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
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_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (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 Iq { OP_I, q_mode }
257 #define Iv64 { OP_I64, v_mode }
258 #define Iw { OP_I, w_mode }
259 #define I1 { OP_I, const_1_mode }
260 #define Jb { OP_J, b_mode }
261 #define Jv { OP_J, v_mode }
262 #define Cm { OP_C, m_mode }
263 #define Dm { OP_D, m_mode }
264 #define Td { OP_T, d_mode }
265 #define Skip_MODRM { OP_Skip_MODRM, 0 }
267 #define RMeAX { OP_REG, eAX_reg }
268 #define RMeBX { OP_REG, eBX_reg }
269 #define RMeCX { OP_REG, eCX_reg }
270 #define RMeDX { OP_REG, eDX_reg }
271 #define RMeSP { OP_REG, eSP_reg }
272 #define RMeBP { OP_REG, eBP_reg }
273 #define RMeSI { OP_REG, eSI_reg }
274 #define RMeDI { OP_REG, eDI_reg }
275 #define RMrAX { OP_REG, rAX_reg }
276 #define RMrBX { OP_REG, rBX_reg }
277 #define RMrCX { OP_REG, rCX_reg }
278 #define RMrDX { OP_REG, rDX_reg }
279 #define RMrSP { OP_REG, rSP_reg }
280 #define RMrBP { OP_REG, rBP_reg }
281 #define RMrSI { OP_REG, rSI_reg }
282 #define RMrDI { OP_REG, rDI_reg }
283 #define RMAL { OP_REG, al_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 MS { OP_MS, v_mode }
358 #define XS { OP_XS, v_mode }
359 #define EMCq { OP_EMC, q_mode }
360 #define MXC { OP_MXC, 0 }
361 #define OPSUF { OP_3DNowSuffix, 0 }
362 #define CMP { CMP_Fixup, 0 }
363 #define XMM0 { XMM_Fixup, 0 }
364 #define FXSAVE { FXSAVE_Fixup, 0 }
365 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
366 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
368 #define Vex { OP_VEX, vex_mode }
369 #define VexScalar { OP_VEX, vex_scalar_mode }
370 #define Vex128 { OP_VEX, vex128_mode }
371 #define Vex256 { OP_VEX, vex256_mode }
372 #define VexI4 { VEXI4_Fixup, 0}
373 #define EXdVex { OP_EX_Vex, d_mode }
374 #define EXdVexS { OP_EX_Vex, d_swap_mode }
375 #define EXdVexScalarS { OP_EX_Vex, d_scalar_swap_mode }
376 #define EXqVex { OP_EX_Vex, q_mode }
377 #define EXqVexS { OP_EX_Vex, q_swap_mode }
378 #define EXqVexScalarS { OP_EX_Vex, q_scalar_swap_mode }
379 #define EXVexW { OP_EX_VexW, x_mode }
380 #define EXdVexW { OP_EX_VexW, d_mode }
381 #define EXqVexW { OP_EX_VexW, q_mode }
382 #define XMVex { OP_XMM_Vex, 0 }
383 #define XMVexScalar { OP_XMM_Vex, scalar_mode }
384 #define XMVexW { OP_XMM_VexW, 0 }
385 #define XMVexI4 { OP_REG_VexI4, x_mode }
386 #define PCLMUL { PCLMUL_Fixup, 0 }
387 #define VZERO { VZERO_Fixup, 0 }
388 #define VCMP { VCMP_Fixup, 0 }
390 /* Used handle "rep" prefix for string instructions. */
391 #define Xbr { REP_Fixup, eSI_reg }
392 #define Xvr { REP_Fixup, eSI_reg }
393 #define Ybr { REP_Fixup, eDI_reg }
394 #define Yvr { REP_Fixup, eDI_reg }
395 #define Yzr { REP_Fixup, eDI_reg }
396 #define indirDXr { REP_Fixup, indir_dx_reg }
397 #define ALr { REP_Fixup, al_reg }
398 #define eAXr { REP_Fixup, eAX_reg }
400 #define cond_jump_flag { NULL, cond_jump_mode }
401 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
403 /* bits in sizeflag */
404 #define SUFFIX_ALWAYS 4
412 /* byte operand with operand swapped */
414 /* operand size depends on prefixes */
416 /* operand size depends on prefixes with operand swapped */
420 /* double word operand */
422 /* double word operand with operand swapped */
424 /* quad word operand */
426 /* quad word operand with operand swapped */
428 /* ten-byte operand */
430 /* 16-byte XMM or 32-byte YMM operand */
432 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
434 /* 16-byte XMM operand */
436 /* 16-byte XMM or quad word operand */
438 /* 32-byte YMM or quad word operand */
440 /* d_mode in 32bit, q_mode in 64bit mode. */
442 /* pair of v_mode operands */
446 /* operand size depends on REX prefixes. */
448 /* registers like dq_mode, memory like w_mode. */
450 /* 4- or 6-byte pointer operand */
453 /* v_mode for stack-related opcodes. */
455 /* non-quad operand size depends on prefixes */
457 /* 16-byte operand */
459 /* registers like dq_mode, memory like b_mode. */
461 /* registers like dq_mode, memory like d_mode. */
463 /* normal vex mode */
465 /* 128bit vex mode */
467 /* 256bit vex mode */
469 /* operand size depends on the VEX.W bit. */
472 /* scalar, ignore vector length. */
474 /* like d_mode, ignore vector length. */
476 /* like d_swap_mode, ignore vector length. */
478 /* like q_mode, ignore vector length. */
480 /* like q_swap_mode, ignore vector length. */
482 /* like vex_mode, ignore vector length. */
548 #define FLOAT NULL, { { NULL, FLOATCODE } }
550 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
551 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
552 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
553 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
554 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
555 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
556 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
557 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
558 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
559 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
560 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
561 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
679 MOD_VEX_3818_PREFIX_2
,
680 MOD_VEX_3819_PREFIX_2
,
681 MOD_VEX_381A_PREFIX_2
,
682 MOD_VEX_382A_PREFIX_2
,
683 MOD_VEX_382C_PREFIX_2
,
684 MOD_VEX_382D_PREFIX_2
,
685 MOD_VEX_382E_PREFIX_2
,
686 MOD_VEX_382F_PREFIX_2
1096 THREE_BYTE_0F38
= 0,
1251 VEX_LEN_3819_P_2_M_0
,
1252 VEX_LEN_381A_P_2_M_0
,
1264 VEX_LEN_382A_P_2_M_0
,
1580 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1591 /* Upper case letters in the instruction names here are macros.
1592 'A' => print 'b' if no register operands or suffix_always is true
1593 'B' => print 'b' if suffix_always is true
1594 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1596 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1597 suffix_always is true
1598 'E' => print 'e' if 32-bit form of jcxz
1599 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1600 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1601 'H' => print ",pt" or ",pn" branch hint
1602 'I' => honor following macro letter even in Intel mode (implemented only
1603 for some of the macro letters)
1605 'K' => print 'd' or 'q' if rex prefix is present.
1606 'L' => print 'l' if suffix_always is true
1607 'M' => print 'r' if intel_mnemonic is false.
1608 'N' => print 'n' if instruction has no wait "prefix"
1609 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1610 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1611 or suffix_always is true. print 'q' if rex prefix is present.
1612 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1614 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1615 'S' => print 'w', 'l' or 'q' if suffix_always is true
1616 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1617 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1618 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1619 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1620 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1621 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1622 suffix_always is true.
1623 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1624 '!' => change condition from true to false or from false to true.
1625 '%' => add 1 upper case letter to the macro.
1627 2 upper case letter macros:
1628 "XY" => print 'x' or 'y' if no register operands or suffix_always
1630 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1631 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1632 or suffix_always is true
1633 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1634 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1635 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1637 Many of the above letters print nothing in Intel mode. See "putop"
1640 Braces '{' and '}', and vertical bars '|', indicate alternative
1641 mnemonic strings for AT&T and Intel. */
1643 static const struct dis386 dis386
[] = {
1645 { "addB", { Eb
, Gb
} },
1646 { "addS", { Ev
, Gv
} },
1647 { "addB", { Gb
, EbS
} },
1648 { "addS", { Gv
, EvS
} },
1649 { "addB", { AL
, Ib
} },
1650 { "addS", { eAX
, Iv
} },
1651 { X86_64_TABLE (X86_64_06
) },
1652 { X86_64_TABLE (X86_64_07
) },
1654 { "orB", { Eb
, Gb
} },
1655 { "orS", { Ev
, Gv
} },
1656 { "orB", { Gb
, EbS
} },
1657 { "orS", { Gv
, EvS
} },
1658 { "orB", { AL
, Ib
} },
1659 { "orS", { eAX
, Iv
} },
1660 { X86_64_TABLE (X86_64_0D
) },
1661 { Bad_Opcode
}, /* 0x0f extended opcode escape */
1663 { "adcB", { Eb
, Gb
} },
1664 { "adcS", { Ev
, Gv
} },
1665 { "adcB", { Gb
, EbS
} },
1666 { "adcS", { Gv
, EvS
} },
1667 { "adcB", { AL
, Ib
} },
1668 { "adcS", { eAX
, Iv
} },
1669 { X86_64_TABLE (X86_64_16
) },
1670 { X86_64_TABLE (X86_64_17
) },
1672 { "sbbB", { Eb
, Gb
} },
1673 { "sbbS", { Ev
, Gv
} },
1674 { "sbbB", { Gb
, EbS
} },
1675 { "sbbS", { Gv
, EvS
} },
1676 { "sbbB", { AL
, Ib
} },
1677 { "sbbS", { eAX
, Iv
} },
1678 { X86_64_TABLE (X86_64_1E
) },
1679 { X86_64_TABLE (X86_64_1F
) },
1681 { "andB", { Eb
, Gb
} },
1682 { "andS", { Ev
, Gv
} },
1683 { "andB", { Gb
, EbS
} },
1684 { "andS", { Gv
, EvS
} },
1685 { "andB", { AL
, Ib
} },
1686 { "andS", { eAX
, Iv
} },
1687 { Bad_Opcode
}, /* SEG ES prefix */
1688 { X86_64_TABLE (X86_64_27
) },
1690 { "subB", { Eb
, Gb
} },
1691 { "subS", { Ev
, Gv
} },
1692 { "subB", { Gb
, EbS
} },
1693 { "subS", { Gv
, EvS
} },
1694 { "subB", { AL
, Ib
} },
1695 { "subS", { eAX
, Iv
} },
1696 { Bad_Opcode
}, /* SEG CS prefix */
1697 { X86_64_TABLE (X86_64_2F
) },
1699 { "xorB", { Eb
, Gb
} },
1700 { "xorS", { Ev
, Gv
} },
1701 { "xorB", { Gb
, EbS
} },
1702 { "xorS", { Gv
, EvS
} },
1703 { "xorB", { AL
, Ib
} },
1704 { "xorS", { eAX
, Iv
} },
1705 { Bad_Opcode
}, /* SEG SS prefix */
1706 { X86_64_TABLE (X86_64_37
) },
1708 { "cmpB", { Eb
, Gb
} },
1709 { "cmpS", { Ev
, Gv
} },
1710 { "cmpB", { Gb
, EbS
} },
1711 { "cmpS", { Gv
, EvS
} },
1712 { "cmpB", { AL
, Ib
} },
1713 { "cmpS", { eAX
, Iv
} },
1714 { Bad_Opcode
}, /* SEG DS prefix */
1715 { X86_64_TABLE (X86_64_3F
) },
1717 { "inc{S|}", { RMeAX
} },
1718 { "inc{S|}", { RMeCX
} },
1719 { "inc{S|}", { RMeDX
} },
1720 { "inc{S|}", { RMeBX
} },
1721 { "inc{S|}", { RMeSP
} },
1722 { "inc{S|}", { RMeBP
} },
1723 { "inc{S|}", { RMeSI
} },
1724 { "inc{S|}", { RMeDI
} },
1726 { "dec{S|}", { RMeAX
} },
1727 { "dec{S|}", { RMeCX
} },
1728 { "dec{S|}", { RMeDX
} },
1729 { "dec{S|}", { RMeBX
} },
1730 { "dec{S|}", { RMeSP
} },
1731 { "dec{S|}", { RMeBP
} },
1732 { "dec{S|}", { RMeSI
} },
1733 { "dec{S|}", { RMeDI
} },
1735 { "pushV", { RMrAX
} },
1736 { "pushV", { RMrCX
} },
1737 { "pushV", { RMrDX
} },
1738 { "pushV", { RMrBX
} },
1739 { "pushV", { RMrSP
} },
1740 { "pushV", { RMrBP
} },
1741 { "pushV", { RMrSI
} },
1742 { "pushV", { RMrDI
} },
1744 { "popV", { RMrAX
} },
1745 { "popV", { RMrCX
} },
1746 { "popV", { RMrDX
} },
1747 { "popV", { RMrBX
} },
1748 { "popV", { RMrSP
} },
1749 { "popV", { RMrBP
} },
1750 { "popV", { RMrSI
} },
1751 { "popV", { RMrDI
} },
1753 { X86_64_TABLE (X86_64_60
) },
1754 { X86_64_TABLE (X86_64_61
) },
1755 { X86_64_TABLE (X86_64_62
) },
1756 { X86_64_TABLE (X86_64_63
) },
1757 { Bad_Opcode
}, /* seg fs */
1758 { Bad_Opcode
}, /* seg gs */
1759 { Bad_Opcode
}, /* op size prefix */
1760 { Bad_Opcode
}, /* adr size prefix */
1762 { "pushT", { Iq
} },
1763 { "imulS", { Gv
, Ev
, Iv
} },
1764 { "pushT", { sIb
} },
1765 { "imulS", { Gv
, Ev
, sIb
} },
1766 { "ins{b|}", { Ybr
, indirDX
} },
1767 { X86_64_TABLE (X86_64_6D
) },
1768 { "outs{b|}", { indirDXr
, Xb
} },
1769 { X86_64_TABLE (X86_64_6F
) },
1771 { "joH", { Jb
, XX
, cond_jump_flag
} },
1772 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1773 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1774 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1775 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1776 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1777 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1778 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1780 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1781 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1782 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1783 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1784 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1785 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1786 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1787 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1789 { REG_TABLE (REG_80
) },
1790 { REG_TABLE (REG_81
) },
1792 { REG_TABLE (REG_82
) },
1793 { "testB", { Eb
, Gb
} },
1794 { "testS", { Ev
, Gv
} },
1795 { "xchgB", { Eb
, Gb
} },
1796 { "xchgS", { Ev
, Gv
} },
1798 { "movB", { Eb
, Gb
} },
1799 { "movS", { Ev
, Gv
} },
1800 { "movB", { Gb
, EbS
} },
1801 { "movS", { Gv
, EvS
} },
1802 { "movD", { Sv
, Sw
} },
1803 { MOD_TABLE (MOD_8D
) },
1804 { "movD", { Sw
, Sv
} },
1805 { REG_TABLE (REG_8F
) },
1807 { PREFIX_TABLE (PREFIX_90
) },
1808 { "xchgS", { RMeCX
, eAX
} },
1809 { "xchgS", { RMeDX
, eAX
} },
1810 { "xchgS", { RMeBX
, eAX
} },
1811 { "xchgS", { RMeSP
, eAX
} },
1812 { "xchgS", { RMeBP
, eAX
} },
1813 { "xchgS", { RMeSI
, eAX
} },
1814 { "xchgS", { RMeDI
, eAX
} },
1816 { "cW{t|}R", { XX
} },
1817 { "cR{t|}O", { XX
} },
1818 { X86_64_TABLE (X86_64_9A
) },
1819 { Bad_Opcode
}, /* fwait */
1820 { "pushfT", { XX
} },
1821 { "popfT", { XX
} },
1825 { "mov%LB", { AL
, Ob
} },
1826 { "mov%LS", { eAX
, Ov
} },
1827 { "mov%LB", { Ob
, AL
} },
1828 { "mov%LS", { Ov
, eAX
} },
1829 { "movs{b|}", { Ybr
, Xb
} },
1830 { "movs{R|}", { Yvr
, Xv
} },
1831 { "cmps{b|}", { Xb
, Yb
} },
1832 { "cmps{R|}", { Xv
, Yv
} },
1834 { "testB", { AL
, Ib
} },
1835 { "testS", { eAX
, Iv
} },
1836 { "stosB", { Ybr
, AL
} },
1837 { "stosS", { Yvr
, eAX
} },
1838 { "lodsB", { ALr
, Xb
} },
1839 { "lodsS", { eAXr
, Xv
} },
1840 { "scasB", { AL
, Yb
} },
1841 { "scasS", { eAX
, Yv
} },
1843 { "movB", { RMAL
, Ib
} },
1844 { "movB", { RMCL
, Ib
} },
1845 { "movB", { RMDL
, Ib
} },
1846 { "movB", { RMBL
, Ib
} },
1847 { "movB", { RMAH
, Ib
} },
1848 { "movB", { RMCH
, Ib
} },
1849 { "movB", { RMDH
, Ib
} },
1850 { "movB", { RMBH
, Ib
} },
1852 { "mov%LV", { RMeAX
, Iv64
} },
1853 { "mov%LV", { RMeCX
, Iv64
} },
1854 { "mov%LV", { RMeDX
, Iv64
} },
1855 { "mov%LV", { RMeBX
, Iv64
} },
1856 { "mov%LV", { RMeSP
, Iv64
} },
1857 { "mov%LV", { RMeBP
, Iv64
} },
1858 { "mov%LV", { RMeSI
, Iv64
} },
1859 { "mov%LV", { RMeDI
, Iv64
} },
1861 { REG_TABLE (REG_C0
) },
1862 { REG_TABLE (REG_C1
) },
1865 { X86_64_TABLE (X86_64_C4
) },
1866 { X86_64_TABLE (X86_64_C5
) },
1867 { REG_TABLE (REG_C6
) },
1868 { REG_TABLE (REG_C7
) },
1870 { "enterT", { Iw
, Ib
} },
1871 { "leaveT", { XX
} },
1872 { "Jret{|f}P", { Iw
} },
1873 { "Jret{|f}P", { XX
} },
1876 { X86_64_TABLE (X86_64_CE
) },
1877 { "iretP", { XX
} },
1879 { REG_TABLE (REG_D0
) },
1880 { REG_TABLE (REG_D1
) },
1881 { REG_TABLE (REG_D2
) },
1882 { REG_TABLE (REG_D3
) },
1883 { X86_64_TABLE (X86_64_D4
) },
1884 { X86_64_TABLE (X86_64_D5
) },
1886 { "xlat", { DSBX
} },
1897 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1898 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1899 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1900 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1901 { "inB", { AL
, Ib
} },
1902 { "inG", { zAX
, Ib
} },
1903 { "outB", { Ib
, AL
} },
1904 { "outG", { Ib
, zAX
} },
1906 { "callT", { Jv
} },
1908 { X86_64_TABLE (X86_64_EA
) },
1910 { "inB", { AL
, indirDX
} },
1911 { "inG", { zAX
, indirDX
} },
1912 { "outB", { indirDX
, AL
} },
1913 { "outG", { indirDX
, zAX
} },
1915 { Bad_Opcode
}, /* lock prefix */
1916 { "icebp", { XX
} },
1917 { Bad_Opcode
}, /* repne */
1918 { Bad_Opcode
}, /* repz */
1921 { REG_TABLE (REG_F6
) },
1922 { REG_TABLE (REG_F7
) },
1930 { REG_TABLE (REG_FE
) },
1931 { REG_TABLE (REG_FF
) },
1934 static const struct dis386 dis386_twobyte
[] = {
1936 { REG_TABLE (REG_0F00
) },
1937 { REG_TABLE (REG_0F01
) },
1938 { "larS", { Gv
, Ew
} },
1939 { "lslS", { Gv
, Ew
} },
1941 { "syscall", { XX
} },
1943 { "sysretP", { XX
} },
1946 { "wbinvd", { XX
} },
1950 { REG_TABLE (REG_0F0D
) },
1951 { "femms", { XX
} },
1952 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1954 { PREFIX_TABLE (PREFIX_0F10
) },
1955 { PREFIX_TABLE (PREFIX_0F11
) },
1956 { PREFIX_TABLE (PREFIX_0F12
) },
1957 { MOD_TABLE (MOD_0F13
) },
1958 { "unpcklpX", { XM
, EXx
} },
1959 { "unpckhpX", { XM
, EXx
} },
1960 { PREFIX_TABLE (PREFIX_0F16
) },
1961 { MOD_TABLE (MOD_0F17
) },
1963 { REG_TABLE (REG_0F18
) },
1972 { MOD_TABLE (MOD_0F20
) },
1973 { MOD_TABLE (MOD_0F21
) },
1974 { MOD_TABLE (MOD_0F22
) },
1975 { MOD_TABLE (MOD_0F23
) },
1976 { MOD_TABLE (MOD_0F24
) },
1978 { MOD_TABLE (MOD_0F26
) },
1981 { "movapX", { XM
, EXx
} },
1982 { "movapX", { EXxS
, XM
} },
1983 { PREFIX_TABLE (PREFIX_0F2A
) },
1984 { PREFIX_TABLE (PREFIX_0F2B
) },
1985 { PREFIX_TABLE (PREFIX_0F2C
) },
1986 { PREFIX_TABLE (PREFIX_0F2D
) },
1987 { PREFIX_TABLE (PREFIX_0F2E
) },
1988 { PREFIX_TABLE (PREFIX_0F2F
) },
1990 { "wrmsr", { XX
} },
1991 { "rdtsc", { XX
} },
1992 { "rdmsr", { XX
} },
1993 { "rdpmc", { XX
} },
1994 { "sysenter", { XX
} },
1995 { "sysexit", { XX
} },
1997 { "getsec", { XX
} },
1999 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
2001 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
2008 { "cmovoS", { Gv
, Ev
} },
2009 { "cmovnoS", { Gv
, Ev
} },
2010 { "cmovbS", { Gv
, Ev
} },
2011 { "cmovaeS", { Gv
, Ev
} },
2012 { "cmoveS", { Gv
, Ev
} },
2013 { "cmovneS", { Gv
, Ev
} },
2014 { "cmovbeS", { Gv
, Ev
} },
2015 { "cmovaS", { Gv
, Ev
} },
2017 { "cmovsS", { Gv
, Ev
} },
2018 { "cmovnsS", { Gv
, Ev
} },
2019 { "cmovpS", { Gv
, Ev
} },
2020 { "cmovnpS", { Gv
, Ev
} },
2021 { "cmovlS", { Gv
, Ev
} },
2022 { "cmovgeS", { Gv
, Ev
} },
2023 { "cmovleS", { Gv
, Ev
} },
2024 { "cmovgS", { Gv
, Ev
} },
2026 { MOD_TABLE (MOD_0F51
) },
2027 { PREFIX_TABLE (PREFIX_0F51
) },
2028 { PREFIX_TABLE (PREFIX_0F52
) },
2029 { PREFIX_TABLE (PREFIX_0F53
) },
2030 { "andpX", { XM
, EXx
} },
2031 { "andnpX", { XM
, EXx
} },
2032 { "orpX", { XM
, EXx
} },
2033 { "xorpX", { XM
, EXx
} },
2035 { PREFIX_TABLE (PREFIX_0F58
) },
2036 { PREFIX_TABLE (PREFIX_0F59
) },
2037 { PREFIX_TABLE (PREFIX_0F5A
) },
2038 { PREFIX_TABLE (PREFIX_0F5B
) },
2039 { PREFIX_TABLE (PREFIX_0F5C
) },
2040 { PREFIX_TABLE (PREFIX_0F5D
) },
2041 { PREFIX_TABLE (PREFIX_0F5E
) },
2042 { PREFIX_TABLE (PREFIX_0F5F
) },
2044 { PREFIX_TABLE (PREFIX_0F60
) },
2045 { PREFIX_TABLE (PREFIX_0F61
) },
2046 { PREFIX_TABLE (PREFIX_0F62
) },
2047 { "packsswb", { MX
, EM
} },
2048 { "pcmpgtb", { MX
, EM
} },
2049 { "pcmpgtw", { MX
, EM
} },
2050 { "pcmpgtd", { MX
, EM
} },
2051 { "packuswb", { MX
, EM
} },
2053 { "punpckhbw", { MX
, EM
} },
2054 { "punpckhwd", { MX
, EM
} },
2055 { "punpckhdq", { MX
, EM
} },
2056 { "packssdw", { MX
, EM
} },
2057 { PREFIX_TABLE (PREFIX_0F6C
) },
2058 { PREFIX_TABLE (PREFIX_0F6D
) },
2059 { "movK", { MX
, Edq
} },
2060 { PREFIX_TABLE (PREFIX_0F6F
) },
2062 { PREFIX_TABLE (PREFIX_0F70
) },
2063 { REG_TABLE (REG_0F71
) },
2064 { REG_TABLE (REG_0F72
) },
2065 { REG_TABLE (REG_0F73
) },
2066 { "pcmpeqb", { MX
, EM
} },
2067 { "pcmpeqw", { MX
, EM
} },
2068 { "pcmpeqd", { MX
, EM
} },
2071 { PREFIX_TABLE (PREFIX_0F78
) },
2072 { PREFIX_TABLE (PREFIX_0F79
) },
2073 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2075 { PREFIX_TABLE (PREFIX_0F7C
) },
2076 { PREFIX_TABLE (PREFIX_0F7D
) },
2077 { PREFIX_TABLE (PREFIX_0F7E
) },
2078 { PREFIX_TABLE (PREFIX_0F7F
) },
2080 { "joH", { Jv
, XX
, cond_jump_flag
} },
2081 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
2082 { "jbH", { Jv
, XX
, cond_jump_flag
} },
2083 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
2084 { "jeH", { Jv
, XX
, cond_jump_flag
} },
2085 { "jneH", { Jv
, XX
, cond_jump_flag
} },
2086 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
2087 { "jaH", { Jv
, XX
, cond_jump_flag
} },
2089 { "jsH", { Jv
, XX
, cond_jump_flag
} },
2090 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
2091 { "jpH", { Jv
, XX
, cond_jump_flag
} },
2092 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
2093 { "jlH", { Jv
, XX
, cond_jump_flag
} },
2094 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
2095 { "jleH", { Jv
, XX
, cond_jump_flag
} },
2096 { "jgH", { Jv
, XX
, cond_jump_flag
} },
2099 { "setno", { Eb
} },
2101 { "setae", { Eb
} },
2103 { "setne", { Eb
} },
2104 { "setbe", { Eb
} },
2108 { "setns", { Eb
} },
2110 { "setnp", { Eb
} },
2112 { "setge", { Eb
} },
2113 { "setle", { Eb
} },
2116 { "pushT", { fs
} },
2118 { "cpuid", { XX
} },
2119 { "btS", { Ev
, Gv
} },
2120 { "shldS", { Ev
, Gv
, Ib
} },
2121 { "shldS", { Ev
, Gv
, CL
} },
2122 { REG_TABLE (REG_0FA6
) },
2123 { REG_TABLE (REG_0FA7
) },
2125 { "pushT", { gs
} },
2128 { "btsS", { Ev
, Gv
} },
2129 { "shrdS", { Ev
, Gv
, Ib
} },
2130 { "shrdS", { Ev
, Gv
, CL
} },
2131 { REG_TABLE (REG_0FAE
) },
2132 { "imulS", { Gv
, Ev
} },
2134 { "cmpxchgB", { Eb
, Gb
} },
2135 { "cmpxchgS", { Ev
, Gv
} },
2136 { MOD_TABLE (MOD_0FB2
) },
2137 { "btrS", { Ev
, Gv
} },
2138 { MOD_TABLE (MOD_0FB4
) },
2139 { MOD_TABLE (MOD_0FB5
) },
2140 { "movz{bR|x}", { Gv
, Eb
} },
2141 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
2143 { PREFIX_TABLE (PREFIX_0FB8
) },
2145 { REG_TABLE (REG_0FBA
) },
2146 { "btcS", { Ev
, Gv
} },
2147 { "bsfS", { Gv
, Ev
} },
2148 { PREFIX_TABLE (PREFIX_0FBD
) },
2149 { "movs{bR|x}", { Gv
, Eb
} },
2150 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
2152 { "xaddB", { Eb
, Gb
} },
2153 { "xaddS", { Ev
, Gv
} },
2154 { PREFIX_TABLE (PREFIX_0FC2
) },
2155 { PREFIX_TABLE (PREFIX_0FC3
) },
2156 { "pinsrw", { MX
, Edqw
, Ib
} },
2157 { "pextrw", { Gdq
, MS
, Ib
} },
2158 { "shufpX", { XM
, EXx
, Ib
} },
2159 { REG_TABLE (REG_0FC7
) },
2161 { "bswap", { RMeAX
} },
2162 { "bswap", { RMeCX
} },
2163 { "bswap", { RMeDX
} },
2164 { "bswap", { RMeBX
} },
2165 { "bswap", { RMeSP
} },
2166 { "bswap", { RMeBP
} },
2167 { "bswap", { RMeSI
} },
2168 { "bswap", { RMeDI
} },
2170 { PREFIX_TABLE (PREFIX_0FD0
) },
2171 { "psrlw", { MX
, EM
} },
2172 { "psrld", { MX
, EM
} },
2173 { "psrlq", { MX
, EM
} },
2174 { "paddq", { MX
, EM
} },
2175 { "pmullw", { MX
, EM
} },
2176 { PREFIX_TABLE (PREFIX_0FD6
) },
2177 { MOD_TABLE (MOD_0FD7
) },
2179 { "psubusb", { MX
, EM
} },
2180 { "psubusw", { MX
, EM
} },
2181 { "pminub", { MX
, EM
} },
2182 { "pand", { MX
, EM
} },
2183 { "paddusb", { MX
, EM
} },
2184 { "paddusw", { MX
, EM
} },
2185 { "pmaxub", { MX
, EM
} },
2186 { "pandn", { MX
, EM
} },
2188 { "pavgb", { MX
, EM
} },
2189 { "psraw", { MX
, EM
} },
2190 { "psrad", { MX
, EM
} },
2191 { "pavgw", { MX
, EM
} },
2192 { "pmulhuw", { MX
, EM
} },
2193 { "pmulhw", { MX
, EM
} },
2194 { PREFIX_TABLE (PREFIX_0FE6
) },
2195 { PREFIX_TABLE (PREFIX_0FE7
) },
2197 { "psubsb", { MX
, EM
} },
2198 { "psubsw", { MX
, EM
} },
2199 { "pminsw", { MX
, EM
} },
2200 { "por", { MX
, EM
} },
2201 { "paddsb", { MX
, EM
} },
2202 { "paddsw", { MX
, EM
} },
2203 { "pmaxsw", { MX
, EM
} },
2204 { "pxor", { MX
, EM
} },
2206 { PREFIX_TABLE (PREFIX_0FF0
) },
2207 { "psllw", { MX
, EM
} },
2208 { "pslld", { MX
, EM
} },
2209 { "psllq", { MX
, EM
} },
2210 { "pmuludq", { MX
, EM
} },
2211 { "pmaddwd", { MX
, EM
} },
2212 { "psadbw", { MX
, EM
} },
2213 { PREFIX_TABLE (PREFIX_0FF7
) },
2215 { "psubb", { MX
, EM
} },
2216 { "psubw", { MX
, EM
} },
2217 { "psubd", { MX
, EM
} },
2218 { "psubq", { MX
, EM
} },
2219 { "paddb", { MX
, EM
} },
2220 { "paddw", { MX
, EM
} },
2221 { "paddd", { MX
, EM
} },
2225 static const unsigned char onebyte_has_modrm
[256] = {
2226 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2227 /* ------------------------------- */
2228 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2229 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2230 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2231 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2232 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2233 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2234 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2235 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2236 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2237 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2238 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2239 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2240 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2241 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2242 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2243 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2244 /* ------------------------------- */
2245 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2248 static const unsigned char twobyte_has_modrm
[256] = {
2249 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2250 /* ------------------------------- */
2251 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2252 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2253 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2254 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2255 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2256 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2257 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2258 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2259 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2260 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2261 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2262 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2263 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2264 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2265 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2266 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2267 /* ------------------------------- */
2268 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2271 static char obuf
[100];
2273 static char *mnemonicendp
;
2274 static char scratchbuf
[100];
2275 static unsigned char *start_codep
;
2276 static unsigned char *insn_codep
;
2277 static unsigned char *codep
;
2278 static int last_lock_prefix
;
2279 static int last_repz_prefix
;
2280 static int last_repnz_prefix
;
2281 static int last_data_prefix
;
2282 static int last_addr_prefix
;
2283 static int last_rex_prefix
;
2284 static int last_seg_prefix
;
2285 #define MAX_CODE_LENGTH 15
2286 /* We can up to 14 prefixes since the maximum instruction length is
2288 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2289 static disassemble_info
*the_info
;
2297 static unsigned char need_modrm
;
2300 int register_specifier
;
2306 static unsigned char need_vex
;
2307 static unsigned char need_vex_reg
;
2308 static unsigned char vex_w_done
;
2316 /* If we are accessing mod/rm/reg without need_modrm set, then the
2317 values are stale. Hitting this abort likely indicates that you
2318 need to update onebyte_has_modrm or twobyte_has_modrm. */
2319 #define MODRM_CHECK if (!need_modrm) abort ()
2321 static const char **names64
;
2322 static const char **names32
;
2323 static const char **names16
;
2324 static const char **names8
;
2325 static const char **names8rex
;
2326 static const char **names_seg
;
2327 static const char *index64
;
2328 static const char *index32
;
2329 static const char **index16
;
2331 static const char *intel_names64
[] = {
2332 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2333 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2335 static const char *intel_names32
[] = {
2336 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2337 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2339 static const char *intel_names16
[] = {
2340 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2341 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2343 static const char *intel_names8
[] = {
2344 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2346 static const char *intel_names8rex
[] = {
2347 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2348 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2350 static const char *intel_names_seg
[] = {
2351 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2353 static const char *intel_index64
= "riz";
2354 static const char *intel_index32
= "eiz";
2355 static const char *intel_index16
[] = {
2356 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2359 static const char *att_names64
[] = {
2360 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2361 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2363 static const char *att_names32
[] = {
2364 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2365 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2367 static const char *att_names16
[] = {
2368 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2369 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2371 static const char *att_names8
[] = {
2372 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2374 static const char *att_names8rex
[] = {
2375 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2376 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2378 static const char *att_names_seg
[] = {
2379 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2381 static const char *att_index64
= "%riz";
2382 static const char *att_index32
= "%eiz";
2383 static const char *att_index16
[] = {
2384 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2387 static const char **names_mm
;
2388 static const char *intel_names_mm
[] = {
2389 "mm0", "mm1", "mm2", "mm3",
2390 "mm4", "mm5", "mm6", "mm7"
2392 static const char *att_names_mm
[] = {
2393 "%mm0", "%mm1", "%mm2", "%mm3",
2394 "%mm4", "%mm5", "%mm6", "%mm7"
2397 static const char **names_xmm
;
2398 static const char *intel_names_xmm
[] = {
2399 "xmm0", "xmm1", "xmm2", "xmm3",
2400 "xmm4", "xmm5", "xmm6", "xmm7",
2401 "xmm8", "xmm9", "xmm10", "xmm11",
2402 "xmm12", "xmm13", "xmm14", "xmm15"
2404 static const char *att_names_xmm
[] = {
2405 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2406 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
2407 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
2408 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
2411 static const char **names_ymm
;
2412 static const char *intel_names_ymm
[] = {
2413 "ymm0", "ymm1", "ymm2", "ymm3",
2414 "ymm4", "ymm5", "ymm6", "ymm7",
2415 "ymm8", "ymm9", "ymm10", "ymm11",
2416 "ymm12", "ymm13", "ymm14", "ymm15"
2418 static const char *att_names_ymm
[] = {
2419 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
2420 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
2421 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
2422 "%ymm12", "%ymm13", "%ymm14", "%ymm15"
2425 static const struct dis386 reg_table
[][8] = {
2428 { "addA", { Eb
, Ib
} },
2429 { "orA", { Eb
, Ib
} },
2430 { "adcA", { Eb
, Ib
} },
2431 { "sbbA", { Eb
, Ib
} },
2432 { "andA", { Eb
, Ib
} },
2433 { "subA", { Eb
, Ib
} },
2434 { "xorA", { Eb
, Ib
} },
2435 { "cmpA", { Eb
, Ib
} },
2439 { "addQ", { Ev
, Iv
} },
2440 { "orQ", { Ev
, Iv
} },
2441 { "adcQ", { Ev
, Iv
} },
2442 { "sbbQ", { Ev
, Iv
} },
2443 { "andQ", { Ev
, Iv
} },
2444 { "subQ", { Ev
, Iv
} },
2445 { "xorQ", { Ev
, Iv
} },
2446 { "cmpQ", { Ev
, Iv
} },
2450 { "addQ", { Ev
, sIb
} },
2451 { "orQ", { Ev
, sIb
} },
2452 { "adcQ", { Ev
, sIb
} },
2453 { "sbbQ", { Ev
, sIb
} },
2454 { "andQ", { Ev
, sIb
} },
2455 { "subQ", { Ev
, sIb
} },
2456 { "xorQ", { Ev
, sIb
} },
2457 { "cmpQ", { Ev
, sIb
} },
2461 { "popU", { stackEv
} },
2462 { XOP_8F_TABLE (XOP_09
) },
2466 { XOP_8F_TABLE (XOP_09
) },
2470 { "rolA", { Eb
, Ib
} },
2471 { "rorA", { Eb
, Ib
} },
2472 { "rclA", { Eb
, Ib
} },
2473 { "rcrA", { Eb
, Ib
} },
2474 { "shlA", { Eb
, Ib
} },
2475 { "shrA", { Eb
, Ib
} },
2477 { "sarA", { Eb
, Ib
} },
2481 { "rolQ", { Ev
, Ib
} },
2482 { "rorQ", { Ev
, Ib
} },
2483 { "rclQ", { Ev
, Ib
} },
2484 { "rcrQ", { Ev
, Ib
} },
2485 { "shlQ", { Ev
, Ib
} },
2486 { "shrQ", { Ev
, Ib
} },
2488 { "sarQ", { Ev
, Ib
} },
2492 { "movA", { Eb
, Ib
} },
2496 { "movQ", { Ev
, Iv
} },
2500 { "rolA", { Eb
, I1
} },
2501 { "rorA", { Eb
, I1
} },
2502 { "rclA", { Eb
, I1
} },
2503 { "rcrA", { Eb
, I1
} },
2504 { "shlA", { Eb
, I1
} },
2505 { "shrA", { Eb
, I1
} },
2507 { "sarA", { Eb
, I1
} },
2511 { "rolQ", { Ev
, I1
} },
2512 { "rorQ", { Ev
, I1
} },
2513 { "rclQ", { Ev
, I1
} },
2514 { "rcrQ", { Ev
, I1
} },
2515 { "shlQ", { Ev
, I1
} },
2516 { "shrQ", { Ev
, I1
} },
2518 { "sarQ", { Ev
, I1
} },
2522 { "rolA", { Eb
, CL
} },
2523 { "rorA", { Eb
, CL
} },
2524 { "rclA", { Eb
, CL
} },
2525 { "rcrA", { Eb
, CL
} },
2526 { "shlA", { Eb
, CL
} },
2527 { "shrA", { Eb
, CL
} },
2529 { "sarA", { Eb
, CL
} },
2533 { "rolQ", { Ev
, CL
} },
2534 { "rorQ", { Ev
, CL
} },
2535 { "rclQ", { Ev
, CL
} },
2536 { "rcrQ", { Ev
, CL
} },
2537 { "shlQ", { Ev
, CL
} },
2538 { "shrQ", { Ev
, CL
} },
2540 { "sarQ", { Ev
, CL
} },
2544 { "testA", { Eb
, Ib
} },
2548 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2549 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2550 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2551 { "idivA", { Eb
} }, /* and idiv for consistency. */
2555 { "testQ", { Ev
, Iv
} },
2559 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2560 { "imulQ", { Ev
} },
2562 { "idivQ", { Ev
} },
2573 { "callT", { indirEv
} },
2574 { "JcallT", { indirEp
} },
2575 { "jmpT", { indirEv
} },
2576 { "JjmpT", { indirEp
} },
2577 { "pushU", { stackEv
} },
2582 { "sldtD", { Sv
} },
2593 { MOD_TABLE (MOD_0F01_REG_0
) },
2594 { MOD_TABLE (MOD_0F01_REG_1
) },
2595 { MOD_TABLE (MOD_0F01_REG_2
) },
2596 { MOD_TABLE (MOD_0F01_REG_3
) },
2597 { "smswD", { Sv
} },
2600 { MOD_TABLE (MOD_0F01_REG_7
) },
2604 { "prefetch", { Eb
} },
2605 { "prefetchw", { Eb
} },
2609 { MOD_TABLE (MOD_0F18_REG_0
) },
2610 { MOD_TABLE (MOD_0F18_REG_1
) },
2611 { MOD_TABLE (MOD_0F18_REG_2
) },
2612 { MOD_TABLE (MOD_0F18_REG_3
) },
2618 { MOD_TABLE (MOD_0F71_REG_2
) },
2620 { MOD_TABLE (MOD_0F71_REG_4
) },
2622 { MOD_TABLE (MOD_0F71_REG_6
) },
2628 { MOD_TABLE (MOD_0F72_REG_2
) },
2630 { MOD_TABLE (MOD_0F72_REG_4
) },
2632 { MOD_TABLE (MOD_0F72_REG_6
) },
2638 { MOD_TABLE (MOD_0F73_REG_2
) },
2639 { MOD_TABLE (MOD_0F73_REG_3
) },
2642 { MOD_TABLE (MOD_0F73_REG_6
) },
2643 { MOD_TABLE (MOD_0F73_REG_7
) },
2647 { "montmul", { { OP_0f07
, 0 } } },
2648 { "xsha1", { { OP_0f07
, 0 } } },
2649 { "xsha256", { { OP_0f07
, 0 } } },
2653 { "xstore-rng", { { OP_0f07
, 0 } } },
2654 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2655 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2656 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2657 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2658 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2662 { MOD_TABLE (MOD_0FAE_REG_0
) },
2663 { MOD_TABLE (MOD_0FAE_REG_1
) },
2664 { MOD_TABLE (MOD_0FAE_REG_2
) },
2665 { MOD_TABLE (MOD_0FAE_REG_3
) },
2666 { MOD_TABLE (MOD_0FAE_REG_4
) },
2667 { MOD_TABLE (MOD_0FAE_REG_5
) },
2668 { MOD_TABLE (MOD_0FAE_REG_6
) },
2669 { MOD_TABLE (MOD_0FAE_REG_7
) },
2677 { "btQ", { Ev
, Ib
} },
2678 { "btsQ", { Ev
, Ib
} },
2679 { "btrQ", { Ev
, Ib
} },
2680 { "btcQ", { Ev
, Ib
} },
2685 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2690 { MOD_TABLE (MOD_0FC7_REG_6
) },
2691 { MOD_TABLE (MOD_0FC7_REG_7
) },
2697 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2699 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2701 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2707 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2709 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2711 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2717 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2718 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2721 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2722 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2728 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2729 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2733 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2734 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2738 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2739 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2743 static const struct dis386 prefix_table
[][4] = {
2746 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2747 { "pause", { XX
} },
2748 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2753 { "movups", { XM
, EXx
} },
2754 { "movss", { XM
, EXd
} },
2755 { "movupd", { XM
, EXx
} },
2756 { "movsd", { XM
, EXq
} },
2761 { "movups", { EXxS
, XM
} },
2762 { "movss", { EXdS
, XM
} },
2763 { "movupd", { EXxS
, XM
} },
2764 { "movsd", { EXqS
, XM
} },
2769 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2770 { "movsldup", { XM
, EXx
} },
2771 { "movlpd", { XM
, EXq
} },
2772 { "movddup", { XM
, EXq
} },
2777 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2778 { "movshdup", { XM
, EXx
} },
2779 { "movhpd", { XM
, EXq
} },
2784 { "cvtpi2ps", { XM
, EMCq
} },
2785 { "cvtsi2ss%LQ", { XM
, Ev
} },
2786 { "cvtpi2pd", { XM
, EMCq
} },
2787 { "cvtsi2sd%LQ", { XM
, Ev
} },
2792 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2793 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2794 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2795 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2800 { "cvttps2pi", { MXC
, EXq
} },
2801 { "cvttss2siY", { Gv
, EXd
} },
2802 { "cvttpd2pi", { MXC
, EXx
} },
2803 { "cvttsd2siY", { Gv
, EXq
} },
2808 { "cvtps2pi", { MXC
, EXq
} },
2809 { "cvtss2siY", { Gv
, EXd
} },
2810 { "cvtpd2pi", { MXC
, EXx
} },
2811 { "cvtsd2siY", { Gv
, EXq
} },
2816 { "ucomiss",{ XM
, EXd
} },
2818 { "ucomisd",{ XM
, EXq
} },
2823 { "comiss", { XM
, EXd
} },
2825 { "comisd", { XM
, EXq
} },
2830 { "sqrtps", { XM
, EXx
} },
2831 { "sqrtss", { XM
, EXd
} },
2832 { "sqrtpd", { XM
, EXx
} },
2833 { "sqrtsd", { XM
, EXq
} },
2838 { "rsqrtps",{ XM
, EXx
} },
2839 { "rsqrtss",{ XM
, EXd
} },
2844 { "rcpps", { XM
, EXx
} },
2845 { "rcpss", { XM
, EXd
} },
2850 { "addps", { XM
, EXx
} },
2851 { "addss", { XM
, EXd
} },
2852 { "addpd", { XM
, EXx
} },
2853 { "addsd", { XM
, EXq
} },
2858 { "mulps", { XM
, EXx
} },
2859 { "mulss", { XM
, EXd
} },
2860 { "mulpd", { XM
, EXx
} },
2861 { "mulsd", { XM
, EXq
} },
2866 { "cvtps2pd", { XM
, EXq
} },
2867 { "cvtss2sd", { XM
, EXd
} },
2868 { "cvtpd2ps", { XM
, EXx
} },
2869 { "cvtsd2ss", { XM
, EXq
} },
2874 { "cvtdq2ps", { XM
, EXx
} },
2875 { "cvttps2dq", { XM
, EXx
} },
2876 { "cvtps2dq", { XM
, EXx
} },
2881 { "subps", { XM
, EXx
} },
2882 { "subss", { XM
, EXd
} },
2883 { "subpd", { XM
, EXx
} },
2884 { "subsd", { XM
, EXq
} },
2889 { "minps", { XM
, EXx
} },
2890 { "minss", { XM
, EXd
} },
2891 { "minpd", { XM
, EXx
} },
2892 { "minsd", { XM
, EXq
} },
2897 { "divps", { XM
, EXx
} },
2898 { "divss", { XM
, EXd
} },
2899 { "divpd", { XM
, EXx
} },
2900 { "divsd", { XM
, EXq
} },
2905 { "maxps", { XM
, EXx
} },
2906 { "maxss", { XM
, EXd
} },
2907 { "maxpd", { XM
, EXx
} },
2908 { "maxsd", { XM
, EXq
} },
2913 { "punpcklbw",{ MX
, EMd
} },
2915 { "punpcklbw",{ MX
, EMx
} },
2920 { "punpcklwd",{ MX
, EMd
} },
2922 { "punpcklwd",{ MX
, EMx
} },
2927 { "punpckldq",{ MX
, EMd
} },
2929 { "punpckldq",{ MX
, EMx
} },
2936 { "punpcklqdq", { XM
, EXx
} },
2943 { "punpckhqdq", { XM
, EXx
} },
2948 { "movq", { MX
, EM
} },
2949 { "movdqu", { XM
, EXx
} },
2950 { "movdqa", { XM
, EXx
} },
2955 { "pshufw", { MX
, EM
, Ib
} },
2956 { "pshufhw",{ XM
, EXx
, Ib
} },
2957 { "pshufd", { XM
, EXx
, Ib
} },
2958 { "pshuflw",{ XM
, EXx
, Ib
} },
2961 /* PREFIX_0F73_REG_3 */
2965 { "psrldq", { XS
, Ib
} },
2968 /* PREFIX_0F73_REG_7 */
2972 { "pslldq", { XS
, Ib
} },
2977 {"vmread", { Em
, Gm
} },
2979 {"extrq", { XS
, Ib
, Ib
} },
2980 {"insertq", { XM
, XS
, Ib
, Ib
} },
2985 {"vmwrite", { Gm
, Em
} },
2987 {"extrq", { XM
, XS
} },
2988 {"insertq", { XM
, XS
} },
2995 { "haddpd", { XM
, EXx
} },
2996 { "haddps", { XM
, EXx
} },
3003 { "hsubpd", { XM
, EXx
} },
3004 { "hsubps", { XM
, EXx
} },
3009 { "movK", { Edq
, MX
} },
3010 { "movq", { XM
, EXq
} },
3011 { "movK", { Edq
, XM
} },
3016 { "movq", { EMS
, MX
} },
3017 { "movdqu", { EXxS
, XM
} },
3018 { "movdqa", { EXxS
, XM
} },
3024 { "popcntS", { Gv
, Ev
} },
3029 { "bsrS", { Gv
, Ev
} },
3030 { "lzcntS", { Gv
, Ev
} },
3031 { "bsrS", { Gv
, Ev
} },
3036 { "cmpps", { XM
, EXx
, CMP
} },
3037 { "cmpss", { XM
, EXd
, CMP
} },
3038 { "cmppd", { XM
, EXx
, CMP
} },
3039 { "cmpsd", { XM
, EXq
, CMP
} },
3044 { "movntiS", { Ma
, Gv
} },
3047 /* PREFIX_0FC7_REG_6 */
3049 { "vmptrld",{ Mq
} },
3050 { "vmxon", { Mq
} },
3051 { "vmclear",{ Mq
} },
3058 { "addsubpd", { XM
, EXx
} },
3059 { "addsubps", { XM
, EXx
} },
3065 { "movq2dq",{ XM
, MS
} },
3066 { "movq", { EXqS
, XM
} },
3067 { "movdq2q",{ MX
, XS
} },
3073 { "cvtdq2pd", { XM
, EXq
} },
3074 { "cvttpd2dq", { XM
, EXx
} },
3075 { "cvtpd2dq", { XM
, EXx
} },
3080 { "movntq", { Mq
, MX
} },
3082 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
3090 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
3095 { "maskmovq", { MX
, MS
} },
3097 { "maskmovdqu", { XM
, XS
} },
3104 { "pblendvb", { XM
, EXx
, XMM0
} },
3111 { "blendvps", { XM
, EXx
, XMM0
} },
3118 { "blendvpd", { XM
, EXx
, XMM0
} },
3125 { "ptest", { XM
, EXx
} },
3132 { "pmovsxbw", { XM
, EXq
} },
3139 { "pmovsxbd", { XM
, EXd
} },
3146 { "pmovsxbq", { XM
, EXw
} },
3153 { "pmovsxwd", { XM
, EXq
} },
3160 { "pmovsxwq", { XM
, EXd
} },
3167 { "pmovsxdq", { XM
, EXq
} },
3174 { "pmuldq", { XM
, EXx
} },
3181 { "pcmpeqq", { XM
, EXx
} },
3188 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
3195 { "packusdw", { XM
, EXx
} },
3202 { "pmovzxbw", { XM
, EXq
} },
3209 { "pmovzxbd", { XM
, EXd
} },
3216 { "pmovzxbq", { XM
, EXw
} },
3223 { "pmovzxwd", { XM
, EXq
} },
3230 { "pmovzxwq", { XM
, EXd
} },
3237 { "pmovzxdq", { XM
, EXq
} },
3244 { "pcmpgtq", { XM
, EXx
} },
3251 { "pminsb", { XM
, EXx
} },
3258 { "pminsd", { XM
, EXx
} },
3265 { "pminuw", { XM
, EXx
} },
3272 { "pminud", { XM
, EXx
} },
3279 { "pmaxsb", { XM
, EXx
} },
3286 { "pmaxsd", { XM
, EXx
} },
3293 { "pmaxuw", { XM
, EXx
} },
3300 { "pmaxud", { XM
, EXx
} },
3307 { "pmulld", { XM
, EXx
} },
3314 { "phminposuw", { XM
, EXx
} },
3321 { "invept", { Gm
, Mo
} },
3328 { "invvpid", { Gm
, Mo
} },
3335 { "aesimc", { XM
, EXx
} },
3342 { "aesenc", { XM
, EXx
} },
3349 { "aesenclast", { XM
, EXx
} },
3356 { "aesdec", { XM
, EXx
} },
3363 { "aesdeclast", { XM
, EXx
} },
3368 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3370 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3371 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3376 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3378 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3379 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3386 { "roundps", { XM
, EXx
, Ib
} },
3393 { "roundpd", { XM
, EXx
, Ib
} },
3400 { "roundss", { XM
, EXd
, Ib
} },
3407 { "roundsd", { XM
, EXq
, Ib
} },
3414 { "blendps", { XM
, EXx
, Ib
} },
3421 { "blendpd", { XM
, EXx
, Ib
} },
3428 { "pblendw", { XM
, EXx
, Ib
} },
3435 { "pextrb", { Edqb
, XM
, Ib
} },
3442 { "pextrw", { Edqw
, XM
, Ib
} },
3449 { "pextrK", { Edq
, XM
, Ib
} },
3456 { "extractps", { Edqd
, XM
, Ib
} },
3463 { "pinsrb", { XM
, Edqb
, Ib
} },
3470 { "insertps", { XM
, EXd
, Ib
} },
3477 { "pinsrK", { XM
, Edq
, Ib
} },
3484 { "dpps", { XM
, EXx
, Ib
} },
3491 { "dppd", { XM
, EXx
, Ib
} },
3498 { "mpsadbw", { XM
, EXx
, Ib
} },
3505 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3512 { "pcmpestrm", { XM
, EXx
, Ib
} },
3519 { "pcmpestri", { XM
, EXx
, Ib
} },
3526 { "pcmpistrm", { XM
, EXx
, Ib
} },
3533 { "pcmpistri", { XM
, EXx
, Ib
} },
3540 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3545 { VEX_W_TABLE (VEX_W_10_P_0
) },
3546 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3547 { VEX_W_TABLE (VEX_W_10_P_2
) },
3548 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3553 { VEX_W_TABLE (VEX_W_11_P_0
) },
3554 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3555 { VEX_W_TABLE (VEX_W_11_P_2
) },
3556 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3561 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3562 { VEX_W_TABLE (VEX_W_12_P_1
) },
3563 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3564 { VEX_W_TABLE (VEX_W_12_P_3
) },
3569 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3570 { VEX_W_TABLE (VEX_W_16_P_1
) },
3571 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3577 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3579 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3585 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3587 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3593 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3595 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3600 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3602 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3607 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3609 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3614 { VEX_W_TABLE (VEX_W_51_P_0
) },
3615 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3616 { VEX_W_TABLE (VEX_W_51_P_2
) },
3617 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3622 { VEX_W_TABLE (VEX_W_52_P_0
) },
3623 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3628 { VEX_W_TABLE (VEX_W_53_P_0
) },
3629 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3634 { VEX_W_TABLE (VEX_W_58_P_0
) },
3635 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3636 { VEX_W_TABLE (VEX_W_58_P_2
) },
3637 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3642 { VEX_W_TABLE (VEX_W_59_P_0
) },
3643 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3644 { VEX_W_TABLE (VEX_W_59_P_2
) },
3645 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3650 { VEX_W_TABLE (VEX_W_5A_P_0
) },
3651 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3652 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3653 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3658 { VEX_W_TABLE (VEX_W_5B_P_0
) },
3659 { VEX_W_TABLE (VEX_W_5B_P_1
) },
3660 { VEX_W_TABLE (VEX_W_5B_P_2
) },
3665 { VEX_W_TABLE (VEX_W_5C_P_0
) },
3666 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3667 { VEX_W_TABLE (VEX_W_5C_P_2
) },
3668 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3673 { VEX_W_TABLE (VEX_W_5D_P_0
) },
3674 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3675 { VEX_W_TABLE (VEX_W_5D_P_2
) },
3676 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3681 { VEX_W_TABLE (VEX_W_5E_P_0
) },
3682 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3683 { VEX_W_TABLE (VEX_W_5E_P_2
) },
3684 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3689 { VEX_W_TABLE (VEX_W_5F_P_0
) },
3690 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3691 { VEX_W_TABLE (VEX_W_5F_P_2
) },
3692 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3699 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3706 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3713 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3720 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3727 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3734 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3741 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3748 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3755 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3762 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3769 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3776 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3783 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3790 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3797 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3803 { VEX_W_TABLE (VEX_W_6F_P_1
) },
3804 { VEX_W_TABLE (VEX_W_6F_P_2
) },
3810 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3811 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3812 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3815 /* PREFIX_VEX_71_REG_2 */
3819 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3822 /* PREFIX_VEX_71_REG_4 */
3826 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3829 /* PREFIX_VEX_71_REG_6 */
3833 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3836 /* PREFIX_VEX_72_REG_2 */
3840 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3843 /* PREFIX_VEX_72_REG_4 */
3847 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3850 /* PREFIX_VEX_72_REG_6 */
3854 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3857 /* PREFIX_VEX_73_REG_2 */
3861 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3864 /* PREFIX_VEX_73_REG_3 */
3868 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3871 /* PREFIX_VEX_73_REG_6 */
3875 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3878 /* PREFIX_VEX_73_REG_7 */
3882 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3889 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3896 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3903 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3908 { VEX_W_TABLE (VEX_W_77_P_0
) },
3915 { VEX_W_TABLE (VEX_W_7C_P_2
) },
3916 { VEX_W_TABLE (VEX_W_7C_P_3
) },
3923 { VEX_W_TABLE (VEX_W_7D_P_2
) },
3924 { VEX_W_TABLE (VEX_W_7D_P_3
) },
3930 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3931 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3937 { VEX_W_TABLE (VEX_W_7F_P_1
) },
3938 { VEX_W_TABLE (VEX_W_7F_P_2
) },
3943 { VEX_W_TABLE (VEX_W_C2_P_0
) },
3944 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3945 { VEX_W_TABLE (VEX_W_C2_P_2
) },
3946 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3953 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3960 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3967 { VEX_W_TABLE (VEX_W_D0_P_2
) },
3968 { VEX_W_TABLE (VEX_W_D0_P_3
) },
3975 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3982 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3989 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
3996 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
4003 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
4010 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
4017 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
4024 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
4031 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
4038 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
4045 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
4052 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
4059 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
4066 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
4073 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
4080 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
4087 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
4094 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
4101 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
4108 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4115 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4121 { VEX_W_TABLE (VEX_W_E6_P_1
) },
4122 { VEX_W_TABLE (VEX_W_E6_P_2
) },
4123 { VEX_W_TABLE (VEX_W_E6_P_3
) },
4130 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4137 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4144 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4151 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4158 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4165 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4172 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4179 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4186 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4194 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4201 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4208 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4215 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4222 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4229 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4236 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4243 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4250 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4257 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4264 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4271 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4278 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4285 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4292 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4295 /* PREFIX_VEX_3800 */
4299 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4302 /* PREFIX_VEX_3801 */
4306 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4309 /* PREFIX_VEX_3802 */
4313 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4316 /* PREFIX_VEX_3803 */
4320 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4323 /* PREFIX_VEX_3804 */
4327 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4330 /* PREFIX_VEX_3805 */
4334 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4337 /* PREFIX_VEX_3806 */
4341 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4344 /* PREFIX_VEX_3807 */
4348 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4351 /* PREFIX_VEX_3808 */
4355 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4358 /* PREFIX_VEX_3809 */
4362 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4365 /* PREFIX_VEX_380A */
4369 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4372 /* PREFIX_VEX_380B */
4376 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4379 /* PREFIX_VEX_380C */
4383 { VEX_W_TABLE (VEX_W_380C_P_2
) },
4386 /* PREFIX_VEX_380D */
4390 { VEX_W_TABLE (VEX_W_380D_P_2
) },
4393 /* PREFIX_VEX_380E */
4397 { VEX_W_TABLE (VEX_W_380E_P_2
) },
4400 /* PREFIX_VEX_380F */
4404 { VEX_W_TABLE (VEX_W_380F_P_2
) },
4407 /* PREFIX_VEX_3817 */
4411 { VEX_W_TABLE (VEX_W_3817_P_2
) },
4414 /* PREFIX_VEX_3818 */
4418 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4421 /* PREFIX_VEX_3819 */
4425 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4428 /* PREFIX_VEX_381A */
4432 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4435 /* PREFIX_VEX_381C */
4439 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4442 /* PREFIX_VEX_381D */
4446 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4449 /* PREFIX_VEX_381E */
4453 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4456 /* PREFIX_VEX_3820 */
4460 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4463 /* PREFIX_VEX_3821 */
4467 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4470 /* PREFIX_VEX_3822 */
4474 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4477 /* PREFIX_VEX_3823 */
4481 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4484 /* PREFIX_VEX_3824 */
4488 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4491 /* PREFIX_VEX_3825 */
4495 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4498 /* PREFIX_VEX_3828 */
4502 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4505 /* PREFIX_VEX_3829 */
4509 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4512 /* PREFIX_VEX_382A */
4516 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4519 /* PREFIX_VEX_382B */
4523 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4526 /* PREFIX_VEX_382C */
4530 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4533 /* PREFIX_VEX_382D */
4537 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4540 /* PREFIX_VEX_382E */
4544 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4547 /* PREFIX_VEX_382F */
4551 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4554 /* PREFIX_VEX_3830 */
4558 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4561 /* PREFIX_VEX_3831 */
4565 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4568 /* PREFIX_VEX_3832 */
4572 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4575 /* PREFIX_VEX_3833 */
4579 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4582 /* PREFIX_VEX_3834 */
4586 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4589 /* PREFIX_VEX_3835 */
4593 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4596 /* PREFIX_VEX_3837 */
4600 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4603 /* PREFIX_VEX_3838 */
4607 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4610 /* PREFIX_VEX_3839 */
4614 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4617 /* PREFIX_VEX_383A */
4621 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4624 /* PREFIX_VEX_383B */
4628 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4631 /* PREFIX_VEX_383C */
4635 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4638 /* PREFIX_VEX_383D */
4642 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4645 /* PREFIX_VEX_383E */
4649 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4652 /* PREFIX_VEX_383F */
4656 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4659 /* PREFIX_VEX_3840 */
4663 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4666 /* PREFIX_VEX_3841 */
4670 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4673 /* PREFIX_VEX_3896 */
4677 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4680 /* PREFIX_VEX_3897 */
4684 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4687 /* PREFIX_VEX_3898 */
4691 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4694 /* PREFIX_VEX_3899 */
4698 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4701 /* PREFIX_VEX_389A */
4705 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4708 /* PREFIX_VEX_389B */
4712 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4715 /* PREFIX_VEX_389C */
4719 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4722 /* PREFIX_VEX_389D */
4726 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4729 /* PREFIX_VEX_389E */
4733 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4736 /* PREFIX_VEX_389F */
4740 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4743 /* PREFIX_VEX_38A6 */
4747 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4751 /* PREFIX_VEX_38A7 */
4755 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4758 /* PREFIX_VEX_38A8 */
4762 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4765 /* PREFIX_VEX_38A9 */
4769 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4772 /* PREFIX_VEX_38AA */
4776 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4779 /* PREFIX_VEX_38AB */
4783 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4786 /* PREFIX_VEX_38AC */
4790 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4793 /* PREFIX_VEX_38AD */
4797 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4800 /* PREFIX_VEX_38AE */
4804 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4807 /* PREFIX_VEX_38AF */
4811 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4814 /* PREFIX_VEX_38B6 */
4818 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4821 /* PREFIX_VEX_38B7 */
4825 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4828 /* PREFIX_VEX_38B8 */
4832 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4835 /* PREFIX_VEX_38B9 */
4839 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4842 /* PREFIX_VEX_38BA */
4846 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4849 /* PREFIX_VEX_38BB */
4853 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4856 /* PREFIX_VEX_38BC */
4860 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4863 /* PREFIX_VEX_38BD */
4867 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4870 /* PREFIX_VEX_38BE */
4874 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4877 /* PREFIX_VEX_38BF */
4881 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4884 /* PREFIX_VEX_38DB */
4888 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4891 /* PREFIX_VEX_38DC */
4895 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4898 /* PREFIX_VEX_38DD */
4902 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4905 /* PREFIX_VEX_38DE */
4909 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4912 /* PREFIX_VEX_38DF */
4916 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4919 /* PREFIX_VEX_3A04 */
4923 { VEX_W_TABLE (VEX_W_3A04_P_2
) },
4926 /* PREFIX_VEX_3A05 */
4930 { VEX_W_TABLE (VEX_W_3A05_P_2
) },
4933 /* PREFIX_VEX_3A06 */
4937 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4940 /* PREFIX_VEX_3A08 */
4944 { VEX_W_TABLE (VEX_W_3A08_P_2
) },
4947 /* PREFIX_VEX_3A09 */
4951 { VEX_W_TABLE (VEX_W_3A09_P_2
) },
4954 /* PREFIX_VEX_3A0A */
4958 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4961 /* PREFIX_VEX_3A0B */
4965 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4968 /* PREFIX_VEX_3A0C */
4972 { VEX_W_TABLE (VEX_W_3A0C_P_2
) },
4975 /* PREFIX_VEX_3A0D */
4979 { VEX_W_TABLE (VEX_W_3A0D_P_2
) },
4982 /* PREFIX_VEX_3A0E */
4986 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
4989 /* PREFIX_VEX_3A0F */
4993 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
4996 /* PREFIX_VEX_3A14 */
5000 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5003 /* PREFIX_VEX_3A15 */
5007 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5010 /* PREFIX_VEX_3A16 */
5014 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5017 /* PREFIX_VEX_3A17 */
5021 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5024 /* PREFIX_VEX_3A18 */
5028 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5031 /* PREFIX_VEX_3A19 */
5035 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5038 /* PREFIX_VEX_3A20 */
5042 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5045 /* PREFIX_VEX_3A21 */
5049 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5052 /* PREFIX_VEX_3A22 */
5056 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5059 /* PREFIX_VEX_3A40 */
5063 { VEX_W_TABLE (VEX_W_3A40_P_2
) },
5066 /* PREFIX_VEX_3A41 */
5070 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5073 /* PREFIX_VEX_3A42 */
5077 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5080 /* PREFIX_VEX_3A44 */
5084 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5087 /* PREFIX_VEX_3A4A */
5091 { VEX_W_TABLE (VEX_W_3A4A_P_2
) },
5094 /* PREFIX_VEX_3A4B */
5098 { VEX_W_TABLE (VEX_W_3A4B_P_2
) },
5101 /* PREFIX_VEX_3A4C */
5105 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5108 /* PREFIX_VEX_3A5C */
5112 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5115 /* PREFIX_VEX_3A5D */
5119 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5122 /* PREFIX_VEX_3A5E */
5126 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5129 /* PREFIX_VEX_3A5F */
5133 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5136 /* PREFIX_VEX_3A60 */
5140 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5144 /* PREFIX_VEX_3A61 */
5148 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5151 /* PREFIX_VEX_3A62 */
5155 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5158 /* PREFIX_VEX_3A63 */
5162 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5165 /* PREFIX_VEX_3A68 */
5169 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5172 /* PREFIX_VEX_3A69 */
5176 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5179 /* PREFIX_VEX_3A6A */
5183 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5186 /* PREFIX_VEX_3A6B */
5190 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5193 /* PREFIX_VEX_3A6C */
5197 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5200 /* PREFIX_VEX_3A6D */
5204 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5207 /* PREFIX_VEX_3A6E */
5211 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5214 /* PREFIX_VEX_3A6F */
5218 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5221 /* PREFIX_VEX_3A78 */
5225 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5228 /* PREFIX_VEX_3A79 */
5232 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5235 /* PREFIX_VEX_3A7A */
5239 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5242 /* PREFIX_VEX_3A7B */
5246 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5249 /* PREFIX_VEX_3A7C */
5253 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5257 /* PREFIX_VEX_3A7D */
5261 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5264 /* PREFIX_VEX_3A7E */
5268 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5271 /* PREFIX_VEX_3A7F */
5275 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5278 /* PREFIX_VEX_3ADF */
5282 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5286 static const struct dis386 x86_64_table
[][2] = {
5289 { "push{T|}", { es
} },
5294 { "pop{T|}", { es
} },
5299 { "push{T|}", { cs
} },
5304 { "push{T|}", { ss
} },
5309 { "pop{T|}", { ss
} },
5314 { "push{T|}", { ds
} },
5319 { "pop{T|}", { ds
} },
5344 { "pusha{P|}", { XX
} },
5349 { "popa{P|}", { XX
} },
5354 { MOD_TABLE (MOD_62_32BIT
) },
5359 { "arpl", { Ew
, Gw
} },
5360 { "movs{lq|xd}", { Gv
, Ed
} },
5365 { "ins{R|}", { Yzr
, indirDX
} },
5366 { "ins{G|}", { Yzr
, indirDX
} },
5371 { "outs{R|}", { indirDXr
, Xz
} },
5372 { "outs{G|}", { indirDXr
, Xz
} },
5377 { "Jcall{T|}", { Ap
} },
5382 { MOD_TABLE (MOD_C4_32BIT
) },
5383 { VEX_C4_TABLE (VEX_0F
) },
5388 { MOD_TABLE (MOD_C5_32BIT
) },
5389 { VEX_C5_TABLE (VEX_0F
) },
5409 { "Jjmp{T|}", { Ap
} },
5412 /* X86_64_0F01_REG_0 */
5414 { "sgdt{Q|IQ}", { M
} },
5418 /* X86_64_0F01_REG_1 */
5420 { "sidt{Q|IQ}", { M
} },
5424 /* X86_64_0F01_REG_2 */
5426 { "lgdt{Q|Q}", { M
} },
5430 /* X86_64_0F01_REG_3 */
5432 { "lidt{Q|Q}", { M
} },
5437 static const struct dis386 three_byte_table
[][256] = {
5439 /* THREE_BYTE_0F38 */
5442 { "pshufb", { MX
, EM
} },
5443 { "phaddw", { MX
, EM
} },
5444 { "phaddd", { MX
, EM
} },
5445 { "phaddsw", { MX
, EM
} },
5446 { "pmaddubsw", { MX
, EM
} },
5447 { "phsubw", { MX
, EM
} },
5448 { "phsubd", { MX
, EM
} },
5449 { "phsubsw", { MX
, EM
} },
5451 { "psignb", { MX
, EM
} },
5452 { "psignw", { MX
, EM
} },
5453 { "psignd", { MX
, EM
} },
5454 { "pmulhrsw", { MX
, EM
} },
5460 { PREFIX_TABLE (PREFIX_0F3810
) },
5464 { PREFIX_TABLE (PREFIX_0F3814
) },
5465 { PREFIX_TABLE (PREFIX_0F3815
) },
5467 { PREFIX_TABLE (PREFIX_0F3817
) },
5473 { "pabsb", { MX
, EM
} },
5474 { "pabsw", { MX
, EM
} },
5475 { "pabsd", { MX
, EM
} },
5478 { PREFIX_TABLE (PREFIX_0F3820
) },
5479 { PREFIX_TABLE (PREFIX_0F3821
) },
5480 { PREFIX_TABLE (PREFIX_0F3822
) },
5481 { PREFIX_TABLE (PREFIX_0F3823
) },
5482 { PREFIX_TABLE (PREFIX_0F3824
) },
5483 { PREFIX_TABLE (PREFIX_0F3825
) },
5487 { PREFIX_TABLE (PREFIX_0F3828
) },
5488 { PREFIX_TABLE (PREFIX_0F3829
) },
5489 { PREFIX_TABLE (PREFIX_0F382A
) },
5490 { PREFIX_TABLE (PREFIX_0F382B
) },
5496 { PREFIX_TABLE (PREFIX_0F3830
) },
5497 { PREFIX_TABLE (PREFIX_0F3831
) },
5498 { PREFIX_TABLE (PREFIX_0F3832
) },
5499 { PREFIX_TABLE (PREFIX_0F3833
) },
5500 { PREFIX_TABLE (PREFIX_0F3834
) },
5501 { PREFIX_TABLE (PREFIX_0F3835
) },
5503 { PREFIX_TABLE (PREFIX_0F3837
) },
5505 { PREFIX_TABLE (PREFIX_0F3838
) },
5506 { PREFIX_TABLE (PREFIX_0F3839
) },
5507 { PREFIX_TABLE (PREFIX_0F383A
) },
5508 { PREFIX_TABLE (PREFIX_0F383B
) },
5509 { PREFIX_TABLE (PREFIX_0F383C
) },
5510 { PREFIX_TABLE (PREFIX_0F383D
) },
5511 { PREFIX_TABLE (PREFIX_0F383E
) },
5512 { PREFIX_TABLE (PREFIX_0F383F
) },
5514 { PREFIX_TABLE (PREFIX_0F3840
) },
5515 { PREFIX_TABLE (PREFIX_0F3841
) },
5586 { PREFIX_TABLE (PREFIX_0F3880
) },
5587 { PREFIX_TABLE (PREFIX_0F3881
) },
5688 { PREFIX_TABLE (PREFIX_0F38DB
) },
5689 { PREFIX_TABLE (PREFIX_0F38DC
) },
5690 { PREFIX_TABLE (PREFIX_0F38DD
) },
5691 { PREFIX_TABLE (PREFIX_0F38DE
) },
5692 { PREFIX_TABLE (PREFIX_0F38DF
) },
5712 { PREFIX_TABLE (PREFIX_0F38F0
) },
5713 { PREFIX_TABLE (PREFIX_0F38F1
) },
5730 /* THREE_BYTE_0F3A */
5742 { PREFIX_TABLE (PREFIX_0F3A08
) },
5743 { PREFIX_TABLE (PREFIX_0F3A09
) },
5744 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5745 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5746 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5747 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5748 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5749 { "palignr", { MX
, EM
, Ib
} },
5755 { PREFIX_TABLE (PREFIX_0F3A14
) },
5756 { PREFIX_TABLE (PREFIX_0F3A15
) },
5757 { PREFIX_TABLE (PREFIX_0F3A16
) },
5758 { PREFIX_TABLE (PREFIX_0F3A17
) },
5769 { PREFIX_TABLE (PREFIX_0F3A20
) },
5770 { PREFIX_TABLE (PREFIX_0F3A21
) },
5771 { PREFIX_TABLE (PREFIX_0F3A22
) },
5805 { PREFIX_TABLE (PREFIX_0F3A40
) },
5806 { PREFIX_TABLE (PREFIX_0F3A41
) },
5807 { PREFIX_TABLE (PREFIX_0F3A42
) },
5809 { PREFIX_TABLE (PREFIX_0F3A44
) },
5841 { PREFIX_TABLE (PREFIX_0F3A60
) },
5842 { PREFIX_TABLE (PREFIX_0F3A61
) },
5843 { PREFIX_TABLE (PREFIX_0F3A62
) },
5844 { PREFIX_TABLE (PREFIX_0F3A63
) },
5983 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6022 /* THREE_BYTE_0F7A */
6061 { "ptest", { XX
} },
6098 { "phaddbw", { XM
, EXq
} },
6099 { "phaddbd", { XM
, EXq
} },
6100 { "phaddbq", { XM
, EXq
} },
6103 { "phaddwd", { XM
, EXq
} },
6104 { "phaddwq", { XM
, EXq
} },
6109 { "phadddq", { XM
, EXq
} },
6116 { "phaddubw", { XM
, EXq
} },
6117 { "phaddubd", { XM
, EXq
} },
6118 { "phaddubq", { XM
, EXq
} },
6121 { "phadduwd", { XM
, EXq
} },
6122 { "phadduwq", { XM
, EXq
} },
6127 { "phaddudq", { XM
, EXq
} },
6134 { "phsubbw", { XM
, EXq
} },
6135 { "phsubbd", { XM
, EXq
} },
6136 { "phsubbq", { XM
, EXq
} },
6315 static const struct dis386 xop_table
[][256] = {
6468 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6469 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6470 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6478 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6479 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6486 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6487 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6488 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6496 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6497 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6501 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6502 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6505 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6523 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6535 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6536 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6537 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6538 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6548 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6549 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6550 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6551 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6584 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6585 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6586 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6587 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6630 { REG_TABLE (REG_XOP_LWPCB
) },
6754 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
6755 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
6756 { "vfrczss", { XM
, EXd
} },
6757 { "vfrczsd", { XM
, EXq
} },
6772 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6773 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6774 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6775 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6776 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6777 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6778 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6779 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6781 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6782 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6783 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6784 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6827 { "vphaddbw", { XM
, EXxmm
} },
6828 { "vphaddbd", { XM
, EXxmm
} },
6829 { "vphaddbq", { XM
, EXxmm
} },
6832 { "vphaddwd", { XM
, EXxmm
} },
6833 { "vphaddwq", { XM
, EXxmm
} },
6838 { "vphadddq", { XM
, EXxmm
} },
6845 { "vphaddubw", { XM
, EXxmm
} },
6846 { "vphaddubd", { XM
, EXxmm
} },
6847 { "vphaddubq", { XM
, EXxmm
} },
6850 { "vphadduwd", { XM
, EXxmm
} },
6851 { "vphadduwq", { XM
, EXxmm
} },
6856 { "vphaddudq", { XM
, EXxmm
} },
6863 { "vphsubbw", { XM
, EXxmm
} },
6864 { "vphsubwd", { XM
, EXxmm
} },
6865 { "vphsubdq", { XM
, EXxmm
} },
6921 { REG_TABLE (REG_XOP_LWP
) },
7191 static const struct dis386 vex_table
[][256] = {
7213 { PREFIX_TABLE (PREFIX_VEX_10
) },
7214 { PREFIX_TABLE (PREFIX_VEX_11
) },
7215 { PREFIX_TABLE (PREFIX_VEX_12
) },
7216 { MOD_TABLE (MOD_VEX_13
) },
7217 { VEX_W_TABLE (VEX_W_14
) },
7218 { VEX_W_TABLE (VEX_W_15
) },
7219 { PREFIX_TABLE (PREFIX_VEX_16
) },
7220 { MOD_TABLE (MOD_VEX_17
) },
7240 { VEX_W_TABLE (VEX_W_28
) },
7241 { VEX_W_TABLE (VEX_W_29
) },
7242 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7243 { MOD_TABLE (MOD_VEX_2B
) },
7244 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7245 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7246 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7247 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7285 { MOD_TABLE (MOD_VEX_50
) },
7286 { PREFIX_TABLE (PREFIX_VEX_51
) },
7287 { PREFIX_TABLE (PREFIX_VEX_52
) },
7288 { PREFIX_TABLE (PREFIX_VEX_53
) },
7289 { "vandpX", { XM
, Vex
, EXx
} },
7290 { "vandnpX", { XM
, Vex
, EXx
} },
7291 { "vorpX", { XM
, Vex
, EXx
} },
7292 { "vxorpX", { XM
, Vex
, EXx
} },
7294 { PREFIX_TABLE (PREFIX_VEX_58
) },
7295 { PREFIX_TABLE (PREFIX_VEX_59
) },
7296 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7297 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7298 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7299 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7300 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7301 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7303 { PREFIX_TABLE (PREFIX_VEX_60
) },
7304 { PREFIX_TABLE (PREFIX_VEX_61
) },
7305 { PREFIX_TABLE (PREFIX_VEX_62
) },
7306 { PREFIX_TABLE (PREFIX_VEX_63
) },
7307 { PREFIX_TABLE (PREFIX_VEX_64
) },
7308 { PREFIX_TABLE (PREFIX_VEX_65
) },
7309 { PREFIX_TABLE (PREFIX_VEX_66
) },
7310 { PREFIX_TABLE (PREFIX_VEX_67
) },
7312 { PREFIX_TABLE (PREFIX_VEX_68
) },
7313 { PREFIX_TABLE (PREFIX_VEX_69
) },
7314 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7315 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7316 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7317 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7318 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7319 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7321 { PREFIX_TABLE (PREFIX_VEX_70
) },
7322 { REG_TABLE (REG_VEX_71
) },
7323 { REG_TABLE (REG_VEX_72
) },
7324 { REG_TABLE (REG_VEX_73
) },
7325 { PREFIX_TABLE (PREFIX_VEX_74
) },
7326 { PREFIX_TABLE (PREFIX_VEX_75
) },
7327 { PREFIX_TABLE (PREFIX_VEX_76
) },
7328 { PREFIX_TABLE (PREFIX_VEX_77
) },
7334 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7335 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7336 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7337 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7390 { REG_TABLE (REG_VEX_AE
) },
7413 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7415 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7416 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7417 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7429 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7430 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7431 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7432 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7433 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7434 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7435 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7436 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7438 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7439 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7440 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7441 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7442 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7443 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7444 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7445 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7447 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7448 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7449 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7450 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7451 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7452 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7453 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7454 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7456 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7457 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7458 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7459 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7460 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7461 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7462 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7463 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7465 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7466 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7467 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7468 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7469 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7470 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7471 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7472 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7474 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7475 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7476 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7477 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7478 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7479 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7480 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7486 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7487 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7488 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7489 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7490 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7491 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7492 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7493 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7495 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7496 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7497 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7498 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7499 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7500 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7501 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7502 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7511 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7513 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7514 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7515 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7517 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7518 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7519 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7522 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7523 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7524 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7525 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7526 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7527 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7531 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7532 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7533 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7534 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7535 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7536 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7537 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7538 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7540 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7541 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7542 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7543 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7544 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7545 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7547 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7549 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7550 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7551 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7552 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7553 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7554 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7555 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7556 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7558 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7559 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7654 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7655 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7657 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7658 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7659 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7660 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7661 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7662 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7663 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7664 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7672 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7673 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7675 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7676 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7677 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7678 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7679 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7680 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7681 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7682 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7690 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7691 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7693 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7694 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7695 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7696 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7697 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7698 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7699 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7700 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7732 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7733 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7734 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7735 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7736 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7781 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7782 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7783 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7786 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7787 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7788 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7789 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7790 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7791 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7792 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7793 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7799 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7800 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7801 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7802 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7804 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7805 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7813 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7814 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7815 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
7849 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7850 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7851 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7853 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7860 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7861 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7862 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7880 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7881 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7882 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7883 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7885 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7886 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7887 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7888 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7894 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7895 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7896 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7897 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7898 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7899 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7900 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7901 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
7912 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7913 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7914 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7915 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7916 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7917 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7918 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7919 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
8027 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8067 static const struct dis386 vex_len_table
[][2] = {
8068 /* VEX_LEN_10_P_1 */
8070 { VEX_W_TABLE (VEX_W_10_P_1
) },
8071 { VEX_W_TABLE (VEX_W_10_P_1
) },
8074 /* VEX_LEN_10_P_3 */
8076 { VEX_W_TABLE (VEX_W_10_P_3
) },
8077 { VEX_W_TABLE (VEX_W_10_P_3
) },
8080 /* VEX_LEN_11_P_1 */
8082 { VEX_W_TABLE (VEX_W_11_P_1
) },
8083 { VEX_W_TABLE (VEX_W_11_P_1
) },
8086 /* VEX_LEN_11_P_3 */
8088 { VEX_W_TABLE (VEX_W_11_P_3
) },
8089 { VEX_W_TABLE (VEX_W_11_P_3
) },
8092 /* VEX_LEN_12_P_0_M_0 */
8094 { VEX_W_TABLE (VEX_W_12_P_0_M_0
) },
8097 /* VEX_LEN_12_P_0_M_1 */
8099 { VEX_W_TABLE (VEX_W_12_P_0_M_1
) },
8102 /* VEX_LEN_12_P_2 */
8104 { VEX_W_TABLE (VEX_W_12_P_2
) },
8107 /* VEX_LEN_13_M_0 */
8109 { VEX_W_TABLE (VEX_W_13_M_0
) },
8112 /* VEX_LEN_16_P_0_M_0 */
8114 { VEX_W_TABLE (VEX_W_16_P_0_M_0
) },
8117 /* VEX_LEN_16_P_0_M_1 */
8119 { VEX_W_TABLE (VEX_W_16_P_0_M_1
) },
8122 /* VEX_LEN_16_P_2 */
8124 { VEX_W_TABLE (VEX_W_16_P_2
) },
8127 /* VEX_LEN_17_M_0 */
8129 { VEX_W_TABLE (VEX_W_17_M_0
) },
8132 /* VEX_LEN_2A_P_1 */
8134 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8135 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8138 /* VEX_LEN_2A_P_3 */
8140 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8141 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8144 /* VEX_LEN_2C_P_1 */
8146 { "vcvttss2siY", { Gv
, EXdScalar
} },
8147 { "vcvttss2siY", { Gv
, EXdScalar
} },
8150 /* VEX_LEN_2C_P_3 */
8152 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8153 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8156 /* VEX_LEN_2D_P_1 */
8158 { "vcvtss2siY", { Gv
, EXdScalar
} },
8159 { "vcvtss2siY", { Gv
, EXdScalar
} },
8162 /* VEX_LEN_2D_P_3 */
8164 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8165 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8168 /* VEX_LEN_2E_P_0 */
8170 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8171 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8174 /* VEX_LEN_2E_P_2 */
8176 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8177 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8180 /* VEX_LEN_2F_P_0 */
8182 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8183 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8186 /* VEX_LEN_2F_P_2 */
8188 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8189 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8192 /* VEX_LEN_51_P_1 */
8194 { VEX_W_TABLE (VEX_W_51_P_1
) },
8195 { VEX_W_TABLE (VEX_W_51_P_1
) },
8198 /* VEX_LEN_51_P_3 */
8200 { VEX_W_TABLE (VEX_W_51_P_3
) },
8201 { VEX_W_TABLE (VEX_W_51_P_3
) },
8204 /* VEX_LEN_52_P_1 */
8206 { VEX_W_TABLE (VEX_W_52_P_1
) },
8207 { VEX_W_TABLE (VEX_W_52_P_1
) },
8210 /* VEX_LEN_53_P_1 */
8212 { VEX_W_TABLE (VEX_W_53_P_1
) },
8213 { VEX_W_TABLE (VEX_W_53_P_1
) },
8216 /* VEX_LEN_58_P_1 */
8218 { VEX_W_TABLE (VEX_W_58_P_1
) },
8219 { VEX_W_TABLE (VEX_W_58_P_1
) },
8222 /* VEX_LEN_58_P_3 */
8224 { VEX_W_TABLE (VEX_W_58_P_3
) },
8225 { VEX_W_TABLE (VEX_W_58_P_3
) },
8228 /* VEX_LEN_59_P_1 */
8230 { VEX_W_TABLE (VEX_W_59_P_1
) },
8231 { VEX_W_TABLE (VEX_W_59_P_1
) },
8234 /* VEX_LEN_59_P_3 */
8236 { VEX_W_TABLE (VEX_W_59_P_3
) },
8237 { VEX_W_TABLE (VEX_W_59_P_3
) },
8240 /* VEX_LEN_5A_P_1 */
8242 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8243 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8246 /* VEX_LEN_5A_P_3 */
8248 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8249 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8252 /* VEX_LEN_5C_P_1 */
8254 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8255 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8258 /* VEX_LEN_5C_P_3 */
8260 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8261 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8264 /* VEX_LEN_5D_P_1 */
8266 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8267 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8270 /* VEX_LEN_5D_P_3 */
8272 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8273 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8276 /* VEX_LEN_5E_P_1 */
8278 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8279 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8282 /* VEX_LEN_5E_P_3 */
8284 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8285 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8288 /* VEX_LEN_5F_P_1 */
8290 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8291 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8294 /* VEX_LEN_5F_P_3 */
8296 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8297 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8300 /* VEX_LEN_60_P_2 */
8302 { VEX_W_TABLE (VEX_W_60_P_2
) },
8305 /* VEX_LEN_61_P_2 */
8307 { VEX_W_TABLE (VEX_W_61_P_2
) },
8310 /* VEX_LEN_62_P_2 */
8312 { VEX_W_TABLE (VEX_W_62_P_2
) },
8315 /* VEX_LEN_63_P_2 */
8317 { VEX_W_TABLE (VEX_W_63_P_2
) },
8320 /* VEX_LEN_64_P_2 */
8322 { VEX_W_TABLE (VEX_W_64_P_2
) },
8325 /* VEX_LEN_65_P_2 */
8327 { VEX_W_TABLE (VEX_W_65_P_2
) },
8330 /* VEX_LEN_66_P_2 */
8332 { VEX_W_TABLE (VEX_W_66_P_2
) },
8335 /* VEX_LEN_67_P_2 */
8337 { VEX_W_TABLE (VEX_W_67_P_2
) },
8340 /* VEX_LEN_68_P_2 */
8342 { VEX_W_TABLE (VEX_W_68_P_2
) },
8345 /* VEX_LEN_69_P_2 */
8347 { VEX_W_TABLE (VEX_W_69_P_2
) },
8350 /* VEX_LEN_6A_P_2 */
8352 { VEX_W_TABLE (VEX_W_6A_P_2
) },
8355 /* VEX_LEN_6B_P_2 */
8357 { VEX_W_TABLE (VEX_W_6B_P_2
) },
8360 /* VEX_LEN_6C_P_2 */
8362 { VEX_W_TABLE (VEX_W_6C_P_2
) },
8365 /* VEX_LEN_6D_P_2 */
8367 { VEX_W_TABLE (VEX_W_6D_P_2
) },
8370 /* VEX_LEN_6E_P_2 */
8372 { "vmovK", { XMScalar
, Edq
} },
8373 { "vmovK", { XMScalar
, Edq
} },
8376 /* VEX_LEN_70_P_1 */
8378 { VEX_W_TABLE (VEX_W_70_P_1
) },
8381 /* VEX_LEN_70_P_2 */
8383 { VEX_W_TABLE (VEX_W_70_P_2
) },
8386 /* VEX_LEN_70_P_3 */
8388 { VEX_W_TABLE (VEX_W_70_P_3
) },
8391 /* VEX_LEN_71_R_2_P_2 */
8393 { VEX_W_TABLE (VEX_W_71_R_2_P_2
) },
8396 /* VEX_LEN_71_R_4_P_2 */
8398 { VEX_W_TABLE (VEX_W_71_R_4_P_2
) },
8401 /* VEX_LEN_71_R_6_P_2 */
8403 { VEX_W_TABLE (VEX_W_71_R_6_P_2
) },
8406 /* VEX_LEN_72_R_2_P_2 */
8408 { VEX_W_TABLE (VEX_W_72_R_2_P_2
) },
8411 /* VEX_LEN_72_R_4_P_2 */
8413 { VEX_W_TABLE (VEX_W_72_R_4_P_2
) },
8416 /* VEX_LEN_72_R_6_P_2 */
8418 { VEX_W_TABLE (VEX_W_72_R_6_P_2
) },
8421 /* VEX_LEN_73_R_2_P_2 */
8423 { VEX_W_TABLE (VEX_W_73_R_2_P_2
) },
8426 /* VEX_LEN_73_R_3_P_2 */
8428 { VEX_W_TABLE (VEX_W_73_R_3_P_2
) },
8431 /* VEX_LEN_73_R_6_P_2 */
8433 { VEX_W_TABLE (VEX_W_73_R_6_P_2
) },
8436 /* VEX_LEN_73_R_7_P_2 */
8438 { VEX_W_TABLE (VEX_W_73_R_7_P_2
) },
8441 /* VEX_LEN_74_P_2 */
8443 { VEX_W_TABLE (VEX_W_74_P_2
) },
8446 /* VEX_LEN_75_P_2 */
8448 { VEX_W_TABLE (VEX_W_75_P_2
) },
8451 /* VEX_LEN_76_P_2 */
8453 { VEX_W_TABLE (VEX_W_76_P_2
) },
8456 /* VEX_LEN_7E_P_1 */
8458 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8459 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8462 /* VEX_LEN_7E_P_2 */
8464 { "vmovK", { Edq
, XMScalar
} },
8465 { "vmovK", { Edq
, XMScalar
} },
8468 /* VEX_LEN_AE_R_2_M_0 */
8470 { VEX_W_TABLE (VEX_W_AE_R_2_M_0
) },
8473 /* VEX_LEN_AE_R_3_M_0 */
8475 { VEX_W_TABLE (VEX_W_AE_R_3_M_0
) },
8478 /* VEX_LEN_C2_P_1 */
8480 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8481 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8484 /* VEX_LEN_C2_P_3 */
8486 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8487 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8490 /* VEX_LEN_C4_P_2 */
8492 { VEX_W_TABLE (VEX_W_C4_P_2
) },
8495 /* VEX_LEN_C5_P_2 */
8497 { VEX_W_TABLE (VEX_W_C5_P_2
) },
8500 /* VEX_LEN_D1_P_2 */
8502 { VEX_W_TABLE (VEX_W_D1_P_2
) },
8505 /* VEX_LEN_D2_P_2 */
8507 { VEX_W_TABLE (VEX_W_D2_P_2
) },
8510 /* VEX_LEN_D3_P_2 */
8512 { VEX_W_TABLE (VEX_W_D3_P_2
) },
8515 /* VEX_LEN_D4_P_2 */
8517 { VEX_W_TABLE (VEX_W_D4_P_2
) },
8520 /* VEX_LEN_D5_P_2 */
8522 { VEX_W_TABLE (VEX_W_D5_P_2
) },
8525 /* VEX_LEN_D6_P_2 */
8527 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8528 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8531 /* VEX_LEN_D7_P_2_M_1 */
8533 { VEX_W_TABLE (VEX_W_D7_P_2_M_1
) },
8536 /* VEX_LEN_D8_P_2 */
8538 { VEX_W_TABLE (VEX_W_D8_P_2
) },
8541 /* VEX_LEN_D9_P_2 */
8543 { VEX_W_TABLE (VEX_W_D9_P_2
) },
8546 /* VEX_LEN_DA_P_2 */
8548 { VEX_W_TABLE (VEX_W_DA_P_2
) },
8551 /* VEX_LEN_DB_P_2 */
8553 { VEX_W_TABLE (VEX_W_DB_P_2
) },
8556 /* VEX_LEN_DC_P_2 */
8558 { VEX_W_TABLE (VEX_W_DC_P_2
) },
8561 /* VEX_LEN_DD_P_2 */
8563 { VEX_W_TABLE (VEX_W_DD_P_2
) },
8566 /* VEX_LEN_DE_P_2 */
8568 { VEX_W_TABLE (VEX_W_DE_P_2
) },
8571 /* VEX_LEN_DF_P_2 */
8573 { VEX_W_TABLE (VEX_W_DF_P_2
) },
8576 /* VEX_LEN_E0_P_2 */
8578 { VEX_W_TABLE (VEX_W_E0_P_2
) },
8581 /* VEX_LEN_E1_P_2 */
8583 { VEX_W_TABLE (VEX_W_E1_P_2
) },
8586 /* VEX_LEN_E2_P_2 */
8588 { VEX_W_TABLE (VEX_W_E2_P_2
) },
8591 /* VEX_LEN_E3_P_2 */
8593 { VEX_W_TABLE (VEX_W_E3_P_2
) },
8596 /* VEX_LEN_E4_P_2 */
8598 { VEX_W_TABLE (VEX_W_E4_P_2
) },
8601 /* VEX_LEN_E5_P_2 */
8603 { VEX_W_TABLE (VEX_W_E5_P_2
) },
8606 /* VEX_LEN_E8_P_2 */
8608 { VEX_W_TABLE (VEX_W_E8_P_2
) },
8611 /* VEX_LEN_E9_P_2 */
8613 { VEX_W_TABLE (VEX_W_E9_P_2
) },
8616 /* VEX_LEN_EA_P_2 */
8618 { VEX_W_TABLE (VEX_W_EA_P_2
) },
8621 /* VEX_LEN_EB_P_2 */
8623 { VEX_W_TABLE (VEX_W_EB_P_2
) },
8626 /* VEX_LEN_EC_P_2 */
8628 { VEX_W_TABLE (VEX_W_EC_P_2
) },
8631 /* VEX_LEN_ED_P_2 */
8633 { VEX_W_TABLE (VEX_W_ED_P_2
) },
8636 /* VEX_LEN_EE_P_2 */
8638 { VEX_W_TABLE (VEX_W_EE_P_2
) },
8641 /* VEX_LEN_EF_P_2 */
8643 { VEX_W_TABLE (VEX_W_EF_P_2
) },
8646 /* VEX_LEN_F1_P_2 */
8648 { VEX_W_TABLE (VEX_W_F1_P_2
) },
8651 /* VEX_LEN_F2_P_2 */
8653 { VEX_W_TABLE (VEX_W_F2_P_2
) },
8656 /* VEX_LEN_F3_P_2 */
8658 { VEX_W_TABLE (VEX_W_F3_P_2
) },
8661 /* VEX_LEN_F4_P_2 */
8663 { VEX_W_TABLE (VEX_W_F4_P_2
) },
8666 /* VEX_LEN_F5_P_2 */
8668 { VEX_W_TABLE (VEX_W_F5_P_2
) },
8671 /* VEX_LEN_F6_P_2 */
8673 { VEX_W_TABLE (VEX_W_F6_P_2
) },
8676 /* VEX_LEN_F7_P_2 */
8678 { VEX_W_TABLE (VEX_W_F7_P_2
) },
8681 /* VEX_LEN_F8_P_2 */
8683 { VEX_W_TABLE (VEX_W_F8_P_2
) },
8686 /* VEX_LEN_F9_P_2 */
8688 { VEX_W_TABLE (VEX_W_F9_P_2
) },
8691 /* VEX_LEN_FA_P_2 */
8693 { VEX_W_TABLE (VEX_W_FA_P_2
) },
8696 /* VEX_LEN_FB_P_2 */
8698 { VEX_W_TABLE (VEX_W_FB_P_2
) },
8701 /* VEX_LEN_FC_P_2 */
8703 { VEX_W_TABLE (VEX_W_FC_P_2
) },
8706 /* VEX_LEN_FD_P_2 */
8708 { VEX_W_TABLE (VEX_W_FD_P_2
) },
8711 /* VEX_LEN_FE_P_2 */
8713 { VEX_W_TABLE (VEX_W_FE_P_2
) },
8716 /* VEX_LEN_3800_P_2 */
8718 { VEX_W_TABLE (VEX_W_3800_P_2
) },
8721 /* VEX_LEN_3801_P_2 */
8723 { VEX_W_TABLE (VEX_W_3801_P_2
) },
8726 /* VEX_LEN_3802_P_2 */
8728 { VEX_W_TABLE (VEX_W_3802_P_2
) },
8731 /* VEX_LEN_3803_P_2 */
8733 { VEX_W_TABLE (VEX_W_3803_P_2
) },
8736 /* VEX_LEN_3804_P_2 */
8738 { VEX_W_TABLE (VEX_W_3804_P_2
) },
8741 /* VEX_LEN_3805_P_2 */
8743 { VEX_W_TABLE (VEX_W_3805_P_2
) },
8746 /* VEX_LEN_3806_P_2 */
8748 { VEX_W_TABLE (VEX_W_3806_P_2
) },
8751 /* VEX_LEN_3807_P_2 */
8753 { VEX_W_TABLE (VEX_W_3807_P_2
) },
8756 /* VEX_LEN_3808_P_2 */
8758 { VEX_W_TABLE (VEX_W_3808_P_2
) },
8761 /* VEX_LEN_3809_P_2 */
8763 { VEX_W_TABLE (VEX_W_3809_P_2
) },
8766 /* VEX_LEN_380A_P_2 */
8768 { VEX_W_TABLE (VEX_W_380A_P_2
) },
8771 /* VEX_LEN_380B_P_2 */
8773 { VEX_W_TABLE (VEX_W_380B_P_2
) },
8776 /* VEX_LEN_3819_P_2_M_0 */
8779 { VEX_W_TABLE (VEX_W_3819_P_2_M_0
) },
8782 /* VEX_LEN_381A_P_2_M_0 */
8785 { VEX_W_TABLE (VEX_W_381A_P_2_M_0
) },
8788 /* VEX_LEN_381C_P_2 */
8790 { VEX_W_TABLE (VEX_W_381C_P_2
) },
8793 /* VEX_LEN_381D_P_2 */
8795 { VEX_W_TABLE (VEX_W_381D_P_2
) },
8798 /* VEX_LEN_381E_P_2 */
8800 { VEX_W_TABLE (VEX_W_381E_P_2
) },
8803 /* VEX_LEN_3820_P_2 */
8805 { VEX_W_TABLE (VEX_W_3820_P_2
) },
8808 /* VEX_LEN_3821_P_2 */
8810 { VEX_W_TABLE (VEX_W_3821_P_2
) },
8813 /* VEX_LEN_3822_P_2 */
8815 { VEX_W_TABLE (VEX_W_3822_P_2
) },
8818 /* VEX_LEN_3823_P_2 */
8820 { VEX_W_TABLE (VEX_W_3823_P_2
) },
8823 /* VEX_LEN_3824_P_2 */
8825 { VEX_W_TABLE (VEX_W_3824_P_2
) },
8828 /* VEX_LEN_3825_P_2 */
8830 { VEX_W_TABLE (VEX_W_3825_P_2
) },
8833 /* VEX_LEN_3828_P_2 */
8835 { VEX_W_TABLE (VEX_W_3828_P_2
) },
8838 /* VEX_LEN_3829_P_2 */
8840 { VEX_W_TABLE (VEX_W_3829_P_2
) },
8843 /* VEX_LEN_382A_P_2_M_0 */
8845 { VEX_W_TABLE (VEX_W_382A_P_2_M_0
) },
8848 /* VEX_LEN_382B_P_2 */
8850 { VEX_W_TABLE (VEX_W_382B_P_2
) },
8853 /* VEX_LEN_3830_P_2 */
8855 { VEX_W_TABLE (VEX_W_3830_P_2
) },
8858 /* VEX_LEN_3831_P_2 */
8860 { VEX_W_TABLE (VEX_W_3831_P_2
) },
8863 /* VEX_LEN_3832_P_2 */
8865 { VEX_W_TABLE (VEX_W_3832_P_2
) },
8868 /* VEX_LEN_3833_P_2 */
8870 { VEX_W_TABLE (VEX_W_3833_P_2
) },
8873 /* VEX_LEN_3834_P_2 */
8875 { VEX_W_TABLE (VEX_W_3834_P_2
) },
8878 /* VEX_LEN_3835_P_2 */
8880 { VEX_W_TABLE (VEX_W_3835_P_2
) },
8883 /* VEX_LEN_3837_P_2 */
8885 { VEX_W_TABLE (VEX_W_3837_P_2
) },
8888 /* VEX_LEN_3838_P_2 */
8890 { VEX_W_TABLE (VEX_W_3838_P_2
) },
8893 /* VEX_LEN_3839_P_2 */
8895 { VEX_W_TABLE (VEX_W_3839_P_2
) },
8898 /* VEX_LEN_383A_P_2 */
8900 { VEX_W_TABLE (VEX_W_383A_P_2
) },
8903 /* VEX_LEN_383B_P_2 */
8905 { VEX_W_TABLE (VEX_W_383B_P_2
) },
8908 /* VEX_LEN_383C_P_2 */
8910 { VEX_W_TABLE (VEX_W_383C_P_2
) },
8913 /* VEX_LEN_383D_P_2 */
8915 { VEX_W_TABLE (VEX_W_383D_P_2
) },
8918 /* VEX_LEN_383E_P_2 */
8920 { VEX_W_TABLE (VEX_W_383E_P_2
) },
8923 /* VEX_LEN_383F_P_2 */
8925 { VEX_W_TABLE (VEX_W_383F_P_2
) },
8928 /* VEX_LEN_3840_P_2 */
8930 { VEX_W_TABLE (VEX_W_3840_P_2
) },
8933 /* VEX_LEN_3841_P_2 */
8935 { VEX_W_TABLE (VEX_W_3841_P_2
) },
8938 /* VEX_LEN_38DB_P_2 */
8940 { VEX_W_TABLE (VEX_W_38DB_P_2
) },
8943 /* VEX_LEN_38DC_P_2 */
8945 { VEX_W_TABLE (VEX_W_38DC_P_2
) },
8948 /* VEX_LEN_38DD_P_2 */
8950 { VEX_W_TABLE (VEX_W_38DD_P_2
) },
8953 /* VEX_LEN_38DE_P_2 */
8955 { VEX_W_TABLE (VEX_W_38DE_P_2
) },
8958 /* VEX_LEN_38DF_P_2 */
8960 { VEX_W_TABLE (VEX_W_38DF_P_2
) },
8963 /* VEX_LEN_3A06_P_2 */
8966 { VEX_W_TABLE (VEX_W_3A06_P_2
) },
8969 /* VEX_LEN_3A0A_P_2 */
8971 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
8972 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
8975 /* VEX_LEN_3A0B_P_2 */
8977 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
8978 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
8981 /* VEX_LEN_3A0E_P_2 */
8983 { VEX_W_TABLE (VEX_W_3A0E_P_2
) },
8986 /* VEX_LEN_3A0F_P_2 */
8988 { VEX_W_TABLE (VEX_W_3A0F_P_2
) },
8991 /* VEX_LEN_3A14_P_2 */
8993 { VEX_W_TABLE (VEX_W_3A14_P_2
) },
8996 /* VEX_LEN_3A15_P_2 */
8998 { VEX_W_TABLE (VEX_W_3A15_P_2
) },
9001 /* VEX_LEN_3A16_P_2 */
9003 { "vpextrK", { Edq
, XM
, Ib
} },
9006 /* VEX_LEN_3A17_P_2 */
9008 { "vextractps", { Edqd
, XM
, Ib
} },
9011 /* VEX_LEN_3A18_P_2 */
9014 { VEX_W_TABLE (VEX_W_3A18_P_2
) },
9017 /* VEX_LEN_3A19_P_2 */
9020 { VEX_W_TABLE (VEX_W_3A19_P_2
) },
9023 /* VEX_LEN_3A20_P_2 */
9025 { VEX_W_TABLE (VEX_W_3A20_P_2
) },
9028 /* VEX_LEN_3A21_P_2 */
9030 { VEX_W_TABLE (VEX_W_3A21_P_2
) },
9033 /* VEX_LEN_3A22_P_2 */
9035 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9038 /* VEX_LEN_3A41_P_2 */
9040 { VEX_W_TABLE (VEX_W_3A41_P_2
) },
9043 /* VEX_LEN_3A42_P_2 */
9045 { VEX_W_TABLE (VEX_W_3A42_P_2
) },
9048 /* VEX_LEN_3A44_P_2 */
9050 { VEX_W_TABLE (VEX_W_3A44_P_2
) },
9053 /* VEX_LEN_3A4C_P_2 */
9055 { VEX_W_TABLE (VEX_W_3A4C_P_2
) },
9058 /* VEX_LEN_3A60_P_2 */
9060 { VEX_W_TABLE (VEX_W_3A60_P_2
) },
9063 /* VEX_LEN_3A61_P_2 */
9065 { VEX_W_TABLE (VEX_W_3A61_P_2
) },
9068 /* VEX_LEN_3A62_P_2 */
9070 { VEX_W_TABLE (VEX_W_3A62_P_2
) },
9073 /* VEX_LEN_3A63_P_2 */
9075 { VEX_W_TABLE (VEX_W_3A63_P_2
) },
9078 /* VEX_LEN_3A6A_P_2 */
9080 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9083 /* VEX_LEN_3A6B_P_2 */
9085 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9088 /* VEX_LEN_3A6E_P_2 */
9090 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9093 /* VEX_LEN_3A6F_P_2 */
9095 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9098 /* VEX_LEN_3A7A_P_2 */
9100 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9103 /* VEX_LEN_3A7B_P_2 */
9105 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9108 /* VEX_LEN_3A7E_P_2 */
9110 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9113 /* VEX_LEN_3A7F_P_2 */
9115 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9118 /* VEX_LEN_3ADF_P_2 */
9120 { VEX_W_TABLE (VEX_W_3ADF_P_2
) },
9123 /* VEX_LEN_XOP_09_80 */
9125 { "vfrczps", { XM
, EXxmm
} },
9126 { "vfrczps", { XM
, EXymmq
} },
9129 /* VEX_LEN_XOP_09_81 */
9131 { "vfrczpd", { XM
, EXxmm
} },
9132 { "vfrczpd", { XM
, EXymmq
} },
9136 static const struct dis386 vex_w_table
[][2] = {
9139 { "vmovups", { XM
, EXx
} },
9143 { "vmovss", { XMVexScalar
, VexScalar
, EXdScalar
} },
9147 { "vmovupd", { XM
, EXx
} },
9151 { "vmovsd", { XMVexScalar
, VexScalar
, EXqScalar
} },
9155 { "vmovups", { EXxS
, XM
} },
9159 { "vmovss", { EXdVexScalarS
, VexScalar
, XMScalar
} },
9163 { "vmovupd", { EXxS
, XM
} },
9167 { "vmovsd", { EXqVexScalarS
, VexScalar
, XMScalar
} },
9170 /* VEX_W_12_P_0_M_0 */
9171 { "vmovlps", { XM
, Vex128
, EXq
} },
9174 /* VEX_W_12_P_0_M_1 */
9175 { "vmovhlps", { XM
, Vex128
, EXq
} },
9179 { "vmovsldup", { XM
, EXx
} },
9183 { "vmovlpd", { XM
, Vex128
, EXq
} },
9187 { "vmovddup", { XM
, EXymmq
} },
9191 { "vmovlpX", { EXq
, XM
} },
9195 { "vunpcklpX", { XM
, Vex
, EXx
} },
9199 { "vunpckhpX", { XM
, Vex
, EXx
} },
9202 /* VEX_W_16_P_0_M_0 */
9203 { "vmovhps", { XM
, Vex128
, EXq
} },
9206 /* VEX_W_16_P_0_M_1 */
9207 { "vmovlhps", { XM
, Vex128
, EXq
} },
9211 { "vmovshdup", { XM
, EXx
} },
9215 { "vmovhpd", { XM
, Vex128
, EXq
} },
9219 { "vmovhpX", { EXq
, XM
} },
9223 { "vmovapX", { XM
, EXx
} },
9227 { "vmovapX", { EXxS
, XM
} },
9231 { "vmovntpX", { Mx
, XM
} },
9235 { "vucomiss", { XMScalar
, EXdScalar
} },
9239 { "vucomisd", { XMScalar
, EXqScalar
} },
9243 { "vcomiss", { XMScalar
, EXdScalar
} },
9247 { "vcomisd", { XMScalar
, EXqScalar
} },
9251 { "vmovmskpX", { Gdq
, XS
} },
9255 { "vsqrtps", { XM
, EXx
} },
9259 { "vsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9263 { "vsqrtpd", { XM
, EXx
} },
9267 { "vsqrtsd", { XMScalar
, VexScalar
, EXqScalar
} },
9271 { "vrsqrtps", { XM
, EXx
} },
9275 { "vrsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9279 { "vrcpps", { XM
, EXx
} },
9283 { "vrcpss", { XMScalar
, VexScalar
, EXdScalar
} },
9287 { "vaddps", { XM
, Vex
, EXx
} },
9291 { "vaddss", { XMScalar
, VexScalar
, EXdScalar
} },
9295 { "vaddpd", { XM
, Vex
, EXx
} },
9299 { "vaddsd", { XMScalar
, VexScalar
, EXqScalar
} },
9303 { "vmulps", { XM
, Vex
, EXx
} },
9307 { "vmulss", { XMScalar
, VexScalar
, EXdScalar
} },
9311 { "vmulpd", { XM
, Vex
, EXx
} },
9315 { "vmulsd", { XMScalar
, VexScalar
, EXqScalar
} },
9319 { "vcvtps2pd", { XM
, EXxmmq
} },
9323 { "vcvtss2sd", { XMScalar
, VexScalar
, EXdScalar
} },
9327 { "vcvtsd2ss", { XMScalar
, VexScalar
, EXqScalar
} },
9331 { "vcvtdq2ps", { XM
, EXx
} },
9335 { "vcvttps2dq", { XM
, EXx
} },
9339 { "vcvtps2dq", { XM
, EXx
} },
9343 { "vsubps", { XM
, Vex
, EXx
} },
9347 { "vsubss", { XMScalar
, VexScalar
, EXdScalar
} },
9351 { "vsubpd", { XM
, Vex
, EXx
} },
9355 { "vsubsd", { XMScalar
, VexScalar
, EXqScalar
} },
9359 { "vminps", { XM
, Vex
, EXx
} },
9363 { "vminss", { XMScalar
, VexScalar
, EXdScalar
} },
9367 { "vminpd", { XM
, Vex
, EXx
} },
9371 { "vminsd", { XMScalar
, VexScalar
, EXqScalar
} },
9375 { "vdivps", { XM
, Vex
, EXx
} },
9379 { "vdivss", { XMScalar
, VexScalar
, EXdScalar
} },
9383 { "vdivpd", { XM
, Vex
, EXx
} },
9387 { "vdivsd", { XMScalar
, VexScalar
, EXqScalar
} },
9391 { "vmaxps", { XM
, Vex
, EXx
} },
9395 { "vmaxss", { XMScalar
, VexScalar
, EXdScalar
} },
9399 { "vmaxpd", { XM
, Vex
, EXx
} },
9403 { "vmaxsd", { XMScalar
, VexScalar
, EXqScalar
} },
9407 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
9411 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
9415 { "vpunpckldq", { XM
, Vex128
, EXx
} },
9419 { "vpacksswb", { XM
, Vex128
, EXx
} },
9423 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
9427 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
9431 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
9435 { "vpackuswb", { XM
, Vex128
, EXx
} },
9439 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
9443 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
9447 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
9451 { "vpackssdw", { XM
, Vex128
, EXx
} },
9455 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
9459 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
9463 { "vmovdqu", { XM
, EXx
} },
9467 { "vmovdqa", { XM
, EXx
} },
9471 { "vpshufhw", { XM
, EXx
, Ib
} },
9475 { "vpshufd", { XM
, EXx
, Ib
} },
9479 { "vpshuflw", { XM
, EXx
, Ib
} },
9482 /* VEX_W_71_R_2_P_2 */
9483 { "vpsrlw", { Vex128
, XS
, Ib
} },
9486 /* VEX_W_71_R_4_P_2 */
9487 { "vpsraw", { Vex128
, XS
, Ib
} },
9490 /* VEX_W_71_R_6_P_2 */
9491 { "vpsllw", { Vex128
, XS
, Ib
} },
9494 /* VEX_W_72_R_2_P_2 */
9495 { "vpsrld", { Vex128
, XS
, Ib
} },
9498 /* VEX_W_72_R_4_P_2 */
9499 { "vpsrad", { Vex128
, XS
, Ib
} },
9502 /* VEX_W_72_R_6_P_2 */
9503 { "vpslld", { Vex128
, XS
, Ib
} },
9506 /* VEX_W_73_R_2_P_2 */
9507 { "vpsrlq", { Vex128
, XS
, Ib
} },
9510 /* VEX_W_73_R_3_P_2 */
9511 { "vpsrldq", { Vex128
, XS
, Ib
} },
9514 /* VEX_W_73_R_6_P_2 */
9515 { "vpsllq", { Vex128
, XS
, Ib
} },
9518 /* VEX_W_73_R_7_P_2 */
9519 { "vpslldq", { Vex128
, XS
, Ib
} },
9523 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
9527 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
9531 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
9539 { "vhaddpd", { XM
, Vex
, EXx
} },
9543 { "vhaddps", { XM
, Vex
, EXx
} },
9547 { "vhsubpd", { XM
, Vex
, EXx
} },
9551 { "vhsubps", { XM
, Vex
, EXx
} },
9555 { "vmovq", { XMScalar
, EXqScalar
} },
9559 { "vmovdqu", { EXxS
, XM
} },
9563 { "vmovdqa", { EXxS
, XM
} },
9566 /* VEX_W_AE_R_2_M_0 */
9567 { "vldmxcsr", { Md
} },
9570 /* VEX_W_AE_R_3_M_0 */
9571 { "vstmxcsr", { Md
} },
9575 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
9579 { "vcmpss", { XMScalar
, VexScalar
, EXdScalar
, VCMP
} },
9583 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
9587 { "vcmpsd", { XMScalar
, VexScalar
, EXqScalar
, VCMP
} },
9591 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
9595 { "vpextrw", { Gdq
, XS
, Ib
} },
9599 { "vaddsubpd", { XM
, Vex
, EXx
} },
9603 { "vaddsubps", { XM
, Vex
, EXx
} },
9607 { "vpsrlw", { XM
, Vex128
, EXx
} },
9611 { "vpsrld", { XM
, Vex128
, EXx
} },
9615 { "vpsrlq", { XM
, Vex128
, EXx
} },
9619 { "vpaddq", { XM
, Vex128
, EXx
} },
9623 { "vpmullw", { XM
, Vex128
, EXx
} },
9627 { "vmovq", { EXqScalarS
, XMScalar
} },
9630 /* VEX_W_D7_P_2_M_1 */
9631 { "vpmovmskb", { Gdq
, XS
} },
9635 { "vpsubusb", { XM
, Vex128
, EXx
} },
9639 { "vpsubusw", { XM
, Vex128
, EXx
} },
9643 { "vpminub", { XM
, Vex128
, EXx
} },
9647 { "vpand", { XM
, Vex128
, EXx
} },
9651 { "vpaddusb", { XM
, Vex128
, EXx
} },
9655 { "vpaddusw", { XM
, Vex128
, EXx
} },
9659 { "vpmaxub", { XM
, Vex128
, EXx
} },
9663 { "vpandn", { XM
, Vex128
, EXx
} },
9667 { "vpavgb", { XM
, Vex128
, EXx
} },
9671 { "vpsraw", { XM
, Vex128
, EXx
} },
9675 { "vpsrad", { XM
, Vex128
, EXx
} },
9679 { "vpavgw", { XM
, Vex128
, EXx
} },
9683 { "vpmulhuw", { XM
, Vex128
, EXx
} },
9687 { "vpmulhw", { XM
, Vex128
, EXx
} },
9691 { "vcvtdq2pd", { XM
, EXxmmq
} },
9695 { "vcvttpd2dq%XY", { XMM
, EXx
} },
9699 { "vcvtpd2dq%XY", { XMM
, EXx
} },
9702 /* VEX_W_E7_P_2_M_0 */
9703 { "vmovntdq", { Mx
, XM
} },
9707 { "vpsubsb", { XM
, Vex128
, EXx
} },
9711 { "vpsubsw", { XM
, Vex128
, EXx
} },
9715 { "vpminsw", { XM
, Vex128
, EXx
} },
9719 { "vpor", { XM
, Vex128
, EXx
} },
9723 { "vpaddsb", { XM
, Vex128
, EXx
} },
9727 { "vpaddsw", { XM
, Vex128
, EXx
} },
9731 { "vpmaxsw", { XM
, Vex128
, EXx
} },
9735 { "vpxor", { XM
, Vex128
, EXx
} },
9738 /* VEX_W_F0_P_3_M_0 */
9739 { "vlddqu", { XM
, M
} },
9743 { "vpsllw", { XM
, Vex128
, EXx
} },
9747 { "vpslld", { XM
, Vex128
, EXx
} },
9751 { "vpsllq", { XM
, Vex128
, EXx
} },
9755 { "vpmuludq", { XM
, Vex128
, EXx
} },
9759 { "vpmaddwd", { XM
, Vex128
, EXx
} },
9763 { "vpsadbw", { XM
, Vex128
, EXx
} },
9767 { "vmaskmovdqu", { XM
, XS
} },
9771 { "vpsubb", { XM
, Vex128
, EXx
} },
9775 { "vpsubw", { XM
, Vex128
, EXx
} },
9779 { "vpsubd", { XM
, Vex128
, EXx
} },
9783 { "vpsubq", { XM
, Vex128
, EXx
} },
9787 { "vpaddb", { XM
, Vex128
, EXx
} },
9791 { "vpaddw", { XM
, Vex128
, EXx
} },
9795 { "vpaddd", { XM
, Vex128
, EXx
} },
9798 /* VEX_W_3800_P_2 */
9799 { "vpshufb", { XM
, Vex128
, EXx
} },
9802 /* VEX_W_3801_P_2 */
9803 { "vphaddw", { XM
, Vex128
, EXx
} },
9806 /* VEX_W_3802_P_2 */
9807 { "vphaddd", { XM
, Vex128
, EXx
} },
9810 /* VEX_W_3803_P_2 */
9811 { "vphaddsw", { XM
, Vex128
, EXx
} },
9814 /* VEX_W_3804_P_2 */
9815 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
9818 /* VEX_W_3805_P_2 */
9819 { "vphsubw", { XM
, Vex128
, EXx
} },
9822 /* VEX_W_3806_P_2 */
9823 { "vphsubd", { XM
, Vex128
, EXx
} },
9826 /* VEX_W_3807_P_2 */
9827 { "vphsubsw", { XM
, Vex128
, EXx
} },
9830 /* VEX_W_3808_P_2 */
9831 { "vpsignb", { XM
, Vex128
, EXx
} },
9834 /* VEX_W_3809_P_2 */
9835 { "vpsignw", { XM
, Vex128
, EXx
} },
9838 /* VEX_W_380A_P_2 */
9839 { "vpsignd", { XM
, Vex128
, EXx
} },
9842 /* VEX_W_380B_P_2 */
9843 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
9846 /* VEX_W_380C_P_2 */
9847 { "vpermilps", { XM
, Vex
, EXx
} },
9850 /* VEX_W_380D_P_2 */
9851 { "vpermilpd", { XM
, Vex
, EXx
} },
9854 /* VEX_W_380E_P_2 */
9855 { "vtestps", { XM
, EXx
} },
9858 /* VEX_W_380F_P_2 */
9859 { "vtestpd", { XM
, EXx
} },
9862 /* VEX_W_3817_P_2 */
9863 { "vptest", { XM
, EXx
} },
9866 /* VEX_W_3818_P_2_M_0 */
9867 { "vbroadcastss", { XM
, Md
} },
9870 /* VEX_W_3819_P_2_M_0 */
9871 { "vbroadcastsd", { XM
, Mq
} },
9874 /* VEX_W_381A_P_2_M_0 */
9875 { "vbroadcastf128", { XM
, Mxmm
} },
9878 /* VEX_W_381C_P_2 */
9879 { "vpabsb", { XM
, EXx
} },
9882 /* VEX_W_381D_P_2 */
9883 { "vpabsw", { XM
, EXx
} },
9886 /* VEX_W_381E_P_2 */
9887 { "vpabsd", { XM
, EXx
} },
9890 /* VEX_W_3820_P_2 */
9891 { "vpmovsxbw", { XM
, EXq
} },
9894 /* VEX_W_3821_P_2 */
9895 { "vpmovsxbd", { XM
, EXd
} },
9898 /* VEX_W_3822_P_2 */
9899 { "vpmovsxbq", { XM
, EXw
} },
9902 /* VEX_W_3823_P_2 */
9903 { "vpmovsxwd", { XM
, EXq
} },
9906 /* VEX_W_3824_P_2 */
9907 { "vpmovsxwq", { XM
, EXd
} },
9910 /* VEX_W_3825_P_2 */
9911 { "vpmovsxdq", { XM
, EXq
} },
9914 /* VEX_W_3828_P_2 */
9915 { "vpmuldq", { XM
, Vex128
, EXx
} },
9918 /* VEX_W_3829_P_2 */
9919 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
9922 /* VEX_W_382A_P_2_M_0 */
9923 { "vmovntdqa", { XM
, Mx
} },
9926 /* VEX_W_382B_P_2 */
9927 { "vpackusdw", { XM
, Vex128
, EXx
} },
9930 /* VEX_W_382C_P_2_M_0 */
9931 { "vmaskmovps", { XM
, Vex
, Mx
} },
9934 /* VEX_W_382D_P_2_M_0 */
9935 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9938 /* VEX_W_382E_P_2_M_0 */
9939 { "vmaskmovps", { Mx
, Vex
, XM
} },
9942 /* VEX_W_382F_P_2_M_0 */
9943 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9946 /* VEX_W_3830_P_2 */
9947 { "vpmovzxbw", { XM
, EXq
} },
9950 /* VEX_W_3831_P_2 */
9951 { "vpmovzxbd", { XM
, EXd
} },
9954 /* VEX_W_3832_P_2 */
9955 { "vpmovzxbq", { XM
, EXw
} },
9958 /* VEX_W_3833_P_2 */
9959 { "vpmovzxwd", { XM
, EXq
} },
9962 /* VEX_W_3834_P_2 */
9963 { "vpmovzxwq", { XM
, EXd
} },
9966 /* VEX_W_3835_P_2 */
9967 { "vpmovzxdq", { XM
, EXq
} },
9970 /* VEX_W_3837_P_2 */
9971 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
9974 /* VEX_W_3838_P_2 */
9975 { "vpminsb", { XM
, Vex128
, EXx
} },
9978 /* VEX_W_3839_P_2 */
9979 { "vpminsd", { XM
, Vex128
, EXx
} },
9982 /* VEX_W_383A_P_2 */
9983 { "vpminuw", { XM
, Vex128
, EXx
} },
9986 /* VEX_W_383B_P_2 */
9987 { "vpminud", { XM
, Vex128
, EXx
} },
9990 /* VEX_W_383C_P_2 */
9991 { "vpmaxsb", { XM
, Vex128
, EXx
} },
9994 /* VEX_W_383D_P_2 */
9995 { "vpmaxsd", { XM
, Vex128
, EXx
} },
9998 /* VEX_W_383E_P_2 */
9999 { "vpmaxuw", { XM
, Vex128
, EXx
} },
10002 /* VEX_W_383F_P_2 */
10003 { "vpmaxud", { XM
, Vex128
, EXx
} },
10006 /* VEX_W_3840_P_2 */
10007 { "vpmulld", { XM
, Vex128
, EXx
} },
10010 /* VEX_W_3841_P_2 */
10011 { "vphminposuw", { XM
, EXx
} },
10014 /* VEX_W_38DB_P_2 */
10015 { "vaesimc", { XM
, EXx
} },
10018 /* VEX_W_38DC_P_2 */
10019 { "vaesenc", { XM
, Vex128
, EXx
} },
10022 /* VEX_W_38DD_P_2 */
10023 { "vaesenclast", { XM
, Vex128
, EXx
} },
10026 /* VEX_W_38DE_P_2 */
10027 { "vaesdec", { XM
, Vex128
, EXx
} },
10030 /* VEX_W_38DF_P_2 */
10031 { "vaesdeclast", { XM
, Vex128
, EXx
} },
10034 /* VEX_W_3A04_P_2 */
10035 { "vpermilps", { XM
, EXx
, Ib
} },
10038 /* VEX_W_3A05_P_2 */
10039 { "vpermilpd", { XM
, EXx
, Ib
} },
10042 /* VEX_W_3A06_P_2 */
10043 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
10046 /* VEX_W_3A08_P_2 */
10047 { "vroundps", { XM
, EXx
, Ib
} },
10050 /* VEX_W_3A09_P_2 */
10051 { "vroundpd", { XM
, EXx
, Ib
} },
10054 /* VEX_W_3A0A_P_2 */
10055 { "vroundss", { XMScalar
, VexScalar
, EXdScalar
, Ib
} },
10058 /* VEX_W_3A0B_P_2 */
10059 { "vroundsd", { XMScalar
, VexScalar
, EXqScalar
, Ib
} },
10062 /* VEX_W_3A0C_P_2 */
10063 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
10066 /* VEX_W_3A0D_P_2 */
10067 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
10070 /* VEX_W_3A0E_P_2 */
10071 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
10074 /* VEX_W_3A0F_P_2 */
10075 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
10078 /* VEX_W_3A14_P_2 */
10079 { "vpextrb", { Edqb
, XM
, Ib
} },
10082 /* VEX_W_3A15_P_2 */
10083 { "vpextrw", { Edqw
, XM
, Ib
} },
10086 /* VEX_W_3A18_P_2 */
10087 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
10090 /* VEX_W_3A19_P_2 */
10091 { "vextractf128", { EXxmm
, XM
, Ib
} },
10094 /* VEX_W_3A20_P_2 */
10095 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
10098 /* VEX_W_3A21_P_2 */
10099 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
10102 /* VEX_W_3A40_P_2 */
10103 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
10106 /* VEX_W_3A41_P_2 */
10107 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
10110 /* VEX_W_3A42_P_2 */
10111 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
10114 /* VEX_W_3A44_P_2 */
10115 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
10118 /* VEX_W_3A4A_P_2 */
10119 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
10122 /* VEX_W_3A4B_P_2 */
10123 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
10126 /* VEX_W_3A4C_P_2 */
10127 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
10130 /* VEX_W_3A60_P_2 */
10131 { "vpcmpestrm", { XM
, EXx
, Ib
} },
10134 /* VEX_W_3A61_P_2 */
10135 { "vpcmpestri", { XM
, EXx
, Ib
} },
10138 /* VEX_W_3A62_P_2 */
10139 { "vpcmpistrm", { XM
, EXx
, Ib
} },
10142 /* VEX_W_3A63_P_2 */
10143 { "vpcmpistri", { XM
, EXx
, Ib
} },
10146 /* VEX_W_3ADF_P_2 */
10147 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
10151 static const struct dis386 mod_table
[][2] = {
10154 { "leaS", { Gv
, M
} },
10157 /* MOD_0F01_REG_0 */
10158 { X86_64_TABLE (X86_64_0F01_REG_0
) },
10159 { RM_TABLE (RM_0F01_REG_0
) },
10162 /* MOD_0F01_REG_1 */
10163 { X86_64_TABLE (X86_64_0F01_REG_1
) },
10164 { RM_TABLE (RM_0F01_REG_1
) },
10167 /* MOD_0F01_REG_2 */
10168 { X86_64_TABLE (X86_64_0F01_REG_2
) },
10169 { RM_TABLE (RM_0F01_REG_2
) },
10172 /* MOD_0F01_REG_3 */
10173 { X86_64_TABLE (X86_64_0F01_REG_3
) },
10174 { RM_TABLE (RM_0F01_REG_3
) },
10177 /* MOD_0F01_REG_7 */
10178 { "invlpg", { Mb
} },
10179 { RM_TABLE (RM_0F01_REG_7
) },
10182 /* MOD_0F12_PREFIX_0 */
10183 { "movlps", { XM
, EXq
} },
10184 { "movhlps", { XM
, EXq
} },
10188 { "movlpX", { EXq
, XM
} },
10191 /* MOD_0F16_PREFIX_0 */
10192 { "movhps", { XM
, EXq
} },
10193 { "movlhps", { XM
, EXq
} },
10197 { "movhpX", { EXq
, XM
} },
10200 /* MOD_0F18_REG_0 */
10201 { "prefetchnta", { Mb
} },
10204 /* MOD_0F18_REG_1 */
10205 { "prefetcht0", { Mb
} },
10208 /* MOD_0F18_REG_2 */
10209 { "prefetcht1", { Mb
} },
10212 /* MOD_0F18_REG_3 */
10213 { "prefetcht2", { Mb
} },
10218 { "movZ", { Rm
, Cm
} },
10223 { "movZ", { Rm
, Dm
} },
10228 { "movZ", { Cm
, Rm
} },
10233 { "movZ", { Dm
, Rm
} },
10238 { "movL", { Rd
, Td
} },
10243 { "movL", { Td
, Rd
} },
10246 /* MOD_0F2B_PREFIX_0 */
10247 {"movntps", { Mx
, XM
} },
10250 /* MOD_0F2B_PREFIX_1 */
10251 {"movntss", { Md
, XM
} },
10254 /* MOD_0F2B_PREFIX_2 */
10255 {"movntpd", { Mx
, XM
} },
10258 /* MOD_0F2B_PREFIX_3 */
10259 {"movntsd", { Mq
, XM
} },
10264 { "movmskpX", { Gdq
, XS
} },
10267 /* MOD_0F71_REG_2 */
10269 { "psrlw", { MS
, Ib
} },
10272 /* MOD_0F71_REG_4 */
10274 { "psraw", { MS
, Ib
} },
10277 /* MOD_0F71_REG_6 */
10279 { "psllw", { MS
, Ib
} },
10282 /* MOD_0F72_REG_2 */
10284 { "psrld", { MS
, Ib
} },
10287 /* MOD_0F72_REG_4 */
10289 { "psrad", { MS
, Ib
} },
10292 /* MOD_0F72_REG_6 */
10294 { "pslld", { MS
, Ib
} },
10297 /* MOD_0F73_REG_2 */
10299 { "psrlq", { MS
, Ib
} },
10302 /* MOD_0F73_REG_3 */
10304 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
10307 /* MOD_0F73_REG_6 */
10309 { "psllq", { MS
, Ib
} },
10312 /* MOD_0F73_REG_7 */
10314 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
10317 /* MOD_0FAE_REG_0 */
10318 { "fxsave", { FXSAVE
} },
10321 /* MOD_0FAE_REG_1 */
10322 { "fxrstor", { FXSAVE
} },
10325 /* MOD_0FAE_REG_2 */
10326 { "ldmxcsr", { Md
} },
10329 /* MOD_0FAE_REG_3 */
10330 { "stmxcsr", { Md
} },
10333 /* MOD_0FAE_REG_4 */
10334 { "xsave", { FXSAVE
} },
10337 /* MOD_0FAE_REG_5 */
10338 { "xrstor", { FXSAVE
} },
10339 { RM_TABLE (RM_0FAE_REG_5
) },
10342 /* MOD_0FAE_REG_6 */
10344 { RM_TABLE (RM_0FAE_REG_6
) },
10347 /* MOD_0FAE_REG_7 */
10348 { "clflush", { Mb
} },
10349 { RM_TABLE (RM_0FAE_REG_7
) },
10353 { "lssS", { Gv
, Mp
} },
10357 { "lfsS", { Gv
, Mp
} },
10361 { "lgsS", { Gv
, Mp
} },
10364 /* MOD_0FC7_REG_6 */
10365 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
10368 /* MOD_0FC7_REG_7 */
10369 { "vmptrst", { Mq
} },
10374 { "pmovmskb", { Gdq
, MS
} },
10377 /* MOD_0FE7_PREFIX_2 */
10378 { "movntdq", { Mx
, XM
} },
10381 /* MOD_0FF0_PREFIX_3 */
10382 { "lddqu", { XM
, M
} },
10385 /* MOD_0F382A_PREFIX_2 */
10386 { "movntdqa", { XM
, Mx
} },
10390 { "bound{S|}", { Gv
, Ma
} },
10394 { "lesS", { Gv
, Mp
} },
10395 { VEX_C4_TABLE (VEX_0F
) },
10399 { "ldsS", { Gv
, Mp
} },
10400 { VEX_C5_TABLE (VEX_0F
) },
10403 /* MOD_VEX_12_PREFIX_0 */
10404 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
10405 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
10409 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
10412 /* MOD_VEX_16_PREFIX_0 */
10413 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
10414 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
10418 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
10422 { VEX_W_TABLE (VEX_W_2B_M_0
) },
10427 { VEX_W_TABLE (VEX_W_50_M_0
) },
10430 /* MOD_VEX_71_REG_2 */
10432 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
10435 /* MOD_VEX_71_REG_4 */
10437 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
10440 /* MOD_VEX_71_REG_6 */
10442 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
10445 /* MOD_VEX_72_REG_2 */
10447 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
10450 /* MOD_VEX_72_REG_4 */
10452 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
10455 /* MOD_VEX_72_REG_6 */
10457 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
10460 /* MOD_VEX_73_REG_2 */
10462 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
10465 /* MOD_VEX_73_REG_3 */
10467 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
10470 /* MOD_VEX_73_REG_6 */
10472 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
10475 /* MOD_VEX_73_REG_7 */
10477 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
10480 /* MOD_VEX_AE_REG_2 */
10481 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
10484 /* MOD_VEX_AE_REG_3 */
10485 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
10488 /* MOD_VEX_D7_PREFIX_2 */
10490 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
10493 /* MOD_VEX_E7_PREFIX_2 */
10494 { VEX_W_TABLE (VEX_W_E7_P_2_M_0
) },
10497 /* MOD_VEX_F0_PREFIX_3 */
10498 { VEX_W_TABLE (VEX_W_F0_P_3_M_0
) },
10501 /* MOD_VEX_3818_PREFIX_2 */
10502 { VEX_W_TABLE (VEX_W_3818_P_2_M_0
) },
10505 /* MOD_VEX_3819_PREFIX_2 */
10506 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
10509 /* MOD_VEX_381A_PREFIX_2 */
10510 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
10513 /* MOD_VEX_382A_PREFIX_2 */
10514 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
10517 /* MOD_VEX_382C_PREFIX_2 */
10518 { VEX_W_TABLE (VEX_W_382C_P_2_M_0
) },
10521 /* MOD_VEX_382D_PREFIX_2 */
10522 { VEX_W_TABLE (VEX_W_382D_P_2_M_0
) },
10525 /* MOD_VEX_382E_PREFIX_2 */
10526 { VEX_W_TABLE (VEX_W_382E_P_2_M_0
) },
10529 /* MOD_VEX_382F_PREFIX_2 */
10530 { VEX_W_TABLE (VEX_W_382F_P_2_M_0
) },
10534 static const struct dis386 rm_table
[][8] = {
10536 /* RM_0F01_REG_0 */
10538 { "vmcall", { Skip_MODRM
} },
10539 { "vmlaunch", { Skip_MODRM
} },
10540 { "vmresume", { Skip_MODRM
} },
10541 { "vmxoff", { Skip_MODRM
} },
10544 /* RM_0F01_REG_1 */
10545 { "monitor", { { OP_Monitor
, 0 } } },
10546 { "mwait", { { OP_Mwait
, 0 } } },
10549 /* RM_0F01_REG_2 */
10550 { "xgetbv", { Skip_MODRM
} },
10551 { "xsetbv", { Skip_MODRM
} },
10554 /* RM_0F01_REG_3 */
10555 { "vmrun", { Skip_MODRM
} },
10556 { "vmmcall", { Skip_MODRM
} },
10557 { "vmload", { Skip_MODRM
} },
10558 { "vmsave", { Skip_MODRM
} },
10559 { "stgi", { Skip_MODRM
} },
10560 { "clgi", { Skip_MODRM
} },
10561 { "skinit", { Skip_MODRM
} },
10562 { "invlpga", { Skip_MODRM
} },
10565 /* RM_0F01_REG_7 */
10566 { "swapgs", { Skip_MODRM
} },
10567 { "rdtscp", { Skip_MODRM
} },
10570 /* RM_0FAE_REG_5 */
10571 { "lfence", { Skip_MODRM
} },
10574 /* RM_0FAE_REG_6 */
10575 { "mfence", { Skip_MODRM
} },
10578 /* RM_0FAE_REG_7 */
10579 { "sfence", { Skip_MODRM
} },
10583 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
10585 /* We use the high bit to indicate different name for the same
10587 #define ADDR16_PREFIX (0x67 | 0x100)
10588 #define ADDR32_PREFIX (0x67 | 0x200)
10589 #define DATA16_PREFIX (0x66 | 0x100)
10590 #define DATA32_PREFIX (0x66 | 0x200)
10591 #define REP_PREFIX (0xf3 | 0x100)
10596 int newrex
, i
, length
;
10602 last_lock_prefix
= -1;
10603 last_repz_prefix
= -1;
10604 last_repnz_prefix
= -1;
10605 last_data_prefix
= -1;
10606 last_addr_prefix
= -1;
10607 last_rex_prefix
= -1;
10608 last_seg_prefix
= -1;
10609 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10610 all_prefixes
[i
] = 0;
10613 /* The maximum instruction length is 15bytes. */
10614 while (length
< MAX_CODE_LENGTH
- 1)
10616 FETCH_DATA (the_info
, codep
+ 1);
10620 /* REX prefixes family. */
10637 if (address_mode
== mode_64bit
)
10641 last_rex_prefix
= i
;
10644 prefixes
|= PREFIX_REPZ
;
10645 last_repz_prefix
= i
;
10648 prefixes
|= PREFIX_REPNZ
;
10649 last_repnz_prefix
= i
;
10652 prefixes
|= PREFIX_LOCK
;
10653 last_lock_prefix
= i
;
10656 prefixes
|= PREFIX_CS
;
10657 last_seg_prefix
= i
;
10660 prefixes
|= PREFIX_SS
;
10661 last_seg_prefix
= i
;
10664 prefixes
|= PREFIX_DS
;
10665 last_seg_prefix
= i
;
10668 prefixes
|= PREFIX_ES
;
10669 last_seg_prefix
= i
;
10672 prefixes
|= PREFIX_FS
;
10673 last_seg_prefix
= i
;
10676 prefixes
|= PREFIX_GS
;
10677 last_seg_prefix
= i
;
10680 prefixes
|= PREFIX_DATA
;
10681 last_data_prefix
= i
;
10684 prefixes
|= PREFIX_ADDR
;
10685 last_addr_prefix
= i
;
10688 /* fwait is really an instruction. If there are prefixes
10689 before the fwait, they belong to the fwait, *not* to the
10690 following instruction. */
10691 if (prefixes
|| rex
)
10693 prefixes
|= PREFIX_FWAIT
;
10697 prefixes
= PREFIX_FWAIT
;
10702 /* Rex is ignored when followed by another prefix. */
10708 if (*codep
!= FWAIT_OPCODE
)
10709 all_prefixes
[i
++] = *codep
;
10718 seg_prefix (int pref
)
10739 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10742 static const char *
10743 prefix_name (int pref
, int sizeflag
)
10745 static const char *rexes
[16] =
10748 "rex.B", /* 0x41 */
10749 "rex.X", /* 0x42 */
10750 "rex.XB", /* 0x43 */
10751 "rex.R", /* 0x44 */
10752 "rex.RB", /* 0x45 */
10753 "rex.RX", /* 0x46 */
10754 "rex.RXB", /* 0x47 */
10755 "rex.W", /* 0x48 */
10756 "rex.WB", /* 0x49 */
10757 "rex.WX", /* 0x4a */
10758 "rex.WXB", /* 0x4b */
10759 "rex.WR", /* 0x4c */
10760 "rex.WRB", /* 0x4d */
10761 "rex.WRX", /* 0x4e */
10762 "rex.WRXB", /* 0x4f */
10767 /* REX prefixes family. */
10784 return rexes
[pref
- 0x40];
10804 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10806 if (address_mode
== mode_64bit
)
10807 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10809 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10812 case ADDR16_PREFIX
:
10814 case ADDR32_PREFIX
:
10816 case DATA16_PREFIX
:
10818 case DATA32_PREFIX
:
10827 static char op_out
[MAX_OPERANDS
][100];
10828 static int op_ad
, op_index
[MAX_OPERANDS
];
10829 static int two_source_ops
;
10830 static bfd_vma op_address
[MAX_OPERANDS
];
10831 static bfd_vma op_riprel
[MAX_OPERANDS
];
10832 static bfd_vma start_pc
;
10835 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10836 * (see topic "Redundant prefixes" in the "Differences from 8086"
10837 * section of the "Virtual 8086 Mode" chapter.)
10838 * 'pc' should be the address of this instruction, it will
10839 * be used to print the target address if this is a relative jump or call
10840 * The function returns the length of this instruction in bytes.
10843 static char intel_syntax
;
10844 static char intel_mnemonic
= !SYSV386_COMPAT
;
10845 static char open_char
;
10846 static char close_char
;
10847 static char separator_char
;
10848 static char scale_char
;
10850 /* Here for backwards compatibility. When gdb stops using
10851 print_insn_i386_att and print_insn_i386_intel these functions can
10852 disappear, and print_insn_i386 be merged into print_insn. */
10854 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10858 return print_insn (pc
, info
);
10862 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10866 return print_insn (pc
, info
);
10870 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10874 return print_insn (pc
, info
);
10878 print_i386_disassembler_options (FILE *stream
)
10880 fprintf (stream
, _("\n\
10881 The following i386/x86-64 specific disassembler options are supported for use\n\
10882 with the -M switch (multiple options should be separated by commas):\n"));
10884 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10885 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10886 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10887 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10888 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10889 fprintf (stream
, _(" att-mnemonic\n"
10890 " Display instruction in AT&T mnemonic\n"));
10891 fprintf (stream
, _(" intel-mnemonic\n"
10892 " Display instruction in Intel mnemonic\n"));
10893 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10894 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10895 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10896 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10897 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10898 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10902 static const struct dis386 bad_opcode
= { "(bad)", { XX
} };
10904 /* Get a pointer to struct dis386 with a valid name. */
10906 static const struct dis386
*
10907 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10909 int vindex
, vex_table_index
;
10911 if (dp
->name
!= NULL
)
10914 switch (dp
->op
[0].bytemode
)
10916 case USE_REG_TABLE
:
10917 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10920 case USE_MOD_TABLE
:
10921 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
10922 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
10926 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10929 case USE_PREFIX_TABLE
:
10932 /* The prefix in VEX is implicit. */
10933 switch (vex
.prefix
)
10938 case REPE_PREFIX_OPCODE
:
10941 case DATA_PREFIX_OPCODE
:
10944 case REPNE_PREFIX_OPCODE
:
10955 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10956 if (prefixes
& PREFIX_REPZ
)
10959 all_prefixes
[last_repz_prefix
] = 0;
10963 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10965 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10966 if (prefixes
& PREFIX_REPNZ
)
10969 all_prefixes
[last_repnz_prefix
] = 0;
10973 used_prefixes
|= (prefixes
& PREFIX_DATA
);
10974 if (prefixes
& PREFIX_DATA
)
10977 all_prefixes
[last_data_prefix
] = 0;
10982 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
10985 case USE_X86_64_TABLE
:
10986 vindex
= address_mode
== mode_64bit
? 1 : 0;
10987 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
10990 case USE_3BYTE_TABLE
:
10991 FETCH_DATA (info
, codep
+ 2);
10993 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
10994 modrm
.mod
= (*codep
>> 6) & 3;
10995 modrm
.reg
= (*codep
>> 3) & 7;
10996 modrm
.rm
= *codep
& 7;
10999 case USE_VEX_LEN_TABLE
:
11003 switch (vex
.length
)
11016 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
11019 case USE_XOP_8F_TABLE
:
11020 FETCH_DATA (info
, codep
+ 3);
11021 /* All bits in the REX prefix are ignored. */
11023 rex
= ~(*codep
>> 5) & 0x7;
11025 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11026 switch ((*codep
& 0x1f))
11031 vex_table_index
= XOP_08
;
11034 vex_table_index
= XOP_09
;
11037 vex_table_index
= XOP_0A
;
11041 vex
.w
= *codep
& 0x80;
11042 if (vex
.w
&& address_mode
== mode_64bit
)
11045 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11046 if (address_mode
!= mode_64bit
11047 && vex
.register_specifier
> 0x7)
11050 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11051 switch ((*codep
& 0x3))
11057 vex
.prefix
= DATA_PREFIX_OPCODE
;
11060 vex
.prefix
= REPE_PREFIX_OPCODE
;
11063 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11070 dp
= &xop_table
[vex_table_index
][vindex
];
11072 FETCH_DATA (info
, codep
+ 1);
11073 modrm
.mod
= (*codep
>> 6) & 3;
11074 modrm
.reg
= (*codep
>> 3) & 7;
11075 modrm
.rm
= *codep
& 7;
11078 case USE_VEX_C4_TABLE
:
11079 FETCH_DATA (info
, codep
+ 3);
11080 /* All bits in the REX prefix are ignored. */
11082 rex
= ~(*codep
>> 5) & 0x7;
11083 switch ((*codep
& 0x1f))
11088 vex_table_index
= VEX_0F
;
11091 vex_table_index
= VEX_0F38
;
11094 vex_table_index
= VEX_0F3A
;
11098 vex
.w
= *codep
& 0x80;
11099 if (vex
.w
&& address_mode
== mode_64bit
)
11102 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11103 if (address_mode
!= mode_64bit
11104 && vex
.register_specifier
> 0x7)
11107 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11108 switch ((*codep
& 0x3))
11114 vex
.prefix
= DATA_PREFIX_OPCODE
;
11117 vex
.prefix
= REPE_PREFIX_OPCODE
;
11120 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11127 dp
= &vex_table
[vex_table_index
][vindex
];
11128 /* There is no MODRM byte for VEX [82|77]. */
11129 if (vindex
!= 0x77 && vindex
!= 0x82)
11131 FETCH_DATA (info
, codep
+ 1);
11132 modrm
.mod
= (*codep
>> 6) & 3;
11133 modrm
.reg
= (*codep
>> 3) & 7;
11134 modrm
.rm
= *codep
& 7;
11138 case USE_VEX_C5_TABLE
:
11139 FETCH_DATA (info
, codep
+ 2);
11140 /* All bits in the REX prefix are ignored. */
11142 rex
= (*codep
& 0x80) ? 0 : REX_R
;
11144 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11145 if (address_mode
!= mode_64bit
11146 && vex
.register_specifier
> 0x7)
11151 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11152 switch ((*codep
& 0x3))
11158 vex
.prefix
= DATA_PREFIX_OPCODE
;
11161 vex
.prefix
= REPE_PREFIX_OPCODE
;
11164 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11171 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
11172 /* There is no MODRM byte for VEX [82|77]. */
11173 if (vindex
!= 0x77 && vindex
!= 0x82)
11175 FETCH_DATA (info
, codep
+ 1);
11176 modrm
.mod
= (*codep
>> 6) & 3;
11177 modrm
.reg
= (*codep
>> 3) & 7;
11178 modrm
.rm
= *codep
& 7;
11182 case USE_VEX_W_TABLE
:
11186 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
11197 if (dp
->name
!= NULL
)
11200 return get_valid_dis386 (dp
, info
);
11204 print_insn (bfd_vma pc
, disassemble_info
*info
)
11206 const struct dis386
*dp
;
11208 char *op_txt
[MAX_OPERANDS
];
11212 struct dis_private priv
;
11215 int default_prefixes
;
11217 if (info
->mach
== bfd_mach_x86_64_intel_syntax
11218 || info
->mach
== bfd_mach_x86_64
11219 || info
->mach
== bfd_mach_l1om
11220 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11221 address_mode
= mode_64bit
;
11223 address_mode
= mode_32bit
;
11225 if (intel_syntax
== (char) -1)
11226 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
11227 || info
->mach
== bfd_mach_x86_64_intel_syntax
11228 || info
->mach
== bfd_mach_l1om_intel_syntax
);
11230 if (info
->mach
== bfd_mach_i386_i386
11231 || info
->mach
== bfd_mach_x86_64
11232 || info
->mach
== bfd_mach_l1om
11233 || info
->mach
== bfd_mach_i386_i386_intel_syntax
11234 || info
->mach
== bfd_mach_x86_64_intel_syntax
11235 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11236 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11237 else if (info
->mach
== bfd_mach_i386_i8086
)
11238 priv
.orig_sizeflag
= 0;
11242 for (p
= info
->disassembler_options
; p
!= NULL
; )
11244 if (CONST_STRNEQ (p
, "x86-64"))
11246 address_mode
= mode_64bit
;
11247 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11249 else if (CONST_STRNEQ (p
, "i386"))
11251 address_mode
= mode_32bit
;
11252 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11254 else if (CONST_STRNEQ (p
, "i8086"))
11256 address_mode
= mode_16bit
;
11257 priv
.orig_sizeflag
= 0;
11259 else if (CONST_STRNEQ (p
, "intel"))
11262 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
11263 intel_mnemonic
= 1;
11265 else if (CONST_STRNEQ (p
, "att"))
11268 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
11269 intel_mnemonic
= 0;
11271 else if (CONST_STRNEQ (p
, "addr"))
11273 if (address_mode
== mode_64bit
)
11275 if (p
[4] == '3' && p
[5] == '2')
11276 priv
.orig_sizeflag
&= ~AFLAG
;
11277 else if (p
[4] == '6' && p
[5] == '4')
11278 priv
.orig_sizeflag
|= AFLAG
;
11282 if (p
[4] == '1' && p
[5] == '6')
11283 priv
.orig_sizeflag
&= ~AFLAG
;
11284 else if (p
[4] == '3' && p
[5] == '2')
11285 priv
.orig_sizeflag
|= AFLAG
;
11288 else if (CONST_STRNEQ (p
, "data"))
11290 if (p
[4] == '1' && p
[5] == '6')
11291 priv
.orig_sizeflag
&= ~DFLAG
;
11292 else if (p
[4] == '3' && p
[5] == '2')
11293 priv
.orig_sizeflag
|= DFLAG
;
11295 else if (CONST_STRNEQ (p
, "suffix"))
11296 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
11298 p
= strchr (p
, ',');
11305 names64
= intel_names64
;
11306 names32
= intel_names32
;
11307 names16
= intel_names16
;
11308 names8
= intel_names8
;
11309 names8rex
= intel_names8rex
;
11310 names_seg
= intel_names_seg
;
11311 names_mm
= intel_names_mm
;
11312 names_xmm
= intel_names_xmm
;
11313 names_ymm
= intel_names_ymm
;
11314 index64
= intel_index64
;
11315 index32
= intel_index32
;
11316 index16
= intel_index16
;
11319 separator_char
= '+';
11324 names64
= att_names64
;
11325 names32
= att_names32
;
11326 names16
= att_names16
;
11327 names8
= att_names8
;
11328 names8rex
= att_names8rex
;
11329 names_seg
= att_names_seg
;
11330 names_mm
= att_names_mm
;
11331 names_xmm
= att_names_xmm
;
11332 names_ymm
= att_names_ymm
;
11333 index64
= att_index64
;
11334 index32
= att_index32
;
11335 index16
= att_index16
;
11338 separator_char
= ',';
11342 /* The output looks better if we put 7 bytes on a line, since that
11343 puts most long word instructions on a single line. Use 8 bytes
11345 if (info
->mach
== bfd_mach_l1om
11346 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11347 info
->bytes_per_line
= 8;
11349 info
->bytes_per_line
= 7;
11351 info
->private_data
= &priv
;
11352 priv
.max_fetched
= priv
.the_buffer
;
11353 priv
.insn_start
= pc
;
11356 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11364 start_codep
= priv
.the_buffer
;
11365 codep
= priv
.the_buffer
;
11367 if (setjmp (priv
.bailout
) != 0)
11371 /* Getting here means we tried for data but didn't get it. That
11372 means we have an incomplete instruction of some sort. Just
11373 print the first byte as a prefix or a .byte pseudo-op. */
11374 if (codep
> priv
.the_buffer
)
11376 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
11378 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11381 /* Just print the first byte as a .byte instruction. */
11382 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
11383 (unsigned int) priv
.the_buffer
[0]);
11393 sizeflag
= priv
.orig_sizeflag
;
11395 if (!ckprefix () || rex_used
)
11397 /* Too many prefixes or unused REX prefixes. */
11399 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
11401 (*info
->fprintf_func
) (info
->stream
, "%s",
11402 prefix_name (all_prefixes
[i
], sizeflag
));
11406 insn_codep
= codep
;
11408 FETCH_DATA (info
, codep
+ 1);
11409 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
11411 if (((prefixes
& PREFIX_FWAIT
)
11412 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
11414 (*info
->fprintf_func
) (info
->stream
, "fwait");
11420 if (*codep
== 0x0f)
11422 unsigned char threebyte
;
11423 FETCH_DATA (info
, codep
+ 2);
11424 threebyte
= *++codep
;
11425 dp
= &dis386_twobyte
[threebyte
];
11426 need_modrm
= twobyte_has_modrm
[*codep
];
11431 dp
= &dis386
[*codep
];
11432 need_modrm
= onebyte_has_modrm
[*codep
];
11436 if ((prefixes
& PREFIX_REPZ
))
11437 used_prefixes
|= PREFIX_REPZ
;
11438 if ((prefixes
& PREFIX_REPNZ
))
11439 used_prefixes
|= PREFIX_REPNZ
;
11440 if ((prefixes
& PREFIX_LOCK
))
11441 used_prefixes
|= PREFIX_LOCK
;
11443 default_prefixes
= 0;
11444 if (prefixes
& PREFIX_ADDR
)
11447 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
11449 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
11450 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
11452 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
11453 default_prefixes
|= PREFIX_ADDR
;
11457 if ((prefixes
& PREFIX_DATA
))
11460 if (dp
->op
[2].bytemode
== cond_jump_mode
11461 && dp
->op
[0].bytemode
== v_mode
11464 if (sizeflag
& DFLAG
)
11465 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
11467 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
11468 default_prefixes
|= PREFIX_DATA
;
11470 else if (rex
& REX_W
)
11472 /* REX_W will override PREFIX_DATA. */
11473 default_prefixes
|= PREFIX_DATA
;
11479 FETCH_DATA (info
, codep
+ 1);
11480 modrm
.mod
= (*codep
>> 6) & 3;
11481 modrm
.reg
= (*codep
>> 3) & 7;
11482 modrm
.rm
= *codep
& 7;
11489 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
11491 dofloat (sizeflag
);
11495 dp
= get_valid_dis386 (dp
, info
);
11496 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
11498 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11501 op_ad
= MAX_OPERANDS
- 1 - i
;
11503 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
11508 /* See if any prefixes were not used. If so, print the first one
11509 separately. If we don't do this, we'll wind up printing an
11510 instruction stream which does not precisely correspond to the
11511 bytes we are disassembling. */
11512 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
11514 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11515 if (all_prefixes
[i
])
11518 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
11520 name
= INTERNAL_DISASSEMBLER_ERROR
;
11521 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11526 /* Check if the REX prefix is used. */
11527 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
11528 all_prefixes
[last_rex_prefix
] = 0;
11530 /* Check if the SEG prefix is used. */
11531 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
11532 | PREFIX_FS
| PREFIX_GS
)) != 0
11534 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
11535 all_prefixes
[last_seg_prefix
] = 0;
11537 /* Check if the ADDR prefix is used. */
11538 if ((prefixes
& PREFIX_ADDR
) != 0
11539 && (used_prefixes
& PREFIX_ADDR
) != 0)
11540 all_prefixes
[last_addr_prefix
] = 0;
11542 /* Check if the DATA prefix is used. */
11543 if ((prefixes
& PREFIX_DATA
) != 0
11544 && (used_prefixes
& PREFIX_DATA
) != 0)
11545 all_prefixes
[last_data_prefix
] = 0;
11548 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11549 if (all_prefixes
[i
])
11552 name
= prefix_name (all_prefixes
[i
], sizeflag
);
11555 prefix_length
+= strlen (name
) + 1;
11556 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
11559 /* Check maximum code length. */
11560 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
11562 (*info
->fprintf_func
) (info
->stream
, "(bad)");
11563 return MAX_CODE_LENGTH
;
11566 obufp
= mnemonicendp
;
11567 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
11570 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
11572 /* The enter and bound instructions are printed with operands in the same
11573 order as the intel book; everything else is printed in reverse order. */
11574 if (intel_syntax
|| two_source_ops
)
11578 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11579 op_txt
[i
] = op_out
[i
];
11581 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
11583 op_ad
= op_index
[i
];
11584 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
11585 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
11586 riprel
= op_riprel
[i
];
11587 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
11588 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
11593 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11594 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
11598 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11602 (*info
->fprintf_func
) (info
->stream
, ",");
11603 if (op_index
[i
] != -1 && !op_riprel
[i
])
11604 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
11606 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
11610 for (i
= 0; i
< MAX_OPERANDS
; i
++)
11611 if (op_index
[i
] != -1 && op_riprel
[i
])
11613 (*info
->fprintf_func
) (info
->stream
, " # ");
11614 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
11615 + op_address
[op_index
[i
]]), info
);
11618 return codep
- priv
.the_buffer
;
11621 static const char *float_mem
[] = {
11696 static const unsigned char float_mem_mode
[] = {
11771 #define ST { OP_ST, 0 }
11772 #define STi { OP_STi, 0 }
11774 #define FGRPd9_2 NULL, { { NULL, 0 } }
11775 #define FGRPd9_4 NULL, { { NULL, 1 } }
11776 #define FGRPd9_5 NULL, { { NULL, 2 } }
11777 #define FGRPd9_6 NULL, { { NULL, 3 } }
11778 #define FGRPd9_7 NULL, { { NULL, 4 } }
11779 #define FGRPda_5 NULL, { { NULL, 5 } }
11780 #define FGRPdb_4 NULL, { { NULL, 6 } }
11781 #define FGRPde_3 NULL, { { NULL, 7 } }
11782 #define FGRPdf_4 NULL, { { NULL, 8 } }
11784 static const struct dis386 float_reg
[][8] = {
11787 { "fadd", { ST
, STi
} },
11788 { "fmul", { ST
, STi
} },
11789 { "fcom", { STi
} },
11790 { "fcomp", { STi
} },
11791 { "fsub", { ST
, STi
} },
11792 { "fsubr", { ST
, STi
} },
11793 { "fdiv", { ST
, STi
} },
11794 { "fdivr", { ST
, STi
} },
11798 { "fld", { STi
} },
11799 { "fxch", { STi
} },
11809 { "fcmovb", { ST
, STi
} },
11810 { "fcmove", { ST
, STi
} },
11811 { "fcmovbe",{ ST
, STi
} },
11812 { "fcmovu", { ST
, STi
} },
11820 { "fcmovnb",{ ST
, STi
} },
11821 { "fcmovne",{ ST
, STi
} },
11822 { "fcmovnbe",{ ST
, STi
} },
11823 { "fcmovnu",{ ST
, STi
} },
11825 { "fucomi", { ST
, STi
} },
11826 { "fcomi", { ST
, STi
} },
11831 { "fadd", { STi
, ST
} },
11832 { "fmul", { STi
, ST
} },
11835 { "fsub!M", { STi
, ST
} },
11836 { "fsubM", { STi
, ST
} },
11837 { "fdiv!M", { STi
, ST
} },
11838 { "fdivM", { STi
, ST
} },
11842 { "ffree", { STi
} },
11844 { "fst", { STi
} },
11845 { "fstp", { STi
} },
11846 { "fucom", { STi
} },
11847 { "fucomp", { STi
} },
11853 { "faddp", { STi
, ST
} },
11854 { "fmulp", { STi
, ST
} },
11857 { "fsub!Mp", { STi
, ST
} },
11858 { "fsubMp", { STi
, ST
} },
11859 { "fdiv!Mp", { STi
, ST
} },
11860 { "fdivMp", { STi
, ST
} },
11864 { "ffreep", { STi
} },
11869 { "fucomip", { ST
, STi
} },
11870 { "fcomip", { ST
, STi
} },
11875 static char *fgrps
[][8] = {
11878 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11883 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11888 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11893 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11898 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11903 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11908 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11909 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11914 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11919 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11924 swap_operand (void)
11926 mnemonicendp
[0] = '.';
11927 mnemonicendp
[1] = 's';
11932 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11933 int sizeflag ATTRIBUTE_UNUSED
)
11935 /* Skip mod/rm byte. */
11941 dofloat (int sizeflag
)
11943 const struct dis386
*dp
;
11944 unsigned char floatop
;
11946 floatop
= codep
[-1];
11948 if (modrm
.mod
!= 3)
11950 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11952 putop (float_mem
[fp_indx
], sizeflag
);
11955 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11958 /* Skip mod/rm byte. */
11962 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11963 if (dp
->name
== NULL
)
11965 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
11967 /* Instruction fnstsw is only one with strange arg. */
11968 if (floatop
== 0xdf && codep
[-1] == 0xe0)
11969 strcpy (op_out
[0], names16
[0]);
11973 putop (dp
->name
, sizeflag
);
11978 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
11983 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
11988 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11990 oappend ("%st" + intel_syntax
);
11994 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11996 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
11997 oappend (scratchbuf
+ intel_syntax
);
12000 /* Capital letters in template are macros. */
12002 putop (const char *in_template
, int sizeflag
)
12007 unsigned int l
= 0, len
= 1;
12010 #define SAVE_LAST(c) \
12011 if (l < len && l < sizeof (last)) \
12016 for (p
= in_template
; *p
; p
++)
12033 while (*++p
!= '|')
12034 if (*p
== '}' || *p
== '\0')
12037 /* Fall through. */
12042 while (*++p
!= '}')
12053 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12057 if (l
== 0 && len
== 1)
12062 if (sizeflag
& SUFFIX_ALWAYS
)
12075 if (address_mode
== mode_64bit
12076 && !(prefixes
& PREFIX_ADDR
))
12087 if (intel_syntax
&& !alt
)
12089 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
12091 if (sizeflag
& DFLAG
)
12092 *obufp
++ = intel_syntax
? 'd' : 'l';
12094 *obufp
++ = intel_syntax
? 'w' : 's';
12095 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12099 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12102 if (modrm
.mod
== 3)
12108 if (sizeflag
& DFLAG
)
12109 *obufp
++ = intel_syntax
? 'd' : 'l';
12112 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12118 case 'E': /* For jcxz/jecxz */
12119 if (address_mode
== mode_64bit
)
12121 if (sizeflag
& AFLAG
)
12127 if (sizeflag
& AFLAG
)
12129 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12134 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
12136 if (sizeflag
& AFLAG
)
12137 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
12139 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
12140 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12144 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
12146 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12150 if (!(rex
& REX_W
))
12151 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12156 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
12157 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
12159 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
12162 if (prefixes
& PREFIX_DS
)
12183 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
12188 /* Fall through. */
12191 if (l
!= 0 || len
!= 1)
12199 if (sizeflag
& SUFFIX_ALWAYS
)
12203 if (intel_mnemonic
!= cond
)
12207 if ((prefixes
& PREFIX_FWAIT
) == 0)
12210 used_prefixes
|= PREFIX_FWAIT
;
12216 else if (intel_syntax
&& (sizeflag
& DFLAG
))
12220 if (!(rex
& REX_W
))
12221 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12226 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12231 /* Fall through. */
12235 if ((prefixes
& PREFIX_DATA
)
12237 || (sizeflag
& SUFFIX_ALWAYS
))
12244 if (sizeflag
& DFLAG
)
12248 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12255 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12257 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12261 /* Fall through. */
12264 if (l
== 0 && len
== 1)
12267 if (intel_syntax
&& !alt
)
12270 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12276 if (sizeflag
& DFLAG
)
12277 *obufp
++ = intel_syntax
? 'd' : 'l';
12280 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12286 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
12292 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12307 else if (sizeflag
& DFLAG
)
12316 if (intel_syntax
&& !p
[1]
12317 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
12319 if (!(rex
& REX_W
))
12320 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12323 if (l
== 0 && len
== 1)
12327 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12329 if (sizeflag
& SUFFIX_ALWAYS
)
12351 /* Fall through. */
12354 if (l
== 0 && len
== 1)
12359 if (sizeflag
& SUFFIX_ALWAYS
)
12365 if (sizeflag
& DFLAG
)
12369 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12383 if (address_mode
== mode_64bit
12384 && !(prefixes
& PREFIX_ADDR
))
12395 if (l
!= 0 || len
!= 1)
12400 if (need_vex
&& vex
.prefix
)
12402 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
12409 if (prefixes
& PREFIX_DATA
)
12413 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12417 if (l
== 0 && len
== 1)
12419 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12430 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12438 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12440 switch (vex
.length
)
12454 if (l
== 0 && len
== 1)
12456 /* operand size flag for cwtl, cbtw */
12465 else if (sizeflag
& DFLAG
)
12469 if (!(rex
& REX_W
))
12470 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12474 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12481 *obufp
++ = vex
.w
? 'd': 's';
12488 mnemonicendp
= obufp
;
12493 oappend (const char *s
)
12495 obufp
= stpcpy (obufp
, s
);
12501 if (prefixes
& PREFIX_CS
)
12503 used_prefixes
|= PREFIX_CS
;
12504 oappend ("%cs:" + intel_syntax
);
12506 if (prefixes
& PREFIX_DS
)
12508 used_prefixes
|= PREFIX_DS
;
12509 oappend ("%ds:" + intel_syntax
);
12511 if (prefixes
& PREFIX_SS
)
12513 used_prefixes
|= PREFIX_SS
;
12514 oappend ("%ss:" + intel_syntax
);
12516 if (prefixes
& PREFIX_ES
)
12518 used_prefixes
|= PREFIX_ES
;
12519 oappend ("%es:" + intel_syntax
);
12521 if (prefixes
& PREFIX_FS
)
12523 used_prefixes
|= PREFIX_FS
;
12524 oappend ("%fs:" + intel_syntax
);
12526 if (prefixes
& PREFIX_GS
)
12528 used_prefixes
|= PREFIX_GS
;
12529 oappend ("%gs:" + intel_syntax
);
12534 OP_indirE (int bytemode
, int sizeflag
)
12538 OP_E (bytemode
, sizeflag
);
12542 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
12544 if (address_mode
== mode_64bit
)
12552 sprintf_vma (tmp
, disp
);
12553 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
12554 strcpy (buf
+ 2, tmp
+ i
);
12558 bfd_signed_vma v
= disp
;
12565 /* Check for possible overflow on 0x8000000000000000. */
12568 strcpy (buf
, "9223372036854775808");
12582 tmp
[28 - i
] = (v
% 10) + '0';
12586 strcpy (buf
, tmp
+ 29 - i
);
12592 sprintf (buf
, "0x%x", (unsigned int) disp
);
12594 sprintf (buf
, "%d", (int) disp
);
12598 /* Put DISP in BUF as signed hex number. */
12601 print_displacement (char *buf
, bfd_vma disp
)
12603 bfd_signed_vma val
= disp
;
12612 /* Check for possible overflow. */
12615 switch (address_mode
)
12618 strcpy (buf
+ j
, "0x8000000000000000");
12621 strcpy (buf
+ j
, "0x80000000");
12624 strcpy (buf
+ j
, "0x8000");
12634 sprintf_vma (tmp
, (bfd_vma
) val
);
12635 for (i
= 0; tmp
[i
] == '0'; i
++)
12637 if (tmp
[i
] == '\0')
12639 strcpy (buf
+ j
, tmp
+ i
);
12643 intel_operand_size (int bytemode
, int sizeflag
)
12650 oappend ("BYTE PTR ");
12654 oappend ("WORD PTR ");
12657 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12659 oappend ("QWORD PTR ");
12668 oappend ("QWORD PTR ");
12671 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
12672 oappend ("DWORD PTR ");
12674 oappend ("WORD PTR ");
12675 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12679 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12681 oappend ("WORD PTR ");
12682 if (!(rex
& REX_W
))
12683 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12686 if (sizeflag
& DFLAG
)
12687 oappend ("QWORD PTR ");
12689 oappend ("DWORD PTR ");
12690 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12693 case d_scalar_mode
:
12694 case d_scalar_swap_mode
:
12697 oappend ("DWORD PTR ");
12700 case q_scalar_mode
:
12701 case q_scalar_swap_mode
:
12703 oappend ("QWORD PTR ");
12706 if (address_mode
== mode_64bit
)
12707 oappend ("QWORD PTR ");
12709 oappend ("DWORD PTR ");
12712 if (sizeflag
& DFLAG
)
12713 oappend ("FWORD PTR ");
12715 oappend ("DWORD PTR ");
12716 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12719 oappend ("TBYTE PTR ");
12725 switch (vex
.length
)
12728 oappend ("XMMWORD PTR ");
12731 oappend ("YMMWORD PTR ");
12738 oappend ("XMMWORD PTR ");
12741 oappend ("XMMWORD PTR ");
12747 switch (vex
.length
)
12750 oappend ("QWORD PTR ");
12753 oappend ("XMMWORD PTR ");
12763 switch (vex
.length
)
12766 oappend ("QWORD PTR ");
12769 oappend ("YMMWORD PTR ");
12776 oappend ("OWORD PTR ");
12778 case vex_w_dq_mode
:
12783 oappend ("QWORD PTR ");
12785 oappend ("DWORD PTR ");
12793 OP_E_register (int bytemode
, int sizeflag
)
12795 int reg
= modrm
.rm
;
12796 const char **names
;
12802 if ((sizeflag
& SUFFIX_ALWAYS
)
12803 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12826 names
= address_mode
== mode_64bit
? names64
: names32
;
12829 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12847 if ((sizeflag
& DFLAG
)
12848 || (bytemode
!= v_mode
12849 && bytemode
!= v_swap_mode
))
12853 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12859 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12862 oappend (names
[reg
]);
12866 OP_E_memory (int bytemode
, int sizeflag
)
12869 int add
= (rex
& REX_B
) ? 8 : 0;
12874 intel_operand_size (bytemode
, sizeflag
);
12877 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12879 /* 32/64 bit address mode */
12897 FETCH_DATA (the_info
, codep
+ 1);
12898 vindex
= (*codep
>> 3) & 7;
12899 scale
= (*codep
>> 6) & 3;
12904 haveindex
= vindex
!= 4;
12907 rbase
= base
+ add
;
12915 if (address_mode
== mode_64bit
&& !havesib
)
12921 FETCH_DATA (the_info
, codep
+ 1);
12923 if ((disp
& 0x80) != 0)
12931 /* In 32bit mode, we need index register to tell [offset] from
12932 [eiz*1 + offset]. */
12933 needindex
= (havesib
12936 && address_mode
== mode_32bit
);
12937 havedisp
= (havebase
12939 || (havesib
&& (haveindex
|| scale
!= 0)));
12942 if (modrm
.mod
!= 0 || base
== 5)
12944 if (havedisp
|| riprel
)
12945 print_displacement (scratchbuf
, disp
);
12947 print_operand_value (scratchbuf
, 1, disp
);
12948 oappend (scratchbuf
);
12952 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12956 if (havebase
|| haveindex
|| riprel
)
12957 used_prefixes
|= PREFIX_ADDR
;
12959 if (havedisp
|| (intel_syntax
&& riprel
))
12961 *obufp
++ = open_char
;
12962 if (intel_syntax
&& riprel
)
12965 oappend (sizeflag
& AFLAG
? "rip" : "eip");
12969 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
12970 ? names64
[rbase
] : names32
[rbase
]);
12973 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12974 print index to tell base + index from base. */
12978 || (havebase
&& base
!= ESP_REG_NUM
))
12980 if (!intel_syntax
|| havebase
)
12982 *obufp
++ = separator_char
;
12986 oappend (address_mode
== mode_64bit
12987 && (sizeflag
& AFLAG
)
12988 ? names64
[vindex
] : names32
[vindex
]);
12990 oappend (address_mode
== mode_64bit
12991 && (sizeflag
& AFLAG
)
12992 ? index64
: index32
);
12994 *obufp
++ = scale_char
;
12996 sprintf (scratchbuf
, "%d", 1 << scale
);
12997 oappend (scratchbuf
);
13001 && (disp
|| modrm
.mod
!= 0 || base
== 5))
13003 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
13008 else if (modrm
.mod
!= 1 && disp
!= -disp
)
13012 disp
= - (bfd_signed_vma
) disp
;
13016 print_displacement (scratchbuf
, disp
);
13018 print_operand_value (scratchbuf
, 1, disp
);
13019 oappend (scratchbuf
);
13022 *obufp
++ = close_char
;
13025 else if (intel_syntax
)
13027 if (modrm
.mod
!= 0 || base
== 5)
13029 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13030 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13034 oappend (names_seg
[ds_reg
- es_reg
]);
13037 print_operand_value (scratchbuf
, 1, disp
);
13038 oappend (scratchbuf
);
13044 /* 16 bit address mode */
13045 used_prefixes
|= prefixes
& PREFIX_ADDR
;
13052 if ((disp
& 0x8000) != 0)
13057 FETCH_DATA (the_info
, codep
+ 1);
13059 if ((disp
& 0x80) != 0)
13064 if ((disp
& 0x8000) != 0)
13070 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
13072 print_displacement (scratchbuf
, disp
);
13073 oappend (scratchbuf
);
13076 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
13078 *obufp
++ = open_char
;
13080 oappend (index16
[modrm
.rm
]);
13082 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
13084 if ((bfd_signed_vma
) disp
>= 0)
13089 else if (modrm
.mod
!= 1)
13093 disp
= - (bfd_signed_vma
) disp
;
13096 print_displacement (scratchbuf
, disp
);
13097 oappend (scratchbuf
);
13100 *obufp
++ = close_char
;
13103 else if (intel_syntax
)
13105 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13106 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13110 oappend (names_seg
[ds_reg
- es_reg
]);
13113 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
13114 oappend (scratchbuf
);
13120 OP_E (int bytemode
, int sizeflag
)
13122 /* Skip mod/rm byte. */
13126 if (modrm
.mod
== 3)
13127 OP_E_register (bytemode
, sizeflag
);
13129 OP_E_memory (bytemode
, sizeflag
);
13133 OP_G (int bytemode
, int sizeflag
)
13144 oappend (names8rex
[modrm
.reg
+ add
]);
13146 oappend (names8
[modrm
.reg
+ add
]);
13149 oappend (names16
[modrm
.reg
+ add
]);
13152 oappend (names32
[modrm
.reg
+ add
]);
13155 oappend (names64
[modrm
.reg
+ add
]);
13164 oappend (names64
[modrm
.reg
+ add
]);
13167 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
13168 oappend (names32
[modrm
.reg
+ add
]);
13170 oappend (names16
[modrm
.reg
+ add
]);
13171 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13175 if (address_mode
== mode_64bit
)
13176 oappend (names64
[modrm
.reg
+ add
]);
13178 oappend (names32
[modrm
.reg
+ add
]);
13181 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13194 FETCH_DATA (the_info
, codep
+ 8);
13195 a
= *codep
++ & 0xff;
13196 a
|= (*codep
++ & 0xff) << 8;
13197 a
|= (*codep
++ & 0xff) << 16;
13198 a
|= (*codep
++ & 0xff) << 24;
13199 b
= *codep
++ & 0xff;
13200 b
|= (*codep
++ & 0xff) << 8;
13201 b
|= (*codep
++ & 0xff) << 16;
13202 b
|= (*codep
++ & 0xff) << 24;
13203 x
= a
+ ((bfd_vma
) b
<< 32);
13211 static bfd_signed_vma
13214 bfd_signed_vma x
= 0;
13216 FETCH_DATA (the_info
, codep
+ 4);
13217 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13218 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13219 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13220 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13224 static bfd_signed_vma
13227 bfd_signed_vma x
= 0;
13229 FETCH_DATA (the_info
, codep
+ 4);
13230 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13231 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13232 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13233 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13235 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
13245 FETCH_DATA (the_info
, codep
+ 2);
13246 x
= *codep
++ & 0xff;
13247 x
|= (*codep
++ & 0xff) << 8;
13252 set_op (bfd_vma op
, int riprel
)
13254 op_index
[op_ad
] = op_ad
;
13255 if (address_mode
== mode_64bit
)
13257 op_address
[op_ad
] = op
;
13258 op_riprel
[op_ad
] = riprel
;
13262 /* Mask to get a 32-bit address. */
13263 op_address
[op_ad
] = op
& 0xffffffff;
13264 op_riprel
[op_ad
] = riprel
& 0xffffffff;
13269 OP_REG (int code
, int sizeflag
)
13281 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13282 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13283 s
= names16
[code
- ax_reg
+ add
];
13285 case es_reg
: case ss_reg
: case cs_reg
:
13286 case ds_reg
: case fs_reg
: case gs_reg
:
13287 s
= names_seg
[code
- es_reg
+ add
];
13289 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13290 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13293 s
= names8rex
[code
- al_reg
+ add
];
13295 s
= names8
[code
- al_reg
];
13297 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
13298 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
13299 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13301 s
= names64
[code
- rAX_reg
+ add
];
13304 code
+= eAX_reg
- rAX_reg
;
13305 /* Fall through. */
13306 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13307 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13310 s
= names64
[code
- eAX_reg
+ add
];
13313 if (sizeflag
& DFLAG
)
13314 s
= names32
[code
- eAX_reg
+ add
];
13316 s
= names16
[code
- eAX_reg
+ add
];
13317 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13321 s
= INTERNAL_DISASSEMBLER_ERROR
;
13328 OP_IMREG (int code
, int sizeflag
)
13340 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13341 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13342 s
= names16
[code
- ax_reg
];
13344 case es_reg
: case ss_reg
: case cs_reg
:
13345 case ds_reg
: case fs_reg
: case gs_reg
:
13346 s
= names_seg
[code
- es_reg
];
13348 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13349 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13352 s
= names8rex
[code
- al_reg
];
13354 s
= names8
[code
- al_reg
];
13356 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13357 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13360 s
= names64
[code
- eAX_reg
];
13363 if (sizeflag
& DFLAG
)
13364 s
= names32
[code
- eAX_reg
];
13366 s
= names16
[code
- eAX_reg
];
13367 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13370 case z_mode_ax_reg
:
13371 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13375 if (!(rex
& REX_W
))
13376 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13379 s
= INTERNAL_DISASSEMBLER_ERROR
;
13386 OP_I (int bytemode
, int sizeflag
)
13389 bfd_signed_vma mask
= -1;
13394 FETCH_DATA (the_info
, codep
+ 1);
13399 if (address_mode
== mode_64bit
)
13404 /* Fall through. */
13411 if (sizeflag
& DFLAG
)
13421 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13433 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13438 scratchbuf
[0] = '$';
13439 print_operand_value (scratchbuf
+ 1, 1, op
);
13440 oappend (scratchbuf
+ intel_syntax
);
13441 scratchbuf
[0] = '\0';
13445 OP_I64 (int bytemode
, int sizeflag
)
13448 bfd_signed_vma mask
= -1;
13450 if (address_mode
!= mode_64bit
)
13452 OP_I (bytemode
, sizeflag
);
13459 FETCH_DATA (the_info
, codep
+ 1);
13469 if (sizeflag
& DFLAG
)
13479 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13487 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13492 scratchbuf
[0] = '$';
13493 print_operand_value (scratchbuf
+ 1, 1, op
);
13494 oappend (scratchbuf
+ intel_syntax
);
13495 scratchbuf
[0] = '\0';
13499 OP_sI (int bytemode
, int sizeflag
)
13502 bfd_signed_vma mask
= -1;
13507 FETCH_DATA (the_info
, codep
+ 1);
13509 if ((op
& 0x80) != 0)
13519 if (sizeflag
& DFLAG
)
13528 if ((op
& 0x8000) != 0)
13531 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13537 if ((op
& 0x8000) != 0)
13541 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13545 scratchbuf
[0] = '$';
13546 print_operand_value (scratchbuf
+ 1, 1, op
);
13547 oappend (scratchbuf
+ intel_syntax
);
13551 OP_J (int bytemode
, int sizeflag
)
13555 bfd_vma segment
= 0;
13560 FETCH_DATA (the_info
, codep
+ 1);
13562 if ((disp
& 0x80) != 0)
13567 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
13572 if ((disp
& 0x8000) != 0)
13574 /* In 16bit mode, address is wrapped around at 64k within
13575 the same segment. Otherwise, a data16 prefix on a jump
13576 instruction means that the pc is masked to 16 bits after
13577 the displacement is added! */
13579 if ((prefixes
& PREFIX_DATA
) == 0)
13580 segment
= ((start_pc
+ codep
- start_codep
)
13581 & ~((bfd_vma
) 0xffff));
13583 if (!(rex
& REX_W
))
13584 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13587 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13590 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
13592 print_operand_value (scratchbuf
, 1, disp
);
13593 oappend (scratchbuf
);
13597 OP_SEG (int bytemode
, int sizeflag
)
13599 if (bytemode
== w_mode
)
13600 oappend (names_seg
[modrm
.reg
]);
13602 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
13606 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
13610 if (sizeflag
& DFLAG
)
13620 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13622 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
13624 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
13625 oappend (scratchbuf
);
13629 OP_OFF (int bytemode
, int sizeflag
)
13633 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13634 intel_operand_size (bytemode
, sizeflag
);
13637 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13644 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13645 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13647 oappend (names_seg
[ds_reg
- es_reg
]);
13651 print_operand_value (scratchbuf
, 1, off
);
13652 oappend (scratchbuf
);
13656 OP_OFF64 (int bytemode
, int sizeflag
)
13660 if (address_mode
!= mode_64bit
13661 || (prefixes
& PREFIX_ADDR
))
13663 OP_OFF (bytemode
, sizeflag
);
13667 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13668 intel_operand_size (bytemode
, sizeflag
);
13675 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13676 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13678 oappend (names_seg
[ds_reg
- es_reg
]);
13682 print_operand_value (scratchbuf
, 1, off
);
13683 oappend (scratchbuf
);
13687 ptr_reg (int code
, int sizeflag
)
13691 *obufp
++ = open_char
;
13692 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13693 if (address_mode
== mode_64bit
)
13695 if (!(sizeflag
& AFLAG
))
13696 s
= names32
[code
- eAX_reg
];
13698 s
= names64
[code
- eAX_reg
];
13700 else if (sizeflag
& AFLAG
)
13701 s
= names32
[code
- eAX_reg
];
13703 s
= names16
[code
- eAX_reg
];
13705 *obufp
++ = close_char
;
13710 OP_ESreg (int code
, int sizeflag
)
13716 case 0x6d: /* insw/insl */
13717 intel_operand_size (z_mode
, sizeflag
);
13719 case 0xa5: /* movsw/movsl/movsq */
13720 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13721 case 0xab: /* stosw/stosl */
13722 case 0xaf: /* scasw/scasl */
13723 intel_operand_size (v_mode
, sizeflag
);
13726 intel_operand_size (b_mode
, sizeflag
);
13729 oappend ("%es:" + intel_syntax
);
13730 ptr_reg (code
, sizeflag
);
13734 OP_DSreg (int code
, int sizeflag
)
13740 case 0x6f: /* outsw/outsl */
13741 intel_operand_size (z_mode
, sizeflag
);
13743 case 0xa5: /* movsw/movsl/movsq */
13744 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13745 case 0xad: /* lodsw/lodsl/lodsq */
13746 intel_operand_size (v_mode
, sizeflag
);
13749 intel_operand_size (b_mode
, sizeflag
);
13758 | PREFIX_GS
)) == 0)
13759 prefixes
|= PREFIX_DS
;
13761 ptr_reg (code
, sizeflag
);
13765 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13773 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13775 all_prefixes
[last_lock_prefix
] = 0;
13776 used_prefixes
|= PREFIX_LOCK
;
13781 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13782 oappend (scratchbuf
+ intel_syntax
);
13786 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13795 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13797 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13798 oappend (scratchbuf
);
13802 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13804 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13805 oappend (scratchbuf
+ intel_syntax
);
13809 OP_R (int bytemode
, int sizeflag
)
13811 if (modrm
.mod
== 3)
13812 OP_E (bytemode
, sizeflag
);
13818 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13820 int reg
= modrm
.reg
;
13821 const char **names
;
13823 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13824 if (prefixes
& PREFIX_DATA
)
13833 oappend (names
[reg
]);
13837 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13839 int reg
= modrm
.reg
;
13840 const char **names
;
13846 && bytemode
!= xmm_mode
13847 && bytemode
!= scalar_mode
)
13849 switch (vex
.length
)
13863 oappend (names
[reg
]);
13867 OP_EM (int bytemode
, int sizeflag
)
13870 const char **names
;
13872 if (modrm
.mod
!= 3)
13875 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13877 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13878 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13880 OP_E (bytemode
, sizeflag
);
13884 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13887 /* Skip mod/rm byte. */
13890 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13892 if (prefixes
& PREFIX_DATA
)
13901 oappend (names
[reg
]);
13904 /* cvt* are the only instructions in sse2 which have
13905 both SSE and MMX operands and also have 0x66 prefix
13906 in their opcode. 0x66 was originally used to differentiate
13907 between SSE and MMX instruction(operands). So we have to handle the
13908 cvt* separately using OP_EMC and OP_MXC */
13910 OP_EMC (int bytemode
, int sizeflag
)
13912 if (modrm
.mod
!= 3)
13914 if (intel_syntax
&& bytemode
== v_mode
)
13916 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13917 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13919 OP_E (bytemode
, sizeflag
);
13923 /* Skip mod/rm byte. */
13926 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13927 oappend (names_mm
[modrm
.rm
]);
13931 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13933 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13934 oappend (names_mm
[modrm
.reg
]);
13938 OP_EX (int bytemode
, int sizeflag
)
13941 const char **names
;
13943 /* Skip mod/rm byte. */
13947 if (modrm
.mod
!= 3)
13949 OP_E_memory (bytemode
, sizeflag
);
13958 if ((sizeflag
& SUFFIX_ALWAYS
)
13959 && (bytemode
== x_swap_mode
13960 || bytemode
== d_swap_mode
13961 || bytemode
== d_scalar_swap_mode
13962 || bytemode
== q_swap_mode
13963 || bytemode
== q_scalar_swap_mode
))
13967 && bytemode
!= xmm_mode
13968 && bytemode
!= xmmq_mode
13969 && bytemode
!= d_scalar_mode
13970 && bytemode
!= d_scalar_swap_mode
13971 && bytemode
!= q_scalar_mode
13972 && bytemode
!= q_scalar_swap_mode
)
13974 switch (vex
.length
)
13988 oappend (names
[reg
]);
13992 OP_MS (int bytemode
, int sizeflag
)
13994 if (modrm
.mod
== 3)
13995 OP_EM (bytemode
, sizeflag
);
14001 OP_XS (int bytemode
, int sizeflag
)
14003 if (modrm
.mod
== 3)
14004 OP_EX (bytemode
, sizeflag
);
14010 OP_M (int bytemode
, int sizeflag
)
14012 if (modrm
.mod
== 3)
14013 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14016 OP_E (bytemode
, sizeflag
);
14020 OP_0f07 (int bytemode
, int sizeflag
)
14022 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
14025 OP_E (bytemode
, sizeflag
);
14028 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14029 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14032 NOP_Fixup1 (int bytemode
, int sizeflag
)
14034 if ((prefixes
& PREFIX_DATA
) != 0
14037 && address_mode
== mode_64bit
))
14038 OP_REG (bytemode
, sizeflag
);
14040 strcpy (obuf
, "nop");
14044 NOP_Fixup2 (int bytemode
, int sizeflag
)
14046 if ((prefixes
& PREFIX_DATA
) != 0
14049 && address_mode
== mode_64bit
))
14050 OP_IMREG (bytemode
, sizeflag
);
14053 static const char *const Suffix3DNow
[] = {
14054 /* 00 */ NULL
, NULL
, NULL
, NULL
,
14055 /* 04 */ NULL
, NULL
, NULL
, NULL
,
14056 /* 08 */ NULL
, NULL
, NULL
, NULL
,
14057 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
14058 /* 10 */ NULL
, NULL
, NULL
, NULL
,
14059 /* 14 */ NULL
, NULL
, NULL
, NULL
,
14060 /* 18 */ NULL
, NULL
, NULL
, NULL
,
14061 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
14062 /* 20 */ NULL
, NULL
, NULL
, NULL
,
14063 /* 24 */ NULL
, NULL
, NULL
, NULL
,
14064 /* 28 */ NULL
, NULL
, NULL
, NULL
,
14065 /* 2C */ NULL
, NULL
, NULL
, NULL
,
14066 /* 30 */ NULL
, NULL
, NULL
, NULL
,
14067 /* 34 */ NULL
, NULL
, NULL
, NULL
,
14068 /* 38 */ NULL
, NULL
, NULL
, NULL
,
14069 /* 3C */ NULL
, NULL
, NULL
, NULL
,
14070 /* 40 */ NULL
, NULL
, NULL
, NULL
,
14071 /* 44 */ NULL
, NULL
, NULL
, NULL
,
14072 /* 48 */ NULL
, NULL
, NULL
, NULL
,
14073 /* 4C */ NULL
, NULL
, NULL
, NULL
,
14074 /* 50 */ NULL
, NULL
, NULL
, NULL
,
14075 /* 54 */ NULL
, NULL
, NULL
, NULL
,
14076 /* 58 */ NULL
, NULL
, NULL
, NULL
,
14077 /* 5C */ NULL
, NULL
, NULL
, NULL
,
14078 /* 60 */ NULL
, NULL
, NULL
, NULL
,
14079 /* 64 */ NULL
, NULL
, NULL
, NULL
,
14080 /* 68 */ NULL
, NULL
, NULL
, NULL
,
14081 /* 6C */ NULL
, NULL
, NULL
, NULL
,
14082 /* 70 */ NULL
, NULL
, NULL
, NULL
,
14083 /* 74 */ NULL
, NULL
, NULL
, NULL
,
14084 /* 78 */ NULL
, NULL
, NULL
, NULL
,
14085 /* 7C */ NULL
, NULL
, NULL
, NULL
,
14086 /* 80 */ NULL
, NULL
, NULL
, NULL
,
14087 /* 84 */ NULL
, NULL
, NULL
, NULL
,
14088 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
14089 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
14090 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
14091 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
14092 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
14093 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
14094 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
14095 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
14096 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
14097 /* AC */ NULL
, NULL
, "pfacc", NULL
,
14098 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
14099 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
14100 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
14101 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
14102 /* C0 */ NULL
, NULL
, NULL
, NULL
,
14103 /* C4 */ NULL
, NULL
, NULL
, NULL
,
14104 /* C8 */ NULL
, NULL
, NULL
, NULL
,
14105 /* CC */ NULL
, NULL
, NULL
, NULL
,
14106 /* D0 */ NULL
, NULL
, NULL
, NULL
,
14107 /* D4 */ NULL
, NULL
, NULL
, NULL
,
14108 /* D8 */ NULL
, NULL
, NULL
, NULL
,
14109 /* DC */ NULL
, NULL
, NULL
, NULL
,
14110 /* E0 */ NULL
, NULL
, NULL
, NULL
,
14111 /* E4 */ NULL
, NULL
, NULL
, NULL
,
14112 /* E8 */ NULL
, NULL
, NULL
, NULL
,
14113 /* EC */ NULL
, NULL
, NULL
, NULL
,
14114 /* F0 */ NULL
, NULL
, NULL
, NULL
,
14115 /* F4 */ NULL
, NULL
, NULL
, NULL
,
14116 /* F8 */ NULL
, NULL
, NULL
, NULL
,
14117 /* FC */ NULL
, NULL
, NULL
, NULL
,
14121 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14123 const char *mnemonic
;
14125 FETCH_DATA (the_info
, codep
+ 1);
14126 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14127 place where an 8-bit immediate would normally go. ie. the last
14128 byte of the instruction. */
14129 obufp
= mnemonicendp
;
14130 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
14132 oappend (mnemonic
);
14135 /* Since a variable sized modrm/sib chunk is between the start
14136 of the opcode (0x0f0f) and the opcode suffix, we need to do
14137 all the modrm processing first, and don't know until now that
14138 we have a bad opcode. This necessitates some cleaning up. */
14139 op_out
[0][0] = '\0';
14140 op_out
[1][0] = '\0';
14143 mnemonicendp
= obufp
;
14146 static struct op simd_cmp_op
[] =
14148 { STRING_COMMA_LEN ("eq") },
14149 { STRING_COMMA_LEN ("lt") },
14150 { STRING_COMMA_LEN ("le") },
14151 { STRING_COMMA_LEN ("unord") },
14152 { STRING_COMMA_LEN ("neq") },
14153 { STRING_COMMA_LEN ("nlt") },
14154 { STRING_COMMA_LEN ("nle") },
14155 { STRING_COMMA_LEN ("ord") }
14159 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14161 unsigned int cmp_type
;
14163 FETCH_DATA (the_info
, codep
+ 1);
14164 cmp_type
= *codep
++ & 0xff;
14165 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
14168 char *p
= mnemonicendp
- 2;
14172 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
14173 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
14177 /* We have a reserved extension byte. Output it directly. */
14178 scratchbuf
[0] = '$';
14179 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14180 oappend (scratchbuf
+ intel_syntax
);
14181 scratchbuf
[0] = '\0';
14186 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
14187 int sizeflag ATTRIBUTE_UNUSED
)
14189 /* mwait %eax,%ecx */
14192 const char **names
= (address_mode
== mode_64bit
14193 ? names64
: names32
);
14194 strcpy (op_out
[0], names
[0]);
14195 strcpy (op_out
[1], names
[1]);
14196 two_source_ops
= 1;
14198 /* Skip mod/rm byte. */
14204 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
14205 int sizeflag ATTRIBUTE_UNUSED
)
14207 /* monitor %eax,%ecx,%edx" */
14210 const char **op1_names
;
14211 const char **names
= (address_mode
== mode_64bit
14212 ? names64
: names32
);
14214 if (!(prefixes
& PREFIX_ADDR
))
14215 op1_names
= (address_mode
== mode_16bit
14216 ? names16
: names
);
14219 /* Remove "addr16/addr32". */
14220 all_prefixes
[last_addr_prefix
] = 0;
14221 op1_names
= (address_mode
!= mode_32bit
14222 ? names32
: names16
);
14223 used_prefixes
|= PREFIX_ADDR
;
14225 strcpy (op_out
[0], op1_names
[0]);
14226 strcpy (op_out
[1], names
[1]);
14227 strcpy (op_out
[2], names
[2]);
14228 two_source_ops
= 1;
14230 /* Skip mod/rm byte. */
14238 /* Throw away prefixes and 1st. opcode byte. */
14239 codep
= insn_codep
+ 1;
14244 REP_Fixup (int bytemode
, int sizeflag
)
14246 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
14248 if (prefixes
& PREFIX_REPZ
)
14249 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
14256 OP_IMREG (bytemode
, sizeflag
);
14259 OP_ESreg (bytemode
, sizeflag
);
14262 OP_DSreg (bytemode
, sizeflag
);
14271 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
14276 /* Change cmpxchg8b to cmpxchg16b. */
14277 char *p
= mnemonicendp
- 2;
14278 mnemonicendp
= stpcpy (p
, "16b");
14281 OP_M (bytemode
, sizeflag
);
14285 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
14287 const char **names
;
14291 switch (vex
.length
)
14305 oappend (names
[reg
]);
14309 CRC32_Fixup (int bytemode
, int sizeflag
)
14311 /* Add proper suffix to "crc32". */
14312 char *p
= mnemonicendp
;
14331 if (sizeflag
& DFLAG
)
14335 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14339 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14346 if (modrm
.mod
== 3)
14350 /* Skip mod/rm byte. */
14355 add
= (rex
& REX_B
) ? 8 : 0;
14356 if (bytemode
== b_mode
)
14360 oappend (names8rex
[modrm
.rm
+ add
]);
14362 oappend (names8
[modrm
.rm
+ add
]);
14368 oappend (names64
[modrm
.rm
+ add
]);
14369 else if ((prefixes
& PREFIX_DATA
))
14370 oappend (names16
[modrm
.rm
+ add
]);
14372 oappend (names32
[modrm
.rm
+ add
]);
14376 OP_E (bytemode
, sizeflag
);
14380 FXSAVE_Fixup (int bytemode
, int sizeflag
)
14382 /* Add proper suffix to "fxsave" and "fxrstor". */
14386 char *p
= mnemonicendp
;
14392 OP_M (bytemode
, sizeflag
);
14395 /* Display the destination register operand for instructions with
14399 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14402 const char **names
;
14410 reg
= vex
.register_specifier
;
14411 if (bytemode
== vex_scalar_mode
)
14413 oappend (names_xmm
[reg
]);
14417 switch (vex
.length
)
14449 oappend (names
[reg
]);
14452 /* Get the VEX immediate byte without moving codep. */
14454 static unsigned char
14455 get_vex_imm8 (int sizeflag
, int opnum
)
14457 int bytes_before_imm
= 0;
14459 if (modrm
.mod
!= 3)
14461 /* There are SIB/displacement bytes. */
14462 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14464 /* 32/64 bit address mode */
14465 int base
= modrm
.rm
;
14467 /* Check SIB byte. */
14470 FETCH_DATA (the_info
, codep
+ 1);
14472 /* When decoding the third source, don't increase
14473 bytes_before_imm as this has already been incremented
14474 by one in OP_E_memory while decoding the second
14477 bytes_before_imm
++;
14480 /* Don't increase bytes_before_imm when decoding the third source,
14481 it has already been incremented by OP_E_memory while decoding
14482 the second source operand. */
14488 /* When modrm.rm == 5 or modrm.rm == 4 and base in
14489 SIB == 5, there is a 4 byte displacement. */
14491 /* No displacement. */
14494 /* 4 byte displacement. */
14495 bytes_before_imm
+= 4;
14498 /* 1 byte displacement. */
14499 bytes_before_imm
++;
14506 /* 16 bit address mode */
14507 /* Don't increase bytes_before_imm when decoding the third source,
14508 it has already been incremented by OP_E_memory while decoding
14509 the second source operand. */
14515 /* When modrm.rm == 6, there is a 2 byte displacement. */
14517 /* No displacement. */
14520 /* 2 byte displacement. */
14521 bytes_before_imm
+= 2;
14524 /* 1 byte displacement: when decoding the third source,
14525 don't increase bytes_before_imm as this has already
14526 been incremented by one in OP_E_memory while decoding
14527 the second source operand. */
14529 bytes_before_imm
++;
14537 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
14538 return codep
[bytes_before_imm
];
14542 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
14544 const char **names
;
14546 if (reg
== -1 && modrm
.mod
!= 3)
14548 OP_E_memory (bytemode
, sizeflag
);
14560 else if (reg
> 7 && address_mode
!= mode_64bit
)
14564 switch (vex
.length
)
14575 oappend (names
[reg
]);
14579 OP_Vex_2src (int bytemode
, int sizeflag
)
14581 if (modrm
.mod
== 3)
14583 int reg
= modrm
.rm
;
14587 oappend (names_xmm
[reg
]);
14592 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14594 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14595 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14597 OP_E (bytemode
, sizeflag
);
14602 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
14604 if (modrm
.mod
== 3)
14606 /* Skip mod/rm byte. */
14612 oappend (names_xmm
[vex
.register_specifier
]);
14614 OP_Vex_2src (bytemode
, sizeflag
);
14618 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
14621 OP_Vex_2src (bytemode
, sizeflag
);
14623 oappend (names_xmm
[vex
.register_specifier
]);
14627 OP_EX_VexW (int bytemode
, int sizeflag
)
14635 /* Skip mod/rm byte. */
14640 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
14645 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
14648 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14652 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14653 int sizeflag ATTRIBUTE_UNUSED
)
14655 /* Skip the immediate byte and check for invalid bits. */
14656 FETCH_DATA (the_info
, codep
+ 1);
14657 if (*codep
++ & 0xf)
14662 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14665 const char **names
;
14667 FETCH_DATA (the_info
, codep
+ 1);
14670 if (bytemode
!= x_mode
)
14677 if (reg
> 7 && address_mode
!= mode_64bit
)
14680 switch (vex
.length
)
14691 oappend (names
[reg
]);
14695 OP_XMM_VexW (int bytemode
, int sizeflag
)
14697 /* Turn off the REX.W bit since it is used for swapping operands
14700 OP_XMM (bytemode
, sizeflag
);
14704 OP_EX_Vex (int bytemode
, int sizeflag
)
14706 if (modrm
.mod
!= 3)
14708 if (vex
.register_specifier
!= 0)
14712 OP_EX (bytemode
, sizeflag
);
14716 OP_XMM_Vex (int bytemode
, int sizeflag
)
14718 if (modrm
.mod
!= 3)
14720 if (vex
.register_specifier
!= 0)
14724 OP_XMM (bytemode
, sizeflag
);
14728 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14730 switch (vex
.length
)
14733 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
14736 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14743 static struct op vex_cmp_op
[] =
14745 { STRING_COMMA_LEN ("eq") },
14746 { STRING_COMMA_LEN ("lt") },
14747 { STRING_COMMA_LEN ("le") },
14748 { STRING_COMMA_LEN ("unord") },
14749 { STRING_COMMA_LEN ("neq") },
14750 { STRING_COMMA_LEN ("nlt") },
14751 { STRING_COMMA_LEN ("nle") },
14752 { STRING_COMMA_LEN ("ord") },
14753 { STRING_COMMA_LEN ("eq_uq") },
14754 { STRING_COMMA_LEN ("nge") },
14755 { STRING_COMMA_LEN ("ngt") },
14756 { STRING_COMMA_LEN ("false") },
14757 { STRING_COMMA_LEN ("neq_oq") },
14758 { STRING_COMMA_LEN ("ge") },
14759 { STRING_COMMA_LEN ("gt") },
14760 { STRING_COMMA_LEN ("true") },
14761 { STRING_COMMA_LEN ("eq_os") },
14762 { STRING_COMMA_LEN ("lt_oq") },
14763 { STRING_COMMA_LEN ("le_oq") },
14764 { STRING_COMMA_LEN ("unord_s") },
14765 { STRING_COMMA_LEN ("neq_us") },
14766 { STRING_COMMA_LEN ("nlt_uq") },
14767 { STRING_COMMA_LEN ("nle_uq") },
14768 { STRING_COMMA_LEN ("ord_s") },
14769 { STRING_COMMA_LEN ("eq_us") },
14770 { STRING_COMMA_LEN ("nge_uq") },
14771 { STRING_COMMA_LEN ("ngt_uq") },
14772 { STRING_COMMA_LEN ("false_os") },
14773 { STRING_COMMA_LEN ("neq_os") },
14774 { STRING_COMMA_LEN ("ge_oq") },
14775 { STRING_COMMA_LEN ("gt_oq") },
14776 { STRING_COMMA_LEN ("true_us") },
14780 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14782 unsigned int cmp_type
;
14784 FETCH_DATA (the_info
, codep
+ 1);
14785 cmp_type
= *codep
++ & 0xff;
14786 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14789 char *p
= mnemonicendp
- 2;
14793 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14794 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14798 /* We have a reserved extension byte. Output it directly. */
14799 scratchbuf
[0] = '$';
14800 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14801 oappend (scratchbuf
+ intel_syntax
);
14802 scratchbuf
[0] = '\0';
14806 static const struct op pclmul_op
[] =
14808 { STRING_COMMA_LEN ("lql") },
14809 { STRING_COMMA_LEN ("hql") },
14810 { STRING_COMMA_LEN ("lqh") },
14811 { STRING_COMMA_LEN ("hqh") }
14815 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14816 int sizeflag ATTRIBUTE_UNUSED
)
14818 unsigned int pclmul_type
;
14820 FETCH_DATA (the_info
, codep
+ 1);
14821 pclmul_type
= *codep
++ & 0xff;
14822 switch (pclmul_type
)
14833 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14836 char *p
= mnemonicendp
- 3;
14841 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14842 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14846 /* We have a reserved extension byte. Output it directly. */
14847 scratchbuf
[0] = '$';
14848 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14849 oappend (scratchbuf
+ intel_syntax
);
14850 scratchbuf
[0] = '\0';
14855 MOVBE_Fixup (int bytemode
, int sizeflag
)
14857 /* Add proper suffix to "movbe". */
14858 char *p
= mnemonicendp
;
14867 if (sizeflag
& SUFFIX_ALWAYS
)
14873 if (sizeflag
& DFLAG
)
14877 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14882 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14889 OP_M (bytemode
, sizeflag
);
14893 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14896 const char **names
;
14898 /* Skip mod/rm byte. */
14904 else if (vex
.length
== 256)
14914 oappend (names
[reg
]);
14918 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14920 const char **names
;
14924 else if (vex
.length
== 256)
14929 oappend (names
[vex
.register_specifier
]);
14933 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
14935 if (vex
.w
|| vex
.length
== 256)
14936 OP_I (q_mode
, sizeflag
);
14938 OP_I (w_mode
, sizeflag
);