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