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