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