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 /* Print i386 instructions for GDB, the GNU debugger. 1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 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 #include <stdlib.h> 34 #include <stdlib.h>
39 #include "dis-asm.h" 35 #include "dis-asm.h"
40 #include "qemu-common.h" 36 #include "qemu-common.h"
41 37
42 -#define MAXLEN 20 38 +#define MAXLEN 15
43 39
44 #include <setjmp.h> 40 #include <setjmp.h>
45 41
@@ -49,53 +45,63 @@ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. @@ -49,53 +45,63 @@ Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
49 #define UNIXWARE_COMPAT 1 45 #define UNIXWARE_COMPAT 1
50 #endif 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 struct dis_private { 106 struct dis_private {
101 /* Points to first byte not fetched. */ 107 /* Points to first byte not fetched. */
@@ -110,8 +116,14 @@ struct dis_private { @@ -110,8 +116,14 @@ struct dis_private {
110 when we can. */ 116 when we can. */
111 #define FWAIT_OPCODE (0x9b) 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 /* Flags for the prefixes for the current instruction. See below. */ 128 /* Flags for the prefixes for the current instruction. See below. */
117 static int prefixes; 129 static int prefixes;
@@ -162,24 +174,25 @@ static int used_prefixes; @@ -162,24 +174,25 @@ static int used_prefixes;
162 ? 1 : fetch_data ((info), (addr))) 174 ? 1 : fetch_data ((info), (addr)))
163 175
164 static int 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 int status; 179 int status;
170 struct dis_private *priv = (struct dis_private *) info->private_data; 180 struct dis_private *priv = (struct dis_private *) info->private_data;
171 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer); 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 if (status != 0) 190 if (status != 0)
178 { 191 {
179 /* If we did manage to read at least one byte, then 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 if (priv->max_fetched == priv->the_buffer) 196 if (priv->max_fetched == priv->the_buffer)
184 (*info->memory_error_func) (status, start, info); 197 (*info->memory_error_func) (status, start, info);
185 longjmp (priv->bailout, 1); 198 longjmp (priv->bailout, 1);
@@ -194,15 +207,22 @@ fetch_data (info, addr) @@ -194,15 +207,22 @@ fetch_data (info, addr)
194 #define Eb OP_E, b_mode 207 #define Eb OP_E, b_mode
195 #define Ev OP_E, v_mode 208 #define Ev OP_E, v_mode
196 #define Ed OP_E, d_mode 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 #define Ew OP_E, w_mode 217 #define Ew OP_E, w_mode
200 #define Ma OP_E, v_mode 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 #define Gb OP_G, b_mode 221 #define Gb OP_G, b_mode
204 #define Gv OP_G, v_mode 222 #define Gv OP_G, v_mode
205 #define Gd OP_G, d_mode 223 #define Gd OP_G, d_mode
  224 +#define Gdq OP_G, dq_mode
  225 +#define Gm OP_G, m_mode
206 #define Gw OP_G, w_mode 226 #define Gw OP_G, w_mode
207 #define Rd OP_Rd, d_mode 227 #define Rd OP_Rd, d_mode
208 #define Rm OP_Rd, m_mode 228 #define Rm OP_Rd, m_mode
@@ -212,11 +232,13 @@ fetch_data (info, addr) @@ -212,11 +232,13 @@ fetch_data (info, addr)
212 #define Iq OP_I, q_mode 232 #define Iq OP_I, q_mode
213 #define Iv64 OP_I64, v_mode 233 #define Iv64 OP_I64, v_mode
214 #define Iw OP_I, w_mode 234 #define Iw OP_I, w_mode
  235 +#define I1 OP_I, const_1_mode
215 #define Jb OP_J, b_mode 236 #define Jb OP_J, b_mode
216 #define Jv OP_J, v_mode 237 #define Jv OP_J, v_mode
217 #define Cm OP_C, m_mode 238 #define Cm OP_C, m_mode
218 #define Dm OP_D, m_mode 239 #define Dm OP_D, m_mode
219 #define Td OP_T, d_mode 240 #define Td OP_T, d_mode
  241 +#define Sv SEG_Fixup, v_mode
220 242
221 #define RMeAX OP_REG, eAX_reg 243 #define RMeAX OP_REG, eAX_reg
222 #define RMeBX OP_REG, eBX_reg 244 #define RMeBX OP_REG, eBX_reg
@@ -255,7 +277,6 @@ fetch_data (info, addr) @@ -255,7 +277,6 @@ fetch_data (info, addr)
255 #define eSI OP_IMREG, eSI_reg 277 #define eSI OP_IMREG, eSI_reg
256 #define eDI OP_IMREG, eDI_reg 278 #define eDI OP_IMREG, eDI_reg
257 #define AL OP_IMREG, al_reg 279 #define AL OP_IMREG, al_reg
258 -#define AL OP_IMREG, al_reg  
259 #define CL OP_IMREG, cl_reg 280 #define CL OP_IMREG, cl_reg
260 #define DL OP_IMREG, dl_reg 281 #define DL OP_IMREG, dl_reg
261 #define BL OP_IMREG, bl_reg 282 #define BL OP_IMREG, bl_reg
@@ -269,10 +290,8 @@ fetch_data (info, addr) @@ -269,10 +290,8 @@ fetch_data (info, addr)
269 290
270 #define Sw OP_SEG, w_mode 291 #define Sw OP_SEG, w_mode
271 #define Ap OP_DIR, 0 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 #define Xb OP_DSreg, eSI_reg 295 #define Xb OP_DSreg, eSI_reg
277 #define Xv OP_DSreg, eSI_reg 296 #define Xv OP_DSreg, eSI_reg
278 #define Yb OP_ESreg, eDI_reg 297 #define Yb OP_ESreg, eDI_reg
@@ -292,10 +311,19 @@ fetch_data (info, addr) @@ -292,10 +311,19 @@ fetch_data (info, addr)
292 #define EX OP_EX, v_mode 311 #define EX OP_EX, v_mode
293 #define MS OP_MS, v_mode 312 #define MS OP_MS, v_mode
294 #define XS OP_XS, v_mode 313 #define XS OP_XS, v_mode
295 -#define None OP_E, 0 314 +#define VM OP_VMX, q_mode
296 #define OPSUF OP_3DNowSuffix, 0 315 #define OPSUF OP_3DNowSuffix, 0
297 #define OPSIMD OP_SIMD_Suffix, 0 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 #define cond_jump_flag NULL, cond_jump_mode 327 #define cond_jump_flag NULL, cond_jump_mode
300 #define loop_jcxz_flag NULL, loop_jcxz_mode 328 #define loop_jcxz_flag NULL, loop_jcxz_mode
301 329
@@ -309,10 +337,16 @@ fetch_data (info, addr) @@ -309,10 +337,16 @@ fetch_data (info, addr)
309 #define w_mode 3 /* word operand */ 337 #define w_mode 3 /* word operand */
310 #define d_mode 4 /* double word operand */ 338 #define d_mode 4 /* double word operand */
311 #define q_mode 5 /* quad word operand */ 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 #define es_reg 100 351 #define es_reg 100
318 #define cs_reg 101 352 #define cs_reg 101
@@ -363,6 +397,7 @@ fetch_data (info, addr) @@ -363,6 +397,7 @@ fetch_data (info, addr)
363 #define USE_GROUPS 2 397 #define USE_GROUPS 2
364 #define USE_PREFIX_USER_TABLE 3 398 #define USE_PREFIX_USER_TABLE 3
365 #define X86_64_SPECIAL 4 399 #define X86_64_SPECIAL 4
  400 +#define IS_3BYTE_OPCODE 5
366 401
367 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0 402 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
368 403
@@ -389,6 +424,8 @@ fetch_data (info, addr) @@ -389,6 +424,8 @@ fetch_data (info, addr)
389 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0 424 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
390 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0 425 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
391 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0 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 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0 430 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0
394 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0 431 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0
@@ -417,10 +454,19 @@ fetch_data (info, addr) @@ -417,10 +454,19 @@ fetch_data (info, addr)
417 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0 454 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
418 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0 455 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
419 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0 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 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0 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 struct dis386 { 471 struct dis386 {
426 const char *name; 472 const char *name;
@@ -435,9 +481,14 @@ struct dis386 { @@ -435,9 +481,14 @@ struct dis386 {
435 /* Upper case letters in the instruction names here are macros. 481 /* Upper case letters in the instruction names here are macros.
436 'A' => print 'b' if no register operands or suffix_always is true 482 'A' => print 'b' if no register operands or suffix_always is true
437 'B' => print 'b' if suffix_always is true 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 'E' => print 'e' if 32-bit form of jcxz 486 'E' => print 'e' if 32-bit form of jcxz
439 'F' => print 'w' or 'l' depending on address size prefix (loop insns) 487 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
440 'H' => print ",pt" or ",pn" branch hint 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 'L' => print 'l' if suffix_always is true 492 'L' => print 'l' if suffix_always is true
442 'N' => print 'n' if instruction has no wait "prefix" 493 'N' => print 'n' if instruction has no wait "prefix"
443 'O' => print 'd', or 'o' 494 'O' => print 'd', or 'o'
@@ -449,9 +500,11 @@ struct dis386 { @@ -449,9 +500,11 @@ struct dis386 {
449 'S' => print 'w', 'l' or 'q' if suffix_always is true 500 'S' => print 'w', 'l' or 'q' if suffix_always is true
450 'T' => print 'q' in 64bit mode and behave as 'P' otherwise 501 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
451 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise 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 'W' => print 'b' or 'w' ("w" or "de" in intel mode) 504 'W' => print 'b' or 'w' ("w" or "de" in intel mode)
  505 + 'X' => print 's', 'd' depending on data16 prefix (for XMM)
454 'Y' => 'q' if instruction has an REX 64bit overwrite prefix 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 Many of the above letters print nothing in Intel mode. See "putop" 509 Many of the above letters print nothing in Intel mode. See "putop"
457 for the details. 510 for the details.
@@ -489,7 +542,7 @@ static const struct dis386 dis386[] = { @@ -489,7 +542,7 @@ static const struct dis386 dis386[] = {
489 { "adcB", AL, Ib, XX }, 542 { "adcB", AL, Ib, XX },
490 { "adcS", eAX, Iv, XX }, 543 { "adcS", eAX, Iv, XX },
491 { "push{T|}", ss, XX, XX }, 544 { "push{T|}", ss, XX, XX },
492 - { "popT|}", ss, XX, XX }, 545 + { "pop{T|}", ss, XX, XX },
493 /* 18 */ 546 /* 18 */
494 { "sbbB", Eb, Gb, XX }, 547 { "sbbB", Eb, Gb, XX },
495 { "sbbS", Ev, Gv, XX }, 548 { "sbbS", Ev, Gv, XX },
@@ -554,23 +607,23 @@ static const struct dis386 dis386[] = { @@ -554,23 +607,23 @@ static const struct dis386 dis386[] = {
554 { "dec{S|}", RMeSI, XX, XX }, 607 { "dec{S|}", RMeSI, XX, XX },
555 { "dec{S|}", RMeDI, XX, XX }, 608 { "dec{S|}", RMeDI, XX, XX },
556 /* 50 */ 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 /* 58 */ 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 /* 60 */ 627 /* 60 */
575 { "pusha{P|}", XX, XX, XX }, 628 { "pusha{P|}", XX, XX, XX },
576 { "popa{P|}", XX, XX, XX }, 629 { "popa{P|}", XX, XX, XX },
@@ -585,10 +638,10 @@ static const struct dis386 dis386[] = { @@ -585,10 +638,10 @@ static const struct dis386 dis386[] = {
585 { "imulS", Gv, Ev, Iv }, 638 { "imulS", Gv, Ev, Iv },
586 { "pushT", sIb, XX, XX }, 639 { "pushT", sIb, XX, XX },
587 { "imulS", Gv, Ev, sIb }, 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 /* 70 */ 645 /* 70 */
593 { "joH", Jb, XX, cond_jump_flag }, 646 { "joH", Jb, XX, cond_jump_flag },
594 { "jnoH", Jb, XX, cond_jump_flag }, 647 { "jnoH", Jb, XX, cond_jump_flag },
@@ -621,13 +674,12 @@ static const struct dis386 dis386[] = { @@ -621,13 +674,12 @@ static const struct dis386 dis386[] = {
621 { "movS", Ev, Gv, XX }, 674 { "movS", Ev, Gv, XX },
622 { "movB", Gb, Eb, XX }, 675 { "movB", Gb, Eb, XX },
623 { "movS", Gv, Ev, XX }, 676 { "movS", Gv, Ev, XX },
624 - { "movQ", Ev, Sw, XX }, 677 + { "movQ", Sv, Sw, XX },
625 { "leaS", Gv, M, XX }, 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 /* 90 */ 681 /* 90 */
629 - { "nop", XX, XX, XX },  
630 - /* FIXME: NOP with REPz prefix is called PAUSE. */ 682 + { "nop", NOP_Fixup, 0, XX, XX },
631 { "xchgS", RMeCX, eAX, XX }, 683 { "xchgS", RMeCX, eAX, XX },
632 { "xchgS", RMeDX, eAX, XX }, 684 { "xchgS", RMeDX, eAX, XX },
633 { "xchgS", RMeBX, eAX, XX }, 685 { "xchgS", RMeBX, eAX, XX },
@@ -638,28 +690,28 @@ static const struct dis386 dis386[] = { @@ -638,28 +690,28 @@ static const struct dis386 dis386[] = {
638 /* 98 */ 690 /* 98 */
639 { "cW{tR||tR|}", XX, XX, XX }, 691 { "cW{tR||tR|}", XX, XX, XX },
640 { "cR{tO||tO|}", XX, XX, XX }, 692 { "cR{tO||tO|}", XX, XX, XX },
641 - { "lcall{T|}", Ap, XX, XX }, 693 + { "Jcall{T|}", Ap, XX, XX },
642 { "(bad)", XX, XX, XX }, /* fwait */ 694 { "(bad)", XX, XX, XX }, /* fwait */
643 { "pushfT", XX, XX, XX }, 695 { "pushfT", XX, XX, XX },
644 { "popfT", XX, XX, XX }, 696 { "popfT", XX, XX, XX },
645 { "sahf{|}", XX, XX, XX }, 697 { "sahf{|}", XX, XX, XX },
646 { "lahf{|}", XX, XX, XX }, 698 { "lahf{|}", XX, XX, XX },
647 /* a0 */ 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 { "cmps{b||b|}", Xb, Yb, XX }, 706 { "cmps{b||b|}", Xb, Yb, XX },
655 { "cmps{R||R|}", Xv, Yv, XX }, 707 { "cmps{R||R|}", Xv, Yv, XX },
656 /* a8 */ 708 /* a8 */
657 { "testB", AL, Ib, XX }, 709 { "testB", AL, Ib, XX },
658 { "testS", eAX, Iv, XX }, 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 { "scasB", AL, Yb, XX }, 715 { "scasB", AL, Yb, XX },
664 { "scasS", eAX, Yv, XX }, 716 { "scasS", eAX, Yv, XX },
665 /* b0 */ 717 /* b0 */
@@ -728,7 +780,7 @@ static const struct dis386 dis386[] = { @@ -728,7 +780,7 @@ static const struct dis386 dis386[] = {
728 /* e8 */ 780 /* e8 */
729 { "callT", Jv, XX, XX }, 781 { "callT", Jv, XX, XX },
730 { "jmpT", Jv, XX, XX }, 782 { "jmpT", Jv, XX, XX },
731 - { "ljmp{T|}", Ap, XX, XX }, 783 + { "Jjmp{T|}", Ap, XX, XX },
732 { "jmp", Jb, XX, XX }, 784 { "jmp", Jb, XX, XX },
733 { "inB", AL, indirDX, XX }, 785 { "inB", AL, indirDX, XX },
734 { "inS", eAX, indirDX, XX }, 786 { "inS", eAX, indirDX, XX },
@@ -736,7 +788,7 @@ static const struct dis386 dis386[] = { @@ -736,7 +788,7 @@ static const struct dis386 dis386[] = {
736 { "outS", indirDX, eAX, XX }, 788 { "outS", indirDX, eAX, XX },
737 /* f0 */ 789 /* f0 */
738 { "(bad)", XX, XX, XX }, /* lock prefix */ 790 { "(bad)", XX, XX, XX }, /* lock prefix */
739 - { "(bad)", XX, XX, XX }, 791 + { "icebp", XX, XX, XX },
740 { "(bad)", XX, XX, XX }, /* repne */ 792 { "(bad)", XX, XX, XX }, /* repne */
741 { "(bad)", XX, XX, XX }, /* repz */ 793 { "(bad)", XX, XX, XX }, /* repz */
742 { "hlt", XX, XX, XX }, 794 { "hlt", XX, XX, XX },
@@ -776,11 +828,11 @@ static const struct dis386 dis386_twobyte[] = { @@ -776,11 +828,11 @@ static const struct dis386 dis386_twobyte[] = {
776 /* 10 */ 828 /* 10 */
777 { PREGRP8 }, 829 { PREGRP8 },
778 { PREGRP9 }, 830 { PREGRP9 },
779 - { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */ 831 + { PREGRP30 },
780 { "movlpX", EX, XM, SIMD_Fixup, 'h' }, 832 { "movlpX", EX, XM, SIMD_Fixup, 'h' },
781 { "unpcklpX", XM, EX, XX }, 833 { "unpcklpX", XM, EX, XX },
782 { "unpckhpX", XM, EX, XX }, 834 { "unpckhpX", XM, EX, XX },
783 - { "movhpX", XM, EX, SIMD_Fixup, 'l' }, 835 + { PREGRP31 },
784 { "movhpX", EX, XM, SIMD_Fixup, 'l' }, 836 { "movhpX", EX, XM, SIMD_Fixup, 'l' },
785 /* 18 */ 837 /* 18 */
786 { GRP14 }, 838 { GRP14 },
@@ -792,10 +844,10 @@ static const struct dis386 dis386_twobyte[] = { @@ -792,10 +844,10 @@ static const struct dis386 dis386_twobyte[] = {
792 { "(bad)", XX, XX, XX }, 844 { "(bad)", XX, XX, XX },
793 { "(bad)", XX, XX, XX }, 845 { "(bad)", XX, XX, XX },
794 /* 20 */ 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 { "movL", Rd, Td, XX }, 851 { "movL", Rd, Td, XX },
800 { "(bad)", XX, XX, XX }, 852 { "(bad)", XX, XX, XX },
801 { "movL", Td, Rd, XX }, 853 { "movL", Td, Rd, XX },
@@ -819,9 +871,9 @@ static const struct dis386 dis386_twobyte[] = { @@ -819,9 +871,9 @@ static const struct dis386 dis386_twobyte[] = {
819 { "(bad)", XX, XX, XX }, 871 { "(bad)", XX, XX, XX },
820 { "(bad)", XX, XX, XX }, 872 { "(bad)", XX, XX, XX },
821 /* 38 */ 873 /* 38 */
  874 + { THREE_BYTE_0 },
822 { "(bad)", XX, XX, XX }, 875 { "(bad)", XX, XX, XX },
823 - { "(bad)", XX, XX, XX },  
824 - { "(bad)", XX, XX, XX }, 876 + { THREE_BYTE_1 },
825 { "(bad)", XX, XX, XX }, 877 { "(bad)", XX, XX, XX },
826 { "(bad)", XX, XX, XX }, 878 { "(bad)", XX, XX, XX },
827 { "(bad)", XX, XX, XX }, 879 { "(bad)", XX, XX, XX },
@@ -846,7 +898,7 @@ static const struct dis386 dis386_twobyte[] = { @@ -846,7 +898,7 @@ static const struct dis386 dis386_twobyte[] = {
846 { "cmovle", Gv, Ev, XX }, 898 { "cmovle", Gv, Ev, XX },
847 { "cmovg", Gv, Ev, XX }, 899 { "cmovg", Gv, Ev, XX },
848 /* 50 */ 900 /* 50 */
849 - { "movmskpX", Gd, XS, XX }, 901 + { "movmskpX", Gdq, XS, XX },
850 { PREGRP13 }, 902 { PREGRP13 },
851 { PREGRP12 }, 903 { PREGRP12 },
852 { PREGRP11 }, 904 { PREGRP11 },
@@ -879,7 +931,7 @@ static const struct dis386 dis386_twobyte[] = { @@ -879,7 +931,7 @@ static const struct dis386 dis386_twobyte[] = {
879 { "packssdw", MX, EM, XX }, 931 { "packssdw", MX, EM, XX },
880 { PREGRP26 }, 932 { PREGRP26 },
881 { PREGRP24 }, 933 { PREGRP24 },
882 - { "movd", MX, Ed, XX }, 934 + { "movd", MX, Edq, XX },
883 { PREGRP19 }, 935 { PREGRP19 },
884 /* 70 */ 936 /* 70 */
885 { PREGRP22 }, 937 { PREGRP22 },
@@ -891,12 +943,12 @@ static const struct dis386 dis386_twobyte[] = { @@ -891,12 +943,12 @@ static const struct dis386 dis386_twobyte[] = {
891 { "pcmpeqd", MX, EM, XX }, 943 { "pcmpeqd", MX, EM, XX },
892 { "emms", XX, XX, XX }, 944 { "emms", XX, XX, XX },
893 /* 78 */ 945 /* 78 */
  946 + { "vmread", Em, Gm, XX },
  947 + { "vmwrite", Gm, Em, XX },
894 { "(bad)", XX, XX, XX }, 948 { "(bad)", XX, XX, XX },
895 { "(bad)", XX, XX, XX }, 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 { PREGRP23 }, 952 { PREGRP23 },
901 { PREGRP20 }, 953 { PREGRP20 },
902 /* 80 */ 954 /* 80 */
@@ -942,8 +994,8 @@ static const struct dis386 dis386_twobyte[] = { @@ -942,8 +994,8 @@ static const struct dis386 dis386_twobyte[] = {
942 { "btS", Ev, Gv, XX }, 994 { "btS", Ev, Gv, XX },
943 { "shldS", Ev, Gv, Ib }, 995 { "shldS", Ev, Gv, Ib },
944 { "shldS", Ev, Gv, CL }, 996 { "shldS", Ev, Gv, CL },
945 - { "(bad)", XX, XX, XX },  
946 - { "(bad)", XX, XX, XX }, 997 + { GRPPADLCK2 },
  998 + { GRPPADLCK1 },
947 /* a8 */ 999 /* a8 */
948 { "pushT", gs, XX, XX }, 1000 { "pushT", gs, XX, XX },
949 { "popT", gs, XX, XX }, 1001 { "popT", gs, XX, XX },
@@ -976,8 +1028,8 @@ static const struct dis386 dis386_twobyte[] = { @@ -976,8 +1028,8 @@ static const struct dis386 dis386_twobyte[] = {
976 { "xaddS", Ev, Gv, XX }, 1028 { "xaddS", Ev, Gv, XX },
977 { PREGRP1 }, 1029 { PREGRP1 },
978 { "movntiS", Ev, Gv, XX }, 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 { "shufpX", XM, EX, Ib }, 1033 { "shufpX", XM, EX, Ib },
982 { GRP9 }, 1034 { GRP9 },
983 /* c8 */ 1035 /* c8 */
@@ -990,14 +1042,14 @@ static const struct dis386 dis386_twobyte[] = { @@ -990,14 +1042,14 @@ static const struct dis386 dis386_twobyte[] = {
990 { "bswap", RMeSI, XX, XX }, 1042 { "bswap", RMeSI, XX, XX },
991 { "bswap", RMeDI, XX, XX }, 1043 { "bswap", RMeDI, XX, XX },
992 /* d0 */ 1044 /* d0 */
993 - { "(bad)", XX, XX, XX }, 1045 + { PREGRP27 },
994 { "psrlw", MX, EM, XX }, 1046 { "psrlw", MX, EM, XX },
995 { "psrld", MX, EM, XX }, 1047 { "psrld", MX, EM, XX },
996 { "psrlq", MX, EM, XX }, 1048 { "psrlq", MX, EM, XX },
997 { "paddq", MX, EM, XX }, 1049 { "paddq", MX, EM, XX },
998 { "pmullw", MX, EM, XX }, 1050 { "pmullw", MX, EM, XX },
999 { PREGRP21 }, 1051 { PREGRP21 },
1000 - { "pmovmskb", Gd, MS, XX }, 1052 + { "pmovmskb", Gdq, MS, XX },
1001 /* d8 */ 1053 /* d8 */
1002 { "psubusb", MX, EM, XX }, 1054 { "psubusb", MX, EM, XX },
1003 { "psubusw", MX, EM, XX }, 1055 { "psubusw", MX, EM, XX },
@@ -1026,7 +1078,7 @@ static const struct dis386 dis386_twobyte[] = { @@ -1026,7 +1078,7 @@ static const struct dis386 dis386_twobyte[] = {
1026 { "pmaxsw", MX, EM, XX }, 1078 { "pmaxsw", MX, EM, XX },
1027 { "pxor", MX, EM, XX }, 1079 { "pxor", MX, EM, XX },
1028 /* f0 */ 1080 /* f0 */
1029 - { "(bad)", XX, XX, XX }, 1081 + { PREGRP32 },
1030 { "psllw", MX, EM, XX }, 1082 { "psllw", MX, EM, XX },
1031 { "pslld", MX, EM, XX }, 1083 { "pslld", MX, EM, XX },
1032 { "psllq", MX, EM, XX }, 1084 { "psllq", MX, EM, XX },
@@ -1074,19 +1126,19 @@ static const unsigned char twobyte_has_modrm[256] = { @@ -1074,19 +1126,19 @@ static const unsigned char twobyte_has_modrm[256] = {
1074 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */ 1126 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1075 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */ 1127 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
1076 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */ 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 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */ 1130 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1079 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */ 1131 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1080 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */ 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 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1134 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1083 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */ 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 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */ 1137 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
1086 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */ 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 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */ 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 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 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,21 +1147,21 @@ static const unsigned char twobyte_uses_SSE_prefix[256] = {
1095 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 1147 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1096 /* ------------------------------- */ 1148 /* ------------------------------- */
1097 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */ 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 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */ 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 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */ 1153 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1102 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */ 1154 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1103 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */ 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 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */ 1157 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1106 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */ 1158 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1107 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */ 1159 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1108 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */ 1160 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1109 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */ 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 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */ 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 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */ 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,25 +1301,25 @@ static const struct dis386 grps[][8] = {
1249 }, 1301 },
1250 /* GRP2b_one */ 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 { "(bad)", XX, XX, XX }, 1310 { "(bad)", XX, XX, XX },
1259 - { "sarA", Eb, XX, XX }, 1311 + { "sarA", Eb, I1, XX },
1260 }, 1312 },
1261 /* GRP2S_one */ 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 { "(bad)", XX, XX, XX}, 1321 { "(bad)", XX, XX, XX},
1270 - { "sarQ", Ev, XX, XX }, 1322 + { "sarQ", Ev, I1, XX },
1271 }, 1323 },
1272 /* GRP2b_cl */ 1324 /* GRP2b_cl */
1273 { 1325 {
@@ -1329,10 +1381,10 @@ static const struct dis386 grps[][8] = { @@ -1329,10 +1381,10 @@ static const struct dis386 grps[][8] = {
1329 { "incQ", Ev, XX, XX }, 1381 { "incQ", Ev, XX, XX },
1330 { "decQ", Ev, XX, XX }, 1382 { "decQ", Ev, XX, XX },
1331 { "callT", indirEv, XX, XX }, 1383 { "callT", indirEv, XX, XX },
1332 - { "lcallT", indirEv, XX, XX }, 1384 + { "JcallT", indirEp, XX, XX },
1333 { "jmpT", indirEv, XX, XX }, 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 { "(bad)", XX, XX, XX }, 1388 { "(bad)", XX, XX, XX },
1337 }, 1389 },
1338 /* GRP6 */ 1390 /* GRP6 */
@@ -1348,14 +1400,14 @@ static const struct dis386 grps[][8] = { @@ -1348,14 +1400,14 @@ static const struct dis386 grps[][8] = {
1348 }, 1400 },
1349 /* GRP7 */ 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 { "smswQ", Ev, XX, XX }, 1407 { "smswQ", Ev, XX, XX },
1356 { "(bad)", XX, XX, XX }, 1408 { "(bad)", XX, XX, XX },
1357 { "lmsw", Ew, XX, XX }, 1409 { "lmsw", Ew, XX, XX },
1358 - { "invlpg", Ew, XX, XX }, 1410 + { "invlpg", INVLPG_Fixup, w_mode, XX, XX },
1359 }, 1411 },
1360 /* GRP8 */ 1412 /* GRP8 */
1361 { 1413 {
@@ -1371,13 +1423,13 @@ static const struct dis386 grps[][8] = { @@ -1371,13 +1423,13 @@ static const struct dis386 grps[][8] = {
1371 /* GRP9 */ 1423 /* GRP9 */
1372 { 1424 {
1373 { "(bad)", XX, XX, XX }, 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 { "(bad)", XX, XX, XX }, 1427 { "(bad)", XX, XX, XX },
1378 { "(bad)", XX, XX, XX }, 1428 { "(bad)", XX, XX, XX },
1379 { "(bad)", XX, XX, XX }, 1429 { "(bad)", XX, XX, XX },
1380 { "(bad)", XX, XX, XX }, 1430 { "(bad)", XX, XX, XX },
  1431 + { "", VM, XX, XX }, /* See OP_VMX. */
  1432 + { "vmptrst", Eq, XX, XX },
1381 }, 1433 },
1382 /* GRP10 */ 1434 /* GRP10 */
1383 { 1435 {
@@ -1419,10 +1471,9 @@ static const struct dis386 grps[][8] = { @@ -1419,10 +1471,9 @@ static const struct dis386 grps[][8] = {
1419 { "ldmxcsr", Ev, XX, XX }, 1471 { "ldmxcsr", Ev, XX, XX },
1420 { "stmxcsr", Ev, XX, XX }, 1472 { "stmxcsr", Ev, XX, XX },
1421 { "(bad)", XX, XX, XX }, 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 /* GRP14 */ 1478 /* GRP14 */
1428 { 1479 {
@@ -1445,6 +1496,28 @@ static const struct dis386 grps[][8] = { @@ -1445,6 +1496,28 @@ static const struct dis386 grps[][8] = {
1445 { "(bad)", XX, XX, XX }, 1496 { "(bad)", XX, XX, XX },
1446 { "(bad)", XX, XX, XX }, 1497 { "(bad)", XX, XX, XX },
1447 { "(bad)", XX, XX, XX }, 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,9 +1685,9 @@ static const struct dis386 prefix_user_table[][4] = {
1612 }, 1685 },
1613 /* PREGRP23 */ 1686 /* PREGRP23 */
1614 { 1687 {
1615 - { "movd", Ed, MX, XX }, 1688 + { "movd", Edq, MX, XX },
1616 { "movq", XM, EX, XX }, 1689 { "movq", XM, EX, XX },
1617 - { "movd", Ed, XM, XX }, 1690 + { "movd", Edq, XM, XX },
1618 { "(bad)", Ed, XM, XX }, 1691 { "(bad)", Ed, XM, XX },
1619 }, 1692 },
1620 /* PREGRP24 */ 1693 /* PREGRP24 */
@@ -1626,10 +1699,10 @@ static const struct dis386 prefix_user_table[][4] = { @@ -1626,10 +1699,10 @@ static const struct dis386 prefix_user_table[][4] = {
1626 }, 1699 },
1627 /* PREGRP25 */ 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 /* PREGRP26 */ 1707 /* PREGRP26 */
1635 { 1708 {
@@ -1638,6 +1711,48 @@ static const struct dis386 prefix_user_table[][4] = { @@ -1638,6 +1711,48 @@ static const struct dis386 prefix_user_table[][4] = {
1638 { "punpcklqdq", XM, EX, XX }, 1711 { "punpcklqdq", XM, EX, XX },
1639 { "(bad)", XM, EX, XX }, 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 static const struct dis386 x86_64_table[][2] = { 1758 static const struct dis386 x86_64_table[][2] = {
@@ -1647,10 +1762,83 @@ 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 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>") 1838 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
1651 1839
1652 static void 1840 static void
1653 -ckprefix () 1841 +ckprefix (void)
1654 { 1842 {
1655 int newrex; 1843 int newrex;
1656 rex = 0; 1844 rex = 0;
@@ -1680,7 +1868,7 @@ ckprefix () @@ -1680,7 +1868,7 @@ ckprefix ()
1680 case 0x4d: 1868 case 0x4d:
1681 case 0x4e: 1869 case 0x4e:
1682 case 0x4f: 1870 case 0x4f:
1683 - if (mode_64bit) 1871 + if (address_mode == mode_64bit)
1684 newrex = *codep; 1872 newrex = *codep;
1685 else 1873 else
1686 return; 1874 return;
@@ -1722,7 +1910,7 @@ ckprefix () @@ -1722,7 +1910,7 @@ ckprefix ()
1722 /* fwait is really an instruction. If there are prefixes 1910 /* fwait is really an instruction. If there are prefixes
1723 before the fwait, they belong to the fwait, *not* to the 1911 before the fwait, they belong to the fwait, *not* to the
1724 following instruction. */ 1912 following instruction. */
1725 - if (prefixes) 1913 + if (prefixes || rex)
1726 { 1914 {
1727 prefixes |= PREFIX_FWAIT; 1915 prefixes |= PREFIX_FWAIT;
1728 codep++; 1916 codep++;
@@ -1736,8 +1924,8 @@ ckprefix () @@ -1736,8 +1924,8 @@ ckprefix ()
1736 /* Rex is ignored when followed by another prefix. */ 1924 /* Rex is ignored when followed by another prefix. */
1737 if (rex) 1925 if (rex)
1738 { 1926 {
1739 - oappend (prefix_name (rex, 0));  
1740 - oappend (" "); 1927 + rex_used = rex;
  1928 + return;
1741 } 1929 }
1742 rex = newrex; 1930 rex = newrex;
1743 codep++; 1931 codep++;
@@ -1748,9 +1936,7 @@ ckprefix () @@ -1748,9 +1936,7 @@ ckprefix ()
1748 prefix byte. */ 1936 prefix byte. */
1749 1937
1750 static const char * 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 switch (pref) 1941 switch (pref)
1756 { 1942 {
@@ -1808,10 +1994,10 @@ prefix_name (pref, sizeflag) @@ -1808,10 +1994,10 @@ prefix_name (pref, sizeflag)
1808 case 0x66: 1994 case 0x66:
1809 return (sizeflag & DFLAG) ? "data16" : "data32"; 1995 return (sizeflag & DFLAG) ? "data16" : "data32";
1810 case 0x67: 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 else 1999 else
1814 - return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32"; 2000 + return (sizeflag & AFLAG) ? "addr16" : "addr32";
1815 case FWAIT_OPCODE: 2001 case FWAIT_OPCODE:
1816 return "fwait"; 2002 return "fwait";
1817 default: 2003 default:
@@ -1821,6 +2007,7 @@ prefix_name (pref, sizeflag) @@ -1821,6 +2007,7 @@ prefix_name (pref, sizeflag)
1821 2007
1822 static char op1out[100], op2out[100], op3out[100]; 2008 static char op1out[100], op2out[100], op3out[100];
1823 static int op_ad, op_index[3]; 2009 static int op_ad, op_index[3];
  2010 +static int two_source_ops;
1824 static bfd_vma op_address[3]; 2011 static bfd_vma op_address[3];
1825 static bfd_vma op_riprel[3]; 2012 static bfd_vma op_riprel[3];
1826 static bfd_vma start_pc; 2013 static bfd_vma start_pc;
@@ -1834,16 +2021,14 @@ static bfd_vma start_pc; @@ -1834,16 +2021,14 @@ static bfd_vma start_pc;
1834 * The function returns the length of this instruction in bytes. 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 static char open_char; 2025 static char open_char;
1839 static char close_char; 2026 static char close_char;
1840 static char separator_char; 2027 static char separator_char;
1841 static char scale_char; 2028 static char scale_char;
1842 2029
1843 int 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 intel_syntax = -1; 2033 intel_syntax = -1;
1849 2034
@@ -1851,24 +2036,24 @@ print_insn_i386 (pc, info) @@ -1851,24 +2036,24 @@ print_insn_i386 (pc, info)
1851 } 2036 }
1852 2037
1853 static int 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 const struct dis386 *dp; 2041 const struct dis386 *dp;
1859 int i; 2042 int i;
1860 - int two_source_ops;  
1861 char *first, *second, *third; 2043 char *first, *second, *third;
1862 int needcomma; 2044 int needcomma;
1863 - unsigned char uses_SSE_prefix; 2045 + unsigned char uses_SSE_prefix, uses_LOCK_prefix;
1864 int sizeflag; 2046 int sizeflag;
1865 const char *p; 2047 const char *p;
1866 struct dis_private priv; 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 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax 2057 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
1873 || info->mach == bfd_mach_x86_64_intel_syntax); 2058 || info->mach == bfd_mach_x86_64_intel_syntax);
1874 2059
@@ -1886,17 +2071,17 @@ print_insn (pc, info) @@ -1886,17 +2071,17 @@ print_insn (pc, info)
1886 { 2071 {
1887 if (strncmp (p, "x86-64", 6) == 0) 2072 if (strncmp (p, "x86-64", 6) == 0)
1888 { 2073 {
1889 - mode_64bit = 1; 2074 + address_mode = mode_64bit;
1890 priv.orig_sizeflag = AFLAG | DFLAG; 2075 priv.orig_sizeflag = AFLAG | DFLAG;
1891 } 2076 }
1892 else if (strncmp (p, "i386", 4) == 0) 2077 else if (strncmp (p, "i386", 4) == 0)
1893 { 2078 {
1894 - mode_64bit = 0; 2079 + address_mode = mode_32bit;
1895 priv.orig_sizeflag = AFLAG | DFLAG; 2080 priv.orig_sizeflag = AFLAG | DFLAG;
1896 } 2081 }
1897 else if (strncmp (p, "i8086", 5) == 0) 2082 else if (strncmp (p, "i8086", 5) == 0)
1898 { 2083 {
1899 - mode_64bit = 0; 2084 + address_mode = mode_16bit;
1900 priv.orig_sizeflag = 0; 2085 priv.orig_sizeflag = 0;
1901 } 2086 }
1902 else if (strncmp (p, "intel", 5) == 0) 2087 else if (strncmp (p, "intel", 5) == 0)
@@ -1962,7 +2147,7 @@ print_insn (pc, info) @@ -1962,7 +2147,7 @@ print_insn (pc, info)
1962 puts most long word instructions on a single line. */ 2147 puts most long word instructions on a single line. */
1963 info->bytes_per_line = 7; 2148 info->bytes_per_line = 7;
1964 2149
1965 - info->private_data = (PTR) &priv; 2150 + info->private_data = &priv;
1966 priv.max_fetched = priv.the_buffer; 2151 priv.max_fetched = priv.the_buffer;
1967 priv.insn_start = pc; 2152 priv.insn_start = pc;
1968 2153
@@ -2012,13 +2197,14 @@ print_insn (pc, info) @@ -2012,13 +2197,14 @@ print_insn (pc, info)
2012 FETCH_DATA (info, codep + 1); 2197 FETCH_DATA (info, codep + 1);
2013 two_source_ops = (*codep == 0x62) || (*codep == 0xc8); 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 const char *name; 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 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag); 2208 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2023 if (name == NULL) 2209 if (name == NULL)
2024 name = INTERNAL_DISASSEMBLER_ERROR; 2210 name = INTERNAL_DISASSEMBLER_ERROR;
@@ -2032,12 +2218,14 @@ print_insn (pc, info) @@ -2032,12 +2218,14 @@ print_insn (pc, info)
2032 dp = &dis386_twobyte[*++codep]; 2218 dp = &dis386_twobyte[*++codep];
2033 need_modrm = twobyte_has_modrm[*codep]; 2219 need_modrm = twobyte_has_modrm[*codep];
2034 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep]; 2220 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
  2221 + uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
2035 } 2222 }
2036 else 2223 else
2037 { 2224 {
2038 dp = &dis386[*codep]; 2225 dp = &dis386[*codep];
2039 need_modrm = onebyte_has_modrm[*codep]; 2226 need_modrm = onebyte_has_modrm[*codep];
2040 uses_SSE_prefix = 0; 2227 uses_SSE_prefix = 0;
  2228 + uses_LOCK_prefix = 0;
2041 } 2229 }
2042 codep++; 2230 codep++;
2043 2231
@@ -2051,7 +2239,7 @@ print_insn (pc, info) @@ -2051,7 +2239,7 @@ print_insn (pc, info)
2051 oappend ("repnz "); 2239 oappend ("repnz ");
2052 used_prefixes |= PREFIX_REPNZ; 2240 used_prefixes |= PREFIX_REPNZ;
2053 } 2241 }
2054 - if (prefixes & PREFIX_LOCK) 2242 + if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
2055 { 2243 {
2056 oappend ("lock "); 2244 oappend ("lock ");
2057 used_prefixes |= PREFIX_LOCK; 2245 used_prefixes |= PREFIX_LOCK;
@@ -2062,7 +2250,7 @@ print_insn (pc, info) @@ -2062,7 +2250,7 @@ print_insn (pc, info)
2062 sizeflag ^= AFLAG; 2250 sizeflag ^= AFLAG;
2063 if (dp->bytemode3 != loop_jcxz_mode || intel_syntax) 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 oappend ("addr32 "); 2254 oappend ("addr32 ");
2067 else 2255 else
2068 oappend ("addr16 "); 2256 oappend ("addr16 ");
@@ -2085,7 +2273,15 @@ print_insn (pc, info) @@ -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 FETCH_DATA (info, codep + 1); 2286 FETCH_DATA (info, codep + 1);
2091 mod = (*codep >> 6) & 3; 2287 mod = (*codep >> 6) & 3;
@@ -2129,7 +2325,8 @@ print_insn (pc, info) @@ -2129,7 +2325,8 @@ print_insn (pc, info)
2129 break; 2325 break;
2130 2326
2131 case X86_64_SPECIAL: 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 break; 2330 break;
2134 2331
2135 default: 2332 default:
@@ -2251,14 +2448,14 @@ static const char *float_mem[] = { @@ -2251,14 +2448,14 @@ static const char *float_mem[] = {
2251 "fsubr{s||s|}", 2448 "fsubr{s||s|}",
2252 "fdiv{s||s|}", 2449 "fdiv{s||s|}",
2253 "fdivr{s||s|}", 2450 "fdivr{s||s|}",
2254 - /* d9 */ 2451 + /* d9 */
2255 "fld{s||s|}", 2452 "fld{s||s|}",
2256 "(bad)", 2453 "(bad)",
2257 "fst{s||s|}", 2454 "fst{s||s|}",
2258 "fstp{s||s|}", 2455 "fstp{s||s|}",
2259 - "fldenv", 2456 + "fldenvIC",
2260 "fldcw", 2457 "fldcw",
2261 - "fNstenv", 2458 + "fNstenvIC",
2262 "fNstcw", 2459 "fNstcw",
2263 /* da */ 2460 /* da */
2264 "fiadd{l||l|}", 2461 "fiadd{l||l|}",
@@ -2271,7 +2468,7 @@ static const char *float_mem[] = { @@ -2271,7 +2468,7 @@ static const char *float_mem[] = {
2271 "fidivr{l||l|}", 2468 "fidivr{l||l|}",
2272 /* db */ 2469 /* db */
2273 "fild{l||l|}", 2470 "fild{l||l|}",
2274 - "(bad)", 2471 + "fisttp{l||l|}",
2275 "fist{l||l|}", 2472 "fist{l||l|}",
2276 "fistp{l||l|}", 2473 "fistp{l||l|}",
2277 "(bad)", 2474 "(bad)",
@@ -2289,12 +2486,12 @@ static const char *float_mem[] = { @@ -2289,12 +2486,12 @@ static const char *float_mem[] = {
2289 "fdivr{l||l|}", 2486 "fdivr{l||l|}",
2290 /* dd */ 2487 /* dd */
2291 "fld{l||l|}", 2488 "fld{l||l|}",
2292 - "(bad)", 2489 + "fisttp{ll||ll|}",
2293 "fst{l||l|}", 2490 "fst{l||l|}",
2294 "fstp{l||l|}", 2491 "fstp{l||l|}",
2295 - "frstor", 2492 + "frstorIC",
2296 "(bad)", 2493 "(bad)",
2297 - "fNsave", 2494 + "fNsaveIC",
2298 "fNstsw", 2495 "fNstsw",
2299 /* de */ 2496 /* de */
2300 "fiadd", 2497 "fiadd",
@@ -2307,13 +2504,88 @@ static const char *float_mem[] = { @@ -2307,13 +2504,88 @@ static const char *float_mem[] = {
2307 "fidivr", 2504 "fidivr",
2308 /* df */ 2505 /* df */
2309 "fild", 2506 "fild",
2310 - "(bad)", 2507 + "fisttp",
2311 "fist", 2508 "fist",
2312 "fistp", 2509 "fistp",
2313 "fbld", 2510 "fbld",
2314 "fild{ll||ll|}", 2511 "fild{ll||ll|}",
2315 "fbstp", 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 #define ST OP_ST, 0 2591 #define ST OP_ST, 0
@@ -2483,8 +2755,7 @@ static const char *fgrps[][8] = { @@ -2483,8 +2755,7 @@ static const char *fgrps[][8] = {
2483 }; 2755 };
2484 2756
2485 static void 2757 static void
2486 -dofloat (sizeflag)  
2487 - int sizeflag; 2758 +dofloat (int sizeflag)
2488 { 2759 {
2489 const struct dis386 *dp; 2760 const struct dis386 *dp;
2490 unsigned char floatop; 2761 unsigned char floatop;
@@ -2493,14 +2764,12 @@ dofloat (sizeflag) @@ -2493,14 +2764,12 @@ dofloat (sizeflag)
2493 2764
2494 if (mod != 3) 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 obufp = op1out; 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 return; 2773 return;
2505 } 2774 }
2506 /* Skip mod/rm byte. */ 2775 /* Skip mod/rm byte. */
@@ -2521,26 +2790,25 @@ dofloat (sizeflag) @@ -2521,26 +2790,25 @@ dofloat (sizeflag)
2521 putop (dp->name, sizeflag); 2790 putop (dp->name, sizeflag);
2522 2791
2523 obufp = op1out; 2792 obufp = op1out;
  2793 + op_ad = 2;
2524 if (dp->op1) 2794 if (dp->op1)
2525 (*dp->op1) (dp->bytemode1, sizeflag); 2795 (*dp->op1) (dp->bytemode1, sizeflag);
  2796 +
2526 obufp = op2out; 2797 obufp = op2out;
  2798 + op_ad = 1;
2527 if (dp->op2) 2799 if (dp->op2)
2528 (*dp->op2) (dp->bytemode2, sizeflag); 2800 (*dp->op2) (dp->bytemode2, sizeflag);
2529 } 2801 }
2530 } 2802 }
2531 2803
2532 static void 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 static void 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 snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", rm); 2813 snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", rm);
2546 oappend (scratchbuf + intel_syntax); 2814 oappend (scratchbuf + intel_syntax);
@@ -2548,12 +2816,10 @@ OP_STi (bytemode, sizeflag) @@ -2548,12 +2816,10 @@ OP_STi (bytemode, sizeflag)
2548 2816
2549 /* Capital letters in template are macros. */ 2817 /* Capital letters in template are macros. */
2550 static int 2818 static int
2551 -putop (template, sizeflag)  
2552 - const char *template;  
2553 - int sizeflag; 2819 +putop (const char *template, int sizeflag)
2554 { 2820 {
2555 const char *p; 2821 const char *p;
2556 - int alt; 2822 + int alt = 0;
2557 2823
2558 for (p = template; *p; p++) 2824 for (p = template; *p; p++)
2559 { 2825 {
@@ -2566,7 +2832,7 @@ putop (template, sizeflag) @@ -2566,7 +2832,7 @@ putop (template, sizeflag)
2566 alt = 0; 2832 alt = 0;
2567 if (intel_syntax) 2833 if (intel_syntax)
2568 alt += 1; 2834 alt += 1;
2569 - if (mode_64bit) 2835 + if (address_mode == mode_64bit)
2570 alt += 2; 2836 alt += 2;
2571 while (alt != 0) 2837 while (alt != 0)
2572 { 2838 {
@@ -2584,7 +2850,10 @@ putop (template, sizeflag) @@ -2584,7 +2850,10 @@ putop (template, sizeflag)
2584 } 2850 }
2585 alt--; 2851 alt--;
2586 } 2852 }
2587 - break; 2853 + /* Fall through. */
  2854 + case 'I':
  2855 + alt = 1;
  2856 + continue;
2588 case '|': 2857 case '|':
2589 while (*++p != '}') 2858 while (*++p != '}')
2590 { 2859 {
@@ -2595,19 +2864,31 @@ putop (template, sizeflag) @@ -2595,19 +2864,31 @@ putop (template, sizeflag)
2595 case '}': 2864 case '}':
2596 break; 2865 break;
2597 case 'A': 2866 case 'A':
2598 - if (intel_syntax)  
2599 - break; 2867 + if (intel_syntax)
  2868 + break;
2600 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 2869 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2601 *obufp++ = 'b'; 2870 *obufp++ = 'b';
2602 break; 2871 break;
2603 case 'B': 2872 case 'B':
2604 - if (intel_syntax)  
2605 - break; 2873 + if (intel_syntax)
  2874 + break;
2606 if (sizeflag & SUFFIX_ALWAYS) 2875 if (sizeflag & SUFFIX_ALWAYS)
2607 *obufp++ = 'b'; 2876 *obufp++ = 'b';
2608 break; 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 case 'E': /* For jcxz/jecxz */ 2890 case 'E': /* For jcxz/jecxz */
2610 - if (mode_64bit) 2891 + if (address_mode == mode_64bit)
2611 { 2892 {
2612 if (sizeflag & AFLAG) 2893 if (sizeflag & AFLAG)
2613 *obufp++ = 'r'; 2894 *obufp++ = 'r';
@@ -2620,20 +2901,20 @@ putop (template, sizeflag) @@ -2620,20 +2901,20 @@ putop (template, sizeflag)
2620 used_prefixes |= (prefixes & PREFIX_ADDR); 2901 used_prefixes |= (prefixes & PREFIX_ADDR);
2621 break; 2902 break;
2622 case 'F': 2903 case 'F':
2623 - if (intel_syntax)  
2624 - break; 2904 + if (intel_syntax)
  2905 + break;
2625 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS)) 2906 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
2626 { 2907 {
2627 if (sizeflag & AFLAG) 2908 if (sizeflag & AFLAG)
2628 - *obufp++ = mode_64bit ? 'q' : 'l'; 2909 + *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
2629 else 2910 else
2630 - *obufp++ = mode_64bit ? 'l' : 'w'; 2911 + *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
2631 used_prefixes |= (prefixes & PREFIX_ADDR); 2912 used_prefixes |= (prefixes & PREFIX_ADDR);
2632 } 2913 }
2633 break; 2914 break;
2634 case 'H': 2915 case 'H':
2635 - if (intel_syntax)  
2636 - break; 2916 + if (intel_syntax)
  2917 + break;
2637 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS 2918 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
2638 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS) 2919 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
2639 { 2920 {
@@ -2646,9 +2927,23 @@ putop (template, sizeflag) @@ -2646,9 +2927,23 @@ putop (template, sizeflag)
2646 *obufp++ = 'n'; 2927 *obufp++ = 'n';
2647 } 2928 }
2648 break; 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 case 'L': 2944 case 'L':
2650 - if (intel_syntax)  
2651 - break; 2945 + if (intel_syntax)
  2946 + break;
2652 if (sizeflag & SUFFIX_ALWAYS) 2947 if (sizeflag & SUFFIX_ALWAYS)
2653 *obufp++ = 'l'; 2948 *obufp++ = 'l';
2654 break; 2949 break;
@@ -2666,17 +2961,17 @@ putop (template, sizeflag) @@ -2666,17 +2961,17 @@ putop (template, sizeflag)
2666 *obufp++ = 'd'; 2961 *obufp++ = 'd';
2667 break; 2962 break;
2668 case 'T': 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 *obufp++ = 'q'; 2968 *obufp++ = 'q';
2674 break; 2969 break;
2675 } 2970 }
2676 /* Fall through. */ 2971 /* Fall through. */
2677 case 'P': 2972 case 'P':
2678 - if (intel_syntax)  
2679 - break; 2973 + if (intel_syntax)
  2974 + break;
2680 if ((prefixes & PREFIX_DATA) 2975 if ((prefixes & PREFIX_DATA)
2681 || (rex & REX_MODE64) 2976 || (rex & REX_MODE64)
2682 || (sizeflag & SUFFIX_ALWAYS)) 2977 || (sizeflag & SUFFIX_ALWAYS))
@@ -2690,22 +2985,23 @@ putop (template, sizeflag) @@ -2690,22 +2985,23 @@ putop (template, sizeflag)
2690 *obufp++ = 'l'; 2985 *obufp++ = 'l';
2691 else 2986 else
2692 *obufp++ = 'w'; 2987 *obufp++ = 'w';
2693 - used_prefixes |= (prefixes & PREFIX_DATA);  
2694 } 2988 }
  2989 + used_prefixes |= (prefixes & PREFIX_DATA);
2695 } 2990 }
2696 break; 2991 break;
2697 case 'U': 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 break; 2999 break;
2704 } 3000 }
2705 /* Fall through. */ 3001 /* Fall through. */
2706 case 'Q': 3002 case 'Q':
2707 - if (intel_syntax)  
2708 - break; 3003 + if (intel_syntax && !alt)
  3004 + break;
2709 USED_REX (REX_MODE64); 3005 USED_REX (REX_MODE64);
2710 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS)) 3006 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2711 { 3007 {
@@ -2714,16 +3010,16 @@ putop (template, sizeflag) @@ -2714,16 +3010,16 @@ putop (template, sizeflag)
2714 else 3010 else
2715 { 3011 {
2716 if (sizeflag & DFLAG) 3012 if (sizeflag & DFLAG)
2717 - *obufp++ = 'l'; 3013 + *obufp++ = intel_syntax ? 'd' : 'l';
2718 else 3014 else
2719 *obufp++ = 'w'; 3015 *obufp++ = 'w';
2720 - used_prefixes |= (prefixes & PREFIX_DATA);  
2721 } 3016 }
  3017 + used_prefixes |= (prefixes & PREFIX_DATA);
2722 } 3018 }
2723 break; 3019 break;
2724 case 'R': 3020 case 'R':
2725 USED_REX (REX_MODE64); 3021 USED_REX (REX_MODE64);
2726 - if (intel_syntax) 3022 + if (intel_syntax)
2727 { 3023 {
2728 if (rex & REX_MODE64) 3024 if (rex & REX_MODE64)
2729 { 3025 {
@@ -2753,9 +3049,19 @@ putop (template, sizeflag) @@ -2753,9 +3049,19 @@ putop (template, sizeflag)
2753 if (!(rex & REX_MODE64)) 3049 if (!(rex & REX_MODE64))
2754 used_prefixes |= (prefixes & PREFIX_DATA); 3050 used_prefixes |= (prefixes & PREFIX_DATA);
2755 break; 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 case 'S': 3062 case 'S':
2757 - if (intel_syntax)  
2758 - break; 3063 + if (intel_syntax)
  3064 + break;
2759 if (sizeflag & SUFFIX_ALWAYS) 3065 if (sizeflag & SUFFIX_ALWAYS)
2760 { 3066 {
2761 if (rex & REX_MODE64) 3067 if (rex & REX_MODE64)
@@ -2775,11 +3081,11 @@ putop (template, sizeflag) @@ -2775,11 +3081,11 @@ putop (template, sizeflag)
2775 *obufp++ = 'd'; 3081 *obufp++ = 'd';
2776 else 3082 else
2777 *obufp++ = 's'; 3083 *obufp++ = 's';
2778 - used_prefixes |= (prefixes & PREFIX_DATA); 3084 + used_prefixes |= (prefixes & PREFIX_DATA);
2779 break; 3085 break;
2780 case 'Y': 3086 case 'Y':
2781 - if (intel_syntax)  
2782 - break; 3087 + if (intel_syntax)
  3088 + break;
2783 if (rex & REX_MODE64) 3089 if (rex & REX_MODE64)
2784 { 3090 {
2785 USED_REX (REX_MODE64); 3091 USED_REX (REX_MODE64);
@@ -2796,7 +3102,7 @@ putop (template, sizeflag) @@ -2796,7 +3102,7 @@ putop (template, sizeflag)
2796 *obufp++ = 'w'; 3102 *obufp++ = 'w';
2797 else 3103 else
2798 *obufp++ = 'b'; 3104 *obufp++ = 'b';
2799 - if (intel_syntax) 3105 + if (intel_syntax)
2800 { 3106 {
2801 if (rex) 3107 if (rex)
2802 { 3108 {
@@ -2817,21 +3123,21 @@ putop (template, sizeflag) @@ -2817,21 +3123,21 @@ putop (template, sizeflag)
2817 used_prefixes |= (prefixes & PREFIX_DATA); 3123 used_prefixes |= (prefixes & PREFIX_DATA);
2818 break; 3124 break;
2819 } 3125 }
  3126 + alt = 0;
2820 } 3127 }
2821 *obufp = 0; 3128 *obufp = 0;
2822 return 0; 3129 return 0;
2823 } 3130 }
2824 3131
2825 static void 3132 static void
2826 -oappend (s)  
2827 - const char *s; 3133 +oappend (const char *s)
2828 { 3134 {
2829 strcpy (obufp, s); 3135 strcpy (obufp, s);
2830 obufp += strlen (s); 3136 obufp += strlen (s);
2831 } 3137 }
2832 3138
2833 static void 3139 static void
2834 -append_seg () 3140 +append_seg (void)
2835 { 3141 {
2836 if (prefixes & PREFIX_CS) 3142 if (prefixes & PREFIX_CS)
2837 { 3143 {
@@ -2866,9 +3172,7 @@ append_seg () @@ -2866,9 +3172,7 @@ append_seg ()
2866 } 3172 }
2867 3173
2868 static void 3174 static void
2869 -OP_indirE (bytemode, sizeflag)  
2870 - int bytemode;  
2871 - int sizeflag; 3175 +OP_indirE (int bytemode, int sizeflag)
2872 { 3176 {
2873 if (!intel_syntax) 3177 if (!intel_syntax)
2874 oappend ("*"); 3178 oappend ("*");
@@ -2878,7 +3182,7 @@ OP_indirE (bytemode, sizeflag) @@ -2878,7 +3182,7 @@ OP_indirE (bytemode, sizeflag)
2878 static void 3182 static void
2879 print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp) 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 if (hex) 3187 if (hex)
2884 { 3188 {
@@ -2933,9 +3237,68 @@ print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp) @@ -2933,9 +3237,68 @@ print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp)
2933 } 3237 }
2934 3238
2935 static void 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 bfd_vma disp; 3303 bfd_vma disp;
2941 int add = 0; 3304 int add = 0;
@@ -2969,26 +3332,33 @@ OP_E (bytemode, sizeflag) @@ -2969,26 +3332,33 @@ OP_E (bytemode, sizeflag)
2969 oappend (names64[rm + add]); 3332 oappend (names64[rm + add]);
2970 break; 3333 break;
2971 case m_mode: 3334 case m_mode:
2972 - if (mode_64bit) 3335 + if (address_mode == mode_64bit)
2973 oappend (names64[rm + add]); 3336 oappend (names64[rm + add]);
2974 else 3337 else
2975 oappend (names32[rm + add]); 3338 oappend (names32[rm + add]);
2976 break; 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 case v_mode: 3349 case v_mode:
  3350 + case dq_mode:
  3351 + case dqw_mode:
2978 USED_REX (REX_MODE64); 3352 USED_REX (REX_MODE64);
2979 if (rex & REX_MODE64) 3353 if (rex & REX_MODE64)
2980 oappend (names64[rm + add]); 3354 oappend (names64[rm + add]);
2981 - else if (sizeflag & DFLAG) 3355 + else if ((sizeflag & DFLAG) || bytemode != v_mode)
2982 oappend (names32[rm + add]); 3356 oappend (names32[rm + add]);
2983 else 3357 else
2984 oappend (names16[rm + add]); 3358 oappend (names16[rm + add]);
2985 used_prefixes |= (prefixes & PREFIX_DATA); 3359 used_prefixes |= (prefixes & PREFIX_DATA);
2986 break; 3360 break;
2987 case 0: 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 break; 3362 break;
2993 default: 3363 default:
2994 oappend (INTERNAL_DISASSEMBLER_ERROR); 3364 oappend (INTERNAL_DISASSEMBLER_ERROR);
@@ -2998,9 +3368,11 @@ OP_E (bytemode, sizeflag) @@ -2998,9 +3368,11 @@ OP_E (bytemode, sizeflag)
2998 } 3368 }
2999 3369
3000 disp = 0; 3370 disp = 0;
  3371 + if (intel_syntax)
  3372 + intel_operand_size (bytemode, sizeflag);
3001 append_seg (); 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 int havesib; 3377 int havesib;
3006 int havebase; 3378 int havebase;
@@ -3016,17 +3388,17 @@ OP_E (bytemode, sizeflag) @@ -3016,17 +3388,17 @@ OP_E (bytemode, sizeflag)
3016 { 3388 {
3017 havesib = 1; 3389 havesib = 1;
3018 FETCH_DATA (the_info, codep + 1); 3390 FETCH_DATA (the_info, codep + 1);
3019 - scale = (*codep >> 6) & 3;  
3020 index = (*codep >> 3) & 7; 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 base = *codep & 7; 3395 base = *codep & 7;
3022 USED_REX (REX_EXTY); 3396 USED_REX (REX_EXTY);
3023 - USED_REX (REX_EXTZ);  
3024 if (rex & REX_EXTY) 3397 if (rex & REX_EXTY)
3025 index += 8; 3398 index += 8;
3026 - if (rex & REX_EXTZ)  
3027 - base += 8;  
3028 codep++; 3399 codep++;
3029 } 3400 }
  3401 + base += add;
3030 3402
3031 switch (mod) 3403 switch (mod)
3032 { 3404 {
@@ -3034,7 +3406,7 @@ OP_E (bytemode, sizeflag) @@ -3034,7 +3406,7 @@ OP_E (bytemode, sizeflag)
3034 if ((base & 7) == 5) 3406 if ((base & 7) == 5)
3035 { 3407 {
3036 havebase = 0; 3408 havebase = 0;
3037 - if (mode_64bit && !havesib && (sizeflag & AFLAG)) 3409 + if (address_mode == mode_64bit && !havesib)
3038 riprel = 1; 3410 riprel = 1;
3039 disp = get32s (); 3411 disp = get32s ();
3040 } 3412 }
@@ -3051,116 +3423,72 @@ OP_E (bytemode, sizeflag) @@ -3051,116 +3423,72 @@ OP_E (bytemode, sizeflag)
3051 } 3423 }
3052 3424
3053 if (!intel_syntax) 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 if (riprel) 3430 if (riprel)
3059 { 3431 {
3060 set_op (disp, 1); 3432 set_op (disp, 1);
3061 oappend ("(%rip)"); 3433 oappend ("(%rip)");
3062 } 3434 }
3063 - } 3435 + }
3064 3436
3065 if (havebase || (havesib && (index != 4 || scale != 0))) 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 *obufp++ = open_char; 3439 *obufp++ = open_char;
3097 if (intel_syntax && riprel) 3440 if (intel_syntax && riprel)
3098 oappend ("rip + "); 3441 oappend ("rip + ");
3099 - *obufp = '\0';  
3100 - USED_REX (REX_EXTZ);  
3101 - if (!havesib && (rex & REX_EXTZ))  
3102 - base += 8; 3442 + *obufp = '\0';
3103 if (havebase) 3443 if (havebase)
3104 - oappend (mode_64bit && (sizeflag & AFLAG) 3444 + oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3105 ? names64[base] : names32[base]); 3445 ? names64[base] : names32[base]);
3106 if (havesib) 3446 if (havesib)
3107 { 3447 {
3108 if (index != 4) 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 oappend (scratchbuf); 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 *obufp++ = close_char; 3485 *obufp++ = close_char;
3158 - *obufp = '\0'; 3486 + *obufp = '\0';
3159 } 3487 }
3160 else if (intel_syntax) 3488 else if (intel_syntax)
3161 - {  
3162 - if (mod != 0 || (base & 7) == 5)  
3163 - { 3489 + {
  3490 + if (mod != 0 || (base & 7) == 5)
  3491 + {
3164 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 3492 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3165 | PREFIX_ES | PREFIX_FS | PREFIX_GS)) 3493 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3166 ; 3494 ;
@@ -3169,17 +3497,17 @@ OP_E (bytemode, sizeflag) @@ -3169,17 +3497,17 @@ OP_E (bytemode, sizeflag)
3169 oappend (names_seg[ds_reg - es_reg]); 3497 oappend (names_seg[ds_reg - es_reg]);
3170 oappend (":"); 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 else 3505 else
3178 { /* 16 bit address mode */ 3506 { /* 16 bit address mode */
3179 switch (mod) 3507 switch (mod)
3180 { 3508 {
3181 case 0: 3509 case 0:
3182 - if ((rm & 7) == 6) 3510 + if (rm == 6)
3183 { 3511 {
3184 disp = get16 (); 3512 disp = get16 ();
3185 if ((disp & 0x8000) != 0) 3513 if ((disp & 0x8000) != 0)
@@ -3200,27 +3528,58 @@ OP_E (bytemode, sizeflag) @@ -3200,27 +3528,58 @@ OP_E (bytemode, sizeflag)
3200 } 3528 }
3201 3529
3202 if (!intel_syntax) 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 *obufp++ = open_char; 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 static void 3581 static void
3221 -OP_G (bytemode, sizeflag)  
3222 - int bytemode;  
3223 - int sizeflag; 3582 +OP_G (int bytemode, int sizeflag)
3224 { 3583 {
3225 int add = 0; 3584 int add = 0;
3226 USED_REX (REX_EXTX); 3585 USED_REX (REX_EXTX);
@@ -3245,15 +3604,23 @@ OP_G (bytemode, sizeflag) @@ -3245,15 +3604,23 @@ OP_G (bytemode, sizeflag)
3245 oappend (names64[reg + add]); 3604 oappend (names64[reg + add]);
3246 break; 3605 break;
3247 case v_mode: 3606 case v_mode:
  3607 + case dq_mode:
  3608 + case dqw_mode:
3248 USED_REX (REX_MODE64); 3609 USED_REX (REX_MODE64);
3249 if (rex & REX_MODE64) 3610 if (rex & REX_MODE64)
3250 oappend (names64[reg + add]); 3611 oappend (names64[reg + add]);
3251 - else if (sizeflag & DFLAG) 3612 + else if ((sizeflag & DFLAG) || bytemode != v_mode)
3252 oappend (names32[reg + add]); 3613 oappend (names32[reg + add]);
3253 else 3614 else
3254 oappend (names16[reg + add]); 3615 oappend (names16[reg + add]);
3255 used_prefixes |= (prefixes & PREFIX_DATA); 3616 used_prefixes |= (prefixes & PREFIX_DATA);
3256 break; 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 default: 3624 default:
3258 oappend (INTERNAL_DISASSEMBLER_ERROR); 3625 oappend (INTERNAL_DISASSEMBLER_ERROR);
3259 break; 3626 break;
@@ -3261,7 +3628,7 @@ OP_G (bytemode, sizeflag) @@ -3261,7 +3628,7 @@ OP_G (bytemode, sizeflag)
3261 } 3628 }
3262 3629
3263 static bfd_vma 3630 static bfd_vma
3264 -get64 () 3631 +get64 (void)
3265 { 3632 {
3266 bfd_vma x; 3633 bfd_vma x;
3267 #ifdef BFD64 3634 #ifdef BFD64
@@ -3286,7 +3653,7 @@ get64 () @@ -3286,7 +3653,7 @@ get64 ()
3286 } 3653 }
3287 3654
3288 static bfd_signed_vma 3655 static bfd_signed_vma
3289 -get32 () 3656 +get32 (void)
3290 { 3657 {
3291 bfd_signed_vma x = 0; 3658 bfd_signed_vma x = 0;
3292 3659
@@ -3299,7 +3666,7 @@ get32 () @@ -3299,7 +3666,7 @@ get32 ()
3299 } 3666 }
3300 3667
3301 static bfd_signed_vma 3668 static bfd_signed_vma
3302 -get32s () 3669 +get32s (void)
3303 { 3670 {
3304 bfd_signed_vma x = 0; 3671 bfd_signed_vma x = 0;
3305 3672
@@ -3315,7 +3682,7 @@ get32s () @@ -3315,7 +3682,7 @@ get32s ()
3315 } 3682 }
3316 3683
3317 static int 3684 static int
3318 -get16 () 3685 +get16 (void)
3319 { 3686 {
3320 int x = 0; 3687 int x = 0;
3321 3688
@@ -3326,12 +3693,10 @@ get16 () @@ -3326,12 +3693,10 @@ get16 ()
3326 } 3693 }
3327 3694
3328 static void 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 op_index[op_ad] = op_ad; 3698 op_index[op_ad] = op_ad;
3334 - if (mode_64bit) 3699 + if (address_mode == mode_64bit)
3335 { 3700 {
3336 op_address[op_ad] = op; 3701 op_address[op_ad] = op;
3337 op_riprel[op_ad] = riprel; 3702 op_riprel[op_ad] = riprel;
@@ -3345,9 +3710,7 @@ set_op (op, riprel) @@ -3345,9 +3710,7 @@ set_op (op, riprel)
3345 } 3710 }
3346 3711
3347 static void 3712 static void
3348 -OP_REG (code, sizeflag)  
3349 - int code;  
3350 - int sizeflag; 3713 +OP_REG (int code, int sizeflag)
3351 { 3714 {
3352 const char *s; 3715 const char *s;
3353 int add = 0; 3716 int add = 0;
@@ -3359,9 +3722,9 @@ OP_REG (code, sizeflag) @@ -3359,9 +3722,9 @@ OP_REG (code, sizeflag)
3359 { 3722 {
3360 case indir_dx_reg: 3723 case indir_dx_reg:
3361 if (intel_syntax) 3724 if (intel_syntax)
3362 - s = "[dx]"; 3725 + s = "[dx]";
3363 else 3726 else
3364 - s = "(%dx)"; 3727 + s = "(%dx)";
3365 break; 3728 break;
3366 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 3729 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3367 case sp_reg: case bp_reg: case si_reg: case di_reg: 3730 case sp_reg: case bp_reg: case si_reg: case di_reg:
@@ -3381,7 +3744,7 @@ OP_REG (code, sizeflag) @@ -3381,7 +3744,7 @@ OP_REG (code, sizeflag)
3381 break; 3744 break;
3382 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg: 3745 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
3383 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg: 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 s = names64[code - rAX_reg + add]; 3749 s = names64[code - rAX_reg + add];
3387 break; 3750 break;
@@ -3407,9 +3770,7 @@ OP_REG (code, sizeflag) @@ -3407,9 +3770,7 @@ OP_REG (code, sizeflag)
3407 } 3770 }
3408 3771
3409 static void 3772 static void
3410 -OP_IMREG (code, sizeflag)  
3411 - int code;  
3412 - int sizeflag; 3773 +OP_IMREG (int code, int sizeflag)
3413 { 3774 {
3414 const char *s; 3775 const char *s;
3415 3776
@@ -3417,9 +3778,9 @@ OP_IMREG (code, sizeflag) @@ -3417,9 +3778,9 @@ OP_IMREG (code, sizeflag)
3417 { 3778 {
3418 case indir_dx_reg: 3779 case indir_dx_reg:
3419 if (intel_syntax) 3780 if (intel_syntax)
3420 - s = "[dx]"; 3781 + s = "[dx]";
3421 else 3782 else
3422 - s = "(%dx)"; 3783 + s = "(%dx)";
3423 break; 3784 break;
3424 case ax_reg: case cx_reg: case dx_reg: case bx_reg: 3785 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3425 case sp_reg: case bp_reg: case si_reg: case di_reg: 3786 case sp_reg: case bp_reg: case si_reg: case di_reg:
@@ -3456,9 +3817,7 @@ OP_IMREG (code, sizeflag) @@ -3456,9 +3817,7 @@ OP_IMREG (code, sizeflag)
3456 } 3817 }
3457 3818
3458 static void 3819 static void
3459 -OP_I (bytemode, sizeflag)  
3460 - int bytemode;  
3461 - int sizeflag; 3820 +OP_I (int bytemode, int sizeflag)
3462 { 3821 {
3463 bfd_signed_vma op; 3822 bfd_signed_vma op;
3464 bfd_signed_vma mask = -1; 3823 bfd_signed_vma mask = -1;
@@ -3471,7 +3830,7 @@ OP_I (bytemode, sizeflag) @@ -3471,7 +3830,7 @@ OP_I (bytemode, sizeflag)
3471 mask = 0xff; 3830 mask = 0xff;
3472 break; 3831 break;
3473 case q_mode: 3832 case q_mode:
3474 - if (mode_64bit) 3833 + if (address_mode == mode_64bit)
3475 { 3834 {
3476 op = get32s (); 3835 op = get32s ();
3477 break; 3836 break;
@@ -3497,6 +3856,10 @@ OP_I (bytemode, sizeflag) @@ -3497,6 +3856,10 @@ OP_I (bytemode, sizeflag)
3497 mask = 0xfffff; 3856 mask = 0xfffff;
3498 op = get16 (); 3857 op = get16 ();
3499 break; 3858 break;
  3859 + case const_1_mode:
  3860 + if (intel_syntax)
  3861 + oappend ("1");
  3862 + return;
3500 default: 3863 default:
3501 oappend (INTERNAL_DISASSEMBLER_ERROR); 3864 oappend (INTERNAL_DISASSEMBLER_ERROR);
3502 return; 3865 return;
@@ -3510,14 +3873,12 @@ OP_I (bytemode, sizeflag) @@ -3510,14 +3873,12 @@ OP_I (bytemode, sizeflag)
3510 } 3873 }
3511 3874
3512 static void 3875 static void
3513 -OP_I64 (bytemode, sizeflag)  
3514 - int bytemode;  
3515 - int sizeflag; 3876 +OP_I64 (int bytemode, int sizeflag)
3516 { 3877 {
3517 bfd_signed_vma op; 3878 bfd_signed_vma op;
3518 bfd_signed_vma mask = -1; 3879 bfd_signed_vma mask = -1;
3519 3880
3520 - if (!mode_64bit) 3881 + if (address_mode != mode_64bit)
3521 { 3882 {
3522 OP_I (bytemode, sizeflag); 3883 OP_I (bytemode, sizeflag);
3523 return; 3884 return;
@@ -3563,9 +3924,7 @@ OP_I64 (bytemode, sizeflag) @@ -3563,9 +3924,7 @@ OP_I64 (bytemode, sizeflag)
3563 } 3924 }
3564 3925
3565 static void 3926 static void
3566 -OP_sI (bytemode, sizeflag)  
3567 - int bytemode;  
3568 - int sizeflag; 3927 +OP_sI (int bytemode, int sizeflag)
3569 { 3928 {
3570 bfd_signed_vma op; 3929 bfd_signed_vma op;
3571 bfd_signed_vma mask = -1; 3930 bfd_signed_vma mask = -1;
@@ -3614,9 +3973,7 @@ OP_sI (bytemode, sizeflag) @@ -3614,9 +3973,7 @@ OP_sI (bytemode, sizeflag)
3614 } 3973 }
3615 3974
3616 static void 3975 static void
3617 -OP_J (bytemode, sizeflag)  
3618 - int bytemode;  
3619 - int sizeflag; 3976 +OP_J (int bytemode, int sizeflag)
3620 { 3977 {
3621 bfd_vma disp; 3978 bfd_vma disp;
3622 bfd_vma mask = -1; 3979 bfd_vma mask = -1;
@@ -3630,7 +3987,7 @@ OP_J (bytemode, sizeflag) @@ -3630,7 +3987,7 @@ OP_J (bytemode, sizeflag)
3630 disp -= 0x100; 3987 disp -= 0x100;
3631 break; 3988 break;
3632 case v_mode: 3989 case v_mode:
3633 - if (sizeflag & DFLAG) 3990 + if ((sizeflag & DFLAG) || (rex & REX_MODE64))
3634 disp = get32s (); 3991 disp = get32s ();
3635 else 3992 else
3636 { 3993 {
@@ -3652,17 +4009,13 @@ OP_J (bytemode, sizeflag) @@ -3652,17 +4009,13 @@ OP_J (bytemode, sizeflag)
3652 } 4009 }
3653 4010
3654 static void 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 oappend (names_seg[reg]); 4014 oappend (names_seg[reg]);
3660 } 4015 }
3661 4016
3662 static void 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 int seg, offset; 4020 int seg, offset;
3668 4021
@@ -3678,22 +4031,22 @@ OP_DIR (dummy, sizeflag) @@ -3678,22 +4031,22 @@ OP_DIR (dummy, sizeflag)
3678 } 4031 }
3679 used_prefixes |= (prefixes & PREFIX_DATA); 4032 used_prefixes |= (prefixes & PREFIX_DATA);
3680 if (intel_syntax) 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 else 4035 else
3683 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset); 4036 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset);
3684 oappend (scratchbuf); 4037 oappend (scratchbuf);
3685 } 4038 }
3686 4039
3687 static void 4040 static void
3688 -OP_OFF (bytemode, sizeflag)  
3689 - int bytemode;  
3690 - int sizeflag; 4041 +OP_OFF (int bytemode, int sizeflag)
3691 { 4042 {
3692 bfd_vma off; 4043 bfd_vma off;
3693 4044
  4045 + if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
  4046 + intel_operand_size (bytemode, sizeflag);
3694 append_seg (); 4047 append_seg ();
3695 4048
3696 - if ((sizeflag & AFLAG) || mode_64bit) 4049 + if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3697 off = get32 (); 4050 off = get32 ();
3698 else 4051 else
3699 off = get16 (); 4052 off = get16 ();
@@ -3701,7 +4054,7 @@ OP_OFF (bytemode, sizeflag) @@ -3701,7 +4054,7 @@ OP_OFF (bytemode, sizeflag)
3701 if (intel_syntax) 4054 if (intel_syntax)
3702 { 4055 {
3703 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 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 oappend (names_seg[ds_reg - es_reg]); 4059 oappend (names_seg[ds_reg - es_reg]);
3707 oappend (":"); 4060 oappend (":");
@@ -3712,18 +4065,18 @@ OP_OFF (bytemode, sizeflag) @@ -3712,18 +4065,18 @@ OP_OFF (bytemode, sizeflag)
3712 } 4065 }
3713 4066
3714 static void 4067 static void
3715 -OP_OFF64 (bytemode, sizeflag)  
3716 - int bytemode;  
3717 - int sizeflag; 4068 +OP_OFF64 (int bytemode, int sizeflag)
3718 { 4069 {
3719 bfd_vma off; 4070 bfd_vma off;
3720 4071
3721 - if (!mode_64bit) 4072 + if (address_mode != mode_64bit)
3722 { 4073 {
3723 OP_OFF (bytemode, sizeflag); 4074 OP_OFF (bytemode, sizeflag);
3724 return; 4075 return;
3725 } 4076 }
3726 4077
  4078 + if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
  4079 + intel_operand_size (bytemode, sizeflag);
3727 append_seg (); 4080 append_seg ();
3728 4081
3729 off = get64 (); 4082 off = get64 ();
@@ -3731,7 +4084,7 @@ OP_OFF64 (bytemode, sizeflag) @@ -3731,7 +4084,7 @@ OP_OFF64 (bytemode, sizeflag)
3731 if (intel_syntax) 4084 if (intel_syntax)
3732 { 4085 {
3733 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS 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 oappend (names_seg[ds_reg - es_reg]); 4089 oappend (names_seg[ds_reg - es_reg]);
3737 oappend (":"); 4090 oappend (":");
@@ -3742,49 +4095,45 @@ OP_OFF64 (bytemode, sizeflag) @@ -3742,49 +4095,45 @@ OP_OFF64 (bytemode, sizeflag)
3742 } 4095 }
3743 4096
3744 static void 4097 static void
3745 -ptr_reg (code, sizeflag)  
3746 - int code;  
3747 - int sizeflag; 4098 +ptr_reg (int code, int sizeflag)
3748 { 4099 {
3749 const char *s; 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 if (!(sizeflag & AFLAG)) 4106 if (!(sizeflag & AFLAG))
3759 - s = names32[code - eAX_reg]; 4107 + s = names32[code - eAX_reg];
3760 else 4108 else
3761 - s = names64[code - eAX_reg]; 4109 + s = names64[code - eAX_reg];
3762 } 4110 }
3763 else if (sizeflag & AFLAG) 4111 else if (sizeflag & AFLAG)
3764 s = names32[code - eAX_reg]; 4112 s = names32[code - eAX_reg];
3765 else 4113 else
3766 s = names16[code - eAX_reg]; 4114 s = names16[code - eAX_reg];
3767 oappend (s); 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 static void 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 oappend ("%es:" + intel_syntax); 4125 oappend ("%es:" + intel_syntax);
3780 ptr_reg (code, sizeflag); 4126 ptr_reg (code, sizeflag);
3781 } 4127 }
3782 4128
3783 static void 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 if ((prefixes 4137 if ((prefixes
3789 & (PREFIX_CS 4138 & (PREFIX_CS
3790 | PREFIX_DS 4139 | PREFIX_DS
@@ -3798,22 +4147,25 @@ OP_DSreg (code, sizeflag) @@ -3798,22 +4147,25 @@ OP_DSreg (code, sizeflag)
3798 } 4147 }
3799 4148
3800 static void 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 int add = 0; 4152 int add = 0;
3806 - USED_REX (REX_EXTX);  
3807 if (rex & REX_EXTX) 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 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", reg + add); 4163 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", reg + add);
3810 oappend (scratchbuf + intel_syntax); 4164 oappend (scratchbuf + intel_syntax);
3811 } 4165 }
3812 4166
3813 static void 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 int add = 0; 4170 int add = 0;
3819 USED_REX (REX_EXTX); 4171 USED_REX (REX_EXTX);
@@ -3827,18 +4179,14 @@ OP_D (dummy, sizeflag) @@ -3827,18 +4179,14 @@ OP_D (dummy, sizeflag)
3827 } 4179 }
3828 4180
3829 static void 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 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", reg); 4184 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", reg);
3835 oappend (scratchbuf + intel_syntax); 4185 oappend (scratchbuf + intel_syntax);
3836 } 4186 }
3837 4187
3838 static void 4188 static void
3839 -OP_Rd (bytemode, sizeflag)  
3840 - int bytemode;  
3841 - int sizeflag; 4189 +OP_Rd (int bytemode, int sizeflag)
3842 { 4190 {
3843 if (mod == 3) 4191 if (mod == 3)
3844 OP_E (bytemode, sizeflag); 4192 OP_E (bytemode, sizeflag);
@@ -3847,26 +4195,24 @@ OP_Rd (bytemode, sizeflag) @@ -3847,26 +4195,24 @@ OP_Rd (bytemode, sizeflag)
3847 } 4195 }
3848 4196
3849 static void 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 used_prefixes |= (prefixes & PREFIX_DATA); 4200 used_prefixes |= (prefixes & PREFIX_DATA);
3859 if (prefixes & PREFIX_DATA) 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 else 4209 else
3862 - snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", reg + add); 4210 + snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", reg);
3863 oappend (scratchbuf + intel_syntax); 4211 oappend (scratchbuf + intel_syntax);
3864 } 4212 }
3865 4213
3866 static void 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 int add = 0; 4217 int add = 0;
3872 USED_REX (REX_EXTX); 4218 USED_REX (REX_EXTX);
@@ -3877,39 +4223,54 @@ OP_XMM (bytemode, sizeflag) @@ -3877,39 +4223,54 @@ OP_XMM (bytemode, sizeflag)
3877 } 4223 }
3878 4224
3879 static void 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 if (mod != 3) 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 OP_E (bytemode, sizeflag); 4235 OP_E (bytemode, sizeflag);
3888 return; 4236 return;
3889 } 4237 }
3890 - USED_REX (REX_EXTZ);  
3891 - if (rex & REX_EXTZ)  
3892 - add = 8;  
3893 4238
3894 /* Skip mod/rm byte. */ 4239 /* Skip mod/rm byte. */
3895 MODRM_CHECK; 4240 MODRM_CHECK;
3896 codep++; 4241 codep++;
3897 used_prefixes |= (prefixes & PREFIX_DATA); 4242 used_prefixes |= (prefixes & PREFIX_DATA);
3898 if (prefixes & PREFIX_DATA) 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 else 4252 else
3901 - snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", rm + add); 4253 + snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", rm);
3902 oappend (scratchbuf + intel_syntax); 4254 oappend (scratchbuf + intel_syntax);
3903 } 4255 }
3904 4256
3905 static void 4257 static void
3906 -OP_EX (bytemode, sizeflag)  
3907 - int bytemode;  
3908 - int sizeflag; 4258 +OP_EX (int bytemode, int sizeflag)
3909 { 4259 {
3910 int add = 0; 4260 int add = 0;
3911 if (mod != 3) 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 OP_E (bytemode, sizeflag); 4274 OP_E (bytemode, sizeflag);
3914 return; 4275 return;
3915 } 4276 }
@@ -3925,9 +4286,7 @@ OP_EX (bytemode, sizeflag) @@ -3925,9 +4286,7 @@ OP_EX (bytemode, sizeflag)
3925 } 4286 }
3926 4287
3927 static void 4288 static void
3928 -OP_MS (bytemode, sizeflag)  
3929 - int bytemode;  
3930 - int sizeflag; 4289 +OP_MS (int bytemode, int sizeflag)
3931 { 4290 {
3932 if (mod == 3) 4291 if (mod == 3)
3933 OP_EM (bytemode, sizeflag); 4292 OP_EM (bytemode, sizeflag);
@@ -3936,9 +4295,7 @@ OP_MS (bytemode, sizeflag) @@ -3936,9 +4295,7 @@ OP_MS (bytemode, sizeflag)
3936 } 4295 }
3937 4296
3938 static void 4297 static void
3939 -OP_XS (bytemode, sizeflag)  
3940 - int bytemode;  
3941 - int sizeflag; 4298 +OP_XS (int bytemode, int sizeflag)
3942 { 4299 {
3943 if (mod == 3) 4300 if (mod == 3)
3944 OP_EX (bytemode, sizeflag); 4301 OP_EX (bytemode, sizeflag);
@@ -3946,6 +4303,55 @@ OP_XS (bytemode, sizeflag) @@ -3946,6 +4303,55 @@ OP_XS (bytemode, sizeflag)
3946 BadOp (); 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 static const char *Suffix3DNow[] = { 4355 static const char *Suffix3DNow[] = {
3950 /* 00 */ NULL, NULL, NULL, NULL, 4356 /* 00 */ NULL, NULL, NULL, NULL,
3951 /* 04 */ NULL, NULL, NULL, NULL, 4357 /* 04 */ NULL, NULL, NULL, NULL,
@@ -4014,9 +4420,7 @@ static const char *Suffix3DNow[] = { @@ -4014,9 +4420,7 @@ static const char *Suffix3DNow[] = {
4014 }; 4420 };
4015 4421
4016 static void 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 const char *mnemonic; 4425 const char *mnemonic;
4022 4426
@@ -4052,9 +4456,7 @@ static const char *simd_cmp_op[] = { @@ -4052,9 +4456,7 @@ static const char *simd_cmp_op[] = {
4052 }; 4456 };
4053 4457
4054 static void 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 unsigned int cmp_type; 4461 unsigned int cmp_type;
4060 4462
@@ -4094,9 +4496,7 @@ OP_SIMD_Suffix (bytemode, sizeflag) @@ -4094,9 +4496,7 @@ OP_SIMD_Suffix (bytemode, sizeflag)
4094 } 4496 }
4095 4497
4096 static void 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 /* Change movlps/movhps to movhlps/movlhps for 2 register operand 4501 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
4102 forms of these instructions. */ 4502 forms of these instructions. */
@@ -4112,9 +4512,334 @@ SIMD_Fixup (extrachar, sizeflag) @@ -4112,9 +4512,334 @@ SIMD_Fixup (extrachar, sizeflag)
4112 } 4512 }
4113 4513
4114 static void 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 BadOp (void) 4671 BadOp (void)
4116 { 4672 {
4117 /* Throw away prefixes and 1st. opcode byte. */ 4673 /* Throw away prefixes and 1st. opcode byte. */
4118 codep = insn_codep + 1; 4674 codep = insn_codep + 1;
4119 oappend ("(bad)"); 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 +}