1 /* opcodes/i386-dis.c r1.126 */ 2 /* Print i386 instructions for GDB, the GNU debugger. 3 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 4 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22 /* 80386 instruction printer by Pace Willisson (pace (at) prep.ai.mit.edu) 23 July 1988 24 modified by John Hassey (hassey (at) dg-rtp.dg.com) 25 x86-64 support added by Jan Hubicka (jh (at) suse.cz) 26 VIA PadLock support by Michal Ludvig (mludvig (at) suse.cz). */ 27 28 /* The main tables describing the instructions is essentially a copy 29 of the "Opcode Map" chapter (Appendix A) of the Intel 80386 30 Programmers Manual. Usually, there is a capital letter, followed 31 by a small letter. The capital letter tell the addressing mode, 32 and the small letter tells about the operand size. Refer to 33 the Intel manual for details. */ 34 35 #include <stdlib.h> 36 #include "dis-asm.h" 37 /* include/opcode/i386.h r1.78 */ 38 39 /* opcode/i386.h -- Intel 80386 opcode macros 40 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 41 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 42 Free Software Foundation, Inc. 43 44 This file is part of GAS, the GNU Assembler, and GDB, the GNU Debugger. 45 46 This program is free software; you can redistribute it and/or modify 47 it under the terms of the GNU General Public License as published by 48 the Free Software Foundation; either version 2 of the License, or 49 (at your option) any later version. 50 51 This program is distributed in the hope that it will be useful, 52 but WITHOUT ANY WARRANTY; without even the implied warranty of 53 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 54 GNU General Public License for more details. 55 56 You should have received a copy of the GNU General Public License 57 along with this program; if not, write to the Free Software 58 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 59 60 /* The SystemV/386 SVR3.2 assembler, and probably all AT&T derived 61 ix86 Unix assemblers, generate floating point instructions with 62 reversed source and destination registers in certain cases. 63 Unfortunately, gcc and possibly many other programs use this 64 reversed syntax, so we're stuck with it. 65 66 eg. `fsub %st(3),%st' results in st = st - st(3) as expected, but 67 `fsub %st,%st(3)' results in st(3) = st - st(3), rather than 68 the expected st(3) = st(3) - st 69 70 This happens with all the non-commutative arithmetic floating point 71 operations with two register operands, where the source register is 72 %st, and destination register is %st(i). 73 74 The affected opcode map is dceX, dcfX, deeX, defX. */ 75 76 #ifndef SYSV386_COMPAT 77 /* Set non-zero for broken, compatible instructions. Set to zero for 78 non-broken opcodes at your peril. gcc generates SystemV/386 79 compatible instructions. */ 80 #define SYSV386_COMPAT 1 81 #endif 82 #ifndef OLDGCC_COMPAT 83 /* Set non-zero to cater for old (<= 2.8.1) versions of gcc that could 84 generate nonsense fsubp, fsubrp, fdivp and fdivrp with operands 85 reversed. */ 86 #define OLDGCC_COMPAT SYSV386_COMPAT 87 #endif 88 89 #define MOV_AX_DISP32 0xa0 90 #define POP_SEG_SHORT 0x07 91 #define JUMP_PC_RELATIVE 0xeb 92 #define INT_OPCODE 0xcd 93 #define INT3_OPCODE 0xcc 94 /* The opcode for the fwait instruction, which disassembler treats as a 95 prefix when it can. */ 96 #define FWAIT_OPCODE 0x9b 97 #define ADDR_PREFIX_OPCODE 0x67 98 #define DATA_PREFIX_OPCODE 0x66 99 #define LOCK_PREFIX_OPCODE 0xf0 100 #define CS_PREFIX_OPCODE 0x2e 101 #define DS_PREFIX_OPCODE 0x3e 102 #define ES_PREFIX_OPCODE 0x26 103 #define FS_PREFIX_OPCODE 0x64 104 #define GS_PREFIX_OPCODE 0x65 105 #define SS_PREFIX_OPCODE 0x36 106 #define REPNE_PREFIX_OPCODE 0xf2 107 #define REPE_PREFIX_OPCODE 0xf3 108 109 #define TWO_BYTE_OPCODE_ESCAPE 0x0f 110 #define NOP_OPCODE (char) 0x90 111 112 /* register numbers */ 113 #define EBP_REG_NUM 5 114 #define ESP_REG_NUM 4 115 116 /* modrm_byte.regmem for twobyte escape */ 117 #define ESCAPE_TO_TWO_BYTE_ADDRESSING ESP_REG_NUM 118 /* index_base_byte.index for no index register addressing */ 119 #define NO_INDEX_REGISTER ESP_REG_NUM 120 /* index_base_byte.base for no base register addressing */ 121 #define NO_BASE_REGISTER EBP_REG_NUM 122 #define NO_BASE_REGISTER_16 6 123 124 /* modrm.mode = REGMEM_FIELD_HAS_REG when a register is in there */ 125 #define REGMEM_FIELD_HAS_REG 0x3/* always = 0x3 */ 126 #define REGMEM_FIELD_HAS_MEM (~REGMEM_FIELD_HAS_REG) 127 128 /* x86-64 extension prefix. */ 129 #define REX_OPCODE 0x40 130 131 /* Indicates 64 bit operand size. */ 132 #define REX_W 8 133 /* High extension to reg field of modrm byte. */ 134 #define REX_R 4 135 /* High extension to SIB index field. */ 136 #define REX_X 2 137 /* High extension to base field of modrm or SIB, or reg field of opcode. */ 138 #define REX_B 1 139 140 /* max operands per insn */ 141 #define MAX_OPERANDS 4 142 143 /* max immediates per insn (lcall, ljmp, insertq, extrq) */ 144 #define MAX_IMMEDIATE_OPERANDS 2 145 146 /* max memory refs per insn (string ops) */ 147 #define MAX_MEMORY_OPERANDS 2 148 149 /* max size of insn mnemonics. */ 150 #define MAX_MNEM_SIZE 16 151 152 /* max size of register name in insn mnemonics. */ 153 #define MAX_REG_NAME_SIZE 8 154 155 /* opcodes/i386-dis.c r1.126 */ 156 #include "qemu-common.h" 157 158 #include <setjmp.h> 159 160 static int fetch_data (struct disassemble_info *, bfd_byte *); 161 static void ckprefix (void); 162 static const char *prefix_name (int, int); 163 static int print_insn (bfd_vma, disassemble_info *); 164 static void dofloat (int); 165 static void OP_ST (int, int); 166 static void OP_STi (int, int); 167 static int putop (const char *, int); 168 static void oappend (const char *); 169 static void append_seg (void); 170 static void OP_indirE (int, int); 171 static void print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp); 172 static void print_displacement (char *, bfd_vma); 173 static void OP_E (int, int); 174 static void OP_G (int, int); 175 static bfd_vma get64 (void); 176 static bfd_signed_vma get32 (void); 177 static bfd_signed_vma get32s (void); 178 static int get16 (void); 179 static void set_op (bfd_vma, int); 180 static void OP_REG (int, int); 181 static void OP_IMREG (int, int); 182 static void OP_I (int, int); 183 static void OP_I64 (int, int); 184 static void OP_sI (int, int); 185 static void OP_J (int, int); 186 static void OP_SEG (int, int); 187 static void OP_DIR (int, int); 188 static void OP_OFF (int, int); 189 static void OP_OFF64 (int, int); 190 static void ptr_reg (int, int); 191 static void OP_ESreg (int, int); 192 static void OP_DSreg (int, int); 193 static void OP_C (int, int); 194 static void OP_D (int, int); 195 static void OP_T (int, int); 196 static void OP_R (int, int); 197 static void OP_MMX (int, int); 198 static void OP_XMM (int, int); 199 static void OP_EM (int, int); 200 static void OP_EX (int, int); 201 static void OP_EMC (int,int); 202 static void OP_MXC (int,int); 203 static void OP_MS (int, int); 204 static void OP_XS (int, int); 205 static void OP_M (int, int); 206 static void OP_VMX (int, int); 207 static void OP_0fae (int, int); 208 static void OP_0f07 (int, int); 209 static void NOP_Fixup1 (int, int); 210 static void NOP_Fixup2 (int, int); 211 static void OP_3DNowSuffix (int, int); 212 static void OP_SIMD_Suffix (int, int); 213 static void SIMD_Fixup (int, int); 214 static void PNI_Fixup (int, int); 215 static void SVME_Fixup (int, int); 216 static void INVLPG_Fixup (int, int); 217 static void BadOp (void); 218 static void VMX_Fixup (int, int); 219 static void REP_Fixup (int, int); 220 static void CMPXCHG8B_Fixup (int, int); 221 static void XMM_Fixup (int, int); 222 static void CRC32_Fixup (int, int); 223 224 struct dis_private { 225 /* Points to first byte not fetched. */ 226 bfd_byte *max_fetched; 227 bfd_byte the_buffer[MAX_MNEM_SIZE]; 228 bfd_vma insn_start; 229 int orig_sizeflag; 230 jmp_buf bailout; 231 }; 232 233 enum address_mode 234 { 235 mode_16bit, 236 mode_32bit, 237 mode_64bit 238 }; 239 240 static enum address_mode address_mode; 241 242 /* Flags for the prefixes for the current instruction. See below. */ 243 static int prefixes; 244 245 /* REX prefix the current instruction. See below. */ 246 static int rex; 247 /* Bits of REX we've already used. */ 248 static int rex_used; 249 /* Mark parts used in the REX prefix. When we are testing for 250 empty prefix (for 8bit register REX extension), just mask it 251 out. Otherwise test for REX bit is excuse for existence of REX 252 only in case value is nonzero. */ 253 #define USED_REX(value) \ 254 { \ 255 if (value) \ 256 { \ 257 if ((rex & value)) \ 258 rex_used |= (value) | REX_OPCODE; \ 259 } \ 260 else \ 261 rex_used |= REX_OPCODE; \ 262 } 263 264 /* Flags for prefixes which we somehow handled when printing the 265 current instruction. */ 266 static int used_prefixes; 267 268 /* Flags stored in PREFIXES. */ 269 #define PREFIX_REPZ 1 270 #define PREFIX_REPNZ 2 271 #define PREFIX_LOCK 4 272 #define PREFIX_CS 8 273 #define PREFIX_SS 0x10 274 #define PREFIX_DS 0x20 275 #define PREFIX_ES 0x40 276 #define PREFIX_FS 0x80 277 #define PREFIX_GS 0x100 278 #define PREFIX_DATA 0x200 279 #define PREFIX_ADDR 0x400 280 #define PREFIX_FWAIT 0x800 281 282 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) 283 to ADDR (exclusive) are valid. Returns 1 for success, longjmps 284 on error. */ 285 #define FETCH_DATA(info, addr) \ 286 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \ 287 ? 1 : fetch_data ((info), (addr))) 288 289 static int 290 fetch_data (struct disassemble_info *info, bfd_byte *addr) 291 { 292 int status; 293 struct dis_private *priv = (struct dis_private *) info->private_data; 294 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 295 296 if (addr <= priv->the_buffer + MAX_MNEM_SIZE) 297 status = (*info->read_memory_func) (start, 298 priv->max_fetched, 299 addr - priv->max_fetched, 300 info); 301 else 302 status = -1; 303 if (status != 0) 304 { 305 /* If we did manage to read at least one byte, then 306 print_insn_i386 will do something sensible. Otherwise, print 307 an error. We do that here because this is where we know 308 STATUS. */ 309 if (priv->max_fetched == priv->the_buffer) 310 (*info->memory_error_func) (status, start, info); 311 longjmp (priv->bailout, 1); 312 } 313 else 314 priv->max_fetched = addr; 315 return 1; 316 } 317 318 #define XX { NULL, 0 } 319 320 #define Eb { OP_E, b_mode } 321 #define Ev { OP_E, v_mode } 322 #define Ed { OP_E, d_mode } 323 #define Edq { OP_E, dq_mode } 324 #define Edqw { OP_E, dqw_mode } 325 #define Edqb { OP_E, dqb_mode } 326 #define Edqd { OP_E, dqd_mode } 327 #define indirEv { OP_indirE, stack_v_mode } 328 #define indirEp { OP_indirE, f_mode } 329 #define stackEv { OP_E, stack_v_mode } 330 #define Em { OP_E, m_mode } 331 #define Ew { OP_E, w_mode } 332 #define M { OP_M, 0 } /* lea, lgdt, etc. */ 333 #define Ma { OP_M, v_mode } 334 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */ 335 #define Mq { OP_M, q_mode } 336 #define Gb { OP_G, b_mode } 337 #define Gv { OP_G, v_mode } 338 #define Gd { OP_G, d_mode } 339 #define Gdq { OP_G, dq_mode } 340 #define Gm { OP_G, m_mode } 341 #define Gw { OP_G, w_mode } 342 #define Rd { OP_R, d_mode } 343 #define Rm { OP_R, m_mode } 344 #define Ib { OP_I, b_mode } 345 #define sIb { OP_sI, b_mode } /* sign extened byte */ 346 #define Iv { OP_I, v_mode } 347 #define Iq { OP_I, q_mode } 348 #define Iv64 { OP_I64, v_mode } 349 #define Iw { OP_I, w_mode } 350 #define I1 { OP_I, const_1_mode } 351 #define Jb { OP_J, b_mode } 352 #define Jv { OP_J, v_mode } 353 #define Cm { OP_C, m_mode } 354 #define Dm { OP_D, m_mode } 355 #define Td { OP_T, d_mode } 356 357 #define RMeAX { OP_REG, eAX_reg } 358 #define RMeBX { OP_REG, eBX_reg } 359 #define RMeCX { OP_REG, eCX_reg } 360 #define RMeDX { OP_REG, eDX_reg } 361 #define RMeSP { OP_REG, eSP_reg } 362 #define RMeBP { OP_REG, eBP_reg } 363 #define RMeSI { OP_REG, eSI_reg } 364 #define RMeDI { OP_REG, eDI_reg } 365 #define RMrAX { OP_REG, rAX_reg } 366 #define RMrBX { OP_REG, rBX_reg } 367 #define RMrCX { OP_REG, rCX_reg } 368 #define RMrDX { OP_REG, rDX_reg } 369 #define RMrSP { OP_REG, rSP_reg } 370 #define RMrBP { OP_REG, rBP_reg } 371 #define RMrSI { OP_REG, rSI_reg } 372 #define RMrDI { OP_REG, rDI_reg } 373 #define RMAL { OP_REG, al_reg } 374 #define RMAL { OP_REG, al_reg } 375 #define RMCL { OP_REG, cl_reg } 376 #define RMDL { OP_REG, dl_reg } 377 #define RMBL { OP_REG, bl_reg } 378 #define RMAH { OP_REG, ah_reg } 379 #define RMCH { OP_REG, ch_reg } 380 #define RMDH { OP_REG, dh_reg } 381 #define RMBH { OP_REG, bh_reg } 382 #define RMAX { OP_REG, ax_reg } 383 #define RMDX { OP_REG, dx_reg } 384 385 #define eAX { OP_IMREG, eAX_reg } 386 #define eBX { OP_IMREG, eBX_reg } 387 #define eCX { OP_IMREG, eCX_reg } 388 #define eDX { OP_IMREG, eDX_reg } 389 #define eSP { OP_IMREG, eSP_reg } 390 #define eBP { OP_IMREG, eBP_reg } 391 #define eSI { OP_IMREG, eSI_reg } 392 #define eDI { OP_IMREG, eDI_reg } 393 #define AL { OP_IMREG, al_reg } 394 #define CL { OP_IMREG, cl_reg } 395 #define DL { OP_IMREG, dl_reg } 396 #define BL { OP_IMREG, bl_reg } 397 #define AH { OP_IMREG, ah_reg } 398 #define CH { OP_IMREG, ch_reg } 399 #define DH { OP_IMREG, dh_reg } 400 #define BH { OP_IMREG, bh_reg } 401 #define AX { OP_IMREG, ax_reg } 402 #define DX { OP_IMREG, dx_reg } 403 #define zAX { OP_IMREG, z_mode_ax_reg } 404 #define indirDX { OP_IMREG, indir_dx_reg } 405 406 #define Sw { OP_SEG, w_mode } 407 #define Sv { OP_SEG, v_mode } 408 #define Ap { OP_DIR, 0 } 409 #define Ob { OP_OFF64, b_mode } 410 #define Ov { OP_OFF64, v_mode } 411 #define Xb { OP_DSreg, eSI_reg } 412 #define Xv { OP_DSreg, eSI_reg } 413 #define Xz { OP_DSreg, eSI_reg } 414 #define Yb { OP_ESreg, eDI_reg } 415 #define Yv { OP_ESreg, eDI_reg } 416 #define DSBX { OP_DSreg, eBX_reg } 417 418 #define es { OP_REG, es_reg } 419 #define ss { OP_REG, ss_reg } 420 #define cs { OP_REG, cs_reg } 421 #define ds { OP_REG, ds_reg } 422 #define fs { OP_REG, fs_reg } 423 #define gs { OP_REG, gs_reg } 424 425 #define MX { OP_MMX, 0 } 426 #define XM { OP_XMM, 0 } 427 #define EM { OP_EM, v_mode } 428 #define EMd { OP_EM, d_mode } 429 #define EMq { OP_EM, q_mode } 430 #define EXd { OP_EX, d_mode } 431 #define EXq { OP_EX, q_mode } 432 #define EXx { OP_EX, x_mode } 433 #define MS { OP_MS, v_mode } 434 #define XS { OP_XS, v_mode } 435 #define EMC { OP_EMC, v_mode } 436 #define MXC { OP_MXC, 0 } 437 #define VM { OP_VMX, q_mode } 438 #define OPSUF { OP_3DNowSuffix, 0 } 439 #define OPSIMD { OP_SIMD_Suffix, 0 } 440 #define XMM0 { XMM_Fixup, 0 } 441 442 /* Used handle "rep" prefix for string instructions. */ 443 #define Xbr { REP_Fixup, eSI_reg } 444 #define Xvr { REP_Fixup, eSI_reg } 445 #define Ybr { REP_Fixup, eDI_reg } 446 #define Yvr { REP_Fixup, eDI_reg } 447 #define Yzr { REP_Fixup, eDI_reg } 448 #define indirDXr { REP_Fixup, indir_dx_reg } 449 #define ALr { REP_Fixup, al_reg } 450 #define eAXr { REP_Fixup, eAX_reg } 451 452 #define cond_jump_flag { NULL, cond_jump_mode } 453 #define loop_jcxz_flag { NULL, loop_jcxz_mode } 454 455 /* bits in sizeflag */ 456 #define SUFFIX_ALWAYS 4 457 #define AFLAG 2 458 #define DFLAG 1 459 460 #define b_mode 1 /* byte operand */ 461 #define v_mode 2 /* operand size depends on prefixes */ 462 #define w_mode 3 /* word operand */ 463 #define d_mode 4 /* double word operand */ 464 #define q_mode 5 /* quad word operand */ 465 #define t_mode 6 /* ten-byte operand */ 466 #define x_mode 7 /* 16-byte XMM operand */ 467 #define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */ 468 #define cond_jump_mode 9 469 #define loop_jcxz_mode 10 470 #define dq_mode 11 /* operand size depends on REX prefixes. */ 471 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */ 472 #define f_mode 13 /* 4- or 6-byte pointer operand */ 473 #define const_1_mode 14 474 #define stack_v_mode 15 /* v_mode for stack-related opcodes. */ 475 #define z_mode 16 /* non-quad operand size depends on prefixes */ 476 #define o_mode 17 /* 16-byte operand */ 477 #define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */ 478 #define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */ 479 480 #define es_reg 100 481 #define cs_reg 101 482 #define ss_reg 102 483 #define ds_reg 103 484 #define fs_reg 104 485 #define gs_reg 105 486 487 #define eAX_reg 108 488 #define eCX_reg 109 489 #define eDX_reg 110 490 #define eBX_reg 111 491 #define eSP_reg 112 492 #define eBP_reg 113 493 #define eSI_reg 114 494 #define eDI_reg 115 495 496 #define al_reg 116 497 #define cl_reg 117 498 #define dl_reg 118 499 #define bl_reg 119 500 #define ah_reg 120 501 #define ch_reg 121 502 #define dh_reg 122 503 #define bh_reg 123 504 505 #define ax_reg 124 506 #define cx_reg 125 507 #define dx_reg 126 508 #define bx_reg 127 509 #define sp_reg 128 510 #define bp_reg 129 511 #define si_reg 130 512 #define di_reg 131 513 514 #define rAX_reg 132 515 #define rCX_reg 133 516 #define rDX_reg 134 517 #define rBX_reg 135 518 #define rSP_reg 136 519 #define rBP_reg 137 520 #define rSI_reg 138 521 #define rDI_reg 139 522 523 #define z_mode_ax_reg 149 524 #define indir_dx_reg 150 525 526 #define FLOATCODE 1 527 #define USE_GROUPS 2 528 #define USE_PREFIX_USER_TABLE 3 529 #define X86_64_SPECIAL 4 530 #define IS_3BYTE_OPCODE 5 531 532 #define FLOAT NULL, { { NULL, FLOATCODE } } 533 534 #define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } } 535 #define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } } 536 #define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } } 537 #define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } } 538 #define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } } 539 #define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } } 540 #define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } } 541 #define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } } 542 #define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } } 543 #define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } } 544 #define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } } 545 #define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } } 546 #define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } } 547 #define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } } 548 #define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } } 549 #define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } } 550 #define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } } 551 #define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } } 552 #define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } } 553 #define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } } 554 #define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } } 555 #define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } } 556 #define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } } 557 #define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } } 558 #define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } } 559 #define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } } 560 #define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } } 561 #define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } } 562 563 #define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } } 564 #define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } } 565 #define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } } 566 #define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } } 567 #define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } } 568 #define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } } 569 #define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } } 570 #define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } } 571 #define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } } 572 #define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } } 573 #define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } } 574 #define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } } 575 #define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } } 576 #define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } } 577 #define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } } 578 #define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } } 579 #define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } } 580 #define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } } 581 #define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } } 582 #define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } } 583 #define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } } 584 #define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } } 585 #define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } } 586 #define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } } 587 #define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } } 588 #define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } } 589 #define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } } 590 #define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } } 591 #define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } } 592 #define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } } 593 #define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } } 594 #define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } } 595 #define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } } 596 #define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } } 597 #define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } } 598 #define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } } 599 #define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } } 600 #define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } } 601 #define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } } 602 #define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } } 603 #define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } } 604 #define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } } 605 #define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } } 606 #define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } } 607 #define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } } 608 #define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } } 609 #define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } } 610 #define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } } 611 #define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } } 612 #define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } } 613 #define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } } 614 #define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } } 615 #define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } } 616 #define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } } 617 #define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } } 618 #define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } } 619 #define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } } 620 #define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } } 621 #define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } } 622 #define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } } 623 #define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } } 624 #define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } } 625 #define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } } 626 #define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } } 627 #define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } } 628 #define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } } 629 #define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } } 630 #define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } } 631 #define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } } 632 #define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } } 633 #define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } } 634 #define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } } 635 #define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } } 636 #define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } } 637 #define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } } 638 #define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } } 639 #define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } } 640 #define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } } 641 #define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } } 642 #define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } } 643 #define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } } 644 #define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } } 645 #define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } } 646 #define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } } 647 #define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } } 648 #define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } } 649 #define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } } 650 #define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } } 651 #define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } } 652 #define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } } 653 #define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } } 654 #define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } } 655 #define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } } 656 #define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } } 657 #define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } } 658 #define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } } 659 #define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } } 660 #define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } } 661 662 663 #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } } 664 #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } } 665 #define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } } 666 #define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } } 667 668 #define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } } 669 #define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } } 670 671 typedef void (*op_rtn) (int bytemode, int sizeflag); 672 673 struct dis386 { 674 const char *name; 675 struct 676 { 677 op_rtn rtn; 678 int bytemode; 679 } op[MAX_OPERANDS]; 680 }; 681 682 /* Upper case letters in the instruction names here are macros. 683 'A' => print 'b' if no register operands or suffix_always is true 684 'B' => print 'b' if suffix_always is true 685 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand 686 . size prefix 687 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if 688 . suffix_always is true 689 'E' => print 'e' if 32-bit form of jcxz 690 'F' => print 'w' or 'l' depending on address size prefix (loop insns) 691 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns) 692 'H' => print ",pt" or ",pn" branch hint 693 'I' => honor following macro letter even in Intel mode (implemented only 694 . for some of the macro letters) 695 'J' => print 'l' 696 'K' => print 'd' or 'q' if rex prefix is present. 697 'L' => print 'l' if suffix_always is true 698 'N' => print 'n' if instruction has no wait "prefix" 699 'O' => print 'd' or 'o' (or 'q' in Intel mode) 700 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix, 701 . or suffix_always is true. print 'q' if rex prefix is present. 702 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always 703 . is true 704 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode) 705 'S' => print 'w', 'l' or 'q' if suffix_always is true 706 'T' => print 'q' in 64bit mode and behave as 'P' otherwise 707 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise 708 'V' => print 'q' in 64bit mode and behave as 'S' otherwise 709 'W' => print 'b', 'w' or 'l' ('d' in Intel mode) 710 'X' => print 's', 'd' depending on data16 prefix (for XMM) 711 'Y' => 'q' if instruction has an REX 64bit overwrite prefix 712 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise 713 714 Many of the above letters print nothing in Intel mode. See "putop" 715 for the details. 716 717 Braces '{' and '}', and vertical bars '|', indicate alternative 718 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel 719 modes. In cases where there are only two alternatives, the X86_64 720 instruction is reserved, and "(bad)" is printed. 721 */ 722 723 static const struct dis386 dis386[] = { 724 /* 00 */ 725 { "addB", { Eb, Gb } }, 726 { "addS", { Ev, Gv } }, 727 { "addB", { Gb, Eb } }, 728 { "addS", { Gv, Ev } }, 729 { "addB", { AL, Ib } }, 730 { "addS", { eAX, Iv } }, 731 { "push{T|}", { es } }, 732 { "pop{T|}", { es } }, 733 /* 08 */ 734 { "orB", { Eb, Gb } }, 735 { "orS", { Ev, Gv } }, 736 { "orB", { Gb, Eb } }, 737 { "orS", { Gv, Ev } }, 738 { "orB", { AL, Ib } }, 739 { "orS", { eAX, Iv } }, 740 { "push{T|}", { cs } }, 741 { "(bad)", { XX } }, /* 0x0f extended opcode escape */ 742 /* 10 */ 743 { "adcB", { Eb, Gb } }, 744 { "adcS", { Ev, Gv } }, 745 { "adcB", { Gb, Eb } }, 746 { "adcS", { Gv, Ev } }, 747 { "adcB", { AL, Ib } }, 748 { "adcS", { eAX, Iv } }, 749 { "push{T|}", { ss } }, 750 { "pop{T|}", { ss } }, 751 /* 18 */ 752 { "sbbB", { Eb, Gb } }, 753 { "sbbS", { Ev, Gv } }, 754 { "sbbB", { Gb, Eb } }, 755 { "sbbS", { Gv, Ev } }, 756 { "sbbB", { AL, Ib } }, 757 { "sbbS", { eAX, Iv } }, 758 { "push{T|}", { ds } }, 759 { "pop{T|}", { ds } }, 760 /* 20 */ 761 { "andB", { Eb, Gb } }, 762 { "andS", { Ev, Gv } }, 763 { "andB", { Gb, Eb } }, 764 { "andS", { Gv, Ev } }, 765 { "andB", { AL, Ib } }, 766 { "andS", { eAX, Iv } }, 767 { "(bad)", { XX } }, /* SEG ES prefix */ 768 { "daa{|}", { XX } }, 769 /* 28 */ 770 { "subB", { Eb, Gb } }, 771 { "subS", { Ev, Gv } }, 772 { "subB", { Gb, Eb } }, 773 { "subS", { Gv, Ev } }, 774 { "subB", { AL, Ib } }, 775 { "subS", { eAX, Iv } }, 776 { "(bad)", { XX } }, /* SEG CS prefix */ 777 { "das{|}", { XX } }, 778 /* 30 */ 779 { "xorB", { Eb, Gb } }, 780 { "xorS", { Ev, Gv } }, 781 { "xorB", { Gb, Eb } }, 782 { "xorS", { Gv, Ev } }, 783 { "xorB", { AL, Ib } }, 784 { "xorS", { eAX, Iv } }, 785 { "(bad)", { XX } }, /* SEG SS prefix */ 786 { "aaa{|}", { XX } }, 787 /* 38 */ 788 { "cmpB", { Eb, Gb } }, 789 { "cmpS", { Ev, Gv } }, 790 { "cmpB", { Gb, Eb } }, 791 { "cmpS", { Gv, Ev } }, 792 { "cmpB", { AL, Ib } }, 793 { "cmpS", { eAX, Iv } }, 794 { "(bad)", { XX } }, /* SEG DS prefix */ 795 { "aas{|}", { XX } }, 796 /* 40 */ 797 { "inc{S|}", { RMeAX } }, 798 { "inc{S|}", { RMeCX } }, 799 { "inc{S|}", { RMeDX } }, 800 { "inc{S|}", { RMeBX } }, 801 { "inc{S|}", { RMeSP } }, 802 { "inc{S|}", { RMeBP } }, 803 { "inc{S|}", { RMeSI } }, 804 { "inc{S|}", { RMeDI } }, 805 /* 48 */ 806 { "dec{S|}", { RMeAX } }, 807 { "dec{S|}", { RMeCX } }, 808 { "dec{S|}", { RMeDX } }, 809 { "dec{S|}", { RMeBX } }, 810 { "dec{S|}", { RMeSP } }, 811 { "dec{S|}", { RMeBP } }, 812 { "dec{S|}", { RMeSI } }, 813 { "dec{S|}", { RMeDI } }, 814 /* 50 */ 815 { "pushV", { RMrAX } }, 816 { "pushV", { RMrCX } }, 817 { "pushV", { RMrDX } }, 818 { "pushV", { RMrBX } }, 819 { "pushV", { RMrSP } }, 820 { "pushV", { RMrBP } }, 821 { "pushV", { RMrSI } }, 822 { "pushV", { RMrDI } }, 823 /* 58 */ 824 { "popV", { RMrAX } }, 825 { "popV", { RMrCX } }, 826 { "popV", { RMrDX } }, 827 { "popV", { RMrBX } }, 828 { "popV", { RMrSP } }, 829 { "popV", { RMrBP } }, 830 { "popV", { RMrSI } }, 831 { "popV", { RMrDI } }, 832 /* 60 */ 833 { X86_64_0 }, 834 { X86_64_1 }, 835 { X86_64_2 }, 836 { X86_64_3 }, 837 { "(bad)", { XX } }, /* seg fs */ 838 { "(bad)", { XX } }, /* seg gs */ 839 { "(bad)", { XX } }, /* op size prefix */ 840 { "(bad)", { XX } }, /* adr size prefix */ 841 /* 68 */ 842 { "pushT", { Iq } }, 843 { "imulS", { Gv, Ev, Iv } }, 844 { "pushT", { sIb } }, 845 { "imulS", { Gv, Ev, sIb } }, 846 { "ins{b||b|}", { Ybr, indirDX } }, 847 { "ins{R||G|}", { Yzr, indirDX } }, 848 { "outs{b||b|}", { indirDXr, Xb } }, 849 { "outs{R||G|}", { indirDXr, Xz } }, 850 /* 70 */ 851 { "joH", { Jb, XX, cond_jump_flag } }, 852 { "jnoH", { Jb, XX, cond_jump_flag } }, 853 { "jbH", { Jb, XX, cond_jump_flag } }, 854 { "jaeH", { Jb, XX, cond_jump_flag } }, 855 { "jeH", { Jb, XX, cond_jump_flag } }, 856 { "jneH", { Jb, XX, cond_jump_flag } }, 857 { "jbeH", { Jb, XX, cond_jump_flag } }, 858 { "jaH", { Jb, XX, cond_jump_flag } }, 859 /* 78 */ 860 { "jsH", { Jb, XX, cond_jump_flag } }, 861 { "jnsH", { Jb, XX, cond_jump_flag } }, 862 { "jpH", { Jb, XX, cond_jump_flag } }, 863 { "jnpH", { Jb, XX, cond_jump_flag } }, 864 { "jlH", { Jb, XX, cond_jump_flag } }, 865 { "jgeH", { Jb, XX, cond_jump_flag } }, 866 { "jleH", { Jb, XX, cond_jump_flag } }, 867 { "jgH", { Jb, XX, cond_jump_flag } }, 868 /* 80 */ 869 { GRP1b }, 870 { GRP1S }, 871 { "(bad)", { XX } }, 872 { GRP1Ss }, 873 { "testB", { Eb, Gb } }, 874 { "testS", { Ev, Gv } }, 875 { "xchgB", { Eb, Gb } }, 876 { "xchgS", { Ev, Gv } }, 877 /* 88 */ 878 { "movB", { Eb, Gb } }, 879 { "movS", { Ev, Gv } }, 880 { "movB", { Gb, Eb } }, 881 { "movS", { Gv, Ev } }, 882 { "movD", { Sv, Sw } }, 883 { "leaS", { Gv, M } }, 884 { "movD", { Sw, Sv } }, 885 { GRP1a }, 886 /* 90 */ 887 { PREGRP38 }, 888 { "xchgS", { RMeCX, eAX } }, 889 { "xchgS", { RMeDX, eAX } }, 890 { "xchgS", { RMeBX, eAX } }, 891 { "xchgS", { RMeSP, eAX } }, 892 { "xchgS", { RMeBP, eAX } }, 893 { "xchgS", { RMeSI, eAX } }, 894 { "xchgS", { RMeDI, eAX } }, 895 /* 98 */ 896 { "cW{t||t|}R", { XX } }, 897 { "cR{t||t|}O", { XX } }, 898 { "Jcall{T|}", { Ap } }, 899 { "(bad)", { XX } }, /* fwait */ 900 { "pushfT", { XX } }, 901 { "popfT", { XX } }, 902 { "sahf{|}", { XX } }, 903 { "lahf{|}", { XX } }, 904 /* a0 */ 905 { "movB", { AL, Ob } }, 906 { "movS", { eAX, Ov } }, 907 { "movB", { Ob, AL } }, 908 { "movS", { Ov, eAX } }, 909 { "movs{b||b|}", { Ybr, Xb } }, 910 { "movs{R||R|}", { Yvr, Xv } }, 911 { "cmps{b||b|}", { Xb, Yb } }, 912 { "cmps{R||R|}", { Xv, Yv } }, 913 /* a8 */ 914 { "testB", { AL, Ib } }, 915 { "testS", { eAX, Iv } }, 916 { "stosB", { Ybr, AL } }, 917 { "stosS", { Yvr, eAX } }, 918 { "lodsB", { ALr, Xb } }, 919 { "lodsS", { eAXr, Xv } }, 920 { "scasB", { AL, Yb } }, 921 { "scasS", { eAX, Yv } }, 922 /* b0 */ 923 { "movB", { RMAL, Ib } }, 924 { "movB", { RMCL, Ib } }, 925 { "movB", { RMDL, Ib } }, 926 { "movB", { RMBL, Ib } }, 927 { "movB", { RMAH, Ib } }, 928 { "movB", { RMCH, Ib } }, 929 { "movB", { RMDH, Ib } }, 930 { "movB", { RMBH, Ib } }, 931 /* b8 */ 932 { "movS", { RMeAX, Iv64 } }, 933 { "movS", { RMeCX, Iv64 } }, 934 { "movS", { RMeDX, Iv64 } }, 935 { "movS", { RMeBX, Iv64 } }, 936 { "movS", { RMeSP, Iv64 } }, 937 { "movS", { RMeBP, Iv64 } }, 938 { "movS", { RMeSI, Iv64 } }, 939 { "movS", { RMeDI, Iv64 } }, 940 /* c0 */ 941 { GRP2b }, 942 { GRP2S }, 943 { "retT", { Iw } }, 944 { "retT", { XX } }, 945 { "les{S|}", { Gv, Mp } }, 946 { "ldsS", { Gv, Mp } }, 947 { GRP11_C6 }, 948 { GRP11_C7 }, 949 /* c8 */ 950 { "enterT", { Iw, Ib } }, 951 { "leaveT", { XX } }, 952 { "lretP", { Iw } }, 953 { "lretP", { XX } }, 954 { "int3", { XX } }, 955 { "int", { Ib } }, 956 { "into{|}", { XX } }, 957 { "iretP", { XX } }, 958 /* d0 */ 959 { GRP2b_one }, 960 { GRP2S_one }, 961 { GRP2b_cl }, 962 { GRP2S_cl }, 963 { "aam{|}", { sIb } }, 964 { "aad{|}", { sIb } }, 965 { "(bad)", { XX } }, 966 { "xlat", { DSBX } }, 967 /* d8 */ 968 { FLOAT }, 969 { FLOAT }, 970 { FLOAT }, 971 { FLOAT }, 972 { FLOAT }, 973 { FLOAT }, 974 { FLOAT }, 975 { FLOAT }, 976 /* e0 */ 977 { "loopneFH", { Jb, XX, loop_jcxz_flag } }, 978 { "loopeFH", { Jb, XX, loop_jcxz_flag } }, 979 { "loopFH", { Jb, XX, loop_jcxz_flag } }, 980 { "jEcxzH", { Jb, XX, loop_jcxz_flag } }, 981 { "inB", { AL, Ib } }, 982 { "inG", { zAX, Ib } }, 983 { "outB", { Ib, AL } }, 984 { "outG", { Ib, zAX } }, 985 /* e8 */ 986 { "callT", { Jv } }, 987 { "jmpT", { Jv } }, 988 { "Jjmp{T|}", { Ap } }, 989 { "jmp", { Jb } }, 990 { "inB", { AL, indirDX } }, 991 { "inG", { zAX, indirDX } }, 992 { "outB", { indirDX, AL } }, 993 { "outG", { indirDX, zAX } }, 994 /* f0 */ 995 { "(bad)", { XX } }, /* lock prefix */ 996 { "icebp", { XX } }, 997 { "(bad)", { XX } }, /* repne */ 998 { "(bad)", { XX } }, /* repz */ 999 { "hlt", { XX } }, 1000 { "cmc", { XX } }, 1001 { GRP3b }, 1002 { GRP3S }, 1003 /* f8 */ 1004 { "clc", { XX } }, 1005 { "stc", { XX } }, 1006 { "cli", { XX } }, 1007 { "sti", { XX } }, 1008 { "cld", { XX } }, 1009 { "std", { XX } }, 1010 { GRP4 }, 1011 { GRP5 }, 1012 }; 1013 1014 static const struct dis386 dis386_twobyte[] = { 1015 /* 00 */ 1016 { GRP6 }, 1017 { GRP7 }, 1018 { "larS", { Gv, Ew } }, 1019 { "lslS", { Gv, Ew } }, 1020 { "(bad)", { XX } }, 1021 { "syscall", { XX } }, 1022 { "clts", { XX } }, 1023 { "sysretP", { XX } }, 1024 /* 08 */ 1025 { "invd", { XX } }, 1026 { "wbinvd", { XX } }, 1027 { "(bad)", { XX } }, 1028 { "ud2a", { XX } }, 1029 { "(bad)", { XX } }, 1030 { GRPAMD }, 1031 { "femms", { XX } }, 1032 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */ 1033 /* 10 */ 1034 { PREGRP8 }, 1035 { PREGRP9 }, 1036 { PREGRP30 }, 1037 { "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } }, 1038 { "unpcklpX", { XM, EXq } }, 1039 { "unpckhpX", { XM, EXq } }, 1040 { PREGRP31 }, 1041 { "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } }, 1042 /* 18 */ 1043 { GRP16 }, 1044 { "(bad)", { XX } }, 1045 { "(bad)", { XX } }, 1046 { "(bad)", { XX } }, 1047 { "(bad)", { XX } }, 1048 { "(bad)", { XX } }, 1049 { "(bad)", { XX } }, 1050 { "nopQ", { Ev } }, 1051 /* 20 */ 1052 { "movZ", { Rm, Cm } }, 1053 { "movZ", { Rm, Dm } }, 1054 { "movZ", { Cm, Rm } }, 1055 { "movZ", { Dm, Rm } }, 1056 { "movL", { Rd, Td } }, 1057 { "(bad)", { XX } }, 1058 { "movL", { Td, Rd } }, 1059 { "(bad)", { XX } }, 1060 /* 28 */ 1061 { "movapX", { XM, EXx } }, 1062 { "movapX", { EXx, XM } }, 1063 { PREGRP2 }, 1064 { PREGRP33 }, 1065 { PREGRP4 }, 1066 { PREGRP3 }, 1067 { PREGRP93 }, 1068 { PREGRP94 }, 1069 /* 30 */ 1070 { "wrmsr", { XX } }, 1071 { "rdtsc", { XX } }, 1072 { "rdmsr", { XX } }, 1073 { "rdpmc", { XX } }, 1074 { "sysenter", { XX } }, 1075 { "sysexit", { XX } }, 1076 { "(bad)", { XX } }, 1077 { "(bad)", { XX } }, 1078 /* 38 */ 1079 { THREE_BYTE_0 }, 1080 { "(bad)", { XX } }, 1081 { THREE_BYTE_1 }, 1082 { "(bad)", { XX } }, 1083 { "(bad)", { XX } }, 1084 { "(bad)", { XX } }, 1085 { "(bad)", { XX } }, 1086 { "(bad)", { XX } }, 1087 /* 40 */ 1088 { "cmovo", { Gv, Ev } }, 1089 { "cmovno", { Gv, Ev } }, 1090 { "cmovb", { Gv, Ev } }, 1091 { "cmovae", { Gv, Ev } }, 1092 { "cmove", { Gv, Ev } }, 1093 { "cmovne", { Gv, Ev } }, 1094 { "cmovbe", { Gv, Ev } }, 1095 { "cmova", { Gv, Ev } }, 1096 /* 48 */ 1097 { "cmovs", { Gv, Ev } }, 1098 { "cmovns", { Gv, Ev } }, 1099 { "cmovp", { Gv, Ev } }, 1100 { "cmovnp", { Gv, Ev } }, 1101 { "cmovl", { Gv, Ev } }, 1102 { "cmovge", { Gv, Ev } }, 1103 { "cmovle", { Gv, Ev } }, 1104 { "cmovg", { Gv, Ev } }, 1105 /* 50 */ 1106 { "movmskpX", { Gdq, XS } }, 1107 { PREGRP13 }, 1108 { PREGRP12 }, 1109 { PREGRP11 }, 1110 { "andpX", { XM, EXx } }, 1111 { "andnpX", { XM, EXx } }, 1112 { "orpX", { XM, EXx } }, 1113 { "xorpX", { XM, EXx } }, 1114 /* 58 */ 1115 { PREGRP0 }, 1116 { PREGRP10 }, 1117 { PREGRP17 }, 1118 { PREGRP16 }, 1119 { PREGRP14 }, 1120 { PREGRP7 }, 1121 { PREGRP5 }, 1122 { PREGRP6 }, 1123 /* 60 */ 1124 { PREGRP95 }, 1125 { PREGRP96 }, 1126 { PREGRP97 }, 1127 { "packsswb", { MX, EM } }, 1128 { "pcmpgtb", { MX, EM } }, 1129 { "pcmpgtw", { MX, EM } }, 1130 { "pcmpgtd", { MX, EM } }, 1131 { "packuswb", { MX, EM } }, 1132 /* 68 */ 1133 { "punpckhbw", { MX, EM } }, 1134 { "punpckhwd", { MX, EM } }, 1135 { "punpckhdq", { MX, EM } }, 1136 { "packssdw", { MX, EM } }, 1137 { PREGRP26 }, 1138 { PREGRP24 }, 1139 { "movd", { MX, Edq } }, 1140 { PREGRP19 }, 1141 /* 70 */ 1142 { PREGRP22 }, 1143 { GRP12 }, 1144 { GRP13 }, 1145 { GRP14 }, 1146 { "pcmpeqb", { MX, EM } }, 1147 { "pcmpeqw", { MX, EM } }, 1148 { "pcmpeqd", { MX, EM } }, 1149 { "emms", { XX } }, 1150 /* 78 */ 1151 { PREGRP34 }, 1152 { PREGRP35 }, 1153 { "(bad)", { XX } }, 1154 { "(bad)", { XX } }, 1155 { PREGRP28 }, 1156 { PREGRP29 }, 1157 { PREGRP23 }, 1158 { PREGRP20 }, 1159 /* 80 */ 1160 { "joH", { Jv, XX, cond_jump_flag } }, 1161 { "jnoH", { Jv, XX, cond_jump_flag } }, 1162 { "jbH", { Jv, XX, cond_jump_flag } }, 1163 { "jaeH", { Jv, XX, cond_jump_flag } }, 1164 { "jeH", { Jv, XX, cond_jump_flag } }, 1165 { "jneH", { Jv, XX, cond_jump_flag } }, 1166 { "jbeH", { Jv, XX, cond_jump_flag } }, 1167 { "jaH", { Jv, XX, cond_jump_flag } }, 1168 /* 88 */ 1169 { "jsH", { Jv, XX, cond_jump_flag } }, 1170 { "jnsH", { Jv, XX, cond_jump_flag } }, 1171 { "jpH", { Jv, XX, cond_jump_flag } }, 1172 { "jnpH", { Jv, XX, cond_jump_flag } }, 1173 { "jlH", { Jv, XX, cond_jump_flag } }, 1174 { "jgeH", { Jv, XX, cond_jump_flag } }, 1175 { "jleH", { Jv, XX, cond_jump_flag } }, 1176 { "jgH", { Jv, XX, cond_jump_flag } }, 1177 /* 90 */ 1178 { "seto", { Eb } }, 1179 { "setno", { Eb } }, 1180 { "setb", { Eb } }, 1181 { "setae", { Eb } }, 1182 { "sete", { Eb } }, 1183 { "setne", { Eb } }, 1184 { "setbe", { Eb } }, 1185 { "seta", { Eb } }, 1186 /* 98 */ 1187 { "sets", { Eb } }, 1188 { "setns", { Eb } }, 1189 { "setp", { Eb } }, 1190 { "setnp", { Eb } }, 1191 { "setl", { Eb } }, 1192 { "setge", { Eb } }, 1193 { "setle", { Eb } }, 1194 { "setg", { Eb } }, 1195 /* a0 */ 1196 { "pushT", { fs } }, 1197 { "popT", { fs } }, 1198 { "cpuid", { XX } }, 1199 { "btS", { Ev, Gv } }, 1200 { "shldS", { Ev, Gv, Ib } }, 1201 { "shldS", { Ev, Gv, CL } }, 1202 { GRPPADLCK2 }, 1203 { GRPPADLCK1 }, 1204 /* a8 */ 1205 { "pushT", { gs } }, 1206 { "popT", { gs } }, 1207 { "rsm", { XX } }, 1208 { "btsS", { Ev, Gv } }, 1209 { "shrdS", { Ev, Gv, Ib } }, 1210 { "shrdS", { Ev, Gv, CL } }, 1211 { GRP15 }, 1212 { "imulS", { Gv, Ev } }, 1213 /* b0 */ 1214 { "cmpxchgB", { Eb, Gb } }, 1215 { "cmpxchgS", { Ev, Gv } }, 1216 { "lssS", { Gv, Mp } }, 1217 { "btrS", { Ev, Gv } }, 1218 { "lfsS", { Gv, Mp } }, 1219 { "lgsS", { Gv, Mp } }, 1220 { "movz{bR|x|bR|x}", { Gv, Eb } }, 1221 { "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */ 1222 /* b8 */ 1223 { PREGRP37 }, 1224 { "ud2b", { XX } }, 1225 { GRP8 }, 1226 { "btcS", { Ev, Gv } }, 1227 { "bsfS", { Gv, Ev } }, 1228 { PREGRP36 }, 1229 { "movs{bR|x|bR|x}", { Gv, Eb } }, 1230 { "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */ 1231 /* c0 */ 1232 { "xaddB", { Eb, Gb } }, 1233 { "xaddS", { Ev, Gv } }, 1234 { PREGRP1 }, 1235 { "movntiS", { Ev, Gv } }, 1236 { "pinsrw", { MX, Edqw, Ib } }, 1237 { "pextrw", { Gdq, MS, Ib } }, 1238 { "shufpX", { XM, EXx, Ib } }, 1239 { GRP9 }, 1240 /* c8 */ 1241 { "bswap", { RMeAX } }, 1242 { "bswap", { RMeCX } }, 1243 { "bswap", { RMeDX } }, 1244 { "bswap", { RMeBX } }, 1245 { "bswap", { RMeSP } }, 1246 { "bswap", { RMeBP } }, 1247 { "bswap", { RMeSI } }, 1248 { "bswap", { RMeDI } }, 1249 /* d0 */ 1250 { PREGRP27 }, 1251 { "psrlw", { MX, EM } }, 1252 { "psrld", { MX, EM } }, 1253 { "psrlq", { MX, EM } }, 1254 { "paddq", { MX, EM } }, 1255 { "pmullw", { MX, EM } }, 1256 { PREGRP21 }, 1257 { "pmovmskb", { Gdq, MS } }, 1258 /* d8 */ 1259 { "psubusb", { MX, EM } }, 1260 { "psubusw", { MX, EM } }, 1261 { "pminub", { MX, EM } }, 1262 { "pand", { MX, EM } }, 1263 { "paddusb", { MX, EM } }, 1264 { "paddusw", { MX, EM } }, 1265 { "pmaxub", { MX, EM } }, 1266 { "pandn", { MX, EM } }, 1267 /* e0 */ 1268 { "pavgb", { MX, EM } }, 1269 { "psraw", { MX, EM } }, 1270 { "psrad", { MX, EM } }, 1271 { "pavgw", { MX, EM } }, 1272 { "pmulhuw", { MX, EM } }, 1273 { "pmulhw", { MX, EM } }, 1274 { PREGRP15 }, 1275 { PREGRP25 }, 1276 /* e8 */ 1277 { "psubsb", { MX, EM } }, 1278 { "psubsw", { MX, EM } }, 1279 { "pminsw", { MX, EM } }, 1280 { "por", { MX, EM } }, 1281 { "paddsb", { MX, EM } }, 1282 { "paddsw", { MX, EM } }, 1283 { "pmaxsw", { MX, EM } }, 1284 { "pxor", { MX, EM } }, 1285 /* f0 */ 1286 { PREGRP32 }, 1287 { "psllw", { MX, EM } }, 1288 { "pslld", { MX, EM } }, 1289 { "psllq", { MX, EM } }, 1290 { "pmuludq", { MX, EM } }, 1291 { "pmaddwd", { MX, EM } }, 1292 { "psadbw", { MX, EM } }, 1293 { PREGRP18 }, 1294 /* f8 */ 1295 { "psubb", { MX, EM } }, 1296 { "psubw", { MX, EM } }, 1297 { "psubd", { MX, EM } }, 1298 { "psubq", { MX, EM } }, 1299 { "paddb", { MX, EM } }, 1300 { "paddw", { MX, EM } }, 1301 { "paddd", { MX, EM } }, 1302 { "(bad)", { XX } }, 1303 }; 1304 1305 static const unsigned char onebyte_has_modrm[256] = { 1306 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1307 /* ------------------------------- */ 1308 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ 1309 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ 1310 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ 1311 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ 1312 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ 1313 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ 1314 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ 1315 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ 1316 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ 1317 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ 1318 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ 1319 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ 1320 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ 1321 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ 1322 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ 1323 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ 1324 /* ------------------------------- */ 1325 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1326 }; 1327 1328 static const unsigned char twobyte_has_modrm[256] = { 1329 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1330 /* ------------------------------- */ 1331 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ 1332 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */ 1333 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ 1334 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ 1335 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ 1336 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ 1337 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ 1338 /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */ 1339 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1340 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ 1341 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */ 1342 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */ 1343 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ 1344 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ 1345 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ 1346 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ 1347 /* ------------------------------- */ 1348 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1349 }; 1350 1351 static const unsigned char twobyte_uses_DATA_prefix[256] = { 1352 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1353 /* ------------------------------- */ 1354 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1355 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ 1356 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1357 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ 1358 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1359 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 1360 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ 1361 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */ 1362 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1363 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1364 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1365 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1366 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1367 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1368 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1369 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ 1370 /* ------------------------------- */ 1371 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1372 }; 1373 1374 static const unsigned char twobyte_uses_REPNZ_prefix[256] = { 1375 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1376 /* ------------------------------- */ 1377 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1378 /* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1379 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1380 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1381 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1382 /* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */ 1383 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1384 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */ 1385 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1386 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1387 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1388 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1389 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1390 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1391 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1392 /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1393 /* ------------------------------- */ 1394 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1395 }; 1396 1397 static const unsigned char twobyte_uses_REPZ_prefix[256] = { 1398 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1399 /* ------------------------------- */ 1400 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1401 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ 1402 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1403 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1404 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1405 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 1406 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */ 1407 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */ 1408 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1409 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1410 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1411 /* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */ 1412 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1413 /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1414 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1415 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1416 /* ------------------------------- */ 1417 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1418 }; 1419 1420 /* This is used to determine if opcode 0f 38 XX uses DATA prefix. */ 1421 static const unsigned char threebyte_0x38_uses_DATA_prefix[256] = { 1422 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1423 /* ------------------------------- */ 1424 /* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */ 1425 /* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */ 1426 /* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */ 1427 /* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */ 1428 /* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1429 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1430 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1431 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1432 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1433 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1434 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1435 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1436 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1437 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1438 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1439 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1440 /* ------------------------------- */ 1441 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1442 }; 1443 1444 /* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */ 1445 static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = { 1446 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1447 /* ------------------------------- */ 1448 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1449 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1450 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1451 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1452 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1453 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1454 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1455 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1456 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1457 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1458 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1459 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1460 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1461 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1462 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1463 /* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1464 /* ------------------------------- */ 1465 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1466 }; 1467 1468 /* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */ 1469 static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = { 1470 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1471 /* ------------------------------- */ 1472 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1473 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1474 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1475 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1476 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1477 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1478 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1479 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1480 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1481 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1482 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1483 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1484 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1485 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1486 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1487 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1488 /* ------------------------------- */ 1489 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1490 }; 1491 1492 /* This is used to determine if opcode 0f 3a XX uses DATA prefix. */ 1493 static const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = { 1494 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1495 /* ------------------------------- */ 1496 /* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */ 1497 /* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */ 1498 /* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1499 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1500 /* 40 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1501 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1502 /* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1503 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1504 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1505 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1506 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1507 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1508 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1509 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1510 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1511 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1512 /* ------------------------------- */ 1513 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1514 }; 1515 1516 /* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */ 1517 static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = { 1518 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1519 /* ------------------------------- */ 1520 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1521 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1522 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1523 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1524 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1525 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1526 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1527 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1528 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1529 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1530 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1531 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1532 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1533 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1534 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1535 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1536 /* ------------------------------- */ 1537 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1538 }; 1539 1540 /* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */ 1541 static const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = { 1542 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1543 /* ------------------------------- */ 1544 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1545 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1546 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1547 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1548 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1549 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1550 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1551 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1552 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1553 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1554 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1555 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1556 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1557 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1558 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1559 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1560 /* ------------------------------- */ 1561 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1562 }; 1563 1564 static char obuf[100]; 1565 static char *obufp; 1566 static char scratchbuf[100]; 1567 static unsigned char *start_codep; 1568 static unsigned char *insn_codep; 1569 static unsigned char *codep; 1570 static disassemble_info *the_info; 1571 static struct 1572 { 1573 int mod; 1574 int reg; 1575 int rm; 1576 } 1577 modrm; 1578 static unsigned char need_modrm; 1579 1580 /* If we are accessing mod/rm/reg without need_modrm set, then the 1581 values are stale. Hitting this abort likely indicates that you 1582 need to update onebyte_has_modrm or twobyte_has_modrm. */ 1583 #define MODRM_CHECK if (!need_modrm) abort () 1584 1585 static const char * const *names64; 1586 static const char * const *names32; 1587 static const char * const *names16; 1588 static const char * const *names8; 1589 static const char * const *names8rex; 1590 static const char * const *names_seg; 1591 static const char * const *index16; 1592 1593 static const char * const intel_names64[] = { 1594 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", 1595 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 1596 }; 1597 static const char * const intel_names32[] = { 1598 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", 1599 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" 1600 }; 1601 static const char * const intel_names16[] = { 1602 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", 1603 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" 1604 }; 1605 static const char * const intel_names8[] = { 1606 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", 1607 }; 1608 static const char * const intel_names8rex[] = { 1609 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", 1610 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" 1611 }; 1612 static const char * const intel_names_seg[] = { 1613 "es", "cs", "ss", "ds", "fs", "gs", "?", "?", 1614 }; 1615 static const char * const intel_index16[] = { 1616 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" 1617 }; 1618 1619 static const char * const att_names64[] = { 1620 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", 1621 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 1622 }; 1623 static const char * const att_names32[] = { 1624 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", 1625 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" 1626 }; 1627 static const char * const att_names16[] = { 1628 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", 1629 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" 1630 }; 1631 static const char * const att_names8[] = { 1632 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", 1633 }; 1634 static const char * const att_names8rex[] = { 1635 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", 1636 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" 1637 }; 1638 static const char * const att_names_seg[] = { 1639 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", 1640 }; 1641 static const char * const att_index16[] = { 1642 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" 1643 }; 1644 1645 static const struct dis386 grps[][8] = { 1646 /* GRP1a */ 1647 { 1648 { "popU", { stackEv } }, 1649 { "(bad)", { XX } }, 1650 { "(bad)", { XX } }, 1651 { "(bad)", { XX } }, 1652 { "(bad)", { XX } }, 1653 { "(bad)", { XX } }, 1654 { "(bad)", { XX } }, 1655 { "(bad)", { XX } }, 1656 }, 1657 /* GRP1b */ 1658 { 1659 { "addA", { Eb, Ib } }, 1660 { "orA", { Eb, Ib } }, 1661 { "adcA", { Eb, Ib } }, 1662 { "sbbA", { Eb, Ib } }, 1663 { "andA", { Eb, Ib } }, 1664 { "subA", { Eb, Ib } }, 1665 { "xorA", { Eb, Ib } }, 1666 { "cmpA", { Eb, Ib } }, 1667 }, 1668 /* GRP1S */ 1669 { 1670 { "addQ", { Ev, Iv } }, 1671 { "orQ", { Ev, Iv } }, 1672 { "adcQ", { Ev, Iv } }, 1673 { "sbbQ", { Ev, Iv } }, 1674 { "andQ", { Ev, Iv } }, 1675 { "subQ", { Ev, Iv } }, 1676 { "xorQ", { Ev, Iv } }, 1677 { "cmpQ", { Ev, Iv } }, 1678 }, 1679 /* GRP1Ss */ 1680 { 1681 { "addQ", { Ev, sIb } }, 1682 { "orQ", { Ev, sIb } }, 1683 { "adcQ", { Ev, sIb } }, 1684 { "sbbQ", { Ev, sIb } }, 1685 { "andQ", { Ev, sIb } }, 1686 { "subQ", { Ev, sIb } }, 1687 { "xorQ", { Ev, sIb } }, 1688 { "cmpQ", { Ev, sIb } }, 1689 }, 1690 /* GRP2b */ 1691 { 1692 { "rolA", { Eb, Ib } }, 1693 { "rorA", { Eb, Ib } }, 1694 { "rclA", { Eb, Ib } }, 1695 { "rcrA", { Eb, Ib } }, 1696 { "shlA", { Eb, Ib } }, 1697 { "shrA", { Eb, Ib } }, 1698 { "(bad)", { XX } }, 1699 { "sarA", { Eb, Ib } }, 1700 }, 1701 /* GRP2S */ 1702 { 1703 { "rolQ", { Ev, Ib } }, 1704 { "rorQ", { Ev, Ib } }, 1705 { "rclQ", { Ev, Ib } }, 1706 { "rcrQ", { Ev, Ib } }, 1707 { "shlQ", { Ev, Ib } }, 1708 { "shrQ", { Ev, Ib } }, 1709 { "(bad)", { XX } }, 1710 { "sarQ", { Ev, Ib } }, 1711 }, 1712 /* GRP2b_one */ 1713 { 1714 { "rolA", { Eb, I1 } }, 1715 { "rorA", { Eb, I1 } }, 1716 { "rclA", { Eb, I1 } }, 1717 { "rcrA", { Eb, I1 } }, 1718 { "shlA", { Eb, I1 } }, 1719 { "shrA", { Eb, I1 } }, 1720 { "(bad)", { XX } }, 1721 { "sarA", { Eb, I1 } }, 1722 }, 1723 /* GRP2S_one */ 1724 { 1725 { "rolQ", { Ev, I1 } }, 1726 { "rorQ", { Ev, I1 } }, 1727 { "rclQ", { Ev, I1 } }, 1728 { "rcrQ", { Ev, I1 } }, 1729 { "shlQ", { Ev, I1 } }, 1730 { "shrQ", { Ev, I1 } }, 1731 { "(bad)", { XX } }, 1732 { "sarQ", { Ev, I1 } }, 1733 }, 1734 /* GRP2b_cl */ 1735 { 1736 { "rolA", { Eb, CL } }, 1737 { "rorA", { Eb, CL } }, 1738 { "rclA", { Eb, CL } }, 1739 { "rcrA", { Eb, CL } }, 1740 { "shlA", { Eb, CL } }, 1741 { "shrA", { Eb, CL } }, 1742 { "(bad)", { XX } }, 1743 { "sarA", { Eb, CL } }, 1744 }, 1745 /* GRP2S_cl */ 1746 { 1747 { "rolQ", { Ev, CL } }, 1748 { "rorQ", { Ev, CL } }, 1749 { "rclQ", { Ev, CL } }, 1750 { "rcrQ", { Ev, CL } }, 1751 { "shlQ", { Ev, CL } }, 1752 { "shrQ", { Ev, CL } }, 1753 { "(bad)", { XX } }, 1754 { "sarQ", { Ev, CL } }, 1755 }, 1756 /* GRP3b */ 1757 { 1758 { "testA", { Eb, Ib } }, 1759 { "(bad)", { Eb } }, 1760 { "notA", { Eb } }, 1761 { "negA", { Eb } }, 1762 { "mulA", { Eb } }, /* Don't print the implicit %al register, */ 1763 { "imulA", { Eb } }, /* to distinguish these opcodes from other */ 1764 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */ 1765 { "idivA", { Eb } }, /* and idiv for consistency. */ 1766 }, 1767 /* GRP3S */ 1768 { 1769 { "testQ", { Ev, Iv } }, 1770 { "(bad)", { XX } }, 1771 { "notQ", { Ev } }, 1772 { "negQ", { Ev } }, 1773 { "mulQ", { Ev } }, /* Don't print the implicit register. */ 1774 { "imulQ", { Ev } }, 1775 { "divQ", { Ev } }, 1776 { "idivQ", { Ev } }, 1777 }, 1778 /* GRP4 */ 1779 { 1780 { "incA", { Eb } }, 1781 { "decA", { Eb } }, 1782 { "(bad)", { XX } }, 1783 { "(bad)", { XX } }, 1784 { "(bad)", { XX } }, 1785 { "(bad)", { XX } }, 1786 { "(bad)", { XX } }, 1787 { "(bad)", { XX } }, 1788 }, 1789 /* GRP5 */ 1790 { 1791 { "incQ", { Ev } }, 1792 { "decQ", { Ev } }, 1793 { "callT", { indirEv } }, 1794 { "JcallT", { indirEp } }, 1795 { "jmpT", { indirEv } }, 1796 { "JjmpT", { indirEp } }, 1797 { "pushU", { stackEv } }, 1798 { "(bad)", { XX } }, 1799 }, 1800 /* GRP6 */ 1801 { 1802 { "sldtD", { Sv } }, 1803 { "strD", { Sv } }, 1804 { "lldt", { Ew } }, 1805 { "ltr", { Ew } }, 1806 { "verr", { Ew } }, 1807 { "verw", { Ew } }, 1808 { "(bad)", { XX } }, 1809 { "(bad)", { XX } }, 1810 }, 1811 /* GRP7 */ 1812 { 1813 { "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } }, 1814 { "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } }, 1815 { "lgdt{Q|Q||}", { M } }, 1816 { "lidt{Q|Q||}", { { SVME_Fixup, 0 } } }, 1817 { "smswD", { Sv } }, 1818 { "(bad)", { XX } }, 1819 { "lmsw", { Ew } }, 1820 { "invlpg", { { INVLPG_Fixup, w_mode } } }, 1821 }, 1822 /* GRP8 */ 1823 { 1824 { "(bad)", { XX } }, 1825 { "(bad)", { XX } }, 1826 { "(bad)", { XX } }, 1827 { "(bad)", { XX } }, 1828 { "btQ", { Ev, Ib } }, 1829 { "btsQ", { Ev, Ib } }, 1830 { "btrQ", { Ev, Ib } }, 1831 { "btcQ", { Ev, Ib } }, 1832 }, 1833 /* GRP9 */ 1834 { 1835 { "(bad)", { XX } }, 1836 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } }, 1837 { "(bad)", { XX } }, 1838 { "(bad)", { XX } }, 1839 { "(bad)", { XX } }, 1840 { "(bad)", { XX } }, 1841 { "", { VM } }, /* See OP_VMX. */ 1842 { "vmptrst", { Mq } }, 1843 }, 1844 /* GRP11_C6 */ 1845 { 1846 { "movA", { Eb, Ib } }, 1847 { "(bad)", { XX } }, 1848 { "(bad)", { XX } }, 1849 { "(bad)", { XX } }, 1850 { "(bad)", { XX } }, 1851 { "(bad)", { XX } }, 1852 { "(bad)", { XX } }, 1853 { "(bad)", { XX } }, 1854 }, 1855 /* GRP11_C7 */ 1856 { 1857 { "movQ", { Ev, Iv } }, 1858 { "(bad)", { XX } }, 1859 { "(bad)", { XX } }, 1860 { "(bad)", { XX } }, 1861 { "(bad)", { XX } }, 1862 { "(bad)", { XX } }, 1863 { "(bad)", { XX } }, 1864 { "(bad)", { XX } }, 1865 }, 1866 /* GRP12 */ 1867 { 1868 { "(bad)", { XX } }, 1869 { "(bad)", { XX } }, 1870 { "psrlw", { MS, Ib } }, 1871 { "(bad)", { XX } }, 1872 { "psraw", { MS, Ib } }, 1873 { "(bad)", { XX } }, 1874 { "psllw", { MS, Ib } }, 1875 { "(bad)", { XX } }, 1876 }, 1877 /* GRP13 */ 1878 { 1879 { "(bad)", { XX } }, 1880 { "(bad)", { XX } }, 1881 { "psrld", { MS, Ib } }, 1882 { "(bad)", { XX } }, 1883 { "psrad", { MS, Ib } }, 1884 { "(bad)", { XX } }, 1885 { "pslld", { MS, Ib } }, 1886 { "(bad)", { XX } }, 1887 }, 1888 /* GRP14 */ 1889 { 1890 { "(bad)", { XX } }, 1891 { "(bad)", { XX } }, 1892 { "psrlq", { MS, Ib } }, 1893 { "psrldq", { MS, Ib } }, 1894 { "(bad)", { XX } }, 1895 { "(bad)", { XX } }, 1896 { "psllq", { MS, Ib } }, 1897 { "pslldq", { MS, Ib } }, 1898 }, 1899 /* GRP15 */ 1900 { 1901 { "fxsave", { Ev } }, 1902 { "fxrstor", { Ev } }, 1903 { "ldmxcsr", { Ev } }, 1904 { "stmxcsr", { Ev } }, 1905 { "(bad)", { XX } }, 1906 { "lfence", { { OP_0fae, 0 } } }, 1907 { "mfence", { { OP_0fae, 0 } } }, 1908 { "clflush", { { OP_0fae, 0 } } }, 1909 }, 1910 /* GRP16 */ 1911 { 1912 { "prefetchnta", { Ev } }, 1913 { "prefetcht0", { Ev } }, 1914 { "prefetcht1", { Ev } }, 1915 { "prefetcht2", { Ev } }, 1916 { "(bad)", { XX } }, 1917 { "(bad)", { XX } }, 1918 { "(bad)", { XX } }, 1919 { "(bad)", { XX } }, 1920 }, 1921 /* GRPAMD */ 1922 { 1923 { "prefetch", { Eb } }, 1924 { "prefetchw", { Eb } }, 1925 { "(bad)", { XX } }, 1926 { "(bad)", { XX } }, 1927 { "(bad)", { XX } }, 1928 { "(bad)", { XX } }, 1929 { "(bad)", { XX } }, 1930 { "(bad)", { XX } }, 1931 }, 1932 /* GRPPADLCK1 */ 1933 { 1934 { "xstore-rng", { { OP_0f07, 0 } } }, 1935 { "xcrypt-ecb", { { OP_0f07, 0 } } }, 1936 { "xcrypt-cbc", { { OP_0f07, 0 } } }, 1937 { "xcrypt-ctr", { { OP_0f07, 0 } } }, 1938 { "xcrypt-cfb", { { OP_0f07, 0 } } }, 1939 { "xcrypt-ofb", { { OP_0f07, 0 } } }, 1940 { "(bad)", { { OP_0f07, 0 } } }, 1941 { "(bad)", { { OP_0f07, 0 } } }, 1942 }, 1943 /* GRPPADLCK2 */ 1944 { 1945 { "montmul", { { OP_0f07, 0 } } }, 1946 { "xsha1", { { OP_0f07, 0 } } }, 1947 { "xsha256", { { OP_0f07, 0 } } }, 1948 { "(bad)", { { OP_0f07, 0 } } }, 1949 { "(bad)", { { OP_0f07, 0 } } }, 1950 { "(bad)", { { OP_0f07, 0 } } }, 1951 { "(bad)", { { OP_0f07, 0 } } }, 1952 { "(bad)", { { OP_0f07, 0 } } }, 1953 } 1954 }; 1955 1956 static const struct dis386 prefix_user_table[][4] = { 1957 /* PREGRP0 */ 1958 { 1959 { "addps", { XM, EXx } }, 1960 { "addss", { XM, EXd } }, 1961 { "addpd", { XM, EXx } }, 1962 { "addsd", { XM, EXq } }, 1963 }, 1964 /* PREGRP1 */ 1965 { 1966 { "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */ 1967 { "", { XM, EXx, OPSIMD } }, 1968 { "", { XM, EXx, OPSIMD } }, 1969 { "", { XM, EXx, OPSIMD } }, 1970 }, 1971 /* PREGRP2 */ 1972 { 1973 { "cvtpi2ps", { XM, EMC } }, 1974 { "cvtsi2ssY", { XM, Ev } }, 1975 { "cvtpi2pd", { XM, EMC } }, 1976 { "cvtsi2sdY", { XM, Ev } }, 1977 }, 1978 /* PREGRP3 */ 1979 { 1980 { "cvtps2pi", { MXC, EXx } }, 1981 { "cvtss2siY", { Gv, EXx } }, 1982 { "cvtpd2pi", { MXC, EXx } }, 1983 { "cvtsd2siY", { Gv, EXx } }, 1984 }, 1985 /* PREGRP4 */ 1986 { 1987 { "cvttps2pi", { MXC, EXx } }, 1988 { "cvttss2siY", { Gv, EXx } }, 1989 { "cvttpd2pi", { MXC, EXx } }, 1990 { "cvttsd2siY", { Gv, EXx } }, 1991 }, 1992 /* PREGRP5 */ 1993 { 1994 { "divps", { XM, EXx } }, 1995 { "divss", { XM, EXx } }, 1996 { "divpd", { XM, EXx } }, 1997 { "divsd", { XM, EXx } }, 1998 }, 1999 /* PREGRP6 */ 2000 { 2001 { "maxps", { XM, EXx } }, 2002 { "maxss", { XM, EXx } }, 2003 { "maxpd", { XM, EXx } }, 2004 { "maxsd", { XM, EXx } }, 2005 }, 2006 /* PREGRP7 */ 2007 { 2008 { "minps", { XM, EXx } }, 2009 { "minss", { XM, EXx } }, 2010 { "minpd", { XM, EXx } }, 2011 { "minsd", { XM, EXx } }, 2012 }, 2013 /* PREGRP8 */ 2014 { 2015 { "movups", { XM, EXx } }, 2016 { "movss", { XM, EXx } }, 2017 { "movupd", { XM, EXx } }, 2018 { "movsd", { XM, EXx } }, 2019 }, 2020 /* PREGRP9 */ 2021 { 2022 { "movups", { EXx, XM } }, 2023 { "movss", { EXx, XM } }, 2024 { "movupd", { EXx, XM } }, 2025 { "movsd", { EXx, XM } }, 2026 }, 2027 /* PREGRP10 */ 2028 { 2029 { "mulps", { XM, EXx } }, 2030 { "mulss", { XM, EXx } }, 2031 { "mulpd", { XM, EXx } }, 2032 { "mulsd", { XM, EXx } }, 2033 }, 2034 /* PREGRP11 */ 2035 { 2036 { "rcpps", { XM, EXx } }, 2037 { "rcpss", { XM, EXx } }, 2038 { "(bad)", { XM, EXx } }, 2039 { "(bad)", { XM, EXx } }, 2040 }, 2041 /* PREGRP12 */ 2042 { 2043 { "rsqrtps",{ XM, EXx } }, 2044 { "rsqrtss",{ XM, EXx } }, 2045 { "(bad)", { XM, EXx } }, 2046 { "(bad)", { XM, EXx } }, 2047 }, 2048 /* PREGRP13 */ 2049 { 2050 { "sqrtps", { XM, EXx } }, 2051 { "sqrtss", { XM, EXx } }, 2052 { "sqrtpd", { XM, EXx } }, 2053 { "sqrtsd", { XM, EXx } }, 2054 }, 2055 /* PREGRP14 */ 2056 { 2057 { "subps", { XM, EXx } }, 2058 { "subss", { XM, EXx } }, 2059 { "subpd", { XM, EXx } }, 2060 { "subsd", { XM, EXx } }, 2061 }, 2062 /* PREGRP15 */ 2063 { 2064 { "(bad)", { XM, EXx } }, 2065 { "cvtdq2pd", { XM, EXq } }, 2066 { "cvttpd2dq", { XM, EXx } }, 2067 { "cvtpd2dq", { XM, EXx } }, 2068 }, 2069 /* PREGRP16 */ 2070 { 2071 { "cvtdq2ps", { XM, EXx } }, 2072 { "cvttps2dq", { XM, EXx } }, 2073 { "cvtps2dq", { XM, EXx } }, 2074 { "(bad)", { XM, EXx } }, 2075 }, 2076 /* PREGRP17 */ 2077 { 2078 { "cvtps2pd", { XM, EXq } }, 2079 { "cvtss2sd", { XM, EXx } }, 2080 { "cvtpd2ps", { XM, EXx } }, 2081 { "cvtsd2ss", { XM, EXx } }, 2082 }, 2083 /* PREGRP18 */ 2084 { 2085 { "maskmovq", { MX, MS } }, 2086 { "(bad)", { XM, EXx } }, 2087 { "maskmovdqu", { XM, XS } }, 2088 { "(bad)", { XM, EXx } }, 2089 }, 2090 /* PREGRP19 */ 2091 { 2092 { "movq", { MX, EM } }, 2093 { "movdqu", { XM, EXx } }, 2094 { "movdqa", { XM, EXx } }, 2095 { "(bad)", { XM, EXx } }, 2096 }, 2097 /* PREGRP20 */ 2098 { 2099 { "movq", { EM, MX } }, 2100 { "movdqu", { EXx, XM } }, 2101 { "movdqa", { EXx, XM } }, 2102 { "(bad)", { EXx, XM } }, 2103 }, 2104 /* PREGRP21 */ 2105 { 2106 { "(bad)", { EXx, XM } }, 2107 { "movq2dq",{ XM, MS } }, 2108 { "movq", { EXx, XM } }, 2109 { "movdq2q",{ MX, XS } }, 2110 }, 2111 /* PREGRP22 */ 2112 { 2113 { "pshufw", { MX, EM, Ib } }, 2114 { "pshufhw",{ XM, EXx, Ib } }, 2115 { "pshufd", { XM, EXx, Ib } }, 2116 { "pshuflw",{ XM, EXx, Ib } }, 2117 }, 2118 /* PREGRP23 */ 2119 { 2120 { "movd", { Edq, MX } }, 2121 { "movq", { XM, EXx } }, 2122 { "movd", { Edq, XM } }, 2123 { "(bad)", { Ed, XM } }, 2124 }, 2125 /* PREGRP24 */ 2126 { 2127 { "(bad)", { MX, EXx } }, 2128 { "(bad)", { XM, EXx } }, 2129 { "punpckhqdq", { XM, EXx } }, 2130 { "(bad)", { XM, EXx } }, 2131 }, 2132 /* PREGRP25 */ 2133 { 2134 { "movntq", { EM, MX } }, 2135 { "(bad)", { EM, XM } }, 2136 { "movntdq",{ EM, XM } }, 2137 { "(bad)", { EM, XM } }, 2138 }, 2139 /* PREGRP26 */ 2140 { 2141 { "(bad)", { MX, EXx } }, 2142 { "(bad)", { XM, EXx } }, 2143 { "punpcklqdq", { XM, EXx } }, 2144 { "(bad)", { XM, EXx } }, 2145 }, 2146 /* PREGRP27 */ 2147 { 2148 { "(bad)", { MX, EXx } }, 2149 { "(bad)", { XM, EXx } }, 2150 { "addsubpd", { XM, EXx } }, 2151 { "addsubps", { XM, EXx } }, 2152 }, 2153 /* PREGRP28 */ 2154 { 2155 { "(bad)", { MX, EXx } }, 2156 { "(bad)", { XM, EXx } }, 2157 { "haddpd", { XM, EXx } }, 2158 { "haddps", { XM, EXx } }, 2159 }, 2160 /* PREGRP29 */ 2161 { 2162 { "(bad)", { MX, EXx } }, 2163 { "(bad)", { XM, EXx } }, 2164 { "hsubpd", { XM, EXx } }, 2165 { "hsubps", { XM, EXx } }, 2166 }, 2167 /* PREGRP30 */ 2168 { 2169 { "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */ 2170 { "movsldup", { XM, EXx } }, 2171 { "movlpd", { XM, EXq } }, 2172 { "movddup", { XM, EXq } }, 2173 }, 2174 /* PREGRP31 */ 2175 { 2176 { "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } }, 2177 { "movshdup", { XM, EXx } }, 2178 { "movhpd", { XM, EXq } }, 2179 { "(bad)", { XM, EXq } }, 2180 }, 2181 /* PREGRP32 */ 2182 { 2183 { "(bad)", { XM, EXx } }, 2184 { "(bad)", { XM, EXx } }, 2185 { "(bad)", { XM, EXx } }, 2186 { "lddqu", { XM, M } }, 2187 }, 2188 /* PREGRP33 */ 2189 { 2190 {"movntps", { Ev, XM } }, 2191 {"movntss", { Ev, XM } }, 2192 {"movntpd", { Ev, XM } }, 2193 {"movntsd", { Ev, XM } }, 2194 }, 2195 2196 /* PREGRP34 */ 2197 { 2198 {"vmread", { Em, Gm } }, 2199 {"(bad)", { XX } }, 2200 {"extrq", { XS, Ib, Ib } }, 2201 {"insertq", { XM, XS, Ib, Ib } }, 2202 }, 2203 2204 /* PREGRP35 */ 2205 { 2206 {"vmwrite", { Gm, Em } }, 2207 {"(bad)", { XX } }, 2208 {"extrq", { XM, XS } }, 2209 {"insertq", { XM, XS } }, 2210 }, 2211 2212 /* PREGRP36 */ 2213 { 2214 { "bsrS", { Gv, Ev } }, 2215 { "lzcntS", { Gv, Ev } }, 2216 { "bsrS", { Gv, Ev } }, 2217 { "(bad)", { XX } }, 2218 }, 2219 2220 /* PREGRP37 */ 2221 { 2222 { "(bad)", { XX } }, 2223 { "popcntS", { Gv, Ev } }, 2224 { "(bad)", { XX } }, 2225 { "(bad)", { XX } }, 2226 }, 2227 2228 /* PREGRP38 */ 2229 { 2230 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } }, 2231 { "pause", { XX } }, 2232 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } }, 2233 { "(bad)", { XX } }, 2234 }, 2235 2236 /* PREGRP39 */ 2237 { 2238 { "(bad)", { XX } }, 2239 { "(bad)", { XX } }, 2240 { "pblendvb", {XM, EXx, XMM0 } }, 2241 { "(bad)", { XX } }, 2242 }, 2243 2244 /* PREGRP40 */ 2245 { 2246 { "(bad)", { XX } }, 2247 { "(bad)", { XX } }, 2248 { "blendvps", {XM, EXx, XMM0 } }, 2249 { "(bad)", { XX } }, 2250 }, 2251 2252 /* PREGRP41 */ 2253 { 2254 { "(bad)", { XX } }, 2255 { "(bad)", { XX } }, 2256 { "blendvpd", { XM, EXx, XMM0 } }, 2257 { "(bad)", { XX } }, 2258 }, 2259 2260 /* PREGRP42 */ 2261 { 2262 { "(bad)", { XX } }, 2263 { "(bad)", { XX } }, 2264 { "ptest", { XM, EXx } }, 2265 { "(bad)", { XX } }, 2266 }, 2267 2268 /* PREGRP43 */ 2269 { 2270 { "(bad)", { XX } }, 2271 { "(bad)", { XX } }, 2272 { "pmovsxbw", { XM, EXx } }, 2273 { "(bad)", { XX } }, 2274 }, 2275 2276 /* PREGRP44 */ 2277 { 2278 { "(bad)", { XX } }, 2279 { "(bad)", { XX } }, 2280 { "pmovsxbd", { XM, EXx } }, 2281 { "(bad)", { XX } }, 2282 }, 2283 2284 /* PREGRP45 */ 2285 { 2286 { "(bad)", { XX } }, 2287 { "(bad)", { XX } }, 2288 { "pmovsxbq", { XM, EXx } }, 2289 { "(bad)", { XX } }, 2290 }, 2291 2292 /* PREGRP46 */ 2293 { 2294 { "(bad)", { XX } }, 2295 { "(bad)", { XX } }, 2296 { "pmovsxwd", { XM, EXx } }, 2297 { "(bad)", { XX } }, 2298 }, 2299 2300 /* PREGRP47 */ 2301 { 2302 { "(bad)", { XX } }, 2303 { "(bad)", { XX } }, 2304 { "pmovsxwq", { XM, EXx } }, 2305 { "(bad)", { XX } }, 2306 }, 2307 2308 /* PREGRP48 */ 2309 { 2310 { "(bad)", { XX } }, 2311 { "(bad)", { XX } }, 2312 { "pmovsxdq", { XM, EXx } }, 2313 { "(bad)", { XX } }, 2314 }, 2315 2316 /* PREGRP49 */ 2317 { 2318 { "(bad)", { XX } }, 2319 { "(bad)", { XX } }, 2320 { "pmuldq", { XM, EXx } }, 2321 { "(bad)", { XX } }, 2322 }, 2323 2324 /* PREGRP50 */ 2325 { 2326 { "(bad)", { XX } }, 2327 { "(bad)", { XX } }, 2328 { "pcmpeqq", { XM, EXx } }, 2329 { "(bad)", { XX } }, 2330 }, 2331 2332 /* PREGRP51 */ 2333 { 2334 { "(bad)", { XX } }, 2335 { "(bad)", { XX } }, 2336 { "movntdqa", { XM, EM } }, 2337 { "(bad)", { XX } }, 2338 }, 2339 2340 /* PREGRP52 */ 2341 { 2342 { "(bad)", { XX } }, 2343 { "(bad)", { XX } }, 2344 { "packusdw", { XM, EXx } }, 2345 { "(bad)", { XX } }, 2346 }, 2347 2348 /* PREGRP53 */ 2349 { 2350 { "(bad)", { XX } }, 2351 { "(bad)", { XX } }, 2352 { "pmovzxbw", { XM, EXx } }, 2353 { "(bad)", { XX } }, 2354 }, 2355 2356 /* PREGRP54 */ 2357 { 2358 { "(bad)", { XX } }, 2359 { "(bad)", { XX } }, 2360 { "pmovzxbd", { XM, EXx } }, 2361 { "(bad)", { XX } }, 2362 }, 2363 2364 /* PREGRP55 */ 2365 { 2366 { "(bad)", { XX } }, 2367 { "(bad)", { XX } }, 2368 { "pmovzxbq", { XM, EXx } }, 2369 { "(bad)", { XX } }, 2370 }, 2371 2372 /* PREGRP56 */ 2373 { 2374 { "(bad)", { XX } }, 2375 { "(bad)", { XX } }, 2376 { "pmovzxwd", { XM, EXx } }, 2377 { "(bad)", { XX } }, 2378 }, 2379 2380 /* PREGRP57 */ 2381 { 2382 { "(bad)", { XX } }, 2383 { "(bad)", { XX } }, 2384 { "pmovzxwq", { XM, EXx } }, 2385 { "(bad)", { XX } }, 2386 }, 2387 2388 /* PREGRP58 */ 2389 { 2390 { "(bad)", { XX } }, 2391 { "(bad)", { XX } }, 2392 { "pmovzxdq", { XM, EXx } }, 2393 { "(bad)", { XX } }, 2394 }, 2395 2396 /* PREGRP59 */ 2397 { 2398 { "(bad)", { XX } }, 2399 { "(bad)", { XX } }, 2400 { "pminsb", { XM, EXx } }, 2401 { "(bad)", { XX } }, 2402 }, 2403 2404 /* PREGRP60 */ 2405 { 2406 { "(bad)", { XX } }, 2407 { "(bad)", { XX } }, 2408 { "pminsd", { XM, EXx } }, 2409 { "(bad)", { XX } }, 2410 }, 2411 2412 /* PREGRP61 */ 2413 { 2414 { "(bad)", { XX } }, 2415 { "(bad)", { XX } }, 2416 { "pminuw", { XM, EXx } }, 2417 { "(bad)", { XX } }, 2418 }, 2419 2420 /* PREGRP62 */ 2421 { 2422 { "(bad)", { XX } }, 2423 { "(bad)", { XX } }, 2424 { "pminud", { XM, EXx } }, 2425 { "(bad)", { XX } }, 2426 }, 2427 2428 /* PREGRP63 */ 2429 { 2430 { "(bad)", { XX } }, 2431 { "(bad)", { XX } }, 2432 { "pmaxsb", { XM, EXx } }, 2433 { "(bad)", { XX } }, 2434 }, 2435 2436 /* PREGRP64 */ 2437 { 2438 { "(bad)", { XX } }, 2439 { "(bad)", { XX } }, 2440 { "pmaxsd", { XM, EXx } }, 2441 { "(bad)", { XX } }, 2442 }, 2443 2444 /* PREGRP65 */ 2445 { 2446 { "(bad)", { XX } }, 2447 { "(bad)", { XX } }, 2448 { "pmaxuw", { XM, EXx } }, 2449 { "(bad)", { XX } }, 2450 }, 2451 2452 /* PREGRP66 */ 2453 { 2454 { "(bad)", { XX } }, 2455 { "(bad)", { XX } }, 2456 { "pmaxud", { XM, EXx } }, 2457 { "(bad)", { XX } }, 2458 }, 2459 2460 /* PREGRP67 */ 2461 { 2462 { "(bad)", { XX } }, 2463 { "(bad)", { XX } }, 2464 { "pmulld", { XM, EXx } }, 2465 { "(bad)", { XX } }, 2466 }, 2467 2468 /* PREGRP68 */ 2469 { 2470 { "(bad)", { XX } }, 2471 { "(bad)", { XX } }, 2472 { "phminposuw", { XM, EXx } }, 2473 { "(bad)", { XX } }, 2474 }, 2475 2476 /* PREGRP69 */ 2477 { 2478 { "(bad)", { XX } }, 2479 { "(bad)", { XX } }, 2480 { "roundps", { XM, EXx, Ib } }, 2481 { "(bad)", { XX } }, 2482 }, 2483 2484 /* PREGRP70 */ 2485 { 2486 { "(bad)", { XX } }, 2487 { "(bad)", { XX } }, 2488 { "roundpd", { XM, EXx, Ib } }, 2489 { "(bad)", { XX } }, 2490 }, 2491 2492 /* PREGRP71 */ 2493 { 2494 { "(bad)", { XX } }, 2495 { "(bad)", { XX } }, 2496 { "roundss", { XM, EXx, Ib } }, 2497 { "(bad)", { XX } }, 2498 }, 2499 2500 /* PREGRP72 */ 2501 { 2502 { "(bad)", { XX } }, 2503 { "(bad)", { XX } }, 2504 { "roundsd", { XM, EXx, Ib } }, 2505 { "(bad)", { XX } }, 2506 }, 2507 2508 /* PREGRP73 */ 2509 { 2510 { "(bad)", { XX } }, 2511 { "(bad)", { XX } }, 2512 { "blendps", { XM, EXx, Ib } }, 2513 { "(bad)", { XX } }, 2514 }, 2515 2516 /* PREGRP74 */ 2517 { 2518 { "(bad)", { XX } }, 2519 { "(bad)", { XX } }, 2520 { "blendpd", { XM, EXx, Ib } }, 2521 { "(bad)", { XX } }, 2522 }, 2523 2524 /* PREGRP75 */ 2525 { 2526 { "(bad)", { XX } }, 2527 { "(bad)", { XX } }, 2528 { "pblendw", { XM, EXx, Ib } }, 2529 { "(bad)", { XX } }, 2530 }, 2531 2532 /* PREGRP76 */ 2533 { 2534 { "(bad)", { XX } }, 2535 { "(bad)", { XX } }, 2536 { "pextrb", { Edqb, XM, Ib } }, 2537 { "(bad)", { XX } }, 2538 }, 2539 2540 /* PREGRP77 */ 2541 { 2542 { "(bad)", { XX } }, 2543 { "(bad)", { XX } }, 2544 { "pextrw", { Edqw, XM, Ib } }, 2545 { "(bad)", { XX } }, 2546 }, 2547 2548 /* PREGRP78 */ 2549 { 2550 { "(bad)", { XX } }, 2551 { "(bad)", { XX } }, 2552 { "pextrK", { Edq, XM, Ib } }, 2553 { "(bad)", { XX } }, 2554 }, 2555 2556 /* PREGRP79 */ 2557 { 2558 { "(bad)", { XX } }, 2559 { "(bad)", { XX } }, 2560 { "extractps", { Edqd, XM, Ib } }, 2561 { "(bad)", { XX } }, 2562 }, 2563 2564 /* PREGRP80 */ 2565 { 2566 { "(bad)", { XX } }, 2567 { "(bad)", { XX } }, 2568 { "pinsrb", { XM, Edqb, Ib } }, 2569 { "(bad)", { XX } }, 2570 }, 2571 2572 /* PREGRP81 */ 2573 { 2574 { "(bad)", { XX } }, 2575 { "(bad)", { XX } }, 2576 { "insertps", { XM, EXx, Ib } }, 2577 { "(bad)", { XX } }, 2578 }, 2579 2580 /* PREGRP82 */ 2581 { 2582 { "(bad)", { XX } }, 2583 { "(bad)", { XX } }, 2584 { "pinsrK", { XM, Edq, Ib } }, 2585 { "(bad)", { XX } }, 2586 }, 2587 2588 /* PREGRP83 */ 2589 { 2590 { "(bad)", { XX } }, 2591 { "(bad)", { XX } }, 2592 { "dpps", { XM, EXx, Ib } }, 2593 { "(bad)", { XX } }, 2594 }, 2595 2596 /* PREGRP84 */ 2597 { 2598 { "(bad)", { XX } }, 2599 { "(bad)", { XX } }, 2600 { "dppd", { XM, EXx, Ib } }, 2601 { "(bad)", { XX } }, 2602 }, 2603 2604 /* PREGRP85 */ 2605 { 2606 { "(bad)", { XX } }, 2607 { "(bad)", { XX } }, 2608 { "mpsadbw", { XM, EXx, Ib } }, 2609 { "(bad)", { XX } }, 2610 }, 2611 2612 /* PREGRP86 */ 2613 { 2614 { "(bad)", { XX } }, 2615 { "(bad)", { XX } }, 2616 { "pcmpgtq", { XM, EXx } }, 2617 { "(bad)", { XX } }, 2618 }, 2619 2620 /* PREGRP87 */ 2621 { 2622 { "(bad)", { XX } }, 2623 { "(bad)", { XX } }, 2624 { "(bad)", { XX } }, 2625 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } }, 2626 }, 2627 2628 /* PREGRP88 */ 2629 { 2630 { "(bad)", { XX } }, 2631 { "(bad)", { XX } }, 2632 { "(bad)", { XX } }, 2633 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } }, 2634 }, 2635 2636 /* PREGRP89 */ 2637 { 2638 { "(bad)", { XX } }, 2639 { "(bad)", { XX } }, 2640 { "pcmpestrm", { XM, EXx, Ib } }, 2641 { "(bad)", { XX } }, 2642 }, 2643 2644 /* PREGRP90 */ 2645 { 2646 { "(bad)", { XX } }, 2647 { "(bad)", { XX } }, 2648 { "pcmpestri", { XM, EXx, Ib } }, 2649 { "(bad)", { XX } }, 2650 }, 2651 2652 /* PREGRP91 */ 2653 { 2654 { "(bad)", { XX } }, 2655 { "(bad)", { XX } }, 2656 { "pcmpistrm", { XM, EXx, Ib } }, 2657 { "(bad)", { XX } }, 2658 }, 2659 2660 /* PREGRP92 */ 2661 { 2662 { "(bad)", { XX } }, 2663 { "(bad)", { XX } }, 2664 { "pcmpistri", { XM, EXx, Ib } }, 2665 { "(bad)", { XX } }, 2666 }, 2667 2668 /* PREGRP93 */ 2669 { 2670 { "ucomiss",{ XM, EXd } }, 2671 { "(bad)", { XX } }, 2672 { "ucomisd",{ XM, EXq } }, 2673 { "(bad)", { XX } }, 2674 }, 2675 2676 /* PREGRP94 */ 2677 { 2678 { "comiss", { XM, EXd } }, 2679 { "(bad)", { XX } }, 2680 { "comisd", { XM, EXq } }, 2681 { "(bad)", { XX } }, 2682 }, 2683 2684 /* PREGRP95 */ 2685 { 2686 { "punpcklbw",{ MX, EMd } }, 2687 { "(bad)", { XX } }, 2688 { "punpcklbw",{ MX, EMq } }, 2689 { "(bad)", { XX } }, 2690 }, 2691 2692 /* PREGRP96 */ 2693 { 2694 { "punpcklwd",{ MX, EMd } }, 2695 { "(bad)", { XX } }, 2696 { "punpcklwd",{ MX, EMq } }, 2697 { "(bad)", { XX } }, 2698 }, 2699 2700 /* PREGRP97 */ 2701 { 2702 { "punpckldq",{ MX, EMd } }, 2703 { "(bad)", { XX } }, 2704 { "punpckldq",{ MX, EMq } }, 2705 { "(bad)", { XX } }, 2706 }, 2707 }; 2708 2709 static const struct dis386 x86_64_table[][2] = { 2710 { 2711 { "pusha{P|}", { XX } }, 2712 { "(bad)", { XX } }, 2713 }, 2714 { 2715 { "popa{P|}", { XX } }, 2716 { "(bad)", { XX } }, 2717 }, 2718 { 2719 { "bound{S|}", { Gv, Ma } }, 2720 { "(bad)", { XX } }, 2721 }, 2722 { 2723 { "arpl", { Ew, Gw } }, 2724 { "movs{||lq|xd}", { Gv, Ed } }, 2725 }, 2726 }; 2727 2728 static const struct dis386 three_byte_table[][256] = { 2729 /* THREE_BYTE_0 */ 2730 { 2731 /* 00 */ 2732 { "pshufb", { MX, EM } }, 2733 { "phaddw", { MX, EM } }, 2734 { "phaddd", { MX, EM } }, 2735 { "phaddsw", { MX, EM } }, 2736 { "pmaddubsw", { MX, EM } }, 2737 { "phsubw", { MX, EM } }, 2738 { "phsubd", { MX, EM } }, 2739 { "phsubsw", { MX, EM } }, 2740 /* 08 */ 2741 { "psignb", { MX, EM } }, 2742 { "psignw", { MX, EM } }, 2743 { "psignd", { MX, EM } }, 2744 { "pmulhrsw", { MX, EM } }, 2745 { "(bad)", { XX } }, 2746 { "(bad)", { XX } }, 2747 { "(bad)", { XX } }, 2748 { "(bad)", { XX } }, 2749 /* 10 */ 2750 { PREGRP39 }, 2751 { "(bad)", { XX } }, 2752 { "(bad)", { XX } }, 2753 { "(bad)", { XX } }, 2754 { PREGRP40 }, 2755 { PREGRP41 }, 2756 { "(bad)", { XX } }, 2757 { PREGRP42 }, 2758 /* 18 */ 2759 { "(bad)", { XX } }, 2760 { "(bad)", { XX } }, 2761 { "(bad)", { XX } }, 2762 { "(bad)", { XX } }, 2763 { "pabsb", { MX, EM } }, 2764 { "pabsw", { MX, EM } }, 2765 { "pabsd", { MX, EM } }, 2766 { "(bad)", { XX } }, 2767 /* 20 */ 2768 { PREGRP43 }, 2769 { PREGRP44 }, 2770 { PREGRP45 }, 2771 { PREGRP46 }, 2772 { PREGRP47 }, 2773 { PREGRP48 }, 2774 { "(bad)", { XX } }, 2775 { "(bad)", { XX } }, 2776 /* 28 */ 2777 { PREGRP49 }, 2778 { PREGRP50 }, 2779 { PREGRP51 }, 2780 { PREGRP52 }, 2781 { "(bad)", { XX } }, 2782 { "(bad)", { XX } }, 2783 { "(bad)", { XX } }, 2784 { "(bad)", { XX } }, 2785 /* 30 */ 2786 { PREGRP53 }, 2787 { PREGRP54 }, 2788 { PREGRP55 }, 2789 { PREGRP56 }, 2790 { PREGRP57 }, 2791 { PREGRP58 }, 2792 { "(bad)", { XX } }, 2793 { PREGRP86 }, 2794 /* 38 */ 2795 { PREGRP59 }, 2796 { PREGRP60 }, 2797 { PREGRP61 }, 2798 { PREGRP62 }, 2799 { PREGRP63 }, 2800 { PREGRP64 }, 2801 { PREGRP65 }, 2802 { PREGRP66 }, 2803 /* 40 */ 2804 { PREGRP67 }, 2805 { PREGRP68 }, 2806 { "(bad)", { XX } }, 2807 { "(bad)", { XX } }, 2808 { "(bad)", { XX } }, 2809 { "(bad)", { XX } }, 2810 { "(bad)", { XX } }, 2811 { "(bad)", { XX } }, 2812 /* 48 */ 2813 { "(bad)", { XX } }, 2814 { "(bad)", { XX } }, 2815 { "(bad)", { XX } }, 2816 { "(bad)", { XX } }, 2817 { "(bad)", { XX } }, 2818 { "(bad)", { XX } }, 2819 { "(bad)", { XX } }, 2820 { "(bad)", { XX } }, 2821 /* 50 */ 2822 { "(bad)", { XX } }, 2823 { "(bad)", { XX } }, 2824 { "(bad)", { XX } }, 2825 { "(bad)", { XX } }, 2826 { "(bad)", { XX } }, 2827 { "(bad)", { XX } }, 2828 { "(bad)", { XX } }, 2829 { "(bad)", { XX } }, 2830 /* 58 */ 2831 { "(bad)", { XX } }, 2832 { "(bad)", { XX } }, 2833 { "(bad)", { XX } }, 2834 { "(bad)", { XX } }, 2835 { "(bad)", { XX } }, 2836 { "(bad)", { XX } }, 2837 { "(bad)", { XX } }, 2838 { "(bad)", { XX } }, 2839 /* 60 */ 2840 { "(bad)", { XX } }, 2841 { "(bad)", { XX } }, 2842 { "(bad)", { XX } }, 2843 { "(bad)", { XX } }, 2844 { "(bad)", { XX } }, 2845 { "(bad)", { XX } }, 2846 { "(bad)", { XX } }, 2847 { "(bad)", { XX } }, 2848 /* 68 */ 2849 { "(bad)", { XX } }, 2850 { "(bad)", { XX } }, 2851 { "(bad)", { XX } }, 2852 { "(bad)", { XX } }, 2853 { "(bad)", { XX } }, 2854 { "(bad)", { XX } }, 2855 { "(bad)", { XX } }, 2856 { "(bad)", { XX } }, 2857 /* 70 */ 2858 { "(bad)", { XX } }, 2859 { "(bad)", { XX } }, 2860 { "(bad)", { XX } }, 2861 { "(bad)", { XX } }, 2862 { "(bad)", { XX } }, 2863 { "(bad)", { XX } }, 2864 { "(bad)", { XX } }, 2865 { "(bad)", { XX } }, 2866 /* 78 */ 2867 { "(bad)", { XX } }, 2868 { "(bad)", { XX } }, 2869 { "(bad)", { XX } }, 2870 { "(bad)", { XX } }, 2871 { "(bad)", { XX } }, 2872 { "(bad)", { XX } }, 2873 { "(bad)", { XX } }, 2874 { "(bad)", { XX } }, 2875 /* 80 */ 2876 { "(bad)", { XX } }, 2877 { "(bad)", { XX } }, 2878 { "(bad)", { XX } }, 2879 { "(bad)", { XX } }, 2880 { "(bad)", { XX } }, 2881 { "(bad)", { XX } }, 2882 { "(bad)", { XX } }, 2883 { "(bad)", { XX } }, 2884 /* 88 */ 2885 { "(bad)", { XX } }, 2886 { "(bad)", { XX } }, 2887 { "(bad)", { XX } }, 2888 { "(bad)", { XX } }, 2889 { "(bad)", { XX } }, 2890 { "(bad)", { XX } }, 2891 { "(bad)", { XX } }, 2892 { "(bad)", { XX } }, 2893 /* 90 */ 2894 { "(bad)", { XX } }, 2895 { "(bad)", { XX } }, 2896 { "(bad)", { XX } }, 2897 { "(bad)", { XX } }, 2898 { "(bad)", { XX } }, 2899 { "(bad)", { XX } }, 2900 { "(bad)", { XX } }, 2901 { "(bad)", { XX } }, 2902 /* 98 */ 2903 { "(bad)", { XX } }, 2904 { "(bad)", { XX } }, 2905 { "(bad)", { XX } }, 2906 { "(bad)", { XX } }, 2907 { "(bad)", { XX } }, 2908 { "(bad)", { XX } }, 2909 { "(bad)", { XX } }, 2910 { "(bad)", { XX } }, 2911 /* a0 */ 2912 { "(bad)", { XX } }, 2913 { "(bad)", { XX } }, 2914 { "(bad)", { XX } }, 2915 { "(bad)", { XX } }, 2916 { "(bad)", { XX } }, 2917 { "(bad)", { XX } }, 2918 { "(bad)", { XX } }, 2919 { "(bad)", { XX } }, 2920 /* a8 */ 2921 { "(bad)", { XX } }, 2922 { "(bad)", { XX } }, 2923 { "(bad)", { XX } }, 2924 { "(bad)", { XX } }, 2925 { "(bad)", { XX } }, 2926 { "(bad)", { XX } }, 2927 { "(bad)", { XX } }, 2928 { "(bad)", { XX } }, 2929 /* b0 */ 2930 { "(bad)", { XX } }, 2931 { "(bad)", { XX } }, 2932 { "(bad)", { XX } }, 2933 { "(bad)", { XX } }, 2934 { "(bad)", { XX } }, 2935 { "(bad)", { XX } }, 2936 { "(bad)", { XX } }, 2937 { "(bad)", { XX } }, 2938 /* b8 */ 2939 { "(bad)", { XX } }, 2940 { "(bad)", { XX } }, 2941 { "(bad)", { XX } }, 2942 { "(bad)", { XX } }, 2943 { "(bad)", { XX } }, 2944 { "(bad)", { XX } }, 2945 { "(bad)", { XX } }, 2946 { "(bad)", { XX } }, 2947 /* c0 */ 2948 { "(bad)", { XX } }, 2949 { "(bad)", { XX } }, 2950 { "(bad)", { XX } }, 2951 { "(bad)", { XX } }, 2952 { "(bad)", { XX } }, 2953 { "(bad)", { XX } }, 2954 { "(bad)", { XX } }, 2955 { "(bad)", { XX } }, 2956 /* c8 */ 2957 { "(bad)", { XX } }, 2958 { "(bad)", { XX } }, 2959 { "(bad)", { XX } }, 2960 { "(bad)", { XX } }, 2961 { "(bad)", { XX } }, 2962 { "(bad)", { XX } }, 2963 { "(bad)", { XX } }, 2964 { "(bad)", { XX } }, 2965 /* d0 */ 2966 { "(bad)", { XX } }, 2967 { "(bad)", { XX } }, 2968 { "(bad)", { XX } }, 2969 { "(bad)", { XX } }, 2970 { "(bad)", { XX } }, 2971 { "(bad)", { XX } }, 2972 { "(bad)", { XX } }, 2973 { "(bad)", { XX } }, 2974 /* d8 */ 2975 { "(bad)", { XX } }, 2976 { "(bad)", { XX } }, 2977 { "(bad)", { XX } }, 2978 { "(bad)", { XX } }, 2979 { "(bad)", { XX } }, 2980 { "(bad)", { XX } }, 2981 { "(bad)", { XX } }, 2982 { "(bad)", { XX } }, 2983 /* e0 */ 2984 { "(bad)", { XX } }, 2985 { "(bad)", { XX } }, 2986 { "(bad)", { XX } }, 2987 { "(bad)", { XX } }, 2988 { "(bad)", { XX } }, 2989 { "(bad)", { XX } }, 2990 { "(bad)", { XX } }, 2991 { "(bad)", { XX } }, 2992 /* e8 */ 2993 { "(bad)", { XX } }, 2994 { "(bad)", { XX } }, 2995 { "(bad)", { XX } }, 2996 { "(bad)", { XX } }, 2997 { "(bad)", { XX } }, 2998 { "(bad)", { XX } }, 2999 { "(bad)", { XX } }, 3000 { "(bad)", { XX } }, 3001 /* f0 */ 3002 { PREGRP87 }, 3003 { PREGRP88 }, 3004 { "(bad)", { XX } }, 3005 { "(bad)", { XX } }, 3006 { "(bad)", { XX } }, 3007 { "(bad)", { XX } }, 3008 { "(bad)", { XX } }, 3009 { "(bad)", { XX } }, 3010 /* f8 */ 3011 { "(bad)", { XX } }, 3012 { "(bad)", { XX } }, 3013 { "(bad)", { XX } }, 3014 { "(bad)", { XX } }, 3015 { "(bad)", { XX } }, 3016 { "(bad)", { XX } }, 3017 { "(bad)", { XX } }, 3018 { "(bad)", { XX } }, 3019 }, 3020 /* THREE_BYTE_1 */ 3021 { 3022 /* 00 */ 3023 { "(bad)", { XX } }, 3024 { "(bad)", { XX } }, 3025 { "(bad)", { XX } }, 3026 { "(bad)", { XX } }, 3027 { "(bad)", { XX } }, 3028 { "(bad)", { XX } }, 3029 { "(bad)", { XX } }, 3030 { "(bad)", { XX } }, 3031 /* 08 */ 3032 { PREGRP69 }, 3033 { PREGRP70 }, 3034 { PREGRP71 }, 3035 { PREGRP72 }, 3036 { PREGRP73 }, 3037 { PREGRP74 }, 3038 { PREGRP75 }, 3039 { "palignr", { MX, EM, Ib } }, 3040 /* 10 */ 3041 { "(bad)", { XX } }, 3042 { "(bad)", { XX } }, 3043 { "(bad)", { XX } }, 3044 { "(bad)", { XX } }, 3045 { PREGRP76 }, 3046 { PREGRP77 }, 3047 { PREGRP78 }, 3048 { PREGRP79 }, 3049 /* 18 */ 3050 { "(bad)", { XX } }, 3051 { "(bad)", { XX } }, 3052 { "(bad)", { XX } }, 3053 { "(bad)", { XX } }, 3054 { "(bad)", { XX } }, 3055 { "(bad)", { XX } }, 3056 { "(bad)", { XX } }, 3057 { "(bad)", { XX } }, 3058 /* 20 */ 3059 { PREGRP80 }, 3060 { PREGRP81 }, 3061 { PREGRP82 }, 3062 { "(bad)", { XX } }, 3063 { "(bad)", { XX } }, 3064 { "(bad)", { XX } }, 3065 { "(bad)", { XX } }, 3066 { "(bad)", { XX } }, 3067 /* 28 */ 3068 { "(bad)", { XX } }, 3069 { "(bad)", { XX } }, 3070 { "(bad)", { XX } }, 3071 { "(bad)", { XX } }, 3072 { "(bad)", { XX } }, 3073 { "(bad)", { XX } }, 3074 { "(bad)", { XX } }, 3075 { "(bad)", { XX } }, 3076 /* 30 */ 3077 { "(bad)", { XX } }, 3078 { "(bad)", { XX } }, 3079 { "(bad)", { XX } }, 3080 { "(bad)", { XX } }, 3081 { "(bad)", { XX } }, 3082 { "(bad)", { XX } }, 3083 { "(bad)", { XX } }, 3084 { "(bad)", { XX } }, 3085 /* 38 */ 3086 { "(bad)", { XX } }, 3087 { "(bad)", { XX } }, 3088 { "(bad)", { XX } }, 3089 { "(bad)", { XX } }, 3090 { "(bad)", { XX } }, 3091 { "(bad)", { XX } }, 3092 { "(bad)", { XX } }, 3093 { "(bad)", { XX } }, 3094 /* 40 */ 3095 { PREGRP83 }, 3096 { PREGRP84 }, 3097 { PREGRP85 }, 3098 { "(bad)", { XX } }, 3099 { "(bad)", { XX } }, 3100 { "(bad)", { XX } }, 3101 { "(bad)", { XX } }, 3102 { "(bad)", { XX } }, 3103 /* 48 */ 3104 { "(bad)", { XX } }, 3105 { "(bad)", { XX } }, 3106 { "(bad)", { XX } }, 3107 { "(bad)", { XX } }, 3108 { "(bad)", { XX } }, 3109 { "(bad)", { XX } }, 3110 { "(bad)", { XX } }, 3111 { "(bad)", { XX } }, 3112 /* 50 */ 3113 { "(bad)", { XX } }, 3114 { "(bad)", { XX } }, 3115 { "(bad)", { XX } }, 3116 { "(bad)", { XX } }, 3117 { "(bad)", { XX } }, 3118 { "(bad)", { XX } }, 3119 { "(bad)", { XX } }, 3120 { "(bad)", { XX } }, 3121 /* 58 */ 3122 { "(bad)", { XX } }, 3123 { "(bad)", { XX } }, 3124 { "(bad)", { XX } }, 3125 { "(bad)", { XX } }, 3126 { "(bad)", { XX } }, 3127 { "(bad)", { XX } }, 3128 { "(bad)", { XX } }, 3129 { "(bad)", { XX } }, 3130 /* 60 */ 3131 { PREGRP89 }, 3132 { PREGRP90 }, 3133 { PREGRP91 }, 3134 { PREGRP92 }, 3135 { "(bad)", { XX } }, 3136 { "(bad)", { XX } }, 3137 { "(bad)", { XX } }, 3138 { "(bad)", { XX } }, 3139 /* 68 */ 3140 { "(bad)", { XX } }, 3141 { "(bad)", { XX } }, 3142 { "(bad)", { XX } }, 3143 { "(bad)", { XX } }, 3144 { "(bad)", { XX } }, 3145 { "(bad)", { XX } }, 3146 { "(bad)", { XX } }, 3147 { "(bad)", { XX } }, 3148 /* 70 */ 3149 { "(bad)", { XX } }, 3150 { "(bad)", { XX } }, 3151 { "(bad)", { XX } }, 3152 { "(bad)", { XX } }, 3153 { "(bad)", { XX } }, 3154 { "(bad)", { XX } }, 3155 { "(bad)", { XX } }, 3156 { "(bad)", { XX } }, 3157 /* 78 */ 3158 { "(bad)", { XX } }, 3159 { "(bad)", { XX } }, 3160 { "(bad)", { XX } }, 3161 { "(bad)", { XX } }, 3162 { "(bad)", { XX } }, 3163 { "(bad)", { XX } }, 3164 { "(bad)", { XX } }, 3165 { "(bad)", { XX } }, 3166 /* 80 */ 3167 { "(bad)", { XX } }, 3168 { "(bad)", { XX } }, 3169 { "(bad)", { XX } }, 3170 { "(bad)", { XX } }, 3171 { "(bad)", { XX } }, 3172 { "(bad)", { XX } }, 3173 { "(bad)", { XX } }, 3174 { "(bad)", { XX } }, 3175 /* 88 */ 3176 { "(bad)", { XX } }, 3177 { "(bad)", { XX } }, 3178 { "(bad)", { XX } }, 3179 { "(bad)", { XX } }, 3180 { "(bad)", { XX } }, 3181 { "(bad)", { XX } }, 3182 { "(bad)", { XX } }, 3183 { "(bad)", { XX } }, 3184 /* 90 */ 3185 { "(bad)", { XX } }, 3186 { "(bad)", { XX } }, 3187 { "(bad)", { XX } }, 3188 { "(bad)", { XX } }, 3189 { "(bad)", { XX } }, 3190 { "(bad)", { XX } }, 3191 { "(bad)", { XX } }, 3192 { "(bad)", { XX } }, 3193 /* 98 */ 3194 { "(bad)", { XX } }, 3195 { "(bad)", { XX } }, 3196 { "(bad)", { XX } }, 3197 { "(bad)", { XX } }, 3198 { "(bad)", { XX } }, 3199 { "(bad)", { XX } }, 3200 { "(bad)", { XX } }, 3201 { "(bad)", { XX } }, 3202 /* a0 */ 3203 { "(bad)", { XX } }, 3204 { "(bad)", { XX } }, 3205 { "(bad)", { XX } }, 3206 { "(bad)", { XX } }, 3207 { "(bad)", { XX } }, 3208 { "(bad)", { XX } }, 3209 { "(bad)", { XX } }, 3210 { "(bad)", { XX } }, 3211 /* a8 */ 3212 { "(bad)", { XX } }, 3213 { "(bad)", { XX } }, 3214 { "(bad)", { XX } }, 3215 { "(bad)", { XX } }, 3216 { "(bad)", { XX } }, 3217 { "(bad)", { XX } }, 3218 { "(bad)", { XX } }, 3219 { "(bad)", { XX } }, 3220 /* b0 */ 3221 { "(bad)", { XX } }, 3222 { "(bad)", { XX } }, 3223 { "(bad)", { XX } }, 3224 { "(bad)", { XX } }, 3225 { "(bad)", { XX } }, 3226 { "(bad)", { XX } }, 3227 { "(bad)", { XX } }, 3228 { "(bad)", { XX } }, 3229 /* b8 */ 3230 { "(bad)", { XX } }, 3231 { "(bad)", { XX } }, 3232 { "(bad)", { XX } }, 3233 { "(bad)", { XX } }, 3234 { "(bad)", { XX } }, 3235 { "(bad)", { XX } }, 3236 { "(bad)", { XX } }, 3237 { "(bad)", { XX } }, 3238 /* c0 */ 3239 { "(bad)", { XX } }, 3240 { "(bad)", { XX } }, 3241 { "(bad)", { XX } }, 3242 { "(bad)", { XX } }, 3243 { "(bad)", { XX } }, 3244 { "(bad)", { XX } }, 3245 { "(bad)", { XX } }, 3246 { "(bad)", { XX } }, 3247 /* c8 */ 3248 { "(bad)", { XX } }, 3249 { "(bad)", { XX } }, 3250 { "(bad)", { XX } }, 3251 { "(bad)", { XX } }, 3252 { "(bad)", { XX } }, 3253 { "(bad)", { XX } }, 3254 { "(bad)", { XX } }, 3255 { "(bad)", { XX } }, 3256 /* d0 */ 3257 { "(bad)", { XX } }, 3258 { "(bad)", { XX } }, 3259 { "(bad)", { XX } }, 3260 { "(bad)", { XX } }, 3261 { "(bad)", { XX } }, 3262 { "(bad)", { XX } }, 3263 { "(bad)", { XX } }, 3264 { "(bad)", { XX } }, 3265 /* d8 */ 3266 { "(bad)", { XX } }, 3267 { "(bad)", { XX } }, 3268 { "(bad)", { XX } }, 3269 { "(bad)", { XX } }, 3270 { "(bad)", { XX } }, 3271 { "(bad)", { XX } }, 3272 { "(bad)", { XX } }, 3273 { "(bad)", { XX } }, 3274 /* e0 */ 3275 { "(bad)", { XX } }, 3276 { "(bad)", { XX } }, 3277 { "(bad)", { XX } }, 3278 { "(bad)", { XX } }, 3279 { "(bad)", { XX } }, 3280 { "(bad)", { XX } }, 3281 { "(bad)", { XX } }, 3282 { "(bad)", { XX } }, 3283 /* e8 */ 3284 { "(bad)", { XX } }, 3285 { "(bad)", { XX } }, 3286 { "(bad)", { XX } }, 3287 { "(bad)", { XX } }, 3288 { "(bad)", { XX } }, 3289 { "(bad)", { XX } }, 3290 { "(bad)", { XX } }, 3291 { "(bad)", { XX } }, 3292 /* f0 */ 3293 { "(bad)", { XX } }, 3294 { "(bad)", { XX } }, 3295 { "(bad)", { XX } }, 3296 { "(bad)", { XX } }, 3297 { "(bad)", { XX } }, 3298 { "(bad)", { XX } }, 3299 { "(bad)", { XX } }, 3300 { "(bad)", { XX } }, 3301 /* f8 */ 3302 { "(bad)", { XX } }, 3303 { "(bad)", { XX } }, 3304 { "(bad)", { XX } }, 3305 { "(bad)", { XX } }, 3306 { "(bad)", { XX } }, 3307 { "(bad)", { XX } }, 3308 { "(bad)", { XX } }, 3309 { "(bad)", { XX } }, 3310 } 3311 }; 3312 3313 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") 3314 3315 static void 3316 ckprefix (void) 3317 { 3318 int newrex; 3319 rex = 0; 3320 prefixes = 0; 3321 used_prefixes = 0; 3322 rex_used = 0; 3323 while (1) 3324 { 3325 FETCH_DATA (the_info, codep + 1); 3326 newrex = 0; 3327 switch (*codep) 3328 { 3329 /* REX prefixes family. */ 3330 case 0x40: 3331 case 0x41: 3332 case 0x42: 3333 case 0x43: 3334 case 0x44: 3335 case 0x45: 3336 case 0x46: 3337 case 0x47: 3338 case 0x48: 3339 case 0x49: 3340 case 0x4a: 3341 case 0x4b: 3342 case 0x4c: 3343 case 0x4d: 3344 case 0x4e: 3345 case 0x4f: 3346 if (address_mode == mode_64bit) 3347 newrex = *codep; 3348 else 3349 return; 3350 break; 3351 case 0xf3: 3352 prefixes |= PREFIX_REPZ; 3353 break; 3354 case 0xf2: 3355 prefixes |= PREFIX_REPNZ; 3356 break; 3357 case 0xf0: 3358 prefixes |= PREFIX_LOCK; 3359 break; 3360 case 0x2e: 3361 prefixes |= PREFIX_CS; 3362 break; 3363 case 0x36: 3364 prefixes |= PREFIX_SS; 3365 break; 3366 case 0x3e: 3367 prefixes |= PREFIX_DS; 3368 break; 3369 case 0x26: 3370 prefixes |= PREFIX_ES; 3371 break; 3372 case 0x64: 3373 prefixes |= PREFIX_FS; 3374 break; 3375 case 0x65: 3376 prefixes |= PREFIX_GS; 3377 break; 3378 case 0x66: 3379 prefixes |= PREFIX_DATA; 3380 break; 3381 case 0x67: 3382 prefixes |= PREFIX_ADDR; 3383 break; 3384 case FWAIT_OPCODE: 3385 /* fwait is really an instruction. If there are prefixes 3386 before the fwait, they belong to the fwait, *not* to the 3387 following instruction. */ 3388 if (prefixes || rex) 3389 { 3390 prefixes |= PREFIX_FWAIT; 3391 codep++; 3392 return; 3393 } 3394 prefixes = PREFIX_FWAIT; 3395 break; 3396 default: 3397 return; 3398 } 3399 /* Rex is ignored when followed by another prefix. */ 3400 if (rex) 3401 { 3402 rex_used = rex; 3403 return; 3404 } 3405 rex = newrex; 3406 codep++; 3407 } 3408 } 3409 3410 /* Return the name of the prefix byte PREF, or NULL if PREF is not a 3411 prefix byte. */ 3412 3413 static const char * 3414 prefix_name (int pref, int sizeflag) 3415 { 3416 static const char * const rexes [16] = 3417 { 3418 "rex", /* 0x40 */ 3419 "rex.B", /* 0x41 */ 3420 "rex.X", /* 0x42 */ 3421 "rex.XB", /* 0x43 */ 3422 "rex.R", /* 0x44 */ 3423 "rex.RB", /* 0x45 */ 3424 "rex.RX", /* 0x46 */ 3425 "rex.RXB", /* 0x47 */ 3426 "rex.W", /* 0x48 */ 3427 "rex.WB", /* 0x49 */ 3428 "rex.WX", /* 0x4a */ 3429 "rex.WXB", /* 0x4b */ 3430 "rex.WR", /* 0x4c */ 3431 "rex.WRB", /* 0x4d */ 3432 "rex.WRX", /* 0x4e */ 3433 "rex.WRXB", /* 0x4f */ 3434 }; 3435 3436 switch (pref) 3437 { 3438 /* REX prefixes family. */ 3439 case 0x40: 3440 case 0x41: 3441 case 0x42: 3442 case 0x43: 3443 case 0x44: 3444 case 0x45: 3445 case 0x46: 3446 case 0x47: 3447 case 0x48: 3448 case 0x49: 3449 case 0x4a: 3450 case 0x4b: 3451 case 0x4c: 3452 case 0x4d: 3453 case 0x4e: 3454 case 0x4f: 3455 return rexes [pref - 0x40]; 3456 case 0xf3: 3457 return "repz"; 3458 case 0xf2: 3459 return "repnz"; 3460 case 0xf0: 3461 return "lock"; 3462 case 0x2e: 3463 return "cs"; 3464 case 0x36: 3465 return "ss"; 3466 case 0x3e: 3467 return "ds"; 3468 case 0x26: 3469 return "es"; 3470 case 0x64: 3471 return "fs"; 3472 case 0x65: 3473 return "gs"; 3474 case 0x66: 3475 return (sizeflag & DFLAG) ? "data16" : "data32"; 3476 case 0x67: 3477 if (address_mode == mode_64bit) 3478 return (sizeflag & AFLAG) ? "addr32" : "addr64"; 3479 else 3480 return (sizeflag & AFLAG) ? "addr16" : "addr32"; 3481 case FWAIT_OPCODE: 3482 return "fwait"; 3483 default: 3484 return NULL; 3485 } 3486 } 3487 3488 static char op_out[MAX_OPERANDS][100]; 3489 static int op_ad, op_index[MAX_OPERANDS]; 3490 static int two_source_ops; 3491 static bfd_vma op_address[MAX_OPERANDS]; 3492 static bfd_vma op_riprel[MAX_OPERANDS]; 3493 static bfd_vma start_pc; 3494 3495 /* 3496 * On the 386's of 1988, the maximum length of an instruction is 15 bytes. 3497 * (see topic "Redundant prefixes" in the "Differences from 8086" 3498 * section of the "Virtual 8086 Mode" chapter.) 3499 * 'pc' should be the address of this instruction, it will 3500 * be used to print the target address if this is a relative jump or call 3501 * The function returns the length of this instruction in bytes. 3502 */ 3503 3504 static char intel_syntax; 3505 static char open_char; 3506 static char close_char; 3507 static char separator_char; 3508 static char scale_char; 3509 3510 int 3511 print_insn_i386 (bfd_vma pc, disassemble_info *info) 3512 { 3513 intel_syntax = -1; 3514 3515 return print_insn (pc, info); 3516 } 3517 3518 static int 3519 print_insn (bfd_vma pc, disassemble_info *info) 3520 { 3521 const struct dis386 *dp; 3522 int i; 3523 char *op_txt[MAX_OPERANDS]; 3524 int needcomma; 3525 unsigned char uses_DATA_prefix, uses_LOCK_prefix; 3526 unsigned char uses_REPNZ_prefix, uses_REPZ_prefix; 3527 int sizeflag; 3528 const char *p; 3529 struct dis_private priv; 3530 unsigned char op; 3531 3532 if (info->mach == bfd_mach_x86_64_intel_syntax 3533 || info->mach == bfd_mach_x86_64) 3534 address_mode = mode_64bit; 3535 else 3536 address_mode = mode_32bit; 3537 3538 if (intel_syntax == (char) -1) 3539 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax 3540 || info->mach == bfd_mach_x86_64_intel_syntax); 3541 3542 if (info->mach == bfd_mach_i386_i386 3543 || info->mach == bfd_mach_x86_64 3544 || info->mach == bfd_mach_i386_i386_intel_syntax 3545 || info->mach == bfd_mach_x86_64_intel_syntax) 3546 priv.orig_sizeflag = AFLAG | DFLAG; 3547 else if (info->mach == bfd_mach_i386_i8086) 3548 priv.orig_sizeflag = 0; 3549 else 3550 abort (); 3551 3552 for (p = info->disassembler_options; p != NULL; ) 3553 { 3554 if (strncmp (p, "x86-64", 6) == 0) 3555 { 3556 address_mode = mode_64bit; 3557 priv.orig_sizeflag = AFLAG | DFLAG; 3558 } 3559 else if (strncmp (p, "i386", 4) == 0) 3560 { 3561 address_mode = mode_32bit; 3562 priv.orig_sizeflag = AFLAG | DFLAG; 3563 } 3564 else if (strncmp (p, "i8086", 5) == 0) 3565 { 3566 address_mode = mode_16bit; 3567 priv.orig_sizeflag = 0; 3568 } 3569 else if (strncmp (p, "intel", 5) == 0) 3570 { 3571 intel_syntax = 1; 3572 } 3573 else if (strncmp (p, "att", 3) == 0) 3574 { 3575 intel_syntax = 0; 3576 } 3577 else if (strncmp (p, "addr", 4) == 0) 3578 { 3579 if (address_mode == mode_64bit) 3580 { 3581 if (p[4] == '3' && p[5] == '2') 3582 priv.orig_sizeflag &= ~AFLAG; 3583 else if (p[4] == '6' && p[5] == '4') 3584 priv.orig_sizeflag |= AFLAG; 3585 } 3586 else 3587 { 3588 if (p[4] == '1' && p[5] == '6') 3589 priv.orig_sizeflag &= ~AFLAG; 3590 else if (p[4] == '3' && p[5] == '2') 3591 priv.orig_sizeflag |= AFLAG; 3592 } 3593 } 3594 else if (strncmp (p, "data", 4) == 0) 3595 { 3596 if (p[4] == '1' && p[5] == '6') 3597 priv.orig_sizeflag &= ~DFLAG; 3598 else if (p[4] == '3' && p[5] == '2') 3599 priv.orig_sizeflag |= DFLAG; 3600 } 3601 else if (strncmp (p, "suffix", 6) == 0) 3602 priv.orig_sizeflag |= SUFFIX_ALWAYS; 3603 3604 p = strchr (p, ','); 3605 if (p != NULL) 3606 p++; 3607 } 3608 3609 if (intel_syntax) 3610 { 3611 names64 = intel_names64; 3612 names32 = intel_names32; 3613 names16 = intel_names16; 3614 names8 = intel_names8; 3615 names8rex = intel_names8rex; 3616 names_seg = intel_names_seg; 3617 index16 = intel_index16; 3618 open_char = '['; 3619 close_char = ']'; 3620 separator_char = '+'; 3621 scale_char = '*'; 3622 } 3623 else 3624 { 3625 names64 = att_names64; 3626 names32 = att_names32; 3627 names16 = att_names16; 3628 names8 = att_names8; 3629 names8rex = att_names8rex; 3630 names_seg = att_names_seg; 3631 index16 = att_index16; 3632 open_char = '('; 3633 close_char = ')'; 3634 separator_char = ','; 3635 scale_char = ','; 3636 } 3637 3638 /* The output looks better if we put 7 bytes on a line, since that 3639 puts most long word instructions on a single line. */ 3640 info->bytes_per_line = 7; 3641 3642 info->private_data = &priv; 3643 priv.max_fetched = priv.the_buffer; 3644 priv.insn_start = pc; 3645 3646 obuf[0] = 0; 3647 for (i = 0; i < MAX_OPERANDS; ++i) 3648 { 3649 op_out[i][0] = 0; 3650 op_index[i] = -1; 3651 } 3652 3653 the_info = info; 3654 start_pc = pc; 3655 start_codep = priv.the_buffer; 3656 codep = priv.the_buffer; 3657 3658 if (setjmp (priv.bailout) != 0) 3659 { 3660 const char *name; 3661 3662 /* Getting here means we tried for data but didn't get it. That 3663 means we have an incomplete instruction of some sort. Just 3664 print the first byte as a prefix or a .byte pseudo-op. */ 3665 if (codep > priv.the_buffer) 3666 { 3667 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3668 if (name != NULL) 3669 (*info->fprintf_func) (info->stream, "%s", name); 3670 else 3671 { 3672 /* Just print the first byte as a .byte instruction. */ 3673 (*info->fprintf_func) (info->stream, ".byte 0x%x", 3674 (unsigned int) priv.the_buffer[0]); 3675 } 3676 3677 return 1; 3678 } 3679 3680 return -1; 3681 } 3682 3683 obufp = obuf; 3684 ckprefix (); 3685 3686 insn_codep = codep; 3687 sizeflag = priv.orig_sizeflag; 3688 3689 FETCH_DATA (info, codep + 1); 3690 two_source_ops = (*codep == 0x62) || (*codep == 0xc8); 3691 3692 if (((prefixes & PREFIX_FWAIT) 3693 && ((*codep < 0xd8) || (*codep > 0xdf))) 3694 || (rex && rex_used)) 3695 { 3696 const char *name; 3697 3698 /* fwait not followed by floating point instruction, or rex followed 3699 by other prefixes. Print the first prefix. */ 3700 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3701 if (name == NULL) 3702 name = INTERNAL_DISASSEMBLER_ERROR; 3703 (*info->fprintf_func) (info->stream, "%s", name); 3704 return 1; 3705 } 3706 3707 op = 0; 3708 if (*codep == 0x0f) 3709 { 3710 unsigned char threebyte; 3711 FETCH_DATA (info, codep + 2); 3712 threebyte = *++codep; 3713 dp = &dis386_twobyte[threebyte]; 3714 need_modrm = twobyte_has_modrm[*codep]; 3715 uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep]; 3716 uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep]; 3717 uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep]; 3718 uses_LOCK_prefix = (*codep & ~0x02) == 0x20; 3719 codep++; 3720 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) 3721 { 3722 FETCH_DATA (info, codep + 2); 3723 op = *codep++; 3724 switch (threebyte) 3725 { 3726 case 0x38: 3727 uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op]; 3728 uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op]; 3729 uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op]; 3730 break; 3731 case 0x3a: 3732 uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op]; 3733 uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op]; 3734 uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op]; 3735 break; 3736 default: 3737 break; 3738 } 3739 } 3740 } 3741 else 3742 { 3743 dp = &dis386[*codep]; 3744 need_modrm = onebyte_has_modrm[*codep]; 3745 uses_DATA_prefix = 0; 3746 uses_REPNZ_prefix = 0; 3747 /* pause is 0xf3 0x90. */ 3748 uses_REPZ_prefix = *codep == 0x90; 3749 uses_LOCK_prefix = 0; 3750 codep++; 3751 } 3752 3753 if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ)) 3754 { 3755 oappend ("repz "); 3756 used_prefixes |= PREFIX_REPZ; 3757 } 3758 if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ)) 3759 { 3760 oappend ("repnz "); 3761 used_prefixes |= PREFIX_REPNZ; 3762 } 3763 3764 if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK)) 3765 { 3766 oappend ("lock "); 3767 used_prefixes |= PREFIX_LOCK; 3768 } 3769 3770 if (prefixes & PREFIX_ADDR) 3771 { 3772 sizeflag ^= AFLAG; 3773 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax) 3774 { 3775 if ((sizeflag & AFLAG) || address_mode == mode_64bit) 3776 oappend ("addr32 "); 3777 else 3778 oappend ("addr16 "); 3779 used_prefixes |= PREFIX_ADDR; 3780 } 3781 } 3782 3783 if (!uses_DATA_prefix && (prefixes & PREFIX_DATA)) 3784 { 3785 sizeflag ^= DFLAG; 3786 if (dp->op[2].bytemode == cond_jump_mode 3787 && dp->op[0].bytemode == v_mode 3788 && !intel_syntax) 3789 { 3790 if (sizeflag & DFLAG) 3791 oappend ("data32 "); 3792 else 3793 oappend ("data16 "); 3794 used_prefixes |= PREFIX_DATA; 3795 } 3796 } 3797 3798 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) 3799 { 3800 dp = &three_byte_table[dp->op[1].bytemode][op]; 3801 modrm.mod = (*codep >> 6) & 3; 3802 modrm.reg = (*codep >> 3) & 7; 3803 modrm.rm = *codep & 7; 3804 } 3805 else if (need_modrm) 3806 { 3807 FETCH_DATA (info, codep + 1); 3808 modrm.mod = (*codep >> 6) & 3; 3809 modrm.reg = (*codep >> 3) & 7; 3810 modrm.rm = *codep & 7; 3811 } 3812 3813 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE) 3814 { 3815 dofloat (sizeflag); 3816 } 3817 else 3818 { 3819 int index; 3820 if (dp->name == NULL) 3821 { 3822 switch (dp->op[0].bytemode) 3823 { 3824 case USE_GROUPS: 3825 dp = &grps[dp->op[1].bytemode][modrm.reg]; 3826 break; 3827 3828 case USE_PREFIX_USER_TABLE: 3829 index = 0; 3830 used_prefixes |= (prefixes & PREFIX_REPZ); 3831 if (prefixes & PREFIX_REPZ) 3832 index = 1; 3833 else 3834 { 3835 /* We should check PREFIX_REPNZ and PREFIX_REPZ 3836 before PREFIX_DATA. */ 3837 used_prefixes |= (prefixes & PREFIX_REPNZ); 3838 if (prefixes & PREFIX_REPNZ) 3839 index = 3; 3840 else 3841 { 3842 used_prefixes |= (prefixes & PREFIX_DATA); 3843 if (prefixes & PREFIX_DATA) 3844 index = 2; 3845 } 3846 } 3847 dp = &prefix_user_table[dp->op[1].bytemode][index]; 3848 break; 3849 3850 case X86_64_SPECIAL: 3851 index = address_mode == mode_64bit ? 1 : 0; 3852 dp = &x86_64_table[dp->op[1].bytemode][index]; 3853 break; 3854 3855 default: 3856 oappend (INTERNAL_DISASSEMBLER_ERROR); 3857 break; 3858 } 3859 } 3860 3861 if (putop (dp->name, sizeflag) == 0) 3862 { 3863 for (i = 0; i < MAX_OPERANDS; ++i) 3864 { 3865 obufp = op_out[i]; 3866 op_ad = MAX_OPERANDS - 1 - i; 3867 if (dp->op[i].rtn) 3868 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag); 3869 } 3870 } 3871 } 3872 3873 /* See if any prefixes were not used. If so, print the first one 3874 separately. If we don't do this, we'll wind up printing an 3875 instruction stream which does not precisely correspond to the 3876 bytes we are disassembling. */ 3877 if ((prefixes & ~used_prefixes) != 0) 3878 { 3879 const char *name; 3880 3881 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 3882 if (name == NULL) 3883 name = INTERNAL_DISASSEMBLER_ERROR; 3884 (*info->fprintf_func) (info->stream, "%s", name); 3885 return 1; 3886 } 3887 if (rex & ~rex_used) 3888 { 3889 const char *name; 3890 name = prefix_name (rex | 0x40, priv.orig_sizeflag); 3891 if (name == NULL) 3892 name = INTERNAL_DISASSEMBLER_ERROR; 3893 (*info->fprintf_func) (info->stream, "%s ", name); 3894 } 3895 3896 obufp = obuf + strlen (obuf); 3897 for (i = strlen (obuf); i < 6; i++) 3898 oappend (" "); 3899 oappend (" "); 3900 (*info->fprintf_func) (info->stream, "%s", obuf); 3901 3902 /* The enter and bound instructions are printed with operands in the same 3903 order as the intel book; everything else is printed in reverse order. */ 3904 if (intel_syntax || two_source_ops) 3905 { 3906 bfd_vma riprel; 3907 3908 for (i = 0; i < MAX_OPERANDS; ++i) 3909 op_txt[i] = op_out[i]; 3910 3911 for (i = 0; i < (MAX_OPERANDS >> 1); ++i) 3912 { 3913 op_ad = op_index[i]; 3914 op_index[i] = op_index[MAX_OPERANDS - 1 - i]; 3915 op_index[MAX_OPERANDS - 1 - i] = op_ad; 3916 riprel = op_riprel[i]; 3917 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i]; 3918 op_riprel[MAX_OPERANDS - 1 - i] = riprel; 3919 } 3920 } 3921 else 3922 { 3923 for (i = 0; i < MAX_OPERANDS; ++i) 3924 op_txt[MAX_OPERANDS - 1 - i] = op_out[i]; 3925 } 3926 3927 needcomma = 0; 3928 for (i = 0; i < MAX_OPERANDS; ++i) 3929 if (*op_txt[i]) 3930 { 3931 if (needcomma) 3932 (*info->fprintf_func) (info->stream, ","); 3933 if (op_index[i] != -1 && !op_riprel[i]) 3934 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info); 3935 else 3936 (*info->fprintf_func) (info->stream, "%s", op_txt[i]); 3937 needcomma = 1; 3938 } 3939 3940 for (i = 0; i < MAX_OPERANDS; i++) 3941 if (op_index[i] != -1 && op_riprel[i]) 3942 { 3943 (*info->fprintf_func) (info->stream, " # "); 3944 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep 3945 + op_address[op_index[i]]), info); 3946 break; 3947 } 3948 return codep - priv.the_buffer; 3949 } 3950 3951 static const char *float_mem[] = { 3952 /* d8 */ 3953 "fadd{s||s|}", 3954 "fmul{s||s|}", 3955 "fcom{s||s|}", 3956 "fcomp{s||s|}", 3957 "fsub{s||s|}", 3958 "fsubr{s||s|}", 3959 "fdiv{s||s|}", 3960 "fdivr{s||s|}", 3961 /* d9 */ 3962 "fld{s||s|}", 3963 "(bad)", 3964 "fst{s||s|}", 3965 "fstp{s||s|}", 3966 "fldenvIC", 3967 "fldcw", 3968 "fNstenvIC", 3969 "fNstcw", 3970 /* da */ 3971 "fiadd{l||l|}", 3972 "fimul{l||l|}", 3973 "ficom{l||l|}", 3974 "ficomp{l||l|}", 3975 "fisub{l||l|}", 3976 "fisubr{l||l|}", 3977 "fidiv{l||l|}", 3978 "fidivr{l||l|}", 3979 /* db */ 3980 "fild{l||l|}", 3981 "fisttp{l||l|}", 3982 "fist{l||l|}", 3983 "fistp{l||l|}", 3984 "(bad)", 3985 "fld{t||t|}", 3986 "(bad)", 3987 "fstp{t||t|}", 3988 /* dc */ 3989 "fadd{l||l|}", 3990 "fmul{l||l|}", 3991 "fcom{l||l|}", 3992 "fcomp{l||l|}", 3993 "fsub{l||l|}", 3994 "fsubr{l||l|}", 3995 "fdiv{l||l|}", 3996 "fdivr{l||l|}", 3997 /* dd */ 3998 "fld{l||l|}", 3999 "fisttp{ll||ll|}", 4000 "fst{l||l|}", 4001 "fstp{l||l|}", 4002 "frstorIC", 4003 "(bad)", 4004 "fNsaveIC", 4005 "fNstsw", 4006 /* de */ 4007 "fiadd", 4008 "fimul", 4009 "ficom", 4010 "ficomp", 4011 "fisub", 4012 "fisubr", 4013 "fidiv", 4014 "fidivr", 4015 /* df */ 4016 "fild", 4017 "fisttp", 4018 "fist", 4019 "fistp", 4020 "fbld", 4021 "fild{ll||ll|}", 4022 "fbstp", 4023 "fistp{ll||ll|}", 4024 }; 4025 4026 static const unsigned char float_mem_mode[] = { 4027 /* d8 */ 4028 d_mode, 4029 d_mode, 4030 d_mode, 4031 d_mode, 4032 d_mode, 4033 d_mode, 4034 d_mode, 4035 d_mode, 4036 /* d9 */ 4037 d_mode, 4038 0, 4039 d_mode, 4040 d_mode, 4041 0, 4042 w_mode, 4043 0, 4044 w_mode, 4045 /* da */ 4046 d_mode, 4047 d_mode, 4048 d_mode, 4049 d_mode, 4050 d_mode, 4051 d_mode, 4052 d_mode, 4053 d_mode, 4054 /* db */ 4055 d_mode, 4056 d_mode, 4057 d_mode, 4058 d_mode, 4059 0, 4060 t_mode, 4061 0, 4062 t_mode, 4063 /* dc */ 4064 q_mode, 4065 q_mode, 4066 q_mode, 4067 q_mode, 4068 q_mode, 4069 q_mode, 4070 q_mode, 4071 q_mode, 4072 /* dd */ 4073 q_mode, 4074 q_mode, 4075 q_mode, 4076 q_mode, 4077 0, 4078 0, 4079 0, 4080 w_mode, 4081 /* de */ 4082 w_mode, 4083 w_mode, 4084 w_mode, 4085 w_mode, 4086 w_mode, 4087 w_mode, 4088 w_mode, 4089 w_mode, 4090 /* df */ 4091 w_mode, 4092 w_mode, 4093 w_mode, 4094 w_mode, 4095 t_mode, 4096 q_mode, 4097 t_mode, 4098 q_mode 4099 }; 4100 4101 #define ST { OP_ST, 0 } 4102 #define STi { OP_STi, 0 } 4103 4104 #define FGRPd9_2 NULL, { { NULL, 0 } } 4105 #define FGRPd9_4 NULL, { { NULL, 1 } } 4106 #define FGRPd9_5 NULL, { { NULL, 2 } } 4107 #define FGRPd9_6 NULL, { { NULL, 3 } } 4108 #define FGRPd9_7 NULL, { { NULL, 4 } } 4109 #define FGRPda_5 NULL, { { NULL, 5 } } 4110 #define FGRPdb_4 NULL, { { NULL, 6 } } 4111 #define FGRPde_3 NULL, { { NULL, 7 } } 4112 #define FGRPdf_4 NULL, { { NULL, 8 } } 4113 4114 static const struct dis386 float_reg[][8] = { 4115 /* d8 */ 4116 { 4117 { "fadd", { ST, STi } }, 4118 { "fmul", { ST, STi } }, 4119 { "fcom", { STi } }, 4120 { "fcomp", { STi } }, 4121 { "fsub", { ST, STi } }, 4122 { "fsubr", { ST, STi } }, 4123 { "fdiv", { ST, STi } }, 4124 { "fdivr", { ST, STi } }, 4125 }, 4126 /* d9 */ 4127 { 4128 { "fld", { STi } }, 4129 { "fxch", { STi } }, 4130 { FGRPd9_2 }, 4131 { "(bad)", { XX } }, 4132 { FGRPd9_4 }, 4133 { FGRPd9_5 }, 4134 { FGRPd9_6 }, 4135 { FGRPd9_7 }, 4136 }, 4137 /* da */ 4138 { 4139 { "fcmovb", { ST, STi } }, 4140 { "fcmove", { ST, STi } }, 4141 { "fcmovbe",{ ST, STi } }, 4142 { "fcmovu", { ST, STi } }, 4143 { "(bad)", { XX } }, 4144 { FGRPda_5 }, 4145 { "(bad)", { XX } }, 4146 { "(bad)", { XX } }, 4147 }, 4148 /* db */ 4149 { 4150 { "fcmovnb",{ ST, STi } }, 4151 { "fcmovne",{ ST, STi } }, 4152 { "fcmovnbe",{ ST, STi } }, 4153 { "fcmovnu",{ ST, STi } }, 4154 { FGRPdb_4 }, 4155 { "fucomi", { ST, STi } }, 4156 { "fcomi", { ST, STi } }, 4157 { "(bad)", { XX } }, 4158 }, 4159 /* dc */ 4160 { 4161 { "fadd", { STi, ST } }, 4162 { "fmul", { STi, ST } }, 4163 { "(bad)", { XX } }, 4164 { "(bad)", { XX } }, 4165 #if SYSV386_COMPAT 4166 { "fsub", { STi, ST } }, 4167 { "fsubr", { STi, ST } }, 4168 { "fdiv", { STi, ST } }, 4169 { "fdivr", { STi, ST } }, 4170 #else 4171 { "fsubr", { STi, ST } }, 4172 { "fsub", { STi, ST } }, 4173 { "fdivr", { STi, ST } }, 4174 { "fdiv", { STi, ST } }, 4175 #endif 4176 }, 4177 /* dd */ 4178 { 4179 { "ffree", { STi } }, 4180 { "(bad)", { XX } }, 4181 { "fst", { STi } }, 4182 { "fstp", { STi } }, 4183 { "fucom", { STi } }, 4184 { "fucomp", { STi } }, 4185 { "(bad)", { XX } }, 4186 { "(bad)", { XX } }, 4187 }, 4188 /* de */ 4189 { 4190 { "faddp", { STi, ST } }, 4191 { "fmulp", { STi, ST } }, 4192 { "(bad)", { XX } }, 4193 { FGRPde_3 }, 4194 #if SYSV386_COMPAT 4195 { "fsubp", { STi, ST } }, 4196 { "fsubrp", { STi, ST } }, 4197 { "fdivp", { STi, ST } }, 4198 { "fdivrp", { STi, ST } }, 4199 #else 4200 { "fsubrp", { STi, ST } }, 4201 { "fsubp", { STi, ST } }, 4202 { "fdivrp", { STi, ST } }, 4203 { "fdivp", { STi, ST } }, 4204 #endif 4205 }, 4206 /* df */ 4207 { 4208 { "ffreep", { STi } }, 4209 { "(bad)", { XX } }, 4210 { "(bad)", { XX } }, 4211 { "(bad)", { XX } }, 4212 { FGRPdf_4 }, 4213 { "fucomip", { ST, STi } }, 4214 { "fcomip", { ST, STi } }, 4215 { "(bad)", { XX } }, 4216 }, 4217 }; 4218 4219 static const char *fgrps[][8] = { 4220 /* d9_2 0 */ 4221 { 4222 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 4223 }, 4224 4225 /* d9_4 1 */ 4226 { 4227 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", 4228 }, 4229 4230 /* d9_5 2 */ 4231 { 4232 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", 4233 }, 4234 4235 /* d9_6 3 */ 4236 { 4237 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", 4238 }, 4239 4240 /* d9_7 4 */ 4241 { 4242 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", 4243 }, 4244 4245 /* da_5 5 */ 4246 { 4247 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 4248 }, 4249 4250 /* db_4 6 */ 4251 { 4252 "feni(287 only)","fdisi(287 only)","fNclex","fNinit", 4253 "fNsetpm(287 only)","(bad)","(bad)","(bad)", 4254 }, 4255 4256 /* de_3 7 */ 4257 { 4258 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 4259 }, 4260 4261 /* df_4 8 */ 4262 { 4263 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 4264 }, 4265 }; 4266 4267 static void 4268 dofloat (int sizeflag) 4269 { 4270 const struct dis386 *dp; 4271 unsigned char floatop; 4272 4273 floatop = codep[-1]; 4274 4275 if (modrm.mod != 3) 4276 { 4277 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg; 4278 4279 putop (float_mem[fp_indx], sizeflag); 4280 obufp = op_out[0]; 4281 op_ad = 2; 4282 OP_E (float_mem_mode[fp_indx], sizeflag); 4283 return; 4284 } 4285 /* Skip mod/rm byte. */ 4286 MODRM_CHECK; 4287 codep++; 4288 4289 dp = &float_reg[floatop - 0xd8][modrm.reg]; 4290 if (dp->name == NULL) 4291 { 4292 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag); 4293 4294 /* Instruction fnstsw is only one with strange arg. */ 4295 if (floatop == 0xdf && codep[-1] == 0xe0) 4296 pstrcpy (op_out[0], sizeof(op_out[0]), names16[0]); 4297 } 4298 else 4299 { 4300 putop (dp->name, sizeflag); 4301 4302 obufp = op_out[0]; 4303 op_ad = 2; 4304 if (dp->op[0].rtn) 4305 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag); 4306 4307 obufp = op_out[1]; 4308 op_ad = 1; 4309 if (dp->op[1].rtn) 4310 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag); 4311 } 4312 } 4313 4314 static void 4315 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 4316 { 4317 oappend ("%st" + intel_syntax); 4318 } 4319 4320 static void 4321 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 4322 { 4323 snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", modrm.rm); 4324 oappend (scratchbuf + intel_syntax); 4325 } 4326 4327 /* Capital letters in template are macros. */ 4328 static int 4329 putop (const char *template, int sizeflag) 4330 { 4331 const char *p; 4332 int alt = 0; 4333 4334 for (p = template; *p; p++) 4335 { 4336 switch (*p) 4337 { 4338 default: 4339 *obufp++ = *p; 4340 break; 4341 case '{': 4342 alt = 0; 4343 if (intel_syntax) 4344 alt += 1; 4345 if (address_mode == mode_64bit) 4346 alt += 2; 4347 while (alt != 0) 4348 { 4349 while (*++p != '|') 4350 { 4351 if (*p == '}') 4352 { 4353 /* Alternative not valid. */ 4354 pstrcpy (obuf, sizeof(obuf), "(bad)"); 4355 obufp = obuf + 5; 4356 return 1; 4357 } 4358 else if (*p == '\0') 4359 abort (); 4360 } 4361 alt--; 4362 } 4363 /* Fall through. */ 4364 case 'I': 4365 alt = 1; 4366 continue; 4367 case '|': 4368 while (*++p != '}') 4369 { 4370 if (*p == '\0') 4371 abort (); 4372 } 4373 break; 4374 case '}': 4375 break; 4376 case 'A': 4377 if (intel_syntax) 4378 break; 4379 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 4380 *obufp++ = 'b'; 4381 break; 4382 case 'B': 4383 if (intel_syntax) 4384 break; 4385 if (sizeflag & SUFFIX_ALWAYS) 4386 *obufp++ = 'b'; 4387 break; 4388 case 'C': 4389 if (intel_syntax && !alt) 4390 break; 4391 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS)) 4392 { 4393 if (sizeflag & DFLAG) 4394 *obufp++ = intel_syntax ? 'd' : 'l'; 4395 else 4396 *obufp++ = intel_syntax ? 'w' : 's'; 4397 used_prefixes |= (prefixes & PREFIX_DATA); 4398 } 4399 break; 4400 case 'D': 4401 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS)) 4402 break; 4403 USED_REX (REX_W); 4404 if (modrm.mod == 3) 4405 { 4406 if (rex & REX_W) 4407 *obufp++ = 'q'; 4408 else if (sizeflag & DFLAG) 4409 *obufp++ = intel_syntax ? 'd' : 'l'; 4410 else 4411 *obufp++ = 'w'; 4412 used_prefixes |= (prefixes & PREFIX_DATA); 4413 } 4414 else 4415 *obufp++ = 'w'; 4416 break; 4417 case 'E': /* For jcxz/jecxz */ 4418 if (address_mode == mode_64bit) 4419 { 4420 if (sizeflag & AFLAG) 4421 *obufp++ = 'r'; 4422 else 4423 *obufp++ = 'e'; 4424 } 4425 else 4426 if (sizeflag & AFLAG) 4427 *obufp++ = 'e'; 4428 used_prefixes |= (prefixes & PREFIX_ADDR); 4429 break; 4430 case 'F': 4431 if (intel_syntax) 4432 break; 4433 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) 4434 { 4435 if (sizeflag & AFLAG) 4436 *obufp++ = address_mode == mode_64bit ? 'q' : 'l'; 4437 else 4438 *obufp++ = address_mode == mode_64bit ? 'l' : 'w'; 4439 used_prefixes |= (prefixes & PREFIX_ADDR); 4440 } 4441 break; 4442 case 'G': 4443 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS))) 4444 break; 4445 if ((rex & REX_W) || (sizeflag & DFLAG)) 4446 *obufp++ = 'l'; 4447 else 4448 *obufp++ = 'w'; 4449 if (!(rex & REX_W)) 4450 used_prefixes |= (prefixes & PREFIX_DATA); 4451 break; 4452 case 'H': 4453 if (intel_syntax) 4454 break; 4455 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS 4456 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) 4457 { 4458 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); 4459 *obufp++ = ','; 4460 *obufp++ = 'p'; 4461 if (prefixes & PREFIX_DS) 4462 *obufp++ = 't'; 4463 else 4464 *obufp++ = 'n'; 4465 } 4466 break; 4467 case 'J': 4468 if (intel_syntax) 4469 break; 4470 *obufp++ = 'l'; 4471 break; 4472 case 'K': 4473 USED_REX (REX_W); 4474 if (rex & REX_W) 4475 *obufp++ = 'q'; 4476 else 4477 *obufp++ = 'd'; 4478 break; 4479 case 'Z': 4480 if (intel_syntax) 4481 break; 4482 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS)) 4483 { 4484 *obufp++ = 'q'; 4485 break; 4486 } 4487 /* Fall through. */ 4488 case 'L': 4489 if (intel_syntax) 4490 break; 4491 if (sizeflag & SUFFIX_ALWAYS) 4492 *obufp++ = 'l'; 4493 break; 4494 case 'N': 4495 if ((prefixes & PREFIX_FWAIT) == 0) 4496 *obufp++ = 'n'; 4497 else 4498 used_prefixes |= PREFIX_FWAIT; 4499 break; 4500 case 'O': 4501 USED_REX (REX_W); 4502 if (rex & REX_W) 4503 *obufp++ = 'o'; 4504 else if (intel_syntax && (sizeflag & DFLAG)) 4505 *obufp++ = 'q'; 4506 else 4507 *obufp++ = 'd'; 4508 if (!(rex & REX_W)) 4509 used_prefixes |= (prefixes & PREFIX_DATA); 4510 break; 4511 case 'T': 4512 if (intel_syntax) 4513 break; 4514 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4515 { 4516 *obufp++ = 'q'; 4517 break; 4518 } 4519 /* Fall through. */ 4520 case 'P': 4521 if (intel_syntax) 4522 break; 4523 if ((prefixes & PREFIX_DATA) 4524 || (rex & REX_W) 4525 || (sizeflag & SUFFIX_ALWAYS)) 4526 { 4527 USED_REX (REX_W); 4528 if (rex & REX_W) 4529 *obufp++ = 'q'; 4530 else 4531 { 4532 if (sizeflag & DFLAG) 4533 *obufp++ = 'l'; 4534 else 4535 *obufp++ = 'w'; 4536 } 4537 used_prefixes |= (prefixes & PREFIX_DATA); 4538 } 4539 break; 4540 case 'U': 4541 if (intel_syntax) 4542 break; 4543 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4544 { 4545 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 4546 *obufp++ = 'q'; 4547 break; 4548 } 4549 /* Fall through. */ 4550 case 'Q': 4551 if (intel_syntax && !alt) 4552 break; 4553 USED_REX (REX_W); 4554 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 4555 { 4556 if (rex & REX_W) 4557 *obufp++ = 'q'; 4558 else 4559 { 4560 if (sizeflag & DFLAG) 4561 *obufp++ = intel_syntax ? 'd' : 'l'; 4562 else 4563 *obufp++ = 'w'; 4564 } 4565 used_prefixes |= (prefixes & PREFIX_DATA); 4566 } 4567 break; 4568 case 'R': 4569 USED_REX (REX_W); 4570 if (rex & REX_W) 4571 *obufp++ = 'q'; 4572 else if (sizeflag & DFLAG) 4573 { 4574 if (intel_syntax) 4575 *obufp++ = 'd'; 4576 else 4577 *obufp++ = 'l'; 4578 } 4579 else 4580 *obufp++ = 'w'; 4581 if (intel_syntax && !p[1] 4582 && ((rex & REX_W) || (sizeflag & DFLAG))) 4583 *obufp++ = 'e'; 4584 if (!(rex & REX_W)) 4585 used_prefixes |= (prefixes & PREFIX_DATA); 4586 break; 4587 case 'V': 4588 if (intel_syntax) 4589 break; 4590 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4591 { 4592 if (sizeflag & SUFFIX_ALWAYS) 4593 *obufp++ = 'q'; 4594 break; 4595 } 4596 /* Fall through. */ 4597 case 'S': 4598 if (intel_syntax) 4599 break; 4600 if (sizeflag & SUFFIX_ALWAYS) 4601 { 4602 if (rex & REX_W) 4603 *obufp++ = 'q'; 4604 else 4605 { 4606 if (sizeflag & DFLAG) 4607 *obufp++ = 'l'; 4608 else 4609 *obufp++ = 'w'; 4610 used_prefixes |= (prefixes & PREFIX_DATA); 4611 } 4612 } 4613 break; 4614 case 'X': 4615 if (prefixes & PREFIX_DATA) 4616 *obufp++ = 'd'; 4617 else 4618 *obufp++ = 's'; 4619 used_prefixes |= (prefixes & PREFIX_DATA); 4620 break; 4621 case 'Y': 4622 if (intel_syntax) 4623 break; 4624 if (rex & REX_W) 4625 { 4626 USED_REX (REX_W); 4627 *obufp++ = 'q'; 4628 } 4629 break; 4630 /* implicit operand size 'l' for i386 or 'q' for x86-64 */ 4631 case 'W': 4632 /* operand size flag for cwtl, cbtw */ 4633 USED_REX (REX_W); 4634 if (rex & REX_W) 4635 { 4636 if (intel_syntax) 4637 *obufp++ = 'd'; 4638 else 4639 *obufp++ = 'l'; 4640 } 4641 else if (sizeflag & DFLAG) 4642 *obufp++ = 'w'; 4643 else 4644 *obufp++ = 'b'; 4645 if (!(rex & REX_W)) 4646 used_prefixes |= (prefixes & PREFIX_DATA); 4647 break; 4648 } 4649 alt = 0; 4650 } 4651 *obufp = 0; 4652 return 0; 4653 } 4654 4655 static void 4656 oappend (const char *s) 4657 { 4658 strcpy (obufp, s); 4659 obufp += strlen (s); 4660 } 4661 4662 static void 4663 append_seg (void) 4664 { 4665 if (prefixes & PREFIX_CS) 4666 { 4667 used_prefixes |= PREFIX_CS; 4668 oappend ("%cs:" + intel_syntax); 4669 } 4670 if (prefixes & PREFIX_DS) 4671 { 4672 used_prefixes |= PREFIX_DS; 4673 oappend ("%ds:" + intel_syntax); 4674 } 4675 if (prefixes & PREFIX_SS) 4676 { 4677 used_prefixes |= PREFIX_SS; 4678 oappend ("%ss:" + intel_syntax); 4679 } 4680 if (prefixes & PREFIX_ES) 4681 { 4682 used_prefixes |= PREFIX_ES; 4683 oappend ("%es:" + intel_syntax); 4684 } 4685 if (prefixes & PREFIX_FS) 4686 { 4687 used_prefixes |= PREFIX_FS; 4688 oappend ("%fs:" + intel_syntax); 4689 } 4690 if (prefixes & PREFIX_GS) 4691 { 4692 used_prefixes |= PREFIX_GS; 4693 oappend ("%gs:" + intel_syntax); 4694 } 4695 } 4696 4697 static void 4698 OP_indirE (int bytemode, int sizeflag) 4699 { 4700 if (!intel_syntax) 4701 oappend ("*"); 4702 OP_E (bytemode, sizeflag); 4703 } 4704 4705 static void 4706 print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp) 4707 { 4708 if (address_mode == mode_64bit) 4709 { 4710 if (hex) 4711 { 4712 char tmp[30]; 4713 int i; 4714 buf[0] = '0'; 4715 buf[1] = 'x'; 4716 snprintf_vma (tmp, sizeof(tmp), disp); 4717 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); 4718 pstrcpy (buf + 2, bufsize - 2, tmp + i); 4719 } 4720 else 4721 { 4722 bfd_signed_vma v = disp; 4723 char tmp[30]; 4724 int i; 4725 if (v < 0) 4726 { 4727 *(buf++) = '-'; 4728 v = -disp; 4729 /* Check for possible overflow on 0x8000000000000000. */ 4730 if (v < 0) 4731 { 4732 pstrcpy (buf, bufsize, "9223372036854775808"); 4733 return; 4734 } 4735 } 4736 if (!v) 4737 { 4738 pstrcpy (buf, bufsize, "0"); 4739 return; 4740 } 4741 4742 i = 0; 4743 tmp[29] = 0; 4744 while (v) 4745 { 4746 tmp[28 - i] = (v % 10) + '0'; 4747 v /= 10; 4748 i++; 4749 } 4750 pstrcpy (buf, bufsize, tmp + 29 - i); 4751 } 4752 } 4753 else 4754 { 4755 if (hex) 4756 snprintf (buf, bufsize, "0x%x", (unsigned int) disp); 4757 else 4758 snprintf (buf, bufsize, "%d", (int) disp); 4759 } 4760 } 4761 4762 /* Put DISP in BUF as signed hex number. */ 4763 4764 static void 4765 print_displacement (char *buf, bfd_vma disp) 4766 { 4767 bfd_signed_vma val = disp; 4768 char tmp[30]; 4769 int i, j = 0; 4770 4771 if (val < 0) 4772 { 4773 buf[j++] = '-'; 4774 val = -disp; 4775 4776 /* Check for possible overflow. */ 4777 if (val < 0) 4778 { 4779 switch (address_mode) 4780 { 4781 case mode_64bit: 4782 strcpy (buf + j, "0x8000000000000000"); 4783 break; 4784 case mode_32bit: 4785 strcpy (buf + j, "0x80000000"); 4786 break; 4787 case mode_16bit: 4788 strcpy (buf + j, "0x8000"); 4789 break; 4790 } 4791 return; 4792 } 4793 } 4794 4795 buf[j++] = '0'; 4796 buf[j++] = 'x'; 4797 4798 snprintf_vma (tmp, sizeof(tmp), val); 4799 for (i = 0; tmp[i] == '0'; i++) 4800 continue; 4801 if (tmp[i] == '\0') 4802 i--; 4803 strcpy (buf + j, tmp + i); 4804 } 4805 4806 static void 4807 intel_operand_size (int bytemode, int sizeflag) 4808 { 4809 switch (bytemode) 4810 { 4811 case b_mode: 4812 case dqb_mode: 4813 oappend ("BYTE PTR "); 4814 break; 4815 case w_mode: 4816 case dqw_mode: 4817 oappend ("WORD PTR "); 4818 break; 4819 case stack_v_mode: 4820 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4821 { 4822 oappend ("QWORD PTR "); 4823 used_prefixes |= (prefixes & PREFIX_DATA); 4824 break; 4825 } 4826 /* FALLTHRU */ 4827 case v_mode: 4828 case dq_mode: 4829 USED_REX (REX_W); 4830 if (rex & REX_W) 4831 oappend ("QWORD PTR "); 4832 else if ((sizeflag & DFLAG) || bytemode == dq_mode) 4833 oappend ("DWORD PTR "); 4834 else 4835 oappend ("WORD PTR "); 4836 used_prefixes |= (prefixes & PREFIX_DATA); 4837 break; 4838 case z_mode: 4839 if ((rex & REX_W) || (sizeflag & DFLAG)) 4840 *obufp++ = 'D'; 4841 oappend ("WORD PTR "); 4842 if (!(rex & REX_W)) 4843 used_prefixes |= (prefixes & PREFIX_DATA); 4844 break; 4845 case d_mode: 4846 case dqd_mode: 4847 oappend ("DWORD PTR "); 4848 break; 4849 case q_mode: 4850 oappend ("QWORD PTR "); 4851 break; 4852 case m_mode: 4853 if (address_mode == mode_64bit) 4854 oappend ("QWORD PTR "); 4855 else 4856 oappend ("DWORD PTR "); 4857 break; 4858 case f_mode: 4859 if (sizeflag & DFLAG) 4860 oappend ("FWORD PTR "); 4861 else 4862 oappend ("DWORD PTR "); 4863 used_prefixes |= (prefixes & PREFIX_DATA); 4864 break; 4865 case t_mode: 4866 oappend ("TBYTE PTR "); 4867 break; 4868 case x_mode: 4869 oappend ("XMMWORD PTR "); 4870 break; 4871 case o_mode: 4872 oappend ("OWORD PTR "); 4873 break; 4874 default: 4875 break; 4876 } 4877 } 4878 4879 static void 4880 OP_E (int bytemode, int sizeflag) 4881 { 4882 bfd_vma disp; 4883 int add = 0; 4884 int riprel = 0; 4885 USED_REX (REX_B); 4886 if (rex & REX_B) 4887 add += 8; 4888 4889 /* Skip mod/rm byte. */ 4890 MODRM_CHECK; 4891 codep++; 4892 4893 if (modrm.mod == 3) 4894 { 4895 switch (bytemode) 4896 { 4897 case b_mode: 4898 USED_REX (0); 4899 if (rex) 4900 oappend (names8rex[modrm.rm + add]); 4901 else 4902 oappend (names8[modrm.rm + add]); 4903 break; 4904 case w_mode: 4905 oappend (names16[modrm.rm + add]); 4906 break; 4907 case d_mode: 4908 oappend (names32[modrm.rm + add]); 4909 break; 4910 case q_mode: 4911 oappend (names64[modrm.rm + add]); 4912 break; 4913 case m_mode: 4914 if (address_mode == mode_64bit) 4915 oappend (names64[modrm.rm + add]); 4916 else 4917 oappend (names32[modrm.rm + add]); 4918 break; 4919 case stack_v_mode: 4920 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4921 { 4922 oappend (names64[modrm.rm + add]); 4923 used_prefixes |= (prefixes & PREFIX_DATA); 4924 break; 4925 } 4926 bytemode = v_mode; 4927 /* FALLTHRU */ 4928 case v_mode: 4929 case dq_mode: 4930 case dqb_mode: 4931 case dqd_mode: 4932 case dqw_mode: 4933 USED_REX (REX_W); 4934 if (rex & REX_W) 4935 oappend (names64[modrm.rm + add]); 4936 else if ((sizeflag & DFLAG) || bytemode != v_mode) 4937 oappend (names32[modrm.rm + add]); 4938 else 4939 oappend (names16[modrm.rm + add]); 4940 used_prefixes |= (prefixes & PREFIX_DATA); 4941 break; 4942 case 0: 4943 break; 4944 default: 4945 oappend (INTERNAL_DISASSEMBLER_ERROR); 4946 break; 4947 } 4948 return; 4949 } 4950 4951 disp = 0; 4952 if (intel_syntax) 4953 intel_operand_size (bytemode, sizeflag); 4954 append_seg (); 4955 4956 if ((sizeflag & AFLAG) || address_mode == mode_64bit) 4957 { 4958 /* 32/64 bit address mode */ 4959 int havedisp; 4960 int havesib; 4961 int havebase; 4962 int base; 4963 int index = 0; 4964 int scale = 0; 4965 4966 havesib = 0; 4967 havebase = 1; 4968 base = modrm.rm; 4969 4970 if (base == 4) 4971 { 4972 havesib = 1; 4973 FETCH_DATA (the_info, codep + 1); 4974 index = (*codep >> 3) & 7; 4975 if (address_mode == mode_64bit || index != 0x4) 4976 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */ 4977 scale = (*codep >> 6) & 3; 4978 base = *codep & 7; 4979 USED_REX (REX_X); 4980 if (rex & REX_X) 4981 index += 8; 4982 codep++; 4983 } 4984 base += add; 4985 4986 switch (modrm.mod) 4987 { 4988 case 0: 4989 if ((base & 7) == 5) 4990 { 4991 havebase = 0; 4992 if (address_mode == mode_64bit && !havesib) 4993 riprel = 1; 4994 disp = get32s (); 4995 } 4996 break; 4997 case 1: 4998 FETCH_DATA (the_info, codep + 1); 4999 disp = *codep++; 5000 if ((disp & 0x80) != 0) 5001 disp -= 0x100; 5002 break; 5003 case 2: 5004 disp = get32s (); 5005 break; 5006 } 5007 5008 havedisp = havebase || (havesib && (index != 4 || scale != 0)); 5009 5010 if (!intel_syntax) 5011 if (modrm.mod != 0 || (base & 7) == 5) 5012 { 5013 if (havedisp || riprel) 5014 print_displacement (scratchbuf, disp); 5015 else 5016 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); 5017 oappend (scratchbuf); 5018 if (riprel) 5019 { 5020 set_op (disp, 1); 5021 oappend ("(%rip)"); 5022 } 5023 } 5024 5025 if (havedisp || (intel_syntax && riprel)) 5026 { 5027 *obufp++ = open_char; 5028 if (intel_syntax && riprel) 5029 { 5030 set_op (disp, 1); 5031 oappend ("rip"); 5032 } 5033 *obufp = '\0'; 5034 if (havebase) 5035 oappend (address_mode == mode_64bit && (sizeflag & AFLAG) 5036 ? names64[base] : names32[base]); 5037 if (havesib) 5038 { 5039 if (index != 4) 5040 { 5041 if (!intel_syntax || havebase) 5042 { 5043 *obufp++ = separator_char; 5044 *obufp = '\0'; 5045 } 5046 oappend (address_mode == mode_64bit && (sizeflag & AFLAG) 5047 ? names64[index] : names32[index]); 5048 } 5049 if (scale != 0 || (!intel_syntax && index != 4)) 5050 { 5051 *obufp++ = scale_char; 5052 *obufp = '\0'; 5053 snprintf (scratchbuf, sizeof(scratchbuf), "%d", 1 << scale); 5054 oappend (scratchbuf); 5055 } 5056 } 5057 if (intel_syntax 5058 && (disp || modrm.mod != 0 || (base & 7) == 5)) 5059 { 5060 if ((bfd_signed_vma) disp >= 0) 5061 { 5062 *obufp++ = '+'; 5063 *obufp = '\0'; 5064 } 5065 else if (modrm.mod != 1) 5066 { 5067 *obufp++ = '-'; 5068 *obufp = '\0'; 5069 disp = - (bfd_signed_vma) disp; 5070 } 5071 5072 print_displacement (scratchbuf, disp); 5073 oappend (scratchbuf); 5074 } 5075 5076 *obufp++ = close_char; 5077 *obufp = '\0'; 5078 } 5079 else if (intel_syntax) 5080 { 5081 if (modrm.mod != 0 || (base & 7) == 5) 5082 { 5083 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5084 | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 5085 ; 5086 else 5087 { 5088 oappend (names_seg[ds_reg - es_reg]); 5089 oappend (":"); 5090 } 5091 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); 5092 oappend (scratchbuf); 5093 } 5094 } 5095 } 5096 else 5097 { /* 16 bit address mode */ 5098 switch (modrm.mod) 5099 { 5100 case 0: 5101 if (modrm.rm == 6) 5102 { 5103 disp = get16 (); 5104 if ((disp & 0x8000) != 0) 5105 disp -= 0x10000; 5106 } 5107 break; 5108 case 1: 5109 FETCH_DATA (the_info, codep + 1); 5110 disp = *codep++; 5111 if ((disp & 0x80) != 0) 5112 disp -= 0x100; 5113 break; 5114 case 2: 5115 disp = get16 (); 5116 if ((disp & 0x8000) != 0) 5117 disp -= 0x10000; 5118 break; 5119 } 5120 5121 if (!intel_syntax) 5122 if (modrm.mod != 0 || modrm.rm == 6) 5123 { 5124 print_displacement (scratchbuf, disp); 5125 oappend (scratchbuf); 5126 } 5127 5128 if (modrm.mod != 0 || modrm.rm != 6) 5129 { 5130 *obufp++ = open_char; 5131 *obufp = '\0'; 5132 oappend (index16[modrm.rm]); 5133 if (intel_syntax 5134 && (disp || modrm.mod != 0 || modrm.rm == 6)) 5135 { 5136 if ((bfd_signed_vma) disp >= 0) 5137 { 5138 *obufp++ = '+'; 5139 *obufp = '\0'; 5140 } 5141 else if (modrm.mod != 1) 5142 { 5143 *obufp++ = '-'; 5144 *obufp = '\0'; 5145 disp = - (bfd_signed_vma) disp; 5146 } 5147 5148 print_displacement (scratchbuf, disp); 5149 oappend (scratchbuf); 5150 } 5151 5152 *obufp++ = close_char; 5153 *obufp = '\0'; 5154 } 5155 else if (intel_syntax) 5156 { 5157 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5158 | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 5159 ; 5160 else 5161 { 5162 oappend (names_seg[ds_reg - es_reg]); 5163 oappend (":"); 5164 } 5165 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, 5166 disp & 0xffff); 5167 oappend (scratchbuf); 5168 } 5169 } 5170 } 5171 5172 static void 5173 OP_G (int bytemode, int sizeflag) 5174 { 5175 int add = 0; 5176 USED_REX (REX_R); 5177 if (rex & REX_R) 5178 add += 8; 5179 switch (bytemode) 5180 { 5181 case b_mode: 5182 USED_REX (0); 5183 if (rex) 5184 oappend (names8rex[modrm.reg + add]); 5185 else 5186 oappend (names8[modrm.reg + add]); 5187 break; 5188 case w_mode: 5189 oappend (names16[modrm.reg + add]); 5190 break; 5191 case d_mode: 5192 oappend (names32[modrm.reg + add]); 5193 break; 5194 case q_mode: 5195 oappend (names64[modrm.reg + add]); 5196 break; 5197 case v_mode: 5198 case dq_mode: 5199 case dqb_mode: 5200 case dqd_mode: 5201 case dqw_mode: 5202 USED_REX (REX_W); 5203 if (rex & REX_W) 5204 oappend (names64[modrm.reg + add]); 5205 else if ((sizeflag & DFLAG) || bytemode != v_mode) 5206 oappend (names32[modrm.reg + add]); 5207 else 5208 oappend (names16[modrm.reg + add]); 5209 used_prefixes |= (prefixes & PREFIX_DATA); 5210 break; 5211 case m_mode: 5212 if (address_mode == mode_64bit) 5213 oappend (names64[modrm.reg + add]); 5214 else 5215 oappend (names32[modrm.reg + add]); 5216 break; 5217 default: 5218 oappend (INTERNAL_DISASSEMBLER_ERROR); 5219 break; 5220 } 5221 } 5222 5223 static bfd_vma 5224 get64 (void) 5225 { 5226 bfd_vma x; 5227 #ifdef BFD64 5228 unsigned int a; 5229 unsigned int b; 5230 5231 FETCH_DATA (the_info, codep + 8); 5232 a = *codep++ & 0xff; 5233 a |= (*codep++ & 0xff) << 8; 5234 a |= (*codep++ & 0xff) << 16; 5235 a |= (*codep++ & 0xff) << 24; 5236 b = *codep++ & 0xff; 5237 b |= (*codep++ & 0xff) << 8; 5238 b |= (*codep++ & 0xff) << 16; 5239 b |= (*codep++ & 0xff) << 24; 5240 x = a + ((bfd_vma) b << 32); 5241 #else 5242 abort (); 5243 x = 0; 5244 #endif 5245 return x; 5246 } 5247 5248 static bfd_signed_vma 5249 get32 (void) 5250 { 5251 bfd_signed_vma x = 0; 5252 5253 FETCH_DATA (the_info, codep + 4); 5254 x = *codep++ & (bfd_signed_vma) 0xff; 5255 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 5256 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 5257 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 5258 return x; 5259 } 5260 5261 static bfd_signed_vma 5262 get32s (void) 5263 { 5264 bfd_signed_vma x = 0; 5265 5266 FETCH_DATA (the_info, codep + 4); 5267 x = *codep++ & (bfd_signed_vma) 0xff; 5268 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 5269 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 5270 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 5271 5272 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); 5273 5274 return x; 5275 } 5276 5277 static int 5278 get16 (void) 5279 { 5280 int x = 0; 5281 5282 FETCH_DATA (the_info, codep + 2); 5283 x = *codep++ & 0xff; 5284 x |= (*codep++ & 0xff) << 8; 5285 return x; 5286 } 5287 5288 static void 5289 set_op (bfd_vma op, int riprel) 5290 { 5291 op_index[op_ad] = op_ad; 5292 if (address_mode == mode_64bit) 5293 { 5294 op_address[op_ad] = op; 5295 op_riprel[op_ad] = riprel; 5296 } 5297 else 5298 { 5299 /* Mask to get a 32-bit address. */ 5300 op_address[op_ad] = op & 0xffffffff; 5301 op_riprel[op_ad] = riprel & 0xffffffff; 5302 } 5303 } 5304 5305 static void 5306 OP_REG (int code, int sizeflag) 5307 { 5308 const char *s; 5309 int add = 0; 5310 USED_REX (REX_B); 5311 if (rex & REX_B) 5312 add = 8; 5313 5314 switch (code) 5315 { 5316 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 5317 case sp_reg: case bp_reg: case si_reg: case di_reg: 5318 s = names16[code - ax_reg + add]; 5319 break; 5320 case es_reg: case ss_reg: case cs_reg: 5321 case ds_reg: case fs_reg: case gs_reg: 5322 s = names_seg[code - es_reg + add]; 5323 break; 5324 case al_reg: case ah_reg: case cl_reg: case ch_reg: 5325 case dl_reg: case dh_reg: case bl_reg: case bh_reg: 5326 USED_REX (0); 5327 if (rex) 5328 s = names8rex[code - al_reg + add]; 5329 else 5330 s = names8[code - al_reg]; 5331 break; 5332 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: 5333 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: 5334 if (address_mode == mode_64bit && (sizeflag & DFLAG)) 5335 { 5336 s = names64[code - rAX_reg + add]; 5337 break; 5338 } 5339 code += eAX_reg - rAX_reg; 5340 /* Fall through. */ 5341 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 5342 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 5343 USED_REX (REX_W); 5344 if (rex & REX_W) 5345 s = names64[code - eAX_reg + add]; 5346 else if (sizeflag & DFLAG) 5347 s = names32[code - eAX_reg + add]; 5348 else 5349 s = names16[code - eAX_reg + add]; 5350 used_prefixes |= (prefixes & PREFIX_DATA); 5351 break; 5352 default: 5353 s = INTERNAL_DISASSEMBLER_ERROR; 5354 break; 5355 } 5356 oappend (s); 5357 } 5358 5359 static void 5360 OP_IMREG (int code, int sizeflag) 5361 { 5362 const char *s; 5363 5364 switch (code) 5365 { 5366 case indir_dx_reg: 5367 if (intel_syntax) 5368 s = "dx"; 5369 else 5370 s = "(%dx)"; 5371 break; 5372 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 5373 case sp_reg: case bp_reg: case si_reg: case di_reg: 5374 s = names16[code - ax_reg]; 5375 break; 5376 case es_reg: case ss_reg: case cs_reg: 5377 case ds_reg: case fs_reg: case gs_reg: 5378 s = names_seg[code - es_reg]; 5379 break; 5380 case al_reg: case ah_reg: case cl_reg: case ch_reg: 5381 case dl_reg: case dh_reg: case bl_reg: case bh_reg: 5382 USED_REX (0); 5383 if (rex) 5384 s = names8rex[code - al_reg]; 5385 else 5386 s = names8[code - al_reg]; 5387 break; 5388 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 5389 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 5390 USED_REX (REX_W); 5391 if (rex & REX_W) 5392 s = names64[code - eAX_reg]; 5393 else if (sizeflag & DFLAG) 5394 s = names32[code - eAX_reg]; 5395 else 5396 s = names16[code - eAX_reg]; 5397 used_prefixes |= (prefixes & PREFIX_DATA); 5398 break; 5399 case z_mode_ax_reg: 5400 if ((rex & REX_W) || (sizeflag & DFLAG)) 5401 s = *names32; 5402 else 5403 s = *names16; 5404 if (!(rex & REX_W)) 5405 used_prefixes |= (prefixes & PREFIX_DATA); 5406 break; 5407 default: 5408 s = INTERNAL_DISASSEMBLER_ERROR; 5409 break; 5410 } 5411 oappend (s); 5412 } 5413 5414 static void 5415 OP_I (int bytemode, int sizeflag) 5416 { 5417 bfd_signed_vma op; 5418 bfd_signed_vma mask = -1; 5419 5420 switch (bytemode) 5421 { 5422 case b_mode: 5423 FETCH_DATA (the_info, codep + 1); 5424 op = *codep++; 5425 mask = 0xff; 5426 break; 5427 case q_mode: 5428 if (address_mode == mode_64bit) 5429 { 5430 op = get32s (); 5431 break; 5432 } 5433 /* Fall through. */ 5434 case v_mode: 5435 USED_REX (REX_W); 5436 if (rex & REX_W) 5437 op = get32s (); 5438 else if (sizeflag & DFLAG) 5439 { 5440 op = get32 (); 5441 mask = 0xffffffff; 5442 } 5443 else 5444 { 5445 op = get16 (); 5446 mask = 0xfffff; 5447 } 5448 used_prefixes |= (prefixes & PREFIX_DATA); 5449 break; 5450 case w_mode: 5451 mask = 0xfffff; 5452 op = get16 (); 5453 break; 5454 case const_1_mode: 5455 if (intel_syntax) 5456 oappend ("1"); 5457 return; 5458 default: 5459 oappend (INTERNAL_DISASSEMBLER_ERROR); 5460 return; 5461 } 5462 5463 op &= mask; 5464 scratchbuf[0] = '$'; 5465 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); 5466 oappend (scratchbuf + intel_syntax); 5467 scratchbuf[0] = '\0'; 5468 } 5469 5470 static void 5471 OP_I64 (int bytemode, int sizeflag) 5472 { 5473 bfd_signed_vma op; 5474 bfd_signed_vma mask = -1; 5475 5476 if (address_mode != mode_64bit) 5477 { 5478 OP_I (bytemode, sizeflag); 5479 return; 5480 } 5481 5482 switch (bytemode) 5483 { 5484 case b_mode: 5485 FETCH_DATA (the_info, codep + 1); 5486 op = *codep++; 5487 mask = 0xff; 5488 break; 5489 case v_mode: 5490 USED_REX (REX_W); 5491 if (rex & REX_W) 5492 op = get64 (); 5493 else if (sizeflag & DFLAG) 5494 { 5495 op = get32 (); 5496 mask = 0xffffffff; 5497 } 5498 else 5499 { 5500 op = get16 (); 5501 mask = 0xfffff; 5502 } 5503 used_prefixes |= (prefixes & PREFIX_DATA); 5504 break; 5505 case w_mode: 5506 mask = 0xfffff; 5507 op = get16 (); 5508 break; 5509 default: 5510 oappend (INTERNAL_DISASSEMBLER_ERROR); 5511 return; 5512 } 5513 5514 op &= mask; 5515 scratchbuf[0] = '$'; 5516 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); 5517 oappend (scratchbuf + intel_syntax); 5518 scratchbuf[0] = '\0'; 5519 } 5520 5521 static void 5522 OP_sI (int bytemode, int sizeflag) 5523 { 5524 bfd_signed_vma op; 5525 bfd_signed_vma mask = -1; 5526 5527 switch (bytemode) 5528 { 5529 case b_mode: 5530 FETCH_DATA (the_info, codep + 1); 5531 op = *codep++; 5532 if ((op & 0x80) != 0) 5533 op -= 0x100; 5534 mask = 0xffffffff; 5535 break; 5536 case v_mode: 5537 USED_REX (REX_W); 5538 if (rex & REX_W) 5539 op = get32s (); 5540 else if (sizeflag & DFLAG) 5541 { 5542 op = get32s (); 5543 mask = 0xffffffff; 5544 } 5545 else 5546 { 5547 mask = 0xffffffff; 5548 op = get16 (); 5549 if ((op & 0x8000) != 0) 5550 op -= 0x10000; 5551 } 5552 used_prefixes |= (prefixes & PREFIX_DATA); 5553 break; 5554 case w_mode: 5555 op = get16 (); 5556 mask = 0xffffffff; 5557 if ((op & 0x8000) != 0) 5558 op -= 0x10000; 5559 break; 5560 default: 5561 oappend (INTERNAL_DISASSEMBLER_ERROR); 5562 return; 5563 } 5564 5565 scratchbuf[0] = '$'; 5566 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op); 5567 oappend (scratchbuf + intel_syntax); 5568 } 5569 5570 static void 5571 OP_J (int bytemode, int sizeflag) 5572 { 5573 bfd_vma disp; 5574 bfd_vma mask = -1; 5575 bfd_vma segment = 0; 5576 5577 switch (bytemode) 5578 { 5579 case b_mode: 5580 FETCH_DATA (the_info, codep + 1); 5581 disp = *codep++; 5582 if ((disp & 0x80) != 0) 5583 disp -= 0x100; 5584 break; 5585 case v_mode: 5586 if ((sizeflag & DFLAG) || (rex & REX_W)) 5587 disp = get32s (); 5588 else 5589 { 5590 disp = get16 (); 5591 if ((disp & 0x8000) != 0) 5592 disp -= 0x10000; 5593 /* In 16bit mode, address is wrapped around at 64k within 5594 the same segment. Otherwise, a data16 prefix on a jump 5595 instruction means that the pc is masked to 16 bits after 5596 the displacement is added! */ 5597 mask = 0xffff; 5598 if ((prefixes & PREFIX_DATA) == 0) 5599 segment = ((start_pc + codep - start_codep) 5600 & ~((bfd_vma) 0xffff)); 5601 } 5602 used_prefixes |= (prefixes & PREFIX_DATA); 5603 break; 5604 default: 5605 oappend (INTERNAL_DISASSEMBLER_ERROR); 5606 return; 5607 } 5608 disp = ((start_pc + codep - start_codep + disp) & mask) | segment; 5609 set_op (disp, 0); 5610 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp); 5611 oappend (scratchbuf); 5612 } 5613 5614 static void 5615 OP_SEG (int bytemode, int sizeflag) 5616 { 5617 if (bytemode == w_mode) 5618 oappend (names_seg[modrm.reg]); 5619 else 5620 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag); 5621 } 5622 5623 static void 5624 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag) 5625 { 5626 int seg, offset; 5627 5628 if (sizeflag & DFLAG) 5629 { 5630 offset = get32 (); 5631 seg = get16 (); 5632 } 5633 else 5634 { 5635 offset = get16 (); 5636 seg = get16 (); 5637 } 5638 used_prefixes |= (prefixes & PREFIX_DATA); 5639 if (intel_syntax) 5640 snprintf (scratchbuf, sizeof(scratchbuf), "0x%x:0x%x", seg, offset); 5641 else 5642 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset); 5643 oappend (scratchbuf); 5644 } 5645 5646 static void 5647 OP_OFF (int bytemode, int sizeflag) 5648 { 5649 bfd_vma off; 5650 5651 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 5652 intel_operand_size (bytemode, sizeflag); 5653 append_seg (); 5654 5655 if ((sizeflag & AFLAG) || address_mode == mode_64bit) 5656 off = get32 (); 5657 else 5658 off = get16 (); 5659 5660 if (intel_syntax) 5661 { 5662 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5663 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 5664 { 5665 oappend (names_seg[ds_reg - es_reg]); 5666 oappend (":"); 5667 } 5668 } 5669 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off); 5670 oappend (scratchbuf); 5671 } 5672 5673 static void 5674 OP_OFF64 (int bytemode, int sizeflag) 5675 { 5676 bfd_vma off; 5677 5678 if (address_mode != mode_64bit 5679 || (prefixes & PREFIX_ADDR)) 5680 { 5681 OP_OFF (bytemode, sizeflag); 5682 return; 5683 } 5684 5685 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 5686 intel_operand_size (bytemode, sizeflag); 5687 append_seg (); 5688 5689 off = get64 (); 5690 5691 if (intel_syntax) 5692 { 5693 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5694 | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 5695 { 5696 oappend (names_seg[ds_reg - es_reg]); 5697 oappend (":"); 5698 } 5699 } 5700 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off); 5701 oappend (scratchbuf); 5702 } 5703 5704 static void 5705 ptr_reg (int code, int sizeflag) 5706 { 5707 const char *s; 5708 5709 *obufp++ = open_char; 5710 used_prefixes |= (prefixes & PREFIX_ADDR); 5711 if (address_mode == mode_64bit) 5712 { 5713 if (!(sizeflag & AFLAG)) 5714 s = names32[code - eAX_reg]; 5715 else 5716 s = names64[code - eAX_reg]; 5717 } 5718 else if (sizeflag & AFLAG) 5719 s = names32[code - eAX_reg]; 5720 else 5721 s = names16[code - eAX_reg]; 5722 oappend (s); 5723 *obufp++ = close_char; 5724 *obufp = 0; 5725 } 5726 5727 static void 5728 OP_ESreg (int code, int sizeflag) 5729 { 5730 if (intel_syntax) 5731 { 5732 switch (codep[-1]) 5733 { 5734 case 0x6d: /* insw/insl */ 5735 intel_operand_size (z_mode, sizeflag); 5736 break; 5737 case 0xa5: /* movsw/movsl/movsq */ 5738 case 0xa7: /* cmpsw/cmpsl/cmpsq */ 5739 case 0xab: /* stosw/stosl */ 5740 case 0xaf: /* scasw/scasl */ 5741 intel_operand_size (v_mode, sizeflag); 5742 break; 5743 default: 5744 intel_operand_size (b_mode, sizeflag); 5745 } 5746 } 5747 oappend ("%es:" + intel_syntax); 5748 ptr_reg (code, sizeflag); 5749 } 5750 5751 static void 5752 OP_DSreg (int code, int sizeflag) 5753 { 5754 if (intel_syntax) 5755 { 5756 switch (codep[-1]) 5757 { 5758 case 0x6f: /* outsw/outsl */ 5759 intel_operand_size (z_mode, sizeflag); 5760 break; 5761 case 0xa5: /* movsw/movsl/movsq */ 5762 case 0xa7: /* cmpsw/cmpsl/cmpsq */ 5763 case 0xad: /* lodsw/lodsl/lodsq */ 5764 intel_operand_size (v_mode, sizeflag); 5765 break; 5766 default: 5767 intel_operand_size (b_mode, sizeflag); 5768 } 5769 } 5770 if ((prefixes 5771 & (PREFIX_CS 5772 | PREFIX_DS 5773 | PREFIX_SS 5774 | PREFIX_ES 5775 | PREFIX_FS 5776 | PREFIX_GS)) == 0) 5777 prefixes |= PREFIX_DS; 5778 append_seg (); 5779 ptr_reg (code, sizeflag); 5780 } 5781 5782 static void 5783 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5784 { 5785 int add = 0; 5786 if (rex & REX_R) 5787 { 5788 USED_REX (REX_R); 5789 add = 8; 5790 } 5791 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK)) 5792 { 5793 used_prefixes |= PREFIX_LOCK; 5794 add = 8; 5795 } 5796 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", modrm.reg + add); 5797 oappend (scratchbuf + intel_syntax); 5798 } 5799 5800 static void 5801 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5802 { 5803 int add = 0; 5804 USED_REX (REX_R); 5805 if (rex & REX_R) 5806 add = 8; 5807 if (intel_syntax) 5808 snprintf (scratchbuf, sizeof(scratchbuf), "db%d", modrm.reg + add); 5809 else 5810 snprintf (scratchbuf, sizeof(scratchbuf), "%%db%d", modrm.reg + add); 5811 oappend (scratchbuf); 5812 } 5813 5814 static void 5815 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5816 { 5817 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", modrm.reg); 5818 oappend (scratchbuf + intel_syntax); 5819 } 5820 5821 static void 5822 OP_R (int bytemode, int sizeflag) 5823 { 5824 if (modrm.mod == 3) 5825 OP_E (bytemode, sizeflag); 5826 else 5827 BadOp (); 5828 } 5829 5830 static void 5831 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5832 { 5833 used_prefixes |= (prefixes & PREFIX_DATA); 5834 if (prefixes & PREFIX_DATA) 5835 { 5836 int add = 0; 5837 USED_REX (REX_R); 5838 if (rex & REX_R) 5839 add = 8; 5840 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add); 5841 } 5842 else 5843 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg); 5844 oappend (scratchbuf + intel_syntax); 5845 } 5846 5847 static void 5848 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5849 { 5850 int add = 0; 5851 USED_REX (REX_R); 5852 if (rex & REX_R) 5853 add = 8; 5854 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add); 5855 oappend (scratchbuf + intel_syntax); 5856 } 5857 5858 static void 5859 OP_EM (int bytemode, int sizeflag) 5860 { 5861 if (modrm.mod != 3) 5862 { 5863 if (intel_syntax && bytemode == v_mode) 5864 { 5865 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; 5866 used_prefixes |= (prefixes & PREFIX_DATA); 5867 } 5868 OP_E (bytemode, sizeflag); 5869 return; 5870 } 5871 5872 /* Skip mod/rm byte. */ 5873 MODRM_CHECK; 5874 codep++; 5875 used_prefixes |= (prefixes & PREFIX_DATA); 5876 if (prefixes & PREFIX_DATA) 5877 { 5878 int add = 0; 5879 5880 USED_REX (REX_B); 5881 if (rex & REX_B) 5882 add = 8; 5883 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add); 5884 } 5885 else 5886 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm); 5887 oappend (scratchbuf + intel_syntax); 5888 } 5889 5890 /* cvt* are the only instructions in sse2 which have 5891 both SSE and MMX operands and also have 0x66 prefix 5892 in their opcode. 0x66 was originally used to differentiate 5893 between SSE and MMX instruction(operands). So we have to handle the 5894 cvt* separately using OP_EMC and OP_MXC */ 5895 static void 5896 OP_EMC (int bytemode, int sizeflag) 5897 { 5898 if (modrm.mod != 3) 5899 { 5900 if (intel_syntax && bytemode == v_mode) 5901 { 5902 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; 5903 used_prefixes |= (prefixes & PREFIX_DATA); 5904 } 5905 OP_E (bytemode, sizeflag); 5906 return; 5907 } 5908 5909 /* Skip mod/rm byte. */ 5910 MODRM_CHECK; 5911 codep++; 5912 used_prefixes |= (prefixes & PREFIX_DATA); 5913 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm); 5914 oappend (scratchbuf + intel_syntax); 5915 } 5916 5917 static void 5918 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5919 { 5920 used_prefixes |= (prefixes & PREFIX_DATA); 5921 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg); 5922 oappend (scratchbuf + intel_syntax); 5923 } 5924 5925 static void 5926 OP_EX (int bytemode, int sizeflag) 5927 { 5928 int add = 0; 5929 if (modrm.mod != 3) 5930 { 5931 OP_E (bytemode, sizeflag); 5932 return; 5933 } 5934 USED_REX (REX_B); 5935 if (rex & REX_B) 5936 add = 8; 5937 5938 /* Skip mod/rm byte. */ 5939 MODRM_CHECK; 5940 codep++; 5941 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add); 5942 oappend (scratchbuf + intel_syntax); 5943 } 5944 5945 static void 5946 OP_MS (int bytemode, int sizeflag) 5947 { 5948 if (modrm.mod == 3) 5949 OP_EM (bytemode, sizeflag); 5950 else 5951 BadOp (); 5952 } 5953 5954 static void 5955 OP_XS (int bytemode, int sizeflag) 5956 { 5957 if (modrm.mod == 3) 5958 OP_EX (bytemode, sizeflag); 5959 else 5960 BadOp (); 5961 } 5962 5963 static void 5964 OP_M (int bytemode, int sizeflag) 5965 { 5966 if (modrm.mod == 3) 5967 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */ 5968 BadOp (); 5969 else 5970 OP_E (bytemode, sizeflag); 5971 } 5972 5973 static void 5974 OP_0f07 (int bytemode, int sizeflag) 5975 { 5976 if (modrm.mod != 3 || modrm.rm != 0) 5977 BadOp (); 5978 else 5979 OP_E (bytemode, sizeflag); 5980 } 5981 5982 static void 5983 OP_0fae (int bytemode, int sizeflag) 5984 { 5985 if (modrm.mod == 3) 5986 { 5987 if (modrm.reg == 7) 5988 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence"); 5989 5990 if (modrm.reg < 5 || modrm.rm != 0) 5991 { 5992 BadOp (); /* bad sfence, mfence, or lfence */ 5993 return; 5994 } 5995 } 5996 else if (modrm.reg != 7) 5997 { 5998 BadOp (); /* bad clflush */ 5999 return; 6000 } 6001 6002 OP_E (bytemode, sizeflag); 6003 } 6004 6005 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in 6006 32bit mode and "xchg %rax,%rax" in 64bit mode. */ 6007 6008 static void 6009 NOP_Fixup1 (int bytemode, int sizeflag) 6010 { 6011 if ((prefixes & PREFIX_DATA) != 0 6012 || (rex != 0 6013 && rex != 0x48 6014 && address_mode == mode_64bit)) 6015 OP_REG (bytemode, sizeflag); 6016 else 6017 strcpy (obuf, "nop"); 6018 } 6019 6020 static void 6021 NOP_Fixup2 (int bytemode, int sizeflag) 6022 { 6023 if ((prefixes & PREFIX_DATA) != 0 6024 || (rex != 0 6025 && rex != 0x48 6026 && address_mode == mode_64bit)) 6027 OP_IMREG (bytemode, sizeflag); 6028 } 6029 6030 static const char *Suffix3DNow[] = { 6031 /* 00 */ NULL, NULL, NULL, NULL, 6032 /* 04 */ NULL, NULL, NULL, NULL, 6033 /* 08 */ NULL, NULL, NULL, NULL, 6034 /* 0C */ "pi2fw", "pi2fd", NULL, NULL, 6035 /* 10 */ NULL, NULL, NULL, NULL, 6036 /* 14 */ NULL, NULL, NULL, NULL, 6037 /* 18 */ NULL, NULL, NULL, NULL, 6038 /* 1C */ "pf2iw", "pf2id", NULL, NULL, 6039 /* 20 */ NULL, NULL, NULL, NULL, 6040 /* 24 */ NULL, NULL, NULL, NULL, 6041 /* 28 */ NULL, NULL, NULL, NULL, 6042 /* 2C */ NULL, NULL, NULL, NULL, 6043 /* 30 */ NULL, NULL, NULL, NULL, 6044 /* 34 */ NULL, NULL, NULL, NULL, 6045 /* 38 */ NULL, NULL, NULL, NULL, 6046 /* 3C */ NULL, NULL, NULL, NULL, 6047 /* 40 */ NULL, NULL, NULL, NULL, 6048 /* 44 */ NULL, NULL, NULL, NULL, 6049 /* 48 */ NULL, NULL, NULL, NULL, 6050 /* 4C */ NULL, NULL, NULL, NULL, 6051 /* 50 */ NULL, NULL, NULL, NULL, 6052 /* 54 */ NULL, NULL, NULL, NULL, 6053 /* 58 */ NULL, NULL, NULL, NULL, 6054 /* 5C */ NULL, NULL, NULL, NULL, 6055 /* 60 */ NULL, NULL, NULL, NULL, 6056 /* 64 */ NULL, NULL, NULL, NULL, 6057 /* 68 */ NULL, NULL, NULL, NULL, 6058 /* 6C */ NULL, NULL, NULL, NULL, 6059 /* 70 */ NULL, NULL, NULL, NULL, 6060 /* 74 */ NULL, NULL, NULL, NULL, 6061 /* 78 */ NULL, NULL, NULL, NULL, 6062 /* 7C */ NULL, NULL, NULL, NULL, 6063 /* 80 */ NULL, NULL, NULL, NULL, 6064 /* 84 */ NULL, NULL, NULL, NULL, 6065 /* 88 */ NULL, NULL, "pfnacc", NULL, 6066 /* 8C */ NULL, NULL, "pfpnacc", NULL, 6067 /* 90 */ "pfcmpge", NULL, NULL, NULL, 6068 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", 6069 /* 98 */ NULL, NULL, "pfsub", NULL, 6070 /* 9C */ NULL, NULL, "pfadd", NULL, 6071 /* A0 */ "pfcmpgt", NULL, NULL, NULL, 6072 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", 6073 /* A8 */ NULL, NULL, "pfsubr", NULL, 6074 /* AC */ NULL, NULL, "pfacc", NULL, 6075 /* B0 */ "pfcmpeq", NULL, NULL, NULL, 6076 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw", 6077 /* B8 */ NULL, NULL, NULL, "pswapd", 6078 /* BC */ NULL, NULL, NULL, "pavgusb", 6079 /* C0 */ NULL, NULL, NULL, NULL, 6080 /* C4 */ NULL, NULL, NULL, NULL, 6081 /* C8 */ NULL, NULL, NULL, NULL, 6082 /* CC */ NULL, NULL, NULL, NULL, 6083 /* D0 */ NULL, NULL, NULL, NULL, 6084 /* D4 */ NULL, NULL, NULL, NULL, 6085 /* D8 */ NULL, NULL, NULL, NULL, 6086 /* DC */ NULL, NULL, NULL, NULL, 6087 /* E0 */ NULL, NULL, NULL, NULL, 6088 /* E4 */ NULL, NULL, NULL, NULL, 6089 /* E8 */ NULL, NULL, NULL, NULL, 6090 /* EC */ NULL, NULL, NULL, NULL, 6091 /* F0 */ NULL, NULL, NULL, NULL, 6092 /* F4 */ NULL, NULL, NULL, NULL, 6093 /* F8 */ NULL, NULL, NULL, NULL, 6094 /* FC */ NULL, NULL, NULL, NULL, 6095 }; 6096 6097 static void 6098 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 6099 { 6100 const char *mnemonic; 6101 6102 FETCH_DATA (the_info, codep + 1); 6103 /* AMD 3DNow! instructions are specified by an opcode suffix in the 6104 place where an 8-bit immediate would normally go. ie. the last 6105 byte of the instruction. */ 6106 obufp = obuf + strlen (obuf); 6107 mnemonic = Suffix3DNow[*codep++ & 0xff]; 6108 if (mnemonic) 6109 oappend (mnemonic); 6110 else 6111 { 6112 /* Since a variable sized modrm/sib chunk is between the start 6113 of the opcode (0x0f0f) and the opcode suffix, we need to do 6114 all the modrm processing first, and don't know until now that 6115 we have a bad opcode. This necessitates some cleaning up. */ 6116 op_out[0][0] = '\0'; 6117 op_out[1][0] = '\0'; 6118 BadOp (); 6119 } 6120 } 6121 6122 static const char *simd_cmp_op[] = { 6123 "eq", 6124 "lt", 6125 "le", 6126 "unord", 6127 "neq", 6128 "nlt", 6129 "nle", 6130 "ord" 6131 }; 6132 6133 static void 6134 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 6135 { 6136 unsigned int cmp_type; 6137 6138 FETCH_DATA (the_info, codep + 1); 6139 obufp = obuf + strlen (obuf); 6140 cmp_type = *codep++ & 0xff; 6141 if (cmp_type < 8) 6142 { 6143 char suffix1 = 'p', suffix2 = 's'; 6144 used_prefixes |= (prefixes & PREFIX_REPZ); 6145 if (prefixes & PREFIX_REPZ) 6146 suffix1 = 's'; 6147 else 6148 { 6149 used_prefixes |= (prefixes & PREFIX_DATA); 6150 if (prefixes & PREFIX_DATA) 6151 suffix2 = 'd'; 6152 else 6153 { 6154 used_prefixes |= (prefixes & PREFIX_REPNZ); 6155 if (prefixes & PREFIX_REPNZ) 6156 suffix1 = 's', suffix2 = 'd'; 6157 } 6158 } 6159 snprintf (scratchbuf, sizeof(scratchbuf), "cmp%s%c%c", 6160 simd_cmp_op[cmp_type], suffix1, suffix2); 6161 used_prefixes |= (prefixes & PREFIX_REPZ); 6162 oappend (scratchbuf); 6163 } 6164 else 6165 { 6166 /* We have a bad extension byte. Clean up. */ 6167 op_out[0][0] = '\0'; 6168 op_out[1][0] = '\0'; 6169 BadOp (); 6170 } 6171 } 6172 6173 static void 6174 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED) 6175 { 6176 /* Change movlps/movhps to movhlps/movlhps for 2 register operand 6177 forms of these instructions. */ 6178 if (modrm.mod == 3) 6179 { 6180 char *p = obuf + strlen (obuf); 6181 *(p + 1) = '\0'; 6182 *p = *(p - 1); 6183 *(p - 1) = *(p - 2); 6184 *(p - 2) = *(p - 3); 6185 *(p - 3) = extrachar; 6186 } 6187 } 6188 6189 static void 6190 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 6191 { 6192 if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1) 6193 { 6194 /* Override "sidt". */ 6195 size_t olen = strlen (obuf); 6196 char *p = obuf + olen - 4; 6197 const char * const *names = (address_mode == mode_64bit 6198 ? names64 : names32); 6199 6200 /* We might have a suffix when disassembling with -Msuffix. */ 6201 if (*p == 'i') 6202 --p; 6203 6204 /* Remove "addr16/addr32" if we aren't in Intel mode. */ 6205 if (!intel_syntax 6206 && (prefixes & PREFIX_ADDR) 6207 && olen >= (4 + 7) 6208 && *(p - 1) == ' ' 6209 && strncmp (p - 7, "addr", 4) == 0 6210 && (strncmp (p - 3, "16", 2) == 0 6211 || strncmp (p - 3, "32", 2) == 0)) 6212 p -= 7; 6213 6214 if (modrm.rm) 6215 { 6216 /* mwait %eax,%ecx */ 6217 strcpy (p, "mwait"); 6218 if (!intel_syntax) 6219 strcpy (op_out[0], names[0]); 6220 } 6221 else 6222 { 6223 /* monitor %eax,%ecx,%edx" */ 6224 strcpy (p, "monitor"); 6225 if (!intel_syntax) 6226 { 6227 const char * const *op1_names; 6228 if (!(prefixes & PREFIX_ADDR)) 6229 op1_names = (address_mode == mode_16bit 6230 ? names16 : names); 6231 else 6232 { 6233 op1_names = (address_mode != mode_32bit 6234 ? names32 : names16); 6235 used_prefixes |= PREFIX_ADDR; 6236 } 6237 strcpy (op_out[0], op1_names[0]); 6238 strcpy (op_out[2], names[2]); 6239 } 6240 } 6241 if (!intel_syntax) 6242 { 6243 strcpy (op_out[1], names[1]); 6244 two_source_ops = 1; 6245 } 6246 6247 codep++; 6248 } 6249 else 6250 OP_M (0, sizeflag); 6251 } 6252 6253 static void 6254 SVME_Fixup (int bytemode, int sizeflag) 6255 { 6256 const char *alt; 6257 char *p; 6258 6259 switch (*codep) 6260 { 6261 case 0xd8: 6262 alt = "vmrun"; 6263 break; 6264 case 0xd9: 6265 alt = "vmmcall"; 6266 break; 6267 case 0xda: 6268 alt = "vmload"; 6269 break; 6270 case 0xdb: 6271 alt = "vmsave"; 6272 break; 6273 case 0xdc: 6274 alt = "stgi"; 6275 break; 6276 case 0xdd: 6277 alt = "clgi"; 6278 break; 6279 case 0xde: 6280 alt = "skinit"; 6281 break; 6282 case 0xdf: 6283 alt = "invlpga"; 6284 break; 6285 default: 6286 OP_M (bytemode, sizeflag); 6287 return; 6288 } 6289 /* Override "lidt". */ 6290 p = obuf + strlen (obuf) - 4; 6291 /* We might have a suffix. */ 6292 if (*p == 'i') 6293 --p; 6294 strcpy (p, alt); 6295 if (!(prefixes & PREFIX_ADDR)) 6296 { 6297 ++codep; 6298 return; 6299 } 6300 used_prefixes |= PREFIX_ADDR; 6301 switch (*codep++) 6302 { 6303 case 0xdf: 6304 strcpy (op_out[1], names32[1]); 6305 two_source_ops = 1; 6306 /* Fall through. */ 6307 case 0xd8: 6308 case 0xda: 6309 case 0xdb: 6310 *obufp++ = open_char; 6311 if (address_mode == mode_64bit || (sizeflag & AFLAG)) 6312 alt = names32[0]; 6313 else 6314 alt = names16[0]; 6315 strcpy (obufp, alt); 6316 obufp += strlen (alt); 6317 *obufp++ = close_char; 6318 *obufp = '\0'; 6319 break; 6320 } 6321 } 6322 6323 static void 6324 INVLPG_Fixup (int bytemode, int sizeflag) 6325 { 6326 const char *alt; 6327 6328 switch (*codep) 6329 { 6330 case 0xf8: 6331 alt = "swapgs"; 6332 break; 6333 case 0xf9: 6334 alt = "rdtscp"; 6335 break; 6336 default: 6337 OP_M (bytemode, sizeflag); 6338 return; 6339 } 6340 /* Override "invlpg". */ 6341 strcpy (obuf + strlen (obuf) - 6, alt); 6342 codep++; 6343 } 6344 6345 static void 6346 BadOp (void) 6347 { 6348 /* Throw away prefixes and 1st. opcode byte. */ 6349 codep = insn_codep + 1; 6350 oappend ("(bad)"); 6351 } 6352 6353 static void 6354 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 6355 { 6356 if (modrm.mod == 3 6357 && modrm.reg == 0 6358 && modrm.rm >=1 6359 && modrm.rm <= 4) 6360 { 6361 /* Override "sgdt". */ 6362 char *p = obuf + strlen (obuf) - 4; 6363 6364 /* We might have a suffix when disassembling with -Msuffix. */ 6365 if (*p == 'g') 6366 --p; 6367 6368 switch (modrm.rm) 6369 { 6370 case 1: 6371 strcpy (p, "vmcall"); 6372 break; 6373 case 2: 6374 strcpy (p, "vmlaunch"); 6375 break; 6376 case 3: 6377 strcpy (p, "vmresume"); 6378 break; 6379 case 4: 6380 strcpy (p, "vmxoff"); 6381 break; 6382 } 6383 6384 codep++; 6385 } 6386 else 6387 OP_E (0, sizeflag); 6388 } 6389 6390 static void 6391 OP_VMX (int bytemode, int sizeflag) 6392 { 6393 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ)); 6394 if (prefixes & PREFIX_DATA) 6395 strcpy (obuf, "vmclear"); 6396 else if (prefixes & PREFIX_REPZ) 6397 strcpy (obuf, "vmxon"); 6398 else 6399 strcpy (obuf, "vmptrld"); 6400 OP_E (bytemode, sizeflag); 6401 } 6402 6403 static void 6404 REP_Fixup (int bytemode, int sizeflag) 6405 { 6406 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs, 6407 lods and stos. */ 6408 size_t ilen = 0; 6409 6410 if (prefixes & PREFIX_REPZ) 6411 switch (*insn_codep) 6412 { 6413 case 0x6e: /* outsb */ 6414 case 0x6f: /* outsw/outsl */ 6415 case 0xa4: /* movsb */ 6416 case 0xa5: /* movsw/movsl/movsq */ 6417 if (!intel_syntax) 6418 ilen = 5; 6419 else 6420 ilen = 4; 6421 break; 6422 case 0xaa: /* stosb */ 6423 case 0xab: /* stosw/stosl/stosq */ 6424 case 0xac: /* lodsb */ 6425 case 0xad: /* lodsw/lodsl/lodsq */ 6426 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 6427 ilen = 5; 6428 else 6429 ilen = 4; 6430 break; 6431 case 0x6c: /* insb */ 6432 case 0x6d: /* insl/insw */ 6433 if (!intel_syntax) 6434 ilen = 4; 6435 else 6436 ilen = 3; 6437 break; 6438 default: 6439 abort (); 6440 break; 6441 } 6442 6443 if (ilen != 0) 6444 { 6445 size_t olen; 6446 char *p; 6447 6448 olen = strlen (obuf); 6449 p = obuf + olen - ilen - 1 - 4; 6450 /* Handle "repz [addr16|addr32]". */ 6451 if ((prefixes & PREFIX_ADDR)) 6452 p -= 1 + 6; 6453 6454 memmove (p + 3, p + 4, olen - (p + 3 - obuf)); 6455 } 6456 6457 switch (bytemode) 6458 { 6459 case al_reg: 6460 case eAX_reg: 6461 case indir_dx_reg: 6462 OP_IMREG (bytemode, sizeflag); 6463 break; 6464 case eDI_reg: 6465 OP_ESreg (bytemode, sizeflag); 6466 break; 6467 case eSI_reg: 6468 OP_DSreg (bytemode, sizeflag); 6469 break; 6470 default: 6471 abort (); 6472 break; 6473 } 6474 } 6475 6476 static void 6477 CMPXCHG8B_Fixup (int bytemode, int sizeflag) 6478 { 6479 USED_REX (REX_W); 6480 if (rex & REX_W) 6481 { 6482 /* Change cmpxchg8b to cmpxchg16b. */ 6483 char *p = obuf + strlen (obuf) - 2; 6484 strcpy (p, "16b"); 6485 bytemode = o_mode; 6486 } 6487 OP_M (bytemode, sizeflag); 6488 } 6489 6490 static void 6491 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED) 6492 { 6493 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg); 6494 oappend (scratchbuf + intel_syntax); 6495 } 6496 6497 static void 6498 CRC32_Fixup (int bytemode, int sizeflag) 6499 { 6500 /* Add proper suffix to "crc32". */ 6501 char *p = obuf + strlen (obuf); 6502 6503 switch (bytemode) 6504 { 6505 case b_mode: 6506 if (intel_syntax) 6507 break; 6508 6509 *p++ = 'b'; 6510 break; 6511 case v_mode: 6512 if (intel_syntax) 6513 break; 6514 6515 USED_REX (REX_W); 6516 if (rex & REX_W) 6517 *p++ = 'q'; 6518 else if (sizeflag & DFLAG) 6519 *p++ = 'l'; 6520 else 6521 *p++ = 'w'; 6522 used_prefixes |= (prefixes & PREFIX_DATA); 6523 break; 6524 default: 6525 oappend (INTERNAL_DISASSEMBLER_ERROR); 6526 break; 6527 } 6528 *p = '\0'; 6529 6530 if (modrm.mod == 3) 6531 { 6532 int add; 6533 6534 /* Skip mod/rm byte. */ 6535 MODRM_CHECK; 6536 codep++; 6537 6538 USED_REX (REX_B); 6539 add = (rex & REX_B) ? 8 : 0; 6540 if (bytemode == b_mode) 6541 { 6542 USED_REX (0); 6543 if (rex) 6544 oappend (names8rex[modrm.rm + add]); 6545 else 6546 oappend (names8[modrm.rm + add]); 6547 } 6548 else 6549 { 6550 USED_REX (REX_W); 6551 if (rex & REX_W) 6552 oappend (names64[modrm.rm + add]); 6553 else if ((prefixes & PREFIX_DATA)) 6554 oappend (names16[modrm.rm + add]); 6555 else 6556 oappend (names32[modrm.rm + add]); 6557 } 6558 } 6559 else 6560 OP_E (bytemode, sizeflag); 6561 } 6562
