Merge from vendor branch CVS:
[dragonfly.git] / contrib / binutils-2.14 / opcodes / i386-dis.c
1 /* Print i386 instructions for GDB, the GNU debugger.
2    Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3    2001, 2002, 2003 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
20
21 /*
22  * 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
23  * July 1988
24  *  modified by John Hassey (hassey@dg-rtp.dg.com)
25  *  x86-64 support added by Jan Hubicka (jh@suse.cz)
26  */
27
28 /*
29  * The main tables describing the instructions is essentially a copy
30  * of the "Opcode Map" chapter (Appendix A) of the Intel 80386
31  * Programmers Manual.  Usually, there is a capital letter, followed
32  * by a small letter.  The capital letter tell the addressing mode,
33  * and the small letter tells about the operand size.  Refer to
34  * the Intel manual for details.
35  */
36
37 #include "dis-asm.h"
38 #include "sysdep.h"
39 #include "opintl.h"
40
41 #define MAXLEN 20
42
43 #include <setjmp.h>
44
45 #ifndef UNIXWARE_COMPAT
46 /* Set non-zero for broken, compatible instructions.  Set to zero for
47    non-broken opcodes.  */
48 #define UNIXWARE_COMPAT 1
49 #endif
50
51 static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *));
52 static void ckprefix PARAMS ((void));
53 static const char *prefix_name PARAMS ((int, int));
54 static int print_insn PARAMS ((bfd_vma, disassemble_info *));
55 static void dofloat PARAMS ((int));
56 static void OP_ST PARAMS ((int, int));
57 static void OP_STi  PARAMS ((int, int));
58 static int putop PARAMS ((const char *, int));
59 static void oappend PARAMS ((const char *));
60 static void append_seg PARAMS ((void));
61 static void OP_indirE PARAMS ((int, int));
62 static void print_operand_value PARAMS ((char *, int, bfd_vma));
63 static void OP_E PARAMS ((int, int));
64 static void OP_G PARAMS ((int, int));
65 static bfd_vma get64 PARAMS ((void));
66 static bfd_signed_vma get32 PARAMS ((void));
67 static bfd_signed_vma get32s PARAMS ((void));
68 static int get16 PARAMS ((void));
69 static void set_op PARAMS ((bfd_vma, int));
70 static void OP_REG PARAMS ((int, int));
71 static void OP_IMREG PARAMS ((int, int));
72 static void OP_I PARAMS ((int, int));
73 static void OP_I64 PARAMS ((int, int));
74 static void OP_sI PARAMS ((int, int));
75 static void OP_J PARAMS ((int, int));
76 static void OP_SEG PARAMS ((int, int));
77 static void OP_DIR PARAMS ((int, int));
78 static void OP_OFF PARAMS ((int, int));
79 static void OP_OFF64 PARAMS ((int, int));
80 static void ptr_reg PARAMS ((int, int));
81 static void OP_ESreg PARAMS ((int, int));
82 static void OP_DSreg PARAMS ((int, int));
83 static void OP_C PARAMS ((int, int));
84 static void OP_D PARAMS ((int, int));
85 static void OP_T PARAMS ((int, int));
86 static void OP_Rd PARAMS ((int, int));
87 static void OP_MMX PARAMS ((int, int));
88 static void OP_XMM PARAMS ((int, int));
89 static void OP_EM PARAMS ((int, int));
90 static void OP_EX PARAMS ((int, int));
91 static void OP_MS PARAMS ((int, int));
92 static void OP_XS PARAMS ((int, int));
93 static void OP_3DNowSuffix PARAMS ((int, int));
94 static void OP_SIMD_Suffix PARAMS ((int, int));
95 static void SIMD_Fixup PARAMS ((int, int));
96 static void BadOp PARAMS ((void));
97
98 struct dis_private {
99   /* Points to first byte not fetched.  */
100   bfd_byte *max_fetched;
101   bfd_byte the_buffer[MAXLEN];
102   bfd_vma insn_start;
103   int orig_sizeflag;
104   jmp_buf bailout;
105 };
106
107 /* The opcode for the fwait instruction, which we treat as a prefix
108    when we can.  */
109 #define FWAIT_OPCODE (0x9b)
110
111 /* Set to 1 for 64bit mode disassembly.  */
112 static int mode_64bit;
113
114 /* Flags for the prefixes for the current instruction.  See below.  */
115 static int prefixes;
116
117 /* REX prefix the current instruction.  See below.  */
118 static int rex;
119 /* Bits of REX we've already used.  */
120 static int rex_used;
121 #define REX_MODE64      8
122 #define REX_EXTX        4
123 #define REX_EXTY        2
124 #define REX_EXTZ        1
125 /* Mark parts used in the REX prefix.  When we are testing for
126    empty prefix (for 8bit register REX extension), just mask it
127    out.  Otherwise test for REX bit is excuse for existence of REX
128    only in case value is nonzero.  */
129 #define USED_REX(value)                                 \
130   {                                                     \
131     if (value)                                          \
132       rex_used |= (rex & value) ? (value) | 0x40 : 0;   \
133     else                                                \
134       rex_used |= 0x40;                                 \
135   }
136
137 /* Flags for prefixes which we somehow handled when printing the
138    current instruction.  */
139 static int used_prefixes;
140
141 /* Flags stored in PREFIXES.  */
142 #define PREFIX_REPZ 1
143 #define PREFIX_REPNZ 2
144 #define PREFIX_LOCK 4
145 #define PREFIX_CS 8
146 #define PREFIX_SS 0x10
147 #define PREFIX_DS 0x20
148 #define PREFIX_ES 0x40
149 #define PREFIX_FS 0x80
150 #define PREFIX_GS 0x100
151 #define PREFIX_DATA 0x200
152 #define PREFIX_ADDR 0x400
153 #define PREFIX_FWAIT 0x800
154
155 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
156    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
157    on error.  */
158 #define FETCH_DATA(info, addr) \
159   ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
160    ? 1 : fetch_data ((info), (addr)))
161
162 static int
163 fetch_data (info, addr)
164      struct disassemble_info *info;
165      bfd_byte *addr;
166 {
167   int status;
168   struct dis_private *priv = (struct dis_private *) info->private_data;
169   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
170
171   status = (*info->read_memory_func) (start,
172                                       priv->max_fetched,
173                                       addr - priv->max_fetched,
174                                       info);
175   if (status != 0)
176     {
177       /* If we did manage to read at least one byte, then
178          print_insn_i386 will do something sensible.  Otherwise, print
179          an error.  We do that here because this is where we know
180          STATUS.  */
181       if (priv->max_fetched == priv->the_buffer)
182         (*info->memory_error_func) (status, start, info);
183       longjmp (priv->bailout, 1);
184     }
185   else
186     priv->max_fetched = addr;
187   return 1;
188 }
189
190 #define XX NULL, 0
191
192 #define Eb OP_E, b_mode
193 #define Ev OP_E, v_mode
194 #define Ed OP_E, d_mode
195 #define Edq OP_E, dq_mode
196 #define indirEb OP_indirE, b_mode
197 #define indirEv OP_indirE, v_mode
198 #define Ew OP_E, w_mode
199 #define Ma OP_E, v_mode
200 #define M OP_E, 0               /* lea, lgdt, etc. */
201 #define Mp OP_E, 0              /* 32 or 48 bit memory operand for LDS, LES etc */
202 #define Gb OP_G, b_mode
203 #define Gv OP_G, v_mode
204 #define Gd OP_G, d_mode
205 #define Gw OP_G, w_mode
206 #define Rd OP_Rd, d_mode
207 #define Rm OP_Rd, m_mode
208 #define Ib OP_I, b_mode
209 #define sIb OP_sI, b_mode       /* sign extened byte */
210 #define Iv OP_I, v_mode
211 #define Iq OP_I, q_mode
212 #define Iv64 OP_I64, v_mode
213 #define Iw OP_I, w_mode
214 #define Jb OP_J, b_mode
215 #define Jv OP_J, v_mode
216 #define Cm OP_C, m_mode
217 #define Dm OP_D, m_mode
218 #define Td OP_T, d_mode
219
220 #define RMeAX OP_REG, eAX_reg
221 #define RMeBX OP_REG, eBX_reg
222 #define RMeCX OP_REG, eCX_reg
223 #define RMeDX OP_REG, eDX_reg
224 #define RMeSP OP_REG, eSP_reg
225 #define RMeBP OP_REG, eBP_reg
226 #define RMeSI OP_REG, eSI_reg
227 #define RMeDI OP_REG, eDI_reg
228 #define RMrAX OP_REG, rAX_reg
229 #define RMrBX OP_REG, rBX_reg
230 #define RMrCX OP_REG, rCX_reg
231 #define RMrDX OP_REG, rDX_reg
232 #define RMrSP OP_REG, rSP_reg
233 #define RMrBP OP_REG, rBP_reg
234 #define RMrSI OP_REG, rSI_reg
235 #define RMrDI OP_REG, rDI_reg
236 #define RMAL OP_REG, al_reg
237 #define RMAL OP_REG, al_reg
238 #define RMCL OP_REG, cl_reg
239 #define RMDL OP_REG, dl_reg
240 #define RMBL OP_REG, bl_reg
241 #define RMAH OP_REG, ah_reg
242 #define RMCH OP_REG, ch_reg
243 #define RMDH OP_REG, dh_reg
244 #define RMBH OP_REG, bh_reg
245 #define RMAX OP_REG, ax_reg
246 #define RMDX OP_REG, dx_reg
247
248 #define eAX OP_IMREG, eAX_reg
249 #define eBX OP_IMREG, eBX_reg
250 #define eCX OP_IMREG, eCX_reg
251 #define eDX OP_IMREG, eDX_reg
252 #define eSP OP_IMREG, eSP_reg
253 #define eBP OP_IMREG, eBP_reg
254 #define eSI OP_IMREG, eSI_reg
255 #define eDI OP_IMREG, eDI_reg
256 #define AL OP_IMREG, al_reg
257 #define AL OP_IMREG, al_reg
258 #define CL OP_IMREG, cl_reg
259 #define DL OP_IMREG, dl_reg
260 #define BL OP_IMREG, bl_reg
261 #define AH OP_IMREG, ah_reg
262 #define CH OP_IMREG, ch_reg
263 #define DH OP_IMREG, dh_reg
264 #define BH OP_IMREG, bh_reg
265 #define AX OP_IMREG, ax_reg
266 #define DX OP_IMREG, dx_reg
267 #define indirDX OP_IMREG, indir_dx_reg
268
269 #define Sw OP_SEG, w_mode
270 #define Ap OP_DIR, 0
271 #define Ob OP_OFF, b_mode
272 #define Ob64 OP_OFF64, b_mode
273 #define Ov OP_OFF, v_mode
274 #define Ov64 OP_OFF64, v_mode
275 #define Xb OP_DSreg, eSI_reg
276 #define Xv OP_DSreg, eSI_reg
277 #define Yb OP_ESreg, eDI_reg
278 #define Yv OP_ESreg, eDI_reg
279 #define DSBX OP_DSreg, eBX_reg
280
281 #define es OP_REG, es_reg
282 #define ss OP_REG, ss_reg
283 #define cs OP_REG, cs_reg
284 #define ds OP_REG, ds_reg
285 #define fs OP_REG, fs_reg
286 #define gs OP_REG, gs_reg
287
288 #define MX OP_MMX, 0
289 #define XM OP_XMM, 0
290 #define EM OP_EM, v_mode
291 #define EX OP_EX, v_mode
292 #define MS OP_MS, v_mode
293 #define XS OP_XS, v_mode
294 #define None OP_E, 0
295 #define OPSUF OP_3DNowSuffix, 0
296 #define OPSIMD OP_SIMD_Suffix, 0
297
298 #define cond_jump_flag NULL, cond_jump_mode
299 #define loop_jcxz_flag NULL, loop_jcxz_mode
300
301 /* bits in sizeflag */
302 #define SUFFIX_ALWAYS 4
303 #define AFLAG 2
304 #define DFLAG 1
305
306 #define b_mode 1  /* byte operand */
307 #define v_mode 2  /* operand size depends on prefixes */
308 #define w_mode 3  /* word operand */
309 #define d_mode 4  /* double word operand  */
310 #define q_mode 5  /* quad word operand */
311 #define x_mode 6
312 #define m_mode 7  /* d_mode in 32bit, q_mode in 64bit mode.  */
313 #define cond_jump_mode 8
314 #define loop_jcxz_mode 9
315 #define dq_mode 10 /* operand size depends on REX prefixes.  */
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   { "icebp",            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, Edq, 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", Edq, MX, XX },
1616     { "movq", XM, EX, XX },
1617     { "movd", Edq, 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 == (char) -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         case dq_mode:
3005           USED_REX (REX_MODE64);
3006           if (rex & REX_MODE64)
3007             oappend (names64[rm + add]);
3008           else if ((sizeflag & DFLAG) || bytemode == dq_mode)
3009             oappend (names32[rm + add]);
3010           else
3011             oappend (names16[rm + add]);
3012           used_prefixes |= (prefixes & PREFIX_DATA);
3013           break;
3014         case 0:
3015           if (!(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */)
3016               && !(codep[-2] == 0xAE && codep[-1] == 0xF0 /* mfence */)
3017               && !(codep[-2] == 0xAE && codep[-1] == 0xe8 /* lfence */))
3018             BadOp ();   /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
3019           break;
3020         default:
3021           oappend (INTERNAL_DISASSEMBLER_ERROR);
3022           break;
3023         }
3024       return;
3025     }
3026
3027   disp = 0;
3028   append_seg ();
3029
3030   if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
3031     {
3032       int havesib;
3033       int havebase;
3034       int base;
3035       int index = 0;
3036       int scale = 0;
3037
3038       havesib = 0;
3039       havebase = 1;
3040       base = rm;
3041
3042       if (base == 4)
3043         {
3044           havesib = 1;
3045           FETCH_DATA (the_info, codep + 1);
3046           scale = (*codep >> 6) & 3;
3047           index = (*codep >> 3) & 7;
3048           base = *codep & 7;
3049           USED_REX (REX_EXTY);
3050           USED_REX (REX_EXTZ);
3051           if (rex & REX_EXTY)
3052             index += 8;
3053           if (rex & REX_EXTZ)
3054             base += 8;
3055           codep++;
3056         }
3057
3058       switch (mod)
3059         {
3060         case 0:
3061           if ((base & 7) == 5)
3062             {
3063               havebase = 0;
3064               if (mode_64bit && !havesib && (sizeflag & AFLAG))
3065                 riprel = 1;
3066               disp = get32s ();
3067             }
3068           break;
3069         case 1:
3070           FETCH_DATA (the_info, codep + 1);
3071           disp = *codep++;
3072           if ((disp & 0x80) != 0)
3073             disp -= 0x100;
3074           break;
3075         case 2:
3076           disp = get32s ();
3077           break;
3078         }
3079
3080       if (!intel_syntax)
3081         if (mod != 0 || (base & 7) == 5)
3082           {
3083             print_operand_value (scratchbuf, !riprel, disp);
3084             oappend (scratchbuf);
3085             if (riprel)
3086               {
3087                 set_op (disp, 1);
3088                 oappend ("(%rip)");
3089               }
3090           }
3091
3092       if (havebase || (havesib && (index != 4 || scale != 0)))
3093         {
3094           if (intel_syntax)
3095             {
3096               switch (bytemode)
3097                 {
3098                 case b_mode:
3099                   oappend ("BYTE PTR ");
3100                   break;
3101                 case w_mode:
3102                   oappend ("WORD PTR ");
3103                   break;
3104                 case v_mode:
3105                   oappend ("DWORD PTR ");
3106                   break;
3107                 case d_mode:
3108                   oappend ("QWORD PTR ");
3109                   break;
3110                 case m_mode:
3111                   if (mode_64bit)
3112                     oappend ("DWORD PTR ");
3113                   else
3114                     oappend ("QWORD PTR ");
3115                   break;
3116                 case x_mode:
3117                   oappend ("XWORD PTR ");
3118                   break;
3119                 default:
3120                   break;
3121                 }
3122              }
3123           *obufp++ = open_char;
3124           if (intel_syntax && riprel)
3125             oappend ("rip + ");
3126           *obufp = '\0';
3127           USED_REX (REX_EXTZ);
3128           if (!havesib && (rex & REX_EXTZ))
3129             base += 8;
3130           if (havebase)
3131             oappend (mode_64bit && (sizeflag & AFLAG)
3132                      ? names64[base] : names32[base]);
3133           if (havesib)
3134             {
3135               if (index != 4)
3136                 {
3137                   if (intel_syntax)
3138                     {
3139                       if (havebase)
3140                         {
3141                           *obufp++ = separator_char;
3142                           *obufp = '\0';
3143                         }
3144                       sprintf (scratchbuf, "%s",
3145                                mode_64bit && (sizeflag & AFLAG)
3146                                ? names64[index] : names32[index]);
3147                     }
3148                   else
3149                     sprintf (scratchbuf, ",%s",
3150                              mode_64bit && (sizeflag & AFLAG)
3151                              ? names64[index] : names32[index]);
3152                   oappend (scratchbuf);
3153                 }
3154               if (!intel_syntax
3155                   || (intel_syntax
3156                       && bytemode != b_mode
3157                       && bytemode != w_mode
3158                       && bytemode != v_mode))
3159                 {
3160                   *obufp++ = scale_char;
3161                   *obufp = '\0';
3162                   sprintf (scratchbuf, "%d", 1 << scale);
3163                   oappend (scratchbuf);
3164                 }
3165             }
3166           if (intel_syntax)
3167             if (mod != 0 || (base & 7) == 5)
3168               {
3169                 /* Don't print zero displacements.  */
3170                 if (disp != 0)
3171                   {
3172                     if ((bfd_signed_vma) disp > 0)
3173                       {
3174                         *obufp++ = '+';
3175                         *obufp = '\0';
3176                       }
3177
3178                     print_operand_value (scratchbuf, 0, disp);
3179                     oappend (scratchbuf);
3180                   }
3181               }
3182
3183           *obufp++ = close_char;
3184           *obufp = '\0';
3185         }
3186       else if (intel_syntax)
3187         {
3188           if (mod != 0 || (base & 7) == 5)
3189             {
3190               if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3191                               | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3192                 ;
3193               else
3194                 {
3195                   oappend (names_seg[ds_reg - es_reg]);
3196                   oappend (":");
3197                 }
3198               print_operand_value (scratchbuf, 1, disp);
3199               oappend (scratchbuf);
3200             }
3201         }
3202     }
3203   else
3204     { /* 16 bit address mode */
3205       switch (mod)
3206         {
3207         case 0:
3208           if ((rm & 7) == 6)
3209             {
3210               disp = get16 ();
3211               if ((disp & 0x8000) != 0)
3212                 disp -= 0x10000;
3213             }
3214           break;
3215         case 1:
3216           FETCH_DATA (the_info, codep + 1);
3217           disp = *codep++;
3218           if ((disp & 0x80) != 0)
3219             disp -= 0x100;
3220           break;
3221         case 2:
3222           disp = get16 ();
3223           if ((disp & 0x8000) != 0)
3224             disp -= 0x10000;
3225           break;
3226         }
3227
3228       if (!intel_syntax)
3229         if (mod != 0 || (rm & 7) == 6)
3230           {
3231             print_operand_value (scratchbuf, 0, disp);
3232             oappend (scratchbuf);
3233           }
3234
3235       if (mod != 0 || (rm & 7) != 6)
3236         {
3237           *obufp++ = open_char;
3238           *obufp = '\0';
3239           oappend (index16[rm + add]);
3240           *obufp++ = close_char;
3241           *obufp = '\0';
3242         }
3243     }
3244 }
3245
3246 static void
3247 OP_G (bytemode, sizeflag)
3248      int bytemode;
3249      int sizeflag;
3250 {
3251   int add = 0;
3252   USED_REX (REX_EXTX);
3253   if (rex & REX_EXTX)
3254     add += 8;
3255   switch (bytemode)
3256     {
3257     case b_mode:
3258       USED_REX (0);
3259       if (rex)
3260         oappend (names8rex[reg + add]);
3261       else
3262         oappend (names8[reg + add]);
3263       break;
3264     case w_mode:
3265       oappend (names16[reg + add]);
3266       break;
3267     case d_mode:
3268       oappend (names32[reg + add]);
3269       break;
3270     case q_mode:
3271       oappend (names64[reg + add]);
3272       break;
3273     case v_mode:
3274       USED_REX (REX_MODE64);
3275       if (rex & REX_MODE64)
3276         oappend (names64[reg + add]);
3277       else if (sizeflag & DFLAG)
3278         oappend (names32[reg + add]);
3279       else
3280         oappend (names16[reg + add]);
3281       used_prefixes |= (prefixes & PREFIX_DATA);
3282       break;
3283     default:
3284       oappend (INTERNAL_DISASSEMBLER_ERROR);
3285       break;
3286     }
3287 }
3288
3289 static bfd_vma
3290 get64 ()
3291 {
3292   bfd_vma x;
3293 #ifdef BFD64
3294   unsigned int a;
3295   unsigned int b;
3296
3297   FETCH_DATA (the_info, codep + 8);
3298   a = *codep++ & 0xff;
3299   a |= (*codep++ & 0xff) << 8;
3300   a |= (*codep++ & 0xff) << 16;
3301   a |= (*codep++ & 0xff) << 24;
3302   b = *codep++ & 0xff;
3303   b |= (*codep++ & 0xff) << 8;
3304   b |= (*codep++ & 0xff) << 16;
3305   b |= (*codep++ & 0xff) << 24;
3306   x = a + ((bfd_vma) b << 32);
3307 #else
3308   abort ();
3309   x = 0;
3310 #endif
3311   return x;
3312 }
3313
3314 static bfd_signed_vma
3315 get32 ()
3316 {
3317   bfd_signed_vma x = 0;
3318
3319   FETCH_DATA (the_info, codep + 4);
3320   x = *codep++ & (bfd_signed_vma) 0xff;
3321   x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3322   x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3323   x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3324   return x;
3325 }
3326
3327 static bfd_signed_vma
3328 get32s ()
3329 {
3330   bfd_signed_vma x = 0;
3331
3332   FETCH_DATA (the_info, codep + 4);
3333   x = *codep++ & (bfd_signed_vma) 0xff;
3334   x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3335   x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3336   x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3337
3338   x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
3339
3340   return x;
3341 }
3342
3343 static int
3344 get16 ()
3345 {
3346   int x = 0;
3347
3348   FETCH_DATA (the_info, codep + 2);
3349   x = *codep++ & 0xff;
3350   x |= (*codep++ & 0xff) << 8;
3351   return x;
3352 }
3353
3354 static void
3355 set_op (op, riprel)
3356      bfd_vma op;
3357      int riprel;
3358 {
3359   op_index[op_ad] = op_ad;
3360   if (mode_64bit)
3361     {
3362       op_address[op_ad] = op;
3363       op_riprel[op_ad] = riprel;
3364     }
3365   else
3366     {
3367       /* Mask to get a 32-bit address.  */
3368       op_address[op_ad] = op & 0xffffffff;
3369       op_riprel[op_ad] = riprel & 0xffffffff;
3370     }
3371 }
3372
3373 static void
3374 OP_REG (code, sizeflag)
3375      int code;
3376      int sizeflag;
3377 {
3378   const char *s;
3379   int add = 0;
3380   USED_REX (REX_EXTZ);
3381   if (rex & REX_EXTZ)
3382     add = 8;
3383
3384   switch (code)
3385     {
3386     case indir_dx_reg:
3387       if (intel_syntax)
3388         s = "[dx]";
3389       else
3390         s = "(%dx)";
3391       break;
3392     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3393     case sp_reg: case bp_reg: case si_reg: case di_reg:
3394       s = names16[code - ax_reg + add];
3395       break;
3396     case es_reg: case ss_reg: case cs_reg:
3397     case ds_reg: case fs_reg: case gs_reg:
3398       s = names_seg[code - es_reg + add];
3399       break;
3400     case al_reg: case ah_reg: case cl_reg: case ch_reg:
3401     case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3402       USED_REX (0);
3403       if (rex)
3404         s = names8rex[code - al_reg + add];
3405       else
3406         s = names8[code - al_reg];
3407       break;
3408     case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
3409     case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
3410       if (mode_64bit)
3411         {
3412           s = names64[code - rAX_reg + add];
3413           break;
3414         }
3415       code += eAX_reg - rAX_reg;
3416       /* Fall through.  */
3417     case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3418     case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3419       USED_REX (REX_MODE64);
3420       if (rex & REX_MODE64)
3421         s = names64[code - eAX_reg + add];
3422       else if (sizeflag & DFLAG)
3423         s = names32[code - eAX_reg + add];
3424       else
3425         s = names16[code - eAX_reg + add];
3426       used_prefixes |= (prefixes & PREFIX_DATA);
3427       break;
3428     default:
3429       s = INTERNAL_DISASSEMBLER_ERROR;
3430       break;
3431     }
3432   oappend (s);
3433 }
3434
3435 static void
3436 OP_IMREG (code, sizeflag)
3437      int code;
3438      int sizeflag;
3439 {
3440   const char *s;
3441
3442   switch (code)
3443     {
3444     case indir_dx_reg:
3445       if (intel_syntax)
3446         s = "[dx]";
3447       else
3448         s = "(%dx)";
3449       break;
3450     case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3451     case sp_reg: case bp_reg: case si_reg: case di_reg:
3452       s = names16[code - ax_reg];
3453       break;
3454     case es_reg: case ss_reg: case cs_reg:
3455     case ds_reg: case fs_reg: case gs_reg:
3456       s = names_seg[code - es_reg];
3457       break;
3458     case al_reg: case ah_reg: case cl_reg: case ch_reg:
3459     case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3460       USED_REX (0);
3461       if (rex)
3462         s = names8rex[code - al_reg];
3463       else
3464         s = names8[code - al_reg];
3465       break;
3466     case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3467     case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3468       USED_REX (REX_MODE64);
3469       if (rex & REX_MODE64)
3470         s = names64[code - eAX_reg];
3471       else if (sizeflag & DFLAG)
3472         s = names32[code - eAX_reg];
3473       else
3474         s = names16[code - eAX_reg];
3475       used_prefixes |= (prefixes & PREFIX_DATA);
3476       break;
3477     default:
3478       s = INTERNAL_DISASSEMBLER_ERROR;
3479       break;
3480     }
3481   oappend (s);
3482 }
3483
3484 static void
3485 OP_I (bytemode, sizeflag)
3486      int bytemode;
3487      int sizeflag;
3488 {
3489   bfd_signed_vma op;
3490   bfd_signed_vma mask = -1;
3491
3492   switch (bytemode)
3493     {
3494     case b_mode:
3495       FETCH_DATA (the_info, codep + 1);
3496       op = *codep++;
3497       mask = 0xff;
3498       break;
3499     case q_mode:
3500       if (mode_64bit)
3501         {
3502           op = get32s ();
3503           break;
3504         }
3505       /* Fall through.  */
3506     case v_mode:
3507       USED_REX (REX_MODE64);
3508       if (rex & REX_MODE64)
3509         op = get32s ();
3510       else if (sizeflag & DFLAG)
3511         {
3512           op = get32 ();
3513           mask = 0xffffffff;
3514         }
3515       else
3516         {
3517           op = get16 ();
3518           mask = 0xfffff;
3519         }
3520       used_prefixes |= (prefixes & PREFIX_DATA);
3521       break;
3522     case w_mode:
3523       mask = 0xfffff;
3524       op = get16 ();
3525       break;
3526     default:
3527       oappend (INTERNAL_DISASSEMBLER_ERROR);
3528       return;
3529     }
3530
3531   op &= mask;
3532   scratchbuf[0] = '$';
3533   print_operand_value (scratchbuf + 1, 1, op);
3534   oappend (scratchbuf + intel_syntax);
3535   scratchbuf[0] = '\0';
3536 }
3537
3538 static void
3539 OP_I64 (bytemode, sizeflag)
3540      int bytemode;
3541      int sizeflag;
3542 {
3543   bfd_signed_vma op;
3544   bfd_signed_vma mask = -1;
3545
3546   if (!mode_64bit)
3547     {
3548       OP_I (bytemode, sizeflag);
3549       return;
3550     }
3551
3552   switch (bytemode)
3553     {
3554     case b_mode:
3555       FETCH_DATA (the_info, codep + 1);
3556       op = *codep++;
3557       mask = 0xff;
3558       break;
3559     case v_mode:
3560       USED_REX (REX_MODE64);
3561       if (rex & REX_MODE64)
3562         op = get64 ();
3563       else if (sizeflag & DFLAG)
3564         {
3565           op = get32 ();
3566           mask = 0xffffffff;
3567         }
3568       else
3569         {
3570           op = get16 ();
3571           mask = 0xfffff;
3572         }
3573       used_prefixes |= (prefixes & PREFIX_DATA);
3574       break;
3575     case w_mode:
3576       mask = 0xfffff;
3577       op = get16 ();
3578       break;
3579     default:
3580       oappend (INTERNAL_DISASSEMBLER_ERROR);
3581       return;
3582     }
3583
3584   op &= mask;
3585   scratchbuf[0] = '$';
3586   print_operand_value (scratchbuf + 1, 1, op);
3587   oappend (scratchbuf + intel_syntax);
3588   scratchbuf[0] = '\0';
3589 }
3590
3591 static void
3592 OP_sI (bytemode, sizeflag)
3593      int bytemode;
3594      int sizeflag;
3595 {
3596   bfd_signed_vma op;
3597   bfd_signed_vma mask = -1;
3598
3599   switch (bytemode)
3600     {
3601     case b_mode:
3602       FETCH_DATA (the_info, codep + 1);
3603       op = *codep++;
3604       if ((op & 0x80) != 0)
3605         op -= 0x100;
3606       mask = 0xffffffff;
3607       break;
3608     case v_mode:
3609       USED_REX (REX_MODE64);
3610       if (rex & REX_MODE64)
3611         op = get32s ();
3612       else if (sizeflag & DFLAG)
3613         {
3614           op = get32s ();
3615           mask = 0xffffffff;
3616         }
3617       else
3618         {
3619           mask = 0xffffffff;
3620           op = get16 ();
3621           if ((op & 0x8000) != 0)
3622             op -= 0x10000;
3623         }
3624       used_prefixes |= (prefixes & PREFIX_DATA);
3625       break;
3626     case w_mode:
3627       op = get16 ();
3628       mask = 0xffffffff;
3629       if ((op & 0x8000) != 0)
3630         op -= 0x10000;
3631       break;
3632     default:
3633       oappend (INTERNAL_DISASSEMBLER_ERROR);
3634       return;
3635     }
3636
3637   scratchbuf[0] = '$';
3638   print_operand_value (scratchbuf + 1, 1, op);
3639   oappend (scratchbuf + intel_syntax);
3640 }
3641
3642 static void
3643 OP_J (bytemode, sizeflag)
3644      int bytemode;
3645      int sizeflag;
3646 {
3647   bfd_vma disp;
3648   bfd_vma mask = -1;
3649
3650   switch (bytemode)
3651     {
3652     case b_mode:
3653       FETCH_DATA (the_info, codep + 1);
3654       disp = *codep++;
3655       if ((disp & 0x80) != 0)
3656         disp -= 0x100;
3657       break;
3658     case v_mode:
3659       if (sizeflag & DFLAG)
3660         disp = get32s ();
3661       else
3662         {
3663           disp = get16 ();
3664           /* For some reason, a data16 prefix on a jump instruction
3665              means that the pc is masked to 16 bits after the
3666              displacement is added!  */
3667           mask = 0xffff;
3668         }
3669       break;
3670     default:
3671       oappend (INTERNAL_DISASSEMBLER_ERROR);
3672       return;
3673     }
3674   disp = (start_pc + codep - start_codep + disp) & mask;
3675   set_op (disp, 0);
3676   print_operand_value (scratchbuf, 1, disp);
3677   oappend (scratchbuf);
3678 }
3679
3680 static void
3681 OP_SEG (dummy, sizeflag)
3682      int dummy ATTRIBUTE_UNUSED;
3683      int sizeflag ATTRIBUTE_UNUSED;
3684 {
3685   oappend (names_seg[reg]);
3686 }
3687
3688 static void
3689 OP_DIR (dummy, sizeflag)
3690      int dummy ATTRIBUTE_UNUSED;
3691      int sizeflag;
3692 {
3693   int seg, offset;
3694
3695   if (sizeflag & DFLAG)
3696     {
3697       offset = get32 ();
3698       seg = get16 ();
3699     }
3700   else
3701     {
3702       offset = get16 ();
3703       seg = get16 ();
3704     }
3705   used_prefixes |= (prefixes & PREFIX_DATA);
3706   if (intel_syntax)
3707     sprintf (scratchbuf, "0x%x,0x%x", seg, offset);
3708   else
3709     sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
3710   oappend (scratchbuf);
3711 }
3712
3713 static void
3714 OP_OFF (bytemode, sizeflag)
3715      int bytemode ATTRIBUTE_UNUSED;
3716      int sizeflag;
3717 {
3718   bfd_vma off;
3719
3720   append_seg ();
3721
3722   if ((sizeflag & AFLAG) || mode_64bit)
3723     off = get32 ();
3724   else
3725     off = get16 ();
3726
3727   if (intel_syntax)
3728     {
3729       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3730                         | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
3731         {
3732           oappend (names_seg[ds_reg - es_reg]);
3733           oappend (":");
3734         }
3735     }
3736   print_operand_value (scratchbuf, 1, off);
3737   oappend (scratchbuf);
3738 }
3739
3740 static void
3741 OP_OFF64 (bytemode, sizeflag)
3742      int bytemode ATTRIBUTE_UNUSED;
3743      int sizeflag ATTRIBUTE_UNUSED;
3744 {
3745   bfd_vma off;
3746
3747   if (!mode_64bit)
3748     {
3749       OP_OFF (bytemode, sizeflag);
3750       return;
3751     }
3752
3753   append_seg ();
3754
3755   off = get64 ();
3756
3757   if (intel_syntax)
3758     {
3759       if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3760                         | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
3761         {
3762           oappend (names_seg[ds_reg - es_reg]);
3763           oappend (":");
3764         }
3765     }
3766   print_operand_value (scratchbuf, 1, off);
3767   oappend (scratchbuf);
3768 }
3769
3770 static void
3771 ptr_reg (code, sizeflag)
3772      int code;
3773      int sizeflag;
3774 {
3775   const char *s;
3776   if (intel_syntax)
3777     oappend ("[");
3778   else
3779     oappend ("(");
3780
3781   USED_REX (REX_MODE64);
3782   if (rex & REX_MODE64)
3783     {
3784       if (!(sizeflag & AFLAG))
3785         s = names32[code - eAX_reg];
3786       else
3787         s = names64[code - eAX_reg];
3788     }
3789   else if (sizeflag & AFLAG)
3790     s = names32[code - eAX_reg];
3791   else
3792     s = names16[code - eAX_reg];
3793   oappend (s);
3794   if (intel_syntax)
3795     oappend ("]");
3796   else
3797     oappend (")");
3798 }
3799
3800 static void
3801 OP_ESreg (code, sizeflag)
3802      int code;
3803      int sizeflag;
3804 {
3805   oappend ("%es:" + intel_syntax);
3806   ptr_reg (code, sizeflag);
3807 }
3808
3809 static void
3810 OP_DSreg (code, sizeflag)
3811      int code;
3812      int sizeflag;
3813 {
3814   if ((prefixes
3815        & (PREFIX_CS
3816           | PREFIX_DS
3817           | PREFIX_SS
3818           | PREFIX_ES
3819           | PREFIX_FS
3820           | PREFIX_GS)) == 0)
3821     prefixes |= PREFIX_DS;
3822   append_seg ();
3823   ptr_reg (code, sizeflag);
3824 }
3825
3826 static void
3827 OP_C (dummy, sizeflag)
3828      int dummy ATTRIBUTE_UNUSED;
3829      int sizeflag ATTRIBUTE_UNUSED;
3830 {
3831   int add = 0;
3832   USED_REX (REX_EXTX);
3833   if (rex & REX_EXTX)
3834     add = 8;
3835   sprintf (scratchbuf, "%%cr%d", reg + add);
3836   oappend (scratchbuf + intel_syntax);
3837 }
3838
3839 static void
3840 OP_D (dummy, sizeflag)
3841      int dummy ATTRIBUTE_UNUSED;
3842      int sizeflag ATTRIBUTE_UNUSED;
3843 {
3844   int add = 0;
3845   USED_REX (REX_EXTX);
3846   if (rex & REX_EXTX)
3847     add = 8;
3848   if (intel_syntax)
3849     sprintf (scratchbuf, "db%d", reg + add);
3850   else
3851     sprintf (scratchbuf, "%%db%d", reg + add);
3852   oappend (scratchbuf);
3853 }
3854
3855 static void
3856 OP_T (dummy, sizeflag)
3857      int dummy ATTRIBUTE_UNUSED;
3858      int sizeflag ATTRIBUTE_UNUSED;
3859 {
3860   sprintf (scratchbuf, "%%tr%d", reg);
3861   oappend (scratchbuf + intel_syntax);
3862 }
3863
3864 static void
3865 OP_Rd (bytemode, sizeflag)
3866      int bytemode;
3867      int sizeflag;
3868 {
3869   if (mod == 3)
3870     OP_E (bytemode, sizeflag);
3871   else
3872     BadOp ();
3873 }
3874
3875 static void
3876 OP_MMX (bytemode, sizeflag)
3877      int bytemode ATTRIBUTE_UNUSED;
3878      int sizeflag ATTRIBUTE_UNUSED;
3879 {
3880   int add = 0;
3881   USED_REX (REX_EXTX);
3882   if (rex & REX_EXTX)
3883     add = 8;
3884   used_prefixes |= (prefixes & PREFIX_DATA);
3885   if (prefixes & PREFIX_DATA)
3886     sprintf (scratchbuf, "%%xmm%d", reg + add);
3887   else
3888     sprintf (scratchbuf, "%%mm%d", reg + add);
3889   oappend (scratchbuf + intel_syntax);
3890 }
3891
3892 static void
3893 OP_XMM (bytemode, sizeflag)
3894      int bytemode ATTRIBUTE_UNUSED;
3895      int sizeflag ATTRIBUTE_UNUSED;
3896 {
3897   int add = 0;
3898   USED_REX (REX_EXTX);
3899   if (rex & REX_EXTX)
3900     add = 8;
3901   sprintf (scratchbuf, "%%xmm%d", reg + add);
3902   oappend (scratchbuf + intel_syntax);
3903 }
3904
3905 static void
3906 OP_EM (bytemode, sizeflag)
3907      int bytemode;
3908      int sizeflag;
3909 {
3910   int add = 0;
3911   if (mod != 3)
3912     {
3913       OP_E (bytemode, sizeflag);
3914       return;
3915     }
3916   USED_REX (REX_EXTZ);
3917   if (rex & REX_EXTZ)
3918     add = 8;
3919
3920   /* Skip mod/rm byte.  */
3921   MODRM_CHECK;
3922   codep++;
3923   used_prefixes |= (prefixes & PREFIX_DATA);
3924   if (prefixes & PREFIX_DATA)
3925     sprintf (scratchbuf, "%%xmm%d", rm + add);
3926   else
3927     sprintf (scratchbuf, "%%mm%d", rm + add);
3928   oappend (scratchbuf + intel_syntax);
3929 }
3930
3931 static void
3932 OP_EX (bytemode, sizeflag)
3933      int bytemode;
3934      int sizeflag;
3935 {
3936   int add = 0;
3937   if (mod != 3)
3938     {
3939       OP_E (bytemode, sizeflag);
3940       return;
3941     }
3942   USED_REX (REX_EXTZ);
3943   if (rex & REX_EXTZ)
3944     add = 8;
3945
3946   /* Skip mod/rm byte.  */
3947   MODRM_CHECK;
3948   codep++;
3949   sprintf (scratchbuf, "%%xmm%d", rm + add);
3950   oappend (scratchbuf + intel_syntax);
3951 }
3952
3953 static void
3954 OP_MS (bytemode, sizeflag)
3955      int bytemode;
3956      int sizeflag;
3957 {
3958   if (mod == 3)
3959     OP_EM (bytemode, sizeflag);
3960   else
3961     BadOp ();
3962 }
3963
3964 static void
3965 OP_XS (bytemode, sizeflag)
3966      int bytemode;
3967      int sizeflag;
3968 {
3969   if (mod == 3)
3970     OP_EX (bytemode, sizeflag);
3971   else
3972     BadOp ();
3973 }
3974
3975 static const char *const Suffix3DNow[] = {
3976 /* 00 */        NULL,           NULL,           NULL,           NULL,
3977 /* 04 */        NULL,           NULL,           NULL,           NULL,
3978 /* 08 */        NULL,           NULL,           NULL,           NULL,
3979 /* 0C */        "pi2fw",        "pi2fd",        NULL,           NULL,
3980 /* 10 */        NULL,           NULL,           NULL,           NULL,
3981 /* 14 */        NULL,           NULL,           NULL,           NULL,
3982 /* 18 */        NULL,           NULL,           NULL,           NULL,
3983 /* 1C */        "pf2iw",        "pf2id",        NULL,           NULL,
3984 /* 20 */        NULL,           NULL,           NULL,           NULL,
3985 /* 24 */        NULL,           NULL,           NULL,           NULL,
3986 /* 28 */        NULL,           NULL,           NULL,           NULL,
3987 /* 2C */        NULL,           NULL,           NULL,           NULL,
3988 /* 30 */        NULL,           NULL,           NULL,           NULL,
3989 /* 34 */        NULL,           NULL,           NULL,           NULL,
3990 /* 38 */        NULL,           NULL,           NULL,           NULL,
3991 /* 3C */        NULL,           NULL,           NULL,           NULL,
3992 /* 40 */        NULL,           NULL,           NULL,           NULL,
3993 /* 44 */        NULL,           NULL,           NULL,           NULL,
3994 /* 48 */        NULL,           NULL,           NULL,           NULL,
3995 /* 4C */        NULL,           NULL,           NULL,           NULL,
3996 /* 50 */        NULL,           NULL,           NULL,           NULL,
3997 /* 54 */        NULL,           NULL,           NULL,           NULL,
3998 /* 58 */        NULL,           NULL,           NULL,           NULL,
3999 /* 5C */        NULL,           NULL,           NULL,           NULL,
4000 /* 60 */        NULL,           NULL,           NULL,           NULL,
4001 /* 64 */        NULL,           NULL,           NULL,           NULL,
4002 /* 68 */        NULL,           NULL,           NULL,           NULL,
4003 /* 6C */        NULL,           NULL,           NULL,           NULL,
4004 /* 70 */        NULL,           NULL,           NULL,           NULL,
4005 /* 74 */        NULL,           NULL,           NULL,           NULL,
4006 /* 78 */        NULL,           NULL,           NULL,           NULL,
4007 /* 7C */        NULL,           NULL,           NULL,           NULL,
4008 /* 80 */        NULL,           NULL,           NULL,           NULL,
4009 /* 84 */        NULL,           NULL,           NULL,           NULL,
4010 /* 88 */        NULL,           NULL,           "pfnacc",       NULL,
4011 /* 8C */        NULL,           NULL,           "pfpnacc",      NULL,
4012 /* 90 */        "pfcmpge",      NULL,           NULL,           NULL,
4013 /* 94 */        "pfmin",        NULL,           "pfrcp",        "pfrsqrt",
4014 /* 98 */        NULL,           NULL,           "pfsub",        NULL,
4015 /* 9C */        NULL,           NULL,           "pfadd",        NULL,
4016 /* A0 */        "pfcmpgt",      NULL,           NULL,           NULL,
4017 /* A4 */        "pfmax",        NULL,           "pfrcpit1",     "pfrsqit1",
4018 /* A8 */        NULL,           NULL,           "pfsubr",       NULL,
4019 /* AC */        NULL,           NULL,           "pfacc",        NULL,
4020 /* B0 */        "pfcmpeq",      NULL,           NULL,           NULL,
4021 /* B4 */        "pfmul",        NULL,           "pfrcpit2",     "pfmulhrw",
4022 /* B8 */        NULL,           NULL,           NULL,           "pswapd",
4023 /* BC */        NULL,           NULL,           NULL,           "pavgusb",
4024 /* C0 */        NULL,           NULL,           NULL,           NULL,
4025 /* C4 */        NULL,           NULL,           NULL,           NULL,
4026 /* C8 */        NULL,           NULL,           NULL,           NULL,
4027 /* CC */        NULL,           NULL,           NULL,           NULL,
4028 /* D0 */        NULL,           NULL,           NULL,           NULL,
4029 /* D4 */        NULL,           NULL,           NULL,           NULL,
4030 /* D8 */        NULL,           NULL,           NULL,           NULL,
4031 /* DC */        NULL,           NULL,           NULL,           NULL,
4032 /* E0 */        NULL,           NULL,           NULL,           NULL,
4033 /* E4 */        NULL,           NULL,           NULL,           NULL,
4034 /* E8 */        NULL,           NULL,           NULL,           NULL,
4035 /* EC */        NULL,           NULL,           NULL,           NULL,
4036 /* F0 */        NULL,           NULL,           NULL,           NULL,
4037 /* F4 */        NULL,           NULL,           NULL,           NULL,
4038 /* F8 */        NULL,           NULL,           NULL,           NULL,
4039 /* FC */        NULL,           NULL,           NULL,           NULL,
4040 };
4041
4042 static void
4043 OP_3DNowSuffix (bytemode, sizeflag)
4044      int bytemode ATTRIBUTE_UNUSED;
4045      int sizeflag ATTRIBUTE_UNUSED;
4046 {
4047   const char *mnemonic;
4048
4049   FETCH_DATA (the_info, codep + 1);
4050   /* AMD 3DNow! instructions are specified by an opcode suffix in the
4051      place where an 8-bit immediate would normally go.  ie. the last
4052      byte of the instruction.  */
4053   obufp = obuf + strlen (obuf);
4054   mnemonic = Suffix3DNow[*codep++ & 0xff];
4055   if (mnemonic)
4056     oappend (mnemonic);
4057   else
4058     {
4059       /* Since a variable sized modrm/sib chunk is between the start
4060          of the opcode (0x0f0f) and the opcode suffix, we need to do
4061          all the modrm processing first, and don't know until now that
4062          we have a bad opcode.  This necessitates some cleaning up.  */
4063       op1out[0] = '\0';
4064       op2out[0] = '\0';
4065       BadOp ();
4066     }
4067 }
4068
4069 static const char *simd_cmp_op[] = {
4070   "eq",
4071   "lt",
4072   "le",
4073   "unord",
4074   "neq",
4075   "nlt",
4076   "nle",
4077   "ord"
4078 };
4079
4080 static void
4081 OP_SIMD_Suffix (bytemode, sizeflag)
4082      int bytemode ATTRIBUTE_UNUSED;
4083      int sizeflag ATTRIBUTE_UNUSED;
4084 {
4085   unsigned int cmp_type;
4086
4087   FETCH_DATA (the_info, codep + 1);
4088   obufp = obuf + strlen (obuf);
4089   cmp_type = *codep++ & 0xff;
4090   if (cmp_type < 8)
4091     {
4092       char suffix1 = 'p', suffix2 = 's';
4093       used_prefixes |= (prefixes & PREFIX_REPZ);
4094       if (prefixes & PREFIX_REPZ)
4095         suffix1 = 's';
4096       else
4097         {
4098           used_prefixes |= (prefixes & PREFIX_DATA);
4099           if (prefixes & PREFIX_DATA)
4100             suffix2 = 'd';
4101           else
4102             {
4103               used_prefixes |= (prefixes & PREFIX_REPNZ);
4104               if (prefixes & PREFIX_REPNZ)
4105                 suffix1 = 's', suffix2 = 'd';
4106             }
4107         }
4108       sprintf (scratchbuf, "cmp%s%c%c",
4109                simd_cmp_op[cmp_type], suffix1, suffix2);
4110       used_prefixes |= (prefixes & PREFIX_REPZ);
4111       oappend (scratchbuf);
4112     }
4113   else
4114     {
4115       /* We have a bad extension byte.  Clean up.  */
4116       op1out[0] = '\0';
4117       op2out[0] = '\0';
4118       BadOp ();
4119     }
4120