1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library 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 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
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,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
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. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma
, disassemble_info
*);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma
);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma
);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma
get64 (void);
60 static bfd_signed_vma
get32 (void);
61 static bfd_signed_vma
get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma
, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (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_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_EX_VexImmW (int, int);
95 static void OP_XMM_Vex (int, int);
96 static void OP_XMM_VexW (int, int);
97 static void OP_REG_VexI4 (int, int);
98 static void PCLMUL_Fixup (int, int);
99 static void VEXI4_Fixup (int, int);
100 static void VZERO_Fixup (int, int);
101 static void VCMP_Fixup (int, int);
102 static void OP_0f07 (int, int);
103 static void OP_Monitor (int, int);
104 static void OP_Mwait (int, int);
105 static void NOP_Fixup1 (int, int);
106 static void NOP_Fixup2 (int, int);
107 static void OP_3DNowSuffix (int, int);
108 static void CMP_Fixup (int, int);
109 static void BadOp (void);
110 static void REP_Fixup (int, int);
111 static void CMPXCHG8B_Fixup (int, int);
112 static void XMM_Fixup (int, int);
113 static void CRC32_Fixup (int, int);
114 static void FXSAVE_Fixup (int, int);
115 static void OP_LWPCB_E (int, int);
116 static void OP_LWP_E (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte
*max_fetched
;
125 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
138 enum address_mode address_mode
;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* REX bits in original REX prefix ignored. */
148 static int rex_ignored
;
149 /* Mark parts used in the REX prefix. When we are testing for
150 empty prefix (for 8bit register REX extension), just mask it
151 out. Otherwise test for REX bit is excuse for existence of REX
152 only in case value is nonzero. */
153 #define USED_REX(value) \
158 rex_used |= (value) | REX_OPCODE; \
161 rex_used |= REX_OPCODE; \
164 /* Flags for prefixes which we somehow handled when printing the
165 current instruction. */
166 static int used_prefixes
;
168 /* Flags stored in PREFIXES. */
169 #define PREFIX_REPZ 1
170 #define PREFIX_REPNZ 2
171 #define PREFIX_LOCK 4
173 #define PREFIX_SS 0x10
174 #define PREFIX_DS 0x20
175 #define PREFIX_ES 0x40
176 #define PREFIX_FS 0x80
177 #define PREFIX_GS 0x100
178 #define PREFIX_DATA 0x200
179 #define PREFIX_ADDR 0x400
180 #define PREFIX_FWAIT 0x800
182 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
183 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
185 #define FETCH_DATA(info, addr) \
186 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
187 ? 1 : fetch_data ((info), (addr)))
190 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
193 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
194 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
196 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
197 status
= (*info
->read_memory_func
) (start
,
199 addr
- priv
->max_fetched
,
205 /* If we did manage to read at least one byte, then
206 print_insn_i386 will do something sensible. Otherwise, print
207 an error. We do that here because this is where we know
209 if (priv
->max_fetched
== priv
->the_buffer
)
210 (*info
->memory_error_func
) (status
, start
, info
);
211 longjmp (priv
->bailout
, 1);
214 priv
->max_fetched
= addr
;
218 #define XX { NULL, 0 }
219 #define Bad_Opcode NULL, { { NULL, 0 } }
221 #define Eb { OP_E, b_mode }
222 #define EbS { OP_E, b_swap_mode }
223 #define Ev { OP_E, v_mode }
224 #define EvS { OP_E, v_swap_mode }
225 #define Ed { OP_E, d_mode }
226 #define Edq { OP_E, dq_mode }
227 #define Edqw { OP_E, dqw_mode }
228 #define Edqb { OP_E, dqb_mode }
229 #define Edqd { OP_E, dqd_mode }
230 #define Eq { OP_E, q_mode }
231 #define indirEv { OP_indirE, stack_v_mode }
232 #define indirEp { OP_indirE, f_mode }
233 #define stackEv { OP_E, stack_v_mode }
234 #define Em { OP_E, m_mode }
235 #define Ew { OP_E, w_mode }
236 #define M { OP_M, 0 } /* lea, lgdt, etc. */
237 #define Ma { OP_M, a_mode }
238 #define Mb { OP_M, b_mode }
239 #define Md { OP_M, d_mode }
240 #define Mo { OP_M, o_mode }
241 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
242 #define Mq { OP_M, q_mode }
243 #define Mx { OP_M, x_mode }
244 #define Mxmm { OP_M, xmm_mode }
245 #define Gb { OP_G, b_mode }
246 #define Gv { OP_G, v_mode }
247 #define Gd { OP_G, d_mode }
248 #define Gdq { OP_G, dq_mode }
249 #define Gm { OP_G, m_mode }
250 #define Gw { OP_G, w_mode }
251 #define Rd { OP_R, d_mode }
252 #define Rm { OP_R, m_mode }
253 #define Ib { OP_I, b_mode }
254 #define sIb { OP_sI, b_mode } /* sign extened byte */
255 #define Iv { OP_I, v_mode }
256 #define sIv { OP_sI, v_mode }
257 #define Iq { OP_I, q_mode }
258 #define Iv64 { OP_I64, v_mode }
259 #define Iw { OP_I, w_mode }
260 #define I1 { OP_I, const_1_mode }
261 #define Jb { OP_J, b_mode }
262 #define Jv { OP_J, v_mode }
263 #define Cm { OP_C, m_mode }
264 #define Dm { OP_D, m_mode }
265 #define Td { OP_T, d_mode }
266 #define Skip_MODRM { OP_Skip_MODRM, 0 }
268 #define RMeAX { OP_REG, eAX_reg }
269 #define RMeBX { OP_REG, eBX_reg }
270 #define RMeCX { OP_REG, eCX_reg }
271 #define RMeDX { OP_REG, eDX_reg }
272 #define RMeSP { OP_REG, eSP_reg }
273 #define RMeBP { OP_REG, eBP_reg }
274 #define RMeSI { OP_REG, eSI_reg }
275 #define RMeDI { OP_REG, eDI_reg }
276 #define RMrAX { OP_REG, rAX_reg }
277 #define RMrBX { OP_REG, rBX_reg }
278 #define RMrCX { OP_REG, rCX_reg }
279 #define RMrDX { OP_REG, rDX_reg }
280 #define RMrSP { OP_REG, rSP_reg }
281 #define RMrBP { OP_REG, rBP_reg }
282 #define RMrSI { OP_REG, rSI_reg }
283 #define RMrDI { OP_REG, rDI_reg }
284 #define RMAL { OP_REG, al_reg }
285 #define RMCL { OP_REG, cl_reg }
286 #define RMDL { OP_REG, dl_reg }
287 #define RMBL { OP_REG, bl_reg }
288 #define RMAH { OP_REG, ah_reg }
289 #define RMCH { OP_REG, ch_reg }
290 #define RMDH { OP_REG, dh_reg }
291 #define RMBH { OP_REG, bh_reg }
292 #define RMAX { OP_REG, ax_reg }
293 #define RMDX { OP_REG, dx_reg }
295 #define eAX { OP_IMREG, eAX_reg }
296 #define eBX { OP_IMREG, eBX_reg }
297 #define eCX { OP_IMREG, eCX_reg }
298 #define eDX { OP_IMREG, eDX_reg }
299 #define eSP { OP_IMREG, eSP_reg }
300 #define eBP { OP_IMREG, eBP_reg }
301 #define eSI { OP_IMREG, eSI_reg }
302 #define eDI { OP_IMREG, eDI_reg }
303 #define AL { OP_IMREG, al_reg }
304 #define CL { OP_IMREG, cl_reg }
305 #define DL { OP_IMREG, dl_reg }
306 #define BL { OP_IMREG, bl_reg }
307 #define AH { OP_IMREG, ah_reg }
308 #define CH { OP_IMREG, ch_reg }
309 #define DH { OP_IMREG, dh_reg }
310 #define BH { OP_IMREG, bh_reg }
311 #define AX { OP_IMREG, ax_reg }
312 #define DX { OP_IMREG, dx_reg }
313 #define zAX { OP_IMREG, z_mode_ax_reg }
314 #define indirDX { OP_IMREG, indir_dx_reg }
316 #define Sw { OP_SEG, w_mode }
317 #define Sv { OP_SEG, v_mode }
318 #define Ap { OP_DIR, 0 }
319 #define Ob { OP_OFF64, b_mode }
320 #define Ov { OP_OFF64, v_mode }
321 #define Xb { OP_DSreg, eSI_reg }
322 #define Xv { OP_DSreg, eSI_reg }
323 #define Xz { OP_DSreg, eSI_reg }
324 #define Yb { OP_ESreg, eDI_reg }
325 #define Yv { OP_ESreg, eDI_reg }
326 #define DSBX { OP_DSreg, eBX_reg }
328 #define es { OP_REG, es_reg }
329 #define ss { OP_REG, ss_reg }
330 #define cs { OP_REG, cs_reg }
331 #define ds { OP_REG, ds_reg }
332 #define fs { OP_REG, fs_reg }
333 #define gs { OP_REG, gs_reg }
335 #define MX { OP_MMX, 0 }
336 #define XM { OP_XMM, 0 }
337 #define XMScalar { OP_XMM, scalar_mode }
338 #define XMM { OP_XMM, xmm_mode }
339 #define EM { OP_EM, v_mode }
340 #define EMS { OP_EM, v_swap_mode }
341 #define EMd { OP_EM, d_mode }
342 #define EMx { OP_EM, x_mode }
343 #define EXw { OP_EX, w_mode }
344 #define EXd { OP_EX, d_mode }
345 #define EXdScalar { OP_EX, d_scalar_mode }
346 #define EXdS { OP_EX, d_swap_mode }
347 #define EXq { OP_EX, q_mode }
348 #define EXqScalar { OP_EX, q_scalar_mode }
349 #define EXqScalarS { OP_EX, q_scalar_swap_mode }
350 #define EXqS { OP_EX, q_swap_mode }
351 #define EXx { OP_EX, x_mode }
352 #define EXxS { OP_EX, x_swap_mode }
353 #define EXxmm { OP_EX, xmm_mode }
354 #define EXxmmq { OP_EX, xmmq_mode }
355 #define EXymmq { OP_EX, ymmq_mode }
356 #define EXVexWdq { OP_EX, vex_w_dq_mode }
357 #define EXVexWdqScalar { OP_EX, vex_scalar_w_dq_mode }
358 #define MS { OP_MS, v_mode }
359 #define XS { OP_XS, v_mode }
360 #define EMCq { OP_EMC, q_mode }
361 #define MXC { OP_MXC, 0 }
362 #define OPSUF { OP_3DNowSuffix, 0 }
363 #define CMP { CMP_Fixup, 0 }
364 #define XMM0 { XMM_Fixup, 0 }
365 #define FXSAVE { FXSAVE_Fixup, 0 }
366 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
367 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
369 #define Vex { OP_VEX, vex_mode }
370 #define VexScalar { OP_VEX, vex_scalar_mode }
371 #define Vex128 { OP_VEX, vex128_mode }
372 #define Vex256 { OP_VEX, vex256_mode }
373 #define VexGdq { OP_VEX, dq_mode }
374 #define VexI4 { VEXI4_Fixup, 0}
375 #define EXdVex { OP_EX_Vex, d_mode }
376 #define EXdVexS { OP_EX_Vex, d_swap_mode }
377 #define EXdVexScalarS { OP_EX_Vex, d_scalar_swap_mode }
378 #define EXqVex { OP_EX_Vex, q_mode }
379 #define EXqVexS { OP_EX_Vex, q_swap_mode }
380 #define EXqVexScalarS { OP_EX_Vex, q_scalar_swap_mode }
381 #define EXVexW { OP_EX_VexW, x_mode }
382 #define EXdVexW { OP_EX_VexW, d_mode }
383 #define EXqVexW { OP_EX_VexW, q_mode }
384 #define EXVexImmW { OP_EX_VexImmW, x_mode }
385 #define XMVex { OP_XMM_Vex, 0 }
386 #define XMVexScalar { OP_XMM_Vex, scalar_mode }
387 #define XMVexW { OP_XMM_VexW, 0 }
388 #define XMVexI4 { OP_REG_VexI4, x_mode }
389 #define PCLMUL { PCLMUL_Fixup, 0 }
390 #define VZERO { VZERO_Fixup, 0 }
391 #define VCMP { VCMP_Fixup, 0 }
393 /* Used handle "rep" prefix for string instructions. */
394 #define Xbr { REP_Fixup, eSI_reg }
395 #define Xvr { REP_Fixup, eSI_reg }
396 #define Ybr { REP_Fixup, eDI_reg }
397 #define Yvr { REP_Fixup, eDI_reg }
398 #define Yzr { REP_Fixup, eDI_reg }
399 #define indirDXr { REP_Fixup, indir_dx_reg }
400 #define ALr { REP_Fixup, al_reg }
401 #define eAXr { REP_Fixup, eAX_reg }
403 #define cond_jump_flag { NULL, cond_jump_mode }
404 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
406 /* bits in sizeflag */
407 #define SUFFIX_ALWAYS 4
415 /* byte operand with operand swapped */
417 /* operand size depends on prefixes */
419 /* operand size depends on prefixes with operand swapped */
423 /* double word operand */
425 /* double word operand with operand swapped */
427 /* quad word operand */
429 /* quad word operand with operand swapped */
431 /* ten-byte operand */
433 /* 16-byte XMM or 32-byte YMM operand */
435 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
437 /* 16-byte XMM operand */
439 /* 16-byte XMM or quad word operand */
441 /* 32-byte YMM or quad word operand */
443 /* d_mode in 32bit, q_mode in 64bit mode. */
445 /* pair of v_mode operands */
449 /* operand size depends on REX prefixes. */
451 /* registers like dq_mode, memory like w_mode. */
453 /* 4- or 6-byte pointer operand */
456 /* v_mode for stack-related opcodes. */
458 /* non-quad operand size depends on prefixes */
460 /* 16-byte operand */
462 /* registers like dq_mode, memory like b_mode. */
464 /* registers like dq_mode, memory like d_mode. */
466 /* normal vex mode */
468 /* 128bit vex mode */
470 /* 256bit vex mode */
472 /* operand size depends on the VEX.W bit. */
475 /* scalar, ignore vector length. */
477 /* like d_mode, ignore vector length. */
479 /* like d_swap_mode, ignore vector length. */
481 /* like q_mode, ignore vector length. */
483 /* like q_swap_mode, ignore vector length. */
485 /* like vex_mode, ignore vector length. */
487 /* like vex_w_dq_mode, ignore vector length. */
488 vex_scalar_w_dq_mode
,
553 #define FLOAT NULL, { { NULL, FLOATCODE } }
555 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
556 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
557 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
558 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
559 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
560 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
561 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
562 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
563 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
564 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
565 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
566 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
666 MOD_VEX_0F12_PREFIX_0
,
668 MOD_VEX_0F16_PREFIX_0
,
684 MOD_VEX_0FD7_PREFIX_2
,
685 MOD_VEX_0FE7_PREFIX_2
,
686 MOD_VEX_0FF0_PREFIX_3
,
687 MOD_VEX_0F3818_PREFIX_2
,
688 MOD_VEX_0F3819_PREFIX_2
,
689 MOD_VEX_0F381A_PREFIX_2
,
690 MOD_VEX_0F382A_PREFIX_2
,
691 MOD_VEX_0F382C_PREFIX_2
,
692 MOD_VEX_0F382D_PREFIX_2
,
693 MOD_VEX_0F382E_PREFIX_2
,
694 MOD_VEX_0F382F_PREFIX_2
864 PREFIX_VEX_0F71_REG_2
,
865 PREFIX_VEX_0F71_REG_4
,
866 PREFIX_VEX_0F71_REG_6
,
867 PREFIX_VEX_0F72_REG_2
,
868 PREFIX_VEX_0F72_REG_4
,
869 PREFIX_VEX_0F72_REG_6
,
870 PREFIX_VEX_0F73_REG_2
,
871 PREFIX_VEX_0F73_REG_3
,
872 PREFIX_VEX_0F73_REG_6
,
873 PREFIX_VEX_0F73_REG_7
,
1023 PREFIX_VEX_0F38F3_REG_1
,
1024 PREFIX_VEX_0F38F3_REG_2
,
1025 PREFIX_VEX_0F38F3_REG_3
,
1118 THREE_BYTE_0F38
= 0,
1139 VEX_LEN_0F10_P_1
= 0,
1143 VEX_LEN_0F12_P_0_M_0
,
1144 VEX_LEN_0F12_P_0_M_1
,
1147 VEX_LEN_0F16_P_0_M_0
,
1148 VEX_LEN_0F16_P_0_M_1
,
1197 VEX_LEN_0F71_R_2_P_2
,
1198 VEX_LEN_0F71_R_4_P_2
,
1199 VEX_LEN_0F71_R_6_P_2
,
1200 VEX_LEN_0F72_R_2_P_2
,
1201 VEX_LEN_0F72_R_4_P_2
,
1202 VEX_LEN_0F72_R_6_P_2
,
1203 VEX_LEN_0F73_R_2_P_2
,
1204 VEX_LEN_0F73_R_3_P_2
,
1205 VEX_LEN_0F73_R_6_P_2
,
1206 VEX_LEN_0F73_R_7_P_2
,
1212 VEX_LEN_0FAE_R_2_M_0
,
1213 VEX_LEN_0FAE_R_3_M_0
,
1224 VEX_LEN_0FD7_P_2_M_1
,
1273 VEX_LEN_0F3819_P_2_M_0
,
1274 VEX_LEN_0F381A_P_2_M_0
,
1286 VEX_LEN_0F382A_P_2_M_0
,
1311 VEX_LEN_0F38F3_R_1_P_0
,
1312 VEX_LEN_0F38F3_R_2_P_0
,
1313 VEX_LEN_0F38F3_R_3_P_0
,
1346 VEX_LEN_0FXOP_09_80
,
1534 VEX_W_0F3818_P_2_M_0
,
1535 VEX_W_0F3819_P_2_M_0
,
1536 VEX_W_0F381A_P_2_M_0
,
1548 VEX_W_0F382A_P_2_M_0
,
1550 VEX_W_0F382C_P_2_M_0
,
1551 VEX_W_0F382D_P_2_M_0
,
1552 VEX_W_0F382E_P_2_M_0
,
1553 VEX_W_0F382F_P_2_M_0
,
1609 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1620 /* Upper case letters in the instruction names here are macros.
1621 'A' => print 'b' if no register operands or suffix_always is true
1622 'B' => print 'b' if suffix_always is true
1623 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1625 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1626 suffix_always is true
1627 'E' => print 'e' if 32-bit form of jcxz
1628 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1629 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1630 'H' => print ",pt" or ",pn" branch hint
1631 'I' => honor following macro letter even in Intel mode (implemented only
1632 for some of the macro letters)
1634 'K' => print 'd' or 'q' if rex prefix is present.
1635 'L' => print 'l' if suffix_always is true
1636 'M' => print 'r' if intel_mnemonic is false.
1637 'N' => print 'n' if instruction has no wait "prefix"
1638 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1639 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1640 or suffix_always is true. print 'q' if rex prefix is present.
1641 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1643 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1644 'S' => print 'w', 'l' or 'q' if suffix_always is true
1645 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1646 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1647 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1648 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1649 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1650 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1651 suffix_always is true.
1652 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1653 '!' => change condition from true to false or from false to true.
1654 '%' => add 1 upper case letter to the macro.
1656 2 upper case letter macros:
1657 "XY" => print 'x' or 'y' if no register operands or suffix_always
1659 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1660 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1661 or suffix_always is true
1662 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1663 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1664 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1666 Many of the above letters print nothing in Intel mode. See "putop"
1669 Braces '{' and '}', and vertical bars '|', indicate alternative
1670 mnemonic strings for AT&T and Intel. */
1672 static const struct dis386 dis386
[] = {
1674 { "addB", { Eb
, Gb
} },
1675 { "addS", { Ev
, Gv
} },
1676 { "addB", { Gb
, EbS
} },
1677 { "addS", { Gv
, EvS
} },
1678 { "addB", { AL
, Ib
} },
1679 { "addS", { eAX
, Iv
} },
1680 { X86_64_TABLE (X86_64_06
) },
1681 { X86_64_TABLE (X86_64_07
) },
1683 { "orB", { Eb
, Gb
} },
1684 { "orS", { Ev
, Gv
} },
1685 { "orB", { Gb
, EbS
} },
1686 { "orS", { Gv
, EvS
} },
1687 { "orB", { AL
, Ib
} },
1688 { "orS", { eAX
, Iv
} },
1689 { X86_64_TABLE (X86_64_0D
) },
1690 { Bad_Opcode
}, /* 0x0f extended opcode escape */
1692 { "adcB", { Eb
, Gb
} },
1693 { "adcS", { Ev
, Gv
} },
1694 { "adcB", { Gb
, EbS
} },
1695 { "adcS", { Gv
, EvS
} },
1696 { "adcB", { AL
, Ib
} },
1697 { "adcS", { eAX
, Iv
} },
1698 { X86_64_TABLE (X86_64_16
) },
1699 { X86_64_TABLE (X86_64_17
) },
1701 { "sbbB", { Eb
, Gb
} },
1702 { "sbbS", { Ev
, Gv
} },
1703 { "sbbB", { Gb
, EbS
} },
1704 { "sbbS", { Gv
, EvS
} },
1705 { "sbbB", { AL
, Ib
} },
1706 { "sbbS", { eAX
, Iv
} },
1707 { X86_64_TABLE (X86_64_1E
) },
1708 { X86_64_TABLE (X86_64_1F
) },
1710 { "andB", { Eb
, Gb
} },
1711 { "andS", { Ev
, Gv
} },
1712 { "andB", { Gb
, EbS
} },
1713 { "andS", { Gv
, EvS
} },
1714 { "andB", { AL
, Ib
} },
1715 { "andS", { eAX
, Iv
} },
1716 { Bad_Opcode
}, /* SEG ES prefix */
1717 { X86_64_TABLE (X86_64_27
) },
1719 { "subB", { Eb
, Gb
} },
1720 { "subS", { Ev
, Gv
} },
1721 { "subB", { Gb
, EbS
} },
1722 { "subS", { Gv
, EvS
} },
1723 { "subB", { AL
, Ib
} },
1724 { "subS", { eAX
, Iv
} },
1725 { Bad_Opcode
}, /* SEG CS prefix */
1726 { X86_64_TABLE (X86_64_2F
) },
1728 { "xorB", { Eb
, Gb
} },
1729 { "xorS", { Ev
, Gv
} },
1730 { "xorB", { Gb
, EbS
} },
1731 { "xorS", { Gv
, EvS
} },
1732 { "xorB", { AL
, Ib
} },
1733 { "xorS", { eAX
, Iv
} },
1734 { Bad_Opcode
}, /* SEG SS prefix */
1735 { X86_64_TABLE (X86_64_37
) },
1737 { "cmpB", { Eb
, Gb
} },
1738 { "cmpS", { Ev
, Gv
} },
1739 { "cmpB", { Gb
, EbS
} },
1740 { "cmpS", { Gv
, EvS
} },
1741 { "cmpB", { AL
, Ib
} },
1742 { "cmpS", { eAX
, Iv
} },
1743 { Bad_Opcode
}, /* SEG DS prefix */
1744 { X86_64_TABLE (X86_64_3F
) },
1746 { "inc{S|}", { RMeAX
} },
1747 { "inc{S|}", { RMeCX
} },
1748 { "inc{S|}", { RMeDX
} },
1749 { "inc{S|}", { RMeBX
} },
1750 { "inc{S|}", { RMeSP
} },
1751 { "inc{S|}", { RMeBP
} },
1752 { "inc{S|}", { RMeSI
} },
1753 { "inc{S|}", { RMeDI
} },
1755 { "dec{S|}", { RMeAX
} },
1756 { "dec{S|}", { RMeCX
} },
1757 { "dec{S|}", { RMeDX
} },
1758 { "dec{S|}", { RMeBX
} },
1759 { "dec{S|}", { RMeSP
} },
1760 { "dec{S|}", { RMeBP
} },
1761 { "dec{S|}", { RMeSI
} },
1762 { "dec{S|}", { RMeDI
} },
1764 { "pushV", { RMrAX
} },
1765 { "pushV", { RMrCX
} },
1766 { "pushV", { RMrDX
} },
1767 { "pushV", { RMrBX
} },
1768 { "pushV", { RMrSP
} },
1769 { "pushV", { RMrBP
} },
1770 { "pushV", { RMrSI
} },
1771 { "pushV", { RMrDI
} },
1773 { "popV", { RMrAX
} },
1774 { "popV", { RMrCX
} },
1775 { "popV", { RMrDX
} },
1776 { "popV", { RMrBX
} },
1777 { "popV", { RMrSP
} },
1778 { "popV", { RMrBP
} },
1779 { "popV", { RMrSI
} },
1780 { "popV", { RMrDI
} },
1782 { X86_64_TABLE (X86_64_60
) },
1783 { X86_64_TABLE (X86_64_61
) },
1784 { X86_64_TABLE (X86_64_62
) },
1785 { X86_64_TABLE (X86_64_63
) },
1786 { Bad_Opcode
}, /* seg fs */
1787 { Bad_Opcode
}, /* seg gs */
1788 { Bad_Opcode
}, /* op size prefix */
1789 { Bad_Opcode
}, /* adr size prefix */
1791 { "pushT", { sIv
} },
1792 { "imulS", { Gv
, Ev
, Iv
} },
1793 { "pushT", { sIb
} },
1794 { "imulS", { Gv
, Ev
, sIb
} },
1795 { "ins{b|}", { Ybr
, indirDX
} },
1796 { X86_64_TABLE (X86_64_6D
) },
1797 { "outs{b|}", { indirDXr
, Xb
} },
1798 { X86_64_TABLE (X86_64_6F
) },
1800 { "joH", { Jb
, XX
, cond_jump_flag
} },
1801 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1802 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1803 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1804 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1805 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1806 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1807 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1809 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1810 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1811 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1812 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1813 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1814 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1815 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1816 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1818 { REG_TABLE (REG_80
) },
1819 { REG_TABLE (REG_81
) },
1821 { REG_TABLE (REG_82
) },
1822 { "testB", { Eb
, Gb
} },
1823 { "testS", { Ev
, Gv
} },
1824 { "xchgB", { Eb
, Gb
} },
1825 { "xchgS", { Ev
, Gv
} },
1827 { "movB", { Eb
, Gb
} },
1828 { "movS", { Ev
, Gv
} },
1829 { "movB", { Gb
, EbS
} },
1830 { "movS", { Gv
, EvS
} },
1831 { "movD", { Sv
, Sw
} },
1832 { MOD_TABLE (MOD_8D
) },
1833 { "movD", { Sw
, Sv
} },
1834 { REG_TABLE (REG_8F
) },
1836 { PREFIX_TABLE (PREFIX_90
) },
1837 { "xchgS", { RMeCX
, eAX
} },
1838 { "xchgS", { RMeDX
, eAX
} },
1839 { "xchgS", { RMeBX
, eAX
} },
1840 { "xchgS", { RMeSP
, eAX
} },
1841 { "xchgS", { RMeBP
, eAX
} },
1842 { "xchgS", { RMeSI
, eAX
} },
1843 { "xchgS", { RMeDI
, eAX
} },
1845 { "cW{t|}R", { XX
} },
1846 { "cR{t|}O", { XX
} },
1847 { X86_64_TABLE (X86_64_9A
) },
1848 { Bad_Opcode
}, /* fwait */
1849 { "pushfT", { XX
} },
1850 { "popfT", { XX
} },
1854 { "mov%LB", { AL
, Ob
} },
1855 { "mov%LS", { eAX
, Ov
} },
1856 { "mov%LB", { Ob
, AL
} },
1857 { "mov%LS", { Ov
, eAX
} },
1858 { "movs{b|}", { Ybr
, Xb
} },
1859 { "movs{R|}", { Yvr
, Xv
} },
1860 { "cmps{b|}", { Xb
, Yb
} },
1861 { "cmps{R|}", { Xv
, Yv
} },
1863 { "testB", { AL
, Ib
} },
1864 { "testS", { eAX
, Iv
} },
1865 { "stosB", { Ybr
, AL
} },
1866 { "stosS", { Yvr
, eAX
} },
1867 { "lodsB", { ALr
, Xb
} },
1868 { "lodsS", { eAXr
, Xv
} },
1869 { "scasB", { AL
, Yb
} },
1870 { "scasS", { eAX
, Yv
} },
1872 { "movB", { RMAL
, Ib
} },
1873 { "movB", { RMCL
, Ib
} },
1874 { "movB", { RMDL
, Ib
} },
1875 { "movB", { RMBL
, Ib
} },
1876 { "movB", { RMAH
, Ib
} },
1877 { "movB", { RMCH
, Ib
} },
1878 { "movB", { RMDH
, Ib
} },
1879 { "movB", { RMBH
, Ib
} },
1881 { "mov%LV", { RMeAX
, Iv64
} },
1882 { "mov%LV", { RMeCX
, Iv64
} },
1883 { "mov%LV", { RMeDX
, Iv64
} },
1884 { "mov%LV", { RMeBX
, Iv64
} },
1885 { "mov%LV", { RMeSP
, Iv64
} },
1886 { "mov%LV", { RMeBP
, Iv64
} },
1887 { "mov%LV", { RMeSI
, Iv64
} },
1888 { "mov%LV", { RMeDI
, Iv64
} },
1890 { REG_TABLE (REG_C0
) },
1891 { REG_TABLE (REG_C1
) },
1894 { X86_64_TABLE (X86_64_C4
) },
1895 { X86_64_TABLE (X86_64_C5
) },
1896 { REG_TABLE (REG_C6
) },
1897 { REG_TABLE (REG_C7
) },
1899 { "enterT", { Iw
, Ib
} },
1900 { "leaveT", { XX
} },
1901 { "Jret{|f}P", { Iw
} },
1902 { "Jret{|f}P", { XX
} },
1905 { X86_64_TABLE (X86_64_CE
) },
1906 { "iretP", { XX
} },
1908 { REG_TABLE (REG_D0
) },
1909 { REG_TABLE (REG_D1
) },
1910 { REG_TABLE (REG_D2
) },
1911 { REG_TABLE (REG_D3
) },
1912 { X86_64_TABLE (X86_64_D4
) },
1913 { X86_64_TABLE (X86_64_D5
) },
1915 { "xlat", { DSBX
} },
1926 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1927 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1928 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1929 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1930 { "inB", { AL
, Ib
} },
1931 { "inG", { zAX
, Ib
} },
1932 { "outB", { Ib
, AL
} },
1933 { "outG", { Ib
, zAX
} },
1935 { "callT", { Jv
} },
1937 { X86_64_TABLE (X86_64_EA
) },
1939 { "inB", { AL
, indirDX
} },
1940 { "inG", { zAX
, indirDX
} },
1941 { "outB", { indirDX
, AL
} },
1942 { "outG", { indirDX
, zAX
} },
1944 { Bad_Opcode
}, /* lock prefix */
1945 { "icebp", { XX
} },
1946 { Bad_Opcode
}, /* repne */
1947 { Bad_Opcode
}, /* repz */
1950 { REG_TABLE (REG_F6
) },
1951 { REG_TABLE (REG_F7
) },
1959 { REG_TABLE (REG_FE
) },
1960 { REG_TABLE (REG_FF
) },
1963 static const struct dis386 dis386_twobyte
[] = {
1965 { REG_TABLE (REG_0F00
) },
1966 { REG_TABLE (REG_0F01
) },
1967 { "larS", { Gv
, Ew
} },
1968 { "lslS", { Gv
, Ew
} },
1970 { "syscall", { XX
} },
1972 { "sysretP", { XX
} },
1975 { "wbinvd", { XX
} },
1979 { REG_TABLE (REG_0F0D
) },
1980 { "femms", { XX
} },
1981 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1983 { PREFIX_TABLE (PREFIX_0F10
) },
1984 { PREFIX_TABLE (PREFIX_0F11
) },
1985 { PREFIX_TABLE (PREFIX_0F12
) },
1986 { MOD_TABLE (MOD_0F13
) },
1987 { "unpcklpX", { XM
, EXx
} },
1988 { "unpckhpX", { XM
, EXx
} },
1989 { PREFIX_TABLE (PREFIX_0F16
) },
1990 { MOD_TABLE (MOD_0F17
) },
1992 { REG_TABLE (REG_0F18
) },
2001 { MOD_TABLE (MOD_0F20
) },
2002 { MOD_TABLE (MOD_0F21
) },
2003 { MOD_TABLE (MOD_0F22
) },
2004 { MOD_TABLE (MOD_0F23
) },
2005 { MOD_TABLE (MOD_0F24
) },
2007 { MOD_TABLE (MOD_0F26
) },
2010 { "movapX", { XM
, EXx
} },
2011 { "movapX", { EXxS
, XM
} },
2012 { PREFIX_TABLE (PREFIX_0F2A
) },
2013 { PREFIX_TABLE (PREFIX_0F2B
) },
2014 { PREFIX_TABLE (PREFIX_0F2C
) },
2015 { PREFIX_TABLE (PREFIX_0F2D
) },
2016 { PREFIX_TABLE (PREFIX_0F2E
) },
2017 { PREFIX_TABLE (PREFIX_0F2F
) },
2019 { "wrmsr", { XX
} },
2020 { "rdtsc", { XX
} },
2021 { "rdmsr", { XX
} },
2022 { "rdpmc", { XX
} },
2023 { "sysenter", { XX
} },
2024 { "sysexit", { XX
} },
2026 { "getsec", { XX
} },
2028 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
2030 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
2037 { "cmovoS", { Gv
, Ev
} },
2038 { "cmovnoS", { Gv
, Ev
} },
2039 { "cmovbS", { Gv
, Ev
} },
2040 { "cmovaeS", { Gv
, Ev
} },
2041 { "cmoveS", { Gv
, Ev
} },
2042 { "cmovneS", { Gv
, Ev
} },
2043 { "cmovbeS", { Gv
, Ev
} },
2044 { "cmovaS", { Gv
, Ev
} },
2046 { "cmovsS", { Gv
, Ev
} },
2047 { "cmovnsS", { Gv
, Ev
} },
2048 { "cmovpS", { Gv
, Ev
} },
2049 { "cmovnpS", { Gv
, Ev
} },
2050 { "cmovlS", { Gv
, Ev
} },
2051 { "cmovgeS", { Gv
, Ev
} },
2052 { "cmovleS", { Gv
, Ev
} },
2053 { "cmovgS", { Gv
, Ev
} },
2055 { MOD_TABLE (MOD_0F51
) },
2056 { PREFIX_TABLE (PREFIX_0F51
) },
2057 { PREFIX_TABLE (PREFIX_0F52
) },
2058 { PREFIX_TABLE (PREFIX_0F53
) },
2059 { "andpX", { XM
, EXx
} },
2060 { "andnpX", { XM
, EXx
} },
2061 { "orpX", { XM
, EXx
} },
2062 { "xorpX", { XM
, EXx
} },
2064 { PREFIX_TABLE (PREFIX_0F58
) },
2065 { PREFIX_TABLE (PREFIX_0F59
) },
2066 { PREFIX_TABLE (PREFIX_0F5A
) },
2067 { PREFIX_TABLE (PREFIX_0F5B
) },
2068 { PREFIX_TABLE (PREFIX_0F5C
) },
2069 { PREFIX_TABLE (PREFIX_0F5D
) },
2070 { PREFIX_TABLE (PREFIX_0F5E
) },
2071 { PREFIX_TABLE (PREFIX_0F5F
) },
2073 { PREFIX_TABLE (PREFIX_0F60
) },
2074 { PREFIX_TABLE (PREFIX_0F61
) },
2075 { PREFIX_TABLE (PREFIX_0F62
) },
2076 { "packsswb", { MX
, EM
} },
2077 { "pcmpgtb", { MX
, EM
} },
2078 { "pcmpgtw", { MX
, EM
} },
2079 { "pcmpgtd", { MX
, EM
} },
2080 { "packuswb", { MX
, EM
} },
2082 { "punpckhbw", { MX
, EM
} },
2083 { "punpckhwd", { MX
, EM
} },
2084 { "punpckhdq", { MX
, EM
} },
2085 { "packssdw", { MX
, EM
} },
2086 { PREFIX_TABLE (PREFIX_0F6C
) },
2087 { PREFIX_TABLE (PREFIX_0F6D
) },
2088 { "movK", { MX
, Edq
} },
2089 { PREFIX_TABLE (PREFIX_0F6F
) },
2091 { PREFIX_TABLE (PREFIX_0F70
) },
2092 { REG_TABLE (REG_0F71
) },
2093 { REG_TABLE (REG_0F72
) },
2094 { REG_TABLE (REG_0F73
) },
2095 { "pcmpeqb", { MX
, EM
} },
2096 { "pcmpeqw", { MX
, EM
} },
2097 { "pcmpeqd", { MX
, EM
} },
2100 { PREFIX_TABLE (PREFIX_0F78
) },
2101 { PREFIX_TABLE (PREFIX_0F79
) },
2102 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2104 { PREFIX_TABLE (PREFIX_0F7C
) },
2105 { PREFIX_TABLE (PREFIX_0F7D
) },
2106 { PREFIX_TABLE (PREFIX_0F7E
) },
2107 { PREFIX_TABLE (PREFIX_0F7F
) },
2109 { "joH", { Jv
, XX
, cond_jump_flag
} },
2110 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
2111 { "jbH", { Jv
, XX
, cond_jump_flag
} },
2112 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
2113 { "jeH", { Jv
, XX
, cond_jump_flag
} },
2114 { "jneH", { Jv
, XX
, cond_jump_flag
} },
2115 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
2116 { "jaH", { Jv
, XX
, cond_jump_flag
} },
2118 { "jsH", { Jv
, XX
, cond_jump_flag
} },
2119 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
2120 { "jpH", { Jv
, XX
, cond_jump_flag
} },
2121 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
2122 { "jlH", { Jv
, XX
, cond_jump_flag
} },
2123 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
2124 { "jleH", { Jv
, XX
, cond_jump_flag
} },
2125 { "jgH", { Jv
, XX
, cond_jump_flag
} },
2128 { "setno", { Eb
} },
2130 { "setae", { Eb
} },
2132 { "setne", { Eb
} },
2133 { "setbe", { Eb
} },
2137 { "setns", { Eb
} },
2139 { "setnp", { Eb
} },
2141 { "setge", { Eb
} },
2142 { "setle", { Eb
} },
2145 { "pushT", { fs
} },
2147 { "cpuid", { XX
} },
2148 { "btS", { Ev
, Gv
} },
2149 { "shldS", { Ev
, Gv
, Ib
} },
2150 { "shldS", { Ev
, Gv
, CL
} },
2151 { REG_TABLE (REG_0FA6
) },
2152 { REG_TABLE (REG_0FA7
) },
2154 { "pushT", { gs
} },
2157 { "btsS", { Ev
, Gv
} },
2158 { "shrdS", { Ev
, Gv
, Ib
} },
2159 { "shrdS", { Ev
, Gv
, CL
} },
2160 { REG_TABLE (REG_0FAE
) },
2161 { "imulS", { Gv
, Ev
} },
2163 { "cmpxchgB", { Eb
, Gb
} },
2164 { "cmpxchgS", { Ev
, Gv
} },
2165 { MOD_TABLE (MOD_0FB2
) },
2166 { "btrS", { Ev
, Gv
} },
2167 { MOD_TABLE (MOD_0FB4
) },
2168 { MOD_TABLE (MOD_0FB5
) },
2169 { "movz{bR|x}", { Gv
, Eb
} },
2170 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
2172 { PREFIX_TABLE (PREFIX_0FB8
) },
2174 { REG_TABLE (REG_0FBA
) },
2175 { "btcS", { Ev
, Gv
} },
2176 { PREFIX_TABLE (PREFIX_0FBC
) },
2177 { PREFIX_TABLE (PREFIX_0FBD
) },
2178 { "movs{bR|x}", { Gv
, Eb
} },
2179 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
2181 { "xaddB", { Eb
, Gb
} },
2182 { "xaddS", { Ev
, Gv
} },
2183 { PREFIX_TABLE (PREFIX_0FC2
) },
2184 { PREFIX_TABLE (PREFIX_0FC3
) },
2185 { "pinsrw", { MX
, Edqw
, Ib
} },
2186 { "pextrw", { Gdq
, MS
, Ib
} },
2187 { "shufpX", { XM
, EXx
, Ib
} },
2188 { REG_TABLE (REG_0FC7
) },
2190 { "bswap", { RMeAX
} },
2191 { "bswap", { RMeCX
} },
2192 { "bswap", { RMeDX
} },
2193 { "bswap", { RMeBX
} },
2194 { "bswap", { RMeSP
} },
2195 { "bswap", { RMeBP
} },
2196 { "bswap", { RMeSI
} },
2197 { "bswap", { RMeDI
} },
2199 { PREFIX_TABLE (PREFIX_0FD0
) },
2200 { "psrlw", { MX
, EM
} },
2201 { "psrld", { MX
, EM
} },
2202 { "psrlq", { MX
, EM
} },
2203 { "paddq", { MX
, EM
} },
2204 { "pmullw", { MX
, EM
} },
2205 { PREFIX_TABLE (PREFIX_0FD6
) },
2206 { MOD_TABLE (MOD_0FD7
) },
2208 { "psubusb", { MX
, EM
} },
2209 { "psubusw", { MX
, EM
} },
2210 { "pminub", { MX
, EM
} },
2211 { "pand", { MX
, EM
} },
2212 { "paddusb", { MX
, EM
} },
2213 { "paddusw", { MX
, EM
} },
2214 { "pmaxub", { MX
, EM
} },
2215 { "pandn", { MX
, EM
} },
2217 { "pavgb", { MX
, EM
} },
2218 { "psraw", { MX
, EM
} },
2219 { "psrad", { MX
, EM
} },
2220 { "pavgw", { MX
, EM
} },
2221 { "pmulhuw", { MX
, EM
} },
2222 { "pmulhw", { MX
, EM
} },
2223 { PREFIX_TABLE (PREFIX_0FE6
) },
2224 { PREFIX_TABLE (PREFIX_0FE7
) },
2226 { "psubsb", { MX
, EM
} },
2227 { "psubsw", { MX
, EM
} },
2228 { "pminsw", { MX
, EM
} },
2229 { "por", { MX
, EM
} },
2230 { "paddsb", { MX
, EM
} },
2231 { "paddsw", { MX
, EM
} },
2232 { "pmaxsw", { MX
, EM
} },
2233 { "pxor", { MX
, EM
} },
2235 { PREFIX_TABLE (PREFIX_0FF0
) },
2236 { "psllw", { MX
, EM
} },
2237 { "pslld", { MX
, EM
} },
2238 { "psllq", { MX
, EM
} },
2239 { "pmuludq", { MX
, EM
} },
2240 { "pmaddwd", { MX
, EM
} },
2241 { "psadbw", { MX
, EM
} },
2242 { PREFIX_TABLE (PREFIX_0FF7
) },
2244 { "psubb", { MX
, EM
} },
2245 { "psubw", { MX
, EM
} },
2246 { "psubd", { MX
, EM
} },
2247 { "psubq", { MX
, EM
} },
2248 { "paddb", { MX
, EM
} },
2249 { "paddw", { MX
, EM
} },
2250 { "paddd", { MX
, EM
} },
2254 static const unsigned char onebyte_has_modrm
[256] = {
2255 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2256 /* ------------------------------- */
2257 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2258 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2259 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2260 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2261 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2262 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2263 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2264 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2265 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2266 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2267 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2268 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2269 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2270 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2271 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2272 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2273 /* ------------------------------- */
2274 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2277 static const unsigned char twobyte_has_modrm
[256] = {
2278 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2279 /* ------------------------------- */
2280 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2281 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2282 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2283 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2284 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2285 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2286 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2287 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2288 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2289 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2290 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2291 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2292 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2293 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2294 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2295 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2296 /* ------------------------------- */
2297 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2300 static char obuf
[100];
2302 static char *mnemonicendp
;
2303 static char scratchbuf
[100];
2304 static unsigned char *start_codep
;
2305 static unsigned char *insn_codep
;
2306 static unsigned char *codep
;
2307 static int last_lock_prefix
;
2308 static int last_repz_prefix
;
2309 static int last_repnz_prefix
;
2310 static int last_data_prefix
;
2311 static int last_addr_prefix
;
2312 static int last_rex_prefix
;
2313 static int last_seg_prefix
;
2314 #define MAX_CODE_LENGTH 15
2315 /* We can up to 14 prefixes since the maximum instruction length is
2317 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2318 static disassemble_info
*the_info
;
2326 static unsigned char need_modrm
;
2336 int register_specifier
;
2342 static unsigned char need_vex
;
2343 static unsigned char need_vex_reg
;
2344 static unsigned char vex_w_done
;
2352 /* If we are accessing mod/rm/reg without need_modrm set, then the
2353 values are stale. Hitting this abort likely indicates that you
2354 need to update onebyte_has_modrm or twobyte_has_modrm. */
2355 #define MODRM_CHECK if (!need_modrm) abort ()
2357 static const char **names64
;
2358 static const char **names32
;
2359 static const char **names16
;
2360 static const char **names8
;
2361 static const char **names8rex
;
2362 static const char **names_seg
;
2363 static const char *index64
;
2364 static const char *index32
;
2365 static const char **index16
;
2367 static const char *intel_names64
[] = {
2368 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2369 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2371 static const char *intel_names32
[] = {
2372 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2373 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2375 static const char *intel_names16
[] = {
2376 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2377 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2379 static const char *intel_names8
[] = {
2380 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2382 static const char *intel_names8rex
[] = {
2383 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2384 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2386 static const char *intel_names_seg
[] = {
2387 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2389 static const char *intel_index64
= "riz";
2390 static const char *intel_index32
= "eiz";
2391 static const char *intel_index16
[] = {
2392 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2395 static const char *att_names64
[] = {
2396 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2397 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2399 static const char *att_names32
[] = {
2400 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2401 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2403 static const char *att_names16
[] = {
2404 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2405 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2407 static const char *att_names8
[] = {
2408 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2410 static const char *att_names8rex
[] = {
2411 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2412 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2414 static const char *att_names_seg
[] = {
2415 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2417 static const char *att_index64
= "%riz";
2418 static const char *att_index32
= "%eiz";
2419 static const char *att_index16
[] = {
2420 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2423 static const char **names_mm
;
2424 static const char *intel_names_mm
[] = {
2425 "mm0", "mm1", "mm2", "mm3",
2426 "mm4", "mm5", "mm6", "mm7"
2428 static const char *att_names_mm
[] = {
2429 "%mm0", "%mm1", "%mm2", "%mm3",
2430 "%mm4", "%mm5", "%mm6", "%mm7"
2433 static const char **names_xmm
;
2434 static const char *intel_names_xmm
[] = {
2435 "xmm0", "xmm1", "xmm2", "xmm3",
2436 "xmm4", "xmm5", "xmm6", "xmm7",
2437 "xmm8", "xmm9", "xmm10", "xmm11",
2438 "xmm12", "xmm13", "xmm14", "xmm15"
2440 static const char *att_names_xmm
[] = {
2441 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2442 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
2443 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
2444 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
2447 static const char **names_ymm
;
2448 static const char *intel_names_ymm
[] = {
2449 "ymm0", "ymm1", "ymm2", "ymm3",
2450 "ymm4", "ymm5", "ymm6", "ymm7",
2451 "ymm8", "ymm9", "ymm10", "ymm11",
2452 "ymm12", "ymm13", "ymm14", "ymm15"
2454 static const char *att_names_ymm
[] = {
2455 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
2456 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
2457 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
2458 "%ymm12", "%ymm13", "%ymm14", "%ymm15"
2461 static const struct dis386 reg_table
[][8] = {
2464 { "addA", { Eb
, Ib
} },
2465 { "orA", { Eb
, Ib
} },
2466 { "adcA", { Eb
, Ib
} },
2467 { "sbbA", { Eb
, Ib
} },
2468 { "andA", { Eb
, Ib
} },
2469 { "subA", { Eb
, Ib
} },
2470 { "xorA", { Eb
, Ib
} },
2471 { "cmpA", { Eb
, Ib
} },
2475 { "addQ", { Ev
, Iv
} },
2476 { "orQ", { Ev
, Iv
} },
2477 { "adcQ", { Ev
, Iv
} },
2478 { "sbbQ", { Ev
, Iv
} },
2479 { "andQ", { Ev
, Iv
} },
2480 { "subQ", { Ev
, Iv
} },
2481 { "xorQ", { Ev
, Iv
} },
2482 { "cmpQ", { Ev
, Iv
} },
2486 { "addQ", { Ev
, sIb
} },
2487 { "orQ", { Ev
, sIb
} },
2488 { "adcQ", { Ev
, sIb
} },
2489 { "sbbQ", { Ev
, sIb
} },
2490 { "andQ", { Ev
, sIb
} },
2491 { "subQ", { Ev
, sIb
} },
2492 { "xorQ", { Ev
, sIb
} },
2493 { "cmpQ", { Ev
, sIb
} },
2497 { "popU", { stackEv
} },
2498 { XOP_8F_TABLE (XOP_09
) },
2502 { XOP_8F_TABLE (XOP_09
) },
2506 { "rolA", { Eb
, Ib
} },
2507 { "rorA", { Eb
, Ib
} },
2508 { "rclA", { Eb
, Ib
} },
2509 { "rcrA", { Eb
, Ib
} },
2510 { "shlA", { Eb
, Ib
} },
2511 { "shrA", { Eb
, Ib
} },
2513 { "sarA", { Eb
, Ib
} },
2517 { "rolQ", { Ev
, Ib
} },
2518 { "rorQ", { Ev
, Ib
} },
2519 { "rclQ", { Ev
, Ib
} },
2520 { "rcrQ", { Ev
, Ib
} },
2521 { "shlQ", { Ev
, Ib
} },
2522 { "shrQ", { Ev
, Ib
} },
2524 { "sarQ", { Ev
, Ib
} },
2528 { "movA", { Eb
, Ib
} },
2532 { "movQ", { Ev
, Iv
} },
2536 { "rolA", { Eb
, I1
} },
2537 { "rorA", { Eb
, I1
} },
2538 { "rclA", { Eb
, I1
} },
2539 { "rcrA", { Eb
, I1
} },
2540 { "shlA", { Eb
, I1
} },
2541 { "shrA", { Eb
, I1
} },
2543 { "sarA", { Eb
, I1
} },
2547 { "rolQ", { Ev
, I1
} },
2548 { "rorQ", { Ev
, I1
} },
2549 { "rclQ", { Ev
, I1
} },
2550 { "rcrQ", { Ev
, I1
} },
2551 { "shlQ", { Ev
, I1
} },
2552 { "shrQ", { Ev
, I1
} },
2554 { "sarQ", { Ev
, I1
} },
2558 { "rolA", { Eb
, CL
} },
2559 { "rorA", { Eb
, CL
} },
2560 { "rclA", { Eb
, CL
} },
2561 { "rcrA", { Eb
, CL
} },
2562 { "shlA", { Eb
, CL
} },
2563 { "shrA", { Eb
, CL
} },
2565 { "sarA", { Eb
, CL
} },
2569 { "rolQ", { Ev
, CL
} },
2570 { "rorQ", { Ev
, CL
} },
2571 { "rclQ", { Ev
, CL
} },
2572 { "rcrQ", { Ev
, CL
} },
2573 { "shlQ", { Ev
, CL
} },
2574 { "shrQ", { Ev
, CL
} },
2576 { "sarQ", { Ev
, CL
} },
2580 { "testA", { Eb
, Ib
} },
2584 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2585 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2586 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2587 { "idivA", { Eb
} }, /* and idiv for consistency. */
2591 { "testQ", { Ev
, Iv
} },
2595 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2596 { "imulQ", { Ev
} },
2598 { "idivQ", { Ev
} },
2609 { "call{T|}", { indirEv
} },
2610 { "Jcall{T|}", { indirEp
} },
2611 { "jmp{T|}", { indirEv
} },
2612 { "Jjmp{T|}", { indirEp
} },
2613 { "pushU", { stackEv
} },
2618 { "sldtD", { Sv
} },
2629 { MOD_TABLE (MOD_0F01_REG_0
) },
2630 { MOD_TABLE (MOD_0F01_REG_1
) },
2631 { MOD_TABLE (MOD_0F01_REG_2
) },
2632 { MOD_TABLE (MOD_0F01_REG_3
) },
2633 { "smswD", { Sv
} },
2636 { MOD_TABLE (MOD_0F01_REG_7
) },
2640 { "prefetch", { Mb
} },
2641 { "prefetchw", { Mb
} },
2645 { MOD_TABLE (MOD_0F18_REG_0
) },
2646 { MOD_TABLE (MOD_0F18_REG_1
) },
2647 { MOD_TABLE (MOD_0F18_REG_2
) },
2648 { MOD_TABLE (MOD_0F18_REG_3
) },
2654 { MOD_TABLE (MOD_0F71_REG_2
) },
2656 { MOD_TABLE (MOD_0F71_REG_4
) },
2658 { MOD_TABLE (MOD_0F71_REG_6
) },
2664 { MOD_TABLE (MOD_0F72_REG_2
) },
2666 { MOD_TABLE (MOD_0F72_REG_4
) },
2668 { MOD_TABLE (MOD_0F72_REG_6
) },
2674 { MOD_TABLE (MOD_0F73_REG_2
) },
2675 { MOD_TABLE (MOD_0F73_REG_3
) },
2678 { MOD_TABLE (MOD_0F73_REG_6
) },
2679 { MOD_TABLE (MOD_0F73_REG_7
) },
2683 { "montmul", { { OP_0f07
, 0 } } },
2684 { "xsha1", { { OP_0f07
, 0 } } },
2685 { "xsha256", { { OP_0f07
, 0 } } },
2689 { "xstore-rng", { { OP_0f07
, 0 } } },
2690 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2691 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2692 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2693 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2694 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2698 { MOD_TABLE (MOD_0FAE_REG_0
) },
2699 { MOD_TABLE (MOD_0FAE_REG_1
) },
2700 { MOD_TABLE (MOD_0FAE_REG_2
) },
2701 { MOD_TABLE (MOD_0FAE_REG_3
) },
2702 { MOD_TABLE (MOD_0FAE_REG_4
) },
2703 { MOD_TABLE (MOD_0FAE_REG_5
) },
2704 { MOD_TABLE (MOD_0FAE_REG_6
) },
2705 { MOD_TABLE (MOD_0FAE_REG_7
) },
2713 { "btQ", { Ev
, Ib
} },
2714 { "btsQ", { Ev
, Ib
} },
2715 { "btrQ", { Ev
, Ib
} },
2716 { "btcQ", { Ev
, Ib
} },
2721 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2726 { MOD_TABLE (MOD_0FC7_REG_6
) },
2727 { MOD_TABLE (MOD_0FC7_REG_7
) },
2733 { MOD_TABLE (MOD_VEX_0F71_REG_2
) },
2735 { MOD_TABLE (MOD_VEX_0F71_REG_4
) },
2737 { MOD_TABLE (MOD_VEX_0F71_REG_6
) },
2743 { MOD_TABLE (MOD_VEX_0F72_REG_2
) },
2745 { MOD_TABLE (MOD_VEX_0F72_REG_4
) },
2747 { MOD_TABLE (MOD_VEX_0F72_REG_6
) },
2753 { MOD_TABLE (MOD_VEX_0F73_REG_2
) },
2754 { MOD_TABLE (MOD_VEX_0F73_REG_3
) },
2757 { MOD_TABLE (MOD_VEX_0F73_REG_6
) },
2758 { MOD_TABLE (MOD_VEX_0F73_REG_7
) },
2764 { MOD_TABLE (MOD_VEX_0FAE_REG_2
) },
2765 { MOD_TABLE (MOD_VEX_0FAE_REG_3
) },
2767 /* REG_VEX_0F38F3 */
2770 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_1
) },
2771 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_2
) },
2772 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_3
) },
2776 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2777 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2781 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, Iq
} },
2782 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, Iq
} },
2784 /* REG_XOP_TBM_01 */
2787 { "blcfill", { { OP_LWP_E
, 0 }, Ev
} },
2788 { "blsfill", { { OP_LWP_E
, 0 }, Ev
} },
2789 { "blcs", { { OP_LWP_E
, 0 }, Ev
} },
2790 { "tzmsk", { { OP_LWP_E
, 0 }, Ev
} },
2791 { "blcic", { { OP_LWP_E
, 0 }, Ev
} },
2792 { "blsic", { { OP_LWP_E
, 0 }, Ev
} },
2793 { "t1mskc", { { OP_LWP_E
, 0 }, Ev
} },
2795 /* REG_XOP_TBM_02 */
2798 { "blcmsk", { { OP_LWP_E
, 0 }, Ev
} },
2803 { "blci", { { OP_LWP_E
, 0 }, Ev
} },
2807 static const struct dis386 prefix_table
[][4] = {
2810 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2811 { "pause", { XX
} },
2812 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2817 { "movups", { XM
, EXx
} },
2818 { "movss", { XM
, EXd
} },
2819 { "movupd", { XM
, EXx
} },
2820 { "movsd", { XM
, EXq
} },
2825 { "movups", { EXxS
, XM
} },
2826 { "movss", { EXdS
, XM
} },
2827 { "movupd", { EXxS
, XM
} },
2828 { "movsd", { EXqS
, XM
} },
2833 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2834 { "movsldup", { XM
, EXx
} },
2835 { "movlpd", { XM
, EXq
} },
2836 { "movddup", { XM
, EXq
} },
2841 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2842 { "movshdup", { XM
, EXx
} },
2843 { "movhpd", { XM
, EXq
} },
2848 { "cvtpi2ps", { XM
, EMCq
} },
2849 { "cvtsi2ss%LQ", { XM
, Ev
} },
2850 { "cvtpi2pd", { XM
, EMCq
} },
2851 { "cvtsi2sd%LQ", { XM
, Ev
} },
2856 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2857 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2858 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2859 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2864 { "cvttps2pi", { MXC
, EXq
} },
2865 { "cvttss2siY", { Gv
, EXd
} },
2866 { "cvttpd2pi", { MXC
, EXx
} },
2867 { "cvttsd2siY", { Gv
, EXq
} },
2872 { "cvtps2pi", { MXC
, EXq
} },
2873 { "cvtss2siY", { Gv
, EXd
} },
2874 { "cvtpd2pi", { MXC
, EXx
} },
2875 { "cvtsd2siY", { Gv
, EXq
} },
2880 { "ucomiss",{ XM
, EXd
} },
2882 { "ucomisd",{ XM
, EXq
} },
2887 { "comiss", { XM
, EXd
} },
2889 { "comisd", { XM
, EXq
} },
2894 { "sqrtps", { XM
, EXx
} },
2895 { "sqrtss", { XM
, EXd
} },
2896 { "sqrtpd", { XM
, EXx
} },
2897 { "sqrtsd", { XM
, EXq
} },
2902 { "rsqrtps",{ XM
, EXx
} },
2903 { "rsqrtss",{ XM
, EXd
} },
2908 { "rcpps", { XM
, EXx
} },
2909 { "rcpss", { XM
, EXd
} },
2914 { "addps", { XM
, EXx
} },
2915 { "addss", { XM
, EXd
} },
2916 { "addpd", { XM
, EXx
} },
2917 { "addsd", { XM
, EXq
} },
2922 { "mulps", { XM
, EXx
} },
2923 { "mulss", { XM
, EXd
} },
2924 { "mulpd", { XM
, EXx
} },
2925 { "mulsd", { XM
, EXq
} },
2930 { "cvtps2pd", { XM
, EXq
} },
2931 { "cvtss2sd", { XM
, EXd
} },
2932 { "cvtpd2ps", { XM
, EXx
} },
2933 { "cvtsd2ss", { XM
, EXq
} },
2938 { "cvtdq2ps", { XM
, EXx
} },
2939 { "cvttps2dq", { XM
, EXx
} },
2940 { "cvtps2dq", { XM
, EXx
} },
2945 { "subps", { XM
, EXx
} },
2946 { "subss", { XM
, EXd
} },
2947 { "subpd", { XM
, EXx
} },
2948 { "subsd", { XM
, EXq
} },
2953 { "minps", { XM
, EXx
} },
2954 { "minss", { XM
, EXd
} },
2955 { "minpd", { XM
, EXx
} },
2956 { "minsd", { XM
, EXq
} },
2961 { "divps", { XM
, EXx
} },
2962 { "divss", { XM
, EXd
} },
2963 { "divpd", { XM
, EXx
} },
2964 { "divsd", { XM
, EXq
} },
2969 { "maxps", { XM
, EXx
} },
2970 { "maxss", { XM
, EXd
} },
2971 { "maxpd", { XM
, EXx
} },
2972 { "maxsd", { XM
, EXq
} },
2977 { "punpcklbw",{ MX
, EMd
} },
2979 { "punpcklbw",{ MX
, EMx
} },
2984 { "punpcklwd",{ MX
, EMd
} },
2986 { "punpcklwd",{ MX
, EMx
} },
2991 { "punpckldq",{ MX
, EMd
} },
2993 { "punpckldq",{ MX
, EMx
} },
3000 { "punpcklqdq", { XM
, EXx
} },
3007 { "punpckhqdq", { XM
, EXx
} },
3012 { "movq", { MX
, EM
} },
3013 { "movdqu", { XM
, EXx
} },
3014 { "movdqa", { XM
, EXx
} },
3019 { "pshufw", { MX
, EM
, Ib
} },
3020 { "pshufhw",{ XM
, EXx
, Ib
} },
3021 { "pshufd", { XM
, EXx
, Ib
} },
3022 { "pshuflw",{ XM
, EXx
, Ib
} },
3025 /* PREFIX_0F73_REG_3 */
3029 { "psrldq", { XS
, Ib
} },
3032 /* PREFIX_0F73_REG_7 */
3036 { "pslldq", { XS
, Ib
} },
3041 {"vmread", { Em
, Gm
} },
3043 {"extrq", { XS
, Ib
, Ib
} },
3044 {"insertq", { XM
, XS
, Ib
, Ib
} },
3049 {"vmwrite", { Gm
, Em
} },
3051 {"extrq", { XM
, XS
} },
3052 {"insertq", { XM
, XS
} },
3059 { "haddpd", { XM
, EXx
} },
3060 { "haddps", { XM
, EXx
} },
3067 { "hsubpd", { XM
, EXx
} },
3068 { "hsubps", { XM
, EXx
} },
3073 { "movK", { Edq
, MX
} },
3074 { "movq", { XM
, EXq
} },
3075 { "movK", { Edq
, XM
} },
3080 { "movq", { EMS
, MX
} },
3081 { "movdqu", { EXxS
, XM
} },
3082 { "movdqa", { EXxS
, XM
} },
3085 /* PREFIX_0FAE_REG_0 */
3088 { "rdfsbase", { Ev
} },
3091 /* PREFIX_0FAE_REG_1 */
3094 { "rdgsbase", { Ev
} },
3097 /* PREFIX_0FAE_REG_2 */
3100 { "wrfsbase", { Ev
} },
3103 /* PREFIX_0FAE_REG_3 */
3106 { "wrgsbase", { Ev
} },
3112 { "popcntS", { Gv
, Ev
} },
3117 { "bsfS", { Gv
, Ev
} },
3118 { "tzcntS", { Gv
, Ev
} },
3119 { "bsfS", { Gv
, Ev
} },
3124 { "bsrS", { Gv
, Ev
} },
3125 { "lzcntS", { Gv
, Ev
} },
3126 { "bsrS", { Gv
, Ev
} },
3131 { "cmpps", { XM
, EXx
, CMP
} },
3132 { "cmpss", { XM
, EXd
, CMP
} },
3133 { "cmppd", { XM
, EXx
, CMP
} },
3134 { "cmpsd", { XM
, EXq
, CMP
} },
3139 { "movntiS", { Ma
, Gv
} },
3142 /* PREFIX_0FC7_REG_6 */
3144 { "vmptrld",{ Mq
} },
3145 { "vmxon", { Mq
} },
3146 { "vmclear",{ Mq
} },
3153 { "addsubpd", { XM
, EXx
} },
3154 { "addsubps", { XM
, EXx
} },
3160 { "movq2dq",{ XM
, MS
} },
3161 { "movq", { EXqS
, XM
} },
3162 { "movdq2q",{ MX
, XS
} },
3168 { "cvtdq2pd", { XM
, EXq
} },
3169 { "cvttpd2dq", { XM
, EXx
} },
3170 { "cvtpd2dq", { XM
, EXx
} },
3175 { "movntq", { Mq
, MX
} },
3177 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
3185 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
3190 { "maskmovq", { MX
, MS
} },
3192 { "maskmovdqu", { XM
, XS
} },
3199 { "pblendvb", { XM
, EXx
, XMM0
} },
3206 { "blendvps", { XM
, EXx
, XMM0
} },
3213 { "blendvpd", { XM
, EXx
, XMM0
} },
3220 { "ptest", { XM
, EXx
} },
3227 { "pmovsxbw", { XM
, EXq
} },
3234 { "pmovsxbd", { XM
, EXd
} },
3241 { "pmovsxbq", { XM
, EXw
} },
3248 { "pmovsxwd", { XM
, EXq
} },
3255 { "pmovsxwq", { XM
, EXd
} },
3262 { "pmovsxdq", { XM
, EXq
} },
3269 { "pmuldq", { XM
, EXx
} },
3276 { "pcmpeqq", { XM
, EXx
} },
3283 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
3290 { "packusdw", { XM
, EXx
} },
3297 { "pmovzxbw", { XM
, EXq
} },
3304 { "pmovzxbd", { XM
, EXd
} },
3311 { "pmovzxbq", { XM
, EXw
} },
3318 { "pmovzxwd", { XM
, EXq
} },
3325 { "pmovzxwq", { XM
, EXd
} },
3332 { "pmovzxdq", { XM
, EXq
} },
3339 { "pcmpgtq", { XM
, EXx
} },
3346 { "pminsb", { XM
, EXx
} },
3353 { "pminsd", { XM
, EXx
} },
3360 { "pminuw", { XM
, EXx
} },
3367 { "pminud", { XM
, EXx
} },
3374 { "pmaxsb", { XM
, EXx
} },
3381 { "pmaxsd", { XM
, EXx
} },
3388 { "pmaxuw", { XM
, EXx
} },
3395 { "pmaxud", { XM
, EXx
} },
3402 { "pmulld", { XM
, EXx
} },
3409 { "phminposuw", { XM
, EXx
} },
3416 { "invept", { Gm
, Mo
} },
3423 { "invvpid", { Gm
, Mo
} },
3430 { "aesimc", { XM
, EXx
} },
3437 { "aesenc", { XM
, EXx
} },
3444 { "aesenclast", { XM
, EXx
} },
3451 { "aesdec", { XM
, EXx
} },
3458 { "aesdeclast", { XM
, EXx
} },
3463 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3465 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3466 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3471 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3473 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3474 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3481 { "roundps", { XM
, EXx
, Ib
} },
3488 { "roundpd", { XM
, EXx
, Ib
} },
3495 { "roundss", { XM
, EXd
, Ib
} },
3502 { "roundsd", { XM
, EXq
, Ib
} },
3509 { "blendps", { XM
, EXx
, Ib
} },
3516 { "blendpd", { XM
, EXx
, Ib
} },
3523 { "pblendw", { XM
, EXx
, Ib
} },
3530 { "pextrb", { Edqb
, XM
, Ib
} },
3537 { "pextrw", { Edqw
, XM
, Ib
} },
3544 { "pextrK", { Edq
, XM
, Ib
} },
3551 { "extractps", { Edqd
, XM
, Ib
} },
3558 { "pinsrb", { XM
, Edqb
, Ib
} },
3565 { "insertps", { XM
, EXd
, Ib
} },
3572 { "pinsrK", { XM
, Edq
, Ib
} },
3579 { "dpps", { XM
, EXx
, Ib
} },
3586 { "dppd", { XM
, EXx
, Ib
} },
3593 { "mpsadbw", { XM
, EXx
, Ib
} },
3600 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3607 { "pcmpestrm", { XM
, EXx
, Ib
} },
3614 { "pcmpestri", { XM
, EXx
, Ib
} },
3621 { "pcmpistrm", { XM
, EXx
, Ib
} },
3628 { "pcmpistri", { XM
, EXx
, Ib
} },
3635 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3638 /* PREFIX_VEX_0F10 */
3640 { VEX_W_TABLE (VEX_W_0F10_P_0
) },
3641 { VEX_LEN_TABLE (VEX_LEN_0F10_P_1
) },
3642 { VEX_W_TABLE (VEX_W_0F10_P_2
) },
3643 { VEX_LEN_TABLE (VEX_LEN_0F10_P_3
) },
3646 /* PREFIX_VEX_0F11 */
3648 { VEX_W_TABLE (VEX_W_0F11_P_0
) },
3649 { VEX_LEN_TABLE (VEX_LEN_0F11_P_1
) },
3650 { VEX_W_TABLE (VEX_W_0F11_P_2
) },
3651 { VEX_LEN_TABLE (VEX_LEN_0F11_P_3
) },
3654 /* PREFIX_VEX_0F12 */
3656 { MOD_TABLE (MOD_VEX_0F12_PREFIX_0
) },
3657 { VEX_W_TABLE (VEX_W_0F12_P_1
) },
3658 { VEX_LEN_TABLE (VEX_LEN_0F12_P_2
) },
3659 { VEX_W_TABLE (VEX_W_0F12_P_3
) },
3662 /* PREFIX_VEX_0F16 */
3664 { MOD_TABLE (MOD_VEX_0F16_PREFIX_0
) },
3665 { VEX_W_TABLE (VEX_W_0F16_P_1
) },
3666 { VEX_LEN_TABLE (VEX_LEN_0F16_P_2
) },
3669 /* PREFIX_VEX_0F2A */
3672 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_1
) },
3674 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_3
) },
3677 /* PREFIX_VEX_0F2C */
3680 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_1
) },
3682 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_3
) },
3685 /* PREFIX_VEX_0F2D */
3688 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_1
) },
3690 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_3
) },
3693 /* PREFIX_VEX_0F2E */
3695 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_0
) },
3697 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_2
) },
3700 /* PREFIX_VEX_0F2F */
3702 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_0
) },
3704 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_2
) },
3707 /* PREFIX_VEX_0F51 */
3709 { VEX_W_TABLE (VEX_W_0F51_P_0
) },
3710 { VEX_LEN_TABLE (VEX_LEN_0F51_P_1
) },
3711 { VEX_W_TABLE (VEX_W_0F51_P_2
) },
3712 { VEX_LEN_TABLE (VEX_LEN_0F51_P_3
) },
3715 /* PREFIX_VEX_0F52 */
3717 { VEX_W_TABLE (VEX_W_0F52_P_0
) },
3718 { VEX_LEN_TABLE (VEX_LEN_0F52_P_1
) },
3721 /* PREFIX_VEX_0F53 */
3723 { VEX_W_TABLE (VEX_W_0F53_P_0
) },
3724 { VEX_LEN_TABLE (VEX_LEN_0F53_P_1
) },
3727 /* PREFIX_VEX_0F58 */
3729 { VEX_W_TABLE (VEX_W_0F58_P_0
) },
3730 { VEX_LEN_TABLE (VEX_LEN_0F58_P_1
) },
3731 { VEX_W_TABLE (VEX_W_0F58_P_2
) },
3732 { VEX_LEN_TABLE (VEX_LEN_0F58_P_3
) },
3735 /* PREFIX_VEX_0F59 */
3737 { VEX_W_TABLE (VEX_W_0F59_P_0
) },
3738 { VEX_LEN_TABLE (VEX_LEN_0F59_P_1
) },
3739 { VEX_W_TABLE (VEX_W_0F59_P_2
) },
3740 { VEX_LEN_TABLE (VEX_LEN_0F59_P_3
) },
3743 /* PREFIX_VEX_0F5A */
3745 { VEX_W_TABLE (VEX_W_0F5A_P_0
) },
3746 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_1
) },
3747 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3748 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_3
) },
3751 /* PREFIX_VEX_0F5B */
3753 { VEX_W_TABLE (VEX_W_0F5B_P_0
) },
3754 { VEX_W_TABLE (VEX_W_0F5B_P_1
) },
3755 { VEX_W_TABLE (VEX_W_0F5B_P_2
) },
3758 /* PREFIX_VEX_0F5C */
3760 { VEX_W_TABLE (VEX_W_0F5C_P_0
) },
3761 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_1
) },
3762 { VEX_W_TABLE (VEX_W_0F5C_P_2
) },
3763 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_3
) },
3766 /* PREFIX_VEX_0F5D */
3768 { VEX_W_TABLE (VEX_W_0F5D_P_0
) },
3769 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_1
) },
3770 { VEX_W_TABLE (VEX_W_0F5D_P_2
) },
3771 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_3
) },
3774 /* PREFIX_VEX_0F5E */
3776 { VEX_W_TABLE (VEX_W_0F5E_P_0
) },
3777 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_1
) },
3778 { VEX_W_TABLE (VEX_W_0F5E_P_2
) },
3779 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_3
) },
3782 /* PREFIX_VEX_0F5F */
3784 { VEX_W_TABLE (VEX_W_0F5F_P_0
) },
3785 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_1
) },
3786 { VEX_W_TABLE (VEX_W_0F5F_P_2
) },
3787 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_3
) },
3790 /* PREFIX_VEX_0F60 */
3794 { VEX_LEN_TABLE (VEX_LEN_0F60_P_2
) },
3797 /* PREFIX_VEX_0F61 */
3801 { VEX_LEN_TABLE (VEX_LEN_0F61_P_2
) },
3804 /* PREFIX_VEX_0F62 */
3808 { VEX_LEN_TABLE (VEX_LEN_0F62_P_2
) },
3811 /* PREFIX_VEX_0F63 */
3815 { VEX_LEN_TABLE (VEX_LEN_0F63_P_2
) },
3818 /* PREFIX_VEX_0F64 */
3822 { VEX_LEN_TABLE (VEX_LEN_0F64_P_2
) },
3825 /* PREFIX_VEX_0F65 */
3829 { VEX_LEN_TABLE (VEX_LEN_0F65_P_2
) },
3832 /* PREFIX_VEX_0F66 */
3836 { VEX_LEN_TABLE (VEX_LEN_0F66_P_2
) },
3839 /* PREFIX_VEX_0F67 */
3843 { VEX_LEN_TABLE (VEX_LEN_0F67_P_2
) },
3846 /* PREFIX_VEX_0F68 */
3850 { VEX_LEN_TABLE (VEX_LEN_0F68_P_2
) },
3853 /* PREFIX_VEX_0F69 */
3857 { VEX_LEN_TABLE (VEX_LEN_0F69_P_2
) },
3860 /* PREFIX_VEX_0F6A */
3864 { VEX_LEN_TABLE (VEX_LEN_0F6A_P_2
) },
3867 /* PREFIX_VEX_0F6B */
3871 { VEX_LEN_TABLE (VEX_LEN_0F6B_P_2
) },
3874 /* PREFIX_VEX_0F6C */
3878 { VEX_LEN_TABLE (VEX_LEN_0F6C_P_2
) },
3881 /* PREFIX_VEX_0F6D */
3885 { VEX_LEN_TABLE (VEX_LEN_0F6D_P_2
) },
3888 /* PREFIX_VEX_0F6E */
3892 { VEX_LEN_TABLE (VEX_LEN_0F6E_P_2
) },
3895 /* PREFIX_VEX_0F6F */
3898 { VEX_W_TABLE (VEX_W_0F6F_P_1
) },
3899 { VEX_W_TABLE (VEX_W_0F6F_P_2
) },
3902 /* PREFIX_VEX_0F70 */
3905 { VEX_LEN_TABLE (VEX_LEN_0F70_P_1
) },
3906 { VEX_LEN_TABLE (VEX_LEN_0F70_P_2
) },
3907 { VEX_LEN_TABLE (VEX_LEN_0F70_P_3
) },
3910 /* PREFIX_VEX_0F71_REG_2 */
3914 { VEX_LEN_TABLE (VEX_LEN_0F71_R_2_P_2
) },
3917 /* PREFIX_VEX_0F71_REG_4 */
3921 { VEX_LEN_TABLE (VEX_LEN_0F71_R_4_P_2
) },
3924 /* PREFIX_VEX_0F71_REG_6 */
3928 { VEX_LEN_TABLE (VEX_LEN_0F71_R_6_P_2
) },
3931 /* PREFIX_VEX_0F72_REG_2 */
3935 { VEX_LEN_TABLE (VEX_LEN_0F72_R_2_P_2
) },
3938 /* PREFIX_VEX_0F72_REG_4 */
3942 { VEX_LEN_TABLE (VEX_LEN_0F72_R_4_P_2
) },
3945 /* PREFIX_VEX_0F72_REG_6 */
3949 { VEX_LEN_TABLE (VEX_LEN_0F72_R_6_P_2
) },
3952 /* PREFIX_VEX_0F73_REG_2 */
3956 { VEX_LEN_TABLE (VEX_LEN_0F73_R_2_P_2
) },
3959 /* PREFIX_VEX_0F73_REG_3 */
3963 { VEX_LEN_TABLE (VEX_LEN_0F73_R_3_P_2
) },
3966 /* PREFIX_VEX_0F73_REG_6 */
3970 { VEX_LEN_TABLE (VEX_LEN_0F73_R_6_P_2
) },
3973 /* PREFIX_VEX_0F73_REG_7 */
3977 { VEX_LEN_TABLE (VEX_LEN_0F73_R_7_P_2
) },
3980 /* PREFIX_VEX_0F74 */
3984 { VEX_LEN_TABLE (VEX_LEN_0F74_P_2
) },
3987 /* PREFIX_VEX_0F75 */
3991 { VEX_LEN_TABLE (VEX_LEN_0F75_P_2
) },
3994 /* PREFIX_VEX_0F76 */
3998 { VEX_LEN_TABLE (VEX_LEN_0F76_P_2
) },
4001 /* PREFIX_VEX_0F77 */
4003 { VEX_W_TABLE (VEX_W_0F77_P_0
) },
4006 /* PREFIX_VEX_0F7C */
4010 { VEX_W_TABLE (VEX_W_0F7C_P_2
) },
4011 { VEX_W_TABLE (VEX_W_0F7C_P_3
) },
4014 /* PREFIX_VEX_0F7D */
4018 { VEX_W_TABLE (VEX_W_0F7D_P_2
) },
4019 { VEX_W_TABLE (VEX_W_0F7D_P_3
) },
4022 /* PREFIX_VEX_0F7E */
4025 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_1
) },
4026 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_2
) },
4029 /* PREFIX_VEX_0F7F */
4032 { VEX_W_TABLE (VEX_W_0F7F_P_1
) },
4033 { VEX_W_TABLE (VEX_W_0F7F_P_2
) },
4036 /* PREFIX_VEX_0FC2 */
4038 { VEX_W_TABLE (VEX_W_0FC2_P_0
) },
4039 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_1
) },
4040 { VEX_W_TABLE (VEX_W_0FC2_P_2
) },
4041 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_3
) },
4044 /* PREFIX_VEX_0FC4 */
4048 { VEX_LEN_TABLE (VEX_LEN_0FC4_P_2
) },
4051 /* PREFIX_VEX_0FC5 */
4055 { VEX_LEN_TABLE (VEX_LEN_0FC5_P_2
) },
4058 /* PREFIX_VEX_0FD0 */
4062 { VEX_W_TABLE (VEX_W_0FD0_P_2
) },
4063 { VEX_W_TABLE (VEX_W_0FD0_P_3
) },
4066 /* PREFIX_VEX_0FD1 */
4070 { VEX_LEN_TABLE (VEX_LEN_0FD1_P_2
) },
4073 /* PREFIX_VEX_0FD2 */
4077 { VEX_LEN_TABLE (VEX_LEN_0FD2_P_2
) },
4080 /* PREFIX_VEX_0FD3 */
4084 { VEX_LEN_TABLE (VEX_LEN_0FD3_P_2
) },
4087 /* PREFIX_VEX_0FD4 */
4091 { VEX_LEN_TABLE (VEX_LEN_0FD4_P_2
) },
4094 /* PREFIX_VEX_0FD5 */
4098 { VEX_LEN_TABLE (VEX_LEN_0FD5_P_2
) },
4101 /* PREFIX_VEX_0FD6 */
4105 { VEX_LEN_TABLE (VEX_LEN_0FD6_P_2
) },
4108 /* PREFIX_VEX_0FD7 */
4112 { MOD_TABLE (MOD_VEX_0FD7_PREFIX_2
) },
4115 /* PREFIX_VEX_0FD8 */
4119 { VEX_LEN_TABLE (VEX_LEN_0FD8_P_2
) },
4122 /* PREFIX_VEX_0FD9 */
4126 { VEX_LEN_TABLE (VEX_LEN_0FD9_P_2
) },
4129 /* PREFIX_VEX_0FDA */
4133 { VEX_LEN_TABLE (VEX_LEN_0FDA_P_2
) },
4136 /* PREFIX_VEX_0FDB */
4140 { VEX_LEN_TABLE (VEX_LEN_0FDB_P_2
) },
4143 /* PREFIX_VEX_0FDC */
4147 { VEX_LEN_TABLE (VEX_LEN_0FDC_P_2
) },
4150 /* PREFIX_VEX_0FDD */
4154 { VEX_LEN_TABLE (VEX_LEN_0FDD_P_2
) },
4157 /* PREFIX_VEX_0FDE */
4161 { VEX_LEN_TABLE (VEX_LEN_0FDE_P_2
) },
4164 /* PREFIX_VEX_0FDF */
4168 { VEX_LEN_TABLE (VEX_LEN_0FDF_P_2
) },
4171 /* PREFIX_VEX_0FE0 */
4175 { VEX_LEN_TABLE (VEX_LEN_0FE0_P_2
) },
4178 /* PREFIX_VEX_0FE1 */
4182 { VEX_LEN_TABLE (VEX_LEN_0FE1_P_2
) },
4185 /* PREFIX_VEX_0FE2 */
4189 { VEX_LEN_TABLE (VEX_LEN_0FE2_P_2
) },
4192 /* PREFIX_VEX_0FE3 */
4196 { VEX_LEN_TABLE (VEX_LEN_0FE3_P_2
) },
4199 /* PREFIX_VEX_0FE4 */
4203 { VEX_LEN_TABLE (VEX_LEN_0FE4_P_2
) },
4206 /* PREFIX_VEX_0FE5 */
4210 { VEX_LEN_TABLE (VEX_LEN_0FE5_P_2
) },
4213 /* PREFIX_VEX_0FE6 */
4216 { VEX_W_TABLE (VEX_W_0FE6_P_1
) },
4217 { VEX_W_TABLE (VEX_W_0FE6_P_2
) },
4218 { VEX_W_TABLE (VEX_W_0FE6_P_3
) },
4221 /* PREFIX_VEX_0FE7 */
4225 { MOD_TABLE (MOD_VEX_0FE7_PREFIX_2
) },
4228 /* PREFIX_VEX_0FE8 */
4232 { VEX_LEN_TABLE (VEX_LEN_0FE8_P_2
) },
4235 /* PREFIX_VEX_0FE9 */
4239 { VEX_LEN_TABLE (VEX_LEN_0FE9_P_2
) },
4242 /* PREFIX_VEX_0FEA */
4246 { VEX_LEN_TABLE (VEX_LEN_0FEA_P_2
) },
4249 /* PREFIX_VEX_0FEB */
4253 { VEX_LEN_TABLE (VEX_LEN_0FEB_P_2
) },
4256 /* PREFIX_VEX_0FEC */
4260 { VEX_LEN_TABLE (VEX_LEN_0FEC_P_2
) },
4263 /* PREFIX_VEX_0FED */
4267 { VEX_LEN_TABLE (VEX_LEN_0FED_P_2
) },
4270 /* PREFIX_VEX_0FEE */
4274 { VEX_LEN_TABLE (VEX_LEN_0FEE_P_2
) },
4277 /* PREFIX_VEX_0FEF */
4281 { VEX_LEN_TABLE (VEX_LEN_0FEF_P_2
) },
4284 /* PREFIX_VEX_0FF0 */
4289 { MOD_TABLE (MOD_VEX_0FF0_PREFIX_3
) },
4292 /* PREFIX_VEX_0FF1 */
4296 { VEX_LEN_TABLE (VEX_LEN_0FF1_P_2
) },
4299 /* PREFIX_VEX_0FF2 */
4303 { VEX_LEN_TABLE (VEX_LEN_0FF2_P_2
) },
4306 /* PREFIX_VEX_0FF3 */
4310 { VEX_LEN_TABLE (VEX_LEN_0FF3_P_2
) },
4313 /* PREFIX_VEX_0FF4 */
4317 { VEX_LEN_TABLE (VEX_LEN_0FF4_P_2
) },
4320 /* PREFIX_VEX_0FF5 */
4324 { VEX_LEN_TABLE (VEX_LEN_0FF5_P_2
) },
4327 /* PREFIX_VEX_0FF6 */
4331 { VEX_LEN_TABLE (VEX_LEN_0FF6_P_2
) },
4334 /* PREFIX_VEX_0FF7 */
4338 { VEX_LEN_TABLE (VEX_LEN_0FF7_P_2
) },
4341 /* PREFIX_VEX_0FF8 */
4345 { VEX_LEN_TABLE (VEX_LEN_0FF8_P_2
) },
4348 /* PREFIX_VEX_0FF9 */
4352 { VEX_LEN_TABLE (VEX_LEN_0FF9_P_2
) },
4355 /* PREFIX_VEX_0FFA */
4359 { VEX_LEN_TABLE (VEX_LEN_0FFA_P_2
) },
4362 /* PREFIX_VEX_0FFB */
4366 { VEX_LEN_TABLE (VEX_LEN_0FFB_P_2
) },
4369 /* PREFIX_VEX_0FFC */
4373 { VEX_LEN_TABLE (VEX_LEN_0FFC_P_2
) },
4376 /* PREFIX_VEX_0FFD */
4380 { VEX_LEN_TABLE (VEX_LEN_0FFD_P_2
) },
4383 /* PREFIX_VEX_0FFE */
4387 { VEX_LEN_TABLE (VEX_LEN_0FFE_P_2
) },
4390 /* PREFIX_VEX_0F3800 */
4394 { VEX_LEN_TABLE (VEX_LEN_0F3800_P_2
) },
4397 /* PREFIX_VEX_0F3801 */
4401 { VEX_LEN_TABLE (VEX_LEN_0F3801_P_2
) },
4404 /* PREFIX_VEX_0F3802 */
4408 { VEX_LEN_TABLE (VEX_LEN_0F3802_P_2
) },
4411 /* PREFIX_VEX_0F3803 */
4415 { VEX_LEN_TABLE (VEX_LEN_0F3803_P_2
) },
4418 /* PREFIX_VEX_0F3804 */
4422 { VEX_LEN_TABLE (VEX_LEN_0F3804_P_2
) },
4425 /* PREFIX_VEX_0F3805 */
4429 { VEX_LEN_TABLE (VEX_LEN_0F3805_P_2
) },
4432 /* PREFIX_VEX_0F3806 */
4436 { VEX_LEN_TABLE (VEX_LEN_0F3806_P_2
) },
4439 /* PREFIX_VEX_0F3807 */
4443 { VEX_LEN_TABLE (VEX_LEN_0F3807_P_2
) },
4446 /* PREFIX_VEX_0F3808 */
4450 { VEX_LEN_TABLE (VEX_LEN_0F3808_P_2
) },
4453 /* PREFIX_VEX_0F3809 */
4457 { VEX_LEN_TABLE (VEX_LEN_0F3809_P_2
) },
4460 /* PREFIX_VEX_0F380A */
4464 { VEX_LEN_TABLE (VEX_LEN_0F380A_P_2
) },
4467 /* PREFIX_VEX_0F380B */
4471 { VEX_LEN_TABLE (VEX_LEN_0F380B_P_2
) },
4474 /* PREFIX_VEX_0F380C */
4478 { VEX_W_TABLE (VEX_W_0F380C_P_2
) },
4481 /* PREFIX_VEX_0F380D */
4485 { VEX_W_TABLE (VEX_W_0F380D_P_2
) },
4488 /* PREFIX_VEX_0F380E */
4492 { VEX_W_TABLE (VEX_W_0F380E_P_2
) },
4495 /* PREFIX_VEX_0F380F */
4499 { VEX_W_TABLE (VEX_W_0F380F_P_2
) },
4502 /* PREFIX_VEX_0F3813 */
4506 { "vcvtph2ps", { XM
, EXxmmq
} },
4509 /* PREFIX_VEX_0F3817 */
4513 { VEX_W_TABLE (VEX_W_0F3817_P_2
) },
4516 /* PREFIX_VEX_0F3818 */
4520 { MOD_TABLE (MOD_VEX_0F3818_PREFIX_2
) },
4523 /* PREFIX_VEX_0F3819 */
4527 { MOD_TABLE (MOD_VEX_0F3819_PREFIX_2
) },
4530 /* PREFIX_VEX_0F381A */
4534 { MOD_TABLE (MOD_VEX_0F381A_PREFIX_2
) },
4537 /* PREFIX_VEX_0F381C */
4541 { VEX_LEN_TABLE (VEX_LEN_0F381C_P_2
) },
4544 /* PREFIX_VEX_0F381D */
4548 { VEX_LEN_TABLE (VEX_LEN_0F381D_P_2
) },
4551 /* PREFIX_VEX_0F381E */
4555 { VEX_LEN_TABLE (VEX_LEN_0F381E_P_2
) },
4558 /* PREFIX_VEX_0F3820 */
4562 { VEX_LEN_TABLE (VEX_LEN_0F3820_P_2
) },
4565 /* PREFIX_VEX_0F3821 */
4569 { VEX_LEN_TABLE (VEX_LEN_0F3821_P_2
) },
4572 /* PREFIX_VEX_0F3822 */
4576 { VEX_LEN_TABLE (VEX_LEN_0F3822_P_2
) },
4579 /* PREFIX_VEX_0F3823 */
4583 { VEX_LEN_TABLE (VEX_LEN_0F3823_P_2
) },
4586 /* PREFIX_VEX_0F3824 */
4590 { VEX_LEN_TABLE (VEX_LEN_0F3824_P_2
) },
4593 /* PREFIX_VEX_0F3825 */
4597 { VEX_LEN_TABLE (VEX_LEN_0F3825_P_2
) },
4600 /* PREFIX_VEX_0F3828 */
4604 { VEX_LEN_TABLE (VEX_LEN_0F3828_P_2
) },
4607 /* PREFIX_VEX_0F3829 */
4611 { VEX_LEN_TABLE (VEX_LEN_0F3829_P_2
) },
4614 /* PREFIX_VEX_0F382A */
4618 { MOD_TABLE (MOD_VEX_0F382A_PREFIX_2
) },
4621 /* PREFIX_VEX_0F382B */
4625 { VEX_LEN_TABLE (VEX_LEN_0F382B_P_2
) },
4628 /* PREFIX_VEX_0F382C */
4632 { MOD_TABLE (MOD_VEX_0F382C_PREFIX_2
) },
4635 /* PREFIX_VEX_0F382D */
4639 { MOD_TABLE (MOD_VEX_0F382D_PREFIX_2
) },
4642 /* PREFIX_VEX_0F382E */
4646 { MOD_TABLE (MOD_VEX_0F382E_PREFIX_2
) },
4649 /* PREFIX_VEX_0F382F */
4653 { MOD_TABLE (MOD_VEX_0F382F_PREFIX_2
) },
4656 /* PREFIX_VEX_0F3830 */
4660 { VEX_LEN_TABLE (VEX_LEN_0F3830_P_2
) },
4663 /* PREFIX_VEX_0F3831 */
4667 { VEX_LEN_TABLE (VEX_LEN_0F3831_P_2
) },
4670 /* PREFIX_VEX_0F3832 */
4674 { VEX_LEN_TABLE (VEX_LEN_0F3832_P_2
) },
4677 /* PREFIX_VEX_0F3833 */
4681 { VEX_LEN_TABLE (VEX_LEN_0F3833_P_2
) },
4684 /* PREFIX_VEX_0F3834 */
4688 { VEX_LEN_TABLE (VEX_LEN_0F3834_P_2
) },
4691 /* PREFIX_VEX_0F3835 */
4695 { VEX_LEN_TABLE (VEX_LEN_0F3835_P_2
) },
4698 /* PREFIX_VEX_0F3837 */
4702 { VEX_LEN_TABLE (VEX_LEN_0F3837_P_2
) },
4705 /* PREFIX_VEX_0F3838 */
4709 { VEX_LEN_TABLE (VEX_LEN_0F3838_P_2
) },
4712 /* PREFIX_VEX_0F3839 */
4716 { VEX_LEN_TABLE (VEX_LEN_0F3839_P_2
) },
4719 /* PREFIX_VEX_0F383A */
4723 { VEX_LEN_TABLE (VEX_LEN_0F383A_P_2
) },
4726 /* PREFIX_VEX_0F383B */
4730 { VEX_LEN_TABLE (VEX_LEN_0F383B_P_2
) },
4733 /* PREFIX_VEX_0F383C */
4737 { VEX_LEN_TABLE (VEX_LEN_0F383C_P_2
) },
4740 /* PREFIX_VEX_0F383D */
4744 { VEX_LEN_TABLE (VEX_LEN_0F383D_P_2
) },
4747 /* PREFIX_VEX_0F383E */
4751 { VEX_LEN_TABLE (VEX_LEN_0F383E_P_2
) },
4754 /* PREFIX_VEX_0F383F */
4758 { VEX_LEN_TABLE (VEX_LEN_0F383F_P_2
) },
4761 /* PREFIX_VEX_0F3840 */
4765 { VEX_LEN_TABLE (VEX_LEN_0F3840_P_2
) },
4768 /* PREFIX_VEX_0F3841 */
4772 { VEX_LEN_TABLE (VEX_LEN_0F3841_P_2
) },
4775 /* PREFIX_VEX_0F3896 */
4779 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4782 /* PREFIX_VEX_0F3897 */
4786 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4789 /* PREFIX_VEX_0F3898 */
4793 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4796 /* PREFIX_VEX_0F3899 */
4800 { "vfmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4803 /* PREFIX_VEX_0F389A */
4807 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4810 /* PREFIX_VEX_0F389B */
4814 { "vfmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4817 /* PREFIX_VEX_0F389C */
4821 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4824 /* PREFIX_VEX_0F389D */
4828 { "vfnmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4831 /* PREFIX_VEX_0F389E */
4835 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4838 /* PREFIX_VEX_0F389F */
4842 { "vfnmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4845 /* PREFIX_VEX_0F38A6 */
4849 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4853 /* PREFIX_VEX_0F38A7 */
4857 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4860 /* PREFIX_VEX_0F38A8 */
4864 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4867 /* PREFIX_VEX_0F38A9 */
4871 { "vfmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4874 /* PREFIX_VEX_0F38AA */
4878 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4881 /* PREFIX_VEX_0F38AB */
4885 { "vfmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4888 /* PREFIX_VEX_0F38AC */
4892 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4895 /* PREFIX_VEX_0F38AD */
4899 { "vfnmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4902 /* PREFIX_VEX_0F38AE */
4906 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4909 /* PREFIX_VEX_0F38AF */
4913 { "vfnmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4916 /* PREFIX_VEX_0F38B6 */
4920 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4923 /* PREFIX_VEX_0F38B7 */
4927 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4930 /* PREFIX_VEX_0F38B8 */
4934 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4937 /* PREFIX_VEX_0F38B9 */
4941 { "vfmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4944 /* PREFIX_VEX_0F38BA */
4948 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4951 /* PREFIX_VEX_0F38BB */
4955 { "vfmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4958 /* PREFIX_VEX_0F38BC */
4962 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4965 /* PREFIX_VEX_0F38BD */
4969 { "vfnmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4972 /* PREFIX_VEX_0F38BE */
4976 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4979 /* PREFIX_VEX_0F38BF */
4983 { "vfnmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4986 /* PREFIX_VEX_0F38DB */
4990 { VEX_LEN_TABLE (VEX_LEN_0F38DB_P_2
) },
4993 /* PREFIX_VEX_0F38DC */
4997 { VEX_LEN_TABLE (VEX_LEN_0F38DC_P_2
) },
5000 /* PREFIX_VEX_0F38DD */
5004 { VEX_LEN_TABLE (VEX_LEN_0F38DD_P_2
) },
5007 /* PREFIX_VEX_0F38DE */
5011 { VEX_LEN_TABLE (VEX_LEN_0F38DE_P_2
) },
5014 /* PREFIX_VEX_0F38DF */
5018 { VEX_LEN_TABLE (VEX_LEN_0F38DF_P_2
) },
5021 /* PREFIX_VEX_0F38F2 */
5023 { VEX_LEN_TABLE (VEX_LEN_0F38F2_P_0
) },
5026 /* PREFIX_VEX_0F38F3_REG_1 */
5028 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_1_P_0
) },
5031 /* PREFIX_VEX_0F38F3_REG_2 */
5033 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_2_P_0
) },
5036 /* PREFIX_VEX_0F38F3_REG_3 */
5038 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_3_P_0
) },
5041 /* PREFIX_VEX_0F38F7 */
5043 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_0
) },
5046 /* PREFIX_VEX_0F3A04 */
5050 { VEX_W_TABLE (VEX_W_0F3A04_P_2
) },
5053 /* PREFIX_VEX_0F3A05 */
5057 { VEX_W_TABLE (VEX_W_0F3A05_P_2
) },
5060 /* PREFIX_VEX_0F3A06 */
5064 { VEX_LEN_TABLE (VEX_LEN_0F3A06_P_2
) },
5067 /* PREFIX_VEX_0F3A08 */
5071 { VEX_W_TABLE (VEX_W_0F3A08_P_2
) },
5074 /* PREFIX_VEX_0F3A09 */
5078 { VEX_W_TABLE (VEX_W_0F3A09_P_2
) },
5081 /* PREFIX_VEX_0F3A0A */
5085 { VEX_LEN_TABLE (VEX_LEN_0F3A0A_P_2
) },
5088 /* PREFIX_VEX_0F3A0B */
5092 { VEX_LEN_TABLE (VEX_LEN_0F3A0B_P_2
) },
5095 /* PREFIX_VEX_0F3A0C */
5099 { VEX_W_TABLE (VEX_W_0F3A0C_P_2
) },
5102 /* PREFIX_VEX_0F3A0D */
5106 { VEX_W_TABLE (VEX_W_0F3A0D_P_2
) },
5109 /* PREFIX_VEX_0F3A0E */
5113 { VEX_LEN_TABLE (VEX_LEN_0F3A0E_P_2
) },
5116 /* PREFIX_VEX_0F3A0F */
5120 { VEX_LEN_TABLE (VEX_LEN_0F3A0F_P_2
) },
5123 /* PREFIX_VEX_0F3A14 */
5127 { VEX_LEN_TABLE (VEX_LEN_0F3A14_P_2
) },
5130 /* PREFIX_VEX_0F3A15 */
5134 { VEX_LEN_TABLE (VEX_LEN_0F3A15_P_2
) },
5137 /* PREFIX_VEX_0F3A16 */
5141 { VEX_LEN_TABLE (VEX_LEN_0F3A16_P_2
) },
5144 /* PREFIX_VEX_0F3A17 */
5148 { VEX_LEN_TABLE (VEX_LEN_0F3A17_P_2
) },
5151 /* PREFIX_VEX_0F3A18 */
5155 { VEX_LEN_TABLE (VEX_LEN_0F3A18_P_2
) },
5158 /* PREFIX_VEX_0F3A19 */
5162 { VEX_LEN_TABLE (VEX_LEN_0F3A19_P_2
) },
5165 /* PREFIX_VEX_0F3A1D */
5169 { "vcvtps2ph", { EXxmmq
, XM
, Ib
} },
5172 /* PREFIX_VEX_0F3A20 */
5176 { VEX_LEN_TABLE (VEX_LEN_0F3A20_P_2
) },
5179 /* PREFIX_VEX_0F3A21 */
5183 { VEX_LEN_TABLE (VEX_LEN_0F3A21_P_2
) },
5186 /* PREFIX_VEX_0F3A22 */
5190 { VEX_LEN_TABLE (VEX_LEN_0F3A22_P_2
) },
5193 /* PREFIX_VEX_0F3A40 */
5197 { VEX_W_TABLE (VEX_W_0F3A40_P_2
) },
5200 /* PREFIX_VEX_0F3A41 */
5204 { VEX_LEN_TABLE (VEX_LEN_0F3A41_P_2
) },
5207 /* PREFIX_VEX_0F3A42 */
5211 { VEX_LEN_TABLE (VEX_LEN_0F3A42_P_2
) },
5214 /* PREFIX_VEX_0F3A44 */
5218 { VEX_LEN_TABLE (VEX_LEN_0F3A44_P_2
) },
5221 /* PREFIX_VEX_0F3A48 */
5225 { VEX_W_TABLE (VEX_W_0F3A48_P_2
) },
5228 /* PREFIX_VEX_0F3A49 */
5232 { VEX_W_TABLE (VEX_W_0F3A49_P_2
) },
5235 /* PREFIX_VEX_0F3A4A */
5239 { VEX_W_TABLE (VEX_W_0F3A4A_P_2
) },
5242 /* PREFIX_VEX_0F3A4B */
5246 { VEX_W_TABLE (VEX_W_0F3A4B_P_2
) },
5249 /* PREFIX_VEX_0F3A4C */
5253 { VEX_LEN_TABLE (VEX_LEN_0F3A4C_P_2
) },
5256 /* PREFIX_VEX_0F3A5C */
5260 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5263 /* PREFIX_VEX_0F3A5D */
5267 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5270 /* PREFIX_VEX_0F3A5E */
5274 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5277 /* PREFIX_VEX_0F3A5F */
5281 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5284 /* PREFIX_VEX_0F3A60 */
5288 { VEX_LEN_TABLE (VEX_LEN_0F3A60_P_2
) },
5292 /* PREFIX_VEX_0F3A61 */
5296 { VEX_LEN_TABLE (VEX_LEN_0F3A61_P_2
) },
5299 /* PREFIX_VEX_0F3A62 */
5303 { VEX_LEN_TABLE (VEX_LEN_0F3A62_P_2
) },
5306 /* PREFIX_VEX_0F3A63 */
5310 { VEX_LEN_TABLE (VEX_LEN_0F3A63_P_2
) },
5313 /* PREFIX_VEX_0F3A68 */
5317 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5320 /* PREFIX_VEX_0F3A69 */
5324 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5327 /* PREFIX_VEX_0F3A6A */
5331 { VEX_LEN_TABLE (VEX_LEN_0F3A6A_P_2
) },
5334 /* PREFIX_VEX_0F3A6B */
5338 { VEX_LEN_TABLE (VEX_LEN_0F3A6B_P_2
) },
5341 /* PREFIX_VEX_0F3A6C */
5345 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5348 /* PREFIX_VEX_0F3A6D */
5352 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5355 /* PREFIX_VEX_0F3A6E */
5359 { VEX_LEN_TABLE (VEX_LEN_0F3A6E_P_2
) },
5362 /* PREFIX_VEX_0F3A6F */
5366 { VEX_LEN_TABLE (VEX_LEN_0F3A6F_P_2
) },
5369 /* PREFIX_VEX_0F3A78 */
5373 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5376 /* PREFIX_VEX_0F3A79 */
5380 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5383 /* PREFIX_VEX_0F3A7A */
5387 { VEX_LEN_TABLE (VEX_LEN_0F3A7A_P_2
) },
5390 /* PREFIX_VEX_0F3A7B */
5394 { VEX_LEN_TABLE (VEX_LEN_0F3A7B_P_2
) },
5397 /* PREFIX_VEX_0F3A7C */
5401 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5405 /* PREFIX_VEX_0F3A7D */
5409 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5412 /* PREFIX_VEX_0F3A7E */
5416 { VEX_LEN_TABLE (VEX_LEN_0F3A7E_P_2
) },
5419 /* PREFIX_VEX_0F3A7F */
5423 { VEX_LEN_TABLE (VEX_LEN_0F3A7F_P_2
) },
5426 /* PREFIX_VEX_0F3ADF */
5430 { VEX_LEN_TABLE (VEX_LEN_0F3ADF_P_2
) },
5434 static const struct dis386 x86_64_table
[][2] = {
5437 { "pushP", { es
} },
5447 { "pushP", { cs
} },
5452 { "pushP", { ss
} },
5462 { "pushP", { ds
} },
5492 { "pushaP", { XX
} },
5497 { "popaP", { XX
} },
5502 { MOD_TABLE (MOD_62_32BIT
) },
5507 { "arpl", { Ew
, Gw
} },
5508 { "movs{lq|xd}", { Gv
, Ed
} },
5513 { "ins{R|}", { Yzr
, indirDX
} },
5514 { "ins{G|}", { Yzr
, indirDX
} },
5519 { "outs{R|}", { indirDXr
, Xz
} },
5520 { "outs{G|}", { indirDXr
, Xz
} },
5525 { "Jcall{T|}", { Ap
} },
5530 { MOD_TABLE (MOD_C4_32BIT
) },
5531 { VEX_C4_TABLE (VEX_0F
) },
5536 { MOD_TABLE (MOD_C5_32BIT
) },
5537 { VEX_C5_TABLE (VEX_0F
) },
5557 { "Jjmp{T|}", { Ap
} },
5560 /* X86_64_0F01_REG_0 */
5562 { "sgdt{Q|IQ}", { M
} },
5566 /* X86_64_0F01_REG_1 */
5568 { "sidt{Q|IQ}", { M
} },
5572 /* X86_64_0F01_REG_2 */
5574 { "lgdt{Q|Q}", { M
} },
5578 /* X86_64_0F01_REG_3 */
5580 { "lidt{Q|Q}", { M
} },
5585 static const struct dis386 three_byte_table
[][256] = {
5587 /* THREE_BYTE_0F38 */
5590 { "pshufb", { MX
, EM
} },
5591 { "phaddw", { MX
, EM
} },
5592 { "phaddd", { MX
, EM
} },
5593 { "phaddsw", { MX
, EM
} },
5594 { "pmaddubsw", { MX
, EM
} },
5595 { "phsubw", { MX
, EM
} },
5596 { "phsubd", { MX
, EM
} },
5597 { "phsubsw", { MX
, EM
} },
5599 { "psignb", { MX
, EM
} },
5600 { "psignw", { MX
, EM
} },
5601 { "psignd", { MX
, EM
} },
5602 { "pmulhrsw", { MX
, EM
} },
5608 { PREFIX_TABLE (PREFIX_0F3810
) },
5612 { PREFIX_TABLE (PREFIX_0F3814
) },
5613 { PREFIX_TABLE (PREFIX_0F3815
) },
5615 { PREFIX_TABLE (PREFIX_0F3817
) },
5621 { "pabsb", { MX
, EM
} },
5622 { "pabsw", { MX
, EM
} },
5623 { "pabsd", { MX
, EM
} },
5626 { PREFIX_TABLE (PREFIX_0F3820
) },
5627 { PREFIX_TABLE (PREFIX_0F3821
) },
5628 { PREFIX_TABLE (PREFIX_0F3822
) },
5629 { PREFIX_TABLE (PREFIX_0F3823
) },
5630 { PREFIX_TABLE (PREFIX_0F3824
) },
5631 { PREFIX_TABLE (PREFIX_0F3825
) },
5635 { PREFIX_TABLE (PREFIX_0F3828
) },
5636 { PREFIX_TABLE (PREFIX_0F3829
) },
5637 { PREFIX_TABLE (PREFIX_0F382A
) },
5638 { PREFIX_TABLE (PREFIX_0F382B
) },
5644 { PREFIX_TABLE (PREFIX_0F3830
) },
5645 { PREFIX_TABLE (PREFIX_0F3831
) },
5646 { PREFIX_TABLE (PREFIX_0F3832
) },
5647 { PREFIX_TABLE (PREFIX_0F3833
) },
5648 { PREFIX_TABLE (PREFIX_0F3834
) },
5649 { PREFIX_TABLE (PREFIX_0F3835
) },
5651 { PREFIX_TABLE (PREFIX_0F3837
) },
5653 { PREFIX_TABLE (PREFIX_0F3838
) },
5654 { PREFIX_TABLE (PREFIX_0F3839
) },
5655 { PREFIX_TABLE (PREFIX_0F383A
) },
5656 { PREFIX_TABLE (PREFIX_0F383B
) },
5657 { PREFIX_TABLE (PREFIX_0F383C
) },
5658 { PREFIX_TABLE (PREFIX_0F383D
) },
5659 { PREFIX_TABLE (PREFIX_0F383E
) },
5660 { PREFIX_TABLE (PREFIX_0F383F
) },
5662 { PREFIX_TABLE (PREFIX_0F3840
) },
5663 { PREFIX_TABLE (PREFIX_0F3841
) },
5734 { PREFIX_TABLE (PREFIX_0F3880
) },
5735 { PREFIX_TABLE (PREFIX_0F3881
) },
5836 { PREFIX_TABLE (PREFIX_0F38DB
) },
5837 { PREFIX_TABLE (PREFIX_0F38DC
) },
5838 { PREFIX_TABLE (PREFIX_0F38DD
) },
5839 { PREFIX_TABLE (PREFIX_0F38DE
) },
5840 { PREFIX_TABLE (PREFIX_0F38DF
) },
5860 { PREFIX_TABLE (PREFIX_0F38F0
) },
5861 { PREFIX_TABLE (PREFIX_0F38F1
) },
5878 /* THREE_BYTE_0F3A */
5890 { PREFIX_TABLE (PREFIX_0F3A08
) },
5891 { PREFIX_TABLE (PREFIX_0F3A09
) },
5892 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5893 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5894 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5895 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5896 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5897 { "palignr", { MX
, EM
, Ib
} },
5903 { PREFIX_TABLE (PREFIX_0F3A14
) },
5904 { PREFIX_TABLE (PREFIX_0F3A15
) },
5905 { PREFIX_TABLE (PREFIX_0F3A16
) },
5906 { PREFIX_TABLE (PREFIX_0F3A17
) },
5917 { PREFIX_TABLE (PREFIX_0F3A20
) },
5918 { PREFIX_TABLE (PREFIX_0F3A21
) },
5919 { PREFIX_TABLE (PREFIX_0F3A22
) },
5953 { PREFIX_TABLE (PREFIX_0F3A40
) },
5954 { PREFIX_TABLE (PREFIX_0F3A41
) },
5955 { PREFIX_TABLE (PREFIX_0F3A42
) },
5957 { PREFIX_TABLE (PREFIX_0F3A44
) },
5989 { PREFIX_TABLE (PREFIX_0F3A60
) },
5990 { PREFIX_TABLE (PREFIX_0F3A61
) },
5991 { PREFIX_TABLE (PREFIX_0F3A62
) },
5992 { PREFIX_TABLE (PREFIX_0F3A63
) },
6131 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6170 /* THREE_BYTE_0F7A */
6209 { "ptest", { XX
} },
6246 { "phaddbw", { XM
, EXq
} },
6247 { "phaddbd", { XM
, EXq
} },
6248 { "phaddbq", { XM
, EXq
} },
6251 { "phaddwd", { XM
, EXq
} },
6252 { "phaddwq", { XM
, EXq
} },
6257 { "phadddq", { XM
, EXq
} },
6264 { "phaddubw", { XM
, EXq
} },
6265 { "phaddubd", { XM
, EXq
} },
6266 { "phaddubq", { XM
, EXq
} },
6269 { "phadduwd", { XM
, EXq
} },
6270 { "phadduwq", { XM
, EXq
} },
6275 { "phaddudq", { XM
, EXq
} },
6282 { "phsubbw", { XM
, EXq
} },
6283 { "phsubbd", { XM
, EXq
} },
6284 { "phsubbq", { XM
, EXq
} },
6463 static const struct dis386 xop_table
[][256] = {
6485 { "bextr", { Gv
, Ev
, Iq
} },
6616 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6617 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6618 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6626 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6627 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6634 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6635 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6636 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6644 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6645 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6649 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6650 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6653 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6671 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6683 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6684 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6685 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6686 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6696 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6697 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6698 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6699 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6732 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6733 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6734 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6735 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6759 { REG_TABLE (REG_XOP_TBM_01
) },
6760 { REG_TABLE (REG_XOP_TBM_02
) },
6778 { REG_TABLE (REG_XOP_LWPCB
) },
6902 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_80
) },
6903 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_81
) },
6904 { "vfrczss", { XM
, EXd
} },
6905 { "vfrczsd", { XM
, EXq
} },
6920 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6921 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6922 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6923 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6924 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6925 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6926 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6927 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6929 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6930 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6931 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6932 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6975 { "vphaddbw", { XM
, EXxmm
} },
6976 { "vphaddbd", { XM
, EXxmm
} },
6977 { "vphaddbq", { XM
, EXxmm
} },
6980 { "vphaddwd", { XM
, EXxmm
} },
6981 { "vphaddwq", { XM
, EXxmm
} },
6986 { "vphadddq", { XM
, EXxmm
} },
6993 { "vphaddubw", { XM
, EXxmm
} },
6994 { "vphaddubd", { XM
, EXxmm
} },
6995 { "vphaddubq", { XM
, EXxmm
} },
6998 { "vphadduwd", { XM
, EXxmm
} },
6999 { "vphadduwq", { XM
, EXxmm
} },
7004 { "vphaddudq", { XM
, EXxmm
} },
7011 { "vphsubbw", { XM
, EXxmm
} },
7012 { "vphsubwd", { XM
, EXxmm
} },
7013 { "vphsubdq", { XM
, EXxmm
} },
7067 { "bextr", { Gv
, Ev
, Iq
} },
7069 { REG_TABLE (REG_XOP_LWP
) },
7339 static const struct dis386 vex_table
[][256] = {
7361 { PREFIX_TABLE (PREFIX_VEX_0F10
) },
7362 { PREFIX_TABLE (PREFIX_VEX_0F11
) },
7363 { PREFIX_TABLE (PREFIX_VEX_0F12
) },
7364 { MOD_TABLE (MOD_VEX_0F13
) },
7365 { VEX_W_TABLE (VEX_W_0F14
) },
7366 { VEX_W_TABLE (VEX_W_0F15
) },
7367 { PREFIX_TABLE (PREFIX_VEX_0F16
) },
7368 { MOD_TABLE (MOD_VEX_0F17
) },
7388 { VEX_W_TABLE (VEX_W_0F28
) },
7389 { VEX_W_TABLE (VEX_W_0F29
) },
7390 { PREFIX_TABLE (PREFIX_VEX_0F2A
) },
7391 { MOD_TABLE (MOD_VEX_0F2B
) },
7392 { PREFIX_TABLE (PREFIX_VEX_0F2C
) },
7393 { PREFIX_TABLE (PREFIX_VEX_0F2D
) },
7394 { PREFIX_TABLE (PREFIX_VEX_0F2E
) },
7395 { PREFIX_TABLE (PREFIX_VEX_0F2F
) },
7433 { MOD_TABLE (MOD_VEX_0F50
) },
7434 { PREFIX_TABLE (PREFIX_VEX_0F51
) },
7435 { PREFIX_TABLE (PREFIX_VEX_0F52
) },
7436 { PREFIX_TABLE (PREFIX_VEX_0F53
) },
7437 { "vandpX", { XM
, Vex
, EXx
} },
7438 { "vandnpX", { XM
, Vex
, EXx
} },
7439 { "vorpX", { XM
, Vex
, EXx
} },
7440 { "vxorpX", { XM
, Vex
, EXx
} },
7442 { PREFIX_TABLE (PREFIX_VEX_0F58
) },
7443 { PREFIX_TABLE (PREFIX_VEX_0F59
) },
7444 { PREFIX_TABLE (PREFIX_VEX_0F5A
) },
7445 { PREFIX_TABLE (PREFIX_VEX_0F5B
) },
7446 { PREFIX_TABLE (PREFIX_VEX_0F5C
) },
7447 { PREFIX_TABLE (PREFIX_VEX_0F5D
) },
7448 { PREFIX_TABLE (PREFIX_VEX_0F5E
) },
7449 { PREFIX_TABLE (PREFIX_VEX_0F5F
) },
7451 { PREFIX_TABLE (PREFIX_VEX_0F60
) },
7452 { PREFIX_TABLE (PREFIX_VEX_0F61
) },
7453 { PREFIX_TABLE (PREFIX_VEX_0F62
) },
7454 { PREFIX_TABLE (PREFIX_VEX_0F63
) },
7455 { PREFIX_TABLE (PREFIX_VEX_0F64
) },
7456 { PREFIX_TABLE (PREFIX_VEX_0F65
) },
7457 { PREFIX_TABLE (PREFIX_VEX_0F66
) },
7458 { PREFIX_TABLE (PREFIX_VEX_0F67
) },
7460 { PREFIX_TABLE (PREFIX_VEX_0F68
) },
7461 { PREFIX_TABLE (PREFIX_VEX_0F69
) },
7462 { PREFIX_TABLE (PREFIX_VEX_0F6A
) },
7463 { PREFIX_TABLE (PREFIX_VEX_0F6B
) },
7464 { PREFIX_TABLE (PREFIX_VEX_0F6C
) },
7465 { PREFIX_TABLE (PREFIX_VEX_0F6D
) },
7466 { PREFIX_TABLE (PREFIX_VEX_0F6E
) },
7467 { PREFIX_TABLE (PREFIX_VEX_0F6F
) },
7469 { PREFIX_TABLE (PREFIX_VEX_0F70
) },
7470 { REG_TABLE (REG_VEX_0F71
) },
7471 { REG_TABLE (REG_VEX_0F72
) },
7472 { REG_TABLE (REG_VEX_0F73
) },
7473 { PREFIX_TABLE (PREFIX_VEX_0F74
) },
7474 { PREFIX_TABLE (PREFIX_VEX_0F75
) },
7475 { PREFIX_TABLE (PREFIX_VEX_0F76
) },
7476 { PREFIX_TABLE (PREFIX_VEX_0F77
) },
7482 { PREFIX_TABLE (PREFIX_VEX_0F7C
) },
7483 { PREFIX_TABLE (PREFIX_VEX_0F7D
) },
7484 { PREFIX_TABLE (PREFIX_VEX_0F7E
) },
7485 { PREFIX_TABLE (PREFIX_VEX_0F7F
) },
7538 { REG_TABLE (REG_VEX_0FAE
) },
7561 { PREFIX_TABLE (PREFIX_VEX_0FC2
) },
7563 { PREFIX_TABLE (PREFIX_VEX_0FC4
) },
7564 { PREFIX_TABLE (PREFIX_VEX_0FC5
) },
7565 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7577 { PREFIX_TABLE (PREFIX_VEX_0FD0
) },
7578 { PREFIX_TABLE (PREFIX_VEX_0FD1
) },
7579 { PREFIX_TABLE (PREFIX_VEX_0FD2
) },
7580 { PREFIX_TABLE (PREFIX_VEX_0FD3
) },
7581 { PREFIX_TABLE (PREFIX_VEX_0FD4
) },
7582 { PREFIX_TABLE (PREFIX_VEX_0FD5
) },
7583 { PREFIX_TABLE (PREFIX_VEX_0FD6
) },
7584 { PREFIX_TABLE (PREFIX_VEX_0FD7
) },
7586 { PREFIX_TABLE (PREFIX_VEX_0FD8
) },
7587 { PREFIX_TABLE (PREFIX_VEX_0FD9
) },
7588 { PREFIX_TABLE (PREFIX_VEX_0FDA
) },
7589 { PREFIX_TABLE (PREFIX_VEX_0FDB
) },
7590 { PREFIX_TABLE (PREFIX_VEX_0FDC
) },
7591 { PREFIX_TABLE (PREFIX_VEX_0FDD
) },
7592 { PREFIX_TABLE (PREFIX_VEX_0FDE
) },
7593 { PREFIX_TABLE (PREFIX_VEX_0FDF
) },
7595 { PREFIX_TABLE (PREFIX_VEX_0FE0
) },
7596 { PREFIX_TABLE (PREFIX_VEX_0FE1
) },
7597 { PREFIX_TABLE (PREFIX_VEX_0FE2
) },
7598 { PREFIX_TABLE (PREFIX_VEX_0FE3
) },
7599 { PREFIX_TABLE (PREFIX_VEX_0FE4
) },
7600 { PREFIX_TABLE (PREFIX_VEX_0FE5
) },
7601 { PREFIX_TABLE (PREFIX_VEX_0FE6
) },
7602 { PREFIX_TABLE (PREFIX_VEX_0FE7
) },
7604 { PREFIX_TABLE (PREFIX_VEX_0FE8
) },
7605 { PREFIX_TABLE (PREFIX_VEX_0FE9
) },
7606 { PREFIX_TABLE (PREFIX_VEX_0FEA
) },
7607 { PREFIX_TABLE (PREFIX_VEX_0FEB
) },
7608 { PREFIX_TABLE (PREFIX_VEX_0FEC
) },
7609 { PREFIX_TABLE (PREFIX_VEX_0FED
) },
7610 { PREFIX_TABLE (PREFIX_VEX_0FEE
) },
7611 { PREFIX_TABLE (PREFIX_VEX_0FEF
) },
7613 { PREFIX_TABLE (PREFIX_VEX_0FF0
) },
7614 { PREFIX_TABLE (PREFIX_VEX_0FF1
) },
7615 { PREFIX_TABLE (PREFIX_VEX_0FF2
) },
7616 { PREFIX_TABLE (PREFIX_VEX_0FF3
) },
7617 { PREFIX_TABLE (PREFIX_VEX_0FF4
) },
7618 { PREFIX_TABLE (PREFIX_VEX_0FF5
) },
7619 { PREFIX_TABLE (PREFIX_VEX_0FF6
) },
7620 { PREFIX_TABLE (PREFIX_VEX_0FF7
) },
7622 { PREFIX_TABLE (PREFIX_VEX_0FF8
) },
7623 { PREFIX_TABLE (PREFIX_VEX_0FF9
) },
7624 { PREFIX_TABLE (PREFIX_VEX_0FFA
) },
7625 { PREFIX_TABLE (PREFIX_VEX_0FFB
) },
7626 { PREFIX_TABLE (PREFIX_VEX_0FFC
) },
7627 { PREFIX_TABLE (PREFIX_VEX_0FFD
) },
7628 { PREFIX_TABLE (PREFIX_VEX_0FFE
) },
7634 { PREFIX_TABLE (PREFIX_VEX_0F3800
) },
7635 { PREFIX_TABLE (PREFIX_VEX_0F3801
) },
7636 { PREFIX_TABLE (PREFIX_VEX_0F3802
) },
7637 { PREFIX_TABLE (PREFIX_VEX_0F3803
) },
7638 { PREFIX_TABLE (PREFIX_VEX_0F3804
) },
7639 { PREFIX_TABLE (PREFIX_VEX_0F3805
) },
7640 { PREFIX_TABLE (PREFIX_VEX_0F3806
) },
7641 { PREFIX_TABLE (PREFIX_VEX_0F3807
) },
7643 { PREFIX_TABLE (PREFIX_VEX_0F3808
) },
7644 { PREFIX_TABLE (PREFIX_VEX_0F3809
) },
7645 { PREFIX_TABLE (PREFIX_VEX_0F380A
) },
7646 { PREFIX_TABLE (PREFIX_VEX_0F380B
) },
7647 { PREFIX_TABLE (PREFIX_VEX_0F380C
) },
7648 { PREFIX_TABLE (PREFIX_VEX_0F380D
) },
7649 { PREFIX_TABLE (PREFIX_VEX_0F380E
) },
7650 { PREFIX_TABLE (PREFIX_VEX_0F380F
) },
7655 { PREFIX_TABLE (PREFIX_VEX_0F3813
) },
7659 { PREFIX_TABLE (PREFIX_VEX_0F3817
) },
7661 { PREFIX_TABLE (PREFIX_VEX_0F3818
) },
7662 { PREFIX_TABLE (PREFIX_VEX_0F3819
) },
7663 { PREFIX_TABLE (PREFIX_VEX_0F381A
) },
7665 { PREFIX_TABLE (PREFIX_VEX_0F381C
) },
7666 { PREFIX_TABLE (PREFIX_VEX_0F381D
) },
7667 { PREFIX_TABLE (PREFIX_VEX_0F381E
) },
7670 { PREFIX_TABLE (PREFIX_VEX_0F3820
) },
7671 { PREFIX_TABLE (PREFIX_VEX_0F3821
) },
7672 { PREFIX_TABLE (PREFIX_VEX_0F3822
) },
7673 { PREFIX_TABLE (PREFIX_VEX_0F3823
) },
7674 { PREFIX_TABLE (PREFIX_VEX_0F3824
) },
7675 { PREFIX_TABLE (PREFIX_VEX_0F3825
) },
7679 { PREFIX_TABLE (PREFIX_VEX_0F3828
) },
7680 { PREFIX_TABLE (PREFIX_VEX_0F3829
) },
7681 { PREFIX_TABLE (PREFIX_VEX_0F382A
) },
7682 { PREFIX_TABLE (PREFIX_VEX_0F382B
) },
7683 { PREFIX_TABLE (PREFIX_VEX_0F382C
) },
7684 { PREFIX_TABLE (PREFIX_VEX_0F382D
) },
7685 { PREFIX_TABLE (PREFIX_VEX_0F382E
) },
7686 { PREFIX_TABLE (PREFIX_VEX_0F382F
) },
7688 { PREFIX_TABLE (PREFIX_VEX_0F3830
) },
7689 { PREFIX_TABLE (PREFIX_VEX_0F3831
) },
7690 { PREFIX_TABLE (PREFIX_VEX_0F3832
) },
7691 { PREFIX_TABLE (PREFIX_VEX_0F3833
) },
7692 { PREFIX_TABLE (PREFIX_VEX_0F3834
) },
7693 { PREFIX_TABLE (PREFIX_VEX_0F3835
) },
7695 { PREFIX_TABLE (PREFIX_VEX_0F3837
) },
7697 { PREFIX_TABLE (PREFIX_VEX_0F3838
) },
7698 { PREFIX_TABLE (PREFIX_VEX_0F3839
) },
7699 { PREFIX_TABLE (PREFIX_VEX_0F383A
) },
7700 { PREFIX_TABLE (PREFIX_VEX_0F383B
) },
7701 { PREFIX_TABLE (PREFIX_VEX_0F383C
) },
7702 { PREFIX_TABLE (PREFIX_VEX_0F383D
) },
7703 { PREFIX_TABLE (PREFIX_VEX_0F383E
) },
7704 { PREFIX_TABLE (PREFIX_VEX_0F383F
) },
7706 { PREFIX_TABLE (PREFIX_VEX_0F3840
) },
7707 { PREFIX_TABLE (PREFIX_VEX_0F3841
) },
7802 { PREFIX_TABLE (PREFIX_VEX_0F3896
) },
7803 { PREFIX_TABLE (PREFIX_VEX_0F3897
) },
7805 { PREFIX_TABLE (PREFIX_VEX_0F3898
) },
7806 { PREFIX_TABLE (PREFIX_VEX_0F3899
) },
7807 { PREFIX_TABLE (PREFIX_VEX_0F389A
) },
7808 { PREFIX_TABLE (PREFIX_VEX_0F389B
) },
7809 { PREFIX_TABLE (PREFIX_VEX_0F389C
) },
7810 { PREFIX_TABLE (PREFIX_VEX_0F389D
) },
7811 { PREFIX_TABLE (PREFIX_VEX_0F389E
) },
7812 { PREFIX_TABLE (PREFIX_VEX_0F389F
) },
7820 { PREFIX_TABLE (PREFIX_VEX_0F38A6
) },
7821 { PREFIX_TABLE (PREFIX_VEX_0F38A7
) },
7823 { PREFIX_TABLE (PREFIX_VEX_0F38A8
) },
7824 { PREFIX_TABLE (PREFIX_VEX_0F38A9
) },
7825 { PREFIX_TABLE (PREFIX_VEX_0F38AA
) },
7826 { PREFIX_TABLE (PREFIX_VEX_0F38AB
) },
7827 { PREFIX_TABLE (PREFIX_VEX_0F38AC
) },
7828 { PREFIX_TABLE (PREFIX_VEX_0F38AD
) },
7829 { PREFIX_TABLE (PREFIX_VEX_0F38AE
) },
7830 { PREFIX_TABLE (PREFIX_VEX_0F38AF
) },
7838 { PREFIX_TABLE (PREFIX_VEX_0F38B6
) },
7839 { PREFIX_TABLE (PREFIX_VEX_0F38B7
) },
7841 { PREFIX_TABLE (PREFIX_VEX_0F38B8
) },
7842 { PREFIX_TABLE (PREFIX_VEX_0F38B9
) },
7843 { PREFIX_TABLE (PREFIX_VEX_0F38BA
) },
7844 { PREFIX_TABLE (PREFIX_VEX_0F38BB
) },
7845 { PREFIX_TABLE (PREFIX_VEX_0F38BC
) },
7846 { PREFIX_TABLE (PREFIX_VEX_0F38BD
) },
7847 { PREFIX_TABLE (PREFIX_VEX_0F38BE
) },
7848 { PREFIX_TABLE (PREFIX_VEX_0F38BF
) },
7880 { PREFIX_TABLE (PREFIX_VEX_0F38DB
) },
7881 { PREFIX_TABLE (PREFIX_VEX_0F38DC
) },
7882 { PREFIX_TABLE (PREFIX_VEX_0F38DD
) },
7883 { PREFIX_TABLE (PREFIX_VEX_0F38DE
) },
7884 { PREFIX_TABLE (PREFIX_VEX_0F38DF
) },
7906 { PREFIX_TABLE (PREFIX_VEX_0F38F2
) },
7907 { REG_TABLE (REG_VEX_0F38F3
) },
7911 { PREFIX_TABLE (PREFIX_VEX_0F38F7
) },
7929 { PREFIX_TABLE (PREFIX_VEX_0F3A04
) },
7930 { PREFIX_TABLE (PREFIX_VEX_0F3A05
) },
7931 { PREFIX_TABLE (PREFIX_VEX_0F3A06
) },
7934 { PREFIX_TABLE (PREFIX_VEX_0F3A08
) },
7935 { PREFIX_TABLE (PREFIX_VEX_0F3A09
) },
7936 { PREFIX_TABLE (PREFIX_VEX_0F3A0A
) },
7937 { PREFIX_TABLE (PREFIX_VEX_0F3A0B
) },
7938 { PREFIX_TABLE (PREFIX_VEX_0F3A0C
) },
7939 { PREFIX_TABLE (PREFIX_VEX_0F3A0D
) },
7940 { PREFIX_TABLE (PREFIX_VEX_0F3A0E
) },
7941 { PREFIX_TABLE (PREFIX_VEX_0F3A0F
) },
7947 { PREFIX_TABLE (PREFIX_VEX_0F3A14
) },
7948 { PREFIX_TABLE (PREFIX_VEX_0F3A15
) },
7949 { PREFIX_TABLE (PREFIX_VEX_0F3A16
) },
7950 { PREFIX_TABLE (PREFIX_VEX_0F3A17
) },
7952 { PREFIX_TABLE (PREFIX_VEX_0F3A18
) },
7953 { PREFIX_TABLE (PREFIX_VEX_0F3A19
) },
7957 { PREFIX_TABLE (PREFIX_VEX_0F3A1D
) },
7961 { PREFIX_TABLE (PREFIX_VEX_0F3A20
) },
7962 { PREFIX_TABLE (PREFIX_VEX_0F3A21
) },
7963 { PREFIX_TABLE (PREFIX_VEX_0F3A22
) },
7997 { PREFIX_TABLE (PREFIX_VEX_0F3A40
) },
7998 { PREFIX_TABLE (PREFIX_VEX_0F3A41
) },
7999 { PREFIX_TABLE (PREFIX_VEX_0F3A42
) },
8001 { PREFIX_TABLE (PREFIX_VEX_0F3A44
) },
8006 { PREFIX_TABLE (PREFIX_VEX_0F3A48
) },
8007 { PREFIX_TABLE (PREFIX_VEX_0F3A49
) },
8008 { PREFIX_TABLE (PREFIX_VEX_0F3A4A
) },
8009 { PREFIX_TABLE (PREFIX_VEX_0F3A4B
) },
8010 { PREFIX_TABLE (PREFIX_VEX_0F3A4C
) },
8028 { PREFIX_TABLE (PREFIX_VEX_0F3A5C
) },
8029 { PREFIX_TABLE (PREFIX_VEX_0F3A5D
) },
8030 { PREFIX_TABLE (PREFIX_VEX_0F3A5E
) },
8031 { PREFIX_TABLE (PREFIX_VEX_0F3A5F
) },
8033 { PREFIX_TABLE (PREFIX_VEX_0F3A60
) },
8034 { PREFIX_TABLE (PREFIX_VEX_0F3A61
) },
8035 { PREFIX_TABLE (PREFIX_VEX_0F3A62
) },
8036 { PREFIX_TABLE (PREFIX_VEX_0F3A63
) },
8042 { PREFIX_TABLE (PREFIX_VEX_0F3A68
) },
8043 { PREFIX_TABLE (PREFIX_VEX_0F3A69
) },
8044 { PREFIX_TABLE (PREFIX_VEX_0F3A6A
) },
8045 { PREFIX_TABLE (PREFIX_VEX_0F3A6B
) },
8046 { PREFIX_TABLE (PREFIX_VEX_0F3A6C
) },
8047 { PREFIX_TABLE (PREFIX_VEX_0F3A6D
) },
8048 { PREFIX_TABLE (PREFIX_VEX_0F3A6E
) },
8049 { PREFIX_TABLE (PREFIX_VEX_0F3A6F
) },
8060 { PREFIX_TABLE (PREFIX_VEX_0F3A78
) },
8061 { PREFIX_TABLE (PREFIX_VEX_0F3A79
) },
8062 { PREFIX_TABLE (PREFIX_VEX_0F3A7A
) },
8063 { PREFIX_TABLE (PREFIX_VEX_0F3A7B
) },
8064 { PREFIX_TABLE (PREFIX_VEX_0F3A7C
) },
8065 { PREFIX_TABLE (PREFIX_VEX_0F3A7D
) },
8066 { PREFIX_TABLE (PREFIX_VEX_0F3A7E
) },
8067 { PREFIX_TABLE (PREFIX_VEX_0F3A7F
) },
8175 { PREFIX_TABLE (PREFIX_VEX_0F3ADF
) },
8215 static const struct dis386 vex_len_table
[][2] = {
8216 /* VEX_LEN_0F10_P_1 */
8218 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
8219 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
8222 /* VEX_LEN_0F10_P_3 */
8224 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
8225 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
8228 /* VEX_LEN_0F11_P_1 */
8230 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
8231 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
8234 /* VEX_LEN_0F11_P_3 */
8236 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
8237 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
8240 /* VEX_LEN_0F12_P_0_M_0 */
8242 { VEX_W_TABLE (VEX_W_0F12_P_0_M_0
) },
8245 /* VEX_LEN_0F12_P_0_M_1 */
8247 { VEX_W_TABLE (VEX_W_0F12_P_0_M_1
) },
8250 /* VEX_LEN_0F12_P_2 */
8252 { VEX_W_TABLE (VEX_W_0F12_P_2
) },
8255 /* VEX_LEN_0F13_M_0 */
8257 { VEX_W_TABLE (VEX_W_0F13_M_0
) },
8260 /* VEX_LEN_0F16_P_0_M_0 */
8262 { VEX_W_TABLE (VEX_W_0F16_P_0_M_0
) },
8265 /* VEX_LEN_0F16_P_0_M_1 */
8267 { VEX_W_TABLE (VEX_W_0F16_P_0_M_1
) },
8270 /* VEX_LEN_0F16_P_2 */
8272 { VEX_W_TABLE (VEX_W_0F16_P_2
) },
8275 /* VEX_LEN_0F17_M_0 */
8277 { VEX_W_TABLE (VEX_W_0F17_M_0
) },
8280 /* VEX_LEN_0F2A_P_1 */
8282 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8283 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8286 /* VEX_LEN_0F2A_P_3 */
8288 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8289 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8292 /* VEX_LEN_0F2C_P_1 */
8294 { "vcvttss2siY", { Gv
, EXdScalar
} },
8295 { "vcvttss2siY", { Gv
, EXdScalar
} },
8298 /* VEX_LEN_0F2C_P_3 */
8300 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8301 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8304 /* VEX_LEN_0F2D_P_1 */
8306 { "vcvtss2siY", { Gv
, EXdScalar
} },
8307 { "vcvtss2siY", { Gv
, EXdScalar
} },
8310 /* VEX_LEN_0F2D_P_3 */
8312 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8313 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8316 /* VEX_LEN_0F2E_P_0 */
8318 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
8319 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
8322 /* VEX_LEN_0F2E_P_2 */
8324 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
8325 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
8328 /* VEX_LEN_0F2F_P_0 */
8330 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
8331 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
8334 /* VEX_LEN_0F2F_P_2 */
8336 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
8337 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
8340 /* VEX_LEN_0F51_P_1 */
8342 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
8343 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
8346 /* VEX_LEN_0F51_P_3 */
8348 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
8349 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
8352 /* VEX_LEN_0F52_P_1 */
8354 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
8355 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
8358 /* VEX_LEN_0F53_P_1 */
8360 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
8361 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
8364 /* VEX_LEN_0F58_P_1 */
8366 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
8367 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
8370 /* VEX_LEN_0F58_P_3 */
8372 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
8373 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
8376 /* VEX_LEN_0F59_P_1 */
8378 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
8379 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
8382 /* VEX_LEN_0F59_P_3 */
8384 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
8385 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
8388 /* VEX_LEN_0F5A_P_1 */
8390 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
8391 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
8394 /* VEX_LEN_0F5A_P_3 */
8396 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
8397 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
8400 /* VEX_LEN_0F5C_P_1 */
8402 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
8403 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
8406 /* VEX_LEN_0F5C_P_3 */
8408 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
8409 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
8412 /* VEX_LEN_0F5D_P_1 */
8414 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
8415 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
8418 /* VEX_LEN_0F5D_P_3 */
8420 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
8421 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
8424 /* VEX_LEN_0F5E_P_1 */
8426 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
8427 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
8430 /* VEX_LEN_0F5E_P_3 */
8432 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
8433 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
8436 /* VEX_LEN_0F5F_P_1 */
8438 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
8439 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
8442 /* VEX_LEN_0F5F_P_3 */
8444 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
8445 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
8448 /* VEX_LEN_0F60_P_2 */
8450 { VEX_W_TABLE (VEX_W_0F60_P_2
) },
8453 /* VEX_LEN_0F61_P_2 */
8455 { VEX_W_TABLE (VEX_W_0F61_P_2
) },
8458 /* VEX_LEN_0F62_P_2 */
8460 { VEX_W_TABLE (VEX_W_0F62_P_2
) },
8463 /* VEX_LEN_0F63_P_2 */
8465 { VEX_W_TABLE (VEX_W_0F63_P_2
) },
8468 /* VEX_LEN_0F64_P_2 */
8470 { VEX_W_TABLE (VEX_W_0F64_P_2
) },
8473 /* VEX_LEN_0F65_P_2 */
8475 { VEX_W_TABLE (VEX_W_0F65_P_2
) },
8478 /* VEX_LEN_0F66_P_2 */
8480 { VEX_W_TABLE (VEX_W_0F66_P_2
) },
8483 /* VEX_LEN_0F67_P_2 */
8485 { VEX_W_TABLE (VEX_W_0F67_P_2
) },
8488 /* VEX_LEN_0F68_P_2 */
8490 { VEX_W_TABLE (VEX_W_0F68_P_2
) },
8493 /* VEX_LEN_0F69_P_2 */
8495 { VEX_W_TABLE (VEX_W_0F69_P_2
) },
8498 /* VEX_LEN_0F6A_P_2 */
8500 { VEX_W_TABLE (VEX_W_0F6A_P_2
) },
8503 /* VEX_LEN_0F6B_P_2 */
8505 { VEX_W_TABLE (VEX_W_0F6B_P_2
) },
8508 /* VEX_LEN_0F6C_P_2 */
8510 { VEX_W_TABLE (VEX_W_0F6C_P_2
) },
8513 /* VEX_LEN_0F6D_P_2 */
8515 { VEX_W_TABLE (VEX_W_0F6D_P_2
) },
8518 /* VEX_LEN_0F6E_P_2 */
8520 { "vmovK", { XMScalar
, Edq
} },
8521 { "vmovK", { XMScalar
, Edq
} },
8524 /* VEX_LEN_0F70_P_1 */
8526 { VEX_W_TABLE (VEX_W_0F70_P_1
) },
8529 /* VEX_LEN_0F70_P_2 */
8531 { VEX_W_TABLE (VEX_W_0F70_P_2
) },
8534 /* VEX_LEN_0F70_P_3 */
8536 { VEX_W_TABLE (VEX_W_0F70_P_3
) },
8539 /* VEX_LEN_0F71_R_2_P_2 */
8541 { VEX_W_TABLE (VEX_W_0F71_R_2_P_2
) },
8544 /* VEX_LEN_0F71_R_4_P_2 */
8546 { VEX_W_TABLE (VEX_W_0F71_R_4_P_2
) },
8549 /* VEX_LEN_0F71_R_6_P_2 */
8551 { VEX_W_TABLE (VEX_W_0F71_R_6_P_2
) },
8554 /* VEX_LEN_0F72_R_2_P_2 */
8556 { VEX_W_TABLE (VEX_W_0F72_R_2_P_2
) },
8559 /* VEX_LEN_0F72_R_4_P_2 */
8561 { VEX_W_TABLE (VEX_W_0F72_R_4_P_2
) },
8564 /* VEX_LEN_0F72_R_6_P_2 */
8566 { VEX_W_TABLE (VEX_W_0F72_R_6_P_2
) },
8569 /* VEX_LEN_0F73_R_2_P_2 */
8571 { VEX_W_TABLE (VEX_W_0F73_R_2_P_2
) },
8574 /* VEX_LEN_0F73_R_3_P_2 */
8576 { VEX_W_TABLE (VEX_W_0F73_R_3_P_2
) },
8579 /* VEX_LEN_0F73_R_6_P_2 */
8581 { VEX_W_TABLE (VEX_W_0F73_R_6_P_2
) },
8584 /* VEX_LEN_0F73_R_7_P_2 */
8586 { VEX_W_TABLE (VEX_W_0F73_R_7_P_2
) },
8589 /* VEX_LEN_0F74_P_2 */
8591 { VEX_W_TABLE (VEX_W_0F74_P_2
) },
8594 /* VEX_LEN_0F75_P_2 */
8596 { VEX_W_TABLE (VEX_W_0F75_P_2
) },
8599 /* VEX_LEN_0F76_P_2 */
8601 { VEX_W_TABLE (VEX_W_0F76_P_2
) },
8604 /* VEX_LEN_0F7E_P_1 */
8606 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
8607 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
8610 /* VEX_LEN_0F7E_P_2 */
8612 { "vmovK", { Edq
, XMScalar
} },
8613 { "vmovK", { Edq
, XMScalar
} },
8616 /* VEX_LEN_0FAE_R_2_M_0 */
8618 { VEX_W_TABLE (VEX_W_0FAE_R_2_M_0
) },
8621 /* VEX_LEN_0FAE_R_3_M_0 */
8623 { VEX_W_TABLE (VEX_W_0FAE_R_3_M_0
) },
8626 /* VEX_LEN_0FC2_P_1 */
8628 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
8629 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
8632 /* VEX_LEN_0FC2_P_3 */
8634 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
8635 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
8638 /* VEX_LEN_0FC4_P_2 */
8640 { VEX_W_TABLE (VEX_W_0FC4_P_2
) },
8643 /* VEX_LEN_0FC5_P_2 */
8645 { VEX_W_TABLE (VEX_W_0FC5_P_2
) },
8648 /* VEX_LEN_0FD1_P_2 */
8650 { VEX_W_TABLE (VEX_W_0FD1_P_2
) },
8653 /* VEX_LEN_0FD2_P_2 */
8655 { VEX_W_TABLE (VEX_W_0FD2_P_2
) },
8658 /* VEX_LEN_0FD3_P_2 */
8660 { VEX_W_TABLE (VEX_W_0FD3_P_2
) },
8663 /* VEX_LEN_0FD4_P_2 */
8665 { VEX_W_TABLE (VEX_W_0FD4_P_2
) },
8668 /* VEX_LEN_0FD5_P_2 */
8670 { VEX_W_TABLE (VEX_W_0FD5_P_2
) },
8673 /* VEX_LEN_0FD6_P_2 */
8675 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
8676 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
8679 /* VEX_LEN_0FD7_P_2_M_1 */
8681 { VEX_W_TABLE (VEX_W_0FD7_P_2_M_1
) },
8684 /* VEX_LEN_0FD8_P_2 */
8686 { VEX_W_TABLE (VEX_W_0FD8_P_2
) },
8689 /* VEX_LEN_0FD9_P_2 */
8691 { VEX_W_TABLE (VEX_W_0FD9_P_2
) },
8694 /* VEX_LEN_0FDA_P_2 */
8696 { VEX_W_TABLE (VEX_W_0FDA_P_2
) },
8699 /* VEX_LEN_0FDB_P_2 */
8701 { VEX_W_TABLE (VEX_W_0FDB_P_2
) },
8704 /* VEX_LEN_0FDC_P_2 */
8706 { VEX_W_TABLE (VEX_W_0FDC_P_2
) },
8709 /* VEX_LEN_0FDD_P_2 */
8711 { VEX_W_TABLE (VEX_W_0FDD_P_2
) },
8714 /* VEX_LEN_0FDE_P_2 */
8716 { VEX_W_TABLE (VEX_W_0FDE_P_2
) },
8719 /* VEX_LEN_0FDF_P_2 */
8721 { VEX_W_TABLE (VEX_W_0FDF_P_2
) },
8724 /* VEX_LEN_0FE0_P_2 */
8726 { VEX_W_TABLE (VEX_W_0FE0_P_2
) },
8729 /* VEX_LEN_0FE1_P_2 */
8731 { VEX_W_TABLE (VEX_W_0FE1_P_2
) },
8734 /* VEX_LEN_0FE2_P_2 */
8736 { VEX_W_TABLE (VEX_W_0FE2_P_2
) },
8739 /* VEX_LEN_0FE3_P_2 */
8741 { VEX_W_TABLE (VEX_W_0FE3_P_2
) },
8744 /* VEX_LEN_0FE4_P_2 */
8746 { VEX_W_TABLE (VEX_W_0FE4_P_2
) },
8749 /* VEX_LEN_0FE5_P_2 */
8751 { VEX_W_TABLE (VEX_W_0FE5_P_2
) },
8754 /* VEX_LEN_0FE8_P_2 */
8756 { VEX_W_TABLE (VEX_W_0FE8_P_2
) },
8759 /* VEX_LEN_0FE9_P_2 */
8761 { VEX_W_TABLE (VEX_W_0FE9_P_2
) },
8764 /* VEX_LEN_0FEA_P_2 */
8766 { VEX_W_TABLE (VEX_W_0FEA_P_2
) },
8769 /* VEX_LEN_0FEB_P_2 */
8771 { VEX_W_TABLE (VEX_W_0FEB_P_2
) },
8774 /* VEX_LEN_0FEC_P_2 */
8776 { VEX_W_TABLE (VEX_W_0FEC_P_2
) },
8779 /* VEX_LEN_0FED_P_2 */
8781 { VEX_W_TABLE (VEX_W_0FED_P_2
) },
8784 /* VEX_LEN_0FEE_P_2 */
8786 { VEX_W_TABLE (VEX_W_0FEE_P_2
) },
8789 /* VEX_LEN_0FEF_P_2 */
8791 { VEX_W_TABLE (VEX_W_0FEF_P_2
) },
8794 /* VEX_LEN_0FF1_P_2 */
8796 { VEX_W_TABLE (VEX_W_0FF1_P_2
) },
8799 /* VEX_LEN_0FF2_P_2 */
8801 { VEX_W_TABLE (VEX_W_0FF2_P_2
) },
8804 /* VEX_LEN_0FF3_P_2 */
8806 { VEX_W_TABLE (VEX_W_0FF3_P_2
) },
8809 /* VEX_LEN_0FF4_P_2 */
8811 { VEX_W_TABLE (VEX_W_0FF4_P_2
) },
8814 /* VEX_LEN_0FF5_P_2 */
8816 { VEX_W_TABLE (VEX_W_0FF5_P_2
) },
8819 /* VEX_LEN_0FF6_P_2 */
8821 { VEX_W_TABLE (VEX_W_0FF6_P_2
) },
8824 /* VEX_LEN_0FF7_P_2 */
8826 { VEX_W_TABLE (VEX_W_0FF7_P_2
) },
8829 /* VEX_LEN_0FF8_P_2 */
8831 { VEX_W_TABLE (VEX_W_0FF8_P_2
) },
8834 /* VEX_LEN_0FF9_P_2 */
8836 { VEX_W_TABLE (VEX_W_0FF9_P_2
) },
8839 /* VEX_LEN_0FFA_P_2 */
8841 { VEX_W_TABLE (VEX_W_0FFA_P_2
) },
8844 /* VEX_LEN_0FFB_P_2 */
8846 { VEX_W_TABLE (VEX_W_0FFB_P_2
) },
8849 /* VEX_LEN_0FFC_P_2 */
8851 { VEX_W_TABLE (VEX_W_0FFC_P_2
) },
8854 /* VEX_LEN_0FFD_P_2 */
8856 { VEX_W_TABLE (VEX_W_0FFD_P_2
) },
8859 /* VEX_LEN_0FFE_P_2 */
8861 { VEX_W_TABLE (VEX_W_0FFE_P_2
) },
8864 /* VEX_LEN_0F3800_P_2 */
8866 { VEX_W_TABLE (VEX_W_0F3800_P_2
) },
8869 /* VEX_LEN_0F3801_P_2 */
8871 { VEX_W_TABLE (VEX_W_0F3801_P_2
) },
8874 /* VEX_LEN_0F3802_P_2 */
8876 { VEX_W_TABLE (VEX_W_0F3802_P_2
) },
8879 /* VEX_LEN_0F3803_P_2 */
8881 { VEX_W_TABLE (VEX_W_0F3803_P_2
) },
8884 /* VEX_LEN_0F3804_P_2 */
8886 { VEX_W_TABLE (VEX_W_0F3804_P_2
) },
8889 /* VEX_LEN_0F3805_P_2 */
8891 { VEX_W_TABLE (VEX_W_0F3805_P_2
) },
8894 /* VEX_LEN_0F3806_P_2 */
8896 { VEX_W_TABLE (VEX_W_0F3806_P_2
) },
8899 /* VEX_LEN_0F3807_P_2 */
8901 { VEX_W_TABLE (VEX_W_0F3807_P_2
) },
8904 /* VEX_LEN_0F3808_P_2 */
8906 { VEX_W_TABLE (VEX_W_0F3808_P_2
) },
8909 /* VEX_LEN_0F3809_P_2 */
8911 { VEX_W_TABLE (VEX_W_0F3809_P_2
) },
8914 /* VEX_LEN_0F380A_P_2 */
8916 { VEX_W_TABLE (VEX_W_0F380A_P_2
) },
8919 /* VEX_LEN_0F380B_P_2 */
8921 { VEX_W_TABLE (VEX_W_0F380B_P_2
) },
8924 /* VEX_LEN_0F3819_P_2_M_0 */
8927 { VEX_W_TABLE (VEX_W_0F3819_P_2_M_0
) },
8930 /* VEX_LEN_0F381A_P_2_M_0 */
8933 { VEX_W_TABLE (VEX_W_0F381A_P_2_M_0
) },
8936 /* VEX_LEN_0F381C_P_2 */
8938 { VEX_W_TABLE (VEX_W_0F381C_P_2
) },
8941 /* VEX_LEN_0F381D_P_2 */
8943 { VEX_W_TABLE (VEX_W_0F381D_P_2
) },
8946 /* VEX_LEN_0F381E_P_2 */
8948 { VEX_W_TABLE (VEX_W_0F381E_P_2
) },
8951 /* VEX_LEN_0F3820_P_2 */
8953 { VEX_W_TABLE (VEX_W_0F3820_P_2
) },
8956 /* VEX_LEN_0F3821_P_2 */
8958 { VEX_W_TABLE (VEX_W_0F3821_P_2
) },
8961 /* VEX_LEN_0F3822_P_2 */
8963 { VEX_W_TABLE (VEX_W_0F3822_P_2
) },
8966 /* VEX_LEN_0F3823_P_2 */
8968 { VEX_W_TABLE (VEX_W_0F3823_P_2
) },
8971 /* VEX_LEN_0F3824_P_2 */
8973 { VEX_W_TABLE (VEX_W_0F3824_P_2
) },
8976 /* VEX_LEN_0F3825_P_2 */
8978 { VEX_W_TABLE (VEX_W_0F3825_P_2
) },
8981 /* VEX_LEN_0F3828_P_2 */
8983 { VEX_W_TABLE (VEX_W_0F3828_P_2
) },
8986 /* VEX_LEN_0F3829_P_2 */
8988 { VEX_W_TABLE (VEX_W_0F3829_P_2
) },
8991 /* VEX_LEN_0F382A_P_2_M_0 */
8993 { VEX_W_TABLE (VEX_W_0F382A_P_2_M_0
) },
8996 /* VEX_LEN_0F382B_P_2 */
8998 { VEX_W_TABLE (VEX_W_0F382B_P_2
) },
9001 /* VEX_LEN_0F3830_P_2 */
9003 { VEX_W_TABLE (VEX_W_0F3830_P_2
) },
9006 /* VEX_LEN_0F3831_P_2 */
9008 { VEX_W_TABLE (VEX_W_0F3831_P_2
) },
9011 /* VEX_LEN_0F3832_P_2 */
9013 { VEX_W_TABLE (VEX_W_0F3832_P_2
) },
9016 /* VEX_LEN_0F3833_P_2 */
9018 { VEX_W_TABLE (VEX_W_0F3833_P_2
) },
9021 /* VEX_LEN_0F3834_P_2 */
9023 { VEX_W_TABLE (VEX_W_0F3834_P_2
) },
9026 /* VEX_LEN_0F3835_P_2 */
9028 { VEX_W_TABLE (VEX_W_0F3835_P_2
) },
9031 /* VEX_LEN_0F3837_P_2 */
9033 { VEX_W_TABLE (VEX_W_0F3837_P_2
) },
9036 /* VEX_LEN_0F3838_P_2 */
9038 { VEX_W_TABLE (VEX_W_0F3838_P_2
) },
9041 /* VEX_LEN_0F3839_P_2 */
9043 { VEX_W_TABLE (VEX_W_0F3839_P_2
) },
9046 /* VEX_LEN_0F383A_P_2 */
9048 { VEX_W_TABLE (VEX_W_0F383A_P_2
) },
9051 /* VEX_LEN_0F383B_P_2 */
9053 { VEX_W_TABLE (VEX_W_0F383B_P_2
) },
9056 /* VEX_LEN_0F383C_P_2 */
9058 { VEX_W_TABLE (VEX_W_0F383C_P_2
) },
9061 /* VEX_LEN_0F383D_P_2 */
9063 { VEX_W_TABLE (VEX_W_0F383D_P_2
) },
9066 /* VEX_LEN_0F383E_P_2 */
9068 { VEX_W_TABLE (VEX_W_0F383E_P_2
) },
9071 /* VEX_LEN_0F383F_P_2 */
9073 { VEX_W_TABLE (VEX_W_0F383F_P_2
) },
9076 /* VEX_LEN_0F3840_P_2 */
9078 { VEX_W_TABLE (VEX_W_0F3840_P_2
) },
9081 /* VEX_LEN_0F3841_P_2 */
9083 { VEX_W_TABLE (VEX_W_0F3841_P_2
) },
9086 /* VEX_LEN_0F38DB_P_2 */
9088 { VEX_W_TABLE (VEX_W_0F38DB_P_2
) },
9091 /* VEX_LEN_0F38DC_P_2 */
9093 { VEX_W_TABLE (VEX_W_0F38DC_P_2
) },
9096 /* VEX_LEN_0F38DD_P_2 */
9098 { VEX_W_TABLE (VEX_W_0F38DD_P_2
) },
9101 /* VEX_LEN_0F38DE_P_2 */
9103 { VEX_W_TABLE (VEX_W_0F38DE_P_2
) },
9106 /* VEX_LEN_0F38DF_P_2 */
9108 { VEX_W_TABLE (VEX_W_0F38DF_P_2
) },
9111 /* VEX_LEN_0F38F2_P_0 */
9113 { "andnS", { Gdq
, VexGdq
, Edq
} },
9116 /* VEX_LEN_0F38F3_R_1_P_0 */
9118 { "blsrS", { VexGdq
, Edq
} },
9121 /* VEX_LEN_0F38F3_R_2_P_0 */
9123 { "blsmskS", { VexGdq
, Edq
} },
9126 /* VEX_LEN_0F38F3_R_3_P_0 */
9128 { "blsiS", { VexGdq
, Edq
} },
9131 /* VEX_LEN_0F38F7_P_0 */
9133 { "bextrS", { Gdq
, Edq
, VexGdq
} },
9136 /* VEX_LEN_0F3A06_P_2 */
9139 { VEX_W_TABLE (VEX_W_0F3A06_P_2
) },
9142 /* VEX_LEN_0F3A0A_P_2 */
9144 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
9145 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
9148 /* VEX_LEN_0F3A0B_P_2 */
9150 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
9151 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
9154 /* VEX_LEN_0F3A0E_P_2 */
9156 { VEX_W_TABLE (VEX_W_0F3A0E_P_2
) },
9159 /* VEX_LEN_0F3A0F_P_2 */
9161 { VEX_W_TABLE (VEX_W_0F3A0F_P_2
) },
9164 /* VEX_LEN_0F3A14_P_2 */
9166 { VEX_W_TABLE (VEX_W_0F3A14_P_2
) },
9169 /* VEX_LEN_0F3A15_P_2 */
9171 { VEX_W_TABLE (VEX_W_0F3A15_P_2
) },
9174 /* VEX_LEN_0F3A16_P_2 */
9176 { "vpextrK", { Edq
, XM
, Ib
} },
9179 /* VEX_LEN_0F3A17_P_2 */
9181 { "vextractps", { Edqd
, XM
, Ib
} },
9184 /* VEX_LEN_0F3A18_P_2 */
9187 { VEX_W_TABLE (VEX_W_0F3A18_P_2
) },
9190 /* VEX_LEN_0F3A19_P_2 */
9193 { VEX_W_TABLE (VEX_W_0F3A19_P_2
) },
9196 /* VEX_LEN_0F3A20_P_2 */
9198 { VEX_W_TABLE (VEX_W_0F3A20_P_2
) },
9201 /* VEX_LEN_0F3A21_P_2 */
9203 { VEX_W_TABLE (VEX_W_0F3A21_P_2
) },
9206 /* VEX_LEN_0F3A22_P_2 */
9208 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9211 /* VEX_LEN_0F3A41_P_2 */
9213 { VEX_W_TABLE (VEX_W_0F3A41_P_2
) },
9216 /* VEX_LEN_0F3A42_P_2 */
9218 { VEX_W_TABLE (VEX_W_0F3A42_P_2
) },
9221 /* VEX_LEN_0F3A44_P_2 */
9223 { VEX_W_TABLE (VEX_W_0F3A44_P_2
) },
9226 /* VEX_LEN_0F3A4C_P_2 */
9228 { VEX_W_TABLE (VEX_W_0F3A4C_P_2
) },
9231 /* VEX_LEN_0F3A60_P_2 */
9233 { VEX_W_TABLE (VEX_W_0F3A60_P_2
) },
9236 /* VEX_LEN_0F3A61_P_2 */
9238 { VEX_W_TABLE (VEX_W_0F3A61_P_2
) },
9241 /* VEX_LEN_0F3A62_P_2 */
9243 { VEX_W_TABLE (VEX_W_0F3A62_P_2
) },
9246 /* VEX_LEN_0F3A63_P_2 */
9248 { VEX_W_TABLE (VEX_W_0F3A63_P_2
) },
9251 /* VEX_LEN_0F3A6A_P_2 */
9253 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9256 /* VEX_LEN_0F3A6B_P_2 */
9258 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9261 /* VEX_LEN_0F3A6E_P_2 */
9263 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9266 /* VEX_LEN_0F3A6F_P_2 */
9268 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9271 /* VEX_LEN_0F3A7A_P_2 */
9273 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9276 /* VEX_LEN_0F3A7B_P_2 */
9278 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9281 /* VEX_LEN_0F3A7E_P_2 */
9283 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9286 /* VEX_LEN_0F3A7F_P_2 */
9288 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9291 /* VEX_LEN_0F3ADF_P_2 */
9293 { VEX_W_TABLE (VEX_W_0F3ADF_P_2
) },
9296 /* VEX_LEN_0FXOP_09_80 */
9298 { "vfrczps", { XM
, EXxmm
} },
9299 { "vfrczps", { XM
, EXymmq
} },
9302 /* VEX_LEN_0FXOP_09_81 */
9304 { "vfrczpd", { XM
, EXxmm
} },
9305 { "vfrczpd", { XM
, EXymmq
} },
9309 static const struct dis386 vex_w_table
[][2] = {
9311 /* VEX_W_0F10_P_0 */
9312 { "vmovups", { XM
, EXx
} },
9315 /* VEX_W_0F10_P_1 */
9316 { "vmovss", { XMVexScalar
, VexScalar
, EXdScalar
} },
9319 /* VEX_W_0F10_P_2 */
9320 { "vmovupd", { XM
, EXx
} },
9323 /* VEX_W_0F10_P_3 */
9324 { "vmovsd", { XMVexScalar
, VexScalar
, EXqScalar
} },
9327 /* VEX_W_0F11_P_0 */
9328 { "vmovups", { EXxS
, XM
} },
9331 /* VEX_W_0F11_P_1 */
9332 { "vmovss", { EXdVexScalarS
, VexScalar
, XMScalar
} },
9335 /* VEX_W_0F11_P_2 */
9336 { "vmovupd", { EXxS
, XM
} },
9339 /* VEX_W_0F11_P_3 */
9340 { "vmovsd", { EXqVexScalarS
, VexScalar
, XMScalar
} },
9343 /* VEX_W_0F12_P_0_M_0 */
9344 { "vmovlps", { XM
, Vex128
, EXq
} },
9347 /* VEX_W_0F12_P_0_M_1 */
9348 { "vmovhlps", { XM
, Vex128
, EXq
} },
9351 /* VEX_W_0F12_P_1 */
9352 { "vmovsldup", { XM
, EXx
} },
9355 /* VEX_W_0F12_P_2 */
9356 { "vmovlpd", { XM
, Vex128
, EXq
} },
9359 /* VEX_W_0F12_P_3 */
9360 { "vmovddup", { XM
, EXymmq
} },
9363 /* VEX_W_0F13_M_0 */
9364 { "vmovlpX", { EXq
, XM
} },
9368 { "vunpcklpX", { XM
, Vex
, EXx
} },
9372 { "vunpckhpX", { XM
, Vex
, EXx
} },
9375 /* VEX_W_0F16_P_0_M_0 */
9376 { "vmovhps", { XM
, Vex128
, EXq
} },
9379 /* VEX_W_0F16_P_0_M_1 */
9380 { "vmovlhps", { XM
, Vex128
, EXq
} },
9383 /* VEX_W_0F16_P_1 */
9384 { "vmovshdup", { XM
, EXx
} },
9387 /* VEX_W_0F16_P_2 */
9388 { "vmovhpd", { XM
, Vex128
, EXq
} },
9391 /* VEX_W_0F17_M_0 */
9392 { "vmovhpX", { EXq
, XM
} },
9396 { "vmovapX", { XM
, EXx
} },
9400 { "vmovapX", { EXxS
, XM
} },
9403 /* VEX_W_0F2B_M_0 */
9404 { "vmovntpX", { Mx
, XM
} },
9407 /* VEX_W_0F2E_P_0 */
9408 { "vucomiss", { XMScalar
, EXdScalar
} },
9411 /* VEX_W_0F2E_P_2 */
9412 { "vucomisd", { XMScalar
, EXqScalar
} },
9415 /* VEX_W_0F2F_P_0 */
9416 { "vcomiss", { XMScalar
, EXdScalar
} },
9419 /* VEX_W_0F2F_P_2 */
9420 { "vcomisd", { XMScalar
, EXqScalar
} },
9423 /* VEX_W_0F50_M_0 */
9424 { "vmovmskpX", { Gdq
, XS
} },
9427 /* VEX_W_0F51_P_0 */
9428 { "vsqrtps", { XM
, EXx
} },
9431 /* VEX_W_0F51_P_1 */
9432 { "vsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9435 /* VEX_W_0F51_P_2 */
9436 { "vsqrtpd", { XM
, EXx
} },
9439 /* VEX_W_0F51_P_3 */
9440 { "vsqrtsd", { XMScalar
, VexScalar
, EXqScalar
} },
9443 /* VEX_W_0F52_P_0 */
9444 { "vrsqrtps", { XM
, EXx
} },
9447 /* VEX_W_0F52_P_1 */
9448 { "vrsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9451 /* VEX_W_0F53_P_0 */
9452 { "vrcpps", { XM
, EXx
} },
9455 /* VEX_W_0F53_P_1 */
9456 { "vrcpss", { XMScalar
, VexScalar
, EXdScalar
} },
9459 /* VEX_W_0F58_P_0 */
9460 { "vaddps", { XM
, Vex
, EXx
} },
9463 /* VEX_W_0F58_P_1 */
9464 { "vaddss", { XMScalar
, VexScalar
, EXdScalar
} },
9467 /* VEX_W_0F58_P_2 */
9468 { "vaddpd", { XM
, Vex
, EXx
} },
9471 /* VEX_W_0F58_P_3 */
9472 { "vaddsd", { XMScalar
, VexScalar
, EXqScalar
} },
9475 /* VEX_W_0F59_P_0 */
9476 { "vmulps", { XM
, Vex
, EXx
} },
9479 /* VEX_W_0F59_P_1 */
9480 { "vmulss", { XMScalar
, VexScalar
, EXdScalar
} },
9483 /* VEX_W_0F59_P_2 */
9484 { "vmulpd", { XM
, Vex
, EXx
} },
9487 /* VEX_W_0F59_P_3 */
9488 { "vmulsd", { XMScalar
, VexScalar
, EXqScalar
} },
9491 /* VEX_W_0F5A_P_0 */
9492 { "vcvtps2pd", { XM
, EXxmmq
} },
9495 /* VEX_W_0F5A_P_1 */
9496 { "vcvtss2sd", { XMScalar
, VexScalar
, EXdScalar
} },
9499 /* VEX_W_0F5A_P_3 */
9500 { "vcvtsd2ss", { XMScalar
, VexScalar
, EXqScalar
} },
9503 /* VEX_W_0F5B_P_0 */
9504 { "vcvtdq2ps", { XM
, EXx
} },
9507 /* VEX_W_0F5B_P_1 */
9508 { "vcvttps2dq", { XM
, EXx
} },
9511 /* VEX_W_0F5B_P_2 */
9512 { "vcvtps2dq", { XM
, EXx
} },
9515 /* VEX_W_0F5C_P_0 */
9516 { "vsubps", { XM
, Vex
, EXx
} },
9519 /* VEX_W_0F5C_P_1 */
9520 { "vsubss", { XMScalar
, VexScalar
, EXdScalar
} },
9523 /* VEX_W_0F5C_P_2 */
9524 { "vsubpd", { XM
, Vex
, EXx
} },
9527 /* VEX_W_0F5C_P_3 */
9528 { "vsubsd", { XMScalar
, VexScalar
, EXqScalar
} },
9531 /* VEX_W_0F5D_P_0 */
9532 { "vminps", { XM
, Vex
, EXx
} },
9535 /* VEX_W_0F5D_P_1 */
9536 { "vminss", { XMScalar
, VexScalar
, EXdScalar
} },
9539 /* VEX_W_0F5D_P_2 */
9540 { "vminpd", { XM
, Vex
, EXx
} },
9543 /* VEX_W_0F5D_P_3 */
9544 { "vminsd", { XMScalar
, VexScalar
, EXqScalar
} },
9547 /* VEX_W_0F5E_P_0 */
9548 { "vdivps", { XM
, Vex
, EXx
} },
9551 /* VEX_W_0F5E_P_1 */
9552 { "vdivss", { XMScalar
, VexScalar
, EXdScalar
} },
9555 /* VEX_W_0F5E_P_2 */
9556 { "vdivpd", { XM
, Vex
, EXx
} },
9559 /* VEX_W_0F5E_P_3 */
9560 { "vdivsd", { XMScalar
, VexScalar
, EXqScalar
} },
9563 /* VEX_W_0F5F_P_0 */
9564 { "vmaxps", { XM
, Vex
, EXx
} },
9567 /* VEX_W_0F5F_P_1 */
9568 { "vmaxss", { XMScalar
, VexScalar
, EXdScalar
} },
9571 /* VEX_W_0F5F_P_2 */
9572 { "vmaxpd", { XM
, Vex
, EXx
} },
9575 /* VEX_W_0F5F_P_3 */
9576 { "vmaxsd", { XMScalar
, VexScalar
, EXqScalar
} },
9579 /* VEX_W_0F60_P_2 */
9580 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
9583 /* VEX_W_0F61_P_2 */
9584 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
9587 /* VEX_W_0F62_P_2 */
9588 { "vpunpckldq", { XM
, Vex128
, EXx
} },
9591 /* VEX_W_0F63_P_2 */
9592 { "vpacksswb", { XM
, Vex128
, EXx
} },
9595 /* VEX_W_0F64_P_2 */
9596 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
9599 /* VEX_W_0F65_P_2 */
9600 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
9603 /* VEX_W_0F66_P_2 */
9604 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
9607 /* VEX_W_0F67_P_2 */
9608 { "vpackuswb", { XM
, Vex128
, EXx
} },
9611 /* VEX_W_0F68_P_2 */
9612 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
9615 /* VEX_W_0F69_P_2 */
9616 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
9619 /* VEX_W_0F6A_P_2 */
9620 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
9623 /* VEX_W_0F6B_P_2 */
9624 { "vpackssdw", { XM
, Vex128
, EXx
} },
9627 /* VEX_W_0F6C_P_2 */
9628 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
9631 /* VEX_W_0F6D_P_2 */
9632 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
9635 /* VEX_W_0F6F_P_1 */
9636 { "vmovdqu", { XM
, EXx
} },
9639 /* VEX_W_0F6F_P_2 */
9640 { "vmovdqa", { XM
, EXx
} },
9643 /* VEX_W_0F70_P_1 */
9644 { "vpshufhw", { XM
, EXx
, Ib
} },
9647 /* VEX_W_0F70_P_2 */
9648 { "vpshufd", { XM
, EXx
, Ib
} },
9651 /* VEX_W_0F70_P_3 */
9652 { "vpshuflw", { XM
, EXx
, Ib
} },
9655 /* VEX_W_0F71_R_2_P_2 */
9656 { "vpsrlw", { Vex128
, XS
, Ib
} },
9659 /* VEX_W_0F71_R_4_P_2 */
9660 { "vpsraw", { Vex128
, XS
, Ib
} },
9663 /* VEX_W_0F71_R_6_P_2 */
9664 { "vpsllw", { Vex128
, XS
, Ib
} },
9667 /* VEX_W_0F72_R_2_P_2 */
9668 { "vpsrld", { Vex128
, XS
, Ib
} },
9671 /* VEX_W_0F72_R_4_P_2 */
9672 { "vpsrad", { Vex128
, XS
, Ib
} },
9675 /* VEX_W_0F72_R_6_P_2 */
9676 { "vpslld", { Vex128
, XS
, Ib
} },
9679 /* VEX_W_0F73_R_2_P_2 */
9680 { "vpsrlq", { Vex128
, XS
, Ib
} },
9683 /* VEX_W_0F73_R_3_P_2 */
9684 { "vpsrldq", { Vex128
, XS
, Ib
} },
9687 /* VEX_W_0F73_R_6_P_2 */
9688 { "vpsllq", { Vex128
, XS
, Ib
} },
9691 /* VEX_W_0F73_R_7_P_2 */
9692 { "vpslldq", { Vex128
, XS
, Ib
} },
9695 /* VEX_W_0F74_P_2 */
9696 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
9699 /* VEX_W_0F75_P_2 */
9700 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
9703 /* VEX_W_0F76_P_2 */
9704 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
9707 /* VEX_W_0F77_P_0 */
9711 /* VEX_W_0F7C_P_2 */
9712 { "vhaddpd", { XM
, Vex
, EXx
} },
9715 /* VEX_W_0F7C_P_3 */
9716 { "vhaddps", { XM
, Vex
, EXx
} },
9719 /* VEX_W_0F7D_P_2 */
9720 { "vhsubpd", { XM
, Vex
, EXx
} },
9723 /* VEX_W_0F7D_P_3 */
9724 { "vhsubps", { XM
, Vex
, EXx
} },
9727 /* VEX_W_0F7E_P_1 */
9728 { "vmovq", { XMScalar
, EXqScalar
} },
9731 /* VEX_W_0F7F_P_1 */
9732 { "vmovdqu", { EXxS
, XM
} },
9735 /* VEX_W_0F7F_P_2 */
9736 { "vmovdqa", { EXxS
, XM
} },
9739 /* VEX_W_0FAE_R_2_M_0 */
9740 { "vldmxcsr", { Md
} },
9743 /* VEX_W_0FAE_R_3_M_0 */
9744 { "vstmxcsr", { Md
} },
9747 /* VEX_W_0FC2_P_0 */
9748 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
9751 /* VEX_W_0FC2_P_1 */
9752 { "vcmpss", { XMScalar
, VexScalar
, EXdScalar
, VCMP
} },
9755 /* VEX_W_0FC2_P_2 */
9756 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
9759 /* VEX_W_0FC2_P_3 */
9760 { "vcmpsd", { XMScalar
, VexScalar
, EXqScalar
, VCMP
} },
9763 /* VEX_W_0FC4_P_2 */
9764 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
9767 /* VEX_W_0FC5_P_2 */
9768 { "vpextrw", { Gdq
, XS
, Ib
} },
9771 /* VEX_W_0FD0_P_2 */
9772 { "vaddsubpd", { XM
, Vex
, EXx
} },
9775 /* VEX_W_0FD0_P_3 */
9776 { "vaddsubps", { XM
, Vex
, EXx
} },
9779 /* VEX_W_0FD1_P_2 */
9780 { "vpsrlw", { XM
, Vex128
, EXx
} },
9783 /* VEX_W_0FD2_P_2 */
9784 { "vpsrld", { XM
, Vex128
, EXx
} },
9787 /* VEX_W_0FD3_P_2 */
9788 { "vpsrlq", { XM
, Vex128
, EXx
} },
9791 /* VEX_W_0FD4_P_2 */
9792 { "vpaddq", { XM
, Vex128
, EXx
} },
9795 /* VEX_W_0FD5_P_2 */
9796 { "vpmullw", { XM
, Vex128
, EXx
} },
9799 /* VEX_W_0FD6_P_2 */
9800 { "vmovq", { EXqScalarS
, XMScalar
} },
9803 /* VEX_W_0FD7_P_2_M_1 */
9804 { "vpmovmskb", { Gdq
, XS
} },
9807 /* VEX_W_0FD8_P_2 */
9808 { "vpsubusb", { XM
, Vex128
, EXx
} },
9811 /* VEX_W_0FD9_P_2 */
9812 { "vpsubusw", { XM
, Vex128
, EXx
} },
9815 /* VEX_W_0FDA_P_2 */
9816 { "vpminub", { XM
, Vex128
, EXx
} },
9819 /* VEX_W_0FDB_P_2 */
9820 { "vpand", { XM
, Vex128
, EXx
} },
9823 /* VEX_W_0FDC_P_2 */
9824 { "vpaddusb", { XM
, Vex128
, EXx
} },
9827 /* VEX_W_0FDD_P_2 */
9828 { "vpaddusw", { XM
, Vex128
, EXx
} },
9831 /* VEX_W_0FDE_P_2 */
9832 { "vpmaxub", { XM
, Vex128
, EXx
} },
9835 /* VEX_W_0FDF_P_2 */
9836 { "vpandn", { XM
, Vex128
, EXx
} },
9839 /* VEX_W_0FE0_P_2 */
9840 { "vpavgb", { XM
, Vex128
, EXx
} },
9843 /* VEX_W_0FE1_P_2 */
9844 { "vpsraw", { XM
, Vex128
, EXx
} },
9847 /* VEX_W_0FE2_P_2 */
9848 { "vpsrad", { XM
, Vex128
, EXx
} },
9851 /* VEX_W_0FE3_P_2 */
9852 { "vpavgw", { XM
, Vex128
, EXx
} },
9855 /* VEX_W_0FE4_P_2 */
9856 { "vpmulhuw", { XM
, Vex128
, EXx
} },
9859 /* VEX_W_0FE5_P_2 */
9860 { "vpmulhw", { XM
, Vex128
, EXx
} },
9863 /* VEX_W_0FE6_P_1 */
9864 { "vcvtdq2pd", { XM
, EXxmmq
} },
9867 /* VEX_W_0FE6_P_2 */
9868 { "vcvttpd2dq%XY", { XMM
, EXx
} },
9871 /* VEX_W_0FE6_P_3 */
9872 { "vcvtpd2dq%XY", { XMM
, EXx
} },
9875 /* VEX_W_0FE7_P_2_M_0 */
9876 { "vmovntdq", { Mx
, XM
} },
9879 /* VEX_W_0FE8_P_2 */
9880 { "vpsubsb", { XM
, Vex128
, EXx
} },
9883 /* VEX_W_0FE9_P_2 */
9884 { "vpsubsw", { XM
, Vex128
, EXx
} },
9887 /* VEX_W_0FEA_P_2 */
9888 { "vpminsw", { XM
, Vex128
, EXx
} },
9891 /* VEX_W_0FEB_P_2 */
9892 { "vpor", { XM
, Vex128
, EXx
} },
9895 /* VEX_W_0FEC_P_2 */
9896 { "vpaddsb", { XM
, Vex128
, EXx
} },
9899 /* VEX_W_0FED_P_2 */
9900 { "vpaddsw", { XM
, Vex128
, EXx
} },
9903 /* VEX_W_0FEE_P_2 */
9904 { "vpmaxsw", { XM
, Vex128
, EXx
} },
9907 /* VEX_W_0FEF_P_2 */
9908 { "vpxor", { XM
, Vex128
, EXx
} },
9911 /* VEX_W_0FF0_P_3_M_0 */
9912 { "vlddqu", { XM
, M
} },
9915 /* VEX_W_0FF1_P_2 */
9916 { "vpsllw", { XM
, Vex128
, EXx
} },
9919 /* VEX_W_0FF2_P_2 */
9920 { "vpslld", { XM
, Vex128
, EXx
} },
9923 /* VEX_W_0FF3_P_2 */
9924 { "vpsllq", { XM
, Vex128
, EXx
} },
9927 /* VEX_W_0FF4_P_2 */
9928 { "vpmuludq", { XM
, Vex128
, EXx
} },
9931 /* VEX_W_0FF5_P_2 */
9932 { "vpmaddwd", { XM
, Vex128
, EXx
} },
9935 /* VEX_W_0FF6_P_2 */
9936 { "vpsadbw", { XM
, Vex128
, EXx
} },
9939 /* VEX_W_0FF7_P_2 */
9940 { "vmaskmovdqu", { XM
, XS
} },
9943 /* VEX_W_0FF8_P_2 */
9944 { "vpsubb", { XM
, Vex128
, EXx
} },
9947 /* VEX_W_0FF9_P_2 */
9948 { "vpsubw", { XM
, Vex128
, EXx
} },
9951 /* VEX_W_0FFA_P_2 */
9952 { "vpsubd", { XM
, Vex128
, EXx
} },
9955 /* VEX_W_0FFB_P_2 */
9956 { "vpsubq", { XM
, Vex128
, EXx
} },
9959 /* VEX_W_0FFC_P_2 */
9960 { "vpaddb", { XM
, Vex128
, EXx
} },
9963 /* VEX_W_0FFD_P_2 */
9964 { "vpaddw", { XM
, Vex128
, EXx
} },
9967 /* VEX_W_0FFE_P_2 */
9968 { "vpaddd", { XM
, Vex128
, EXx
} },
9971 /* VEX_W_0F3800_P_2 */
9972 { "vpshufb", { XM
, Vex128
, EXx
} },
9975 /* VEX_W_0F3801_P_2 */
9976 { "vphaddw", { XM
, Vex128
, EXx
} },
9979 /* VEX_W_0F3802_P_2 */
9980 { "vphaddd", { XM
, Vex128
, EXx
} },
9983 /* VEX_W_0F3803_P_2 */
9984 { "vphaddsw", { XM
, Vex128
, EXx
} },
9987 /* VEX_W_0F3804_P_2 */
9988 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
9991 /* VEX_W_0F3805_P_2 */
9992 { "vphsubw", { XM
, Vex128
, EXx
} },
9995 /* VEX_W_0F3806_P_2 */
9996 { "vphsubd", { XM
, Vex128
, EXx
} },
9999 /* VEX_W_0F3807_P_2 */
10000 { "vphsubsw", { XM
, Vex128
, EXx
} },
10003 /* VEX_W_0F3808_P_2 */
10004 { "vpsignb", { XM
, Vex128
, EXx
} },
10007 /* VEX_W_0F3809_P_2 */
10008 { "vpsignw", { XM
, Vex128
, EXx
} },
10011 /* VEX_W_0F380A_P_2 */
10012 { "vpsignd", { XM
, Vex128
, EXx
} },
10015 /* VEX_W_0F380B_P_2 */
10016 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
10019 /* VEX_W_0F380C_P_2 */
10020 { "vpermilps", { XM
, Vex
, EXx
} },
10023 /* VEX_W_0F380D_P_2 */
10024 { "vpermilpd", { XM
, Vex
, EXx
} },
10027 /* VEX_W_0F380E_P_2 */
10028 { "vtestps", { XM
, EXx
} },
10031 /* VEX_W_0F380F_P_2 */
10032 { "vtestpd", { XM
, EXx
} },
10035 /* VEX_W_0F3817_P_2 */
10036 { "vptest", { XM
, EXx
} },
10039 /* VEX_W_0F3818_P_2_M_0 */
10040 { "vbroadcastss", { XM
, Md
} },
10043 /* VEX_W_0F3819_P_2_M_0 */
10044 { "vbroadcastsd", { XM
, Mq
} },
10047 /* VEX_W_0F381A_P_2_M_0 */
10048 { "vbroadcastf128", { XM
, Mxmm
} },
10051 /* VEX_W_0F381C_P_2 */
10052 { "vpabsb", { XM
, EXx
} },
10055 /* VEX_W_0F381D_P_2 */
10056 { "vpabsw", { XM
, EXx
} },
10059 /* VEX_W_0F381E_P_2 */
10060 { "vpabsd", { XM
, EXx
} },
10063 /* VEX_W_0F3820_P_2 */
10064 { "vpmovsxbw", { XM
, EXq
} },
10067 /* VEX_W_0F3821_P_2 */
10068 { "vpmovsxbd", { XM
, EXd
} },
10071 /* VEX_W_0F3822_P_2 */
10072 { "vpmovsxbq", { XM
, EXw
} },
10075 /* VEX_W_0F3823_P_2 */
10076 { "vpmovsxwd", { XM
, EXq
} },
10079 /* VEX_W_0F3824_P_2 */
10080 { "vpmovsxwq", { XM
, EXd
} },
10083 /* VEX_W_0F3825_P_2 */
10084 { "vpmovsxdq", { XM
, EXq
} },
10087 /* VEX_W_0F3828_P_2 */
10088 { "vpmuldq", { XM
, Vex128
, EXx
} },
10091 /* VEX_W_0F3829_P_2 */
10092 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
10095 /* VEX_W_0F382A_P_2_M_0 */
10096 { "vmovntdqa", { XM
, Mx
} },
10099 /* VEX_W_0F382B_P_2 */
10100 { "vpackusdw", { XM
, Vex128
, EXx
} },
10103 /* VEX_W_0F382C_P_2_M_0 */
10104 { "vmaskmovps", { XM
, Vex
, Mx
} },
10107 /* VEX_W_0F382D_P_2_M_0 */
10108 { "vmaskmovpd", { XM
, Vex
, Mx
} },
10111 /* VEX_W_0F382E_P_2_M_0 */
10112 { "vmaskmovps", { Mx
, Vex
, XM
} },
10115 /* VEX_W_0F382F_P_2_M_0 */
10116 { "vmaskmovpd", { Mx
, Vex
, XM
} },
10119 /* VEX_W_0F3830_P_2 */
10120 { "vpmovzxbw", { XM
, EXq
} },
10123 /* VEX_W_0F3831_P_2 */
10124 { "vpmovzxbd", { XM
, EXd
} },
10127 /* VEX_W_0F3832_P_2 */
10128 { "vpmovzxbq", { XM
, EXw
} },
10131 /* VEX_W_0F3833_P_2 */
10132 { "vpmovzxwd", { XM
, EXq
} },
10135 /* VEX_W_0F3834_P_2 */
10136 { "vpmovzxwq", { XM
, EXd
} },
10139 /* VEX_W_0F3835_P_2 */
10140 { "vpmovzxdq", { XM
, EXq
} },
10143 /* VEX_W_0F3837_P_2 */
10144 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
10147 /* VEX_W_0F3838_P_2 */
10148 { "vpminsb", { XM
, Vex128
, EXx
} },
10151 /* VEX_W_0F3839_P_2 */
10152 { "vpminsd", { XM
, Vex128
, EXx
} },
10155 /* VEX_W_0F383A_P_2 */
10156 { "vpminuw", { XM
, Vex128
, EXx
} },
10159 /* VEX_W_0F383B_P_2 */
10160 { "vpminud", { XM
, Vex128
, EXx
} },
10163 /* VEX_W_0F383C_P_2 */
10164 { "vpmaxsb", { XM
, Vex128
, EXx
} },
10167 /* VEX_W_0F383D_P_2 */
10168 { "vpmaxsd", { XM
, Vex128
, EXx
} },
10171 /* VEX_W_0F383E_P_2 */
10172 { "vpmaxuw", { XM
, Vex128
, EXx
} },
10175 /* VEX_W_0F383F_P_2 */
10176 { "vpmaxud", { XM
, Vex128
, EXx
} },
10179 /* VEX_W_0F3840_P_2 */
10180 { "vpmulld", { XM
, Vex128
, EXx
} },
10183 /* VEX_W_0F3841_P_2 */
10184 { "vphminposuw", { XM
, EXx
} },
10187 /* VEX_W_0F38DB_P_2 */
10188 { "vaesimc", { XM
, EXx
} },
10191 /* VEX_W_0F38DC_P_2 */
10192 { "vaesenc", { XM
, Vex128
, EXx
} },
10195 /* VEX_W_0F38DD_P_2 */
10196 { "vaesenclast", { XM
, Vex128
, EXx
} },
10199 /* VEX_W_0F38DE_P_2 */
10200 { "vaesdec", { XM
, Vex128
, EXx
} },
10203 /* VEX_W_0F38DF_P_2 */
10204 { "vaesdeclast", { XM
, Vex128
, EXx
} },
10207 /* VEX_W_0F3A04_P_2 */
10208 { "vpermilps", { XM
, EXx
, Ib
} },
10211 /* VEX_W_0F3A05_P_2 */
10212 { "vpermilpd", { XM
, EXx
, Ib
} },
10215 /* VEX_W_0F3A06_P_2 */
10216 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
10219 /* VEX_W_0F3A08_P_2 */
10220 { "vroundps", { XM
, EXx
, Ib
} },
10223 /* VEX_W_0F3A09_P_2 */
10224 { "vroundpd", { XM
, EXx
, Ib
} },
10227 /* VEX_W_0F3A0A_P_2 */
10228 { "vroundss", { XMScalar
, VexScalar
, EXdScalar
, Ib
} },
10231 /* VEX_W_0F3A0B_P_2 */
10232 { "vroundsd", { XMScalar
, VexScalar
, EXqScalar
, Ib
} },
10235 /* VEX_W_0F3A0C_P_2 */
10236 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
10239 /* VEX_W_0F3A0D_P_2 */
10240 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
10243 /* VEX_W_0F3A0E_P_2 */
10244 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
10247 /* VEX_W_0F3A0F_P_2 */
10248 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
10251 /* VEX_W_0F3A14_P_2 */
10252 { "vpextrb", { Edqb
, XM
, Ib
} },
10255 /* VEX_W_0F3A15_P_2 */
10256 { "vpextrw", { Edqw
, XM
, Ib
} },
10259 /* VEX_W_0F3A18_P_2 */
10260 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
10263 /* VEX_W_0F3A19_P_2 */
10264 { "vextractf128", { EXxmm
, XM
, Ib
} },
10267 /* VEX_W_0F3A20_P_2 */
10268 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
10271 /* VEX_W_0F3A21_P_2 */
10272 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
10275 /* VEX_W_0F3A40_P_2 */
10276 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
10279 /* VEX_W_0F3A41_P_2 */
10280 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
10283 /* VEX_W_0F3A42_P_2 */
10284 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
10287 /* VEX_W_0F3A44_P_2 */
10288 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
10291 /* VEX_W_0F3A48_P_2 */
10292 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10293 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10296 /* VEX_W_0F3A49_P_2 */
10297 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10298 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10301 /* VEX_W_0F3A4A_P_2 */
10302 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
10305 /* VEX_W_0F3A4B_P_2 */
10306 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
10309 /* VEX_W_0F3A4C_P_2 */
10310 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
10313 /* VEX_W_0F3A60_P_2 */
10314 { "vpcmpestrm", { XM
, EXx
, Ib
} },
10317 /* VEX_W_0F3A61_P_2 */
10318 { "vpcmpestri", { XM
, EXx
, Ib
} },
10321 /* VEX_W_0F3A62_P_2 */
10322 { "vpcmpistrm", { XM
, EXx
, Ib
} },
10325 /* VEX_W_0F3A63_P_2 */
10326 { "vpcmpistri", { XM
, EXx
, Ib
} },
10329 /* VEX_W_0F3ADF_P_2 */
10330 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
10334 static const struct dis386 mod_table
[][2] = {
10337 { "leaS", { Gv
, M
} },
10340 /* MOD_0F01_REG_0 */
10341 { X86_64_TABLE (X86_64_0F01_REG_0
) },
10342 { RM_TABLE (RM_0F01_REG_0
) },
10345 /* MOD_0F01_REG_1 */
10346 { X86_64_TABLE (X86_64_0F01_REG_1
) },
10347 { RM_TABLE (RM_0F01_REG_1
) },
10350 /* MOD_0F01_REG_2 */
10351 { X86_64_TABLE (X86_64_0F01_REG_2
) },
10352 { RM_TABLE (RM_0F01_REG_2
) },
10355 /* MOD_0F01_REG_3 */
10356 { X86_64_TABLE (X86_64_0F01_REG_3
) },
10357 { RM_TABLE (RM_0F01_REG_3
) },
10360 /* MOD_0F01_REG_7 */
10361 { "invlpg", { Mb
} },
10362 { RM_TABLE (RM_0F01_REG_7
) },
10365 /* MOD_0F12_PREFIX_0 */
10366 { "movlps", { XM
, EXq
} },
10367 { "movhlps", { XM
, EXq
} },
10371 { "movlpX", { EXq
, XM
} },
10374 /* MOD_0F16_PREFIX_0 */
10375 { "movhps", { XM
, EXq
} },
10376 { "movlhps", { XM
, EXq
} },
10380 { "movhpX", { EXq
, XM
} },
10383 /* MOD_0F18_REG_0 */
10384 { "prefetchnta", { Mb
} },
10387 /* MOD_0F18_REG_1 */
10388 { "prefetcht0", { Mb
} },
10391 /* MOD_0F18_REG_2 */
10392 { "prefetcht1", { Mb
} },
10395 /* MOD_0F18_REG_3 */
10396 { "prefetcht2", { Mb
} },
10401 { "movZ", { Rm
, Cm
} },
10406 { "movZ", { Rm
, Dm
} },
10411 { "movZ", { Cm
, Rm
} },
10416 { "movZ", { Dm
, Rm
} },
10421 { "movL", { Rd
, Td
} },
10426 { "movL", { Td
, Rd
} },
10429 /* MOD_0F2B_PREFIX_0 */
10430 {"movntps", { Mx
, XM
} },
10433 /* MOD_0F2B_PREFIX_1 */
10434 {"movntss", { Md
, XM
} },
10437 /* MOD_0F2B_PREFIX_2 */
10438 {"movntpd", { Mx
, XM
} },
10441 /* MOD_0F2B_PREFIX_3 */
10442 {"movntsd", { Mq
, XM
} },
10447 { "movmskpX", { Gdq
, XS
} },
10450 /* MOD_0F71_REG_2 */
10452 { "psrlw", { MS
, Ib
} },
10455 /* MOD_0F71_REG_4 */
10457 { "psraw", { MS
, Ib
} },
10460 /* MOD_0F71_REG_6 */
10462 { "psllw", { MS
, Ib
} },
10465 /* MOD_0F72_REG_2 */
10467 { "psrld", { MS
, Ib
} },
10470 /* MOD_0F72_REG_4 */
10472 { "psrad", { MS
, Ib
} },
10475 /* MOD_0F72_REG_6 */
10477 { "pslld", { MS
, Ib
} },
10480 /* MOD_0F73_REG_2 */
10482 { "psrlq", { MS
, Ib
} },
10485 /* MOD_0F73_REG_3 */
10487 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
10490 /* MOD_0F73_REG_6 */
10492 { "psllq", { MS
, Ib
} },
10495 /* MOD_0F73_REG_7 */
10497 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
10500 /* MOD_0FAE_REG_0 */
10501 { "fxsave", { FXSAVE
} },
10502 { PREFIX_TABLE (PREFIX_0FAE_REG_0
) },
10505 /* MOD_0FAE_REG_1 */
10506 { "fxrstor", { FXSAVE
} },
10507 { PREFIX_TABLE (PREFIX_0FAE_REG_1
) },
10510 /* MOD_0FAE_REG_2 */
10511 { "ldmxcsr", { Md
} },
10512 { PREFIX_TABLE (PREFIX_0FAE_REG_2
) },
10515 /* MOD_0FAE_REG_3 */
10516 { "stmxcsr", { Md
} },
10517 { PREFIX_TABLE (PREFIX_0FAE_REG_3
) },
10520 /* MOD_0FAE_REG_4 */
10521 { "xsave", { FXSAVE
} },
10524 /* MOD_0FAE_REG_5 */
10525 { "xrstor", { FXSAVE
} },
10526 { RM_TABLE (RM_0FAE_REG_5
) },
10529 /* MOD_0FAE_REG_6 */
10530 { "xsaveopt", { FXSAVE
} },
10531 { RM_TABLE (RM_0FAE_REG_6
) },
10534 /* MOD_0FAE_REG_7 */
10535 { "clflush", { Mb
} },
10536 { RM_TABLE (RM_0FAE_REG_7
) },
10540 { "lssS", { Gv
, Mp
} },
10544 { "lfsS", { Gv
, Mp
} },
10548 { "lgsS", { Gv
, Mp
} },
10551 /* MOD_0FC7_REG_6 */
10552 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
10553 { "rdrand", { Ev
} },
10556 /* MOD_0FC7_REG_7 */
10557 { "vmptrst", { Mq
} },
10562 { "pmovmskb", { Gdq
, MS
} },
10565 /* MOD_0FE7_PREFIX_2 */
10566 { "movntdq", { Mx
, XM
} },
10569 /* MOD_0FF0_PREFIX_3 */
10570 { "lddqu", { XM
, M
} },
10573 /* MOD_0F382A_PREFIX_2 */
10574 { "movntdqa", { XM
, Mx
} },
10578 { "bound{S|}", { Gv
, Ma
} },
10582 { "lesS", { Gv
, Mp
} },
10583 { VEX_C4_TABLE (VEX_0F
) },
10587 { "ldsS", { Gv
, Mp
} },
10588 { VEX_C5_TABLE (VEX_0F
) },
10591 /* MOD_VEX_0F12_PREFIX_0 */
10592 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_0
) },
10593 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_1
) },
10597 { VEX_LEN_TABLE (VEX_LEN_0F13_M_0
) },
10600 /* MOD_VEX_0F16_PREFIX_0 */
10601 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_0
) },
10602 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_1
) },
10606 { VEX_LEN_TABLE (VEX_LEN_0F17_M_0
) },
10610 { VEX_W_TABLE (VEX_W_0F2B_M_0
) },
10615 { VEX_W_TABLE (VEX_W_0F50_M_0
) },
10618 /* MOD_VEX_0F71_REG_2 */
10620 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_2
) },
10623 /* MOD_VEX_0F71_REG_4 */
10625 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_4
) },
10628 /* MOD_VEX_0F71_REG_6 */
10630 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_6
) },
10633 /* MOD_VEX_0F72_REG_2 */
10635 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_2
) },
10638 /* MOD_VEX_0F72_REG_4 */
10640 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_4
) },
10643 /* MOD_VEX_0F72_REG_6 */
10645 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_6
) },
10648 /* MOD_VEX_0F73_REG_2 */
10650 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_2
) },
10653 /* MOD_VEX_0F73_REG_3 */
10655 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_3
) },
10658 /* MOD_VEX_0F73_REG_6 */
10660 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_6
) },
10663 /* MOD_VEX_0F73_REG_7 */
10665 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_7
) },
10668 /* MOD_VEX_0FAE_REG_2 */
10669 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_2_M_0
) },
10672 /* MOD_VEX_0FAE_REG_3 */
10673 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_3_M_0
) },
10676 /* MOD_VEX_0FD7_PREFIX_2 */
10678 { VEX_LEN_TABLE (VEX_LEN_0FD7_P_2_M_1
) },
10681 /* MOD_VEX_0FE7_PREFIX_2 */
10682 { VEX_W_TABLE (VEX_W_0FE7_P_2_M_0
) },
10685 /* MOD_VEX_0FF0_PREFIX_3 */
10686 { VEX_W_TABLE (VEX_W_0FF0_P_3_M_0
) },
10689 /* MOD_VEX_0F3818_PREFIX_2 */
10690 { VEX_W_TABLE (VEX_W_0F3818_P_2_M_0
) },
10693 /* MOD_VEX_0F3819_PREFIX_2 */
10694 { VEX_LEN_TABLE (VEX_LEN_0F3819_P_2_M_0
) },
10697 /* MOD_VEX_0F381A_PREFIX_2 */
10698 { VEX_LEN_TABLE (VEX_LEN_0F381A_P_2_M_0
) },
10701 /* MOD_VEX_0F382A_PREFIX_2 */
10702 { VEX_LEN_TABLE (VEX_LEN_0F382A_P_2_M_0
) },
10705 /* MOD_VEX_0F382C_PREFIX_2 */
10706 { VEX_W_TABLE (VEX_W_0F382C_P_2_M_0
) },
10709 /* MOD_VEX_0F382D_PREFIX_2 */
10710 { VEX_W_TABLE (VEX_W_0F382D_P_2_M_0
) },
10713 /* MOD_VEX_0F382E_PREFIX_2 */
10714 { VEX_W_TABLE (VEX_W_0F382E_P_2_M_0
) },
10717 /* MOD_VEX_0F382F_PREFIX_2 */
10718 { VEX_W_TABLE (VEX_W_0F382F_P_2_M_0
) },
10722 static const struct dis386 rm_table
[][8] = {
10724 /* RM_0F01_REG_0 */
10726 { "vmcall", { Skip_MODRM
} },
10727 { "vmlaunch", { Skip_MODRM
} },
10728 { "vmresume", { Skip_MODRM
} },
10729 { "vmxoff", { Skip_MODRM
} },
10732 /* RM_0F01_REG_1 */
10733 { "monitor", { { OP_Monitor
, 0 } } },
10734 { "mwait", { { OP_Mwait
, 0 } } },
10737 /* RM_0F01_REG_2 */
10738 { "xgetbv", { Skip_MODRM
} },
10739 { "xsetbv", { Skip_MODRM
} },
10742 /* RM_0F01_REG_3 */
10743 { "vmrun", { Skip_MODRM
} },
10744 { "vmmcall", { Skip_MODRM
} },
10745 { "vmload", { Skip_MODRM
} },
10746 { "vmsave", { Skip_MODRM
} },
10747 { "stgi", { Skip_MODRM
} },
10748 { "clgi", { Skip_MODRM
} },
10749 { "skinit", { Skip_MODRM
} },
10750 { "invlpga", { Skip_MODRM
} },
10753 /* RM_0F01_REG_7 */
10754 { "swapgs", { Skip_MODRM
} },
10755 { "rdtscp", { Skip_MODRM
} },
10758 /* RM_0FAE_REG_5 */
10759 { "lfence", { Skip_MODRM
} },
10762 /* RM_0FAE_REG_6 */
10763 { "mfence", { Skip_MODRM
} },
10766 /* RM_0FAE_REG_7 */
10767 { "sfence", { Skip_MODRM
} },
10771 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
10773 /* We use the high bit to indicate different name for the same
10775 #define ADDR16_PREFIX (0x67 | 0x100)
10776 #define ADDR32_PREFIX (0x67 | 0x200)
10777 #define DATA16_PREFIX (0x66 | 0x100)
10778 #define DATA32_PREFIX (0x66 | 0x200)
10779 #define REP_PREFIX (0xf3 | 0x100)
10784 int newrex
, i
, length
;
10790 last_lock_prefix
= -1;
10791 last_repz_prefix
= -1;
10792 last_repnz_prefix
= -1;
10793 last_data_prefix
= -1;
10794 last_addr_prefix
= -1;
10795 last_rex_prefix
= -1;
10796 last_seg_prefix
= -1;
10797 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10798 all_prefixes
[i
] = 0;
10801 /* The maximum instruction length is 15bytes. */
10802 while (length
< MAX_CODE_LENGTH
- 1)
10804 FETCH_DATA (the_info
, codep
+ 1);
10808 /* REX prefixes family. */
10825 if (address_mode
== mode_64bit
)
10829 last_rex_prefix
= i
;
10832 prefixes
|= PREFIX_REPZ
;
10833 last_repz_prefix
= i
;
10836 prefixes
|= PREFIX_REPNZ
;
10837 last_repnz_prefix
= i
;
10840 prefixes
|= PREFIX_LOCK
;
10841 last_lock_prefix
= i
;
10844 prefixes
|= PREFIX_CS
;
10845 last_seg_prefix
= i
;
10848 prefixes
|= PREFIX_SS
;
10849 last_seg_prefix
= i
;
10852 prefixes
|= PREFIX_DS
;
10853 last_seg_prefix
= i
;
10856 prefixes
|= PREFIX_ES
;
10857 last_seg_prefix
= i
;
10860 prefixes
|= PREFIX_FS
;
10861 last_seg_prefix
= i
;
10864 prefixes
|= PREFIX_GS
;
10865 last_seg_prefix
= i
;
10868 prefixes
|= PREFIX_DATA
;
10869 last_data_prefix
= i
;
10872 prefixes
|= PREFIX_ADDR
;
10873 last_addr_prefix
= i
;
10876 /* fwait is really an instruction. If there are prefixes
10877 before the fwait, they belong to the fwait, *not* to the
10878 following instruction. */
10879 if (prefixes
|| rex
)
10881 prefixes
|= PREFIX_FWAIT
;
10885 prefixes
= PREFIX_FWAIT
;
10890 /* Rex is ignored when followed by another prefix. */
10896 if (*codep
!= FWAIT_OPCODE
)
10897 all_prefixes
[i
++] = *codep
;
10906 seg_prefix (int pref
)
10927 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10930 static const char *
10931 prefix_name (int pref
, int sizeflag
)
10933 static const char *rexes
[16] =
10936 "rex.B", /* 0x41 */
10937 "rex.X", /* 0x42 */
10938 "rex.XB", /* 0x43 */
10939 "rex.R", /* 0x44 */
10940 "rex.RB", /* 0x45 */
10941 "rex.RX", /* 0x46 */
10942 "rex.RXB", /* 0x47 */
10943 "rex.W", /* 0x48 */
10944 "rex.WB", /* 0x49 */
10945 "rex.WX", /* 0x4a */
10946 "rex.WXB", /* 0x4b */
10947 "rex.WR", /* 0x4c */
10948 "rex.WRB", /* 0x4d */
10949 "rex.WRX", /* 0x4e */
10950 "rex.WRXB", /* 0x4f */
10955 /* REX prefixes family. */
10972 return rexes
[pref
- 0x40];
10992 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10994 if (address_mode
== mode_64bit
)
10995 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10997 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
11000 case ADDR16_PREFIX
:
11002 case ADDR32_PREFIX
:
11004 case DATA16_PREFIX
:
11006 case DATA32_PREFIX
:
11015 static char op_out
[MAX_OPERANDS
][100];
11016 static int op_ad
, op_index
[MAX_OPERANDS
];
11017 static int two_source_ops
;
11018 static bfd_vma op_address
[MAX_OPERANDS
];
11019 static bfd_vma op_riprel
[MAX_OPERANDS
];
11020 static bfd_vma start_pc
;
11023 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
11024 * (see topic "Redundant prefixes" in the "Differences from 8086"
11025 * section of the "Virtual 8086 Mode" chapter.)
11026 * 'pc' should be the address of this instruction, it will
11027 * be used to print the target address if this is a relative jump or call
11028 * The function returns the length of this instruction in bytes.
11031 static char intel_syntax
;
11032 static char intel_mnemonic
= !SYSV386_COMPAT
;
11033 static char open_char
;
11034 static char close_char
;
11035 static char separator_char
;
11036 static char scale_char
;
11038 /* Here for backwards compatibility. When gdb stops using
11039 print_insn_i386_att and print_insn_i386_intel these functions can
11040 disappear, and print_insn_i386 be merged into print_insn. */
11042 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
11046 return print_insn (pc
, info
);
11050 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
11054 return print_insn (pc
, info
);
11058 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
11062 return print_insn (pc
, info
);
11066 print_i386_disassembler_options (FILE *stream
)
11068 fprintf (stream
, _("\n\
11069 The following i386/x86-64 specific disassembler options are supported for use\n\
11070 with the -M switch (multiple options should be separated by commas):\n"));
11072 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
11073 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
11074 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
11075 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
11076 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
11077 fprintf (stream
, _(" att-mnemonic\n"
11078 " Display instruction in AT&T mnemonic\n"));
11079 fprintf (stream
, _(" intel-mnemonic\n"
11080 " Display instruction in Intel mnemonic\n"));
11081 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
11082 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
11083 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
11084 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
11085 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
11086 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
11090 static const struct dis386 bad_opcode
= { "(bad)", { XX
} };
11092 /* Get a pointer to struct dis386 with a valid name. */
11094 static const struct dis386
*
11095 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
11097 int vindex
, vex_table_index
;
11099 if (dp
->name
!= NULL
)
11102 switch (dp
->op
[0].bytemode
)
11104 case USE_REG_TABLE
:
11105 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
11108 case USE_MOD_TABLE
:
11109 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
11110 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
11114 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
11117 case USE_PREFIX_TABLE
:
11120 /* The prefix in VEX is implicit. */
11121 switch (vex
.prefix
)
11126 case REPE_PREFIX_OPCODE
:
11129 case DATA_PREFIX_OPCODE
:
11132 case REPNE_PREFIX_OPCODE
:
11143 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
11144 if (prefixes
& PREFIX_REPZ
)
11147 all_prefixes
[last_repz_prefix
] = 0;
11151 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
11153 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
11154 if (prefixes
& PREFIX_REPNZ
)
11157 all_prefixes
[last_repnz_prefix
] = 0;
11161 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11162 if (prefixes
& PREFIX_DATA
)
11165 all_prefixes
[last_data_prefix
] = 0;
11170 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
11173 case USE_X86_64_TABLE
:
11174 vindex
= address_mode
== mode_64bit
? 1 : 0;
11175 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
11178 case USE_3BYTE_TABLE
:
11179 FETCH_DATA (info
, codep
+ 2);
11181 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
11182 modrm
.mod
= (*codep
>> 6) & 3;
11183 modrm
.reg
= (*codep
>> 3) & 7;
11184 modrm
.rm
= *codep
& 7;
11187 case USE_VEX_LEN_TABLE
:
11191 switch (vex
.length
)
11204 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
11207 case USE_XOP_8F_TABLE
:
11208 FETCH_DATA (info
, codep
+ 3);
11209 /* All bits in the REX prefix are ignored. */
11211 rex
= ~(*codep
>> 5) & 0x7;
11213 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11214 switch ((*codep
& 0x1f))
11220 vex_table_index
= XOP_08
;
11223 vex_table_index
= XOP_09
;
11226 vex_table_index
= XOP_0A
;
11230 vex
.w
= *codep
& 0x80;
11231 if (vex
.w
&& address_mode
== mode_64bit
)
11234 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11235 if (address_mode
!= mode_64bit
11236 && vex
.register_specifier
> 0x7)
11242 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11243 switch ((*codep
& 0x3))
11249 vex
.prefix
= DATA_PREFIX_OPCODE
;
11252 vex
.prefix
= REPE_PREFIX_OPCODE
;
11255 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11262 dp
= &xop_table
[vex_table_index
][vindex
];
11264 FETCH_DATA (info
, codep
+ 1);
11265 modrm
.mod
= (*codep
>> 6) & 3;
11266 modrm
.reg
= (*codep
>> 3) & 7;
11267 modrm
.rm
= *codep
& 7;
11270 case USE_VEX_C4_TABLE
:
11271 FETCH_DATA (info
, codep
+ 3);
11272 /* All bits in the REX prefix are ignored. */
11274 rex
= ~(*codep
>> 5) & 0x7;
11275 switch ((*codep
& 0x1f))
11281 vex_table_index
= VEX_0F
;
11284 vex_table_index
= VEX_0F38
;
11287 vex_table_index
= VEX_0F3A
;
11291 vex
.w
= *codep
& 0x80;
11292 if (vex
.w
&& address_mode
== mode_64bit
)
11295 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11296 if (address_mode
!= mode_64bit
11297 && vex
.register_specifier
> 0x7)
11303 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11304 switch ((*codep
& 0x3))
11310 vex
.prefix
= DATA_PREFIX_OPCODE
;
11313 vex
.prefix
= REPE_PREFIX_OPCODE
;
11316 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11323 dp
= &vex_table
[vex_table_index
][vindex
];
11324 /* There is no MODRM byte for VEX [82|77]. */
11325 if (vindex
!= 0x77 && vindex
!= 0x82)
11327 FETCH_DATA (info
, codep
+ 1);
11328 modrm
.mod
= (*codep
>> 6) & 3;
11329 modrm
.reg
= (*codep
>> 3) & 7;
11330 modrm
.rm
= *codep
& 7;
11334 case USE_VEX_C5_TABLE
:
11335 FETCH_DATA (info
, codep
+ 2);
11336 /* All bits in the REX prefix are ignored. */
11338 rex
= (*codep
& 0x80) ? 0 : REX_R
;
11340 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11341 if (address_mode
!= mode_64bit
11342 && vex
.register_specifier
> 0x7)
11350 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11351 switch ((*codep
& 0x3))
11357 vex
.prefix
= DATA_PREFIX_OPCODE
;
11360 vex
.prefix
= REPE_PREFIX_OPCODE
;
11363 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11370 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
11371 /* There is no MODRM byte for VEX [82|77]. */
11372 if (vindex
!= 0x77 && vindex
!= 0x82)
11374 FETCH_DATA (info
, codep
+ 1);
11375 modrm
.mod
= (*codep
>> 6) & 3;
11376 modrm
.reg
= (*codep
>> 3) & 7;
11377 modrm
.rm
= *codep
& 7;
11381 case USE_VEX_W_TABLE
:
11385 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
11396 if (dp
->name
!= NULL
)
11399 return get_valid_dis386 (dp
, info
);
11403 get_sib (disassemble_info
*info
)
11405 /* If modrm.mod == 3, operand must be register. */
11407 && address_mode
!= mode_16bit
11411 FETCH_DATA (info
, codep
+ 2);
11412 sib
.index
= (codep
[1] >> 3) & 7;
11413 sib
.scale
= (codep
[1] >> 6) & 3;
11414 sib
.base
= codep
[1] & 7;
11419 print_insn (bfd_vma pc
, disassemble_info
*info
)
11421 const struct dis386
*dp
;
11423 char *op_txt
[MAX_OPERANDS
];
11427 struct dis_private priv
;
11429 int default_prefixes
;
11431 if (info
->mach
== bfd_mach_x86_64_intel_syntax
11432 || info
->mach
== bfd_mach_x86_64
11433 || info
->mach
== bfd_mach_x64_32_intel_syntax
11434 || info
->mach
== bfd_mach_x64_32
11435 || info
->mach
== bfd_mach_l1om
11436 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11437 address_mode
= mode_64bit
;
11439 address_mode
= mode_32bit
;
11441 if (intel_syntax
== (char) -1)
11442 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
11443 || info
->mach
== bfd_mach_x86_64_intel_syntax
11444 || info
->mach
== bfd_mach_x64_32_intel_syntax
11445 || info
->mach
== bfd_mach_l1om_intel_syntax
);
11447 if (info
->mach
== bfd_mach_i386_i386
11448 || info
->mach
== bfd_mach_x86_64
11449 || info
->mach
== bfd_mach_x64_32
11450 || info
->mach
== bfd_mach_l1om
11451 || info
->mach
== bfd_mach_i386_i386_intel_syntax
11452 || info
->mach
== bfd_mach_x86_64_intel_syntax
11453 || info
->mach
== bfd_mach_x64_32_intel_syntax
11454 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11455 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11456 else if (info
->mach
== bfd_mach_i386_i8086
)
11457 priv
.orig_sizeflag
= 0;
11461 for (p
= info
->disassembler_options
; p
!= NULL
; )
11463 if (CONST_STRNEQ (p
, "x86-64"))
11465 address_mode
= mode_64bit
;
11466 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11468 else if (CONST_STRNEQ (p
, "i386"))
11470 address_mode
= mode_32bit
;
11471 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11473 else if (CONST_STRNEQ (p
, "i8086"))
11475 address_mode
= mode_16bit
;
11476 priv
.orig_sizeflag
= 0;
11478 else if (CONST_STRNEQ (p
, "intel"))
11481 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
11482 intel_mnemonic
= 1;
11484 else if (CONST_STRNEQ (p
, "att"))
11487 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
11488 intel_mnemonic
= 0;
11490 else if (CONST_STRNEQ (p
, "addr"))
11492 if (address_mode
== mode_64bit
)
11494 if (p
[4] == '3' && p
[5] == '2')
11495 priv
.orig_sizeflag
&= ~AFLAG
;
11496 else if (p
[4] == '6' && p
[5] == '4')
11497 priv
.orig_sizeflag
|= AFLAG
;
11501 if (p
[4] == '1' && p
[5] == '6')
11502 priv
.orig_sizeflag
&= ~AFLAG
;
11503 else if (p
[4] == '3' && p
[5] == '2')
11504 priv
.orig_sizeflag
|= AFLAG
;
11507 else if (CONST_STRNEQ (p
, "data"))
11509 if (p
[4] == '1' && p
[5] == '6')
11510 priv
.orig_sizeflag
&= ~DFLAG
;
11511 else if (p
[4] == '3' && p
[5] == '2')
11512 priv
.orig_sizeflag
|= DFLAG
;
11514 else if (CONST_STRNEQ (p
, "suffix"))
11515 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
11517 p
= strchr (p
, ',');
11524 names64
= intel_names64
;
11525 names32
= intel_names32
;
11526 names16
= intel_names16
;
11527 names8
= intel_names8
;
11528 names8rex
= intel_names8rex
;
11529 names_seg
= intel_names_seg
;
11530 names_mm
= intel_names_mm
;
11531 names_xmm
= intel_names_xmm
;
11532 names_ymm
= intel_names_ymm
;
11533 index64
= intel_index64
;
11534 index32
= intel_index32
;
11535 index16
= intel_index16
;
11538 separator_char
= '+';
11543 names64
= att_names64
;
11544 names32
= att_names32
;
11545 names16
= att_names16
;
11546 names8
= att_names8
;
11547 names8rex
= att_names8rex
;
11548 names_seg
= att_names_seg
;
11549 names_mm
= att_names_mm
;
11550 names_xmm
= att_names_xmm
;
11551 names_ymm
= att_names_ymm
;
11552 index64
= att_index64
;
11553 index32
= att_index32
;
11554 index16
= att_index16
;
11557 separator_char
= ',';
11561 /* The output looks better if we put 7 bytes on a line, since that
11562 puts most long word instructions on a single line. Use 8 bytes
11564 if (info
->mach
== bfd_mach_l1om
11565 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11566 info
->bytes_per_line
= 8;
11568 info
->bytes_per_line
= 7;
11570 info
->private_data
= &priv
;
11571 priv
.max_fetched
= priv
.the_buffer
;
11572 priv
.insn_start
= pc
;
11575 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11583 start_codep
= priv
.the_buffer
;
11584 codep
= priv
.the_buffer
;
11586 if (setjmp (priv
.bailout
) != 0)
11590 /* Getting here means we tried for data but didn't get it. That
11591 means we have an incomplete instruction of some sort. Just
11592 print the first byte as a prefix or a .byte pseudo-op. */
11593 if (codep
> priv
.the_buffer
)
11595 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
11597 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11600 /* Just print the first byte as a .byte instruction. */
11601 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
11602 (unsigned int) priv
.the_buffer
[0]);
11612 sizeflag
= priv
.orig_sizeflag
;
11614 if (!ckprefix () || rex_used
)
11616 /* Too many prefixes or unused REX prefixes. */
11618 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
11620 (*info
->fprintf_func
) (info
->stream
, "%s",
11621 prefix_name (all_prefixes
[i
], sizeflag
));
11625 insn_codep
= codep
;
11627 FETCH_DATA (info
, codep
+ 1);
11628 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
11630 if (((prefixes
& PREFIX_FWAIT
)
11631 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
11633 (*info
->fprintf_func
) (info
->stream
, "fwait");
11637 if (*codep
== 0x0f)
11639 unsigned char threebyte
;
11640 FETCH_DATA (info
, codep
+ 2);
11641 threebyte
= *++codep
;
11642 dp
= &dis386_twobyte
[threebyte
];
11643 need_modrm
= twobyte_has_modrm
[*codep
];
11648 dp
= &dis386
[*codep
];
11649 need_modrm
= onebyte_has_modrm
[*codep
];
11653 if ((prefixes
& PREFIX_REPZ
))
11654 used_prefixes
|= PREFIX_REPZ
;
11655 if ((prefixes
& PREFIX_REPNZ
))
11656 used_prefixes
|= PREFIX_REPNZ
;
11657 if ((prefixes
& PREFIX_LOCK
))
11658 used_prefixes
|= PREFIX_LOCK
;
11660 default_prefixes
= 0;
11661 if (prefixes
& PREFIX_ADDR
)
11664 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
11666 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
11667 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
11669 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
11670 default_prefixes
|= PREFIX_ADDR
;
11674 if ((prefixes
& PREFIX_DATA
))
11677 if (dp
->op
[2].bytemode
== cond_jump_mode
11678 && dp
->op
[0].bytemode
== v_mode
11681 if (sizeflag
& DFLAG
)
11682 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
11684 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
11685 default_prefixes
|= PREFIX_DATA
;
11687 else if (rex
& REX_W
)
11689 /* REX_W will override PREFIX_DATA. */
11690 default_prefixes
|= PREFIX_DATA
;
11696 FETCH_DATA (info
, codep
+ 1);
11697 modrm
.mod
= (*codep
>> 6) & 3;
11698 modrm
.reg
= (*codep
>> 3) & 7;
11699 modrm
.rm
= *codep
& 7;
11706 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
11709 dofloat (sizeflag
);
11713 dp
= get_valid_dis386 (dp
, info
);
11714 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
11717 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11720 op_ad
= MAX_OPERANDS
- 1 - i
;
11722 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
11727 /* See if any prefixes were not used. If so, print the first one
11728 separately. If we don't do this, we'll wind up printing an
11729 instruction stream which does not precisely correspond to the
11730 bytes we are disassembling. */
11731 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
11733 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11734 if (all_prefixes
[i
])
11737 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
11739 name
= INTERNAL_DISASSEMBLER_ERROR
;
11740 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11745 /* Check if the REX prefix is used. */
11746 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
11747 all_prefixes
[last_rex_prefix
] = 0;
11749 /* Check if the SEG prefix is used. */
11750 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
11751 | PREFIX_FS
| PREFIX_GS
)) != 0
11753 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
11754 all_prefixes
[last_seg_prefix
] = 0;
11756 /* Check if the ADDR prefix is used. */
11757 if ((prefixes
& PREFIX_ADDR
) != 0
11758 && (used_prefixes
& PREFIX_ADDR
) != 0)
11759 all_prefixes
[last_addr_prefix
] = 0;
11761 /* Check if the DATA prefix is used. */
11762 if ((prefixes
& PREFIX_DATA
) != 0
11763 && (used_prefixes
& PREFIX_DATA
) != 0)
11764 all_prefixes
[last_data_prefix
] = 0;
11767 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11768 if (all_prefixes
[i
])
11771 name
= prefix_name (all_prefixes
[i
], sizeflag
);
11774 prefix_length
+= strlen (name
) + 1;
11775 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
11778 /* Check maximum code length. */
11779 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
11781 (*info
->fprintf_func
) (info
->stream
, "(bad)");
11782 return MAX_CODE_LENGTH
;
11785 obufp
= mnemonicendp
;
11786 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
11789 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
11791 /* The enter and bound instructions are printed with operands in the same
11792 order as the intel book; everything else is printed in reverse order. */
11793 if (intel_syntax
|| two_source_ops
)
11797 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11798 op_txt
[i
] = op_out
[i
];
11800 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
11802 op_ad
= op_index
[i
];
11803 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
11804 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
11805 riprel
= op_riprel
[i
];
11806 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
11807 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
11812 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11813 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
11817 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11821 (*info
->fprintf_func
) (info
->stream
, ",");
11822 if (op_index
[i
] != -1 && !op_riprel
[i
])
11823 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
11825 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
11829 for (i
= 0; i
< MAX_OPERANDS
; i
++)
11830 if (op_index
[i
] != -1 && op_riprel
[i
])
11832 (*info
->fprintf_func
) (info
->stream
, " # ");
11833 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
11834 + op_address
[op_index
[i
]]), info
);
11837 return codep
- priv
.the_buffer
;
11840 static const char *float_mem
[] = {
11915 static const unsigned char float_mem_mode
[] = {
11990 #define ST { OP_ST, 0 }
11991 #define STi { OP_STi, 0 }
11993 #define FGRPd9_2 NULL, { { NULL, 0 } }
11994 #define FGRPd9_4 NULL, { { NULL, 1 } }
11995 #define FGRPd9_5 NULL, { { NULL, 2 } }
11996 #define FGRPd9_6 NULL, { { NULL, 3 } }
11997 #define FGRPd9_7 NULL, { { NULL, 4 } }
11998 #define FGRPda_5 NULL, { { NULL, 5 } }
11999 #define FGRPdb_4 NULL, { { NULL, 6 } }
12000 #define FGRPde_3 NULL, { { NULL, 7 } }
12001 #define FGRPdf_4 NULL, { { NULL, 8 } }
12003 static const struct dis386 float_reg
[][8] = {
12006 { "fadd", { ST
, STi
} },
12007 { "fmul", { ST
, STi
} },
12008 { "fcom", { STi
} },
12009 { "fcomp", { STi
} },
12010 { "fsub", { ST
, STi
} },
12011 { "fsubr", { ST
, STi
} },
12012 { "fdiv", { ST
, STi
} },
12013 { "fdivr", { ST
, STi
} },
12017 { "fld", { STi
} },
12018 { "fxch", { STi
} },
12028 { "fcmovb", { ST
, STi
} },
12029 { "fcmove", { ST
, STi
} },
12030 { "fcmovbe",{ ST
, STi
} },
12031 { "fcmovu", { ST
, STi
} },
12039 { "fcmovnb",{ ST
, STi
} },
12040 { "fcmovne",{ ST
, STi
} },
12041 { "fcmovnbe",{ ST
, STi
} },
12042 { "fcmovnu",{ ST
, STi
} },
12044 { "fucomi", { ST
, STi
} },
12045 { "fcomi", { ST
, STi
} },
12050 { "fadd", { STi
, ST
} },
12051 { "fmul", { STi
, ST
} },
12054 { "fsub!M", { STi
, ST
} },
12055 { "fsubM", { STi
, ST
} },
12056 { "fdiv!M", { STi
, ST
} },
12057 { "fdivM", { STi
, ST
} },
12061 { "ffree", { STi
} },
12063 { "fst", { STi
} },
12064 { "fstp", { STi
} },
12065 { "fucom", { STi
} },
12066 { "fucomp", { STi
} },
12072 { "faddp", { STi
, ST
} },
12073 { "fmulp", { STi
, ST
} },
12076 { "fsub!Mp", { STi
, ST
} },
12077 { "fsubMp", { STi
, ST
} },
12078 { "fdiv!Mp", { STi
, ST
} },
12079 { "fdivMp", { STi
, ST
} },
12083 { "ffreep", { STi
} },
12088 { "fucomip", { ST
, STi
} },
12089 { "fcomip", { ST
, STi
} },
12094 static char *fgrps
[][8] = {
12097 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12102 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
12107 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
12112 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
12117 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
12122 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12127 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
12128 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
12133 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12138 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12143 swap_operand (void)
12145 mnemonicendp
[0] = '.';
12146 mnemonicendp
[1] = 's';
12151 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
12152 int sizeflag ATTRIBUTE_UNUSED
)
12154 /* Skip mod/rm byte. */
12160 dofloat (int sizeflag
)
12162 const struct dis386
*dp
;
12163 unsigned char floatop
;
12165 floatop
= codep
[-1];
12167 if (modrm
.mod
!= 3)
12169 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
12171 putop (float_mem
[fp_indx
], sizeflag
);
12174 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
12177 /* Skip mod/rm byte. */
12181 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
12182 if (dp
->name
== NULL
)
12184 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
12186 /* Instruction fnstsw is only one with strange arg. */
12187 if (floatop
== 0xdf && codep
[-1] == 0xe0)
12188 strcpy (op_out
[0], names16
[0]);
12192 putop (dp
->name
, sizeflag
);
12197 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
12202 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
12207 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12209 oappend ("%st" + intel_syntax
);
12213 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12215 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
12216 oappend (scratchbuf
+ intel_syntax
);
12219 /* Capital letters in template are macros. */
12221 putop (const char *in_template
, int sizeflag
)
12226 unsigned int l
= 0, len
= 1;
12229 #define SAVE_LAST(c) \
12230 if (l < len && l < sizeof (last)) \
12235 for (p
= in_template
; *p
; p
++)
12252 while (*++p
!= '|')
12253 if (*p
== '}' || *p
== '\0')
12256 /* Fall through. */
12261 while (*++p
!= '}')
12272 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12276 if (l
== 0 && len
== 1)
12281 if (sizeflag
& SUFFIX_ALWAYS
)
12294 if (address_mode
== mode_64bit
12295 && !(prefixes
& PREFIX_ADDR
))
12306 if (intel_syntax
&& !alt
)
12308 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
12310 if (sizeflag
& DFLAG
)
12311 *obufp
++ = intel_syntax
? 'd' : 'l';
12313 *obufp
++ = intel_syntax
? 'w' : 's';
12314 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12318 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12321 if (modrm
.mod
== 3)
12327 if (sizeflag
& DFLAG
)
12328 *obufp
++ = intel_syntax
? 'd' : 'l';
12331 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12337 case 'E': /* For jcxz/jecxz */
12338 if (address_mode
== mode_64bit
)
12340 if (sizeflag
& AFLAG
)
12346 if (sizeflag
& AFLAG
)
12348 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12353 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
12355 if (sizeflag
& AFLAG
)
12356 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
12358 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
12359 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12363 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
12365 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12369 if (!(rex
& REX_W
))
12370 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12375 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
12376 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
12378 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
12381 if (prefixes
& PREFIX_DS
)
12402 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
12407 /* Fall through. */
12410 if (l
!= 0 || len
!= 1)
12418 if (sizeflag
& SUFFIX_ALWAYS
)
12422 if (intel_mnemonic
!= cond
)
12426 if ((prefixes
& PREFIX_FWAIT
) == 0)
12429 used_prefixes
|= PREFIX_FWAIT
;
12435 else if (intel_syntax
&& (sizeflag
& DFLAG
))
12439 if (!(rex
& REX_W
))
12440 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12444 && address_mode
== mode_64bit
12445 && (sizeflag
& DFLAG
))
12450 /* Fall through. */
12454 if ((rex
& REX_W
) == 0
12455 && (prefixes
& PREFIX_DATA
))
12457 if ((sizeflag
& DFLAG
) == 0)
12459 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12463 if ((prefixes
& PREFIX_DATA
)
12465 || (sizeflag
& SUFFIX_ALWAYS
))
12472 if (sizeflag
& DFLAG
)
12476 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12483 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12485 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12489 /* Fall through. */
12492 if (l
== 0 && len
== 1)
12495 if (intel_syntax
&& !alt
)
12498 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12504 if (sizeflag
& DFLAG
)
12505 *obufp
++ = intel_syntax
? 'd' : 'l';
12508 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12514 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
12520 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12535 else if (sizeflag
& DFLAG
)
12544 if (intel_syntax
&& !p
[1]
12545 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
12547 if (!(rex
& REX_W
))
12548 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12551 if (l
== 0 && len
== 1)
12555 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12557 if (sizeflag
& SUFFIX_ALWAYS
)
12579 /* Fall through. */
12582 if (l
== 0 && len
== 1)
12587 if (sizeflag
& SUFFIX_ALWAYS
)
12593 if (sizeflag
& DFLAG
)
12597 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12611 if (address_mode
== mode_64bit
12612 && !(prefixes
& PREFIX_ADDR
))
12623 if (l
!= 0 || len
!= 1)
12628 if (need_vex
&& vex
.prefix
)
12630 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
12637 if (prefixes
& PREFIX_DATA
)
12641 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12645 if (l
== 0 && len
== 1)
12647 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12658 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12666 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12668 switch (vex
.length
)
12682 if (l
== 0 && len
== 1)
12684 /* operand size flag for cwtl, cbtw */
12693 else if (sizeflag
& DFLAG
)
12697 if (!(rex
& REX_W
))
12698 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12702 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12709 *obufp
++ = vex
.w
? 'd': 's';
12716 mnemonicendp
= obufp
;
12721 oappend (const char *s
)
12723 obufp
= stpcpy (obufp
, s
);
12729 if (prefixes
& PREFIX_CS
)
12731 used_prefixes
|= PREFIX_CS
;
12732 oappend ("%cs:" + intel_syntax
);
12734 if (prefixes
& PREFIX_DS
)
12736 used_prefixes
|= PREFIX_DS
;
12737 oappend ("%ds:" + intel_syntax
);
12739 if (prefixes
& PREFIX_SS
)
12741 used_prefixes
|= PREFIX_SS
;
12742 oappend ("%ss:" + intel_syntax
);
12744 if (prefixes
& PREFIX_ES
)
12746 used_prefixes
|= PREFIX_ES
;
12747 oappend ("%es:" + intel_syntax
);
12749 if (prefixes
& PREFIX_FS
)
12751 used_prefixes
|= PREFIX_FS
;
12752 oappend ("%fs:" + intel_syntax
);
12754 if (prefixes
& PREFIX_GS
)
12756 used_prefixes
|= PREFIX_GS
;
12757 oappend ("%gs:" + intel_syntax
);
12762 OP_indirE (int bytemode
, int sizeflag
)
12766 OP_E (bytemode
, sizeflag
);
12770 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
12772 if (address_mode
== mode_64bit
)
12780 sprintf_vma (tmp
, disp
);
12781 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
12782 strcpy (buf
+ 2, tmp
+ i
);
12786 bfd_signed_vma v
= disp
;
12793 /* Check for possible overflow on 0x8000000000000000. */
12796 strcpy (buf
, "9223372036854775808");
12810 tmp
[28 - i
] = (v
% 10) + '0';
12814 strcpy (buf
, tmp
+ 29 - i
);
12820 sprintf (buf
, "0x%x", (unsigned int) disp
);
12822 sprintf (buf
, "%d", (int) disp
);
12826 /* Put DISP in BUF as signed hex number. */
12829 print_displacement (char *buf
, bfd_vma disp
)
12831 bfd_signed_vma val
= disp
;
12840 /* Check for possible overflow. */
12843 switch (address_mode
)
12846 strcpy (buf
+ j
, "0x8000000000000000");
12849 strcpy (buf
+ j
, "0x80000000");
12852 strcpy (buf
+ j
, "0x8000");
12862 sprintf_vma (tmp
, (bfd_vma
) val
);
12863 for (i
= 0; tmp
[i
] == '0'; i
++)
12865 if (tmp
[i
] == '\0')
12867 strcpy (buf
+ j
, tmp
+ i
);
12871 intel_operand_size (int bytemode
, int sizeflag
)
12878 oappend ("BYTE PTR ");
12882 oappend ("WORD PTR ");
12885 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12887 oappend ("QWORD PTR ");
12896 oappend ("QWORD PTR ");
12899 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
12900 oappend ("DWORD PTR ");
12902 oappend ("WORD PTR ");
12903 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12907 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12909 oappend ("WORD PTR ");
12910 if (!(rex
& REX_W
))
12911 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12914 if (sizeflag
& DFLAG
)
12915 oappend ("QWORD PTR ");
12917 oappend ("DWORD PTR ");
12918 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12921 case d_scalar_mode
:
12922 case d_scalar_swap_mode
:
12925 oappend ("DWORD PTR ");
12928 case q_scalar_mode
:
12929 case q_scalar_swap_mode
:
12931 oappend ("QWORD PTR ");
12934 if (address_mode
== mode_64bit
)
12935 oappend ("QWORD PTR ");
12937 oappend ("DWORD PTR ");
12940 if (sizeflag
& DFLAG
)
12941 oappend ("FWORD PTR ");
12943 oappend ("DWORD PTR ");
12944 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12947 oappend ("TBYTE PTR ");
12953 switch (vex
.length
)
12956 oappend ("XMMWORD PTR ");
12959 oappend ("YMMWORD PTR ");
12966 oappend ("XMMWORD PTR ");
12969 oappend ("XMMWORD PTR ");
12975 switch (vex
.length
)
12978 oappend ("QWORD PTR ");
12981 oappend ("XMMWORD PTR ");
12991 switch (vex
.length
)
12994 oappend ("QWORD PTR ");
12997 oappend ("YMMWORD PTR ");
13004 oappend ("OWORD PTR ");
13006 case vex_w_dq_mode
:
13007 case vex_scalar_w_dq_mode
:
13012 oappend ("QWORD PTR ");
13014 oappend ("DWORD PTR ");
13022 OP_E_register (int bytemode
, int sizeflag
)
13024 int reg
= modrm
.rm
;
13025 const char **names
;
13031 if ((sizeflag
& SUFFIX_ALWAYS
)
13032 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
13055 names
= address_mode
== mode_64bit
? names64
: names32
;
13058 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13076 if ((sizeflag
& DFLAG
)
13077 || (bytemode
!= v_mode
13078 && bytemode
!= v_swap_mode
))
13082 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13088 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13091 oappend (names
[reg
]);
13095 OP_E_memory (int bytemode
, int sizeflag
)
13098 int add
= (rex
& REX_B
) ? 8 : 0;
13103 intel_operand_size (bytemode
, sizeflag
);
13106 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13108 /* 32/64 bit address mode */
13126 vindex
= sib
.index
;
13132 haveindex
= vindex
!= 4;
13135 rbase
= base
+ add
;
13143 if (address_mode
== mode_64bit
&& !havesib
)
13149 FETCH_DATA (the_info
, codep
+ 1);
13151 if ((disp
& 0x80) != 0)
13159 /* In 32bit mode, we need index register to tell [offset] from
13160 [eiz*1 + offset]. */
13161 needindex
= (havesib
13164 && address_mode
== mode_32bit
);
13165 havedisp
= (havebase
13167 || (havesib
&& (haveindex
|| scale
!= 0)));
13170 if (modrm
.mod
!= 0 || base
== 5)
13172 if (havedisp
|| riprel
)
13173 print_displacement (scratchbuf
, disp
);
13175 print_operand_value (scratchbuf
, 1, disp
);
13176 oappend (scratchbuf
);
13180 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
13184 if (havebase
|| haveindex
|| riprel
)
13185 used_prefixes
|= PREFIX_ADDR
;
13187 if (havedisp
|| (intel_syntax
&& riprel
))
13189 *obufp
++ = open_char
;
13190 if (intel_syntax
&& riprel
)
13193 oappend (sizeflag
& AFLAG
? "rip" : "eip");
13197 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
13198 ? names64
[rbase
] : names32
[rbase
]);
13201 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13202 print index to tell base + index from base. */
13206 || (havebase
&& base
!= ESP_REG_NUM
))
13208 if (!intel_syntax
|| havebase
)
13210 *obufp
++ = separator_char
;
13214 oappend (address_mode
== mode_64bit
13215 && (sizeflag
& AFLAG
)
13216 ? names64
[vindex
] : names32
[vindex
]);
13218 oappend (address_mode
== mode_64bit
13219 && (sizeflag
& AFLAG
)
13220 ? index64
: index32
);
13222 *obufp
++ = scale_char
;
13224 sprintf (scratchbuf
, "%d", 1 << scale
);
13225 oappend (scratchbuf
);
13229 && (disp
|| modrm
.mod
!= 0 || base
== 5))
13231 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
13236 else if (modrm
.mod
!= 1 && disp
!= -disp
)
13240 disp
= - (bfd_signed_vma
) disp
;
13244 print_displacement (scratchbuf
, disp
);
13246 print_operand_value (scratchbuf
, 1, disp
);
13247 oappend (scratchbuf
);
13250 *obufp
++ = close_char
;
13253 else if (intel_syntax
)
13255 if (modrm
.mod
!= 0 || base
== 5)
13257 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13258 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13262 oappend (names_seg
[ds_reg
- es_reg
]);
13265 print_operand_value (scratchbuf
, 1, disp
);
13266 oappend (scratchbuf
);
13272 /* 16 bit address mode */
13273 used_prefixes
|= prefixes
& PREFIX_ADDR
;
13280 if ((disp
& 0x8000) != 0)
13285 FETCH_DATA (the_info
, codep
+ 1);
13287 if ((disp
& 0x80) != 0)
13292 if ((disp
& 0x8000) != 0)
13298 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
13300 print_displacement (scratchbuf
, disp
);
13301 oappend (scratchbuf
);
13304 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
13306 *obufp
++ = open_char
;
13308 oappend (index16
[modrm
.rm
]);
13310 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
13312 if ((bfd_signed_vma
) disp
>= 0)
13317 else if (modrm
.mod
!= 1)
13321 disp
= - (bfd_signed_vma
) disp
;
13324 print_displacement (scratchbuf
, disp
);
13325 oappend (scratchbuf
);
13328 *obufp
++ = close_char
;
13331 else if (intel_syntax
)
13333 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13334 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13338 oappend (names_seg
[ds_reg
- es_reg
]);
13341 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
13342 oappend (scratchbuf
);
13348 OP_E (int bytemode
, int sizeflag
)
13350 /* Skip mod/rm byte. */
13354 if (modrm
.mod
== 3)
13355 OP_E_register (bytemode
, sizeflag
);
13357 OP_E_memory (bytemode
, sizeflag
);
13361 OP_G (int bytemode
, int sizeflag
)
13372 oappend (names8rex
[modrm
.reg
+ add
]);
13374 oappend (names8
[modrm
.reg
+ add
]);
13377 oappend (names16
[modrm
.reg
+ add
]);
13380 oappend (names32
[modrm
.reg
+ add
]);
13383 oappend (names64
[modrm
.reg
+ add
]);
13392 oappend (names64
[modrm
.reg
+ add
]);
13395 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
13396 oappend (names32
[modrm
.reg
+ add
]);
13398 oappend (names16
[modrm
.reg
+ add
]);
13399 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13403 if (address_mode
== mode_64bit
)
13404 oappend (names64
[modrm
.reg
+ add
]);
13406 oappend (names32
[modrm
.reg
+ add
]);
13409 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13422 FETCH_DATA (the_info
, codep
+ 8);
13423 a
= *codep
++ & 0xff;
13424 a
|= (*codep
++ & 0xff) << 8;
13425 a
|= (*codep
++ & 0xff) << 16;
13426 a
|= (*codep
++ & 0xff) << 24;
13427 b
= *codep
++ & 0xff;
13428 b
|= (*codep
++ & 0xff) << 8;
13429 b
|= (*codep
++ & 0xff) << 16;
13430 b
|= (*codep
++ & 0xff) << 24;
13431 x
= a
+ ((bfd_vma
) b
<< 32);
13439 static bfd_signed_vma
13442 bfd_signed_vma x
= 0;
13444 FETCH_DATA (the_info
, codep
+ 4);
13445 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13446 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13447 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13448 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13452 static bfd_signed_vma
13455 bfd_signed_vma x
= 0;
13457 FETCH_DATA (the_info
, codep
+ 4);
13458 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13459 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13460 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13461 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13463 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
13473 FETCH_DATA (the_info
, codep
+ 2);
13474 x
= *codep
++ & 0xff;
13475 x
|= (*codep
++ & 0xff) << 8;
13480 set_op (bfd_vma op
, int riprel
)
13482 op_index
[op_ad
] = op_ad
;
13483 if (address_mode
== mode_64bit
)
13485 op_address
[op_ad
] = op
;
13486 op_riprel
[op_ad
] = riprel
;
13490 /* Mask to get a 32-bit address. */
13491 op_address
[op_ad
] = op
& 0xffffffff;
13492 op_riprel
[op_ad
] = riprel
& 0xffffffff;
13497 OP_REG (int code
, int sizeflag
)
13509 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13510 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13511 s
= names16
[code
- ax_reg
+ add
];
13513 case es_reg
: case ss_reg
: case cs_reg
:
13514 case ds_reg
: case fs_reg
: case gs_reg
:
13515 s
= names_seg
[code
- es_reg
+ add
];
13517 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13518 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13521 s
= names8rex
[code
- al_reg
+ add
];
13523 s
= names8
[code
- al_reg
];
13525 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
13526 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
13527 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13529 s
= names64
[code
- rAX_reg
+ add
];
13532 code
+= eAX_reg
- rAX_reg
;
13533 /* Fall through. */
13534 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13535 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13538 s
= names64
[code
- eAX_reg
+ add
];
13541 if (sizeflag
& DFLAG
)
13542 s
= names32
[code
- eAX_reg
+ add
];
13544 s
= names16
[code
- eAX_reg
+ add
];
13545 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13549 s
= INTERNAL_DISASSEMBLER_ERROR
;
13556 OP_IMREG (int code
, int sizeflag
)
13568 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13569 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13570 s
= names16
[code
- ax_reg
];
13572 case es_reg
: case ss_reg
: case cs_reg
:
13573 case ds_reg
: case fs_reg
: case gs_reg
:
13574 s
= names_seg
[code
- es_reg
];
13576 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13577 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13580 s
= names8rex
[code
- al_reg
];
13582 s
= names8
[code
- al_reg
];
13584 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13585 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13588 s
= names64
[code
- eAX_reg
];
13591 if (sizeflag
& DFLAG
)
13592 s
= names32
[code
- eAX_reg
];
13594 s
= names16
[code
- eAX_reg
];
13595 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13598 case z_mode_ax_reg
:
13599 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13603 if (!(rex
& REX_W
))
13604 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13607 s
= INTERNAL_DISASSEMBLER_ERROR
;
13614 OP_I (int bytemode
, int sizeflag
)
13617 bfd_signed_vma mask
= -1;
13622 FETCH_DATA (the_info
, codep
+ 1);
13627 if (address_mode
== mode_64bit
)
13632 /* Fall through. */
13639 if (sizeflag
& DFLAG
)
13649 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13661 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13666 scratchbuf
[0] = '$';
13667 print_operand_value (scratchbuf
+ 1, 1, op
);
13668 oappend (scratchbuf
+ intel_syntax
);
13669 scratchbuf
[0] = '\0';
13673 OP_I64 (int bytemode
, int sizeflag
)
13676 bfd_signed_vma mask
= -1;
13678 if (address_mode
!= mode_64bit
)
13680 OP_I (bytemode
, sizeflag
);
13687 FETCH_DATA (the_info
, codep
+ 1);
13697 if (sizeflag
& DFLAG
)
13707 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13715 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13720 scratchbuf
[0] = '$';
13721 print_operand_value (scratchbuf
+ 1, 1, op
);
13722 oappend (scratchbuf
+ intel_syntax
);
13723 scratchbuf
[0] = '\0';
13727 OP_sI (int bytemode
, int sizeflag
)
13734 FETCH_DATA (the_info
, codep
+ 1);
13736 if ((op
& 0x80) != 0)
13740 if (sizeflag
& DFLAG
)
13746 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13750 scratchbuf
[0] = '$';
13751 print_operand_value (scratchbuf
+ 1, 1, op
);
13752 oappend (scratchbuf
+ intel_syntax
);
13756 OP_J (int bytemode
, int sizeflag
)
13760 bfd_vma segment
= 0;
13765 FETCH_DATA (the_info
, codep
+ 1);
13767 if ((disp
& 0x80) != 0)
13772 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
13777 if ((disp
& 0x8000) != 0)
13779 /* In 16bit mode, address is wrapped around at 64k within
13780 the same segment. Otherwise, a data16 prefix on a jump
13781 instruction means that the pc is masked to 16 bits after
13782 the displacement is added! */
13784 if ((prefixes
& PREFIX_DATA
) == 0)
13785 segment
= ((start_pc
+ codep
- start_codep
)
13786 & ~((bfd_vma
) 0xffff));
13788 if (!(rex
& REX_W
))
13789 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13792 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13795 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
13797 print_operand_value (scratchbuf
, 1, disp
);
13798 oappend (scratchbuf
);
13802 OP_SEG (int bytemode
, int sizeflag
)
13804 if (bytemode
== w_mode
)
13805 oappend (names_seg
[modrm
.reg
]);
13807 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
13811 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
13815 if (sizeflag
& DFLAG
)
13825 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13827 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
13829 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
13830 oappend (scratchbuf
);
13834 OP_OFF (int bytemode
, int sizeflag
)
13838 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13839 intel_operand_size (bytemode
, sizeflag
);
13842 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13849 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13850 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13852 oappend (names_seg
[ds_reg
- es_reg
]);
13856 print_operand_value (scratchbuf
, 1, off
);
13857 oappend (scratchbuf
);
13861 OP_OFF64 (int bytemode
, int sizeflag
)
13865 if (address_mode
!= mode_64bit
13866 || (prefixes
& PREFIX_ADDR
))
13868 OP_OFF (bytemode
, sizeflag
);
13872 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13873 intel_operand_size (bytemode
, sizeflag
);
13880 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13881 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13883 oappend (names_seg
[ds_reg
- es_reg
]);
13887 print_operand_value (scratchbuf
, 1, off
);
13888 oappend (scratchbuf
);
13892 ptr_reg (int code
, int sizeflag
)
13896 *obufp
++ = open_char
;
13897 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13898 if (address_mode
== mode_64bit
)
13900 if (!(sizeflag
& AFLAG
))
13901 s
= names32
[code
- eAX_reg
];
13903 s
= names64
[code
- eAX_reg
];
13905 else if (sizeflag
& AFLAG
)
13906 s
= names32
[code
- eAX_reg
];
13908 s
= names16
[code
- eAX_reg
];
13910 *obufp
++ = close_char
;
13915 OP_ESreg (int code
, int sizeflag
)
13921 case 0x6d: /* insw/insl */
13922 intel_operand_size (z_mode
, sizeflag
);
13924 case 0xa5: /* movsw/movsl/movsq */
13925 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13926 case 0xab: /* stosw/stosl */
13927 case 0xaf: /* scasw/scasl */
13928 intel_operand_size (v_mode
, sizeflag
);
13931 intel_operand_size (b_mode
, sizeflag
);
13934 oappend ("%es:" + intel_syntax
);
13935 ptr_reg (code
, sizeflag
);
13939 OP_DSreg (int code
, int sizeflag
)
13945 case 0x6f: /* outsw/outsl */
13946 intel_operand_size (z_mode
, sizeflag
);
13948 case 0xa5: /* movsw/movsl/movsq */
13949 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13950 case 0xad: /* lodsw/lodsl/lodsq */
13951 intel_operand_size (v_mode
, sizeflag
);
13954 intel_operand_size (b_mode
, sizeflag
);
13963 | PREFIX_GS
)) == 0)
13964 prefixes
|= PREFIX_DS
;
13966 ptr_reg (code
, sizeflag
);
13970 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13978 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13980 all_prefixes
[last_lock_prefix
] = 0;
13981 used_prefixes
|= PREFIX_LOCK
;
13986 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13987 oappend (scratchbuf
+ intel_syntax
);
13991 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14000 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
14002 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
14003 oappend (scratchbuf
);
14007 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14009 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
14010 oappend (scratchbuf
+ intel_syntax
);
14014 OP_R (int bytemode
, int sizeflag
)
14016 if (modrm
.mod
== 3)
14017 OP_E (bytemode
, sizeflag
);
14023 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14025 int reg
= modrm
.reg
;
14026 const char **names
;
14028 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14029 if (prefixes
& PREFIX_DATA
)
14038 oappend (names
[reg
]);
14042 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14044 int reg
= modrm
.reg
;
14045 const char **names
;
14051 && bytemode
!= xmm_mode
14052 && bytemode
!= scalar_mode
)
14054 switch (vex
.length
)
14068 oappend (names
[reg
]);
14072 OP_EM (int bytemode
, int sizeflag
)
14075 const char **names
;
14077 if (modrm
.mod
!= 3)
14080 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14082 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14083 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14085 OP_E (bytemode
, sizeflag
);
14089 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
14092 /* Skip mod/rm byte. */
14095 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14097 if (prefixes
& PREFIX_DATA
)
14106 oappend (names
[reg
]);
14109 /* cvt* are the only instructions in sse2 which have
14110 both SSE and MMX operands and also have 0x66 prefix
14111 in their opcode. 0x66 was originally used to differentiate
14112 between SSE and MMX instruction(operands). So we have to handle the
14113 cvt* separately using OP_EMC and OP_MXC */
14115 OP_EMC (int bytemode
, int sizeflag
)
14117 if (modrm
.mod
!= 3)
14119 if (intel_syntax
&& bytemode
== v_mode
)
14121 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14122 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14124 OP_E (bytemode
, sizeflag
);
14128 /* Skip mod/rm byte. */
14131 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14132 oappend (names_mm
[modrm
.rm
]);
14136 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14138 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14139 oappend (names_mm
[modrm
.reg
]);
14143 OP_EX (int bytemode
, int sizeflag
)
14146 const char **names
;
14148 /* Skip mod/rm byte. */
14152 if (modrm
.mod
!= 3)
14154 OP_E_memory (bytemode
, sizeflag
);
14163 if ((sizeflag
& SUFFIX_ALWAYS
)
14164 && (bytemode
== x_swap_mode
14165 || bytemode
== d_swap_mode
14166 || bytemode
== d_scalar_swap_mode
14167 || bytemode
== q_swap_mode
14168 || bytemode
== q_scalar_swap_mode
))
14172 && bytemode
!= xmm_mode
14173 && bytemode
!= xmmq_mode
14174 && bytemode
!= d_scalar_mode
14175 && bytemode
!= d_scalar_swap_mode
14176 && bytemode
!= q_scalar_mode
14177 && bytemode
!= q_scalar_swap_mode
14178 && bytemode
!= vex_scalar_w_dq_mode
)
14180 switch (vex
.length
)
14194 oappend (names
[reg
]);
14198 OP_MS (int bytemode
, int sizeflag
)
14200 if (modrm
.mod
== 3)
14201 OP_EM (bytemode
, sizeflag
);
14207 OP_XS (int bytemode
, int sizeflag
)
14209 if (modrm
.mod
== 3)
14210 OP_EX (bytemode
, sizeflag
);
14216 OP_M (int bytemode
, int sizeflag
)
14218 if (modrm
.mod
== 3)
14219 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14222 OP_E (bytemode
, sizeflag
);
14226 OP_0f07 (int bytemode
, int sizeflag
)
14228 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
14231 OP_E (bytemode
, sizeflag
);
14234 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14235 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14238 NOP_Fixup1 (int bytemode
, int sizeflag
)
14240 if ((prefixes
& PREFIX_DATA
) != 0
14243 && address_mode
== mode_64bit
))
14244 OP_REG (bytemode
, sizeflag
);
14246 strcpy (obuf
, "nop");
14250 NOP_Fixup2 (int bytemode
, int sizeflag
)
14252 if ((prefixes
& PREFIX_DATA
) != 0
14255 && address_mode
== mode_64bit
))
14256 OP_IMREG (bytemode
, sizeflag
);
14259 static const char *const Suffix3DNow
[] = {
14260 /* 00 */ NULL
, NULL
, NULL
, NULL
,
14261 /* 04 */ NULL
, NULL
, NULL
, NULL
,
14262 /* 08 */ NULL
, NULL
, NULL
, NULL
,
14263 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
14264 /* 10 */ NULL
, NULL
, NULL
, NULL
,
14265 /* 14 */ NULL
, NULL
, NULL
, NULL
,
14266 /* 18 */ NULL
, NULL
, NULL
, NULL
,
14267 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
14268 /* 20 */ NULL
, NULL
, NULL
, NULL
,
14269 /* 24 */ NULL
, NULL
, NULL
, NULL
,
14270 /* 28 */ NULL
, NULL
, NULL
, NULL
,
14271 /* 2C */ NULL
, NULL
, NULL
, NULL
,
14272 /* 30 */ NULL
, NULL
, NULL
, NULL
,
14273 /* 34 */ NULL
, NULL
, NULL
, NULL
,
14274 /* 38 */ NULL
, NULL
, NULL
, NULL
,
14275 /* 3C */ NULL
, NULL
, NULL
, NULL
,
14276 /* 40 */ NULL
, NULL
, NULL
, NULL
,
14277 /* 44 */ NULL
, NULL
, NULL
, NULL
,
14278 /* 48 */ NULL
, NULL
, NULL
, NULL
,
14279 /* 4C */ NULL
, NULL
, NULL
, NULL
,
14280 /* 50 */ NULL
, NULL
, NULL
, NULL
,
14281 /* 54 */ NULL
, NULL
, NULL
, NULL
,
14282 /* 58 */ NULL
, NULL
, NULL
, NULL
,
14283 /* 5C */ NULL
, NULL
, NULL
, NULL
,
14284 /* 60 */ NULL
, NULL
, NULL
, NULL
,
14285 /* 64 */ NULL
, NULL
, NULL
, NULL
,
14286 /* 68 */ NULL
, NULL
, NULL
, NULL
,
14287 /* 6C */ NULL
, NULL
, NULL
, NULL
,
14288 /* 70 */ NULL
, NULL
, NULL
, NULL
,
14289 /* 74 */ NULL
, NULL
, NULL
, NULL
,
14290 /* 78 */ NULL
, NULL
, NULL
, NULL
,
14291 /* 7C */ NULL
, NULL
, NULL
, NULL
,
14292 /* 80 */ NULL
, NULL
, NULL
, NULL
,
14293 /* 84 */ NULL
, NULL
, NULL
, NULL
,
14294 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
14295 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
14296 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
14297 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
14298 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
14299 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
14300 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
14301 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
14302 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
14303 /* AC */ NULL
, NULL
, "pfacc", NULL
,
14304 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
14305 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
14306 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
14307 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
14308 /* C0 */ NULL
, NULL
, NULL
, NULL
,
14309 /* C4 */ NULL
, NULL
, NULL
, NULL
,
14310 /* C8 */ NULL
, NULL
, NULL
, NULL
,
14311 /* CC */ NULL
, NULL
, NULL
, NULL
,
14312 /* D0 */ NULL
, NULL
, NULL
, NULL
,
14313 /* D4 */ NULL
, NULL
, NULL
, NULL
,
14314 /* D8 */ NULL
, NULL
, NULL
, NULL
,
14315 /* DC */ NULL
, NULL
, NULL
, NULL
,
14316 /* E0 */ NULL
, NULL
, NULL
, NULL
,
14317 /* E4 */ NULL
, NULL
, NULL
, NULL
,
14318 /* E8 */ NULL
, NULL
, NULL
, NULL
,
14319 /* EC */ NULL
, NULL
, NULL
, NULL
,
14320 /* F0 */ NULL
, NULL
, NULL
, NULL
,
14321 /* F4 */ NULL
, NULL
, NULL
, NULL
,
14322 /* F8 */ NULL
, NULL
, NULL
, NULL
,
14323 /* FC */ NULL
, NULL
, NULL
, NULL
,
14327 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14329 const char *mnemonic
;
14331 FETCH_DATA (the_info
, codep
+ 1);
14332 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14333 place where an 8-bit immediate would normally go. ie. the last
14334 byte of the instruction. */
14335 obufp
= mnemonicendp
;
14336 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
14338 oappend (mnemonic
);
14341 /* Since a variable sized modrm/sib chunk is between the start
14342 of the opcode (0x0f0f) and the opcode suffix, we need to do
14343 all the modrm processing first, and don't know until now that
14344 we have a bad opcode. This necessitates some cleaning up. */
14345 op_out
[0][0] = '\0';
14346 op_out
[1][0] = '\0';
14349 mnemonicendp
= obufp
;
14352 static struct op simd_cmp_op
[] =
14354 { STRING_COMMA_LEN ("eq") },
14355 { STRING_COMMA_LEN ("lt") },
14356 { STRING_COMMA_LEN ("le") },
14357 { STRING_COMMA_LEN ("unord") },
14358 { STRING_COMMA_LEN ("neq") },
14359 { STRING_COMMA_LEN ("nlt") },
14360 { STRING_COMMA_LEN ("nle") },
14361 { STRING_COMMA_LEN ("ord") }
14365 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14367 unsigned int cmp_type
;
14369 FETCH_DATA (the_info
, codep
+ 1);
14370 cmp_type
= *codep
++ & 0xff;
14371 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
14374 char *p
= mnemonicendp
- 2;
14378 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
14379 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
14383 /* We have a reserved extension byte. Output it directly. */
14384 scratchbuf
[0] = '$';
14385 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14386 oappend (scratchbuf
+ intel_syntax
);
14387 scratchbuf
[0] = '\0';
14392 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
14393 int sizeflag ATTRIBUTE_UNUSED
)
14395 /* mwait %eax,%ecx */
14398 const char **names
= (address_mode
== mode_64bit
14399 ? names64
: names32
);
14400 strcpy (op_out
[0], names
[0]);
14401 strcpy (op_out
[1], names
[1]);
14402 two_source_ops
= 1;
14404 /* Skip mod/rm byte. */
14410 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
14411 int sizeflag ATTRIBUTE_UNUSED
)
14413 /* monitor %eax,%ecx,%edx" */
14416 const char **op1_names
;
14417 const char **names
= (address_mode
== mode_64bit
14418 ? names64
: names32
);
14420 if (!(prefixes
& PREFIX_ADDR
))
14421 op1_names
= (address_mode
== mode_16bit
14422 ? names16
: names
);
14425 /* Remove "addr16/addr32". */
14426 all_prefixes
[last_addr_prefix
] = 0;
14427 op1_names
= (address_mode
!= mode_32bit
14428 ? names32
: names16
);
14429 used_prefixes
|= PREFIX_ADDR
;
14431 strcpy (op_out
[0], op1_names
[0]);
14432 strcpy (op_out
[1], names
[1]);
14433 strcpy (op_out
[2], names
[2]);
14434 two_source_ops
= 1;
14436 /* Skip mod/rm byte. */
14444 /* Throw away prefixes and 1st. opcode byte. */
14445 codep
= insn_codep
+ 1;
14450 REP_Fixup (int bytemode
, int sizeflag
)
14452 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
14454 if (prefixes
& PREFIX_REPZ
)
14455 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
14462 OP_IMREG (bytemode
, sizeflag
);
14465 OP_ESreg (bytemode
, sizeflag
);
14468 OP_DSreg (bytemode
, sizeflag
);
14477 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
14482 /* Change cmpxchg8b to cmpxchg16b. */
14483 char *p
= mnemonicendp
- 2;
14484 mnemonicendp
= stpcpy (p
, "16b");
14487 OP_M (bytemode
, sizeflag
);
14491 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
14493 const char **names
;
14497 switch (vex
.length
)
14511 oappend (names
[reg
]);
14515 CRC32_Fixup (int bytemode
, int sizeflag
)
14517 /* Add proper suffix to "crc32". */
14518 char *p
= mnemonicendp
;
14537 if (sizeflag
& DFLAG
)
14541 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14545 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14552 if (modrm
.mod
== 3)
14556 /* Skip mod/rm byte. */
14561 add
= (rex
& REX_B
) ? 8 : 0;
14562 if (bytemode
== b_mode
)
14566 oappend (names8rex
[modrm
.rm
+ add
]);
14568 oappend (names8
[modrm
.rm
+ add
]);
14574 oappend (names64
[modrm
.rm
+ add
]);
14575 else if ((prefixes
& PREFIX_DATA
))
14576 oappend (names16
[modrm
.rm
+ add
]);
14578 oappend (names32
[modrm
.rm
+ add
]);
14582 OP_E (bytemode
, sizeflag
);
14586 FXSAVE_Fixup (int bytemode
, int sizeflag
)
14588 /* Add proper suffix to "fxsave" and "fxrstor". */
14592 char *p
= mnemonicendp
;
14598 OP_M (bytemode
, sizeflag
);
14601 /* Display the destination register operand for instructions with
14605 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14608 const char **names
;
14616 reg
= vex
.register_specifier
;
14617 if (bytemode
== vex_scalar_mode
)
14619 oappend (names_xmm
[reg
]);
14623 switch (vex
.length
)
14660 oappend (names
[reg
]);
14663 /* Get the VEX immediate byte without moving codep. */
14665 static unsigned char
14666 get_vex_imm8 (int sizeflag
, int opnum
)
14668 int bytes_before_imm
= 0;
14670 if (modrm
.mod
!= 3)
14672 /* There are SIB/displacement bytes. */
14673 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14675 /* 32/64 bit address mode */
14676 int base
= modrm
.rm
;
14678 /* Check SIB byte. */
14681 FETCH_DATA (the_info
, codep
+ 1);
14683 /* When decoding the third source, don't increase
14684 bytes_before_imm as this has already been incremented
14685 by one in OP_E_memory while decoding the second
14688 bytes_before_imm
++;
14691 /* Don't increase bytes_before_imm when decoding the third source,
14692 it has already been incremented by OP_E_memory while decoding
14693 the second source operand. */
14699 /* When modrm.rm == 5 or modrm.rm == 4 and base in
14700 SIB == 5, there is a 4 byte displacement. */
14702 /* No displacement. */
14705 /* 4 byte displacement. */
14706 bytes_before_imm
+= 4;
14709 /* 1 byte displacement. */
14710 bytes_before_imm
++;
14717 /* 16 bit address mode */
14718 /* Don't increase bytes_before_imm when decoding the third source,
14719 it has already been incremented by OP_E_memory while decoding
14720 the second source operand. */
14726 /* When modrm.rm == 6, there is a 2 byte displacement. */
14728 /* No displacement. */
14731 /* 2 byte displacement. */
14732 bytes_before_imm
+= 2;
14735 /* 1 byte displacement: when decoding the third source,
14736 don't increase bytes_before_imm as this has already
14737 been incremented by one in OP_E_memory while decoding
14738 the second source operand. */
14740 bytes_before_imm
++;
14748 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
14749 return codep
[bytes_before_imm
];
14753 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
14755 const char **names
;
14757 if (reg
== -1 && modrm
.mod
!= 3)
14759 OP_E_memory (bytemode
, sizeflag
);
14771 else if (reg
> 7 && address_mode
!= mode_64bit
)
14775 switch (vex
.length
)
14786 oappend (names
[reg
]);
14790 OP_EX_VexImmW (int bytemode
, int sizeflag
)
14793 static unsigned char vex_imm8
;
14795 if (vex_w_done
== 0)
14799 /* Skip mod/rm byte. */
14803 vex_imm8
= get_vex_imm8 (sizeflag
, 0);
14806 reg
= vex_imm8
>> 4;
14808 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14810 else if (vex_w_done
== 1)
14815 reg
= vex_imm8
>> 4;
14817 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14821 /* Output the imm8 directly. */
14822 scratchbuf
[0] = '$';
14823 print_operand_value (scratchbuf
+ 1, 1, vex_imm8
& 0xf);
14824 oappend (scratchbuf
+ intel_syntax
);
14825 scratchbuf
[0] = '\0';
14831 OP_Vex_2src (int bytemode
, int sizeflag
)
14833 if (modrm
.mod
== 3)
14835 int reg
= modrm
.rm
;
14839 oappend (names_xmm
[reg
]);
14844 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14846 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14847 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14849 OP_E (bytemode
, sizeflag
);
14854 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
14856 if (modrm
.mod
== 3)
14858 /* Skip mod/rm byte. */
14864 oappend (names_xmm
[vex
.register_specifier
]);
14866 OP_Vex_2src (bytemode
, sizeflag
);
14870 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
14873 OP_Vex_2src (bytemode
, sizeflag
);
14875 oappend (names_xmm
[vex
.register_specifier
]);
14879 OP_EX_VexW (int bytemode
, int sizeflag
)
14887 /* Skip mod/rm byte. */
14892 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
14897 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
14900 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14904 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14905 int sizeflag ATTRIBUTE_UNUSED
)
14907 /* Skip the immediate byte and check for invalid bits. */
14908 FETCH_DATA (the_info
, codep
+ 1);
14909 if (*codep
++ & 0xf)
14914 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14917 const char **names
;
14919 FETCH_DATA (the_info
, codep
+ 1);
14922 if (bytemode
!= x_mode
)
14929 if (reg
> 7 && address_mode
!= mode_64bit
)
14932 switch (vex
.length
)
14943 oappend (names
[reg
]);
14947 OP_XMM_VexW (int bytemode
, int sizeflag
)
14949 /* Turn off the REX.W bit since it is used for swapping operands
14952 OP_XMM (bytemode
, sizeflag
);
14956 OP_EX_Vex (int bytemode
, int sizeflag
)
14958 if (modrm
.mod
!= 3)
14960 if (vex
.register_specifier
!= 0)
14964 OP_EX (bytemode
, sizeflag
);
14968 OP_XMM_Vex (int bytemode
, int sizeflag
)
14970 if (modrm
.mod
!= 3)
14972 if (vex
.register_specifier
!= 0)
14976 OP_XMM (bytemode
, sizeflag
);
14980 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14982 switch (vex
.length
)
14985 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
14988 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14995 static struct op vex_cmp_op
[] =
14997 { STRING_COMMA_LEN ("eq") },
14998 { STRING_COMMA_LEN ("lt") },
14999 { STRING_COMMA_LEN ("le") },
15000 { STRING_COMMA_LEN ("unord") },
15001 { STRING_COMMA_LEN ("neq") },
15002 { STRING_COMMA_LEN ("nlt") },
15003 { STRING_COMMA_LEN ("nle") },
15004 { STRING_COMMA_LEN ("ord") },
15005 { STRING_COMMA_LEN ("eq_uq") },
15006 { STRING_COMMA_LEN ("nge") },
15007 { STRING_COMMA_LEN ("ngt") },
15008 { STRING_COMMA_LEN ("false") },
15009 { STRING_COMMA_LEN ("neq_oq") },
15010 { STRING_COMMA_LEN ("ge") },
15011 { STRING_COMMA_LEN ("gt") },
15012 { STRING_COMMA_LEN ("true") },
15013 { STRING_COMMA_LEN ("eq_os") },
15014 { STRING_COMMA_LEN ("lt_oq") },
15015 { STRING_COMMA_LEN ("le_oq") },
15016 { STRING_COMMA_LEN ("unord_s") },
15017 { STRING_COMMA_LEN ("neq_us") },
15018 { STRING_COMMA_LEN ("nlt_uq") },
15019 { STRING_COMMA_LEN ("nle_uq") },
15020 { STRING_COMMA_LEN ("ord_s") },
15021 { STRING_COMMA_LEN ("eq_us") },
15022 { STRING_COMMA_LEN ("nge_uq") },
15023 { STRING_COMMA_LEN ("ngt_uq") },
15024 { STRING_COMMA_LEN ("false_os") },
15025 { STRING_COMMA_LEN ("neq_os") },
15026 { STRING_COMMA_LEN ("ge_oq") },
15027 { STRING_COMMA_LEN ("gt_oq") },
15028 { STRING_COMMA_LEN ("true_us") },
15032 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15034 unsigned int cmp_type
;
15036 FETCH_DATA (the_info
, codep
+ 1);
15037 cmp_type
= *codep
++ & 0xff;
15038 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
15041 char *p
= mnemonicendp
- 2;
15045 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
15046 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
15050 /* We have a reserved extension byte. Output it directly. */
15051 scratchbuf
[0] = '$';
15052 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
15053 oappend (scratchbuf
+ intel_syntax
);
15054 scratchbuf
[0] = '\0';
15058 static const struct op pclmul_op
[] =
15060 { STRING_COMMA_LEN ("lql") },
15061 { STRING_COMMA_LEN ("hql") },
15062 { STRING_COMMA_LEN ("lqh") },
15063 { STRING_COMMA_LEN ("hqh") }
15067 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
15068 int sizeflag ATTRIBUTE_UNUSED
)
15070 unsigned int pclmul_type
;
15072 FETCH_DATA (the_info
, codep
+ 1);
15073 pclmul_type
= *codep
++ & 0xff;
15074 switch (pclmul_type
)
15085 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
15088 char *p
= mnemonicendp
- 3;
15093 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
15094 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
15098 /* We have a reserved extension byte. Output it directly. */
15099 scratchbuf
[0] = '$';
15100 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
15101 oappend (scratchbuf
+ intel_syntax
);
15102 scratchbuf
[0] = '\0';
15107 MOVBE_Fixup (int bytemode
, int sizeflag
)
15109 /* Add proper suffix to "movbe". */
15110 char *p
= mnemonicendp
;
15119 if (sizeflag
& SUFFIX_ALWAYS
)
15125 if (sizeflag
& DFLAG
)
15129 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15134 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15141 OP_M (bytemode
, sizeflag
);
15145 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15148 const char **names
;
15150 /* Skip mod/rm byte. */
15164 oappend (names
[reg
]);
15168 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15170 const char **names
;
15177 oappend (names
[vex
.register_specifier
]);