gwj / at91sam9263 · Commits

Commit c2c73b42753a73d5d63428d67f325ea3b806c911

Authored by blueswir1
1 parent d40cdb10

Update i386-dis.c from binutils 2.17 

git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@6743 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 1286 additions and 561 deletions
i386-dis.c
  View file @c2c73b4
1 1 /* Print i386 instructions for GDB, the GNU debugger.
2 2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3   - 2001
4   - Free Software Foundation, Inc.
  3 + 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
5 4  
6   -This file is part of GDB.
  5 + This file is part of GDB.
7 6  
8   -This program is free software; you can redistribute it and/or modify
9   -it under the terms of the GNU General Public License as published by
10   -the Free Software Foundation; either version 2 of the License, or
11   -(at your option) any later version.
  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.
12 11  
13   -This program is distributed in the hope that it will be useful,
14   -but WITHOUT ANY WARRANTY; without even the implied warranty of
15   -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16   -GNU General Public License for more details.
  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.
17 16  
18   -You should have received a copy of the GNU General Public License
19   -along with this program; if not, write to the Free Software
20   -Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
  17 + You should have received a copy of the GNU General Public License
  18 + along with this program; if not, write to the Free Software
  19 + Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21 20  
22   -/*
23   - * 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
24   - * July 1988
25   - * modified by John Hassey (hassey@dg-rtp.dg.com)
26   - * x86-64 support added by Jan Hubicka (jh@suse.cz)
27   - */
  21 +/* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
  22 + July 1988
  23 + modified by John Hassey (hassey@dg-rtp.dg.com)
  24 + x86-64 support added by Jan Hubicka (jh@suse.cz)
  25 + VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
28 26  
29   -/*
30   - * The main tables describing the instructions is essentially a copy
31   - * of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32   - * Programmers Manual. Usually, there is a capital letter, followed
33   - * by a small letter. The capital letter tell the addressing mode,
34   - * and the small letter tells about the operand size. Refer to
35   - * the Intel manual for details.
36   - */
  27 +/* The main tables describing the instructions is essentially a copy
  28 + of the "Opcode Map" chapter (Appendix A) of the Intel 80386
  29 + Programmers Manual. Usually, there is a capital letter, followed
  30 + by a small letter. The capital letter tell the addressing mode,
  31 + and the small letter tells about the operand size. Refer to
  32 + the Intel manual for details. */
37 33  
38 34 #include <stdlib.h>
39 35 #include "dis-asm.h"
40 36 #include "qemu-common.h"
41 37  
42   -#define MAXLEN 20
  38 +#define MAXLEN 15
43 39  
44 40 #include <setjmp.h>
45 41  
... ... @@ -49,53 +45,63 @@ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
49 45 #define UNIXWARE_COMPAT 1
50 46 #endif
51 47  
52   -static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *));
53   -static void ckprefix PARAMS ((void));
54   -static const char *prefix_name PARAMS ((int, int));
55   -static int print_insn PARAMS ((bfd_vma, disassemble_info *));
56   -static void dofloat PARAMS ((int));
57   -static void OP_ST PARAMS ((int, int));
58   -static void OP_STi PARAMS ((int, int));
59   -static int putop PARAMS ((const char *, int));
60   -static void oappend PARAMS ((const char *));
61   -static void append_seg PARAMS ((void));
62   -static void OP_indirE PARAMS ((int, int));
63   -static void print_operand_value (char *buf, size_t bufsize, int hex,
64   - bfd_vma disp);
65   -static void OP_E PARAMS ((int, int));
66   -static void OP_G PARAMS ((int, int));
67   -static bfd_vma get64 PARAMS ((void));
68   -static bfd_signed_vma get32 PARAMS ((void));
69   -static bfd_signed_vma get32s PARAMS ((void));
70   -static int get16 PARAMS ((void));
71   -static void set_op PARAMS ((bfd_vma, int));
72   -static void OP_REG PARAMS ((int, int));
73   -static void OP_IMREG PARAMS ((int, int));
74   -static void OP_I PARAMS ((int, int));
75   -static void OP_I64 PARAMS ((int, int));
76   -static void OP_sI PARAMS ((int, int));
77   -static void OP_J PARAMS ((int, int));
78   -static void OP_SEG PARAMS ((int, int));
79   -static void OP_DIR PARAMS ((int, int));
80   -static void OP_OFF PARAMS ((int, int));
81   -static void OP_OFF64 PARAMS ((int, int));
82   -static void ptr_reg PARAMS ((int, int));
83   -static void OP_ESreg PARAMS ((int, int));
84   -static void OP_DSreg PARAMS ((int, int));
85   -static void OP_C PARAMS ((int, int));
86   -static void OP_D PARAMS ((int, int));
87   -static void OP_T PARAMS ((int, int));
88   -static void OP_Rd PARAMS ((int, int));
89   -static void OP_MMX PARAMS ((int, int));
90   -static void OP_XMM PARAMS ((int, int));
91   -static void OP_EM PARAMS ((int, int));
92   -static void OP_EX PARAMS ((int, int));
93   -static void OP_MS PARAMS ((int, int));
94   -static void OP_XS PARAMS ((int, int));
95   -static void OP_3DNowSuffix PARAMS ((int, int));
96   -static void OP_SIMD_Suffix PARAMS ((int, int));
97   -static void SIMD_Fixup PARAMS ((int, int));
98   -static void BadOp PARAMS ((void));
  48 +static int fetch_data (struct disassemble_info *, bfd_byte *);
  49 +static void ckprefix (void);
  50 +static const char *prefix_name (int, int);
  51 +static int print_insn (bfd_vma, disassemble_info *);
  52 +static void dofloat (int);
  53 +static void OP_ST (int, int);
  54 +static void OP_STi (int, int);
  55 +static int putop (const char *, int);
  56 +static void oappend (const char *);
  57 +static void append_seg (void);
  58 +static void OP_indirE (int, int);
  59 +static void print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp);
  60 +static void OP_E (int, int);
  61 +static void OP_G (int, int);
  62 +static bfd_vma get64 (void);
  63 +static bfd_signed_vma get32 (void);
  64 +static bfd_signed_vma get32s (void);
  65 +static int get16 (void);
  66 +static void set_op (bfd_vma, int);
  67 +static void OP_REG (int, int);
  68 +static void OP_IMREG (int, int);
  69 +static void OP_I (int, int);
  70 +static void OP_I64 (int, int);
  71 +static void OP_sI (int, int);
  72 +static void OP_J (int, int);
  73 +static void OP_SEG (int, int);
  74 +static void OP_DIR (int, int);
  75 +static void OP_OFF (int, int);
  76 +static void OP_OFF64 (int, int);
  77 +static void ptr_reg (int, int);
  78 +static void OP_ESreg (int, int);
  79 +static void OP_DSreg (int, int);
  80 +static void OP_C (int, int);
  81 +static void OP_D (int, int);
  82 +static void OP_T (int, int);
  83 +static void OP_Rd (int, int);
  84 +static void OP_MMX (int, int);
  85 +static void OP_XMM (int, int);
  86 +static void OP_EM (int, int);
  87 +static void OP_EX (int, int);
  88 +static void OP_MS (int, int);
  89 +static void OP_XS (int, int);
  90 +static void OP_M (int, int);
  91 +static void OP_VMX (int, int);
  92 +static void OP_0fae (int, int);
  93 +static void OP_0f07 (int, int);
  94 +static void NOP_Fixup (int, int);
  95 +static void OP_3DNowSuffix (int, int);
  96 +static void OP_SIMD_Suffix (int, int);
  97 +static void SIMD_Fixup (int, int);
  98 +static void PNI_Fixup (int, int);
  99 +static void SVME_Fixup (int, int);
  100 +static void INVLPG_Fixup (int, int);
  101 +static void BadOp (void);
  102 +static void SEG_Fixup (int, int);
  103 +static void VMX_Fixup (int, int);
  104 +static void REP_Fixup (int, int);
99 105  
100 106 struct dis_private {
101 107 /* Points to first byte not fetched. */
... ... @@ -110,8 +116,14 @@ struct dis_private {
110 116 when we can. */
111 117 #define FWAIT_OPCODE (0x9b)
112 118  
113   -/* Set to 1 for 64bit mode disassembly. */
114   -static int mode_64bit;
  119 +enum address_mode
  120 +{
  121 + mode_16bit,
  122 + mode_32bit,
  123 + mode_64bit
  124 +};
  125 +
  126 +static enum address_mode address_mode;
115 127  
116 128 /* Flags for the prefixes for the current instruction. See below. */
117 129 static int prefixes;
... ... @@ -162,24 +174,25 @@ static int used_prefixes;
162 174 ? 1 : fetch_data ((info), (addr)))
163 175  
164 176 static int
165   -fetch_data (info, addr)
166   - struct disassemble_info *info;
167   - bfd_byte *addr;
  177 +fetch_data (struct disassemble_info *info, bfd_byte *addr)
168 178 {
169 179 int status;
170 180 struct dis_private *priv = (struct dis_private *) info->private_data;
171 181 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
172 182  
173   - status = (*info->read_memory_func) (start,
174   - priv->max_fetched,
175   - addr - priv->max_fetched,
176   - info);
  183 + if (addr <= priv->the_buffer + MAXLEN)
  184 + status = (*info->read_memory_func) (start,
  185 + priv->max_fetched,
  186 + addr - priv->max_fetched,
  187 + info);
  188 + else
  189 + status = -1;
177 190 if (status != 0)
178 191 {
179 192 /* If we did manage to read at least one byte, then
180   - print_insn_i386 will do something sensible. Otherwise, print
181   - an error. We do that here because this is where we know
182   - STATUS. */
  193 + print_insn_i386 will do something sensible. Otherwise, print
  194 + an error. We do that here because this is where we know
  195 + STATUS. */
183 196 if (priv->max_fetched == priv->the_buffer)
184 197 (*info->memory_error_func) (status, start, info);
185 198 longjmp (priv->bailout, 1);
... ... @@ -194,15 +207,22 @@ fetch_data (info, addr)
194 207 #define Eb OP_E, b_mode
195 208 #define Ev OP_E, v_mode
196 209 #define Ed OP_E, d_mode
197   -#define indirEb OP_indirE, b_mode
198   -#define indirEv OP_indirE, v_mode
  210 +#define Eq OP_E, q_mode
  211 +#define Edq OP_E, dq_mode
  212 +#define Edqw OP_E, dqw_mode
  213 +#define indirEv OP_indirE, stack_v_mode
  214 +#define indirEp OP_indirE, f_mode
  215 +#define stackEv OP_E, stack_v_mode
  216 +#define Em OP_E, m_mode
199 217 #define Ew OP_E, w_mode
200 218 #define Ma OP_E, v_mode
201   -#define M OP_E, 0 /* lea, lgdt, etc. */
202   -#define Mp OP_E, 0 /* 32 or 48 bit memory operand for LDS, LES etc */
  219 +#define M OP_M, 0 /* lea, lgdt, etc. */
  220 +#define Mp OP_M, f_mode /* 32 or 48 bit memory operand for LDS, LES etc */
203 221 #define Gb OP_G, b_mode
204 222 #define Gv OP_G, v_mode
205 223 #define Gd OP_G, d_mode
  224 +#define Gdq OP_G, dq_mode
  225 +#define Gm OP_G, m_mode
206 226 #define Gw OP_G, w_mode
207 227 #define Rd OP_Rd, d_mode
208 228 #define Rm OP_Rd, m_mode
... ... @@ -212,11 +232,13 @@ fetch_data (info, addr)
212 232 #define Iq OP_I, q_mode
213 233 #define Iv64 OP_I64, v_mode
214 234 #define Iw OP_I, w_mode
  235 +#define I1 OP_I, const_1_mode
215 236 #define Jb OP_J, b_mode
216 237 #define Jv OP_J, v_mode
217 238 #define Cm OP_C, m_mode
218 239 #define Dm OP_D, m_mode
219 240 #define Td OP_T, d_mode
  241 +#define Sv SEG_Fixup, v_mode
220 242  
221 243 #define RMeAX OP_REG, eAX_reg
222 244 #define RMeBX OP_REG, eBX_reg
... ... @@ -255,7 +277,6 @@ fetch_data (info, addr)
255 277 #define eSI OP_IMREG, eSI_reg
256 278 #define eDI OP_IMREG, eDI_reg
257 279 #define AL OP_IMREG, al_reg
258   -#define AL OP_IMREG, al_reg
259 280 #define CL OP_IMREG, cl_reg
260 281 #define DL OP_IMREG, dl_reg
261 282 #define BL OP_IMREG, bl_reg
... ... @@ -269,10 +290,8 @@ fetch_data (info, addr)
269 290  
270 291 #define Sw OP_SEG, w_mode
271 292 #define Ap OP_DIR, 0
272   -#define Ob OP_OFF, b_mode
273   -#define Ob64 OP_OFF64, b_mode
274   -#define Ov OP_OFF, v_mode
275   -#define Ov64 OP_OFF64, v_mode
  293 +#define Ob OP_OFF64, b_mode
  294 +#define Ov OP_OFF64, v_mode
276 295 #define Xb OP_DSreg, eSI_reg
277 296 #define Xv OP_DSreg, eSI_reg
278 297 #define Yb OP_ESreg, eDI_reg
... ... @@ -292,10 +311,19 @@ fetch_data (info, addr)
292 311 #define EX OP_EX, v_mode
293 312 #define MS OP_MS, v_mode
294 313 #define XS OP_XS, v_mode
295   -#define None OP_E, 0
  314 +#define VM OP_VMX, q_mode
296 315 #define OPSUF OP_3DNowSuffix, 0
297 316 #define OPSIMD OP_SIMD_Suffix, 0
298 317  
  318 +/* Used handle "rep" prefix for string instructions. */
  319 +#define Xbr REP_Fixup, eSI_reg
  320 +#define Xvr REP_Fixup, eSI_reg
  321 +#define Ybr REP_Fixup, eDI_reg
  322 +#define Yvr REP_Fixup, eDI_reg
  323 +#define indirDXr REP_Fixup, indir_dx_reg
  324 +#define ALr REP_Fixup, al_reg
  325 +#define eAXr REP_Fixup, eAX_reg
  326 +
299 327 #define cond_jump_flag NULL, cond_jump_mode
300 328 #define loop_jcxz_flag NULL, loop_jcxz_mode
301 329  
... ... @@ -309,10 +337,16 @@ fetch_data (info, addr)
309 337 #define w_mode 3 /* word operand */
310 338 #define d_mode 4 /* double word operand */
311 339 #define q_mode 5 /* quad word operand */
312   -#define x_mode 6
313   -#define m_mode 7 /* d_mode in 32bit, q_mode in 64bit mode. */
314   -#define cond_jump_mode 8
315   -#define loop_jcxz_mode 9
  340 +#define t_mode 6 /* ten-byte operand */
  341 +#define x_mode 7 /* 16-byte XMM operand */
  342 +#define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */
  343 +#define cond_jump_mode 9
  344 +#define loop_jcxz_mode 10
  345 +#define dq_mode 11 /* operand size depends on REX prefixes. */
  346 +#define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */
  347 +#define f_mode 13 /* 4- or 6-byte pointer operand */
  348 +#define const_1_mode 14
  349 +#define stack_v_mode 15 /* v_mode for stack-related opcodes. */
316 350  
317 351 #define es_reg 100
318 352 #define cs_reg 101
... ... @@ -363,6 +397,7 @@ fetch_data (info, addr)
363 397 #define USE_GROUPS 2
364 398 #define USE_PREFIX_USER_TABLE 3
365 399 #define X86_64_SPECIAL 4
  400 +#define IS_3BYTE_OPCODE 5
366 401  
367 402 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
368 403  
... ... @@ -389,6 +424,8 @@ fetch_data (info, addr)
389 424 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
390 425 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
391 426 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
  427 +#define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0
  428 +#define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0
392 429  
393 430 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0
394 431 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0
... ... @@ -417,10 +454,19 @@ fetch_data (info, addr)
417 454 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
418 455 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
419 456 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
  457 +#define PREGRP27 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
  458 +#define PREGRP28 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
  459 +#define PREGRP29 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
  460 +#define PREGRP30 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
  461 +#define PREGRP31 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
  462 +#define PREGRP32 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
420 463  
421 464 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0
422 465  
423   -typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag));
  466 +#define THREE_BYTE_0 NULL, NULL, IS_3BYTE_OPCODE, NULL, 0, NULL, 0
  467 +#define THREE_BYTE_1 NULL, NULL, IS_3BYTE_OPCODE, NULL, 1, NULL, 0
  468 +
  469 +typedef void (*op_rtn) (int bytemode, int sizeflag);
424 470  
425 471 struct dis386 {
426 472 const char *name;
... ... @@ -435,9 +481,14 @@ struct dis386 {
435 481 /* Upper case letters in the instruction names here are macros.
436 482 'A' => print 'b' if no register operands or suffix_always is true
437 483 'B' => print 'b' if suffix_always is true
  484 + 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
  485 + . size prefix
438 486 'E' => print 'e' if 32-bit form of jcxz
439 487 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
440 488 'H' => print ",pt" or ",pn" branch hint
  489 + 'I' => honor following macro letter even in Intel mode (implemented only
  490 + . for some of the macro letters)
  491 + 'J' => print 'l'
441 492 'L' => print 'l' if suffix_always is true
442 493 'N' => print 'n' if instruction has no wait "prefix"
443 494 'O' => print 'd', or 'o'
... ... @@ -449,9 +500,11 @@ struct dis386 {
449 500 'S' => print 'w', 'l' or 'q' if suffix_always is true
450 501 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
451 502 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
452   - 'X' => print 's', 'd' depending on data16 prefix (for XMM)
  503 + 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
453 504 'W' => print 'b' or 'w' ("w" or "de" in intel mode)
  505 + 'X' => print 's', 'd' depending on data16 prefix (for XMM)
454 506 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
  507 + 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
455 508  
456 509 Many of the above letters print nothing in Intel mode. See "putop"
457 510 for the details.
... ... @@ -489,7 +542,7 @@ static const struct dis386 dis386[] = {
489 542 { "adcB", AL, Ib, XX },
490 543 { "adcS", eAX, Iv, XX },
491 544 { "push{T|}", ss, XX, XX },
492   - { "popT|}", ss, XX, XX },
  545 + { "pop{T|}", ss, XX, XX },
493 546 /* 18 */
494 547 { "sbbB", Eb, Gb, XX },
495 548 { "sbbS", Ev, Gv, XX },
... ... @@ -554,23 +607,23 @@ static const struct dis386 dis386[] = {
554 607 { "dec{S|}", RMeSI, XX, XX },
555 608 { "dec{S|}", RMeDI, XX, XX },
556 609 /* 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 },
  610 + { "pushV", RMrAX, XX, XX },
  611 + { "pushV", RMrCX, XX, XX },
  612 + { "pushV", RMrDX, XX, XX },
  613 + { "pushV", RMrBX, XX, XX },
  614 + { "pushV", RMrSP, XX, XX },
  615 + { "pushV", RMrBP, XX, XX },
  616 + { "pushV", RMrSI, XX, XX },
  617 + { "pushV", RMrDI, XX, XX },
565 618 /* 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 },
  619 + { "popV", RMrAX, XX, XX },
  620 + { "popV", RMrCX, XX, XX },
  621 + { "popV", RMrDX, XX, XX },
  622 + { "popV", RMrBX, XX, XX },
  623 + { "popV", RMrSP, XX, XX },
  624 + { "popV", RMrBP, XX, XX },
  625 + { "popV", RMrSI, XX, XX },
  626 + { "popV", RMrDI, XX, XX },
574 627 /* 60 */
575 628 { "pusha{P|}", XX, XX, XX },
576 629 { "popa{P|}", XX, XX, XX },
... ... @@ -585,10 +638,10 @@ static const struct dis386 dis386[] = {
585 638 { "imulS", Gv, Ev, Iv },
586 639 { "pushT", sIb, XX, XX },
587 640 { "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 },
  641 + { "ins{b||b|}", Ybr, indirDX, XX },
  642 + { "ins{R||R|}", Yvr, indirDX, XX },
  643 + { "outs{b||b|}", indirDXr, Xb, XX },
  644 + { "outs{R||R|}", indirDXr, Xv, XX },
592 645 /* 70 */
593 646 { "joH", Jb, XX, cond_jump_flag },
594 647 { "jnoH", Jb, XX, cond_jump_flag },
... ... @@ -621,13 +674,12 @@ static const struct dis386 dis386[] = {
621 674 { "movS", Ev, Gv, XX },
622 675 { "movB", Gb, Eb, XX },
623 676 { "movS", Gv, Ev, XX },
624   - { "movQ", Ev, Sw, XX },
  677 + { "movQ", Sv, Sw, XX },
625 678 { "leaS", Gv, M, XX },
626   - { "movQ", Sw, Ev, XX },
627   - { "popU", Ev, XX, XX },
  679 + { "movQ", Sw, Sv, XX },
  680 + { "popU", stackEv, XX, XX },
628 681 /* 90 */
629   - { "nop", XX, XX, XX },
630   - /* FIXME: NOP with REPz prefix is called PAUSE. */
  682 + { "nop", NOP_Fixup, 0, XX, XX },
631 683 { "xchgS", RMeCX, eAX, XX },
632 684 { "xchgS", RMeDX, eAX, XX },
633 685 { "xchgS", RMeBX, eAX, XX },
... ... @@ -638,28 +690,28 @@ static const struct dis386 dis386[] = {
638 690 /* 98 */
639 691 { "cW{tR||tR|}", XX, XX, XX },
640 692 { "cR{tO||tO|}", XX, XX, XX },
641   - { "lcall{T|}", Ap, XX, XX },
  693 + { "Jcall{T|}", Ap, XX, XX },
642 694 { "(bad)", XX, XX, XX }, /* fwait */
643 695 { "pushfT", XX, XX, XX },
644 696 { "popfT", XX, XX, XX },
645 697 { "sahf{|}", XX, XX, XX },
646 698 { "lahf{|}", XX, XX, XX },
647 699 /* 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 },
  700 + { "movB", AL, Ob, XX },
  701 + { "movS", eAX, Ov, XX },
  702 + { "movB", Ob, AL, XX },
  703 + { "movS", Ov, eAX, XX },
  704 + { "movs{b||b|}", Ybr, Xb, XX },
  705 + { "movs{R||R|}", Yvr, Xv, XX },
654 706 { "cmps{b||b|}", Xb, Yb, XX },
655 707 { "cmps{R||R|}", Xv, Yv, XX },
656 708 /* a8 */
657 709 { "testB", AL, Ib, XX },
658 710 { "testS", eAX, Iv, XX },
659   - { "stosB", Yb, AL, XX },
660   - { "stosS", Yv, eAX, XX },
661   - { "lodsB", AL, Xb, XX },
662   - { "lodsS", eAX, Xv, XX },
  711 + { "stosB", Ybr, AL, XX },
  712 + { "stosS", Yvr, eAX, XX },
  713 + { "lodsB", ALr, Xb, XX },
  714 + { "lodsS", eAXr, Xv, XX },
663 715 { "scasB", AL, Yb, XX },
664 716 { "scasS", eAX, Yv, XX },
665 717 /* b0 */
... ... @@ -728,7 +780,7 @@ static const struct dis386 dis386[] = {
728 780 /* e8 */
729 781 { "callT", Jv, XX, XX },
730 782 { "jmpT", Jv, XX, XX },
731   - { "ljmp{T|}", Ap, XX, XX },
  783 + { "Jjmp{T|}", Ap, XX, XX },
732 784 { "jmp", Jb, XX, XX },
733 785 { "inB", AL, indirDX, XX },
734 786 { "inS", eAX, indirDX, XX },
... ... @@ -736,7 +788,7 @@ static const struct dis386 dis386[] = {
736 788 { "outS", indirDX, eAX, XX },
737 789 /* f0 */
738 790 { "(bad)", XX, XX, XX }, /* lock prefix */
739   - { "(bad)", XX, XX, XX },
  791 + { "icebp", XX, XX, XX },
740 792 { "(bad)", XX, XX, XX }, /* repne */
741 793 { "(bad)", XX, XX, XX }, /* repz */
742 794 { "hlt", XX, XX, XX },
... ... @@ -776,11 +828,11 @@ static const struct dis386 dis386_twobyte[] = {
776 828 /* 10 */
777 829 { PREGRP8 },
778 830 { PREGRP9 },
779   - { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
  831 + { PREGRP30 },
780 832 { "movlpX", EX, XM, SIMD_Fixup, 'h' },
781 833 { "unpcklpX", XM, EX, XX },
782 834 { "unpckhpX", XM, EX, XX },
783   - { "movhpX", XM, EX, SIMD_Fixup, 'l' },
  835 + { PREGRP31 },
784 836 { "movhpX", EX, XM, SIMD_Fixup, 'l' },
785 837 /* 18 */
786 838 { GRP14 },
... ... @@ -792,10 +844,10 @@ static const struct dis386 dis386_twobyte[] = {
792 844 { "(bad)", XX, XX, XX },
793 845 { "(bad)", XX, XX, XX },
794 846 /* 20 */
795   - { "movL", Rm, Cm, XX },
796   - { "movL", Rm, Dm, XX },
797   - { "movL", Cm, Rm, XX },
798   - { "movL", Dm, Rm, XX },
  847 + { "movZ", Rm, Cm, XX },
  848 + { "movZ", Rm, Dm, XX },
  849 + { "movZ", Cm, Rm, XX },
  850 + { "movZ", Dm, Rm, XX },
799 851 { "movL", Rd, Td, XX },
800 852 { "(bad)", XX, XX, XX },
801 853 { "movL", Td, Rd, XX },
... ... @@ -819,9 +871,9 @@ static const struct dis386 dis386_twobyte[] = {
819 871 { "(bad)", XX, XX, XX },
820 872 { "(bad)", XX, XX, XX },
821 873 /* 38 */
  874 + { THREE_BYTE_0 },
822 875 { "(bad)", XX, XX, XX },
823   - { "(bad)", XX, XX, XX },
824   - { "(bad)", XX, XX, XX },
  876 + { THREE_BYTE_1 },
825 877 { "(bad)", XX, XX, XX },
826 878 { "(bad)", XX, XX, XX },
827 879 { "(bad)", XX, XX, XX },
... ... @@ -846,7 +898,7 @@ static const struct dis386 dis386_twobyte[] = {
846 898 { "cmovle", Gv, Ev, XX },
847 899 { "cmovg", Gv, Ev, XX },
848 900 /* 50 */
849   - { "movmskpX", Gd, XS, XX },
  901 + { "movmskpX", Gdq, XS, XX },
850 902 { PREGRP13 },
851 903 { PREGRP12 },
852 904 { PREGRP11 },
... ... @@ -879,7 +931,7 @@ static const struct dis386 dis386_twobyte[] = {
879 931 { "packssdw", MX, EM, XX },
880 932 { PREGRP26 },
881 933 { PREGRP24 },
882   - { "movd", MX, Ed, XX },
  934 + { "movd", MX, Edq, XX },
883 935 { PREGRP19 },
884 936 /* 70 */
885 937 { PREGRP22 },
... ... @@ -891,12 +943,12 @@ static const struct dis386 dis386_twobyte[] = {
891 943 { "pcmpeqd", MX, EM, XX },
892 944 { "emms", XX, XX, XX },
893 945 /* 78 */
  946 + { "vmread", Em, Gm, XX },
  947 + { "vmwrite", Gm, Em, XX },
894 948 { "(bad)", XX, XX, XX },
895 949 { "(bad)", XX, XX, XX },
896   - { "(bad)", XX, XX, XX },
897   - { "(bad)", XX, XX, XX },
898   - { "(bad)", XX, XX, XX },
899   - { "(bad)", XX, XX, XX },
  950 + { PREGRP28 },
  951 + { PREGRP29 },
900 952 { PREGRP23 },
901 953 { PREGRP20 },
902 954 /* 80 */
... ... @@ -942,8 +994,8 @@ static const struct dis386 dis386_twobyte[] = {
942 994 { "btS", Ev, Gv, XX },
943 995 { "shldS", Ev, Gv, Ib },
944 996 { "shldS", Ev, Gv, CL },
945   - { "(bad)", XX, XX, XX },
946   - { "(bad)", XX, XX, XX },
  997 + { GRPPADLCK2 },
  998 + { GRPPADLCK1 },
947 999 /* a8 */
948 1000 { "pushT", gs, XX, XX },
949 1001 { "popT", gs, XX, XX },
... ... @@ -976,8 +1028,8 @@ static const struct dis386 dis386_twobyte[] = {
976 1028 { "xaddS", Ev, Gv, XX },
977 1029 { PREGRP1 },
978 1030 { "movntiS", Ev, Gv, XX },
979   - { "pinsrw", MX, Ed, Ib },
980   - { "pextrw", Gd, MS, Ib },
  1031 + { "pinsrw", MX, Edqw, Ib },
  1032 + { "pextrw", Gdq, MS, Ib },
981 1033 { "shufpX", XM, EX, Ib },
982 1034 { GRP9 },
983 1035 /* c8 */
... ... @@ -990,14 +1042,14 @@ static const struct dis386 dis386_twobyte[] = {
990 1042 { "bswap", RMeSI, XX, XX },
991 1043 { "bswap", RMeDI, XX, XX },
992 1044 /* d0 */
993   - { "(bad)", XX, XX, XX },
  1045 + { PREGRP27 },
994 1046 { "psrlw", MX, EM, XX },
995 1047 { "psrld", MX, EM, XX },
996 1048 { "psrlq", MX, EM, XX },
997 1049 { "paddq", MX, EM, XX },
998 1050 { "pmullw", MX, EM, XX },
999 1051 { PREGRP21 },
1000   - { "pmovmskb", Gd, MS, XX },
  1052 + { "pmovmskb", Gdq, MS, XX },
1001 1053 /* d8 */
1002 1054 { "psubusb", MX, EM, XX },
1003 1055 { "psubusw", MX, EM, XX },
... ... @@ -1026,7 +1078,7 @@ static const struct dis386 dis386_twobyte[] = {
1026 1078 { "pmaxsw", MX, EM, XX },
1027 1079 { "pxor", MX, EM, XX },
1028 1080 /* f0 */
1029   - { "(bad)", XX, XX, XX },
  1081 + { PREGRP32 },
1030 1082 { "psllw", MX, EM, XX },
1031 1083 { "pslld", MX, EM, XX },
1032 1084 { "psllq", MX, EM, XX },
... ... @@ -1074,19 +1126,19 @@ static const unsigned char twobyte_has_modrm[256] = {
1074 1126 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1075 1127 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
1076 1128 /* 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 */
  1129 + /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1078 1130 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1079 1131 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1080 1132 /* 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 */
  1133 + /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1082 1134 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1083 1135 /* 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 */
  1136 + /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1085 1137 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
1086 1138 /* 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 */
  1139 + /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1088 1140 /* 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 */
  1141 + /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1090 1142 /* ------------------------------- */
1091 1143 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1092 1144 };
... ... @@ -1095,21 +1147,21 @@ static const unsigned char twobyte_uses_SSE_prefix[256] = {
1095 1147 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1096 1148 /* ------------------------------- */
1097 1149 /* 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 */
  1150 + /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1099 1151 /* 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 */
  1152 + /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1101 1153 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1102 1154 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1103 1155 /* 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 */
  1156 + /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
1105 1157 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1106 1158 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1107 1159 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1108 1160 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1109 1161 /* 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 */
  1162 + /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1111 1163 /* 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 */
  1164 + /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1113 1165 /* ------------------------------- */
1114 1166 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1115 1167 };
... ... @@ -1249,25 +1301,25 @@ static const struct dis386 grps[][8] = {
1249 1301 },
1250 1302 /* GRP2b_one */
1251 1303 {
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 },
  1304 + { "rolA", Eb, I1, XX },
  1305 + { "rorA", Eb, I1, XX },
  1306 + { "rclA", Eb, I1, XX },
  1307 + { "rcrA", Eb, I1, XX },
  1308 + { "shlA", Eb, I1, XX },
  1309 + { "shrA", Eb, I1, XX },
1258 1310 { "(bad)", XX, XX, XX },
1259   - { "sarA", Eb, XX, XX },
  1311 + { "sarA", Eb, I1, XX },
1260 1312 },
1261 1313 /* GRP2S_one */
1262 1314 {
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 },
  1315 + { "rolQ", Ev, I1, XX },
  1316 + { "rorQ", Ev, I1, XX },
  1317 + { "rclQ", Ev, I1, XX },
  1318 + { "rcrQ", Ev, I1, XX },
  1319 + { "shlQ", Ev, I1, XX },
  1320 + { "shrQ", Ev, I1, XX },
1269 1321 { "(bad)", XX, XX, XX},
1270   - { "sarQ", Ev, XX, XX },
  1322 + { "sarQ", Ev, I1, XX },
1271 1323 },
1272 1324 /* GRP2b_cl */
1273 1325 {
... ... @@ -1329,10 +1381,10 @@ static const struct dis386 grps[][8] = {
1329 1381 { "incQ", Ev, XX, XX },
1330 1382 { "decQ", Ev, XX, XX },
1331 1383 { "callT", indirEv, XX, XX },
1332   - { "lcallT", indirEv, XX, XX },
  1384 + { "JcallT", indirEp, XX, XX },
1333 1385 { "jmpT", indirEv, XX, XX },
1334   - { "ljmpT", indirEv, XX, XX },
1335   - { "pushU", Ev, XX, XX },
  1386 + { "JjmpT", indirEp, XX, XX },
  1387 + { "pushU", stackEv, XX, XX },
1336 1388 { "(bad)", XX, XX, XX },
1337 1389 },
1338 1390 /* GRP6 */
... ... @@ -1348,14 +1400,14 @@ static const struct dis386 grps[][8] = {
1348 1400 },
1349 1401 /* GRP7 */
1350 1402 {
1351   - { "sgdtQ", M, XX, XX },
1352   - { "sidtQ", M, XX, XX },
1353   - { "lgdtQ", M, XX, XX },
1354   - { "lidtQ", M, XX, XX },
  1403 + { "sgdtIQ", VMX_Fixup, 0, XX, XX },
  1404 + { "sidtIQ", PNI_Fixup, 0, XX, XX },
  1405 + { "lgdt{Q|Q||}", M, XX, XX },
  1406 + { "lidt{Q|Q||}", SVME_Fixup, 0, XX, XX },
1355 1407 { "smswQ", Ev, XX, XX },
1356 1408 { "(bad)", XX, XX, XX },
1357 1409 { "lmsw", Ew, XX, XX },
1358   - { "invlpg", Ew, XX, XX },
  1410 + { "invlpg", INVLPG_Fixup, w_mode, XX, XX },
1359 1411 },
1360 1412 /* GRP8 */
1361 1413 {
... ... @@ -1371,13 +1423,13 @@ static const struct dis386 grps[][8] = {
1371 1423 /* GRP9 */
1372 1424 {
1373 1425 { "(bad)", XX, XX, XX },
1374   - { "cmpxchg8b", Ev, XX, XX },
1375   - { "(bad)", XX, XX, XX },
1376   - { "(bad)", XX, XX, XX },
  1426 + { "cmpxchg8b", Eq, XX, XX },
1377 1427 { "(bad)", XX, XX, XX },
1378 1428 { "(bad)", XX, XX, XX },
1379 1429 { "(bad)", XX, XX, XX },
1380 1430 { "(bad)", XX, XX, XX },
  1431 + { "", VM, XX, XX }, /* See OP_VMX. */
  1432 + { "vmptrst", Eq, XX, XX },
1381 1433 },
1382 1434 /* GRP10 */
1383 1435 {
... ... @@ -1419,10 +1471,9 @@ static const struct dis386 grps[][8] = {
1419 1471 { "ldmxcsr", Ev, XX, XX },
1420 1472 { "stmxcsr", Ev, XX, XX },
1421 1473 { "(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! */
  1474 + { "lfence", OP_0fae, 0, XX, XX },
  1475 + { "mfence", OP_0fae, 0, XX, XX },
  1476 + { "clflush", OP_0fae, 0, XX, XX },
1426 1477 },
1427 1478 /* GRP14 */
1428 1479 {
... ... @@ -1445,6 +1496,28 @@ static const struct dis386 grps[][8] = {
1445 1496 { "(bad)", XX, XX, XX },
1446 1497 { "(bad)", XX, XX, XX },
1447 1498 { "(bad)", XX, XX, XX },
  1499 + },
  1500 + /* GRPPADLCK1 */
  1501 + {
  1502 + { "xstore-rng", OP_0f07, 0, XX, XX },
  1503 + { "xcrypt-ecb", OP_0f07, 0, XX, XX },
  1504 + { "xcrypt-cbc", OP_0f07, 0, XX, XX },
  1505 + { "xcrypt-ctr", OP_0f07, 0, XX, XX },
  1506 + { "xcrypt-cfb", OP_0f07, 0, XX, XX },
  1507 + { "xcrypt-ofb", OP_0f07, 0, XX, XX },
  1508 + { "(bad)", OP_0f07, 0, XX, XX },
  1509 + { "(bad)", OP_0f07, 0, XX, XX },
  1510 + },
  1511 + /* GRPPADLCK2 */
  1512 + {
  1513 + { "montmul", OP_0f07, 0, XX, XX },
  1514 + { "xsha1", OP_0f07, 0, XX, XX },
  1515 + { "xsha256", OP_0f07, 0, XX, XX },
  1516 + { "(bad)", OP_0f07, 0, XX, XX },
  1517 + { "(bad)", OP_0f07, 0, XX, XX },
  1518 + { "(bad)", OP_0f07, 0, XX, XX },
  1519 + { "(bad)", OP_0f07, 0, XX, XX },
  1520 + { "(bad)", OP_0f07, 0, XX, XX },
1448 1521 }
1449 1522 };
1450 1523  
... ... @@ -1612,9 +1685,9 @@ static const struct dis386 prefix_user_table[][4] = {
1612 1685 },
1613 1686 /* PREGRP23 */
1614 1687 {
1615   - { "movd", Ed, MX, XX },
  1688 + { "movd", Edq, MX, XX },
1616 1689 { "movq", XM, EX, XX },
1617   - { "movd", Ed, XM, XX },
  1690 + { "movd", Edq, XM, XX },
1618 1691 { "(bad)", Ed, XM, XX },
1619 1692 },
1620 1693 /* PREGRP24 */
... ... @@ -1626,10 +1699,10 @@ static const struct dis386 prefix_user_table[][4] = {
1626 1699 },
1627 1700 /* PREGRP25 */
1628 1701 {
1629   - { "movntq", Ev, MX, XX },
1630   - { "(bad)", Ev, XM, XX },
1631   - { "movntdq", Ev, XM, XX },
1632   - { "(bad)", Ev, XM, XX },
  1702 + { "movntq", EM, MX, XX },
  1703 + { "(bad)", EM, XM, XX },
  1704 + { "movntdq", EM, XM, XX },
  1705 + { "(bad)", EM, XM, XX },
1633 1706 },
1634 1707 /* PREGRP26 */
1635 1708 {
... ... @@ -1638,6 +1711,48 @@ static const struct dis386 prefix_user_table[][4] = {
1638 1711 { "punpcklqdq", XM, EX, XX },
1639 1712 { "(bad)", XM, EX, XX },
1640 1713 },
  1714 + /* PREGRP27 */
  1715 + {
  1716 + { "(bad)", MX, EX, XX },
  1717 + { "(bad)", XM, EX, XX },
  1718 + { "addsubpd", XM, EX, XX },
  1719 + { "addsubps", XM, EX, XX },
  1720 + },
  1721 + /* PREGRP28 */
  1722 + {
  1723 + { "(bad)", MX, EX, XX },
  1724 + { "(bad)", XM, EX, XX },
  1725 + { "haddpd", XM, EX, XX },
  1726 + { "haddps", XM, EX, XX },
  1727 + },
  1728 + /* PREGRP29 */
  1729 + {
  1730 + { "(bad)", MX, EX, XX },
  1731 + { "(bad)", XM, EX, XX },
  1732 + { "hsubpd", XM, EX, XX },
  1733 + { "hsubps", XM, EX, XX },
  1734 + },
  1735 + /* PREGRP30 */
  1736 + {
  1737 + { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
  1738 + { "movsldup", XM, EX, XX },
  1739 + { "movlpd", XM, EX, XX },
  1740 + { "movddup", XM, EX, XX },
  1741 + },
  1742 + /* PREGRP31 */
  1743 + {
  1744 + { "movhpX", XM, EX, SIMD_Fixup, 'l' },
  1745 + { "movshdup", XM, EX, XX },
  1746 + { "movhpd", XM, EX, XX },
  1747 + { "(bad)", XM, EX, XX },
  1748 + },
  1749 + /* PREGRP32 */
  1750 + {
  1751 + { "(bad)", XM, EX, XX },
  1752 + { "(bad)", XM, EX, XX },
  1753 + { "(bad)", XM, EX, XX },
  1754 + { "lddqu", XM, M, XX },
  1755 + },
1641 1756 };
1642 1757  
1643 1758 static const struct dis386 x86_64_table[][2] = {
... ... @@ -1647,10 +1762,83 @@ static const struct dis386 x86_64_table[][2] = {
1647 1762 },
1648 1763 };
1649 1764  
  1765 +static const struct dis386 three_byte_table[][32] = {
  1766 + /* THREE_BYTE_0 */
  1767 + {
  1768 + { "pshufb", MX, EM, XX },
  1769 + { "phaddw", MX, EM, XX },
  1770 + { "phaddd", MX, EM, XX },
  1771 + { "phaddsw", MX, EM, XX },
  1772 + { "pmaddubsw", MX, EM, XX },
  1773 + { "phsubw", MX, EM, XX },
  1774 + { "phsubd", MX, EM, XX },
  1775 + { "phsubsw", MX, EM, XX },
  1776 + { "psignb", MX, EM, XX },
  1777 + { "psignw", MX, EM, XX },
  1778 + { "psignd", MX, EM, XX },
  1779 + { "pmulhrsw", MX, EM, XX },
  1780 + { "(bad)", XX, XX, XX },
  1781 + { "(bad)", XX, XX, XX },
  1782 + { "(bad)", XX, XX, XX },
  1783 + { "(bad)", XX, XX, XX },
  1784 + { "(bad)", XX, XX, XX },
  1785 + { "(bad)", XX, XX, XX },
  1786 + { "(bad)", XX, XX, XX },
  1787 + { "(bad)", XX, XX, XX },
  1788 + { "(bad)", XX, XX, XX },
  1789 + { "(bad)", XX, XX, XX },
  1790 + { "(bad)", XX, XX, XX },
  1791 + { "(bad)", XX, XX, XX },
  1792 + { "(bad)", XX, XX, XX },
  1793 + { "(bad)", XX, XX, XX },
  1794 + { "(bad)", XX, XX, XX },
  1795 + { "(bad)", XX, XX, XX },
  1796 + { "pabsb", MX, EM, XX },
  1797 + { "pabsw", MX, EM, XX },
  1798 + { "pabsd", MX, EM, XX },
  1799 + { "(bad)", XX, XX, XX }
  1800 + },
  1801 + /* THREE_BYTE_1 */
  1802 + {
  1803 + { "(bad)", XX, XX, XX },
  1804 + { "(bad)", XX, XX, XX },
  1805 + { "(bad)", XX, XX, XX },
  1806 + { "(bad)", XX, XX, XX },
  1807 + { "(bad)", XX, XX, XX },
  1808 + { "(bad)", XX, XX, XX },
  1809 + { "(bad)", XX, XX, XX },
  1810 + { "(bad)", XX, XX, XX },
  1811 + { "(bad)", XX, XX, XX },
  1812 + { "(bad)", XX, XX, XX },
  1813 + { "(bad)", XX, XX, XX },
  1814 + { "(bad)", XX, XX, XX },
  1815 + { "(bad)", XX, XX, XX },
  1816 + { "(bad)", XX, XX, XX },
  1817 + { "(bad)", XX, XX, XX },
  1818 + { "palignr", MX, EM, Ib },
  1819 + { "(bad)", XX, XX, XX },
  1820 + { "(bad)", XX, XX, XX },
  1821 + { "(bad)", XX, XX, XX },
  1822 + { "(bad)", XX, XX, XX },
  1823 + { "(bad)", XX, XX, XX },
  1824 + { "(bad)", XX, XX, XX },
  1825 + { "(bad)", XX, XX, XX },
  1826 + { "(bad)", XX, XX, XX },
  1827 + { "(bad)", XX, XX, XX },
  1828 + { "(bad)", XX, XX, XX },
  1829 + { "(bad)", XX, XX, XX },
  1830 + { "(bad)", XX, XX, XX },
  1831 + { "(bad)", XX, XX, XX },
  1832 + { "(bad)", XX, XX, XX },
  1833 + { "(bad)", XX, XX, XX },
  1834 + { "(bad)", XX, XX, XX }
  1835 + },
  1836 +};
  1837 +
1650 1838 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
1651 1839  
1652 1840 static void
1653   -ckprefix ()
  1841 +ckprefix (void)
1654 1842 {
1655 1843 int newrex;
1656 1844 rex = 0;
... ... @@ -1680,7 +1868,7 @@ ckprefix ()
1680 1868 case 0x4d:
1681 1869 case 0x4e:
1682 1870 case 0x4f:
1683   - if (mode_64bit)
  1871 + if (address_mode == mode_64bit)
1684 1872 newrex = *codep;
1685 1873 else
1686 1874 return;
... ... @@ -1722,7 +1910,7 @@ ckprefix ()
1722 1910 /* fwait is really an instruction. If there are prefixes
1723 1911 before the fwait, they belong to the fwait, *not* to the
1724 1912 following instruction. */
1725   - if (prefixes)
  1913 + if (prefixes || rex)
1726 1914 {
1727 1915 prefixes |= PREFIX_FWAIT;
1728 1916 codep++;
... ... @@ -1736,8 +1924,8 @@ ckprefix ()
1736 1924 /* Rex is ignored when followed by another prefix. */
1737 1925 if (rex)
1738 1926 {
1739   - oappend (prefix_name (rex, 0));
1740   - oappend (" ");
  1927 + rex_used = rex;
  1928 + return;
1741 1929 }
1742 1930 rex = newrex;
1743 1931 codep++;
... ... @@ -1748,9 +1936,7 @@ ckprefix ()
1748 1936 prefix byte. */
1749 1937  
1750 1938 static const char *
1751   -prefix_name (pref, sizeflag)
1752   - int pref;
1753   - int sizeflag;
  1939 +prefix_name (int pref, int sizeflag)
1754 1940 {
1755 1941 switch (pref)
1756 1942 {
... ... @@ -1808,10 +1994,10 @@ prefix_name (pref, sizeflag)
1808 1994 case 0x66:
1809 1995 return (sizeflag & DFLAG) ? "data16" : "data32";
1810 1996 case 0x67:
1811   - if (mode_64bit)
1812   - return (sizeflag & AFLAG) ? "addr32" : "addr64";
  1997 + if (address_mode == mode_64bit)
  1998 + return (sizeflag & AFLAG) ? "addr32" : "addr64";
1813 1999 else
1814   - return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32";
  2000 + return (sizeflag & AFLAG) ? "addr16" : "addr32";
1815 2001 case FWAIT_OPCODE:
1816 2002 return "fwait";
1817 2003 default:
... ... @@ -1821,6 +2007,7 @@ prefix_name (pref, sizeflag)
1821 2007  
1822 2008 static char op1out[100], op2out[100], op3out[100];
1823 2009 static int op_ad, op_index[3];
  2010 +static int two_source_ops;
1824 2011 static bfd_vma op_address[3];
1825 2012 static bfd_vma op_riprel[3];
1826 2013 static bfd_vma start_pc;
... ... @@ -1834,16 +2021,14 @@ static bfd_vma start_pc;
1834 2021 * The function returns the length of this instruction in bytes.
1835 2022 */
1836 2023  
1837   -static int8_t intel_syntax;
  2024 +static char intel_syntax;
1838 2025 static char open_char;
1839 2026 static char close_char;
1840 2027 static char separator_char;
1841 2028 static char scale_char;
1842 2029  
1843 2030 int
1844   -print_insn_i386 (pc, info)
1845   - bfd_vma pc;
1846   - disassemble_info *info;
  2031 +print_insn_i386 (bfd_vma pc, disassemble_info *info)
1847 2032 {
1848 2033 intel_syntax = -1;
1849 2034  
... ... @@ -1851,24 +2036,24 @@ print_insn_i386 (pc, info)
1851 2036 }
1852 2037  
1853 2038 static int
1854   -print_insn (pc, info)
1855   - bfd_vma pc;
1856   - disassemble_info *info;
  2039 +print_insn (bfd_vma pc, disassemble_info *info)
1857 2040 {
1858 2041 const struct dis386 *dp;
1859 2042 int i;
1860   - int two_source_ops;
1861 2043 char *first, *second, *third;
1862 2044 int needcomma;
1863   - unsigned char uses_SSE_prefix;
  2045 + unsigned char uses_SSE_prefix, uses_LOCK_prefix;
1864 2046 int sizeflag;
1865 2047 const char *p;
1866 2048 struct dis_private priv;
1867 2049  
1868   - mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax
1869   - || info->mach == bfd_mach_x86_64);
  2050 + if (info->mach == bfd_mach_x86_64_intel_syntax
  2051 + || info->mach == bfd_mach_x86_64)
  2052 + address_mode = mode_64bit;
  2053 + else
  2054 + address_mode = mode_32bit;
1870 2055  
1871   - if (intel_syntax == -1)
  2056 + if (intel_syntax == (char) -1)
1872 2057 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
1873 2058 || info->mach == bfd_mach_x86_64_intel_syntax);
1874 2059  
... ... @@ -1886,17 +2071,17 @@ print_insn (pc, info)
1886 2071 {
1887 2072 if (strncmp (p, "x86-64", 6) == 0)
1888 2073 {
1889   - mode_64bit = 1;
  2074 + address_mode = mode_64bit;
1890 2075 priv.orig_sizeflag = AFLAG | DFLAG;
1891 2076 }
1892 2077 else if (strncmp (p, "i386", 4) == 0)
1893 2078 {
1894   - mode_64bit = 0;
  2079 + address_mode = mode_32bit;
1895 2080 priv.orig_sizeflag = AFLAG | DFLAG;
1896 2081 }
1897 2082 else if (strncmp (p, "i8086", 5) == 0)
1898 2083 {
1899   - mode_64bit = 0;
  2084 + address_mode = mode_16bit;
1900 2085 priv.orig_sizeflag = 0;
1901 2086 }
1902 2087 else if (strncmp (p, "intel", 5) == 0)
... ... @@ -1962,7 +2147,7 @@ print_insn (pc, info)
1962 2147 puts most long word instructions on a single line. */
1963 2148 info->bytes_per_line = 7;
1964 2149  
1965   - info->private_data = (PTR) &priv;
  2150 + info->private_data = &priv;
1966 2151 priv.max_fetched = priv.the_buffer;
1967 2152 priv.insn_start = pc;
1968 2153  
... ... @@ -2012,13 +2197,14 @@ print_insn (pc, info)
2012 2197 FETCH_DATA (info, codep + 1);
2013 2198 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
2014 2199  
2015   - if ((prefixes & PREFIX_FWAIT)
2016   - && ((*codep < 0xd8) || (*codep > 0xdf)))
  2200 + if (((prefixes & PREFIX_FWAIT)
  2201 + && ((*codep < 0xd8) || (*codep > 0xdf)))
  2202 + || (rex && rex_used))
2017 2203 {
2018 2204 const char *name;
2019 2205  
2020   - /* fwait not followed by floating point instruction. Print the
2021   - first prefix, which is probably fwait itself. */
  2206 + /* fwait not followed by floating point instruction, or rex followed
  2207 + by other prefixes. Print the first prefix. */
2022 2208 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2023 2209 if (name == NULL)
2024 2210 name = INTERNAL_DISASSEMBLER_ERROR;
... ... @@ -2032,12 +2218,14 @@ print_insn (pc, info)
2032 2218 dp = &dis386_twobyte[*++codep];
2033 2219 need_modrm = twobyte_has_modrm[*codep];
2034 2220 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
  2221 + uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
2035 2222 }
2036 2223 else
2037 2224 {
2038 2225 dp = &dis386[*codep];
2039 2226 need_modrm = onebyte_has_modrm[*codep];
2040 2227 uses_SSE_prefix = 0;
  2228 + uses_LOCK_prefix = 0;
2041 2229 }
2042 2230 codep++;
2043 2231  
... ... @@ -2051,7 +2239,7 @@ print_insn (pc, info)
2051 2239 oappend ("repnz ");
2052 2240 used_prefixes |= PREFIX_REPNZ;
2053 2241 }
2054   - if (prefixes & PREFIX_LOCK)
  2242 + if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
2055 2243 {
2056 2244 oappend ("lock ");
2057 2245 used_prefixes |= PREFIX_LOCK;
... ... @@ -2062,7 +2250,7 @@ print_insn (pc, info)
2062 2250 sizeflag ^= AFLAG;
2063 2251 if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
2064 2252 {
2065   - if ((sizeflag & AFLAG) || mode_64bit)
  2253 + if ((sizeflag & AFLAG) || address_mode == mode_64bit)
2066 2254 oappend ("addr32 ");
2067 2255 else
2068 2256 oappend ("addr16 ");
... ... @@ -2085,7 +2273,15 @@ print_insn (pc, info)
2085 2273 }
2086 2274 }
2087 2275  
2088   - if (need_modrm)
  2276 + if (dp->name == NULL && dp->bytemode1 == IS_3BYTE_OPCODE)
  2277 + {
  2278 + FETCH_DATA (info, codep + 2);
  2279 + dp = &three_byte_table[dp->bytemode2][*codep++];
  2280 + mod = (*codep >> 6) & 3;
  2281 + reg = (*codep >> 3) & 7;
  2282 + rm = *codep & 7;
  2283 + }
  2284 + else if (need_modrm)
2089 2285 {
2090 2286 FETCH_DATA (info, codep + 1);
2091 2287 mod = (*codep >> 6) & 3;
... ... @@ -2129,7 +2325,8 @@ print_insn (pc, info)
2129 2325 break;
2130 2326  
2131 2327 case X86_64_SPECIAL:
2132   - dp = &x86_64_table[dp->bytemode2][mode_64bit];
  2328 + index = address_mode == mode_64bit ? 1 : 0;
  2329 + dp = &x86_64_table[dp->bytemode2][index];
2133 2330 break;
2134 2331  
2135 2332 default:
... ... @@ -2251,14 +2448,14 @@ static const char *float_mem[] = {
2251 2448 "fsubr{s||s|}",
2252 2449 "fdiv{s||s|}",
2253 2450 "fdivr{s||s|}",
2254   - /* d9 */
  2451 + /* d9 */
2255 2452 "fld{s||s|}",
2256 2453 "(bad)",
2257 2454 "fst{s||s|}",
2258 2455 "fstp{s||s|}",
2259   - "fldenv",
  2456 + "fldenvIC",
2260 2457 "fldcw",
2261   - "fNstenv",
  2458 + "fNstenvIC",
2262 2459 "fNstcw",
2263 2460 /* da */
2264 2461 "fiadd{l||l|}",
... ... @@ -2271,7 +2468,7 @@ static const char *float_mem[] = {
2271 2468 "fidivr{l||l|}",
2272 2469 /* db */
2273 2470 "fild{l||l|}",
2274   - "(bad)",
  2471 + "fisttp{l||l|}",
2275 2472 "fist{l||l|}",
2276 2473 "fistp{l||l|}",
2277 2474 "(bad)",
... ... @@ -2289,12 +2486,12 @@ static const char *float_mem[] = {
2289 2486 "fdivr{l||l|}",
2290 2487 /* dd */
2291 2488 "fld{l||l|}",
2292   - "(bad)",
  2489 + "fisttp{ll||ll|}",
2293 2490 "fst{l||l|}",
2294 2491 "fstp{l||l|}",
2295   - "frstor",
  2492 + "frstorIC",
2296 2493 "(bad)",
2297   - "fNsave",
  2494 + "fNsaveIC",
2298 2495 "fNstsw",
2299 2496 /* de */
2300 2497 "fiadd",
... ... @@ -2307,13 +2504,88 @@ static const char *float_mem[] = {
2307 2504 "fidivr",
2308 2505 /* df */
2309 2506 "fild",
2310   - "(bad)",
  2507 + "fisttp",
2311 2508 "fist",
2312 2509 "fistp",
2313 2510 "fbld",
2314 2511 "fild{ll||ll|}",
2315 2512 "fbstp",
2316   - "fistpll",
  2513 + "fistp{ll||ll|}",
  2514 +};
  2515 +
  2516 +static const unsigned char float_mem_mode[] = {
  2517 + /* d8 */
  2518 + d_mode,
  2519 + d_mode,
  2520 + d_mode,
  2521 + d_mode,
  2522 + d_mode,
  2523 + d_mode,
  2524 + d_mode,
  2525 + d_mode,
  2526 + /* d9 */
  2527 + d_mode,
  2528 + 0,
  2529 + d_mode,
  2530 + d_mode,
  2531 + 0,
  2532 + w_mode,
  2533 + 0,
  2534 + w_mode,
  2535 + /* da */
  2536 + d_mode,
  2537 + d_mode,
  2538 + d_mode,
  2539 + d_mode,
  2540 + d_mode,
  2541 + d_mode,
  2542 + d_mode,
  2543 + d_mode,
  2544 + /* db */
  2545 + d_mode,
  2546 + d_mode,
  2547 + d_mode,
  2548 + d_mode,
  2549 + 0,
  2550 + t_mode,
  2551 + 0,
  2552 + t_mode,
  2553 + /* dc */
  2554 + q_mode,
  2555 + q_mode,
  2556 + q_mode,
  2557 + q_mode,
  2558 + q_mode,
  2559 + q_mode,
  2560 + q_mode,
  2561 + q_mode,
  2562 + /* dd */
  2563 + q_mode,
  2564 + q_mode,
  2565 + q_mode,
  2566 + q_mode,
  2567 + 0,
  2568 + 0,
  2569 + 0,
  2570 + w_mode,
  2571 + /* de */
  2572 + w_mode,
  2573 + w_mode,
  2574 + w_mode,
  2575 + w_mode,
  2576 + w_mode,
  2577 + w_mode,
  2578 + w_mode,
  2579 + w_mode,
  2580 + /* df */
  2581 + w_mode,
  2582 + w_mode,
  2583 + w_mode,
  2584 + w_mode,
  2585 + t_mode,
  2586 + q_mode,
  2587 + t_mode,
  2588 + q_mode
2317 2589 };
2318 2590  
2319 2591 #define ST OP_ST, 0
... ... @@ -2483,8 +2755,7 @@ static const char *fgrps[][8] = {
2483 2755 };
2484 2756  
2485 2757 static void
2486   -dofloat (sizeflag)
2487   - int sizeflag;
  2758 +dofloat (int sizeflag)
2488 2759 {
2489 2760 const struct dis386 *dp;
2490 2761 unsigned char floatop;
... ... @@ -2493,14 +2764,12 @@ dofloat (sizeflag)
2493 2764  
2494 2765 if (mod != 3)
2495 2766 {
2496   - putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag);
  2767 + int fp_indx = (floatop - 0xd8) * 8 + reg;
  2768 +
  2769 + putop (float_mem[fp_indx], sizeflag);
2497 2770 obufp = op1out;
2498   - if (floatop == 0xdb)
2499   - OP_E (x_mode, sizeflag);
2500   - else if (floatop == 0xdd)
2501   - OP_E (d_mode, sizeflag);
2502   - else
2503   - OP_E (v_mode, sizeflag);
  2771 + op_ad = 2;
  2772 + OP_E (float_mem_mode[fp_indx], sizeflag);
2504 2773 return;
2505 2774 }
2506 2775 /* Skip mod/rm byte. */
... ... @@ -2521,26 +2790,25 @@ dofloat (sizeflag)
2521 2790 putop (dp->name, sizeflag);
2522 2791  
2523 2792 obufp = op1out;
  2793 + op_ad = 2;
2524 2794 if (dp->op1)
2525 2795 (*dp->op1) (dp->bytemode1, sizeflag);
  2796 +
2526 2797 obufp = op2out;
  2798 + op_ad = 1;
2527 2799 if (dp->op2)
2528 2800 (*dp->op2) (dp->bytemode2, sizeflag);
2529 2801 }
2530 2802 }
2531 2803  
2532 2804 static void
2533   -OP_ST (bytemode, sizeflag)
2534   - int bytemode;
2535   - int sizeflag;
  2805 +OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2536 2806 {
2537   - oappend ("%st");
  2807 + oappend ("%st" + intel_syntax);
2538 2808 }
2539 2809  
2540 2810 static void
2541   -OP_STi (bytemode, sizeflag)
2542   - int bytemode;
2543   - int sizeflag;
  2811 +OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2544 2812 {
2545 2813 snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", rm);
2546 2814 oappend (scratchbuf + intel_syntax);
... ... @@ -2548,12 +2816,10 @@ OP_STi (bytemode, sizeflag)
2548 2816  
2549 2817 /* Capital letters in template are macros. */
2550 2818 static int
2551   -putop (template, sizeflag)
2552   - const char *template;
2553   - int sizeflag;
  2819 +putop (const char *template, int sizeflag)
2554 2820 {
2555 2821 const char *p;
2556   - int alt;
  2822 + int alt = 0;
2557 2823  
2558 2824 for (p = template; *p; p++)
2559 2825 {
... ... @@ -2566,7 +2832,7 @@ putop (template, sizeflag)
2566 2832 alt = 0;
2567 2833 if (intel_syntax)
2568 2834 alt += 1;
2569   - if (mode_64bit)
  2835 + if (address_mode == mode_64bit)
2570 2836 alt += 2;
2571 2837 while (alt != 0)
2572 2838 {
... ... @@ -2584,7 +2850,10 @@ putop (template, sizeflag)
2584 2850 }
2585 2851 alt--;
2586 2852 }
2587   - break;
  2853 + /* Fall through. */
  2854 + case 'I':
  2855 + alt = 1;
  2856 + continue;
2588 2857 case '|':
2589 2858 while (*++p != '}')
2590 2859 {
... ... @@ -2595,19 +2864,31 @@ putop (template, sizeflag)
2595 2864 case '}':
2596 2865 break;
2597 2866 case 'A':
2598   - if (intel_syntax)
2599   - break;
  2867 + if (intel_syntax)
  2868 + break;
2600 2869 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2601 2870 *obufp++ = 'b';
2602 2871 break;
2603 2872 case 'B':
2604   - if (intel_syntax)
2605   - break;
  2873 + if (intel_syntax)
  2874 + break;
2606 2875 if (sizeflag & SUFFIX_ALWAYS)
2607 2876 *obufp++ = 'b';
2608 2877 break;
  2878 + case 'C':
  2879 + if (intel_syntax && !alt)
  2880 + break;
  2881 + if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
  2882 + {
  2883 + if (sizeflag & DFLAG)
  2884 + *obufp++ = intel_syntax ? 'd' : 'l';
  2885 + else
  2886 + *obufp++ = intel_syntax ? 'w' : 's';
  2887 + used_prefixes |= (prefixes & PREFIX_DATA);
  2888 + }
  2889 + break;
2609 2890 case 'E': /* For jcxz/jecxz */
2610   - if (mode_64bit)
  2891 + if (address_mode == mode_64bit)
2611 2892 {
2612 2893 if (sizeflag & AFLAG)
2613 2894 *obufp++ = 'r';
... ... @@ -2620,20 +2901,20 @@ putop (template, sizeflag)
2620 2901 used_prefixes |= (prefixes & PREFIX_ADDR);
2621 2902 break;
2622 2903 case 'F':
2623   - if (intel_syntax)
2624   - break;
  2904 + if (intel_syntax)
  2905 + break;
2625 2906 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
2626 2907 {
2627 2908 if (sizeflag & AFLAG)
2628   - *obufp++ = mode_64bit ? 'q' : 'l';
  2909 + *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
2629 2910 else
2630   - *obufp++ = mode_64bit ? 'l' : 'w';
  2911 + *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
2631 2912 used_prefixes |= (prefixes & PREFIX_ADDR);
2632 2913 }
2633 2914 break;
2634 2915 case 'H':
2635   - if (intel_syntax)
2636   - break;
  2916 + if (intel_syntax)
  2917 + break;
2637 2918 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
2638 2919 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
2639 2920 {
... ... @@ -2646,9 +2927,23 @@ putop (template, sizeflag)
2646 2927 *obufp++ = 'n';
2647 2928 }
2648 2929 break;
  2930 + case 'J':
  2931 + if (intel_syntax)
  2932 + break;
  2933 + *obufp++ = 'l';
  2934 + break;
  2935 + case 'Z':
  2936 + if (intel_syntax)
  2937 + break;
  2938 + if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
  2939 + {
  2940 + *obufp++ = 'q';
  2941 + break;
  2942 + }
  2943 + /* Fall through. */
2649 2944 case 'L':
2650   - if (intel_syntax)
2651   - break;
  2945 + if (intel_syntax)
  2946 + break;
2652 2947 if (sizeflag & SUFFIX_ALWAYS)
2653 2948 *obufp++ = 'l';
2654 2949 break;
... ... @@ -2666,17 +2961,17 @@ putop (template, sizeflag)
2666 2961 *obufp++ = 'd';
2667 2962 break;
2668 2963 case 'T':
2669   - if (intel_syntax)
2670   - break;
2671   - if (mode_64bit)
  2964 + if (intel_syntax)
  2965 + break;
  2966 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
2672 2967 {
2673 2968 *obufp++ = 'q';
2674 2969 break;
2675 2970 }
2676 2971 /* Fall through. */
2677 2972 case 'P':
2678   - if (intel_syntax)
2679   - break;
  2973 + if (intel_syntax)
  2974 + break;
2680 2975 if ((prefixes & PREFIX_DATA)
2681 2976 || (rex & REX_MODE64)
2682 2977 || (sizeflag & SUFFIX_ALWAYS))
... ... @@ -2690,22 +2985,23 @@ putop (template, sizeflag)
2690 2985 *obufp++ = 'l';
2691 2986 else
2692 2987 *obufp++ = 'w';
2693   - used_prefixes |= (prefixes & PREFIX_DATA);
2694 2988 }
  2989 + used_prefixes |= (prefixes & PREFIX_DATA);
2695 2990 }
2696 2991 break;
2697 2992 case 'U':
2698   - if (intel_syntax)
2699   - break;
2700   - if (mode_64bit)
  2993 + if (intel_syntax)
  2994 + break;
  2995 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
2701 2996 {
2702   - *obufp++ = 'q';
  2997 + if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
  2998 + *obufp++ = 'q';
2703 2999 break;
2704 3000 }
2705 3001 /* Fall through. */
2706 3002 case 'Q':
2707   - if (intel_syntax)
2708   - break;
  3003 + if (intel_syntax && !alt)
  3004 + break;
2709 3005 USED_REX (REX_MODE64);
2710 3006 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2711 3007 {
... ... @@ -2714,16 +3010,16 @@ putop (template, sizeflag)
2714 3010 else
2715 3011 {
2716 3012 if (sizeflag & DFLAG)
2717   - *obufp++ = 'l';
  3013 + *obufp++ = intel_syntax ? 'd' : 'l';
2718 3014 else
2719 3015 *obufp++ = 'w';
2720   - used_prefixes |= (prefixes & PREFIX_DATA);
2721 3016 }
  3017 + used_prefixes |= (prefixes & PREFIX_DATA);
2722 3018 }
2723 3019 break;
2724 3020 case 'R':
2725 3021 USED_REX (REX_MODE64);
2726   - if (intel_syntax)
  3022 + if (intel_syntax)
2727 3023 {
2728 3024 if (rex & REX_MODE64)
2729 3025 {
... ... @@ -2753,9 +3049,19 @@ putop (template, sizeflag)
2753 3049 if (!(rex & REX_MODE64))
2754 3050 used_prefixes |= (prefixes & PREFIX_DATA);
2755 3051 break;
  3052 + case 'V':
  3053 + if (intel_syntax)
  3054 + break;
  3055 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
  3056 + {
  3057 + if (sizeflag & SUFFIX_ALWAYS)
  3058 + *obufp++ = 'q';
  3059 + break;
  3060 + }
  3061 + /* Fall through. */
2756 3062 case 'S':
2757   - if (intel_syntax)
2758   - break;
  3063 + if (intel_syntax)
  3064 + break;
2759 3065 if (sizeflag & SUFFIX_ALWAYS)
2760 3066 {
2761 3067 if (rex & REX_MODE64)
... ... @@ -2775,11 +3081,11 @@ putop (template, sizeflag)
2775 3081 *obufp++ = 'd';
2776 3082 else
2777 3083 *obufp++ = 's';
2778   - used_prefixes |= (prefixes & PREFIX_DATA);
  3084 + used_prefixes |= (prefixes & PREFIX_DATA);
2779 3085 break;
2780 3086 case 'Y':
2781   - if (intel_syntax)
2782   - break;
  3087 + if (intel_syntax)
  3088 + break;
2783 3089 if (rex & REX_MODE64)
2784 3090 {
2785 3091 USED_REX (REX_MODE64);
... ... @@ -2796,7 +3102,7 @@ putop (template, sizeflag)
2796 3102 *obufp++ = 'w';
2797 3103 else
2798 3104 *obufp++ = 'b';
2799   - if (intel_syntax)
  3105 + if (intel_syntax)
2800 3106 {
2801 3107 if (rex)
2802 3108 {
... ... @@ -2817,21 +3123,21 @@ putop (template, sizeflag)
2817 3123 used_prefixes |= (prefixes & PREFIX_DATA);
2818 3124 break;
2819 3125 }
  3126 + alt = 0;
2820 3127 }
2821 3128 *obufp = 0;
2822 3129 return 0;
2823 3130 }
2824 3131  
2825 3132 static void
2826   -oappend (s)
2827   - const char *s;
  3133 +oappend (const char *s)
2828 3134 {
2829 3135 strcpy (obufp, s);
2830 3136 obufp += strlen (s);
2831 3137 }
2832 3138  
2833 3139 static void
2834   -append_seg ()
  3140 +append_seg (void)
2835 3141 {
2836 3142 if (prefixes & PREFIX_CS)
2837 3143 {
... ... @@ -2866,9 +3172,7 @@ append_seg ()
2866 3172 }
2867 3173  
2868 3174 static void
2869   -OP_indirE (bytemode, sizeflag)
2870   - int bytemode;
2871   - int sizeflag;
  3175 +OP_indirE (int bytemode, int sizeflag)
2872 3176 {
2873 3177 if (!intel_syntax)
2874 3178 oappend ("*");
... ... @@ -2878,7 +3182,7 @@ OP_indirE (bytemode, sizeflag)
2878 3182 static void
2879 3183 print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp)
2880 3184 {
2881   - if (mode_64bit)
  3185 + if (address_mode == mode_64bit)
2882 3186 {
2883 3187 if (hex)
2884 3188 {
... ... @@ -2933,9 +3237,68 @@ print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp)
2933 3237 }
2934 3238  
2935 3239 static void
2936   -OP_E (bytemode, sizeflag)
2937   - int bytemode;
2938   - int sizeflag;
  3240 +intel_operand_size (int bytemode, int sizeflag)
  3241 +{
  3242 + switch (bytemode)
  3243 + {
  3244 + case b_mode:
  3245 + oappend ("BYTE PTR ");
  3246 + break;
  3247 + case w_mode:
  3248 + case dqw_mode:
  3249 + oappend ("WORD PTR ");
  3250 + break;
  3251 + case stack_v_mode:
  3252 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
  3253 + {
  3254 + oappend ("QWORD PTR ");
  3255 + used_prefixes |= (prefixes & PREFIX_DATA);
  3256 + break;
  3257 + }
  3258 + /* FALLTHRU */
  3259 + case v_mode:
  3260 + case dq_mode:
  3261 + USED_REX (REX_MODE64);
  3262 + if (rex & REX_MODE64)
  3263 + oappend ("QWORD PTR ");
  3264 + else if ((sizeflag & DFLAG) || bytemode == dq_mode)
  3265 + oappend ("DWORD PTR ");
  3266 + else
  3267 + oappend ("WORD PTR ");
  3268 + used_prefixes |= (prefixes & PREFIX_DATA);
  3269 + break;
  3270 + case d_mode:
  3271 + oappend ("DWORD PTR ");
  3272 + break;
  3273 + case q_mode:
  3274 + oappend ("QWORD PTR ");
  3275 + break;
  3276 + case m_mode:
  3277 + if (address_mode == mode_64bit)
  3278 + oappend ("QWORD PTR ");
  3279 + else
  3280 + oappend ("DWORD PTR ");
  3281 + break;
  3282 + case f_mode:
  3283 + if (sizeflag & DFLAG)
  3284 + oappend ("FWORD PTR ");
  3285 + else
  3286 + oappend ("DWORD PTR ");
  3287 + used_prefixes |= (prefixes & PREFIX_DATA);
  3288 + break;
  3289 + case t_mode:
  3290 + oappend ("TBYTE PTR ");
  3291 + break;
  3292 + case x_mode:
  3293 + oappend ("XMMWORD PTR ");
  3294 + break;
  3295 + default:
  3296 + break;
  3297 + }
  3298 +}
  3299 +
  3300 +static void
  3301 +OP_E (int bytemode, int sizeflag)
2939 3302 {
2940 3303 bfd_vma disp;
2941 3304 int add = 0;
... ... @@ -2969,26 +3332,33 @@ OP_E (bytemode, sizeflag)
2969 3332 oappend (names64[rm + add]);
2970 3333 break;
2971 3334 case m_mode:
2972   - if (mode_64bit)
  3335 + if (address_mode == mode_64bit)
2973 3336 oappend (names64[rm + add]);
2974 3337 else
2975 3338 oappend (names32[rm + add]);
2976 3339 break;
  3340 + case stack_v_mode:
  3341 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
  3342 + {
  3343 + oappend (names64[rm + add]);
  3344 + used_prefixes |= (prefixes & PREFIX_DATA);
  3345 + break;
  3346 + }
  3347 + bytemode = v_mode;
  3348 + /* FALLTHRU */
2977 3349 case v_mode:
  3350 + case dq_mode:
  3351 + case dqw_mode:
2978 3352 USED_REX (REX_MODE64);
2979 3353 if (rex & REX_MODE64)
2980 3354 oappend (names64[rm + add]);
2981   - else if (sizeflag & DFLAG)
  3355 + else if ((sizeflag & DFLAG) || bytemode != v_mode)
2982 3356 oappend (names32[rm + add]);
2983 3357 else
2984 3358 oappend (names16[rm + add]);
2985 3359 used_prefixes |= (prefixes & PREFIX_DATA);
2986 3360 break;
2987 3361 case 0:
2988   - if (!(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */)
2989   - && !(codep[-2] == 0xAE && codep[-1] == 0xF0 /* mfence */)
2990   - && !(codep[-2] == 0xAE && codep[-1] == 0xe8 /* lfence */))
2991   - BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
2992 3362 break;
2993 3363 default:
2994 3364 oappend (INTERNAL_DISASSEMBLER_ERROR);
... ... @@ -2998,9 +3368,11 @@ OP_E (bytemode, sizeflag)
2998 3368 }
2999 3369  
3000 3370 disp = 0;
  3371 + if (intel_syntax)
  3372 + intel_operand_size (bytemode, sizeflag);
3001 3373 append_seg ();
3002 3374  
3003   - if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
  3375 + if ((sizeflag & AFLAG) || address_mode == mode_64bit) /* 32 bit address mode */
3004 3376 {
3005 3377 int havesib;
3006 3378 int havebase;
... ... @@ -3016,17 +3388,17 @@ OP_E (bytemode, sizeflag)
3016 3388 {
3017 3389 havesib = 1;
3018 3390 FETCH_DATA (the_info, codep + 1);
3019   - scale = (*codep >> 6) & 3;
3020 3391 index = (*codep >> 3) & 7;
  3392 + if (address_mode == mode_64bit || index != 0x4)
  3393 + /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
  3394 + scale = (*codep >> 6) & 3;
3021 3395 base = *codep & 7;
3022 3396 USED_REX (REX_EXTY);
3023   - USED_REX (REX_EXTZ);
3024 3397 if (rex & REX_EXTY)
3025 3398 index += 8;
3026   - if (rex & REX_EXTZ)
3027   - base += 8;
3028 3399 codep++;
3029 3400 }
  3401 + base += add;
3030 3402  
3031 3403 switch (mod)
3032 3404 {
... ... @@ -3034,7 +3406,7 @@ OP_E (bytemode, sizeflag)
3034 3406 if ((base & 7) == 5)
3035 3407 {
3036 3408 havebase = 0;
3037   - if (mode_64bit && !havesib && (sizeflag & AFLAG))
  3409 + if (address_mode == mode_64bit && !havesib)
3038 3410 riprel = 1;
3039 3411 disp = get32s ();
3040 3412 }
... ... @@ -3051,116 +3423,72 @@ OP_E (bytemode, sizeflag)
3051 3423 }
3052 3424  
3053 3425 if (!intel_syntax)
3054   - if (mod != 0 || (base & 7) == 5)
3055   - {
3056   - print_operand_value (scratchbuf, sizeof(scratchbuf), !riprel, disp);
3057   - oappend (scratchbuf);
  3426 + if (mod != 0 || (base & 7) == 5)
  3427 + {
  3428 + print_operand_value (scratchbuf, sizeof(scratchbuf), !riprel, disp);
  3429 + oappend (scratchbuf);
3058 3430 if (riprel)
3059 3431 {
3060 3432 set_op (disp, 1);
3061 3433 oappend ("(%rip)");
3062 3434 }
3063   - }
  3435 + }
3064 3436  
3065 3437 if (havebase || (havesib && (index != 4 || scale != 0)))
3066 3438 {
3067   - if (intel_syntax)
3068   - {
3069   - switch (bytemode)
3070   - {
3071   - case b_mode:
3072   - oappend ("BYTE PTR ");
3073   - break;
3074   - case w_mode:
3075   - oappend ("WORD PTR ");
3076   - break;
3077   - case v_mode:
3078   - oappend ("DWORD PTR ");
3079   - break;
3080   - case d_mode:
3081   - oappend ("QWORD PTR ");
3082   - break;
3083   - case m_mode:
3084   - if (mode_64bit)
3085   - oappend ("DWORD PTR ");
3086   - else
3087   - oappend ("QWORD PTR ");
3088   - break;
3089   - case x_mode:
3090   - oappend ("XWORD PTR ");
3091   - break;
3092   - default:
3093   - break;
3094   - }
3095   - }
3096 3439 *obufp++ = open_char;
3097 3440 if (intel_syntax && riprel)
3098 3441 oappend ("rip + ");
3099   - *obufp = '\0';
3100   - USED_REX (REX_EXTZ);
3101   - if (!havesib && (rex & REX_EXTZ))
3102   - base += 8;
  3442 + *obufp = '\0';
3103 3443 if (havebase)
3104   - oappend (mode_64bit && (sizeflag & AFLAG)
  3444 + oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3105 3445 ? names64[base] : names32[base]);
3106 3446 if (havesib)
3107 3447 {
3108 3448 if (index != 4)
3109 3449 {
3110   - if (intel_syntax)
3111   - {
3112   - if (havebase)
3113   - {
3114   - *obufp++ = separator_char;
3115   - *obufp = '\0';
3116   - }
3117   - snprintf (scratchbuf, sizeof(scratchbuf), "%s",
3118   - mode_64bit && (sizeflag & AFLAG)
3119   - ? names64[index] : names32[index]);
3120   - }
3121   - else
3122   - snprintf (scratchbuf, sizeof(scratchbuf), ",%s",
3123   - mode_64bit && (sizeflag & AFLAG)
3124   - ? names64[index] : names32[index]);
  3450 + if (!intel_syntax || havebase)
  3451 + {
  3452 + *obufp++ = separator_char;
  3453 + *obufp = '\0';
  3454 + }
  3455 + oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
  3456 + ? names64[index] : names32[index]);
  3457 + }
  3458 + if (scale != 0 || (!intel_syntax && index != 4))
  3459 + {
  3460 + *obufp++ = scale_char;
  3461 + *obufp = '\0';
  3462 + snprintf (scratchbuf, sizeof(scratchbuf), "%d", 1 << scale);
3125 3463 oappend (scratchbuf);
3126 3464 }
3127   - if (!intel_syntax
3128   - || (intel_syntax
3129   - && bytemode != b_mode
3130   - && bytemode != w_mode
3131   - && bytemode != v_mode))
3132   - {
3133   - *obufp++ = scale_char;
3134   - *obufp = '\0';
3135   - snprintf (scratchbuf, sizeof(scratchbuf), "%d", 1 << scale);
3136   - oappend (scratchbuf);
3137   - }
3138 3465 }
3139   - if (intel_syntax)
3140   - if (mod != 0 || (base & 7) == 5)
3141   - {
3142   - /* Don't print zero displacements. */
3143   - if (disp != 0)
3144   - {
3145   - if ((bfd_signed_vma) disp > 0)
3146   - {
3147   - *obufp++ = '+';
3148   - *obufp = '\0';
3149   - }
3150   -
3151   - print_operand_value (scratchbuf, sizeof(scratchbuf), 0,
3152   - disp);
3153   - oappend (scratchbuf);
3154   - }
3155   - }
  3466 + if (intel_syntax && disp)
  3467 + {
  3468 + if ((bfd_signed_vma) disp > 0)
  3469 + {
  3470 + *obufp++ = '+';
  3471 + *obufp = '\0';
  3472 + }
  3473 + else if (mod != 1)
  3474 + {
  3475 + *obufp++ = '-';
  3476 + *obufp = '\0';
  3477 + disp = - (bfd_signed_vma) disp;
  3478 + }
  3479 +
  3480 + print_operand_value (scratchbuf, sizeof(scratchbuf), mod != 1,
  3481 + disp);
  3482 + oappend (scratchbuf);
  3483 + }
3156 3484  
3157 3485 *obufp++ = close_char;
3158   - *obufp = '\0';
  3486 + *obufp = '\0';
3159 3487 }
3160 3488 else if (intel_syntax)
3161   - {
3162   - if (mod != 0 || (base & 7) == 5)
3163   - {
  3489 + {
  3490 + if (mod != 0 || (base & 7) == 5)
  3491 + {
3164 3492 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3165 3493 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3166 3494 ;
... ... @@ -3169,17 +3497,17 @@ OP_E (bytemode, sizeflag)
3169 3497 oappend (names_seg[ds_reg - es_reg]);
3170 3498 oappend (":");
3171 3499 }
3172   - print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
3173   - oappend (scratchbuf);
3174   - }
3175   - }
  3500 + print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
  3501 + oappend (scratchbuf);
  3502 + }
  3503 + }
3176 3504 }
3177 3505 else
3178 3506 { /* 16 bit address mode */
3179 3507 switch (mod)
3180 3508 {
3181 3509 case 0:
3182   - if ((rm & 7) == 6)
  3510 + if (rm == 6)
3183 3511 {
3184 3512 disp = get16 ();
3185 3513 if ((disp & 0x8000) != 0)
... ... @@ -3200,27 +3528,58 @@ OP_E (bytemode, sizeflag)
3200 3528 }
3201 3529  
3202 3530 if (!intel_syntax)
3203   - if (mod != 0 || (rm & 7) == 6)
3204   - {
3205   - print_operand_value (scratchbuf, sizeof(scratchbuf), 0, disp);
3206   - oappend (scratchbuf);
3207   - }
  3531 + if (mod != 0 || rm == 6)
  3532 + {
  3533 + print_operand_value (scratchbuf, sizeof(scratchbuf), 0, disp);
  3534 + oappend (scratchbuf);
  3535 + }
3208 3536  
3209   - if (mod != 0 || (rm & 7) != 6)
  3537 + if (mod != 0 || rm != 6)
3210 3538 {
3211 3539 *obufp++ = open_char;
3212   - *obufp = '\0';
3213   - oappend (index16[rm + add]);
3214   - *obufp++ = close_char;
3215   - *obufp = '\0';
  3540 + *obufp = '\0';
  3541 + oappend (index16[rm]);
  3542 + if (intel_syntax && disp)
  3543 + {
  3544 + if ((bfd_signed_vma) disp > 0)
  3545 + {
  3546 + *obufp++ = '+';
  3547 + *obufp = '\0';
  3548 + }
  3549 + else if (mod != 1)
  3550 + {
  3551 + *obufp++ = '-';
  3552 + *obufp = '\0';
  3553 + disp = - (bfd_signed_vma) disp;
  3554 + }
  3555 +
  3556 + print_operand_value (scratchbuf, sizeof(scratchbuf), mod != 1,
  3557 + disp);
  3558 + oappend (scratchbuf);
  3559 + }
  3560 +
  3561 + *obufp++ = close_char;
  3562 + *obufp = '\0';
  3563 + }
  3564 + else if (intel_syntax)
  3565 + {
  3566 + if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
  3567 + | PREFIX_ES | PREFIX_FS | PREFIX_GS))
  3568 + ;
  3569 + else
  3570 + {
  3571 + oappend (names_seg[ds_reg - es_reg]);
  3572 + oappend (":");
  3573 + }
  3574 + print_operand_value (scratchbuf, sizeof(scratchbuf), 1,
  3575 + disp & 0xffff);
  3576 + oappend (scratchbuf);
3216 3577 }
3217 3578 }
3218 3579 }
3219 3580  
3220 3581 static void
3221   -OP_G (bytemode, sizeflag)
3222   - int bytemode;
3223   - int sizeflag;
  3582 +OP_G (int bytemode, int sizeflag)
3224 3583 {
3225 3584 int add = 0;
3226 3585 USED_REX (REX_EXTX);
... ... @@ -3245,15 +3604,23 @@ OP_G (bytemode, sizeflag)
3245 3604 oappend (names64[reg + add]);
3246 3605 break;
3247 3606 case v_mode:
  3607 + case dq_mode:
  3608 + case dqw_mode:
3248 3609 USED_REX (REX_MODE64);
3249 3610 if (rex & REX_MODE64)
3250 3611 oappend (names64[reg + add]);
3251   - else if (sizeflag & DFLAG)
  3612 + else if ((sizeflag & DFLAG) || bytemode != v_mode)
3252 3613 oappend (names32[reg + add]);
3253 3614 else
3254 3615 oappend (names16[reg + add]);
3255 3616 used_prefixes |= (prefixes & PREFIX_DATA);
3256 3617 break;
  3618 + case m_mode:
  3619 + if (address_mode == mode_64bit)
  3620 + oappend (names64[reg + add]);
  3621 + else
  3622 + oappend (names32[reg + add]);
  3623 + break;
3257 3624 default:
3258 3625 oappend (INTERNAL_DISASSEMBLER_ERROR);
3259 3626 break;
... ... @@ -3261,7 +3628,7 @@ OP_G (bytemode, sizeflag)
3261 3628 }
3262 3629  
3263 3630 static bfd_vma
3264   -get64 ()
  3631 +get64 (void)
3265 3632 {
3266 3633 bfd_vma x;
3267 3634 #ifdef BFD64
... ... @@ -3286,7 +3653,7 @@ get64 ()
3286 3653 }
3287 3654  
3288 3655 static bfd_signed_vma
3289   -get32 ()
  3656 +get32 (void)
3290 3657 {
3291 3658 bfd_signed_vma x = 0;
3292 3659  
... ... @@ -3299,7 +3666,7 @@ get32 ()
3299 3666 }
3300 3667  
3301 3668 static bfd_signed_vma
3302   -get32s ()
  3669 +get32s (void)
3303 3670 {
3304 3671 bfd_signed_vma x = 0;
3305 3672  
... ... @@ -3315,7 +3682,7 @@ get32s ()
3315 3682 }
3316 3683  
3317 3684 static int
3318   -get16 ()
  3685 +get16 (void)
3319 3686 {
3320 3687 int x = 0;
3321 3688  
... ... @@ -3326,12 +3693,10 @@ get16 ()
3326 3693 }
3327 3694  
3328 3695 static void
3329   -set_op (op, riprel)
3330   - bfd_vma op;
3331   - int riprel;
  3696 +set_op (bfd_vma op, int riprel)
3332 3697 {
3333 3698 op_index[op_ad] = op_ad;
3334   - if (mode_64bit)
  3699 + if (address_mode == mode_64bit)
3335 3700 {
3336 3701 op_address[op_ad] = op;
3337 3702 op_riprel[op_ad] = riprel;
... ... @@ -3345,9 +3710,7 @@ set_op (op, riprel)
3345 3710 }
3346 3711  
3347 3712 static void
3348   -OP_REG (code, sizeflag)
3349   - int code;
3350   - int sizeflag;
  3713 +OP_REG (int code, int sizeflag)
3351 3714 {
3352 3715 const char *s;
3353 3716 int add = 0;
... ... @@ -3359,9 +3722,9 @@ OP_REG (code, sizeflag)
3359 3722 {
3360 3723 case indir_dx_reg:
3361 3724 if (intel_syntax)
3362   - s = "[dx]";
  3725 + s = "[dx]";
3363 3726 else
3364   - s = "(%dx)";
  3727 + s = "(%dx)";
3365 3728 break;
3366 3729 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3367 3730 case sp_reg: case bp_reg: case si_reg: case di_reg:
... ... @@ -3381,7 +3744,7 @@ OP_REG (code, sizeflag)
3381 3744 break;
3382 3745 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
3383 3746 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
3384   - if (mode_64bit)
  3747 + if (address_mode == mode_64bit && (sizeflag & DFLAG))
3385 3748 {
3386 3749 s = names64[code - rAX_reg + add];
3387 3750 break;
... ... @@ -3407,9 +3770,7 @@ OP_REG (code, sizeflag)
3407 3770 }
3408 3771  
3409 3772 static void
3410   -OP_IMREG (code, sizeflag)
3411   - int code;
3412   - int sizeflag;
  3773 +OP_IMREG (int code, int sizeflag)
3413 3774 {
3414 3775 const char *s;
3415 3776  
... ... @@ -3417,9 +3778,9 @@ OP_IMREG (code, sizeflag)
3417 3778 {
3418 3779 case indir_dx_reg:
3419 3780 if (intel_syntax)
3420   - s = "[dx]";
  3781 + s = "[dx]";
3421 3782 else
3422   - s = "(%dx)";
  3783 + s = "(%dx)";
3423 3784 break;
3424 3785 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3425 3786 case sp_reg: case bp_reg: case si_reg: case di_reg:
... ... @@ -3456,9 +3817,7 @@ OP_IMREG (code, sizeflag)
3456 3817 }
3457 3818  
3458 3819 static void
3459   -OP_I (bytemode, sizeflag)
3460   - int bytemode;
3461   - int sizeflag;
  3820 +OP_I (int bytemode, int sizeflag)
3462 3821 {
3463 3822 bfd_signed_vma op;
3464 3823 bfd_signed_vma mask = -1;
... ... @@ -3471,7 +3830,7 @@ OP_I (bytemode, sizeflag)
3471 3830 mask = 0xff;
3472 3831 break;
3473 3832 case q_mode:
3474   - if (mode_64bit)
  3833 + if (address_mode == mode_64bit)
3475 3834 {
3476 3835 op = get32s ();
3477 3836 break;
... ... @@ -3497,6 +3856,10 @@ OP_I (bytemode, sizeflag)
3497 3856 mask = 0xfffff;
3498 3857 op = get16 ();
3499 3858 break;
  3859 + case const_1_mode:
  3860 + if (intel_syntax)
  3861 + oappend ("1");
  3862 + return;
3500 3863 default:
3501 3864 oappend (INTERNAL_DISASSEMBLER_ERROR);
3502 3865 return;
... ... @@ -3510,14 +3873,12 @@ OP_I (bytemode, sizeflag)
3510 3873 }
3511 3874  
3512 3875 static void
3513   -OP_I64 (bytemode, sizeflag)
3514   - int bytemode;
3515   - int sizeflag;
  3876 +OP_I64 (int bytemode, int sizeflag)
3516 3877 {
3517 3878 bfd_signed_vma op;
3518 3879 bfd_signed_vma mask = -1;
3519 3880  
3520   - if (!mode_64bit)
  3881 + if (address_mode != mode_64bit)
3521 3882 {
3522 3883 OP_I (bytemode, sizeflag);
3523 3884 return;
... ... @@ -3563,9 +3924,7 @@ OP_I64 (bytemode, sizeflag)
3563 3924 }
3564 3925  
3565 3926 static void
3566   -OP_sI (bytemode, sizeflag)
3567   - int bytemode;
3568   - int sizeflag;
  3927 +OP_sI (int bytemode, int sizeflag)
3569 3928 {
3570 3929 bfd_signed_vma op;
3571 3930 bfd_signed_vma mask = -1;
... ... @@ -3614,9 +3973,7 @@ OP_sI (bytemode, sizeflag)
3614 3973 }
3615 3974  
3616 3975 static void
3617   -OP_J (bytemode, sizeflag)
3618   - int bytemode;
3619   - int sizeflag;
  3976 +OP_J (int bytemode, int sizeflag)
3620 3977 {
3621 3978 bfd_vma disp;
3622 3979 bfd_vma mask = -1;
... ... @@ -3630,7 +3987,7 @@ OP_J (bytemode, sizeflag)
3630 3987 disp -= 0x100;
3631 3988 break;
3632 3989 case v_mode:
3633   - if (sizeflag & DFLAG)
  3990 + if ((sizeflag & DFLAG) || (rex & REX_MODE64))
3634 3991 disp = get32s ();
3635 3992 else
3636 3993 {
... ... @@ -3652,17 +4009,13 @@ OP_J (bytemode, sizeflag)
3652 4009 }
3653 4010  
3654 4011 static void
3655   -OP_SEG (dummy, sizeflag)
3656   - int dummy;
3657   - int sizeflag;
  4012 +OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3658 4013 {
3659 4014 oappend (names_seg[reg]);
3660 4015 }
3661 4016  
3662 4017 static void
3663   -OP_DIR (dummy, sizeflag)
3664   - int dummy;
3665   - int sizeflag;
  4018 +OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
3666 4019 {
3667 4020 int seg, offset;
3668 4021  
... ... @@ -3678,22 +4031,22 @@ OP_DIR (dummy, sizeflag)
3678 4031 }
3679 4032 used_prefixes |= (prefixes & PREFIX_DATA);
3680 4033 if (intel_syntax)
3681   - snprintf (scratchbuf, sizeof(scratchbuf), "0x%x,0x%x", seg, offset);
  4034 + snprintf (scratchbuf, sizeof(scratchbuf), "0x%x:0x%x", seg, offset);
3682 4035 else
3683 4036 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset);
3684 4037 oappend (scratchbuf);
3685 4038 }
3686 4039  
3687 4040 static void
3688   -OP_OFF (bytemode, sizeflag)
3689   - int bytemode;
3690   - int sizeflag;
  4041 +OP_OFF (int bytemode, int sizeflag)
3691 4042 {
3692 4043 bfd_vma off;
3693 4044  
  4045 + if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
  4046 + intel_operand_size (bytemode, sizeflag);
3694 4047 append_seg ();
3695 4048  
3696   - if ((sizeflag & AFLAG) || mode_64bit)
  4049 + if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3697 4050 off = get32 ();
3698 4051 else
3699 4052 off = get16 ();
... ... @@ -3701,7 +4054,7 @@ OP_OFF (bytemode, sizeflag)
3701 4054 if (intel_syntax)
3702 4055 {
3703 4056 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3704   - | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
  4057 + | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
3705 4058 {
3706 4059 oappend (names_seg[ds_reg - es_reg]);
3707 4060 oappend (":");
... ... @@ -3712,18 +4065,18 @@ OP_OFF (bytemode, sizeflag)
3712 4065 }
3713 4066  
3714 4067 static void
3715   -OP_OFF64 (bytemode, sizeflag)
3716   - int bytemode;
3717   - int sizeflag;
  4068 +OP_OFF64 (int bytemode, int sizeflag)
3718 4069 {
3719 4070 bfd_vma off;
3720 4071  
3721   - if (!mode_64bit)
  4072 + if (address_mode != mode_64bit)
3722 4073 {
3723 4074 OP_OFF (bytemode, sizeflag);
3724 4075 return;
3725 4076 }
3726 4077  
  4078 + if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
  4079 + intel_operand_size (bytemode, sizeflag);
3727 4080 append_seg ();
3728 4081  
3729 4082 off = get64 ();
... ... @@ -3731,7 +4084,7 @@ OP_OFF64 (bytemode, sizeflag)
3731 4084 if (intel_syntax)
3732 4085 {
3733 4086 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3734   - | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
  4087 + | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
3735 4088 {
3736 4089 oappend (names_seg[ds_reg - es_reg]);
3737 4090 oappend (":");
... ... @@ -3742,49 +4095,45 @@ OP_OFF64 (bytemode, sizeflag)
3742 4095 }
3743 4096  
3744 4097 static void
3745   -ptr_reg (code, sizeflag)
3746   - int code;
3747   - int sizeflag;
  4098 +ptr_reg (int code, int sizeflag)
3748 4099 {
3749 4100 const char *s;
3750   - if (intel_syntax)
3751   - oappend ("[");
3752   - else
3753   - oappend ("(");
3754 4101  
3755   - USED_REX (REX_MODE64);
3756   - if (rex & REX_MODE64)
  4102 + *obufp++ = open_char;
  4103 + used_prefixes |= (prefixes & PREFIX_ADDR);
  4104 + if (address_mode == mode_64bit)
3757 4105 {
3758 4106 if (!(sizeflag & AFLAG))
3759   - s = names32[code - eAX_reg];
  4107 + s = names32[code - eAX_reg];
3760 4108 else
3761   - s = names64[code - eAX_reg];
  4109 + s = names64[code - eAX_reg];
3762 4110 }
3763 4111 else if (sizeflag & AFLAG)
3764 4112 s = names32[code - eAX_reg];
3765 4113 else
3766 4114 s = names16[code - eAX_reg];
3767 4115 oappend (s);
3768   - if (intel_syntax)
3769   - oappend ("]");
3770   - else
3771   - oappend (")");
  4116 + *obufp++ = close_char;
  4117 + *obufp = 0;
3772 4118 }
3773 4119  
3774 4120 static void
3775   -OP_ESreg (code, sizeflag)
3776   - int code;
3777   - int sizeflag;
  4121 +OP_ESreg (int code, int sizeflag)
3778 4122 {
  4123 + if (intel_syntax)
  4124 + intel_operand_size (codep[-1] & 1 ? v_mode : b_mode, sizeflag);
3779 4125 oappend ("%es:" + intel_syntax);
3780 4126 ptr_reg (code, sizeflag);
3781 4127 }
3782 4128  
3783 4129 static void
3784   -OP_DSreg (code, sizeflag)
3785   - int code;
3786   - int sizeflag;
  4130 +OP_DSreg (int code, int sizeflag)
3787 4131 {
  4132 + if (intel_syntax)
  4133 + intel_operand_size (codep[-1] != 0xd7 && (codep[-1] & 1)
  4134 + ? v_mode
  4135 + : b_mode,
  4136 + sizeflag);
3788 4137 if ((prefixes
3789 4138 & (PREFIX_CS
3790 4139 | PREFIX_DS
... ... @@ -3798,22 +4147,25 @@ OP_DSreg (code, sizeflag)
3798 4147 }
3799 4148  
3800 4149 static void
3801   -OP_C (dummy, sizeflag)
3802   - int dummy;
3803   - int sizeflag;
  4150 +OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3804 4151 {
3805 4152 int add = 0;
3806   - USED_REX (REX_EXTX);
3807 4153 if (rex & REX_EXTX)
3808   - add = 8;
  4154 + {
  4155 + USED_REX (REX_EXTX);
  4156 + add = 8;
  4157 + }
  4158 + else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
  4159 + {
  4160 + used_prefixes |= PREFIX_LOCK;
  4161 + add = 8;
  4162 + }
3809 4163 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", reg + add);
3810 4164 oappend (scratchbuf + intel_syntax);
3811 4165 }
3812 4166  
3813 4167 static void
3814   -OP_D (dummy, sizeflag)
3815   - int dummy;
3816   - int sizeflag;
  4168 +OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3817 4169 {
3818 4170 int add = 0;
3819 4171 USED_REX (REX_EXTX);
... ... @@ -3827,18 +4179,14 @@ OP_D (dummy, sizeflag)
3827 4179 }
3828 4180  
3829 4181 static void
3830   -OP_T (dummy, sizeflag)
3831   - int dummy;
3832   - int sizeflag;
  4182 +OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3833 4183 {
3834 4184 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", reg);
3835 4185 oappend (scratchbuf + intel_syntax);
3836 4186 }
3837 4187  
3838 4188 static void
3839   -OP_Rd (bytemode, sizeflag)
3840   - int bytemode;
3841   - int sizeflag;
  4189 +OP_Rd (int bytemode, int sizeflag)
3842 4190 {
3843 4191 if (mod == 3)
3844 4192 OP_E (bytemode, sizeflag);
... ... @@ -3847,26 +4195,24 @@ OP_Rd (bytemode, sizeflag)
3847 4195 }
3848 4196  
3849 4197 static void
3850   -OP_MMX (bytemode, sizeflag)
3851   - int bytemode;
3852   - int sizeflag;
  4198 +OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3853 4199 {
3854   - int add = 0;
3855   - USED_REX (REX_EXTX);
3856   - if (rex & REX_EXTX)
3857   - add = 8;
3858 4200 used_prefixes |= (prefixes & PREFIX_DATA);
3859 4201 if (prefixes & PREFIX_DATA)
3860   - snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg + add);
  4202 + {
  4203 + int add = 0;
  4204 + USED_REX (REX_EXTX);
  4205 + if (rex & REX_EXTX)
  4206 + add = 8;
  4207 + snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg + add);
  4208 + }
3861 4209 else
3862   - snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", reg + add);
  4210 + snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", reg);
3863 4211 oappend (scratchbuf + intel_syntax);
3864 4212 }
3865 4213  
3866 4214 static void
3867   -OP_XMM (bytemode, sizeflag)
3868   - int bytemode;
3869   - int sizeflag;
  4215 +OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
3870 4216 {
3871 4217 int add = 0;
3872 4218 USED_REX (REX_EXTX);
... ... @@ -3877,39 +4223,54 @@ OP_XMM (bytemode, sizeflag)
3877 4223 }
3878 4224  
3879 4225 static void
3880   -OP_EM (bytemode, sizeflag)
3881   - int bytemode;
3882   - int sizeflag;
  4226 +OP_EM (int bytemode, int sizeflag)
3883 4227 {
3884   - int add = 0;
3885 4228 if (mod != 3)
3886 4229 {
  4230 + if (intel_syntax && bytemode == v_mode)
  4231 + {
  4232 + bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
  4233 + used_prefixes |= (prefixes & PREFIX_DATA);
  4234 + }
3887 4235 OP_E (bytemode, sizeflag);
3888 4236 return;
3889 4237 }
3890   - USED_REX (REX_EXTZ);
3891   - if (rex & REX_EXTZ)
3892   - add = 8;
3893 4238  
3894 4239 /* Skip mod/rm byte. */
3895 4240 MODRM_CHECK;
3896 4241 codep++;
3897 4242 used_prefixes |= (prefixes & PREFIX_DATA);
3898 4243 if (prefixes & PREFIX_DATA)
3899   - snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", rm + add);
  4244 + {
  4245 + int add = 0;
  4246 +
  4247 + USED_REX (REX_EXTZ);
  4248 + if (rex & REX_EXTZ)
  4249 + add = 8;
  4250 + snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", rm + add);
  4251 + }
3900 4252 else
3901   - snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", rm + add);
  4253 + snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", rm);
3902 4254 oappend (scratchbuf + intel_syntax);
3903 4255 }
3904 4256  
3905 4257 static void
3906   -OP_EX (bytemode, sizeflag)
3907   - int bytemode;
3908   - int sizeflag;
  4258 +OP_EX (int bytemode, int sizeflag)
3909 4259 {
3910 4260 int add = 0;
3911 4261 if (mod != 3)
3912 4262 {
  4263 + if (intel_syntax && bytemode == v_mode)
  4264 + {
  4265 + switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
  4266 + {
  4267 + case 0: bytemode = x_mode; break;
  4268 + case PREFIX_REPZ: bytemode = d_mode; used_prefixes |= PREFIX_REPZ; break;
  4269 + case PREFIX_DATA: bytemode = x_mode; used_prefixes |= PREFIX_DATA; break;
  4270 + case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
  4271 + default: bytemode = 0; break;
  4272 + }
  4273 + }
3913 4274 OP_E (bytemode, sizeflag);
3914 4275 return;
3915 4276 }
... ... @@ -3925,9 +4286,7 @@ OP_EX (bytemode, sizeflag)
3925 4286 }
3926 4287  
3927 4288 static void
3928   -OP_MS (bytemode, sizeflag)
3929   - int bytemode;
3930   - int sizeflag;
  4289 +OP_MS (int bytemode, int sizeflag)
3931 4290 {
3932 4291 if (mod == 3)
3933 4292 OP_EM (bytemode, sizeflag);
... ... @@ -3936,9 +4295,7 @@ OP_MS (bytemode, sizeflag)
3936 4295 }
3937 4296  
3938 4297 static void
3939   -OP_XS (bytemode, sizeflag)
3940   - int bytemode;
3941   - int sizeflag;
  4298 +OP_XS (int bytemode, int sizeflag)
3942 4299 {
3943 4300 if (mod == 3)
3944 4301 OP_EX (bytemode, sizeflag);
... ... @@ -3946,6 +4303,55 @@ OP_XS (bytemode, sizeflag)
3946 4303 BadOp ();
3947 4304 }
3948 4305  
  4306 +static void
  4307 +OP_M (int bytemode, int sizeflag)
  4308 +{
  4309 + if (mod == 3)
  4310 + BadOp (); /* bad lea,lds,les,lfs,lgs,lss modrm */
  4311 + else
  4312 + OP_E (bytemode, sizeflag);
  4313 +}
  4314 +
  4315 +static void
  4316 +OP_0f07 (int bytemode, int sizeflag)
  4317 +{
  4318 + if (mod != 3 || rm != 0)
  4319 + BadOp ();
  4320 + else
  4321 + OP_E (bytemode, sizeflag);
  4322 +}
  4323 +
  4324 +static void
  4325 +OP_0fae (int bytemode, int sizeflag)
  4326 +{
  4327 + if (mod == 3)
  4328 + {
  4329 + if (reg == 7)
  4330 + strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
  4331 +
  4332 + if (reg < 5 || rm != 0)
  4333 + {
  4334 + BadOp (); /* bad sfence, mfence, or lfence */
  4335 + return;
  4336 + }
  4337 + }
  4338 + else if (reg != 7)
  4339 + {
  4340 + BadOp (); /* bad clflush */
  4341 + return;
  4342 + }
  4343 +
  4344 + OP_E (bytemode, sizeflag);
  4345 +}
  4346 +
  4347 +static void
  4348 +NOP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
  4349 +{
  4350 + /* NOP with REPZ prefix is called PAUSE. */
  4351 + if (prefixes == PREFIX_REPZ)
  4352 + strcpy (obuf, "pause");
  4353 +}
  4354 +
3949 4355 static const char *Suffix3DNow[] = {
3950 4356 /* 00 */ NULL, NULL, NULL, NULL,
3951 4357 /* 04 */ NULL, NULL, NULL, NULL,
... ... @@ -4014,9 +4420,7 @@ static const char *Suffix3DNow[] = {
4014 4420 };
4015 4421  
4016 4422 static void
4017   -OP_3DNowSuffix (bytemode, sizeflag)
4018   - int bytemode;
4019   - int sizeflag;
  4423 +OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4020 4424 {
4021 4425 const char *mnemonic;
4022 4426  
... ... @@ -4052,9 +4456,7 @@ static const char *simd_cmp_op[] = {
4052 4456 };
4053 4457  
4054 4458 static void
4055   -OP_SIMD_Suffix (bytemode, sizeflag)
4056   - int bytemode;
4057   - int sizeflag;
  4459 +OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4058 4460 {
4059 4461 unsigned int cmp_type;
4060 4462  
... ... @@ -4094,9 +4496,7 @@ OP_SIMD_Suffix (bytemode, sizeflag)
4094 4496 }
4095 4497  
4096 4498 static void
4097   -SIMD_Fixup (extrachar, sizeflag)
4098   - int extrachar;
4099   - int sizeflag;
  4499 +SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
4100 4500 {
4101 4501 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
4102 4502 forms of these instructions. */
... ... @@ -4112,9 +4512,334 @@ SIMD_Fixup (extrachar, sizeflag)
4112 4512 }
4113 4513  
4114 4514 static void
  4515 +PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
  4516 +{
  4517 + if (mod == 3 && reg == 1 && rm <= 1)
  4518 + {
  4519 + /* Override "sidt". */
  4520 + size_t olen = strlen (obuf);
  4521 + char *p = obuf + olen - 4;
  4522 + const char * const *names = (address_mode == mode_64bit
  4523 + ? names64 : names32);
  4524 +
  4525 + /* We might have a suffix when disassembling with -Msuffix. */
  4526 + if (*p == 'i')
  4527 + --p;
  4528 +
  4529 + /* Remove "addr16/addr32" if we aren't in Intel mode. */
  4530 + if (!intel_syntax
  4531 + && (prefixes & PREFIX_ADDR)
  4532 + && olen >= (4 + 7)
  4533 + && *(p - 1) == ' '
  4534 + && strncmp (p - 7, "addr", 4) == 0
  4535 + && (strncmp (p - 3, "16", 2) == 0
  4536 + || strncmp (p - 3, "32", 2) == 0))
  4537 + p -= 7;
  4538 +
  4539 + if (rm)
  4540 + {
  4541 + /* mwait %eax,%ecx */
  4542 + strcpy (p, "mwait");
  4543 + if (!intel_syntax)
  4544 + strcpy (op1out, names[0]);
  4545 + }
  4546 + else
  4547 + {
  4548 + /* monitor %eax,%ecx,%edx" */
  4549 + strcpy (p, "monitor");
  4550 + if (!intel_syntax)
  4551 + {
  4552 + const char * const *op1_names;
  4553 + if (!(prefixes & PREFIX_ADDR))
  4554 + op1_names = (address_mode == mode_16bit
  4555 + ? names16 : names);
  4556 + else
  4557 + {
  4558 + op1_names = (address_mode != mode_32bit
  4559 + ? names32 : names16);
  4560 + used_prefixes |= PREFIX_ADDR;
  4561 + }
  4562 + strcpy (op1out, op1_names[0]);
  4563 + strcpy (op3out, names[2]);
  4564 + }
  4565 + }
  4566 + if (!intel_syntax)
  4567 + {
  4568 + strcpy (op2out, names[1]);
  4569 + two_source_ops = 1;
  4570 + }
  4571 +
  4572 + codep++;
  4573 + }
  4574 + else
  4575 + OP_M (0, sizeflag);
  4576 +}
  4577 +
  4578 +static void
  4579 +SVME_Fixup (int bytemode, int sizeflag)
  4580 +{
  4581 + const char *alt;
  4582 + char *p;
  4583 +
  4584 + switch (*codep)
  4585 + {
  4586 + case 0xd8:
  4587 + alt = "vmrun";
  4588 + break;
  4589 + case 0xd9:
  4590 + alt = "vmmcall";
  4591 + break;
  4592 + case 0xda:
  4593 + alt = "vmload";
  4594 + break;
  4595 + case 0xdb:
  4596 + alt = "vmsave";
  4597 + break;
  4598 + case 0xdc:
  4599 + alt = "stgi";
  4600 + break;
  4601 + case 0xdd:
  4602 + alt = "clgi";
  4603 + break;
  4604 + case 0xde:
  4605 + alt = "skinit";
  4606 + break;
  4607 + case 0xdf:
  4608 + alt = "invlpga";
  4609 + break;
  4610 + default:
  4611 + OP_M (bytemode, sizeflag);
  4612 + return;
  4613 + }
  4614 + /* Override "lidt". */
  4615 + p = obuf + strlen (obuf) - 4;
  4616 + /* We might have a suffix. */
  4617 + if (*p == 'i')
  4618 + --p;
  4619 + strcpy (p, alt);
  4620 + if (!(prefixes & PREFIX_ADDR))
  4621 + {
  4622 + ++codep;
  4623 + return;
  4624 + }
  4625 + used_prefixes |= PREFIX_ADDR;
  4626 + switch (*codep++)
  4627 + {
  4628 + case 0xdf:
  4629 + strcpy (op2out, names32[1]);
  4630 + two_source_ops = 1;
  4631 + /* Fall through. */
  4632 + case 0xd8:
  4633 + case 0xda:
  4634 + case 0xdb:
  4635 + *obufp++ = open_char;
  4636 + if (address_mode == mode_64bit || (sizeflag & AFLAG))
  4637 + alt = names32[0];
  4638 + else
  4639 + alt = names16[0];
  4640 + strcpy (obufp, alt);
  4641 + obufp += strlen (alt);
  4642 + *obufp++ = close_char;
  4643 + *obufp = '\0';
  4644 + break;
  4645 + }
  4646 +}
  4647 +
  4648 +static void
  4649 +INVLPG_Fixup (int bytemode, int sizeflag)
  4650 +{
  4651 + const char *alt;
  4652 +
  4653 + switch (*codep)
  4654 + {
  4655 + case 0xf8:
  4656 + alt = "swapgs";
  4657 + break;
  4658 + case 0xf9:
  4659 + alt = "rdtscp";
  4660 + break;
  4661 + default:
  4662 + OP_M (bytemode, sizeflag);
  4663 + return;
  4664 + }
  4665 + /* Override "invlpg". */
  4666 + strcpy (obuf + strlen (obuf) - 6, alt);
  4667 + codep++;
  4668 +}
  4669 +
  4670 +static void
4115 4671 BadOp (void)
4116 4672 {
4117 4673 /* Throw away prefixes and 1st. opcode byte. */
4118 4674 codep = insn_codep + 1;
4119 4675 oappend ("(bad)");
4120 4676 }
  4677 +
  4678 +static void
  4679 +SEG_Fixup (int extrachar, int sizeflag)
  4680 +{
  4681 + if (mod == 3)
  4682 + {
  4683 + /* We need to add a proper suffix with
  4684 +
  4685 + movw %ds,%ax
  4686 + movl %ds,%eax
  4687 + movq %ds,%rax
  4688 + movw %ax,%ds
  4689 + movl %eax,%ds
  4690 + movq %rax,%ds
  4691 + */
  4692 + const char *suffix;
  4693 +
  4694 + if (prefixes & PREFIX_DATA)
  4695 + suffix = "w";
  4696 + else
  4697 + {
  4698 + USED_REX (REX_MODE64);
  4699 + if (rex & REX_MODE64)
  4700 + suffix = "q";
  4701 + else
  4702 + suffix = "l";
  4703 + }
  4704 + strcat (obuf, suffix);
  4705 + }
  4706 + else
  4707 + {
  4708 + /* We need to fix the suffix for
  4709 +
  4710 + movw %ds,(%eax)
  4711 + movw %ds,(%rax)
  4712 + movw (%eax),%ds
  4713 + movw (%rax),%ds
  4714 +
  4715 + Override "mov[l|q]". */
  4716 + char *p = obuf + strlen (obuf) - 1;
  4717 +
  4718 + /* We might not have a suffix. */
  4719 + if (*p == 'v')
  4720 + ++p;
  4721 + *p = 'w';
  4722 + }
  4723 +
  4724 + OP_E (extrachar, sizeflag);
  4725 +}
  4726 +
  4727 +static void
  4728 +VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
  4729 +{
  4730 + if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
  4731 + {
  4732 + /* Override "sgdt". */
  4733 + char *p = obuf + strlen (obuf) - 4;
  4734 +
  4735 + /* We might have a suffix when disassembling with -Msuffix. */
  4736 + if (*p == 'g')
  4737 + --p;
  4738 +
  4739 + switch (rm)
  4740 + {
  4741 + case 1:
  4742 + strcpy (p, "vmcall");
  4743 + break;
  4744 + case 2:
  4745 + strcpy (p, "vmlaunch");
  4746 + break;
  4747 + case 3:
  4748 + strcpy (p, "vmresume");
  4749 + break;
  4750 + case 4:
  4751 + strcpy (p, "vmxoff");
  4752 + break;
  4753 + }
  4754 +
  4755 + codep++;
  4756 + }
  4757 + else
  4758 + OP_E (0, sizeflag);
  4759 +}
  4760 +
  4761 +static void
  4762 +OP_VMX (int bytemode, int sizeflag)
  4763 +{
  4764 + used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
  4765 + if (prefixes & PREFIX_DATA)
  4766 + strcpy (obuf, "vmclear");
  4767 + else if (prefixes & PREFIX_REPZ)
  4768 + strcpy (obuf, "vmxon");
  4769 + else
  4770 + strcpy (obuf, "vmptrld");
  4771 + OP_E (bytemode, sizeflag);
  4772 +}
  4773 +
  4774 +static void
  4775 +REP_Fixup (int bytemode, int sizeflag)
  4776 +{
  4777 + /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
  4778 + lods and stos. */
  4779 + size_t ilen = 0;
  4780 +
  4781 + if (prefixes & PREFIX_REPZ)
  4782 + switch (*insn_codep)
  4783 + {
  4784 + case 0x6e: /* outsb */
  4785 + case 0x6f: /* outsw/outsl */
  4786 + case 0xa4: /* movsb */
  4787 + case 0xa5: /* movsw/movsl/movsq */
  4788 + if (!intel_syntax)
  4789 + ilen = 5;
  4790 + else
  4791 + ilen = 4;
  4792 + break;
  4793 + case 0xaa: /* stosb */
  4794 + case 0xab: /* stosw/stosl/stosq */
  4795 + case 0xac: /* lodsb */
  4796 + case 0xad: /* lodsw/lodsl/lodsq */
  4797 + if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
  4798 + ilen = 5;
  4799 + else
  4800 + ilen = 4;
  4801 + break;
  4802 + case 0x6c: /* insb */
  4803 + case 0x6d: /* insl/insw */
  4804 + if (!intel_syntax)
  4805 + ilen = 4;
  4806 + else
  4807 + ilen = 3;
  4808 + break;
  4809 + default:
  4810 + abort ();
  4811 + break;
  4812 + }
  4813 +
  4814 + if (ilen != 0)
  4815 + {
  4816 + size_t olen;
  4817 + char *p;
  4818 +
  4819 + olen = strlen (obuf);
  4820 + p = obuf + olen - ilen - 1 - 4;
  4821 + /* Handle "repz [addr16|addr32]". */
  4822 + if ((prefixes & PREFIX_ADDR))
  4823 + p -= 1 + 6;
  4824 +
  4825 + memmove (p + 3, p + 4, olen - (p + 3 - obuf));
  4826 + }
  4827 +
  4828 + switch (bytemode)
  4829 + {
  4830 + case al_reg:
  4831 + case eAX_reg:
  4832 + case indir_dx_reg:
  4833 + OP_IMREG (bytemode, sizeflag);
  4834 + break;
  4835 + case eDI_reg:
  4836 + OP_ESreg (bytemode, sizeflag);
  4837 + break;
  4838 + case eSI_reg:
  4839 + OP_DSreg (bytemode, sizeflag);
  4840 + break;
  4841 + default:
  4842 + abort ();
  4843 + break;
  4844 + }
  4845 +}
... ...