File:  [Qemu by Fabrice Bellard] / qemu / i386-dis.c
Revision 1.1.1.4 (vendor branch): download - view: text, annotated - select for diffs
Tue Apr 24 17:21:04 2018 UTC (2 years, 3 months ago) by root
Branches: qemu, MAIN
CVS tags: qemu0125, qemu0124, qemu0123, qemu0122, qemu0121, qemu0120, qemu0111, qemu0110, HEAD
qemu 0.11.0

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

unix.superglobalmegacorp.com