opcodes/i386-dis.c

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