1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma
, disassemble_info
*);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma
);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma
);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma
get64 (void);
60 static bfd_signed_vma
get32 (void);
61 static bfd_signed_vma
get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma
, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte
*max_fetched
;
125 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
138 enum address_mode address_mode
;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* Original REX prefix. */
148 static int rex_original
;
149 /* REX bits in original REX prefix ignored. It may not be the same
150 as rex_original since some bits may not be ignored. */
151 static int rex_ignored
;
152 /* Mark parts used in the REX prefix. When we are testing for
153 empty prefix (for 8bit register REX extension), just mask it
154 out. Otherwise test for REX bit is excuse for existence of REX
155 only in case value is nonzero. */
156 #define USED_REX(value) \
161 rex_used |= (value) | REX_OPCODE; \
164 rex_used |= REX_OPCODE; \
167 /* Flags for prefixes which we somehow handled when printing the
168 current instruction. */
169 static int used_prefixes
;
171 /* Flags stored in PREFIXES. */
172 #define PREFIX_REPZ 1
173 #define PREFIX_REPNZ 2
174 #define PREFIX_LOCK 4
176 #define PREFIX_SS 0x10
177 #define PREFIX_DS 0x20
178 #define PREFIX_ES 0x40
179 #define PREFIX_FS 0x80
180 #define PREFIX_GS 0x100
181 #define PREFIX_DATA 0x200
182 #define PREFIX_ADDR 0x400
183 #define PREFIX_FWAIT 0x800
185 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
186 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
188 #define FETCH_DATA(info, addr) \
189 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
190 ? 1 : fetch_data ((info), (addr)))
193 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
196 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
197 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
199 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
200 status
= (*info
->read_memory_func
) (start
,
202 addr
- priv
->max_fetched
,
208 /* If we did manage to read at least one byte, then
209 print_insn_i386 will do something sensible. Otherwise, print
210 an error. We do that here because this is where we know
212 if (priv
->max_fetched
== priv
->the_buffer
)
213 (*info
->memory_error_func
) (status
, start
, info
);
214 longjmp (priv
->bailout
, 1);
217 priv
->max_fetched
= addr
;
221 #define XX { NULL, 0 }
223 #define Eb { OP_E, b_mode }
224 #define EbS { OP_E, b_swap_mode }
225 #define Ev { OP_E, v_mode }
226 #define EvS { OP_E, v_swap_mode }
227 #define Ed { OP_E, d_mode }
228 #define Edq { OP_E, dq_mode }
229 #define Edqw { OP_E, dqw_mode }
230 #define Edqb { OP_E, dqb_mode }
231 #define Edqd { OP_E, dqd_mode }
232 #define Eq { OP_E, q_mode }
233 #define indirEv { OP_indirE, stack_v_mode }
234 #define indirEp { OP_indirE, f_mode }
235 #define stackEv { OP_E, stack_v_mode }
236 #define Em { OP_E, m_mode }
237 #define Ew { OP_E, w_mode }
238 #define M { OP_M, 0 } /* lea, lgdt, etc. */
239 #define Ma { OP_M, a_mode }
240 #define Mb { OP_M, b_mode }
241 #define Md { OP_M, d_mode }
242 #define Mo { OP_M, o_mode }
243 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
244 #define Mq { OP_M, q_mode }
245 #define Mx { OP_M, x_mode }
246 #define Mxmm { OP_M, xmm_mode }
247 #define Gb { OP_G, b_mode }
248 #define Gv { OP_G, v_mode }
249 #define Gd { OP_G, d_mode }
250 #define Gdq { OP_G, dq_mode }
251 #define Gm { OP_G, m_mode }
252 #define Gw { OP_G, w_mode }
253 #define Rd { OP_R, d_mode }
254 #define Rm { OP_R, m_mode }
255 #define Ib { OP_I, b_mode }
256 #define sIb { OP_sI, b_mode } /* sign extened byte */
257 #define Iv { OP_I, v_mode }
258 #define Iq { OP_I, q_mode }
259 #define Iv64 { OP_I64, v_mode }
260 #define Iw { OP_I, w_mode }
261 #define I1 { OP_I, const_1_mode }
262 #define Jb { OP_J, b_mode }
263 #define Jv { OP_J, v_mode }
264 #define Cm { OP_C, m_mode }
265 #define Dm { OP_D, m_mode }
266 #define Td { OP_T, d_mode }
267 #define Skip_MODRM { OP_Skip_MODRM, 0 }
269 #define RMeAX { OP_REG, eAX_reg }
270 #define RMeBX { OP_REG, eBX_reg }
271 #define RMeCX { OP_REG, eCX_reg }
272 #define RMeDX { OP_REG, eDX_reg }
273 #define RMeSP { OP_REG, eSP_reg }
274 #define RMeBP { OP_REG, eBP_reg }
275 #define RMeSI { OP_REG, eSI_reg }
276 #define RMeDI { OP_REG, eDI_reg }
277 #define RMrAX { OP_REG, rAX_reg }
278 #define RMrBX { OP_REG, rBX_reg }
279 #define RMrCX { OP_REG, rCX_reg }
280 #define RMrDX { OP_REG, rDX_reg }
281 #define RMrSP { OP_REG, rSP_reg }
282 #define RMrBP { OP_REG, rBP_reg }
283 #define RMrSI { OP_REG, rSI_reg }
284 #define RMrDI { OP_REG, rDI_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMAL { OP_REG, al_reg }
287 #define RMCL { OP_REG, cl_reg }
288 #define RMDL { OP_REG, dl_reg }
289 #define RMBL { OP_REG, bl_reg }
290 #define RMAH { OP_REG, ah_reg }
291 #define RMCH { OP_REG, ch_reg }
292 #define RMDH { OP_REG, dh_reg }
293 #define RMBH { OP_REG, bh_reg }
294 #define RMAX { OP_REG, ax_reg }
295 #define RMDX { OP_REG, dx_reg }
297 #define eAX { OP_IMREG, eAX_reg }
298 #define eBX { OP_IMREG, eBX_reg }
299 #define eCX { OP_IMREG, eCX_reg }
300 #define eDX { OP_IMREG, eDX_reg }
301 #define eSP { OP_IMREG, eSP_reg }
302 #define eBP { OP_IMREG, eBP_reg }
303 #define eSI { OP_IMREG, eSI_reg }
304 #define eDI { OP_IMREG, eDI_reg }
305 #define AL { OP_IMREG, al_reg }
306 #define CL { OP_IMREG, cl_reg }
307 #define DL { OP_IMREG, dl_reg }
308 #define BL { OP_IMREG, bl_reg }
309 #define AH { OP_IMREG, ah_reg }
310 #define CH { OP_IMREG, ch_reg }
311 #define DH { OP_IMREG, dh_reg }
312 #define BH { OP_IMREG, bh_reg }
313 #define AX { OP_IMREG, ax_reg }
314 #define DX { OP_IMREG, dx_reg }
315 #define zAX { OP_IMREG, z_mode_ax_reg }
316 #define indirDX { OP_IMREG, indir_dx_reg }
318 #define Sw { OP_SEG, w_mode }
319 #define Sv { OP_SEG, v_mode }
320 #define Ap { OP_DIR, 0 }
321 #define Ob { OP_OFF64, b_mode }
322 #define Ov { OP_OFF64, v_mode }
323 #define Xb { OP_DSreg, eSI_reg }
324 #define Xv { OP_DSreg, eSI_reg }
325 #define Xz { OP_DSreg, eSI_reg }
326 #define Yb { OP_ESreg, eDI_reg }
327 #define Yv { OP_ESreg, eDI_reg }
328 #define DSBX { OP_DSreg, eBX_reg }
330 #define es { OP_REG, es_reg }
331 #define ss { OP_REG, ss_reg }
332 #define cs { OP_REG, cs_reg }
333 #define ds { OP_REG, ds_reg }
334 #define fs { OP_REG, fs_reg }
335 #define gs { OP_REG, gs_reg }
337 #define MX { OP_MMX, 0 }
338 #define XM { OP_XMM, 0 }
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 EXdS { OP_EX, d_swap_mode }
347 #define EXq { OP_EX, q_mode }
348 #define EXqS { OP_EX, q_swap_mode }
349 #define EXx { OP_EX, x_mode }
350 #define EXxS { OP_EX, x_swap_mode }
351 #define EXxmm { OP_EX, xmm_mode }
352 #define EXxmmq { OP_EX, xmmq_mode }
353 #define EXymmq { OP_EX, ymmq_mode }
354 #define EXVexWdq { OP_EX, vex_w_dq_mode }
355 #define MS { OP_MS, v_mode }
356 #define XS { OP_XS, v_mode }
357 #define EMCq { OP_EMC, q_mode }
358 #define MXC { OP_MXC, 0 }
359 #define OPSUF { OP_3DNowSuffix, 0 }
360 #define CMP { CMP_Fixup, 0 }
361 #define XMM0 { XMM_Fixup, 0 }
362 #define FXSAVE { FXSAVE_Fixup, 0 }
363 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
364 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
366 #define Vex { OP_VEX, vex_mode }
367 #define Vex128 { OP_VEX, vex128_mode }
368 #define Vex256 { OP_VEX, vex256_mode }
369 #define VexI4 { VEXI4_Fixup, 0}
370 #define EXdVex { OP_EX_Vex, d_mode }
371 #define EXdVexS { OP_EX_Vex, d_swap_mode }
372 #define EXqVex { OP_EX_Vex, q_mode }
373 #define EXqVexS { OP_EX_Vex, q_swap_mode }
374 #define EXVexW { OP_EX_VexW, x_mode }
375 #define EXdVexW { OP_EX_VexW, d_mode }
376 #define EXqVexW { OP_EX_VexW, q_mode }
377 #define XMVex { OP_XMM_Vex, 0 }
378 #define XMVexW { OP_XMM_VexW, 0 }
379 #define XMVexI4 { OP_REG_VexI4, x_mode }
380 #define PCLMUL { PCLMUL_Fixup, 0 }
381 #define VZERO { VZERO_Fixup, 0 }
382 #define VCMP { VCMP_Fixup, 0 }
384 /* Used handle "rep" prefix for string instructions. */
385 #define Xbr { REP_Fixup, eSI_reg }
386 #define Xvr { REP_Fixup, eSI_reg }
387 #define Ybr { REP_Fixup, eDI_reg }
388 #define Yvr { REP_Fixup, eDI_reg }
389 #define Yzr { REP_Fixup, eDI_reg }
390 #define indirDXr { REP_Fixup, indir_dx_reg }
391 #define ALr { REP_Fixup, al_reg }
392 #define eAXr { REP_Fixup, eAX_reg }
394 #define cond_jump_flag { NULL, cond_jump_mode }
395 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
397 /* bits in sizeflag */
398 #define SUFFIX_ALWAYS 4
406 /* byte operand with operand swapped */
408 /* operand size depends on prefixes */
410 /* operand size depends on prefixes with operand swapped */
414 /* double word operand */
416 /* double word operand with operand swapped */
418 /* quad word operand */
420 /* quad word operand with operand swapped */
422 /* ten-byte operand */
424 /* 16-byte XMM or 32-byte YMM operand */
426 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
428 /* 16-byte XMM operand */
430 /* 16-byte XMM or quad word operand */
432 /* 32-byte YMM or quad word operand */
434 /* d_mode in 32bit, q_mode in 64bit mode. */
436 /* pair of v_mode operands */
440 /* operand size depends on REX prefixes. */
442 /* registers like dq_mode, memory like w_mode. */
444 /* 4- or 6-byte pointer operand */
447 /* v_mode for stack-related opcodes. */
449 /* non-quad operand size depends on prefixes */
451 /* 16-byte operand */
453 /* registers like dq_mode, memory like b_mode. */
455 /* registers like dq_mode, memory like d_mode. */
457 /* normal vex mode */
459 /* 128bit vex mode */
461 /* 256bit vex mode */
463 /* operand size depends on the VEX.W bit. */
529 #define FLOAT NULL, { { NULL, FLOATCODE } }
531 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
532 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
533 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
534 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
535 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
536 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
537 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
538 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
539 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
540 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
541 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
542 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
660 MOD_VEX_3818_PREFIX_2
,
661 MOD_VEX_3819_PREFIX_2
,
662 MOD_VEX_381A_PREFIX_2
,
663 MOD_VEX_382A_PREFIX_2
,
664 MOD_VEX_382C_PREFIX_2
,
665 MOD_VEX_382D_PREFIX_2
,
666 MOD_VEX_382E_PREFIX_2
,
667 MOD_VEX_382F_PREFIX_2
1077 THREE_BYTE_0F38
= 0,
1232 VEX_LEN_3819_P_2_M_0
,
1233 VEX_LEN_381A_P_2_M_0
,
1245 VEX_LEN_382A_P_2_M_0
,
1561 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1572 /* Upper case letters in the instruction names here are macros.
1573 'A' => print 'b' if no register operands or suffix_always is true
1574 'B' => print 'b' if suffix_always is true
1575 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1577 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1578 suffix_always is true
1579 'E' => print 'e' if 32-bit form of jcxz
1580 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1581 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1582 'H' => print ",pt" or ",pn" branch hint
1583 'I' => honor following macro letter even in Intel mode (implemented only
1584 for some of the macro letters)
1586 'K' => print 'd' or 'q' if rex prefix is present.
1587 'L' => print 'l' if suffix_always is true
1588 'M' => print 'r' if intel_mnemonic is false.
1589 'N' => print 'n' if instruction has no wait "prefix"
1590 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1591 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1592 or suffix_always is true. print 'q' if rex prefix is present.
1593 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1595 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1596 'S' => print 'w', 'l' or 'q' if suffix_always is true
1597 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1598 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1599 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1600 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1601 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1602 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1603 suffix_always is true.
1604 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1605 '!' => change condition from true to false or from false to true.
1606 '%' => add 1 upper case letter to the macro.
1608 2 upper case letter macros:
1609 "XY" => print 'x' or 'y' if no register operands or suffix_always
1611 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1612 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1613 or suffix_always is true
1614 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1615 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1616 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1618 Many of the above letters print nothing in Intel mode. See "putop"
1621 Braces '{' and '}', and vertical bars '|', indicate alternative
1622 mnemonic strings for AT&T and Intel. */
1624 static const struct dis386 dis386
[] = {
1626 { "addB", { Eb
, Gb
} },
1627 { "addS", { Ev
, Gv
} },
1628 { "addB", { Gb
, EbS
} },
1629 { "addS", { Gv
, EvS
} },
1630 { "addB", { AL
, Ib
} },
1631 { "addS", { eAX
, Iv
} },
1632 { X86_64_TABLE (X86_64_06
) },
1633 { X86_64_TABLE (X86_64_07
) },
1635 { "orB", { Eb
, Gb
} },
1636 { "orS", { Ev
, Gv
} },
1637 { "orB", { Gb
, EbS
} },
1638 { "orS", { Gv
, EvS
} },
1639 { "orB", { AL
, Ib
} },
1640 { "orS", { eAX
, Iv
} },
1641 { X86_64_TABLE (X86_64_0D
) },
1642 { "(bad)", { XX
} }, /* 0x0f extended opcode escape */
1644 { "adcB", { Eb
, Gb
} },
1645 { "adcS", { Ev
, Gv
} },
1646 { "adcB", { Gb
, EbS
} },
1647 { "adcS", { Gv
, EvS
} },
1648 { "adcB", { AL
, Ib
} },
1649 { "adcS", { eAX
, Iv
} },
1650 { X86_64_TABLE (X86_64_16
) },
1651 { X86_64_TABLE (X86_64_17
) },
1653 { "sbbB", { Eb
, Gb
} },
1654 { "sbbS", { Ev
, Gv
} },
1655 { "sbbB", { Gb
, EbS
} },
1656 { "sbbS", { Gv
, EvS
} },
1657 { "sbbB", { AL
, Ib
} },
1658 { "sbbS", { eAX
, Iv
} },
1659 { X86_64_TABLE (X86_64_1E
) },
1660 { X86_64_TABLE (X86_64_1F
) },
1662 { "andB", { Eb
, Gb
} },
1663 { "andS", { Ev
, Gv
} },
1664 { "andB", { Gb
, EbS
} },
1665 { "andS", { Gv
, EvS
} },
1666 { "andB", { AL
, Ib
} },
1667 { "andS", { eAX
, Iv
} },
1668 { "(bad)", { XX
} }, /* SEG ES prefix */
1669 { X86_64_TABLE (X86_64_27
) },
1671 { "subB", { Eb
, Gb
} },
1672 { "subS", { Ev
, Gv
} },
1673 { "subB", { Gb
, EbS
} },
1674 { "subS", { Gv
, EvS
} },
1675 { "subB", { AL
, Ib
} },
1676 { "subS", { eAX
, Iv
} },
1677 { "(bad)", { XX
} }, /* SEG CS prefix */
1678 { X86_64_TABLE (X86_64_2F
) },
1680 { "xorB", { Eb
, Gb
} },
1681 { "xorS", { Ev
, Gv
} },
1682 { "xorB", { Gb
, EbS
} },
1683 { "xorS", { Gv
, EvS
} },
1684 { "xorB", { AL
, Ib
} },
1685 { "xorS", { eAX
, Iv
} },
1686 { "(bad)", { XX
} }, /* SEG SS prefix */
1687 { X86_64_TABLE (X86_64_37
) },
1689 { "cmpB", { Eb
, Gb
} },
1690 { "cmpS", { Ev
, Gv
} },
1691 { "cmpB", { Gb
, EbS
} },
1692 { "cmpS", { Gv
, EvS
} },
1693 { "cmpB", { AL
, Ib
} },
1694 { "cmpS", { eAX
, Iv
} },
1695 { "(bad)", { XX
} }, /* SEG DS prefix */
1696 { X86_64_TABLE (X86_64_3F
) },
1698 { "inc{S|}", { RMeAX
} },
1699 { "inc{S|}", { RMeCX
} },
1700 { "inc{S|}", { RMeDX
} },
1701 { "inc{S|}", { RMeBX
} },
1702 { "inc{S|}", { RMeSP
} },
1703 { "inc{S|}", { RMeBP
} },
1704 { "inc{S|}", { RMeSI
} },
1705 { "inc{S|}", { RMeDI
} },
1707 { "dec{S|}", { RMeAX
} },
1708 { "dec{S|}", { RMeCX
} },
1709 { "dec{S|}", { RMeDX
} },
1710 { "dec{S|}", { RMeBX
} },
1711 { "dec{S|}", { RMeSP
} },
1712 { "dec{S|}", { RMeBP
} },
1713 { "dec{S|}", { RMeSI
} },
1714 { "dec{S|}", { RMeDI
} },
1716 { "pushV", { RMrAX
} },
1717 { "pushV", { RMrCX
} },
1718 { "pushV", { RMrDX
} },
1719 { "pushV", { RMrBX
} },
1720 { "pushV", { RMrSP
} },
1721 { "pushV", { RMrBP
} },
1722 { "pushV", { RMrSI
} },
1723 { "pushV", { RMrDI
} },
1725 { "popV", { RMrAX
} },
1726 { "popV", { RMrCX
} },
1727 { "popV", { RMrDX
} },
1728 { "popV", { RMrBX
} },
1729 { "popV", { RMrSP
} },
1730 { "popV", { RMrBP
} },
1731 { "popV", { RMrSI
} },
1732 { "popV", { RMrDI
} },
1734 { X86_64_TABLE (X86_64_60
) },
1735 { X86_64_TABLE (X86_64_61
) },
1736 { X86_64_TABLE (X86_64_62
) },
1737 { X86_64_TABLE (X86_64_63
) },
1738 { "(bad)", { XX
} }, /* seg fs */
1739 { "(bad)", { XX
} }, /* seg gs */
1740 { "(bad)", { XX
} }, /* op size prefix */
1741 { "(bad)", { XX
} }, /* adr size prefix */
1743 { "pushT", { Iq
} },
1744 { "imulS", { Gv
, Ev
, Iv
} },
1745 { "pushT", { sIb
} },
1746 { "imulS", { Gv
, Ev
, sIb
} },
1747 { "ins{b|}", { Ybr
, indirDX
} },
1748 { X86_64_TABLE (X86_64_6D
) },
1749 { "outs{b|}", { indirDXr
, Xb
} },
1750 { X86_64_TABLE (X86_64_6F
) },
1752 { "joH", { Jb
, XX
, cond_jump_flag
} },
1753 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1754 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1755 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1756 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1757 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1758 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1759 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1761 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1762 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1763 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1764 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1765 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1766 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1767 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1768 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1770 { REG_TABLE (REG_80
) },
1771 { REG_TABLE (REG_81
) },
1772 { "(bad)", { XX
} },
1773 { REG_TABLE (REG_82
) },
1774 { "testB", { Eb
, Gb
} },
1775 { "testS", { Ev
, Gv
} },
1776 { "xchgB", { Eb
, Gb
} },
1777 { "xchgS", { Ev
, Gv
} },
1779 { "movB", { Eb
, Gb
} },
1780 { "movS", { Ev
, Gv
} },
1781 { "movB", { Gb
, EbS
} },
1782 { "movS", { Gv
, EvS
} },
1783 { "movD", { Sv
, Sw
} },
1784 { MOD_TABLE (MOD_8D
) },
1785 { "movD", { Sw
, Sv
} },
1786 { REG_TABLE (REG_8F
) },
1788 { PREFIX_TABLE (PREFIX_90
) },
1789 { "xchgS", { RMeCX
, eAX
} },
1790 { "xchgS", { RMeDX
, eAX
} },
1791 { "xchgS", { RMeBX
, eAX
} },
1792 { "xchgS", { RMeSP
, eAX
} },
1793 { "xchgS", { RMeBP
, eAX
} },
1794 { "xchgS", { RMeSI
, eAX
} },
1795 { "xchgS", { RMeDI
, eAX
} },
1797 { "cW{t|}R", { XX
} },
1798 { "cR{t|}O", { XX
} },
1799 { X86_64_TABLE (X86_64_9A
) },
1800 { "(bad)", { XX
} }, /* fwait */
1801 { "pushfT", { XX
} },
1802 { "popfT", { XX
} },
1806 { "mov%LB", { AL
, Ob
} },
1807 { "mov%LS", { eAX
, Ov
} },
1808 { "mov%LB", { Ob
, AL
} },
1809 { "mov%LS", { Ov
, eAX
} },
1810 { "movs{b|}", { Ybr
, Xb
} },
1811 { "movs{R|}", { Yvr
, Xv
} },
1812 { "cmps{b|}", { Xb
, Yb
} },
1813 { "cmps{R|}", { Xv
, Yv
} },
1815 { "testB", { AL
, Ib
} },
1816 { "testS", { eAX
, Iv
} },
1817 { "stosB", { Ybr
, AL
} },
1818 { "stosS", { Yvr
, eAX
} },
1819 { "lodsB", { ALr
, Xb
} },
1820 { "lodsS", { eAXr
, Xv
} },
1821 { "scasB", { AL
, Yb
} },
1822 { "scasS", { eAX
, Yv
} },
1824 { "movB", { RMAL
, Ib
} },
1825 { "movB", { RMCL
, Ib
} },
1826 { "movB", { RMDL
, Ib
} },
1827 { "movB", { RMBL
, Ib
} },
1828 { "movB", { RMAH
, Ib
} },
1829 { "movB", { RMCH
, Ib
} },
1830 { "movB", { RMDH
, Ib
} },
1831 { "movB", { RMBH
, Ib
} },
1833 { "mov%LV", { RMeAX
, Iv64
} },
1834 { "mov%LV", { RMeCX
, Iv64
} },
1835 { "mov%LV", { RMeDX
, Iv64
} },
1836 { "mov%LV", { RMeBX
, Iv64
} },
1837 { "mov%LV", { RMeSP
, Iv64
} },
1838 { "mov%LV", { RMeBP
, Iv64
} },
1839 { "mov%LV", { RMeSI
, Iv64
} },
1840 { "mov%LV", { RMeDI
, Iv64
} },
1842 { REG_TABLE (REG_C0
) },
1843 { REG_TABLE (REG_C1
) },
1846 { X86_64_TABLE (X86_64_C4
) },
1847 { X86_64_TABLE (X86_64_C5
) },
1848 { REG_TABLE (REG_C6
) },
1849 { REG_TABLE (REG_C7
) },
1851 { "enterT", { Iw
, Ib
} },
1852 { "leaveT", { XX
} },
1853 { "Jret{|f}P", { Iw
} },
1854 { "Jret{|f}P", { XX
} },
1857 { X86_64_TABLE (X86_64_CE
) },
1858 { "iretP", { XX
} },
1860 { REG_TABLE (REG_D0
) },
1861 { REG_TABLE (REG_D1
) },
1862 { REG_TABLE (REG_D2
) },
1863 { REG_TABLE (REG_D3
) },
1864 { X86_64_TABLE (X86_64_D4
) },
1865 { X86_64_TABLE (X86_64_D5
) },
1866 { "(bad)", { XX
} },
1867 { "xlat", { DSBX
} },
1878 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1879 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1880 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1881 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1882 { "inB", { AL
, Ib
} },
1883 { "inG", { zAX
, Ib
} },
1884 { "outB", { Ib
, AL
} },
1885 { "outG", { Ib
, zAX
} },
1887 { "callT", { Jv
} },
1889 { X86_64_TABLE (X86_64_EA
) },
1891 { "inB", { AL
, indirDX
} },
1892 { "inG", { zAX
, indirDX
} },
1893 { "outB", { indirDX
, AL
} },
1894 { "outG", { indirDX
, zAX
} },
1896 { "(bad)", { XX
} }, /* lock prefix */
1897 { "icebp", { XX
} },
1898 { "(bad)", { XX
} }, /* repne */
1899 { "(bad)", { XX
} }, /* repz */
1902 { REG_TABLE (REG_F6
) },
1903 { REG_TABLE (REG_F7
) },
1911 { REG_TABLE (REG_FE
) },
1912 { REG_TABLE (REG_FF
) },
1915 static const struct dis386 dis386_twobyte
[] = {
1917 { REG_TABLE (REG_0F00
) },
1918 { REG_TABLE (REG_0F01
) },
1919 { "larS", { Gv
, Ew
} },
1920 { "lslS", { Gv
, Ew
} },
1921 { "(bad)", { XX
} },
1922 { "syscall", { XX
} },
1924 { "sysretP", { XX
} },
1927 { "wbinvd", { XX
} },
1928 { "(bad)", { XX
} },
1930 { "(bad)", { XX
} },
1931 { REG_TABLE (REG_0F0D
) },
1932 { "femms", { XX
} },
1933 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1935 { PREFIX_TABLE (PREFIX_0F10
) },
1936 { PREFIX_TABLE (PREFIX_0F11
) },
1937 { PREFIX_TABLE (PREFIX_0F12
) },
1938 { MOD_TABLE (MOD_0F13
) },
1939 { "unpcklpX", { XM
, EXx
} },
1940 { "unpckhpX", { XM
, EXx
} },
1941 { PREFIX_TABLE (PREFIX_0F16
) },
1942 { MOD_TABLE (MOD_0F17
) },
1944 { REG_TABLE (REG_0F18
) },
1953 { MOD_TABLE (MOD_0F20
) },
1954 { MOD_TABLE (MOD_0F21
) },
1955 { MOD_TABLE (MOD_0F22
) },
1956 { MOD_TABLE (MOD_0F23
) },
1957 { MOD_TABLE (MOD_0F24
) },
1958 { "(bad)", { XX
} },
1959 { MOD_TABLE (MOD_0F26
) },
1960 { "(bad)", { XX
} },
1962 { "movapX", { XM
, EXx
} },
1963 { "movapX", { EXxS
, XM
} },
1964 { PREFIX_TABLE (PREFIX_0F2A
) },
1965 { PREFIX_TABLE (PREFIX_0F2B
) },
1966 { PREFIX_TABLE (PREFIX_0F2C
) },
1967 { PREFIX_TABLE (PREFIX_0F2D
) },
1968 { PREFIX_TABLE (PREFIX_0F2E
) },
1969 { PREFIX_TABLE (PREFIX_0F2F
) },
1971 { "wrmsr", { XX
} },
1972 { "rdtsc", { XX
} },
1973 { "rdmsr", { XX
} },
1974 { "rdpmc", { XX
} },
1975 { "sysenter", { XX
} },
1976 { "sysexit", { XX
} },
1977 { "(bad)", { XX
} },
1978 { "getsec", { XX
} },
1980 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
1981 { "(bad)", { XX
} },
1982 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
1983 { "(bad)", { XX
} },
1984 { "(bad)", { XX
} },
1985 { "(bad)", { XX
} },
1986 { "(bad)", { XX
} },
1987 { "(bad)", { XX
} },
1989 { "cmovoS", { Gv
, Ev
} },
1990 { "cmovnoS", { Gv
, Ev
} },
1991 { "cmovbS", { Gv
, Ev
} },
1992 { "cmovaeS", { Gv
, Ev
} },
1993 { "cmoveS", { Gv
, Ev
} },
1994 { "cmovneS", { Gv
, Ev
} },
1995 { "cmovbeS", { Gv
, Ev
} },
1996 { "cmovaS", { Gv
, Ev
} },
1998 { "cmovsS", { Gv
, Ev
} },
1999 { "cmovnsS", { Gv
, Ev
} },
2000 { "cmovpS", { Gv
, Ev
} },
2001 { "cmovnpS", { Gv
, Ev
} },
2002 { "cmovlS", { Gv
, Ev
} },
2003 { "cmovgeS", { Gv
, Ev
} },
2004 { "cmovleS", { Gv
, Ev
} },
2005 { "cmovgS", { Gv
, Ev
} },
2007 { MOD_TABLE (MOD_0F51
) },
2008 { PREFIX_TABLE (PREFIX_0F51
) },
2009 { PREFIX_TABLE (PREFIX_0F52
) },
2010 { PREFIX_TABLE (PREFIX_0F53
) },
2011 { "andpX", { XM
, EXx
} },
2012 { "andnpX", { XM
, EXx
} },
2013 { "orpX", { XM
, EXx
} },
2014 { "xorpX", { XM
, EXx
} },
2016 { PREFIX_TABLE (PREFIX_0F58
) },
2017 { PREFIX_TABLE (PREFIX_0F59
) },
2018 { PREFIX_TABLE (PREFIX_0F5A
) },
2019 { PREFIX_TABLE (PREFIX_0F5B
) },
2020 { PREFIX_TABLE (PREFIX_0F5C
) },
2021 { PREFIX_TABLE (PREFIX_0F5D
) },
2022 { PREFIX_TABLE (PREFIX_0F5E
) },
2023 { PREFIX_TABLE (PREFIX_0F5F
) },
2025 { PREFIX_TABLE (PREFIX_0F60
) },
2026 { PREFIX_TABLE (PREFIX_0F61
) },
2027 { PREFIX_TABLE (PREFIX_0F62
) },
2028 { "packsswb", { MX
, EM
} },
2029 { "pcmpgtb", { MX
, EM
} },
2030 { "pcmpgtw", { MX
, EM
} },
2031 { "pcmpgtd", { MX
, EM
} },
2032 { "packuswb", { MX
, EM
} },
2034 { "punpckhbw", { MX
, EM
} },
2035 { "punpckhwd", { MX
, EM
} },
2036 { "punpckhdq", { MX
, EM
} },
2037 { "packssdw", { MX
, EM
} },
2038 { PREFIX_TABLE (PREFIX_0F6C
) },
2039 { PREFIX_TABLE (PREFIX_0F6D
) },
2040 { "movK", { MX
, Edq
} },
2041 { PREFIX_TABLE (PREFIX_0F6F
) },
2043 { PREFIX_TABLE (PREFIX_0F70
) },
2044 { REG_TABLE (REG_0F71
) },
2045 { REG_TABLE (REG_0F72
) },
2046 { REG_TABLE (REG_0F73
) },
2047 { "pcmpeqb", { MX
, EM
} },
2048 { "pcmpeqw", { MX
, EM
} },
2049 { "pcmpeqd", { MX
, EM
} },
2052 { PREFIX_TABLE (PREFIX_0F78
) },
2053 { PREFIX_TABLE (PREFIX_0F79
) },
2054 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2055 { "(bad)", { XX
} },
2056 { PREFIX_TABLE (PREFIX_0F7C
) },
2057 { PREFIX_TABLE (PREFIX_0F7D
) },
2058 { PREFIX_TABLE (PREFIX_0F7E
) },
2059 { PREFIX_TABLE (PREFIX_0F7F
) },
2061 { "joH", { Jv
, XX
, cond_jump_flag
} },
2062 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
2063 { "jbH", { Jv
, XX
, cond_jump_flag
} },
2064 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
2065 { "jeH", { Jv
, XX
, cond_jump_flag
} },
2066 { "jneH", { Jv
, XX
, cond_jump_flag
} },
2067 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
2068 { "jaH", { Jv
, XX
, cond_jump_flag
} },
2070 { "jsH", { Jv
, XX
, cond_jump_flag
} },
2071 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
2072 { "jpH", { Jv
, XX
, cond_jump_flag
} },
2073 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
2074 { "jlH", { Jv
, XX
, cond_jump_flag
} },
2075 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
2076 { "jleH", { Jv
, XX
, cond_jump_flag
} },
2077 { "jgH", { Jv
, XX
, cond_jump_flag
} },
2080 { "setno", { Eb
} },
2082 { "setae", { Eb
} },
2084 { "setne", { Eb
} },
2085 { "setbe", { Eb
} },
2089 { "setns", { Eb
} },
2091 { "setnp", { Eb
} },
2093 { "setge", { Eb
} },
2094 { "setle", { Eb
} },
2097 { "pushT", { fs
} },
2099 { "cpuid", { XX
} },
2100 { "btS", { Ev
, Gv
} },
2101 { "shldS", { Ev
, Gv
, Ib
} },
2102 { "shldS", { Ev
, Gv
, CL
} },
2103 { REG_TABLE (REG_0FA6
) },
2104 { REG_TABLE (REG_0FA7
) },
2106 { "pushT", { gs
} },
2109 { "btsS", { Ev
, Gv
} },
2110 { "shrdS", { Ev
, Gv
, Ib
} },
2111 { "shrdS", { Ev
, Gv
, CL
} },
2112 { REG_TABLE (REG_0FAE
) },
2113 { "imulS", { Gv
, Ev
} },
2115 { "cmpxchgB", { Eb
, Gb
} },
2116 { "cmpxchgS", { Ev
, Gv
} },
2117 { MOD_TABLE (MOD_0FB2
) },
2118 { "btrS", { Ev
, Gv
} },
2119 { MOD_TABLE (MOD_0FB4
) },
2120 { MOD_TABLE (MOD_0FB5
) },
2121 { "movz{bR|x}", { Gv
, Eb
} },
2122 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
2124 { PREFIX_TABLE (PREFIX_0FB8
) },
2126 { REG_TABLE (REG_0FBA
) },
2127 { "btcS", { Ev
, Gv
} },
2128 { "bsfS", { Gv
, Ev
} },
2129 { PREFIX_TABLE (PREFIX_0FBD
) },
2130 { "movs{bR|x}", { Gv
, Eb
} },
2131 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
2133 { "xaddB", { Eb
, Gb
} },
2134 { "xaddS", { Ev
, Gv
} },
2135 { PREFIX_TABLE (PREFIX_0FC2
) },
2136 { PREFIX_TABLE (PREFIX_0FC3
) },
2137 { "pinsrw", { MX
, Edqw
, Ib
} },
2138 { "pextrw", { Gdq
, MS
, Ib
} },
2139 { "shufpX", { XM
, EXx
, Ib
} },
2140 { REG_TABLE (REG_0FC7
) },
2142 { "bswap", { RMeAX
} },
2143 { "bswap", { RMeCX
} },
2144 { "bswap", { RMeDX
} },
2145 { "bswap", { RMeBX
} },
2146 { "bswap", { RMeSP
} },
2147 { "bswap", { RMeBP
} },
2148 { "bswap", { RMeSI
} },
2149 { "bswap", { RMeDI
} },
2151 { PREFIX_TABLE (PREFIX_0FD0
) },
2152 { "psrlw", { MX
, EM
} },
2153 { "psrld", { MX
, EM
} },
2154 { "psrlq", { MX
, EM
} },
2155 { "paddq", { MX
, EM
} },
2156 { "pmullw", { MX
, EM
} },
2157 { PREFIX_TABLE (PREFIX_0FD6
) },
2158 { MOD_TABLE (MOD_0FD7
) },
2160 { "psubusb", { MX
, EM
} },
2161 { "psubusw", { MX
, EM
} },
2162 { "pminub", { MX
, EM
} },
2163 { "pand", { MX
, EM
} },
2164 { "paddusb", { MX
, EM
} },
2165 { "paddusw", { MX
, EM
} },
2166 { "pmaxub", { MX
, EM
} },
2167 { "pandn", { MX
, EM
} },
2169 { "pavgb", { MX
, EM
} },
2170 { "psraw", { MX
, EM
} },
2171 { "psrad", { MX
, EM
} },
2172 { "pavgw", { MX
, EM
} },
2173 { "pmulhuw", { MX
, EM
} },
2174 { "pmulhw", { MX
, EM
} },
2175 { PREFIX_TABLE (PREFIX_0FE6
) },
2176 { PREFIX_TABLE (PREFIX_0FE7
) },
2178 { "psubsb", { MX
, EM
} },
2179 { "psubsw", { MX
, EM
} },
2180 { "pminsw", { MX
, EM
} },
2181 { "por", { MX
, EM
} },
2182 { "paddsb", { MX
, EM
} },
2183 { "paddsw", { MX
, EM
} },
2184 { "pmaxsw", { MX
, EM
} },
2185 { "pxor", { MX
, EM
} },
2187 { PREFIX_TABLE (PREFIX_0FF0
) },
2188 { "psllw", { MX
, EM
} },
2189 { "pslld", { MX
, EM
} },
2190 { "psllq", { MX
, EM
} },
2191 { "pmuludq", { MX
, EM
} },
2192 { "pmaddwd", { MX
, EM
} },
2193 { "psadbw", { MX
, EM
} },
2194 { PREFIX_TABLE (PREFIX_0FF7
) },
2196 { "psubb", { MX
, EM
} },
2197 { "psubw", { MX
, EM
} },
2198 { "psubd", { MX
, EM
} },
2199 { "psubq", { MX
, EM
} },
2200 { "paddb", { MX
, EM
} },
2201 { "paddw", { MX
, EM
} },
2202 { "paddd", { MX
, EM
} },
2203 { "(bad)", { XX
} },
2206 static const unsigned char onebyte_has_modrm
[256] = {
2207 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2208 /* ------------------------------- */
2209 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2210 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2211 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2212 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2213 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2214 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2215 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2216 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2217 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2218 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2219 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2220 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2221 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2222 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2223 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2224 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2225 /* ------------------------------- */
2226 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2229 static const unsigned char twobyte_has_modrm
[256] = {
2230 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2231 /* ------------------------------- */
2232 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2233 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2234 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2235 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2236 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2237 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2238 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2239 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2240 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2241 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2242 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2243 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2244 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2245 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2246 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2247 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2248 /* ------------------------------- */
2249 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2252 static char obuf
[100];
2254 static char *mnemonicendp
;
2255 static char scratchbuf
[100];
2256 static unsigned char *start_codep
;
2257 static unsigned char *insn_codep
;
2258 static unsigned char *codep
;
2259 static int last_lock_prefix
;
2260 static int last_repz_prefix
;
2261 static int last_repnz_prefix
;
2262 static int last_data_prefix
;
2263 static int last_addr_prefix
;
2264 static int last_rex_prefix
;
2265 static int last_seg_prefix
;
2266 #define MAX_CODE_LENGTH 15
2267 /* We can up to 14 prefixes since the maximum instruction length is
2269 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2270 static disassemble_info
*the_info
;
2278 static unsigned char need_modrm
;
2281 int register_specifier
;
2287 static unsigned char need_vex
;
2288 static unsigned char need_vex_reg
;
2289 static unsigned char vex_w_done
;
2297 /* If we are accessing mod/rm/reg without need_modrm set, then the
2298 values are stale. Hitting this abort likely indicates that you
2299 need to update onebyte_has_modrm or twobyte_has_modrm. */
2300 #define MODRM_CHECK if (!need_modrm) abort ()
2302 static const char **names64
;
2303 static const char **names32
;
2304 static const char **names16
;
2305 static const char **names8
;
2306 static const char **names8rex
;
2307 static const char **names_seg
;
2308 static const char *index64
;
2309 static const char *index32
;
2310 static const char **index16
;
2312 static const char *intel_names64
[] = {
2313 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2314 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2316 static const char *intel_names32
[] = {
2317 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2318 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2320 static const char *intel_names16
[] = {
2321 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2322 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2324 static const char *intel_names8
[] = {
2325 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2327 static const char *intel_names8rex
[] = {
2328 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2329 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2331 static const char *intel_names_seg
[] = {
2332 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2334 static const char *intel_index64
= "riz";
2335 static const char *intel_index32
= "eiz";
2336 static const char *intel_index16
[] = {
2337 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2340 static const char *att_names64
[] = {
2341 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2342 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2344 static const char *att_names32
[] = {
2345 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2346 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2348 static const char *att_names16
[] = {
2349 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2350 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2352 static const char *att_names8
[] = {
2353 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2355 static const char *att_names8rex
[] = {
2356 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2357 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2359 static const char *att_names_seg
[] = {
2360 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2362 static const char *att_index64
= "%riz";
2363 static const char *att_index32
= "%eiz";
2364 static const char *att_index16
[] = {
2365 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2368 static const struct dis386 reg_table
[][8] = {
2371 { "addA", { Eb
, Ib
} },
2372 { "orA", { Eb
, Ib
} },
2373 { "adcA", { Eb
, Ib
} },
2374 { "sbbA", { Eb
, Ib
} },
2375 { "andA", { Eb
, Ib
} },
2376 { "subA", { Eb
, Ib
} },
2377 { "xorA", { Eb
, Ib
} },
2378 { "cmpA", { Eb
, Ib
} },
2382 { "addQ", { Ev
, Iv
} },
2383 { "orQ", { Ev
, Iv
} },
2384 { "adcQ", { Ev
, Iv
} },
2385 { "sbbQ", { Ev
, Iv
} },
2386 { "andQ", { Ev
, Iv
} },
2387 { "subQ", { Ev
, Iv
} },
2388 { "xorQ", { Ev
, Iv
} },
2389 { "cmpQ", { Ev
, Iv
} },
2393 { "addQ", { Ev
, sIb
} },
2394 { "orQ", { Ev
, sIb
} },
2395 { "adcQ", { Ev
, sIb
} },
2396 { "sbbQ", { Ev
, sIb
} },
2397 { "andQ", { Ev
, sIb
} },
2398 { "subQ", { Ev
, sIb
} },
2399 { "xorQ", { Ev
, sIb
} },
2400 { "cmpQ", { Ev
, sIb
} },
2404 { "popU", { stackEv
} },
2405 { XOP_8F_TABLE (XOP_09
) },
2406 { "(bad)", { XX
} },
2407 { "(bad)", { XX
} },
2408 { "(bad)", { XX
} },
2409 { XOP_8F_TABLE (XOP_09
) },
2410 { "(bad)", { XX
} },
2411 { "(bad)", { XX
} },
2415 { "rolA", { Eb
, Ib
} },
2416 { "rorA", { Eb
, Ib
} },
2417 { "rclA", { Eb
, Ib
} },
2418 { "rcrA", { Eb
, Ib
} },
2419 { "shlA", { Eb
, Ib
} },
2420 { "shrA", { Eb
, Ib
} },
2421 { "(bad)", { XX
} },
2422 { "sarA", { Eb
, Ib
} },
2426 { "rolQ", { Ev
, Ib
} },
2427 { "rorQ", { Ev
, Ib
} },
2428 { "rclQ", { Ev
, Ib
} },
2429 { "rcrQ", { Ev
, Ib
} },
2430 { "shlQ", { Ev
, Ib
} },
2431 { "shrQ", { Ev
, Ib
} },
2432 { "(bad)", { XX
} },
2433 { "sarQ", { Ev
, Ib
} },
2437 { "movA", { Eb
, Ib
} },
2438 { "(bad)", { XX
} },
2439 { "(bad)", { XX
} },
2440 { "(bad)", { XX
} },
2441 { "(bad)", { XX
} },
2442 { "(bad)", { XX
} },
2443 { "(bad)", { XX
} },
2444 { "(bad)", { XX
} },
2448 { "movQ", { Ev
, Iv
} },
2449 { "(bad)", { XX
} },
2450 { "(bad)", { XX
} },
2451 { "(bad)", { XX
} },
2452 { "(bad)", { XX
} },
2453 { "(bad)", { XX
} },
2454 { "(bad)", { XX
} },
2455 { "(bad)", { XX
} },
2459 { "rolA", { Eb
, I1
} },
2460 { "rorA", { Eb
, I1
} },
2461 { "rclA", { Eb
, I1
} },
2462 { "rcrA", { Eb
, I1
} },
2463 { "shlA", { Eb
, I1
} },
2464 { "shrA", { Eb
, I1
} },
2465 { "(bad)", { XX
} },
2466 { "sarA", { Eb
, I1
} },
2470 { "rolQ", { Ev
, I1
} },
2471 { "rorQ", { Ev
, I1
} },
2472 { "rclQ", { Ev
, I1
} },
2473 { "rcrQ", { Ev
, I1
} },
2474 { "shlQ", { Ev
, I1
} },
2475 { "shrQ", { Ev
, I1
} },
2476 { "(bad)", { XX
} },
2477 { "sarQ", { Ev
, I1
} },
2481 { "rolA", { Eb
, CL
} },
2482 { "rorA", { Eb
, CL
} },
2483 { "rclA", { Eb
, CL
} },
2484 { "rcrA", { Eb
, CL
} },
2485 { "shlA", { Eb
, CL
} },
2486 { "shrA", { Eb
, CL
} },
2487 { "(bad)", { XX
} },
2488 { "sarA", { Eb
, CL
} },
2492 { "rolQ", { Ev
, CL
} },
2493 { "rorQ", { Ev
, CL
} },
2494 { "rclQ", { Ev
, CL
} },
2495 { "rcrQ", { Ev
, CL
} },
2496 { "shlQ", { Ev
, CL
} },
2497 { "shrQ", { Ev
, CL
} },
2498 { "(bad)", { XX
} },
2499 { "sarQ", { Ev
, CL
} },
2503 { "testA", { Eb
, Ib
} },
2504 { "(bad)", { XX
} },
2507 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2508 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2509 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2510 { "idivA", { Eb
} }, /* and idiv for consistency. */
2514 { "testQ", { Ev
, Iv
} },
2515 { "(bad)", { XX
} },
2518 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2519 { "imulQ", { Ev
} },
2521 { "idivQ", { Ev
} },
2527 { "(bad)", { XX
} },
2528 { "(bad)", { XX
} },
2529 { "(bad)", { XX
} },
2530 { "(bad)", { XX
} },
2531 { "(bad)", { XX
} },
2532 { "(bad)", { XX
} },
2538 { "callT", { indirEv
} },
2539 { "JcallT", { indirEp
} },
2540 { "jmpT", { indirEv
} },
2541 { "JjmpT", { indirEp
} },
2542 { "pushU", { stackEv
} },
2543 { "(bad)", { XX
} },
2547 { "sldtD", { Sv
} },
2553 { "(bad)", { XX
} },
2554 { "(bad)", { XX
} },
2558 { MOD_TABLE (MOD_0F01_REG_0
) },
2559 { MOD_TABLE (MOD_0F01_REG_1
) },
2560 { MOD_TABLE (MOD_0F01_REG_2
) },
2561 { MOD_TABLE (MOD_0F01_REG_3
) },
2562 { "smswD", { Sv
} },
2563 { "(bad)", { XX
} },
2565 { MOD_TABLE (MOD_0F01_REG_7
) },
2569 { "prefetch", { Eb
} },
2570 { "prefetchw", { Eb
} },
2571 { "(bad)", { XX
} },
2572 { "(bad)", { XX
} },
2573 { "(bad)", { XX
} },
2574 { "(bad)", { XX
} },
2575 { "(bad)", { XX
} },
2576 { "(bad)", { XX
} },
2580 { MOD_TABLE (MOD_0F18_REG_0
) },
2581 { MOD_TABLE (MOD_0F18_REG_1
) },
2582 { MOD_TABLE (MOD_0F18_REG_2
) },
2583 { MOD_TABLE (MOD_0F18_REG_3
) },
2584 { "(bad)", { XX
} },
2585 { "(bad)", { XX
} },
2586 { "(bad)", { XX
} },
2587 { "(bad)", { XX
} },
2591 { "(bad)", { XX
} },
2592 { "(bad)", { XX
} },
2593 { MOD_TABLE (MOD_0F71_REG_2
) },
2594 { "(bad)", { XX
} },
2595 { MOD_TABLE (MOD_0F71_REG_4
) },
2596 { "(bad)", { XX
} },
2597 { MOD_TABLE (MOD_0F71_REG_6
) },
2598 { "(bad)", { XX
} },
2602 { "(bad)", { XX
} },
2603 { "(bad)", { XX
} },
2604 { MOD_TABLE (MOD_0F72_REG_2
) },
2605 { "(bad)", { XX
} },
2606 { MOD_TABLE (MOD_0F72_REG_4
) },
2607 { "(bad)", { XX
} },
2608 { MOD_TABLE (MOD_0F72_REG_6
) },
2609 { "(bad)", { XX
} },
2613 { "(bad)", { XX
} },
2614 { "(bad)", { XX
} },
2615 { MOD_TABLE (MOD_0F73_REG_2
) },
2616 { MOD_TABLE (MOD_0F73_REG_3
) },
2617 { "(bad)", { XX
} },
2618 { "(bad)", { XX
} },
2619 { MOD_TABLE (MOD_0F73_REG_6
) },
2620 { MOD_TABLE (MOD_0F73_REG_7
) },
2624 { "montmul", { { OP_0f07
, 0 } } },
2625 { "xsha1", { { OP_0f07
, 0 } } },
2626 { "xsha256", { { OP_0f07
, 0 } } },
2627 { "(bad)", { { OP_0f07
, 0 } } },
2628 { "(bad)", { { OP_0f07
, 0 } } },
2629 { "(bad)", { { OP_0f07
, 0 } } },
2630 { "(bad)", { { OP_0f07
, 0 } } },
2631 { "(bad)", { { OP_0f07
, 0 } } },
2635 { "xstore-rng", { { OP_0f07
, 0 } } },
2636 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2637 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2638 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2639 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2640 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2641 { "(bad)", { { OP_0f07
, 0 } } },
2642 { "(bad)", { { OP_0f07
, 0 } } },
2646 { MOD_TABLE (MOD_0FAE_REG_0
) },
2647 { MOD_TABLE (MOD_0FAE_REG_1
) },
2648 { MOD_TABLE (MOD_0FAE_REG_2
) },
2649 { MOD_TABLE (MOD_0FAE_REG_3
) },
2650 { MOD_TABLE (MOD_0FAE_REG_4
) },
2651 { MOD_TABLE (MOD_0FAE_REG_5
) },
2652 { MOD_TABLE (MOD_0FAE_REG_6
) },
2653 { MOD_TABLE (MOD_0FAE_REG_7
) },
2657 { "(bad)", { XX
} },
2658 { "(bad)", { XX
} },
2659 { "(bad)", { XX
} },
2660 { "(bad)", { XX
} },
2661 { "btQ", { Ev
, Ib
} },
2662 { "btsQ", { Ev
, Ib
} },
2663 { "btrQ", { Ev
, Ib
} },
2664 { "btcQ", { Ev
, Ib
} },
2668 { "(bad)", { XX
} },
2669 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2670 { "(bad)", { XX
} },
2671 { "(bad)", { XX
} },
2672 { "(bad)", { XX
} },
2673 { "(bad)", { XX
} },
2674 { MOD_TABLE (MOD_0FC7_REG_6
) },
2675 { MOD_TABLE (MOD_0FC7_REG_7
) },
2679 { "(bad)", { XX
} },
2680 { "(bad)", { XX
} },
2681 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2682 { "(bad)", { XX
} },
2683 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2684 { "(bad)", { XX
} },
2685 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2686 { "(bad)", { XX
} },
2690 { "(bad)", { XX
} },
2691 { "(bad)", { XX
} },
2692 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2693 { "(bad)", { XX
} },
2694 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2695 { "(bad)", { XX
} },
2696 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2697 { "(bad)", { XX
} },
2701 { "(bad)", { XX
} },
2702 { "(bad)", { XX
} },
2703 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2704 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2705 { "(bad)", { XX
} },
2706 { "(bad)", { XX
} },
2707 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2708 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2712 { "(bad)", { XX
} },
2713 { "(bad)", { XX
} },
2714 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2715 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2716 { "(bad)", { XX
} },
2717 { "(bad)", { XX
} },
2718 { "(bad)", { XX
} },
2719 { "(bad)", { XX
} },
2723 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2724 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2725 { "(bad)", { XX
} },
2726 { "(bad)", { XX
} },
2727 { "(bad)", { XX
} },
2728 { "(bad)", { XX
} },
2729 { "(bad)", { XX
} },
2730 { "(bad)", { XX
} },
2734 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2735 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2736 { "(bad)", { XX
} },
2737 { "(bad)", { XX
} },
2738 { "(bad)", { XX
} },
2739 { "(bad)", { XX
} },
2740 { "(bad)", { XX
} },
2741 { "(bad)", { XX
} },
2745 static const struct dis386 prefix_table
[][4] = {
2748 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2749 { "pause", { XX
} },
2750 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2751 { "(bad)", { XX
} },
2756 { "movups", { XM
, EXx
} },
2757 { "movss", { XM
, EXd
} },
2758 { "movupd", { XM
, EXx
} },
2759 { "movsd", { XM
, EXq
} },
2764 { "movups", { EXxS
, XM
} },
2765 { "movss", { EXdS
, XM
} },
2766 { "movupd", { EXxS
, XM
} },
2767 { "movsd", { EXqS
, XM
} },
2772 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2773 { "movsldup", { XM
, EXx
} },
2774 { "movlpd", { XM
, EXq
} },
2775 { "movddup", { XM
, EXq
} },
2780 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2781 { "movshdup", { XM
, EXx
} },
2782 { "movhpd", { XM
, EXq
} },
2783 { "(bad)", { XX
} },
2788 { "cvtpi2ps", { XM
, EMCq
} },
2789 { "cvtsi2ss%LQ", { XM
, Ev
} },
2790 { "cvtpi2pd", { XM
, EMCq
} },
2791 { "cvtsi2sd%LQ", { XM
, Ev
} },
2796 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2797 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2798 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2799 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2804 { "cvttps2pi", { MXC
, EXq
} },
2805 { "cvttss2siY", { Gv
, EXd
} },
2806 { "cvttpd2pi", { MXC
, EXx
} },
2807 { "cvttsd2siY", { Gv
, EXq
} },
2812 { "cvtps2pi", { MXC
, EXq
} },
2813 { "cvtss2siY", { Gv
, EXd
} },
2814 { "cvtpd2pi", { MXC
, EXx
} },
2815 { "cvtsd2siY", { Gv
, EXq
} },
2820 { "ucomiss",{ XM
, EXd
} },
2821 { "(bad)", { XX
} },
2822 { "ucomisd",{ XM
, EXq
} },
2823 { "(bad)", { XX
} },
2828 { "comiss", { XM
, EXd
} },
2829 { "(bad)", { XX
} },
2830 { "comisd", { XM
, EXq
} },
2831 { "(bad)", { XX
} },
2836 { "sqrtps", { XM
, EXx
} },
2837 { "sqrtss", { XM
, EXd
} },
2838 { "sqrtpd", { XM
, EXx
} },
2839 { "sqrtsd", { XM
, EXq
} },
2844 { "rsqrtps",{ XM
, EXx
} },
2845 { "rsqrtss",{ XM
, EXd
} },
2846 { "(bad)", { XX
} },
2847 { "(bad)", { XX
} },
2852 { "rcpps", { XM
, EXx
} },
2853 { "rcpss", { XM
, EXd
} },
2854 { "(bad)", { XX
} },
2855 { "(bad)", { XX
} },
2860 { "addps", { XM
, EXx
} },
2861 { "addss", { XM
, EXd
} },
2862 { "addpd", { XM
, EXx
} },
2863 { "addsd", { XM
, EXq
} },
2868 { "mulps", { XM
, EXx
} },
2869 { "mulss", { XM
, EXd
} },
2870 { "mulpd", { XM
, EXx
} },
2871 { "mulsd", { XM
, EXq
} },
2876 { "cvtps2pd", { XM
, EXq
} },
2877 { "cvtss2sd", { XM
, EXd
} },
2878 { "cvtpd2ps", { XM
, EXx
} },
2879 { "cvtsd2ss", { XM
, EXq
} },
2884 { "cvtdq2ps", { XM
, EXx
} },
2885 { "cvttps2dq", { XM
, EXx
} },
2886 { "cvtps2dq", { XM
, EXx
} },
2887 { "(bad)", { XX
} },
2892 { "subps", { XM
, EXx
} },
2893 { "subss", { XM
, EXd
} },
2894 { "subpd", { XM
, EXx
} },
2895 { "subsd", { XM
, EXq
} },
2900 { "minps", { XM
, EXx
} },
2901 { "minss", { XM
, EXd
} },
2902 { "minpd", { XM
, EXx
} },
2903 { "minsd", { XM
, EXq
} },
2908 { "divps", { XM
, EXx
} },
2909 { "divss", { XM
, EXd
} },
2910 { "divpd", { XM
, EXx
} },
2911 { "divsd", { XM
, EXq
} },
2916 { "maxps", { XM
, EXx
} },
2917 { "maxss", { XM
, EXd
} },
2918 { "maxpd", { XM
, EXx
} },
2919 { "maxsd", { XM
, EXq
} },
2924 { "punpcklbw",{ MX
, EMd
} },
2925 { "(bad)", { XX
} },
2926 { "punpcklbw",{ MX
, EMx
} },
2927 { "(bad)", { XX
} },
2932 { "punpcklwd",{ MX
, EMd
} },
2933 { "(bad)", { XX
} },
2934 { "punpcklwd",{ MX
, EMx
} },
2935 { "(bad)", { XX
} },
2940 { "punpckldq",{ MX
, EMd
} },
2941 { "(bad)", { XX
} },
2942 { "punpckldq",{ MX
, EMx
} },
2943 { "(bad)", { XX
} },
2948 { "(bad)", { XX
} },
2949 { "(bad)", { XX
} },
2950 { "punpcklqdq", { XM
, EXx
} },
2951 { "(bad)", { XX
} },
2956 { "(bad)", { XX
} },
2957 { "(bad)", { XX
} },
2958 { "punpckhqdq", { XM
, EXx
} },
2959 { "(bad)", { XX
} },
2964 { "movq", { MX
, EM
} },
2965 { "movdqu", { XM
, EXx
} },
2966 { "movdqa", { XM
, EXx
} },
2967 { "(bad)", { XX
} },
2972 { "pshufw", { MX
, EM
, Ib
} },
2973 { "pshufhw",{ XM
, EXx
, Ib
} },
2974 { "pshufd", { XM
, EXx
, Ib
} },
2975 { "pshuflw",{ XM
, EXx
, Ib
} },
2978 /* PREFIX_0F73_REG_3 */
2980 { "(bad)", { XX
} },
2981 { "(bad)", { XX
} },
2982 { "psrldq", { XS
, Ib
} },
2983 { "(bad)", { XX
} },
2986 /* PREFIX_0F73_REG_7 */
2988 { "(bad)", { XX
} },
2989 { "(bad)", { XX
} },
2990 { "pslldq", { XS
, Ib
} },
2991 { "(bad)", { XX
} },
2996 {"vmread", { Em
, Gm
} },
2998 {"extrq", { XS
, Ib
, Ib
} },
2999 {"insertq", { XM
, XS
, Ib
, Ib
} },
3004 {"vmwrite", { Gm
, Em
} },
3006 {"extrq", { XM
, XS
} },
3007 {"insertq", { XM
, XS
} },
3012 { "(bad)", { XX
} },
3013 { "(bad)", { XX
} },
3014 { "haddpd", { XM
, EXx
} },
3015 { "haddps", { XM
, EXx
} },
3020 { "(bad)", { XX
} },
3021 { "(bad)", { XX
} },
3022 { "hsubpd", { XM
, EXx
} },
3023 { "hsubps", { XM
, EXx
} },
3028 { "movK", { Edq
, MX
} },
3029 { "movq", { XM
, EXq
} },
3030 { "movK", { Edq
, XM
} },
3031 { "(bad)", { XX
} },
3036 { "movq", { EMS
, MX
} },
3037 { "movdqu", { EXxS
, XM
} },
3038 { "movdqa", { EXxS
, XM
} },
3039 { "(bad)", { XX
} },
3044 { "(bad)", { XX
} },
3045 { "popcntS", { Gv
, Ev
} },
3046 { "(bad)", { XX
} },
3047 { "(bad)", { XX
} },
3052 { "bsrS", { Gv
, Ev
} },
3053 { "lzcntS", { Gv
, Ev
} },
3054 { "bsrS", { Gv
, Ev
} },
3055 { "(bad)", { XX
} },
3060 { "cmpps", { XM
, EXx
, CMP
} },
3061 { "cmpss", { XM
, EXd
, CMP
} },
3062 { "cmppd", { XM
, EXx
, CMP
} },
3063 { "cmpsd", { XM
, EXq
, CMP
} },
3068 { "movntiS", { Ma
, Gv
} },
3069 { "(bad)", { XX
} },
3070 { "(bad)", { XX
} },
3071 { "(bad)", { XX
} },
3074 /* PREFIX_0FC7_REG_6 */
3076 { "vmptrld",{ Mq
} },
3077 { "vmxon", { Mq
} },
3078 { "vmclear",{ Mq
} },
3079 { "(bad)", { XX
} },
3084 { "(bad)", { XX
} },
3085 { "(bad)", { XX
} },
3086 { "addsubpd", { XM
, EXx
} },
3087 { "addsubps", { XM
, EXx
} },
3092 { "(bad)", { XX
} },
3093 { "movq2dq",{ XM
, MS
} },
3094 { "movq", { EXqS
, XM
} },
3095 { "movdq2q",{ MX
, XS
} },
3100 { "(bad)", { XX
} },
3101 { "cvtdq2pd", { XM
, EXq
} },
3102 { "cvttpd2dq", { XM
, EXx
} },
3103 { "cvtpd2dq", { XM
, EXx
} },
3108 { "movntq", { Mq
, MX
} },
3109 { "(bad)", { XX
} },
3110 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
3111 { "(bad)", { XX
} },
3116 { "(bad)", { XX
} },
3117 { "(bad)", { XX
} },
3118 { "(bad)", { XX
} },
3119 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
3124 { "maskmovq", { MX
, MS
} },
3125 { "(bad)", { XX
} },
3126 { "maskmovdqu", { XM
, XS
} },
3127 { "(bad)", { XX
} },
3132 { "(bad)", { XX
} },
3133 { "(bad)", { XX
} },
3134 { "pblendvb", { XM
, EXx
, XMM0
} },
3135 { "(bad)", { XX
} },
3140 { "(bad)", { XX
} },
3141 { "(bad)", { XX
} },
3142 { "blendvps", { XM
, EXx
, XMM0
} },
3143 { "(bad)", { XX
} },
3148 { "(bad)", { XX
} },
3149 { "(bad)", { XX
} },
3150 { "blendvpd", { XM
, EXx
, XMM0
} },
3151 { "(bad)", { XX
} },
3156 { "(bad)", { XX
} },
3157 { "(bad)", { XX
} },
3158 { "ptest", { XM
, EXx
} },
3159 { "(bad)", { XX
} },
3164 { "(bad)", { XX
} },
3165 { "(bad)", { XX
} },
3166 { "pmovsxbw", { XM
, EXq
} },
3167 { "(bad)", { XX
} },
3172 { "(bad)", { XX
} },
3173 { "(bad)", { XX
} },
3174 { "pmovsxbd", { XM
, EXd
} },
3175 { "(bad)", { XX
} },
3180 { "(bad)", { XX
} },
3181 { "(bad)", { XX
} },
3182 { "pmovsxbq", { XM
, EXw
} },
3183 { "(bad)", { XX
} },
3188 { "(bad)", { XX
} },
3189 { "(bad)", { XX
} },
3190 { "pmovsxwd", { XM
, EXq
} },
3191 { "(bad)", { XX
} },
3196 { "(bad)", { XX
} },
3197 { "(bad)", { XX
} },
3198 { "pmovsxwq", { XM
, EXd
} },
3199 { "(bad)", { XX
} },
3204 { "(bad)", { XX
} },
3205 { "(bad)", { XX
} },
3206 { "pmovsxdq", { XM
, EXq
} },
3207 { "(bad)", { XX
} },
3212 { "(bad)", { XX
} },
3213 { "(bad)", { XX
} },
3214 { "pmuldq", { XM
, EXx
} },
3215 { "(bad)", { XX
} },
3220 { "(bad)", { XX
} },
3221 { "(bad)", { XX
} },
3222 { "pcmpeqq", { XM
, EXx
} },
3223 { "(bad)", { XX
} },
3228 { "(bad)", { XX
} },
3229 { "(bad)", { XX
} },
3230 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
3231 { "(bad)", { XX
} },
3236 { "(bad)", { XX
} },
3237 { "(bad)", { XX
} },
3238 { "packusdw", { XM
, EXx
} },
3239 { "(bad)", { XX
} },
3244 { "(bad)", { XX
} },
3245 { "(bad)", { XX
} },
3246 { "pmovzxbw", { XM
, EXq
} },
3247 { "(bad)", { XX
} },
3252 { "(bad)", { XX
} },
3253 { "(bad)", { XX
} },
3254 { "pmovzxbd", { XM
, EXd
} },
3255 { "(bad)", { XX
} },
3260 { "(bad)", { XX
} },
3261 { "(bad)", { XX
} },
3262 { "pmovzxbq", { XM
, EXw
} },
3263 { "(bad)", { XX
} },
3268 { "(bad)", { XX
} },
3269 { "(bad)", { XX
} },
3270 { "pmovzxwd", { XM
, EXq
} },
3271 { "(bad)", { XX
} },
3276 { "(bad)", { XX
} },
3277 { "(bad)", { XX
} },
3278 { "pmovzxwq", { XM
, EXd
} },
3279 { "(bad)", { XX
} },
3284 { "(bad)", { XX
} },
3285 { "(bad)", { XX
} },
3286 { "pmovzxdq", { XM
, EXq
} },
3287 { "(bad)", { XX
} },
3292 { "(bad)", { XX
} },
3293 { "(bad)", { XX
} },
3294 { "pcmpgtq", { XM
, EXx
} },
3295 { "(bad)", { XX
} },
3300 { "(bad)", { XX
} },
3301 { "(bad)", { XX
} },
3302 { "pminsb", { XM
, EXx
} },
3303 { "(bad)", { XX
} },
3308 { "(bad)", { XX
} },
3309 { "(bad)", { XX
} },
3310 { "pminsd", { XM
, EXx
} },
3311 { "(bad)", { XX
} },
3316 { "(bad)", { XX
} },
3317 { "(bad)", { XX
} },
3318 { "pminuw", { XM
, EXx
} },
3319 { "(bad)", { XX
} },
3324 { "(bad)", { XX
} },
3325 { "(bad)", { XX
} },
3326 { "pminud", { XM
, EXx
} },
3327 { "(bad)", { XX
} },
3332 { "(bad)", { XX
} },
3333 { "(bad)", { XX
} },
3334 { "pmaxsb", { XM
, EXx
} },
3335 { "(bad)", { XX
} },
3340 { "(bad)", { XX
} },
3341 { "(bad)", { XX
} },
3342 { "pmaxsd", { XM
, EXx
} },
3343 { "(bad)", { XX
} },
3348 { "(bad)", { XX
} },
3349 { "(bad)", { XX
} },
3350 { "pmaxuw", { XM
, EXx
} },
3351 { "(bad)", { XX
} },
3356 { "(bad)", { XX
} },
3357 { "(bad)", { XX
} },
3358 { "pmaxud", { XM
, EXx
} },
3359 { "(bad)", { XX
} },
3364 { "(bad)", { XX
} },
3365 { "(bad)", { XX
} },
3366 { "pmulld", { XM
, EXx
} },
3367 { "(bad)", { XX
} },
3372 { "(bad)", { XX
} },
3373 { "(bad)", { XX
} },
3374 { "phminposuw", { XM
, EXx
} },
3375 { "(bad)", { XX
} },
3380 { "(bad)", { XX
} },
3381 { "(bad)", { XX
} },
3382 { "invept", { Gm
, Mo
} },
3383 { "(bad)", { XX
} },
3388 { "(bad)", { XX
} },
3389 { "(bad)", { XX
} },
3390 { "invvpid", { Gm
, Mo
} },
3391 { "(bad)", { XX
} },
3396 { "(bad)", { XX
} },
3397 { "(bad)", { XX
} },
3398 { "aesimc", { XM
, EXx
} },
3399 { "(bad)", { XX
} },
3404 { "(bad)", { XX
} },
3405 { "(bad)", { XX
} },
3406 { "aesenc", { XM
, EXx
} },
3407 { "(bad)", { XX
} },
3412 { "(bad)", { XX
} },
3413 { "(bad)", { XX
} },
3414 { "aesenclast", { XM
, EXx
} },
3415 { "(bad)", { XX
} },
3420 { "(bad)", { XX
} },
3421 { "(bad)", { XX
} },
3422 { "aesdec", { XM
, EXx
} },
3423 { "(bad)", { XX
} },
3428 { "(bad)", { XX
} },
3429 { "(bad)", { XX
} },
3430 { "aesdeclast", { XM
, EXx
} },
3431 { "(bad)", { XX
} },
3436 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3437 { "(bad)", { XX
} },
3438 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3439 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3444 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3445 { "(bad)", { XX
} },
3446 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3447 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3452 { "(bad)", { XX
} },
3453 { "(bad)", { XX
} },
3454 { "roundps", { XM
, EXx
, Ib
} },
3455 { "(bad)", { XX
} },
3460 { "(bad)", { XX
} },
3461 { "(bad)", { XX
} },
3462 { "roundpd", { XM
, EXx
, Ib
} },
3463 { "(bad)", { XX
} },
3468 { "(bad)", { XX
} },
3469 { "(bad)", { XX
} },
3470 { "roundss", { XM
, EXd
, Ib
} },
3471 { "(bad)", { XX
} },
3476 { "(bad)", { XX
} },
3477 { "(bad)", { XX
} },
3478 { "roundsd", { XM
, EXq
, Ib
} },
3479 { "(bad)", { XX
} },
3484 { "(bad)", { XX
} },
3485 { "(bad)", { XX
} },
3486 { "blendps", { XM
, EXx
, Ib
} },
3487 { "(bad)", { XX
} },
3492 { "(bad)", { XX
} },
3493 { "(bad)", { XX
} },
3494 { "blendpd", { XM
, EXx
, Ib
} },
3495 { "(bad)", { XX
} },
3500 { "(bad)", { XX
} },
3501 { "(bad)", { XX
} },
3502 { "pblendw", { XM
, EXx
, Ib
} },
3503 { "(bad)", { XX
} },
3508 { "(bad)", { XX
} },
3509 { "(bad)", { XX
} },
3510 { "pextrb", { Edqb
, XM
, Ib
} },
3511 { "(bad)", { XX
} },
3516 { "(bad)", { XX
} },
3517 { "(bad)", { XX
} },
3518 { "pextrw", { Edqw
, XM
, Ib
} },
3519 { "(bad)", { XX
} },
3524 { "(bad)", { XX
} },
3525 { "(bad)", { XX
} },
3526 { "pextrK", { Edq
, XM
, Ib
} },
3527 { "(bad)", { XX
} },
3532 { "(bad)", { XX
} },
3533 { "(bad)", { XX
} },
3534 { "extractps", { Edqd
, XM
, Ib
} },
3535 { "(bad)", { XX
} },
3540 { "(bad)", { XX
} },
3541 { "(bad)", { XX
} },
3542 { "pinsrb", { XM
, Edqb
, Ib
} },
3543 { "(bad)", { XX
} },
3548 { "(bad)", { XX
} },
3549 { "(bad)", { XX
} },
3550 { "insertps", { XM
, EXd
, Ib
} },
3551 { "(bad)", { XX
} },
3556 { "(bad)", { XX
} },
3557 { "(bad)", { XX
} },
3558 { "pinsrK", { XM
, Edq
, Ib
} },
3559 { "(bad)", { XX
} },
3564 { "(bad)", { XX
} },
3565 { "(bad)", { XX
} },
3566 { "dpps", { XM
, EXx
, Ib
} },
3567 { "(bad)", { XX
} },
3572 { "(bad)", { XX
} },
3573 { "(bad)", { XX
} },
3574 { "dppd", { XM
, EXx
, Ib
} },
3575 { "(bad)", { XX
} },
3580 { "(bad)", { XX
} },
3581 { "(bad)", { XX
} },
3582 { "mpsadbw", { XM
, EXx
, Ib
} },
3583 { "(bad)", { XX
} },
3588 { "(bad)", { XX
} },
3589 { "(bad)", { XX
} },
3590 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3591 { "(bad)", { XX
} },
3596 { "(bad)", { XX
} },
3597 { "(bad)", { XX
} },
3598 { "pcmpestrm", { XM
, EXx
, Ib
} },
3599 { "(bad)", { XX
} },
3604 { "(bad)", { XX
} },
3605 { "(bad)", { XX
} },
3606 { "pcmpestri", { XM
, EXx
, Ib
} },
3607 { "(bad)", { XX
} },
3612 { "(bad)", { XX
} },
3613 { "(bad)", { XX
} },
3614 { "pcmpistrm", { XM
, EXx
, Ib
} },
3615 { "(bad)", { XX
} },
3620 { "(bad)", { XX
} },
3621 { "(bad)", { XX
} },
3622 { "pcmpistri", { XM
, EXx
, Ib
} },
3623 { "(bad)", { XX
} },
3628 { "(bad)", { XX
} },
3629 { "(bad)", { XX
} },
3630 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3631 { "(bad)", { XX
} },
3636 { VEX_W_TABLE (VEX_W_10_P_0
) },
3637 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3638 { VEX_W_TABLE (VEX_W_10_P_2
) },
3639 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3644 { VEX_W_TABLE (VEX_W_11_P_0
) },
3645 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3646 { VEX_W_TABLE (VEX_W_11_P_2
) },
3647 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3652 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3653 { VEX_W_TABLE (VEX_W_12_P_1
) },
3654 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3655 { VEX_W_TABLE (VEX_W_12_P_3
) },
3660 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3661 { VEX_W_TABLE (VEX_W_16_P_1
) },
3662 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3663 { "(bad)", { XX
} },
3668 { "(bad)", { XX
} },
3669 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3670 { "(bad)", { XX
} },
3671 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3676 { "(bad)", { XX
} },
3677 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3678 { "(bad)", { XX
} },
3679 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3684 { "(bad)", { XX
} },
3685 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3686 { "(bad)", { XX
} },
3687 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3692 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3693 { "(bad)", { XX
} },
3694 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3695 { "(bad)", { XX
} },
3700 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3701 { "(bad)", { XX
} },
3702 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3703 { "(bad)", { XX
} },
3708 { VEX_W_TABLE (VEX_W_51_P_0
) },
3709 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3710 { VEX_W_TABLE (VEX_W_51_P_2
) },
3711 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3716 { VEX_W_TABLE (VEX_W_52_P_0
) },
3717 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3718 { "(bad)", { XX
} },
3719 { "(bad)", { XX
} },
3724 { VEX_W_TABLE (VEX_W_53_P_0
) },
3725 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3726 { "(bad)", { XX
} },
3727 { "(bad)", { XX
} },
3732 { VEX_W_TABLE (VEX_W_58_P_0
) },
3733 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3734 { VEX_W_TABLE (VEX_W_58_P_2
) },
3735 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3740 { VEX_W_TABLE (VEX_W_59_P_0
) },
3741 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3742 { VEX_W_TABLE (VEX_W_59_P_2
) },
3743 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3748 { VEX_W_TABLE (VEX_W_5A_P_0
) },
3749 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3750 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3751 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3756 { VEX_W_TABLE (VEX_W_5B_P_0
) },
3757 { VEX_W_TABLE (VEX_W_5B_P_1
) },
3758 { VEX_W_TABLE (VEX_W_5B_P_2
) },
3759 { "(bad)", { XX
} },
3764 { VEX_W_TABLE (VEX_W_5C_P_0
) },
3765 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3766 { VEX_W_TABLE (VEX_W_5C_P_2
) },
3767 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3772 { VEX_W_TABLE (VEX_W_5D_P_0
) },
3773 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3774 { VEX_W_TABLE (VEX_W_5D_P_2
) },
3775 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3780 { VEX_W_TABLE (VEX_W_5E_P_0
) },
3781 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3782 { VEX_W_TABLE (VEX_W_5E_P_2
) },
3783 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3788 { VEX_W_TABLE (VEX_W_5F_P_0
) },
3789 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3790 { VEX_W_TABLE (VEX_W_5F_P_2
) },
3791 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3796 { "(bad)", { XX
} },
3797 { "(bad)", { XX
} },
3798 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3799 { "(bad)", { XX
} },
3804 { "(bad)", { XX
} },
3805 { "(bad)", { XX
} },
3806 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3807 { "(bad)", { XX
} },
3812 { "(bad)", { XX
} },
3813 { "(bad)", { XX
} },
3814 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3815 { "(bad)", { XX
} },
3820 { "(bad)", { XX
} },
3821 { "(bad)", { XX
} },
3822 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3823 { "(bad)", { XX
} },
3828 { "(bad)", { XX
} },
3829 { "(bad)", { XX
} },
3830 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3831 { "(bad)", { XX
} },
3836 { "(bad)", { XX
} },
3837 { "(bad)", { XX
} },
3838 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3839 { "(bad)", { XX
} },
3844 { "(bad)", { XX
} },
3845 { "(bad)", { XX
} },
3846 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3847 { "(bad)", { XX
} },
3852 { "(bad)", { XX
} },
3853 { "(bad)", { XX
} },
3854 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3855 { "(bad)", { XX
} },
3860 { "(bad)", { XX
} },
3861 { "(bad)", { XX
} },
3862 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3863 { "(bad)", { XX
} },
3868 { "(bad)", { XX
} },
3869 { "(bad)", { XX
} },
3870 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3871 { "(bad)", { XX
} },
3876 { "(bad)", { XX
} },
3877 { "(bad)", { XX
} },
3878 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3879 { "(bad)", { XX
} },
3884 { "(bad)", { XX
} },
3885 { "(bad)", { XX
} },
3886 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3887 { "(bad)", { XX
} },
3892 { "(bad)", { XX
} },
3893 { "(bad)", { XX
} },
3894 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3895 { "(bad)", { XX
} },
3900 { "(bad)", { XX
} },
3901 { "(bad)", { XX
} },
3902 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3903 { "(bad)", { XX
} },
3908 { "(bad)", { XX
} },
3909 { "(bad)", { XX
} },
3910 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3911 { "(bad)", { XX
} },
3916 { "(bad)", { XX
} },
3917 { VEX_W_TABLE (VEX_W_6F_P_1
) },
3918 { VEX_W_TABLE (VEX_W_6F_P_2
) },
3919 { "(bad)", { XX
} },
3924 { "(bad)", { XX
} },
3925 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3926 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3927 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3930 /* PREFIX_VEX_71_REG_2 */
3932 { "(bad)", { XX
} },
3933 { "(bad)", { XX
} },
3934 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3935 { "(bad)", { XX
} },
3938 /* PREFIX_VEX_71_REG_4 */
3940 { "(bad)", { XX
} },
3941 { "(bad)", { XX
} },
3942 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3943 { "(bad)", { XX
} },
3946 /* PREFIX_VEX_71_REG_6 */
3948 { "(bad)", { XX
} },
3949 { "(bad)", { XX
} },
3950 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3951 { "(bad)", { XX
} },
3954 /* PREFIX_VEX_72_REG_2 */
3956 { "(bad)", { XX
} },
3957 { "(bad)", { XX
} },
3958 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3959 { "(bad)", { XX
} },
3962 /* PREFIX_VEX_72_REG_4 */
3964 { "(bad)", { XX
} },
3965 { "(bad)", { XX
} },
3966 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3967 { "(bad)", { XX
} },
3970 /* PREFIX_VEX_72_REG_6 */
3972 { "(bad)", { XX
} },
3973 { "(bad)", { XX
} },
3974 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3975 { "(bad)", { XX
} },
3978 /* PREFIX_VEX_73_REG_2 */
3980 { "(bad)", { XX
} },
3981 { "(bad)", { XX
} },
3982 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3983 { "(bad)", { XX
} },
3986 /* PREFIX_VEX_73_REG_3 */
3988 { "(bad)", { XX
} },
3989 { "(bad)", { XX
} },
3990 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3991 { "(bad)", { XX
} },
3994 /* PREFIX_VEX_73_REG_6 */
3996 { "(bad)", { XX
} },
3997 { "(bad)", { XX
} },
3998 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3999 { "(bad)", { XX
} },
4002 /* PREFIX_VEX_73_REG_7 */
4004 { "(bad)", { XX
} },
4005 { "(bad)", { XX
} },
4006 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
4007 { "(bad)", { XX
} },
4012 { "(bad)", { XX
} },
4013 { "(bad)", { XX
} },
4014 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
4015 { "(bad)", { XX
} },
4020 { "(bad)", { XX
} },
4021 { "(bad)", { XX
} },
4022 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
4023 { "(bad)", { XX
} },
4028 { "(bad)", { XX
} },
4029 { "(bad)", { XX
} },
4030 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
4031 { "(bad)", { XX
} },
4036 { VEX_W_TABLE (VEX_W_77_P_0
) },
4037 { "(bad)", { XX
} },
4038 { "(bad)", { XX
} },
4039 { "(bad)", { XX
} },
4044 { "(bad)", { XX
} },
4045 { "(bad)", { XX
} },
4046 { VEX_W_TABLE (VEX_W_7C_P_2
) },
4047 { VEX_W_TABLE (VEX_W_7C_P_3
) },
4052 { "(bad)", { XX
} },
4053 { "(bad)", { XX
} },
4054 { VEX_W_TABLE (VEX_W_7D_P_2
) },
4055 { VEX_W_TABLE (VEX_W_7D_P_3
) },
4060 { "(bad)", { XX
} },
4061 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
4062 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
4063 { "(bad)", { XX
} },
4068 { "(bad)", { XX
} },
4069 { VEX_W_TABLE (VEX_W_7F_P_1
) },
4070 { VEX_W_TABLE (VEX_W_7F_P_2
) },
4071 { "(bad)", { XX
} },
4076 { VEX_W_TABLE (VEX_W_C2_P_0
) },
4077 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
4078 { VEX_W_TABLE (VEX_W_C2_P_2
) },
4079 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
4084 { "(bad)", { XX
} },
4085 { "(bad)", { XX
} },
4086 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
4087 { "(bad)", { XX
} },
4092 { "(bad)", { XX
} },
4093 { "(bad)", { XX
} },
4094 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
4095 { "(bad)", { XX
} },
4100 { "(bad)", { XX
} },
4101 { "(bad)", { XX
} },
4102 { VEX_W_TABLE (VEX_W_D0_P_2
) },
4103 { VEX_W_TABLE (VEX_W_D0_P_3
) },
4108 { "(bad)", { XX
} },
4109 { "(bad)", { XX
} },
4110 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
4111 { "(bad)", { XX
} },
4116 { "(bad)", { XX
} },
4117 { "(bad)", { XX
} },
4118 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
4119 { "(bad)", { XX
} },
4124 { "(bad)", { XX
} },
4125 { "(bad)", { XX
} },
4126 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
4127 { "(bad)", { XX
} },
4132 { "(bad)", { XX
} },
4133 { "(bad)", { XX
} },
4134 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
4135 { "(bad)", { XX
} },
4140 { "(bad)", { XX
} },
4141 { "(bad)", { XX
} },
4142 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
4143 { "(bad)", { XX
} },
4148 { "(bad)", { XX
} },
4149 { "(bad)", { XX
} },
4150 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
4151 { "(bad)", { XX
} },
4156 { "(bad)", { XX
} },
4157 { "(bad)", { XX
} },
4158 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
4159 { "(bad)", { XX
} },
4164 { "(bad)", { XX
} },
4165 { "(bad)", { XX
} },
4166 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
4167 { "(bad)", { XX
} },
4172 { "(bad)", { XX
} },
4173 { "(bad)", { XX
} },
4174 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
4175 { "(bad)", { XX
} },
4180 { "(bad)", { XX
} },
4181 { "(bad)", { XX
} },
4182 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
4183 { "(bad)", { XX
} },
4188 { "(bad)", { XX
} },
4189 { "(bad)", { XX
} },
4190 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
4191 { "(bad)", { XX
} },
4196 { "(bad)", { XX
} },
4197 { "(bad)", { XX
} },
4198 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
4199 { "(bad)", { XX
} },
4204 { "(bad)", { XX
} },
4205 { "(bad)", { XX
} },
4206 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
4207 { "(bad)", { XX
} },
4212 { "(bad)", { XX
} },
4213 { "(bad)", { XX
} },
4214 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
4215 { "(bad)", { XX
} },
4220 { "(bad)", { XX
} },
4221 { "(bad)", { XX
} },
4222 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
4223 { "(bad)", { XX
} },
4228 { "(bad)", { XX
} },
4229 { "(bad)", { XX
} },
4230 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
4231 { "(bad)", { XX
} },
4236 { "(bad)", { XX
} },
4237 { "(bad)", { XX
} },
4238 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
4239 { "(bad)", { XX
} },
4244 { "(bad)", { XX
} },
4245 { "(bad)", { XX
} },
4246 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
4247 { "(bad)", { XX
} },
4252 { "(bad)", { XX
} },
4253 { "(bad)", { XX
} },
4254 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
4255 { "(bad)", { XX
} },
4260 { "(bad)", { XX
} },
4261 { "(bad)", { XX
} },
4262 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4263 { "(bad)", { XX
} },
4268 { "(bad)", { XX
} },
4269 { "(bad)", { XX
} },
4270 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4271 { "(bad)", { XX
} },
4276 { "(bad)", { XX
} },
4277 { VEX_W_TABLE (VEX_W_E6_P_1
) },
4278 { VEX_W_TABLE (VEX_W_E6_P_2
) },
4279 { VEX_W_TABLE (VEX_W_E6_P_3
) },
4284 { "(bad)", { XX
} },
4285 { "(bad)", { XX
} },
4286 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4287 { "(bad)", { XX
} },
4292 { "(bad)", { XX
} },
4293 { "(bad)", { XX
} },
4294 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4295 { "(bad)", { XX
} },
4300 { "(bad)", { XX
} },
4301 { "(bad)", { XX
} },
4302 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4303 { "(bad)", { XX
} },
4308 { "(bad)", { XX
} },
4309 { "(bad)", { XX
} },
4310 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4311 { "(bad)", { XX
} },
4316 { "(bad)", { XX
} },
4317 { "(bad)", { XX
} },
4318 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4319 { "(bad)", { XX
} },
4324 { "(bad)", { XX
} },
4325 { "(bad)", { XX
} },
4326 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4327 { "(bad)", { XX
} },
4332 { "(bad)", { XX
} },
4333 { "(bad)", { XX
} },
4334 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4335 { "(bad)", { XX
} },
4340 { "(bad)", { XX
} },
4341 { "(bad)", { XX
} },
4342 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4343 { "(bad)", { XX
} },
4348 { "(bad)", { XX
} },
4349 { "(bad)", { XX
} },
4350 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4351 { "(bad)", { XX
} },
4356 { "(bad)", { XX
} },
4357 { "(bad)", { XX
} },
4358 { "(bad)", { XX
} },
4359 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4364 { "(bad)", { XX
} },
4365 { "(bad)", { XX
} },
4366 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4367 { "(bad)", { XX
} },
4372 { "(bad)", { XX
} },
4373 { "(bad)", { XX
} },
4374 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4375 { "(bad)", { XX
} },
4380 { "(bad)", { XX
} },
4381 { "(bad)", { XX
} },
4382 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4383 { "(bad)", { XX
} },
4388 { "(bad)", { XX
} },
4389 { "(bad)", { XX
} },
4390 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4391 { "(bad)", { XX
} },
4396 { "(bad)", { XX
} },
4397 { "(bad)", { XX
} },
4398 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4399 { "(bad)", { XX
} },
4404 { "(bad)", { XX
} },
4405 { "(bad)", { XX
} },
4406 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4407 { "(bad)", { XX
} },
4412 { "(bad)", { XX
} },
4413 { "(bad)", { XX
} },
4414 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4415 { "(bad)", { XX
} },
4420 { "(bad)", { XX
} },
4421 { "(bad)", { XX
} },
4422 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4423 { "(bad)", { XX
} },
4428 { "(bad)", { XX
} },
4429 { "(bad)", { XX
} },
4430 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4431 { "(bad)", { XX
} },
4436 { "(bad)", { XX
} },
4437 { "(bad)", { XX
} },
4438 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4439 { "(bad)", { XX
} },
4444 { "(bad)", { XX
} },
4445 { "(bad)", { XX
} },
4446 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4447 { "(bad)", { XX
} },
4452 { "(bad)", { XX
} },
4453 { "(bad)", { XX
} },
4454 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4455 { "(bad)", { XX
} },
4460 { "(bad)", { XX
} },
4461 { "(bad)", { XX
} },
4462 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4463 { "(bad)", { XX
} },
4468 { "(bad)", { XX
} },
4469 { "(bad)", { XX
} },
4470 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4471 { "(bad)", { XX
} },
4474 /* PREFIX_VEX_3800 */
4476 { "(bad)", { XX
} },
4477 { "(bad)", { XX
} },
4478 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4479 { "(bad)", { XX
} },
4482 /* PREFIX_VEX_3801 */
4484 { "(bad)", { XX
} },
4485 { "(bad)", { XX
} },
4486 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4487 { "(bad)", { XX
} },
4490 /* PREFIX_VEX_3802 */
4492 { "(bad)", { XX
} },
4493 { "(bad)", { XX
} },
4494 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4495 { "(bad)", { XX
} },
4498 /* PREFIX_VEX_3803 */
4500 { "(bad)", { XX
} },
4501 { "(bad)", { XX
} },
4502 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4503 { "(bad)", { XX
} },
4506 /* PREFIX_VEX_3804 */
4508 { "(bad)", { XX
} },
4509 { "(bad)", { XX
} },
4510 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4511 { "(bad)", { XX
} },
4514 /* PREFIX_VEX_3805 */
4516 { "(bad)", { XX
} },
4517 { "(bad)", { XX
} },
4518 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4519 { "(bad)", { XX
} },
4522 /* PREFIX_VEX_3806 */
4524 { "(bad)", { XX
} },
4525 { "(bad)", { XX
} },
4526 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4527 { "(bad)", { XX
} },
4530 /* PREFIX_VEX_3807 */
4532 { "(bad)", { XX
} },
4533 { "(bad)", { XX
} },
4534 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4535 { "(bad)", { XX
} },
4538 /* PREFIX_VEX_3808 */
4540 { "(bad)", { XX
} },
4541 { "(bad)", { XX
} },
4542 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4543 { "(bad)", { XX
} },
4546 /* PREFIX_VEX_3809 */
4548 { "(bad)", { XX
} },
4549 { "(bad)", { XX
} },
4550 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4551 { "(bad)", { XX
} },
4554 /* PREFIX_VEX_380A */
4556 { "(bad)", { XX
} },
4557 { "(bad)", { XX
} },
4558 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4559 { "(bad)", { XX
} },
4562 /* PREFIX_VEX_380B */
4564 { "(bad)", { XX
} },
4565 { "(bad)", { XX
} },
4566 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4567 { "(bad)", { XX
} },
4570 /* PREFIX_VEX_380C */
4572 { "(bad)", { XX
} },
4573 { "(bad)", { XX
} },
4574 { VEX_W_TABLE (VEX_W_380C_P_2
) },
4575 { "(bad)", { XX
} },
4578 /* PREFIX_VEX_380D */
4580 { "(bad)", { XX
} },
4581 { "(bad)", { XX
} },
4582 { VEX_W_TABLE (VEX_W_380D_P_2
) },
4583 { "(bad)", { XX
} },
4586 /* PREFIX_VEX_380E */
4588 { "(bad)", { XX
} },
4589 { "(bad)", { XX
} },
4590 { VEX_W_TABLE (VEX_W_380E_P_2
) },
4591 { "(bad)", { XX
} },
4594 /* PREFIX_VEX_380F */
4596 { "(bad)", { XX
} },
4597 { "(bad)", { XX
} },
4598 { VEX_W_TABLE (VEX_W_380F_P_2
) },
4599 { "(bad)", { XX
} },
4602 /* PREFIX_VEX_3817 */
4604 { "(bad)", { XX
} },
4605 { "(bad)", { XX
} },
4606 { VEX_W_TABLE (VEX_W_3817_P_2
) },
4607 { "(bad)", { XX
} },
4610 /* PREFIX_VEX_3818 */
4612 { "(bad)", { XX
} },
4613 { "(bad)", { XX
} },
4614 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4615 { "(bad)", { XX
} },
4618 /* PREFIX_VEX_3819 */
4620 { "(bad)", { XX
} },
4621 { "(bad)", { XX
} },
4622 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4623 { "(bad)", { XX
} },
4626 /* PREFIX_VEX_381A */
4628 { "(bad)", { XX
} },
4629 { "(bad)", { XX
} },
4630 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4631 { "(bad)", { XX
} },
4634 /* PREFIX_VEX_381C */
4636 { "(bad)", { XX
} },
4637 { "(bad)", { XX
} },
4638 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4639 { "(bad)", { XX
} },
4642 /* PREFIX_VEX_381D */
4644 { "(bad)", { XX
} },
4645 { "(bad)", { XX
} },
4646 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4647 { "(bad)", { XX
} },
4650 /* PREFIX_VEX_381E */
4652 { "(bad)", { XX
} },
4653 { "(bad)", { XX
} },
4654 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4655 { "(bad)", { XX
} },
4658 /* PREFIX_VEX_3820 */
4660 { "(bad)", { XX
} },
4661 { "(bad)", { XX
} },
4662 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4663 { "(bad)", { XX
} },
4666 /* PREFIX_VEX_3821 */
4668 { "(bad)", { XX
} },
4669 { "(bad)", { XX
} },
4670 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4671 { "(bad)", { XX
} },
4674 /* PREFIX_VEX_3822 */
4676 { "(bad)", { XX
} },
4677 { "(bad)", { XX
} },
4678 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4679 { "(bad)", { XX
} },
4682 /* PREFIX_VEX_3823 */
4684 { "(bad)", { XX
} },
4685 { "(bad)", { XX
} },
4686 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4687 { "(bad)", { XX
} },
4690 /* PREFIX_VEX_3824 */
4692 { "(bad)", { XX
} },
4693 { "(bad)", { XX
} },
4694 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4695 { "(bad)", { XX
} },
4698 /* PREFIX_VEX_3825 */
4700 { "(bad)", { XX
} },
4701 { "(bad)", { XX
} },
4702 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4703 { "(bad)", { XX
} },
4706 /* PREFIX_VEX_3828 */
4708 { "(bad)", { XX
} },
4709 { "(bad)", { XX
} },
4710 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4711 { "(bad)", { XX
} },
4714 /* PREFIX_VEX_3829 */
4716 { "(bad)", { XX
} },
4717 { "(bad)", { XX
} },
4718 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4719 { "(bad)", { XX
} },
4722 /* PREFIX_VEX_382A */
4724 { "(bad)", { XX
} },
4725 { "(bad)", { XX
} },
4726 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4727 { "(bad)", { XX
} },
4730 /* PREFIX_VEX_382B */
4732 { "(bad)", { XX
} },
4733 { "(bad)", { XX
} },
4734 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4735 { "(bad)", { XX
} },
4738 /* PREFIX_VEX_382C */
4740 { "(bad)", { XX
} },
4741 { "(bad)", { XX
} },
4742 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4743 { "(bad)", { XX
} },
4746 /* PREFIX_VEX_382D */
4748 { "(bad)", { XX
} },
4749 { "(bad)", { XX
} },
4750 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4751 { "(bad)", { XX
} },
4754 /* PREFIX_VEX_382E */
4756 { "(bad)", { XX
} },
4757 { "(bad)", { XX
} },
4758 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4759 { "(bad)", { XX
} },
4762 /* PREFIX_VEX_382F */
4764 { "(bad)", { XX
} },
4765 { "(bad)", { XX
} },
4766 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4767 { "(bad)", { XX
} },
4770 /* PREFIX_VEX_3830 */
4772 { "(bad)", { XX
} },
4773 { "(bad)", { XX
} },
4774 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4775 { "(bad)", { XX
} },
4778 /* PREFIX_VEX_3831 */
4780 { "(bad)", { XX
} },
4781 { "(bad)", { XX
} },
4782 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4783 { "(bad)", { XX
} },
4786 /* PREFIX_VEX_3832 */
4788 { "(bad)", { XX
} },
4789 { "(bad)", { XX
} },
4790 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4791 { "(bad)", { XX
} },
4794 /* PREFIX_VEX_3833 */
4796 { "(bad)", { XX
} },
4797 { "(bad)", { XX
} },
4798 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4799 { "(bad)", { XX
} },
4802 /* PREFIX_VEX_3834 */
4804 { "(bad)", { XX
} },
4805 { "(bad)", { XX
} },
4806 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4807 { "(bad)", { XX
} },
4810 /* PREFIX_VEX_3835 */
4812 { "(bad)", { XX
} },
4813 { "(bad)", { XX
} },
4814 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4815 { "(bad)", { XX
} },
4818 /* PREFIX_VEX_3837 */
4820 { "(bad)", { XX
} },
4821 { "(bad)", { XX
} },
4822 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4823 { "(bad)", { XX
} },
4826 /* PREFIX_VEX_3838 */
4828 { "(bad)", { XX
} },
4829 { "(bad)", { XX
} },
4830 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4831 { "(bad)", { XX
} },
4834 /* PREFIX_VEX_3839 */
4836 { "(bad)", { XX
} },
4837 { "(bad)", { XX
} },
4838 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4839 { "(bad)", { XX
} },
4842 /* PREFIX_VEX_383A */
4844 { "(bad)", { XX
} },
4845 { "(bad)", { XX
} },
4846 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4847 { "(bad)", { XX
} },
4850 /* PREFIX_VEX_383B */
4852 { "(bad)", { XX
} },
4853 { "(bad)", { XX
} },
4854 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4855 { "(bad)", { XX
} },
4858 /* PREFIX_VEX_383C */
4860 { "(bad)", { XX
} },
4861 { "(bad)", { XX
} },
4862 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4863 { "(bad)", { XX
} },
4866 /* PREFIX_VEX_383D */
4868 { "(bad)", { XX
} },
4869 { "(bad)", { XX
} },
4870 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4871 { "(bad)", { XX
} },
4874 /* PREFIX_VEX_383E */
4876 { "(bad)", { XX
} },
4877 { "(bad)", { XX
} },
4878 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4879 { "(bad)", { XX
} },
4882 /* PREFIX_VEX_383F */
4884 { "(bad)", { XX
} },
4885 { "(bad)", { XX
} },
4886 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4887 { "(bad)", { XX
} },
4890 /* PREFIX_VEX_3840 */
4892 { "(bad)", { XX
} },
4893 { "(bad)", { XX
} },
4894 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4895 { "(bad)", { XX
} },
4898 /* PREFIX_VEX_3841 */
4900 { "(bad)", { XX
} },
4901 { "(bad)", { XX
} },
4902 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4903 { "(bad)", { XX
} },
4906 /* PREFIX_VEX_3896 */
4908 { "(bad)", { XX
} },
4909 { "(bad)", { XX
} },
4910 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4911 { "(bad)", { XX
} },
4914 /* PREFIX_VEX_3897 */
4916 { "(bad)", { XX
} },
4917 { "(bad)", { XX
} },
4918 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4919 { "(bad)", { XX
} },
4922 /* PREFIX_VEX_3898 */
4924 { "(bad)", { XX
} },
4925 { "(bad)", { XX
} },
4926 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4927 { "(bad)", { XX
} },
4930 /* PREFIX_VEX_3899 */
4932 { "(bad)", { XX
} },
4933 { "(bad)", { XX
} },
4934 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4935 { "(bad)", { XX
} },
4938 /* PREFIX_VEX_389A */
4940 { "(bad)", { XX
} },
4941 { "(bad)", { XX
} },
4942 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4943 { "(bad)", { XX
} },
4946 /* PREFIX_VEX_389B */
4948 { "(bad)", { XX
} },
4949 { "(bad)", { XX
} },
4950 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4951 { "(bad)", { XX
} },
4954 /* PREFIX_VEX_389C */
4956 { "(bad)", { XX
} },
4957 { "(bad)", { XX
} },
4958 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4959 { "(bad)", { XX
} },
4962 /* PREFIX_VEX_389D */
4964 { "(bad)", { XX
} },
4965 { "(bad)", { XX
} },
4966 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4967 { "(bad)", { XX
} },
4970 /* PREFIX_VEX_389E */
4972 { "(bad)", { XX
} },
4973 { "(bad)", { XX
} },
4974 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4975 { "(bad)", { XX
} },
4978 /* PREFIX_VEX_389F */
4980 { "(bad)", { XX
} },
4981 { "(bad)", { XX
} },
4982 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4983 { "(bad)", { XX
} },
4986 /* PREFIX_VEX_38A6 */
4988 { "(bad)", { XX
} },
4989 { "(bad)", { XX
} },
4990 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4991 { "(bad)", { XX
} },
4994 /* PREFIX_VEX_38A7 */
4996 { "(bad)", { XX
} },
4997 { "(bad)", { XX
} },
4998 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4999 { "(bad)", { XX
} },
5002 /* PREFIX_VEX_38A8 */
5004 { "(bad)", { XX
} },
5005 { "(bad)", { XX
} },
5006 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
5007 { "(bad)", { XX
} },
5010 /* PREFIX_VEX_38A9 */
5012 { "(bad)", { XX
} },
5013 { "(bad)", { XX
} },
5014 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
5015 { "(bad)", { XX
} },
5018 /* PREFIX_VEX_38AA */
5020 { "(bad)", { XX
} },
5021 { "(bad)", { XX
} },
5022 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
5023 { "(bad)", { XX
} },
5026 /* PREFIX_VEX_38AB */
5028 { "(bad)", { XX
} },
5029 { "(bad)", { XX
} },
5030 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
5031 { "(bad)", { XX
} },
5034 /* PREFIX_VEX_38AC */
5036 { "(bad)", { XX
} },
5037 { "(bad)", { XX
} },
5038 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
5039 { "(bad)", { XX
} },
5042 /* PREFIX_VEX_38AD */
5044 { "(bad)", { XX
} },
5045 { "(bad)", { XX
} },
5046 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
5047 { "(bad)", { XX
} },
5050 /* PREFIX_VEX_38AE */
5052 { "(bad)", { XX
} },
5053 { "(bad)", { XX
} },
5054 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
5055 { "(bad)", { XX
} },
5058 /* PREFIX_VEX_38AF */
5060 { "(bad)", { XX
} },
5061 { "(bad)", { XX
} },
5062 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
5063 { "(bad)", { XX
} },
5066 /* PREFIX_VEX_38B6 */
5068 { "(bad)", { XX
} },
5069 { "(bad)", { XX
} },
5070 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
5071 { "(bad)", { XX
} },
5074 /* PREFIX_VEX_38B7 */
5076 { "(bad)", { XX
} },
5077 { "(bad)", { XX
} },
5078 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
5079 { "(bad)", { XX
} },
5082 /* PREFIX_VEX_38B8 */
5084 { "(bad)", { XX
} },
5085 { "(bad)", { XX
} },
5086 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
5087 { "(bad)", { XX
} },
5090 /* PREFIX_VEX_38B9 */
5092 { "(bad)", { XX
} },
5093 { "(bad)", { XX
} },
5094 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
5095 { "(bad)", { XX
} },
5098 /* PREFIX_VEX_38BA */
5100 { "(bad)", { XX
} },
5101 { "(bad)", { XX
} },
5102 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
5103 { "(bad)", { XX
} },
5106 /* PREFIX_VEX_38BB */
5108 { "(bad)", { XX
} },
5109 { "(bad)", { XX
} },
5110 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
5111 { "(bad)", { XX
} },
5114 /* PREFIX_VEX_38BC */
5116 { "(bad)", { XX
} },
5117 { "(bad)", { XX
} },
5118 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
5119 { "(bad)", { XX
} },
5122 /* PREFIX_VEX_38BD */
5124 { "(bad)", { XX
} },
5125 { "(bad)", { XX
} },
5126 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
5127 { "(bad)", { XX
} },
5130 /* PREFIX_VEX_38BE */
5132 { "(bad)", { XX
} },
5133 { "(bad)", { XX
} },
5134 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
5135 { "(bad)", { XX
} },
5138 /* PREFIX_VEX_38BF */
5140 { "(bad)", { XX
} },
5141 { "(bad)", { XX
} },
5142 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
5143 { "(bad)", { XX
} },
5146 /* PREFIX_VEX_38DB */
5148 { "(bad)", { XX
} },
5149 { "(bad)", { XX
} },
5150 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
5151 { "(bad)", { XX
} },
5154 /* PREFIX_VEX_38DC */
5156 { "(bad)", { XX
} },
5157 { "(bad)", { XX
} },
5158 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
5159 { "(bad)", { XX
} },
5162 /* PREFIX_VEX_38DD */
5164 { "(bad)", { XX
} },
5165 { "(bad)", { XX
} },
5166 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
5167 { "(bad)", { XX
} },
5170 /* PREFIX_VEX_38DE */
5172 { "(bad)", { XX
} },
5173 { "(bad)", { XX
} },
5174 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
5175 { "(bad)", { XX
} },
5178 /* PREFIX_VEX_38DF */
5180 { "(bad)", { XX
} },
5181 { "(bad)", { XX
} },
5182 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
5183 { "(bad)", { XX
} },
5186 /* PREFIX_VEX_3A04 */
5188 { "(bad)", { XX
} },
5189 { "(bad)", { XX
} },
5190 { VEX_W_TABLE (VEX_W_3A04_P_2
) },
5191 { "(bad)", { XX
} },
5194 /* PREFIX_VEX_3A05 */
5196 { "(bad)", { XX
} },
5197 { "(bad)", { XX
} },
5198 { VEX_W_TABLE (VEX_W_3A05_P_2
) },
5199 { "(bad)", { XX
} },
5202 /* PREFIX_VEX_3A06 */
5204 { "(bad)", { XX
} },
5205 { "(bad)", { XX
} },
5206 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
5207 { "(bad)", { XX
} },
5210 /* PREFIX_VEX_3A08 */
5212 { "(bad)", { XX
} },
5213 { "(bad)", { XX
} },
5214 { VEX_W_TABLE (VEX_W_3A08_P_2
) },
5215 { "(bad)", { XX
} },
5218 /* PREFIX_VEX_3A09 */
5220 { "(bad)", { XX
} },
5221 { "(bad)", { XX
} },
5222 { VEX_W_TABLE (VEX_W_3A09_P_2
) },
5223 { "(bad)", { XX
} },
5226 /* PREFIX_VEX_3A0A */
5228 { "(bad)", { XX
} },
5229 { "(bad)", { XX
} },
5230 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
5231 { "(bad)", { XX
} },
5234 /* PREFIX_VEX_3A0B */
5236 { "(bad)", { XX
} },
5237 { "(bad)", { XX
} },
5238 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
5239 { "(bad)", { XX
} },
5242 /* PREFIX_VEX_3A0C */
5244 { "(bad)", { XX
} },
5245 { "(bad)", { XX
} },
5246 { VEX_W_TABLE (VEX_W_3A0C_P_2
) },
5247 { "(bad)", { XX
} },
5250 /* PREFIX_VEX_3A0D */
5252 { "(bad)", { XX
} },
5253 { "(bad)", { XX
} },
5254 { VEX_W_TABLE (VEX_W_3A0D_P_2
) },
5255 { "(bad)", { XX
} },
5258 /* PREFIX_VEX_3A0E */
5260 { "(bad)", { XX
} },
5261 { "(bad)", { XX
} },
5262 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
5263 { "(bad)", { XX
} },
5266 /* PREFIX_VEX_3A0F */
5268 { "(bad)", { XX
} },
5269 { "(bad)", { XX
} },
5270 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
5271 { "(bad)", { XX
} },
5274 /* PREFIX_VEX_3A14 */
5276 { "(bad)", { XX
} },
5277 { "(bad)", { XX
} },
5278 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5279 { "(bad)", { XX
} },
5282 /* PREFIX_VEX_3A15 */
5284 { "(bad)", { XX
} },
5285 { "(bad)", { XX
} },
5286 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5287 { "(bad)", { XX
} },
5290 /* PREFIX_VEX_3A16 */
5292 { "(bad)", { XX
} },
5293 { "(bad)", { XX
} },
5294 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5295 { "(bad)", { XX
} },
5298 /* PREFIX_VEX_3A17 */
5300 { "(bad)", { XX
} },
5301 { "(bad)", { XX
} },
5302 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5303 { "(bad)", { XX
} },
5306 /* PREFIX_VEX_3A18 */
5308 { "(bad)", { XX
} },
5309 { "(bad)", { XX
} },
5310 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5311 { "(bad)", { XX
} },
5314 /* PREFIX_VEX_3A19 */
5316 { "(bad)", { XX
} },
5317 { "(bad)", { XX
} },
5318 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5319 { "(bad)", { XX
} },
5322 /* PREFIX_VEX_3A20 */
5324 { "(bad)", { XX
} },
5325 { "(bad)", { XX
} },
5326 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5327 { "(bad)", { XX
} },
5330 /* PREFIX_VEX_3A21 */
5332 { "(bad)", { XX
} },
5333 { "(bad)", { XX
} },
5334 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5335 { "(bad)", { XX
} },
5338 /* PREFIX_VEX_3A22 */
5340 { "(bad)", { XX
} },
5341 { "(bad)", { XX
} },
5342 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5343 { "(bad)", { XX
} },
5346 /* PREFIX_VEX_3A40 */
5348 { "(bad)", { XX
} },
5349 { "(bad)", { XX
} },
5350 { VEX_W_TABLE (VEX_W_3A40_P_2
) },
5351 { "(bad)", { XX
} },
5354 /* PREFIX_VEX_3A41 */
5356 { "(bad)", { XX
} },
5357 { "(bad)", { XX
} },
5358 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5359 { "(bad)", { XX
} },
5362 /* PREFIX_VEX_3A42 */
5364 { "(bad)", { XX
} },
5365 { "(bad)", { XX
} },
5366 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5367 { "(bad)", { XX
} },
5370 /* PREFIX_VEX_3A44 */
5372 { "(bad)", { XX
} },
5373 { "(bad)", { XX
} },
5374 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5375 { "(bad)", { XX
} },
5378 /* PREFIX_VEX_3A4A */
5380 { "(bad)", { XX
} },
5381 { "(bad)", { XX
} },
5382 { VEX_W_TABLE (VEX_W_3A4A_P_2
) },
5383 { "(bad)", { XX
} },
5386 /* PREFIX_VEX_3A4B */
5388 { "(bad)", { XX
} },
5389 { "(bad)", { XX
} },
5390 { VEX_W_TABLE (VEX_W_3A4B_P_2
) },
5391 { "(bad)", { XX
} },
5394 /* PREFIX_VEX_3A4C */
5396 { "(bad)", { XX
} },
5397 { "(bad)", { XX
} },
5398 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5399 { "(bad)", { XX
} },
5402 /* PREFIX_VEX_3A5C */
5404 { "(bad)", { XX
} },
5405 { "(bad)", { XX
} },
5406 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5407 { "(bad)", { XX
} },
5410 /* PREFIX_VEX_3A5D */
5412 { "(bad)", { XX
} },
5413 { "(bad)", { XX
} },
5414 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5415 { "(bad)", { XX
} },
5418 /* PREFIX_VEX_3A5E */
5420 { "(bad)", { XX
} },
5421 { "(bad)", { XX
} },
5422 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5423 { "(bad)", { XX
} },
5426 /* PREFIX_VEX_3A5F */
5428 { "(bad)", { XX
} },
5429 { "(bad)", { XX
} },
5430 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5431 { "(bad)", { XX
} },
5434 /* PREFIX_VEX_3A60 */
5436 { "(bad)", { XX
} },
5437 { "(bad)", { XX
} },
5438 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5439 { "(bad)", { XX
} },
5442 /* PREFIX_VEX_3A61 */
5444 { "(bad)", { XX
} },
5445 { "(bad)", { XX
} },
5446 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5447 { "(bad)", { XX
} },
5450 /* PREFIX_VEX_3A62 */
5452 { "(bad)", { XX
} },
5453 { "(bad)", { XX
} },
5454 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5455 { "(bad)", { XX
} },
5458 /* PREFIX_VEX_3A63 */
5460 { "(bad)", { XX
} },
5461 { "(bad)", { XX
} },
5462 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5463 { "(bad)", { XX
} },
5466 /* PREFIX_VEX_3A68 */
5468 { "(bad)", { XX
} },
5469 { "(bad)", { XX
} },
5470 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5471 { "(bad)", { XX
} },
5474 /* PREFIX_VEX_3A69 */
5476 { "(bad)", { XX
} },
5477 { "(bad)", { XX
} },
5478 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5479 { "(bad)", { XX
} },
5482 /* PREFIX_VEX_3A6A */
5484 { "(bad)", { XX
} },
5485 { "(bad)", { XX
} },
5486 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5487 { "(bad)", { XX
} },
5490 /* PREFIX_VEX_3A6B */
5492 { "(bad)", { XX
} },
5493 { "(bad)", { XX
} },
5494 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5495 { "(bad)", { XX
} },
5498 /* PREFIX_VEX_3A6C */
5500 { "(bad)", { XX
} },
5501 { "(bad)", { XX
} },
5502 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5503 { "(bad)", { XX
} },
5506 /* PREFIX_VEX_3A6D */
5508 { "(bad)", { XX
} },
5509 { "(bad)", { XX
} },
5510 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5511 { "(bad)", { XX
} },
5514 /* PREFIX_VEX_3A6E */
5516 { "(bad)", { XX
} },
5517 { "(bad)", { XX
} },
5518 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5519 { "(bad)", { XX
} },
5522 /* PREFIX_VEX_3A6F */
5524 { "(bad)", { XX
} },
5525 { "(bad)", { XX
} },
5526 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5527 { "(bad)", { XX
} },
5530 /* PREFIX_VEX_3A78 */
5532 { "(bad)", { XX
} },
5533 { "(bad)", { XX
} },
5534 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5535 { "(bad)", { XX
} },
5538 /* PREFIX_VEX_3A79 */
5540 { "(bad)", { XX
} },
5541 { "(bad)", { XX
} },
5542 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5543 { "(bad)", { XX
} },
5546 /* PREFIX_VEX_3A7A */
5548 { "(bad)", { XX
} },
5549 { "(bad)", { XX
} },
5550 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5551 { "(bad)", { XX
} },
5554 /* PREFIX_VEX_3A7B */
5556 { "(bad)", { XX
} },
5557 { "(bad)", { XX
} },
5558 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5559 { "(bad)", { XX
} },
5562 /* PREFIX_VEX_3A7C */
5564 { "(bad)", { XX
} },
5565 { "(bad)", { XX
} },
5566 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5567 { "(bad)", { XX
} },
5570 /* PREFIX_VEX_3A7D */
5572 { "(bad)", { XX
} },
5573 { "(bad)", { XX
} },
5574 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5575 { "(bad)", { XX
} },
5578 /* PREFIX_VEX_3A7E */
5580 { "(bad)", { XX
} },
5581 { "(bad)", { XX
} },
5582 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5583 { "(bad)", { XX
} },
5586 /* PREFIX_VEX_3A7F */
5588 { "(bad)", { XX
} },
5589 { "(bad)", { XX
} },
5590 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5591 { "(bad)", { XX
} },
5594 /* PREFIX_VEX_3ADF */
5596 { "(bad)", { XX
} },
5597 { "(bad)", { XX
} },
5598 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5599 { "(bad)", { XX
} },
5603 static const struct dis386 x86_64_table
[][2] = {
5606 { "push{T|}", { es
} },
5607 { "(bad)", { XX
} },
5612 { "pop{T|}", { es
} },
5613 { "(bad)", { XX
} },
5618 { "push{T|}", { cs
} },
5619 { "(bad)", { XX
} },
5624 { "push{T|}", { ss
} },
5625 { "(bad)", { XX
} },
5630 { "pop{T|}", { ss
} },
5631 { "(bad)", { XX
} },
5636 { "push{T|}", { ds
} },
5637 { "(bad)", { XX
} },
5642 { "pop{T|}", { ds
} },
5643 { "(bad)", { XX
} },
5649 { "(bad)", { XX
} },
5655 { "(bad)", { XX
} },
5661 { "(bad)", { XX
} },
5667 { "(bad)", { XX
} },
5672 { "pusha{P|}", { XX
} },
5673 { "(bad)", { XX
} },
5678 { "popa{P|}", { XX
} },
5679 { "(bad)", { XX
} },
5684 { MOD_TABLE (MOD_62_32BIT
) },
5685 { "(bad)", { XX
} },
5690 { "arpl", { Ew
, Gw
} },
5691 { "movs{lq|xd}", { Gv
, Ed
} },
5696 { "ins{R|}", { Yzr
, indirDX
} },
5697 { "ins{G|}", { Yzr
, indirDX
} },
5702 { "outs{R|}", { indirDXr
, Xz
} },
5703 { "outs{G|}", { indirDXr
, Xz
} },
5708 { "Jcall{T|}", { Ap
} },
5709 { "(bad)", { XX
} },
5714 { MOD_TABLE (MOD_C4_32BIT
) },
5715 { VEX_C4_TABLE (VEX_0F
) },
5720 { MOD_TABLE (MOD_C5_32BIT
) },
5721 { VEX_C5_TABLE (VEX_0F
) },
5727 { "(bad)", { XX
} },
5733 { "(bad)", { XX
} },
5739 { "(bad)", { XX
} },
5744 { "Jjmp{T|}", { Ap
} },
5745 { "(bad)", { XX
} },
5748 /* X86_64_0F01_REG_0 */
5750 { "sgdt{Q|IQ}", { M
} },
5754 /* X86_64_0F01_REG_1 */
5756 { "sidt{Q|IQ}", { M
} },
5760 /* X86_64_0F01_REG_2 */
5762 { "lgdt{Q|Q}", { M
} },
5766 /* X86_64_0F01_REG_3 */
5768 { "lidt{Q|Q}", { M
} },
5773 static const struct dis386 three_byte_table
[][256] = {
5775 /* THREE_BYTE_0F38 */
5778 { "pshufb", { MX
, EM
} },
5779 { "phaddw", { MX
, EM
} },
5780 { "phaddd", { MX
, EM
} },
5781 { "phaddsw", { MX
, EM
} },
5782 { "pmaddubsw", { MX
, EM
} },
5783 { "phsubw", { MX
, EM
} },
5784 { "phsubd", { MX
, EM
} },
5785 { "phsubsw", { MX
, EM
} },
5787 { "psignb", { MX
, EM
} },
5788 { "psignw", { MX
, EM
} },
5789 { "psignd", { MX
, EM
} },
5790 { "pmulhrsw", { MX
, EM
} },
5791 { "(bad)", { XX
} },
5792 { "(bad)", { XX
} },
5793 { "(bad)", { XX
} },
5794 { "(bad)", { XX
} },
5796 { PREFIX_TABLE (PREFIX_0F3810
) },
5797 { "(bad)", { XX
} },
5798 { "(bad)", { XX
} },
5799 { "(bad)", { XX
} },
5800 { PREFIX_TABLE (PREFIX_0F3814
) },
5801 { PREFIX_TABLE (PREFIX_0F3815
) },
5802 { "(bad)", { XX
} },
5803 { PREFIX_TABLE (PREFIX_0F3817
) },
5805 { "(bad)", { XX
} },
5806 { "(bad)", { XX
} },
5807 { "(bad)", { XX
} },
5808 { "(bad)", { XX
} },
5809 { "pabsb", { MX
, EM
} },
5810 { "pabsw", { MX
, EM
} },
5811 { "pabsd", { MX
, EM
} },
5812 { "(bad)", { XX
} },
5814 { PREFIX_TABLE (PREFIX_0F3820
) },
5815 { PREFIX_TABLE (PREFIX_0F3821
) },
5816 { PREFIX_TABLE (PREFIX_0F3822
) },
5817 { PREFIX_TABLE (PREFIX_0F3823
) },
5818 { PREFIX_TABLE (PREFIX_0F3824
) },
5819 { PREFIX_TABLE (PREFIX_0F3825
) },
5820 { "(bad)", { XX
} },
5821 { "(bad)", { XX
} },
5823 { PREFIX_TABLE (PREFIX_0F3828
) },
5824 { PREFIX_TABLE (PREFIX_0F3829
) },
5825 { PREFIX_TABLE (PREFIX_0F382A
) },
5826 { PREFIX_TABLE (PREFIX_0F382B
) },
5827 { "(bad)", { XX
} },
5828 { "(bad)", { XX
} },
5829 { "(bad)", { XX
} },
5830 { "(bad)", { XX
} },
5832 { PREFIX_TABLE (PREFIX_0F3830
) },
5833 { PREFIX_TABLE (PREFIX_0F3831
) },
5834 { PREFIX_TABLE (PREFIX_0F3832
) },
5835 { PREFIX_TABLE (PREFIX_0F3833
) },
5836 { PREFIX_TABLE (PREFIX_0F3834
) },
5837 { PREFIX_TABLE (PREFIX_0F3835
) },
5838 { "(bad)", { XX
} },
5839 { PREFIX_TABLE (PREFIX_0F3837
) },
5841 { PREFIX_TABLE (PREFIX_0F3838
) },
5842 { PREFIX_TABLE (PREFIX_0F3839
) },
5843 { PREFIX_TABLE (PREFIX_0F383A
) },
5844 { PREFIX_TABLE (PREFIX_0F383B
) },
5845 { PREFIX_TABLE (PREFIX_0F383C
) },
5846 { PREFIX_TABLE (PREFIX_0F383D
) },
5847 { PREFIX_TABLE (PREFIX_0F383E
) },
5848 { PREFIX_TABLE (PREFIX_0F383F
) },
5850 { PREFIX_TABLE (PREFIX_0F3840
) },
5851 { PREFIX_TABLE (PREFIX_0F3841
) },
5852 { "(bad)", { XX
} },
5853 { "(bad)", { XX
} },
5854 { "(bad)", { XX
} },
5855 { "(bad)", { XX
} },
5856 { "(bad)", { XX
} },
5857 { "(bad)", { XX
} },
5859 { "(bad)", { XX
} },
5860 { "(bad)", { XX
} },
5861 { "(bad)", { XX
} },
5862 { "(bad)", { XX
} },
5863 { "(bad)", { XX
} },
5864 { "(bad)", { XX
} },
5865 { "(bad)", { XX
} },
5866 { "(bad)", { XX
} },
5868 { "(bad)", { XX
} },
5869 { "(bad)", { XX
} },
5870 { "(bad)", { XX
} },
5871 { "(bad)", { XX
} },
5872 { "(bad)", { XX
} },
5873 { "(bad)", { XX
} },
5874 { "(bad)", { XX
} },
5875 { "(bad)", { XX
} },
5877 { "(bad)", { XX
} },
5878 { "(bad)", { XX
} },
5879 { "(bad)", { XX
} },
5880 { "(bad)", { XX
} },
5881 { "(bad)", { XX
} },
5882 { "(bad)", { XX
} },
5883 { "(bad)", { XX
} },
5884 { "(bad)", { XX
} },
5886 { "(bad)", { XX
} },
5887 { "(bad)", { XX
} },
5888 { "(bad)", { XX
} },
5889 { "(bad)", { XX
} },
5890 { "(bad)", { XX
} },
5891 { "(bad)", { XX
} },
5892 { "(bad)", { XX
} },
5893 { "(bad)", { XX
} },
5895 { "(bad)", { XX
} },
5896 { "(bad)", { XX
} },
5897 { "(bad)", { XX
} },
5898 { "(bad)", { XX
} },
5899 { "(bad)", { XX
} },
5900 { "(bad)", { XX
} },
5901 { "(bad)", { XX
} },
5902 { "(bad)", { XX
} },
5904 { "(bad)", { XX
} },
5905 { "(bad)", { XX
} },
5906 { "(bad)", { XX
} },
5907 { "(bad)", { XX
} },
5908 { "(bad)", { XX
} },
5909 { "(bad)", { XX
} },
5910 { "(bad)", { XX
} },
5911 { "(bad)", { XX
} },
5913 { "(bad)", { XX
} },
5914 { "(bad)", { XX
} },
5915 { "(bad)", { XX
} },
5916 { "(bad)", { XX
} },
5917 { "(bad)", { XX
} },
5918 { "(bad)", { XX
} },
5919 { "(bad)", { XX
} },
5920 { "(bad)", { XX
} },
5922 { PREFIX_TABLE (PREFIX_0F3880
) },
5923 { PREFIX_TABLE (PREFIX_0F3881
) },
5924 { "(bad)", { XX
} },
5925 { "(bad)", { XX
} },
5926 { "(bad)", { XX
} },
5927 { "(bad)", { XX
} },
5928 { "(bad)", { XX
} },
5929 { "(bad)", { XX
} },
5931 { "(bad)", { XX
} },
5932 { "(bad)", { XX
} },
5933 { "(bad)", { XX
} },
5934 { "(bad)", { XX
} },
5935 { "(bad)", { XX
} },
5936 { "(bad)", { XX
} },
5937 { "(bad)", { XX
} },
5938 { "(bad)", { XX
} },
5940 { "(bad)", { XX
} },
5941 { "(bad)", { XX
} },
5942 { "(bad)", { XX
} },
5943 { "(bad)", { XX
} },
5944 { "(bad)", { XX
} },
5945 { "(bad)", { XX
} },
5946 { "(bad)", { XX
} },
5947 { "(bad)", { XX
} },
5949 { "(bad)", { XX
} },
5950 { "(bad)", { XX
} },
5951 { "(bad)", { XX
} },
5952 { "(bad)", { XX
} },
5953 { "(bad)", { XX
} },
5954 { "(bad)", { XX
} },
5955 { "(bad)", { XX
} },
5956 { "(bad)", { XX
} },
5958 { "(bad)", { XX
} },
5959 { "(bad)", { XX
} },
5960 { "(bad)", { XX
} },
5961 { "(bad)", { XX
} },
5962 { "(bad)", { XX
} },
5963 { "(bad)", { XX
} },
5964 { "(bad)", { XX
} },
5965 { "(bad)", { XX
} },
5967 { "(bad)", { XX
} },
5968 { "(bad)", { XX
} },
5969 { "(bad)", { XX
} },
5970 { "(bad)", { XX
} },
5971 { "(bad)", { XX
} },
5972 { "(bad)", { XX
} },
5973 { "(bad)", { XX
} },
5974 { "(bad)", { XX
} },
5976 { "(bad)", { XX
} },
5977 { "(bad)", { XX
} },
5978 { "(bad)", { XX
} },
5979 { "(bad)", { XX
} },
5980 { "(bad)", { XX
} },
5981 { "(bad)", { XX
} },
5982 { "(bad)", { XX
} },
5983 { "(bad)", { XX
} },
5985 { "(bad)", { XX
} },
5986 { "(bad)", { XX
} },
5987 { "(bad)", { XX
} },
5988 { "(bad)", { XX
} },
5989 { "(bad)", { XX
} },
5990 { "(bad)", { XX
} },
5991 { "(bad)", { XX
} },
5992 { "(bad)", { XX
} },
5994 { "(bad)", { XX
} },
5995 { "(bad)", { XX
} },
5996 { "(bad)", { XX
} },
5997 { "(bad)", { XX
} },
5998 { "(bad)", { XX
} },
5999 { "(bad)", { XX
} },
6000 { "(bad)", { XX
} },
6001 { "(bad)", { XX
} },
6003 { "(bad)", { XX
} },
6004 { "(bad)", { XX
} },
6005 { "(bad)", { XX
} },
6006 { "(bad)", { XX
} },
6007 { "(bad)", { XX
} },
6008 { "(bad)", { XX
} },
6009 { "(bad)", { XX
} },
6010 { "(bad)", { XX
} },
6012 { "(bad)", { XX
} },
6013 { "(bad)", { XX
} },
6014 { "(bad)", { XX
} },
6015 { "(bad)", { XX
} },
6016 { "(bad)", { XX
} },
6017 { "(bad)", { XX
} },
6018 { "(bad)", { XX
} },
6019 { "(bad)", { XX
} },
6021 { "(bad)", { XX
} },
6022 { "(bad)", { XX
} },
6023 { "(bad)", { XX
} },
6024 { PREFIX_TABLE (PREFIX_0F38DB
) },
6025 { PREFIX_TABLE (PREFIX_0F38DC
) },
6026 { PREFIX_TABLE (PREFIX_0F38DD
) },
6027 { PREFIX_TABLE (PREFIX_0F38DE
) },
6028 { PREFIX_TABLE (PREFIX_0F38DF
) },
6030 { "(bad)", { XX
} },
6031 { "(bad)", { XX
} },
6032 { "(bad)", { XX
} },
6033 { "(bad)", { XX
} },
6034 { "(bad)", { XX
} },
6035 { "(bad)", { XX
} },
6036 { "(bad)", { XX
} },
6037 { "(bad)", { XX
} },
6039 { "(bad)", { XX
} },
6040 { "(bad)", { XX
} },
6041 { "(bad)", { XX
} },
6042 { "(bad)", { XX
} },
6043 { "(bad)", { XX
} },
6044 { "(bad)", { XX
} },
6045 { "(bad)", { XX
} },
6046 { "(bad)", { XX
} },
6048 { PREFIX_TABLE (PREFIX_0F38F0
) },
6049 { PREFIX_TABLE (PREFIX_0F38F1
) },
6050 { "(bad)", { XX
} },
6051 { "(bad)", { XX
} },
6052 { "(bad)", { XX
} },
6053 { "(bad)", { XX
} },
6054 { "(bad)", { XX
} },
6055 { "(bad)", { XX
} },
6057 { "(bad)", { XX
} },
6058 { "(bad)", { XX
} },
6059 { "(bad)", { XX
} },
6060 { "(bad)", { XX
} },
6061 { "(bad)", { XX
} },
6062 { "(bad)", { XX
} },
6063 { "(bad)", { XX
} },
6064 { "(bad)", { XX
} },
6066 /* THREE_BYTE_0F3A */
6069 { "(bad)", { XX
} },
6070 { "(bad)", { XX
} },
6071 { "(bad)", { XX
} },
6072 { "(bad)", { XX
} },
6073 { "(bad)", { XX
} },
6074 { "(bad)", { XX
} },
6075 { "(bad)", { XX
} },
6076 { "(bad)", { XX
} },
6078 { PREFIX_TABLE (PREFIX_0F3A08
) },
6079 { PREFIX_TABLE (PREFIX_0F3A09
) },
6080 { PREFIX_TABLE (PREFIX_0F3A0A
) },
6081 { PREFIX_TABLE (PREFIX_0F3A0B
) },
6082 { PREFIX_TABLE (PREFIX_0F3A0C
) },
6083 { PREFIX_TABLE (PREFIX_0F3A0D
) },
6084 { PREFIX_TABLE (PREFIX_0F3A0E
) },
6085 { "palignr", { MX
, EM
, Ib
} },
6087 { "(bad)", { XX
} },
6088 { "(bad)", { XX
} },
6089 { "(bad)", { XX
} },
6090 { "(bad)", { XX
} },
6091 { PREFIX_TABLE (PREFIX_0F3A14
) },
6092 { PREFIX_TABLE (PREFIX_0F3A15
) },
6093 { PREFIX_TABLE (PREFIX_0F3A16
) },
6094 { PREFIX_TABLE (PREFIX_0F3A17
) },
6096 { "(bad)", { XX
} },
6097 { "(bad)", { XX
} },
6098 { "(bad)", { XX
} },
6099 { "(bad)", { XX
} },
6100 { "(bad)", { XX
} },
6101 { "(bad)", { XX
} },
6102 { "(bad)", { XX
} },
6103 { "(bad)", { XX
} },
6105 { PREFIX_TABLE (PREFIX_0F3A20
) },
6106 { PREFIX_TABLE (PREFIX_0F3A21
) },
6107 { PREFIX_TABLE (PREFIX_0F3A22
) },
6108 { "(bad)", { XX
} },
6109 { "(bad)", { XX
} },
6110 { "(bad)", { XX
} },
6111 { "(bad)", { XX
} },
6112 { "(bad)", { XX
} },
6114 { "(bad)", { XX
} },
6115 { "(bad)", { XX
} },
6116 { "(bad)", { XX
} },
6117 { "(bad)", { XX
} },
6118 { "(bad)", { XX
} },
6119 { "(bad)", { XX
} },
6120 { "(bad)", { XX
} },
6121 { "(bad)", { XX
} },
6123 { "(bad)", { XX
} },
6124 { "(bad)", { XX
} },
6125 { "(bad)", { XX
} },
6126 { "(bad)", { XX
} },
6127 { "(bad)", { XX
} },
6128 { "(bad)", { XX
} },
6129 { "(bad)", { XX
} },
6130 { "(bad)", { XX
} },
6132 { "(bad)", { XX
} },
6133 { "(bad)", { XX
} },
6134 { "(bad)", { XX
} },
6135 { "(bad)", { XX
} },
6136 { "(bad)", { XX
} },
6137 { "(bad)", { XX
} },
6138 { "(bad)", { XX
} },
6139 { "(bad)", { XX
} },
6141 { PREFIX_TABLE (PREFIX_0F3A40
) },
6142 { PREFIX_TABLE (PREFIX_0F3A41
) },
6143 { PREFIX_TABLE (PREFIX_0F3A42
) },
6144 { "(bad)", { XX
} },
6145 { PREFIX_TABLE (PREFIX_0F3A44
) },
6146 { "(bad)", { XX
} },
6147 { "(bad)", { XX
} },
6148 { "(bad)", { XX
} },
6150 { "(bad)", { XX
} },
6151 { "(bad)", { XX
} },
6152 { "(bad)", { XX
} },
6153 { "(bad)", { XX
} },
6154 { "(bad)", { XX
} },
6155 { "(bad)", { XX
} },
6156 { "(bad)", { XX
} },
6157 { "(bad)", { XX
} },
6159 { "(bad)", { XX
} },
6160 { "(bad)", { XX
} },
6161 { "(bad)", { XX
} },
6162 { "(bad)", { XX
} },
6163 { "(bad)", { XX
} },
6164 { "(bad)", { XX
} },
6165 { "(bad)", { XX
} },
6166 { "(bad)", { XX
} },
6168 { "(bad)", { XX
} },
6169 { "(bad)", { XX
} },
6170 { "(bad)", { XX
} },
6171 { "(bad)", { XX
} },
6172 { "(bad)", { XX
} },
6173 { "(bad)", { XX
} },
6174 { "(bad)", { XX
} },
6175 { "(bad)", { XX
} },
6177 { PREFIX_TABLE (PREFIX_0F3A60
) },
6178 { PREFIX_TABLE (PREFIX_0F3A61
) },
6179 { PREFIX_TABLE (PREFIX_0F3A62
) },
6180 { PREFIX_TABLE (PREFIX_0F3A63
) },
6181 { "(bad)", { XX
} },
6182 { "(bad)", { XX
} },
6183 { "(bad)", { XX
} },
6184 { "(bad)", { XX
} },
6186 { "(bad)", { XX
} },
6187 { "(bad)", { XX
} },
6188 { "(bad)", { XX
} },
6189 { "(bad)", { XX
} },
6190 { "(bad)", { XX
} },
6191 { "(bad)", { XX
} },
6192 { "(bad)", { XX
} },
6193 { "(bad)", { XX
} },
6195 { "(bad)", { XX
} },
6196 { "(bad)", { XX
} },
6197 { "(bad)", { XX
} },
6198 { "(bad)", { XX
} },
6199 { "(bad)", { XX
} },
6200 { "(bad)", { XX
} },
6201 { "(bad)", { XX
} },
6202 { "(bad)", { XX
} },
6204 { "(bad)", { XX
} },
6205 { "(bad)", { XX
} },
6206 { "(bad)", { XX
} },
6207 { "(bad)", { XX
} },
6208 { "(bad)", { XX
} },
6209 { "(bad)", { XX
} },
6210 { "(bad)", { XX
} },
6211 { "(bad)", { XX
} },
6213 { "(bad)", { XX
} },
6214 { "(bad)", { XX
} },
6215 { "(bad)", { XX
} },
6216 { "(bad)", { XX
} },
6217 { "(bad)", { XX
} },
6218 { "(bad)", { XX
} },
6219 { "(bad)", { XX
} },
6220 { "(bad)", { XX
} },
6222 { "(bad)", { XX
} },
6223 { "(bad)", { XX
} },
6224 { "(bad)", { XX
} },
6225 { "(bad)", { XX
} },
6226 { "(bad)", { XX
} },
6227 { "(bad)", { XX
} },
6228 { "(bad)", { XX
} },
6229 { "(bad)", { XX
} },
6231 { "(bad)", { XX
} },
6232 { "(bad)", { XX
} },
6233 { "(bad)", { XX
} },
6234 { "(bad)", { XX
} },
6235 { "(bad)", { XX
} },
6236 { "(bad)", { XX
} },
6237 { "(bad)", { XX
} },
6238 { "(bad)", { XX
} },
6240 { "(bad)", { XX
} },
6241 { "(bad)", { XX
} },
6242 { "(bad)", { XX
} },
6243 { "(bad)", { XX
} },
6244 { "(bad)", { XX
} },
6245 { "(bad)", { XX
} },
6246 { "(bad)", { XX
} },
6247 { "(bad)", { XX
} },
6249 { "(bad)", { XX
} },
6250 { "(bad)", { XX
} },
6251 { "(bad)", { XX
} },
6252 { "(bad)", { XX
} },
6253 { "(bad)", { XX
} },
6254 { "(bad)", { XX
} },
6255 { "(bad)", { XX
} },
6256 { "(bad)", { XX
} },
6258 { "(bad)", { XX
} },
6259 { "(bad)", { XX
} },
6260 { "(bad)", { XX
} },
6261 { "(bad)", { XX
} },
6262 { "(bad)", { XX
} },
6263 { "(bad)", { XX
} },
6264 { "(bad)", { XX
} },
6265 { "(bad)", { XX
} },
6267 { "(bad)", { XX
} },
6268 { "(bad)", { XX
} },
6269 { "(bad)", { XX
} },
6270 { "(bad)", { XX
} },
6271 { "(bad)", { XX
} },
6272 { "(bad)", { XX
} },
6273 { "(bad)", { XX
} },
6274 { "(bad)", { XX
} },
6276 { "(bad)", { XX
} },
6277 { "(bad)", { XX
} },
6278 { "(bad)", { XX
} },
6279 { "(bad)", { XX
} },
6280 { "(bad)", { XX
} },
6281 { "(bad)", { XX
} },
6282 { "(bad)", { XX
} },
6283 { "(bad)", { XX
} },
6285 { "(bad)", { XX
} },
6286 { "(bad)", { XX
} },
6287 { "(bad)", { XX
} },
6288 { "(bad)", { XX
} },
6289 { "(bad)", { XX
} },
6290 { "(bad)", { XX
} },
6291 { "(bad)", { XX
} },
6292 { "(bad)", { XX
} },
6294 { "(bad)", { XX
} },
6295 { "(bad)", { XX
} },
6296 { "(bad)", { XX
} },
6297 { "(bad)", { XX
} },
6298 { "(bad)", { XX
} },
6299 { "(bad)", { XX
} },
6300 { "(bad)", { XX
} },
6301 { "(bad)", { XX
} },
6303 { "(bad)", { XX
} },
6304 { "(bad)", { XX
} },
6305 { "(bad)", { XX
} },
6306 { "(bad)", { XX
} },
6307 { "(bad)", { XX
} },
6308 { "(bad)", { XX
} },
6309 { "(bad)", { XX
} },
6310 { "(bad)", { XX
} },
6312 { "(bad)", { XX
} },
6313 { "(bad)", { XX
} },
6314 { "(bad)", { XX
} },
6315 { "(bad)", { XX
} },
6316 { "(bad)", { XX
} },
6317 { "(bad)", { XX
} },
6318 { "(bad)", { XX
} },
6319 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6321 { "(bad)", { XX
} },
6322 { "(bad)", { XX
} },
6323 { "(bad)", { XX
} },
6324 { "(bad)", { XX
} },
6325 { "(bad)", { XX
} },
6326 { "(bad)", { XX
} },
6327 { "(bad)", { XX
} },
6328 { "(bad)", { XX
} },
6330 { "(bad)", { XX
} },
6331 { "(bad)", { XX
} },
6332 { "(bad)", { XX
} },
6333 { "(bad)", { XX
} },
6334 { "(bad)", { XX
} },
6335 { "(bad)", { XX
} },
6336 { "(bad)", { XX
} },
6337 { "(bad)", { XX
} },
6339 { "(bad)", { XX
} },
6340 { "(bad)", { XX
} },
6341 { "(bad)", { XX
} },
6342 { "(bad)", { XX
} },
6343 { "(bad)", { XX
} },
6344 { "(bad)", { XX
} },
6345 { "(bad)", { XX
} },
6346 { "(bad)", { XX
} },
6348 { "(bad)", { XX
} },
6349 { "(bad)", { XX
} },
6350 { "(bad)", { XX
} },
6351 { "(bad)", { XX
} },
6352 { "(bad)", { XX
} },
6353 { "(bad)", { XX
} },
6354 { "(bad)", { XX
} },
6355 { "(bad)", { XX
} },
6358 /* THREE_BYTE_0F7A */
6361 { "(bad)", { XX
} },
6362 { "(bad)", { XX
} },
6363 { "(bad)", { XX
} },
6364 { "(bad)", { XX
} },
6365 { "(bad)", { XX
} },
6366 { "(bad)", { XX
} },
6367 { "(bad)", { XX
} },
6368 { "(bad)", { XX
} },
6370 { "(bad)", { XX
} },
6371 { "(bad)", { XX
} },
6372 { "(bad)", { XX
} },
6373 { "(bad)", { XX
} },
6374 { "(bad)", { XX
} },
6375 { "(bad)", { XX
} },
6376 { "(bad)", { XX
} },
6377 { "(bad)", { XX
} },
6379 { "(bad)", { XX
} },
6380 { "(bad)", { XX
} },
6381 { "(bad)", { XX
} },
6382 { "(bad)", { XX
} },
6383 { "(bad)", { XX
} },
6384 { "(bad)", { XX
} },
6385 { "(bad)", { XX
} },
6386 { "(bad)", { XX
} },
6388 { "(bad)", { XX
} },
6389 { "(bad)", { XX
} },
6390 { "(bad)", { XX
} },
6391 { "(bad)", { XX
} },
6392 { "(bad)", { XX
} },
6393 { "(bad)", { XX
} },
6394 { "(bad)", { XX
} },
6395 { "(bad)", { XX
} },
6397 { "ptest", { XX
} },
6398 { "(bad)", { XX
} },
6399 { "(bad)", { XX
} },
6400 { "(bad)", { XX
} },
6401 { "(bad)", { XX
} },
6402 { "(bad)", { XX
} },
6403 { "(bad)", { XX
} },
6404 { "(bad)", { XX
} },
6406 { "(bad)", { XX
} },
6407 { "(bad)", { XX
} },
6408 { "(bad)", { XX
} },
6409 { "(bad)", { XX
} },
6410 { "(bad)", { XX
} },
6411 { "(bad)", { XX
} },
6412 { "(bad)", { XX
} },
6413 { "(bad)", { XX
} },
6415 { "(bad)", { XX
} },
6416 { "(bad)", { XX
} },
6417 { "(bad)", { XX
} },
6418 { "(bad)", { XX
} },
6419 { "(bad)", { XX
} },
6420 { "(bad)", { XX
} },
6421 { "(bad)", { XX
} },
6422 { "(bad)", { XX
} },
6424 { "(bad)", { XX
} },
6425 { "(bad)", { XX
} },
6426 { "(bad)", { XX
} },
6427 { "(bad)", { XX
} },
6428 { "(bad)", { XX
} },
6429 { "(bad)", { XX
} },
6430 { "(bad)", { XX
} },
6431 { "(bad)", { XX
} },
6433 { "(bad)", { XX
} },
6434 { "phaddbw", { XM
, EXq
} },
6435 { "phaddbd", { XM
, EXq
} },
6436 { "phaddbq", { XM
, EXq
} },
6437 { "(bad)", { XX
} },
6438 { "(bad)", { XX
} },
6439 { "phaddwd", { XM
, EXq
} },
6440 { "phaddwq", { XM
, EXq
} },
6442 { "(bad)", { XX
} },
6443 { "(bad)", { XX
} },
6444 { "(bad)", { XX
} },
6445 { "phadddq", { XM
, EXq
} },
6446 { "(bad)", { XX
} },
6447 { "(bad)", { XX
} },
6448 { "(bad)", { XX
} },
6449 { "(bad)", { XX
} },
6451 { "(bad)", { XX
} },
6452 { "phaddubw", { XM
, EXq
} },
6453 { "phaddubd", { XM
, EXq
} },
6454 { "phaddubq", { XM
, EXq
} },
6455 { "(bad)", { XX
} },
6456 { "(bad)", { XX
} },
6457 { "phadduwd", { XM
, EXq
} },
6458 { "phadduwq", { XM
, EXq
} },
6460 { "(bad)", { XX
} },
6461 { "(bad)", { XX
} },
6462 { "(bad)", { XX
} },
6463 { "phaddudq", { XM
, EXq
} },
6464 { "(bad)", { XX
} },
6465 { "(bad)", { XX
} },
6466 { "(bad)", { XX
} },
6467 { "(bad)", { XX
} },
6469 { "(bad)", { XX
} },
6470 { "phsubbw", { XM
, EXq
} },
6471 { "phsubbd", { XM
, EXq
} },
6472 { "phsubbq", { XM
, EXq
} },
6473 { "(bad)", { XX
} },
6474 { "(bad)", { XX
} },
6475 { "(bad)", { XX
} },
6476 { "(bad)", { XX
} },
6478 { "(bad)", { XX
} },
6479 { "(bad)", { XX
} },
6480 { "(bad)", { XX
} },
6481 { "(bad)", { XX
} },
6482 { "(bad)", { XX
} },
6483 { "(bad)", { XX
} },
6484 { "(bad)", { XX
} },
6485 { "(bad)", { XX
} },
6487 { "(bad)", { XX
} },
6488 { "(bad)", { XX
} },
6489 { "(bad)", { XX
} },
6490 { "(bad)", { XX
} },
6491 { "(bad)", { XX
} },
6492 { "(bad)", { XX
} },
6493 { "(bad)", { XX
} },
6494 { "(bad)", { XX
} },
6496 { "(bad)", { XX
} },
6497 { "(bad)", { XX
} },
6498 { "(bad)", { XX
} },
6499 { "(bad)", { XX
} },
6500 { "(bad)", { XX
} },
6501 { "(bad)", { XX
} },
6502 { "(bad)", { XX
} },
6503 { "(bad)", { XX
} },
6505 { "(bad)", { XX
} },
6506 { "(bad)", { XX
} },
6507 { "(bad)", { XX
} },
6508 { "(bad)", { XX
} },
6509 { "(bad)", { XX
} },
6510 { "(bad)", { XX
} },
6511 { "(bad)", { XX
} },
6512 { "(bad)", { XX
} },
6514 { "(bad)", { XX
} },
6515 { "(bad)", { XX
} },
6516 { "(bad)", { XX
} },
6517 { "(bad)", { XX
} },
6518 { "(bad)", { XX
} },
6519 { "(bad)", { XX
} },
6520 { "(bad)", { XX
} },
6521 { "(bad)", { XX
} },
6523 { "(bad)", { XX
} },
6524 { "(bad)", { XX
} },
6525 { "(bad)", { XX
} },
6526 { "(bad)", { XX
} },
6527 { "(bad)", { XX
} },
6528 { "(bad)", { XX
} },
6529 { "(bad)", { XX
} },
6530 { "(bad)", { XX
} },
6532 { "(bad)", { XX
} },
6533 { "(bad)", { XX
} },
6534 { "(bad)", { XX
} },
6535 { "(bad)", { XX
} },
6536 { "(bad)", { XX
} },
6537 { "(bad)", { XX
} },
6538 { "(bad)", { XX
} },
6539 { "(bad)", { XX
} },
6541 { "(bad)", { XX
} },
6542 { "(bad)", { XX
} },
6543 { "(bad)", { XX
} },
6544 { "(bad)", { XX
} },
6545 { "(bad)", { XX
} },
6546 { "(bad)", { XX
} },
6547 { "(bad)", { XX
} },
6548 { "(bad)", { XX
} },
6550 { "(bad)", { XX
} },
6551 { "(bad)", { XX
} },
6552 { "(bad)", { XX
} },
6553 { "(bad)", { XX
} },
6554 { "(bad)", { XX
} },
6555 { "(bad)", { XX
} },
6556 { "(bad)", { XX
} },
6557 { "(bad)", { XX
} },
6559 { "(bad)", { XX
} },
6560 { "(bad)", { XX
} },
6561 { "(bad)", { XX
} },
6562 { "(bad)", { XX
} },
6563 { "(bad)", { XX
} },
6564 { "(bad)", { XX
} },
6565 { "(bad)", { XX
} },
6566 { "(bad)", { XX
} },
6568 { "(bad)", { XX
} },
6569 { "(bad)", { XX
} },
6570 { "(bad)", { XX
} },
6571 { "(bad)", { XX
} },
6572 { "(bad)", { XX
} },
6573 { "(bad)", { XX
} },
6574 { "(bad)", { XX
} },
6575 { "(bad)", { XX
} },
6577 { "(bad)", { XX
} },
6578 { "(bad)", { XX
} },
6579 { "(bad)", { XX
} },
6580 { "(bad)", { XX
} },
6581 { "(bad)", { XX
} },
6582 { "(bad)", { XX
} },
6583 { "(bad)", { XX
} },
6584 { "(bad)", { XX
} },
6586 { "(bad)", { XX
} },
6587 { "(bad)", { XX
} },
6588 { "(bad)", { XX
} },
6589 { "(bad)", { XX
} },
6590 { "(bad)", { XX
} },
6591 { "(bad)", { XX
} },
6592 { "(bad)", { XX
} },
6593 { "(bad)", { XX
} },
6595 { "(bad)", { XX
} },
6596 { "(bad)", { XX
} },
6597 { "(bad)", { XX
} },
6598 { "(bad)", { XX
} },
6599 { "(bad)", { XX
} },
6600 { "(bad)", { XX
} },
6601 { "(bad)", { XX
} },
6602 { "(bad)", { XX
} },
6604 { "(bad)", { XX
} },
6605 { "(bad)", { XX
} },
6606 { "(bad)", { XX
} },
6607 { "(bad)", { XX
} },
6608 { "(bad)", { XX
} },
6609 { "(bad)", { XX
} },
6610 { "(bad)", { XX
} },
6611 { "(bad)", { XX
} },
6613 { "(bad)", { XX
} },
6614 { "(bad)", { XX
} },
6615 { "(bad)", { XX
} },
6616 { "(bad)", { XX
} },
6617 { "(bad)", { XX
} },
6618 { "(bad)", { XX
} },
6619 { "(bad)", { XX
} },
6620 { "(bad)", { XX
} },
6622 { "(bad)", { XX
} },
6623 { "(bad)", { XX
} },
6624 { "(bad)", { XX
} },
6625 { "(bad)", { XX
} },
6626 { "(bad)", { XX
} },
6627 { "(bad)", { XX
} },
6628 { "(bad)", { XX
} },
6629 { "(bad)", { XX
} },
6631 { "(bad)", { XX
} },
6632 { "(bad)", { XX
} },
6633 { "(bad)", { XX
} },
6634 { "(bad)", { XX
} },
6635 { "(bad)", { XX
} },
6636 { "(bad)", { XX
} },
6637 { "(bad)", { XX
} },
6638 { "(bad)", { XX
} },
6640 { "(bad)", { XX
} },
6641 { "(bad)", { XX
} },
6642 { "(bad)", { XX
} },
6643 { "(bad)", { XX
} },
6644 { "(bad)", { XX
} },
6645 { "(bad)", { XX
} },
6646 { "(bad)", { XX
} },
6647 { "(bad)", { XX
} },
6651 static const struct dis386 xop_table
[][256] = {
6655 { "(bad)", { XX
} },
6656 { "(bad)", { XX
} },
6657 { "(bad)", { XX
} },
6658 { "(bad)", { XX
} },
6659 { "(bad)", { XX
} },
6660 { "(bad)", { XX
} },
6661 { "(bad)", { XX
} },
6662 { "(bad)", { XX
} },
6664 { "(bad)", { XX
} },
6665 { "(bad)", { XX
} },
6666 { "(bad)", { XX
} },
6667 { "(bad)", { XX
} },
6668 { "(bad)", { XX
} },
6669 { "(bad)", { XX
} },
6670 { "(bad)", { XX
} },
6671 { "(bad)", { XX
} },
6673 { "(bad)", { XX
} },
6674 { "(bad)", { XX
} },
6675 { "(bad)", { XX
} },
6676 { "(bad)", { XX
} },
6677 { "(bad)", { XX
} },
6678 { "(bad)", { XX
} },
6679 { "(bad)", { XX
} },
6680 { "(bad)", { XX
} },
6682 { "(bad)", { XX
} },
6683 { "(bad)", { XX
} },
6684 { "(bad)", { XX
} },
6685 { "(bad)", { XX
} },
6686 { "(bad)", { XX
} },
6687 { "(bad)", { XX
} },
6688 { "(bad)", { XX
} },
6689 { "(bad)", { XX
} },
6691 { "(bad)", { XX
} },
6692 { "(bad)", { XX
} },
6693 { "(bad)", { XX
} },
6694 { "(bad)", { XX
} },
6695 { "(bad)", { XX
} },
6696 { "(bad)", { XX
} },
6697 { "(bad)", { XX
} },
6698 { "(bad)", { XX
} },
6700 { "(bad)", { XX
} },
6701 { "(bad)", { XX
} },
6702 { "(bad)", { XX
} },
6703 { "(bad)", { XX
} },
6704 { "(bad)", { XX
} },
6705 { "(bad)", { XX
} },
6706 { "(bad)", { XX
} },
6707 { "(bad)", { XX
} },
6709 { "(bad)", { XX
} },
6710 { "(bad)", { XX
} },
6711 { "(bad)", { XX
} },
6712 { "(bad)", { XX
} },
6713 { "(bad)", { XX
} },
6714 { "(bad)", { XX
} },
6715 { "(bad)", { XX
} },
6716 { "(bad)", { XX
} },
6718 { "(bad)", { XX
} },
6719 { "(bad)", { XX
} },
6720 { "(bad)", { XX
} },
6721 { "(bad)", { XX
} },
6722 { "(bad)", { XX
} },
6723 { "(bad)", { XX
} },
6724 { "(bad)", { XX
} },
6725 { "(bad)", { XX
} },
6727 { "(bad)", { XX
} },
6728 { "(bad)", { XX
} },
6729 { "(bad)", { XX
} },
6730 { "(bad)", { XX
} },
6731 { "(bad)", { XX
} },
6732 { "(bad)", { XX
} },
6733 { "(bad)", { XX
} },
6734 { "(bad)", { XX
} },
6736 { "(bad)", { XX
} },
6737 { "(bad)", { XX
} },
6738 { "(bad)", { XX
} },
6739 { "(bad)", { XX
} },
6740 { "(bad)", { XX
} },
6741 { "(bad)", { XX
} },
6742 { "(bad)", { XX
} },
6743 { "(bad)", { XX
} },
6745 { "(bad)", { XX
} },
6746 { "(bad)", { XX
} },
6747 { "(bad)", { XX
} },
6748 { "(bad)", { XX
} },
6749 { "(bad)", { XX
} },
6750 { "(bad)", { XX
} },
6751 { "(bad)", { XX
} },
6752 { "(bad)", { XX
} },
6754 { "(bad)", { XX
} },
6755 { "(bad)", { XX
} },
6756 { "(bad)", { XX
} },
6757 { "(bad)", { XX
} },
6758 { "(bad)", { XX
} },
6759 { "(bad)", { XX
} },
6760 { "(bad)", { XX
} },
6761 { "(bad)", { XX
} },
6763 { "(bad)", { XX
} },
6764 { "(bad)", { XX
} },
6765 { "(bad)", { XX
} },
6766 { "(bad)", { XX
} },
6767 { "(bad)", { XX
} },
6768 { "(bad)", { XX
} },
6769 { "(bad)", { XX
} },
6770 { "(bad)", { XX
} },
6772 { "(bad)", { XX
} },
6773 { "(bad)", { XX
} },
6774 { "(bad)", { XX
} },
6775 { "(bad)", { XX
} },
6776 { "(bad)", { XX
} },
6777 { "(bad)", { XX
} },
6778 { "(bad)", { XX
} },
6779 { "(bad)", { XX
} },
6781 { "(bad)", { XX
} },
6782 { "(bad)", { XX
} },
6783 { "(bad)", { XX
} },
6784 { "(bad)", { XX
} },
6785 { "(bad)", { XX
} },
6786 { "(bad)", { XX
} },
6787 { "(bad)", { XX
} },
6788 { "(bad)", { XX
} },
6790 { "(bad)", { XX
} },
6791 { "(bad)", { XX
} },
6792 { "(bad)", { XX
} },
6793 { "(bad)", { XX
} },
6794 { "(bad)", { XX
} },
6795 { "(bad)", { XX
} },
6796 { "(bad)", { XX
} },
6797 { "(bad)", { XX
} },
6799 { "(bad)", { XX
} },
6800 { "(bad)", { XX
} },
6801 { "(bad)", { XX
} },
6802 { "(bad)", { XX
} },
6803 { "(bad)", { XX
} },
6804 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6805 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6806 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6808 { "(bad)", { XX
} },
6809 { "(bad)", { XX
} },
6810 { "(bad)", { XX
} },
6811 { "(bad)", { XX
} },
6812 { "(bad)", { XX
} },
6813 { "(bad)", { XX
} },
6814 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6815 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6817 { "(bad)", { XX
} },
6818 { "(bad)", { XX
} },
6819 { "(bad)", { XX
} },
6820 { "(bad)", { XX
} },
6821 { "(bad)", { XX
} },
6822 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6823 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6824 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6826 { "(bad)", { XX
} },
6827 { "(bad)", { XX
} },
6828 { "(bad)", { XX
} },
6829 { "(bad)", { XX
} },
6830 { "(bad)", { XX
} },
6831 { "(bad)", { XX
} },
6832 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6833 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6835 { "(bad)", { XX
} },
6836 { "(bad)", { XX
} },
6837 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6838 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6839 { "(bad)", { XX
} },
6840 { "(bad)", { XX
} },
6841 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6842 { "(bad)", { XX
} },
6844 { "(bad)", { XX
} },
6845 { "(bad)", { XX
} },
6846 { "(bad)", { XX
} },
6847 { "(bad)", { XX
} },
6848 { "(bad)", { XX
} },
6849 { "(bad)", { XX
} },
6850 { "(bad)", { XX
} },
6851 { "(bad)", { XX
} },
6853 { "(bad)", { XX
} },
6854 { "(bad)", { XX
} },
6855 { "(bad)", { XX
} },
6856 { "(bad)", { XX
} },
6857 { "(bad)", { XX
} },
6858 { "(bad)", { XX
} },
6859 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6860 { "(bad)", { XX
} },
6862 { "(bad)", { XX
} },
6863 { "(bad)", { XX
} },
6864 { "(bad)", { XX
} },
6865 { "(bad)", { XX
} },
6866 { "(bad)", { XX
} },
6867 { "(bad)", { XX
} },
6868 { "(bad)", { XX
} },
6869 { "(bad)", { XX
} },
6871 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6872 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6873 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6874 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6875 { "(bad)", { XX
} },
6876 { "(bad)", { XX
} },
6877 { "(bad)", { XX
} },
6878 { "(bad)", { XX
} },
6880 { "(bad)", { XX
} },
6881 { "(bad)", { XX
} },
6882 { "(bad)", { XX
} },
6883 { "(bad)", { XX
} },
6884 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6885 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6886 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6887 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6889 { "(bad)", { XX
} },
6890 { "(bad)", { XX
} },
6891 { "(bad)", { XX
} },
6892 { "(bad)", { XX
} },
6893 { "(bad)", { XX
} },
6894 { "(bad)", { XX
} },
6895 { "(bad)", { XX
} },
6896 { "(bad)", { XX
} },
6898 { "(bad)", { XX
} },
6899 { "(bad)", { XX
} },
6900 { "(bad)", { XX
} },
6901 { "(bad)", { XX
} },
6902 { "(bad)", { XX
} },
6903 { "(bad)", { XX
} },
6904 { "(bad)", { XX
} },
6905 { "(bad)", { XX
} },
6907 { "(bad)", { XX
} },
6908 { "(bad)", { XX
} },
6909 { "(bad)", { XX
} },
6910 { "(bad)", { XX
} },
6911 { "(bad)", { XX
} },
6912 { "(bad)", { XX
} },
6913 { "(bad)", { XX
} },
6914 { "(bad)", { XX
} },
6916 { "(bad)", { XX
} },
6917 { "(bad)", { XX
} },
6918 { "(bad)", { XX
} },
6919 { "(bad)", { XX
} },
6920 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6921 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6922 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6923 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6925 { "(bad)", { XX
} },
6926 { "(bad)", { XX
} },
6927 { "(bad)", { XX
} },
6928 { "(bad)", { XX
} },
6929 { "(bad)", { XX
} },
6930 { "(bad)", { XX
} },
6931 { "(bad)", { XX
} },
6932 { "(bad)", { XX
} },
6934 { "(bad)", { XX
} },
6935 { "(bad)", { XX
} },
6936 { "(bad)", { XX
} },
6937 { "(bad)", { XX
} },
6938 { "(bad)", { XX
} },
6939 { "(bad)", { XX
} },
6940 { "(bad)", { XX
} },
6941 { "(bad)", { XX
} },
6946 { "(bad)", { XX
} },
6947 { "(bad)", { XX
} },
6948 { "(bad)", { XX
} },
6949 { "(bad)", { XX
} },
6950 { "(bad)", { XX
} },
6951 { "(bad)", { XX
} },
6952 { "(bad)", { XX
} },
6953 { "(bad)", { XX
} },
6955 { "(bad)", { XX
} },
6956 { "(bad)", { XX
} },
6957 { "(bad)", { XX
} },
6958 { "(bad)", { XX
} },
6959 { "(bad)", { XX
} },
6960 { "(bad)", { XX
} },
6961 { "(bad)", { XX
} },
6962 { "(bad)", { XX
} },
6964 { "(bad)", { XX
} },
6965 { "(bad)", { XX
} },
6966 { REG_TABLE (REG_XOP_LWPCB
) },
6967 { "(bad)", { XX
} },
6968 { "(bad)", { XX
} },
6969 { "(bad)", { XX
} },
6970 { "(bad)", { XX
} },
6971 { "(bad)", { XX
} },
6973 { "(bad)", { XX
} },
6974 { "(bad)", { XX
} },
6975 { "(bad)", { XX
} },
6976 { "(bad)", { XX
} },
6977 { "(bad)", { XX
} },
6978 { "(bad)", { XX
} },
6979 { "(bad)", { XX
} },
6980 { "(bad)", { XX
} },
6982 { "(bad)", { XX
} },
6983 { "(bad)", { XX
} },
6984 { "(bad)", { XX
} },
6985 { "(bad)", { XX
} },
6986 { "(bad)", { XX
} },
6987 { "(bad)", { XX
} },
6988 { "(bad)", { XX
} },
6989 { "(bad)", { XX
} },
6991 { "(bad)", { XX
} },
6992 { "(bad)", { XX
} },
6993 { "(bad)", { XX
} },
6994 { "(bad)", { XX
} },
6995 { "(bad)", { XX
} },
6996 { "(bad)", { XX
} },
6997 { "(bad)", { XX
} },
6998 { "(bad)", { XX
} },
7000 { "(bad)", { XX
} },
7001 { "(bad)", { XX
} },
7002 { "(bad)", { XX
} },
7003 { "(bad)", { XX
} },
7004 { "(bad)", { XX
} },
7005 { "(bad)", { XX
} },
7006 { "(bad)", { XX
} },
7007 { "(bad)", { XX
} },
7009 { "(bad)", { XX
} },
7010 { "(bad)", { XX
} },
7011 { "(bad)", { XX
} },
7012 { "(bad)", { XX
} },
7013 { "(bad)", { XX
} },
7014 { "(bad)", { XX
} },
7015 { "(bad)", { XX
} },
7016 { "(bad)", { XX
} },
7018 { "(bad)", { XX
} },
7019 { "(bad)", { XX
} },
7020 { "(bad)", { XX
} },
7021 { "(bad)", { XX
} },
7022 { "(bad)", { XX
} },
7023 { "(bad)", { XX
} },
7024 { "(bad)", { XX
} },
7025 { "(bad)", { XX
} },
7027 { "(bad)", { XX
} },
7028 { "(bad)", { XX
} },
7029 { "(bad)", { XX
} },
7030 { "(bad)", { XX
} },
7031 { "(bad)", { XX
} },
7032 { "(bad)", { XX
} },
7033 { "(bad)", { XX
} },
7034 { "(bad)", { XX
} },
7036 { "(bad)", { XX
} },
7037 { "(bad)", { XX
} },
7038 { "(bad)", { XX
} },
7039 { "(bad)", { XX
} },
7040 { "(bad)", { XX
} },
7041 { "(bad)", { XX
} },
7042 { "(bad)", { XX
} },
7043 { "(bad)", { XX
} },
7045 { "(bad)", { XX
} },
7046 { "(bad)", { XX
} },
7047 { "(bad)", { XX
} },
7048 { "(bad)", { XX
} },
7049 { "(bad)", { XX
} },
7050 { "(bad)", { XX
} },
7051 { "(bad)", { XX
} },
7052 { "(bad)", { XX
} },
7054 { "(bad)", { XX
} },
7055 { "(bad)", { XX
} },
7056 { "(bad)", { XX
} },
7057 { "(bad)", { XX
} },
7058 { "(bad)", { XX
} },
7059 { "(bad)", { XX
} },
7060 { "(bad)", { XX
} },
7061 { "(bad)", { XX
} },
7063 { "(bad)", { XX
} },
7064 { "(bad)", { XX
} },
7065 { "(bad)", { XX
} },
7066 { "(bad)", { XX
} },
7067 { "(bad)", { XX
} },
7068 { "(bad)", { XX
} },
7069 { "(bad)", { XX
} },
7070 { "(bad)", { XX
} },
7072 { "(bad)", { XX
} },
7073 { "(bad)", { XX
} },
7074 { "(bad)", { XX
} },
7075 { "(bad)", { XX
} },
7076 { "(bad)", { XX
} },
7077 { "(bad)", { XX
} },
7078 { "(bad)", { XX
} },
7079 { "(bad)", { XX
} },
7081 { "(bad)", { XX
} },
7082 { "(bad)", { XX
} },
7083 { "(bad)", { XX
} },
7084 { "(bad)", { XX
} },
7085 { "(bad)", { XX
} },
7086 { "(bad)", { XX
} },
7087 { "(bad)", { XX
} },
7088 { "(bad)", { XX
} },
7090 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
7091 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
7092 { "vfrczss", { XM
, EXd
} },
7093 { "vfrczsd", { XM
, EXq
} },
7094 { "(bad)", { XX
} },
7095 { "(bad)", { XX
} },
7096 { "(bad)", { XX
} },
7097 { "(bad)", { XX
} },
7099 { "(bad)", { XX
} },
7100 { "(bad)", { XX
} },
7101 { "(bad)", { XX
} },
7102 { "(bad)", { XX
} },
7103 { "(bad)", { XX
} },
7104 { "(bad)", { XX
} },
7105 { "(bad)", { XX
} },
7106 { "(bad)", { XX
} },
7108 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
7109 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
7110 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
7111 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
7112 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
7113 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
7114 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
7115 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
7117 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
7118 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
7119 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
7120 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
7121 { "(bad)", { XX
} },
7122 { "(bad)", { XX
} },
7123 { "(bad)", { XX
} },
7124 { "(bad)", { XX
} },
7126 { "(bad)", { XX
} },
7127 { "(bad)", { XX
} },
7128 { "(bad)", { XX
} },
7129 { "(bad)", { XX
} },
7130 { "(bad)", { XX
} },
7131 { "(bad)", { XX
} },
7132 { "(bad)", { XX
} },
7133 { "(bad)", { XX
} },
7135 { "(bad)", { XX
} },
7136 { "(bad)", { XX
} },
7137 { "(bad)", { XX
} },
7138 { "(bad)", { XX
} },
7139 { "(bad)", { XX
} },
7140 { "(bad)", { XX
} },
7141 { "(bad)", { XX
} },
7142 { "(bad)", { XX
} },
7144 { "(bad)", { XX
} },
7145 { "(bad)", { XX
} },
7146 { "(bad)", { XX
} },
7147 { "(bad)", { XX
} },
7148 { "(bad)", { XX
} },
7149 { "(bad)", { XX
} },
7150 { "(bad)", { XX
} },
7151 { "(bad)", { XX
} },
7153 { "(bad)", { XX
} },
7154 { "(bad)", { XX
} },
7155 { "(bad)", { XX
} },
7156 { "(bad)", { XX
} },
7157 { "(bad)", { XX
} },
7158 { "(bad)", { XX
} },
7159 { "(bad)", { XX
} },
7160 { "(bad)", { XX
} },
7162 { "(bad)", { XX
} },
7163 { "vphaddbw", { XM
, EXxmm
} },
7164 { "vphaddbd", { XM
, EXxmm
} },
7165 { "vphaddbq", { XM
, EXxmm
} },
7166 { "(bad)", { XX
} },
7167 { "(bad)", { XX
} },
7168 { "vphaddwd", { XM
, EXxmm
} },
7169 { "vphaddwq", { XM
, EXxmm
} },
7171 { "(bad)", { XX
} },
7172 { "(bad)", { XX
} },
7173 { "(bad)", { XX
} },
7174 { "vphadddq", { XM
, EXxmm
} },
7175 { "(bad)", { XX
} },
7176 { "(bad)", { XX
} },
7177 { "(bad)", { XX
} },
7178 { "(bad)", { XX
} },
7180 { "(bad)", { XX
} },
7181 { "vphaddubw", { XM
, EXxmm
} },
7182 { "vphaddubd", { XM
, EXxmm
} },
7183 { "vphaddubq", { XM
, EXxmm
} },
7184 { "(bad)", { XX
} },
7185 { "(bad)", { XX
} },
7186 { "vphadduwd", { XM
, EXxmm
} },
7187 { "vphadduwq", { XM
, EXxmm
} },
7189 { "(bad)", { XX
} },
7190 { "(bad)", { XX
} },
7191 { "(bad)", { XX
} },
7192 { "vphaddudq", { XM
, EXxmm
} },
7193 { "(bad)", { XX
} },
7194 { "(bad)", { XX
} },
7195 { "(bad)", { XX
} },
7196 { "(bad)", { XX
} },
7198 { "(bad)", { XX
} },
7199 { "vphsubbw", { XM
, EXxmm
} },
7200 { "vphsubwd", { XM
, EXxmm
} },
7201 { "vphsubdq", { XM
, EXxmm
} },
7202 { "(bad)", { XX
} },
7203 { "(bad)", { XX
} },
7204 { "(bad)", { XX
} },
7205 { "(bad)", { XX
} },
7207 { "(bad)", { XX
} },
7208 { "(bad)", { XX
} },
7209 { "(bad)", { XX
} },
7210 { "(bad)", { XX
} },
7211 { "(bad)", { XX
} },
7212 { "(bad)", { XX
} },
7213 { "(bad)", { XX
} },
7214 { "(bad)", { XX
} },
7216 { "(bad)", { XX
} },
7217 { "(bad)", { XX
} },
7218 { "(bad)", { XX
} },
7219 { "(bad)", { XX
} },
7220 { "(bad)", { XX
} },
7221 { "(bad)", { XX
} },
7222 { "(bad)", { XX
} },
7223 { "(bad)", { XX
} },
7225 { "(bad)", { XX
} },
7226 { "(bad)", { XX
} },
7227 { "(bad)", { XX
} },
7228 { "(bad)", { XX
} },
7229 { "(bad)", { XX
} },
7230 { "(bad)", { XX
} },
7231 { "(bad)", { XX
} },
7232 { "(bad)", { XX
} },
7237 { "(bad)", { XX
} },
7238 { "(bad)", { XX
} },
7239 { "(bad)", { XX
} },
7240 { "(bad)", { XX
} },
7241 { "(bad)", { XX
} },
7242 { "(bad)", { XX
} },
7243 { "(bad)", { XX
} },
7244 { "(bad)", { XX
} },
7246 { "(bad)", { XX
} },
7247 { "(bad)", { XX
} },
7248 { "(bad)", { XX
} },
7249 { "(bad)", { XX
} },
7250 { "(bad)", { XX
} },
7251 { "(bad)", { XX
} },
7252 { "(bad)", { XX
} },
7253 { "(bad)", { XX
} },
7255 { "(bad)", { XX
} },
7256 { "(bad)", { XX
} },
7257 { REG_TABLE (REG_XOP_LWP
) },
7258 { "(bad)", { XX
} },
7259 { "(bad)", { XX
} },
7260 { "(bad)", { XX
} },
7261 { "(bad)", { XX
} },
7262 { "(bad)", { XX
} },
7264 { "(bad)", { XX
} },
7265 { "(bad)", { XX
} },
7266 { "(bad)", { XX
} },
7267 { "(bad)", { XX
} },
7268 { "(bad)", { XX
} },
7269 { "(bad)", { XX
} },
7270 { "(bad)", { XX
} },
7271 { "(bad)", { XX
} },
7273 { "(bad)", { XX
} },
7274 { "(bad)", { XX
} },
7275 { "(bad)", { XX
} },
7276 { "(bad)", { XX
} },
7277 { "(bad)", { XX
} },
7278 { "(bad)", { XX
} },
7279 { "(bad)", { XX
} },
7280 { "(bad)", { XX
} },
7282 { "(bad)", { XX
} },
7283 { "(bad)", { XX
} },
7284 { "(bad)", { XX
} },
7285 { "(bad)", { XX
} },
7286 { "(bad)", { XX
} },
7287 { "(bad)", { XX
} },
7288 { "(bad)", { XX
} },
7289 { "(bad)", { XX
} },
7291 { "(bad)", { XX
} },
7292 { "(bad)", { XX
} },
7293 { "(bad)", { XX
} },
7294 { "(bad)", { XX
} },
7295 { "(bad)", { XX
} },
7296 { "(bad)", { XX
} },
7297 { "(bad)", { XX
} },
7298 { "(bad)", { XX
} },
7300 { "(bad)", { XX
} },
7301 { "(bad)", { XX
} },
7302 { "(bad)", { XX
} },
7303 { "(bad)", { XX
} },
7304 { "(bad)", { XX
} },
7305 { "(bad)", { XX
} },
7306 { "(bad)", { XX
} },
7307 { "(bad)", { XX
} },
7309 { "(bad)", { XX
} },
7310 { "(bad)", { XX
} },
7311 { "(bad)", { XX
} },
7312 { "(bad)", { XX
} },
7313 { "(bad)", { XX
} },
7314 { "(bad)", { XX
} },
7315 { "(bad)", { XX
} },
7316 { "(bad)", { XX
} },
7318 { "(bad)", { XX
} },
7319 { "(bad)", { XX
} },
7320 { "(bad)", { XX
} },
7321 { "(bad)", { XX
} },
7322 { "(bad)", { XX
} },
7323 { "(bad)", { XX
} },
7324 { "(bad)", { XX
} },
7325 { "(bad)", { XX
} },
7327 { "(bad)", { XX
} },
7328 { "(bad)", { XX
} },
7329 { "(bad)", { XX
} },
7330 { "(bad)", { XX
} },
7331 { "(bad)", { XX
} },
7332 { "(bad)", { XX
} },
7333 { "(bad)", { XX
} },
7334 { "(bad)", { XX
} },
7336 { "(bad)", { XX
} },
7337 { "(bad)", { XX
} },
7338 { "(bad)", { XX
} },
7339 { "(bad)", { XX
} },
7340 { "(bad)", { XX
} },
7341 { "(bad)", { XX
} },
7342 { "(bad)", { XX
} },
7343 { "(bad)", { XX
} },
7345 { "(bad)", { XX
} },
7346 { "(bad)", { XX
} },
7347 { "(bad)", { XX
} },
7348 { "(bad)", { XX
} },
7349 { "(bad)", { XX
} },
7350 { "(bad)", { XX
} },
7351 { "(bad)", { XX
} },
7352 { "(bad)", { XX
} },
7354 { "(bad)", { XX
} },
7355 { "(bad)", { XX
} },
7356 { "(bad)", { XX
} },
7357 { "(bad)", { XX
} },
7358 { "(bad)", { XX
} },
7359 { "(bad)", { XX
} },
7360 { "(bad)", { XX
} },
7361 { "(bad)", { XX
} },
7363 { "(bad)", { XX
} },
7364 { "(bad)", { XX
} },
7365 { "(bad)", { XX
} },
7366 { "(bad)", { XX
} },
7367 { "(bad)", { XX
} },
7368 { "(bad)", { XX
} },
7369 { "(bad)", { XX
} },
7370 { "(bad)", { XX
} },
7372 { "(bad)", { XX
} },
7373 { "(bad)", { XX
} },
7374 { "(bad)", { XX
} },
7375 { "(bad)", { XX
} },
7376 { "(bad)", { XX
} },
7377 { "(bad)", { XX
} },
7378 { "(bad)", { XX
} },
7379 { "(bad)", { XX
} },
7381 { "(bad)", { XX
} },
7382 { "(bad)", { XX
} },
7383 { "(bad)", { XX
} },
7384 { "(bad)", { XX
} },
7385 { "(bad)", { XX
} },
7386 { "(bad)", { XX
} },
7387 { "(bad)", { XX
} },
7388 { "(bad)", { XX
} },
7390 { "(bad)", { XX
} },
7391 { "(bad)", { XX
} },
7392 { "(bad)", { XX
} },
7393 { "(bad)", { XX
} },
7394 { "(bad)", { XX
} },
7395 { "(bad)", { XX
} },
7396 { "(bad)", { XX
} },
7397 { "(bad)", { XX
} },
7399 { "(bad)", { XX
} },
7400 { "(bad)", { XX
} },
7401 { "(bad)", { XX
} },
7402 { "(bad)", { XX
} },
7403 { "(bad)", { XX
} },
7404 { "(bad)", { XX
} },
7405 { "(bad)", { XX
} },
7406 { "(bad)", { XX
} },
7408 { "(bad)", { XX
} },
7409 { "(bad)", { XX
} },
7410 { "(bad)", { XX
} },
7411 { "(bad)", { XX
} },
7412 { "(bad)", { XX
} },
7413 { "(bad)", { XX
} },
7414 { "(bad)", { XX
} },
7415 { "(bad)", { XX
} },
7417 { "(bad)", { XX
} },
7418 { "(bad)", { XX
} },
7419 { "(bad)", { XX
} },
7420 { "(bad)", { XX
} },
7421 { "(bad)", { XX
} },
7422 { "(bad)", { XX
} },
7423 { "(bad)", { XX
} },
7424 { "(bad)", { XX
} },
7426 { "(bad)", { XX
} },
7427 { "(bad)", { XX
} },
7428 { "(bad)", { XX
} },
7429 { "(bad)", { XX
} },
7430 { "(bad)", { XX
} },
7431 { "(bad)", { XX
} },
7432 { "(bad)", { XX
} },
7433 { "(bad)", { XX
} },
7435 { "(bad)", { XX
} },
7436 { "(bad)", { XX
} },
7437 { "(bad)", { XX
} },
7438 { "(bad)", { XX
} },
7439 { "(bad)", { XX
} },
7440 { "(bad)", { XX
} },
7441 { "(bad)", { XX
} },
7442 { "(bad)", { XX
} },
7444 { "(bad)", { XX
} },
7445 { "(bad)", { XX
} },
7446 { "(bad)", { XX
} },
7447 { "(bad)", { XX
} },
7448 { "(bad)", { XX
} },
7449 { "(bad)", { XX
} },
7450 { "(bad)", { XX
} },
7451 { "(bad)", { XX
} },
7453 { "(bad)", { XX
} },
7454 { "(bad)", { XX
} },
7455 { "(bad)", { XX
} },
7456 { "(bad)", { XX
} },
7457 { "(bad)", { XX
} },
7458 { "(bad)", { XX
} },
7459 { "(bad)", { XX
} },
7460 { "(bad)", { XX
} },
7462 { "(bad)", { XX
} },
7463 { "(bad)", { XX
} },
7464 { "(bad)", { XX
} },
7465 { "(bad)", { XX
} },
7466 { "(bad)", { XX
} },
7467 { "(bad)", { XX
} },
7468 { "(bad)", { XX
} },
7469 { "(bad)", { XX
} },
7471 { "(bad)", { XX
} },
7472 { "(bad)", { XX
} },
7473 { "(bad)", { XX
} },
7474 { "(bad)", { XX
} },
7475 { "(bad)", { XX
} },
7476 { "(bad)", { XX
} },
7477 { "(bad)", { XX
} },
7478 { "(bad)", { XX
} },
7480 { "(bad)", { XX
} },
7481 { "(bad)", { XX
} },
7482 { "(bad)", { XX
} },
7483 { "(bad)", { XX
} },
7484 { "(bad)", { XX
} },
7485 { "(bad)", { XX
} },
7486 { "(bad)", { XX
} },
7487 { "(bad)", { XX
} },
7489 { "(bad)", { XX
} },
7490 { "(bad)", { XX
} },
7491 { "(bad)", { XX
} },
7492 { "(bad)", { XX
} },
7493 { "(bad)", { XX
} },
7494 { "(bad)", { XX
} },
7495 { "(bad)", { XX
} },
7496 { "(bad)", { XX
} },
7498 { "(bad)", { XX
} },
7499 { "(bad)", { XX
} },
7500 { "(bad)", { XX
} },
7501 { "(bad)", { XX
} },
7502 { "(bad)", { XX
} },
7503 { "(bad)", { XX
} },
7504 { "(bad)", { XX
} },
7505 { "(bad)", { XX
} },
7507 { "(bad)", { XX
} },
7508 { "(bad)", { XX
} },
7509 { "(bad)", { XX
} },
7510 { "(bad)", { XX
} },
7511 { "(bad)", { XX
} },
7512 { "(bad)", { XX
} },
7513 { "(bad)", { XX
} },
7514 { "(bad)", { XX
} },
7516 { "(bad)", { XX
} },
7517 { "(bad)", { XX
} },
7518 { "(bad)", { XX
} },
7519 { "(bad)", { XX
} },
7520 { "(bad)", { XX
} },
7521 { "(bad)", { XX
} },
7522 { "(bad)", { XX
} },
7523 { "(bad)", { XX
} },
7527 static const struct dis386 vex_table
[][256] = {
7531 { "(bad)", { XX
} },
7532 { "(bad)", { XX
} },
7533 { "(bad)", { XX
} },
7534 { "(bad)", { XX
} },
7535 { "(bad)", { XX
} },
7536 { "(bad)", { XX
} },
7537 { "(bad)", { XX
} },
7538 { "(bad)", { XX
} },
7540 { "(bad)", { XX
} },
7541 { "(bad)", { XX
} },
7542 { "(bad)", { XX
} },
7543 { "(bad)", { XX
} },
7544 { "(bad)", { XX
} },
7545 { "(bad)", { XX
} },
7546 { "(bad)", { XX
} },
7547 { "(bad)", { XX
} },
7549 { PREFIX_TABLE (PREFIX_VEX_10
) },
7550 { PREFIX_TABLE (PREFIX_VEX_11
) },
7551 { PREFIX_TABLE (PREFIX_VEX_12
) },
7552 { MOD_TABLE (MOD_VEX_13
) },
7553 { VEX_W_TABLE (VEX_W_14
) },
7554 { VEX_W_TABLE (VEX_W_15
) },
7555 { PREFIX_TABLE (PREFIX_VEX_16
) },
7556 { MOD_TABLE (MOD_VEX_17
) },
7558 { "(bad)", { XX
} },
7559 { "(bad)", { XX
} },
7560 { "(bad)", { XX
} },
7561 { "(bad)", { XX
} },
7562 { "(bad)", { XX
} },
7563 { "(bad)", { XX
} },
7564 { "(bad)", { XX
} },
7565 { "(bad)", { XX
} },
7567 { "(bad)", { XX
} },
7568 { "(bad)", { XX
} },
7569 { "(bad)", { XX
} },
7570 { "(bad)", { XX
} },
7571 { "(bad)", { XX
} },
7572 { "(bad)", { XX
} },
7573 { "(bad)", { XX
} },
7574 { "(bad)", { XX
} },
7576 { VEX_W_TABLE (VEX_W_28
) },
7577 { VEX_W_TABLE (VEX_W_29
) },
7578 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7579 { MOD_TABLE (MOD_VEX_2B
) },
7580 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7581 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7582 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7583 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7585 { "(bad)", { XX
} },
7586 { "(bad)", { XX
} },
7587 { "(bad)", { XX
} },
7588 { "(bad)", { XX
} },
7589 { "(bad)", { XX
} },
7590 { "(bad)", { XX
} },
7591 { "(bad)", { XX
} },
7592 { "(bad)", { XX
} },
7594 { "(bad)", { XX
} },
7595 { "(bad)", { XX
} },
7596 { "(bad)", { XX
} },
7597 { "(bad)", { XX
} },
7598 { "(bad)", { XX
} },
7599 { "(bad)", { XX
} },
7600 { "(bad)", { XX
} },
7601 { "(bad)", { XX
} },
7603 { "(bad)", { XX
} },
7604 { "(bad)", { XX
} },
7605 { "(bad)", { XX
} },
7606 { "(bad)", { XX
} },
7607 { "(bad)", { XX
} },
7608 { "(bad)", { XX
} },
7609 { "(bad)", { XX
} },
7610 { "(bad)", { XX
} },
7612 { "(bad)", { XX
} },
7613 { "(bad)", { XX
} },
7614 { "(bad)", { XX
} },
7615 { "(bad)", { XX
} },
7616 { "(bad)", { XX
} },
7617 { "(bad)", { XX
} },
7618 { "(bad)", { XX
} },
7619 { "(bad)", { XX
} },
7621 { MOD_TABLE (MOD_VEX_50
) },
7622 { PREFIX_TABLE (PREFIX_VEX_51
) },
7623 { PREFIX_TABLE (PREFIX_VEX_52
) },
7624 { PREFIX_TABLE (PREFIX_VEX_53
) },
7625 { "vandpX", { XM
, Vex
, EXx
} },
7626 { "vandnpX", { XM
, Vex
, EXx
} },
7627 { "vorpX", { XM
, Vex
, EXx
} },
7628 { "vxorpX", { XM
, Vex
, EXx
} },
7630 { PREFIX_TABLE (PREFIX_VEX_58
) },
7631 { PREFIX_TABLE (PREFIX_VEX_59
) },
7632 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7633 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7634 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7635 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7636 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7637 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7639 { PREFIX_TABLE (PREFIX_VEX_60
) },
7640 { PREFIX_TABLE (PREFIX_VEX_61
) },
7641 { PREFIX_TABLE (PREFIX_VEX_62
) },
7642 { PREFIX_TABLE (PREFIX_VEX_63
) },
7643 { PREFIX_TABLE (PREFIX_VEX_64
) },
7644 { PREFIX_TABLE (PREFIX_VEX_65
) },
7645 { PREFIX_TABLE (PREFIX_VEX_66
) },
7646 { PREFIX_TABLE (PREFIX_VEX_67
) },
7648 { PREFIX_TABLE (PREFIX_VEX_68
) },
7649 { PREFIX_TABLE (PREFIX_VEX_69
) },
7650 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7651 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7652 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7653 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7654 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7655 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7657 { PREFIX_TABLE (PREFIX_VEX_70
) },
7658 { REG_TABLE (REG_VEX_71
) },
7659 { REG_TABLE (REG_VEX_72
) },
7660 { REG_TABLE (REG_VEX_73
) },
7661 { PREFIX_TABLE (PREFIX_VEX_74
) },
7662 { PREFIX_TABLE (PREFIX_VEX_75
) },
7663 { PREFIX_TABLE (PREFIX_VEX_76
) },
7664 { PREFIX_TABLE (PREFIX_VEX_77
) },
7666 { "(bad)", { XX
} },
7667 { "(bad)", { XX
} },
7668 { "(bad)", { XX
} },
7669 { "(bad)", { XX
} },
7670 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7671 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7672 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7673 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7675 { "(bad)", { XX
} },
7676 { "(bad)", { XX
} },
7677 { "(bad)", { XX
} },
7678 { "(bad)", { XX
} },
7679 { "(bad)", { XX
} },
7680 { "(bad)", { XX
} },
7681 { "(bad)", { XX
} },
7682 { "(bad)", { XX
} },
7684 { "(bad)", { XX
} },
7685 { "(bad)", { XX
} },
7686 { "(bad)", { XX
} },
7687 { "(bad)", { XX
} },
7688 { "(bad)", { XX
} },
7689 { "(bad)", { XX
} },
7690 { "(bad)", { XX
} },
7691 { "(bad)", { XX
} },
7693 { "(bad)", { XX
} },
7694 { "(bad)", { XX
} },
7695 { "(bad)", { XX
} },
7696 { "(bad)", { XX
} },
7697 { "(bad)", { XX
} },
7698 { "(bad)", { XX
} },
7699 { "(bad)", { XX
} },
7700 { "(bad)", { XX
} },
7702 { "(bad)", { XX
} },
7703 { "(bad)", { XX
} },
7704 { "(bad)", { XX
} },
7705 { "(bad)", { XX
} },
7706 { "(bad)", { XX
} },
7707 { "(bad)", { XX
} },
7708 { "(bad)", { XX
} },
7709 { "(bad)", { XX
} },
7711 { "(bad)", { XX
} },
7712 { "(bad)", { XX
} },
7713 { "(bad)", { XX
} },
7714 { "(bad)", { XX
} },
7715 { "(bad)", { XX
} },
7716 { "(bad)", { XX
} },
7717 { "(bad)", { XX
} },
7718 { "(bad)", { XX
} },
7720 { "(bad)", { XX
} },
7721 { "(bad)", { XX
} },
7722 { "(bad)", { XX
} },
7723 { "(bad)", { XX
} },
7724 { "(bad)", { XX
} },
7725 { "(bad)", { XX
} },
7726 { REG_TABLE (REG_VEX_AE
) },
7727 { "(bad)", { XX
} },
7729 { "(bad)", { XX
} },
7730 { "(bad)", { XX
} },
7731 { "(bad)", { XX
} },
7732 { "(bad)", { XX
} },
7733 { "(bad)", { XX
} },
7734 { "(bad)", { XX
} },
7735 { "(bad)", { XX
} },
7736 { "(bad)", { XX
} },
7738 { "(bad)", { XX
} },
7739 { "(bad)", { XX
} },
7740 { "(bad)", { XX
} },
7741 { "(bad)", { XX
} },
7742 { "(bad)", { XX
} },
7743 { "(bad)", { XX
} },
7744 { "(bad)", { XX
} },
7745 { "(bad)", { XX
} },
7747 { "(bad)", { XX
} },
7748 { "(bad)", { XX
} },
7749 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7750 { "(bad)", { XX
} },
7751 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7752 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7753 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7754 { "(bad)", { XX
} },
7756 { "(bad)", { XX
} },
7757 { "(bad)", { XX
} },
7758 { "(bad)", { XX
} },
7759 { "(bad)", { XX
} },
7760 { "(bad)", { XX
} },
7761 { "(bad)", { XX
} },
7762 { "(bad)", { XX
} },
7763 { "(bad)", { XX
} },
7765 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7766 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7767 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7768 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7769 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7770 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7771 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7772 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7774 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7775 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7776 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7777 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7778 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7779 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7780 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7781 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7783 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7784 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7785 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7786 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7787 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7788 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7789 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7790 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7792 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7793 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7794 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7795 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7796 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7797 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7798 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7799 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7801 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7802 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7803 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7804 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7805 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7806 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7807 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7808 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7810 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7811 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7812 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7813 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7814 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7815 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7816 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7817 { "(bad)", { XX
} },
7822 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7823 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7824 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7825 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7826 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7827 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7828 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7829 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7831 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7832 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7833 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7834 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7835 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7836 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7837 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7838 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7840 { "(bad)", { XX
} },
7841 { "(bad)", { XX
} },
7842 { "(bad)", { XX
} },
7843 { "(bad)", { XX
} },
7844 { "(bad)", { XX
} },
7845 { "(bad)", { XX
} },
7846 { "(bad)", { XX
} },
7847 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7849 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7850 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7851 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7852 { "(bad)", { XX
} },
7853 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7854 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7855 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7856 { "(bad)", { XX
} },
7858 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7859 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7860 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7861 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7862 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7863 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7864 { "(bad)", { XX
} },
7865 { "(bad)", { XX
} },
7867 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7868 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7869 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7870 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7871 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7872 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7873 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7874 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7876 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7877 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7878 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7879 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7880 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7881 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7882 { "(bad)", { XX
} },
7883 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7885 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7886 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7887 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7888 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7889 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7890 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7891 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7892 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7894 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7895 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7896 { "(bad)", { XX
} },
7897 { "(bad)", { XX
} },
7898 { "(bad)", { XX
} },
7899 { "(bad)", { XX
} },
7900 { "(bad)", { XX
} },
7901 { "(bad)", { XX
} },
7903 { "(bad)", { XX
} },
7904 { "(bad)", { XX
} },
7905 { "(bad)", { XX
} },
7906 { "(bad)", { XX
} },
7907 { "(bad)", { XX
} },
7908 { "(bad)", { XX
} },
7909 { "(bad)", { XX
} },
7910 { "(bad)", { XX
} },
7912 { "(bad)", { XX
} },
7913 { "(bad)", { XX
} },
7914 { "(bad)", { XX
} },
7915 { "(bad)", { XX
} },
7916 { "(bad)", { XX
} },
7917 { "(bad)", { XX
} },
7918 { "(bad)", { XX
} },
7919 { "(bad)", { XX
} },
7921 { "(bad)", { XX
} },
7922 { "(bad)", { XX
} },
7923 { "(bad)", { XX
} },
7924 { "(bad)", { XX
} },
7925 { "(bad)", { XX
} },
7926 { "(bad)", { XX
} },
7927 { "(bad)", { XX
} },
7928 { "(bad)", { XX
} },
7930 { "(bad)", { XX
} },
7931 { "(bad)", { XX
} },
7932 { "(bad)", { XX
} },
7933 { "(bad)", { XX
} },
7934 { "(bad)", { XX
} },
7935 { "(bad)", { XX
} },
7936 { "(bad)", { XX
} },
7937 { "(bad)", { XX
} },
7939 { "(bad)", { XX
} },
7940 { "(bad)", { XX
} },
7941 { "(bad)", { XX
} },
7942 { "(bad)", { XX
} },
7943 { "(bad)", { XX
} },
7944 { "(bad)", { XX
} },
7945 { "(bad)", { XX
} },
7946 { "(bad)", { XX
} },
7948 { "(bad)", { XX
} },
7949 { "(bad)", { XX
} },
7950 { "(bad)", { XX
} },
7951 { "(bad)", { XX
} },
7952 { "(bad)", { XX
} },
7953 { "(bad)", { XX
} },
7954 { "(bad)", { XX
} },
7955 { "(bad)", { XX
} },
7957 { "(bad)", { XX
} },
7958 { "(bad)", { XX
} },
7959 { "(bad)", { XX
} },
7960 { "(bad)", { XX
} },
7961 { "(bad)", { XX
} },
7962 { "(bad)", { XX
} },
7963 { "(bad)", { XX
} },
7964 { "(bad)", { XX
} },
7966 { "(bad)", { XX
} },
7967 { "(bad)", { XX
} },
7968 { "(bad)", { XX
} },
7969 { "(bad)", { XX
} },
7970 { "(bad)", { XX
} },
7971 { "(bad)", { XX
} },
7972 { "(bad)", { XX
} },
7973 { "(bad)", { XX
} },
7975 { "(bad)", { XX
} },
7976 { "(bad)", { XX
} },
7977 { "(bad)", { XX
} },
7978 { "(bad)", { XX
} },
7979 { "(bad)", { XX
} },
7980 { "(bad)", { XX
} },
7981 { "(bad)", { XX
} },
7982 { "(bad)", { XX
} },
7984 { "(bad)", { XX
} },
7985 { "(bad)", { XX
} },
7986 { "(bad)", { XX
} },
7987 { "(bad)", { XX
} },
7988 { "(bad)", { XX
} },
7989 { "(bad)", { XX
} },
7990 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7991 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7993 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7994 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7995 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7996 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7997 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7998 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7999 { PREFIX_TABLE (PREFIX_VEX_389E
) },
8000 { PREFIX_TABLE (PREFIX_VEX_389F
) },
8002 { "(bad)", { XX
} },
8003 { "(bad)", { XX
} },
8004 { "(bad)", { XX
} },
8005 { "(bad)", { XX
} },
8006 { "(bad)", { XX
} },
8007 { "(bad)", { XX
} },
8008 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
8009 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
8011 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
8012 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
8013 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
8014 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
8015 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
8016 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
8017 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
8018 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
8020 { "(bad)", { XX
} },
8021 { "(bad)", { XX
} },
8022 { "(bad)", { XX
} },
8023 { "(bad)", { XX
} },
8024 { "(bad)", { XX
} },
8025 { "(bad)", { XX
} },
8026 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
8027 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
8029 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
8030 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
8031 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
8032 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
8033 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
8034 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
8035 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
8036 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
8038 { "(bad)", { XX
} },
8039 { "(bad)", { XX
} },
8040 { "(bad)", { XX
} },
8041 { "(bad)", { XX
} },
8042 { "(bad)", { XX
} },
8043 { "(bad)", { XX
} },
8044 { "(bad)", { XX
} },
8045 { "(bad)", { XX
} },
8047 { "(bad)", { XX
} },
8048 { "(bad)", { XX
} },
8049 { "(bad)", { XX
} },
8050 { "(bad)", { XX
} },
8051 { "(bad)", { XX
} },
8052 { "(bad)", { XX
} },
8053 { "(bad)", { XX
} },
8054 { "(bad)", { XX
} },
8056 { "(bad)", { XX
} },
8057 { "(bad)", { XX
} },
8058 { "(bad)", { XX
} },
8059 { "(bad)", { XX
} },
8060 { "(bad)", { XX
} },
8061 { "(bad)", { XX
} },
8062 { "(bad)", { XX
} },
8063 { "(bad)", { XX
} },
8065 { "(bad)", { XX
} },
8066 { "(bad)", { XX
} },
8067 { "(bad)", { XX
} },
8068 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
8069 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
8070 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
8071 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
8072 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
8074 { "(bad)", { XX
} },
8075 { "(bad)", { XX
} },
8076 { "(bad)", { XX
} },
8077 { "(bad)", { XX
} },
8078 { "(bad)", { XX
} },
8079 { "(bad)", { XX
} },
8080 { "(bad)", { XX
} },
8081 { "(bad)", { XX
} },
8083 { "(bad)", { XX
} },
8084 { "(bad)", { XX
} },
8085 { "(bad)", { XX
} },
8086 { "(bad)", { XX
} },
8087 { "(bad)", { XX
} },
8088 { "(bad)", { XX
} },
8089 { "(bad)", { XX
} },
8090 { "(bad)", { XX
} },
8092 { "(bad)", { XX
} },
8093 { "(bad)", { XX
} },
8094 { "(bad)", { XX
} },
8095 { "(bad)", { XX
} },
8096 { "(bad)", { XX
} },
8097 { "(bad)", { XX
} },
8098 { "(bad)", { XX
} },
8099 { "(bad)", { XX
} },
8101 { "(bad)", { XX
} },
8102 { "(bad)", { XX
} },
8103 { "(bad)", { XX
} },
8104 { "(bad)", { XX
} },
8105 { "(bad)", { XX
} },
8106 { "(bad)", { XX
} },
8107 { "(bad)", { XX
} },
8108 { "(bad)", { XX
} },
8113 { "(bad)", { XX
} },
8114 { "(bad)", { XX
} },
8115 { "(bad)", { XX
} },
8116 { "(bad)", { XX
} },
8117 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
8118 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
8119 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
8120 { "(bad)", { XX
} },
8122 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
8123 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
8124 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
8125 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
8126 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
8127 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
8128 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
8129 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
8131 { "(bad)", { XX
} },
8132 { "(bad)", { XX
} },
8133 { "(bad)", { XX
} },
8134 { "(bad)", { XX
} },
8135 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
8136 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
8137 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
8138 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
8140 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
8141 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
8142 { "(bad)", { XX
} },
8143 { "(bad)", { XX
} },
8144 { "(bad)", { XX
} },
8145 { "(bad)", { XX
} },
8146 { "(bad)", { XX
} },
8147 { "(bad)", { XX
} },
8149 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
8150 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
8151 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
8152 { "(bad)", { XX
} },
8153 { "(bad)", { XX
} },
8154 { "(bad)", { XX
} },
8155 { "(bad)", { XX
} },
8156 { "(bad)", { XX
} },
8158 { "(bad)", { XX
} },
8159 { "(bad)", { XX
} },
8160 { "(bad)", { XX
} },
8161 { "(bad)", { XX
} },
8162 { "(bad)", { XX
} },
8163 { "(bad)", { XX
} },
8164 { "(bad)", { XX
} },
8165 { "(bad)", { XX
} },
8167 { "(bad)", { XX
} },
8168 { "(bad)", { XX
} },
8169 { "(bad)", { XX
} },
8170 { "(bad)", { XX
} },
8171 { "(bad)", { XX
} },
8172 { "(bad)", { XX
} },
8173 { "(bad)", { XX
} },
8174 { "(bad)", { XX
} },
8176 { "(bad)", { XX
} },
8177 { "(bad)", { XX
} },
8178 { "(bad)", { XX
} },
8179 { "(bad)", { XX
} },
8180 { "(bad)", { XX
} },
8181 { "(bad)", { XX
} },
8182 { "(bad)", { XX
} },
8183 { "(bad)", { XX
} },
8185 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
8186 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
8187 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
8188 { "(bad)", { XX
} },
8189 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
8190 { "(bad)", { XX
} },
8191 { "(bad)", { XX
} },
8192 { "(bad)", { XX
} },
8194 { "(bad)", { XX
} },
8195 { "(bad)", { XX
} },
8196 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
8197 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
8198 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
8199 { "(bad)", { XX
} },
8200 { "(bad)", { XX
} },
8201 { "(bad)", { XX
} },
8203 { "(bad)", { XX
} },
8204 { "(bad)", { XX
} },
8205 { "(bad)", { XX
} },
8206 { "(bad)", { XX
} },
8207 { "(bad)", { XX
} },
8208 { "(bad)", { XX
} },
8209 { "(bad)", { XX
} },
8210 { "(bad)", { XX
} },
8212 { "(bad)", { XX
} },
8213 { "(bad)", { XX
} },
8214 { "(bad)", { XX
} },
8215 { "(bad)", { XX
} },
8216 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
8217 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
8218 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
8219 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
8221 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
8222 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
8223 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
8224 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
8225 { "(bad)", { XX
} },
8226 { "(bad)", { XX
} },
8227 { "(bad)", { XX
} },
8228 { "(bad)", { XX
} },
8230 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
8231 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
8232 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
8233 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
8234 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
8235 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
8236 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
8237 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
8239 { "(bad)", { XX
} },
8240 { "(bad)", { XX
} },
8241 { "(bad)", { XX
} },
8242 { "(bad)", { XX
} },
8243 { "(bad)", { XX
} },
8244 { "(bad)", { XX
} },
8245 { "(bad)", { XX
} },
8246 { "(bad)", { XX
} },
8248 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
8249 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
8250 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
8251 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
8252 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
8253 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
8254 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
8255 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
8257 { "(bad)", { XX
} },
8258 { "(bad)", { XX
} },
8259 { "(bad)", { XX
} },
8260 { "(bad)", { XX
} },
8261 { "(bad)", { XX
} },
8262 { "(bad)", { XX
} },
8263 { "(bad)", { XX
} },
8264 { "(bad)", { XX
} },
8266 { "(bad)", { XX
} },
8267 { "(bad)", { XX
} },
8268 { "(bad)", { XX
} },
8269 { "(bad)", { XX
} },
8270 { "(bad)", { XX
} },
8271 { "(bad)", { XX
} },
8272 { "(bad)", { XX
} },
8273 { "(bad)", { XX
} },
8275 { "(bad)", { XX
} },
8276 { "(bad)", { XX
} },
8277 { "(bad)", { XX
} },
8278 { "(bad)", { XX
} },
8279 { "(bad)", { XX
} },
8280 { "(bad)", { XX
} },
8281 { "(bad)", { XX
} },
8282 { "(bad)", { XX
} },
8284 { "(bad)", { XX
} },
8285 { "(bad)", { XX
} },
8286 { "(bad)", { XX
} },
8287 { "(bad)", { XX
} },
8288 { "(bad)", { XX
} },
8289 { "(bad)", { XX
} },
8290 { "(bad)", { XX
} },
8291 { "(bad)", { XX
} },
8293 { "(bad)", { XX
} },
8294 { "(bad)", { XX
} },
8295 { "(bad)", { XX
} },
8296 { "(bad)", { XX
} },
8297 { "(bad)", { XX
} },
8298 { "(bad)", { XX
} },
8299 { "(bad)", { XX
} },
8300 { "(bad)", { XX
} },
8302 { "(bad)", { XX
} },
8303 { "(bad)", { XX
} },
8304 { "(bad)", { XX
} },
8305 { "(bad)", { XX
} },
8306 { "(bad)", { XX
} },
8307 { "(bad)", { XX
} },
8308 { "(bad)", { XX
} },
8309 { "(bad)", { XX
} },
8311 { "(bad)", { XX
} },
8312 { "(bad)", { XX
} },
8313 { "(bad)", { XX
} },
8314 { "(bad)", { XX
} },
8315 { "(bad)", { XX
} },
8316 { "(bad)", { XX
} },
8317 { "(bad)", { XX
} },
8318 { "(bad)", { XX
} },
8320 { "(bad)", { XX
} },
8321 { "(bad)", { XX
} },
8322 { "(bad)", { XX
} },
8323 { "(bad)", { XX
} },
8324 { "(bad)", { XX
} },
8325 { "(bad)", { XX
} },
8326 { "(bad)", { XX
} },
8327 { "(bad)", { XX
} },
8329 { "(bad)", { XX
} },
8330 { "(bad)", { XX
} },
8331 { "(bad)", { XX
} },
8332 { "(bad)", { XX
} },
8333 { "(bad)", { XX
} },
8334 { "(bad)", { XX
} },
8335 { "(bad)", { XX
} },
8336 { "(bad)", { XX
} },
8338 { "(bad)", { XX
} },
8339 { "(bad)", { XX
} },
8340 { "(bad)", { XX
} },
8341 { "(bad)", { XX
} },
8342 { "(bad)", { XX
} },
8343 { "(bad)", { XX
} },
8344 { "(bad)", { XX
} },
8345 { "(bad)", { XX
} },
8347 { "(bad)", { XX
} },
8348 { "(bad)", { XX
} },
8349 { "(bad)", { XX
} },
8350 { "(bad)", { XX
} },
8351 { "(bad)", { XX
} },
8352 { "(bad)", { XX
} },
8353 { "(bad)", { XX
} },
8354 { "(bad)", { XX
} },
8356 { "(bad)", { XX
} },
8357 { "(bad)", { XX
} },
8358 { "(bad)", { XX
} },
8359 { "(bad)", { XX
} },
8360 { "(bad)", { XX
} },
8361 { "(bad)", { XX
} },
8362 { "(bad)", { XX
} },
8363 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8365 { "(bad)", { XX
} },
8366 { "(bad)", { XX
} },
8367 { "(bad)", { XX
} },
8368 { "(bad)", { XX
} },
8369 { "(bad)", { XX
} },
8370 { "(bad)", { XX
} },
8371 { "(bad)", { XX
} },
8372 { "(bad)", { XX
} },
8374 { "(bad)", { XX
} },
8375 { "(bad)", { XX
} },
8376 { "(bad)", { XX
} },
8377 { "(bad)", { XX
} },
8378 { "(bad)", { XX
} },
8379 { "(bad)", { XX
} },
8380 { "(bad)", { XX
} },
8381 { "(bad)", { XX
} },
8383 { "(bad)", { XX
} },
8384 { "(bad)", { XX
} },
8385 { "(bad)", { XX
} },
8386 { "(bad)", { XX
} },
8387 { "(bad)", { XX
} },
8388 { "(bad)", { XX
} },
8389 { "(bad)", { XX
} },
8390 { "(bad)", { XX
} },
8392 { "(bad)", { XX
} },
8393 { "(bad)", { XX
} },
8394 { "(bad)", { XX
} },
8395 { "(bad)", { XX
} },
8396 { "(bad)", { XX
} },
8397 { "(bad)", { XX
} },
8398 { "(bad)", { XX
} },
8399 { "(bad)", { XX
} },
8403 static const struct dis386 vex_len_table
[][2] = {
8404 /* VEX_LEN_10_P_1 */
8406 { VEX_W_TABLE (VEX_W_10_P_1
) },
8407 { "(bad)", { XX
} },
8410 /* VEX_LEN_10_P_3 */
8412 { VEX_W_TABLE (VEX_W_10_P_3
) },
8413 { "(bad)", { XX
} },
8416 /* VEX_LEN_11_P_1 */
8418 { VEX_W_TABLE (VEX_W_11_P_1
) },
8419 { "(bad)", { XX
} },
8422 /* VEX_LEN_11_P_3 */
8424 { VEX_W_TABLE (VEX_W_11_P_3
) },
8425 { "(bad)", { XX
} },
8428 /* VEX_LEN_12_P_0_M_0 */
8430 { VEX_W_TABLE (VEX_W_12_P_0_M_0
) },
8431 { "(bad)", { XX
} },
8434 /* VEX_LEN_12_P_0_M_1 */
8436 { VEX_W_TABLE (VEX_W_12_P_0_M_1
) },
8437 { "(bad)", { XX
} },
8440 /* VEX_LEN_12_P_2 */
8442 { VEX_W_TABLE (VEX_W_12_P_2
) },
8443 { "(bad)", { XX
} },
8446 /* VEX_LEN_13_M_0 */
8448 { VEX_W_TABLE (VEX_W_13_M_0
) },
8449 { "(bad)", { XX
} },
8452 /* VEX_LEN_16_P_0_M_0 */
8454 { VEX_W_TABLE (VEX_W_16_P_0_M_0
) },
8455 { "(bad)", { XX
} },
8458 /* VEX_LEN_16_P_0_M_1 */
8460 { VEX_W_TABLE (VEX_W_16_P_0_M_1
) },
8461 { "(bad)", { XX
} },
8464 /* VEX_LEN_16_P_2 */
8466 { VEX_W_TABLE (VEX_W_16_P_2
) },
8467 { "(bad)", { XX
} },
8470 /* VEX_LEN_17_M_0 */
8472 { VEX_W_TABLE (VEX_W_17_M_0
) },
8473 { "(bad)", { XX
} },
8476 /* VEX_LEN_2A_P_1 */
8478 { "vcvtsi2ss%LQ", { XM
, Vex128
, Ev
} },
8479 { "(bad)", { XX
} },
8482 /* VEX_LEN_2A_P_3 */
8484 { "vcvtsi2sd%LQ", { XM
, Vex128
, Ev
} },
8485 { "(bad)", { XX
} },
8488 /* VEX_LEN_2C_P_1 */
8490 { "vcvttss2siY", { Gv
, EXd
} },
8491 { "(bad)", { XX
} },
8494 /* VEX_LEN_2C_P_3 */
8496 { "vcvttsd2siY", { Gv
, EXq
} },
8497 { "(bad)", { XX
} },
8500 /* VEX_LEN_2D_P_1 */
8502 { "vcvtss2siY", { Gv
, EXd
} },
8503 { "(bad)", { XX
} },
8506 /* VEX_LEN_2D_P_3 */
8508 { "vcvtsd2siY", { Gv
, EXq
} },
8509 { "(bad)", { XX
} },
8512 /* VEX_LEN_2E_P_0 */
8514 { VEX_W_TABLE (VEX_W_2E_P_0
) },
8515 { "(bad)", { XX
} },
8518 /* VEX_LEN_2E_P_2 */
8520 { VEX_W_TABLE (VEX_W_2E_P_2
) },
8521 { "(bad)", { XX
} },
8524 /* VEX_LEN_2F_P_0 */
8526 { VEX_W_TABLE (VEX_W_2F_P_0
) },
8527 { "(bad)", { XX
} },
8530 /* VEX_LEN_2F_P_2 */
8532 { VEX_W_TABLE (VEX_W_2F_P_2
) },
8533 { "(bad)", { XX
} },
8536 /* VEX_LEN_51_P_1 */
8538 { VEX_W_TABLE (VEX_W_51_P_1
) },
8539 { "(bad)", { XX
} },
8542 /* VEX_LEN_51_P_3 */
8544 { VEX_W_TABLE (VEX_W_51_P_3
) },
8545 { "(bad)", { XX
} },
8548 /* VEX_LEN_52_P_1 */
8550 { VEX_W_TABLE (VEX_W_52_P_1
) },
8551 { "(bad)", { XX
} },
8554 /* VEX_LEN_53_P_1 */
8556 { VEX_W_TABLE (VEX_W_53_P_1
) },
8557 { "(bad)", { XX
} },
8560 /* VEX_LEN_58_P_1 */
8562 { VEX_W_TABLE (VEX_W_58_P_1
) },
8563 { "(bad)", { XX
} },
8566 /* VEX_LEN_58_P_3 */
8568 { VEX_W_TABLE (VEX_W_58_P_3
) },
8569 { "(bad)", { XX
} },
8572 /* VEX_LEN_59_P_1 */
8574 { VEX_W_TABLE (VEX_W_59_P_1
) },
8575 { "(bad)", { XX
} },
8578 /* VEX_LEN_59_P_3 */
8580 { VEX_W_TABLE (VEX_W_59_P_3
) },
8581 { "(bad)", { XX
} },
8584 /* VEX_LEN_5A_P_1 */
8586 { VEX_W_TABLE (VEX_W_5A_P_1
) },
8587 { "(bad)", { XX
} },
8590 /* VEX_LEN_5A_P_3 */
8592 { VEX_W_TABLE (VEX_W_5A_P_3
) },
8593 { "(bad)", { XX
} },
8596 /* VEX_LEN_5C_P_1 */
8598 { VEX_W_TABLE (VEX_W_5C_P_1
) },
8599 { "(bad)", { XX
} },
8602 /* VEX_LEN_5C_P_3 */
8604 { VEX_W_TABLE (VEX_W_5C_P_3
) },
8605 { "(bad)", { XX
} },
8608 /* VEX_LEN_5D_P_1 */
8610 { VEX_W_TABLE (VEX_W_5D_P_1
) },
8611 { "(bad)", { XX
} },
8614 /* VEX_LEN_5D_P_3 */
8616 { VEX_W_TABLE (VEX_W_5D_P_3
) },
8617 { "(bad)", { XX
} },
8620 /* VEX_LEN_5E_P_1 */
8622 { VEX_W_TABLE (VEX_W_5E_P_1
) },
8623 { "(bad)", { XX
} },
8626 /* VEX_LEN_5E_P_3 */
8628 { VEX_W_TABLE (VEX_W_5E_P_3
) },
8629 { "(bad)", { XX
} },
8632 /* VEX_LEN_5F_P_1 */
8634 { VEX_W_TABLE (VEX_W_5F_P_1
) },
8635 { "(bad)", { XX
} },
8638 /* VEX_LEN_5F_P_3 */
8640 { VEX_W_TABLE (VEX_W_5F_P_3
) },
8641 { "(bad)", { XX
} },
8644 /* VEX_LEN_60_P_2 */
8646 { VEX_W_TABLE (VEX_W_60_P_2
) },
8647 { "(bad)", { XX
} },
8650 /* VEX_LEN_61_P_2 */
8652 { VEX_W_TABLE (VEX_W_61_P_2
) },
8653 { "(bad)", { XX
} },
8656 /* VEX_LEN_62_P_2 */
8658 { VEX_W_TABLE (VEX_W_62_P_2
) },
8659 { "(bad)", { XX
} },
8662 /* VEX_LEN_63_P_2 */
8664 { VEX_W_TABLE (VEX_W_63_P_2
) },
8665 { "(bad)", { XX
} },
8668 /* VEX_LEN_64_P_2 */
8670 { VEX_W_TABLE (VEX_W_64_P_2
) },
8671 { "(bad)", { XX
} },
8674 /* VEX_LEN_65_P_2 */
8676 { VEX_W_TABLE (VEX_W_65_P_2
) },
8677 { "(bad)", { XX
} },
8680 /* VEX_LEN_66_P_2 */
8682 { VEX_W_TABLE (VEX_W_66_P_2
) },
8683 { "(bad)", { XX
} },
8686 /* VEX_LEN_67_P_2 */
8688 { VEX_W_TABLE (VEX_W_67_P_2
) },
8689 { "(bad)", { XX
} },
8692 /* VEX_LEN_68_P_2 */
8694 { VEX_W_TABLE (VEX_W_68_P_2
) },
8695 { "(bad)", { XX
} },
8698 /* VEX_LEN_69_P_2 */
8700 { VEX_W_TABLE (VEX_W_69_P_2
) },
8701 { "(bad)", { XX
} },
8704 /* VEX_LEN_6A_P_2 */
8706 { VEX_W_TABLE (VEX_W_6A_P_2
) },
8707 { "(bad)", { XX
} },
8710 /* VEX_LEN_6B_P_2 */
8712 { VEX_W_TABLE (VEX_W_6B_P_2
) },
8713 { "(bad)", { XX
} },
8716 /* VEX_LEN_6C_P_2 */
8718 { VEX_W_TABLE (VEX_W_6C_P_2
) },
8719 { "(bad)", { XX
} },
8722 /* VEX_LEN_6D_P_2 */
8724 { VEX_W_TABLE (VEX_W_6D_P_2
) },
8725 { "(bad)", { XX
} },
8728 /* VEX_LEN_6E_P_2 */
8730 { "vmovK", { XM
, Edq
} },
8731 { "(bad)", { XX
} },
8734 /* VEX_LEN_70_P_1 */
8736 { VEX_W_TABLE (VEX_W_70_P_1
) },
8737 { "(bad)", { XX
} },
8740 /* VEX_LEN_70_P_2 */
8742 { VEX_W_TABLE (VEX_W_70_P_2
) },
8743 { "(bad)", { XX
} },
8746 /* VEX_LEN_70_P_3 */
8748 { VEX_W_TABLE (VEX_W_70_P_3
) },
8749 { "(bad)", { XX
} },
8752 /* VEX_LEN_71_R_2_P_2 */
8754 { VEX_W_TABLE (VEX_W_71_R_2_P_2
) },
8755 { "(bad)", { XX
} },
8758 /* VEX_LEN_71_R_4_P_2 */
8760 { VEX_W_TABLE (VEX_W_71_R_4_P_2
) },
8761 { "(bad)", { XX
} },
8764 /* VEX_LEN_71_R_6_P_2 */
8766 { VEX_W_TABLE (VEX_W_71_R_6_P_2
) },
8767 { "(bad)", { XX
} },
8770 /* VEX_LEN_72_R_2_P_2 */
8772 { VEX_W_TABLE (VEX_W_72_R_2_P_2
) },
8773 { "(bad)", { XX
} },
8776 /* VEX_LEN_72_R_4_P_2 */
8778 { VEX_W_TABLE (VEX_W_72_R_4_P_2
) },
8779 { "(bad)", { XX
} },
8782 /* VEX_LEN_72_R_6_P_2 */
8784 { VEX_W_TABLE (VEX_W_72_R_6_P_2
) },
8785 { "(bad)", { XX
} },
8788 /* VEX_LEN_73_R_2_P_2 */
8790 { VEX_W_TABLE (VEX_W_73_R_2_P_2
) },
8791 { "(bad)", { XX
} },
8794 /* VEX_LEN_73_R_3_P_2 */
8796 { VEX_W_TABLE (VEX_W_73_R_3_P_2
) },
8797 { "(bad)", { XX
} },
8800 /* VEX_LEN_73_R_6_P_2 */
8802 { VEX_W_TABLE (VEX_W_73_R_6_P_2
) },
8803 { "(bad)", { XX
} },
8806 /* VEX_LEN_73_R_7_P_2 */
8808 { VEX_W_TABLE (VEX_W_73_R_7_P_2
) },
8809 { "(bad)", { XX
} },
8812 /* VEX_LEN_74_P_2 */
8814 { VEX_W_TABLE (VEX_W_74_P_2
) },
8815 { "(bad)", { XX
} },
8818 /* VEX_LEN_75_P_2 */
8820 { VEX_W_TABLE (VEX_W_75_P_2
) },
8821 { "(bad)", { XX
} },
8824 /* VEX_LEN_76_P_2 */
8826 { VEX_W_TABLE (VEX_W_76_P_2
) },
8827 { "(bad)", { XX
} },
8830 /* VEX_LEN_7E_P_1 */
8832 { VEX_W_TABLE (VEX_W_7E_P_1
) },
8833 { "(bad)", { XX
} },
8836 /* VEX_LEN_7E_P_2 */
8838 { "vmovK", { Edq
, XM
} },
8839 { "(bad)", { XX
} },
8842 /* VEX_LEN_AE_R_2_M_0 */
8844 { VEX_W_TABLE (VEX_W_AE_R_2_M_0
) },
8845 { "(bad)", { XX
} },
8848 /* VEX_LEN_AE_R_3_M_0 */
8850 { VEX_W_TABLE (VEX_W_AE_R_3_M_0
) },
8851 { "(bad)", { XX
} },
8854 /* VEX_LEN_C2_P_1 */
8856 { VEX_W_TABLE (VEX_W_C2_P_1
) },
8857 { "(bad)", { XX
} },
8860 /* VEX_LEN_C2_P_3 */
8862 { VEX_W_TABLE (VEX_W_C2_P_3
) },
8863 { "(bad)", { XX
} },
8866 /* VEX_LEN_C4_P_2 */
8868 { VEX_W_TABLE (VEX_W_C4_P_2
) },
8869 { "(bad)", { XX
} },
8872 /* VEX_LEN_C5_P_2 */
8874 { VEX_W_TABLE (VEX_W_C5_P_2
) },
8875 { "(bad)", { XX
} },
8878 /* VEX_LEN_D1_P_2 */
8880 { VEX_W_TABLE (VEX_W_D1_P_2
) },
8881 { "(bad)", { XX
} },
8884 /* VEX_LEN_D2_P_2 */
8886 { VEX_W_TABLE (VEX_W_D2_P_2
) },
8887 { "(bad)", { XX
} },
8890 /* VEX_LEN_D3_P_2 */
8892 { VEX_W_TABLE (VEX_W_D3_P_2
) },
8893 { "(bad)", { XX
} },
8896 /* VEX_LEN_D4_P_2 */
8898 { VEX_W_TABLE (VEX_W_D4_P_2
) },
8899 { "(bad)", { XX
} },
8902 /* VEX_LEN_D5_P_2 */
8904 { VEX_W_TABLE (VEX_W_D5_P_2
) },
8905 { "(bad)", { XX
} },
8908 /* VEX_LEN_D6_P_2 */
8910 { VEX_W_TABLE (VEX_W_D6_P_2
) },
8911 { "(bad)", { XX
} },
8914 /* VEX_LEN_D7_P_2_M_1 */
8916 { VEX_W_TABLE (VEX_W_D7_P_2_M_1
) },
8917 { "(bad)", { XX
} },
8920 /* VEX_LEN_D8_P_2 */
8922 { VEX_W_TABLE (VEX_W_D8_P_2
) },
8923 { "(bad)", { XX
} },
8926 /* VEX_LEN_D9_P_2 */
8928 { VEX_W_TABLE (VEX_W_D9_P_2
) },
8929 { "(bad)", { XX
} },
8932 /* VEX_LEN_DA_P_2 */
8934 { VEX_W_TABLE (VEX_W_DA_P_2
) },
8935 { "(bad)", { XX
} },
8938 /* VEX_LEN_DB_P_2 */
8940 { VEX_W_TABLE (VEX_W_DB_P_2
) },
8941 { "(bad)", { XX
} },
8944 /* VEX_LEN_DC_P_2 */
8946 { VEX_W_TABLE (VEX_W_DC_P_2
) },
8947 { "(bad)", { XX
} },
8950 /* VEX_LEN_DD_P_2 */
8952 { VEX_W_TABLE (VEX_W_DD_P_2
) },
8953 { "(bad)", { XX
} },
8956 /* VEX_LEN_DE_P_2 */
8958 { VEX_W_TABLE (VEX_W_DE_P_2
) },
8959 { "(bad)", { XX
} },
8962 /* VEX_LEN_DF_P_2 */
8964 { VEX_W_TABLE (VEX_W_DF_P_2
) },
8965 { "(bad)", { XX
} },
8968 /* VEX_LEN_E0_P_2 */
8970 { VEX_W_TABLE (VEX_W_E0_P_2
) },
8971 { "(bad)", { XX
} },
8974 /* VEX_LEN_E1_P_2 */
8976 { VEX_W_TABLE (VEX_W_E1_P_2
) },
8977 { "(bad)", { XX
} },
8980 /* VEX_LEN_E2_P_2 */
8982 { VEX_W_TABLE (VEX_W_E2_P_2
) },
8983 { "(bad)", { XX
} },
8986 /* VEX_LEN_E3_P_2 */
8988 { VEX_W_TABLE (VEX_W_E3_P_2
) },
8989 { "(bad)", { XX
} },
8992 /* VEX_LEN_E4_P_2 */
8994 { VEX_W_TABLE (VEX_W_E4_P_2
) },
8995 { "(bad)", { XX
} },
8998 /* VEX_LEN_E5_P_2 */
9000 { VEX_W_TABLE (VEX_W_E5_P_2
) },
9001 { "(bad)", { XX
} },
9004 /* VEX_LEN_E8_P_2 */
9006 { VEX_W_TABLE (VEX_W_E8_P_2
) },
9007 { "(bad)", { XX
} },
9010 /* VEX_LEN_E9_P_2 */
9012 { VEX_W_TABLE (VEX_W_E9_P_2
) },
9013 { "(bad)", { XX
} },
9016 /* VEX_LEN_EA_P_2 */
9018 { VEX_W_TABLE (VEX_W_EA_P_2
) },
9019 { "(bad)", { XX
} },
9022 /* VEX_LEN_EB_P_2 */
9024 { VEX_W_TABLE (VEX_W_EB_P_2
) },
9025 { "(bad)", { XX
} },
9028 /* VEX_LEN_EC_P_2 */
9030 { VEX_W_TABLE (VEX_W_EC_P_2
) },
9031 { "(bad)", { XX
} },
9034 /* VEX_LEN_ED_P_2 */
9036 { VEX_W_TABLE (VEX_W_ED_P_2
) },
9037 { "(bad)", { XX
} },
9040 /* VEX_LEN_EE_P_2 */
9042 { VEX_W_TABLE (VEX_W_EE_P_2
) },
9043 { "(bad)", { XX
} },
9046 /* VEX_LEN_EF_P_2 */
9048 { VEX_W_TABLE (VEX_W_EF_P_2
) },
9049 { "(bad)", { XX
} },
9052 /* VEX_LEN_F1_P_2 */
9054 { VEX_W_TABLE (VEX_W_F1_P_2
) },
9055 { "(bad)", { XX
} },
9058 /* VEX_LEN_F2_P_2 */
9060 { VEX_W_TABLE (VEX_W_F2_P_2
) },
9061 { "(bad)", { XX
} },
9064 /* VEX_LEN_F3_P_2 */
9066 { VEX_W_TABLE (VEX_W_F3_P_2
) },
9067 { "(bad)", { XX
} },
9070 /* VEX_LEN_F4_P_2 */
9072 { VEX_W_TABLE (VEX_W_F4_P_2
) },
9073 { "(bad)", { XX
} },
9076 /* VEX_LEN_F5_P_2 */
9078 { VEX_W_TABLE (VEX_W_F5_P_2
) },
9079 { "(bad)", { XX
} },
9082 /* VEX_LEN_F6_P_2 */
9084 { VEX_W_TABLE (VEX_W_F6_P_2
) },
9085 { "(bad)", { XX
} },
9088 /* VEX_LEN_F7_P_2 */
9090 { VEX_W_TABLE (VEX_W_F7_P_2
) },
9091 { "(bad)", { XX
} },
9094 /* VEX_LEN_F8_P_2 */
9096 { VEX_W_TABLE (VEX_W_F8_P_2
) },
9097 { "(bad)", { XX
} },
9100 /* VEX_LEN_F9_P_2 */
9102 { VEX_W_TABLE (VEX_W_F9_P_2
) },
9103 { "(bad)", { XX
} },
9106 /* VEX_LEN_FA_P_2 */
9108 { VEX_W_TABLE (VEX_W_FA_P_2
) },
9109 { "(bad)", { XX
} },
9112 /* VEX_LEN_FB_P_2 */
9114 { VEX_W_TABLE (VEX_W_FB_P_2
) },
9115 { "(bad)", { XX
} },
9118 /* VEX_LEN_FC_P_2 */
9120 { VEX_W_TABLE (VEX_W_FC_P_2
) },
9121 { "(bad)", { XX
} },
9124 /* VEX_LEN_FD_P_2 */
9126 { VEX_W_TABLE (VEX_W_FD_P_2
) },
9127 { "(bad)", { XX
} },
9130 /* VEX_LEN_FE_P_2 */
9132 { VEX_W_TABLE (VEX_W_FE_P_2
) },
9133 { "(bad)", { XX
} },
9136 /* VEX_LEN_3800_P_2 */
9138 { VEX_W_TABLE (VEX_W_3800_P_2
) },
9139 { "(bad)", { XX
} },
9142 /* VEX_LEN_3801_P_2 */
9144 { VEX_W_TABLE (VEX_W_3801_P_2
) },
9145 { "(bad)", { XX
} },
9148 /* VEX_LEN_3802_P_2 */
9150 { VEX_W_TABLE (VEX_W_3802_P_2
) },
9151 { "(bad)", { XX
} },
9154 /* VEX_LEN_3803_P_2 */
9156 { VEX_W_TABLE (VEX_W_3803_P_2
) },
9157 { "(bad)", { XX
} },
9160 /* VEX_LEN_3804_P_2 */
9162 { VEX_W_TABLE (VEX_W_3804_P_2
) },
9163 { "(bad)", { XX
} },
9166 /* VEX_LEN_3805_P_2 */
9168 { VEX_W_TABLE (VEX_W_3805_P_2
) },
9169 { "(bad)", { XX
} },
9172 /* VEX_LEN_3806_P_2 */
9174 { VEX_W_TABLE (VEX_W_3806_P_2
) },
9175 { "(bad)", { XX
} },
9178 /* VEX_LEN_3807_P_2 */
9180 { VEX_W_TABLE (VEX_W_3807_P_2
) },
9181 { "(bad)", { XX
} },
9184 /* VEX_LEN_3808_P_2 */
9186 { VEX_W_TABLE (VEX_W_3808_P_2
) },
9187 { "(bad)", { XX
} },
9190 /* VEX_LEN_3809_P_2 */
9192 { VEX_W_TABLE (VEX_W_3809_P_2
) },
9193 { "(bad)", { XX
} },
9196 /* VEX_LEN_380A_P_2 */
9198 { VEX_W_TABLE (VEX_W_380A_P_2
) },
9199 { "(bad)", { XX
} },
9202 /* VEX_LEN_380B_P_2 */
9204 { VEX_W_TABLE (VEX_W_380B_P_2
) },
9205 { "(bad)", { XX
} },
9208 /* VEX_LEN_3819_P_2_M_0 */
9210 { "(bad)", { XX
} },
9211 { VEX_W_TABLE (VEX_W_3819_P_2_M_0
) },
9214 /* VEX_LEN_381A_P_2_M_0 */
9216 { "(bad)", { XX
} },
9217 { VEX_W_TABLE (VEX_W_381A_P_2_M_0
) },
9220 /* VEX_LEN_381C_P_2 */
9222 { VEX_W_TABLE (VEX_W_381C_P_2
) },
9223 { "(bad)", { XX
} },
9226 /* VEX_LEN_381D_P_2 */
9228 { VEX_W_TABLE (VEX_W_381D_P_2
) },
9229 { "(bad)", { XX
} },
9232 /* VEX_LEN_381E_P_2 */
9234 { VEX_W_TABLE (VEX_W_381E_P_2
) },
9235 { "(bad)", { XX
} },
9238 /* VEX_LEN_3820_P_2 */
9240 { VEX_W_TABLE (VEX_W_3820_P_2
) },
9241 { "(bad)", { XX
} },
9244 /* VEX_LEN_3821_P_2 */
9246 { VEX_W_TABLE (VEX_W_3821_P_2
) },
9247 { "(bad)", { XX
} },
9250 /* VEX_LEN_3822_P_2 */
9252 { VEX_W_TABLE (VEX_W_3822_P_2
) },
9253 { "(bad)", { XX
} },
9256 /* VEX_LEN_3823_P_2 */
9258 { VEX_W_TABLE (VEX_W_3823_P_2
) },
9259 { "(bad)", { XX
} },
9262 /* VEX_LEN_3824_P_2 */
9264 { VEX_W_TABLE (VEX_W_3824_P_2
) },
9265 { "(bad)", { XX
} },
9268 /* VEX_LEN_3825_P_2 */
9270 { VEX_W_TABLE (VEX_W_3825_P_2
) },
9271 { "(bad)", { XX
} },
9274 /* VEX_LEN_3828_P_2 */
9276 { VEX_W_TABLE (VEX_W_3828_P_2
) },
9277 { "(bad)", { XX
} },
9280 /* VEX_LEN_3829_P_2 */
9282 { VEX_W_TABLE (VEX_W_3829_P_2
) },
9283 { "(bad)", { XX
} },
9286 /* VEX_LEN_382A_P_2_M_0 */
9288 { VEX_W_TABLE (VEX_W_382A_P_2_M_0
) },
9289 { "(bad)", { XX
} },
9292 /* VEX_LEN_382B_P_2 */
9294 { VEX_W_TABLE (VEX_W_382B_P_2
) },
9295 { "(bad)", { XX
} },
9298 /* VEX_LEN_3830_P_2 */
9300 { VEX_W_TABLE (VEX_W_3830_P_2
) },
9301 { "(bad)", { XX
} },
9304 /* VEX_LEN_3831_P_2 */
9306 { VEX_W_TABLE (VEX_W_3831_P_2
) },
9307 { "(bad)", { XX
} },
9310 /* VEX_LEN_3832_P_2 */
9312 { VEX_W_TABLE (VEX_W_3832_P_2
) },
9313 { "(bad)", { XX
} },
9316 /* VEX_LEN_3833_P_2 */
9318 { VEX_W_TABLE (VEX_W_3833_P_2
) },
9319 { "(bad)", { XX
} },
9322 /* VEX_LEN_3834_P_2 */
9324 { VEX_W_TABLE (VEX_W_3834_P_2
) },
9325 { "(bad)", { XX
} },
9328 /* VEX_LEN_3835_P_2 */
9330 { VEX_W_TABLE (VEX_W_3835_P_2
) },
9331 { "(bad)", { XX
} },
9334 /* VEX_LEN_3837_P_2 */
9336 { VEX_W_TABLE (VEX_W_3837_P_2
) },
9337 { "(bad)", { XX
} },
9340 /* VEX_LEN_3838_P_2 */
9342 { VEX_W_TABLE (VEX_W_3838_P_2
) },
9343 { "(bad)", { XX
} },
9346 /* VEX_LEN_3839_P_2 */
9348 { VEX_W_TABLE (VEX_W_3839_P_2
) },
9349 { "(bad)", { XX
} },
9352 /* VEX_LEN_383A_P_2 */
9354 { VEX_W_TABLE (VEX_W_383A_P_2
) },
9355 { "(bad)", { XX
} },
9358 /* VEX_LEN_383B_P_2 */
9360 { VEX_W_TABLE (VEX_W_383B_P_2
) },
9361 { "(bad)", { XX
} },
9364 /* VEX_LEN_383C_P_2 */
9366 { VEX_W_TABLE (VEX_W_383C_P_2
) },
9367 { "(bad)", { XX
} },
9370 /* VEX_LEN_383D_P_2 */
9372 { VEX_W_TABLE (VEX_W_383D_P_2
) },
9373 { "(bad)", { XX
} },
9376 /* VEX_LEN_383E_P_2 */
9378 { VEX_W_TABLE (VEX_W_383E_P_2
) },
9379 { "(bad)", { XX
} },
9382 /* VEX_LEN_383F_P_2 */
9384 { VEX_W_TABLE (VEX_W_383F_P_2
) },
9385 { "(bad)", { XX
} },
9388 /* VEX_LEN_3840_P_2 */
9390 { VEX_W_TABLE (VEX_W_3840_P_2
) },
9391 { "(bad)", { XX
} },
9394 /* VEX_LEN_3841_P_2 */
9396 { VEX_W_TABLE (VEX_W_3841_P_2
) },
9397 { "(bad)", { XX
} },
9400 /* VEX_LEN_38DB_P_2 */
9402 { VEX_W_TABLE (VEX_W_38DB_P_2
) },
9403 { "(bad)", { XX
} },
9406 /* VEX_LEN_38DC_P_2 */
9408 { VEX_W_TABLE (VEX_W_38DC_P_2
) },
9409 { "(bad)", { XX
} },
9412 /* VEX_LEN_38DD_P_2 */
9414 { VEX_W_TABLE (VEX_W_38DD_P_2
) },
9415 { "(bad)", { XX
} },
9418 /* VEX_LEN_38DE_P_2 */
9420 { VEX_W_TABLE (VEX_W_38DE_P_2
) },
9421 { "(bad)", { XX
} },
9424 /* VEX_LEN_38DF_P_2 */
9426 { VEX_W_TABLE (VEX_W_38DF_P_2
) },
9427 { "(bad)", { XX
} },
9430 /* VEX_LEN_3A06_P_2 */
9432 { "(bad)", { XX
} },
9433 { VEX_W_TABLE (VEX_W_3A06_P_2
) },
9436 /* VEX_LEN_3A0A_P_2 */
9438 { VEX_W_TABLE (VEX_W_3A0A_P_2
) },
9439 { "(bad)", { XX
} },
9442 /* VEX_LEN_3A0B_P_2 */
9444 { VEX_W_TABLE (VEX_W_3A0B_P_2
) },
9445 { "(bad)", { XX
} },
9448 /* VEX_LEN_3A0E_P_2 */
9450 { VEX_W_TABLE (VEX_W_3A0E_P_2
) },
9451 { "(bad)", { XX
} },
9454 /* VEX_LEN_3A0F_P_2 */
9456 { VEX_W_TABLE (VEX_W_3A0F_P_2
) },
9457 { "(bad)", { XX
} },
9460 /* VEX_LEN_3A14_P_2 */
9462 { VEX_W_TABLE (VEX_W_3A14_P_2
) },
9463 { "(bad)", { XX
} },
9466 /* VEX_LEN_3A15_P_2 */
9468 { VEX_W_TABLE (VEX_W_3A15_P_2
) },
9469 { "(bad)", { XX
} },
9472 /* VEX_LEN_3A16_P_2 */
9474 { "vpextrK", { Edq
, XM
, Ib
} },
9475 { "(bad)", { XX
} },
9478 /* VEX_LEN_3A17_P_2 */
9480 { "vextractps", { Edqd
, XM
, Ib
} },
9481 { "(bad)", { XX
} },
9484 /* VEX_LEN_3A18_P_2 */
9486 { "(bad)", { XX
} },
9487 { VEX_W_TABLE (VEX_W_3A18_P_2
) },
9490 /* VEX_LEN_3A19_P_2 */
9492 { "(bad)", { XX
} },
9493 { VEX_W_TABLE (VEX_W_3A19_P_2
) },
9496 /* VEX_LEN_3A20_P_2 */
9498 { VEX_W_TABLE (VEX_W_3A20_P_2
) },
9499 { "(bad)", { XX
} },
9502 /* VEX_LEN_3A21_P_2 */
9504 { VEX_W_TABLE (VEX_W_3A21_P_2
) },
9505 { "(bad)", { XX
} },
9508 /* VEX_LEN_3A22_P_2 */
9510 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9511 { "(bad)", { XX
} },
9514 /* VEX_LEN_3A41_P_2 */
9516 { VEX_W_TABLE (VEX_W_3A41_P_2
) },
9517 { "(bad)", { XX
} },
9520 /* VEX_LEN_3A42_P_2 */
9522 { VEX_W_TABLE (VEX_W_3A42_P_2
) },
9523 { "(bad)", { XX
} },
9526 /* VEX_LEN_3A44_P_2 */
9528 { VEX_W_TABLE (VEX_W_3A44_P_2
) },
9529 { "(bad)", { XX
} },
9532 /* VEX_LEN_3A4C_P_2 */
9534 { VEX_W_TABLE (VEX_W_3A4C_P_2
) },
9535 { "(bad)", { XX
} },
9538 /* VEX_LEN_3A60_P_2 */
9540 { VEX_W_TABLE (VEX_W_3A60_P_2
) },
9541 { "(bad)", { XX
} },
9544 /* VEX_LEN_3A61_P_2 */
9546 { VEX_W_TABLE (VEX_W_3A61_P_2
) },
9547 { "(bad)", { XX
} },
9550 /* VEX_LEN_3A62_P_2 */
9552 { VEX_W_TABLE (VEX_W_3A62_P_2
) },
9553 { "(bad)", { XX
} },
9556 /* VEX_LEN_3A63_P_2 */
9558 { VEX_W_TABLE (VEX_W_3A63_P_2
) },
9559 { "(bad)", { XX
} },
9562 /* VEX_LEN_3A6A_P_2 */
9564 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9565 { "(bad)", { XX
} },
9568 /* VEX_LEN_3A6B_P_2 */
9570 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9571 { "(bad)", { XX
} },
9574 /* VEX_LEN_3A6E_P_2 */
9576 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9577 { "(bad)", { XX
} },
9580 /* VEX_LEN_3A6F_P_2 */
9582 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9583 { "(bad)", { XX
} },
9586 /* VEX_LEN_3A7A_P_2 */
9588 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9589 { "(bad)", { XX
} },
9592 /* VEX_LEN_3A7B_P_2 */
9594 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9595 { "(bad)", { XX
} },
9598 /* VEX_LEN_3A7E_P_2 */
9600 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9601 { "(bad)", { XX
} },
9604 /* VEX_LEN_3A7F_P_2 */
9606 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9607 { "(bad)", { XX
} },
9610 /* VEX_LEN_3ADF_P_2 */
9612 { VEX_W_TABLE (VEX_W_3ADF_P_2
) },
9613 { "(bad)", { XX
} },
9616 /* VEX_LEN_XOP_09_80 */
9618 { "vfrczps", { XM
, EXxmm
} },
9619 { "vfrczps", { XM
, EXymmq
} },
9622 /* VEX_LEN_XOP_09_81 */
9624 { "vfrczpd", { XM
, EXxmm
} },
9625 { "vfrczpd", { XM
, EXymmq
} },
9629 static const struct dis386 vex_w_table
[][2] = {
9632 { "vmovups", { XM
, EXx
} },
9633 { "(bad)", { XX
} },
9637 { "vmovss", { XMVex
, Vex128
, EXd
} },
9638 { "(bad)", { XX
} },
9642 { "vmovupd", { XM
, EXx
} },
9643 { "(bad)", { XX
} },
9647 { "vmovsd", { XMVex
, Vex128
, EXq
} },
9648 { "(bad)", { XX
} },
9652 { "vmovups", { EXxS
, XM
} },
9653 { "(bad)", { XX
} },
9657 { "vmovss", { EXdVexS
, Vex128
, XM
} },
9658 { "(bad)", { XX
} },
9662 { "vmovupd", { EXxS
, XM
} },
9663 { "(bad)", { XX
} },
9667 { "vmovsd", { EXqVexS
, Vex128
, XM
} },
9668 { "(bad)", { XX
} },
9671 /* VEX_W_12_P_0_M_0 */
9672 { "vmovlps", { XM
, Vex128
, EXq
} },
9673 { "(bad)", { XX
} },
9676 /* VEX_W_12_P_0_M_1 */
9677 { "vmovhlps", { XM
, Vex128
, EXq
} },
9678 { "(bad)", { XX
} },
9682 { "vmovsldup", { XM
, EXx
} },
9683 { "(bad)", { XX
} },
9687 { "vmovlpd", { XM
, Vex128
, EXq
} },
9688 { "(bad)", { XX
} },
9692 { "vmovddup", { XM
, EXymmq
} },
9693 { "(bad)", { XX
} },
9697 { "vmovlpX", { EXq
, XM
} },
9698 { "(bad)", { XX
} },
9702 { "vunpcklpX", { XM
, Vex
, EXx
} },
9703 { "(bad)", { XX
} },
9707 { "vunpckhpX", { XM
, Vex
, EXx
} },
9708 { "(bad)", { XX
} },
9711 /* VEX_W_16_P_0_M_0 */
9712 { "vmovhps", { XM
, Vex128
, EXq
} },
9713 { "(bad)", { XX
} },
9716 /* VEX_W_16_P_0_M_1 */
9717 { "vmovlhps", { XM
, Vex128
, EXq
} },
9718 { "(bad)", { XX
} },
9722 { "vmovshdup", { XM
, EXx
} },
9723 { "(bad)", { XX
} },
9727 { "vmovhpd", { XM
, Vex128
, EXq
} },
9728 { "(bad)", { XX
} },
9732 { "vmovhpX", { EXq
, XM
} },
9733 { "(bad)", { XX
} },
9737 { "vmovapX", { XM
, EXx
} },
9738 { "(bad)", { XX
} },
9742 { "vmovapX", { EXxS
, XM
} },
9743 { "(bad)", { XX
} },
9747 { "vmovntpX", { Mx
, XM
} },
9748 { "(bad)", { XX
} },
9752 { "vucomiss", { XM
, EXd
} },
9753 { "(bad)", { XX
} },
9757 { "vucomisd", { XM
, EXq
} },
9758 { "(bad)", { XX
} },
9762 { "vcomiss", { XM
, EXd
} },
9763 { "(bad)", { XX
} },
9767 { "vcomisd", { XM
, EXq
} },
9768 { "(bad)", { XX
} },
9772 { "vmovmskpX", { Gdq
, XS
} },
9773 { "(bad)", { XX
} },
9777 { "vsqrtps", { XM
, EXx
} },
9778 { "(bad)", { XX
} },
9782 { "vsqrtss", { XM
, Vex128
, EXd
} },
9783 { "(bad)", { XX
} },
9787 { "vsqrtpd", { XM
, EXx
} },
9788 { "(bad)", { XX
} },
9792 { "vsqrtsd", { XM
, Vex128
, EXq
} },
9793 { "(bad)", { XX
} },
9797 { "vrsqrtps", { XM
, EXx
} },
9798 { "(bad)", { XX
} },
9802 { "vrsqrtss", { XM
, Vex128
, EXd
} },
9803 { "(bad)", { XX
} },
9807 { "vrcpps", { XM
, EXx
} },
9808 { "(bad)", { XX
} },
9812 { "vrcpss", { XM
, Vex128
, EXd
} },
9813 { "(bad)", { XX
} },
9817 { "vaddps", { XM
, Vex
, EXx
} },
9818 { "(bad)", { XX
} },
9822 { "vaddss", { XM
, Vex128
, EXd
} },
9823 { "(bad)", { XX
} },
9827 { "vaddpd", { XM
, Vex
, EXx
} },
9828 { "(bad)", { XX
} },
9832 { "vaddsd", { XM
, Vex128
, EXq
} },
9833 { "(bad)", { XX
} },
9837 { "vmulps", { XM
, Vex
, EXx
} },
9838 { "(bad)", { XX
} },
9842 { "vmulss", { XM
, Vex128
, EXd
} },
9843 { "(bad)", { XX
} },
9847 { "vmulpd", { XM
, Vex
, EXx
} },
9848 { "(bad)", { XX
} },
9852 { "vmulsd", { XM
, Vex128
, EXq
} },
9853 { "(bad)", { XX
} },
9857 { "vcvtps2pd", { XM
, EXxmmq
} },
9858 { "(bad)", { XX
} },
9862 { "vcvtss2sd", { XM
, Vex128
, EXd
} },
9863 { "(bad)", { XX
} },
9867 { "vcvtsd2ss", { XM
, Vex128
, EXq
} },
9868 { "(bad)", { XX
} },
9872 { "vcvtdq2ps", { XM
, EXx
} },
9873 { "(bad)", { XX
} },
9877 { "vcvttps2dq", { XM
, EXx
} },
9878 { "(bad)", { XX
} },
9882 { "vcvtps2dq", { XM
, EXx
} },
9883 { "(bad)", { XX
} },
9887 { "vsubps", { XM
, Vex
, EXx
} },
9888 { "(bad)", { XX
} },
9892 { "vsubss", { XM
, Vex128
, EXd
} },
9893 { "(bad)", { XX
} },
9897 { "vsubpd", { XM
, Vex
, EXx
} },
9898 { "(bad)", { XX
} },
9902 { "vsubsd", { XM
, Vex128
, EXq
} },
9903 { "(bad)", { XX
} },
9907 { "vminps", { XM
, Vex
, EXx
} },
9908 { "(bad)", { XX
} },
9912 { "vminss", { XM
, Vex128
, EXd
} },
9913 { "(bad)", { XX
} },
9917 { "vminpd", { XM
, Vex
, EXx
} },
9918 { "(bad)", { XX
} },
9922 { "vminsd", { XM
, Vex128
, EXq
} },
9923 { "(bad)", { XX
} },
9927 { "vdivps", { XM
, Vex
, EXx
} },
9928 { "(bad)", { XX
} },
9932 { "vdivss", { XM
, Vex128
, EXd
} },
9933 { "(bad)", { XX
} },
9937 { "vdivpd", { XM
, Vex
, EXx
} },
9938 { "(bad)", { XX
} },
9942 { "vdivsd", { XM
, Vex128
, EXq
} },
9943 { "(bad)", { XX
} },
9947 { "vmaxps", { XM
, Vex
, EXx
} },
9948 { "(bad)", { XX
} },
9952 { "vmaxss", { XM
, Vex128
, EXd
} },
9953 { "(bad)", { XX
} },
9957 { "vmaxpd", { XM
, Vex
, EXx
} },
9958 { "(bad)", { XX
} },
9962 { "vmaxsd", { XM
, Vex128
, EXq
} },
9963 { "(bad)", { XX
} },
9967 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
9968 { "(bad)", { XX
} },
9972 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
9973 { "(bad)", { XX
} },
9977 { "vpunpckldq", { XM
, Vex128
, EXx
} },
9978 { "(bad)", { XX
} },
9982 { "vpacksswb", { XM
, Vex128
, EXx
} },
9983 { "(bad)", { XX
} },
9987 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
9988 { "(bad)", { XX
} },
9992 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
9993 { "(bad)", { XX
} },
9997 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
9998 { "(bad)", { XX
} },
10002 { "vpackuswb", { XM
, Vex128
, EXx
} },
10003 { "(bad)", { XX
} },
10007 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
10008 { "(bad)", { XX
} },
10012 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
10013 { "(bad)", { XX
} },
10017 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
10018 { "(bad)", { XX
} },
10022 { "vpackssdw", { XM
, Vex128
, EXx
} },
10023 { "(bad)", { XX
} },
10027 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
10028 { "(bad)", { XX
} },
10032 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
10033 { "(bad)", { XX
} },
10037 { "vmovdqu", { XM
, EXx
} },
10038 { "(bad)", { XX
} },
10042 { "vmovdqa", { XM
, EXx
} },
10043 { "(bad)", { XX
} },
10047 { "vpshufhw", { XM
, EXx
, Ib
} },
10048 { "(bad)", { XX
} },
10052 { "vpshufd", { XM
, EXx
, Ib
} },
10053 { "(bad)", { XX
} },
10057 { "vpshuflw", { XM
, EXx
, Ib
} },
10058 { "(bad)", { XX
} },
10061 /* VEX_W_71_R_2_P_2 */
10062 { "vpsrlw", { Vex128
, XS
, Ib
} },
10063 { "(bad)", { XX
} },
10066 /* VEX_W_71_R_4_P_2 */
10067 { "vpsraw", { Vex128
, XS
, Ib
} },
10068 { "(bad)", { XX
} },
10071 /* VEX_W_71_R_6_P_2 */
10072 { "vpsllw", { Vex128
, XS
, Ib
} },
10073 { "(bad)", { XX
} },
10076 /* VEX_W_72_R_2_P_2 */
10077 { "vpsrld", { Vex128
, XS
, Ib
} },
10078 { "(bad)", { XX
} },
10081 /* VEX_W_72_R_4_P_2 */
10082 { "vpsrad", { Vex128
, XS
, Ib
} },
10083 { "(bad)", { XX
} },
10086 /* VEX_W_72_R_6_P_2 */
10087 { "vpslld", { Vex128
, XS
, Ib
} },
10088 { "(bad)", { XX
} },
10091 /* VEX_W_73_R_2_P_2 */
10092 { "vpsrlq", { Vex128
, XS
, Ib
} },
10093 { "(bad)", { XX
} },
10096 /* VEX_W_73_R_3_P_2 */
10097 { "vpsrldq", { Vex128
, XS
, Ib
} },
10098 { "(bad)", { XX
} },
10101 /* VEX_W_73_R_6_P_2 */
10102 { "vpsllq", { Vex128
, XS
, Ib
} },
10103 { "(bad)", { XX
} },
10106 /* VEX_W_73_R_7_P_2 */
10107 { "vpslldq", { Vex128
, XS
, Ib
} },
10108 { "(bad)", { XX
} },
10112 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
10113 { "(bad)", { XX
} },
10117 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
10118 { "(bad)", { XX
} },
10122 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
10123 { "(bad)", { XX
} },
10128 { "(bad)", { XX
} },
10132 { "vhaddpd", { XM
, Vex
, EXx
} },
10133 { "(bad)", { XX
} },
10137 { "vhaddps", { XM
, Vex
, EXx
} },
10138 { "(bad)", { XX
} },
10142 { "vhsubpd", { XM
, Vex
, EXx
} },
10143 { "(bad)", { XX
} },
10147 { "vhsubps", { XM
, Vex
, EXx
} },
10148 { "(bad)", { XX
} },
10152 { "vmovq", { XM
, EXq
} },
10153 { "(bad)", { XX
} },
10157 { "vmovdqu", { EXxS
, XM
} },
10158 { "(bad)", { XX
} },
10162 { "vmovdqa", { EXxS
, XM
} },
10163 { "(bad)", { XX
} },
10166 /* VEX_W_AE_R_2_M_0 */
10167 { "vldmxcsr", { Md
} },
10168 { "(bad)", { XX
} },
10171 /* VEX_W_AE_R_3_M_0 */
10172 { "vstmxcsr", { Md
} },
10173 { "(bad)", { XX
} },
10177 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
10178 { "(bad)", { XX
} },
10182 { "vcmpss", { XM
, Vex128
, EXd
, VCMP
} },
10183 { "(bad)", { XX
} },
10187 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
10188 { "(bad)", { XX
} },
10192 { "vcmpsd", { XM
, Vex128
, EXq
, VCMP
} },
10193 { "(bad)", { XX
} },
10197 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
10198 { "(bad)", { XX
} },
10202 { "vpextrw", { Gdq
, XS
, Ib
} },
10203 { "(bad)", { XX
} },
10207 { "vaddsubpd", { XM
, Vex
, EXx
} },
10208 { "(bad)", { XX
} },
10212 { "vaddsubps", { XM
, Vex
, EXx
} },
10213 { "(bad)", { XX
} },
10217 { "vpsrlw", { XM
, Vex128
, EXx
} },
10218 { "(bad)", { XX
} },
10222 { "vpsrld", { XM
, Vex128
, EXx
} },
10223 { "(bad)", { XX
} },
10227 { "vpsrlq", { XM
, Vex128
, EXx
} },
10228 { "(bad)", { XX
} },
10232 { "vpaddq", { XM
, Vex128
, EXx
} },
10233 { "(bad)", { XX
} },
10237 { "vpmullw", { XM
, Vex128
, EXx
} },
10238 { "(bad)", { XX
} },
10242 { "vmovq", { EXqS
, XM
} },
10243 { "(bad)", { XX
} },
10246 /* VEX_W_D7_P_2_M_1 */
10247 { "vpmovmskb", { Gdq
, XS
} },
10248 { "(bad)", { XX
} },
10252 { "vpsubusb", { XM
, Vex128
, EXx
} },
10253 { "(bad)", { XX
} },
10257 { "vpsubusw", { XM
, Vex128
, EXx
} },
10258 { "(bad)", { XX
} },
10262 { "vpminub", { XM
, Vex128
, EXx
} },
10263 { "(bad)", { XX
} },
10267 { "vpand", { XM
, Vex128
, EXx
} },
10268 { "(bad)", { XX
} },
10272 { "vpaddusb", { XM
, Vex128
, EXx
} },
10273 { "(bad)", { XX
} },
10277 { "vpaddusw", { XM
, Vex128
, EXx
} },
10278 { "(bad)", { XX
} },
10282 { "vpmaxub", { XM
, Vex128
, EXx
} },
10283 { "(bad)", { XX
} },
10287 { "vpandn", { XM
, Vex128
, EXx
} },
10288 { "(bad)", { XX
} },
10292 { "vpavgb", { XM
, Vex128
, EXx
} },
10293 { "(bad)", { XX
} },
10297 { "vpsraw", { XM
, Vex128
, EXx
} },
10298 { "(bad)", { XX
} },
10302 { "vpsrad", { XM
, Vex128
, EXx
} },
10303 { "(bad)", { XX
} },
10307 { "vpavgw", { XM
, Vex128
, EXx
} },
10308 { "(bad)", { XX
} },
10312 { "vpmulhuw", { XM
, Vex128
, EXx
} },
10313 { "(bad)", { XX
} },
10317 { "vpmulhw", { XM
, Vex128
, EXx
} },
10318 { "(bad)", { XX
} },
10322 { "vcvtdq2pd", { XM
, EXxmmq
} },
10323 { "(bad)", { XX
} },
10327 { "vcvttpd2dq%XY", { XMM
, EXx
} },
10328 { "(bad)", { XX
} },
10332 { "vcvtpd2dq%XY", { XMM
, EXx
} },
10333 { "(bad)", { XX
} },
10336 /* VEX_W_E7_P_2_M_0 */
10337 { "vmovntdq", { Mx
, XM
} },
10338 { "(bad)", { XX
} },
10342 { "vpsubsb", { XM
, Vex128
, EXx
} },
10343 { "(bad)", { XX
} },
10347 { "vpsubsw", { XM
, Vex128
, EXx
} },
10348 { "(bad)", { XX
} },
10352 { "vpminsw", { XM
, Vex128
, EXx
} },
10353 { "(bad)", { XX
} },
10357 { "vpor", { XM
, Vex128
, EXx
} },
10358 { "(bad)", { XX
} },
10362 { "vpaddsb", { XM
, Vex128
, EXx
} },
10363 { "(bad)", { XX
} },
10367 { "vpaddsw", { XM
, Vex128
, EXx
} },
10368 { "(bad)", { XX
} },
10372 { "vpmaxsw", { XM
, Vex128
, EXx
} },
10373 { "(bad)", { XX
} },
10377 { "vpxor", { XM
, Vex128
, EXx
} },
10378 { "(bad)", { XX
} },
10381 /* VEX_W_F0_P_3_M_0 */
10382 { "vlddqu", { XM
, M
} },
10383 { "(bad)", { XX
} },
10387 { "vpsllw", { XM
, Vex128
, EXx
} },
10388 { "(bad)", { XX
} },
10392 { "vpslld", { XM
, Vex128
, EXx
} },
10393 { "(bad)", { XX
} },
10397 { "vpsllq", { XM
, Vex128
, EXx
} },
10398 { "(bad)", { XX
} },
10402 { "vpmuludq", { XM
, Vex128
, EXx
} },
10403 { "(bad)", { XX
} },
10407 { "vpmaddwd", { XM
, Vex128
, EXx
} },
10408 { "(bad)", { XX
} },
10412 { "vpsadbw", { XM
, Vex128
, EXx
} },
10413 { "(bad)", { XX
} },
10417 { "vmaskmovdqu", { XM
, XS
} },
10418 { "(bad)", { XX
} },
10422 { "vpsubb", { XM
, Vex128
, EXx
} },
10423 { "(bad)", { XX
} },
10427 { "vpsubw", { XM
, Vex128
, EXx
} },
10428 { "(bad)", { XX
} },
10432 { "vpsubd", { XM
, Vex128
, EXx
} },
10433 { "(bad)", { XX
} },
10437 { "vpsubq", { XM
, Vex128
, EXx
} },
10438 { "(bad)", { XX
} },
10442 { "vpaddb", { XM
, Vex128
, EXx
} },
10443 { "(bad)", { XX
} },
10447 { "vpaddw", { XM
, Vex128
, EXx
} },
10448 { "(bad)", { XX
} },
10452 { "vpaddd", { XM
, Vex128
, EXx
} },
10453 { "(bad)", { XX
} },
10456 /* VEX_W_3800_P_2 */
10457 { "vpshufb", { XM
, Vex128
, EXx
} },
10458 { "(bad)", { XX
} },
10461 /* VEX_W_3801_P_2 */
10462 { "vphaddw", { XM
, Vex128
, EXx
} },
10463 { "(bad)", { XX
} },
10466 /* VEX_W_3802_P_2 */
10467 { "vphaddd", { XM
, Vex128
, EXx
} },
10468 { "(bad)", { XX
} },
10471 /* VEX_W_3803_P_2 */
10472 { "vphaddsw", { XM
, Vex128
, EXx
} },
10473 { "(bad)", { XX
} },
10476 /* VEX_W_3804_P_2 */
10477 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
10478 { "(bad)", { XX
} },
10481 /* VEX_W_3805_P_2 */
10482 { "vphsubw", { XM
, Vex128
, EXx
} },
10483 { "(bad)", { XX
} },
10486 /* VEX_W_3806_P_2 */
10487 { "vphsubd", { XM
, Vex128
, EXx
} },
10488 { "(bad)", { XX
} },
10491 /* VEX_W_3807_P_2 */
10492 { "vphsubsw", { XM
, Vex128
, EXx
} },
10493 { "(bad)", { XX
} },
10496 /* VEX_W_3808_P_2 */
10497 { "vpsignb", { XM
, Vex128
, EXx
} },
10498 { "(bad)", { XX
} },
10501 /* VEX_W_3809_P_2 */
10502 { "vpsignw", { XM
, Vex128
, EXx
} },
10503 { "(bad)", { XX
} },
10506 /* VEX_W_380A_P_2 */
10507 { "vpsignd", { XM
, Vex128
, EXx
} },
10508 { "(bad)", { XX
} },
10511 /* VEX_W_380B_P_2 */
10512 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
10513 { "(bad)", { XX
} },
10516 /* VEX_W_380C_P_2 */
10517 { "vpermilps", { XM
, Vex
, EXx
} },
10518 { "(bad)", { XX
} },
10521 /* VEX_W_380D_P_2 */
10522 { "vpermilpd", { XM
, Vex
, EXx
} },
10523 { "(bad)", { XX
} },
10526 /* VEX_W_380E_P_2 */
10527 { "vtestps", { XM
, EXx
} },
10528 { "(bad)", { XX
} },
10531 /* VEX_W_380F_P_2 */
10532 { "vtestpd", { XM
, EXx
} },
10533 { "(bad)", { XX
} },
10536 /* VEX_W_3817_P_2 */
10537 { "vptest", { XM
, EXx
} },
10538 { "(bad)", { XX
} },
10541 /* VEX_W_3818_P_2_M_0 */
10542 { "vbroadcastss", { XM
, Md
} },
10543 { "(bad)", { XX
} },
10546 /* VEX_W_3819_P_2_M_0 */
10547 { "vbroadcastsd", { XM
, Mq
} },
10548 { "(bad)", { XX
} },
10551 /* VEX_W_381A_P_2_M_0 */
10552 { "vbroadcastf128", { XM
, Mxmm
} },
10553 { "(bad)", { XX
} },
10556 /* VEX_W_381C_P_2 */
10557 { "vpabsb", { XM
, EXx
} },
10558 { "(bad)", { XX
} },
10561 /* VEX_W_381D_P_2 */
10562 { "vpabsw", { XM
, EXx
} },
10563 { "(bad)", { XX
} },
10566 /* VEX_W_381E_P_2 */
10567 { "vpabsd", { XM
, EXx
} },
10568 { "(bad)", { XX
} },
10571 /* VEX_W_3820_P_2 */
10572 { "vpmovsxbw", { XM
, EXq
} },
10573 { "(bad)", { XX
} },
10576 /* VEX_W_3821_P_2 */
10577 { "vpmovsxbd", { XM
, EXd
} },
10578 { "(bad)", { XX
} },
10581 /* VEX_W_3822_P_2 */
10582 { "vpmovsxbq", { XM
, EXw
} },
10583 { "(bad)", { XX
} },
10586 /* VEX_W_3823_P_2 */
10587 { "vpmovsxwd", { XM
, EXq
} },
10588 { "(bad)", { XX
} },
10591 /* VEX_W_3824_P_2 */
10592 { "vpmovsxwq", { XM
, EXd
} },
10593 { "(bad)", { XX
} },
10596 /* VEX_W_3825_P_2 */
10597 { "vpmovsxdq", { XM
, EXq
} },
10598 { "(bad)", { XX
} },
10601 /* VEX_W_3828_P_2 */
10602 { "vpmuldq", { XM
, Vex128
, EXx
} },
10603 { "(bad)", { XX
} },
10606 /* VEX_W_3829_P_2 */
10607 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
10608 { "(bad)", { XX
} },
10611 /* VEX_W_382A_P_2_M_0 */
10612 { "vmovntdqa", { XM
, Mx
} },
10613 { "(bad)", { XX
} },
10616 /* VEX_W_382B_P_2 */
10617 { "vpackusdw", { XM
, Vex128
, EXx
} },
10618 { "(bad)", { XX
} },
10621 /* VEX_W_382C_P_2_M_0 */
10622 { "vmaskmovps", { XM
, Vex
, Mx
} },
10623 { "(bad)", { XX
} },
10626 /* VEX_W_382D_P_2_M_0 */
10627 { "vmaskmovpd", { XM
, Vex
, Mx
} },
10628 { "(bad)", { XX
} },
10631 /* VEX_W_382E_P_2_M_0 */
10632 { "vmaskmovps", { Mx
, Vex
, XM
} },
10633 { "(bad)", { XX
} },
10636 /* VEX_W_382F_P_2_M_0 */
10637 { "vmaskmovpd", { Mx
, Vex
, XM
} },
10638 { "(bad)", { XX
} },
10641 /* VEX_W_3830_P_2 */
10642 { "vpmovzxbw", { XM
, EXq
} },
10643 { "(bad)", { XX
} },
10646 /* VEX_W_3831_P_2 */
10647 { "vpmovzxbd", { XM
, EXd
} },
10648 { "(bad)", { XX
} },
10651 /* VEX_W_3832_P_2 */
10652 { "vpmovzxbq", { XM
, EXw
} },
10653 { "(bad)", { XX
} },
10656 /* VEX_W_3833_P_2 */
10657 { "vpmovzxwd", { XM
, EXq
} },
10658 { "(bad)", { XX
} },
10661 /* VEX_W_3834_P_2 */
10662 { "vpmovzxwq", { XM
, EXd
} },
10663 { "(bad)", { XX
} },
10666 /* VEX_W_3835_P_2 */
10667 { "vpmovzxdq", { XM
, EXq
} },
10668 { "(bad)", { XX
} },
10671 /* VEX_W_3837_P_2 */
10672 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
10673 { "(bad)", { XX
} },
10676 /* VEX_W_3838_P_2 */
10677 { "vpminsb", { XM
, Vex128
, EXx
} },
10678 { "(bad)", { XX
} },
10681 /* VEX_W_3839_P_2 */
10682 { "vpminsd", { XM
, Vex128
, EXx
} },
10683 { "(bad)", { XX
} },
10686 /* VEX_W_383A_P_2 */
10687 { "vpminuw", { XM
, Vex128
, EXx
} },
10688 { "(bad)", { XX
} },
10691 /* VEX_W_383B_P_2 */
10692 { "vpminud", { XM
, Vex128
, EXx
} },
10693 { "(bad)", { XX
} },
10696 /* VEX_W_383C_P_2 */
10697 { "vpmaxsb", { XM
, Vex128
, EXx
} },
10698 { "(bad)", { XX
} },
10701 /* VEX_W_383D_P_2 */
10702 { "vpmaxsd", { XM
, Vex128
, EXx
} },
10703 { "(bad)", { XX
} },
10706 /* VEX_W_383E_P_2 */
10707 { "vpmaxuw", { XM
, Vex128
, EXx
} },
10708 { "(bad)", { XX
} },
10711 /* VEX_W_383F_P_2 */
10712 { "vpmaxud", { XM
, Vex128
, EXx
} },
10713 { "(bad)", { XX
} },
10716 /* VEX_W_3840_P_2 */
10717 { "vpmulld", { XM
, Vex128
, EXx
} },
10718 { "(bad)", { XX
} },
10721 /* VEX_W_3841_P_2 */
10722 { "vphminposuw", { XM
, EXx
} },
10723 { "(bad)", { XX
} },
10726 /* VEX_W_38DB_P_2 */
10727 { "vaesimc", { XM
, EXx
} },
10728 { "(bad)", { XX
} },
10731 /* VEX_W_38DC_P_2 */
10732 { "vaesenc", { XM
, Vex128
, EXx
} },
10733 { "(bad)", { XX
} },
10736 /* VEX_W_38DD_P_2 */
10737 { "vaesenclast", { XM
, Vex128
, EXx
} },
10738 { "(bad)", { XX
} },
10741 /* VEX_W_38DE_P_2 */
10742 { "vaesdec", { XM
, Vex128
, EXx
} },
10743 { "(bad)", { XX
} },
10746 /* VEX_W_38DF_P_2 */
10747 { "vaesdeclast", { XM
, Vex128
, EXx
} },
10748 { "(bad)", { XX
} },
10751 /* VEX_W_3A04_P_2 */
10752 { "vpermilps", { XM
, EXx
, Ib
} },
10753 { "(bad)", { XX
} },
10756 /* VEX_W_3A05_P_2 */
10757 { "vpermilpd", { XM
, EXx
, Ib
} },
10758 { "(bad)", { XX
} },
10761 /* VEX_W_3A06_P_2 */
10762 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
10763 { "(bad)", { XX
} },
10766 /* VEX_W_3A08_P_2 */
10767 { "vroundps", { XM
, EXx
, Ib
} },
10768 { "(bad)", { XX
} },
10771 /* VEX_W_3A09_P_2 */
10772 { "vroundpd", { XM
, EXx
, Ib
} },
10773 { "(bad)", { XX
} },
10776 /* VEX_W_3A0A_P_2 */
10777 { "vroundss", { XM
, Vex128
, EXd
, Ib
} },
10778 { "(bad)", { XX
} },
10781 /* VEX_W_3A0B_P_2 */
10782 { "vroundsd", { XM
, Vex128
, EXq
, Ib
} },
10783 { "(bad)", { XX
} },
10786 /* VEX_W_3A0C_P_2 */
10787 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
10788 { "(bad)", { XX
} },
10791 /* VEX_W_3A0D_P_2 */
10792 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
10793 { "(bad)", { XX
} },
10796 /* VEX_W_3A0E_P_2 */
10797 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
10798 { "(bad)", { XX
} },
10801 /* VEX_W_3A0F_P_2 */
10802 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
10803 { "(bad)", { XX
} },
10806 /* VEX_W_3A14_P_2 */
10807 { "vpextrb", { Edqb
, XM
, Ib
} },
10808 { "(bad)", { XX
} },
10811 /* VEX_W_3A15_P_2 */
10812 { "vpextrw", { Edqw
, XM
, Ib
} },
10813 { "(bad)", { XX
} },
10816 /* VEX_W_3A18_P_2 */
10817 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
10818 { "(bad)", { XX
} },
10821 /* VEX_W_3A19_P_2 */
10822 { "vextractf128", { EXxmm
, XM
, Ib
} },
10823 { "(bad)", { XX
} },
10826 /* VEX_W_3A20_P_2 */
10827 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
10828 { "(bad)", { XX
} },
10831 /* VEX_W_3A21_P_2 */
10832 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
10833 { "(bad)", { XX
} },
10836 /* VEX_W_3A40_P_2 */
10837 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
10838 { "(bad)", { XX
} },
10841 /* VEX_W_3A41_P_2 */
10842 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
10843 { "(bad)", { XX
} },
10846 /* VEX_W_3A42_P_2 */
10847 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
10848 { "(bad)", { XX
} },
10851 /* VEX_W_3A44_P_2 */
10852 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
10853 { "(bad)", { XX
} },
10856 /* VEX_W_3A4A_P_2 */
10857 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
10858 { "(bad)", { XX
} },
10861 /* VEX_W_3A4B_P_2 */
10862 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
10863 { "(bad)", { XX
} },
10866 /* VEX_W_3A4C_P_2 */
10867 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
10868 { "(bad)", { XX
} },
10871 /* VEX_W_3A60_P_2 */
10872 { "vpcmpestrm", { XM
, EXx
, Ib
} },
10873 { "(bad)", { XX
} },
10876 /* VEX_W_3A61_P_2 */
10877 { "vpcmpestri", { XM
, EXx
, Ib
} },
10878 { "(bad)", { XX
} },
10881 /* VEX_W_3A62_P_2 */
10882 { "vpcmpistrm", { XM
, EXx
, Ib
} },
10883 { "(bad)", { XX
} },
10886 /* VEX_W_3A63_P_2 */
10887 { "vpcmpistri", { XM
, EXx
, Ib
} },
10888 { "(bad)", { XX
} },
10891 /* VEX_W_3ADF_P_2 */
10892 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
10893 { "(bad)", { XX
} },
10897 static const struct dis386 mod_table
[][2] = {
10900 { "leaS", { Gv
, M
} },
10901 { "(bad)", { XX
} },
10904 /* MOD_0F01_REG_0 */
10905 { X86_64_TABLE (X86_64_0F01_REG_0
) },
10906 { RM_TABLE (RM_0F01_REG_0
) },
10909 /* MOD_0F01_REG_1 */
10910 { X86_64_TABLE (X86_64_0F01_REG_1
) },
10911 { RM_TABLE (RM_0F01_REG_1
) },
10914 /* MOD_0F01_REG_2 */
10915 { X86_64_TABLE (X86_64_0F01_REG_2
) },
10916 { RM_TABLE (RM_0F01_REG_2
) },
10919 /* MOD_0F01_REG_3 */
10920 { X86_64_TABLE (X86_64_0F01_REG_3
) },
10921 { RM_TABLE (RM_0F01_REG_3
) },
10924 /* MOD_0F01_REG_7 */
10925 { "invlpg", { Mb
} },
10926 { RM_TABLE (RM_0F01_REG_7
) },
10929 /* MOD_0F12_PREFIX_0 */
10930 { "movlps", { XM
, EXq
} },
10931 { "movhlps", { XM
, EXq
} },
10935 { "movlpX", { EXq
, XM
} },
10936 { "(bad)", { XX
} },
10939 /* MOD_0F16_PREFIX_0 */
10940 { "movhps", { XM
, EXq
} },
10941 { "movlhps", { XM
, EXq
} },
10945 { "movhpX", { EXq
, XM
} },
10946 { "(bad)", { XX
} },
10949 /* MOD_0F18_REG_0 */
10950 { "prefetchnta", { Mb
} },
10951 { "(bad)", { XX
} },
10954 /* MOD_0F18_REG_1 */
10955 { "prefetcht0", { Mb
} },
10956 { "(bad)", { XX
} },
10959 /* MOD_0F18_REG_2 */
10960 { "prefetcht1", { Mb
} },
10961 { "(bad)", { XX
} },
10964 /* MOD_0F18_REG_3 */
10965 { "prefetcht2", { Mb
} },
10966 { "(bad)", { XX
} },
10970 { "(bad)", { XX
} },
10971 { "movZ", { Rm
, Cm
} },
10975 { "(bad)", { XX
} },
10976 { "movZ", { Rm
, Dm
} },
10980 { "(bad)", { XX
} },
10981 { "movZ", { Cm
, Rm
} },
10985 { "(bad)", { XX
} },
10986 { "movZ", { Dm
, Rm
} },
10990 { "(bad)", { XX
} },
10991 { "movL", { Rd
, Td
} },
10995 { "(bad)", { XX
} },
10996 { "movL", { Td
, Rd
} },
10999 /* MOD_0F2B_PREFIX_0 */
11000 {"movntps", { Mx
, XM
} },
11001 { "(bad)", { XX
} },
11004 /* MOD_0F2B_PREFIX_1 */
11005 {"movntss", { Md
, XM
} },
11006 { "(bad)", { XX
} },
11009 /* MOD_0F2B_PREFIX_2 */
11010 {"movntpd", { Mx
, XM
} },
11011 { "(bad)", { XX
} },
11014 /* MOD_0F2B_PREFIX_3 */
11015 {"movntsd", { Mq
, XM
} },
11016 { "(bad)", { XX
} },
11020 { "(bad)", { XX
} },
11021 { "movmskpX", { Gdq
, XS
} },
11024 /* MOD_0F71_REG_2 */
11025 { "(bad)", { XX
} },
11026 { "psrlw", { MS
, Ib
} },
11029 /* MOD_0F71_REG_4 */
11030 { "(bad)", { XX
} },
11031 { "psraw", { MS
, Ib
} },
11034 /* MOD_0F71_REG_6 */
11035 { "(bad)", { XX
} },
11036 { "psllw", { MS
, Ib
} },
11039 /* MOD_0F72_REG_2 */
11040 { "(bad)", { XX
} },
11041 { "psrld", { MS
, Ib
} },
11044 /* MOD_0F72_REG_4 */
11045 { "(bad)", { XX
} },
11046 { "psrad", { MS
, Ib
} },
11049 /* MOD_0F72_REG_6 */
11050 { "(bad)", { XX
} },
11051 { "pslld", { MS
, Ib
} },
11054 /* MOD_0F73_REG_2 */
11055 { "(bad)", { XX
} },
11056 { "psrlq", { MS
, Ib
} },
11059 /* MOD_0F73_REG_3 */
11060 { "(bad)", { XX
} },
11061 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
11064 /* MOD_0F73_REG_6 */
11065 { "(bad)", { XX
} },
11066 { "psllq", { MS
, Ib
} },
11069 /* MOD_0F73_REG_7 */
11070 { "(bad)", { XX
} },
11071 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
11074 /* MOD_0FAE_REG_0 */
11075 { "fxsave", { FXSAVE
} },
11076 { "(bad)", { XX
} },
11079 /* MOD_0FAE_REG_1 */
11080 { "fxrstor", { FXSAVE
} },
11081 { "(bad)", { XX
} },
11084 /* MOD_0FAE_REG_2 */
11085 { "ldmxcsr", { Md
} },
11086 { "(bad)", { XX
} },
11089 /* MOD_0FAE_REG_3 */
11090 { "stmxcsr", { Md
} },
11091 { "(bad)", { XX
} },
11094 /* MOD_0FAE_REG_4 */
11095 { "xsave", { M
} },
11096 { "(bad)", { XX
} },
11099 /* MOD_0FAE_REG_5 */
11100 { "xrstor", { M
} },
11101 { RM_TABLE (RM_0FAE_REG_5
) },
11104 /* MOD_0FAE_REG_6 */
11105 { "xsaveopt", { M
} },
11106 { RM_TABLE (RM_0FAE_REG_6
) },
11109 /* MOD_0FAE_REG_7 */
11110 { "clflush", { Mb
} },
11111 { RM_TABLE (RM_0FAE_REG_7
) },
11115 { "lssS", { Gv
, Mp
} },
11116 { "(bad)", { XX
} },
11120 { "lfsS", { Gv
, Mp
} },
11121 { "(bad)", { XX
} },
11125 { "lgsS", { Gv
, Mp
} },
11126 { "(bad)", { XX
} },
11129 /* MOD_0FC7_REG_6 */
11130 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
11131 { "(bad)", { XX
} },
11134 /* MOD_0FC7_REG_7 */
11135 { "vmptrst", { Mq
} },
11136 { "(bad)", { XX
} },
11140 { "(bad)", { XX
} },
11141 { "pmovmskb", { Gdq
, MS
} },
11144 /* MOD_0FE7_PREFIX_2 */
11145 { "movntdq", { Mx
, XM
} },
11146 { "(bad)", { XX
} },
11149 /* MOD_0FF0_PREFIX_3 */
11150 { "lddqu", { XM
, M
} },
11151 { "(bad)", { XX
} },
11154 /* MOD_0F382A_PREFIX_2 */
11155 { "movntdqa", { XM
, Mx
} },
11156 { "(bad)", { XX
} },
11160 { "bound{S|}", { Gv
, Ma
} },
11161 { "(bad)", { XX
} },
11165 { "lesS", { Gv
, Mp
} },
11166 { VEX_C4_TABLE (VEX_0F
) },
11170 { "ldsS", { Gv
, Mp
} },
11171 { VEX_C5_TABLE (VEX_0F
) },
11174 /* MOD_VEX_12_PREFIX_0 */
11175 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
11176 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
11180 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
11181 { "(bad)", { XX
} },
11184 /* MOD_VEX_16_PREFIX_0 */
11185 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
11186 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
11190 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
11191 { "(bad)", { XX
} },
11195 { VEX_W_TABLE (VEX_W_2B_M_0
) },
11196 { "(bad)", { XX
} },
11200 { "(bad)", { XX
} },
11201 { VEX_W_TABLE (VEX_W_50_M_0
) },
11204 /* MOD_VEX_71_REG_2 */
11205 { "(bad)", { XX
} },
11206 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
11209 /* MOD_VEX_71_REG_4 */
11210 { "(bad)", { XX
} },
11211 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
11214 /* MOD_VEX_71_REG_6 */
11215 { "(bad)", { XX
} },
11216 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
11219 /* MOD_VEX_72_REG_2 */
11220 { "(bad)", { XX
} },
11221 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
11224 /* MOD_VEX_72_REG_4 */
11225 { "(bad)", { XX
} },
11226 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
11229 /* MOD_VEX_72_REG_6 */
11230 { "(bad)", { XX
} },
11231 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
11234 /* MOD_VEX_73_REG_2 */
11235 { "(bad)", { XX
} },
11236 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
11239 /* MOD_VEX_73_REG_3 */
11240 { "(bad)", { XX
} },
11241 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
11244 /* MOD_VEX_73_REG_6 */
11245 { "(bad)", { XX
} },
11246 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
11249 /* MOD_VEX_73_REG_7 */
11250 { "(bad)", { XX
} },
11251 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
11254 /* MOD_VEX_AE_REG_2 */
11255 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
11256 { "(bad)", { XX
} },
11259 /* MOD_VEX_AE_REG_3 */
11260 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
11261 { "(bad)", { XX
} },
11264 /* MOD_VEX_D7_PREFIX_2 */
11265 { "(bad)", { XX
} },
11266 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
11269 /* MOD_VEX_E7_PREFIX_2 */
11270 { VEX_W_TABLE (VEX_W_E7_P_2_M_0
) },
11271 { "(bad)", { XX
} },
11274 /* MOD_VEX_F0_PREFIX_3 */
11275 { VEX_W_TABLE (VEX_W_F0_P_3_M_0
) },
11276 { "(bad)", { XX
} },
11279 /* MOD_VEX_3818_PREFIX_2 */
11280 { VEX_W_TABLE (VEX_W_3818_P_2_M_0
) },
11281 { "(bad)", { XX
} },
11284 /* MOD_VEX_3819_PREFIX_2 */
11285 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
11286 { "(bad)", { XX
} },
11289 /* MOD_VEX_381A_PREFIX_2 */
11290 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
11291 { "(bad)", { XX
} },
11294 /* MOD_VEX_382A_PREFIX_2 */
11295 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
11296 { "(bad)", { XX
} },
11299 /* MOD_VEX_382C_PREFIX_2 */
11300 { VEX_W_TABLE (VEX_W_382C_P_2_M_0
) },
11301 { "(bad)", { XX
} },
11304 /* MOD_VEX_382D_PREFIX_2 */
11305 { VEX_W_TABLE (VEX_W_382D_P_2_M_0
) },
11306 { "(bad)", { XX
} },
11309 /* MOD_VEX_382E_PREFIX_2 */
11310 { VEX_W_TABLE (VEX_W_382E_P_2_M_0
) },
11311 { "(bad)", { XX
} },
11314 /* MOD_VEX_382F_PREFIX_2 */
11315 { VEX_W_TABLE (VEX_W_382F_P_2_M_0
) },
11316 { "(bad)", { XX
} },
11320 static const struct dis386 rm_table
[][8] = {
11322 /* RM_0F01_REG_0 */
11323 { "(bad)", { XX
} },
11324 { "vmcall", { Skip_MODRM
} },
11325 { "vmlaunch", { Skip_MODRM
} },
11326 { "vmresume", { Skip_MODRM
} },
11327 { "vmxoff", { Skip_MODRM
} },
11328 { "(bad)", { XX
} },
11329 { "(bad)", { XX
} },
11330 { "(bad)", { XX
} },
11333 /* RM_0F01_REG_1 */
11334 { "monitor", { { OP_Monitor
, 0 } } },
11335 { "mwait", { { OP_Mwait
, 0 } } },
11336 { "(bad)", { XX
} },
11337 { "(bad)", { XX
} },
11338 { "(bad)", { XX
} },
11339 { "(bad)", { XX
} },
11340 { "(bad)", { XX
} },
11341 { "(bad)", { XX
} },
11344 /* RM_0F01_REG_2 */
11345 { "xgetbv", { Skip_MODRM
} },
11346 { "xsetbv", { Skip_MODRM
} },
11347 { "(bad)", { XX
} },
11348 { "(bad)", { XX
} },
11349 { "(bad)", { XX
} },
11350 { "(bad)", { XX
} },
11351 { "(bad)", { XX
} },
11352 { "(bad)", { XX
} },
11355 /* RM_0F01_REG_3 */
11356 { "vmrun", { Skip_MODRM
} },
11357 { "vmmcall", { Skip_MODRM
} },
11358 { "vmload", { Skip_MODRM
} },
11359 { "vmsave", { Skip_MODRM
} },
11360 { "stgi", { Skip_MODRM
} },
11361 { "clgi", { Skip_MODRM
} },
11362 { "skinit", { Skip_MODRM
} },
11363 { "invlpga", { Skip_MODRM
} },
11366 /* RM_0F01_REG_7 */
11367 { "swapgs", { Skip_MODRM
} },
11368 { "rdtscp", { Skip_MODRM
} },
11369 { "(bad)", { XX
} },
11370 { "(bad)", { XX
} },
11371 { "(bad)", { XX
} },
11372 { "(bad)", { XX
} },
11373 { "(bad)", { XX
} },
11374 { "(bad)", { XX
} },
11377 /* RM_0FAE_REG_5 */
11378 { "lfence", { Skip_MODRM
} },
11379 { "(bad)", { XX
} },
11380 { "(bad)", { XX
} },
11381 { "(bad)", { XX
} },
11382 { "(bad)", { XX
} },
11383 { "(bad)", { XX
} },
11384 { "(bad)", { XX
} },
11385 { "(bad)", { XX
} },
11388 /* RM_0FAE_REG_6 */
11389 { "mfence", { Skip_MODRM
} },
11390 { "(bad)", { XX
} },
11391 { "(bad)", { XX
} },
11392 { "(bad)", { XX
} },
11393 { "(bad)", { XX
} },
11394 { "(bad)", { XX
} },
11395 { "(bad)", { XX
} },
11396 { "(bad)", { XX
} },
11399 /* RM_0FAE_REG_7 */
11400 { "sfence", { Skip_MODRM
} },
11401 { "(bad)", { XX
} },
11402 { "(bad)", { XX
} },
11403 { "(bad)", { XX
} },
11404 { "(bad)", { XX
} },
11405 { "(bad)", { XX
} },
11406 { "(bad)", { XX
} },
11407 { "(bad)", { XX
} },
11411 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
11413 /* We use the high bit to indicate different name for the same
11415 #define ADDR16_PREFIX (0x67 | 0x100)
11416 #define ADDR32_PREFIX (0x67 | 0x200)
11417 #define DATA16_PREFIX (0x66 | 0x100)
11418 #define DATA32_PREFIX (0x66 | 0x200)
11419 #define REP_PREFIX (0xf3 | 0x100)
11424 int newrex
, i
, length
;
11431 last_lock_prefix
= -1;
11432 last_repz_prefix
= -1;
11433 last_repnz_prefix
= -1;
11434 last_data_prefix
= -1;
11435 last_addr_prefix
= -1;
11436 last_rex_prefix
= -1;
11437 last_seg_prefix
= -1;
11438 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
11439 all_prefixes
[i
] = 0;
11442 /* The maximum instruction length is 15bytes. */
11443 while (length
< MAX_CODE_LENGTH
- 1)
11445 FETCH_DATA (the_info
, codep
+ 1);
11449 /* REX prefixes family. */
11466 if (address_mode
== mode_64bit
)
11470 last_rex_prefix
= i
;
11473 prefixes
|= PREFIX_REPZ
;
11474 last_repz_prefix
= i
;
11477 prefixes
|= PREFIX_REPNZ
;
11478 last_repnz_prefix
= i
;
11481 prefixes
|= PREFIX_LOCK
;
11482 last_lock_prefix
= i
;
11485 prefixes
|= PREFIX_CS
;
11486 last_seg_prefix
= i
;
11489 prefixes
|= PREFIX_SS
;
11490 last_seg_prefix
= i
;
11493 prefixes
|= PREFIX_DS
;
11494 last_seg_prefix
= i
;
11497 prefixes
|= PREFIX_ES
;
11498 last_seg_prefix
= i
;
11501 prefixes
|= PREFIX_FS
;
11502 last_seg_prefix
= i
;
11505 prefixes
|= PREFIX_GS
;
11506 last_seg_prefix
= i
;
11509 prefixes
|= PREFIX_DATA
;
11510 last_data_prefix
= i
;
11513 prefixes
|= PREFIX_ADDR
;
11514 last_addr_prefix
= i
;
11517 /* fwait is really an instruction. If there are prefixes
11518 before the fwait, they belong to the fwait, *not* to the
11519 following instruction. */
11520 if (prefixes
|| rex
)
11522 prefixes
|= PREFIX_FWAIT
;
11526 prefixes
= PREFIX_FWAIT
;
11531 /* Rex is ignored when followed by another prefix. */
11537 if (*codep
!= FWAIT_OPCODE
)
11538 all_prefixes
[i
++] = *codep
;
11540 rex_original
= rex
;
11548 seg_prefix (int pref
)
11569 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
11572 static const char *
11573 prefix_name (int pref
, int sizeflag
)
11575 static const char *rexes
[16] =
11578 "rex.B", /* 0x41 */
11579 "rex.X", /* 0x42 */
11580 "rex.XB", /* 0x43 */
11581 "rex.R", /* 0x44 */
11582 "rex.RB", /* 0x45 */
11583 "rex.RX", /* 0x46 */
11584 "rex.RXB", /* 0x47 */
11585 "rex.W", /* 0x48 */
11586 "rex.WB", /* 0x49 */
11587 "rex.WX", /* 0x4a */
11588 "rex.WXB", /* 0x4b */
11589 "rex.WR", /* 0x4c */
11590 "rex.WRB", /* 0x4d */
11591 "rex.WRX", /* 0x4e */
11592 "rex.WRXB", /* 0x4f */
11597 /* REX prefixes family. */
11614 return rexes
[pref
- 0x40];
11634 return (sizeflag
& DFLAG
) ? "data16" : "data32";
11636 if (address_mode
== mode_64bit
)
11637 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
11639 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
11642 case ADDR16_PREFIX
:
11644 case ADDR32_PREFIX
:
11646 case DATA16_PREFIX
:
11648 case DATA32_PREFIX
:
11657 static char op_out
[MAX_OPERANDS
][100];
11658 static int op_ad
, op_index
[MAX_OPERANDS
];
11659 static int two_source_ops
;
11660 static bfd_vma op_address
[MAX_OPERANDS
];
11661 static bfd_vma op_riprel
[MAX_OPERANDS
];
11662 static bfd_vma start_pc
;
11665 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
11666 * (see topic "Redundant prefixes" in the "Differences from 8086"
11667 * section of the "Virtual 8086 Mode" chapter.)
11668 * 'pc' should be the address of this instruction, it will
11669 * be used to print the target address if this is a relative jump or call
11670 * The function returns the length of this instruction in bytes.
11673 static char intel_syntax
;
11674 static char intel_mnemonic
= !SYSV386_COMPAT
;
11675 static char open_char
;
11676 static char close_char
;
11677 static char separator_char
;
11678 static char scale_char
;
11680 /* Here for backwards compatibility. When gdb stops using
11681 print_insn_i386_att and print_insn_i386_intel these functions can
11682 disappear, and print_insn_i386 be merged into print_insn. */
11684 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
11688 return print_insn (pc
, info
);
11692 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
11696 return print_insn (pc
, info
);
11700 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
11704 return print_insn (pc
, info
);
11708 print_i386_disassembler_options (FILE *stream
)
11710 fprintf (stream
, _("\n\
11711 The following i386/x86-64 specific disassembler options are supported for use\n\
11712 with the -M switch (multiple options should be separated by commas):\n"));
11714 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
11715 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
11716 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
11717 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
11718 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
11719 fprintf (stream
, _(" att-mnemonic\n"
11720 " Display instruction in AT&T mnemonic\n"));
11721 fprintf (stream
, _(" intel-mnemonic\n"
11722 " Display instruction in Intel mnemonic\n"));
11723 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
11724 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
11725 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
11726 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
11727 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
11728 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
11731 /* Get a pointer to struct dis386 with a valid name. */
11733 static const struct dis386
*
11734 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
11736 int vindex
, vex_table_index
;
11738 if (dp
->name
!= NULL
)
11741 switch (dp
->op
[0].bytemode
)
11743 case USE_REG_TABLE
:
11744 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
11747 case USE_MOD_TABLE
:
11748 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
11749 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
11753 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
11756 case USE_PREFIX_TABLE
:
11759 /* The prefix in VEX is implicit. */
11760 switch (vex
.prefix
)
11765 case REPE_PREFIX_OPCODE
:
11768 case DATA_PREFIX_OPCODE
:
11771 case REPNE_PREFIX_OPCODE
:
11782 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
11783 if (prefixes
& PREFIX_REPZ
)
11786 all_prefixes
[last_repz_prefix
] = 0;
11790 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
11792 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
11793 if (prefixes
& PREFIX_REPNZ
)
11796 all_prefixes
[last_repnz_prefix
] = 0;
11800 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11801 if (prefixes
& PREFIX_DATA
)
11804 all_prefixes
[last_data_prefix
] = 0;
11809 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
11812 case USE_X86_64_TABLE
:
11813 vindex
= address_mode
== mode_64bit
? 1 : 0;
11814 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
11817 case USE_3BYTE_TABLE
:
11818 FETCH_DATA (info
, codep
+ 2);
11820 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
11821 modrm
.mod
= (*codep
>> 6) & 3;
11822 modrm
.reg
= (*codep
>> 3) & 7;
11823 modrm
.rm
= *codep
& 7;
11826 case USE_VEX_LEN_TABLE
:
11830 switch (vex
.length
)
11843 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
11846 case USE_XOP_8F_TABLE
:
11847 FETCH_DATA (info
, codep
+ 3);
11848 /* All bits in the REX prefix are ignored. */
11850 rex
= ~(*codep
>> 5) & 0x7;
11852 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11853 switch ((*codep
& 0x1f))
11858 vex_table_index
= XOP_08
;
11861 vex_table_index
= XOP_09
;
11864 vex_table_index
= XOP_0A
;
11868 vex
.w
= *codep
& 0x80;
11869 if (vex
.w
&& address_mode
== mode_64bit
)
11872 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11873 if (address_mode
!= mode_64bit
11874 && vex
.register_specifier
> 0x7)
11877 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11878 switch ((*codep
& 0x3))
11884 vex
.prefix
= DATA_PREFIX_OPCODE
;
11887 vex
.prefix
= REPE_PREFIX_OPCODE
;
11890 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11897 dp
= &xop_table
[vex_table_index
][vindex
];
11899 FETCH_DATA (info
, codep
+ 1);
11900 modrm
.mod
= (*codep
>> 6) & 3;
11901 modrm
.reg
= (*codep
>> 3) & 7;
11902 modrm
.rm
= *codep
& 7;
11905 case USE_VEX_C4_TABLE
:
11906 FETCH_DATA (info
, codep
+ 3);
11907 /* All bits in the REX prefix are ignored. */
11909 rex
= ~(*codep
>> 5) & 0x7;
11910 switch ((*codep
& 0x1f))
11915 vex_table_index
= VEX_0F
;
11918 vex_table_index
= VEX_0F38
;
11921 vex_table_index
= VEX_0F3A
;
11925 vex
.w
= *codep
& 0x80;
11926 if (vex
.w
&& address_mode
== mode_64bit
)
11929 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11930 if (address_mode
!= mode_64bit
11931 && vex
.register_specifier
> 0x7)
11934 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11935 switch ((*codep
& 0x3))
11941 vex
.prefix
= DATA_PREFIX_OPCODE
;
11944 vex
.prefix
= REPE_PREFIX_OPCODE
;
11947 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11954 dp
= &vex_table
[vex_table_index
][vindex
];
11955 /* There is no MODRM byte for VEX [82|77]. */
11956 if (vindex
!= 0x77 && vindex
!= 0x82)
11958 FETCH_DATA (info
, codep
+ 1);
11959 modrm
.mod
= (*codep
>> 6) & 3;
11960 modrm
.reg
= (*codep
>> 3) & 7;
11961 modrm
.rm
= *codep
& 7;
11965 case USE_VEX_C5_TABLE
:
11966 FETCH_DATA (info
, codep
+ 2);
11967 /* All bits in the REX prefix are ignored. */
11969 rex
= (*codep
& 0x80) ? 0 : REX_R
;
11971 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
11972 if (address_mode
!= mode_64bit
11973 && vex
.register_specifier
> 0x7)
11978 vex
.length
= (*codep
& 0x4) ? 256 : 128;
11979 switch ((*codep
& 0x3))
11985 vex
.prefix
= DATA_PREFIX_OPCODE
;
11988 vex
.prefix
= REPE_PREFIX_OPCODE
;
11991 vex
.prefix
= REPNE_PREFIX_OPCODE
;
11998 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
11999 /* There is no MODRM byte for VEX [82|77]. */
12000 if (vindex
!= 0x77 && vindex
!= 0x82)
12002 FETCH_DATA (info
, codep
+ 1);
12003 modrm
.mod
= (*codep
>> 6) & 3;
12004 modrm
.reg
= (*codep
>> 3) & 7;
12005 modrm
.rm
= *codep
& 7;
12009 case USE_VEX_W_TABLE
:
12013 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
12020 if (dp
->name
!= NULL
)
12023 return get_valid_dis386 (dp
, info
);
12027 print_insn (bfd_vma pc
, disassemble_info
*info
)
12029 const struct dis386
*dp
;
12031 char *op_txt
[MAX_OPERANDS
];
12035 struct dis_private priv
;
12038 int default_prefixes
;
12040 if (info
->mach
== bfd_mach_x86_64_intel_syntax
12041 || info
->mach
== bfd_mach_x86_64
12042 || info
->mach
== bfd_mach_l1om
12043 || info
->mach
== bfd_mach_l1om_intel_syntax
)
12044 address_mode
= mode_64bit
;
12046 address_mode
= mode_32bit
;
12048 if (intel_syntax
== (char) -1)
12049 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
12050 || info
->mach
== bfd_mach_x86_64_intel_syntax
12051 || info
->mach
== bfd_mach_l1om_intel_syntax
);
12053 if (info
->mach
== bfd_mach_i386_i386
12054 || info
->mach
== bfd_mach_x86_64
12055 || info
->mach
== bfd_mach_l1om
12056 || info
->mach
== bfd_mach_i386_i386_intel_syntax
12057 || info
->mach
== bfd_mach_x86_64_intel_syntax
12058 || info
->mach
== bfd_mach_l1om_intel_syntax
)
12059 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12060 else if (info
->mach
== bfd_mach_i386_i8086
)
12061 priv
.orig_sizeflag
= 0;
12065 for (p
= info
->disassembler_options
; p
!= NULL
; )
12067 if (CONST_STRNEQ (p
, "x86-64"))
12069 address_mode
= mode_64bit
;
12070 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12072 else if (CONST_STRNEQ (p
, "i386"))
12074 address_mode
= mode_32bit
;
12075 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12077 else if (CONST_STRNEQ (p
, "i8086"))
12079 address_mode
= mode_16bit
;
12080 priv
.orig_sizeflag
= 0;
12082 else if (CONST_STRNEQ (p
, "intel"))
12085 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
12086 intel_mnemonic
= 1;
12088 else if (CONST_STRNEQ (p
, "att"))
12091 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
12092 intel_mnemonic
= 0;
12094 else if (CONST_STRNEQ (p
, "addr"))
12096 if (address_mode
== mode_64bit
)
12098 if (p
[4] == '3' && p
[5] == '2')
12099 priv
.orig_sizeflag
&= ~AFLAG
;
12100 else if (p
[4] == '6' && p
[5] == '4')
12101 priv
.orig_sizeflag
|= AFLAG
;
12105 if (p
[4] == '1' && p
[5] == '6')
12106 priv
.orig_sizeflag
&= ~AFLAG
;
12107 else if (p
[4] == '3' && p
[5] == '2')
12108 priv
.orig_sizeflag
|= AFLAG
;
12111 else if (CONST_STRNEQ (p
, "data"))
12113 if (p
[4] == '1' && p
[5] == '6')
12114 priv
.orig_sizeflag
&= ~DFLAG
;
12115 else if (p
[4] == '3' && p
[5] == '2')
12116 priv
.orig_sizeflag
|= DFLAG
;
12118 else if (CONST_STRNEQ (p
, "suffix"))
12119 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
12121 p
= strchr (p
, ',');
12128 names64
= intel_names64
;
12129 names32
= intel_names32
;
12130 names16
= intel_names16
;
12131 names8
= intel_names8
;
12132 names8rex
= intel_names8rex
;
12133 names_seg
= intel_names_seg
;
12134 index64
= intel_index64
;
12135 index32
= intel_index32
;
12136 index16
= intel_index16
;
12139 separator_char
= '+';
12144 names64
= att_names64
;
12145 names32
= att_names32
;
12146 names16
= att_names16
;
12147 names8
= att_names8
;
12148 names8rex
= att_names8rex
;
12149 names_seg
= att_names_seg
;
12150 index64
= att_index64
;
12151 index32
= att_index32
;
12152 index16
= att_index16
;
12155 separator_char
= ',';
12159 /* The output looks better if we put 7 bytes on a line, since that
12160 puts most long word instructions on a single line. Use 8 bytes
12162 if (info
->mach
== bfd_mach_l1om
12163 || info
->mach
== bfd_mach_l1om_intel_syntax
)
12164 info
->bytes_per_line
= 8;
12166 info
->bytes_per_line
= 7;
12168 info
->private_data
= &priv
;
12169 priv
.max_fetched
= priv
.the_buffer
;
12170 priv
.insn_start
= pc
;
12173 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12181 start_codep
= priv
.the_buffer
;
12182 codep
= priv
.the_buffer
;
12184 if (setjmp (priv
.bailout
) != 0)
12188 /* Getting here means we tried for data but didn't get it. That
12189 means we have an incomplete instruction of some sort. Just
12190 print the first byte as a prefix or a .byte pseudo-op. */
12191 if (codep
> priv
.the_buffer
)
12193 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
12195 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
12198 /* Just print the first byte as a .byte instruction. */
12199 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
12200 (unsigned int) priv
.the_buffer
[0]);
12210 sizeflag
= priv
.orig_sizeflag
;
12212 if (!ckprefix () || rex_used
)
12214 /* Too many prefixes or unused REX prefixes. */
12216 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
12218 (*info
->fprintf_func
) (info
->stream
, "%s",
12219 prefix_name (all_prefixes
[i
], sizeflag
));
12223 insn_codep
= codep
;
12225 FETCH_DATA (info
, codep
+ 1);
12226 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
12228 if (((prefixes
& PREFIX_FWAIT
)
12229 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
12231 (*info
->fprintf_func
) (info
->stream
, "fwait");
12237 if (*codep
== 0x0f)
12239 unsigned char threebyte
;
12240 FETCH_DATA (info
, codep
+ 2);
12241 threebyte
= *++codep
;
12242 dp
= &dis386_twobyte
[threebyte
];
12243 need_modrm
= twobyte_has_modrm
[*codep
];
12248 dp
= &dis386
[*codep
];
12249 need_modrm
= onebyte_has_modrm
[*codep
];
12253 if ((prefixes
& PREFIX_REPZ
))
12254 used_prefixes
|= PREFIX_REPZ
;
12255 if ((prefixes
& PREFIX_REPNZ
))
12256 used_prefixes
|= PREFIX_REPNZ
;
12257 if ((prefixes
& PREFIX_LOCK
))
12258 used_prefixes
|= PREFIX_LOCK
;
12260 default_prefixes
= 0;
12261 if (prefixes
& PREFIX_ADDR
)
12264 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
12266 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12267 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
12269 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
12270 default_prefixes
|= PREFIX_ADDR
;
12274 if ((prefixes
& PREFIX_DATA
))
12277 if (dp
->op
[2].bytemode
== cond_jump_mode
12278 && dp
->op
[0].bytemode
== v_mode
12281 if (sizeflag
& DFLAG
)
12282 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
12284 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
12285 default_prefixes
|= PREFIX_DATA
;
12287 else if (rex
& REX_W
)
12289 /* REX_W will override PREFIX_DATA. */
12290 default_prefixes
|= PREFIX_DATA
;
12296 FETCH_DATA (info
, codep
+ 1);
12297 modrm
.mod
= (*codep
>> 6) & 3;
12298 modrm
.reg
= (*codep
>> 3) & 7;
12299 modrm
.rm
= *codep
& 7;
12306 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
12308 dofloat (sizeflag
);
12312 dp
= get_valid_dis386 (dp
, info
);
12313 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
12315 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12318 op_ad
= MAX_OPERANDS
- 1 - i
;
12320 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
12325 /* See if any prefixes were not used. If so, print the first one
12326 separately. If we don't do this, we'll wind up printing an
12327 instruction stream which does not precisely correspond to the
12328 bytes we are disassembling. */
12329 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
12331 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
12332 if (all_prefixes
[i
])
12335 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
12337 name
= INTERNAL_DISASSEMBLER_ERROR
;
12338 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
12343 /* Check if the REX prefix used. */
12344 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
12345 all_prefixes
[last_rex_prefix
] = 0;
12347 /* Check if the SEG prefix used. */
12348 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
12349 | PREFIX_FS
| PREFIX_GS
)) != 0
12351 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
12352 all_prefixes
[last_seg_prefix
] = 0;
12354 /* Check if the ADDR prefix used. */
12355 if ((prefixes
& PREFIX_ADDR
) != 0
12356 && (used_prefixes
& PREFIX_ADDR
) != 0)
12357 all_prefixes
[last_addr_prefix
] = 0;
12359 /* Check if the DATA prefix used. */
12360 if ((prefixes
& PREFIX_DATA
) != 0
12361 && (used_prefixes
& PREFIX_DATA
) != 0)
12362 all_prefixes
[last_data_prefix
] = 0;
12365 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
12366 if (all_prefixes
[i
])
12369 name
= prefix_name (all_prefixes
[i
], sizeflag
);
12372 prefix_length
+= strlen (name
) + 1;
12373 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
12376 /* Check maximum code length. */
12377 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
12379 (*info
->fprintf_func
) (info
->stream
, "(bad)");
12380 return MAX_CODE_LENGTH
;
12383 obufp
= mnemonicendp
;
12384 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
12387 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
12389 /* The enter and bound instructions are printed with operands in the same
12390 order as the intel book; everything else is printed in reverse order. */
12391 if (intel_syntax
|| two_source_ops
)
12395 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12396 op_txt
[i
] = op_out
[i
];
12398 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
12400 op_ad
= op_index
[i
];
12401 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
12402 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
12403 riprel
= op_riprel
[i
];
12404 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
12405 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
12410 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12411 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
12415 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12419 (*info
->fprintf_func
) (info
->stream
, ",");
12420 if (op_index
[i
] != -1 && !op_riprel
[i
])
12421 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
12423 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
12427 for (i
= 0; i
< MAX_OPERANDS
; i
++)
12428 if (op_index
[i
] != -1 && op_riprel
[i
])
12430 (*info
->fprintf_func
) (info
->stream
, " # ");
12431 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
12432 + op_address
[op_index
[i
]]), info
);
12435 return codep
- priv
.the_buffer
;
12438 static const char *float_mem
[] = {
12513 static const unsigned char float_mem_mode
[] = {
12588 #define ST { OP_ST, 0 }
12589 #define STi { OP_STi, 0 }
12591 #define FGRPd9_2 NULL, { { NULL, 0 } }
12592 #define FGRPd9_4 NULL, { { NULL, 1 } }
12593 #define FGRPd9_5 NULL, { { NULL, 2 } }
12594 #define FGRPd9_6 NULL, { { NULL, 3 } }
12595 #define FGRPd9_7 NULL, { { NULL, 4 } }
12596 #define FGRPda_5 NULL, { { NULL, 5 } }
12597 #define FGRPdb_4 NULL, { { NULL, 6 } }
12598 #define FGRPde_3 NULL, { { NULL, 7 } }
12599 #define FGRPdf_4 NULL, { { NULL, 8 } }
12601 static const struct dis386 float_reg
[][8] = {
12604 { "fadd", { ST
, STi
} },
12605 { "fmul", { ST
, STi
} },
12606 { "fcom", { STi
} },
12607 { "fcomp", { STi
} },
12608 { "fsub", { ST
, STi
} },
12609 { "fsubr", { ST
, STi
} },
12610 { "fdiv", { ST
, STi
} },
12611 { "fdivr", { ST
, STi
} },
12615 { "fld", { STi
} },
12616 { "fxch", { STi
} },
12618 { "(bad)", { XX
} },
12626 { "fcmovb", { ST
, STi
} },
12627 { "fcmove", { ST
, STi
} },
12628 { "fcmovbe",{ ST
, STi
} },
12629 { "fcmovu", { ST
, STi
} },
12630 { "(bad)", { XX
} },
12632 { "(bad)", { XX
} },
12633 { "(bad)", { XX
} },
12637 { "fcmovnb",{ ST
, STi
} },
12638 { "fcmovne",{ ST
, STi
} },
12639 { "fcmovnbe",{ ST
, STi
} },
12640 { "fcmovnu",{ ST
, STi
} },
12642 { "fucomi", { ST
, STi
} },
12643 { "fcomi", { ST
, STi
} },
12644 { "(bad)", { XX
} },
12648 { "fadd", { STi
, ST
} },
12649 { "fmul", { STi
, ST
} },
12650 { "(bad)", { XX
} },
12651 { "(bad)", { XX
} },
12652 { "fsub!M", { STi
, ST
} },
12653 { "fsubM", { STi
, ST
} },
12654 { "fdiv!M", { STi
, ST
} },
12655 { "fdivM", { STi
, ST
} },
12659 { "ffree", { STi
} },
12660 { "(bad)", { XX
} },
12661 { "fst", { STi
} },
12662 { "fstp", { STi
} },
12663 { "fucom", { STi
} },
12664 { "fucomp", { STi
} },
12665 { "(bad)", { XX
} },
12666 { "(bad)", { XX
} },
12670 { "faddp", { STi
, ST
} },
12671 { "fmulp", { STi
, ST
} },
12672 { "(bad)", { XX
} },
12674 { "fsub!Mp", { STi
, ST
} },
12675 { "fsubMp", { STi
, ST
} },
12676 { "fdiv!Mp", { STi
, ST
} },
12677 { "fdivMp", { STi
, ST
} },
12681 { "ffreep", { STi
} },
12682 { "(bad)", { XX
} },
12683 { "(bad)", { XX
} },
12684 { "(bad)", { XX
} },
12686 { "fucomip", { ST
, STi
} },
12687 { "fcomip", { ST
, STi
} },
12688 { "(bad)", { XX
} },
12692 static char *fgrps
[][8] = {
12695 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12700 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
12705 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
12710 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
12715 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
12720 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12725 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
12726 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
12731 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12736 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12741 swap_operand (void)
12743 mnemonicendp
[0] = '.';
12744 mnemonicendp
[1] = 's';
12749 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
12750 int sizeflag ATTRIBUTE_UNUSED
)
12752 /* Skip mod/rm byte. */
12758 dofloat (int sizeflag
)
12760 const struct dis386
*dp
;
12761 unsigned char floatop
;
12763 floatop
= codep
[-1];
12765 if (modrm
.mod
!= 3)
12767 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
12769 putop (float_mem
[fp_indx
], sizeflag
);
12772 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
12775 /* Skip mod/rm byte. */
12779 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
12780 if (dp
->name
== NULL
)
12782 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
12784 /* Instruction fnstsw is only one with strange arg. */
12785 if (floatop
== 0xdf && codep
[-1] == 0xe0)
12786 strcpy (op_out
[0], names16
[0]);
12790 putop (dp
->name
, sizeflag
);
12795 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
12800 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
12805 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12807 oappend ("%st" + intel_syntax
);
12811 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12813 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
12814 oappend (scratchbuf
+ intel_syntax
);
12817 /* Capital letters in template are macros. */
12819 putop (const char *in_template
, int sizeflag
)
12824 unsigned int l
= 0, len
= 1;
12827 #define SAVE_LAST(c) \
12828 if (l < len && l < sizeof (last)) \
12833 for (p
= in_template
; *p
; p
++)
12850 while (*++p
!= '|')
12851 if (*p
== '}' || *p
== '\0')
12854 /* Fall through. */
12859 while (*++p
!= '}')
12870 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
12874 if (l
== 0 && len
== 1)
12879 if (sizeflag
& SUFFIX_ALWAYS
)
12892 if (address_mode
== mode_64bit
12893 && !(prefixes
& PREFIX_ADDR
))
12904 if (intel_syntax
&& !alt
)
12906 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
12908 if (sizeflag
& DFLAG
)
12909 *obufp
++ = intel_syntax
? 'd' : 'l';
12911 *obufp
++ = intel_syntax
? 'w' : 's';
12912 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12916 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
12919 if (modrm
.mod
== 3)
12925 if (sizeflag
& DFLAG
)
12926 *obufp
++ = intel_syntax
? 'd' : 'l';
12929 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12935 case 'E': /* For jcxz/jecxz */
12936 if (address_mode
== mode_64bit
)
12938 if (sizeflag
& AFLAG
)
12944 if (sizeflag
& AFLAG
)
12946 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12951 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
12953 if (sizeflag
& AFLAG
)
12954 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
12956 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
12957 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12961 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
12963 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12967 if (!(rex
& REX_W
))
12968 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12973 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
12974 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
12976 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
12979 if (prefixes
& PREFIX_DS
)
13000 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
13005 /* Fall through. */
13008 if (l
!= 0 || len
!= 1)
13016 if (sizeflag
& SUFFIX_ALWAYS
)
13020 if (intel_mnemonic
!= cond
)
13024 if ((prefixes
& PREFIX_FWAIT
) == 0)
13027 used_prefixes
|= PREFIX_FWAIT
;
13033 else if (intel_syntax
&& (sizeflag
& DFLAG
))
13037 if (!(rex
& REX_W
))
13038 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13043 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13048 /* Fall through. */
13052 if ((prefixes
& PREFIX_DATA
)
13054 || (sizeflag
& SUFFIX_ALWAYS
))
13061 if (sizeflag
& DFLAG
)
13065 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13072 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13074 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13078 /* Fall through. */
13081 if (l
== 0 && len
== 1)
13084 if (intel_syntax
&& !alt
)
13087 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13093 if (sizeflag
& DFLAG
)
13094 *obufp
++ = intel_syntax
? 'd' : 'l';
13097 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13103 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
13109 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
13124 else if (sizeflag
& DFLAG
)
13133 if (intel_syntax
&& !p
[1]
13134 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
13136 if (!(rex
& REX_W
))
13137 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13140 if (l
== 0 && len
== 1)
13144 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13146 if (sizeflag
& SUFFIX_ALWAYS
)
13168 /* Fall through. */
13171 if (l
== 0 && len
== 1)
13176 if (sizeflag
& SUFFIX_ALWAYS
)
13182 if (sizeflag
& DFLAG
)
13186 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13200 if (address_mode
== mode_64bit
13201 && !(prefixes
& PREFIX_ADDR
))
13212 if (l
!= 0 || len
!= 1)
13217 if (need_vex
&& vex
.prefix
)
13219 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
13226 if (prefixes
& PREFIX_DATA
)
13230 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13234 if (l
== 0 && len
== 1)
13236 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
13247 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
13255 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
13257 switch (vex
.length
)
13271 if (l
== 0 && len
== 1)
13273 /* operand size flag for cwtl, cbtw */
13282 else if (sizeflag
& DFLAG
)
13286 if (!(rex
& REX_W
))
13287 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13291 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
13298 *obufp
++ = vex
.w
? 'd': 's';
13305 mnemonicendp
= obufp
;
13310 oappend (const char *s
)
13312 obufp
= stpcpy (obufp
, s
);
13318 if (prefixes
& PREFIX_CS
)
13320 used_prefixes
|= PREFIX_CS
;
13321 oappend ("%cs:" + intel_syntax
);
13323 if (prefixes
& PREFIX_DS
)
13325 used_prefixes
|= PREFIX_DS
;
13326 oappend ("%ds:" + intel_syntax
);
13328 if (prefixes
& PREFIX_SS
)
13330 used_prefixes
|= PREFIX_SS
;
13331 oappend ("%ss:" + intel_syntax
);
13333 if (prefixes
& PREFIX_ES
)
13335 used_prefixes
|= PREFIX_ES
;
13336 oappend ("%es:" + intel_syntax
);
13338 if (prefixes
& PREFIX_FS
)
13340 used_prefixes
|= PREFIX_FS
;
13341 oappend ("%fs:" + intel_syntax
);
13343 if (prefixes
& PREFIX_GS
)
13345 used_prefixes
|= PREFIX_GS
;
13346 oappend ("%gs:" + intel_syntax
);
13351 OP_indirE (int bytemode
, int sizeflag
)
13355 OP_E (bytemode
, sizeflag
);
13359 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
13361 if (address_mode
== mode_64bit
)
13369 sprintf_vma (tmp
, disp
);
13370 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
13371 strcpy (buf
+ 2, tmp
+ i
);
13375 bfd_signed_vma v
= disp
;
13382 /* Check for possible overflow on 0x8000000000000000. */
13385 strcpy (buf
, "9223372036854775808");
13399 tmp
[28 - i
] = (v
% 10) + '0';
13403 strcpy (buf
, tmp
+ 29 - i
);
13409 sprintf (buf
, "0x%x", (unsigned int) disp
);
13411 sprintf (buf
, "%d", (int) disp
);
13415 /* Put DISP in BUF as signed hex number. */
13418 print_displacement (char *buf
, bfd_vma disp
)
13420 bfd_signed_vma val
= disp
;
13429 /* Check for possible overflow. */
13432 switch (address_mode
)
13435 strcpy (buf
+ j
, "0x8000000000000000");
13438 strcpy (buf
+ j
, "0x80000000");
13441 strcpy (buf
+ j
, "0x8000");
13451 sprintf_vma (tmp
, (bfd_vma
) val
);
13452 for (i
= 0; tmp
[i
] == '0'; i
++)
13454 if (tmp
[i
] == '\0')
13456 strcpy (buf
+ j
, tmp
+ i
);
13460 intel_operand_size (int bytemode
, int sizeflag
)
13467 oappend ("BYTE PTR ");
13471 oappend ("WORD PTR ");
13474 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13476 oappend ("QWORD PTR ");
13485 oappend ("QWORD PTR ");
13488 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
13489 oappend ("DWORD PTR ");
13491 oappend ("WORD PTR ");
13492 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13496 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13498 oappend ("WORD PTR ");
13499 if (!(rex
& REX_W
))
13500 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13503 if (sizeflag
& DFLAG
)
13504 oappend ("QWORD PTR ");
13506 oappend ("DWORD PTR ");
13507 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13512 oappend ("DWORD PTR ");
13516 oappend ("QWORD PTR ");
13519 if (address_mode
== mode_64bit
)
13520 oappend ("QWORD PTR ");
13522 oappend ("DWORD PTR ");
13525 if (sizeflag
& DFLAG
)
13526 oappend ("FWORD PTR ");
13528 oappend ("DWORD PTR ");
13529 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13532 oappend ("TBYTE PTR ");
13538 switch (vex
.length
)
13541 oappend ("XMMWORD PTR ");
13544 oappend ("YMMWORD PTR ");
13551 oappend ("XMMWORD PTR ");
13554 oappend ("XMMWORD PTR ");
13560 switch (vex
.length
)
13563 oappend ("QWORD PTR ");
13566 oappend ("XMMWORD PTR ");
13576 switch (vex
.length
)
13579 oappend ("QWORD PTR ");
13582 oappend ("YMMWORD PTR ");
13589 oappend ("OWORD PTR ");
13591 case vex_w_dq_mode
:
13596 oappend ("QWORD PTR ");
13598 oappend ("DWORD PTR ");
13606 OP_E_register (int bytemode
, int sizeflag
)
13608 int reg
= modrm
.rm
;
13609 const char **names
;
13615 if ((sizeflag
& SUFFIX_ALWAYS
)
13616 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
13639 names
= address_mode
== mode_64bit
? names64
: names32
;
13642 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
13660 if ((sizeflag
& DFLAG
)
13661 || (bytemode
!= v_mode
13662 && bytemode
!= v_swap_mode
))
13666 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13672 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13675 oappend (names
[reg
]);
13679 OP_E_memory (int bytemode
, int sizeflag
)
13682 int add
= (rex
& REX_B
) ? 8 : 0;
13687 intel_operand_size (bytemode
, sizeflag
);
13690 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13692 /* 32/64 bit address mode */
13710 FETCH_DATA (the_info
, codep
+ 1);
13711 vindex
= (*codep
>> 3) & 7;
13712 scale
= (*codep
>> 6) & 3;
13717 haveindex
= vindex
!= 4;
13720 rbase
= base
+ add
;
13728 if (address_mode
== mode_64bit
&& !havesib
)
13734 FETCH_DATA (the_info
, codep
+ 1);
13736 if ((disp
& 0x80) != 0)
13744 /* In 32bit mode, we need index register to tell [offset] from
13745 [eiz*1 + offset]. */
13746 needindex
= (havesib
13749 && address_mode
== mode_32bit
);
13750 havedisp
= (havebase
13752 || (havesib
&& (haveindex
|| scale
!= 0)));
13755 if (modrm
.mod
!= 0 || base
== 5)
13757 if (havedisp
|| riprel
)
13758 print_displacement (scratchbuf
, disp
);
13760 print_operand_value (scratchbuf
, 1, disp
);
13761 oappend (scratchbuf
);
13765 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
13769 if (havebase
|| haveindex
|| riprel
)
13770 used_prefixes
|= PREFIX_ADDR
;
13772 if (havedisp
|| (intel_syntax
&& riprel
))
13774 *obufp
++ = open_char
;
13775 if (intel_syntax
&& riprel
)
13778 oappend (sizeflag
& AFLAG
? "rip" : "eip");
13782 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
13783 ? names64
[rbase
] : names32
[rbase
]);
13786 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13787 print index to tell base + index from base. */
13791 || (havebase
&& base
!= ESP_REG_NUM
))
13793 if (!intel_syntax
|| havebase
)
13795 *obufp
++ = separator_char
;
13799 oappend (address_mode
== mode_64bit
13800 && (sizeflag
& AFLAG
)
13801 ? names64
[vindex
] : names32
[vindex
]);
13803 oappend (address_mode
== mode_64bit
13804 && (sizeflag
& AFLAG
)
13805 ? index64
: index32
);
13807 *obufp
++ = scale_char
;
13809 sprintf (scratchbuf
, "%d", 1 << scale
);
13810 oappend (scratchbuf
);
13814 && (disp
|| modrm
.mod
!= 0 || base
== 5))
13816 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
13821 else if (modrm
.mod
!= 1 && disp
!= -disp
)
13825 disp
= - (bfd_signed_vma
) disp
;
13829 print_displacement (scratchbuf
, disp
);
13831 print_operand_value (scratchbuf
, 1, disp
);
13832 oappend (scratchbuf
);
13835 *obufp
++ = close_char
;
13838 else if (intel_syntax
)
13840 if (modrm
.mod
!= 0 || base
== 5)
13842 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13843 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13847 oappend (names_seg
[ds_reg
- es_reg
]);
13850 print_operand_value (scratchbuf
, 1, disp
);
13851 oappend (scratchbuf
);
13857 /* 16 bit address mode */
13858 used_prefixes
|= prefixes
& PREFIX_ADDR
;
13865 if ((disp
& 0x8000) != 0)
13870 FETCH_DATA (the_info
, codep
+ 1);
13872 if ((disp
& 0x80) != 0)
13877 if ((disp
& 0x8000) != 0)
13883 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
13885 print_displacement (scratchbuf
, disp
);
13886 oappend (scratchbuf
);
13889 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
13891 *obufp
++ = open_char
;
13893 oappend (index16
[modrm
.rm
]);
13895 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
13897 if ((bfd_signed_vma
) disp
>= 0)
13902 else if (modrm
.mod
!= 1)
13906 disp
= - (bfd_signed_vma
) disp
;
13909 print_displacement (scratchbuf
, disp
);
13910 oappend (scratchbuf
);
13913 *obufp
++ = close_char
;
13916 else if (intel_syntax
)
13918 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
13919 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
13923 oappend (names_seg
[ds_reg
- es_reg
]);
13926 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
13927 oappend (scratchbuf
);
13933 OP_E (int bytemode
, int sizeflag
)
13935 /* Skip mod/rm byte. */
13939 if (modrm
.mod
== 3)
13940 OP_E_register (bytemode
, sizeflag
);
13942 OP_E_memory (bytemode
, sizeflag
);
13946 OP_G (int bytemode
, int sizeflag
)
13957 oappend (names8rex
[modrm
.reg
+ add
]);
13959 oappend (names8
[modrm
.reg
+ add
]);
13962 oappend (names16
[modrm
.reg
+ add
]);
13965 oappend (names32
[modrm
.reg
+ add
]);
13968 oappend (names64
[modrm
.reg
+ add
]);
13977 oappend (names64
[modrm
.reg
+ add
]);
13980 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
13981 oappend (names32
[modrm
.reg
+ add
]);
13983 oappend (names16
[modrm
.reg
+ add
]);
13984 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13988 if (address_mode
== mode_64bit
)
13989 oappend (names64
[modrm
.reg
+ add
]);
13991 oappend (names32
[modrm
.reg
+ add
]);
13994 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14007 FETCH_DATA (the_info
, codep
+ 8);
14008 a
= *codep
++ & 0xff;
14009 a
|= (*codep
++ & 0xff) << 8;
14010 a
|= (*codep
++ & 0xff) << 16;
14011 a
|= (*codep
++ & 0xff) << 24;
14012 b
= *codep
++ & 0xff;
14013 b
|= (*codep
++ & 0xff) << 8;
14014 b
|= (*codep
++ & 0xff) << 16;
14015 b
|= (*codep
++ & 0xff) << 24;
14016 x
= a
+ ((bfd_vma
) b
<< 32);
14024 static bfd_signed_vma
14027 bfd_signed_vma x
= 0;
14029 FETCH_DATA (the_info
, codep
+ 4);
14030 x
= *codep
++ & (bfd_signed_vma
) 0xff;
14031 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
14032 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
14033 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
14037 static bfd_signed_vma
14040 bfd_signed_vma x
= 0;
14042 FETCH_DATA (the_info
, codep
+ 4);
14043 x
= *codep
++ & (bfd_signed_vma
) 0xff;
14044 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
14045 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
14046 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
14048 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
14058 FETCH_DATA (the_info
, codep
+ 2);
14059 x
= *codep
++ & 0xff;
14060 x
|= (*codep
++ & 0xff) << 8;
14065 set_op (bfd_vma op
, int riprel
)
14067 op_index
[op_ad
] = op_ad
;
14068 if (address_mode
== mode_64bit
)
14070 op_address
[op_ad
] = op
;
14071 op_riprel
[op_ad
] = riprel
;
14075 /* Mask to get a 32-bit address. */
14076 op_address
[op_ad
] = op
& 0xffffffff;
14077 op_riprel
[op_ad
] = riprel
& 0xffffffff;
14082 OP_REG (int code
, int sizeflag
)
14094 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
14095 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
14096 s
= names16
[code
- ax_reg
+ add
];
14098 case es_reg
: case ss_reg
: case cs_reg
:
14099 case ds_reg
: case fs_reg
: case gs_reg
:
14100 s
= names_seg
[code
- es_reg
+ add
];
14102 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
14103 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
14106 s
= names8rex
[code
- al_reg
+ add
];
14108 s
= names8
[code
- al_reg
];
14110 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
14111 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
14112 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
14114 s
= names64
[code
- rAX_reg
+ add
];
14117 code
+= eAX_reg
- rAX_reg
;
14118 /* Fall through. */
14119 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
14120 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
14123 s
= names64
[code
- eAX_reg
+ add
];
14126 if (sizeflag
& DFLAG
)
14127 s
= names32
[code
- eAX_reg
+ add
];
14129 s
= names16
[code
- eAX_reg
+ add
];
14130 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14134 s
= INTERNAL_DISASSEMBLER_ERROR
;
14141 OP_IMREG (int code
, int sizeflag
)
14153 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
14154 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
14155 s
= names16
[code
- ax_reg
];
14157 case es_reg
: case ss_reg
: case cs_reg
:
14158 case ds_reg
: case fs_reg
: case gs_reg
:
14159 s
= names_seg
[code
- es_reg
];
14161 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
14162 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
14165 s
= names8rex
[code
- al_reg
];
14167 s
= names8
[code
- al_reg
];
14169 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
14170 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
14173 s
= names64
[code
- eAX_reg
];
14176 if (sizeflag
& DFLAG
)
14177 s
= names32
[code
- eAX_reg
];
14179 s
= names16
[code
- eAX_reg
];
14180 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14183 case z_mode_ax_reg
:
14184 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
14188 if (!(rex
& REX_W
))
14189 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14192 s
= INTERNAL_DISASSEMBLER_ERROR
;
14199 OP_I (int bytemode
, int sizeflag
)
14202 bfd_signed_vma mask
= -1;
14207 FETCH_DATA (the_info
, codep
+ 1);
14212 if (address_mode
== mode_64bit
)
14217 /* Fall through. */
14224 if (sizeflag
& DFLAG
)
14234 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14246 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14251 scratchbuf
[0] = '$';
14252 print_operand_value (scratchbuf
+ 1, 1, op
);
14253 oappend (scratchbuf
+ intel_syntax
);
14254 scratchbuf
[0] = '\0';
14258 OP_I64 (int bytemode
, int sizeflag
)
14261 bfd_signed_vma mask
= -1;
14263 if (address_mode
!= mode_64bit
)
14265 OP_I (bytemode
, sizeflag
);
14272 FETCH_DATA (the_info
, codep
+ 1);
14282 if (sizeflag
& DFLAG
)
14292 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14300 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14305 scratchbuf
[0] = '$';
14306 print_operand_value (scratchbuf
+ 1, 1, op
);
14307 oappend (scratchbuf
+ intel_syntax
);
14308 scratchbuf
[0] = '\0';
14312 OP_sI (int bytemode
, int sizeflag
)
14315 bfd_signed_vma mask
= -1;
14320 FETCH_DATA (the_info
, codep
+ 1);
14322 if ((op
& 0x80) != 0)
14332 if (sizeflag
& DFLAG
)
14341 if ((op
& 0x8000) != 0)
14344 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14350 if ((op
& 0x8000) != 0)
14354 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14358 scratchbuf
[0] = '$';
14359 print_operand_value (scratchbuf
+ 1, 1, op
);
14360 oappend (scratchbuf
+ intel_syntax
);
14364 OP_J (int bytemode
, int sizeflag
)
14368 bfd_vma segment
= 0;
14373 FETCH_DATA (the_info
, codep
+ 1);
14375 if ((disp
& 0x80) != 0)
14380 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
14385 if ((disp
& 0x8000) != 0)
14387 /* In 16bit mode, address is wrapped around at 64k within
14388 the same segment. Otherwise, a data16 prefix on a jump
14389 instruction means that the pc is masked to 16 bits after
14390 the displacement is added! */
14392 if ((prefixes
& PREFIX_DATA
) == 0)
14393 segment
= ((start_pc
+ codep
- start_codep
)
14394 & ~((bfd_vma
) 0xffff));
14396 if (!(rex
& REX_W
))
14397 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14400 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14403 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
14405 print_operand_value (scratchbuf
, 1, disp
);
14406 oappend (scratchbuf
);
14410 OP_SEG (int bytemode
, int sizeflag
)
14412 if (bytemode
== w_mode
)
14413 oappend (names_seg
[modrm
.reg
]);
14415 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
14419 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
14423 if (sizeflag
& DFLAG
)
14433 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14435 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
14437 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
14438 oappend (scratchbuf
);
14442 OP_OFF (int bytemode
, int sizeflag
)
14446 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
14447 intel_operand_size (bytemode
, sizeflag
);
14450 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14457 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
14458 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
14460 oappend (names_seg
[ds_reg
- es_reg
]);
14464 print_operand_value (scratchbuf
, 1, off
);
14465 oappend (scratchbuf
);
14469 OP_OFF64 (int bytemode
, int sizeflag
)
14473 if (address_mode
!= mode_64bit
14474 || (prefixes
& PREFIX_ADDR
))
14476 OP_OFF (bytemode
, sizeflag
);
14480 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
14481 intel_operand_size (bytemode
, sizeflag
);
14488 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
14489 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
14491 oappend (names_seg
[ds_reg
- es_reg
]);
14495 print_operand_value (scratchbuf
, 1, off
);
14496 oappend (scratchbuf
);
14500 ptr_reg (int code
, int sizeflag
)
14504 *obufp
++ = open_char
;
14505 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
14506 if (address_mode
== mode_64bit
)
14508 if (!(sizeflag
& AFLAG
))
14509 s
= names32
[code
- eAX_reg
];
14511 s
= names64
[code
- eAX_reg
];
14513 else if (sizeflag
& AFLAG
)
14514 s
= names32
[code
- eAX_reg
];
14516 s
= names16
[code
- eAX_reg
];
14518 *obufp
++ = close_char
;
14523 OP_ESreg (int code
, int sizeflag
)
14529 case 0x6d: /* insw/insl */
14530 intel_operand_size (z_mode
, sizeflag
);
14532 case 0xa5: /* movsw/movsl/movsq */
14533 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14534 case 0xab: /* stosw/stosl */
14535 case 0xaf: /* scasw/scasl */
14536 intel_operand_size (v_mode
, sizeflag
);
14539 intel_operand_size (b_mode
, sizeflag
);
14542 oappend ("%es:" + intel_syntax
);
14543 ptr_reg (code
, sizeflag
);
14547 OP_DSreg (int code
, int sizeflag
)
14553 case 0x6f: /* outsw/outsl */
14554 intel_operand_size (z_mode
, sizeflag
);
14556 case 0xa5: /* movsw/movsl/movsq */
14557 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14558 case 0xad: /* lodsw/lodsl/lodsq */
14559 intel_operand_size (v_mode
, sizeflag
);
14562 intel_operand_size (b_mode
, sizeflag
);
14571 | PREFIX_GS
)) == 0)
14572 prefixes
|= PREFIX_DS
;
14574 ptr_reg (code
, sizeflag
);
14578 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14586 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
14588 all_prefixes
[last_lock_prefix
] = 0;
14589 used_prefixes
|= PREFIX_LOCK
;
14594 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
14595 oappend (scratchbuf
+ intel_syntax
);
14599 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14608 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
14610 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
14611 oappend (scratchbuf
);
14615 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14617 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
14618 oappend (scratchbuf
+ intel_syntax
);
14622 OP_R (int bytemode
, int sizeflag
)
14624 if (modrm
.mod
== 3)
14625 OP_E (bytemode
, sizeflag
);
14631 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14633 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14634 if (prefixes
& PREFIX_DATA
)
14642 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
14645 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
14646 oappend (scratchbuf
+ intel_syntax
);
14650 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
14658 if (need_vex
&& bytemode
!= xmm_mode
)
14660 switch (vex
.length
)
14663 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
14666 sprintf (scratchbuf
, "%%ymm%d", modrm
.reg
+ add
);
14673 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
14674 oappend (scratchbuf
+ intel_syntax
);
14678 OP_EM (int bytemode
, int sizeflag
)
14680 if (modrm
.mod
!= 3)
14683 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
14685 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14686 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14688 OP_E (bytemode
, sizeflag
);
14692 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
14695 /* Skip mod/rm byte. */
14698 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14699 if (prefixes
& PREFIX_DATA
)
14708 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
14711 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
14712 oappend (scratchbuf
+ intel_syntax
);
14715 /* cvt* are the only instructions in sse2 which have
14716 both SSE and MMX operands and also have 0x66 prefix
14717 in their opcode. 0x66 was originally used to differentiate
14718 between SSE and MMX instruction(operands). So we have to handle the
14719 cvt* separately using OP_EMC and OP_MXC */
14721 OP_EMC (int bytemode
, int sizeflag
)
14723 if (modrm
.mod
!= 3)
14725 if (intel_syntax
&& bytemode
== v_mode
)
14727 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
14728 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14730 OP_E (bytemode
, sizeflag
);
14734 /* Skip mod/rm byte. */
14737 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14738 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
14739 oappend (scratchbuf
+ intel_syntax
);
14743 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14745 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14746 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
14747 oappend (scratchbuf
+ intel_syntax
);
14751 OP_EX (int bytemode
, int sizeflag
)
14755 /* Skip mod/rm byte. */
14759 if (modrm
.mod
!= 3)
14761 OP_E_memory (bytemode
, sizeflag
);
14771 if ((sizeflag
& SUFFIX_ALWAYS
)
14772 && (bytemode
== x_swap_mode
14773 || bytemode
== d_swap_mode
14774 || bytemode
== q_swap_mode
))
14778 && bytemode
!= xmm_mode
14779 && bytemode
!= xmmq_mode
)
14781 switch (vex
.length
)
14784 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
14787 sprintf (scratchbuf
, "%%ymm%d", modrm
.rm
+ add
);
14794 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
14795 oappend (scratchbuf
+ intel_syntax
);
14799 OP_MS (int bytemode
, int sizeflag
)
14801 if (modrm
.mod
== 3)
14802 OP_EM (bytemode
, sizeflag
);
14808 OP_XS (int bytemode
, int sizeflag
)
14810 if (modrm
.mod
== 3)
14811 OP_EX (bytemode
, sizeflag
);
14817 OP_M (int bytemode
, int sizeflag
)
14819 if (modrm
.mod
== 3)
14820 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14823 OP_E (bytemode
, sizeflag
);
14827 OP_0f07 (int bytemode
, int sizeflag
)
14829 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
14832 OP_E (bytemode
, sizeflag
);
14835 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14836 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14839 NOP_Fixup1 (int bytemode
, int sizeflag
)
14841 if ((prefixes
& PREFIX_DATA
) != 0
14844 && address_mode
== mode_64bit
))
14845 OP_REG (bytemode
, sizeflag
);
14847 strcpy (obuf
, "nop");
14851 NOP_Fixup2 (int bytemode
, int sizeflag
)
14853 if ((prefixes
& PREFIX_DATA
) != 0
14856 && address_mode
== mode_64bit
))
14857 OP_IMREG (bytemode
, sizeflag
);
14860 static const char *const Suffix3DNow
[] = {
14861 /* 00 */ NULL
, NULL
, NULL
, NULL
,
14862 /* 04 */ NULL
, NULL
, NULL
, NULL
,
14863 /* 08 */ NULL
, NULL
, NULL
, NULL
,
14864 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
14865 /* 10 */ NULL
, NULL
, NULL
, NULL
,
14866 /* 14 */ NULL
, NULL
, NULL
, NULL
,
14867 /* 18 */ NULL
, NULL
, NULL
, NULL
,
14868 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
14869 /* 20 */ NULL
, NULL
, NULL
, NULL
,
14870 /* 24 */ NULL
, NULL
, NULL
, NULL
,
14871 /* 28 */ NULL
, NULL
, NULL
, NULL
,
14872 /* 2C */ NULL
, NULL
, NULL
, NULL
,
14873 /* 30 */ NULL
, NULL
, NULL
, NULL
,
14874 /* 34 */ NULL
, NULL
, NULL
, NULL
,
14875 /* 38 */ NULL
, NULL
, NULL
, NULL
,
14876 /* 3C */ NULL
, NULL
, NULL
, NULL
,
14877 /* 40 */ NULL
, NULL
, NULL
, NULL
,
14878 /* 44 */ NULL
, NULL
, NULL
, NULL
,
14879 /* 48 */ NULL
, NULL
, NULL
, NULL
,
14880 /* 4C */ NULL
, NULL
, NULL
, NULL
,
14881 /* 50 */ NULL
, NULL
, NULL
, NULL
,
14882 /* 54 */ NULL
, NULL
, NULL
, NULL
,
14883 /* 58 */ NULL
, NULL
, NULL
, NULL
,
14884 /* 5C */ NULL
, NULL
, NULL
, NULL
,
14885 /* 60 */ NULL
, NULL
, NULL
, NULL
,
14886 /* 64 */ NULL
, NULL
, NULL
, NULL
,
14887 /* 68 */ NULL
, NULL
, NULL
, NULL
,
14888 /* 6C */ NULL
, NULL
, NULL
, NULL
,
14889 /* 70 */ NULL
, NULL
, NULL
, NULL
,
14890 /* 74 */ NULL
, NULL
, NULL
, NULL
,
14891 /* 78 */ NULL
, NULL
, NULL
, NULL
,
14892 /* 7C */ NULL
, NULL
, NULL
, NULL
,
14893 /* 80 */ NULL
, NULL
, NULL
, NULL
,
14894 /* 84 */ NULL
, NULL
, NULL
, NULL
,
14895 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
14896 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
14897 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
14898 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
14899 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
14900 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
14901 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
14902 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
14903 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
14904 /* AC */ NULL
, NULL
, "pfacc", NULL
,
14905 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
14906 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
14907 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
14908 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
14909 /* C0 */ NULL
, NULL
, NULL
, NULL
,
14910 /* C4 */ NULL
, NULL
, NULL
, NULL
,
14911 /* C8 */ NULL
, NULL
, NULL
, NULL
,
14912 /* CC */ NULL
, NULL
, NULL
, NULL
,
14913 /* D0 */ NULL
, NULL
, NULL
, NULL
,
14914 /* D4 */ NULL
, NULL
, NULL
, NULL
,
14915 /* D8 */ NULL
, NULL
, NULL
, NULL
,
14916 /* DC */ NULL
, NULL
, NULL
, NULL
,
14917 /* E0 */ NULL
, NULL
, NULL
, NULL
,
14918 /* E4 */ NULL
, NULL
, NULL
, NULL
,
14919 /* E8 */ NULL
, NULL
, NULL
, NULL
,
14920 /* EC */ NULL
, NULL
, NULL
, NULL
,
14921 /* F0 */ NULL
, NULL
, NULL
, NULL
,
14922 /* F4 */ NULL
, NULL
, NULL
, NULL
,
14923 /* F8 */ NULL
, NULL
, NULL
, NULL
,
14924 /* FC */ NULL
, NULL
, NULL
, NULL
,
14928 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14930 const char *mnemonic
;
14932 FETCH_DATA (the_info
, codep
+ 1);
14933 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14934 place where an 8-bit immediate would normally go. ie. the last
14935 byte of the instruction. */
14936 obufp
= mnemonicendp
;
14937 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
14939 oappend (mnemonic
);
14942 /* Since a variable sized modrm/sib chunk is between the start
14943 of the opcode (0x0f0f) and the opcode suffix, we need to do
14944 all the modrm processing first, and don't know until now that
14945 we have a bad opcode. This necessitates some cleaning up. */
14946 op_out
[0][0] = '\0';
14947 op_out
[1][0] = '\0';
14950 mnemonicendp
= obufp
;
14953 static struct op simd_cmp_op
[] =
14955 { STRING_COMMA_LEN ("eq") },
14956 { STRING_COMMA_LEN ("lt") },
14957 { STRING_COMMA_LEN ("le") },
14958 { STRING_COMMA_LEN ("unord") },
14959 { STRING_COMMA_LEN ("neq") },
14960 { STRING_COMMA_LEN ("nlt") },
14961 { STRING_COMMA_LEN ("nle") },
14962 { STRING_COMMA_LEN ("ord") }
14966 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14968 unsigned int cmp_type
;
14970 FETCH_DATA (the_info
, codep
+ 1);
14971 cmp_type
= *codep
++ & 0xff;
14972 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
14975 char *p
= mnemonicendp
- 2;
14979 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
14980 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
14984 /* We have a reserved extension byte. Output it directly. */
14985 scratchbuf
[0] = '$';
14986 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14987 oappend (scratchbuf
+ intel_syntax
);
14988 scratchbuf
[0] = '\0';
14993 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
14994 int sizeflag ATTRIBUTE_UNUSED
)
14996 /* mwait %eax,%ecx */
14999 const char **names
= (address_mode
== mode_64bit
15000 ? names64
: names32
);
15001 strcpy (op_out
[0], names
[0]);
15002 strcpy (op_out
[1], names
[1]);
15003 two_source_ops
= 1;
15005 /* Skip mod/rm byte. */
15011 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
15012 int sizeflag ATTRIBUTE_UNUSED
)
15014 /* monitor %eax,%ecx,%edx" */
15017 const char **op1_names
;
15018 const char **names
= (address_mode
== mode_64bit
15019 ? names64
: names32
);
15021 if (!(prefixes
& PREFIX_ADDR
))
15022 op1_names
= (address_mode
== mode_16bit
15023 ? names16
: names
);
15026 /* Remove "addr16/addr32". */
15027 all_prefixes
[last_addr_prefix
] = 0;
15028 op1_names
= (address_mode
!= mode_32bit
15029 ? names32
: names16
);
15030 used_prefixes
|= PREFIX_ADDR
;
15032 strcpy (op_out
[0], op1_names
[0]);
15033 strcpy (op_out
[1], names
[1]);
15034 strcpy (op_out
[2], names
[2]);
15035 two_source_ops
= 1;
15037 /* Skip mod/rm byte. */
15045 /* Throw away prefixes and 1st. opcode byte. */
15046 codep
= insn_codep
+ 1;
15051 REP_Fixup (int bytemode
, int sizeflag
)
15053 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
15055 if (prefixes
& PREFIX_REPZ
)
15056 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
15063 OP_IMREG (bytemode
, sizeflag
);
15066 OP_ESreg (bytemode
, sizeflag
);
15069 OP_DSreg (bytemode
, sizeflag
);
15078 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
15083 /* Change cmpxchg8b to cmpxchg16b. */
15084 char *p
= mnemonicendp
- 2;
15085 mnemonicendp
= stpcpy (p
, "16b");
15088 OP_M (bytemode
, sizeflag
);
15092 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
15096 switch (vex
.length
)
15099 sprintf (scratchbuf
, "%%xmm%d", reg
);
15102 sprintf (scratchbuf
, "%%ymm%d", reg
);
15109 sprintf (scratchbuf
, "%%xmm%d", reg
);
15110 oappend (scratchbuf
+ intel_syntax
);
15114 CRC32_Fixup (int bytemode
, int sizeflag
)
15116 /* Add proper suffix to "crc32". */
15117 char *p
= mnemonicendp
;
15136 if (sizeflag
& DFLAG
)
15140 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15144 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15151 if (modrm
.mod
== 3)
15155 /* Skip mod/rm byte. */
15160 add
= (rex
& REX_B
) ? 8 : 0;
15161 if (bytemode
== b_mode
)
15165 oappend (names8rex
[modrm
.rm
+ add
]);
15167 oappend (names8
[modrm
.rm
+ add
]);
15173 oappend (names64
[modrm
.rm
+ add
]);
15174 else if ((prefixes
& PREFIX_DATA
))
15175 oappend (names16
[modrm
.rm
+ add
]);
15177 oappend (names32
[modrm
.rm
+ add
]);
15181 OP_E (bytemode
, sizeflag
);
15185 FXSAVE_Fixup (int bytemode
, int sizeflag
)
15187 /* Add proper suffix to "fxsave" and "fxrstor". */
15191 char *p
= mnemonicendp
;
15197 OP_M (bytemode
, sizeflag
);
15200 /* Display the destination register operand for instructions with
15204 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
15212 switch (vex
.length
)
15225 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
15238 sprintf (scratchbuf
, "%%ymm%d", vex
.register_specifier
);
15244 oappend (scratchbuf
+ intel_syntax
);
15247 /* Get the VEX immediate byte without moving codep. */
15249 static unsigned char
15250 get_vex_imm8 (int sizeflag
, int opnum
)
15252 int bytes_before_imm
= 0;
15254 if (modrm
.mod
!= 3)
15256 /* There are SIB/displacement bytes. */
15257 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
15259 /* 32/64 bit address mode */
15260 int base
= modrm
.rm
;
15262 /* Check SIB byte. */
15265 FETCH_DATA (the_info
, codep
+ 1);
15267 /* When decoding the third source, don't increase
15268 bytes_before_imm as this has already been incremented
15269 by one in OP_E_memory while decoding the second
15272 bytes_before_imm
++;
15275 /* Don't increase bytes_before_imm when decoding the third source,
15276 it has already been incremented by OP_E_memory while decoding
15277 the second source operand. */
15283 /* When modrm.rm == 5 or modrm.rm == 4 and base in
15284 SIB == 5, there is a 4 byte displacement. */
15286 /* No displacement. */
15289 /* 4 byte displacement. */
15290 bytes_before_imm
+= 4;
15293 /* 1 byte displacement. */
15294 bytes_before_imm
++;
15301 /* 16 bit address mode */
15302 /* Don't increase bytes_before_imm when decoding the third source,
15303 it has already been incremented by OP_E_memory while decoding
15304 the second source operand. */
15310 /* When modrm.rm == 6, there is a 2 byte displacement. */
15312 /* No displacement. */
15315 /* 2 byte displacement. */
15316 bytes_before_imm
+= 2;
15319 /* 1 byte displacement: when decoding the third source,
15320 don't increase bytes_before_imm as this has already
15321 been incremented by one in OP_E_memory while decoding
15322 the second source operand. */
15324 bytes_before_imm
++;
15332 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
15333 return codep
[bytes_before_imm
];
15337 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
15339 if (reg
== -1 && modrm
.mod
!= 3)
15341 OP_E_memory (bytemode
, sizeflag
);
15353 else if (reg
> 7 && address_mode
!= mode_64bit
)
15357 switch (vex
.length
)
15360 sprintf (scratchbuf
, "%%xmm%d", reg
);
15363 sprintf (scratchbuf
, "%%ymm%d", reg
);
15368 oappend (scratchbuf
+ intel_syntax
);
15372 OP_Vex_2src (int bytemode
, int sizeflag
)
15374 if (modrm
.mod
== 3)
15377 sprintf (scratchbuf
, "%%xmm%d", rex
& REX_B
? modrm
.rm
+ 8 : modrm
.rm
);
15378 oappend (scratchbuf
+ intel_syntax
);
15383 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
15385 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
15386 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15388 OP_E (bytemode
, sizeflag
);
15393 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
15395 if (modrm
.mod
== 3)
15397 /* Skip mod/rm byte. */
15404 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
15405 oappend (scratchbuf
+ intel_syntax
);
15408 OP_Vex_2src (bytemode
, sizeflag
);
15412 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
15415 OP_Vex_2src (bytemode
, sizeflag
);
15418 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
15419 oappend (scratchbuf
+ intel_syntax
);
15424 OP_EX_VexW (int bytemode
, int sizeflag
)
15432 /* Skip mod/rm byte. */
15437 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
15442 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
15445 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
15449 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
15450 int sizeflag ATTRIBUTE_UNUSED
)
15452 /* Skip the immediate byte and check for invalid bits. */
15453 FETCH_DATA (the_info
, codep
+ 1);
15454 if (*codep
++ & 0xf)
15459 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
15462 FETCH_DATA (the_info
, codep
+ 1);
15465 if (bytemode
!= x_mode
)
15472 if (reg
> 7 && address_mode
!= mode_64bit
)
15475 switch (vex
.length
)
15478 sprintf (scratchbuf
, "%%xmm%d", reg
);
15481 sprintf (scratchbuf
, "%%ymm%d", reg
);
15486 oappend (scratchbuf
+ intel_syntax
);
15490 OP_XMM_VexW (int bytemode
, int sizeflag
)
15492 /* Turn off the REX.W bit since it is used for swapping operands
15495 OP_XMM (bytemode
, sizeflag
);
15499 OP_EX_Vex (int bytemode
, int sizeflag
)
15501 if (modrm
.mod
!= 3)
15503 if (vex
.register_specifier
!= 0)
15507 OP_EX (bytemode
, sizeflag
);
15511 OP_XMM_Vex (int bytemode
, int sizeflag
)
15513 if (modrm
.mod
!= 3)
15515 if (vex
.register_specifier
!= 0)
15519 OP_XMM (bytemode
, sizeflag
);
15523 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15525 switch (vex
.length
)
15528 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
15531 mnemonicendp
= stpcpy (obuf
, "vzeroall");
15538 static struct op vex_cmp_op
[] =
15540 { STRING_COMMA_LEN ("eq") },
15541 { STRING_COMMA_LEN ("lt") },
15542 { STRING_COMMA_LEN ("le") },
15543 { STRING_COMMA_LEN ("unord") },
15544 { STRING_COMMA_LEN ("neq") },
15545 { STRING_COMMA_LEN ("nlt") },
15546 { STRING_COMMA_LEN ("nle") },
15547 { STRING_COMMA_LEN ("ord") },
15548 { STRING_COMMA_LEN ("eq_uq") },
15549 { STRING_COMMA_LEN ("nge") },
15550 { STRING_COMMA_LEN ("ngt") },
15551 { STRING_COMMA_LEN ("false") },
15552 { STRING_COMMA_LEN ("neq_oq") },
15553 { STRING_COMMA_LEN ("ge") },
15554 { STRING_COMMA_LEN ("gt") },
15555 { STRING_COMMA_LEN ("true") },
15556 { STRING_COMMA_LEN ("eq_os") },
15557 { STRING_COMMA_LEN ("lt_oq") },
15558 { STRING_COMMA_LEN ("le_oq") },
15559 { STRING_COMMA_LEN ("unord_s") },
15560 { STRING_COMMA_LEN ("neq_us") },
15561 { STRING_COMMA_LEN ("nlt_uq") },
15562 { STRING_COMMA_LEN ("nle_uq") },
15563 { STRING_COMMA_LEN ("ord_s") },
15564 { STRING_COMMA_LEN ("eq_us") },
15565 { STRING_COMMA_LEN ("nge_uq") },
15566 { STRING_COMMA_LEN ("ngt_uq") },
15567 { STRING_COMMA_LEN ("false_os") },
15568 { STRING_COMMA_LEN ("neq_os") },
15569 { STRING_COMMA_LEN ("ge_oq") },
15570 { STRING_COMMA_LEN ("gt_oq") },
15571 { STRING_COMMA_LEN ("true_us") },
15575 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15577 unsigned int cmp_type
;
15579 FETCH_DATA (the_info
, codep
+ 1);
15580 cmp_type
= *codep
++ & 0xff;
15581 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
15584 char *p
= mnemonicendp
- 2;
15588 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
15589 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
15593 /* We have a reserved extension byte. Output it directly. */
15594 scratchbuf
[0] = '$';
15595 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
15596 oappend (scratchbuf
+ intel_syntax
);
15597 scratchbuf
[0] = '\0';
15601 static const struct op pclmul_op
[] =
15603 { STRING_COMMA_LEN ("lql") },
15604 { STRING_COMMA_LEN ("hql") },
15605 { STRING_COMMA_LEN ("lqh") },
15606 { STRING_COMMA_LEN ("hqh") }
15610 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
15611 int sizeflag ATTRIBUTE_UNUSED
)
15613 unsigned int pclmul_type
;
15615 FETCH_DATA (the_info
, codep
+ 1);
15616 pclmul_type
= *codep
++ & 0xff;
15617 switch (pclmul_type
)
15628 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
15631 char *p
= mnemonicendp
- 3;
15636 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
15637 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
15641 /* We have a reserved extension byte. Output it directly. */
15642 scratchbuf
[0] = '$';
15643 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
15644 oappend (scratchbuf
+ intel_syntax
);
15645 scratchbuf
[0] = '\0';
15650 MOVBE_Fixup (int bytemode
, int sizeflag
)
15652 /* Add proper suffix to "movbe". */
15653 char *p
= mnemonicendp
;
15662 if (sizeflag
& SUFFIX_ALWAYS
)
15668 if (sizeflag
& DFLAG
)
15672 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15677 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15684 OP_M (bytemode
, sizeflag
);
15688 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15691 const char **names
;
15693 /* Skip mod/rm byte. */
15699 else if (vex
.length
== 256)
15709 oappend (names
[reg
]);
15713 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15715 const char **names
;
15719 else if (vex
.length
== 256)
15724 oappend (names
[vex
.register_specifier
]);
15728 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
15730 if (vex
.w
|| vex
.length
== 256)
15731 OP_I (q_mode
, sizeflag
);
15733 OP_I (w_mode
, sizeflag
);