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

unix.superglobalmegacorp.com