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