1 /* Print i386 instructions for GDB, the GNU debugger. 2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3 2001, 2002, 2003, 2004 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 20 21 /* 22 * 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu) 23 * July 1988 24 * modified by John Hassey (hassey@dg-rtp.dg.com) 25 * x86-64 support added by Jan Hubicka (jh@suse.cz) 26 * VIA PadLock support by Michal Ludvig (mludvig@suse.cz) 27 */ 28 29 /* 30 * The main tables describing the instructions is essentially a copy 31 * of the "Opcode Map" chapter (Appendix A) of the Intel 80386 32 * Programmers Manual. Usually, there is a capital letter, followed 33 * by a small letter. The capital letter tell the addressing mode, 34 * and the small letter tells about the operand size. Refer to 35 * the Intel manual for details. 36 */ 37 38 #include "dis-asm.h" 39 #include "sysdep.h" 40 #include "opintl.h" 41 42 #define MAXLEN 20 43 44 #include <setjmp.h> 45 46 #ifndef UNIXWARE_COMPAT 47 /* Set non-zero for broken, compatible instructions. Set to zero for 48 non-broken opcodes. */ 49 #define UNIXWARE_COMPAT 1 50 #endif 51 52 static int fetch_data (struct disassemble_info *, bfd_byte *); 53 static void ckprefix (void); 54 static const char *prefix_name (int, int); 55 static int print_insn (bfd_vma, disassemble_info *); 56 static void dofloat (int); 57 static void OP_ST (int, int); 58 static void OP_STi (int, int); 59 static int putop (const char *, int); 60 static void oappend (const char *); 61 static void append_seg (void); 62 static void OP_indirE (int, int); 63 static void print_operand_value (char *, int, bfd_vma); 64 static void OP_E (int, int); 65 static void OP_G (int, int); 66 static bfd_vma get64 (void); 67 static bfd_signed_vma get32 (void); 68 static bfd_signed_vma get32s (void); 69 static int get16 (void); 70 static void set_op (bfd_vma, int); 71 static void OP_REG (int, int); 72 static void OP_IMREG (int, int); 73 static void OP_I (int, int); 74 static void OP_I64 (int, int); 75 static void OP_sI (int, int); 76 static void OP_J (int, int); 77 static void OP_SEG (int, int); 78 static void OP_DIR (int, int); 79 static void OP_OFF (int, int); 80 static void OP_OFF64 (int, int); 81 static void ptr_reg (int, int); 82 static void OP_ESreg (int, int); 83 static void OP_DSreg (int, int); 84 static void OP_C (int, int); 85 static void OP_D (int, int); 86 static void OP_T (int, int); 87 static void OP_Rd (int, int); 88 static void OP_MMX (int, int); 89 static void OP_XMM (int, int); 90 static void OP_EM (int, int); 91 static void OP_EX (int, int); 92 static void OP_MS (int, int); 93 static void OP_XS (int, int); 94 static void OP_M (int, int); 95 static void OP_0fae (int, int); 96 static void NOP_Fixup (int, int); 97 static void OP_3DNowSuffix (int, int); 98 static void OP_xcrypt2 (int, int); 99 static void OP_xcrypt (int, int); 100 static void OP_SIMD_Suffix (int, int); 101 static void SIMD_Fixup (int, int); 102 static void PNI_Fixup (int, int); 103 static void XCR_Fixup (int, int); 104 static void INVLPG_Fixup (int, int); 105 static void OP_0f38 (int, int); 106 static void OP_0f3a (int, int); 107 static void BadOp (void); 108 109 struct dis_private { 110 /* Points to first byte not fetched. */ 111 bfd_byte *max_fetched; 112 bfd_byte the_buffer[MAXLEN]; 113 bfd_vma insn_start; 114 int orig_sizeflag; 115 jmp_buf bailout; 116 }; 117 118 /* The opcode for the fwait instruction, which we treat as a prefix 119 when we can. */ 120 #define FWAIT_OPCODE (0x9b) 121 122 /* Set to 1 for 64bit mode disassembly. */ 123 static int mode_64bit; 124 125 /* Flags for the prefixes for the current instruction. See below. */ 126 static int prefixes; 127 128 /* REX prefix the current instruction. See below. */ 129 static int rex; 130 /* Bits of REX we've already used. */ 131 static int rex_used; 132 #define REX_MODE64 8 133 #define REX_EXTX 4 134 #define REX_EXTY 2 135 #define REX_EXTZ 1 136 /* Mark parts used in the REX prefix. When we are testing for 137 empty prefix (for 8bit register REX extension), just mask it 138 out. Otherwise test for REX bit is excuse for existence of REX 139 only in case value is nonzero. */ 140 #define USED_REX(value) \ 141 { \ 142 if (value) \ 143 rex_used |= (rex & value) ? (value) | 0x40 : 0; \ 144 else \ 145 rex_used |= 0x40; \ 146 } 147 148 /* Flags for prefixes which we somehow handled when printing the 149 current instruction. */ 150 static int used_prefixes; 151 152 /* Flags stored in PREFIXES. */ 153 #define PREFIX_REPZ 1 154 #define PREFIX_REPNZ 2 155 #define PREFIX_LOCK 4 156 #define PREFIX_CS 8 157 #define PREFIX_SS 0x10 158 #define PREFIX_DS 0x20 159 #define PREFIX_ES 0x40 160 #define PREFIX_FS 0x80 161 #define PREFIX_GS 0x100 162 #define PREFIX_DATA 0x200 163 #define PREFIX_ADDR 0x400 164 #define PREFIX_FWAIT 0x800 165 166 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) 167 to ADDR (exclusive) are valid. Returns 1 for success, longjmps 168 on error. */ 169 #define FETCH_DATA(info, addr) \ 170 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \ 171 ? 1 : fetch_data ((info), (addr))) 172 173 static int 174 fetch_data (struct disassemble_info *info, bfd_byte *addr) 175 { 176 int status; 177 struct dis_private *priv = (struct dis_private *) info->private_data; 178 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 179 180 status = (*info->read_memory_func) (start, 181 priv->max_fetched, 182 addr - priv->max_fetched, 183 info); 184 if (status != 0) 185 { 186 /* If we did manage to read at least one byte, then 187 print_insn_i386 will do something sensible. Otherwise, print 188 an error. We do that here because this is where we know 189 STATUS. */ 190 if (priv->max_fetched == priv->the_buffer) 191 (*info->memory_error_func) (status, start, info); 192 longjmp (priv->bailout, 1); 193 } 194 else 195 priv->max_fetched = addr; 196 return 1; 197 } 198 199 #define XX NULL, 0 200 201 #define Eb OP_E, b_mode 202 #define Ev OP_E, v_mode 203 #define Ed OP_E, d_mode 204 #define Edq OP_E, dq_mode 205 #define indirEb OP_indirE, b_mode 206 #define indirEv OP_indirE, v_mode 207 #define Ew OP_E, w_mode 208 #define Ma OP_E, v_mode 209 #define M OP_M, 0 /* lea, lgdt, etc. */ 210 #define Mp OP_M, 0 /* 32 or 48 bit memory operand for LDS, LES etc */ 211 #define Gb OP_G, b_mode 212 #define Gv OP_G, v_mode 213 #define Gd OP_G, d_mode 214 #define Gw OP_G, w_mode 215 #define Rd OP_Rd, d_mode 216 #define Rm OP_Rd, m_mode 217 #define Ib OP_I, b_mode 218 #define sIb OP_sI, b_mode /* sign extened byte */ 219 #define Iv OP_I, v_mode 220 #define Iq OP_I, q_mode 221 #define Iv64 OP_I64, v_mode 222 #define Iw OP_I, w_mode 223 #define Jb OP_J, b_mode 224 #define Jv OP_J, v_mode 225 #define Cm OP_C, m_mode 226 #define Dm OP_D, m_mode 227 #define Td OP_T, d_mode 228 229 #define RMeAX OP_REG, eAX_reg 230 #define RMeBX OP_REG, eBX_reg 231 #define RMeCX OP_REG, eCX_reg 232 #define RMeDX OP_REG, eDX_reg 233 #define RMeSP OP_REG, eSP_reg 234 #define RMeBP OP_REG, eBP_reg 235 #define RMeSI OP_REG, eSI_reg 236 #define RMeDI OP_REG, eDI_reg 237 #define RMrAX OP_REG, rAX_reg 238 #define RMrBX OP_REG, rBX_reg 239 #define RMrCX OP_REG, rCX_reg 240 #define RMrDX OP_REG, rDX_reg 241 #define RMrSP OP_REG, rSP_reg 242 #define RMrBP OP_REG, rBP_reg 243 #define RMrSI OP_REG, rSI_reg 244 #define RMrDI OP_REG, rDI_reg 245 #define RMAL OP_REG, al_reg 246 #define RMAL OP_REG, al_reg 247 #define RMCL OP_REG, cl_reg 248 #define RMDL OP_REG, dl_reg 249 #define RMBL OP_REG, bl_reg 250 #define RMAH OP_REG, ah_reg 251 #define RMCH OP_REG, ch_reg 252 #define RMDH OP_REG, dh_reg 253 #define RMBH OP_REG, bh_reg 254 #define RMAX OP_REG, ax_reg 255 #define RMDX OP_REG, dx_reg 256 257 #define eAX OP_IMREG, eAX_reg 258 #define eBX OP_IMREG, eBX_reg 259 #define eCX OP_IMREG, eCX_reg 260 #define eDX OP_IMREG, eDX_reg 261 #define eSP OP_IMREG, eSP_reg 262 #define eBP OP_IMREG, eBP_reg 263 #define eSI OP_IMREG, eSI_reg 264 #define eDI OP_IMREG, eDI_reg 265 #define AL OP_IMREG, al_reg 266 #define AL OP_IMREG, al_reg 267 #define CL OP_IMREG, cl_reg 268 #define DL OP_IMREG, dl_reg 269 #define BL OP_IMREG, bl_reg 270 #define AH OP_IMREG, ah_reg 271 #define CH OP_IMREG, ch_reg 272 #define DH OP_IMREG, dh_reg 273 #define BH OP_IMREG, bh_reg 274 #define AX OP_IMREG, ax_reg 275 #define DX OP_IMREG, dx_reg 276 #define indirDX OP_IMREG, indir_dx_reg 277 278 #define Sw OP_SEG, w_mode 279 #define Ap OP_DIR, 0 280 #define Ob OP_OFF, b_mode 281 #define Ob64 OP_OFF64, b_mode 282 #define Ov OP_OFF, v_mode 283 #define Ov64 OP_OFF64, v_mode 284 #define Xb OP_DSreg, eSI_reg 285 #define Xv OP_DSreg, eSI_reg 286 #define Yb OP_ESreg, eDI_reg 287 #define Yv OP_ESreg, eDI_reg 288 #define DSBX OP_DSreg, eBX_reg 289 290 #define es OP_REG, es_reg 291 #define ss OP_REG, ss_reg 292 #define cs OP_REG, cs_reg 293 #define ds OP_REG, ds_reg 294 #define fs OP_REG, fs_reg 295 #define gs OP_REG, gs_reg 296 297 #define MX OP_MMX, 0 298 #define XM OP_XMM, 0 299 #define EM OP_EM, v_mode 300 #define EX OP_EX, v_mode 301 #define MS OP_MS, v_mode 302 #define XS OP_XS, v_mode 303 #define OPSUF OP_3DNowSuffix, 0 304 #define OPXCRYPT OP_xcrypt, 0 305 #define OPXCRYPT2 OP_xcrypt2, 0 306 #define OPSIMD OP_SIMD_Suffix, 0 307 #define OP0F38 OP_0f38, 0 308 #define OP0F3A OP_0f3a, 0 309 310 #define cond_jump_flag NULL, cond_jump_mode 311 #define loop_jcxz_flag NULL, loop_jcxz_mode 312 313 /* bits in sizeflag */ 314 #define SUFFIX_ALWAYS 4 315 #define AFLAG 2 316 #define DFLAG 1 317 318 #define b_mode 1 /* byte operand */ 319 #define v_mode 2 /* operand size depends on prefixes */ 320 #define w_mode 3 /* word operand */ 321 #define d_mode 4 /* double word operand */ 322 #define q_mode 5 /* quad word operand */ 323 #define x_mode 6 324 #define m_mode 7 /* d_mode in 32bit, q_mode in 64bit mode. */ 325 #define cond_jump_mode 8 326 #define loop_jcxz_mode 9 327 #define dq_mode 10 /* operand size depends on REX prefixes. */ 328 329 #define es_reg 100 330 #define cs_reg 101 331 #define ss_reg 102 332 #define ds_reg 103 333 #define fs_reg 104 334 #define gs_reg 105 335 336 #define eAX_reg 108 337 #define eCX_reg 109 338 #define eDX_reg 110 339 #define eBX_reg 111 340 #define eSP_reg 112 341 #define eBP_reg 113 342 #define eSI_reg 114 343 #define eDI_reg 115 344 345 #define al_reg 116 346 #define cl_reg 117 347 #define dl_reg 118 348 #define bl_reg 119 349 #define ah_reg 120 350 #define ch_reg 121 351 #define dh_reg 122 352 #define bh_reg 123 353 354 #define ax_reg 124 355 #define cx_reg 125 356 #define dx_reg 126 357 #define bx_reg 127 358 #define sp_reg 128 359 #define bp_reg 129 360 #define si_reg 130 361 #define di_reg 131 362 363 #define rAX_reg 132 364 #define rCX_reg 133 365 #define rDX_reg 134 366 #define rBX_reg 135 367 #define rSP_reg 136 368 #define rBP_reg 137 369 #define rSI_reg 138 370 #define rDI_reg 139 371 372 #define indir_dx_reg 150 373 374 #define FLOATCODE 1 375 #define USE_GROUPS 2 376 #define USE_PREFIX_USER_TABLE 3 377 #define X86_64_SPECIAL 4 378 379 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 380 381 #define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0 382 #define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0 383 #define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0 384 #define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0 385 #define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0 386 #define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0 387 #define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0 388 #define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0 389 #define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0 390 #define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0 391 #define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0 392 #define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0 393 #define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0 394 #define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0 395 #define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0 396 #define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0 397 #define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0 398 #define GRP10 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0 399 #define GRP11 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0 400 #define GRP12 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0 401 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0 402 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0 403 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0 404 405 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0 406 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0 407 #define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0 408 #define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0 409 #define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0 410 #define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0 411 #define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0 412 #define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0 413 #define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0 414 #define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0 415 #define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0 416 #define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0 417 #define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0 418 #define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0 419 #define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0 420 #define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0 421 #define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0 422 #define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0 423 #define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0 424 #define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0 425 #define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0 426 #define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0 427 #define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0 428 #define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0 429 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0 430 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0 431 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0 432 #define PREGRP27 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0 433 #define PREGRP28 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0 434 #define PREGRP29 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0 435 #define PREGRP30 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0 436 #define PREGRP31 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0 437 #define PREGRP32 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0 438 439 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0 440 441 typedef void (*op_rtn) (int bytemode, int sizeflag); 442 443 struct dis386 { 444 const char *name; 445 op_rtn op1; 446 int bytemode1; 447 op_rtn op2; 448 int bytemode2; 449 op_rtn op3; 450 int bytemode3; 451 }; 452 453 /* Upper case letters in the instruction names here are macros. 454 'A' => print 'b' if no register operands or suffix_always is true 455 'B' => print 'b' if suffix_always is true 456 'E' => print 'e' if 32-bit form of jcxz 457 'F' => print 'w' or 'l' depending on address size prefix (loop insns) 458 'H' => print ",pt" or ",pn" branch hint 459 'L' => print 'l' if suffix_always is true 460 'N' => print 'n' if instruction has no wait "prefix" 461 'O' => print 'd', or 'o' 462 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix, 463 . or suffix_always is true. print 'q' if rex prefix is present. 464 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always 465 . is true 466 'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode) 467 'S' => print 'w', 'l' or 'q' if suffix_always is true 468 'T' => print 'q' in 64bit mode and behave as 'P' otherwise 469 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise 470 'X' => print 's', 'd' depending on data16 prefix (for XMM) 471 'W' => print 'b' or 'w' ("w" or "de" in intel mode) 472 'Y' => 'q' if instruction has an REX 64bit overwrite prefix 473 474 Many of the above letters print nothing in Intel mode. See "putop" 475 for the details. 476 477 Braces '{' and '}', and vertical bars '|', indicate alternative 478 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel 479 modes. In cases where there are only two alternatives, the X86_64 480 instruction is reserved, and "(bad)" is printed. 481 */ 482 483 static const struct dis386 dis386[] = { 484 /* 00 */ 485 { "addB", Eb, Gb, XX }, 486 { "addS", Ev, Gv, XX }, 487 { "addB", Gb, Eb, XX }, 488 { "addS", Gv, Ev, XX }, 489 { "addB", AL, Ib, XX }, 490 { "addS", eAX, Iv, XX }, 491 { "push{T|}", es, XX, XX }, 492 { "pop{T|}", es, XX, XX }, 493 /* 08 */ 494 { "orB", Eb, Gb, XX }, 495 { "orS", Ev, Gv, XX }, 496 { "orB", Gb, Eb, XX }, 497 { "orS", Gv, Ev, XX }, 498 { "orB", AL, Ib, XX }, 499 { "orS", eAX, Iv, XX }, 500 { "push{T|}", cs, XX, XX }, 501 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */ 502 /* 10 */ 503 { "adcB", Eb, Gb, XX }, 504 { "adcS", Ev, Gv, XX }, 505 { "adcB", Gb, Eb, XX }, 506 { "adcS", Gv, Ev, XX }, 507 { "adcB", AL, Ib, XX }, 508 { "adcS", eAX, Iv, XX }, 509 { "push{T|}", ss, XX, XX }, 510 { "popT|}", ss, XX, XX }, 511 /* 18 */ 512 { "sbbB", Eb, Gb, XX }, 513 { "sbbS", Ev, Gv, XX }, 514 { "sbbB", Gb, Eb, XX }, 515 { "sbbS", Gv, Ev, XX }, 516 { "sbbB", AL, Ib, XX }, 517 { "sbbS", eAX, Iv, XX }, 518 { "push{T|}", ds, XX, XX }, 519 { "pop{T|}", ds, XX, XX }, 520 /* 20 */ 521 { "andB", Eb, Gb, XX }, 522 { "andS", Ev, Gv, XX }, 523 { "andB", Gb, Eb, XX }, 524 { "andS", Gv, Ev, XX }, 525 { "andB", AL, Ib, XX }, 526 { "andS", eAX, Iv, XX }, 527 { "(bad)", XX, XX, XX }, /* SEG ES prefix */ 528 { "daa{|}", XX, XX, XX }, 529 /* 28 */ 530 { "subB", Eb, Gb, XX }, 531 { "subS", Ev, Gv, XX }, 532 { "subB", Gb, Eb, XX }, 533 { "subS", Gv, Ev, XX }, 534 { "subB", AL, Ib, XX }, 535 { "subS", eAX, Iv, XX }, 536 { "(bad)", XX, XX, XX }, /* SEG CS prefix */ 537 { "das{|}", XX, XX, XX }, 538 /* 30 */ 539 { "xorB", Eb, Gb, XX }, 540 { "xorS", Ev, Gv, XX }, 541 { "xorB", Gb, Eb, XX }, 542 { "xorS", Gv, Ev, XX }, 543 { "xorB", AL, Ib, XX }, 544 { "xorS", eAX, Iv, XX }, 545 { "(bad)", XX, XX, XX }, /* SEG SS prefix */ 546 { "aaa{|}", XX, XX, XX }, 547 /* 38 */ 548 { "cmpB", Eb, Gb, XX }, 549 { "cmpS", Ev, Gv, XX }, 550 { "cmpB", Gb, Eb, XX }, 551 { "cmpS", Gv, Ev, XX }, 552 { "cmpB", AL, Ib, XX }, 553 { "cmpS", eAX, Iv, XX }, 554 { "(bad)", XX, XX, XX }, /* SEG DS prefix */ 555 { "aas{|}", XX, XX, XX }, 556 /* 40 */ 557 { "inc{S|}", RMeAX, XX, XX }, 558 { "inc{S|}", RMeCX, XX, XX }, 559 { "inc{S|}", RMeDX, XX, XX }, 560 { "inc{S|}", RMeBX, XX, XX }, 561 { "inc{S|}", RMeSP, XX, XX }, 562 { "inc{S|}", RMeBP, XX, XX }, 563 { "inc{S|}", RMeSI, XX, XX }, 564 { "inc{S|}", RMeDI, XX, XX }, 565 /* 48 */ 566 { "dec{S|}", RMeAX, XX, XX }, 567 { "dec{S|}", RMeCX, XX, XX }, 568 { "dec{S|}", RMeDX, XX, XX }, 569 { "dec{S|}", RMeBX, XX, XX }, 570 { "dec{S|}", RMeSP, XX, XX }, 571 { "dec{S|}", RMeBP, XX, XX }, 572 { "dec{S|}", RMeSI, XX, XX }, 573 { "dec{S|}", RMeDI, XX, XX }, 574 /* 50 */ 575 { "pushS", RMrAX, XX, XX }, 576 { "pushS", RMrCX, XX, XX }, 577 { "pushS", RMrDX, XX, XX }, 578 { "pushS", RMrBX, XX, XX }, 579 { "pushS", RMrSP, XX, XX }, 580 { "pushS", RMrBP, XX, XX }, 581 { "pushS", RMrSI, XX, XX }, 582 { "pushS", RMrDI, XX, XX }, 583 /* 58 */ 584 { "popS", RMrAX, XX, XX }, 585 { "popS", RMrCX, XX, XX }, 586 { "popS", RMrDX, XX, XX }, 587 { "popS", RMrBX, XX, XX }, 588 { "popS", RMrSP, XX, XX }, 589 { "popS", RMrBP, XX, XX }, 590 { "popS", RMrSI, XX, XX }, 591 { "popS", RMrDI, XX, XX }, 592 /* 60 */ 593 { "pusha{P|}", XX, XX, XX }, 594 { "popa{P|}", XX, XX, XX }, 595 { "bound{S|}", Gv, Ma, XX }, 596 { X86_64_0 }, 597 { "(bad)", XX, XX, XX }, /* seg fs */ 598 { "(bad)", XX, XX, XX }, /* seg gs */ 599 { "(bad)", XX, XX, XX }, /* op size prefix */ 600 { "(bad)", XX, XX, XX }, /* adr size prefix */ 601 /* 68 */ 602 { "pushT", Iq, XX, XX }, 603 { "imulS", Gv, Ev, Iv }, 604 { "pushT", sIb, XX, XX }, 605 { "imulS", Gv, Ev, sIb }, 606 { "ins{b||b|}", Yb, indirDX, XX }, 607 { "ins{R||R|}", Yv, indirDX, XX }, 608 { "outs{b||b|}", indirDX, Xb, XX }, 609 { "outs{R||R|}", indirDX, Xv, XX }, 610 /* 70 */ 611 { "joH", Jb, XX, cond_jump_flag }, 612 { "jnoH", Jb, XX, cond_jump_flag }, 613 { "jbH", Jb, XX, cond_jump_flag }, 614 { "jaeH", Jb, XX, cond_jump_flag }, 615 { "jeH", Jb, XX, cond_jump_flag }, 616 { "jneH", Jb, XX, cond_jump_flag }, 617 { "jbeH", Jb, XX, cond_jump_flag }, 618 { "jaH", Jb, XX, cond_jump_flag }, 619 /* 78 */ 620 { "jsH", Jb, XX, cond_jump_flag }, 621 { "jnsH", Jb, XX, cond_jump_flag }, 622 { "jpH", Jb, XX, cond_jump_flag }, 623 { "jnpH", Jb, XX, cond_jump_flag }, 624 { "jlH", Jb, XX, cond_jump_flag }, 625 { "jgeH", Jb, XX, cond_jump_flag }, 626 { "jleH", Jb, XX, cond_jump_flag }, 627 { "jgH", Jb, XX, cond_jump_flag }, 628 /* 80 */ 629 { GRP1b }, 630 { GRP1S }, 631 { "(bad)", XX, XX, XX }, 632 { GRP1Ss }, 633 { "testB", Eb, Gb, XX }, 634 { "testS", Ev, Gv, XX }, 635 { "xchgB", Eb, Gb, XX }, 636 { "xchgS", Ev, Gv, XX }, 637 /* 88 */ 638 { "movB", Eb, Gb, XX }, 639 { "movS", Ev, Gv, XX }, 640 { "movB", Gb, Eb, XX }, 641 { "movS", Gv, Ev, XX }, 642 { "movQ", Ev, Sw, XX }, 643 { "leaS", Gv, M, XX }, 644 { "movQ", Sw, Ev, XX }, 645 { "popU", Ev, XX, XX }, 646 /* 90 */ 647 { "nop", NOP_Fixup, 0, XX, XX }, 648 { "xchgS", RMeCX, eAX, XX }, 649 { "xchgS", RMeDX, eAX, XX }, 650 { "xchgS", RMeBX, eAX, XX }, 651 { "xchgS", RMeSP, eAX, XX }, 652 { "xchgS", RMeBP, eAX, XX }, 653 { "xchgS", RMeSI, eAX, XX }, 654 { "xchgS", RMeDI, eAX, XX }, 655 /* 98 */ 656 { "cW{tR||tR|}", XX, XX, XX }, 657 { "cR{tO||tO|}", XX, XX, XX }, 658 { "lcall{T|}", Ap, XX, XX }, 659 { "(bad)", XX, XX, XX }, /* fwait */ 660 { "pushfT", XX, XX, XX }, 661 { "popfT", XX, XX, XX }, 662 { "sahf{|}", XX, XX, XX }, 663 { "lahf{|}", XX, XX, XX }, 664 /* a0 */ 665 { "movB", AL, Ob64, XX }, 666 { "movS", eAX, Ov64, XX }, 667 { "movB", Ob64, AL, XX }, 668 { "movS", Ov64, eAX, XX }, 669 { "movs{b||b|}", Yb, Xb, XX }, 670 { "movs{R||R|}", Yv, Xv, XX }, 671 { "cmps{b||b|}", Xb, Yb, XX }, 672 { "cmps{R||R|}", Xv, Yv, XX }, 673 /* a8 */ 674 { "testB", AL, Ib, XX }, 675 { "testS", eAX, Iv, XX }, 676 { "stosB", Yb, AL, XX }, 677 { "stosS", Yv, eAX, XX }, 678 { "lodsB", AL, Xb, XX }, 679 { "lodsS", eAX, Xv, XX }, 680 { "scasB", AL, Yb, XX }, 681 { "scasS", eAX, Yv, XX }, 682 /* b0 */ 683 { "movB", RMAL, Ib, XX }, 684 { "movB", RMCL, Ib, XX }, 685 { "movB", RMDL, Ib, XX }, 686 { "movB", RMBL, Ib, XX }, 687 { "movB", RMAH, Ib, XX }, 688 { "movB", RMCH, Ib, XX }, 689 { "movB", RMDH, Ib, XX }, 690 { "movB", RMBH, Ib, XX }, 691 /* b8 */ 692 { "movS", RMeAX, Iv64, XX }, 693 { "movS", RMeCX, Iv64, XX }, 694 { "movS", RMeDX, Iv64, XX }, 695 { "movS", RMeBX, Iv64, XX }, 696 { "movS", RMeSP, Iv64, XX }, 697 { "movS", RMeBP, Iv64, XX }, 698 { "movS", RMeSI, Iv64, XX }, 699 { "movS", RMeDI, Iv64, XX }, 700 /* c0 */ 701 { GRP2b }, 702 { GRP2S }, 703 { "retT", Iw, XX, XX }, 704 { "retT", XX, XX, XX }, 705 { "les{S|}", Gv, Mp, XX }, 706 { "ldsS", Gv, Mp, XX }, 707 { "movA", Eb, Ib, XX }, 708 { "movQ", Ev, Iv, XX }, 709 /* c8 */ 710 { "enterT", Iw, Ib, XX }, 711 { "leaveT", XX, XX, XX }, 712 { "lretP", Iw, XX, XX }, 713 { "lretP", XX, XX, XX }, 714 { "int3", XX, XX, XX }, 715 { "int", Ib, XX, XX }, 716 { "into{|}", XX, XX, XX }, 717 { "iretP", XX, XX, XX }, 718 /* d0 */ 719 { GRP2b_one }, 720 { GRP2S_one }, 721 { GRP2b_cl }, 722 { GRP2S_cl }, 723 { "aam{|}", sIb, XX, XX }, 724 { "aad{|}", sIb, XX, XX }, 725 { "(bad)", XX, XX, XX }, 726 { "xlat", DSBX, XX, XX }, 727 /* d8 */ 728 { FLOAT }, 729 { FLOAT }, 730 { FLOAT }, 731 { FLOAT }, 732 { FLOAT }, 733 { FLOAT }, 734 { FLOAT }, 735 { FLOAT }, 736 /* e0 */ 737 { "loopneFH", Jb, XX, loop_jcxz_flag }, 738 { "loopeFH", Jb, XX, loop_jcxz_flag }, 739 { "loopFH", Jb, XX, loop_jcxz_flag }, 740 { "jEcxzH", Jb, XX, loop_jcxz_flag }, 741 { "inB", AL, Ib, XX }, 742 { "inS", eAX, Ib, XX }, 743 { "outB", Ib, AL, XX }, 744 { "outS", Ib, eAX, XX }, 745 /* e8 */ 746 { "callT", Jv, XX, XX }, 747 { "jmpT", Jv, XX, XX }, 748 { "ljmp{T|}", Ap, XX, XX }, 749 { "jmp", Jb, XX, XX }, 750 { "inB", AL, indirDX, XX }, 751 { "inS", eAX, indirDX, XX }, 752 { "outB", indirDX, AL, XX }, 753 { "outS", indirDX, eAX, XX }, 754 /* f0 */ 755 { "(bad)", XX, XX, XX }, /* lock prefix */ 756 { "icebp", XX, XX, XX }, 757 { "(bad)", XX, XX, XX }, /* repne */ 758 { "(bad)", XX, XX, XX }, /* repz */ 759 { "hlt", XX, XX, XX }, 760 { "cmc", XX, XX, XX }, 761 { GRP3b }, 762 { GRP3S }, 763 /* f8 */ 764 { "clc", XX, XX, XX }, 765 { "stc", XX, XX, XX }, 766 { "cli", XX, XX, XX }, 767 { "sti", XX, XX, XX }, 768 { "cld", XX, XX, XX }, 769 { "std", XX, XX, XX }, 770 { GRP4 }, 771 { GRP5 }, 772 }; 773 774 static const struct dis386 dis386_twobyte[] = { 775 /* 00 */ 776 { GRP6 }, 777 { GRP7 }, 778 { "larS", Gv, Ew, XX }, 779 { "lslS", Gv, Ew, XX }, 780 { "(bad)", XX, XX, XX }, 781 { "syscall", XX, XX, XX }, 782 { "clts", XX, XX, XX }, 783 { "sysretP", XX, XX, XX }, 784 /* 08 */ 785 { "invd", XX, XX, XX }, 786 { "wbinvd", XX, XX, XX }, 787 { "(bad)", XX, XX, XX }, 788 { "ud2a", XX, XX, XX }, 789 { "(bad)", XX, XX, XX }, 790 { GRPAMD }, 791 { "femms", XX, XX, XX }, 792 { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */ 793 /* 10 */ 794 { PREGRP8 }, 795 { PREGRP9 }, 796 { PREGRP30 }, 797 { "movlpX", EX, XM, SIMD_Fixup, 'h' }, 798 { "unpcklpX", XM, EX, XX }, 799 { "unpckhpX", XM, EX, XX }, 800 { PREGRP31 }, 801 { "movhpX", EX, XM, SIMD_Fixup, 'l' }, 802 /* 18 */ 803 { GRP14 }, 804 { "(bad)", XX, XX, XX }, 805 { "(bad)", XX, XX, XX }, 806 { "(bad)", XX, XX, XX }, 807 { "(bad)", XX, XX, XX }, 808 { "(bad)", XX, XX, XX }, 809 { "(bad)", XX, XX, XX }, 810 { "(bad)", XX, XX, XX }, 811 /* 20 */ 812 { "movL", Rm, Cm, XX }, 813 { "movL", Rm, Dm, XX }, 814 { "movL", Cm, Rm, XX }, 815 { "movL", Dm, Rm, XX }, 816 { "movL", Rd, Td, XX }, 817 { "(bad)", XX, XX, XX }, 818 { "movL", Td, Rd, XX }, 819 { "(bad)", XX, XX, XX }, 820 /* 28 */ 821 { "movapX", XM, EX, XX }, 822 { "movapX", EX, XM, XX }, 823 { PREGRP2 }, 824 { "movntpX", Ev, XM, XX }, 825 { PREGRP4 }, 826 { PREGRP3 }, 827 { "ucomisX", XM,EX, XX }, 828 { "comisX", XM,EX, XX }, 829 /* 30 */ 830 { "wrmsr", XX, XX, XX }, 831 { "rdtsc", XX, XX, XX }, 832 { "rdmsr", XX, XX, XX }, 833 { "rdpmc", XX, XX, XX }, 834 { "sysenter", XX, XX, XX }, 835 { "sysexit", XX, XX, XX }, 836 { "(bad)", XX, XX, XX }, 837 { "(bad)", XX, XX, XX }, 838 /* 38 */ 839 { "", OP0F38, XX, XX }, 840 { "(bad)", XX, XX, XX }, 841 { "", OP0F3A, XX, XX }, 842 { "(bad)", XX, XX, XX }, 843 { "(bad)", XX, XX, XX }, 844 { "(bad)", XX, XX, XX }, 845 { "(bad)", XX, XX, XX }, 846 { "(bad)", XX, XX, XX }, 847 /* 40 */ 848 { "cmovo", Gv, Ev, XX }, 849 { "cmovno", Gv, Ev, XX }, 850 { "cmovb", Gv, Ev, XX }, 851 { "cmovae", Gv, Ev, XX }, 852 { "cmove", Gv, Ev, XX }, 853 { "cmovne", Gv, Ev, XX }, 854 { "cmovbe", Gv, Ev, XX }, 855 { "cmova", Gv, Ev, XX }, 856 /* 48 */ 857 { "cmovs", Gv, Ev, XX }, 858 { "cmovns", Gv, Ev, XX }, 859 { "cmovp", Gv, Ev, XX }, 860 { "cmovnp", Gv, Ev, XX }, 861 { "cmovl", Gv, Ev, XX }, 862 { "cmovge", Gv, Ev, XX }, 863 { "cmovle", Gv, Ev, XX }, 864 { "cmovg", Gv, Ev, XX }, 865 /* 50 */ 866 { "movmskpX", Gd, XS, XX }, 867 { PREGRP13 }, 868 { PREGRP12 }, 869 { PREGRP11 }, 870 { "andpX", XM, EX, XX }, 871 { "andnpX", XM, EX, XX }, 872 { "orpX", XM, EX, XX }, 873 { "xorpX", XM, EX, XX }, 874 /* 58 */ 875 { PREGRP0 }, 876 { PREGRP10 }, 877 { PREGRP17 }, 878 { PREGRP16 }, 879 { PREGRP14 }, 880 { PREGRP7 }, 881 { PREGRP5 }, 882 { PREGRP6 }, 883 /* 60 */ 884 { "punpcklbw", MX, EM, XX }, 885 { "punpcklwd", MX, EM, XX }, 886 { "punpckldq", MX, EM, XX }, 887 { "packsswb", MX, EM, XX }, 888 { "pcmpgtb", MX, EM, XX }, 889 { "pcmpgtw", MX, EM, XX }, 890 { "pcmpgtd", MX, EM, XX }, 891 { "packuswb", MX, EM, XX }, 892 /* 68 */ 893 { "punpckhbw", MX, EM, XX }, 894 { "punpckhwd", MX, EM, XX }, 895 { "punpckhdq", MX, EM, XX }, 896 { "packssdw", MX, EM, XX }, 897 { PREGRP26 }, 898 { PREGRP24 }, 899 { "movd", MX, Edq, XX }, 900 { PREGRP19 }, 901 /* 70 */ 902 { PREGRP22 }, 903 { GRP10 }, 904 { GRP11 }, 905 { GRP12 }, 906 { "pcmpeqb", MX, EM, XX }, 907 { "pcmpeqw", MX, EM, XX }, 908 { "pcmpeqd", MX, EM, XX }, 909 { "emms", XX, XX, XX }, 910 /* 78 */ 911 { "(bad)", XX, XX, XX }, 912 { "(bad)", XX, XX, XX }, 913 { "(bad)", XX, XX, XX }, 914 { "(bad)", XX, XX, XX }, 915 { PREGRP28 }, 916 { PREGRP29 }, 917 { PREGRP23 }, 918 { PREGRP20 }, 919 /* 80 */ 920 { "joH", Jv, XX, cond_jump_flag }, 921 { "jnoH", Jv, XX, cond_jump_flag }, 922 { "jbH", Jv, XX, cond_jump_flag }, 923 { "jaeH", Jv, XX, cond_jump_flag }, 924 { "jeH", Jv, XX, cond_jump_flag }, 925 { "jneH", Jv, XX, cond_jump_flag }, 926 { "jbeH", Jv, XX, cond_jump_flag }, 927 { "jaH", Jv, XX, cond_jump_flag }, 928 /* 88 */ 929 { "jsH", Jv, XX, cond_jump_flag }, 930 { "jnsH", Jv, XX, cond_jump_flag }, 931 { "jpH", Jv, XX, cond_jump_flag }, 932 { "jnpH", Jv, XX, cond_jump_flag }, 933 { "jlH", Jv, XX, cond_jump_flag }, 934 { "jgeH", Jv, XX, cond_jump_flag }, 935 { "jleH", Jv, XX, cond_jump_flag }, 936 { "jgH", Jv, XX, cond_jump_flag }, 937 /* 90 */ 938 { "seto", Eb, XX, XX }, 939 { "setno", Eb, XX, XX }, 940 { "setb", Eb, XX, XX }, 941 { "setae", Eb, XX, XX }, 942 { "sete", Eb, XX, XX }, 943 { "setne", Eb, XX, XX }, 944 { "setbe", Eb, XX, XX }, 945 { "seta", Eb, XX, XX }, 946 /* 98 */ 947 { "sets", Eb, XX, XX }, 948 { "setns", Eb, XX, XX }, 949 { "setp", Eb, XX, XX }, 950 { "setnp", Eb, XX, XX }, 951 { "setl", Eb, XX, XX }, 952 { "setge", Eb, XX, XX }, 953 { "setle", Eb, XX, XX }, 954 { "setg", Eb, XX, XX }, 955 /* a0 */ 956 { "pushT", fs, XX, XX }, 957 { "popT", fs, XX, XX }, 958 { "cpuid", XX, XX, XX }, 959 { "btS", Ev, Gv, XX }, 960 { "shldS", Ev, Gv, Ib }, 961 { "shldS", Ev, Gv, CL }, 962 { "", OPXCRYPT2, XX, XX }, 963 { "", OPXCRYPT, XX, XX }, 964 /* a8 */ 965 { "pushT", gs, XX, XX }, 966 { "popT", gs, XX, XX }, 967 { "rsm", XX, XX, XX }, 968 { "btsS", Ev, Gv, XX }, 969 { "shrdS", Ev, Gv, Ib }, 970 { "shrdS", Ev, Gv, CL }, 971 { GRP13 }, 972 { "imulS", Gv, Ev, XX }, 973 /* b0 */ 974 { "cmpxchgB", Eb, Gb, XX }, 975 { "cmpxchgS", Ev, Gv, XX }, 976 { "lssS", Gv, Mp, XX }, 977 { "btrS", Ev, Gv, XX }, 978 { "lfsS", Gv, Mp, XX }, 979 { "lgsS", Gv, Mp, XX }, 980 { "movz{bR|x|bR|x}", Gv, Eb, XX }, 981 { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */ 982 /* b8 */ 983 { "(bad)", XX, XX, XX }, 984 { "ud2b", XX, XX, XX }, 985 { GRP8 }, 986 { "btcS", Ev, Gv, XX }, 987 { "bsfS", Gv, Ev, XX }, 988 { "bsrS", Gv, Ev, XX }, 989 { "movs{bR|x|bR|x}", Gv, Eb, XX }, 990 { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */ 991 /* c0 */ 992 { "xaddB", Eb, Gb, XX }, 993 { "xaddS", Ev, Gv, XX }, 994 { PREGRP1 }, 995 { "movntiS", Ev, Gv, XX }, 996 { "pinsrw", MX, Ed, Ib }, 997 { "pextrw", Gd, MS, Ib }, 998 { "shufpX", XM, EX, Ib }, 999 { GRP9 }, 1000 /* c8 */ 1001 { "bswap", RMeAX, XX, XX }, 1002 { "bswap", RMeCX, XX, XX }, 1003 { "bswap", RMeDX, XX, XX }, 1004 { "bswap", RMeBX, XX, XX }, 1005 { "bswap", RMeSP, XX, XX }, 1006 { "bswap", RMeBP, XX, XX }, 1007 { "bswap", RMeSI, XX, XX }, 1008 { "bswap", RMeDI, XX, XX }, 1009 /* d0 */ 1010 { PREGRP27 }, 1011 { "psrlw", MX, EM, XX }, 1012 { "psrld", MX, EM, XX }, 1013 { "psrlq", MX, EM, XX }, 1014 { "paddq", MX, EM, XX }, 1015 { "pmullw", MX, EM, XX }, 1016 { PREGRP21 }, 1017 { "pmovmskb", Gd, MS, XX }, 1018 /* d8 */ 1019 { "psubusb", MX, EM, XX }, 1020 { "psubusw", MX, EM, XX }, 1021 { "pminub", MX, EM, XX }, 1022 { "pand", MX, EM, XX }, 1023 { "paddusb", MX, EM, XX }, 1024 { "paddusw", MX, EM, XX }, 1025 { "pmaxub", MX, EM, XX }, 1026 { "pandn", MX, EM, XX }, 1027 /* e0 */ 1028 { "pavgb", MX, EM, XX }, 1029 { "psraw", MX, EM, XX }, 1030 { "psrad", MX, EM, XX }, 1031 { "pavgw", MX, EM, XX }, 1032 { "pmulhuw", MX, EM, XX }, 1033 { "pmulhw", MX, EM, XX }, 1034 { PREGRP15 }, 1035 { PREGRP25 }, 1036 /* e8 */ 1037 { "psubsb", MX, EM, XX }, 1038 { "psubsw", MX, EM, XX }, 1039 { "pminsw", MX, EM, XX }, 1040 { "por", MX, EM, XX }, 1041 { "paddsb", MX, EM, XX }, 1042 { "paddsw", MX, EM, XX }, 1043 { "pmaxsw", MX, EM, XX }, 1044 { "pxor", MX, EM, XX }, 1045 /* f0 */ 1046 { PREGRP32 }, 1047 { "psllw", MX, EM, XX }, 1048 { "pslld", MX, EM, XX }, 1049 { "psllq", MX, EM, XX }, 1050 { "pmuludq", MX, EM, XX }, 1051 { "pmaddwd", MX, EM, XX }, 1052 { "psadbw", MX, EM, XX }, 1053 { PREGRP18 }, 1054 /* f8 */ 1055 { "psubb", MX, EM, XX }, 1056 { "psubw", MX, EM, XX }, 1057 { "psubd", MX, EM, XX }, 1058 { "psubq", MX, EM, XX }, 1059 { "paddb", MX, EM, XX }, 1060 { "paddw", MX, EM, XX }, 1061 { "paddd", MX, EM, XX }, 1062 { "(bad)", XX, XX, XX } 1063 }; 1064 1065 static const unsigned char onebyte_has_modrm[256] = { 1066 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1067 /* ------------------------------- */ 1068 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ 1069 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ 1070 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ 1071 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ 1072 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ 1073 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ 1074 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ 1075 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ 1076 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ 1077 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ 1078 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ 1079 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ 1080 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ 1081 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ 1082 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ 1083 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ 1084 /* ------------------------------- */ 1085 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1086 }; 1087 1088 static const unsigned char twobyte_has_modrm[256] = { 1089 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1090 /* ------------------------------- */ 1091 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ 1092 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */ 1093 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ 1094 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1095 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ 1096 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ 1097 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ 1098 /* 70 */ 1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1, /* 7f */ 1099 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1100 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ 1101 /* a0 */ 0,0,0,1,1,1,0,1,0,0,0,1,1,1,1,1, /* af */ 1102 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */ 1103 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ 1104 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ 1105 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ 1106 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ 1107 /* ------------------------------- */ 1108 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1109 }; 1110 1111 static const unsigned char twobyte_uses_SSE_prefix[256] = { 1112 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1113 /* ------------------------------- */ 1114 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1115 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ 1116 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */ 1117 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ 1118 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1119 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 1120 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ 1121 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */ 1122 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1123 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1124 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1125 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1126 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1127 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1128 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1129 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ 1130 /* ------------------------------- */ 1131 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1132 }; 1133 1134 static char obuf[100]; 1135 static char *obufp; 1136 static char scratchbuf[100]; 1137 static unsigned char *start_codep; 1138 static unsigned char *insn_codep; 1139 static unsigned char *codep; 1140 static disassemble_info *the_info; 1141 static int mod; 1142 static int rm; 1143 static int reg; 1144 static unsigned char need_modrm; 1145 1146 /* If we are accessing mod/rm/reg without need_modrm set, then the 1147 values are stale. Hitting this abort likely indicates that you 1148 need to update onebyte_has_modrm or twobyte_has_modrm. */ 1149 #define MODRM_CHECK if (!need_modrm) abort () 1150 1151 static const char **names64; 1152 static const char **names32; 1153 static const char **names16; 1154 static const char **names8; 1155 static const char **names8rex; 1156 static const char **names_seg; 1157 static const char **index16; 1158 1159 static const char *intel_names64[] = { 1160 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", 1161 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 1162 }; 1163 static const char *intel_names32[] = { 1164 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", 1165 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" 1166 }; 1167 static const char *intel_names16[] = { 1168 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", 1169 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" 1170 }; 1171 static const char *intel_names8[] = { 1172 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", 1173 }; 1174 static const char *intel_names8rex[] = { 1175 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", 1176 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" 1177 }; 1178 static const char *intel_names_seg[] = { 1179 "es", "cs", "ss", "ds", "fs", "gs", "?", "?", 1180 }; 1181 static const char *intel_index16[] = { 1182 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" 1183 }; 1184 1185 static const char *att_names64[] = { 1186 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", 1187 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 1188 }; 1189 static const char *att_names32[] = { 1190 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", 1191 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" 1192 }; 1193 static const char *att_names16[] = { 1194 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", 1195 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" 1196 }; 1197 static const char *att_names8[] = { 1198 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", 1199 }; 1200 static const char *att_names8rex[] = { 1201 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", 1202 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" 1203 }; 1204 static const char *att_names_seg[] = { 1205 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", 1206 }; 1207 static const char *att_index16[] = { 1208 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" 1209 }; 1210 1211 static const struct dis386 grps[][8] = { 1212 /* GRP1b */ 1213 { 1214 { "addA", Eb, Ib, XX }, 1215 { "orA", Eb, Ib, XX }, 1216 { "adcA", Eb, Ib, XX }, 1217 { "sbbA", Eb, Ib, XX }, 1218 { "andA", Eb, Ib, XX }, 1219 { "subA", Eb, Ib, XX }, 1220 { "xorA", Eb, Ib, XX }, 1221 { "cmpA", Eb, Ib, XX } 1222 }, 1223 /* GRP1S */ 1224 { 1225 { "addQ", Ev, Iv, XX }, 1226 { "orQ", Ev, Iv, XX }, 1227 { "adcQ", Ev, Iv, XX }, 1228 { "sbbQ", Ev, Iv, XX }, 1229 { "andQ", Ev, Iv, XX }, 1230 { "subQ", Ev, Iv, XX }, 1231 { "xorQ", Ev, Iv, XX }, 1232 { "cmpQ", Ev, Iv, XX } 1233 }, 1234 /* GRP1Ss */ 1235 { 1236 { "addQ", Ev, sIb, XX }, 1237 { "orQ", Ev, sIb, XX }, 1238 { "adcQ", Ev, sIb, XX }, 1239 { "sbbQ", Ev, sIb, XX }, 1240 { "andQ", Ev, sIb, XX }, 1241 { "subQ", Ev, sIb, XX }, 1242 { "xorQ", Ev, sIb, XX }, 1243 { "cmpQ", Ev, sIb, XX } 1244 }, 1245 /* GRP2b */ 1246 { 1247 { "rolA", Eb, Ib, XX }, 1248 { "rorA", Eb, Ib, XX }, 1249 { "rclA", Eb, Ib, XX }, 1250 { "rcrA", Eb, Ib, XX }, 1251 { "shlA", Eb, Ib, XX }, 1252 { "shrA", Eb, Ib, XX }, 1253 { "(bad)", XX, XX, XX }, 1254 { "sarA", Eb, Ib, XX }, 1255 }, 1256 /* GRP2S */ 1257 { 1258 { "rolQ", Ev, Ib, XX }, 1259 { "rorQ", Ev, Ib, XX }, 1260 { "rclQ", Ev, Ib, XX }, 1261 { "rcrQ", Ev, Ib, XX }, 1262 { "shlQ", Ev, Ib, XX }, 1263 { "shrQ", Ev, Ib, XX }, 1264 { "(bad)", XX, XX, XX }, 1265 { "sarQ", Ev, Ib, XX }, 1266 }, 1267 /* GRP2b_one */ 1268 { 1269 { "rolA", Eb, XX, XX }, 1270 { "rorA", Eb, XX, XX }, 1271 { "rclA", Eb, XX, XX }, 1272 { "rcrA", Eb, XX, XX }, 1273 { "shlA", Eb, XX, XX }, 1274 { "shrA", Eb, XX, XX }, 1275 { "(bad)", XX, XX, XX }, 1276 { "sarA", Eb, XX, XX }, 1277 }, 1278 /* GRP2S_one */ 1279 { 1280 { "rolQ", Ev, XX, XX }, 1281 { "rorQ", Ev, XX, XX }, 1282 { "rclQ", Ev, XX, XX }, 1283 { "rcrQ", Ev, XX, XX }, 1284 { "shlQ", Ev, XX, XX }, 1285 { "shrQ", Ev, XX, XX }, 1286 { "(bad)", XX, XX, XX}, 1287 { "sarQ", Ev, XX, XX }, 1288 }, 1289 /* GRP2b_cl */ 1290 { 1291 { "rolA", Eb, CL, XX }, 1292 { "rorA", Eb, CL, XX }, 1293 { "rclA", Eb, CL, XX }, 1294 { "rcrA", Eb, CL, XX }, 1295 { "shlA", Eb, CL, XX }, 1296 { "shrA", Eb, CL, XX }, 1297 { "(bad)", XX, XX, XX }, 1298 { "sarA", Eb, CL, XX }, 1299 }, 1300 /* GRP2S_cl */ 1301 { 1302 { "rolQ", Ev, CL, XX }, 1303 { "rorQ", Ev, CL, XX }, 1304 { "rclQ", Ev, CL, XX }, 1305 { "rcrQ", Ev, CL, XX }, 1306 { "shlQ", Ev, CL, XX }, 1307 { "shrQ", Ev, CL, XX }, 1308 { "(bad)", XX, XX, XX }, 1309 { "sarQ", Ev, CL, XX } 1310 }, 1311 /* GRP3b */ 1312 { 1313 { "testA", Eb, Ib, XX }, 1314 { "(bad)", Eb, XX, XX }, 1315 { "notA", Eb, XX, XX }, 1316 { "negA", Eb, XX, XX }, 1317 { "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */ 1318 { "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */ 1319 { "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */ 1320 { "idivA", Eb, XX, XX } /* and idiv for consistency. */ 1321 }, 1322 /* GRP3S */ 1323 { 1324 { "testQ", Ev, Iv, XX }, 1325 { "(bad)", XX, XX, XX }, 1326 { "notQ", Ev, XX, XX }, 1327 { "negQ", Ev, XX, XX }, 1328 { "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */ 1329 { "imulQ", Ev, XX, XX }, 1330 { "divQ", Ev, XX, XX }, 1331 { "idivQ", Ev, XX, XX }, 1332 }, 1333 /* GRP4 */ 1334 { 1335 { "incA", Eb, XX, XX }, 1336 { "decA", Eb, XX, XX }, 1337 { "(bad)", XX, XX, XX }, 1338 { "(bad)", XX, XX, XX }, 1339 { "(bad)", XX, XX, XX }, 1340 { "(bad)", XX, XX, XX }, 1341 { "(bad)", XX, XX, XX }, 1342 { "(bad)", XX, XX, XX }, 1343 }, 1344 /* GRP5 */ 1345 { 1346 { "incQ", Ev, XX, XX }, 1347 { "decQ", Ev, XX, XX }, 1348 { "callT", indirEv, XX, XX }, 1349 { "lcallT", indirEv, XX, XX }, 1350 { "jmpT", indirEv, XX, XX }, 1351 { "ljmpT", indirEv, XX, XX }, 1352 { "pushU", Ev, XX, XX }, 1353 { "(bad)", XX, XX, XX }, 1354 }, 1355 /* GRP6 */ 1356 { 1357 { "sldtQ", Ev, XX, XX }, 1358 { "strQ", Ev, XX, XX }, 1359 { "lldt", Ew, XX, XX }, 1360 { "ltr", Ew, XX, XX }, 1361 { "verr", Ew, XX, XX }, 1362 { "verw", Ew, XX, XX }, 1363 { "(bad)", XX, XX, XX }, 1364 { "(bad)", XX, XX, XX } 1365 }, 1366 /* GRP7 */ 1367 { 1368 { "sgdtQ", M, XX, XX }, 1369 { "sidtQ", PNI_Fixup, 0, XX, XX }, 1370 { "lgdtQ", XCR_Fixup, 0, XX, XX }, 1371 { "lidtQ", M, XX, XX }, 1372 { "smswQ", Ev, XX, XX }, 1373 { "(bad)", XX, XX, XX }, 1374 { "lmsw", Ew, XX, XX }, 1375 { "invlpg", INVLPG_Fixup, w_mode, XX, XX }, 1376 }, 1377 /* GRP8 */ 1378 { 1379 { "(bad)", XX, XX, XX }, 1380 { "(bad)", XX, XX, XX }, 1381 { "(bad)", XX, XX, XX }, 1382 { "(bad)", XX, XX, XX }, 1383 { "btQ", Ev, Ib, XX }, 1384 { "btsQ", Ev, Ib, XX }, 1385 { "btrQ", Ev, Ib, XX }, 1386 { "btcQ", Ev, Ib, XX }, 1387 }, 1388 /* GRP9 */ 1389 { 1390 { "(bad)", XX, XX, XX }, 1391 { "cmpxchg8b", Ev, XX, XX }, 1392 { "(bad)", XX, XX, XX }, 1393 { "(bad)", XX, XX, XX }, 1394 { "(bad)", XX, XX, XX }, 1395 { "(bad)", XX, XX, XX }, 1396 { "rdrand", Ev, XX, XX }, 1397 { "(bad)", XX, XX, XX }, 1398 }, 1399 /* GRP10 */ 1400 { 1401 { "(bad)", XX, XX, XX }, 1402 { "(bad)", XX, XX, XX }, 1403 { "psrlw", MS, Ib, XX }, 1404 { "(bad)", XX, XX, XX }, 1405 { "psraw", MS, Ib, XX }, 1406 { "(bad)", XX, XX, XX }, 1407 { "psllw", MS, Ib, XX }, 1408 { "(bad)", XX, XX, XX }, 1409 }, 1410 /* GRP11 */ 1411 { 1412 { "(bad)", XX, XX, XX }, 1413 { "(bad)", XX, XX, XX }, 1414 { "psrld", MS, Ib, XX }, 1415 { "(bad)", XX, XX, XX }, 1416 { "psrad", MS, Ib, XX }, 1417 { "(bad)", XX, XX, XX }, 1418 { "pslld", MS, Ib, XX }, 1419 { "(bad)", XX, XX, XX }, 1420 }, 1421 /* GRP12 */ 1422 { 1423 { "(bad)", XX, XX, XX }, 1424 { "(bad)", XX, XX, XX }, 1425 { "psrlq", MS, Ib, XX }, 1426 { "psrldq", MS, Ib, XX }, 1427 { "(bad)", XX, XX, XX }, 1428 { "(bad)", XX, XX, XX }, 1429 { "psllq", MS, Ib, XX }, 1430 { "pslldq", MS, Ib, XX }, 1431 }, 1432 /* GRP13 */ 1433 { 1434 { "fxsave", Ev, XX, XX }, 1435 { "fxrstor", Ev, XX, XX }, 1436 { "ldmxcsr", Ev, XX, XX }, 1437 { "stmxcsr", Ev, XX, XX }, 1438 { "xsave", Ev, XX, XX }, 1439 { "xrstor", OP_0fae, v_mode, XX, XX }, 1440 { "xsaveopt", OP_0fae, v_mode, XX, XX }, 1441 { "clflush", OP_0fae, v_mode, XX, XX }, 1442 }, 1443 /* GRP14 */ 1444 { 1445 { "prefetchnta", Ev, XX, XX }, 1446 { "prefetcht0", Ev, XX, XX }, 1447 { "prefetcht1", Ev, XX, XX }, 1448 { "prefetcht2", Ev, XX, XX }, 1449 { "(bad)", XX, XX, XX }, 1450 { "(bad)", XX, XX, XX }, 1451 { "(bad)", XX, XX, XX }, 1452 { "(bad)", XX, XX, XX }, 1453 }, 1454 /* GRPAMD */ 1455 { 1456 { "prefetch", Eb, XX, XX }, 1457 { "prefetchw", Eb, XX, XX }, 1458 { "(bad)", XX, XX, XX }, 1459 { "(bad)", XX, XX, XX }, 1460 { "(bad)", XX, XX, XX }, 1461 { "(bad)", XX, XX, XX }, 1462 { "(bad)", XX, XX, XX }, 1463 { "(bad)", XX, XX, XX }, 1464 }, 1465 }; 1466 1467 static const struct dis386 prefix_user_table[][4] = { 1468 /* PREGRP0 */ 1469 { 1470 { "addps", XM, EX, XX }, 1471 { "addss", XM, EX, XX }, 1472 { "addpd", XM, EX, XX }, 1473 { "addsd", XM, EX, XX }, 1474 }, 1475 /* PREGRP1 */ 1476 { 1477 { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */ 1478 { "", XM, EX, OPSIMD }, 1479 { "", XM, EX, OPSIMD }, 1480 { "", XM, EX, OPSIMD }, 1481 }, 1482 /* PREGRP2 */ 1483 { 1484 { "cvtpi2ps", XM, EM, XX }, 1485 { "cvtsi2ssY", XM, Ev, XX }, 1486 { "cvtpi2pd", XM, EM, XX }, 1487 { "cvtsi2sdY", XM, Ev, XX }, 1488 }, 1489 /* PREGRP3 */ 1490 { 1491 { "cvtps2pi", MX, EX, XX }, 1492 { "cvtss2siY", Gv, EX, XX }, 1493 { "cvtpd2pi", MX, EX, XX }, 1494 { "cvtsd2siY", Gv, EX, XX }, 1495 }, 1496 /* PREGRP4 */ 1497 { 1498 { "cvttps2pi", MX, EX, XX }, 1499 { "cvttss2siY", Gv, EX, XX }, 1500 { "cvttpd2pi", MX, EX, XX }, 1501 { "cvttsd2siY", Gv, EX, XX }, 1502 }, 1503 /* PREGRP5 */ 1504 { 1505 { "divps", XM, EX, XX }, 1506 { "divss", XM, EX, XX }, 1507 { "divpd", XM, EX, XX }, 1508 { "divsd", XM, EX, XX }, 1509 }, 1510 /* PREGRP6 */ 1511 { 1512 { "maxps", XM, EX, XX }, 1513 { "maxss", XM, EX, XX }, 1514 { "maxpd", XM, EX, XX }, 1515 { "maxsd", XM, EX, XX }, 1516 }, 1517 /* PREGRP7 */ 1518 { 1519 { "minps", XM, EX, XX }, 1520 { "minss", XM, EX, XX }, 1521 { "minpd", XM, EX, XX }, 1522 { "minsd", XM, EX, XX }, 1523 }, 1524 /* PREGRP8 */ 1525 { 1526 { "movups", XM, EX, XX }, 1527 { "movss", XM, EX, XX }, 1528 { "movupd", XM, EX, XX }, 1529 { "movsd", XM, EX, XX }, 1530 }, 1531 /* PREGRP9 */ 1532 { 1533 { "movups", EX, XM, XX }, 1534 { "movss", EX, XM, XX }, 1535 { "movupd", EX, XM, XX }, 1536 { "movsd", EX, XM, XX }, 1537 }, 1538 /* PREGRP10 */ 1539 { 1540 { "mulps", XM, EX, XX }, 1541 { "mulss", XM, EX, XX }, 1542 { "mulpd", XM, EX, XX }, 1543 { "mulsd", XM, EX, XX }, 1544 }, 1545 /* PREGRP11 */ 1546 { 1547 { "rcpps", XM, EX, XX }, 1548 { "rcpss", XM, EX, XX }, 1549 { "(bad)", XM, EX, XX }, 1550 { "(bad)", XM, EX, XX }, 1551 }, 1552 /* PREGRP12 */ 1553 { 1554 { "rsqrtps", XM, EX, XX }, 1555 { "rsqrtss", XM, EX, XX }, 1556 { "(bad)", XM, EX, XX }, 1557 { "(bad)", XM, EX, XX }, 1558 }, 1559 /* PREGRP13 */ 1560 { 1561 { "sqrtps", XM, EX, XX }, 1562 { "sqrtss", XM, EX, XX }, 1563 { "sqrtpd", XM, EX, XX }, 1564 { "sqrtsd", XM, EX, XX }, 1565 }, 1566 /* PREGRP14 */ 1567 { 1568 { "subps", XM, EX, XX }, 1569 { "subss", XM, EX, XX }, 1570 { "subpd", XM, EX, XX }, 1571 { "subsd", XM, EX, XX }, 1572 }, 1573 /* PREGRP15 */ 1574 { 1575 { "(bad)", XM, EX, XX }, 1576 { "cvtdq2pd", XM, EX, XX }, 1577 { "cvttpd2dq", XM, EX, XX }, 1578 { "cvtpd2dq", XM, EX, XX }, 1579 }, 1580 /* PREGRP16 */ 1581 { 1582 { "cvtdq2ps", XM, EX, XX }, 1583 { "cvttps2dq",XM, EX, XX }, 1584 { "cvtps2dq",XM, EX, XX }, 1585 { "(bad)", XM, EX, XX }, 1586 }, 1587 /* PREGRP17 */ 1588 { 1589 { "cvtps2pd", XM, EX, XX }, 1590 { "cvtss2sd", XM, EX, XX }, 1591 { "cvtpd2ps", XM, EX, XX }, 1592 { "cvtsd2ss", XM, EX, XX }, 1593 }, 1594 /* PREGRP18 */ 1595 { 1596 { "maskmovq", MX, MS, XX }, 1597 { "(bad)", XM, EX, XX }, 1598 { "maskmovdqu", XM, EX, XX }, 1599 { "(bad)", XM, EX, XX }, 1600 }, 1601 /* PREGRP19 */ 1602 { 1603 { "movq", MX, EM, XX }, 1604 { "movdqu", XM, EX, XX }, 1605 { "movdqa", XM, EX, XX }, 1606 { "(bad)", XM, EX, XX }, 1607 }, 1608 /* PREGRP20 */ 1609 { 1610 { "movq", EM, MX, XX }, 1611 { "movdqu", EX, XM, XX }, 1612 { "movdqa", EX, XM, XX }, 1613 { "(bad)", EX, XM, XX }, 1614 }, 1615 /* PREGRP21 */ 1616 { 1617 { "(bad)", EX, XM, XX }, 1618 { "movq2dq", XM, MS, XX }, 1619 { "movq", EX, XM, XX }, 1620 { "movdq2q", MX, XS, XX }, 1621 }, 1622 /* PREGRP22 */ 1623 { 1624 { "pshufw", MX, EM, Ib }, 1625 { "pshufhw", XM, EX, Ib }, 1626 { "pshufd", XM, EX, Ib }, 1627 { "pshuflw", XM, EX, Ib }, 1628 }, 1629 /* PREGRP23 */ 1630 { 1631 { "movd", Edq, MX, XX }, 1632 { "movq", XM, EX, XX }, 1633 { "movd", Edq, XM, XX }, 1634 { "(bad)", Ed, XM, XX }, 1635 }, 1636 /* PREGRP24 */ 1637 { 1638 { "(bad)", MX, EX, XX }, 1639 { "(bad)", XM, EX, XX }, 1640 { "punpckhqdq", XM, EX, XX }, 1641 { "(bad)", XM, EX, XX }, 1642 }, 1643 /* PREGRP25 */ 1644 { 1645 { "movntq", Ev, MX, XX }, 1646 { "(bad)", Ev, XM, XX }, 1647 { "movntdq", Ev, XM, XX }, 1648 { "(bad)", Ev, XM, XX }, 1649 }, 1650 /* PREGRP26 */ 1651 { 1652 { "(bad)", MX, EX, XX }, 1653 { "(bad)", XM, EX, XX }, 1654 { "punpcklqdq", XM, EX, XX }, 1655 { "(bad)", XM, EX, XX }, 1656 }, 1657 /* PREGRP27 */ 1658 { 1659 { "(bad)", MX, EX, XX }, 1660 { "(bad)", XM, EX, XX }, 1661 { "addsubpd", XM, EX, XX }, 1662 { "addsubps", XM, EX, XX }, 1663 }, 1664 /* PREGRP28 */ 1665 { 1666 { "(bad)", MX, EX, XX }, 1667 { "(bad)", XM, EX, XX }, 1668 { "haddpd", XM, EX, XX }, 1669 { "haddps", XM, EX, XX }, 1670 }, 1671 /* PREGRP29 */ 1672 { 1673 { "(bad)", MX, EX, XX }, 1674 { "(bad)", XM, EX, XX }, 1675 { "hsubpd", XM, EX, XX }, 1676 { "hsubps", XM, EX, XX }, 1677 }, 1678 /* PREGRP30 */ 1679 { 1680 { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ 1681 { "movsldup", XM, EX, XX }, 1682 { "movlpd", XM, EX, XX }, 1683 { "movddup", XM, EX, XX }, 1684 }, 1685 /* PREGRP31 */ 1686 { 1687 { "movhpX", XM, EX, SIMD_Fixup, 'l' }, 1688 { "movshdup", XM, EX, XX }, 1689 { "movhpd", XM, EX, XX }, 1690 { "(bad)", XM, EX, XX }, 1691 }, 1692 /* PREGRP32 */ 1693 { 1694 { "(bad)", XM, EX, XX }, 1695 { "(bad)", XM, EX, XX }, 1696 { "(bad)", XM, EX, XX }, 1697 { "lddqu", XM, M, XX }, 1698 }, 1699 }; 1700 1701 static const struct dis386 x86_64_table[][2] = { 1702 { 1703 { "arpl", Ew, Gw, XX }, 1704 { "movs{||lq|xd}", Gv, Ed, XX }, 1705 }, 1706 }; 1707 1708 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") 1709 1710 static void 1711 ckprefix (void) 1712 { 1713 int newrex; 1714 rex = 0; 1715 prefixes = 0; 1716 used_prefixes = 0; 1717 rex_used = 0; 1718 while (1) 1719 { 1720 FETCH_DATA (the_info, codep + 1); 1721 newrex = 0; 1722 switch (*codep) 1723 { 1724 /* REX prefixes family. */ 1725 case 0x40: 1726 case 0x41: 1727 case 0x42: 1728 case 0x43: 1729 case 0x44: 1730 case 0x45: 1731 case 0x46: 1732 case 0x47: 1733 case 0x48: 1734 case 0x49: 1735 case 0x4a: 1736 case 0x4b: 1737 case 0x4c: 1738 case 0x4d: 1739 case 0x4e: 1740 case 0x4f: 1741 if (mode_64bit) 1742 newrex = *codep; 1743 else 1744 return; 1745 break; 1746 case 0xf3: 1747 prefixes |= PREFIX_REPZ; 1748 break; 1749 case 0xf2: 1750 prefixes |= PREFIX_REPNZ; 1751 break; 1752 case 0xf0: 1753 prefixes |= PREFIX_LOCK; 1754 break; 1755 case 0x2e: 1756 prefixes |= PREFIX_CS; 1757 break; 1758 case 0x36: 1759 prefixes |= PREFIX_SS; 1760 break; 1761 case 0x3e: 1762 prefixes |= PREFIX_DS; 1763 break; 1764 case 0x26: 1765 prefixes |= PREFIX_ES; 1766 break; 1767 case 0x64: 1768 prefixes |= PREFIX_FS; 1769 break; 1770 case 0x65: 1771 prefixes |= PREFIX_GS; 1772 break; 1773 case 0x66: 1774 prefixes |= PREFIX_DATA; 1775 break; 1776 case 0x67: 1777 prefixes |= PREFIX_ADDR; 1778 break; 1779 case FWAIT_OPCODE: 1780 /* fwait is really an instruction. If there are prefixes 1781 before the fwait, they belong to the fwait, *not* to the 1782 following instruction. */ 1783 if (prefixes) 1784 { 1785 prefixes |= PREFIX_FWAIT; 1786 codep++; 1787 return; 1788 } 1789 prefixes = PREFIX_FWAIT; 1790 break; 1791 default: 1792 return; 1793 } 1794 /* Rex is ignored when followed by another prefix. */ 1795 if (rex) 1796 { 1797 oappend (prefix_name (rex, 0)); 1798 oappend (" "); 1799 } 1800 rex = newrex; 1801 codep++; 1802 } 1803 } 1804 1805 /* Return the name of the prefix byte PREF, or NULL if PREF is not a 1806 prefix byte. */ 1807 1808 static const char * 1809 prefix_name (int pref, int sizeflag) 1810 { 1811 switch (pref) 1812 { 1813 /* REX prefixes family. */ 1814 case 0x40: 1815 return "rex"; 1816 case 0x41: 1817 return "rexZ"; 1818 case 0x42: 1819 return "rexY"; 1820 case 0x43: 1821 return "rexYZ"; 1822 case 0x44: 1823 return "rexX"; 1824 case 0x45: 1825 return "rexXZ"; 1826 case 0x46: 1827 return "rexXY"; 1828 case 0x47: 1829 return "rexXYZ"; 1830 case 0x48: 1831 return "rex64"; 1832 case 0x49: 1833 return "rex64Z"; 1834 case 0x4a: 1835 return "rex64Y"; 1836 case 0x4b: 1837 return "rex64YZ"; 1838 case 0x4c: 1839 return "rex64X"; 1840 case 0x4d: 1841 return "rex64XZ"; 1842 case 0x4e: 1843 return "rex64XY"; 1844 case 0x4f: 1845 return "rex64XYZ"; 1846 case 0xf3: 1847 return "repz"; 1848 case 0xf2: 1849 return "repnz"; 1850 case 0xf0: 1851 return "lock"; 1852 case 0x2e: 1853 return "cs"; 1854 case 0x36: 1855 return "ss"; 1856 case 0x3e: 1857 return "ds"; 1858 case 0x26: 1859 return "es"; 1860 case 0x64: 1861 return "fs"; 1862 case 0x65: 1863 return "gs"; 1864 case 0x66: 1865 return (sizeflag & DFLAG) ? "data16" : "data32"; 1866 case 0x67: 1867 if (mode_64bit) 1868 return (sizeflag & AFLAG) ? "addr32" : "addr64"; 1869 else 1870 return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32"; 1871 case FWAIT_OPCODE: 1872 return "fwait"; 1873 default: 1874 return NULL; 1875 } 1876 } 1877 1878 static char op1out[100], op2out[100], op3out[100]; 1879 static int op_ad, op_index[3]; 1880 static bfd_vma op_address[3]; 1881 static bfd_vma op_riprel[3]; 1882 static bfd_vma start_pc; 1883 1884 /* 1885 * On the 386's of 1988, the maximum length of an instruction is 15 bytes. 1886 * (see topic "Redundant prefixes" in the "Differences from 8086" 1887 * section of the "Virtual 8086 Mode" chapter.) 1888 * 'pc' should be the address of this instruction, it will 1889 * be used to print the target address if this is a relative jump or call 1890 * The function returns the length of this instruction in bytes. 1891 */ 1892 1893 static char intel_syntax; 1894 static char open_char; 1895 static char close_char; 1896 static char separator_char; 1897 static char scale_char; 1898 1899 /* Here for backwards compatibility. When gdb stops using 1900 print_insn_i386_att and print_insn_i386_intel these functions can 1901 disappear, and print_insn_i386 be merged into print_insn. */ 1902 int 1903 print_insn_i386_att (bfd_vma pc, disassemble_info *info) 1904 { 1905 intel_syntax = 0; 1906 1907 return print_insn (pc, info); 1908 } 1909 1910 int 1911 print_insn_i386_intel (bfd_vma pc, disassemble_info *info) 1912 { 1913 intel_syntax = 1; 1914 1915 return print_insn (pc, info); 1916 } 1917 1918 int 1919 print_insn_i386 (bfd_vma pc, disassemble_info *info) 1920 { 1921 intel_syntax = -1; 1922 1923 return print_insn (pc, info); 1924 } 1925 1926 static int 1927 print_insn (bfd_vma pc, disassemble_info *info) 1928 { 1929 const struct dis386 *dp; 1930 int i; 1931 int two_source_ops; 1932 char *first, *second, *third; 1933 int needcomma; 1934 unsigned char uses_SSE_prefix; 1935 int sizeflag; 1936 const char *p; 1937 struct dis_private priv; 1938 1939 mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax 1940 || info->mach == bfd_mach_x86_64); 1941 1942 if (intel_syntax == (char) -1) 1943 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax 1944 || info->mach == bfd_mach_x86_64_intel_syntax); 1945 1946 if (info->mach == bfd_mach_i386_i386 1947 || info->mach == bfd_mach_x86_64 1948 || info->mach == bfd_mach_i386_i386_intel_syntax 1949 || info->mach == bfd_mach_x86_64_intel_syntax) 1950 priv.orig_sizeflag = AFLAG | DFLAG; 1951 else if (info->mach == bfd_mach_i386_i8086) 1952 priv.orig_sizeflag = 0; 1953 else 1954 abort (); 1955 1956 for (p = info->disassembler_options; p != NULL; ) 1957 { 1958 if (strncmp (p, "x86-64", 6) == 0) 1959 { 1960 mode_64bit = 1; 1961 priv.orig_sizeflag = AFLAG | DFLAG; 1962 } 1963 else if (strncmp (p, "i386", 4) == 0) 1964 { 1965 mode_64bit = 0; 1966 priv.orig_sizeflag = AFLAG | DFLAG; 1967 } 1968 else if (strncmp (p, "i8086", 5) == 0) 1969 { 1970 mode_64bit = 0; 1971 priv.orig_sizeflag = 0; 1972 } 1973 else if (strncmp (p, "intel", 5) == 0) 1974 { 1975 intel_syntax = 1; 1976 } 1977 else if (strncmp (p, "att", 3) == 0) 1978 { 1979 intel_syntax = 0; 1980 } 1981 else if (strncmp (p, "addr", 4) == 0) 1982 { 1983 if (p[4] == '1' && p[5] == '6') 1984 priv.orig_sizeflag &= ~AFLAG; 1985 else if (p[4] == '3' && p[5] == '2') 1986 priv.orig_sizeflag |= AFLAG; 1987 } 1988 else if (strncmp (p, "data", 4) == 0) 1989 { 1990 if (p[4] == '1' && p[5] == '6') 1991 priv.orig_sizeflag &= ~DFLAG; 1992 else if (p[4] == '3' && p[5] == '2') 1993 priv.orig_sizeflag |= DFLAG; 1994 } 1995 else if (strncmp (p, "suffix", 6) == 0) 1996 priv.orig_sizeflag |= SUFFIX_ALWAYS; 1997 1998 p = strchr (p, ','); 1999 if (p != NULL) 2000 p++; 2001 } 2002 2003 if (intel_syntax) 2004 { 2005 names64 = intel_names64; 2006 names32 = intel_names32; 2007 names16 = intel_names16; 2008 names8 = intel_names8; 2009 names8rex = intel_names8rex; 2010 names_seg = intel_names_seg; 2011 index16 = intel_index16; 2012 open_char = '['; 2013 close_char = ']'; 2014 separator_char = '+'; 2015 scale_char = '*'; 2016 } 2017 else 2018 { 2019 names64 = att_names64; 2020 names32 = att_names32; 2021 names16 = att_names16; 2022 names8 = att_names8; 2023 names8rex = att_names8rex; 2024 names_seg = att_names_seg; 2025 index16 = att_index16; 2026 open_char = '('; 2027 close_char = ')'; 2028 separator_char = ','; 2029 scale_char = ','; 2030 } 2031 2032 /* The output looks better if we put 7 bytes on a line, since that 2033 puts most long word instructions on a single line. */ 2034 info->bytes_per_line = 7; 2035 2036 info->private_data = &priv; 2037 priv.max_fetched = priv.the_buffer; 2038 priv.insn_start = pc; 2039 2040 obuf[0] = 0; 2041 op1out[0] = 0; 2042 op2out[0] = 0; 2043 op3out[0] = 0; 2044 2045 op_index[0] = op_index[1] = op_index[2] = -1; 2046 2047 the_info = info; 2048 start_pc = pc; 2049 start_codep = priv.the_buffer; 2050 codep = priv.the_buffer; 2051 2052 if (setjmp (priv.bailout) != 0) 2053 { 2054 const char *name; 2055 2056 /* Getting here means we tried for data but didn't get it. That 2057 means we have an incomplete instruction of some sort. Just 2058 print the first byte as a prefix or a .byte pseudo-op. */ 2059 if (codep > priv.the_buffer) 2060 { 2061 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 2062 if (name != NULL) 2063 (*info->fprintf_func) (info->stream, "%s", name); 2064 else 2065 { 2066 /* Just print the first byte as a .byte instruction. */ 2067 (*info->fprintf_func) (info->stream, ".byte 0x%x", 2068 (unsigned int) priv.the_buffer[0]); 2069 } 2070 2071 return 1; 2072 } 2073 2074 return -1; 2075 } 2076 2077 obufp = obuf; 2078 ckprefix (); 2079 2080 insn_codep = codep; 2081 sizeflag = priv.orig_sizeflag; 2082 2083 FETCH_DATA (info, codep + 1); 2084 two_source_ops = (*codep == 0x62) || (*codep == 0xc8); 2085 2086 if ((prefixes & PREFIX_FWAIT) 2087 && ((*codep < 0xd8) || (*codep > 0xdf))) 2088 { 2089 const char *name; 2090 2091 /* fwait not followed by floating point instruction. Print the 2092 first prefix, which is probably fwait itself. */ 2093 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 2094 if (name == NULL) 2095 name = INTERNAL_DISASSEMBLER_ERROR; 2096 (*info->fprintf_func) (info->stream, "%s", name); 2097 return 1; 2098 } 2099 2100 if (*codep == 0x0f) 2101 { 2102 FETCH_DATA (info, codep + 2); 2103 dp = &dis386_twobyte[*++codep]; 2104 need_modrm = twobyte_has_modrm[*codep]; 2105 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep]; 2106 } 2107 else 2108 { 2109 dp = &dis386[*codep]; 2110 need_modrm = onebyte_has_modrm[*codep]; 2111 uses_SSE_prefix = 0; 2112 } 2113 codep++; 2114 2115 if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ)) 2116 { 2117 oappend ("repz "); 2118 used_prefixes |= PREFIX_REPZ; 2119 } 2120 if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ)) 2121 { 2122 oappend ("repnz "); 2123 used_prefixes |= PREFIX_REPNZ; 2124 } 2125 if (prefixes & PREFIX_LOCK) 2126 { 2127 oappend ("lock "); 2128 used_prefixes |= PREFIX_LOCK; 2129 } 2130 2131 if (prefixes & PREFIX_ADDR) 2132 { 2133 sizeflag ^= AFLAG; 2134 if (dp->bytemode3 != loop_jcxz_mode || intel_syntax) 2135 { 2136 if ((sizeflag & AFLAG) || mode_64bit) 2137 oappend ("addr32 "); 2138 else 2139 oappend ("addr16 "); 2140 used_prefixes |= PREFIX_ADDR; 2141 } 2142 } 2143 2144 if (!uses_SSE_prefix && (prefixes & PREFIX_DATA)) 2145 { 2146 sizeflag ^= DFLAG; 2147 if (dp->bytemode3 == cond_jump_mode 2148 && dp->bytemode1 == v_mode 2149 && !intel_syntax) 2150 { 2151 if (sizeflag & DFLAG) 2152 oappend ("data32 "); 2153 else 2154 oappend ("data16 "); 2155 used_prefixes |= PREFIX_DATA; 2156 } 2157 } 2158 2159 if (need_modrm) 2160 { 2161 FETCH_DATA (info, codep + 1); 2162 mod = (*codep >> 6) & 3; 2163 reg = (*codep >> 3) & 7; 2164 rm = *codep & 7; 2165 } 2166 2167 if (dp->name == NULL && dp->bytemode1 == FLOATCODE) 2168 { 2169 dofloat (sizeflag); 2170 } 2171 else 2172 { 2173 int index; 2174 if (dp->name == NULL) 2175 { 2176 switch (dp->bytemode1) 2177 { 2178 case USE_GROUPS: 2179 dp = &grps[dp->bytemode2][reg]; 2180 break; 2181 2182 case USE_PREFIX_USER_TABLE: 2183 index = 0; 2184 used_prefixes |= (prefixes & PREFIX_REPZ); 2185 if (prefixes & PREFIX_REPZ) 2186 index = 1; 2187 else 2188 { 2189 used_prefixes |= (prefixes & PREFIX_DATA); 2190 if (prefixes & PREFIX_DATA) 2191 index = 2; 2192 else 2193 { 2194 used_prefixes |= (prefixes & PREFIX_REPNZ); 2195 if (prefixes & PREFIX_REPNZ) 2196 index = 3; 2197 } 2198 } 2199 dp = &prefix_user_table[dp->bytemode2][index]; 2200 break; 2201 2202 case X86_64_SPECIAL: 2203 dp = &x86_64_table[dp->bytemode2][mode_64bit]; 2204 break; 2205 2206 default: 2207 oappend (INTERNAL_DISASSEMBLER_ERROR); 2208 break; 2209 } 2210 } 2211 2212 if (putop (dp->name, sizeflag) == 0) 2213 { 2214 obufp = op1out; 2215 op_ad = 2; 2216 if (dp->op1) 2217 (*dp->op1) (dp->bytemode1, sizeflag); 2218 2219 obufp = op2out; 2220 op_ad = 1; 2221 if (dp->op2) 2222 (*dp->op2) (dp->bytemode2, sizeflag); 2223 2224 obufp = op3out; 2225 op_ad = 0; 2226 if (dp->op3) 2227 (*dp->op3) (dp->bytemode3, sizeflag); 2228 } 2229 } 2230 2231 /* See if any prefixes were not used. If so, print the first one 2232 separately. If we don't do this, we'll wind up printing an 2233 instruction stream which does not precisely correspond to the 2234 bytes we are disassembling. */ 2235 if ((prefixes & ~used_prefixes) != 0) 2236 { 2237 const char *name; 2238 2239 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 2240 if (name == NULL) 2241 name = INTERNAL_DISASSEMBLER_ERROR; 2242 (*info->fprintf_func) (info->stream, "%s", name); 2243 return 1; 2244 } 2245 if (rex & ~rex_used) 2246 { 2247 const char *name; 2248 name = prefix_name (rex | 0x40, priv.orig_sizeflag); 2249 if (name == NULL) 2250 name = INTERNAL_DISASSEMBLER_ERROR; 2251 (*info->fprintf_func) (info->stream, "%s ", name); 2252 } 2253 2254 obufp = obuf + strlen (obuf); 2255 for (i = strlen (obuf); i < 6; i++) 2256 oappend (" "); 2257 oappend (" "); 2258 (*info->fprintf_func) (info->stream, "%s", obuf); 2259 2260 /* The enter and bound instructions are printed with operands in the same 2261 order as the intel book; everything else is printed in reverse order. */ 2262 if (intel_syntax || two_source_ops) 2263 { 2264 first = op1out; 2265 second = op2out; 2266 third = op3out; 2267 op_ad = op_index[0]; 2268 op_index[0] = op_index[2]; 2269 op_index[2] = op_ad; 2270 } 2271 else 2272 { 2273 first = op3out; 2274 second = op2out; 2275 third = op1out; 2276 } 2277 needcomma = 0; 2278 if (*first) 2279 { 2280 if (op_index[0] != -1 && !op_riprel[0]) 2281 (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info); 2282 else 2283 (*info->fprintf_func) (info->stream, "%s", first); 2284 needcomma = 1; 2285 } 2286 if (*second) 2287 { 2288 if (needcomma) 2289 (*info->fprintf_func) (info->stream, ","); 2290 if (op_index[1] != -1 && !op_riprel[1]) 2291 (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info); 2292 else 2293 (*info->fprintf_func) (info->stream, "%s", second); 2294 needcomma = 1; 2295 } 2296 if (*third) 2297 { 2298 if (needcomma) 2299 (*info->fprintf_func) (info->stream, ","); 2300 if (op_index[2] != -1 && !op_riprel[2]) 2301 (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info); 2302 else 2303 (*info->fprintf_func) (info->stream, "%s", third); 2304 } 2305 for (i = 0; i < 3; i++) 2306 if (op_index[i] != -1 && op_riprel[i]) 2307 { 2308 (*info->fprintf_func) (info->stream, " # "); 2309 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep 2310 + op_address[op_index[i]]), info); 2311 } 2312 return codep - priv.the_buffer; 2313 } 2314 2315 static const char *float_mem[] = { 2316 /* d8 */ 2317 "fadd{s||s|}", 2318 "fmul{s||s|}", 2319 "fcom{s||s|}", 2320 "fcomp{s||s|}", 2321 "fsub{s||s|}", 2322 "fsubr{s||s|}", 2323 "fdiv{s||s|}", 2324 "fdivr{s||s|}", 2325 /* d9 */ 2326 "fld{s||s|}", 2327 "(bad)", 2328 "fst{s||s|}", 2329 "fstp{s||s|}", 2330 "fldenv", 2331 "fldcw", 2332 "fNstenv", 2333 "fNstcw", 2334 /* da */ 2335 "fiadd{l||l|}", 2336 "fimul{l||l|}", 2337 "ficom{l||l|}", 2338 "ficomp{l||l|}", 2339 "fisub{l||l|}", 2340 "fisubr{l||l|}", 2341 "fidiv{l||l|}", 2342 "fidivr{l||l|}", 2343 /* db */ 2344 "fild{l||l|}", 2345 "fisttp{l||l|}", 2346 "fist{l||l|}", 2347 "fistp{l||l|}", 2348 "(bad)", 2349 "fld{t||t|}", 2350 "(bad)", 2351 "fstp{t||t|}", 2352 /* dc */ 2353 "fadd{l||l|}", 2354 "fmul{l||l|}", 2355 "fcom{l||l|}", 2356 "fcomp{l||l|}", 2357 "fsub{l||l|}", 2358 "fsubr{l||l|}", 2359 "fdiv{l||l|}", 2360 "fdivr{l||l|}", 2361 /* dd */ 2362 "fld{l||l|}", 2363 "fisttpll", 2364 "fst{l||l|}", 2365 "fstp{l||l|}", 2366 "frstor", 2367 "(bad)", 2368 "fNsave", 2369 "fNstsw", 2370 /* de */ 2371 "fiadd", 2372 "fimul", 2373 "ficom", 2374 "ficomp", 2375 "fisub", 2376 "fisubr", 2377 "fidiv", 2378 "fidivr", 2379 /* df */ 2380 "fild", 2381 "fisttp", 2382 "fist", 2383 "fistp", 2384 "fbld", 2385 "fild{ll||ll|}", 2386 "fbstp", 2387 "fistpll", 2388 }; 2389 2390 #define ST OP_ST, 0 2391 #define STi OP_STi, 0 2392 2393 #define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0 2394 #define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0 2395 #define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0 2396 #define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0 2397 #define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0 2398 #define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0 2399 #define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0 2400 #define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0 2401 #define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0 2402 2403 static const struct dis386 float_reg[][8] = { 2404 /* d8 */ 2405 { 2406 { "fadd", ST, STi, XX }, 2407 { "fmul", ST, STi, XX }, 2408 { "fcom", STi, XX, XX }, 2409 { "fcomp", STi, XX, XX }, 2410 { "fsub", ST, STi, XX }, 2411 { "fsubr", ST, STi, XX }, 2412 { "fdiv", ST, STi, XX }, 2413 { "fdivr", ST, STi, XX }, 2414 }, 2415 /* d9 */ 2416 { 2417 { "fld", STi, XX, XX }, 2418 { "fxch", STi, XX, XX }, 2419 { FGRPd9_2 }, 2420 { "(bad)", XX, XX, XX }, 2421 { FGRPd9_4 }, 2422 { FGRPd9_5 }, 2423 { FGRPd9_6 }, 2424 { FGRPd9_7 }, 2425 }, 2426 /* da */ 2427 { 2428 { "fcmovb", ST, STi, XX }, 2429 { "fcmove", ST, STi, XX }, 2430 { "fcmovbe",ST, STi, XX }, 2431 { "fcmovu", ST, STi, XX }, 2432 { "(bad)", XX, XX, XX }, 2433 { FGRPda_5 }, 2434 { "(bad)", XX, XX, XX }, 2435 { "(bad)", XX, XX, XX }, 2436 }, 2437 /* db */ 2438 { 2439 { "fcmovnb",ST, STi, XX }, 2440 { "fcmovne",ST, STi, XX }, 2441 { "fcmovnbe",ST, STi, XX }, 2442 { "fcmovnu",ST, STi, XX }, 2443 { FGRPdb_4 }, 2444 { "fucomi", ST, STi, XX }, 2445 { "fcomi", ST, STi, XX }, 2446 { "(bad)", XX, XX, XX }, 2447 }, 2448 /* dc */ 2449 { 2450 { "fadd", STi, ST, XX }, 2451 { "fmul", STi, ST, XX }, 2452 { "(bad)", XX, XX, XX }, 2453 { "(bad)", XX, XX, XX }, 2454 #if UNIXWARE_COMPAT 2455 { "fsub", STi, ST, XX }, 2456 { "fsubr", STi, ST, XX }, 2457 { "fdiv", STi, ST, XX }, 2458 { "fdivr", STi, ST, XX }, 2459 #else 2460 { "fsubr", STi, ST, XX }, 2461 { "fsub", STi, ST, XX }, 2462 { "fdivr", STi, ST, XX }, 2463 { "fdiv", STi, ST, XX }, 2464 #endif 2465 }, 2466 /* dd */ 2467 { 2468 { "ffree", STi, XX, XX }, 2469 { "(bad)", XX, XX, XX }, 2470 { "fst", STi, XX, XX }, 2471 { "fstp", STi, XX, XX }, 2472 { "fucom", STi, XX, XX }, 2473 { "fucomp", STi, XX, XX }, 2474 { "(bad)", XX, XX, XX }, 2475 { "(bad)", XX, XX, XX }, 2476 }, 2477 /* de */ 2478 { 2479 { "faddp", STi, ST, XX }, 2480 { "fmulp", STi, ST, XX }, 2481 { "(bad)", XX, XX, XX }, 2482 { FGRPde_3 }, 2483 #if UNIXWARE_COMPAT 2484 { "fsubp", STi, ST, XX }, 2485 { "fsubrp", STi, ST, XX }, 2486 { "fdivp", STi, ST, XX }, 2487 { "fdivrp", STi, ST, XX }, 2488 #else 2489 { "fsubrp", STi, ST, XX }, 2490 { "fsubp", STi, ST, XX }, 2491 { "fdivrp", STi, ST, XX }, 2492 { "fdivp", STi, ST, XX }, 2493 #endif 2494 }, 2495 /* df */ 2496 { 2497 { "ffreep", STi, XX, XX }, 2498 { "(bad)", XX, XX, XX }, 2499 { "(bad)", XX, XX, XX }, 2500 { "(bad)", XX, XX, XX }, 2501 { FGRPdf_4 }, 2502 { "fucomip",ST, STi, XX }, 2503 { "fcomip", ST, STi, XX }, 2504 { "(bad)", XX, XX, XX }, 2505 }, 2506 }; 2507 2508 static char *fgrps[][8] = { 2509 /* d9_2 0 */ 2510 { 2511 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 2512 }, 2513 2514 /* d9_4 1 */ 2515 { 2516 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", 2517 }, 2518 2519 /* d9_5 2 */ 2520 { 2521 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", 2522 }, 2523 2524 /* d9_6 3 */ 2525 { 2526 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", 2527 }, 2528 2529 /* d9_7 4 */ 2530 { 2531 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", 2532 }, 2533 2534 /* da_5 5 */ 2535 { 2536 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 2537 }, 2538 2539 /* db_4 6 */ 2540 { 2541 "feni(287 only)","fdisi(287 only)","fNclex","fNinit", 2542 "fNsetpm(287 only)","(bad)","(bad)","(bad)", 2543 }, 2544 2545 /* de_3 7 */ 2546 { 2547 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 2548 }, 2549 2550 /* df_4 8 */ 2551 { 2552 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 2553 }, 2554 }; 2555 2556 static void 2557 dofloat (int sizeflag) 2558 { 2559 const struct dis386 *dp; 2560 unsigned char floatop; 2561 2562 floatop = codep[-1]; 2563 2564 if (mod != 3) 2565 { 2566 putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag); 2567 obufp = op1out; 2568 if (floatop == 0xdb) 2569 OP_E (x_mode, sizeflag); 2570 else if (floatop == 0xdd) 2571 OP_E (d_mode, sizeflag); 2572 else 2573 OP_E (v_mode, sizeflag); 2574 return; 2575 } 2576 /* Skip mod/rm byte. */ 2577 MODRM_CHECK; 2578 codep++; 2579 2580 dp = &float_reg[floatop - 0xd8][reg]; 2581 if (dp->name == NULL) 2582 { 2583 putop (fgrps[dp->bytemode1][rm], sizeflag); 2584 2585 /* Instruction fnstsw is only one with strange arg. */ 2586 if (floatop == 0xdf && codep[-1] == 0xe0) 2587 strcpy (op1out, names16[0]); 2588 } 2589 else 2590 { 2591 putop (dp->name, sizeflag); 2592 2593 obufp = op1out; 2594 if (dp->op1) 2595 (*dp->op1) (dp->bytemode1, sizeflag); 2596 obufp = op2out; 2597 if (dp->op2) 2598 (*dp->op2) (dp->bytemode2, sizeflag); 2599 } 2600 } 2601 2602 static void 2603 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 2604 { 2605 oappend ("%st"); 2606 } 2607 2608 static void 2609 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 2610 { 2611 sprintf (scratchbuf, "%%st(%d)", rm); 2612 oappend (scratchbuf + intel_syntax); 2613 } 2614 2615 /* Capital letters in template are macros. */ 2616 static int 2617 putop (const char *template, int sizeflag) 2618 { 2619 const char *p; 2620 int alt; 2621 2622 for (p = template; *p; p++) 2623 { 2624 switch (*p) 2625 { 2626 default: 2627 *obufp++ = *p; 2628 break; 2629 case '{': 2630 alt = 0; 2631 if (intel_syntax) 2632 alt += 1; 2633 if (mode_64bit) 2634 alt += 2; 2635 while (alt != 0) 2636 { 2637 while (*++p != '|') 2638 { 2639 if (*p == '}') 2640 { 2641 /* Alternative not valid. */ 2642 strcpy (obuf, "(bad)"); 2643 obufp = obuf + 5; 2644 return 1; 2645 } 2646 else if (*p == '\0') 2647 abort (); 2648 } 2649 alt--; 2650 } 2651 break; 2652 case '|': 2653 while (*++p != '}') 2654 { 2655 if (*p == '\0') 2656 abort (); 2657 } 2658 break; 2659 case '}': 2660 break; 2661 case 'A': 2662 if (intel_syntax) 2663 break; 2664 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 2665 *obufp++ = 'b'; 2666 break; 2667 case 'B': 2668 if (intel_syntax) 2669 break; 2670 if (sizeflag & SUFFIX_ALWAYS) 2671 *obufp++ = 'b'; 2672 break; 2673 case 'E': /* For jcxz/jecxz */ 2674 if (mode_64bit) 2675 { 2676 if (sizeflag & AFLAG) 2677 *obufp++ = 'r'; 2678 else 2679 *obufp++ = 'e'; 2680 } 2681 else 2682 if (sizeflag & AFLAG) 2683 *obufp++ = 'e'; 2684 used_prefixes |= (prefixes & PREFIX_ADDR); 2685 break; 2686 case 'F': 2687 if (intel_syntax) 2688 break; 2689 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) 2690 { 2691 if (sizeflag & AFLAG) 2692 *obufp++ = mode_64bit ? 'q' : 'l'; 2693 else 2694 *obufp++ = mode_64bit ? 'l' : 'w'; 2695 used_prefixes |= (prefixes & PREFIX_ADDR); 2696 } 2697 break; 2698 case 'H': 2699 if (intel_syntax) 2700 break; 2701 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS 2702 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) 2703 { 2704 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); 2705 *obufp++ = ','; 2706 *obufp++ = 'p'; 2707 if (prefixes & PREFIX_DS) 2708 *obufp++ = 't'; 2709 else 2710 *obufp++ = 'n'; 2711 } 2712 break; 2713 case 'L': 2714 if (intel_syntax) 2715 break; 2716 if (sizeflag & SUFFIX_ALWAYS) 2717 *obufp++ = 'l'; 2718 break; 2719 case 'N': 2720 if ((prefixes & PREFIX_FWAIT) == 0) 2721 *obufp++ = 'n'; 2722 else 2723 used_prefixes |= PREFIX_FWAIT; 2724 break; 2725 case 'O': 2726 USED_REX (REX_MODE64); 2727 if (rex & REX_MODE64) 2728 *obufp++ = 'o'; 2729 else 2730 *obufp++ = 'd'; 2731 break; 2732 case 'T': 2733 if (intel_syntax) 2734 break; 2735 if (mode_64bit) 2736 { 2737 *obufp++ = 'q'; 2738 break; 2739 } 2740 /* Fall through. */ 2741 case 'P': 2742 if (intel_syntax) 2743 break; 2744 if ((prefixes & PREFIX_DATA) 2745 || (rex & REX_MODE64) 2746 || (sizeflag & SUFFIX_ALWAYS)) 2747 { 2748 USED_REX (REX_MODE64); 2749 if (rex & REX_MODE64) 2750 *obufp++ = 'q'; 2751 else 2752 { 2753 if (sizeflag & DFLAG) 2754 *obufp++ = 'l'; 2755 else 2756 *obufp++ = 'w'; 2757 used_prefixes |= (prefixes & PREFIX_DATA); 2758 } 2759 } 2760 break; 2761 case 'U': 2762 if (intel_syntax) 2763 break; 2764 if (mode_64bit) 2765 { 2766 *obufp++ = 'q'; 2767 break; 2768 } 2769 /* Fall through. */ 2770 case 'Q': 2771 if (intel_syntax) 2772 break; 2773 USED_REX (REX_MODE64); 2774 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 2775 { 2776 if (rex & REX_MODE64) 2777 *obufp++ = 'q'; 2778 else 2779 { 2780 if (sizeflag & DFLAG) 2781 *obufp++ = 'l'; 2782 else 2783 *obufp++ = 'w'; 2784 used_prefixes |= (prefixes & PREFIX_DATA); 2785 } 2786 } 2787 break; 2788 case 'R': 2789 USED_REX (REX_MODE64); 2790 if (intel_syntax) 2791 { 2792 if (rex & REX_MODE64) 2793 { 2794 *obufp++ = 'q'; 2795 *obufp++ = 't'; 2796 } 2797 else if (sizeflag & DFLAG) 2798 { 2799 *obufp++ = 'd'; 2800 *obufp++ = 'q'; 2801 } 2802 else 2803 { 2804 *obufp++ = 'w'; 2805 *obufp++ = 'd'; 2806 } 2807 } 2808 else 2809 { 2810 if (rex & REX_MODE64) 2811 *obufp++ = 'q'; 2812 else if (sizeflag & DFLAG) 2813 *obufp++ = 'l'; 2814 else 2815 *obufp++ = 'w'; 2816 } 2817 if (!(rex & REX_MODE64)) 2818 used_prefixes |= (prefixes & PREFIX_DATA); 2819 break; 2820 case 'S': 2821 if (intel_syntax) 2822 break; 2823 if (sizeflag & SUFFIX_ALWAYS) 2824 { 2825 if (rex & REX_MODE64) 2826 *obufp++ = 'q'; 2827 else 2828 { 2829 if (sizeflag & DFLAG) 2830 *obufp++ = 'l'; 2831 else 2832 *obufp++ = 'w'; 2833 used_prefixes |= (prefixes & PREFIX_DATA); 2834 } 2835 } 2836 break; 2837 case 'X': 2838 if (prefixes & PREFIX_DATA) 2839 *obufp++ = 'd'; 2840 else 2841 *obufp++ = 's'; 2842 used_prefixes |= (prefixes & PREFIX_DATA); 2843 break; 2844 case 'Y': 2845 if (intel_syntax) 2846 break; 2847 if (rex & REX_MODE64) 2848 { 2849 USED_REX (REX_MODE64); 2850 *obufp++ = 'q'; 2851 } 2852 break; 2853 /* implicit operand size 'l' for i386 or 'q' for x86-64 */ 2854 case 'W': 2855 /* operand size flag for cwtl, cbtw */ 2856 USED_REX (0); 2857 if (rex) 2858 *obufp++ = 'l'; 2859 else if (sizeflag & DFLAG) 2860 *obufp++ = 'w'; 2861 else 2862 *obufp++ = 'b'; 2863 if (intel_syntax) 2864 { 2865 if (rex) 2866 { 2867 *obufp++ = 'q'; 2868 *obufp++ = 'e'; 2869 } 2870 if (sizeflag & DFLAG) 2871 { 2872 *obufp++ = 'd'; 2873 *obufp++ = 'e'; 2874 } 2875 else 2876 { 2877 *obufp++ = 'w'; 2878 } 2879 } 2880 if (!rex) 2881 used_prefixes |= (prefixes & PREFIX_DATA); 2882 break; 2883 } 2884 } 2885 *obufp = 0; 2886 return 0; 2887 } 2888 2889 static void 2890 oappend (const char *s) 2891 { 2892 strcpy (obufp, s); 2893 obufp += strlen (s); 2894 } 2895 2896 static void 2897 append_seg (void) 2898 { 2899 if (prefixes & PREFIX_CS) 2900 { 2901 used_prefixes |= PREFIX_CS; 2902 oappend ("%cs:" + intel_syntax); 2903 } 2904 if (prefixes & PREFIX_DS) 2905 { 2906 used_prefixes |= PREFIX_DS; 2907 oappend ("%ds:" + intel_syntax); 2908 } 2909 if (prefixes & PREFIX_SS) 2910 { 2911 used_prefixes |= PREFIX_SS; 2912 oappend ("%ss:" + intel_syntax); 2913 } 2914 if (prefixes & PREFIX_ES) 2915 { 2916 used_prefixes |= PREFIX_ES; 2917 oappend ("%es:" + intel_syntax); 2918 } 2919 if (prefixes & PREFIX_FS) 2920 { 2921 used_prefixes |= PREFIX_FS; 2922 oappend ("%fs:" + intel_syntax); 2923 } 2924 if (prefixes & PREFIX_GS) 2925 { 2926 used_prefixes |= PREFIX_GS; 2927 oappend ("%gs:" + intel_syntax); 2928 } 2929 } 2930 2931 static void 2932 OP_indirE (int bytemode, int sizeflag) 2933 { 2934 if (!intel_syntax) 2935 oappend ("*"); 2936 OP_E (bytemode, sizeflag); 2937 } 2938 2939 static void 2940 print_operand_value (char *buf, int hex, bfd_vma disp) 2941 { 2942 if (mode_64bit) 2943 { 2944 if (hex) 2945 { 2946 char tmp[30]; 2947 int i; 2948 buf[0] = '0'; 2949 buf[1] = 'x'; 2950 sprintf_vma (tmp, disp); 2951 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); 2952 strcpy (buf + 2, tmp + i); 2953 } 2954 else 2955 { 2956 bfd_signed_vma v = disp; 2957 char tmp[30]; 2958 int i; 2959 if (v < 0) 2960 { 2961 *(buf++) = '-'; 2962 v = -disp; 2963 /* Check for possible overflow on 0x8000000000000000. */ 2964 if (v < 0) 2965 { 2966 strcpy (buf, "9223372036854775808"); 2967 return; 2968 } 2969 } 2970 if (!v) 2971 { 2972 strcpy (buf, "0"); 2973 return; 2974 } 2975 2976 i = 0; 2977 tmp[29] = 0; 2978 while (v) 2979 { 2980 tmp[28 - i] = (v % 10) + '0'; 2981 v /= 10; 2982 i++; 2983 } 2984 strcpy (buf, tmp + 29 - i); 2985 } 2986 } 2987 else 2988 { 2989 if (hex) 2990 sprintf (buf, "0x%x", (unsigned int) disp); 2991 else 2992 sprintf (buf, "%d", (int) disp); 2993 } 2994 } 2995 2996 static void 2997 OP_E (int bytemode, int sizeflag) 2998 { 2999 bfd_vma disp; 3000 int add = 0; 3001 int riprel = 0; 3002 USED_REX (REX_EXTZ); 3003 if (rex & REX_EXTZ) 3004 add += 8; 3005 3006 /* Skip mod/rm byte. */ 3007 MODRM_CHECK; 3008 codep++; 3009 3010 if (mod == 3) 3011 { 3012 switch (bytemode) 3013 { 3014 case b_mode: 3015 USED_REX (0); 3016 if (rex) 3017 oappend (names8rex[rm + add]); 3018 else 3019 oappend (names8[rm + add]); 3020 break; 3021 case w_mode: 3022 oappend (names16[rm + add]); 3023 break; 3024 case d_mode: 3025 oappend (names32[rm + add]); 3026 break; 3027 case q_mode: 3028 oappend (names64[rm + add]); 3029 break; 3030 case m_mode: 3031 if (mode_64bit) 3032 oappend (names64[rm + add]); 3033 else 3034 oappend (names32[rm + add]); 3035 break; 3036 case v_mode: 3037 case dq_mode: 3038 USED_REX (REX_MODE64); 3039 if (rex & REX_MODE64) 3040 oappend (names64[rm + add]); 3041 else if ((sizeflag & DFLAG) || bytemode == dq_mode) 3042 oappend (names32[rm + add]); 3043 else 3044 oappend (names16[rm + add]); 3045 used_prefixes |= (prefixes & PREFIX_DATA); 3046 break; 3047 case 0: 3048 break; 3049 default: 3050 oappend (INTERNAL_DISASSEMBLER_ERROR); 3051 break; 3052 } 3053 return; 3054 } 3055 3056 disp = 0; 3057 append_seg (); 3058 3059 if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */ 3060 { 3061 int havesib; 3062 int havebase; 3063 int base; 3064 int index = 0; 3065 int scale = 0; 3066 3067 havesib = 0; 3068 havebase = 1; 3069 base = rm; 3070 3071 if (base == 4) 3072 { 3073 havesib = 1; 3074 FETCH_DATA (the_info, codep + 1); 3075 scale = (*codep >> 6) & 3; 3076 index = (*codep >> 3) & 7; 3077 base = *codep & 7; 3078 USED_REX (REX_EXTY); 3079 USED_REX (REX_EXTZ); 3080 if (rex & REX_EXTY) 3081 index += 8; 3082 if (rex & REX_EXTZ) 3083 base += 8; 3084 codep++; 3085 } 3086 3087 switch (mod) 3088 { 3089 case 0: 3090 if ((base & 7) == 5) 3091 { 3092 havebase = 0; 3093 if (mode_64bit && !havesib && (sizeflag & AFLAG)) 3094 riprel = 1; 3095 disp = get32s (); 3096 } 3097 break; 3098 case 1: 3099 FETCH_DATA (the_info, codep + 1); 3100 disp = *codep++; 3101 if ((disp & 0x80) != 0) 3102 disp -= 0x100; 3103 break; 3104 case 2: 3105 disp = get32s (); 3106 break; 3107 } 3108 3109 if (!intel_syntax) 3110 if (mod != 0 || (base & 7) == 5) 3111 { 3112 print_operand_value (scratchbuf, !riprel, disp); 3113 oappend (scratchbuf); 3114 if (riprel) 3115 { 3116 set_op (disp, 1); 3117 oappend ("(%rip)"); 3118 } 3119 } 3120 3121 if (havebase || (havesib && (index != 4 || scale != 0))) 3122 { 3123 if (intel_syntax) 3124 { 3125 switch (bytemode) 3126 { 3127 case b_mode: 3128 oappend ("BYTE PTR "); 3129 break; 3130 case w_mode: 3131 oappend ("WORD PTR "); 3132 break; 3133 case v_mode: 3134 oappend ("DWORD PTR "); 3135 break; 3136 case d_mode: 3137 oappend ("QWORD PTR "); 3138 break; 3139 case m_mode: 3140 if (mode_64bit) 3141 oappend ("DWORD PTR "); 3142 else 3143 oappend ("QWORD PTR "); 3144 break; 3145 case x_mode: 3146 oappend ("XWORD PTR "); 3147 break; 3148 default: 3149 break; 3150 } 3151 } 3152 *obufp++ = open_char; 3153 if (intel_syntax && riprel) 3154 oappend ("rip + "); 3155 *obufp = '\0'; 3156 USED_REX (REX_EXTZ); 3157 if (!havesib && (rex & REX_EXTZ)) 3158 base += 8; 3159 if (havebase) 3160 oappend (mode_64bit && (sizeflag & AFLAG) 3161 ? names64[base] : names32[base]); 3162 if (havesib) 3163 { 3164 if (index != 4) 3165 { 3166 if (intel_syntax) 3167 { 3168 if (havebase) 3169 { 3170 *obufp++ = separator_char; 3171 *obufp = '\0'; 3172 } 3173 sprintf (scratchbuf, "%s", 3174 mode_64bit && (sizeflag & AFLAG) 3175 ? names64[index] : names32[index]); 3176 } 3177 else 3178 sprintf (scratchbuf, ",%s", 3179 mode_64bit && (sizeflag & AFLAG) 3180 ? names64[index] : names32[index]); 3181 oappend (scratchbuf); 3182 } 3183 if (scale != 0 || (!intel_syntax && index != 4)) 3184 { 3185 *obufp++ = scale_char; 3186 *obufp = '\0'; 3187 sprintf (scratchbuf, "%d", 1 << scale); 3188 oappend (scratchbuf); 3189 } 3190 } 3191 if (intel_syntax) 3192 if (mod != 0 || (base & 7) == 5) 3193 { 3194 /* Don't print zero displacements. */ 3195 if (disp != 0) 3196 { 3197 if ((bfd_signed_vma) disp > 0) 3198 { 3199 *obufp++ = '+'; 3200 *obufp = '\0'; 3201 } 3202 3203 print_operand_value (scratchbuf, 0, disp); 3204 oappend (scratchbuf); 3205 } 3206 } 3207 3208 *obufp++ = close_char; 3209 *obufp = '\0'; 3210 } 3211 else if (intel_syntax) 3212 { 3213 if (mod != 0 || (base & 7) == 5) 3214 { 3215 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 3216 | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 3217 ; 3218 else 3219 { 3220 oappend (names_seg[ds_reg - es_reg]); 3221 oappend (":"); 3222 } 3223 print_operand_value (scratchbuf, 1, disp); 3224 oappend (scratchbuf); 3225 } 3226 } 3227 } 3228 else 3229 { /* 16 bit address mode */ 3230 switch (mod) 3231 { 3232 case 0: 3233 if ((rm & 7) == 6) 3234 { 3235 disp = get16 (); 3236 if ((disp & 0x8000) != 0) 3237 disp -= 0x10000; 3238 } 3239 break; 3240 case 1: 3241 FETCH_DATA (the_info, codep + 1); 3242 disp = *codep++; 3243 if ((disp & 0x80) != 0) 3244 disp -= 0x100; 3245 break; 3246 case 2: 3247 disp = get16 (); 3248 if ((disp & 0x8000) != 0) 3249 disp -= 0x10000; 3250 break; 3251 } 3252 3253 if (!intel_syntax) 3254 if (mod != 0 || (rm & 7) == 6) 3255 { 3256 print_operand_value (scratchbuf, 0, disp); 3257 oappend (scratchbuf); 3258 } 3259 3260 if (mod != 0 || (rm & 7) != 6) 3261 { 3262 *obufp++ = open_char; 3263 *obufp = '\0'; 3264 oappend (index16[rm + add]); 3265 *obufp++ = close_char; 3266 *obufp = '\0'; 3267 } 3268 } 3269 } 3270 3271 static void 3272 OP_G (int bytemode, int sizeflag) 3273 { 3274 int add = 0; 3275 USED_REX (REX_EXTX); 3276 if (rex & REX_EXTX) 3277 add += 8; 3278 switch (bytemode) 3279 { 3280 case b_mode: 3281 USED_REX (0); 3282 if (rex) 3283 oappend (names8rex[reg + add]); 3284 else 3285 oappend (names8[reg + add]); 3286 break; 3287 case w_mode: 3288 oappend (names16[reg + add]); 3289 break; 3290 case d_mode: 3291 oappend (names32[reg + add]); 3292 break; 3293 case q_mode: 3294 oappend (names64[reg + add]); 3295 break; 3296 case v_mode: 3297 USED_REX (REX_MODE64); 3298 if (rex & REX_MODE64) 3299 oappend (names64[reg + add]); 3300 else if (sizeflag & DFLAG) 3301 oappend (names32[reg + add]); 3302 else 3303 oappend (names16[reg + add]); 3304 used_prefixes |= (prefixes & PREFIX_DATA); 3305 break; 3306 default: 3307 oappend (INTERNAL_DISASSEMBLER_ERROR); 3308 break; 3309 } 3310 } 3311 3312 static bfd_vma 3313 get64 (void) 3314 { 3315 bfd_vma x; 3316 #ifdef BFD64 3317 unsigned int a; 3318 unsigned int b; 3319 3320 FETCH_DATA (the_info, codep + 8); 3321 a = *codep++ & 0xff; 3322 a |= (*codep++ & 0xff) << 8; 3323 a |= (*codep++ & 0xff) << 16; 3324 a |= (*codep++ & 0xff) << 24; 3325 b = *codep++ & 0xff; 3326 b |= (*codep++ & 0xff) << 8; 3327 b |= (*codep++ & 0xff) << 16; 3328 b |= (*codep++ & 0xff) << 24; 3329 x = a + ((bfd_vma) b << 32); 3330 #else 3331 abort (); 3332 x = 0; 3333 #endif 3334 return x; 3335 } 3336 3337 static bfd_signed_vma 3338 get32 (void) 3339 { 3340 bfd_signed_vma x = 0; 3341 3342 FETCH_DATA (the_info, codep + 4); 3343 x = *codep++ & (bfd_signed_vma) 0xff; 3344 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 3345 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 3346 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 3347 return x; 3348 } 3349 3350 static bfd_signed_vma 3351 get32s (void) 3352 { 3353 bfd_signed_vma x = 0; 3354 3355 FETCH_DATA (the_info, codep + 4); 3356 x = *codep++ & (bfd_signed_vma) 0xff; 3357 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 3358 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 3359 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 3360 3361 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); 3362 3363 return x; 3364 } 3365 3366 static int 3367 get16 (void) 3368 { 3369 int x = 0; 3370 3371 FETCH_DATA (the_info, codep + 2); 3372 x = *codep++ & 0xff; 3373 x |= (*codep++ & 0xff) << 8; 3374 return x; 3375 } 3376 3377 static void 3378 set_op (bfd_vma op, int riprel) 3379 { 3380 op_index[op_ad] = op_ad; 3381 if (mode_64bit) 3382 { 3383 op_address[op_ad] = op; 3384 op_riprel[op_ad] = riprel; 3385 } 3386 else 3387 { 3388 /* Mask to get a 32-bit address. */ 3389 op_address[op_ad] = op & 0xffffffff; 3390 op_riprel[op_ad] = riprel & 0xffffffff; 3391 } 3392 } 3393 3394 static void 3395 OP_REG (int code, int sizeflag) 3396 { 3397 const char *s; 3398 int add = 0; 3399 USED_REX (REX_EXTZ); 3400 if (rex & REX_EXTZ) 3401 add = 8; 3402 3403 switch (code) 3404 { 3405 case indir_dx_reg: 3406 if (intel_syntax) 3407 s = "[dx]"; 3408 else 3409 s = "(%dx)"; 3410 break; 3411 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 3412 case sp_reg: case bp_reg: case si_reg: case di_reg: 3413 s = names16[code - ax_reg + add]; 3414 break; 3415 case es_reg: case ss_reg: case cs_reg: 3416 case ds_reg: case fs_reg: case gs_reg: 3417 s = names_seg[code - es_reg + add]; 3418 break; 3419 case al_reg: case ah_reg: case cl_reg: case ch_reg: 3420 case dl_reg: case dh_reg: case bl_reg: case bh_reg: 3421 USED_REX (0); 3422 if (rex) 3423 s = names8rex[code - al_reg + add]; 3424 else 3425 s = names8[code - al_reg]; 3426 break; 3427 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: 3428 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: 3429 if (mode_64bit) 3430 { 3431 s = names64[code - rAX_reg + add]; 3432 break; 3433 } 3434 code += eAX_reg - rAX_reg; 3435 /* Fall through. */ 3436 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 3437 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 3438 USED_REX (REX_MODE64); 3439 if (rex & REX_MODE64) 3440 s = names64[code - eAX_reg + add]; 3441 else if (sizeflag & DFLAG) 3442 s = names32[code - eAX_reg + add]; 3443 else 3444 s = names16[code - eAX_reg + add]; 3445 used_prefixes |= (prefixes & PREFIX_DATA); 3446 break; 3447 default: 3448 s = INTERNAL_DISASSEMBLER_ERROR; 3449 break; 3450 } 3451 oappend (s); 3452 } 3453 3454 static void 3455 OP_IMREG (int code, int sizeflag) 3456 { 3457 const char *s; 3458 3459 switch (code) 3460 { 3461 case indir_dx_reg: 3462 if (intel_syntax) 3463 s = "[dx]"; 3464 else 3465 s = "(%dx)"; 3466 break; 3467 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 3468 case sp_reg: case bp_reg: case si_reg: case di_reg: 3469 s = names16[code - ax_reg]; 3470 break; 3471 case es_reg: case ss_reg: case cs_reg: 3472 case ds_reg: case fs_reg: case gs_reg: 3473 s = names_seg[code - es_reg]; 3474 break; 3475 case al_reg: case ah_reg: case cl_reg: case ch_reg: 3476 case dl_reg: case dh_reg: case bl_reg: case bh_reg: 3477 USED_REX (0); 3478 if (rex) 3479 s = names8rex[code - al_reg]; 3480 else 3481 s = names8[code - al_reg]; 3482 break; 3483 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 3484 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 3485 USED_REX (REX_MODE64); 3486 if (rex & REX_MODE64) 3487 s = names64[code - eAX_reg]; 3488 else if (sizeflag & DFLAG) 3489 s = names32[code - eAX_reg]; 3490 else 3491 s = names16[code - eAX_reg]; 3492 used_prefixes |= (prefixes & PREFIX_DATA); 3493 break; 3494 default: 3495 s = INTERNAL_DISASSEMBLER_ERROR; 3496 break; 3497 } 3498 oappend (s); 3499 } 3500 3501 static void 3502 OP_I (int bytemode, int sizeflag) 3503 { 3504 bfd_signed_vma op; 3505 bfd_signed_vma mask = -1; 3506 3507 switch (bytemode) 3508 { 3509 case b_mode: 3510 FETCH_DATA (the_info, codep + 1); 3511 op = *codep++; 3512 mask = 0xff; 3513 break; 3514 case q_mode: 3515 if (mode_64bit) 3516 { 3517 op = get32s (); 3518 break; 3519 } 3520 /* Fall through. */ 3521 case v_mode: 3522 USED_REX (REX_MODE64); 3523 if (rex & REX_MODE64) 3524 op = get32s (); 3525 else if (sizeflag & DFLAG) 3526 { 3527 op = get32 (); 3528 mask = 0xffffffff; 3529 } 3530 else 3531 { 3532 op = get16 (); 3533 mask = 0xfffff; 3534 } 3535 used_prefixes |= (prefixes & PREFIX_DATA); 3536 break; 3537 case w_mode: 3538 mask = 0xfffff; 3539 op = get16 (); 3540 break; 3541 default: 3542 oappend (INTERNAL_DISASSEMBLER_ERROR); 3543 return; 3544 } 3545 3546 op &= mask; 3547 scratchbuf[0] = '$'; 3548 print_operand_value (scratchbuf + 1, 1, op); 3549 oappend (scratchbuf + intel_syntax); 3550 scratchbuf[0] = '\0'; 3551 } 3552 3553 static void 3554 OP_I64 (int bytemode, int sizeflag) 3555 { 3556 bfd_signed_vma op; 3557 bfd_signed_vma mask = -1; 3558 3559 if (!mode_64bit) 3560 { 3561 OP_I (bytemode, sizeflag); 3562 return; 3563 } 3564 3565 switch (bytemode) 3566 { 3567 case b_mode: 3568 FETCH_DATA (the_info, codep + 1); 3569 op = *codep++; 3570 mask = 0xff; 3571 break; 3572 case v_mode: 3573 USED_REX (REX_MODE64); 3574 if (rex & REX_MODE64) 3575 op = get64 (); 3576 else if (sizeflag & DFLAG) 3577 { 3578 op = get32 (); 3579 mask = 0xffffffff; 3580 } 3581 else 3582 { 3583 op = get16 (); 3584 mask = 0xfffff; 3585 } 3586 used_prefixes |= (prefixes & PREFIX_DATA); 3587 break; 3588 case w_mode: 3589 mask = 0xfffff; 3590 op = get16 (); 3591 break; 3592 default: 3593 oappend (INTERNAL_DISASSEMBLER_ERROR); 3594 return; 3595 } 3596 3597 op &= mask; 3598 scratchbuf[0] = '$'; 3599 print_operand_value (scratchbuf + 1, 1, op); 3600 oappend (scratchbuf + intel_syntax); 3601 scratchbuf[0] = '\0'; 3602 } 3603 3604 static void 3605 OP_sI (int bytemode, int sizeflag) 3606 { 3607 bfd_signed_vma op; 3608 bfd_signed_vma mask = -1; 3609 3610 switch (bytemode) 3611 { 3612 case b_mode: 3613 FETCH_DATA (the_info, codep + 1); 3614 op = *codep++; 3615 if ((op & 0x80) != 0) 3616 op -= 0x100; 3617 mask = 0xffffffff; 3618 break; 3619 case v_mode: 3620 USED_REX (REX_MODE64); 3621 if (rex & REX_MODE64) 3622 op = get32s (); 3623 else if (sizeflag & DFLAG) 3624 { 3625 op = get32s (); 3626 mask = 0xffffffff; 3627 } 3628 else 3629 { 3630 mask = 0xffffffff; 3631 op = get16 (); 3632 if ((op & 0x8000) != 0) 3633 op -= 0x10000; 3634 } 3635 used_prefixes |= (prefixes & PREFIX_DATA); 3636 break; 3637 case w_mode: 3638 op = get16 (); 3639 mask = 0xffffffff; 3640 if ((op & 0x8000) != 0) 3641 op -= 0x10000; 3642 break; 3643 default: 3644 oappend (INTERNAL_DISASSEMBLER_ERROR); 3645 return; 3646 } 3647 3648 scratchbuf[0] = '$'; 3649 print_operand_value (scratchbuf + 1, 1, op); 3650 oappend (scratchbuf + intel_syntax); 3651 } 3652 3653 static void 3654 OP_J (int bytemode, int sizeflag) 3655 { 3656 bfd_vma disp; 3657 bfd_vma mask = -1; 3658 3659 switch (bytemode) 3660 { 3661 case b_mode: 3662 FETCH_DATA (the_info, codep + 1); 3663 disp = *codep++; 3664 if ((disp & 0x80) != 0) 3665 disp -= 0x100; 3666 break; 3667 case v_mode: 3668 if (sizeflag & DFLAG) 3669 disp = get32s (); 3670 else 3671 { 3672 disp = get16 (); 3673 /* For some reason, a data16 prefix on a jump instruction 3674 means that the pc is masked to 16 bits after the 3675 displacement is added! */ 3676 mask = 0xffff; 3677 } 3678 break; 3679 default: 3680 oappend (INTERNAL_DISASSEMBLER_ERROR); 3681 return; 3682 } 3683 disp = (start_pc + codep - start_codep + disp) & mask; 3684 set_op (disp, 0); 3685 print_operand_value (scratchbuf, 1, disp); 3686 oappend (scratchbuf); 3687 } 3688 3689 static void 3690 OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3691 { 3692 oappend (names_seg[reg]); 3693 } 3694 3695 static void 3696 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag) 3697 { 3698 int seg, offset; 3699 3700 if (sizeflag & DFLAG) 3701 { 3702 offset = get32 (); 3703 seg = get16 (); 3704 } 3705 else 3706 { 3707 offset = get16 (); 3708 seg = get16 (); 3709 } 3710 used_prefixes |= (prefixes & PREFIX_DATA); 3711 if (intel_syntax) 3712 sprintf (scratchbuf, "0x%x,0x%x", seg, offset); 3713 else 3714 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset); 3715 oappend (scratchbuf); 3716 } 3717 3718 static void 3719 OP_OFF (int bytemode ATTRIBUTE_UNUSED, int sizeflag) 3720 { 3721 bfd_vma off; 3722 3723 append_seg (); 3724 3725 if ((sizeflag & AFLAG) || mode_64bit) 3726 off = get32 (); 3727 else 3728 off = get16 (); 3729 3730 if (intel_syntax) 3731 { 3732 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 3733 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 3734 { 3735 oappend (names_seg[ds_reg - es_reg]); 3736 oappend (":"); 3737 } 3738 } 3739 print_operand_value (scratchbuf, 1, off); 3740 oappend (scratchbuf); 3741 } 3742 3743 static void 3744 OP_OFF64 (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3745 { 3746 bfd_vma off; 3747 3748 if (!mode_64bit) 3749 { 3750 OP_OFF (bytemode, sizeflag); 3751 return; 3752 } 3753 3754 append_seg (); 3755 3756 off = get64 (); 3757 3758 if (intel_syntax) 3759 { 3760 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 3761 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 3762 { 3763 oappend (names_seg[ds_reg - es_reg]); 3764 oappend (":"); 3765 } 3766 } 3767 print_operand_value (scratchbuf, 1, off); 3768 oappend (scratchbuf); 3769 } 3770 3771 static void 3772 ptr_reg (int code, int sizeflag) 3773 { 3774 const char *s; 3775 if (intel_syntax) 3776 oappend ("["); 3777 else 3778 oappend ("("); 3779 3780 USED_REX (REX_MODE64); 3781 if (rex & REX_MODE64) 3782 { 3783 if (!(sizeflag & AFLAG)) 3784 s = names32[code - eAX_reg]; 3785 else 3786 s = names64[code - eAX_reg]; 3787 } 3788 else if (sizeflag & AFLAG) 3789 s = names32[code - eAX_reg]; 3790 else 3791 s = names16[code - eAX_reg]; 3792 oappend (s); 3793 if (intel_syntax) 3794 oappend ("]"); 3795 else 3796 oappend (")"); 3797 } 3798 3799 static void 3800 OP_ESreg (int code, int sizeflag) 3801 { 3802 oappend ("%es:" + intel_syntax); 3803 ptr_reg (code, sizeflag); 3804 } 3805 3806 static void 3807 OP_DSreg (int code, int sizeflag) 3808 { 3809 if ((prefixes 3810 & (PREFIX_CS 3811 | PREFIX_DS 3812 | PREFIX_SS 3813 | PREFIX_ES 3814 | PREFIX_FS 3815 | PREFIX_GS)) == 0) 3816 prefixes |= PREFIX_DS; 3817 append_seg (); 3818 ptr_reg (code, sizeflag); 3819 } 3820 3821 static void 3822 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3823 { 3824 int add = 0; 3825 USED_REX (REX_EXTX); 3826 if (rex & REX_EXTX) 3827 add = 8; 3828 sprintf (scratchbuf, "%%cr%d", reg + add); 3829 oappend (scratchbuf + intel_syntax); 3830 } 3831 3832 static void 3833 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3834 { 3835 int add = 0; 3836 USED_REX (REX_EXTX); 3837 if (rex & REX_EXTX) 3838 add = 8; 3839 if (intel_syntax) 3840 sprintf (scratchbuf, "db%d", reg + add); 3841 else 3842 sprintf (scratchbuf, "%%db%d", reg + add); 3843 oappend (scratchbuf); 3844 } 3845 3846 static void 3847 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3848 { 3849 sprintf (scratchbuf, "%%tr%d", reg); 3850 oappend (scratchbuf + intel_syntax); 3851 } 3852 3853 static void 3854 OP_Rd (int bytemode, int sizeflag) 3855 { 3856 if (mod == 3) 3857 OP_E (bytemode, sizeflag); 3858 else 3859 BadOp (); 3860 } 3861 3862 static void 3863 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3864 { 3865 int add = 0; 3866 USED_REX (REX_EXTX); 3867 if (rex & REX_EXTX) 3868 add = 8; 3869 used_prefixes |= (prefixes & PREFIX_DATA); 3870 if (prefixes & PREFIX_DATA) 3871 sprintf (scratchbuf, "%%xmm%d", reg + add); 3872 else 3873 sprintf (scratchbuf, "%%mm%d", reg + add); 3874 oappend (scratchbuf + intel_syntax); 3875 } 3876 3877 static void 3878 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3879 { 3880 int add = 0; 3881 USED_REX (REX_EXTX); 3882 if (rex & REX_EXTX) 3883 add = 8; 3884 sprintf (scratchbuf, "%%xmm%d", reg + add); 3885 oappend (scratchbuf + intel_syntax); 3886 } 3887 3888 static void 3889 OP_EM (int bytemode, int sizeflag) 3890 { 3891 int add = 0; 3892 if (mod != 3) 3893 { 3894 OP_E (bytemode, sizeflag); 3895 return; 3896 } 3897 USED_REX (REX_EXTZ); 3898 if (rex & REX_EXTZ) 3899 add = 8; 3900 3901 /* Skip mod/rm byte. */ 3902 MODRM_CHECK; 3903 codep++; 3904 used_prefixes |= (prefixes & PREFIX_DATA); 3905 if (prefixes & PREFIX_DATA) 3906 sprintf (scratchbuf, "%%xmm%d", rm + add); 3907 else 3908 sprintf (scratchbuf, "%%mm%d", rm + add); 3909 oappend (scratchbuf + intel_syntax); 3910 } 3911 3912 static void 3913 OP_EX (int bytemode, int sizeflag) 3914 { 3915 int add = 0; 3916 if (mod != 3) 3917 { 3918 OP_E (bytemode, sizeflag); 3919 return; 3920 } 3921 USED_REX (REX_EXTZ); 3922 if (rex & REX_EXTZ) 3923 add = 8; 3924 3925 /* Skip mod/rm byte. */ 3926 MODRM_CHECK; 3927 codep++; 3928 sprintf (scratchbuf, "%%xmm%d", rm + add); 3929 oappend (scratchbuf + intel_syntax); 3930 } 3931 3932 static void 3933 OP_MS (int bytemode, int sizeflag) 3934 { 3935 if (mod == 3) 3936 OP_EM (bytemode, sizeflag); 3937 else 3938 BadOp (); 3939 } 3940 3941 static void 3942 OP_XS (int bytemode, int sizeflag) 3943 { 3944 if (mod == 3) 3945 OP_EX (bytemode, sizeflag); 3946 else 3947 BadOp (); 3948 } 3949 3950 static void 3951 OP_M (int bytemode, int sizeflag) 3952 { 3953 if (mod == 3) 3954 BadOp (); /* bad lea,lds,les,lfs,lgs,lss modrm */ 3955 else 3956 OP_E (bytemode, sizeflag); 3957 } 3958 3959 static void 3960 OP_0fae (int bytemode, int sizeflag) 3961 { 3962 if (mod == 3) 3963 { 3964 if (reg == 7) 3965 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence"); 3966 else if (reg == 6) 3967 strcpy (obuf + strlen (obuf) - sizeof ("xsaveopt") + 1, "mfence"); 3968 else if (reg == 5) 3969 strcpy (obuf + strlen (obuf) - sizeof ("xrstor") + 1, "lfence"); 3970 bytemode = 0; 3971 3972 if (reg < 5 || rm != 0) 3973 { 3974 BadOp (); /* bad sfence, mfence, or lfence */ 3975 return; 3976 } 3977 } 3978 else if (reg < 5) 3979 { 3980 BadOp (); /* bad sfence, mfence, or lfence */ 3981 return; 3982 } 3983 3984 OP_E (bytemode, sizeflag); 3985 } 3986 3987 static void 3988 NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 3989 { 3990 /* NOP with REPZ prefix is called PAUSE. */ 3991 if (prefixes == PREFIX_REPZ) 3992 strcpy (obuf, "pause"); 3993 } 3994 3995 static const char *const Suffix3DNow[] = { 3996 /* 00 */ NULL, NULL, NULL, NULL, 3997 /* 04 */ NULL, NULL, NULL, NULL, 3998 /* 08 */ NULL, NULL, NULL, NULL, 3999 /* 0C */ "pi2fw", "pi2fd", NULL, NULL, 4000 /* 10 */ NULL, NULL, NULL, NULL, 4001 /* 14 */ NULL, NULL, NULL, NULL, 4002 /* 18 */ NULL, NULL, NULL, NULL, 4003 /* 1C */ "pf2iw", "pf2id", NULL, NULL, 4004 /* 20 */ NULL, NULL, NULL, NULL, 4005 /* 24 */ NULL, NULL, NULL, NULL, 4006 /* 28 */ NULL, NULL, NULL, NULL, 4007 /* 2C */ NULL, NULL, NULL, NULL, 4008 /* 30 */ NULL, NULL, NULL, NULL, 4009 /* 34 */ NULL, NULL, NULL, NULL, 4010 /* 38 */ NULL, NULL, NULL, NULL, 4011 /* 3C */ NULL, NULL, NULL, NULL, 4012 /* 40 */ NULL, NULL, NULL, NULL, 4013 /* 44 */ NULL, NULL, NULL, NULL, 4014 /* 48 */ NULL, NULL, NULL, NULL, 4015 /* 4C */ NULL, NULL, NULL, NULL, 4016 /* 50 */ NULL, NULL, NULL, NULL, 4017 /* 54 */ NULL, NULL, NULL, NULL, 4018 /* 58 */ NULL, NULL, NULL, NULL, 4019 /* 5C */ NULL, NULL, NULL, NULL, 4020 /* 60 */ NULL, NULL, NULL, NULL, 4021 /* 64 */ NULL, NULL, NULL, NULL, 4022 /* 68 */ NULL, NULL, NULL, NULL, 4023 /* 6C */ NULL, NULL, NULL, NULL, 4024 /* 70 */ NULL, NULL, NULL, NULL, 4025 /* 74 */ NULL, NULL, NULL, NULL, 4026 /* 78 */ NULL, NULL, NULL, NULL, 4027 /* 7C */ NULL, NULL, NULL, NULL, 4028 /* 80 */ NULL, NULL, NULL, NULL, 4029 /* 84 */ NULL, NULL, NULL, NULL, 4030 /* 88 */ NULL, NULL, "pfnacc", NULL, 4031 /* 8C */ NULL, NULL, "pfpnacc", NULL, 4032 /* 90 */ "pfcmpge", NULL, NULL, NULL, 4033 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", 4034 /* 98 */ NULL, NULL, "pfsub", NULL, 4035 /* 9C */ NULL, NULL, "pfadd", NULL, 4036 /* A0 */ "pfcmpgt", NULL, NULL, NULL, 4037 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", 4038 /* A8 */ NULL, NULL, "pfsubr", NULL, 4039 /* AC */ NULL, NULL, "pfacc", NULL, 4040 /* B0 */ "pfcmpeq", NULL, NULL, NULL, 4041 /* B4 */ "pfmul", NULL, "pfrcpit2", "pfmulhrw", 4042 /* B8 */ NULL, NULL, NULL, "pswapd", 4043 /* BC */ NULL, NULL, NULL, "pavgusb", 4044 /* C0 */ NULL, NULL, NULL, NULL, 4045 /* C4 */ NULL, NULL, NULL, NULL, 4046 /* C8 */ NULL, NULL, NULL, NULL, 4047 /* CC */ NULL, NULL, NULL, NULL, 4048 /* D0 */ NULL, NULL, NULL, NULL, 4049 /* D4 */ NULL, NULL, NULL, NULL, 4050 /* D8 */ NULL, NULL, NULL, NULL, 4051 /* DC */ NULL, NULL, NULL, NULL, 4052 /* E0 */ NULL, NULL, NULL, NULL, 4053 /* E4 */ NULL, NULL, NULL, NULL, 4054 /* E8 */ NULL, NULL, NULL, NULL, 4055 /* EC */ NULL, NULL, NULL, NULL, 4056 /* F0 */ NULL, NULL, NULL, NULL, 4057 /* F4 */ NULL, NULL, NULL, NULL, 4058 /* F8 */ NULL, NULL, NULL, NULL, 4059 /* FC */ NULL, NULL, NULL, NULL, 4060 }; 4061 4062 static void 4063 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 4064 { 4065 const char *mnemonic; 4066 4067 FETCH_DATA (the_info, codep + 1); 4068 /* AMD 3DNow! instructions are specified by an opcode suffix in the 4069 place where an 8-bit immediate would normally go. ie. the last 4070 byte of the instruction. */ 4071 obufp = obuf + strlen (obuf); 4072 mnemonic = Suffix3DNow[*codep++ & 0xff]; 4073 if (mnemonic) 4074 oappend (mnemonic); 4075 else 4076 { 4077 /* Since a variable sized modrm/sib chunk is between the start 4078 of the opcode (0x0f0f) and the opcode suffix, we need to do 4079 all the modrm processing first, and don't know until now that 4080 we have a bad opcode. This necessitates some cleaning up. */ 4081 op1out[0] = '\0'; 4082 op2out[0] = '\0'; 4083 BadOp (); 4084 } 4085 } 4086 4087 static const char *simd_cmp_op[] = { 4088 "eq", 4089 "lt", 4090 "le", 4091 "unord", 4092 "neq", 4093 "nlt", 4094 "nle", 4095 "ord" 4096 }; 4097 4098 static void 4099 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 4100 { 4101 unsigned int cmp_type; 4102 4103 FETCH_DATA (the_info, codep + 1); 4104 obufp = obuf + strlen (obuf); 4105 cmp_type = *codep++ & 0xff; 4106 if (cmp_type < 8) 4107 { 4108 char suffix1 = 'p', suffix2 = 's'; 4109 used_prefixes |= (prefixes & PREFIX_REPZ); 4110 if (prefixes & PREFIX_REPZ) 4111 suffix1 = 's'; 4112 else 4113 { 4114 used_prefixes |= (prefixes & PREFIX_DATA); 4115 if (prefixes & PREFIX_DATA) 4116 suffix2 = 'd'; 4117 else 4118 { 4119 used_prefixes |= (prefixes & PREFIX_REPNZ); 4120 if (prefixes & PREFIX_REPNZ) 4121 suffix1 = 's', suffix2 = 'd'; 4122 } 4123 } 4124 sprintf (scratchbuf, "cmp%s%c%c", 4125 simd_cmp_op[cmp_type], suffix1, suffix2); 4126 used_prefixes |= (prefixes & PREFIX_REPZ); 4127 oappend (scratchbuf); 4128 } 4129 else 4130 { 4131 /* We have a bad extension byte. Clean up. */ 4132 op1out[0] = '\0'; 4133 op2out[0] = '\0'; 4134 BadOp (); 4135 } 4136 } 4137 4138 static void 4139 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED) 4140 { 4141 /* Change movlps/movhps to movhlps/movlhps for 2 register operand 4142 forms of these instructions. */ 4143 if (mod == 3) 4144 { 4145 char *p = obuf + strlen (obuf); 4146 *(p + 1) = '\0'; 4147 *p = *(p - 1); 4148 *(p - 1) = *(p - 2); 4149 *(p - 2) = *(p - 3); 4150 *(p - 3) = extrachar; 4151 } 4152 } 4153 4154 static void 4155 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 4156 { 4157 if (mod == 3 && reg == 1 && rm <= 1) 4158 { 4159 char *p = obuf + strlen (obuf); 4160 4161 /* Override "sidt". */ 4162 if (rm) 4163 { 4164 /* mwait %eax,%ecx */ 4165 strcpy (p - 4, "mwait %eax,%ecx"); 4166 } 4167 else 4168 { 4169 /* monitor %eax,%ecx,%edx" */ 4170 strcpy (p - 4, "monitor %eax,%ecx,%edx"); 4171 } 4172 4173 codep++; 4174 } 4175 else if (mod == 3 && reg == 1 && rm <= 3) 4176 { 4177 size_t olen = strlen (obuf); 4178 char *p = obuf + olen - 4; 4179 if (*codep == 0xca) 4180 strcpy (p, "clac"); 4181 else if (*codep == 0xcb) 4182 strcpy (p, "stac"); 4183 codep++; 4184 } 4185 else 4186 OP_E (0, sizeflag); 4187 } 4188 4189 static void 4190 XCR_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 4191 { 4192 if (mod == 3 && reg == 2 && rm <= 1) 4193 { 4194 char *p = obuf + strlen (obuf); 4195 4196 /* Override "lgdt". */ 4197 if (rm) 4198 { 4199 strcpy (p - 4, "xsetbv"); 4200 } 4201 else 4202 { 4203 strcpy (p - 4, "xgetbv"); 4204 } 4205 4206 codep++; 4207 } 4208 else 4209 OP_M (0, sizeflag); 4210 } 4211 4212 static void 4213 INVLPG_Fixup (int bytemode, int sizeflag) 4214 { 4215 const char *alt; 4216 4217 switch (*codep) 4218 { 4219 case 0xf8: 4220 alt = "swapgs"; 4221 break; 4222 case 0xf9: 4223 alt = "rdtscp"; 4224 break; 4225 default: 4226 OP_M (bytemode, sizeflag); 4227 return; 4228 } 4229 /* Override "invlpg". */ 4230 strcpy (obuf + strlen (obuf) - 6, alt); 4231 codep++; 4232 } 4233 4234 static struct { 4235 unsigned char opc; 4236 char *name; 4237 } xcrypt[] = { 4238 { 0xc0, "xstore-rng" }, 4239 { 0xc8, "xcrypt-ecb" }, 4240 { 0xd0, "xcrypt-cbc" }, 4241 { 0xd8, "xcrypt-ctr" }, 4242 { 0xe0, "xcrypt-cfb" }, 4243 { 0xe8, "xcrypt-ofb" }, 4244 }; 4245 4246 static struct { 4247 unsigned char opc; 4248 char *name; 4249 } xcrypt2[] = { 4250 { 0xc0, "montmul" }, 4251 { 0xc8, "xsha1" }, 4252 { 0xd0, "xsha256" }, 4253 }; 4254 4255 static void 4256 OP_xcrypt (bytemode, sizeflag) 4257 int bytemode ATTRIBUTE_UNUSED; 4258 int sizeflag ATTRIBUTE_UNUSED; 4259 { 4260 const char *mnemonic = NULL; 4261 unsigned int i; 4262 4263 FETCH_DATA (the_info, codep + 1); 4264 /* VIA C3 xcrypt-* & xmove-* instructions are specified by an opcode 4265 suffix in the place where an 8-bit immediate would normally go. 4266 ie. the last byte of the instruction. */ 4267 obufp = obuf + strlen(obuf); 4268 4269 for (i = 0; i < sizeof(xcrypt) / sizeof(xcrypt[0]); i++) 4270 if (xcrypt[i].opc == (*codep & 0xff)) 4271 mnemonic = xcrypt[i].name; 4272 codep++; 4273 if (mnemonic) 4274 oappend (mnemonic); 4275 else 4276 BadOp(); 4277 } 4278 4279 static void 4280 OP_xcrypt2 (bytemode, sizeflag) 4281 int bytemode ATTRIBUTE_UNUSED; 4282 int sizeflag ATTRIBUTE_UNUSED; 4283 { 4284 const char *mnemonic = NULL; 4285 unsigned int i; 4286 4287 FETCH_DATA (the_info, codep + 1); 4288 /* VIA C3 xcrypt2 instructions are specified by an opcode 4289 suffix in the place where an 8-bit immediate would normally go. 4290 ie. the last byte of the instruction. */ 4291 obufp = obuf + strlen(obuf); 4292 4293 for (i = 0; i < sizeof(xcrypt2) / sizeof(xcrypt2[0]); i++) 4294 if (xcrypt2[i].opc == (*codep & 0xff)) 4295 mnemonic = xcrypt2[i].name; 4296 codep++; 4297 if (mnemonic) 4298 oappend (mnemonic); 4299 else 4300 BadOp(); 4301 } 4302 4303 static struct { 4304 unsigned char opc; 4305 char *name; 4306 } aes[] = { 4307 { 0x00, "pshufb" }, 4308 { 0xdb, "aesimc" }, 4309 { 0xdc, "aesenc" }, 4310 { 0xde, "aesdec" }, 4311 { 0xdd, "aesenclast" }, 4312 { 0xdf, "aesdeclast" } 4313 }; 4314 4315 #define XMM_DST(rex, modrm) \ 4316 (((((rex) & ~0x40) & 0x4) ? 8 : 0) | (((modrm) & ~0xc0) >> 3)) 4317 #define XMM_SRC(rex, modrm) \ 4318 (((((rex) & ~0x40) & 0x1) ? 8 : 0) | (((modrm) & ~0xc0) & 7)) 4319 4320 static void 4321 OP_0f38 (bytemode, sizeflag) 4322 int bytemode ATTRIBUTE_UNUSED; 4323 int sizeflag ATTRIBUTE_UNUSED; 4324 { 4325 const char *mnemonic = NULL; 4326 unsigned int i; 4327 4328 FETCH_DATA (the_info, codep + 1); 4329 obufp = obuf + strlen (obuf); 4330 4331 for (i = 0; i < sizeof(aes) / sizeof(aes[0]); i++) 4332 if (aes[i].opc == (*codep & 0xff)) 4333 mnemonic = aes[i].name; 4334 4335 codep++; 4336 if (mnemonic) 4337 { 4338 oappend (mnemonic); 4339 4340 FETCH_DATA (the_info, codep + 1); 4341 sprintf (scratchbuf, " %%xmm%d", XMM_SRC (rex, *codep)); 4342 oappend (scratchbuf); 4343 sprintf (scratchbuf, ",%%xmm%d", XMM_DST (rex, *codep)); 4344 oappend (scratchbuf); 4345 4346 codep++; 4347 used_prefixes |= (prefixes & PREFIX_DATA); 4348 USED_REX(rex); 4349 } 4350 else 4351 BadOp(); 4352 } 4353 4354 static struct { 4355 unsigned char opc; 4356 char *name; 4357 } pclmul[] = { 4358 { 0x00, "pclmullqlqdq" }, 4359 { 0x01, "pclmulhqlqdq" }, 4360 { 0x10, "pclmullqhqdq" }, 4361 { 0x11, "pclmulhqhqdq" }, 4362 }; 4363 4364 static void 4365 OP_0f3a (bytemode, sizeflag) 4366 int bytemode ATTRIBUTE_UNUSED; 4367 int sizeflag ATTRIBUTE_UNUSED; 4368 { 4369 const char *mnemonic = NULL; 4370 unsigned int i, xmms; 4371 unsigned char op, imm; 4372 4373 FETCH_DATA (the_info, codep + 1); 4374 obufp = obuf + strlen (obuf); 4375 4376 op = *codep; 4377 codep++; 4378 4379 FETCH_DATA (the_info, codep + 1); 4380 4381 /* save xmm pair */ 4382 xmms = XMM_DST (rex, *codep) << 8; 4383 xmms |= XMM_SRC (rex, *codep); 4384 codep++; 4385 4386 /* save immediate field */ 4387 FETCH_DATA (the_info, codep + 2); 4388 imm = *codep; 4389 codep++; 4390 4391 if (op != 0x44 && op != 0xdf) 4392 { 4393 BadOp(); 4394 return; 4395 } 4396 4397 switch (op) 4398 { 4399 case 0x44: 4400 for (i = 0; i < sizeof(pclmul) / sizeof(pclmul[0]); i++) 4401 if (pclmul[i].opc == imm) 4402 mnemonic = pclmul[i].name; 4403 4404 if (!mnemonic) 4405 { 4406 oappend ("pclmulqdq"); 4407 sprintf (scratchbuf, " $%#x,", imm); 4408 oappend (scratchbuf); 4409 } 4410 else 4411 { 4412 oappend (mnemonic); 4413 oappend (" "); 4414 } 4415 break; 4416 case 0xdf: 4417 oappend ("aeskeygenassist "); 4418 sprintf (scratchbuf, " $%#x,", imm); 4419 oappend (scratchbuf); 4420 break; 4421 } 4422 4423 sprintf (scratchbuf, "%%xmm%d,", xmms & 0xff); 4424 oappend (scratchbuf); 4425 sprintf (scratchbuf, "%%xmm%d", xmms >> 8); 4426 oappend (scratchbuf); 4427 4428 used_prefixes |= (prefixes & PREFIX_DATA); 4429 USED_REX(rex); 4430 } 4431 4432 static void 4433 BadOp (void) 4434 { 4435 /* Throw away prefixes and 1st. opcode byte. */ 4436 codep = insn_codep + 1; 4437 oappend ("(bad)"); 4438 } 4439