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 XMM { OP_XMM, xmm_mode }
338 #define EM { OP_EM, v_mode }
339 #define EMS { OP_EM, v_swap_mode }
340 #define EMd { OP_EM, d_mode }
341 #define EMx { OP_EM, x_mode }
342 #define EXw { OP_EX, w_mode }
343 #define EXd { OP_EX, d_mode }
344 #define EXdS { OP_EX, d_swap_mode }
345 #define EXq { OP_EX, q_mode }
346 #define EXqS { OP_EX, q_swap_mode }
347 #define EXx { OP_EX, x_mode }
348 #define EXxS { OP_EX, x_swap_mode }
349 #define EXxmm { OP_EX, xmm_mode }
350 #define EXxmmq { OP_EX, xmmq_mode }
351 #define EXymmq { OP_EX, ymmq_mode }
352 #define EXVexWdq { OP_EX, vex_w_dq_mode }
353 #define MS { OP_MS, v_mode }
354 #define XS { OP_XS, v_mode }
355 #define EMCq { OP_EMC, q_mode }
356 #define MXC { OP_MXC, 0 }
357 #define OPSUF { OP_3DNowSuffix, 0 }
358 #define CMP { CMP_Fixup, 0 }
359 #define XMM0 { XMM_Fixup, 0 }
360 #define FXSAVE { FXSAVE_Fixup, 0 }
361 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
362 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
364 #define Vex { OP_VEX, vex_mode }
365 #define Vex128 { OP_VEX, vex128_mode }
366 #define Vex256 { OP_VEX, vex256_mode }
367 #define VexI4 { VEXI4_Fixup, 0}
368 #define EXdVex { OP_EX_Vex, d_mode }
369 #define EXdVexS { OP_EX_Vex, d_swap_mode }
370 #define EXqVex { OP_EX_Vex, q_mode }
371 #define EXqVexS { OP_EX_Vex, q_swap_mode }
372 #define EXVexW { OP_EX_VexW, x_mode }
373 #define EXdVexW { OP_EX_VexW, d_mode }
374 #define EXqVexW { OP_EX_VexW, q_mode }
375 #define XMVex { OP_XMM_Vex, 0 }
376 #define XMVexW { OP_XMM_VexW, 0 }
377 #define XMVexI4 { OP_REG_VexI4, x_mode }
378 #define PCLMUL { PCLMUL_Fixup, 0 }
379 #define VZERO { VZERO_Fixup, 0 }
380 #define VCMP { VCMP_Fixup, 0 }
382 /* Used handle "rep" prefix for string instructions. */
383 #define Xbr { REP_Fixup, eSI_reg }
384 #define Xvr { REP_Fixup, eSI_reg }
385 #define Ybr { REP_Fixup, eDI_reg }
386 #define Yvr { REP_Fixup, eDI_reg }
387 #define Yzr { REP_Fixup, eDI_reg }
388 #define indirDXr { REP_Fixup, indir_dx_reg }
389 #define ALr { REP_Fixup, al_reg }
390 #define eAXr { REP_Fixup, eAX_reg }
392 #define cond_jump_flag { NULL, cond_jump_mode }
393 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
395 /* bits in sizeflag */
396 #define SUFFIX_ALWAYS 4
404 /* byte operand with operand swapped */
406 /* operand size depends on prefixes */
408 /* operand size depends on prefixes with operand swapped */
412 /* double word operand */
414 /* double word operand with operand swapped */
416 /* quad word operand */
418 /* quad word operand with operand swapped */
420 /* ten-byte operand */
422 /* 16-byte XMM or 32-byte YMM operand */
424 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
426 /* 16-byte XMM operand */
428 /* 16-byte XMM or quad word operand */
430 /* 32-byte YMM or quad word operand */
432 /* d_mode in 32bit, q_mode in 64bit mode. */
434 /* pair of v_mode operands */
438 /* operand size depends on REX prefixes. */
440 /* registers like dq_mode, memory like w_mode. */
442 /* 4- or 6-byte pointer operand */
445 /* v_mode for stack-related opcodes. */
447 /* non-quad operand size depends on prefixes */
449 /* 16-byte operand */
451 /* registers like dq_mode, memory like b_mode. */
453 /* registers like dq_mode, memory like d_mode. */
455 /* normal vex mode */
457 /* 128bit vex mode */
459 /* 256bit vex mode */
461 /* operand size depends on the VEX.W bit. */
527 #define FLOAT NULL, { { NULL, FLOATCODE } }
529 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
530 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
531 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
532 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
533 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
534 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
535 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
536 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
537 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
538 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
539 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
540 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
658 MOD_VEX_3818_PREFIX_2
,
659 MOD_VEX_3819_PREFIX_2
,
660 MOD_VEX_381A_PREFIX_2
,
661 MOD_VEX_382A_PREFIX_2
,
662 MOD_VEX_382C_PREFIX_2
,
663 MOD_VEX_382D_PREFIX_2
,
664 MOD_VEX_382E_PREFIX_2
,
665 MOD_VEX_382F_PREFIX_2
1075 THREE_BYTE_0F38
= 0,
1230 VEX_LEN_3819_P_2_M_0
,
1231 VEX_LEN_381A_P_2_M_0
,
1243 VEX_LEN_382A_P_2_M_0
,
1559 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1570 /* Upper case letters in the instruction names here are macros.
1571 'A' => print 'b' if no register operands or suffix_always is true
1572 'B' => print 'b' if suffix_always is true
1573 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1575 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1576 suffix_always is true
1577 'E' => print 'e' if 32-bit form of jcxz
1578 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1579 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1580 'H' => print ",pt" or ",pn" branch hint
1581 'I' => honor following macro letter even in Intel mode (implemented only
1582 for some of the macro letters)
1584 'K' => print 'd' or 'q' if rex prefix is present.
1585 'L' => print 'l' if suffix_always is true
1586 'M' => print 'r' if intel_mnemonic is false.
1587 'N' => print 'n' if instruction has no wait "prefix"
1588 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1589 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1590 or suffix_always is true. print 'q' if rex prefix is present.
1591 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1593 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1594 'S' => print 'w', 'l' or 'q' if suffix_always is true
1595 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1596 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1597 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1598 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1599 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1600 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1601 suffix_always is true.
1602 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1603 '!' => change condition from true to false or from false to true.
1604 '%' => add 1 upper case letter to the macro.
1606 2 upper case letter macros:
1607 "XY" => print 'x' or 'y' if no register operands or suffix_always
1609 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1610 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1611 or suffix_always is true
1612 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1613 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1614 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1616 Many of the above letters print nothing in Intel mode. See "putop"
1619 Braces '{' and '}', and vertical bars '|', indicate alternative
1620 mnemonic strings for AT&T and Intel. */
1622 static const struct dis386 dis386
[] = {
1624 { "addB", { Eb
, Gb
} },
1625 { "addS", { Ev
, Gv
} },
1626 { "addB", { Gb
, EbS
} },
1627 { "addS", { Gv
, EvS
} },
1628 { "addB", { AL
, Ib
} },
1629 { "addS", { eAX
, Iv
} },
1630 { X86_64_TABLE (X86_64_06
) },
1631 { X86_64_TABLE (X86_64_07
) },
1633 { "orB", { Eb
, Gb
} },
1634 { "orS", { Ev
, Gv
} },
1635 { "orB", { Gb
, EbS
} },
1636 { "orS", { Gv
, EvS
} },
1637 { "orB", { AL
, Ib
} },
1638 { "orS", { eAX
, Iv
} },
1639 { X86_64_TABLE (X86_64_0D
) },
1640 { Bad_Opcode
}, /* 0x0f extended opcode escape */
1642 { "adcB", { Eb
, Gb
} },
1643 { "adcS", { Ev
, Gv
} },
1644 { "adcB", { Gb
, EbS
} },
1645 { "adcS", { Gv
, EvS
} },
1646 { "adcB", { AL
, Ib
} },
1647 { "adcS", { eAX
, Iv
} },
1648 { X86_64_TABLE (X86_64_16
) },
1649 { X86_64_TABLE (X86_64_17
) },
1651 { "sbbB", { Eb
, Gb
} },
1652 { "sbbS", { Ev
, Gv
} },
1653 { "sbbB", { Gb
, EbS
} },
1654 { "sbbS", { Gv
, EvS
} },
1655 { "sbbB", { AL
, Ib
} },
1656 { "sbbS", { eAX
, Iv
} },
1657 { X86_64_TABLE (X86_64_1E
) },
1658 { X86_64_TABLE (X86_64_1F
) },
1660 { "andB", { Eb
, Gb
} },
1661 { "andS", { Ev
, Gv
} },
1662 { "andB", { Gb
, EbS
} },
1663 { "andS", { Gv
, EvS
} },
1664 { "andB", { AL
, Ib
} },
1665 { "andS", { eAX
, Iv
} },
1666 { Bad_Opcode
}, /* SEG ES prefix */
1667 { X86_64_TABLE (X86_64_27
) },
1669 { "subB", { Eb
, Gb
} },
1670 { "subS", { Ev
, Gv
} },
1671 { "subB", { Gb
, EbS
} },
1672 { "subS", { Gv
, EvS
} },
1673 { "subB", { AL
, Ib
} },
1674 { "subS", { eAX
, Iv
} },
1675 { Bad_Opcode
}, /* SEG CS prefix */
1676 { X86_64_TABLE (X86_64_2F
) },
1678 { "xorB", { Eb
, Gb
} },
1679 { "xorS", { Ev
, Gv
} },
1680 { "xorB", { Gb
, EbS
} },
1681 { "xorS", { Gv
, EvS
} },
1682 { "xorB", { AL
, Ib
} },
1683 { "xorS", { eAX
, Iv
} },
1684 { Bad_Opcode
}, /* SEG SS prefix */
1685 { X86_64_TABLE (X86_64_37
) },
1687 { "cmpB", { Eb
, Gb
} },
1688 { "cmpS", { Ev
, Gv
} },
1689 { "cmpB", { Gb
, EbS
} },
1690 { "cmpS", { Gv
, EvS
} },
1691 { "cmpB", { AL
, Ib
} },
1692 { "cmpS", { eAX
, Iv
} },
1693 { Bad_Opcode
}, /* SEG DS prefix */
1694 { X86_64_TABLE (X86_64_3F
) },
1696 { "inc{S|}", { RMeAX
} },
1697 { "inc{S|}", { RMeCX
} },
1698 { "inc{S|}", { RMeDX
} },
1699 { "inc{S|}", { RMeBX
} },
1700 { "inc{S|}", { RMeSP
} },
1701 { "inc{S|}", { RMeBP
} },
1702 { "inc{S|}", { RMeSI
} },
1703 { "inc{S|}", { RMeDI
} },
1705 { "dec{S|}", { RMeAX
} },
1706 { "dec{S|}", { RMeCX
} },
1707 { "dec{S|}", { RMeDX
} },
1708 { "dec{S|}", { RMeBX
} },
1709 { "dec{S|}", { RMeSP
} },
1710 { "dec{S|}", { RMeBP
} },
1711 { "dec{S|}", { RMeSI
} },
1712 { "dec{S|}", { RMeDI
} },
1714 { "pushV", { RMrAX
} },
1715 { "pushV", { RMrCX
} },
1716 { "pushV", { RMrDX
} },
1717 { "pushV", { RMrBX
} },
1718 { "pushV", { RMrSP
} },
1719 { "pushV", { RMrBP
} },
1720 { "pushV", { RMrSI
} },
1721 { "pushV", { RMrDI
} },
1723 { "popV", { RMrAX
} },
1724 { "popV", { RMrCX
} },
1725 { "popV", { RMrDX
} },
1726 { "popV", { RMrBX
} },
1727 { "popV", { RMrSP
} },
1728 { "popV", { RMrBP
} },
1729 { "popV", { RMrSI
} },
1730 { "popV", { RMrDI
} },
1732 { X86_64_TABLE (X86_64_60
) },
1733 { X86_64_TABLE (X86_64_61
) },
1734 { X86_64_TABLE (X86_64_62
) },
1735 { X86_64_TABLE (X86_64_63
) },
1736 { Bad_Opcode
}, /* seg fs */
1737 { Bad_Opcode
}, /* seg gs */
1738 { Bad_Opcode
}, /* op size prefix */
1739 { Bad_Opcode
}, /* adr size prefix */
1741 { "pushT", { Iq
} },
1742 { "imulS", { Gv
, Ev
, Iv
} },
1743 { "pushT", { sIb
} },
1744 { "imulS", { Gv
, Ev
, sIb
} },
1745 { "ins{b|}", { Ybr
, indirDX
} },
1746 { X86_64_TABLE (X86_64_6D
) },
1747 { "outs{b|}", { indirDXr
, Xb
} },
1748 { X86_64_TABLE (X86_64_6F
) },
1750 { "joH", { Jb
, XX
, cond_jump_flag
} },
1751 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1752 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1753 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1754 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1755 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1756 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1757 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1759 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1760 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1761 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1762 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1763 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1764 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1765 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1766 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1768 { REG_TABLE (REG_80
) },
1769 { REG_TABLE (REG_81
) },
1771 { REG_TABLE (REG_82
) },
1772 { "testB", { Eb
, Gb
} },
1773 { "testS", { Ev
, Gv
} },
1774 { "xchgB", { Eb
, Gb
} },
1775 { "xchgS", { Ev
, Gv
} },
1777 { "movB", { Eb
, Gb
} },
1778 { "movS", { Ev
, Gv
} },
1779 { "movB", { Gb
, EbS
} },
1780 { "movS", { Gv
, EvS
} },
1781 { "movD", { Sv
, Sw
} },
1782 { MOD_TABLE (MOD_8D
) },
1783 { "movD", { Sw
, Sv
} },
1784 { REG_TABLE (REG_8F
) },
1786 { PREFIX_TABLE (PREFIX_90
) },
1787 { "xchgS", { RMeCX
, eAX
} },
1788 { "xchgS", { RMeDX
, eAX
} },
1789 { "xchgS", { RMeBX
, eAX
} },
1790 { "xchgS", { RMeSP
, eAX
} },
1791 { "xchgS", { RMeBP
, eAX
} },
1792 { "xchgS", { RMeSI
, eAX
} },
1793 { "xchgS", { RMeDI
, eAX
} },
1795 { "cW{t|}R", { XX
} },
1796 { "cR{t|}O", { XX
} },
1797 { X86_64_TABLE (X86_64_9A
) },
1798 { Bad_Opcode
}, /* fwait */
1799 { "pushfT", { XX
} },
1800 { "popfT", { XX
} },
1804 { "mov%LB", { AL
, Ob
} },
1805 { "mov%LS", { eAX
, Ov
} },
1806 { "mov%LB", { Ob
, AL
} },
1807 { "mov%LS", { Ov
, eAX
} },
1808 { "movs{b|}", { Ybr
, Xb
} },
1809 { "movs{R|}", { Yvr
, Xv
} },
1810 { "cmps{b|}", { Xb
, Yb
} },
1811 { "cmps{R|}", { Xv
, Yv
} },
1813 { "testB", { AL
, Ib
} },
1814 { "testS", { eAX
, Iv
} },
1815 { "stosB", { Ybr
, AL
} },
1816 { "stosS", { Yvr
, eAX
} },
1817 { "lodsB", { ALr
, Xb
} },
1818 { "lodsS", { eAXr
, Xv
} },
1819 { "scasB", { AL
, Yb
} },
1820 { "scasS", { eAX
, Yv
} },
1822 { "movB", { RMAL
, Ib
} },
1823 { "movB", { RMCL
, Ib
} },
1824 { "movB", { RMDL
, Ib
} },
1825 { "movB", { RMBL
, Ib
} },
1826 { "movB", { RMAH
, Ib
} },
1827 { "movB", { RMCH
, Ib
} },
1828 { "movB", { RMDH
, Ib
} },
1829 { "movB", { RMBH
, Ib
} },
1831 { "mov%LV", { RMeAX
, Iv64
} },
1832 { "mov%LV", { RMeCX
, Iv64
} },
1833 { "mov%LV", { RMeDX
, Iv64
} },
1834 { "mov%LV", { RMeBX
, Iv64
} },
1835 { "mov%LV", { RMeSP
, Iv64
} },
1836 { "mov%LV", { RMeBP
, Iv64
} },
1837 { "mov%LV", { RMeSI
, Iv64
} },
1838 { "mov%LV", { RMeDI
, Iv64
} },
1840 { REG_TABLE (REG_C0
) },
1841 { REG_TABLE (REG_C1
) },
1844 { X86_64_TABLE (X86_64_C4
) },
1845 { X86_64_TABLE (X86_64_C5
) },
1846 { REG_TABLE (REG_C6
) },
1847 { REG_TABLE (REG_C7
) },
1849 { "enterT", { Iw
, Ib
} },
1850 { "leaveT", { XX
} },
1851 { "Jret{|f}P", { Iw
} },
1852 { "Jret{|f}P", { XX
} },
1855 { X86_64_TABLE (X86_64_CE
) },
1856 { "iretP", { XX
} },
1858 { REG_TABLE (REG_D0
) },
1859 { REG_TABLE (REG_D1
) },
1860 { REG_TABLE (REG_D2
) },
1861 { REG_TABLE (REG_D3
) },
1862 { X86_64_TABLE (X86_64_D4
) },
1863 { X86_64_TABLE (X86_64_D5
) },
1865 { "xlat", { DSBX
} },
1876 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1877 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1878 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1879 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1880 { "inB", { AL
, Ib
} },
1881 { "inG", { zAX
, Ib
} },
1882 { "outB", { Ib
, AL
} },
1883 { "outG", { Ib
, zAX
} },
1885 { "callT", { Jv
} },
1887 { X86_64_TABLE (X86_64_EA
) },
1889 { "inB", { AL
, indirDX
} },
1890 { "inG", { zAX
, indirDX
} },
1891 { "outB", { indirDX
, AL
} },
1892 { "outG", { indirDX
, zAX
} },
1894 { Bad_Opcode
}, /* lock prefix */
1895 { "icebp", { XX
} },
1896 { Bad_Opcode
}, /* repne */
1897 { Bad_Opcode
}, /* repz */
1900 { REG_TABLE (REG_F6
) },
1901 { REG_TABLE (REG_F7
) },
1909 { REG_TABLE (REG_FE
) },
1910 { REG_TABLE (REG_FF
) },
1913 static const struct dis386 dis386_twobyte
[] = {
1915 { REG_TABLE (REG_0F00
) },
1916 { REG_TABLE (REG_0F01
) },
1917 { "larS", { Gv
, Ew
} },
1918 { "lslS", { Gv
, Ew
} },
1920 { "syscall", { XX
} },
1922 { "sysretP", { XX
} },
1925 { "wbinvd", { XX
} },
1929 { REG_TABLE (REG_0F0D
) },
1930 { "femms", { XX
} },
1931 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1933 { PREFIX_TABLE (PREFIX_0F10
) },
1934 { PREFIX_TABLE (PREFIX_0F11
) },
1935 { PREFIX_TABLE (PREFIX_0F12
) },
1936 { MOD_TABLE (MOD_0F13
) },
1937 { "unpcklpX", { XM
, EXx
} },
1938 { "unpckhpX", { XM
, EXx
} },
1939 { PREFIX_TABLE (PREFIX_0F16
) },
1940 { MOD_TABLE (MOD_0F17
) },
1942 { REG_TABLE (REG_0F18
) },
1951 { MOD_TABLE (MOD_0F20
) },
1952 { MOD_TABLE (MOD_0F21
) },
1953 { MOD_TABLE (MOD_0F22
) },
1954 { MOD_TABLE (MOD_0F23
) },
1955 { MOD_TABLE (MOD_0F24
) },
1957 { MOD_TABLE (MOD_0F26
) },
1960 { "movapX", { XM
, EXx
} },
1961 { "movapX", { EXxS
, XM
} },
1962 { PREFIX_TABLE (PREFIX_0F2A
) },
1963 { PREFIX_TABLE (PREFIX_0F2B
) },
1964 { PREFIX_TABLE (PREFIX_0F2C
) },
1965 { PREFIX_TABLE (PREFIX_0F2D
) },
1966 { PREFIX_TABLE (PREFIX_0F2E
) },
1967 { PREFIX_TABLE (PREFIX_0F2F
) },
1969 { "wrmsr", { XX
} },
1970 { "rdtsc", { XX
} },
1971 { "rdmsr", { XX
} },
1972 { "rdpmc", { XX
} },
1973 { "sysenter", { XX
} },
1974 { "sysexit", { XX
} },
1976 { "getsec", { XX
} },
1978 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
1980 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
1987 { "cmovoS", { Gv
, Ev
} },
1988 { "cmovnoS", { Gv
, Ev
} },
1989 { "cmovbS", { Gv
, Ev
} },
1990 { "cmovaeS", { Gv
, Ev
} },
1991 { "cmoveS", { Gv
, Ev
} },
1992 { "cmovneS", { Gv
, Ev
} },
1993 { "cmovbeS", { Gv
, Ev
} },
1994 { "cmovaS", { Gv
, Ev
} },
1996 { "cmovsS", { Gv
, Ev
} },
1997 { "cmovnsS", { Gv
, Ev
} },
1998 { "cmovpS", { Gv
, Ev
} },
1999 { "cmovnpS", { Gv
, Ev
} },
2000 { "cmovlS", { Gv
, Ev
} },
2001 { "cmovgeS", { Gv
, Ev
} },
2002 { "cmovleS", { Gv
, Ev
} },
2003 { "cmovgS", { Gv
, Ev
} },
2005 { MOD_TABLE (MOD_0F51
) },
2006 { PREFIX_TABLE (PREFIX_0F51
) },
2007 { PREFIX_TABLE (PREFIX_0F52
) },
2008 { PREFIX_TABLE (PREFIX_0F53
) },
2009 { "andpX", { XM
, EXx
} },
2010 { "andnpX", { XM
, EXx
} },
2011 { "orpX", { XM
, EXx
} },
2012 { "xorpX", { XM
, EXx
} },
2014 { PREFIX_TABLE (PREFIX_0F58
) },
2015 { PREFIX_TABLE (PREFIX_0F59
) },
2016 { PREFIX_TABLE (PREFIX_0F5A
) },
2017 { PREFIX_TABLE (PREFIX_0F5B
) },
2018 { PREFIX_TABLE (PREFIX_0F5C
) },
2019 { PREFIX_TABLE (PREFIX_0F5D
) },
2020 { PREFIX_TABLE (PREFIX_0F5E
) },
2021 { PREFIX_TABLE (PREFIX_0F5F
) },
2023 { PREFIX_TABLE (PREFIX_0F60
) },
2024 { PREFIX_TABLE (PREFIX_0F61
) },
2025 { PREFIX_TABLE (PREFIX_0F62
) },
2026 { "packsswb", { MX
, EM
} },
2027 { "pcmpgtb", { MX
, EM
} },
2028 { "pcmpgtw", { MX
, EM
} },
2029 { "pcmpgtd", { MX
, EM
} },
2030 { "packuswb", { MX
, EM
} },
2032 { "punpckhbw", { MX
, EM
} },
2033 { "punpckhwd", { MX
, EM
} },
2034 { "punpckhdq", { MX
, EM
} },
2035 { "packssdw", { MX
, EM
} },
2036 { PREFIX_TABLE (PREFIX_0F6C
) },
2037 { PREFIX_TABLE (PREFIX_0F6D
) },
2038 { "movK", { MX
, Edq
} },
2039 { PREFIX_TABLE (PREFIX_0F6F
) },
2041 { PREFIX_TABLE (PREFIX_0F70
) },
2042 { REG_TABLE (REG_0F71
) },
2043 { REG_TABLE (REG_0F72
) },
2044 { REG_TABLE (REG_0F73
) },
2045 { "pcmpeqb", { MX
, EM
} },
2046 { "pcmpeqw", { MX
, EM
} },
2047 { "pcmpeqd", { MX
, EM
} },
2050 { PREFIX_TABLE (PREFIX_0F78
) },
2051 { PREFIX_TABLE (PREFIX_0F79
) },
2052 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2054 { PREFIX_TABLE (PREFIX_0F7C
) },
2055 { PREFIX_TABLE (PREFIX_0F7D
) },
2056 { PREFIX_TABLE (PREFIX_0F7E
) },
2057 { PREFIX_TABLE (PREFIX_0F7F
) },
2059 { "joH", { Jv
, XX
, cond_jump_flag
} },
2060 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
2061 { "jbH", { Jv
, XX
, cond_jump_flag
} },
2062 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
2063 { "jeH", { Jv
, XX
, cond_jump_flag
} },
2064 { "jneH", { Jv
, XX
, cond_jump_flag
} },
2065 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
2066 { "jaH", { Jv
, XX
, cond_jump_flag
} },
2068 { "jsH", { Jv
, XX
, cond_jump_flag
} },
2069 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
2070 { "jpH", { Jv
, XX
, cond_jump_flag
} },
2071 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
2072 { "jlH", { Jv
, XX
, cond_jump_flag
} },
2073 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
2074 { "jleH", { Jv
, XX
, cond_jump_flag
} },
2075 { "jgH", { Jv
, XX
, cond_jump_flag
} },
2078 { "setno", { Eb
} },
2080 { "setae", { Eb
} },
2082 { "setne", { Eb
} },
2083 { "setbe", { Eb
} },
2087 { "setns", { Eb
} },
2089 { "setnp", { Eb
} },
2091 { "setge", { Eb
} },
2092 { "setle", { Eb
} },
2095 { "pushT", { fs
} },
2097 { "cpuid", { XX
} },
2098 { "btS", { Ev
, Gv
} },
2099 { "shldS", { Ev
, Gv
, Ib
} },
2100 { "shldS", { Ev
, Gv
, CL
} },
2101 { REG_TABLE (REG_0FA6
) },
2102 { REG_TABLE (REG_0FA7
) },
2104 { "pushT", { gs
} },
2107 { "btsS", { Ev
, Gv
} },
2108 { "shrdS", { Ev
, Gv
, Ib
} },
2109 { "shrdS", { Ev
, Gv
, CL
} },
2110 { REG_TABLE (REG_0FAE
) },
2111 { "imulS", { Gv
, Ev
} },
2113 { "cmpxchgB", { Eb
, Gb
} },
2114 { "cmpxchgS", { Ev
, Gv
} },
2115 { MOD_TABLE (MOD_0FB2
) },
2116 { "btrS", { Ev
, Gv
} },
2117 { MOD_TABLE (MOD_0FB4
) },
2118 { MOD_TABLE (MOD_0FB5
) },
2119 { "movz{bR|x}", { Gv
, Eb
} },
2120 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
2122 { PREFIX_TABLE (PREFIX_0FB8
) },
2124 { REG_TABLE (REG_0FBA
) },
2125 { "btcS", { Ev
, Gv
} },
2126 { "bsfS", { Gv
, Ev
} },
2127 { PREFIX_TABLE (PREFIX_0FBD
) },
2128 { "movs{bR|x}", { Gv
, Eb
} },
2129 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
2131 { "xaddB", { Eb
, Gb
} },
2132 { "xaddS", { Ev
, Gv
} },
2133 { PREFIX_TABLE (PREFIX_0FC2
) },
2134 { PREFIX_TABLE (PREFIX_0FC3
) },
2135 { "pinsrw", { MX
, Edqw
, Ib
} },
2136 { "pextrw", { Gdq
, MS
, Ib
} },
2137 { "shufpX", { XM
, EXx
, Ib
} },
2138 { REG_TABLE (REG_0FC7
) },
2140 { "bswap", { RMeAX
} },
2141 { "bswap", { RMeCX
} },
2142 { "bswap", { RMeDX
} },
2143 { "bswap", { RMeBX
} },
2144 { "bswap", { RMeSP
} },
2145 { "bswap", { RMeBP
} },
2146 { "bswap", { RMeSI
} },
2147 { "bswap", { RMeDI
} },
2149 { PREFIX_TABLE (PREFIX_0FD0
) },
2150 { "psrlw", { MX
, EM
} },
2151 { "psrld", { MX
, EM
} },
2152 { "psrlq", { MX
, EM
} },
2153 { "paddq", { MX
, EM
} },
2154 { "pmullw", { MX
, EM
} },
2155 { PREFIX_TABLE (PREFIX_0FD6
) },
2156 { MOD_TABLE (MOD_0FD7
) },
2158 { "psubusb", { MX
, EM
} },
2159 { "psubusw", { MX
, EM
} },
2160 { "pminub", { MX
, EM
} },
2161 { "pand", { MX
, EM
} },
2162 { "paddusb", { MX
, EM
} },
2163 { "paddusw", { MX
, EM
} },
2164 { "pmaxub", { MX
, EM
} },
2165 { "pandn", { MX
, EM
} },
2167 { "pavgb", { MX
, EM
} },
2168 { "psraw", { MX
, EM
} },
2169 { "psrad", { MX
, EM
} },
2170 { "pavgw", { MX
, EM
} },
2171 { "pmulhuw", { MX
, EM
} },
2172 { "pmulhw", { MX
, EM
} },
2173 { PREFIX_TABLE (PREFIX_0FE6
) },
2174 { PREFIX_TABLE (PREFIX_0FE7
) },
2176 { "psubsb", { MX
, EM
} },
2177 { "psubsw", { MX
, EM
} },
2178 { "pminsw", { MX
, EM
} },
2179 { "por", { MX
, EM
} },
2180 { "paddsb", { MX
, EM
} },
2181 { "paddsw", { MX
, EM
} },
2182 { "pmaxsw", { MX
, EM
} },
2183 { "pxor", { MX
, EM
} },
2185 { PREFIX_TABLE (PREFIX_0FF0
) },
2186 { "psllw", { MX
, EM
} },
2187 { "pslld", { MX
, EM
} },
2188 { "psllq", { MX
, EM
} },
2189 { "pmuludq", { MX
, EM
} },
2190 { "pmaddwd", { MX
, EM
} },
2191 { "psadbw", { MX
, EM
} },
2192 { PREFIX_TABLE (PREFIX_0FF7
) },
2194 { "psubb", { MX
, EM
} },
2195 { "psubw", { MX
, EM
} },
2196 { "psubd", { MX
, EM
} },
2197 { "psubq", { MX
, EM
} },
2198 { "paddb", { MX
, EM
} },
2199 { "paddw", { MX
, EM
} },
2200 { "paddd", { MX
, EM
} },
2204 static const unsigned char onebyte_has_modrm
[256] = {
2205 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2206 /* ------------------------------- */
2207 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2208 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2209 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2210 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2211 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2212 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2213 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2214 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2215 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2216 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2217 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2218 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2219 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2220 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2221 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2222 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2223 /* ------------------------------- */
2224 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2227 static const unsigned char twobyte_has_modrm
[256] = {
2228 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2229 /* ------------------------------- */
2230 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2231 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2232 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2233 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2234 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2235 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2236 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2237 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2238 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2239 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2240 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2241 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2242 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2243 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2244 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2245 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2246 /* ------------------------------- */
2247 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2250 static char obuf
[100];
2252 static char *mnemonicendp
;
2253 static char scratchbuf
[100];
2254 static unsigned char *start_codep
;
2255 static unsigned char *insn_codep
;
2256 static unsigned char *codep
;
2257 static int last_lock_prefix
;
2258 static int last_repz_prefix
;
2259 static int last_repnz_prefix
;
2260 static int last_data_prefix
;
2261 static int last_addr_prefix
;
2262 static int last_rex_prefix
;
2263 static int last_seg_prefix
;
2264 #define MAX_CODE_LENGTH 15
2265 /* We can up to 14 prefixes since the maximum instruction length is
2267 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2268 static disassemble_info
*the_info
;
2276 static unsigned char need_modrm
;
2279 int register_specifier
;
2285 static unsigned char need_vex
;
2286 static unsigned char need_vex_reg
;
2287 static unsigned char vex_w_done
;
2295 /* If we are accessing mod/rm/reg without need_modrm set, then the
2296 values are stale. Hitting this abort likely indicates that you
2297 need to update onebyte_has_modrm or twobyte_has_modrm. */
2298 #define MODRM_CHECK if (!need_modrm) abort ()
2300 static const char **names64
;
2301 static const char **names32
;
2302 static const char **names16
;
2303 static const char **names8
;
2304 static const char **names8rex
;
2305 static const char **names_seg
;
2306 static const char *index64
;
2307 static const char *index32
;
2308 static const char **index16
;
2310 static const char *intel_names64
[] = {
2311 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2312 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2314 static const char *intel_names32
[] = {
2315 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2316 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2318 static const char *intel_names16
[] = {
2319 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2320 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2322 static const char *intel_names8
[] = {
2323 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2325 static const char *intel_names8rex
[] = {
2326 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2327 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2329 static const char *intel_names_seg
[] = {
2330 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2332 static const char *intel_index64
= "riz";
2333 static const char *intel_index32
= "eiz";
2334 static const char *intel_index16
[] = {
2335 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2338 static const char *att_names64
[] = {
2339 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2340 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2342 static const char *att_names32
[] = {
2343 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2344 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2346 static const char *att_names16
[] = {
2347 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2348 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2350 static const char *att_names8
[] = {
2351 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2353 static const char *att_names8rex
[] = {
2354 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2355 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2357 static const char *att_names_seg
[] = {
2358 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2360 static const char *att_index64
= "%riz";
2361 static const char *att_index32
= "%eiz";
2362 static const char *att_index16
[] = {
2363 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2366 static const char **names_mm
;
2367 static const char *intel_names_mm
[] = {
2368 "mm0", "mm1", "mm2", "mm3",
2369 "mm4", "mm5", "mm6", "mm7"
2371 static const char *att_names_mm
[] = {
2372 "%mm0", "%mm1", "%mm2", "%mm3",
2373 "%mm4", "%mm5", "%mm6", "%mm7"
2376 static const char **names_xmm
;
2377 static const char *intel_names_xmm
[] = {
2378 "xmm0", "xmm1", "xmm2", "xmm3",
2379 "xmm4", "xmm5", "xmm6", "xmm7",
2380 "xmm8", "xmm9", "xmm10", "xmm11",
2381 "xmm12", "xmm13", "xmm14", "xmm15"
2383 static const char *att_names_xmm
[] = {
2384 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2385 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
2386 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
2387 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
2390 static const char **names_ymm
;
2391 static const char *intel_names_ymm
[] = {
2392 "ymm0", "ymm1", "ymm2", "ymm3",
2393 "ymm4", "ymm5", "ymm6", "ymm7",
2394 "ymm8", "ymm9", "ymm10", "ymm11",
2395 "ymm12", "ymm13", "ymm14", "ymm15"
2397 static const char *att_names_ymm
[] = {
2398 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
2399 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
2400 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
2401 "%ymm12", "%ymm13", "%ymm14", "%ymm15"
2404 static const struct dis386 reg_table
[][8] = {
2407 { "addA", { Eb
, Ib
} },
2408 { "orA", { Eb
, Ib
} },
2409 { "adcA", { Eb
, Ib
} },
2410 { "sbbA", { Eb
, Ib
} },
2411 { "andA", { Eb
, Ib
} },
2412 { "subA", { Eb
, Ib
} },
2413 { "xorA", { Eb
, Ib
} },
2414 { "cmpA", { Eb
, Ib
} },
2418 { "addQ", { Ev
, Iv
} },
2419 { "orQ", { Ev
, Iv
} },
2420 { "adcQ", { Ev
, Iv
} },
2421 { "sbbQ", { Ev
, Iv
} },
2422 { "andQ", { Ev
, Iv
} },
2423 { "subQ", { Ev
, Iv
} },
2424 { "xorQ", { Ev
, Iv
} },
2425 { "cmpQ", { Ev
, Iv
} },
2429 { "addQ", { Ev
, sIb
} },
2430 { "orQ", { Ev
, sIb
} },
2431 { "adcQ", { Ev
, sIb
} },
2432 { "sbbQ", { Ev
, sIb
} },
2433 { "andQ", { Ev
, sIb
} },
2434 { "subQ", { Ev
, sIb
} },
2435 { "xorQ", { Ev
, sIb
} },
2436 { "cmpQ", { Ev
, sIb
} },
2440 { "popU", { stackEv
} },
2441 { XOP_8F_TABLE (XOP_09
) },
2445 { XOP_8F_TABLE (XOP_09
) },
2449 { "rolA", { Eb
, Ib
} },
2450 { "rorA", { Eb
, Ib
} },
2451 { "rclA", { Eb
, Ib
} },
2452 { "rcrA", { Eb
, Ib
} },
2453 { "shlA", { Eb
, Ib
} },
2454 { "shrA", { Eb
, Ib
} },
2456 { "sarA", { Eb
, Ib
} },
2460 { "rolQ", { Ev
, Ib
} },
2461 { "rorQ", { Ev
, Ib
} },
2462 { "rclQ", { Ev
, Ib
} },
2463 { "rcrQ", { Ev
, Ib
} },
2464 { "shlQ", { Ev
, Ib
} },
2465 { "shrQ", { Ev
, Ib
} },
2467 { "sarQ", { Ev
, Ib
} },
2471 { "movA", { Eb
, Ib
} },
2475 { "movQ", { Ev
, Iv
} },
2479 { "rolA", { Eb
, I1
} },
2480 { "rorA", { Eb
, I1
} },
2481 { "rclA", { Eb
, I1
} },
2482 { "rcrA", { Eb
, I1
} },
2483 { "shlA", { Eb
, I1
} },
2484 { "shrA", { Eb
, I1
} },
2486 { "sarA", { Eb
, I1
} },
2490 { "rolQ", { Ev
, I1
} },
2491 { "rorQ", { Ev
, I1
} },
2492 { "rclQ", { Ev
, I1
} },
2493 { "rcrQ", { Ev
, I1
} },
2494 { "shlQ", { Ev
, I1
} },
2495 { "shrQ", { Ev
, I1
} },
2497 { "sarQ", { Ev
, I1
} },
2501 { "rolA", { Eb
, CL
} },
2502 { "rorA", { Eb
, CL
} },
2503 { "rclA", { Eb
, CL
} },
2504 { "rcrA", { Eb
, CL
} },
2505 { "shlA", { Eb
, CL
} },
2506 { "shrA", { Eb
, CL
} },
2508 { "sarA", { Eb
, CL
} },
2512 { "rolQ", { Ev
, CL
} },
2513 { "rorQ", { Ev
, CL
} },
2514 { "rclQ", { Ev
, CL
} },
2515 { "rcrQ", { Ev
, CL
} },
2516 { "shlQ", { Ev
, CL
} },
2517 { "shrQ", { Ev
, CL
} },
2519 { "sarQ", { Ev
, CL
} },
2523 { "testA", { Eb
, Ib
} },
2527 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2528 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2529 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2530 { "idivA", { Eb
} }, /* and idiv for consistency. */
2534 { "testQ", { Ev
, Iv
} },
2538 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2539 { "imulQ", { Ev
} },
2541 { "idivQ", { Ev
} },
2552 { "callT", { indirEv
} },
2553 { "JcallT", { indirEp
} },
2554 { "jmpT", { indirEv
} },
2555 { "JjmpT", { indirEp
} },
2556 { "pushU", { stackEv
} },
2561 { "sldtD", { Sv
} },
2572 { MOD_TABLE (MOD_0F01_REG_0
) },
2573 { MOD_TABLE (MOD_0F01_REG_1
) },
2574 { MOD_TABLE (MOD_0F01_REG_2
) },
2575 { MOD_TABLE (MOD_0F01_REG_3
) },
2576 { "smswD", { Sv
} },
2579 { MOD_TABLE (MOD_0F01_REG_7
) },
2583 { "prefetch", { Eb
} },
2584 { "prefetchw", { Eb
} },
2588 { MOD_TABLE (MOD_0F18_REG_0
) },
2589 { MOD_TABLE (MOD_0F18_REG_1
) },
2590 { MOD_TABLE (MOD_0F18_REG_2
) },
2591 { MOD_TABLE (MOD_0F18_REG_3
) },
2597 { MOD_TABLE (MOD_0F71_REG_2
) },
2599 { MOD_TABLE (MOD_0F71_REG_4
) },
2601 { MOD_TABLE (MOD_0F71_REG_6
) },
2607 { MOD_TABLE (MOD_0F72_REG_2
) },
2609 { MOD_TABLE (MOD_0F72_REG_4
) },
2611 { MOD_TABLE (MOD_0F72_REG_6
) },
2617 { MOD_TABLE (MOD_0F73_REG_2
) },
2618 { MOD_TABLE (MOD_0F73_REG_3
) },
2621 { MOD_TABLE (MOD_0F73_REG_6
) },
2622 { MOD_TABLE (MOD_0F73_REG_7
) },
2626 { "montmul", { { OP_0f07
, 0 } } },
2627 { "xsha1", { { OP_0f07
, 0 } } },
2628 { "xsha256", { { OP_0f07
, 0 } } },
2632 { "xstore-rng", { { OP_0f07
, 0 } } },
2633 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2634 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2635 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2636 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2637 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2641 { MOD_TABLE (MOD_0FAE_REG_0
) },
2642 { MOD_TABLE (MOD_0FAE_REG_1
) },
2643 { MOD_TABLE (MOD_0FAE_REG_2
) },
2644 { MOD_TABLE (MOD_0FAE_REG_3
) },
2645 { MOD_TABLE (MOD_0FAE_REG_4
) },
2646 { MOD_TABLE (MOD_0FAE_REG_5
) },
2647 { MOD_TABLE (MOD_0FAE_REG_6
) },
2648 { MOD_TABLE (MOD_0FAE_REG_7
) },
2656 { "btQ", { Ev
, Ib
} },
2657 { "btsQ", { Ev
, Ib
} },
2658 { "btrQ", { Ev
, Ib
} },
2659 { "btcQ", { Ev
, Ib
} },
2664 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2669 { MOD_TABLE (MOD_0FC7_REG_6
) },
2670 { MOD_TABLE (MOD_0FC7_REG_7
) },
2676 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2678 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2680 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2686 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2688 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2690 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2696 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2697 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2700 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2701 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2707 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2708 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2712 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2713 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2717 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2718 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2722 static const struct dis386 prefix_table
[][4] = {
2725 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2726 { "pause", { XX
} },
2727 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2732 { "movups", { XM
, EXx
} },
2733 { "movss", { XM
, EXd
} },
2734 { "movupd", { XM
, EXx
} },
2735 { "movsd", { XM
, EXq
} },
2740 { "movups", { EXxS
, XM
} },
2741 { "movss", { EXdS
, XM
} },
2742 { "movupd", { EXxS
, XM
} },
2743 { "movsd", { EXqS
, XM
} },
2748 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2749 { "movsldup", { XM
, EXx
} },
2750 { "movlpd", { XM
, EXq
} },
2751 { "movddup", { XM
, EXq
} },
2756 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2757 { "movshdup", { XM
, EXx
} },
2758 { "movhpd", { XM
, EXq
} },
2763 { "cvtpi2ps", { XM
, EMCq
} },
2764 { "cvtsi2ss%LQ", { XM
, Ev
} },
2765 { "cvtpi2pd", { XM
, EMCq
} },
2766 { "cvtsi2sd%LQ", { XM
, Ev
} },
2771 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2772 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2773 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2774 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2779 { "cvttps2pi", { MXC
, EXq
} },
2780 { "cvttss2siY", { Gv
, EXd
} },
2781 { "cvttpd2pi", { MXC
, EXx
} },
2782 { "cvttsd2siY", { Gv
, EXq
} },
2787 { "cvtps2pi", { MXC
, EXq
} },
2788 { "cvtss2siY", { Gv
, EXd
} },
2789 { "cvtpd2pi", { MXC
, EXx
} },
2790 { "cvtsd2siY", { Gv
, EXq
} },
2795 { "ucomiss",{ XM
, EXd
} },
2797 { "ucomisd",{ XM
, EXq
} },
2802 { "comiss", { XM
, EXd
} },
2804 { "comisd", { XM
, EXq
} },
2809 { "sqrtps", { XM
, EXx
} },
2810 { "sqrtss", { XM
, EXd
} },
2811 { "sqrtpd", { XM
, EXx
} },
2812 { "sqrtsd", { XM
, EXq
} },
2817 { "rsqrtps",{ XM
, EXx
} },
2818 { "rsqrtss",{ XM
, EXd
} },
2823 { "rcpps", { XM
, EXx
} },
2824 { "rcpss", { XM
, EXd
} },
2829 { "addps", { XM
, EXx
} },
2830 { "addss", { XM
, EXd
} },
2831 { "addpd", { XM
, EXx
} },
2832 { "addsd", { XM
, EXq
} },
2837 { "mulps", { XM
, EXx
} },
2838 { "mulss", { XM
, EXd
} },
2839 { "mulpd", { XM
, EXx
} },
2840 { "mulsd", { XM
, EXq
} },
2845 { "cvtps2pd", { XM
, EXq
} },
2846 { "cvtss2sd", { XM
, EXd
} },
2847 { "cvtpd2ps", { XM
, EXx
} },
2848 { "cvtsd2ss", { XM
, EXq
} },
2853 { "cvtdq2ps", { XM
, EXx
} },
2854 { "cvttps2dq", { XM
, EXx
} },
2855 { "cvtps2dq", { XM
, EXx
} },
2860 { "subps", { XM
, EXx
} },
2861 { "subss", { XM
, EXd
} },
2862 { "subpd", { XM
, EXx
} },
2863 { "subsd", { XM
, EXq
} },
2868 { "minps", { XM
, EXx
} },
2869 { "minss", { XM
, EXd
} },
2870 { "minpd", { XM
, EXx
} },
2871 { "minsd", { XM
, EXq
} },
2876 { "divps", { XM
, EXx
} },
2877 { "divss", { XM
, EXd
} },
2878 { "divpd", { XM
, EXx
} },
2879 { "divsd", { XM
, EXq
} },
2884 { "maxps", { XM
, EXx
} },
2885 { "maxss", { XM
, EXd
} },
2886 { "maxpd", { XM
, EXx
} },
2887 { "maxsd", { XM
, EXq
} },
2892 { "punpcklbw",{ MX
, EMd
} },
2894 { "punpcklbw",{ MX
, EMx
} },
2899 { "punpcklwd",{ MX
, EMd
} },
2901 { "punpcklwd",{ MX
, EMx
} },
2906 { "punpckldq",{ MX
, EMd
} },
2908 { "punpckldq",{ MX
, EMx
} },
2915 { "punpcklqdq", { XM
, EXx
} },
2922 { "punpckhqdq", { XM
, EXx
} },
2927 { "movq", { MX
, EM
} },
2928 { "movdqu", { XM
, EXx
} },
2929 { "movdqa", { XM
, EXx
} },
2934 { "pshufw", { MX
, EM
, Ib
} },
2935 { "pshufhw",{ XM
, EXx
, Ib
} },
2936 { "pshufd", { XM
, EXx
, Ib
} },
2937 { "pshuflw",{ XM
, EXx
, Ib
} },
2940 /* PREFIX_0F73_REG_3 */
2944 { "psrldq", { XS
, Ib
} },
2947 /* PREFIX_0F73_REG_7 */
2951 { "pslldq", { XS
, Ib
} },
2956 {"vmread", { Em
, Gm
} },
2958 {"extrq", { XS
, Ib
, Ib
} },
2959 {"insertq", { XM
, XS
, Ib
, Ib
} },
2964 {"vmwrite", { Gm
, Em
} },
2966 {"extrq", { XM
, XS
} },
2967 {"insertq", { XM
, XS
} },
2974 { "haddpd", { XM
, EXx
} },
2975 { "haddps", { XM
, EXx
} },
2982 { "hsubpd", { XM
, EXx
} },
2983 { "hsubps", { XM
, EXx
} },
2988 { "movK", { Edq
, MX
} },
2989 { "movq", { XM
, EXq
} },
2990 { "movK", { Edq
, XM
} },
2995 { "movq", { EMS
, MX
} },
2996 { "movdqu", { EXxS
, XM
} },
2997 { "movdqa", { EXxS
, XM
} },
3003 { "popcntS", { Gv
, Ev
} },
3008 { "bsrS", { Gv
, Ev
} },
3009 { "lzcntS", { Gv
, Ev
} },
3010 { "bsrS", { Gv
, Ev
} },
3015 { "cmpps", { XM
, EXx
, CMP
} },
3016 { "cmpss", { XM
, EXd
, CMP
} },
3017 { "cmppd", { XM
, EXx
, CMP
} },
3018 { "cmpsd", { XM
, EXq
, CMP
} },
3023 { "movntiS", { Ma
, Gv
} },
3026 /* PREFIX_0FC7_REG_6 */
3028 { "vmptrld",{ Mq
} },
3029 { "vmxon", { Mq
} },
3030 { "vmclear",{ Mq
} },
3037 { "addsubpd", { XM
, EXx
} },
3038 { "addsubps", { XM
, EXx
} },
3044 { "movq2dq",{ XM
, MS
} },
3045 { "movq", { EXqS
, XM
} },
3046 { "movdq2q",{ MX
, XS
} },
3052 { "cvtdq2pd", { XM
, EXq
} },
3053 { "cvttpd2dq", { XM
, EXx
} },
3054 { "cvtpd2dq", { XM
, EXx
} },
3059 { "movntq", { Mq
, MX
} },
3061 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
3069 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
3074 { "maskmovq", { MX
, MS
} },
3076 { "maskmovdqu", { XM
, XS
} },
3083 { "pblendvb", { XM
, EXx
, XMM0
} },
3090 { "blendvps", { XM
, EXx
, XMM0
} },
3097 { "blendvpd", { XM
, EXx
, XMM0
} },
3104 { "ptest", { XM
, EXx
} },
3111 { "pmovsxbw", { XM
, EXq
} },
3118 { "pmovsxbd", { XM
, EXd
} },
3125 { "pmovsxbq", { XM
, EXw
} },
3132 { "pmovsxwd", { XM
, EXq
} },
3139 { "pmovsxwq", { XM
, EXd
} },
3146 { "pmovsxdq", { XM
, EXq
} },
3153 { "pmuldq", { XM
, EXx
} },
3160 { "pcmpeqq", { XM
, EXx
} },
3167 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
3174 { "packusdw", { XM
, EXx
} },
3181 { "pmovzxbw", { XM
, EXq
} },
3188 { "pmovzxbd", { XM
, EXd
} },
3195 { "pmovzxbq", { XM
, EXw
} },
3202 { "pmovzxwd", { XM
, EXq
} },
3209 { "pmovzxwq", { XM
, EXd
} },
3216 { "pmovzxdq", { XM
, EXq
} },
3223 { "pcmpgtq", { XM
, EXx
} },
3230 { "pminsb", { XM
, EXx
} },
3237 { "pminsd", { XM
, EXx
} },
3244 { "pminuw", { XM
, EXx
} },
3251 { "pminud", { XM
, EXx
} },
3258 { "pmaxsb", { XM
, EXx
} },
3265 { "pmaxsd", { XM
, EXx
} },
3272 { "pmaxuw", { XM
, EXx
} },
3279 { "pmaxud", { XM
, EXx
} },
3286 { "pmulld", { XM
, EXx
} },
3293 { "phminposuw", { XM
, EXx
} },
3300 { "invept", { Gm
, Mo
} },
3307 { "invvpid", { Gm
, Mo
} },
3314 { "aesimc", { XM
, EXx
} },
3321 { "aesenc", { XM
, EXx
} },
3328 { "aesenclast", { XM
, EXx
} },
3335 { "aesdec", { XM
, EXx
} },
3342 { "aesdeclast", { XM
, EXx
} },
3347 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3349 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3350 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3355 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3357 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3358 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3365 { "roundps", { XM
, EXx
, Ib
} },
3372 { "roundpd", { XM
, EXx
, Ib
} },
3379 { "roundss", { XM
, EXd
, Ib
} },
3386 { "roundsd", { XM
, EXq
, Ib
} },
3393 { "blendps", { XM
, EXx
, Ib
} },
3400 { "blendpd", { XM
, EXx
, Ib
} },
3407 { "pblendw", { XM
, EXx
, Ib
} },
3414 { "pextrb", { Edqb
, XM
, Ib
} },
3421 { "pextrw", { Edqw
, XM
, Ib
} },
3428 { "pextrK", { Edq
, XM
, Ib
} },
3435 { "extractps", { Edqd
, XM
, Ib
} },
3442 { "pinsrb", { XM
, Edqb
, Ib
} },
3449 { "insertps", { XM
, EXd
, Ib
} },
3456 { "pinsrK", { XM
, Edq
, Ib
} },
3463 { "dpps", { XM
, EXx
, Ib
} },
3470 { "dppd", { XM
, EXx
, Ib
} },
3477 { "mpsadbw", { XM
, EXx
, Ib
} },
3484 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3491 { "pcmpestrm", { XM
, EXx
, Ib
} },
3498 { "pcmpestri", { XM
, EXx
, Ib
} },
3505 { "pcmpistrm", { XM
, EXx
, Ib
} },
3512 { "pcmpistri", { XM
, EXx
, Ib
} },
3519 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3524 { VEX_W_TABLE (VEX_W_10_P_0
) },
3525 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3526 { VEX_W_TABLE (VEX_W_10_P_2
) },
3527 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3532 { VEX_W_TABLE (VEX_W_11_P_0
) },
3533 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3534 { VEX_W_TABLE (VEX_W_11_P_2
) },
3535 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3540 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3541 { VEX_W_TABLE (VEX_W_12_P_1
) },
3542 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3543 { VEX_W_TABLE (VEX_W_12_P_3
) },
3548 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3549 { VEX_W_TABLE (VEX_W_16_P_1
) },
3550 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3556 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3558 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3564 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3566 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3572 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3574 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3579 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3581 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3586 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3588 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3593 { VEX_W_TABLE (VEX_W_51_P_0
) },
3594 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3595 { VEX_W_TABLE (VEX_W_51_P_2
) },
3596 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3601 { VEX_W_TABLE (VEX_W_52_P_0
) },
3602 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3607 { VEX_W_TABLE (VEX_W_53_P_0
) },
3608 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3613 { VEX_W_TABLE (VEX_W_58_P_0
) },
3614 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3615 { VEX_W_TABLE (VEX_W_58_P_2
) },
3616 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3621 { VEX_W_TABLE (VEX_W_59_P_0
) },
3622 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3623 { VEX_W_TABLE (VEX_W_59_P_2
) },
3624 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3629 { VEX_W_TABLE (VEX_W_5A_P_0
) },
3630 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3631 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3632 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3637 { VEX_W_TABLE (VEX_W_5B_P_0
) },
3638 { VEX_W_TABLE (VEX_W_5B_P_1
) },
3639 { VEX_W_TABLE (VEX_W_5B_P_2
) },
3644 { VEX_W_TABLE (VEX_W_5C_P_0
) },
3645 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3646 { VEX_W_TABLE (VEX_W_5C_P_2
) },
3647 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3652 { VEX_W_TABLE (VEX_W_5D_P_0
) },
3653 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3654 { VEX_W_TABLE (VEX_W_5D_P_2
) },
3655 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3660 { VEX_W_TABLE (VEX_W_5E_P_0
) },
3661 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3662 { VEX_W_TABLE (VEX_W_5E_P_2
) },
3663 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3668 { VEX_W_TABLE (VEX_W_5F_P_0
) },
3669 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3670 { VEX_W_TABLE (VEX_W_5F_P_2
) },
3671 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3678 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3685 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3692 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3699 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3706 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3713 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3720 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3727 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3734 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3741 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3748 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3755 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3762 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3769 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3776 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3782 { VEX_W_TABLE (VEX_W_6F_P_1
) },
3783 { VEX_W_TABLE (VEX_W_6F_P_2
) },
3789 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3790 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3791 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3794 /* PREFIX_VEX_71_REG_2 */
3798 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3801 /* PREFIX_VEX_71_REG_4 */
3805 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3808 /* PREFIX_VEX_71_REG_6 */
3812 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3815 /* PREFIX_VEX_72_REG_2 */
3819 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3822 /* PREFIX_VEX_72_REG_4 */
3826 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3829 /* PREFIX_VEX_72_REG_6 */
3833 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3836 /* PREFIX_VEX_73_REG_2 */
3840 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3843 /* PREFIX_VEX_73_REG_3 */
3847 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3850 /* PREFIX_VEX_73_REG_6 */
3854 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3857 /* PREFIX_VEX_73_REG_7 */
3861 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3868 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3875 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3882 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3887 { VEX_W_TABLE (VEX_W_77_P_0
) },
3894 { VEX_W_TABLE (VEX_W_7C_P_2
) },
3895 { VEX_W_TABLE (VEX_W_7C_P_3
) },
3902 { VEX_W_TABLE (VEX_W_7D_P_2
) },
3903 { VEX_W_TABLE (VEX_W_7D_P_3
) },
3909 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3910 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3916 { VEX_W_TABLE (VEX_W_7F_P_1
) },
3917 { VEX_W_TABLE (VEX_W_7F_P_2
) },
3922 { VEX_W_TABLE (VEX_W_C2_P_0
) },
3923 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3924 { VEX_W_TABLE (VEX_W_C2_P_2
) },
3925 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3932 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3939 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3946 { VEX_W_TABLE (VEX_W_D0_P_2
) },
3947 { VEX_W_TABLE (VEX_W_D0_P_3
) },
3954 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3961 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3968 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
3975 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
3982 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
3989 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
3996 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
4003 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
4010 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
4017 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
4024 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
4031 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
4038 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
4045 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
4052 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
4059 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
4066 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
4073 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
4080 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
4087 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4094 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4100 { VEX_W_TABLE (VEX_W_E6_P_1
) },
4101 { VEX_W_TABLE (VEX_W_E6_P_2
) },
4102 { VEX_W_TABLE (VEX_W_E6_P_3
) },
4109 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4116 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4123 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4130 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4137 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4144 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4151 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4158 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4165 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4173 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4180 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4187 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4194 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4201 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4208 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4215 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4222 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4229 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4236 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4243 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4250 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4257 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4264 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4271 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4274 /* PREFIX_VEX_3800 */
4278 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4281 /* PREFIX_VEX_3801 */
4285 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4288 /* PREFIX_VEX_3802 */
4292 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4295 /* PREFIX_VEX_3803 */
4299 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4302 /* PREFIX_VEX_3804 */
4306 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4309 /* PREFIX_VEX_3805 */
4313 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4316 /* PREFIX_VEX_3806 */
4320 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4323 /* PREFIX_VEX_3807 */
4327 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4330 /* PREFIX_VEX_3808 */
4334 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4337 /* PREFIX_VEX_3809 */
4341 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4344 /* PREFIX_VEX_380A */
4348 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4351 /* PREFIX_VEX_380B */
4355 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4358 /* PREFIX_VEX_380C */
4362 { VEX_W_TABLE (VEX_W_380C_P_2
) },
4365 /* PREFIX_VEX_380D */
4369 { VEX_W_TABLE (VEX_W_380D_P_2
) },
4372 /* PREFIX_VEX_380E */
4376 { VEX_W_TABLE (VEX_W_380E_P_2
) },
4379 /* PREFIX_VEX_380F */
4383 { VEX_W_TABLE (VEX_W_380F_P_2
) },
4386 /* PREFIX_VEX_3817 */
4390 { VEX_W_TABLE (VEX_W_3817_P_2
) },
4393 /* PREFIX_VEX_3818 */
4397 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4400 /* PREFIX_VEX_3819 */
4404 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4407 /* PREFIX_VEX_381A */
4411 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4414 /* PREFIX_VEX_381C */
4418 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4421 /* PREFIX_VEX_381D */
4425 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4428 /* PREFIX_VEX_381E */
4432 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4435 /* PREFIX_VEX_3820 */
4439 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4443 /* PREFIX_VEX_3821 */
4447 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4450 /* PREFIX_VEX_3822 */
4454 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4457 /* PREFIX_VEX_3823 */
4461 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4464 /* PREFIX_VEX_3824 */
4468 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4471 /* PREFIX_VEX_3825 */
4475 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4478 /* PREFIX_VEX_3828 */
4482 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4485 /* PREFIX_VEX_3829 */
4489 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4492 /* PREFIX_VEX_382A */
4496 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4499 /* PREFIX_VEX_382B */
4503 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4506 /* PREFIX_VEX_382C */
4510 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4513 /* PREFIX_VEX_382D */
4517 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4520 /* PREFIX_VEX_382E */
4524 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4527 /* PREFIX_VEX_382F */
4531 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4534 /* PREFIX_VEX_3830 */
4538 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4541 /* PREFIX_VEX_3831 */
4545 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4548 /* PREFIX_VEX_3832 */
4552 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4555 /* PREFIX_VEX_3833 */
4559 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4562 /* PREFIX_VEX_3834 */
4566 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4569 /* PREFIX_VEX_3835 */
4573 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4576 /* PREFIX_VEX_3837 */
4580 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4583 /* PREFIX_VEX_3838 */
4587 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4590 /* PREFIX_VEX_3839 */
4594 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4597 /* PREFIX_VEX_383A */
4601 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4604 /* PREFIX_VEX_383B */
4608 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4611 /* PREFIX_VEX_383C */
4615 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4618 /* PREFIX_VEX_383D */
4622 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4625 /* PREFIX_VEX_383E */
4629 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4632 /* PREFIX_VEX_383F */
4636 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4639 /* PREFIX_VEX_3840 */
4643 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4646 /* PREFIX_VEX_3841 */
4650 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4653 /* PREFIX_VEX_3896 */
4657 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4660 /* PREFIX_VEX_3897 */
4664 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4667 /* PREFIX_VEX_3898 */
4671 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4674 /* PREFIX_VEX_3899 */
4678 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4681 /* PREFIX_VEX_389A */
4685 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4688 /* PREFIX_VEX_389B */
4692 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4695 /* PREFIX_VEX_389C */
4699 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4702 /* PREFIX_VEX_389D */
4706 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4709 /* PREFIX_VEX_389E */
4713 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4716 /* PREFIX_VEX_389F */
4720 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4723 /* PREFIX_VEX_38A6 */
4727 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4731 /* PREFIX_VEX_38A7 */
4735 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4738 /* PREFIX_VEX_38A8 */
4742 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4745 /* PREFIX_VEX_38A9 */
4749 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4752 /* PREFIX_VEX_38AA */
4756 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4759 /* PREFIX_VEX_38AB */
4763 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4766 /* PREFIX_VEX_38AC */
4770 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4773 /* PREFIX_VEX_38AD */
4777 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4780 /* PREFIX_VEX_38AE */
4784 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4787 /* PREFIX_VEX_38AF */
4791 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4794 /* PREFIX_VEX_38B6 */
4798 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4801 /* PREFIX_VEX_38B7 */
4805 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4808 /* PREFIX_VEX_38B8 */
4812 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4815 /* PREFIX_VEX_38B9 */
4819 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4822 /* PREFIX_VEX_38BA */
4826 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4829 /* PREFIX_VEX_38BB */
4833 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4836 /* PREFIX_VEX_38BC */
4840 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4843 /* PREFIX_VEX_38BD */
4847 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4850 /* PREFIX_VEX_38BE */
4854 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4857 /* PREFIX_VEX_38BF */
4861 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4864 /* PREFIX_VEX_38DB */
4868 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4871 /* PREFIX_VEX_38DC */
4875 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4878 /* PREFIX_VEX_38DD */
4882 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4885 /* PREFIX_VEX_38DE */
4889 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4892 /* PREFIX_VEX_38DF */
4896 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4899 /* PREFIX_VEX_3A04 */
4903 { VEX_W_TABLE (VEX_W_3A04_P_2
) },
4906 /* PREFIX_VEX_3A05 */
4910 { VEX_W_TABLE (VEX_W_3A05_P_2
) },
4913 /* PREFIX_VEX_3A06 */
4917 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4920 /* PREFIX_VEX_3A08 */
4924 { VEX_W_TABLE (VEX_W_3A08_P_2
) },
4927 /* PREFIX_VEX_3A09 */
4931 { VEX_W_TABLE (VEX_W_3A09_P_2
) },
4934 /* PREFIX_VEX_3A0A */
4938 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4941 /* PREFIX_VEX_3A0B */
4945 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4948 /* PREFIX_VEX_3A0C */
4952 { VEX_W_TABLE (VEX_W_3A0C_P_2
) },
4955 /* PREFIX_VEX_3A0D */
4959 { VEX_W_TABLE (VEX_W_3A0D_P_2
) },
4962 /* PREFIX_VEX_3A0E */
4966 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
4969 /* PREFIX_VEX_3A0F */
4973 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
4976 /* PREFIX_VEX_3A14 */
4980 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
4983 /* PREFIX_VEX_3A15 */
4987 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
4990 /* PREFIX_VEX_3A16 */
4994 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
4997 /* PREFIX_VEX_3A17 */
5001 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5004 /* PREFIX_VEX_3A18 */
5008 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5011 /* PREFIX_VEX_3A19 */
5015 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5018 /* PREFIX_VEX_3A20 */
5022 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5025 /* PREFIX_VEX_3A21 */
5029 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5032 /* PREFIX_VEX_3A22 */
5036 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5039 /* PREFIX_VEX_3A40 */
5043 { VEX_W_TABLE (VEX_W_3A40_P_2
) },
5046 /* PREFIX_VEX_3A41 */
5050 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5053 /* PREFIX_VEX_3A42 */
5057 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5060 /* PREFIX_VEX_3A44 */
5064 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5067 /* PREFIX_VEX_3A4A */
5071 { VEX_W_TABLE (VEX_W_3A4A_P_2
) },
5074 /* PREFIX_VEX_3A4B */
5078 { VEX_W_TABLE (VEX_W_3A4B_P_2
) },
5081 /* PREFIX_VEX_3A4C */
5085 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5088 /* PREFIX_VEX_3A5C */
5092 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5095 /* PREFIX_VEX_3A5D */
5099 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5102 /* PREFIX_VEX_3A5E */
5106 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5109 /* PREFIX_VEX_3A5F */
5113 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5116 /* PREFIX_VEX_3A60 */
5120 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5124 /* PREFIX_VEX_3A61 */
5128 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5131 /* PREFIX_VEX_3A62 */
5135 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5138 /* PREFIX_VEX_3A63 */
5142 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5145 /* PREFIX_VEX_3A68 */
5149 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5152 /* PREFIX_VEX_3A69 */
5156 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5159 /* PREFIX_VEX_3A6A */
5163 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5166 /* PREFIX_VEX_3A6B */
5170 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5173 /* PREFIX_VEX_3A6C */
5177 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5180 /* PREFIX_VEX_3A6D */
5184 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5187 /* PREFIX_VEX_3A6E */
5191 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5194 /* PREFIX_VEX_3A6F */
5198 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5201 /* PREFIX_VEX_3A78 */
5205 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5208 /* PREFIX_VEX_3A79 */
5212 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5215 /* PREFIX_VEX_3A7A */
5219 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5222 /* PREFIX_VEX_3A7B */
5226 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5229 /* PREFIX_VEX_3A7C */
5233 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5237 /* PREFIX_VEX_3A7D */
5241 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5244 /* PREFIX_VEX_3A7E */
5248 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5251 /* PREFIX_VEX_3A7F */
5255 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5258 /* PREFIX_VEX_3ADF */
5262 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5267 static const struct dis386 x86_64_table
[][2] = {
5270 { "push{T|}", { es
} },
5275 { "pop{T|}", { es
} },
5280 { "push{T|}", { cs
} },
5285 { "push{T|}", { ss
} },
5290 { "pop{T|}", { ss
} },
5295 { "push{T|}", { ds
} },
5300 { "pop{T|}", { ds
} },
5325 { "pusha{P|}", { XX
} },
5330 { "popa{P|}", { XX
} },
5335 { MOD_TABLE (MOD_62_32BIT
) },
5340 { "arpl", { Ew
, Gw
} },
5341 { "movs{lq|xd}", { Gv
, Ed
} },
5346 { "ins{R|}", { Yzr
, indirDX
} },
5347 { "ins{G|}", { Yzr
, indirDX
} },
5352 { "outs{R|}", { indirDXr
, Xz
} },
5353 { "outs{G|}", { indirDXr
, Xz
} },
5358 { "Jcall{T|}", { Ap
} },
5363 { MOD_TABLE (MOD_C4_32BIT
) },
5364 { VEX_C4_TABLE (VEX_0F
) },
5369 { MOD_TABLE (MOD_C5_32BIT
) },
5370 { VEX_C5_TABLE (VEX_0F
) },
5390 { "Jjmp{T|}", { Ap
} },
5393 /* X86_64_0F01_REG_0 */
5395 { "sgdt{Q|IQ}", { M
} },
5399 /* X86_64_0F01_REG_1 */
5401 { "sidt{Q|IQ}", { M
} },
5405 /* X86_64_0F01_REG_2 */
5407 { "lgdt{Q|Q}", { M
} },
5411 /* X86_64_0F01_REG_3 */
5413 { "lidt{Q|Q}", { M
} },
5418 static const struct dis386 three_byte_table
[][256] = {
5420 /* THREE_BYTE_0F38 */
5423 { "pshufb", { MX
, EM
} },
5424 { "phaddw", { MX
, EM
} },
5425 { "phaddd", { MX
, EM
} },
5426 { "phaddsw", { MX
, EM
} },
5427 { "pmaddubsw", { MX
, EM
} },
5428 { "phsubw", { MX
, EM
} },
5429 { "phsubd", { MX
, EM
} },
5430 { "phsubsw", { MX
, EM
} },
5432 { "psignb", { MX
, EM
} },
5433 { "psignw", { MX
, EM
} },
5434 { "psignd", { MX
, EM
} },
5435 { "pmulhrsw", { MX
, EM
} },
5441 { PREFIX_TABLE (PREFIX_0F3810
) },
5445 { PREFIX_TABLE (PREFIX_0F3814
) },
5446 { PREFIX_TABLE (PREFIX_0F3815
) },
5448 { PREFIX_TABLE (PREFIX_0F3817
) },
5454 { "pabsb", { MX
, EM
} },
5455 { "pabsw", { MX
, EM
} },
5456 { "pabsd", { MX
, EM
} },
5459 { PREFIX_TABLE (PREFIX_0F3820
) },
5460 { PREFIX_TABLE (PREFIX_0F3821
) },
5461 { PREFIX_TABLE (PREFIX_0F3822
) },
5462 { PREFIX_TABLE (PREFIX_0F3823
) },
5463 { PREFIX_TABLE (PREFIX_0F3824
) },
5464 { PREFIX_TABLE (PREFIX_0F3825
) },
5468 { PREFIX_TABLE (PREFIX_0F3828
) },
5469 { PREFIX_TABLE (PREFIX_0F3829
) },
5470 { PREFIX_TABLE (PREFIX_0F382A
) },
5471 { PREFIX_TABLE (PREFIX_0F382B
) },
5477 { PREFIX_TABLE (PREFIX_0F3830
) },
5478 { PREFIX_TABLE (PREFIX_0F3831
) },
5479 { PREFIX_TABLE (PREFIX_0F3832
) },
5480 { PREFIX_TABLE (PREFIX_0F3833
) },
5481 { PREFIX_TABLE (PREFIX_0F3834
) },
5482 { PREFIX_TABLE (PREFIX_0F3835
) },
5484 { PREFIX_TABLE (PREFIX_0F3837
) },
5486 { PREFIX_TABLE (PREFIX_0F3838
) },
5487 { PREFIX_TABLE (PREFIX_0F3839
) },
5488 { PREFIX_TABLE (PREFIX_0F383A
) },
5489 { PREFIX_TABLE (PREFIX_0F383B
) },
5490 { PREFIX_TABLE (PREFIX_0F383C
) },
5491 { PREFIX_TABLE (PREFIX_0F383D
) },
5492 { PREFIX_TABLE (PREFIX_0F383E
) },
5493 { PREFIX_TABLE (PREFIX_0F383F
) },
5495 { PREFIX_TABLE (PREFIX_0F3840
) },
5496 { PREFIX_TABLE (PREFIX_0F3841
) },
5567 { PREFIX_TABLE (PREFIX_0F3880
) },
5568 { PREFIX_TABLE (PREFIX_0F3881
) },
5669 { PREFIX_TABLE (PREFIX_0F38DB
) },
5670 { PREFIX_TABLE (PREFIX_0F38DC
) },
5671 { PREFIX_TABLE (PREFIX_0F38DD
) },
5672 { PREFIX_TABLE (PREFIX_0F38DE
) },
5673 { PREFIX_TABLE (PREFIX_0F38DF
) },
5693 { PREFIX_TABLE (PREFIX_0F38F0
) },
5694 { PREFIX_TABLE (PREFIX_0F38F1
) },
5711 /* THREE_BYTE_0F3A */
5723 { PREFIX_TABLE (PREFIX_0F3A08
) },
5724 { PREFIX_TABLE (PREFIX_0F3A09
) },
5725 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5726 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5727 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5728 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5729 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5730 { "palignr", { MX
, EM
, Ib
} },
5736 { PREFIX_TABLE (PREFIX_0F3A14
) },
5737 { PREFIX_TABLE (PREFIX_0F3A15
) },
5738 { PREFIX_TABLE (PREFIX_0F3A16
) },
5739 { PREFIX_TABLE (PREFIX_0F3A17
) },
5750 { PREFIX_TABLE (PREFIX_0F3A20
) },
5751 { PREFIX_TABLE (PREFIX_0F3A21
) },
5752 { PREFIX_TABLE (PREFIX_0F3A22
) },
5786 { PREFIX_TABLE (PREFIX_0F3A40
) },
5787 { PREFIX_TABLE (PREFIX_0F3A41
) },
5788 { PREFIX_TABLE (PREFIX_0F3A42
) },
5790 { PREFIX_TABLE (PREFIX_0F3A44
) },
5822 { PREFIX_TABLE (PREFIX_0F3A60
) },
5823 { PREFIX_TABLE (PREFIX_0F3A61
) },
5824 { PREFIX_TABLE (PREFIX_0F3A62
) },
5825 { PREFIX_TABLE (PREFIX_0F3A63
) },
5964 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6003 /* THREE_BYTE_0F7A */
6042 { "ptest", { XX
} },
6079 { "phaddbw", { XM
, EXq
} },
6080 { "phaddbd", { XM
, EXq
} },
6081 { "phaddbq", { XM
, EXq
} },
6084 { "phaddwd", { XM
, EXq
} },
6085 { "phaddwq", { XM
, EXq
} },
6090 { "phadddq", { XM
, EXq
} },
6097 { "phaddubw", { XM
, EXq
} },
6098 { "phaddubd", { XM
, EXq
} },
6099 { "phaddubq", { XM
, EXq
} },
6102 { "phadduwd", { XM
, EXq
} },
6103 { "phadduwq", { XM
, EXq
} },
6108 { "phaddudq", { XM
, EXq
} },
6115 { "phsubbw", { XM
, EXq
} },
6116 { "phsubbd", { XM
, EXq
} },
6117 { "phsubbq", { XM
, EXq
} },
6296 static const struct dis386 xop_table
[][256] = {
6449 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6450 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6451 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6459 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6460 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6467 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6468 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6469 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6477 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6478 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6482 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6483 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6486 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6504 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6516 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6517 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6518 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6519 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6529 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6530 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6531 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6532 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6565 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6566 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6567 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6568 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6611 { REG_TABLE (REG_XOP_LWPCB
) },
6735 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
6736 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
6737 { "vfrczss", { XM
, EXd
} },
6738 { "vfrczsd", { XM
, EXq
} },
6753 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6754 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6755 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6756 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6757 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6758 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6759 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6760 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6762 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6763 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6764 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6765 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6808 { "vphaddbw", { XM
, EXxmm
} },
6809 { "vphaddbd", { XM
, EXxmm
} },
6810 { "vphaddbq", { XM
, EXxmm
} },
6813 { "vphaddwd", { XM
, EXxmm
} },
6814 { "vphaddwq", { XM
, EXxmm
} },
6819 { "vphadddq", { XM
, EXxmm
} },
6826 { "vphaddubw", { XM
, EXxmm
} },
6827 { "vphaddubd", { XM
, EXxmm
} },
6828 { "vphaddubq", { XM
, EXxmm
} },
6831 { "vphadduwd", { XM
, EXxmm
} },
6832 { "vphadduwq", { XM
, EXxmm
} },
6837 { "vphaddudq", { XM
, EXxmm
} },
6844 { "vphsubbw", { XM
, EXxmm
} },
6845 { "vphsubwd", { XM
, EXxmm
} },
6846 { "vphsubdq", { XM
, EXxmm
} },
6902 { REG_TABLE (REG_XOP_LWP
) },
7172 static const struct dis386 vex_table
[][256] = {
7194 { PREFIX_TABLE (PREFIX_VEX_10
) },
7195 { PREFIX_TABLE (PREFIX_VEX_11
) },
7196 { PREFIX_TABLE (PREFIX_VEX_12
) },
7197 { MOD_TABLE (MOD_VEX_13
) },
7198 { VEX_W_TABLE (VEX_W_14
) },
7199 { VEX_W_TABLE (VEX_W_15
) },
7200 { PREFIX_TABLE (PREFIX_VEX_16
) },
7201 { MOD_TABLE (MOD_VEX_17
) },
7221 { VEX_W_TABLE (VEX_W_28
) },
7222 { VEX_W_TABLE (VEX_W_29
) },
7223 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7224 { MOD_TABLE (MOD_VEX_2B
) },
7225 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7226 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7227 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7228 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7266 { MOD_TABLE (MOD_VEX_50
) },
7267 { PREFIX_TABLE (PREFIX_VEX_51
) },
7268 { PREFIX_TABLE (PREFIX_VEX_52
) },
7269 { PREFIX_TABLE (PREFIX_VEX_53
) },
7270 { "vandpX", { XM
, Vex
, EXx
} },
7271 { "vandnpX", { XM
, Vex
, EXx
} },
7272 { "vorpX", { XM
, Vex
, EXx
} },
7273 { "vxorpX", { XM
, Vex
, EXx
} },
7275 { PREFIX_TABLE (PREFIX_VEX_58
) },
7276 { PREFIX_TABLE (PREFIX_VEX_59
) },
7277 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7278 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7279 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7280 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7281 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7282 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7284 { PREFIX_TABLE (PREFIX_VEX_60
) },
7285 { PREFIX_TABLE (PREFIX_VEX_61
) },
7286 { PREFIX_TABLE (PREFIX_VEX_62
) },
7287 { PREFIX_TABLE (PREFIX_VEX_63
) },
7288 { PREFIX_TABLE (PREFIX_VEX_64
) },
7289 { PREFIX_TABLE (PREFIX_VEX_65
) },
7290 { PREFIX_TABLE (PREFIX_VEX_66
) },
7291 { PREFIX_TABLE (PREFIX_VEX_67
) },
7293 { PREFIX_TABLE (PREFIX_VEX_68
) },
7294 { PREFIX_TABLE (PREFIX_VEX_69
) },
7295 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7296 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7297 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7298 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7299 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7300 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7302 { PREFIX_TABLE (PREFIX_VEX_70
) },
7303 { REG_TABLE (REG_VEX_71
) },
7304 { REG_TABLE (REG_VEX_72
) },
7305 { REG_TABLE (REG_VEX_73
) },
7306 { PREFIX_TABLE (PREFIX_VEX_74
) },
7307 { PREFIX_TABLE (PREFIX_VEX_75
) },
7308 { PREFIX_TABLE (PREFIX_VEX_76
) },
7309 { PREFIX_TABLE (PREFIX_VEX_77
) },
7315 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7316 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7317 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7318 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7371 { REG_TABLE (REG_VEX_AE
) },
7394 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7396 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7397 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7398 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7410 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7411 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7412 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7413 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7414 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7415 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7416 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7417 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7419 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7420 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7421 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7422 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7423 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7424 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7425 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7426 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7428 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7429 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7430 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7431 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7432 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7433 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7434 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7435 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7437 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7438 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7439 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7440 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7441 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7442 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7443 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7444 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7446 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7447 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7448 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7449 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7450 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7451 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7452 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7453 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7455 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7456 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7457 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7458 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7459 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7460 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7461 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7467 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7468 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7469 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7470 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7471 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7472 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7473 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7474 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7476 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7477 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7478 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7479 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7480 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7481 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7482 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7483 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7492 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7494 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7495 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7496 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7498 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7499 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7500 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7503 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7504 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7505 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7506 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7507 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7508 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7512 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7513 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7514 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7515 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7516 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7517 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7518 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7519 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7521 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7522 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7523 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7524 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7525 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7526 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7528 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7530 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7531 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7532 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7533 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7534 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7535 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7536 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7537 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7539 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7540 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7635 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7636 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7638 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7639 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7640 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7641 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7642 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7643 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7644 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7645 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7653 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7654 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7656 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7657 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7658 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7659 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7660 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7661 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7662 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7663 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7671 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7672 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7674 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7675 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7676 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7677 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7678 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7679 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7680 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7681 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7713 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7714 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7715 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7716 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7717 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7762 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7763 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7764 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7767 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7768 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7769 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7770 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7771 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7772 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7773 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7774 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7780 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7781 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7782 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7783 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7785 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7786 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7794 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7795 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7796 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
7830 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7831 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7832 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7834 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7841 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7842 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7843 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7861 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7862 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7863 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7864 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7866 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7867 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7868 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7869 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7875 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7876 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7877 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7878 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7879 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7880 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7881 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7882 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
7893 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7894 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7895 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7896 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7897 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7898 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7899 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7900 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
8008 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8048 static const struct dis386 vex_len_table
[][2] = {
8049 /* VEX_LEN_10_P_1 */
8051 { VEX_W_TABLE (VEX_W_10_P_1
) },
8054 /* VEX_LEN_10_P_3 */
8056 { VEX_W_TABLE (VEX_W_10_P_3
) },
8059 /* VEX_LEN_11_P_1 */
8061 { VEX_W_TABLE (VEX_W_11_P_1
) },
8064 /* VEX_LEN_11_P_3 */
8066 { VEX_W_TABLE (VEX_W_11_P_3
) },
8069 /* VEX_LEN_12_P_0_M_0 */
8071 { VEX_W_TABLE (VEX_W_12_P_0_M_0
) },
8074 /* VEX_LEN_12_P_0_M_1 */
8076 { VEX_W_TABLE (VEX_W_12_P_0_M_1
) },
8079 /* VEX_LEN_12_P_2 */
8081 { VEX_W_TABLE (VEX_W_12_P_2
) },
8084 /* VEX_LEN_13_M_0 */
8086 { VEX_W_TABLE (VEX_W_13_M_0
) },
8089 /* VEX_LEN_16_P_0_M_0 */
8091 { VEX_W_TABLE (VEX_W_16_P_0_M_0
) },
8094 /* VEX_LEN_16_P_0_M_1 */
8096 { VEX_W_TABLE (VEX_W_16_P_0_M_1
) },
8099 /* VEX_LEN_16_P_2 */
8101 { VEX_W_TABLE (VEX_W_16_P_2
) },
8104 /* VEX_LEN_17_M_0 */
8106 { VEX_W_TABLE (VEX_W_17_M_0
) },
8109 /* VEX_LEN_2A_P_1 */
8111 { "vcvtsi2ss%LQ", { XM
, Vex128
, Ev
} },
8114 /* VEX_LEN_2A_P_3 */
8116 { "vcvtsi2sd%LQ", { XM
, Vex128
, Ev
} },
8119 /* VEX_LEN_2C_P_1 */
8121 { "vcvttss2siY", { Gv
, EXd
} },
8124 /* VEX_LEN_2C_P_3 */
8126 { "vcvttsd2siY", { Gv
, EXq
} },
8129 /* VEX_LEN_2D_P_1 */
8131 { "vcvtss2siY", { Gv
, EXd
} },
8134 /* VEX_LEN_2D_P_3 */
8136 { "vcvtsd2siY", { Gv
, EXq
} },
8139 /* VEX_LEN_2E_P_0 */
8141 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8144 /* VEX_LEN_2E_P_2 */
8146 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8149 /* VEX_LEN_2F_P_0 */
8151 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8154 /* VEX_LEN_2F_P_2 */
8156 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8159 /* VEX_LEN_51_P_1 */
8161 { VEX_W_TABLE (VEX_W_51_P_1
) },
8164 /* VEX_LEN_51_P_3 */
8166 { VEX_W_TABLE (VEX_W_51_P_3
) },
8169 /* VEX_LEN_52_P_1 */
8171 { VEX_W_TABLE (VEX_W_52_P_1
) },
8174 /* VEX_LEN_53_P_1 */
8176 { VEX_W_TABLE (VEX_W_53_P_1
) },
8179 /* VEX_LEN_58_P_1 */
8181 { VEX_W_TABLE (VEX_W_58_P_1
) },
8184 /* VEX_LEN_58_P_3 */
8186 { VEX_W_TABLE (VEX_W_58_P_3
) },
8189 /* VEX_LEN_59_P_1 */
8191 { VEX_W_TABLE (VEX_W_59_P_1
) },
8194 /* VEX_LEN_59_P_3 */
8196 { VEX_W_TABLE (VEX_W_59_P_3
) },
8199 /* VEX_LEN_5A_P_1 */
8201 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8204 /* VEX_LEN_5A_P_3 */
8206 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8209 /* VEX_LEN_5C_P_1 */
8211 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8214 /* VEX_LEN_5C_P_3 */
8216 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8219 /* VEX_LEN_5D_P_1 */
8221 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8224 /* VEX_LEN_5D_P_3 */
8226 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8229 /* VEX_LEN_5E_P_1 */
8231 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8234 /* VEX_LEN_5E_P_3 */
8236 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8239 /* VEX_LEN_5F_P_1 */
8241 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8244 /* VEX_LEN_5F_P_3 */
8246 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8249 /* VEX_LEN_60_P_2 */
8251 { VEX_W_TABLE (VEX_W_60_P_2
) },
8254 /* VEX_LEN_61_P_2 */
8256 { VEX_W_TABLE (VEX_W_61_P_2
) },
8259 /* VEX_LEN_62_P_2 */
8261 { VEX_W_TABLE (VEX_W_62_P_2
) },
8264 /* VEX_LEN_63_P_2 */
8266 { VEX_W_TABLE (VEX_W_63_P_2
) },
8269 /* VEX_LEN_64_P_2 */
8271 { VEX_W_TABLE (VEX_W_64_P_2
) },
8274 /* VEX_LEN_65_P_2 */
8276 { VEX_W_TABLE (VEX_W_65_P_2
) },
8279 /* VEX_LEN_66_P_2 */
8281 { VEX_W_TABLE (VEX_W_66_P_2
) },
8284 /* VEX_LEN_67_P_2 */
8286 { VEX_W_TABLE (VEX_W_67_P_2
) },
8289 /* VEX_LEN_68_P_2 */
8291 { VEX_W_TABLE (VEX_W_68_P_2
) },
8294 /* VEX_LEN_69_P_2 */
8296 { VEX_W_TABLE (VEX_W_69_P_2
) },
8299 /* VEX_LEN_6A_P_2 */
8301 { VEX_W_TABLE (VEX_W_6A_P_2
) },
8304 /* VEX_LEN_6B_P_2 */
8306 { VEX_W_TABLE (VEX_W_6B_P_2
) },
8309 /* VEX_LEN_6C_P_2 */
8311 { VEX_W_TABLE (VEX_W_6C_P_2
) },
8314 /* VEX_LEN_6D_P_2 */
8316 { VEX_W_TABLE (VEX_W_6D_P_2
) },
8319 /* VEX_LEN_6E_P_2 */
8321 { "vmovK", { XM
, Edq
} },
8324 /* VEX_LEN_70_P_1 */
8326 { VEX_W_TABLE (VEX_W_70_P_1
) },
8329 /* VEX_LEN_70_P_2 */
8331 { VEX_W_TABLE (VEX_W_70_P_2
) },
8334 /* VEX_LEN_70_P_3 */
8336 { VEX_W_TABLE (VEX_W_70_P_3
) },
8339 /* VEX_LEN_71_R_2_P_2 */
8341 { VEX_W_TABLE (VEX_W_71_R_2_P_2
) },
8344 /* VEX_LEN_71_R_4_P_2 */
8346 { VEX_W_TABLE (VEX_W_71_R_4_P_2
) },
8349 /* VEX_LEN_71_R_6_P_2 */
8351 { VEX_W_TABLE (VEX_W_71_R_6_P_2
) },
8354 /* VEX_LEN_72_R_2_P_2 */
8356 { VEX_W_TABLE (VEX_W_72_R_2_P_2
) },
8359 /* VEX_LEN_72_R_4_P_2 */
8361 { VEX_W_TABLE (VEX_W_72_R_4_P_2
) },
8364 /* VEX_LEN_72_R_6_P_2 */
8366 { VEX_W_TABLE (VEX_W_72_R_6_P_2
) },
8369 /* VEX_LEN_73_R_2_P_2 */
8371 { VEX_W_TABLE (VEX_W_73_R_2_P_2
) },
8374 /* VEX_LEN_73_R_3_P_2 */
8376 { VEX_W_TABLE (VEX_W_73_R_3_P_2
) },
8379 /* VEX_LEN_73_R_6_P_2 */
8381 { VEX_W_TABLE (VEX_W_73_R_6_P_2
) },
8384 /* VEX_LEN_73_R_7_P_2 */
8386 { VEX_W_TABLE (VEX_W_73_R_7_P_2
) },
8389 /* VEX_LEN_74_P_2 */
8391 { VEX_W_TABLE (VEX_W_74_P_2
) },
8394 /* VEX_LEN_75_P_2 */
8396 { VEX_W_TABLE (VEX_W_75_P_2
) },
8399 /* VEX_LEN_76_P_2 */
8401 { VEX_W_TABLE (VEX_W_76_P_2
) },
8404 /* VEX_LEN_7E_P_1 */
8406 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8409 /* VEX_LEN_7E_P_2 */
8411 { "vmovK", { Edq
, XM
} },
8414 /* VEX_LEN_AE_R_2_M_0 */
8416 { VEX_W_TABLE (VEX_W_AE_R_2_M_0
) },
8419 /* VEX_LEN_AE_R_3_M_0 */
8421 { VEX_W_TABLE (VEX_W_AE_R_3_M_0
) },
8424 /* VEX_LEN_C2_P_1 */
8426 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8429 /* VEX_LEN_C2_P_3 */
8431 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8434 /* VEX_LEN_C4_P_2 */
8436 { VEX_W_TABLE (VEX_W_C4_P_2
) },
8439 /* VEX_LEN_C5_P_2 */
8441 { VEX_W_TABLE (VEX_W_C5_P_2
) },
8444 /* VEX_LEN_D1_P_2 */
8446 { VEX_W_TABLE (VEX_W_D1_P_2
) },
8449 /* VEX_LEN_D2_P_2 */
8451 { VEX_W_TABLE (VEX_W_D2_P_2
) },
8454 /* VEX_LEN_D3_P_2 */
8456 { VEX_W_TABLE (VEX_W_D3_P_2
) },
8459 /* VEX_LEN_D4_P_2 */
8461 { VEX_W_TABLE (VEX_W_D4_P_2
) },
8464 /* VEX_LEN_D5_P_2 */
8466 { VEX_W_TABLE (VEX_W_D5_P_2
) },
8469 /* VEX_LEN_D6_P_2 */
8471 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8474 /* VEX_LEN_D7_P_2_M_1 */
8476 { VEX_W_TABLE (VEX_W_D7_P_2_M_1
) },
8479 /* VEX_LEN_D8_P_2 */
8481 { VEX_W_TABLE (VEX_W_D8_P_2
) },
8484 /* VEX_LEN_D9_P_2 */
8486 { VEX_W_TABLE (VEX_W_D9_P_2
) },
8489 /* VEX_LEN_DA_P_2 */
8491 { VEX_W_TABLE (VEX_W_DA_P_2
) },
8494 /* VEX_LEN_DB_P_2 */
8496 { VEX_W_TABLE (VEX_W_DB_P_2
) },
8499 /* VEX_LEN_DC_P_2 */
8501 { VEX_W_TABLE (VEX_W_DC_P_2
) },
8504 /* VEX_LEN_DD_P_2 */
8506 { VEX_W_TABLE (VEX_W_DD_P_2
) },
8509 /* VEX_LEN_DE_P_2 */
8511 { VEX_W_TABLE (VEX_W_DE_P_2
) },
8514 /* VEX_LEN_DF_P_2 */
8516 { VEX_W_TABLE (VEX_W_DF_P_2
) },
8519 /* VEX_LEN_E0_P_2 */
8521 { VEX_W_TABLE (VEX_W_E0_P_2
) },
8524 /* VEX_LEN_E1_P_2 */
8526 { VEX_W_TABLE (VEX_W_E1_P_2
) },
8529 /* VEX_LEN_E2_P_2 */
8531 { VEX_W_TABLE (VEX_W_E2_P_2
) },
8534 /* VEX_LEN_E3_P_2 */
8536 { VEX_W_TABLE (VEX_W_E3_P_2
) },
8539 /* VEX_LEN_E4_P_2 */
8541 { VEX_W_TABLE (VEX_W_E4_P_2
) },
8544 /* VEX_LEN_E5_P_2 */
8546 { VEX_W_TABLE (VEX_W_E5_P_2
) },
8549 /* VEX_LEN_E8_P_2 */
8551 { VEX_W_TABLE (VEX_W_E8_P_2
) },
8554 /* VEX_LEN_E9_P_2 */
8556 { VEX_W_TABLE (VEX_W_E9_P_2
) },
8559 /* VEX_LEN_EA_P_2 */
8561 { VEX_W_TABLE (VEX_W_EA_P_2
) },
8564 /* VEX_LEN_EB_P_2 */
8566 { VEX_W_TABLE (VEX_W_EB_P_2
) },
8569 /* VEX_LEN_EC_P_2 */
8571 { VEX_W_TABLE (VEX_W_EC_P_2
) },
8574 /* VEX_LEN_ED_P_2 */
8576 { VEX_W_TABLE (VEX_W_ED_P_2
) },
8579 /* VEX_LEN_EE_P_2 */
8581 { VEX_W_TABLE (VEX_W_EE_P_2
) },
8584 /* VEX_LEN_EF_P_2 */
8586 { VEX_W_TABLE (VEX_W_EF_P_2
) },
8589 /* VEX_LEN_F1_P_2 */
8591 { VEX_W_TABLE (VEX_W_F1_P_2
) },
8594 /* VEX_LEN_F2_P_2 */
8596 { VEX_W_TABLE (VEX_W_F2_P_2
) },
8600 /* VEX_LEN_F3_P_2 */
8602 { VEX_W_TABLE (VEX_W_F3_P_2
) },
8605 /* VEX_LEN_F4_P_2 */
8607 { VEX_W_TABLE (VEX_W_F4_P_2
) },
8610 /* VEX_LEN_F5_P_2 */
8612 { VEX_W_TABLE (VEX_W_F5_P_2
) },
8615 /* VEX_LEN_F6_P_2 */
8617 { VEX_W_TABLE (VEX_W_F6_P_2
) },
8620 /* VEX_LEN_F7_P_2 */
8622 { VEX_W_TABLE (VEX_W_F7_P_2
) },
8625 /* VEX_LEN_F8_P_2 */
8627 { VEX_W_TABLE (VEX_W_F8_P_2
) },
8630 /* VEX_LEN_F9_P_2 */
8632 { VEX_W_TABLE (VEX_W_F9_P_2
) },
8635 /* VEX_LEN_FA_P_2 */
8637 { VEX_W_TABLE (VEX_W_FA_P_2
) },
8640 /* VEX_LEN_FB_P_2 */
8642 { VEX_W_TABLE (VEX_W_FB_P_2
) },
8645 /* VEX_LEN_FC_P_2 */
8647 { VEX_W_TABLE (VEX_W_FC_P_2
) },
8650 /* VEX_LEN_FD_P_2 */
8652 { VEX_W_TABLE (VEX_W_FD_P_2
) },
8655 /* VEX_LEN_FE_P_2 */
8657 { VEX_W_TABLE (VEX_W_FE_P_2
) },
8660 /* VEX_LEN_3800_P_2 */
8662 { VEX_W_TABLE (VEX_W_3800_P_2
) },
8665 /* VEX_LEN_3801_P_2 */
8667 { VEX_W_TABLE (VEX_W_3801_P_2
) },
8670 /* VEX_LEN_3802_P_2 */
8672 { VEX_W_TABLE (VEX_W_3802_P_2
) },
8675 /* VEX_LEN_3803_P_2 */
8677 { VEX_W_TABLE (VEX_W_3803_P_2
) },
8680 /* VEX_LEN_3804_P_2 */
8682 { VEX_W_TABLE (VEX_W_3804_P_2
) },
8685 /* VEX_LEN_3805_P_2 */
8687 { VEX_W_TABLE (VEX_W_3805_P_2
) },
8690 /* VEX_LEN_3806_P_2 */
8692 { VEX_W_TABLE (VEX_W_3806_P_2
) },
8695 /* VEX_LEN_3807_P_2 */
8697 { VEX_W_TABLE (VEX_W_3807_P_2
) },
8700 /* VEX_LEN_3808_P_2 */
8702 { VEX_W_TABLE (VEX_W_3808_P_2
) },
8705 /* VEX_LEN_3809_P_2 */
8707 { VEX_W_TABLE (VEX_W_3809_P_2
) },
8710 /* VEX_LEN_380A_P_2 */
8712 { VEX_W_TABLE (VEX_W_380A_P_2
) },
8715 /* VEX_LEN_380B_P_2 */
8717 { VEX_W_TABLE (VEX_W_380B_P_2
) },
8720 /* VEX_LEN_3819_P_2_M_0 */
8723 { VEX_W_TABLE (VEX_W_3819_P_2_M_0
) },
8726 /* VEX_LEN_381A_P_2_M_0 */
8729 { VEX_W_TABLE (VEX_W_381A_P_2_M_0
) },
8732 /* VEX_LEN_381C_P_2 */
8734 { VEX_W_TABLE (VEX_W_381C_P_2
) },
8737 /* VEX_LEN_381D_P_2 */
8739 { VEX_W_TABLE (VEX_W_381D_P_2
) },
8742 /* VEX_LEN_381E_P_2 */
8744 { VEX_W_TABLE (VEX_W_381E_P_2
) },
8747 /* VEX_LEN_3820_P_2 */
8749 { VEX_W_TABLE (VEX_W_3820_P_2
) },
8752 /* VEX_LEN_3821_P_2 */
8754 { VEX_W_TABLE (VEX_W_3821_P_2
) },
8757 /* VEX_LEN_3822_P_2 */
8759 { VEX_W_TABLE (VEX_W_3822_P_2
) },
8762 /* VEX_LEN_3823_P_2 */
8764 { VEX_W_TABLE (VEX_W_3823_P_2
) },
8767 /* VEX_LEN_3824_P_2 */
8769 { VEX_W_TABLE (VEX_W_3824_P_2
) },
8772 /* VEX_LEN_3825_P_2 */
8774 { VEX_W_TABLE (VEX_W_3825_P_2
) },
8777 /* VEX_LEN_3828_P_2 */
8779 { VEX_W_TABLE (VEX_W_3828_P_2
) },
8782 /* VEX_LEN_3829_P_2 */
8784 { VEX_W_TABLE (VEX_W_3829_P_2
) },
8787 /* VEX_LEN_382A_P_2_M_0 */
8789 { VEX_W_TABLE (VEX_W_382A_P_2_M_0
) },
8792 /* VEX_LEN_382B_P_2 */
8794 { VEX_W_TABLE (VEX_W_382B_P_2
) },
8797 /* VEX_LEN_3830_P_2 */
8799 { VEX_W_TABLE (VEX_W_3830_P_2
) },
8802 /* VEX_LEN_3831_P_2 */
8804 { VEX_W_TABLE (VEX_W_3831_P_2
) },
8807 /* VEX_LEN_3832_P_2 */
8809 { VEX_W_TABLE (VEX_W_3832_P_2
) },
8812 /* VEX_LEN_3833_P_2 */
8814 { VEX_W_TABLE (VEX_W_3833_P_2
) },
8817 /* VEX_LEN_3834_P_2 */
8819 { VEX_W_TABLE (VEX_W_3834_P_2
) },
8822 /* VEX_LEN_3835_P_2 */
8824 { VEX_W_TABLE (VEX_W_3835_P_2
) },
8827 /* VEX_LEN_3837_P_2 */
8829 { VEX_W_TABLE (VEX_W_3837_P_2
) },
8832 /* VEX_LEN_3838_P_2 */
8834 { VEX_W_TABLE (VEX_W_3838_P_2
) },
8837 /* VEX_LEN_3839_P_2 */
8839 { VEX_W_TABLE (VEX_W_3839_P_2
) },
8842 /* VEX_LEN_383A_P_2 */
8844 { VEX_W_TABLE (VEX_W_383A_P_2
) },
8847 /* VEX_LEN_383B_P_2 */
8849 { VEX_W_TABLE (VEX_W_383B_P_2
) },
8852 /* VEX_LEN_383C_P_2 */
8854 { VEX_W_TABLE (VEX_W_383C_P_2
) },
8857 /* VEX_LEN_383D_P_2 */
8859 { VEX_W_TABLE (VEX_W_383D_P_2
) },
8862 /* VEX_LEN_383E_P_2 */
8864 { VEX_W_TABLE (VEX_W_383E_P_2
) },
8867 /* VEX_LEN_383F_P_2 */
8869 { VEX_W_TABLE (VEX_W_383F_P_2
) },
8872 /* VEX_LEN_3840_P_2 */
8874 { VEX_W_TABLE (VEX_W_3840_P_2
) },
8877 /* VEX_LEN_3841_P_2 */
8879 { VEX_W_TABLE (VEX_W_3841_P_2
) },
8882 /* VEX_LEN_38DB_P_2 */
8884 { VEX_W_TABLE (VEX_W_38DB_P_2
) },
8887 /* VEX_LEN_38DC_P_2 */
8889 { VEX_W_TABLE (VEX_W_38DC_P_2
) },
8892 /* VEX_LEN_38DD_P_2 */
8894 { VEX_W_TABLE (VEX_W_38DD_P_2
) },
8897 /* VEX_LEN_38DE_P_2 */
8899 { VEX_W_TABLE (VEX_W_38DE_P_2
) },
8902 /* VEX_LEN_38DF_P_2 */
8904 { VEX_W_TABLE (VEX_W_38DF_P_2
) },
8907 /* VEX_LEN_3A06_P_2 */
8910 { VEX_W_TABLE (VEX_W_3A06_P_2
) },
8913 /* VEX_LEN_3A0A_P_2 */
8915 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
8918 /* VEX_LEN_3A0B_P_2 */
8920 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
8923 /* VEX_LEN_3A0E_P_2 */
8925 { VEX_W_TABLE (VEX_W_3A0E_P_2
) },
8928 /* VEX_LEN_3A0F_P_2 */
8930 { VEX_W_TABLE (VEX_W_3A0F_P_2
) },
8933 /* VEX_LEN_3A14_P_2 */
8935 { VEX_W_TABLE (VEX_W_3A14_P_2
) },
8938 /* VEX_LEN_3A15_P_2 */
8940 { VEX_W_TABLE (VEX_W_3A15_P_2
) },
8943 /* VEX_LEN_3A16_P_2 */
8945 { "vpextrK", { Edq
, XM
, Ib
} },
8948 /* VEX_LEN_3A17_P_2 */
8950 { "vextractps", { Edqd
, XM
, Ib
} },
8953 /* VEX_LEN_3A18_P_2 */
8956 { VEX_W_TABLE (VEX_W_3A18_P_2
) },
8959 /* VEX_LEN_3A19_P_2 */
8962 { VEX_W_TABLE (VEX_W_3A19_P_2
) },
8965 /* VEX_LEN_3A20_P_2 */
8967 { VEX_W_TABLE (VEX_W_3A20_P_2
) },
8970 /* VEX_LEN_3A21_P_2 */
8972 { VEX_W_TABLE (VEX_W_3A21_P_2
) },
8975 /* VEX_LEN_3A22_P_2 */
8977 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
8980 /* VEX_LEN_3A41_P_2 */
8982 { VEX_W_TABLE (VEX_W_3A41_P_2
) },
8985 /* VEX_LEN_3A42_P_2 */
8987 { VEX_W_TABLE (VEX_W_3A42_P_2
) },
8990 /* VEX_LEN_3A44_P_2 */
8992 { VEX_W_TABLE (VEX_W_3A44_P_2
) },
8995 /* VEX_LEN_3A4C_P_2 */
8997 { VEX_W_TABLE (VEX_W_3A4C_P_2
) },
9000 /* VEX_LEN_3A60_P_2 */
9002 { VEX_W_TABLE (VEX_W_3A60_P_2
) },
9005 /* VEX_LEN_3A61_P_2 */
9007 { VEX_W_TABLE (VEX_W_3A61_P_2
) },
9010 /* VEX_LEN_3A62_P_2 */
9012 { VEX_W_TABLE (VEX_W_3A62_P_2
) },
9015 /* VEX_LEN_3A63_P_2 */
9017 { VEX_W_TABLE (VEX_W_3A63_P_2
) },
9020 /* VEX_LEN_3A6A_P_2 */
9022 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9025 /* VEX_LEN_3A6B_P_2 */
9027 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9030 /* VEX_LEN_3A6E_P_2 */
9032 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9035 /* VEX_LEN_3A6F_P_2 */
9037 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9040 /* VEX_LEN_3A7A_P_2 */
9042 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9045 /* VEX_LEN_3A7B_P_2 */
9047 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9050 /* VEX_LEN_3A7E_P_2 */
9052 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9055 /* VEX_LEN_3A7F_P_2 */
9057 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9060 /* VEX_LEN_3ADF_P_2 */
9062 { VEX_W_TABLE (VEX_W_3ADF_P_2
) },
9065 /* VEX_LEN_XOP_09_80 */
9067 { "vfrczps", { XM
, EXxmm
} },
9068 { "vfrczps", { XM
, EXymmq
} },
9071 /* VEX_LEN_XOP_09_81 */
9073 { "vfrczpd", { XM
, EXxmm
} },
9074 { "vfrczpd", { XM
, EXymmq
} },
9078 static const struct dis386 vex_w_table
[][2] = {
9081 { "vmovups", { XM
, EXx
} },
9085 { "vmovss", { XMVex
, Vex128
, EXd
} },
9089 { "vmovupd", { XM
, EXx
} },
9093 { "vmovsd", { XMVex
, Vex128
, EXq
} },
9097 { "vmovups", { EXxS
, XM
} },
9101 { "vmovss", { EXdVexS
, Vex128
, XM
} },
9105 { "vmovupd", { EXxS
, XM
} },
9109 { "vmovsd", { EXqVexS
, Vex128
, XM
} },
9112 /* VEX_W_12_P_0_M_0 */
9113 { "vmovlps", { XM
, Vex128
, EXq
} },
9116 /* VEX_W_12_P_0_M_1 */
9117 { "vmovhlps", { XM
, Vex128
, EXq
} },
9121 { "vmovsldup", { XM
, EXx
} },
9125 { "vmovlpd", { XM
, Vex128
, EXq
} },
9129 { "vmovddup", { XM
, EXymmq
} },
9133 { "vmovlpX", { EXq
, XM
} },
9137 { "vunpcklpX", { XM
, Vex
, EXx
} },
9141 { "vunpckhpX", { XM
, Vex
, EXx
} },
9144 /* VEX_W_16_P_0_M_0 */
9145 { "vmovhps", { XM
, Vex128
, EXq
} },
9148 /* VEX_W_16_P_0_M_1 */
9149 { "vmovlhps", { XM
, Vex128
, EXq
} },
9153 { "vmovshdup", { XM
, EXx
} },
9157 { "vmovhpd", { XM
, Vex128
, EXq
} },
9161 { "vmovhpX", { EXq
, XM
} },
9165 { "vmovapX", { XM
, EXx
} },
9169 { "vmovapX", { EXxS
, XM
} },
9173 { "vmovntpX", { Mx
, XM
} },
9177 { "vucomiss", { XM
, EXd
} },
9181 { "vucomisd", { XM
, EXq
} },
9185 { "vcomiss", { XM
, EXd
} },
9189 { "vcomisd", { XM
, EXq
} },
9193 { "vmovmskpX", { Gdq
, XS
} },
9197 { "vsqrtps", { XM
, EXx
} },
9201 { "vsqrtss", { XM
, Vex128
, EXd
} },
9205 { "vsqrtpd", { XM
, EXx
} },
9209 { "vsqrtsd", { XM
, Vex128
, EXq
} },
9213 { "vrsqrtps", { XM
, EXx
} },
9217 { "vrsqrtss", { XM
, Vex128
, EXd
} },
9221 { "vrcpps", { XM
, EXx
} },
9225 { "vrcpss", { XM
, Vex128
, EXd
} },
9229 { "vaddps", { XM
, Vex
, EXx
} },
9233 { "vaddss", { XM
, Vex128
, EXd
} },
9237 { "vaddpd", { XM
, Vex
, EXx
} },
9241 { "vaddsd", { XM
, Vex128
, EXq
} },
9245 { "vmulps", { XM
, Vex
, EXx
} },
9249 { "vmulss", { XM
, Vex128
, EXd
} },
9253 { "vmulpd", { XM
, Vex
, EXx
} },
9257 { "vmulsd", { XM
, Vex128
, EXq
} },
9261 { "vcvtps2pd", { XM
, EXxmmq
} },
9265 { "vcvtss2sd", { XM
, Vex128
, EXd
} },
9269 { "vcvtsd2ss", { XM
, Vex128
, EXq
} },
9273 { "vcvtdq2ps", { XM
, EXx
} },
9277 { "vcvttps2dq", { XM
, EXx
} },
9281 { "vcvtps2dq", { XM
, EXx
} },
9285 { "vsubps", { XM
, Vex
, EXx
} },
9289 { "vsubss", { XM
, Vex128
, EXd
} },
9293 { "vsubpd", { XM
, Vex
, EXx
} },
9297 { "vsubsd", { XM
, Vex128
, EXq
} },
9301 { "vminps", { XM
, Vex
, EXx
} },
9305 { "vminss", { XM
, Vex128
, EXd
} },
9309 { "vminpd", { XM
, Vex
, EXx
} },
9313 { "vminsd", { XM
, Vex128
, EXq
} },
9317 { "vdivps", { XM
, Vex
, EXx
} },
9321 { "vdivss", { XM
, Vex128
, EXd
} },
9325 { "vdivpd", { XM
, Vex
, EXx
} },
9329 { "vdivsd", { XM
, Vex128
, EXq
} },
9333 { "vmaxps", { XM
, Vex
, EXx
} },
9337 { "vmaxss", { XM
, Vex128
, EXd
} },
9341 { "vmaxpd", { XM
, Vex
, EXx
} },
9345 { "vmaxsd", { XM
, Vex128
, EXq
} },
9349 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
9353 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
9357 { "vpunpckldq", { XM
, Vex128
, EXx
} },
9361 { "vpacksswb", { XM
, Vex128
, EXx
} },
9365 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
9369 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
9373 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
9377 { "vpackuswb", { XM
, Vex128
, EXx
} },
9381 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
9385 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
9389 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
9393 { "vpackssdw", { XM
, Vex128
, EXx
} },
9397 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
9401 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
9405 { "vmovdqu", { XM
, EXx
} },
9409 { "vmovdqa", { XM
, EXx
} },
9413 { "vpshufhw", { XM
, EXx
, Ib
} },
9417 { "vpshufd", { XM
, EXx
, Ib
} },
9421 { "vpshuflw", { XM
, EXx
, Ib
} },
9424 /* VEX_W_71_R_2_P_2 */
9425 { "vpsrlw", { Vex128
, XS
, Ib
} },
9428 /* VEX_W_71_R_4_P_2 */
9429 { "vpsraw", { Vex128
, XS
, Ib
} },
9432 /* VEX_W_71_R_6_P_2 */
9433 { "vpsllw", { Vex128
, XS
, Ib
} },
9436 /* VEX_W_72_R_2_P_2 */
9437 { "vpsrld", { Vex128
, XS
, Ib
} },
9440 /* VEX_W_72_R_4_P_2 */
9441 { "vpsrad", { Vex128
, XS
, Ib
} },
9444 /* VEX_W_72_R_6_P_2 */
9445 { "vpslld", { Vex128
, XS
, Ib
} },
9448 /* VEX_W_73_R_2_P_2 */
9449 { "vpsrlq", { Vex128
, XS
, Ib
} },
9452 /* VEX_W_73_R_3_P_2 */
9453 { "vpsrldq", { Vex128
, XS
, Ib
} },
9456 /* VEX_W_73_R_6_P_2 */
9457 { "vpsllq", { Vex128
, XS
, Ib
} },
9460 /* VEX_W_73_R_7_P_2 */
9461 { "vpslldq", { Vex128
, XS
, Ib
} },
9465 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
9469 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
9473 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
9481 { "vhaddpd", { XM
, Vex
, EXx
} },
9485 { "vhaddps", { XM
, Vex
, EXx
} },
9489 { "vhsubpd", { XM
, Vex
, EXx
} },
9493 { "vhsubps", { XM
, Vex
, EXx
} },
9497 { "vmovq", { XM
, EXq
} },
9501 { "vmovdqu", { EXxS
, XM
} },
9505 { "vmovdqa", { EXxS
, XM
} },
9508 /* VEX_W_AE_R_2_M_0 */
9509 { "vldmxcsr", { Md
} },
9512 /* VEX_W_AE_R_3_M_0 */
9513 { "vstmxcsr", { Md
} },
9517 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
9521 { "vcmpss", { XM
, Vex128
, EXd
, VCMP
} },
9525 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
9529 { "vcmpsd", { XM
, Vex128
, EXq
, VCMP
} },
9533 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
9537 { "vpextrw", { Gdq
, XS
, Ib
} },
9541 { "vaddsubpd", { XM
, Vex
, EXx
} },
9545 { "vaddsubps", { XM
, Vex
, EXx
} },
9549 { "vpsrlw", { XM
, Vex128
, EXx
} },
9553 { "vpsrld", { XM
, Vex128
, EXx
} },
9557 { "vpsrlq", { XM
, Vex128
, EXx
} },
9561 { "vpaddq", { XM
, Vex128
, EXx
} },
9565 { "vpmullw", { XM
, Vex128
, EXx
} },
9569 { "vmovq", { EXqS
, XM
} },
9572 /* VEX_W_D7_P_2_M_1 */
9573 { "vpmovmskb", { Gdq
, XS
} },
9577 { "vpsubusb", { XM
, Vex128
, EXx
} },
9581 { "vpsubusw", { XM
, Vex128
, EXx
} },
9585 { "vpminub", { XM
, Vex128
, EXx
} },
9589 { "vpand", { XM
, Vex128
, EXx
} },
9593 { "vpaddusb", { XM
, Vex128
, EXx
} },
9597 { "vpaddusw", { XM
, Vex128
, EXx
} },
9601 { "vpmaxub", { XM
, Vex128
, EXx
} },
9605 { "vpandn", { XM
, Vex128
, EXx
} },
9609 { "vpavgb", { XM
, Vex128
, EXx
} },
9613 { "vpsraw", { XM
, Vex128
, EXx
} },
9617 { "vpsrad", { XM
, Vex128
, EXx
} },
9621 { "vpavgw", { XM
, Vex128
, EXx
} },
9625 { "vpmulhuw", { XM
, Vex128
, EXx
} },
9629 { "vpmulhw", { XM
, Vex128
, EXx
} },
9633 { "vcvtdq2pd", { XM
, EXxmmq
} },
9637 { "vcvttpd2dq%XY", { XMM
, EXx
} },
9641 { "vcvtpd2dq%XY", { XMM
, EXx
} },
9644 /* VEX_W_E7_P_2_M_0 */
9645 { "vmovntdq", { Mx
, XM
} },
9649 { "vpsubsb", { XM
, Vex128
, EXx
} },
9653 { "vpsubsw", { XM
, Vex128
, EXx
} },
9657 { "vpminsw", { XM
, Vex128
, EXx
} },
9661 { "vpor", { XM
, Vex128
, EXx
} },
9665 { "vpaddsb", { XM
, Vex128
, EXx
} },
9669 { "vpaddsw", { XM
, Vex128
, EXx
} },
9673 { "vpmaxsw", { XM
, Vex128
, EXx
} },
9677 { "vpxor", { XM
, Vex128
, EXx
} },
9680 /* VEX_W_F0_P_3_M_0 */
9681 { "vlddqu", { XM
, M
} },
9685 { "vpsllw", { XM
, Vex128
, EXx
} },
9689 { "vpslld", { XM
, Vex128
, EXx
} },
9693 { "vpsllq", { XM
, Vex128
, EXx
} },
9697 { "vpmuludq", { XM
, Vex128
, EXx
} },
9701 { "vpmaddwd", { XM
, Vex128
, EXx
} },
9705 { "vpsadbw", { XM
, Vex128
, EXx
} },
9709 { "vmaskmovdqu", { XM
, XS
} },
9713 { "vpsubb", { XM
, Vex128
, EXx
} },
9717 { "vpsubw", { XM
, Vex128
, EXx
} },
9721 { "vpsubd", { XM
, Vex128
, EXx
} },
9725 { "vpsubq", { XM
, Vex128
, EXx
} },
9729 { "vpaddb", { XM
, Vex128
, EXx
} },
9733 { "vpaddw", { XM
, Vex128
, EXx
} },
9737 { "vpaddd", { XM
, Vex128
, EXx
} },
9740 /* VEX_W_3800_P_2 */
9741 { "vpshufb", { XM
, Vex128
, EXx
} },
9744 /* VEX_W_3801_P_2 */
9745 { "vphaddw", { XM
, Vex128
, EXx
} },
9748 /* VEX_W_3802_P_2 */
9749 { "vphaddd", { XM
, Vex128
, EXx
} },
9752 /* VEX_W_3803_P_2 */
9753 { "vphaddsw", { XM
, Vex128
, EXx
} },
9756 /* VEX_W_3804_P_2 */
9757 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
9760 /* VEX_W_3805_P_2 */
9761 { "vphsubw", { XM
, Vex128
, EXx
} },
9764 /* VEX_W_3806_P_2 */
9765 { "vphsubd", { XM
, Vex128
, EXx
} },
9768 /* VEX_W_3807_P_2 */
9769 { "vphsubsw", { XM
, Vex128
, EXx
} },
9772 /* VEX_W_3808_P_2 */
9773 { "vpsignb", { XM
, Vex128
, EXx
} },
9776 /* VEX_W_3809_P_2 */
9777 { "vpsignw", { XM
, Vex128
, EXx
} },
9780 /* VEX_W_380A_P_2 */
9781 { "vpsignd", { XM
, Vex128
, EXx
} },
9784 /* VEX_W_380B_P_2 */
9785 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
9788 /* VEX_W_380C_P_2 */
9789 { "vpermilps", { XM
, Vex
, EXx
} },
9792 /* VEX_W_380D_P_2 */
9793 { "vpermilpd", { XM
, Vex
, EXx
} },
9796 /* VEX_W_380E_P_2 */
9797 { "vtestps", { XM
, EXx
} },
9800 /* VEX_W_380F_P_2 */
9801 { "vtestpd", { XM
, EXx
} },
9804 /* VEX_W_3817_P_2 */
9805 { "vptest", { XM
, EXx
} },
9808 /* VEX_W_3818_P_2_M_0 */
9809 { "vbroadcastss", { XM
, Md
} },
9812 /* VEX_W_3819_P_2_M_0 */
9813 { "vbroadcastsd", { XM
, Mq
} },
9816 /* VEX_W_381A_P_2_M_0 */
9817 { "vbroadcastf128", { XM
, Mxmm
} },
9820 /* VEX_W_381C_P_2 */
9821 { "vpabsb", { XM
, EXx
} },
9824 /* VEX_W_381D_P_2 */
9825 { "vpabsw", { XM
, EXx
} },
9828 /* VEX_W_381E_P_2 */
9829 { "vpabsd", { XM
, EXx
} },
9832 /* VEX_W_3820_P_2 */
9833 { "vpmovsxbw", { XM
, EXq
} },
9836 /* VEX_W_3821_P_2 */
9837 { "vpmovsxbd", { XM
, EXd
} },
9840 /* VEX_W_3822_P_2 */
9841 { "vpmovsxbq", { XM
, EXw
} },
9844 /* VEX_W_3823_P_2 */
9845 { "vpmovsxwd", { XM
, EXq
} },
9848 /* VEX_W_3824_P_2 */
9849 { "vpmovsxwq", { XM
, EXd
} },
9852 /* VEX_W_3825_P_2 */
9853 { "vpmovsxdq", { XM
, EXq
} },
9856 /* VEX_W_3828_P_2 */
9857 { "vpmuldq", { XM
, Vex128
, EXx
} },
9860 /* VEX_W_3829_P_2 */
9861 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
9864 /* VEX_W_382A_P_2_M_0 */
9865 { "vmovntdqa", { XM
, Mx
} },
9868 /* VEX_W_382B_P_2 */
9869 { "vpackusdw", { XM
, Vex128
, EXx
} },
9872 /* VEX_W_382C_P_2_M_0 */
9873 { "vmaskmovps", { XM
, Vex
, Mx
} },
9876 /* VEX_W_382D_P_2_M_0 */
9877 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9880 /* VEX_W_382E_P_2_M_0 */
9881 { "vmaskmovps", { Mx
, Vex
, XM
} },
9884 /* VEX_W_382F_P_2_M_0 */
9885 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9888 /* VEX_W_3830_P_2 */
9889 { "vpmovzxbw", { XM
, EXq
} },
9892 /* VEX_W_3831_P_2 */
9893 { "vpmovzxbd", { XM
, EXd
} },
9896 /* VEX_W_3832_P_2 */
9897 { "vpmovzxbq", { XM
, EXw
} },
9900 /* VEX_W_3833_P_2 */
9901 { "vpmovzxwd", { XM
, EXq
} },
9904 /* VEX_W_3834_P_2 */
9905 { "vpmovzxwq", { XM
, EXd
} },
9908 /* VEX_W_3835_P_2 */
9909 { "vpmovzxdq", { XM
, EXq
} },
9912 /* VEX_W_3837_P_2 */
9913 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
9916 /* VEX_W_3838_P_2 */
9917 { "vpminsb", { XM
, Vex128
, EXx
} },
9920 /* VEX_W_3839_P_2 */
9921 { "vpminsd", { XM
, Vex128
, EXx
} },
9924 /* VEX_W_383A_P_2 */
9925 { "vpminuw", { XM
, Vex128
, EXx
} },
9928 /* VEX_W_383B_P_2 */
9929 { "vpminud", { XM
, Vex128
, EXx
} },
9932 /* VEX_W_383C_P_2 */
9933 { "vpmaxsb", { XM
, Vex128
, EXx
} },
9936 /* VEX_W_383D_P_2 */
9937 { "vpmaxsd", { XM
, Vex128
, EXx
} },
9940 /* VEX_W_383E_P_2 */
9941 { "vpmaxuw", { XM
, Vex128
, EXx
} },
9944 /* VEX_W_383F_P_2 */
9945 { "vpmaxud", { XM
, Vex128
, EXx
} },
9948 /* VEX_W_3840_P_2 */
9949 { "vpmulld", { XM
, Vex128
, EXx
} },
9952 /* VEX_W_3841_P_2 */
9953 { "vphminposuw", { XM
, EXx
} },
9956 /* VEX_W_38DB_P_2 */
9957 { "vaesimc", { XM
, EXx
} },
9960 /* VEX_W_38DC_P_2 */
9961 { "vaesenc", { XM
, Vex128
, EXx
} },
9964 /* VEX_W_38DD_P_2 */
9965 { "vaesenclast", { XM
, Vex128
, EXx
} },
9968 /* VEX_W_38DE_P_2 */
9969 { "vaesdec", { XM
, Vex128
, EXx
} },
9972 /* VEX_W_38DF_P_2 */
9973 { "vaesdeclast", { XM
, Vex128
, EXx
} },
9976 /* VEX_W_3A04_P_2 */
9977 { "vpermilps", { XM
, EXx
, Ib
} },
9980 /* VEX_W_3A05_P_2 */
9981 { "vpermilpd", { XM
, EXx
, Ib
} },
9984 /* VEX_W_3A06_P_2 */
9985 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
9988 /* VEX_W_3A08_P_2 */
9989 { "vroundps", { XM
, EXx
, Ib
} },
9992 /* VEX_W_3A09_P_2 */
9993 { "vroundpd", { XM
, EXx
, Ib
} },
9996 /* VEX_W_3A0A_P_2 */
9997 { "vroundss", { XM
, Vex128
, EXd
, Ib
} },
10000 /* VEX_W_3A0B_P_2 */
10001 { "vroundsd", { XM
, Vex128
, EXq
, Ib
} },
10004 /* VEX_W_3A0C_P_2 */
10005 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
10008 /* VEX_W_3A0D_P_2 */
10009 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
10012 /* VEX_W_3A0E_P_2 */
10013 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
10016 /* VEX_W_3A0F_P_2 */
10017 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
10020 /* VEX_W_3A14_P_2 */
10021 { "vpextrb", { Edqb
, XM
, Ib
} },
10024 /* VEX_W_3A15_P_2 */
10025 { "vpextrw", { Edqw
, XM
, Ib
} },
10028 /* VEX_W_3A18_P_2 */
10029 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
10032 /* VEX_W_3A19_P_2 */
10033 { "vextractf128", { EXxmm
, XM
, Ib
} },
10036 /* VEX_W_3A20_P_2 */
10037 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
10040 /* VEX_W_3A21_P_2 */
10041 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
10044 /* VEX_W_3A40_P_2 */
10045 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
10048 /* VEX_W_3A41_P_2 */
10049 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
10052 /* VEX_W_3A42_P_2 */
10053 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
10056 /* VEX_W_3A44_P_2 */
10057 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
10060 /* VEX_W_3A4A_P_2 */
10061 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
10064 /* VEX_W_3A4B_P_2 */
10065 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
10068 /* VEX_W_3A4C_P_2 */
10069 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
10072 /* VEX_W_3A60_P_2 */
10073 { "vpcmpestrm", { XM
, EXx
, Ib
} },
10076 /* VEX_W_3A61_P_2 */
10077 { "vpcmpestri", { XM
, EXx
, Ib
} },
10080 /* VEX_W_3A62_P_2 */
10081 { "vpcmpistrm", { XM
, EXx
, Ib
} },
10084 /* VEX_W_3A63_P_2 */
10085 { "vpcmpistri", { XM
, EXx
, Ib
} },
10088 /* VEX_W_3ADF_P_2 */
10089 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
10093 static const struct dis386 mod_table
[][2] = {
10096 { "leaS", { Gv
, M
} },
10099 /* MOD_0F01_REG_0 */
10100 { X86_64_TABLE (X86_64_0F01_REG_0
) },
10101 { RM_TABLE (RM_0F01_REG_0
) },
10104 /* MOD_0F01_REG_1 */
10105 { X86_64_TABLE (X86_64_0F01_REG_1
) },
10106 { RM_TABLE (RM_0F01_REG_1
) },
10109 /* MOD_0F01_REG_2 */
10110 { X86_64_TABLE (X86_64_0F01_REG_2
) },
10111 { RM_TABLE (RM_0F01_REG_2
) },
10114 /* MOD_0F01_REG_3 */
10115 { X86_64_TABLE (X86_64_0F01_REG_3
) },
10116 { RM_TABLE (RM_0F01_REG_3
) },
10119 /* MOD_0F01_REG_7 */
10120 { "invlpg", { Mb
} },
10121 { RM_TABLE (RM_0F01_REG_7
) },
10124 /* MOD_0F12_PREFIX_0 */
10125 { "movlps", { XM
, EXq
} },
10126 { "movhlps", { XM
, EXq
} },
10130 { "movlpX", { EXq
, XM
} },
10133 /* MOD_0F16_PREFIX_0 */
10134 { "movhps", { XM
, EXq
} },
10135 { "movlhps", { XM
, EXq
} },
10139 { "movhpX", { EXq
, XM
} },
10142 /* MOD_0F18_REG_0 */
10143 { "prefetchnta", { Mb
} },
10146 /* MOD_0F18_REG_1 */
10147 { "prefetcht0", { Mb
} },
10150 /* MOD_0F18_REG_2 */
10151 { "prefetcht1", { Mb
} },
10154 /* MOD_0F18_REG_3 */
10155 { "prefetcht2", { Mb
} },
10160 { "movZ", { Rm
, Cm
} },
10165 { "movZ", { Rm
, Dm
} },
10170 { "movZ", { Cm
, Rm
} },
10175 { "movZ", { Dm
, Rm
} },
10180 { "movL", { Rd
, Td
} },
10185 { "movL", { Td
, Rd
} },
10188 /* MOD_0F2B_PREFIX_0 */
10189 {"movntps", { Mx
, XM
} },
10192 /* MOD_0F2B_PREFIX_1 */
10193 {"movntss", { Md
, XM
} },
10196 /* MOD_0F2B_PREFIX_2 */
10197 {"movntpd", { Mx
, XM
} },
10200 /* MOD_0F2B_PREFIX_3 */
10201 {"movntsd", { Mq
, XM
} },
10206 { "movmskpX", { Gdq
, XS
} },
10209 /* MOD_0F71_REG_2 */
10211 { "psrlw", { MS
, Ib
} },
10214 /* MOD_0F71_REG_4 */
10216 { "psraw", { MS
, Ib
} },
10219 /* MOD_0F71_REG_6 */
10221 { "psllw", { MS
, Ib
} },
10224 /* MOD_0F72_REG_2 */
10226 { "psrld", { MS
, Ib
} },
10229 /* MOD_0F72_REG_4 */
10231 { "psrad", { MS
, Ib
} },
10234 /* MOD_0F72_REG_6 */
10236 { "pslld", { MS
, Ib
} },
10239 /* MOD_0F73_REG_2 */
10241 { "psrlq", { MS
, Ib
} },
10244 /* MOD_0F73_REG_3 */
10246 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
10249 /* MOD_0F73_REG_6 */
10251 { "psllq", { MS
, Ib
} },
10254 /* MOD_0F73_REG_7 */
10256 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
10259 /* MOD_0FAE_REG_0 */
10260 { "fxsave", { FXSAVE
} },
10263 /* MOD_0FAE_REG_1 */
10264 { "fxrstor", { FXSAVE
} },
10267 /* MOD_0FAE_REG_2 */
10268 { "ldmxcsr", { Md
} },
10271 /* MOD_0FAE_REG_3 */
10272 { "stmxcsr", { Md
} },
10275 /* MOD_0FAE_REG_4 */
10276 { "xsave", { FXSAVE
} },
10279 /* MOD_0FAE_REG_5 */
10280 { "xrstor", { FXSAVE
} },
10281 { RM_TABLE (RM_0FAE_REG_5
) },
10284 /* MOD_0FAE_REG_6 */
10286 { RM_TABLE (RM_0FAE_REG_6
) },
10289 /* MOD_0FAE_REG_7 */
10290 { "clflush", { Mb
} },
10291 { RM_TABLE (RM_0FAE_REG_7
) },
10295 { "lssS", { Gv
, Mp
} },
10299 { "lfsS", { Gv
, Mp
} },
10303 { "lgsS", { Gv
, Mp
} },
10306 /* MOD_0FC7_REG_6 */
10307 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
10310 /* MOD_0FC7_REG_7 */
10311 { "vmptrst", { Mq
} },
10316 { "pmovmskb", { Gdq
, MS
} },
10319 /* MOD_0FE7_PREFIX_2 */
10320 { "movntdq", { Mx
, XM
} },
10323 /* MOD_0FF0_PREFIX_3 */
10324 { "lddqu", { XM
, M
} },
10327 /* MOD_0F382A_PREFIX_2 */
10328 { "movntdqa", { XM
, Mx
} },
10332 { "bound{S|}", { Gv
, Ma
} },
10336 { "lesS", { Gv
, Mp
} },
10337 { VEX_C4_TABLE (VEX_0F
) },
10341 { "ldsS", { Gv
, Mp
} },
10342 { VEX_C5_TABLE (VEX_0F
) },
10345 /* MOD_VEX_12_PREFIX_0 */
10346 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
10347 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
10351 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
10354 /* MOD_VEX_16_PREFIX_0 */
10355 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
10356 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
10360 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
10364 { VEX_W_TABLE (VEX_W_2B_M_0
) },
10369 { VEX_W_TABLE (VEX_W_50_M_0
) },
10372 /* MOD_VEX_71_REG_2 */
10374 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
10377 /* MOD_VEX_71_REG_4 */
10379 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
10382 /* MOD_VEX_71_REG_6 */
10384 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
10387 /* MOD_VEX_72_REG_2 */
10389 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
10392 /* MOD_VEX_72_REG_4 */
10394 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
10397 /* MOD_VEX_72_REG_6 */
10399 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
10402 /* MOD_VEX_73_REG_2 */
10404 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
10407 /* MOD_VEX_73_REG_3 */
10409 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
10412 /* MOD_VEX_73_REG_6 */
10414 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
10417 /* MOD_VEX_73_REG_7 */
10419 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
10422 /* MOD_VEX_AE_REG_2 */
10423 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
10426 /* MOD_VEX_AE_REG_3 */
10427 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
10430 /* MOD_VEX_D7_PREFIX_2 */
10432 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
10435 /* MOD_VEX_E7_PREFIX_2 */
10436 { VEX_W_TABLE (VEX_W_E7_P_2_M_0
) },
10439 /* MOD_VEX_F0_PREFIX_3 */
10440 { VEX_W_TABLE (VEX_W_F0_P_3_M_0
) },
10443 /* MOD_VEX_3818_PREFIX_2 */
10444 { VEX_W_TABLE (VEX_W_3818_P_2_M_0
) },
10447 /* MOD_VEX_3819_PREFIX_2 */
10448 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
10451 /* MOD_VEX_381A_PREFIX_2 */
10452 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
10455 /* MOD_VEX_382A_PREFIX_2 */
10456 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
10459 /* MOD_VEX_382C_PREFIX_2 */
10460 { VEX_W_TABLE (VEX_W_382C_P_2_M_0
) },
10463 /* MOD_VEX_382D_PREFIX_2 */
10464 { VEX_W_TABLE (VEX_W_382D_P_2_M_0
) },
10467 /* MOD_VEX_382E_PREFIX_2 */
10468 { VEX_W_TABLE (VEX_W_382E_P_2_M_0
) },
10471 /* MOD_VEX_382F_PREFIX_2 */
10472 { VEX_W_TABLE (VEX_W_382F_P_2_M_0
) },
10476 static const struct dis386 rm_table
[][8] = {
10478 /* RM_0F01_REG_0 */
10480 { "vmcall", { Skip_MODRM
} },
10481 { "vmlaunch", { Skip_MODRM
} },
10482 { "vmresume", { Skip_MODRM
} },
10483 { "vmxoff", { Skip_MODRM
} },
10486 /* RM_0F01_REG_1 */
10487 { "monitor", { { OP_Monitor
, 0 } } },
10488 { "mwait", { { OP_Mwait
, 0 } } },
10491 /* RM_0F01_REG_2 */
10492 { "xgetbv", { Skip_MODRM
} },
10493 { "xsetbv", { Skip_MODRM
} },
10496 /* RM_0F01_REG_3 */
10497 { "vmrun", { Skip_MODRM
} },
10498 { "vmmcall", { Skip_MODRM
} },
10499 { "vmload", { Skip_MODRM
} },
10500 { "vmsave", { Skip_MODRM
} },
10501 { "stgi", { Skip_MODRM
} },
10502 { "clgi", { Skip_MODRM
} },
10503 { "skinit", { Skip_MODRM
} },
10504 { "invlpga", { Skip_MODRM
} },
10507 /* RM_0F01_REG_7 */
10508 { "swapgs", { Skip_MODRM
} },
10509 { "rdtscp", { Skip_MODRM
} },
10512 /* RM_0FAE_REG_5 */
10513 { "lfence", { Skip_MODRM
} },
10516 /* RM_0FAE_REG_6 */
10517 { "mfence", { Skip_MODRM
} },
10520 /* RM_0FAE_REG_7 */
10521 { "sfence", { Skip_MODRM
} },
10525 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
10527 /* We use the high bit to indicate different name for the same
10529 #define ADDR16_PREFIX (0x67 | 0x100)
10530 #define ADDR32_PREFIX (0x67 | 0x200)
10531 #define DATA16_PREFIX (0x66 | 0x100)
10532 #define DATA32_PREFIX (0x66 | 0x200)
10533 #define REP_PREFIX (0xf3 | 0x100)
10538 int newrex
, i
, length
;
10544 last_lock_prefix
= -1;
10545 last_repz_prefix
= -1;
10546 last_repnz_prefix
= -1;
10547 last_data_prefix
= -1;
10548 last_addr_prefix
= -1;
10549 last_rex_prefix
= -1;
10550 last_seg_prefix
= -1;
10551 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10552 all_prefixes
[i
] = 0;
10555 /* The maximum instruction length is 15bytes. */
10556 while (length
< MAX_CODE_LENGTH
- 1)
10558 FETCH_DATA (the_info
, codep
+ 1);
10562 /* REX prefixes family. */
10579 if (address_mode
== mode_64bit
)
10583 last_rex_prefix
= i
;
10586 prefixes
|= PREFIX_REPZ
;
10587 last_repz_prefix
= i
;
10590 prefixes
|= PREFIX_REPNZ
;
10591 last_repnz_prefix
= i
;
10594 prefixes
|= PREFIX_LOCK
;
10595 last_lock_prefix
= i
;
10598 prefixes
|= PREFIX_CS
;
10599 last_seg_prefix
= i
;
10602 prefixes
|= PREFIX_SS
;
10603 last_seg_prefix
= i
;
10606 prefixes
|= PREFIX_DS
;
10607 last_seg_prefix
= i
;
10610 prefixes
|= PREFIX_ES
;
10611 last_seg_prefix
= i
;
10614 prefixes
|= PREFIX_FS
;
10615 last_seg_prefix
= i
;
10618 prefixes
|= PREFIX_GS
;
10619 last_seg_prefix
= i
;
10622 prefixes
|= PREFIX_DATA
;
10623 last_data_prefix
= i
;
10626 prefixes
|= PREFIX_ADDR
;
10627 last_addr_prefix
= i
;
10630 /* fwait is really an instruction. If there are prefixes
10631 before the fwait, they belong to the fwait, *not* to the
10632 following instruction. */
10633 if (prefixes
|| rex
)
10635 prefixes
|= PREFIX_FWAIT
;
10639 prefixes
= PREFIX_FWAIT
;
10644 /* Rex is ignored when followed by another prefix. */
10650 if (*codep
!= FWAIT_OPCODE
)
10651 all_prefixes
[i
++] = *codep
;
10660 seg_prefix (int pref
)
10681 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10684 static const char *
10685 prefix_name (int pref
, int sizeflag
)
10687 static const char *rexes
[16] =
10690 "rex.B", /* 0x41 */
10691 "rex.X", /* 0x42 */
10692 "rex.XB", /* 0x43 */
10693 "rex.R", /* 0x44 */
10694 "rex.RB", /* 0x45 */
10695 "rex.RX", /* 0x46 */
10696 "rex.RXB", /* 0x47 */
10697 "rex.W", /* 0x48 */
10698 "rex.WB", /* 0x49 */
10699 "rex.WX", /* 0x4a */
10700 "rex.WXB", /* 0x4b */
10701 "rex.WR", /* 0x4c */
10702 "rex.WRB", /* 0x4d */
10703 "rex.WRX", /* 0x4e */
10704 "rex.WRXB", /* 0x4f */
10709 /* REX prefixes family. */
10726 return rexes
[pref
- 0x40];
10746 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10748 if (address_mode
== mode_64bit
)
10749 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10751 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10754 case ADDR16_PREFIX
:
10756 case ADDR32_PREFIX
:
10758 case DATA16_PREFIX
:
10760 case DATA32_PREFIX
:
10769 static char op_out
[MAX_OPERANDS
][100];
10770 static int op_ad
, op_index
[MAX_OPERANDS
];
10771 static int two_source_ops
;
10772 static bfd_vma op_address
[MAX_OPERANDS
];
10773 static bfd_vma op_riprel
[MAX_OPERANDS
];
10774 static bfd_vma start_pc
;
10777 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10778 * (see topic "Redundant prefixes" in the "Differences from 8086"
10779 * section of the "Virtual 8086 Mode" chapter.)
10780 * 'pc' should be the address of this instruction, it will
10781 * be used to print the target address if this is a relative jump or call
10782 * The function returns the length of this instruction in bytes.
10785 static char intel_syntax
;
10786 static char intel_mnemonic
= !SYSV386_COMPAT
;
10787 static char open_char
;
10788 static char close_char
;
10789 static char separator_char
;
10790 static char scale_char
;
10792 /* Here for backwards compatibility. When gdb stops using
10793 print_insn_i386_att and print_insn_i386_intel these functions can
10794 disappear, and print_insn_i386 be merged into print_insn. */
10796 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10800 return print_insn (pc
, info
);
10804 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10808 return print_insn (pc
, info
);
10812 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10816 return print_insn (pc
, info
);
10820 print_i386_disassembler_options (FILE *stream
)
10822 fprintf (stream
, _("\n\
10823 The following i386/x86-64 specific disassembler options are supported for use\n\
10824 with the -M switch (multiple options should be separated by commas):\n"));
10826 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10827 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10828 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10829 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10830 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10831 fprintf (stream
, _(" att-mnemonic\n"
10832 " Display instruction in AT&T mnemonic\n"));
10833 fprintf (stream
, _(" intel-mnemonic\n"
10834 " Display instruction in Intel mnemonic\n"));
10835 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10836 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10837 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10838 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10839 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10840 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10844 static const struct dis386 bad_opcode
= { "(bad)", { XX
} };
10846 /* Get a pointer to struct dis386 with a valid name. */
10848 static const struct dis386
*
10849 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10851 int vindex
, vex_table_index
;
10853 if (dp
->name
!= NULL
)
10856 switch (dp
->op
[0].bytemode
)
10858 case USE_REG_TABLE
:
10859 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10862 case USE_MOD_TABLE
:
10863 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
10864 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
10868 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10871 case USE_PREFIX_TABLE
:
10874 /* The prefix in VEX is implicit. */
10875 switch (vex
.prefix
)
10880 case REPE_PREFIX_OPCODE
:
10883 case DATA_PREFIX_OPCODE
:
10886 case REPNE_PREFIX_OPCODE
:
10897 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10898 if (prefixes
& PREFIX_REPZ
)
10901 all_prefixes
[last_repz_prefix
] = 0;
10905 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10907 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10908 if (prefixes
& PREFIX_REPNZ
)
10911 all_prefixes
[last_repnz_prefix
] = 0;
10915 used_prefixes
|= (prefixes
& PREFIX_DATA
);
10916 if (prefixes
& PREFIX_DATA
)
10919 all_prefixes
[last_data_prefix
] = 0;
10924 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
10927 case USE_X86_64_TABLE
:
10928 vindex
= address_mode
== mode_64bit
? 1 : 0;
10929 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
10932 case USE_3BYTE_TABLE
:
10933 FETCH_DATA (info
, codep
+ 2);
10935 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
10936 modrm
.mod
= (*codep
>> 6) & 3;
10937 modrm
.reg
= (*codep
>> 3) & 7;
10938 modrm
.rm
= *codep
& 7;
10941 case USE_VEX_LEN_TABLE
:
10945 switch (vex
.length
)
10958 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
10961 case USE_XOP_8F_TABLE
:
10962 FETCH_DATA (info
, codep
+ 3);
10963 /* All bits in the REX prefix are ignored. */
10965 rex
= ~(*codep
>> 5) & 0x7;
10967 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10968 switch ((*codep
& 0x1f))
10973 vex_table_index
= XOP_08
;
10976 vex_table_index
= XOP_09
;
10979 vex_table_index
= XOP_0A
;
10983 vex
.w
= *codep
& 0x80;
10984 if (vex
.w
&& address_mode
== mode_64bit
)
10987 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10988 if (address_mode
!= mode_64bit
10989 && vex
.register_specifier
> 0x7)
10992 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10993 switch ((*codep
& 0x3))
10999 vex
.prefix
= DATA_PREFIX_OPCODE
;
11002 vex
.prefix
= REPE_PREFIX_OPCODE
;
11005 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11012 dp
= &xop_table
[vex_table_index
][vindex
];
11014 FETCH_DATA (info
, codep
+ 1);
11015 modrm
.mod
= (*codep
>> 6) & 3;
11016 modrm
.reg
= (*codep
>> 3) & 7;
11017 modrm
.rm
= *codep
& 7;
11020 case USE_VEX_C4_TABLE
:
11021 FETCH_DATA (info
, codep
+ 3);
11022 /* All bits in the REX prefix are ignored. */
11024 rex
= ~(*codep
>> 5) & 0x7;
11025 switch ((*codep
& 0x1f))
11030 vex_table_index
= VEX_0F
;
11033 vex_table_index
= VEX_0F38
;
11036 vex_table_index
= VEX_0F3A
;
11040 vex
.w
= *codep
& 0x80;
11041 if (vex
.w
&& address_mode
== mode_64bit
)
11044 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11045 if (address_mode
!= mode_64bit
11046 && vex
.register_specifier
> 0x7)
11049 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11050 switch ((*codep
& 0x3))
11056 vex
.prefix
= DATA_PREFIX_OPCODE
;
11059 vex
.prefix
= REPE_PREFIX_OPCODE
;
11062 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11069 dp
= &vex_table
[vex_table_index
][vindex
];
11070 /* There is no MODRM byte for VEX [82|77]. */
11071 if (vindex
!= 0x77 && vindex
!= 0x82)
11073 FETCH_DATA (info
, codep
+ 1);
11074 modrm
.mod
= (*codep
>> 6) & 3;
11075 modrm
.reg
= (*codep
>> 3) & 7;
11076 modrm
.rm
= *codep
& 7;
11080 case USE_VEX_C5_TABLE
:
11081 FETCH_DATA (info
, codep
+ 2);
11082 /* All bits in the REX prefix are ignored. */
11084 rex
= (*codep
& 0x80) ? 0 : REX_R
;
11086 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11087 if (address_mode
!= mode_64bit
11088 && vex
.register_specifier
> 0x7)
11093 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11094 switch ((*codep
& 0x3))
11100 vex
.prefix
= DATA_PREFIX_OPCODE
;
11103 vex
.prefix
= REPE_PREFIX_OPCODE
;
11106 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11113 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
11114 /* There is no MODRM byte for VEX [82|77]. */
11115 if (vindex
!= 0x77 && vindex
!= 0x82)
11117 FETCH_DATA (info
, codep
+ 1);
11118 modrm
.mod
= (*codep
>> 6) & 3;
11119 modrm
.reg
= (*codep
>> 3) & 7;
11120 modrm
.rm
= *codep
& 7;
11124 case USE_VEX_W_TABLE
:
11128 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
11139 if (dp
->name
!= NULL
)
11142 return get_valid_dis386 (dp
, info
);
11146 print_insn (bfd_vma pc
, disassemble_info
*info
)
11148 const struct dis386
*dp
;
11150 char *op_txt
[MAX_OPERANDS
];
11154 struct dis_private priv
;
11157 int default_prefixes
;
11159 if (info
->mach
== bfd_mach_x86_64_intel_syntax
11160 || info
->mach
== bfd_mach_x86_64
11161 || info
->mach
== bfd_mach_l1om
11162 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11163 address_mode
= mode_64bit
;
11165 address_mode
= mode_32bit
;
11167 if (intel_syntax
== (char) -1)
11168 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
11169 || info
->mach
== bfd_mach_x86_64_intel_syntax
11170 || info
->mach
== bfd_mach_l1om_intel_syntax
);
11172 if (info
->mach
== bfd_mach_i386_i386
11173 || info
->mach
== bfd_mach_x86_64
11174 || info
->mach
== bfd_mach_l1om
11175 || info
->mach
== bfd_mach_i386_i386_intel_syntax
11176 || info
->mach
== bfd_mach_x86_64_intel_syntax
11177 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11178 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11179 else if (info
->mach
== bfd_mach_i386_i8086
)
11180 priv
.orig_sizeflag
= 0;
11184 for (p
= info
->disassembler_options
; p
!= NULL
; )
11186 if (CONST_STRNEQ (p
, "x86-64"))
11188 address_mode
= mode_64bit
;
11189 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11191 else if (CONST_STRNEQ (p
, "i386"))
11193 address_mode
= mode_32bit
;
11194 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11196 else if (CONST_STRNEQ (p
, "i8086"))
11198 address_mode
= mode_16bit
;
11199 priv
.orig_sizeflag
= 0;
11201 else if (CONST_STRNEQ (p
, "intel"))
11204 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
11205 intel_mnemonic
= 1;
11207 else if (CONST_STRNEQ (p
, "att"))
11210 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
11211 intel_mnemonic
= 0;
11213 else if (CONST_STRNEQ (p
, "addr"))
11215 if (address_mode
== mode_64bit
)
11217 if (p
[4] == '3' && p
[5] == '2')
11218 priv
.orig_sizeflag
&= ~AFLAG
;
11219 else if (p
[4] == '6' && p
[5] == '4')
11220 priv
.orig_sizeflag
|= AFLAG
;
11224 if (p
[4] == '1' && p
[5] == '6')
11225 priv
.orig_sizeflag
&= ~AFLAG
;
11226 else if (p
[4] == '3' && p
[5] == '2')
11227 priv
.orig_sizeflag
|= AFLAG
;
11230 else if (CONST_STRNEQ (p
, "data"))
11232 if (p
[4] == '1' && p
[5] == '6')
11233 priv
.orig_sizeflag
&= ~DFLAG
;
11234 else if (p
[4] == '3' && p
[5] == '2')
11235 priv
.orig_sizeflag
|= DFLAG
;
11237 else if (CONST_STRNEQ (p
, "suffix"))
11238 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
11240 p
= strchr (p
, ',');
11247 names64
= intel_names64
;
11248 names32
= intel_names32
;
11249 names16
= intel_names16
;
11250 names8
= intel_names8
;
11251 names8rex
= intel_names8rex
;
11252 names_seg
= intel_names_seg
;
11253 names_mm
= intel_names_mm
;
11254 names_xmm
= intel_names_xmm
;
11255 names_ymm
= intel_names_ymm
;
11256 index64
= intel_index64
;
11257 index32
= intel_index32
;
11258 index16
= intel_index16
;
11261 separator_char
= '+';
11266 names64
= att_names64
;
11267 names32
= att_names32
;
11268 names16
= att_names16
;
11269 names8
= att_names8
;
11270 names8rex
= att_names8rex
;
11271 names_seg
= att_names_seg
;
11272 names_mm
= att_names_mm
;
11273 names_xmm
= att_names_xmm
;
11274 names_ymm
= att_names_ymm
;
11275 index64
= att_index64
;
11276 index32
= att_index32
;
11277 index16
= att_index16
;
11280 separator_char
= ',';
11284 /* The output looks better if we put 7 bytes on a line, since that
11285 puts most long word instructions on a single line. Use 8 bytes
11287 if (info
->mach
== bfd_mach_l1om
11288 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11289 info
->bytes_per_line
= 8;
11291 info
->bytes_per_line
= 7;
11293 info
->private_data
= &priv
;
11294 priv
.max_fetched
= priv
.the_buffer
;
11295 priv
.insn_start
= pc
;
11298 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11306 start_codep
= priv
.the_buffer
;
11307 codep
= priv
.the_buffer
;
11309 if (setjmp (priv
.bailout
) != 0)
11313 /* Getting here means we tried for data but didn't get it. That
11314 means we have an incomplete instruction of some sort. Just
11315 print the first byte as a prefix or a .byte pseudo-op. */
11316 if (codep
> priv
.the_buffer
)
11318 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
11320 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11323 /* Just print the first byte as a .byte instruction. */
11324 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
11325 (unsigned int) priv
.the_buffer
[0]);
11335 sizeflag
= priv
.orig_sizeflag
;
11337 if (!ckprefix () || rex_used
)
11339 /* Too many prefixes or unused REX prefixes. */
11341 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
11343 (*info
->fprintf_func
) (info
->stream
, "%s",
11344 prefix_name (all_prefixes
[i
], sizeflag
));
11348 insn_codep
= codep
;
11350 FETCH_DATA (info
, codep
+ 1);
11351 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
11353 if (((prefixes
& PREFIX_FWAIT
)
11354 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
11356 (*info
->fprintf_func
) (info
->stream
, "fwait");
11362 if (*codep
== 0x0f)
11364 unsigned char threebyte
;
11365 FETCH_DATA (info
, codep
+ 2);
11366 threebyte
= *++codep
;
11367 dp
= &dis386_twobyte
[threebyte
];
11368 need_modrm
= twobyte_has_modrm
[*codep
];
11373 dp
= &dis386
[*codep
];
11374 need_modrm
= onebyte_has_modrm
[*codep
];
11378 if ((prefixes
& PREFIX_REPZ
))
11379 used_prefixes
|= PREFIX_REPZ
;
11380 if ((prefixes
& PREFIX_REPNZ
))
11381 used_prefixes
|= PREFIX_REPNZ
;
11382 if ((prefixes
& PREFIX_LOCK
))
11383 used_prefixes
|= PREFIX_LOCK
;
11385 default_prefixes
= 0;
11386 if (prefixes
& PREFIX_ADDR
)
11389 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
11391 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
11392 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
11394 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
11395 default_prefixes
|= PREFIX_ADDR
;
11399 if ((prefixes
& PREFIX_DATA
))
11402 if (dp
->op
[2].bytemode
== cond_jump_mode
11403 && dp
->op
[0].bytemode
== v_mode
11406 if (sizeflag
& DFLAG
)
11407 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
11409 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
11410 default_prefixes
|= PREFIX_DATA
;
11412 else if (rex
& REX_W
)
11414 /* REX_W will override PREFIX_DATA. */
11415 default_prefixes
|= PREFIX_DATA
;
11421 FETCH_DATA (info
, codep
+ 1);
11422 modrm
.mod
= (*codep
>> 6) & 3;
11423 modrm
.reg
= (*codep
>> 3) & 7;
11424 modrm
.rm
= *codep
& 7;
11431 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
11433 dofloat (sizeflag
);
11437 dp
= get_valid_dis386 (dp
, info
);
11438 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
11440 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11443 op_ad
= MAX_OPERANDS
- 1 - i
;
11445 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
11450 /* See if any prefixes were not used. If so, print the first one
11451 separately. If we don't do this, we'll wind up printing an
11452 instruction stream which does not precisely correspond to the
11453 bytes we are disassembling. */
11454 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
11456 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11457 if (all_prefixes
[i
])
11460 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
11462 name
= INTERNAL_DISASSEMBLER_ERROR
;
11463 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11468 /* Check if the REX prefix is used. */
11469 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
11470 all_prefixes
[last_rex_prefix
] = 0;
11472 /* Check if the SEG prefix is used. */
11473 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
11474 | PREFIX_FS
| PREFIX_GS
)) != 0
11476 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
11477 all_prefixes
[last_seg_prefix
] = 0;
11479 /* Check if the ADDR prefix is used. */
11480 if ((prefixes
& PREFIX_ADDR
) != 0
11481 && (used_prefixes
& PREFIX_ADDR
) != 0)
11482 all_prefixes
[last_addr_prefix
] = 0;
11484 /* Check if the DATA prefix is used. */
11485 if ((prefixes
& PREFIX_DATA
) != 0
11486 && (used_prefixes
& PREFIX_DATA
) != 0)
11487 all_prefixes
[last_data_prefix
] = 0;
11490 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11491 if (all_prefixes
[i
])
11494 name
= prefix_name (all_prefixes
[i
], sizeflag
);
11497 prefix_length
+= strlen (name
) + 1;
11498 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
11501 /* Check maximum code length. */
11502 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
11504 (*info
->fprintf_func
) (info
->stream
, "(bad)");
11505 return MAX_CODE_LENGTH
;
11508 obufp
= mnemonicendp
;
11509 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
11512 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
11514 /* The enter and bound instructions are printed with operands in the same
11515 order as the intel book; everything else is printed in reverse order. */
11516 if (intel_syntax
|| two_source_ops
)
11520 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11521 op_txt
[i
] = op_out
[i
];
11523 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
11525 op_ad
= op_index
[i
];
11526 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
11527 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
11528 riprel
= op_riprel
[i
];
11529 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
11530 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
11535 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11536 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
11540 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11544 (*info
->fprintf_func
) (info
->stream
, ",");
11545 if (op_index
[i
] != -1 && !op_riprel
[i
])
11546 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
11548 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
11552 for (i
= 0; i
< MAX_OPERANDS
; i
++)
11553 if (op_index
[i
] != -1 && op_riprel
[i
])
11555 (*info
->fprintf_func
) (info
->stream
, " # ");
11556 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
11557 + op_address
[op_index
[i
]]), info
);
11560 return codep
- priv
.the_buffer
;
11563 static const char *float_mem
[] = {
11638 static const unsigned char float_mem_mode
[] = {
11713 #define ST { OP_ST, 0 }
11714 #define STi { OP_STi, 0 }
11716 #define FGRPd9_2 NULL, { { NULL, 0 } }
11717 #define FGRPd9_4 NULL, { { NULL, 1 } }
11718 #define FGRPd9_5 NULL, { { NULL, 2 } }
11719 #define FGRPd9_6 NULL, { { NULL, 3 } }
11720 #define FGRPd9_7 NULL, { { NULL, 4 } }
11721 #define FGRPda_5 NULL, { { NULL, 5 } }
11722 #define FGRPdb_4 NULL, { { NULL, 6 } }
11723 #define FGRPde_3 NULL, { { NULL, 7 } }
11724 #define FGRPdf_4 NULL, { { NULL, 8 } }
11726 static const struct dis386 float_reg
[][8] = {
11729 { "fadd", { ST
, STi
} },
11730 { "fmul", { ST
, STi
} },
11731 { "fcom", { STi
} },
11732 { "fcomp", { STi
} },
11733 { "fsub", { ST
, STi
} },
11734 { "fsubr", { ST
, STi
} },
11735 { "fdiv", { ST
, STi
} },
11736 { "fdivr", { ST
, STi
} },
11740 { "fld", { STi
} },
11741 { "fxch", { STi
} },
11751 { "fcmovb", { ST
, STi
} },
11752 { "fcmove", { ST
, STi
} },
11753 { "fcmovbe",{ ST
, STi
} },
11754 { "fcmovu", { ST
, STi
} },
11762 { "fcmovnb",{ ST
, STi
} },
11763 { "fcmovne",{ ST
, STi
} },
11764 { "fcmovnbe",{ ST
, STi
} },
11765 { "fcmovnu",{ ST
, STi
} },
11767 { "fucomi", { ST
, STi
} },
11768 { "fcomi", { ST
, STi
} },
11773 { "fadd", { STi
, ST
} },
11774 { "fmul", { STi
, ST
} },
11777 { "fsub!M", { STi
, ST
} },
11778 { "fsubM", { STi
, ST
} },
11779 { "fdiv!M", { STi
, ST
} },
11780 { "fdivM", { STi
, ST
} },
11784 { "ffree", { STi
} },
11786 { "fst", { STi
} },
11787 { "fstp", { STi
} },
11788 { "fucom", { STi
} },
11789 { "fucomp", { STi
} },
11795 { "faddp", { STi
, ST
} },
11796 { "fmulp", { STi
, ST
} },
11799 { "fsub!Mp", { STi
, ST
} },
11800 { "fsubMp", { STi
, ST
} },
11801 { "fdiv!Mp", { STi
, ST
} },
11802 { "fdivMp", { STi
, ST
} },
11806 { "ffreep", { STi
} },
11811 { "fucomip", { ST
, STi
} },
11812 { "fcomip", { ST
, STi
} },
11817 static char *fgrps
[][8] = {
11820 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11825 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11830 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11835 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11840 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11845 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11850 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11851 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11856 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11861 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11866 swap_operand (void)
11868 mnemonicendp
[0] = '.';
11869 mnemonicendp
[1] = 's';
11874 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11875 int sizeflag ATTRIBUTE_UNUSED
)
11877 /* Skip mod/rm byte. */
11883 dofloat (int sizeflag
)
11885 const struct dis386
*dp
;
11886 unsigned char floatop
;
11888 floatop
= codep
[-1];
11890 if (modrm
.mod
!= 3)
11892 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11894 putop (float_mem
[fp_indx
], sizeflag
);
11897 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11900 /* Skip mod/rm byte. */
11904 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11905 if (dp
->name
== NULL
)
11907 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
11909 /* Instruction fnstsw is only one with strange arg. */
11910 if (floatop
== 0xdf && codep
[-1] == 0xe0)
11911 strcpy (op_out
[0], names16
[0]);
11915 putop (dp
->name
, sizeflag
);
11920 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
11925 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
11930 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11932 oappend ("%st" + intel_syntax
);
11936 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11938 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
11939 oappend (scratchbuf
+ intel_syntax
);
11942 /* Capital letters in template are macros. */
11944 putop (const char *in_template
, int sizeflag
)
11949 unsigned int l
= 0, len
= 1;
11952 #define SAVE_LAST(c) \
11953 if (l < len && l < sizeof (last)) \
11958 for (p
= in_template
; *p
; p
++)
11975 while (*++p
!= '|')
11976 if (*p
== '}' || *p
== '\0')
11979 /* Fall through. */
11984 while (*++p
!= '}')
11995 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11999 if (l
== 0 && len
== 1)
12004 if (sizeflag
& SUFFIX_ALWAYS
)
12017 if (address_mode
== mode_64bit
12018 && !(prefixes
& PREFIX_ADDR
))
12029 if (intel_syntax
&& !alt
)
12031 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
12033 if (sizeflag
& DFLAG
)
12034 *obufp
++ = intel_syntax
? 'd' : 'l';
12036 *obufp
++ = intel_syntax
? 'w' : 's';
12037 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12041 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12044 if (modrm
.mod
== 3)
12050 if (sizeflag
& DFLAG
)
12051 *obufp
++ = intel_syntax
? 'd' : 'l';
12054 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12060 case 'E': /* For jcxz/jecxz */
12061 if (address_mode
== mode_64bit
)
12063 if (sizeflag
& AFLAG
)
12069 if (sizeflag
& AFLAG
)
12071 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12076 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
12078 if (sizeflag
& AFLAG
)
12079 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
12081 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
12082 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12086 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
12088 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12092 if (!(rex
& REX_W
))
12093 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12098 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
12099 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
12101 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
12104 if (prefixes
& PREFIX_DS
)
12125 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
12130 /* Fall through. */
12133 if (l
!= 0 || len
!= 1)
12141 if (sizeflag
& SUFFIX_ALWAYS
)
12145 if (intel_mnemonic
!= cond
)
12149 if ((prefixes
& PREFIX_FWAIT
) == 0)
12152 used_prefixes
|= PREFIX_FWAIT
;
12158 else if (intel_syntax
&& (sizeflag
& DFLAG
))
12162 if (!(rex
& REX_W
))
12163 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12168 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12173 /* Fall through. */
12177 if ((prefixes
& PREFIX_DATA
)
12179 || (sizeflag
& SUFFIX_ALWAYS
))
12186 if (sizeflag
& DFLAG
)
12190 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12197 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12199 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12203 /* Fall through. */
12206 if (l
== 0 && len
== 1)
12209 if (intel_syntax
&& !alt
)
12212 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12218 if (sizeflag
& DFLAG
)
12219 *obufp
++ = intel_syntax
? 'd' : 'l';
12222 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12228 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
12234 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12249 else if (sizeflag
& DFLAG
)
12258 if (intel_syntax
&& !p
[1]
12259 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
12261 if (!(rex
& REX_W
))
12262 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12265 if (l
== 0 && len
== 1)
12269 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12271 if (sizeflag
& SUFFIX_ALWAYS
)
12293 /* Fall through. */
12296 if (l
== 0 && len
== 1)
12301 if (sizeflag
& SUFFIX_ALWAYS
)
12307 if (sizeflag
& DFLAG
)
12311 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12325 if (address_mode
== mode_64bit
12326 && !(prefixes
& PREFIX_ADDR
))
12337 if (l
!= 0 || len
!= 1)
12342 if (need_vex
&& vex
.prefix
)
12344 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
12351 if (prefixes
& PREFIX_DATA
)
12355 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12359 if (l
== 0 && len
== 1)
12361 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12372 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12380 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12382 switch (vex
.length
)
12396 if (l
== 0 && len
== 1)
12398 /* operand size flag for cwtl, cbtw */
12407 else if (sizeflag
& DFLAG
)
12411 if (!(rex
& REX_W
))
12412 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12416 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12423 *obufp
++ = vex
.w
? 'd': 's';
12430 mnemonicendp
= obufp
;
12435 oappend (const char *s
)
12437 obufp
= stpcpy (obufp
, s
);
12443 if (prefixes
& PREFIX_CS
)
12445 used_prefixes
|= PREFIX_CS
;
12446 oappend ("%cs:" + intel_syntax
);
12448 if (prefixes
& PREFIX_DS
)
12450 used_prefixes
|= PREFIX_DS
;
12451 oappend ("%ds:" + intel_syntax
);
12453 if (prefixes
& PREFIX_SS
)
12455 used_prefixes
|= PREFIX_SS
;
12456 oappend ("%ss:" + intel_syntax
);
12458 if (prefixes
& PREFIX_ES
)
12460 used_prefixes
|= PREFIX_ES
;
12461 oappend ("%es:" + intel_syntax
);
12463 if (prefixes
& PREFIX_FS
)
12465 used_prefixes
|= PREFIX_FS
;
12466 oappend ("%fs:" + intel_syntax
);
12468 if (prefixes
& PREFIX_GS
)
12470 used_prefixes
|= PREFIX_GS
;
12471 oappend ("%gs:" + intel_syntax
);
12476 OP_indirE (int bytemode
, int sizeflag
)
12480 OP_E (bytemode
, sizeflag
);
12484 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
12486 if (address_mode
== mode_64bit
)
12494 sprintf_vma (tmp
, disp
);
12495 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
12496 strcpy (buf
+ 2, tmp
+ i
);
12500 bfd_signed_vma v
= disp
;
12507 /* Check for possible overflow on 0x8000000000000000. */
12510 strcpy (buf
, "9223372036854775808");
12524 tmp
[28 - i
] = (v
% 10) + '0';
12528 strcpy (buf
, tmp
+ 29 - i
);
12534 sprintf (buf
, "0x%x", (unsigned int) disp
);
12536 sprintf (buf
, "%d", (int) disp
);
12540 /* Put DISP in BUF as signed hex number. */
12543 print_displacement (char *buf
, bfd_vma disp
)
12545 bfd_signed_vma val
= disp
;
12554 /* Check for possible overflow. */
12557 switch (address_mode
)
12560 strcpy (buf
+ j
, "0x8000000000000000");
12563 strcpy (buf
+ j
, "0x80000000");
12566 strcpy (buf
+ j
, "0x8000");
12576 sprintf_vma (tmp
, (bfd_vma
) val
);
12577 for (i
= 0; tmp
[i
] == '0'; i
++)
12579 if (tmp
[i
] == '\0')
12581 strcpy (buf
+ j
, tmp
+ i
);
12585 intel_operand_size (int bytemode
, int sizeflag
)
12592 oappend ("BYTE PTR ");
12596 oappend ("WORD PTR ");
12599 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12601 oappend ("QWORD PTR ");
12610 oappend ("QWORD PTR ");
12613 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
12614 oappend ("DWORD PTR ");
12616 oappend ("WORD PTR ");
12617 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12621 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12623 oappend ("WORD PTR ");
12624 if (!(rex
& REX_W
))
12625 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12628 if (sizeflag
& DFLAG
)
12629 oappend ("QWORD PTR ");
12631 oappend ("DWORD PTR ");
12632 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12637 oappend ("DWORD PTR ");
12641 oappend ("QWORD PTR ");
12644 if (address_mode
== mode_64bit
)
12645 oappend ("QWORD PTR ");
12647 oappend ("DWORD PTR ");
12650 if (sizeflag
& DFLAG
)
12651 oappend ("FWORD PTR ");
12653 oappend ("DWORD PTR ");
12654 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12657 oappend ("TBYTE PTR ");
12663 switch (vex
.length
)
12666 oappend ("XMMWORD PTR ");
12669 oappend ("YMMWORD PTR ");
12676 oappend ("XMMWORD PTR ");
12679 oappend ("XMMWORD PTR ");
12685 switch (vex
.length
)
12688 oappend ("QWORD PTR ");
12691 oappend ("XMMWORD PTR ");
12701 switch (vex
.length
)
12704 oappend ("QWORD PTR ");
12707 oappend ("YMMWORD PTR ");
12714 oappend ("OWORD PTR ");
12716 case vex_w_dq_mode
:
12721 oappend ("QWORD PTR ");
12723 oappend ("DWORD PTR ");
12731 OP_E_register (int bytemode
, int sizeflag
)
12733 int reg
= modrm
.rm
;
12734 const char **names
;
12740 if ((sizeflag
& SUFFIX_ALWAYS
)
12741 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12764 names
= address_mode
== mode_64bit
? names64
: names32
;
12767 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12785 if ((sizeflag
& DFLAG
)
12786 || (bytemode
!= v_mode
12787 && bytemode
!= v_swap_mode
))
12791 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12797 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12800 oappend (names
[reg
]);
12804 OP_E_memory (int bytemode
, int sizeflag
)
12807 int add
= (rex
& REX_B
) ? 8 : 0;
12812 intel_operand_size (bytemode
, sizeflag
);
12815 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12817 /* 32/64 bit address mode */
12835 FETCH_DATA (the_info
, codep
+ 1);
12836 vindex
= (*codep
>> 3) & 7;
12837 scale
= (*codep
>> 6) & 3;
12842 haveindex
= vindex
!= 4;
12845 rbase
= base
+ add
;
12853 if (address_mode
== mode_64bit
&& !havesib
)
12859 FETCH_DATA (the_info
, codep
+ 1);
12861 if ((disp
& 0x80) != 0)
12869 /* In 32bit mode, we need index register to tell [offset] from
12870 [eiz*1 + offset]. */
12871 needindex
= (havesib
12874 && address_mode
== mode_32bit
);
12875 havedisp
= (havebase
12877 || (havesib
&& (haveindex
|| scale
!= 0)));
12880 if (modrm
.mod
!= 0 || base
== 5)
12882 if (havedisp
|| riprel
)
12883 print_displacement (scratchbuf
, disp
);
12885 print_operand_value (scratchbuf
, 1, disp
);
12886 oappend (scratchbuf
);
12890 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12894 if (havebase
|| haveindex
|| riprel
)
12895 used_prefixes
|= PREFIX_ADDR
;
12897 if (havedisp
|| (intel_syntax
&& riprel
))
12899 *obufp
++ = open_char
;
12900 if (intel_syntax
&& riprel
)
12903 oappend (sizeflag
& AFLAG
? "rip" : "eip");
12907 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
12908 ? names64
[rbase
] : names32
[rbase
]);
12911 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12912 print index to tell base + index from base. */
12916 || (havebase
&& base
!= ESP_REG_NUM
))
12918 if (!intel_syntax
|| havebase
)
12920 *obufp
++ = separator_char
;
12924 oappend (address_mode
== mode_64bit
12925 && (sizeflag
& AFLAG
)
12926 ? names64
[vindex
] : names32
[vindex
]);
12928 oappend (address_mode
== mode_64bit
12929 && (sizeflag
& AFLAG
)
12930 ? index64
: index32
);
12932 *obufp
++ = scale_char
;
12934 sprintf (scratchbuf
, "%d", 1 << scale
);
12935 oappend (scratchbuf
);
12939 && (disp
|| modrm
.mod
!= 0 || base
== 5))
12941 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
12946 else if (modrm
.mod
!= 1 && disp
!= -disp
)
12950 disp
= - (bfd_signed_vma
) disp
;
12954 print_displacement (scratchbuf
, disp
);
12956 print_operand_value (scratchbuf
, 1, disp
);
12957 oappend (scratchbuf
);
12960 *obufp
++ = close_char
;
12963 else if (intel_syntax
)
12965 if (modrm
.mod
!= 0 || base
== 5)
12967 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12968 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12972 oappend (names_seg
[ds_reg
- es_reg
]);
12975 print_operand_value (scratchbuf
, 1, disp
);
12976 oappend (scratchbuf
);
12982 /* 16 bit address mode */
12983 used_prefixes
|= prefixes
& PREFIX_ADDR
;
12990 if ((disp
& 0x8000) != 0)
12995 FETCH_DATA (the_info
, codep
+ 1);
12997 if ((disp
& 0x80) != 0)
13002 if ((disp
& 0x8000) != 0)
13008 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
13010 print_displacement (scratchbuf
, disp
);
13011 oappend (scratchbuf
);
13014 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
13016 *obufp
++ = open_char
;
13018 oappend (index16
[modrm
.rm
]);
13020 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
13022 if ((bfd_signed_vma
) disp
>= 0)
13027 else if (modrm
.mod
!= 1)
13031 disp
= - (bfd_signed_vma
) disp
;
13034 print_displacement (scratchbuf
, disp
);
13035 oappend (scratchbuf
);
13038 *obufp
++ = close_char
;
13041 else if (intel_syntax
)
13043 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13044 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13048 oappend (names_seg
[ds_reg
- es_reg
]);
13051 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
13052 oappend (scratchbuf
);
13058 OP_E (int bytemode
, int sizeflag
)
13060 /* Skip mod/rm byte. */
13064 if (modrm
.mod
== 3)
13065 OP_E_register (bytemode
, sizeflag
);
13067 OP_E_memory (bytemode
, sizeflag
);
13071 OP_G (int bytemode
, int sizeflag
)
13082 oappend (names8rex
[modrm
.reg
+ add
]);
13084 oappend (names8
[modrm
.reg
+ add
]);
13087 oappend (names16
[modrm
.reg
+ add
]);
13090 oappend (names32
[modrm
.reg
+ add
]);
13093 oappend (names64
[modrm
.reg
+ add
]);
13102 oappend (names64
[modrm
.reg
+ add
]);
13105 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
13106 oappend (names32
[modrm
.reg
+ add
]);
13108 oappend (names16
[modrm
.reg
+ add
]);
13109 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13113 if (address_mode
== mode_64bit
)
13114 oappend (names64
[modrm
.reg
+ add
]);
13116 oappend (names32
[modrm
.reg
+ add
]);
13119 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13132 FETCH_DATA (the_info
, codep
+ 8);
13133 a
= *codep
++ & 0xff;
13134 a
|= (*codep
++ & 0xff) << 8;
13135 a
|= (*codep
++ & 0xff) << 16;
13136 a
|= (*codep
++ & 0xff) << 24;
13137 b
= *codep
++ & 0xff;
13138 b
|= (*codep
++ & 0xff) << 8;
13139 b
|= (*codep
++ & 0xff) << 16;
13140 b
|= (*codep
++ & 0xff) << 24;
13141 x
= a
+ ((bfd_vma
) b
<< 32);
13149 static bfd_signed_vma
13152 bfd_signed_vma x
= 0;
13154 FETCH_DATA (the_info
, codep
+ 4);
13155 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13156 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13157 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13158 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13162 static bfd_signed_vma
13165 bfd_signed_vma x
= 0;
13167 FETCH_DATA (the_info
, codep
+ 4);
13168 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13169 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13170 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13171 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13173 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
13183 FETCH_DATA (the_info
, codep
+ 2);
13184 x
= *codep
++ & 0xff;
13185 x
|= (*codep
++ & 0xff) << 8;
13190 set_op (bfd_vma op
, int riprel
)
13192 op_index
[op_ad
] = op_ad
;
13193 if (address_mode
== mode_64bit
)
13195 op_address
[op_ad
] = op
;
13196 op_riprel
[op_ad
] = riprel
;
13200 /* Mask to get a 32-bit address. */
13201 op_address
[op_ad
] = op
& 0xffffffff;
13202 op_riprel
[op_ad
] = riprel
& 0xffffffff;
13207 OP_REG (int code
, int sizeflag
)
13219 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13220 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13221 s
= names16
[code
- ax_reg
+ add
];
13223 case es_reg
: case ss_reg
: case cs_reg
:
13224 case ds_reg
: case fs_reg
: case gs_reg
:
13225 s
= names_seg
[code
- es_reg
+ add
];
13227 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13228 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13231 s
= names8rex
[code
- al_reg
+ add
];
13233 s
= names8
[code
- al_reg
];
13235 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
13236 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
13237 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13239 s
= names64
[code
- rAX_reg
+ add
];
13242 code
+= eAX_reg
- rAX_reg
;
13243 /* Fall through. */
13244 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13245 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13248 s
= names64
[code
- eAX_reg
+ add
];
13251 if (sizeflag
& DFLAG
)
13252 s
= names32
[code
- eAX_reg
+ add
];
13254 s
= names16
[code
- eAX_reg
+ add
];
13255 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13259 s
= INTERNAL_DISASSEMBLER_ERROR
;
13266 OP_IMREG (int code
, int sizeflag
)
13278 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13279 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13280 s
= names16
[code
- ax_reg
];
13282 case es_reg
: case ss_reg
: case cs_reg
:
13283 case ds_reg
: case fs_reg
: case gs_reg
:
13284 s
= names_seg
[code
- es_reg
];
13286 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13287 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13290 s
= names8rex
[code
- al_reg
];
13292 s
= names8
[code
- al_reg
];
13294 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13295 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13298 s
= names64
[code
- eAX_reg
];
13301 if (sizeflag
& DFLAG
)
13302 s
= names32
[code
- eAX_reg
];
13304 s
= names16
[code
- eAX_reg
];
13305 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13308 case z_mode_ax_reg
:
13309 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13313 if (!(rex
& REX_W
))
13314 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13317 s
= INTERNAL_DISASSEMBLER_ERROR
;
13324 OP_I (int bytemode
, int sizeflag
)
13327 bfd_signed_vma mask
= -1;
13332 FETCH_DATA (the_info
, codep
+ 1);
13337 if (address_mode
== mode_64bit
)
13342 /* Fall through. */
13349 if (sizeflag
& DFLAG
)
13359 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13371 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13376 scratchbuf
[0] = '$';
13377 print_operand_value (scratchbuf
+ 1, 1, op
);
13378 oappend (scratchbuf
+ intel_syntax
);
13379 scratchbuf
[0] = '\0';
13383 OP_I64 (int bytemode
, int sizeflag
)
13386 bfd_signed_vma mask
= -1;
13388 if (address_mode
!= mode_64bit
)
13390 OP_I (bytemode
, sizeflag
);
13397 FETCH_DATA (the_info
, codep
+ 1);
13407 if (sizeflag
& DFLAG
)
13417 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13425 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13430 scratchbuf
[0] = '$';
13431 print_operand_value (scratchbuf
+ 1, 1, op
);
13432 oappend (scratchbuf
+ intel_syntax
);
13433 scratchbuf
[0] = '\0';
13437 OP_sI (int bytemode
, int sizeflag
)
13440 bfd_signed_vma mask
= -1;
13445 FETCH_DATA (the_info
, codep
+ 1);
13447 if ((op
& 0x80) != 0)
13457 if (sizeflag
& DFLAG
)
13466 if ((op
& 0x8000) != 0)
13469 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13475 if ((op
& 0x8000) != 0)
13479 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13483 scratchbuf
[0] = '$';
13484 print_operand_value (scratchbuf
+ 1, 1, op
);
13485 oappend (scratchbuf
+ intel_syntax
);
13489 OP_J (int bytemode
, int sizeflag
)
13493 bfd_vma segment
= 0;
13498 FETCH_DATA (the_info
, codep
+ 1);
13500 if ((disp
& 0x80) != 0)
13505 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
13510 if ((disp
& 0x8000) != 0)
13512 /* In 16bit mode, address is wrapped around at 64k within
13513 the same segment. Otherwise, a data16 prefix on a jump
13514 instruction means that the pc is masked to 16 bits after
13515 the displacement is added! */
13517 if ((prefixes
& PREFIX_DATA
) == 0)
13518 segment
= ((start_pc
+ codep
- start_codep
)
13519 & ~((bfd_vma
) 0xffff));
13521 if (!(rex
& REX_W
))
13522 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13525 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13528 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
13530 print_operand_value (scratchbuf
, 1, disp
);
13531 oappend (scratchbuf
);
13535 OP_SEG (int bytemode
, int sizeflag
)
13537 if (bytemode
== w_mode
)
13538 oappend (names_seg
[modrm
.reg
]);
13540 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
13544 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
13548 if (sizeflag
& DFLAG
)
13558 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13560 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
13562 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
13563 oappend (scratchbuf
);
13567 OP_OFF (int bytemode
, int sizeflag
)
13571 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13572 intel_operand_size (bytemode
, sizeflag
);
13575 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13582 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13583 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13585 oappend (names_seg
[ds_reg
- es_reg
]);
13589 print_operand_value (scratchbuf
, 1, off
);
13590 oappend (scratchbuf
);
13594 OP_OFF64 (int bytemode
, int sizeflag
)
13598 if (address_mode
!= mode_64bit
13599 || (prefixes
& PREFIX_ADDR
))
13601 OP_OFF (bytemode
, sizeflag
);
13605 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13606 intel_operand_size (bytemode
, sizeflag
);
13613 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13614 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13616 oappend (names_seg
[ds_reg
- es_reg
]);
13620 print_operand_value (scratchbuf
, 1, off
);
13621 oappend (scratchbuf
);
13625 ptr_reg (int code
, int sizeflag
)
13629 *obufp
++ = open_char
;
13630 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13631 if (address_mode
== mode_64bit
)
13633 if (!(sizeflag
& AFLAG
))
13634 s
= names32
[code
- eAX_reg
];
13636 s
= names64
[code
- eAX_reg
];
13638 else if (sizeflag
& AFLAG
)
13639 s
= names32
[code
- eAX_reg
];
13641 s
= names16
[code
- eAX_reg
];
13643 *obufp
++ = close_char
;
13648 OP_ESreg (int code
, int sizeflag
)
13654 case 0x6d: /* insw/insl */
13655 intel_operand_size (z_mode
, sizeflag
);
13657 case 0xa5: /* movsw/movsl/movsq */
13658 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13659 case 0xab: /* stosw/stosl */
13660 case 0xaf: /* scasw/scasl */
13661 intel_operand_size (v_mode
, sizeflag
);
13664 intel_operand_size (b_mode
, sizeflag
);
13667 oappend ("%es:" + intel_syntax
);
13668 ptr_reg (code
, sizeflag
);
13672 OP_DSreg (int code
, int sizeflag
)
13678 case 0x6f: /* outsw/outsl */
13679 intel_operand_size (z_mode
, sizeflag
);
13681 case 0xa5: /* movsw/movsl/movsq */
13682 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13683 case 0xad: /* lodsw/lodsl/lodsq */
13684 intel_operand_size (v_mode
, sizeflag
);
13687 intel_operand_size (b_mode
, sizeflag
);
13696 | PREFIX_GS
)) == 0)
13697 prefixes
|= PREFIX_DS
;
13699 ptr_reg (code
, sizeflag
);
13703 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13711 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13713 all_prefixes
[last_lock_prefix
] = 0;
13714 used_prefixes
|= PREFIX_LOCK
;
13719 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13720 oappend (scratchbuf
+ intel_syntax
);
13724 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13733 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13735 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13736 oappend (scratchbuf
);
13740 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13742 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13743 oappend (scratchbuf
+ intel_syntax
);
13747 OP_R (int bytemode
, int sizeflag
)
13749 if (modrm
.mod
== 3)
13750 OP_E (bytemode
, sizeflag
);
13756 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13758 int reg
= modrm
.reg
;
13759 const char **names
;
13761 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13762 if (prefixes
& PREFIX_DATA
)
13771 oappend (names
[reg
]);
13775 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13777 int reg
= modrm
.reg
;
13778 const char **names
;
13783 if (need_vex
&& bytemode
!= xmm_mode
)
13785 switch (vex
.length
)
13799 oappend (names
[reg
]);
13803 OP_EM (int bytemode
, int sizeflag
)
13806 const char **names
;
13808 if (modrm
.mod
!= 3)
13811 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13813 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13814 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13816 OP_E (bytemode
, sizeflag
);
13820 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13823 /* Skip mod/rm byte. */
13826 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13828 if (prefixes
& PREFIX_DATA
)
13837 oappend (names
[reg
]);
13840 /* cvt* are the only instructions in sse2 which have
13841 both SSE and MMX operands and also have 0x66 prefix
13842 in their opcode. 0x66 was originally used to differentiate
13843 between SSE and MMX instruction(operands). So we have to handle the
13844 cvt* separately using OP_EMC and OP_MXC */
13846 OP_EMC (int bytemode
, int sizeflag
)
13848 if (modrm
.mod
!= 3)
13850 if (intel_syntax
&& bytemode
== v_mode
)
13852 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13853 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13855 OP_E (bytemode
, sizeflag
);
13859 /* Skip mod/rm byte. */
13862 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13863 oappend (names_mm
[modrm
.rm
]);
13867 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13869 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13870 oappend (names_mm
[modrm
.reg
]);
13874 OP_EX (int bytemode
, int sizeflag
)
13877 const char **names
;
13879 /* Skip mod/rm byte. */
13883 if (modrm
.mod
!= 3)
13885 OP_E_memory (bytemode
, sizeflag
);
13894 if ((sizeflag
& SUFFIX_ALWAYS
)
13895 && (bytemode
== x_swap_mode
13896 || bytemode
== d_swap_mode
13897 || bytemode
== q_swap_mode
))
13901 && bytemode
!= xmm_mode
13902 && bytemode
!= xmmq_mode
)
13904 switch (vex
.length
)
13918 oappend (names
[reg
]);
13922 OP_MS (int bytemode
, int sizeflag
)
13924 if (modrm
.mod
== 3)
13925 OP_EM (bytemode
, sizeflag
);
13931 OP_XS (int bytemode
, int sizeflag
)
13933 if (modrm
.mod
== 3)
13934 OP_EX (bytemode
, sizeflag
);
13940 OP_M (int bytemode
, int sizeflag
)
13942 if (modrm
.mod
== 3)
13943 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
13946 OP_E (bytemode
, sizeflag
);
13950 OP_0f07 (int bytemode
, int sizeflag
)
13952 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
13955 OP_E (bytemode
, sizeflag
);
13958 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
13959 32bit mode and "xchg %rax,%rax" in 64bit mode. */
13962 NOP_Fixup1 (int bytemode
, int sizeflag
)
13964 if ((prefixes
& PREFIX_DATA
) != 0
13967 && address_mode
== mode_64bit
))
13968 OP_REG (bytemode
, sizeflag
);
13970 strcpy (obuf
, "nop");
13974 NOP_Fixup2 (int bytemode
, int sizeflag
)
13976 if ((prefixes
& PREFIX_DATA
) != 0
13979 && address_mode
== mode_64bit
))
13980 OP_IMREG (bytemode
, sizeflag
);
13983 static const char *const Suffix3DNow
[] = {
13984 /* 00 */ NULL
, NULL
, NULL
, NULL
,
13985 /* 04 */ NULL
, NULL
, NULL
, NULL
,
13986 /* 08 */ NULL
, NULL
, NULL
, NULL
,
13987 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
13988 /* 10 */ NULL
, NULL
, NULL
, NULL
,
13989 /* 14 */ NULL
, NULL
, NULL
, NULL
,
13990 /* 18 */ NULL
, NULL
, NULL
, NULL
,
13991 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
13992 /* 20 */ NULL
, NULL
, NULL
, NULL
,
13993 /* 24 */ NULL
, NULL
, NULL
, NULL
,
13994 /* 28 */ NULL
, NULL
, NULL
, NULL
,
13995 /* 2C */ NULL
, NULL
, NULL
, NULL
,
13996 /* 30 */ NULL
, NULL
, NULL
, NULL
,
13997 /* 34 */ NULL
, NULL
, NULL
, NULL
,
13998 /* 38 */ NULL
, NULL
, NULL
, NULL
,
13999 /* 3C */ NULL
, NULL
, NULL
, NULL
,
14000 /* 40 */ NULL
, NULL
, NULL
, NULL
,
14001 /* 44 */ NULL
, NULL
, NULL
, NULL
,
14002 /* 48 */ NULL
, NULL
, NULL
, NULL
,
14003 /* 4C */ NULL
, NULL
, NULL
, NULL
,
14004 /* 50 */ NULL
, NULL
, NULL
, NULL
,
14005 /* 54 */ NULL
, NULL
, NULL
, NULL
,
14006 /* 58 */ NULL
, NULL
, NULL
, NULL
,
14007 /* 5C */ NULL
, NULL
, NULL
, NULL
,
14008 /* 60 */ NULL
, NULL
, NULL
, NULL
,
14009 /* 64 */ NULL
, NULL
, NULL
, NULL
,
14010 /* 68 */ NULL
, NULL
, NULL
, NULL
,
14011 /* 6C */ NULL
, NULL
, NULL
, NULL
,
14012 /* 70 */ NULL
, NULL
, NULL
, NULL
,
14013 /* 74 */ NULL
, NULL
, NULL
, NULL
,
14014 /* 78 */ NULL
, NULL
, NULL
, NULL
,
14015 /* 7C */ NULL
, NULL
, NULL
, NULL
,
14016 /* 80 */ NULL
, NULL
, NULL
, NULL
,
14017 /* 84 */ NULL
, NULL
, NULL
, NULL
,
14018 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
14019 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
14020 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
14021 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
14022 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
14023 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
14024 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
14025 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
14026 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
14027 /* AC */ NULL
, NULL
, "pfacc", NULL
,
14028 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
14029 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
14030 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
14031 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
14032 /* C0 */ NULL
, NULL
, NULL
, NULL
,
14033 /* C4 */ NULL
, NULL
, NULL
, NULL
,
14034 /* C8 */ NULL
, NULL
, NULL
, NULL
,
14035 /* CC */ NULL
, NULL
, NULL
, NULL
,
14036 /* D0 */ NULL
, NULL
, NULL
, NULL
,
14037 /* D4 */ NULL
, NULL
, NULL
, NULL
,
14038 /* D8 */ NULL
, NULL
, NULL
, NULL
,
14039 /* DC */ NULL
, NULL
, NULL
, NULL
,
14040 /* E0 */ NULL
, NULL
, NULL
, NULL
,
14041 /* E4 */ NULL
, NULL
, NULL
, NULL
,
14042 /* E8 */ NULL
, NULL
, NULL
, NULL
,
14043 /* EC */ NULL
, NULL
, NULL
, NULL
,
14044 /* F0 */ NULL
, NULL
, NULL
, NULL
,
14045 /* F4 */ NULL
, NULL
, NULL
, NULL
,
14046 /* F8 */ NULL
, NULL
, NULL
, NULL
,
14047 /* FC */ NULL
, NULL
, NULL
, NULL
,
14051 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14053 const char *mnemonic
;
14055 FETCH_DATA (the_info
, codep
+ 1);
14056 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14057 place where an 8-bit immediate would normally go. ie. the last
14058 byte of the instruction. */
14059 obufp
= mnemonicendp
;
14060 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
14062 oappend (mnemonic
);
14065 /* Since a variable sized modrm/sib chunk is between the start
14066 of the opcode (0x0f0f) and the opcode suffix, we need to do
14067 all the modrm processing first, and don't know until now that
14068 we have a bad opcode. This necessitates some cleaning up. */
14069 op_out
[0][0] = '\0';
14070 op_out
[1][0] = '\0';
14073 mnemonicendp
= obufp
;
14076 static struct op simd_cmp_op
[] =
14078 { STRING_COMMA_LEN ("eq") },
14079 { STRING_COMMA_LEN ("lt") },
14080 { STRING_COMMA_LEN ("le") },
14081 { STRING_COMMA_LEN ("unord") },
14082 { STRING_COMMA_LEN ("neq") },
14083 { STRING_COMMA_LEN ("nlt") },
14084 { STRING_COMMA_LEN ("nle") },
14085 { STRING_COMMA_LEN ("ord") }
14089 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14091 unsigned int cmp_type
;
14093 FETCH_DATA (the_info
, codep
+ 1);
14094 cmp_type
= *codep
++ & 0xff;
14095 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
14098 char *p
= mnemonicendp
- 2;
14102 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
14103 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
14107 /* We have a reserved extension byte. Output it directly. */
14108 scratchbuf
[0] = '$';
14109 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14110 oappend (scratchbuf
+ intel_syntax
);
14111 scratchbuf
[0] = '\0';
14116 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
14117 int sizeflag ATTRIBUTE_UNUSED
)
14119 /* mwait %eax,%ecx */
14122 const char **names
= (address_mode
== mode_64bit
14123 ? names64
: names32
);
14124 strcpy (op_out
[0], names
[0]);
14125 strcpy (op_out
[1], names
[1]);
14126 two_source_ops
= 1;
14128 /* Skip mod/rm byte. */
14134 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
14135 int sizeflag ATTRIBUTE_UNUSED
)
14137 /* monitor %eax,%ecx,%edx" */
14140 const char **op1_names
;
14141 const char **names
= (address_mode
== mode_64bit
14142 ? names64
: names32
);
14144 if (!(prefixes
& PREFIX_ADDR
))
14145 op1_names
= (address_mode
== mode_16bit
14146 ? names16
: names
);
14149 /* Remove "addr16/addr32". */
14150 all_prefixes
[last_addr_prefix
] = 0;
14151 op1_names
= (address_mode
!= mode_32bit
14152 ? names32
: names16
);
14153 used_prefixes
|= PREFIX_ADDR
;
14155 strcpy (op_out
[0], op1_names
[0]);
14156 strcpy (op_out
[1], names
[1]);
14157 strcpy (op_out
[2], names
[2]);
14158 two_source_ops
= 1;
14160 /* Skip mod/rm byte. */
14168 /* Throw away prefixes and 1st. opcode byte. */
14169 codep
= insn_codep
+ 1;
14174 REP_Fixup (int bytemode
, int sizeflag
)
14176 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
14178 if (prefixes
& PREFIX_REPZ
)
14179 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
14186 OP_IMREG (bytemode
, sizeflag
);
14189 OP_ESreg (bytemode
, sizeflag
);
14192 OP_DSreg (bytemode
, sizeflag
);
14201 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
14206 /* Change cmpxchg8b to cmpxchg16b. */
14207 char *p
= mnemonicendp
- 2;
14208 mnemonicendp
= stpcpy (p
, "16b");
14211 OP_M (bytemode
, sizeflag
);
14215 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
14217 const char **names
;
14221 switch (vex
.length
)
14235 oappend (names
[reg
]);
14239 CRC32_Fixup (int bytemode
, int sizeflag
)
14241 /* Add proper suffix to "crc32". */
14242 char *p
= mnemonicendp
;
14261 if (sizeflag
& DFLAG
)
14265 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14269 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14276 if (modrm
.mod
== 3)
14280 /* Skip mod/rm byte. */
14285 add
= (rex
& REX_B
) ? 8 : 0;
14286 if (bytemode
== b_mode
)
14290 oappend (names8rex
[modrm
.rm
+ add
]);
14292 oappend (names8
[modrm
.rm
+ add
]);
14298 oappend (names64
[modrm
.rm
+ add
]);
14299 else if ((prefixes
& PREFIX_DATA
))
14300 oappend (names16
[modrm
.rm
+ add
]);
14302 oappend (names32
[modrm
.rm
+ add
]);
14306 OP_E (bytemode
, sizeflag
);
14310 FXSAVE_Fixup (int bytemode
, int sizeflag
)
14312 /* Add proper suffix to "fxsave" and "fxrstor". */
14316 char *p
= mnemonicendp
;
14322 OP_M (bytemode
, sizeflag
);
14325 /* Display the destination register operand for instructions with
14329 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14331 const char **names
;
14339 switch (vex
.length
)
14371 oappend (names
[vex
.register_specifier
]);
14374 /* Get the VEX immediate byte without moving codep. */
14376 static unsigned char
14377 get_vex_imm8 (int sizeflag
, int opnum
)
14379 int bytes_before_imm
= 0;
14381 if (modrm
.mod
!= 3)
14383 /* There are SIB/displacement bytes. */
14384 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14386 /* 32/64 bit address mode */
14387 int base
= modrm
.rm
;
14389 /* Check SIB byte. */
14392 FETCH_DATA (the_info
, codep
+ 1);
14394 /* When decoding the third source, don't increase
14395 bytes_before_imm as this has already been incremented
14396 by one in OP_E_memory while decoding the second
14399 bytes_before_imm
++;
14402 /* Don't increase bytes_before_imm when decoding the third source,
14403 it has already been incremented by OP_E_memory while decoding
14404 the second source operand. */
14410 /* When modrm.rm == 5 or modrm.rm == 4 and base in
14411 SIB == 5, there is a 4 byte displacement. */
14413 /* No displacement. */
14416 /* 4 byte displacement. */
14417 bytes_before_imm
+= 4;
14420 /* 1 byte displacement. */
14421 bytes_before_imm
++;
14428 /* 16 bit address mode */
14429 /* Don't increase bytes_before_imm when decoding the third source,
14430 it has already been incremented by OP_E_memory while decoding
14431 the second source operand. */
14437 /* When modrm.rm == 6, there is a 2 byte displacement. */
14439 /* No displacement. */
14442 /* 2 byte displacement. */
14443 bytes_before_imm
+= 2;
14446 /* 1 byte displacement: when decoding the third source,
14447 don't increase bytes_before_imm as this has already
14448 been incremented by one in OP_E_memory while decoding
14449 the second source operand. */
14451 bytes_before_imm
++;
14459 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
14460 return codep
[bytes_before_imm
];
14464 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
14466 const char **names
;
14468 if (reg
== -1 && modrm
.mod
!= 3)
14470 OP_E_memory (bytemode
, sizeflag
);
14482 else if (reg
> 7 && address_mode
!= mode_64bit
)
14486 switch (vex
.length
)
14497 oappend (names
[reg
]);
14501 OP_Vex_2src (int bytemode
, int sizeflag
)
14503 if (modrm
.mod
== 3)
14505 int reg
= modrm
.rm
;
14509 oappend (names_xmm
[reg
]);
14514 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14516 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14517 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14519 OP_E (bytemode
, sizeflag
);
14524 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
14526 if (modrm
.mod
== 3)
14528 /* Skip mod/rm byte. */
14534 oappend (names_xmm
[vex
.register_specifier
]);
14536 OP_Vex_2src (bytemode
, sizeflag
);
14540 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
14543 OP_Vex_2src (bytemode
, sizeflag
);
14545 oappend (names_xmm
[vex
.register_specifier
]);
14549 OP_EX_VexW (int bytemode
, int sizeflag
)
14557 /* Skip mod/rm byte. */
14562 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
14567 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
14570 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14574 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14575 int sizeflag ATTRIBUTE_UNUSED
)
14577 /* Skip the immediate byte and check for invalid bits. */
14578 FETCH_DATA (the_info
, codep
+ 1);
14579 if (*codep
++ & 0xf)
14584 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14587 const char **names
;
14589 FETCH_DATA (the_info
, codep
+ 1);
14592 if (bytemode
!= x_mode
)
14599 if (reg
> 7 && address_mode
!= mode_64bit
)
14602 switch (vex
.length
)
14613 oappend (names
[reg
]);
14617 OP_XMM_VexW (int bytemode
, int sizeflag
)
14619 /* Turn off the REX.W bit since it is used for swapping operands
14622 OP_XMM (bytemode
, sizeflag
);
14626 OP_EX_Vex (int bytemode
, int sizeflag
)
14628 if (modrm
.mod
!= 3)
14630 if (vex
.register_specifier
!= 0)
14634 OP_EX (bytemode
, sizeflag
);
14638 OP_XMM_Vex (int bytemode
, int sizeflag
)
14640 if (modrm
.mod
!= 3)
14642 if (vex
.register_specifier
!= 0)
14646 OP_XMM (bytemode
, sizeflag
);
14650 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14652 switch (vex
.length
)
14655 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
14658 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14665 static struct op vex_cmp_op
[] =
14667 { STRING_COMMA_LEN ("eq") },
14668 { STRING_COMMA_LEN ("lt") },
14669 { STRING_COMMA_LEN ("le") },
14670 { STRING_COMMA_LEN ("unord") },
14671 { STRING_COMMA_LEN ("neq") },
14672 { STRING_COMMA_LEN ("nlt") },
14673 { STRING_COMMA_LEN ("nle") },
14674 { STRING_COMMA_LEN ("ord") },
14675 { STRING_COMMA_LEN ("eq_uq") },
14676 { STRING_COMMA_LEN ("nge") },
14677 { STRING_COMMA_LEN ("ngt") },
14678 { STRING_COMMA_LEN ("false") },
14679 { STRING_COMMA_LEN ("neq_oq") },
14680 { STRING_COMMA_LEN ("ge") },
14681 { STRING_COMMA_LEN ("gt") },
14682 { STRING_COMMA_LEN ("true") },
14683 { STRING_COMMA_LEN ("eq_os") },
14684 { STRING_COMMA_LEN ("lt_oq") },
14685 { STRING_COMMA_LEN ("le_oq") },
14686 { STRING_COMMA_LEN ("unord_s") },
14687 { STRING_COMMA_LEN ("neq_us") },
14688 { STRING_COMMA_LEN ("nlt_uq") },
14689 { STRING_COMMA_LEN ("nle_uq") },
14690 { STRING_COMMA_LEN ("ord_s") },
14691 { STRING_COMMA_LEN ("eq_us") },
14692 { STRING_COMMA_LEN ("nge_uq") },
14693 { STRING_COMMA_LEN ("ngt_uq") },
14694 { STRING_COMMA_LEN ("false_os") },
14695 { STRING_COMMA_LEN ("neq_os") },
14696 { STRING_COMMA_LEN ("ge_oq") },
14697 { STRING_COMMA_LEN ("gt_oq") },
14698 { STRING_COMMA_LEN ("true_us") },
14702 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14704 unsigned int cmp_type
;
14706 FETCH_DATA (the_info
, codep
+ 1);
14707 cmp_type
= *codep
++ & 0xff;
14708 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14711 char *p
= mnemonicendp
- 2;
14715 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14716 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14720 /* We have a reserved extension byte. Output it directly. */
14721 scratchbuf
[0] = '$';
14722 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14723 oappend (scratchbuf
+ intel_syntax
);
14724 scratchbuf
[0] = '\0';
14728 static const struct op pclmul_op
[] =
14730 { STRING_COMMA_LEN ("lql") },
14731 { STRING_COMMA_LEN ("hql") },
14732 { STRING_COMMA_LEN ("lqh") },
14733 { STRING_COMMA_LEN ("hqh") }
14737 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14738 int sizeflag ATTRIBUTE_UNUSED
)
14740 unsigned int pclmul_type
;
14742 FETCH_DATA (the_info
, codep
+ 1);
14743 pclmul_type
= *codep
++ & 0xff;
14744 switch (pclmul_type
)
14755 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14758 char *p
= mnemonicendp
- 3;
14763 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14764 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14768 /* We have a reserved extension byte. Output it directly. */
14769 scratchbuf
[0] = '$';
14770 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14771 oappend (scratchbuf
+ intel_syntax
);
14772 scratchbuf
[0] = '\0';
14777 MOVBE_Fixup (int bytemode
, int sizeflag
)
14779 /* Add proper suffix to "movbe". */
14780 char *p
= mnemonicendp
;
14789 if (sizeflag
& SUFFIX_ALWAYS
)
14795 if (sizeflag
& DFLAG
)
14799 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14804 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14811 OP_M (bytemode
, sizeflag
);
14815 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14818 const char **names
;
14820 /* Skip mod/rm byte. */
14826 else if (vex
.length
== 256)
14836 oappend (names
[reg
]);
14840 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14842 const char **names
;
14846 else if (vex
.length
== 256)
14851 oappend (names
[vex
.register_specifier
]);
14855 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
14857 if (vex
.w
|| vex
.length
== 256)
14858 OP_I (q_mode
, sizeflag
);
14860 OP_I (w_mode
, sizeflag
);