i386-dis.c revision 238123
133965Sjdp/* Print i386 instructions for GDB, the GNU debugger. 277298Sobrien Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 3218822Sdim 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc. 433965Sjdp 5218822Sdim This file is part of GDB. 633965Sjdp 7218822Sdim This program is free software; you can redistribute it and/or modify 8218822Sdim it under the terms of the GNU General Public License as published by 9218822Sdim the Free Software Foundation; either version 2 of the License, or 10218822Sdim (at your option) any later version. 1133965Sjdp 12218822Sdim This program is distributed in the hope that it will be useful, 13218822Sdim but WITHOUT ANY WARRANTY; without even the implied warranty of 14218822Sdim MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15218822Sdim GNU General Public License for more details. 1633965Sjdp 17218822Sdim You should have received a copy of the GNU General Public License 18218822Sdim along with this program; if not, write to the Free Software 19218822Sdim Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 2033965Sjdp 21218822Sdim/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu) 22218822Sdim July 1988 23218822Sdim modified by John Hassey (hassey@dg-rtp.dg.com) 24218822Sdim x86-64 support added by Jan Hubicka (jh@suse.cz) 25218822Sdim VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */ 2633965Sjdp 27218822Sdim/* The main tables describing the instructions is essentially a copy 28218822Sdim of the "Opcode Map" chapter (Appendix A) of the Intel 80386 29218822Sdim Programmers Manual. Usually, there is a capital letter, followed 30218822Sdim by a small letter. The capital letter tell the addressing mode, 31218822Sdim and the small letter tells about the operand size. Refer to 32218822Sdim the Intel manual for details. */ 3333965Sjdp 3433965Sjdp#include "dis-asm.h" 3533965Sjdp#include "sysdep.h" 3660484Sobrien#include "opintl.h" 37218822Sdim#include "opcode/i386.h" 3833965Sjdp 3933965Sjdp#include <setjmp.h> 4033965Sjdp 41130561Sobrienstatic int fetch_data (struct disassemble_info *, bfd_byte *); 42130561Sobrienstatic void ckprefix (void); 43130561Sobrienstatic const char *prefix_name (int, int); 44130561Sobrienstatic int print_insn (bfd_vma, disassemble_info *); 45130561Sobrienstatic void dofloat (int); 46130561Sobrienstatic void OP_ST (int, int); 47130561Sobrienstatic void OP_STi (int, int); 48130561Sobrienstatic int putop (const char *, int); 49130561Sobrienstatic void oappend (const char *); 50130561Sobrienstatic void append_seg (void); 51130561Sobrienstatic void OP_indirE (int, int); 52130561Sobrienstatic void print_operand_value (char *, int, bfd_vma); 53218822Sdimstatic void print_displacement (char *, bfd_vma); 54130561Sobrienstatic void OP_E (int, int); 55130561Sobrienstatic void OP_G (int, int); 56130561Sobrienstatic bfd_vma get64 (void); 57130561Sobrienstatic bfd_signed_vma get32 (void); 58130561Sobrienstatic bfd_signed_vma get32s (void); 59130561Sobrienstatic int get16 (void); 60130561Sobrienstatic void set_op (bfd_vma, int); 61130561Sobrienstatic void OP_REG (int, int); 62130561Sobrienstatic void OP_IMREG (int, int); 63130561Sobrienstatic void OP_I (int, int); 64130561Sobrienstatic void OP_I64 (int, int); 65130561Sobrienstatic void OP_sI (int, int); 66130561Sobrienstatic void OP_J (int, int); 67130561Sobrienstatic void OP_SEG (int, int); 68130561Sobrienstatic void OP_DIR (int, int); 69130561Sobrienstatic void OP_OFF (int, int); 70130561Sobrienstatic void OP_OFF64 (int, int); 71130561Sobrienstatic void ptr_reg (int, int); 72130561Sobrienstatic void OP_ESreg (int, int); 73130561Sobrienstatic void OP_DSreg (int, int); 74130561Sobrienstatic void OP_C (int, int); 75130561Sobrienstatic void OP_D (int, int); 76130561Sobrienstatic void OP_T (int, int); 77218822Sdimstatic void OP_R (int, int); 78130561Sobrienstatic void OP_MMX (int, int); 79130561Sobrienstatic void OP_XMM (int, int); 80130561Sobrienstatic void OP_EM (int, int); 81130561Sobrienstatic void OP_EX (int, int); 82218822Sdimstatic void OP_EMC (int,int); 83218822Sdimstatic void OP_MXC (int,int); 84130561Sobrienstatic void OP_MS (int, int); 85130561Sobrienstatic void OP_XS (int, int); 86130561Sobrienstatic void OP_M (int, int); 87218822Sdimstatic void OP_VMX (int, int); 88130561Sobrienstatic void OP_0fae (int, int); 89130561Sobrienstatic void OP_0f07 (int, int); 90218822Sdimstatic void NOP_Fixup1 (int, int); 91218822Sdimstatic void NOP_Fixup2 (int, int); 92130561Sobrienstatic void OP_3DNowSuffix (int, int); 93130561Sobrienstatic void OP_SIMD_Suffix (int, int); 94130561Sobrienstatic void SIMD_Fixup (int, int); 95130561Sobrienstatic void PNI_Fixup (int, int); 96238123Sjhbstatic void XCR_Fixup (int, int); 97218822Sdimstatic void SVME_Fixup (int, int); 98130561Sobrienstatic void INVLPG_Fixup (int, int); 99130561Sobrienstatic void BadOp (void); 100218822Sdimstatic void VMX_Fixup (int, int); 101218822Sdimstatic void REP_Fixup (int, int); 102218822Sdimstatic void CMPXCHG8B_Fixup (int, int); 103218822Sdimstatic void XMM_Fixup (int, int); 104218822Sdimstatic void CRC32_Fixup (int, int); 10533965Sjdp 10685815Sobrienstruct dis_private { 10733965Sjdp /* Points to first byte not fetched. */ 10833965Sjdp bfd_byte *max_fetched; 109218822Sdim bfd_byte the_buffer[MAX_MNEM_SIZE]; 11033965Sjdp bfd_vma insn_start; 11189857Sobrien int orig_sizeflag; 11233965Sjdp jmp_buf bailout; 11333965Sjdp}; 11433965Sjdp 115218822Sdimenum address_mode 116218822Sdim{ 117218822Sdim mode_16bit, 118218822Sdim mode_32bit, 119218822Sdim mode_64bit 120218822Sdim}; 12160484Sobrien 122218822Sdimenum address_mode address_mode; 12377298Sobrien 12460484Sobrien/* Flags for the prefixes for the current instruction. See below. */ 12560484Sobrienstatic int prefixes; 12660484Sobrien 12777298Sobrien/* REX prefix the current instruction. See below. */ 12877298Sobrienstatic int rex; 12977298Sobrien/* Bits of REX we've already used. */ 13077298Sobrienstatic int rex_used; 13177298Sobrien/* Mark parts used in the REX prefix. When we are testing for 13277298Sobrien empty prefix (for 8bit register REX extension), just mask it 13377298Sobrien out. Otherwise test for REX bit is excuse for existence of REX 13477298Sobrien only in case value is nonzero. */ 13577298Sobrien#define USED_REX(value) \ 13677298Sobrien { \ 13777298Sobrien if (value) \ 138218822Sdim { \ 139218822Sdim if ((rex & value)) \ 140218822Sdim rex_used |= (value) | REX_OPCODE; \ 141218822Sdim } \ 14277298Sobrien else \ 143218822Sdim rex_used |= REX_OPCODE; \ 14477298Sobrien } 14577298Sobrien 14660484Sobrien/* Flags for prefixes which we somehow handled when printing the 14760484Sobrien current instruction. */ 14860484Sobrienstatic int used_prefixes; 14960484Sobrien 15060484Sobrien/* Flags stored in PREFIXES. */ 15160484Sobrien#define PREFIX_REPZ 1 15260484Sobrien#define PREFIX_REPNZ 2 15360484Sobrien#define PREFIX_LOCK 4 15460484Sobrien#define PREFIX_CS 8 15560484Sobrien#define PREFIX_SS 0x10 15660484Sobrien#define PREFIX_DS 0x20 15760484Sobrien#define PREFIX_ES 0x40 15860484Sobrien#define PREFIX_FS 0x80 15960484Sobrien#define PREFIX_GS 0x100 16060484Sobrien#define PREFIX_DATA 0x200 16160484Sobrien#define PREFIX_ADDR 0x400 16260484Sobrien#define PREFIX_FWAIT 0x800 16360484Sobrien 16433965Sjdp/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive) 16533965Sjdp to ADDR (exclusive) are valid. Returns 1 for success, longjmps 16633965Sjdp on error. */ 16733965Sjdp#define FETCH_DATA(info, addr) \ 16885815Sobrien ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \ 16933965Sjdp ? 1 : fetch_data ((info), (addr))) 17033965Sjdp 17133965Sjdpstatic int 172130561Sobrienfetch_data (struct disassemble_info *info, bfd_byte *addr) 17333965Sjdp{ 17433965Sjdp int status; 17585815Sobrien struct dis_private *priv = (struct dis_private *) info->private_data; 17633965Sjdp bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 17733965Sjdp 178218822Sdim if (addr <= priv->the_buffer + MAX_MNEM_SIZE) 179218822Sdim status = (*info->read_memory_func) (start, 180218822Sdim priv->max_fetched, 181218822Sdim addr - priv->max_fetched, 182218822Sdim info); 183218822Sdim else 184218822Sdim status = -1; 18533965Sjdp if (status != 0) 18633965Sjdp { 18760484Sobrien /* If we did manage to read at least one byte, then 188130561Sobrien print_insn_i386 will do something sensible. Otherwise, print 189130561Sobrien an error. We do that here because this is where we know 190130561Sobrien STATUS. */ 19160484Sobrien if (priv->max_fetched == priv->the_buffer) 19260484Sobrien (*info->memory_error_func) (status, start, info); 19333965Sjdp longjmp (priv->bailout, 1); 19433965Sjdp } 19533965Sjdp else 19633965Sjdp priv->max_fetched = addr; 19733965Sjdp return 1; 19833965Sjdp} 19933965Sjdp 200218822Sdim#define XX { NULL, 0 } 20160484Sobrien 202218822Sdim#define Eb { OP_E, b_mode } 203218822Sdim#define Ev { OP_E, v_mode } 204218822Sdim#define Ed { OP_E, d_mode } 205218822Sdim#define Edq { OP_E, dq_mode } 206218822Sdim#define Edqw { OP_E, dqw_mode } 207218822Sdim#define Edqb { OP_E, dqb_mode } 208218822Sdim#define Edqd { OP_E, dqd_mode } 209218822Sdim#define indirEv { OP_indirE, stack_v_mode } 210218822Sdim#define indirEp { OP_indirE, f_mode } 211218822Sdim#define stackEv { OP_E, stack_v_mode } 212218822Sdim#define Em { OP_E, m_mode } 213218822Sdim#define Ew { OP_E, w_mode } 214218822Sdim#define M { OP_M, 0 } /* lea, lgdt, etc. */ 215218822Sdim#define Ma { OP_M, v_mode } 216218822Sdim#define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */ 217218822Sdim#define Mq { OP_M, q_mode } 218218822Sdim#define Gb { OP_G, b_mode } 219218822Sdim#define Gv { OP_G, v_mode } 220218822Sdim#define Gd { OP_G, d_mode } 221218822Sdim#define Gdq { OP_G, dq_mode } 222218822Sdim#define Gm { OP_G, m_mode } 223218822Sdim#define Gw { OP_G, w_mode } 224218822Sdim#define Rd { OP_R, d_mode } 225218822Sdim#define Rm { OP_R, m_mode } 226218822Sdim#define Ib { OP_I, b_mode } 227218822Sdim#define sIb { OP_sI, b_mode } /* sign extened byte */ 228218822Sdim#define Iv { OP_I, v_mode } 229218822Sdim#define Iq { OP_I, q_mode } 230218822Sdim#define Iv64 { OP_I64, v_mode } 231218822Sdim#define Iw { OP_I, w_mode } 232218822Sdim#define I1 { OP_I, const_1_mode } 233218822Sdim#define Jb { OP_J, b_mode } 234218822Sdim#define Jv { OP_J, v_mode } 235218822Sdim#define Cm { OP_C, m_mode } 236218822Sdim#define Dm { OP_D, m_mode } 237218822Sdim#define Td { OP_T, d_mode } 23833965Sjdp 239218822Sdim#define RMeAX { OP_REG, eAX_reg } 240218822Sdim#define RMeBX { OP_REG, eBX_reg } 241218822Sdim#define RMeCX { OP_REG, eCX_reg } 242218822Sdim#define RMeDX { OP_REG, eDX_reg } 243218822Sdim#define RMeSP { OP_REG, eSP_reg } 244218822Sdim#define RMeBP { OP_REG, eBP_reg } 245218822Sdim#define RMeSI { OP_REG, eSI_reg } 246218822Sdim#define RMeDI { OP_REG, eDI_reg } 247218822Sdim#define RMrAX { OP_REG, rAX_reg } 248218822Sdim#define RMrBX { OP_REG, rBX_reg } 249218822Sdim#define RMrCX { OP_REG, rCX_reg } 250218822Sdim#define RMrDX { OP_REG, rDX_reg } 251218822Sdim#define RMrSP { OP_REG, rSP_reg } 252218822Sdim#define RMrBP { OP_REG, rBP_reg } 253218822Sdim#define RMrSI { OP_REG, rSI_reg } 254218822Sdim#define RMrDI { OP_REG, rDI_reg } 255218822Sdim#define RMAL { OP_REG, al_reg } 256218822Sdim#define RMAL { OP_REG, al_reg } 257218822Sdim#define RMCL { OP_REG, cl_reg } 258218822Sdim#define RMDL { OP_REG, dl_reg } 259218822Sdim#define RMBL { OP_REG, bl_reg } 260218822Sdim#define RMAH { OP_REG, ah_reg } 261218822Sdim#define RMCH { OP_REG, ch_reg } 262218822Sdim#define RMDH { OP_REG, dh_reg } 263218822Sdim#define RMBH { OP_REG, bh_reg } 264218822Sdim#define RMAX { OP_REG, ax_reg } 265218822Sdim#define RMDX { OP_REG, dx_reg } 26633965Sjdp 267218822Sdim#define eAX { OP_IMREG, eAX_reg } 268218822Sdim#define eBX { OP_IMREG, eBX_reg } 269218822Sdim#define eCX { OP_IMREG, eCX_reg } 270218822Sdim#define eDX { OP_IMREG, eDX_reg } 271218822Sdim#define eSP { OP_IMREG, eSP_reg } 272218822Sdim#define eBP { OP_IMREG, eBP_reg } 273218822Sdim#define eSI { OP_IMREG, eSI_reg } 274218822Sdim#define eDI { OP_IMREG, eDI_reg } 275218822Sdim#define AL { OP_IMREG, al_reg } 276218822Sdim#define CL { OP_IMREG, cl_reg } 277218822Sdim#define DL { OP_IMREG, dl_reg } 278218822Sdim#define BL { OP_IMREG, bl_reg } 279218822Sdim#define AH { OP_IMREG, ah_reg } 280218822Sdim#define CH { OP_IMREG, ch_reg } 281218822Sdim#define DH { OP_IMREG, dh_reg } 282218822Sdim#define BH { OP_IMREG, bh_reg } 283218822Sdim#define AX { OP_IMREG, ax_reg } 284218822Sdim#define DX { OP_IMREG, dx_reg } 285218822Sdim#define zAX { OP_IMREG, z_mode_ax_reg } 286218822Sdim#define indirDX { OP_IMREG, indir_dx_reg } 28777298Sobrien 288218822Sdim#define Sw { OP_SEG, w_mode } 289218822Sdim#define Sv { OP_SEG, v_mode } 290218822Sdim#define Ap { OP_DIR, 0 } 291218822Sdim#define Ob { OP_OFF64, b_mode } 292218822Sdim#define Ov { OP_OFF64, v_mode } 293218822Sdim#define Xb { OP_DSreg, eSI_reg } 294218822Sdim#define Xv { OP_DSreg, eSI_reg } 295218822Sdim#define Xz { OP_DSreg, eSI_reg } 296218822Sdim#define Yb { OP_ESreg, eDI_reg } 297218822Sdim#define Yv { OP_ESreg, eDI_reg } 298218822Sdim#define DSBX { OP_DSreg, eBX_reg } 29933965Sjdp 300218822Sdim#define es { OP_REG, es_reg } 301218822Sdim#define ss { OP_REG, ss_reg } 302218822Sdim#define cs { OP_REG, cs_reg } 303218822Sdim#define ds { OP_REG, ds_reg } 304218822Sdim#define fs { OP_REG, fs_reg } 305218822Sdim#define gs { OP_REG, gs_reg } 30633965Sjdp 307218822Sdim#define MX { OP_MMX, 0 } 308218822Sdim#define XM { OP_XMM, 0 } 309218822Sdim#define EM { OP_EM, v_mode } 310218822Sdim#define EMd { OP_EM, d_mode } 311218822Sdim#define EMq { OP_EM, q_mode } 312218822Sdim#define EXd { OP_EX, d_mode } 313218822Sdim#define EXq { OP_EX, q_mode } 314218822Sdim#define EXx { OP_EX, x_mode } 315218822Sdim#define MS { OP_MS, v_mode } 316218822Sdim#define XS { OP_XS, v_mode } 317218822Sdim#define EMC { OP_EMC, v_mode } 318218822Sdim#define MXC { OP_MXC, 0 } 319218822Sdim#define VM { OP_VMX, q_mode } 320218822Sdim#define OPSUF { OP_3DNowSuffix, 0 } 321218822Sdim#define OPSIMD { OP_SIMD_Suffix, 0 } 322218822Sdim#define XMM0 { XMM_Fixup, 0 } 32333965Sjdp 324218822Sdim/* Used handle "rep" prefix for string instructions. */ 325218822Sdim#define Xbr { REP_Fixup, eSI_reg } 326218822Sdim#define Xvr { REP_Fixup, eSI_reg } 327218822Sdim#define Ybr { REP_Fixup, eDI_reg } 328218822Sdim#define Yvr { REP_Fixup, eDI_reg } 329218822Sdim#define Yzr { REP_Fixup, eDI_reg } 330218822Sdim#define indirDXr { REP_Fixup, indir_dx_reg } 331218822Sdim#define ALr { REP_Fixup, al_reg } 332218822Sdim#define eAXr { REP_Fixup, eAX_reg } 33378828Sobrien 334218822Sdim#define cond_jump_flag { NULL, cond_jump_mode } 335218822Sdim#define loop_jcxz_flag { NULL, loop_jcxz_mode } 336218822Sdim 33760484Sobrien/* bits in sizeflag */ 33860484Sobrien#define SUFFIX_ALWAYS 4 33960484Sobrien#define AFLAG 2 34060484Sobrien#define DFLAG 1 34133965Sjdp 34277298Sobrien#define b_mode 1 /* byte operand */ 34377298Sobrien#define v_mode 2 /* operand size depends on prefixes */ 34477298Sobrien#define w_mode 3 /* word operand */ 34577298Sobrien#define d_mode 4 /* double word operand */ 34677298Sobrien#define q_mode 5 /* quad word operand */ 347218822Sdim#define t_mode 6 /* ten-byte operand */ 348218822Sdim#define x_mode 7 /* 16-byte XMM operand */ 349218822Sdim#define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */ 350218822Sdim#define cond_jump_mode 9 351218822Sdim#define loop_jcxz_mode 10 352218822Sdim#define dq_mode 11 /* operand size depends on REX prefixes. */ 353218822Sdim#define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */ 354218822Sdim#define f_mode 13 /* 4- or 6-byte pointer operand */ 355218822Sdim#define const_1_mode 14 356218822Sdim#define stack_v_mode 15 /* v_mode for stack-related opcodes. */ 357218822Sdim#define z_mode 16 /* non-quad operand size depends on prefixes */ 358218822Sdim#define o_mode 17 /* 16-byte operand */ 359218822Sdim#define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */ 360218822Sdim#define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */ 36133965Sjdp 36233965Sjdp#define es_reg 100 36333965Sjdp#define cs_reg 101 36433965Sjdp#define ss_reg 102 36533965Sjdp#define ds_reg 103 36633965Sjdp#define fs_reg 104 36733965Sjdp#define gs_reg 105 36833965Sjdp 36960484Sobrien#define eAX_reg 108 37060484Sobrien#define eCX_reg 109 37160484Sobrien#define eDX_reg 110 37260484Sobrien#define eBX_reg 111 37360484Sobrien#define eSP_reg 112 37460484Sobrien#define eBP_reg 113 37560484Sobrien#define eSI_reg 114 37660484Sobrien#define eDI_reg 115 37733965Sjdp 37833965Sjdp#define al_reg 116 37933965Sjdp#define cl_reg 117 38033965Sjdp#define dl_reg 118 38133965Sjdp#define bl_reg 119 38233965Sjdp#define ah_reg 120 38333965Sjdp#define ch_reg 121 38433965Sjdp#define dh_reg 122 38533965Sjdp#define bh_reg 123 38633965Sjdp 38733965Sjdp#define ax_reg 124 38833965Sjdp#define cx_reg 125 38933965Sjdp#define dx_reg 126 39033965Sjdp#define bx_reg 127 39133965Sjdp#define sp_reg 128 39233965Sjdp#define bp_reg 129 39333965Sjdp#define si_reg 130 39433965Sjdp#define di_reg 131 39533965Sjdp 39677298Sobrien#define rAX_reg 132 39777298Sobrien#define rCX_reg 133 39877298Sobrien#define rDX_reg 134 39977298Sobrien#define rBX_reg 135 40077298Sobrien#define rSP_reg 136 40177298Sobrien#define rBP_reg 137 40277298Sobrien#define rSI_reg 138 40377298Sobrien#define rDI_reg 139 40477298Sobrien 405218822Sdim#define z_mode_ax_reg 149 40633965Sjdp#define indir_dx_reg 150 40733965Sjdp 40885815Sobrien#define FLOATCODE 1 40985815Sobrien#define USE_GROUPS 2 41085815Sobrien#define USE_PREFIX_USER_TABLE 3 41185815Sobrien#define X86_64_SPECIAL 4 412218822Sdim#define IS_3BYTE_OPCODE 5 41333965Sjdp 414218822Sdim#define FLOAT NULL, { { NULL, FLOATCODE } } 41560484Sobrien 416218822Sdim#define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } } 417218822Sdim#define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } } 418218822Sdim#define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } } 419218822Sdim#define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } } 420218822Sdim#define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } } 421218822Sdim#define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } } 422218822Sdim#define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } } 423218822Sdim#define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } } 424218822Sdim#define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } } 425218822Sdim#define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } } 426218822Sdim#define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } } 427218822Sdim#define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } } 428218822Sdim#define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } } 429218822Sdim#define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } } 430218822Sdim#define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } } 431218822Sdim#define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } } 432218822Sdim#define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } } 433218822Sdim#define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } } 434218822Sdim#define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } } 435218822Sdim#define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } } 436218822Sdim#define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } } 437218822Sdim#define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } } 438218822Sdim#define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } } 439218822Sdim#define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } } 440218822Sdim#define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } } 441218822Sdim#define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } } 442218822Sdim#define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } } 443218822Sdim#define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } } 44460484Sobrien 445218822Sdim#define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } } 446218822Sdim#define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } } 447218822Sdim#define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } } 448218822Sdim#define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } } 449218822Sdim#define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } } 450218822Sdim#define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } } 451218822Sdim#define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } } 452218822Sdim#define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } } 453218822Sdim#define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } } 454218822Sdim#define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } } 455218822Sdim#define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } } 456218822Sdim#define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } } 457218822Sdim#define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } } 458218822Sdim#define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } } 459218822Sdim#define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } } 460218822Sdim#define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } } 461218822Sdim#define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } } 462218822Sdim#define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } } 463218822Sdim#define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } } 464218822Sdim#define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } } 465218822Sdim#define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } } 466218822Sdim#define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } } 467218822Sdim#define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } } 468218822Sdim#define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } } 469218822Sdim#define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } } 470218822Sdim#define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } } 471218822Sdim#define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } } 472218822Sdim#define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } } 473218822Sdim#define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } } 474218822Sdim#define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } } 475218822Sdim#define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } } 476218822Sdim#define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } } 477218822Sdim#define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } } 478218822Sdim#define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } } 479218822Sdim#define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } } 480218822Sdim#define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } } 481218822Sdim#define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } } 482218822Sdim#define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } } 483218822Sdim#define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } } 484218822Sdim#define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } } 485218822Sdim#define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } } 486218822Sdim#define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } } 487218822Sdim#define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } } 488218822Sdim#define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } } 489218822Sdim#define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } } 490218822Sdim#define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } } 491218822Sdim#define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } } 492218822Sdim#define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } } 493218822Sdim#define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } } 494218822Sdim#define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } } 495218822Sdim#define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } } 496218822Sdim#define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } } 497218822Sdim#define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } } 498218822Sdim#define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } } 499218822Sdim#define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } } 500218822Sdim#define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } } 501218822Sdim#define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } } 502218822Sdim#define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } } 503218822Sdim#define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } } 504218822Sdim#define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } } 505218822Sdim#define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } } 506218822Sdim#define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } } 507218822Sdim#define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } } 508218822Sdim#define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } } 509218822Sdim#define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } } 510218822Sdim#define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } } 511218822Sdim#define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } } 512218822Sdim#define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } } 513218822Sdim#define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } } 514218822Sdim#define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } } 515218822Sdim#define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } } 516218822Sdim#define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } } 517218822Sdim#define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } } 518218822Sdim#define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } } 519218822Sdim#define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } } 520218822Sdim#define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } } 521218822Sdim#define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } } 522218822Sdim#define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } } 523218822Sdim#define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } } 524218822Sdim#define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } } 525218822Sdim#define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } } 526218822Sdim#define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } } 527218822Sdim#define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } } 528218822Sdim#define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } } 529218822Sdim#define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } } 530218822Sdim#define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } } 531218822Sdim#define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } } 532218822Sdim#define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } } 533218822Sdim#define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } } 534218822Sdim#define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } } 535218822Sdim#define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } } 536218822Sdim#define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } } 537218822Sdim#define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } } 538218822Sdim#define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } } 539218822Sdim#define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } } 540218822Sdim#define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } } 541218822Sdim#define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } } 542218822Sdim#define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } } 54333965Sjdp 54485815Sobrien 545218822Sdim#define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } } 546218822Sdim#define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } } 547218822Sdim#define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } } 548218822Sdim#define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } } 549218822Sdim 550218822Sdim#define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } } 551218822Sdim#define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } } 552218822Sdim 553130561Sobrientypedef void (*op_rtn) (int bytemode, int sizeflag); 55485815Sobrien 55533965Sjdpstruct dis386 { 55660484Sobrien const char *name; 557218822Sdim struct 558218822Sdim { 559218822Sdim op_rtn rtn; 560218822Sdim int bytemode; 561218822Sdim } op[MAX_OPERANDS]; 56233965Sjdp}; 56333965Sjdp 56460484Sobrien/* Upper case letters in the instruction names here are macros. 56560484Sobrien 'A' => print 'b' if no register operands or suffix_always is true 56660484Sobrien 'B' => print 'b' if suffix_always is true 567218822Sdim 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand 568218822Sdim . size prefix 569218822Sdim 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if 570218822Sdim . suffix_always is true 57160484Sobrien 'E' => print 'e' if 32-bit form of jcxz 57278828Sobrien 'F' => print 'w' or 'l' depending on address size prefix (loop insns) 573218822Sdim 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns) 57485815Sobrien 'H' => print ",pt" or ",pn" branch hint 575218822Sdim 'I' => honor following macro letter even in Intel mode (implemented only 576218822Sdim . for some of the macro letters) 577218822Sdim 'J' => print 'l' 578218822Sdim 'K' => print 'd' or 'q' if rex prefix is present. 57960484Sobrien 'L' => print 'l' if suffix_always is true 58060484Sobrien 'N' => print 'n' if instruction has no wait "prefix" 581218822Sdim 'O' => print 'd' or 'o' (or 'q' in Intel mode) 58277298Sobrien 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix, 58389857Sobrien . or suffix_always is true. print 'q' if rex prefix is present. 58489857Sobrien 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always 58589857Sobrien . is true 586218822Sdim 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode) 58777298Sobrien 'S' => print 'w', 'l' or 'q' if suffix_always is true 58885815Sobrien 'T' => print 'q' in 64bit mode and behave as 'P' otherwise 58985815Sobrien 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise 590218822Sdim 'V' => print 'q' in 64bit mode and behave as 'S' otherwise 591218822Sdim 'W' => print 'b', 'w' or 'l' ('d' in Intel mode) 59277298Sobrien 'X' => print 's', 'd' depending on data16 prefix (for XMM) 59377298Sobrien 'Y' => 'q' if instruction has an REX 64bit overwrite prefix 594218822Sdim 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise 59560484Sobrien 59685815Sobrien Many of the above letters print nothing in Intel mode. See "putop" 59785815Sobrien for the details. 59833965Sjdp 59985815Sobrien Braces '{' and '}', and vertical bars '|', indicate alternative 60085815Sobrien mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel 60185815Sobrien modes. In cases where there are only two alternatives, the X86_64 60285815Sobrien instruction is reserved, and "(bad)" is printed. 60385815Sobrien*/ 60460484Sobrien 60585815Sobrienstatic const struct dis386 dis386[] = { 60677298Sobrien /* 00 */ 607218822Sdim { "addB", { Eb, Gb } }, 608218822Sdim { "addS", { Ev, Gv } }, 609218822Sdim { "addB", { Gb, Eb } }, 610218822Sdim { "addS", { Gv, Ev } }, 611218822Sdim { "addB", { AL, Ib } }, 612218822Sdim { "addS", { eAX, Iv } }, 613218822Sdim { "push{T|}", { es } }, 614218822Sdim { "pop{T|}", { es } }, 61577298Sobrien /* 08 */ 616218822Sdim { "orB", { Eb, Gb } }, 617218822Sdim { "orS", { Ev, Gv } }, 618218822Sdim { "orB", { Gb, Eb } }, 619218822Sdim { "orS", { Gv, Ev } }, 620218822Sdim { "orB", { AL, Ib } }, 621218822Sdim { "orS", { eAX, Iv } }, 622218822Sdim { "push{T|}", { cs } }, 623218822Sdim { "(bad)", { XX } }, /* 0x0f extended opcode escape */ 62477298Sobrien /* 10 */ 625218822Sdim { "adcB", { Eb, Gb } }, 626218822Sdim { "adcS", { Ev, Gv } }, 627218822Sdim { "adcB", { Gb, Eb } }, 628218822Sdim { "adcS", { Gv, Ev } }, 629218822Sdim { "adcB", { AL, Ib } }, 630218822Sdim { "adcS", { eAX, Iv } }, 631218822Sdim { "push{T|}", { ss } }, 632218822Sdim { "pop{T|}", { ss } }, 63377298Sobrien /* 18 */ 634218822Sdim { "sbbB", { Eb, Gb } }, 635218822Sdim { "sbbS", { Ev, Gv } }, 636218822Sdim { "sbbB", { Gb, Eb } }, 637218822Sdim { "sbbS", { Gv, Ev } }, 638218822Sdim { "sbbB", { AL, Ib } }, 639218822Sdim { "sbbS", { eAX, Iv } }, 640218822Sdim { "push{T|}", { ds } }, 641218822Sdim { "pop{T|}", { ds } }, 64277298Sobrien /* 20 */ 643218822Sdim { "andB", { Eb, Gb } }, 644218822Sdim { "andS", { Ev, Gv } }, 645218822Sdim { "andB", { Gb, Eb } }, 646218822Sdim { "andS", { Gv, Ev } }, 647218822Sdim { "andB", { AL, Ib } }, 648218822Sdim { "andS", { eAX, Iv } }, 649218822Sdim { "(bad)", { XX } }, /* SEG ES prefix */ 650218822Sdim { "daa{|}", { XX } }, 65177298Sobrien /* 28 */ 652218822Sdim { "subB", { Eb, Gb } }, 653218822Sdim { "subS", { Ev, Gv } }, 654218822Sdim { "subB", { Gb, Eb } }, 655218822Sdim { "subS", { Gv, Ev } }, 656218822Sdim { "subB", { AL, Ib } }, 657218822Sdim { "subS", { eAX, Iv } }, 658218822Sdim { "(bad)", { XX } }, /* SEG CS prefix */ 659218822Sdim { "das{|}", { XX } }, 66077298Sobrien /* 30 */ 661218822Sdim { "xorB", { Eb, Gb } }, 662218822Sdim { "xorS", { Ev, Gv } }, 663218822Sdim { "xorB", { Gb, Eb } }, 664218822Sdim { "xorS", { Gv, Ev } }, 665218822Sdim { "xorB", { AL, Ib } }, 666218822Sdim { "xorS", { eAX, Iv } }, 667218822Sdim { "(bad)", { XX } }, /* SEG SS prefix */ 668218822Sdim { "aaa{|}", { XX } }, 66977298Sobrien /* 38 */ 670218822Sdim { "cmpB", { Eb, Gb } }, 671218822Sdim { "cmpS", { Ev, Gv } }, 672218822Sdim { "cmpB", { Gb, Eb } }, 673218822Sdim { "cmpS", { Gv, Ev } }, 674218822Sdim { "cmpB", { AL, Ib } }, 675218822Sdim { "cmpS", { eAX, Iv } }, 676218822Sdim { "(bad)", { XX } }, /* SEG DS prefix */ 677218822Sdim { "aas{|}", { XX } }, 67877298Sobrien /* 40 */ 679218822Sdim { "inc{S|}", { RMeAX } }, 680218822Sdim { "inc{S|}", { RMeCX } }, 681218822Sdim { "inc{S|}", { RMeDX } }, 682218822Sdim { "inc{S|}", { RMeBX } }, 683218822Sdim { "inc{S|}", { RMeSP } }, 684218822Sdim { "inc{S|}", { RMeBP } }, 685218822Sdim { "inc{S|}", { RMeSI } }, 686218822Sdim { "inc{S|}", { RMeDI } }, 68777298Sobrien /* 48 */ 688218822Sdim { "dec{S|}", { RMeAX } }, 689218822Sdim { "dec{S|}", { RMeCX } }, 690218822Sdim { "dec{S|}", { RMeDX } }, 691218822Sdim { "dec{S|}", { RMeBX } }, 692218822Sdim { "dec{S|}", { RMeSP } }, 693218822Sdim { "dec{S|}", { RMeBP } }, 694218822Sdim { "dec{S|}", { RMeSI } }, 695218822Sdim { "dec{S|}", { RMeDI } }, 69677298Sobrien /* 50 */ 697218822Sdim { "pushV", { RMrAX } }, 698218822Sdim { "pushV", { RMrCX } }, 699218822Sdim { "pushV", { RMrDX } }, 700218822Sdim { "pushV", { RMrBX } }, 701218822Sdim { "pushV", { RMrSP } }, 702218822Sdim { "pushV", { RMrBP } }, 703218822Sdim { "pushV", { RMrSI } }, 704218822Sdim { "pushV", { RMrDI } }, 70577298Sobrien /* 58 */ 706218822Sdim { "popV", { RMrAX } }, 707218822Sdim { "popV", { RMrCX } }, 708218822Sdim { "popV", { RMrDX } }, 709218822Sdim { "popV", { RMrBX } }, 710218822Sdim { "popV", { RMrSP } }, 711218822Sdim { "popV", { RMrBP } }, 712218822Sdim { "popV", { RMrSI } }, 713218822Sdim { "popV", { RMrDI } }, 71477298Sobrien /* 60 */ 71585815Sobrien { X86_64_0 }, 716218822Sdim { X86_64_1 }, 717218822Sdim { X86_64_2 }, 718218822Sdim { X86_64_3 }, 719218822Sdim { "(bad)", { XX } }, /* seg fs */ 720218822Sdim { "(bad)", { XX } }, /* seg gs */ 721218822Sdim { "(bad)", { XX } }, /* op size prefix */ 722218822Sdim { "(bad)", { XX } }, /* adr size prefix */ 72377298Sobrien /* 68 */ 724218822Sdim { "pushT", { Iq } }, 725218822Sdim { "imulS", { Gv, Ev, Iv } }, 726218822Sdim { "pushT", { sIb } }, 727218822Sdim { "imulS", { Gv, Ev, sIb } }, 728218822Sdim { "ins{b||b|}", { Ybr, indirDX } }, 729218822Sdim { "ins{R||G|}", { Yzr, indirDX } }, 730218822Sdim { "outs{b||b|}", { indirDXr, Xb } }, 731218822Sdim { "outs{R||G|}", { indirDXr, Xz } }, 73277298Sobrien /* 70 */ 733218822Sdim { "joH", { Jb, XX, cond_jump_flag } }, 734218822Sdim { "jnoH", { Jb, XX, cond_jump_flag } }, 735218822Sdim { "jbH", { Jb, XX, cond_jump_flag } }, 736218822Sdim { "jaeH", { Jb, XX, cond_jump_flag } }, 737218822Sdim { "jeH", { Jb, XX, cond_jump_flag } }, 738218822Sdim { "jneH", { Jb, XX, cond_jump_flag } }, 739218822Sdim { "jbeH", { Jb, XX, cond_jump_flag } }, 740218822Sdim { "jaH", { Jb, XX, cond_jump_flag } }, 74177298Sobrien /* 78 */ 742218822Sdim { "jsH", { Jb, XX, cond_jump_flag } }, 743218822Sdim { "jnsH", { Jb, XX, cond_jump_flag } }, 744218822Sdim { "jpH", { Jb, XX, cond_jump_flag } }, 745218822Sdim { "jnpH", { Jb, XX, cond_jump_flag } }, 746218822Sdim { "jlH", { Jb, XX, cond_jump_flag } }, 747218822Sdim { "jgeH", { Jb, XX, cond_jump_flag } }, 748218822Sdim { "jleH", { Jb, XX, cond_jump_flag } }, 749218822Sdim { "jgH", { Jb, XX, cond_jump_flag } }, 75077298Sobrien /* 80 */ 75177298Sobrien { GRP1b }, 75277298Sobrien { GRP1S }, 753218822Sdim { "(bad)", { XX } }, 75477298Sobrien { GRP1Ss }, 755218822Sdim { "testB", { Eb, Gb } }, 756218822Sdim { "testS", { Ev, Gv } }, 757218822Sdim { "xchgB", { Eb, Gb } }, 758218822Sdim { "xchgS", { Ev, Gv } }, 75977298Sobrien /* 88 */ 760218822Sdim { "movB", { Eb, Gb } }, 761218822Sdim { "movS", { Ev, Gv } }, 762218822Sdim { "movB", { Gb, Eb } }, 763218822Sdim { "movS", { Gv, Ev } }, 764218822Sdim { "movD", { Sv, Sw } }, 765218822Sdim { "leaS", { Gv, M } }, 766218822Sdim { "movD", { Sw, Sv } }, 767218822Sdim { GRP1a }, 76877298Sobrien /* 90 */ 769218822Sdim { PREGRP38 }, 770218822Sdim { "xchgS", { RMeCX, eAX } }, 771218822Sdim { "xchgS", { RMeDX, eAX } }, 772218822Sdim { "xchgS", { RMeBX, eAX } }, 773218822Sdim { "xchgS", { RMeSP, eAX } }, 774218822Sdim { "xchgS", { RMeBP, eAX } }, 775218822Sdim { "xchgS", { RMeSI, eAX } }, 776218822Sdim { "xchgS", { RMeDI, eAX } }, 77777298Sobrien /* 98 */ 778218822Sdim { "cW{t||t|}R", { XX } }, 779218822Sdim { "cR{t||t|}O", { XX } }, 780218822Sdim { "Jcall{T|}", { Ap } }, 781218822Sdim { "(bad)", { XX } }, /* fwait */ 782218822Sdim { "pushfT", { XX } }, 783218822Sdim { "popfT", { XX } }, 784218822Sdim { "sahf{|}", { XX } }, 785218822Sdim { "lahf{|}", { XX } }, 78677298Sobrien /* a0 */ 787218822Sdim { "movB", { AL, Ob } }, 788218822Sdim { "movS", { eAX, Ov } }, 789218822Sdim { "movB", { Ob, AL } }, 790218822Sdim { "movS", { Ov, eAX } }, 791218822Sdim { "movs{b||b|}", { Ybr, Xb } }, 792218822Sdim { "movs{R||R|}", { Yvr, Xv } }, 793218822Sdim { "cmps{b||b|}", { Xb, Yb } }, 794218822Sdim { "cmps{R||R|}", { Xv, Yv } }, 79577298Sobrien /* a8 */ 796218822Sdim { "testB", { AL, Ib } }, 797218822Sdim { "testS", { eAX, Iv } }, 798218822Sdim { "stosB", { Ybr, AL } }, 799218822Sdim { "stosS", { Yvr, eAX } }, 800218822Sdim { "lodsB", { ALr, Xb } }, 801218822Sdim { "lodsS", { eAXr, Xv } }, 802218822Sdim { "scasB", { AL, Yb } }, 803218822Sdim { "scasS", { eAX, Yv } }, 80477298Sobrien /* b0 */ 805218822Sdim { "movB", { RMAL, Ib } }, 806218822Sdim { "movB", { RMCL, Ib } }, 807218822Sdim { "movB", { RMDL, Ib } }, 808218822Sdim { "movB", { RMBL, Ib } }, 809218822Sdim { "movB", { RMAH, Ib } }, 810218822Sdim { "movB", { RMCH, Ib } }, 811218822Sdim { "movB", { RMDH, Ib } }, 812218822Sdim { "movB", { RMBH, Ib } }, 81377298Sobrien /* b8 */ 814218822Sdim { "movS", { RMeAX, Iv64 } }, 815218822Sdim { "movS", { RMeCX, Iv64 } }, 816218822Sdim { "movS", { RMeDX, Iv64 } }, 817218822Sdim { "movS", { RMeBX, Iv64 } }, 818218822Sdim { "movS", { RMeSP, Iv64 } }, 819218822Sdim { "movS", { RMeBP, Iv64 } }, 820218822Sdim { "movS", { RMeSI, Iv64 } }, 821218822Sdim { "movS", { RMeDI, Iv64 } }, 82277298Sobrien /* c0 */ 82377298Sobrien { GRP2b }, 82477298Sobrien { GRP2S }, 825218822Sdim { "retT", { Iw } }, 826218822Sdim { "retT", { XX } }, 827218822Sdim { "les{S|}", { Gv, Mp } }, 828218822Sdim { "ldsS", { Gv, Mp } }, 829218822Sdim { GRP11_C6 }, 830218822Sdim { GRP11_C7 }, 83177298Sobrien /* c8 */ 832218822Sdim { "enterT", { Iw, Ib } }, 833218822Sdim { "leaveT", { XX } }, 834218822Sdim { "lretP", { Iw } }, 835218822Sdim { "lretP", { XX } }, 836218822Sdim { "int3", { XX } }, 837218822Sdim { "int", { Ib } }, 838218822Sdim { "into{|}", { XX } }, 839218822Sdim { "iretP", { XX } }, 84077298Sobrien /* d0 */ 84177298Sobrien { GRP2b_one }, 84277298Sobrien { GRP2S_one }, 84377298Sobrien { GRP2b_cl }, 84477298Sobrien { GRP2S_cl }, 845218822Sdim { "aam{|}", { sIb } }, 846218822Sdim { "aad{|}", { sIb } }, 847218822Sdim { "(bad)", { XX } }, 848218822Sdim { "xlat", { DSBX } }, 84977298Sobrien /* d8 */ 85077298Sobrien { FLOAT }, 85177298Sobrien { FLOAT }, 85277298Sobrien { FLOAT }, 85377298Sobrien { FLOAT }, 85477298Sobrien { FLOAT }, 85577298Sobrien { FLOAT }, 85677298Sobrien { FLOAT }, 85777298Sobrien { FLOAT }, 85877298Sobrien /* e0 */ 859218822Sdim { "loopneFH", { Jb, XX, loop_jcxz_flag } }, 860218822Sdim { "loopeFH", { Jb, XX, loop_jcxz_flag } }, 861218822Sdim { "loopFH", { Jb, XX, loop_jcxz_flag } }, 862218822Sdim { "jEcxzH", { Jb, XX, loop_jcxz_flag } }, 863218822Sdim { "inB", { AL, Ib } }, 864218822Sdim { "inG", { zAX, Ib } }, 865218822Sdim { "outB", { Ib, AL } }, 866218822Sdim { "outG", { Ib, zAX } }, 86777298Sobrien /* e8 */ 868218822Sdim { "callT", { Jv } }, 869218822Sdim { "jmpT", { Jv } }, 870218822Sdim { "Jjmp{T|}", { Ap } }, 871218822Sdim { "jmp", { Jb } }, 872218822Sdim { "inB", { AL, indirDX } }, 873218822Sdim { "inG", { zAX, indirDX } }, 874218822Sdim { "outB", { indirDX, AL } }, 875218822Sdim { "outG", { indirDX, zAX } }, 87677298Sobrien /* f0 */ 877218822Sdim { "(bad)", { XX } }, /* lock prefix */ 878218822Sdim { "icebp", { XX } }, 879218822Sdim { "(bad)", { XX } }, /* repne */ 880218822Sdim { "(bad)", { XX } }, /* repz */ 881218822Sdim { "hlt", { XX } }, 882218822Sdim { "cmc", { XX } }, 88377298Sobrien { GRP3b }, 88477298Sobrien { GRP3S }, 88577298Sobrien /* f8 */ 886218822Sdim { "clc", { XX } }, 887218822Sdim { "stc", { XX } }, 888218822Sdim { "cli", { XX } }, 889218822Sdim { "sti", { XX } }, 890218822Sdim { "cld", { XX } }, 891218822Sdim { "std", { XX } }, 89277298Sobrien { GRP4 }, 89377298Sobrien { GRP5 }, 89477298Sobrien}; 89577298Sobrien 89685815Sobrienstatic const struct dis386 dis386_twobyte[] = { 89777298Sobrien /* 00 */ 89833965Sjdp { GRP6 }, 89933965Sjdp { GRP7 }, 900218822Sdim { "larS", { Gv, Ew } }, 901218822Sdim { "lslS", { Gv, Ew } }, 902218822Sdim { "(bad)", { XX } }, 903218822Sdim { "syscall", { XX } }, 904218822Sdim { "clts", { XX } }, 905218822Sdim { "sysretP", { XX } }, 90633965Sjdp /* 08 */ 907218822Sdim { "invd", { XX } }, 908218822Sdim { "wbinvd", { XX } }, 909218822Sdim { "(bad)", { XX } }, 910218822Sdim { "ud2a", { XX } }, 911218822Sdim { "(bad)", { XX } }, 91260484Sobrien { GRPAMD }, 913218822Sdim { "femms", { XX } }, 914218822Sdim { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */ 91533965Sjdp /* 10 */ 91660484Sobrien { PREGRP8 }, 91760484Sobrien { PREGRP9 }, 918130561Sobrien { PREGRP30 }, 919218822Sdim { "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } }, 920218822Sdim { "unpcklpX", { XM, EXq } }, 921218822Sdim { "unpckhpX", { XM, EXq } }, 922130561Sobrien { PREGRP31 }, 923218822Sdim { "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } }, 92433965Sjdp /* 18 */ 925218822Sdim { GRP16 }, 926218822Sdim { "(bad)", { XX } }, 927218822Sdim { "(bad)", { XX } }, 928218822Sdim { "(bad)", { XX } }, 929218822Sdim { "(bad)", { XX } }, 930218822Sdim { "(bad)", { XX } }, 931218822Sdim { "(bad)", { XX } }, 932218822Sdim { "nopQ", { Ev } }, 93333965Sjdp /* 20 */ 934218822Sdim { "movZ", { Rm, Cm } }, 935218822Sdim { "movZ", { Rm, Dm } }, 936218822Sdim { "movZ", { Cm, Rm } }, 937218822Sdim { "movZ", { Dm, Rm } }, 938218822Sdim { "movL", { Rd, Td } }, 939218822Sdim { "(bad)", { XX } }, 940218822Sdim { "movL", { Td, Rd } }, 941218822Sdim { "(bad)", { XX } }, 94233965Sjdp /* 28 */ 943218822Sdim { "movapX", { XM, EXx } }, 944218822Sdim { "movapX", { EXx, XM } }, 94560484Sobrien { PREGRP2 }, 946218822Sdim { PREGRP33 }, 94760484Sobrien { PREGRP4 }, 94860484Sobrien { PREGRP3 }, 949218822Sdim { PREGRP93 }, 950218822Sdim { PREGRP94 }, 95133965Sjdp /* 30 */ 952218822Sdim { "wrmsr", { XX } }, 953218822Sdim { "rdtsc", { XX } }, 954218822Sdim { "rdmsr", { XX } }, 955218822Sdim { "rdpmc", { XX } }, 956218822Sdim { "sysenter", { XX } }, 957218822Sdim { "sysexit", { XX } }, 958218822Sdim { "(bad)", { XX } }, 959218822Sdim { "(bad)", { XX } }, 96033965Sjdp /* 38 */ 961218822Sdim { THREE_BYTE_0 }, 962218822Sdim { "(bad)", { XX } }, 963218822Sdim { THREE_BYTE_1 }, 964218822Sdim { "(bad)", { XX } }, 965218822Sdim { "(bad)", { XX } }, 966218822Sdim { "(bad)", { XX } }, 967218822Sdim { "(bad)", { XX } }, 968218822Sdim { "(bad)", { XX } }, 96933965Sjdp /* 40 */ 970218822Sdim { "cmovo", { Gv, Ev } }, 971218822Sdim { "cmovno", { Gv, Ev } }, 972218822Sdim { "cmovb", { Gv, Ev } }, 973218822Sdim { "cmovae", { Gv, Ev } }, 974218822Sdim { "cmove", { Gv, Ev } }, 975218822Sdim { "cmovne", { Gv, Ev } }, 976218822Sdim { "cmovbe", { Gv, Ev } }, 977218822Sdim { "cmova", { Gv, Ev } }, 97833965Sjdp /* 48 */ 979218822Sdim { "cmovs", { Gv, Ev } }, 980218822Sdim { "cmovns", { Gv, Ev } }, 981218822Sdim { "cmovp", { Gv, Ev } }, 982218822Sdim { "cmovnp", { Gv, Ev } }, 983218822Sdim { "cmovl", { Gv, Ev } }, 984218822Sdim { "cmovge", { Gv, Ev } }, 985218822Sdim { "cmovle", { Gv, Ev } }, 986218822Sdim { "cmovg", { Gv, Ev } }, 98733965Sjdp /* 50 */ 988218822Sdim { "movmskpX", { Gdq, XS } }, 98960484Sobrien { PREGRP13 }, 99060484Sobrien { PREGRP12 }, 99160484Sobrien { PREGRP11 }, 992218822Sdim { "andpX", { XM, EXx } }, 993218822Sdim { "andnpX", { XM, EXx } }, 994218822Sdim { "orpX", { XM, EXx } }, 995218822Sdim { "xorpX", { XM, EXx } }, 99633965Sjdp /* 58 */ 99760484Sobrien { PREGRP0 }, 99860484Sobrien { PREGRP10 }, 99977298Sobrien { PREGRP17 }, 100077298Sobrien { PREGRP16 }, 100160484Sobrien { PREGRP14 }, 100260484Sobrien { PREGRP7 }, 100360484Sobrien { PREGRP5 }, 100460484Sobrien { PREGRP6 }, 100533965Sjdp /* 60 */ 1006218822Sdim { PREGRP95 }, 1007218822Sdim { PREGRP96 }, 1008218822Sdim { PREGRP97 }, 1009218822Sdim { "packsswb", { MX, EM } }, 1010218822Sdim { "pcmpgtb", { MX, EM } }, 1011218822Sdim { "pcmpgtw", { MX, EM } }, 1012218822Sdim { "pcmpgtd", { MX, EM } }, 1013218822Sdim { "packuswb", { MX, EM } }, 101433965Sjdp /* 68 */ 1015218822Sdim { "punpckhbw", { MX, EM } }, 1016218822Sdim { "punpckhwd", { MX, EM } }, 1017218822Sdim { "punpckhdq", { MX, EM } }, 1018218822Sdim { "packssdw", { MX, EM } }, 101977298Sobrien { PREGRP26 }, 102077298Sobrien { PREGRP24 }, 1021218822Sdim { "movd", { MX, Edq } }, 102277298Sobrien { PREGRP19 }, 102333965Sjdp /* 70 */ 102477298Sobrien { PREGRP22 }, 102533965Sjdp { GRP12 }, 1026218822Sdim { GRP13 }, 1027218822Sdim { GRP14 }, 1028218822Sdim { "pcmpeqb", { MX, EM } }, 1029218822Sdim { "pcmpeqw", { MX, EM } }, 1030218822Sdim { "pcmpeqd", { MX, EM } }, 1031218822Sdim { "emms", { XX } }, 103233965Sjdp /* 78 */ 1033218822Sdim { PREGRP34 }, 1034218822Sdim { PREGRP35 }, 1035218822Sdim { "(bad)", { XX } }, 1036218822Sdim { "(bad)", { XX } }, 1037130561Sobrien { PREGRP28 }, 1038130561Sobrien { PREGRP29 }, 103977298Sobrien { PREGRP23 }, 104077298Sobrien { PREGRP20 }, 104133965Sjdp /* 80 */ 1042218822Sdim { "joH", { Jv, XX, cond_jump_flag } }, 1043218822Sdim { "jnoH", { Jv, XX, cond_jump_flag } }, 1044218822Sdim { "jbH", { Jv, XX, cond_jump_flag } }, 1045218822Sdim { "jaeH", { Jv, XX, cond_jump_flag } }, 1046218822Sdim { "jeH", { Jv, XX, cond_jump_flag } }, 1047218822Sdim { "jneH", { Jv, XX, cond_jump_flag } }, 1048218822Sdim { "jbeH", { Jv, XX, cond_jump_flag } }, 1049218822Sdim { "jaH", { Jv, XX, cond_jump_flag } }, 105033965Sjdp /* 88 */ 1051218822Sdim { "jsH", { Jv, XX, cond_jump_flag } }, 1052218822Sdim { "jnsH", { Jv, XX, cond_jump_flag } }, 1053218822Sdim { "jpH", { Jv, XX, cond_jump_flag } }, 1054218822Sdim { "jnpH", { Jv, XX, cond_jump_flag } }, 1055218822Sdim { "jlH", { Jv, XX, cond_jump_flag } }, 1056218822Sdim { "jgeH", { Jv, XX, cond_jump_flag } }, 1057218822Sdim { "jleH", { Jv, XX, cond_jump_flag } }, 1058218822Sdim { "jgH", { Jv, XX, cond_jump_flag } }, 105933965Sjdp /* 90 */ 1060218822Sdim { "seto", { Eb } }, 1061218822Sdim { "setno", { Eb } }, 1062218822Sdim { "setb", { Eb } }, 1063218822Sdim { "setae", { Eb } }, 1064218822Sdim { "sete", { Eb } }, 1065218822Sdim { "setne", { Eb } }, 1066218822Sdim { "setbe", { Eb } }, 1067218822Sdim { "seta", { Eb } }, 106833965Sjdp /* 98 */ 1069218822Sdim { "sets", { Eb } }, 1070218822Sdim { "setns", { Eb } }, 1071218822Sdim { "setp", { Eb } }, 1072218822Sdim { "setnp", { Eb } }, 1073218822Sdim { "setl", { Eb } }, 1074218822Sdim { "setge", { Eb } }, 1075218822Sdim { "setle", { Eb } }, 1076218822Sdim { "setg", { Eb } }, 107733965Sjdp /* a0 */ 1078218822Sdim { "pushT", { fs } }, 1079218822Sdim { "popT", { fs } }, 1080218822Sdim { "cpuid", { XX } }, 1081218822Sdim { "btS", { Ev, Gv } }, 1082218822Sdim { "shldS", { Ev, Gv, Ib } }, 1083218822Sdim { "shldS", { Ev, Gv, CL } }, 1084218822Sdim { GRPPADLCK2 }, 1085218822Sdim { GRPPADLCK1 }, 108633965Sjdp /* a8 */ 1087218822Sdim { "pushT", { gs } }, 1088218822Sdim { "popT", { gs } }, 1089218822Sdim { "rsm", { XX } }, 1090218822Sdim { "btsS", { Ev, Gv } }, 1091218822Sdim { "shrdS", { Ev, Gv, Ib } }, 1092218822Sdim { "shrdS", { Ev, Gv, CL } }, 1093218822Sdim { GRP15 }, 1094218822Sdim { "imulS", { Gv, Ev } }, 109533965Sjdp /* b0 */ 1096218822Sdim { "cmpxchgB", { Eb, Gb } }, 1097218822Sdim { "cmpxchgS", { Ev, Gv } }, 1098218822Sdim { "lssS", { Gv, Mp } }, 1099218822Sdim { "btrS", { Ev, Gv } }, 1100218822Sdim { "lfsS", { Gv, Mp } }, 1101218822Sdim { "lgsS", { Gv, Mp } }, 1102218822Sdim { "movz{bR|x|bR|x}", { Gv, Eb } }, 1103218822Sdim { "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */ 110433965Sjdp /* b8 */ 1105218822Sdim { PREGRP37 }, 1106218822Sdim { "ud2b", { XX } }, 110733965Sjdp { GRP8 }, 1108218822Sdim { "btcS", { Ev, Gv } }, 1109218822Sdim { "bsfS", { Gv, Ev } }, 1110218822Sdim { PREGRP36 }, 1111218822Sdim { "movs{bR|x|bR|x}", { Gv, Eb } }, 1112218822Sdim { "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */ 111333965Sjdp /* c0 */ 1114218822Sdim { "xaddB", { Eb, Gb } }, 1115218822Sdim { "xaddS", { Ev, Gv } }, 111660484Sobrien { PREGRP1 }, 1117218822Sdim { "movntiS", { Ev, Gv } }, 1118218822Sdim { "pinsrw", { MX, Edqw, Ib } }, 1119218822Sdim { "pextrw", { Gdq, MS, Ib } }, 1120218822Sdim { "shufpX", { XM, EXx, Ib } }, 112160484Sobrien { GRP9 }, 112233965Sjdp /* c8 */ 1123218822Sdim { "bswap", { RMeAX } }, 1124218822Sdim { "bswap", { RMeCX } }, 1125218822Sdim { "bswap", { RMeDX } }, 1126218822Sdim { "bswap", { RMeBX } }, 1127218822Sdim { "bswap", { RMeSP } }, 1128218822Sdim { "bswap", { RMeBP } }, 1129218822Sdim { "bswap", { RMeSI } }, 1130218822Sdim { "bswap", { RMeDI } }, 113133965Sjdp /* d0 */ 1132130561Sobrien { PREGRP27 }, 1133218822Sdim { "psrlw", { MX, EM } }, 1134218822Sdim { "psrld", { MX, EM } }, 1135218822Sdim { "psrlq", { MX, EM } }, 1136218822Sdim { "paddq", { MX, EM } }, 1137218822Sdim { "pmullw", { MX, EM } }, 113877298Sobrien { PREGRP21 }, 1139218822Sdim { "pmovmskb", { Gdq, MS } }, 114033965Sjdp /* d8 */ 1141218822Sdim { "psubusb", { MX, EM } }, 1142218822Sdim { "psubusw", { MX, EM } }, 1143218822Sdim { "pminub", { MX, EM } }, 1144218822Sdim { "pand", { MX, EM } }, 1145218822Sdim { "paddusb", { MX, EM } }, 1146218822Sdim { "paddusw", { MX, EM } }, 1147218822Sdim { "pmaxub", { MX, EM } }, 1148218822Sdim { "pandn", { MX, EM } }, 114933965Sjdp /* e0 */ 1150218822Sdim { "pavgb", { MX, EM } }, 1151218822Sdim { "psraw", { MX, EM } }, 1152218822Sdim { "psrad", { MX, EM } }, 1153218822Sdim { "pavgw", { MX, EM } }, 1154218822Sdim { "pmulhuw", { MX, EM } }, 1155218822Sdim { "pmulhw", { MX, EM } }, 115677298Sobrien { PREGRP15 }, 115777298Sobrien { PREGRP25 }, 115833965Sjdp /* e8 */ 1159218822Sdim { "psubsb", { MX, EM } }, 1160218822Sdim { "psubsw", { MX, EM } }, 1161218822Sdim { "pminsw", { MX, EM } }, 1162218822Sdim { "por", { MX, EM } }, 1163218822Sdim { "paddsb", { MX, EM } }, 1164218822Sdim { "paddsw", { MX, EM } }, 1165218822Sdim { "pmaxsw", { MX, EM } }, 1166218822Sdim { "pxor", { MX, EM } }, 116733965Sjdp /* f0 */ 1168130561Sobrien { PREGRP32 }, 1169218822Sdim { "psllw", { MX, EM } }, 1170218822Sdim { "pslld", { MX, EM } }, 1171218822Sdim { "psllq", { MX, EM } }, 1172218822Sdim { "pmuludq", { MX, EM } }, 1173218822Sdim { "pmaddwd", { MX, EM } }, 1174218822Sdim { "psadbw", { MX, EM } }, 117577298Sobrien { PREGRP18 }, 117633965Sjdp /* f8 */ 1177218822Sdim { "psubb", { MX, EM } }, 1178218822Sdim { "psubw", { MX, EM } }, 1179218822Sdim { "psubd", { MX, EM } }, 1180218822Sdim { "psubq", { MX, EM } }, 1181218822Sdim { "paddb", { MX, EM } }, 1182218822Sdim { "paddw", { MX, EM } }, 1183218822Sdim { "paddd", { MX, EM } }, 1184218822Sdim { "(bad)", { XX } }, 118533965Sjdp}; 118633965Sjdp 118733965Sjdpstatic const unsigned char onebyte_has_modrm[256] = { 118860484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 118960484Sobrien /* ------------------------------- */ 119060484Sobrien /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */ 119160484Sobrien /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */ 119260484Sobrien /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */ 119360484Sobrien /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */ 119460484Sobrien /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */ 119560484Sobrien /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */ 119660484Sobrien /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */ 119760484Sobrien /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */ 119860484Sobrien /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */ 119960484Sobrien /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */ 120060484Sobrien /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */ 120160484Sobrien /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */ 120260484Sobrien /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */ 120360484Sobrien /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */ 120460484Sobrien /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */ 120560484Sobrien /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */ 120660484Sobrien /* ------------------------------- */ 120760484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 120833965Sjdp}; 120933965Sjdp 121033965Sjdpstatic const unsigned char twobyte_has_modrm[256] = { 121160484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 121260484Sobrien /* ------------------------------- */ 121360484Sobrien /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ 1214218822Sdim /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */ 121578828Sobrien /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ 1216218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ 121733965Sjdp /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ 121878828Sobrien /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ 121978828Sobrien /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ 1220218822Sdim /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */ 122133965Sjdp /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 122233965Sjdp /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ 1223218822Sdim /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */ 1224218822Sdim /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */ 122533965Sjdp /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ 1226130561Sobrien /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */ 122778828Sobrien /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ 1228130561Sobrien /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */ 122960484Sobrien /* ------------------------------- */ 123060484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 123133965Sjdp}; 123233965Sjdp 1233218822Sdimstatic const unsigned char twobyte_uses_DATA_prefix[256] = { 123460484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 123560484Sobrien /* ------------------------------- */ 123660484Sobrien /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1237130561Sobrien /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ 1238218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1239218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */ 124060484Sobrien /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 124177298Sobrien /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 124277298Sobrien /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ 1243218822Sdim /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */ 124460484Sobrien /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 124560484Sobrien /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 124660484Sobrien /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 124760484Sobrien /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 124860484Sobrien /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1249130561Sobrien /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 125077298Sobrien /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1251130561Sobrien /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */ 125260484Sobrien /* ------------------------------- */ 125360484Sobrien /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 125460484Sobrien}; 125560484Sobrien 1256218822Sdimstatic const unsigned char twobyte_uses_REPNZ_prefix[256] = { 1257218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1258218822Sdim /* ------------------------------- */ 1259218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1260218822Sdim /* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1261218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1262218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1263218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1264218822Sdim /* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */ 1265218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1266218822Sdim /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */ 1267218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1268218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1269218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1270218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1271218822Sdim /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1272218822Sdim /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1273218822Sdim /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1274218822Sdim /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1275218822Sdim /* ------------------------------- */ 1276218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1277218822Sdim}; 1278218822Sdim 1279218822Sdimstatic const unsigned char twobyte_uses_REPZ_prefix[256] = { 1280218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1281218822Sdim /* ------------------------------- */ 1282218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1283218822Sdim /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */ 1284218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */ 1285218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1286218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1287218822Sdim /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 1288218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */ 1289218822Sdim /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */ 1290218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1291218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1292218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1293218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */ 1294218822Sdim /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1295218822Sdim /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */ 1296218822Sdim /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 1297218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1298218822Sdim /* ------------------------------- */ 1299218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1300218822Sdim}; 1301218822Sdim 1302218822Sdim/* This is used to determine if opcode 0f 38 XX uses DATA prefix. */ 1303218822Sdimstatic const unsigned char threebyte_0x38_uses_DATA_prefix[256] = { 1304218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1305218822Sdim /* ------------------------------- */ 1306218822Sdim /* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */ 1307218822Sdim /* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */ 1308218822Sdim /* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */ 1309218822Sdim /* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */ 1310218822Sdim /* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1311218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1312218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1313218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1314218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1315218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1316218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1317218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1318218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1319218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1320218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1321218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1322218822Sdim /* ------------------------------- */ 1323218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1324218822Sdim}; 1325218822Sdim 1326218822Sdim/* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */ 1327218822Sdimstatic const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = { 1328218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1329218822Sdim /* ------------------------------- */ 1330218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1331218822Sdim /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1332218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1333218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1334218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1335218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1336218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1337218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1338218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1339218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1340218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1341218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1342218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1343218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1344218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1345218822Sdim /* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1346218822Sdim /* ------------------------------- */ 1347218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1348218822Sdim}; 1349218822Sdim 1350218822Sdim/* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */ 1351218822Sdimstatic const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = { 1352218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1353218822Sdim /* ------------------------------- */ 1354218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1355218822Sdim /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1356218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1357218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1358218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1359218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1360218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1361218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1362218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1363218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1364218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1365218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1366218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1367218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1368218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1369218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1370218822Sdim /* ------------------------------- */ 1371218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1372218822Sdim}; 1373218822Sdim 1374218822Sdim/* This is used to determine if opcode 0f 3a XX uses DATA prefix. */ 1375218822Sdimstatic const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = { 1376218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1377218822Sdim /* ------------------------------- */ 1378218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */ 1379218822Sdim /* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */ 1380218822Sdim /* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1381218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1382218822Sdim /* 40 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1383218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1384218822Sdim /* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1385218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1386218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1387218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1388218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1389218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1390218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1391218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1392218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1393218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1394218822Sdim /* ------------------------------- */ 1395218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1396218822Sdim}; 1397218822Sdim 1398218822Sdim/* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */ 1399218822Sdimstatic const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = { 1400218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1401218822Sdim /* ------------------------------- */ 1402218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1403218822Sdim /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1404218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1405218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1406218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1407218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1408218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1409218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1410218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1411218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1412218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1413218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1414218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1415218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1416218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1417218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1418218822Sdim /* ------------------------------- */ 1419218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1420218822Sdim}; 1421218822Sdim 1422218822Sdim/* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */ 1423218822Sdimstatic const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = { 1424218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1425218822Sdim /* ------------------------------- */ 1426218822Sdim /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 1427218822Sdim /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */ 1428218822Sdim /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */ 1429218822Sdim /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */ 1430218822Sdim /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1431218822Sdim /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */ 1432218822Sdim /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */ 1433218822Sdim /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */ 1434218822Sdim /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1435218822Sdim /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1436218822Sdim /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1437218822Sdim /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1438218822Sdim /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 1439218822Sdim /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */ 1440218822Sdim /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */ 1441218822Sdim /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */ 1442218822Sdim /* ------------------------------- */ 1443218822Sdim /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1444218822Sdim}; 1445218822Sdim 144633965Sjdpstatic char obuf[100]; 144733965Sjdpstatic char *obufp; 144833965Sjdpstatic char scratchbuf[100]; 144933965Sjdpstatic unsigned char *start_codep; 145060484Sobrienstatic unsigned char *insn_codep; 145133965Sjdpstatic unsigned char *codep; 145233965Sjdpstatic disassemble_info *the_info; 1453218822Sdimstatic struct 1454218822Sdim { 1455218822Sdim int mod; 1456218822Sdim int reg; 1457218822Sdim int rm; 1458218822Sdim } 1459218822Sdimmodrm; 146078828Sobrienstatic unsigned char need_modrm; 146133965Sjdp 146278828Sobrien/* If we are accessing mod/rm/reg without need_modrm set, then the 146378828Sobrien values are stale. Hitting this abort likely indicates that you 146478828Sobrien need to update onebyte_has_modrm or twobyte_has_modrm. */ 146578828Sobrien#define MODRM_CHECK if (!need_modrm) abort () 146678828Sobrien 146785815Sobrienstatic const char **names64; 146885815Sobrienstatic const char **names32; 146985815Sobrienstatic const char **names16; 147085815Sobrienstatic const char **names8; 147185815Sobrienstatic const char **names8rex; 147285815Sobrienstatic const char **names_seg; 147385815Sobrienstatic const char **index16; 147485815Sobrien 147585815Sobrienstatic const char *intel_names64[] = { 147685815Sobrien "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi", 147785815Sobrien "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" 147885815Sobrien}; 147985815Sobrienstatic const char *intel_names32[] = { 148085815Sobrien "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi", 148185815Sobrien "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d" 148285815Sobrien}; 148385815Sobrienstatic const char *intel_names16[] = { 148485815Sobrien "ax", "cx", "dx", "bx", "sp", "bp", "si", "di", 148585815Sobrien "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w" 148685815Sobrien}; 148785815Sobrienstatic const char *intel_names8[] = { 148885815Sobrien "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh", 148985815Sobrien}; 149085815Sobrienstatic const char *intel_names8rex[] = { 149185815Sobrien "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil", 149285815Sobrien "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b" 149385815Sobrien}; 149485815Sobrienstatic const char *intel_names_seg[] = { 149585815Sobrien "es", "cs", "ss", "ds", "fs", "gs", "?", "?", 149685815Sobrien}; 149785815Sobrienstatic const char *intel_index16[] = { 149885815Sobrien "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx" 149985815Sobrien}; 150085815Sobrien 150185815Sobrienstatic const char *att_names64[] = { 150285815Sobrien "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi", 150377298Sobrien "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15" 150477298Sobrien}; 150585815Sobrienstatic const char *att_names32[] = { 150685815Sobrien "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi", 150777298Sobrien "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d" 150833965Sjdp}; 150985815Sobrienstatic const char *att_names16[] = { 151085815Sobrien "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di", 151177298Sobrien "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w" 151233965Sjdp}; 151385815Sobrienstatic const char *att_names8[] = { 151485815Sobrien "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh", 151533965Sjdp}; 151685815Sobrienstatic const char *att_names8rex[] = { 151785815Sobrien "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil", 151877298Sobrien "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b" 151977298Sobrien}; 152085815Sobrienstatic const char *att_names_seg[] = { 152185815Sobrien "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?", 152233965Sjdp}; 152385815Sobrienstatic const char *att_index16[] = { 152485815Sobrien "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx" 152533965Sjdp}; 152633965Sjdp 152760484Sobrienstatic const struct dis386 grps[][8] = { 1528218822Sdim /* GRP1a */ 1529218822Sdim { 1530218822Sdim { "popU", { stackEv } }, 1531218822Sdim { "(bad)", { XX } }, 1532218822Sdim { "(bad)", { XX } }, 1533218822Sdim { "(bad)", { XX } }, 1534218822Sdim { "(bad)", { XX } }, 1535218822Sdim { "(bad)", { XX } }, 1536218822Sdim { "(bad)", { XX } }, 1537218822Sdim { "(bad)", { XX } }, 1538218822Sdim }, 153933965Sjdp /* GRP1b */ 154033965Sjdp { 1541218822Sdim { "addA", { Eb, Ib } }, 1542218822Sdim { "orA", { Eb, Ib } }, 1543218822Sdim { "adcA", { Eb, Ib } }, 1544218822Sdim { "sbbA", { Eb, Ib } }, 1545218822Sdim { "andA", { Eb, Ib } }, 1546218822Sdim { "subA", { Eb, Ib } }, 1547218822Sdim { "xorA", { Eb, Ib } }, 1548218822Sdim { "cmpA", { Eb, Ib } }, 154933965Sjdp }, 155033965Sjdp /* GRP1S */ 155133965Sjdp { 1552218822Sdim { "addQ", { Ev, Iv } }, 1553218822Sdim { "orQ", { Ev, Iv } }, 1554218822Sdim { "adcQ", { Ev, Iv } }, 1555218822Sdim { "sbbQ", { Ev, Iv } }, 1556218822Sdim { "andQ", { Ev, Iv } }, 1557218822Sdim { "subQ", { Ev, Iv } }, 1558218822Sdim { "xorQ", { Ev, Iv } }, 1559218822Sdim { "cmpQ", { Ev, Iv } }, 156033965Sjdp }, 156133965Sjdp /* GRP1Ss */ 156233965Sjdp { 1563218822Sdim { "addQ", { Ev, sIb } }, 1564218822Sdim { "orQ", { Ev, sIb } }, 1565218822Sdim { "adcQ", { Ev, sIb } }, 1566218822Sdim { "sbbQ", { Ev, sIb } }, 1567218822Sdim { "andQ", { Ev, sIb } }, 1568218822Sdim { "subQ", { Ev, sIb } }, 1569218822Sdim { "xorQ", { Ev, sIb } }, 1570218822Sdim { "cmpQ", { Ev, sIb } }, 157133965Sjdp }, 157233965Sjdp /* GRP2b */ 157333965Sjdp { 1574218822Sdim { "rolA", { Eb, Ib } }, 1575218822Sdim { "rorA", { Eb, Ib } }, 1576218822Sdim { "rclA", { Eb, Ib } }, 1577218822Sdim { "rcrA", { Eb, Ib } }, 1578218822Sdim { "shlA", { Eb, Ib } }, 1579218822Sdim { "shrA", { Eb, Ib } }, 1580218822Sdim { "(bad)", { XX } }, 1581218822Sdim { "sarA", { Eb, Ib } }, 158233965Sjdp }, 158333965Sjdp /* GRP2S */ 158433965Sjdp { 1585218822Sdim { "rolQ", { Ev, Ib } }, 1586218822Sdim { "rorQ", { Ev, Ib } }, 1587218822Sdim { "rclQ", { Ev, Ib } }, 1588218822Sdim { "rcrQ", { Ev, Ib } }, 1589218822Sdim { "shlQ", { Ev, Ib } }, 1590218822Sdim { "shrQ", { Ev, Ib } }, 1591218822Sdim { "(bad)", { XX } }, 1592218822Sdim { "sarQ", { Ev, Ib } }, 159333965Sjdp }, 159433965Sjdp /* GRP2b_one */ 159533965Sjdp { 1596218822Sdim { "rolA", { Eb, I1 } }, 1597218822Sdim { "rorA", { Eb, I1 } }, 1598218822Sdim { "rclA", { Eb, I1 } }, 1599218822Sdim { "rcrA", { Eb, I1 } }, 1600218822Sdim { "shlA", { Eb, I1 } }, 1601218822Sdim { "shrA", { Eb, I1 } }, 1602218822Sdim { "(bad)", { XX } }, 1603218822Sdim { "sarA", { Eb, I1 } }, 160433965Sjdp }, 160533965Sjdp /* GRP2S_one */ 160633965Sjdp { 1607218822Sdim { "rolQ", { Ev, I1 } }, 1608218822Sdim { "rorQ", { Ev, I1 } }, 1609218822Sdim { "rclQ", { Ev, I1 } }, 1610218822Sdim { "rcrQ", { Ev, I1 } }, 1611218822Sdim { "shlQ", { Ev, I1 } }, 1612218822Sdim { "shrQ", { Ev, I1 } }, 1613218822Sdim { "(bad)", { XX } }, 1614218822Sdim { "sarQ", { Ev, I1 } }, 161533965Sjdp }, 161633965Sjdp /* GRP2b_cl */ 161733965Sjdp { 1618218822Sdim { "rolA", { Eb, CL } }, 1619218822Sdim { "rorA", { Eb, CL } }, 1620218822Sdim { "rclA", { Eb, CL } }, 1621218822Sdim { "rcrA", { Eb, CL } }, 1622218822Sdim { "shlA", { Eb, CL } }, 1623218822Sdim { "shrA", { Eb, CL } }, 1624218822Sdim { "(bad)", { XX } }, 1625218822Sdim { "sarA", { Eb, CL } }, 162633965Sjdp }, 162733965Sjdp /* GRP2S_cl */ 162833965Sjdp { 1629218822Sdim { "rolQ", { Ev, CL } }, 1630218822Sdim { "rorQ", { Ev, CL } }, 1631218822Sdim { "rclQ", { Ev, CL } }, 1632218822Sdim { "rcrQ", { Ev, CL } }, 1633218822Sdim { "shlQ", { Ev, CL } }, 1634218822Sdim { "shrQ", { Ev, CL } }, 1635218822Sdim { "(bad)", { XX } }, 1636218822Sdim { "sarQ", { Ev, CL } }, 163733965Sjdp }, 163833965Sjdp /* GRP3b */ 163933965Sjdp { 1640218822Sdim { "testA", { Eb, Ib } }, 1641218822Sdim { "(bad)", { Eb } }, 1642218822Sdim { "notA", { Eb } }, 1643218822Sdim { "negA", { Eb } }, 1644218822Sdim { "mulA", { Eb } }, /* Don't print the implicit %al register, */ 1645218822Sdim { "imulA", { Eb } }, /* to distinguish these opcodes from other */ 1646218822Sdim { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */ 1647218822Sdim { "idivA", { Eb } }, /* and idiv for consistency. */ 164833965Sjdp }, 164933965Sjdp /* GRP3S */ 165033965Sjdp { 1651218822Sdim { "testQ", { Ev, Iv } }, 1652218822Sdim { "(bad)", { XX } }, 1653218822Sdim { "notQ", { Ev } }, 1654218822Sdim { "negQ", { Ev } }, 1655218822Sdim { "mulQ", { Ev } }, /* Don't print the implicit register. */ 1656218822Sdim { "imulQ", { Ev } }, 1657218822Sdim { "divQ", { Ev } }, 1658218822Sdim { "idivQ", { Ev } }, 165933965Sjdp }, 166033965Sjdp /* GRP4 */ 166133965Sjdp { 1662218822Sdim { "incA", { Eb } }, 1663218822Sdim { "decA", { Eb } }, 1664218822Sdim { "(bad)", { XX } }, 1665218822Sdim { "(bad)", { XX } }, 1666218822Sdim { "(bad)", { XX } }, 1667218822Sdim { "(bad)", { XX } }, 1668218822Sdim { "(bad)", { XX } }, 1669218822Sdim { "(bad)", { XX } }, 167033965Sjdp }, 167133965Sjdp /* GRP5 */ 167233965Sjdp { 1673218822Sdim { "incQ", { Ev } }, 1674218822Sdim { "decQ", { Ev } }, 1675218822Sdim { "callT", { indirEv } }, 1676218822Sdim { "JcallT", { indirEp } }, 1677218822Sdim { "jmpT", { indirEv } }, 1678218822Sdim { "JjmpT", { indirEp } }, 1679218822Sdim { "pushU", { stackEv } }, 1680218822Sdim { "(bad)", { XX } }, 168133965Sjdp }, 168233965Sjdp /* GRP6 */ 168333965Sjdp { 1684218822Sdim { "sldtD", { Sv } }, 1685218822Sdim { "strD", { Sv } }, 1686218822Sdim { "lldt", { Ew } }, 1687218822Sdim { "ltr", { Ew } }, 1688218822Sdim { "verr", { Ew } }, 1689218822Sdim { "verw", { Ew } }, 1690218822Sdim { "(bad)", { XX } }, 1691218822Sdim { "(bad)", { XX } }, 169233965Sjdp }, 169333965Sjdp /* GRP7 */ 169433965Sjdp { 1695218822Sdim { "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } }, 1696218822Sdim { "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } }, 1697238123Sjhb { "lgdt{Q|Q||}", { { XCR_Fixup, 0 } } }, 1698218822Sdim { "lidt{Q|Q||}", { { SVME_Fixup, 0 } } }, 1699218822Sdim { "smswD", { Sv } }, 1700218822Sdim { "(bad)", { XX } }, 1701218822Sdim { "lmsw", { Ew } }, 1702218822Sdim { "invlpg", { { INVLPG_Fixup, w_mode } } }, 170333965Sjdp }, 170433965Sjdp /* GRP8 */ 170533965Sjdp { 1706218822Sdim { "(bad)", { XX } }, 1707218822Sdim { "(bad)", { XX } }, 1708218822Sdim { "(bad)", { XX } }, 1709218822Sdim { "(bad)", { XX } }, 1710218822Sdim { "btQ", { Ev, Ib } }, 1711218822Sdim { "btsQ", { Ev, Ib } }, 1712218822Sdim { "btrQ", { Ev, Ib } }, 1713218822Sdim { "btcQ", { Ev, Ib } }, 171433965Sjdp }, 171533965Sjdp /* GRP9 */ 171633965Sjdp { 1717218822Sdim { "(bad)", { XX } }, 1718218822Sdim { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } }, 1719218822Sdim { "(bad)", { XX } }, 1720218822Sdim { "(bad)", { XX } }, 1721218822Sdim { "(bad)", { XX } }, 1722218822Sdim { "(bad)", { XX } }, 1723218822Sdim { "", { VM } }, /* See OP_VMX. */ 1724218822Sdim { "vmptrst", { Mq } }, 172533965Sjdp }, 1726218822Sdim /* GRP11_C6 */ 172733965Sjdp { 1728218822Sdim { "movA", { Eb, Ib } }, 1729218822Sdim { "(bad)", { XX } }, 1730218822Sdim { "(bad)", { XX } }, 1731218822Sdim { "(bad)", { XX } }, 1732218822Sdim { "(bad)", { XX } }, 1733218822Sdim { "(bad)", { XX } }, 1734218822Sdim { "(bad)", { XX } }, 1735218822Sdim { "(bad)", { XX } }, 173633965Sjdp }, 1737218822Sdim /* GRP11_C7 */ 173833965Sjdp { 1739218822Sdim { "movQ", { Ev, Iv } }, 1740218822Sdim { "(bad)", { XX } }, 1741218822Sdim { "(bad)", { XX } }, 1742218822Sdim { "(bad)", { XX } }, 1743218822Sdim { "(bad)", { XX } }, 1744218822Sdim { "(bad)", { XX } }, 1745218822Sdim { "(bad)", { XX } }, 1746218822Sdim { "(bad)", { XX } }, 174733965Sjdp }, 174833965Sjdp /* GRP12 */ 174933965Sjdp { 1750218822Sdim { "(bad)", { XX } }, 1751218822Sdim { "(bad)", { XX } }, 1752218822Sdim { "psrlw", { MS, Ib } }, 1753218822Sdim { "(bad)", { XX } }, 1754218822Sdim { "psraw", { MS, Ib } }, 1755218822Sdim { "(bad)", { XX } }, 1756218822Sdim { "psllw", { MS, Ib } }, 1757218822Sdim { "(bad)", { XX } }, 175860484Sobrien }, 175960484Sobrien /* GRP13 */ 176060484Sobrien { 1761218822Sdim { "(bad)", { XX } }, 1762218822Sdim { "(bad)", { XX } }, 1763218822Sdim { "psrld", { MS, Ib } }, 1764218822Sdim { "(bad)", { XX } }, 1765218822Sdim { "psrad", { MS, Ib } }, 1766218822Sdim { "(bad)", { XX } }, 1767218822Sdim { "pslld", { MS, Ib } }, 1768218822Sdim { "(bad)", { XX } }, 176960484Sobrien }, 177060484Sobrien /* GRP14 */ 177160484Sobrien { 1772218822Sdim { "(bad)", { XX } }, 1773218822Sdim { "(bad)", { XX } }, 1774218822Sdim { "psrlq", { MS, Ib } }, 1775218822Sdim { "psrldq", { MS, Ib } }, 1776218822Sdim { "(bad)", { XX } }, 1777218822Sdim { "(bad)", { XX } }, 1778218822Sdim { "psllq", { MS, Ib } }, 1779218822Sdim { "pslldq", { MS, Ib } }, 178060484Sobrien }, 1781218822Sdim /* GRP15 */ 1782218822Sdim { 1783218822Sdim { "fxsave", { Ev } }, 1784218822Sdim { "fxrstor", { Ev } }, 1785218822Sdim { "ldmxcsr", { Ev } }, 1786218822Sdim { "stmxcsr", { Ev } }, 1787238123Sjhb { "xsave", { Ev } }, 1788238123Sjhb { "xrstor", { { OP_0fae, v_mode } } }, 1789238123Sjhb { "xsaveopt", { { OP_0fae, v_mode } } }, 1790218822Sdim { "clflush", { { OP_0fae, 0 } } }, 1791218822Sdim }, 1792218822Sdim /* GRP16 */ 1793218822Sdim { 1794218822Sdim { "prefetchnta", { Ev } }, 1795218822Sdim { "prefetcht0", { Ev } }, 1796218822Sdim { "prefetcht1", { Ev } }, 1797218822Sdim { "prefetcht2", { Ev } }, 1798218822Sdim { "(bad)", { XX } }, 1799218822Sdim { "(bad)", { XX } }, 1800218822Sdim { "(bad)", { XX } }, 1801218822Sdim { "(bad)", { XX } }, 1802218822Sdim }, 180360484Sobrien /* GRPAMD */ 180460484Sobrien { 1805218822Sdim { "prefetch", { Eb } }, 1806218822Sdim { "prefetchw", { Eb } }, 1807218822Sdim { "(bad)", { XX } }, 1808218822Sdim { "(bad)", { XX } }, 1809218822Sdim { "(bad)", { XX } }, 1810218822Sdim { "(bad)", { XX } }, 1811218822Sdim { "(bad)", { XX } }, 1812218822Sdim { "(bad)", { XX } }, 1813130561Sobrien }, 1814218822Sdim /* GRPPADLCK1 */ 1815130561Sobrien { 1816218822Sdim { "xstore-rng", { { OP_0f07, 0 } } }, 1817218822Sdim { "xcrypt-ecb", { { OP_0f07, 0 } } }, 1818218822Sdim { "xcrypt-cbc", { { OP_0f07, 0 } } }, 1819218822Sdim { "xcrypt-ctr", { { OP_0f07, 0 } } }, 1820218822Sdim { "xcrypt-cfb", { { OP_0f07, 0 } } }, 1821218822Sdim { "xcrypt-ofb", { { OP_0f07, 0 } } }, 1822218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1823218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1824218822Sdim }, 1825218822Sdim /* GRPPADLCK2 */ 1826218822Sdim { 1827218822Sdim { "montmul", { { OP_0f07, 0 } } }, 1828218822Sdim { "xsha1", { { OP_0f07, 0 } } }, 1829218822Sdim { "xsha256", { { OP_0f07, 0 } } }, 1830218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1831218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1832218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1833218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 1834218822Sdim { "(bad)", { { OP_0f07, 0 } } }, 183533965Sjdp } 183633965Sjdp}; 183733965Sjdp 183877298Sobrienstatic const struct dis386 prefix_user_table[][4] = { 183960484Sobrien /* PREGRP0 */ 184060484Sobrien { 1841218822Sdim { "addps", { XM, EXx } }, 1842218822Sdim { "addss", { XM, EXd } }, 1843218822Sdim { "addpd", { XM, EXx } }, 1844218822Sdim { "addsd", { XM, EXq } }, 184560484Sobrien }, 184660484Sobrien /* PREGRP1 */ 184760484Sobrien { 1848218822Sdim { "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */ 1849218822Sdim { "", { XM, EXx, OPSIMD } }, 1850218822Sdim { "", { XM, EXx, OPSIMD } }, 1851218822Sdim { "", { XM, EXx, OPSIMD } }, 185260484Sobrien }, 185360484Sobrien /* PREGRP2 */ 185460484Sobrien { 1855218822Sdim { "cvtpi2ps", { XM, EMC } }, 1856218822Sdim { "cvtsi2ssY", { XM, Ev } }, 1857218822Sdim { "cvtpi2pd", { XM, EMC } }, 1858218822Sdim { "cvtsi2sdY", { XM, Ev } }, 185960484Sobrien }, 186060484Sobrien /* PREGRP3 */ 186160484Sobrien { 1862218822Sdim { "cvtps2pi", { MXC, EXx } }, 1863218822Sdim { "cvtss2siY", { Gv, EXx } }, 1864218822Sdim { "cvtpd2pi", { MXC, EXx } }, 1865218822Sdim { "cvtsd2siY", { Gv, EXx } }, 186660484Sobrien }, 186760484Sobrien /* PREGRP4 */ 186860484Sobrien { 1869218822Sdim { "cvttps2pi", { MXC, EXx } }, 1870218822Sdim { "cvttss2siY", { Gv, EXx } }, 1871218822Sdim { "cvttpd2pi", { MXC, EXx } }, 1872218822Sdim { "cvttsd2siY", { Gv, EXx } }, 187360484Sobrien }, 187460484Sobrien /* PREGRP5 */ 187560484Sobrien { 1876218822Sdim { "divps", { XM, EXx } }, 1877218822Sdim { "divss", { XM, EXx } }, 1878218822Sdim { "divpd", { XM, EXx } }, 1879218822Sdim { "divsd", { XM, EXx } }, 188060484Sobrien }, 188160484Sobrien /* PREGRP6 */ 188260484Sobrien { 1883218822Sdim { "maxps", { XM, EXx } }, 1884218822Sdim { "maxss", { XM, EXx } }, 1885218822Sdim { "maxpd", { XM, EXx } }, 1886218822Sdim { "maxsd", { XM, EXx } }, 188760484Sobrien }, 188860484Sobrien /* PREGRP7 */ 188960484Sobrien { 1890218822Sdim { "minps", { XM, EXx } }, 1891218822Sdim { "minss", { XM, EXx } }, 1892218822Sdim { "minpd", { XM, EXx } }, 1893218822Sdim { "minsd", { XM, EXx } }, 189460484Sobrien }, 189560484Sobrien /* PREGRP8 */ 189660484Sobrien { 1897218822Sdim { "movups", { XM, EXx } }, 1898218822Sdim { "movss", { XM, EXx } }, 1899218822Sdim { "movupd", { XM, EXx } }, 1900218822Sdim { "movsd", { XM, EXx } }, 190160484Sobrien }, 190260484Sobrien /* PREGRP9 */ 190360484Sobrien { 1904218822Sdim { "movups", { EXx, XM } }, 1905218822Sdim { "movss", { EXx, XM } }, 1906218822Sdim { "movupd", { EXx, XM } }, 1907218822Sdim { "movsd", { EXx, XM } }, 190860484Sobrien }, 190960484Sobrien /* PREGRP10 */ 191060484Sobrien { 1911218822Sdim { "mulps", { XM, EXx } }, 1912218822Sdim { "mulss", { XM, EXx } }, 1913218822Sdim { "mulpd", { XM, EXx } }, 1914218822Sdim { "mulsd", { XM, EXx } }, 191560484Sobrien }, 191660484Sobrien /* PREGRP11 */ 191760484Sobrien { 1918218822Sdim { "rcpps", { XM, EXx } }, 1919218822Sdim { "rcpss", { XM, EXx } }, 1920218822Sdim { "(bad)", { XM, EXx } }, 1921218822Sdim { "(bad)", { XM, EXx } }, 192260484Sobrien }, 192360484Sobrien /* PREGRP12 */ 192460484Sobrien { 1925218822Sdim { "rsqrtps",{ XM, EXx } }, 1926218822Sdim { "rsqrtss",{ XM, EXx } }, 1927218822Sdim { "(bad)", { XM, EXx } }, 1928218822Sdim { "(bad)", { XM, EXx } }, 192960484Sobrien }, 193060484Sobrien /* PREGRP13 */ 193160484Sobrien { 1932218822Sdim { "sqrtps", { XM, EXx } }, 1933218822Sdim { "sqrtss", { XM, EXx } }, 1934218822Sdim { "sqrtpd", { XM, EXx } }, 1935218822Sdim { "sqrtsd", { XM, EXx } }, 193660484Sobrien }, 193760484Sobrien /* PREGRP14 */ 193860484Sobrien { 1939218822Sdim { "subps", { XM, EXx } }, 1940218822Sdim { "subss", { XM, EXx } }, 1941218822Sdim { "subpd", { XM, EXx } }, 1942218822Sdim { "subsd", { XM, EXx } }, 194377298Sobrien }, 194477298Sobrien /* PREGRP15 */ 194577298Sobrien { 1946218822Sdim { "(bad)", { XM, EXx } }, 1947218822Sdim { "cvtdq2pd", { XM, EXq } }, 1948218822Sdim { "cvttpd2dq", { XM, EXx } }, 1949218822Sdim { "cvtpd2dq", { XM, EXx } }, 195077298Sobrien }, 195177298Sobrien /* PREGRP16 */ 195277298Sobrien { 1953218822Sdim { "cvtdq2ps", { XM, EXx } }, 1954218822Sdim { "cvttps2dq", { XM, EXx } }, 1955218822Sdim { "cvtps2dq", { XM, EXx } }, 1956218822Sdim { "(bad)", { XM, EXx } }, 195777298Sobrien }, 195877298Sobrien /* PREGRP17 */ 195977298Sobrien { 1960218822Sdim { "cvtps2pd", { XM, EXq } }, 1961218822Sdim { "cvtss2sd", { XM, EXx } }, 1962218822Sdim { "cvtpd2ps", { XM, EXx } }, 1963218822Sdim { "cvtsd2ss", { XM, EXx } }, 196477298Sobrien }, 196577298Sobrien /* PREGRP18 */ 196677298Sobrien { 1967218822Sdim { "maskmovq", { MX, MS } }, 1968218822Sdim { "(bad)", { XM, EXx } }, 1969218822Sdim { "maskmovdqu", { XM, XS } }, 1970218822Sdim { "(bad)", { XM, EXx } }, 197177298Sobrien }, 197277298Sobrien /* PREGRP19 */ 197377298Sobrien { 1974218822Sdim { "movq", { MX, EM } }, 1975218822Sdim { "movdqu", { XM, EXx } }, 1976218822Sdim { "movdqa", { XM, EXx } }, 1977218822Sdim { "(bad)", { XM, EXx } }, 197877298Sobrien }, 197977298Sobrien /* PREGRP20 */ 198077298Sobrien { 1981218822Sdim { "movq", { EM, MX } }, 1982218822Sdim { "movdqu", { EXx, XM } }, 1983218822Sdim { "movdqa", { EXx, XM } }, 1984218822Sdim { "(bad)", { EXx, XM } }, 198577298Sobrien }, 198677298Sobrien /* PREGRP21 */ 198777298Sobrien { 1988218822Sdim { "(bad)", { EXx, XM } }, 1989218822Sdim { "movq2dq",{ XM, MS } }, 1990218822Sdim { "movq", { EXx, XM } }, 1991218822Sdim { "movdq2q",{ MX, XS } }, 199277298Sobrien }, 199377298Sobrien /* PREGRP22 */ 199477298Sobrien { 1995218822Sdim { "pshufw", { MX, EM, Ib } }, 1996218822Sdim { "pshufhw",{ XM, EXx, Ib } }, 1997218822Sdim { "pshufd", { XM, EXx, Ib } }, 1998218822Sdim { "pshuflw",{ XM, EXx, Ib } }, 199977298Sobrien }, 200077298Sobrien /* PREGRP23 */ 200177298Sobrien { 2002218822Sdim { "movd", { Edq, MX } }, 2003218822Sdim { "movq", { XM, EXx } }, 2004218822Sdim { "movd", { Edq, XM } }, 2005218822Sdim { "(bad)", { Ed, XM } }, 200677298Sobrien }, 200777298Sobrien /* PREGRP24 */ 200877298Sobrien { 2009218822Sdim { "(bad)", { MX, EXx } }, 2010218822Sdim { "(bad)", { XM, EXx } }, 2011218822Sdim { "punpckhqdq", { XM, EXx } }, 2012218822Sdim { "(bad)", { XM, EXx } }, 201377298Sobrien }, 201477298Sobrien /* PREGRP25 */ 201577298Sobrien { 2016218822Sdim { "movntq", { EM, MX } }, 2017218822Sdim { "(bad)", { EM, XM } }, 2018218822Sdim { "movntdq",{ EM, XM } }, 2019218822Sdim { "(bad)", { EM, XM } }, 202077298Sobrien }, 202177298Sobrien /* PREGRP26 */ 202277298Sobrien { 2023218822Sdim { "(bad)", { MX, EXx } }, 2024218822Sdim { "(bad)", { XM, EXx } }, 2025218822Sdim { "punpcklqdq", { XM, EXx } }, 2026218822Sdim { "(bad)", { XM, EXx } }, 202777298Sobrien }, 2028130561Sobrien /* PREGRP27 */ 2029130561Sobrien { 2030218822Sdim { "(bad)", { MX, EXx } }, 2031218822Sdim { "(bad)", { XM, EXx } }, 2032218822Sdim { "addsubpd", { XM, EXx } }, 2033218822Sdim { "addsubps", { XM, EXx } }, 2034130561Sobrien }, 2035130561Sobrien /* PREGRP28 */ 2036130561Sobrien { 2037218822Sdim { "(bad)", { MX, EXx } }, 2038218822Sdim { "(bad)", { XM, EXx } }, 2039218822Sdim { "haddpd", { XM, EXx } }, 2040218822Sdim { "haddps", { XM, EXx } }, 2041130561Sobrien }, 2042130561Sobrien /* PREGRP29 */ 2043130561Sobrien { 2044218822Sdim { "(bad)", { MX, EXx } }, 2045218822Sdim { "(bad)", { XM, EXx } }, 2046218822Sdim { "hsubpd", { XM, EXx } }, 2047218822Sdim { "hsubps", { XM, EXx } }, 2048130561Sobrien }, 2049130561Sobrien /* PREGRP30 */ 2050130561Sobrien { 2051218822Sdim { "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */ 2052218822Sdim { "movsldup", { XM, EXx } }, 2053218822Sdim { "movlpd", { XM, EXq } }, 2054218822Sdim { "movddup", { XM, EXq } }, 2055130561Sobrien }, 2056130561Sobrien /* PREGRP31 */ 2057130561Sobrien { 2058218822Sdim { "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } }, 2059218822Sdim { "movshdup", { XM, EXx } }, 2060218822Sdim { "movhpd", { XM, EXq } }, 2061218822Sdim { "(bad)", { XM, EXq } }, 2062130561Sobrien }, 2063130561Sobrien /* PREGRP32 */ 2064130561Sobrien { 2065218822Sdim { "(bad)", { XM, EXx } }, 2066218822Sdim { "(bad)", { XM, EXx } }, 2067218822Sdim { "(bad)", { XM, EXx } }, 2068218822Sdim { "lddqu", { XM, M } }, 2069130561Sobrien }, 2070218822Sdim /* PREGRP33 */ 2071218822Sdim { 2072218822Sdim {"movntps", { Ev, XM } }, 2073218822Sdim {"movntss", { Ev, XM } }, 2074218822Sdim {"movntpd", { Ev, XM } }, 2075218822Sdim {"movntsd", { Ev, XM } }, 2076218822Sdim }, 2077218822Sdim 2078218822Sdim /* PREGRP34 */ 2079218822Sdim { 2080218822Sdim {"vmread", { Em, Gm } }, 2081218822Sdim {"(bad)", { XX } }, 2082218822Sdim {"extrq", { XS, Ib, Ib } }, 2083218822Sdim {"insertq", { XM, XS, Ib, Ib } }, 2084218822Sdim }, 2085218822Sdim 2086218822Sdim /* PREGRP35 */ 2087218822Sdim { 2088218822Sdim {"vmwrite", { Gm, Em } }, 2089218822Sdim {"(bad)", { XX } }, 2090218822Sdim {"extrq", { XM, XS } }, 2091218822Sdim {"insertq", { XM, XS } }, 2092218822Sdim }, 2093218822Sdim 2094218822Sdim /* PREGRP36 */ 2095218822Sdim { 2096218822Sdim { "bsrS", { Gv, Ev } }, 2097218822Sdim { "lzcntS", { Gv, Ev } }, 2098218822Sdim { "bsrS", { Gv, Ev } }, 2099218822Sdim { "(bad)", { XX } }, 2100218822Sdim }, 2101218822Sdim 2102218822Sdim /* PREGRP37 */ 2103218822Sdim { 2104218822Sdim { "(bad)", { XX } }, 2105218822Sdim { "popcntS", { Gv, Ev } }, 2106218822Sdim { "(bad)", { XX } }, 2107218822Sdim { "(bad)", { XX } }, 2108218822Sdim }, 2109218822Sdim 2110218822Sdim /* PREGRP38 */ 2111218822Sdim { 2112218822Sdim { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } }, 2113218822Sdim { "pause", { XX } }, 2114218822Sdim { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } }, 2115218822Sdim { "(bad)", { XX } }, 2116218822Sdim }, 2117218822Sdim 2118218822Sdim /* PREGRP39 */ 2119218822Sdim { 2120218822Sdim { "(bad)", { XX } }, 2121218822Sdim { "(bad)", { XX } }, 2122218822Sdim { "pblendvb", {XM, EXx, XMM0 } }, 2123218822Sdim { "(bad)", { XX } }, 2124218822Sdim }, 2125218822Sdim 2126218822Sdim /* PREGRP40 */ 2127218822Sdim { 2128218822Sdim { "(bad)", { XX } }, 2129218822Sdim { "(bad)", { XX } }, 2130218822Sdim { "blendvps", {XM, EXx, XMM0 } }, 2131218822Sdim { "(bad)", { XX } }, 2132218822Sdim }, 2133218822Sdim 2134218822Sdim /* PREGRP41 */ 2135218822Sdim { 2136218822Sdim { "(bad)", { XX } }, 2137218822Sdim { "(bad)", { XX } }, 2138218822Sdim { "blendvpd", { XM, EXx, XMM0 } }, 2139218822Sdim { "(bad)", { XX } }, 2140218822Sdim }, 2141218822Sdim 2142218822Sdim /* PREGRP42 */ 2143218822Sdim { 2144218822Sdim { "(bad)", { XX } }, 2145218822Sdim { "(bad)", { XX } }, 2146218822Sdim { "ptest", { XM, EXx } }, 2147218822Sdim { "(bad)", { XX } }, 2148218822Sdim }, 2149218822Sdim 2150218822Sdim /* PREGRP43 */ 2151218822Sdim { 2152218822Sdim { "(bad)", { XX } }, 2153218822Sdim { "(bad)", { XX } }, 2154218822Sdim { "pmovsxbw", { XM, EXx } }, 2155218822Sdim { "(bad)", { XX } }, 2156218822Sdim }, 2157218822Sdim 2158218822Sdim /* PREGRP44 */ 2159218822Sdim { 2160218822Sdim { "(bad)", { XX } }, 2161218822Sdim { "(bad)", { XX } }, 2162218822Sdim { "pmovsxbd", { XM, EXx } }, 2163218822Sdim { "(bad)", { XX } }, 2164218822Sdim }, 2165218822Sdim 2166218822Sdim /* PREGRP45 */ 2167218822Sdim { 2168218822Sdim { "(bad)", { XX } }, 2169218822Sdim { "(bad)", { XX } }, 2170218822Sdim { "pmovsxbq", { XM, EXx } }, 2171218822Sdim { "(bad)", { XX } }, 2172218822Sdim }, 2173218822Sdim 2174218822Sdim /* PREGRP46 */ 2175218822Sdim { 2176218822Sdim { "(bad)", { XX } }, 2177218822Sdim { "(bad)", { XX } }, 2178218822Sdim { "pmovsxwd", { XM, EXx } }, 2179218822Sdim { "(bad)", { XX } }, 2180218822Sdim }, 2181218822Sdim 2182218822Sdim /* PREGRP47 */ 2183218822Sdim { 2184218822Sdim { "(bad)", { XX } }, 2185218822Sdim { "(bad)", { XX } }, 2186218822Sdim { "pmovsxwq", { XM, EXx } }, 2187218822Sdim { "(bad)", { XX } }, 2188218822Sdim }, 2189218822Sdim 2190218822Sdim /* PREGRP48 */ 2191218822Sdim { 2192218822Sdim { "(bad)", { XX } }, 2193218822Sdim { "(bad)", { XX } }, 2194218822Sdim { "pmovsxdq", { XM, EXx } }, 2195218822Sdim { "(bad)", { XX } }, 2196218822Sdim }, 2197218822Sdim 2198218822Sdim /* PREGRP49 */ 2199218822Sdim { 2200218822Sdim { "(bad)", { XX } }, 2201218822Sdim { "(bad)", { XX } }, 2202218822Sdim { "pmuldq", { XM, EXx } }, 2203218822Sdim { "(bad)", { XX } }, 2204218822Sdim }, 2205218822Sdim 2206218822Sdim /* PREGRP50 */ 2207218822Sdim { 2208218822Sdim { "(bad)", { XX } }, 2209218822Sdim { "(bad)", { XX } }, 2210218822Sdim { "pcmpeqq", { XM, EXx } }, 2211218822Sdim { "(bad)", { XX } }, 2212218822Sdim }, 2213218822Sdim 2214218822Sdim /* PREGRP51 */ 2215218822Sdim { 2216218822Sdim { "(bad)", { XX } }, 2217218822Sdim { "(bad)", { XX } }, 2218218822Sdim { "movntdqa", { XM, EM } }, 2219218822Sdim { "(bad)", { XX } }, 2220218822Sdim }, 2221218822Sdim 2222218822Sdim /* PREGRP52 */ 2223218822Sdim { 2224218822Sdim { "(bad)", { XX } }, 2225218822Sdim { "(bad)", { XX } }, 2226218822Sdim { "packusdw", { XM, EXx } }, 2227218822Sdim { "(bad)", { XX } }, 2228218822Sdim }, 2229218822Sdim 2230218822Sdim /* PREGRP53 */ 2231218822Sdim { 2232218822Sdim { "(bad)", { XX } }, 2233218822Sdim { "(bad)", { XX } }, 2234218822Sdim { "pmovzxbw", { XM, EXx } }, 2235218822Sdim { "(bad)", { XX } }, 2236218822Sdim }, 2237218822Sdim 2238218822Sdim /* PREGRP54 */ 2239218822Sdim { 2240218822Sdim { "(bad)", { XX } }, 2241218822Sdim { "(bad)", { XX } }, 2242218822Sdim { "pmovzxbd", { XM, EXx } }, 2243218822Sdim { "(bad)", { XX } }, 2244218822Sdim }, 2245218822Sdim 2246218822Sdim /* PREGRP55 */ 2247218822Sdim { 2248218822Sdim { "(bad)", { XX } }, 2249218822Sdim { "(bad)", { XX } }, 2250218822Sdim { "pmovzxbq", { XM, EXx } }, 2251218822Sdim { "(bad)", { XX } }, 2252218822Sdim }, 2253218822Sdim 2254218822Sdim /* PREGRP56 */ 2255218822Sdim { 2256218822Sdim { "(bad)", { XX } }, 2257218822Sdim { "(bad)", { XX } }, 2258218822Sdim { "pmovzxwd", { XM, EXx } }, 2259218822Sdim { "(bad)", { XX } }, 2260218822Sdim }, 2261218822Sdim 2262218822Sdim /* PREGRP57 */ 2263218822Sdim { 2264218822Sdim { "(bad)", { XX } }, 2265218822Sdim { "(bad)", { XX } }, 2266218822Sdim { "pmovzxwq", { XM, EXx } }, 2267218822Sdim { "(bad)", { XX } }, 2268218822Sdim }, 2269218822Sdim 2270218822Sdim /* PREGRP58 */ 2271218822Sdim { 2272218822Sdim { "(bad)", { XX } }, 2273218822Sdim { "(bad)", { XX } }, 2274218822Sdim { "pmovzxdq", { XM, EXx } }, 2275218822Sdim { "(bad)", { XX } }, 2276218822Sdim }, 2277218822Sdim 2278218822Sdim /* PREGRP59 */ 2279218822Sdim { 2280218822Sdim { "(bad)", { XX } }, 2281218822Sdim { "(bad)", { XX } }, 2282218822Sdim { "pminsb", { XM, EXx } }, 2283218822Sdim { "(bad)", { XX } }, 2284218822Sdim }, 2285218822Sdim 2286218822Sdim /* PREGRP60 */ 2287218822Sdim { 2288218822Sdim { "(bad)", { XX } }, 2289218822Sdim { "(bad)", { XX } }, 2290218822Sdim { "pminsd", { XM, EXx } }, 2291218822Sdim { "(bad)", { XX } }, 2292218822Sdim }, 2293218822Sdim 2294218822Sdim /* PREGRP61 */ 2295218822Sdim { 2296218822Sdim { "(bad)", { XX } }, 2297218822Sdim { "(bad)", { XX } }, 2298218822Sdim { "pminuw", { XM, EXx } }, 2299218822Sdim { "(bad)", { XX } }, 2300218822Sdim }, 2301218822Sdim 2302218822Sdim /* PREGRP62 */ 2303218822Sdim { 2304218822Sdim { "(bad)", { XX } }, 2305218822Sdim { "(bad)", { XX } }, 2306218822Sdim { "pminud", { XM, EXx } }, 2307218822Sdim { "(bad)", { XX } }, 2308218822Sdim }, 2309218822Sdim 2310218822Sdim /* PREGRP63 */ 2311218822Sdim { 2312218822Sdim { "(bad)", { XX } }, 2313218822Sdim { "(bad)", { XX } }, 2314218822Sdim { "pmaxsb", { XM, EXx } }, 2315218822Sdim { "(bad)", { XX } }, 2316218822Sdim }, 2317218822Sdim 2318218822Sdim /* PREGRP64 */ 2319218822Sdim { 2320218822Sdim { "(bad)", { XX } }, 2321218822Sdim { "(bad)", { XX } }, 2322218822Sdim { "pmaxsd", { XM, EXx } }, 2323218822Sdim { "(bad)", { XX } }, 2324218822Sdim }, 2325218822Sdim 2326218822Sdim /* PREGRP65 */ 2327218822Sdim { 2328218822Sdim { "(bad)", { XX } }, 2329218822Sdim { "(bad)", { XX } }, 2330218822Sdim { "pmaxuw", { XM, EXx } }, 2331218822Sdim { "(bad)", { XX } }, 2332218822Sdim }, 2333218822Sdim 2334218822Sdim /* PREGRP66 */ 2335218822Sdim { 2336218822Sdim { "(bad)", { XX } }, 2337218822Sdim { "(bad)", { XX } }, 2338218822Sdim { "pmaxud", { XM, EXx } }, 2339218822Sdim { "(bad)", { XX } }, 2340218822Sdim }, 2341218822Sdim 2342218822Sdim /* PREGRP67 */ 2343218822Sdim { 2344218822Sdim { "(bad)", { XX } }, 2345218822Sdim { "(bad)", { XX } }, 2346218822Sdim { "pmulld", { XM, EXx } }, 2347218822Sdim { "(bad)", { XX } }, 2348218822Sdim }, 2349218822Sdim 2350218822Sdim /* PREGRP68 */ 2351218822Sdim { 2352218822Sdim { "(bad)", { XX } }, 2353218822Sdim { "(bad)", { XX } }, 2354218822Sdim { "phminposuw", { XM, EXx } }, 2355218822Sdim { "(bad)", { XX } }, 2356218822Sdim }, 2357218822Sdim 2358218822Sdim /* PREGRP69 */ 2359218822Sdim { 2360218822Sdim { "(bad)", { XX } }, 2361218822Sdim { "(bad)", { XX } }, 2362218822Sdim { "roundps", { XM, EXx, Ib } }, 2363218822Sdim { "(bad)", { XX } }, 2364218822Sdim }, 2365218822Sdim 2366218822Sdim /* PREGRP70 */ 2367218822Sdim { 2368218822Sdim { "(bad)", { XX } }, 2369218822Sdim { "(bad)", { XX } }, 2370218822Sdim { "roundpd", { XM, EXx, Ib } }, 2371218822Sdim { "(bad)", { XX } }, 2372218822Sdim }, 2373218822Sdim 2374218822Sdim /* PREGRP71 */ 2375218822Sdim { 2376218822Sdim { "(bad)", { XX } }, 2377218822Sdim { "(bad)", { XX } }, 2378218822Sdim { "roundss", { XM, EXx, Ib } }, 2379218822Sdim { "(bad)", { XX } }, 2380218822Sdim }, 2381218822Sdim 2382218822Sdim /* PREGRP72 */ 2383218822Sdim { 2384218822Sdim { "(bad)", { XX } }, 2385218822Sdim { "(bad)", { XX } }, 2386218822Sdim { "roundsd", { XM, EXx, Ib } }, 2387218822Sdim { "(bad)", { XX } }, 2388218822Sdim }, 2389218822Sdim 2390218822Sdim /* PREGRP73 */ 2391218822Sdim { 2392218822Sdim { "(bad)", { XX } }, 2393218822Sdim { "(bad)", { XX } }, 2394218822Sdim { "blendps", { XM, EXx, Ib } }, 2395218822Sdim { "(bad)", { XX } }, 2396218822Sdim }, 2397218822Sdim 2398218822Sdim /* PREGRP74 */ 2399218822Sdim { 2400218822Sdim { "(bad)", { XX } }, 2401218822Sdim { "(bad)", { XX } }, 2402218822Sdim { "blendpd", { XM, EXx, Ib } }, 2403218822Sdim { "(bad)", { XX } }, 2404218822Sdim }, 2405218822Sdim 2406218822Sdim /* PREGRP75 */ 2407218822Sdim { 2408218822Sdim { "(bad)", { XX } }, 2409218822Sdim { "(bad)", { XX } }, 2410218822Sdim { "pblendw", { XM, EXx, Ib } }, 2411218822Sdim { "(bad)", { XX } }, 2412218822Sdim }, 2413218822Sdim 2414218822Sdim /* PREGRP76 */ 2415218822Sdim { 2416218822Sdim { "(bad)", { XX } }, 2417218822Sdim { "(bad)", { XX } }, 2418218822Sdim { "pextrb", { Edqb, XM, Ib } }, 2419218822Sdim { "(bad)", { XX } }, 2420218822Sdim }, 2421218822Sdim 2422218822Sdim /* PREGRP77 */ 2423218822Sdim { 2424218822Sdim { "(bad)", { XX } }, 2425218822Sdim { "(bad)", { XX } }, 2426218822Sdim { "pextrw", { Edqw, XM, Ib } }, 2427218822Sdim { "(bad)", { XX } }, 2428218822Sdim }, 2429218822Sdim 2430218822Sdim /* PREGRP78 */ 2431218822Sdim { 2432218822Sdim { "(bad)", { XX } }, 2433218822Sdim { "(bad)", { XX } }, 2434218822Sdim { "pextrK", { Edq, XM, Ib } }, 2435218822Sdim { "(bad)", { XX } }, 2436218822Sdim }, 2437218822Sdim 2438218822Sdim /* PREGRP79 */ 2439218822Sdim { 2440218822Sdim { "(bad)", { XX } }, 2441218822Sdim { "(bad)", { XX } }, 2442218822Sdim { "extractps", { Edqd, XM, Ib } }, 2443218822Sdim { "(bad)", { XX } }, 2444218822Sdim }, 2445218822Sdim 2446218822Sdim /* PREGRP80 */ 2447218822Sdim { 2448218822Sdim { "(bad)", { XX } }, 2449218822Sdim { "(bad)", { XX } }, 2450218822Sdim { "pinsrb", { XM, Edqb, Ib } }, 2451218822Sdim { "(bad)", { XX } }, 2452218822Sdim }, 2453218822Sdim 2454218822Sdim /* PREGRP81 */ 2455218822Sdim { 2456218822Sdim { "(bad)", { XX } }, 2457218822Sdim { "(bad)", { XX } }, 2458218822Sdim { "insertps", { XM, EXx, Ib } }, 2459218822Sdim { "(bad)", { XX } }, 2460218822Sdim }, 2461218822Sdim 2462218822Sdim /* PREGRP82 */ 2463218822Sdim { 2464218822Sdim { "(bad)", { XX } }, 2465218822Sdim { "(bad)", { XX } }, 2466218822Sdim { "pinsrK", { XM, Edq, Ib } }, 2467218822Sdim { "(bad)", { XX } }, 2468218822Sdim }, 2469218822Sdim 2470218822Sdim /* PREGRP83 */ 2471218822Sdim { 2472218822Sdim { "(bad)", { XX } }, 2473218822Sdim { "(bad)", { XX } }, 2474218822Sdim { "dpps", { XM, EXx, Ib } }, 2475218822Sdim { "(bad)", { XX } }, 2476218822Sdim }, 2477218822Sdim 2478218822Sdim /* PREGRP84 */ 2479218822Sdim { 2480218822Sdim { "(bad)", { XX } }, 2481218822Sdim { "(bad)", { XX } }, 2482218822Sdim { "dppd", { XM, EXx, Ib } }, 2483218822Sdim { "(bad)", { XX } }, 2484218822Sdim }, 2485218822Sdim 2486218822Sdim /* PREGRP85 */ 2487218822Sdim { 2488218822Sdim { "(bad)", { XX } }, 2489218822Sdim { "(bad)", { XX } }, 2490218822Sdim { "mpsadbw", { XM, EXx, Ib } }, 2491218822Sdim { "(bad)", { XX } }, 2492218822Sdim }, 2493218822Sdim 2494218822Sdim /* PREGRP86 */ 2495218822Sdim { 2496218822Sdim { "(bad)", { XX } }, 2497218822Sdim { "(bad)", { XX } }, 2498218822Sdim { "pcmpgtq", { XM, EXx } }, 2499218822Sdim { "(bad)", { XX } }, 2500218822Sdim }, 2501218822Sdim 2502218822Sdim /* PREGRP87 */ 2503218822Sdim { 2504218822Sdim { "(bad)", { XX } }, 2505218822Sdim { "(bad)", { XX } }, 2506218822Sdim { "(bad)", { XX } }, 2507218822Sdim { "crc32", { Gdq, { CRC32_Fixup, b_mode } } }, 2508218822Sdim }, 2509218822Sdim 2510218822Sdim /* PREGRP88 */ 2511218822Sdim { 2512218822Sdim { "(bad)", { XX } }, 2513218822Sdim { "(bad)", { XX } }, 2514218822Sdim { "(bad)", { XX } }, 2515218822Sdim { "crc32", { Gdq, { CRC32_Fixup, v_mode } } }, 2516218822Sdim }, 2517218822Sdim 2518218822Sdim /* PREGRP89 */ 2519218822Sdim { 2520218822Sdim { "(bad)", { XX } }, 2521218822Sdim { "(bad)", { XX } }, 2522218822Sdim { "pcmpestrm", { XM, EXx, Ib } }, 2523218822Sdim { "(bad)", { XX } }, 2524218822Sdim }, 2525218822Sdim 2526218822Sdim /* PREGRP90 */ 2527218822Sdim { 2528218822Sdim { "(bad)", { XX } }, 2529218822Sdim { "(bad)", { XX } }, 2530218822Sdim { "pcmpestri", { XM, EXx, Ib } }, 2531218822Sdim { "(bad)", { XX } }, 2532218822Sdim }, 2533218822Sdim 2534218822Sdim /* PREGRP91 */ 2535218822Sdim { 2536218822Sdim { "(bad)", { XX } }, 2537218822Sdim { "(bad)", { XX } }, 2538218822Sdim { "pcmpistrm", { XM, EXx, Ib } }, 2539218822Sdim { "(bad)", { XX } }, 2540218822Sdim }, 2541218822Sdim 2542218822Sdim /* PREGRP92 */ 2543218822Sdim { 2544218822Sdim { "(bad)", { XX } }, 2545218822Sdim { "(bad)", { XX } }, 2546218822Sdim { "pcmpistri", { XM, EXx, Ib } }, 2547218822Sdim { "(bad)", { XX } }, 2548218822Sdim }, 2549218822Sdim 2550218822Sdim /* PREGRP93 */ 2551218822Sdim { 2552218822Sdim { "ucomiss",{ XM, EXd } }, 2553218822Sdim { "(bad)", { XX } }, 2554218822Sdim { "ucomisd",{ XM, EXq } }, 2555218822Sdim { "(bad)", { XX } }, 2556218822Sdim }, 2557218822Sdim 2558218822Sdim /* PREGRP94 */ 2559218822Sdim { 2560218822Sdim { "comiss", { XM, EXd } }, 2561218822Sdim { "(bad)", { XX } }, 2562218822Sdim { "comisd", { XM, EXq } }, 2563218822Sdim { "(bad)", { XX } }, 2564218822Sdim }, 2565218822Sdim 2566218822Sdim /* PREGRP95 */ 2567218822Sdim { 2568218822Sdim { "punpcklbw",{ MX, EMd } }, 2569218822Sdim { "(bad)", { XX } }, 2570218822Sdim { "punpcklbw",{ MX, EMq } }, 2571218822Sdim { "(bad)", { XX } }, 2572218822Sdim }, 2573218822Sdim 2574218822Sdim /* PREGRP96 */ 2575218822Sdim { 2576218822Sdim { "punpcklwd",{ MX, EMd } }, 2577218822Sdim { "(bad)", { XX } }, 2578218822Sdim { "punpcklwd",{ MX, EMq } }, 2579218822Sdim { "(bad)", { XX } }, 2580218822Sdim }, 2581218822Sdim 2582218822Sdim /* PREGRP97 */ 2583218822Sdim { 2584218822Sdim { "punpckldq",{ MX, EMd } }, 2585218822Sdim { "(bad)", { XX } }, 2586218822Sdim { "punpckldq",{ MX, EMq } }, 2587218822Sdim { "(bad)", { XX } }, 2588218822Sdim }, 258960484Sobrien}; 259033965Sjdp 259185815Sobrienstatic const struct dis386 x86_64_table[][2] = { 259285815Sobrien { 2593218822Sdim { "pusha{P|}", { XX } }, 2594218822Sdim { "(bad)", { XX } }, 259585815Sobrien }, 2596218822Sdim { 2597218822Sdim { "popa{P|}", { XX } }, 2598218822Sdim { "(bad)", { XX } }, 2599218822Sdim }, 2600218822Sdim { 2601218822Sdim { "bound{S|}", { Gv, Ma } }, 2602218822Sdim { "(bad)", { XX } }, 2603218822Sdim }, 2604218822Sdim { 2605218822Sdim { "arpl", { Ew, Gw } }, 2606218822Sdim { "movs{||lq|xd}", { Gv, Ed } }, 2607218822Sdim }, 260885815Sobrien}; 260985815Sobrien 2610218822Sdimstatic const struct dis386 three_byte_table[][256] = { 2611218822Sdim /* THREE_BYTE_0 */ 2612218822Sdim { 2613218822Sdim /* 00 */ 2614218822Sdim { "pshufb", { MX, EM } }, 2615218822Sdim { "phaddw", { MX, EM } }, 2616218822Sdim { "phaddd", { MX, EM } }, 2617218822Sdim { "phaddsw", { MX, EM } }, 2618218822Sdim { "pmaddubsw", { MX, EM } }, 2619218822Sdim { "phsubw", { MX, EM } }, 2620218822Sdim { "phsubd", { MX, EM } }, 2621218822Sdim { "phsubsw", { MX, EM } }, 2622218822Sdim /* 08 */ 2623218822Sdim { "psignb", { MX, EM } }, 2624218822Sdim { "psignw", { MX, EM } }, 2625218822Sdim { "psignd", { MX, EM } }, 2626218822Sdim { "pmulhrsw", { MX, EM } }, 2627218822Sdim { "(bad)", { XX } }, 2628218822Sdim { "(bad)", { XX } }, 2629218822Sdim { "(bad)", { XX } }, 2630218822Sdim { "(bad)", { XX } }, 2631218822Sdim /* 10 */ 2632218822Sdim { PREGRP39 }, 2633218822Sdim { "(bad)", { XX } }, 2634218822Sdim { "(bad)", { XX } }, 2635218822Sdim { "(bad)", { XX } }, 2636218822Sdim { PREGRP40 }, 2637218822Sdim { PREGRP41 }, 2638218822Sdim { "(bad)", { XX } }, 2639218822Sdim { PREGRP42 }, 2640218822Sdim /* 18 */ 2641218822Sdim { "(bad)", { XX } }, 2642218822Sdim { "(bad)", { XX } }, 2643218822Sdim { "(bad)", { XX } }, 2644218822Sdim { "(bad)", { XX } }, 2645218822Sdim { "pabsb", { MX, EM } }, 2646218822Sdim { "pabsw", { MX, EM } }, 2647218822Sdim { "pabsd", { MX, EM } }, 2648218822Sdim { "(bad)", { XX } }, 2649218822Sdim /* 20 */ 2650218822Sdim { PREGRP43 }, 2651218822Sdim { PREGRP44 }, 2652218822Sdim { PREGRP45 }, 2653218822Sdim { PREGRP46 }, 2654218822Sdim { PREGRP47 }, 2655218822Sdim { PREGRP48 }, 2656218822Sdim { "(bad)", { XX } }, 2657218822Sdim { "(bad)", { XX } }, 2658218822Sdim /* 28 */ 2659218822Sdim { PREGRP49 }, 2660218822Sdim { PREGRP50 }, 2661218822Sdim { PREGRP51 }, 2662218822Sdim { PREGRP52 }, 2663218822Sdim { "(bad)", { XX } }, 2664218822Sdim { "(bad)", { XX } }, 2665218822Sdim { "(bad)", { XX } }, 2666218822Sdim { "(bad)", { XX } }, 2667218822Sdim /* 30 */ 2668218822Sdim { PREGRP53 }, 2669218822Sdim { PREGRP54 }, 2670218822Sdim { PREGRP55 }, 2671218822Sdim { PREGRP56 }, 2672218822Sdim { PREGRP57 }, 2673218822Sdim { PREGRP58 }, 2674218822Sdim { "(bad)", { XX } }, 2675218822Sdim { PREGRP86 }, 2676218822Sdim /* 38 */ 2677218822Sdim { PREGRP59 }, 2678218822Sdim { PREGRP60 }, 2679218822Sdim { PREGRP61 }, 2680218822Sdim { PREGRP62 }, 2681218822Sdim { PREGRP63 }, 2682218822Sdim { PREGRP64 }, 2683218822Sdim { PREGRP65 }, 2684218822Sdim { PREGRP66 }, 2685218822Sdim /* 40 */ 2686218822Sdim { PREGRP67 }, 2687218822Sdim { PREGRP68 }, 2688218822Sdim { "(bad)", { XX } }, 2689218822Sdim { "(bad)", { XX } }, 2690218822Sdim { "(bad)", { XX } }, 2691218822Sdim { "(bad)", { XX } }, 2692218822Sdim { "(bad)", { XX } }, 2693218822Sdim { "(bad)", { XX } }, 2694218822Sdim /* 48 */ 2695218822Sdim { "(bad)", { XX } }, 2696218822Sdim { "(bad)", { XX } }, 2697218822Sdim { "(bad)", { XX } }, 2698218822Sdim { "(bad)", { XX } }, 2699218822Sdim { "(bad)", { XX } }, 2700218822Sdim { "(bad)", { XX } }, 2701218822Sdim { "(bad)", { XX } }, 2702218822Sdim { "(bad)", { XX } }, 2703218822Sdim /* 50 */ 2704218822Sdim { "(bad)", { XX } }, 2705218822Sdim { "(bad)", { XX } }, 2706218822Sdim { "(bad)", { XX } }, 2707218822Sdim { "(bad)", { XX } }, 2708218822Sdim { "(bad)", { XX } }, 2709218822Sdim { "(bad)", { XX } }, 2710218822Sdim { "(bad)", { XX } }, 2711218822Sdim { "(bad)", { XX } }, 2712218822Sdim /* 58 */ 2713218822Sdim { "(bad)", { XX } }, 2714218822Sdim { "(bad)", { XX } }, 2715218822Sdim { "(bad)", { XX } }, 2716218822Sdim { "(bad)", { XX } }, 2717218822Sdim { "(bad)", { XX } }, 2718218822Sdim { "(bad)", { XX } }, 2719218822Sdim { "(bad)", { XX } }, 2720218822Sdim { "(bad)", { XX } }, 2721218822Sdim /* 60 */ 2722218822Sdim { "(bad)", { XX } }, 2723218822Sdim { "(bad)", { XX } }, 2724218822Sdim { "(bad)", { XX } }, 2725218822Sdim { "(bad)", { XX } }, 2726218822Sdim { "(bad)", { XX } }, 2727218822Sdim { "(bad)", { XX } }, 2728218822Sdim { "(bad)", { XX } }, 2729218822Sdim { "(bad)", { XX } }, 2730218822Sdim /* 68 */ 2731218822Sdim { "(bad)", { XX } }, 2732218822Sdim { "(bad)", { XX } }, 2733218822Sdim { "(bad)", { XX } }, 2734218822Sdim { "(bad)", { XX } }, 2735218822Sdim { "(bad)", { XX } }, 2736218822Sdim { "(bad)", { XX } }, 2737218822Sdim { "(bad)", { XX } }, 2738218822Sdim { "(bad)", { XX } }, 2739218822Sdim /* 70 */ 2740218822Sdim { "(bad)", { XX } }, 2741218822Sdim { "(bad)", { XX } }, 2742218822Sdim { "(bad)", { XX } }, 2743218822Sdim { "(bad)", { XX } }, 2744218822Sdim { "(bad)", { XX } }, 2745218822Sdim { "(bad)", { XX } }, 2746218822Sdim { "(bad)", { XX } }, 2747218822Sdim { "(bad)", { XX } }, 2748218822Sdim /* 78 */ 2749218822Sdim { "(bad)", { XX } }, 2750218822Sdim { "(bad)", { XX } }, 2751218822Sdim { "(bad)", { XX } }, 2752218822Sdim { "(bad)", { XX } }, 2753218822Sdim { "(bad)", { XX } }, 2754218822Sdim { "(bad)", { XX } }, 2755218822Sdim { "(bad)", { XX } }, 2756218822Sdim { "(bad)", { XX } }, 2757218822Sdim /* 80 */ 2758218822Sdim { "(bad)", { XX } }, 2759218822Sdim { "(bad)", { XX } }, 2760218822Sdim { "(bad)", { XX } }, 2761218822Sdim { "(bad)", { XX } }, 2762218822Sdim { "(bad)", { XX } }, 2763218822Sdim { "(bad)", { XX } }, 2764218822Sdim { "(bad)", { XX } }, 2765218822Sdim { "(bad)", { XX } }, 2766218822Sdim /* 88 */ 2767218822Sdim { "(bad)", { XX } }, 2768218822Sdim { "(bad)", { XX } }, 2769218822Sdim { "(bad)", { XX } }, 2770218822Sdim { "(bad)", { XX } }, 2771218822Sdim { "(bad)", { XX } }, 2772218822Sdim { "(bad)", { XX } }, 2773218822Sdim { "(bad)", { XX } }, 2774218822Sdim { "(bad)", { XX } }, 2775218822Sdim /* 90 */ 2776218822Sdim { "(bad)", { XX } }, 2777218822Sdim { "(bad)", { XX } }, 2778218822Sdim { "(bad)", { XX } }, 2779218822Sdim { "(bad)", { XX } }, 2780218822Sdim { "(bad)", { XX } }, 2781218822Sdim { "(bad)", { XX } }, 2782218822Sdim { "(bad)", { XX } }, 2783218822Sdim { "(bad)", { XX } }, 2784218822Sdim /* 98 */ 2785218822Sdim { "(bad)", { XX } }, 2786218822Sdim { "(bad)", { XX } }, 2787218822Sdim { "(bad)", { XX } }, 2788218822Sdim { "(bad)", { XX } }, 2789218822Sdim { "(bad)", { XX } }, 2790218822Sdim { "(bad)", { XX } }, 2791218822Sdim { "(bad)", { XX } }, 2792218822Sdim { "(bad)", { XX } }, 2793218822Sdim /* a0 */ 2794218822Sdim { "(bad)", { XX } }, 2795218822Sdim { "(bad)", { XX } }, 2796218822Sdim { "(bad)", { XX } }, 2797218822Sdim { "(bad)", { XX } }, 2798218822Sdim { "(bad)", { XX } }, 2799218822Sdim { "(bad)", { XX } }, 2800218822Sdim { "(bad)", { XX } }, 2801218822Sdim { "(bad)", { XX } }, 2802218822Sdim /* a8 */ 2803218822Sdim { "(bad)", { XX } }, 2804218822Sdim { "(bad)", { XX } }, 2805218822Sdim { "(bad)", { XX } }, 2806218822Sdim { "(bad)", { XX } }, 2807218822Sdim { "(bad)", { XX } }, 2808218822Sdim { "(bad)", { XX } }, 2809218822Sdim { "(bad)", { XX } }, 2810218822Sdim { "(bad)", { XX } }, 2811218822Sdim /* b0 */ 2812218822Sdim { "(bad)", { XX } }, 2813218822Sdim { "(bad)", { XX } }, 2814218822Sdim { "(bad)", { XX } }, 2815218822Sdim { "(bad)", { XX } }, 2816218822Sdim { "(bad)", { XX } }, 2817218822Sdim { "(bad)", { XX } }, 2818218822Sdim { "(bad)", { XX } }, 2819218822Sdim { "(bad)", { XX } }, 2820218822Sdim /* b8 */ 2821218822Sdim { "(bad)", { XX } }, 2822218822Sdim { "(bad)", { XX } }, 2823218822Sdim { "(bad)", { XX } }, 2824218822Sdim { "(bad)", { XX } }, 2825218822Sdim { "(bad)", { XX } }, 2826218822Sdim { "(bad)", { XX } }, 2827218822Sdim { "(bad)", { XX } }, 2828218822Sdim { "(bad)", { XX } }, 2829218822Sdim /* c0 */ 2830218822Sdim { "(bad)", { XX } }, 2831218822Sdim { "(bad)", { XX } }, 2832218822Sdim { "(bad)", { XX } }, 2833218822Sdim { "(bad)", { XX } }, 2834218822Sdim { "(bad)", { XX } }, 2835218822Sdim { "(bad)", { XX } }, 2836218822Sdim { "(bad)", { XX } }, 2837218822Sdim { "(bad)", { XX } }, 2838218822Sdim /* c8 */ 2839218822Sdim { "(bad)", { XX } }, 2840218822Sdim { "(bad)", { XX } }, 2841218822Sdim { "(bad)", { XX } }, 2842218822Sdim { "(bad)", { XX } }, 2843218822Sdim { "(bad)", { XX } }, 2844218822Sdim { "(bad)", { XX } }, 2845218822Sdim { "(bad)", { XX } }, 2846218822Sdim { "(bad)", { XX } }, 2847218822Sdim /* d0 */ 2848218822Sdim { "(bad)", { XX } }, 2849218822Sdim { "(bad)", { XX } }, 2850218822Sdim { "(bad)", { XX } }, 2851218822Sdim { "(bad)", { XX } }, 2852218822Sdim { "(bad)", { XX } }, 2853218822Sdim { "(bad)", { XX } }, 2854218822Sdim { "(bad)", { XX } }, 2855218822Sdim { "(bad)", { XX } }, 2856218822Sdim /* d8 */ 2857218822Sdim { "(bad)", { XX } }, 2858218822Sdim { "(bad)", { XX } }, 2859218822Sdim { "(bad)", { XX } }, 2860218822Sdim { "(bad)", { XX } }, 2861218822Sdim { "(bad)", { XX } }, 2862218822Sdim { "(bad)", { XX } }, 2863218822Sdim { "(bad)", { XX } }, 2864218822Sdim { "(bad)", { XX } }, 2865218822Sdim /* e0 */ 2866218822Sdim { "(bad)", { XX } }, 2867218822Sdim { "(bad)", { XX } }, 2868218822Sdim { "(bad)", { XX } }, 2869218822Sdim { "(bad)", { XX } }, 2870218822Sdim { "(bad)", { XX } }, 2871218822Sdim { "(bad)", { XX } }, 2872218822Sdim { "(bad)", { XX } }, 2873218822Sdim { "(bad)", { XX } }, 2874218822Sdim /* e8 */ 2875218822Sdim { "(bad)", { XX } }, 2876218822Sdim { "(bad)", { XX } }, 2877218822Sdim { "(bad)", { XX } }, 2878218822Sdim { "(bad)", { XX } }, 2879218822Sdim { "(bad)", { XX } }, 2880218822Sdim { "(bad)", { XX } }, 2881218822Sdim { "(bad)", { XX } }, 2882218822Sdim { "(bad)", { XX } }, 2883218822Sdim /* f0 */ 2884218822Sdim { PREGRP87 }, 2885218822Sdim { PREGRP88 }, 2886218822Sdim { "(bad)", { XX } }, 2887218822Sdim { "(bad)", { XX } }, 2888218822Sdim { "(bad)", { XX } }, 2889218822Sdim { "(bad)", { XX } }, 2890218822Sdim { "(bad)", { XX } }, 2891218822Sdim { "(bad)", { XX } }, 2892218822Sdim /* f8 */ 2893218822Sdim { "(bad)", { XX } }, 2894218822Sdim { "(bad)", { XX } }, 2895218822Sdim { "(bad)", { XX } }, 2896218822Sdim { "(bad)", { XX } }, 2897218822Sdim { "(bad)", { XX } }, 2898218822Sdim { "(bad)", { XX } }, 2899218822Sdim { "(bad)", { XX } }, 2900218822Sdim { "(bad)", { XX } }, 2901218822Sdim }, 2902218822Sdim /* THREE_BYTE_1 */ 2903218822Sdim { 2904218822Sdim /* 00 */ 2905218822Sdim { "(bad)", { XX } }, 2906218822Sdim { "(bad)", { XX } }, 2907218822Sdim { "(bad)", { XX } }, 2908218822Sdim { "(bad)", { XX } }, 2909218822Sdim { "(bad)", { XX } }, 2910218822Sdim { "(bad)", { XX } }, 2911218822Sdim { "(bad)", { XX } }, 2912218822Sdim { "(bad)", { XX } }, 2913218822Sdim /* 08 */ 2914218822Sdim { PREGRP69 }, 2915218822Sdim { PREGRP70 }, 2916218822Sdim { PREGRP71 }, 2917218822Sdim { PREGRP72 }, 2918218822Sdim { PREGRP73 }, 2919218822Sdim { PREGRP74 }, 2920218822Sdim { PREGRP75 }, 2921218822Sdim { "palignr", { MX, EM, Ib } }, 2922218822Sdim /* 10 */ 2923218822Sdim { "(bad)", { XX } }, 2924218822Sdim { "(bad)", { XX } }, 2925218822Sdim { "(bad)", { XX } }, 2926218822Sdim { "(bad)", { XX } }, 2927218822Sdim { PREGRP76 }, 2928218822Sdim { PREGRP77 }, 2929218822Sdim { PREGRP78 }, 2930218822Sdim { PREGRP79 }, 2931218822Sdim /* 18 */ 2932218822Sdim { "(bad)", { XX } }, 2933218822Sdim { "(bad)", { XX } }, 2934218822Sdim { "(bad)", { XX } }, 2935218822Sdim { "(bad)", { XX } }, 2936218822Sdim { "(bad)", { XX } }, 2937218822Sdim { "(bad)", { XX } }, 2938218822Sdim { "(bad)", { XX } }, 2939218822Sdim { "(bad)", { XX } }, 2940218822Sdim /* 20 */ 2941218822Sdim { PREGRP80 }, 2942218822Sdim { PREGRP81 }, 2943218822Sdim { PREGRP82 }, 2944218822Sdim { "(bad)", { XX } }, 2945218822Sdim { "(bad)", { XX } }, 2946218822Sdim { "(bad)", { XX } }, 2947218822Sdim { "(bad)", { XX } }, 2948218822Sdim { "(bad)", { XX } }, 2949218822Sdim /* 28 */ 2950218822Sdim { "(bad)", { XX } }, 2951218822Sdim { "(bad)", { XX } }, 2952218822Sdim { "(bad)", { XX } }, 2953218822Sdim { "(bad)", { XX } }, 2954218822Sdim { "(bad)", { XX } }, 2955218822Sdim { "(bad)", { XX } }, 2956218822Sdim { "(bad)", { XX } }, 2957218822Sdim { "(bad)", { XX } }, 2958218822Sdim /* 30 */ 2959218822Sdim { "(bad)", { XX } }, 2960218822Sdim { "(bad)", { XX } }, 2961218822Sdim { "(bad)", { XX } }, 2962218822Sdim { "(bad)", { XX } }, 2963218822Sdim { "(bad)", { XX } }, 2964218822Sdim { "(bad)", { XX } }, 2965218822Sdim { "(bad)", { XX } }, 2966218822Sdim { "(bad)", { XX } }, 2967218822Sdim /* 38 */ 2968218822Sdim { "(bad)", { XX } }, 2969218822Sdim { "(bad)", { XX } }, 2970218822Sdim { "(bad)", { XX } }, 2971218822Sdim { "(bad)", { XX } }, 2972218822Sdim { "(bad)", { XX } }, 2973218822Sdim { "(bad)", { XX } }, 2974218822Sdim { "(bad)", { XX } }, 2975218822Sdim { "(bad)", { XX } }, 2976218822Sdim /* 40 */ 2977218822Sdim { PREGRP83 }, 2978218822Sdim { PREGRP84 }, 2979218822Sdim { PREGRP85 }, 2980218822Sdim { "(bad)", { XX } }, 2981218822Sdim { "(bad)", { XX } }, 2982218822Sdim { "(bad)", { XX } }, 2983218822Sdim { "(bad)", { XX } }, 2984218822Sdim { "(bad)", { XX } }, 2985218822Sdim /* 48 */ 2986218822Sdim { "(bad)", { XX } }, 2987218822Sdim { "(bad)", { XX } }, 2988218822Sdim { "(bad)", { XX } }, 2989218822Sdim { "(bad)", { XX } }, 2990218822Sdim { "(bad)", { XX } }, 2991218822Sdim { "(bad)", { XX } }, 2992218822Sdim { "(bad)", { XX } }, 2993218822Sdim { "(bad)", { XX } }, 2994218822Sdim /* 50 */ 2995218822Sdim { "(bad)", { XX } }, 2996218822Sdim { "(bad)", { XX } }, 2997218822Sdim { "(bad)", { XX } }, 2998218822Sdim { "(bad)", { XX } }, 2999218822Sdim { "(bad)", { XX } }, 3000218822Sdim { "(bad)", { XX } }, 3001218822Sdim { "(bad)", { XX } }, 3002218822Sdim { "(bad)", { XX } }, 3003218822Sdim /* 58 */ 3004218822Sdim { "(bad)", { XX } }, 3005218822Sdim { "(bad)", { XX } }, 3006218822Sdim { "(bad)", { XX } }, 3007218822Sdim { "(bad)", { XX } }, 3008218822Sdim { "(bad)", { XX } }, 3009218822Sdim { "(bad)", { XX } }, 3010218822Sdim { "(bad)", { XX } }, 3011218822Sdim { "(bad)", { XX } }, 3012218822Sdim /* 60 */ 3013218822Sdim { PREGRP89 }, 3014218822Sdim { PREGRP90 }, 3015218822Sdim { PREGRP91 }, 3016218822Sdim { PREGRP92 }, 3017218822Sdim { "(bad)", { XX } }, 3018218822Sdim { "(bad)", { XX } }, 3019218822Sdim { "(bad)", { XX } }, 3020218822Sdim { "(bad)", { XX } }, 3021218822Sdim /* 68 */ 3022218822Sdim { "(bad)", { XX } }, 3023218822Sdim { "(bad)", { XX } }, 3024218822Sdim { "(bad)", { XX } }, 3025218822Sdim { "(bad)", { XX } }, 3026218822Sdim { "(bad)", { XX } }, 3027218822Sdim { "(bad)", { XX } }, 3028218822Sdim { "(bad)", { XX } }, 3029218822Sdim { "(bad)", { XX } }, 3030218822Sdim /* 70 */ 3031218822Sdim { "(bad)", { XX } }, 3032218822Sdim { "(bad)", { XX } }, 3033218822Sdim { "(bad)", { XX } }, 3034218822Sdim { "(bad)", { XX } }, 3035218822Sdim { "(bad)", { XX } }, 3036218822Sdim { "(bad)", { XX } }, 3037218822Sdim { "(bad)", { XX } }, 3038218822Sdim { "(bad)", { XX } }, 3039218822Sdim /* 78 */ 3040218822Sdim { "(bad)", { XX } }, 3041218822Sdim { "(bad)", { XX } }, 3042218822Sdim { "(bad)", { XX } }, 3043218822Sdim { "(bad)", { XX } }, 3044218822Sdim { "(bad)", { XX } }, 3045218822Sdim { "(bad)", { XX } }, 3046218822Sdim { "(bad)", { XX } }, 3047218822Sdim { "(bad)", { XX } }, 3048218822Sdim /* 80 */ 3049218822Sdim { "(bad)", { XX } }, 3050218822Sdim { "(bad)", { XX } }, 3051218822Sdim { "(bad)", { XX } }, 3052218822Sdim { "(bad)", { XX } }, 3053218822Sdim { "(bad)", { XX } }, 3054218822Sdim { "(bad)", { XX } }, 3055218822Sdim { "(bad)", { XX } }, 3056218822Sdim { "(bad)", { XX } }, 3057218822Sdim /* 88 */ 3058218822Sdim { "(bad)", { XX } }, 3059218822Sdim { "(bad)", { XX } }, 3060218822Sdim { "(bad)", { XX } }, 3061218822Sdim { "(bad)", { XX } }, 3062218822Sdim { "(bad)", { XX } }, 3063218822Sdim { "(bad)", { XX } }, 3064218822Sdim { "(bad)", { XX } }, 3065218822Sdim { "(bad)", { XX } }, 3066218822Sdim /* 90 */ 3067218822Sdim { "(bad)", { XX } }, 3068218822Sdim { "(bad)", { XX } }, 3069218822Sdim { "(bad)", { XX } }, 3070218822Sdim { "(bad)", { XX } }, 3071218822Sdim { "(bad)", { XX } }, 3072218822Sdim { "(bad)", { XX } }, 3073218822Sdim { "(bad)", { XX } }, 3074218822Sdim { "(bad)", { XX } }, 3075218822Sdim /* 98 */ 3076218822Sdim { "(bad)", { XX } }, 3077218822Sdim { "(bad)", { XX } }, 3078218822Sdim { "(bad)", { XX } }, 3079218822Sdim { "(bad)", { XX } }, 3080218822Sdim { "(bad)", { XX } }, 3081218822Sdim { "(bad)", { XX } }, 3082218822Sdim { "(bad)", { XX } }, 3083218822Sdim { "(bad)", { XX } }, 3084218822Sdim /* a0 */ 3085218822Sdim { "(bad)", { XX } }, 3086218822Sdim { "(bad)", { XX } }, 3087218822Sdim { "(bad)", { XX } }, 3088218822Sdim { "(bad)", { XX } }, 3089218822Sdim { "(bad)", { XX } }, 3090218822Sdim { "(bad)", { XX } }, 3091218822Sdim { "(bad)", { XX } }, 3092218822Sdim { "(bad)", { XX } }, 3093218822Sdim /* a8 */ 3094218822Sdim { "(bad)", { XX } }, 3095218822Sdim { "(bad)", { XX } }, 3096218822Sdim { "(bad)", { XX } }, 3097218822Sdim { "(bad)", { XX } }, 3098218822Sdim { "(bad)", { XX } }, 3099218822Sdim { "(bad)", { XX } }, 3100218822Sdim { "(bad)", { XX } }, 3101218822Sdim { "(bad)", { XX } }, 3102218822Sdim /* b0 */ 3103218822Sdim { "(bad)", { XX } }, 3104218822Sdim { "(bad)", { XX } }, 3105218822Sdim { "(bad)", { XX } }, 3106218822Sdim { "(bad)", { XX } }, 3107218822Sdim { "(bad)", { XX } }, 3108218822Sdim { "(bad)", { XX } }, 3109218822Sdim { "(bad)", { XX } }, 3110218822Sdim { "(bad)", { XX } }, 3111218822Sdim /* b8 */ 3112218822Sdim { "(bad)", { XX } }, 3113218822Sdim { "(bad)", { XX } }, 3114218822Sdim { "(bad)", { XX } }, 3115218822Sdim { "(bad)", { XX } }, 3116218822Sdim { "(bad)", { XX } }, 3117218822Sdim { "(bad)", { XX } }, 3118218822Sdim { "(bad)", { XX } }, 3119218822Sdim { "(bad)", { XX } }, 3120218822Sdim /* c0 */ 3121218822Sdim { "(bad)", { XX } }, 3122218822Sdim { "(bad)", { XX } }, 3123218822Sdim { "(bad)", { XX } }, 3124218822Sdim { "(bad)", { XX } }, 3125218822Sdim { "(bad)", { XX } }, 3126218822Sdim { "(bad)", { XX } }, 3127218822Sdim { "(bad)", { XX } }, 3128218822Sdim { "(bad)", { XX } }, 3129218822Sdim /* c8 */ 3130218822Sdim { "(bad)", { XX } }, 3131218822Sdim { "(bad)", { XX } }, 3132218822Sdim { "(bad)", { XX } }, 3133218822Sdim { "(bad)", { XX } }, 3134218822Sdim { "(bad)", { XX } }, 3135218822Sdim { "(bad)", { XX } }, 3136218822Sdim { "(bad)", { XX } }, 3137218822Sdim { "(bad)", { XX } }, 3138218822Sdim /* d0 */ 3139218822Sdim { "(bad)", { XX } }, 3140218822Sdim { "(bad)", { XX } }, 3141218822Sdim { "(bad)", { XX } }, 3142218822Sdim { "(bad)", { XX } }, 3143218822Sdim { "(bad)", { XX } }, 3144218822Sdim { "(bad)", { XX } }, 3145218822Sdim { "(bad)", { XX } }, 3146218822Sdim { "(bad)", { XX } }, 3147218822Sdim /* d8 */ 3148218822Sdim { "(bad)", { XX } }, 3149218822Sdim { "(bad)", { XX } }, 3150218822Sdim { "(bad)", { XX } }, 3151218822Sdim { "(bad)", { XX } }, 3152218822Sdim { "(bad)", { XX } }, 3153218822Sdim { "(bad)", { XX } }, 3154218822Sdim { "(bad)", { XX } }, 3155218822Sdim { "(bad)", { XX } }, 3156218822Sdim /* e0 */ 3157218822Sdim { "(bad)", { XX } }, 3158218822Sdim { "(bad)", { XX } }, 3159218822Sdim { "(bad)", { XX } }, 3160218822Sdim { "(bad)", { XX } }, 3161218822Sdim { "(bad)", { XX } }, 3162218822Sdim { "(bad)", { XX } }, 3163218822Sdim { "(bad)", { XX } }, 3164218822Sdim { "(bad)", { XX } }, 3165218822Sdim /* e8 */ 3166218822Sdim { "(bad)", { XX } }, 3167218822Sdim { "(bad)", { XX } }, 3168218822Sdim { "(bad)", { XX } }, 3169218822Sdim { "(bad)", { XX } }, 3170218822Sdim { "(bad)", { XX } }, 3171218822Sdim { "(bad)", { XX } }, 3172218822Sdim { "(bad)", { XX } }, 3173218822Sdim { "(bad)", { XX } }, 3174218822Sdim /* f0 */ 3175218822Sdim { "(bad)", { XX } }, 3176218822Sdim { "(bad)", { XX } }, 3177218822Sdim { "(bad)", { XX } }, 3178218822Sdim { "(bad)", { XX } }, 3179218822Sdim { "(bad)", { XX } }, 3180218822Sdim { "(bad)", { XX } }, 3181218822Sdim { "(bad)", { XX } }, 3182218822Sdim { "(bad)", { XX } }, 3183218822Sdim /* f8 */ 3184218822Sdim { "(bad)", { XX } }, 3185218822Sdim { "(bad)", { XX } }, 3186218822Sdim { "(bad)", { XX } }, 3187218822Sdim { "(bad)", { XX } }, 3188218822Sdim { "(bad)", { XX } }, 3189218822Sdim { "(bad)", { XX } }, 3190218822Sdim { "(bad)", { XX } }, 3191218822Sdim { "(bad)", { XX } }, 3192218822Sdim } 3193218822Sdim}; 3194218822Sdim 319560484Sobrien#define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") 319633965Sjdp 319733965Sjdpstatic void 3198130561Sobrienckprefix (void) 319933965Sjdp{ 320077298Sobrien int newrex; 320177298Sobrien rex = 0; 320233965Sjdp prefixes = 0; 320360484Sobrien used_prefixes = 0; 320477298Sobrien rex_used = 0; 320533965Sjdp while (1) 320633965Sjdp { 3207223262Sbenl (void) FETCH_DATA (the_info, codep + 1); 320877298Sobrien newrex = 0; 320933965Sjdp switch (*codep) 321033965Sjdp { 321177298Sobrien /* REX prefixes family. */ 321277298Sobrien case 0x40: 321377298Sobrien case 0x41: 321477298Sobrien case 0x42: 321577298Sobrien case 0x43: 321677298Sobrien case 0x44: 321777298Sobrien case 0x45: 321877298Sobrien case 0x46: 321977298Sobrien case 0x47: 322077298Sobrien case 0x48: 322177298Sobrien case 0x49: 322277298Sobrien case 0x4a: 322377298Sobrien case 0x4b: 322477298Sobrien case 0x4c: 322577298Sobrien case 0x4d: 322677298Sobrien case 0x4e: 322777298Sobrien case 0x4f: 3228218822Sdim if (address_mode == mode_64bit) 322977298Sobrien newrex = *codep; 323077298Sobrien else 323177298Sobrien return; 323277298Sobrien break; 323333965Sjdp case 0xf3: 323433965Sjdp prefixes |= PREFIX_REPZ; 323533965Sjdp break; 323633965Sjdp case 0xf2: 323733965Sjdp prefixes |= PREFIX_REPNZ; 323833965Sjdp break; 323933965Sjdp case 0xf0: 324033965Sjdp prefixes |= PREFIX_LOCK; 324133965Sjdp break; 324233965Sjdp case 0x2e: 324333965Sjdp prefixes |= PREFIX_CS; 324433965Sjdp break; 324533965Sjdp case 0x36: 324633965Sjdp prefixes |= PREFIX_SS; 324733965Sjdp break; 324833965Sjdp case 0x3e: 324933965Sjdp prefixes |= PREFIX_DS; 325033965Sjdp break; 325133965Sjdp case 0x26: 325233965Sjdp prefixes |= PREFIX_ES; 325333965Sjdp break; 325433965Sjdp case 0x64: 325533965Sjdp prefixes |= PREFIX_FS; 325633965Sjdp break; 325733965Sjdp case 0x65: 325833965Sjdp prefixes |= PREFIX_GS; 325933965Sjdp break; 326033965Sjdp case 0x66: 326133965Sjdp prefixes |= PREFIX_DATA; 326233965Sjdp break; 326333965Sjdp case 0x67: 326460484Sobrien prefixes |= PREFIX_ADDR; 326533965Sjdp break; 326660484Sobrien case FWAIT_OPCODE: 326760484Sobrien /* fwait is really an instruction. If there are prefixes 326860484Sobrien before the fwait, they belong to the fwait, *not* to the 326960484Sobrien following instruction. */ 3270218822Sdim if (prefixes || rex) 327160484Sobrien { 327260484Sobrien prefixes |= PREFIX_FWAIT; 327360484Sobrien codep++; 327460484Sobrien return; 327560484Sobrien } 327660484Sobrien prefixes = PREFIX_FWAIT; 327733965Sjdp break; 327833965Sjdp default: 327933965Sjdp return; 328033965Sjdp } 328177298Sobrien /* Rex is ignored when followed by another prefix. */ 328277298Sobrien if (rex) 328377298Sobrien { 3284218822Sdim rex_used = rex; 3285218822Sdim return; 328677298Sobrien } 328777298Sobrien rex = newrex; 328833965Sjdp codep++; 328933965Sjdp } 329033965Sjdp} 329133965Sjdp 329260484Sobrien/* Return the name of the prefix byte PREF, or NULL if PREF is not a 329360484Sobrien prefix byte. */ 329460484Sobrien 329560484Sobrienstatic const char * 3296130561Sobrienprefix_name (int pref, int sizeflag) 329760484Sobrien{ 3298218822Sdim static const char *rexes [16] = 3299218822Sdim { 3300218822Sdim "rex", /* 0x40 */ 3301218822Sdim "rex.B", /* 0x41 */ 3302218822Sdim "rex.X", /* 0x42 */ 3303218822Sdim "rex.XB", /* 0x43 */ 3304218822Sdim "rex.R", /* 0x44 */ 3305218822Sdim "rex.RB", /* 0x45 */ 3306218822Sdim "rex.RX", /* 0x46 */ 3307218822Sdim "rex.RXB", /* 0x47 */ 3308218822Sdim "rex.W", /* 0x48 */ 3309218822Sdim "rex.WB", /* 0x49 */ 3310218822Sdim "rex.WX", /* 0x4a */ 3311218822Sdim "rex.WXB", /* 0x4b */ 3312218822Sdim "rex.WR", /* 0x4c */ 3313218822Sdim "rex.WRB", /* 0x4d */ 3314218822Sdim "rex.WRX", /* 0x4e */ 3315218822Sdim "rex.WRXB", /* 0x4f */ 3316218822Sdim }; 3317218822Sdim 331860484Sobrien switch (pref) 331960484Sobrien { 332077298Sobrien /* REX prefixes family. */ 332177298Sobrien case 0x40: 332277298Sobrien case 0x41: 332377298Sobrien case 0x42: 332477298Sobrien case 0x43: 332577298Sobrien case 0x44: 332677298Sobrien case 0x45: 332777298Sobrien case 0x46: 332877298Sobrien case 0x47: 332977298Sobrien case 0x48: 333077298Sobrien case 0x49: 333177298Sobrien case 0x4a: 333277298Sobrien case 0x4b: 333377298Sobrien case 0x4c: 333477298Sobrien case 0x4d: 333577298Sobrien case 0x4e: 333677298Sobrien case 0x4f: 3337218822Sdim return rexes [pref - 0x40]; 333860484Sobrien case 0xf3: 333960484Sobrien return "repz"; 334060484Sobrien case 0xf2: 334160484Sobrien return "repnz"; 334260484Sobrien case 0xf0: 334360484Sobrien return "lock"; 334460484Sobrien case 0x2e: 334560484Sobrien return "cs"; 334660484Sobrien case 0x36: 334760484Sobrien return "ss"; 334860484Sobrien case 0x3e: 334960484Sobrien return "ds"; 335060484Sobrien case 0x26: 335160484Sobrien return "es"; 335260484Sobrien case 0x64: 335360484Sobrien return "fs"; 335460484Sobrien case 0x65: 335560484Sobrien return "gs"; 335660484Sobrien case 0x66: 335760484Sobrien return (sizeflag & DFLAG) ? "data16" : "data32"; 335860484Sobrien case 0x67: 3359218822Sdim if (address_mode == mode_64bit) 3360130561Sobrien return (sizeflag & AFLAG) ? "addr32" : "addr64"; 336192828Sobrien else 3362218822Sdim return (sizeflag & AFLAG) ? "addr16" : "addr32"; 336360484Sobrien case FWAIT_OPCODE: 336460484Sobrien return "fwait"; 336560484Sobrien default: 336660484Sobrien return NULL; 336760484Sobrien } 336860484Sobrien} 336960484Sobrien 3370218822Sdimstatic char op_out[MAX_OPERANDS][100]; 3371218822Sdimstatic int op_ad, op_index[MAX_OPERANDS]; 3372218822Sdimstatic int two_source_ops; 3373218822Sdimstatic bfd_vma op_address[MAX_OPERANDS]; 3374218822Sdimstatic bfd_vma op_riprel[MAX_OPERANDS]; 337577298Sobrienstatic bfd_vma start_pc; 3376218822Sdim 337733965Sjdp/* 337833965Sjdp * On the 386's of 1988, the maximum length of an instruction is 15 bytes. 337933965Sjdp * (see topic "Redundant prefixes" in the "Differences from 8086" 338033965Sjdp * section of the "Virtual 8086 Mode" chapter.) 338133965Sjdp * 'pc' should be the address of this instruction, it will 338233965Sjdp * be used to print the target address if this is a relative jump or call 338333965Sjdp * The function returns the length of this instruction in bytes. 338433965Sjdp */ 338533965Sjdp 338660484Sobrienstatic char intel_syntax; 338760484Sobrienstatic char open_char; 338860484Sobrienstatic char close_char; 338960484Sobrienstatic char separator_char; 339060484Sobrienstatic char scale_char; 339160484Sobrien 339289857Sobrien/* Here for backwards compatibility. When gdb stops using 339389857Sobrien print_insn_i386_att and print_insn_i386_intel these functions can 339489857Sobrien disappear, and print_insn_i386 be merged into print_insn. */ 339533965Sjdpint 3396130561Sobrienprint_insn_i386_att (bfd_vma pc, disassemble_info *info) 339733965Sjdp{ 339860484Sobrien intel_syntax = 0; 339960484Sobrien 340089857Sobrien return print_insn (pc, info); 340133965Sjdp} 340233965Sjdp 340333965Sjdpint 3404130561Sobrienprint_insn_i386_intel (bfd_vma pc, disassemble_info *info) 340533965Sjdp{ 340660484Sobrien intel_syntax = 1; 340760484Sobrien 340889857Sobrien return print_insn (pc, info); 340960484Sobrien} 341060484Sobrien 341189857Sobrienint 3412130561Sobrienprint_insn_i386 (bfd_vma pc, disassemble_info *info) 341360484Sobrien{ 341489857Sobrien intel_syntax = -1; 341589857Sobrien 341689857Sobrien return print_insn (pc, info); 341789857Sobrien} 341889857Sobrien 3419218822Sdimvoid 3420218822Sdimprint_i386_disassembler_options (FILE *stream) 3421218822Sdim{ 3422218822Sdim fprintf (stream, _("\n\ 3423218822SdimThe following i386/x86-64 specific disassembler options are supported for use\n\ 3424218822Sdimwith the -M switch (multiple options should be separated by commas):\n")); 3425218822Sdim 3426218822Sdim fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n")); 3427218822Sdim fprintf (stream, _(" i386 Disassemble in 32bit mode\n")); 3428218822Sdim fprintf (stream, _(" i8086 Disassemble in 16bit mode\n")); 3429218822Sdim fprintf (stream, _(" att Display instruction in AT&T syntax\n")); 3430218822Sdim fprintf (stream, _(" intel Display instruction in Intel syntax\n")); 3431218822Sdim fprintf (stream, _(" addr64 Assume 64bit address size\n")); 3432218822Sdim fprintf (stream, _(" addr32 Assume 32bit address size\n")); 3433218822Sdim fprintf (stream, _(" addr16 Assume 16bit address size\n")); 3434218822Sdim fprintf (stream, _(" data32 Assume 32bit data size\n")); 3435218822Sdim fprintf (stream, _(" data16 Assume 16bit data size\n")); 3436218822Sdim fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n")); 3437218822Sdim} 3438218822Sdim 343989857Sobrienstatic int 3440130561Sobrienprint_insn (bfd_vma pc, disassemble_info *info) 344189857Sobrien{ 344260484Sobrien const struct dis386 *dp; 344333965Sjdp int i; 3444218822Sdim char *op_txt[MAX_OPERANDS]; 344533965Sjdp int needcomma; 3446218822Sdim unsigned char uses_DATA_prefix, uses_LOCK_prefix; 3447218822Sdim unsigned char uses_REPNZ_prefix, uses_REPZ_prefix; 344889857Sobrien int sizeflag; 344989857Sobrien const char *p; 345033965Sjdp struct dis_private priv; 3451218822Sdim unsigned char op; 345233965Sjdp 3453218822Sdim if (info->mach == bfd_mach_x86_64_intel_syntax 3454218822Sdim || info->mach == bfd_mach_x86_64) 3455218822Sdim address_mode = mode_64bit; 3456218822Sdim else 3457218822Sdim address_mode = mode_32bit; 345877298Sobrien 3459130561Sobrien if (intel_syntax == (char) -1) 346089857Sobrien intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax 346189857Sobrien || info->mach == bfd_mach_x86_64_intel_syntax); 346289857Sobrien 346360484Sobrien if (info->mach == bfd_mach_i386_i386 346477298Sobrien || info->mach == bfd_mach_x86_64 346577298Sobrien || info->mach == bfd_mach_i386_i386_intel_syntax 346677298Sobrien || info->mach == bfd_mach_x86_64_intel_syntax) 346789857Sobrien priv.orig_sizeflag = AFLAG | DFLAG; 346860484Sobrien else if (info->mach == bfd_mach_i386_i8086) 346989857Sobrien priv.orig_sizeflag = 0; 347060484Sobrien else 347160484Sobrien abort (); 347233965Sjdp 347389857Sobrien for (p = info->disassembler_options; p != NULL; ) 347489857Sobrien { 3475218822Sdim if (CONST_STRNEQ (p, "x86-64")) 347689857Sobrien { 3477218822Sdim address_mode = mode_64bit; 347889857Sobrien priv.orig_sizeflag = AFLAG | DFLAG; 347989857Sobrien } 3480218822Sdim else if (CONST_STRNEQ (p, "i386")) 348189857Sobrien { 3482218822Sdim address_mode = mode_32bit; 348389857Sobrien priv.orig_sizeflag = AFLAG | DFLAG; 348489857Sobrien } 3485218822Sdim else if (CONST_STRNEQ (p, "i8086")) 348689857Sobrien { 3487218822Sdim address_mode = mode_16bit; 348889857Sobrien priv.orig_sizeflag = 0; 348989857Sobrien } 3490218822Sdim else if (CONST_STRNEQ (p, "intel")) 349189857Sobrien { 349289857Sobrien intel_syntax = 1; 349389857Sobrien } 3494218822Sdim else if (CONST_STRNEQ (p, "att")) 349589857Sobrien { 349689857Sobrien intel_syntax = 0; 349789857Sobrien } 3498218822Sdim else if (CONST_STRNEQ (p, "addr")) 349989857Sobrien { 3500218822Sdim if (address_mode == mode_64bit) 3501218822Sdim { 3502218822Sdim if (p[4] == '3' && p[5] == '2') 3503218822Sdim priv.orig_sizeflag &= ~AFLAG; 3504218822Sdim else if (p[4] == '6' && p[5] == '4') 3505218822Sdim priv.orig_sizeflag |= AFLAG; 3506218822Sdim } 3507218822Sdim else 3508218822Sdim { 3509218822Sdim if (p[4] == '1' && p[5] == '6') 3510218822Sdim priv.orig_sizeflag &= ~AFLAG; 3511218822Sdim else if (p[4] == '3' && p[5] == '2') 3512218822Sdim priv.orig_sizeflag |= AFLAG; 3513218822Sdim } 351489857Sobrien } 3515218822Sdim else if (CONST_STRNEQ (p, "data")) 351689857Sobrien { 351789857Sobrien if (p[4] == '1' && p[5] == '6') 351889857Sobrien priv.orig_sizeflag &= ~DFLAG; 351989857Sobrien else if (p[4] == '3' && p[5] == '2') 352089857Sobrien priv.orig_sizeflag |= DFLAG; 352189857Sobrien } 3522218822Sdim else if (CONST_STRNEQ (p, "suffix")) 352389857Sobrien priv.orig_sizeflag |= SUFFIX_ALWAYS; 352489857Sobrien 352589857Sobrien p = strchr (p, ','); 352689857Sobrien if (p != NULL) 352789857Sobrien p++; 352889857Sobrien } 352989857Sobrien 353089857Sobrien if (intel_syntax) 353189857Sobrien { 353289857Sobrien names64 = intel_names64; 353389857Sobrien names32 = intel_names32; 353489857Sobrien names16 = intel_names16; 353589857Sobrien names8 = intel_names8; 353689857Sobrien names8rex = intel_names8rex; 353789857Sobrien names_seg = intel_names_seg; 353889857Sobrien index16 = intel_index16; 353989857Sobrien open_char = '['; 354089857Sobrien close_char = ']'; 354189857Sobrien separator_char = '+'; 354289857Sobrien scale_char = '*'; 354389857Sobrien } 354489857Sobrien else 354589857Sobrien { 354689857Sobrien names64 = att_names64; 354789857Sobrien names32 = att_names32; 354889857Sobrien names16 = att_names16; 354989857Sobrien names8 = att_names8; 355089857Sobrien names8rex = att_names8rex; 355189857Sobrien names_seg = att_names_seg; 355289857Sobrien index16 = att_index16; 355389857Sobrien open_char = '('; 355489857Sobrien close_char = ')'; 355589857Sobrien separator_char = ','; 355689857Sobrien scale_char = ','; 355789857Sobrien } 355889857Sobrien 355960484Sobrien /* The output looks better if we put 7 bytes on a line, since that 356060484Sobrien puts most long word instructions on a single line. */ 356160484Sobrien info->bytes_per_line = 7; 356260484Sobrien 3563130561Sobrien info->private_data = &priv; 356433965Sjdp priv.max_fetched = priv.the_buffer; 356533965Sjdp priv.insn_start = pc; 356633965Sjdp 356733965Sjdp obuf[0] = 0; 3568218822Sdim for (i = 0; i < MAX_OPERANDS; ++i) 3569218822Sdim { 3570218822Sdim op_out[i][0] = 0; 3571218822Sdim op_index[i] = -1; 3572218822Sdim } 357333965Sjdp 357433965Sjdp the_info = info; 357533965Sjdp start_pc = pc; 357689857Sobrien start_codep = priv.the_buffer; 357789857Sobrien codep = priv.the_buffer; 357860484Sobrien 357960484Sobrien if (setjmp (priv.bailout) != 0) 358060484Sobrien { 358160484Sobrien const char *name; 358260484Sobrien 358360484Sobrien /* Getting here means we tried for data but didn't get it. That 358489857Sobrien means we have an incomplete instruction of some sort. Just 358589857Sobrien print the first byte as a prefix or a .byte pseudo-op. */ 358689857Sobrien if (codep > priv.the_buffer) 358760484Sobrien { 358889857Sobrien name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 358960484Sobrien if (name != NULL) 359060484Sobrien (*info->fprintf_func) (info->stream, "%s", name); 359160484Sobrien else 359260484Sobrien { 359360484Sobrien /* Just print the first byte as a .byte instruction. */ 359460484Sobrien (*info->fprintf_func) (info->stream, ".byte 0x%x", 359589857Sobrien (unsigned int) priv.the_buffer[0]); 359660484Sobrien } 359760484Sobrien 359860484Sobrien return 1; 359960484Sobrien } 360060484Sobrien 360160484Sobrien return -1; 360260484Sobrien } 360360484Sobrien 360477298Sobrien obufp = obuf; 360533965Sjdp ckprefix (); 360633965Sjdp 360760484Sobrien insn_codep = codep; 360889857Sobrien sizeflag = priv.orig_sizeflag; 360960484Sobrien 3610223262Sbenl (void) FETCH_DATA (info, codep + 1); 361160484Sobrien two_source_ops = (*codep == 0x62) || (*codep == 0xc8); 361260484Sobrien 3613218822Sdim if (((prefixes & PREFIX_FWAIT) 3614218822Sdim && ((*codep < 0xd8) || (*codep > 0xdf))) 3615218822Sdim || (rex && rex_used)) 361633965Sjdp { 361760484Sobrien const char *name; 361860484Sobrien 3619218822Sdim /* fwait not followed by floating point instruction, or rex followed 3620218822Sdim by other prefixes. Print the first prefix. */ 362189857Sobrien name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 362260484Sobrien if (name == NULL) 362360484Sobrien name = INTERNAL_DISASSEMBLER_ERROR; 362460484Sobrien (*info->fprintf_func) (info->stream, "%s", name); 362560484Sobrien return 1; 362633965Sjdp } 362760484Sobrien 3628218822Sdim op = 0; 362933965Sjdp if (*codep == 0x0f) 363033965Sjdp { 3631218822Sdim unsigned char threebyte; 3632223262Sbenl (void) FETCH_DATA (info, codep + 2); 3633218822Sdim threebyte = *++codep; 3634218822Sdim dp = &dis386_twobyte[threebyte]; 363533965Sjdp need_modrm = twobyte_has_modrm[*codep]; 3636218822Sdim uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep]; 3637218822Sdim uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep]; 3638218822Sdim uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep]; 3639218822Sdim uses_LOCK_prefix = (*codep & ~0x02) == 0x20; 3640218822Sdim codep++; 3641218822Sdim if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) 3642218822Sdim { 3643223262Sbenl (void) FETCH_DATA (info, codep + 2); 3644218822Sdim op = *codep++; 3645218822Sdim switch (threebyte) 3646218822Sdim { 3647218822Sdim case 0x38: 3648218822Sdim uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op]; 3649218822Sdim uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op]; 3650218822Sdim uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op]; 3651218822Sdim break; 3652218822Sdim case 0x3a: 3653218822Sdim uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op]; 3654218822Sdim uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op]; 3655218822Sdim uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op]; 3656218822Sdim break; 3657218822Sdim default: 3658218822Sdim break; 3659218822Sdim } 3660218822Sdim } 366133965Sjdp } 366233965Sjdp else 366333965Sjdp { 366485815Sobrien dp = &dis386[*codep]; 366533965Sjdp need_modrm = onebyte_has_modrm[*codep]; 3666218822Sdim uses_DATA_prefix = 0; 3667218822Sdim uses_REPNZ_prefix = 0; 3668218822Sdim /* pause is 0xf3 0x90. */ 3669218822Sdim uses_REPZ_prefix = *codep == 0x90; 3670218822Sdim uses_LOCK_prefix = 0; 3671218822Sdim codep++; 367233965Sjdp } 367333965Sjdp 3674218822Sdim if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ)) 367560484Sobrien { 367660484Sobrien oappend ("repz "); 367760484Sobrien used_prefixes |= PREFIX_REPZ; 367860484Sobrien } 3679218822Sdim if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ)) 368060484Sobrien { 368160484Sobrien oappend ("repnz "); 368260484Sobrien used_prefixes |= PREFIX_REPNZ; 368360484Sobrien } 3684218822Sdim 3685218822Sdim if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK)) 368660484Sobrien { 368760484Sobrien oappend ("lock "); 368860484Sobrien used_prefixes |= PREFIX_LOCK; 368960484Sobrien } 369060484Sobrien 369160484Sobrien if (prefixes & PREFIX_ADDR) 369260484Sobrien { 369360484Sobrien sizeflag ^= AFLAG; 3694218822Sdim if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax) 369578828Sobrien { 3696218822Sdim if ((sizeflag & AFLAG) || address_mode == mode_64bit) 369778828Sobrien oappend ("addr32 "); 369878828Sobrien else 369978828Sobrien oappend ("addr16 "); 370078828Sobrien used_prefixes |= PREFIX_ADDR; 370178828Sobrien } 370260484Sobrien } 370360484Sobrien 3704218822Sdim if (!uses_DATA_prefix && (prefixes & PREFIX_DATA)) 370578828Sobrien { 370678828Sobrien sizeflag ^= DFLAG; 3707218822Sdim if (dp->op[2].bytemode == cond_jump_mode 3708218822Sdim && dp->op[0].bytemode == v_mode 370985815Sobrien && !intel_syntax) 371078828Sobrien { 371178828Sobrien if (sizeflag & DFLAG) 371278828Sobrien oappend ("data32 "); 371378828Sobrien else 371478828Sobrien oappend ("data16 "); 371578828Sobrien used_prefixes |= PREFIX_DATA; 371678828Sobrien } 371778828Sobrien } 371878828Sobrien 3719218822Sdim if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE) 372033965Sjdp { 3721218822Sdim dp = &three_byte_table[dp->op[1].bytemode][op]; 3722218822Sdim modrm.mod = (*codep >> 6) & 3; 3723218822Sdim modrm.reg = (*codep >> 3) & 7; 3724218822Sdim modrm.rm = *codep & 7; 3725218822Sdim } 3726218822Sdim else if (need_modrm) 3727218822Sdim { 3728223262Sbenl (void) FETCH_DATA (info, codep + 1); 3729218822Sdim modrm.mod = (*codep >> 6) & 3; 3730218822Sdim modrm.reg = (*codep >> 3) & 7; 3731218822Sdim modrm.rm = *codep & 7; 373233965Sjdp } 373333965Sjdp 3734218822Sdim if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE) 373533965Sjdp { 373660484Sobrien dofloat (sizeflag); 373733965Sjdp } 373833965Sjdp else 373933965Sjdp { 374077298Sobrien int index; 374133965Sjdp if (dp->name == NULL) 374260484Sobrien { 3743218822Sdim switch (dp->op[0].bytemode) 374460484Sobrien { 374585815Sobrien case USE_GROUPS: 3746218822Sdim dp = &grps[dp->op[1].bytemode][modrm.reg]; 374785815Sobrien break; 374885815Sobrien 374985815Sobrien case USE_PREFIX_USER_TABLE: 375085815Sobrien index = 0; 375185815Sobrien used_prefixes |= (prefixes & PREFIX_REPZ); 375285815Sobrien if (prefixes & PREFIX_REPZ) 375385815Sobrien index = 1; 375485815Sobrien else 375585815Sobrien { 3756218822Sdim /* We should check PREFIX_REPNZ and PREFIX_REPZ 3757218822Sdim before PREFIX_DATA. */ 3758218822Sdim used_prefixes |= (prefixes & PREFIX_REPNZ); 3759218822Sdim if (prefixes & PREFIX_REPNZ) 3760218822Sdim index = 3; 376185815Sobrien else 376285815Sobrien { 3763218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 3764218822Sdim if (prefixes & PREFIX_DATA) 3765218822Sdim index = 2; 376685815Sobrien } 376785815Sobrien } 3768218822Sdim dp = &prefix_user_table[dp->op[1].bytemode][index]; 376985815Sobrien break; 377085815Sobrien 377185815Sobrien case X86_64_SPECIAL: 3772218822Sdim index = address_mode == mode_64bit ? 1 : 0; 3773218822Sdim dp = &x86_64_table[dp->op[1].bytemode][index]; 377485815Sobrien break; 377585815Sobrien 377685815Sobrien default: 377785815Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 377885815Sobrien break; 377960484Sobrien } 378060484Sobrien } 378160484Sobrien 378285815Sobrien if (putop (dp->name, sizeflag) == 0) 3783218822Sdim { 3784218822Sdim for (i = 0; i < MAX_OPERANDS; ++i) 3785218822Sdim { 3786218822Sdim obufp = op_out[i]; 3787218822Sdim op_ad = MAX_OPERANDS - 1 - i; 3788218822Sdim if (dp->op[i].rtn) 3789218822Sdim (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag); 3790218822Sdim } 379185815Sobrien } 379233965Sjdp } 379360484Sobrien 379460484Sobrien /* See if any prefixes were not used. If so, print the first one 379560484Sobrien separately. If we don't do this, we'll wind up printing an 379660484Sobrien instruction stream which does not precisely correspond to the 379760484Sobrien bytes we are disassembling. */ 379860484Sobrien if ((prefixes & ~used_prefixes) != 0) 379960484Sobrien { 380060484Sobrien const char *name; 380160484Sobrien 380289857Sobrien name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 380360484Sobrien if (name == NULL) 380460484Sobrien name = INTERNAL_DISASSEMBLER_ERROR; 380560484Sobrien (*info->fprintf_func) (info->stream, "%s", name); 380660484Sobrien return 1; 380760484Sobrien } 380877298Sobrien if (rex & ~rex_used) 380977298Sobrien { 381077298Sobrien const char *name; 381189857Sobrien name = prefix_name (rex | 0x40, priv.orig_sizeflag); 381277298Sobrien if (name == NULL) 381377298Sobrien name = INTERNAL_DISASSEMBLER_ERROR; 381477298Sobrien (*info->fprintf_func) (info->stream, "%s ", name); 381577298Sobrien } 381660484Sobrien 381733965Sjdp obufp = obuf + strlen (obuf); 381833965Sjdp for (i = strlen (obuf); i < 6; i++) 381933965Sjdp oappend (" "); 382033965Sjdp oappend (" "); 382133965Sjdp (*info->fprintf_func) (info->stream, "%s", obuf); 382260484Sobrien 382360484Sobrien /* The enter and bound instructions are printed with operands in the same 382460484Sobrien order as the intel book; everything else is printed in reverse order. */ 382560484Sobrien if (intel_syntax || two_source_ops) 382633965Sjdp { 3827218822Sdim bfd_vma riprel; 3828218822Sdim 3829218822Sdim for (i = 0; i < MAX_OPERANDS; ++i) 3830218822Sdim op_txt[i] = op_out[i]; 3831218822Sdim 3832218822Sdim for (i = 0; i < (MAX_OPERANDS >> 1); ++i) 3833218822Sdim { 3834218822Sdim op_ad = op_index[i]; 3835218822Sdim op_index[i] = op_index[MAX_OPERANDS - 1 - i]; 3836218822Sdim op_index[MAX_OPERANDS - 1 - i] = op_ad; 3837218822Sdim riprel = op_riprel[i]; 3838218822Sdim op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i]; 3839218822Sdim op_riprel[MAX_OPERANDS - 1 - i] = riprel; 3840218822Sdim } 384133965Sjdp } 384233965Sjdp else 384333965Sjdp { 3844218822Sdim for (i = 0; i < MAX_OPERANDS; ++i) 3845218822Sdim op_txt[MAX_OPERANDS - 1 - i] = op_out[i]; 384633965Sjdp } 3847218822Sdim 384833965Sjdp needcomma = 0; 3849218822Sdim for (i = 0; i < MAX_OPERANDS; ++i) 3850218822Sdim if (*op_txt[i]) 3851218822Sdim { 3852218822Sdim if (needcomma) 3853218822Sdim (*info->fprintf_func) (info->stream, ","); 3854218822Sdim if (op_index[i] != -1 && !op_riprel[i]) 3855218822Sdim (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info); 3856218822Sdim else 3857218822Sdim (*info->fprintf_func) (info->stream, "%s", op_txt[i]); 3858218822Sdim needcomma = 1; 3859218822Sdim } 3860218822Sdim 3861218822Sdim for (i = 0; i < MAX_OPERANDS; i++) 386277298Sobrien if (op_index[i] != -1 && op_riprel[i]) 386377298Sobrien { 386477298Sobrien (*info->fprintf_func) (info->stream, " # "); 386577298Sobrien (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep 386677298Sobrien + op_address[op_index[i]]), info); 3867218822Sdim break; 386877298Sobrien } 386989857Sobrien return codep - priv.the_buffer; 387033965Sjdp} 387133965Sjdp 387285815Sobrienstatic const char *float_mem[] = { 387333965Sjdp /* d8 */ 387485815Sobrien "fadd{s||s|}", 387585815Sobrien "fmul{s||s|}", 387685815Sobrien "fcom{s||s|}", 387785815Sobrien "fcomp{s||s|}", 387885815Sobrien "fsub{s||s|}", 387985815Sobrien "fsubr{s||s|}", 388085815Sobrien "fdiv{s||s|}", 388185815Sobrien "fdivr{s||s|}", 3882130561Sobrien /* d9 */ 388385815Sobrien "fld{s||s|}", 388433965Sjdp "(bad)", 388585815Sobrien "fst{s||s|}", 388685815Sobrien "fstp{s||s|}", 3887218822Sdim "fldenvIC", 388833965Sjdp "fldcw", 3889218822Sdim "fNstenvIC", 389033965Sjdp "fNstcw", 389133965Sjdp /* da */ 389285815Sobrien "fiadd{l||l|}", 389385815Sobrien "fimul{l||l|}", 389485815Sobrien "ficom{l||l|}", 389585815Sobrien "ficomp{l||l|}", 389685815Sobrien "fisub{l||l|}", 389785815Sobrien "fisubr{l||l|}", 389885815Sobrien "fidiv{l||l|}", 389985815Sobrien "fidivr{l||l|}", 390033965Sjdp /* db */ 390185815Sobrien "fild{l||l|}", 3902130561Sobrien "fisttp{l||l|}", 390385815Sobrien "fist{l||l|}", 390485815Sobrien "fistp{l||l|}", 390533965Sjdp "(bad)", 390685815Sobrien "fld{t||t|}", 390733965Sjdp "(bad)", 390885815Sobrien "fstp{t||t|}", 390933965Sjdp /* dc */ 391085815Sobrien "fadd{l||l|}", 391185815Sobrien "fmul{l||l|}", 391285815Sobrien "fcom{l||l|}", 391385815Sobrien "fcomp{l||l|}", 391485815Sobrien "fsub{l||l|}", 391585815Sobrien "fsubr{l||l|}", 391685815Sobrien "fdiv{l||l|}", 391785815Sobrien "fdivr{l||l|}", 391833965Sjdp /* dd */ 391985815Sobrien "fld{l||l|}", 3920218822Sdim "fisttp{ll||ll|}", 392185815Sobrien "fst{l||l|}", 392285815Sobrien "fstp{l||l|}", 3923218822Sdim "frstorIC", 392433965Sjdp "(bad)", 3925218822Sdim "fNsaveIC", 392633965Sjdp "fNstsw", 392733965Sjdp /* de */ 392833965Sjdp "fiadd", 392933965Sjdp "fimul", 393033965Sjdp "ficom", 393133965Sjdp "ficomp", 393233965Sjdp "fisub", 393333965Sjdp "fisubr", 393433965Sjdp "fidiv", 393533965Sjdp "fidivr", 393633965Sjdp /* df */ 393733965Sjdp "fild", 3938130561Sobrien "fisttp", 393933965Sjdp "fist", 394033965Sjdp "fistp", 394133965Sjdp "fbld", 394285815Sobrien "fild{ll||ll|}", 394333965Sjdp "fbstp", 3944218822Sdim "fistp{ll||ll|}", 394533965Sjdp}; 394633965Sjdp 3947218822Sdimstatic const unsigned char float_mem_mode[] = { 3948218822Sdim /* d8 */ 3949218822Sdim d_mode, 3950218822Sdim d_mode, 3951218822Sdim d_mode, 3952218822Sdim d_mode, 3953218822Sdim d_mode, 3954218822Sdim d_mode, 3955218822Sdim d_mode, 3956218822Sdim d_mode, 3957218822Sdim /* d9 */ 3958218822Sdim d_mode, 3959218822Sdim 0, 3960218822Sdim d_mode, 3961218822Sdim d_mode, 3962218822Sdim 0, 3963218822Sdim w_mode, 3964218822Sdim 0, 3965218822Sdim w_mode, 3966218822Sdim /* da */ 3967218822Sdim d_mode, 3968218822Sdim d_mode, 3969218822Sdim d_mode, 3970218822Sdim d_mode, 3971218822Sdim d_mode, 3972218822Sdim d_mode, 3973218822Sdim d_mode, 3974218822Sdim d_mode, 3975218822Sdim /* db */ 3976218822Sdim d_mode, 3977218822Sdim d_mode, 3978218822Sdim d_mode, 3979218822Sdim d_mode, 3980218822Sdim 0, 3981218822Sdim t_mode, 3982218822Sdim 0, 3983218822Sdim t_mode, 3984218822Sdim /* dc */ 3985218822Sdim q_mode, 3986218822Sdim q_mode, 3987218822Sdim q_mode, 3988218822Sdim q_mode, 3989218822Sdim q_mode, 3990218822Sdim q_mode, 3991218822Sdim q_mode, 3992218822Sdim q_mode, 3993218822Sdim /* dd */ 3994218822Sdim q_mode, 3995218822Sdim q_mode, 3996218822Sdim q_mode, 3997218822Sdim q_mode, 3998218822Sdim 0, 3999218822Sdim 0, 4000218822Sdim 0, 4001218822Sdim w_mode, 4002218822Sdim /* de */ 4003218822Sdim w_mode, 4004218822Sdim w_mode, 4005218822Sdim w_mode, 4006218822Sdim w_mode, 4007218822Sdim w_mode, 4008218822Sdim w_mode, 4009218822Sdim w_mode, 4010218822Sdim w_mode, 4011218822Sdim /* df */ 4012218822Sdim w_mode, 4013218822Sdim w_mode, 4014218822Sdim w_mode, 4015218822Sdim w_mode, 4016218822Sdim t_mode, 4017218822Sdim q_mode, 4018218822Sdim t_mode, 4019218822Sdim q_mode 4020218822Sdim}; 402133965Sjdp 4022218822Sdim#define ST { OP_ST, 0 } 4023218822Sdim#define STi { OP_STi, 0 } 402433965Sjdp 4025218822Sdim#define FGRPd9_2 NULL, { { NULL, 0 } } 4026218822Sdim#define FGRPd9_4 NULL, { { NULL, 1 } } 4027218822Sdim#define FGRPd9_5 NULL, { { NULL, 2 } } 4028218822Sdim#define FGRPd9_6 NULL, { { NULL, 3 } } 4029218822Sdim#define FGRPd9_7 NULL, { { NULL, 4 } } 4030218822Sdim#define FGRPda_5 NULL, { { NULL, 5 } } 4031218822Sdim#define FGRPdb_4 NULL, { { NULL, 6 } } 4032218822Sdim#define FGRPde_3 NULL, { { NULL, 7 } } 4033218822Sdim#define FGRPdf_4 NULL, { { NULL, 8 } } 4034218822Sdim 403560484Sobrienstatic const struct dis386 float_reg[][8] = { 403633965Sjdp /* d8 */ 403733965Sjdp { 4038218822Sdim { "fadd", { ST, STi } }, 4039218822Sdim { "fmul", { ST, STi } }, 4040218822Sdim { "fcom", { STi } }, 4041218822Sdim { "fcomp", { STi } }, 4042218822Sdim { "fsub", { ST, STi } }, 4043218822Sdim { "fsubr", { ST, STi } }, 4044218822Sdim { "fdiv", { ST, STi } }, 4045218822Sdim { "fdivr", { ST, STi } }, 404633965Sjdp }, 404733965Sjdp /* d9 */ 404833965Sjdp { 4049218822Sdim { "fld", { STi } }, 4050218822Sdim { "fxch", { STi } }, 405133965Sjdp { FGRPd9_2 }, 4052218822Sdim { "(bad)", { XX } }, 405333965Sjdp { FGRPd9_4 }, 405433965Sjdp { FGRPd9_5 }, 405533965Sjdp { FGRPd9_6 }, 405633965Sjdp { FGRPd9_7 }, 405733965Sjdp }, 405833965Sjdp /* da */ 405933965Sjdp { 4060218822Sdim { "fcmovb", { ST, STi } }, 4061218822Sdim { "fcmove", { ST, STi } }, 4062218822Sdim { "fcmovbe",{ ST, STi } }, 4063218822Sdim { "fcmovu", { ST, STi } }, 4064218822Sdim { "(bad)", { XX } }, 406533965Sjdp { FGRPda_5 }, 4066218822Sdim { "(bad)", { XX } }, 4067218822Sdim { "(bad)", { XX } }, 406833965Sjdp }, 406933965Sjdp /* db */ 407033965Sjdp { 4071218822Sdim { "fcmovnb",{ ST, STi } }, 4072218822Sdim { "fcmovne",{ ST, STi } }, 4073218822Sdim { "fcmovnbe",{ ST, STi } }, 4074218822Sdim { "fcmovnu",{ ST, STi } }, 407533965Sjdp { FGRPdb_4 }, 4076218822Sdim { "fucomi", { ST, STi } }, 4077218822Sdim { "fcomi", { ST, STi } }, 4078218822Sdim { "(bad)", { XX } }, 407933965Sjdp }, 408033965Sjdp /* dc */ 408133965Sjdp { 4082218822Sdim { "fadd", { STi, ST } }, 4083218822Sdim { "fmul", { STi, ST } }, 4084218822Sdim { "(bad)", { XX } }, 4085218822Sdim { "(bad)", { XX } }, 4086218822Sdim#if SYSV386_COMPAT 4087218822Sdim { "fsub", { STi, ST } }, 4088218822Sdim { "fsubr", { STi, ST } }, 4089218822Sdim { "fdiv", { STi, ST } }, 4090218822Sdim { "fdivr", { STi, ST } }, 409160484Sobrien#else 4092218822Sdim { "fsubr", { STi, ST } }, 4093218822Sdim { "fsub", { STi, ST } }, 4094218822Sdim { "fdivr", { STi, ST } }, 4095218822Sdim { "fdiv", { STi, ST } }, 409660484Sobrien#endif 409733965Sjdp }, 409833965Sjdp /* dd */ 409933965Sjdp { 4100218822Sdim { "ffree", { STi } }, 4101218822Sdim { "(bad)", { XX } }, 4102218822Sdim { "fst", { STi } }, 4103218822Sdim { "fstp", { STi } }, 4104218822Sdim { "fucom", { STi } }, 4105218822Sdim { "fucomp", { STi } }, 4106218822Sdim { "(bad)", { XX } }, 4107218822Sdim { "(bad)", { XX } }, 410833965Sjdp }, 410933965Sjdp /* de */ 411033965Sjdp { 4111218822Sdim { "faddp", { STi, ST } }, 4112218822Sdim { "fmulp", { STi, ST } }, 4113218822Sdim { "(bad)", { XX } }, 411433965Sjdp { FGRPde_3 }, 4115218822Sdim#if SYSV386_COMPAT 4116218822Sdim { "fsubp", { STi, ST } }, 4117218822Sdim { "fsubrp", { STi, ST } }, 4118218822Sdim { "fdivp", { STi, ST } }, 4119218822Sdim { "fdivrp", { STi, ST } }, 412060484Sobrien#else 4121218822Sdim { "fsubrp", { STi, ST } }, 4122218822Sdim { "fsubp", { STi, ST } }, 4123218822Sdim { "fdivrp", { STi, ST } }, 4124218822Sdim { "fdivp", { STi, ST } }, 412560484Sobrien#endif 412633965Sjdp }, 412733965Sjdp /* df */ 412833965Sjdp { 4129218822Sdim { "ffreep", { STi } }, 4130218822Sdim { "(bad)", { XX } }, 4131218822Sdim { "(bad)", { XX } }, 4132218822Sdim { "(bad)", { XX } }, 413333965Sjdp { FGRPdf_4 }, 4134218822Sdim { "fucomip", { ST, STi } }, 4135218822Sdim { "fcomip", { ST, STi } }, 4136218822Sdim { "(bad)", { XX } }, 413733965Sjdp }, 413833965Sjdp}; 413933965Sjdp 414033965Sjdpstatic char *fgrps[][8] = { 414133965Sjdp /* d9_2 0 */ 414233965Sjdp { 414333965Sjdp "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 414433965Sjdp }, 414533965Sjdp 414633965Sjdp /* d9_4 1 */ 414733965Sjdp { 414833965Sjdp "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", 414933965Sjdp }, 415033965Sjdp 415133965Sjdp /* d9_5 2 */ 415233965Sjdp { 415333965Sjdp "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", 415433965Sjdp }, 415533965Sjdp 415633965Sjdp /* d9_6 3 */ 415733965Sjdp { 415833965Sjdp "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", 415933965Sjdp }, 416033965Sjdp 416133965Sjdp /* d9_7 4 */ 416233965Sjdp { 416333965Sjdp "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", 416433965Sjdp }, 416533965Sjdp 416633965Sjdp /* da_5 5 */ 416733965Sjdp { 416833965Sjdp "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 416933965Sjdp }, 417033965Sjdp 417133965Sjdp /* db_4 6 */ 417233965Sjdp { 417333965Sjdp "feni(287 only)","fdisi(287 only)","fNclex","fNinit", 417433965Sjdp "fNsetpm(287 only)","(bad)","(bad)","(bad)", 417533965Sjdp }, 417633965Sjdp 417733965Sjdp /* de_3 7 */ 417833965Sjdp { 417933965Sjdp "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 418033965Sjdp }, 418133965Sjdp 418233965Sjdp /* df_4 8 */ 418333965Sjdp { 418433965Sjdp "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", 418533965Sjdp }, 418633965Sjdp}; 418733965Sjdp 418833965Sjdpstatic void 4189130561Sobriendofloat (int sizeflag) 419033965Sjdp{ 419160484Sobrien const struct dis386 *dp; 419233965Sjdp unsigned char floatop; 419360484Sobrien 419433965Sjdp floatop = codep[-1]; 419560484Sobrien 4196218822Sdim if (modrm.mod != 3) 419733965Sjdp { 4198218822Sdim int fp_indx = (floatop - 0xd8) * 8 + modrm.reg; 4199218822Sdim 4200218822Sdim putop (float_mem[fp_indx], sizeflag); 4201218822Sdim obufp = op_out[0]; 4202218822Sdim op_ad = 2; 4203218822Sdim OP_E (float_mem_mode[fp_indx], sizeflag); 420433965Sjdp return; 420533965Sjdp } 420685815Sobrien /* Skip mod/rm byte. */ 420778828Sobrien MODRM_CHECK; 420833965Sjdp codep++; 420960484Sobrien 4210218822Sdim dp = &float_reg[floatop - 0xd8][modrm.reg]; 421133965Sjdp if (dp->name == NULL) 421233965Sjdp { 4213218822Sdim putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag); 421460484Sobrien 421585815Sobrien /* Instruction fnstsw is only one with strange arg. */ 421660484Sobrien if (floatop == 0xdf && codep[-1] == 0xe0) 4217218822Sdim strcpy (op_out[0], names16[0]); 421833965Sjdp } 421933965Sjdp else 422033965Sjdp { 422160484Sobrien putop (dp->name, sizeflag); 422260484Sobrien 4223218822Sdim obufp = op_out[0]; 4224218822Sdim op_ad = 2; 4225218822Sdim if (dp->op[0].rtn) 4226218822Sdim (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag); 4227218822Sdim 4228218822Sdim obufp = op_out[1]; 4229218822Sdim op_ad = 1; 4230218822Sdim if (dp->op[1].rtn) 4231218822Sdim (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag); 423233965Sjdp } 423333965Sjdp} 423433965Sjdp 423560484Sobrienstatic void 4236130561SobrienOP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 423733965Sjdp{ 4238218822Sdim oappend ("%st" + intel_syntax); 423933965Sjdp} 424033965Sjdp 424160484Sobrienstatic void 4242130561SobrienOP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 424333965Sjdp{ 4244218822Sdim sprintf (scratchbuf, "%%st(%d)", modrm.rm); 424585815Sobrien oappend (scratchbuf + intel_syntax); 424633965Sjdp} 424733965Sjdp 424885815Sobrien/* Capital letters in template are macros. */ 424985815Sobrienstatic int 4250130561Sobrienputop (const char *template, int sizeflag) 425133965Sjdp{ 425260484Sobrien const char *p; 4253218822Sdim int alt = 0; 425460484Sobrien 425533965Sjdp for (p = template; *p; p++) 425633965Sjdp { 425733965Sjdp switch (*p) 425833965Sjdp { 425933965Sjdp default: 426033965Sjdp *obufp++ = *p; 426133965Sjdp break; 426285815Sobrien case '{': 426385815Sobrien alt = 0; 426485815Sobrien if (intel_syntax) 426585815Sobrien alt += 1; 4266218822Sdim if (address_mode == mode_64bit) 426785815Sobrien alt += 2; 426885815Sobrien while (alt != 0) 426985815Sobrien { 427085815Sobrien while (*++p != '|') 427185815Sobrien { 427285815Sobrien if (*p == '}') 427385815Sobrien { 427485815Sobrien /* Alternative not valid. */ 427585815Sobrien strcpy (obuf, "(bad)"); 427685815Sobrien obufp = obuf + 5; 427785815Sobrien return 1; 427885815Sobrien } 427985815Sobrien else if (*p == '\0') 428085815Sobrien abort (); 428185815Sobrien } 428285815Sobrien alt--; 428385815Sobrien } 4284218822Sdim /* Fall through. */ 4285218822Sdim case 'I': 4286218822Sdim alt = 1; 4287218822Sdim continue; 428885815Sobrien case '|': 428985815Sobrien while (*++p != '}') 429085815Sobrien { 429185815Sobrien if (*p == '\0') 429285815Sobrien abort (); 429385815Sobrien } 429485815Sobrien break; 429585815Sobrien case '}': 429685815Sobrien break; 429760484Sobrien case 'A': 4298130561Sobrien if (intel_syntax) 4299130561Sobrien break; 4300218822Sdim if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 430160484Sobrien *obufp++ = 'b'; 430260484Sobrien break; 430360484Sobrien case 'B': 4304130561Sobrien if (intel_syntax) 4305130561Sobrien break; 430660484Sobrien if (sizeflag & SUFFIX_ALWAYS) 430760484Sobrien *obufp++ = 'b'; 430860484Sobrien break; 4309218822Sdim case 'C': 4310218822Sdim if (intel_syntax && !alt) 4311218822Sdim break; 4312218822Sdim if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS)) 4313218822Sdim { 4314218822Sdim if (sizeflag & DFLAG) 4315218822Sdim *obufp++ = intel_syntax ? 'd' : 'l'; 4316218822Sdim else 4317218822Sdim *obufp++ = intel_syntax ? 'w' : 's'; 4318218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4319218822Sdim } 4320218822Sdim break; 4321218822Sdim case 'D': 4322218822Sdim if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS)) 4323218822Sdim break; 4324218822Sdim USED_REX (REX_W); 4325218822Sdim if (modrm.mod == 3) 4326218822Sdim { 4327218822Sdim if (rex & REX_W) 4328218822Sdim *obufp++ = 'q'; 4329218822Sdim else if (sizeflag & DFLAG) 4330218822Sdim *obufp++ = intel_syntax ? 'd' : 'l'; 4331218822Sdim else 4332218822Sdim *obufp++ = 'w'; 4333218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4334218822Sdim } 4335218822Sdim else 4336218822Sdim *obufp++ = 'w'; 4337218822Sdim break; 433860484Sobrien case 'E': /* For jcxz/jecxz */ 4339218822Sdim if (address_mode == mode_64bit) 434092828Sobrien { 434192828Sobrien if (sizeflag & AFLAG) 434292828Sobrien *obufp++ = 'r'; 434392828Sobrien else 434492828Sobrien *obufp++ = 'e'; 434592828Sobrien } 434692828Sobrien else 434792828Sobrien if (sizeflag & AFLAG) 434892828Sobrien *obufp++ = 'e'; 434978828Sobrien used_prefixes |= (prefixes & PREFIX_ADDR); 435033965Sjdp break; 435178828Sobrien case 'F': 4352130561Sobrien if (intel_syntax) 4353130561Sobrien break; 435489857Sobrien if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) 435578828Sobrien { 435678828Sobrien if (sizeflag & AFLAG) 4357218822Sdim *obufp++ = address_mode == mode_64bit ? 'q' : 'l'; 435878828Sobrien else 4359218822Sdim *obufp++ = address_mode == mode_64bit ? 'l' : 'w'; 436078828Sobrien used_prefixes |= (prefixes & PREFIX_ADDR); 436178828Sobrien } 436278828Sobrien break; 4363218822Sdim case 'G': 4364218822Sdim if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS))) 4365218822Sdim break; 4366218822Sdim if ((rex & REX_W) || (sizeflag & DFLAG)) 4367218822Sdim *obufp++ = 'l'; 4368218822Sdim else 4369218822Sdim *obufp++ = 'w'; 4370218822Sdim if (!(rex & REX_W)) 4371218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4372218822Sdim break; 437385815Sobrien case 'H': 4374130561Sobrien if (intel_syntax) 4375130561Sobrien break; 437685815Sobrien if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS 437785815Sobrien || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) 437877298Sobrien { 437985815Sobrien used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS); 438085815Sobrien *obufp++ = ','; 438185815Sobrien *obufp++ = 'p'; 438285815Sobrien if (prefixes & PREFIX_DS) 438385815Sobrien *obufp++ = 't'; 438485815Sobrien else 438585815Sobrien *obufp++ = 'n'; 438677298Sobrien } 438777298Sobrien break; 4388218822Sdim case 'J': 4389218822Sdim if (intel_syntax) 4390218822Sdim break; 4391218822Sdim *obufp++ = 'l'; 4392218822Sdim break; 4393218822Sdim case 'K': 4394218822Sdim USED_REX (REX_W); 4395218822Sdim if (rex & REX_W) 4396218822Sdim *obufp++ = 'q'; 4397218822Sdim else 4398218822Sdim *obufp++ = 'd'; 4399218822Sdim break; 4400218822Sdim case 'Z': 4401218822Sdim if (intel_syntax) 4402218822Sdim break; 4403218822Sdim if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS)) 4404218822Sdim { 4405218822Sdim *obufp++ = 'q'; 4406218822Sdim break; 4407218822Sdim } 4408218822Sdim /* Fall through. */ 440960484Sobrien case 'L': 4410130561Sobrien if (intel_syntax) 4411130561Sobrien break; 441260484Sobrien if (sizeflag & SUFFIX_ALWAYS) 441360484Sobrien *obufp++ = 'l'; 441460484Sobrien break; 441533965Sjdp case 'N': 441633965Sjdp if ((prefixes & PREFIX_FWAIT) == 0) 441733965Sjdp *obufp++ = 'n'; 441860484Sobrien else 441960484Sobrien used_prefixes |= PREFIX_FWAIT; 442033965Sjdp break; 442177298Sobrien case 'O': 4422218822Sdim USED_REX (REX_W); 4423218822Sdim if (rex & REX_W) 442485815Sobrien *obufp++ = 'o'; 4425218822Sdim else if (intel_syntax && (sizeflag & DFLAG)) 4426218822Sdim *obufp++ = 'q'; 442777298Sobrien else 442877298Sobrien *obufp++ = 'd'; 4429218822Sdim if (!(rex & REX_W)) 4430218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 443177298Sobrien break; 443285815Sobrien case 'T': 4433130561Sobrien if (intel_syntax) 4434130561Sobrien break; 4435218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 443685815Sobrien { 443785815Sobrien *obufp++ = 'q'; 443885815Sobrien break; 443985815Sobrien } 444085815Sobrien /* Fall through. */ 444160484Sobrien case 'P': 4442130561Sobrien if (intel_syntax) 4443130561Sobrien break; 444460484Sobrien if ((prefixes & PREFIX_DATA) 4445218822Sdim || (rex & REX_W) 444689857Sobrien || (sizeflag & SUFFIX_ALWAYS)) 444760484Sobrien { 4448218822Sdim USED_REX (REX_W); 4449218822Sdim if (rex & REX_W) 445077298Sobrien *obufp++ = 'q'; 445178828Sobrien else 445277298Sobrien { 445377298Sobrien if (sizeflag & DFLAG) 445477298Sobrien *obufp++ = 'l'; 445577298Sobrien else 445677298Sobrien *obufp++ = 'w'; 445777298Sobrien } 4458218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 445960484Sobrien } 446060484Sobrien break; 446185815Sobrien case 'U': 4462130561Sobrien if (intel_syntax) 4463130561Sobrien break; 4464218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 446585815Sobrien { 4466218822Sdim if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 4467218822Sdim *obufp++ = 'q'; 446885815Sobrien break; 446985815Sobrien } 447085815Sobrien /* Fall through. */ 447160484Sobrien case 'Q': 4472218822Sdim if (intel_syntax && !alt) 4473130561Sobrien break; 4474218822Sdim USED_REX (REX_W); 4475218822Sdim if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 447660484Sobrien { 4477218822Sdim if (rex & REX_W) 447877298Sobrien *obufp++ = 'q'; 447960484Sobrien else 448077298Sobrien { 448177298Sobrien if (sizeflag & DFLAG) 4482218822Sdim *obufp++ = intel_syntax ? 'd' : 'l'; 448377298Sobrien else 448477298Sobrien *obufp++ = 'w'; 448577298Sobrien } 4486218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 448760484Sobrien } 448860484Sobrien break; 448960484Sobrien case 'R': 4490218822Sdim USED_REX (REX_W); 4491218822Sdim if (rex & REX_W) 4492218822Sdim *obufp++ = 'q'; 4493218822Sdim else if (sizeflag & DFLAG) 449460484Sobrien { 4495218822Sdim if (intel_syntax) 449660484Sobrien *obufp++ = 'd'; 449760484Sobrien else 4498218822Sdim *obufp++ = 'l'; 449960484Sobrien } 450033965Sjdp else 4501218822Sdim *obufp++ = 'w'; 4502218822Sdim if (intel_syntax && !p[1] 4503218822Sdim && ((rex & REX_W) || (sizeflag & DFLAG))) 4504218822Sdim *obufp++ = 'e'; 4505218822Sdim if (!(rex & REX_W)) 4506218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4507218822Sdim break; 4508218822Sdim case 'V': 4509218822Sdim if (intel_syntax) 4510218822Sdim break; 4511218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 451260484Sobrien { 4513218822Sdim if (sizeflag & SUFFIX_ALWAYS) 451477298Sobrien *obufp++ = 'q'; 4515218822Sdim break; 451660484Sobrien } 4517218822Sdim /* Fall through. */ 451860484Sobrien case 'S': 4519130561Sobrien if (intel_syntax) 4520130561Sobrien break; 452160484Sobrien if (sizeflag & SUFFIX_ALWAYS) 452260484Sobrien { 4523218822Sdim if (rex & REX_W) 452477298Sobrien *obufp++ = 'q'; 452577298Sobrien else 452677298Sobrien { 452777298Sobrien if (sizeflag & DFLAG) 452877298Sobrien *obufp++ = 'l'; 452977298Sobrien else 453077298Sobrien *obufp++ = 'w'; 453177298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 453277298Sobrien } 453377298Sobrien } 453477298Sobrien break; 453577298Sobrien case 'X': 453677298Sobrien if (prefixes & PREFIX_DATA) 453777298Sobrien *obufp++ = 'd'; 453877298Sobrien else 453977298Sobrien *obufp++ = 's'; 4540130561Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 454177298Sobrien break; 454277298Sobrien case 'Y': 4543130561Sobrien if (intel_syntax) 4544130561Sobrien break; 4545218822Sdim if (rex & REX_W) 454677298Sobrien { 4547218822Sdim USED_REX (REX_W); 454877298Sobrien *obufp++ = 'q'; 454977298Sobrien } 455077298Sobrien break; 455177298Sobrien /* implicit operand size 'l' for i386 or 'q' for x86-64 */ 455238889Sjdp case 'W': 455338889Sjdp /* operand size flag for cwtl, cbtw */ 4554218822Sdim USED_REX (REX_W); 4555218822Sdim if (rex & REX_W) 4556218822Sdim { 4557218822Sdim if (intel_syntax) 4558218822Sdim *obufp++ = 'd'; 4559218822Sdim else 4560218822Sdim *obufp++ = 'l'; 4561218822Sdim } 456277298Sobrien else if (sizeflag & DFLAG) 456338889Sjdp *obufp++ = 'w'; 456438889Sjdp else 456538889Sjdp *obufp++ = 'b'; 4566218822Sdim if (!(rex & REX_W)) 456777298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 456838889Sjdp break; 456933965Sjdp } 4570218822Sdim alt = 0; 457133965Sjdp } 457233965Sjdp *obufp = 0; 457385815Sobrien return 0; 457433965Sjdp} 457533965Sjdp 457633965Sjdpstatic void 4577130561Sobrienoappend (const char *s) 457833965Sjdp{ 457933965Sjdp strcpy (obufp, s); 458033965Sjdp obufp += strlen (s); 458133965Sjdp} 458233965Sjdp 458333965Sjdpstatic void 4584130561Sobrienappend_seg (void) 458533965Sjdp{ 458633965Sjdp if (prefixes & PREFIX_CS) 458760484Sobrien { 458860484Sobrien used_prefixes |= PREFIX_CS; 458985815Sobrien oappend ("%cs:" + intel_syntax); 459060484Sobrien } 459133965Sjdp if (prefixes & PREFIX_DS) 459260484Sobrien { 459360484Sobrien used_prefixes |= PREFIX_DS; 459485815Sobrien oappend ("%ds:" + intel_syntax); 459560484Sobrien } 459633965Sjdp if (prefixes & PREFIX_SS) 459760484Sobrien { 459860484Sobrien used_prefixes |= PREFIX_SS; 459985815Sobrien oappend ("%ss:" + intel_syntax); 460060484Sobrien } 460133965Sjdp if (prefixes & PREFIX_ES) 460260484Sobrien { 460360484Sobrien used_prefixes |= PREFIX_ES; 460485815Sobrien oappend ("%es:" + intel_syntax); 460560484Sobrien } 460633965Sjdp if (prefixes & PREFIX_FS) 460760484Sobrien { 460860484Sobrien used_prefixes |= PREFIX_FS; 460985815Sobrien oappend ("%fs:" + intel_syntax); 461060484Sobrien } 461133965Sjdp if (prefixes & PREFIX_GS) 461260484Sobrien { 461360484Sobrien used_prefixes |= PREFIX_GS; 461485815Sobrien oappend ("%gs:" + intel_syntax); 461560484Sobrien } 461633965Sjdp} 461733965Sjdp 461860484Sobrienstatic void 4619130561SobrienOP_indirE (int bytemode, int sizeflag) 462033965Sjdp{ 462160484Sobrien if (!intel_syntax) 462260484Sobrien oappend ("*"); 462360484Sobrien OP_E (bytemode, sizeflag); 462433965Sjdp} 462533965Sjdp 462660484Sobrienstatic void 4627130561Sobrienprint_operand_value (char *buf, int hex, bfd_vma disp) 462877298Sobrien{ 4629218822Sdim if (address_mode == mode_64bit) 463077298Sobrien { 463177298Sobrien if (hex) 463277298Sobrien { 463377298Sobrien char tmp[30]; 463477298Sobrien int i; 463577298Sobrien buf[0] = '0'; 463677298Sobrien buf[1] = 'x'; 463777298Sobrien sprintf_vma (tmp, disp); 463885815Sobrien for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++); 463977298Sobrien strcpy (buf + 2, tmp + i); 464077298Sobrien } 464177298Sobrien else 464277298Sobrien { 464377298Sobrien bfd_signed_vma v = disp; 464477298Sobrien char tmp[30]; 464577298Sobrien int i; 464677298Sobrien if (v < 0) 464777298Sobrien { 464877298Sobrien *(buf++) = '-'; 464977298Sobrien v = -disp; 465085815Sobrien /* Check for possible overflow on 0x8000000000000000. */ 465177298Sobrien if (v < 0) 465277298Sobrien { 465377298Sobrien strcpy (buf, "9223372036854775808"); 465477298Sobrien return; 465577298Sobrien } 465677298Sobrien } 465777298Sobrien if (!v) 465877298Sobrien { 465977298Sobrien strcpy (buf, "0"); 466077298Sobrien return; 466177298Sobrien } 466277298Sobrien 466377298Sobrien i = 0; 466477298Sobrien tmp[29] = 0; 466577298Sobrien while (v) 466677298Sobrien { 466785815Sobrien tmp[28 - i] = (v % 10) + '0'; 466877298Sobrien v /= 10; 466977298Sobrien i++; 467077298Sobrien } 467177298Sobrien strcpy (buf, tmp + 29 - i); 467277298Sobrien } 467377298Sobrien } 467477298Sobrien else 467577298Sobrien { 467677298Sobrien if (hex) 467777298Sobrien sprintf (buf, "0x%x", (unsigned int) disp); 467877298Sobrien else 467977298Sobrien sprintf (buf, "%d", (int) disp); 468077298Sobrien } 468177298Sobrien} 468277298Sobrien 4683218822Sdim/* Put DISP in BUF as signed hex number. */ 4684218822Sdim 468577298Sobrienstatic void 4686218822Sdimprint_displacement (char *buf, bfd_vma disp) 4687218822Sdim{ 4688218822Sdim bfd_signed_vma val = disp; 4689218822Sdim char tmp[30]; 4690218822Sdim int i, j = 0; 4691218822Sdim 4692218822Sdim if (val < 0) 4693218822Sdim { 4694218822Sdim buf[j++] = '-'; 4695218822Sdim val = -disp; 4696218822Sdim 4697218822Sdim /* Check for possible overflow. */ 4698218822Sdim if (val < 0) 4699218822Sdim { 4700218822Sdim switch (address_mode) 4701218822Sdim { 4702218822Sdim case mode_64bit: 4703218822Sdim strcpy (buf + j, "0x8000000000000000"); 4704218822Sdim break; 4705218822Sdim case mode_32bit: 4706218822Sdim strcpy (buf + j, "0x80000000"); 4707218822Sdim break; 4708218822Sdim case mode_16bit: 4709218822Sdim strcpy (buf + j, "0x8000"); 4710218822Sdim break; 4711218822Sdim } 4712218822Sdim return; 4713218822Sdim } 4714218822Sdim } 4715218822Sdim 4716218822Sdim buf[j++] = '0'; 4717218822Sdim buf[j++] = 'x'; 4718218822Sdim 4719218822Sdim sprintf_vma (tmp, val); 4720218822Sdim for (i = 0; tmp[i] == '0'; i++) 4721218822Sdim continue; 4722218822Sdim if (tmp[i] == '\0') 4723218822Sdim i--; 4724218822Sdim strcpy (buf + j, tmp + i); 4725218822Sdim} 4726218822Sdim 4727218822Sdimstatic void 4728218822Sdimintel_operand_size (int bytemode, int sizeflag) 4729218822Sdim{ 4730218822Sdim switch (bytemode) 4731218822Sdim { 4732218822Sdim case b_mode: 4733218822Sdim case dqb_mode: 4734218822Sdim oappend ("BYTE PTR "); 4735218822Sdim break; 4736218822Sdim case w_mode: 4737218822Sdim case dqw_mode: 4738218822Sdim oappend ("WORD PTR "); 4739218822Sdim break; 4740218822Sdim case stack_v_mode: 4741218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4742218822Sdim { 4743218822Sdim oappend ("QWORD PTR "); 4744218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4745218822Sdim break; 4746218822Sdim } 4747218822Sdim /* FALLTHRU */ 4748218822Sdim case v_mode: 4749218822Sdim case dq_mode: 4750218822Sdim USED_REX (REX_W); 4751218822Sdim if (rex & REX_W) 4752218822Sdim oappend ("QWORD PTR "); 4753218822Sdim else if ((sizeflag & DFLAG) || bytemode == dq_mode) 4754218822Sdim oappend ("DWORD PTR "); 4755218822Sdim else 4756218822Sdim oappend ("WORD PTR "); 4757218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4758218822Sdim break; 4759218822Sdim case z_mode: 4760218822Sdim if ((rex & REX_W) || (sizeflag & DFLAG)) 4761218822Sdim *obufp++ = 'D'; 4762218822Sdim oappend ("WORD PTR "); 4763218822Sdim if (!(rex & REX_W)) 4764218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4765218822Sdim break; 4766218822Sdim case d_mode: 4767218822Sdim case dqd_mode: 4768218822Sdim oappend ("DWORD PTR "); 4769218822Sdim break; 4770218822Sdim case q_mode: 4771218822Sdim oappend ("QWORD PTR "); 4772218822Sdim break; 4773218822Sdim case m_mode: 4774218822Sdim if (address_mode == mode_64bit) 4775218822Sdim oappend ("QWORD PTR "); 4776218822Sdim else 4777218822Sdim oappend ("DWORD PTR "); 4778218822Sdim break; 4779218822Sdim case f_mode: 4780218822Sdim if (sizeflag & DFLAG) 4781218822Sdim oappend ("FWORD PTR "); 4782218822Sdim else 4783218822Sdim oappend ("DWORD PTR "); 4784218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4785218822Sdim break; 4786218822Sdim case t_mode: 4787218822Sdim oappend ("TBYTE PTR "); 4788218822Sdim break; 4789218822Sdim case x_mode: 4790218822Sdim oappend ("XMMWORD PTR "); 4791218822Sdim break; 4792218822Sdim case o_mode: 4793218822Sdim oappend ("OWORD PTR "); 4794218822Sdim break; 4795218822Sdim default: 4796218822Sdim break; 4797218822Sdim } 4798218822Sdim} 4799218822Sdim 4800218822Sdimstatic void 4801130561SobrienOP_E (int bytemode, int sizeflag) 480233965Sjdp{ 480377298Sobrien bfd_vma disp; 480477298Sobrien int add = 0; 480577298Sobrien int riprel = 0; 4806218822Sdim USED_REX (REX_B); 4807218822Sdim if (rex & REX_B) 480877298Sobrien add += 8; 480933965Sjdp 481085815Sobrien /* Skip mod/rm byte. */ 481178828Sobrien MODRM_CHECK; 481233965Sjdp codep++; 481333965Sjdp 4814218822Sdim if (modrm.mod == 3) 481533965Sjdp { 481633965Sjdp switch (bytemode) 481733965Sjdp { 481833965Sjdp case b_mode: 481977298Sobrien USED_REX (0); 482077298Sobrien if (rex) 4821218822Sdim oappend (names8rex[modrm.rm + add]); 482277298Sobrien else 4823218822Sdim oappend (names8[modrm.rm + add]); 482433965Sjdp break; 482533965Sjdp case w_mode: 4826218822Sdim oappend (names16[modrm.rm + add]); 482733965Sjdp break; 482860484Sobrien case d_mode: 4829218822Sdim oappend (names32[modrm.rm + add]); 483060484Sobrien break; 483177298Sobrien case q_mode: 4832218822Sdim oappend (names64[modrm.rm + add]); 483377298Sobrien break; 483477298Sobrien case m_mode: 4835218822Sdim if (address_mode == mode_64bit) 4836218822Sdim oappend (names64[modrm.rm + add]); 483777298Sobrien else 4838218822Sdim oappend (names32[modrm.rm + add]); 483977298Sobrien break; 4840218822Sdim case stack_v_mode: 4841218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 4842218822Sdim { 4843218822Sdim oappend (names64[modrm.rm + add]); 4844218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 4845218822Sdim break; 4846218822Sdim } 4847218822Sdim bytemode = v_mode; 4848218822Sdim /* FALLTHRU */ 484933965Sjdp case v_mode: 4850130561Sobrien case dq_mode: 4851218822Sdim case dqb_mode: 4852218822Sdim case dqd_mode: 4853218822Sdim case dqw_mode: 4854218822Sdim USED_REX (REX_W); 4855218822Sdim if (rex & REX_W) 4856218822Sdim oappend (names64[modrm.rm + add]); 4857218822Sdim else if ((sizeflag & DFLAG) || bytemode != v_mode) 4858218822Sdim oappend (names32[modrm.rm + add]); 485933965Sjdp else 4860218822Sdim oappend (names16[modrm.rm + add]); 486160484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 486233965Sjdp break; 486360484Sobrien case 0: 486460484Sobrien break; 486533965Sjdp default: 486660484Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 486733965Sjdp break; 486833965Sjdp } 486960484Sobrien return; 487033965Sjdp } 487133965Sjdp 487233965Sjdp disp = 0; 4873218822Sdim if (intel_syntax) 4874218822Sdim intel_operand_size (bytemode, sizeflag); 487560484Sobrien append_seg (); 487633965Sjdp 4877218822Sdim if ((sizeflag & AFLAG) || address_mode == mode_64bit) 487833965Sjdp { 4879218822Sdim /* 32/64 bit address mode */ 4880218822Sdim int havedisp; 488133965Sjdp int havesib; 488233965Sjdp int havebase; 488333965Sjdp int base; 488438889Sjdp int index = 0; 488538889Sjdp int scale = 0; 488633965Sjdp 488733965Sjdp havesib = 0; 488833965Sjdp havebase = 1; 4889218822Sdim base = modrm.rm; 489033965Sjdp 489133965Sjdp if (base == 4) 489233965Sjdp { 489333965Sjdp havesib = 1; 4894223262Sbenl (void) FETCH_DATA (the_info, codep + 1); 489533965Sjdp index = (*codep >> 3) & 7; 4896218822Sdim if (address_mode == mode_64bit || index != 0x4) 4897218822Sdim /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */ 4898218822Sdim scale = (*codep >> 6) & 3; 489933965Sjdp base = *codep & 7; 4900218822Sdim USED_REX (REX_X); 4901218822Sdim if (rex & REX_X) 490277298Sobrien index += 8; 490333965Sjdp codep++; 490433965Sjdp } 4905218822Sdim base += add; 490633965Sjdp 4907218822Sdim switch (modrm.mod) 490833965Sjdp { 490933965Sjdp case 0: 491077298Sobrien if ((base & 7) == 5) 491133965Sjdp { 491233965Sjdp havebase = 0; 4913218822Sdim if (address_mode == mode_64bit && !havesib) 491477298Sobrien riprel = 1; 491577298Sobrien disp = get32s (); 491633965Sjdp } 491733965Sjdp break; 491833965Sjdp case 1: 491933965Sjdp FETCH_DATA (the_info, codep + 1); 492038889Sjdp disp = *codep++; 492138889Sjdp if ((disp & 0x80) != 0) 492238889Sjdp disp -= 0x100; 492333965Sjdp break; 492433965Sjdp case 2: 492577298Sobrien disp = get32s (); 492633965Sjdp break; 492733965Sjdp } 492833965Sjdp 4929218822Sdim havedisp = havebase || (havesib && (index != 4 || scale != 0)); 4930218822Sdim 493160484Sobrien if (!intel_syntax) 4932218822Sdim if (modrm.mod != 0 || (base & 7) == 5) 4933130561Sobrien { 4934218822Sdim if (havedisp || riprel) 4935218822Sdim print_displacement (scratchbuf, disp); 4936218822Sdim else 4937218822Sdim print_operand_value (scratchbuf, 1, disp); 4938130561Sobrien oappend (scratchbuf); 493977298Sobrien if (riprel) 494077298Sobrien { 494177298Sobrien set_op (disp, 1); 494277298Sobrien oappend ("(%rip)"); 494377298Sobrien } 4944130561Sobrien } 494533965Sjdp 4946218822Sdim if (havedisp || (intel_syntax && riprel)) 494733965Sjdp { 494860484Sobrien *obufp++ = open_char; 494977298Sobrien if (intel_syntax && riprel) 4950218822Sdim { 4951218822Sdim set_op (disp, 1); 4952218822Sdim oappend ("rip"); 4953218822Sdim } 4954130561Sobrien *obufp = '\0'; 495533965Sjdp if (havebase) 4956218822Sdim oappend (address_mode == mode_64bit && (sizeflag & AFLAG) 495792828Sobrien ? names64[base] : names32[base]); 495833965Sjdp if (havesib) 495933965Sjdp { 496033965Sjdp if (index != 4) 496133965Sjdp { 4962218822Sdim if (!intel_syntax || havebase) 4963130561Sobrien { 4964218822Sdim *obufp++ = separator_char; 4965218822Sdim *obufp = '\0'; 4966130561Sobrien } 4967218822Sdim oappend (address_mode == mode_64bit && (sizeflag & AFLAG) 4968218822Sdim ? names64[index] : names32[index]); 496933965Sjdp } 4970130561Sobrien if (scale != 0 || (!intel_syntax && index != 4)) 4971130561Sobrien { 4972130561Sobrien *obufp++ = scale_char; 4973130561Sobrien *obufp = '\0'; 4974130561Sobrien sprintf (scratchbuf, "%d", 1 << scale); 4975130561Sobrien oappend (scratchbuf); 4976130561Sobrien } 497733965Sjdp } 4978218822Sdim if (intel_syntax 4979218822Sdim && (disp || modrm.mod != 0 || (base & 7) == 5)) 4980218822Sdim { 4981218822Sdim if ((bfd_signed_vma) disp >= 0) 4982218822Sdim { 4983218822Sdim *obufp++ = '+'; 4984218822Sdim *obufp = '\0'; 4985218822Sdim } 4986218822Sdim else if (modrm.mod != 1) 4987218822Sdim { 4988218822Sdim *obufp++ = '-'; 4989218822Sdim *obufp = '\0'; 4990218822Sdim disp = - (bfd_signed_vma) disp; 4991218822Sdim } 499285815Sobrien 4993218822Sdim print_displacement (scratchbuf, disp); 4994218822Sdim oappend (scratchbuf); 4995218822Sdim } 499660484Sobrien 499760484Sobrien *obufp++ = close_char; 4998130561Sobrien *obufp = '\0'; 499933965Sjdp } 500060484Sobrien else if (intel_syntax) 5001130561Sobrien { 5002218822Sdim if (modrm.mod != 0 || (base & 7) == 5) 5003130561Sobrien { 500460484Sobrien if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 500560484Sobrien | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 500660484Sobrien ; 500760484Sobrien else 500860484Sobrien { 500985815Sobrien oappend (names_seg[ds_reg - es_reg]); 501060484Sobrien oappend (":"); 501160484Sobrien } 501277298Sobrien print_operand_value (scratchbuf, 1, disp); 5013130561Sobrien oappend (scratchbuf); 5014130561Sobrien } 5015130561Sobrien } 501633965Sjdp } 501733965Sjdp else 501833965Sjdp { /* 16 bit address mode */ 5019218822Sdim switch (modrm.mod) 502033965Sjdp { 502133965Sjdp case 0: 5022218822Sdim if (modrm.rm == 6) 502338889Sjdp { 502438889Sjdp disp = get16 (); 502538889Sjdp if ((disp & 0x8000) != 0) 502638889Sjdp disp -= 0x10000; 502738889Sjdp } 502833965Sjdp break; 502933965Sjdp case 1: 503033965Sjdp FETCH_DATA (the_info, codep + 1); 503138889Sjdp disp = *codep++; 503238889Sjdp if ((disp & 0x80) != 0) 503338889Sjdp disp -= 0x100; 503433965Sjdp break; 503533965Sjdp case 2: 503638889Sjdp disp = get16 (); 503738889Sjdp if ((disp & 0x8000) != 0) 503838889Sjdp disp -= 0x10000; 503933965Sjdp break; 504033965Sjdp } 504133965Sjdp 504260484Sobrien if (!intel_syntax) 5043218822Sdim if (modrm.mod != 0 || modrm.rm == 6) 5044130561Sobrien { 5045218822Sdim print_displacement (scratchbuf, disp); 5046130561Sobrien oappend (scratchbuf); 5047130561Sobrien } 504833965Sjdp 5049218822Sdim if (modrm.mod != 0 || modrm.rm != 6) 505033965Sjdp { 505160484Sobrien *obufp++ = open_char; 5052130561Sobrien *obufp = '\0'; 5053218822Sdim oappend (index16[modrm.rm]); 5054218822Sdim if (intel_syntax 5055218822Sdim && (disp || modrm.mod != 0 || modrm.rm == 6)) 5056218822Sdim { 5057218822Sdim if ((bfd_signed_vma) disp >= 0) 5058218822Sdim { 5059218822Sdim *obufp++ = '+'; 5060218822Sdim *obufp = '\0'; 5061218822Sdim } 5062218822Sdim else if (modrm.mod != 1) 5063218822Sdim { 5064218822Sdim *obufp++ = '-'; 5065218822Sdim *obufp = '\0'; 5066218822Sdim disp = - (bfd_signed_vma) disp; 5067218822Sdim } 5068218822Sdim 5069218822Sdim print_displacement (scratchbuf, disp); 5070218822Sdim oappend (scratchbuf); 5071218822Sdim } 5072218822Sdim 5073130561Sobrien *obufp++ = close_char; 5074130561Sobrien *obufp = '\0'; 507533965Sjdp } 5076218822Sdim else if (intel_syntax) 5077218822Sdim { 5078218822Sdim if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5079218822Sdim | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 5080218822Sdim ; 5081218822Sdim else 5082218822Sdim { 5083218822Sdim oappend (names_seg[ds_reg - es_reg]); 5084218822Sdim oappend (":"); 5085218822Sdim } 5086218822Sdim print_operand_value (scratchbuf, 1, disp & 0xffff); 5087218822Sdim oappend (scratchbuf); 5088218822Sdim } 508933965Sjdp } 509033965Sjdp} 509133965Sjdp 509260484Sobrienstatic void 5093130561SobrienOP_G (int bytemode, int sizeflag) 509433965Sjdp{ 509577298Sobrien int add = 0; 5096218822Sdim USED_REX (REX_R); 5097218822Sdim if (rex & REX_R) 509877298Sobrien add += 8; 509960484Sobrien switch (bytemode) 510033965Sjdp { 510133965Sjdp case b_mode: 510277298Sobrien USED_REX (0); 510377298Sobrien if (rex) 5104218822Sdim oappend (names8rex[modrm.reg + add]); 510577298Sobrien else 5106218822Sdim oappend (names8[modrm.reg + add]); 510733965Sjdp break; 510833965Sjdp case w_mode: 5109218822Sdim oappend (names16[modrm.reg + add]); 511033965Sjdp break; 511133965Sjdp case d_mode: 5112218822Sdim oappend (names32[modrm.reg + add]); 511333965Sjdp break; 511477298Sobrien case q_mode: 5115218822Sdim oappend (names64[modrm.reg + add]); 511677298Sobrien break; 511733965Sjdp case v_mode: 5118218822Sdim case dq_mode: 5119218822Sdim case dqb_mode: 5120218822Sdim case dqd_mode: 5121218822Sdim case dqw_mode: 5122218822Sdim USED_REX (REX_W); 5123218822Sdim if (rex & REX_W) 5124218822Sdim oappend (names64[modrm.reg + add]); 5125218822Sdim else if ((sizeflag & DFLAG) || bytemode != v_mode) 5126218822Sdim oappend (names32[modrm.reg + add]); 512733965Sjdp else 5128218822Sdim oappend (names16[modrm.reg + add]); 512960484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 513033965Sjdp break; 5131218822Sdim case m_mode: 5132218822Sdim if (address_mode == mode_64bit) 5133218822Sdim oappend (names64[modrm.reg + add]); 5134218822Sdim else 5135218822Sdim oappend (names32[modrm.reg + add]); 5136218822Sdim break; 513733965Sjdp default: 513860484Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 513933965Sjdp break; 514033965Sjdp } 514133965Sjdp} 514233965Sjdp 514377298Sobrienstatic bfd_vma 5144130561Sobrienget64 (void) 514577298Sobrien{ 514685815Sobrien bfd_vma x; 514785815Sobrien#ifdef BFD64 514885815Sobrien unsigned int a; 514985815Sobrien unsigned int b; 515077298Sobrien 5151223262Sbenl (void) FETCH_DATA (the_info, codep + 8); 515277298Sobrien a = *codep++ & 0xff; 515377298Sobrien a |= (*codep++ & 0xff) << 8; 515477298Sobrien a |= (*codep++ & 0xff) << 16; 515577298Sobrien a |= (*codep++ & 0xff) << 24; 515685815Sobrien b = *codep++ & 0xff; 515777298Sobrien b |= (*codep++ & 0xff) << 8; 515877298Sobrien b |= (*codep++ & 0xff) << 16; 515977298Sobrien b |= (*codep++ & 0xff) << 24; 516077298Sobrien x = a + ((bfd_vma) b << 32); 516177298Sobrien#else 516285815Sobrien abort (); 516385815Sobrien x = 0; 516477298Sobrien#endif 516577298Sobrien return x; 516677298Sobrien} 516777298Sobrien 516877298Sobrienstatic bfd_signed_vma 5169130561Sobrienget32 (void) 517033965Sjdp{ 517177298Sobrien bfd_signed_vma x = 0; 517233965Sjdp 5173223262Sbenl (void) FETCH_DATA (the_info, codep + 4); 517477298Sobrien x = *codep++ & (bfd_signed_vma) 0xff; 517577298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 517677298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 517777298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 517860484Sobrien return x; 517933965Sjdp} 518033965Sjdp 518177298Sobrienstatic bfd_signed_vma 5182130561Sobrienget32s (void) 518377298Sobrien{ 518477298Sobrien bfd_signed_vma x = 0; 518577298Sobrien 5186223262Sbenl (void) FETCH_DATA (the_info, codep + 4); 518777298Sobrien x = *codep++ & (bfd_signed_vma) 0xff; 518877298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 8; 518977298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 16; 519077298Sobrien x |= (*codep++ & (bfd_signed_vma) 0xff) << 24; 519177298Sobrien 519277298Sobrien x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31); 519377298Sobrien 519477298Sobrien return x; 519577298Sobrien} 519677298Sobrien 519733965Sjdpstatic int 5198130561Sobrienget16 (void) 519933965Sjdp{ 520033965Sjdp int x = 0; 520133965Sjdp 5202223262Sbenl (void) FETCH_DATA (the_info, codep + 2); 520333965Sjdp x = *codep++ & 0xff; 520433965Sjdp x |= (*codep++ & 0xff) << 8; 520560484Sobrien return x; 520633965Sjdp} 520733965Sjdp 520833965Sjdpstatic void 5209130561Sobrienset_op (bfd_vma op, int riprel) 521033965Sjdp{ 521133965Sjdp op_index[op_ad] = op_ad; 5212218822Sdim if (address_mode == mode_64bit) 521385815Sobrien { 521485815Sobrien op_address[op_ad] = op; 521585815Sobrien op_riprel[op_ad] = riprel; 521685815Sobrien } 521785815Sobrien else 521885815Sobrien { 521985815Sobrien /* Mask to get a 32-bit address. */ 522085815Sobrien op_address[op_ad] = op & 0xffffffff; 522185815Sobrien op_riprel[op_ad] = riprel & 0xffffffff; 522285815Sobrien } 522333965Sjdp} 522433965Sjdp 522560484Sobrienstatic void 5226130561SobrienOP_REG (int code, int sizeflag) 522733965Sjdp{ 522860484Sobrien const char *s; 522977298Sobrien int add = 0; 5230218822Sdim USED_REX (REX_B); 5231218822Sdim if (rex & REX_B) 523277298Sobrien add = 8; 523360484Sobrien 523460484Sobrien switch (code) 523533965Sjdp { 523660484Sobrien case ax_reg: case cx_reg: case dx_reg: case bx_reg: 523760484Sobrien case sp_reg: case bp_reg: case si_reg: case di_reg: 523877298Sobrien s = names16[code - ax_reg + add]; 523977298Sobrien break; 524077298Sobrien case es_reg: case ss_reg: case cs_reg: 524177298Sobrien case ds_reg: case fs_reg: case gs_reg: 524277298Sobrien s = names_seg[code - es_reg + add]; 524377298Sobrien break; 524477298Sobrien case al_reg: case ah_reg: case cl_reg: case ch_reg: 524577298Sobrien case dl_reg: case dh_reg: case bl_reg: case bh_reg: 524677298Sobrien USED_REX (0); 524777298Sobrien if (rex) 524877298Sobrien s = names8rex[code - al_reg + add]; 524977298Sobrien else 525077298Sobrien s = names8[code - al_reg]; 525177298Sobrien break; 525285815Sobrien case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: 525385815Sobrien case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: 5254218822Sdim if (address_mode == mode_64bit && (sizeflag & DFLAG)) 525585815Sobrien { 525685815Sobrien s = names64[code - rAX_reg + add]; 525785815Sobrien break; 525885815Sobrien } 525985815Sobrien code += eAX_reg - rAX_reg; 526085815Sobrien /* Fall through. */ 526177298Sobrien case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 526277298Sobrien case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 5263218822Sdim USED_REX (REX_W); 5264218822Sdim if (rex & REX_W) 526577298Sobrien s = names64[code - eAX_reg + add]; 526677298Sobrien else if (sizeflag & DFLAG) 526777298Sobrien s = names32[code - eAX_reg + add]; 526877298Sobrien else 526977298Sobrien s = names16[code - eAX_reg + add]; 527077298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 527177298Sobrien break; 527277298Sobrien default: 527377298Sobrien s = INTERNAL_DISASSEMBLER_ERROR; 527477298Sobrien break; 527577298Sobrien } 527677298Sobrien oappend (s); 527777298Sobrien} 527877298Sobrien 527977298Sobrienstatic void 5280130561SobrienOP_IMREG (int code, int sizeflag) 528177298Sobrien{ 528277298Sobrien const char *s; 528377298Sobrien 528477298Sobrien switch (code) 528577298Sobrien { 528677298Sobrien case indir_dx_reg: 528785815Sobrien if (intel_syntax) 5288218822Sdim s = "dx"; 528985815Sobrien else 5290130561Sobrien s = "(%dx)"; 529177298Sobrien break; 529277298Sobrien case ax_reg: case cx_reg: case dx_reg: case bx_reg: 529377298Sobrien case sp_reg: case bp_reg: case si_reg: case di_reg: 529460484Sobrien s = names16[code - ax_reg]; 529560484Sobrien break; 529660484Sobrien case es_reg: case ss_reg: case cs_reg: 529760484Sobrien case ds_reg: case fs_reg: case gs_reg: 529860484Sobrien s = names_seg[code - es_reg]; 529960484Sobrien break; 530060484Sobrien case al_reg: case ah_reg: case cl_reg: case ch_reg: 530160484Sobrien case dl_reg: case dh_reg: case bl_reg: case bh_reg: 530277298Sobrien USED_REX (0); 530377298Sobrien if (rex) 530477298Sobrien s = names8rex[code - al_reg]; 530577298Sobrien else 530677298Sobrien s = names8[code - al_reg]; 530760484Sobrien break; 530860484Sobrien case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: 530960484Sobrien case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: 5310218822Sdim USED_REX (REX_W); 5311218822Sdim if (rex & REX_W) 531277298Sobrien s = names64[code - eAX_reg]; 531377298Sobrien else if (sizeflag & DFLAG) 531433965Sjdp s = names32[code - eAX_reg]; 531533965Sjdp else 531633965Sjdp s = names16[code - eAX_reg]; 531760484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 531833965Sjdp break; 5319218822Sdim case z_mode_ax_reg: 5320218822Sdim if ((rex & REX_W) || (sizeflag & DFLAG)) 5321218822Sdim s = *names32; 5322218822Sdim else 5323218822Sdim s = *names16; 5324218822Sdim if (!(rex & REX_W)) 5325218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 5326218822Sdim break; 532733965Sjdp default: 532860484Sobrien s = INTERNAL_DISASSEMBLER_ERROR; 532933965Sjdp break; 533033965Sjdp } 533133965Sjdp oappend (s); 533233965Sjdp} 533333965Sjdp 533460484Sobrienstatic void 5335130561SobrienOP_I (int bytemode, int sizeflag) 533633965Sjdp{ 533777298Sobrien bfd_signed_vma op; 533877298Sobrien bfd_signed_vma mask = -1; 533960484Sobrien 534060484Sobrien switch (bytemode) 534133965Sjdp { 534233965Sjdp case b_mode: 534333965Sjdp FETCH_DATA (the_info, codep + 1); 534477298Sobrien op = *codep++; 534577298Sobrien mask = 0xff; 534633965Sjdp break; 534777298Sobrien case q_mode: 5348218822Sdim if (address_mode == mode_64bit) 534985815Sobrien { 535085815Sobrien op = get32s (); 535185815Sobrien break; 535285815Sobrien } 535385815Sobrien /* Fall through. */ 535433965Sjdp case v_mode: 5355218822Sdim USED_REX (REX_W); 5356218822Sdim if (rex & REX_W) 535777298Sobrien op = get32s (); 535877298Sobrien else if (sizeflag & DFLAG) 535977298Sobrien { 536077298Sobrien op = get32 (); 536177298Sobrien mask = 0xffffffff; 536277298Sobrien } 536333965Sjdp else 536477298Sobrien { 536577298Sobrien op = get16 (); 536677298Sobrien mask = 0xfffff; 536777298Sobrien } 536860484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 536933965Sjdp break; 537033965Sjdp case w_mode: 537177298Sobrien mask = 0xfffff; 537233965Sjdp op = get16 (); 537333965Sjdp break; 5374218822Sdim case const_1_mode: 5375218822Sdim if (intel_syntax) 5376218822Sdim oappend ("1"); 5377218822Sdim return; 537833965Sjdp default: 537960484Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 538060484Sobrien return; 538133965Sjdp } 538260484Sobrien 538377298Sobrien op &= mask; 538477298Sobrien scratchbuf[0] = '$'; 538585815Sobrien print_operand_value (scratchbuf + 1, 1, op); 538685815Sobrien oappend (scratchbuf + intel_syntax); 538760484Sobrien scratchbuf[0] = '\0'; 538833965Sjdp} 538933965Sjdp 539060484Sobrienstatic void 5391130561SobrienOP_I64 (int bytemode, int sizeflag) 539277298Sobrien{ 539377298Sobrien bfd_signed_vma op; 539477298Sobrien bfd_signed_vma mask = -1; 539577298Sobrien 5396218822Sdim if (address_mode != mode_64bit) 539785815Sobrien { 539885815Sobrien OP_I (bytemode, sizeflag); 539985815Sobrien return; 540085815Sobrien } 540185815Sobrien 540277298Sobrien switch (bytemode) 540377298Sobrien { 540477298Sobrien case b_mode: 540577298Sobrien FETCH_DATA (the_info, codep + 1); 540677298Sobrien op = *codep++; 540777298Sobrien mask = 0xff; 540877298Sobrien break; 540977298Sobrien case v_mode: 5410218822Sdim USED_REX (REX_W); 5411218822Sdim if (rex & REX_W) 541277298Sobrien op = get64 (); 541377298Sobrien else if (sizeflag & DFLAG) 541477298Sobrien { 541577298Sobrien op = get32 (); 541677298Sobrien mask = 0xffffffff; 541777298Sobrien } 541877298Sobrien else 541977298Sobrien { 542077298Sobrien op = get16 (); 542177298Sobrien mask = 0xfffff; 542277298Sobrien } 542377298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 542477298Sobrien break; 542577298Sobrien case w_mode: 542677298Sobrien mask = 0xfffff; 542777298Sobrien op = get16 (); 542877298Sobrien break; 542977298Sobrien default: 543077298Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 543177298Sobrien return; 543277298Sobrien } 543377298Sobrien 543477298Sobrien op &= mask; 543577298Sobrien scratchbuf[0] = '$'; 543685815Sobrien print_operand_value (scratchbuf + 1, 1, op); 543785815Sobrien oappend (scratchbuf + intel_syntax); 543877298Sobrien scratchbuf[0] = '\0'; 543977298Sobrien} 544077298Sobrien 544177298Sobrienstatic void 5442130561SobrienOP_sI (int bytemode, int sizeflag) 544333965Sjdp{ 544477298Sobrien bfd_signed_vma op; 544577298Sobrien bfd_signed_vma mask = -1; 544660484Sobrien 544760484Sobrien switch (bytemode) 544833965Sjdp { 544933965Sjdp case b_mode: 545033965Sjdp FETCH_DATA (the_info, codep + 1); 545138889Sjdp op = *codep++; 545238889Sjdp if ((op & 0x80) != 0) 545338889Sjdp op -= 0x100; 545477298Sobrien mask = 0xffffffff; 545533965Sjdp break; 545633965Sjdp case v_mode: 5457218822Sdim USED_REX (REX_W); 5458218822Sdim if (rex & REX_W) 545977298Sobrien op = get32s (); 546077298Sobrien else if (sizeflag & DFLAG) 546177298Sobrien { 546277298Sobrien op = get32s (); 546377298Sobrien mask = 0xffffffff; 546477298Sobrien } 546533965Sjdp else 546638889Sjdp { 546777298Sobrien mask = 0xffffffff; 546885815Sobrien op = get16 (); 546938889Sjdp if ((op & 0x8000) != 0) 547038889Sjdp op -= 0x10000; 547138889Sjdp } 547260484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 547333965Sjdp break; 547433965Sjdp case w_mode: 547538889Sjdp op = get16 (); 547677298Sobrien mask = 0xffffffff; 547738889Sjdp if ((op & 0x8000) != 0) 547838889Sjdp op -= 0x10000; 547933965Sjdp break; 548033965Sjdp default: 548160484Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 548260484Sobrien return; 548333965Sjdp } 548477298Sobrien 548577298Sobrien scratchbuf[0] = '$'; 548677298Sobrien print_operand_value (scratchbuf + 1, 1, op); 548785815Sobrien oappend (scratchbuf + intel_syntax); 548833965Sjdp} 548933965Sjdp 549060484Sobrienstatic void 5491130561SobrienOP_J (int bytemode, int sizeflag) 549233965Sjdp{ 549377298Sobrien bfd_vma disp; 549485815Sobrien bfd_vma mask = -1; 5495218822Sdim bfd_vma segment = 0; 549660484Sobrien 549760484Sobrien switch (bytemode) 549833965Sjdp { 549933965Sjdp case b_mode: 550033965Sjdp FETCH_DATA (the_info, codep + 1); 550138889Sjdp disp = *codep++; 550238889Sjdp if ((disp & 0x80) != 0) 550338889Sjdp disp -= 0x100; 550433965Sjdp break; 550533965Sjdp case v_mode: 5506218822Sdim if ((sizeflag & DFLAG) || (rex & REX_W)) 550777298Sobrien disp = get32s (); 550833965Sjdp else 550933965Sjdp { 551038889Sjdp disp = get16 (); 5511218822Sdim if ((disp & 0x8000) != 0) 5512218822Sdim disp -= 0x10000; 5513218822Sdim /* In 16bit mode, address is wrapped around at 64k within 5514218822Sdim the same segment. Otherwise, a data16 prefix on a jump 5515218822Sdim instruction means that the pc is masked to 16 bits after 5516218822Sdim the displacement is added! */ 551733965Sjdp mask = 0xffff; 5518218822Sdim if ((prefixes & PREFIX_DATA) == 0) 5519218822Sdim segment = ((start_pc + codep - start_codep) 5520218822Sdim & ~((bfd_vma) 0xffff)); 552133965Sjdp } 5522218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 552333965Sjdp break; 552433965Sjdp default: 552560484Sobrien oappend (INTERNAL_DISASSEMBLER_ERROR); 552660484Sobrien return; 552733965Sjdp } 5528218822Sdim disp = ((start_pc + codep - start_codep + disp) & mask) | segment; 552977298Sobrien set_op (disp, 0); 553077298Sobrien print_operand_value (scratchbuf, 1, disp); 553133965Sjdp oappend (scratchbuf); 553233965Sjdp} 553333965Sjdp 553460484Sobrienstatic void 5535218822SdimOP_SEG (int bytemode, int sizeflag) 553633965Sjdp{ 5537218822Sdim if (bytemode == w_mode) 5538218822Sdim oappend (names_seg[modrm.reg]); 5539218822Sdim else 5540218822Sdim OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag); 554133965Sjdp} 554233965Sjdp 554360484Sobrienstatic void 5544130561SobrienOP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag) 554533965Sjdp{ 554633965Sjdp int seg, offset; 554760484Sobrien 554860484Sobrien if (sizeflag & DFLAG) 554933965Sjdp { 555060484Sobrien offset = get32 (); 555160484Sobrien seg = get16 (); 555233965Sjdp } 555360484Sobrien else 555460484Sobrien { 555560484Sobrien offset = get16 (); 555660484Sobrien seg = get16 (); 555760484Sobrien } 555860484Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 555985815Sobrien if (intel_syntax) 5560218822Sdim sprintf (scratchbuf, "0x%x:0x%x", seg, offset); 556185815Sobrien else 556285815Sobrien sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset); 556360484Sobrien oappend (scratchbuf); 556433965Sjdp} 556533965Sjdp 556660484Sobrienstatic void 5567218822SdimOP_OFF (int bytemode, int sizeflag) 556833965Sjdp{ 556977298Sobrien bfd_vma off; 557033965Sjdp 5571218822Sdim if (intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 5572218822Sdim intel_operand_size (bytemode, sizeflag); 557360484Sobrien append_seg (); 557433965Sjdp 5575218822Sdim if ((sizeflag & AFLAG) || address_mode == mode_64bit) 557633965Sjdp off = get32 (); 557733965Sjdp else 557833965Sjdp off = get16 (); 557960484Sobrien 558060484Sobrien if (intel_syntax) 558160484Sobrien { 558260484Sobrien if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5583130561Sobrien | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 558460484Sobrien { 558585815Sobrien oappend (names_seg[ds_reg - es_reg]); 558660484Sobrien oappend (":"); 558760484Sobrien } 558860484Sobrien } 558977298Sobrien print_operand_value (scratchbuf, 1, off); 559033965Sjdp oappend (scratchbuf); 559133965Sjdp} 559285815Sobrien 559377298Sobrienstatic void 5594218822SdimOP_OFF64 (int bytemode, int sizeflag) 559577298Sobrien{ 559677298Sobrien bfd_vma off; 559733965Sjdp 5598218822Sdim if (address_mode != mode_64bit 5599218822Sdim || (prefixes & PREFIX_ADDR)) 560085815Sobrien { 560185815Sobrien OP_OFF (bytemode, sizeflag); 560285815Sobrien return; 560385815Sobrien } 560485815Sobrien 5605218822Sdim if (intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 5606218822Sdim intel_operand_size (bytemode, sizeflag); 560777298Sobrien append_seg (); 560877298Sobrien 560985815Sobrien off = get64 (); 561077298Sobrien 561177298Sobrien if (intel_syntax) 561277298Sobrien { 561377298Sobrien if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 5614130561Sobrien | PREFIX_ES | PREFIX_FS | PREFIX_GS))) 561577298Sobrien { 561685815Sobrien oappend (names_seg[ds_reg - es_reg]); 561777298Sobrien oappend (":"); 561877298Sobrien } 561977298Sobrien } 562077298Sobrien print_operand_value (scratchbuf, 1, off); 562177298Sobrien oappend (scratchbuf); 562277298Sobrien} 562377298Sobrien 562460484Sobrienstatic void 5625130561Sobrienptr_reg (int code, int sizeflag) 562633965Sjdp{ 562760484Sobrien const char *s; 562885815Sobrien 5629218822Sdim *obufp++ = open_char; 5630218822Sdim used_prefixes |= (prefixes & PREFIX_ADDR); 5631218822Sdim if (address_mode == mode_64bit) 563292828Sobrien { 563392828Sobrien if (!(sizeflag & AFLAG)) 5634130561Sobrien s = names32[code - eAX_reg]; 563592828Sobrien else 5636130561Sobrien s = names64[code - eAX_reg]; 563792828Sobrien } 563877298Sobrien else if (sizeflag & AFLAG) 563960484Sobrien s = names32[code - eAX_reg]; 564060484Sobrien else 564160484Sobrien s = names16[code - eAX_reg]; 564260484Sobrien oappend (s); 5643218822Sdim *obufp++ = close_char; 5644218822Sdim *obufp = 0; 564533965Sjdp} 564633965Sjdp 564760484Sobrienstatic void 5648130561SobrienOP_ESreg (int code, int sizeflag) 564933965Sjdp{ 5650218822Sdim if (intel_syntax) 5651218822Sdim { 5652218822Sdim switch (codep[-1]) 5653218822Sdim { 5654218822Sdim case 0x6d: /* insw/insl */ 5655218822Sdim intel_operand_size (z_mode, sizeflag); 5656218822Sdim break; 5657218822Sdim case 0xa5: /* movsw/movsl/movsq */ 5658218822Sdim case 0xa7: /* cmpsw/cmpsl/cmpsq */ 5659218822Sdim case 0xab: /* stosw/stosl */ 5660218822Sdim case 0xaf: /* scasw/scasl */ 5661218822Sdim intel_operand_size (v_mode, sizeflag); 5662218822Sdim break; 5663218822Sdim default: 5664218822Sdim intel_operand_size (b_mode, sizeflag); 5665218822Sdim } 5666218822Sdim } 566785815Sobrien oappend ("%es:" + intel_syntax); 566860484Sobrien ptr_reg (code, sizeflag); 566960484Sobrien} 567060484Sobrien 567160484Sobrienstatic void 5672130561SobrienOP_DSreg (int code, int sizeflag) 567360484Sobrien{ 5674218822Sdim if (intel_syntax) 5675218822Sdim { 5676218822Sdim switch (codep[-1]) 5677218822Sdim { 5678218822Sdim case 0x6f: /* outsw/outsl */ 5679218822Sdim intel_operand_size (z_mode, sizeflag); 5680218822Sdim break; 5681218822Sdim case 0xa5: /* movsw/movsl/movsq */ 5682218822Sdim case 0xa7: /* cmpsw/cmpsl/cmpsq */ 5683218822Sdim case 0xad: /* lodsw/lodsl/lodsq */ 5684218822Sdim intel_operand_size (v_mode, sizeflag); 5685218822Sdim break; 5686218822Sdim default: 5687218822Sdim intel_operand_size (b_mode, sizeflag); 5688218822Sdim } 5689218822Sdim } 569038889Sjdp if ((prefixes 569138889Sjdp & (PREFIX_CS 569238889Sjdp | PREFIX_DS 569338889Sjdp | PREFIX_SS 569438889Sjdp | PREFIX_ES 569538889Sjdp | PREFIX_FS 569638889Sjdp | PREFIX_GS)) == 0) 569738889Sjdp prefixes |= PREFIX_DS; 569885815Sobrien append_seg (); 569960484Sobrien ptr_reg (code, sizeflag); 570033965Sjdp} 570133965Sjdp 570260484Sobrienstatic void 5703130561SobrienOP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 570433965Sjdp{ 570577298Sobrien int add = 0; 5706218822Sdim if (rex & REX_R) 5707218822Sdim { 5708218822Sdim USED_REX (REX_R); 5709218822Sdim add = 8; 5710218822Sdim } 5711218822Sdim else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK)) 5712218822Sdim { 5713218822Sdim used_prefixes |= PREFIX_LOCK; 5714218822Sdim add = 8; 5715218822Sdim } 5716218822Sdim sprintf (scratchbuf, "%%cr%d", modrm.reg + add); 571785815Sobrien oappend (scratchbuf + intel_syntax); 571833965Sjdp} 571933965Sjdp 572060484Sobrienstatic void 5721130561SobrienOP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 572233965Sjdp{ 572377298Sobrien int add = 0; 5724218822Sdim USED_REX (REX_R); 5725218822Sdim if (rex & REX_R) 572677298Sobrien add = 8; 572785815Sobrien if (intel_syntax) 5728218822Sdim sprintf (scratchbuf, "db%d", modrm.reg + add); 572985815Sobrien else 5730218822Sdim sprintf (scratchbuf, "%%db%d", modrm.reg + add); 573133965Sjdp oappend (scratchbuf); 573233965Sjdp} 573333965Sjdp 573460484Sobrienstatic void 5735130561SobrienOP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 573633965Sjdp{ 5737218822Sdim sprintf (scratchbuf, "%%tr%d", modrm.reg); 573885815Sobrien oappend (scratchbuf + intel_syntax); 573933965Sjdp} 574033965Sjdp 574160484Sobrienstatic void 5742218822SdimOP_R (int bytemode, int sizeflag) 574333965Sjdp{ 5744218822Sdim if (modrm.mod == 3) 574560484Sobrien OP_E (bytemode, sizeflag); 574660484Sobrien else 574785815Sobrien BadOp (); 574833965Sjdp} 574933965Sjdp 575060484Sobrienstatic void 5751130561SobrienOP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 575233965Sjdp{ 575377298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 575477298Sobrien if (prefixes & PREFIX_DATA) 5755218822Sdim { 5756218822Sdim int add = 0; 5757218822Sdim USED_REX (REX_R); 5758218822Sdim if (rex & REX_R) 5759218822Sdim add = 8; 5760218822Sdim sprintf (scratchbuf, "%%xmm%d", modrm.reg + add); 5761218822Sdim } 576277298Sobrien else 5763218822Sdim sprintf (scratchbuf, "%%mm%d", modrm.reg); 576485815Sobrien oappend (scratchbuf + intel_syntax); 576533965Sjdp} 576633965Sjdp 576760484Sobrienstatic void 5768130561SobrienOP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 576960484Sobrien{ 577077298Sobrien int add = 0; 5771218822Sdim USED_REX (REX_R); 5772218822Sdim if (rex & REX_R) 577377298Sobrien add = 8; 5774218822Sdim sprintf (scratchbuf, "%%xmm%d", modrm.reg + add); 577585815Sobrien oappend (scratchbuf + intel_syntax); 577660484Sobrien} 577760484Sobrien 577860484Sobrienstatic void 5779130561SobrienOP_EM (int bytemode, int sizeflag) 578033965Sjdp{ 5781218822Sdim if (modrm.mod != 3) 578260484Sobrien { 5783218822Sdim if (intel_syntax && bytemode == v_mode) 5784218822Sdim { 5785218822Sdim bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; 5786218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 5787218822Sdim } 578860484Sobrien OP_E (bytemode, sizeflag); 578960484Sobrien return; 579060484Sobrien } 579133965Sjdp 579285815Sobrien /* Skip mod/rm byte. */ 579378828Sobrien MODRM_CHECK; 579433965Sjdp codep++; 579577298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 579677298Sobrien if (prefixes & PREFIX_DATA) 5797218822Sdim { 5798218822Sdim int add = 0; 5799218822Sdim 5800218822Sdim USED_REX (REX_B); 5801218822Sdim if (rex & REX_B) 5802218822Sdim add = 8; 5803218822Sdim sprintf (scratchbuf, "%%xmm%d", modrm.rm + add); 5804218822Sdim } 580577298Sobrien else 5806218822Sdim sprintf (scratchbuf, "%%mm%d", modrm.rm); 580785815Sobrien oappend (scratchbuf + intel_syntax); 580833965Sjdp} 580933965Sjdp 5810218822Sdim/* cvt* are the only instructions in sse2 which have 5811218822Sdim both SSE and MMX operands and also have 0x66 prefix 5812218822Sdim in their opcode. 0x66 was originally used to differentiate 5813218822Sdim between SSE and MMX instruction(operands). So we have to handle the 5814218822Sdim cvt* separately using OP_EMC and OP_MXC */ 581560484Sobrienstatic void 5816218822SdimOP_EMC (int bytemode, int sizeflag) 5817218822Sdim{ 5818218822Sdim if (modrm.mod != 3) 5819218822Sdim { 5820218822Sdim if (intel_syntax && bytemode == v_mode) 5821218822Sdim { 5822218822Sdim bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode; 5823218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 5824218822Sdim } 5825218822Sdim OP_E (bytemode, sizeflag); 5826218822Sdim return; 5827218822Sdim } 5828218822Sdim 5829218822Sdim /* Skip mod/rm byte. */ 5830218822Sdim MODRM_CHECK; 5831218822Sdim codep++; 5832218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 5833218822Sdim sprintf (scratchbuf, "%%mm%d", modrm.rm); 5834218822Sdim oappend (scratchbuf + intel_syntax); 5835218822Sdim} 5836218822Sdim 5837218822Sdimstatic void 5838218822SdimOP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 5839218822Sdim{ 5840218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 5841218822Sdim sprintf (scratchbuf, "%%mm%d", modrm.reg); 5842218822Sdim oappend (scratchbuf + intel_syntax); 5843218822Sdim} 5844218822Sdim 5845218822Sdimstatic void 5846130561SobrienOP_EX (int bytemode, int sizeflag) 584733965Sjdp{ 584877298Sobrien int add = 0; 5849218822Sdim if (modrm.mod != 3) 585060484Sobrien { 585160484Sobrien OP_E (bytemode, sizeflag); 585260484Sobrien return; 585360484Sobrien } 5854218822Sdim USED_REX (REX_B); 5855218822Sdim if (rex & REX_B) 585677298Sobrien add = 8; 585760484Sobrien 585885815Sobrien /* Skip mod/rm byte. */ 585978828Sobrien MODRM_CHECK; 586060484Sobrien codep++; 5861218822Sdim sprintf (scratchbuf, "%%xmm%d", modrm.rm + add); 586285815Sobrien oappend (scratchbuf + intel_syntax); 586333965Sjdp} 586460484Sobrien 586560484Sobrienstatic void 5866130561SobrienOP_MS (int bytemode, int sizeflag) 586760484Sobrien{ 5868218822Sdim if (modrm.mod == 3) 586960484Sobrien OP_EM (bytemode, sizeflag); 587060484Sobrien else 587185815Sobrien BadOp (); 587260484Sobrien} 587360484Sobrien 587478828Sobrienstatic void 5875130561SobrienOP_XS (int bytemode, int sizeflag) 587678828Sobrien{ 5877218822Sdim if (modrm.mod == 3) 587878828Sobrien OP_EX (bytemode, sizeflag); 587978828Sobrien else 588085815Sobrien BadOp (); 588178828Sobrien} 588278828Sobrien 5883130561Sobrienstatic void 5884130561SobrienOP_M (int bytemode, int sizeflag) 5885130561Sobrien{ 5886218822Sdim if (modrm.mod == 3) 5887218822Sdim /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */ 5888218822Sdim BadOp (); 5889130561Sobrien else 5890130561Sobrien OP_E (bytemode, sizeflag); 5891130561Sobrien} 5892130561Sobrien 5893130561Sobrienstatic void 5894130561SobrienOP_0f07 (int bytemode, int sizeflag) 5895130561Sobrien{ 5896218822Sdim if (modrm.mod != 3 || modrm.rm != 0) 5897130561Sobrien BadOp (); 5898130561Sobrien else 5899130561Sobrien OP_E (bytemode, sizeflag); 5900130561Sobrien} 5901130561Sobrien 5902130561Sobrienstatic void 5903130561SobrienOP_0fae (int bytemode, int sizeflag) 5904130561Sobrien{ 5905218822Sdim if (modrm.mod == 3) 5906130561Sobrien { 5907218822Sdim if (modrm.reg == 7) 5908130561Sobrien strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence"); 5909238123Sjhb else if (modrm.reg == 6) 5910238123Sjhb strcpy (obuf + strlen (obuf) - sizeof ("xsaveopt") + 1, "mfence"); 5911238123Sjhb else if (modrm.reg == 5) 5912238123Sjhb strcpy (obuf + strlen (obuf) - sizeof ("xrstor") + 1, "lfence"); 5913130561Sobrien 5914218822Sdim if (modrm.reg < 5 || modrm.rm != 0) 5915130561Sobrien { 5916130561Sobrien BadOp (); /* bad sfence, mfence, or lfence */ 5917130561Sobrien return; 5918130561Sobrien } 5919238123Sjhb bytemode = 0; 5920130561Sobrien } 5921130561Sobrien 5922130561Sobrien OP_E (bytemode, sizeflag); 5923130561Sobrien} 5924130561Sobrien 5925218822Sdim/* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in 5926218822Sdim 32bit mode and "xchg %rax,%rax" in 64bit mode. */ 5927218822Sdim 5928130561Sobrienstatic void 5929218822SdimNOP_Fixup1 (int bytemode, int sizeflag) 5930130561Sobrien{ 5931218822Sdim if ((prefixes & PREFIX_DATA) != 0 5932218822Sdim || (rex != 0 5933218822Sdim && rex != 0x48 5934218822Sdim && address_mode == mode_64bit)) 5935218822Sdim OP_REG (bytemode, sizeflag); 5936218822Sdim else 5937218822Sdim strcpy (obuf, "nop"); 5938130561Sobrien} 5939130561Sobrien 5940218822Sdimstatic void 5941218822SdimNOP_Fixup2 (int bytemode, int sizeflag) 5942218822Sdim{ 5943218822Sdim if ((prefixes & PREFIX_DATA) != 0 5944218822Sdim || (rex != 0 5945218822Sdim && rex != 0x48 5946218822Sdim && address_mode == mode_64bit)) 5947218822Sdim OP_IMREG (bytemode, sizeflag); 5948218822Sdim} 5949218822Sdim 5950130561Sobrienstatic const char *const Suffix3DNow[] = { 595160484Sobrien/* 00 */ NULL, NULL, NULL, NULL, 595260484Sobrien/* 04 */ NULL, NULL, NULL, NULL, 595360484Sobrien/* 08 */ NULL, NULL, NULL, NULL, 595460484Sobrien/* 0C */ "pi2fw", "pi2fd", NULL, NULL, 595560484Sobrien/* 10 */ NULL, NULL, NULL, NULL, 595660484Sobrien/* 14 */ NULL, NULL, NULL, NULL, 595760484Sobrien/* 18 */ NULL, NULL, NULL, NULL, 595860484Sobrien/* 1C */ "pf2iw", "pf2id", NULL, NULL, 595960484Sobrien/* 20 */ NULL, NULL, NULL, NULL, 596060484Sobrien/* 24 */ NULL, NULL, NULL, NULL, 596160484Sobrien/* 28 */ NULL, NULL, NULL, NULL, 596260484Sobrien/* 2C */ NULL, NULL, NULL, NULL, 596360484Sobrien/* 30 */ NULL, NULL, NULL, NULL, 596460484Sobrien/* 34 */ NULL, NULL, NULL, NULL, 596560484Sobrien/* 38 */ NULL, NULL, NULL, NULL, 596660484Sobrien/* 3C */ NULL, NULL, NULL, NULL, 596760484Sobrien/* 40 */ NULL, NULL, NULL, NULL, 596860484Sobrien/* 44 */ NULL, NULL, NULL, NULL, 596960484Sobrien/* 48 */ NULL, NULL, NULL, NULL, 597060484Sobrien/* 4C */ NULL, NULL, NULL, NULL, 597160484Sobrien/* 50 */ NULL, NULL, NULL, NULL, 597260484Sobrien/* 54 */ NULL, NULL, NULL, NULL, 597360484Sobrien/* 58 */ NULL, NULL, NULL, NULL, 597460484Sobrien/* 5C */ NULL, NULL, NULL, NULL, 597560484Sobrien/* 60 */ NULL, NULL, NULL, NULL, 597660484Sobrien/* 64 */ NULL, NULL, NULL, NULL, 597760484Sobrien/* 68 */ NULL, NULL, NULL, NULL, 597860484Sobrien/* 6C */ NULL, NULL, NULL, NULL, 597960484Sobrien/* 70 */ NULL, NULL, NULL, NULL, 598060484Sobrien/* 74 */ NULL, NULL, NULL, NULL, 598160484Sobrien/* 78 */ NULL, NULL, NULL, NULL, 598260484Sobrien/* 7C */ NULL, NULL, NULL, NULL, 598360484Sobrien/* 80 */ NULL, NULL, NULL, NULL, 598460484Sobrien/* 84 */ NULL, NULL, NULL, NULL, 598560484Sobrien/* 88 */ NULL, NULL, "pfnacc", NULL, 598660484Sobrien/* 8C */ NULL, NULL, "pfpnacc", NULL, 598760484Sobrien/* 90 */ "pfcmpge", NULL, NULL, NULL, 598860484Sobrien/* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt", 598960484Sobrien/* 98 */ NULL, NULL, "pfsub", NULL, 599060484Sobrien/* 9C */ NULL, NULL, "pfadd", NULL, 599160484Sobrien/* A0 */ "pfcmpgt", NULL, NULL, NULL, 599260484Sobrien/* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1", 599360484Sobrien/* A8 */ NULL, NULL, "pfsubr", NULL, 599460484Sobrien/* AC */ NULL, NULL, "pfacc", NULL, 599560484Sobrien/* B0 */ "pfcmpeq", NULL, NULL, NULL, 5996218822Sdim/* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw", 599760484Sobrien/* B8 */ NULL, NULL, NULL, "pswapd", 599860484Sobrien/* BC */ NULL, NULL, NULL, "pavgusb", 599960484Sobrien/* C0 */ NULL, NULL, NULL, NULL, 600060484Sobrien/* C4 */ NULL, NULL, NULL, NULL, 600160484Sobrien/* C8 */ NULL, NULL, NULL, NULL, 600260484Sobrien/* CC */ NULL, NULL, NULL, NULL, 600360484Sobrien/* D0 */ NULL, NULL, NULL, NULL, 600460484Sobrien/* D4 */ NULL, NULL, NULL, NULL, 600560484Sobrien/* D8 */ NULL, NULL, NULL, NULL, 600660484Sobrien/* DC */ NULL, NULL, NULL, NULL, 600760484Sobrien/* E0 */ NULL, NULL, NULL, NULL, 600860484Sobrien/* E4 */ NULL, NULL, NULL, NULL, 600960484Sobrien/* E8 */ NULL, NULL, NULL, NULL, 601060484Sobrien/* EC */ NULL, NULL, NULL, NULL, 601160484Sobrien/* F0 */ NULL, NULL, NULL, NULL, 601260484Sobrien/* F4 */ NULL, NULL, NULL, NULL, 601360484Sobrien/* F8 */ NULL, NULL, NULL, NULL, 601460484Sobrien/* FC */ NULL, NULL, NULL, NULL, 601560484Sobrien}; 601660484Sobrien 601760484Sobrienstatic void 6018130561SobrienOP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 601960484Sobrien{ 602060484Sobrien const char *mnemonic; 602160484Sobrien 6022223262Sbenl (void) FETCH_DATA (the_info, codep + 1); 602360484Sobrien /* AMD 3DNow! instructions are specified by an opcode suffix in the 602460484Sobrien place where an 8-bit immediate would normally go. ie. the last 602560484Sobrien byte of the instruction. */ 602685815Sobrien obufp = obuf + strlen (obuf); 602760484Sobrien mnemonic = Suffix3DNow[*codep++ & 0xff]; 602860484Sobrien if (mnemonic) 602960484Sobrien oappend (mnemonic); 603060484Sobrien else 603160484Sobrien { 603260484Sobrien /* Since a variable sized modrm/sib chunk is between the start 603360484Sobrien of the opcode (0x0f0f) and the opcode suffix, we need to do 603460484Sobrien all the modrm processing first, and don't know until now that 603560484Sobrien we have a bad opcode. This necessitates some cleaning up. */ 6036218822Sdim op_out[0][0] = '\0'; 6037218822Sdim op_out[1][0] = '\0'; 603885815Sobrien BadOp (); 603960484Sobrien } 604060484Sobrien} 604160484Sobrien 604285815Sobrienstatic const char *simd_cmp_op[] = { 604360484Sobrien "eq", 604460484Sobrien "lt", 604560484Sobrien "le", 604660484Sobrien "unord", 604760484Sobrien "neq", 604860484Sobrien "nlt", 604960484Sobrien "nle", 605060484Sobrien "ord" 605160484Sobrien}; 605260484Sobrien 605360484Sobrienstatic void 6054130561SobrienOP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED) 605560484Sobrien{ 605660484Sobrien unsigned int cmp_type; 605760484Sobrien 6058223262Sbenl (void) FETCH_DATA (the_info, codep + 1); 605985815Sobrien obufp = obuf + strlen (obuf); 606060484Sobrien cmp_type = *codep++ & 0xff; 606160484Sobrien if (cmp_type < 8) 606260484Sobrien { 606377298Sobrien char suffix1 = 'p', suffix2 = 's'; 606460484Sobrien used_prefixes |= (prefixes & PREFIX_REPZ); 606577298Sobrien if (prefixes & PREFIX_REPZ) 606677298Sobrien suffix1 = 's'; 606777298Sobrien else 606877298Sobrien { 606977298Sobrien used_prefixes |= (prefixes & PREFIX_DATA); 607077298Sobrien if (prefixes & PREFIX_DATA) 607177298Sobrien suffix2 = 'd'; 607277298Sobrien else 607377298Sobrien { 607477298Sobrien used_prefixes |= (prefixes & PREFIX_REPNZ); 607577298Sobrien if (prefixes & PREFIX_REPNZ) 607677298Sobrien suffix1 = 's', suffix2 = 'd'; 607777298Sobrien } 607877298Sobrien } 607977298Sobrien sprintf (scratchbuf, "cmp%s%c%c", 608077298Sobrien simd_cmp_op[cmp_type], suffix1, suffix2); 608177298Sobrien used_prefixes |= (prefixes & PREFIX_REPZ); 608260484Sobrien oappend (scratchbuf); 608360484Sobrien } 608460484Sobrien else 608560484Sobrien { 608660484Sobrien /* We have a bad extension byte. Clean up. */ 6087218822Sdim op_out[0][0] = '\0'; 6088218822Sdim op_out[1][0] = '\0'; 608985815Sobrien BadOp (); 609060484Sobrien } 609160484Sobrien} 609260484Sobrien 609360484Sobrienstatic void 6094130561SobrienSIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED) 609560484Sobrien{ 609660484Sobrien /* Change movlps/movhps to movhlps/movlhps for 2 register operand 609760484Sobrien forms of these instructions. */ 6098218822Sdim if (modrm.mod == 3) 609960484Sobrien { 610085815Sobrien char *p = obuf + strlen (obuf); 610185815Sobrien *(p + 1) = '\0'; 610285815Sobrien *p = *(p - 1); 610385815Sobrien *(p - 1) = *(p - 2); 610485815Sobrien *(p - 2) = *(p - 3); 610585815Sobrien *(p - 3) = extrachar; 610660484Sobrien } 610760484Sobrien} 610860484Sobrien 610985815Sobrienstatic void 6110130561SobrienPNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 6111130561Sobrien{ 6112218822Sdim if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1) 6113130561Sobrien { 6114218822Sdim /* Override "sidt". */ 6115218822Sdim size_t olen = strlen (obuf); 6116218822Sdim char *p = obuf + olen - 4; 6117218822Sdim const char **names = (address_mode == mode_64bit 6118218822Sdim ? names64 : names32); 6119130561Sobrien 6120218822Sdim /* We might have a suffix when disassembling with -Msuffix. */ 6121218822Sdim if (*p == 'i') 6122218822Sdim --p; 6123218822Sdim 6124218822Sdim /* Remove "addr16/addr32" if we aren't in Intel mode. */ 6125218822Sdim if (!intel_syntax 6126218822Sdim && (prefixes & PREFIX_ADDR) 6127218822Sdim && olen >= (4 + 7) 6128218822Sdim && *(p - 1) == ' ' 6129218822Sdim && CONST_STRNEQ (p - 7, "addr") 6130218822Sdim && (CONST_STRNEQ (p - 3, "16") 6131218822Sdim || CONST_STRNEQ (p - 3, "32"))) 6132218822Sdim p -= 7; 6133218822Sdim 6134218822Sdim if (modrm.rm) 6135130561Sobrien { 6136130561Sobrien /* mwait %eax,%ecx */ 6137218822Sdim strcpy (p, "mwait"); 6138218822Sdim if (!intel_syntax) 6139218822Sdim strcpy (op_out[0], names[0]); 6140130561Sobrien } 6141130561Sobrien else 6142130561Sobrien { 6143130561Sobrien /* monitor %eax,%ecx,%edx" */ 6144218822Sdim strcpy (p, "monitor"); 6145218822Sdim if (!intel_syntax) 6146218822Sdim { 6147218822Sdim const char **op1_names; 6148218822Sdim if (!(prefixes & PREFIX_ADDR)) 6149218822Sdim op1_names = (address_mode == mode_16bit 6150218822Sdim ? names16 : names); 6151218822Sdim else 6152218822Sdim { 6153218822Sdim op1_names = (address_mode != mode_32bit 6154218822Sdim ? names32 : names16); 6155218822Sdim used_prefixes |= PREFIX_ADDR; 6156218822Sdim } 6157218822Sdim strcpy (op_out[0], op1_names[0]); 6158218822Sdim strcpy (op_out[2], names[2]); 6159218822Sdim } 6160130561Sobrien } 6161218822Sdim if (!intel_syntax) 6162218822Sdim { 6163218822Sdim strcpy (op_out[1], names[1]); 6164218822Sdim two_source_ops = 1; 6165218822Sdim } 6166130561Sobrien 6167130561Sobrien codep++; 6168130561Sobrien } 6169130561Sobrien else 6170218822Sdim OP_M (0, sizeflag); 6171130561Sobrien} 6172130561Sobrien 6173130561Sobrienstatic void 6174238123SjhbXCR_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 6175238123Sjhb{ 6176238123Sjhb if (modrm.mod == 3 && modrm.reg == 2 && modrm.rm <= 1) 6177238123Sjhb { 6178238123Sjhb /* Override "lgdt". */ 6179238123Sjhb size_t olen = strlen (obuf); 6180238123Sjhb char *p = obuf + olen - 4; 6181238123Sjhb 6182238123Sjhb /* We might have a suffix when disassembling with -Msuffix. */ 6183238123Sjhb if (*p == 'i') 6184238123Sjhb --p; 6185238123Sjhb 6186238123Sjhb /* Remove "addr16/addr32" if we aren't in Intel mode. */ 6187238123Sjhb if (!intel_syntax 6188238123Sjhb && (prefixes & PREFIX_ADDR) 6189238123Sjhb && olen >= (4 + 7) 6190238123Sjhb && *(p - 1) == ' ' 6191238123Sjhb && CONST_STRNEQ (p - 7, "addr") 6192238123Sjhb && (CONST_STRNEQ (p - 3, "16") 6193238123Sjhb || CONST_STRNEQ (p - 3, "32"))) 6194238123Sjhb p -= 7; 6195238123Sjhb 6196238123Sjhb if (modrm.rm) 6197238123Sjhb { 6198238123Sjhb strcpy (p, "xsetbv"); 6199238123Sjhb } 6200238123Sjhb else 6201238123Sjhb { 6202238123Sjhb strcpy (p, "xgetbv"); 6203238123Sjhb } 6204238123Sjhb 6205238123Sjhb codep++; 6206238123Sjhb } 6207238123Sjhb else 6208238123Sjhb OP_M (0, sizeflag); 6209238123Sjhb} 6210238123Sjhbstatic void 6211218822SdimSVME_Fixup (int bytemode, int sizeflag) 6212218822Sdim{ 6213218822Sdim const char *alt; 6214218822Sdim char *p; 6215218822Sdim 6216218822Sdim switch (*codep) 6217218822Sdim { 6218218822Sdim case 0xd8: 6219218822Sdim alt = "vmrun"; 6220218822Sdim break; 6221218822Sdim case 0xd9: 6222218822Sdim alt = "vmmcall"; 6223218822Sdim break; 6224218822Sdim case 0xda: 6225218822Sdim alt = "vmload"; 6226218822Sdim break; 6227218822Sdim case 0xdb: 6228218822Sdim alt = "vmsave"; 6229218822Sdim break; 6230218822Sdim case 0xdc: 6231218822Sdim alt = "stgi"; 6232218822Sdim break; 6233218822Sdim case 0xdd: 6234218822Sdim alt = "clgi"; 6235218822Sdim break; 6236218822Sdim case 0xde: 6237218822Sdim alt = "skinit"; 6238218822Sdim break; 6239218822Sdim case 0xdf: 6240218822Sdim alt = "invlpga"; 6241218822Sdim break; 6242218822Sdim default: 6243218822Sdim OP_M (bytemode, sizeflag); 6244218822Sdim return; 6245218822Sdim } 6246218822Sdim /* Override "lidt". */ 6247218822Sdim p = obuf + strlen (obuf) - 4; 6248218822Sdim /* We might have a suffix. */ 6249218822Sdim if (*p == 'i') 6250218822Sdim --p; 6251218822Sdim strcpy (p, alt); 6252218822Sdim if (!(prefixes & PREFIX_ADDR)) 6253218822Sdim { 6254218822Sdim ++codep; 6255218822Sdim return; 6256218822Sdim } 6257218822Sdim used_prefixes |= PREFIX_ADDR; 6258218822Sdim switch (*codep++) 6259218822Sdim { 6260218822Sdim case 0xdf: 6261218822Sdim strcpy (op_out[1], names32[1]); 6262218822Sdim two_source_ops = 1; 6263218822Sdim /* Fall through. */ 6264218822Sdim case 0xd8: 6265218822Sdim case 0xda: 6266218822Sdim case 0xdb: 6267218822Sdim *obufp++ = open_char; 6268218822Sdim if (address_mode == mode_64bit || (sizeflag & AFLAG)) 6269218822Sdim alt = names32[0]; 6270218822Sdim else 6271218822Sdim alt = names16[0]; 6272218822Sdim strcpy (obufp, alt); 6273218822Sdim obufp += strlen (alt); 6274218822Sdim *obufp++ = close_char; 6275218822Sdim *obufp = '\0'; 6276218822Sdim break; 6277218822Sdim } 6278218822Sdim} 6279218822Sdim 6280218822Sdimstatic void 6281130561SobrienINVLPG_Fixup (int bytemode, int sizeflag) 6282130561Sobrien{ 6283218822Sdim const char *alt; 6284218822Sdim 6285218822Sdim switch (*codep) 6286130561Sobrien { 6287218822Sdim case 0xf8: 6288218822Sdim alt = "swapgs"; 6289218822Sdim break; 6290218822Sdim case 0xf9: 6291218822Sdim alt = "rdtscp"; 6292218822Sdim break; 6293218822Sdim default: 6294218822Sdim OP_M (bytemode, sizeflag); 6295218822Sdim return; 6296130561Sobrien } 6297218822Sdim /* Override "invlpg". */ 6298218822Sdim strcpy (obuf + strlen (obuf) - 6, alt); 6299218822Sdim codep++; 6300130561Sobrien} 6301130561Sobrien 6302130561Sobrienstatic void 630385815SobrienBadOp (void) 630460484Sobrien{ 630585815Sobrien /* Throw away prefixes and 1st. opcode byte. */ 630685815Sobrien codep = insn_codep + 1; 630760484Sobrien oappend ("(bad)"); 630860484Sobrien} 6309218822Sdim 6310218822Sdimstatic void 6311218822SdimVMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag) 6312218822Sdim{ 6313218822Sdim if (modrm.mod == 3 6314218822Sdim && modrm.reg == 0 6315218822Sdim && modrm.rm >=1 6316218822Sdim && modrm.rm <= 4) 6317218822Sdim { 6318218822Sdim /* Override "sgdt". */ 6319218822Sdim char *p = obuf + strlen (obuf) - 4; 6320218822Sdim 6321218822Sdim /* We might have a suffix when disassembling with -Msuffix. */ 6322218822Sdim if (*p == 'g') 6323218822Sdim --p; 6324218822Sdim 6325218822Sdim switch (modrm.rm) 6326218822Sdim { 6327218822Sdim case 1: 6328218822Sdim strcpy (p, "vmcall"); 6329218822Sdim break; 6330218822Sdim case 2: 6331218822Sdim strcpy (p, "vmlaunch"); 6332218822Sdim break; 6333218822Sdim case 3: 6334218822Sdim strcpy (p, "vmresume"); 6335218822Sdim break; 6336218822Sdim case 4: 6337218822Sdim strcpy (p, "vmxoff"); 6338218822Sdim break; 6339218822Sdim } 6340218822Sdim 6341218822Sdim codep++; 6342218822Sdim } 6343218822Sdim else 6344218822Sdim OP_E (0, sizeflag); 6345218822Sdim} 6346218822Sdim 6347218822Sdimstatic void 6348218822SdimOP_VMX (int bytemode, int sizeflag) 6349218822Sdim{ 6350218822Sdim used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ)); 6351218822Sdim if (prefixes & PREFIX_DATA) 6352218822Sdim strcpy (obuf, "vmclear"); 6353218822Sdim else if (prefixes & PREFIX_REPZ) 6354218822Sdim strcpy (obuf, "vmxon"); 6355218822Sdim else 6356218822Sdim strcpy (obuf, "vmptrld"); 6357218822Sdim OP_E (bytemode, sizeflag); 6358218822Sdim} 6359218822Sdim 6360218822Sdimstatic void 6361218822SdimREP_Fixup (int bytemode, int sizeflag) 6362218822Sdim{ 6363218822Sdim /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs, 6364218822Sdim lods and stos. */ 6365218822Sdim size_t ilen = 0; 6366218822Sdim 6367218822Sdim if (prefixes & PREFIX_REPZ) 6368218822Sdim switch (*insn_codep) 6369218822Sdim { 6370218822Sdim case 0x6e: /* outsb */ 6371218822Sdim case 0x6f: /* outsw/outsl */ 6372218822Sdim case 0xa4: /* movsb */ 6373218822Sdim case 0xa5: /* movsw/movsl/movsq */ 6374218822Sdim if (!intel_syntax) 6375218822Sdim ilen = 5; 6376218822Sdim else 6377218822Sdim ilen = 4; 6378218822Sdim break; 6379218822Sdim case 0xaa: /* stosb */ 6380218822Sdim case 0xab: /* stosw/stosl/stosq */ 6381218822Sdim case 0xac: /* lodsb */ 6382218822Sdim case 0xad: /* lodsw/lodsl/lodsq */ 6383218822Sdim if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS)) 6384218822Sdim ilen = 5; 6385218822Sdim else 6386218822Sdim ilen = 4; 6387218822Sdim break; 6388218822Sdim case 0x6c: /* insb */ 6389218822Sdim case 0x6d: /* insl/insw */ 6390218822Sdim if (!intel_syntax) 6391218822Sdim ilen = 4; 6392218822Sdim else 6393218822Sdim ilen = 3; 6394218822Sdim break; 6395218822Sdim default: 6396218822Sdim abort (); 6397218822Sdim break; 6398218822Sdim } 6399218822Sdim 6400218822Sdim if (ilen != 0) 6401218822Sdim { 6402218822Sdim size_t olen; 6403218822Sdim char *p; 6404218822Sdim 6405218822Sdim olen = strlen (obuf); 6406218822Sdim p = obuf + olen - ilen - 1 - 4; 6407218822Sdim /* Handle "repz [addr16|addr32]". */ 6408218822Sdim if ((prefixes & PREFIX_ADDR)) 6409218822Sdim p -= 1 + 6; 6410218822Sdim 6411218822Sdim memmove (p + 3, p + 4, olen - (p + 3 - obuf)); 6412218822Sdim } 6413218822Sdim 6414218822Sdim switch (bytemode) 6415218822Sdim { 6416218822Sdim case al_reg: 6417218822Sdim case eAX_reg: 6418218822Sdim case indir_dx_reg: 6419218822Sdim OP_IMREG (bytemode, sizeflag); 6420218822Sdim break; 6421218822Sdim case eDI_reg: 6422218822Sdim OP_ESreg (bytemode, sizeflag); 6423218822Sdim break; 6424218822Sdim case eSI_reg: 6425218822Sdim OP_DSreg (bytemode, sizeflag); 6426218822Sdim break; 6427218822Sdim default: 6428218822Sdim abort (); 6429218822Sdim break; 6430218822Sdim } 6431218822Sdim} 6432218822Sdim 6433218822Sdimstatic void 6434218822SdimCMPXCHG8B_Fixup (int bytemode, int sizeflag) 6435218822Sdim{ 6436218822Sdim USED_REX (REX_W); 6437218822Sdim if (rex & REX_W) 6438218822Sdim { 6439218822Sdim /* Change cmpxchg8b to cmpxchg16b. */ 6440218822Sdim char *p = obuf + strlen (obuf) - 2; 6441218822Sdim strcpy (p, "16b"); 6442218822Sdim bytemode = o_mode; 6443218822Sdim } 6444218822Sdim OP_M (bytemode, sizeflag); 6445218822Sdim} 6446218822Sdim 6447218822Sdimstatic void 6448218822SdimXMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED) 6449218822Sdim{ 6450218822Sdim sprintf (scratchbuf, "%%xmm%d", reg); 6451218822Sdim oappend (scratchbuf + intel_syntax); 6452218822Sdim} 6453218822Sdim 6454218822Sdimstatic void 6455218822SdimCRC32_Fixup (int bytemode, int sizeflag) 6456218822Sdim{ 6457218822Sdim /* Add proper suffix to "crc32". */ 6458218822Sdim char *p = obuf + strlen (obuf); 6459218822Sdim 6460218822Sdim switch (bytemode) 6461218822Sdim { 6462218822Sdim case b_mode: 6463218822Sdim if (intel_syntax) 6464218822Sdim break; 6465218822Sdim 6466218822Sdim *p++ = 'b'; 6467218822Sdim break; 6468218822Sdim case v_mode: 6469218822Sdim if (intel_syntax) 6470218822Sdim break; 6471218822Sdim 6472218822Sdim USED_REX (REX_W); 6473218822Sdim if (rex & REX_W) 6474218822Sdim *p++ = 'q'; 6475218822Sdim else if (sizeflag & DFLAG) 6476218822Sdim *p++ = 'l'; 6477218822Sdim else 6478218822Sdim *p++ = 'w'; 6479218822Sdim used_prefixes |= (prefixes & PREFIX_DATA); 6480218822Sdim break; 6481218822Sdim default: 6482218822Sdim oappend (INTERNAL_DISASSEMBLER_ERROR); 6483218822Sdim break; 6484218822Sdim } 6485218822Sdim *p = '\0'; 6486218822Sdim 6487218822Sdim if (modrm.mod == 3) 6488218822Sdim { 6489218822Sdim int add; 6490218822Sdim 6491218822Sdim /* Skip mod/rm byte. */ 6492218822Sdim MODRM_CHECK; 6493218822Sdim codep++; 6494218822Sdim 6495218822Sdim USED_REX (REX_B); 6496218822Sdim add = (rex & REX_B) ? 8 : 0; 6497218822Sdim if (bytemode == b_mode) 6498218822Sdim { 6499218822Sdim USED_REX (0); 6500218822Sdim if (rex) 6501218822Sdim oappend (names8rex[modrm.rm + add]); 6502218822Sdim else 6503218822Sdim oappend (names8[modrm.rm + add]); 6504218822Sdim } 6505218822Sdim else 6506218822Sdim { 6507218822Sdim USED_REX (REX_W); 6508218822Sdim if (rex & REX_W) 6509218822Sdim oappend (names64[modrm.rm + add]); 6510218822Sdim else if ((prefixes & PREFIX_DATA)) 6511218822Sdim oappend (names16[modrm.rm + add]); 6512218822Sdim else 6513218822Sdim oappend (names32[modrm.rm + add]); 6514218822Sdim } 6515218822Sdim } 6516218822Sdim else 6517218822Sdim OP_E (bytemode, sizeflag); 6518218822Sdim} 6519