disas/i386.c

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