Subversion Repositories Kolibri OS

//CODE GENERATION DESCRIPTORS

// =========================

// >>> DESCRIPTION CODES <<<

// =========================

//T_:

//		DB 

//	 [DB ]

//	 [DB ]

//		DB 

//		DB 

//		DB 0

//OR		DB _END //IF THERE'RE NO MORE INFO ABOUT THIS MNEMONIC

// OPERATION SIZE CODES

enum {	_B, //OPERATION MAY BE OF SIZE BYTE,WORD OR DWORD SEIN. THE OPCODE'S

		// W BIT INDICATES IF IT'S A BYTE OR WORD OPERATION.

		// FOR DWORD OPERATIONS, THE W BIT MUST BE TRUE (WORD OPERATION)

		// AND THE RAND:PREFIX MUST BE GENERATED.

	_W, //OPERATION SIZE MAY BE WORD OR DWORD.

	_D, //OPERATION MAY ONLY BE DWORD.

	WB, //1. OPERAND WORD, 2. OPERAND BYTE

	_DW,	//1. OPERAND DWORD, 2. OPERAND WORD

	BW, //1. OPERAND BYTE, 2. OPERAND WORD

	NB, //ONLY BYTE SIZE.

	_OW,	//ONLY WORD SIZE.

	_OD,	// Only DWORD size

	AF};	//ONLY ABSOLUTE FAR 32/48 BIT ADDRESS

#define _JB 1 //OPERAND IS A JUMP - DESTINATION +/-128

#define _JW 2 //OPERAND IS A JUMP - DESTINATION +/-32678

// 0-2	 = OPERATION SIZE CODE

// 3-4	 = # OF OPERANDS NEEDED.

// # OF OPERANDS

#define OL0 0

#define OL1 0o10

#define OL2 0o20

#define OL3 0o30

#define OLBITS		 0o30 //MASKS FOR # OF OPERANDS.

#define NOLBITS 	 0o347

#define TRANSBITS  0o7	//MASKS FOR OPERATION SIZE CODES.

#define NTRANSBITS 0o370

// IF OL1, USE THIS OPERAND TYPES:

#define SOJ 0b00000000	//JUMP

#define SOE 0b00100000	//EA

#define SOR 0b01000000	//REG

#define SOC 0b01100000	//CONST

#define SO3 0b10000000	//_3

#define SOS 0b10100000	//SREG

#define SOM 0b11000000	//EA-MEMORY-POINTER

#define SOO 0b11100000	//THERE IS INFORMATION USING THE OPERAND SIZE CODE BITS.

#define SOO_FS 0o340	//FS-REGISTER

#define SOO_GS 0o341	//GS-REGISTER

#define SOO_AF 0o342	//ABSOLUTE ADRESS

#define SOO_CC 0o343	//SIGNED BYTE

#define OPBITS 0b11100000

// IF OL2, USE THOSE INSTEAD:

//		00000000B  //DIRECT DESCRIPTOR

		//AR,CO

#define ERO  0b00100000 //FIXED EA,REG ORDER

#define REO  0b01000000 //FIXED REG,EA ORDER

#define DER  0b01100000 //EA,REG OR REG,EA DEFINED BY A D-BIT

#define ECO  0b10000000 //EA,CONSTANT// SIZE DEFINED BY W-BIT

#define ECCO 0b10100000 //EA,CC

#define RCO  0b11000000 //REG,CONSTANT// SIZE DEFINED BY W-BIT

#define EAO  0b11100000 //EA,? // SECOND OPERAND DESCRIBED BY OLD DESCIPTORS

			//?=_1,rCL,CO

// OPERAND TYPE CODES

enum {	R,		 //GENERAL REGISTER

	E,		 //EFFEKTIVE ADRESS

	CO, 	 //CONSTANT

	_SR,	 //SEGMENT REGISTER

	SYSR,  //SYSTEM REGISTER

	_DR,	 //DEBUG REGISTER

	_TR,	 //TASK REGISTER

	_CR,	 //CONTROL REGISTER

	_CR4,  //

	_AF,	 //ABSOLUTE 32/48 BIT FAR ADDRESS

	AR=11, //AX/AL REGISTER, INDICATED BY OPERATION SIZE

	_1};	 //CONSTANT VALUE 1

// IF OL3, USE THIS:

// INSTRUCTION WITH THREE OPERANDS ARE ALWAYS OF SIZE WORD.

// THE FOLLOWING CODES DESCRIBE THE 3RD OPERAND.

enum {	CB3,	 //BYTE CONSTANT

	CW3,	 //WORD CONSTANT

	CC3,	 //SBYTE CONSTANT

	CL3};  //CL REGISTER

// OPCODE DESCRIPTORS

enum{ O=1,	 //OPCODE IS A BYTE

	OW, 	 //OPCODE IS A WORD

	OS, 	 //OPCODE IS A BYTE PLUS A SECOND BYTE THAT IS DESCRIBED BY AN

				 //OCTAL STRING.

	S,		 //OCTAL STRING FOLLOWS FOR OPCODE

	XRM,	 //MODRM BYTE

	XPM,	 //MODRM MIT P-FLAG (GRUPPE VON ARITHMETIC INSTRUCTIONS)

	XSM,	 //MODRM MIT SEGMENTREGISTER

	X0M,X1M,X2M,X3M,X4M,X5M,X6M,X7M //MODRM WITH CONSTANT R DIGIT

	};

byte OVERRIDETAB={0o46,0o56,0o66,0o76,0o144,0o145};

// ---- Š®¤¨à®¢ª  ॣ¨áâ஢

enum{ rAL ,rCL ,rDL ,rBL ,rAH ,rCH ,rDH ,rBH, // 0-7	 byte regs

	rAX ,rCX ,rDX ,rBX ,rSP ,rBP ,rSI ,rDI, // 8-15  16-bit word regs

	rEAX,rECX,rEDX,rEBX,rESP,rEBP,rESI,rEDI,// 16-23 32-bit regs

	rCR0,rCR1,rCR2,rCR3,rCR4,rCR5,rCR6,rCR7,// 24-31 control regs

	rDR0,rDR1,rDR2,rDR3,rDR4,rDR5,rDR6,rDR7,// 32-39 debug regs

	rTR0,rTR1,rTR2,rTR3,rTR4,rTR5,rTR6,rTR7,// 40-47 test regs

	rES,rCS,rSS,rDS, rFS,rGS};		// 48-53 seg regs

byte Registers={

	"AL","CL","DL","BL","AH","CH","DH","BH",

	"AX","CX","DX","BX","SP","BP","SI","DI",

	"EAX","ECX","EDX","EBX","ESP","EBP","ESI","EDI",

	"CR0","CR1","CR2","CR3","CR4","CR5","CR6","CR7",

	"DR0","DR1","DR2","DR3","DR4","DR5","DR6","DR7",

	"TR0","TR1","TR2","TR3","TR4","TR5","TR6","TR7",

	"ES","CS","SS","DS","FS","GS",_END};

byte Sizes={"BYTE","WORD","DWORD",_END};

// ---- Ž¯¨á ­¨ï ¬¥­¬®­¨ª

byte PCOMMANDS1={

		0,		//P FLAG STARTS AT 0

		_B+OL2+EAO,AR,CO,S,"0P4",

		_B+OL2+DER,S,'0','P','0',XRM,0,

		_W+OL2+ECCO,O,0o203,XPM,0,

		_B+OL2+ECO,O,0o200,XPM,_END};

byte PCOMMANDS2={

		4,		//P FLAG STARTS AT 4

		_B+OL1+SOE,O,0xF6,XPM,_END};

byte PCOMMANDS3= 0; 	 //P FLAG STARTS AT 0

byte PCOMMANDS3_={

		_B+OL2+EAO,-1,_1,O,0xD0,XPM,0,

		_B+OL2+EAO,-1,rCL,O,0xD2,XPM,0,

		_B+OL2+ECCO,O,0xC0,XPM,_END};

byte PCOMMANDS4={

		4,		//P FLAG STARTS AT 4

		_W+OL2+ERO,OS,0xF,'2','P','3',XRM,0,

		WB+OL2+ECO,OW,0xF,0o272,XPM,_END};

// Ž¤­®¡ ©â®¢ë¥ ¨­áâàãªæ¨¨

byte T_DAA={	O,0o47,_END};

byte T_DAS={	O,0o57,_END};

byte T_AAA={	O,0o67,_END};

byte T_AAD={	OW,0o325,0o12,_END};

byte T_AAM={	OW,0o324,0o12,_END};

byte T_AAS={	O,0o77,_END};

byte T_CWDE={ O,0o230,_END};

byte T_CBW={	OW,0x66,0o230,_END};

byte T_CDQ={	O,0o231,_END};

byte T_CWD={	OW,0x66,0o231,_END};

byte T_XLATB={	O,0o327,_END};

byte T_NOP={	O,0o220,_END};

byte T_WAIT={ O,0o233,_END};

byte T_LOCK={ O,0o360,_END};

byte T_HLT={	O,0o364,_END};

byte T_INTO={ O,0o316,_END};

byte T_IRET={ O,0o317,_END};

byte T_POPFD={	O,0o235,_END};

byte T_POPF={ OW,0x66,0o235,_END};

byte T_PUSHFD={ O,0o234,_END};

byte T_PUSHF={	OW,0x66,0o234,_END};			//PUSHF / (#) PUSHFD

byte T_SAHF={ O,0o236,_END};

byte T_LAHF={ O,0o237,_END};

byte T_CMC={	O,0o365,_END};

byte T_CLC={	O,0o370,_END};

byte T_STC={	O,0o371,_END};

byte T_CLI={	O,0o372,_END};

byte T_STI={	O,0o373,_END};

byte T_CLD={	O,0o374,_END};

byte T_STD={	O,0o375,_END};

byte T_PUSHAD={ O,0o140,_END};

byte T_PUSHA={	OW,0x66,0o140,_END};

byte T_POPAD={	O,0o141,_END};

byte T_POPA={ OW,0x66,0o141,_END};

byte T_INSB={ O,0o154,_END};

byte T_INSW={ OW,0x66,0o155,_END};

byte T_INSD={ O,0o155,_END};

byte T_OUTSB={	O,0o156,_END};

byte T_OUTSW={	OW,0x66,0o157,_END};

byte T_OUTSD={	O,0o157,_END};

byte T_MOVSB={	O,0o244,_END};

byte T_MOVSW={	OW,0x66,0o245,_END};

byte T_MOVSD={	O,0o245,_END};

byte T_CMPSB={	O,0o246,_END};

byte T_CMPSW={	OW,0x66,0o247,_END};

byte T_CMPSD={	O,0o247,_END};

byte T_STOSB={	O,0o252,_END};

byte T_STOSW={	OW,0x66,0o253,_END};

byte T_STOSD={	O,0o253,_END};

byte T_LODSB={	O,0o254,_END};

byte T_LODSW={	OW,0x66,0o255,_END};

byte T_LODSD={	O,0o255,_END};

byte T_SCASB={	O,0o256,_END};

byte T_SCASW={	OW,0x66,0o257,_END};

byte T_SCASD={	O,0o257,_END};

byte T_REP={	O,0o362,_END};

byte T_REPE={ O,0o363,_END};

byte T_RAND={ O,0o146,_END}; //RAND:

byte T_ADDR={ O,0o147,_END}; //ADDR:

byte T_LEAVE={	O,0o311,_END};

byte T_CLTS={ OW,0xF,6,_END};

byte T_INVD={ OW,0xF,0o10,_END};

byte T_WBINVD={ OW,0xF,0o11,_END};

byte T_WRMSR={	OW,0xF,0x30,_END}; //WRMSR WRITE	EDXEAX TO MODEL SPECIFIC REG #ECX

byte T_CPUID={	OW,0xF,0xA2,_END}; //CPUID IF EAX=1 SET EDXEAX TO CPU IDENTIFICATION VALUES

byte T_RDMSR={	OW,0xF,0x32,_END}; //RDMSR READ MODEL SPECIFIC REG #ECX TO EDXEAX

byte T_RDTSC={	OW,0xF,0x31,_END}; //RDTSC READ TIME STAMP COUNTER TO EDXEAX

byte T_RSM={	OW,0xF,0xAA,_END}; //RSM	RESUME FROM SYSTEM MANAGEMENT MODE

//===== INTEL PENTIUM PRO INSTRUCTIONS

byte T_RDPMC={	OW,0xF,0x33,_END};	//READ PERFORMANCE MONITORING COUNTERS

byte T_UD2={	OW,0xF,0xB,_END}; 		 //UNDEFINED INSTRUCTION EXCEPTION

byte T_EMMX={ OW,0xF,0x77,_END};	//EMPTY MMX STATE

byte T_SALC={ O,0xD6,_END};

byte T_ICEBP={	O,0xF1,_END};

byte T_PSHIMW={ OW,0xF,0x71,_END};

byte T_PSHIMD={ OW,0xF,0x72,_END};

byte T_PSHIMQ={ OW,0xF,0x73,_END};

byte T_NOT={	_B+OL1+SOE,O,0xF6,X2M,_END};

byte T_NEG={	_B+OL1+SOE,O,0xF6,X3M,_END};

byte T_INC={	_W+OL1+SOR,S,"10R",

		_B+OL1+SOE,O,0xFE,X0M,_END};

byte T_DEC={	_W+OL1+SOR,S,"11R",

		_B+OL1+SOE,O,0xFE,X1M,_END};

byte T_TEST={ _B+OL2+ERO,O,0o204,XRM,0, //ALPHA:WAS 204O

		_B+OL2+REO,O,0o204,XRM,0, //"

		_B+OL2+EAO,AR,CO,O,0o250,0,

		_B+OL2+ECO,O,0xF6,X0M,_END};

// EXTENDED 386 INTEGER MULTIPLICATION

byte T_IMUL={ _B+OL1+SOE,O,0xF6,X5M,0,			//IMUL EB

		_B+OL2+ECO,O,0xC0,X1M,0,

		_B+OL2+EAO,-1,_1,O,0xD0,X1M,0,

		_B+OL2+EAO,-1,rCL,O,0xD2,X1M,0,

		_W+OL1+REO,OW,0xF,0o257,XRM,0,	//IMUL RW, EW

		OL3+REO+CC3,O,0o153,XRM,0,	//IMUL RW, EW, DC

		OL3+REO+CW3,O,0o151,XRM,_END};	//IMUL RW, EW, DW

byte T_SHLD={ OL3+ERO+CB3,OW,0xF,0o244,XRM,0,

		OL3+ERO+CL3,OW,0xF,0o245,XRM,_END};

byte T_SHRD={ OL3+ERO+CB3,OW,0xF,0o254,XRM,0,

		OL3+ERO+CL3,OW,0xF,0o255,XRM,_END};

byte T_MOVSX={	WB+OL2+REO,OW,0xF,0o276,XRM,0,

		_DW+OL2+REO,OW,0xF,0o277,XRM,_END};

byte T_MOVZX={	WB+OL2+REO,OW,0xF,0o266,XRM,0,

		_DW+OL2+REO,OW,0xF,0o267,XRM,_END};

byte T_BSWAP={	_D+OL1+SOR,OS,0xF,"31R",_END};

byte T_BSF={	_W+OL2+REO,OW,0xF,0o274,XRM,_END};

byte T_BSR={	_W+OL2+REO,OW,0xF,0o275,XRM,_END};

byte T_CMPXCHG={_B+OL2+ERO,OW,0xF,0xB0,XRM,_END};

byte T_CMPXCHG486={_B+OL2+ERO,OW,0xF,0xA7,XRM,_END};

byte T_CMPXCHG8B={_B+OL2+ERO,OW,0xF,0xC7,XRM,_END};

byte T_XADD={ _B+OL2+ERO,OW,0xF,0xC0,XRM,_END};

byte T_XCHG={ _W+OL2+EAO,-1,AR,S,"22M", //ALPHA:WAS "22R" BUT GENERATED NOP

		_W+OL2+EAO,AR,-1,S,"22R",

		_B+OL2+REO,O,0o206,XRM,0,

		_B+OL2+ERO,O,0o206,XRM,_END};

byte T_MOV=0; 	 //DUMMY BYTE

byte T_LEA={	_D+OL2+REO,O,0o215,XRM,_END}; 	//LEA RW, EN	(X != 3)

byte T_LSS={	_D+OL2+REO,OW,0xF,0o262,XRM,_END};//LSS RW, EF	(X != 3)

byte T_LFS={	_D+OL2+REO,OW,0xF,0o264,XRM,_END};//LFS RW, EF	(X != 3)

byte T_LGS={	_D+OL2+REO,OW,0xF,0o265,XRM,_END};//LGS RW, EF	(X != 3)

byte T_LES={	_D+OL2+REO,O,0o304,XRM,_END}; 	//LES RW, EF	(X != 3)

byte T_LDS={	_D+OL2+REO,O,0o305,XRM,_END}; 	//LDS RW, EF	(X != 3)

byte T_SET0={ NB+OL1+SOE,OW,0xF,0o220,X0M,_END};

byte T_SET1={ NB+OL1+SOE,OW,0xF,0o221,X0M,_END};

byte T_SET2={ NB+OL1+SOE,OW,0xF,0o222,X0M,_END};

byte T_SET3={ NB+OL1+SOE,OW,0xF,0o223,X0M,_END};

byte T_SET4={ NB+OL1+SOE,OW,0xF,0o224,X0M,_END};

byte T_SET5={ NB+OL1+SOE,OW,0xF,0o225,X0M,_END};

byte T_SET6={ NB+OL1+SOE,OW,0xF,0o226,X0M,_END};

byte T_SET7={ NB+OL1+SOE,OW,0xF,0o227,X0M,_END};

byte T_SET8={ NB+OL1+SOE,OW,0xF,0o230,X0M,_END};

byte T_SET9={ NB+OL1+SOE,OW,0xF,0o231,X0M,_END};

byte T_SETA={ NB+OL1+SOE,OW,0xF,0o232,X0M,_END};

byte T_SETB={ NB+OL1+SOE,OW,0xF,0o233,X0M,_END};

byte T_SETC={ NB+OL1+SOE,OW,0xF,0o234,X0M,_END};

byte T_SETD={ NB+OL1+SOE,OW,0xF,0o235,X0M,_END};

byte T_SETE={ NB+OL1+SOE,OW,0xF,0o236,X0M,_END};

byte T_SETF={ NB+OL1+SOE,OW,0xF,0o237,X0M,_END};

//

byte T_JCXZ={ OL1,_JB,O,0o343,_END};

byte T_LOOPNZ={ OL1,_JB,O,0o340,_END};

byte T_LOOPZ={	OL1,_JB,O,0o341,_END};

byte T_LOOP={ OL1,_JB,O,0o342,_END};

byte T_J0={ OL1,_JB,O,0o160,0,

		OL1,_JW,6,OW,0o17,0o200,_END};

byte T_J1={ OL1,_JB,O,0o161,0,

		OL1,_JW,6,OW,0o17,0o201,_END};

byte T_J2={ OL1,_JB,O,0o162,0,

		OL1,_JW,6,OW,0o17,0o202,_END};

byte T_J3={ OL1,_JB,O,0o163,0,

		OL1,_JW,6,OW,0o17,0o203,_END};

byte T_J4={ OL1,_JB,O,0o164,0,

		OL1,_JW,6,OW,0o17,0o204,_END};

byte T_J5={ OL1,_JB,O,0o165,0,

		OL1,_JW,6,OW,0o17,0o205,_END};

byte T_J6={ OL1,_JB,O,0o166,0,

		OL1,_JW,6,OW,0o17,0o206,_END};

byte T_J7={ OL1,_JB,O,0o167,0,

		OL1,_JW,6,OW,0o17,0o207,_END};

byte T_J8={ OL1,_JB,O,0o170,0,

		OL1,_JW,6,OW,0o17,0o210,_END};

byte T_J9={ OL1,_JB,O,0o171,0,

		OL1,_JW,6,OW,0o17,0o211,_END};

byte T_JA={ OL1,_JB,O,0o172,0,

		OL1,_JW,6,OW,0o17,0o212,_END};

byte T_JB={ OL1,_JB,O,0o173,0,

		OL1,_JW,6,OW,0o17,0o213,_END};

byte T_JC={ OL1,_JB,O,0o174,0,

		OL1,_JW,6,OW,0o17,0o214,_END};

byte T_JD={ OL1,_JB,O,0o175,0,

		OL1,_JW,6,OW,0o17,0o215,_END};

byte T_JE={ OL1,_JB,O,0o176,0,

		OL1,_JW,6,OW,0o17,0o216,_END};

byte T_JF={ OL1,_JB,O,0o177,0,

		OL1,_JW,6,OW,0o17,0o217,_END};

byte T_JMP={	OL1,_JB,O,0o353,0,	//JMP SHORT CB

		OL1,_JW,5,O,0o351,0,	//JMP NEAR CW

		_OW+OL1+SOE,O,0o377,X4M,0}; // JMP NEAR EN

byte T_JMPFAR={ _D+OL1+SOE,O,0o377,X5M,0, // JMP FAR EF

		OL1+SOO_AF,O,0o352,_END}; //JMP FAR AF

byte T_JMPSHORT={

		OL1,_JB,O,0o353,_END};			 //JMP SHORT CB

byte T_JMPNEAR={OL1,_JW,5,O,0o351,0,			//JMP NEAR CW

		_OW+OL1+SOE,O,0o377,X4M,_END}; // JMP NEAR EN

byte T_CALL={ OL1,_JW,5,O,0o350,0,			//CALL CW

		_OW+OL1+SOE,O,0o377,X2M,0}; 	 //CALL EN

byte T_CALLFAR={

		OL1+SOO_AF,O,0o232,0,  //CALL AF

		_D+OL1+SOE,O,0o377,X3M,_END}; //CALL FAR EF

byte T_RETF={ 0,O,0o313,0,		 //RETF/RET FAR

		_OW+OL1+SOC,O,0o312,_END}; //RETF DW/RET FAR DW

byte T_ENTER={	WB+OL2+EAO,CO,CO,O,0o310,_END};

byte T_BOUND={	_W+OL2+REO,O,0o142,XRM,_END}; 		//BOUND RW, ED

/*byte T_INT={	NB+OL1+SO3,O,0o314,0, // !!! No interrupts in Win32

		NB+OL1+SOC,O,0o315,_END};*/

byte T_IN={ NB+OL2+EAO,AR,CO,O,0o344,0, 		 //IN AL, DB

		WB+OL2+EAO,AR,CO,O,0o345,0, 		 //IN AX,CO

		_B+OL2+EAO,AR,rDX,O,0o354,0,			 //IN AL,DX

		_OW+OL2+EAO,AR,rDX,O,0o355,_END}; //IN AX, DX

byte T_OUT={	NB+OL2+EAO,CO,AR,O,0o346,0, 		 //OUT DB, AL

		BW+OL2+EAO,CO,AR,O,0o347,0, 		 //OUT DB, AX

		WB+OL2+EAO,rDX,AR,O,0o356,0,			 //OUT DX, AL

		_OW+OL2+EAO,rDX,AR,O,0o357,_END}; //OUT DX, AX

byte T_PUSH={ OL1+SOO_CC,O,0o152,0,

		_D+OL1+SOR,S,"12R",

		_D+OL1+SOE,O,0o377,X6M,0,

		_D+OL1+SOC,O,0o150,0,

		OL1+SOO_FS,OW,0xF,0o240,0,

		OL1+SOO_GS,OW,0xF,0o250,0,

		_OW+OL1+SOS,S,"0S6", //WIEDER ANS ENDE PACKEN

		_END};

byte T_RET={	_OW+OL1+SOC,O,0o302,0, //RET DW

		O,0o303,0,_END};	//RET

byte T_POP={	_D+OL1+SOR,S,"13R",

		_D+OL1+SOE,O,0o217,X0M,0,

		OL1+SOO_FS,OW,0xF,0o241,0,

		OL1+SOO_GS,OW,0xF,0o251,0,

		_OW+OL1+SOS,S,"0S7",_END};

byte T_ARPL={ _W+OL2+ERO,O,0o143,XRM,_END}; //ARPL ES, RW

byte T_SLDT={ _OW+OL1+SOE,OW,0xF,0,X0M,_END}; 	//SLDT EW

byte T_STR={	_OW+OL1+SOE,OW,0xF,0,X1M,_END}; 	//STR EW

byte T_LLDT={ _OW+OL1+SOE,OW,0xF,0,X2M,_END}; 	//LLDT EW

byte T_LTR={	_OW+OL1+SOE,OW,0xF,0,X3M,_END}; 	//LTR EW

byte T_VERR={ _OW+OL1+SOE,OW,0xF,0,X4M,_END}; 	//VERR EW

byte T_VERW={ _OW+OL1+SOE,OW,0xF,0,X5M,_END}; 	//VERW EW

byte T_LAR={	_OW+OL1+REO,OW,0xF,2,XRM,_END}; 	//LAR RW, EW

byte T_LSL={	_OW+OL1+REO,OW,0xF,3,XRM,_END}; 	//LSL RW, EW

byte T_SGDT={ _OW+OL1+SOM,OW,0xF,1,X0M,_END}; 	//SGDT EP

byte T_SIDT={ _OW+OL1+SOM,OW,0xF,1,X1M,_END}; 	//SIDT EP

byte T_LGDT={ _OW+OL1+SOM,OW,0xF,1,X2M,_END}; 	//LGDT EP

byte T_LIDT={ _OW+OL1+SOM,OW,0xF,1,X3M,_END}; 	//LIDT EP

byte T_SMSW={ _OW+OL1+SOE,OW,0xF,1,X4M,_END}; 	//SMSW EW

byte T_LMSW={ _OW+OL1+SOE,OW,0xF,1,X6M,_END}; 	//LMSW EW

//===== X486 INSTRUCTIONS

byte T_INVLPD={ _OW+OL1+SOM,OW,0xF,0o20,X7M,_END};	//INVLPG EA

//===== INTEL PENTIUM INSTRUCTIONS

byte T_CMPX8={	_OW+OL1+SOE,OW,0xF,0xC7,X1M,_END}; //CMPX8 EW 5 IF EDXEAX=MQ THEN MQ:=ECXEBX, ELSE EAXEDX:=MQ

byte T_CMOV={ _W+OL2,REO,OW,0xF,0x40,XRM,_END};

//===== MMX INSTRUCTIONS

byte T_EMMS={ _END};

byte T_UMOV={ _B+OL2,DER,OW,0xF,0x10,XRM,_END};

#define _Q 1

#define MMXE 1

#define MMXP 1

#define MMXPI 1

#define MMXPE 1

#define MMXEP 1

byte T_PUNPCKLBW={	_D+OL2,MMXE,OW,0xF,0x60,_END};

byte T_PUNPCKLWD={	_D+OL2,MMXE,OW,0xF,0x61,_END};

byte T_PUNPCKLDQ={	_D+OL2,MMXE,OW,0xF,0x62,_END};

byte T_PACKSSWB={ _Q+OL2,MMXE,OW,0xF,0x63,_END};

byte T_PCMPGTB={	_Q+OL2,MMXE,OW,0xF,0x64,_END};

byte T_PCMPGTW={	_Q+OL2,MMXE,OW,0xF,0x65,_END};

byte T_PCMPGTD={	_Q+OL2,MMXE,OW,0xF,0x66,_END};

byte T_PACKUSWB={ _Q+OL2,MMXE,OW,0xF,0x67,_END};

byte T_PCMPEQB={	_Q+OL2,MMXE,OW,0xF,0x74,_END};

byte T_PCMPEQW={	_Q+OL2,MMXE,OW,0xF,0x75,_END};

byte T_PCMPEQD={	_Q+OL2,MMXE,OW,0xF,0x76,_END};

byte T_PSRLW={		_Q+OL2,MMXE,OW,0xF,0xD1,_END};

byte T_PSRLD={		_Q+OL2,MMXE,OW,0xF,0xD2,_END};

byte T_PSRLQ={		_Q+OL2,MMXE,OW,0xF,0xD3,_END};

byte T_PMULLW={ 	_Q+OL2,MMXE,OW,0xF,0xD5,_END};

byte T_PSRAW={		_Q+OL2,MMXE,OW,0xF,0xE1,_END};

byte T_PSRAD={		_Q+OL2,MMXE,OW,0xF,0xE2,_END};

byte T_PMULHW={ 	_Q+OL2,MMXE,OW,0xF,0xE5,_END};

byte T_PSLLW={		_Q+OL2,MMXE,OW,0xF,0xF1,_END};

byte T_PSLLD={		_Q+OL2,MMXE,OW,0xF,0xF2,_END};

byte T_PSLLQ={		_Q+OL2,MMXE,OW,0xF,0xF3,_END};

byte T_PMADDWD={	_Q+OL2,MMXE,OW,0xF,0xF5,_END};

byte T_PUNPCKHBW={	_Q+OL2,MMXE,OW,0xF,0x68,_END};

byte T_PUNPCKHWD={	_Q+OL2,MMXE,OW,0xF,0x69,_END};

byte T_PUNPCKHDQ={	_Q+OL2,MMXE,OW,0xF,0x6A,_END};

byte T_PACKSSDW={ _Q+OL2,MMXE,OW,0xF, 0x6B,_END};

byte T_MOVD={ 	_D+OL2,MMXPE,OW,0xF,0x6E,0,

			_Q+OL2,MMXEP,OW,0xF,0x7E,_END};

byte T_MOVQ={ 	_Q+OL2,MMXE,OW,0xF,0x6F,0,

			_Q+OL2,MMXE,OW,0xF,0x7F,_END};

byte T_PSUBUSB={	_Q+OL2,MMXE,OW,0xF,0xD8,_END};

byte T_PSUBUSW={	_Q+OL2,MMXE,OW,0xF,0xD9,_END};

byte T_PAND={ 	_Q+OL2,MMXE,OW,0xF,0xDB,_END};

byte T_PADDUSB={	_Q+OL2,MMXE,OW,0xF,0xDC,_END};

byte T_PADDUSW={	_Q+OL2,MMXE,OW,0xF,0xDD,_END};

byte T_PANDN={		_Q+OL2,MMXE,OW,0xF,0xDF,_END};

byte T_PSUBSB={ 	_Q+OL2,MMXE,OW,0xF,0xE8,_END};

byte T_PSUBSW={ 	_D+OL2,MMXE,OW,0xF,0xE9,_END};

byte T_POR={		_Q+OL2,MMXE,OW,0xF,0xEB,_END};

byte T_PADDSB={ 	_Q+OL2,MMXE,OW,0xF,0xEC,_END};

byte T_PADDSW={ 	_Q+OL2,MMXE,OW,0xF,0xED,_END};

byte T_PXOR={ 	_Q+OL2,MMXE,OW,0xF,0xEF,_END};

byte T_PSUBB={		_Q+OL2,MMXE,OW,0xF,0xF8,_END};

byte T_PSUBW={		_Q+OL2,MMXE,OW,0xF,0xF9,_END};

byte T_PSUBD={		_Q+OL2,MMXE,OW,0xF,0xFA,_END};

byte T_PADDB={		_Q+OL2,MMXE,OW,0xF,0xFC,_END};

byte T_PADDW={		_Q+OL2,MMXE,OW,0xF,0xFD,_END};

byte T_PADDD={		_Q+OL2,MMXE,OW,0xF,0xFE,_END};

byte T_PSRL={ 	_Q+OL2,MMXPI,OW,0xF,_END};

byte T_PSRA={ 	_Q+OL2,MMXPI,OW,0xF,_END};

byte T_PSLL={ 	_Q+OL2,MMXE,OW,0xF,_END};

byte Mnemonics={

// FIRST OF ALL THE COMMANDS WITH A P-FLAG. THIS"LL MAKE THINGS EASIER FOR

// COMPARISON IN THE PARSE ENGINE

	//P1=0-7

	"ADD","OR","ADC","SBB/BC","AND","SUB","XOR","CMP",

	//P2=4-7

	"MUL","-","DIV","IDIV",

	//			IMUL ENTFERNT

	//P3=0-5/7

	"ROL","ROR","RCL","RCR","SHL/AL","SHR","-","SAR",

	//P4=4-7

	"BT","BTS","BTR","BTC",

	// USUAL COMMANDS

	"NOT","NEG","INC","DEC","TEST", "IMUL","SHLD","SHRD",

	"DAA","DAS","AAA","AAS","AAM","AAD",

	"MOVSX","MOVZX","CBW","CWDE","CWD","CDQ",

	"BSWAP","XLAT/LATB","BSF","BSR",

	"CMPXCHG","CMPXCHG486","CMPXCHG8B","XADD",

	"NOP","WAIT","LOCK","HLT",	//"INT",

	"INTO","IRET",

	"POPF","POPFD","PUSHF","PUSHFD","SAHF","LAHF",

	"CMC","CLC","STC","CLI","STI","CLD","STD",

	"PUSH","PUSHA","PUSHAD","POP","POPA","POPAD",

	"XCHG","MOV","LEA","LSS","LFS","LGS","LES","LDS",

	"ADDR","RAND",

	"IN","OUT","INSB","INSW","INSD","OUTSB","OUTSW","OUTSD",

	"MOVSB","MOVSW","MOVSD","CMPSB","CMPSW","CMPSD",

	"STOSB","STOSW","STOSD","LODSB","LODSW","LODSD",

	"SCASB","SCASW","SCASD","REP/EPNE/EPNZ","REPE/EPZ",

	"JCXZ/ECXZ","LOOP","LOOPZ/OOPE","LOOPNZ/OOPNE",

	"JO","JNO","JC/B/NAE","JNC/AE/NB",

	"JE/Z","JNE/NZ","JBE/NA","JA/NBE",

	"JS","JNS","JP/PE","JNP/PO","JL/NGE","JGE/NL",

	"JLE/NG","JG/NLE",

	"SETO","SETNO","SETC/ETB/ETNAE","SETNC/ETAE/ETNB",

	"SETE/ETZ","SETNE/ETNZ","SETBE/ETNA","SETA/ETNBE",

	"SETS","SETNS","SETP/ETPE","SETNP/ETPO","SETL/ETNGE","SETGE/ETNL",

	"SETLE/ETNG","SETG/ETNLE",

	"JMPS","JMPN","JMPF","JMP",

	"CALL","CALLF","RET","RETF",

	"ENTER","LEAVE","BOUND","ARPL",

	"SLDT","STR","LLDT","LTR","VERR","VERW","LAR","LSL",

	"SGDT","SIDT","LGDT","LIDT","SMSW","LMSW","CLTS",

	"INVD","WBINVD","INVLPD",

	//INTEL PENTIUM COMMANDS

	"WRMSR","CMPX8/MPXCHG8B","CPUID","RDMSR","RDTSC","RSM",

	//INTEL PENTIUM PRO INSTRUCTIONS

	"RDPMC","UD2","EMMX","SETALC",

	//MMX INSTRUCTIONS

	"MOVD","MOVQ",			 //MOVE MMX REG

	"PACKUS/PACKUSWB",			 //PACK MMX REG WITH UNSIGNED SATURATION

	"PACKSSWB","PACKSSDW",		 //PACK MMX REG WITH SIGNED SATURATION

	"PUNPCKHBW","PUNPCKHWD",

	"PUNPCKHDQ",		 //UNPACK HIGH ORDER

	"PUNPCKLBW","PUNPCKLWD",

	"PUNPCKLDQ", //UNPACK LOW ORDER

	"PADDB","PADDW","PADDD", //ADD MMX REG WITH WRAP-AROUND

	"PADDSB","PADDSW",		 //" WITH SIGNED SATURATION

	"PADDUSB","PADDUSW",		 //" WITH UNSIGNED SATURATION

	"PSUBB","PSUBW","PSUBD", //SUBTRACT MMX REG

	"PSUBSB","PSUBSW","PSUBUSB","PSUBUSW",

	"PMULH/PMULHW","PMULL/PMULLW","PMADD/PMADDWD",

	"PSLLW","PSLLD","PSLLQ","PSRLW","PSRLD","PSRLQ",

	"PSRAW","PSRAD","PCMPEQB","PCMPEQW","PCMPEQD",

	"PCMPGTB","PCMPGTW","PCMPGTD","PAND","PANDN","POR","PXOR","EMMS",_END};

dword TAB_MNEMONICS={

	#T_NOT,#T_NEG,#T_INC,#T_DEC,#T_TEST,

	#T_IMUL,#T_SHLD,#T_SHRD,

	#T_DAA,#T_DAS,#T_AAA,#T_AAS,#T_AAM,#T_AAD,

	#T_MOVSX,#T_MOVZX,#T_CBW,#T_CWDE,#T_CWD,#T_CDQ,

	#T_BSWAP,#T_XLATB,

	#T_BSF,#T_BSR,#T_CMPXCHG,#T_CMPXCHG486,#T_CMPXCHG8B,#T_XADD,

	#T_NOP,#T_WAIT,#T_LOCK,#T_HLT,

//	#T_INT,

	#T_INTO,#T_IRET,

	#T_POPF,#T_POPFD,#T_PUSHF,#T_PUSHFD,

	#T_SAHF,#T_LAHF,

	#T_CMC,#T_CLC,#T_STC,#T_CLI,#T_STI,#T_CLD,#T_STD,

	#T_PUSH,#T_PUSHA,#T_PUSHAD,

	#T_POP,#T_POPA,#T_POPAD,

	#T_XCHG,#T_MOV,

	#T_LEA,#T_LSS,#T_LFS,#T_LGS,#T_LES,#T_LDS,

	#T_ADDR,#T_RAND,

	#T_IN,#T_OUT,

	#T_INSB,#T_INSW,#T_INSD,

	#T_OUTSB,#T_OUTSW,#T_OUTSD,

	#T_MOVSB,#T_MOVSW,#T_MOVSD,

	#T_CMPSB,#T_CMPSW,#T_CMPSD,

	#T_STOSB,#T_STOSW,#T_STOSD,

	#T_LODSB,#T_LODSW,#T_LODSD,

	#T_SCASB,#T_SCASW,#T_SCASD,

	#T_REP,

	#T_REPE,

	#T_JCXZ,#T_LOOP,#T_LOOPZ,#T_LOOPNZ,

	#T_J0,#T_J1,#T_J2,#T_J3,

	#T_J4,#T_J5,#T_J6,#T_J7,

	#T_J8,#T_J9,#T_JA,#T_JB,

	#T_JC,#T_JD,#T_JE,#T_JF,

	#T_SET0,#T_SET1,#T_SET2,#T_SET3,

	#T_SET4,#T_SET5,#T_SET6,#T_SET7,

	#T_SET8,#T_SET9,#T_SETA,#T_SETB,

	#T_SETC,#T_SETD,#T_SETE,#T_SETF,

	#T_JMPSHORT,#T_JMPNEAR,#T_JMPFAR,#T_JMP,

	#T_CALL,#T_CALLFAR,

	#T_RET,#T_RETF,

	#T_ENTER,#T_LEAVE,

	#T_BOUND,#T_ARPL,

	#T_SLDT,#T_STR,#T_LLDT,#T_LTR,#T_VERR,#T_VERW,

	#T_LAR,#T_LSL,

	#T_SGDT,#T_SIDT,#T_LGDT,#T_LIDT,

	#T_SMSW,#T_LMSW,#T_CLTS,

	#T_INVD,#T_WBINVD,#T_INVLPD,

//INTEL PENTIUM INSTRUCTIONS

	#T_WRMSR,#T_CMPX8,#T_CPUID,#T_RDMSR,#T_RDTSC,#T_RSM,

//INTEL PENTIUM PRO INSTRUCTIONS

	#T_RDPMC,#T_UD2,#T_EMMX,#T_SALC,

//MMX INSTRUCTIONS

	#T_MOVD,#T_MOVQ,		//MOVE MMX REG

	#T_PACKUSWB,					 //PACK MMX REG WITH UNSIGNED SATURATION

	#T_PACKSSWB,#T_PACKSSDW,	//PACK MMX REG WITH SIGNED SATURATION

	#T_PUNPCKHBW,#T_PUNPCKHWD,#T_PUNPCKHDQ, //UNPACK HIGH ORDER

	#T_PUNPCKLBW,#T_PUNPCKLWD,#T_PUNPCKLDQ, //UNPACK LOW ORDER

	#T_PADDB,#T_PADDW,#T_PADDD,  //ADD MMX REG WITH WRAP-AROUND

	#T_PADDSB,#T_PADDSW,		//" WITH SIGNED SATURATION

	#T_PADDUSB,#T_PADDUSW,		//" WITH UNSIGNED SATURATION

	#T_PSUBB,#T_PSUBW,#T_PSUBD,  //SUBTRACT MMX REG

	#T_PSUBSB,#T_PSUBSW,

	#T_PSUBUSB,#T_PSUBUSW,

	#T_PMULHW,

	#T_PMULLW,

	#T_PMADDWD,

	#T_PSLLW,#T_PSLLD,#T_PSLLQ,

	#T_PSRLW,#T_PSRLD,#T_PSRLQ,

	#T_PSRAW,#T_PSRAD,

	#T_PCMPEQB,#T_PCMPEQW,#T_PCMPEQD,

	#T_PCMPGTB,#T_PCMPGTW,#T_PCMPGTD,

	#T_PAND,

	#T_PANDN,

	#T_POR,

	#T_PXOR,

	#T_EMMS};