Changeset 609 for branches/GNU/src/binutils/opcodes/i386-dis.c
- Timestamp:
- Aug 16, 2003, 6:59:22 PM (22 years ago)
- File:
-
- 1 edited
Legend:
- Unmodified
- Added
- Removed
-
branches/GNU/src/binutils/opcodes/i386-dis.c
-
Property cvs2svn:cvs-rev
changed from
1.1to1.1.1.2
r608 r609 1 1 /* Print i386 instructions for GDB, the GNU debugger. 2 2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2001 4 Free Software Foundation, Inc. 3 2001, 2002, 2003 Free Software Foundation, Inc. 5 4 6 5 This file is part of GDB. … … 51 50 52 51 static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *)); 53 54 struct dis_private 55 { 52 static void ckprefix PARAMS ((void)); 53 static const char *prefix_name PARAMS ((int, int)); 54 static int print_insn PARAMS ((bfd_vma, disassemble_info *)); 55 static void dofloat PARAMS ((int)); 56 static void OP_ST PARAMS ((int, int)); 57 static void OP_STi PARAMS ((int, int)); 58 static int putop PARAMS ((const char *, int)); 59 static void oappend PARAMS ((const char *)); 60 static void append_seg PARAMS ((void)); 61 static void OP_indirE PARAMS ((int, int)); 62 static void print_operand_value PARAMS ((char *, int, bfd_vma)); 63 static void OP_E PARAMS ((int, int)); 64 static void OP_G PARAMS ((int, int)); 65 static bfd_vma get64 PARAMS ((void)); 66 static bfd_signed_vma get32 PARAMS ((void)); 67 static bfd_signed_vma get32s PARAMS ((void)); 68 static int get16 PARAMS ((void)); 69 static void set_op PARAMS ((bfd_vma, int)); 70 static void OP_REG PARAMS ((int, int)); 71 static void OP_IMREG PARAMS ((int, int)); 72 static void OP_I PARAMS ((int, int)); 73 static void OP_I64 PARAMS ((int, int)); 74 static void OP_sI PARAMS ((int, int)); 75 static void OP_J PARAMS ((int, int)); 76 static void OP_SEG PARAMS ((int, int)); 77 static void OP_DIR PARAMS ((int, int)); 78 static void OP_OFF PARAMS ((int, int)); 79 static void OP_OFF64 PARAMS ((int, int)); 80 static void ptr_reg PARAMS ((int, int)); 81 static void OP_ESreg PARAMS ((int, int)); 82 static void OP_DSreg PARAMS ((int, int)); 83 static void OP_C PARAMS ((int, int)); 84 static void OP_D PARAMS ((int, int)); 85 static void OP_T PARAMS ((int, int)); 86 static void OP_Rd PARAMS ((int, int)); 87 static void OP_MMX PARAMS ((int, int)); 88 static void OP_XMM PARAMS ((int, int)); 89 static void OP_EM PARAMS ((int, int)); 90 static void OP_EX PARAMS ((int, int)); 91 static void OP_MS PARAMS ((int, int)); 92 static void OP_XS PARAMS ((int, int)); 93 static void OP_3DNowSuffix PARAMS ((int, int)); 94 static void OP_SIMD_Suffix PARAMS ((int, int)); 95 static void SIMD_Fixup PARAMS ((int, int)); 96 static void BadOp PARAMS ((void)); 97 98 struct dis_private { 56 99 /* Points to first byte not fetched. */ 57 100 bfd_byte *max_fetched; 58 101 bfd_byte the_buffer[MAXLEN]; 59 102 bfd_vma insn_start; 103 int orig_sizeflag; 60 104 jmp_buf bailout; 61 105 }; … … 113 157 on error. */ 114 158 #define FETCH_DATA(info, addr) \ 115 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \159 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \ 116 160 ? 1 : fetch_data ((info), (addr))) 117 161 … … 122 166 { 123 167 int status; 124 struct dis_private *priv = (struct dis_private *) info->private_data;168 struct dis_private *priv = (struct dis_private *) info->private_data; 125 169 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 126 170 … … 132 176 { 133 177 /* If we did manage to read at least one byte, then 134 135 136 178 print_insn_i386 will do something sensible. Otherwise, print 179 an error. We do that here because this is where we know 180 STATUS. */ 137 181 if (priv->max_fetched == priv->the_buffer) 138 182 (*info->memory_error_func) (status, start, info); … … 149 193 #define Ev OP_E, v_mode 150 194 #define Ed OP_E, d_mode 195 #define Edq OP_E, dq_mode 151 196 #define indirEb OP_indirE, b_mode 152 197 #define indirEv OP_indirE, v_mode 153 198 #define Ew OP_E, w_mode 154 199 #define Ma OP_E, v_mode 155 #define M OP_E, 0 /* lea */200 #define M OP_E, 0 /* lea, lgdt, etc. */ 156 201 #define Mp OP_E, 0 /* 32 or 48 bit memory operand for LDS, LES etc */ 157 202 #define Gb OP_G, b_mode … … 255 300 256 301 /* bits in sizeflag */ 257 #if 0 /* leave undefined until someone adds the extra flag to objdump */258 302 #define SUFFIX_ALWAYS 4 259 #endif260 303 #define AFLAG 2 261 304 #define DFLAG 1 262 263 typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag));264 265 static void OP_E PARAMS ((int, int));266 static void OP_G PARAMS ((int, int));267 static void OP_I PARAMS ((int, int));268 static void OP_I64 PARAMS ((int, int));269 static void OP_OFF PARAMS ((int, int));270 static void OP_REG PARAMS ((int, int));271 static void OP_IMREG PARAMS ((int, int));272 static void OP_OFF64 PARAMS ((int, int));273 static void OP_indirE PARAMS ((int, int));274 static void OP_sI PARAMS ((int, int));275 static void OP_REG PARAMS ((int, int));276 static void OP_J PARAMS ((int, int));277 static void OP_DIR PARAMS ((int, int));278 static void OP_OFF PARAMS ((int, int));279 static void OP_ESreg PARAMS ((int, int));280 static void OP_DSreg PARAMS ((int, int));281 static void OP_SEG PARAMS ((int, int));282 static void OP_C PARAMS ((int, int));283 static void OP_D PARAMS ((int, int));284 static void OP_T PARAMS ((int, int));285 static void OP_Rd PARAMS ((int, int));286 static void OP_ST PARAMS ((int, int));287 static void OP_STi PARAMS ((int, int));288 static void OP_MMX PARAMS ((int, int));289 static void OP_XMM PARAMS ((int, int));290 static void OP_EM PARAMS ((int, int));291 static void OP_EX PARAMS ((int, int));292 static void OP_MS PARAMS ((int, int));293 static void OP_XS PARAMS ((int, int));294 static void OP_3DNowSuffix PARAMS ((int, int));295 static void OP_SIMD_Suffix PARAMS ((int, int));296 static void SIMD_Fixup PARAMS ((int, int));297 298 static void append_seg PARAMS ((void));299 static void set_op PARAMS ((unsigned int op, int));300 static void putop PARAMS ((const char *template, int sizeflag));301 static void dofloat PARAMS ((int sizeflag));302 static int get16 PARAMS ((void));303 static bfd_vma get64 PARAMS ((void));304 static bfd_signed_vma get32 PARAMS ((void));305 static bfd_signed_vma get32s PARAMS ((void));306 static void ckprefix PARAMS ((void));307 static const char *prefix_name PARAMS ((int, int));308 static void ptr_reg PARAMS ((int, int));309 static void BadOp PARAMS ((void));310 305 311 306 #define b_mode 1 /* byte operand */ … … 318 313 #define cond_jump_mode 8 319 314 #define loop_jcxz_mode 9 315 #define dq_mode 10 /* operand size depends on REX prefixes. */ 320 316 321 317 #define es_reg 100 … … 364 360 #define indir_dx_reg 150 365 361 366 #define USE_GROUPS 1 367 #define USE_PREFIX_USER_TABLE 2 368 369 #define GRP1b NULL, NULL, 0, NULL, USE_GROUPS, NULL, 0 370 #define GRP1S NULL, NULL, 1, NULL, USE_GROUPS, NULL, 0 371 #define GRP1Ss NULL, NULL, 2, NULL, USE_GROUPS, NULL, 0 372 #define GRP2b NULL, NULL, 3, NULL, USE_GROUPS, NULL, 0 373 #define GRP2S NULL, NULL, 4, NULL, USE_GROUPS, NULL, 0 374 #define GRP2b_one NULL, NULL, 5, NULL, USE_GROUPS, NULL, 0 375 #define GRP2S_one NULL, NULL, 6, NULL, USE_GROUPS, NULL, 0 376 #define GRP2b_cl NULL, NULL, 7, NULL, USE_GROUPS, NULL, 0 377 #define GRP2S_cl NULL, NULL, 8, NULL, USE_GROUPS, NULL, 0 378 #define GRP3b NULL, NULL, 9, NULL, USE_GROUPS, NULL, 0 379 #define GRP3S NULL, NULL, 10, NULL, USE_GROUPS, NULL, 0 380 #define GRP4 NULL, NULL, 11, NULL, USE_GROUPS, NULL, 0 381 #define GRP5 NULL, NULL, 12, NULL, USE_GROUPS, NULL, 0 382 #define GRP6 NULL, NULL, 13, NULL, USE_GROUPS, NULL, 0 383 #define GRP7 NULL, NULL, 14, NULL, USE_GROUPS, NULL, 0 384 #define GRP8 NULL, NULL, 15, NULL, USE_GROUPS, NULL, 0 385 #define GRP9 NULL, NULL, 16, NULL, USE_GROUPS, NULL, 0 386 #define GRP10 NULL, NULL, 17, NULL, USE_GROUPS, NULL, 0 387 #define GRP11 NULL, NULL, 18, NULL, USE_GROUPS, NULL, 0 388 #define GRP12 NULL, NULL, 19, NULL, USE_GROUPS, NULL, 0 389 #define GRP13 NULL, NULL, 20, NULL, USE_GROUPS, NULL, 0 390 #define GRP14 NULL, NULL, 21, NULL, USE_GROUPS, NULL, 0 391 #define GRPAMD NULL, NULL, 22, NULL, USE_GROUPS, NULL, 0 392 393 #define PREGRP0 NULL, NULL, 0, NULL, USE_PREFIX_USER_TABLE, NULL, 0 394 #define PREGRP1 NULL, NULL, 1, NULL, USE_PREFIX_USER_TABLE, NULL, 0 395 #define PREGRP2 NULL, NULL, 2, NULL, USE_PREFIX_USER_TABLE, NULL, 0 396 #define PREGRP3 NULL, NULL, 3, NULL, USE_PREFIX_USER_TABLE, NULL, 0 397 #define PREGRP4 NULL, NULL, 4, NULL, USE_PREFIX_USER_TABLE, NULL, 0 398 #define PREGRP5 NULL, NULL, 5, NULL, USE_PREFIX_USER_TABLE, NULL, 0 399 #define PREGRP6 NULL, NULL, 6, NULL, USE_PREFIX_USER_TABLE, NULL, 0 400 #define PREGRP7 NULL, NULL, 7, NULL, USE_PREFIX_USER_TABLE, NULL, 0 401 #define PREGRP8 NULL, NULL, 8, NULL, USE_PREFIX_USER_TABLE, NULL, 0 402 #define PREGRP9 NULL, NULL, 9, NULL, USE_PREFIX_USER_TABLE, NULL, 0 403 #define PREGRP10 NULL, NULL, 10, NULL, USE_PREFIX_USER_TABLE, NULL, 0 404 #define PREGRP11 NULL, NULL, 11, NULL, USE_PREFIX_USER_TABLE, NULL, 0 405 #define PREGRP12 NULL, NULL, 12, NULL, USE_PREFIX_USER_TABLE, NULL, 0 406 #define PREGRP13 NULL, NULL, 13, NULL, USE_PREFIX_USER_TABLE, NULL, 0 407 #define PREGRP14 NULL, NULL, 14, NULL, USE_PREFIX_USER_TABLE, NULL, 0 408 #define PREGRP15 NULL, NULL, 15, NULL, USE_PREFIX_USER_TABLE, NULL, 0 409 #define PREGRP16 NULL, NULL, 16, NULL, USE_PREFIX_USER_TABLE, NULL, 0 410 #define PREGRP17 NULL, NULL, 17, NULL, USE_PREFIX_USER_TABLE, NULL, 0 411 #define PREGRP18 NULL, NULL, 18, NULL, USE_PREFIX_USER_TABLE, NULL, 0 412 #define PREGRP19 NULL, NULL, 19, NULL, USE_PREFIX_USER_TABLE, NULL, 0 413 #define PREGRP20 NULL, NULL, 20, NULL, USE_PREFIX_USER_TABLE, NULL, 0 414 #define PREGRP21 NULL, NULL, 21, NULL, USE_PREFIX_USER_TABLE, NULL, 0 415 #define PREGRP22 NULL, NULL, 22, NULL, USE_PREFIX_USER_TABLE, NULL, 0 416 #define PREGRP23 NULL, NULL, 23, NULL, USE_PREFIX_USER_TABLE, NULL, 0 417 #define PREGRP24 NULL, NULL, 24, NULL, USE_PREFIX_USER_TABLE, NULL, 0 418 #define PREGRP25 NULL, NULL, 25, NULL, USE_PREFIX_USER_TABLE, NULL, 0 419 #define PREGRP26 NULL, NULL, 26, NULL, USE_PREFIX_USER_TABLE, NULL, 0 420 421 #define FLOATCODE 50 422 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 362 #define FLOATCODE 1 363 #define USE_GROUPS 2 364 #define USE_PREFIX_USER_TABLE 3 365 #define X86_64_SPECIAL 4 366 367 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 368 369 #define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0 370 #define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0 371 #define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0 372 #define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0 373 #define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0 374 #define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0 375 #define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0 376 #define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0 377 #define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0 378 #define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0 379 #define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0 380 #define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0 381 #define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0 382 #define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0 383 #define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0 384 #define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0 385 #define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0 386 #define GRP10 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0 387 #define GRP11 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0 388 #define GRP12 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0 389 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0 390 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0 391 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0 392 393 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0 394 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0 395 #define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0 396 #define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0 397 #define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0 398 #define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0 399 #define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0 400 #define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0 401 #define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0 402 #define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0 403 #define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0 404 #define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0 405 #define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0 406 #define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0 407 #define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0 408 #define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0 409 #define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0 410 #define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0 411 #define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0 412 #define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0 413 #define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0 414 #define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0 415 #define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0 416 #define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0 417 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0 418 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0 419 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0 420 421 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0 422 423 typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag)); 423 424 424 425 struct dis386 { … … 437 438 'E' => print 'e' if 32-bit form of jcxz 438 439 'F' => print 'w' or 'l' depending on address size prefix (loop insns) 440 'H' => print ",pt" or ",pn" branch hint 439 441 'L' => print 'l' if suffix_always is true 440 442 'N' => print 'n' if instruction has no wait "prefix" 441 443 'O' => print 'd', or 'o' 442 444 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix, 443 or suffix_always is true 444 print 'q' if rex prefix is present. 445 'I' => print 'q' in 64bit mode and behave as 'P' otherwise 446 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always is true 445 . or suffix_always is true. print 'q' if rex prefix is present. 446 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always 447 . is true 447 448 'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode) 448 449 'S' => print 'w', 'l' or 'q' if suffix_always is true 449 'T' => print 'q' in 64bit mode and behave as 'I' otherwise 450 'T' => print 'q' in 64bit mode and behave as 'P' otherwise 451 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise 450 452 'X' => print 's', 'd' depending on data16 prefix (for XMM) 451 453 'W' => print 'b' or 'w' ("w" or "de" in intel mode) 452 454 'Y' => 'q' if instruction has an REX 64bit overwrite prefix 455 456 Many of the above letters print nothing in Intel mode. See "putop" 457 for the details. 458 459 Braces '{' and '}', and vertical bars '|', indicate alternative 460 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel 461 modes. In cases where there are only two alternatives, the X86_64 462 instruction is reserved, and "(bad)" is printed. 453 463 */ 454 464 455 static const struct dis386 dis386 _att[] = {465 static const struct dis386 dis386[] = { 456 466 /* 00 */ 457 { "addB", Eb, Gb, XX },458 { "addS", Ev, Gv, XX },459 { "addB", Gb, Eb, XX },460 { "addS", Gv, Ev, XX },461 { "addB", AL, Ib, XX },462 { "addS", eAX, Iv, XX },463 { "push I",es, XX, XX },464 { "pop I",es, XX, XX },467 { "addB", Eb, Gb, XX }, 468 { "addS", Ev, Gv, XX }, 469 { "addB", Gb, Eb, XX }, 470 { "addS", Gv, Ev, XX }, 471 { "addB", AL, Ib, XX }, 472 { "addS", eAX, Iv, XX }, 473 { "push{T|}", es, XX, XX }, 474 { "pop{T|}", es, XX, XX }, 465 475 /* 08 */ 466 { "orB", Eb, Gb, XX },467 { "orS", Ev, Gv, XX },468 { "orB", Gb, Eb, XX },469 { "orS", Gv, Ev, XX },470 { "orB", AL, Ib, XX },471 { "orS", eAX, Iv, XX },472 { "push I",cs, XX, XX },473 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */476 { "orB", Eb, Gb, XX }, 477 { "orS", Ev, Gv, XX }, 478 { "orB", Gb, Eb, XX }, 479 { "orS", Gv, Ev, XX }, 480 { "orB", AL, Ib, XX }, 481 { "orS", eAX, Iv, XX }, 482 { "push{T|}", cs, XX, XX }, 483 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ 474 484 /* 10 */ 475 { "adcB", Eb, Gb, XX },476 { "adcS", Ev, Gv, XX },477 { "adcB", Gb, Eb, XX },478 { "adcS", Gv, Ev, XX },479 { "adcB", AL, Ib, XX },480 { "adcS", eAX, Iv, XX },481 { "push I",ss, XX, XX },482 { "pop I",ss, XX, XX },485 { "adcB", Eb, Gb, XX }, 486 { "adcS", Ev, Gv, XX }, 487 { "adcB", Gb, Eb, XX }, 488 { "adcS", Gv, Ev, XX }, 489 { "adcB", AL, Ib, XX }, 490 { "adcS", eAX, Iv, XX }, 491 { "push{T|}", ss, XX, XX }, 492 { "popT|}", ss, XX, XX }, 483 493 /* 18 */ 484 { "sbbB", Eb, Gb, XX },485 { "sbbS", Ev, Gv, XX },486 { "sbbB", Gb, Eb, XX },487 { "sbbS", Gv, Ev, XX },488 { "sbbB", AL, Ib, XX },489 { "sbbS", eAX, Iv, XX },490 { "push I",ds, XX, XX },491 { "pop I",ds, XX, XX },494 { "sbbB", Eb, Gb, XX }, 495 { "sbbS", Ev, Gv, XX }, 496 { "sbbB", Gb, Eb, XX }, 497 { "sbbS", Gv, Ev, XX }, 498 { "sbbB", AL, Ib, XX }, 499 { "sbbS", eAX, Iv, XX }, 500 { "push{T|}", ds, XX, XX }, 501 { "pop{T|}", ds, XX, XX }, 492 502 /* 20 */ 493 { "andB", Eb, Gb, XX },494 { "andS", Ev, Gv, XX },495 { "andB", Gb, Eb, XX },496 { "andS", Gv, Ev, XX },497 { "andB", AL, Ib, XX },498 { "andS", eAX, Iv, XX },499 { "(bad)", XX, XX, XX },/* SEG ES prefix */500 { "daa ",XX, XX, XX },503 { "andB", Eb, Gb, XX }, 504 { "andS", Ev, Gv, XX }, 505 { "andB", Gb, Eb, XX }, 506 { "andS", Gv, Ev, XX }, 507 { "andB", AL, Ib, XX }, 508 { "andS", eAX, Iv, XX }, 509 { "(bad)", XX, XX, XX }, /* SEG ES prefix */ 510 { "daa{|}", XX, XX, XX }, 501 511 /* 28 */ 502 { "subB", Eb, Gb, XX },503 { "subS", Ev, Gv, XX },504 { "subB", Gb, Eb, XX },505 { "subS", Gv, Ev, XX },506 { "subB", AL, Ib, XX },507 { "subS", eAX, Iv, XX },508 { "(bad)", XX, XX, XX },/* SEG CS prefix */509 { "das ",XX, XX, XX },512 { "subB", Eb, Gb, XX }, 513 { "subS", Ev, Gv, XX }, 514 { "subB", Gb, Eb, XX }, 515 { "subS", Gv, Ev, XX }, 516 { "subB", AL, Ib, XX }, 517 { "subS", eAX, Iv, XX }, 518 { "(bad)", XX, XX, XX }, /* SEG CS prefix */ 519 { "das{|}", XX, XX, XX }, 510 520 /* 30 */ 511 { "xorB", Eb, Gb, XX },512 { "xorS", Ev, Gv, XX },513 { "xorB", Gb, Eb, XX },514 { "xorS", Gv, Ev, XX },515 { "xorB", AL, Ib, XX },516 { "xorS", eAX, Iv, XX },517 { "(bad)", XX, XX, XX },/* SEG SS prefix */518 { "aaa ",XX, XX, XX },521 { "xorB", Eb, Gb, XX }, 522 { "xorS", Ev, Gv, XX }, 523 { "xorB", Gb, Eb, XX }, 524 { "xorS", Gv, Ev, XX }, 525 { "xorB", AL, Ib, XX }, 526 { "xorS", eAX, Iv, XX }, 527 { "(bad)", XX, XX, XX }, /* SEG SS prefix */ 528 { "aaa{|}", XX, XX, XX }, 519 529 /* 38 */ 520 { "cmpB", Eb, Gb, XX },521 { "cmpS", Ev, Gv, XX },522 { "cmpB", Gb, Eb, XX },523 { "cmpS", Gv, Ev, XX },524 { "cmpB", AL, Ib, XX },525 { "cmpS", eAX, Iv, XX },526 { "(bad)", XX, XX, XX },/* SEG DS prefix */527 { "aas ",XX, XX, XX },530 { "cmpB", Eb, Gb, XX }, 531 { "cmpS", Ev, Gv, XX }, 532 { "cmpB", Gb, Eb, XX }, 533 { "cmpS", Gv, Ev, XX }, 534 { "cmpB", AL, Ib, XX }, 535 { "cmpS", eAX, Iv, XX }, 536 { "(bad)", XX, XX, XX }, /* SEG DS prefix */ 537 { "aas{|}", XX, XX, XX }, 528 538 /* 40 */ 529 { "inc S",RMeAX, XX, XX },530 { "inc S",RMeCX, XX, XX },531 { "inc S",RMeDX, XX, XX },532 { "inc S",RMeBX, XX, XX },533 { "inc S",RMeSP, XX, XX },534 { "inc S",RMeBP, XX, XX },535 { "inc S",RMeSI, XX, XX },536 { "inc S",RMeDI, XX, XX },539 { "inc{S|}", RMeAX, XX, XX }, 540 { "inc{S|}", RMeCX, XX, XX }, 541 { "inc{S|}", RMeDX, XX, XX }, 542 { "inc{S|}", RMeBX, XX, XX }, 543 { "inc{S|}", RMeSP, XX, XX }, 544 { "inc{S|}", RMeBP, XX, XX }, 545 { "inc{S|}", RMeSI, XX, XX }, 546 { "inc{S|}", RMeDI, XX, XX }, 537 547 /* 48 */ 538 { "dec S",RMeAX, XX, XX },539 { "dec S",RMeCX, XX, XX },540 { "dec S",RMeDX, XX, XX },541 { "dec S",RMeBX, XX, XX },542 { "dec S",RMeSP, XX, XX },543 { "dec S",RMeBP, XX, XX },544 { "dec S",RMeSI, XX, XX },545 { "dec S",RMeDI, XX, XX },548 { "dec{S|}", RMeAX, XX, XX }, 549 { "dec{S|}", RMeCX, XX, XX }, 550 { "dec{S|}", RMeDX, XX, XX }, 551 { "dec{S|}", RMeBX, XX, XX }, 552 { "dec{S|}", RMeSP, XX, XX }, 553 { "dec{S|}", RMeBP, XX, XX }, 554 { "dec{S|}", RMeSI, XX, XX }, 555 { "dec{S|}", RMeDI, XX, XX }, 546 556 /* 50 */ 547 { "pushS", RMeAX, XX, XX },548 { "pushS", RMeCX, XX, XX },549 { "pushS", RMeDX, XX, XX },550 { "pushS", RMeBX, XX, XX },551 { "pushS", RMeSP, XX, XX },552 { "pushS", RMeBP, XX, XX },553 { "pushS", RMeSI, XX, XX },554 { "pushS", RMeDI, XX, XX },557 { "pushS", RMrAX, XX, XX }, 558 { "pushS", RMrCX, XX, XX }, 559 { "pushS", RMrDX, XX, XX }, 560 { "pushS", RMrBX, XX, XX }, 561 { "pushS", RMrSP, XX, XX }, 562 { "pushS", RMrBP, XX, XX }, 563 { "pushS", RMrSI, XX, XX }, 564 { "pushS", RMrDI, XX, XX }, 555 565 /* 58 */ 556 { "popS", RMeAX, XX, XX },557 { "popS", RMeCX, XX, XX },558 { "popS", RMeDX, XX, XX },559 { "popS", RMeBX, XX, XX },560 { "popS", RMeSP, XX, XX },561 { "popS", RMeBP, XX, XX },562 { "popS", RMeSI, XX, XX },563 { "popS", RMeDI, XX, XX },566 { "popS", RMrAX, XX, XX }, 567 { "popS", RMrCX, XX, XX }, 568 { "popS", RMrDX, XX, XX }, 569 { "popS", RMrBX, XX, XX }, 570 { "popS", RMrSP, XX, XX }, 571 { "popS", RMrBP, XX, XX }, 572 { "popS", RMrSI, XX, XX }, 573 { "popS", RMrDI, XX, XX }, 564 574 /* 60 */ 565 { "pusha P", XX, XX, XX },566 { "popa P",XX, XX, XX },567 { "bound S", Gv, Ma, XX },568 { "arpl", Ew, Gw, XX},569 { "(bad)", XX, XX, XX },/* seg fs */570 { "(bad)", XX, XX, XX },/* seg gs */571 { "(bad)", XX, XX, XX },/* op size prefix */572 { "(bad)", XX, XX, XX },/* adr size prefix */575 { "pusha{P|}", XX, XX, XX }, 576 { "popa{P|}", XX, XX, XX }, 577 { "bound{S|}", Gv, Ma, XX }, 578 { X86_64_0 }, 579 { "(bad)", XX, XX, XX }, /* seg fs */ 580 { "(bad)", XX, XX, XX }, /* seg gs */ 581 { "(bad)", XX, XX, XX }, /* op size prefix */ 582 { "(bad)", XX, XX, XX }, /* adr size prefix */ 573 583 /* 68 */ 574 { "push I", Iv, XX, XX }, /* 386 book wrong */575 { "imulS", Gv, Ev, Iv },576 { "push I", sIb, XX, XX }, /* push of byte really pushes 2 or 4 bytes */577 { "imulS", Gv, Ev, sIb },578 { "ins b", Yb, indirDX, XX },579 { "ins R", Yv, indirDX, XX },580 { "outs b", indirDX, Xb, XX },581 { "outs R", indirDX, Xv, XX },584 { "pushT", Iq, XX, XX }, 585 { "imulS", Gv, Ev, Iv }, 586 { "pushT", sIb, XX, XX }, 587 { "imulS", Gv, Ev, sIb }, 588 { "ins{b||b|}", Yb, indirDX, XX }, 589 { "ins{R||R|}", Yv, indirDX, XX }, 590 { "outs{b||b|}", indirDX, Xb, XX }, 591 { "outs{R||R|}", indirDX, Xv, XX }, 582 592 /* 70 */ 583 { "jo ", Jb, cond_jump_flag, XX},584 { "jno ", Jb, cond_jump_flag, XX},585 { "jb ", Jb, cond_jump_flag, XX},586 { "jae ", Jb, cond_jump_flag, XX},587 { "je ", Jb, cond_jump_flag, XX},588 { "jne ", Jb, cond_jump_flag, XX},589 { "jbe ", Jb, cond_jump_flag, XX},590 { "ja ", Jb, cond_jump_flag, XX},593 { "joH", Jb, XX, cond_jump_flag }, 594 { "jnoH", Jb, XX, cond_jump_flag }, 595 { "jbH", Jb, XX, cond_jump_flag }, 596 { "jaeH", Jb, XX, cond_jump_flag }, 597 { "jeH", Jb, XX, cond_jump_flag }, 598 { "jneH", Jb, XX, cond_jump_flag }, 599 { "jbeH", Jb, XX, cond_jump_flag }, 600 { "jaH", Jb, XX, cond_jump_flag }, 591 601 /* 78 */ 592 { "js ", Jb, cond_jump_flag, XX},593 { "jns ", Jb, cond_jump_flag, XX},594 { "jp ", Jb, cond_jump_flag, XX},595 { "jnp ", Jb, cond_jump_flag, XX},596 { "jl ", Jb, cond_jump_flag, XX},597 { "jge ", Jb, cond_jump_flag, XX},598 { "jle ", Jb, cond_jump_flag, XX},599 { "jg ", Jb, cond_jump_flag, XX},602 { "jsH", Jb, XX, cond_jump_flag }, 603 { "jnsH", Jb, XX, cond_jump_flag }, 604 { "jpH", Jb, XX, cond_jump_flag }, 605 { "jnpH", Jb, XX, cond_jump_flag }, 606 { "jlH", Jb, XX, cond_jump_flag }, 607 { "jgeH", Jb, XX, cond_jump_flag }, 608 { "jleH", Jb, XX, cond_jump_flag }, 609 { "jgH", Jb, XX, cond_jump_flag }, 600 610 /* 80 */ 601 611 { GRP1b }, 602 612 { GRP1S }, 603 { "(bad)", XX, XX, XX },613 { "(bad)", XX, XX, XX }, 604 614 { GRP1Ss }, 605 { "testB", Eb, Gb, XX },606 { "testS", Ev, Gv, XX },607 { "xchgB", Eb, Gb, XX },608 { "xchgS", Ev, Gv, XX },615 { "testB", Eb, Gb, XX }, 616 { "testS", Ev, Gv, XX }, 617 { "xchgB", Eb, Gb, XX }, 618 { "xchgS", Ev, Gv, XX }, 609 619 /* 88 */ 610 { "movB", Eb, Gb, XX },611 { "movS", Ev, Gv, XX },612 { "movB", Gb, Eb, XX },613 { "movS", Gv, Ev, XX },614 { "movQ", Ev, Sw, XX },615 { "leaS", Gv, M, XX },616 { "movQ", Sw, Ev, XX },617 { "pop T",Ev, XX, XX },620 { "movB", Eb, Gb, XX }, 621 { "movS", Ev, Gv, XX }, 622 { "movB", Gb, Eb, XX }, 623 { "movS", Gv, Ev, XX }, 624 { "movQ", Ev, Sw, XX }, 625 { "leaS", Gv, M, XX }, 626 { "movQ", Sw, Ev, XX }, 627 { "popU", Ev, XX, XX }, 618 628 /* 90 */ 619 { "nop", XX, XX, XX },629 { "nop", XX, XX, XX }, 620 630 /* FIXME: NOP with REPz prefix is called PAUSE. */ 621 { "xchgS", RMeCX, eAX, XX },622 { "xchgS", RMeDX, eAX, XX },623 { "xchgS", RMeBX, eAX, XX },624 { "xchgS", RMeSP, eAX, XX },625 { "xchgS", RMeBP, eAX, XX },626 { "xchgS", RMeSI, eAX, XX },627 { "xchgS", RMeDI, eAX, XX },631 { "xchgS", RMeCX, eAX, XX }, 632 { "xchgS", RMeDX, eAX, XX }, 633 { "xchgS", RMeBX, eAX, XX }, 634 { "xchgS", RMeSP, eAX, XX }, 635 { "xchgS", RMeBP, eAX, XX }, 636 { "xchgS", RMeSI, eAX, XX }, 637 { "xchgS", RMeDI, eAX, XX }, 628 638 /* 98 */ 629 { "cW tR", XX, XX, XX },630 { "cR tO", XX, XX, XX },631 { "lcall I", Ap, XX, XX },632 { "(bad)", XX, XX, XX },/* fwait */633 { "pushf I",XX, XX, XX },634 { "popf I",XX, XX, XX },635 { "sahf ",XX, XX, XX },636 { "lahf ",XX, XX, XX },639 { "cW{tR||tR|}", XX, XX, XX }, 640 { "cR{tO||tO|}", XX, XX, XX }, 641 { "lcall{T|}", Ap, XX, XX }, 642 { "(bad)", XX, XX, XX }, /* fwait */ 643 { "pushfT", XX, XX, XX }, 644 { "popfT", XX, XX, XX }, 645 { "sahf{|}", XX, XX, XX }, 646 { "lahf{|}", XX, XX, XX }, 637 647 /* a0 */ 638 { "movB", AL, Ob, XX },639 { "movS", eAX, Ov, XX },640 { "movB", Ob, AL, XX },641 { "movS", Ov, eAX, XX },642 { "movs b", Yb, Xb, XX },643 { "movs R", Yv, Xv, XX },644 { "cmps b", Xb, Yb, XX },645 { "cmps R", Xv, Yv, XX },648 { "movB", AL, Ob64, XX }, 649 { "movS", eAX, Ov64, XX }, 650 { "movB", Ob64, AL, XX }, 651 { "movS", Ov64, eAX, XX }, 652 { "movs{b||b|}", Yb, Xb, XX }, 653 { "movs{R||R|}", Yv, Xv, XX }, 654 { "cmps{b||b|}", Xb, Yb, XX }, 655 { "cmps{R||R|}", Xv, Yv, XX }, 646 656 /* a8 */ 647 { "testB", AL, Ib, XX },648 { "testS", eAX, Iv, XX },649 { "stosB", Yb, AL, XX },650 { "stosS", Yv, eAX, XX },651 { "lodsB", AL, Xb, XX },652 { "lodsS", eAX, Xv, XX },653 { "scasB", AL, Yb, XX },654 { "scasS", eAX, Yv, XX },657 { "testB", AL, Ib, XX }, 658 { "testS", eAX, Iv, XX }, 659 { "stosB", Yb, AL, XX }, 660 { "stosS", Yv, eAX, XX }, 661 { "lodsB", AL, Xb, XX }, 662 { "lodsS", eAX, Xv, XX }, 663 { "scasB", AL, Yb, XX }, 664 { "scasS", eAX, Yv, XX }, 655 665 /* b0 */ 656 { "movB", RMAL, Ib, XX },657 { "movB", RMCL, Ib, XX },658 { "movB", RMDL, Ib, XX },659 { "movB", RMBL, Ib, XX },660 { "movB", RMAH, Ib, XX },661 { "movB", RMCH, Ib, XX },662 { "movB", RMDH, Ib, XX },663 { "movB", RMBH, Ib, XX },666 { "movB", RMAL, Ib, XX }, 667 { "movB", RMCL, Ib, XX }, 668 { "movB", RMDL, Ib, XX }, 669 { "movB", RMBL, Ib, XX }, 670 { "movB", RMAH, Ib, XX }, 671 { "movB", RMCH, Ib, XX }, 672 { "movB", RMDH, Ib, XX }, 673 { "movB", RMBH, Ib, XX }, 664 674 /* b8 */ 665 { "movS", RMeAX, Iv, XX },666 { "movS", RMeCX, Iv, XX },667 { "movS", RMeDX, Iv, XX },668 { "movS", RMeBX, Iv, XX },669 { "movS", RMeSP, Iv, XX },670 { "movS", RMeBP, Iv, XX },671 { "movS", RMeSI, Iv, XX },672 { "movS", RMeDI, Iv, XX },675 { "movS", RMeAX, Iv64, XX }, 676 { "movS", RMeCX, Iv64, XX }, 677 { "movS", RMeDX, Iv64, XX }, 678 { "movS", RMeBX, Iv64, XX }, 679 { "movS", RMeSP, Iv64, XX }, 680 { "movS", RMeBP, Iv64, XX }, 681 { "movS", RMeSI, Iv64, XX }, 682 { "movS", RMeDI, Iv64, XX }, 673 683 /* c0 */ 674 684 { GRP2b }, 675 685 { GRP2S }, 676 { "ret I",Iw, XX, XX },677 { "ret I",XX, XX, XX },678 { "les S",Gv, Mp, XX },679 { "ldsS", Gv, Mp, XX },680 { "movA", Eb, Ib, XX },681 { "movQ", Ev, Iv, XX },686 { "retT", Iw, XX, XX }, 687 { "retT", XX, XX, XX }, 688 { "les{S|}", Gv, Mp, XX }, 689 { "ldsS", Gv, Mp, XX }, 690 { "movA", Eb, Ib, XX }, 691 { "movQ", Ev, Iv, XX }, 682 692 /* c8 */ 683 { "enter I",Iw, Ib, XX },684 { "leave I",XX, XX, XX },685 { "lretP", Iw, XX, XX },686 { "lretP", XX, XX, XX },687 { "int3", XX, XX, XX },688 { "int", Ib, XX, XX },689 { "into ", XX, XX, XX},690 { "iretP", XX, XX, XX },693 { "enterT", Iw, Ib, XX }, 694 { "leaveT", XX, XX, XX }, 695 { "lretP", Iw, XX, XX }, 696 { "lretP", XX, XX, XX }, 697 { "int3", XX, XX, XX }, 698 { "int", Ib, XX, XX }, 699 { "into{|}", XX, XX, XX }, 700 { "iretP", XX, XX, XX }, 691 701 /* d0 */ 692 702 { GRP2b_one }, … … 694 704 { GRP2b_cl }, 695 705 { GRP2S_cl }, 696 { "aam ",sIb, XX, XX },697 { "aad ",sIb, XX, XX },698 { "(bad)", XX, XX, XX },699 { "xlat", DSBX, XX, XX },706 { "aam{|}", sIb, XX, XX }, 707 { "aad{|}", sIb, XX, XX }, 708 { "(bad)", XX, XX, XX }, 709 { "xlat", DSBX, XX, XX }, 700 710 /* d8 */ 701 711 { FLOAT }, … … 708 718 { FLOAT }, 709 719 /* e0 */ 710 { "loopneF ", Jb, loop_jcxz_flag, XX},711 { "loopeF ", Jb, loop_jcxz_flag, XX},712 { "loopF ", Jb, loop_jcxz_flag, XX},713 { "jEcxz ", Jb, loop_jcxz_flag, XX},714 { "inB", AL, Ib, XX },715 { "inS", eAX, Ib, XX },716 { "outB", Ib, AL, XX },717 { "outS", Ib, eAX, XX },720 { "loopneFH", Jb, XX, loop_jcxz_flag }, 721 { "loopeFH", Jb, XX, loop_jcxz_flag }, 722 { "loopFH", Jb, XX, loop_jcxz_flag }, 723 { "jEcxzH", Jb, XX, loop_jcxz_flag }, 724 { "inB", AL, Ib, XX }, 725 { "inS", eAX, Ib, XX }, 726 { "outB", Ib, AL, XX }, 727 { "outS", Ib, eAX, XX }, 718 728 /* e8 */ 719 { "call I",Jv, XX, XX },720 { "jmp I",Jv, XX, XX },721 { "ljmp I",Ap, XX, XX },722 { "jmp", Jb, XX, XX },723 { "inB", AL, indirDX, XX },724 { "inS", eAX, indirDX, XX },725 { "outB", indirDX, AL, XX },726 { "outS", indirDX, eAX, XX },729 { "callT", Jv, XX, XX }, 730 { "jmpT", Jv, XX, XX }, 731 { "ljmp{T|}", Ap, XX, XX }, 732 { "jmp", Jb, XX, XX }, 733 { "inB", AL, indirDX, XX }, 734 { "inS", eAX, indirDX, XX }, 735 { "outB", indirDX, AL, XX }, 736 { "outS", indirDX, eAX, XX }, 727 737 /* f0 */ 728 { "(bad)", XX, XX, XX },/* lock prefix */729 { " (bad)",XX, XX, XX },730 { "(bad)", XX, XX, XX },/* repne */731 { "(bad)", XX, XX, XX },/* repz */732 { "hlt", XX, XX, XX },733 { "cmc", XX, XX, XX },738 { "(bad)", XX, XX, XX }, /* lock prefix */ 739 { "icebp", XX, XX, XX }, 740 { "(bad)", XX, XX, XX }, /* repne */ 741 { "(bad)", XX, XX, XX }, /* repz */ 742 { "hlt", XX, XX, XX }, 743 { "cmc", XX, XX, XX }, 734 744 { GRP3b }, 735 745 { GRP3S }, 736 746 /* f8 */ 737 { "clc", XX, XX, XX },738 { "stc", XX, XX, XX },739 { "cli", XX, XX, XX },740 { "sti", XX, XX, XX },741 { "cld", XX, XX, XX },742 { "std", XX, XX, XX },747 { "clc", XX, XX, XX }, 748 { "stc", XX, XX, XX }, 749 { "cli", XX, XX, XX }, 750 { "sti", XX, XX, XX }, 751 { "cld", XX, XX, XX }, 752 { "std", XX, XX, XX }, 743 753 { GRP4 }, 744 754 { GRP5 }, 745 755 }; 746 756 747 static const struct dis386 dis386_intel[] = { 748 /* 00 */ 749 { "add", Eb, Gb, XX }, 750 { "add", Ev, Gv, XX }, 751 { "add", Gb, Eb, XX }, 752 { "add", Gv, Ev, XX }, 753 { "add", AL, Ib, XX }, 754 { "add", eAX, Iv, XX }, 755 { "push", es, XX, XX }, 756 { "pop", es, XX, XX }, 757 /* 08 */ 758 { "or", Eb, Gb, XX }, 759 { "or", Ev, Gv, XX }, 760 { "or", Gb, Eb, XX }, 761 { "or", Gv, Ev, XX }, 762 { "or", AL, Ib, XX }, 763 { "or", eAX, Iv, XX }, 764 { "push", cs, XX, XX }, 765 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ 766 /* 10 */ 767 { "adc", Eb, Gb, XX }, 768 { "adc", Ev, Gv, XX }, 769 { "adc", Gb, Eb, XX }, 770 { "adc", Gv, Ev, XX }, 771 { "adc", AL, Ib, XX }, 772 { "adc", eAX, Iv, XX }, 773 { "push", ss, XX, XX }, 774 { "pop", ss, XX, XX }, 775 /* 18 */ 776 { "sbb", Eb, Gb, XX }, 777 { "sbb", Ev, Gv, XX }, 778 { "sbb", Gb, Eb, XX }, 779 { "sbb", Gv, Ev, XX }, 780 { "sbb", AL, Ib, XX }, 781 { "sbb", eAX, Iv, XX }, 782 { "push", ds, XX, XX }, 783 { "pop", ds, XX, XX }, 784 /* 20 */ 785 { "and", Eb, Gb, XX }, 786 { "and", Ev, Gv, XX }, 787 { "and", Gb, Eb, XX }, 788 { "and", Gv, Ev, XX }, 789 { "and", AL, Ib, XX }, 790 { "and", eAX, Iv, XX }, 791 { "(bad)", XX, XX, XX }, /* SEG ES prefix */ 792 { "daa", XX, XX, XX }, 793 /* 28 */ 794 { "sub", Eb, Gb, XX }, 795 { "sub", Ev, Gv, XX }, 796 { "sub", Gb, Eb, XX }, 797 { "sub", Gv, Ev, XX }, 798 { "sub", AL, Ib, XX }, 799 { "sub", eAX, Iv, XX }, 800 { "(bad)", XX, XX, XX }, /* SEG CS prefix */ 801 { "das", XX, XX, XX }, 802 /* 30 */ 803 { "xor", Eb, Gb, XX }, 804 { "xor", Ev, Gv, XX }, 805 { "xor", Gb, Eb, XX }, 806 { "xor", Gv, Ev, XX }, 807 { "xor", AL, Ib, XX }, 808 { "xor", eAX, Iv, XX }, 809 { "(bad)", XX, XX, XX }, /* SEG SS prefix */ 810 { "aaa", XX, XX, XX }, 811 /* 38 */ 812 { "cmp", Eb, Gb, XX }, 813 { "cmp", Ev, Gv, XX }, 814 { "cmp", Gb, Eb, XX }, 815 { "cmp", Gv, Ev, XX }, 816 { "cmp", AL, Ib, XX }, 817 { "cmp", eAX, Iv, XX }, 818 { "(bad)", XX, XX, XX }, /* SEG DS prefix */ 819 { "aas", XX, XX, XX }, 820 /* 40 */ 821 { "inc", RMeAX, XX, XX }, 822 { "inc", RMeCX, XX, XX }, 823 { "inc", RMeDX, XX, XX }, 824 { "inc", RMeBX, XX, XX }, 825 { "inc", RMeSP, XX, XX }, 826 { "inc", RMeBP, XX, XX }, 827 { "inc", RMeSI, XX, XX }, 828 { "inc", RMeDI, XX, XX }, 829 /* 48 */ 830 { "dec", RMeAX, XX, XX }, 831 { "dec", RMeCX, XX, XX }, 832 { "dec", RMeDX, XX, XX }, 833 { "dec", RMeBX, XX, XX }, 834 { "dec", RMeSP, XX, XX }, 835 { "dec", RMeBP, XX, XX }, 836 { "dec", RMeSI, XX, XX }, 837 { "dec", RMeDI, XX, XX }, 838 /* 50 */ 839 { "push", RMeAX, XX, XX }, 840 { "push", RMeCX, XX, XX }, 841 { "push", RMeDX, XX, XX }, 842 { "push", RMeBX, XX, XX }, 843 { "push", RMeSP, XX, XX }, 844 { "push", RMeBP, XX, XX }, 845 { "push", RMeSI, XX, XX }, 846 { "push", RMeDI, XX, XX }, 847 /* 58 */ 848 { "pop", RMeAX, XX, XX }, 849 { "pop", RMeCX, XX, XX }, 850 { "pop", RMeDX, XX, XX }, 851 { "pop", RMeBX, XX, XX }, 852 { "pop", RMeSP, XX, XX }, 853 { "pop", RMeBP, XX, XX }, 854 { "pop", RMeSI, XX, XX }, 855 { "pop", RMeDI, XX, XX }, 856 /* 60 */ 857 { "pusha", XX, XX, XX }, 858 { "popa", XX, XX, XX }, 859 { "bound", Gv, Ma, XX }, 860 { "arpl", Ew, Gw, XX }, 861 { "(bad)", XX, XX, XX }, /* seg fs */ 862 { "(bad)", XX, XX, XX }, /* seg gs */ 863 { "(bad)", XX, XX, XX }, /* op size prefix */ 864 { "(bad)", XX, XX, XX }, /* adr size prefix */ 865 /* 68 */ 866 { "push", Iv, XX, XX }, /* 386 book wrong */ 867 { "imul", Gv, Ev, Iv }, 868 { "push", sIb, XX, XX }, /* push of byte really pushes 2 or 4 bytes */ 869 { "imul", Gv, Ev, sIb }, 870 { "ins", Yb, indirDX, XX }, 871 { "ins", Yv, indirDX, XX }, 872 { "outs", indirDX, Xb, XX }, 873 { "outs", indirDX, Xv, XX }, 874 /* 70 */ 875 { "jo", Jb, XX, XX }, 876 { "jno", Jb, XX, XX }, 877 { "jb", Jb, XX, XX }, 878 { "jae", Jb, XX, XX }, 879 { "je", Jb, XX, XX }, 880 { "jne", Jb, XX, XX }, 881 { "jbe", Jb, XX, XX }, 882 { "ja", Jb, XX, XX }, 883 /* 78 */ 884 { "js", Jb, XX, XX }, 885 { "jns", Jb, XX, XX }, 886 { "jp", Jb, XX, XX }, 887 { "jnp", Jb, XX, XX }, 888 { "jl", Jb, XX, XX }, 889 { "jge", Jb, XX, XX }, 890 { "jle", Jb, XX, XX }, 891 { "jg", Jb, XX, XX }, 892 /* 80 */ 893 { GRP1b }, 894 { GRP1S }, 895 { "(bad)", XX, XX, XX }, 896 { GRP1Ss }, 897 { "test", Eb, Gb, XX }, 898 { "test", Ev, Gv, XX }, 899 { "xchg", Eb, Gb, XX }, 900 { "xchg", Ev, Gv, XX }, 901 /* 88 */ 902 { "mov", Eb, Gb, XX }, 903 { "mov", Ev, Gv, XX }, 904 { "mov", Gb, Eb, XX }, 905 { "mov", Gv, Ev, XX }, 906 { "mov", Ev, Sw, XX }, 907 { "lea", Gv, M, XX }, 908 { "mov", Sw, Ev, XX }, 909 { "pop", Ev, XX, XX }, 910 /* 90 */ 911 { "nop", XX, XX, XX }, 912 /* FIXME: NOP with REPz prefix is called PAUSE. */ 913 { "xchg", RMeCX, eAX, XX }, 914 { "xchg", RMeDX, eAX, XX }, 915 { "xchg", RMeBX, eAX, XX }, 916 { "xchg", RMeSP, eAX, XX }, 917 { "xchg", RMeBP, eAX, XX }, 918 { "xchg", RMeSI, eAX, XX }, 919 { "xchg", RMeDI, eAX, XX }, 920 /* 98 */ 921 { "cW", XX, XX, XX }, /* cwde and cbw */ 922 { "cR", XX, XX, XX }, /* cdq and cwd */ 923 { "lcall", Ap, XX, XX }, 924 { "(bad)", XX, XX, XX }, /* fwait */ 925 { "pushf", XX, XX, XX }, 926 { "popf", XX, XX, XX }, 927 { "sahf", XX, XX, XX }, 928 { "lahf", XX, XX, XX }, 929 /* a0 */ 930 { "mov", AL, Ob, XX }, 931 { "mov", eAX, Ov, XX }, 932 { "mov", Ob, AL, XX }, 933 { "mov", Ov, eAX, XX }, 934 { "movs", Yb, Xb, XX }, 935 { "movs", Yv, Xv, XX }, 936 { "cmps", Xb, Yb, XX }, 937 { "cmps", Xv, Yv, XX }, 938 /* a8 */ 939 { "test", AL, Ib, XX }, 940 { "test", eAX, Iv, XX }, 941 { "stos", Yb, AL, XX }, 942 { "stos", Yv, eAX, XX }, 943 { "lods", AL, Xb, XX }, 944 { "lods", eAX, Xv, XX }, 945 { "scas", AL, Yb, XX }, 946 { "scas", eAX, Yv, XX }, 947 /* b0 */ 948 { "mov", RMAL, Ib, XX }, 949 { "mov", RMCL, Ib, XX }, 950 { "mov", RMDL, Ib, XX }, 951 { "mov", RMBL, Ib, XX }, 952 { "mov", RMAH, Ib, XX }, 953 { "mov", RMCH, Ib, XX }, 954 { "mov", RMDH, Ib, XX }, 955 { "mov", RMBH, Ib, XX }, 956 /* b8 */ 957 { "mov", RMeAX, Iv, XX }, 958 { "mov", RMeCX, Iv, XX }, 959 { "mov", RMeDX, Iv, XX }, 960 { "mov", RMeBX, Iv, XX }, 961 { "mov", RMeSP, Iv, XX }, 962 { "mov", RMeBP, Iv, XX }, 963 { "mov", RMeSI, Iv, XX }, 964 { "mov", RMeDI, Iv, XX }, 965 /* c0 */ 966 { GRP2b }, 967 { GRP2S }, 968 { "ret", Iw, XX, XX }, 969 { "ret", XX, XX, XX }, 970 { "les", Gv, Mp, XX }, 971 { "lds", Gv, Mp, XX }, 972 { "mov", Eb, Ib, XX }, 973 { "mov", Ev, Iv, XX }, 974 /* c8 */ 975 { "enter", Iw, Ib, XX }, 976 { "leave", XX, XX, XX }, 977 { "lret", Iw, XX, XX }, 978 { "lret", XX, XX, XX }, 979 { "int3", XX, XX, XX }, 980 { "int", Ib, XX, XX }, 981 { "into", XX, XX, XX }, 982 { "iret", XX, XX, XX }, 983 /* d0 */ 984 { GRP2b_one }, 985 { GRP2S_one }, 986 { GRP2b_cl }, 987 { GRP2S_cl }, 988 { "aam", sIb, XX, XX }, 989 { "aad", sIb, XX, XX }, 990 { "(bad)", XX, XX, XX }, 991 { "xlat", DSBX, XX, XX }, 992 /* d8 */ 993 { FLOAT }, 994 { FLOAT }, 995 { FLOAT }, 996 { FLOAT }, 997 { FLOAT }, 998 { FLOAT }, 999 { FLOAT }, 1000 { FLOAT }, 1001 /* e0 */ 1002 { "loopne", Jb, XX, XX }, 1003 { "loope", Jb, XX, XX }, 1004 { "loop", Jb, XX, XX }, 1005 { "jEcxz", Jb, XX, XX }, 1006 { "in", AL, Ib, XX }, 1007 { "in", eAX, Ib, XX }, 1008 { "out", Ib, AL, XX }, 1009 { "out", Ib, eAX, XX }, 1010 /* e8 */ 1011 { "call", Jv, XX, XX }, 1012 { "jmp", Jv, XX, XX }, 1013 { "ljmp", Ap, XX, XX }, 1014 { "jmp", Jb, XX, XX }, 1015 { "in", AL, indirDX, XX }, 1016 { "in", eAX, indirDX, XX }, 1017 { "out", indirDX, AL, XX }, 1018 { "out", indirDX, eAX, XX }, 1019 /* f0 */ 1020 { "(bad)", XX, XX, XX }, /* lock prefix */ 1021 { "(bad)", XX, XX, XX }, 1022 { "(bad)", XX, XX, XX }, /* repne */ 1023 { "(bad)", XX, XX, XX }, /* repz */ 1024 { "hlt", XX, XX, XX }, 1025 { "cmc", XX, XX, XX }, 1026 { GRP3b }, 1027 { GRP3S }, 1028 /* f8 */ 1029 { "clc", XX, XX, XX }, 1030 { "stc", XX, XX, XX }, 1031 { "cli", XX, XX, XX }, 1032 { "sti", XX, XX, XX }, 1033 { "cld", XX, XX, XX }, 1034 { "std", XX, XX, XX }, 1035 { GRP4 }, 1036 { GRP5 }, 1037 }; 1038 1039 /* 64bit mode is having some instruction set differences, so separate table is 1040 needed. */ 1041 static const struct dis386 disx86_64_att[] = { 1042 /* 00 */ 1043 { "addB", Eb, Gb, XX }, 1044 { "addS", Ev, Gv, XX }, 1045 { "addB", Gb, Eb, XX }, 1046 { "addS", Gv, Ev, XX }, 1047 { "addB", AL, Ib, XX }, 1048 { "addS", eAX, Iv, XX }, 1049 { "(bad)", XX, XX, XX }, /* Reserved. */ 1050 { "(bad)", XX, XX, XX }, /* Reserved. */ 1051 /* 08 */ 1052 { "orB", Eb, Gb, XX }, 1053 { "orS", Ev, Gv, XX }, 1054 { "orB", Gb, Eb, XX }, 1055 { "orS", Gv, Ev, XX }, 1056 { "orB", AL, Ib, XX }, 1057 { "orS", eAX, Iv, XX }, 1058 { "(bad)", XX, XX, XX }, /* Reserved. */ 1059 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ 1060 /* 10 */ 1061 { "adcB", Eb, Gb, XX }, 1062 { "adcS", Ev, Gv, XX }, 1063 { "adcB", Gb, Eb, XX }, 1064 { "adcS", Gv, Ev, XX }, 1065 { "adcB", AL, Ib, XX }, 1066 { "adcS", eAX, Iv, XX }, 1067 { "(bad)", XX, XX, XX }, /* Reserved. */ 1068 { "(bad)", XX, XX, XX }, /* Reserved. */ 1069 /* 18 */ 1070 { "sbbB", Eb, Gb, XX }, 1071 { "sbbS", Ev, Gv, XX }, 1072 { "sbbB", Gb, Eb, XX }, 1073 { "sbbS", Gv, Ev, XX }, 1074 { "sbbB", AL, Ib, XX }, 1075 { "sbbS", eAX, Iv, XX }, 1076 { "(bad)", XX, XX, XX }, /* Reserved. */ 1077 { "(bad)", XX, XX, XX }, /* Reserved. */ 1078 /* 20 */ 1079 { "andB", Eb, Gb, XX }, 1080 { "andS", Ev, Gv, XX }, 1081 { "andB", Gb, Eb, XX }, 1082 { "andS", Gv, Ev, XX }, 1083 { "andB", AL, Ib, XX }, 1084 { "andS", eAX, Iv, XX }, 1085 { "(bad)", XX, XX, XX }, /* SEG ES prefix */ 1086 { "(bad)", XX, XX, XX }, /* Reserved. */ 1087 /* 28 */ 1088 { "subB", Eb, Gb, XX }, 1089 { "subS", Ev, Gv, XX }, 1090 { "subB", Gb, Eb, XX }, 1091 { "subS", Gv, Ev, XX }, 1092 { "subB", AL, Ib, XX }, 1093 { "subS", eAX, Iv, XX }, 1094 { "(bad)", XX, XX, XX }, /* SEG CS prefix */ 1095 { "(bad)", XX, XX, XX }, /* Reserved. */ 1096 /* 30 */ 1097 { "xorB", Eb, Gb, XX }, 1098 { "xorS", Ev, Gv, XX }, 1099 { "xorB", Gb, Eb, XX }, 1100 { "xorS", Gv, Ev, XX }, 1101 { "xorB", AL, Ib, XX }, 1102 { "xorS", eAX, Iv, XX }, 1103 { "(bad)", XX, XX, XX }, /* SEG SS prefix */ 1104 { "(bad)", XX, XX, XX }, /* Reserved. */ 1105 /* 38 */ 1106 { "cmpB", Eb, Gb, XX }, 1107 { "cmpS", Ev, Gv, XX }, 1108 { "cmpB", Gb, Eb, XX }, 1109 { "cmpS", Gv, Ev, XX }, 1110 { "cmpB", AL, Ib, XX }, 1111 { "cmpS", eAX, Iv, XX }, 1112 { "(bad)", XX, XX, XX }, /* SEG DS prefix */ 1113 { "(bad)", XX, XX, XX }, /* Reserved. */ 1114 /* 40 */ 1115 { "(bad)", XX, XX, XX }, /* REX prefix area. */ 1116 { "(bad)", XX, XX, XX }, 1117 { "(bad)", XX, XX, XX }, 1118 { "(bad)", XX, XX, XX }, 1119 { "(bad)", XX, XX, XX }, 1120 { "(bad)", XX, XX, XX }, 1121 { "(bad)", XX, XX, XX }, 1122 { "(bad)", XX, XX, XX }, 1123 /* 48 */ 1124 { "(bad)", XX, XX, XX }, 1125 { "(bad)", XX, XX, XX }, 1126 { "(bad)", XX, XX, XX }, 1127 { "(bad)", XX, XX, XX }, 1128 { "(bad)", XX, XX, XX }, 1129 { "(bad)", XX, XX, XX }, 1130 { "(bad)", XX, XX, XX }, 1131 { "(bad)", XX, XX, XX }, 1132 /* 50 */ 1133 { "pushI", RMrAX, XX, XX }, 1134 { "pushI", RMrCX, XX, XX }, 1135 { "pushI", RMrDX, XX, XX }, 1136 { "pushI", RMrBX, XX, XX }, 1137 { "pushI", RMrSP, XX, XX }, 1138 { "pushI", RMrBP, XX, XX }, 1139 { "pushI", RMrSI, XX, XX }, 1140 { "pushI", RMrDI, XX, XX }, 1141 /* 58 */ 1142 { "popI", RMrAX, XX, XX }, 1143 { "popI", RMrCX, XX, XX }, 1144 { "popI", RMrDX, XX, XX }, 1145 { "popI", RMrBX, XX, XX }, 1146 { "popI", RMrSP, XX, XX }, 1147 { "popI", RMrBP, XX, XX }, 1148 { "popI", RMrSI, XX, XX }, 1149 { "popI", RMrDI, XX, XX }, 1150 /* 60 */ 1151 { "(bad)", XX, XX, XX }, /* reserved. */ 1152 { "(bad)", XX, XX, XX }, /* reserved. */ 1153 { "(bad)", XX, XX, XX }, /* reserved. */ 1154 { "movslR", Gv, Ed, XX }, 1155 { "(bad)", XX, XX, XX }, /* seg fs */ 1156 { "(bad)", XX, XX, XX }, /* seg gs */ 1157 { "(bad)", XX, XX, XX }, /* op size prefix */ 1158 { "(bad)", XX, XX, XX }, /* adr size prefix */ 1159 /* 68 */ 1160 { "pushI", Iq, XX, XX }, /* 386 book wrong */ 1161 { "imulS", Gv, Ev, Iv }, 1162 { "pushI", sIb, XX, XX }, /* push of byte really pushes 2 or 4 bytes */ 1163 { "imulS", Gv, Ev, sIb }, 1164 { "insb", Yb, indirDX, XX }, 1165 { "insR", Yv, indirDX, XX }, 1166 { "outsb", indirDX, Xb, XX }, 1167 { "outsR", indirDX, Xv, XX }, 1168 /* 70 */ 1169 { "jo", Jb, cond_jump_flag, XX }, 1170 { "jno", Jb, cond_jump_flag, XX }, 1171 { "jb", Jb, cond_jump_flag, XX }, 1172 { "jae", Jb, cond_jump_flag, XX }, 1173 { "je", Jb, cond_jump_flag, XX }, 1174 { "jne", Jb, cond_jump_flag, XX }, 1175 { "jbe", Jb, cond_jump_flag, XX }, 1176 { "ja", Jb, cond_jump_flag, XX }, 1177 /* 78 */ 1178 { "js", Jb, cond_jump_flag, XX }, 1179 { "jns", Jb, cond_jump_flag, XX }, 1180 { "jp", Jb, cond_jump_flag, XX }, 1181 { "jnp", Jb, cond_jump_flag, XX }, 1182 { "jl", Jb, cond_jump_flag, XX }, 1183 { "jge", Jb, cond_jump_flag, XX }, 1184 { "jle", Jb, cond_jump_flag, XX }, 1185 { "jg", Jb, cond_jump_flag, XX }, 1186 /* 80 */ 1187 { GRP1b }, 1188 { GRP1S }, 1189 { "(bad)", XX, XX, XX }, 1190 { GRP1Ss }, 1191 { "testB", Eb, Gb, XX }, 1192 { "testS", Ev, Gv, XX }, 1193 { "xchgB", Eb, Gb, XX }, 1194 { "xchgS", Ev, Gv, XX }, 1195 /* 88 */ 1196 { "movB", Eb, Gb, XX }, 1197 { "movS", Ev, Gv, XX }, 1198 { "movB", Gb, Eb, XX }, 1199 { "movS", Gv, Ev, XX }, 1200 { "movQ", Ev, Sw, XX }, 1201 { "leaS", Gv, M, XX }, 1202 { "movQ", Sw, Ev, XX }, 1203 { "popI", Ev, XX, XX }, 1204 /* 90 */ 1205 { "nop", XX, XX, XX }, 1206 /* FIXME: NOP with REPz prefix is called PAUSE. */ 1207 { "xchgS", RMeCX, eAX, XX }, 1208 { "xchgS", RMeDX, eAX, XX }, 1209 { "xchgS", RMeBX, eAX, XX }, 1210 { "xchgS", RMeSP, eAX, XX }, 1211 { "xchgS", RMeBP, eAX, XX }, 1212 { "xchgS", RMeSI, eAX, XX }, 1213 { "xchgS", RMeDI, eAX, XX }, 1214 /* 98 */ 1215 { "cWtR", XX, XX, XX }, 1216 { "cRtO", XX, XX, XX }, 1217 { "(bad)", XX, XX, XX }, /* reserved. */ 1218 { "(bad)", XX, XX, XX }, /* fwait */ 1219 { "pushfI", XX, XX, XX }, 1220 { "popfI", XX, XX, XX }, 1221 { "(bad)", XX, XX, XX }, /* reserved. */ 1222 { "(bad)", XX, XX, XX }, /* reserved. */ 1223 /* a0 */ 1224 { "movB", AL, Ob64, XX }, 1225 { "movS", eAX, Ov64, XX }, 1226 { "movB", Ob64, AL, XX }, 1227 { "movS", Ov64, eAX, XX }, 1228 { "movsb", Yb, Xb, XX }, 1229 { "movsR", Yv, Xv, XX }, 1230 { "cmpsb", Xb, Yb, XX }, 1231 { "cmpsR", Xv, Yv, XX }, 1232 /* a8 */ 1233 { "testB", AL, Ib, XX }, 1234 { "testS", eAX, Iv, XX }, 1235 { "stosB", Yb, AL, XX }, 1236 { "stosS", Yv, eAX, XX }, 1237 { "lodsB", AL, Xb, XX }, 1238 { "lodsS", eAX, Xv, XX }, 1239 { "scasB", AL, Yb, XX }, 1240 { "scasS", eAX, Yv, XX }, 1241 /* b0 */ 1242 { "movB", RMAL, Ib, XX }, 1243 { "movB", RMCL, Ib, XX }, 1244 { "movB", RMDL, Ib, XX }, 1245 { "movB", RMBL, Ib, XX }, 1246 { "movB", RMAH, Ib, XX }, 1247 { "movB", RMCH, Ib, XX }, 1248 { "movB", RMDH, Ib, XX }, 1249 { "movB", RMBH, Ib, XX }, 1250 /* b8 */ 1251 { "movS", RMeAX, Iv64, XX }, 1252 { "movS", RMeCX, Iv64, XX }, 1253 { "movS", RMeDX, Iv64, XX }, 1254 { "movS", RMeBX, Iv64, XX }, 1255 { "movS", RMeSP, Iv64, XX }, 1256 { "movS", RMeBP, Iv64, XX }, 1257 { "movS", RMeSI, Iv64, XX }, 1258 { "movS", RMeDI, Iv64, XX }, 1259 /* c0 */ 1260 { GRP2b }, 1261 { GRP2S }, 1262 { "retI", Iw, XX, XX }, 1263 { "retI", XX, XX, XX }, 1264 { "(bad)", XX, XX, XX }, /* reserved. */ 1265 { "ldsS", Gv, Mp, XX }, 1266 { "movA", Eb, Ib, XX }, 1267 { "movQ", Ev, Iv, XX }, 1268 /* c8 */ 1269 { "enterI", Iw, Ib, XX }, 1270 { "leaveI", XX, XX, XX }, 1271 { "lretP", Iw, XX, XX }, 1272 { "lretP", XX, XX, XX }, 1273 { "int3", XX, XX, XX }, 1274 { "int", Ib, XX, XX }, 1275 { "(bad)", XX, XX, XX }, /* reserved. */ 1276 { "iretP", XX, XX, XX }, 1277 /* d0 */ 1278 { GRP2b_one }, 1279 { GRP2S_one }, 1280 { GRP2b_cl }, 1281 { GRP2S_cl }, 1282 { "(bad)", XX, XX, XX }, /* reserved. */ 1283 { "(bad)", XX, XX, XX }, /* reserved. */ 1284 { "(bad)", XX, XX, XX }, /* reserved. */ 1285 { "xlat", DSBX, XX, XX }, 1286 /* d8 */ 1287 { FLOAT }, 1288 { FLOAT }, 1289 { FLOAT }, 1290 { FLOAT }, 1291 { FLOAT }, 1292 { FLOAT }, 1293 { FLOAT }, 1294 { FLOAT }, 1295 /* e0 */ 1296 { "loopneF", Jb, loop_jcxz_flag, XX }, 1297 { "loopeF", Jb, loop_jcxz_flag, XX }, 1298 { "loopF", Jb, loop_jcxz_flag, XX }, 1299 { "jEcxz", Jb, loop_jcxz_flag, XX }, 1300 { "inB", AL, Ib, XX }, 1301 { "inS", eAX, Ib, XX }, 1302 { "outB", Ib, AL, XX }, 1303 { "outS", Ib, eAX, XX }, 1304 /* e8 */ 1305 { "callI", Jv, XX, XX }, 1306 { "jmpI", Jv, XX, XX }, 1307 { "(bad)", XX, XX, XX }, /* reserved. */ 1308 { "jmp", Jb, XX, XX }, 1309 { "inB", AL, indirDX, XX }, 1310 { "inS", eAX, indirDX, XX }, 1311 { "outB", indirDX, AL, XX }, 1312 { "outS", indirDX, eAX, XX }, 1313 /* f0 */ 1314 { "(bad)", XX, XX, XX }, /* lock prefix */ 1315 { "(bad)", XX, XX, XX }, 1316 { "(bad)", XX, XX, XX }, /* repne */ 1317 { "(bad)", XX, XX, XX }, /* repz */ 1318 { "hlt", XX, XX, XX }, 1319 { "cmc", XX, XX, XX }, 1320 { GRP3b }, 1321 { GRP3S }, 1322 /* f8 */ 1323 { "clc", XX, XX, XX }, 1324 { "stc", XX, XX, XX }, 1325 { "cli", XX, XX, XX }, 1326 { "sti", XX, XX, XX }, 1327 { "cld", XX, XX, XX }, 1328 { "std", XX, XX, XX }, 1329 { GRP4 }, 1330 { GRP5 }, 1331 }; 1332 1333 static const struct dis386 dis386_64_intel[] = { 1334 /* 00 */ 1335 { "add", Eb, Gb, XX }, 1336 { "add", Ev, Gv, XX }, 1337 { "add", Gb, Eb, XX }, 1338 { "add", Gv, Ev, XX }, 1339 { "add", AL, Ib, XX }, 1340 { "add", eAX, Iv, XX }, 1341 { "(bad)", XX, XX, XX }, /* Reserved. */ 1342 { "(bad)", XX, XX, XX }, /* Reserved. */ 1343 /* 08 */ 1344 { "or", Eb, Gb, XX }, 1345 { "or", Ev, Gv, XX }, 1346 { "or", Gb, Eb, XX }, 1347 { "or", Gv, Ev, XX }, 1348 { "or", AL, Ib, XX }, 1349 { "or", eAX, Iv, XX }, 1350 { "(bad)", XX, XX, XX }, /* Reserved. */ 1351 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ 1352 /* 10 */ 1353 { "adc", Eb, Gb, XX }, 1354 { "adc", Ev, Gv, XX }, 1355 { "adc", Gb, Eb, XX }, 1356 { "adc", Gv, Ev, XX }, 1357 { "adc", AL, Ib, XX }, 1358 { "adc", eAX, Iv, XX }, 1359 { "(bad)", XX, XX, XX }, /* Reserved. */ 1360 { "(bad)", XX, XX, XX }, /* Reserved. */ 1361 /* 18 */ 1362 { "sbb", Eb, Gb, XX }, 1363 { "sbb", Ev, Gv, XX }, 1364 { "sbb", Gb, Eb, XX }, 1365 { "sbb", Gv, Ev, XX }, 1366 { "sbb", AL, Ib, XX }, 1367 { "sbb", eAX, Iv, XX }, 1368 { "(bad)", XX, XX, XX }, /* Reserved. */ 1369 { "(bad)", XX, XX, XX }, /* Reserved. */ 1370 /* 20 */ 1371 { "and", Eb, Gb, XX }, 1372 { "and", Ev, Gv, XX }, 1373 { "and", Gb, Eb, XX }, 1374 { "and", Gv, Ev, XX }, 1375 { "and", AL, Ib, XX }, 1376 { "and", eAX, Iv, XX }, 1377 { "(bad)", XX, XX, XX }, /* SEG ES prefix */ 1378 { "(bad)", XX, XX, XX }, /* Reserved. */ 1379 /* 28 */ 1380 { "sub", Eb, Gb, XX }, 1381 { "sub", Ev, Gv, XX }, 1382 { "sub", Gb, Eb, XX }, 1383 { "sub", Gv, Ev, XX }, 1384 { "sub", AL, Ib, XX }, 1385 { "sub", eAX, Iv, XX }, 1386 { "(bad)", XX, XX, XX }, /* SEG CS prefix */ 1387 { "(bad)", XX, XX, XX }, /* Reserved. */ 1388 /* 30 */ 1389 { "xor", Eb, Gb, XX }, 1390 { "xor", Ev, Gv, XX }, 1391 { "xor", Gb, Eb, XX }, 1392 { "xor", Gv, Ev, XX }, 1393 { "xor", AL, Ib, XX }, 1394 { "xor", eAX, Iv, XX }, 1395 { "(bad)", XX, XX, XX }, /* SEG SS prefix */ 1396 { "(bad)", XX, XX, XX }, /* Reserved. */ 1397 /* 38 */ 1398 { "cmp", Eb, Gb, XX }, 1399 { "cmp", Ev, Gv, XX }, 1400 { "cmp", Gb, Eb, XX }, 1401 { "cmp", Gv, Ev, XX }, 1402 { "cmp", AL, Ib, XX }, 1403 { "cmp", eAX, Iv, XX }, 1404 { "(bad)", XX, XX, XX }, /* SEG DS prefix */ 1405 { "(bad)", XX, XX, XX }, /* Reserved. */ 1406 /* 40 */ 1407 { "(bad)", XX, XX, XX }, /* REX prefix area. */ 1408 { "(bad)", XX, XX, XX }, 1409 { "(bad)", XX, XX, XX }, 1410 { "(bad)", XX, XX, XX }, 1411 { "(bad)", XX, XX, XX }, 1412 { "(bad)", XX, XX, XX }, 1413 { "(bad)", XX, XX, XX }, 1414 { "(bad)", XX, XX, XX }, 1415 /* 48 */ 1416 { "(bad)", XX, XX, XX }, 1417 { "(bad)", XX, XX, XX }, 1418 { "(bad)", XX, XX, XX }, 1419 { "(bad)", XX, XX, XX }, 1420 { "(bad)", XX, XX, XX }, 1421 { "(bad)", XX, XX, XX }, 1422 { "(bad)", XX, XX, XX }, 1423 { "(bad)", XX, XX, XX }, 1424 /* 50 */ 1425 { "push", RMrAX, XX, XX }, 1426 { "push", RMrCX, XX, XX }, 1427 { "push", RMrDX, XX, XX }, 1428 { "push", RMrBX, XX, XX }, 1429 { "push", RMrSP, XX, XX }, 1430 { "push", RMrBP, XX, XX }, 1431 { "push", RMrSI, XX, XX }, 1432 { "push", RMrDI, XX, XX }, 1433 /* 58 */ 1434 { "pop", RMrAX, XX, XX }, 1435 { "pop", RMrCX, XX, XX }, 1436 { "pop", RMrDX, XX, XX }, 1437 { "pop", RMrBX, XX, XX }, 1438 { "pop", RMrSP, XX, XX }, 1439 { "pop", RMrBP, XX, XX }, 1440 { "pop", RMrSI, XX, XX }, 1441 { "pop", RMrDI, XX, XX }, 1442 /* 60 */ 1443 { "(bad)", XX, XX, XX }, /* Reserved. */ 1444 { "(bad)", XX, XX, XX }, /* Reserved. */ 1445 { "(bad)", XX, XX, XX }, /* Reserved. */ 1446 { "movsx", Gv, Ed, XX }, 1447 { "(bad)", XX, XX, XX }, /* seg fs */ 1448 { "(bad)", XX, XX, XX }, /* seg gs */ 1449 { "(bad)", XX, XX, XX }, /* op size prefix */ 1450 { "(bad)", XX, XX, XX }, /* adr size prefix */ 1451 /* 68 */ 1452 { "push", Iq, XX, XX }, /* 386 book wrong */ 1453 { "imul", Gv, Ev, Iv }, 1454 { "push", sIb, XX, XX }, /* push of byte really pushes 2 or 4 bytes */ 1455 { "imul", Gv, Ev, sIb }, 1456 { "ins", Yb, indirDX, XX }, 1457 { "ins", Yv, indirDX, XX }, 1458 { "outs", indirDX, Xb, XX }, 1459 { "outs", indirDX, Xv, XX }, 1460 /* 70 */ 1461 { "jo", Jb, XX, XX }, 1462 { "jno", Jb, XX, XX }, 1463 { "jb", Jb, XX, XX }, 1464 { "jae", Jb, XX, XX }, 1465 { "je", Jb, XX, XX }, 1466 { "jne", Jb, XX, XX }, 1467 { "jbe", Jb, XX, XX }, 1468 { "ja", Jb, XX, XX }, 1469 /* 78 */ 1470 { "js", Jb, XX, XX }, 1471 { "jns", Jb, XX, XX }, 1472 { "jp", Jb, XX, XX }, 1473 { "jnp", Jb, XX, XX }, 1474 { "jl", Jb, XX, XX }, 1475 { "jge", Jb, XX, XX }, 1476 { "jle", Jb, XX, XX }, 1477 { "jg", Jb, XX, XX }, 1478 /* 80 */ 1479 { GRP1b }, 1480 { GRP1S }, 1481 { "(bad)", XX, XX, XX }, 1482 { GRP1Ss }, 1483 { "test", Eb, Gb, XX }, 1484 { "test", Ev, Gv, XX }, 1485 { "xchg", Eb, Gb, XX }, 1486 { "xchg", Ev, Gv, XX }, 1487 /* 88 */ 1488 { "mov", Eb, Gb, XX }, 1489 { "mov", Ev, Gv, XX }, 1490 { "mov", Gb, Eb, XX }, 1491 { "mov", Gv, Ev, XX }, 1492 { "mov", Ev, Sw, XX }, 1493 { "lea", Gv, M, XX }, 1494 { "mov", Sw, Ev, XX }, 1495 { "pop", Ev, XX, XX }, 1496 /* 90 */ 1497 { "nop", XX, XX, XX }, 1498 /* FIXME: NOP with REPz prefix is called PAUSE. */ 1499 { "xchg", RMeCX, eAX, XX }, 1500 { "xchg", RMeDX, eAX, XX }, 1501 { "xchg", RMeBX, eAX, XX }, 1502 { "xchg", RMeSP, eAX, XX }, 1503 { "xchg", RMeBP, eAX, XX }, 1504 { "xchg", RMeSI, eAX, XX }, 1505 { "xchg", RMeDI, eAX, XX }, 1506 /* 98 */ 1507 { "cW", XX, XX, XX }, /* cwde and cbw */ 1508 { "cR", XX, XX, XX }, /* cdq and cwd */ 1509 { "(bad)", XX, XX, XX }, /* Reserved. */ 1510 { "(bad)", XX, XX, XX }, /* fwait */ 1511 { "pushf", XX, XX, XX }, 1512 { "popf", XX, XX, XX }, 1513 { "(bad)", XX, XX, XX }, /* Reserved. */ 1514 { "(bad)", XX, XX, XX }, /* Reserved. */ 1515 /* a0 */ 1516 { "mov", AL, Ob, XX }, 1517 { "mov", eAX, Ov, XX }, 1518 { "mov", Ob, AL, XX }, 1519 { "mov", Ov, eAX, XX }, 1520 { "movs", Yb, Xb, XX }, 1521 { "movs", Yv, Xv, XX }, 1522 { "cmps", Xb, Yb, XX }, 1523 { "cmps", Xv, Yv, XX }, 1524 /* a8 */ 1525 { "test", AL, Ib, XX }, 1526 { "test", eAX, Iv, XX }, 1527 { "stos", Yb, AL, XX }, 1528 { "stos", Yv, eAX, XX }, 1529 { "lods", AL, Xb, XX }, 1530 { "lods", eAX, Xv, XX }, 1531 { "scas", AL, Yb, XX }, 1532 { "scas", eAX, Yv, XX }, 1533 /* b0 */ 1534 { "mov", RMAL, Ib, XX }, 1535 { "mov", RMCL, Ib, XX }, 1536 { "mov", RMDL, Ib, XX }, 1537 { "mov", RMBL, Ib, XX }, 1538 { "mov", RMAH, Ib, XX }, 1539 { "mov", RMCH, Ib, XX }, 1540 { "mov", RMDH, Ib, XX }, 1541 { "mov", RMBH, Ib, XX }, 1542 /* b8 */ 1543 { "mov", RMeAX, Iv, XX }, 1544 { "mov", RMeCX, Iv, XX }, 1545 { "mov", RMeDX, Iv, XX }, 1546 { "mov", RMeBX, Iv, XX }, 1547 { "mov", RMeSP, Iv, XX }, 1548 { "mov", RMeBP, Iv, XX }, 1549 { "mov", RMeSI, Iv, XX }, 1550 { "mov", RMeDI, Iv, XX }, 1551 /* c0 */ 1552 { GRP2b }, 1553 { GRP2S }, 1554 { "ret", Iw, XX, XX }, 1555 { "ret", XX, XX, XX }, 1556 { "(bad)", XX, XX, XX }, /* Reserved. */ 1557 { "lds", Gv, Mp, XX }, 1558 { "mov", Eb, Ib, XX }, 1559 { "mov", Ev, Iv, XX }, 1560 /* c8 */ 1561 { "enter", Iw, Ib, XX }, 1562 { "leave", XX, XX, XX }, 1563 { "lret", Iw, XX, XX }, 1564 { "lret", XX, XX, XX }, 1565 { "int3", XX, XX, XX }, 1566 { "int", Ib, XX, XX }, 1567 { "(bad)", XX, XX, XX }, /* Reserved. */ 1568 { "iret", XX, XX, XX }, 1569 /* d0 */ 1570 { GRP2b_one }, 1571 { GRP2S_one }, 1572 { GRP2b_cl }, 1573 { GRP2S_cl }, 1574 { "(bad)", XX, XX, XX }, /* Reserved. */ 1575 { "(bad)", XX, XX, XX }, /* Reserved. */ 1576 { "(bad)", XX, XX, XX }, /* Reserved. */ 1577 { "xlat", DSBX, XX, XX }, 1578 /* d8 */ 1579 { FLOAT }, 1580 { FLOAT }, 1581 { FLOAT }, 1582 { FLOAT }, 1583 { FLOAT }, 1584 { FLOAT }, 1585 { FLOAT }, 1586 { FLOAT }, 1587 /* e0 */ 1588 { "loopne", Jb, XX, XX }, 1589 { "loope", Jb, XX, XX }, 1590 { "loop", Jb, XX, XX }, 1591 { "jEcxz", Jb, XX, XX }, 1592 { "in", AL, Ib, XX }, 1593 { "in", eAX, Ib, XX }, 1594 { "out", Ib, AL, XX }, 1595 { "out", Ib, eAX, XX }, 1596 /* e8 */ 1597 { "call", Jv, XX, XX }, 1598 { "jmp", Jv, XX, XX }, 1599 { "(bad)", XX, XX, XX }, /* Reserved. */ 1600 { "jmp", Jb, XX, XX }, 1601 { "in", AL, indirDX, XX }, 1602 { "in", eAX, indirDX, XX }, 1603 { "out", indirDX, AL, XX }, 1604 { "out", indirDX, eAX, XX }, 1605 /* f0 */ 1606 { "(bad)", XX, XX, XX }, /* lock prefix */ 1607 { "(bad)", XX, XX, XX }, 1608 { "(bad)", XX, XX, XX }, /* repne */ 1609 { "(bad)", XX, XX, XX }, /* repz */ 1610 { "hlt", XX, XX, XX }, 1611 { "cmc", XX, XX, XX }, 1612 { GRP3b }, 1613 { GRP3S }, 1614 /* f8 */ 1615 { "clc", XX, XX, XX }, 1616 { "stc", XX, XX, XX }, 1617 { "cli", XX, XX, XX }, 1618 { "sti", XX, XX, XX }, 1619 { "cld", XX, XX, XX }, 1620 { "std", XX, XX, XX }, 1621 { GRP4 }, 1622 { GRP5 }, 1623 }; 1624 1625 static const struct dis386 dis386_twobyte_att[] = { 757 static const struct dis386 dis386_twobyte[] = { 1626 758 /* 00 */ 1627 759 { GRP6 }, 1628 760 { GRP7 }, 1629 { "larS", 1630 { "lslS", 1631 { "(bad)", 1632 { "syscall", 1633 { "clts", 1634 { "sysretP", 761 { "larS", Gv, Ew, XX }, 762 { "lslS", Gv, Ew, XX }, 763 { "(bad)", XX, XX, XX }, 764 { "syscall", XX, XX, XX }, 765 { "clts", XX, XX, XX }, 766 { "sysretP", XX, XX, XX }, 1635 767 /* 08 */ 1636 { "invd", 1637 { "wbinvd", 1638 { "(bad)", 1639 { "ud2a", 1640 { "(bad)", 768 { "invd", XX, XX, XX }, 769 { "wbinvd", XX, XX, XX }, 770 { "(bad)", XX, XX, XX }, 771 { "ud2a", XX, XX, XX }, 772 { "(bad)", XX, XX, XX }, 1641 773 { GRPAMD }, 1642 { "femms", 1643 { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix*/774 { "femms", XX, XX, XX }, 775 { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */ 1644 776 /* 10 */ 1645 777 { PREGRP8 }, 1646 778 { PREGRP9 }, 1647 { "movlpX", XM, EX, SIMD_Fixup, 'h' },/* really only 2 operands */1648 { "movlpX", 1649 { "unpcklpX", 1650 { "unpckhpX", 1651 { "movhpX", 1652 { "movhpX", 779 { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ 780 { "movlpX", EX, XM, SIMD_Fixup, 'h' }, 781 { "unpcklpX", XM, EX, XX }, 782 { "unpckhpX", XM, EX, XX }, 783 { "movhpX", XM, EX, SIMD_Fixup, 'l' }, 784 { "movhpX", EX, XM, SIMD_Fixup, 'l' }, 1653 785 /* 18 */ 1654 786 { GRP14 }, 1655 { "(bad)", 1656 { "(bad)", 1657 { "(bad)", 1658 { "(bad)", 1659 { "(bad)", 1660 { "(bad)", 1661 { "(bad)", 787 { "(bad)", XX, XX, XX }, 788 { "(bad)", XX, XX, XX }, 789 { "(bad)", XX, XX, XX }, 790 { "(bad)", XX, XX, XX }, 791 { "(bad)", XX, XX, XX }, 792 { "(bad)", XX, XX, XX }, 793 { "(bad)", XX, XX, XX }, 1662 794 /* 20 */ 1663 /* these are all backward in appendix A of the intel book */ 1664 { "movL", Rm, Cm, XX }, 1665 { "movL", Rm, Dm, XX }, 1666 { "movL", Cm, Rm, XX }, 1667 { "movL", Dm, Rm, XX }, 1668 { "movL", Rd, Td, XX }, 1669 { "(bad)", XX, XX, XX }, 1670 { "movL", Td, Rd, XX }, 1671 { "(bad)", XX, XX, XX }, 795 { "movL", Rm, Cm, XX }, 796 { "movL", Rm, Dm, XX }, 797 { "movL", Cm, Rm, XX }, 798 { "movL", Dm, Rm, XX }, 799 { "movL", Rd, Td, XX }, 800 { "(bad)", XX, XX, XX }, 801 { "movL", Td, Rd, XX }, 802 { "(bad)", XX, XX, XX }, 1672 803 /* 28 */ 1673 { "movapX", 1674 { "movapX", 804 { "movapX", XM, EX, XX }, 805 { "movapX", EX, XM, XX }, 1675 806 { PREGRP2 }, 1676 { "movntpX", 807 { "movntpX", Ev, XM, XX }, 1677 808 { PREGRP4 }, 1678 809 { PREGRP3 }, 1679 { "ucomisX", 1680 { "comisX", 810 { "ucomisX", XM,EX, XX }, 811 { "comisX", XM,EX, XX }, 1681 812 /* 30 */ 1682 { "wrmsr", 1683 { "rdtsc", 1684 { "rdmsr", 1685 { "rdpmc", 1686 { "sysenter", 1687 { "sysexit", 1688 { "(bad)", 1689 { "(bad)", 813 { "wrmsr", XX, XX, XX }, 814 { "rdtsc", XX, XX, XX }, 815 { "rdmsr", XX, XX, XX }, 816 { "rdpmc", XX, XX, XX }, 817 { "sysenter", XX, XX, XX }, 818 { "sysexit", XX, XX, XX }, 819 { "(bad)", XX, XX, XX }, 820 { "(bad)", XX, XX, XX }, 1690 821 /* 38 */ 1691 { "(bad)", 1692 { "(bad)", 1693 { "(bad)", 1694 { "(bad)", 1695 { "(bad)", 1696 { "(bad)", 1697 { "(bad)", 1698 { "(bad)", 822 { "(bad)", XX, XX, XX }, 823 { "(bad)", XX, XX, XX }, 824 { "(bad)", XX, XX, XX }, 825 { "(bad)", XX, XX, XX }, 826 { "(bad)", XX, XX, XX }, 827 { "(bad)", XX, XX, XX }, 828 { "(bad)", XX, XX, XX }, 829 { "(bad)", XX, XX, XX }, 1699 830 /* 40 */ 1700 { "cmovo", 1701 { "cmovno", 1702 { "cmovb", 1703 { "cmovae", 1704 { "cmove", 1705 { "cmovne", 1706 { "cmovbe", 1707 { "cmova", 831 { "cmovo", Gv, Ev, XX }, 832 { "cmovno", Gv, Ev, XX }, 833 { "cmovb", Gv, Ev, XX }, 834 { "cmovae", Gv, Ev, XX }, 835 { "cmove", Gv, Ev, XX }, 836 { "cmovne", Gv, Ev, XX }, 837 { "cmovbe", Gv, Ev, XX }, 838 { "cmova", Gv, Ev, XX }, 1708 839 /* 48 */ 1709 { "cmovs", 1710 { "cmovns", 1711 { "cmovp", 1712 { "cmovnp", 1713 { "cmovl", 1714 { "cmovge", 1715 { "cmovle", 1716 { "cmovg", 840 { "cmovs", Gv, Ev, XX }, 841 { "cmovns", Gv, Ev, XX }, 842 { "cmovp", Gv, Ev, XX }, 843 { "cmovnp", Gv, Ev, XX }, 844 { "cmovl", Gv, Ev, XX }, 845 { "cmovge", Gv, Ev, XX }, 846 { "cmovle", Gv, Ev, XX }, 847 { "cmovg", Gv, Ev, XX }, 1717 848 /* 50 */ 1718 { "movmskpX", 849 { "movmskpX", Gd, XS, XX }, 1719 850 { PREGRP13 }, 1720 851 { PREGRP12 }, 1721 852 { PREGRP11 }, 1722 { "andpX", 1723 { "andnpX", 1724 { "orpX", 1725 { "xorpX", 853 { "andpX", XM, EX, XX }, 854 { "andnpX", XM, EX, XX }, 855 { "orpX", XM, EX, XX }, 856 { "xorpX", XM, EX, XX }, 1726 857 /* 58 */ 1727 858 { PREGRP0 }, … … 1734 865 { PREGRP6 }, 1735 866 /* 60 */ 1736 { "punpcklbw", 1737 { "punpcklwd", 1738 { "punpckldq", 1739 { "packsswb", 1740 { "pcmpgtb", 1741 { "pcmpgtw", 1742 { "pcmpgtd", 1743 { "packuswb", 867 { "punpcklbw", MX, EM, XX }, 868 { "punpcklwd", MX, EM, XX }, 869 { "punpckldq", MX, EM, XX }, 870 { "packsswb", MX, EM, XX }, 871 { "pcmpgtb", MX, EM, XX }, 872 { "pcmpgtw", MX, EM, XX }, 873 { "pcmpgtd", MX, EM, XX }, 874 { "packuswb", MX, EM, XX }, 1744 875 /* 68 */ 1745 { "punpckhbw", 1746 { "punpckhwd", 1747 { "punpckhdq", 1748 { "packssdw", 876 { "punpckhbw", MX, EM, XX }, 877 { "punpckhwd", MX, EM, XX }, 878 { "punpckhdq", MX, EM, XX }, 879 { "packssdw", MX, EM, XX }, 1749 880 { PREGRP26 }, 1750 881 { PREGRP24 }, 1751 { "movd", MX, Ed, XX },882 { "movd", MX, Edq, XX }, 1752 883 { PREGRP19 }, 1753 884 /* 70 */ … … 1756 887 { GRP11 }, 1757 888 { GRP12 }, 1758 { "pcmpeqb", 1759 { "pcmpeqw", 1760 { "pcmpeqd", 1761 { "emms", 889 { "pcmpeqb", MX, EM, XX }, 890 { "pcmpeqw", MX, EM, XX }, 891 { "pcmpeqd", MX, EM, XX }, 892 { "emms", XX, XX, XX }, 1762 893 /* 78 */ 1763 { "(bad)", 1764 { "(bad)", 1765 { "(bad)", 1766 { "(bad)", 1767 { "(bad)", 1768 { "(bad)", 894 { "(bad)", XX, XX, XX }, 895 { "(bad)", XX, XX, XX }, 896 { "(bad)", XX, XX, XX }, 897 { "(bad)", XX, XX, XX }, 898 { "(bad)", XX, XX, XX }, 899 { "(bad)", XX, XX, XX }, 1769 900 { PREGRP23 }, 1770 901 { PREGRP20 }, 1771 902 /* 80 */ 1772 { "jo ", Jv, cond_jump_flag, XX},1773 { "jno ", Jv, cond_jump_flag, XX},1774 { "jb ", Jv, cond_jump_flag, XX},1775 { "jae ", Jv, cond_jump_flag, XX},1776 { "je ", Jv, cond_jump_flag, XX},1777 { "jne ", Jv, cond_jump_flag, XX},1778 { "jbe ", Jv, cond_jump_flag, XX},1779 { "ja ", Jv, cond_jump_flag, XX},903 { "joH", Jv, XX, cond_jump_flag }, 904 { "jnoH", Jv, XX, cond_jump_flag }, 905 { "jbH", Jv, XX, cond_jump_flag }, 906 { "jaeH", Jv, XX, cond_jump_flag }, 907 { "jeH", Jv, XX, cond_jump_flag }, 908 { "jneH", Jv, XX, cond_jump_flag }, 909 { "jbeH", Jv, XX, cond_jump_flag }, 910 { "jaH", Jv, XX, cond_jump_flag }, 1780 911 /* 88 */ 1781 { "js ", Jv, cond_jump_flag, XX},1782 { "jns ", Jv, cond_jump_flag, XX},1783 { "jp ", Jv, cond_jump_flag, XX},1784 { "jnp ", Jv, cond_jump_flag, XX},1785 { "jl ", Jv, cond_jump_flag, XX},1786 { "jge ", Jv, cond_jump_flag, XX},1787 { "jle ", Jv, cond_jump_flag, XX},1788 { "jg ", Jv, cond_jump_flag, XX},912 { "jsH", Jv, XX, cond_jump_flag }, 913 { "jnsH", Jv, XX, cond_jump_flag }, 914 { "jpH", Jv, XX, cond_jump_flag }, 915 { "jnpH", Jv, XX, cond_jump_flag }, 916 { "jlH", Jv, XX, cond_jump_flag }, 917 { "jgeH", Jv, XX, cond_jump_flag }, 918 { "jleH", Jv, XX, cond_jump_flag }, 919 { "jgH", Jv, XX, cond_jump_flag }, 1789 920 /* 90 */ 1790 { "seto", 1791 { "setno", 1792 { "setb", 1793 { "setae", 1794 { "sete", 1795 { "setne", 1796 { "setbe", 1797 { "seta", 921 { "seto", Eb, XX, XX }, 922 { "setno", Eb, XX, XX }, 923 { "setb", Eb, XX, XX }, 924 { "setae", Eb, XX, XX }, 925 { "sete", Eb, XX, XX }, 926 { "setne", Eb, XX, XX }, 927 { "setbe", Eb, XX, XX }, 928 { "seta", Eb, XX, XX }, 1798 929 /* 98 */ 1799 { "sets", 1800 { "setns", 1801 { "setp", 1802 { "setnp", 1803 { "setl", 1804 { "setge", 1805 { "setle", 1806 { "setg", 930 { "sets", Eb, XX, XX }, 931 { "setns", Eb, XX, XX }, 932 { "setp", Eb, XX, XX }, 933 { "setnp", Eb, XX, XX }, 934 { "setl", Eb, XX, XX }, 935 { "setge", Eb, XX, XX }, 936 { "setle", Eb, XX, XX }, 937 { "setg", Eb, XX, XX }, 1807 938 /* a0 */ 1808 { "push I",fs, XX, XX },1809 { "pop I",fs, XX, XX },1810 { "cpuid", 1811 { "btS", 1812 { "shldS", 1813 { "shldS", 1814 { "(bad)", 1815 { "(bad)", 939 { "pushT", fs, XX, XX }, 940 { "popT", fs, XX, XX }, 941 { "cpuid", XX, XX, XX }, 942 { "btS", Ev, Gv, XX }, 943 { "shldS", Ev, Gv, Ib }, 944 { "shldS", Ev, Gv, CL }, 945 { "(bad)", XX, XX, XX }, 946 { "(bad)", XX, XX, XX }, 1816 947 /* a8 */ 1817 { "push I",gs, XX, XX },1818 { "pop I",gs, XX, XX },1819 { "rsm", 1820 { "btsS", 1821 { "shrdS", 1822 { "shrdS", 948 { "pushT", gs, XX, XX }, 949 { "popT", gs, XX, XX }, 950 { "rsm", XX, XX, XX }, 951 { "btsS", Ev, Gv, XX }, 952 { "shrdS", Ev, Gv, Ib }, 953 { "shrdS", Ev, Gv, CL }, 1823 954 { GRP13 }, 1824 { "imulS", 955 { "imulS", Gv, Ev, XX }, 1825 956 /* b0 */ 1826 { "cmpxchgB", 1827 { "cmpxchgS", 1828 { "lssS", 1829 { "btrS", 1830 { "lfsS", 1831 { "lgsS", 1832 { "movz bR",Gv, Eb, XX },1833 { "movz wR",Gv, Ew, XX }, /* yes, there really is movzww ! */957 { "cmpxchgB", Eb, Gb, XX }, 958 { "cmpxchgS", Ev, Gv, XX }, 959 { "lssS", Gv, Mp, XX }, 960 { "btrS", Ev, Gv, XX }, 961 { "lfsS", Gv, Mp, XX }, 962 { "lgsS", Gv, Mp, XX }, 963 { "movz{bR|x|bR|x}", Gv, Eb, XX }, 964 { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */ 1834 965 /* b8 */ 1835 { "(bad)", 1836 { "ud2b", 966 { "(bad)", XX, XX, XX }, 967 { "ud2b", XX, XX, XX }, 1837 968 { GRP8 }, 1838 { "btcS", 1839 { "bsfS", 1840 { "bsrS", 1841 { "movs bR",Gv, Eb, XX },1842 { "movs wR",Gv, Ew, XX }, /* yes, there really is movsww ! */969 { "btcS", Ev, Gv, XX }, 970 { "bsfS", Gv, Ev, XX }, 971 { "bsrS", Gv, Ev, XX }, 972 { "movs{bR|x|bR|x}", Gv, Eb, XX }, 973 { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */ 1843 974 /* c0 */ 1844 { "xaddB", 1845 { "xaddS", 975 { "xaddB", Eb, Gb, XX }, 976 { "xaddS", Ev, Gv, XX }, 1846 977 { PREGRP1 }, 1847 { "movntiS", 1848 { "pinsrw", 1849 { "pextrw", 1850 { "shufpX", 978 { "movntiS", Ev, Gv, XX }, 979 { "pinsrw", MX, Ed, Ib }, 980 { "pextrw", Gd, MS, Ib }, 981 { "shufpX", XM, EX, Ib }, 1851 982 { GRP9 }, 1852 983 /* c8 */ 1853 { "bswap", RMeAX, XX, XX }, /* bswap doesn't support 16 bit regs */1854 { "bswap", 1855 { "bswap", 1856 { "bswap", 1857 { "bswap", 1858 { "bswap", 1859 { "bswap", 1860 { "bswap", 984 { "bswap", RMeAX, XX, XX }, 985 { "bswap", RMeCX, XX, XX }, 986 { "bswap", RMeDX, XX, XX }, 987 { "bswap", RMeBX, XX, XX }, 988 { "bswap", RMeSP, XX, XX }, 989 { "bswap", RMeBP, XX, XX }, 990 { "bswap", RMeSI, XX, XX }, 991 { "bswap", RMeDI, XX, XX }, 1861 992 /* d0 */ 1862 { "(bad)", 1863 { "psrlw", 1864 { "psrld", 1865 { "psrlq", 1866 { "paddq", 1867 { "pmullw", 993 { "(bad)", XX, XX, XX }, 994 { "psrlw", MX, EM, XX }, 995 { "psrld", MX, EM, XX }, 996 { "psrlq", MX, EM, XX }, 997 { "paddq", MX, EM, XX }, 998 { "pmullw", MX, EM, XX }, 1868 999 { PREGRP21 }, 1869 { "pmovmskb", 1000 { "pmovmskb", Gd, MS, XX }, 1870 1001 /* d8 */ 1871 { "psubusb", 1872 { "psubusw", 1873 { "pminub", 1874 { "pand", 1875 { "paddusb", 1876 { "paddusw", 1877 { "pmaxub", 1878 { "pandn", 1002 { "psubusb", MX, EM, XX }, 1003 { "psubusw", MX, EM, XX }, 1004 { "pminub", MX, EM, XX }, 1005 { "pand", MX, EM, XX }, 1006 { "paddusb", MX, EM, XX }, 1007 { "paddusw", MX, EM, XX }, 1008 { "pmaxub", MX, EM, XX }, 1009 { "pandn", MX, EM, XX }, 1879 1010 /* e0 */ 1880 { "pavgb", 1881 { "psraw", 1882 { "psrad", 1883 { "pavgw", 1884 { "pmulhuw", 1885 { "pmulhw", 1011 { "pavgb", MX, EM, XX }, 1012 { "psraw", MX, EM, XX }, 1013 { "psrad", MX, EM, XX }, 1014 { "pavgw", MX, EM, XX }, 1015 { "pmulhuw", MX, EM, XX }, 1016 { "pmulhw", MX, EM, XX }, 1886 1017 { PREGRP15 }, 1887 1018 { PREGRP25 }, 1888 1019 /* e8 */ 1889 { "psubsb", 1890 { "psubsw", 1891 { "pminsw", 1892 { "por", 1893 { "paddsb", 1894 { "paddsw", 1895 { "pmaxsw", 1896 { "pxor", 1020 { "psubsb", MX, EM, XX }, 1021 { "psubsw", MX, EM, XX }, 1022 { "pminsw", MX, EM, XX }, 1023 { "por", MX, EM, XX }, 1024 { "paddsb", MX, EM, XX }, 1025 { "paddsw", MX, EM, XX }, 1026 { "pmaxsw", MX, EM, XX }, 1027 { "pxor", MX, EM, XX }, 1897 1028 /* f0 */ 1898 { "(bad)", 1899 { "psllw", 1900 { "pslld", 1901 { "psllq", 1902 { "pmuludq", 1903 { "pmaddwd", 1904 { "psadbw", 1029 { "(bad)", XX, XX, XX }, 1030 { "psllw", MX, EM, XX }, 1031 { "pslld", MX, EM, XX }, 1032 { "psllq", MX, EM, XX }, 1033 { "pmuludq", MX, EM, XX }, 1034 { "pmaddwd", MX, EM, XX }, 1035 { "psadbw", MX, EM, XX }, 1905 1036 { PREGRP18 }, 1906 1037 /* f8 */ 1907 { "psubb", MX, EM, XX }, 1908 { "psubw", MX, EM, XX }, 1909 { "psubd", MX, EM, XX }, 1910 { "psubq", MX, EM, XX }, 1911 { "paddb", MX, EM, XX }, 1912 { "paddw", MX, EM, XX }, 1913 { "paddd", MX, EM, XX }, 1914 { "(bad)", XX, XX, XX } 1915 }; 1916 1917 static const struct dis386 dis386_twobyte_intel[] = { 1918 /* 00 */ 1919 { GRP6 }, 1920 { GRP7 }, 1921 { "lar", Gv, Ew, XX }, 1922 { "lsl", Gv, Ew, XX }, 1923 { "(bad)", XX, XX, XX }, 1924 { "syscall", XX, XX, XX }, 1925 { "clts", XX, XX, XX }, 1926 { "sysretP", XX, XX, XX }, 1927 /* 08 */ 1928 { "invd", XX, XX, XX }, 1929 { "wbinvd", XX, XX, XX }, 1930 { "(bad)", XX, XX, XX }, 1931 { "ud2a", XX, XX, XX }, 1932 { "(bad)", XX, XX, XX }, 1933 { GRPAMD }, 1934 { "femms" , XX, XX, XX}, 1935 { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix */ 1936 /* 10 */ 1937 { PREGRP8 }, 1938 { PREGRP9 }, 1939 { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ 1940 { "movlpX", EX, XM, SIMD_Fixup, 'h' }, 1941 { "unpcklpX", XM, EX, XX }, 1942 { "unpckhpX", XM, EX, XX }, 1943 { "movhpX", XM, EX, SIMD_Fixup, 'l' }, 1944 { "movhpX", EX, XM, SIMD_Fixup, 'l' }, 1945 /* 18 */ 1946 { GRP14 }, 1947 { "(bad)", XX, XX, XX }, 1948 { "(bad)", XX, XX, XX }, 1949 { "(bad)", XX, XX, XX }, 1950 { "(bad)", XX, XX, XX }, 1951 { "(bad)", XX, XX, XX }, 1952 { "(bad)", XX, XX, XX }, 1953 { "(bad)", XX, XX, XX }, 1954 /* 20 */ 1955 /* these are all backward in appendix A of the intel book */ 1956 { "mov", Rm, Cm, XX }, 1957 { "mov", Rm, Dm, XX }, 1958 { "mov", Cm, Rm, XX }, 1959 { "mov", Dm, Rm, XX }, 1960 { "mov", Rd, Td, XX }, 1961 { "(bad)", XX, XX, XX }, 1962 { "mov", Td, Rd, XX }, 1963 { "(bad)", XX, XX, XX }, 1964 /* 28 */ 1965 { "movapX", XM, EX, XX }, 1966 { "movapX", EX, XM, XX }, 1967 { PREGRP2 }, 1968 { "movntpX", Ev, XM, XX }, 1969 { PREGRP4 }, 1970 { PREGRP3 }, 1971 { "ucomisX", XM,EX, XX }, 1972 { "comisX", XM,EX, XX }, 1973 /* 30 */ 1974 { "wrmsr", XX, XX, XX }, 1975 { "rdtsc", XX, XX, XX }, 1976 { "rdmsr", XX, XX, XX }, 1977 { "rdpmc", XX, XX, XX }, 1978 { "sysenter", XX, XX, XX }, 1979 { "sysexit", XX, XX, XX }, 1980 { "(bad)", XX, XX, XX }, 1981 { "(bad)", XX, XX, XX }, 1982 /* 38 */ 1983 { "(bad)", XX, XX, XX }, 1984 { "(bad)", XX, XX, XX }, 1985 { "(bad)", XX, XX, XX }, 1986 { "(bad)", XX, XX, XX }, 1987 { "(bad)", XX, XX, XX }, 1988 { "(bad)", XX, XX, XX }, 1989 { "(bad)", XX, XX, XX }, 1990 { "(bad)", XX, XX, XX }, 1991 /* 40 */ 1992 { "cmovo", Gv, Ev, XX }, 1993 { "cmovno", Gv, Ev, XX }, 1994 { "cmovb", Gv, Ev, XX }, 1995 { "cmovae", Gv, Ev, XX }, 1996 { "cmove", Gv, Ev, XX }, 1997 { "cmovne", Gv, Ev, XX }, 1998 { "cmovbe", Gv, Ev, XX }, 1999 { "cmova", Gv, Ev, XX }, 2000 /* 48 */ 2001 { "cmovs", Gv, Ev, XX }, 2002 { "cmovns", Gv, Ev, XX }, 2003 { "cmovp", Gv, Ev, XX }, 2004 { "cmovnp", Gv, Ev, XX }, 2005 { "cmovl", Gv, Ev, XX }, 2006 { "cmovge", Gv, Ev, XX }, 2007 { "cmovle", Gv, Ev, XX }, 2008 { "cmovg", Gv, Ev, XX }, 2009 /* 50 */ 2010 { "movmskpX", Gd, XS, XX }, 2011 { PREGRP13 }, 2012 { PREGRP12 }, 2013 { PREGRP11 }, 2014 { "andpX", XM, EX, XX }, 2015 { "andnpX", XM, EX, XX }, 2016 { "orpX", XM, EX, XX }, 2017 { "xorpX", XM, EX, XX }, 2018 /* 58 */ 2019 { PREGRP0 }, 2020 { PREGRP10 }, 2021 { PREGRP17 }, 2022 { PREGRP16 }, 2023 { PREGRP14 }, 2024 { PREGRP7 }, 2025 { PREGRP5 }, 2026 { PREGRP6 }, 2027 /* 60 */ 2028 { "punpcklbw", MX, EM, XX }, 2029 { "punpcklwd", MX, EM, XX }, 2030 { "punpckldq", MX, EM, XX }, 2031 { "packsswb", MX, EM, XX }, 2032 { "pcmpgtb", MX, EM, XX }, 2033 { "pcmpgtw", MX, EM, XX }, 2034 { "pcmpgtd", MX, EM, XX }, 2035 { "packuswb", MX, EM, XX }, 2036 /* 68 */ 2037 { "punpckhbw", MX, EM, XX }, 2038 { "punpckhwd", MX, EM, XX }, 2039 { "punpckhdq", MX, EM, XX }, 2040 { "packssdw", MX, EM, XX }, 2041 { PREGRP26 }, 2042 { PREGRP24 }, 2043 { "movd", MX, Ed, XX }, 2044 { PREGRP19 }, 2045 /* 70 */ 2046 { PREGRP22 }, 2047 { GRP10 }, 2048 { GRP11 }, 2049 { GRP12 }, 2050 { "pcmpeqb", MX, EM, XX }, 2051 { "pcmpeqw", MX, EM, XX }, 2052 { "pcmpeqd", MX, EM, XX }, 2053 { "emms", XX, XX, XX }, 2054 /* 78 */ 2055 { "(bad)", XX, XX, XX }, 2056 { "(bad)", XX, XX, XX }, 2057 { "(bad)", XX, XX, XX }, 2058 { "(bad)", XX, XX, XX }, 2059 { "(bad)", XX, XX, XX }, 2060 { "(bad)", XX, XX, XX }, 2061 { PREGRP23 }, 2062 { PREGRP20 }, 2063 /* 80 */ 2064 { "jo", Jv, XX, XX }, 2065 { "jno", Jv, XX, XX }, 2066 { "jb", Jv, XX, XX }, 2067 { "jae", Jv, XX, XX }, 2068 { "je", Jv, XX, XX }, 2069 { "jne", Jv, XX, XX }, 2070 { "jbe", Jv, XX, XX }, 2071 { "ja", Jv, XX, XX }, 2072 /* 88 */ 2073 { "js", Jv, XX, XX }, 2074 { "jns", Jv, XX, XX }, 2075 { "jp", Jv, XX, XX }, 2076 { "jnp", Jv, XX, XX }, 2077 { "jl", Jv, XX, XX }, 2078 { "jge", Jv, XX, XX }, 2079 { "jle", Jv, XX, XX }, 2080 { "jg", Jv, XX, XX }, 2081 /* 90 */ 2082 { "seto", Eb, XX, XX }, 2083 { "setno", Eb, XX, XX }, 2084 { "setb", Eb, XX, XX }, 2085 { "setae", Eb, XX, XX }, 2086 { "sete", Eb, XX, XX }, 2087 { "setne", Eb, XX, XX }, 2088 { "setbe", Eb, XX, XX }, 2089 { "seta", Eb, XX, XX }, 2090 /* 98 */ 2091 { "sets", Eb, XX, XX }, 2092 { "setns", Eb, XX, XX }, 2093 { "setp", Eb, XX, XX }, 2094 { "setnp", Eb, XX, XX }, 2095 { "setl", Eb, XX, XX }, 2096 { "setge", Eb, XX, XX }, 2097 { "setle", Eb, XX, XX }, 2098 { "setg", Eb, XX, XX }, 2099 /* a0 */ 2100 { "push", fs, XX, XX }, 2101 { "pop", fs, XX, XX }, 2102 { "cpuid", XX, XX, XX }, 2103 { "bt", Ev, Gv, XX }, 2104 { "shld", Ev, Gv, Ib }, 2105 { "shld", Ev, Gv, CL }, 2106 { "(bad)", XX, XX, XX }, 2107 { "(bad)", XX, XX, XX }, 2108 /* a8 */ 2109 { "push", gs, XX, XX }, 2110 { "pop", gs, XX, XX }, 2111 { "rsm" , XX, XX, XX}, 2112 { "bts", Ev, Gv, XX }, 2113 { "shrd", Ev, Gv, Ib }, 2114 { "shrd", Ev, Gv, CL }, 2115 { GRP13 }, 2116 { "imul", Gv, Ev, XX }, 2117 /* b0 */ 2118 { "cmpxchg", Eb, Gb, XX }, 2119 { "cmpxchg", Ev, Gv, XX }, 2120 { "lss", Gv, Mp, XX }, 2121 { "btr", Ev, Gv, XX }, 2122 { "lfs", Gv, Mp, XX }, 2123 { "lgs", Gv, Mp, XX }, 2124 { "movzx", Gv, Eb, XX }, 2125 { "movzx", Gv, Ew, XX }, 2126 /* b8 */ 2127 { "(bad)", XX, XX, XX }, 2128 { "ud2b", XX, XX, XX }, 2129 { GRP8 }, 2130 { "btc", Ev, Gv, XX }, 2131 { "bsf", Gv, Ev, XX }, 2132 { "bsr", Gv, Ev, XX }, 2133 { "movsx", Gv, Eb, XX }, 2134 { "movsx", Gv, Ew, XX }, 2135 /* c0 */ 2136 { "xadd", Eb, Gb, XX }, 2137 { "xadd", Ev, Gv, XX }, 2138 { PREGRP1 }, 2139 { "movnti", Ev, Gv, XX }, 2140 { "pinsrw", MX, Ed, Ib }, 2141 { "pextrw", Gd, MS, Ib }, 2142 { "shufpX", XM, EX, Ib }, 2143 { GRP9 }, 2144 /* c8 */ 2145 { "bswap", RMeAX, XX, XX }, /* bswap doesn't support 16 bit regs */ 2146 { "bswap", RMeCX, XX, XX }, 2147 { "bswap", RMeDX, XX, XX }, 2148 { "bswap", RMeBX, XX, XX }, 2149 { "bswap", RMeSP, XX, XX }, 2150 { "bswap", RMeBP, XX, XX }, 2151 { "bswap", RMeSI, XX, XX }, 2152 { "bswap", RMeDI, XX, XX }, 2153 /* d0 */ 2154 { "(bad)", XX, XX, XX }, 2155 { "psrlw", MX, EM, XX }, 2156 { "psrld", MX, EM, XX }, 2157 { "psrlq", MX, EM, XX }, 2158 { "paddq", MX, EM, XX }, 2159 { "pmullw", MX, EM, XX }, 2160 { PREGRP21 }, 2161 { "pmovmskb", Gd, MS, XX }, 2162 /* d8 */ 2163 { "psubusb", MX, EM, XX }, 2164 { "psubusw", MX, EM, XX }, 2165 { "pminub", MX, EM, XX }, 2166 { "pand", MX, EM, XX }, 2167 { "paddusb", MX, EM, XX }, 2168 { "paddusw", MX, EM, XX }, 2169 { "pmaxub", MX, EM, XX }, 2170 { "pandn", MX, EM, XX }, 2171 /* e0 */ 2172 { "pavgb", MX, EM, XX }, 2173 { "psraw", MX, EM, XX }, 2174 { "psrad", MX, EM, XX }, 2175 { "pavgw", MX, EM, XX }, 2176 { "pmulhuw", MX, EM, XX }, 2177 { "pmulhw", MX, EM, XX }, 2178 { PREGRP15 }, 2179 { PREGRP25 }, 2180 /* e8 */ 2181 { "psubsb", MX, EM, XX }, 2182 { "psubsw", MX, EM, XX }, 2183 { "pminsw", MX, EM, XX }, 2184 { "por", MX, EM, XX }, 2185 { "paddsb", MX, EM, XX }, 2186 { "paddsw", MX, EM, XX }, 2187 { "pmaxsw", MX, EM, XX }, 2188 { "pxor", MX, EM, XX }, 2189 /* f0 */ 2190 { "(bad)", XX, XX, XX }, 2191 { "psllw", MX, EM, XX }, 2192 { "pslld", MX, EM, XX }, 2193 { "psllq", MX, EM, XX }, 2194 { "pmuludq", MX, EM, XX }, 2195 { "pmaddwd", MX, EM, XX }, 2196 { "psadbw", MX, EM, XX }, 2197 { PREGRP18 }, 2198 /* f8 */ 2199 { "psubb", MX, EM, XX }, 2200 { "psubw", MX, EM, XX }, 2201 { "psubd", MX, EM, XX }, 2202 { "psubq", MX, EM, XX }, 2203 { "paddb", MX, EM, XX }, 2204 { "paddw", MX, EM, XX }, 2205 { "paddd", MX, EM, XX }, 2206 { "(bad)", XX, XX, XX } 1038 { "psubb", MX, EM, XX }, 1039 { "psubw", MX, EM, XX }, 1040 { "psubd", MX, EM, XX }, 1041 { "psubq", MX, EM, XX }, 1042 { "paddb", MX, EM, XX }, 1043 { "paddw", MX, EM, XX }, 1044 { "paddd", MX, EM, XX }, 1045 { "(bad)", XX, XX, XX } 2207 1046 }; 2208 1047 … … 2287 1126 static int reg; 2288 1127 static unsigned char need_modrm; 2289 static void oappend PARAMS ((const char *s));2290 1128 2291 1129 /* If we are accessing mod/rm/reg without need_modrm set, then the … … 2294 1132 #define MODRM_CHECK if (!need_modrm) abort () 2295 1133 2296 static const char *names64[] = { 2297 "%rax","%rcx","%rdx","%rbx", "%rsp","%rbp","%rsi","%rdi", 1134 static const char **names64; 1135 static const char **names32; 1136 static const char **names16; 1137 static const char **names8; 1138 static const char **names8rex; 1139 static const char **names_seg; 1140 static const char **index16; 1141 1142 static const char *intel_names64[] = { 1143 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", 1144 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 1145 }; 1146 static const char *intel_names32[] = { 1147 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", 1148 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" 1149 }; 1150 static const char *intel_names16[] = { 1151 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", 1152 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" 1153 }; 1154 static const char *intel_names8[] = { 1155 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", 1156 }; 1157 static const char *intel_names8rex[] = { 1158 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", 1159 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" 1160 }; 1161 static const char *intel_names_seg[] = { 1162 "es", "cs", "ss", "ds", "fs", "gs", "?", "?", 1163 }; 1164 static const char *intel_index16[] = { 1165 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" 1166 }; 1167 1168 static const char *att_names64[] = { 1169 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", 2298 1170 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 2299 1171 }; 2300 static const char * names32[] = {2301 "%eax", "%ecx","%edx","%ebx", "%esp","%ebp","%esi","%edi",1172 static const char *att_names32[] = { 1173 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", 2302 1174 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" 2303 1175 }; 2304 static const char * names16[] = {2305 "%ax", "%cx","%dx","%bx","%sp","%bp","%si","%di",1176 static const char *att_names16[] = { 1177 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", 2306 1178 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" 2307 1179 }; 2308 static const char * names8[] = {2309 "%al", "%cl","%dl","%bl","%ah","%ch","%dh","%bh",1180 static const char *att_names8[] = { 1181 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", 2310 1182 }; 2311 static const char * names8rex[] = {2312 "%al", "%cl","%dl","%bl","%spl", "%bpl", "%sil", "%dil",1183 static const char *att_names8rex[] = { 1184 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", 2313 1185 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" 2314 1186 }; 2315 static const char * names_seg[] = {2316 "%es", "%cs","%ss","%ds","%fs","%gs","%?","%?",1187 static const char *att_names_seg[] = { 1188 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", 2317 1189 }; 2318 static const char * index16[] = {2319 "%bx,%si", "%bx,%di","%bp,%si","%bp,%di","%si","%di","%bp","%bx"1190 static const char *att_index16[] = { 1191 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" 2320 1192 }; 2321 1193 … … 2426 1298 { "notA", Eb, XX, XX }, 2427 1299 { "negA", Eb, XX, XX }, 2428 { "mul B", AL, Eb, XX },2429 { "imul B", AL, Eb, XX },2430 { "div B", AL, Eb, XX },2431 { "idiv B", AL, Eb, XX }1300 { "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */ 1301 { "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */ 1302 { "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */ 1303 { "idivA", Eb, XX, XX } /* and idiv for consistency. */ 2432 1304 }, 2433 1305 /* GRP3S */ … … 2437 1309 { "notQ", Ev, XX, XX }, 2438 1310 { "negQ", Ev, XX, XX }, 2439 { "mul S", eAX, Ev, XX },2440 { "imul S", eAX, Ev, XX },2441 { "div S", eAX, Ev, XX },2442 { "idiv S", eAX, Ev, XX },1311 { "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */ 1312 { "imulQ", Ev, XX, XX }, 1313 { "divQ", Ev, XX, XX }, 1314 { "idivQ", Ev, XX, XX }, 2443 1315 }, 2444 1316 /* GRP4 */ … … 2457 1329 { "incQ", Ev, XX, XX }, 2458 1330 { "decQ", Ev, XX, XX }, 2459 { "call I", indirEv, XX, XX },2460 { "lcall I", indirEv, XX, XX },2461 { "jmp I", indirEv, XX, XX },2462 { "ljmp I", indirEv, XX, XX },2463 { "push T", Ev, XX, XX },1331 { "callT", indirEv, XX, XX }, 1332 { "lcallT", indirEv, XX, XX }, 1333 { "jmpT", indirEv, XX, XX }, 1334 { "ljmpT", indirEv, XX, XX }, 1335 { "pushU", Ev, XX, XX }, 2464 1336 { "(bad)", XX, XX, XX }, 2465 1337 }, 2466 1338 /* GRP6 */ 2467 1339 { 2468 { "sldt ", Ew, XX, XX },2469 { "str ", Ew, XX, XX },1340 { "sldtQ", Ev, XX, XX }, 1341 { "strQ", Ev, XX, XX }, 2470 1342 { "lldt", Ew, XX, XX }, 2471 1343 { "ltr", Ew, XX, XX }, … … 2477 1349 /* GRP7 */ 2478 1350 { 2479 { "sgdt ", Ew, XX, XX },2480 { "sidt ", Ew, XX, XX },2481 { "lgdt ", Ew, XX, XX },2482 { "lidt ", Ew, XX, XX },2483 { "smsw ", Ew, XX, XX },2484 { "(bad)", 2485 { "lmsw", 2486 { "invlpg", 1351 { "sgdtQ", M, XX, XX }, 1352 { "sidtQ", M, XX, XX }, 1353 { "lgdtQ", M, XX, XX }, 1354 { "lidtQ", M, XX, XX }, 1355 { "smswQ", Ev, XX, XX }, 1356 { "(bad)", XX, XX, XX }, 1357 { "lmsw", Ew, XX, XX }, 1358 { "invlpg", Ew, XX, XX }, 2487 1359 }, 2488 1360 /* GRP8 */ … … 2551 1423 { "mfence", None, XX, XX }, 2552 1424 { "sfence", None, XX, XX }, 2553 /* FIXME: the sfence with memory operand is clflush! */1425 /* FIXME: the sfence with memory operand is clflush! */ 2554 1426 }, 2555 1427 /* GRP14 */ … … 2575 1447 { "(bad)", XX, XX, XX }, 2576 1448 } 2577 2578 1449 }; 2579 1450 … … 2588 1459 /* PREGRP1 */ 2589 1460 { 2590 { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX */1461 { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */ 2591 1462 { "", XM, EX, OPSIMD }, 2592 1463 { "", XM, EX, OPSIMD }, … … 2742 1613 /* PREGRP23 */ 2743 1614 { 2744 { "movd", Ed , MX, XX },1615 { "movd", Edq, MX, XX }, 2745 1616 { "movq", XM, EX, XX }, 2746 { "movd", Ed , XM, XX },1617 { "movd", Edq, XM, XX }, 2747 1618 { "(bad)", Ed, XM, XX }, 2748 1619 }, … … 2767 1638 { "punpcklqdq", XM, EX, XX }, 2768 1639 { "(bad)", XM, EX, XX }, 1640 }, 1641 }; 1642 1643 static const struct dis386 x86_64_table[][2] = { 1644 { 1645 { "arpl", Ew, Gw, XX }, 1646 { "movs{||lq|xd}", Gv, Ed, XX }, 2769 1647 }, 2770 1648 }; … … 2931 1809 return (sizeflag & DFLAG) ? "data16" : "data32"; 2932 1810 case 0x67: 2933 return (sizeflag & AFLAG) ? "addr16" : "addr32"; 1811 if (mode_64bit) 1812 return (sizeflag & AFLAG) ? "addr32" : "addr64"; 1813 else 1814 return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32"; 2934 1815 case FWAIT_OPCODE: 2935 1816 return "fwait"; … … 2941 1822 static char op1out[100], op2out[100], op3out[100]; 2942 1823 static int op_ad, op_index[3]; 2943 static unsigned intop_address[3];2944 static unsigned intop_riprel[3];1824 static bfd_vma op_address[3]; 1825 static bfd_vma op_riprel[3]; 2945 1826 static bfd_vma start_pc; 2946 2947 1827 2948 1828 … … 2956 1836 */ 2957 1837 2958 static int print_insn_i3862959 PARAMS ((bfd_vma pc, disassemble_info *info));2960 2961 1838 static char intel_syntax; 2962 1839 static char open_char; … … 2965 1842 static char scale_char; 2966 1843 1844 /* Here for backwards compatibility. When gdb stops using 1845 print_insn_i386_att and print_insn_i386_intel these functions can 1846 disappear, and print_insn_i386 be merged into print_insn. */ 2967 1847 int 2968 1848 print_insn_i386_att (pc, info) … … 2971 1851 { 2972 1852 intel_syntax = 0; 2973 open_char = '('; 2974 close_char = ')'; 2975 separator_char = ','; 2976 scale_char = ','; 2977 2978 return print_insn_i386 (pc, info); 1853 1854 return print_insn (pc, info); 2979 1855 } 2980 1856 … … 2985 1861 { 2986 1862 intel_syntax = 1; 2987 open_char = '['; 2988 close_char = ']'; 2989 separator_char = '+'; 2990 scale_char = '*'; 2991 2992 return print_insn_i386 (pc, info); 1863 1864 return print_insn (pc, info); 1865 } 1866 1867 int 1868 print_insn_i386 (pc, info) 1869 bfd_vma pc; 1870 disassemble_info *info; 1871 { 1872 intel_syntax = -1; 1873 1874 return print_insn (pc, info); 2993 1875 } 2994 1876 2995 1877 static int 2996 print_insn _i386(pc, info)1878 print_insn (pc, info) 2997 1879 bfd_vma pc; 2998 1880 disassemble_info *info; … … 3004 1886 int needcomma; 3005 1887 unsigned char uses_SSE_prefix; 3006 VOLATILE int sizeflag; 3007 VOLATILE int orig_sizeflag; 3008 1888 int sizeflag; 1889 const char *p; 3009 1890 struct dis_private priv; 3010 bfd_byte *inbuf = priv.the_buffer;3011 1891 3012 1892 mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax 3013 1893 || info->mach == bfd_mach_x86_64); 1894 1895 if (intel_syntax == (char) -1) 1896 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax 1897 || info->mach == bfd_mach_x86_64_intel_syntax); 3014 1898 3015 1899 if (info->mach == bfd_mach_i386_i386 … … 3017 1901 || info->mach == bfd_mach_i386_i386_intel_syntax 3018 1902 || info->mach == bfd_mach_x86_64_intel_syntax) 3019 sizeflag = AFLAG|DFLAG;1903 priv.orig_sizeflag = AFLAG | DFLAG; 3020 1904 else if (info->mach == bfd_mach_i386_i8086) 3021 sizeflag = 0;1905 priv.orig_sizeflag = 0; 3022 1906 else 3023 1907 abort (); 3024 orig_sizeflag = sizeflag; 1908 1909 for (p = info->disassembler_options; p != NULL; ) 1910 { 1911 if (strncmp (p, "x86-64", 6) == 0) 1912 { 1913 mode_64bit = 1; 1914 priv.orig_sizeflag = AFLAG | DFLAG; 1915 } 1916 else if (strncmp (p, "i386", 4) == 0) 1917 { 1918 mode_64bit = 0; 1919 priv.orig_sizeflag = AFLAG | DFLAG; 1920 } 1921 else if (strncmp (p, "i8086", 5) == 0) 1922 { 1923 mode_64bit = 0; 1924 priv.orig_sizeflag = 0; 1925 } 1926 else if (strncmp (p, "intel", 5) == 0) 1927 { 1928 intel_syntax = 1; 1929 } 1930 else if (strncmp (p, "att", 3) == 0) 1931 { 1932 intel_syntax = 0; 1933 } 1934 else if (strncmp (p, "addr", 4) == 0) 1935 { 1936 if (p[4] == '1' && p[5] == '6') 1937 priv.orig_sizeflag &= ~AFLAG; 1938 else if (p[4] == '3' && p[5] == '2') 1939 priv.orig_sizeflag |= AFLAG; 1940 } 1941 else if (strncmp (p, "data", 4) == 0) 1942 { 1943 if (p[4] == '1' && p[5] == '6') 1944 priv.orig_sizeflag &= ~DFLAG; 1945 else if (p[4] == '3' && p[5] == '2') 1946 priv.orig_sizeflag |= DFLAG; 1947 } 1948 else if (strncmp (p, "suffix", 6) == 0) 1949 priv.orig_sizeflag |= SUFFIX_ALWAYS; 1950 1951 p = strchr (p, ','); 1952 if (p != NULL) 1953 p++; 1954 } 1955 1956 if (intel_syntax) 1957 { 1958 names64 = intel_names64; 1959 names32 = intel_names32; 1960 names16 = intel_names16; 1961 names8 = intel_names8; 1962 names8rex = intel_names8rex; 1963 names_seg = intel_names_seg; 1964 index16 = intel_index16; 1965 open_char = '['; 1966 close_char = ']'; 1967 separator_char = '+'; 1968 scale_char = '*'; 1969 } 1970 else 1971 { 1972 names64 = att_names64; 1973 names32 = att_names32; 1974 names16 = att_names16; 1975 names8 = att_names8; 1976 names8rex = att_names8rex; 1977 names_seg = att_names_seg; 1978 index16 = att_index16; 1979 open_char = '('; 1980 close_char = ')'; 1981 separator_char = ','; 1982 scale_char = ','; 1983 } 3025 1984 3026 1985 /* The output looks better if we put 7 bytes on a line, since that … … 3041 2000 the_info = info; 3042 2001 start_pc = pc; 3043 start_codep = inbuf;3044 codep = inbuf;2002 start_codep = priv.the_buffer; 2003 codep = priv.the_buffer; 3045 2004 3046 2005 if (setjmp (priv.bailout) != 0) … … 3049 2008 3050 2009 /* Getting here means we tried for data but didn't get it. That 3051 3052 3053 if (codep > inbuf)2010 means we have an incomplete instruction of some sort. Just 2011 print the first byte as a prefix or a .byte pseudo-op. */ 2012 if (codep > priv.the_buffer) 3054 2013 { 3055 name = prefix_name ( inbuf[0],orig_sizeflag);2014 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3056 2015 if (name != NULL) 3057 2016 (*info->fprintf_func) (info->stream, "%s", name); … … 3060 2019 /* Just print the first byte as a .byte instruction. */ 3061 2020 (*info->fprintf_func) (info->stream, ".byte 0x%x", 3062 (unsigned int) inbuf[0]);2021 (unsigned int) priv.the_buffer[0]); 3063 2022 } 3064 2023 … … 3073 2032 3074 2033 insn_codep = codep; 2034 sizeflag = priv.orig_sizeflag; 3075 2035 3076 2036 FETCH_DATA (info, codep + 1); … … 3083 2043 3084 2044 /* fwait not followed by floating point instruction. Print the 3085 3086 name = prefix_name ( inbuf[0],orig_sizeflag);2045 first prefix, which is probably fwait itself. */ 2046 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3087 2047 if (name == NULL) 3088 2048 name = INTERNAL_DISASSEMBLER_ERROR; … … 3094 2054 { 3095 2055 FETCH_DATA (info, codep + 2); 3096 if (intel_syntax) 3097 dp = &dis386_twobyte_intel[*++codep]; 3098 else 3099 dp = &dis386_twobyte_att[*++codep]; 2056 dp = &dis386_twobyte[*++codep]; 3100 2057 need_modrm = twobyte_has_modrm[*codep]; 3101 2058 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep]; … … 3103 2060 else 3104 2061 { 3105 if (intel_syntax) 3106 if (mode_64bit) 3107 dp = &dis386_64_intel[*codep]; 3108 else 3109 dp = &dis386_intel[*codep]; 3110 else 3111 if (mode_64bit) 3112 dp = &disx86_64_att[*codep]; 3113 else 3114 dp = &dis386_att[*codep]; 2062 dp = &dis386[*codep]; 3115 2063 need_modrm = onebyte_has_modrm[*codep]; 3116 2064 uses_SSE_prefix = 0; … … 3137 2085 { 3138 2086 sizeflag ^= AFLAG; 3139 if (dp->bytemode 2 != loop_jcxz_mode)2087 if (dp->bytemode3 != loop_jcxz_mode || intel_syntax) 3140 2088 { 3141 if ( sizeflag & AFLAG)2089 if ((sizeflag & AFLAG) || mode_64bit) 3142 2090 oappend ("addr32 "); 3143 2091 else … … 3150 2098 { 3151 2099 sizeflag ^= DFLAG; 3152 if (dp->bytemode2 == cond_jump_mode && dp->bytemode1 == v_mode) 2100 if (dp->bytemode3 == cond_jump_mode 2101 && dp->bytemode1 == v_mode 2102 && !intel_syntax) 3153 2103 { 3154 2104 if (sizeflag & DFLAG) … … 3160 2110 } 3161 2111 3162 if (dp->bytemode2 == cond_jump_mode || dp->bytemode2 == loop_jcxz_mode)3163 {3164 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS)3165 {3166 oappend ("cs ");3167 used_prefixes |= PREFIX_CS;3168 }3169 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)3170 {3171 oappend ("ds ");3172 used_prefixes |= PREFIX_DS;3173 }3174 }3175 3176 2112 if (need_modrm) 3177 2113 { … … 3191 2127 if (dp->name == NULL) 3192 2128 { 3193 switch (dp->bytemode2)2129 switch (dp->bytemode1) 3194 2130 { 3195 case USE_GROUPS: 3196 dp = &grps[dp->bytemode1][reg]; 3197 break; 3198 case USE_PREFIX_USER_TABLE: 3199 index = 0; 3200 used_prefixes |= (prefixes & PREFIX_REPZ); 3201 if (prefixes & PREFIX_REPZ) 3202 index = 1; 3203 else 3204 { 3205 used_prefixes |= (prefixes & PREFIX_DATA); 3206 if (prefixes & PREFIX_DATA) 3207 index = 2; 3208 else 3209 { 3210 used_prefixes |= (prefixes & PREFIX_REPNZ); 3211 if (prefixes & PREFIX_REPNZ) 3212 index = 3; 3213 } 3214 } 3215 dp = &prefix_user_table[dp->bytemode1][index]; 3216 break; 3217 default: 3218 oappend (INTERNAL_DISASSEMBLER_ERROR); 3219 break; 2131 case USE_GROUPS: 2132 dp = &grps[dp->bytemode2][reg]; 2133 break; 2134 2135 case USE_PREFIX_USER_TABLE: 2136 index = 0; 2137 used_prefixes |= (prefixes & PREFIX_REPZ); 2138 if (prefixes & PREFIX_REPZ) 2139 index = 1; 2140 else 2141 { 2142 used_prefixes |= (prefixes & PREFIX_DATA); 2143 if (prefixes & PREFIX_DATA) 2144 index = 2; 2145 else 2146 { 2147 used_prefixes |= (prefixes & PREFIX_REPNZ); 2148 if (prefixes & PREFIX_REPNZ) 2149 index = 3; 2150 } 2151 } 2152 dp = &prefix_user_table[dp->bytemode2][index]; 2153 break; 2154 2155 case X86_64_SPECIAL: 2156 dp = &x86_64_table[dp->bytemode2][mode_64bit]; 2157 break; 2158 2159 default: 2160 oappend (INTERNAL_DISASSEMBLER_ERROR); 2161 break; 3220 2162 } 3221 2163 } 3222 2164 3223 putop (dp->name, sizeflag); 3224 3225 obufp = op1out; 3226 op_ad = 2; 3227 if (dp->op1) 3228 (*dp->op1)(dp->bytemode1, sizeflag); 3229 3230 obufp = op2out; 3231 op_ad = 1; 3232 if (dp->op2) 3233 (*dp->op2)(dp->bytemode2, sizeflag); 3234 3235 obufp = op3out; 3236 op_ad = 0; 3237 if (dp->op3) 3238 (*dp->op3)(dp->bytemode3, sizeflag); 2165 if (putop (dp->name, sizeflag) == 0) 2166 { 2167 obufp = op1out; 2168 op_ad = 2; 2169 if (dp->op1) 2170 (*dp->op1) (dp->bytemode1, sizeflag); 2171 2172 obufp = op2out; 2173 op_ad = 1; 2174 if (dp->op2) 2175 (*dp->op2) (dp->bytemode2, sizeflag); 2176 2177 obufp = op3out; 2178 op_ad = 0; 2179 if (dp->op3) 2180 (*dp->op3) (dp->bytemode3, sizeflag); 2181 } 3239 2182 } 3240 2183 … … 3247 2190 const char *name; 3248 2191 3249 name = prefix_name ( inbuf[0],orig_sizeflag);2192 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3250 2193 if (name == NULL) 3251 2194 name = INTERNAL_DISASSEMBLER_ERROR; … … 3256 2199 { 3257 2200 const char *name; 3258 name = prefix_name (rex | 0x40, orig_sizeflag);2201 name = prefix_name (rex | 0x40, priv.orig_sizeflag); 3259 2202 if (name == NULL) 3260 2203 name = INTERNAL_DISASSEMBLER_ERROR; … … 3320 2263 + op_address[op_index[i]]), info); 3321 2264 } 3322 return codep - inbuf;3323 } 3324 3325 static const char *float_mem _att[] = {2265 return codep - priv.the_buffer; 2266 } 2267 2268 static const char *float_mem[] = { 3326 2269 /* d8 */ 3327 "fadd s",3328 "fmul s",3329 "fcom s",3330 "fcomp s",3331 "fsub s",3332 "fsubr s",3333 "fdiv s",3334 "fdivr s",3335 /* 3336 "fld s",2270 "fadd{s||s|}", 2271 "fmul{s||s|}", 2272 "fcom{s||s|}", 2273 "fcomp{s||s|}", 2274 "fsub{s||s|}", 2275 "fsubr{s||s|}", 2276 "fdiv{s||s|}", 2277 "fdivr{s||s|}", 2278 /* d9 */ 2279 "fld{s||s|}", 3337 2280 "(bad)", 3338 "fst s",3339 "fstp s",2281 "fst{s||s|}", 2282 "fstp{s||s|}", 3340 2283 "fldenv", 3341 2284 "fldcw", … … 3343 2286 "fNstcw", 3344 2287 /* da */ 3345 "fiadd l",3346 "fimul l",3347 "ficom l",3348 "ficomp l",3349 "fisub l",3350 "fisubr l",3351 "fidiv l",3352 "fidivr l",2288 "fiadd{l||l|}", 2289 "fimul{l||l|}", 2290 "ficom{l||l|}", 2291 "ficomp{l||l|}", 2292 "fisub{l||l|}", 2293 "fisubr{l||l|}", 2294 "fidiv{l||l|}", 2295 "fidivr{l||l|}", 3353 2296 /* db */ 3354 "fild l",2297 "fild{l||l|}", 3355 2298 "(bad)", 3356 "fist l",3357 "fistp l",2299 "fist{l||l|}", 2300 "fistp{l||l|}", 3358 2301 "(bad)", 3359 "fld t",2302 "fld{t||t|}", 3360 2303 "(bad)", 3361 "fstp t",2304 "fstp{t||t|}", 3362 2305 /* dc */ 3363 "fadd l",3364 "fmul l",3365 "fcom l",3366 "fcomp l",3367 "fsub l",3368 "fsubr l",3369 "fdiv l",3370 "fdivr l",2306 "fadd{l||l|}", 2307 "fmul{l||l|}", 2308 "fcom{l||l|}", 2309 "fcomp{l||l|}", 2310 "fsub{l||l|}", 2311 "fsubr{l||l|}", 2312 "fdiv{l||l|}", 2313 "fdivr{l||l|}", 3371 2314 /* dd */ 3372 "fld l",2315 "fld{l||l|}", 3373 2316 "(bad)", 3374 "fst l",3375 "fstp l",2317 "fst{l||l|}", 2318 "fstp{l||l|}", 3376 2319 "frstor", 3377 2320 "(bad)", … … 3393 2336 "fistp", 3394 2337 "fbld", 3395 "fildll", 3396 "fbstp", 3397 "fistpll", 3398 }; 3399 3400 static const char *float_mem_intel[] = { 3401 /* d8 */ 3402 "fadd", 3403 "fmul", 3404 "fcom", 3405 "fcomp", 3406 "fsub", 3407 "fsubr", 3408 "fdiv", 3409 "fdivr", 3410 /* d9 */ 3411 "fld", 3412 "(bad)", 3413 "fst", 3414 "fstp", 3415 "fldenv", 3416 "fldcw", 3417 "fNstenv", 3418 "fNstcw", 3419 /* da */ 3420 "fiadd", 3421 "fimul", 3422 "ficom", 3423 "ficomp", 3424 "fisub", 3425 "fisubr", 3426 "fidiv", 3427 "fidivr", 3428 /* db */ 3429 "fild", 3430 "(bad)", 3431 "fist", 3432 "fistp", 3433 "(bad)", 3434 "fld", 3435 "(bad)", 3436 "fstp", 3437 /* dc */ 3438 "fadd", 3439 "fmul", 3440 "fcom", 3441 "fcomp", 3442 "fsub", 3443 "fsubr", 3444 "fdiv", 3445 "fdivr", 3446 /* dd */ 3447 "fld", 3448 "(bad)", 3449 "fst", 3450 "fstp", 3451 "frstor", 3452 "(bad)", 3453 "fNsave", 3454 "fNstsw", 3455 /* de */ 3456 "fiadd", 3457 "fimul", 3458 "ficom", 3459 "ficomp", 3460 "fisub", 3461 "fisubr", 3462 "fidiv", 3463 "fidivr", 3464 /* df */ 3465 "fild", 3466 "(bad)", 3467 "fist", 3468 "fistp", 3469 "fbld", 3470 "fild", 2338 "fild{ll||ll|}", 3471 2339 "fbstp", 3472 2340 "fistpll", … … 3591 2459 }; 3592 2460 3593 3594 2461 static char *fgrps[][8] = { 3595 2462 /* d9_2 0 */ … … 3651 2518 if (mod != 3) 3652 2519 { 3653 if (intel_syntax) 3654 putop (float_mem_intel[(floatop - 0xd8 ) * 8 + reg], sizeflag); 3655 else 3656 putop (float_mem_att[(floatop - 0xd8 ) * 8 + reg], sizeflag); 2520 putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag); 3657 2521 obufp = op1out; 3658 2522 if (floatop == 0xdb) 3659 2523 OP_E (x_mode, sizeflag); 3660 2524 else if (floatop == 0xdd) 3661 2525 OP_E (d_mode, sizeflag); 3662 2526 else 3663 2527 OP_E (v_mode, sizeflag); 3664 2528 return; 3665 2529 } 3666 /* skip mod/rm byte*/2530 /* Skip mod/rm byte. */ 3667 2531 MODRM_CHECK; 3668 2532 codep++; … … 3673 2537 putop (fgrps[dp->bytemode1][rm], sizeflag); 3674 2538 3675 /* instruction fnstsw is only one with strange arg*/2539 /* Instruction fnstsw is only one with strange arg. */ 3676 2540 if (floatop == 0xdf && codep[-1] == 0xe0) 3677 2541 strcpy (op1out, names16[0]); … … 3683 2547 obufp = op1out; 3684 2548 if (dp->op1) 3685 (*dp->op1) (dp->bytemode1, sizeflag);2549 (*dp->op1) (dp->bytemode1, sizeflag); 3686 2550 obufp = op2out; 3687 2551 if (dp->op2) 3688 (*dp->op2)(dp->bytemode2, sizeflag); 3689 } 3690 } 3691 3692 /* ARGSUSED */ 2552 (*dp->op2) (dp->bytemode2, sizeflag); 2553 } 2554 } 2555 3693 2556 static void 3694 OP_ST ( ignore, sizeflag)3695 int ignore ATTRIBUTE_UNUSED;2557 OP_ST (bytemode, sizeflag) 2558 int bytemode ATTRIBUTE_UNUSED; 3696 2559 int sizeflag ATTRIBUTE_UNUSED; 3697 2560 { … … 3699 2562 } 3700 2563 3701 /* ARGSUSED */3702 2564 static void 3703 OP_STi ( ignore, sizeflag)3704 int ignore ATTRIBUTE_UNUSED;2565 OP_STi (bytemode, sizeflag) 2566 int bytemode ATTRIBUTE_UNUSED; 3705 2567 int sizeflag ATTRIBUTE_UNUSED; 3706 2568 { 3707 2569 sprintf (scratchbuf, "%%st(%d)", rm); 3708 oappend (scratchbuf); 3709 } 3710 3711 3712 /* capital letters in template are macros */ 3713 static void 2570 oappend (scratchbuf + intel_syntax); 2571 } 2572 2573 /* Capital letters in template are macros. */ 2574 static int 3714 2575 putop (template, sizeflag) 3715 2576 const char *template; … … 3717 2578 { 3718 2579 const char *p; 2580 int alt; 3719 2581 3720 2582 for (p = template; *p; p++) … … 3725 2587 *obufp++ = *p; 3726 2588 break; 2589 case '{': 2590 alt = 0; 2591 if (intel_syntax) 2592 alt += 1; 2593 if (mode_64bit) 2594 alt += 2; 2595 while (alt != 0) 2596 { 2597 while (*++p != '|') 2598 { 2599 if (*p == '}') 2600 { 2601 /* Alternative not valid. */ 2602 strcpy (obuf, "(bad)"); 2603 obufp = obuf + 5; 2604 return 1; 2605 } 2606 else if (*p == '\0') 2607 abort (); 2608 } 2609 alt--; 2610 } 2611 break; 2612 case '|': 2613 while (*++p != '}') 2614 { 2615 if (*p == '\0') 2616 abort (); 2617 } 2618 break; 2619 case '}': 2620 break; 3727 2621 case 'A': 3728 if (intel_syntax) 3729 break; 3730 if (mod != 3 3731 #ifdef SUFFIX_ALWAYS 3732 || (sizeflag & SUFFIX_ALWAYS) 3733 #endif 3734 ) 2622 if (intel_syntax) 2623 break; 2624 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 3735 2625 *obufp++ = 'b'; 3736 2626 break; 3737 2627 case 'B': 3738 if (intel_syntax) 3739 break; 3740 #ifdef SUFFIX_ALWAYS 2628 if (intel_syntax) 2629 break; 3741 2630 if (sizeflag & SUFFIX_ALWAYS) 3742 2631 *obufp++ = 'b'; 3743 #endif3744 2632 break; 3745 2633 case 'E': /* For jcxz/jecxz */ 3746 if (sizeflag & AFLAG) 3747 *obufp++ = 'e'; 3748 used_prefixes |= (prefixes & PREFIX_ADDR); 3749 break; 3750 case 'F': 3751 if ((prefixes & PREFIX_ADDR) 3752 #ifdef SUFFIX_ALWAYS 3753 || (sizeflag & SUFFIX_ALWAYS) 3754 #endif 3755 ) 2634 if (mode_64bit) 3756 2635 { 3757 2636 if (sizeflag & AFLAG) 3758 *obufp++ = ' l';2637 *obufp++ = 'r'; 3759 2638 else 3760 *obufp++ = 'w'; 2639 *obufp++ = 'e'; 2640 } 2641 else 2642 if (sizeflag & AFLAG) 2643 *obufp++ = 'e'; 2644 used_prefixes |= (prefixes & PREFIX_ADDR); 2645 break; 2646 case 'F': 2647 if (intel_syntax) 2648 break; 2649 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) 2650 { 2651 if (sizeflag & AFLAG) 2652 *obufp++ = mode_64bit ? 'q' : 'l'; 2653 else 2654 *obufp++ = mode_64bit ? 'l' : 'w'; 3761 2655 used_prefixes |= (prefixes & PREFIX_ADDR); 3762 2656 } 3763 2657 break; 3764 case 'I': 3765 if (intel_syntax) 3766 break; 3767 if (mode_64bit) 3768 *obufp++ = 'q'; 3769 else 2658 case 'H': 2659 if (intel_syntax) 2660 break; 2661 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS 2662 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) 3770 2663 { 3771 if ((prefixes & PREFIX_DATA) 3772 #ifdef SUFFIX_ALWAYS 3773 || (sizeflag & SUFFIX_ALWAYS) 3774 #endif 3775 ) 3776 { 3777 if (sizeflag & DFLAG) 3778 *obufp++ = 'l'; 3779 else 3780 *obufp++ = 'w'; 3781 used_prefixes |= (prefixes & PREFIX_DATA); 3782 } 2664 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); 2665 *obufp++ = ','; 2666 *obufp++ = 'p'; 2667 if (prefixes & PREFIX_DS) 2668 *obufp++ = 't'; 2669 else 2670 *obufp++ = 'n'; 3783 2671 } 3784 2672 break; 3785 2673 case 'L': 3786 if (intel_syntax) 3787 break; 3788 #ifdef SUFFIX_ALWAYS 2674 if (intel_syntax) 2675 break; 3789 2676 if (sizeflag & SUFFIX_ALWAYS) 3790 2677 *obufp++ = 'l'; 3791 #endif3792 2678 break; 3793 2679 case 'N': … … 3800 2686 USED_REX (REX_MODE64); 3801 2687 if (rex & REX_MODE64) 3802 2688 *obufp++ = 'o'; 3803 2689 else 3804 2690 *obufp++ = 'd'; 3805 2691 break; 2692 case 'T': 2693 if (intel_syntax) 2694 break; 2695 if (mode_64bit) 2696 { 2697 *obufp++ = 'q'; 2698 break; 2699 } 2700 /* Fall through. */ 3806 2701 case 'P': 3807 3808 2702 if (intel_syntax) 2703 break; 3809 2704 if ((prefixes & PREFIX_DATA) 3810 2705 || (rex & REX_MODE64) 3811 #ifdef SUFFIX_ALWAYS 3812 || (sizeflag & SUFFIX_ALWAYS) 3813 #endif 3814 ) 2706 || (sizeflag & SUFFIX_ALWAYS)) 3815 2707 { 3816 2708 USED_REX (REX_MODE64); … … 3827 2719 } 3828 2720 break; 2721 case 'U': 2722 if (intel_syntax) 2723 break; 2724 if (mode_64bit) 2725 { 2726 *obufp++ = 'q'; 2727 break; 2728 } 2729 /* Fall through. */ 3829 2730 case 'Q': 3830 3831 2731 if (intel_syntax) 2732 break; 3832 2733 USED_REX (REX_MODE64); 3833 if (mod != 3 3834 #ifdef SUFFIX_ALWAYS 3835 || (sizeflag & SUFFIX_ALWAYS) 3836 #endif 3837 ) 2734 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 3838 2735 { 3839 2736 if (rex & REX_MODE64) … … 3851 2748 case 'R': 3852 2749 USED_REX (REX_MODE64); 3853 2750 if (intel_syntax) 3854 2751 { 3855 2752 if (rex & REX_MODE64) … … 3882 2779 break; 3883 2780 case 'S': 3884 if (intel_syntax) 3885 break; 3886 #ifdef SUFFIX_ALWAYS 2781 if (intel_syntax) 2782 break; 3887 2783 if (sizeflag & SUFFIX_ALWAYS) 3888 2784 { … … 3898 2794 } 3899 2795 } 3900 #endif3901 break;3902 case 'T':3903 if (intel_syntax)3904 break;3905 if (mode_64bit)3906 *obufp++ = 'q';3907 else if (mod != 33908 #ifdef SUFFIX_ALWAYS3909 || (sizeflag & SUFFIX_ALWAYS)3910 #endif3911 )3912 {3913 if (sizeflag & DFLAG)3914 *obufp++ = 'l';3915 else3916 *obufp++ = 'w';3917 used_prefixes |= (prefixes & PREFIX_DATA);3918 }3919 2796 break; 3920 2797 case 'X': … … 3923 2800 else 3924 2801 *obufp++ = 's'; 3925 2802 used_prefixes |= (prefixes & PREFIX_DATA); 3926 2803 break; 3927 2804 case 'Y': 3928 3929 2805 if (intel_syntax) 2806 break; 3930 2807 if (rex & REX_MODE64) 3931 2808 { … … 3944 2821 else 3945 2822 *obufp++ = 'b'; 3946 2823 if (intel_syntax) 3947 2824 { 3948 2825 if (rex) … … 3967 2844 } 3968 2845 *obufp = 0; 2846 return 0; 3969 2847 } 3970 2848 … … 3982 2860 if (prefixes & PREFIX_CS) 3983 2861 { 3984 oappend ("%cs:");3985 2862 used_prefixes |= PREFIX_CS; 2863 oappend ("%cs:" + intel_syntax); 3986 2864 } 3987 2865 if (prefixes & PREFIX_DS) 3988 2866 { 3989 oappend ("%ds:");3990 2867 used_prefixes |= PREFIX_DS; 2868 oappend ("%ds:" + intel_syntax); 3991 2869 } 3992 2870 if (prefixes & PREFIX_SS) 3993 2871 { 3994 oappend ("%ss:");3995 2872 used_prefixes |= PREFIX_SS; 2873 oappend ("%ss:" + intel_syntax); 3996 2874 } 3997 2875 if (prefixes & PREFIX_ES) 3998 2876 { 3999 oappend ("%es:");4000 2877 used_prefixes |= PREFIX_ES; 2878 oappend ("%es:" + intel_syntax); 4001 2879 } 4002 2880 if (prefixes & PREFIX_FS) 4003 2881 { 4004 oappend ("%fs:");4005 2882 used_prefixes |= PREFIX_FS; 2883 oappend ("%fs:" + intel_syntax); 4006 2884 } 4007 2885 if (prefixes & PREFIX_GS) 4008 2886 { 4009 oappend ("%gs:");4010 2887 used_prefixes |= PREFIX_GS; 2888 oappend ("%gs:" + intel_syntax); 4011 2889 } 4012 2890 } … … 4037 2915 buf[1] = 'x'; 4038 2916 sprintf_vma (tmp, disp); 4039 for (i = 0; tmp[i] == '0' && tmp[i +1]; i++);2917 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); 4040 2918 strcpy (buf + 2, tmp + i); 4041 2919 } … … 4049 2927 *(buf++) = '-'; 4050 2928 v = -disp; 4051 /* Check for possible overflow on 0x8000000000000000 */2929 /* Check for possible overflow on 0x8000000000000000. */ 4052 2930 if (v < 0) 4053 2931 { … … 4066 2944 while (v) 4067 2945 { 4068 tmp[28 -i] = (v % 10) + '0';2946 tmp[28 - i] = (v % 10) + '0'; 4069 2947 v /= 10; 4070 2948 i++; … … 4094 2972 add += 8; 4095 2973 4096 /* skip mod/rm byte*/2974 /* Skip mod/rm byte. */ 4097 2975 MODRM_CHECK; 4098 2976 codep++; … … 4125 3003 break; 4126 3004 case v_mode: 3005 case dq_mode: 4127 3006 USED_REX (REX_MODE64); 4128 3007 if (rex & REX_MODE64) 4129 3008 oappend (names64[rm + add]); 4130 else if ( sizeflag & DFLAG)3009 else if ((sizeflag & DFLAG) || bytemode == dq_mode) 4131 3010 oappend (names32[rm + add]); 4132 3011 else … … 4135 3014 break; 4136 3015 case 0: 4137 if ( 3016 if (!(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */) 4138 3017 && !(codep[-2] == 0xAE && codep[-1] == 0xF0 /* mfence */) 4139 3018 && !(codep[-2] == 0xAE && codep[-1] == 0xe8 /* lfence */)) 4140 BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */3019 BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */ 4141 3020 break; 4142 3021 default: … … 4150 3029 append_seg (); 4151 3030 4152 if ( sizeflag & AFLAG) /* 32 bit address mode */3031 if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */ 4153 3032 { 4154 3033 int havesib; … … 4184 3063 { 4185 3064 havebase = 0; 4186 if (mode_64bit && !havesib )3065 if (mode_64bit && !havesib && (sizeflag & AFLAG)) 4187 3066 riprel = 1; 4188 3067 disp = get32s (); … … 4201 3080 4202 3081 if (!intel_syntax) 4203 4204 3082 if (mod != 0 || (base & 7) == 5) 3083 { 4205 3084 print_operand_value (scratchbuf, !riprel, disp); 4206 3085 oappend (scratchbuf); 4207 3086 if (riprel) 4208 3087 { … … 4210 3089 oappend ("(%rip)"); 4211 3090 } 4212 3091 } 4213 3092 4214 3093 if (havebase || (havesib && (index != 4 || scale != 0))) 4215 3094 { 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232 3095 if (intel_syntax) 3096 { 3097 switch (bytemode) 3098 { 3099 case b_mode: 3100 oappend ("BYTE PTR "); 3101 break; 3102 case w_mode: 3103 oappend ("WORD PTR "); 3104 break; 3105 case v_mode: 3106 oappend ("DWORD PTR "); 3107 break; 3108 case d_mode: 3109 oappend ("QWORD PTR "); 3110 break; 3111 case m_mode: 4233 3112 if (mode_64bit) 4234 3113 oappend ("DWORD PTR "); … … 4236 3115 oappend ("QWORD PTR "); 4237 3116 break; 4238 4239 4240 4241 4242 4243 4244 3117 case x_mode: 3118 oappend ("XWORD PTR "); 3119 break; 3120 default: 3121 break; 3122 } 3123 } 4245 3124 *obufp++ = open_char; 4246 3125 if (intel_syntax && riprel) 4247 3126 oappend ("rip + "); 4248 3127 *obufp = '\0'; 4249 3128 USED_REX (REX_EXTZ); 4250 3129 if (!havesib && (rex & REX_EXTZ)) 4251 3130 base += 8; 4252 3131 if (havebase) 4253 oappend (mode_64bit ? names64[base] : names32[base]); 3132 oappend (mode_64bit && (sizeflag & AFLAG) 3133 ? names64[base] : names32[base]); 4254 3134 if (havesib) 4255 3135 { 4256 3136 if (index != 4) 4257 3137 { 4258 if (intel_syntax) 4259 { 4260 if (havebase) 4261 { 4262 *obufp++ = separator_char; 4263 *obufp = '\0'; 4264 } 4265 sprintf (scratchbuf, "%s", mode_64bit ? names64[index] : names32[index]); 4266 } 4267 else 4268 sprintf (scratchbuf, ",%s", mode_64bit ? names64[index] : names32[index]); 3138 if (intel_syntax) 3139 { 3140 if (havebase) 3141 { 3142 *obufp++ = separator_char; 3143 *obufp = '\0'; 3144 } 3145 sprintf (scratchbuf, "%s", 3146 mode_64bit && (sizeflag & AFLAG) 3147 ? names64[index] : names32[index]); 3148 } 3149 else 3150 sprintf (scratchbuf, ",%s", 3151 mode_64bit && (sizeflag & AFLAG) 3152 ? names64[index] : names32[index]); 4269 3153 oappend (scratchbuf); 4270 3154 } 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 3155 if (!intel_syntax 3156 || (intel_syntax 3157 && bytemode != b_mode 3158 && bytemode != w_mode 3159 && bytemode != v_mode)) 3160 { 3161 *obufp++ = scale_char; 3162 *obufp = '\0'; 3163 sprintf (scratchbuf, "%d", 1 << scale); 3164 oappend (scratchbuf); 3165 } 4282 3166 } 4283 if (intel_syntax) 4284 if (mod != 0 || (base & 7) == 5) 4285 { 4286 /* Don't print zero displacements */ 4287 if (disp != 0) 4288 { 3167 if (intel_syntax) 3168 if (mod != 0 || (base & 7) == 5) 3169 { 3170 /* Don't print zero displacements. */ 3171 if (disp != 0) 3172 { 3173 if ((bfd_signed_vma) disp > 0) 3174 { 3175 *obufp++ = '+'; 3176 *obufp = '\0'; 3177 } 3178 4289 3179 print_operand_value (scratchbuf, 0, disp); 4290 4291 4292 3180 oappend (scratchbuf); 3181 } 3182 } 4293 3183 4294 3184 *obufp++ = close_char; 4295 3185 *obufp = '\0'; 4296 3186 } 4297 3187 else if (intel_syntax) 4298 4299 4300 3188 { 3189 if (mod != 0 || (base & 7) == 5) 3190 { 4301 3191 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 4302 3192 | PREFIX_ES | PREFIX_FS | PREFIX_GS)) … … 4304 3194 else 4305 3195 { 4306 oappend (names_seg[ 3]);3196 oappend (names_seg[ds_reg - es_reg]); 4307 3197 oappend (":"); 4308 3198 } 4309 3199 print_operand_value (scratchbuf, 1, disp); 4310 4311 4312 3200 oappend (scratchbuf); 3201 } 3202 } 4313 3203 } 4314 3204 else … … 4338 3228 4339 3229 if (!intel_syntax) 4340 4341 3230 if (mod != 0 || (rm & 7) == 6) 3231 { 4342 3232 print_operand_value (scratchbuf, 0, disp); 4343 4344 3233 oappend (scratchbuf); 3234 } 4345 3235 4346 3236 if (mod != 0 || (rm & 7) != 6) 4347 3237 { 4348 3238 *obufp++ = open_char; 4349 3239 *obufp = '\0'; 4350 3240 oappend (index16[rm + add]); 4351 4352 3241 *obufp++ = close_char; 3242 *obufp = '\0'; 4353 3243 } 4354 3244 } … … 4401 3291 get64 () 4402 3292 { 4403 unsigned int a = 0; 4404 unsigned int b = 0; 4405 bfd_vma x = 0; 4406 3293 bfd_vma x; 4407 3294 #ifdef BFD64 3295 unsigned int a; 3296 unsigned int b; 3297 4408 3298 FETCH_DATA (the_info, codep + 8); 4409 3299 a = *codep++ & 0xff; … … 4411 3301 a |= (*codep++ & 0xff) << 16; 4412 3302 a |= (*codep++ & 0xff) << 24; 4413 b |= (*codep++ & 0xff);3303 b = *codep++ & 0xff; 4414 3304 b |= (*codep++ & 0xff) << 8; 4415 3305 b |= (*codep++ & 0xff) << 16; … … 4417 3307 x = a + ((bfd_vma) b << 32); 4418 3308 #else 4419 abort(); 3309 abort (); 3310 x = 0; 4420 3311 #endif 4421 3312 return x; … … 4464 3355 static void 4465 3356 set_op (op, riprel) 4466 unsigned intop;3357 bfd_vma op; 4467 3358 int riprel; 4468 3359 { 4469 3360 op_index[op_ad] = op_ad; 4470 op_address[op_ad] = op; 4471 op_riprel[op_ad] = riprel; 3361 if (mode_64bit) 3362 { 3363 op_address[op_ad] = op; 3364 op_riprel[op_ad] = riprel; 3365 } 3366 else 3367 { 3368 /* Mask to get a 32-bit address. */ 3369 op_address[op_ad] = op & 0xffffffff; 3370 op_riprel[op_ad] = riprel & 0xffffffff; 3371 } 4472 3372 } 4473 3373 … … 4486 3386 { 4487 3387 case indir_dx_reg: 4488 s = "(%dx)"; 3388 if (intel_syntax) 3389 s = "[dx]"; 3390 else 3391 s = "(%dx)"; 4489 3392 break; 4490 3393 case ax_reg: case cx_reg: case dx_reg: case bx_reg: … … 4504 3407 s = names8[code - al_reg]; 4505 3408 break; 3409 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: 3410 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: 3411 if (mode_64bit) 3412 { 3413 s = names64[code - rAX_reg + add]; 3414 break; 3415 } 3416 code += eAX_reg - rAX_reg; 3417 /* Fall through. */ 4506 3418 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 4507 3419 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: … … 4515 3427 used_prefixes |= (prefixes & PREFIX_DATA); 4516 3428 break; 4517 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:4518 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:4519 s = names64[code - rAX_reg + add];4520 break;4521 3429 default: 4522 3430 s = INTERNAL_DISASSEMBLER_ERROR; … … 4536 3444 { 4537 3445 case indir_dx_reg: 4538 s = "(%dx)"; 3446 if (intel_syntax) 3447 s = "[dx]"; 3448 else 3449 s = "(%dx)"; 4539 3450 break; 4540 3451 case ax_reg: case cx_reg: case dx_reg: case bx_reg: … … 4588 3499 break; 4589 3500 case q_mode: 4590 op = get32s (); 4591 break; 3501 if (mode_64bit) 3502 { 3503 op = get32s (); 3504 break; 3505 } 3506 /* Fall through. */ 4592 3507 case v_mode: 4593 3508 USED_REX (REX_MODE64); … … 4617 3532 op &= mask; 4618 3533 scratchbuf[0] = '$'; 4619 print_operand_value (scratchbuf + !intel_syntax, 1, op);4620 oappend (scratchbuf );3534 print_operand_value (scratchbuf + 1, 1, op); 3535 oappend (scratchbuf + intel_syntax); 4621 3536 scratchbuf[0] = '\0'; 4622 3537 } … … 4629 3544 bfd_signed_vma op; 4630 3545 bfd_signed_vma mask = -1; 3546 3547 if (!mode_64bit) 3548 { 3549 OP_I (bytemode, sizeflag); 3550 return; 3551 } 4631 3552 4632 3553 switch (bytemode) … … 4664 3585 op &= mask; 4665 3586 scratchbuf[0] = '$'; 4666 print_operand_value (scratchbuf + !intel_syntax, 1, op);4667 oappend (scratchbuf );3587 print_operand_value (scratchbuf + 1, 1, op); 3588 oappend (scratchbuf + intel_syntax); 4668 3589 scratchbuf[0] = '\0'; 4669 3590 } … … 4698 3619 { 4699 3620 mask = 0xffffffff; 4700 op = get16 ();3621 op = get16 (); 4701 3622 if ((op & 0x8000) != 0) 4702 3623 op -= 0x10000; … … 4717 3638 scratchbuf[0] = '$'; 4718 3639 print_operand_value (scratchbuf + 1, 1, op); 4719 oappend (scratchbuf );3640 oappend (scratchbuf + intel_syntax); 4720 3641 } 4721 3642 … … 4726 3647 { 4727 3648 bfd_vma disp; 4728 intmask = -1;3649 bfd_vma mask = -1; 4729 3650 4730 3651 switch (bytemode) … … 4742 3663 { 4743 3664 disp = get16 (); 4744 /* for some reason, a data16 prefix on a jump instruction3665 /* For some reason, a data16 prefix on a jump instruction 4745 3666 means that the pc is masked to 16 bits after the 4746 3667 displacement is added! */ … … 4758 3679 } 4759 3680 4760 /* ARGSUSED */4761 3681 static void 4762 3682 OP_SEG (dummy, sizeflag) … … 4764 3684 int sizeflag ATTRIBUTE_UNUSED; 4765 3685 { 4766 static char *sreg[] = { 4767 "%es","%cs","%ss","%ds","%fs","%gs","%?","%?", 4768 }; 4769 4770 oappend (sreg[reg]); 4771 } 4772 4773 /* ARGSUSED */ 3686 oappend (names_seg[reg]); 3687 } 3688 4774 3689 static void 4775 3690 OP_DIR (dummy, sizeflag) … … 4790 3705 } 4791 3706 used_prefixes |= (prefixes & PREFIX_DATA); 4792 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset); 3707 if (intel_syntax) 3708 sprintf (scratchbuf, "0x%x,0x%x", seg, offset); 3709 else 3710 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset); 4793 3711 oappend (scratchbuf); 4794 3712 } 4795 3713 4796 /* ARGSUSED */4797 3714 static void 4798 OP_OFF ( ignored, sizeflag)4799 int ignoredATTRIBUTE_UNUSED;3715 OP_OFF (bytemode, sizeflag) 3716 int bytemode ATTRIBUTE_UNUSED; 4800 3717 int sizeflag; 4801 3718 { … … 4804 3721 append_seg (); 4805 3722 4806 if ( sizeflag & AFLAG)3723 if ((sizeflag & AFLAG) || mode_64bit) 4807 3724 off = get32 (); 4808 3725 else … … 4812 3729 { 4813 3730 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 4814 3731 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 4815 3732 { 4816 oappend (names_seg[ 3]);3733 oappend (names_seg[ds_reg - es_reg]); 4817 3734 oappend (":"); 4818 3735 } … … 4821 3738 oappend (scratchbuf); 4822 3739 } 4823 /* ARGSUSED */ 3740 4824 3741 static void 4825 OP_OFF64 ( ignored, sizeflag)4826 int ignoredATTRIBUTE_UNUSED;3742 OP_OFF64 (bytemode, sizeflag) 3743 int bytemode ATTRIBUTE_UNUSED; 4827 3744 int sizeflag ATTRIBUTE_UNUSED; 4828 3745 { 4829 3746 bfd_vma off; 4830 3747 3748 if (!mode_64bit) 3749 { 3750 OP_OFF (bytemode, sizeflag); 3751 return; 3752 } 3753 4831 3754 append_seg (); 4832 3755 4833 off = get64 ();3756 off = get64 (); 4834 3757 4835 3758 if (intel_syntax) 4836 3759 { 4837 3760 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 4838 3761 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 4839 3762 { 4840 oappend (names_seg[ 3]);3763 oappend (names_seg[ds_reg - es_reg]); 4841 3764 oappend (":"); 4842 3765 } … … 4852 3775 { 4853 3776 const char *s; 4854 oappend ("("); 3777 if (intel_syntax) 3778 oappend ("["); 3779 else 3780 oappend ("("); 3781 4855 3782 USED_REX (REX_MODE64); 4856 3783 if (rex & REX_MODE64) 4857 s = names64[code - eAX_reg]; 3784 { 3785 if (!(sizeflag & AFLAG)) 3786 s = names32[code - eAX_reg]; 3787 else 3788 s = names64[code - eAX_reg]; 3789 } 4858 3790 else if (sizeflag & AFLAG) 4859 3791 s = names32[code - eAX_reg]; … … 4861 3793 s = names16[code - eAX_reg]; 4862 3794 oappend (s); 4863 oappend (")"); 3795 if (intel_syntax) 3796 oappend ("]"); 3797 else 3798 oappend (")"); 4864 3799 } 4865 3800 … … 4869 3804 int sizeflag; 4870 3805 { 4871 oappend ("%es:" );3806 oappend ("%es:" + intel_syntax); 4872 3807 ptr_reg (code, sizeflag); 4873 3808 } … … 4886 3821 | PREFIX_GS)) == 0) 4887 3822 prefixes |= PREFIX_DS; 4888 append_seg ();3823 append_seg (); 4889 3824 ptr_reg (code, sizeflag); 4890 3825 } 4891 3826 4892 /* ARGSUSED */4893 3827 static void 4894 3828 OP_C (dummy, sizeflag) … … 4900 3834 if (rex & REX_EXTX) 4901 3835 add = 8; 4902 sprintf (scratchbuf, "%%cr%d", reg+add); 4903 oappend (scratchbuf); 4904 } 4905 4906 /* ARGSUSED */ 3836 sprintf (scratchbuf, "%%cr%d", reg + add); 3837 oappend (scratchbuf + intel_syntax); 3838 } 3839 4907 3840 static void 4908 3841 OP_D (dummy, sizeflag) … … 4914 3847 if (rex & REX_EXTX) 4915 3848 add = 8; 4916 sprintf (scratchbuf, "%%db%d", reg+add); 3849 if (intel_syntax) 3850 sprintf (scratchbuf, "db%d", reg + add); 3851 else 3852 sprintf (scratchbuf, "%%db%d", reg + add); 4917 3853 oappend (scratchbuf); 4918 3854 } 4919 3855 4920 /* ARGSUSED */4921 3856 static void 4922 3857 OP_T (dummy, sizeflag) … … 4925 3860 { 4926 3861 sprintf (scratchbuf, "%%tr%d", reg); 4927 oappend (scratchbuf );3862 oappend (scratchbuf + intel_syntax); 4928 3863 } 4929 3864 … … 4936 3871 OP_E (bytemode, sizeflag); 4937 3872 else 4938 BadOp ();3873 BadOp (); 4939 3874 } 4940 3875 4941 3876 static void 4942 OP_MMX ( ignore, sizeflag)4943 int ignore ATTRIBUTE_UNUSED;3877 OP_MMX (bytemode, sizeflag) 3878 int bytemode ATTRIBUTE_UNUSED; 4944 3879 int sizeflag ATTRIBUTE_UNUSED; 4945 3880 { … … 4953 3888 else 4954 3889 sprintf (scratchbuf, "%%mm%d", reg + add); 4955 oappend (scratchbuf );3890 oappend (scratchbuf + intel_syntax); 4956 3891 } 4957 3892 … … 4966 3901 add = 8; 4967 3902 sprintf (scratchbuf, "%%xmm%d", reg + add); 4968 oappend (scratchbuf );3903 oappend (scratchbuf + intel_syntax); 4969 3904 } 4970 3905 … … 4984 3919 add = 8; 4985 3920 4986 /* skip mod/rm byte*/3921 /* Skip mod/rm byte. */ 4987 3922 MODRM_CHECK; 4988 3923 codep++; … … 4992 3927 else 4993 3928 sprintf (scratchbuf, "%%mm%d", rm + add); 4994 oappend (scratchbuf );3929 oappend (scratchbuf + intel_syntax); 4995 3930 } 4996 3931 … … 5010 3945 add = 8; 5011 3946 5012 /* skip mod/rm byte*/3947 /* Skip mod/rm byte. */ 5013 3948 MODRM_CHECK; 5014 3949 codep++; 5015 3950 sprintf (scratchbuf, "%%xmm%d", rm + add); 5016 oappend (scratchbuf );3951 oappend (scratchbuf + intel_syntax); 5017 3952 } 5018 3953 … … 5025 3960 OP_EM (bytemode, sizeflag); 5026 3961 else 5027 BadOp ();3962 BadOp (); 5028 3963 } 5029 3964 … … 5036 3971 OP_EX (bytemode, sizeflag); 5037 3972 else 5038 BadOp ();5039 } 5040 5041 static const char * Suffix3DNow[] = {3973 BadOp (); 3974 } 3975 3976 static const char *const Suffix3DNow[] = { 5042 3977 /* 00 */ NULL, NULL, NULL, NULL, 5043 3978 /* 04 */ NULL, NULL, NULL, NULL, … … 5117 4052 place where an 8-bit immediate would normally go. ie. the last 5118 4053 byte of the instruction. */ 5119 obufp = obuf + strlen (obuf);4054 obufp = obuf + strlen (obuf); 5120 4055 mnemonic = Suffix3DNow[*codep++ & 0xff]; 5121 4056 if (mnemonic) … … 5129 4064 op1out[0] = '\0'; 5130 4065 op2out[0] = '\0'; 5131 BadOp(); 5132 } 5133 } 5134 5135 5136 static const char *simd_cmp_op [] = { 4066 BadOp (); 4067 } 4068 } 4069 4070 static const char *simd_cmp_op[] = { 5137 4071 "eq", 5138 4072 "lt", … … 5153 4087 5154 4088 FETCH_DATA (the_info, codep + 1); 5155 obufp = obuf + strlen (obuf);4089 obufp = obuf + strlen (obuf); 5156 4090 cmp_type = *codep++ & 0xff; 5157 4091 if (cmp_type < 8) … … 5183 4117 op1out[0] = '\0'; 5184 4118 op2out[0] = '\0'; 5185 BadOp ();4119 BadOp (); 5186 4120 } 5187 4121 } … … 5196 4130 if (mod == 3) 5197 4131 { 5198 char *p = obuf + strlen(obuf); 5199 *(p+1) = '\0'; 5200 *p = *(p-1); 5201 *(p-1) = *(p-2); 5202 *(p-2) = *(p-3); 5203 *(p-3) = extrachar; 5204 } 5205 } 5206 5207 static void BadOp (void) 5208 { 5209 codep = insn_codep + 1; /* throw away prefixes and 1st. opcode byte */ 4132 char *p = obuf + strlen (obuf); 4133 *(p + 1) = '\0'; 4134 *p = *(p - 1); 4135 *(p - 1) = *(p - 2); 4136 *(p - 2) = *(p - 3); 4137 *(p - 3) = extrachar; 4138 } 4139 } 4140 4141 static void 4142 BadOp (void) 4143 { 4144 /* Throw away prefixes and 1st. opcode byte. */ 4145 codep = insn_codep + 1; 5210 4146 oappend ("(bad)"); 5211 4147 } -
Property cvs2svn:cvs-rev
changed from
Note:
See TracChangeset
for help on using the changeset viewer.
