Annotation of qemu/i386-dis.c, revision 1.1.1.4

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

unix.superglobalmegacorp.com