1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma, disassemble_info *);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma get64 (void);
60 static bfd_signed_vma get32 (void);
61 static bfd_signed_vma get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte *max_fetched;
125 bfd_byte the_buffer[MAX_MNEM_SIZE];
138 enum address_mode address_mode;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* REX bits in original REX prefix ignored. */
148 static int rex_ignored;
149 /* Mark parts used in the REX prefix. When we are testing for
150 empty prefix (for 8bit register REX extension), just mask it
151 out. Otherwise test for REX bit is excuse for existence of REX
152 only in case value is nonzero. */
153 #define USED_REX(value) \
158 rex_used |= (value) | REX_OPCODE; \
161 rex_used |= REX_OPCODE; \
164 /* Flags for prefixes which we somehow handled when printing the
165 current instruction. */
166 static int used_prefixes;
168 /* Flags stored in PREFIXES. */
169 #define PREFIX_REPZ 1
170 #define PREFIX_REPNZ 2
171 #define PREFIX_LOCK 4
173 #define PREFIX_SS 0x10
174 #define PREFIX_DS 0x20
175 #define PREFIX_ES 0x40
176 #define PREFIX_FS 0x80
177 #define PREFIX_GS 0x100
178 #define PREFIX_DATA 0x200
179 #define PREFIX_ADDR 0x400
180 #define PREFIX_FWAIT 0x800
182 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
183 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
185 #define FETCH_DATA(info, addr) \
186 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
187 ? 1 : fetch_data ((info), (addr)))
190 fetch_data (struct disassemble_info *info, bfd_byte *addr)
193 struct dis_private *priv = (struct dis_private *) info->private_data;
194 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
196 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
197 status = (*info->read_memory_func) (start,
199 addr - priv->max_fetched,
205 /* If we did manage to read at least one byte, then
206 print_insn_i386 will do something sensible. Otherwise, print
207 an error. We do that here because this is where we know
209 if (priv->max_fetched == priv->the_buffer)
210 (*info->memory_error_func) (status, start, info);
211 longjmp (priv->bailout, 1);
214 priv->max_fetched = addr;
218 #define XX { NULL, 0 }
220 #define Eb { OP_E, b_mode }
221 #define EbS { OP_E, b_swap_mode }
222 #define Ev { OP_E, v_mode }
223 #define EvS { OP_E, v_swap_mode }
224 #define Ed { OP_E, d_mode }
225 #define Edq { OP_E, dq_mode }
226 #define Edqw { OP_E, dqw_mode }
227 #define Edqb { OP_E, dqb_mode }
228 #define Edqd { OP_E, dqd_mode }
229 #define Eq { OP_E, q_mode }
230 #define indirEv { OP_indirE, stack_v_mode }
231 #define indirEp { OP_indirE, f_mode }
232 #define stackEv { OP_E, stack_v_mode }
233 #define Em { OP_E, m_mode }
234 #define Ew { OP_E, w_mode }
235 #define M { OP_M, 0 } /* lea, lgdt, etc. */
236 #define Ma { OP_M, a_mode }
237 #define Mb { OP_M, b_mode }
238 #define Md { OP_M, d_mode }
239 #define Mo { OP_M, o_mode }
240 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
241 #define Mq { OP_M, q_mode }
242 #define Mx { OP_M, x_mode }
243 #define Mxmm { OP_M, xmm_mode }
244 #define Gb { OP_G, b_mode }
245 #define Gv { OP_G, v_mode }
246 #define Gd { OP_G, d_mode }
247 #define Gdq { OP_G, dq_mode }
248 #define Gm { OP_G, m_mode }
249 #define Gw { OP_G, w_mode }
250 #define Rd { OP_R, d_mode }
251 #define Rm { OP_R, m_mode }
252 #define Ib { OP_I, b_mode }
253 #define sIb { OP_sI, b_mode } /* sign extened byte */
254 #define Iv { OP_I, v_mode }
255 #define Iq { OP_I, q_mode }
256 #define Iv64 { OP_I64, v_mode }
257 #define Iw { OP_I, w_mode }
258 #define I1 { OP_I, const_1_mode }
259 #define Jb { OP_J, b_mode }
260 #define Jv { OP_J, v_mode }
261 #define Cm { OP_C, m_mode }
262 #define Dm { OP_D, m_mode }
263 #define Td { OP_T, d_mode }
264 #define Skip_MODRM { OP_Skip_MODRM, 0 }
266 #define RMeAX { OP_REG, eAX_reg }
267 #define RMeBX { OP_REG, eBX_reg }
268 #define RMeCX { OP_REG, eCX_reg }
269 #define RMeDX { OP_REG, eDX_reg }
270 #define RMeSP { OP_REG, eSP_reg }
271 #define RMeBP { OP_REG, eBP_reg }
272 #define RMeSI { OP_REG, eSI_reg }
273 #define RMeDI { OP_REG, eDI_reg }
274 #define RMrAX { OP_REG, rAX_reg }
275 #define RMrBX { OP_REG, rBX_reg }
276 #define RMrCX { OP_REG, rCX_reg }
277 #define RMrDX { OP_REG, rDX_reg }
278 #define RMrSP { OP_REG, rSP_reg }
279 #define RMrBP { OP_REG, rBP_reg }
280 #define RMrSI { OP_REG, rSI_reg }
281 #define RMrDI { OP_REG, rDI_reg }
282 #define RMAL { OP_REG, al_reg }
283 #define RMAL { OP_REG, al_reg }
284 #define RMCL { OP_REG, cl_reg }
285 #define RMDL { OP_REG, dl_reg }
286 #define RMBL { OP_REG, bl_reg }
287 #define RMAH { OP_REG, ah_reg }
288 #define RMCH { OP_REG, ch_reg }
289 #define RMDH { OP_REG, dh_reg }
290 #define RMBH { OP_REG, bh_reg }
291 #define RMAX { OP_REG, ax_reg }
292 #define RMDX { OP_REG, dx_reg }
294 #define eAX { OP_IMREG, eAX_reg }
295 #define eBX { OP_IMREG, eBX_reg }
296 #define eCX { OP_IMREG, eCX_reg }
297 #define eDX { OP_IMREG, eDX_reg }
298 #define eSP { OP_IMREG, eSP_reg }
299 #define eBP { OP_IMREG, eBP_reg }
300 #define eSI { OP_IMREG, eSI_reg }
301 #define eDI { OP_IMREG, eDI_reg }
302 #define AL { OP_IMREG, al_reg }
303 #define CL { OP_IMREG, cl_reg }
304 #define DL { OP_IMREG, dl_reg }
305 #define BL { OP_IMREG, bl_reg }
306 #define AH { OP_IMREG, ah_reg }
307 #define CH { OP_IMREG, ch_reg }
308 #define DH { OP_IMREG, dh_reg }
309 #define BH { OP_IMREG, bh_reg }
310 #define AX { OP_IMREG, ax_reg }
311 #define DX { OP_IMREG, dx_reg }
312 #define zAX { OP_IMREG, z_mode_ax_reg }
313 #define indirDX { OP_IMREG, indir_dx_reg }
315 #define Sw { OP_SEG, w_mode }
316 #define Sv { OP_SEG, v_mode }
317 #define Ap { OP_DIR, 0 }
318 #define Ob { OP_OFF64, b_mode }
319 #define Ov { OP_OFF64, v_mode }
320 #define Xb { OP_DSreg, eSI_reg }
321 #define Xv { OP_DSreg, eSI_reg }
322 #define Xz { OP_DSreg, eSI_reg }
323 #define Yb { OP_ESreg, eDI_reg }
324 #define Yv { OP_ESreg, eDI_reg }
325 #define DSBX { OP_DSreg, eBX_reg }
327 #define es { OP_REG, es_reg }
328 #define ss { OP_REG, ss_reg }
329 #define cs { OP_REG, cs_reg }
330 #define ds { OP_REG, ds_reg }
331 #define fs { OP_REG, fs_reg }
332 #define gs { OP_REG, gs_reg }
334 #define MX { OP_MMX, 0 }
335 #define XM { OP_XMM, 0 }
336 #define XMM { OP_XMM, xmm_mode }
337 #define EM { OP_EM, v_mode }
338 #define EMS { OP_EM, v_swap_mode }
339 #define EMd { OP_EM, d_mode }
340 #define EMx { OP_EM, x_mode }
341 #define EXw { OP_EX, w_mode }
342 #define EXd { OP_EX, d_mode }
343 #define EXdS { OP_EX, d_swap_mode }
344 #define EXq { OP_EX, q_mode }
345 #define EXqS { OP_EX, q_swap_mode }
346 #define EXx { OP_EX, x_mode }
347 #define EXxS { OP_EX, x_swap_mode }
348 #define EXxmm { OP_EX, xmm_mode }
349 #define EXxmmq { OP_EX, xmmq_mode }
350 #define EXymmq { OP_EX, ymmq_mode }
351 #define EXVexWdq { OP_EX, vex_w_dq_mode }
352 #define MS { OP_MS, v_mode }
353 #define XS { OP_XS, v_mode }
354 #define EMCq { OP_EMC, q_mode }
355 #define MXC { OP_MXC, 0 }
356 #define OPSUF { OP_3DNowSuffix, 0 }
357 #define CMP { CMP_Fixup, 0 }
358 #define XMM0 { XMM_Fixup, 0 }
359 #define FXSAVE { FXSAVE_Fixup, 0 }
360 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
361 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
363 #define Vex { OP_VEX, vex_mode }
364 #define Vex128 { OP_VEX, vex128_mode }
365 #define Vex256 { OP_VEX, vex256_mode }
366 #define VexI4 { VEXI4_Fixup, 0}
367 #define EXdVex { OP_EX_Vex, d_mode }
368 #define EXdVexS { OP_EX_Vex, d_swap_mode }
369 #define EXqVex { OP_EX_Vex, q_mode }
370 #define EXqVexS { OP_EX_Vex, q_swap_mode }
371 #define EXVexW { OP_EX_VexW, x_mode }
372 #define EXdVexW { OP_EX_VexW, d_mode }
373 #define EXqVexW { OP_EX_VexW, q_mode }
374 #define XMVex { OP_XMM_Vex, 0 }
375 #define XMVexW { OP_XMM_VexW, 0 }
376 #define XMVexI4 { OP_REG_VexI4, x_mode }
377 #define PCLMUL { PCLMUL_Fixup, 0 }
378 #define VZERO { VZERO_Fixup, 0 }
379 #define VCMP { VCMP_Fixup, 0 }
381 /* Used handle "rep" prefix for string instructions. */
382 #define Xbr { REP_Fixup, eSI_reg }
383 #define Xvr { REP_Fixup, eSI_reg }
384 #define Ybr { REP_Fixup, eDI_reg }
385 #define Yvr { REP_Fixup, eDI_reg }
386 #define Yzr { REP_Fixup, eDI_reg }
387 #define indirDXr { REP_Fixup, indir_dx_reg }
388 #define ALr { REP_Fixup, al_reg }
389 #define eAXr { REP_Fixup, eAX_reg }
391 #define cond_jump_flag { NULL, cond_jump_mode }
392 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
394 /* bits in sizeflag */
395 #define SUFFIX_ALWAYS 4
403 /* byte operand with operand swapped */
405 /* operand size depends on prefixes */
407 /* operand size depends on prefixes with operand swapped */
411 /* double word operand */
413 /* double word operand with operand swapped */
415 /* quad word operand */
417 /* quad word operand with operand swapped */
419 /* ten-byte operand */
421 /* 16-byte XMM or 32-byte YMM operand */
423 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
425 /* 16-byte XMM operand */
427 /* 16-byte XMM or quad word operand */
429 /* 32-byte YMM or quad word operand */
431 /* d_mode in 32bit, q_mode in 64bit mode. */
433 /* pair of v_mode operands */
437 /* operand size depends on REX prefixes. */
439 /* registers like dq_mode, memory like w_mode. */
441 /* 4- or 6-byte pointer operand */
444 /* v_mode for stack-related opcodes. */
446 /* non-quad operand size depends on prefixes */
448 /* 16-byte operand */
450 /* registers like dq_mode, memory like b_mode. */
452 /* registers like dq_mode, memory like d_mode. */
454 /* normal vex mode */
456 /* 128bit vex mode */
458 /* 256bit vex mode */
460 /* operand size depends on the VEX.W bit. */
526 #define FLOAT NULL, { { NULL, FLOATCODE } }
528 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
529 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
530 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
531 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
532 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
533 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
534 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
535 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
536 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
537 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
538 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
539 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
657 MOD_VEX_3818_PREFIX_2,
658 MOD_VEX_3819_PREFIX_2,
659 MOD_VEX_381A_PREFIX_2,
660 MOD_VEX_382A_PREFIX_2,
661 MOD_VEX_382C_PREFIX_2,
662 MOD_VEX_382D_PREFIX_2,
663 MOD_VEX_382E_PREFIX_2,
664 MOD_VEX_382F_PREFIX_2
1074 THREE_BYTE_0F38 = 0,
1229 VEX_LEN_3819_P_2_M_0,
1230 VEX_LEN_381A_P_2_M_0,
1242 VEX_LEN_382A_P_2_M_0,
1558 typedef void (*op_rtn) (int bytemode, int sizeflag);
1569 /* Upper case letters in the instruction names here are macros.
1570 'A' => print 'b' if no register operands or suffix_always is true
1571 'B' => print 'b' if suffix_always is true
1572 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1574 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1575 suffix_always is true
1576 'E' => print 'e' if 32-bit form of jcxz
1577 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1578 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1579 'H' => print ",pt" or ",pn" branch hint
1580 'I' => honor following macro letter even in Intel mode (implemented only
1581 for some of the macro letters)
1583 'K' => print 'd' or 'q' if rex prefix is present.
1584 'L' => print 'l' if suffix_always is true
1585 'M' => print 'r' if intel_mnemonic is false.
1586 'N' => print 'n' if instruction has no wait "prefix"
1587 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1588 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1589 or suffix_always is true. print 'q' if rex prefix is present.
1590 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1592 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1593 'S' => print 'w', 'l' or 'q' if suffix_always is true
1594 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1595 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1596 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1597 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1598 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1599 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1600 suffix_always is true.
1601 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1602 '!' => change condition from true to false or from false to true.
1603 '%' => add 1 upper case letter to the macro.
1605 2 upper case letter macros:
1606 "XY" => print 'x' or 'y' if no register operands or suffix_always
1608 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1609 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1610 or suffix_always is true
1611 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1612 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1613 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1615 Many of the above letters print nothing in Intel mode. See "putop"
1618 Braces '{' and '}', and vertical bars '|', indicate alternative
1619 mnemonic strings for AT&T and Intel. */
1621 static const struct dis386 dis386[] = {
1623 { "addB", { Eb, Gb } },
1624 { "addS", { Ev, Gv } },
1625 { "addB", { Gb, EbS } },
1626 { "addS", { Gv, EvS } },
1627 { "addB", { AL, Ib } },
1628 { "addS", { eAX, Iv } },
1629 { X86_64_TABLE (X86_64_06) },
1630 { X86_64_TABLE (X86_64_07) },
1632 { "orB", { Eb, Gb } },
1633 { "orS", { Ev, Gv } },
1634 { "orB", { Gb, EbS } },
1635 { "orS", { Gv, EvS } },
1636 { "orB", { AL, Ib } },
1637 { "orS", { eAX, Iv } },
1638 { X86_64_TABLE (X86_64_0D) },
1639 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
1641 { "adcB", { Eb, Gb } },
1642 { "adcS", { Ev, Gv } },
1643 { "adcB", { Gb, EbS } },
1644 { "adcS", { Gv, EvS } },
1645 { "adcB", { AL, Ib } },
1646 { "adcS", { eAX, Iv } },
1647 { X86_64_TABLE (X86_64_16) },
1648 { X86_64_TABLE (X86_64_17) },
1650 { "sbbB", { Eb, Gb } },
1651 { "sbbS", { Ev, Gv } },
1652 { "sbbB", { Gb, EbS } },
1653 { "sbbS", { Gv, EvS } },
1654 { "sbbB", { AL, Ib } },
1655 { "sbbS", { eAX, Iv } },
1656 { X86_64_TABLE (X86_64_1E) },
1657 { X86_64_TABLE (X86_64_1F) },
1659 { "andB", { Eb, Gb } },
1660 { "andS", { Ev, Gv } },
1661 { "andB", { Gb, EbS } },
1662 { "andS", { Gv, EvS } },
1663 { "andB", { AL, Ib } },
1664 { "andS", { eAX, Iv } },
1665 { "(bad)", { XX } }, /* SEG ES prefix */
1666 { X86_64_TABLE (X86_64_27) },
1668 { "subB", { Eb, Gb } },
1669 { "subS", { Ev, Gv } },
1670 { "subB", { Gb, EbS } },
1671 { "subS", { Gv, EvS } },
1672 { "subB", { AL, Ib } },
1673 { "subS", { eAX, Iv } },
1674 { "(bad)", { XX } }, /* SEG CS prefix */
1675 { X86_64_TABLE (X86_64_2F) },
1677 { "xorB", { Eb, Gb } },
1678 { "xorS", { Ev, Gv } },
1679 { "xorB", { Gb, EbS } },
1680 { "xorS", { Gv, EvS } },
1681 { "xorB", { AL, Ib } },
1682 { "xorS", { eAX, Iv } },
1683 { "(bad)", { XX } }, /* SEG SS prefix */
1684 { X86_64_TABLE (X86_64_37) },
1686 { "cmpB", { Eb, Gb } },
1687 { "cmpS", { Ev, Gv } },
1688 { "cmpB", { Gb, EbS } },
1689 { "cmpS", { Gv, EvS } },
1690 { "cmpB", { AL, Ib } },
1691 { "cmpS", { eAX, Iv } },
1692 { "(bad)", { XX } }, /* SEG DS prefix */
1693 { X86_64_TABLE (X86_64_3F) },
1695 { "inc{S|}", { RMeAX } },
1696 { "inc{S|}", { RMeCX } },
1697 { "inc{S|}", { RMeDX } },
1698 { "inc{S|}", { RMeBX } },
1699 { "inc{S|}", { RMeSP } },
1700 { "inc{S|}", { RMeBP } },
1701 { "inc{S|}", { RMeSI } },
1702 { "inc{S|}", { RMeDI } },
1704 { "dec{S|}", { RMeAX } },
1705 { "dec{S|}", { RMeCX } },
1706 { "dec{S|}", { RMeDX } },
1707 { "dec{S|}", { RMeBX } },
1708 { "dec{S|}", { RMeSP } },
1709 { "dec{S|}", { RMeBP } },
1710 { "dec{S|}", { RMeSI } },
1711 { "dec{S|}", { RMeDI } },
1713 { "pushV", { RMrAX } },
1714 { "pushV", { RMrCX } },
1715 { "pushV", { RMrDX } },
1716 { "pushV", { RMrBX } },
1717 { "pushV", { RMrSP } },
1718 { "pushV", { RMrBP } },
1719 { "pushV", { RMrSI } },
1720 { "pushV", { RMrDI } },
1722 { "popV", { RMrAX } },
1723 { "popV", { RMrCX } },
1724 { "popV", { RMrDX } },
1725 { "popV", { RMrBX } },
1726 { "popV", { RMrSP } },
1727 { "popV", { RMrBP } },
1728 { "popV", { RMrSI } },
1729 { "popV", { RMrDI } },
1731 { X86_64_TABLE (X86_64_60) },
1732 { X86_64_TABLE (X86_64_61) },
1733 { X86_64_TABLE (X86_64_62) },
1734 { X86_64_TABLE (X86_64_63) },
1735 { "(bad)", { XX } }, /* seg fs */
1736 { "(bad)", { XX } }, /* seg gs */
1737 { "(bad)", { XX } }, /* op size prefix */
1738 { "(bad)", { XX } }, /* adr size prefix */
1740 { "pushT", { Iq } },
1741 { "imulS", { Gv, Ev, Iv } },
1742 { "pushT", { sIb } },
1743 { "imulS", { Gv, Ev, sIb } },
1744 { "ins{b|}", { Ybr, indirDX } },
1745 { X86_64_TABLE (X86_64_6D) },
1746 { "outs{b|}", { indirDXr, Xb } },
1747 { X86_64_TABLE (X86_64_6F) },
1749 { "joH", { Jb, XX, cond_jump_flag } },
1750 { "jnoH", { Jb, XX, cond_jump_flag } },
1751 { "jbH", { Jb, XX, cond_jump_flag } },
1752 { "jaeH", { Jb, XX, cond_jump_flag } },
1753 { "jeH", { Jb, XX, cond_jump_flag } },
1754 { "jneH", { Jb, XX, cond_jump_flag } },
1755 { "jbeH", { Jb, XX, cond_jump_flag } },
1756 { "jaH", { Jb, XX, cond_jump_flag } },
1758 { "jsH", { Jb, XX, cond_jump_flag } },
1759 { "jnsH", { Jb, XX, cond_jump_flag } },
1760 { "jpH", { Jb, XX, cond_jump_flag } },
1761 { "jnpH", { Jb, XX, cond_jump_flag } },
1762 { "jlH", { Jb, XX, cond_jump_flag } },
1763 { "jgeH", { Jb, XX, cond_jump_flag } },
1764 { "jleH", { Jb, XX, cond_jump_flag } },
1765 { "jgH", { Jb, XX, cond_jump_flag } },
1767 { REG_TABLE (REG_80) },
1768 { REG_TABLE (REG_81) },
1769 { "(bad)", { XX } },
1770 { REG_TABLE (REG_82) },
1771 { "testB", { Eb, Gb } },
1772 { "testS", { Ev, Gv } },
1773 { "xchgB", { Eb, Gb } },
1774 { "xchgS", { Ev, Gv } },
1776 { "movB", { Eb, Gb } },
1777 { "movS", { Ev, Gv } },
1778 { "movB", { Gb, EbS } },
1779 { "movS", { Gv, EvS } },
1780 { "movD", { Sv, Sw } },
1781 { MOD_TABLE (MOD_8D) },
1782 { "movD", { Sw, Sv } },
1783 { REG_TABLE (REG_8F) },
1785 { PREFIX_TABLE (PREFIX_90) },
1786 { "xchgS", { RMeCX, eAX } },
1787 { "xchgS", { RMeDX, eAX } },
1788 { "xchgS", { RMeBX, eAX } },
1789 { "xchgS", { RMeSP, eAX } },
1790 { "xchgS", { RMeBP, eAX } },
1791 { "xchgS", { RMeSI, eAX } },
1792 { "xchgS", { RMeDI, eAX } },
1794 { "cW{t|}R", { XX } },
1795 { "cR{t|}O", { XX } },
1796 { X86_64_TABLE (X86_64_9A) },
1797 { "(bad)", { XX } }, /* fwait */
1798 { "pushfT", { XX } },
1799 { "popfT", { XX } },
1803 { "mov%LB", { AL, Ob } },
1804 { "mov%LS", { eAX, Ov } },
1805 { "mov%LB", { Ob, AL } },
1806 { "mov%LS", { Ov, eAX } },
1807 { "movs{b|}", { Ybr, Xb } },
1808 { "movs{R|}", { Yvr, Xv } },
1809 { "cmps{b|}", { Xb, Yb } },
1810 { "cmps{R|}", { Xv, Yv } },
1812 { "testB", { AL, Ib } },
1813 { "testS", { eAX, Iv } },
1814 { "stosB", { Ybr, AL } },
1815 { "stosS", { Yvr, eAX } },
1816 { "lodsB", { ALr, Xb } },
1817 { "lodsS", { eAXr, Xv } },
1818 { "scasB", { AL, Yb } },
1819 { "scasS", { eAX, Yv } },
1821 { "movB", { RMAL, Ib } },
1822 { "movB", { RMCL, Ib } },
1823 { "movB", { RMDL, Ib } },
1824 { "movB", { RMBL, Ib } },
1825 { "movB", { RMAH, Ib } },
1826 { "movB", { RMCH, Ib } },
1827 { "movB", { RMDH, Ib } },
1828 { "movB", { RMBH, Ib } },
1830 { "mov%LV", { RMeAX, Iv64 } },
1831 { "mov%LV", { RMeCX, Iv64 } },
1832 { "mov%LV", { RMeDX, Iv64 } },
1833 { "mov%LV", { RMeBX, Iv64 } },
1834 { "mov%LV", { RMeSP, Iv64 } },
1835 { "mov%LV", { RMeBP, Iv64 } },
1836 { "mov%LV", { RMeSI, Iv64 } },
1837 { "mov%LV", { RMeDI, Iv64 } },
1839 { REG_TABLE (REG_C0) },
1840 { REG_TABLE (REG_C1) },
1843 { X86_64_TABLE (X86_64_C4) },
1844 { X86_64_TABLE (X86_64_C5) },
1845 { REG_TABLE (REG_C6) },
1846 { REG_TABLE (REG_C7) },
1848 { "enterT", { Iw, Ib } },
1849 { "leaveT", { XX } },
1850 { "Jret{|f}P", { Iw } },
1851 { "Jret{|f}P", { XX } },
1854 { X86_64_TABLE (X86_64_CE) },
1855 { "iretP", { XX } },
1857 { REG_TABLE (REG_D0) },
1858 { REG_TABLE (REG_D1) },
1859 { REG_TABLE (REG_D2) },
1860 { REG_TABLE (REG_D3) },
1861 { X86_64_TABLE (X86_64_D4) },
1862 { X86_64_TABLE (X86_64_D5) },
1863 { "(bad)", { XX } },
1864 { "xlat", { DSBX } },
1875 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
1876 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
1877 { "loopFH", { Jb, XX, loop_jcxz_flag } },
1878 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
1879 { "inB", { AL, Ib } },
1880 { "inG", { zAX, Ib } },
1881 { "outB", { Ib, AL } },
1882 { "outG", { Ib, zAX } },
1884 { "callT", { Jv } },
1886 { X86_64_TABLE (X86_64_EA) },
1888 { "inB", { AL, indirDX } },
1889 { "inG", { zAX, indirDX } },
1890 { "outB", { indirDX, AL } },
1891 { "outG", { indirDX, zAX } },
1893 { "(bad)", { XX } }, /* lock prefix */
1894 { "icebp", { XX } },
1895 { "(bad)", { XX } }, /* repne */
1896 { "(bad)", { XX } }, /* repz */
1899 { REG_TABLE (REG_F6) },
1900 { REG_TABLE (REG_F7) },
1908 { REG_TABLE (REG_FE) },
1909 { REG_TABLE (REG_FF) },
1912 static const struct dis386 dis386_twobyte[] = {
1914 { REG_TABLE (REG_0F00 ) },
1915 { REG_TABLE (REG_0F01 ) },
1916 { "larS", { Gv, Ew } },
1917 { "lslS", { Gv, Ew } },
1918 { "(bad)", { XX } },
1919 { "syscall", { XX } },
1921 { "sysretP", { XX } },
1924 { "wbinvd", { XX } },
1925 { "(bad)", { XX } },
1927 { "(bad)", { XX } },
1928 { REG_TABLE (REG_0F0D) },
1929 { "femms", { XX } },
1930 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1932 { PREFIX_TABLE (PREFIX_0F10) },
1933 { PREFIX_TABLE (PREFIX_0F11) },
1934 { PREFIX_TABLE (PREFIX_0F12) },
1935 { MOD_TABLE (MOD_0F13) },
1936 { "unpcklpX", { XM, EXx } },
1937 { "unpckhpX", { XM, EXx } },
1938 { PREFIX_TABLE (PREFIX_0F16) },
1939 { MOD_TABLE (MOD_0F17) },
1941 { REG_TABLE (REG_0F18) },
1950 { MOD_TABLE (MOD_0F20) },
1951 { MOD_TABLE (MOD_0F21) },
1952 { MOD_TABLE (MOD_0F22) },
1953 { MOD_TABLE (MOD_0F23) },
1954 { MOD_TABLE (MOD_0F24) },
1955 { "(bad)", { XX } },
1956 { MOD_TABLE (MOD_0F26) },
1957 { "(bad)", { XX } },
1959 { "movapX", { XM, EXx } },
1960 { "movapX", { EXxS, XM } },
1961 { PREFIX_TABLE (PREFIX_0F2A) },
1962 { PREFIX_TABLE (PREFIX_0F2B) },
1963 { PREFIX_TABLE (PREFIX_0F2C) },
1964 { PREFIX_TABLE (PREFIX_0F2D) },
1965 { PREFIX_TABLE (PREFIX_0F2E) },
1966 { PREFIX_TABLE (PREFIX_0F2F) },
1968 { "wrmsr", { XX } },
1969 { "rdtsc", { XX } },
1970 { "rdmsr", { XX } },
1971 { "rdpmc", { XX } },
1972 { "sysenter", { XX } },
1973 { "sysexit", { XX } },
1974 { "(bad)", { XX } },
1975 { "getsec", { XX } },
1977 { THREE_BYTE_TABLE (THREE_BYTE_0F38) },
1978 { "(bad)", { XX } },
1979 { THREE_BYTE_TABLE (THREE_BYTE_0F3A) },
1980 { "(bad)", { XX } },
1981 { "(bad)", { XX } },
1982 { "(bad)", { XX } },
1983 { "(bad)", { XX } },
1984 { "(bad)", { XX } },
1986 { "cmovoS", { Gv, Ev } },
1987 { "cmovnoS", { Gv, Ev } },
1988 { "cmovbS", { Gv, Ev } },
1989 { "cmovaeS", { Gv, Ev } },
1990 { "cmoveS", { Gv, Ev } },
1991 { "cmovneS", { Gv, Ev } },
1992 { "cmovbeS", { Gv, Ev } },
1993 { "cmovaS", { Gv, Ev } },
1995 { "cmovsS", { Gv, Ev } },
1996 { "cmovnsS", { Gv, Ev } },
1997 { "cmovpS", { Gv, Ev } },
1998 { "cmovnpS", { Gv, Ev } },
1999 { "cmovlS", { Gv, Ev } },
2000 { "cmovgeS", { Gv, Ev } },
2001 { "cmovleS", { Gv, Ev } },
2002 { "cmovgS", { Gv, Ev } },
2004 { MOD_TABLE (MOD_0F51) },
2005 { PREFIX_TABLE (PREFIX_0F51) },
2006 { PREFIX_TABLE (PREFIX_0F52) },
2007 { PREFIX_TABLE (PREFIX_0F53) },
2008 { "andpX", { XM, EXx } },
2009 { "andnpX", { XM, EXx } },
2010 { "orpX", { XM, EXx } },
2011 { "xorpX", { XM, EXx } },
2013 { PREFIX_TABLE (PREFIX_0F58) },
2014 { PREFIX_TABLE (PREFIX_0F59) },
2015 { PREFIX_TABLE (PREFIX_0F5A) },
2016 { PREFIX_TABLE (PREFIX_0F5B) },
2017 { PREFIX_TABLE (PREFIX_0F5C) },
2018 { PREFIX_TABLE (PREFIX_0F5D) },
2019 { PREFIX_TABLE (PREFIX_0F5E) },
2020 { PREFIX_TABLE (PREFIX_0F5F) },
2022 { PREFIX_TABLE (PREFIX_0F60) },
2023 { PREFIX_TABLE (PREFIX_0F61) },
2024 { PREFIX_TABLE (PREFIX_0F62) },
2025 { "packsswb", { MX, EM } },
2026 { "pcmpgtb", { MX, EM } },
2027 { "pcmpgtw", { MX, EM } },
2028 { "pcmpgtd", { MX, EM } },
2029 { "packuswb", { MX, EM } },
2031 { "punpckhbw", { MX, EM } },
2032 { "punpckhwd", { MX, EM } },
2033 { "punpckhdq", { MX, EM } },
2034 { "packssdw", { MX, EM } },
2035 { PREFIX_TABLE (PREFIX_0F6C) },
2036 { PREFIX_TABLE (PREFIX_0F6D) },
2037 { "movK", { MX, Edq } },
2038 { PREFIX_TABLE (PREFIX_0F6F) },
2040 { PREFIX_TABLE (PREFIX_0F70) },
2041 { REG_TABLE (REG_0F71) },
2042 { REG_TABLE (REG_0F72) },
2043 { REG_TABLE (REG_0F73) },
2044 { "pcmpeqb", { MX, EM } },
2045 { "pcmpeqw", { MX, EM } },
2046 { "pcmpeqd", { MX, EM } },
2049 { PREFIX_TABLE (PREFIX_0F78) },
2050 { PREFIX_TABLE (PREFIX_0F79) },
2051 { THREE_BYTE_TABLE (THREE_BYTE_0F7A) },
2052 { "(bad)", { XX } },
2053 { PREFIX_TABLE (PREFIX_0F7C) },
2054 { PREFIX_TABLE (PREFIX_0F7D) },
2055 { PREFIX_TABLE (PREFIX_0F7E) },
2056 { PREFIX_TABLE (PREFIX_0F7F) },
2058 { "joH", { Jv, XX, cond_jump_flag } },
2059 { "jnoH", { Jv, XX, cond_jump_flag } },
2060 { "jbH", { Jv, XX, cond_jump_flag } },
2061 { "jaeH", { Jv, XX, cond_jump_flag } },
2062 { "jeH", { Jv, XX, cond_jump_flag } },
2063 { "jneH", { Jv, XX, cond_jump_flag } },
2064 { "jbeH", { Jv, XX, cond_jump_flag } },
2065 { "jaH", { Jv, XX, cond_jump_flag } },
2067 { "jsH", { Jv, XX, cond_jump_flag } },
2068 { "jnsH", { Jv, XX, cond_jump_flag } },
2069 { "jpH", { Jv, XX, cond_jump_flag } },
2070 { "jnpH", { Jv, XX, cond_jump_flag } },
2071 { "jlH", { Jv, XX, cond_jump_flag } },
2072 { "jgeH", { Jv, XX, cond_jump_flag } },
2073 { "jleH", { Jv, XX, cond_jump_flag } },
2074 { "jgH", { Jv, XX, cond_jump_flag } },
2077 { "setno", { Eb } },
2079 { "setae", { Eb } },
2081 { "setne", { Eb } },
2082 { "setbe", { Eb } },
2086 { "setns", { Eb } },
2088 { "setnp", { Eb } },
2090 { "setge", { Eb } },
2091 { "setle", { Eb } },
2094 { "pushT", { fs } },
2096 { "cpuid", { XX } },
2097 { "btS", { Ev, Gv } },
2098 { "shldS", { Ev, Gv, Ib } },
2099 { "shldS", { Ev, Gv, CL } },
2100 { REG_TABLE (REG_0FA6) },
2101 { REG_TABLE (REG_0FA7) },
2103 { "pushT", { gs } },
2106 { "btsS", { Ev, Gv } },
2107 { "shrdS", { Ev, Gv, Ib } },
2108 { "shrdS", { Ev, Gv, CL } },
2109 { REG_TABLE (REG_0FAE) },
2110 { "imulS", { Gv, Ev } },
2112 { "cmpxchgB", { Eb, Gb } },
2113 { "cmpxchgS", { Ev, Gv } },
2114 { MOD_TABLE (MOD_0FB2) },
2115 { "btrS", { Ev, Gv } },
2116 { MOD_TABLE (MOD_0FB4) },
2117 { MOD_TABLE (MOD_0FB5) },
2118 { "movz{bR|x}", { Gv, Eb } },
2119 { "movz{wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
2121 { PREFIX_TABLE (PREFIX_0FB8) },
2123 { REG_TABLE (REG_0FBA) },
2124 { "btcS", { Ev, Gv } },
2125 { "bsfS", { Gv, Ev } },
2126 { PREFIX_TABLE (PREFIX_0FBD) },
2127 { "movs{bR|x}", { Gv, Eb } },
2128 { "movs{wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
2130 { "xaddB", { Eb, Gb } },
2131 { "xaddS", { Ev, Gv } },
2132 { PREFIX_TABLE (PREFIX_0FC2) },
2133 { PREFIX_TABLE (PREFIX_0FC3) },
2134 { "pinsrw", { MX, Edqw, Ib } },
2135 { "pextrw", { Gdq, MS, Ib } },
2136 { "shufpX", { XM, EXx, Ib } },
2137 { REG_TABLE (REG_0FC7) },
2139 { "bswap", { RMeAX } },
2140 { "bswap", { RMeCX } },
2141 { "bswap", { RMeDX } },
2142 { "bswap", { RMeBX } },
2143 { "bswap", { RMeSP } },
2144 { "bswap", { RMeBP } },
2145 { "bswap", { RMeSI } },
2146 { "bswap", { RMeDI } },
2148 { PREFIX_TABLE (PREFIX_0FD0) },
2149 { "psrlw", { MX, EM } },
2150 { "psrld", { MX, EM } },
2151 { "psrlq", { MX, EM } },
2152 { "paddq", { MX, EM } },
2153 { "pmullw", { MX, EM } },
2154 { PREFIX_TABLE (PREFIX_0FD6) },
2155 { MOD_TABLE (MOD_0FD7) },
2157 { "psubusb", { MX, EM } },
2158 { "psubusw", { MX, EM } },
2159 { "pminub", { MX, EM } },
2160 { "pand", { MX, EM } },
2161 { "paddusb", { MX, EM } },
2162 { "paddusw", { MX, EM } },
2163 { "pmaxub", { MX, EM } },
2164 { "pandn", { MX, EM } },
2166 { "pavgb", { MX, EM } },
2167 { "psraw", { MX, EM } },
2168 { "psrad", { MX, EM } },
2169 { "pavgw", { MX, EM } },
2170 { "pmulhuw", { MX, EM } },
2171 { "pmulhw", { MX, EM } },
2172 { PREFIX_TABLE (PREFIX_0FE6) },
2173 { PREFIX_TABLE (PREFIX_0FE7) },
2175 { "psubsb", { MX, EM } },
2176 { "psubsw", { MX, EM } },
2177 { "pminsw", { MX, EM } },
2178 { "por", { MX, EM } },
2179 { "paddsb", { MX, EM } },
2180 { "paddsw", { MX, EM } },
2181 { "pmaxsw", { MX, EM } },
2182 { "pxor", { MX, EM } },
2184 { PREFIX_TABLE (PREFIX_0FF0) },
2185 { "psllw", { MX, EM } },
2186 { "pslld", { MX, EM } },
2187 { "psllq", { MX, EM } },
2188 { "pmuludq", { MX, EM } },
2189 { "pmaddwd", { MX, EM } },
2190 { "psadbw", { MX, EM } },
2191 { PREFIX_TABLE (PREFIX_0FF7) },
2193 { "psubb", { MX, EM } },
2194 { "psubw", { MX, EM } },
2195 { "psubd", { MX, EM } },
2196 { "psubq", { MX, EM } },
2197 { "paddb", { MX, EM } },
2198 { "paddw", { MX, EM } },
2199 { "paddd", { MX, EM } },
2200 { "(bad)", { XX } },
2203 static const unsigned char onebyte_has_modrm[256] = {
2204 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2205 /* ------------------------------- */
2206 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2207 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2208 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2209 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2210 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2211 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2212 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2213 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2214 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2215 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2216 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2217 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2218 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2219 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2220 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2221 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2222 /* ------------------------------- */
2223 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2226 static const unsigned char twobyte_has_modrm[256] = {
2227 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2228 /* ------------------------------- */
2229 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2230 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2231 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2232 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2233 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2234 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2235 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2236 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2237 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2238 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2239 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2240 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2241 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2242 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2243 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2244 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2245 /* ------------------------------- */
2246 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2249 static char obuf[100];
2251 static char *mnemonicendp;
2252 static char scratchbuf[100];
2253 static unsigned char *start_codep;
2254 static unsigned char *insn_codep;
2255 static unsigned char *codep;
2256 static int last_lock_prefix;
2257 static int last_repz_prefix;
2258 static int last_repnz_prefix;
2259 static int last_data_prefix;
2260 static int last_addr_prefix;
2261 static int last_rex_prefix;
2262 static int last_seg_prefix;
2263 #define MAX_CODE_LENGTH 15
2264 /* We can up to 14 prefixes since the maximum instruction length is
2266 static int all_prefixes[MAX_CODE_LENGTH - 1];
2267 static disassemble_info *the_info;
2275 static unsigned char need_modrm;
2278 int register_specifier;
2284 static unsigned char need_vex;
2285 static unsigned char need_vex_reg;
2286 static unsigned char vex_w_done;
2294 /* If we are accessing mod/rm/reg without need_modrm set, then the
2295 values are stale. Hitting this abort likely indicates that you
2296 need to update onebyte_has_modrm or twobyte_has_modrm. */
2297 #define MODRM_CHECK if (!need_modrm) abort ()
2299 static const char **names64;
2300 static const char **names32;
2301 static const char **names16;
2302 static const char **names8;
2303 static const char **names8rex;
2304 static const char **names_seg;
2305 static const char *index64;
2306 static const char *index32;
2307 static const char **index16;
2309 static const char *intel_names64[] = {
2310 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2311 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2313 static const char *intel_names32[] = {
2314 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2315 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2317 static const char *intel_names16[] = {
2318 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2319 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2321 static const char *intel_names8[] = {
2322 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2324 static const char *intel_names8rex[] = {
2325 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2326 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2328 static const char *intel_names_seg[] = {
2329 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2331 static const char *intel_index64 = "riz";
2332 static const char *intel_index32 = "eiz";
2333 static const char *intel_index16[] = {
2334 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2337 static const char *att_names64[] = {
2338 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2339 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2341 static const char *att_names32[] = {
2342 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2343 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2345 static const char *att_names16[] = {
2346 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2347 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2349 static const char *att_names8[] = {
2350 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2352 static const char *att_names8rex[] = {
2353 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2354 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2356 static const char *att_names_seg[] = {
2357 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2359 static const char *att_index64 = "%riz";
2360 static const char *att_index32 = "%eiz";
2361 static const char *att_index16[] = {
2362 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2365 static const char **names_mm;
2366 static const char *intel_names_mm[] = {
2367 "mm0", "mm1", "mm2", "mm3",
2368 "mm4", "mm5", "mm6", "mm7"
2370 static const char *att_names_mm[] = {
2371 "%mm0", "%mm1", "%mm2", "%mm3",
2372 "%mm4", "%mm5", "%mm6", "%mm7"
2375 static const char **names_xmm;
2376 static const char *intel_names_xmm[] = {
2377 "xmm0", "xmm1", "xmm2", "xmm3",
2378 "xmm4", "xmm5", "xmm6", "xmm7",
2379 "xmm8", "xmm9", "xmm10", "xmm11",
2380 "xmm12", "xmm13", "xmm14", "xmm15"
2382 static const char *att_names_xmm[] = {
2383 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
2384 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
2385 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
2386 "%xmm12", "%xmm13", "%xmm14", "%xmm15"
2389 static const char **names_ymm;
2390 static const char *intel_names_ymm[] = {
2391 "ymm0", "ymm1", "ymm2", "ymm3",
2392 "ymm4", "ymm5", "ymm6", "ymm7",
2393 "ymm8", "ymm9", "ymm10", "ymm11",
2394 "ymm12", "ymm13", "ymm14", "ymm15"
2396 static const char *att_names_ymm[] = {
2397 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
2398 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
2399 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
2400 "%ymm12", "%ymm13", "%ymm14", "%ymm15"
2403 static const struct dis386 reg_table[][8] = {
2406 { "addA", { Eb, Ib } },
2407 { "orA", { Eb, Ib } },
2408 { "adcA", { Eb, Ib } },
2409 { "sbbA", { Eb, Ib } },
2410 { "andA", { Eb, Ib } },
2411 { "subA", { Eb, Ib } },
2412 { "xorA", { Eb, Ib } },
2413 { "cmpA", { Eb, Ib } },
2417 { "addQ", { Ev, Iv } },
2418 { "orQ", { Ev, Iv } },
2419 { "adcQ", { Ev, Iv } },
2420 { "sbbQ", { Ev, Iv } },
2421 { "andQ", { Ev, Iv } },
2422 { "subQ", { Ev, Iv } },
2423 { "xorQ", { Ev, Iv } },
2424 { "cmpQ", { Ev, Iv } },
2428 { "addQ", { Ev, sIb } },
2429 { "orQ", { Ev, sIb } },
2430 { "adcQ", { Ev, sIb } },
2431 { "sbbQ", { Ev, sIb } },
2432 { "andQ", { Ev, sIb } },
2433 { "subQ", { Ev, sIb } },
2434 { "xorQ", { Ev, sIb } },
2435 { "cmpQ", { Ev, sIb } },
2439 { "popU", { stackEv } },
2440 { XOP_8F_TABLE (XOP_09) },
2441 { "(bad)", { XX } },
2442 { "(bad)", { XX } },
2443 { "(bad)", { XX } },
2444 { XOP_8F_TABLE (XOP_09) },
2445 { "(bad)", { XX } },
2446 { "(bad)", { XX } },
2450 { "rolA", { Eb, Ib } },
2451 { "rorA", { Eb, Ib } },
2452 { "rclA", { Eb, Ib } },
2453 { "rcrA", { Eb, Ib } },
2454 { "shlA", { Eb, Ib } },
2455 { "shrA", { Eb, Ib } },
2456 { "(bad)", { XX } },
2457 { "sarA", { Eb, Ib } },
2461 { "rolQ", { Ev, Ib } },
2462 { "rorQ", { Ev, Ib } },
2463 { "rclQ", { Ev, Ib } },
2464 { "rcrQ", { Ev, Ib } },
2465 { "shlQ", { Ev, Ib } },
2466 { "shrQ", { Ev, Ib } },
2467 { "(bad)", { XX } },
2468 { "sarQ", { Ev, Ib } },
2472 { "movA", { Eb, Ib } },
2473 { "(bad)", { XX } },
2474 { "(bad)", { XX } },
2475 { "(bad)", { XX } },
2476 { "(bad)", { XX } },
2477 { "(bad)", { XX } },
2478 { "(bad)", { XX } },
2479 { "(bad)", { XX } },
2483 { "movQ", { Ev, Iv } },
2484 { "(bad)", { XX } },
2485 { "(bad)", { XX } },
2486 { "(bad)", { XX } },
2487 { "(bad)", { XX } },
2488 { "(bad)", { XX } },
2489 { "(bad)", { XX } },
2490 { "(bad)", { XX } },
2494 { "rolA", { Eb, I1 } },
2495 { "rorA", { Eb, I1 } },
2496 { "rclA", { Eb, I1 } },
2497 { "rcrA", { Eb, I1 } },
2498 { "shlA", { Eb, I1 } },
2499 { "shrA", { Eb, I1 } },
2500 { "(bad)", { XX } },
2501 { "sarA", { Eb, I1 } },
2505 { "rolQ", { Ev, I1 } },
2506 { "rorQ", { Ev, I1 } },
2507 { "rclQ", { Ev, I1 } },
2508 { "rcrQ", { Ev, I1 } },
2509 { "shlQ", { Ev, I1 } },
2510 { "shrQ", { Ev, I1 } },
2511 { "(bad)", { XX } },
2512 { "sarQ", { Ev, I1 } },
2516 { "rolA", { Eb, CL } },
2517 { "rorA", { Eb, CL } },
2518 { "rclA", { Eb, CL } },
2519 { "rcrA", { Eb, CL } },
2520 { "shlA", { Eb, CL } },
2521 { "shrA", { Eb, CL } },
2522 { "(bad)", { XX } },
2523 { "sarA", { Eb, CL } },
2527 { "rolQ", { Ev, CL } },
2528 { "rorQ", { Ev, CL } },
2529 { "rclQ", { Ev, CL } },
2530 { "rcrQ", { Ev, CL } },
2531 { "shlQ", { Ev, CL } },
2532 { "shrQ", { Ev, CL } },
2533 { "(bad)", { XX } },
2534 { "sarQ", { Ev, CL } },
2538 { "testA", { Eb, Ib } },
2539 { "(bad)", { XX } },
2542 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
2543 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
2544 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
2545 { "idivA", { Eb } }, /* and idiv for consistency. */
2549 { "testQ", { Ev, Iv } },
2550 { "(bad)", { XX } },
2553 { "mulQ", { Ev } }, /* Don't print the implicit register. */
2554 { "imulQ", { Ev } },
2556 { "idivQ", { Ev } },
2562 { "(bad)", { XX } },
2563 { "(bad)", { XX } },
2564 { "(bad)", { XX } },
2565 { "(bad)", { XX } },
2566 { "(bad)", { XX } },
2567 { "(bad)", { XX } },
2573 { "callT", { indirEv } },
2574 { "JcallT", { indirEp } },
2575 { "jmpT", { indirEv } },
2576 { "JjmpT", { indirEp } },
2577 { "pushU", { stackEv } },
2578 { "(bad)", { XX } },
2582 { "sldtD", { Sv } },
2588 { "(bad)", { XX } },
2589 { "(bad)", { XX } },
2593 { MOD_TABLE (MOD_0F01_REG_0) },
2594 { MOD_TABLE (MOD_0F01_REG_1) },
2595 { MOD_TABLE (MOD_0F01_REG_2) },
2596 { MOD_TABLE (MOD_0F01_REG_3) },
2597 { "smswD", { Sv } },
2598 { "(bad)", { XX } },
2600 { MOD_TABLE (MOD_0F01_REG_7) },
2604 { "prefetch", { Eb } },
2605 { "prefetchw", { Eb } },
2606 { "(bad)", { XX } },
2607 { "(bad)", { XX } },
2608 { "(bad)", { XX } },
2609 { "(bad)", { XX } },
2610 { "(bad)", { XX } },
2611 { "(bad)", { XX } },
2615 { MOD_TABLE (MOD_0F18_REG_0) },
2616 { MOD_TABLE (MOD_0F18_REG_1) },
2617 { MOD_TABLE (MOD_0F18_REG_2) },
2618 { MOD_TABLE (MOD_0F18_REG_3) },
2619 { "(bad)", { XX } },
2620 { "(bad)", { XX } },
2621 { "(bad)", { XX } },
2622 { "(bad)", { XX } },
2626 { "(bad)", { XX } },
2627 { "(bad)", { XX } },
2628 { MOD_TABLE (MOD_0F71_REG_2) },
2629 { "(bad)", { XX } },
2630 { MOD_TABLE (MOD_0F71_REG_4) },
2631 { "(bad)", { XX } },
2632 { MOD_TABLE (MOD_0F71_REG_6) },
2633 { "(bad)", { XX } },
2637 { "(bad)", { XX } },
2638 { "(bad)", { XX } },
2639 { MOD_TABLE (MOD_0F72_REG_2) },
2640 { "(bad)", { XX } },
2641 { MOD_TABLE (MOD_0F72_REG_4) },
2642 { "(bad)", { XX } },
2643 { MOD_TABLE (MOD_0F72_REG_6) },
2644 { "(bad)", { XX } },
2648 { "(bad)", { XX } },
2649 { "(bad)", { XX } },
2650 { MOD_TABLE (MOD_0F73_REG_2) },
2651 { MOD_TABLE (MOD_0F73_REG_3) },
2652 { "(bad)", { XX } },
2653 { "(bad)", { XX } },
2654 { MOD_TABLE (MOD_0F73_REG_6) },
2655 { MOD_TABLE (MOD_0F73_REG_7) },
2659 { "montmul", { { OP_0f07, 0 } } },
2660 { "xsha1", { { OP_0f07, 0 } } },
2661 { "xsha256", { { OP_0f07, 0 } } },
2662 { "(bad)", { { OP_0f07, 0 } } },
2663 { "(bad)", { { OP_0f07, 0 } } },
2664 { "(bad)", { { OP_0f07, 0 } } },
2665 { "(bad)", { { OP_0f07, 0 } } },
2666 { "(bad)", { { OP_0f07, 0 } } },
2670 { "xstore-rng", { { OP_0f07, 0 } } },
2671 { "xcrypt-ecb", { { OP_0f07, 0 } } },
2672 { "xcrypt-cbc", { { OP_0f07, 0 } } },
2673 { "xcrypt-ctr", { { OP_0f07, 0 } } },
2674 { "xcrypt-cfb", { { OP_0f07, 0 } } },
2675 { "xcrypt-ofb", { { OP_0f07, 0 } } },
2676 { "(bad)", { { OP_0f07, 0 } } },
2677 { "(bad)", { { OP_0f07, 0 } } },
2681 { MOD_TABLE (MOD_0FAE_REG_0) },
2682 { MOD_TABLE (MOD_0FAE_REG_1) },
2683 { MOD_TABLE (MOD_0FAE_REG_2) },
2684 { MOD_TABLE (MOD_0FAE_REG_3) },
2685 { MOD_TABLE (MOD_0FAE_REG_4) },
2686 { MOD_TABLE (MOD_0FAE_REG_5) },
2687 { MOD_TABLE (MOD_0FAE_REG_6) },
2688 { MOD_TABLE (MOD_0FAE_REG_7) },
2692 { "(bad)", { XX } },
2693 { "(bad)", { XX } },
2694 { "(bad)", { XX } },
2695 { "(bad)", { XX } },
2696 { "btQ", { Ev, Ib } },
2697 { "btsQ", { Ev, Ib } },
2698 { "btrQ", { Ev, Ib } },
2699 { "btcQ", { Ev, Ib } },
2703 { "(bad)", { XX } },
2704 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
2705 { "(bad)", { XX } },
2706 { "(bad)", { XX } },
2707 { "(bad)", { XX } },
2708 { "(bad)", { XX } },
2709 { MOD_TABLE (MOD_0FC7_REG_6) },
2710 { MOD_TABLE (MOD_0FC7_REG_7) },
2714 { "(bad)", { XX } },
2715 { "(bad)", { XX } },
2716 { MOD_TABLE (MOD_VEX_71_REG_2) },
2717 { "(bad)", { XX } },
2718 { MOD_TABLE (MOD_VEX_71_REG_4) },
2719 { "(bad)", { XX } },
2720 { MOD_TABLE (MOD_VEX_71_REG_6) },
2721 { "(bad)", { XX } },
2725 { "(bad)", { XX } },
2726 { "(bad)", { XX } },
2727 { MOD_TABLE (MOD_VEX_72_REG_2) },
2728 { "(bad)", { XX } },
2729 { MOD_TABLE (MOD_VEX_72_REG_4) },
2730 { "(bad)", { XX } },
2731 { MOD_TABLE (MOD_VEX_72_REG_6) },
2732 { "(bad)", { XX } },
2736 { "(bad)", { XX } },
2737 { "(bad)", { XX } },
2738 { MOD_TABLE (MOD_VEX_73_REG_2) },
2739 { MOD_TABLE (MOD_VEX_73_REG_3) },
2740 { "(bad)", { XX } },
2741 { "(bad)", { XX } },
2742 { MOD_TABLE (MOD_VEX_73_REG_6) },
2743 { MOD_TABLE (MOD_VEX_73_REG_7) },
2747 { "(bad)", { XX } },
2748 { "(bad)", { XX } },
2749 { MOD_TABLE (MOD_VEX_AE_REG_2) },
2750 { MOD_TABLE (MOD_VEX_AE_REG_3) },
2751 { "(bad)", { XX } },
2752 { "(bad)", { XX } },
2753 { "(bad)", { XX } },
2754 { "(bad)", { XX } },
2758 { "llwpcb", { { OP_LWPCB_E, 0 } } },
2759 { "slwpcb", { { OP_LWPCB_E, 0 } } },
2760 { "(bad)", { XX } },
2761 { "(bad)", { XX } },
2762 { "(bad)", { XX } },
2763 { "(bad)", { XX } },
2764 { "(bad)", { XX } },
2765 { "(bad)", { XX } },
2769 { "lwpins", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2770 { "lwpval", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2771 { "(bad)", { XX } },
2772 { "(bad)", { XX } },
2773 { "(bad)", { XX } },
2774 { "(bad)", { XX } },
2775 { "(bad)", { XX } },
2776 { "(bad)", { XX } },
2780 static const struct dis386 prefix_table[][4] = {
2783 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2784 { "pause", { XX } },
2785 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2786 { "(bad)", { XX } },
2791 { "movups", { XM, EXx } },
2792 { "movss", { XM, EXd } },
2793 { "movupd", { XM, EXx } },
2794 { "movsd", { XM, EXq } },
2799 { "movups", { EXxS, XM } },
2800 { "movss", { EXdS, XM } },
2801 { "movupd", { EXxS, XM } },
2802 { "movsd", { EXqS, XM } },
2807 { MOD_TABLE (MOD_0F12_PREFIX_0) },
2808 { "movsldup", { XM, EXx } },
2809 { "movlpd", { XM, EXq } },
2810 { "movddup", { XM, EXq } },
2815 { MOD_TABLE (MOD_0F16_PREFIX_0) },
2816 { "movshdup", { XM, EXx } },
2817 { "movhpd", { XM, EXq } },
2818 { "(bad)", { XX } },
2823 { "cvtpi2ps", { XM, EMCq } },
2824 { "cvtsi2ss%LQ", { XM, Ev } },
2825 { "cvtpi2pd", { XM, EMCq } },
2826 { "cvtsi2sd%LQ", { XM, Ev } },
2831 { MOD_TABLE (MOD_0F2B_PREFIX_0) },
2832 { MOD_TABLE (MOD_0F2B_PREFIX_1) },
2833 { MOD_TABLE (MOD_0F2B_PREFIX_2) },
2834 { MOD_TABLE (MOD_0F2B_PREFIX_3) },
2839 { "cvttps2pi", { MXC, EXq } },
2840 { "cvttss2siY", { Gv, EXd } },
2841 { "cvttpd2pi", { MXC, EXx } },
2842 { "cvttsd2siY", { Gv, EXq } },
2847 { "cvtps2pi", { MXC, EXq } },
2848 { "cvtss2siY", { Gv, EXd } },
2849 { "cvtpd2pi", { MXC, EXx } },
2850 { "cvtsd2siY", { Gv, EXq } },
2855 { "ucomiss",{ XM, EXd } },
2856 { "(bad)", { XX } },
2857 { "ucomisd",{ XM, EXq } },
2858 { "(bad)", { XX } },
2863 { "comiss", { XM, EXd } },
2864 { "(bad)", { XX } },
2865 { "comisd", { XM, EXq } },
2866 { "(bad)", { XX } },
2871 { "sqrtps", { XM, EXx } },
2872 { "sqrtss", { XM, EXd } },
2873 { "sqrtpd", { XM, EXx } },
2874 { "sqrtsd", { XM, EXq } },
2879 { "rsqrtps",{ XM, EXx } },
2880 { "rsqrtss",{ XM, EXd } },
2881 { "(bad)", { XX } },
2882 { "(bad)", { XX } },
2887 { "rcpps", { XM, EXx } },
2888 { "rcpss", { XM, EXd } },
2889 { "(bad)", { XX } },
2890 { "(bad)", { XX } },
2895 { "addps", { XM, EXx } },
2896 { "addss", { XM, EXd } },
2897 { "addpd", { XM, EXx } },
2898 { "addsd", { XM, EXq } },
2903 { "mulps", { XM, EXx } },
2904 { "mulss", { XM, EXd } },
2905 { "mulpd", { XM, EXx } },
2906 { "mulsd", { XM, EXq } },
2911 { "cvtps2pd", { XM, EXq } },
2912 { "cvtss2sd", { XM, EXd } },
2913 { "cvtpd2ps", { XM, EXx } },
2914 { "cvtsd2ss", { XM, EXq } },
2919 { "cvtdq2ps", { XM, EXx } },
2920 { "cvttps2dq", { XM, EXx } },
2921 { "cvtps2dq", { XM, EXx } },
2922 { "(bad)", { XX } },
2927 { "subps", { XM, EXx } },
2928 { "subss", { XM, EXd } },
2929 { "subpd", { XM, EXx } },
2930 { "subsd", { XM, EXq } },
2935 { "minps", { XM, EXx } },
2936 { "minss", { XM, EXd } },
2937 { "minpd", { XM, EXx } },
2938 { "minsd", { XM, EXq } },
2943 { "divps", { XM, EXx } },
2944 { "divss", { XM, EXd } },
2945 { "divpd", { XM, EXx } },
2946 { "divsd", { XM, EXq } },
2951 { "maxps", { XM, EXx } },
2952 { "maxss", { XM, EXd } },
2953 { "maxpd", { XM, EXx } },
2954 { "maxsd", { XM, EXq } },
2959 { "punpcklbw",{ MX, EMd } },
2960 { "(bad)", { XX } },
2961 { "punpcklbw",{ MX, EMx } },
2962 { "(bad)", { XX } },
2967 { "punpcklwd",{ MX, EMd } },
2968 { "(bad)", { XX } },
2969 { "punpcklwd",{ MX, EMx } },
2970 { "(bad)", { XX } },
2975 { "punpckldq",{ MX, EMd } },
2976 { "(bad)", { XX } },
2977 { "punpckldq",{ MX, EMx } },
2978 { "(bad)", { XX } },
2983 { "(bad)", { XX } },
2984 { "(bad)", { XX } },
2985 { "punpcklqdq", { XM, EXx } },
2986 { "(bad)", { XX } },
2991 { "(bad)", { XX } },
2992 { "(bad)", { XX } },
2993 { "punpckhqdq", { XM, EXx } },
2994 { "(bad)", { XX } },
2999 { "movq", { MX, EM } },
3000 { "movdqu", { XM, EXx } },
3001 { "movdqa", { XM, EXx } },
3002 { "(bad)", { XX } },
3007 { "pshufw", { MX, EM, Ib } },
3008 { "pshufhw",{ XM, EXx, Ib } },
3009 { "pshufd", { XM, EXx, Ib } },
3010 { "pshuflw",{ XM, EXx, Ib } },
3013 /* PREFIX_0F73_REG_3 */
3015 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "psrldq", { XS, Ib } },
3018 { "(bad)", { XX } },
3021 /* PREFIX_0F73_REG_7 */
3023 { "(bad)", { XX } },
3024 { "(bad)", { XX } },
3025 { "pslldq", { XS, Ib } },
3026 { "(bad)", { XX } },
3031 {"vmread", { Em, Gm } },
3033 {"extrq", { XS, Ib, Ib } },
3034 {"insertq", { XM, XS, Ib, Ib } },
3039 {"vmwrite", { Gm, Em } },
3041 {"extrq", { XM, XS } },
3042 {"insertq", { XM, XS } },
3047 { "(bad)", { XX } },
3048 { "(bad)", { XX } },
3049 { "haddpd", { XM, EXx } },
3050 { "haddps", { XM, EXx } },
3055 { "(bad)", { XX } },
3056 { "(bad)", { XX } },
3057 { "hsubpd", { XM, EXx } },
3058 { "hsubps", { XM, EXx } },
3063 { "movK", { Edq, MX } },
3064 { "movq", { XM, EXq } },
3065 { "movK", { Edq, XM } },
3066 { "(bad)", { XX } },
3071 { "movq", { EMS, MX } },
3072 { "movdqu", { EXxS, XM } },
3073 { "movdqa", { EXxS, XM } },
3074 { "(bad)", { XX } },
3079 { "(bad)", { XX } },
3080 { "popcntS", { Gv, Ev } },
3081 { "(bad)", { XX } },
3082 { "(bad)", { XX } },
3087 { "bsrS", { Gv, Ev } },
3088 { "lzcntS", { Gv, Ev } },
3089 { "bsrS", { Gv, Ev } },
3090 { "(bad)", { XX } },
3095 { "cmpps", { XM, EXx, CMP } },
3096 { "cmpss", { XM, EXd, CMP } },
3097 { "cmppd", { XM, EXx, CMP } },
3098 { "cmpsd", { XM, EXq, CMP } },
3103 { "movntiS", { Ma, Gv } },
3104 { "(bad)", { XX } },
3105 { "(bad)", { XX } },
3106 { "(bad)", { XX } },
3109 /* PREFIX_0FC7_REG_6 */
3111 { "vmptrld",{ Mq } },
3112 { "vmxon", { Mq } },
3113 { "vmclear",{ Mq } },
3114 { "(bad)", { XX } },
3119 { "(bad)", { XX } },
3120 { "(bad)", { XX } },
3121 { "addsubpd", { XM, EXx } },
3122 { "addsubps", { XM, EXx } },
3127 { "(bad)", { XX } },
3128 { "movq2dq",{ XM, MS } },
3129 { "movq", { EXqS, XM } },
3130 { "movdq2q",{ MX, XS } },
3135 { "(bad)", { XX } },
3136 { "cvtdq2pd", { XM, EXq } },
3137 { "cvttpd2dq", { XM, EXx } },
3138 { "cvtpd2dq", { XM, EXx } },
3143 { "movntq", { Mq, MX } },
3144 { "(bad)", { XX } },
3145 { MOD_TABLE (MOD_0FE7_PREFIX_2) },
3146 { "(bad)", { XX } },
3151 { "(bad)", { XX } },
3152 { "(bad)", { XX } },
3153 { "(bad)", { XX } },
3154 { MOD_TABLE (MOD_0FF0_PREFIX_3) },
3159 { "maskmovq", { MX, MS } },
3160 { "(bad)", { XX } },
3161 { "maskmovdqu", { XM, XS } },
3162 { "(bad)", { XX } },
3167 { "(bad)", { XX } },
3168 { "(bad)", { XX } },
3169 { "pblendvb", { XM, EXx, XMM0 } },
3170 { "(bad)", { XX } },
3175 { "(bad)", { XX } },
3176 { "(bad)", { XX } },
3177 { "blendvps", { XM, EXx, XMM0 } },
3178 { "(bad)", { XX } },
3183 { "(bad)", { XX } },
3184 { "(bad)", { XX } },
3185 { "blendvpd", { XM, EXx, XMM0 } },
3186 { "(bad)", { XX } },
3191 { "(bad)", { XX } },
3192 { "(bad)", { XX } },
3193 { "ptest", { XM, EXx } },
3194 { "(bad)", { XX } },
3199 { "(bad)", { XX } },
3200 { "(bad)", { XX } },
3201 { "pmovsxbw", { XM, EXq } },
3202 { "(bad)", { XX } },
3207 { "(bad)", { XX } },
3208 { "(bad)", { XX } },
3209 { "pmovsxbd", { XM, EXd } },
3210 { "(bad)", { XX } },
3215 { "(bad)", { XX } },
3216 { "(bad)", { XX } },
3217 { "pmovsxbq", { XM, EXw } },
3218 { "(bad)", { XX } },
3223 { "(bad)", { XX } },
3224 { "(bad)", { XX } },
3225 { "pmovsxwd", { XM, EXq } },
3226 { "(bad)", { XX } },
3231 { "(bad)", { XX } },
3232 { "(bad)", { XX } },
3233 { "pmovsxwq", { XM, EXd } },
3234 { "(bad)", { XX } },
3239 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "pmovsxdq", { XM, EXq } },
3242 { "(bad)", { XX } },
3247 { "(bad)", { XX } },
3248 { "(bad)", { XX } },
3249 { "pmuldq", { XM, EXx } },
3250 { "(bad)", { XX } },
3255 { "(bad)", { XX } },
3256 { "(bad)", { XX } },
3257 { "pcmpeqq", { XM, EXx } },
3258 { "(bad)", { XX } },
3263 { "(bad)", { XX } },
3264 { "(bad)", { XX } },
3265 { MOD_TABLE (MOD_0F382A_PREFIX_2) },
3266 { "(bad)", { XX } },
3271 { "(bad)", { XX } },
3272 { "(bad)", { XX } },
3273 { "packusdw", { XM, EXx } },
3274 { "(bad)", { XX } },
3279 { "(bad)", { XX } },
3280 { "(bad)", { XX } },
3281 { "pmovzxbw", { XM, EXq } },
3282 { "(bad)", { XX } },
3287 { "(bad)", { XX } },
3288 { "(bad)", { XX } },
3289 { "pmovzxbd", { XM, EXd } },
3290 { "(bad)", { XX } },
3295 { "(bad)", { XX } },
3296 { "(bad)", { XX } },
3297 { "pmovzxbq", { XM, EXw } },
3298 { "(bad)", { XX } },
3303 { "(bad)", { XX } },
3304 { "(bad)", { XX } },
3305 { "pmovzxwd", { XM, EXq } },
3306 { "(bad)", { XX } },
3311 { "(bad)", { XX } },
3312 { "(bad)", { XX } },
3313 { "pmovzxwq", { XM, EXd } },
3314 { "(bad)", { XX } },
3319 { "(bad)", { XX } },
3320 { "(bad)", { XX } },
3321 { "pmovzxdq", { XM, EXq } },
3322 { "(bad)", { XX } },
3327 { "(bad)", { XX } },
3328 { "(bad)", { XX } },
3329 { "pcmpgtq", { XM, EXx } },
3330 { "(bad)", { XX } },
3335 { "(bad)", { XX } },
3336 { "(bad)", { XX } },
3337 { "pminsb", { XM, EXx } },
3338 { "(bad)", { XX } },
3343 { "(bad)", { XX } },
3344 { "(bad)", { XX } },
3345 { "pminsd", { XM, EXx } },
3346 { "(bad)", { XX } },
3351 { "(bad)", { XX } },
3352 { "(bad)", { XX } },
3353 { "pminuw", { XM, EXx } },
3354 { "(bad)", { XX } },
3359 { "(bad)", { XX } },
3360 { "(bad)", { XX } },
3361 { "pminud", { XM, EXx } },
3362 { "(bad)", { XX } },
3367 { "(bad)", { XX } },
3368 { "(bad)", { XX } },
3369 { "pmaxsb", { XM, EXx } },
3370 { "(bad)", { XX } },
3375 { "(bad)", { XX } },
3376 { "(bad)", { XX } },
3377 { "pmaxsd", { XM, EXx } },
3378 { "(bad)", { XX } },
3383 { "(bad)", { XX } },
3384 { "(bad)", { XX } },
3385 { "pmaxuw", { XM, EXx } },
3386 { "(bad)", { XX } },
3391 { "(bad)", { XX } },
3392 { "(bad)", { XX } },
3393 { "pmaxud", { XM, EXx } },
3394 { "(bad)", { XX } },
3399 { "(bad)", { XX } },
3400 { "(bad)", { XX } },
3401 { "pmulld", { XM, EXx } },
3402 { "(bad)", { XX } },
3407 { "(bad)", { XX } },
3408 { "(bad)", { XX } },
3409 { "phminposuw", { XM, EXx } },
3410 { "(bad)", { XX } },
3415 { "(bad)", { XX } },
3416 { "(bad)", { XX } },
3417 { "invept", { Gm, Mo } },
3418 { "(bad)", { XX } },
3423 { "(bad)", { XX } },
3424 { "(bad)", { XX } },
3425 { "invvpid", { Gm, Mo } },
3426 { "(bad)", { XX } },
3431 { "(bad)", { XX } },
3432 { "(bad)", { XX } },
3433 { "aesimc", { XM, EXx } },
3434 { "(bad)", { XX } },
3439 { "(bad)", { XX } },
3440 { "(bad)", { XX } },
3441 { "aesenc", { XM, EXx } },
3442 { "(bad)", { XX } },
3447 { "(bad)", { XX } },
3448 { "(bad)", { XX } },
3449 { "aesenclast", { XM, EXx } },
3450 { "(bad)", { XX } },
3455 { "(bad)", { XX } },
3456 { "(bad)", { XX } },
3457 { "aesdec", { XM, EXx } },
3458 { "(bad)", { XX } },
3463 { "(bad)", { XX } },
3464 { "(bad)", { XX } },
3465 { "aesdeclast", { XM, EXx } },
3466 { "(bad)", { XX } },
3471 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3472 { "(bad)", { XX } },
3473 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3474 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
3479 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3480 { "(bad)", { XX } },
3481 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3482 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
3487 { "(bad)", { XX } },
3488 { "(bad)", { XX } },
3489 { "roundps", { XM, EXx, Ib } },
3490 { "(bad)", { XX } },
3495 { "(bad)", { XX } },
3496 { "(bad)", { XX } },
3497 { "roundpd", { XM, EXx, Ib } },
3498 { "(bad)", { XX } },
3503 { "(bad)", { XX } },
3504 { "(bad)", { XX } },
3505 { "roundss", { XM, EXd, Ib } },
3506 { "(bad)", { XX } },
3511 { "(bad)", { XX } },
3512 { "(bad)", { XX } },
3513 { "roundsd", { XM, EXq, Ib } },
3514 { "(bad)", { XX } },
3519 { "(bad)", { XX } },
3520 { "(bad)", { XX } },
3521 { "blendps", { XM, EXx, Ib } },
3522 { "(bad)", { XX } },
3527 { "(bad)", { XX } },
3528 { "(bad)", { XX } },
3529 { "blendpd", { XM, EXx, Ib } },
3530 { "(bad)", { XX } },
3535 { "(bad)", { XX } },
3536 { "(bad)", { XX } },
3537 { "pblendw", { XM, EXx, Ib } },
3538 { "(bad)", { XX } },
3543 { "(bad)", { XX } },
3544 { "(bad)", { XX } },
3545 { "pextrb", { Edqb, XM, Ib } },
3546 { "(bad)", { XX } },
3551 { "(bad)", { XX } },
3552 { "(bad)", { XX } },
3553 { "pextrw", { Edqw, XM, Ib } },
3554 { "(bad)", { XX } },
3559 { "(bad)", { XX } },
3560 { "(bad)", { XX } },
3561 { "pextrK", { Edq, XM, Ib } },
3562 { "(bad)", { XX } },
3567 { "(bad)", { XX } },
3568 { "(bad)", { XX } },
3569 { "extractps", { Edqd, XM, Ib } },
3570 { "(bad)", { XX } },
3575 { "(bad)", { XX } },
3576 { "(bad)", { XX } },
3577 { "pinsrb", { XM, Edqb, Ib } },
3578 { "(bad)", { XX } },
3583 { "(bad)", { XX } },
3584 { "(bad)", { XX } },
3585 { "insertps", { XM, EXd, Ib } },
3586 { "(bad)", { XX } },
3591 { "(bad)", { XX } },
3592 { "(bad)", { XX } },
3593 { "pinsrK", { XM, Edq, Ib } },
3594 { "(bad)", { XX } },
3599 { "(bad)", { XX } },
3600 { "(bad)", { XX } },
3601 { "dpps", { XM, EXx, Ib } },
3602 { "(bad)", { XX } },
3607 { "(bad)", { XX } },
3608 { "(bad)", { XX } },
3609 { "dppd", { XM, EXx, Ib } },
3610 { "(bad)", { XX } },
3615 { "(bad)", { XX } },
3616 { "(bad)", { XX } },
3617 { "mpsadbw", { XM, EXx, Ib } },
3618 { "(bad)", { XX } },
3623 { "(bad)", { XX } },
3624 { "(bad)", { XX } },
3625 { "pclmulqdq", { XM, EXx, PCLMUL } },
3626 { "(bad)", { XX } },
3631 { "(bad)", { XX } },
3632 { "(bad)", { XX } },
3633 { "pcmpestrm", { XM, EXx, Ib } },
3634 { "(bad)", { XX } },
3639 { "(bad)", { XX } },
3640 { "(bad)", { XX } },
3641 { "pcmpestri", { XM, EXx, Ib } },
3642 { "(bad)", { XX } },
3647 { "(bad)", { XX } },
3648 { "(bad)", { XX } },
3649 { "pcmpistrm", { XM, EXx, Ib } },
3650 { "(bad)", { XX } },
3655 { "(bad)", { XX } },
3656 { "(bad)", { XX } },
3657 { "pcmpistri", { XM, EXx, Ib } },
3658 { "(bad)", { XX } },
3663 { "(bad)", { XX } },
3664 { "(bad)", { XX } },
3665 { "aeskeygenassist", { XM, EXx, Ib } },
3666 { "(bad)", { XX } },
3671 { VEX_W_TABLE (VEX_W_10_P_0) },
3672 { VEX_LEN_TABLE (VEX_LEN_10_P_1) },
3673 { VEX_W_TABLE (VEX_W_10_P_2) },
3674 { VEX_LEN_TABLE (VEX_LEN_10_P_3) },
3679 { VEX_W_TABLE (VEX_W_11_P_0) },
3680 { VEX_LEN_TABLE (VEX_LEN_11_P_1) },
3681 { VEX_W_TABLE (VEX_W_11_P_2) },
3682 { VEX_LEN_TABLE (VEX_LEN_11_P_3) },
3687 { MOD_TABLE (MOD_VEX_12_PREFIX_0) },
3688 { VEX_W_TABLE (VEX_W_12_P_1) },
3689 { VEX_LEN_TABLE (VEX_LEN_12_P_2) },
3690 { VEX_W_TABLE (VEX_W_12_P_3) },
3695 { MOD_TABLE (MOD_VEX_16_PREFIX_0) },
3696 { VEX_W_TABLE (VEX_W_16_P_1) },
3697 { VEX_LEN_TABLE (VEX_LEN_16_P_2) },
3698 { "(bad)", { XX } },
3703 { "(bad)", { XX } },
3704 { VEX_LEN_TABLE (VEX_LEN_2A_P_1) },
3705 { "(bad)", { XX } },
3706 { VEX_LEN_TABLE (VEX_LEN_2A_P_3) },
3711 { "(bad)", { XX } },
3712 { VEX_LEN_TABLE (VEX_LEN_2C_P_1) },
3713 { "(bad)", { XX } },
3714 { VEX_LEN_TABLE (VEX_LEN_2C_P_3) },
3719 { "(bad)", { XX } },
3720 { VEX_LEN_TABLE (VEX_LEN_2D_P_1) },
3721 { "(bad)", { XX } },
3722 { VEX_LEN_TABLE (VEX_LEN_2D_P_3) },
3727 { VEX_LEN_TABLE (VEX_LEN_2E_P_0) },
3728 { "(bad)", { XX } },
3729 { VEX_LEN_TABLE (VEX_LEN_2E_P_2) },
3730 { "(bad)", { XX } },
3735 { VEX_LEN_TABLE (VEX_LEN_2F_P_0) },
3736 { "(bad)", { XX } },
3737 { VEX_LEN_TABLE (VEX_LEN_2F_P_2) },
3738 { "(bad)", { XX } },
3743 { VEX_W_TABLE (VEX_W_51_P_0) },
3744 { VEX_LEN_TABLE (VEX_LEN_51_P_1) },
3745 { VEX_W_TABLE (VEX_W_51_P_2) },
3746 { VEX_LEN_TABLE (VEX_LEN_51_P_3) },
3751 { VEX_W_TABLE (VEX_W_52_P_0) },
3752 { VEX_LEN_TABLE (VEX_LEN_52_P_1) },
3753 { "(bad)", { XX } },
3754 { "(bad)", { XX } },
3759 { VEX_W_TABLE (VEX_W_53_P_0) },
3760 { VEX_LEN_TABLE (VEX_LEN_53_P_1) },
3761 { "(bad)", { XX } },
3762 { "(bad)", { XX } },
3767 { VEX_W_TABLE (VEX_W_58_P_0) },
3768 { VEX_LEN_TABLE (VEX_LEN_58_P_1) },
3769 { VEX_W_TABLE (VEX_W_58_P_2) },
3770 { VEX_LEN_TABLE (VEX_LEN_58_P_3) },
3775 { VEX_W_TABLE (VEX_W_59_P_0) },
3776 { VEX_LEN_TABLE (VEX_LEN_59_P_1) },
3777 { VEX_W_TABLE (VEX_W_59_P_2) },
3778 { VEX_LEN_TABLE (VEX_LEN_59_P_3) },
3783 { VEX_W_TABLE (VEX_W_5A_P_0) },
3784 { VEX_LEN_TABLE (VEX_LEN_5A_P_1) },
3785 { "vcvtpd2ps%XY", { XMM, EXx } },
3786 { VEX_LEN_TABLE (VEX_LEN_5A_P_3) },
3791 { VEX_W_TABLE (VEX_W_5B_P_0) },
3792 { VEX_W_TABLE (VEX_W_5B_P_1) },
3793 { VEX_W_TABLE (VEX_W_5B_P_2) },
3794 { "(bad)", { XX } },
3799 { VEX_W_TABLE (VEX_W_5C_P_0) },
3800 { VEX_LEN_TABLE (VEX_LEN_5C_P_1) },
3801 { VEX_W_TABLE (VEX_W_5C_P_2) },
3802 { VEX_LEN_TABLE (VEX_LEN_5C_P_3) },
3807 { VEX_W_TABLE (VEX_W_5D_P_0) },
3808 { VEX_LEN_TABLE (VEX_LEN_5D_P_1) },
3809 { VEX_W_TABLE (VEX_W_5D_P_2) },
3810 { VEX_LEN_TABLE (VEX_LEN_5D_P_3) },
3815 { VEX_W_TABLE (VEX_W_5E_P_0) },
3816 { VEX_LEN_TABLE (VEX_LEN_5E_P_1) },
3817 { VEX_W_TABLE (VEX_W_5E_P_2) },
3818 { VEX_LEN_TABLE (VEX_LEN_5E_P_3) },
3823 { VEX_W_TABLE (VEX_W_5F_P_0) },
3824 { VEX_LEN_TABLE (VEX_LEN_5F_P_1) },
3825 { VEX_W_TABLE (VEX_W_5F_P_2) },
3826 { VEX_LEN_TABLE (VEX_LEN_5F_P_3) },
3831 { "(bad)", { XX } },
3832 { "(bad)", { XX } },
3833 { VEX_LEN_TABLE (VEX_LEN_60_P_2) },
3834 { "(bad)", { XX } },
3839 { "(bad)", { XX } },
3840 { "(bad)", { XX } },
3841 { VEX_LEN_TABLE (VEX_LEN_61_P_2) },
3842 { "(bad)", { XX } },
3847 { "(bad)", { XX } },
3848 { "(bad)", { XX } },
3849 { VEX_LEN_TABLE (VEX_LEN_62_P_2) },
3850 { "(bad)", { XX } },
3855 { "(bad)", { XX } },
3856 { "(bad)", { XX } },
3857 { VEX_LEN_TABLE (VEX_LEN_63_P_2) },
3858 { "(bad)", { XX } },
3863 { "(bad)", { XX } },
3864 { "(bad)", { XX } },
3865 { VEX_LEN_TABLE (VEX_LEN_64_P_2) },
3866 { "(bad)", { XX } },
3871 { "(bad)", { XX } },
3872 { "(bad)", { XX } },
3873 { VEX_LEN_TABLE (VEX_LEN_65_P_2) },
3874 { "(bad)", { XX } },
3879 { "(bad)", { XX } },
3880 { "(bad)", { XX } },
3881 { VEX_LEN_TABLE (VEX_LEN_66_P_2) },
3882 { "(bad)", { XX } },
3887 { "(bad)", { XX } },
3888 { "(bad)", { XX } },
3889 { VEX_LEN_TABLE (VEX_LEN_67_P_2) },
3890 { "(bad)", { XX } },
3895 { "(bad)", { XX } },
3896 { "(bad)", { XX } },
3897 { VEX_LEN_TABLE (VEX_LEN_68_P_2) },
3898 { "(bad)", { XX } },
3903 { "(bad)", { XX } },
3904 { "(bad)", { XX } },
3905 { VEX_LEN_TABLE (VEX_LEN_69_P_2) },
3906 { "(bad)", { XX } },
3911 { "(bad)", { XX } },
3912 { "(bad)", { XX } },
3913 { VEX_LEN_TABLE (VEX_LEN_6A_P_2) },
3914 { "(bad)", { XX } },
3919 { "(bad)", { XX } },
3920 { "(bad)", { XX } },
3921 { VEX_LEN_TABLE (VEX_LEN_6B_P_2) },
3922 { "(bad)", { XX } },
3927 { "(bad)", { XX } },
3928 { "(bad)", { XX } },
3929 { VEX_LEN_TABLE (VEX_LEN_6C_P_2) },
3930 { "(bad)", { XX } },
3935 { "(bad)", { XX } },
3936 { "(bad)", { XX } },
3937 { VEX_LEN_TABLE (VEX_LEN_6D_P_2) },
3938 { "(bad)", { XX } },
3943 { "(bad)", { XX } },
3944 { "(bad)", { XX } },
3945 { VEX_LEN_TABLE (VEX_LEN_6E_P_2) },
3946 { "(bad)", { XX } },
3951 { "(bad)", { XX } },
3952 { VEX_W_TABLE (VEX_W_6F_P_1) },
3953 { VEX_W_TABLE (VEX_W_6F_P_2) },
3954 { "(bad)", { XX } },
3959 { "(bad)", { XX } },
3960 { VEX_LEN_TABLE (VEX_LEN_70_P_1) },
3961 { VEX_LEN_TABLE (VEX_LEN_70_P_2) },
3962 { VEX_LEN_TABLE (VEX_LEN_70_P_3) },
3965 /* PREFIX_VEX_71_REG_2 */
3967 { "(bad)", { XX } },
3968 { "(bad)", { XX } },
3969 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2) },
3970 { "(bad)", { XX } },
3973 /* PREFIX_VEX_71_REG_4 */
3975 { "(bad)", { XX } },
3976 { "(bad)", { XX } },
3977 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2) },
3978 { "(bad)", { XX } },
3981 /* PREFIX_VEX_71_REG_6 */
3983 { "(bad)", { XX } },
3984 { "(bad)", { XX } },
3985 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2) },
3986 { "(bad)", { XX } },
3989 /* PREFIX_VEX_72_REG_2 */
3991 { "(bad)", { XX } },
3992 { "(bad)", { XX } },
3993 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2) },
3994 { "(bad)", { XX } },
3997 /* PREFIX_VEX_72_REG_4 */
3999 { "(bad)", { XX } },
4000 { "(bad)", { XX } },
4001 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2) },
4002 { "(bad)", { XX } },
4005 /* PREFIX_VEX_72_REG_6 */
4007 { "(bad)", { XX } },
4008 { "(bad)", { XX } },
4009 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2) },
4010 { "(bad)", { XX } },
4013 /* PREFIX_VEX_73_REG_2 */
4015 { "(bad)", { XX } },
4016 { "(bad)", { XX } },
4017 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2) },
4018 { "(bad)", { XX } },
4021 /* PREFIX_VEX_73_REG_3 */
4023 { "(bad)", { XX } },
4024 { "(bad)", { XX } },
4025 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2) },
4026 { "(bad)", { XX } },
4029 /* PREFIX_VEX_73_REG_6 */
4031 { "(bad)", { XX } },
4032 { "(bad)", { XX } },
4033 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2) },
4034 { "(bad)", { XX } },
4037 /* PREFIX_VEX_73_REG_7 */
4039 { "(bad)", { XX } },
4040 { "(bad)", { XX } },
4041 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2) },
4042 { "(bad)", { XX } },
4047 { "(bad)", { XX } },
4048 { "(bad)", { XX } },
4049 { VEX_LEN_TABLE (VEX_LEN_74_P_2) },
4050 { "(bad)", { XX } },
4055 { "(bad)", { XX } },
4056 { "(bad)", { XX } },
4057 { VEX_LEN_TABLE (VEX_LEN_75_P_2) },
4058 { "(bad)", { XX } },
4063 { "(bad)", { XX } },
4064 { "(bad)", { XX } },
4065 { VEX_LEN_TABLE (VEX_LEN_76_P_2) },
4066 { "(bad)", { XX } },
4071 { VEX_W_TABLE (VEX_W_77_P_0) },
4072 { "(bad)", { XX } },
4073 { "(bad)", { XX } },
4074 { "(bad)", { XX } },
4079 { "(bad)", { XX } },
4080 { "(bad)", { XX } },
4081 { VEX_W_TABLE (VEX_W_7C_P_2) },
4082 { VEX_W_TABLE (VEX_W_7C_P_3) },
4087 { "(bad)", { XX } },
4088 { "(bad)", { XX } },
4089 { VEX_W_TABLE (VEX_W_7D_P_2) },
4090 { VEX_W_TABLE (VEX_W_7D_P_3) },
4095 { "(bad)", { XX } },
4096 { VEX_LEN_TABLE (VEX_LEN_7E_P_1) },
4097 { VEX_LEN_TABLE (VEX_LEN_7E_P_2) },
4098 { "(bad)", { XX } },
4103 { "(bad)", { XX } },
4104 { VEX_W_TABLE (VEX_W_7F_P_1) },
4105 { VEX_W_TABLE (VEX_W_7F_P_2) },
4106 { "(bad)", { XX } },
4111 { VEX_W_TABLE (VEX_W_C2_P_0) },
4112 { VEX_LEN_TABLE (VEX_LEN_C2_P_1) },
4113 { VEX_W_TABLE (VEX_W_C2_P_2) },
4114 { VEX_LEN_TABLE (VEX_LEN_C2_P_3) },
4119 { "(bad)", { XX } },
4120 { "(bad)", { XX } },
4121 { VEX_LEN_TABLE (VEX_LEN_C4_P_2) },
4122 { "(bad)", { XX } },
4127 { "(bad)", { XX } },
4128 { "(bad)", { XX } },
4129 { VEX_LEN_TABLE (VEX_LEN_C5_P_2) },
4130 { "(bad)", { XX } },
4135 { "(bad)", { XX } },
4136 { "(bad)", { XX } },
4137 { VEX_W_TABLE (VEX_W_D0_P_2) },
4138 { VEX_W_TABLE (VEX_W_D0_P_3) },
4143 { "(bad)", { XX } },
4144 { "(bad)", { XX } },
4145 { VEX_LEN_TABLE (VEX_LEN_D1_P_2) },
4146 { "(bad)", { XX } },
4151 { "(bad)", { XX } },
4152 { "(bad)", { XX } },
4153 { VEX_LEN_TABLE (VEX_LEN_D2_P_2) },
4154 { "(bad)", { XX } },
4159 { "(bad)", { XX } },
4160 { "(bad)", { XX } },
4161 { VEX_LEN_TABLE (VEX_LEN_D3_P_2) },
4162 { "(bad)", { XX } },
4167 { "(bad)", { XX } },
4168 { "(bad)", { XX } },
4169 { VEX_LEN_TABLE (VEX_LEN_D4_P_2) },
4170 { "(bad)", { XX } },
4175 { "(bad)", { XX } },
4176 { "(bad)", { XX } },
4177 { VEX_LEN_TABLE (VEX_LEN_D5_P_2) },
4178 { "(bad)", { XX } },
4183 { "(bad)", { XX } },
4184 { "(bad)", { XX } },
4185 { VEX_LEN_TABLE (VEX_LEN_D6_P_2) },
4186 { "(bad)", { XX } },
4191 { "(bad)", { XX } },
4192 { "(bad)", { XX } },
4193 { MOD_TABLE (MOD_VEX_D7_PREFIX_2) },
4194 { "(bad)", { XX } },
4199 { "(bad)", { XX } },
4200 { "(bad)", { XX } },
4201 { VEX_LEN_TABLE (VEX_LEN_D8_P_2) },
4202 { "(bad)", { XX } },
4207 { "(bad)", { XX } },
4208 { "(bad)", { XX } },
4209 { VEX_LEN_TABLE (VEX_LEN_D9_P_2) },
4210 { "(bad)", { XX } },
4215 { "(bad)", { XX } },
4216 { "(bad)", { XX } },
4217 { VEX_LEN_TABLE (VEX_LEN_DA_P_2) },
4218 { "(bad)", { XX } },
4223 { "(bad)", { XX } },
4224 { "(bad)", { XX } },
4225 { VEX_LEN_TABLE (VEX_LEN_DB_P_2) },
4226 { "(bad)", { XX } },
4231 { "(bad)", { XX } },
4232 { "(bad)", { XX } },
4233 { VEX_LEN_TABLE (VEX_LEN_DC_P_2) },
4234 { "(bad)", { XX } },
4239 { "(bad)", { XX } },
4240 { "(bad)", { XX } },
4241 { VEX_LEN_TABLE (VEX_LEN_DD_P_2) },
4242 { "(bad)", { XX } },
4247 { "(bad)", { XX } },
4248 { "(bad)", { XX } },
4249 { VEX_LEN_TABLE (VEX_LEN_DE_P_2) },
4250 { "(bad)", { XX } },
4255 { "(bad)", { XX } },
4256 { "(bad)", { XX } },
4257 { VEX_LEN_TABLE (VEX_LEN_DF_P_2) },
4258 { "(bad)", { XX } },
4263 { "(bad)", { XX } },
4264 { "(bad)", { XX } },
4265 { VEX_LEN_TABLE (VEX_LEN_E0_P_2) },
4266 { "(bad)", { XX } },
4271 { "(bad)", { XX } },
4272 { "(bad)", { XX } },
4273 { VEX_LEN_TABLE (VEX_LEN_E1_P_2) },
4274 { "(bad)", { XX } },
4279 { "(bad)", { XX } },
4280 { "(bad)", { XX } },
4281 { VEX_LEN_TABLE (VEX_LEN_E2_P_2) },
4282 { "(bad)", { XX } },
4287 { "(bad)", { XX } },
4288 { "(bad)", { XX } },
4289 { VEX_LEN_TABLE (VEX_LEN_E3_P_2) },
4290 { "(bad)", { XX } },
4295 { "(bad)", { XX } },
4296 { "(bad)", { XX } },
4297 { VEX_LEN_TABLE (VEX_LEN_E4_P_2) },
4298 { "(bad)", { XX } },
4303 { "(bad)", { XX } },
4304 { "(bad)", { XX } },
4305 { VEX_LEN_TABLE (VEX_LEN_E5_P_2) },
4306 { "(bad)", { XX } },
4311 { "(bad)", { XX } },
4312 { VEX_W_TABLE (VEX_W_E6_P_1) },
4313 { VEX_W_TABLE (VEX_W_E6_P_2) },
4314 { VEX_W_TABLE (VEX_W_E6_P_3) },
4319 { "(bad)", { XX } },
4320 { "(bad)", { XX } },
4321 { MOD_TABLE (MOD_VEX_E7_PREFIX_2) },
4322 { "(bad)", { XX } },
4327 { "(bad)", { XX } },
4328 { "(bad)", { XX } },
4329 { VEX_LEN_TABLE (VEX_LEN_E8_P_2) },
4330 { "(bad)", { XX } },
4335 { "(bad)", { XX } },
4336 { "(bad)", { XX } },
4337 { VEX_LEN_TABLE (VEX_LEN_E9_P_2) },
4338 { "(bad)", { XX } },
4343 { "(bad)", { XX } },
4344 { "(bad)", { XX } },
4345 { VEX_LEN_TABLE (VEX_LEN_EA_P_2) },
4346 { "(bad)", { XX } },
4351 { "(bad)", { XX } },
4352 { "(bad)", { XX } },
4353 { VEX_LEN_TABLE (VEX_LEN_EB_P_2) },
4354 { "(bad)", { XX } },
4359 { "(bad)", { XX } },
4360 { "(bad)", { XX } },
4361 { VEX_LEN_TABLE (VEX_LEN_EC_P_2) },
4362 { "(bad)", { XX } },
4367 { "(bad)", { XX } },
4368 { "(bad)", { XX } },
4369 { VEX_LEN_TABLE (VEX_LEN_ED_P_2) },
4370 { "(bad)", { XX } },
4375 { "(bad)", { XX } },
4376 { "(bad)", { XX } },
4377 { VEX_LEN_TABLE (VEX_LEN_EE_P_2) },
4378 { "(bad)", { XX } },
4383 { "(bad)", { XX } },
4384 { "(bad)", { XX } },
4385 { VEX_LEN_TABLE (VEX_LEN_EF_P_2) },
4386 { "(bad)", { XX } },
4391 { "(bad)", { XX } },
4392 { "(bad)", { XX } },
4393 { "(bad)", { XX } },
4394 { MOD_TABLE (MOD_VEX_F0_PREFIX_3) },
4399 { "(bad)", { XX } },
4400 { "(bad)", { XX } },
4401 { VEX_LEN_TABLE (VEX_LEN_F1_P_2) },
4402 { "(bad)", { XX } },
4407 { "(bad)", { XX } },
4408 { "(bad)", { XX } },
4409 { VEX_LEN_TABLE (VEX_LEN_F2_P_2) },
4410 { "(bad)", { XX } },
4415 { "(bad)", { XX } },
4416 { "(bad)", { XX } },
4417 { VEX_LEN_TABLE (VEX_LEN_F3_P_2) },
4418 { "(bad)", { XX } },
4423 { "(bad)", { XX } },
4424 { "(bad)", { XX } },
4425 { VEX_LEN_TABLE (VEX_LEN_F4_P_2) },
4426 { "(bad)", { XX } },
4431 { "(bad)", { XX } },
4432 { "(bad)", { XX } },
4433 { VEX_LEN_TABLE (VEX_LEN_F5_P_2) },
4434 { "(bad)", { XX } },
4439 { "(bad)", { XX } },
4440 { "(bad)", { XX } },
4441 { VEX_LEN_TABLE (VEX_LEN_F6_P_2) },
4442 { "(bad)", { XX } },
4447 { "(bad)", { XX } },
4448 { "(bad)", { XX } },
4449 { VEX_LEN_TABLE (VEX_LEN_F7_P_2) },
4450 { "(bad)", { XX } },
4455 { "(bad)", { XX } },
4456 { "(bad)", { XX } },
4457 { VEX_LEN_TABLE (VEX_LEN_F8_P_2) },
4458 { "(bad)", { XX } },
4463 { "(bad)", { XX } },
4464 { "(bad)", { XX } },
4465 { VEX_LEN_TABLE (VEX_LEN_F9_P_2) },
4466 { "(bad)", { XX } },
4471 { "(bad)", { XX } },
4472 { "(bad)", { XX } },
4473 { VEX_LEN_TABLE (VEX_LEN_FA_P_2) },
4474 { "(bad)", { XX } },
4479 { "(bad)", { XX } },
4480 { "(bad)", { XX } },
4481 { VEX_LEN_TABLE (VEX_LEN_FB_P_2) },
4482 { "(bad)", { XX } },
4487 { "(bad)", { XX } },
4488 { "(bad)", { XX } },
4489 { VEX_LEN_TABLE (VEX_LEN_FC_P_2) },
4490 { "(bad)", { XX } },
4495 { "(bad)", { XX } },
4496 { "(bad)", { XX } },
4497 { VEX_LEN_TABLE (VEX_LEN_FD_P_2) },
4498 { "(bad)", { XX } },
4503 { "(bad)", { XX } },
4504 { "(bad)", { XX } },
4505 { VEX_LEN_TABLE (VEX_LEN_FE_P_2) },
4506 { "(bad)", { XX } },
4509 /* PREFIX_VEX_3800 */
4511 { "(bad)", { XX } },
4512 { "(bad)", { XX } },
4513 { VEX_LEN_TABLE (VEX_LEN_3800_P_2) },
4514 { "(bad)", { XX } },
4517 /* PREFIX_VEX_3801 */
4519 { "(bad)", { XX } },
4520 { "(bad)", { XX } },
4521 { VEX_LEN_TABLE (VEX_LEN_3801_P_2) },
4522 { "(bad)", { XX } },
4525 /* PREFIX_VEX_3802 */
4527 { "(bad)", { XX } },
4528 { "(bad)", { XX } },
4529 { VEX_LEN_TABLE (VEX_LEN_3802_P_2) },
4530 { "(bad)", { XX } },
4533 /* PREFIX_VEX_3803 */
4535 { "(bad)", { XX } },
4536 { "(bad)", { XX } },
4537 { VEX_LEN_TABLE (VEX_LEN_3803_P_2) },
4538 { "(bad)", { XX } },
4541 /* PREFIX_VEX_3804 */
4543 { "(bad)", { XX } },
4544 { "(bad)", { XX } },
4545 { VEX_LEN_TABLE (VEX_LEN_3804_P_2) },
4546 { "(bad)", { XX } },
4549 /* PREFIX_VEX_3805 */
4551 { "(bad)", { XX } },
4552 { "(bad)", { XX } },
4553 { VEX_LEN_TABLE (VEX_LEN_3805_P_2) },
4554 { "(bad)", { XX } },
4557 /* PREFIX_VEX_3806 */
4559 { "(bad)", { XX } },
4560 { "(bad)", { XX } },
4561 { VEX_LEN_TABLE (VEX_LEN_3806_P_2) },
4562 { "(bad)", { XX } },
4565 /* PREFIX_VEX_3807 */
4567 { "(bad)", { XX } },
4568 { "(bad)", { XX } },
4569 { VEX_LEN_TABLE (VEX_LEN_3807_P_2) },
4570 { "(bad)", { XX } },
4573 /* PREFIX_VEX_3808 */
4575 { "(bad)", { XX } },
4576 { "(bad)", { XX } },
4577 { VEX_LEN_TABLE (VEX_LEN_3808_P_2) },
4578 { "(bad)", { XX } },
4581 /* PREFIX_VEX_3809 */
4583 { "(bad)", { XX } },
4584 { "(bad)", { XX } },
4585 { VEX_LEN_TABLE (VEX_LEN_3809_P_2) },
4586 { "(bad)", { XX } },
4589 /* PREFIX_VEX_380A */
4591 { "(bad)", { XX } },
4592 { "(bad)", { XX } },
4593 { VEX_LEN_TABLE (VEX_LEN_380A_P_2) },
4594 { "(bad)", { XX } },
4597 /* PREFIX_VEX_380B */
4599 { "(bad)", { XX } },
4600 { "(bad)", { XX } },
4601 { VEX_LEN_TABLE (VEX_LEN_380B_P_2) },
4602 { "(bad)", { XX } },
4605 /* PREFIX_VEX_380C */
4607 { "(bad)", { XX } },
4608 { "(bad)", { XX } },
4609 { VEX_W_TABLE (VEX_W_380C_P_2) },
4610 { "(bad)", { XX } },
4613 /* PREFIX_VEX_380D */
4615 { "(bad)", { XX } },
4616 { "(bad)", { XX } },
4617 { VEX_W_TABLE (VEX_W_380D_P_2) },
4618 { "(bad)", { XX } },
4621 /* PREFIX_VEX_380E */
4623 { "(bad)", { XX } },
4624 { "(bad)", { XX } },
4625 { VEX_W_TABLE (VEX_W_380E_P_2) },
4626 { "(bad)", { XX } },
4629 /* PREFIX_VEX_380F */
4631 { "(bad)", { XX } },
4632 { "(bad)", { XX } },
4633 { VEX_W_TABLE (VEX_W_380F_P_2) },
4634 { "(bad)", { XX } },
4637 /* PREFIX_VEX_3817 */
4639 { "(bad)", { XX } },
4640 { "(bad)", { XX } },
4641 { VEX_W_TABLE (VEX_W_3817_P_2) },
4642 { "(bad)", { XX } },
4645 /* PREFIX_VEX_3818 */
4647 { "(bad)", { XX } },
4648 { "(bad)", { XX } },
4649 { MOD_TABLE (MOD_VEX_3818_PREFIX_2) },
4650 { "(bad)", { XX } },
4653 /* PREFIX_VEX_3819 */
4655 { "(bad)", { XX } },
4656 { "(bad)", { XX } },
4657 { MOD_TABLE (MOD_VEX_3819_PREFIX_2) },
4658 { "(bad)", { XX } },
4661 /* PREFIX_VEX_381A */
4663 { "(bad)", { XX } },
4664 { "(bad)", { XX } },
4665 { MOD_TABLE (MOD_VEX_381A_PREFIX_2) },
4666 { "(bad)", { XX } },
4669 /* PREFIX_VEX_381C */
4671 { "(bad)", { XX } },
4672 { "(bad)", { XX } },
4673 { VEX_LEN_TABLE (VEX_LEN_381C_P_2) },
4674 { "(bad)", { XX } },
4677 /* PREFIX_VEX_381D */
4679 { "(bad)", { XX } },
4680 { "(bad)", { XX } },
4681 { VEX_LEN_TABLE (VEX_LEN_381D_P_2) },
4682 { "(bad)", { XX } },
4685 /* PREFIX_VEX_381E */
4687 { "(bad)", { XX } },
4688 { "(bad)", { XX } },
4689 { VEX_LEN_TABLE (VEX_LEN_381E_P_2) },
4690 { "(bad)", { XX } },
4693 /* PREFIX_VEX_3820 */
4695 { "(bad)", { XX } },
4696 { "(bad)", { XX } },
4697 { VEX_LEN_TABLE (VEX_LEN_3820_P_2) },
4698 { "(bad)", { XX } },
4701 /* PREFIX_VEX_3821 */
4703 { "(bad)", { XX } },
4704 { "(bad)", { XX } },
4705 { VEX_LEN_TABLE (VEX_LEN_3821_P_2) },
4706 { "(bad)", { XX } },
4709 /* PREFIX_VEX_3822 */
4711 { "(bad)", { XX } },
4712 { "(bad)", { XX } },
4713 { VEX_LEN_TABLE (VEX_LEN_3822_P_2) },
4714 { "(bad)", { XX } },
4717 /* PREFIX_VEX_3823 */
4719 { "(bad)", { XX } },
4720 { "(bad)", { XX } },
4721 { VEX_LEN_TABLE (VEX_LEN_3823_P_2) },
4722 { "(bad)", { XX } },
4725 /* PREFIX_VEX_3824 */
4727 { "(bad)", { XX } },
4728 { "(bad)", { XX } },
4729 { VEX_LEN_TABLE (VEX_LEN_3824_P_2) },
4730 { "(bad)", { XX } },
4733 /* PREFIX_VEX_3825 */
4735 { "(bad)", { XX } },
4736 { "(bad)", { XX } },
4737 { VEX_LEN_TABLE (VEX_LEN_3825_P_2) },
4738 { "(bad)", { XX } },
4741 /* PREFIX_VEX_3828 */
4743 { "(bad)", { XX } },
4744 { "(bad)", { XX } },
4745 { VEX_LEN_TABLE (VEX_LEN_3828_P_2) },
4746 { "(bad)", { XX } },
4749 /* PREFIX_VEX_3829 */
4751 { "(bad)", { XX } },
4752 { "(bad)", { XX } },
4753 { VEX_LEN_TABLE (VEX_LEN_3829_P_2) },
4754 { "(bad)", { XX } },
4757 /* PREFIX_VEX_382A */
4759 { "(bad)", { XX } },
4760 { "(bad)", { XX } },
4761 { MOD_TABLE (MOD_VEX_382A_PREFIX_2) },
4762 { "(bad)", { XX } },
4765 /* PREFIX_VEX_382B */
4767 { "(bad)", { XX } },
4768 { "(bad)", { XX } },
4769 { VEX_LEN_TABLE (VEX_LEN_382B_P_2) },
4770 { "(bad)", { XX } },
4773 /* PREFIX_VEX_382C */
4775 { "(bad)", { XX } },
4776 { "(bad)", { XX } },
4777 { MOD_TABLE (MOD_VEX_382C_PREFIX_2) },
4778 { "(bad)", { XX } },
4781 /* PREFIX_VEX_382D */
4783 { "(bad)", { XX } },
4784 { "(bad)", { XX } },
4785 { MOD_TABLE (MOD_VEX_382D_PREFIX_2) },
4786 { "(bad)", { XX } },
4789 /* PREFIX_VEX_382E */
4791 { "(bad)", { XX } },
4792 { "(bad)", { XX } },
4793 { MOD_TABLE (MOD_VEX_382E_PREFIX_2) },
4794 { "(bad)", { XX } },
4797 /* PREFIX_VEX_382F */
4799 { "(bad)", { XX } },
4800 { "(bad)", { XX } },
4801 { MOD_TABLE (MOD_VEX_382F_PREFIX_2) },
4802 { "(bad)", { XX } },
4805 /* PREFIX_VEX_3830 */
4807 { "(bad)", { XX } },
4808 { "(bad)", { XX } },
4809 { VEX_LEN_TABLE (VEX_LEN_3830_P_2) },
4810 { "(bad)", { XX } },
4813 /* PREFIX_VEX_3831 */
4815 { "(bad)", { XX } },
4816 { "(bad)", { XX } },
4817 { VEX_LEN_TABLE (VEX_LEN_3831_P_2) },
4818 { "(bad)", { XX } },
4821 /* PREFIX_VEX_3832 */
4823 { "(bad)", { XX } },
4824 { "(bad)", { XX } },
4825 { VEX_LEN_TABLE (VEX_LEN_3832_P_2) },
4826 { "(bad)", { XX } },
4829 /* PREFIX_VEX_3833 */
4831 { "(bad)", { XX } },
4832 { "(bad)", { XX } },
4833 { VEX_LEN_TABLE (VEX_LEN_3833_P_2) },
4834 { "(bad)", { XX } },
4837 /* PREFIX_VEX_3834 */
4839 { "(bad)", { XX } },
4840 { "(bad)", { XX } },
4841 { VEX_LEN_TABLE (VEX_LEN_3834_P_2) },
4842 { "(bad)", { XX } },
4845 /* PREFIX_VEX_3835 */
4847 { "(bad)", { XX } },
4848 { "(bad)", { XX } },
4849 { VEX_LEN_TABLE (VEX_LEN_3835_P_2) },
4850 { "(bad)", { XX } },
4853 /* PREFIX_VEX_3837 */
4855 { "(bad)", { XX } },
4856 { "(bad)", { XX } },
4857 { VEX_LEN_TABLE (VEX_LEN_3837_P_2) },
4858 { "(bad)", { XX } },
4861 /* PREFIX_VEX_3838 */
4863 { "(bad)", { XX } },
4864 { "(bad)", { XX } },
4865 { VEX_LEN_TABLE (VEX_LEN_3838_P_2) },
4866 { "(bad)", { XX } },
4869 /* PREFIX_VEX_3839 */
4871 { "(bad)", { XX } },
4872 { "(bad)", { XX } },
4873 { VEX_LEN_TABLE (VEX_LEN_3839_P_2) },
4874 { "(bad)", { XX } },
4877 /* PREFIX_VEX_383A */
4879 { "(bad)", { XX } },
4880 { "(bad)", { XX } },
4881 { VEX_LEN_TABLE (VEX_LEN_383A_P_2) },
4882 { "(bad)", { XX } },
4885 /* PREFIX_VEX_383B */
4887 { "(bad)", { XX } },
4888 { "(bad)", { XX } },
4889 { VEX_LEN_TABLE (VEX_LEN_383B_P_2) },
4890 { "(bad)", { XX } },
4893 /* PREFIX_VEX_383C */
4895 { "(bad)", { XX } },
4896 { "(bad)", { XX } },
4897 { VEX_LEN_TABLE (VEX_LEN_383C_P_2) },
4898 { "(bad)", { XX } },
4901 /* PREFIX_VEX_383D */
4903 { "(bad)", { XX } },
4904 { "(bad)", { XX } },
4905 { VEX_LEN_TABLE (VEX_LEN_383D_P_2) },
4906 { "(bad)", { XX } },
4909 /* PREFIX_VEX_383E */
4911 { "(bad)", { XX } },
4912 { "(bad)", { XX } },
4913 { VEX_LEN_TABLE (VEX_LEN_383E_P_2) },
4914 { "(bad)", { XX } },
4917 /* PREFIX_VEX_383F */
4919 { "(bad)", { XX } },
4920 { "(bad)", { XX } },
4921 { VEX_LEN_TABLE (VEX_LEN_383F_P_2) },
4922 { "(bad)", { XX } },
4925 /* PREFIX_VEX_3840 */
4927 { "(bad)", { XX } },
4928 { "(bad)", { XX } },
4929 { VEX_LEN_TABLE (VEX_LEN_3840_P_2) },
4930 { "(bad)", { XX } },
4933 /* PREFIX_VEX_3841 */
4935 { "(bad)", { XX } },
4936 { "(bad)", { XX } },
4937 { VEX_LEN_TABLE (VEX_LEN_3841_P_2) },
4938 { "(bad)", { XX } },
4941 /* PREFIX_VEX_3896 */
4943 { "(bad)", { XX } },
4944 { "(bad)", { XX } },
4945 { "vfmaddsub132p%XW", { XM, Vex, EXx } },
4946 { "(bad)", { XX } },
4949 /* PREFIX_VEX_3897 */
4951 { "(bad)", { XX } },
4952 { "(bad)", { XX } },
4953 { "vfmsubadd132p%XW", { XM, Vex, EXx } },
4954 { "(bad)", { XX } },
4957 /* PREFIX_VEX_3898 */
4959 { "(bad)", { XX } },
4960 { "(bad)", { XX } },
4961 { "vfmadd132p%XW", { XM, Vex, EXx } },
4962 { "(bad)", { XX } },
4965 /* PREFIX_VEX_3899 */
4967 { "(bad)", { XX } },
4968 { "(bad)", { XX } },
4969 { "vfmadd132s%XW", { XM, Vex, EXVexWdq } },
4970 { "(bad)", { XX } },
4973 /* PREFIX_VEX_389A */
4975 { "(bad)", { XX } },
4976 { "(bad)", { XX } },
4977 { "vfmsub132p%XW", { XM, Vex, EXx } },
4978 { "(bad)", { XX } },
4981 /* PREFIX_VEX_389B */
4983 { "(bad)", { XX } },
4984 { "(bad)", { XX } },
4985 { "vfmsub132s%XW", { XM, Vex, EXVexWdq } },
4986 { "(bad)", { XX } },
4989 /* PREFIX_VEX_389C */
4991 { "(bad)", { XX } },
4992 { "(bad)", { XX } },
4993 { "vfnmadd132p%XW", { XM, Vex, EXx } },
4994 { "(bad)", { XX } },
4997 /* PREFIX_VEX_389D */
4999 { "(bad)", { XX } },
5000 { "(bad)", { XX } },
5001 { "vfnmadd132s%XW", { XM, Vex, EXVexWdq } },
5002 { "(bad)", { XX } },
5005 /* PREFIX_VEX_389E */
5007 { "(bad)", { XX } },
5008 { "(bad)", { XX } },
5009 { "vfnmsub132p%XW", { XM, Vex, EXx } },
5010 { "(bad)", { XX } },
5013 /* PREFIX_VEX_389F */
5015 { "(bad)", { XX } },
5016 { "(bad)", { XX } },
5017 { "vfnmsub132s%XW", { XM, Vex, EXVexWdq } },
5018 { "(bad)", { XX } },
5021 /* PREFIX_VEX_38A6 */
5023 { "(bad)", { XX } },
5024 { "(bad)", { XX } },
5025 { "vfmaddsub213p%XW", { XM, Vex, EXx } },
5026 { "(bad)", { XX } },
5029 /* PREFIX_VEX_38A7 */
5031 { "(bad)", { XX } },
5032 { "(bad)", { XX } },
5033 { "vfmsubadd213p%XW", { XM, Vex, EXx } },
5034 { "(bad)", { XX } },
5037 /* PREFIX_VEX_38A8 */
5039 { "(bad)", { XX } },
5040 { "(bad)", { XX } },
5041 { "vfmadd213p%XW", { XM, Vex, EXx } },
5042 { "(bad)", { XX } },
5045 /* PREFIX_VEX_38A9 */
5047 { "(bad)", { XX } },
5048 { "(bad)", { XX } },
5049 { "vfmadd213s%XW", { XM, Vex, EXVexWdq } },
5050 { "(bad)", { XX } },
5053 /* PREFIX_VEX_38AA */
5055 { "(bad)", { XX } },
5056 { "(bad)", { XX } },
5057 { "vfmsub213p%XW", { XM, Vex, EXx } },
5058 { "(bad)", { XX } },
5061 /* PREFIX_VEX_38AB */
5063 { "(bad)", { XX } },
5064 { "(bad)", { XX } },
5065 { "vfmsub213s%XW", { XM, Vex, EXVexWdq } },
5066 { "(bad)", { XX } },
5069 /* PREFIX_VEX_38AC */
5071 { "(bad)", { XX } },
5072 { "(bad)", { XX } },
5073 { "vfnmadd213p%XW", { XM, Vex, EXx } },
5074 { "(bad)", { XX } },
5077 /* PREFIX_VEX_38AD */
5079 { "(bad)", { XX } },
5080 { "(bad)", { XX } },
5081 { "vfnmadd213s%XW", { XM, Vex, EXVexWdq } },
5082 { "(bad)", { XX } },
5085 /* PREFIX_VEX_38AE */
5087 { "(bad)", { XX } },
5088 { "(bad)", { XX } },
5089 { "vfnmsub213p%XW", { XM, Vex, EXx } },
5090 { "(bad)", { XX } },
5093 /* PREFIX_VEX_38AF */
5095 { "(bad)", { XX } },
5096 { "(bad)", { XX } },
5097 { "vfnmsub213s%XW", { XM, Vex, EXVexWdq } },
5098 { "(bad)", { XX } },
5101 /* PREFIX_VEX_38B6 */
5103 { "(bad)", { XX } },
5104 { "(bad)", { XX } },
5105 { "vfmaddsub231p%XW", { XM, Vex, EXx } },
5106 { "(bad)", { XX } },
5109 /* PREFIX_VEX_38B7 */
5111 { "(bad)", { XX } },
5112 { "(bad)", { XX } },
5113 { "vfmsubadd231p%XW", { XM, Vex, EXx } },
5114 { "(bad)", { XX } },
5117 /* PREFIX_VEX_38B8 */
5119 { "(bad)", { XX } },
5120 { "(bad)", { XX } },
5121 { "vfmadd231p%XW", { XM, Vex, EXx } },
5122 { "(bad)", { XX } },
5125 /* PREFIX_VEX_38B9 */
5127 { "(bad)", { XX } },
5128 { "(bad)", { XX } },
5129 { "vfmadd231s%XW", { XM, Vex, EXVexWdq } },
5130 { "(bad)", { XX } },
5133 /* PREFIX_VEX_38BA */
5135 { "(bad)", { XX } },
5136 { "(bad)", { XX } },
5137 { "vfmsub231p%XW", { XM, Vex, EXx } },
5138 { "(bad)", { XX } },
5141 /* PREFIX_VEX_38BB */
5143 { "(bad)", { XX } },
5144 { "(bad)", { XX } },
5145 { "vfmsub231s%XW", { XM, Vex, EXVexWdq } },
5146 { "(bad)", { XX } },
5149 /* PREFIX_VEX_38BC */
5151 { "(bad)", { XX } },
5152 { "(bad)", { XX } },
5153 { "vfnmadd231p%XW", { XM, Vex, EXx } },
5154 { "(bad)", { XX } },
5157 /* PREFIX_VEX_38BD */
5159 { "(bad)", { XX } },
5160 { "(bad)", { XX } },
5161 { "vfnmadd231s%XW", { XM, Vex, EXVexWdq } },
5162 { "(bad)", { XX } },
5165 /* PREFIX_VEX_38BE */
5167 { "(bad)", { XX } },
5168 { "(bad)", { XX } },
5169 { "vfnmsub231p%XW", { XM, Vex, EXx } },
5170 { "(bad)", { XX } },
5173 /* PREFIX_VEX_38BF */
5175 { "(bad)", { XX } },
5176 { "(bad)", { XX } },
5177 { "vfnmsub231s%XW", { XM, Vex, EXVexWdq } },
5178 { "(bad)", { XX } },
5181 /* PREFIX_VEX_38DB */
5183 { "(bad)", { XX } },
5184 { "(bad)", { XX } },
5185 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2) },
5186 { "(bad)", { XX } },
5189 /* PREFIX_VEX_38DC */
5191 { "(bad)", { XX } },
5192 { "(bad)", { XX } },
5193 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2) },
5194 { "(bad)", { XX } },
5197 /* PREFIX_VEX_38DD */
5199 { "(bad)", { XX } },
5200 { "(bad)", { XX } },
5201 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2) },
5202 { "(bad)", { XX } },
5205 /* PREFIX_VEX_38DE */
5207 { "(bad)", { XX } },
5208 { "(bad)", { XX } },
5209 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2) },
5210 { "(bad)", { XX } },
5213 /* PREFIX_VEX_38DF */
5215 { "(bad)", { XX } },
5216 { "(bad)", { XX } },
5217 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2) },
5218 { "(bad)", { XX } },
5221 /* PREFIX_VEX_3A04 */
5223 { "(bad)", { XX } },
5224 { "(bad)", { XX } },
5225 { VEX_W_TABLE (VEX_W_3A04_P_2) },
5226 { "(bad)", { XX } },
5229 /* PREFIX_VEX_3A05 */
5231 { "(bad)", { XX } },
5232 { "(bad)", { XX } },
5233 { VEX_W_TABLE (VEX_W_3A05_P_2) },
5234 { "(bad)", { XX } },
5237 /* PREFIX_VEX_3A06 */
5239 { "(bad)", { XX } },
5240 { "(bad)", { XX } },
5241 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2) },
5242 { "(bad)", { XX } },
5245 /* PREFIX_VEX_3A08 */
5247 { "(bad)", { XX } },
5248 { "(bad)", { XX } },
5249 { VEX_W_TABLE (VEX_W_3A08_P_2) },
5250 { "(bad)", { XX } },
5253 /* PREFIX_VEX_3A09 */
5255 { "(bad)", { XX } },
5256 { "(bad)", { XX } },
5257 { VEX_W_TABLE (VEX_W_3A09_P_2) },
5258 { "(bad)", { XX } },
5261 /* PREFIX_VEX_3A0A */
5263 { "(bad)", { XX } },
5264 { "(bad)", { XX } },
5265 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2) },
5266 { "(bad)", { XX } },
5269 /* PREFIX_VEX_3A0B */
5271 { "(bad)", { XX } },
5272 { "(bad)", { XX } },
5273 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2) },
5274 { "(bad)", { XX } },
5277 /* PREFIX_VEX_3A0C */
5279 { "(bad)", { XX } },
5280 { "(bad)", { XX } },
5281 { VEX_W_TABLE (VEX_W_3A0C_P_2) },
5282 { "(bad)", { XX } },
5285 /* PREFIX_VEX_3A0D */
5287 { "(bad)", { XX } },
5288 { "(bad)", { XX } },
5289 { VEX_W_TABLE (VEX_W_3A0D_P_2) },
5290 { "(bad)", { XX } },
5293 /* PREFIX_VEX_3A0E */
5295 { "(bad)", { XX } },
5296 { "(bad)", { XX } },
5297 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2) },
5298 { "(bad)", { XX } },
5301 /* PREFIX_VEX_3A0F */
5303 { "(bad)", { XX } },
5304 { "(bad)", { XX } },
5305 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2) },
5306 { "(bad)", { XX } },
5309 /* PREFIX_VEX_3A14 */
5311 { "(bad)", { XX } },
5312 { "(bad)", { XX } },
5313 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2) },
5314 { "(bad)", { XX } },
5317 /* PREFIX_VEX_3A15 */
5319 { "(bad)", { XX } },
5320 { "(bad)", { XX } },
5321 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2) },
5322 { "(bad)", { XX } },
5325 /* PREFIX_VEX_3A16 */
5327 { "(bad)", { XX } },
5328 { "(bad)", { XX } },
5329 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2) },
5330 { "(bad)", { XX } },
5333 /* PREFIX_VEX_3A17 */
5335 { "(bad)", { XX } },
5336 { "(bad)", { XX } },
5337 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2) },
5338 { "(bad)", { XX } },
5341 /* PREFIX_VEX_3A18 */
5343 { "(bad)", { XX } },
5344 { "(bad)", { XX } },
5345 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2) },
5346 { "(bad)", { XX } },
5349 /* PREFIX_VEX_3A19 */
5351 { "(bad)", { XX } },
5352 { "(bad)", { XX } },
5353 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2) },
5354 { "(bad)", { XX } },
5357 /* PREFIX_VEX_3A20 */
5359 { "(bad)", { XX } },
5360 { "(bad)", { XX } },
5361 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2) },
5362 { "(bad)", { XX } },
5365 /* PREFIX_VEX_3A21 */
5367 { "(bad)", { XX } },
5368 { "(bad)", { XX } },
5369 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2) },
5370 { "(bad)", { XX } },
5373 /* PREFIX_VEX_3A22 */
5375 { "(bad)", { XX } },
5376 { "(bad)", { XX } },
5377 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2) },
5378 { "(bad)", { XX } },
5381 /* PREFIX_VEX_3A40 */
5383 { "(bad)", { XX } },
5384 { "(bad)", { XX } },
5385 { VEX_W_TABLE (VEX_W_3A40_P_2) },
5386 { "(bad)", { XX } },
5389 /* PREFIX_VEX_3A41 */
5391 { "(bad)", { XX } },
5392 { "(bad)", { XX } },
5393 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2) },
5394 { "(bad)", { XX } },
5397 /* PREFIX_VEX_3A42 */
5399 { "(bad)", { XX } },
5400 { "(bad)", { XX } },
5401 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2) },
5402 { "(bad)", { XX } },
5405 /* PREFIX_VEX_3A44 */
5407 { "(bad)", { XX } },
5408 { "(bad)", { XX } },
5409 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2) },
5410 { "(bad)", { XX } },
5413 /* PREFIX_VEX_3A4A */
5415 { "(bad)", { XX } },
5416 { "(bad)", { XX } },
5417 { VEX_W_TABLE (VEX_W_3A4A_P_2) },
5418 { "(bad)", { XX } },
5421 /* PREFIX_VEX_3A4B */
5423 { "(bad)", { XX } },
5424 { "(bad)", { XX } },
5425 { VEX_W_TABLE (VEX_W_3A4B_P_2) },
5426 { "(bad)", { XX } },
5429 /* PREFIX_VEX_3A4C */
5431 { "(bad)", { XX } },
5432 { "(bad)", { XX } },
5433 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2) },
5434 { "(bad)", { XX } },
5437 /* PREFIX_VEX_3A5C */
5439 { "(bad)", { XX } },
5440 { "(bad)", { XX } },
5441 { "vfmaddsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5442 { "(bad)", { XX } },
5445 /* PREFIX_VEX_3A5D */
5447 { "(bad)", { XX } },
5448 { "(bad)", { XX } },
5449 { "vfmaddsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5450 { "(bad)", { XX } },
5453 /* PREFIX_VEX_3A5E */
5455 { "(bad)", { XX } },
5456 { "(bad)", { XX } },
5457 { "vfmsubaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5458 { "(bad)", { XX } },
5461 /* PREFIX_VEX_3A5F */
5463 { "(bad)", { XX } },
5464 { "(bad)", { XX } },
5465 { "vfmsubaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5466 { "(bad)", { XX } },
5469 /* PREFIX_VEX_3A60 */
5471 { "(bad)", { XX } },
5472 { "(bad)", { XX } },
5473 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2) },
5474 { "(bad)", { XX } },
5477 /* PREFIX_VEX_3A61 */
5479 { "(bad)", { XX } },
5480 { "(bad)", { XX } },
5481 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2) },
5482 { "(bad)", { XX } },
5485 /* PREFIX_VEX_3A62 */
5487 { "(bad)", { XX } },
5488 { "(bad)", { XX } },
5489 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2) },
5490 { "(bad)", { XX } },
5493 /* PREFIX_VEX_3A63 */
5495 { "(bad)", { XX } },
5496 { "(bad)", { XX } },
5497 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2) },
5498 { "(bad)", { XX } },
5501 /* PREFIX_VEX_3A68 */
5503 { "(bad)", { XX } },
5504 { "(bad)", { XX } },
5505 { "vfmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5506 { "(bad)", { XX } },
5509 /* PREFIX_VEX_3A69 */
5511 { "(bad)", { XX } },
5512 { "(bad)", { XX } },
5513 { "vfmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5514 { "(bad)", { XX } },
5517 /* PREFIX_VEX_3A6A */
5519 { "(bad)", { XX } },
5520 { "(bad)", { XX } },
5521 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2) },
5522 { "(bad)", { XX } },
5525 /* PREFIX_VEX_3A6B */
5527 { "(bad)", { XX } },
5528 { "(bad)", { XX } },
5529 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2) },
5530 { "(bad)", { XX } },
5533 /* PREFIX_VEX_3A6C */
5535 { "(bad)", { XX } },
5536 { "(bad)", { XX } },
5537 { "vfmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5538 { "(bad)", { XX } },
5541 /* PREFIX_VEX_3A6D */
5543 { "(bad)", { XX } },
5544 { "(bad)", { XX } },
5545 { "vfmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5546 { "(bad)", { XX } },
5549 /* PREFIX_VEX_3A6E */
5551 { "(bad)", { XX } },
5552 { "(bad)", { XX } },
5553 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2) },
5554 { "(bad)", { XX } },
5557 /* PREFIX_VEX_3A6F */
5559 { "(bad)", { XX } },
5560 { "(bad)", { XX } },
5561 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2) },
5562 { "(bad)", { XX } },
5565 /* PREFIX_VEX_3A78 */
5567 { "(bad)", { XX } },
5568 { "(bad)", { XX } },
5569 { "vfnmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5570 { "(bad)", { XX } },
5573 /* PREFIX_VEX_3A79 */
5575 { "(bad)", { XX } },
5576 { "(bad)", { XX } },
5577 { "vfnmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5578 { "(bad)", { XX } },
5581 /* PREFIX_VEX_3A7A */
5583 { "(bad)", { XX } },
5584 { "(bad)", { XX } },
5585 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2) },
5586 { "(bad)", { XX } },
5589 /* PREFIX_VEX_3A7B */
5591 { "(bad)", { XX } },
5592 { "(bad)", { XX } },
5593 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2) },
5594 { "(bad)", { XX } },
5597 /* PREFIX_VEX_3A7C */
5599 { "(bad)", { XX } },
5600 { "(bad)", { XX } },
5601 { "vfnmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5602 { "(bad)", { XX } },
5605 /* PREFIX_VEX_3A7D */
5607 { "(bad)", { XX } },
5608 { "(bad)", { XX } },
5609 { "vfnmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5610 { "(bad)", { XX } },
5613 /* PREFIX_VEX_3A7E */
5615 { "(bad)", { XX } },
5616 { "(bad)", { XX } },
5617 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2) },
5618 { "(bad)", { XX } },
5621 /* PREFIX_VEX_3A7F */
5623 { "(bad)", { XX } },
5624 { "(bad)", { XX } },
5625 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2) },
5626 { "(bad)", { XX } },
5629 /* PREFIX_VEX_3ADF */
5631 { "(bad)", { XX } },
5632 { "(bad)", { XX } },
5633 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2) },
5634 { "(bad)", { XX } },
5638 static const struct dis386 x86_64_table[][2] = {
5641 { "push{T|}", { es } },
5642 { "(bad)", { XX } },
5647 { "pop{T|}", { es } },
5648 { "(bad)", { XX } },
5653 { "push{T|}", { cs } },
5654 { "(bad)", { XX } },
5659 { "push{T|}", { ss } },
5660 { "(bad)", { XX } },
5665 { "pop{T|}", { ss } },
5666 { "(bad)", { XX } },
5671 { "push{T|}", { ds } },
5672 { "(bad)", { XX } },
5677 { "pop{T|}", { ds } },
5678 { "(bad)", { XX } },
5684 { "(bad)", { XX } },
5690 { "(bad)", { XX } },
5696 { "(bad)", { XX } },
5702 { "(bad)", { XX } },
5707 { "pusha{P|}", { XX } },
5708 { "(bad)", { XX } },
5713 { "popa{P|}", { XX } },
5714 { "(bad)", { XX } },
5719 { MOD_TABLE (MOD_62_32BIT) },
5720 { "(bad)", { XX } },
5725 { "arpl", { Ew, Gw } },
5726 { "movs{lq|xd}", { Gv, Ed } },
5731 { "ins{R|}", { Yzr, indirDX } },
5732 { "ins{G|}", { Yzr, indirDX } },
5737 { "outs{R|}", { indirDXr, Xz } },
5738 { "outs{G|}", { indirDXr, Xz } },
5743 { "Jcall{T|}", { Ap } },
5744 { "(bad)", { XX } },
5749 { MOD_TABLE (MOD_C4_32BIT) },
5750 { VEX_C4_TABLE (VEX_0F) },
5755 { MOD_TABLE (MOD_C5_32BIT) },
5756 { VEX_C5_TABLE (VEX_0F) },
5762 { "(bad)", { XX } },
5768 { "(bad)", { XX } },
5774 { "(bad)", { XX } },
5779 { "Jjmp{T|}", { Ap } },
5780 { "(bad)", { XX } },
5783 /* X86_64_0F01_REG_0 */
5785 { "sgdt{Q|IQ}", { M } },
5789 /* X86_64_0F01_REG_1 */
5791 { "sidt{Q|IQ}", { M } },
5795 /* X86_64_0F01_REG_2 */
5797 { "lgdt{Q|Q}", { M } },
5801 /* X86_64_0F01_REG_3 */
5803 { "lidt{Q|Q}", { M } },
5808 static const struct dis386 three_byte_table[][256] = {
5810 /* THREE_BYTE_0F38 */
5813 { "pshufb", { MX, EM } },
5814 { "phaddw", { MX, EM } },
5815 { "phaddd", { MX, EM } },
5816 { "phaddsw", { MX, EM } },
5817 { "pmaddubsw", { MX, EM } },
5818 { "phsubw", { MX, EM } },
5819 { "phsubd", { MX, EM } },
5820 { "phsubsw", { MX, EM } },
5822 { "psignb", { MX, EM } },
5823 { "psignw", { MX, EM } },
5824 { "psignd", { MX, EM } },
5825 { "pmulhrsw", { MX, EM } },
5826 { "(bad)", { XX } },
5827 { "(bad)", { XX } },
5828 { "(bad)", { XX } },
5829 { "(bad)", { XX } },
5831 { PREFIX_TABLE (PREFIX_0F3810) },
5832 { "(bad)", { XX } },
5833 { "(bad)", { XX } },
5834 { "(bad)", { XX } },
5835 { PREFIX_TABLE (PREFIX_0F3814) },
5836 { PREFIX_TABLE (PREFIX_0F3815) },
5837 { "(bad)", { XX } },
5838 { PREFIX_TABLE (PREFIX_0F3817) },
5840 { "(bad)", { XX } },
5841 { "(bad)", { XX } },
5842 { "(bad)", { XX } },
5843 { "(bad)", { XX } },
5844 { "pabsb", { MX, EM } },
5845 { "pabsw", { MX, EM } },
5846 { "pabsd", { MX, EM } },
5847 { "(bad)", { XX } },
5849 { PREFIX_TABLE (PREFIX_0F3820) },
5850 { PREFIX_TABLE (PREFIX_0F3821) },
5851 { PREFIX_TABLE (PREFIX_0F3822) },
5852 { PREFIX_TABLE (PREFIX_0F3823) },
5853 { PREFIX_TABLE (PREFIX_0F3824) },
5854 { PREFIX_TABLE (PREFIX_0F3825) },
5855 { "(bad)", { XX } },
5856 { "(bad)", { XX } },
5858 { PREFIX_TABLE (PREFIX_0F3828) },
5859 { PREFIX_TABLE (PREFIX_0F3829) },
5860 { PREFIX_TABLE (PREFIX_0F382A) },
5861 { PREFIX_TABLE (PREFIX_0F382B) },
5862 { "(bad)", { XX } },
5863 { "(bad)", { XX } },
5864 { "(bad)", { XX } },
5865 { "(bad)", { XX } },
5867 { PREFIX_TABLE (PREFIX_0F3830) },
5868 { PREFIX_TABLE (PREFIX_0F3831) },
5869 { PREFIX_TABLE (PREFIX_0F3832) },
5870 { PREFIX_TABLE (PREFIX_0F3833) },
5871 { PREFIX_TABLE (PREFIX_0F3834) },
5872 { PREFIX_TABLE (PREFIX_0F3835) },
5873 { "(bad)", { XX } },
5874 { PREFIX_TABLE (PREFIX_0F3837) },
5876 { PREFIX_TABLE (PREFIX_0F3838) },
5877 { PREFIX_TABLE (PREFIX_0F3839) },
5878 { PREFIX_TABLE (PREFIX_0F383A) },
5879 { PREFIX_TABLE (PREFIX_0F383B) },
5880 { PREFIX_TABLE (PREFIX_0F383C) },
5881 { PREFIX_TABLE (PREFIX_0F383D) },
5882 { PREFIX_TABLE (PREFIX_0F383E) },
5883 { PREFIX_TABLE (PREFIX_0F383F) },
5885 { PREFIX_TABLE (PREFIX_0F3840) },
5886 { PREFIX_TABLE (PREFIX_0F3841) },
5887 { "(bad)", { XX } },
5888 { "(bad)", { XX } },
5889 { "(bad)", { XX } },
5890 { "(bad)", { XX } },
5891 { "(bad)", { XX } },
5892 { "(bad)", { XX } },
5894 { "(bad)", { XX } },
5895 { "(bad)", { XX } },
5896 { "(bad)", { XX } },
5897 { "(bad)", { XX } },
5898 { "(bad)", { XX } },
5899 { "(bad)", { XX } },
5900 { "(bad)", { XX } },
5901 { "(bad)", { XX } },
5903 { "(bad)", { XX } },
5904 { "(bad)", { XX } },
5905 { "(bad)", { XX } },
5906 { "(bad)", { XX } },
5907 { "(bad)", { XX } },
5908 { "(bad)", { XX } },
5909 { "(bad)", { XX } },
5910 { "(bad)", { XX } },
5912 { "(bad)", { XX } },
5913 { "(bad)", { XX } },
5914 { "(bad)", { XX } },
5915 { "(bad)", { XX } },
5916 { "(bad)", { XX } },
5917 { "(bad)", { XX } },
5918 { "(bad)", { XX } },
5919 { "(bad)", { XX } },
5921 { "(bad)", { XX } },
5922 { "(bad)", { XX } },
5923 { "(bad)", { XX } },
5924 { "(bad)", { XX } },
5925 { "(bad)", { XX } },
5926 { "(bad)", { XX } },
5927 { "(bad)", { XX } },
5928 { "(bad)", { XX } },
5930 { "(bad)", { XX } },
5931 { "(bad)", { XX } },
5932 { "(bad)", { XX } },
5933 { "(bad)", { XX } },
5934 { "(bad)", { XX } },
5935 { "(bad)", { XX } },
5936 { "(bad)", { XX } },
5937 { "(bad)", { XX } },
5939 { "(bad)", { XX } },
5940 { "(bad)", { XX } },
5941 { "(bad)", { XX } },
5942 { "(bad)", { XX } },
5943 { "(bad)", { XX } },
5944 { "(bad)", { XX } },
5945 { "(bad)", { XX } },
5946 { "(bad)", { XX } },
5948 { "(bad)", { XX } },
5949 { "(bad)", { XX } },
5950 { "(bad)", { XX } },
5951 { "(bad)", { XX } },
5952 { "(bad)", { XX } },
5953 { "(bad)", { XX } },
5954 { "(bad)", { XX } },
5955 { "(bad)", { XX } },
5957 { PREFIX_TABLE (PREFIX_0F3880) },
5958 { PREFIX_TABLE (PREFIX_0F3881) },
5959 { "(bad)", { XX } },
5960 { "(bad)", { XX } },
5961 { "(bad)", { XX } },
5962 { "(bad)", { XX } },
5963 { "(bad)", { XX } },
5964 { "(bad)", { XX } },
5966 { "(bad)", { XX } },
5967 { "(bad)", { XX } },
5968 { "(bad)", { XX } },
5969 { "(bad)", { XX } },
5970 { "(bad)", { XX } },
5971 { "(bad)", { XX } },
5972 { "(bad)", { XX } },
5973 { "(bad)", { XX } },
5975 { "(bad)", { XX } },
5976 { "(bad)", { XX } },
5977 { "(bad)", { XX } },
5978 { "(bad)", { XX } },
5979 { "(bad)", { XX } },
5980 { "(bad)", { XX } },
5981 { "(bad)", { XX } },
5982 { "(bad)", { XX } },
5984 { "(bad)", { XX } },
5985 { "(bad)", { XX } },
5986 { "(bad)", { XX } },
5987 { "(bad)", { XX } },
5988 { "(bad)", { XX } },
5989 { "(bad)", { XX } },
5990 { "(bad)", { XX } },
5991 { "(bad)", { XX } },
5993 { "(bad)", { XX } },
5994 { "(bad)", { XX } },
5995 { "(bad)", { XX } },
5996 { "(bad)", { XX } },
5997 { "(bad)", { XX } },
5998 { "(bad)", { XX } },
5999 { "(bad)", { XX } },
6000 { "(bad)", { XX } },
6002 { "(bad)", { XX } },
6003 { "(bad)", { XX } },
6004 { "(bad)", { XX } },
6005 { "(bad)", { XX } },
6006 { "(bad)", { XX } },
6007 { "(bad)", { XX } },
6008 { "(bad)", { XX } },
6009 { "(bad)", { XX } },
6011 { "(bad)", { XX } },
6012 { "(bad)", { XX } },
6013 { "(bad)", { XX } },
6014 { "(bad)", { XX } },
6015 { "(bad)", { XX } },
6016 { "(bad)", { XX } },
6017 { "(bad)", { XX } },
6018 { "(bad)", { XX } },
6020 { "(bad)", { XX } },
6021 { "(bad)", { XX } },
6022 { "(bad)", { XX } },
6023 { "(bad)", { XX } },
6024 { "(bad)", { XX } },
6025 { "(bad)", { XX } },
6026 { "(bad)", { XX } },
6027 { "(bad)", { XX } },
6029 { "(bad)", { XX } },
6030 { "(bad)", { XX } },
6031 { "(bad)", { XX } },
6032 { "(bad)", { XX } },
6033 { "(bad)", { XX } },
6034 { "(bad)", { XX } },
6035 { "(bad)", { XX } },
6036 { "(bad)", { XX } },
6038 { "(bad)", { XX } },
6039 { "(bad)", { XX } },
6040 { "(bad)", { XX } },
6041 { "(bad)", { XX } },
6042 { "(bad)", { XX } },
6043 { "(bad)", { XX } },
6044 { "(bad)", { XX } },
6045 { "(bad)", { XX } },
6047 { "(bad)", { XX } },
6048 { "(bad)", { XX } },
6049 { "(bad)", { XX } },
6050 { "(bad)", { XX } },
6051 { "(bad)", { XX } },
6052 { "(bad)", { XX } },
6053 { "(bad)", { XX } },
6054 { "(bad)", { XX } },
6056 { "(bad)", { XX } },
6057 { "(bad)", { XX } },
6058 { "(bad)", { XX } },
6059 { PREFIX_TABLE (PREFIX_0F38DB) },
6060 { PREFIX_TABLE (PREFIX_0F38DC) },
6061 { PREFIX_TABLE (PREFIX_0F38DD) },
6062 { PREFIX_TABLE (PREFIX_0F38DE) },
6063 { PREFIX_TABLE (PREFIX_0F38DF) },
6065 { "(bad)", { XX } },
6066 { "(bad)", { XX } },
6067 { "(bad)", { XX } },
6068 { "(bad)", { XX } },
6069 { "(bad)", { XX } },
6070 { "(bad)", { XX } },
6071 { "(bad)", { XX } },
6072 { "(bad)", { XX } },
6074 { "(bad)", { XX } },
6075 { "(bad)", { XX } },
6076 { "(bad)", { XX } },
6077 { "(bad)", { XX } },
6078 { "(bad)", { XX } },
6079 { "(bad)", { XX } },
6080 { "(bad)", { XX } },
6081 { "(bad)", { XX } },
6083 { PREFIX_TABLE (PREFIX_0F38F0) },
6084 { PREFIX_TABLE (PREFIX_0F38F1) },
6085 { "(bad)", { XX } },
6086 { "(bad)", { XX } },
6087 { "(bad)", { XX } },
6088 { "(bad)", { XX } },
6089 { "(bad)", { XX } },
6090 { "(bad)", { XX } },
6092 { "(bad)", { XX } },
6093 { "(bad)", { XX } },
6094 { "(bad)", { XX } },
6095 { "(bad)", { XX } },
6096 { "(bad)", { XX } },
6097 { "(bad)", { XX } },
6098 { "(bad)", { XX } },
6099 { "(bad)", { XX } },
6101 /* THREE_BYTE_0F3A */
6104 { "(bad)", { XX } },
6105 { "(bad)", { XX } },
6106 { "(bad)", { XX } },
6107 { "(bad)", { XX } },
6108 { "(bad)", { XX } },
6109 { "(bad)", { XX } },
6110 { "(bad)", { XX } },
6111 { "(bad)", { XX } },
6113 { PREFIX_TABLE (PREFIX_0F3A08) },
6114 { PREFIX_TABLE (PREFIX_0F3A09) },
6115 { PREFIX_TABLE (PREFIX_0F3A0A) },
6116 { PREFIX_TABLE (PREFIX_0F3A0B) },
6117 { PREFIX_TABLE (PREFIX_0F3A0C) },
6118 { PREFIX_TABLE (PREFIX_0F3A0D) },
6119 { PREFIX_TABLE (PREFIX_0F3A0E) },
6120 { "palignr", { MX, EM, Ib } },
6122 { "(bad)", { XX } },
6123 { "(bad)", { XX } },
6124 { "(bad)", { XX } },
6125 { "(bad)", { XX } },
6126 { PREFIX_TABLE (PREFIX_0F3A14) },
6127 { PREFIX_TABLE (PREFIX_0F3A15) },
6128 { PREFIX_TABLE (PREFIX_0F3A16) },
6129 { PREFIX_TABLE (PREFIX_0F3A17) },
6131 { "(bad)", { XX } },
6132 { "(bad)", { XX } },
6133 { "(bad)", { XX } },
6134 { "(bad)", { XX } },
6135 { "(bad)", { XX } },
6136 { "(bad)", { XX } },
6137 { "(bad)", { XX } },
6138 { "(bad)", { XX } },
6140 { PREFIX_TABLE (PREFIX_0F3A20) },
6141 { PREFIX_TABLE (PREFIX_0F3A21) },
6142 { PREFIX_TABLE (PREFIX_0F3A22) },
6143 { "(bad)", { XX } },
6144 { "(bad)", { XX } },
6145 { "(bad)", { XX } },
6146 { "(bad)", { XX } },
6147 { "(bad)", { XX } },
6149 { "(bad)", { XX } },
6150 { "(bad)", { XX } },
6151 { "(bad)", { XX } },
6152 { "(bad)", { XX } },
6153 { "(bad)", { XX } },
6154 { "(bad)", { XX } },
6155 { "(bad)", { XX } },
6156 { "(bad)", { XX } },
6158 { "(bad)", { XX } },
6159 { "(bad)", { XX } },
6160 { "(bad)", { XX } },
6161 { "(bad)", { XX } },
6162 { "(bad)", { XX } },
6163 { "(bad)", { XX } },
6164 { "(bad)", { XX } },
6165 { "(bad)", { XX } },
6167 { "(bad)", { XX } },
6168 { "(bad)", { XX } },
6169 { "(bad)", { XX } },
6170 { "(bad)", { XX } },
6171 { "(bad)", { XX } },
6172 { "(bad)", { XX } },
6173 { "(bad)", { XX } },
6174 { "(bad)", { XX } },
6176 { PREFIX_TABLE (PREFIX_0F3A40) },
6177 { PREFIX_TABLE (PREFIX_0F3A41) },
6178 { PREFIX_TABLE (PREFIX_0F3A42) },
6179 { "(bad)", { XX } },
6180 { PREFIX_TABLE (PREFIX_0F3A44) },
6181 { "(bad)", { XX } },
6182 { "(bad)", { XX } },
6183 { "(bad)", { XX } },
6185 { "(bad)", { XX } },
6186 { "(bad)", { XX } },
6187 { "(bad)", { XX } },
6188 { "(bad)", { XX } },
6189 { "(bad)", { XX } },
6190 { "(bad)", { XX } },
6191 { "(bad)", { XX } },
6192 { "(bad)", { XX } },
6194 { "(bad)", { XX } },
6195 { "(bad)", { XX } },
6196 { "(bad)", { XX } },
6197 { "(bad)", { XX } },
6198 { "(bad)", { XX } },
6199 { "(bad)", { XX } },
6200 { "(bad)", { XX } },
6201 { "(bad)", { XX } },
6203 { "(bad)", { XX } },
6204 { "(bad)", { XX } },
6205 { "(bad)", { XX } },
6206 { "(bad)", { XX } },
6207 { "(bad)", { XX } },
6208 { "(bad)", { XX } },
6209 { "(bad)", { XX } },
6210 { "(bad)", { XX } },
6212 { PREFIX_TABLE (PREFIX_0F3A60) },
6213 { PREFIX_TABLE (PREFIX_0F3A61) },
6214 { PREFIX_TABLE (PREFIX_0F3A62) },
6215 { PREFIX_TABLE (PREFIX_0F3A63) },
6216 { "(bad)", { XX } },
6217 { "(bad)", { XX } },
6218 { "(bad)", { XX } },
6219 { "(bad)", { XX } },
6221 { "(bad)", { XX } },
6222 { "(bad)", { XX } },
6223 { "(bad)", { XX } },
6224 { "(bad)", { XX } },
6225 { "(bad)", { XX } },
6226 { "(bad)", { XX } },
6227 { "(bad)", { XX } },
6228 { "(bad)", { XX } },
6230 { "(bad)", { XX } },
6231 { "(bad)", { XX } },
6232 { "(bad)", { XX } },
6233 { "(bad)", { XX } },
6234 { "(bad)", { XX } },
6235 { "(bad)", { XX } },
6236 { "(bad)", { XX } },
6237 { "(bad)", { XX } },
6239 { "(bad)", { XX } },
6240 { "(bad)", { XX } },
6241 { "(bad)", { XX } },
6242 { "(bad)", { XX } },
6243 { "(bad)", { XX } },
6244 { "(bad)", { XX } },
6245 { "(bad)", { XX } },
6246 { "(bad)", { XX } },
6248 { "(bad)", { XX } },
6249 { "(bad)", { XX } },
6250 { "(bad)", { XX } },
6251 { "(bad)", { XX } },
6252 { "(bad)", { XX } },
6253 { "(bad)", { XX } },
6254 { "(bad)", { XX } },
6255 { "(bad)", { XX } },
6257 { "(bad)", { XX } },
6258 { "(bad)", { XX } },
6259 { "(bad)", { XX } },
6260 { "(bad)", { XX } },
6261 { "(bad)", { XX } },
6262 { "(bad)", { XX } },
6263 { "(bad)", { XX } },
6264 { "(bad)", { XX } },
6266 { "(bad)", { XX } },
6267 { "(bad)", { XX } },
6268 { "(bad)", { XX } },
6269 { "(bad)", { XX } },
6270 { "(bad)", { XX } },
6271 { "(bad)", { XX } },
6272 { "(bad)", { XX } },
6273 { "(bad)", { XX } },
6275 { "(bad)", { XX } },
6276 { "(bad)", { XX } },
6277 { "(bad)", { XX } },
6278 { "(bad)", { XX } },
6279 { "(bad)", { XX } },
6280 { "(bad)", { XX } },
6281 { "(bad)", { XX } },
6282 { "(bad)", { XX } },
6284 { "(bad)", { XX } },
6285 { "(bad)", { XX } },
6286 { "(bad)", { XX } },
6287 { "(bad)", { XX } },
6288 { "(bad)", { XX } },
6289 { "(bad)", { XX } },
6290 { "(bad)", { XX } },
6291 { "(bad)", { XX } },
6293 { "(bad)", { XX } },
6294 { "(bad)", { XX } },
6295 { "(bad)", { XX } },
6296 { "(bad)", { XX } },
6297 { "(bad)", { XX } },
6298 { "(bad)", { XX } },
6299 { "(bad)", { XX } },
6300 { "(bad)", { XX } },
6302 { "(bad)", { XX } },
6303 { "(bad)", { XX } },
6304 { "(bad)", { XX } },
6305 { "(bad)", { XX } },
6306 { "(bad)", { XX } },
6307 { "(bad)", { XX } },
6308 { "(bad)", { XX } },
6309 { "(bad)", { XX } },
6311 { "(bad)", { XX } },
6312 { "(bad)", { XX } },
6313 { "(bad)", { XX } },
6314 { "(bad)", { XX } },
6315 { "(bad)", { XX } },
6316 { "(bad)", { XX } },
6317 { "(bad)", { XX } },
6318 { "(bad)", { XX } },
6320 { "(bad)", { XX } },
6321 { "(bad)", { XX } },
6322 { "(bad)", { XX } },
6323 { "(bad)", { XX } },
6324 { "(bad)", { XX } },
6325 { "(bad)", { XX } },
6326 { "(bad)", { XX } },
6327 { "(bad)", { XX } },
6329 { "(bad)", { XX } },
6330 { "(bad)", { XX } },
6331 { "(bad)", { XX } },
6332 { "(bad)", { XX } },
6333 { "(bad)", { XX } },
6334 { "(bad)", { XX } },
6335 { "(bad)", { XX } },
6336 { "(bad)", { XX } },
6338 { "(bad)", { XX } },
6339 { "(bad)", { XX } },
6340 { "(bad)", { XX } },
6341 { "(bad)", { XX } },
6342 { "(bad)", { XX } },
6343 { "(bad)", { XX } },
6344 { "(bad)", { XX } },
6345 { "(bad)", { XX } },
6347 { "(bad)", { XX } },
6348 { "(bad)", { XX } },
6349 { "(bad)", { XX } },
6350 { "(bad)", { XX } },
6351 { "(bad)", { XX } },
6352 { "(bad)", { XX } },
6353 { "(bad)", { XX } },
6354 { PREFIX_TABLE (PREFIX_0F3ADF) },
6356 { "(bad)", { XX } },
6357 { "(bad)", { XX } },
6358 { "(bad)", { XX } },
6359 { "(bad)", { XX } },
6360 { "(bad)", { XX } },
6361 { "(bad)", { XX } },
6362 { "(bad)", { XX } },
6363 { "(bad)", { XX } },
6365 { "(bad)", { XX } },
6366 { "(bad)", { XX } },
6367 { "(bad)", { XX } },
6368 { "(bad)", { XX } },
6369 { "(bad)", { XX } },
6370 { "(bad)", { XX } },
6371 { "(bad)", { XX } },
6372 { "(bad)", { XX } },
6374 { "(bad)", { XX } },
6375 { "(bad)", { XX } },
6376 { "(bad)", { XX } },
6377 { "(bad)", { XX } },
6378 { "(bad)", { XX } },
6379 { "(bad)", { XX } },
6380 { "(bad)", { XX } },
6381 { "(bad)", { XX } },
6383 { "(bad)", { XX } },
6384 { "(bad)", { XX } },
6385 { "(bad)", { XX } },
6386 { "(bad)", { XX } },
6387 { "(bad)", { XX } },
6388 { "(bad)", { XX } },
6389 { "(bad)", { XX } },
6390 { "(bad)", { XX } },
6393 /* THREE_BYTE_0F7A */
6396 { "(bad)", { XX } },
6397 { "(bad)", { XX } },
6398 { "(bad)", { XX } },
6399 { "(bad)", { XX } },
6400 { "(bad)", { XX } },
6401 { "(bad)", { XX } },
6402 { "(bad)", { XX } },
6403 { "(bad)", { XX } },
6405 { "(bad)", { XX } },
6406 { "(bad)", { XX } },
6407 { "(bad)", { XX } },
6408 { "(bad)", { XX } },
6409 { "(bad)", { XX } },
6410 { "(bad)", { XX } },
6411 { "(bad)", { XX } },
6412 { "(bad)", { XX } },
6414 { "(bad)", { XX } },
6415 { "(bad)", { XX } },
6416 { "(bad)", { XX } },
6417 { "(bad)", { XX } },
6418 { "(bad)", { XX } },
6419 { "(bad)", { XX } },
6420 { "(bad)", { XX } },
6421 { "(bad)", { XX } },
6423 { "(bad)", { XX } },
6424 { "(bad)", { XX } },
6425 { "(bad)", { XX } },
6426 { "(bad)", { XX } },
6427 { "(bad)", { XX } },
6428 { "(bad)", { XX } },
6429 { "(bad)", { XX } },
6430 { "(bad)", { XX } },
6432 { "ptest", { XX } },
6433 { "(bad)", { XX } },
6434 { "(bad)", { XX } },
6435 { "(bad)", { XX } },
6436 { "(bad)", { XX } },
6437 { "(bad)", { XX } },
6438 { "(bad)", { XX } },
6439 { "(bad)", { XX } },
6441 { "(bad)", { XX } },
6442 { "(bad)", { XX } },
6443 { "(bad)", { XX } },
6444 { "(bad)", { XX } },
6445 { "(bad)", { XX } },
6446 { "(bad)", { XX } },
6447 { "(bad)", { XX } },
6448 { "(bad)", { XX } },
6450 { "(bad)", { XX } },
6451 { "(bad)", { XX } },
6452 { "(bad)", { XX } },
6453 { "(bad)", { XX } },
6454 { "(bad)", { XX } },
6455 { "(bad)", { XX } },
6456 { "(bad)", { XX } },
6457 { "(bad)", { XX } },
6459 { "(bad)", { XX } },
6460 { "(bad)", { XX } },
6461 { "(bad)", { XX } },
6462 { "(bad)", { XX } },
6463 { "(bad)", { XX } },
6464 { "(bad)", { XX } },
6465 { "(bad)", { XX } },
6466 { "(bad)", { XX } },
6468 { "(bad)", { XX } },
6469 { "phaddbw", { XM, EXq } },
6470 { "phaddbd", { XM, EXq } },
6471 { "phaddbq", { XM, EXq } },
6472 { "(bad)", { XX } },
6473 { "(bad)", { XX } },
6474 { "phaddwd", { XM, EXq } },
6475 { "phaddwq", { XM, EXq } },
6477 { "(bad)", { XX } },
6478 { "(bad)", { XX } },
6479 { "(bad)", { XX } },
6480 { "phadddq", { XM, EXq } },
6481 { "(bad)", { XX } },
6482 { "(bad)", { XX } },
6483 { "(bad)", { XX } },
6484 { "(bad)", { XX } },
6486 { "(bad)", { XX } },
6487 { "phaddubw", { XM, EXq } },
6488 { "phaddubd", { XM, EXq } },
6489 { "phaddubq", { XM, EXq } },
6490 { "(bad)", { XX } },
6491 { "(bad)", { XX } },
6492 { "phadduwd", { XM, EXq } },
6493 { "phadduwq", { XM, EXq } },
6495 { "(bad)", { XX } },
6496 { "(bad)", { XX } },
6497 { "(bad)", { XX } },
6498 { "phaddudq", { XM, EXq } },
6499 { "(bad)", { XX } },
6500 { "(bad)", { XX } },
6501 { "(bad)", { XX } },
6502 { "(bad)", { XX } },
6504 { "(bad)", { XX } },
6505 { "phsubbw", { XM, EXq } },
6506 { "phsubbd", { XM, EXq } },
6507 { "phsubbq", { XM, EXq } },
6508 { "(bad)", { XX } },
6509 { "(bad)", { XX } },
6510 { "(bad)", { XX } },
6511 { "(bad)", { XX } },
6513 { "(bad)", { XX } },
6514 { "(bad)", { XX } },
6515 { "(bad)", { XX } },
6516 { "(bad)", { XX } },
6517 { "(bad)", { XX } },
6518 { "(bad)", { XX } },
6519 { "(bad)", { XX } },
6520 { "(bad)", { XX } },
6522 { "(bad)", { XX } },
6523 { "(bad)", { XX } },
6524 { "(bad)", { XX } },
6525 { "(bad)", { XX } },
6526 { "(bad)", { XX } },
6527 { "(bad)", { XX } },
6528 { "(bad)", { XX } },
6529 { "(bad)", { XX } },
6531 { "(bad)", { XX } },
6532 { "(bad)", { XX } },
6533 { "(bad)", { XX } },
6534 { "(bad)", { XX } },
6535 { "(bad)", { XX } },
6536 { "(bad)", { XX } },
6537 { "(bad)", { XX } },
6538 { "(bad)", { XX } },
6540 { "(bad)", { XX } },
6541 { "(bad)", { XX } },
6542 { "(bad)", { XX } },
6543 { "(bad)", { XX } },
6544 { "(bad)", { XX } },
6545 { "(bad)", { XX } },
6546 { "(bad)", { XX } },
6547 { "(bad)", { XX } },
6549 { "(bad)", { XX } },
6550 { "(bad)", { XX } },
6551 { "(bad)", { XX } },
6552 { "(bad)", { XX } },
6553 { "(bad)", { XX } },
6554 { "(bad)", { XX } },
6555 { "(bad)", { XX } },
6556 { "(bad)", { XX } },
6558 { "(bad)", { XX } },
6559 { "(bad)", { XX } },
6560 { "(bad)", { XX } },
6561 { "(bad)", { XX } },
6562 { "(bad)", { XX } },
6563 { "(bad)", { XX } },
6564 { "(bad)", { XX } },
6565 { "(bad)", { XX } },
6567 { "(bad)", { XX } },
6568 { "(bad)", { XX } },
6569 { "(bad)", { XX } },
6570 { "(bad)", { XX } },
6571 { "(bad)", { XX } },
6572 { "(bad)", { XX } },
6573 { "(bad)", { XX } },
6574 { "(bad)", { XX } },
6576 { "(bad)", { XX } },
6577 { "(bad)", { XX } },
6578 { "(bad)", { XX } },
6579 { "(bad)", { XX } },
6580 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6582 { "(bad)", { XX } },
6583 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6589 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6591 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6598 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6600 { "(bad)", { XX } },
6601 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6607 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6609 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6612 { "(bad)", { XX } },
6613 { "(bad)", { XX } },
6614 { "(bad)", { XX } },
6615 { "(bad)", { XX } },
6616 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6618 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6625 { "(bad)", { XX } },
6626 { "(bad)", { XX } },
6627 { "(bad)", { XX } },
6628 { "(bad)", { XX } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6634 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6636 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6643 { "(bad)", { XX } },
6644 { "(bad)", { XX } },
6645 { "(bad)", { XX } },
6646 { "(bad)", { XX } },
6648 { "(bad)", { XX } },
6649 { "(bad)", { XX } },
6650 { "(bad)", { XX } },
6651 { "(bad)", { XX } },
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6654 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6658 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6660 { "(bad)", { XX } },
6661 { "(bad)", { XX } },
6662 { "(bad)", { XX } },
6663 { "(bad)", { XX } },
6664 { "(bad)", { XX } },
6666 { "(bad)", { XX } },
6667 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6669 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6672 { "(bad)", { XX } },
6673 { "(bad)", { XX } },
6675 { "(bad)", { XX } },
6676 { "(bad)", { XX } },
6677 { "(bad)", { XX } },
6678 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6686 static const struct dis386 xop_table[][256] = {
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6693 { "(bad)", { XX } },
6694 { "(bad)", { XX } },
6695 { "(bad)", { XX } },
6696 { "(bad)", { XX } },
6697 { "(bad)", { XX } },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6702 { "(bad)", { XX } },
6703 { "(bad)", { XX } },
6704 { "(bad)", { XX } },
6705 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6711 { "(bad)", { XX } },
6712 { "(bad)", { XX } },
6713 { "(bad)", { XX } },
6714 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6720 { "(bad)", { XX } },
6721 { "(bad)", { XX } },
6722 { "(bad)", { XX } },
6723 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6729 { "(bad)", { XX } },
6730 { "(bad)", { XX } },
6731 { "(bad)", { XX } },
6732 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6738 { "(bad)", { XX } },
6739 { "(bad)", { XX } },
6740 { "(bad)", { XX } },
6741 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6747 { "(bad)", { XX } },
6748 { "(bad)", { XX } },
6749 { "(bad)", { XX } },
6750 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6756 { "(bad)", { XX } },
6757 { "(bad)", { XX } },
6758 { "(bad)", { XX } },
6759 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6765 { "(bad)", { XX } },
6766 { "(bad)", { XX } },
6767 { "(bad)", { XX } },
6768 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6774 { "(bad)", { XX } },
6775 { "(bad)", { XX } },
6776 { "(bad)", { XX } },
6777 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6783 { "(bad)", { XX } },
6784 { "(bad)", { XX } },
6785 { "(bad)", { XX } },
6786 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6792 { "(bad)", { XX } },
6793 { "(bad)", { XX } },
6794 { "(bad)", { XX } },
6795 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "(bad)", { XX } },
6800 { "(bad)", { XX } },
6801 { "(bad)", { XX } },
6802 { "(bad)", { XX } },
6803 { "(bad)", { XX } },
6804 { "(bad)", { XX } },
6805 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "(bad)", { XX } },
6810 { "(bad)", { XX } },
6811 { "(bad)", { XX } },
6812 { "(bad)", { XX } },
6813 { "(bad)", { XX } },
6814 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "(bad)", { XX } },
6818 { "(bad)", { XX } },
6819 { "(bad)", { XX } },
6820 { "(bad)", { XX } },
6821 { "(bad)", { XX } },
6822 { "(bad)", { XX } },
6823 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "(bad)", { XX } },
6828 { "(bad)", { XX } },
6829 { "(bad)", { XX } },
6830 { "(bad)", { XX } },
6831 { "(bad)", { XX } },
6832 { "(bad)", { XX } },
6834 { "(bad)", { XX } },
6835 { "(bad)", { XX } },
6836 { "(bad)", { XX } },
6837 { "(bad)", { XX } },
6838 { "(bad)", { XX } },
6839 { "vpmacssww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6840 { "vpmacsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6841 { "vpmacssdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6846 { "(bad)", { XX } },
6847 { "(bad)", { XX } },
6848 { "(bad)", { XX } },
6849 { "vpmacssdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6850 { "vpmacssdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6852 { "(bad)", { XX } },
6853 { "(bad)", { XX } },
6854 { "(bad)", { XX } },
6855 { "(bad)", { XX } },
6856 { "(bad)", { XX } },
6857 { "vpmacsww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6858 { "vpmacswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6859 { "vpmacsdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6861 { "(bad)", { XX } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6864 { "(bad)", { XX } },
6865 { "(bad)", { XX } },
6866 { "(bad)", { XX } },
6867 { "vpmacsdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6868 { "vpmacsdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6870 { "(bad)", { XX } },
6871 { "(bad)", { XX } },
6872 { "vpcmov", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6873 { "vpperm", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6874 { "(bad)", { XX } },
6875 { "(bad)", { XX } },
6876 { "vpmadcsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6877 { "(bad)", { XX } },
6879 { "(bad)", { XX } },
6880 { "(bad)", { XX } },
6881 { "(bad)", { XX } },
6882 { "(bad)", { XX } },
6883 { "(bad)", { XX } },
6884 { "(bad)", { XX } },
6885 { "(bad)", { XX } },
6886 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6891 { "(bad)", { XX } },
6892 { "(bad)", { XX } },
6893 { "(bad)", { XX } },
6894 { "vpmadcswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6895 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6900 { "(bad)", { XX } },
6901 { "(bad)", { XX } },
6902 { "(bad)", { XX } },
6903 { "(bad)", { XX } },
6904 { "(bad)", { XX } },
6906 { "vprotb", { XM, Vex_2src_1, Ib } },
6907 { "vprotw", { XM, Vex_2src_1, Ib } },
6908 { "vprotd", { XM, Vex_2src_1, Ib } },
6909 { "vprotq", { XM, Vex_2src_1, Ib } },
6910 { "(bad)", { XX } },
6911 { "(bad)", { XX } },
6912 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6915 { "(bad)", { XX } },
6916 { "(bad)", { XX } },
6917 { "(bad)", { XX } },
6918 { "(bad)", { XX } },
6919 { "vpcomb", { XM, Vex128, EXx, Ib } },
6920 { "vpcomw", { XM, Vex128, EXx, Ib } },
6921 { "vpcomd", { XM, Vex128, EXx, Ib } },
6922 { "vpcomq", { XM, Vex128, EXx, Ib } },
6924 { "(bad)", { XX } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6927 { "(bad)", { XX } },
6928 { "(bad)", { XX } },
6929 { "(bad)", { XX } },
6930 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6933 { "(bad)", { XX } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6936 { "(bad)", { XX } },
6937 { "(bad)", { XX } },
6938 { "(bad)", { XX } },
6939 { "(bad)", { XX } },
6940 { "(bad)", { XX } },
6942 { "(bad)", { XX } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6945 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6947 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6949 { "(bad)", { XX } },
6951 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6954 { "(bad)", { XX } },
6955 { "vpcomub", { XM, Vex128, EXx, Ib } },
6956 { "vpcomuw", { XM, Vex128, EXx, Ib } },
6957 { "vpcomud", { XM, Vex128, EXx, Ib } },
6958 { "vpcomuq", { XM, Vex128, EXx, Ib } },
6960 { "(bad)", { XX } },
6961 { "(bad)", { XX } },
6962 { "(bad)", { XX } },
6963 { "(bad)", { XX } },
6964 { "(bad)", { XX } },
6965 { "(bad)", { XX } },
6966 { "(bad)", { XX } },
6967 { "(bad)", { XX } },
6969 { "(bad)", { XX } },
6970 { "(bad)", { XX } },
6971 { "(bad)", { XX } },
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6974 { "(bad)", { XX } },
6975 { "(bad)", { XX } },
6976 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6985 { "(bad)", { XX } },
6986 { "(bad)", { XX } },
6987 { "(bad)", { XX } },
6988 { "(bad)", { XX } },
6990 { "(bad)", { XX } },
6991 { "(bad)", { XX } },
6992 { "(bad)", { XX } },
6993 { "(bad)", { XX } },
6994 { "(bad)", { XX } },
6995 { "(bad)", { XX } },
6996 { "(bad)", { XX } },
6997 { "(bad)", { XX } },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { REG_TABLE (REG_XOP_LWPCB) },
7002 { "(bad)", { XX } },
7003 { "(bad)", { XX } },
7004 { "(bad)", { XX } },
7005 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7012 { "(bad)", { XX } },
7013 { "(bad)", { XX } },
7014 { "(bad)", { XX } },
7015 { "(bad)", { XX } },
7017 { "(bad)", { XX } },
7018 { "(bad)", { XX } },
7019 { "(bad)", { XX } },
7020 { "(bad)", { XX } },
7021 { "(bad)", { XX } },
7022 { "(bad)", { XX } },
7023 { "(bad)", { XX } },
7024 { "(bad)", { XX } },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7030 { "(bad)", { XX } },
7031 { "(bad)", { XX } },
7032 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7039 { "(bad)", { XX } },
7040 { "(bad)", { XX } },
7041 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7048 { "(bad)", { XX } },
7049 { "(bad)", { XX } },
7050 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7057 { "(bad)", { XX } },
7058 { "(bad)", { XX } },
7059 { "(bad)", { XX } },
7060 { "(bad)", { XX } },
7062 { "(bad)", { XX } },
7063 { "(bad)", { XX } },
7064 { "(bad)", { XX } },
7065 { "(bad)", { XX } },
7066 { "(bad)", { XX } },
7067 { "(bad)", { XX } },
7068 { "(bad)", { XX } },
7069 { "(bad)", { XX } },
7071 { "(bad)", { XX } },
7072 { "(bad)", { XX } },
7073 { "(bad)", { XX } },
7074 { "(bad)", { XX } },
7075 { "(bad)", { XX } },
7076 { "(bad)", { XX } },
7077 { "(bad)", { XX } },
7078 { "(bad)", { XX } },
7080 { "(bad)", { XX } },
7081 { "(bad)", { XX } },
7082 { "(bad)", { XX } },
7083 { "(bad)", { XX } },
7084 { "(bad)", { XX } },
7085 { "(bad)", { XX } },
7086 { "(bad)", { XX } },
7087 { "(bad)", { XX } },
7089 { "(bad)", { XX } },
7090 { "(bad)", { XX } },
7091 { "(bad)", { XX } },
7092 { "(bad)", { XX } },
7093 { "(bad)", { XX } },
7094 { "(bad)", { XX } },
7095 { "(bad)", { XX } },
7096 { "(bad)", { XX } },
7098 { "(bad)", { XX } },
7099 { "(bad)", { XX } },
7100 { "(bad)", { XX } },
7101 { "(bad)", { XX } },
7102 { "(bad)", { XX } },
7103 { "(bad)", { XX } },
7104 { "(bad)", { XX } },
7105 { "(bad)", { XX } },
7107 { "(bad)", { XX } },
7108 { "(bad)", { XX } },
7109 { "(bad)", { XX } },
7110 { "(bad)", { XX } },
7111 { "(bad)", { XX } },
7112 { "(bad)", { XX } },
7113 { "(bad)", { XX } },
7114 { "(bad)", { XX } },
7116 { "(bad)", { XX } },
7117 { "(bad)", { XX } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7120 { "(bad)", { XX } },
7121 { "(bad)", { XX } },
7122 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7125 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80) },
7126 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81) },
7127 { "vfrczss", { XM, EXd } },
7128 { "vfrczsd", { XM, EXq } },
7129 { "(bad)", { XX } },
7130 { "(bad)", { XX } },
7131 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7138 { "(bad)", { XX } },
7139 { "(bad)", { XX } },
7140 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7143 { "vprotb", { XM, Vex_2src_1, Vex_2src_2 } },
7144 { "vprotw", { XM, Vex_2src_1, Vex_2src_2 } },
7145 { "vprotd", { XM, Vex_2src_1, Vex_2src_2 } },
7146 { "vprotq", { XM, Vex_2src_1, Vex_2src_2 } },
7147 { "vpshlb", { XM, Vex_2src_1, Vex_2src_2 } },
7148 { "vpshlw", { XM, Vex_2src_1, Vex_2src_2 } },
7149 { "vpshld", { XM, Vex_2src_1, Vex_2src_2 } },
7150 { "vpshlq", { XM, Vex_2src_1, Vex_2src_2 } },
7152 { "vpshab", { XM, Vex_2src_1, Vex_2src_2 } },
7153 { "vpshaw", { XM, Vex_2src_1, Vex_2src_2 } },
7154 { "vpshad", { XM, Vex_2src_1, Vex_2src_2 } },
7155 { "vpshaq", { XM, Vex_2src_1, Vex_2src_2 } },
7156 { "(bad)", { XX } },
7157 { "(bad)", { XX } },
7158 { "(bad)", { XX } },
7159 { "(bad)", { XX } },
7161 { "(bad)", { XX } },
7162 { "(bad)", { XX } },
7163 { "(bad)", { XX } },
7164 { "(bad)", { XX } },
7165 { "(bad)", { XX } },
7166 { "(bad)", { XX } },
7167 { "(bad)", { XX } },
7168 { "(bad)", { XX } },
7170 { "(bad)", { XX } },
7171 { "(bad)", { XX } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7174 { "(bad)", { XX } },
7175 { "(bad)", { XX } },
7176 { "(bad)", { XX } },
7177 { "(bad)", { XX } },
7179 { "(bad)", { XX } },
7180 { "(bad)", { XX } },
7181 { "(bad)", { XX } },
7182 { "(bad)", { XX } },
7183 { "(bad)", { XX } },
7184 { "(bad)", { XX } },
7185 { "(bad)", { XX } },
7186 { "(bad)", { XX } },
7188 { "(bad)", { XX } },
7189 { "(bad)", { XX } },
7190 { "(bad)", { XX } },
7191 { "(bad)", { XX } },
7192 { "(bad)", { XX } },
7193 { "(bad)", { XX } },
7194 { "(bad)", { XX } },
7195 { "(bad)", { XX } },
7197 { "(bad)", { XX } },
7198 { "vphaddbw", { XM, EXxmm } },
7199 { "vphaddbd", { XM, EXxmm } },
7200 { "vphaddbq", { XM, EXxmm } },
7201 { "(bad)", { XX } },
7202 { "(bad)", { XX } },
7203 { "vphaddwd", { XM, EXxmm } },
7204 { "vphaddwq", { XM, EXxmm } },
7206 { "(bad)", { XX } },
7207 { "(bad)", { XX } },
7208 { "(bad)", { XX } },
7209 { "vphadddq", { XM, EXxmm } },
7210 { "(bad)", { XX } },
7211 { "(bad)", { XX } },
7212 { "(bad)", { XX } },
7213 { "(bad)", { XX } },
7215 { "(bad)", { XX } },
7216 { "vphaddubw", { XM, EXxmm } },
7217 { "vphaddubd", { XM, EXxmm } },
7218 { "vphaddubq", { XM, EXxmm } },
7219 { "(bad)", { XX } },
7220 { "(bad)", { XX } },
7221 { "vphadduwd", { XM, EXxmm } },
7222 { "vphadduwq", { XM, EXxmm } },
7224 { "(bad)", { XX } },
7225 { "(bad)", { XX } },
7226 { "(bad)", { XX } },
7227 { "vphaddudq", { XM, EXxmm } },
7228 { "(bad)", { XX } },
7229 { "(bad)", { XX } },
7230 { "(bad)", { XX } },
7231 { "(bad)", { XX } },
7233 { "(bad)", { XX } },
7234 { "vphsubbw", { XM, EXxmm } },
7235 { "vphsubwd", { XM, EXxmm } },
7236 { "vphsubdq", { XM, EXxmm } },
7237 { "(bad)", { XX } },
7238 { "(bad)", { XX } },
7239 { "(bad)", { XX } },
7240 { "(bad)", { XX } },
7242 { "(bad)", { XX } },
7243 { "(bad)", { XX } },
7244 { "(bad)", { XX } },
7245 { "(bad)", { XX } },
7246 { "(bad)", { XX } },
7247 { "(bad)", { XX } },
7248 { "(bad)", { XX } },
7249 { "(bad)", { XX } },
7251 { "(bad)", { XX } },
7252 { "(bad)", { XX } },
7253 { "(bad)", { XX } },
7254 { "(bad)", { XX } },
7255 { "(bad)", { XX } },
7256 { "(bad)", { XX } },
7257 { "(bad)", { XX } },
7258 { "(bad)", { XX } },
7260 { "(bad)", { XX } },
7261 { "(bad)", { XX } },
7262 { "(bad)", { XX } },
7263 { "(bad)", { XX } },
7264 { "(bad)", { XX } },
7265 { "(bad)", { XX } },
7266 { "(bad)", { XX } },
7267 { "(bad)", { XX } },
7272 { "(bad)", { XX } },
7273 { "(bad)", { XX } },
7274 { "(bad)", { XX } },
7275 { "(bad)", { XX } },
7276 { "(bad)", { XX } },
7277 { "(bad)", { XX } },
7278 { "(bad)", { XX } },
7279 { "(bad)", { XX } },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7285 { "(bad)", { XX } },
7286 { "(bad)", { XX } },
7287 { "(bad)", { XX } },
7288 { "(bad)", { XX } },
7290 { "(bad)", { XX } },
7291 { "(bad)", { XX } },
7292 { REG_TABLE (REG_XOP_LWP) },
7293 { "(bad)", { XX } },
7294 { "(bad)", { XX } },
7295 { "(bad)", { XX } },
7296 { "(bad)", { XX } },
7297 { "(bad)", { XX } },
7299 { "(bad)", { XX } },
7300 { "(bad)", { XX } },
7301 { "(bad)", { XX } },
7302 { "(bad)", { XX } },
7303 { "(bad)", { XX } },
7304 { "(bad)", { XX } },
7305 { "(bad)", { XX } },
7306 { "(bad)", { XX } },
7308 { "(bad)", { XX } },
7309 { "(bad)", { XX } },
7310 { "(bad)", { XX } },
7311 { "(bad)", { XX } },
7312 { "(bad)", { XX } },
7313 { "(bad)", { XX } },
7314 { "(bad)", { XX } },
7315 { "(bad)", { XX } },
7317 { "(bad)", { XX } },
7318 { "(bad)", { XX } },
7319 { "(bad)", { XX } },
7320 { "(bad)", { XX } },
7321 { "(bad)", { XX } },
7322 { "(bad)", { XX } },
7323 { "(bad)", { XX } },
7324 { "(bad)", { XX } },
7326 { "(bad)", { XX } },
7327 { "(bad)", { XX } },
7328 { "(bad)", { XX } },
7329 { "(bad)", { XX } },
7330 { "(bad)", { XX } },
7331 { "(bad)", { XX } },
7332 { "(bad)", { XX } },
7333 { "(bad)", { XX } },
7335 { "(bad)", { XX } },
7336 { "(bad)", { XX } },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7339 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7341 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7348 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7350 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7357 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7359 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7362 { "(bad)", { XX } },
7363 { "(bad)", { XX } },
7364 { "(bad)", { XX } },
7365 { "(bad)", { XX } },
7366 { "(bad)", { XX } },
7367 { "(bad)", { XX } },
7368 { "(bad)", { XX } },
7369 { "(bad)", { XX } },
7371 { "(bad)", { XX } },
7372 { "(bad)", { XX } },
7373 { "(bad)", { XX } },
7374 { "(bad)", { XX } },
7375 { "(bad)", { XX } },
7376 { "(bad)", { XX } },
7377 { "(bad)", { XX } },
7378 { "(bad)", { XX } },
7380 { "(bad)", { XX } },
7381 { "(bad)", { XX } },
7382 { "(bad)", { XX } },
7383 { "(bad)", { XX } },
7384 { "(bad)", { XX } },
7385 { "(bad)", { XX } },
7386 { "(bad)", { XX } },
7387 { "(bad)", { XX } },
7389 { "(bad)", { XX } },
7390 { "(bad)", { XX } },
7391 { "(bad)", { XX } },
7392 { "(bad)", { XX } },
7393 { "(bad)", { XX } },
7394 { "(bad)", { XX } },
7395 { "(bad)", { XX } },
7396 { "(bad)", { XX } },
7398 { "(bad)", { XX } },
7399 { "(bad)", { XX } },
7400 { "(bad)", { XX } },
7401 { "(bad)", { XX } },
7402 { "(bad)", { XX } },
7403 { "(bad)", { XX } },
7404 { "(bad)", { XX } },
7405 { "(bad)", { XX } },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7411 { "(bad)", { XX } },
7412 { "(bad)", { XX } },
7413 { "(bad)", { XX } },
7414 { "(bad)", { XX } },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7420 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7422 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7429 { "(bad)", { XX } },
7430 { "(bad)", { XX } },
7431 { "(bad)", { XX } },
7432 { "(bad)", { XX } },
7434 { "(bad)", { XX } },
7435 { "(bad)", { XX } },
7436 { "(bad)", { XX } },
7437 { "(bad)", { XX } },
7438 { "(bad)", { XX } },
7439 { "(bad)", { XX } },
7440 { "(bad)", { XX } },
7441 { "(bad)", { XX } },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7447 { "(bad)", { XX } },
7448 { "(bad)", { XX } },
7449 { "(bad)", { XX } },
7450 { "(bad)", { XX } },
7452 { "(bad)", { XX } },
7453 { "(bad)", { XX } },
7454 { "(bad)", { XX } },
7455 { "(bad)", { XX } },
7456 { "(bad)", { XX } },
7457 { "(bad)", { XX } },
7458 { "(bad)", { XX } },
7459 { "(bad)", { XX } },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7465 { "(bad)", { XX } },
7466 { "(bad)", { XX } },
7467 { "(bad)", { XX } },
7468 { "(bad)", { XX } },
7470 { "(bad)", { XX } },
7471 { "(bad)", { XX } },
7472 { "(bad)", { XX } },
7473 { "(bad)", { XX } },
7474 { "(bad)", { XX } },
7475 { "(bad)", { XX } },
7476 { "(bad)", { XX } },
7477 { "(bad)", { XX } },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7483 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7485 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { "(bad)", { XX } },
7491 { "(bad)", { XX } },
7492 { "(bad)", { XX } },
7493 { "(bad)", { XX } },
7494 { "(bad)", { XX } },
7495 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7501 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7503 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7506 { "(bad)", { XX } },
7507 { "(bad)", { XX } },
7508 { "(bad)", { XX } },
7509 { "(bad)", { XX } },
7510 { "(bad)", { XX } },
7511 { "(bad)", { XX } },
7512 { "(bad)", { XX } },
7513 { "(bad)", { XX } },
7515 { "(bad)", { XX } },
7516 { "(bad)", { XX } },
7517 { "(bad)", { XX } },
7518 { "(bad)", { XX } },
7519 { "(bad)", { XX } },
7520 { "(bad)", { XX } },
7521 { "(bad)", { XX } },
7522 { "(bad)", { XX } },
7524 { "(bad)", { XX } },
7525 { "(bad)", { XX } },
7526 { "(bad)", { XX } },
7527 { "(bad)", { XX } },
7528 { "(bad)", { XX } },
7529 { "(bad)", { XX } },
7530 { "(bad)", { XX } },
7531 { "(bad)", { XX } },
7533 { "(bad)", { XX } },
7534 { "(bad)", { XX } },
7535 { "(bad)", { XX } },
7536 { "(bad)", { XX } },
7537 { "(bad)", { XX } },
7538 { "(bad)", { XX } },
7539 { "(bad)", { XX } },
7540 { "(bad)", { XX } },
7542 { "(bad)", { XX } },
7543 { "(bad)", { XX } },
7544 { "(bad)", { XX } },
7545 { "(bad)", { XX } },
7546 { "(bad)", { XX } },
7547 { "(bad)", { XX } },
7548 { "(bad)", { XX } },
7549 { "(bad)", { XX } },
7551 { "(bad)", { XX } },
7552 { "(bad)", { XX } },
7553 { "(bad)", { XX } },
7554 { "(bad)", { XX } },
7555 { "(bad)", { XX } },
7556 { "(bad)", { XX } },
7557 { "(bad)", { XX } },
7558 { "(bad)", { XX } },
7562 static const struct dis386 vex_table[][256] = {
7566 { "(bad)", { XX } },
7567 { "(bad)", { XX } },
7568 { "(bad)", { XX } },
7569 { "(bad)", { XX } },
7570 { "(bad)", { XX } },
7571 { "(bad)", { XX } },
7572 { "(bad)", { XX } },
7573 { "(bad)", { XX } },
7575 { "(bad)", { XX } },
7576 { "(bad)", { XX } },
7577 { "(bad)", { XX } },
7578 { "(bad)", { XX } },
7579 { "(bad)", { XX } },
7580 { "(bad)", { XX } },
7581 { "(bad)", { XX } },
7582 { "(bad)", { XX } },
7584 { PREFIX_TABLE (PREFIX_VEX_10) },
7585 { PREFIX_TABLE (PREFIX_VEX_11) },
7586 { PREFIX_TABLE (PREFIX_VEX_12) },
7587 { MOD_TABLE (MOD_VEX_13) },
7588 { VEX_W_TABLE (VEX_W_14) },
7589 { VEX_W_TABLE (VEX_W_15) },
7590 { PREFIX_TABLE (PREFIX_VEX_16) },
7591 { MOD_TABLE (MOD_VEX_17) },
7593 { "(bad)", { XX } },
7594 { "(bad)", { XX } },
7595 { "(bad)", { XX } },
7596 { "(bad)", { XX } },
7597 { "(bad)", { XX } },
7598 { "(bad)", { XX } },
7599 { "(bad)", { XX } },
7600 { "(bad)", { XX } },
7602 { "(bad)", { XX } },
7603 { "(bad)", { XX } },
7604 { "(bad)", { XX } },
7605 { "(bad)", { XX } },
7606 { "(bad)", { XX } },
7607 { "(bad)", { XX } },
7608 { "(bad)", { XX } },
7609 { "(bad)", { XX } },
7611 { VEX_W_TABLE (VEX_W_28) },
7612 { VEX_W_TABLE (VEX_W_29) },
7613 { PREFIX_TABLE (PREFIX_VEX_2A) },
7614 { MOD_TABLE (MOD_VEX_2B) },
7615 { PREFIX_TABLE (PREFIX_VEX_2C) },
7616 { PREFIX_TABLE (PREFIX_VEX_2D) },
7617 { PREFIX_TABLE (PREFIX_VEX_2E) },
7618 { PREFIX_TABLE (PREFIX_VEX_2F) },
7620 { "(bad)", { XX } },
7621 { "(bad)", { XX } },
7622 { "(bad)", { XX } },
7623 { "(bad)", { XX } },
7624 { "(bad)", { XX } },
7625 { "(bad)", { XX } },
7626 { "(bad)", { XX } },
7627 { "(bad)", { XX } },
7629 { "(bad)", { XX } },
7630 { "(bad)", { XX } },
7631 { "(bad)", { XX } },
7632 { "(bad)", { XX } },
7633 { "(bad)", { XX } },
7634 { "(bad)", { XX } },
7635 { "(bad)", { XX } },
7636 { "(bad)", { XX } },
7638 { "(bad)", { XX } },
7639 { "(bad)", { XX } },
7640 { "(bad)", { XX } },
7641 { "(bad)", { XX } },
7642 { "(bad)", { XX } },
7643 { "(bad)", { XX } },
7644 { "(bad)", { XX } },
7645 { "(bad)", { XX } },
7647 { "(bad)", { XX } },
7648 { "(bad)", { XX } },
7649 { "(bad)", { XX } },
7650 { "(bad)", { XX } },
7651 { "(bad)", { XX } },
7652 { "(bad)", { XX } },
7653 { "(bad)", { XX } },
7654 { "(bad)", { XX } },
7656 { MOD_TABLE (MOD_VEX_50) },
7657 { PREFIX_TABLE (PREFIX_VEX_51) },
7658 { PREFIX_TABLE (PREFIX_VEX_52) },
7659 { PREFIX_TABLE (PREFIX_VEX_53) },
7660 { "vandpX", { XM, Vex, EXx } },
7661 { "vandnpX", { XM, Vex, EXx } },
7662 { "vorpX", { XM, Vex, EXx } },
7663 { "vxorpX", { XM, Vex, EXx } },
7665 { PREFIX_TABLE (PREFIX_VEX_58) },
7666 { PREFIX_TABLE (PREFIX_VEX_59) },
7667 { PREFIX_TABLE (PREFIX_VEX_5A) },
7668 { PREFIX_TABLE (PREFIX_VEX_5B) },
7669 { PREFIX_TABLE (PREFIX_VEX_5C) },
7670 { PREFIX_TABLE (PREFIX_VEX_5D) },
7671 { PREFIX_TABLE (PREFIX_VEX_5E) },
7672 { PREFIX_TABLE (PREFIX_VEX_5F) },
7674 { PREFIX_TABLE (PREFIX_VEX_60) },
7675 { PREFIX_TABLE (PREFIX_VEX_61) },
7676 { PREFIX_TABLE (PREFIX_VEX_62) },
7677 { PREFIX_TABLE (PREFIX_VEX_63) },
7678 { PREFIX_TABLE (PREFIX_VEX_64) },
7679 { PREFIX_TABLE (PREFIX_VEX_65) },
7680 { PREFIX_TABLE (PREFIX_VEX_66) },
7681 { PREFIX_TABLE (PREFIX_VEX_67) },
7683 { PREFIX_TABLE (PREFIX_VEX_68) },
7684 { PREFIX_TABLE (PREFIX_VEX_69) },
7685 { PREFIX_TABLE (PREFIX_VEX_6A) },
7686 { PREFIX_TABLE (PREFIX_VEX_6B) },
7687 { PREFIX_TABLE (PREFIX_VEX_6C) },
7688 { PREFIX_TABLE (PREFIX_VEX_6D) },
7689 { PREFIX_TABLE (PREFIX_VEX_6E) },
7690 { PREFIX_TABLE (PREFIX_VEX_6F) },
7692 { PREFIX_TABLE (PREFIX_VEX_70) },
7693 { REG_TABLE (REG_VEX_71) },
7694 { REG_TABLE (REG_VEX_72) },
7695 { REG_TABLE (REG_VEX_73) },
7696 { PREFIX_TABLE (PREFIX_VEX_74) },
7697 { PREFIX_TABLE (PREFIX_VEX_75) },
7698 { PREFIX_TABLE (PREFIX_VEX_76) },
7699 { PREFIX_TABLE (PREFIX_VEX_77) },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7704 { "(bad)", { XX } },
7705 { PREFIX_TABLE (PREFIX_VEX_7C) },
7706 { PREFIX_TABLE (PREFIX_VEX_7D) },
7707 { PREFIX_TABLE (PREFIX_VEX_7E) },
7708 { PREFIX_TABLE (PREFIX_VEX_7F) },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7713 { "(bad)", { XX } },
7714 { "(bad)", { XX } },
7715 { "(bad)", { XX } },
7716 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { "(bad)", { XX } },
7722 { "(bad)", { XX } },
7723 { "(bad)", { XX } },
7724 { "(bad)", { XX } },
7725 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7731 { "(bad)", { XX } },
7732 { "(bad)", { XX } },
7733 { "(bad)", { XX } },
7734 { "(bad)", { XX } },
7735 { "(bad)", { XX } },
7737 { "(bad)", { XX } },
7738 { "(bad)", { XX } },
7739 { "(bad)", { XX } },
7740 { "(bad)", { XX } },
7741 { "(bad)", { XX } },
7742 { "(bad)", { XX } },
7743 { "(bad)", { XX } },
7744 { "(bad)", { XX } },
7746 { "(bad)", { XX } },
7747 { "(bad)", { XX } },
7748 { "(bad)", { XX } },
7749 { "(bad)", { XX } },
7750 { "(bad)", { XX } },
7751 { "(bad)", { XX } },
7752 { "(bad)", { XX } },
7753 { "(bad)", { XX } },
7755 { "(bad)", { XX } },
7756 { "(bad)", { XX } },
7757 { "(bad)", { XX } },
7758 { "(bad)", { XX } },
7759 { "(bad)", { XX } },
7760 { "(bad)", { XX } },
7761 { REG_TABLE (REG_VEX_AE) },
7762 { "(bad)", { XX } },
7764 { "(bad)", { XX } },
7765 { "(bad)", { XX } },
7766 { "(bad)", { XX } },
7767 { "(bad)", { XX } },
7768 { "(bad)", { XX } },
7769 { "(bad)", { XX } },
7770 { "(bad)", { XX } },
7771 { "(bad)", { XX } },
7773 { "(bad)", { XX } },
7774 { "(bad)", { XX } },
7775 { "(bad)", { XX } },
7776 { "(bad)", { XX } },
7777 { "(bad)", { XX } },
7778 { "(bad)", { XX } },
7779 { "(bad)", { XX } },
7780 { "(bad)", { XX } },
7782 { "(bad)", { XX } },
7783 { "(bad)", { XX } },
7784 { PREFIX_TABLE (PREFIX_VEX_C2) },
7785 { "(bad)", { XX } },
7786 { PREFIX_TABLE (PREFIX_VEX_C4) },
7787 { PREFIX_TABLE (PREFIX_VEX_C5) },
7788 { "vshufpX", { XM, Vex, EXx, Ib } },
7789 { "(bad)", { XX } },
7791 { "(bad)", { XX } },
7792 { "(bad)", { XX } },
7793 { "(bad)", { XX } },
7794 { "(bad)", { XX } },
7795 { "(bad)", { XX } },
7796 { "(bad)", { XX } },
7797 { "(bad)", { XX } },
7798 { "(bad)", { XX } },
7800 { PREFIX_TABLE (PREFIX_VEX_D0) },
7801 { PREFIX_TABLE (PREFIX_VEX_D1) },
7802 { PREFIX_TABLE (PREFIX_VEX_D2) },
7803 { PREFIX_TABLE (PREFIX_VEX_D3) },
7804 { PREFIX_TABLE (PREFIX_VEX_D4) },
7805 { PREFIX_TABLE (PREFIX_VEX_D5) },
7806 { PREFIX_TABLE (PREFIX_VEX_D6) },
7807 { PREFIX_TABLE (PREFIX_VEX_D7) },
7809 { PREFIX_TABLE (PREFIX_VEX_D8) },
7810 { PREFIX_TABLE (PREFIX_VEX_D9) },
7811 { PREFIX_TABLE (PREFIX_VEX_DA) },
7812 { PREFIX_TABLE (PREFIX_VEX_DB) },
7813 { PREFIX_TABLE (PREFIX_VEX_DC) },
7814 { PREFIX_TABLE (PREFIX_VEX_DD) },
7815 { PREFIX_TABLE (PREFIX_VEX_DE) },
7816 { PREFIX_TABLE (PREFIX_VEX_DF) },
7818 { PREFIX_TABLE (PREFIX_VEX_E0) },
7819 { PREFIX_TABLE (PREFIX_VEX_E1) },
7820 { PREFIX_TABLE (PREFIX_VEX_E2) },
7821 { PREFIX_TABLE (PREFIX_VEX_E3) },
7822 { PREFIX_TABLE (PREFIX_VEX_E4) },
7823 { PREFIX_TABLE (PREFIX_VEX_E5) },
7824 { PREFIX_TABLE (PREFIX_VEX_E6) },
7825 { PREFIX_TABLE (PREFIX_VEX_E7) },
7827 { PREFIX_TABLE (PREFIX_VEX_E8) },
7828 { PREFIX_TABLE (PREFIX_VEX_E9) },
7829 { PREFIX_TABLE (PREFIX_VEX_EA) },
7830 { PREFIX_TABLE (PREFIX_VEX_EB) },
7831 { PREFIX_TABLE (PREFIX_VEX_EC) },
7832 { PREFIX_TABLE (PREFIX_VEX_ED) },
7833 { PREFIX_TABLE (PREFIX_VEX_EE) },
7834 { PREFIX_TABLE (PREFIX_VEX_EF) },
7836 { PREFIX_TABLE (PREFIX_VEX_F0) },
7837 { PREFIX_TABLE (PREFIX_VEX_F1) },
7838 { PREFIX_TABLE (PREFIX_VEX_F2) },
7839 { PREFIX_TABLE (PREFIX_VEX_F3) },
7840 { PREFIX_TABLE (PREFIX_VEX_F4) },
7841 { PREFIX_TABLE (PREFIX_VEX_F5) },
7842 { PREFIX_TABLE (PREFIX_VEX_F6) },
7843 { PREFIX_TABLE (PREFIX_VEX_F7) },
7845 { PREFIX_TABLE (PREFIX_VEX_F8) },
7846 { PREFIX_TABLE (PREFIX_VEX_F9) },
7847 { PREFIX_TABLE (PREFIX_VEX_FA) },
7848 { PREFIX_TABLE (PREFIX_VEX_FB) },
7849 { PREFIX_TABLE (PREFIX_VEX_FC) },
7850 { PREFIX_TABLE (PREFIX_VEX_FD) },
7851 { PREFIX_TABLE (PREFIX_VEX_FE) },
7852 { "(bad)", { XX } },
7857 { PREFIX_TABLE (PREFIX_VEX_3800) },
7858 { PREFIX_TABLE (PREFIX_VEX_3801) },
7859 { PREFIX_TABLE (PREFIX_VEX_3802) },
7860 { PREFIX_TABLE (PREFIX_VEX_3803) },
7861 { PREFIX_TABLE (PREFIX_VEX_3804) },
7862 { PREFIX_TABLE (PREFIX_VEX_3805) },
7863 { PREFIX_TABLE (PREFIX_VEX_3806) },
7864 { PREFIX_TABLE (PREFIX_VEX_3807) },
7866 { PREFIX_TABLE (PREFIX_VEX_3808) },
7867 { PREFIX_TABLE (PREFIX_VEX_3809) },
7868 { PREFIX_TABLE (PREFIX_VEX_380A) },
7869 { PREFIX_TABLE (PREFIX_VEX_380B) },
7870 { PREFIX_TABLE (PREFIX_VEX_380C) },
7871 { PREFIX_TABLE (PREFIX_VEX_380D) },
7872 { PREFIX_TABLE (PREFIX_VEX_380E) },
7873 { PREFIX_TABLE (PREFIX_VEX_380F) },
7875 { "(bad)", { XX } },
7876 { "(bad)", { XX } },
7877 { "(bad)", { XX } },
7878 { "(bad)", { XX } },
7879 { "(bad)", { XX } },
7880 { "(bad)", { XX } },
7881 { "(bad)", { XX } },
7882 { PREFIX_TABLE (PREFIX_VEX_3817) },
7884 { PREFIX_TABLE (PREFIX_VEX_3818) },
7885 { PREFIX_TABLE (PREFIX_VEX_3819) },
7886 { PREFIX_TABLE (PREFIX_VEX_381A) },
7887 { "(bad)", { XX } },
7888 { PREFIX_TABLE (PREFIX_VEX_381C) },
7889 { PREFIX_TABLE (PREFIX_VEX_381D) },
7890 { PREFIX_TABLE (PREFIX_VEX_381E) },
7891 { "(bad)", { XX } },
7893 { PREFIX_TABLE (PREFIX_VEX_3820) },
7894 { PREFIX_TABLE (PREFIX_VEX_3821) },
7895 { PREFIX_TABLE (PREFIX_VEX_3822) },
7896 { PREFIX_TABLE (PREFIX_VEX_3823) },
7897 { PREFIX_TABLE (PREFIX_VEX_3824) },
7898 { PREFIX_TABLE (PREFIX_VEX_3825) },
7899 { "(bad)", { XX } },
7900 { "(bad)", { XX } },
7902 { PREFIX_TABLE (PREFIX_VEX_3828) },
7903 { PREFIX_TABLE (PREFIX_VEX_3829) },
7904 { PREFIX_TABLE (PREFIX_VEX_382A) },
7905 { PREFIX_TABLE (PREFIX_VEX_382B) },
7906 { PREFIX_TABLE (PREFIX_VEX_382C) },
7907 { PREFIX_TABLE (PREFIX_VEX_382D) },
7908 { PREFIX_TABLE (PREFIX_VEX_382E) },
7909 { PREFIX_TABLE (PREFIX_VEX_382F) },
7911 { PREFIX_TABLE (PREFIX_VEX_3830) },
7912 { PREFIX_TABLE (PREFIX_VEX_3831) },
7913 { PREFIX_TABLE (PREFIX_VEX_3832) },
7914 { PREFIX_TABLE (PREFIX_VEX_3833) },
7915 { PREFIX_TABLE (PREFIX_VEX_3834) },
7916 { PREFIX_TABLE (PREFIX_VEX_3835) },
7917 { "(bad)", { XX } },
7918 { PREFIX_TABLE (PREFIX_VEX_3837) },
7920 { PREFIX_TABLE (PREFIX_VEX_3838) },
7921 { PREFIX_TABLE (PREFIX_VEX_3839) },
7922 { PREFIX_TABLE (PREFIX_VEX_383A) },
7923 { PREFIX_TABLE (PREFIX_VEX_383B) },
7924 { PREFIX_TABLE (PREFIX_VEX_383C) },
7925 { PREFIX_TABLE (PREFIX_VEX_383D) },
7926 { PREFIX_TABLE (PREFIX_VEX_383E) },
7927 { PREFIX_TABLE (PREFIX_VEX_383F) },
7929 { PREFIX_TABLE (PREFIX_VEX_3840) },
7930 { PREFIX_TABLE (PREFIX_VEX_3841) },
7931 { "(bad)", { XX } },
7932 { "(bad)", { XX } },
7933 { "(bad)", { XX } },
7934 { "(bad)", { XX } },
7935 { "(bad)", { XX } },
7936 { "(bad)", { XX } },
7938 { "(bad)", { XX } },
7939 { "(bad)", { XX } },
7940 { "(bad)", { XX } },
7941 { "(bad)", { XX } },
7942 { "(bad)", { XX } },
7943 { "(bad)", { XX } },
7944 { "(bad)", { XX } },
7945 { "(bad)", { XX } },
7947 { "(bad)", { XX } },
7948 { "(bad)", { XX } },
7949 { "(bad)", { XX } },
7950 { "(bad)", { XX } },
7951 { "(bad)", { XX } },
7952 { "(bad)", { XX } },
7953 { "(bad)", { XX } },
7954 { "(bad)", { XX } },
7956 { "(bad)", { XX } },
7957 { "(bad)", { XX } },
7958 { "(bad)", { XX } },
7959 { "(bad)", { XX } },
7960 { "(bad)", { XX } },
7961 { "(bad)", { XX } },
7962 { "(bad)", { XX } },
7963 { "(bad)", { XX } },
7965 { "(bad)", { XX } },
7966 { "(bad)", { XX } },
7967 { "(bad)", { XX } },
7968 { "(bad)", { XX } },
7969 { "(bad)", { XX } },
7970 { "(bad)", { XX } },
7971 { "(bad)", { XX } },
7972 { "(bad)", { XX } },
7974 { "(bad)", { XX } },
7975 { "(bad)", { XX } },
7976 { "(bad)", { XX } },
7977 { "(bad)", { XX } },
7978 { "(bad)", { XX } },
7979 { "(bad)", { XX } },
7980 { "(bad)", { XX } },
7981 { "(bad)", { XX } },
7983 { "(bad)", { XX } },
7984 { "(bad)", { XX } },
7985 { "(bad)", { XX } },
7986 { "(bad)", { XX } },
7987 { "(bad)", { XX } },
7988 { "(bad)", { XX } },
7989 { "(bad)", { XX } },
7990 { "(bad)", { XX } },
7992 { "(bad)", { XX } },
7993 { "(bad)", { XX } },
7994 { "(bad)", { XX } },
7995 { "(bad)", { XX } },
7996 { "(bad)", { XX } },
7997 { "(bad)", { XX } },
7998 { "(bad)", { XX } },
7999 { "(bad)", { XX } },
8001 { "(bad)", { XX } },
8002 { "(bad)", { XX } },
8003 { "(bad)", { XX } },
8004 { "(bad)", { XX } },
8005 { "(bad)", { XX } },
8006 { "(bad)", { XX } },
8007 { "(bad)", { XX } },
8008 { "(bad)", { XX } },
8010 { "(bad)", { XX } },
8011 { "(bad)", { XX } },
8012 { "(bad)", { XX } },
8013 { "(bad)", { XX } },
8014 { "(bad)", { XX } },
8015 { "(bad)", { XX } },
8016 { "(bad)", { XX } },
8017 { "(bad)", { XX } },
8019 { "(bad)", { XX } },
8020 { "(bad)", { XX } },
8021 { "(bad)", { XX } },
8022 { "(bad)", { XX } },
8023 { "(bad)", { XX } },
8024 { "(bad)", { XX } },
8025 { PREFIX_TABLE (PREFIX_VEX_3896) },
8026 { PREFIX_TABLE (PREFIX_VEX_3897) },
8028 { PREFIX_TABLE (PREFIX_VEX_3898) },
8029 { PREFIX_TABLE (PREFIX_VEX_3899) },
8030 { PREFIX_TABLE (PREFIX_VEX_389A) },
8031 { PREFIX_TABLE (PREFIX_VEX_389B) },
8032 { PREFIX_TABLE (PREFIX_VEX_389C) },
8033 { PREFIX_TABLE (PREFIX_VEX_389D) },
8034 { PREFIX_TABLE (PREFIX_VEX_389E) },
8035 { PREFIX_TABLE (PREFIX_VEX_389F) },
8037 { "(bad)", { XX } },
8038 { "(bad)", { XX } },
8039 { "(bad)", { XX } },
8040 { "(bad)", { XX } },
8041 { "(bad)", { XX } },
8042 { "(bad)", { XX } },
8043 { PREFIX_TABLE (PREFIX_VEX_38A6) },
8044 { PREFIX_TABLE (PREFIX_VEX_38A7) },
8046 { PREFIX_TABLE (PREFIX_VEX_38A8) },
8047 { PREFIX_TABLE (PREFIX_VEX_38A9) },
8048 { PREFIX_TABLE (PREFIX_VEX_38AA) },
8049 { PREFIX_TABLE (PREFIX_VEX_38AB) },
8050 { PREFIX_TABLE (PREFIX_VEX_38AC) },
8051 { PREFIX_TABLE (PREFIX_VEX_38AD) },
8052 { PREFIX_TABLE (PREFIX_VEX_38AE) },
8053 { PREFIX_TABLE (PREFIX_VEX_38AF) },
8055 { "(bad)", { XX } },
8056 { "(bad)", { XX } },
8057 { "(bad)", { XX } },
8058 { "(bad)", { XX } },
8059 { "(bad)", { XX } },
8060 { "(bad)", { XX } },
8061 { PREFIX_TABLE (PREFIX_VEX_38B6) },
8062 { PREFIX_TABLE (PREFIX_VEX_38B7) },
8064 { PREFIX_TABLE (PREFIX_VEX_38B8) },
8065 { PREFIX_TABLE (PREFIX_VEX_38B9) },
8066 { PREFIX_TABLE (PREFIX_VEX_38BA) },
8067 { PREFIX_TABLE (PREFIX_VEX_38BB) },
8068 { PREFIX_TABLE (PREFIX_VEX_38BC) },
8069 { PREFIX_TABLE (PREFIX_VEX_38BD) },
8070 { PREFIX_TABLE (PREFIX_VEX_38BE) },
8071 { PREFIX_TABLE (PREFIX_VEX_38BF) },
8073 { "(bad)", { XX } },
8074 { "(bad)", { XX } },
8075 { "(bad)", { XX } },
8076 { "(bad)", { XX } },
8077 { "(bad)", { XX } },
8078 { "(bad)", { XX } },
8079 { "(bad)", { XX } },
8080 { "(bad)", { XX } },
8082 { "(bad)", { XX } },
8083 { "(bad)", { XX } },
8084 { "(bad)", { XX } },
8085 { "(bad)", { XX } },
8086 { "(bad)", { XX } },
8087 { "(bad)", { XX } },
8088 { "(bad)", { XX } },
8089 { "(bad)", { XX } },
8091 { "(bad)", { XX } },
8092 { "(bad)", { XX } },
8093 { "(bad)", { XX } },
8094 { "(bad)", { XX } },
8095 { "(bad)", { XX } },
8096 { "(bad)", { XX } },
8097 { "(bad)", { XX } },
8098 { "(bad)", { XX } },
8100 { "(bad)", { XX } },
8101 { "(bad)", { XX } },
8102 { "(bad)", { XX } },
8103 { PREFIX_TABLE (PREFIX_VEX_38DB) },
8104 { PREFIX_TABLE (PREFIX_VEX_38DC) },
8105 { PREFIX_TABLE (PREFIX_VEX_38DD) },
8106 { PREFIX_TABLE (PREFIX_VEX_38DE) },
8107 { PREFIX_TABLE (PREFIX_VEX_38DF) },
8109 { "(bad)", { XX } },
8110 { "(bad)", { XX } },
8111 { "(bad)", { XX } },
8112 { "(bad)", { XX } },
8113 { "(bad)", { XX } },
8114 { "(bad)", { XX } },
8115 { "(bad)", { XX } },
8116 { "(bad)", { XX } },
8118 { "(bad)", { XX } },
8119 { "(bad)", { XX } },
8120 { "(bad)", { XX } },
8121 { "(bad)", { XX } },
8122 { "(bad)", { XX } },
8123 { "(bad)", { XX } },
8124 { "(bad)", { XX } },
8125 { "(bad)", { XX } },
8127 { "(bad)", { XX } },
8128 { "(bad)", { XX } },
8129 { "(bad)", { XX } },
8130 { "(bad)", { XX } },
8131 { "(bad)", { XX } },
8132 { "(bad)", { XX } },
8133 { "(bad)", { XX } },
8134 { "(bad)", { XX } },
8136 { "(bad)", { XX } },
8137 { "(bad)", { XX } },
8138 { "(bad)", { XX } },
8139 { "(bad)", { XX } },
8140 { "(bad)", { XX } },
8141 { "(bad)", { XX } },
8142 { "(bad)", { XX } },
8143 { "(bad)", { XX } },
8148 { "(bad)", { XX } },
8149 { "(bad)", { XX } },
8150 { "(bad)", { XX } },
8151 { "(bad)", { XX } },
8152 { PREFIX_TABLE (PREFIX_VEX_3A04) },
8153 { PREFIX_TABLE (PREFIX_VEX_3A05) },
8154 { PREFIX_TABLE (PREFIX_VEX_3A06) },
8155 { "(bad)", { XX } },
8157 { PREFIX_TABLE (PREFIX_VEX_3A08) },
8158 { PREFIX_TABLE (PREFIX_VEX_3A09) },
8159 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
8160 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
8161 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
8162 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
8163 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
8164 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
8166 { "(bad)", { XX } },
8167 { "(bad)", { XX } },
8168 { "(bad)", { XX } },
8169 { "(bad)", { XX } },
8170 { PREFIX_TABLE (PREFIX_VEX_3A14) },
8171 { PREFIX_TABLE (PREFIX_VEX_3A15) },
8172 { PREFIX_TABLE (PREFIX_VEX_3A16) },
8173 { PREFIX_TABLE (PREFIX_VEX_3A17) },
8175 { PREFIX_TABLE (PREFIX_VEX_3A18) },
8176 { PREFIX_TABLE (PREFIX_VEX_3A19) },
8177 { "(bad)", { XX } },
8178 { "(bad)", { XX } },
8179 { "(bad)", { XX } },
8180 { "(bad)", { XX } },
8181 { "(bad)", { XX } },
8182 { "(bad)", { XX } },
8184 { PREFIX_TABLE (PREFIX_VEX_3A20) },
8185 { PREFIX_TABLE (PREFIX_VEX_3A21) },
8186 { PREFIX_TABLE (PREFIX_VEX_3A22) },
8187 { "(bad)", { XX } },
8188 { "(bad)", { XX } },
8189 { "(bad)", { XX } },
8190 { "(bad)", { XX } },
8191 { "(bad)", { XX } },
8193 { "(bad)", { XX } },
8194 { "(bad)", { XX } },
8195 { "(bad)", { XX } },
8196 { "(bad)", { XX } },
8197 { "(bad)", { XX } },
8198 { "(bad)", { XX } },
8199 { "(bad)", { XX } },
8200 { "(bad)", { XX } },
8202 { "(bad)", { XX } },
8203 { "(bad)", { XX } },
8204 { "(bad)", { XX } },
8205 { "(bad)", { XX } },
8206 { "(bad)", { XX } },
8207 { "(bad)", { XX } },
8208 { "(bad)", { XX } },
8209 { "(bad)", { XX } },
8211 { "(bad)", { XX } },
8212 { "(bad)", { XX } },
8213 { "(bad)", { XX } },
8214 { "(bad)", { XX } },
8215 { "(bad)", { XX } },
8216 { "(bad)", { XX } },
8217 { "(bad)", { XX } },
8218 { "(bad)", { XX } },
8220 { PREFIX_TABLE (PREFIX_VEX_3A40) },
8221 { PREFIX_TABLE (PREFIX_VEX_3A41) },
8222 { PREFIX_TABLE (PREFIX_VEX_3A42) },
8223 { "(bad)", { XX } },
8224 { PREFIX_TABLE (PREFIX_VEX_3A44) },
8225 { "(bad)", { XX } },
8226 { "(bad)", { XX } },
8227 { "(bad)", { XX } },
8229 { "(bad)", { XX } },
8230 { "(bad)", { XX } },
8231 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
8232 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
8233 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
8234 { "(bad)", { XX } },
8235 { "(bad)", { XX } },
8236 { "(bad)", { XX } },
8238 { "(bad)", { XX } },
8239 { "(bad)", { XX } },
8240 { "(bad)", { XX } },
8241 { "(bad)", { XX } },
8242 { "(bad)", { XX } },
8243 { "(bad)", { XX } },
8244 { "(bad)", { XX } },
8245 { "(bad)", { XX } },
8247 { "(bad)", { XX } },
8248 { "(bad)", { XX } },
8249 { "(bad)", { XX } },
8250 { "(bad)", { XX } },
8251 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
8252 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
8253 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
8254 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
8256 { PREFIX_TABLE (PREFIX_VEX_3A60) },
8257 { PREFIX_TABLE (PREFIX_VEX_3A61) },
8258 { PREFIX_TABLE (PREFIX_VEX_3A62) },
8259 { PREFIX_TABLE (PREFIX_VEX_3A63) },
8260 { "(bad)", { XX } },
8261 { "(bad)", { XX } },
8262 { "(bad)", { XX } },
8263 { "(bad)", { XX } },
8265 { PREFIX_TABLE (PREFIX_VEX_3A68) },
8266 { PREFIX_TABLE (PREFIX_VEX_3A69) },
8267 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
8268 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
8269 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
8270 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
8271 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
8272 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
8274 { "(bad)", { XX } },
8275 { "(bad)", { XX } },
8276 { "(bad)", { XX } },
8277 { "(bad)", { XX } },
8278 { "(bad)", { XX } },
8279 { "(bad)", { XX } },
8280 { "(bad)", { XX } },
8281 { "(bad)", { XX } },
8283 { PREFIX_TABLE (PREFIX_VEX_3A78) },
8284 { PREFIX_TABLE (PREFIX_VEX_3A79) },
8285 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
8286 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
8287 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
8288 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
8289 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
8290 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
8292 { "(bad)", { XX } },
8293 { "(bad)", { XX } },
8294 { "(bad)", { XX } },
8295 { "(bad)", { XX } },
8296 { "(bad)", { XX } },
8297 { "(bad)", { XX } },
8298 { "(bad)", { XX } },
8299 { "(bad)", { XX } },
8301 { "(bad)", { XX } },
8302 { "(bad)", { XX } },
8303 { "(bad)", { XX } },
8304 { "(bad)", { XX } },
8305 { "(bad)", { XX } },
8306 { "(bad)", { XX } },
8307 { "(bad)", { XX } },
8308 { "(bad)", { XX } },
8310 { "(bad)", { XX } },
8311 { "(bad)", { XX } },
8312 { "(bad)", { XX } },
8313 { "(bad)", { XX } },
8314 { "(bad)", { XX } },
8315 { "(bad)", { XX } },
8316 { "(bad)", { XX } },
8317 { "(bad)", { XX } },
8319 { "(bad)", { XX } },
8320 { "(bad)", { XX } },
8321 { "(bad)", { XX } },
8322 { "(bad)", { XX } },
8323 { "(bad)", { XX } },
8324 { "(bad)", { XX } },
8325 { "(bad)", { XX } },
8326 { "(bad)", { XX } },
8328 { "(bad)", { XX } },
8329 { "(bad)", { XX } },
8330 { "(bad)", { XX } },
8331 { "(bad)", { XX } },
8332 { "(bad)", { XX } },
8333 { "(bad)", { XX } },
8334 { "(bad)", { XX } },
8335 { "(bad)", { XX } },
8337 { "(bad)", { XX } },
8338 { "(bad)", { XX } },
8339 { "(bad)", { XX } },
8340 { "(bad)", { XX } },
8341 { "(bad)", { XX } },
8342 { "(bad)", { XX } },
8343 { "(bad)", { XX } },
8344 { "(bad)", { XX } },
8346 { "(bad)", { XX } },
8347 { "(bad)", { XX } },
8348 { "(bad)", { XX } },
8349 { "(bad)", { XX } },
8350 { "(bad)", { XX } },
8351 { "(bad)", { XX } },
8352 { "(bad)", { XX } },
8353 { "(bad)", { XX } },
8355 { "(bad)", { XX } },
8356 { "(bad)", { XX } },
8357 { "(bad)", { XX } },
8358 { "(bad)", { XX } },
8359 { "(bad)", { XX } },
8360 { "(bad)", { XX } },
8361 { "(bad)", { XX } },
8362 { "(bad)", { XX } },
8364 { "(bad)", { XX } },
8365 { "(bad)", { XX } },
8366 { "(bad)", { XX } },
8367 { "(bad)", { XX } },
8368 { "(bad)", { XX } },
8369 { "(bad)", { XX } },
8370 { "(bad)", { XX } },
8371 { "(bad)", { XX } },
8373 { "(bad)", { XX } },
8374 { "(bad)", { XX } },
8375 { "(bad)", { XX } },
8376 { "(bad)", { XX } },
8377 { "(bad)", { XX } },
8378 { "(bad)", { XX } },
8379 { "(bad)", { XX } },
8380 { "(bad)", { XX } },
8382 { "(bad)", { XX } },
8383 { "(bad)", { XX } },
8384 { "(bad)", { XX } },
8385 { "(bad)", { XX } },
8386 { "(bad)", { XX } },
8387 { "(bad)", { XX } },
8388 { "(bad)", { XX } },
8389 { "(bad)", { XX } },
8391 { "(bad)", { XX } },
8392 { "(bad)", { XX } },
8393 { "(bad)", { XX } },
8394 { "(bad)", { XX } },
8395 { "(bad)", { XX } },
8396 { "(bad)", { XX } },
8397 { "(bad)", { XX } },
8398 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
8400 { "(bad)", { XX } },
8401 { "(bad)", { XX } },
8402 { "(bad)", { XX } },
8403 { "(bad)", { XX } },
8404 { "(bad)", { XX } },
8405 { "(bad)", { XX } },
8406 { "(bad)", { XX } },
8407 { "(bad)", { XX } },
8409 { "(bad)", { XX } },
8410 { "(bad)", { XX } },
8411 { "(bad)", { XX } },
8412 { "(bad)", { XX } },
8413 { "(bad)", { XX } },
8414 { "(bad)", { XX } },
8415 { "(bad)", { XX } },
8416 { "(bad)", { XX } },
8418 { "(bad)", { XX } },
8419 { "(bad)", { XX } },
8420 { "(bad)", { XX } },
8421 { "(bad)", { XX } },
8422 { "(bad)", { XX } },
8423 { "(bad)", { XX } },
8424 { "(bad)", { XX } },
8425 { "(bad)", { XX } },
8427 { "(bad)", { XX } },
8428 { "(bad)", { XX } },
8429 { "(bad)", { XX } },
8430 { "(bad)", { XX } },
8431 { "(bad)", { XX } },
8432 { "(bad)", { XX } },
8433 { "(bad)", { XX } },
8434 { "(bad)", { XX } },
8438 static const struct dis386 vex_len_table[][2] = {
8439 /* VEX_LEN_10_P_1 */
8441 { VEX_W_TABLE (VEX_W_10_P_1) },
8442 { "(bad)", { XX } },
8445 /* VEX_LEN_10_P_3 */
8447 { VEX_W_TABLE (VEX_W_10_P_3) },
8448 { "(bad)", { XX } },
8451 /* VEX_LEN_11_P_1 */
8453 { VEX_W_TABLE (VEX_W_11_P_1) },
8454 { "(bad)", { XX } },
8457 /* VEX_LEN_11_P_3 */
8459 { VEX_W_TABLE (VEX_W_11_P_3) },
8460 { "(bad)", { XX } },
8463 /* VEX_LEN_12_P_0_M_0 */
8465 { VEX_W_TABLE (VEX_W_12_P_0_M_0) },
8466 { "(bad)", { XX } },
8469 /* VEX_LEN_12_P_0_M_1 */
8471 { VEX_W_TABLE (VEX_W_12_P_0_M_1) },
8472 { "(bad)", { XX } },
8475 /* VEX_LEN_12_P_2 */
8477 { VEX_W_TABLE (VEX_W_12_P_2) },
8478 { "(bad)", { XX } },
8481 /* VEX_LEN_13_M_0 */
8483 { VEX_W_TABLE (VEX_W_13_M_0) },
8484 { "(bad)", { XX } },
8487 /* VEX_LEN_16_P_0_M_0 */
8489 { VEX_W_TABLE (VEX_W_16_P_0_M_0) },
8490 { "(bad)", { XX } },
8493 /* VEX_LEN_16_P_0_M_1 */
8495 { VEX_W_TABLE (VEX_W_16_P_0_M_1) },
8496 { "(bad)", { XX } },
8499 /* VEX_LEN_16_P_2 */
8501 { VEX_W_TABLE (VEX_W_16_P_2) },
8502 { "(bad)", { XX } },
8505 /* VEX_LEN_17_M_0 */
8507 { VEX_W_TABLE (VEX_W_17_M_0) },
8508 { "(bad)", { XX } },
8511 /* VEX_LEN_2A_P_1 */
8513 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
8514 { "(bad)", { XX } },
8517 /* VEX_LEN_2A_P_3 */
8519 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
8520 { "(bad)", { XX } },
8523 /* VEX_LEN_2C_P_1 */
8525 { "vcvttss2siY", { Gv, EXd } },
8526 { "(bad)", { XX } },
8529 /* VEX_LEN_2C_P_3 */
8531 { "vcvttsd2siY", { Gv, EXq } },
8532 { "(bad)", { XX } },
8535 /* VEX_LEN_2D_P_1 */
8537 { "vcvtss2siY", { Gv, EXd } },
8538 { "(bad)", { XX } },
8541 /* VEX_LEN_2D_P_3 */
8543 { "vcvtsd2siY", { Gv, EXq } },
8544 { "(bad)", { XX } },
8547 /* VEX_LEN_2E_P_0 */
8549 { VEX_W_TABLE (VEX_W_2E_P_0) },
8550 { "(bad)", { XX } },
8553 /* VEX_LEN_2E_P_2 */
8555 { VEX_W_TABLE (VEX_W_2E_P_2) },
8556 { "(bad)", { XX } },
8559 /* VEX_LEN_2F_P_0 */
8561 { VEX_W_TABLE (VEX_W_2F_P_0) },
8562 { "(bad)", { XX } },
8565 /* VEX_LEN_2F_P_2 */
8567 { VEX_W_TABLE (VEX_W_2F_P_2) },
8568 { "(bad)", { XX } },
8571 /* VEX_LEN_51_P_1 */
8573 { VEX_W_TABLE (VEX_W_51_P_1) },
8574 { "(bad)", { XX } },
8577 /* VEX_LEN_51_P_3 */
8579 { VEX_W_TABLE (VEX_W_51_P_3) },
8580 { "(bad)", { XX } },
8583 /* VEX_LEN_52_P_1 */
8585 { VEX_W_TABLE (VEX_W_52_P_1) },
8586 { "(bad)", { XX } },
8589 /* VEX_LEN_53_P_1 */
8591 { VEX_W_TABLE (VEX_W_53_P_1) },
8592 { "(bad)", { XX } },
8595 /* VEX_LEN_58_P_1 */
8597 { VEX_W_TABLE (VEX_W_58_P_1) },
8598 { "(bad)", { XX } },
8601 /* VEX_LEN_58_P_3 */
8603 { VEX_W_TABLE (VEX_W_58_P_3) },
8604 { "(bad)", { XX } },
8607 /* VEX_LEN_59_P_1 */
8609 { VEX_W_TABLE (VEX_W_59_P_1) },
8610 { "(bad)", { XX } },
8613 /* VEX_LEN_59_P_3 */
8615 { VEX_W_TABLE (VEX_W_59_P_3) },
8616 { "(bad)", { XX } },
8619 /* VEX_LEN_5A_P_1 */
8621 { VEX_W_TABLE (VEX_W_5A_P_1) },
8622 { "(bad)", { XX } },
8625 /* VEX_LEN_5A_P_3 */
8627 { VEX_W_TABLE (VEX_W_5A_P_3) },
8628 { "(bad)", { XX } },
8631 /* VEX_LEN_5C_P_1 */
8633 { VEX_W_TABLE (VEX_W_5C_P_1) },
8634 { "(bad)", { XX } },
8637 /* VEX_LEN_5C_P_3 */
8639 { VEX_W_TABLE (VEX_W_5C_P_3) },
8640 { "(bad)", { XX } },
8643 /* VEX_LEN_5D_P_1 */
8645 { VEX_W_TABLE (VEX_W_5D_P_1) },
8646 { "(bad)", { XX } },
8649 /* VEX_LEN_5D_P_3 */
8651 { VEX_W_TABLE (VEX_W_5D_P_3) },
8652 { "(bad)", { XX } },
8655 /* VEX_LEN_5E_P_1 */
8657 { VEX_W_TABLE (VEX_W_5E_P_1) },
8658 { "(bad)", { XX } },
8661 /* VEX_LEN_5E_P_3 */
8663 { VEX_W_TABLE (VEX_W_5E_P_3) },
8664 { "(bad)", { XX } },
8667 /* VEX_LEN_5F_P_1 */
8669 { VEX_W_TABLE (VEX_W_5F_P_1) },
8670 { "(bad)", { XX } },
8673 /* VEX_LEN_5F_P_3 */
8675 { VEX_W_TABLE (VEX_W_5F_P_3) },
8676 { "(bad)", { XX } },
8679 /* VEX_LEN_60_P_2 */
8681 { VEX_W_TABLE (VEX_W_60_P_2) },
8682 { "(bad)", { XX } },
8685 /* VEX_LEN_61_P_2 */
8687 { VEX_W_TABLE (VEX_W_61_P_2) },
8688 { "(bad)", { XX } },
8691 /* VEX_LEN_62_P_2 */
8693 { VEX_W_TABLE (VEX_W_62_P_2) },
8694 { "(bad)", { XX } },
8697 /* VEX_LEN_63_P_2 */
8699 { VEX_W_TABLE (VEX_W_63_P_2) },
8700 { "(bad)", { XX } },
8703 /* VEX_LEN_64_P_2 */
8705 { VEX_W_TABLE (VEX_W_64_P_2) },
8706 { "(bad)", { XX } },
8709 /* VEX_LEN_65_P_2 */
8711 { VEX_W_TABLE (VEX_W_65_P_2) },
8712 { "(bad)", { XX } },
8715 /* VEX_LEN_66_P_2 */
8717 { VEX_W_TABLE (VEX_W_66_P_2) },
8718 { "(bad)", { XX } },
8721 /* VEX_LEN_67_P_2 */
8723 { VEX_W_TABLE (VEX_W_67_P_2) },
8724 { "(bad)", { XX } },
8727 /* VEX_LEN_68_P_2 */
8729 { VEX_W_TABLE (VEX_W_68_P_2) },
8730 { "(bad)", { XX } },
8733 /* VEX_LEN_69_P_2 */
8735 { VEX_W_TABLE (VEX_W_69_P_2) },
8736 { "(bad)", { XX } },
8739 /* VEX_LEN_6A_P_2 */
8741 { VEX_W_TABLE (VEX_W_6A_P_2) },
8742 { "(bad)", { XX } },
8745 /* VEX_LEN_6B_P_2 */
8747 { VEX_W_TABLE (VEX_W_6B_P_2) },
8748 { "(bad)", { XX } },
8751 /* VEX_LEN_6C_P_2 */
8753 { VEX_W_TABLE (VEX_W_6C_P_2) },
8754 { "(bad)", { XX } },
8757 /* VEX_LEN_6D_P_2 */
8759 { VEX_W_TABLE (VEX_W_6D_P_2) },
8760 { "(bad)", { XX } },
8763 /* VEX_LEN_6E_P_2 */
8765 { "vmovK", { XM, Edq } },
8766 { "(bad)", { XX } },
8769 /* VEX_LEN_70_P_1 */
8771 { VEX_W_TABLE (VEX_W_70_P_1) },
8772 { "(bad)", { XX } },
8775 /* VEX_LEN_70_P_2 */
8777 { VEX_W_TABLE (VEX_W_70_P_2) },
8778 { "(bad)", { XX } },
8781 /* VEX_LEN_70_P_3 */
8783 { VEX_W_TABLE (VEX_W_70_P_3) },
8784 { "(bad)", { XX } },
8787 /* VEX_LEN_71_R_2_P_2 */
8789 { VEX_W_TABLE (VEX_W_71_R_2_P_2) },
8790 { "(bad)", { XX } },
8793 /* VEX_LEN_71_R_4_P_2 */
8795 { VEX_W_TABLE (VEX_W_71_R_4_P_2) },
8796 { "(bad)", { XX } },
8799 /* VEX_LEN_71_R_6_P_2 */
8801 { VEX_W_TABLE (VEX_W_71_R_6_P_2) },
8802 { "(bad)", { XX } },
8805 /* VEX_LEN_72_R_2_P_2 */
8807 { VEX_W_TABLE (VEX_W_72_R_2_P_2) },
8808 { "(bad)", { XX } },
8811 /* VEX_LEN_72_R_4_P_2 */
8813 { VEX_W_TABLE (VEX_W_72_R_4_P_2) },
8814 { "(bad)", { XX } },
8817 /* VEX_LEN_72_R_6_P_2 */
8819 { VEX_W_TABLE (VEX_W_72_R_6_P_2) },
8820 { "(bad)", { XX } },
8823 /* VEX_LEN_73_R_2_P_2 */
8825 { VEX_W_TABLE (VEX_W_73_R_2_P_2) },
8826 { "(bad)", { XX } },
8829 /* VEX_LEN_73_R_3_P_2 */
8831 { VEX_W_TABLE (VEX_W_73_R_3_P_2) },
8832 { "(bad)", { XX } },
8835 /* VEX_LEN_73_R_6_P_2 */
8837 { VEX_W_TABLE (VEX_W_73_R_6_P_2) },
8838 { "(bad)", { XX } },
8841 /* VEX_LEN_73_R_7_P_2 */
8843 { VEX_W_TABLE (VEX_W_73_R_7_P_2) },
8844 { "(bad)", { XX } },
8847 /* VEX_LEN_74_P_2 */
8849 { VEX_W_TABLE (VEX_W_74_P_2) },
8850 { "(bad)", { XX } },
8853 /* VEX_LEN_75_P_2 */
8855 { VEX_W_TABLE (VEX_W_75_P_2) },
8856 { "(bad)", { XX } },
8859 /* VEX_LEN_76_P_2 */
8861 { VEX_W_TABLE (VEX_W_76_P_2) },
8862 { "(bad)", { XX } },
8865 /* VEX_LEN_7E_P_1 */
8867 { VEX_W_TABLE (VEX_W_7E_P_1) },
8868 { "(bad)", { XX } },
8871 /* VEX_LEN_7E_P_2 */
8873 { "vmovK", { Edq, XM } },
8874 { "(bad)", { XX } },
8877 /* VEX_LEN_AE_R_2_M_0 */
8879 { VEX_W_TABLE (VEX_W_AE_R_2_M_0) },
8880 { "(bad)", { XX } },
8883 /* VEX_LEN_AE_R_3_M_0 */
8885 { VEX_W_TABLE (VEX_W_AE_R_3_M_0) },
8886 { "(bad)", { XX } },
8889 /* VEX_LEN_C2_P_1 */
8891 { VEX_W_TABLE (VEX_W_C2_P_1) },
8892 { "(bad)", { XX } },
8895 /* VEX_LEN_C2_P_3 */
8897 { VEX_W_TABLE (VEX_W_C2_P_3) },
8898 { "(bad)", { XX } },
8901 /* VEX_LEN_C4_P_2 */
8903 { VEX_W_TABLE (VEX_W_C4_P_2) },
8904 { "(bad)", { XX } },
8907 /* VEX_LEN_C5_P_2 */
8909 { VEX_W_TABLE (VEX_W_C5_P_2) },
8910 { "(bad)", { XX } },
8913 /* VEX_LEN_D1_P_2 */
8915 { VEX_W_TABLE (VEX_W_D1_P_2) },
8916 { "(bad)", { XX } },
8919 /* VEX_LEN_D2_P_2 */
8921 { VEX_W_TABLE (VEX_W_D2_P_2) },
8922 { "(bad)", { XX } },
8925 /* VEX_LEN_D3_P_2 */
8927 { VEX_W_TABLE (VEX_W_D3_P_2) },
8928 { "(bad)", { XX } },
8931 /* VEX_LEN_D4_P_2 */
8933 { VEX_W_TABLE (VEX_W_D4_P_2) },
8934 { "(bad)", { XX } },
8937 /* VEX_LEN_D5_P_2 */
8939 { VEX_W_TABLE (VEX_W_D5_P_2) },
8940 { "(bad)", { XX } },
8943 /* VEX_LEN_D6_P_2 */
8945 { VEX_W_TABLE (VEX_W_D6_P_2) },
8946 { "(bad)", { XX } },
8949 /* VEX_LEN_D7_P_2_M_1 */
8951 { VEX_W_TABLE (VEX_W_D7_P_2_M_1) },
8952 { "(bad)", { XX } },
8955 /* VEX_LEN_D8_P_2 */
8957 { VEX_W_TABLE (VEX_W_D8_P_2) },
8958 { "(bad)", { XX } },
8961 /* VEX_LEN_D9_P_2 */
8963 { VEX_W_TABLE (VEX_W_D9_P_2) },
8964 { "(bad)", { XX } },
8967 /* VEX_LEN_DA_P_2 */
8969 { VEX_W_TABLE (VEX_W_DA_P_2) },
8970 { "(bad)", { XX } },
8973 /* VEX_LEN_DB_P_2 */
8975 { VEX_W_TABLE (VEX_W_DB_P_2) },
8976 { "(bad)", { XX } },
8979 /* VEX_LEN_DC_P_2 */
8981 { VEX_W_TABLE (VEX_W_DC_P_2) },
8982 { "(bad)", { XX } },
8985 /* VEX_LEN_DD_P_2 */
8987 { VEX_W_TABLE (VEX_W_DD_P_2) },
8988 { "(bad)", { XX } },
8991 /* VEX_LEN_DE_P_2 */
8993 { VEX_W_TABLE (VEX_W_DE_P_2) },
8994 { "(bad)", { XX } },
8997 /* VEX_LEN_DF_P_2 */
8999 { VEX_W_TABLE (VEX_W_DF_P_2) },
9000 { "(bad)", { XX } },
9003 /* VEX_LEN_E0_P_2 */
9005 { VEX_W_TABLE (VEX_W_E0_P_2) },
9006 { "(bad)", { XX } },
9009 /* VEX_LEN_E1_P_2 */
9011 { VEX_W_TABLE (VEX_W_E1_P_2) },
9012 { "(bad)", { XX } },
9015 /* VEX_LEN_E2_P_2 */
9017 { VEX_W_TABLE (VEX_W_E2_P_2) },
9018 { "(bad)", { XX } },
9021 /* VEX_LEN_E3_P_2 */
9023 { VEX_W_TABLE (VEX_W_E3_P_2) },
9024 { "(bad)", { XX } },
9027 /* VEX_LEN_E4_P_2 */
9029 { VEX_W_TABLE (VEX_W_E4_P_2) },
9030 { "(bad)", { XX } },
9033 /* VEX_LEN_E5_P_2 */
9035 { VEX_W_TABLE (VEX_W_E5_P_2) },
9036 { "(bad)", { XX } },
9039 /* VEX_LEN_E8_P_2 */
9041 { VEX_W_TABLE (VEX_W_E8_P_2) },
9042 { "(bad)", { XX } },
9045 /* VEX_LEN_E9_P_2 */
9047 { VEX_W_TABLE (VEX_W_E9_P_2) },
9048 { "(bad)", { XX } },
9051 /* VEX_LEN_EA_P_2 */
9053 { VEX_W_TABLE (VEX_W_EA_P_2) },
9054 { "(bad)", { XX } },
9057 /* VEX_LEN_EB_P_2 */
9059 { VEX_W_TABLE (VEX_W_EB_P_2) },
9060 { "(bad)", { XX } },
9063 /* VEX_LEN_EC_P_2 */
9065 { VEX_W_TABLE (VEX_W_EC_P_2) },
9066 { "(bad)", { XX } },
9069 /* VEX_LEN_ED_P_2 */
9071 { VEX_W_TABLE (VEX_W_ED_P_2) },
9072 { "(bad)", { XX } },
9075 /* VEX_LEN_EE_P_2 */
9077 { VEX_W_TABLE (VEX_W_EE_P_2) },
9078 { "(bad)", { XX } },
9081 /* VEX_LEN_EF_P_2 */
9083 { VEX_W_TABLE (VEX_W_EF_P_2) },
9084 { "(bad)", { XX } },
9087 /* VEX_LEN_F1_P_2 */
9089 { VEX_W_TABLE (VEX_W_F1_P_2) },
9090 { "(bad)", { XX } },
9093 /* VEX_LEN_F2_P_2 */
9095 { VEX_W_TABLE (VEX_W_F2_P_2) },
9096 { "(bad)", { XX } },
9099 /* VEX_LEN_F3_P_2 */
9101 { VEX_W_TABLE (VEX_W_F3_P_2) },
9102 { "(bad)", { XX } },
9105 /* VEX_LEN_F4_P_2 */
9107 { VEX_W_TABLE (VEX_W_F4_P_2) },
9108 { "(bad)", { XX } },
9111 /* VEX_LEN_F5_P_2 */
9113 { VEX_W_TABLE (VEX_W_F5_P_2) },
9114 { "(bad)", { XX } },
9117 /* VEX_LEN_F6_P_2 */
9119 { VEX_W_TABLE (VEX_W_F6_P_2) },
9120 { "(bad)", { XX } },
9123 /* VEX_LEN_F7_P_2 */
9125 { VEX_W_TABLE (VEX_W_F7_P_2) },
9126 { "(bad)", { XX } },
9129 /* VEX_LEN_F8_P_2 */
9131 { VEX_W_TABLE (VEX_W_F8_P_2) },
9132 { "(bad)", { XX } },
9135 /* VEX_LEN_F9_P_2 */
9137 { VEX_W_TABLE (VEX_W_F9_P_2) },
9138 { "(bad)", { XX } },
9141 /* VEX_LEN_FA_P_2 */
9143 { VEX_W_TABLE (VEX_W_FA_P_2) },
9144 { "(bad)", { XX } },
9147 /* VEX_LEN_FB_P_2 */
9149 { VEX_W_TABLE (VEX_W_FB_P_2) },
9150 { "(bad)", { XX } },
9153 /* VEX_LEN_FC_P_2 */
9155 { VEX_W_TABLE (VEX_W_FC_P_2) },
9156 { "(bad)", { XX } },
9159 /* VEX_LEN_FD_P_2 */
9161 { VEX_W_TABLE (VEX_W_FD_P_2) },
9162 { "(bad)", { XX } },
9165 /* VEX_LEN_FE_P_2 */
9167 { VEX_W_TABLE (VEX_W_FE_P_2) },
9168 { "(bad)", { XX } },
9171 /* VEX_LEN_3800_P_2 */
9173 { VEX_W_TABLE (VEX_W_3800_P_2) },
9174 { "(bad)", { XX } },
9177 /* VEX_LEN_3801_P_2 */
9179 { VEX_W_TABLE (VEX_W_3801_P_2) },
9180 { "(bad)", { XX } },
9183 /* VEX_LEN_3802_P_2 */
9185 { VEX_W_TABLE (VEX_W_3802_P_2) },
9186 { "(bad)", { XX } },
9189 /* VEX_LEN_3803_P_2 */
9191 { VEX_W_TABLE (VEX_W_3803_P_2) },
9192 { "(bad)", { XX } },
9195 /* VEX_LEN_3804_P_2 */
9197 { VEX_W_TABLE (VEX_W_3804_P_2) },
9198 { "(bad)", { XX } },
9201 /* VEX_LEN_3805_P_2 */
9203 { VEX_W_TABLE (VEX_W_3805_P_2) },
9204 { "(bad)", { XX } },
9207 /* VEX_LEN_3806_P_2 */
9209 { VEX_W_TABLE (VEX_W_3806_P_2) },
9210 { "(bad)", { XX } },
9213 /* VEX_LEN_3807_P_2 */
9215 { VEX_W_TABLE (VEX_W_3807_P_2) },
9216 { "(bad)", { XX } },
9219 /* VEX_LEN_3808_P_2 */
9221 { VEX_W_TABLE (VEX_W_3808_P_2) },
9222 { "(bad)", { XX } },
9225 /* VEX_LEN_3809_P_2 */
9227 { VEX_W_TABLE (VEX_W_3809_P_2) },
9228 { "(bad)", { XX } },
9231 /* VEX_LEN_380A_P_2 */
9233 { VEX_W_TABLE (VEX_W_380A_P_2) },
9234 { "(bad)", { XX } },
9237 /* VEX_LEN_380B_P_2 */
9239 { VEX_W_TABLE (VEX_W_380B_P_2) },
9240 { "(bad)", { XX } },
9243 /* VEX_LEN_3819_P_2_M_0 */
9245 { "(bad)", { XX } },
9246 { VEX_W_TABLE (VEX_W_3819_P_2_M_0) },
9249 /* VEX_LEN_381A_P_2_M_0 */
9251 { "(bad)", { XX } },
9252 { VEX_W_TABLE (VEX_W_381A_P_2_M_0) },
9255 /* VEX_LEN_381C_P_2 */
9257 { VEX_W_TABLE (VEX_W_381C_P_2) },
9258 { "(bad)", { XX } },
9261 /* VEX_LEN_381D_P_2 */
9263 { VEX_W_TABLE (VEX_W_381D_P_2) },
9264 { "(bad)", { XX } },
9267 /* VEX_LEN_381E_P_2 */
9269 { VEX_W_TABLE (VEX_W_381E_P_2) },
9270 { "(bad)", { XX } },
9273 /* VEX_LEN_3820_P_2 */
9275 { VEX_W_TABLE (VEX_W_3820_P_2) },
9276 { "(bad)", { XX } },
9279 /* VEX_LEN_3821_P_2 */
9281 { VEX_W_TABLE (VEX_W_3821_P_2) },
9282 { "(bad)", { XX } },
9285 /* VEX_LEN_3822_P_2 */
9287 { VEX_W_TABLE (VEX_W_3822_P_2) },
9288 { "(bad)", { XX } },
9291 /* VEX_LEN_3823_P_2 */
9293 { VEX_W_TABLE (VEX_W_3823_P_2) },
9294 { "(bad)", { XX } },
9297 /* VEX_LEN_3824_P_2 */
9299 { VEX_W_TABLE (VEX_W_3824_P_2) },
9300 { "(bad)", { XX } },
9303 /* VEX_LEN_3825_P_2 */
9305 { VEX_W_TABLE (VEX_W_3825_P_2) },
9306 { "(bad)", { XX } },
9309 /* VEX_LEN_3828_P_2 */
9311 { VEX_W_TABLE (VEX_W_3828_P_2) },
9312 { "(bad)", { XX } },
9315 /* VEX_LEN_3829_P_2 */
9317 { VEX_W_TABLE (VEX_W_3829_P_2) },
9318 { "(bad)", { XX } },
9321 /* VEX_LEN_382A_P_2_M_0 */
9323 { VEX_W_TABLE (VEX_W_382A_P_2_M_0) },
9324 { "(bad)", { XX } },
9327 /* VEX_LEN_382B_P_2 */
9329 { VEX_W_TABLE (VEX_W_382B_P_2) },
9330 { "(bad)", { XX } },
9333 /* VEX_LEN_3830_P_2 */
9335 { VEX_W_TABLE (VEX_W_3830_P_2) },
9336 { "(bad)", { XX } },
9339 /* VEX_LEN_3831_P_2 */
9341 { VEX_W_TABLE (VEX_W_3831_P_2) },
9342 { "(bad)", { XX } },
9345 /* VEX_LEN_3832_P_2 */
9347 { VEX_W_TABLE (VEX_W_3832_P_2) },
9348 { "(bad)", { XX } },
9351 /* VEX_LEN_3833_P_2 */
9353 { VEX_W_TABLE (VEX_W_3833_P_2) },
9354 { "(bad)", { XX } },
9357 /* VEX_LEN_3834_P_2 */
9359 { VEX_W_TABLE (VEX_W_3834_P_2) },
9360 { "(bad)", { XX } },
9363 /* VEX_LEN_3835_P_2 */
9365 { VEX_W_TABLE (VEX_W_3835_P_2) },
9366 { "(bad)", { XX } },
9369 /* VEX_LEN_3837_P_2 */
9371 { VEX_W_TABLE (VEX_W_3837_P_2) },
9372 { "(bad)", { XX } },
9375 /* VEX_LEN_3838_P_2 */
9377 { VEX_W_TABLE (VEX_W_3838_P_2) },
9378 { "(bad)", { XX } },
9381 /* VEX_LEN_3839_P_2 */
9383 { VEX_W_TABLE (VEX_W_3839_P_2) },
9384 { "(bad)", { XX } },
9387 /* VEX_LEN_383A_P_2 */
9389 { VEX_W_TABLE (VEX_W_383A_P_2) },
9390 { "(bad)", { XX } },
9393 /* VEX_LEN_383B_P_2 */
9395 { VEX_W_TABLE (VEX_W_383B_P_2) },
9396 { "(bad)", { XX } },
9399 /* VEX_LEN_383C_P_2 */
9401 { VEX_W_TABLE (VEX_W_383C_P_2) },
9402 { "(bad)", { XX } },
9405 /* VEX_LEN_383D_P_2 */
9407 { VEX_W_TABLE (VEX_W_383D_P_2) },
9408 { "(bad)", { XX } },
9411 /* VEX_LEN_383E_P_2 */
9413 { VEX_W_TABLE (VEX_W_383E_P_2) },
9414 { "(bad)", { XX } },
9417 /* VEX_LEN_383F_P_2 */
9419 { VEX_W_TABLE (VEX_W_383F_P_2) },
9420 { "(bad)", { XX } },
9423 /* VEX_LEN_3840_P_2 */
9425 { VEX_W_TABLE (VEX_W_3840_P_2) },
9426 { "(bad)", { XX } },
9429 /* VEX_LEN_3841_P_2 */
9431 { VEX_W_TABLE (VEX_W_3841_P_2) },
9432 { "(bad)", { XX } },
9435 /* VEX_LEN_38DB_P_2 */
9437 { VEX_W_TABLE (VEX_W_38DB_P_2) },
9438 { "(bad)", { XX } },
9441 /* VEX_LEN_38DC_P_2 */
9443 { VEX_W_TABLE (VEX_W_38DC_P_2) },
9444 { "(bad)", { XX } },
9447 /* VEX_LEN_38DD_P_2 */
9449 { VEX_W_TABLE (VEX_W_38DD_P_2) },
9450 { "(bad)", { XX } },
9453 /* VEX_LEN_38DE_P_2 */
9455 { VEX_W_TABLE (VEX_W_38DE_P_2) },
9456 { "(bad)", { XX } },
9459 /* VEX_LEN_38DF_P_2 */
9461 { VEX_W_TABLE (VEX_W_38DF_P_2) },
9462 { "(bad)", { XX } },
9465 /* VEX_LEN_3A06_P_2 */
9467 { "(bad)", { XX } },
9468 { VEX_W_TABLE (VEX_W_3A06_P_2) },
9471 /* VEX_LEN_3A0A_P_2 */
9473 { VEX_W_TABLE (VEX_W_3A0A_P_2) },
9474 { "(bad)", { XX } },
9477 /* VEX_LEN_3A0B_P_2 */
9479 { VEX_W_TABLE (VEX_W_3A0B_P_2) },
9480 { "(bad)", { XX } },
9483 /* VEX_LEN_3A0E_P_2 */
9485 { VEX_W_TABLE (VEX_W_3A0E_P_2) },
9486 { "(bad)", { XX } },
9489 /* VEX_LEN_3A0F_P_2 */
9491 { VEX_W_TABLE (VEX_W_3A0F_P_2) },
9492 { "(bad)", { XX } },
9495 /* VEX_LEN_3A14_P_2 */
9497 { VEX_W_TABLE (VEX_W_3A14_P_2) },
9498 { "(bad)", { XX } },
9501 /* VEX_LEN_3A15_P_2 */
9503 { VEX_W_TABLE (VEX_W_3A15_P_2) },
9504 { "(bad)", { XX } },
9507 /* VEX_LEN_3A16_P_2 */
9509 { "vpextrK", { Edq, XM, Ib } },
9510 { "(bad)", { XX } },
9513 /* VEX_LEN_3A17_P_2 */
9515 { "vextractps", { Edqd, XM, Ib } },
9516 { "(bad)", { XX } },
9519 /* VEX_LEN_3A18_P_2 */
9521 { "(bad)", { XX } },
9522 { VEX_W_TABLE (VEX_W_3A18_P_2) },
9525 /* VEX_LEN_3A19_P_2 */
9527 { "(bad)", { XX } },
9528 { VEX_W_TABLE (VEX_W_3A19_P_2) },
9531 /* VEX_LEN_3A20_P_2 */
9533 { VEX_W_TABLE (VEX_W_3A20_P_2) },
9534 { "(bad)", { XX } },
9537 /* VEX_LEN_3A21_P_2 */
9539 { VEX_W_TABLE (VEX_W_3A21_P_2) },
9540 { "(bad)", { XX } },
9543 /* VEX_LEN_3A22_P_2 */
9545 { "vpinsrK", { XM, Vex128, Edq, Ib } },
9546 { "(bad)", { XX } },
9549 /* VEX_LEN_3A41_P_2 */
9551 { VEX_W_TABLE (VEX_W_3A41_P_2) },
9552 { "(bad)", { XX } },
9555 /* VEX_LEN_3A42_P_2 */
9557 { VEX_W_TABLE (VEX_W_3A42_P_2) },
9558 { "(bad)", { XX } },
9561 /* VEX_LEN_3A44_P_2 */
9563 { VEX_W_TABLE (VEX_W_3A44_P_2) },
9564 { "(bad)", { XX } },
9567 /* VEX_LEN_3A4C_P_2 */
9569 { VEX_W_TABLE (VEX_W_3A4C_P_2) },
9570 { "(bad)", { XX } },
9573 /* VEX_LEN_3A60_P_2 */
9575 { VEX_W_TABLE (VEX_W_3A60_P_2) },
9576 { "(bad)", { XX } },
9579 /* VEX_LEN_3A61_P_2 */
9581 { VEX_W_TABLE (VEX_W_3A61_P_2) },
9582 { "(bad)", { XX } },
9585 /* VEX_LEN_3A62_P_2 */
9587 { VEX_W_TABLE (VEX_W_3A62_P_2) },
9588 { "(bad)", { XX } },
9591 /* VEX_LEN_3A63_P_2 */
9593 { VEX_W_TABLE (VEX_W_3A63_P_2) },
9594 { "(bad)", { XX } },
9597 /* VEX_LEN_3A6A_P_2 */
9599 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9600 { "(bad)", { XX } },
9603 /* VEX_LEN_3A6B_P_2 */
9605 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9606 { "(bad)", { XX } },
9609 /* VEX_LEN_3A6E_P_2 */
9611 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9612 { "(bad)", { XX } },
9615 /* VEX_LEN_3A6F_P_2 */
9617 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9618 { "(bad)", { XX } },
9621 /* VEX_LEN_3A7A_P_2 */
9623 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9624 { "(bad)", { XX } },
9627 /* VEX_LEN_3A7B_P_2 */
9629 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9630 { "(bad)", { XX } },
9633 /* VEX_LEN_3A7E_P_2 */
9635 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9636 { "(bad)", { XX } },
9639 /* VEX_LEN_3A7F_P_2 */
9641 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9642 { "(bad)", { XX } },
9645 /* VEX_LEN_3ADF_P_2 */
9647 { VEX_W_TABLE (VEX_W_3ADF_P_2) },
9648 { "(bad)", { XX } },
9651 /* VEX_LEN_XOP_09_80 */
9653 { "vfrczps", { XM, EXxmm } },
9654 { "vfrczps", { XM, EXymmq } },
9657 /* VEX_LEN_XOP_09_81 */
9659 { "vfrczpd", { XM, EXxmm } },
9660 { "vfrczpd", { XM, EXymmq } },
9664 static const struct dis386 vex_w_table[][2] = {
9667 { "vmovups", { XM, EXx } },
9668 { "(bad)", { XX } },
9672 { "vmovss", { XMVex, Vex128, EXd } },
9673 { "(bad)", { XX } },
9677 { "vmovupd", { XM, EXx } },
9678 { "(bad)", { XX } },
9682 { "vmovsd", { XMVex, Vex128, EXq } },
9683 { "(bad)", { XX } },
9687 { "vmovups", { EXxS, XM } },
9688 { "(bad)", { XX } },
9692 { "vmovss", { EXdVexS, Vex128, XM } },
9693 { "(bad)", { XX } },
9697 { "vmovupd", { EXxS, XM } },
9698 { "(bad)", { XX } },
9702 { "vmovsd", { EXqVexS, Vex128, XM } },
9703 { "(bad)", { XX } },
9706 /* VEX_W_12_P_0_M_0 */
9707 { "vmovlps", { XM, Vex128, EXq } },
9708 { "(bad)", { XX } },
9711 /* VEX_W_12_P_0_M_1 */
9712 { "vmovhlps", { XM, Vex128, EXq } },
9713 { "(bad)", { XX } },
9717 { "vmovsldup", { XM, EXx } },
9718 { "(bad)", { XX } },
9722 { "vmovlpd", { XM, Vex128, EXq } },
9723 { "(bad)", { XX } },
9727 { "vmovddup", { XM, EXymmq } },
9728 { "(bad)", { XX } },
9732 { "vmovlpX", { EXq, XM } },
9733 { "(bad)", { XX } },
9737 { "vunpcklpX", { XM, Vex, EXx } },
9738 { "(bad)", { XX } },
9742 { "vunpckhpX", { XM, Vex, EXx } },
9743 { "(bad)", { XX } },
9746 /* VEX_W_16_P_0_M_0 */
9747 { "vmovhps", { XM, Vex128, EXq } },
9748 { "(bad)", { XX } },
9751 /* VEX_W_16_P_0_M_1 */
9752 { "vmovlhps", { XM, Vex128, EXq } },
9753 { "(bad)", { XX } },
9757 { "vmovshdup", { XM, EXx } },
9758 { "(bad)", { XX } },
9762 { "vmovhpd", { XM, Vex128, EXq } },
9763 { "(bad)", { XX } },
9767 { "vmovhpX", { EXq, XM } },
9768 { "(bad)", { XX } },
9772 { "vmovapX", { XM, EXx } },
9773 { "(bad)", { XX } },
9777 { "vmovapX", { EXxS, XM } },
9778 { "(bad)", { XX } },
9782 { "vmovntpX", { Mx, XM } },
9783 { "(bad)", { XX } },
9787 { "vucomiss", { XM, EXd } },
9788 { "(bad)", { XX } },
9792 { "vucomisd", { XM, EXq } },
9793 { "(bad)", { XX } },
9797 { "vcomiss", { XM, EXd } },
9798 { "(bad)", { XX } },
9802 { "vcomisd", { XM, EXq } },
9803 { "(bad)", { XX } },
9807 { "vmovmskpX", { Gdq, XS } },
9808 { "(bad)", { XX } },
9812 { "vsqrtps", { XM, EXx } },
9813 { "(bad)", { XX } },
9817 { "vsqrtss", { XM, Vex128, EXd } },
9818 { "(bad)", { XX } },
9822 { "vsqrtpd", { XM, EXx } },
9823 { "(bad)", { XX } },
9827 { "vsqrtsd", { XM, Vex128, EXq } },
9828 { "(bad)", { XX } },
9832 { "vrsqrtps", { XM, EXx } },
9833 { "(bad)", { XX } },
9837 { "vrsqrtss", { XM, Vex128, EXd } },
9838 { "(bad)", { XX } },
9842 { "vrcpps", { XM, EXx } },
9843 { "(bad)", { XX } },
9847 { "vrcpss", { XM, Vex128, EXd } },
9848 { "(bad)", { XX } },
9852 { "vaddps", { XM, Vex, EXx } },
9853 { "(bad)", { XX } },
9857 { "vaddss", { XM, Vex128, EXd } },
9858 { "(bad)", { XX } },
9862 { "vaddpd", { XM, Vex, EXx } },
9863 { "(bad)", { XX } },
9867 { "vaddsd", { XM, Vex128, EXq } },
9868 { "(bad)", { XX } },
9872 { "vmulps", { XM, Vex, EXx } },
9873 { "(bad)", { XX } },
9877 { "vmulss", { XM, Vex128, EXd } },
9878 { "(bad)", { XX } },
9882 { "vmulpd", { XM, Vex, EXx } },
9883 { "(bad)", { XX } },
9887 { "vmulsd", { XM, Vex128, EXq } },
9888 { "(bad)", { XX } },
9892 { "vcvtps2pd", { XM, EXxmmq } },
9893 { "(bad)", { XX } },
9897 { "vcvtss2sd", { XM, Vex128, EXd } },
9898 { "(bad)", { XX } },
9902 { "vcvtsd2ss", { XM, Vex128, EXq } },
9903 { "(bad)", { XX } },
9907 { "vcvtdq2ps", { XM, EXx } },
9908 { "(bad)", { XX } },
9912 { "vcvttps2dq", { XM, EXx } },
9913 { "(bad)", { XX } },
9917 { "vcvtps2dq", { XM, EXx } },
9918 { "(bad)", { XX } },
9922 { "vsubps", { XM, Vex, EXx } },
9923 { "(bad)", { XX } },
9927 { "vsubss", { XM, Vex128, EXd } },
9928 { "(bad)", { XX } },
9932 { "vsubpd", { XM, Vex, EXx } },
9933 { "(bad)", { XX } },
9937 { "vsubsd", { XM, Vex128, EXq } },
9938 { "(bad)", { XX } },
9942 { "vminps", { XM, Vex, EXx } },
9943 { "(bad)", { XX } },
9947 { "vminss", { XM, Vex128, EXd } },
9948 { "(bad)", { XX } },
9952 { "vminpd", { XM, Vex, EXx } },
9953 { "(bad)", { XX } },
9957 { "vminsd", { XM, Vex128, EXq } },
9958 { "(bad)", { XX } },
9962 { "vdivps", { XM, Vex, EXx } },
9963 { "(bad)", { XX } },
9967 { "vdivss", { XM, Vex128, EXd } },
9968 { "(bad)", { XX } },
9972 { "vdivpd", { XM, Vex, EXx } },
9973 { "(bad)", { XX } },
9977 { "vdivsd", { XM, Vex128, EXq } },
9978 { "(bad)", { XX } },
9982 { "vmaxps", { XM, Vex, EXx } },
9983 { "(bad)", { XX } },
9987 { "vmaxss", { XM, Vex128, EXd } },
9988 { "(bad)", { XX } },
9992 { "vmaxpd", { XM, Vex, EXx } },
9993 { "(bad)", { XX } },
9997 { "vmaxsd", { XM, Vex128, EXq } },
9998 { "(bad)", { XX } },
10002 { "vpunpcklbw", { XM, Vex128, EXx } },
10003 { "(bad)", { XX } },
10007 { "vpunpcklwd", { XM, Vex128, EXx } },
10008 { "(bad)", { XX } },
10012 { "vpunpckldq", { XM, Vex128, EXx } },
10013 { "(bad)", { XX } },
10017 { "vpacksswb", { XM, Vex128, EXx } },
10018 { "(bad)", { XX } },
10022 { "vpcmpgtb", { XM, Vex128, EXx } },
10023 { "(bad)", { XX } },
10027 { "vpcmpgtw", { XM, Vex128, EXx } },
10028 { "(bad)", { XX } },
10032 { "vpcmpgtd", { XM, Vex128, EXx } },
10033 { "(bad)", { XX } },
10037 { "vpackuswb", { XM, Vex128, EXx } },
10038 { "(bad)", { XX } },
10042 { "vpunpckhbw", { XM, Vex128, EXx } },
10043 { "(bad)", { XX } },
10047 { "vpunpckhwd", { XM, Vex128, EXx } },
10048 { "(bad)", { XX } },
10052 { "vpunpckhdq", { XM, Vex128, EXx } },
10053 { "(bad)", { XX } },
10057 { "vpackssdw", { XM, Vex128, EXx } },
10058 { "(bad)", { XX } },
10062 { "vpunpcklqdq", { XM, Vex128, EXx } },
10063 { "(bad)", { XX } },
10067 { "vpunpckhqdq", { XM, Vex128, EXx } },
10068 { "(bad)", { XX } },
10072 { "vmovdqu", { XM, EXx } },
10073 { "(bad)", { XX } },
10077 { "vmovdqa", { XM, EXx } },
10078 { "(bad)", { XX } },
10082 { "vpshufhw", { XM, EXx, Ib } },
10083 { "(bad)", { XX } },
10087 { "vpshufd", { XM, EXx, Ib } },
10088 { "(bad)", { XX } },
10092 { "vpshuflw", { XM, EXx, Ib } },
10093 { "(bad)", { XX } },
10096 /* VEX_W_71_R_2_P_2 */
10097 { "vpsrlw", { Vex128, XS, Ib } },
10098 { "(bad)", { XX } },
10101 /* VEX_W_71_R_4_P_2 */
10102 { "vpsraw", { Vex128, XS, Ib } },
10103 { "(bad)", { XX } },
10106 /* VEX_W_71_R_6_P_2 */
10107 { "vpsllw", { Vex128, XS, Ib } },
10108 { "(bad)", { XX } },
10111 /* VEX_W_72_R_2_P_2 */
10112 { "vpsrld", { Vex128, XS, Ib } },
10113 { "(bad)", { XX } },
10116 /* VEX_W_72_R_4_P_2 */
10117 { "vpsrad", { Vex128, XS, Ib } },
10118 { "(bad)", { XX } },
10121 /* VEX_W_72_R_6_P_2 */
10122 { "vpslld", { Vex128, XS, Ib } },
10123 { "(bad)", { XX } },
10126 /* VEX_W_73_R_2_P_2 */
10127 { "vpsrlq", { Vex128, XS, Ib } },
10128 { "(bad)", { XX } },
10131 /* VEX_W_73_R_3_P_2 */
10132 { "vpsrldq", { Vex128, XS, Ib } },
10133 { "(bad)", { XX } },
10136 /* VEX_W_73_R_6_P_2 */
10137 { "vpsllq", { Vex128, XS, Ib } },
10138 { "(bad)", { XX } },
10141 /* VEX_W_73_R_7_P_2 */
10142 { "vpslldq", { Vex128, XS, Ib } },
10143 { "(bad)", { XX } },
10147 { "vpcmpeqb", { XM, Vex128, EXx } },
10148 { "(bad)", { XX } },
10152 { "vpcmpeqw", { XM, Vex128, EXx } },
10153 { "(bad)", { XX } },
10157 { "vpcmpeqd", { XM, Vex128, EXx } },
10158 { "(bad)", { XX } },
10163 { "(bad)", { XX } },
10167 { "vhaddpd", { XM, Vex, EXx } },
10168 { "(bad)", { XX } },
10172 { "vhaddps", { XM, Vex, EXx } },
10173 { "(bad)", { XX } },
10177 { "vhsubpd", { XM, Vex, EXx } },
10178 { "(bad)", { XX } },
10182 { "vhsubps", { XM, Vex, EXx } },
10183 { "(bad)", { XX } },
10187 { "vmovq", { XM, EXq } },
10188 { "(bad)", { XX } },
10192 { "vmovdqu", { EXxS, XM } },
10193 { "(bad)", { XX } },
10197 { "vmovdqa", { EXxS, XM } },
10198 { "(bad)", { XX } },
10201 /* VEX_W_AE_R_2_M_0 */
10202 { "vldmxcsr", { Md } },
10203 { "(bad)", { XX } },
10206 /* VEX_W_AE_R_3_M_0 */
10207 { "vstmxcsr", { Md } },
10208 { "(bad)", { XX } },
10212 { "vcmpps", { XM, Vex, EXx, VCMP } },
10213 { "(bad)", { XX } },
10217 { "vcmpss", { XM, Vex128, EXd, VCMP } },
10218 { "(bad)", { XX } },
10222 { "vcmppd", { XM, Vex, EXx, VCMP } },
10223 { "(bad)", { XX } },
10227 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
10228 { "(bad)", { XX } },
10232 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
10233 { "(bad)", { XX } },
10237 { "vpextrw", { Gdq, XS, Ib } },
10238 { "(bad)", { XX } },
10242 { "vaddsubpd", { XM, Vex, EXx } },
10243 { "(bad)", { XX } },
10247 { "vaddsubps", { XM, Vex, EXx } },
10248 { "(bad)", { XX } },
10252 { "vpsrlw", { XM, Vex128, EXx } },
10253 { "(bad)", { XX } },
10257 { "vpsrld", { XM, Vex128, EXx } },
10258 { "(bad)", { XX } },
10262 { "vpsrlq", { XM, Vex128, EXx } },
10263 { "(bad)", { XX } },
10267 { "vpaddq", { XM, Vex128, EXx } },
10268 { "(bad)", { XX } },
10272 { "vpmullw", { XM, Vex128, EXx } },
10273 { "(bad)", { XX } },
10277 { "vmovq", { EXqS, XM } },
10278 { "(bad)", { XX } },
10281 /* VEX_W_D7_P_2_M_1 */
10282 { "vpmovmskb", { Gdq, XS } },
10283 { "(bad)", { XX } },
10287 { "vpsubusb", { XM, Vex128, EXx } },
10288 { "(bad)", { XX } },
10292 { "vpsubusw", { XM, Vex128, EXx } },
10293 { "(bad)", { XX } },
10297 { "vpminub", { XM, Vex128, EXx } },
10298 { "(bad)", { XX } },
10302 { "vpand", { XM, Vex128, EXx } },
10303 { "(bad)", { XX } },
10307 { "vpaddusb", { XM, Vex128, EXx } },
10308 { "(bad)", { XX } },
10312 { "vpaddusw", { XM, Vex128, EXx } },
10313 { "(bad)", { XX } },
10317 { "vpmaxub", { XM, Vex128, EXx } },
10318 { "(bad)", { XX } },
10322 { "vpandn", { XM, Vex128, EXx } },
10323 { "(bad)", { XX } },
10327 { "vpavgb", { XM, Vex128, EXx } },
10328 { "(bad)", { XX } },
10332 { "vpsraw", { XM, Vex128, EXx } },
10333 { "(bad)", { XX } },
10337 { "vpsrad", { XM, Vex128, EXx } },
10338 { "(bad)", { XX } },
10342 { "vpavgw", { XM, Vex128, EXx } },
10343 { "(bad)", { XX } },
10347 { "vpmulhuw", { XM, Vex128, EXx } },
10348 { "(bad)", { XX } },
10352 { "vpmulhw", { XM, Vex128, EXx } },
10353 { "(bad)", { XX } },
10357 { "vcvtdq2pd", { XM, EXxmmq } },
10358 { "(bad)", { XX } },
10362 { "vcvttpd2dq%XY", { XMM, EXx } },
10363 { "(bad)", { XX } },
10367 { "vcvtpd2dq%XY", { XMM, EXx } },
10368 { "(bad)", { XX } },
10371 /* VEX_W_E7_P_2_M_0 */
10372 { "vmovntdq", { Mx, XM } },
10373 { "(bad)", { XX } },
10377 { "vpsubsb", { XM, Vex128, EXx } },
10378 { "(bad)", { XX } },
10382 { "vpsubsw", { XM, Vex128, EXx } },
10383 { "(bad)", { XX } },
10387 { "vpminsw", { XM, Vex128, EXx } },
10388 { "(bad)", { XX } },
10392 { "vpor", { XM, Vex128, EXx } },
10393 { "(bad)", { XX } },
10397 { "vpaddsb", { XM, Vex128, EXx } },
10398 { "(bad)", { XX } },
10402 { "vpaddsw", { XM, Vex128, EXx } },
10403 { "(bad)", { XX } },
10407 { "vpmaxsw", { XM, Vex128, EXx } },
10408 { "(bad)", { XX } },
10412 { "vpxor", { XM, Vex128, EXx } },
10413 { "(bad)", { XX } },
10416 /* VEX_W_F0_P_3_M_0 */
10417 { "vlddqu", { XM, M } },
10418 { "(bad)", { XX } },
10422 { "vpsllw", { XM, Vex128, EXx } },
10423 { "(bad)", { XX } },
10427 { "vpslld", { XM, Vex128, EXx } },
10428 { "(bad)", { XX } },
10432 { "vpsllq", { XM, Vex128, EXx } },
10433 { "(bad)", { XX } },
10437 { "vpmuludq", { XM, Vex128, EXx } },
10438 { "(bad)", { XX } },
10442 { "vpmaddwd", { XM, Vex128, EXx } },
10443 { "(bad)", { XX } },
10447 { "vpsadbw", { XM, Vex128, EXx } },
10448 { "(bad)", { XX } },
10452 { "vmaskmovdqu", { XM, XS } },
10453 { "(bad)", { XX } },
10457 { "vpsubb", { XM, Vex128, EXx } },
10458 { "(bad)", { XX } },
10462 { "vpsubw", { XM, Vex128, EXx } },
10463 { "(bad)", { XX } },
10467 { "vpsubd", { XM, Vex128, EXx } },
10468 { "(bad)", { XX } },
10472 { "vpsubq", { XM, Vex128, EXx } },
10473 { "(bad)", { XX } },
10477 { "vpaddb", { XM, Vex128, EXx } },
10478 { "(bad)", { XX } },
10482 { "vpaddw", { XM, Vex128, EXx } },
10483 { "(bad)", { XX } },
10487 { "vpaddd", { XM, Vex128, EXx } },
10488 { "(bad)", { XX } },
10491 /* VEX_W_3800_P_2 */
10492 { "vpshufb", { XM, Vex128, EXx } },
10493 { "(bad)", { XX } },
10496 /* VEX_W_3801_P_2 */
10497 { "vphaddw", { XM, Vex128, EXx } },
10498 { "(bad)", { XX } },
10501 /* VEX_W_3802_P_2 */
10502 { "vphaddd", { XM, Vex128, EXx } },
10503 { "(bad)", { XX } },
10506 /* VEX_W_3803_P_2 */
10507 { "vphaddsw", { XM, Vex128, EXx } },
10508 { "(bad)", { XX } },
10511 /* VEX_W_3804_P_2 */
10512 { "vpmaddubsw", { XM, Vex128, EXx } },
10513 { "(bad)", { XX } },
10516 /* VEX_W_3805_P_2 */
10517 { "vphsubw", { XM, Vex128, EXx } },
10518 { "(bad)", { XX } },
10521 /* VEX_W_3806_P_2 */
10522 { "vphsubd", { XM, Vex128, EXx } },
10523 { "(bad)", { XX } },
10526 /* VEX_W_3807_P_2 */
10527 { "vphsubsw", { XM, Vex128, EXx } },
10528 { "(bad)", { XX } },
10531 /* VEX_W_3808_P_2 */
10532 { "vpsignb", { XM, Vex128, EXx } },
10533 { "(bad)", { XX } },
10536 /* VEX_W_3809_P_2 */
10537 { "vpsignw", { XM, Vex128, EXx } },
10538 { "(bad)", { XX } },
10541 /* VEX_W_380A_P_2 */
10542 { "vpsignd", { XM, Vex128, EXx } },
10543 { "(bad)", { XX } },
10546 /* VEX_W_380B_P_2 */
10547 { "vpmulhrsw", { XM, Vex128, EXx } },
10548 { "(bad)", { XX } },
10551 /* VEX_W_380C_P_2 */
10552 { "vpermilps", { XM, Vex, EXx } },
10553 { "(bad)", { XX } },
10556 /* VEX_W_380D_P_2 */
10557 { "vpermilpd", { XM, Vex, EXx } },
10558 { "(bad)", { XX } },
10561 /* VEX_W_380E_P_2 */
10562 { "vtestps", { XM, EXx } },
10563 { "(bad)", { XX } },
10566 /* VEX_W_380F_P_2 */
10567 { "vtestpd", { XM, EXx } },
10568 { "(bad)", { XX } },
10571 /* VEX_W_3817_P_2 */
10572 { "vptest", { XM, EXx } },
10573 { "(bad)", { XX } },
10576 /* VEX_W_3818_P_2_M_0 */
10577 { "vbroadcastss", { XM, Md } },
10578 { "(bad)", { XX } },
10581 /* VEX_W_3819_P_2_M_0 */
10582 { "vbroadcastsd", { XM, Mq } },
10583 { "(bad)", { XX } },
10586 /* VEX_W_381A_P_2_M_0 */
10587 { "vbroadcastf128", { XM, Mxmm } },
10588 { "(bad)", { XX } },
10591 /* VEX_W_381C_P_2 */
10592 { "vpabsb", { XM, EXx } },
10593 { "(bad)", { XX } },
10596 /* VEX_W_381D_P_2 */
10597 { "vpabsw", { XM, EXx } },
10598 { "(bad)", { XX } },
10601 /* VEX_W_381E_P_2 */
10602 { "vpabsd", { XM, EXx } },
10603 { "(bad)", { XX } },
10606 /* VEX_W_3820_P_2 */
10607 { "vpmovsxbw", { XM, EXq } },
10608 { "(bad)", { XX } },
10611 /* VEX_W_3821_P_2 */
10612 { "vpmovsxbd", { XM, EXd } },
10613 { "(bad)", { XX } },
10616 /* VEX_W_3822_P_2 */
10617 { "vpmovsxbq", { XM, EXw } },
10618 { "(bad)", { XX } },
10621 /* VEX_W_3823_P_2 */
10622 { "vpmovsxwd", { XM, EXq } },
10623 { "(bad)", { XX } },
10626 /* VEX_W_3824_P_2 */
10627 { "vpmovsxwq", { XM, EXd } },
10628 { "(bad)", { XX } },
10631 /* VEX_W_3825_P_2 */
10632 { "vpmovsxdq", { XM, EXq } },
10633 { "(bad)", { XX } },
10636 /* VEX_W_3828_P_2 */
10637 { "vpmuldq", { XM, Vex128, EXx } },
10638 { "(bad)", { XX } },
10641 /* VEX_W_3829_P_2 */
10642 { "vpcmpeqq", { XM, Vex128, EXx } },
10643 { "(bad)", { XX } },
10646 /* VEX_W_382A_P_2_M_0 */
10647 { "vmovntdqa", { XM, Mx } },
10648 { "(bad)", { XX } },
10651 /* VEX_W_382B_P_2 */
10652 { "vpackusdw", { XM, Vex128, EXx } },
10653 { "(bad)", { XX } },
10656 /* VEX_W_382C_P_2_M_0 */
10657 { "vmaskmovps", { XM, Vex, Mx } },
10658 { "(bad)", { XX } },
10661 /* VEX_W_382D_P_2_M_0 */
10662 { "vmaskmovpd", { XM, Vex, Mx } },
10663 { "(bad)", { XX } },
10666 /* VEX_W_382E_P_2_M_0 */
10667 { "vmaskmovps", { Mx, Vex, XM } },
10668 { "(bad)", { XX } },
10671 /* VEX_W_382F_P_2_M_0 */
10672 { "vmaskmovpd", { Mx, Vex, XM } },
10673 { "(bad)", { XX } },
10676 /* VEX_W_3830_P_2 */
10677 { "vpmovzxbw", { XM, EXq } },
10678 { "(bad)", { XX } },
10681 /* VEX_W_3831_P_2 */
10682 { "vpmovzxbd", { XM, EXd } },
10683 { "(bad)", { XX } },
10686 /* VEX_W_3832_P_2 */
10687 { "vpmovzxbq", { XM, EXw } },
10688 { "(bad)", { XX } },
10691 /* VEX_W_3833_P_2 */
10692 { "vpmovzxwd", { XM, EXq } },
10693 { "(bad)", { XX } },
10696 /* VEX_W_3834_P_2 */
10697 { "vpmovzxwq", { XM, EXd } },
10698 { "(bad)", { XX } },
10701 /* VEX_W_3835_P_2 */
10702 { "vpmovzxdq", { XM, EXq } },
10703 { "(bad)", { XX } },
10706 /* VEX_W_3837_P_2 */
10707 { "vpcmpgtq", { XM, Vex128, EXx } },
10708 { "(bad)", { XX } },
10711 /* VEX_W_3838_P_2 */
10712 { "vpminsb", { XM, Vex128, EXx } },
10713 { "(bad)", { XX } },
10716 /* VEX_W_3839_P_2 */
10717 { "vpminsd", { XM, Vex128, EXx } },
10718 { "(bad)", { XX } },
10721 /* VEX_W_383A_P_2 */
10722 { "vpminuw", { XM, Vex128, EXx } },
10723 { "(bad)", { XX } },
10726 /* VEX_W_383B_P_2 */
10727 { "vpminud", { XM, Vex128, EXx } },
10728 { "(bad)", { XX } },
10731 /* VEX_W_383C_P_2 */
10732 { "vpmaxsb", { XM, Vex128, EXx } },
10733 { "(bad)", { XX } },
10736 /* VEX_W_383D_P_2 */
10737 { "vpmaxsd", { XM, Vex128, EXx } },
10738 { "(bad)", { XX } },
10741 /* VEX_W_383E_P_2 */
10742 { "vpmaxuw", { XM, Vex128, EXx } },
10743 { "(bad)", { XX } },
10746 /* VEX_W_383F_P_2 */
10747 { "vpmaxud", { XM, Vex128, EXx } },
10748 { "(bad)", { XX } },
10751 /* VEX_W_3840_P_2 */
10752 { "vpmulld", { XM, Vex128, EXx } },
10753 { "(bad)", { XX } },
10756 /* VEX_W_3841_P_2 */
10757 { "vphminposuw", { XM, EXx } },
10758 { "(bad)", { XX } },
10761 /* VEX_W_38DB_P_2 */
10762 { "vaesimc", { XM, EXx } },
10763 { "(bad)", { XX } },
10766 /* VEX_W_38DC_P_2 */
10767 { "vaesenc", { XM, Vex128, EXx } },
10768 { "(bad)", { XX } },
10771 /* VEX_W_38DD_P_2 */
10772 { "vaesenclast", { XM, Vex128, EXx } },
10773 { "(bad)", { XX } },
10776 /* VEX_W_38DE_P_2 */
10777 { "vaesdec", { XM, Vex128, EXx } },
10778 { "(bad)", { XX } },
10781 /* VEX_W_38DF_P_2 */
10782 { "vaesdeclast", { XM, Vex128, EXx } },
10783 { "(bad)", { XX } },
10786 /* VEX_W_3A04_P_2 */
10787 { "vpermilps", { XM, EXx, Ib } },
10788 { "(bad)", { XX } },
10791 /* VEX_W_3A05_P_2 */
10792 { "vpermilpd", { XM, EXx, Ib } },
10793 { "(bad)", { XX } },
10796 /* VEX_W_3A06_P_2 */
10797 { "vperm2f128", { XM, Vex256, EXx, Ib } },
10798 { "(bad)", { XX } },
10801 /* VEX_W_3A08_P_2 */
10802 { "vroundps", { XM, EXx, Ib } },
10803 { "(bad)", { XX } },
10806 /* VEX_W_3A09_P_2 */
10807 { "vroundpd", { XM, EXx, Ib } },
10808 { "(bad)", { XX } },
10811 /* VEX_W_3A0A_P_2 */
10812 { "vroundss", { XM, Vex128, EXd, Ib } },
10813 { "(bad)", { XX } },
10816 /* VEX_W_3A0B_P_2 */
10817 { "vroundsd", { XM, Vex128, EXq, Ib } },
10818 { "(bad)", { XX } },
10821 /* VEX_W_3A0C_P_2 */
10822 { "vblendps", { XM, Vex, EXx, Ib } },
10823 { "(bad)", { XX } },
10826 /* VEX_W_3A0D_P_2 */
10827 { "vblendpd", { XM, Vex, EXx, Ib } },
10828 { "(bad)", { XX } },
10831 /* VEX_W_3A0E_P_2 */
10832 { "vpblendw", { XM, Vex128, EXx, Ib } },
10833 { "(bad)", { XX } },
10836 /* VEX_W_3A0F_P_2 */
10837 { "vpalignr", { XM, Vex128, EXx, Ib } },
10838 { "(bad)", { XX } },
10841 /* VEX_W_3A14_P_2 */
10842 { "vpextrb", { Edqb, XM, Ib } },
10843 { "(bad)", { XX } },
10846 /* VEX_W_3A15_P_2 */
10847 { "vpextrw", { Edqw, XM, Ib } },
10848 { "(bad)", { XX } },
10851 /* VEX_W_3A18_P_2 */
10852 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
10853 { "(bad)", { XX } },
10856 /* VEX_W_3A19_P_2 */
10857 { "vextractf128", { EXxmm, XM, Ib } },
10858 { "(bad)", { XX } },
10861 /* VEX_W_3A20_P_2 */
10862 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
10863 { "(bad)", { XX } },
10866 /* VEX_W_3A21_P_2 */
10867 { "vinsertps", { XM, Vex128, EXd, Ib } },
10868 { "(bad)", { XX } },
10871 /* VEX_W_3A40_P_2 */
10872 { "vdpps", { XM, Vex, EXx, Ib } },
10873 { "(bad)", { XX } },
10876 /* VEX_W_3A41_P_2 */
10877 { "vdppd", { XM, Vex128, EXx, Ib } },
10878 { "(bad)", { XX } },
10881 /* VEX_W_3A42_P_2 */
10882 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
10883 { "(bad)", { XX } },
10886 /* VEX_W_3A44_P_2 */
10887 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
10888 { "(bad)", { XX } },
10891 /* VEX_W_3A4A_P_2 */
10892 { "vblendvps", { XM, Vex, EXx, XMVexI4 } },
10893 { "(bad)", { XX } },
10896 /* VEX_W_3A4B_P_2 */
10897 { "vblendvpd", { XM, Vex, EXx, XMVexI4 } },
10898 { "(bad)", { XX } },
10901 /* VEX_W_3A4C_P_2 */
10902 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
10903 { "(bad)", { XX } },
10906 /* VEX_W_3A60_P_2 */
10907 { "vpcmpestrm", { XM, EXx, Ib } },
10908 { "(bad)", { XX } },
10911 /* VEX_W_3A61_P_2 */
10912 { "vpcmpestri", { XM, EXx, Ib } },
10913 { "(bad)", { XX } },
10916 /* VEX_W_3A62_P_2 */
10917 { "vpcmpistrm", { XM, EXx, Ib } },
10918 { "(bad)", { XX } },
10921 /* VEX_W_3A63_P_2 */
10922 { "vpcmpistri", { XM, EXx, Ib } },
10923 { "(bad)", { XX } },
10926 /* VEX_W_3ADF_P_2 */
10927 { "vaeskeygenassist", { XM, EXx, Ib } },
10928 { "(bad)", { XX } },
10932 static const struct dis386 mod_table[][2] = {
10935 { "leaS", { Gv, M } },
10936 { "(bad)", { XX } },
10939 /* MOD_0F01_REG_0 */
10940 { X86_64_TABLE (X86_64_0F01_REG_0) },
10941 { RM_TABLE (RM_0F01_REG_0) },
10944 /* MOD_0F01_REG_1 */
10945 { X86_64_TABLE (X86_64_0F01_REG_1) },
10946 { RM_TABLE (RM_0F01_REG_1) },
10949 /* MOD_0F01_REG_2 */
10950 { X86_64_TABLE (X86_64_0F01_REG_2) },
10951 { RM_TABLE (RM_0F01_REG_2) },
10954 /* MOD_0F01_REG_3 */
10955 { X86_64_TABLE (X86_64_0F01_REG_3) },
10956 { RM_TABLE (RM_0F01_REG_3) },
10959 /* MOD_0F01_REG_7 */
10960 { "invlpg", { Mb } },
10961 { RM_TABLE (RM_0F01_REG_7) },
10964 /* MOD_0F12_PREFIX_0 */
10965 { "movlps", { XM, EXq } },
10966 { "movhlps", { XM, EXq } },
10970 { "movlpX", { EXq, XM } },
10971 { "(bad)", { XX } },
10974 /* MOD_0F16_PREFIX_0 */
10975 { "movhps", { XM, EXq } },
10976 { "movlhps", { XM, EXq } },
10980 { "movhpX", { EXq, XM } },
10981 { "(bad)", { XX } },
10984 /* MOD_0F18_REG_0 */
10985 { "prefetchnta", { Mb } },
10986 { "(bad)", { XX } },
10989 /* MOD_0F18_REG_1 */
10990 { "prefetcht0", { Mb } },
10991 { "(bad)", { XX } },
10994 /* MOD_0F18_REG_2 */
10995 { "prefetcht1", { Mb } },
10996 { "(bad)", { XX } },
10999 /* MOD_0F18_REG_3 */
11000 { "prefetcht2", { Mb } },
11001 { "(bad)", { XX } },
11005 { "(bad)", { XX } },
11006 { "movZ", { Rm, Cm } },
11010 { "(bad)", { XX } },
11011 { "movZ", { Rm, Dm } },
11015 { "(bad)", { XX } },
11016 { "movZ", { Cm, Rm } },
11020 { "(bad)", { XX } },
11021 { "movZ", { Dm, Rm } },
11025 { "(bad)", { XX } },
11026 { "movL", { Rd, Td } },
11030 { "(bad)", { XX } },
11031 { "movL", { Td, Rd } },
11034 /* MOD_0F2B_PREFIX_0 */
11035 {"movntps", { Mx, XM } },
11036 { "(bad)", { XX } },
11039 /* MOD_0F2B_PREFIX_1 */
11040 {"movntss", { Md, XM } },
11041 { "(bad)", { XX } },
11044 /* MOD_0F2B_PREFIX_2 */
11045 {"movntpd", { Mx, XM } },
11046 { "(bad)", { XX } },
11049 /* MOD_0F2B_PREFIX_3 */
11050 {"movntsd", { Mq, XM } },
11051 { "(bad)", { XX } },
11055 { "(bad)", { XX } },
11056 { "movmskpX", { Gdq, XS } },
11059 /* MOD_0F71_REG_2 */
11060 { "(bad)", { XX } },
11061 { "psrlw", { MS, Ib } },
11064 /* MOD_0F71_REG_4 */
11065 { "(bad)", { XX } },
11066 { "psraw", { MS, Ib } },
11069 /* MOD_0F71_REG_6 */
11070 { "(bad)", { XX } },
11071 { "psllw", { MS, Ib } },
11074 /* MOD_0F72_REG_2 */
11075 { "(bad)", { XX } },
11076 { "psrld", { MS, Ib } },
11079 /* MOD_0F72_REG_4 */
11080 { "(bad)", { XX } },
11081 { "psrad", { MS, Ib } },
11084 /* MOD_0F72_REG_6 */
11085 { "(bad)", { XX } },
11086 { "pslld", { MS, Ib } },
11089 /* MOD_0F73_REG_2 */
11090 { "(bad)", { XX } },
11091 { "psrlq", { MS, Ib } },
11094 /* MOD_0F73_REG_3 */
11095 { "(bad)", { XX } },
11096 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
11099 /* MOD_0F73_REG_6 */
11100 { "(bad)", { XX } },
11101 { "psllq", { MS, Ib } },
11104 /* MOD_0F73_REG_7 */
11105 { "(bad)", { XX } },
11106 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
11109 /* MOD_0FAE_REG_0 */
11110 { "fxsave", { FXSAVE } },
11111 { "(bad)", { XX } },
11114 /* MOD_0FAE_REG_1 */
11115 { "fxrstor", { FXSAVE } },
11116 { "(bad)", { XX } },
11119 /* MOD_0FAE_REG_2 */
11120 { "ldmxcsr", { Md } },
11121 { "(bad)", { XX } },
11124 /* MOD_0FAE_REG_3 */
11125 { "stmxcsr", { Md } },
11126 { "(bad)", { XX } },
11129 /* MOD_0FAE_REG_4 */
11130 { "xsave", { M } },
11131 { "(bad)", { XX } },
11134 /* MOD_0FAE_REG_5 */
11135 { "xrstor", { M } },
11136 { RM_TABLE (RM_0FAE_REG_5) },
11139 /* MOD_0FAE_REG_6 */
11140 { "xsaveopt", { M } },
11141 { RM_TABLE (RM_0FAE_REG_6) },
11144 /* MOD_0FAE_REG_7 */
11145 { "clflush", { Mb } },
11146 { RM_TABLE (RM_0FAE_REG_7) },
11150 { "lssS", { Gv, Mp } },
11151 { "(bad)", { XX } },
11155 { "lfsS", { Gv, Mp } },
11156 { "(bad)", { XX } },
11160 { "lgsS", { Gv, Mp } },
11161 { "(bad)", { XX } },
11164 /* MOD_0FC7_REG_6 */
11165 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
11166 { "(bad)", { XX } },
11169 /* MOD_0FC7_REG_7 */
11170 { "vmptrst", { Mq } },
11171 { "(bad)", { XX } },
11175 { "(bad)", { XX } },
11176 { "pmovmskb", { Gdq, MS } },
11179 /* MOD_0FE7_PREFIX_2 */
11180 { "movntdq", { Mx, XM } },
11181 { "(bad)", { XX } },
11184 /* MOD_0FF0_PREFIX_3 */
11185 { "lddqu", { XM, M } },
11186 { "(bad)", { XX } },
11189 /* MOD_0F382A_PREFIX_2 */
11190 { "movntdqa", { XM, Mx } },
11191 { "(bad)", { XX } },
11195 { "bound{S|}", { Gv, Ma } },
11196 { "(bad)", { XX } },
11200 { "lesS", { Gv, Mp } },
11201 { VEX_C4_TABLE (VEX_0F) },
11205 { "ldsS", { Gv, Mp } },
11206 { VEX_C5_TABLE (VEX_0F) },
11209 /* MOD_VEX_12_PREFIX_0 */
11210 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
11211 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
11215 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
11216 { "(bad)", { XX } },
11219 /* MOD_VEX_16_PREFIX_0 */
11220 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
11221 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
11225 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
11226 { "(bad)", { XX } },
11230 { VEX_W_TABLE (VEX_W_2B_M_0) },
11231 { "(bad)", { XX } },
11235 { "(bad)", { XX } },
11236 { VEX_W_TABLE (VEX_W_50_M_0) },
11239 /* MOD_VEX_71_REG_2 */
11240 { "(bad)", { XX } },
11241 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
11244 /* MOD_VEX_71_REG_4 */
11245 { "(bad)", { XX } },
11246 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
11249 /* MOD_VEX_71_REG_6 */
11250 { "(bad)", { XX } },
11251 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
11254 /* MOD_VEX_72_REG_2 */
11255 { "(bad)", { XX } },
11256 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
11259 /* MOD_VEX_72_REG_4 */
11260 { "(bad)", { XX } },
11261 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
11264 /* MOD_VEX_72_REG_6 */
11265 { "(bad)", { XX } },
11266 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
11269 /* MOD_VEX_73_REG_2 */
11270 { "(bad)", { XX } },
11271 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
11274 /* MOD_VEX_73_REG_3 */
11275 { "(bad)", { XX } },
11276 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
11279 /* MOD_VEX_73_REG_6 */
11280 { "(bad)", { XX } },
11281 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
11284 /* MOD_VEX_73_REG_7 */
11285 { "(bad)", { XX } },
11286 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
11289 /* MOD_VEX_AE_REG_2 */
11290 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
11291 { "(bad)", { XX } },
11294 /* MOD_VEX_AE_REG_3 */
11295 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
11296 { "(bad)", { XX } },
11299 /* MOD_VEX_D7_PREFIX_2 */
11300 { "(bad)", { XX } },
11301 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
11304 /* MOD_VEX_E7_PREFIX_2 */
11305 { VEX_W_TABLE (VEX_W_E7_P_2_M_0) },
11306 { "(bad)", { XX } },
11309 /* MOD_VEX_F0_PREFIX_3 */
11310 { VEX_W_TABLE (VEX_W_F0_P_3_M_0) },
11311 { "(bad)", { XX } },
11314 /* MOD_VEX_3818_PREFIX_2 */
11315 { VEX_W_TABLE (VEX_W_3818_P_2_M_0) },
11316 { "(bad)", { XX } },
11319 /* MOD_VEX_3819_PREFIX_2 */
11320 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
11321 { "(bad)", { XX } },
11324 /* MOD_VEX_381A_PREFIX_2 */
11325 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
11326 { "(bad)", { XX } },
11329 /* MOD_VEX_382A_PREFIX_2 */
11330 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
11331 { "(bad)", { XX } },
11334 /* MOD_VEX_382C_PREFIX_2 */
11335 { VEX_W_TABLE (VEX_W_382C_P_2_M_0) },
11336 { "(bad)", { XX } },
11339 /* MOD_VEX_382D_PREFIX_2 */
11340 { VEX_W_TABLE (VEX_W_382D_P_2_M_0) },
11341 { "(bad)", { XX } },
11344 /* MOD_VEX_382E_PREFIX_2 */
11345 { VEX_W_TABLE (VEX_W_382E_P_2_M_0) },
11346 { "(bad)", { XX } },
11349 /* MOD_VEX_382F_PREFIX_2 */
11350 { VEX_W_TABLE (VEX_W_382F_P_2_M_0) },
11351 { "(bad)", { XX } },
11355 static const struct dis386 rm_table[][8] = {
11357 /* RM_0F01_REG_0 */
11358 { "(bad)", { XX } },
11359 { "vmcall", { Skip_MODRM } },
11360 { "vmlaunch", { Skip_MODRM } },
11361 { "vmresume", { Skip_MODRM } },
11362 { "vmxoff", { Skip_MODRM } },
11363 { "(bad)", { XX } },
11364 { "(bad)", { XX } },
11365 { "(bad)", { XX } },
11368 /* RM_0F01_REG_1 */
11369 { "monitor", { { OP_Monitor, 0 } } },
11370 { "mwait", { { OP_Mwait, 0 } } },
11371 { "(bad)", { XX } },
11372 { "(bad)", { XX } },
11373 { "(bad)", { XX } },
11374 { "(bad)", { XX } },
11375 { "(bad)", { XX } },
11376 { "(bad)", { XX } },
11379 /* RM_0F01_REG_2 */
11380 { "xgetbv", { Skip_MODRM } },
11381 { "xsetbv", { Skip_MODRM } },
11382 { "(bad)", { XX } },
11383 { "(bad)", { XX } },
11384 { "(bad)", { XX } },
11385 { "(bad)", { XX } },
11386 { "(bad)", { XX } },
11387 { "(bad)", { XX } },
11390 /* RM_0F01_REG_3 */
11391 { "vmrun", { Skip_MODRM } },
11392 { "vmmcall", { Skip_MODRM } },
11393 { "vmload", { Skip_MODRM } },
11394 { "vmsave", { Skip_MODRM } },
11395 { "stgi", { Skip_MODRM } },
11396 { "clgi", { Skip_MODRM } },
11397 { "skinit", { Skip_MODRM } },
11398 { "invlpga", { Skip_MODRM } },
11401 /* RM_0F01_REG_7 */
11402 { "swapgs", { Skip_MODRM } },
11403 { "rdtscp", { Skip_MODRM } },
11404 { "(bad)", { XX } },
11405 { "(bad)", { XX } },
11406 { "(bad)", { XX } },
11407 { "(bad)", { XX } },
11408 { "(bad)", { XX } },
11409 { "(bad)", { XX } },
11412 /* RM_0FAE_REG_5 */
11413 { "lfence", { Skip_MODRM } },
11414 { "(bad)", { XX } },
11415 { "(bad)", { XX } },
11416 { "(bad)", { XX } },
11417 { "(bad)", { XX } },
11418 { "(bad)", { XX } },
11419 { "(bad)", { XX } },
11420 { "(bad)", { XX } },
11423 /* RM_0FAE_REG_6 */
11424 { "mfence", { Skip_MODRM } },
11425 { "(bad)", { XX } },
11426 { "(bad)", { XX } },
11427 { "(bad)", { XX } },
11428 { "(bad)", { XX } },
11429 { "(bad)", { XX } },
11430 { "(bad)", { XX } },
11431 { "(bad)", { XX } },
11434 /* RM_0FAE_REG_7 */
11435 { "sfence", { Skip_MODRM } },
11436 { "(bad)", { XX } },
11437 { "(bad)", { XX } },
11438 { "(bad)", { XX } },
11439 { "(bad)", { XX } },
11440 { "(bad)", { XX } },
11441 { "(bad)", { XX } },
11442 { "(bad)", { XX } },
11446 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
11448 /* We use the high bit to indicate different name for the same
11450 #define ADDR16_PREFIX (0x67 | 0x100)
11451 #define ADDR32_PREFIX (0x67 | 0x200)
11452 #define DATA16_PREFIX (0x66 | 0x100)
11453 #define DATA32_PREFIX (0x66 | 0x200)
11454 #define REP_PREFIX (0xf3 | 0x100)
11459 int newrex, i, length;
11465 last_lock_prefix = -1;
11466 last_repz_prefix = -1;
11467 last_repnz_prefix = -1;
11468 last_data_prefix = -1;
11469 last_addr_prefix = -1;
11470 last_rex_prefix = -1;
11471 last_seg_prefix = -1;
11472 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
11473 all_prefixes[i] = 0;
11476 /* The maximum instruction length is 15bytes. */
11477 while (length < MAX_CODE_LENGTH - 1)
11479 FETCH_DATA (the_info, codep + 1);
11483 /* REX prefixes family. */
11500 if (address_mode == mode_64bit)
11504 last_rex_prefix = i;
11507 prefixes |= PREFIX_REPZ;
11508 last_repz_prefix = i;
11511 prefixes |= PREFIX_REPNZ;
11512 last_repnz_prefix = i;
11515 prefixes |= PREFIX_LOCK;
11516 last_lock_prefix = i;
11519 prefixes |= PREFIX_CS;
11520 last_seg_prefix = i;
11523 prefixes |= PREFIX_SS;
11524 last_seg_prefix = i;
11527 prefixes |= PREFIX_DS;
11528 last_seg_prefix = i;
11531 prefixes |= PREFIX_ES;
11532 last_seg_prefix = i;
11535 prefixes |= PREFIX_FS;
11536 last_seg_prefix = i;
11539 prefixes |= PREFIX_GS;
11540 last_seg_prefix = i;
11543 prefixes |= PREFIX_DATA;
11544 last_data_prefix = i;
11547 prefixes |= PREFIX_ADDR;
11548 last_addr_prefix = i;
11551 /* fwait is really an instruction. If there are prefixes
11552 before the fwait, they belong to the fwait, *not* to the
11553 following instruction. */
11554 if (prefixes || rex)
11556 prefixes |= PREFIX_FWAIT;
11560 prefixes = PREFIX_FWAIT;
11565 /* Rex is ignored when followed by another prefix. */
11571 if (*codep != FWAIT_OPCODE)
11572 all_prefixes[i++] = *codep;
11581 seg_prefix (int pref)
11602 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
11605 static const char *
11606 prefix_name (int pref, int sizeflag)
11608 static const char *rexes [16] =
11611 "rex.B", /* 0x41 */
11612 "rex.X", /* 0x42 */
11613 "rex.XB", /* 0x43 */
11614 "rex.R", /* 0x44 */
11615 "rex.RB", /* 0x45 */
11616 "rex.RX", /* 0x46 */
11617 "rex.RXB", /* 0x47 */
11618 "rex.W", /* 0x48 */
11619 "rex.WB", /* 0x49 */
11620 "rex.WX", /* 0x4a */
11621 "rex.WXB", /* 0x4b */
11622 "rex.WR", /* 0x4c */
11623 "rex.WRB", /* 0x4d */
11624 "rex.WRX", /* 0x4e */
11625 "rex.WRXB", /* 0x4f */
11630 /* REX prefixes family. */
11647 return rexes [pref - 0x40];
11667 return (sizeflag & DFLAG) ? "data16" : "data32";
11669 if (address_mode == mode_64bit)
11670 return (sizeflag & AFLAG) ? "addr32" : "addr64";
11672 return (sizeflag & AFLAG) ? "addr16" : "addr32";
11675 case ADDR16_PREFIX:
11677 case ADDR32_PREFIX:
11679 case DATA16_PREFIX:
11681 case DATA32_PREFIX:
11690 static char op_out[MAX_OPERANDS][100];
11691 static int op_ad, op_index[MAX_OPERANDS];
11692 static int two_source_ops;
11693 static bfd_vma op_address[MAX_OPERANDS];
11694 static bfd_vma op_riprel[MAX_OPERANDS];
11695 static bfd_vma start_pc;
11698 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
11699 * (see topic "Redundant prefixes" in the "Differences from 8086"
11700 * section of the "Virtual 8086 Mode" chapter.)
11701 * 'pc' should be the address of this instruction, it will
11702 * be used to print the target address if this is a relative jump or call
11703 * The function returns the length of this instruction in bytes.
11706 static char intel_syntax;
11707 static char intel_mnemonic = !SYSV386_COMPAT;
11708 static char open_char;
11709 static char close_char;
11710 static char separator_char;
11711 static char scale_char;
11713 /* Here for backwards compatibility. When gdb stops using
11714 print_insn_i386_att and print_insn_i386_intel these functions can
11715 disappear, and print_insn_i386 be merged into print_insn. */
11717 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
11721 return print_insn (pc, info);
11725 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
11729 return print_insn (pc, info);
11733 print_insn_i386 (bfd_vma pc, disassemble_info *info)
11737 return print_insn (pc, info);
11741 print_i386_disassembler_options (FILE *stream)
11743 fprintf (stream, _("\n\
11744 The following i386/x86-64 specific disassembler options are supported for use\n\
11745 with the -M switch (multiple options should be separated by commas):\n"));
11747 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
11748 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
11749 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
11750 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
11751 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
11752 fprintf (stream, _(" att-mnemonic\n"
11753 " Display instruction in AT&T mnemonic\n"));
11754 fprintf (stream, _(" intel-mnemonic\n"
11755 " Display instruction in Intel mnemonic\n"));
11756 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
11757 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
11758 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
11759 fprintf (stream, _(" data32 Assume 32bit data size\n"));
11760 fprintf (stream, _(" data16 Assume 16bit data size\n"));
11761 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
11764 /* Get a pointer to struct dis386 with a valid name. */
11766 static const struct dis386 *
11767 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
11769 int vindex, vex_table_index;
11771 if (dp->name != NULL)
11774 switch (dp->op[0].bytemode)
11776 case USE_REG_TABLE:
11777 dp = ®_table[dp->op[1].bytemode][modrm.reg];
11780 case USE_MOD_TABLE:
11781 vindex = modrm.mod == 0x3 ? 1 : 0;
11782 dp = &mod_table[dp->op[1].bytemode][vindex];
11786 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
11789 case USE_PREFIX_TABLE:
11792 /* The prefix in VEX is implicit. */
11793 switch (vex.prefix)
11798 case REPE_PREFIX_OPCODE:
11801 case DATA_PREFIX_OPCODE:
11804 case REPNE_PREFIX_OPCODE:
11815 used_prefixes |= (prefixes & PREFIX_REPZ);
11816 if (prefixes & PREFIX_REPZ)
11819 all_prefixes[last_repz_prefix] = 0;
11823 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
11825 used_prefixes |= (prefixes & PREFIX_REPNZ);
11826 if (prefixes & PREFIX_REPNZ)
11829 all_prefixes[last_repnz_prefix] = 0;
11833 used_prefixes |= (prefixes & PREFIX_DATA);
11834 if (prefixes & PREFIX_DATA)
11837 all_prefixes[last_data_prefix] = 0;
11842 dp = &prefix_table[dp->op[1].bytemode][vindex];
11845 case USE_X86_64_TABLE:
11846 vindex = address_mode == mode_64bit ? 1 : 0;
11847 dp = &x86_64_table[dp->op[1].bytemode][vindex];
11850 case USE_3BYTE_TABLE:
11851 FETCH_DATA (info, codep + 2);
11853 dp = &three_byte_table[dp->op[1].bytemode][vindex];
11854 modrm.mod = (*codep >> 6) & 3;
11855 modrm.reg = (*codep >> 3) & 7;
11856 modrm.rm = *codep & 7;
11859 case USE_VEX_LEN_TABLE:
11863 switch (vex.length)
11876 dp = &vex_len_table[dp->op[1].bytemode][vindex];
11879 case USE_XOP_8F_TABLE:
11880 FETCH_DATA (info, codep + 3);
11881 /* All bits in the REX prefix are ignored. */
11883 rex = ~(*codep >> 5) & 0x7;
11885 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11886 switch ((*codep & 0x1f))
11891 vex_table_index = XOP_08;
11894 vex_table_index = XOP_09;
11897 vex_table_index = XOP_0A;
11901 vex.w = *codep & 0x80;
11902 if (vex.w && address_mode == mode_64bit)
11905 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11906 if (address_mode != mode_64bit
11907 && vex.register_specifier > 0x7)
11910 vex.length = (*codep & 0x4) ? 256 : 128;
11911 switch ((*codep & 0x3))
11917 vex.prefix = DATA_PREFIX_OPCODE;
11920 vex.prefix = REPE_PREFIX_OPCODE;
11923 vex.prefix = REPNE_PREFIX_OPCODE;
11930 dp = &xop_table[vex_table_index][vindex];
11932 FETCH_DATA (info, codep + 1);
11933 modrm.mod = (*codep >> 6) & 3;
11934 modrm.reg = (*codep >> 3) & 7;
11935 modrm.rm = *codep & 7;
11938 case USE_VEX_C4_TABLE:
11939 FETCH_DATA (info, codep + 3);
11940 /* All bits in the REX prefix are ignored. */
11942 rex = ~(*codep >> 5) & 0x7;
11943 switch ((*codep & 0x1f))
11948 vex_table_index = VEX_0F;
11951 vex_table_index = VEX_0F38;
11954 vex_table_index = VEX_0F3A;
11958 vex.w = *codep & 0x80;
11959 if (vex.w && address_mode == mode_64bit)
11962 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11963 if (address_mode != mode_64bit
11964 && vex.register_specifier > 0x7)
11967 vex.length = (*codep & 0x4) ? 256 : 128;
11968 switch ((*codep & 0x3))
11974 vex.prefix = DATA_PREFIX_OPCODE;
11977 vex.prefix = REPE_PREFIX_OPCODE;
11980 vex.prefix = REPNE_PREFIX_OPCODE;
11987 dp = &vex_table[vex_table_index][vindex];
11988 /* There is no MODRM byte for VEX [82|77]. */
11989 if (vindex != 0x77 && vindex != 0x82)
11991 FETCH_DATA (info, codep + 1);
11992 modrm.mod = (*codep >> 6) & 3;
11993 modrm.reg = (*codep >> 3) & 7;
11994 modrm.rm = *codep & 7;
11998 case USE_VEX_C5_TABLE:
11999 FETCH_DATA (info, codep + 2);
12000 /* All bits in the REX prefix are ignored. */
12002 rex = (*codep & 0x80) ? 0 : REX_R;
12004 vex.register_specifier = (~(*codep >> 3)) & 0xf;
12005 if (address_mode != mode_64bit
12006 && vex.register_specifier > 0x7)
12011 vex.length = (*codep & 0x4) ? 256 : 128;
12012 switch ((*codep & 0x3))
12018 vex.prefix = DATA_PREFIX_OPCODE;
12021 vex.prefix = REPE_PREFIX_OPCODE;
12024 vex.prefix = REPNE_PREFIX_OPCODE;
12031 dp = &vex_table[dp->op[1].bytemode][vindex];
12032 /* There is no MODRM byte for VEX [82|77]. */
12033 if (vindex != 0x77 && vindex != 0x82)
12035 FETCH_DATA (info, codep + 1);
12036 modrm.mod = (*codep >> 6) & 3;
12037 modrm.reg = (*codep >> 3) & 7;
12038 modrm.rm = *codep & 7;
12042 case USE_VEX_W_TABLE:
12046 dp = &vex_w_table[dp->op[1].bytemode][vex.w ? 1 : 0];
12053 if (dp->name != NULL)
12056 return get_valid_dis386 (dp, info);
12060 print_insn (bfd_vma pc, disassemble_info *info)
12062 const struct dis386 *dp;
12064 char *op_txt[MAX_OPERANDS];
12068 struct dis_private priv;
12071 int default_prefixes;
12073 if (info->mach == bfd_mach_x86_64_intel_syntax
12074 || info->mach == bfd_mach_x86_64
12075 || info->mach == bfd_mach_l1om
12076 || info->mach == bfd_mach_l1om_intel_syntax)
12077 address_mode = mode_64bit;
12079 address_mode = mode_32bit;
12081 if (intel_syntax == (char) -1)
12082 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
12083 || info->mach == bfd_mach_x86_64_intel_syntax
12084 || info->mach == bfd_mach_l1om_intel_syntax);
12086 if (info->mach == bfd_mach_i386_i386
12087 || info->mach == bfd_mach_x86_64
12088 || info->mach == bfd_mach_l1om
12089 || info->mach == bfd_mach_i386_i386_intel_syntax
12090 || info->mach == bfd_mach_x86_64_intel_syntax
12091 || info->mach == bfd_mach_l1om_intel_syntax)
12092 priv.orig_sizeflag = AFLAG | DFLAG;
12093 else if (info->mach == bfd_mach_i386_i8086)
12094 priv.orig_sizeflag = 0;
12098 for (p = info->disassembler_options; p != NULL; )
12100 if (CONST_STRNEQ (p, "x86-64"))
12102 address_mode = mode_64bit;
12103 priv.orig_sizeflag = AFLAG | DFLAG;
12105 else if (CONST_STRNEQ (p, "i386"))
12107 address_mode = mode_32bit;
12108 priv.orig_sizeflag = AFLAG | DFLAG;
12110 else if (CONST_STRNEQ (p, "i8086"))
12112 address_mode = mode_16bit;
12113 priv.orig_sizeflag = 0;
12115 else if (CONST_STRNEQ (p, "intel"))
12118 if (CONST_STRNEQ (p + 5, "-mnemonic"))
12119 intel_mnemonic = 1;
12121 else if (CONST_STRNEQ (p, "att"))
12124 if (CONST_STRNEQ (p + 3, "-mnemonic"))
12125 intel_mnemonic = 0;
12127 else if (CONST_STRNEQ (p, "addr"))
12129 if (address_mode == mode_64bit)
12131 if (p[4] == '3' && p[5] == '2')
12132 priv.orig_sizeflag &= ~AFLAG;
12133 else if (p[4] == '6' && p[5] == '4')
12134 priv.orig_sizeflag |= AFLAG;
12138 if (p[4] == '1' && p[5] == '6')
12139 priv.orig_sizeflag &= ~AFLAG;
12140 else if (p[4] == '3' && p[5] == '2')
12141 priv.orig_sizeflag |= AFLAG;
12144 else if (CONST_STRNEQ (p, "data"))
12146 if (p[4] == '1' && p[5] == '6')
12147 priv.orig_sizeflag &= ~DFLAG;
12148 else if (p[4] == '3' && p[5] == '2')
12149 priv.orig_sizeflag |= DFLAG;
12151 else if (CONST_STRNEQ (p, "suffix"))
12152 priv.orig_sizeflag |= SUFFIX_ALWAYS;
12154 p = strchr (p, ',');
12161 names64 = intel_names64;
12162 names32 = intel_names32;
12163 names16 = intel_names16;
12164 names8 = intel_names8;
12165 names8rex = intel_names8rex;
12166 names_seg = intel_names_seg;
12167 names_mm = intel_names_mm;
12168 names_xmm = intel_names_xmm;
12169 names_ymm = intel_names_ymm;
12170 index64 = intel_index64;
12171 index32 = intel_index32;
12172 index16 = intel_index16;
12175 separator_char = '+';
12180 names64 = att_names64;
12181 names32 = att_names32;
12182 names16 = att_names16;
12183 names8 = att_names8;
12184 names8rex = att_names8rex;
12185 names_seg = att_names_seg;
12186 names_mm = att_names_mm;
12187 names_xmm = att_names_xmm;
12188 names_ymm = att_names_ymm;
12189 index64 = att_index64;
12190 index32 = att_index32;
12191 index16 = att_index16;
12194 separator_char = ',';
12198 /* The output looks better if we put 7 bytes on a line, since that
12199 puts most long word instructions on a single line. Use 8 bytes
12201 if (info->mach == bfd_mach_l1om
12202 || info->mach == bfd_mach_l1om_intel_syntax)
12203 info->bytes_per_line = 8;
12205 info->bytes_per_line = 7;
12207 info->private_data = &priv;
12208 priv.max_fetched = priv.the_buffer;
12209 priv.insn_start = pc;
12212 for (i = 0; i < MAX_OPERANDS; ++i)
12220 start_codep = priv.the_buffer;
12221 codep = priv.the_buffer;
12223 if (setjmp (priv.bailout) != 0)
12227 /* Getting here means we tried for data but didn't get it. That
12228 means we have an incomplete instruction of some sort. Just
12229 print the first byte as a prefix or a .byte pseudo-op. */
12230 if (codep > priv.the_buffer)
12232 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
12234 (*info->fprintf_func) (info->stream, "%s", name);
12237 /* Just print the first byte as a .byte instruction. */
12238 (*info->fprintf_func) (info->stream, ".byte 0x%x",
12239 (unsigned int) priv.the_buffer[0]);
12249 sizeflag = priv.orig_sizeflag;
12251 if (!ckprefix () || rex_used)
12253 /* Too many prefixes or unused REX prefixes. */
12255 all_prefixes[i] && i < (int) ARRAY_SIZE (all_prefixes);
12257 (*info->fprintf_func) (info->stream, "%s",
12258 prefix_name (all_prefixes[i], sizeflag));
12262 insn_codep = codep;
12264 FETCH_DATA (info, codep + 1);
12265 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
12267 if (((prefixes & PREFIX_FWAIT)
12268 && ((*codep < 0xd8) || (*codep > 0xdf))))
12270 (*info->fprintf_func) (info->stream, "fwait");
12276 if (*codep == 0x0f)
12278 unsigned char threebyte;
12279 FETCH_DATA (info, codep + 2);
12280 threebyte = *++codep;
12281 dp = &dis386_twobyte[threebyte];
12282 need_modrm = twobyte_has_modrm[*codep];
12287 dp = &dis386[*codep];
12288 need_modrm = onebyte_has_modrm[*codep];
12292 if ((prefixes & PREFIX_REPZ))
12293 used_prefixes |= PREFIX_REPZ;
12294 if ((prefixes & PREFIX_REPNZ))
12295 used_prefixes |= PREFIX_REPNZ;
12296 if ((prefixes & PREFIX_LOCK))
12297 used_prefixes |= PREFIX_LOCK;
12299 default_prefixes = 0;
12300 if (prefixes & PREFIX_ADDR)
12303 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
12305 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12306 all_prefixes[last_addr_prefix] = ADDR32_PREFIX;
12308 all_prefixes[last_addr_prefix] = ADDR16_PREFIX;
12309 default_prefixes |= PREFIX_ADDR;
12313 if ((prefixes & PREFIX_DATA))
12316 if (dp->op[2].bytemode == cond_jump_mode
12317 && dp->op[0].bytemode == v_mode
12320 if (sizeflag & DFLAG)
12321 all_prefixes[last_data_prefix] = DATA32_PREFIX;
12323 all_prefixes[last_data_prefix] = DATA16_PREFIX;
12324 default_prefixes |= PREFIX_DATA;
12326 else if (rex & REX_W)
12328 /* REX_W will override PREFIX_DATA. */
12329 default_prefixes |= PREFIX_DATA;
12335 FETCH_DATA (info, codep + 1);
12336 modrm.mod = (*codep >> 6) & 3;
12337 modrm.reg = (*codep >> 3) & 7;
12338 modrm.rm = *codep & 7;
12345 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
12347 dofloat (sizeflag);
12351 dp = get_valid_dis386 (dp, info);
12352 if (dp != NULL && putop (dp->name, sizeflag) == 0)
12354 for (i = 0; i < MAX_OPERANDS; ++i)
12357 op_ad = MAX_OPERANDS - 1 - i;
12359 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
12364 /* See if any prefixes were not used. If so, print the first one
12365 separately. If we don't do this, we'll wind up printing an
12366 instruction stream which does not precisely correspond to the
12367 bytes we are disassembling. */
12368 if ((prefixes & ~(used_prefixes | default_prefixes)) != 0)
12370 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12371 if (all_prefixes[i])
12374 name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
12376 name = INTERNAL_DISASSEMBLER_ERROR;
12377 (*info->fprintf_func) (info->stream, "%s", name);
12382 /* Check if the REX prefix is used. */
12383 if (rex_ignored == 0 && (rex ^ rex_used) == 0)
12384 all_prefixes[last_rex_prefix] = 0;
12386 /* Check if the SEG prefix is used. */
12387 if ((prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
12388 | PREFIX_FS | PREFIX_GS)) != 0
12390 & seg_prefix (all_prefixes[last_seg_prefix])) != 0)
12391 all_prefixes[last_seg_prefix] = 0;
12393 /* Check if the ADDR prefix is used. */
12394 if ((prefixes & PREFIX_ADDR) != 0
12395 && (used_prefixes & PREFIX_ADDR) != 0)
12396 all_prefixes[last_addr_prefix] = 0;
12398 /* Check if the DATA prefix is used. */
12399 if ((prefixes & PREFIX_DATA) != 0
12400 && (used_prefixes & PREFIX_DATA) != 0)
12401 all_prefixes[last_data_prefix] = 0;
12404 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12405 if (all_prefixes[i])
12408 name = prefix_name (all_prefixes[i], sizeflag);
12411 prefix_length += strlen (name) + 1;
12412 (*info->fprintf_func) (info->stream, "%s ", name);
12415 /* Check maximum code length. */
12416 if ((codep - start_codep) > MAX_CODE_LENGTH)
12418 (*info->fprintf_func) (info->stream, "(bad)");
12419 return MAX_CODE_LENGTH;
12422 obufp = mnemonicendp;
12423 for (i = strlen (obuf) + prefix_length; i < 6; i++)
12426 (*info->fprintf_func) (info->stream, "%s", obuf);
12428 /* The enter and bound instructions are printed with operands in the same
12429 order as the intel book; everything else is printed in reverse order. */
12430 if (intel_syntax || two_source_ops)
12434 for (i = 0; i < MAX_OPERANDS; ++i)
12435 op_txt[i] = op_out[i];
12437 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
12439 op_ad = op_index[i];
12440 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
12441 op_index[MAX_OPERANDS - 1 - i] = op_ad;
12442 riprel = op_riprel[i];
12443 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
12444 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
12449 for (i = 0; i < MAX_OPERANDS; ++i)
12450 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
12454 for (i = 0; i < MAX_OPERANDS; ++i)
12458 (*info->fprintf_func) (info->stream, ",");
12459 if (op_index[i] != -1 && !op_riprel[i])
12460 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
12462 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
12466 for (i = 0; i < MAX_OPERANDS; i++)
12467 if (op_index[i] != -1 && op_riprel[i])
12469 (*info->fprintf_func) (info->stream, " # ");
12470 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
12471 + op_address[op_index[i]]), info);
12474 return codep - priv.the_buffer;
12477 static const char *float_mem[] = {
12552 static const unsigned char float_mem_mode[] = {
12627 #define ST { OP_ST, 0 }
12628 #define STi { OP_STi, 0 }
12630 #define FGRPd9_2 NULL, { { NULL, 0 } }
12631 #define FGRPd9_4 NULL, { { NULL, 1 } }
12632 #define FGRPd9_5 NULL, { { NULL, 2 } }
12633 #define FGRPd9_6 NULL, { { NULL, 3 } }
12634 #define FGRPd9_7 NULL, { { NULL, 4 } }
12635 #define FGRPda_5 NULL, { { NULL, 5 } }
12636 #define FGRPdb_4 NULL, { { NULL, 6 } }
12637 #define FGRPde_3 NULL, { { NULL, 7 } }
12638 #define FGRPdf_4 NULL, { { NULL, 8 } }
12640 static const struct dis386 float_reg[][8] = {
12643 { "fadd", { ST, STi } },
12644 { "fmul", { ST, STi } },
12645 { "fcom", { STi } },
12646 { "fcomp", { STi } },
12647 { "fsub", { ST, STi } },
12648 { "fsubr", { ST, STi } },
12649 { "fdiv", { ST, STi } },
12650 { "fdivr", { ST, STi } },
12654 { "fld", { STi } },
12655 { "fxch", { STi } },
12657 { "(bad)", { XX } },
12665 { "fcmovb", { ST, STi } },
12666 { "fcmove", { ST, STi } },
12667 { "fcmovbe",{ ST, STi } },
12668 { "fcmovu", { ST, STi } },
12669 { "(bad)", { XX } },
12671 { "(bad)", { XX } },
12672 { "(bad)", { XX } },
12676 { "fcmovnb",{ ST, STi } },
12677 { "fcmovne",{ ST, STi } },
12678 { "fcmovnbe",{ ST, STi } },
12679 { "fcmovnu",{ ST, STi } },
12681 { "fucomi", { ST, STi } },
12682 { "fcomi", { ST, STi } },
12683 { "(bad)", { XX } },
12687 { "fadd", { STi, ST } },
12688 { "fmul", { STi, ST } },
12689 { "(bad)", { XX } },
12690 { "(bad)", { XX } },
12691 { "fsub!M", { STi, ST } },
12692 { "fsubM", { STi, ST } },
12693 { "fdiv!M", { STi, ST } },
12694 { "fdivM", { STi, ST } },
12698 { "ffree", { STi } },
12699 { "(bad)", { XX } },
12700 { "fst", { STi } },
12701 { "fstp", { STi } },
12702 { "fucom", { STi } },
12703 { "fucomp", { STi } },
12704 { "(bad)", { XX } },
12705 { "(bad)", { XX } },
12709 { "faddp", { STi, ST } },
12710 { "fmulp", { STi, ST } },
12711 { "(bad)", { XX } },
12713 { "fsub!Mp", { STi, ST } },
12714 { "fsubMp", { STi, ST } },
12715 { "fdiv!Mp", { STi, ST } },
12716 { "fdivMp", { STi, ST } },
12720 { "ffreep", { STi } },
12721 { "(bad)", { XX } },
12722 { "(bad)", { XX } },
12723 { "(bad)", { XX } },
12725 { "fucomip", { ST, STi } },
12726 { "fcomip", { ST, STi } },
12727 { "(bad)", { XX } },
12731 static char *fgrps[][8] = {
12734 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12739 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
12744 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
12749 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
12754 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
12759 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12764 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
12765 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
12770 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12775 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12780 swap_operand (void)
12782 mnemonicendp[0] = '.';
12783 mnemonicendp[1] = 's';
12788 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
12789 int sizeflag ATTRIBUTE_UNUSED)
12791 /* Skip mod/rm byte. */
12797 dofloat (int sizeflag)
12799 const struct dis386 *dp;
12800 unsigned char floatop;
12802 floatop = codep[-1];
12804 if (modrm.mod != 3)
12806 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
12808 putop (float_mem[fp_indx], sizeflag);
12811 OP_E (float_mem_mode[fp_indx], sizeflag);
12814 /* Skip mod/rm byte. */
12818 dp = &float_reg[floatop - 0xd8][modrm.reg];
12819 if (dp->name == NULL)
12821 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
12823 /* Instruction fnstsw is only one with strange arg. */
12824 if (floatop == 0xdf && codep[-1] == 0xe0)
12825 strcpy (op_out[0], names16[0]);
12829 putop (dp->name, sizeflag);
12834 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
12839 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
12844 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12846 oappend ("%st" + intel_syntax);
12850 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12852 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
12853 oappend (scratchbuf + intel_syntax);
12856 /* Capital letters in template are macros. */
12858 putop (const char *in_template, int sizeflag)
12863 unsigned int l = 0, len = 1;
12866 #define SAVE_LAST(c) \
12867 if (l < len && l < sizeof (last)) \
12872 for (p = in_template; *p; p++)
12889 while (*++p != '|')
12890 if (*p == '}' || *p == '\0')
12893 /* Fall through. */
12898 while (*++p != '}')
12909 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
12913 if (l == 0 && len == 1)
12918 if (sizeflag & SUFFIX_ALWAYS)
12931 if (address_mode == mode_64bit
12932 && !(prefixes & PREFIX_ADDR))
12943 if (intel_syntax && !alt)
12945 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
12947 if (sizeflag & DFLAG)
12948 *obufp++ = intel_syntax ? 'd' : 'l';
12950 *obufp++ = intel_syntax ? 'w' : 's';
12951 used_prefixes |= (prefixes & PREFIX_DATA);
12955 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
12958 if (modrm.mod == 3)
12964 if (sizeflag & DFLAG)
12965 *obufp++ = intel_syntax ? 'd' : 'l';
12968 used_prefixes |= (prefixes & PREFIX_DATA);
12974 case 'E': /* For jcxz/jecxz */
12975 if (address_mode == mode_64bit)
12977 if (sizeflag & AFLAG)
12983 if (sizeflag & AFLAG)
12985 used_prefixes |= (prefixes & PREFIX_ADDR);
12990 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
12992 if (sizeflag & AFLAG)
12993 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
12995 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
12996 used_prefixes |= (prefixes & PREFIX_ADDR);
13000 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
13002 if ((rex & REX_W) || (sizeflag & DFLAG))
13006 if (!(rex & REX_W))
13007 used_prefixes |= (prefixes & PREFIX_DATA);
13012 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
13013 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
13015 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
13018 if (prefixes & PREFIX_DS)
13039 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
13044 /* Fall through. */
13047 if (l != 0 || len != 1)
13055 if (sizeflag & SUFFIX_ALWAYS)
13059 if (intel_mnemonic != cond)
13063 if ((prefixes & PREFIX_FWAIT) == 0)
13066 used_prefixes |= PREFIX_FWAIT;
13072 else if (intel_syntax && (sizeflag & DFLAG))
13076 if (!(rex & REX_W))
13077 used_prefixes |= (prefixes & PREFIX_DATA);
13082 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13087 /* Fall through. */
13091 if ((prefixes & PREFIX_DATA)
13093 || (sizeflag & SUFFIX_ALWAYS))
13100 if (sizeflag & DFLAG)
13104 used_prefixes |= (prefixes & PREFIX_DATA);
13111 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13113 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13117 /* Fall through. */
13120 if (l == 0 && len == 1)
13123 if (intel_syntax && !alt)
13126 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13132 if (sizeflag & DFLAG)
13133 *obufp++ = intel_syntax ? 'd' : 'l';
13136 used_prefixes |= (prefixes & PREFIX_DATA);
13142 if (l != 1 || len != 2 || last[0] != 'L')
13148 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13163 else if (sizeflag & DFLAG)
13172 if (intel_syntax && !p[1]
13173 && ((rex & REX_W) || (sizeflag & DFLAG)))
13175 if (!(rex & REX_W))
13176 used_prefixes |= (prefixes & PREFIX_DATA);
13179 if (l == 0 && len == 1)
13183 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13185 if (sizeflag & SUFFIX_ALWAYS)
13207 /* Fall through. */
13210 if (l == 0 && len == 1)
13215 if (sizeflag & SUFFIX_ALWAYS)
13221 if (sizeflag & DFLAG)
13225 used_prefixes |= (prefixes & PREFIX_DATA);
13239 if (address_mode == mode_64bit
13240 && !(prefixes & PREFIX_ADDR))
13251 if (l != 0 || len != 1)
13256 if (need_vex && vex.prefix)
13258 if (vex.prefix == DATA_PREFIX_OPCODE)
13265 if (prefixes & PREFIX_DATA)
13269 used_prefixes |= (prefixes & PREFIX_DATA);
13273 if (l == 0 && len == 1)
13275 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
13286 if (l != 1 || len != 2 || last[0] != 'X')
13294 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13296 switch (vex.length)
13310 if (l == 0 && len == 1)
13312 /* operand size flag for cwtl, cbtw */
13321 else if (sizeflag & DFLAG)
13325 if (!(rex & REX_W))
13326 used_prefixes |= (prefixes & PREFIX_DATA);
13330 if (l != 1 || len != 2 || last[0] != 'X')
13337 *obufp++ = vex.w ? 'd': 's';
13344 mnemonicendp = obufp;
13349 oappend (const char *s)
13351 obufp = stpcpy (obufp, s);
13357 if (prefixes & PREFIX_CS)
13359 used_prefixes |= PREFIX_CS;
13360 oappend ("%cs:" + intel_syntax);
13362 if (prefixes & PREFIX_DS)
13364 used_prefixes |= PREFIX_DS;
13365 oappend ("%ds:" + intel_syntax);
13367 if (prefixes & PREFIX_SS)
13369 used_prefixes |= PREFIX_SS;
13370 oappend ("%ss:" + intel_syntax);
13372 if (prefixes & PREFIX_ES)
13374 used_prefixes |= PREFIX_ES;
13375 oappend ("%es:" + intel_syntax);
13377 if (prefixes & PREFIX_FS)
13379 used_prefixes |= PREFIX_FS;
13380 oappend ("%fs:" + intel_syntax);
13382 if (prefixes & PREFIX_GS)
13384 used_prefixes |= PREFIX_GS;
13385 oappend ("%gs:" + intel_syntax);
13390 OP_indirE (int bytemode, int sizeflag)
13394 OP_E (bytemode, sizeflag);
13398 print_operand_value (char *buf, int hex, bfd_vma disp)
13400 if (address_mode == mode_64bit)
13408 sprintf_vma (tmp, disp);
13409 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
13410 strcpy (buf + 2, tmp + i);
13414 bfd_signed_vma v = disp;
13421 /* Check for possible overflow on 0x8000000000000000. */
13424 strcpy (buf, "9223372036854775808");
13438 tmp[28 - i] = (v % 10) + '0';
13442 strcpy (buf, tmp + 29 - i);
13448 sprintf (buf, "0x%x", (unsigned int) disp);
13450 sprintf (buf, "%d", (int) disp);
13454 /* Put DISP in BUF as signed hex number. */
13457 print_displacement (char *buf, bfd_vma disp)
13459 bfd_signed_vma val = disp;
13468 /* Check for possible overflow. */
13471 switch (address_mode)
13474 strcpy (buf + j, "0x8000000000000000");
13477 strcpy (buf + j, "0x80000000");
13480 strcpy (buf + j, "0x8000");
13490 sprintf_vma (tmp, (bfd_vma) val);
13491 for (i = 0; tmp[i] == '0'; i++)
13493 if (tmp[i] == '\0')
13495 strcpy (buf + j, tmp + i);
13499 intel_operand_size (int bytemode, int sizeflag)
13506 oappend ("BYTE PTR ");
13510 oappend ("WORD PTR ");
13513 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13515 oappend ("QWORD PTR ");
13524 oappend ("QWORD PTR ");
13527 if ((sizeflag & DFLAG) || bytemode == dq_mode)
13528 oappend ("DWORD PTR ");
13530 oappend ("WORD PTR ");
13531 used_prefixes |= (prefixes & PREFIX_DATA);
13535 if ((rex & REX_W) || (sizeflag & DFLAG))
13537 oappend ("WORD PTR ");
13538 if (!(rex & REX_W))
13539 used_prefixes |= (prefixes & PREFIX_DATA);
13542 if (sizeflag & DFLAG)
13543 oappend ("QWORD PTR ");
13545 oappend ("DWORD PTR ");
13546 used_prefixes |= (prefixes & PREFIX_DATA);
13551 oappend ("DWORD PTR ");
13555 oappend ("QWORD PTR ");
13558 if (address_mode == mode_64bit)
13559 oappend ("QWORD PTR ");
13561 oappend ("DWORD PTR ");
13564 if (sizeflag & DFLAG)
13565 oappend ("FWORD PTR ");
13567 oappend ("DWORD PTR ");
13568 used_prefixes |= (prefixes & PREFIX_DATA);
13571 oappend ("TBYTE PTR ");
13577 switch (vex.length)
13580 oappend ("XMMWORD PTR ");
13583 oappend ("YMMWORD PTR ");
13590 oappend ("XMMWORD PTR ");
13593 oappend ("XMMWORD PTR ");
13599 switch (vex.length)
13602 oappend ("QWORD PTR ");
13605 oappend ("XMMWORD PTR ");
13615 switch (vex.length)
13618 oappend ("QWORD PTR ");
13621 oappend ("YMMWORD PTR ");
13628 oappend ("OWORD PTR ");
13630 case vex_w_dq_mode:
13635 oappend ("QWORD PTR ");
13637 oappend ("DWORD PTR ");
13645 OP_E_register (int bytemode, int sizeflag)
13647 int reg = modrm.rm;
13648 const char **names;
13654 if ((sizeflag & SUFFIX_ALWAYS)
13655 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
13678 names = address_mode == mode_64bit ? names64 : names32;
13681 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13699 if ((sizeflag & DFLAG)
13700 || (bytemode != v_mode
13701 && bytemode != v_swap_mode))
13705 used_prefixes |= (prefixes & PREFIX_DATA);
13711 oappend (INTERNAL_DISASSEMBLER_ERROR);
13714 oappend (names[reg]);
13718 OP_E_memory (int bytemode, int sizeflag)
13721 int add = (rex & REX_B) ? 8 : 0;
13726 intel_operand_size (bytemode, sizeflag);
13729 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13731 /* 32/64 bit address mode */
13749 FETCH_DATA (the_info, codep + 1);
13750 vindex = (*codep >> 3) & 7;
13751 scale = (*codep >> 6) & 3;
13756 haveindex = vindex != 4;
13759 rbase = base + add;
13767 if (address_mode == mode_64bit && !havesib)
13773 FETCH_DATA (the_info, codep + 1);
13775 if ((disp & 0x80) != 0)
13783 /* In 32bit mode, we need index register to tell [offset] from
13784 [eiz*1 + offset]. */
13785 needindex = (havesib
13788 && address_mode == mode_32bit);
13789 havedisp = (havebase
13791 || (havesib && (haveindex || scale != 0)));
13794 if (modrm.mod != 0 || base == 5)
13796 if (havedisp || riprel)
13797 print_displacement (scratchbuf, disp);
13799 print_operand_value (scratchbuf, 1, disp);
13800 oappend (scratchbuf);
13804 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
13808 if (havebase || haveindex || riprel)
13809 used_prefixes |= PREFIX_ADDR;
13811 if (havedisp || (intel_syntax && riprel))
13813 *obufp++ = open_char;
13814 if (intel_syntax && riprel)
13817 oappend (sizeflag & AFLAG ? "rip" : "eip");
13821 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
13822 ? names64[rbase] : names32[rbase]);
13825 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13826 print index to tell base + index from base. */
13830 || (havebase && base != ESP_REG_NUM))
13832 if (!intel_syntax || havebase)
13834 *obufp++ = separator_char;
13838 oappend (address_mode == mode_64bit
13839 && (sizeflag & AFLAG)
13840 ? names64[vindex] : names32[vindex]);
13842 oappend (address_mode == mode_64bit
13843 && (sizeflag & AFLAG)
13844 ? index64 : index32);
13846 *obufp++ = scale_char;
13848 sprintf (scratchbuf, "%d", 1 << scale);
13849 oappend (scratchbuf);
13853 && (disp || modrm.mod != 0 || base == 5))
13855 if (!havedisp || (bfd_signed_vma) disp >= 0)
13860 else if (modrm.mod != 1 && disp != -disp)
13864 disp = - (bfd_signed_vma) disp;
13868 print_displacement (scratchbuf, disp);
13870 print_operand_value (scratchbuf, 1, disp);
13871 oappend (scratchbuf);
13874 *obufp++ = close_char;
13877 else if (intel_syntax)
13879 if (modrm.mod != 0 || base == 5)
13881 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13882 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13886 oappend (names_seg[ds_reg - es_reg]);
13889 print_operand_value (scratchbuf, 1, disp);
13890 oappend (scratchbuf);
13896 /* 16 bit address mode */
13897 used_prefixes |= prefixes & PREFIX_ADDR;
13904 if ((disp & 0x8000) != 0)
13909 FETCH_DATA (the_info, codep + 1);
13911 if ((disp & 0x80) != 0)
13916 if ((disp & 0x8000) != 0)
13922 if (modrm.mod != 0 || modrm.rm == 6)
13924 print_displacement (scratchbuf, disp);
13925 oappend (scratchbuf);
13928 if (modrm.mod != 0 || modrm.rm != 6)
13930 *obufp++ = open_char;
13932 oappend (index16[modrm.rm]);
13934 && (disp || modrm.mod != 0 || modrm.rm == 6))
13936 if ((bfd_signed_vma) disp >= 0)
13941 else if (modrm.mod != 1)
13945 disp = - (bfd_signed_vma) disp;
13948 print_displacement (scratchbuf, disp);
13949 oappend (scratchbuf);
13952 *obufp++ = close_char;
13955 else if (intel_syntax)
13957 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13958 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13962 oappend (names_seg[ds_reg - es_reg]);
13965 print_operand_value (scratchbuf, 1, disp & 0xffff);
13966 oappend (scratchbuf);
13972 OP_E (int bytemode, int sizeflag)
13974 /* Skip mod/rm byte. */
13978 if (modrm.mod == 3)
13979 OP_E_register (bytemode, sizeflag);
13981 OP_E_memory (bytemode, sizeflag);
13985 OP_G (int bytemode, int sizeflag)
13996 oappend (names8rex[modrm.reg + add]);
13998 oappend (names8[modrm.reg + add]);
14001 oappend (names16[modrm.reg + add]);
14004 oappend (names32[modrm.reg + add]);
14007 oappend (names64[modrm.reg + add]);
14016 oappend (names64[modrm.reg + add]);
14019 if ((sizeflag & DFLAG) || bytemode != v_mode)
14020 oappend (names32[modrm.reg + add]);
14022 oappend (names16[modrm.reg + add]);
14023 used_prefixes |= (prefixes & PREFIX_DATA);
14027 if (address_mode == mode_64bit)
14028 oappend (names64[modrm.reg + add]);
14030 oappend (names32[modrm.reg + add]);
14033 oappend (INTERNAL_DISASSEMBLER_ERROR);
14046 FETCH_DATA (the_info, codep + 8);
14047 a = *codep++ & 0xff;
14048 a |= (*codep++ & 0xff) << 8;
14049 a |= (*codep++ & 0xff) << 16;
14050 a |= (*codep++ & 0xff) << 24;
14051 b = *codep++ & 0xff;
14052 b |= (*codep++ & 0xff) << 8;
14053 b |= (*codep++ & 0xff) << 16;
14054 b |= (*codep++ & 0xff) << 24;
14055 x = a + ((bfd_vma) b << 32);
14063 static bfd_signed_vma
14066 bfd_signed_vma x = 0;
14068 FETCH_DATA (the_info, codep + 4);
14069 x = *codep++ & (bfd_signed_vma) 0xff;
14070 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14071 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14072 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14076 static bfd_signed_vma
14079 bfd_signed_vma x = 0;
14081 FETCH_DATA (the_info, codep + 4);
14082 x = *codep++ & (bfd_signed_vma) 0xff;
14083 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14084 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14085 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14087 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
14097 FETCH_DATA (the_info, codep + 2);
14098 x = *codep++ & 0xff;
14099 x |= (*codep++ & 0xff) << 8;
14104 set_op (bfd_vma op, int riprel)
14106 op_index[op_ad] = op_ad;
14107 if (address_mode == mode_64bit)
14109 op_address[op_ad] = op;
14110 op_riprel[op_ad] = riprel;
14114 /* Mask to get a 32-bit address. */
14115 op_address[op_ad] = op & 0xffffffff;
14116 op_riprel[op_ad] = riprel & 0xffffffff;
14121 OP_REG (int code, int sizeflag)
14133 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14134 case sp_reg: case bp_reg: case si_reg: case di_reg:
14135 s = names16[code - ax_reg + add];
14137 case es_reg: case ss_reg: case cs_reg:
14138 case ds_reg: case fs_reg: case gs_reg:
14139 s = names_seg[code - es_reg + add];
14141 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14142 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14145 s = names8rex[code - al_reg + add];
14147 s = names8[code - al_reg];
14149 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
14150 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
14151 if (address_mode == mode_64bit && (sizeflag & DFLAG))
14153 s = names64[code - rAX_reg + add];
14156 code += eAX_reg - rAX_reg;
14157 /* Fall through. */
14158 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14159 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14162 s = names64[code - eAX_reg + add];
14165 if (sizeflag & DFLAG)
14166 s = names32[code - eAX_reg + add];
14168 s = names16[code - eAX_reg + add];
14169 used_prefixes |= (prefixes & PREFIX_DATA);
14173 s = INTERNAL_DISASSEMBLER_ERROR;
14180 OP_IMREG (int code, int sizeflag)
14192 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14193 case sp_reg: case bp_reg: case si_reg: case di_reg:
14194 s = names16[code - ax_reg];
14196 case es_reg: case ss_reg: case cs_reg:
14197 case ds_reg: case fs_reg: case gs_reg:
14198 s = names_seg[code - es_reg];
14200 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14201 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14204 s = names8rex[code - al_reg];
14206 s = names8[code - al_reg];
14208 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14209 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14212 s = names64[code - eAX_reg];
14215 if (sizeflag & DFLAG)
14216 s = names32[code - eAX_reg];
14218 s = names16[code - eAX_reg];
14219 used_prefixes |= (prefixes & PREFIX_DATA);
14222 case z_mode_ax_reg:
14223 if ((rex & REX_W) || (sizeflag & DFLAG))
14227 if (!(rex & REX_W))
14228 used_prefixes |= (prefixes & PREFIX_DATA);
14231 s = INTERNAL_DISASSEMBLER_ERROR;
14238 OP_I (int bytemode, int sizeflag)
14241 bfd_signed_vma mask = -1;
14246 FETCH_DATA (the_info, codep + 1);
14251 if (address_mode == mode_64bit)
14256 /* Fall through. */
14263 if (sizeflag & DFLAG)
14273 used_prefixes |= (prefixes & PREFIX_DATA);
14285 oappend (INTERNAL_DISASSEMBLER_ERROR);
14290 scratchbuf[0] = '$';
14291 print_operand_value (scratchbuf + 1, 1, op);
14292 oappend (scratchbuf + intel_syntax);
14293 scratchbuf[0] = '\0';
14297 OP_I64 (int bytemode, int sizeflag)
14300 bfd_signed_vma mask = -1;
14302 if (address_mode != mode_64bit)
14304 OP_I (bytemode, sizeflag);
14311 FETCH_DATA (the_info, codep + 1);
14321 if (sizeflag & DFLAG)
14331 used_prefixes |= (prefixes & PREFIX_DATA);
14339 oappend (INTERNAL_DISASSEMBLER_ERROR);
14344 scratchbuf[0] = '$';
14345 print_operand_value (scratchbuf + 1, 1, op);
14346 oappend (scratchbuf + intel_syntax);
14347 scratchbuf[0] = '\0';
14351 OP_sI (int bytemode, int sizeflag)
14354 bfd_signed_vma mask = -1;
14359 FETCH_DATA (the_info, codep + 1);
14361 if ((op & 0x80) != 0)
14371 if (sizeflag & DFLAG)
14380 if ((op & 0x8000) != 0)
14383 used_prefixes |= (prefixes & PREFIX_DATA);
14389 if ((op & 0x8000) != 0)
14393 oappend (INTERNAL_DISASSEMBLER_ERROR);
14397 scratchbuf[0] = '$';
14398 print_operand_value (scratchbuf + 1, 1, op);
14399 oappend (scratchbuf + intel_syntax);
14403 OP_J (int bytemode, int sizeflag)
14407 bfd_vma segment = 0;
14412 FETCH_DATA (the_info, codep + 1);
14414 if ((disp & 0x80) != 0)
14419 if ((sizeflag & DFLAG) || (rex & REX_W))
14424 if ((disp & 0x8000) != 0)
14426 /* In 16bit mode, address is wrapped around at 64k within
14427 the same segment. Otherwise, a data16 prefix on a jump
14428 instruction means that the pc is masked to 16 bits after
14429 the displacement is added! */
14431 if ((prefixes & PREFIX_DATA) == 0)
14432 segment = ((start_pc + codep - start_codep)
14433 & ~((bfd_vma) 0xffff));
14435 if (!(rex & REX_W))
14436 used_prefixes |= (prefixes & PREFIX_DATA);
14439 oappend (INTERNAL_DISASSEMBLER_ERROR);
14442 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
14444 print_operand_value (scratchbuf, 1, disp);
14445 oappend (scratchbuf);
14449 OP_SEG (int bytemode, int sizeflag)
14451 if (bytemode == w_mode)
14452 oappend (names_seg[modrm.reg]);
14454 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
14458 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
14462 if (sizeflag & DFLAG)
14472 used_prefixes |= (prefixes & PREFIX_DATA);
14474 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
14476 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
14477 oappend (scratchbuf);
14481 OP_OFF (int bytemode, int sizeflag)
14485 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14486 intel_operand_size (bytemode, sizeflag);
14489 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
14496 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14497 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14499 oappend (names_seg[ds_reg - es_reg]);
14503 print_operand_value (scratchbuf, 1, off);
14504 oappend (scratchbuf);
14508 OP_OFF64 (int bytemode, int sizeflag)
14512 if (address_mode != mode_64bit
14513 || (prefixes & PREFIX_ADDR))
14515 OP_OFF (bytemode, sizeflag);
14519 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14520 intel_operand_size (bytemode, sizeflag);
14527 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14528 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14530 oappend (names_seg[ds_reg - es_reg]);
14534 print_operand_value (scratchbuf, 1, off);
14535 oappend (scratchbuf);
14539 ptr_reg (int code, int sizeflag)
14543 *obufp++ = open_char;
14544 used_prefixes |= (prefixes & PREFIX_ADDR);
14545 if (address_mode == mode_64bit)
14547 if (!(sizeflag & AFLAG))
14548 s = names32[code - eAX_reg];
14550 s = names64[code - eAX_reg];
14552 else if (sizeflag & AFLAG)
14553 s = names32[code - eAX_reg];
14555 s = names16[code - eAX_reg];
14557 *obufp++ = close_char;
14562 OP_ESreg (int code, int sizeflag)
14568 case 0x6d: /* insw/insl */
14569 intel_operand_size (z_mode, sizeflag);
14571 case 0xa5: /* movsw/movsl/movsq */
14572 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14573 case 0xab: /* stosw/stosl */
14574 case 0xaf: /* scasw/scasl */
14575 intel_operand_size (v_mode, sizeflag);
14578 intel_operand_size (b_mode, sizeflag);
14581 oappend ("%es:" + intel_syntax);
14582 ptr_reg (code, sizeflag);
14586 OP_DSreg (int code, int sizeflag)
14592 case 0x6f: /* outsw/outsl */
14593 intel_operand_size (z_mode, sizeflag);
14595 case 0xa5: /* movsw/movsl/movsq */
14596 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14597 case 0xad: /* lodsw/lodsl/lodsq */
14598 intel_operand_size (v_mode, sizeflag);
14601 intel_operand_size (b_mode, sizeflag);
14610 | PREFIX_GS)) == 0)
14611 prefixes |= PREFIX_DS;
14613 ptr_reg (code, sizeflag);
14617 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14625 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
14627 all_prefixes[last_lock_prefix] = 0;
14628 used_prefixes |= PREFIX_LOCK;
14633 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
14634 oappend (scratchbuf + intel_syntax);
14638 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14647 sprintf (scratchbuf, "db%d", modrm.reg + add);
14649 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
14650 oappend (scratchbuf);
14654 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14656 sprintf (scratchbuf, "%%tr%d", modrm.reg);
14657 oappend (scratchbuf + intel_syntax);
14661 OP_R (int bytemode, int sizeflag)
14663 if (modrm.mod == 3)
14664 OP_E (bytemode, sizeflag);
14670 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14672 int reg = modrm.reg;
14673 const char **names;
14675 used_prefixes |= (prefixes & PREFIX_DATA);
14676 if (prefixes & PREFIX_DATA)
14685 oappend (names[reg]);
14689 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14691 int reg = modrm.reg;
14692 const char **names;
14697 if (need_vex && bytemode != xmm_mode)
14699 switch (vex.length)
14713 oappend (names[reg]);
14717 OP_EM (int bytemode, int sizeflag)
14720 const char **names;
14722 if (modrm.mod != 3)
14725 && (bytemode == v_mode || bytemode == v_swap_mode))
14727 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14728 used_prefixes |= (prefixes & PREFIX_DATA);
14730 OP_E (bytemode, sizeflag);
14734 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
14737 /* Skip mod/rm byte. */
14740 used_prefixes |= (prefixes & PREFIX_DATA);
14742 if (prefixes & PREFIX_DATA)
14751 oappend (names[reg]);
14754 /* cvt* are the only instructions in sse2 which have
14755 both SSE and MMX operands and also have 0x66 prefix
14756 in their opcode. 0x66 was originally used to differentiate
14757 between SSE and MMX instruction(operands). So we have to handle the
14758 cvt* separately using OP_EMC and OP_MXC */
14760 OP_EMC (int bytemode, int sizeflag)
14762 if (modrm.mod != 3)
14764 if (intel_syntax && bytemode == v_mode)
14766 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14767 used_prefixes |= (prefixes & PREFIX_DATA);
14769 OP_E (bytemode, sizeflag);
14773 /* Skip mod/rm byte. */
14776 used_prefixes |= (prefixes & PREFIX_DATA);
14777 oappend (names_mm[modrm.rm]);
14781 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14783 used_prefixes |= (prefixes & PREFIX_DATA);
14784 oappend (names_mm[modrm.reg]);
14788 OP_EX (int bytemode, int sizeflag)
14791 const char **names;
14793 /* Skip mod/rm byte. */
14797 if (modrm.mod != 3)
14799 OP_E_memory (bytemode, sizeflag);
14808 if ((sizeflag & SUFFIX_ALWAYS)
14809 && (bytemode == x_swap_mode
14810 || bytemode == d_swap_mode
14811 || bytemode == q_swap_mode))
14815 && bytemode != xmm_mode
14816 && bytemode != xmmq_mode)
14818 switch (vex.length)
14832 oappend (names[reg]);
14836 OP_MS (int bytemode, int sizeflag)
14838 if (modrm.mod == 3)
14839 OP_EM (bytemode, sizeflag);
14845 OP_XS (int bytemode, int sizeflag)
14847 if (modrm.mod == 3)
14848 OP_EX (bytemode, sizeflag);
14854 OP_M (int bytemode, int sizeflag)
14856 if (modrm.mod == 3)
14857 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14860 OP_E (bytemode, sizeflag);
14864 OP_0f07 (int bytemode, int sizeflag)
14866 if (modrm.mod != 3 || modrm.rm != 0)
14869 OP_E (bytemode, sizeflag);
14872 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14873 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14876 NOP_Fixup1 (int bytemode, int sizeflag)
14878 if ((prefixes & PREFIX_DATA) != 0
14881 && address_mode == mode_64bit))
14882 OP_REG (bytemode, sizeflag);
14884 strcpy (obuf, "nop");
14888 NOP_Fixup2 (int bytemode, int sizeflag)
14890 if ((prefixes & PREFIX_DATA) != 0
14893 && address_mode == mode_64bit))
14894 OP_IMREG (bytemode, sizeflag);
14897 static const char *const Suffix3DNow[] = {
14898 /* 00 */ NULL, NULL, NULL, NULL,
14899 /* 04 */ NULL, NULL, NULL, NULL,
14900 /* 08 */ NULL, NULL, NULL, NULL,
14901 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
14902 /* 10 */ NULL, NULL, NULL, NULL,
14903 /* 14 */ NULL, NULL, NULL, NULL,
14904 /* 18 */ NULL, NULL, NULL, NULL,
14905 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
14906 /* 20 */ NULL, NULL, NULL, NULL,
14907 /* 24 */ NULL, NULL, NULL, NULL,
14908 /* 28 */ NULL, NULL, NULL, NULL,
14909 /* 2C */ NULL, NULL, NULL, NULL,
14910 /* 30 */ NULL, NULL, NULL, NULL,
14911 /* 34 */ NULL, NULL, NULL, NULL,
14912 /* 38 */ NULL, NULL, NULL, NULL,
14913 /* 3C */ NULL, NULL, NULL, NULL,
14914 /* 40 */ NULL, NULL, NULL, NULL,
14915 /* 44 */ NULL, NULL, NULL, NULL,
14916 /* 48 */ NULL, NULL, NULL, NULL,
14917 /* 4C */ NULL, NULL, NULL, NULL,
14918 /* 50 */ NULL, NULL, NULL, NULL,
14919 /* 54 */ NULL, NULL, NULL, NULL,
14920 /* 58 */ NULL, NULL, NULL, NULL,
14921 /* 5C */ NULL, NULL, NULL, NULL,
14922 /* 60 */ NULL, NULL, NULL, NULL,
14923 /* 64 */ NULL, NULL, NULL, NULL,
14924 /* 68 */ NULL, NULL, NULL, NULL,
14925 /* 6C */ NULL, NULL, NULL, NULL,
14926 /* 70 */ NULL, NULL, NULL, NULL,
14927 /* 74 */ NULL, NULL, NULL, NULL,
14928 /* 78 */ NULL, NULL, NULL, NULL,
14929 /* 7C */ NULL, NULL, NULL, NULL,
14930 /* 80 */ NULL, NULL, NULL, NULL,
14931 /* 84 */ NULL, NULL, NULL, NULL,
14932 /* 88 */ NULL, NULL, "pfnacc", NULL,
14933 /* 8C */ NULL, NULL, "pfpnacc", NULL,
14934 /* 90 */ "pfcmpge", NULL, NULL, NULL,
14935 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
14936 /* 98 */ NULL, NULL, "pfsub", NULL,
14937 /* 9C */ NULL, NULL, "pfadd", NULL,
14938 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
14939 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
14940 /* A8 */ NULL, NULL, "pfsubr", NULL,
14941 /* AC */ NULL, NULL, "pfacc", NULL,
14942 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
14943 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
14944 /* B8 */ NULL, NULL, NULL, "pswapd",
14945 /* BC */ NULL, NULL, NULL, "pavgusb",
14946 /* C0 */ NULL, NULL, NULL, NULL,
14947 /* C4 */ NULL, NULL, NULL, NULL,
14948 /* C8 */ NULL, NULL, NULL, NULL,
14949 /* CC */ NULL, NULL, NULL, NULL,
14950 /* D0 */ NULL, NULL, NULL, NULL,
14951 /* D4 */ NULL, NULL, NULL, NULL,
14952 /* D8 */ NULL, NULL, NULL, NULL,
14953 /* DC */ NULL, NULL, NULL, NULL,
14954 /* E0 */ NULL, NULL, NULL, NULL,
14955 /* E4 */ NULL, NULL, NULL, NULL,
14956 /* E8 */ NULL, NULL, NULL, NULL,
14957 /* EC */ NULL, NULL, NULL, NULL,
14958 /* F0 */ NULL, NULL, NULL, NULL,
14959 /* F4 */ NULL, NULL, NULL, NULL,
14960 /* F8 */ NULL, NULL, NULL, NULL,
14961 /* FC */ NULL, NULL, NULL, NULL,
14965 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14967 const char *mnemonic;
14969 FETCH_DATA (the_info, codep + 1);
14970 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14971 place where an 8-bit immediate would normally go. ie. the last
14972 byte of the instruction. */
14973 obufp = mnemonicendp;
14974 mnemonic = Suffix3DNow[*codep++ & 0xff];
14976 oappend (mnemonic);
14979 /* Since a variable sized modrm/sib chunk is between the start
14980 of the opcode (0x0f0f) and the opcode suffix, we need to do
14981 all the modrm processing first, and don't know until now that
14982 we have a bad opcode. This necessitates some cleaning up. */
14983 op_out[0][0] = '\0';
14984 op_out[1][0] = '\0';
14987 mnemonicendp = obufp;
14990 static struct op simd_cmp_op[] =
14992 { STRING_COMMA_LEN ("eq") },
14993 { STRING_COMMA_LEN ("lt") },
14994 { STRING_COMMA_LEN ("le") },
14995 { STRING_COMMA_LEN ("unord") },
14996 { STRING_COMMA_LEN ("neq") },
14997 { STRING_COMMA_LEN ("nlt") },
14998 { STRING_COMMA_LEN ("nle") },
14999 { STRING_COMMA_LEN ("ord") }
15003 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15005 unsigned int cmp_type;
15007 FETCH_DATA (the_info, codep + 1);
15008 cmp_type = *codep++ & 0xff;
15009 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
15012 char *p = mnemonicendp - 2;
15016 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
15017 mnemonicendp += simd_cmp_op[cmp_type].len;
15021 /* We have a reserved extension byte. Output it directly. */
15022 scratchbuf[0] = '$';
15023 print_operand_value (scratchbuf + 1, 1, cmp_type);
15024 oappend (scratchbuf + intel_syntax);
15025 scratchbuf[0] = '\0';
15030 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
15031 int sizeflag ATTRIBUTE_UNUSED)
15033 /* mwait %eax,%ecx */
15036 const char **names = (address_mode == mode_64bit
15037 ? names64 : names32);
15038 strcpy (op_out[0], names[0]);
15039 strcpy (op_out[1], names[1]);
15040 two_source_ops = 1;
15042 /* Skip mod/rm byte. */
15048 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
15049 int sizeflag ATTRIBUTE_UNUSED)
15051 /* monitor %eax,%ecx,%edx" */
15054 const char **op1_names;
15055 const char **names = (address_mode == mode_64bit
15056 ? names64 : names32);
15058 if (!(prefixes & PREFIX_ADDR))
15059 op1_names = (address_mode == mode_16bit
15060 ? names16 : names);
15063 /* Remove "addr16/addr32". */
15064 all_prefixes[last_addr_prefix] = 0;
15065 op1_names = (address_mode != mode_32bit
15066 ? names32 : names16);
15067 used_prefixes |= PREFIX_ADDR;
15069 strcpy (op_out[0], op1_names[0]);
15070 strcpy (op_out[1], names[1]);
15071 strcpy (op_out[2], names[2]);
15072 two_source_ops = 1;
15074 /* Skip mod/rm byte. */
15082 /* Throw away prefixes and 1st. opcode byte. */
15083 codep = insn_codep + 1;
15088 REP_Fixup (int bytemode, int sizeflag)
15090 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
15092 if (prefixes & PREFIX_REPZ)
15093 all_prefixes[last_repz_prefix] = REP_PREFIX;
15100 OP_IMREG (bytemode, sizeflag);
15103 OP_ESreg (bytemode, sizeflag);
15106 OP_DSreg (bytemode, sizeflag);
15115 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
15120 /* Change cmpxchg8b to cmpxchg16b. */
15121 char *p = mnemonicendp - 2;
15122 mnemonicendp = stpcpy (p, "16b");
15125 OP_M (bytemode, sizeflag);
15129 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
15131 const char **names;
15135 switch (vex.length)
15149 oappend (names[reg]);
15153 CRC32_Fixup (int bytemode, int sizeflag)
15155 /* Add proper suffix to "crc32". */
15156 char *p = mnemonicendp;
15175 if (sizeflag & DFLAG)
15179 used_prefixes |= (prefixes & PREFIX_DATA);
15183 oappend (INTERNAL_DISASSEMBLER_ERROR);
15190 if (modrm.mod == 3)
15194 /* Skip mod/rm byte. */
15199 add = (rex & REX_B) ? 8 : 0;
15200 if (bytemode == b_mode)
15204 oappend (names8rex[modrm.rm + add]);
15206 oappend (names8[modrm.rm + add]);
15212 oappend (names64[modrm.rm + add]);
15213 else if ((prefixes & PREFIX_DATA))
15214 oappend (names16[modrm.rm + add]);
15216 oappend (names32[modrm.rm + add]);
15220 OP_E (bytemode, sizeflag);
15224 FXSAVE_Fixup (int bytemode, int sizeflag)
15226 /* Add proper suffix to "fxsave" and "fxrstor". */
15230 char *p = mnemonicendp;
15236 OP_M (bytemode, sizeflag);
15239 /* Display the destination register operand for instructions with
15243 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15245 const char **names;
15253 switch (vex.length)
15285 oappend (names[vex.register_specifier]);
15288 /* Get the VEX immediate byte without moving codep. */
15290 static unsigned char
15291 get_vex_imm8 (int sizeflag, int opnum)
15293 int bytes_before_imm = 0;
15295 if (modrm.mod != 3)
15297 /* There are SIB/displacement bytes. */
15298 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
15300 /* 32/64 bit address mode */
15301 int base = modrm.rm;
15303 /* Check SIB byte. */
15306 FETCH_DATA (the_info, codep + 1);
15308 /* When decoding the third source, don't increase
15309 bytes_before_imm as this has already been incremented
15310 by one in OP_E_memory while decoding the second
15313 bytes_before_imm++;
15316 /* Don't increase bytes_before_imm when decoding the third source,
15317 it has already been incremented by OP_E_memory while decoding
15318 the second source operand. */
15324 /* When modrm.rm == 5 or modrm.rm == 4 and base in
15325 SIB == 5, there is a 4 byte displacement. */
15327 /* No displacement. */
15330 /* 4 byte displacement. */
15331 bytes_before_imm += 4;
15334 /* 1 byte displacement. */
15335 bytes_before_imm++;
15342 /* 16 bit address mode */
15343 /* Don't increase bytes_before_imm when decoding the third source,
15344 it has already been incremented by OP_E_memory while decoding
15345 the second source operand. */
15351 /* When modrm.rm == 6, there is a 2 byte displacement. */
15353 /* No displacement. */
15356 /* 2 byte displacement. */
15357 bytes_before_imm += 2;
15360 /* 1 byte displacement: when decoding the third source,
15361 don't increase bytes_before_imm as this has already
15362 been incremented by one in OP_E_memory while decoding
15363 the second source operand. */
15365 bytes_before_imm++;
15373 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
15374 return codep [bytes_before_imm];
15378 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
15380 const char **names;
15382 if (reg == -1 && modrm.mod != 3)
15384 OP_E_memory (bytemode, sizeflag);
15396 else if (reg > 7 && address_mode != mode_64bit)
15400 switch (vex.length)
15411 oappend (names[reg]);
15415 OP_Vex_2src (int bytemode, int sizeflag)
15417 if (modrm.mod == 3)
15419 int reg = modrm.rm;
15423 oappend (names_xmm[reg]);
15428 && (bytemode == v_mode || bytemode == v_swap_mode))
15430 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
15431 used_prefixes |= (prefixes & PREFIX_DATA);
15433 OP_E (bytemode, sizeflag);
15438 OP_Vex_2src_1 (int bytemode, int sizeflag)
15440 if (modrm.mod == 3)
15442 /* Skip mod/rm byte. */
15448 oappend (names_xmm[vex.register_specifier]);
15450 OP_Vex_2src (bytemode, sizeflag);
15454 OP_Vex_2src_2 (int bytemode, int sizeflag)
15457 OP_Vex_2src (bytemode, sizeflag);
15459 oappend (names_xmm[vex.register_specifier]);
15463 OP_EX_VexW (int bytemode, int sizeflag)
15471 /* Skip mod/rm byte. */
15476 reg = get_vex_imm8 (sizeflag, 0) >> 4;
15481 reg = get_vex_imm8 (sizeflag, 1) >> 4;
15484 OP_EX_VexReg (bytemode, sizeflag, reg);
15488 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
15489 int sizeflag ATTRIBUTE_UNUSED)
15491 /* Skip the immediate byte and check for invalid bits. */
15492 FETCH_DATA (the_info, codep + 1);
15493 if (*codep++ & 0xf)
15498 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15501 const char **names;
15503 FETCH_DATA (the_info, codep + 1);
15506 if (bytemode != x_mode)
15513 if (reg > 7 && address_mode != mode_64bit)
15516 switch (vex.length)
15527 oappend (names[reg]);
15531 OP_XMM_VexW (int bytemode, int sizeflag)
15533 /* Turn off the REX.W bit since it is used for swapping operands
15536 OP_XMM (bytemode, sizeflag);
15540 OP_EX_Vex (int bytemode, int sizeflag)
15542 if (modrm.mod != 3)
15544 if (vex.register_specifier != 0)
15548 OP_EX (bytemode, sizeflag);
15552 OP_XMM_Vex (int bytemode, int sizeflag)
15554 if (modrm.mod != 3)
15556 if (vex.register_specifier != 0)
15560 OP_XMM (bytemode, sizeflag);
15564 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15566 switch (vex.length)
15569 mnemonicendp = stpcpy (obuf, "vzeroupper");
15572 mnemonicendp = stpcpy (obuf, "vzeroall");
15579 static struct op vex_cmp_op[] =
15581 { STRING_COMMA_LEN ("eq") },
15582 { STRING_COMMA_LEN ("lt") },
15583 { STRING_COMMA_LEN ("le") },
15584 { STRING_COMMA_LEN ("unord") },
15585 { STRING_COMMA_LEN ("neq") },
15586 { STRING_COMMA_LEN ("nlt") },
15587 { STRING_COMMA_LEN ("nle") },
15588 { STRING_COMMA_LEN ("ord") },
15589 { STRING_COMMA_LEN ("eq_uq") },
15590 { STRING_COMMA_LEN ("nge") },
15591 { STRING_COMMA_LEN ("ngt") },
15592 { STRING_COMMA_LEN ("false") },
15593 { STRING_COMMA_LEN ("neq_oq") },
15594 { STRING_COMMA_LEN ("ge") },
15595 { STRING_COMMA_LEN ("gt") },
15596 { STRING_COMMA_LEN ("true") },
15597 { STRING_COMMA_LEN ("eq_os") },
15598 { STRING_COMMA_LEN ("lt_oq") },
15599 { STRING_COMMA_LEN ("le_oq") },
15600 { STRING_COMMA_LEN ("unord_s") },
15601 { STRING_COMMA_LEN ("neq_us") },
15602 { STRING_COMMA_LEN ("nlt_uq") },
15603 { STRING_COMMA_LEN ("nle_uq") },
15604 { STRING_COMMA_LEN ("ord_s") },
15605 { STRING_COMMA_LEN ("eq_us") },
15606 { STRING_COMMA_LEN ("nge_uq") },
15607 { STRING_COMMA_LEN ("ngt_uq") },
15608 { STRING_COMMA_LEN ("false_os") },
15609 { STRING_COMMA_LEN ("neq_os") },
15610 { STRING_COMMA_LEN ("ge_oq") },
15611 { STRING_COMMA_LEN ("gt_oq") },
15612 { STRING_COMMA_LEN ("true_us") },
15616 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15618 unsigned int cmp_type;
15620 FETCH_DATA (the_info, codep + 1);
15621 cmp_type = *codep++ & 0xff;
15622 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
15625 char *p = mnemonicendp - 2;
15629 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
15630 mnemonicendp += vex_cmp_op[cmp_type].len;
15634 /* We have a reserved extension byte. Output it directly. */
15635 scratchbuf[0] = '$';
15636 print_operand_value (scratchbuf + 1, 1, cmp_type);
15637 oappend (scratchbuf + intel_syntax);
15638 scratchbuf[0] = '\0';
15642 static const struct op pclmul_op[] =
15644 { STRING_COMMA_LEN ("lql") },
15645 { STRING_COMMA_LEN ("hql") },
15646 { STRING_COMMA_LEN ("lqh") },
15647 { STRING_COMMA_LEN ("hqh") }
15651 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
15652 int sizeflag ATTRIBUTE_UNUSED)
15654 unsigned int pclmul_type;
15656 FETCH_DATA (the_info, codep + 1);
15657 pclmul_type = *codep++ & 0xff;
15658 switch (pclmul_type)
15669 if (pclmul_type < ARRAY_SIZE (pclmul_op))
15672 char *p = mnemonicendp - 3;
15677 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
15678 mnemonicendp += pclmul_op[pclmul_type].len;
15682 /* We have a reserved extension byte. Output it directly. */
15683 scratchbuf[0] = '$';
15684 print_operand_value (scratchbuf + 1, 1, pclmul_type);
15685 oappend (scratchbuf + intel_syntax);
15686 scratchbuf[0] = '\0';
15691 MOVBE_Fixup (int bytemode, int sizeflag)
15693 /* Add proper suffix to "movbe". */
15694 char *p = mnemonicendp;
15703 if (sizeflag & SUFFIX_ALWAYS)
15709 if (sizeflag & DFLAG)
15713 used_prefixes |= (prefixes & PREFIX_DATA);
15718 oappend (INTERNAL_DISASSEMBLER_ERROR);
15725 OP_M (bytemode, sizeflag);
15729 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15732 const char **names;
15734 /* Skip mod/rm byte. */
15740 else if (vex.length == 256)
15750 oappend (names[reg]);
15754 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15756 const char **names;
15760 else if (vex.length == 256)
15765 oappend (names[vex.register_specifier]);
15769 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
15771 if (vex.w || vex.length == 256)
15772 OP_I (q_mode, sizeflag);
15774 OP_I (w_mode, sizeflag);