]> pd.if.org Git - mmurtl/blob - dasm/source/dasm.h
autocommit for file dated 1995-02-09 16:00:32
[mmurtl] / dasm / source / dasm.h
1 /* 386 D-Group ASSEMBLER.  Header file.\r
2    Copyright 1992 R.A. Burgess\r
3 */\r
4 \r
5  /* The DASM parser returns a TOKEN type and fills in certain\r
6    global variables with the values found.  The token type is\r
7    placed in Token as well as being returned to the caller.\r
8 */\r
9 \r
10 /* The following are the TOKEN types returned by the parser or\r
11    the expression analyzer :\r
12 */\r
13 \r
14 #define ZERO    0       /* Parser returned NOTHING (blank or EOL) */\r
15 #define INSTRU  1       /* 386 instruction. Number placed in TInst. */\r
16 #define REGIST  2       /* 386 register is placed in TReg */\r
17 #define SYMBOL  3       /* In symbol table. Sym number placed in TSymnum */\r
18 #define LSYMBOL 4       /* In symbol table. LSym number placed in TSymnum */\r
19 #define STRING  5       /* 'quoted' string of characters left in TString */\r
20 #define NUMBER  6       /* Valid value placed in TNumber */\r
21 #define NUMOFF  7       /* Valid TNumber derived from OFFSET (needs fix) */\r
22 #define UNKSYM  8       /* Qualifies as a sym but not found. Left in TString */\r
23 #define SYMOFF  9   /* Symbol offset value (from Expression analyzer) */\r
24 #define ERROR   10      /* Bad char found in line. Line terminated by Parse(). */\r
25 \r
26 /* alphabetized list of reserved words excluding registers and\r
27    instructions.  They must be alphabetized for binary search\r
28    function to work. They begin with #89 so they don't conflict\r
29    with other token values. */\r
30 \r
31 #define nreserved 30\r
32 #define srsvd 8                 /* size of a reserved storage */\r
33 #define nrsvd1 94               /* must be the first number of rgReserved */\r
34 char rgReserved[nreserved][srsvd]  = {          /* 109 bytes */\r
35          "ALIGN",     /*  94 */\r
36          "BYTE",      /*  95 */\r
37          "CODE",      /*  96 */\r
38          "DATA",      /*  97 */\r
39          "DB",        /*  98 */\r
40          "DD",        /*  99 */\r
41          "DF",        /* 100 */\r
42          "DUP",       /* 101 */\r
43          "DW",        /* 102 */\r
44          "DWORD",     /* 103 */\r
45              "END",       /* 104 */\r
46          "EQU",       /* 105 */\r
47          "EXTRN",     /* 106 */\r
48          "FAR",       /* 107 */\r
49          "FWORD",     /* 108 */\r
50          "INCLUDE",   /* 109 */\r
51          "NAME",      /* 110 */\r
52          "NEAR",      /* 111 */\r
53          "OFFSET",    /* 112 */\r
54          "PARA",      /* 113 */\r
55          "PTR",       /* 114 */\r
56                  "PUBLIC",    /* 115 */\r
57          "SEARCH",    /* 116 */\r
58          "SHORT",     /* 117 */\r
59          "STACK",     /* 118 */\r
60          "START",     /* 119 */\r
61          "USE16",     /* 120 */\r
62          "USE32",     /* 121 */\r
63          "VIRTUAL",   /* 122 */\r
64          "WORD",      /* 123  up to 127 MAX */\r
65          };\r
66 \r
67 /* The following reserved "words" are recognized by Parse.\r
68    This list MUST agree with the numbering of the table\r
69    rgReserved above.\r
70 */\r
71 \r
72 #define  rALIGN         94      /* .ALIGN n - Align code segment   */\r
73 #define  rBYTE          95      /* for forcing types on operands   */\r
74 #define  rCODE          96      /* .CODE - begin/continue code segment   */\r
75 #define  rDATA          97      /* .DATA - begin/continue data segment   */\r
76 #define  rDB            98      /* storage of byte(s) or (strings) */\r
77 #define  rDD            99      /* double words */\r
78 #define  rDF            100 /* FWord (OFF:SEL) */\r
79 #define  rDUP           101     /* duplicated storage of DB, DW or DD */\r
80 #define  rDW            102     /* storage of words follows */\r
81 #define  rDWORD         103     /* for forcing types on operands */\r
82 #define  rEND           104     /* .END - file end - no more segments    */\r
83 #define  rEQU           105     /* EQUATE for numbers/addresses only */\r
84 #define  rEXTRN     106  /* for EXTERNAL definition */\r
85 #define  rFAR           107     /* FAR operator for calls */\r
86 #define  rFWORD         108     /* for forcing types on operands */\r
87 #define  rINCLUDE       109     /* .INCLUDE - Include file for assembly  */\r
88 #define  rNAME          110     /* .NAME to name a segment */\r
89 #define  rNEAR          111     /* NEAR operator for calls (default) */\r
90 #define  rOFFSET        112     /* offset in segment of ... */\r
91 #define  rPARA          113     /* PTR operator for mem ops */\r
92 #define  rPTR           114     /* PTR operator for mem ops */\r
93 #define  rPUBLIC    115 /* for PUBLIC declarations */\r
94 #define  rSEARCH        116     /* SEARCH command for Lib files  */\r
95 #define  rSHORT         117     /* SHORT operator for relative jumps   */\r
96 #define  rSTACK         118     /* .START - Entry point for execution    */\r
97 #define  rSTART         119     /* .STACK - Sets initial stack size   */\r
98 #define  rUSE16     120 /* .USE16 (16 bit segment) */\r
99 #define  rUSE32     121 /* .USE16 (16 bit segment) */\r
100 #define  rVIRTUAL       122 /* .VIRTUAL n - Data @ virtual address n */\r
101 #define  rWORD          123 /*  WORD operator for mem ops */\r
102 \r
103 /* Special characters. They are treated as reserved words but are\r
104    not searched alphabetically.  They must maintain their ASCII\r
105    values (other tokens are numbers "around" them).\r
106 */\r
107 \r
108 #define  DOLLAR         0x24   /* 36 */\r
109 #define  SQUOTE         0x27   /* 39 */\r
110 #define  OPENRND        0x28   /* 40 */\r
111 #define  CLOSRND        0x29   /* 41 */\r
112 #define  STAR           0x2a   /* 42 */\r
113 #define  PLUS           0x2b   /* 43 */\r
114 #define  COMMA          0x2c   /* 44 */\r
115 #define  MINUS          0x2d   /* 45 */\r
116 #define  DOT            0x2e   /* 46 */\r
117 #define  SLASH          0x2f   /* 47 */\r
118 #define  COLON          0x3a   /* 58 */\r
119 #define  SEMI           0x3b   /* 59 */\r
120 #define  OPENSQR        0x5b   /* 91 */\r
121 #define  CLOSSQR        0x5d   /* 93 */\r
122 \r
123 /* The following bits identify symbol types in GST & LST */\r
124 \r
125 #define CLABEL  0x0001  /* Code label - SymPtr has Offset in Code seg */\r
126 #define DLABEL  0x0002  /* Data label - SymPtr has Offset in Data seg */\r
127 #define MACRO   0x0004  /* No offset associated -  pts to string */\r
128 #define sBYTE   0x0008  /* Data label for BYTE (8 bit)   */\r
129 #define sWORD   0x0010  /* Data label for WORD (16 bit)  */\r
130 #define sDWORD  0x0020  /* Data label for DWORD (32 bit) */\r
131 #define sFWORD  0x0040  /* Data label for FWORD (48 bit) */\r
132 #define tEXTRN  0x0080  /* Defined External, Public not found yet */\r
133 #define tFAR    0x0100  /* Defined as FAR, default is near */\r
134 #define tPUBLIC 0x0200  /* Defined as PUBLIC */\r
135 \r
136 \r
137 /* This is an alphabetical array of all the 386 registers.\r
138    It it used for a binary search for a register name. If\r
139    the beginning number (128) is changed here you must make\r
140    sure to change the define nreg1 to match to the search\r
141    routine will give you the correct number They start at 128\r
142    so they don't conflict with operand types in instruction table\r
143    rgINS[].\r
144 */\r
145 \r
146 #define nregs 52\r
147 #define sregs 4\r
148 #define nreg1 128\r
149 \r
150 char rgreg[nregs][4]  = {               /* 176 bytes */\r
151 \r
152       "AH",    /* 128 */\r
153       "AL",    /* 129 */\r
154       "AX",    /* 130 */\r
155           "BH",    /* 131 */\r
156           "BL",    /* 132 */\r
157           "BP",    /* 133 */\r
158           "BX",    /* 134 */\r
159           "CH",    /* 135 */\r
160           "CL",    /* 136 */\r
161           "CR0",   /* 137 */\r
162           "CR1",   /* 138 */\r
163           "CR2",   /* 139 */\r
164       "CR3",   /* 140 */\r
165           "CS",    /* 141 */\r
166           "CX",    /* 142 */\r
167           "DH",    /* 143 */\r
168           "DI",    /* 144 */\r
169           "DL",    /* 145 */\r
170           "DR0",   /* 146 */\r
171           "DR1",   /* 147 */\r
172           "DR2",   /* 148 */\r
173           "DR3",   /* 149 */\r
174           "DR6",   /* 150 */\r
175           "DR7",   /* 151 */\r
176           "DS",    /* 152 */\r
177           "DX",    /* 153 */\r
178       "EAX",   /* 154 */\r
179           "EBP",   /* 155 */\r
180           "EBX",   /* 156 */\r
181           "ECX",   /* 157 */\r
182           "EDI",   /* 158 */\r
183           "EDX",   /* 159 */\r
184           "ESI",   /* 160 */\r
185           "ES",    /* 161 */\r
186           "ESP",   /* 162 */\r
187           "FS",    /* 163 */\r
188           "GS",    /* 164 */\r
189           "SI",    /* 165 */\r
190           "SP",    /* 166 */\r
191           "SS",    /* 167 */\r
192           "TR6",   /* 168 */\r
193           "TR7"};  /* 169 */\r
194 \r
195 #define rAH  128\r
196 #define rAL  129\r
197 #define rAX  130\r
198 #define rBH  131\r
199 #define rBL  132\r
200 #define rBP  133\r
201 #define rBX  134\r
202 #define rCH  135\r
203 #define rCL  136\r
204 #define rCR0 137\r
205 #define rCR1 138\r
206 #define rCR2 139\r
207 #define rCR3 140\r
208 #define rCS  141\r
209 #define rCX  142\r
210 #define rDH  143\r
211 #define rDI  144\r
212 #define rDL  145\r
213 #define rDR0 146\r
214 #define rDR1 147\r
215 #define rDR2 148\r
216 #define rDR3 149\r
217 #define rDR6 150\r
218 #define rDR7 151\r
219 #define rDS  152\r
220 #define rDX  153\r
221 #define rEAX 154\r
222 #define rEBP 155\r
223 #define rEBX 156\r
224 #define rECX 157\r
225 #define rEDI 158\r
226 #define rEDX 159\r
227 #define rESI 160\r
228 #define rES  161\r
229 #define rESP 162\r
230 #define rFS  163\r
231 #define rGS  164\r
232 #define rSI  165\r
233 #define rSP  166\r
234 #define rSS  167\r
235 #define rTR6 168\r
236 #define rTR7 169\r
237 \r
238 /* This is an alaphebetical array of all the 386 instructions */\r
239 /* It it used for a binary search for an instruction  */\r
240 \r
241 #define ninst 208\r
242 #define sinst 7                                 /* size of a instruction storage */\r
243 \r
244 int rgInsLookUp[ninst+1];               /* Lookup for instruction table */\r
245 \r
246 char rginst[ninst][sinst] = {   /*  1456 bytes */\r
247 \r
248     "AAA",     /* 001 */\r
249     "AAD",     /* 002 */\r
250     "AAM",     /* 003 */\r
251         "AAS",     /* 004 */\r
252         "ADC",     /* 005 */\r
253         "ADD",     /* 006 */\r
254         "AND",     /* 007 */\r
255         "ARPL",    /* 008 */\r
256 \r
257         "BOUND",   /* 009 */\r
258         "BSF",     /* 010 */\r
259         "BSR",     /* 011 */\r
260         "BT",      /* 012 */\r
261         "BTC",     /* 013 */\r
262         "BTR",     /* 014 */\r
263         "BTS",     /* 015 */\r
264 \r
265         "CALL",    /* 016 */\r
266         "CBW",     /* 017 */\r
267         "CDQ",     /* 018 */\r
268         "CLC",     /* 019 */\r
269         "CLD",     /* 020 */\r
270         "CLI",     /* 021 */\r
271         "CLTS",    /* 022 */\r
272         "CMC",     /* 023 */\r
273         "CMP",     /* 024 */\r
274         "CMPS",    /* 025 */\r
275         "CMPSB",   /* 026 */\r
276         "CMPSD",   /* 027 */\r
277         "CMPSW",   /* 028 */\r
278         "CWD",     /* 029 */\r
279         "CWDE",    /* 030 */\r
280 \r
281         "DAA",     /* 031 */\r
282         "DAS",     /* 032 */\r
283         "DEC",     /* 033 */\r
284         "DIV",     /* 034 */\r
285 \r
286         "ENTER",   /* 035 */\r
287 \r
288         "HLT",     /* 036 */\r
289 \r
290         "IDIV",    /* 037 */\r
291         "IMUL",    /* 038 */\r
292         "IN",      /* 039 */\r
293         "INC",     /* 040 */\r
294         "INS",     /* 041 */\r
295         "INSB",    /* 042 */\r
296         "INSD",    /* 043 */\r
297         "INSW",    /* 044 */\r
298         "INT",     /* 045 */\r
299         "INTO",    /* 046 */\r
300         "IRET",    /* 047 */\r
301         "IRETD",   /* 048 */\r
302 \r
303         "JA",      /* 049 */\r
304         "JAE",     /* 050 */\r
305         "JB",      /* 051 */\r
306         "JBE",     /* 052 */\r
307         "JC",      /* 053 */\r
308         "JCXZ",    /* 054 */\r
309         "JE",      /* 055 */\r
310         "JECXZ",   /* 056 */\r
311         "JG",      /* 057 */\r
312         "JGE",     /* 058 */\r
313         "JL",      /* 059 */\r
314         "JLE",     /* 060 */\r
315         "JMP",     /* 061 */\r
316         "JNA",     /* 062 */\r
317         "JNAE",    /* 063 */\r
318         "JNB",     /* 064 */\r
319         "JNBE",    /* 065 */\r
320         "JNC",     /* 066 */\r
321         "JNE",     /* 067 */\r
322         "JNG",     /* 068 */\r
323         "JNGE",    /* 069 */\r
324         "JNL",     /* 070 */\r
325         "JNLE",    /* 071 */\r
326         "JNO",     /* 072 */\r
327         "JNP",     /* 073 */\r
328         "JNS",     /* 074 */\r
329         "JNZ",     /* 075 */\r
330         "JO",      /* 076 */\r
331         "JP",      /* 077 */\r
332         "JPE",     /* 078 */\r
333         "JPO",     /* 079 */\r
334         "JS",      /* 080 */\r
335         "JZ",      /* 081 */\r
336 \r
337         "LAHF",    /* 082 */\r
338         "LAR",     /* 083 */\r
339         "LDS",     /* 084 */\r
340         "LEA",     /* 085 */\r
341         "LEAVE",   /* 086 */\r
342         "LES",     /* 087 */\r
343         "LFS",     /* 088 */\r
344         "LGDT",    /* 089 */\r
345         "LGS",     /* 090 */\r
346         "LIDT",    /* 091 */\r
347         "LLDT",    /* 092 */\r
348         "LMSW",    /* 093 */\r
349         "LOCK",    /* 094 */\r
350         "LODS",    /* 095 */\r
351         "LODSB",   /* 096 */\r
352         "LODSD",   /* 097 */\r
353         "LODSW",   /* 098 */\r
354         "LOOP",    /* 099 */\r
355         "LOOPE",   /* 100 */\r
356         "LOOPNE",  /* 101 */\r
357         "LOOPNZ",  /* 102 */\r
358         "LOOPZ",   /* 103 */\r
359         "LSL",     /* 104 */\r
360         "LSS",     /* 105 */\r
361         "LTR",     /* 106 */\r
362 \r
363         "MOV",     /* 107 */\r
364         "MOVS",    /* 108 */\r
365         "MOVSB",   /* 109 */\r
366         "MOVSD",   /* 110 */\r
367         "MOVSW",   /* 111 */\r
368         "MOVSX",   /* 112 */\r
369         "MOVZX",   /* 113 */\r
370         "MUL",     /* 114 */\r
371 \r
372         "NEG",     /* 115 */\r
373         "NOP",     /* 116 */\r
374         "NOT",     /* 117 */\r
375 \r
376         "OR",      /* 118 */\r
377         "OUT",     /* 119 */\r
378         "OUTS",    /* 120 */\r
379         "OUTSB",   /* 121 */\r
380         "OUTSD",   /* 122 */\r
381         "OUTSW",   /* 123 */\r
382 \r
383         "POP",     /* 124 */\r
384         "POPA",    /* 125 */\r
385         "POPAD",   /* 126 */\r
386         "POPF",    /* 127 */\r
387         "POPFD",   /* 128 */\r
388         "PUSH",    /* 129 */\r
389         "PUSHA",   /* 130 */\r
390     "PUSHAD",  /* 131 */\r
391     "PUSHF",   /* 132 */\r
392     "PUSHFD",  /* 133 */\r
393 \r
394     "RCL",     /* 134 */\r
395     "RCR",     /* 135 */\r
396     "REP",     /* 136 */\r
397     "REPE",    /* 137 */\r
398     "REPNE",   /* 138 */\r
399     "REPNZ",   /* 139 */\r
400     "REPZ",    /* 140 */\r
401     "RET",     /* 141 */\r
402     "RETF",    /* 142 */\r
403     "RETN",    /* 143 */\r
404     "ROL",     /* 144 */\r
405     "ROR",     /* 145 */\r
406 \r
407     "SAHF",    /* 146 */\r
408     "SAL",     /* 147 */\r
409     "SAR",     /* 148 */\r
410     "SBB",     /* 149 */\r
411     "SCAS",    /* 150 */\r
412     "SCASB",   /* 151 */\r
413     "SCASD",   /* 152 */\r
414     "SCASW",   /* 153 */\r
415     "SETA",    /* 154 */\r
416     "SETAE",   /* 155 */\r
417     "SETB",    /* 156 */\r
418     "SETBE",   /* 157 */\r
419     "SETC",    /* 158 */\r
420     "SETE",    /* 159 */\r
421     "SETG",    /* 160 */\r
422     "SETGE",   /* 161 */\r
423     "SETL",    /* 162 */\r
424     "SETLE",   /* 163 */\r
425     "SETNA",   /* 164 */\r
426     "SETNAE",  /* 165 */\r
427     "SETNB",   /* 166 */\r
428     "SETNBE",  /* 167 */\r
429     "SETNC",   /* 168 */\r
430         "SETNE",   /* 169 */\r
431         "SETNG",   /* 170 */\r
432         "SETNGE",  /* 171 */\r
433         "SETNL",   /* 172 */\r
434     "SETNLE",  /* 173 */\r
435     "SETNO",   /* 174 */\r
436     "SETNP",   /* 175 */\r
437     "SETNS",   /* 176 */\r
438     "SETNZ",   /* 177 */\r
439     "SETO",    /* 178 */\r
440     "SETP",    /* 179 */\r
441     "SETPE",   /* 180 */\r
442     "SETPO",   /* 181 */\r
443     "SETS",    /* 182 */\r
444     "SETZ",    /* 183 */\r
445     "SGDT",    /* 184 */\r
446     "SHL",     /* 185 */\r
447     "SHLD",    /* 186 */\r
448     "SHR",     /* 187 */\r
449     "SHRD",    /* 188 */\r
450     "SIDT",    /* 189 */\r
451     "SLDT",    /* 190 */\r
452     "SMSW",    /* 191 */\r
453     "STC",     /* 192 */\r
454     "STD",     /* 193 */\r
455     "STI",     /* 194 */\r
456     "STOS",    /* 195 */\r
457     "STOSB",   /* 196 */\r
458     "STOSD",   /* 197 */\r
459     "STOSW",   /* 198 */\r
460     "STR",     /* 199 */\r
461     "SUB",     /* 200 */\r
462 \r
463     "TEST",    /* 201 */\r
464 \r
465     "VERR",    /* 202 */\r
466     "VERW",    /* 203 */\r
467 \r
468     "WAIT",    /* 204 */\r
469         "XCHG",    /* 205 */\r
470     "XLAT",    /* 206 */\r
471     "XLATB",   /* 207 */\r
472     "XOR"};    /* 208 */\r
473 \r
474 #define xAAA    1\r
475 #define xAAD    2\r
476 #define xAAM    3\r
477 #define xAAS    4\r
478 #define xADC    5\r
479 #define xADD    6\r
480 #define xAND    7\r
481 #define xARPL   8\r
482 \r
483 #define xBOUND  9\r
484 #define xBSF    10\r
485 #define xBSR    11\r
486 #define xBT     12\r
487 #define xBTC    13\r
488 #define xBTR    14\r
489 #define xBTS    15\r
490 \r
491 #define xCALL   16\r
492 #define xCBW    17\r
493 #define xCDQ    18\r
494 #define xCLC    19\r
495 #define xCLD    20\r
496 #define xCLI    21\r
497 #define xCLTS   22\r
498 #define xCMC    23\r
499 #define xCMP    24\r
500 #define xCMPS   25\r
501 #define xCMPSB  26\r
502 #define xCMPSD  27\r
503 #define xCMPSW  28\r
504 #define xCWD    29\r
505 #define xCWDE   30\r
506 \r
507 #define xDAA    31\r
508 #define xDAS    32\r
509 #define xDEC    33\r
510 #define xDIV    34\r
511 \r
512 #define xENTER  35\r
513 #define xHLT    36\r
514 \r
515 #define xIDIV   37\r
516 #define xIMUL   38\r
517 #define xIN     39\r
518 #define xINC    40\r
519 #define xINS    41\r
520 #define xINSB   42\r
521 #define xINSD   43\r
522 #define xINSW   44\r
523 #define xINT    45\r
524 #define xINTO   46\r
525 #define xIRET   47\r
526 #define xIRETD  48\r
527 \r
528 #define xJA     49\r
529 #define xJAE    50\r
530 #define xJB     51\r
531 #define xJBE    52\r
532 #define xJC     53\r
533 #define xJCXZ   54\r
534 #define xJE     55\r
535 #define xJECXZ  56\r
536 #define xJG     57\r
537 #define xJGE    58\r
538 #define xJL     59\r
539 #define xJLE    60\r
540 #define xJMP    61\r
541 #define xJNA    62\r
542 #define xJNAE   63\r
543 #define xJNB    64\r
544 #define xJNBE   65\r
545 #define xJNC    66\r
546 #define xJNE    67\r
547 #define xJNG    68\r
548 #define xJNGE   69\r
549 #define xJNL    70\r
550 #define xJNLE   71\r
551 #define xJNO    72\r
552 #define xJNP    73\r
553 #define xJNS    74\r
554 #define xJNZ    75\r
555 #define xJO     76\r
556 #define xJP     77\r
557 #define xJPE    78\r
558 #define xJPO    79\r
559 #define xJS     80\r
560 #define xJZ     81\r
561 \r
562 #define xLAHF   82\r
563 #define xLAR    83\r
564 #define xLDS    84\r
565 #define xLEA    85\r
566 #define xLEAVE  86\r
567 #define xLES    87\r
568 #define xLFS    88\r
569 #define xLGDT   89\r
570 #define xLGS    90\r
571 #define xLIDT   91\r
572 #define xLLDT   92\r
573 #define xLMSW   93\r
574 #define xLOCK   94\r
575 #define xLODS   95\r
576 #define xLODSB  96\r
577 #define xLODSD  97\r
578 #define xLODSW  98\r
579 #define xLOOP   99\r
580 #define xLOOPE  100\r
581 #define xLOOPNE 101\r
582 #define xLOOPNZ 102\r
583 #define xLOOPZ  103\r
584 #define xLSL    104\r
585 #define xLSS    105\r
586 #define xLTR    106\r
587 \r
588 #define xMOV    107\r
589 #define xMOVS   108\r
590 #define xMOVSB  109\r
591 #define xMOVSD  110\r
592 #define xMOVSW  111\r
593 #define xMOVSX  112\r
594 #define xMOVZX  113\r
595 #define xMUL    114\r
596 \r
597 #define xNEG    115\r
598 #define xNOP    116\r
599 #define xNOT    117\r
600 \r
601 #define xOR     118\r
602 #define xOUT    119\r
603 #define xOUTS   120\r
604 #define xOUTSB  121\r
605 #define xOUTSD  122\r
606 #define xOUTSW  123\r
607 \r
608 #define xPOP    124\r
609 #define xPOPA   125\r
610 #define xPOPAD  126\r
611 #define xPOPF   127\r
612 #define xPOPFD  128\r
613 #define xPUSH   129\r
614 #define xPUSHA  130\r
615 #define xPUSHAD 131\r
616 #define xPUSHF  132\r
617 #define xPUSHFD 133\r
618 \r
619 #define xRCL    134\r
620 #define xRCR    135\r
621 #define xREP    136\r
622 #define xREPE   137\r
623 #define xREPNE  138\r
624 #define xREPNZ  139\r
625 #define xREPZ   140\r
626 #define xRET    141\r
627 #define xRETF   142\r
628 #define xRETN   143\r
629 #define xROL    144\r
630 #define xROR    145\r
631 \r
632 #define xSAHF   146\r
633 #define xSAL    147\r
634 #define xSAR    148\r
635 #define xSBB    149\r
636 #define xSCAS   150\r
637 #define xSCASB  151\r
638 #define xSCASD  152\r
639 #define xSCASW  153\r
640 #define xSETA   154\r
641 #define xSETAE  155\r
642 #define xSETB   156\r
643 #define xSETBE  157\r
644 #define xSETC   158\r
645 #define xSETE   159\r
646 #define xSETG   160\r
647 #define xSETGE  161\r
648 #define xSETL   162\r
649 #define xSETLE  163\r
650 #define xSETNA  164\r
651 #define xSETNAE 165\r
652 #define xSETNB  166\r
653 #define xSETNBE 167\r
654 #define xSETNC  168\r
655 #define xSETNE  169\r
656 #define xSETNG  170\r
657 #define xSETNGE 171\r
658 #define xSETNL  172\r
659 #define xSETNLE 173\r
660 #define xSETNO  174\r
661 #define xSETNP  175\r
662 #define xSETNS  176\r
663 #define xSETNZ  177\r
664 #define xSETO   178\r
665 #define xSETP   179\r
666 #define xSETPE  180\r
667 #define xSETPO  181\r
668 #define xSETS   182\r
669 #define xSETZ   183\r
670 #define xSGDT   184\r
671 #define xSHL    185\r
672 #define xSHLD   186\r
673 #define xSHR    187\r
674 #define xSHRD   188\r
675 #define xSIDT   189\r
676 #define xSLDT   190\r
677 #define xSMSW   191\r
678 #define xSTC    192\r
679 #define xSTD    193\r
680 #define xSTI    194\r
681 #define xSTOS   195\r
682 #define xSTOSB  196\r
683 #define xSTOSD  197\r
684 #define xSTOSW  198\r
685 #define xSTR    199\r
686 #define xSUB    200\r
687 \r
688 #define xTEST   201\r
689 \r
690 #define xVERR   202\r
691 #define xVERW   203\r
692 \r
693 #define xWAIT   204\r
694 #define xXCHG   205\r
695 #define xXLAT   206\r
696 #define xXLATB  207\r
697 #define xXOR    208\r
698 \r
699 \r
700 #define nrinst 80                       /* number of float instructions */\r
701 #define srinst 8\r
702 char rgrinst[nrinst][srinst] = {                /*  560 bytes */\r
703 \r
704         "F2XM1",     /* 01 */\r
705         "FABS",      /* 02 */\r
706         "FADD",      /* 03 */\r
707         "FADDP",     /* 04 */\r
708         "FBLD",      /* 05 */\r
709         "FBSTP",     /* 06 */\r
710         "FCHS",      /* 07 */\r
711         "FCLEX",     /* 08 */\r
712         "FCOM",      /* 09 */\r
713         "FCOMP",     /* 10 */\r
714         "FCOMPP",    /* 11 */\r
715         "FCOS",      /* 12 */\r
716         "FDECSTP",   /* 13 */\r
717         "FDIV",      /* 14 */\r
718         "FDIVP",     /* 15 */\r
719         "FDIVR",     /* 16 */\r
720         "FDIVRP",    /* 17 */\r
721         "FFREE",     /* 18 */\r
722         "FIADD",     /* 19 */\r
723         "FICOM",     /* 20 */\r
724         "FICOMP",    /* 21 */\r
725         "FIDIV",     /* 22 */\r
726         "FIDIVR",    /* 23 */\r
727         "FILD",      /* 24 */\r
728         "FIMUL",     /* 25 */\r
729         "FINCSTP",   /* 26 */\r
730         "FINIT",     /* 27 */\r
731         "FIST",      /* 28 */\r
732         "FISTP",     /* 29 */\r
733         "FISUB",     /* 30 */\r
734         "FISUBR",    /* 31 */\r
735         "FLD",       /* 32 */\r
736         "FLD1",      /* 33 */\r
737         "FLDCW",     /* 34 */\r
738         "FLDENV",    /* 35 */\r
739         "FLDL2E",    /* 36 */\r
740         "FLDL2T",    /* 37 */\r
741         "FLDLG2",    /* 38 */\r
742         "FLDLN2",    /* 39 */\r
743         "FLDPI",     /* 40 */\r
744         "FLDZ",      /* 41 */\r
745         "FMUL",      /* 42 */\r
746         "FMULP",     /* 43 */\r
747         "FNCLEX",    /* 44 */\r
748         "FNINIT",    /* 45 */\r
749         "FNOP",      /* 46 */\r
750         "FNSAVE",    /* 47 */\r
751         "FNSTCW",    /* 48 */\r
752         "FNSTENV",   /* 49 */\r
753         "FNSTSW",    /* 50 */\r
754         "FPATAN",    /* 51 */\r
755         "FPREM",     /* 52 */\r
756         "FPREM1",    /* 53 */\r
757         "FPTAN",     /* 54 */\r
758         "FRNDINT",   /* 55 */\r
759         "FRSTOR",    /* 56 */\r
760         "FSAVE",     /* 57 */\r
761         "FSCALE",    /* 58 */\r
762         "FSIN",      /* 59 */\r
763         "FSINCOS",   /* 60 */\r
764         "FSQRT",     /* 61 */\r
765         "FST",       /* 62 */\r
766         "FSTCW",     /* 63 */\r
767         "FSTENV",    /* 64 */\r
768         "FSTP",      /* 65 */\r
769         "FSTSW",     /* 66 */\r
770         "FSUB",      /* 67 */\r
771         "FSUBP",     /* 68 */\r
772         "FSUBPR",    /* 69 */\r
773         "FSUBR",     /* 70 */\r
774         "FTST",      /* 71 */\r
775         "FUCOM",     /* 72 */\r
776         "FUCOMP",    /* 73 */\r
777         "FUCOMPP",   /* 74 */\r
778         "FWAIT",     /* 75 */\r
779         "FXAM",      /* 76 */\r
780         "FXCH",      /* 77 */\r
781         "FXTRACT",   /* 78 */\r
782         "FYL2X",     /* 79 */\r
783         "FYL2XP1" }; /* 80 */\r
784 \r
785 \r
786 /*  END OF INSTRUCTIONS  */\r
787 \r
788 /* Allowed Operand types for instruction sequences\r
789    Start numbering at 61 so they don't conflict with\r
790    token values or special characters */\r
791 \r
792 #define rel8   61       /* mem address within +/-127 bytes of currnt address */\r
793 #define relW   62       /* mem address relative (WORD/DWORD) of current addr */\r
794 #define iSAD   63       /* immediate segment address (seg16:offset16/32)  */\r
795 #define r8     64       /* Reg: AL, BL, CL, DL, AH, BH, CH, DH            */\r
796 #define r16    65       /* Reg: AX, BX, CX, DX, SP, BP, SI, DI            */\r
797 #define r32    66       /* Reg: EAX, EBX, ECX, EDX, ESP, EBP, ESI, EDI    */\r
798 #define rREG   67   /* Any 8, 16 or 32 bit general register */\r
799 #define rRGW   68   /* Any 16 or 32 bit general register    */\r
800 #define rACC   69   /* Reg: Accumulator AL, AX, EAX (any size) */\r
801 #define rSEG   70   /* Reg: CS, DS, SS, ES, FS, GS   */\r
802 #define rCRG   71   /* Reg: CR0, CR2, CR3 */\r
803 #define rDRG   72   /* Reg: DR0, DR1, DR2, DR3, DR6, DR7 */\r
804 #define rTRG   73   /* Reg: TR6, TR7 */\r
805 #define imm8   74       /* Immediate BYTE - UNSIGNED*/\r
806 #define ims8   75       /* Immediate BYTE - Will be SIGN Extended!!! */\r
807 #define imm16  76       /* Immediate WORD signed value  */\r
808 #define immX   77   /* immediate size value to match the other operand */\r
809 #define rm8    78       /* r8 or memory address to BYTE                   */\r
810 #define rm16   79       /* r16 or memory address to WORD                  */\r
811 #define rRM    80   /* Any 8, 16 or 32 bit register or memory ref     */\r
812 #define rRMW   81   /* Any 16 or 32 bit register or memory ref        */\r
813 #define mem    82       /* Memory address. Any legal data mem reference   */\r
814 #define memF   83       /* Memory address of a 16:32 ptr value   */\r
815 #define moff   84       /* Memory address (Immediate, Disp only, Seg relative)*/\r
816 #define immv3  85   /* immediate value 3 for INT 03 debug */\r
817 #define immv1  86   /* immediate value 1 for some instructions (SHL etc.) */\r
818 \r
819 /* these are only used in the rgMEM32 table */\r
820 \r
821 #define val8   87       /* Indicates numeric value for displacement, */\r
822 #define val16  88   /*  immediate, address, etc. Used in memory model */\r
823 #define val32  89       /*  template. */\r
824 \r
825 \r
826 /*  Instruction sequence lookup table is made of:\r
827         - Instruction number (from definitions above)\r
828         - Opr1-3 are the legal operands for the instructions\r
829         - Opc is base opcode.\r
830         - Oprm is the ModR/M byte (if needed). It is partially filled in\r
831           and used as indicated by Om1 below.\r
832         - Opfx - Operand prefix and operand count for instruction.\r
833                 qP0F - Prefix Opc with 0x0f\r
834                 qUW  - Use 0x66 prefix always\r
835                 qU16 - If USE16 prefix Opcodes with 0x66.\r
836                 qU32 - If USE32 prefix Opcodes with 0x66.\r
837 \r
838         - Om1 -  Modifications or additions to OpCode to complete instruction:\r
839                 zMOP - Use Oprm as ModR/M byte (which is already filled in\r
840                            partially with Opcode in bits 3-5). If operand 1 is\r
841                            register, placed code in R/M field of ModR/M byte (bits 0-2).\r
842                            If operand 1 is mem, handle normally. In special case of\r
843                            AAD and AAM instructions Oprm is actually second byte of\r
844                            opcode (no operands to handle).\r
845                 zMR1 - Use Oprm as ModR/M byte. Register in operand 1\r
846                            must be encoded in REG/OPC field of ModR/M. If reg in\r
847                            operand 2 it must be incoded in R/M field.\r
848                 zMR2 - Use Oprm as ModR/M byte. Register in operand 2\r
849                            must be encoded in REG/OPC field of ModR/M. If reg in\r
850                            operand 1, it must be encoded in R/M field.\r
851                 zORD - OR Opc1 with 01 if WORD or DWORD reg/mem\r
852                 zAR1 - No ModRM, Add register code in operand 1 to Opc byte to\r
853                        complete the opcode.\r
854                 zAR2 - No ModRM, Add register code in operand 2 to Opc byte to\r
855                        complete the opcode.\r
856                 zRG1 - If register in operand 1, it must be encoded in\r
857                        REG/OPC field of ModR/M, else handle memory operand normally.\r
858             zSIZ - This is not actually a modification to the instruction,\r
859                    but tells the assembler that the operand sizes will not\r
860                    match and that it's ok.  The operand size should be the\r
861                    size of the first operand.\r
862 \r
863  */\r
864 \r
865 /* Prefix instruction/operand count byte */\r
866 \r
867 #define qP0F 0x01\r
868 #define qU16 0x02\r
869 #define qU32 0x04\r
870 #define qUW  0x08\r
871 \r
872 /* OM1 instruction byte  (Opcode Modifier/Special build instructions) */\r
873 #define zMOP 0x01\r
874 #define zMR1 0x02\r
875 #define zMR2 0x04\r
876 #define zORD 0x08\r
877 #define zAR1 0x10\r
878 #define zAR2 0x20\r
879 #define zRG1 0x40\r
880 #define zSIZ 0x80\r
881 \r
882 \r
883 /* Certain table entries were added for optimization to ensure that\r
884    the shortest instruction is used in all cases.  This adds about\r
885    50 lines to the table, but it's well worth the overhead!\r
886 */\r
887 \r
888 #define nrgINS 338\r
889 unsigned char rgINS[nrgINS][8] = {  /* 338 * 8 = */\r
890 \r
891 /*Inst   Opr1    Opr2   Opr3  Opfx        Opc   Oprm   Om1          */\r
892 \r
893 {0      , 0,     0,     0,    0,          0,     0,    0            },\r
894 {xAAA   , 0,     0,     0,    0,          0x37,  0,    0            },\r
895 {xAAD   , 0,     0,     0,    0,          0xd5,  0x0A, zMOP         },\r
896 {xAAM   , 0,     0,     0,    0,          0xd4,  0x0A, zMOP         },\r
897 {xADC   , rACC,  immX,  0,    0,          0x14,  0,    zORD         },\r
898 {xADC   , rRMW,  imm8,  0,    0,          0x83,  0x10, zMOP         },\r
899 {xADC   , rRM,   immX,  0,    0,          0x80,  0x10, zMOP|zORD    },\r
900 {xADC   , rRM,   rREG,  0,    0,          0x10,  0,    zMR2|zORD    },\r
901 {xADC   , rREG,  rRM,   0,    0,          0x12,  0,    zMR1|zORD    },\r
902 \r
903 {xADD   , rRMW,  ims8,  0,    0,          0x83,  0,    zMOP         },\r
904 {xADD   , rACC,  immX,  0,    0,          0x04,  0,    zORD         },\r
905 {xADD   , rRM,   immX,  0,    0,          0x80,  0,    zMOP|zORD    },\r
906 {xADD   , rREG,  rRM,   0,    0,          0x02,  0,    zMR1|zORD    },\r
907 {xADD   , rRM,   rREG,  0,    0,          0x00,  0,    zMR2|zORD    },\r
908 \r
909 {xAND   , rRMW,  ims8,  0,    0,          0x83,  0x20, zMOP         },\r
910 {xAND   , rACC,  immX,  0,    0,          0x24,  0,    zORD         },\r
911 {xAND   , rRM,   immX,  0,    0,          0x80,  0x20, zMOP|zORD    },\r
912 {xAND   , rREG,  rRM,   0,    0,          0x22,  0,    zMR1|zORD    },\r
913 {xAND   , rRM,   rREG,  0,    0,          0x20,  0,    zMR2|zORD    },\r
914 \r
915 {xARPL  , rm16,  r16,   0,    0,          0x63,  0,    zMR2         },\r
916 {xBOUND , rRMW,  mem,   0,    0,          0x62,  0,    zMR1         },\r
917 {xBSF   , rRGW,  rRMW,  0,    qP0F,       0xbc,  0,    zMR1         },\r
918 {xBSR   , rRGW,  rRMW,  0,    qP0F,       0xbd,  0,    zMR1         },\r
919 {xBT    , rRMW,  rRGW,  0,    qP0F,       0xa3,  0,    zMR2         },\r
920 {xBT    , rRMW,  imm8,  0,    qP0F,       0xba,  0x20, zMOP         },\r
921 {xBTC   , rRMW,  rRGW,  0,    qP0F,       0xbb,  0,    zMR2         },\r
922 {xBTC   , rRMW,  imm8,  0,    qP0F,       0xba,  0x38, zMOP         },\r
923 {xBTR   , rRMW,  rRGW,  0,    qP0F,       0xb3,  0,    zMR2         },\r
924 {xBTR   , rRMW,  imm8,  0,    qP0F,       0xba,  0x30, zMOP         },\r
925 {xBTS   , rRMW,  rRGW,  0,    qP0F,       0xab,  0,    zMR2         },\r
926 {xBTS   , rRMW,  imm8,  0,    qP0F,       0xba,  0x28, zMOP         },\r
927 {xCALL  , relW,  0,     0,    0,          0xe8,  0,    0            },\r
928 {xCALL  , rRMW,  0,     0,    0,          0xff,  0x10, zMOP         },\r
929 {xCALL  , iSAD,  0,     0,    0,          0x9a,  0,    0            },\r
930 {xCALL  , memF,  0,     0,    0,          0xff,  0x18, zMOP         },\r
931 {xCBW   , 0,     0,     0,    qU32,       0x98,  0,    0            },\r
932 {xCWDE  , 0,     0,     0,    qU16,       0x98,  0,    0            },\r
933 {xCLC   , 0,     0,     0,    0,          0xf8,  0,    0            },\r
934 {xCLD   , 0,     0,     0,    0,          0xfc,  0,    0            },\r
935 {xCLI   , 0,     0,     0,    0,          0xfa,  0,    0            },\r
936 {xCLTS  , 0,     0,     0,    qP0F,       0x06,  0,    0            },\r
937 {xCMC   , 0,     0,     0,    0,          0xf5,  0,    0            },\r
938 \r
939 {xCMP   , rRMW,  ims8,  0,    0,          0x83,  0x38, zMOP         },\r
940 {xCMP   , rACC,  immX,  0,    0,          0x3c,  0,    zORD         },\r
941 {xCMP   , rRM,   immX,  0,    0,          0x80,  0x38, zMOP|zORD    },\r
942 {xCMP   , rREG,  rRM,   0,    0,          0x3a,  0,    zMR1|zORD    },\r
943 {xCMP   , rRM,   rREG,  0,    0,          0x38,  0,    zMR2|zORD    },\r
944 \r
945 {xCMPSB , 0,     0,     0,     0,         0xa6,  0,    0            },\r
946 {xCMPSD , 0,     0,     0,     0,         0xa7,  0,    0            },\r
947 {xCMPSW , 0,     0,     0,     qUW,       0xa7,  0,    0            },\r
948 {xCWD   , 0,     0,     0,     qUW,      0x99,  0,    0            },\r
949 {xCDQ   , 0,     0,     0,     qU16,      0x99,  0,    0            },\r
950 {xDAA   , 0,     0,     0,     0,         0x27,  0,    0            },\r
951 {xDAS   , 0,     0,     0,     0,         0x2f,  0,    0            },\r
952 {xDEC   , rRGW,  0,     0,     0,         0x48,  0,    zAR1         },\r
953 {xDEC   , rRM,   0,     0,     0,         0xfe,  0x08, zMOP|zORD    },\r
954 {xDIV   , rRM,   0,     0,     0,         0xf6,  0x30, zMOP|zORD    },\r
955 {xENTER , imm16, imm8,  0,     0,         0xc8,  0,    zSIZ         },\r
956 {xHLT   , 0,     0,     0,     0,         0xf4,  0,    0            },\r
957 {xIDIV  , rRM,   0,     0,     0,         0xf6,  0x38, zMOP|zORD    },\r
958 {xIMUL  , rRM,   0,     0,     0,         0xf6,  0x28, zMOP|zORD    },\r
959 {xIMUL  , rRGW,  rRMW,  0,     qP0F,      0xaf,  0,    zMR1         },\r
960 {xIMUL  , rRGW,  rRMW,  imm8,  0,         0x6b,  0,    zMR1         },\r
961 {xIMUL  , rRGW,  imm8,  0,     0,         0x6b,  0,    zMR1|zSIZ    },\r
962 {xIMUL  , rRGW,  rRMW,  immX,  0,         0x69,  0,    zMR1         },\r
963 {xIMUL  , rRGW,  immX,  0,     0,         0x69,  0,    zMR1         },\r
964 {xIN    , rACC,  imm8,  0,     0,         0xe4,  0,    zORD|zSIZ    },\r
965 {xIN    , rACC,  rDX,   0,     0,         0xec,  0,    zORD|zSIZ    },\r
966 {xINC   , rRGW,  0,     0,     0,         0x40,  0,    zAR1         },\r
967 {xINC   , rRM,   0,     0,     0,         0xfe,  0,    zMOP|zORD    },\r
968 {xINSB  , 0,     0,     0,     0,         0x6C,  0,    0            },\r
969 {xINSD  , 0,     0,     0,     0,         0x6D,  0,    0            },\r
970 {xINSW  , 0,     0,     0,     qUW,       0x6D,  0,    0            },\r
971 {xINT   , immv3, 0,     0,     0,         0xcc,  0,    0            },\r
972 {xINT   , imm8,  0,     0,     0,         0xcd,  0,    0            },\r
973 {xINTO  , 0,     0,     0,     0,         0xce,  0,    0            },\r
974 {xIRET  , 0,     0,     0,     qUW,       0xcf,  0,    0            },\r
975 {xIRETD , 0,     0,     0,     0,         0xcf,  0,    0            },\r
976 {xJA    , rel8,  0,     0,     0,         0x77,  0,    0            },\r
977 {xJA    , relW,  0,     0,     qP0F,      0x87,  0,    0            },\r
978 {xJAE   , rel8,  0,     0,     0,         0x73,  0,    0            },\r
979 {xJAE   , relW,  0,     0,     qP0F,      0x83,  0,    0            },\r
980 {xJB    , rel8,  0,     0,     0,         0x72,  0,    0            },\r
981 {xJB    , relW,  0,     0,     qP0F,      0x82,  0,    0            },\r
982 {xJBE   , rel8,  0,     0,     0,         0x76,  0,    0            },\r
983 {xJBE   , relW,  0,     0,     qP0F,      0x86,  0,    0            },\r
984 {xJC    , rel8,  0,     0,     0,         0x72,  0,    0            },\r
985 {xJC    , relW,  0,     0,     qP0F,      0x82,  0,    0            },\r
986 {xJCXZ  , rel8,  0,     0,     0,         0xe3,  0,    0            },\r
987 {xJNBE  , rel8,  0,     0,     0,         0x77,  0,    0            },\r
988 {xJNBE  , relW,  0,     0,     qP0F,      0x87,  0,    0            },\r
989 {xJNB   , rel8,  0,     0,     0,         0x73,  0,    0            },\r
990 {xJNB   , relW,  0,     0,     qP0F,      0x83,  0,    0            },\r
991 {xJNC   , rel8,  0,     0,     0,         0x73,  0,    0            },\r
992 {xJNC   , relW,  0,     0,     qP0F,      0x83,  0,    0            },\r
993 {xJNA   , rel8,  0,     0,     0,         0x76,  0,    0            },\r
994 {xJNA   , relW,  0,     0,     qP0F,      0x86,  0,    0            },\r
995 {xJNAE  , rel8,  0,     0,     0,         0x72,  0,    0            },\r
996 {xJNAE  , relW,  0,     0,     qP0F,      0x82,  0,    0            },\r
997 {xJECXZ , rel8,  0,     0,     0,         0xe3,  0,    0            },\r
998 {xJE    , rel8,  0,     0,     0,         0x74,  0,    0            },\r
999 {xJE    , relW,  0,     0,     qP0F,      0x84,  0,    0            },\r
1000 {xJG    , rel8,  0,     0,     0,         0x7f,  0,    0            },\r
1001 {xJG    , relW,  0,     0,     qP0F,      0x8f,  0,    0            },\r
1002 {xJGE   , rel8,  0,     0,     0,         0x7d,  0,    0            },\r
1003 {xJGE   , relW,  0,     0,     qP0F,      0x8d,  0,    0            },\r
1004 {xJNL   , rel8,  0,     0,     0,         0x7d,  0,    0            },\r
1005 {xJNL   , relW,  0,     0,     qP0F,      0x8d,  0,    0            },\r
1006 {xJL    , rel8,  0,     0,     0,         0x7c,  0,    0            },\r
1007 {xJL    , relW,  0,     0,     qP0F,      0x8c,  0,    0            },\r
1008 {xJNGE  , rel8,  0,     0,     0,         0x7c,  0,    0            },\r
1009 {xJNGE  , relW,  0,     0,     qP0F,      0x8c,  0,    0            },\r
1010 {xJLE   , rel8,  0,     0,     0,         0x7e,  0,    0            },\r
1011 {xJLE   , relW,  0,     0,     qP0F,      0x8e,  0,    0            },\r
1012 {xJNG   , rel8,  0,     0,     0,         0x7e,  0,    0            },\r
1013 {xJNG   , relW,  0,     0,     qP0F,      0x8e,  0,    0            },\r
1014 {xJNE   , rel8,  0,     0,     0,         0x75,  0,    0            },\r
1015 {xJNE   , relW,  0,     0,     qP0F,      0x85,  0,    0            },\r
1016 {xJNLE  , rel8,  0,     0,     0,         0x7f,  0,    0            },\r
1017 {xJNLE  , relW,  0,     0,     qP0F,      0x8f,  0,    0            },\r
1018 {xJNO   , rel8,  0,     0,     0,         0x71,  0,    0            },\r
1019 {xJNO   , relW,  0,     0,     qP0F,      0x81,  0,    0            },\r
1020 {xJNP   , rel8,  0,     0,     0,         0x7b,  0,    0            },\r
1021 {xJNP   , relW,  0,     0,     qP0F,      0x8b,  0,    0            },\r
1022 {xJNS   , rel8,  0,     0,     0,         0x79,  0,    0            },\r
1023 {xJNS   , relW,  0,     0,     qP0F,      0x89,  0,    0            },\r
1024 {xJNZ   , rel8,  0,     0,     0,         0x75,  0,    0            },\r
1025 {xJNZ   , relW,  0,     0,     qP0F,      0x85,  0,    0            },\r
1026 {xJO    , rel8,  0,     0,     0,         0x70,  0,    0            },\r
1027 {xJO    , relW,  0,     0,     qP0F,      0x80,  0,    0            },\r
1028 {xJP    , rel8,  0,     0,     0,         0x7a,  0,    0            },\r
1029 {xJP    , relW,  0,     0,     qP0F,      0x8a,  0,    0            },\r
1030 {xJPO   , rel8,  0,     0,     0,         0x7b,  0,    0            },\r
1031 {xJPO   , relW,  0,     0,     qP0F,      0x8b,  0,    0            },\r
1032 {xJPE   , rel8,  0,     0,     0,         0x7a,  0,    0            },\r
1033 {xJPE   , relW,  0,     0,     qP0F,      0x8a,  0,    0            },\r
1034 {xJS    , rel8,  0,     0,     0,         0x78,  0,    0            },\r
1035 {xJS    , relW,  0,     0,     qP0F,      0x88,  0,    0            },\r
1036 {xJZ    , rel8,  0,     0,     0,         0x74,  0,    0            },\r
1037 {xJZ    , relW,  0,     0,     qP0F,      0x84,  0,    0            },\r
1038 {xJMP   , rel8,  0,     0,     0,         0xeb,  0,    0            },\r
1039 {xJMP   , relW,  0,     0,     0,         0xe9,  0,    0            },\r
1040 {xJMP   , rRMW,  0,     0,     0,         0xff,  0x20, zMOP         },\r
1041 {xJMP   , iSAD,  0,     0,     0,         0xea,  0,    0            },\r
1042 {xJMP   , memF,  0,     0,     0,         0xff,  0x28, zMOP         },\r
1043 {xLAHF  , 0,     0,     0,     0,         0x9f,  0,    0            },\r
1044 {xLAR   , rRGW,  rRMW,  0,     qP0F,      0x02,  0,    zMR1         },\r
1045 {xLEA   , rRGW,  mem,   0,     0,         0x8d,  0,    zMR1|zSIZ    },\r
1046 {xLEAVE , 0,     0,     0,     0,         0xc9,  0,    0            },\r
1047 {xLGDT  , memF,  0,     0,     qP0F,      0x01,  0x10, zMOP         },\r
1048 {xLIDT  , memF,  0,     0,     qP0F,      0x01,  0x18, zMOP         },\r
1049 {xLDS   , rRGW,  memF,  0,     0,         0xc5,  0,    zMR1         },\r
1050 {xLSS   , rRGW,  memF,  0,     qP0F,      0xb2,  0,    zMR1         },\r
1051 {xLES   , rRGW,  memF,  0,     0,         0xc4,  0,    zMR1         },\r
1052 {xLFS   , rRGW,  memF,  0,     qP0F,      0xb4,  0,    zMR1         },\r
1053 {xLGS   , rRGW,  memF,  0,     qP0F,      0xb5,  0,    zMR1         },\r
1054 {xLLDT  , rm16,  0,     0,     qP0F,      0x00,  0x10, zMOP         },\r
1055 {xLMSW  , rm16,  0,     0,     qP0F,      0x01,  0x30, zMOP         },\r
1056 {xLOCK  , 0,     0,     0,     0,         0xf0,  0,    0            },\r
1057 {xLODSB , 0,     0,     0,     0,         0xac,  0,    0            },\r
1058 {xLODSD , 0,     0,     0,     0,         0xad,  0,    0            },\r
1059 {xLODSW , 0,     0,     0,     qUW,       0xad,  0,    0            },\r
1060 {xLOOP  , rel8,  0,     0,     0,         0xe2,  0,    0            },\r
1061 {xLOOPE , rel8,  0,     0,     0,         0xe1,  0,    0            },\r
1062 {xLOOPZ , rel8,  0,     0,     0,         0xe1,  0,    0            },\r
1063 {xLOOPNE, rel8,  0,     0,     0,         0xe0,  0,    0            },\r
1064 {xLOOPNZ, rel8,  0,     0,     0,         0xe0,  0,    0            },\r
1065 {xLSL   , rRGW,  rRMW,  0,     qP0F,      0x03,  0,    zMR1         },\r
1066 {xLTR   , rm16,  0,     0,     qP0F,      0x00,  0x18, zMOP         },\r
1067 {xMOV   , rACC,  moff,  0,     0,         0xA0,  0,    zORD         },\r
1068 {xMOV   , moff,  rACC,  0,     0,         0xA2,  0,    zORD         },\r
1069 {xMOV   , r8,    imm8,  0,     0,         0xb0,  0,    zAR1         },\r
1070 {xMOV   , rRGW,  immX,  0,     0,         0xb8,  0,    zAR1         },\r
1071 {xMOV   , rREG,  rRM,   0,     0,         0x8a,  0,    zMR1|zORD    },\r
1072 {xMOV   , rRM,   rREG,  0,     0,         0x88,  0,    zMR2|zORD    },\r
1073 {xMOV   , rRM,   immX,  0,     0,         0xc6,  0,    zMR1|zORD    },/*?*/\r
1074 {xMOV   , rm16,  rSEG,  0,     0,         0x8c,  0,    zMR2         },\r
1075 {xMOV   , rSEG,  rm16,  0,     0,         0x8e,  0,    zMR1         },\r
1076 {xMOV   , r32,   rCRG,  0,     qP0F,      0x20,  0,    zMR2         },\r
1077 {xMOV   , rCRG,  r32,   0,     qP0F,      0x22,  0,    zMR1         },\r
1078 {xMOV   , r32,   rDRG,  0,     qP0F,      0x21,  0,    zMR2         },\r
1079 {xMOV   , rDRG,  r32,   0,     qP0F,      0x23,  0,    zMR1         },\r
1080 {xMOV   , r32,   rTRG,  0,     qP0F,      0x24,  0,    zMR2         },\r
1081 {xMOV   , rTRG,  r32,   0,     qP0F,      0x26,  0,    zMR1         },\r
1082 {xMOVSB , 0,     0,     0,     0,         0xa4,  0,    0            },\r
1083 {xMOVSD , 0,     0,     0,     0,         0xa5,  0,    0            },\r
1084 {xMOVSW , 0,     0,     0,     qUW,       0xa5,  0,    0            },\r
1085 {xMOVSX , r32,   rm16,  0,     qP0F,      0xbf,  0,    zMR1|zSIZ    },\r
1086 {xMOVSX , rRGW,  rm8,   0,     qP0F,      0xbe,  0,    zMR1|zSIZ    },\r
1087 {xMOVZX , r32,   rm16,  0,     qP0F,      0xb7,  0,    zMR1|zSIZ    },\r
1088 {xMOVZX , rRGW,  rm8,   0,     qP0F,      0xb6,  0,    zMR1|zSIZ    },\r
1089 {xMUL   , rRM,   0,     0,     0,         0xf6,  0x20, zMOP|zORD    },\r
1090 {xNEG   , rRM,   0,     0,     0,         0xf6,  0x18, zMOP|zORD    },\r
1091 {xNOP   , 0,     0,     0,     0,         0x90,  0,    0            },\r
1092 {xNOT   , rRM,   0,     0,     0,         0xf6,  0x10, zMOP|zORD    },\r
1093 \r
1094 {xOR    , rRMW,  ims8,  0,     0,         0x83,  0x08, zMOP         },\r
1095 {xOR    , rACC,  immX,  0,     0,         0x0c,  0,    zORD         },\r
1096 {xOR    , rRM,   immX,  0,     0,         0x80,  0x08, zMOP|zORD    },\r
1097 {xOR    , rREG,  rRM,   0,     0,         0x0a,  0,    zMR1|zORD    },\r
1098 {xOR    , rRM,   rREG,  0,     0,         0x08,  0,    zMR2|zORD    },\r
1099 \r
1100 {xOUT   , imm8,  rACC,  0,     0,         0xe6,  0,    zORD         },\r
1101 {xOUT   , rDX,   rACC,  0,     0,         0xee,  0,    zORD         },\r
1102 {xOUTSB , 0,     0,     0,     0,         0x6e,  0,    0            },\r
1103 {xOUTSD , 0,     0,     0,     0,         0x6f,  0,    0            },\r
1104 {xOUTSW , 0,     0,     0,     qUW,       0x6f,  0,    0            },\r
1105 {xPOP   , mem,   0,     0,     0,         0x8f,  0,    zMOP         },\r
1106 {xPOP   , rRGW,  0,     0,     0,         0x58,  0,    zAR1         },\r
1107 {xPOP   , rDS,   0,     0,     0,         0x1f,  0,    0            },\r
1108 {xPOP   , rES,   0,     0,     0,         0x07,  0,    0            },\r
1109 {xPOP   , rSS,   0,     0,     0,         0x17,  0,    0            },\r
1110 {xPOP   , rFS,   0,     0,     qP0F,      0xa1,  0,    0            },\r
1111 {xPOP   , rGS,   0,     0,     qP0F,      0xa9,  0,    0            },\r
1112 {xPOPA  , 0,     0,     0,     0,         0x61,  0,    0            },\r
1113 {xPOPAD , 0,     0,     0,     0,         0x61,  0,    0            },\r
1114 {xPOPF  , 0,     0,     0,     0,         0x9d,  0,    0            },\r
1115 {xPOPFD , 0,     0,     0,     0,         0x9d,  0,    0            },\r
1116 {xPUSH  , mem,   0,     0,     0,         0xff,  0x30, zMOP         },\r
1117 {xPUSH  , rRGW,  0,     0,     0,         0x50,  0,    zAR1         },\r
1118 {xPUSH  , ims8,  0,     0,     0,         0x6a,  0,    0            },\r
1119 {xPUSH  , immX,  0,     0,     0,         0x68,  0,    0            },\r
1120 {xPUSH  , rCS,   0,     0,     0,         0x0e,  0,    0            },\r
1121 {xPUSH  , rSS,   0,     0,     0,         0x16,  0,    0            },\r
1122 {xPUSH  , rDS,   0,     0,     0,         0x1e,  0,    0            },\r
1123 {xPUSH  , rES,   0,     0,     0,         0x06,  0,    0            },\r
1124 {xPUSH  , rFS,   0,     0,     qP0F,      0xa0,  0,    0            },\r
1125 {xPUSH  , rGS,   0,     0,     qP0F,      0xa8,  0,    0            },\r
1126 {xPUSHA , 0,     0,     0,     0,         0x60,  0,    0            },\r
1127 {xPUSHAD, 0,     0,     0,     0,         0x60,  0,    0            },\r
1128 {xPUSHF , 0,     0,     0,     0,         0x9c,  0,    0            },\r
1129 {xPUSHFD, 0,     0,     0,     0,         0x9c,  0,    0            },\r
1130 {xRCL   , rRM,   immv1, 0,     0,         0xd0,  0x10, zMOP|zORD|zSIZ },\r
1131 {xRCL   , rRM,   rCL,   0,     0,         0xd2,  0x10, zMOP|zORD|zSIZ },\r
1132 {xRCL   , rRM,   imm8,  0,     0,         0xc0,  0x10, zMOP|zORD|zSIZ },\r
1133 {xRCR   , rRM,   immv1, 0,     0,         0xd0,  0x18, zMOP|zORD|zSIZ },\r
1134 {xRCR   , rRM,   rCL,   0,     0,         0xd2,  0x18, zMOP|zORD|zSIZ },\r
1135 {xRCR   , rRM,   imm8,  0,     0,         0xc0,  0x18, zMOP|zORD|zSIZ },\r
1136 {xROL   , rRM,   immv1, 0,     0,         0xd0,  0,    zMOP|zORD|zSIZ },\r
1137 {xROL   , rRM,   rCL,   0,     0,         0xd2,  0,    zMOP|zORD|zSIZ },\r
1138 {xROL   , rRM,   imm8,  0,     0,         0xc0,  0,    zMOP|zORD|zSIZ },\r
1139 {xROR   , rRM,   immv1, 0,     0,         0xd0,  0x08, zMOP|zORD|zSIZ },\r
1140 {xROR   , rRM,   rCL,   0,     0,         0xd2,  0x08, zMOP|zORD|zSIZ },\r
1141 {xROR   , rRM,   imm8,  0,     0,         0xc0,  0x08, zMOP|zORD|zSIZ },\r
1142 {xREP   , 0,     0,     0,     0,         0xf3,  0,    0            },\r
1143 {xREPE  , 0,     0,     0,     0,         0xf3,  0,    0            },\r
1144 {xREPNE , 0,     0,     0,     0,         0xf2,  0,    0            },\r
1145 {xRETN  , 0,     0,     0,     0,         0xc3,  0,    0            },\r
1146 {xRETN  , imm16, 0,     0,     0,         0xc2,  0,    0            },\r
1147 {xRETF  , 0,     0,     0,     0,         0xcb,  0,    0            },\r
1148 {xRETF  , imm16, 0,     0,     0,         0xca,  0,    0            },\r
1149 {xSAL   , rRM,   immv1, 0,     0,         0xd0,  0x20, zMOP|zORD|zSIZ },\r
1150 {xSAL   , rRM,   rCL,   0,     0,         0xd2,  0x20, zMOP|zORD|zSIZ },\r
1151 {xSAL   , rRM,   imm8,  0,     0,         0xc0,  0x20, zMOP|zORD|zSIZ },\r
1152 {xSAR   , rRM,   immv1, 0,     0,         0xd0,  0x38, zMOP|zORD|zSIZ },\r
1153 {xSAR   , rRM,   rCL,   0,     0,         0xd2,  0x38, zMOP|zORD|zSIZ },\r
1154 {xSAR   , rRM,   imm8,  0,     0,         0xc0,  0x38, zMOP|zORD|zSIZ },\r
1155 {xSHL   , rRM,   immv1, 0,     0,         0xd0,  0x20, zMOP|zORD|zSIZ },\r
1156 {xSHL   , rRM,   rCL,   0,     0,         0xd2,  0x20, zMOP|zORD|zSIZ },\r
1157 {xSHL   , rRM,   imm8,  0,     0,         0xc0,  0x20, zMOP|zORD|zSIZ },\r
1158 {xSHR   , rRM,   immv1, 0,     0,         0xd0,  0x28, zMOP|zORD|zSIZ },\r
1159 {xSHR   , rRM,   rCL,   0,     0,         0xd2,  0x28, zMOP|zORD|zSIZ },\r
1160 {xSHR   , rRM,   imm8,  0,     0,         0xc0,  0x28, zMOP|zORD|zSIZ },\r
1161 \r
1162 {xSBB   , rRMW,  ims8,  0,     0,         0x83,  0x18, zMOP         },\r
1163 {xSBB   , rACC,  immX,  0,     0,         0x1c,  0,    zORD         },\r
1164 {xSBB   , rRM,   immX,  0,     0,         0x80,  0x18, zMOP|zORD    },\r
1165 {xSBB   , rREG,  rRM,   0,     0,         0x1a,  0,    zMR1|zORD    },\r
1166 {xSBB   , rRM,   rREG,  0,     0,         0x18,  0,    zMR2|zORD    },\r
1167 \r
1168 {xSCASB , 0,     0,     0,     0,         0xae,  0,    0            },\r
1169 {xSCASD , 0,     0,     0,     0,         0xaf,  0,    0            },\r
1170 {xSCASW , 0,     0,     0,     qUW,       0xaf,  0,    0            },\r
1171 {xSETA  , rm8,   0,     0,     qP0F,      0x97,  0,    zRG1         },\r
1172 {xSETAE , rm8,   0,     0,     qP0F,      0x93,  0,    zRG1         },\r
1173 {xSETB  , rm8,   0,     0,     qP0F,      0x92,  0,    zRG1         },\r
1174 {xSETBE , rm8,   0,     0,     qP0F,      0x96,  0,    zRG1         },\r
1175 {xSETC  , rm8,   0,     0,     qP0F,      0x92,  0,    zRG1         },\r
1176 {xSETE  , rm8,   0,     0,     qP0F,      0x94,  0,    zRG1         },\r
1177 {xSETG  , rm8,   0,     0,     qP0F,      0x9F,  0,    zRG1         },\r
1178 {xSETGE , rm8,   0,     0,     qP0F,      0x9D,  0,    zRG1         },\r
1179 {xSETL  , rm8,   0,     0,     qP0F,      0x9C,  0,    zRG1         },\r
1180 {xSETLE , rm8,   0,     0,     qP0F,      0x9E,  0,    zRG1         },\r
1181 {xSETNA , rm8,   0,     0,     qP0F,      0x96,  0,    zRG1         },\r
1182 {xSETNAE, rm8,   0,     0,     qP0F,      0x92,  0,    zRG1         },\r
1183 {xSETNB , rm8,   0,     0,     qP0F,      0x93,  0,    zRG1         },\r
1184 {xSETNBE, rm8,   0,     0,     qP0F,      0x97,  0,    zRG1         },\r
1185 {xSETNC , rm8,   0,     0,     qP0F,      0x93,  0,    zRG1         },\r
1186 {xSETNE , rm8,   0,     0,     qP0F,      0x95,  0,    zRG1         },\r
1187 {xSETNG , rm8,   0,     0,     qP0F,      0x9E,  0,    zRG1         },\r
1188 {xSETNGE, rm8,   0,     0,     qP0F,      0x9C,  0,    zRG1         },\r
1189 {xSETNL , rm8,   0,     0,     qP0F,      0x9D,  0,    zRG1         },\r
1190 {xSETNLE, rm8,   0,     0,     qP0F,      0x9F,  0,    zRG1         },\r
1191 {xSETNO , rm8,   0,     0,     qP0F,      0x91,  0,    zRG1         },\r
1192 {xSETNP , rm8,   0,     0,     qP0F,      0x9B,  0,    zRG1         },\r
1193 {xSETNS , rm8,   0,     0,     qP0F,      0x99,  0,    zRG1         },\r
1194 {xSETNZ , rm8,   0,     0,     qP0F,      0x95,  0,    zRG1         },\r
1195 {xSETO  , rm8,   0,     0,     qP0F,      0x90,  0,    zRG1         },\r
1196 {xSETP  , rm8,   0,     0,     qP0F,      0x9A,  0,    zRG1         },\r
1197 {xSETPE , rm8,   0,     0,     qP0F,      0x9A,  0,    zRG1         },\r
1198 {xSETPO , rm8,   0,     0,     qP0F,      0x9B,  0,    zRG1         },\r
1199 {xSETS  , rm8,   0,     0,     qP0F,      0x98,  0,    zRG1         },\r
1200 {xSETZ  , rm8,   0,     0,     qP0F,      0x94,  0,    zRG1         },\r
1201 {xSGDT  , memF,  0,     0,     qP0F,      0x01,  0,    zMOP         },\r
1202 {xSIDT  , memF,  0,     0,     qP0F,      0x01,  0x08, zMOP         },\r
1203 {xSHLD  , rRMW,  rRGW,  imm8,  qP0F,      0xa4,  0,    0            },\r
1204 {xSHLD  , rRMW,  rRGW,  rCL,   qP0F,      0xa5,  0,    0            },\r
1205 {xSHRD  , rRMW,  rRGW,  imm8,  qP0F,      0xac,  0,    0            },\r
1206 {xSHRD  , rRMW,  rRGW,  rCL,   qP0F,      0xad,  0,    0            },\r
1207 {xSLDT  , rm16,  0,     0,     qP0F,      0x00,  0,    zMOP         },\r
1208 {xSMSW  , rm16,  0,     0,     qP0F,      0x01,  0x20, zMOP         },\r
1209 {xSTC   , 0,     0,     0,     0,         0xf9,  0,    0            },\r
1210 {xSTI   , 0,     0,     0,     0,         0xfb,  0,    0            },\r
1211 {xSTD   , 0,     0,     0,     0,         0xfd,  0,    0            },\r
1212 {xSTOSB , 0,     0,     0,     0,         0xaa,  0,    0            },\r
1213 {xSTOSD , 0,     0,     0,     0,         0xab,  0,    0            },\r
1214 {xSTOSW , 0,     0,     0,     qUW,       0xab,  0,    0            },\r
1215 {xSTR   , rm16,  0,     0,     qP0F,      0x00,  0x08, zMOP         },\r
1216 \r
1217 {xSUB   , rRMW,  ims8,  0,     0,         0x83,  0x28, zMOP         },\r
1218 {xSUB   , rACC,  immX,  0,     0,         0x2c,  0,    zORD         },\r
1219 {xSUB   , rRM,   immX,  0,     0,         0x80,  0x28, zMOP|zORD    },\r
1220 {xSUB   , rREG,  rRM,   0,     0,         0x2a,  0,    zMR1|zORD    },\r
1221 {xSUB   , rRM,   rREG,  0,     0,         0x28,  0,    zMR2|zORD    },\r
1222 \r
1223 {xTEST  , rACC,  immX,  0,     0,         0xa8,  0,    zORD         },\r
1224 {xTEST  , rRM,   immX,  0,     0,         0xf6,  0,    zMOP|zORD    },\r
1225 {xTEST  , rREG,  rRM,   0,     0,         0x84,  0,    zMR1|zORD    },\r
1226 {xVERR  , rm16,  0,     0,     qP0F,      0x00,  0x20, zMOP         },\r
1227 {xVERW  , rm16,  0,     0,     qP0F,      0x00,  0x28, zMOP         },\r
1228 {xWAIT  , 0,     0,     0,     0,         0x9b,  0,    0            },\r
1229 {xXCHG  , r16,   rAX,   0,     0,         0x90,  0,    zAR1         },\r
1230 {xXCHG  , rAX,   r16,   0,     0,         0x90,  0,    zAR2         },\r
1231 {xXCHG  , r32,   rEAX,  0,     0,         0x90,  0,    zAR1         },\r
1232 {xXCHG  , rEAX,  r32,   0,     0,         0x90,  0,    zAR2         },\r
1233 {xXCHG  , rRM,   rREG,  0,     0,         0x86,  0,    zMR2|zORD    },\r
1234 {xXCHG  , rREG,  rRM,   0,     0,         0x86,  0,    zMR1|zORD    },\r
1235 {xXLAT  , mem,   0,     0,     0,         0x00,  0,    0            },\r
1236 {xXLATB , 0,     0,     0,     0,         0x00,  0,    0            },\r
1237 \r
1238 {xXOR   , rRMW,  ims8,  0,     0,         0x83,  0x30, zMOP         },\r
1239 {xXOR   , rACC,  immX,  0,     0,         0x34,  0,    zORD         },\r
1240 {xXOR   , rRM,   immX,  0,     0,         0x80,  0x30, zMOP|zORD    },\r
1241 {xXOR   , rREG,  rRM,   0,     0,         0x32,  0,    zMR1|zORD    },\r
1242 {xXOR   , rRM,   rREG,  0,     0,         0x30,  0,    zMR2|zORD    },\r
1243 };\r
1244 \r
1245 /* END of instruction sequence definitions  */\r
1246 \r
1247 /* This table provides look-up instructions on building the ModR/M and\r
1248    SIB bytes (optional) for all memory references.\r
1249    THIS IS ONLY FOR MEMORY REFERENCES.\r
1250    The Mod value in this table can be ORed to the ModR/M byte\r
1251    and SS value in this table can be ORed to the SIB byte\r
1252    for the instruction you're building.\r
1253 */\r
1254 \r
1255 \r
1256 #define fBase   0x01\r
1257 #define fIndx   0x02    /* fScale = 1 by default when fIndx is present */\r
1258 #define fScale2 0x04\r
1259 #define fScale4 0x08\r
1260 #define fScale8 0x10\r
1261 #define fDisp8  0x20\r
1262 #define fDisp32 0x40\r
1263 \r
1264 #define UseSIB  1\r
1265 #define nrgM32 20\r
1266 \r
1267 U8 rgM32[20][4] = {\r
1268 /*                                    UseSIB  Mod   SS */\r
1269 {   0,                                 0,    0x00, 0x00 },\r
1270 {   fBase,                             0,    0x00, 0x00 },\r
1271 {   fBase | fIndx,                     1,    0x04, 0x00 },\r
1272 {   fIndx | fScale2,                   1,    0x04, 0x40 },\r
1273 {   fIndx | fScale4,                   1,    0x04, 0x80 },\r
1274 {   fIndx | fScale8,                   1,    0x04, 0xC0 },\r
1275 {   fDisp32,                           0,    0x05, 0x00 },\r
1276 {   fBase | fIndx | fScale2,           1,    0x04, 0x40 },\r
1277 {   fBase | fIndx | fScale4,           1,    0x04, 0x80 },\r
1278 {   fBase | fIndx | fScale8,           1,    0x04, 0xC0 },\r
1279 {   fBase | fDisp8,                    0,    0x40, 0x00 },\r
1280 {   fBase | fDisp32,                   0,    0x80, 0x00 },\r
1281 {   fBase | fIndx | fDisp8,            1,    0x44, 0x00 },\r
1282 {   fBase | fIndx | fDisp32,           1,    0x84, 0x00 },\r
1283 {   fBase | fIndx | fScale2 | fDisp8,  1,    0x44, 0x40 },\r
1284 {   fBase | fIndx | fScale4 | fDisp8,  1,    0x44, 0x80 },\r
1285 {   fBase | fIndx | fScale8 | fDisp8,  1,    0x44, 0xC0 },\r
1286 {   fBase | fIndx | fScale2 | fDisp32, 1,    0x84, 0x40 },\r
1287 {   fBase | fIndx | fScale4 | fDisp32, 1,    0x84, 0x80 },\r
1288 {   fBase | fIndx | fScale8 | fDisp32, 1,    0x84, 0xC0 },\r
1289 };\r
1290 \r
1291 \r
1292 /* The following 16 bit addressing modes are recognized: */\r
1293 /* UseSIB is always 0 in 16 bit addressing modes */\r
1294 \r
1295 #define nrgM16 24\r
1296 \r
1297 int rgM16[24][8] = {\r
1298 \r
1299 /*                                        UseSIB  Mod     SS */\r
1300         {rBX,    rSI,    0,     0,   0,   0,     0,      0},\r
1301         {rBX,    rDI,    0,     0,   0,   0,     0,      0},\r
1302         {rBP,    rSI,    0,     0,   0,   0,     0,      0},\r
1303         {rBP,    rDI,    0,     0,   0,   0,     0,      0},\r
1304         {rSI,    0,      0,     0,   0,   0,     0,      0},\r
1305         {rDI,    0,      0,     0,   0,   0,     0,      0},\r
1306         {val16,  0,      0,     0,   0,   0,     0,      0},\r
1307         {rBX,    0,      0,     0,   0,   0,     0,      0},\r
1308         {rBX,    rSI,    val8,  0,   0,   0,     0,      0},\r
1309         {rBX,    rDI,    val8,  0,   0,   0,     0,      0},\r
1310         {rBP,    rSI,    val8,  0,   0,   0,     0,      0},\r
1311         {rBP,    rDI,    val8,  0,   0,   0,     0,      0},\r
1312         {rSI,    val8,   0,     0,   0,   0,     0,      0},\r
1313         {rDI,    val8,   0,         0,   0,   0,     0,      0},\r
1314         {rBP,    val8,   0,         0,   0,   0,     0,      0},\r
1315         {rBX,    val8,   0,         0,   0,   0,     0,      0},\r
1316         {rBX,    rSI,    val16, 0,   0,   0,     0,      0},\r
1317         {rBX,    rDI,    val16, 0,   0,   0,     0,      0},\r
1318         {rBP,    rSI,    val16, 0,   0,   0,     0,      0},\r
1319         {rBP,    rDI,    val16, 0,   0,   0,     0,      0},\r
1320         {rSI,    val16,  0,     0,   0,   0,     0,      0},\r
1321         {rDI,    val16,  0,         0,   0,   0,     0,      0},\r
1322         {rBP,    val16,  0,         0,   0,   0,     0,      0},\r
1323         {rBX,    val16,  0,     0,   0,   0,     0,      0},\r
1324         };\r
1325 \r
1326 /* End of memory Look-up tables */\r
1327 \r
1328 /* The following flag bits are used to determine memory operand size\r
1329    either by looking at the register involved, or by seeing the user\r
1330    force the size with WORD PTR (etc.).  They are put in variable\r
1331    OpSize and used by the functions that encode the instruction.\r
1332 */\r
1333 \r
1334 #define fByte  0x01\r
1335 #define fWord  0x02\r
1336 #define fDWord 0x04\r
1337 #define fFWord 0x08\r
1338 #define fNear  0x10\r
1339 #define fFar   0x20\r
1340 #define fShort 0x40\r
1341 #define fPtr   0x80             /* not currently used... */\r
1342 \r
1343 /* The following flag bits are used to determine if a register prefix\r
1344    was specified as part of a memory address. The flag bits are set in\r
1345    char variable OpPrefix.\r
1346 */\r
1347 \r
1348 #define fDSp   0x01\r
1349 #define fESp   0x02\r
1350 #define fSSp   0x04\r
1351 #define fFSp   0x08\r
1352 #define fGSp   0x10\r
1353 #define fCSp   0x20\r
1354 \r
1355 /*  END OF HEADER FILE */\r