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