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