1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma
, disassemble_info
*);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma
);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma
);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma
get64 (void);
60 static bfd_signed_vma
get32 (void);
61 static bfd_signed_vma
get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma
, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_EX_VexImmW (int, int);
95 static void OP_XMM_Vex (int, int);
96 static void OP_XMM_VexW (int, int);
97 static void OP_REG_VexI4 (int, int);
98 static void PCLMUL_Fixup (int, int);
99 static void VEXI4_Fixup (int, int);
100 static void VZERO_Fixup (int, int);
101 static void VCMP_Fixup (int, int);
102 static void OP_0f07 (int, int);
103 static void OP_Monitor (int, int);
104 static void OP_Mwait (int, int);
105 static void NOP_Fixup1 (int, int);
106 static void NOP_Fixup2 (int, int);
107 static void OP_3DNowSuffix (int, int);
108 static void CMP_Fixup (int, int);
109 static void BadOp (void);
110 static void REP_Fixup (int, int);
111 static void CMPXCHG8B_Fixup (int, int);
112 static void XMM_Fixup (int, int);
113 static void CRC32_Fixup (int, int);
114 static void FXSAVE_Fixup (int, int);
115 static void OP_LWPCB_E (int, int);
116 static void OP_LWP_E (int, int);
117 static void OP_LWP_I (int, int);
118 static void OP_Vex_2src_1 (int, int);
119 static void OP_Vex_2src_2 (int, int);
121 static void MOVBE_Fixup (int, int);
124 /* Points to first byte not fetched. */
125 bfd_byte
*max_fetched
;
126 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
139 enum address_mode address_mode
;
141 /* Flags for the prefixes for the current instruction. See below. */
144 /* REX prefix the current instruction. See below. */
146 /* Bits of REX we've already used. */
148 /* REX bits in original REX prefix ignored. */
149 static int rex_ignored
;
150 /* Mark parts used in the REX prefix. When we are testing for
151 empty prefix (for 8bit register REX extension), just mask it
152 out. Otherwise test for REX bit is excuse for existence of REX
153 only in case value is nonzero. */
154 #define USED_REX(value) \
159 rex_used |= (value) | REX_OPCODE; \
162 rex_used |= REX_OPCODE; \
165 /* Flags for prefixes which we somehow handled when printing the
166 current instruction. */
167 static int used_prefixes
;
169 /* Flags stored in PREFIXES. */
170 #define PREFIX_REPZ 1
171 #define PREFIX_REPNZ 2
172 #define PREFIX_LOCK 4
174 #define PREFIX_SS 0x10
175 #define PREFIX_DS 0x20
176 #define PREFIX_ES 0x40
177 #define PREFIX_FS 0x80
178 #define PREFIX_GS 0x100
179 #define PREFIX_DATA 0x200
180 #define PREFIX_ADDR 0x400
181 #define PREFIX_FWAIT 0x800
183 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
184 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
186 #define FETCH_DATA(info, addr) \
187 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
188 ? 1 : fetch_data ((info), (addr)))
191 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
194 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
195 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
197 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
198 status
= (*info
->read_memory_func
) (start
,
200 addr
- priv
->max_fetched
,
206 /* If we did manage to read at least one byte, then
207 print_insn_i386 will do something sensible. Otherwise, print
208 an error. We do that here because this is where we know
210 if (priv
->max_fetched
== priv
->the_buffer
)
211 (*info
->memory_error_func
) (status
, start
, info
);
212 longjmp (priv
->bailout
, 1);
215 priv
->max_fetched
= addr
;
219 #define XX { NULL, 0 }
220 #define Bad_Opcode NULL, { { NULL, 0 } }
222 #define Eb { OP_E, b_mode }
223 #define EbS { OP_E, b_swap_mode }
224 #define Ev { OP_E, v_mode }
225 #define EvS { OP_E, v_swap_mode }
226 #define Ed { OP_E, d_mode }
227 #define Edq { OP_E, dq_mode }
228 #define Edqw { OP_E, dqw_mode }
229 #define Edqb { OP_E, dqb_mode }
230 #define Edqd { OP_E, dqd_mode }
231 #define Eq { OP_E, q_mode }
232 #define indirEv { OP_indirE, stack_v_mode }
233 #define indirEp { OP_indirE, f_mode }
234 #define stackEv { OP_E, stack_v_mode }
235 #define Em { OP_E, m_mode }
236 #define Ew { OP_E, w_mode }
237 #define M { OP_M, 0 } /* lea, lgdt, etc. */
238 #define Ma { OP_M, a_mode }
239 #define Mb { OP_M, b_mode }
240 #define Md { OP_M, d_mode }
241 #define Mo { OP_M, o_mode }
242 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
243 #define Mq { OP_M, q_mode }
244 #define Mx { OP_M, x_mode }
245 #define Mxmm { OP_M, xmm_mode }
246 #define Gb { OP_G, b_mode }
247 #define Gv { OP_G, v_mode }
248 #define Gd { OP_G, d_mode }
249 #define Gdq { OP_G, dq_mode }
250 #define Gm { OP_G, m_mode }
251 #define Gw { OP_G, w_mode }
252 #define Rd { OP_R, d_mode }
253 #define Rm { OP_R, m_mode }
254 #define Ib { OP_I, b_mode }
255 #define sIb { OP_sI, b_mode } /* sign extened byte */
256 #define Iv { OP_I, v_mode }
257 #define Iq { OP_I, q_mode }
258 #define Iv64 { OP_I64, v_mode }
259 #define Iw { OP_I, w_mode }
260 #define I1 { OP_I, const_1_mode }
261 #define Jb { OP_J, b_mode }
262 #define Jv { OP_J, v_mode }
263 #define Cm { OP_C, m_mode }
264 #define Dm { OP_D, m_mode }
265 #define Td { OP_T, d_mode }
266 #define Skip_MODRM { OP_Skip_MODRM, 0 }
268 #define RMeAX { OP_REG, eAX_reg }
269 #define RMeBX { OP_REG, eBX_reg }
270 #define RMeCX { OP_REG, eCX_reg }
271 #define RMeDX { OP_REG, eDX_reg }
272 #define RMeSP { OP_REG, eSP_reg }
273 #define RMeBP { OP_REG, eBP_reg }
274 #define RMeSI { OP_REG, eSI_reg }
275 #define RMeDI { OP_REG, eDI_reg }
276 #define RMrAX { OP_REG, rAX_reg }
277 #define RMrBX { OP_REG, rBX_reg }
278 #define RMrCX { OP_REG, rCX_reg }
279 #define RMrDX { OP_REG, rDX_reg }
280 #define RMrSP { OP_REG, rSP_reg }
281 #define RMrBP { OP_REG, rBP_reg }
282 #define RMrSI { OP_REG, rSI_reg }
283 #define RMrDI { OP_REG, rDI_reg }
284 #define RMAL { OP_REG, al_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMCL { OP_REG, cl_reg }
287 #define RMDL { OP_REG, dl_reg }
288 #define RMBL { OP_REG, bl_reg }
289 #define RMAH { OP_REG, ah_reg }
290 #define RMCH { OP_REG, ch_reg }
291 #define RMDH { OP_REG, dh_reg }
292 #define RMBH { OP_REG, bh_reg }
293 #define RMAX { OP_REG, ax_reg }
294 #define RMDX { OP_REG, dx_reg }
296 #define eAX { OP_IMREG, eAX_reg }
297 #define eBX { OP_IMREG, eBX_reg }
298 #define eCX { OP_IMREG, eCX_reg }
299 #define eDX { OP_IMREG, eDX_reg }
300 #define eSP { OP_IMREG, eSP_reg }
301 #define eBP { OP_IMREG, eBP_reg }
302 #define eSI { OP_IMREG, eSI_reg }
303 #define eDI { OP_IMREG, eDI_reg }
304 #define AL { OP_IMREG, al_reg }
305 #define CL { OP_IMREG, cl_reg }
306 #define DL { OP_IMREG, dl_reg }
307 #define BL { OP_IMREG, bl_reg }
308 #define AH { OP_IMREG, ah_reg }
309 #define CH { OP_IMREG, ch_reg }
310 #define DH { OP_IMREG, dh_reg }
311 #define BH { OP_IMREG, bh_reg }
312 #define AX { OP_IMREG, ax_reg }
313 #define DX { OP_IMREG, dx_reg }
314 #define zAX { OP_IMREG, z_mode_ax_reg }
315 #define indirDX { OP_IMREG, indir_dx_reg }
317 #define Sw { OP_SEG, w_mode }
318 #define Sv { OP_SEG, v_mode }
319 #define Ap { OP_DIR, 0 }
320 #define Ob { OP_OFF64, b_mode }
321 #define Ov { OP_OFF64, v_mode }
322 #define Xb { OP_DSreg, eSI_reg }
323 #define Xv { OP_DSreg, eSI_reg }
324 #define Xz { OP_DSreg, eSI_reg }
325 #define Yb { OP_ESreg, eDI_reg }
326 #define Yv { OP_ESreg, eDI_reg }
327 #define DSBX { OP_DSreg, eBX_reg }
329 #define es { OP_REG, es_reg }
330 #define ss { OP_REG, ss_reg }
331 #define cs { OP_REG, cs_reg }
332 #define ds { OP_REG, ds_reg }
333 #define fs { OP_REG, fs_reg }
334 #define gs { OP_REG, gs_reg }
336 #define MX { OP_MMX, 0 }
337 #define XM { OP_XMM, 0 }
338 #define XMScalar { OP_XMM, scalar_mode }
339 #define XMM { OP_XMM, xmm_mode }
340 #define EM { OP_EM, v_mode }
341 #define EMS { OP_EM, v_swap_mode }
342 #define EMd { OP_EM, d_mode }
343 #define EMx { OP_EM, x_mode }
344 #define EXw { OP_EX, w_mode }
345 #define EXd { OP_EX, d_mode }
346 #define EXdScalar { OP_EX, d_scalar_mode }
347 #define EXdS { OP_EX, d_swap_mode }
348 #define EXq { OP_EX, q_mode }
349 #define EXqScalar { OP_EX, q_scalar_mode }
350 #define EXqScalarS { OP_EX, q_scalar_swap_mode }
351 #define EXqS { OP_EX, q_swap_mode }
352 #define EXx { OP_EX, x_mode }
353 #define EXxS { OP_EX, x_swap_mode }
354 #define EXxmm { OP_EX, xmm_mode }
355 #define EXxmmq { OP_EX, xmmq_mode }
356 #define EXymmq { OP_EX, ymmq_mode }
357 #define EXVexWdq { OP_EX, vex_w_dq_mode }
358 #define EXVexWdqScalar { OP_EX, vex_scalar_w_dq_mode }
359 #define MS { OP_MS, v_mode }
360 #define XS { OP_XS, v_mode }
361 #define EMCq { OP_EMC, q_mode }
362 #define MXC { OP_MXC, 0 }
363 #define OPSUF { OP_3DNowSuffix, 0 }
364 #define CMP { CMP_Fixup, 0 }
365 #define XMM0 { XMM_Fixup, 0 }
366 #define FXSAVE { FXSAVE_Fixup, 0 }
367 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
368 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
370 #define Vex { OP_VEX, vex_mode }
371 #define VexScalar { OP_VEX, vex_scalar_mode }
372 #define Vex128 { OP_VEX, vex128_mode }
373 #define Vex256 { OP_VEX, vex256_mode }
374 #define VexI4 { VEXI4_Fixup, 0}
375 #define EXdVex { OP_EX_Vex, d_mode }
376 #define EXdVexS { OP_EX_Vex, d_swap_mode }
377 #define EXdVexScalarS { OP_EX_Vex, d_scalar_swap_mode }
378 #define EXqVex { OP_EX_Vex, q_mode }
379 #define EXqVexS { OP_EX_Vex, q_swap_mode }
380 #define EXqVexScalarS { OP_EX_Vex, q_scalar_swap_mode }
381 #define EXVexW { OP_EX_VexW, x_mode }
382 #define EXdVexW { OP_EX_VexW, d_mode }
383 #define EXqVexW { OP_EX_VexW, q_mode }
384 #define EXVexImmW { OP_EX_VexImmW, x_mode }
385 #define XMVex { OP_XMM_Vex, 0 }
386 #define XMVexScalar { OP_XMM_Vex, scalar_mode }
387 #define XMVexW { OP_XMM_VexW, 0 }
388 #define XMVexI4 { OP_REG_VexI4, x_mode }
389 #define PCLMUL { PCLMUL_Fixup, 0 }
390 #define VZERO { VZERO_Fixup, 0 }
391 #define VCMP { VCMP_Fixup, 0 }
393 /* Used handle "rep" prefix for string instructions. */
394 #define Xbr { REP_Fixup, eSI_reg }
395 #define Xvr { REP_Fixup, eSI_reg }
396 #define Ybr { REP_Fixup, eDI_reg }
397 #define Yvr { REP_Fixup, eDI_reg }
398 #define Yzr { REP_Fixup, eDI_reg }
399 #define indirDXr { REP_Fixup, indir_dx_reg }
400 #define ALr { REP_Fixup, al_reg }
401 #define eAXr { REP_Fixup, eAX_reg }
403 #define cond_jump_flag { NULL, cond_jump_mode }
404 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
406 /* bits in sizeflag */
407 #define SUFFIX_ALWAYS 4
415 /* byte operand with operand swapped */
417 /* operand size depends on prefixes */
419 /* operand size depends on prefixes with operand swapped */
423 /* double word operand */
425 /* double word operand with operand swapped */
427 /* quad word operand */
429 /* quad word operand with operand swapped */
431 /* ten-byte operand */
433 /* 16-byte XMM or 32-byte YMM operand */
435 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
437 /* 16-byte XMM operand */
439 /* 16-byte XMM or quad word operand */
441 /* 32-byte YMM or quad word operand */
443 /* d_mode in 32bit, q_mode in 64bit mode. */
445 /* pair of v_mode operands */
449 /* operand size depends on REX prefixes. */
451 /* registers like dq_mode, memory like w_mode. */
453 /* 4- or 6-byte pointer operand */
456 /* v_mode for stack-related opcodes. */
458 /* non-quad operand size depends on prefixes */
460 /* 16-byte operand */
462 /* registers like dq_mode, memory like b_mode. */
464 /* registers like dq_mode, memory like d_mode. */
466 /* normal vex mode */
468 /* 128bit vex mode */
470 /* 256bit vex mode */
472 /* operand size depends on the VEX.W bit. */
475 /* scalar, ignore vector length. */
477 /* like d_mode, ignore vector length. */
479 /* like d_swap_mode, ignore vector length. */
481 /* like q_mode, ignore vector length. */
483 /* like q_swap_mode, ignore vector length. */
485 /* like vex_mode, ignore vector length. */
487 /* like vex_w_dq_mode, ignore vector length. */
488 vex_scalar_w_dq_mode
,
553 #define FLOAT NULL, { { NULL, FLOATCODE } }
555 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
556 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
557 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
558 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
559 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
560 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
561 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
562 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
563 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
564 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
565 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
566 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
684 MOD_VEX_3818_PREFIX_2
,
685 MOD_VEX_3819_PREFIX_2
,
686 MOD_VEX_381A_PREFIX_2
,
687 MOD_VEX_382A_PREFIX_2
,
688 MOD_VEX_382C_PREFIX_2
,
689 MOD_VEX_382D_PREFIX_2
,
690 MOD_VEX_382E_PREFIX_2
,
691 MOD_VEX_382F_PREFIX_2
1103 THREE_BYTE_0F38
= 0,
1258 VEX_LEN_3819_P_2_M_0
,
1259 VEX_LEN_381A_P_2_M_0
,
1271 VEX_LEN_382A_P_2_M_0
,
1589 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1600 /* Upper case letters in the instruction names here are macros.
1601 'A' => print 'b' if no register operands or suffix_always is true
1602 'B' => print 'b' if suffix_always is true
1603 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1605 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1606 suffix_always is true
1607 'E' => print 'e' if 32-bit form of jcxz
1608 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1609 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1610 'H' => print ",pt" or ",pn" branch hint
1611 'I' => honor following macro letter even in Intel mode (implemented only
1612 for some of the macro letters)
1614 'K' => print 'd' or 'q' if rex prefix is present.
1615 'L' => print 'l' if suffix_always is true
1616 'M' => print 'r' if intel_mnemonic is false.
1617 'N' => print 'n' if instruction has no wait "prefix"
1618 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1619 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1620 or suffix_always is true. print 'q' if rex prefix is present.
1621 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1623 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1624 'S' => print 'w', 'l' or 'q' if suffix_always is true
1625 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1626 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1627 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1628 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1629 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1630 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1631 suffix_always is true.
1632 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1633 '!' => change condition from true to false or from false to true.
1634 '%' => add 1 upper case letter to the macro.
1636 2 upper case letter macros:
1637 "XY" => print 'x' or 'y' if no register operands or suffix_always
1639 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1640 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1641 or suffix_always is true
1642 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1643 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1644 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1646 Many of the above letters print nothing in Intel mode. See "putop"
1649 Braces '{' and '}', and vertical bars '|', indicate alternative
1650 mnemonic strings for AT&T and Intel. */
1652 static const struct dis386 dis386
[] = {
1654 { "addB", { Eb
, Gb
} },
1655 { "addS", { Ev
, Gv
} },
1656 { "addB", { Gb
, EbS
} },
1657 { "addS", { Gv
, EvS
} },
1658 { "addB", { AL
, Ib
} },
1659 { "addS", { eAX
, Iv
} },
1660 { X86_64_TABLE (X86_64_06
) },
1661 { X86_64_TABLE (X86_64_07
) },
1663 { "orB", { Eb
, Gb
} },
1664 { "orS", { Ev
, Gv
} },
1665 { "orB", { Gb
, EbS
} },
1666 { "orS", { Gv
, EvS
} },
1667 { "orB", { AL
, Ib
} },
1668 { "orS", { eAX
, Iv
} },
1669 { X86_64_TABLE (X86_64_0D
) },
1670 { Bad_Opcode
}, /* 0x0f extended opcode escape */
1672 { "adcB", { Eb
, Gb
} },
1673 { "adcS", { Ev
, Gv
} },
1674 { "adcB", { Gb
, EbS
} },
1675 { "adcS", { Gv
, EvS
} },
1676 { "adcB", { AL
, Ib
} },
1677 { "adcS", { eAX
, Iv
} },
1678 { X86_64_TABLE (X86_64_16
) },
1679 { X86_64_TABLE (X86_64_17
) },
1681 { "sbbB", { Eb
, Gb
} },
1682 { "sbbS", { Ev
, Gv
} },
1683 { "sbbB", { Gb
, EbS
} },
1684 { "sbbS", { Gv
, EvS
} },
1685 { "sbbB", { AL
, Ib
} },
1686 { "sbbS", { eAX
, Iv
} },
1687 { X86_64_TABLE (X86_64_1E
) },
1688 { X86_64_TABLE (X86_64_1F
) },
1690 { "andB", { Eb
, Gb
} },
1691 { "andS", { Ev
, Gv
} },
1692 { "andB", { Gb
, EbS
} },
1693 { "andS", { Gv
, EvS
} },
1694 { "andB", { AL
, Ib
} },
1695 { "andS", { eAX
, Iv
} },
1696 { Bad_Opcode
}, /* SEG ES prefix */
1697 { X86_64_TABLE (X86_64_27
) },
1699 { "subB", { Eb
, Gb
} },
1700 { "subS", { Ev
, Gv
} },
1701 { "subB", { Gb
, EbS
} },
1702 { "subS", { Gv
, EvS
} },
1703 { "subB", { AL
, Ib
} },
1704 { "subS", { eAX
, Iv
} },
1705 { Bad_Opcode
}, /* SEG CS prefix */
1706 { X86_64_TABLE (X86_64_2F
) },
1708 { "xorB", { Eb
, Gb
} },
1709 { "xorS", { Ev
, Gv
} },
1710 { "xorB", { Gb
, EbS
} },
1711 { "xorS", { Gv
, EvS
} },
1712 { "xorB", { AL
, Ib
} },
1713 { "xorS", { eAX
, Iv
} },
1714 { Bad_Opcode
}, /* SEG SS prefix */
1715 { X86_64_TABLE (X86_64_37
) },
1717 { "cmpB", { Eb
, Gb
} },
1718 { "cmpS", { Ev
, Gv
} },
1719 { "cmpB", { Gb
, EbS
} },
1720 { "cmpS", { Gv
, EvS
} },
1721 { "cmpB", { AL
, Ib
} },
1722 { "cmpS", { eAX
, Iv
} },
1723 { Bad_Opcode
}, /* SEG DS prefix */
1724 { X86_64_TABLE (X86_64_3F
) },
1726 { "inc{S|}", { RMeAX
} },
1727 { "inc{S|}", { RMeCX
} },
1728 { "inc{S|}", { RMeDX
} },
1729 { "inc{S|}", { RMeBX
} },
1730 { "inc{S|}", { RMeSP
} },
1731 { "inc{S|}", { RMeBP
} },
1732 { "inc{S|}", { RMeSI
} },
1733 { "inc{S|}", { RMeDI
} },
1735 { "dec{S|}", { RMeAX
} },
1736 { "dec{S|}", { RMeCX
} },
1737 { "dec{S|}", { RMeDX
} },
1738 { "dec{S|}", { RMeBX
} },
1739 { "dec{S|}", { RMeSP
} },
1740 { "dec{S|}", { RMeBP
} },
1741 { "dec{S|}", { RMeSI
} },
1742 { "dec{S|}", { RMeDI
} },
1744 { "pushV", { RMrAX
} },
1745 { "pushV", { RMrCX
} },
1746 { "pushV", { RMrDX
} },
1747 { "pushV", { RMrBX
} },
1748 { "pushV", { RMrSP
} },
1749 { "pushV", { RMrBP
} },
1750 { "pushV", { RMrSI
} },
1751 { "pushV", { RMrDI
} },
1753 { "popV", { RMrAX
} },
1754 { "popV", { RMrCX
} },
1755 { "popV", { RMrDX
} },
1756 { "popV", { RMrBX
} },
1757 { "popV", { RMrSP
} },
1758 { "popV", { RMrBP
} },
1759 { "popV", { RMrSI
} },
1760 { "popV", { RMrDI
} },
1762 { X86_64_TABLE (X86_64_60
) },
1763 { X86_64_TABLE (X86_64_61
) },
1764 { X86_64_TABLE (X86_64_62
) },
1765 { X86_64_TABLE (X86_64_63
) },
1766 { Bad_Opcode
}, /* seg fs */
1767 { Bad_Opcode
}, /* seg gs */
1768 { Bad_Opcode
}, /* op size prefix */
1769 { Bad_Opcode
}, /* adr size prefix */
1771 { "pushT", { Iq
} },
1772 { "imulS", { Gv
, Ev
, Iv
} },
1773 { "pushT", { sIb
} },
1774 { "imulS", { Gv
, Ev
, sIb
} },
1775 { "ins{b|}", { Ybr
, indirDX
} },
1776 { X86_64_TABLE (X86_64_6D
) },
1777 { "outs{b|}", { indirDXr
, Xb
} },
1778 { X86_64_TABLE (X86_64_6F
) },
1780 { "joH", { Jb
, XX
, cond_jump_flag
} },
1781 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1782 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1783 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1784 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1785 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1786 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1787 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1789 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1790 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1791 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1792 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1793 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1794 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1795 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1796 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1798 { REG_TABLE (REG_80
) },
1799 { REG_TABLE (REG_81
) },
1801 { REG_TABLE (REG_82
) },
1802 { "testB", { Eb
, Gb
} },
1803 { "testS", { Ev
, Gv
} },
1804 { "xchgB", { Eb
, Gb
} },
1805 { "xchgS", { Ev
, Gv
} },
1807 { "movB", { Eb
, Gb
} },
1808 { "movS", { Ev
, Gv
} },
1809 { "movB", { Gb
, EbS
} },
1810 { "movS", { Gv
, EvS
} },
1811 { "movD", { Sv
, Sw
} },
1812 { MOD_TABLE (MOD_8D
) },
1813 { "movD", { Sw
, Sv
} },
1814 { REG_TABLE (REG_8F
) },
1816 { PREFIX_TABLE (PREFIX_90
) },
1817 { "xchgS", { RMeCX
, eAX
} },
1818 { "xchgS", { RMeDX
, eAX
} },
1819 { "xchgS", { RMeBX
, eAX
} },
1820 { "xchgS", { RMeSP
, eAX
} },
1821 { "xchgS", { RMeBP
, eAX
} },
1822 { "xchgS", { RMeSI
, eAX
} },
1823 { "xchgS", { RMeDI
, eAX
} },
1825 { "cW{t|}R", { XX
} },
1826 { "cR{t|}O", { XX
} },
1827 { X86_64_TABLE (X86_64_9A
) },
1828 { Bad_Opcode
}, /* fwait */
1829 { "pushfT", { XX
} },
1830 { "popfT", { XX
} },
1834 { "mov%LB", { AL
, Ob
} },
1835 { "mov%LS", { eAX
, Ov
} },
1836 { "mov%LB", { Ob
, AL
} },
1837 { "mov%LS", { Ov
, eAX
} },
1838 { "movs{b|}", { Ybr
, Xb
} },
1839 { "movs{R|}", { Yvr
, Xv
} },
1840 { "cmps{b|}", { Xb
, Yb
} },
1841 { "cmps{R|}", { Xv
, Yv
} },
1843 { "testB", { AL
, Ib
} },
1844 { "testS", { eAX
, Iv
} },
1845 { "stosB", { Ybr
, AL
} },
1846 { "stosS", { Yvr
, eAX
} },
1847 { "lodsB", { ALr
, Xb
} },
1848 { "lodsS", { eAXr
, Xv
} },
1849 { "scasB", { AL
, Yb
} },
1850 { "scasS", { eAX
, Yv
} },
1852 { "movB", { RMAL
, Ib
} },
1853 { "movB", { RMCL
, Ib
} },
1854 { "movB", { RMDL
, Ib
} },
1855 { "movB", { RMBL
, Ib
} },
1856 { "movB", { RMAH
, Ib
} },
1857 { "movB", { RMCH
, Ib
} },
1858 { "movB", { RMDH
, Ib
} },
1859 { "movB", { RMBH
, Ib
} },
1861 { "mov%LV", { RMeAX
, Iv64
} },
1862 { "mov%LV", { RMeCX
, Iv64
} },
1863 { "mov%LV", { RMeDX
, Iv64
} },
1864 { "mov%LV", { RMeBX
, Iv64
} },
1865 { "mov%LV", { RMeSP
, Iv64
} },
1866 { "mov%LV", { RMeBP
, Iv64
} },
1867 { "mov%LV", { RMeSI
, Iv64
} },
1868 { "mov%LV", { RMeDI
, Iv64
} },
1870 { REG_TABLE (REG_C0
) },
1871 { REG_TABLE (REG_C1
) },
1874 { X86_64_TABLE (X86_64_C4
) },
1875 { X86_64_TABLE (X86_64_C5
) },
1876 { REG_TABLE (REG_C6
) },
1877 { REG_TABLE (REG_C7
) },
1879 { "enterT", { Iw
, Ib
} },
1880 { "leaveT", { XX
} },
1881 { "Jret{|f}P", { Iw
} },
1882 { "Jret{|f}P", { XX
} },
1885 { X86_64_TABLE (X86_64_CE
) },
1886 { "iretP", { XX
} },
1888 { REG_TABLE (REG_D0
) },
1889 { REG_TABLE (REG_D1
) },
1890 { REG_TABLE (REG_D2
) },
1891 { REG_TABLE (REG_D3
) },
1892 { X86_64_TABLE (X86_64_D4
) },
1893 { X86_64_TABLE (X86_64_D5
) },
1895 { "xlat", { DSBX
} },
1906 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1907 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1908 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1909 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1910 { "inB", { AL
, Ib
} },
1911 { "inG", { zAX
, Ib
} },
1912 { "outB", { Ib
, AL
} },
1913 { "outG", { Ib
, zAX
} },
1915 { "callT", { Jv
} },
1917 { X86_64_TABLE (X86_64_EA
) },
1919 { "inB", { AL
, indirDX
} },
1920 { "inG", { zAX
, indirDX
} },
1921 { "outB", { indirDX
, AL
} },
1922 { "outG", { indirDX
, zAX
} },
1924 { Bad_Opcode
}, /* lock prefix */
1925 { "icebp", { XX
} },
1926 { Bad_Opcode
}, /* repne */
1927 { Bad_Opcode
}, /* repz */
1930 { REG_TABLE (REG_F6
) },
1931 { REG_TABLE (REG_F7
) },
1939 { REG_TABLE (REG_FE
) },
1940 { REG_TABLE (REG_FF
) },
1943 static const struct dis386 dis386_twobyte
[] = {
1945 { REG_TABLE (REG_0F00
) },
1946 { REG_TABLE (REG_0F01
) },
1947 { "larS", { Gv
, Ew
} },
1948 { "lslS", { Gv
, Ew
} },
1950 { "syscall", { XX
} },
1952 { "sysretP", { XX
} },
1955 { "wbinvd", { XX
} },
1959 { REG_TABLE (REG_0F0D
) },
1960 { "femms", { XX
} },
1961 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1963 { PREFIX_TABLE (PREFIX_0F10
) },
1964 { PREFIX_TABLE (PREFIX_0F11
) },
1965 { PREFIX_TABLE (PREFIX_0F12
) },
1966 { MOD_TABLE (MOD_0F13
) },
1967 { "unpcklpX", { XM
, EXx
} },
1968 { "unpckhpX", { XM
, EXx
} },
1969 { PREFIX_TABLE (PREFIX_0F16
) },
1970 { MOD_TABLE (MOD_0F17
) },
1972 { REG_TABLE (REG_0F18
) },
1981 { MOD_TABLE (MOD_0F20
) },
1982 { MOD_TABLE (MOD_0F21
) },
1983 { MOD_TABLE (MOD_0F22
) },
1984 { MOD_TABLE (MOD_0F23
) },
1985 { MOD_TABLE (MOD_0F24
) },
1987 { MOD_TABLE (MOD_0F26
) },
1990 { "movapX", { XM
, EXx
} },
1991 { "movapX", { EXxS
, XM
} },
1992 { PREFIX_TABLE (PREFIX_0F2A
) },
1993 { PREFIX_TABLE (PREFIX_0F2B
) },
1994 { PREFIX_TABLE (PREFIX_0F2C
) },
1995 { PREFIX_TABLE (PREFIX_0F2D
) },
1996 { PREFIX_TABLE (PREFIX_0F2E
) },
1997 { PREFIX_TABLE (PREFIX_0F2F
) },
1999 { "wrmsr", { XX
} },
2000 { "rdtsc", { XX
} },
2001 { "rdmsr", { XX
} },
2002 { "rdpmc", { XX
} },
2003 { "sysenter", { XX
} },
2004 { "sysexit", { XX
} },
2006 { "getsec", { XX
} },
2008 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
2010 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
2017 { "cmovoS", { Gv
, Ev
} },
2018 { "cmovnoS", { Gv
, Ev
} },
2019 { "cmovbS", { Gv
, Ev
} },
2020 { "cmovaeS", { Gv
, Ev
} },
2021 { "cmoveS", { Gv
, Ev
} },
2022 { "cmovneS", { Gv
, Ev
} },
2023 { "cmovbeS", { Gv
, Ev
} },
2024 { "cmovaS", { Gv
, Ev
} },
2026 { "cmovsS", { Gv
, Ev
} },
2027 { "cmovnsS", { Gv
, Ev
} },
2028 { "cmovpS", { Gv
, Ev
} },
2029 { "cmovnpS", { Gv
, Ev
} },
2030 { "cmovlS", { Gv
, Ev
} },
2031 { "cmovgeS", { Gv
, Ev
} },
2032 { "cmovleS", { Gv
, Ev
} },
2033 { "cmovgS", { Gv
, Ev
} },
2035 { MOD_TABLE (MOD_0F51
) },
2036 { PREFIX_TABLE (PREFIX_0F51
) },
2037 { PREFIX_TABLE (PREFIX_0F52
) },
2038 { PREFIX_TABLE (PREFIX_0F53
) },
2039 { "andpX", { XM
, EXx
} },
2040 { "andnpX", { XM
, EXx
} },
2041 { "orpX", { XM
, EXx
} },
2042 { "xorpX", { XM
, EXx
} },
2044 { PREFIX_TABLE (PREFIX_0F58
) },
2045 { PREFIX_TABLE (PREFIX_0F59
) },
2046 { PREFIX_TABLE (PREFIX_0F5A
) },
2047 { PREFIX_TABLE (PREFIX_0F5B
) },
2048 { PREFIX_TABLE (PREFIX_0F5C
) },
2049 { PREFIX_TABLE (PREFIX_0F5D
) },
2050 { PREFIX_TABLE (PREFIX_0F5E
) },
2051 { PREFIX_TABLE (PREFIX_0F5F
) },
2053 { PREFIX_TABLE (PREFIX_0F60
) },
2054 { PREFIX_TABLE (PREFIX_0F61
) },
2055 { PREFIX_TABLE (PREFIX_0F62
) },
2056 { "packsswb", { MX
, EM
} },
2057 { "pcmpgtb", { MX
, EM
} },
2058 { "pcmpgtw", { MX
, EM
} },
2059 { "pcmpgtd", { MX
, EM
} },
2060 { "packuswb", { MX
, EM
} },
2062 { "punpckhbw", { MX
, EM
} },
2063 { "punpckhwd", { MX
, EM
} },
2064 { "punpckhdq", { MX
, EM
} },
2065 { "packssdw", { MX
, EM
} },
2066 { PREFIX_TABLE (PREFIX_0F6C
) },
2067 { PREFIX_TABLE (PREFIX_0F6D
) },
2068 { "movK", { MX
, Edq
} },
2069 { PREFIX_TABLE (PREFIX_0F6F
) },
2071 { PREFIX_TABLE (PREFIX_0F70
) },
2072 { REG_TABLE (REG_0F71
) },
2073 { REG_TABLE (REG_0F72
) },
2074 { REG_TABLE (REG_0F73
) },
2075 { "pcmpeqb", { MX
, EM
} },
2076 { "pcmpeqw", { MX
, EM
} },
2077 { "pcmpeqd", { MX
, EM
} },
2080 { PREFIX_TABLE (PREFIX_0F78
) },
2081 { PREFIX_TABLE (PREFIX_0F79
) },
2082 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2084 { PREFIX_TABLE (PREFIX_0F7C
) },
2085 { PREFIX_TABLE (PREFIX_0F7D
) },
2086 { PREFIX_TABLE (PREFIX_0F7E
) },
2087 { PREFIX_TABLE (PREFIX_0F7F
) },
2089 { "joH", { Jv
, XX
, cond_jump_flag
} },
2090 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
2091 { "jbH", { Jv
, XX
, cond_jump_flag
} },
2092 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
2093 { "jeH", { Jv
, XX
, cond_jump_flag
} },
2094 { "jneH", { Jv
, XX
, cond_jump_flag
} },
2095 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
2096 { "jaH", { Jv
, XX
, cond_jump_flag
} },
2098 { "jsH", { Jv
, XX
, cond_jump_flag
} },
2099 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
2100 { "jpH", { Jv
, XX
, cond_jump_flag
} },
2101 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
2102 { "jlH", { Jv
, XX
, cond_jump_flag
} },
2103 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
2104 { "jleH", { Jv
, XX
, cond_jump_flag
} },
2105 { "jgH", { Jv
, XX
, cond_jump_flag
} },
2108 { "setno", { Eb
} },
2110 { "setae", { Eb
} },
2112 { "setne", { Eb
} },
2113 { "setbe", { Eb
} },
2117 { "setns", { Eb
} },
2119 { "setnp", { Eb
} },
2121 { "setge", { Eb
} },
2122 { "setle", { Eb
} },
2125 { "pushT", { fs
} },
2127 { "cpuid", { XX
} },
2128 { "btS", { Ev
, Gv
} },
2129 { "shldS", { Ev
, Gv
, Ib
} },
2130 { "shldS", { Ev
, Gv
, CL
} },
2131 { REG_TABLE (REG_0FA6
) },
2132 { REG_TABLE (REG_0FA7
) },
2134 { "pushT", { gs
} },
2137 { "btsS", { Ev
, Gv
} },
2138 { "shrdS", { Ev
, Gv
, Ib
} },
2139 { "shrdS", { Ev
, Gv
, CL
} },
2140 { REG_TABLE (REG_0FAE
) },
2141 { "imulS", { Gv
, Ev
} },
2143 { "cmpxchgB", { Eb
, Gb
} },
2144 { "cmpxchgS", { Ev
, Gv
} },
2145 { MOD_TABLE (MOD_0FB2
) },
2146 { "btrS", { Ev
, Gv
} },
2147 { MOD_TABLE (MOD_0FB4
) },
2148 { MOD_TABLE (MOD_0FB5
) },
2149 { "movz{bR|x}", { Gv
, Eb
} },
2150 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
2152 { PREFIX_TABLE (PREFIX_0FB8
) },
2154 { REG_TABLE (REG_0FBA
) },
2155 { "btcS", { Ev
, Gv
} },
2156 { "bsfS", { Gv
, Ev
} },
2157 { PREFIX_TABLE (PREFIX_0FBD
) },
2158 { "movs{bR|x}", { Gv
, Eb
} },
2159 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
2161 { "xaddB", { Eb
, Gb
} },
2162 { "xaddS", { Ev
, Gv
} },
2163 { PREFIX_TABLE (PREFIX_0FC2
) },
2164 { PREFIX_TABLE (PREFIX_0FC3
) },
2165 { "pinsrw", { MX
, Edqw
, Ib
} },
2166 { "pextrw", { Gdq
, MS
, Ib
} },
2167 { "shufpX", { XM
, EXx
, Ib
} },
2168 { REG_TABLE (REG_0FC7
) },
2170 { "bswap", { RMeAX
} },
2171 { "bswap", { RMeCX
} },
2172 { "bswap", { RMeDX
} },
2173 { "bswap", { RMeBX
} },
2174 { "bswap", { RMeSP
} },
2175 { "bswap", { RMeBP
} },
2176 { "bswap", { RMeSI
} },
2177 { "bswap", { RMeDI
} },
2179 { PREFIX_TABLE (PREFIX_0FD0
) },
2180 { "psrlw", { MX
, EM
} },
2181 { "psrld", { MX
, EM
} },
2182 { "psrlq", { MX
, EM
} },
2183 { "paddq", { MX
, EM
} },
2184 { "pmullw", { MX
, EM
} },
2185 { PREFIX_TABLE (PREFIX_0FD6
) },
2186 { MOD_TABLE (MOD_0FD7
) },
2188 { "psubusb", { MX
, EM
} },
2189 { "psubusw", { MX
, EM
} },
2190 { "pminub", { MX
, EM
} },
2191 { "pand", { MX
, EM
} },
2192 { "paddusb", { MX
, EM
} },
2193 { "paddusw", { MX
, EM
} },
2194 { "pmaxub", { MX
, EM
} },
2195 { "pandn", { MX
, EM
} },
2197 { "pavgb", { MX
, EM
} },
2198 { "psraw", { MX
, EM
} },
2199 { "psrad", { MX
, EM
} },
2200 { "pavgw", { MX
, EM
} },
2201 { "pmulhuw", { MX
, EM
} },
2202 { "pmulhw", { MX
, EM
} },
2203 { PREFIX_TABLE (PREFIX_0FE6
) },
2204 { PREFIX_TABLE (PREFIX_0FE7
) },
2206 { "psubsb", { MX
, EM
} },
2207 { "psubsw", { MX
, EM
} },
2208 { "pminsw", { MX
, EM
} },
2209 { "por", { MX
, EM
} },
2210 { "paddsb", { MX
, EM
} },
2211 { "paddsw", { MX
, EM
} },
2212 { "pmaxsw", { MX
, EM
} },
2213 { "pxor", { MX
, EM
} },
2215 { PREFIX_TABLE (PREFIX_0FF0
) },
2216 { "psllw", { MX
, EM
} },
2217 { "pslld", { MX
, EM
} },
2218 { "psllq", { MX
, EM
} },
2219 { "pmuludq", { MX
, EM
} },
2220 { "pmaddwd", { MX
, EM
} },
2221 { "psadbw", { MX
, EM
} },
2222 { PREFIX_TABLE (PREFIX_0FF7
) },
2224 { "psubb", { MX
, EM
} },
2225 { "psubw", { MX
, EM
} },
2226 { "psubd", { MX
, EM
} },
2227 { "psubq", { MX
, EM
} },
2228 { "paddb", { MX
, EM
} },
2229 { "paddw", { MX
, EM
} },
2230 { "paddd", { MX
, EM
} },
2234 static const unsigned char onebyte_has_modrm
[256] = {
2235 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2236 /* ------------------------------- */
2237 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2238 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2239 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2240 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2241 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2242 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2243 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2244 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2245 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2246 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2247 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2248 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2249 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2250 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2251 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2252 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2253 /* ------------------------------- */
2254 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2257 static const unsigned char twobyte_has_modrm
[256] = {
2258 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2259 /* ------------------------------- */
2260 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2261 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2262 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2263 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2264 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2265 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2266 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2267 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2268 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2269 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2270 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2271 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2272 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2273 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2274 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2275 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2276 /* ------------------------------- */
2277 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2280 static char obuf
[100];
2282 static char *mnemonicendp
;
2283 static char scratchbuf
[100];
2284 static unsigned char *start_codep
;
2285 static unsigned char *insn_codep
;
2286 static unsigned char *codep
;
2287 static int last_lock_prefix
;
2288 static int last_repz_prefix
;
2289 static int last_repnz_prefix
;
2290 static int last_data_prefix
;
2291 static int last_addr_prefix
;
2292 static int last_rex_prefix
;
2293 static int last_seg_prefix
;
2294 #define MAX_CODE_LENGTH 15
2295 /* We can up to 14 prefixes since the maximum instruction length is
2297 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2298 static disassemble_info
*the_info
;
2306 static unsigned char need_modrm
;
2309 int register_specifier
;
2315 static unsigned char need_vex
;
2316 static unsigned char need_vex_reg
;
2317 static unsigned char vex_w_done
;
2325 /* If we are accessing mod/rm/reg without need_modrm set, then the
2326 values are stale. Hitting this abort likely indicates that you
2327 need to update onebyte_has_modrm or twobyte_has_modrm. */
2328 #define MODRM_CHECK if (!need_modrm) abort ()
2330 static const char **names64
;
2331 static const char **names32
;
2332 static const char **names16
;
2333 static const char **names8
;
2334 static const char **names8rex
;
2335 static const char **names_seg
;
2336 static const char *index64
;
2337 static const char *index32
;
2338 static const char **index16
;
2340 static const char *intel_names64
[] = {
2341 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2342 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2344 static const char *intel_names32
[] = {
2345 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2346 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2348 static const char *intel_names16
[] = {
2349 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2350 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2352 static const char *intel_names8
[] = {
2353 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2355 static const char *intel_names8rex
[] = {
2356 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2357 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2359 static const char *intel_names_seg
[] = {
2360 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2362 static const char *intel_index64
= "riz";
2363 static const char *intel_index32
= "eiz";
2364 static const char *intel_index16
[] = {
2365 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2368 static const char *att_names64
[] = {
2369 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2370 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2372 static const char *att_names32
[] = {
2373 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2374 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2376 static const char *att_names16
[] = {
2377 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2378 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2380 static const char *att_names8
[] = {
2381 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2383 static const char *att_names8rex
[] = {
2384 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2385 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2387 static const char *att_names_seg
[] = {
2388 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2390 static const char *att_index64
= "%riz";
2391 static const char *att_index32
= "%eiz";
2392 static const char *att_index16
[] = {
2393 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2396 static const char **names_mm
;
2397 static const char *intel_names_mm
[] = {
2398 "mm0", "mm1", "mm2", "mm3",
2399 "mm4", "mm5", "mm6", "mm7"
2401 static const char *att_names_mm
[] = {
2402 "%mm0", "%mm1", "%mm2", "%mm3",
2403 "%mm4", "%mm5", "%mm6", "%mm7"
2406 static const char **names_xmm
;
2407 static const char *intel_names_xmm
[] = {
2408 "xmm0", "xmm1", "xmm2", "xmm3",
2409 "xmm4", "xmm5", "xmm6", "xmm7",
2410 "xmm8", "xmm9", "xmm10", "xmm11",
2411 "xmm12", "xmm13", "xmm14", "xmm15"
2413 static const char *att_names_xmm
[] = {
2414 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2415 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
2416 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
2417 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
2420 static const char **names_ymm
;
2421 static const char *intel_names_ymm
[] = {
2422 "ymm0", "ymm1", "ymm2", "ymm3",
2423 "ymm4", "ymm5", "ymm6", "ymm7",
2424 "ymm8", "ymm9", "ymm10", "ymm11",
2425 "ymm12", "ymm13", "ymm14", "ymm15"
2427 static const char *att_names_ymm
[] = {
2428 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
2429 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
2430 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
2431 "%ymm12", "%ymm13", "%ymm14", "%ymm15"
2434 static const struct dis386 reg_table
[][8] = {
2437 { "addA", { Eb
, Ib
} },
2438 { "orA", { Eb
, Ib
} },
2439 { "adcA", { Eb
, Ib
} },
2440 { "sbbA", { Eb
, Ib
} },
2441 { "andA", { Eb
, Ib
} },
2442 { "subA", { Eb
, Ib
} },
2443 { "xorA", { Eb
, Ib
} },
2444 { "cmpA", { Eb
, Ib
} },
2448 { "addQ", { Ev
, Iv
} },
2449 { "orQ", { Ev
, Iv
} },
2450 { "adcQ", { Ev
, Iv
} },
2451 { "sbbQ", { Ev
, Iv
} },
2452 { "andQ", { Ev
, Iv
} },
2453 { "subQ", { Ev
, Iv
} },
2454 { "xorQ", { Ev
, Iv
} },
2455 { "cmpQ", { Ev
, Iv
} },
2459 { "addQ", { Ev
, sIb
} },
2460 { "orQ", { Ev
, sIb
} },
2461 { "adcQ", { Ev
, sIb
} },
2462 { "sbbQ", { Ev
, sIb
} },
2463 { "andQ", { Ev
, sIb
} },
2464 { "subQ", { Ev
, sIb
} },
2465 { "xorQ", { Ev
, sIb
} },
2466 { "cmpQ", { Ev
, sIb
} },
2470 { "popU", { stackEv
} },
2471 { XOP_8F_TABLE (XOP_09
) },
2475 { XOP_8F_TABLE (XOP_09
) },
2479 { "rolA", { Eb
, Ib
} },
2480 { "rorA", { Eb
, Ib
} },
2481 { "rclA", { Eb
, Ib
} },
2482 { "rcrA", { Eb
, Ib
} },
2483 { "shlA", { Eb
, Ib
} },
2484 { "shrA", { Eb
, Ib
} },
2486 { "sarA", { Eb
, Ib
} },
2490 { "rolQ", { Ev
, Ib
} },
2491 { "rorQ", { Ev
, Ib
} },
2492 { "rclQ", { Ev
, Ib
} },
2493 { "rcrQ", { Ev
, Ib
} },
2494 { "shlQ", { Ev
, Ib
} },
2495 { "shrQ", { Ev
, Ib
} },
2497 { "sarQ", { Ev
, Ib
} },
2501 { "movA", { Eb
, Ib
} },
2505 { "movQ", { Ev
, Iv
} },
2509 { "rolA", { Eb
, I1
} },
2510 { "rorA", { Eb
, I1
} },
2511 { "rclA", { Eb
, I1
} },
2512 { "rcrA", { Eb
, I1
} },
2513 { "shlA", { Eb
, I1
} },
2514 { "shrA", { Eb
, I1
} },
2516 { "sarA", { Eb
, I1
} },
2520 { "rolQ", { Ev
, I1
} },
2521 { "rorQ", { Ev
, I1
} },
2522 { "rclQ", { Ev
, I1
} },
2523 { "rcrQ", { Ev
, I1
} },
2524 { "shlQ", { Ev
, I1
} },
2525 { "shrQ", { Ev
, I1
} },
2527 { "sarQ", { Ev
, I1
} },
2531 { "rolA", { Eb
, CL
} },
2532 { "rorA", { Eb
, CL
} },
2533 { "rclA", { Eb
, CL
} },
2534 { "rcrA", { Eb
, CL
} },
2535 { "shlA", { Eb
, CL
} },
2536 { "shrA", { Eb
, CL
} },
2538 { "sarA", { Eb
, CL
} },
2542 { "rolQ", { Ev
, CL
} },
2543 { "rorQ", { Ev
, CL
} },
2544 { "rclQ", { Ev
, CL
} },
2545 { "rcrQ", { Ev
, CL
} },
2546 { "shlQ", { Ev
, CL
} },
2547 { "shrQ", { Ev
, CL
} },
2549 { "sarQ", { Ev
, CL
} },
2553 { "testA", { Eb
, Ib
} },
2557 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2558 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2559 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2560 { "idivA", { Eb
} }, /* and idiv for consistency. */
2564 { "testQ", { Ev
, Iv
} },
2568 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2569 { "imulQ", { Ev
} },
2571 { "idivQ", { Ev
} },
2582 { "callT", { indirEv
} },
2583 { "JcallT", { indirEp
} },
2584 { "jmpT", { indirEv
} },
2585 { "JjmpT", { indirEp
} },
2586 { "pushU", { stackEv
} },
2591 { "sldtD", { Sv
} },
2602 { MOD_TABLE (MOD_0F01_REG_0
) },
2603 { MOD_TABLE (MOD_0F01_REG_1
) },
2604 { MOD_TABLE (MOD_0F01_REG_2
) },
2605 { MOD_TABLE (MOD_0F01_REG_3
) },
2606 { "smswD", { Sv
} },
2609 { MOD_TABLE (MOD_0F01_REG_7
) },
2613 { "prefetch", { Eb
} },
2614 { "prefetchw", { Eb
} },
2618 { MOD_TABLE (MOD_0F18_REG_0
) },
2619 { MOD_TABLE (MOD_0F18_REG_1
) },
2620 { MOD_TABLE (MOD_0F18_REG_2
) },
2621 { MOD_TABLE (MOD_0F18_REG_3
) },
2627 { MOD_TABLE (MOD_0F71_REG_2
) },
2629 { MOD_TABLE (MOD_0F71_REG_4
) },
2631 { MOD_TABLE (MOD_0F71_REG_6
) },
2637 { MOD_TABLE (MOD_0F72_REG_2
) },
2639 { MOD_TABLE (MOD_0F72_REG_4
) },
2641 { MOD_TABLE (MOD_0F72_REG_6
) },
2647 { MOD_TABLE (MOD_0F73_REG_2
) },
2648 { MOD_TABLE (MOD_0F73_REG_3
) },
2651 { MOD_TABLE (MOD_0F73_REG_6
) },
2652 { MOD_TABLE (MOD_0F73_REG_7
) },
2656 { "montmul", { { OP_0f07
, 0 } } },
2657 { "xsha1", { { OP_0f07
, 0 } } },
2658 { "xsha256", { { OP_0f07
, 0 } } },
2662 { "xstore-rng", { { OP_0f07
, 0 } } },
2663 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2664 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2665 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2666 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2667 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2671 { MOD_TABLE (MOD_0FAE_REG_0
) },
2672 { MOD_TABLE (MOD_0FAE_REG_1
) },
2673 { MOD_TABLE (MOD_0FAE_REG_2
) },
2674 { MOD_TABLE (MOD_0FAE_REG_3
) },
2675 { MOD_TABLE (MOD_0FAE_REG_4
) },
2676 { MOD_TABLE (MOD_0FAE_REG_5
) },
2677 { MOD_TABLE (MOD_0FAE_REG_6
) },
2678 { MOD_TABLE (MOD_0FAE_REG_7
) },
2686 { "btQ", { Ev
, Ib
} },
2687 { "btsQ", { Ev
, Ib
} },
2688 { "btrQ", { Ev
, Ib
} },
2689 { "btcQ", { Ev
, Ib
} },
2694 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2699 { MOD_TABLE (MOD_0FC7_REG_6
) },
2700 { MOD_TABLE (MOD_0FC7_REG_7
) },
2706 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2708 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2710 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2716 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2718 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2720 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2726 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2727 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2730 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2731 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2737 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2738 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2742 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2743 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2747 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2748 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2752 static const struct dis386 prefix_table
[][4] = {
2755 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2756 { "pause", { XX
} },
2757 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2762 { "movups", { XM
, EXx
} },
2763 { "movss", { XM
, EXd
} },
2764 { "movupd", { XM
, EXx
} },
2765 { "movsd", { XM
, EXq
} },
2770 { "movups", { EXxS
, XM
} },
2771 { "movss", { EXdS
, XM
} },
2772 { "movupd", { EXxS
, XM
} },
2773 { "movsd", { EXqS
, XM
} },
2778 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2779 { "movsldup", { XM
, EXx
} },
2780 { "movlpd", { XM
, EXq
} },
2781 { "movddup", { XM
, EXq
} },
2786 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2787 { "movshdup", { XM
, EXx
} },
2788 { "movhpd", { XM
, EXq
} },
2793 { "cvtpi2ps", { XM
, EMCq
} },
2794 { "cvtsi2ss%LQ", { XM
, Ev
} },
2795 { "cvtpi2pd", { XM
, EMCq
} },
2796 { "cvtsi2sd%LQ", { XM
, Ev
} },
2801 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2802 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2803 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2804 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2809 { "cvttps2pi", { MXC
, EXq
} },
2810 { "cvttss2siY", { Gv
, EXd
} },
2811 { "cvttpd2pi", { MXC
, EXx
} },
2812 { "cvttsd2siY", { Gv
, EXq
} },
2817 { "cvtps2pi", { MXC
, EXq
} },
2818 { "cvtss2siY", { Gv
, EXd
} },
2819 { "cvtpd2pi", { MXC
, EXx
} },
2820 { "cvtsd2siY", { Gv
, EXq
} },
2825 { "ucomiss",{ XM
, EXd
} },
2827 { "ucomisd",{ XM
, EXq
} },
2832 { "comiss", { XM
, EXd
} },
2834 { "comisd", { XM
, EXq
} },
2839 { "sqrtps", { XM
, EXx
} },
2840 { "sqrtss", { XM
, EXd
} },
2841 { "sqrtpd", { XM
, EXx
} },
2842 { "sqrtsd", { XM
, EXq
} },
2847 { "rsqrtps",{ XM
, EXx
} },
2848 { "rsqrtss",{ XM
, EXd
} },
2853 { "rcpps", { XM
, EXx
} },
2854 { "rcpss", { XM
, EXd
} },
2859 { "addps", { XM
, EXx
} },
2860 { "addss", { XM
, EXd
} },
2861 { "addpd", { XM
, EXx
} },
2862 { "addsd", { XM
, EXq
} },
2867 { "mulps", { XM
, EXx
} },
2868 { "mulss", { XM
, EXd
} },
2869 { "mulpd", { XM
, EXx
} },
2870 { "mulsd", { XM
, EXq
} },
2875 { "cvtps2pd", { XM
, EXq
} },
2876 { "cvtss2sd", { XM
, EXd
} },
2877 { "cvtpd2ps", { XM
, EXx
} },
2878 { "cvtsd2ss", { XM
, EXq
} },
2883 { "cvtdq2ps", { XM
, EXx
} },
2884 { "cvttps2dq", { XM
, EXx
} },
2885 { "cvtps2dq", { XM
, EXx
} },
2890 { "subps", { XM
, EXx
} },
2891 { "subss", { XM
, EXd
} },
2892 { "subpd", { XM
, EXx
} },
2893 { "subsd", { XM
, EXq
} },
2898 { "minps", { XM
, EXx
} },
2899 { "minss", { XM
, EXd
} },
2900 { "minpd", { XM
, EXx
} },
2901 { "minsd", { XM
, EXq
} },
2906 { "divps", { XM
, EXx
} },
2907 { "divss", { XM
, EXd
} },
2908 { "divpd", { XM
, EXx
} },
2909 { "divsd", { XM
, EXq
} },
2914 { "maxps", { XM
, EXx
} },
2915 { "maxss", { XM
, EXd
} },
2916 { "maxpd", { XM
, EXx
} },
2917 { "maxsd", { XM
, EXq
} },
2922 { "punpcklbw",{ MX
, EMd
} },
2924 { "punpcklbw",{ MX
, EMx
} },
2929 { "punpcklwd",{ MX
, EMd
} },
2931 { "punpcklwd",{ MX
, EMx
} },
2936 { "punpckldq",{ MX
, EMd
} },
2938 { "punpckldq",{ MX
, EMx
} },
2945 { "punpcklqdq", { XM
, EXx
} },
2952 { "punpckhqdq", { XM
, EXx
} },
2957 { "movq", { MX
, EM
} },
2958 { "movdqu", { XM
, EXx
} },
2959 { "movdqa", { XM
, EXx
} },
2964 { "pshufw", { MX
, EM
, Ib
} },
2965 { "pshufhw",{ XM
, EXx
, Ib
} },
2966 { "pshufd", { XM
, EXx
, Ib
} },
2967 { "pshuflw",{ XM
, EXx
, Ib
} },
2970 /* PREFIX_0F73_REG_3 */
2974 { "psrldq", { XS
, Ib
} },
2977 /* PREFIX_0F73_REG_7 */
2981 { "pslldq", { XS
, Ib
} },
2986 {"vmread", { Em
, Gm
} },
2988 {"extrq", { XS
, Ib
, Ib
} },
2989 {"insertq", { XM
, XS
, Ib
, Ib
} },
2994 {"vmwrite", { Gm
, Em
} },
2996 {"extrq", { XM
, XS
} },
2997 {"insertq", { XM
, XS
} },
3004 { "haddpd", { XM
, EXx
} },
3005 { "haddps", { XM
, EXx
} },
3012 { "hsubpd", { XM
, EXx
} },
3013 { "hsubps", { XM
, EXx
} },
3018 { "movK", { Edq
, MX
} },
3019 { "movq", { XM
, EXq
} },
3020 { "movK", { Edq
, XM
} },
3025 { "movq", { EMS
, MX
} },
3026 { "movdqu", { EXxS
, XM
} },
3027 { "movdqa", { EXxS
, XM
} },
3033 { "popcntS", { Gv
, Ev
} },
3038 { "bsrS", { Gv
, Ev
} },
3039 { "lzcntS", { Gv
, Ev
} },
3040 { "bsrS", { Gv
, Ev
} },
3045 { "cmpps", { XM
, EXx
, CMP
} },
3046 { "cmpss", { XM
, EXd
, CMP
} },
3047 { "cmppd", { XM
, EXx
, CMP
} },
3048 { "cmpsd", { XM
, EXq
, CMP
} },
3053 { "movntiS", { Ma
, Gv
} },
3056 /* PREFIX_0FC7_REG_6 */
3058 { "vmptrld",{ Mq
} },
3059 { "vmxon", { Mq
} },
3060 { "vmclear",{ Mq
} },
3067 { "addsubpd", { XM
, EXx
} },
3068 { "addsubps", { XM
, EXx
} },
3074 { "movq2dq",{ XM
, MS
} },
3075 { "movq", { EXqS
, XM
} },
3076 { "movdq2q",{ MX
, XS
} },
3082 { "cvtdq2pd", { XM
, EXq
} },
3083 { "cvttpd2dq", { XM
, EXx
} },
3084 { "cvtpd2dq", { XM
, EXx
} },
3089 { "movntq", { Mq
, MX
} },
3091 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
3099 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
3104 { "maskmovq", { MX
, MS
} },
3106 { "maskmovdqu", { XM
, XS
} },
3113 { "pblendvb", { XM
, EXx
, XMM0
} },
3120 { "blendvps", { XM
, EXx
, XMM0
} },
3127 { "blendvpd", { XM
, EXx
, XMM0
} },
3134 { "ptest", { XM
, EXx
} },
3141 { "pmovsxbw", { XM
, EXq
} },
3148 { "pmovsxbd", { XM
, EXd
} },
3155 { "pmovsxbq", { XM
, EXw
} },
3162 { "pmovsxwd", { XM
, EXq
} },
3169 { "pmovsxwq", { XM
, EXd
} },
3176 { "pmovsxdq", { XM
, EXq
} },
3183 { "pmuldq", { XM
, EXx
} },
3190 { "pcmpeqq", { XM
, EXx
} },
3197 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
3204 { "packusdw", { XM
, EXx
} },
3211 { "pmovzxbw", { XM
, EXq
} },
3218 { "pmovzxbd", { XM
, EXd
} },
3225 { "pmovzxbq", { XM
, EXw
} },
3232 { "pmovzxwd", { XM
, EXq
} },
3239 { "pmovzxwq", { XM
, EXd
} },
3246 { "pmovzxdq", { XM
, EXq
} },
3253 { "pcmpgtq", { XM
, EXx
} },
3260 { "pminsb", { XM
, EXx
} },
3267 { "pminsd", { XM
, EXx
} },
3274 { "pminuw", { XM
, EXx
} },
3281 { "pminud", { XM
, EXx
} },
3288 { "pmaxsb", { XM
, EXx
} },
3295 { "pmaxsd", { XM
, EXx
} },
3302 { "pmaxuw", { XM
, EXx
} },
3309 { "pmaxud", { XM
, EXx
} },
3316 { "pmulld", { XM
, EXx
} },
3323 { "phminposuw", { XM
, EXx
} },
3330 { "invept", { Gm
, Mo
} },
3337 { "invvpid", { Gm
, Mo
} },
3344 { "aesimc", { XM
, EXx
} },
3351 { "aesenc", { XM
, EXx
} },
3358 { "aesenclast", { XM
, EXx
} },
3365 { "aesdec", { XM
, EXx
} },
3372 { "aesdeclast", { XM
, EXx
} },
3377 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3379 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3380 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3385 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3387 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3388 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3395 { "roundps", { XM
, EXx
, Ib
} },
3402 { "roundpd", { XM
, EXx
, Ib
} },
3409 { "roundss", { XM
, EXd
, Ib
} },
3416 { "roundsd", { XM
, EXq
, Ib
} },
3423 { "blendps", { XM
, EXx
, Ib
} },
3430 { "blendpd", { XM
, EXx
, Ib
} },
3437 { "pblendw", { XM
, EXx
, Ib
} },
3444 { "pextrb", { Edqb
, XM
, Ib
} },
3451 { "pextrw", { Edqw
, XM
, Ib
} },
3458 { "pextrK", { Edq
, XM
, Ib
} },
3465 { "extractps", { Edqd
, XM
, Ib
} },
3472 { "pinsrb", { XM
, Edqb
, Ib
} },
3479 { "insertps", { XM
, EXd
, Ib
} },
3486 { "pinsrK", { XM
, Edq
, Ib
} },
3493 { "dpps", { XM
, EXx
, Ib
} },
3500 { "dppd", { XM
, EXx
, Ib
} },
3507 { "mpsadbw", { XM
, EXx
, Ib
} },
3514 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3521 { "pcmpestrm", { XM
, EXx
, Ib
} },
3528 { "pcmpestri", { XM
, EXx
, Ib
} },
3535 { "pcmpistrm", { XM
, EXx
, Ib
} },
3542 { "pcmpistri", { XM
, EXx
, Ib
} },
3549 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3554 { VEX_W_TABLE (VEX_W_10_P_0
) },
3555 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3556 { VEX_W_TABLE (VEX_W_10_P_2
) },
3557 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3562 { VEX_W_TABLE (VEX_W_11_P_0
) },
3563 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3564 { VEX_W_TABLE (VEX_W_11_P_2
) },
3565 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3570 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3571 { VEX_W_TABLE (VEX_W_12_P_1
) },
3572 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3573 { VEX_W_TABLE (VEX_W_12_P_3
) },
3578 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3579 { VEX_W_TABLE (VEX_W_16_P_1
) },
3580 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3586 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3588 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3594 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3596 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3602 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3604 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3609 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3611 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3616 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3618 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3623 { VEX_W_TABLE (VEX_W_51_P_0
) },
3624 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3625 { VEX_W_TABLE (VEX_W_51_P_2
) },
3626 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3631 { VEX_W_TABLE (VEX_W_52_P_0
) },
3632 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3637 { VEX_W_TABLE (VEX_W_53_P_0
) },
3638 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3643 { VEX_W_TABLE (VEX_W_58_P_0
) },
3644 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3645 { VEX_W_TABLE (VEX_W_58_P_2
) },
3646 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3651 { VEX_W_TABLE (VEX_W_59_P_0
) },
3652 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3653 { VEX_W_TABLE (VEX_W_59_P_2
) },
3654 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3659 { VEX_W_TABLE (VEX_W_5A_P_0
) },
3660 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3661 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3662 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3667 { VEX_W_TABLE (VEX_W_5B_P_0
) },
3668 { VEX_W_TABLE (VEX_W_5B_P_1
) },
3669 { VEX_W_TABLE (VEX_W_5B_P_2
) },
3674 { VEX_W_TABLE (VEX_W_5C_P_0
) },
3675 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3676 { VEX_W_TABLE (VEX_W_5C_P_2
) },
3677 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3682 { VEX_W_TABLE (VEX_W_5D_P_0
) },
3683 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3684 { VEX_W_TABLE (VEX_W_5D_P_2
) },
3685 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3690 { VEX_W_TABLE (VEX_W_5E_P_0
) },
3691 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3692 { VEX_W_TABLE (VEX_W_5E_P_2
) },
3693 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3698 { VEX_W_TABLE (VEX_W_5F_P_0
) },
3699 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3700 { VEX_W_TABLE (VEX_W_5F_P_2
) },
3701 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3708 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3715 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3722 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3729 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3736 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3743 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3750 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3757 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3764 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3771 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3778 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3785 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3792 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3799 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3806 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3812 { VEX_W_TABLE (VEX_W_6F_P_1
) },
3813 { VEX_W_TABLE (VEX_W_6F_P_2
) },
3819 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3820 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3821 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3824 /* PREFIX_VEX_71_REG_2 */
3828 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3831 /* PREFIX_VEX_71_REG_4 */
3835 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3838 /* PREFIX_VEX_71_REG_6 */
3842 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3845 /* PREFIX_VEX_72_REG_2 */
3849 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3852 /* PREFIX_VEX_72_REG_4 */
3856 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3859 /* PREFIX_VEX_72_REG_6 */
3863 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3866 /* PREFIX_VEX_73_REG_2 */
3870 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3873 /* PREFIX_VEX_73_REG_3 */
3877 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3880 /* PREFIX_VEX_73_REG_6 */
3884 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3887 /* PREFIX_VEX_73_REG_7 */
3891 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3898 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3905 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3912 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3917 { VEX_W_TABLE (VEX_W_77_P_0
) },
3924 { VEX_W_TABLE (VEX_W_7C_P_2
) },
3925 { VEX_W_TABLE (VEX_W_7C_P_3
) },
3932 { VEX_W_TABLE (VEX_W_7D_P_2
) },
3933 { VEX_W_TABLE (VEX_W_7D_P_3
) },
3939 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3940 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3946 { VEX_W_TABLE (VEX_W_7F_P_1
) },
3947 { VEX_W_TABLE (VEX_W_7F_P_2
) },
3952 { VEX_W_TABLE (VEX_W_C2_P_0
) },
3953 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3954 { VEX_W_TABLE (VEX_W_C2_P_2
) },
3955 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3962 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3969 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3976 { VEX_W_TABLE (VEX_W_D0_P_2
) },
3977 { VEX_W_TABLE (VEX_W_D0_P_3
) },
3984 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3991 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3998 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
4005 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
4012 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
4019 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
4026 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
4033 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
4040 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
4047 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
4054 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
4061 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
4068 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
4075 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
4082 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
4089 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
4096 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
4103 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
4110 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
4117 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4124 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4130 { VEX_W_TABLE (VEX_W_E6_P_1
) },
4131 { VEX_W_TABLE (VEX_W_E6_P_2
) },
4132 { VEX_W_TABLE (VEX_W_E6_P_3
) },
4139 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4146 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4153 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4160 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4167 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4174 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4181 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4188 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4195 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4203 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4210 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4217 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4224 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4231 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4238 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4245 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4252 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4259 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4266 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4273 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4280 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4287 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4294 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4301 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4304 /* PREFIX_VEX_3800 */
4308 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4311 /* PREFIX_VEX_3801 */
4315 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4318 /* PREFIX_VEX_3802 */
4322 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4325 /* PREFIX_VEX_3803 */
4329 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4332 /* PREFIX_VEX_3804 */
4336 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4339 /* PREFIX_VEX_3805 */
4343 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4346 /* PREFIX_VEX_3806 */
4350 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4353 /* PREFIX_VEX_3807 */
4357 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4360 /* PREFIX_VEX_3808 */
4364 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4367 /* PREFIX_VEX_3809 */
4371 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4374 /* PREFIX_VEX_380A */
4378 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4381 /* PREFIX_VEX_380B */
4385 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4388 /* PREFIX_VEX_380C */
4392 { VEX_W_TABLE (VEX_W_380C_P_2
) },
4395 /* PREFIX_VEX_380D */
4399 { VEX_W_TABLE (VEX_W_380D_P_2
) },
4402 /* PREFIX_VEX_380E */
4406 { VEX_W_TABLE (VEX_W_380E_P_2
) },
4409 /* PREFIX_VEX_380F */
4413 { VEX_W_TABLE (VEX_W_380F_P_2
) },
4416 /* PREFIX_VEX_3817 */
4420 { VEX_W_TABLE (VEX_W_3817_P_2
) },
4423 /* PREFIX_VEX_3818 */
4427 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4430 /* PREFIX_VEX_3819 */
4434 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4437 /* PREFIX_VEX_381A */
4441 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4444 /* PREFIX_VEX_381C */
4448 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4451 /* PREFIX_VEX_381D */
4455 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4458 /* PREFIX_VEX_381E */
4462 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4465 /* PREFIX_VEX_3820 */
4469 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4472 /* PREFIX_VEX_3821 */
4476 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4479 /* PREFIX_VEX_3822 */
4483 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4486 /* PREFIX_VEX_3823 */
4490 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4493 /* PREFIX_VEX_3824 */
4497 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4500 /* PREFIX_VEX_3825 */
4504 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4507 /* PREFIX_VEX_3828 */
4511 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4514 /* PREFIX_VEX_3829 */
4518 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4521 /* PREFIX_VEX_382A */
4525 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4528 /* PREFIX_VEX_382B */
4532 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4535 /* PREFIX_VEX_382C */
4539 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4542 /* PREFIX_VEX_382D */
4546 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4549 /* PREFIX_VEX_382E */
4553 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4556 /* PREFIX_VEX_382F */
4560 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4563 /* PREFIX_VEX_3830 */
4567 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4570 /* PREFIX_VEX_3831 */
4574 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4577 /* PREFIX_VEX_3832 */
4581 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4584 /* PREFIX_VEX_3833 */
4588 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4591 /* PREFIX_VEX_3834 */
4595 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4598 /* PREFIX_VEX_3835 */
4602 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4605 /* PREFIX_VEX_3837 */
4609 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4612 /* PREFIX_VEX_3838 */
4616 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4619 /* PREFIX_VEX_3839 */
4623 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4626 /* PREFIX_VEX_383A */
4630 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4633 /* PREFIX_VEX_383B */
4637 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4640 /* PREFIX_VEX_383C */
4644 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4647 /* PREFIX_VEX_383D */
4651 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4654 /* PREFIX_VEX_383E */
4658 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4661 /* PREFIX_VEX_383F */
4665 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4668 /* PREFIX_VEX_3840 */
4672 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4675 /* PREFIX_VEX_3841 */
4679 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4682 /* PREFIX_VEX_3896 */
4686 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4689 /* PREFIX_VEX_3897 */
4693 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4696 /* PREFIX_VEX_3898 */
4700 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4703 /* PREFIX_VEX_3899 */
4707 { "vfmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4710 /* PREFIX_VEX_389A */
4714 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4717 /* PREFIX_VEX_389B */
4721 { "vfmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4724 /* PREFIX_VEX_389C */
4728 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4731 /* PREFIX_VEX_389D */
4735 { "vfnmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4738 /* PREFIX_VEX_389E */
4742 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4745 /* PREFIX_VEX_389F */
4749 { "vfnmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4752 /* PREFIX_VEX_38A6 */
4756 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4760 /* PREFIX_VEX_38A7 */
4764 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4767 /* PREFIX_VEX_38A8 */
4771 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4774 /* PREFIX_VEX_38A9 */
4778 { "vfmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4781 /* PREFIX_VEX_38AA */
4785 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4788 /* PREFIX_VEX_38AB */
4792 { "vfmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4795 /* PREFIX_VEX_38AC */
4799 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4802 /* PREFIX_VEX_38AD */
4806 { "vfnmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4809 /* PREFIX_VEX_38AE */
4813 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4816 /* PREFIX_VEX_38AF */
4820 { "vfnmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4823 /* PREFIX_VEX_38B6 */
4827 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4830 /* PREFIX_VEX_38B7 */
4834 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4837 /* PREFIX_VEX_38B8 */
4841 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4844 /* PREFIX_VEX_38B9 */
4848 { "vfmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4851 /* PREFIX_VEX_38BA */
4855 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4858 /* PREFIX_VEX_38BB */
4862 { "vfmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4865 /* PREFIX_VEX_38BC */
4869 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4872 /* PREFIX_VEX_38BD */
4876 { "vfnmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4879 /* PREFIX_VEX_38BE */
4883 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4886 /* PREFIX_VEX_38BF */
4890 { "vfnmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
} },
4893 /* PREFIX_VEX_38DB */
4897 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4900 /* PREFIX_VEX_38DC */
4904 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4907 /* PREFIX_VEX_38DD */
4911 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4914 /* PREFIX_VEX_38DE */
4918 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4921 /* PREFIX_VEX_38DF */
4925 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4928 /* PREFIX_VEX_3A04 */
4932 { VEX_W_TABLE (VEX_W_3A04_P_2
) },
4935 /* PREFIX_VEX_3A05 */
4939 { VEX_W_TABLE (VEX_W_3A05_P_2
) },
4942 /* PREFIX_VEX_3A06 */
4946 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4949 /* PREFIX_VEX_3A08 */
4953 { VEX_W_TABLE (VEX_W_3A08_P_2
) },
4956 /* PREFIX_VEX_3A09 */
4960 { VEX_W_TABLE (VEX_W_3A09_P_2
) },
4963 /* PREFIX_VEX_3A0A */
4967 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4970 /* PREFIX_VEX_3A0B */
4974 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4977 /* PREFIX_VEX_3A0C */
4981 { VEX_W_TABLE (VEX_W_3A0C_P_2
) },
4984 /* PREFIX_VEX_3A0D */
4988 { VEX_W_TABLE (VEX_W_3A0D_P_2
) },
4991 /* PREFIX_VEX_3A0E */
4995 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
4998 /* PREFIX_VEX_3A0F */
5002 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
5005 /* PREFIX_VEX_3A14 */
5009 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5012 /* PREFIX_VEX_3A15 */
5016 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5019 /* PREFIX_VEX_3A16 */
5023 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5026 /* PREFIX_VEX_3A17 */
5030 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5033 /* PREFIX_VEX_3A18 */
5037 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5040 /* PREFIX_VEX_3A19 */
5044 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5047 /* PREFIX_VEX_3A20 */
5051 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5054 /* PREFIX_VEX_3A21 */
5058 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5061 /* PREFIX_VEX_3A22 */
5065 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5068 /* PREFIX_VEX_3A40 */
5072 { VEX_W_TABLE (VEX_W_3A40_P_2
) },
5075 /* PREFIX_VEX_3A41 */
5079 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5082 /* PREFIX_VEX_3A42 */
5086 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5089 /* PREFIX_VEX_3A44 */
5093 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5096 /* PREFIX_VEX_3A48 */
5100 { VEX_W_TABLE (VEX_W_3A48_P_2
) },
5103 /* PREFIX_VEX_3A49 */
5107 { VEX_W_TABLE (VEX_W_3A49_P_2
) },
5110 /* PREFIX_VEX_3A4A */
5114 { VEX_W_TABLE (VEX_W_3A4A_P_2
) },
5117 /* PREFIX_VEX_3A4B */
5121 { VEX_W_TABLE (VEX_W_3A4B_P_2
) },
5124 /* PREFIX_VEX_3A4C */
5128 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5131 /* PREFIX_VEX_3A5C */
5135 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5138 /* PREFIX_VEX_3A5D */
5142 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5145 /* PREFIX_VEX_3A5E */
5149 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5152 /* PREFIX_VEX_3A5F */
5156 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5159 /* PREFIX_VEX_3A60 */
5163 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5167 /* PREFIX_VEX_3A61 */
5171 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5174 /* PREFIX_VEX_3A62 */
5178 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5181 /* PREFIX_VEX_3A63 */
5185 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5188 /* PREFIX_VEX_3A68 */
5192 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5195 /* PREFIX_VEX_3A69 */
5199 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5202 /* PREFIX_VEX_3A6A */
5206 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5209 /* PREFIX_VEX_3A6B */
5213 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5216 /* PREFIX_VEX_3A6C */
5220 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5223 /* PREFIX_VEX_3A6D */
5227 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5230 /* PREFIX_VEX_3A6E */
5234 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5237 /* PREFIX_VEX_3A6F */
5241 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5244 /* PREFIX_VEX_3A78 */
5248 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5251 /* PREFIX_VEX_3A79 */
5255 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5258 /* PREFIX_VEX_3A7A */
5262 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5265 /* PREFIX_VEX_3A7B */
5269 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5272 /* PREFIX_VEX_3A7C */
5276 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5280 /* PREFIX_VEX_3A7D */
5284 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5287 /* PREFIX_VEX_3A7E */
5291 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5294 /* PREFIX_VEX_3A7F */
5298 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5301 /* PREFIX_VEX_3ADF */
5305 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5309 static const struct dis386 x86_64_table
[][2] = {
5312 { "push{T|}", { es
} },
5317 { "pop{T|}", { es
} },
5322 { "push{T|}", { cs
} },
5327 { "push{T|}", { ss
} },
5332 { "pop{T|}", { ss
} },
5337 { "push{T|}", { ds
} },
5342 { "pop{T|}", { ds
} },
5367 { "pusha{P|}", { XX
} },
5372 { "popa{P|}", { XX
} },
5377 { MOD_TABLE (MOD_62_32BIT
) },
5382 { "arpl", { Ew
, Gw
} },
5383 { "movs{lq|xd}", { Gv
, Ed
} },
5388 { "ins{R|}", { Yzr
, indirDX
} },
5389 { "ins{G|}", { Yzr
, indirDX
} },
5394 { "outs{R|}", { indirDXr
, Xz
} },
5395 { "outs{G|}", { indirDXr
, Xz
} },
5400 { "Jcall{T|}", { Ap
} },
5405 { MOD_TABLE (MOD_C4_32BIT
) },
5406 { VEX_C4_TABLE (VEX_0F
) },
5411 { MOD_TABLE (MOD_C5_32BIT
) },
5412 { VEX_C5_TABLE (VEX_0F
) },
5432 { "Jjmp{T|}", { Ap
} },
5435 /* X86_64_0F01_REG_0 */
5437 { "sgdt{Q|IQ}", { M
} },
5441 /* X86_64_0F01_REG_1 */
5443 { "sidt{Q|IQ}", { M
} },
5447 /* X86_64_0F01_REG_2 */
5449 { "lgdt{Q|Q}", { M
} },
5453 /* X86_64_0F01_REG_3 */
5455 { "lidt{Q|Q}", { M
} },
5460 static const struct dis386 three_byte_table
[][256] = {
5462 /* THREE_BYTE_0F38 */
5465 { "pshufb", { MX
, EM
} },
5466 { "phaddw", { MX
, EM
} },
5467 { "phaddd", { MX
, EM
} },
5468 { "phaddsw", { MX
, EM
} },
5469 { "pmaddubsw", { MX
, EM
} },
5470 { "phsubw", { MX
, EM
} },
5471 { "phsubd", { MX
, EM
} },
5472 { "phsubsw", { MX
, EM
} },
5474 { "psignb", { MX
, EM
} },
5475 { "psignw", { MX
, EM
} },
5476 { "psignd", { MX
, EM
} },
5477 { "pmulhrsw", { MX
, EM
} },
5483 { PREFIX_TABLE (PREFIX_0F3810
) },
5487 { PREFIX_TABLE (PREFIX_0F3814
) },
5488 { PREFIX_TABLE (PREFIX_0F3815
) },
5490 { PREFIX_TABLE (PREFIX_0F3817
) },
5496 { "pabsb", { MX
, EM
} },
5497 { "pabsw", { MX
, EM
} },
5498 { "pabsd", { MX
, EM
} },
5501 { PREFIX_TABLE (PREFIX_0F3820
) },
5502 { PREFIX_TABLE (PREFIX_0F3821
) },
5503 { PREFIX_TABLE (PREFIX_0F3822
) },
5504 { PREFIX_TABLE (PREFIX_0F3823
) },
5505 { PREFIX_TABLE (PREFIX_0F3824
) },
5506 { PREFIX_TABLE (PREFIX_0F3825
) },
5510 { PREFIX_TABLE (PREFIX_0F3828
) },
5511 { PREFIX_TABLE (PREFIX_0F3829
) },
5512 { PREFIX_TABLE (PREFIX_0F382A
) },
5513 { PREFIX_TABLE (PREFIX_0F382B
) },
5519 { PREFIX_TABLE (PREFIX_0F3830
) },
5520 { PREFIX_TABLE (PREFIX_0F3831
) },
5521 { PREFIX_TABLE (PREFIX_0F3832
) },
5522 { PREFIX_TABLE (PREFIX_0F3833
) },
5523 { PREFIX_TABLE (PREFIX_0F3834
) },
5524 { PREFIX_TABLE (PREFIX_0F3835
) },
5526 { PREFIX_TABLE (PREFIX_0F3837
) },
5528 { PREFIX_TABLE (PREFIX_0F3838
) },
5529 { PREFIX_TABLE (PREFIX_0F3839
) },
5530 { PREFIX_TABLE (PREFIX_0F383A
) },
5531 { PREFIX_TABLE (PREFIX_0F383B
) },
5532 { PREFIX_TABLE (PREFIX_0F383C
) },
5533 { PREFIX_TABLE (PREFIX_0F383D
) },
5534 { PREFIX_TABLE (PREFIX_0F383E
) },
5535 { PREFIX_TABLE (PREFIX_0F383F
) },
5537 { PREFIX_TABLE (PREFIX_0F3840
) },
5538 { PREFIX_TABLE (PREFIX_0F3841
) },
5609 { PREFIX_TABLE (PREFIX_0F3880
) },
5610 { PREFIX_TABLE (PREFIX_0F3881
) },
5711 { PREFIX_TABLE (PREFIX_0F38DB
) },
5712 { PREFIX_TABLE (PREFIX_0F38DC
) },
5713 { PREFIX_TABLE (PREFIX_0F38DD
) },
5714 { PREFIX_TABLE (PREFIX_0F38DE
) },
5715 { PREFIX_TABLE (PREFIX_0F38DF
) },
5735 { PREFIX_TABLE (PREFIX_0F38F0
) },
5736 { PREFIX_TABLE (PREFIX_0F38F1
) },
5753 /* THREE_BYTE_0F3A */
5765 { PREFIX_TABLE (PREFIX_0F3A08
) },
5766 { PREFIX_TABLE (PREFIX_0F3A09
) },
5767 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5768 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5769 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5770 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5771 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5772 { "palignr", { MX
, EM
, Ib
} },
5778 { PREFIX_TABLE (PREFIX_0F3A14
) },
5779 { PREFIX_TABLE (PREFIX_0F3A15
) },
5780 { PREFIX_TABLE (PREFIX_0F3A16
) },
5781 { PREFIX_TABLE (PREFIX_0F3A17
) },
5792 { PREFIX_TABLE (PREFIX_0F3A20
) },
5793 { PREFIX_TABLE (PREFIX_0F3A21
) },
5794 { PREFIX_TABLE (PREFIX_0F3A22
) },
5828 { PREFIX_TABLE (PREFIX_0F3A40
) },
5829 { PREFIX_TABLE (PREFIX_0F3A41
) },
5830 { PREFIX_TABLE (PREFIX_0F3A42
) },
5832 { PREFIX_TABLE (PREFIX_0F3A44
) },
5864 { PREFIX_TABLE (PREFIX_0F3A60
) },
5865 { PREFIX_TABLE (PREFIX_0F3A61
) },
5866 { PREFIX_TABLE (PREFIX_0F3A62
) },
5867 { PREFIX_TABLE (PREFIX_0F3A63
) },
6006 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6045 /* THREE_BYTE_0F7A */
6084 { "ptest", { XX
} },
6121 { "phaddbw", { XM
, EXq
} },
6122 { "phaddbd", { XM
, EXq
} },
6123 { "phaddbq", { XM
, EXq
} },
6126 { "phaddwd", { XM
, EXq
} },
6127 { "phaddwq", { XM
, EXq
} },
6132 { "phadddq", { XM
, EXq
} },
6139 { "phaddubw", { XM
, EXq
} },
6140 { "phaddubd", { XM
, EXq
} },
6141 { "phaddubq", { XM
, EXq
} },
6144 { "phadduwd", { XM
, EXq
} },
6145 { "phadduwq", { XM
, EXq
} },
6150 { "phaddudq", { XM
, EXq
} },
6157 { "phsubbw", { XM
, EXq
} },
6158 { "phsubbd", { XM
, EXq
} },
6159 { "phsubbq", { XM
, EXq
} },
6338 static const struct dis386 xop_table
[][256] = {
6491 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6492 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6493 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6501 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6502 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6509 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6510 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6511 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6519 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6520 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6524 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6525 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6528 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6546 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6558 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6559 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6560 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6561 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6571 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6572 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6573 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6574 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6607 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6608 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6609 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6610 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6653 { REG_TABLE (REG_XOP_LWPCB
) },
6777 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
6778 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
6779 { "vfrczss", { XM
, EXd
} },
6780 { "vfrczsd", { XM
, EXq
} },
6795 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6796 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6797 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6798 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6799 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6800 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6801 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6802 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6804 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6805 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6806 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6807 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6850 { "vphaddbw", { XM
, EXxmm
} },
6851 { "vphaddbd", { XM
, EXxmm
} },
6852 { "vphaddbq", { XM
, EXxmm
} },
6855 { "vphaddwd", { XM
, EXxmm
} },
6856 { "vphaddwq", { XM
, EXxmm
} },
6861 { "vphadddq", { XM
, EXxmm
} },
6868 { "vphaddubw", { XM
, EXxmm
} },
6869 { "vphaddubd", { XM
, EXxmm
} },
6870 { "vphaddubq", { XM
, EXxmm
} },
6873 { "vphadduwd", { XM
, EXxmm
} },
6874 { "vphadduwq", { XM
, EXxmm
} },
6879 { "vphaddudq", { XM
, EXxmm
} },
6886 { "vphsubbw", { XM
, EXxmm
} },
6887 { "vphsubwd", { XM
, EXxmm
} },
6888 { "vphsubdq", { XM
, EXxmm
} },
6944 { REG_TABLE (REG_XOP_LWP
) },
7214 static const struct dis386 vex_table
[][256] = {
7236 { PREFIX_TABLE (PREFIX_VEX_10
) },
7237 { PREFIX_TABLE (PREFIX_VEX_11
) },
7238 { PREFIX_TABLE (PREFIX_VEX_12
) },
7239 { MOD_TABLE (MOD_VEX_13
) },
7240 { VEX_W_TABLE (VEX_W_14
) },
7241 { VEX_W_TABLE (VEX_W_15
) },
7242 { PREFIX_TABLE (PREFIX_VEX_16
) },
7243 { MOD_TABLE (MOD_VEX_17
) },
7263 { VEX_W_TABLE (VEX_W_28
) },
7264 { VEX_W_TABLE (VEX_W_29
) },
7265 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7266 { MOD_TABLE (MOD_VEX_2B
) },
7267 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7268 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7269 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7270 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7308 { MOD_TABLE (MOD_VEX_50
) },
7309 { PREFIX_TABLE (PREFIX_VEX_51
) },
7310 { PREFIX_TABLE (PREFIX_VEX_52
) },
7311 { PREFIX_TABLE (PREFIX_VEX_53
) },
7312 { "vandpX", { XM
, Vex
, EXx
} },
7313 { "vandnpX", { XM
, Vex
, EXx
} },
7314 { "vorpX", { XM
, Vex
, EXx
} },
7315 { "vxorpX", { XM
, Vex
, EXx
} },
7317 { PREFIX_TABLE (PREFIX_VEX_58
) },
7318 { PREFIX_TABLE (PREFIX_VEX_59
) },
7319 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7320 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7321 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7322 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7323 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7324 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7326 { PREFIX_TABLE (PREFIX_VEX_60
) },
7327 { PREFIX_TABLE (PREFIX_VEX_61
) },
7328 { PREFIX_TABLE (PREFIX_VEX_62
) },
7329 { PREFIX_TABLE (PREFIX_VEX_63
) },
7330 { PREFIX_TABLE (PREFIX_VEX_64
) },
7331 { PREFIX_TABLE (PREFIX_VEX_65
) },
7332 { PREFIX_TABLE (PREFIX_VEX_66
) },
7333 { PREFIX_TABLE (PREFIX_VEX_67
) },
7335 { PREFIX_TABLE (PREFIX_VEX_68
) },
7336 { PREFIX_TABLE (PREFIX_VEX_69
) },
7337 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7338 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7339 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7340 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7341 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7342 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7344 { PREFIX_TABLE (PREFIX_VEX_70
) },
7345 { REG_TABLE (REG_VEX_71
) },
7346 { REG_TABLE (REG_VEX_72
) },
7347 { REG_TABLE (REG_VEX_73
) },
7348 { PREFIX_TABLE (PREFIX_VEX_74
) },
7349 { PREFIX_TABLE (PREFIX_VEX_75
) },
7350 { PREFIX_TABLE (PREFIX_VEX_76
) },
7351 { PREFIX_TABLE (PREFIX_VEX_77
) },
7357 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7358 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7359 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7360 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7413 { REG_TABLE (REG_VEX_AE
) },
7436 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7438 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7439 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7440 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7452 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7453 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7454 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7455 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7456 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7457 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7458 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7459 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7461 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7462 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7463 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7464 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7465 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7466 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7467 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7468 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7470 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7471 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7472 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7473 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7474 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7475 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7476 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7477 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7479 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7480 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7481 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7482 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7483 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7484 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7485 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7486 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7488 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7489 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7490 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7491 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7492 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7493 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7494 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7495 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7497 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7498 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7499 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7500 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7501 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7502 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7503 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7509 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7510 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7511 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7512 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7513 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7514 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7515 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7516 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7518 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7519 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7520 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7521 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7522 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7523 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7524 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7525 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7534 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7536 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7537 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7538 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7540 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7541 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7542 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7545 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7546 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7547 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7548 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7549 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7550 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7554 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7555 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7556 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7557 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7558 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7559 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7560 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7561 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7563 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7564 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7565 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7566 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7567 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7568 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7570 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7572 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7573 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7574 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7575 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7576 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7577 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7578 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7579 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7581 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7582 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7677 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7678 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7680 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7681 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7682 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7683 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7684 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7685 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7686 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7687 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7695 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7696 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7698 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7699 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7700 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7701 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7702 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7703 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7704 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7705 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7713 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7714 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7716 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7717 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7718 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7719 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7720 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7721 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7722 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7723 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7755 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7756 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7757 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7758 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7759 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7804 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7805 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7806 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7809 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7810 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7811 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7812 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7813 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7814 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7815 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7816 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7822 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7823 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7824 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7825 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7827 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7828 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7836 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7837 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7838 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
7872 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7873 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7874 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7876 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7881 { PREFIX_TABLE (PREFIX_VEX_3A48
) },
7882 { PREFIX_TABLE (PREFIX_VEX_3A49
) },
7883 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7884 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7885 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7903 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7904 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7905 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7906 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7908 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7909 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7910 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7911 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7917 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7918 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7919 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7920 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7921 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7922 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7923 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7924 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
7935 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7936 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7937 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7938 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7939 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7940 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7941 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7942 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
8050 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8090 static const struct dis386 vex_len_table
[][2] = {
8091 /* VEX_LEN_10_P_1 */
8093 { VEX_W_TABLE (VEX_W_10_P_1
) },
8094 { VEX_W_TABLE (VEX_W_10_P_1
) },
8097 /* VEX_LEN_10_P_3 */
8099 { VEX_W_TABLE (VEX_W_10_P_3
) },
8100 { VEX_W_TABLE (VEX_W_10_P_3
) },
8103 /* VEX_LEN_11_P_1 */
8105 { VEX_W_TABLE (VEX_W_11_P_1
) },
8106 { VEX_W_TABLE (VEX_W_11_P_1
) },
8109 /* VEX_LEN_11_P_3 */
8111 { VEX_W_TABLE (VEX_W_11_P_3
) },
8112 { VEX_W_TABLE (VEX_W_11_P_3
) },
8115 /* VEX_LEN_12_P_0_M_0 */
8117 { VEX_W_TABLE (VEX_W_12_P_0_M_0
) },
8120 /* VEX_LEN_12_P_0_M_1 */
8122 { VEX_W_TABLE (VEX_W_12_P_0_M_1
) },
8125 /* VEX_LEN_12_P_2 */
8127 { VEX_W_TABLE (VEX_W_12_P_2
) },
8130 /* VEX_LEN_13_M_0 */
8132 { VEX_W_TABLE (VEX_W_13_M_0
) },
8135 /* VEX_LEN_16_P_0_M_0 */
8137 { VEX_W_TABLE (VEX_W_16_P_0_M_0
) },
8140 /* VEX_LEN_16_P_0_M_1 */
8142 { VEX_W_TABLE (VEX_W_16_P_0_M_1
) },
8145 /* VEX_LEN_16_P_2 */
8147 { VEX_W_TABLE (VEX_W_16_P_2
) },
8150 /* VEX_LEN_17_M_0 */
8152 { VEX_W_TABLE (VEX_W_17_M_0
) },
8155 /* VEX_LEN_2A_P_1 */
8157 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8158 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
} },
8161 /* VEX_LEN_2A_P_3 */
8163 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8164 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
} },
8167 /* VEX_LEN_2C_P_1 */
8169 { "vcvttss2siY", { Gv
, EXdScalar
} },
8170 { "vcvttss2siY", { Gv
, EXdScalar
} },
8173 /* VEX_LEN_2C_P_3 */
8175 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8176 { "vcvttsd2siY", { Gv
, EXqScalar
} },
8179 /* VEX_LEN_2D_P_1 */
8181 { "vcvtss2siY", { Gv
, EXdScalar
} },
8182 { "vcvtss2siY", { Gv
, EXdScalar
} },
8185 /* VEX_LEN_2D_P_3 */
8187 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8188 { "vcvtsd2siY", { Gv
, EXqScalar
} },
8191 /* VEX_LEN_2E_P_0 */
8193 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8194 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8197 /* VEX_LEN_2E_P_2 */
8199 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8200 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8203 /* VEX_LEN_2F_P_0 */
8205 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8206 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8209 /* VEX_LEN_2F_P_2 */
8211 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8212 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8215 /* VEX_LEN_51_P_1 */
8217 { VEX_W_TABLE (VEX_W_51_P_1
) },
8218 { VEX_W_TABLE (VEX_W_51_P_1
) },
8221 /* VEX_LEN_51_P_3 */
8223 { VEX_W_TABLE (VEX_W_51_P_3
) },
8224 { VEX_W_TABLE (VEX_W_51_P_3
) },
8227 /* VEX_LEN_52_P_1 */
8229 { VEX_W_TABLE (VEX_W_52_P_1
) },
8230 { VEX_W_TABLE (VEX_W_52_P_1
) },
8233 /* VEX_LEN_53_P_1 */
8235 { VEX_W_TABLE (VEX_W_53_P_1
) },
8236 { VEX_W_TABLE (VEX_W_53_P_1
) },
8239 /* VEX_LEN_58_P_1 */
8241 { VEX_W_TABLE (VEX_W_58_P_1
) },
8242 { VEX_W_TABLE (VEX_W_58_P_1
) },
8245 /* VEX_LEN_58_P_3 */
8247 { VEX_W_TABLE (VEX_W_58_P_3
) },
8248 { VEX_W_TABLE (VEX_W_58_P_3
) },
8251 /* VEX_LEN_59_P_1 */
8253 { VEX_W_TABLE (VEX_W_59_P_1
) },
8254 { VEX_W_TABLE (VEX_W_59_P_1
) },
8257 /* VEX_LEN_59_P_3 */
8259 { VEX_W_TABLE (VEX_W_59_P_3
) },
8260 { VEX_W_TABLE (VEX_W_59_P_3
) },
8263 /* VEX_LEN_5A_P_1 */
8265 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8266 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8269 /* VEX_LEN_5A_P_3 */
8271 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8272 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8275 /* VEX_LEN_5C_P_1 */
8277 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8278 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8281 /* VEX_LEN_5C_P_3 */
8283 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8284 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8287 /* VEX_LEN_5D_P_1 */
8289 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8290 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8293 /* VEX_LEN_5D_P_3 */
8295 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8296 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8299 /* VEX_LEN_5E_P_1 */
8301 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8302 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8305 /* VEX_LEN_5E_P_3 */
8307 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8308 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8311 /* VEX_LEN_5F_P_1 */
8313 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8314 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8317 /* VEX_LEN_5F_P_3 */
8319 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8320 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8323 /* VEX_LEN_60_P_2 */
8325 { VEX_W_TABLE (VEX_W_60_P_2
) },
8328 /* VEX_LEN_61_P_2 */
8330 { VEX_W_TABLE (VEX_W_61_P_2
) },
8333 /* VEX_LEN_62_P_2 */
8335 { VEX_W_TABLE (VEX_W_62_P_2
) },
8338 /* VEX_LEN_63_P_2 */
8340 { VEX_W_TABLE (VEX_W_63_P_2
) },
8343 /* VEX_LEN_64_P_2 */
8345 { VEX_W_TABLE (VEX_W_64_P_2
) },
8348 /* VEX_LEN_65_P_2 */
8350 { VEX_W_TABLE (VEX_W_65_P_2
) },
8353 /* VEX_LEN_66_P_2 */
8355 { VEX_W_TABLE (VEX_W_66_P_2
) },
8358 /* VEX_LEN_67_P_2 */
8360 { VEX_W_TABLE (VEX_W_67_P_2
) },
8363 /* VEX_LEN_68_P_2 */
8365 { VEX_W_TABLE (VEX_W_68_P_2
) },
8368 /* VEX_LEN_69_P_2 */
8370 { VEX_W_TABLE (VEX_W_69_P_2
) },
8373 /* VEX_LEN_6A_P_2 */
8375 { VEX_W_TABLE (VEX_W_6A_P_2
) },
8378 /* VEX_LEN_6B_P_2 */
8380 { VEX_W_TABLE (VEX_W_6B_P_2
) },
8383 /* VEX_LEN_6C_P_2 */
8385 { VEX_W_TABLE (VEX_W_6C_P_2
) },
8388 /* VEX_LEN_6D_P_2 */
8390 { VEX_W_TABLE (VEX_W_6D_P_2
) },
8393 /* VEX_LEN_6E_P_2 */
8395 { "vmovK", { XMScalar
, Edq
} },
8396 { "vmovK", { XMScalar
, Edq
} },
8399 /* VEX_LEN_70_P_1 */
8401 { VEX_W_TABLE (VEX_W_70_P_1
) },
8404 /* VEX_LEN_70_P_2 */
8406 { VEX_W_TABLE (VEX_W_70_P_2
) },
8409 /* VEX_LEN_70_P_3 */
8411 { VEX_W_TABLE (VEX_W_70_P_3
) },
8414 /* VEX_LEN_71_R_2_P_2 */
8416 { VEX_W_TABLE (VEX_W_71_R_2_P_2
) },
8419 /* VEX_LEN_71_R_4_P_2 */
8421 { VEX_W_TABLE (VEX_W_71_R_4_P_2
) },
8424 /* VEX_LEN_71_R_6_P_2 */
8426 { VEX_W_TABLE (VEX_W_71_R_6_P_2
) },
8429 /* VEX_LEN_72_R_2_P_2 */
8431 { VEX_W_TABLE (VEX_W_72_R_2_P_2
) },
8434 /* VEX_LEN_72_R_4_P_2 */
8436 { VEX_W_TABLE (VEX_W_72_R_4_P_2
) },
8439 /* VEX_LEN_72_R_6_P_2 */
8441 { VEX_W_TABLE (VEX_W_72_R_6_P_2
) },
8444 /* VEX_LEN_73_R_2_P_2 */
8446 { VEX_W_TABLE (VEX_W_73_R_2_P_2
) },
8449 /* VEX_LEN_73_R_3_P_2 */
8451 { VEX_W_TABLE (VEX_W_73_R_3_P_2
) },
8454 /* VEX_LEN_73_R_6_P_2 */
8456 { VEX_W_TABLE (VEX_W_73_R_6_P_2
) },
8459 /* VEX_LEN_73_R_7_P_2 */
8461 { VEX_W_TABLE (VEX_W_73_R_7_P_2
) },
8464 /* VEX_LEN_74_P_2 */
8466 { VEX_W_TABLE (VEX_W_74_P_2
) },
8469 /* VEX_LEN_75_P_2 */
8471 { VEX_W_TABLE (VEX_W_75_P_2
) },
8474 /* VEX_LEN_76_P_2 */
8476 { VEX_W_TABLE (VEX_W_76_P_2
) },
8479 /* VEX_LEN_7E_P_1 */
8481 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8482 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8485 /* VEX_LEN_7E_P_2 */
8487 { "vmovK", { Edq
, XMScalar
} },
8488 { "vmovK", { Edq
, XMScalar
} },
8491 /* VEX_LEN_AE_R_2_M_0 */
8493 { VEX_W_TABLE (VEX_W_AE_R_2_M_0
) },
8496 /* VEX_LEN_AE_R_3_M_0 */
8498 { VEX_W_TABLE (VEX_W_AE_R_3_M_0
) },
8501 /* VEX_LEN_C2_P_1 */
8503 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8504 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8507 /* VEX_LEN_C2_P_3 */
8509 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8510 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8513 /* VEX_LEN_C4_P_2 */
8515 { VEX_W_TABLE (VEX_W_C4_P_2
) },
8518 /* VEX_LEN_C5_P_2 */
8520 { VEX_W_TABLE (VEX_W_C5_P_2
) },
8523 /* VEX_LEN_D1_P_2 */
8525 { VEX_W_TABLE (VEX_W_D1_P_2
) },
8528 /* VEX_LEN_D2_P_2 */
8530 { VEX_W_TABLE (VEX_W_D2_P_2
) },
8533 /* VEX_LEN_D3_P_2 */
8535 { VEX_W_TABLE (VEX_W_D3_P_2
) },
8538 /* VEX_LEN_D4_P_2 */
8540 { VEX_W_TABLE (VEX_W_D4_P_2
) },
8543 /* VEX_LEN_D5_P_2 */
8545 { VEX_W_TABLE (VEX_W_D5_P_2
) },
8548 /* VEX_LEN_D6_P_2 */
8550 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8551 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8554 /* VEX_LEN_D7_P_2_M_1 */
8556 { VEX_W_TABLE (VEX_W_D7_P_2_M_1
) },
8559 /* VEX_LEN_D8_P_2 */
8561 { VEX_W_TABLE (VEX_W_D8_P_2
) },
8564 /* VEX_LEN_D9_P_2 */
8566 { VEX_W_TABLE (VEX_W_D9_P_2
) },
8569 /* VEX_LEN_DA_P_2 */
8571 { VEX_W_TABLE (VEX_W_DA_P_2
) },
8574 /* VEX_LEN_DB_P_2 */
8576 { VEX_W_TABLE (VEX_W_DB_P_2
) },
8579 /* VEX_LEN_DC_P_2 */
8581 { VEX_W_TABLE (VEX_W_DC_P_2
) },
8584 /* VEX_LEN_DD_P_2 */
8586 { VEX_W_TABLE (VEX_W_DD_P_2
) },
8589 /* VEX_LEN_DE_P_2 */
8591 { VEX_W_TABLE (VEX_W_DE_P_2
) },
8594 /* VEX_LEN_DF_P_2 */
8596 { VEX_W_TABLE (VEX_W_DF_P_2
) },
8599 /* VEX_LEN_E0_P_2 */
8601 { VEX_W_TABLE (VEX_W_E0_P_2
) },
8604 /* VEX_LEN_E1_P_2 */
8606 { VEX_W_TABLE (VEX_W_E1_P_2
) },
8609 /* VEX_LEN_E2_P_2 */
8611 { VEX_W_TABLE (VEX_W_E2_P_2
) },
8614 /* VEX_LEN_E3_P_2 */
8616 { VEX_W_TABLE (VEX_W_E3_P_2
) },
8619 /* VEX_LEN_E4_P_2 */
8621 { VEX_W_TABLE (VEX_W_E4_P_2
) },
8624 /* VEX_LEN_E5_P_2 */
8626 { VEX_W_TABLE (VEX_W_E5_P_2
) },
8629 /* VEX_LEN_E8_P_2 */
8631 { VEX_W_TABLE (VEX_W_E8_P_2
) },
8634 /* VEX_LEN_E9_P_2 */
8636 { VEX_W_TABLE (VEX_W_E9_P_2
) },
8639 /* VEX_LEN_EA_P_2 */
8641 { VEX_W_TABLE (VEX_W_EA_P_2
) },
8644 /* VEX_LEN_EB_P_2 */
8646 { VEX_W_TABLE (VEX_W_EB_P_2
) },
8649 /* VEX_LEN_EC_P_2 */
8651 { VEX_W_TABLE (VEX_W_EC_P_2
) },
8654 /* VEX_LEN_ED_P_2 */
8656 { VEX_W_TABLE (VEX_W_ED_P_2
) },
8659 /* VEX_LEN_EE_P_2 */
8661 { VEX_W_TABLE (VEX_W_EE_P_2
) },
8664 /* VEX_LEN_EF_P_2 */
8666 { VEX_W_TABLE (VEX_W_EF_P_2
) },
8669 /* VEX_LEN_F1_P_2 */
8671 { VEX_W_TABLE (VEX_W_F1_P_2
) },
8674 /* VEX_LEN_F2_P_2 */
8676 { VEX_W_TABLE (VEX_W_F2_P_2
) },
8679 /* VEX_LEN_F3_P_2 */
8681 { VEX_W_TABLE (VEX_W_F3_P_2
) },
8684 /* VEX_LEN_F4_P_2 */
8686 { VEX_W_TABLE (VEX_W_F4_P_2
) },
8689 /* VEX_LEN_F5_P_2 */
8691 { VEX_W_TABLE (VEX_W_F5_P_2
) },
8694 /* VEX_LEN_F6_P_2 */
8696 { VEX_W_TABLE (VEX_W_F6_P_2
) },
8699 /* VEX_LEN_F7_P_2 */
8701 { VEX_W_TABLE (VEX_W_F7_P_2
) },
8704 /* VEX_LEN_F8_P_2 */
8706 { VEX_W_TABLE (VEX_W_F8_P_2
) },
8709 /* VEX_LEN_F9_P_2 */
8711 { VEX_W_TABLE (VEX_W_F9_P_2
) },
8714 /* VEX_LEN_FA_P_2 */
8716 { VEX_W_TABLE (VEX_W_FA_P_2
) },
8719 /* VEX_LEN_FB_P_2 */
8721 { VEX_W_TABLE (VEX_W_FB_P_2
) },
8724 /* VEX_LEN_FC_P_2 */
8726 { VEX_W_TABLE (VEX_W_FC_P_2
) },
8729 /* VEX_LEN_FD_P_2 */
8731 { VEX_W_TABLE (VEX_W_FD_P_2
) },
8734 /* VEX_LEN_FE_P_2 */
8736 { VEX_W_TABLE (VEX_W_FE_P_2
) },
8739 /* VEX_LEN_3800_P_2 */
8741 { VEX_W_TABLE (VEX_W_3800_P_2
) },
8744 /* VEX_LEN_3801_P_2 */
8746 { VEX_W_TABLE (VEX_W_3801_P_2
) },
8749 /* VEX_LEN_3802_P_2 */
8751 { VEX_W_TABLE (VEX_W_3802_P_2
) },
8754 /* VEX_LEN_3803_P_2 */
8756 { VEX_W_TABLE (VEX_W_3803_P_2
) },
8759 /* VEX_LEN_3804_P_2 */
8761 { VEX_W_TABLE (VEX_W_3804_P_2
) },
8764 /* VEX_LEN_3805_P_2 */
8766 { VEX_W_TABLE (VEX_W_3805_P_2
) },
8769 /* VEX_LEN_3806_P_2 */
8771 { VEX_W_TABLE (VEX_W_3806_P_2
) },
8774 /* VEX_LEN_3807_P_2 */
8776 { VEX_W_TABLE (VEX_W_3807_P_2
) },
8779 /* VEX_LEN_3808_P_2 */
8781 { VEX_W_TABLE (VEX_W_3808_P_2
) },
8784 /* VEX_LEN_3809_P_2 */
8786 { VEX_W_TABLE (VEX_W_3809_P_2
) },
8789 /* VEX_LEN_380A_P_2 */
8791 { VEX_W_TABLE (VEX_W_380A_P_2
) },
8794 /* VEX_LEN_380B_P_2 */
8796 { VEX_W_TABLE (VEX_W_380B_P_2
) },
8799 /* VEX_LEN_3819_P_2_M_0 */
8802 { VEX_W_TABLE (VEX_W_3819_P_2_M_0
) },
8805 /* VEX_LEN_381A_P_2_M_0 */
8808 { VEX_W_TABLE (VEX_W_381A_P_2_M_0
) },
8811 /* VEX_LEN_381C_P_2 */
8813 { VEX_W_TABLE (VEX_W_381C_P_2
) },
8816 /* VEX_LEN_381D_P_2 */
8818 { VEX_W_TABLE (VEX_W_381D_P_2
) },
8821 /* VEX_LEN_381E_P_2 */
8823 { VEX_W_TABLE (VEX_W_381E_P_2
) },
8826 /* VEX_LEN_3820_P_2 */
8828 { VEX_W_TABLE (VEX_W_3820_P_2
) },
8831 /* VEX_LEN_3821_P_2 */
8833 { VEX_W_TABLE (VEX_W_3821_P_2
) },
8836 /* VEX_LEN_3822_P_2 */
8838 { VEX_W_TABLE (VEX_W_3822_P_2
) },
8841 /* VEX_LEN_3823_P_2 */
8843 { VEX_W_TABLE (VEX_W_3823_P_2
) },
8846 /* VEX_LEN_3824_P_2 */
8848 { VEX_W_TABLE (VEX_W_3824_P_2
) },
8851 /* VEX_LEN_3825_P_2 */
8853 { VEX_W_TABLE (VEX_W_3825_P_2
) },
8856 /* VEX_LEN_3828_P_2 */
8858 { VEX_W_TABLE (VEX_W_3828_P_2
) },
8861 /* VEX_LEN_3829_P_2 */
8863 { VEX_W_TABLE (VEX_W_3829_P_2
) },
8866 /* VEX_LEN_382A_P_2_M_0 */
8868 { VEX_W_TABLE (VEX_W_382A_P_2_M_0
) },
8871 /* VEX_LEN_382B_P_2 */
8873 { VEX_W_TABLE (VEX_W_382B_P_2
) },
8876 /* VEX_LEN_3830_P_2 */
8878 { VEX_W_TABLE (VEX_W_3830_P_2
) },
8881 /* VEX_LEN_3831_P_2 */
8883 { VEX_W_TABLE (VEX_W_3831_P_2
) },
8886 /* VEX_LEN_3832_P_2 */
8888 { VEX_W_TABLE (VEX_W_3832_P_2
) },
8891 /* VEX_LEN_3833_P_2 */
8893 { VEX_W_TABLE (VEX_W_3833_P_2
) },
8896 /* VEX_LEN_3834_P_2 */
8898 { VEX_W_TABLE (VEX_W_3834_P_2
) },
8901 /* VEX_LEN_3835_P_2 */
8903 { VEX_W_TABLE (VEX_W_3835_P_2
) },
8906 /* VEX_LEN_3837_P_2 */
8908 { VEX_W_TABLE (VEX_W_3837_P_2
) },
8911 /* VEX_LEN_3838_P_2 */
8913 { VEX_W_TABLE (VEX_W_3838_P_2
) },
8916 /* VEX_LEN_3839_P_2 */
8918 { VEX_W_TABLE (VEX_W_3839_P_2
) },
8921 /* VEX_LEN_383A_P_2 */
8923 { VEX_W_TABLE (VEX_W_383A_P_2
) },
8926 /* VEX_LEN_383B_P_2 */
8928 { VEX_W_TABLE (VEX_W_383B_P_2
) },
8931 /* VEX_LEN_383C_P_2 */
8933 { VEX_W_TABLE (VEX_W_383C_P_2
) },
8936 /* VEX_LEN_383D_P_2 */
8938 { VEX_W_TABLE (VEX_W_383D_P_2
) },
8941 /* VEX_LEN_383E_P_2 */
8943 { VEX_W_TABLE (VEX_W_383E_P_2
) },
8946 /* VEX_LEN_383F_P_2 */
8948 { VEX_W_TABLE (VEX_W_383F_P_2
) },
8951 /* VEX_LEN_3840_P_2 */
8953 { VEX_W_TABLE (VEX_W_3840_P_2
) },
8956 /* VEX_LEN_3841_P_2 */
8958 { VEX_W_TABLE (VEX_W_3841_P_2
) },
8961 /* VEX_LEN_38DB_P_2 */
8963 { VEX_W_TABLE (VEX_W_38DB_P_2
) },
8966 /* VEX_LEN_38DC_P_2 */
8968 { VEX_W_TABLE (VEX_W_38DC_P_2
) },
8971 /* VEX_LEN_38DD_P_2 */
8973 { VEX_W_TABLE (VEX_W_38DD_P_2
) },
8976 /* VEX_LEN_38DE_P_2 */
8978 { VEX_W_TABLE (VEX_W_38DE_P_2
) },
8981 /* VEX_LEN_38DF_P_2 */
8983 { VEX_W_TABLE (VEX_W_38DF_P_2
) },
8986 /* VEX_LEN_3A06_P_2 */
8989 { VEX_W_TABLE (VEX_W_3A06_P_2
) },
8992 /* VEX_LEN_3A0A_P_2 */
8994 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
8995 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
8998 /* VEX_LEN_3A0B_P_2 */
9000 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
9001 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
9004 /* VEX_LEN_3A0E_P_2 */
9006 { VEX_W_TABLE (VEX_W_3A0E_P_2
) },
9009 /* VEX_LEN_3A0F_P_2 */
9011 { VEX_W_TABLE (VEX_W_3A0F_P_2
) },
9014 /* VEX_LEN_3A14_P_2 */
9016 { VEX_W_TABLE (VEX_W_3A14_P_2
) },
9019 /* VEX_LEN_3A15_P_2 */
9021 { VEX_W_TABLE (VEX_W_3A15_P_2
) },
9024 /* VEX_LEN_3A16_P_2 */
9026 { "vpextrK", { Edq
, XM
, Ib
} },
9029 /* VEX_LEN_3A17_P_2 */
9031 { "vextractps", { Edqd
, XM
, Ib
} },
9034 /* VEX_LEN_3A18_P_2 */
9037 { VEX_W_TABLE (VEX_W_3A18_P_2
) },
9040 /* VEX_LEN_3A19_P_2 */
9043 { VEX_W_TABLE (VEX_W_3A19_P_2
) },
9046 /* VEX_LEN_3A20_P_2 */
9048 { VEX_W_TABLE (VEX_W_3A20_P_2
) },
9051 /* VEX_LEN_3A21_P_2 */
9053 { VEX_W_TABLE (VEX_W_3A21_P_2
) },
9056 /* VEX_LEN_3A22_P_2 */
9058 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9061 /* VEX_LEN_3A41_P_2 */
9063 { VEX_W_TABLE (VEX_W_3A41_P_2
) },
9066 /* VEX_LEN_3A42_P_2 */
9068 { VEX_W_TABLE (VEX_W_3A42_P_2
) },
9071 /* VEX_LEN_3A44_P_2 */
9073 { VEX_W_TABLE (VEX_W_3A44_P_2
) },
9076 /* VEX_LEN_3A4C_P_2 */
9078 { VEX_W_TABLE (VEX_W_3A4C_P_2
) },
9081 /* VEX_LEN_3A60_P_2 */
9083 { VEX_W_TABLE (VEX_W_3A60_P_2
) },
9086 /* VEX_LEN_3A61_P_2 */
9088 { VEX_W_TABLE (VEX_W_3A61_P_2
) },
9091 /* VEX_LEN_3A62_P_2 */
9093 { VEX_W_TABLE (VEX_W_3A62_P_2
) },
9096 /* VEX_LEN_3A63_P_2 */
9098 { VEX_W_TABLE (VEX_W_3A63_P_2
) },
9101 /* VEX_LEN_3A6A_P_2 */
9103 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9106 /* VEX_LEN_3A6B_P_2 */
9108 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9111 /* VEX_LEN_3A6E_P_2 */
9113 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9116 /* VEX_LEN_3A6F_P_2 */
9118 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9121 /* VEX_LEN_3A7A_P_2 */
9123 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9126 /* VEX_LEN_3A7B_P_2 */
9128 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9131 /* VEX_LEN_3A7E_P_2 */
9133 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9136 /* VEX_LEN_3A7F_P_2 */
9138 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9141 /* VEX_LEN_3ADF_P_2 */
9143 { VEX_W_TABLE (VEX_W_3ADF_P_2
) },
9146 /* VEX_LEN_XOP_09_80 */
9148 { "vfrczps", { XM
, EXxmm
} },
9149 { "vfrczps", { XM
, EXymmq
} },
9152 /* VEX_LEN_XOP_09_81 */
9154 { "vfrczpd", { XM
, EXxmm
} },
9155 { "vfrczpd", { XM
, EXymmq
} },
9159 static const struct dis386 vex_w_table
[][2] = {
9162 { "vmovups", { XM
, EXx
} },
9166 { "vmovss", { XMVexScalar
, VexScalar
, EXdScalar
} },
9170 { "vmovupd", { XM
, EXx
} },
9174 { "vmovsd", { XMVexScalar
, VexScalar
, EXqScalar
} },
9178 { "vmovups", { EXxS
, XM
} },
9182 { "vmovss", { EXdVexScalarS
, VexScalar
, XMScalar
} },
9186 { "vmovupd", { EXxS
, XM
} },
9190 { "vmovsd", { EXqVexScalarS
, VexScalar
, XMScalar
} },
9193 /* VEX_W_12_P_0_M_0 */
9194 { "vmovlps", { XM
, Vex128
, EXq
} },
9197 /* VEX_W_12_P_0_M_1 */
9198 { "vmovhlps", { XM
, Vex128
, EXq
} },
9202 { "vmovsldup", { XM
, EXx
} },
9206 { "vmovlpd", { XM
, Vex128
, EXq
} },
9210 { "vmovddup", { XM
, EXymmq
} },
9214 { "vmovlpX", { EXq
, XM
} },
9218 { "vunpcklpX", { XM
, Vex
, EXx
} },
9222 { "vunpckhpX", { XM
, Vex
, EXx
} },
9225 /* VEX_W_16_P_0_M_0 */
9226 { "vmovhps", { XM
, Vex128
, EXq
} },
9229 /* VEX_W_16_P_0_M_1 */
9230 { "vmovlhps", { XM
, Vex128
, EXq
} },
9234 { "vmovshdup", { XM
, EXx
} },
9238 { "vmovhpd", { XM
, Vex128
, EXq
} },
9242 { "vmovhpX", { EXq
, XM
} },
9246 { "vmovapX", { XM
, EXx
} },
9250 { "vmovapX", { EXxS
, XM
} },
9254 { "vmovntpX", { Mx
, XM
} },
9258 { "vucomiss", { XMScalar
, EXdScalar
} },
9262 { "vucomisd", { XMScalar
, EXqScalar
} },
9266 { "vcomiss", { XMScalar
, EXdScalar
} },
9270 { "vcomisd", { XMScalar
, EXqScalar
} },
9274 { "vmovmskpX", { Gdq
, XS
} },
9278 { "vsqrtps", { XM
, EXx
} },
9282 { "vsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9286 { "vsqrtpd", { XM
, EXx
} },
9290 { "vsqrtsd", { XMScalar
, VexScalar
, EXqScalar
} },
9294 { "vrsqrtps", { XM
, EXx
} },
9298 { "vrsqrtss", { XMScalar
, VexScalar
, EXdScalar
} },
9302 { "vrcpps", { XM
, EXx
} },
9306 { "vrcpss", { XMScalar
, VexScalar
, EXdScalar
} },
9310 { "vaddps", { XM
, Vex
, EXx
} },
9314 { "vaddss", { XMScalar
, VexScalar
, EXdScalar
} },
9318 { "vaddpd", { XM
, Vex
, EXx
} },
9322 { "vaddsd", { XMScalar
, VexScalar
, EXqScalar
} },
9326 { "vmulps", { XM
, Vex
, EXx
} },
9330 { "vmulss", { XMScalar
, VexScalar
, EXdScalar
} },
9334 { "vmulpd", { XM
, Vex
, EXx
} },
9338 { "vmulsd", { XMScalar
, VexScalar
, EXqScalar
} },
9342 { "vcvtps2pd", { XM
, EXxmmq
} },
9346 { "vcvtss2sd", { XMScalar
, VexScalar
, EXdScalar
} },
9350 { "vcvtsd2ss", { XMScalar
, VexScalar
, EXqScalar
} },
9354 { "vcvtdq2ps", { XM
, EXx
} },
9358 { "vcvttps2dq", { XM
, EXx
} },
9362 { "vcvtps2dq", { XM
, EXx
} },
9366 { "vsubps", { XM
, Vex
, EXx
} },
9370 { "vsubss", { XMScalar
, VexScalar
, EXdScalar
} },
9374 { "vsubpd", { XM
, Vex
, EXx
} },
9378 { "vsubsd", { XMScalar
, VexScalar
, EXqScalar
} },
9382 { "vminps", { XM
, Vex
, EXx
} },
9386 { "vminss", { XMScalar
, VexScalar
, EXdScalar
} },
9390 { "vminpd", { XM
, Vex
, EXx
} },
9394 { "vminsd", { XMScalar
, VexScalar
, EXqScalar
} },
9398 { "vdivps", { XM
, Vex
, EXx
} },
9402 { "vdivss", { XMScalar
, VexScalar
, EXdScalar
} },
9406 { "vdivpd", { XM
, Vex
, EXx
} },
9410 { "vdivsd", { XMScalar
, VexScalar
, EXqScalar
} },
9414 { "vmaxps", { XM
, Vex
, EXx
} },
9418 { "vmaxss", { XMScalar
, VexScalar
, EXdScalar
} },
9422 { "vmaxpd", { XM
, Vex
, EXx
} },
9426 { "vmaxsd", { XMScalar
, VexScalar
, EXqScalar
} },
9430 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
9434 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
9438 { "vpunpckldq", { XM
, Vex128
, EXx
} },
9442 { "vpacksswb", { XM
, Vex128
, EXx
} },
9446 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
9450 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
9454 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
9458 { "vpackuswb", { XM
, Vex128
, EXx
} },
9462 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
9466 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
9470 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
9474 { "vpackssdw", { XM
, Vex128
, EXx
} },
9478 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
9482 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
9486 { "vmovdqu", { XM
, EXx
} },
9490 { "vmovdqa", { XM
, EXx
} },
9494 { "vpshufhw", { XM
, EXx
, Ib
} },
9498 { "vpshufd", { XM
, EXx
, Ib
} },
9502 { "vpshuflw", { XM
, EXx
, Ib
} },
9505 /* VEX_W_71_R_2_P_2 */
9506 { "vpsrlw", { Vex128
, XS
, Ib
} },
9509 /* VEX_W_71_R_4_P_2 */
9510 { "vpsraw", { Vex128
, XS
, Ib
} },
9513 /* VEX_W_71_R_6_P_2 */
9514 { "vpsllw", { Vex128
, XS
, Ib
} },
9517 /* VEX_W_72_R_2_P_2 */
9518 { "vpsrld", { Vex128
, XS
, Ib
} },
9521 /* VEX_W_72_R_4_P_2 */
9522 { "vpsrad", { Vex128
, XS
, Ib
} },
9525 /* VEX_W_72_R_6_P_2 */
9526 { "vpslld", { Vex128
, XS
, Ib
} },
9529 /* VEX_W_73_R_2_P_2 */
9530 { "vpsrlq", { Vex128
, XS
, Ib
} },
9533 /* VEX_W_73_R_3_P_2 */
9534 { "vpsrldq", { Vex128
, XS
, Ib
} },
9537 /* VEX_W_73_R_6_P_2 */
9538 { "vpsllq", { Vex128
, XS
, Ib
} },
9541 /* VEX_W_73_R_7_P_2 */
9542 { "vpslldq", { Vex128
, XS
, Ib
} },
9546 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
9550 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
9554 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
9562 { "vhaddpd", { XM
, Vex
, EXx
} },
9566 { "vhaddps", { XM
, Vex
, EXx
} },
9570 { "vhsubpd", { XM
, Vex
, EXx
} },
9574 { "vhsubps", { XM
, Vex
, EXx
} },
9578 { "vmovq", { XMScalar
, EXqScalar
} },
9582 { "vmovdqu", { EXxS
, XM
} },
9586 { "vmovdqa", { EXxS
, XM
} },
9589 /* VEX_W_AE_R_2_M_0 */
9590 { "vldmxcsr", { Md
} },
9593 /* VEX_W_AE_R_3_M_0 */
9594 { "vstmxcsr", { Md
} },
9598 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
9602 { "vcmpss", { XMScalar
, VexScalar
, EXdScalar
, VCMP
} },
9606 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
9610 { "vcmpsd", { XMScalar
, VexScalar
, EXqScalar
, VCMP
} },
9614 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
9618 { "vpextrw", { Gdq
, XS
, Ib
} },
9622 { "vaddsubpd", { XM
, Vex
, EXx
} },
9626 { "vaddsubps", { XM
, Vex
, EXx
} },
9630 { "vpsrlw", { XM
, Vex128
, EXx
} },
9634 { "vpsrld", { XM
, Vex128
, EXx
} },
9638 { "vpsrlq", { XM
, Vex128
, EXx
} },
9642 { "vpaddq", { XM
, Vex128
, EXx
} },
9646 { "vpmullw", { XM
, Vex128
, EXx
} },
9650 { "vmovq", { EXqScalarS
, XMScalar
} },
9653 /* VEX_W_D7_P_2_M_1 */
9654 { "vpmovmskb", { Gdq
, XS
} },
9658 { "vpsubusb", { XM
, Vex128
, EXx
} },
9662 { "vpsubusw", { XM
, Vex128
, EXx
} },
9666 { "vpminub", { XM
, Vex128
, EXx
} },
9670 { "vpand", { XM
, Vex128
, EXx
} },
9674 { "vpaddusb", { XM
, Vex128
, EXx
} },
9678 { "vpaddusw", { XM
, Vex128
, EXx
} },
9682 { "vpmaxub", { XM
, Vex128
, EXx
} },
9686 { "vpandn", { XM
, Vex128
, EXx
} },
9690 { "vpavgb", { XM
, Vex128
, EXx
} },
9694 { "vpsraw", { XM
, Vex128
, EXx
} },
9698 { "vpsrad", { XM
, Vex128
, EXx
} },
9702 { "vpavgw", { XM
, Vex128
, EXx
} },
9706 { "vpmulhuw", { XM
, Vex128
, EXx
} },
9710 { "vpmulhw", { XM
, Vex128
, EXx
} },
9714 { "vcvtdq2pd", { XM
, EXxmmq
} },
9718 { "vcvttpd2dq%XY", { XMM
, EXx
} },
9722 { "vcvtpd2dq%XY", { XMM
, EXx
} },
9725 /* VEX_W_E7_P_2_M_0 */
9726 { "vmovntdq", { Mx
, XM
} },
9730 { "vpsubsb", { XM
, Vex128
, EXx
} },
9734 { "vpsubsw", { XM
, Vex128
, EXx
} },
9738 { "vpminsw", { XM
, Vex128
, EXx
} },
9742 { "vpor", { XM
, Vex128
, EXx
} },
9746 { "vpaddsb", { XM
, Vex128
, EXx
} },
9750 { "vpaddsw", { XM
, Vex128
, EXx
} },
9754 { "vpmaxsw", { XM
, Vex128
, EXx
} },
9758 { "vpxor", { XM
, Vex128
, EXx
} },
9761 /* VEX_W_F0_P_3_M_0 */
9762 { "vlddqu", { XM
, M
} },
9766 { "vpsllw", { XM
, Vex128
, EXx
} },
9770 { "vpslld", { XM
, Vex128
, EXx
} },
9774 { "vpsllq", { XM
, Vex128
, EXx
} },
9778 { "vpmuludq", { XM
, Vex128
, EXx
} },
9782 { "vpmaddwd", { XM
, Vex128
, EXx
} },
9786 { "vpsadbw", { XM
, Vex128
, EXx
} },
9790 { "vmaskmovdqu", { XM
, XS
} },
9794 { "vpsubb", { XM
, Vex128
, EXx
} },
9798 { "vpsubw", { XM
, Vex128
, EXx
} },
9802 { "vpsubd", { XM
, Vex128
, EXx
} },
9806 { "vpsubq", { XM
, Vex128
, EXx
} },
9810 { "vpaddb", { XM
, Vex128
, EXx
} },
9814 { "vpaddw", { XM
, Vex128
, EXx
} },
9818 { "vpaddd", { XM
, Vex128
, EXx
} },
9821 /* VEX_W_3800_P_2 */
9822 { "vpshufb", { XM
, Vex128
, EXx
} },
9825 /* VEX_W_3801_P_2 */
9826 { "vphaddw", { XM
, Vex128
, EXx
} },
9829 /* VEX_W_3802_P_2 */
9830 { "vphaddd", { XM
, Vex128
, EXx
} },
9833 /* VEX_W_3803_P_2 */
9834 { "vphaddsw", { XM
, Vex128
, EXx
} },
9837 /* VEX_W_3804_P_2 */
9838 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
9841 /* VEX_W_3805_P_2 */
9842 { "vphsubw", { XM
, Vex128
, EXx
} },
9845 /* VEX_W_3806_P_2 */
9846 { "vphsubd", { XM
, Vex128
, EXx
} },
9849 /* VEX_W_3807_P_2 */
9850 { "vphsubsw", { XM
, Vex128
, EXx
} },
9853 /* VEX_W_3808_P_2 */
9854 { "vpsignb", { XM
, Vex128
, EXx
} },
9857 /* VEX_W_3809_P_2 */
9858 { "vpsignw", { XM
, Vex128
, EXx
} },
9861 /* VEX_W_380A_P_2 */
9862 { "vpsignd", { XM
, Vex128
, EXx
} },
9865 /* VEX_W_380B_P_2 */
9866 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
9869 /* VEX_W_380C_P_2 */
9870 { "vpermilps", { XM
, Vex
, EXx
} },
9873 /* VEX_W_380D_P_2 */
9874 { "vpermilpd", { XM
, Vex
, EXx
} },
9877 /* VEX_W_380E_P_2 */
9878 { "vtestps", { XM
, EXx
} },
9881 /* VEX_W_380F_P_2 */
9882 { "vtestpd", { XM
, EXx
} },
9885 /* VEX_W_3817_P_2 */
9886 { "vptest", { XM
, EXx
} },
9889 /* VEX_W_3818_P_2_M_0 */
9890 { "vbroadcastss", { XM
, Md
} },
9893 /* VEX_W_3819_P_2_M_0 */
9894 { "vbroadcastsd", { XM
, Mq
} },
9897 /* VEX_W_381A_P_2_M_0 */
9898 { "vbroadcastf128", { XM
, Mxmm
} },
9901 /* VEX_W_381C_P_2 */
9902 { "vpabsb", { XM
, EXx
} },
9905 /* VEX_W_381D_P_2 */
9906 { "vpabsw", { XM
, EXx
} },
9909 /* VEX_W_381E_P_2 */
9910 { "vpabsd", { XM
, EXx
} },
9913 /* VEX_W_3820_P_2 */
9914 { "vpmovsxbw", { XM
, EXq
} },
9917 /* VEX_W_3821_P_2 */
9918 { "vpmovsxbd", { XM
, EXd
} },
9921 /* VEX_W_3822_P_2 */
9922 { "vpmovsxbq", { XM
, EXw
} },
9925 /* VEX_W_3823_P_2 */
9926 { "vpmovsxwd", { XM
, EXq
} },
9929 /* VEX_W_3824_P_2 */
9930 { "vpmovsxwq", { XM
, EXd
} },
9933 /* VEX_W_3825_P_2 */
9934 { "vpmovsxdq", { XM
, EXq
} },
9937 /* VEX_W_3828_P_2 */
9938 { "vpmuldq", { XM
, Vex128
, EXx
} },
9941 /* VEX_W_3829_P_2 */
9942 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
9945 /* VEX_W_382A_P_2_M_0 */
9946 { "vmovntdqa", { XM
, Mx
} },
9949 /* VEX_W_382B_P_2 */
9950 { "vpackusdw", { XM
, Vex128
, EXx
} },
9953 /* VEX_W_382C_P_2_M_0 */
9954 { "vmaskmovps", { XM
, Vex
, Mx
} },
9957 /* VEX_W_382D_P_2_M_0 */
9958 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9961 /* VEX_W_382E_P_2_M_0 */
9962 { "vmaskmovps", { Mx
, Vex
, XM
} },
9965 /* VEX_W_382F_P_2_M_0 */
9966 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9969 /* VEX_W_3830_P_2 */
9970 { "vpmovzxbw", { XM
, EXq
} },
9973 /* VEX_W_3831_P_2 */
9974 { "vpmovzxbd", { XM
, EXd
} },
9977 /* VEX_W_3832_P_2 */
9978 { "vpmovzxbq", { XM
, EXw
} },
9981 /* VEX_W_3833_P_2 */
9982 { "vpmovzxwd", { XM
, EXq
} },
9985 /* VEX_W_3834_P_2 */
9986 { "vpmovzxwq", { XM
, EXd
} },
9989 /* VEX_W_3835_P_2 */
9990 { "vpmovzxdq", { XM
, EXq
} },
9993 /* VEX_W_3837_P_2 */
9994 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
9997 /* VEX_W_3838_P_2 */
9998 { "vpminsb", { XM
, Vex128
, EXx
} },
10001 /* VEX_W_3839_P_2 */
10002 { "vpminsd", { XM
, Vex128
, EXx
} },
10005 /* VEX_W_383A_P_2 */
10006 { "vpminuw", { XM
, Vex128
, EXx
} },
10009 /* VEX_W_383B_P_2 */
10010 { "vpminud", { XM
, Vex128
, EXx
} },
10013 /* VEX_W_383C_P_2 */
10014 { "vpmaxsb", { XM
, Vex128
, EXx
} },
10017 /* VEX_W_383D_P_2 */
10018 { "vpmaxsd", { XM
, Vex128
, EXx
} },
10021 /* VEX_W_383E_P_2 */
10022 { "vpmaxuw", { XM
, Vex128
, EXx
} },
10025 /* VEX_W_383F_P_2 */
10026 { "vpmaxud", { XM
, Vex128
, EXx
} },
10029 /* VEX_W_3840_P_2 */
10030 { "vpmulld", { XM
, Vex128
, EXx
} },
10033 /* VEX_W_3841_P_2 */
10034 { "vphminposuw", { XM
, EXx
} },
10037 /* VEX_W_38DB_P_2 */
10038 { "vaesimc", { XM
, EXx
} },
10041 /* VEX_W_38DC_P_2 */
10042 { "vaesenc", { XM
, Vex128
, EXx
} },
10045 /* VEX_W_38DD_P_2 */
10046 { "vaesenclast", { XM
, Vex128
, EXx
} },
10049 /* VEX_W_38DE_P_2 */
10050 { "vaesdec", { XM
, Vex128
, EXx
} },
10053 /* VEX_W_38DF_P_2 */
10054 { "vaesdeclast", { XM
, Vex128
, EXx
} },
10057 /* VEX_W_3A04_P_2 */
10058 { "vpermilps", { XM
, EXx
, Ib
} },
10061 /* VEX_W_3A05_P_2 */
10062 { "vpermilpd", { XM
, EXx
, Ib
} },
10065 /* VEX_W_3A06_P_2 */
10066 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
10069 /* VEX_W_3A08_P_2 */
10070 { "vroundps", { XM
, EXx
, Ib
} },
10073 /* VEX_W_3A09_P_2 */
10074 { "vroundpd", { XM
, EXx
, Ib
} },
10077 /* VEX_W_3A0A_P_2 */
10078 { "vroundss", { XMScalar
, VexScalar
, EXdScalar
, Ib
} },
10081 /* VEX_W_3A0B_P_2 */
10082 { "vroundsd", { XMScalar
, VexScalar
, EXqScalar
, Ib
} },
10085 /* VEX_W_3A0C_P_2 */
10086 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
10089 /* VEX_W_3A0D_P_2 */
10090 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
10093 /* VEX_W_3A0E_P_2 */
10094 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
10097 /* VEX_W_3A0F_P_2 */
10098 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
10101 /* VEX_W_3A14_P_2 */
10102 { "vpextrb", { Edqb
, XM
, Ib
} },
10105 /* VEX_W_3A15_P_2 */
10106 { "vpextrw", { Edqw
, XM
, Ib
} },
10109 /* VEX_W_3A18_P_2 */
10110 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
10113 /* VEX_W_3A19_P_2 */
10114 { "vextractf128", { EXxmm
, XM
, Ib
} },
10117 /* VEX_W_3A20_P_2 */
10118 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
10121 /* VEX_W_3A21_P_2 */
10122 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
10125 /* VEX_W_3A40_P_2 */
10126 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
10129 /* VEX_W_3A41_P_2 */
10130 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
10133 /* VEX_W_3A42_P_2 */
10134 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
10137 /* VEX_W_3A44_P_2 */
10138 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
10141 /* VEX_W_3A48_P_2 */
10142 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10143 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10146 /* VEX_W_3A49_P_2 */
10147 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10148 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
} },
10151 /* VEX_W_3A4A_P_2 */
10152 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
10155 /* VEX_W_3A4B_P_2 */
10156 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
10159 /* VEX_W_3A4C_P_2 */
10160 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
10163 /* VEX_W_3A60_P_2 */
10164 { "vpcmpestrm", { XM
, EXx
, Ib
} },
10167 /* VEX_W_3A61_P_2 */
10168 { "vpcmpestri", { XM
, EXx
, Ib
} },
10171 /* VEX_W_3A62_P_2 */
10172 { "vpcmpistrm", { XM
, EXx
, Ib
} },
10175 /* VEX_W_3A63_P_2 */
10176 { "vpcmpistri", { XM
, EXx
, Ib
} },
10179 /* VEX_W_3ADF_P_2 */
10180 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
10184 static const struct dis386 mod_table
[][2] = {
10187 { "leaS", { Gv
, M
} },
10190 /* MOD_0F01_REG_0 */
10191 { X86_64_TABLE (X86_64_0F01_REG_0
) },
10192 { RM_TABLE (RM_0F01_REG_0
) },
10195 /* MOD_0F01_REG_1 */
10196 { X86_64_TABLE (X86_64_0F01_REG_1
) },
10197 { RM_TABLE (RM_0F01_REG_1
) },
10200 /* MOD_0F01_REG_2 */
10201 { X86_64_TABLE (X86_64_0F01_REG_2
) },
10202 { RM_TABLE (RM_0F01_REG_2
) },
10205 /* MOD_0F01_REG_3 */
10206 { X86_64_TABLE (X86_64_0F01_REG_3
) },
10207 { RM_TABLE (RM_0F01_REG_3
) },
10210 /* MOD_0F01_REG_7 */
10211 { "invlpg", { Mb
} },
10212 { RM_TABLE (RM_0F01_REG_7
) },
10215 /* MOD_0F12_PREFIX_0 */
10216 { "movlps", { XM
, EXq
} },
10217 { "movhlps", { XM
, EXq
} },
10221 { "movlpX", { EXq
, XM
} },
10224 /* MOD_0F16_PREFIX_0 */
10225 { "movhps", { XM
, EXq
} },
10226 { "movlhps", { XM
, EXq
} },
10230 { "movhpX", { EXq
, XM
} },
10233 /* MOD_0F18_REG_0 */
10234 { "prefetchnta", { Mb
} },
10237 /* MOD_0F18_REG_1 */
10238 { "prefetcht0", { Mb
} },
10241 /* MOD_0F18_REG_2 */
10242 { "prefetcht1", { Mb
} },
10245 /* MOD_0F18_REG_3 */
10246 { "prefetcht2", { Mb
} },
10251 { "movZ", { Rm
, Cm
} },
10256 { "movZ", { Rm
, Dm
} },
10261 { "movZ", { Cm
, Rm
} },
10266 { "movZ", { Dm
, Rm
} },
10271 { "movL", { Rd
, Td
} },
10276 { "movL", { Td
, Rd
} },
10279 /* MOD_0F2B_PREFIX_0 */
10280 {"movntps", { Mx
, XM
} },
10283 /* MOD_0F2B_PREFIX_1 */
10284 {"movntss", { Md
, XM
} },
10287 /* MOD_0F2B_PREFIX_2 */
10288 {"movntpd", { Mx
, XM
} },
10291 /* MOD_0F2B_PREFIX_3 */
10292 {"movntsd", { Mq
, XM
} },
10297 { "movmskpX", { Gdq
, XS
} },
10300 /* MOD_0F71_REG_2 */
10302 { "psrlw", { MS
, Ib
} },
10305 /* MOD_0F71_REG_4 */
10307 { "psraw", { MS
, Ib
} },
10310 /* MOD_0F71_REG_6 */
10312 { "psllw", { MS
, Ib
} },
10315 /* MOD_0F72_REG_2 */
10317 { "psrld", { MS
, Ib
} },
10320 /* MOD_0F72_REG_4 */
10322 { "psrad", { MS
, Ib
} },
10325 /* MOD_0F72_REG_6 */
10327 { "pslld", { MS
, Ib
} },
10330 /* MOD_0F73_REG_2 */
10332 { "psrlq", { MS
, Ib
} },
10335 /* MOD_0F73_REG_3 */
10337 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
10340 /* MOD_0F73_REG_6 */
10342 { "psllq", { MS
, Ib
} },
10345 /* MOD_0F73_REG_7 */
10347 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
10350 /* MOD_0FAE_REG_0 */
10351 { "fxsave", { FXSAVE
} },
10354 /* MOD_0FAE_REG_1 */
10355 { "fxrstor", { FXSAVE
} },
10358 /* MOD_0FAE_REG_2 */
10359 { "ldmxcsr", { Md
} },
10362 /* MOD_0FAE_REG_3 */
10363 { "stmxcsr", { Md
} },
10366 /* MOD_0FAE_REG_4 */
10367 { "xsave", { FXSAVE
} },
10370 /* MOD_0FAE_REG_5 */
10371 { "xrstor", { FXSAVE
} },
10372 { RM_TABLE (RM_0FAE_REG_5
) },
10375 /* MOD_0FAE_REG_6 */
10377 { RM_TABLE (RM_0FAE_REG_6
) },
10380 /* MOD_0FAE_REG_7 */
10381 { "clflush", { Mb
} },
10382 { RM_TABLE (RM_0FAE_REG_7
) },
10386 { "lssS", { Gv
, Mp
} },
10390 { "lfsS", { Gv
, Mp
} },
10394 { "lgsS", { Gv
, Mp
} },
10397 /* MOD_0FC7_REG_6 */
10398 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
10401 /* MOD_0FC7_REG_7 */
10402 { "vmptrst", { Mq
} },
10407 { "pmovmskb", { Gdq
, MS
} },
10410 /* MOD_0FE7_PREFIX_2 */
10411 { "movntdq", { Mx
, XM
} },
10414 /* MOD_0FF0_PREFIX_3 */
10415 { "lddqu", { XM
, M
} },
10418 /* MOD_0F382A_PREFIX_2 */
10419 { "movntdqa", { XM
, Mx
} },
10423 { "bound{S|}", { Gv
, Ma
} },
10427 { "lesS", { Gv
, Mp
} },
10428 { VEX_C4_TABLE (VEX_0F
) },
10432 { "ldsS", { Gv
, Mp
} },
10433 { VEX_C5_TABLE (VEX_0F
) },
10436 /* MOD_VEX_12_PREFIX_0 */
10437 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
10438 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
10442 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
10445 /* MOD_VEX_16_PREFIX_0 */
10446 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
10447 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
10451 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
10455 { VEX_W_TABLE (VEX_W_2B_M_0
) },
10460 { VEX_W_TABLE (VEX_W_50_M_0
) },
10463 /* MOD_VEX_71_REG_2 */
10465 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
10468 /* MOD_VEX_71_REG_4 */
10470 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
10473 /* MOD_VEX_71_REG_6 */
10475 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
10478 /* MOD_VEX_72_REG_2 */
10480 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
10483 /* MOD_VEX_72_REG_4 */
10485 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
10488 /* MOD_VEX_72_REG_6 */
10490 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
10493 /* MOD_VEX_73_REG_2 */
10495 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
10498 /* MOD_VEX_73_REG_3 */
10500 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
10503 /* MOD_VEX_73_REG_6 */
10505 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
10508 /* MOD_VEX_73_REG_7 */
10510 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
10513 /* MOD_VEX_AE_REG_2 */
10514 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
10517 /* MOD_VEX_AE_REG_3 */
10518 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
10521 /* MOD_VEX_D7_PREFIX_2 */
10523 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
10526 /* MOD_VEX_E7_PREFIX_2 */
10527 { VEX_W_TABLE (VEX_W_E7_P_2_M_0
) },
10530 /* MOD_VEX_F0_PREFIX_3 */
10531 { VEX_W_TABLE (VEX_W_F0_P_3_M_0
) },
10534 /* MOD_VEX_3818_PREFIX_2 */
10535 { VEX_W_TABLE (VEX_W_3818_P_2_M_0
) },
10538 /* MOD_VEX_3819_PREFIX_2 */
10539 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
10542 /* MOD_VEX_381A_PREFIX_2 */
10543 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
10546 /* MOD_VEX_382A_PREFIX_2 */
10547 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
10550 /* MOD_VEX_382C_PREFIX_2 */
10551 { VEX_W_TABLE (VEX_W_382C_P_2_M_0
) },
10554 /* MOD_VEX_382D_PREFIX_2 */
10555 { VEX_W_TABLE (VEX_W_382D_P_2_M_0
) },
10558 /* MOD_VEX_382E_PREFIX_2 */
10559 { VEX_W_TABLE (VEX_W_382E_P_2_M_0
) },
10562 /* MOD_VEX_382F_PREFIX_2 */
10563 { VEX_W_TABLE (VEX_W_382F_P_2_M_0
) },
10567 static const struct dis386 rm_table
[][8] = {
10569 /* RM_0F01_REG_0 */
10571 { "vmcall", { Skip_MODRM
} },
10572 { "vmlaunch", { Skip_MODRM
} },
10573 { "vmresume", { Skip_MODRM
} },
10574 { "vmxoff", { Skip_MODRM
} },
10577 /* RM_0F01_REG_1 */
10578 { "monitor", { { OP_Monitor
, 0 } } },
10579 { "mwait", { { OP_Mwait
, 0 } } },
10582 /* RM_0F01_REG_2 */
10583 { "xgetbv", { Skip_MODRM
} },
10584 { "xsetbv", { Skip_MODRM
} },
10587 /* RM_0F01_REG_3 */
10588 { "vmrun", { Skip_MODRM
} },
10589 { "vmmcall", { Skip_MODRM
} },
10590 { "vmload", { Skip_MODRM
} },
10591 { "vmsave", { Skip_MODRM
} },
10592 { "stgi", { Skip_MODRM
} },
10593 { "clgi", { Skip_MODRM
} },
10594 { "skinit", { Skip_MODRM
} },
10595 { "invlpga", { Skip_MODRM
} },
10598 /* RM_0F01_REG_7 */
10599 { "swapgs", { Skip_MODRM
} },
10600 { "rdtscp", { Skip_MODRM
} },
10603 /* RM_0FAE_REG_5 */
10604 { "lfence", { Skip_MODRM
} },
10607 /* RM_0FAE_REG_6 */
10608 { "mfence", { Skip_MODRM
} },
10611 /* RM_0FAE_REG_7 */
10612 { "sfence", { Skip_MODRM
} },
10616 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
10618 /* We use the high bit to indicate different name for the same
10620 #define ADDR16_PREFIX (0x67 | 0x100)
10621 #define ADDR32_PREFIX (0x67 | 0x200)
10622 #define DATA16_PREFIX (0x66 | 0x100)
10623 #define DATA32_PREFIX (0x66 | 0x200)
10624 #define REP_PREFIX (0xf3 | 0x100)
10629 int newrex
, i
, length
;
10635 last_lock_prefix
= -1;
10636 last_repz_prefix
= -1;
10637 last_repnz_prefix
= -1;
10638 last_data_prefix
= -1;
10639 last_addr_prefix
= -1;
10640 last_rex_prefix
= -1;
10641 last_seg_prefix
= -1;
10642 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10643 all_prefixes
[i
] = 0;
10646 /* The maximum instruction length is 15bytes. */
10647 while (length
< MAX_CODE_LENGTH
- 1)
10649 FETCH_DATA (the_info
, codep
+ 1);
10653 /* REX prefixes family. */
10670 if (address_mode
== mode_64bit
)
10674 last_rex_prefix
= i
;
10677 prefixes
|= PREFIX_REPZ
;
10678 last_repz_prefix
= i
;
10681 prefixes
|= PREFIX_REPNZ
;
10682 last_repnz_prefix
= i
;
10685 prefixes
|= PREFIX_LOCK
;
10686 last_lock_prefix
= i
;
10689 prefixes
|= PREFIX_CS
;
10690 last_seg_prefix
= i
;
10693 prefixes
|= PREFIX_SS
;
10694 last_seg_prefix
= i
;
10697 prefixes
|= PREFIX_DS
;
10698 last_seg_prefix
= i
;
10701 prefixes
|= PREFIX_ES
;
10702 last_seg_prefix
= i
;
10705 prefixes
|= PREFIX_FS
;
10706 last_seg_prefix
= i
;
10709 prefixes
|= PREFIX_GS
;
10710 last_seg_prefix
= i
;
10713 prefixes
|= PREFIX_DATA
;
10714 last_data_prefix
= i
;
10717 prefixes
|= PREFIX_ADDR
;
10718 last_addr_prefix
= i
;
10721 /* fwait is really an instruction. If there are prefixes
10722 before the fwait, they belong to the fwait, *not* to the
10723 following instruction. */
10724 if (prefixes
|| rex
)
10726 prefixes
|= PREFIX_FWAIT
;
10730 prefixes
= PREFIX_FWAIT
;
10735 /* Rex is ignored when followed by another prefix. */
10741 if (*codep
!= FWAIT_OPCODE
)
10742 all_prefixes
[i
++] = *codep
;
10751 seg_prefix (int pref
)
10772 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10775 static const char *
10776 prefix_name (int pref
, int sizeflag
)
10778 static const char *rexes
[16] =
10781 "rex.B", /* 0x41 */
10782 "rex.X", /* 0x42 */
10783 "rex.XB", /* 0x43 */
10784 "rex.R", /* 0x44 */
10785 "rex.RB", /* 0x45 */
10786 "rex.RX", /* 0x46 */
10787 "rex.RXB", /* 0x47 */
10788 "rex.W", /* 0x48 */
10789 "rex.WB", /* 0x49 */
10790 "rex.WX", /* 0x4a */
10791 "rex.WXB", /* 0x4b */
10792 "rex.WR", /* 0x4c */
10793 "rex.WRB", /* 0x4d */
10794 "rex.WRX", /* 0x4e */
10795 "rex.WRXB", /* 0x4f */
10800 /* REX prefixes family. */
10817 return rexes
[pref
- 0x40];
10837 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10839 if (address_mode
== mode_64bit
)
10840 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10842 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10845 case ADDR16_PREFIX
:
10847 case ADDR32_PREFIX
:
10849 case DATA16_PREFIX
:
10851 case DATA32_PREFIX
:
10860 static char op_out
[MAX_OPERANDS
][100];
10861 static int op_ad
, op_index
[MAX_OPERANDS
];
10862 static int two_source_ops
;
10863 static bfd_vma op_address
[MAX_OPERANDS
];
10864 static bfd_vma op_riprel
[MAX_OPERANDS
];
10865 static bfd_vma start_pc
;
10868 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10869 * (see topic "Redundant prefixes" in the "Differences from 8086"
10870 * section of the "Virtual 8086 Mode" chapter.)
10871 * 'pc' should be the address of this instruction, it will
10872 * be used to print the target address if this is a relative jump or call
10873 * The function returns the length of this instruction in bytes.
10876 static char intel_syntax
;
10877 static char intel_mnemonic
= !SYSV386_COMPAT
;
10878 static char open_char
;
10879 static char close_char
;
10880 static char separator_char
;
10881 static char scale_char
;
10883 /* Here for backwards compatibility. When gdb stops using
10884 print_insn_i386_att and print_insn_i386_intel these functions can
10885 disappear, and print_insn_i386 be merged into print_insn. */
10887 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10891 return print_insn (pc
, info
);
10895 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10899 return print_insn (pc
, info
);
10903 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10907 return print_insn (pc
, info
);
10911 print_i386_disassembler_options (FILE *stream
)
10913 fprintf (stream
, _("\n\
10914 The following i386/x86-64 specific disassembler options are supported for use\n\
10915 with the -M switch (multiple options should be separated by commas):\n"));
10917 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10918 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10919 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10920 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10921 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10922 fprintf (stream
, _(" att-mnemonic\n"
10923 " Display instruction in AT&T mnemonic\n"));
10924 fprintf (stream
, _(" intel-mnemonic\n"
10925 " Display instruction in Intel mnemonic\n"));
10926 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10927 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10928 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10929 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10930 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10931 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10935 static const struct dis386 bad_opcode
= { "(bad)", { XX
} };
10937 /* Get a pointer to struct dis386 with a valid name. */
10939 static const struct dis386
*
10940 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10942 int vindex
, vex_table_index
;
10944 if (dp
->name
!= NULL
)
10947 switch (dp
->op
[0].bytemode
)
10949 case USE_REG_TABLE
:
10950 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10953 case USE_MOD_TABLE
:
10954 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
10955 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
10959 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10962 case USE_PREFIX_TABLE
:
10965 /* The prefix in VEX is implicit. */
10966 switch (vex
.prefix
)
10971 case REPE_PREFIX_OPCODE
:
10974 case DATA_PREFIX_OPCODE
:
10977 case REPNE_PREFIX_OPCODE
:
10988 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10989 if (prefixes
& PREFIX_REPZ
)
10992 all_prefixes
[last_repz_prefix
] = 0;
10996 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10998 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10999 if (prefixes
& PREFIX_REPNZ
)
11002 all_prefixes
[last_repnz_prefix
] = 0;
11006 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11007 if (prefixes
& PREFIX_DATA
)
11010 all_prefixes
[last_data_prefix
] = 0;
11015 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
11018 case USE_X86_64_TABLE
:
11019 vindex
= address_mode
== mode_64bit
? 1 : 0;
11020 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
11023 case USE_3BYTE_TABLE
:
11024 FETCH_DATA (info
, codep
+ 2);
11026 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
11027 modrm
.mod
= (*codep
>> 6) & 3;
11028 modrm
.reg
= (*codep
>> 3) & 7;
11029 modrm
.rm
= *codep
& 7;
11032 case USE_VEX_LEN_TABLE
:
11036 switch (vex
.length
)
11049 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
11052 case USE_XOP_8F_TABLE
:
11053 FETCH_DATA (info
, codep
+ 3);
11054 /* All bits in the REX prefix are ignored. */
11056 rex
= ~(*codep
>> 5) & 0x7;
11058 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11059 switch ((*codep
& 0x1f))
11064 vex_table_index
= XOP_08
;
11067 vex_table_index
= XOP_09
;
11070 vex_table_index
= XOP_0A
;
11074 vex
.w
= *codep
& 0x80;
11075 if (vex
.w
&& address_mode
== mode_64bit
)
11078 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11079 if (address_mode
!= mode_64bit
11080 && vex
.register_specifier
> 0x7)
11083 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11084 switch ((*codep
& 0x3))
11090 vex
.prefix
= DATA_PREFIX_OPCODE
;
11093 vex
.prefix
= REPE_PREFIX_OPCODE
;
11096 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11103 dp
= &xop_table
[vex_table_index
][vindex
];
11105 FETCH_DATA (info
, codep
+ 1);
11106 modrm
.mod
= (*codep
>> 6) & 3;
11107 modrm
.reg
= (*codep
>> 3) & 7;
11108 modrm
.rm
= *codep
& 7;
11111 case USE_VEX_C4_TABLE
:
11112 FETCH_DATA (info
, codep
+ 3);
11113 /* All bits in the REX prefix are ignored. */
11115 rex
= ~(*codep
>> 5) & 0x7;
11116 switch ((*codep
& 0x1f))
11121 vex_table_index
= VEX_0F
;
11124 vex_table_index
= VEX_0F38
;
11127 vex_table_index
= VEX_0F3A
;
11131 vex
.w
= *codep
& 0x80;
11132 if (vex
.w
&& address_mode
== mode_64bit
)
11135 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11136 if (address_mode
!= mode_64bit
11137 && vex
.register_specifier
> 0x7)
11140 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11141 switch ((*codep
& 0x3))
11147 vex
.prefix
= DATA_PREFIX_OPCODE
;
11150 vex
.prefix
= REPE_PREFIX_OPCODE
;
11153 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11160 dp
= &vex_table
[vex_table_index
][vindex
];
11161 /* There is no MODRM byte for VEX [82|77]. */
11162 if (vindex
!= 0x77 && vindex
!= 0x82)
11164 FETCH_DATA (info
, codep
+ 1);
11165 modrm
.mod
= (*codep
>> 6) & 3;
11166 modrm
.reg
= (*codep
>> 3) & 7;
11167 modrm
.rm
= *codep
& 7;
11171 case USE_VEX_C5_TABLE
:
11172 FETCH_DATA (info
, codep
+ 2);
11173 /* All bits in the REX prefix are ignored. */
11175 rex
= (*codep
& 0x80) ? 0 : REX_R
;
11177 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11178 if (address_mode
!= mode_64bit
11179 && vex
.register_specifier
> 0x7)
11184 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11185 switch ((*codep
& 0x3))
11191 vex
.prefix
= DATA_PREFIX_OPCODE
;
11194 vex
.prefix
= REPE_PREFIX_OPCODE
;
11197 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11204 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
11205 /* There is no MODRM byte for VEX [82|77]. */
11206 if (vindex
!= 0x77 && vindex
!= 0x82)
11208 FETCH_DATA (info
, codep
+ 1);
11209 modrm
.mod
= (*codep
>> 6) & 3;
11210 modrm
.reg
= (*codep
>> 3) & 7;
11211 modrm
.rm
= *codep
& 7;
11215 case USE_VEX_W_TABLE
:
11219 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
11230 if (dp
->name
!= NULL
)
11233 return get_valid_dis386 (dp
, info
);
11237 print_insn (bfd_vma pc
, disassemble_info
*info
)
11239 const struct dis386
*dp
;
11241 char *op_txt
[MAX_OPERANDS
];
11245 struct dis_private priv
;
11248 int default_prefixes
;
11250 if (info
->mach
== bfd_mach_x86_64_intel_syntax
11251 || info
->mach
== bfd_mach_x86_64
11252 || info
->mach
== bfd_mach_l1om
11253 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11254 address_mode
= mode_64bit
;
11256 address_mode
= mode_32bit
;
11258 if (intel_syntax
== (char) -1)
11259 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
11260 || info
->mach
== bfd_mach_x86_64_intel_syntax
11261 || info
->mach
== bfd_mach_l1om_intel_syntax
);
11263 if (info
->mach
== bfd_mach_i386_i386
11264 || info
->mach
== bfd_mach_x86_64
11265 || info
->mach
== bfd_mach_l1om
11266 || info
->mach
== bfd_mach_i386_i386_intel_syntax
11267 || info
->mach
== bfd_mach_x86_64_intel_syntax
11268 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11269 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11270 else if (info
->mach
== bfd_mach_i386_i8086
)
11271 priv
.orig_sizeflag
= 0;
11275 for (p
= info
->disassembler_options
; p
!= NULL
; )
11277 if (CONST_STRNEQ (p
, "x86-64"))
11279 address_mode
= mode_64bit
;
11280 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11282 else if (CONST_STRNEQ (p
, "i386"))
11284 address_mode
= mode_32bit
;
11285 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
11287 else if (CONST_STRNEQ (p
, "i8086"))
11289 address_mode
= mode_16bit
;
11290 priv
.orig_sizeflag
= 0;
11292 else if (CONST_STRNEQ (p
, "intel"))
11295 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
11296 intel_mnemonic
= 1;
11298 else if (CONST_STRNEQ (p
, "att"))
11301 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
11302 intel_mnemonic
= 0;
11304 else if (CONST_STRNEQ (p
, "addr"))
11306 if (address_mode
== mode_64bit
)
11308 if (p
[4] == '3' && p
[5] == '2')
11309 priv
.orig_sizeflag
&= ~AFLAG
;
11310 else if (p
[4] == '6' && p
[5] == '4')
11311 priv
.orig_sizeflag
|= AFLAG
;
11315 if (p
[4] == '1' && p
[5] == '6')
11316 priv
.orig_sizeflag
&= ~AFLAG
;
11317 else if (p
[4] == '3' && p
[5] == '2')
11318 priv
.orig_sizeflag
|= AFLAG
;
11321 else if (CONST_STRNEQ (p
, "data"))
11323 if (p
[4] == '1' && p
[5] == '6')
11324 priv
.orig_sizeflag
&= ~DFLAG
;
11325 else if (p
[4] == '3' && p
[5] == '2')
11326 priv
.orig_sizeflag
|= DFLAG
;
11328 else if (CONST_STRNEQ (p
, "suffix"))
11329 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
11331 p
= strchr (p
, ',');
11338 names64
= intel_names64
;
11339 names32
= intel_names32
;
11340 names16
= intel_names16
;
11341 names8
= intel_names8
;
11342 names8rex
= intel_names8rex
;
11343 names_seg
= intel_names_seg
;
11344 names_mm
= intel_names_mm
;
11345 names_xmm
= intel_names_xmm
;
11346 names_ymm
= intel_names_ymm
;
11347 index64
= intel_index64
;
11348 index32
= intel_index32
;
11349 index16
= intel_index16
;
11352 separator_char
= '+';
11357 names64
= att_names64
;
11358 names32
= att_names32
;
11359 names16
= att_names16
;
11360 names8
= att_names8
;
11361 names8rex
= att_names8rex
;
11362 names_seg
= att_names_seg
;
11363 names_mm
= att_names_mm
;
11364 names_xmm
= att_names_xmm
;
11365 names_ymm
= att_names_ymm
;
11366 index64
= att_index64
;
11367 index32
= att_index32
;
11368 index16
= att_index16
;
11371 separator_char
= ',';
11375 /* The output looks better if we put 7 bytes on a line, since that
11376 puts most long word instructions on a single line. Use 8 bytes
11378 if (info
->mach
== bfd_mach_l1om
11379 || info
->mach
== bfd_mach_l1om_intel_syntax
)
11380 info
->bytes_per_line
= 8;
11382 info
->bytes_per_line
= 7;
11384 info
->private_data
= &priv
;
11385 priv
.max_fetched
= priv
.the_buffer
;
11386 priv
.insn_start
= pc
;
11389 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11397 start_codep
= priv
.the_buffer
;
11398 codep
= priv
.the_buffer
;
11400 if (setjmp (priv
.bailout
) != 0)
11404 /* Getting here means we tried for data but didn't get it. That
11405 means we have an incomplete instruction of some sort. Just
11406 print the first byte as a prefix or a .byte pseudo-op. */
11407 if (codep
> priv
.the_buffer
)
11409 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
11411 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11414 /* Just print the first byte as a .byte instruction. */
11415 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
11416 (unsigned int) priv
.the_buffer
[0]);
11426 sizeflag
= priv
.orig_sizeflag
;
11428 if (!ckprefix () || rex_used
)
11430 /* Too many prefixes or unused REX prefixes. */
11432 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
11434 (*info
->fprintf_func
) (info
->stream
, "%s",
11435 prefix_name (all_prefixes
[i
], sizeflag
));
11439 insn_codep
= codep
;
11441 FETCH_DATA (info
, codep
+ 1);
11442 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
11444 if (((prefixes
& PREFIX_FWAIT
)
11445 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
11447 (*info
->fprintf_func
) (info
->stream
, "fwait");
11453 if (*codep
== 0x0f)
11455 unsigned char threebyte
;
11456 FETCH_DATA (info
, codep
+ 2);
11457 threebyte
= *++codep
;
11458 dp
= &dis386_twobyte
[threebyte
];
11459 need_modrm
= twobyte_has_modrm
[*codep
];
11464 dp
= &dis386
[*codep
];
11465 need_modrm
= onebyte_has_modrm
[*codep
];
11469 if ((prefixes
& PREFIX_REPZ
))
11470 used_prefixes
|= PREFIX_REPZ
;
11471 if ((prefixes
& PREFIX_REPNZ
))
11472 used_prefixes
|= PREFIX_REPNZ
;
11473 if ((prefixes
& PREFIX_LOCK
))
11474 used_prefixes
|= PREFIX_LOCK
;
11476 default_prefixes
= 0;
11477 if (prefixes
& PREFIX_ADDR
)
11480 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
11482 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
11483 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
11485 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
11486 default_prefixes
|= PREFIX_ADDR
;
11490 if ((prefixes
& PREFIX_DATA
))
11493 if (dp
->op
[2].bytemode
== cond_jump_mode
11494 && dp
->op
[0].bytemode
== v_mode
11497 if (sizeflag
& DFLAG
)
11498 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
11500 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
11501 default_prefixes
|= PREFIX_DATA
;
11503 else if (rex
& REX_W
)
11505 /* REX_W will override PREFIX_DATA. */
11506 default_prefixes
|= PREFIX_DATA
;
11512 FETCH_DATA (info
, codep
+ 1);
11513 modrm
.mod
= (*codep
>> 6) & 3;
11514 modrm
.reg
= (*codep
>> 3) & 7;
11515 modrm
.rm
= *codep
& 7;
11522 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
11524 dofloat (sizeflag
);
11528 dp
= get_valid_dis386 (dp
, info
);
11529 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
11531 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11534 op_ad
= MAX_OPERANDS
- 1 - i
;
11536 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
11541 /* See if any prefixes were not used. If so, print the first one
11542 separately. If we don't do this, we'll wind up printing an
11543 instruction stream which does not precisely correspond to the
11544 bytes we are disassembling. */
11545 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
11547 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11548 if (all_prefixes
[i
])
11551 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
11553 name
= INTERNAL_DISASSEMBLER_ERROR
;
11554 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
11559 /* Check if the REX prefix is used. */
11560 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
11561 all_prefixes
[last_rex_prefix
] = 0;
11563 /* Check if the SEG prefix is used. */
11564 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
11565 | PREFIX_FS
| PREFIX_GS
)) != 0
11567 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
11568 all_prefixes
[last_seg_prefix
] = 0;
11570 /* Check if the ADDR prefix is used. */
11571 if ((prefixes
& PREFIX_ADDR
) != 0
11572 && (used_prefixes
& PREFIX_ADDR
) != 0)
11573 all_prefixes
[last_addr_prefix
] = 0;
11575 /* Check if the DATA prefix is used. */
11576 if ((prefixes
& PREFIX_DATA
) != 0
11577 && (used_prefixes
& PREFIX_DATA
) != 0)
11578 all_prefixes
[last_data_prefix
] = 0;
11581 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11582 if (all_prefixes
[i
])
11585 name
= prefix_name (all_prefixes
[i
], sizeflag
);
11588 prefix_length
+= strlen (name
) + 1;
11589 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
11592 /* Check maximum code length. */
11593 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
11595 (*info
->fprintf_func
) (info
->stream
, "(bad)");
11596 return MAX_CODE_LENGTH
;
11599 obufp
= mnemonicendp
;
11600 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
11603 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
11605 /* The enter and bound instructions are printed with operands in the same
11606 order as the intel book; everything else is printed in reverse order. */
11607 if (intel_syntax
|| two_source_ops
)
11611 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11612 op_txt
[i
] = op_out
[i
];
11614 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
11616 op_ad
= op_index
[i
];
11617 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
11618 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
11619 riprel
= op_riprel
[i
];
11620 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
11621 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
11626 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11627 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
11631 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
11635 (*info
->fprintf_func
) (info
->stream
, ",");
11636 if (op_index
[i
] != -1 && !op_riprel
[i
])
11637 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
11639 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
11643 for (i
= 0; i
< MAX_OPERANDS
; i
++)
11644 if (op_index
[i
] != -1 && op_riprel
[i
])
11646 (*info
->fprintf_func
) (info
->stream
, " # ");
11647 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
11648 + op_address
[op_index
[i
]]), info
);
11651 return codep
- priv
.the_buffer
;
11654 static const char *float_mem
[] = {
11729 static const unsigned char float_mem_mode
[] = {
11804 #define ST { OP_ST, 0 }
11805 #define STi { OP_STi, 0 }
11807 #define FGRPd9_2 NULL, { { NULL, 0 } }
11808 #define FGRPd9_4 NULL, { { NULL, 1 } }
11809 #define FGRPd9_5 NULL, { { NULL, 2 } }
11810 #define FGRPd9_6 NULL, { { NULL, 3 } }
11811 #define FGRPd9_7 NULL, { { NULL, 4 } }
11812 #define FGRPda_5 NULL, { { NULL, 5 } }
11813 #define FGRPdb_4 NULL, { { NULL, 6 } }
11814 #define FGRPde_3 NULL, { { NULL, 7 } }
11815 #define FGRPdf_4 NULL, { { NULL, 8 } }
11817 static const struct dis386 float_reg
[][8] = {
11820 { "fadd", { ST
, STi
} },
11821 { "fmul", { ST
, STi
} },
11822 { "fcom", { STi
} },
11823 { "fcomp", { STi
} },
11824 { "fsub", { ST
, STi
} },
11825 { "fsubr", { ST
, STi
} },
11826 { "fdiv", { ST
, STi
} },
11827 { "fdivr", { ST
, STi
} },
11831 { "fld", { STi
} },
11832 { "fxch", { STi
} },
11842 { "fcmovb", { ST
, STi
} },
11843 { "fcmove", { ST
, STi
} },
11844 { "fcmovbe",{ ST
, STi
} },
11845 { "fcmovu", { ST
, STi
} },
11853 { "fcmovnb",{ ST
, STi
} },
11854 { "fcmovne",{ ST
, STi
} },
11855 { "fcmovnbe",{ ST
, STi
} },
11856 { "fcmovnu",{ ST
, STi
} },
11858 { "fucomi", { ST
, STi
} },
11859 { "fcomi", { ST
, STi
} },
11864 { "fadd", { STi
, ST
} },
11865 { "fmul", { STi
, ST
} },
11868 { "fsub!M", { STi
, ST
} },
11869 { "fsubM", { STi
, ST
} },
11870 { "fdiv!M", { STi
, ST
} },
11871 { "fdivM", { STi
, ST
} },
11875 { "ffree", { STi
} },
11877 { "fst", { STi
} },
11878 { "fstp", { STi
} },
11879 { "fucom", { STi
} },
11880 { "fucomp", { STi
} },
11886 { "faddp", { STi
, ST
} },
11887 { "fmulp", { STi
, ST
} },
11890 { "fsub!Mp", { STi
, ST
} },
11891 { "fsubMp", { STi
, ST
} },
11892 { "fdiv!Mp", { STi
, ST
} },
11893 { "fdivMp", { STi
, ST
} },
11897 { "ffreep", { STi
} },
11902 { "fucomip", { ST
, STi
} },
11903 { "fcomip", { ST
, STi
} },
11908 static char *fgrps
[][8] = {
11911 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11916 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11921 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11926 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11931 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11936 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11941 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11942 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11947 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11952 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11957 swap_operand (void)
11959 mnemonicendp
[0] = '.';
11960 mnemonicendp
[1] = 's';
11965 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11966 int sizeflag ATTRIBUTE_UNUSED
)
11968 /* Skip mod/rm byte. */
11974 dofloat (int sizeflag
)
11976 const struct dis386
*dp
;
11977 unsigned char floatop
;
11979 floatop
= codep
[-1];
11981 if (modrm
.mod
!= 3)
11983 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11985 putop (float_mem
[fp_indx
], sizeflag
);
11988 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11991 /* Skip mod/rm byte. */
11995 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11996 if (dp
->name
== NULL
)
11998 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
12000 /* Instruction fnstsw is only one with strange arg. */
12001 if (floatop
== 0xdf && codep
[-1] == 0xe0)
12002 strcpy (op_out
[0], names16
[0]);
12006 putop (dp
->name
, sizeflag
);
12011 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
12016 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
12021 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12023 oappend ("%st" + intel_syntax
);
12027 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12029 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
12030 oappend (scratchbuf
+ intel_syntax
);
12033 /* Capital letters in template are macros. */
12035 putop (const char *in_template
, int sizeflag
)
12040 unsigned int l
= 0, len
= 1;
12043 #define SAVE_LAST(c) \
12044 if (l < len && l < sizeof (last)) \
12049 for (p
= in_template
; *p
; p
++)
12066 while (*++p
!= '|')
12067 if (*p
== '}' || *p
== '\0')
12070 /* Fall through. */
12075 while (*++p
!= '}')
12086 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12090 if (l
== 0 && len
== 1)
12095 if (sizeflag
& SUFFIX_ALWAYS
)
12108 if (address_mode
== mode_64bit
12109 && !(prefixes
& PREFIX_ADDR
))
12120 if (intel_syntax
&& !alt
)
12122 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
12124 if (sizeflag
& DFLAG
)
12125 *obufp
++ = intel_syntax
? 'd' : 'l';
12127 *obufp
++ = intel_syntax
? 'w' : 's';
12128 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12132 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12135 if (modrm
.mod
== 3)
12141 if (sizeflag
& DFLAG
)
12142 *obufp
++ = intel_syntax
? 'd' : 'l';
12145 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12151 case 'E': /* For jcxz/jecxz */
12152 if (address_mode
== mode_64bit
)
12154 if (sizeflag
& AFLAG
)
12160 if (sizeflag
& AFLAG
)
12162 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12167 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
12169 if (sizeflag
& AFLAG
)
12170 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
12172 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
12173 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12177 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
12179 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12183 if (!(rex
& REX_W
))
12184 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12189 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
12190 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
12192 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
12195 if (prefixes
& PREFIX_DS
)
12216 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
12221 /* Fall through. */
12224 if (l
!= 0 || len
!= 1)
12232 if (sizeflag
& SUFFIX_ALWAYS
)
12236 if (intel_mnemonic
!= cond
)
12240 if ((prefixes
& PREFIX_FWAIT
) == 0)
12243 used_prefixes
|= PREFIX_FWAIT
;
12249 else if (intel_syntax
&& (sizeflag
& DFLAG
))
12253 if (!(rex
& REX_W
))
12254 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12259 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12264 /* Fall through. */
12268 if ((prefixes
& PREFIX_DATA
)
12270 || (sizeflag
& SUFFIX_ALWAYS
))
12277 if (sizeflag
& DFLAG
)
12281 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12288 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12290 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12294 /* Fall through. */
12297 if (l
== 0 && len
== 1)
12300 if (intel_syntax
&& !alt
)
12303 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12309 if (sizeflag
& DFLAG
)
12310 *obufp
++ = intel_syntax
? 'd' : 'l';
12313 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12319 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
12325 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12340 else if (sizeflag
& DFLAG
)
12349 if (intel_syntax
&& !p
[1]
12350 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
12352 if (!(rex
& REX_W
))
12353 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12356 if (l
== 0 && len
== 1)
12360 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12362 if (sizeflag
& SUFFIX_ALWAYS
)
12384 /* Fall through. */
12387 if (l
== 0 && len
== 1)
12392 if (sizeflag
& SUFFIX_ALWAYS
)
12398 if (sizeflag
& DFLAG
)
12402 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12416 if (address_mode
== mode_64bit
12417 && !(prefixes
& PREFIX_ADDR
))
12428 if (l
!= 0 || len
!= 1)
12433 if (need_vex
&& vex
.prefix
)
12435 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
12442 if (prefixes
& PREFIX_DATA
)
12446 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12450 if (l
== 0 && len
== 1)
12452 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12463 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12471 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
12473 switch (vex
.length
)
12487 if (l
== 0 && len
== 1)
12489 /* operand size flag for cwtl, cbtw */
12498 else if (sizeflag
& DFLAG
)
12502 if (!(rex
& REX_W
))
12503 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12507 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
12514 *obufp
++ = vex
.w
? 'd': 's';
12521 mnemonicendp
= obufp
;
12526 oappend (const char *s
)
12528 obufp
= stpcpy (obufp
, s
);
12534 if (prefixes
& PREFIX_CS
)
12536 used_prefixes
|= PREFIX_CS
;
12537 oappend ("%cs:" + intel_syntax
);
12539 if (prefixes
& PREFIX_DS
)
12541 used_prefixes
|= PREFIX_DS
;
12542 oappend ("%ds:" + intel_syntax
);
12544 if (prefixes
& PREFIX_SS
)
12546 used_prefixes
|= PREFIX_SS
;
12547 oappend ("%ss:" + intel_syntax
);
12549 if (prefixes
& PREFIX_ES
)
12551 used_prefixes
|= PREFIX_ES
;
12552 oappend ("%es:" + intel_syntax
);
12554 if (prefixes
& PREFIX_FS
)
12556 used_prefixes
|= PREFIX_FS
;
12557 oappend ("%fs:" + intel_syntax
);
12559 if (prefixes
& PREFIX_GS
)
12561 used_prefixes
|= PREFIX_GS
;
12562 oappend ("%gs:" + intel_syntax
);
12567 OP_indirE (int bytemode
, int sizeflag
)
12571 OP_E (bytemode
, sizeflag
);
12575 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
12577 if (address_mode
== mode_64bit
)
12585 sprintf_vma (tmp
, disp
);
12586 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
12587 strcpy (buf
+ 2, tmp
+ i
);
12591 bfd_signed_vma v
= disp
;
12598 /* Check for possible overflow on 0x8000000000000000. */
12601 strcpy (buf
, "9223372036854775808");
12615 tmp
[28 - i
] = (v
% 10) + '0';
12619 strcpy (buf
, tmp
+ 29 - i
);
12625 sprintf (buf
, "0x%x", (unsigned int) disp
);
12627 sprintf (buf
, "%d", (int) disp
);
12631 /* Put DISP in BUF as signed hex number. */
12634 print_displacement (char *buf
, bfd_vma disp
)
12636 bfd_signed_vma val
= disp
;
12645 /* Check for possible overflow. */
12648 switch (address_mode
)
12651 strcpy (buf
+ j
, "0x8000000000000000");
12654 strcpy (buf
+ j
, "0x80000000");
12657 strcpy (buf
+ j
, "0x8000");
12667 sprintf_vma (tmp
, (bfd_vma
) val
);
12668 for (i
= 0; tmp
[i
] == '0'; i
++)
12670 if (tmp
[i
] == '\0')
12672 strcpy (buf
+ j
, tmp
+ i
);
12676 intel_operand_size (int bytemode
, int sizeflag
)
12683 oappend ("BYTE PTR ");
12687 oappend ("WORD PTR ");
12690 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12692 oappend ("QWORD PTR ");
12701 oappend ("QWORD PTR ");
12704 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
12705 oappend ("DWORD PTR ");
12707 oappend ("WORD PTR ");
12708 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12712 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12714 oappend ("WORD PTR ");
12715 if (!(rex
& REX_W
))
12716 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12719 if (sizeflag
& DFLAG
)
12720 oappend ("QWORD PTR ");
12722 oappend ("DWORD PTR ");
12723 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12726 case d_scalar_mode
:
12727 case d_scalar_swap_mode
:
12730 oappend ("DWORD PTR ");
12733 case q_scalar_mode
:
12734 case q_scalar_swap_mode
:
12736 oappend ("QWORD PTR ");
12739 if (address_mode
== mode_64bit
)
12740 oappend ("QWORD PTR ");
12742 oappend ("DWORD PTR ");
12745 if (sizeflag
& DFLAG
)
12746 oappend ("FWORD PTR ");
12748 oappend ("DWORD PTR ");
12749 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12752 oappend ("TBYTE PTR ");
12758 switch (vex
.length
)
12761 oappend ("XMMWORD PTR ");
12764 oappend ("YMMWORD PTR ");
12771 oappend ("XMMWORD PTR ");
12774 oappend ("XMMWORD PTR ");
12780 switch (vex
.length
)
12783 oappend ("QWORD PTR ");
12786 oappend ("XMMWORD PTR ");
12796 switch (vex
.length
)
12799 oappend ("QWORD PTR ");
12802 oappend ("YMMWORD PTR ");
12809 oappend ("OWORD PTR ");
12811 case vex_w_dq_mode
:
12812 case vex_scalar_w_dq_mode
:
12817 oappend ("QWORD PTR ");
12819 oappend ("DWORD PTR ");
12827 OP_E_register (int bytemode
, int sizeflag
)
12829 int reg
= modrm
.rm
;
12830 const char **names
;
12836 if ((sizeflag
& SUFFIX_ALWAYS
)
12837 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12860 names
= address_mode
== mode_64bit
? names64
: names32
;
12863 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12881 if ((sizeflag
& DFLAG
)
12882 || (bytemode
!= v_mode
12883 && bytemode
!= v_swap_mode
))
12887 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12893 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12896 oappend (names
[reg
]);
12900 OP_E_memory (int bytemode
, int sizeflag
)
12903 int add
= (rex
& REX_B
) ? 8 : 0;
12908 intel_operand_size (bytemode
, sizeflag
);
12911 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12913 /* 32/64 bit address mode */
12931 FETCH_DATA (the_info
, codep
+ 1);
12932 vindex
= (*codep
>> 3) & 7;
12933 scale
= (*codep
>> 6) & 3;
12938 haveindex
= vindex
!= 4;
12941 rbase
= base
+ add
;
12949 if (address_mode
== mode_64bit
&& !havesib
)
12955 FETCH_DATA (the_info
, codep
+ 1);
12957 if ((disp
& 0x80) != 0)
12965 /* In 32bit mode, we need index register to tell [offset] from
12966 [eiz*1 + offset]. */
12967 needindex
= (havesib
12970 && address_mode
== mode_32bit
);
12971 havedisp
= (havebase
12973 || (havesib
&& (haveindex
|| scale
!= 0)));
12976 if (modrm
.mod
!= 0 || base
== 5)
12978 if (havedisp
|| riprel
)
12979 print_displacement (scratchbuf
, disp
);
12981 print_operand_value (scratchbuf
, 1, disp
);
12982 oappend (scratchbuf
);
12986 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12990 if (havebase
|| haveindex
|| riprel
)
12991 used_prefixes
|= PREFIX_ADDR
;
12993 if (havedisp
|| (intel_syntax
&& riprel
))
12995 *obufp
++ = open_char
;
12996 if (intel_syntax
&& riprel
)
12999 oappend (sizeflag
& AFLAG
? "rip" : "eip");
13003 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
13004 ? names64
[rbase
] : names32
[rbase
]);
13007 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13008 print index to tell base + index from base. */
13012 || (havebase
&& base
!= ESP_REG_NUM
))
13014 if (!intel_syntax
|| havebase
)
13016 *obufp
++ = separator_char
;
13020 oappend (address_mode
== mode_64bit
13021 && (sizeflag
& AFLAG
)
13022 ? names64
[vindex
] : names32
[vindex
]);
13024 oappend (address_mode
== mode_64bit
13025 && (sizeflag
& AFLAG
)
13026 ? index64
: index32
);
13028 *obufp
++ = scale_char
;
13030 sprintf (scratchbuf
, "%d", 1 << scale
);
13031 oappend (scratchbuf
);
13035 && (disp
|| modrm
.mod
!= 0 || base
== 5))
13037 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
13042 else if (modrm
.mod
!= 1 && disp
!= -disp
)
13046 disp
= - (bfd_signed_vma
) disp
;
13050 print_displacement (scratchbuf
, disp
);
13052 print_operand_value (scratchbuf
, 1, disp
);
13053 oappend (scratchbuf
);
13056 *obufp
++ = close_char
;
13059 else if (intel_syntax
)
13061 if (modrm
.mod
!= 0 || base
== 5)
13063 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13064 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13068 oappend (names_seg
[ds_reg
- es_reg
]);
13071 print_operand_value (scratchbuf
, 1, disp
);
13072 oappend (scratchbuf
);
13078 /* 16 bit address mode */
13079 used_prefixes
|= prefixes
& PREFIX_ADDR
;
13086 if ((disp
& 0x8000) != 0)
13091 FETCH_DATA (the_info
, codep
+ 1);
13093 if ((disp
& 0x80) != 0)
13098 if ((disp
& 0x8000) != 0)
13104 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
13106 print_displacement (scratchbuf
, disp
);
13107 oappend (scratchbuf
);
13110 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
13112 *obufp
++ = open_char
;
13114 oappend (index16
[modrm
.rm
]);
13116 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
13118 if ((bfd_signed_vma
) disp
>= 0)
13123 else if (modrm
.mod
!= 1)
13127 disp
= - (bfd_signed_vma
) disp
;
13130 print_displacement (scratchbuf
, disp
);
13131 oappend (scratchbuf
);
13134 *obufp
++ = close_char
;
13137 else if (intel_syntax
)
13139 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13140 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13144 oappend (names_seg
[ds_reg
- es_reg
]);
13147 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
13148 oappend (scratchbuf
);
13154 OP_E (int bytemode
, int sizeflag
)
13156 /* Skip mod/rm byte. */
13160 if (modrm
.mod
== 3)
13161 OP_E_register (bytemode
, sizeflag
);
13163 OP_E_memory (bytemode
, sizeflag
);
13167 OP_G (int bytemode
, int sizeflag
)
13178 oappend (names8rex
[modrm
.reg
+ add
]);
13180 oappend (names8
[modrm
.reg
+ add
]);
13183 oappend (names16
[modrm
.reg
+ add
]);
13186 oappend (names32
[modrm
.reg
+ add
]);
13189 oappend (names64
[modrm
.reg
+ add
]);
13198 oappend (names64
[modrm
.reg
+ add
]);
13201 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
13202 oappend (names32
[modrm
.reg
+ add
]);
13204 oappend (names16
[modrm
.reg
+ add
]);
13205 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13209 if (address_mode
== mode_64bit
)
13210 oappend (names64
[modrm
.reg
+ add
]);
13212 oappend (names32
[modrm
.reg
+ add
]);
13215 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13228 FETCH_DATA (the_info
, codep
+ 8);
13229 a
= *codep
++ & 0xff;
13230 a
|= (*codep
++ & 0xff) << 8;
13231 a
|= (*codep
++ & 0xff) << 16;
13232 a
|= (*codep
++ & 0xff) << 24;
13233 b
= *codep
++ & 0xff;
13234 b
|= (*codep
++ & 0xff) << 8;
13235 b
|= (*codep
++ & 0xff) << 16;
13236 b
|= (*codep
++ & 0xff) << 24;
13237 x
= a
+ ((bfd_vma
) b
<< 32);
13245 static bfd_signed_vma
13248 bfd_signed_vma x
= 0;
13250 FETCH_DATA (the_info
, codep
+ 4);
13251 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13252 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13253 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13254 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13258 static bfd_signed_vma
13261 bfd_signed_vma x
= 0;
13263 FETCH_DATA (the_info
, codep
+ 4);
13264 x
= *codep
++ & (bfd_signed_vma
) 0xff;
13265 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
13266 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
13267 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
13269 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
13279 FETCH_DATA (the_info
, codep
+ 2);
13280 x
= *codep
++ & 0xff;
13281 x
|= (*codep
++ & 0xff) << 8;
13286 set_op (bfd_vma op
, int riprel
)
13288 op_index
[op_ad
] = op_ad
;
13289 if (address_mode
== mode_64bit
)
13291 op_address
[op_ad
] = op
;
13292 op_riprel
[op_ad
] = riprel
;
13296 /* Mask to get a 32-bit address. */
13297 op_address
[op_ad
] = op
& 0xffffffff;
13298 op_riprel
[op_ad
] = riprel
& 0xffffffff;
13303 OP_REG (int code
, int sizeflag
)
13315 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13316 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13317 s
= names16
[code
- ax_reg
+ add
];
13319 case es_reg
: case ss_reg
: case cs_reg
:
13320 case ds_reg
: case fs_reg
: case gs_reg
:
13321 s
= names_seg
[code
- es_reg
+ add
];
13323 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13324 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13327 s
= names8rex
[code
- al_reg
+ add
];
13329 s
= names8
[code
- al_reg
];
13331 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
13332 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
13333 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13335 s
= names64
[code
- rAX_reg
+ add
];
13338 code
+= eAX_reg
- rAX_reg
;
13339 /* Fall through. */
13340 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13341 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13344 s
= names64
[code
- eAX_reg
+ add
];
13347 if (sizeflag
& DFLAG
)
13348 s
= names32
[code
- eAX_reg
+ add
];
13350 s
= names16
[code
- eAX_reg
+ add
];
13351 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13355 s
= INTERNAL_DISASSEMBLER_ERROR
;
13362 OP_IMREG (int code
, int sizeflag
)
13374 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
13375 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
13376 s
= names16
[code
- ax_reg
];
13378 case es_reg
: case ss_reg
: case cs_reg
:
13379 case ds_reg
: case fs_reg
: case gs_reg
:
13380 s
= names_seg
[code
- es_reg
];
13382 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
13383 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
13386 s
= names8rex
[code
- al_reg
];
13388 s
= names8
[code
- al_reg
];
13390 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
13391 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
13394 s
= names64
[code
- eAX_reg
];
13397 if (sizeflag
& DFLAG
)
13398 s
= names32
[code
- eAX_reg
];
13400 s
= names16
[code
- eAX_reg
];
13401 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13404 case z_mode_ax_reg
:
13405 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13409 if (!(rex
& REX_W
))
13410 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13413 s
= INTERNAL_DISASSEMBLER_ERROR
;
13420 OP_I (int bytemode
, int sizeflag
)
13423 bfd_signed_vma mask
= -1;
13428 FETCH_DATA (the_info
, codep
+ 1);
13433 if (address_mode
== mode_64bit
)
13438 /* Fall through. */
13445 if (sizeflag
& DFLAG
)
13455 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13467 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13472 scratchbuf
[0] = '$';
13473 print_operand_value (scratchbuf
+ 1, 1, op
);
13474 oappend (scratchbuf
+ intel_syntax
);
13475 scratchbuf
[0] = '\0';
13479 OP_I64 (int bytemode
, int sizeflag
)
13482 bfd_signed_vma mask
= -1;
13484 if (address_mode
!= mode_64bit
)
13486 OP_I (bytemode
, sizeflag
);
13493 FETCH_DATA (the_info
, codep
+ 1);
13503 if (sizeflag
& DFLAG
)
13513 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13521 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13526 scratchbuf
[0] = '$';
13527 print_operand_value (scratchbuf
+ 1, 1, op
);
13528 oappend (scratchbuf
+ intel_syntax
);
13529 scratchbuf
[0] = '\0';
13533 OP_sI (int bytemode
, int sizeflag
)
13536 bfd_signed_vma mask
= -1;
13541 FETCH_DATA (the_info
, codep
+ 1);
13543 if ((op
& 0x80) != 0)
13553 if (sizeflag
& DFLAG
)
13562 if ((op
& 0x8000) != 0)
13565 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13571 if ((op
& 0x8000) != 0)
13575 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13579 scratchbuf
[0] = '$';
13580 print_operand_value (scratchbuf
+ 1, 1, op
);
13581 oappend (scratchbuf
+ intel_syntax
);
13585 OP_J (int bytemode
, int sizeflag
)
13589 bfd_vma segment
= 0;
13594 FETCH_DATA (the_info
, codep
+ 1);
13596 if ((disp
& 0x80) != 0)
13601 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
13606 if ((disp
& 0x8000) != 0)
13608 /* In 16bit mode, address is wrapped around at 64k within
13609 the same segment. Otherwise, a data16 prefix on a jump
13610 instruction means that the pc is masked to 16 bits after
13611 the displacement is added! */
13613 if ((prefixes
& PREFIX_DATA
) == 0)
13614 segment
= ((start_pc
+ codep
- start_codep
)
13615 & ~((bfd_vma
) 0xffff));
13617 if (!(rex
& REX_W
))
13618 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13621 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13624 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
13626 print_operand_value (scratchbuf
, 1, disp
);
13627 oappend (scratchbuf
);
13631 OP_SEG (int bytemode
, int sizeflag
)
13633 if (bytemode
== w_mode
)
13634 oappend (names_seg
[modrm
.reg
]);
13636 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
13640 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
13644 if (sizeflag
& DFLAG
)
13654 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13656 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
13658 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
13659 oappend (scratchbuf
);
13663 OP_OFF (int bytemode
, int sizeflag
)
13667 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13668 intel_operand_size (bytemode
, sizeflag
);
13671 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13678 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13679 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13681 oappend (names_seg
[ds_reg
- es_reg
]);
13685 print_operand_value (scratchbuf
, 1, off
);
13686 oappend (scratchbuf
);
13690 OP_OFF64 (int bytemode
, int sizeflag
)
13694 if (address_mode
!= mode_64bit
13695 || (prefixes
& PREFIX_ADDR
))
13697 OP_OFF (bytemode
, sizeflag
);
13701 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
13702 intel_operand_size (bytemode
, sizeflag
);
13709 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13710 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
13712 oappend (names_seg
[ds_reg
- es_reg
]);
13716 print_operand_value (scratchbuf
, 1, off
);
13717 oappend (scratchbuf
);
13721 ptr_reg (int code
, int sizeflag
)
13725 *obufp
++ = open_char
;
13726 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13727 if (address_mode
== mode_64bit
)
13729 if (!(sizeflag
& AFLAG
))
13730 s
= names32
[code
- eAX_reg
];
13732 s
= names64
[code
- eAX_reg
];
13734 else if (sizeflag
& AFLAG
)
13735 s
= names32
[code
- eAX_reg
];
13737 s
= names16
[code
- eAX_reg
];
13739 *obufp
++ = close_char
;
13744 OP_ESreg (int code
, int sizeflag
)
13750 case 0x6d: /* insw/insl */
13751 intel_operand_size (z_mode
, sizeflag
);
13753 case 0xa5: /* movsw/movsl/movsq */
13754 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13755 case 0xab: /* stosw/stosl */
13756 case 0xaf: /* scasw/scasl */
13757 intel_operand_size (v_mode
, sizeflag
);
13760 intel_operand_size (b_mode
, sizeflag
);
13763 oappend ("%es:" + intel_syntax
);
13764 ptr_reg (code
, sizeflag
);
13768 OP_DSreg (int code
, int sizeflag
)
13774 case 0x6f: /* outsw/outsl */
13775 intel_operand_size (z_mode
, sizeflag
);
13777 case 0xa5: /* movsw/movsl/movsq */
13778 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13779 case 0xad: /* lodsw/lodsl/lodsq */
13780 intel_operand_size (v_mode
, sizeflag
);
13783 intel_operand_size (b_mode
, sizeflag
);
13792 | PREFIX_GS
)) == 0)
13793 prefixes
|= PREFIX_DS
;
13795 ptr_reg (code
, sizeflag
);
13799 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13807 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13809 all_prefixes
[last_lock_prefix
] = 0;
13810 used_prefixes
|= PREFIX_LOCK
;
13815 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13816 oappend (scratchbuf
+ intel_syntax
);
13820 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13829 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13831 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13832 oappend (scratchbuf
);
13836 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13838 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13839 oappend (scratchbuf
+ intel_syntax
);
13843 OP_R (int bytemode
, int sizeflag
)
13845 if (modrm
.mod
== 3)
13846 OP_E (bytemode
, sizeflag
);
13852 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13854 int reg
= modrm
.reg
;
13855 const char **names
;
13857 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13858 if (prefixes
& PREFIX_DATA
)
13867 oappend (names
[reg
]);
13871 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13873 int reg
= modrm
.reg
;
13874 const char **names
;
13880 && bytemode
!= xmm_mode
13881 && bytemode
!= scalar_mode
)
13883 switch (vex
.length
)
13897 oappend (names
[reg
]);
13901 OP_EM (int bytemode
, int sizeflag
)
13904 const char **names
;
13906 if (modrm
.mod
!= 3)
13909 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13911 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13912 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13914 OP_E (bytemode
, sizeflag
);
13918 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13921 /* Skip mod/rm byte. */
13924 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13926 if (prefixes
& PREFIX_DATA
)
13935 oappend (names
[reg
]);
13938 /* cvt* are the only instructions in sse2 which have
13939 both SSE and MMX operands and also have 0x66 prefix
13940 in their opcode. 0x66 was originally used to differentiate
13941 between SSE and MMX instruction(operands). So we have to handle the
13942 cvt* separately using OP_EMC and OP_MXC */
13944 OP_EMC (int bytemode
, int sizeflag
)
13946 if (modrm
.mod
!= 3)
13948 if (intel_syntax
&& bytemode
== v_mode
)
13950 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13951 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13953 OP_E (bytemode
, sizeflag
);
13957 /* Skip mod/rm byte. */
13960 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13961 oappend (names_mm
[modrm
.rm
]);
13965 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13967 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13968 oappend (names_mm
[modrm
.reg
]);
13972 OP_EX (int bytemode
, int sizeflag
)
13975 const char **names
;
13977 /* Skip mod/rm byte. */
13981 if (modrm
.mod
!= 3)
13983 OP_E_memory (bytemode
, sizeflag
);
13992 if ((sizeflag
& SUFFIX_ALWAYS
)
13993 && (bytemode
== x_swap_mode
13994 || bytemode
== d_swap_mode
13995 || bytemode
== d_scalar_swap_mode
13996 || bytemode
== q_swap_mode
13997 || bytemode
== q_scalar_swap_mode
))
14001 && bytemode
!= xmm_mode
14002 && bytemode
!= xmmq_mode
14003 && bytemode
!= d_scalar_mode
14004 && bytemode
!= d_scalar_swap_mode
14005 && bytemode
!= q_scalar_mode
14006 && bytemode
!= q_scalar_swap_mode
14007 && bytemode
!= vex_scalar_w_dq_mode
)
14009 switch (vex
.length
)
14023 oappend (names
[reg
]);
14027 OP_MS (int bytemode
, int sizeflag
)
14029 if (modrm
.mod
== 3)
14030 OP_EM (bytemode
, sizeflag
);
14036 OP_XS (int bytemode
, int sizeflag
)
14038 if (modrm
.mod
== 3)
14039 OP_EX (bytemode
, sizeflag
);
14045 OP_M (int bytemode
, int sizeflag
)
14047 if (modrm
.mod
== 3)
14048 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14051 OP_E (bytemode
, sizeflag
);
14055 OP_0f07 (int bytemode
, int sizeflag
)
14057 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
14060 OP_E (bytemode
, sizeflag
);
14063 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14064 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14067 NOP_Fixup1 (int bytemode
, int sizeflag
)
14069 if ((prefixes
& PREFIX_DATA
) != 0
14072 && address_mode
== mode_64bit
))
14073 OP_REG (bytemode
, sizeflag
);
14075 strcpy (obuf
, "nop");
14079 NOP_Fixup2 (int bytemode
, int sizeflag
)
14081 if ((prefixes
& PREFIX_DATA
) != 0
14084 && address_mode
== mode_64bit
))
14085 OP_IMREG (bytemode
, sizeflag
);
14088 static const char *const Suffix3DNow
[] = {
14089 /* 00 */ NULL
, NULL
, NULL
, NULL
,
14090 /* 04 */ NULL
, NULL
, NULL
, NULL
,
14091 /* 08 */ NULL
, NULL
, NULL
, NULL
,
14092 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
14093 /* 10 */ NULL
, NULL
, NULL
, NULL
,
14094 /* 14 */ NULL
, NULL
, NULL
, NULL
,
14095 /* 18 */ NULL
, NULL
, NULL
, NULL
,
14096 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
14097 /* 20 */ NULL
, NULL
, NULL
, NULL
,
14098 /* 24 */ NULL
, NULL
, NULL
, NULL
,
14099 /* 28 */ NULL
, NULL
, NULL
, NULL
,
14100 /* 2C */ NULL
, NULL
, NULL
, NULL
,
14101 /* 30 */ NULL
, NULL
, NULL
, NULL
,
14102 /* 34 */ NULL
, NULL
, NULL
, NULL
,
14103 /* 38 */ NULL
, NULL
, NULL
, NULL
,
14104 /* 3C */ NULL
, NULL
, NULL
, NULL
,
14105 /* 40 */ NULL
, NULL
, NULL
, NULL
,
14106 /* 44 */ NULL
, NULL
, NULL
, NULL
,
14107 /* 48 */ NULL
, NULL
, NULL
, NULL
,
14108 /* 4C */ NULL
, NULL
, NULL
, NULL
,
14109 /* 50 */ NULL
, NULL
, NULL
, NULL
,
14110 /* 54 */ NULL
, NULL
, NULL
, NULL
,
14111 /* 58 */ NULL
, NULL
, NULL
, NULL
,
14112 /* 5C */ NULL
, NULL
, NULL
, NULL
,
14113 /* 60 */ NULL
, NULL
, NULL
, NULL
,
14114 /* 64 */ NULL
, NULL
, NULL
, NULL
,
14115 /* 68 */ NULL
, NULL
, NULL
, NULL
,
14116 /* 6C */ NULL
, NULL
, NULL
, NULL
,
14117 /* 70 */ NULL
, NULL
, NULL
, NULL
,
14118 /* 74 */ NULL
, NULL
, NULL
, NULL
,
14119 /* 78 */ NULL
, NULL
, NULL
, NULL
,
14120 /* 7C */ NULL
, NULL
, NULL
, NULL
,
14121 /* 80 */ NULL
, NULL
, NULL
, NULL
,
14122 /* 84 */ NULL
, NULL
, NULL
, NULL
,
14123 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
14124 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
14125 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
14126 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
14127 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
14128 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
14129 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
14130 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
14131 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
14132 /* AC */ NULL
, NULL
, "pfacc", NULL
,
14133 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
14134 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
14135 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
14136 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
14137 /* C0 */ NULL
, NULL
, NULL
, NULL
,
14138 /* C4 */ NULL
, NULL
, NULL
, NULL
,
14139 /* C8 */ NULL
, NULL
, NULL
, NULL
,
14140 /* CC */ NULL
, NULL
, NULL
, NULL
,
14141 /* D0 */ NULL
, NULL
, NULL
, NULL
,
14142 /* D4 */ NULL
, NULL
, NULL
, NULL
,
14143 /* D8 */ NULL
, NULL
, NULL
, NULL
,
14144 /* DC */ NULL
, NULL
, NULL
, NULL
,
14145 /* E0 */ NULL
, NULL
, NULL
, NULL
,
14146 /* E4 */ NULL
, NULL
, NULL
, NULL
,
14147 /* E8 */ NULL
, NULL
, NULL
, NULL
,
14148 /* EC */ NULL
, NULL
, NULL
, NULL
,
14149 /* F0 */ NULL
, NULL
, NULL
, NULL
,
14150 /* F4 */ NULL
, NULL
, NULL
, NULL
,
14151 /* F8 */ NULL
, NULL
, NULL
, NULL
,
14152 /* FC */ NULL
, NULL
, NULL
, NULL
,
14156 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14158 const char *mnemonic
;
14160 FETCH_DATA (the_info
, codep
+ 1);
14161 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14162 place where an 8-bit immediate would normally go. ie. the last
14163 byte of the instruction. */
14164 obufp
= mnemonicendp
;
14165 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
14167 oappend (mnemonic
);
14170 /* Since a variable sized modrm/sib chunk is between the start
14171 of the opcode (0x0f0f) and the opcode suffix, we need to do
14172 all the modrm processing first, and don't know until now that
14173 we have a bad opcode. This necessitates some cleaning up. */
14174 op_out
[0][0] = '\0';
14175 op_out
[1][0] = '\0';
14178 mnemonicendp
= obufp
;
14181 static struct op simd_cmp_op
[] =
14183 { STRING_COMMA_LEN ("eq") },
14184 { STRING_COMMA_LEN ("lt") },
14185 { STRING_COMMA_LEN ("le") },
14186 { STRING_COMMA_LEN ("unord") },
14187 { STRING_COMMA_LEN ("neq") },
14188 { STRING_COMMA_LEN ("nlt") },
14189 { STRING_COMMA_LEN ("nle") },
14190 { STRING_COMMA_LEN ("ord") }
14194 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14196 unsigned int cmp_type
;
14198 FETCH_DATA (the_info
, codep
+ 1);
14199 cmp_type
= *codep
++ & 0xff;
14200 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
14203 char *p
= mnemonicendp
- 2;
14207 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
14208 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
14212 /* We have a reserved extension byte. Output it directly. */
14213 scratchbuf
[0] = '$';
14214 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14215 oappend (scratchbuf
+ intel_syntax
);
14216 scratchbuf
[0] = '\0';
14221 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
14222 int sizeflag ATTRIBUTE_UNUSED
)
14224 /* mwait %eax,%ecx */
14227 const char **names
= (address_mode
== mode_64bit
14228 ? names64
: names32
);
14229 strcpy (op_out
[0], names
[0]);
14230 strcpy (op_out
[1], names
[1]);
14231 two_source_ops
= 1;
14233 /* Skip mod/rm byte. */
14239 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
14240 int sizeflag ATTRIBUTE_UNUSED
)
14242 /* monitor %eax,%ecx,%edx" */
14245 const char **op1_names
;
14246 const char **names
= (address_mode
== mode_64bit
14247 ? names64
: names32
);
14249 if (!(prefixes
& PREFIX_ADDR
))
14250 op1_names
= (address_mode
== mode_16bit
14251 ? names16
: names
);
14254 /* Remove "addr16/addr32". */
14255 all_prefixes
[last_addr_prefix
] = 0;
14256 op1_names
= (address_mode
!= mode_32bit
14257 ? names32
: names16
);
14258 used_prefixes
|= PREFIX_ADDR
;
14260 strcpy (op_out
[0], op1_names
[0]);
14261 strcpy (op_out
[1], names
[1]);
14262 strcpy (op_out
[2], names
[2]);
14263 two_source_ops
= 1;
14265 /* Skip mod/rm byte. */
14273 /* Throw away prefixes and 1st. opcode byte. */
14274 codep
= insn_codep
+ 1;
14279 REP_Fixup (int bytemode
, int sizeflag
)
14281 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
14283 if (prefixes
& PREFIX_REPZ
)
14284 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
14291 OP_IMREG (bytemode
, sizeflag
);
14294 OP_ESreg (bytemode
, sizeflag
);
14297 OP_DSreg (bytemode
, sizeflag
);
14306 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
14311 /* Change cmpxchg8b to cmpxchg16b. */
14312 char *p
= mnemonicendp
- 2;
14313 mnemonicendp
= stpcpy (p
, "16b");
14316 OP_M (bytemode
, sizeflag
);
14320 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
14322 const char **names
;
14326 switch (vex
.length
)
14340 oappend (names
[reg
]);
14344 CRC32_Fixup (int bytemode
, int sizeflag
)
14346 /* Add proper suffix to "crc32". */
14347 char *p
= mnemonicendp
;
14366 if (sizeflag
& DFLAG
)
14370 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14374 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14381 if (modrm
.mod
== 3)
14385 /* Skip mod/rm byte. */
14390 add
= (rex
& REX_B
) ? 8 : 0;
14391 if (bytemode
== b_mode
)
14395 oappend (names8rex
[modrm
.rm
+ add
]);
14397 oappend (names8
[modrm
.rm
+ add
]);
14403 oappend (names64
[modrm
.rm
+ add
]);
14404 else if ((prefixes
& PREFIX_DATA
))
14405 oappend (names16
[modrm
.rm
+ add
]);
14407 oappend (names32
[modrm
.rm
+ add
]);
14411 OP_E (bytemode
, sizeflag
);
14415 FXSAVE_Fixup (int bytemode
, int sizeflag
)
14417 /* Add proper suffix to "fxsave" and "fxrstor". */
14421 char *p
= mnemonicendp
;
14427 OP_M (bytemode
, sizeflag
);
14430 /* Display the destination register operand for instructions with
14434 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14437 const char **names
;
14445 reg
= vex
.register_specifier
;
14446 if (bytemode
== vex_scalar_mode
)
14448 oappend (names_xmm
[reg
]);
14452 switch (vex
.length
)
14484 oappend (names
[reg
]);
14487 /* Get the VEX immediate byte without moving codep. */
14489 static unsigned char
14490 get_vex_imm8 (int sizeflag
, int opnum
)
14492 int bytes_before_imm
= 0;
14494 if (modrm
.mod
!= 3)
14496 /* There are SIB/displacement bytes. */
14497 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14499 /* 32/64 bit address mode */
14500 int base
= modrm
.rm
;
14502 /* Check SIB byte. */
14505 FETCH_DATA (the_info
, codep
+ 1);
14507 /* When decoding the third source, don't increase
14508 bytes_before_imm as this has already been incremented
14509 by one in OP_E_memory while decoding the second
14512 bytes_before_imm
++;
14515 /* Don't increase bytes_before_imm when decoding the third source,
14516 it has already been incremented by OP_E_memory while decoding
14517 the second source operand. */
14523 /* When modrm.rm == 5 or modrm.rm == 4 and base in
14524 SIB == 5, there is a 4 byte displacement. */
14526 /* No displacement. */
14529 /* 4 byte displacement. */
14530 bytes_before_imm
+= 4;
14533 /* 1 byte displacement. */
14534 bytes_before_imm
++;
14541 /* 16 bit address mode */
14542 /* Don't increase bytes_before_imm when decoding the third source,
14543 it has already been incremented by OP_E_memory while decoding
14544 the second source operand. */
14550 /* When modrm.rm == 6, there is a 2 byte displacement. */
14552 /* No displacement. */
14555 /* 2 byte displacement. */
14556 bytes_before_imm
+= 2;
14559 /* 1 byte displacement: when decoding the third source,
14560 don't increase bytes_before_imm as this has already
14561 been incremented by one in OP_E_memory while decoding
14562 the second source operand. */
14564 bytes_before_imm
++;
14572 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
14573 return codep
[bytes_before_imm
];
14577 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
14579 const char **names
;
14581 if (reg
== -1 && modrm
.mod
!= 3)
14583 OP_E_memory (bytemode
, sizeflag
);
14595 else if (reg
> 7 && address_mode
!= mode_64bit
)
14599 switch (vex
.length
)
14610 oappend (names
[reg
]);
14614 OP_EX_VexImmW (int bytemode
, int sizeflag
)
14617 static unsigned char vex_imm8
;
14619 if (vex_w_done
== 0)
14623 /* Skip mod/rm byte. */
14627 vex_imm8
= get_vex_imm8 (sizeflag
, 0);
14630 reg
= vex_imm8
>> 4;
14632 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14634 else if (vex_w_done
== 1)
14639 reg
= vex_imm8
>> 4;
14641 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14645 /* Output the imm8 directly. */
14646 scratchbuf
[0] = '$';
14647 print_operand_value (scratchbuf
+ 1, 1, vex_imm8
& 0xf);
14648 oappend (scratchbuf
+ intel_syntax
);
14649 scratchbuf
[0] = '\0';
14655 OP_Vex_2src (int bytemode
, int sizeflag
)
14657 if (modrm
.mod
== 3)
14659 int reg
= modrm
.rm
;
14663 oappend (names_xmm
[reg
]);
14668 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14670 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14671 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14673 OP_E (bytemode
, sizeflag
);
14678 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
14680 if (modrm
.mod
== 3)
14682 /* Skip mod/rm byte. */
14688 oappend (names_xmm
[vex
.register_specifier
]);
14690 OP_Vex_2src (bytemode
, sizeflag
);
14694 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
14697 OP_Vex_2src (bytemode
, sizeflag
);
14699 oappend (names_xmm
[vex
.register_specifier
]);
14703 OP_EX_VexW (int bytemode
, int sizeflag
)
14711 /* Skip mod/rm byte. */
14716 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
14721 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
14724 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
14728 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14729 int sizeflag ATTRIBUTE_UNUSED
)
14731 /* Skip the immediate byte and check for invalid bits. */
14732 FETCH_DATA (the_info
, codep
+ 1);
14733 if (*codep
++ & 0xf)
14738 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14741 const char **names
;
14743 FETCH_DATA (the_info
, codep
+ 1);
14746 if (bytemode
!= x_mode
)
14753 if (reg
> 7 && address_mode
!= mode_64bit
)
14756 switch (vex
.length
)
14767 oappend (names
[reg
]);
14771 OP_XMM_VexW (int bytemode
, int sizeflag
)
14773 /* Turn off the REX.W bit since it is used for swapping operands
14776 OP_XMM (bytemode
, sizeflag
);
14780 OP_EX_Vex (int bytemode
, int sizeflag
)
14782 if (modrm
.mod
!= 3)
14784 if (vex
.register_specifier
!= 0)
14788 OP_EX (bytemode
, sizeflag
);
14792 OP_XMM_Vex (int bytemode
, int sizeflag
)
14794 if (modrm
.mod
!= 3)
14796 if (vex
.register_specifier
!= 0)
14800 OP_XMM (bytemode
, sizeflag
);
14804 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14806 switch (vex
.length
)
14809 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
14812 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14819 static struct op vex_cmp_op
[] =
14821 { STRING_COMMA_LEN ("eq") },
14822 { STRING_COMMA_LEN ("lt") },
14823 { STRING_COMMA_LEN ("le") },
14824 { STRING_COMMA_LEN ("unord") },
14825 { STRING_COMMA_LEN ("neq") },
14826 { STRING_COMMA_LEN ("nlt") },
14827 { STRING_COMMA_LEN ("nle") },
14828 { STRING_COMMA_LEN ("ord") },
14829 { STRING_COMMA_LEN ("eq_uq") },
14830 { STRING_COMMA_LEN ("nge") },
14831 { STRING_COMMA_LEN ("ngt") },
14832 { STRING_COMMA_LEN ("false") },
14833 { STRING_COMMA_LEN ("neq_oq") },
14834 { STRING_COMMA_LEN ("ge") },
14835 { STRING_COMMA_LEN ("gt") },
14836 { STRING_COMMA_LEN ("true") },
14837 { STRING_COMMA_LEN ("eq_os") },
14838 { STRING_COMMA_LEN ("lt_oq") },
14839 { STRING_COMMA_LEN ("le_oq") },
14840 { STRING_COMMA_LEN ("unord_s") },
14841 { STRING_COMMA_LEN ("neq_us") },
14842 { STRING_COMMA_LEN ("nlt_uq") },
14843 { STRING_COMMA_LEN ("nle_uq") },
14844 { STRING_COMMA_LEN ("ord_s") },
14845 { STRING_COMMA_LEN ("eq_us") },
14846 { STRING_COMMA_LEN ("nge_uq") },
14847 { STRING_COMMA_LEN ("ngt_uq") },
14848 { STRING_COMMA_LEN ("false_os") },
14849 { STRING_COMMA_LEN ("neq_os") },
14850 { STRING_COMMA_LEN ("ge_oq") },
14851 { STRING_COMMA_LEN ("gt_oq") },
14852 { STRING_COMMA_LEN ("true_us") },
14856 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14858 unsigned int cmp_type
;
14860 FETCH_DATA (the_info
, codep
+ 1);
14861 cmp_type
= *codep
++ & 0xff;
14862 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14865 char *p
= mnemonicendp
- 2;
14869 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14870 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14874 /* We have a reserved extension byte. Output it directly. */
14875 scratchbuf
[0] = '$';
14876 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14877 oappend (scratchbuf
+ intel_syntax
);
14878 scratchbuf
[0] = '\0';
14882 static const struct op pclmul_op
[] =
14884 { STRING_COMMA_LEN ("lql") },
14885 { STRING_COMMA_LEN ("hql") },
14886 { STRING_COMMA_LEN ("lqh") },
14887 { STRING_COMMA_LEN ("hqh") }
14891 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14892 int sizeflag ATTRIBUTE_UNUSED
)
14894 unsigned int pclmul_type
;
14896 FETCH_DATA (the_info
, codep
+ 1);
14897 pclmul_type
= *codep
++ & 0xff;
14898 switch (pclmul_type
)
14909 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14912 char *p
= mnemonicendp
- 3;
14917 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14918 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14922 /* We have a reserved extension byte. Output it directly. */
14923 scratchbuf
[0] = '$';
14924 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14925 oappend (scratchbuf
+ intel_syntax
);
14926 scratchbuf
[0] = '\0';
14931 MOVBE_Fixup (int bytemode
, int sizeflag
)
14933 /* Add proper suffix to "movbe". */
14934 char *p
= mnemonicendp
;
14943 if (sizeflag
& SUFFIX_ALWAYS
)
14949 if (sizeflag
& DFLAG
)
14953 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14958 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14965 OP_M (bytemode
, sizeflag
);
14969 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14972 const char **names
;
14974 /* Skip mod/rm byte. */
14980 else if (vex
.length
== 256)
14990 oappend (names
[reg
]);
14994 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14996 const char **names
;
15000 else if (vex
.length
== 256)
15005 oappend (names
[vex
.register_specifier
]);
15009 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
15011 if (vex
.w
|| vex
.length
== 256)
15012 OP_I (q_mode
, sizeflag
);
15014 OP_I (w_mode
, sizeflag
);