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 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
  38 #define MAXLEN 15
  39
  40 #include <setjmp.h>
  41
  42 #ifndef UNIXWARE_COMPAT
  43 /* Set non-zero for broken, compatible instructions.  Set to zero for
  44    non-broken opcodes.  */
  45 #define UNIXWARE_COMPAT 1
  46 #endif
  47
  48 static int fetch_data (struct disassemble_info *, bfd_byte *);
  49 static void ckprefix (void);
  50 static const char *prefix_name (int, int);
  51 static int print_insn (bfd_vma, disassemble_info *);
  52 static void dofloat (int);
  53 static void OP_ST (int, int);
  54 static void OP_STi (int, int);
  55 static int putop (const char *, int);
  56 static void oappend (const char *);
  57 static void append_seg (void);
  58 static void OP_indirE (int, int);
  59 static void print_operand_value (char *, int, bfd_vma);
  60 static void OP_E (int, int);
  61 static void OP_G (int, int);
  62 static bfd_vma get64 (void);
  63 static bfd_signed_vma get32 (void);
  64 static bfd_signed_vma get32s (void);
  65 static int get16 (void);
  66 static void set_op (bfd_vma, int);
  67 static void OP_REG (int, int);
  68 static void OP_IMREG (int, int);
  69 static void OP_I (int, int);
  70 static void OP_I64 (int, int);
  71 static void OP_sI (int, int);
  72 static void OP_J (int, int);
  73 static void OP_SEG (int, int);
  74 static void OP_DIR (int, int);
  75 static void OP_OFF (int, int);
  76 static void OP_OFF64 (int, int);
  77 static void ptr_reg (int, int);
  78 static void OP_ESreg (int, int);
  79 static void OP_DSreg (int, int);
  80 static void OP_C (int, int);
  81 static void OP_D (int, int);
  82 static void OP_T (int, int);
  83 static void OP_Rd (int, int);
  84 static void OP_MMX (int, int);
  85 static void OP_XMM (int, int);
  86 static void OP_EM (int, int);
  87 static void OP_EX (int, int);
  88 static void OP_MS (int, int);
  89 static void OP_XS (int, int);
  90 static void OP_M (int, int);
  91 static void OP_VMX (int, int);
  92 static void OP_0fae (int, int);
  93 static void OP_0f07 (int, int);
  94 static void NOP_Fixup (int, int);
  95 static void OP_3DNowSuffix (int, int);
  96 static void OP_SIMD_Suffix (int, int);
  97 static void SIMD_Fixup (int, int);
  98 static void PNI_Fixup (int, int);
  99 static void SVME_Fixup (int, int);
 100 static void INVLPG_Fixup (int, int);
 101 static void BadOp (void);
 102 static void SEG_Fixup (int, int);
 103 static void VMX_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[MAXLEN];
 109   bfd_vma insn_start;
 110   int orig_sizeflag;
 111   jmp_buf bailout;
 112 };
 113
 114 /* The opcode for the fwait instruction, which we treat as a prefix
 115    when we can.  */
 116 #define FWAIT_OPCODE (0x9b)
 117
 118 enum address_mode
 119 {
 120   mode_16bit,
 121   mode_32bit,
 122   mode_64bit
 123 };
 124
 125 enum address_mode address_mode;
 126
 127 /* Flags for the prefixes for the current instruction.  See below.  */
 128 static int prefixes;
 129
 130 /* REX prefix the current instruction.  See below.  */
 131 static int rex;
 132 /* Bits of REX we've already used.  */
 133 static int rex_used;
 134 #define REX_MODE64      8
 135 #define REX_EXTX        4
 136 #define REX_EXTY        2
 137 #define REX_EXTZ        1
 138 /* Mark parts used in the REX prefix.  When we are testing for
 139    empty prefix (for 8bit register REX extension), just mask it
 140    out.  Otherwise test for REX bit is excuse for existence of REX
 141    only in case value is nonzero.  */
 142 #define USED_REX(value)                                 \
 143   {                                                     \
 144     if (value)                                          \
 145       rex_used |= (rex & value) ? (value) | 0x40 : 0;   \
 146     else                                                \
 147       rex_used |= 0x40;                                 \
 148   }
 149
 150 /* Flags for prefixes which we somehow handled when printing the
 151    current instruction.  */
 152 static int used_prefixes;
 153
 154 /* Flags stored in PREFIXES.  */
 155 #define PREFIX_REPZ 1
 156 #define PREFIX_REPNZ 2
 157 #define PREFIX_LOCK 4
 158 #define PREFIX_CS 8
 159 #define PREFIX_SS 0x10
 160 #define PREFIX_DS 0x20
 161 #define PREFIX_ES 0x40
 162 #define PREFIX_FS 0x80
 163 #define PREFIX_GS 0x100
 164 #define PREFIX_DATA 0x200
 165 #define PREFIX_ADDR 0x400
 166 #define PREFIX_FWAIT 0x800
 167
 168 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
 169    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
 170    on error.  */
 171 #define FETCH_DATA(info, addr) \
 172   ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
 173    ? 1 : fetch_data ((info), (addr)))
 174
 175 static int
 176 fetch_data (struct disassemble_info *info, bfd_byte *addr)
 177 {
 178   int status;
 179   struct dis_private *priv = (struct dis_private *) info->private_data;
 180   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
 181
 182   if (addr <= priv->the_buffer + MAXLEN)
 183     status = (*info->read_memory_func) (start,
 184                                         priv->max_fetched,
 185                                         addr - priv->max_fetched,
 186                                         info);
 187   else
 188     status = -1;
 189   if (status != 0)
 190     {
 191       /* If we did manage to read at least one byte, then
 192          print_insn_i386 will do something sensible.  Otherwise, print
 193          an error.  We do that here because this is where we know
 194          STATUS.  */
 195       if (priv->max_fetched == priv->the_buffer)
 196         (*info->memory_error_func) (status, start, info);
 197       longjmp (priv->bailout, 1);
 198     }
 199   else
 200     priv->max_fetched = addr;
 201   return 1;
 202 }
 203
 204 #define XX NULL, 0
 205
 206 #define Eb OP_E, b_mode
 207 #define Ev OP_E, v_mode
 208 #define Ed OP_E, d_mode
 209 #define Eq OP_E, q_mode
 210 #define Edq OP_E, dq_mode
 211 #define Edqw OP_E, dqw_mode
 212 #define indirEv OP_indirE, stack_v_mode
 213 #define indirEp OP_indirE, f_mode
 214 #define stackEv OP_E, stack_v_mode
 215 #define Em OP_E, m_mode
 216 #define Ew OP_E, w_mode
 217 #define Ma OP_E, v_mode
 218 #define M OP_M, 0               /* lea, lgdt, etc. */
 219 #define Mp OP_M, f_mode         /* 32 or 48 bit memory operand for LDS, LES etc */
 220 #define Gb OP_G, b_mode
 221 #define Gv OP_G, v_mode
 222 #define Gd OP_G, d_mode
 223 #define Gdq OP_G, dq_mode
 224 #define Gm OP_G, m_mode
 225 #define Gw OP_G, w_mode
 226 #define Rd OP_Rd, d_mode
 227 #define Rm OP_Rd, m_mode
 228 #define Ib OP_I, b_mode
 229 #define sIb OP_sI, b_mode       /* sign extened byte */
 230 #define Iv OP_I, v_mode
 231 #define Iq OP_I, q_mode
 232 #define Iv64 OP_I64, v_mode
 233 #define Iw OP_I, w_mode
 234 #define I1 OP_I, const_1_mode
 235 #define Jb OP_J, b_mode
 236 #define Jv OP_J, v_mode
 237 #define Cm OP_C, m_mode
 238 #define Dm OP_D, m_mode
 239 #define Td OP_T, d_mode
 240 #define Sv SEG_Fixup, v_mode
 241
 242 #define RMeAX OP_REG, eAX_reg
 243 #define RMeBX OP_REG, eBX_reg
 244 #define RMeCX OP_REG, eCX_reg
 245 #define RMeDX OP_REG, eDX_reg
 246 #define RMeSP OP_REG, eSP_reg
 247 #define RMeBP OP_REG, eBP_reg
 248 #define RMeSI OP_REG, eSI_reg
 249 #define RMeDI OP_REG, eDI_reg
 250 #define RMrAX OP_REG, rAX_reg
 251 #define RMrBX OP_REG, rBX_reg
 252 #define RMrCX OP_REG, rCX_reg
 253 #define RMrDX OP_REG, rDX_reg
 254 #define RMrSP OP_REG, rSP_reg
 255 #define RMrBP OP_REG, rBP_reg
 256 #define RMrSI OP_REG, rSI_reg
 257 #define RMrDI OP_REG, rDI_reg
 258 #define RMAL OP_REG, al_reg
 259 #define RMAL OP_REG, al_reg
 260 #define RMCL OP_REG, cl_reg
 261 #define RMDL OP_REG, dl_reg
 262 #define RMBL OP_REG, bl_reg
 263 #define RMAH OP_REG, ah_reg
 264 #define RMCH OP_REG, ch_reg
 265 #define RMDH OP_REG, dh_reg
 266 #define RMBH OP_REG, bh_reg
 267 #define RMAX OP_REG, ax_reg
 268 #define RMDX OP_REG, dx_reg
 269
 270 #define eAX OP_IMREG, eAX_reg
 271 #define eBX OP_IMREG, eBX_reg
 272 #define eCX OP_IMREG, eCX_reg
 273 #define eDX OP_IMREG, eDX_reg
 274 #define eSP OP_IMREG, eSP_reg
 275 #define eBP OP_IMREG, eBP_reg
 276 #define eSI OP_IMREG, eSI_reg
 277 #define eDI OP_IMREG, eDI_reg
 278 #define AL OP_IMREG, al_reg
 279 #define AL OP_IMREG, al_reg
 280 #define CL OP_IMREG, cl_reg
 281 #define DL OP_IMREG, dl_reg
 282 #define BL OP_IMREG, bl_reg
 283 #define AH OP_IMREG, ah_reg
 284 #define CH OP_IMREG, ch_reg
 285 #define DH OP_IMREG, dh_reg
 286 #define BH OP_IMREG, bh_reg
 287 #define AX OP_IMREG, ax_reg
 288 #define DX OP_IMREG, dx_reg
 289 #define indirDX OP_IMREG, indir_dx_reg
 290
 291 #define Sw OP_SEG, w_mode
 292 #define Ap OP_DIR, 0
 293 #define Ob OP_OFF64, b_mode
 294 #define Ov OP_OFF64, v_mode
 295 #define Xb OP_DSreg, eSI_reg
 296 #define Xv OP_DSreg, eSI_reg
 297 #define Yb OP_ESreg, eDI_reg
 298 #define Yv OP_ESreg, eDI_reg
 299 #define DSBX OP_DSreg, eBX_reg
 300
 301 #define es OP_REG, es_reg
 302 #define ss OP_REG, ss_reg
 303 #define cs OP_REG, cs_reg
 304 #define ds OP_REG, ds_reg
 305 #define fs OP_REG, fs_reg
 306 #define gs OP_REG, gs_reg
 307
 308 #define MX OP_MMX, 0
 309 #define XM OP_XMM, 0
 310 #define EM OP_EM, v_mode
 311 #define EX OP_EX, v_mode
 312 #define MS OP_MS, v_mode
 313 #define XS OP_XS, v_mode
 314 #define VM OP_VMX, q_mode
 315 #define OPSUF OP_3DNowSuffix, 0
 316 #define OPSIMD OP_SIMD_Suffix, 0
 317
 318 #define cond_jump_flag NULL, cond_jump_mode
 319 #define loop_jcxz_flag NULL, loop_jcxz_mode
 320
 321 /* bits in sizeflag */
 322 #define SUFFIX_ALWAYS 4
 323 #define AFLAG 2
 324 #define DFLAG 1
 325
 326 #define b_mode 1  /* byte operand */
 327 #define v_mode 2  /* operand size depends on prefixes */
 328 #define w_mode 3  /* word operand */
 329 #define d_mode 4  /* double word operand  */
 330 #define q_mode 5  /* quad word operand */
 331 #define t_mode 6  /* ten-byte operand */
 332 #define x_mode 7  /* 16-byte XMM operand */
 333 #define m_mode 8  /* d_mode in 32bit, q_mode in 64bit mode.  */
 334 #define cond_jump_mode 9
 335 #define loop_jcxz_mode 10
 336 #define dq_mode 11 /* operand size depends on REX prefixes.  */
 337 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode.  */
 338 #define f_mode 13 /* 4- or 6-byte pointer operand */
 339 #define const_1_mode 14
 340 #define stack_v_mode 15 /* v_mode for stack-related opcodes.  */
 341
 342 #define es_reg 100
 343 #define cs_reg 101
 344 #define ss_reg 102
 345 #define ds_reg 103
 346 #define fs_reg 104
 347 #define gs_reg 105
 348
 349 #define eAX_reg 108
 350 #define eCX_reg 109
 351 #define eDX_reg 110
 352 #define eBX_reg 111
 353 #define eSP_reg 112
 354 #define eBP_reg 113
 355 #define eSI_reg 114
 356 #define eDI_reg 115
 357
 358 #define al_reg 116
 359 #define cl_reg 117
 360 #define dl_reg 118
 361 #define bl_reg 119
 362 #define ah_reg 120
 363 #define ch_reg 121
 364 #define dh_reg 122
 365 #define bh_reg 123
 366
 367 #define ax_reg 124
 368 #define cx_reg 125
 369 #define dx_reg 126
 370 #define bx_reg 127
 371 #define sp_reg 128
 372 #define bp_reg 129
 373 #define si_reg 130
 374 #define di_reg 131
 375
 376 #define rAX_reg 132
 377 #define rCX_reg 133
 378 #define rDX_reg 134
 379 #define rBX_reg 135
 380 #define rSP_reg 136
 381 #define rBP_reg 137
 382 #define rSI_reg 138
 383 #define rDI_reg 139
 384
 385 #define indir_dx_reg 150
 386
 387 #define FLOATCODE 1
 388 #define USE_GROUPS 2
 389 #define USE_PREFIX_USER_TABLE 3
 390 #define X86_64_SPECIAL 4
 391
 392 #define FLOAT     NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
 393
 394 #define GRP1b     NULL, NULL, USE_GROUPS, NULL,  0, NULL, 0
 395 #define GRP1S     NULL, NULL, USE_GROUPS, NULL,  1, NULL, 0
 396 #define GRP1Ss    NULL, NULL, USE_GROUPS, NULL,  2, NULL, 0
 397 #define GRP2b     NULL, NULL, USE_GROUPS, NULL,  3, NULL, 0
 398 #define GRP2S     NULL, NULL, USE_GROUPS, NULL,  4, NULL, 0
 399 #define GRP2b_one NULL, NULL, USE_GROUPS, NULL,  5, NULL, 0
 400 #define GRP2S_one NULL, NULL, USE_GROUPS, NULL,  6, NULL, 0
 401 #define GRP2b_cl  NULL, NULL, USE_GROUPS, NULL,  7, NULL, 0
 402 #define GRP2S_cl  NULL, NULL, USE_GROUPS, NULL,  8, NULL, 0
 403 #define GRP3b     NULL, NULL, USE_GROUPS, NULL,  9, NULL, 0
 404 #define GRP3S     NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0
 405 #define GRP4      NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0
 406 #define GRP5      NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0
 407 #define GRP6      NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0
 408 #define GRP7      NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0
 409 #define GRP8      NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0
 410 #define GRP9      NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0
 411 #define GRP10     NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0
 412 #define GRP11     NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0
 413 #define GRP12     NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0
 414 #define GRP13     NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
 415 #define GRP14     NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
 416 #define GRPAMD    NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
 417 #define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0
 418 #define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0
 419
 420 #define PREGRP0   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  0, NULL, 0
 421 #define PREGRP1   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  1, NULL, 0
 422 #define PREGRP2   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  2, NULL, 0
 423 #define PREGRP3   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  3, NULL, 0
 424 #define PREGRP4   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  4, NULL, 0
 425 #define PREGRP5   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  5, NULL, 0
 426 #define PREGRP6   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  6, NULL, 0
 427 #define PREGRP7   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  7, NULL, 0
 428 #define PREGRP8   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  8, NULL, 0
 429 #define PREGRP9   NULL, NULL, USE_PREFIX_USER_TABLE, NULL,  9, NULL, 0
 430 #define PREGRP10  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0
 431 #define PREGRP11  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0
 432 #define PREGRP12  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0
 433 #define PREGRP13  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0
 434 #define PREGRP14  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0
 435 #define PREGRP15  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0
 436 #define PREGRP16  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0
 437 #define PREGRP17  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0
 438 #define PREGRP18  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0
 439 #define PREGRP19  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0
 440 #define PREGRP20  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0
 441 #define PREGRP21  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0
 442 #define PREGRP22  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0
 443 #define PREGRP23  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0
 444 #define PREGRP24  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
 445 #define PREGRP25  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
 446 #define PREGRP26  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
 447 #define PREGRP27  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
 448 #define PREGRP28  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
 449 #define PREGRP29  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
 450 #define PREGRP30  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
 451 #define PREGRP31  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
 452 #define PREGRP32  NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
 453
 454 #define X86_64_0  NULL, NULL, X86_64_SPECIAL, NULL,  0, NULL, 0
 455
 456 typedef void (*op_rtn) (int bytemode, int sizeflag);
 457
 458 struct dis386 {
 459   const char *name;
 460   op_rtn op1;
 461   int bytemode1;
 462   op_rtn op2;
 463   int bytemode2;
 464   op_rtn op3;
 465   int bytemode3;
 466 };
 467
 468 /* Upper case letters in the instruction names here are macros.
 469    'A' => print 'b' if no register operands or suffix_always is true
 470    'B' => print 'b' if suffix_always is true
 471    'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
 472    .      size prefix
 473    'E' => print 'e' if 32-bit form of jcxz
 474    'F' => print 'w' or 'l' depending on address size prefix (loop insns)
 475    'H' => print ",pt" or ",pn" branch hint
 476    'I' => honor following macro letter even in Intel mode (implemented only
 477    .      for some of the macro letters)
 478    'J' => print 'l'
 479    'L' => print 'l' if suffix_always is true
 480    'N' => print 'n' if instruction has no wait "prefix"
 481    'O' => print 'd', or 'o'
 482    'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
 483    .      or suffix_always is true.  print 'q' if rex prefix is present.
 484    'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
 485    .      is true
 486    'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
 487    'S' => print 'w', 'l' or 'q' if suffix_always is true
 488    'T' => print 'q' in 64bit mode and behave as 'P' otherwise
 489    'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
 490    'V' => print 'q' in 64bit mode and behave as 'S' otherwise
 491    'W' => print 'b' or 'w' ("w" or "de" in intel mode)
 492    'X' => print 's', 'd' depending on data16 prefix (for XMM)
 493    'Y' => 'q' if instruction has an REX 64bit overwrite prefix
 494    'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
 495
 496    Many of the above letters print nothing in Intel mode.  See "putop"
 497    for the details.
 498
 499    Braces '{' and '}', and vertical bars '|', indicate alternative
 500    mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
 501    modes.  In cases where there are only two alternatives, the X86_64
 502    instruction is reserved, and "(bad)" is printed.
 503 */
 504
 505 static const struct dis386 dis386[] = {
 506   /* 00 */
 507   { "addB",             Eb, Gb, XX },
 508   { "addS",             Ev, Gv, XX },
 509   { "addB",             Gb, Eb, XX },
 510   { "addS",             Gv, Ev, XX },
 511   { "addB",             AL, Ib, XX },
 512   { "addS",             eAX, Iv, XX },
 513   { "push{T|}",         es, XX, XX },
 514   { "pop{T|}",          es, XX, XX },
 515   /* 08 */
 516   { "orB",              Eb, Gb, XX },
 517   { "orS",              Ev, Gv, XX },
 518   { "orB",              Gb, Eb, XX },
 519   { "orS",              Gv, Ev, XX },
 520   { "orB",              AL, Ib, XX },
 521   { "orS",              eAX, Iv, XX },
 522   { "push{T|}",         cs, XX, XX },
 523   { "(bad)",            XX, XX, XX },   /* 0x0f extended opcode escape */
 524   /* 10 */
 525   { "adcB",             Eb, Gb, XX },
 526   { "adcS",             Ev, Gv, XX },
 527   { "adcB",             Gb, Eb, XX },
 528   { "adcS",             Gv, Ev, XX },
 529   { "adcB",             AL, Ib, XX },
 530   { "adcS",             eAX, Iv, XX },
 531   { "push{T|}",         ss, XX, XX },
 532   { "pop{T|}",          ss, XX, XX },
 533   /* 18 */
 534   { "sbbB",             Eb, Gb, XX },
 535   { "sbbS",             Ev, Gv, XX },
 536   { "sbbB",             Gb, Eb, XX },
 537   { "sbbS",             Gv, Ev, XX },
 538   { "sbbB",             AL, Ib, XX },
 539   { "sbbS",             eAX, Iv, XX },
 540   { "push{T|}",         ds, XX, XX },
 541   { "pop{T|}",          ds, XX, XX },
 542   /* 20 */
 543   { "andB",             Eb, Gb, XX },
 544   { "andS",             Ev, Gv, XX },
 545   { "andB",             Gb, Eb, XX },
 546   { "andS",             Gv, Ev, XX },
 547   { "andB",             AL, Ib, XX },
 548   { "andS",             eAX, Iv, XX },
 549   { "(bad)",            XX, XX, XX },   /* SEG ES prefix */
 550   { "daa{|}",           XX, XX, XX },
 551   /* 28 */
 552   { "subB",             Eb, Gb, XX },
 553   { "subS",             Ev, Gv, XX },
 554   { "subB",             Gb, Eb, XX },
 555   { "subS",             Gv, Ev, XX },
 556   { "subB",             AL, Ib, XX },
 557   { "subS",             eAX, Iv, XX },
 558   { "(bad)",            XX, XX, XX },   /* SEG CS prefix */
 559   { "das{|}",           XX, XX, XX },
 560   /* 30 */
 561   { "xorB",             Eb, Gb, XX },
 562   { "xorS",             Ev, Gv, XX },
 563   { "xorB",             Gb, Eb, XX },
 564   { "xorS",             Gv, Ev, XX },
 565   { "xorB",             AL, Ib, XX },
 566   { "xorS",             eAX, Iv, XX },
 567   { "(bad)",            XX, XX, XX },   /* SEG SS prefix */
 568   { "aaa{|}",           XX, XX, XX },
 569   /* 38 */
 570   { "cmpB",             Eb, Gb, XX },
 571   { "cmpS",             Ev, Gv, XX },
 572   { "cmpB",             Gb, Eb, XX },
 573   { "cmpS",             Gv, Ev, XX },
 574   { "cmpB",             AL, Ib, XX },
 575   { "cmpS",             eAX, Iv, XX },
 576   { "(bad)",            XX, XX, XX },   /* SEG DS prefix */
 577   { "aas{|}",           XX, XX, XX },
 578   /* 40 */
 579   { "inc{S|}",          RMeAX, XX, XX },
 580   { "inc{S|}",          RMeCX, XX, XX },
 581   { "inc{S|}",          RMeDX, XX, XX },
 582   { "inc{S|}",          RMeBX, XX, XX },
 583   { "inc{S|}",          RMeSP, XX, XX },
 584   { "inc{S|}",          RMeBP, XX, XX },
 585   { "inc{S|}",          RMeSI, XX, XX },
 586   { "inc{S|}",          RMeDI, XX, XX },
 587   /* 48 */
 588   { "dec{S|}",          RMeAX, XX, XX },
 589   { "dec{S|}",          RMeCX, XX, XX },
 590   { "dec{S|}",          RMeDX, XX, XX },
 591   { "dec{S|}",          RMeBX, XX, XX },
 592   { "dec{S|}",          RMeSP, XX, XX },
 593   { "dec{S|}",          RMeBP, XX, XX },
 594   { "dec{S|}",          RMeSI, XX, XX },
 595   { "dec{S|}",          RMeDI, XX, XX },
 596   /* 50 */
 597   { "pushV",            RMrAX, XX, XX },
 598   { "pushV",            RMrCX, XX, XX },
 599   { "pushV",            RMrDX, XX, XX },
 600   { "pushV",            RMrBX, XX, XX },
 601   { "pushV",            RMrSP, XX, XX },
 602   { "pushV",            RMrBP, XX, XX },
 603   { "pushV",            RMrSI, XX, XX },
 604   { "pushV",            RMrDI, XX, XX },
 605   /* 58 */
 606   { "popV",             RMrAX, XX, XX },
 607   { "popV",             RMrCX, XX, XX },
 608   { "popV",             RMrDX, XX, XX },
 609   { "popV",             RMrBX, XX, XX },
 610   { "popV",             RMrSP, XX, XX },
 611   { "popV",             RMrBP, XX, XX },
 612   { "popV",             RMrSI, XX, XX },
 613   { "popV",             RMrDI, XX, XX },
 614   /* 60 */
 615   { "pusha{P|}",        XX, XX, XX },
 616   { "popa{P|}",         XX, XX, XX },
 617   { "bound{S|}",        Gv, Ma, XX },
 618   { X86_64_0 },
 619   { "(bad)",            XX, XX, XX },   /* seg fs */
 620   { "(bad)",            XX, XX, XX },   /* seg gs */
 621   { "(bad)",            XX, XX, XX },   /* op size prefix */
 622   { "(bad)",            XX, XX, XX },   /* adr size prefix */
 623   /* 68 */
 624   { "pushT",            Iq, XX, XX },
 625   { "imulS",            Gv, Ev, Iv },
 626   { "pushT",            sIb, XX, XX },
 627   { "imulS",            Gv, Ev, sIb },
 628   { "ins{b||b|}",       Yb, indirDX, XX },
 629   { "ins{R||R|}",       Yv, indirDX, XX },
 630   { "outs{b||b|}",      indirDX, Xb, XX },
 631   { "outs{R||R|}",      indirDX, Xv, XX },
 632   /* 70 */
 633   { "joH",              Jb, XX, cond_jump_flag },
 634   { "jnoH",             Jb, XX, cond_jump_flag },
 635   { "jbH",              Jb, XX, cond_jump_flag },
 636   { "jaeH",             Jb, XX, cond_jump_flag },
 637   { "jeH",              Jb, XX, cond_jump_flag },
 638   { "jneH",             Jb, XX, cond_jump_flag },
 639   { "jbeH",             Jb, XX, cond_jump_flag },
 640   { "jaH",              Jb, XX, cond_jump_flag },
 641   /* 78 */
 642   { "jsH",              Jb, XX, cond_jump_flag },
 643   { "jnsH",             Jb, XX, cond_jump_flag },
 644   { "jpH",              Jb, XX, cond_jump_flag },
 645   { "jnpH",             Jb, XX, cond_jump_flag },
 646   { "jlH",              Jb, XX, cond_jump_flag },
 647   { "jgeH",             Jb, XX, cond_jump_flag },
 648   { "jleH",             Jb, XX, cond_jump_flag },
 649   { "jgH",              Jb, XX, cond_jump_flag },
 650   /* 80 */
 651   { GRP1b },
 652   { GRP1S },
 653   { "(bad)",            XX, XX, XX },
 654   { GRP1Ss },
 655   { "testB",            Eb, Gb, XX },
 656   { "testS",            Ev, Gv, XX },
 657   { "xchgB",            Eb, Gb, XX },
 658   { "xchgS",            Ev, Gv, XX },
 659   /* 88 */
 660   { "movB",             Eb, Gb, XX },
 661   { "movS",             Ev, Gv, XX },
 662   { "movB",             Gb, Eb, XX },
 663   { "movS",             Gv, Ev, XX },
 664   { "movQ",             Sv, Sw, XX },
 665   { "leaS",             Gv, M, XX },
 666   { "movQ",             Sw, Sv, XX },
 667   { "popU",             stackEv, XX, XX },
 668   /* 90 */
 669   { "nop",              NOP_Fixup, 0, XX, XX },
 670   { "xchgS",            RMeCX, eAX, XX },
 671   { "xchgS",            RMeDX, eAX, XX },
 672   { "xchgS",            RMeBX, eAX, XX },
 673   { "xchgS",            RMeSP, eAX, XX },
 674   { "xchgS",            RMeBP, eAX, XX },
 675   { "xchgS",            RMeSI, eAX, XX },
 676   { "xchgS",            RMeDI, eAX, XX },
 677   /* 98 */
 678   { "cW{tR||tR|}",      XX, XX, XX },
 679   { "cR{tO||tO|}",      XX, XX, XX },
 680   { "Jcall{T|}",        Ap, XX, XX },
 681   { "(bad)",            XX, XX, XX },   /* fwait */
 682   { "pushfT",           XX, XX, XX },
 683   { "popfT",            XX, XX, XX },
 684   { "sahf{|}",          XX, XX, XX },
 685   { "lahf{|}",          XX, XX, XX },
 686   /* a0 */
 687   { "movB",             AL, Ob, XX },
 688   { "movS",             eAX, Ov, XX },
 689   { "movB",             Ob, AL, XX },
 690   { "movS",             Ov, eAX, XX },
 691   { "movs{b||b|}",      Yb, Xb, XX },
 692   { "movs{R||R|}",      Yv, Xv, XX },
 693   { "cmps{b||b|}",      Xb, Yb, XX },
 694   { "cmps{R||R|}",      Xv, Yv, XX },
 695   /* a8 */
 696   { "testB",            AL, Ib, XX },
 697   { "testS",            eAX, Iv, XX },
 698   { "stosB",            Yb, AL, XX },
 699   { "stosS",            Yv, eAX, XX },
 700   { "lodsB",            AL, Xb, XX },
 701   { "lodsS",            eAX, Xv, XX },
 702   { "scasB",            AL, Yb, XX },
 703   { "scasS",            eAX, Yv, XX },
 704   /* b0 */
 705   { "movB",             RMAL, Ib, XX },
 706   { "movB",             RMCL, Ib, XX },
 707   { "movB",             RMDL, Ib, XX },
 708   { "movB",             RMBL, Ib, XX },
 709   { "movB",             RMAH, Ib, XX },
 710   { "movB",             RMCH, Ib, XX },
 711   { "movB",             RMDH, Ib, XX },
 712   { "movB",             RMBH, Ib, XX },
 713   /* b8 */
 714   { "movS",             RMeAX, Iv64, XX },
 715   { "movS",             RMeCX, Iv64, XX },
 716   { "movS",             RMeDX, Iv64, XX },
 717   { "movS",             RMeBX, Iv64, XX },
 718   { "movS",             RMeSP, Iv64, XX },
 719   { "movS",             RMeBP, Iv64, XX },
 720   { "movS",             RMeSI, Iv64, XX },
 721   { "movS",             RMeDI, Iv64, XX },
 722   /* c0 */
 723   { GRP2b },
 724   { GRP2S },
 725   { "retT",             Iw, XX, XX },
 726   { "retT",             XX, XX, XX },
 727   { "les{S|}",          Gv, Mp, XX },
 728   { "ldsS",             Gv, Mp, XX },
 729   { "movA",             Eb, Ib, XX },
 730   { "movQ",             Ev, Iv, XX },
 731   /* c8 */
 732   { "enterT",           Iw, Ib, XX },
 733   { "leaveT",           XX, XX, XX },
 734   { "lretP",            Iw, XX, XX },
 735   { "lretP",            XX, XX, XX },
 736   { "int3",             XX, XX, XX },
 737   { "int",              Ib, XX, XX },
 738   { "into{|}",          XX, XX, XX },
 739   { "iretP",            XX, XX, XX },
 740   /* d0 */
 741   { GRP2b_one },
 742   { GRP2S_one },
 743   { GRP2b_cl },
 744   { GRP2S_cl },
 745   { "aam{|}",           sIb, XX, XX },
 746   { "aad{|}",           sIb, XX, XX },
 747   { "(bad)",            XX, XX, XX },
 748   { "xlat",             DSBX, XX, XX },
 749   /* d8 */
 750   { FLOAT },
 751   { FLOAT },
 752   { FLOAT },
 753   { FLOAT },
 754   { FLOAT },
 755   { FLOAT },
 756   { FLOAT },
 757   { FLOAT },
 758   /* e0 */
 759   { "loopneFH",         Jb, XX, loop_jcxz_flag },
 760   { "loopeFH",          Jb, XX, loop_jcxz_flag },
 761   { "loopFH",           Jb, XX, loop_jcxz_flag },
 762   { "jEcxzH",           Jb, XX, loop_jcxz_flag },
 763   { "inB",              AL, Ib, XX },
 764   { "inS",              eAX, Ib, XX },
 765   { "outB",             Ib, AL, XX },
 766   { "outS",             Ib, eAX, XX },
 767   /* e8 */
 768   { "callT",            Jv, XX, XX },
 769   { "jmpT",             Jv, XX, XX },
 770   { "Jjmp{T|}",         Ap, XX, XX },
 771   { "jmp",              Jb, XX, XX },
 772   { "inB",              AL, indirDX, XX },
 773   { "inS",              eAX, indirDX, XX },
 774   { "outB",             indirDX, AL, XX },
 775   { "outS",             indirDX, eAX, XX },
 776   /* f0 */
 777   { "(bad)",            XX, XX, XX },   /* lock prefix */
 778   { "icebp",            XX, XX, XX },
 779   { "(bad)",            XX, XX, XX },   /* repne */
 780   { "(bad)",            XX, XX, XX },   /* repz */
 781   { "hlt",              XX, XX, XX },
 782   { "cmc",              XX, XX, XX },
 783   { GRP3b },
 784   { GRP3S },
 785   /* f8 */
 786   { "clc",              XX, XX, XX },
 787   { "stc",              XX, XX, XX },
 788   { "cli",              XX, XX, XX },
 789   { "sti",              XX, XX, XX },
 790   { "cld",              XX, XX, XX },
 791   { "std",              XX, XX, XX },
 792   { GRP4 },
 793   { GRP5 },
 794 };
 795
 796 static const struct dis386 dis386_twobyte[] = {
 797   /* 00 */
 798   { GRP6 },
 799   { GRP7 },
 800   { "larS",             Gv, Ew, XX },
 801   { "lslS",             Gv, Ew, XX },
 802   { "(bad)",            XX, XX, XX },
 803   { "syscall",          XX, XX, XX },
 804   { "clts",             XX, XX, XX },
 805   { "sysretP",          XX, XX, XX },
 806   /* 08 */
 807   { "invd",             XX, XX, XX },
 808   { "wbinvd",           XX, XX, XX },
 809   { "(bad)",            XX, XX, XX },
 810   { "ud2a",             XX, XX, XX },
 811   { "(bad)",            XX, XX, XX },
 812   { GRPAMD },
 813   { "femms",            XX, XX, XX },
 814   { "",                 MX, EM, OPSUF }, /* See OP_3DNowSuffix.  */
 815   /* 10 */
 816   { PREGRP8 },
 817   { PREGRP9 },
 818   { PREGRP30 },
 819   { "movlpX",           EX, XM, SIMD_Fixup, 'h' },
 820   { "unpcklpX",         XM, EX, XX },
 821   { "unpckhpX",         XM, EX, XX },
 822   { PREGRP31 },
 823   { "movhpX",           EX, XM, SIMD_Fixup, 'l' },
 824   /* 18 */
 825   { GRP14 },
 826   { "(bad)",            XX, XX, XX },
 827   { "(bad)",            XX, XX, XX },
 828   { "(bad)",            XX, XX, XX },
 829   { "(bad)",            XX, XX, XX },
 830   { "(bad)",            XX, XX, XX },
 831   { "(bad)",            XX, XX, XX },
 832   { "(bad)",            XX, XX, XX },
 833   /* 20 */
 834   { "movZ",             Rm, Cm, XX },
 835   { "movL",             Rm, Dm, XX },
 836   { "movZ",             Cm, Rm, XX },
 837   { "movL",             Dm, Rm, XX },
 838   { "movL",             Rd, Td, XX },
 839   { "(bad)",            XX, XX, XX },
 840   { "movL",             Td, Rd, XX },
 841   { "(bad)",            XX, XX, XX },
 842   /* 28 */
 843   { "movapX",           XM, EX, XX },
 844   { "movapX",           EX, XM, XX },
 845   { PREGRP2 },
 846   { "movntpX",          Ev, XM, XX },
 847   { PREGRP4 },
 848   { PREGRP3 },
 849   { "ucomisX",          XM,EX, XX },
 850   { "comisX",           XM,EX, XX },
 851   /* 30 */
 852   { "wrmsr",            XX, XX, XX },
 853   { "rdtsc",            XX, XX, XX },
 854   { "rdmsr",            XX, XX, XX },
 855   { "rdpmc",            XX, XX, XX },
 856   { "sysenter",         XX, XX, XX },
 857   { "sysexit",          XX, XX, XX },
 858   { "(bad)",            XX, XX, XX },
 859   { "(bad)",            XX, XX, XX },
 860   /* 38 */
 861   { "(bad)",            XX, XX, XX },
 862   { "(bad)",            XX, XX, XX },
 863   { "(bad)",            XX, XX, XX },
 864   { "(bad)",            XX, XX, XX },
 865   { "(bad)",            XX, XX, XX },
 866   { "(bad)",            XX, XX, XX },
 867   { "(bad)",            XX, XX, XX },
 868   { "(bad)",            XX, XX, XX },
 869   /* 40 */
 870   { "cmovo",            Gv, Ev, XX },
 871   { "cmovno",           Gv, Ev, XX },
 872   { "cmovb",            Gv, Ev, XX },
 873   { "cmovae",           Gv, Ev, XX },
 874   { "cmove",            Gv, Ev, XX },
 875   { "cmovne",           Gv, Ev, XX },
 876   { "cmovbe",           Gv, Ev, XX },
 877   { "cmova",            Gv, Ev, XX },
 878   /* 48 */
 879   { "cmovs",            Gv, Ev, XX },
 880   { "cmovns",           Gv, Ev, XX },
 881   { "cmovp",            Gv, Ev, XX },
 882   { "cmovnp",           Gv, Ev, XX },
 883   { "cmovl",            Gv, Ev, XX },
 884   { "cmovge",           Gv, Ev, XX },
 885   { "cmovle",           Gv, Ev, XX },
 886   { "cmovg",            Gv, Ev, XX },
 887   /* 50 */
 888   { "movmskpX",         Gdq, XS, XX },
 889   { PREGRP13 },
 890   { PREGRP12 },
 891   { PREGRP11 },
 892   { "andpX",            XM, EX, XX },
 893   { "andnpX",           XM, EX, XX },
 894   { "orpX",             XM, EX, XX },
 895   { "xorpX",            XM, EX, XX },
 896   /* 58 */
 897   { PREGRP0 },
 898   { PREGRP10 },
 899   { PREGRP17 },
 900   { PREGRP16 },
 901   { PREGRP14 },
 902   { PREGRP7 },
 903   { PREGRP5 },
 904   { PREGRP6 },
 905   /* 60 */
 906   { "punpcklbw",        MX, EM, XX },
 907   { "punpcklwd",        MX, EM, XX },
 908   { "punpckldq",        MX, EM, XX },
 909   { "packsswb",         MX, EM, XX },
 910   { "pcmpgtb",          MX, EM, XX },
 911   { "pcmpgtw",          MX, EM, XX },
 912   { "pcmpgtd",          MX, EM, XX },
 913   { "packuswb",         MX, EM, XX },
 914   /* 68 */
 915   { "punpckhbw",        MX, EM, XX },
 916   { "punpckhwd",        MX, EM, XX },
 917   { "punpckhdq",        MX, EM, XX },
 918   { "packssdw",         MX, EM, XX },
 919   { PREGRP26 },
 920   { PREGRP24 },
 921   { "movd",             MX, Edq, XX },
 922   { PREGRP19 },
 923   /* 70 */
 924   { PREGRP22 },
 925   { GRP10 },
 926   { GRP11 },
 927   { GRP12 },
 928   { "pcmpeqb",          MX, EM, XX },
 929   { "pcmpeqw",          MX, EM, XX },
 930   { "pcmpeqd",          MX, EM, XX },
 931   { "emms",             XX, XX, XX },
 932   /* 78 */
 933   { "vmread",           Em, Gm, XX },
 934   { "vmwrite",          Gm, Em, XX },
 935   { "(bad)",            XX, XX, XX },
 936   { "(bad)",            XX, XX, XX },
 937   { PREGRP28 },
 938   { PREGRP29 },
 939   { PREGRP23 },
 940   { PREGRP20 },
 941   /* 80 */
 942   { "joH",              Jv, XX, cond_jump_flag },
 943   { "jnoH",             Jv, XX, cond_jump_flag },
 944   { "jbH",              Jv, XX, cond_jump_flag },
 945   { "jaeH",             Jv, XX, cond_jump_flag },
 946   { "jeH",              Jv, XX, cond_jump_flag },
 947   { "jneH",             Jv, XX, cond_jump_flag },
 948   { "jbeH",             Jv, XX, cond_jump_flag },
 949   { "jaH",              Jv, XX, cond_jump_flag },
 950   /* 88 */
 951   { "jsH",              Jv, XX, cond_jump_flag },
 952   { "jnsH",             Jv, XX, cond_jump_flag },
 953   { "jpH",              Jv, XX, cond_jump_flag },
 954   { "jnpH",             Jv, XX, cond_jump_flag },
 955   { "jlH",              Jv, XX, cond_jump_flag },
 956   { "jgeH",             Jv, XX, cond_jump_flag },
 957   { "jleH",             Jv, XX, cond_jump_flag },
 958   { "jgH",              Jv, XX, cond_jump_flag },
 959   /* 90 */
 960   { "seto",             Eb, XX, XX },
 961   { "setno",            Eb, XX, XX },
 962   { "setb",             Eb, XX, XX },
 963   { "setae",            Eb, XX, XX },
 964   { "sete",             Eb, XX, XX },
 965   { "setne",            Eb, XX, XX },
 966   { "setbe",            Eb, XX, XX },
 967   { "seta",             Eb, XX, XX },
 968   /* 98 */
 969   { "sets",             Eb, XX, XX },
 970   { "setns",            Eb, XX, XX },
 971   { "setp",             Eb, XX, XX },
 972   { "setnp",            Eb, XX, XX },
 973   { "setl",             Eb, XX, XX },
 974   { "setge",            Eb, XX, XX },
 975   { "setle",            Eb, XX, XX },
 976   { "setg",             Eb, XX, XX },
 977   /* a0 */
 978   { "pushT",            fs, XX, XX },
 979   { "popT",             fs, XX, XX },
 980   { "cpuid",            XX, XX, XX },
 981   { "btS",              Ev, Gv, XX },
 982   { "shldS",            Ev, Gv, Ib },
 983   { "shldS",            Ev, Gv, CL },
 984   { GRPPADLCK2 },
 985   { GRPPADLCK1 },
 986   /* a8 */
 987   { "pushT",            gs, XX, XX },
 988   { "popT",             gs, XX, XX },
 989   { "rsm",              XX, XX, XX },
 990   { "btsS",             Ev, Gv, XX },
 991   { "shrdS",            Ev, Gv, Ib },
 992   { "shrdS",            Ev, Gv, CL },
 993   { GRP13 },
 994   { "imulS",            Gv, Ev, XX },
 995   /* b0 */
 996   { "cmpxchgB",         Eb, Gb, XX },
 997   { "cmpxchgS",         Ev, Gv, XX },
 998   { "lssS",             Gv, Mp, XX },
 999   { "btrS",             Ev, Gv, XX },
1000   { "lfsS",             Gv, Mp, XX },
1001   { "lgsS",             Gv, Mp, XX },
1002   { "movz{bR|x|bR|x}",  Gv, Eb, XX },
1003   { "movz{wR|x|wR|x}",  Gv, Ew, XX }, /* yes, there really is movzww ! */
1004   /* b8 */
1005   { "(bad)",            XX, XX, XX },
1006   { "ud2b",             XX, XX, XX },
1007   { GRP8 },
1008   { "btcS",             Ev, Gv, XX },
1009   { "bsfS",             Gv, Ev, XX },
1010   { "bsrS",             Gv, Ev, XX },
1011   { "movs{bR|x|bR|x}",  Gv, Eb, XX },
1012   { "movs{wR|x|wR|x}",  Gv, Ew, XX }, /* yes, there really is movsww ! */
1013   /* c0 */
1014   { "xaddB",            Eb, Gb, XX },
1015   { "xaddS",            Ev, Gv, XX },
1016   { PREGRP1 },
1017   { "movntiS",          Ev, Gv, XX },
1018   { "pinsrw",           MX, Edqw, Ib },
1019   { "pextrw",           Gdq, MS, Ib },
1020   { "shufpX",           XM, EX, Ib },
1021   { GRP9 },
1022   /* c8 */
1023   { "bswap",            RMeAX, XX, XX },
1024   { "bswap",            RMeCX, XX, XX },
1025   { "bswap",            RMeDX, XX, XX },
1026   { "bswap",            RMeBX, XX, XX },
1027   { "bswap",            RMeSP, XX, XX },
1028   { "bswap",            RMeBP, XX, XX },
1029   { "bswap",            RMeSI, XX, XX },
1030   { "bswap",            RMeDI, XX, XX },
1031   /* d0 */
1032   { PREGRP27 },
1033   { "psrlw",            MX, EM, XX },
1034   { "psrld",            MX, EM, XX },
1035   { "psrlq",            MX, EM, XX },
1036   { "paddq",            MX, EM, XX },
1037   { "pmullw",           MX, EM, XX },
1038   { PREGRP21 },
1039   { "pmovmskb",         Gdq, MS, XX },
1040   /* d8 */
1041   { "psubusb",          MX, EM, XX },
1042   { "psubusw",          MX, EM, XX },
1043   { "pminub",           MX, EM, XX },
1044   { "pand",             MX, EM, XX },
1045   { "paddusb",          MX, EM, XX },
1046   { "paddusw",          MX, EM, XX },
1047   { "pmaxub",           MX, EM, XX },
1048   { "pandn",            MX, EM, XX },
1049   /* e0 */
1050   { "pavgb",            MX, EM, XX },
1051   { "psraw",            MX, EM, XX },
1052   { "psrad",            MX, EM, XX },
1053   { "pavgw",            MX, EM, XX },
1054   { "pmulhuw",          MX, EM, XX },
1055   { "pmulhw",           MX, EM, XX },
1056   { PREGRP15 },
1057   { PREGRP25 },
1058   /* e8 */
1059   { "psubsb",           MX, EM, XX },
1060   { "psubsw",           MX, EM, XX },
1061   { "pminsw",           MX, EM, XX },
1062   { "por",              MX, EM, XX },
1063   { "paddsb",           MX, EM, XX },
1064   { "paddsw",           MX, EM, XX },
1065   { "pmaxsw",           MX, EM, XX },
1066   { "pxor",             MX, EM, XX },
1067   /* f0 */
1068   { PREGRP32 },
1069   { "psllw",            MX, EM, XX },
1070   { "pslld",            MX, EM, XX },
1071   { "psllq",            MX, EM, XX },
1072   { "pmuludq",          MX, EM, XX },
1073   { "pmaddwd",          MX, EM, XX },
1074   { "psadbw",           MX, EM, XX },
1075   { PREGRP18 },
1076   /* f8 */
1077   { "psubb",            MX, EM, XX },
1078   { "psubw",            MX, EM, XX },
1079   { "psubd",            MX, EM, XX },
1080   { "psubq",            MX, EM, XX },
1081   { "paddb",            MX, EM, XX },
1082   { "paddw",            MX, EM, XX },
1083   { "paddd",            MX, EM, XX },
1084   { "(bad)",            XX, XX, XX }
1085 };
1086
1087 static const unsigned char onebyte_has_modrm[256] = {
1088   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1089   /*       -------------------------------        */
1090   /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1091   /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1092   /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1093   /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1094   /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1095   /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1096   /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1097   /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1098   /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1099   /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1100   /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1101   /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1102   /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1103   /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1104   /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1105   /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1  /* f0 */
1106   /*       -------------------------------        */
1107   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1108 };
1109
1110 static const unsigned char twobyte_has_modrm[256] = {
1111   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1112   /*       -------------------------------        */
1113   /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1114   /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
1115   /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1116   /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1117   /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1118   /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1119   /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1120   /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1121   /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1122   /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1123   /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1124   /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
1125   /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1126   /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1127   /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1128   /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  /* ff */
1129   /*       -------------------------------        */
1130   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1131 };
1132
1133 static const unsigned char twobyte_uses_SSE_prefix[256] = {
1134   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1135   /*       -------------------------------        */
1136   /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1137   /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1138   /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
1139   /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1140   /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1141   /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1142   /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1143   /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
1144   /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1145   /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1146   /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1147   /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1148   /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1149   /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1150   /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1151   /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  /* ff */
1152   /*       -------------------------------        */
1153   /*       0 1 2 3 4 5 6 7 8 9 a b c d e f        */
1154 };
1155
1156 static char obuf[100];
1157 static char *obufp;
1158 static char scratchbuf[100];
1159 static unsigned char *start_codep;
1160 static unsigned char *insn_codep;
1161 static unsigned char *codep;
1162 static disassemble_info *the_info;
1163 static int mod;
1164 static int rm;
1165 static int reg;
1166 static unsigned char need_modrm;
1167
1168 /* If we are accessing mod/rm/reg without need_modrm set, then the
1169    values are stale.  Hitting this abort likely indicates that you
1170    need to update onebyte_has_modrm or twobyte_has_modrm.  */
1171 #define MODRM_CHECK  if (!need_modrm) abort ()
1172
1173 static const char **names64;
1174 static const char **names32;
1175 static const char **names16;
1176 static const char **names8;
1177 static const char **names8rex;
1178 static const char **names_seg;
1179 static const char **index16;
1180
1181 static const char *intel_names64[] = {
1182   "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1183   "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1184 };
1185 static const char *intel_names32[] = {
1186   "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1187   "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1188 };
1189 static const char *intel_names16[] = {
1190   "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1191   "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1192 };
1193 static const char *intel_names8[] = {
1194   "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1195 };
1196 static const char *intel_names8rex[] = {
1197   "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1198   "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1199 };
1200 static const char *intel_names_seg[] = {
1201   "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1202 };
1203 static const char *intel_index16[] = {
1204   "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1205 };
1206
1207 static const char *att_names64[] = {
1208   "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1209   "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1210 };
1211 static const char *att_names32[] = {
1212   "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1213   "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1214 };
1215 static const char *att_names16[] = {
1216   "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1217   "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1218 };
1219 static const char *att_names8[] = {
1220   "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1221 };
1222 static const char *att_names8rex[] = {
1223   "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1224   "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1225 };
1226 static const char *att_names_seg[] = {
1227   "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1228 };
1229 static const char *att_index16[] = {
1230   "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1231 };
1232
1233 static const struct dis386 grps[][8] = {
1234   /* GRP1b */
1235   {
1236     { "addA",   Eb, Ib, XX },
1237     { "orA",    Eb, Ib, XX },
1238     { "adcA",   Eb, Ib, XX },
1239     { "sbbA",   Eb, Ib, XX },
1240     { "andA",   Eb, Ib, XX },
1241     { "subA",   Eb, Ib, XX },
1242     { "xorA",   Eb, Ib, XX },
1243     { "cmpA",   Eb, Ib, XX }
1244   },
1245   /* GRP1S */
1246   {
1247     { "addQ",   Ev, Iv, XX },
1248     { "orQ",    Ev, Iv, XX },
1249     { "adcQ",   Ev, Iv, XX },
1250     { "sbbQ",   Ev, Iv, XX },
1251     { "andQ",   Ev, Iv, XX },
1252     { "subQ",   Ev, Iv, XX },
1253     { "xorQ",   Ev, Iv, XX },
1254     { "cmpQ",   Ev, Iv, XX }
1255   },
1256   /* GRP1Ss */
1257   {
1258     { "addQ",   Ev, sIb, XX },
1259     { "orQ",    Ev, sIb, XX },
1260     { "adcQ",   Ev, sIb, XX },
1261     { "sbbQ",   Ev, sIb, XX },
1262     { "andQ",   Ev, sIb, XX },
1263     { "subQ",   Ev, sIb, XX },
1264     { "xorQ",   Ev, sIb, XX },
1265     { "cmpQ",   Ev, sIb, XX }
1266   },
1267   /* GRP2b */
1268   {
1269     { "rolA",   Eb, Ib, XX },
1270     { "rorA",   Eb, Ib, XX },
1271     { "rclA",   Eb, Ib, XX },
1272     { "rcrA",   Eb, Ib, XX },
1273     { "shlA",   Eb, Ib, XX },
1274     { "shrA",   Eb, Ib, XX },
1275     { "(bad)",  XX, XX, XX },
1276     { "sarA",   Eb, Ib, XX },
1277   },
1278   /* GRP2S */
1279   {
1280     { "rolQ",   Ev, Ib, XX },
1281     { "rorQ",   Ev, Ib, XX },
1282     { "rclQ",   Ev, Ib, XX },
1283     { "rcrQ",   Ev, Ib, XX },
1284     { "shlQ",   Ev, Ib, XX },
1285     { "shrQ",   Ev, Ib, XX },
1286     { "(bad)",  XX, XX, XX },
1287     { "sarQ",   Ev, Ib, XX },
1288   },
1289   /* GRP2b_one */
1290   {
1291     { "rolA",   Eb, I1, XX },
1292     { "rorA",   Eb, I1, XX },
1293     { "rclA",   Eb, I1, XX },
1294     { "rcrA",   Eb, I1, XX },
1295     { "shlA",   Eb, I1, XX },
1296     { "shrA",   Eb, I1, XX },
1297     { "(bad)",  XX, XX, XX },
1298     { "sarA",   Eb, I1, XX },
1299   },
1300   /* GRP2S_one */
1301   {
1302     { "rolQ",   Ev, I1, XX },
1303     { "rorQ",   Ev, I1, XX },
1304     { "rclQ",   Ev, I1, XX },
1305     { "rcrQ",   Ev, I1, XX },
1306     { "shlQ",   Ev, I1, XX },
1307     { "shrQ",   Ev, I1, XX },
1308     { "(bad)",  XX, XX, XX},
1309     { "sarQ",   Ev, I1, XX },
1310   },
1311   /* GRP2b_cl */
1312   {
1313     { "rolA",   Eb, CL, XX },
1314     { "rorA",   Eb, CL, XX },
1315     { "rclA",   Eb, CL, XX },
1316     { "rcrA",   Eb, CL, XX },
1317     { "shlA",   Eb, CL, XX },
1318     { "shrA",   Eb, CL, XX },
1319     { "(bad)",  XX, XX, XX },
1320     { "sarA",   Eb, CL, XX },
1321   },
1322   /* GRP2S_cl */
1323   {
1324     { "rolQ",   Ev, CL, XX },
1325     { "rorQ",   Ev, CL, XX },
1326     { "rclQ",   Ev, CL, XX },
1327     { "rcrQ",   Ev, CL, XX },
1328     { "shlQ",   Ev, CL, XX },
1329     { "shrQ",   Ev, CL, XX },
1330     { "(bad)",  XX, XX, XX },
1331     { "sarQ",   Ev, CL, XX }
1332   },
1333   /* GRP3b */
1334   {
1335     { "testA",  Eb, Ib, XX },
1336     { "(bad)",  Eb, XX, XX },
1337     { "notA",   Eb, XX, XX },
1338     { "negA",   Eb, XX, XX },
1339     { "mulA",   Eb, XX, XX },   /* Don't print the implicit %al register,  */
1340     { "imulA",  Eb, XX, XX },   /* to distinguish these opcodes from other */
1341     { "divA",   Eb, XX, XX },   /* mul/imul opcodes.  Do the same for div  */
1342     { "idivA",  Eb, XX, XX }    /* and idiv for consistency.               */
1343   },
1344   /* GRP3S */
1345   {
1346     { "testQ",  Ev, Iv, XX },
1347     { "(bad)",  XX, XX, XX },
1348     { "notQ",   Ev, XX, XX },
1349     { "negQ",   Ev, XX, XX },
1350     { "mulQ",   Ev, XX, XX },   /* Don't print the implicit register.  */
1351     { "imulQ",  Ev, XX, XX },
1352     { "divQ",   Ev, XX, XX },
1353     { "idivQ",  Ev, XX, XX },
1354   },
1355   /* GRP4 */
1356   {
1357     { "incA",   Eb, XX, XX },
1358     { "decA",   Eb, XX, XX },
1359     { "(bad)",  XX, XX, XX },
1360     { "(bad)",  XX, XX, XX },
1361     { "(bad)",  XX, XX, XX },
1362     { "(bad)",  XX, XX, XX },
1363     { "(bad)",  XX, XX, XX },
1364     { "(bad)",  XX, XX, XX },
1365   },
1366   /* GRP5 */
1367   {
1368     { "incQ",   Ev, XX, XX },
1369     { "decQ",   Ev, XX, XX },
1370     { "callT",  indirEv, XX, XX },
1371     { "JcallT", indirEp, XX, XX },
1372     { "jmpT",   indirEv, XX, XX },
1373     { "JjmpT",  indirEp, XX, XX },
1374     { "pushU",  stackEv, XX, XX },
1375     { "(bad)",  XX, XX, XX },
1376   },
1377   /* GRP6 */
1378   {
1379     { "sldtQ",  Ev, XX, XX },
1380     { "strQ",   Ev, XX, XX },
1381     { "lldt",   Ew, XX, XX },
1382     { "ltr",    Ew, XX, XX },
1383     { "verr",   Ew, XX, XX },
1384     { "verw",   Ew, XX, XX },
1385     { "(bad)",  XX, XX, XX },
1386     { "(bad)",  XX, XX, XX }
1387   },
1388   /* GRP7 */
1389   {
1390     { "sgdtIQ", VMX_Fixup, 0, XX, XX },
1391     { "sidtIQ", PNI_Fixup, 0, XX, XX },
1392     { "lgdt{Q|Q||}",     M, XX, XX },
1393     { "lidt{Q|Q||}",     SVME_Fixup, 0, XX, XX },
1394     { "smswQ",  Ev, XX, XX },
1395     { "(bad)",  XX, XX, XX },
1396     { "lmsw",   Ew, XX, XX },
1397     { "invlpg", INVLPG_Fixup, w_mode, XX, XX },
1398   },
1399   /* GRP8 */
1400   {
1401     { "(bad)",  XX, XX, XX },
1402     { "(bad)",  XX, XX, XX },
1403     { "(bad)",  XX, XX, XX },
1404     { "(bad)",  XX, XX, XX },
1405     { "btQ",    Ev, Ib, XX },
1406     { "btsQ",   Ev, Ib, XX },
1407     { "btrQ",   Ev, Ib, XX },
1408     { "btcQ",   Ev, Ib, XX },
1409   },
1410   /* GRP9 */
1411   {
1412     { "(bad)",  XX, XX, XX },
1413     { "cmpxchg8b", Eq, XX, XX },
1414     { "(bad)",  XX, XX, XX },
1415     { "(bad)",  XX, XX, XX },
1416     { "(bad)",  XX, XX, XX },
1417     { "(bad)",  XX, XX, XX },
1418     { "",       VM, XX, XX },           /* See OP_VMX.  */
1419     { "vmptrst", Eq, XX, XX },
1420   },
1421   /* GRP10 */
1422   {
1423     { "(bad)",  XX, XX, XX },
1424     { "(bad)",  XX, XX, XX },
1425     { "psrlw",  MS, Ib, XX },
1426     { "(bad)",  XX, XX, XX },
1427     { "psraw",  MS, Ib, XX },
1428     { "(bad)",  XX, XX, XX },
1429     { "psllw",  MS, Ib, XX },
1430     { "(bad)",  XX, XX, XX },
1431   },
1432   /* GRP11 */
1433   {
1434     { "(bad)",  XX, XX, XX },
1435     { "(bad)",  XX, XX, XX },
1436     { "psrld",  MS, Ib, XX },
1437     { "(bad)",  XX, XX, XX },
1438     { "psrad",  MS, Ib, XX },
1439     { "(bad)",  XX, XX, XX },
1440     { "pslld",  MS, Ib, XX },
1441     { "(bad)",  XX, XX, XX },
1442   },
1443   /* GRP12 */
1444   {
1445     { "(bad)",  XX, XX, XX },
1446     { "(bad)",  XX, XX, XX },
1447     { "psrlq",  MS, Ib, XX },
1448     { "psrldq", MS, Ib, XX },
1449     { "(bad)",  XX, XX, XX },
1450     { "(bad)",  XX, XX, XX },
1451     { "psllq",  MS, Ib, XX },
1452     { "pslldq", MS, Ib, XX },
1453   },
1454   /* GRP13 */
1455   {
1456     { "fxsave", Ev, XX, XX },
1457     { "fxrstor", Ev, XX, XX },
1458     { "ldmxcsr", Ev, XX, XX },
1459     { "stmxcsr", Ev, XX, XX },
1460     { "(bad)",  XX, XX, XX },
1461     { "lfence", OP_0fae, 0, XX, XX },
1462     { "mfence", OP_0fae, 0, XX, XX },
1463     { "clflush", OP_0fae, 0, XX, XX },
1464   },
1465   /* GRP14 */
1466   {
1467     { "prefetchnta", Ev, XX, XX },
1468     { "prefetcht0", Ev, XX, XX },
1469     { "prefetcht1", Ev, XX, XX },
1470     { "prefetcht2", Ev, XX, XX },
1471     { "(bad)",  XX, XX, XX },
1472     { "(bad)",  XX, XX, XX },
1473     { "(bad)",  XX, XX, XX },
1474     { "(bad)",  XX, XX, XX },
1475   },
1476   /* GRPAMD */
1477   {
1478     { "prefetch", Eb, XX, XX },
1479     { "prefetchw", Eb, XX, XX },
1480     { "(bad)",  XX, XX, XX },
1481     { "(bad)",  XX, XX, XX },
1482     { "(bad)",  XX, XX, XX },
1483     { "(bad)",  XX, XX, XX },
1484     { "(bad)",  XX, XX, XX },
1485     { "(bad)",  XX, XX, XX },
1486   },
1487   /* GRPPADLCK1 */
1488   {
1489     { "xstore-rng", OP_0f07, 0, XX, XX },
1490     { "xcrypt-ecb", OP_0f07, 0, XX, XX },
1491     { "xcrypt-cbc", OP_0f07, 0, XX, XX },
1492     { "xcrypt-ctr", OP_0f07, 0, XX, XX },
1493     { "xcrypt-cfb", OP_0f07, 0, XX, XX },
1494     { "xcrypt-ofb", OP_0f07, 0, XX, XX },
1495     { "(bad)",  OP_0f07, 0, XX, XX },
1496     { "(bad)",  OP_0f07, 0, XX, XX },
1497   },
1498   /* GRPPADLCK2 */
1499   {
1500     { "montmul", OP_0f07, 0, XX, XX },
1501     { "xsha1",   OP_0f07, 0, XX, XX },
1502     { "xsha256", OP_0f07, 0, XX, XX },
1503     { "(bad)",   OP_0f07, 0, XX, XX },
1504     { "(bad)",   OP_0f07, 0, XX, XX },
1505     { "(bad)",   OP_0f07, 0, XX, XX },
1506     { "(bad)",   OP_0f07, 0, XX, XX },
1507     { "(bad)",   OP_0f07, 0, XX, XX },
1508   }
1509 };
1510
1511 static const struct dis386 prefix_user_table[][4] = {
1512   /* PREGRP0 */
1513   {
1514     { "addps", XM, EX, XX },
1515     { "addss", XM, EX, XX },
1516     { "addpd", XM, EX, XX },
1517     { "addsd", XM, EX, XX },
1518   },
1519   /* PREGRP1 */
1520   {
1521     { "", XM, EX, OPSIMD },     /* See OP_SIMD_SUFFIX.  */
1522     { "", XM, EX, OPSIMD },
1523     { "", XM, EX, OPSIMD },
1524     { "", XM, EX, OPSIMD },
1525   },
1526   /* PREGRP2 */
1527   {
1528     { "cvtpi2ps", XM, EM, XX },
1529     { "cvtsi2ssY", XM, Ev, XX },
1530     { "cvtpi2pd", XM, EM, XX },
1531     { "cvtsi2sdY", XM, Ev, XX },
1532   },
1533   /* PREGRP3 */
1534   {
1535     { "cvtps2pi", MX, EX, XX },
1536     { "cvtss2siY", Gv, EX, XX },
1537     { "cvtpd2pi", MX, EX, XX },
1538     { "cvtsd2siY", Gv, EX, XX },
1539   },
1540   /* PREGRP4 */
1541   {
1542     { "cvttps2pi", MX, EX, XX },
1543     { "cvttss2siY", Gv, EX, XX },
1544     { "cvttpd2pi", MX, EX, XX },
1545     { "cvttsd2siY", Gv, EX, XX },
1546   },
1547   /* PREGRP5 */
1548   {
1549     { "divps", XM, EX, XX },
1550     { "divss", XM, EX, XX },
1551     { "divpd", XM, EX, XX },
1552     { "divsd", XM, EX, XX },
1553   },
1554   /* PREGRP6 */
1555   {
1556     { "maxps", XM, EX, XX },
1557     { "maxss", XM, EX, XX },
1558     { "maxpd", XM, EX, XX },
1559     { "maxsd", XM, EX, XX },
1560   },
1561   /* PREGRP7 */
1562   {
1563     { "minps", XM, EX, XX },
1564     { "minss", XM, EX, XX },
1565     { "minpd", XM, EX, XX },
1566     { "minsd", XM, EX, XX },
1567   },
1568   /* PREGRP8 */
1569   {
1570     { "movups", XM, EX, XX },
1571     { "movss", XM, EX, XX },
1572     { "movupd", XM, EX, XX },
1573     { "movsd", XM, EX, XX },
1574   },
1575   /* PREGRP9 */
1576   {
1577     { "movups", EX, XM, XX },
1578     { "movss", EX, XM, XX },
1579     { "movupd", EX, XM, XX },
1580     { "movsd", EX, XM, XX },
1581   },
1582   /* PREGRP10 */
1583   {
1584     { "mulps", XM, EX, XX },
1585     { "mulss", XM, EX, XX },
1586     { "mulpd", XM, EX, XX },
1587     { "mulsd", XM, EX, XX },
1588   },
1589   /* PREGRP11 */
1590   {
1591     { "rcpps", XM, EX, XX },
1592     { "rcpss", XM, EX, XX },
1593     { "(bad)", XM, EX, XX },
1594     { "(bad)", XM, EX, XX },
1595   },
1596   /* PREGRP12 */
1597   {
1598     { "rsqrtps", XM, EX, XX },
1599     { "rsqrtss", XM, EX, XX },
1600     { "(bad)", XM, EX, XX },
1601     { "(bad)", XM, EX, XX },
1602   },
1603   /* PREGRP13 */
1604   {
1605     { "sqrtps", XM, EX, XX },
1606     { "sqrtss", XM, EX, XX },
1607     { "sqrtpd", XM, EX, XX },
1608     { "sqrtsd", XM, EX, XX },
1609   },
1610   /* PREGRP14 */
1611   {
1612     { "subps", XM, EX, XX },
1613     { "subss", XM, EX, XX },
1614     { "subpd", XM, EX, XX },
1615     { "subsd", XM, EX, XX },
1616   },
1617   /* PREGRP15 */
1618   {
1619     { "(bad)", XM, EX, XX },
1620     { "cvtdq2pd", XM, EX, XX },
1621     { "cvttpd2dq", XM, EX, XX },
1622     { "cvtpd2dq", XM, EX, XX },
1623   },
1624   /* PREGRP16 */
1625   {
1626     { "cvtdq2ps", XM, EX, XX },
1627     { "cvttps2dq",XM, EX, XX },
1628     { "cvtps2dq",XM, EX, XX },
1629     { "(bad)", XM, EX, XX },
1630   },
1631   /* PREGRP17 */
1632   {
1633     { "cvtps2pd", XM, EX, XX },
1634     { "cvtss2sd", XM, EX, XX },
1635     { "cvtpd2ps", XM, EX, XX },
1636     { "cvtsd2ss", XM, EX, XX },
1637   },
1638   /* PREGRP18 */
1639   {
1640     { "maskmovq", MX, MS, XX },
1641     { "(bad)", XM, EX, XX },
1642     { "maskmovdqu", XM, EX, XX },
1643     { "(bad)", XM, EX, XX },
1644   },
1645   /* PREGRP19 */
1646   {
1647     { "movq", MX, EM, XX },
1648     { "movdqu", XM, EX, XX },
1649     { "movdqa", XM, EX, XX },
1650     { "(bad)", XM, EX, XX },
1651   },
1652   /* PREGRP20 */
1653   {
1654     { "movq", EM, MX, XX },
1655     { "movdqu", EX, XM, XX },
1656     { "movdqa", EX, XM, XX },
1657     { "(bad)", EX, XM, XX },
1658   },
1659   /* PREGRP21 */
1660   {
1661     { "(bad)", EX, XM, XX },
1662     { "movq2dq", XM, MS, XX },
1663     { "movq", EX, XM, XX },
1664     { "movdq2q", MX, XS, XX },
1665   },
1666   /* PREGRP22 */
1667   {
1668     { "pshufw", MX, EM, Ib },
1669     { "pshufhw", XM, EX, Ib },
1670     { "pshufd", XM, EX, Ib },
1671     { "pshuflw", XM, EX, Ib },
1672   },
1673   /* PREGRP23 */
1674   {
1675     { "movd", Edq, MX, XX },
1676     { "movq", XM, EX, XX },
1677     { "movd", Edq, XM, XX },
1678     { "(bad)", Ed, XM, XX },
1679   },
1680   /* PREGRP24 */
1681   {
1682     { "(bad)", MX, EX, XX },
1683     { "(bad)", XM, EX, XX },
1684     { "punpckhqdq", XM, EX, XX },
1685     { "(bad)", XM, EX, XX },
1686   },
1687   /* PREGRP25 */
1688   {
1689     { "movntq", EM, MX, XX },
1690     { "(bad)", EM, XM, XX },
1691     { "movntdq", EM, XM, XX },
1692     { "(bad)", EM, XM, XX },
1693   },
1694   /* PREGRP26 */
1695   {
1696     { "(bad)", MX, EX, XX },
1697     { "(bad)", XM, EX, XX },
1698     { "punpcklqdq", XM, EX, XX },
1699     { "(bad)", XM, EX, XX },
1700   },
1701   /* PREGRP27 */
1702   {
1703     { "(bad)", MX, EX, XX },
1704     { "(bad)", XM, EX, XX },
1705     { "addsubpd", XM, EX, XX },
1706     { "addsubps", XM, EX, XX },
1707   },
1708   /* PREGRP28 */
1709   {
1710     { "(bad)", MX, EX, XX },
1711     { "(bad)", XM, EX, XX },
1712     { "haddpd", XM, EX, XX },
1713     { "haddps", XM, EX, XX },
1714   },
1715   /* PREGRP29 */
1716   {
1717     { "(bad)", MX, EX, XX },
1718     { "(bad)", XM, EX, XX },
1719     { "hsubpd", XM, EX, XX },
1720     { "hsubps", XM, EX, XX },
1721   },
1722   /* PREGRP30 */
1723   {
1724     { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
1725     { "movsldup", XM, EX, XX },
1726     { "movlpd", XM, EX, XX },
1727     { "movddup", XM, EX, XX },
1728   },
1729   /* PREGRP31 */
1730   {
1731     { "movhpX", XM, EX, SIMD_Fixup, 'l' },
1732     { "movshdup", XM, EX, XX },
1733     { "movhpd", XM, EX, XX },
1734     { "(bad)", XM, EX, XX },
1735   },
1736   /* PREGRP32 */
1737   {
1738     { "(bad)", XM, EX, XX },
1739     { "(bad)", XM, EX, XX },
1740     { "(bad)", XM, EX, XX },
1741     { "lddqu", XM, M, XX },
1742   },
1743 };
1744
1745 static const struct dis386 x86_64_table[][2] = {
1746   {
1747     { "arpl", Ew, Gw, XX },
1748     { "movs{||lq|xd}", Gv, Ed, XX },
1749   },
1750 };
1751
1752 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
1753
1754 static void
1755 ckprefix (void)
1756 {
1757   int newrex;
1758   rex = 0;
1759   prefixes = 0;
1760   used_prefixes = 0;
1761   rex_used = 0;
1762   while (1)
1763     {
1764       FETCH_DATA (the_info, codep + 1);
1765       newrex = 0;
1766       switch (*codep)
1767         {
1768         /* REX prefixes family.  */
1769         case 0x40:
1770         case 0x41:
1771         case 0x42:
1772         case 0x43:
1773         case 0x44:
1774         case 0x45:
1775         case 0x46:
1776         case 0x47:
1777         case 0x48:
1778         case 0x49:
1779         case 0x4a:
1780         case 0x4b:
1781         case 0x4c:
1782         case 0x4d:
1783         case 0x4e:
1784         case 0x4f:
1785             if (address_mode == mode_64bit)
1786               newrex = *codep;
1787             else
1788               return;
1789           break;
1790         case 0xf3:
1791           prefixes |= PREFIX_REPZ;
1792           break;
1793         case 0xf2:
1794           prefixes |= PREFIX_REPNZ;
1795           break;
1796         case 0xf0:
1797           prefixes |= PREFIX_LOCK;
1798           break;
1799         case 0x2e:
1800           prefixes |= PREFIX_CS;
1801           break;
1802         case 0x36:
1803           prefixes |= PREFIX_SS;
1804           break;
1805         case 0x3e:
1806           prefixes |= PREFIX_DS;
1807           break;
1808         case 0x26:
1809           prefixes |= PREFIX_ES;
1810           break;
1811         case 0x64:
1812           prefixes |= PREFIX_FS;
1813           break;
1814         case 0x65:
1815           prefixes |= PREFIX_GS;
1816           break;
1817         case 0x66:
1818           prefixes |= PREFIX_DATA;
1819           break;
1820         case 0x67:
1821           prefixes |= PREFIX_ADDR;
1822           break;
1823         case FWAIT_OPCODE:
1824           /* fwait is really an instruction.  If there are prefixes
1825              before the fwait, they belong to the fwait, *not* to the
1826              following instruction.  */
1827           if (prefixes || rex)
1828             {
1829               prefixes |= PREFIX_FWAIT;
1830               codep++;
1831               return;
1832             }
1833           prefixes = PREFIX_FWAIT;
1834           break;
1835         default:
1836           return;
1837         }
1838       /* Rex is ignored when followed by another prefix.  */
1839       if (rex)
1840         {
1841           rex_used = rex;
1842           return;
1843         }
1844       rex = newrex;
1845       codep++;
1846     }
1847 }
1848
1849 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
1850    prefix byte.  */
1851
1852 static const char *
1853 prefix_name (int pref, int sizeflag)
1854 {
1855   switch (pref)
1856     {
1857     /* REX prefixes family.  */
1858     case 0x40:
1859       return "rex";
1860     case 0x41:
1861       return "rexZ";
1862     case 0x42:
1863       return "rexY";
1864     case 0x43:
1865       return "rexYZ";
1866     case 0x44:
1867       return "rexX";
1868     case 0x45:
1869       return "rexXZ";
1870     case 0x46:
1871       return "rexXY";
1872     case 0x47:
1873       return "rexXYZ";
1874     case 0x48:
1875       return "rex64";
1876     case 0x49:
1877       return "rex64Z";
1878     case 0x4a:
1879       return "rex64Y";
1880     case 0x4b:
1881       return "rex64YZ";
1882     case 0x4c:
1883       return "rex64X";
1884     case 0x4d:
1885       return "rex64XZ";
1886     case 0x4e:
1887       return "rex64XY";
1888     case 0x4f:
1889       return "rex64XYZ";
1890     case 0xf3:
1891       return "repz";
1892     case 0xf2:
1893       return "repnz";
1894     case 0xf0:
1895       return "lock";
1896     case 0x2e:
1897       return "cs";
1898     case 0x36:
1899       return "ss";
1900     case 0x3e:
1901       return "ds";
1902     case 0x26:
1903       return "es";
1904     case 0x64:
1905       return "fs";
1906     case 0x65:
1907       return "gs";
1908     case 0x66:
1909       return (sizeflag & DFLAG) ? "data16" : "data32";
1910     case 0x67:
1911       if (address_mode == mode_64bit)
1912         return (sizeflag & AFLAG) ? "addr32" : "addr64";
1913       else
1914         return (sizeflag & AFLAG) ? "addr16" : "addr32";
1915     case FWAIT_OPCODE:
1916       return "fwait";
1917     default:
1918       return NULL;
1919     }
1920 }
1921
1922 static char op1out[100], op2out[100], op3out[100];
1923 static int op_ad, op_index[3];
1924 static int two_source_ops;
1925 static bfd_vma op_address[3];
1926 static bfd_vma op_riprel[3];
1927 static bfd_vma start_pc;
1928 \f
1929 /*
1930  *   On the 386's of 1988, the maximum length of an instruction is 15 bytes.
1931  *   (see topic "Redundant prefixes" in the "Differences from 8086"
1932  *   section of the "Virtual 8086 Mode" chapter.)
1933  * 'pc' should be the address of this instruction, it will
1934  *   be used to print the target address if this is a relative jump or call
1935  * The function returns the length of this instruction in bytes.
1936  */
1937
1938 static char intel_syntax;
1939 static char open_char;
1940 static char close_char;
1941 static char separator_char;
1942 static char scale_char;
1943
1944 /* Here for backwards compatibility.  When gdb stops using
1945    print_insn_i386_att and print_insn_i386_intel these functions can
1946    disappear, and print_insn_i386 be merged into print_insn.  */
1947 int
1948 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
1949 {
1950   intel_syntax = 0;
1951
1952   return print_insn (pc, info);
1953 }
1954
1955 int
1956 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
1957 {
1958   intel_syntax = 1;
1959
1960   return print_insn (pc, info);
1961 }
1962
1963 int
1964 print_insn_i386 (bfd_vma pc, disassemble_info *info)
1965 {
1966   intel_syntax = -1;
1967
1968   return print_insn (pc, info);
1969 }
1970
1971 static int
1972 print_insn (bfd_vma pc, disassemble_info *info)
1973 {
1974   const struct dis386 *dp;
1975   int i;
1976   char *first, *second, *third;
1977   int needcomma;
1978   unsigned char uses_SSE_prefix, uses_LOCK_prefix;
1979   int sizeflag;
1980   const char *p;
1981   struct dis_private priv;
1982
1983   if (info->mach == bfd_mach_x86_64_intel_syntax
1984       || info->mach == bfd_mach_x86_64)
1985     address_mode = mode_64bit;
1986   else
1987     address_mode = mode_32bit;
1988
1989   if (intel_syntax == (char) -1)
1990     intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
1991                     || info->mach == bfd_mach_x86_64_intel_syntax);
1992
1993   if (info->mach == bfd_mach_i386_i386
1994       || info->mach == bfd_mach_x86_64
1995       || info->mach == bfd_mach_i386_i386_intel_syntax
1996       || info->mach == bfd_mach_x86_64_intel_syntax)
1997     priv.orig_sizeflag = AFLAG | DFLAG;
1998   else if (info->mach == bfd_mach_i386_i8086)
1999     priv.orig_sizeflag = 0;
2000   else
2001     abort ();
2002
2003   for (p = info->disassembler_options; p != NULL; )
2004     {
2005       if (strncmp (p, "x86-64", 6) == 0)
2006         {
2007           address_mode = mode_64bit;
2008           priv.orig_sizeflag = AFLAG | DFLAG;
2009         }
2010       else if (strncmp (p, "i386", 4) == 0)
2011         {
2012           address_mode = mode_32bit;
2013           priv.orig_sizeflag = AFLAG | DFLAG;
2014         }
2015       else if (strncmp (p, "i8086", 5) == 0)
2016         {
2017           address_mode = mode_16bit;
2018           priv.orig_sizeflag = 0;
2019         }
2020       else if (strncmp (p, "intel", 5) == 0)
2021         {
2022           intel_syntax = 1;
2023         }
2024       else if (strncmp (p, "att", 3) == 0)
2025         {
2026           intel_syntax = 0;
2027         }
2028       else if (strncmp (p, "addr", 4) == 0)
2029         {
2030           if (p[4] == '1' && p[5] == '6')
2031             priv.orig_sizeflag &= ~AFLAG;
2032           else if (p[4] == '3' && p[5] == '2')
2033             priv.orig_sizeflag |= AFLAG;
2034         }
2035       else if (strncmp (p, "data", 4) == 0)
2036         {
2037           if (p[4] == '1' && p[5] == '6')
2038             priv.orig_sizeflag &= ~DFLAG;
2039           else if (p[4] == '3' && p[5] == '2')
2040             priv.orig_sizeflag |= DFLAG;
2041         }
2042       else if (strncmp (p, "suffix", 6) == 0)
2043         priv.orig_sizeflag |= SUFFIX_ALWAYS;
2044
2045       p = strchr (p, ',');
2046       if (p != NULL)
2047         p++;
2048     }
2049
2050   if (intel_syntax)
2051     {
2052       names64 = intel_names64;
2053       names32 = intel_names32;
2054       names16 = intel_names16;
2055       names8 = intel_names8;
2056       names8rex = intel_names8rex;
2057       names_seg = intel_names_seg;
2058       index16 = intel_index16;
2059       open_char = '[';
2060       close_char = ']';
2061       separator_char = '+';
2062       scale_char = '*';
2063     }
2064   else
2065     {
2066       names64 = att_names64;
2067       names32 = att_names32;
2068       names16 = att_names16;
2069       names8 = att_names8;
2070       names8rex = att_names8rex;
2071       names_seg = att_names_seg;
2072       index16 = att_index16;
2073       open_char = '(';
2074       close_char =  ')';
2075       separator_char = ',';
2076       scale_char = ',';
2077     }
2078
2079   /* The output looks better if we put 7 bytes on a line, since that
2080      puts most long word instructions on a single line.  */
2081   info->bytes_per_line = 7;
2082
2083   info->private_data = &priv;
2084   priv.max_fetched = priv.the_buffer;
2085   priv.insn_start = pc;
2086
2087   obuf[0] = 0;
2088   op1out[0] = 0;
2089   op2out[0] = 0;
2090   op3out[0] = 0;
2091
2092   op_index[0] = op_index[1] = op_index[2] = -1;
2093
2094   the_info = info;
2095   start_pc = pc;
2096   start_codep = priv.the_buffer;
2097   codep = priv.the_buffer;
2098
2099   if (setjmp (priv.bailout) != 0)
2100     {
2101       const char *name;
2102
2103       /* Getting here means we tried for data but didn't get it.  That
2104          means we have an incomplete instruction of some sort.  Just
2105          print the first byte as a prefix or a .byte pseudo-op.  */
2106       if (codep > priv.the_buffer)
2107         {
2108           name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2109           if (name != NULL)
2110             (*info->fprintf_func) (info->stream, "%s", name);
2111           else
2112             {
2113               /* Just print the first byte as a .byte instruction.  */
2114               (*info->fprintf_func) (info->stream, ".byte 0x%x",
2115                                      (unsigned int) priv.the_buffer[0]);
2116             }
2117
2118           return 1;
2119         }
2120
2121       return -1;
2122     }
2123
2124   obufp = obuf;
2125   ckprefix ();
2126
2127   insn_codep = codep;
2128   sizeflag = priv.orig_sizeflag;
2129
2130   FETCH_DATA (info, codep + 1);
2131   two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
2132
2133   if (((prefixes & PREFIX_FWAIT)
2134        && ((*codep < 0xd8) || (*codep > 0xdf)))
2135       || (rex && rex_used))
2136     {
2137       const char *name;
2138
2139       /* fwait not followed by floating point instruction, or rex followed
2140          by other prefixes.  Print the first prefix.  */
2141       name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2142       if (name == NULL)
2143         name = INTERNAL_DISASSEMBLER_ERROR;
2144       (*info->fprintf_func) (info->stream, "%s", name);
2145       return 1;
2146     }
2147
2148   if (*codep == 0x0f)
2149     {
2150       FETCH_DATA (info, codep + 2);
2151       dp = &dis386_twobyte[*++codep];
2152       need_modrm = twobyte_has_modrm[*codep];
2153       uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
2154       uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
2155     }
2156   else
2157     {
2158       dp = &dis386[*codep];
2159       need_modrm = onebyte_has_modrm[*codep];
2160       uses_SSE_prefix = 0;
2161       uses_LOCK_prefix = 0;
2162     }
2163   codep++;
2164
2165   if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ))
2166     {
2167       oappend ("repz ");
2168       used_prefixes |= PREFIX_REPZ;
2169     }
2170   if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ))
2171     {
2172       oappend ("repnz ");
2173       used_prefixes |= PREFIX_REPNZ;
2174     }
2175   if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
2176     {
2177       oappend ("lock ");
2178       used_prefixes |= PREFIX_LOCK;
2179     }
2180
2181   if (prefixes & PREFIX_ADDR)
2182     {
2183       sizeflag ^= AFLAG;
2184       if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
2185         {
2186           if ((sizeflag & AFLAG) || address_mode == mode_64bit)
2187             oappend ("addr32 ");
2188           else
2189             oappend ("addr16 ");
2190           used_prefixes |= PREFIX_ADDR;
2191         }
2192     }
2193
2194   if (!uses_SSE_prefix && (prefixes & PREFIX_DATA))
2195     {
2196       sizeflag ^= DFLAG;
2197       if (dp->bytemode3 == cond_jump_mode
2198           && dp->bytemode1 == v_mode
2199           && !intel_syntax)
2200         {
2201           if (sizeflag & DFLAG)
2202             oappend ("data32 ");
2203           else
2204             oappend ("data16 ");
2205           used_prefixes |= PREFIX_DATA;
2206         }
2207     }
2208
2209   if (need_modrm)
2210     {
2211       FETCH_DATA (info, codep + 1);
2212       mod = (*codep >> 6) & 3;
2213       reg = (*codep >> 3) & 7;
2214       rm = *codep & 7;
2215     }
2216
2217   if (dp->name == NULL && dp->bytemode1 == FLOATCODE)
2218     {
2219       dofloat (sizeflag);
2220     }
2221   else
2222     {
2223       int index;
2224       if (dp->name == NULL)
2225         {
2226           switch (dp->bytemode1)
2227             {
2228             case USE_GROUPS:
2229               dp = &grps[dp->bytemode2][reg];
2230               break;
2231
2232             case USE_PREFIX_USER_TABLE:
2233               index = 0;
2234               used_prefixes |= (prefixes & PREFIX_REPZ);
2235               if (prefixes & PREFIX_REPZ)
2236                 index = 1;
2237               else
2238                 {
2239                   used_prefixes |= (prefixes & PREFIX_DATA);
2240                   if (prefixes & PREFIX_DATA)
2241                     index = 2;
2242                   else
2243                     {
2244                       used_prefixes |= (prefixes & PREFIX_REPNZ);
2245                       if (prefixes & PREFIX_REPNZ)
2246                         index = 3;
2247                     }
2248                 }
2249               dp = &prefix_user_table[dp->bytemode2][index];
2250               break;
2251
2252             case X86_64_SPECIAL:
2253               index = address_mode == mode_64bit ? 1 : 0;
2254               dp = &x86_64_table[dp->bytemode2][index];
2255               break;
2256
2257             default:
2258               oappend (INTERNAL_DISASSEMBLER_ERROR);
2259               break;
2260             }
2261         }
2262
2263       if (putop (dp->name, sizeflag) == 0)
2264         {
2265           obufp = op1out;
2266           op_ad = 2;
2267           if (dp->op1)
2268             (*dp->op1) (dp->bytemode1, sizeflag);
2269
2270           obufp = op2out;
2271           op_ad = 1;
2272           if (dp->op2)
2273             (*dp->op2) (dp->bytemode2, sizeflag);
2274
2275           obufp = op3out;
2276           op_ad = 0;
2277           if (dp->op3)
2278             (*dp->op3) (dp->bytemode3, sizeflag);
2279         }
2280     }
2281
2282   /* See if any prefixes were not used.  If so, print the first one
2283      separately.  If we don't do this, we'll wind up printing an
2284      instruction stream which does not precisely correspond to the
2285      bytes we are disassembling.  */
2286   if ((prefixes & ~used_prefixes) != 0)
2287     {
2288       const char *name;
2289
2290       name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2291       if (name == NULL)
2292         name = INTERNAL_DISASSEMBLER_ERROR;
2293       (*info->fprintf_func) (info->stream, "%s", name);
2294       return 1;
2295     }
2296   if (rex & ~rex_used)
2297     {
2298       const char *name;
2299       name = prefix_name (rex | 0x40, priv.orig_sizeflag);
2300       if (name == NULL)
2301         name = INTERNAL_DISASSEMBLER_ERROR;
2302       (*info->fprintf_func) (info->stream, "%s ", name);
2303     }
2304
2305   obufp = obuf + strlen (obuf);
2306   for (i = strlen (obuf); i < 6; i++)
2307     oappend (" ");
2308   oappend (" ");
2309   (*info->fprintf_func) (info->stream, "%s", obuf);
2310
2311   /* The enter and bound instructions are printed with operands in the same
2312      order as the intel book; everything else is printed in reverse order.  */
2313   if (intel_syntax || two_source_ops)
2314     {
2315       first = op1out;
2316       second = op2out;
2317       third = op3out;
2318       op_ad = op_index[0];
2319       op_index[0] = op_index[2];
2320       op_index[2] = op_ad;
2321     }
2322   else
2323     {
2324       first = op3out;
2325       second = op2out;
2326       third = op1out;
2327     }
2328   needcomma = 0;
2329   if (*first)
2330     {
2331       if (op_index[0] != -1 && !op_riprel[0])
2332         (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info);
2333       else
2334         (*info->fprintf_func) (info->stream, "%s", first);
2335       needcomma = 1;
2336     }
2337   if (*second)
2338     {
2339       if (needcomma)
2340         (*info->fprintf_func) (info->stream, ",");
2341       if (op_index[1] != -1 && !op_riprel[1])
2342         (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info);
2343       else
2344         (*info->fprintf_func) (info->stream, "%s", second);
2345       needcomma = 1;
2346     }
2347   if (*third)
2348     {
2349       if (needcomma)
2350         (*info->fprintf_func) (info->stream, ",");
2351       if (op_index[2] != -1 && !op_riprel[2])
2352         (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info);
2353       else
2354         (*info->fprintf_func) (info->stream, "%s", third);
2355     }
2356   for (i = 0; i < 3; i++)
2357     if (op_index[i] != -1 && op_riprel[i])
2358       {
2359         (*info->fprintf_func) (info->stream, "        # ");
2360         (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
2361                                                 + op_address[op_index[i]]), info);
2362       }
2363   return codep - priv.the_buffer;
2364 }
2365
2366 static const char *float_mem[] = {
2367   /* d8 */
2368   "fadd{s||s|}",
2369   "fmul{s||s|}",
2370   "fcom{s||s|}",
2371   "fcomp{s||s|}",
2372   "fsub{s||s|}",
2373   "fsubr{s||s|}",
2374   "fdiv{s||s|}",
2375   "fdivr{s||s|}",
2376   /* d9 */
2377   "fld{s||s|}",
2378   "(bad)",
2379   "fst{s||s|}",
2380   "fstp{s||s|}",
2381   "fldenvIC",
2382   "fldcw",
2383   "fNstenvIC",
2384   "fNstcw",
2385   /* da */
2386   "fiadd{l||l|}",
2387   "fimul{l||l|}",
2388   "ficom{l||l|}",
2389   "ficomp{l||l|}",
2390   "fisub{l||l|}",
2391   "fisubr{l||l|}",
2392   "fidiv{l||l|}",
2393   "fidivr{l||l|}",
2394   /* db */
2395   "fild{l||l|}",
2396   "fisttp{l||l|}",
2397   "fist{l||l|}",
2398   "fistp{l||l|}",
2399   "(bad)",
2400   "fld{t||t|}",
2401   "(bad)",
2402   "fstp{t||t|}",
2403   /* dc */
2404   "fadd{l||l|}",
2405   "fmul{l||l|}",
2406   "fcom{l||l|}",
2407   "fcomp{l||l|}",
2408   "fsub{l||l|}",
2409   "fsubr{l||l|}",
2410   "fdiv{l||l|}",
2411   "fdivr{l||l|}",
2412   /* dd */
2413   "fld{l||l|}",
2414   "fisttp{ll||ll|}",
2415   "fst{l||l|}",
2416   "fstp{l||l|}",
2417   "frstorIC",
2418   "(bad)",
2419   "fNsaveIC",
2420   "fNstsw",
2421   /* de */
2422   "fiadd",
2423   "fimul",
2424   "ficom",
2425   "ficomp",
2426   "fisub",
2427   "fisubr",
2428   "fidiv",
2429   "fidivr",
2430   /* df */
2431   "fild",
2432   "fisttp",
2433   "fist",
2434   "fistp",
2435   "fbld",
2436   "fild{ll||ll|}",
2437   "fbstp",
2438   "fistp{ll||ll|}",
2439 };
2440
2441 static const unsigned char float_mem_mode[] = {
2442   /* d8 */
2443   d_mode,
2444   d_mode,
2445   d_mode,
2446   d_mode,
2447   d_mode,
2448   d_mode,
2449   d_mode,
2450   d_mode,
2451   /* d9 */
2452   d_mode,
2453   0,
2454   d_mode,
2455   d_mode,
2456   0,
2457   w_mode,
2458   0,
2459   w_mode,
2460   /* da */
2461   d_mode,
2462   d_mode,
2463   d_mode,
2464   d_mode,
2465   d_mode,
2466   d_mode,
2467   d_mode,
2468   d_mode,
2469   /* db */
2470   d_mode,
2471   d_mode,
2472   d_mode,
2473   d_mode,
2474   0,
2475   t_mode,
2476   0,
2477   t_mode,
2478   /* dc */
2479   q_mode,
2480   q_mode,
2481   q_mode,
2482   q_mode,
2483   q_mode,
2484   q_mode,
2485   q_mode,
2486   q_mode,
2487   /* dd */
2488   q_mode,
2489   q_mode,
2490   q_mode,
2491   q_mode,
2492   0,
2493   0,
2494   0,
2495   w_mode,
2496   /* de */
2497   w_mode,
2498   w_mode,
2499   w_mode,
2500   w_mode,
2501   w_mode,
2502   w_mode,
2503   w_mode,
2504   w_mode,
2505   /* df */
2506   w_mode,
2507   w_mode,
2508   w_mode,
2509   w_mode,
2510   t_mode,
2511   q_mode,
2512   t_mode,
2513   q_mode
2514 };
2515
2516 #define ST OP_ST, 0
2517 #define STi OP_STi, 0
2518
2519 #define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0
2520 #define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0
2521 #define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0
2522 #define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0
2523 #define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0
2524 #define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0
2525 #define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0
2526 #define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0
2527 #define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0
2528
2529 static const struct dis386 float_reg[][8] = {
2530   /* d8 */
2531   {
2532     { "fadd",   ST, STi, XX },
2533     { "fmul",   ST, STi, XX },
2534     { "fcom",   STi, XX, XX },
2535     { "fcomp",  STi, XX, XX },
2536     { "fsub",   ST, STi, XX },
2537     { "fsubr",  ST, STi, XX },
2538     { "fdiv",   ST, STi, XX },
2539     { "fdivr",  ST, STi, XX },
2540   },
2541   /* d9 */
2542   {
2543     { "fld",    STi, XX, XX },
2544     { "fxch",   STi, XX, XX },
2545     { FGRPd9_2 },
2546     { "(bad)",  XX, XX, XX },
2547     { FGRPd9_4 },
2548     { FGRPd9_5 },
2549     { FGRPd9_6 },
2550     { FGRPd9_7 },
2551   },
2552   /* da */
2553   {
2554     { "fcmovb", ST, STi, XX },
2555     { "fcmove", ST, STi, XX },
2556     { "fcmovbe",ST, STi, XX },
2557     { "fcmovu", ST, STi, XX },
2558     { "(bad)",  XX, XX, XX },
2559     { FGRPda_5 },
2560     { "(bad)",  XX, XX, XX },
2561     { "(bad)",  XX, XX, XX },
2562   },
2563   /* db */
2564   {
2565     { "fcmovnb",ST, STi, XX },
2566     { "fcmovne",ST, STi, XX },
2567     { "fcmovnbe",ST, STi, XX },
2568     { "fcmovnu",ST, STi, XX },
2569     { FGRPdb_4 },
2570     { "fucomi", ST, STi, XX },
2571     { "fcomi",  ST, STi, XX },
2572     { "(bad)",  XX, XX, XX },
2573   },
2574   /* dc */
2575   {
2576     { "fadd",   STi, ST, XX },
2577     { "fmul",   STi, ST, XX },
2578     { "(bad)",  XX, XX, XX },
2579     { "(bad)",  XX, XX, XX },
2580 #if UNIXWARE_COMPAT
2581     { "fsub",   STi, ST, XX },
2582     { "fsubr",  STi, ST, XX },
2583     { "fdiv",   STi, ST, XX },
2584     { "fdivr",  STi, ST, XX },
2585 #else
2586     { "fsubr",  STi, ST, XX },
2587     { "fsub",   STi, ST, XX },
2588     { "fdivr",  STi, ST, XX },
2589     { "fdiv",   STi, ST, XX },
2590 #endif
2591   },
2592   /* dd */
2593   {
2594     { "ffree",  STi, XX, XX },
2595     { "(bad)",  XX, XX, XX },
2596     { "fst",    STi, XX, XX },
2597     { "fstp",   STi, XX, XX },
2598     { "fucom",  STi, XX, XX },
2599     { "fucomp", STi, XX, XX },
2600     { "(bad)",  XX, XX, XX },
2601     { "(bad)",  XX, XX, XX },
2602   },
2603   /* de */
2604   {
2605     { "faddp",  STi, ST, XX },
2606     { "fmulp",  STi, ST, XX },
2607     { "(bad)",  XX, XX, XX },
2608     { FGRPde_3 },
2609 #if UNIXWARE_COMPAT
2610     { "fsubp",  STi, ST, XX },
2611     { "fsubrp", STi, ST, XX },
2612     { "fdivp",  STi, ST, XX },
2613     { "fdivrp", STi, ST, XX },
2614 #else
2615     { "fsubrp", STi, ST, XX },
2616     { "fsubp",  STi, ST, XX },
2617     { "fdivrp", STi, ST, XX },
2618     { "fdivp",  STi, ST, XX },
2619 #endif
2620   },
2621   /* df */
2622   {
2623     { "ffreep", STi, XX, XX },
2624     { "(bad)",  XX, XX, XX },
2625     { "(bad)",  XX, XX, XX },
2626     { "(bad)",  XX, XX, XX },
2627     { FGRPdf_4 },
2628     { "fucomip",ST, STi, XX },
2629     { "fcomip", ST, STi, XX },
2630     { "(bad)",  XX, XX, XX },
2631   },
2632 };
2633
2634 static char *fgrps[][8] = {
2635   /* d9_2  0 */
2636   {
2637     "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2638   },
2639
2640   /* d9_4  1 */
2641   {
2642     "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
2643   },
2644
2645   /* d9_5  2 */
2646   {
2647     "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
2648   },
2649
2650   /* d9_6  3 */
2651   {
2652     "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
2653   },
2654
2655   /* d9_7  4 */
2656   {
2657     "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
2658   },
2659
2660   /* da_5  5 */
2661   {
2662     "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2663   },
2664
2665   /* db_4  6 */
2666   {
2667     "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
2668     "fNsetpm(287 only)","(bad)","(bad)","(bad)",
2669   },
2670
2671   /* de_3  7 */
2672   {
2673     "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2674   },
2675
2676   /* df_4  8 */
2677   {
2678     "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2679   },
2680 };
2681
2682 static void
2683 dofloat (int sizeflag)
2684 {
2685   const struct dis386 *dp;
2686   unsigned char floatop;
2687
2688   floatop = codep[-1];
2689
2690   if (mod != 3)
2691     {
2692       int fp_indx = (floatop - 0xd8) * 8 + reg;
2693
2694       putop (float_mem[fp_indx], sizeflag);
2695       obufp = op1out;
2696       op_ad = 2;
2697       OP_E (float_mem_mode[fp_indx], sizeflag);
2698       return;
2699     }
2700   /* Skip mod/rm byte.  */
2701   MODRM_CHECK;
2702   codep++;
2703
2704   dp = &float_reg[floatop - 0xd8][reg];
2705   if (dp->name == NULL)
2706     {
2707       putop (fgrps[dp->bytemode1][rm], sizeflag);
2708
2709       /* Instruction fnstsw is only one with strange arg.  */
2710       if (floatop == 0xdf && codep[-1] == 0xe0)
2711         strcpy (op1out, names16[0]);
2712     }
2713   else
2714     {
2715       putop (dp->name, sizeflag);
2716
2717       obufp = op1out;
2718       op_ad = 2;
2719       if (dp->op1)
2720         (*dp->op1) (dp->bytemode1, sizeflag);
2721
2722       obufp = op2out;
2723       op_ad = 1;
2724       if (dp->op2)
2725         (*dp->op2) (dp->bytemode2, sizeflag);
2726     }
2727 }
2728
2729 static void
2730 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2731 {
2732   oappend ("%st" + intel_syntax);
2733 }
2734
2735 static void
2736 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2737 {
2738   sprintf (scratchbuf, "%%st(%d)", rm);
2739   oappend (scratchbuf + intel_syntax);
2740 }
2741
2742 /* Capital letters in template are macros.  */
2743 static int
2744 putop (const char *template, int sizeflag)
2745 {
2746   const char *p;
2747   int alt = 0;
2748
2749   for (p = template; *p; p++)
2750     {
2751       switch (*p)
2752         {
2753         default:
2754           *obufp++ = *p;
2755           break;
2756         case '{':
2757           alt = 0;
2758           if (intel_syntax)
2759             alt += 1;
2760           if (address_mode == mode_64bit)
2761             alt += 2;
2762           while (alt != 0)
2763             {
2764               while (*++p != '|')
2765                 {
2766                   if (*p == '}')
2767                     {
2768                       /* Alternative not valid.  */
2769                       strcpy (obuf, "(bad)");
2770                       obufp = obuf + 5;
2771                       return 1;
2772                     }
2773                   else if (*p == '\0')
2774                     abort ();
2775                 }
2776               alt--;
2777             }
2778           /* Fall through.  */
2779         case 'I':
2780           alt = 1;
2781           continue;
2782         case '|':
2783           while (*++p != '}')
2784             {
2785               if (*p == '\0')
2786                 abort ();
2787             }
2788           break;
2789         case '}':
2790           break;
2791         case 'A':
2792           if (intel_syntax)
2793             break;
2794           if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2795             *obufp++ = 'b';
2796           break;
2797         case 'B':
2798           if (intel_syntax)
2799             break;
2800           if (sizeflag & SUFFIX_ALWAYS)
2801             *obufp++ = 'b';
2802           break;
2803         case 'C':
2804           if (intel_syntax && !alt)
2805             break;
2806           if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
2807             {
2808               if (sizeflag & DFLAG)
2809                 *obufp++ = intel_syntax ? 'd' : 'l';
2810               else
2811                 *obufp++ = intel_syntax ? 'w' : 's';
2812               used_prefixes |= (prefixes & PREFIX_DATA);
2813             }
2814           break;
2815         case 'E':               /* For jcxz/jecxz */
2816           if (address_mode == mode_64bit)
2817             {
2818               if (sizeflag & AFLAG)
2819                 *obufp++ = 'r';
2820               else
2821                 *obufp++ = 'e';
2822             }
2823           else
2824             if (sizeflag & AFLAG)
2825               *obufp++ = 'e';
2826           used_prefixes |= (prefixes & PREFIX_ADDR);
2827           break;
2828         case 'F':
2829           if (intel_syntax)
2830             break;
2831           if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
2832             {
2833               if (sizeflag & AFLAG)
2834                 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
2835               else
2836                 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
2837               used_prefixes |= (prefixes & PREFIX_ADDR);
2838             }
2839           break;
2840         case 'H':
2841           if (intel_syntax)
2842             break;
2843           if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
2844               || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
2845             {
2846               used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
2847               *obufp++ = ',';
2848               *obufp++ = 'p';
2849               if (prefixes & PREFIX_DS)
2850                 *obufp++ = 't';
2851               else
2852                 *obufp++ = 'n';
2853             }
2854           break;
2855         case 'J':
2856           if (intel_syntax)
2857             break;
2858           *obufp++ = 'l';
2859           break;
2860         case 'Z':
2861           if (intel_syntax)
2862             break;
2863           if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
2864             {
2865               *obufp++ = 'q';
2866               break;
2867             }
2868           /* Fall through.  */
2869         case 'L':
2870           if (intel_syntax)
2871             break;
2872           if (sizeflag & SUFFIX_ALWAYS)
2873             *obufp++ = 'l';
2874           break;
2875         case 'N':
2876           if ((prefixes & PREFIX_FWAIT) == 0)
2877             *obufp++ = 'n';
2878           else
2879             used_prefixes |= PREFIX_FWAIT;
2880           break;
2881         case 'O':
2882           USED_REX (REX_MODE64);
2883           if (rex & REX_MODE64)
2884             *obufp++ = 'o';
2885           else
2886             *obufp++ = 'd';
2887           break;
2888         case 'T':
2889           if (intel_syntax)
2890             break;
2891           if (address_mode == mode_64bit && (sizeflag & DFLAG))
2892             {
2893               *obufp++ = 'q';
2894               break;
2895             }
2896           /* Fall through.  */
2897         case 'P':
2898           if (intel_syntax)
2899             break;
2900           if ((prefixes & PREFIX_DATA)
2901               || (rex & REX_MODE64)
2902               || (sizeflag & SUFFIX_ALWAYS))
2903             {
2904               USED_REX (REX_MODE64);
2905               if (rex & REX_MODE64)
2906                 *obufp++ = 'q';
2907               else
2908                 {
2909                    if (sizeflag & DFLAG)
2910                       *obufp++ = 'l';
2911                    else
2912                      *obufp++ = 'w';
2913                 }
2914               used_prefixes |= (prefixes & PREFIX_DATA);
2915             }
2916           break;
2917         case 'U':
2918           if (intel_syntax)
2919             break;
2920           if (address_mode == mode_64bit && (sizeflag & DFLAG))
2921             {
2922               if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2923                 *obufp++ = 'q';
2924               break;
2925             }
2926           /* Fall through.  */
2927         case 'Q':
2928           if (intel_syntax && !alt)
2929             break;
2930           USED_REX (REX_MODE64);
2931           if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2932             {
2933               if (rex & REX_MODE64)
2934                 *obufp++ = 'q';
2935               else
2936                 {
2937                   if (sizeflag & DFLAG)
2938                     *obufp++ = intel_syntax ? 'd' : 'l';
2939                   else
2940                     *obufp++ = 'w';
2941                 }
2942               used_prefixes |= (prefixes & PREFIX_DATA);
2943             }
2944           break;
2945         case 'R':
2946           USED_REX (REX_MODE64);
2947           if (intel_syntax)
2948             {
2949               if (rex & REX_MODE64)
2950                 {
2951                   *obufp++ = 'q';
2952                   *obufp++ = 't';
2953                 }
2954               else if (sizeflag & DFLAG)
2955                 {
2956                   *obufp++ = 'd';
2957                   *obufp++ = 'q';
2958                 }
2959               else
2960                 {
2961                   *obufp++ = 'w';
2962                   *obufp++ = 'd';
2963                 }
2964             }
2965           else
2966             {
2967               if (rex & REX_MODE64)
2968                 *obufp++ = 'q';
2969               else if (sizeflag & DFLAG)
2970                 *obufp++ = 'l';
2971               else
2972                 *obufp++ = 'w';
2973             }
2974           if (!(rex & REX_MODE64))
2975             used_prefixes |= (prefixes & PREFIX_DATA);
2976           break;
2977         case 'V':
2978           if (intel_syntax)
2979             break;
2980           if (address_mode == mode_64bit && (sizeflag & DFLAG))
2981             {
2982               if (sizeflag & SUFFIX_ALWAYS)
2983                 *obufp++ = 'q';
2984               break;
2985             }
2986           /* Fall through.  */
2987         case 'S':
2988           if (intel_syntax)
2989             break;
2990           if (sizeflag & SUFFIX_ALWAYS)
2991             {
2992               if (rex & REX_MODE64)
2993                 *obufp++ = 'q';
2994               else
2995                 {
2996                   if (sizeflag & DFLAG)
2997                     *obufp++ = 'l';
2998                   else
2999                     *obufp++ = 'w';
3000                   used_prefixes |= (prefixes & PREFIX_DATA);
3001                 }
3002             }
3003           break;
3004         case 'X':
3005           if (prefixes & PREFIX_DATA)
3006             *obufp++ = 'd';
3007           else
3008             *obufp++ = 's';
3009           used_prefixes |= (prefixes & PREFIX_DATA);
3010           break;
3011         case 'Y':
3012           if (intel_syntax)
3013             break;
3014           if (rex & REX_MODE64)
3015             {
3016               USED_REX (REX_MODE64);
3017               *obufp++ = 'q';
3018             }
3019           break;
3020           /* implicit operand size 'l' for i386 or 'q' for x86-64 */
3021         case 'W':
3022           /* operand size flag for cwtl, cbtw */
3023           USED_REX (0);
3024           if (rex)
3025             *obufp++ = 'l';
3026           else if (sizeflag & DFLAG)
3027             *obufp++ = 'w';
3028           else
3029             *obufp++ = 'b';
3030           if (intel_syntax)
3031             {
3032               if (rex)
3033                 {
3034                   *obufp++ = 'q';
3035                   *obufp++ = 'e';
3036                 }
3037               if (sizeflag & DFLAG)
3038                 {
3039                   *obufp++ = 'd';
3040                   *obufp++ = 'e';
3041                 }
3042               else
3043                 {
3044                   *obufp++ = 'w';
3045                 }
3046             }
3047           if (!rex)
3048             used_prefixes |= (prefixes & PREFIX_DATA);
3049           break;
3050         }
3051       alt = 0;
3052     }
3053   *obufp = 0;
3054   return 0;
3055 }
3056
3057 static void
3058 oappend (const char *s)
3059 {
3060   strcpy (obufp, s);
3061   obufp += strlen (s);
3062 }
3063
3064 static void
3065 append_seg (void)
3066 {
3067   if (prefixes & PREFIX_CS)
3068     {
3069       used_prefixes |= PREFIX_CS;
3070       oappend ("%cs:" + intel_syntax);
3071     }
3072   if (prefixes & PREFIX_DS)
3073     {
3074       used_prefixes |= PREFIX_DS;
3075       oappend ("%ds:" + intel_syntax);
3076     }
3077   if (prefixes & PREFIX_SS)
3078     {
3079       used_prefixes |= PREFIX_SS;
3080       oappend ("%ss:" + intel_syntax);
3081     }
3082   if (prefixes & PREFIX_ES)
3083     {
3084       used_prefixes |= PREFIX_ES;
3085       oappend ("%es:" + intel_syntax);
3086     }
3087   if (prefixes & PREFIX_FS)
3088     {
3089       used_prefixes |= PREFIX_FS;
3090       oappend ("%fs:" + intel_syntax);
3091     }
3092   if (prefixes & PREFIX_GS)
3093     {
3094       used_prefixes |= PREFIX_GS;
3095       oappend ("%gs:" + intel_syntax);
3096     }
3097 }
3098
3099 static void
3100 OP_indirE (int bytemode, int sizeflag)
3101 {
3102   if (!intel_syntax)
3103     oappend ("*");
3104   OP_E (bytemode, sizeflag);
3105 }
3106
3107 static void
3108 print_operand_value (char *buf, int hex, bfd_vma disp)
3109 {
3110   if (address_mode == mode_64bit)
3111     {
3112       if (hex)
3113         {
3114           char tmp[30];
3115           int i;
3116           buf[0] = '0';
3117           buf[1] = 'x';
3118           sprintf_vma (tmp, disp);
3119           for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
3120           strcpy (buf + 2, tmp + i);
3121         }
3122       else
3123         {
3124           bfd_signed_vma v = disp;
3125           char tmp[30];
3126           int i;
3127           if (v < 0)
3128             {
3129               *(buf++) = '-';
3130               v = -disp;
3131               /* Check for possible overflow on 0x8000000000000000.  */
3132               if (v < 0)
3133                 {
3134                   strcpy (buf, "9223372036854775808");
3135                   return;
3136                 }
3137             }
3138           if (!v)
3139             {
3140               strcpy (buf, "0");
3141               return;
3142             }
3143
3144           i = 0;
3145           tmp[29] = 0;
3146           while (v)
3147             {
3148               tmp[28 - i] = (v % 10) + '0';
3149               v /= 10;
3150               i++;
3151             }
3152           strcpy (buf, tmp + 29 - i);
3153         }
3154     }
3155   else
3156     {
3157       if (hex)
3158         sprintf (buf, "0x%x", (unsigned int) disp);
3159       else
3160         sprintf (buf, "%d", (int) disp);
3161     }
3162 }
3163
3164 static void
3165 intel_operand_size (int bytemode, int sizeflag)
3166 {
3167   switch (bytemode)
3168     {
3169     case b_mode:
3170       oappend ("BYTE PTR ");
3171       break;
3172     case w_mode:
3173     case dqw_mode:
3174       oappend ("WORD PTR ");
3175       break;
3176     case stack_v_mode:
3177       if (address_mode == mode_64bit && (sizeflag & DFLAG))
3178         {
3179           oappend ("QWORD PTR ");
3180           used_prefixes |= (prefixes & PREFIX_DATA);
3181           break;
3182         }
3183       /* FALLTHRU */
3184     case v_mode:
3185     case dq_mode:
3186       USED_REX (REX_MODE64);
3187       if (rex & REX_MODE64)
3188         oappend ("QWORD PTR ");
3189       else if ((sizeflag & DFLAG) || bytemode == dq_mode)
3190         oappend ("DWORD PTR ");
3191       else
3192         oappend ("WORD PTR ");
3193       used_prefixes |= (prefixes & PREFIX_DATA);
3194       break;
3195     case d_mode:
3196       oappend ("DWORD PTR ");
3197       break;
3198     case q_mode:
3199       oappend ("QWORD PTR ");
3200       break;
3201     case m_mode:
3202       if (address_mode == mode_64bit)
3203         oappend ("QWORD PTR ");
3204       else
3205         oappend ("DWORD PTR ");
3206       break;
3207     case f_mode:
3208       if (sizeflag & DFLAG)
3209         oappend ("FWORD PTR ");
3210       else
3211         oappend ("DWORD PTR ");
3212       used_prefixes |= (prefixes & PREFIX_DATA);
3213       break;
3214     case t_mode:
3215       oappend ("TBYTE PTR ");
3216       break;
3217     case x_mode:
3218       oappend ("XMMWORD PTR ");
3219       break;
3220     default:
3221       break;
3222     }
3223 }
3224
3225 static void
3226 OP_E (int bytemode, int sizeflag)
3227 {
3228   bfd_vma disp;
3229   int add = 0;
3230   int riprel = 0;
3231   USED_REX (REX_EXTZ);
3232   if (rex & REX_EXTZ)
3233     add += 8;
3234
3235   /* Skip mod/rm byte.  */
3236   MODRM_CHECK;
3237   codep++;
3238
3239   if (mod == 3)
3240     {
3241       switch (bytemode)
3242         {
3243         case b_mode:
3244           USED_REX (0);
3245           if (rex)
3246             oappend (names8rex[rm + add]);
3247           else
3248             oappend (names8[rm + add]);
3249           break;
3250         case w_mode:
3251           oappend (names16[rm + add]);
3252           break;
3253         case d_mode:
3254           oappend (names32[rm + add]);
3255           break;
3256         case q_mode:
3257           oappend (names64[rm + add]);
3258           break;
3259         case m_mode:
3260           if (address_mode == mode_64bit)
3261             oappend (names64[rm + add]);
3262           else
3263             oappend (names32[rm + add]);
3264           break;
3265         case stack_v_mode:
3266           if (address_mode == mode_64bit && (sizeflag & DFLAG))
3267             {
3268               oappend (names64[rm + add]);
3269               used_prefixes |= (prefixes & PREFIX_DATA);
3270               break;
3271             }
3272           bytemode = v_mode;
3273           /* FALLTHRU */
3274         case v_mode:
3275         case dq_mode:
3276         case dqw_mode:
3277           USED_REX (REX_MODE64);
3278           if (rex & REX_MODE64)
3279             oappend (names64[rm + add]);
3280           else if ((sizeflag & DFLAG) || bytemode != v_mode)
3281             oappend (names32[rm + add]);
3282           else
3283             oappend (names16[rm + add]);
3284           used_prefixes |= (prefixes & PREFIX_DATA);
3285           break;
3286         case 0:
3287           break;
3288         default:
3289           oappend (INTERNAL_DISASSEMBLER_ERROR);
3290           break;
3291         }
3292       return;
3293     }
3294
3295   disp = 0;
3296   if (intel_syntax)
3297     intel_operand_size (bytemode, sizeflag);
3298   append_seg ();
3299
3300   if ((sizeflag & AFLAG) || address_mode == mode_64bit) /* 32 bit address mode */
3301     {
3302       int havesib;
3303       int havebase;
3304       int base;
3305       int index = 0;
3306       int scale = 0;
3307
3308       havesib = 0;
3309       havebase = 1;
3310       base = rm;
3311
3312       if (base == 4)
3313         {
3314           havesib = 1;
3315           FETCH_DATA (the_info, codep + 1);
3316           index = (*codep >> 3) & 7;
3317           if (address_mode == mode_64bit || index != 0x4)
3318             /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored.  */
3319             scale = (*codep >> 6) & 3;
3320           base = *codep & 7;
3321           USED_REX (REX_EXTY);
3322           if (rex & REX_EXTY)
3323             index += 8;
3324           codep++;
3325         }
3326       base += add;
3327
3328       switch (mod)
3329         {
3330         case 0:
3331           if ((base & 7) == 5)
3332             {
3333               havebase = 0;
3334               if (address_mode == mode_64bit && !havesib)
3335                 riprel = 1;
3336               disp = get32s ();
3337             }
3338           break;
3339         case 1:
3340           FETCH_DATA (the_info, codep + 1);
3341           disp = *codep++;
3342           if ((disp & 0x80) != 0)
3343             disp -= 0x100;
3344           break;
3345         case 2:
3346           disp = get32s ();
3347           break;
3348         }
3349
3350       if (!intel_syntax)
3351         if (mod != 0 || (base & 7) == 5)
3352           {
3353             print_operand_value (scratchbuf, !riprel, disp);
3354             oappend (scratchbuf);
3355             if (riprel)
3356               {
3357                 set_op (disp, 1);
3358                 oappend ("(%rip)");
3359               }
3360           }
3361
3362       if (havebase || (havesib && (index != 4 || scale != 0)))
3363         {
3364           *obufp++ = open_char;
3365           if (intel_syntax && riprel)
3366             oappend ("rip + ");
3367           *obufp = '\0';
3368           if (havebase)
3369             oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3370                      ? names64[base] : names32[base]);
3371           if (havesib)
3372             {
3373               if (index != 4)
3374                 {
3375                   if (!intel_syntax || havebase)
3376                     {
3377                       *obufp++ = separator_char;
3378                       *obufp = '\0';
3379                     }
3380                   oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3381                            ? names64[index] : names32[index]);
3382                 }
3383               if (scale != 0 || (!intel_syntax && index != 4))
3384                 {
3385                   *obufp++ = scale_char;
3386                   *obufp = '\0';
3387                   sprintf (scratchbuf, "%d", 1 << scale);
3388                   oappend (scratchbuf);
3389                 }
3390             }
3391           if (intel_syntax && disp)
3392             {
3393               if ((bfd_signed_vma) disp > 0)
3394                 {
3395                   *obufp++ = '+';
3396                   *obufp = '\0';
3397                 }
3398               else if (mod != 1)
3399                 {
3400                   *obufp++ = '-';
3401                   *obufp = '\0';
3402                   disp = - (bfd_signed_vma) disp;
3403                 }
3404
3405               print_operand_value (scratchbuf, mod != 1, disp);
3406               oappend (scratchbuf);
3407             }
3408
3409           *obufp++ = close_char;
3410           *obufp = '\0';
3411         }
3412       else if (intel_syntax)
3413         {
3414           if (mod != 0 || (base & 7) == 5)
3415             {
3416               if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3417                               | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3418                 ;
3419               else
3420                 {
3421                   oappend (names_seg[ds_reg - es_reg]);
3422                   oappend (":");
3423                 }
3424               print_operand_value (scratchbuf, 1, disp);
3425               oappend (scratchbuf);
3426             }
3427         }
3428     }
3429   else
3430     { /* 16 bit address mode */
3431       switch (mod)
3432         {
3433         case 0:
3434           if (rm == 6)
3435             {
3436               disp = get16 ();
3437               if ((disp & 0x8000) != 0)
3438                 disp -= 0x10000;
3439             }
3440           break;
3441         case 1:
3442           FETCH_DATA (the_info, codep + 1);
3443           disp = *codep++;
3444           if ((disp & 0x80) != 0)
3445             disp -= 0x100;
3446           break;
3447         case 2:
3448           disp = get16 ();
3449           if ((disp & 0x8000) != 0)
3450             disp -= 0x10000;
3451           break;
3452         }
3453
3454       if (!intel_syntax)
3455         if (mod != 0 || rm == 6)
3456           {
3457             print_operand_value (scratchbuf, 0, disp);
3458             oappend (scratchbuf);
3459           }
3460
3461       if (mod != 0 || rm != 6)
3462         {
3463           *obufp++ = open_char;
3464           *obufp = '\0';
3465           oappend (index16[rm]);
3466           if (intel_syntax && disp)
3467             {
3468               if ((bfd_signed_vma) disp > 0)
3469                 {
3470                   *obufp++ = '+';
3471                   *obufp = '\0';
3472                 }
3473               else if (mod != 1)
3474                 {
3475                   *obufp++ = '-';
3476                   *obufp = '\0';
3477                   disp = - (bfd_signed_vma) disp;
3478                 }
3479
3480               print_operand_value (scratchbuf, mod != 1, disp);
3481               oappend (scratchbuf);
3482             }
3483
3484           *obufp++ = close_char;
3485           *obufp = '\0';
3486         }
3487       else if (intel_syntax)
3488         {
3489           if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3490                           | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3491             ;
3492           else
3493             {
3494               oappend (names_seg[ds_reg - es_reg]);
3495               oappend (":");
3496             }
3497           print_operand_value (scratchbuf, 1, disp & 0xffff);
3498           oappend (scratchbuf);
3499         }
3500     }
3501 }
3502
3503 static void
3504 OP_G (int bytemode, int sizeflag)
3505 {
3506   int add = 0;
3507   USED_REX (REX_EXTX);
3508   if (rex & REX_EXTX)
3509     add += 8;
3510   switch (bytemode)
3511     {
3512     case b_mode:
3513       USED_REX (0);
3514       if (rex)
3515         oappend (names8rex[reg + add]);
3516       else
3517         oappend (names8[reg + add]);
3518       break;
3519     case w_mode:
3520       oappend (names16[reg + add]);
3521       break;
3522     case d_mode:
3523       oappend (names32[reg + add]);
3524       break;
3525     case q_mode:
3526       oappend (names64[reg + add]);
3527       break;
3528     case v_mode:
3529     case dq_mode:
3530     case dqw_mode:
3531       USED_REX (REX_MODE64);
3532       if (rex & REX_MODE64)
3533         oappend (names64[reg + add]);
3534       else if ((sizeflag & DFLAG) || bytemode != v_mode)
3535         oappend (names32[reg + add]);
3536       else
3537         oappend (names16[reg + add]);
3538       used_prefixes |= (prefixes & PREFIX_DATA);
3539       break;
3540     case m_mode:
3541       if (address_mode == mode_64bit)
3542         oappend (names64[reg + add]);
3543       else
3544         oappend (names32[reg + add]);
3545       break;
3546     default:
3547       oappend (INTERNAL_DISASSEMBLER_ERROR);
3548       break;
3549     }
3550 }
3551
3552 static bfd_vma
3553 get64 (void)
3554 {
3555   bfd_vma x;
3556 #ifdef BFD64
3557   unsigned int a;
3558   unsigned int b;
3559
3560   FETCH_DATA (the_info, codep + 8);
3561   a = *codep++ & 0xff;
3562   a |= (*codep++ & 0xff) << 8;
3563   a |= (*codep++ & 0xff) << 16;
3564   a |= (*codep++ & 0xff) << 24;
3565   b = *codep++ & 0xff;
3566   b |= (*codep++ & 0xff) << 8;
3567   b |= (*codep++ & 0xff) << 16;
3568   b |= (*codep++ & 0xff) << 24;
3569   x = a + ((bfd_vma) b << 32);
3570 #else
3571   abort ();
3572   x = 0;
3573 #endif
3574   return x;
3575 }
3576
3577 static bfd_signed_vma
3578 get32 (void)
3579 {
3580   bfd_signed_vma x = 0;
3581
3582   FETCH_DATA (the_info, codep + 4);
3583   x = *codep++ & (bfd_signed_vma) 0xff;
3584   x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3585   x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3586   x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3587   return x;
3588 }
3589
3590 static bfd_signed_vma
3591 get32s (void)
3592 {
3593   bfd_signed_vma x = 0;
3594
3595   FETCH_DATA (the_info, codep + 4);
3596   x = *codep++ & (bfd_signed_vma) 0xff;
3597   x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3598   x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3599   x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3600
3601   x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
3602
3603   return x;
3604 }
3605
3606 static int
3607 get16 (void)
3608 {
3609   int x = 0;
3610
3611   FETCH_DATA (the_info, codep + 2);
3612   x = *codep++ & 0xff;
3613   x |= (*codep++ & 0xff) << 8;
3614   return x;
3615 }
3616
3617 static void
3618 set_op (bfd_vma op, int riprel)
3619 {
3620   op_index[op_ad] = op_ad;
3621   if (address_mode == mode_64bit)
3622     {
3623       op_address[op_ad] = op;
3624       op_riprel[op_ad] = riprel;
3625     }
3626   else
3627     {
3628       /* Mask to get a 32-bit address.  */
3629       op_address[op_ad] = op & 0xffffffff;
3630       op_riprel[op_ad] = riprel & 0xffffffff;
3631     }
3632 }
3633
3634 static void
3635 OP_REG (int code, int sizeflag)
3636 {
3637   const char *s;
3638   int add = 0;
3639   USED_REX (REX_EXTZ);
3640   if (rex & REX_EXTZ)
3641     add = 8;
3642
3643   switch (code)
3644     {
3645     case indir_dx_reg:
3646       if (intel_syntax)
3647         s = "[dx]";
3648       else
3649         s = "(%dx)";
3650       break;
3651     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3652     case sp_reg: case bp_reg: case si_reg: case di_reg:
3653       s = names16[code - ax_reg + add];
3654       break;
3655     case es_reg: case ss_reg: case cs_reg:
3656     case ds_reg: case fs_reg: case gs_reg:
3657       s = names_seg[code - es_reg + add];
3658       break;
3659     case al_reg: case ah_reg: case cl_reg: case ch_reg:
3660     case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3661       USED_REX (0);
3662       if (rex)
3663         s = names8rex[code - al_reg + add];
3664       else
3665         s = names8[code - al_reg];
3666       break;
3667     case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
3668     case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
3669       if (address_mode == mode_64bit && (sizeflag & DFLAG))
3670         {
3671           s = names64[code - rAX_reg + add];
3672           break;
3673         }
3674       code += eAX_reg - rAX_reg;
3675       /* Fall through.  */
3676     case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3677     case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3678       USED_REX (REX_MODE64);
3679       if (rex & REX_MODE64)
3680         s = names64[code - eAX_reg + add];
3681       else if (sizeflag & DFLAG)
3682         s = names32[code - eAX_reg + add];
3683       else
3684         s = names16[code - eAX_reg + add];
3685       used_prefixes |= (prefixes & PREFIX_DATA);
3686       break;
3687     default:
3688       s = INTERNAL_DISASSEMBLER_ERROR;
3689       break;
3690     }
3691   oappend (s);
3692 }
3693
3694 static void
3695 OP_IMREG (int code, int sizeflag)
3696 {
3697   const char *s;
3698
3699   switch (code)
3700     {
3701     case indir_dx_reg:
3702       if (intel_syntax)
3703         s = "[dx]";
3704       else
3705         s = "(%dx)";
3706       break;
3707     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3708     case sp_reg: case bp_reg: case si_reg: case di_reg:
3709       s = names16[code - ax_reg];
3710       break;
3711     case es_reg: case ss_reg: case cs_reg:
3712     case ds_reg: case fs_reg: case gs_reg:
3713       s = names_seg[code - es_reg];
3714       break;
3715     case al_reg: case ah_reg: case cl_reg: case ch_reg:
3716     case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3717       USED_REX (0);
3718       if (rex)
3719         s = names8rex[code - al_reg];
3720       else
3721         s = names8[code - al_reg];
3722       break;
3723     case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3724     case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3725       USED_REX (REX_MODE64);
3726       if (rex & REX_MODE64)
3727         s = names64[code - eAX_reg];
3728       else if (sizeflag & DFLAG)
3729         s = names32[code - eAX_reg];
3730       else
3731         s = names16[code - eAX_reg];
3732       used_prefixes |= (prefixes & PREFIX_DATA);
3733       break;
3734     default:
3735       s = INTERNAL_DISASSEMBLER_ERROR;
3736       break;
3737     }
3738   oappend (s);
3739 }
3740
3741 static void
3742 OP_I (int bytemode, int sizeflag)
3743 {
3744   bfd_signed_vma op;
3745   bfd_signed_vma mask = -1;
3746
3747   switch (bytemode)
3748     {
3749     case b_mode:
3750       FETCH_DATA (the_info, codep + 1);
3751       op = *codep++;
3752       mask = 0xff;
3753       break;
3754     case q_mode:
3755       if (address_mode == mode_64bit)
3756         {
3757           op = get32s ();
3758           break;
3759         }
3760       /* Fall through.  */
3761     case v_mode:
3762       USED_REX (REX_MODE64);
3763       if (rex & REX_MODE64)
3764         op = get32s ();
3765       else if (sizeflag & DFLAG)
3766         {
3767           op = get32 ();
3768           mask = 0xffffffff;
3769         }
3770       else
3771         {
3772           op = get16 ();
3773           mask = 0xfffff;
3774         }
3775       used_prefixes |= (prefixes & PREFIX_DATA);
3776       break;
3777     case w_mode:
3778       mask = 0xfffff;
3779       op = get16 ();
3780       break;
3781     case const_1_mode:
3782       if (intel_syntax)
3783         oappend ("1");
3784       return;
3785     default:
3786       oappend (INTERNAL_DISASSEMBLER_ERROR);
3787       return;
3788     }
3789
3790   op &= mask;
3791   scratchbuf[0] = '$';
3792   print_operand_value (scratchbuf + 1, 1, op);
3793   oappend (scratchbuf + intel_syntax);
3794   scratchbuf[0] = '\0';
3795 }
3796
3797 static void
3798 OP_I64 (int bytemode, int sizeflag)
3799 {
3800   bfd_signed_vma op;
3801   bfd_signed_vma mask = -1;
3802
3803   if (address_mode != mode_64bit)
3804     {
3805       OP_I (bytemode, sizeflag);
3806       return;
3807     }
3808
3809   switch (bytemode)
3810     {
3811     case b_mode:
3812       FETCH_DATA (the_info, codep + 1);
3813       op = *codep++;
3814       mask = 0xff;
3815       break;
3816     case v_mode:
3817       USED_REX (REX_MODE64);
3818       if (rex & REX_MODE64)
3819         op = get64 ();
3820       else if (sizeflag & DFLAG)
3821         {
3822           op = get32 ();
3823           mask = 0xffffffff;
3824         }
3825       else
3826         {
3827           op = get16 ();
3828           mask = 0xfffff;
3829         }
3830       used_prefixes |= (prefixes & PREFIX_DATA);
3831       break;
3832     case w_mode:
3833       mask = 0xfffff;
3834       op = get16 ();
3835       break;
3836     default:
3837       oappend (INTERNAL_DISASSEMBLER_ERROR);
3838       return;
3839     }
3840
3841   op &= mask;
3842   scratchbuf[0] = '$';
3843   print_operand_value (scratchbuf + 1, 1, op);
3844   oappend (scratchbuf + intel_syntax);
3845   scratchbuf[0] = '\0';
3846 }
3847
3848 static void
3849 OP_sI (int bytemode, int sizeflag)
3850 {
3851   bfd_signed_vma op;
3852   bfd_signed_vma mask = -1;
3853
3854   switch (bytemode)
3855     {
3856     case b_mode:
3857       FETCH_DATA (the_info, codep + 1);
3858       op = *codep++;
3859       if ((op & 0x80) != 0)
3860         op -= 0x100;
3861       mask = 0xffffffff;
3862       break;
3863     case v_mode:
3864       USED_REX (REX_MODE64);
3865       if (rex & REX_MODE64)
3866         op = get32s ();
3867       else if (sizeflag & DFLAG)
3868         {
3869           op = get32s ();
3870           mask = 0xffffffff;
3871         }
3872       else
3873         {
3874           mask = 0xffffffff;
3875           op = get16 ();
3876           if ((op & 0x8000) != 0)
3877             op -= 0x10000;
3878         }
3879       used_prefixes |= (prefixes & PREFIX_DATA);
3880       break;
3881     case w_mode:
3882       op = get16 ();
3883       mask = 0xffffffff;
3884       if ((op & 0x8000) != 0)
3885         op -= 0x10000;
3886       break;
3887     default:
3888       oappend (INTERNAL_DISASSEMBLER_ERROR);
3889       return;
3890     }
3891
3892   scratchbuf[0] = '$';
3893   print_operand_value (scratchbuf + 1, 1, op);
3894   oappend (scratchbuf + intel_syntax);
3895 }
3896
3897 static void
3898 OP_J (int bytemode, int sizeflag)
3899 {
3900   bfd_vma disp;
3901   bfd_vma mask = -1;
3902
3903   switch (bytemode)
3904     {
3905     case b_mode:
3906       FETCH_DATA (the_info, codep + 1);
3907       disp = *codep++;
3908       if ((disp & 0x80) != 0)
3909         disp -= 0x100;
3910       break;
3911     case v_mode:
3912       if ((sizeflag & DFLAG) || (rex & REX_MODE64))
3913         disp = get32s ();
3914       else
3915         {
3916           disp = get16 ();
3917           /* For some reason, a data16 prefix on a jump instruction
3918              means that the pc is masked to 16 bits after the
3919              displacement is added!  */
3920           mask = 0xffff;
3921         }
3922       break;
3923     default:
3924       oappend (INTERNAL_DISASSEMBLER_ERROR);
3925       return;
3926     }
3927   disp = (start_pc + codep - start_codep + disp) & mask;
3928   set_op (disp, 0);
3929   print_operand_value (scratchbuf, 1, disp);
3930   oappend (scratchbuf);
3931 }
3932
3933 static void
3934 OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3935 {
3936   oappend (names_seg[reg]);
3937 }
3938
3939 static void
3940 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
3941 {
3942   int seg, offset;
3943
3944   if (sizeflag & DFLAG)
3945     {
3946       offset = get32 ();
3947       seg = get16 ();
3948     }
3949   else
3950     {
3951       offset = get16 ();
3952       seg = get16 ();
3953     }
3954   used_prefixes |= (prefixes & PREFIX_DATA);
3955   if (intel_syntax)
3956     sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
3957   else
3958     sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
3959   oappend (scratchbuf);
3960 }
3961
3962 static void
3963 OP_OFF (int bytemode, int sizeflag)
3964 {
3965   bfd_vma off;
3966
3967   if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
3968     intel_operand_size (bytemode, sizeflag);
3969   append_seg ();
3970
3971   if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3972     off = get32 ();
3973   else
3974     off = get16 ();
3975
3976   if (intel_syntax)
3977     {
3978       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3979                         | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
3980         {
3981           oappend (names_seg[ds_reg - es_reg]);
3982           oappend (":");
3983         }
3984     }
3985   print_operand_value (scratchbuf, 1, off);
3986   oappend (scratchbuf);
3987 }
3988
3989 static void
3990 OP_OFF64 (int bytemode, int sizeflag)
3991 {
3992   bfd_vma off;
3993
3994   if (address_mode != mode_64bit)
3995     {
3996       OP_OFF (bytemode, sizeflag);
3997       return;
3998     }
3999
4000   if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
4001     intel_operand_size (bytemode, sizeflag);
4002   append_seg ();
4003
4004   off = get64 ();
4005
4006   if (intel_syntax)
4007     {
4008       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
4009                         | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
4010         {
4011           oappend (names_seg[ds_reg - es_reg]);
4012           oappend (":");
4013         }
4014     }
4015   print_operand_value (scratchbuf, 1, off);
4016   oappend (scratchbuf);
4017 }
4018
4019 static void
4020 ptr_reg (int code, int sizeflag)
4021 {
4022   const char *s;
4023
4024   *obufp++ = open_char;
4025   used_prefixes |= (prefixes & PREFIX_ADDR);
4026   if (address_mode == mode_64bit)
4027     {
4028       if (!(sizeflag & AFLAG))
4029         s = names32[code - eAX_reg];
4030       else
4031         s = names64[code - eAX_reg];
4032     }
4033   else if (sizeflag & AFLAG)
4034     s = names32[code - eAX_reg];
4035   else
4036     s = names16[code - eAX_reg];
4037   oappend (s);
4038   *obufp++ = close_char;
4039   *obufp = 0;
4040 }
4041
4042 static void
4043 OP_ESreg (int code, int sizeflag)
4044 {
4045   if (intel_syntax)
4046     intel_operand_size (codep[-1] & 1 ? v_mode : b_mode, sizeflag);
4047   oappend ("%es:" + intel_syntax);
4048   ptr_reg (code, sizeflag);
4049 }
4050
4051 static void
4052 OP_DSreg (int code, int sizeflag)
4053 {
4054   if (intel_syntax)
4055     intel_operand_size (codep[-1] != 0xd7 && (codep[-1] & 1)
4056                         ? v_mode
4057                         : b_mode,
4058                         sizeflag);
4059   if ((prefixes
4060        & (PREFIX_CS
4061           | PREFIX_DS
4062           | PREFIX_SS
4063           | PREFIX_ES
4064           | PREFIX_FS
4065           | PREFIX_GS)) == 0)
4066     prefixes |= PREFIX_DS;
4067   append_seg ();
4068   ptr_reg (code, sizeflag);
4069 }
4070
4071 static void
4072 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4073 {
4074   int add = 0;
4075   if (rex & REX_EXTX)
4076     {
4077       USED_REX (REX_EXTX);
4078       add = 8;
4079     }
4080   else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
4081     {
4082       used_prefixes |= PREFIX_LOCK;
4083       add = 8;
4084     }
4085   sprintf (scratchbuf, "%%cr%d", reg + add);
4086   oappend (scratchbuf + intel_syntax);
4087 }
4088
4089 static void
4090 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4091 {
4092   int add = 0;
4093   USED_REX (REX_EXTX);
4094   if (rex & REX_EXTX)
4095     add = 8;
4096   if (intel_syntax)
4097     sprintf (scratchbuf, "db%d", reg + add);
4098   else
4099     sprintf (scratchbuf, "%%db%d", reg + add);
4100   oappend (scratchbuf);
4101 }
4102
4103 static void
4104 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4105 {
4106   sprintf (scratchbuf, "%%tr%d", reg);
4107   oappend (scratchbuf + intel_syntax);
4108 }
4109
4110 static void
4111 OP_Rd (int bytemode, int sizeflag)
4112 {
4113   if (mod == 3)
4114     OP_E (bytemode, sizeflag);
4115   else
4116     BadOp ();
4117 }
4118
4119 static void
4120 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4121 {
4122   used_prefixes |= (prefixes & PREFIX_DATA);
4123   if (prefixes & PREFIX_DATA)
4124     {
4125       int add = 0;
4126       USED_REX (REX_EXTX);
4127       if (rex & REX_EXTX)
4128         add = 8;
4129       sprintf (scratchbuf, "%%xmm%d", reg + add);
4130     }
4131   else
4132     sprintf (scratchbuf, "%%mm%d", reg);
4133   oappend (scratchbuf + intel_syntax);
4134 }
4135
4136 static void
4137 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4138 {
4139   int add = 0;
4140   USED_REX (REX_EXTX);
4141   if (rex & REX_EXTX)
4142     add = 8;
4143   sprintf (scratchbuf, "%%xmm%d", reg + add);
4144   oappend (scratchbuf + intel_syntax);
4145 }
4146
4147 static void
4148 OP_EM (int bytemode, int sizeflag)
4149 {
4150   if (mod != 3)
4151     {
4152       if (intel_syntax && bytemode == v_mode)
4153         {
4154           bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
4155           used_prefixes |= (prefixes & PREFIX_DATA);
4156         }
4157       OP_E (bytemode, sizeflag);
4158       return;
4159     }
4160
4161   /* Skip mod/rm byte.  */
4162   MODRM_CHECK;
4163   codep++;
4164   used_prefixes |= (prefixes & PREFIX_DATA);
4165   if (prefixes & PREFIX_DATA)
4166     {
4167       int add = 0;
4168
4169       USED_REX (REX_EXTZ);
4170       if (rex & REX_EXTZ)
4171         add = 8;
4172       sprintf (scratchbuf, "%%xmm%d", rm + add);
4173     }
4174   else
4175     sprintf (scratchbuf, "%%mm%d", rm);
4176   oappend (scratchbuf + intel_syntax);
4177 }
4178
4179 static void
4180 OP_EX (int bytemode, int sizeflag)
4181 {
4182   int add = 0;
4183   if (mod != 3)
4184     {
4185       if (intel_syntax && bytemode == v_mode)
4186         {
4187           switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
4188             {
4189             case 0:            bytemode = x_mode; break;
4190             case PREFIX_REPZ:  bytemode = d_mode; used_prefixes |= PREFIX_REPZ;  break;
4191             case PREFIX_DATA:  bytemode = x_mode; used_prefixes |= PREFIX_DATA;  break;
4192             case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
4193             default:           bytemode = 0; break;
4194             }
4195         }
4196       OP_E (bytemode, sizeflag);
4197       return;
4198     }
4199   USED_REX (REX_EXTZ);
4200   if (rex & REX_EXTZ)
4201     add = 8;
4202
4203   /* Skip mod/rm byte.  */
4204   MODRM_CHECK;
4205   codep++;
4206   sprintf (scratchbuf, "%%xmm%d", rm + add);
4207   oappend (scratchbuf + intel_syntax);
4208 }
4209
4210 static void
4211 OP_MS (int bytemode, int sizeflag)
4212 {
4213   if (mod == 3)
4214     OP_EM (bytemode, sizeflag);
4215   else
4216     BadOp ();
4217 }
4218
4219 static void
4220 OP_XS (int bytemode, int sizeflag)
4221 {
4222   if (mod == 3)
4223     OP_EX (bytemode, sizeflag);
4224   else
4225     BadOp ();
4226 }
4227
4228 static void
4229 OP_M (int bytemode, int sizeflag)
4230 {
4231   if (mod == 3)
4232     BadOp ();   /* bad lea,lds,les,lfs,lgs,lss modrm */
4233   else
4234     OP_E (bytemode, sizeflag);
4235 }
4236
4237 static void
4238 OP_0f07 (int bytemode, int sizeflag)
4239 {
4240   if (mod != 3 || rm != 0)
4241     BadOp ();
4242   else
4243     OP_E (bytemode, sizeflag);
4244 }
4245
4246 static void
4247 OP_0fae (int bytemode, int sizeflag)
4248 {
4249   if (mod == 3)
4250     {
4251       if (reg == 7)
4252         strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
4253
4254       if (reg < 5 || rm != 0)
4255         {
4256           BadOp ();     /* bad sfence, mfence, or lfence */
4257           return;
4258         }
4259     }
4260   else if (reg != 7)
4261     {
4262       BadOp ();         /* bad clflush */
4263       return;
4264     }
4265
4266   OP_E (bytemode, sizeflag);
4267 }
4268
4269 static void
4270 NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4271 {
4272   /* NOP with REPZ prefix is called PAUSE.  */
4273   if (prefixes == PREFIX_REPZ)
4274     strcpy (obuf, "pause");
4275 }
4276
4277 static const char *const Suffix3DNow[] = {
4278 /* 00 */        NULL,           NULL,           NULL,           NULL,
4279 /* 04 */        NULL,           NULL,           NULL,           NULL,
4280 /* 08 */        NULL,           NULL,           NULL,           NULL,
4281 /* 0C */        "pi2fw",        "pi2fd",        NULL,           NULL,
4282 /* 10 */        NULL,           NULL,           NULL,           NULL,
4283 /* 14 */        NULL,           NULL,           NULL,           NULL,
4284 /* 18 */        NULL,           NULL,           NULL,           NULL,
4285 /* 1C */        "pf2iw",        "pf2id",        NULL,           NULL,
4286 /* 20 */        NULL,           NULL,           NULL,           NULL,
4287 /* 24 */        NULL,           NULL,           NULL,           NULL,
4288 /* 28 */        NULL,           NULL,           NULL,           NULL,
4289 /* 2C */        NULL,           NULL,           NULL,           NULL,
4290 /* 30 */        NULL,           NULL,           NULL,           NULL,
4291 /* 34 */        NULL,           NULL,           NULL,           NULL,
4292 /* 38 */        NULL,           NULL,           NULL,           NULL,
4293 /* 3C */        NULL,           NULL,           NULL,           NULL,
4294 /* 40 */        NULL,           NULL,           NULL,           NULL,
4295 /* 44 */        NULL,           NULL,           NULL,           NULL,
4296 /* 48 */        NULL,           NULL,           NULL,           NULL,
4297 /* 4C */        NULL,           NULL,           NULL,           NULL,
4298 /* 50 */        NULL,           NULL,           NULL,           NULL,
4299 /* 54 */        NULL,           NULL,           NULL,           NULL,
4300 /* 58 */        NULL,           NULL,           NULL,           NULL,
4301 /* 5C */        NULL,           NULL,           NULL,           NULL,
4302 /* 60 */        NULL,           NULL,           NULL,           NULL,
4303 /* 64 */        NULL,           NULL,           NULL,           NULL,
4304 /* 68 */        NULL,           NULL,           NULL,           NULL,
4305 /* 6C */        NULL,           NULL,           NULL,           NULL,
4306 /* 70 */        NULL,           NULL,           NULL,           NULL,
4307 /* 74 */        NULL,           NULL,           NULL,           NULL,
4308 /* 78 */        NULL,           NULL,           NULL,           NULL,
4309 /* 7C */        NULL,           NULL,           NULL,           NULL,
4310 /* 80 */        NULL,           NULL,           NULL,           NULL,
4311 /* 84 */        NULL,           NULL,           NULL,           NULL,
4312 /* 88 */        NULL,           NULL,           "pfnacc",       NULL,
4313 /* 8C */        NULL,           NULL,           "pfpnacc",      NULL,
4314 /* 90 */        "pfcmpge",      NULL,           NULL,           NULL,
4315 /* 94 */        "pfmin",        NULL,           "pfrcp",        "pfrsqrt",
4316 /* 98 */        NULL,           NULL,           "pfsub",        NULL,
4317 /* 9C */        NULL,           NULL,           "pfadd",        NULL,
4318 /* A0 */        "pfcmpgt",      NULL,           NULL,           NULL,
4319 /* A4 */        "pfmax",        NULL,           "pfrcpit1",     "pfrsqit1",
4320 /* A8 */        NULL,           NULL,           "pfsubr",       NULL,
4321 /* AC */        NULL,           NULL,           "pfacc",        NULL,
4322 /* B0 */        "pfcmpeq",      NULL,           NULL,           NULL,
4323 /* B4 */        "pfmul",        NULL,           "pfrcpit2",     "pfmulhrw",
4324 /* B8 */        NULL,           NULL,           NULL,           "pswapd",
4325 /* BC */        NULL,           NULL,           NULL,           "pavgusb",
4326 /* C0 */        NULL,           NULL,           NULL,           NULL,
4327 /* C4 */        NULL,           NULL,           NULL,           NULL,
4328 /* C8 */        NULL,           NULL,           NULL,           NULL,
4329 /* CC */        NULL,           NULL,           NULL,           NULL,
4330 /* D0 */        NULL,           NULL,           NULL,           NULL,
4331 /* D4 */        NULL,           NULL,           NULL,           NULL,
4332 /* D8 */        NULL,           NULL,           NULL,           NULL,
4333 /* DC */        NULL,           NULL,           NULL,           NULL,
4334 /* E0 */        NULL,           NULL,           NULL,           NULL,
4335 /* E4 */        NULL,           NULL,           NULL,           NULL,
4336 /* E8 */        NULL,           NULL,           NULL,           NULL,
4337 /* EC */        NULL,           NULL,           NULL,           NULL,
4338 /* F0 */        NULL,           NULL,           NULL,           NULL,
4339 /* F4 */        NULL,           NULL,           NULL,           NULL,
4340 /* F8 */        NULL,           NULL,           NULL,           NULL,
4341 /* FC */        NULL,           NULL,           NULL,           NULL,
4342 };
4343
4344 static void
4345 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4346 {
4347   const char *mnemonic;
4348
4349   FETCH_DATA (the_info, codep + 1);
4350   /* AMD 3DNow! instructions are specified by an opcode suffix in the
4351      place where an 8-bit immediate would normally go.  ie. the last
4352      byte of the instruction.  */
4353   obufp = obuf + strlen (obuf);
4354   mnemonic = Suffix3DNow[*codep++ & 0xff];
4355   if (mnemonic)
4356     oappend (mnemonic);
4357   else
4358     {
4359       /* Since a variable sized modrm/sib chunk is between the start
4360          of the opcode (0x0f0f) and the opcode suffix, we need to do
4361          all the modrm processing first, and don't know until now that
4362          we have a bad opcode.  This necessitates some cleaning up.  */
4363       op1out[0] = '\0';
4364       op2out[0] = '\0';
4365       BadOp ();
4366     }
4367 }
4368
4369 static const char *simd_cmp_op[] = {
4370   "eq",
4371   "lt",
4372   "le",
4373   "unord",
4374   "neq",
4375   "nlt",
4376   "nle",
4377   "ord"
4378 };
4379
4380 static void
4381 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4382 {
4383   unsigned int cmp_type;
4384
4385   FETCH_DATA (the_info, codep + 1);
4386   obufp = obuf + strlen (obuf);
4387   cmp_type = *codep++ & 0xff;
4388   if (cmp_type < 8)
4389     {
4390       char suffix1 = 'p', suffix2 = 's';
4391       used_prefixes |= (prefixes & PREFIX_REPZ);
4392       if (prefixes & PREFIX_REPZ)
4393         suffix1 = 's';
4394       else
4395         {
4396           used_prefixes |= (prefixes & PREFIX_DATA);
4397           if (prefixes & PREFIX_DATA)
4398             suffix2 = 'd';
4399           else
4400             {
4401               used_prefixes |= (prefixes & PREFIX_REPNZ);
4402               if (prefixes & PREFIX_REPNZ)
4403                 suffix1 = 's', suffix2 = 'd';
4404             }
4405         }
4406       sprintf (scratchbuf, "cmp%s%c%c",
4407                simd_cmp_op[cmp_type], suffix1, suffix2);
4408       used_prefixes |= (prefixes & PREFIX_REPZ);
4409       oappend (scratchbuf);
4410     }
4411   else
4412     {
4413       /* We have a bad extension byte.  Clean up.  */
4414       op1out[0] = '\0';
4415       op2out[0] = '\0';
4416       BadOp ();
4417     }
4418 }
4419
4420 static void
4421 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
4422 {
4423   /* Change movlps/movhps to movhlps/movlhps for 2 register operand
4424      forms of these instructions.  */
4425   if (mod == 3)
4426     {
4427       char *p = obuf + strlen (obuf);
4428       *(p + 1) = '\0';
4429       *p       = *(p - 1);
4430       *(p - 1) = *(p - 2);
4431       *(p - 2) = *(p - 3);
4432       *(p - 3) = extrachar;
4433     }
4434 }
4435
4436 static void
4437 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
4438 {
4439   if (mod == 3 && reg == 1 && rm <= 1)
4440     {
4441       /* Override "sidt".  */
4442       size_t olen = strlen (obuf);
4443       char *p = obuf + olen - 4;
4444       const char **names = (address_mode == mode_64bit
4445                             ? names64 : names32);
4446
4447       /* We might have a suffix when disassembling with -Msuffix.  */
4448       if (*p == 'i')
4449         --p;
4450
4451       /* Remove "addr16/addr32" if we aren't in Intel mode.  */
4452       if (!intel_syntax
4453           && (prefixes & PREFIX_ADDR)
4454           && olen >= (4 + 7)
4455           && *(p - 1) == ' '
4456           && strncmp (p - 7, "addr", 4) == 0
4457           && (strncmp (p - 3, "16", 2) == 0
4458               || strncmp (p - 3, "32", 2) == 0))
4459         p -= 7;
4460
4461       if (rm)
4462         {
4463           /* mwait %eax,%ecx  */
4464           strcpy (p, "mwait");
4465           if (!intel_syntax)
4466             strcpy (op1out, names[0]);
4467         }
4468       else
4469         {
4470           /* monitor %eax,%ecx,%edx"  */
4471           strcpy (p, "monitor");
4472           if (!intel_syntax)
4473             {
4474               const char **op1_names;
4475               if (!(prefixes & PREFIX_ADDR))
4476                 op1_names = (address_mode == mode_16bit
4477                              ? names16 : names);
4478               else
4479                 {
4480                   op1_names = (address_mode != mode_32bit
4481                                ? names32 : names16);
4482                   used_prefixes |= PREFIX_ADDR;
4483                 }
4484               strcpy (op1out, op1_names[0]);
4485               strcpy (op3out, names[2]);
4486             }
4487         }
4488       if (!intel_syntax)
4489         {
4490           strcpy (op2out, names[1]);
4491           two_source_ops = 1;
4492         }
4493
4494       codep++;
4495     }
4496   else
4497     OP_M (0, sizeflag);
4498 }
4499
4500 static void
4501 SVME_Fixup (int bytemode, int sizeflag)
4502 {
4503   const char *alt;
4504   char *p;
4505
4506   switch (*codep)
4507     {
4508     case 0xd8:
4509       alt = "vmrun";
4510       break;
4511     case 0xd9:
4512       alt = "vmmcall";
4513       break;
4514     case 0xda:
4515       alt = "vmload";
4516       break;
4517     case 0xdb:
4518       alt = "vmsave";
4519       break;
4520     case 0xdc:
4521       alt = "stgi";
4522       break;
4523     case 0xdd:
4524       alt = "clgi";
4525       break;
4526     case 0xde:
4527       alt = "skinit";
4528       break;
4529     case 0xdf:
4530       alt = "invlpga";
4531       break;
4532     default:
4533       OP_M (bytemode, sizeflag);
4534       return;
4535     }
4536   /* Override "lidt".  */
4537   p = obuf + strlen (obuf) - 4;
4538   /* We might have a suffix.  */
4539   if (*p == 'i')
4540     --p;
4541   strcpy (p, alt);
4542   if (!(prefixes & PREFIX_ADDR))
4543     {
4544       ++codep;
4545       return;
4546     }
4547   used_prefixes |= PREFIX_ADDR;
4548   switch (*codep++)
4549     {
4550     case 0xdf:
4551       strcpy (op2out, names32[1]);
4552       two_source_ops = 1;
4553           /* Fall through.  */
4554     case 0xd8:
4555     case 0xda:
4556     case 0xdb:
4557       *obufp++ = open_char;
4558       if (address_mode == mode_64bit || (sizeflag & AFLAG))
4559         alt = names32[0];
4560       else
4561         alt = names16[0];
4562       strcpy (obufp, alt);
4563       obufp += strlen (alt);
4564       *obufp++ = close_char;
4565       *obufp = '\0';
4566       break;
4567     }
4568 }
4569
4570 static void
4571 INVLPG_Fixup (int bytemode, int sizeflag)
4572 {
4573   const char *alt;
4574
4575   switch (*codep)
4576     {
4577     case 0xf8:
4578       alt = "swapgs";
4579       break;
4580     case 0xf9:
4581       alt = "rdtscp";
4582       break;
4583     default:
4584       OP_M (bytemode, sizeflag);
4585       return;
4586     }
4587   /* Override "invlpg".  */
4588   strcpy (obuf + strlen (obuf) - 6, alt);
4589   codep++;
4590 }
4591
4592 static void
4593 BadOp (void)
4594 {
4595   /* Throw away prefixes and 1st. opcode byte.  */
4596   codep = insn_codep + 1;
4597   oappend ("(bad)");
4598 }
4599
4600 static void
4601 SEG_Fixup (int extrachar, int sizeflag)
4602 {
4603   if (mod == 3)
4604     {
4605       /* We need to add a proper suffix with
4606
4607                 movw %ds,%ax
4608                 movl %ds,%eax
4609                 movq %ds,%rax
4610                 movw %ax,%ds
4611                 movl %eax,%ds
4612                 movq %rax,%ds
4613        */
4614       const char *suffix;
4615
4616       if (prefixes & PREFIX_DATA)
4617         suffix = "w";
4618       else
4619         {
4620           USED_REX (REX_MODE64);
4621           if (rex & REX_MODE64)
4622             suffix = "q";
4623           else
4624             suffix = "l";
4625         }
4626       strcat (obuf, suffix);
4627     }
4628   else
4629     {
4630       /* We need to fix the suffix for
4631
4632                 movw %ds,(%eax)
4633                 movw %ds,(%rax)
4634                 movw (%eax),%ds
4635                 movw (%rax),%ds
4636
4637          Override "mov[l|q]".  */
4638       char *p = obuf + strlen (obuf) - 1;
4639
4640       /* We might not have a suffix.  */
4641       if (*p == 'v')
4642         ++p;
4643       *p = 'w';
4644     }
4645
4646   OP_E (extrachar, sizeflag);
4647 }
4648
4649 static void
4650 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
4651 {
4652   if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
4653     {
4654       /* Override "sgdt".  */
4655       char *p = obuf + strlen (obuf) - 4;
4656
4657       /* We might have a suffix when disassembling with -Msuffix.  */
4658       if (*p == 'g')
4659         --p;
4660
4661       switch (rm)
4662         {
4663         case 1:
4664           strcpy (p, "vmcall");
4665           break;
4666         case 2:
4667           strcpy (p, "vmlaunch");
4668           break;
4669         case 3:
4670           strcpy (p, "vmresume");
4671           break;
4672         case 4:
4673           strcpy (p, "vmxoff");
4674           break;
4675         }
4676
4677       codep++;
4678     }
4679   else
4680     OP_E (0, sizeflag);
4681 }
4682
4683 static void
4684 OP_VMX (int bytemode, int sizeflag)
4685 {
4686   used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
4687   if (prefixes & PREFIX_DATA)
4688     strcpy (obuf, "vmclear");
4689   else if (prefixes & PREFIX_REPZ)
4690     strcpy (obuf, "vmxon");
4691   else
4692     strcpy (obuf, "vmptrld");
4693   OP_E (bytemode, sizeflag);
4694 }