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