contrib/binutils/opcodes/i386-dis.c

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