opcodes/i386-dis.c

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