1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma, disassemble_info *);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma get64 (void);
60 static bfd_signed_vma get32 (void);
61 static bfd_signed_vma get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte *max_fetched;
125 bfd_byte the_buffer[MAX_MNEM_SIZE];
138 enum address_mode address_mode;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* Original REX prefix. */
148 static int rex_original;
149 /* REX bits in original REX prefix ignored. It may not be the same
150 as rex_original since some bits may not be ignored. */
151 static int rex_ignored;
152 /* Mark parts used in the REX prefix. When we are testing for
153 empty prefix (for 8bit register REX extension), just mask it
154 out. Otherwise test for REX bit is excuse for existence of REX
155 only in case value is nonzero. */
156 #define USED_REX(value) \
161 rex_used |= (value) | REX_OPCODE; \
164 rex_used |= REX_OPCODE; \
167 /* Flags for prefixes which we somehow handled when printing the
168 current instruction. */
169 static int used_prefixes;
171 /* Flags stored in PREFIXES. */
172 #define PREFIX_REPZ 1
173 #define PREFIX_REPNZ 2
174 #define PREFIX_LOCK 4
176 #define PREFIX_SS 0x10
177 #define PREFIX_DS 0x20
178 #define PREFIX_ES 0x40
179 #define PREFIX_FS 0x80
180 #define PREFIX_GS 0x100
181 #define PREFIX_DATA 0x200
182 #define PREFIX_ADDR 0x400
183 #define PREFIX_FWAIT 0x800
185 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
186 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
188 #define FETCH_DATA(info, addr) \
189 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
190 ? 1 : fetch_data ((info), (addr)))
193 fetch_data (struct disassemble_info *info, bfd_byte *addr)
196 struct dis_private *priv = (struct dis_private *) info->private_data;
197 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
199 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
200 status = (*info->read_memory_func) (start,
202 addr - priv->max_fetched,
208 /* If we did manage to read at least one byte, then
209 print_insn_i386 will do something sensible. Otherwise, print
210 an error. We do that here because this is where we know
212 if (priv->max_fetched == priv->the_buffer)
213 (*info->memory_error_func) (status, start, info);
214 longjmp (priv->bailout, 1);
217 priv->max_fetched = addr;
221 #define XX { NULL, 0 }
223 #define Eb { OP_E, b_mode }
224 #define EbS { OP_E, b_swap_mode }
225 #define Ev { OP_E, v_mode }
226 #define EvS { OP_E, v_swap_mode }
227 #define Ed { OP_E, d_mode }
228 #define Edq { OP_E, dq_mode }
229 #define Edqw { OP_E, dqw_mode }
230 #define Edqb { OP_E, dqb_mode }
231 #define Edqd { OP_E, dqd_mode }
232 #define Eq { OP_E, q_mode }
233 #define indirEv { OP_indirE, stack_v_mode }
234 #define indirEp { OP_indirE, f_mode }
235 #define stackEv { OP_E, stack_v_mode }
236 #define Em { OP_E, m_mode }
237 #define Ew { OP_E, w_mode }
238 #define M { OP_M, 0 } /* lea, lgdt, etc. */
239 #define Ma { OP_M, a_mode }
240 #define Mb { OP_M, b_mode }
241 #define Md { OP_M, d_mode }
242 #define Mo { OP_M, o_mode }
243 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
244 #define Mq { OP_M, q_mode }
245 #define Mx { OP_M, x_mode }
246 #define Mxmm { OP_M, xmm_mode }
247 #define Gb { OP_G, b_mode }
248 #define Gv { OP_G, v_mode }
249 #define Gd { OP_G, d_mode }
250 #define Gdq { OP_G, dq_mode }
251 #define Gm { OP_G, m_mode }
252 #define Gw { OP_G, w_mode }
253 #define Rd { OP_R, d_mode }
254 #define Rm { OP_R, m_mode }
255 #define Ib { OP_I, b_mode }
256 #define sIb { OP_sI, b_mode } /* sign extened byte */
257 #define Iv { OP_I, v_mode }
258 #define Iq { OP_I, q_mode }
259 #define Iv64 { OP_I64, v_mode }
260 #define Iw { OP_I, w_mode }
261 #define I1 { OP_I, const_1_mode }
262 #define Jb { OP_J, b_mode }
263 #define Jv { OP_J, v_mode }
264 #define Cm { OP_C, m_mode }
265 #define Dm { OP_D, m_mode }
266 #define Td { OP_T, d_mode }
267 #define Skip_MODRM { OP_Skip_MODRM, 0 }
269 #define RMeAX { OP_REG, eAX_reg }
270 #define RMeBX { OP_REG, eBX_reg }
271 #define RMeCX { OP_REG, eCX_reg }
272 #define RMeDX { OP_REG, eDX_reg }
273 #define RMeSP { OP_REG, eSP_reg }
274 #define RMeBP { OP_REG, eBP_reg }
275 #define RMeSI { OP_REG, eSI_reg }
276 #define RMeDI { OP_REG, eDI_reg }
277 #define RMrAX { OP_REG, rAX_reg }
278 #define RMrBX { OP_REG, rBX_reg }
279 #define RMrCX { OP_REG, rCX_reg }
280 #define RMrDX { OP_REG, rDX_reg }
281 #define RMrSP { OP_REG, rSP_reg }
282 #define RMrBP { OP_REG, rBP_reg }
283 #define RMrSI { OP_REG, rSI_reg }
284 #define RMrDI { OP_REG, rDI_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMAL { OP_REG, al_reg }
287 #define RMCL { OP_REG, cl_reg }
288 #define RMDL { OP_REG, dl_reg }
289 #define RMBL { OP_REG, bl_reg }
290 #define RMAH { OP_REG, ah_reg }
291 #define RMCH { OP_REG, ch_reg }
292 #define RMDH { OP_REG, dh_reg }
293 #define RMBH { OP_REG, bh_reg }
294 #define RMAX { OP_REG, ax_reg }
295 #define RMDX { OP_REG, dx_reg }
297 #define eAX { OP_IMREG, eAX_reg }
298 #define eBX { OP_IMREG, eBX_reg }
299 #define eCX { OP_IMREG, eCX_reg }
300 #define eDX { OP_IMREG, eDX_reg }
301 #define eSP { OP_IMREG, eSP_reg }
302 #define eBP { OP_IMREG, eBP_reg }
303 #define eSI { OP_IMREG, eSI_reg }
304 #define eDI { OP_IMREG, eDI_reg }
305 #define AL { OP_IMREG, al_reg }
306 #define CL { OP_IMREG, cl_reg }
307 #define DL { OP_IMREG, dl_reg }
308 #define BL { OP_IMREG, bl_reg }
309 #define AH { OP_IMREG, ah_reg }
310 #define CH { OP_IMREG, ch_reg }
311 #define DH { OP_IMREG, dh_reg }
312 #define BH { OP_IMREG, bh_reg }
313 #define AX { OP_IMREG, ax_reg }
314 #define DX { OP_IMREG, dx_reg }
315 #define zAX { OP_IMREG, z_mode_ax_reg }
316 #define indirDX { OP_IMREG, indir_dx_reg }
318 #define Sw { OP_SEG, w_mode }
319 #define Sv { OP_SEG, v_mode }
320 #define Ap { OP_DIR, 0 }
321 #define Ob { OP_OFF64, b_mode }
322 #define Ov { OP_OFF64, v_mode }
323 #define Xb { OP_DSreg, eSI_reg }
324 #define Xv { OP_DSreg, eSI_reg }
325 #define Xz { OP_DSreg, eSI_reg }
326 #define Yb { OP_ESreg, eDI_reg }
327 #define Yv { OP_ESreg, eDI_reg }
328 #define DSBX { OP_DSreg, eBX_reg }
330 #define es { OP_REG, es_reg }
331 #define ss { OP_REG, ss_reg }
332 #define cs { OP_REG, cs_reg }
333 #define ds { OP_REG, ds_reg }
334 #define fs { OP_REG, fs_reg }
335 #define gs { OP_REG, gs_reg }
337 #define MX { OP_MMX, 0 }
338 #define XM { OP_XMM, 0 }
339 #define XMM { OP_XMM, xmm_mode }
340 #define EM { OP_EM, v_mode }
341 #define EMS { OP_EM, v_swap_mode }
342 #define EMd { OP_EM, d_mode }
343 #define EMx { OP_EM, x_mode }
344 #define EXw { OP_EX, w_mode }
345 #define EXd { OP_EX, d_mode }
346 #define EXdS { OP_EX, d_swap_mode }
347 #define EXq { OP_EX, q_mode }
348 #define EXqS { OP_EX, q_swap_mode }
349 #define EXx { OP_EX, x_mode }
350 #define EXxS { OP_EX, x_swap_mode }
351 #define EXxmm { OP_EX, xmm_mode }
352 #define EXxmmq { OP_EX, xmmq_mode }
353 #define EXymmq { OP_EX, ymmq_mode }
354 #define EXVexWdq { OP_EX, vex_w_dq_mode }
355 #define MS { OP_MS, v_mode }
356 #define XS { OP_XS, v_mode }
357 #define EMCq { OP_EMC, q_mode }
358 #define MXC { OP_MXC, 0 }
359 #define OPSUF { OP_3DNowSuffix, 0 }
360 #define CMP { CMP_Fixup, 0 }
361 #define XMM0 { XMM_Fixup, 0 }
362 #define FXSAVE { FXSAVE_Fixup, 0 }
363 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
364 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
366 #define Vex { OP_VEX, vex_mode }
367 #define Vex128 { OP_VEX, vex128_mode }
368 #define Vex256 { OP_VEX, vex256_mode }
369 #define VexI4 { VEXI4_Fixup, 0}
370 #define EXdVex { OP_EX_Vex, d_mode }
371 #define EXdVexS { OP_EX_Vex, d_swap_mode }
372 #define EXqVex { OP_EX_Vex, q_mode }
373 #define EXqVexS { OP_EX_Vex, q_swap_mode }
374 #define EXVexW { OP_EX_VexW, x_mode }
375 #define EXdVexW { OP_EX_VexW, d_mode }
376 #define EXqVexW { OP_EX_VexW, q_mode }
377 #define XMVex { OP_XMM_Vex, 0 }
378 #define XMVexW { OP_XMM_VexW, 0 }
379 #define XMVexI4 { OP_REG_VexI4, x_mode }
380 #define PCLMUL { PCLMUL_Fixup, 0 }
381 #define VZERO { VZERO_Fixup, 0 }
382 #define VCMP { VCMP_Fixup, 0 }
384 /* Used handle "rep" prefix for string instructions. */
385 #define Xbr { REP_Fixup, eSI_reg }
386 #define Xvr { REP_Fixup, eSI_reg }
387 #define Ybr { REP_Fixup, eDI_reg }
388 #define Yvr { REP_Fixup, eDI_reg }
389 #define Yzr { REP_Fixup, eDI_reg }
390 #define indirDXr { REP_Fixup, indir_dx_reg }
391 #define ALr { REP_Fixup, al_reg }
392 #define eAXr { REP_Fixup, eAX_reg }
394 #define cond_jump_flag { NULL, cond_jump_mode }
395 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
397 /* bits in sizeflag */
398 #define SUFFIX_ALWAYS 4
406 /* byte operand with operand swapped */
408 /* operand size depends on prefixes */
410 /* operand size depends on prefixes with operand swapped */
414 /* double word operand */
416 /* double word operand with operand swapped */
418 /* quad word operand */
420 /* quad word operand with operand swapped */
422 /* ten-byte operand */
424 /* 16-byte XMM or 32-byte YMM operand */
426 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
428 /* 16-byte XMM operand */
430 /* 16-byte XMM or quad word operand */
432 /* 32-byte YMM or quad word operand */
434 /* d_mode in 32bit, q_mode in 64bit mode. */
436 /* pair of v_mode operands */
440 /* operand size depends on REX prefixes. */
442 /* registers like dq_mode, memory like w_mode. */
444 /* 4- or 6-byte pointer operand */
447 /* v_mode for stack-related opcodes. */
449 /* non-quad operand size depends on prefixes */
451 /* 16-byte operand */
453 /* registers like dq_mode, memory like b_mode. */
455 /* registers like dq_mode, memory like d_mode. */
457 /* normal vex mode */
459 /* 128bit vex mode */
461 /* 256bit vex mode */
463 /* operand size depends on the VEX.W bit. */
529 #define FLOAT NULL, { { NULL, FLOATCODE } }
531 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
532 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
533 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
534 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
535 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
536 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
537 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
538 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
539 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
540 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
541 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
542 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
660 MOD_VEX_3818_PREFIX_2,
661 MOD_VEX_3819_PREFIX_2,
662 MOD_VEX_381A_PREFIX_2,
663 MOD_VEX_382A_PREFIX_2,
664 MOD_VEX_382C_PREFIX_2,
665 MOD_VEX_382D_PREFIX_2,
666 MOD_VEX_382E_PREFIX_2,
667 MOD_VEX_382F_PREFIX_2
1077 THREE_BYTE_0F38 = 0,
1232 VEX_LEN_3819_P_2_M_0,
1233 VEX_LEN_381A_P_2_M_0,
1245 VEX_LEN_382A_P_2_M_0,
1556 typedef void (*op_rtn) (int bytemode, int sizeflag);
1567 /* Upper case letters in the instruction names here are macros.
1568 'A' => print 'b' if no register operands or suffix_always is true
1569 'B' => print 'b' if suffix_always is true
1570 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1572 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1573 suffix_always is true
1574 'E' => print 'e' if 32-bit form of jcxz
1575 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1576 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1577 'H' => print ",pt" or ",pn" branch hint
1578 'I' => honor following macro letter even in Intel mode (implemented only
1579 for some of the macro letters)
1581 'K' => print 'd' or 'q' if rex prefix is present.
1582 'L' => print 'l' if suffix_always is true
1583 'M' => print 'r' if intel_mnemonic is false.
1584 'N' => print 'n' if instruction has no wait "prefix"
1585 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1586 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1587 or suffix_always is true. print 'q' if rex prefix is present.
1588 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1590 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1591 'S' => print 'w', 'l' or 'q' if suffix_always is true
1592 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1593 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1594 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1595 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1596 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1597 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1598 suffix_always is true.
1599 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1600 '!' => change condition from true to false or from false to true.
1601 '%' => add 1 upper case letter to the macro.
1603 2 upper case letter macros:
1604 "XY" => print 'x' or 'y' if no register operands or suffix_always
1606 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1607 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1608 or suffix_always is true
1609 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1610 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1611 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1613 Many of the above letters print nothing in Intel mode. See "putop"
1616 Braces '{' and '}', and vertical bars '|', indicate alternative
1617 mnemonic strings for AT&T and Intel. */
1619 static const struct dis386 dis386[] = {
1621 { "addB", { Eb, Gb } },
1622 { "addS", { Ev, Gv } },
1623 { "addB", { Gb, EbS } },
1624 { "addS", { Gv, EvS } },
1625 { "addB", { AL, Ib } },
1626 { "addS", { eAX, Iv } },
1627 { X86_64_TABLE (X86_64_06) },
1628 { X86_64_TABLE (X86_64_07) },
1630 { "orB", { Eb, Gb } },
1631 { "orS", { Ev, Gv } },
1632 { "orB", { Gb, EbS } },
1633 { "orS", { Gv, EvS } },
1634 { "orB", { AL, Ib } },
1635 { "orS", { eAX, Iv } },
1636 { X86_64_TABLE (X86_64_0D) },
1637 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
1639 { "adcB", { Eb, Gb } },
1640 { "adcS", { Ev, Gv } },
1641 { "adcB", { Gb, EbS } },
1642 { "adcS", { Gv, EvS } },
1643 { "adcB", { AL, Ib } },
1644 { "adcS", { eAX, Iv } },
1645 { X86_64_TABLE (X86_64_16) },
1646 { X86_64_TABLE (X86_64_17) },
1648 { "sbbB", { Eb, Gb } },
1649 { "sbbS", { Ev, Gv } },
1650 { "sbbB", { Gb, EbS } },
1651 { "sbbS", { Gv, EvS } },
1652 { "sbbB", { AL, Ib } },
1653 { "sbbS", { eAX, Iv } },
1654 { X86_64_TABLE (X86_64_1E) },
1655 { X86_64_TABLE (X86_64_1F) },
1657 { "andB", { Eb, Gb } },
1658 { "andS", { Ev, Gv } },
1659 { "andB", { Gb, EbS } },
1660 { "andS", { Gv, EvS } },
1661 { "andB", { AL, Ib } },
1662 { "andS", { eAX, Iv } },
1663 { "(bad)", { XX } }, /* SEG ES prefix */
1664 { X86_64_TABLE (X86_64_27) },
1666 { "subB", { Eb, Gb } },
1667 { "subS", { Ev, Gv } },
1668 { "subB", { Gb, EbS } },
1669 { "subS", { Gv, EvS } },
1670 { "subB", { AL, Ib } },
1671 { "subS", { eAX, Iv } },
1672 { "(bad)", { XX } }, /* SEG CS prefix */
1673 { X86_64_TABLE (X86_64_2F) },
1675 { "xorB", { Eb, Gb } },
1676 { "xorS", { Ev, Gv } },
1677 { "xorB", { Gb, EbS } },
1678 { "xorS", { Gv, EvS } },
1679 { "xorB", { AL, Ib } },
1680 { "xorS", { eAX, Iv } },
1681 { "(bad)", { XX } }, /* SEG SS prefix */
1682 { X86_64_TABLE (X86_64_37) },
1684 { "cmpB", { Eb, Gb } },
1685 { "cmpS", { Ev, Gv } },
1686 { "cmpB", { Gb, EbS } },
1687 { "cmpS", { Gv, EvS } },
1688 { "cmpB", { AL, Ib } },
1689 { "cmpS", { eAX, Iv } },
1690 { "(bad)", { XX } }, /* SEG DS prefix */
1691 { X86_64_TABLE (X86_64_3F) },
1693 { "inc{S|}", { RMeAX } },
1694 { "inc{S|}", { RMeCX } },
1695 { "inc{S|}", { RMeDX } },
1696 { "inc{S|}", { RMeBX } },
1697 { "inc{S|}", { RMeSP } },
1698 { "inc{S|}", { RMeBP } },
1699 { "inc{S|}", { RMeSI } },
1700 { "inc{S|}", { RMeDI } },
1702 { "dec{S|}", { RMeAX } },
1703 { "dec{S|}", { RMeCX } },
1704 { "dec{S|}", { RMeDX } },
1705 { "dec{S|}", { RMeBX } },
1706 { "dec{S|}", { RMeSP } },
1707 { "dec{S|}", { RMeBP } },
1708 { "dec{S|}", { RMeSI } },
1709 { "dec{S|}", { RMeDI } },
1711 { "pushV", { RMrAX } },
1712 { "pushV", { RMrCX } },
1713 { "pushV", { RMrDX } },
1714 { "pushV", { RMrBX } },
1715 { "pushV", { RMrSP } },
1716 { "pushV", { RMrBP } },
1717 { "pushV", { RMrSI } },
1718 { "pushV", { RMrDI } },
1720 { "popV", { RMrAX } },
1721 { "popV", { RMrCX } },
1722 { "popV", { RMrDX } },
1723 { "popV", { RMrBX } },
1724 { "popV", { RMrSP } },
1725 { "popV", { RMrBP } },
1726 { "popV", { RMrSI } },
1727 { "popV", { RMrDI } },
1729 { X86_64_TABLE (X86_64_60) },
1730 { X86_64_TABLE (X86_64_61) },
1731 { X86_64_TABLE (X86_64_62) },
1732 { X86_64_TABLE (X86_64_63) },
1733 { "(bad)", { XX } }, /* seg fs */
1734 { "(bad)", { XX } }, /* seg gs */
1735 { "(bad)", { XX } }, /* op size prefix */
1736 { "(bad)", { XX } }, /* adr size prefix */
1738 { "pushT", { Iq } },
1739 { "imulS", { Gv, Ev, Iv } },
1740 { "pushT", { sIb } },
1741 { "imulS", { Gv, Ev, sIb } },
1742 { "ins{b|}", { Ybr, indirDX } },
1743 { X86_64_TABLE (X86_64_6D) },
1744 { "outs{b|}", { indirDXr, Xb } },
1745 { X86_64_TABLE (X86_64_6F) },
1747 { "joH", { Jb, XX, cond_jump_flag } },
1748 { "jnoH", { Jb, XX, cond_jump_flag } },
1749 { "jbH", { Jb, XX, cond_jump_flag } },
1750 { "jaeH", { Jb, XX, cond_jump_flag } },
1751 { "jeH", { Jb, XX, cond_jump_flag } },
1752 { "jneH", { Jb, XX, cond_jump_flag } },
1753 { "jbeH", { Jb, XX, cond_jump_flag } },
1754 { "jaH", { Jb, XX, cond_jump_flag } },
1756 { "jsH", { Jb, XX, cond_jump_flag } },
1757 { "jnsH", { Jb, XX, cond_jump_flag } },
1758 { "jpH", { Jb, XX, cond_jump_flag } },
1759 { "jnpH", { Jb, XX, cond_jump_flag } },
1760 { "jlH", { Jb, XX, cond_jump_flag } },
1761 { "jgeH", { Jb, XX, cond_jump_flag } },
1762 { "jleH", { Jb, XX, cond_jump_flag } },
1763 { "jgH", { Jb, XX, cond_jump_flag } },
1765 { REG_TABLE (REG_80) },
1766 { REG_TABLE (REG_81) },
1767 { "(bad)", { XX } },
1768 { REG_TABLE (REG_82) },
1769 { "testB", { Eb, Gb } },
1770 { "testS", { Ev, Gv } },
1771 { "xchgB", { Eb, Gb } },
1772 { "xchgS", { Ev, Gv } },
1774 { "movB", { Eb, Gb } },
1775 { "movS", { Ev, Gv } },
1776 { "movB", { Gb, EbS } },
1777 { "movS", { Gv, EvS } },
1778 { "movD", { Sv, Sw } },
1779 { MOD_TABLE (MOD_8D) },
1780 { "movD", { Sw, Sv } },
1781 { REG_TABLE (REG_8F) },
1783 { PREFIX_TABLE (PREFIX_90) },
1784 { "xchgS", { RMeCX, eAX } },
1785 { "xchgS", { RMeDX, eAX } },
1786 { "xchgS", { RMeBX, eAX } },
1787 { "xchgS", { RMeSP, eAX } },
1788 { "xchgS", { RMeBP, eAX } },
1789 { "xchgS", { RMeSI, eAX } },
1790 { "xchgS", { RMeDI, eAX } },
1792 { "cW{t|}R", { XX } },
1793 { "cR{t|}O", { XX } },
1794 { X86_64_TABLE (X86_64_9A) },
1795 { "(bad)", { XX } }, /* fwait */
1796 { "pushfT", { XX } },
1797 { "popfT", { XX } },
1801 { "mov%LB", { AL, Ob } },
1802 { "mov%LS", { eAX, Ov } },
1803 { "mov%LB", { Ob, AL } },
1804 { "mov%LS", { Ov, eAX } },
1805 { "movs{b|}", { Ybr, Xb } },
1806 { "movs{R|}", { Yvr, Xv } },
1807 { "cmps{b|}", { Xb, Yb } },
1808 { "cmps{R|}", { Xv, Yv } },
1810 { "testB", { AL, Ib } },
1811 { "testS", { eAX, Iv } },
1812 { "stosB", { Ybr, AL } },
1813 { "stosS", { Yvr, eAX } },
1814 { "lodsB", { ALr, Xb } },
1815 { "lodsS", { eAXr, Xv } },
1816 { "scasB", { AL, Yb } },
1817 { "scasS", { eAX, Yv } },
1819 { "movB", { RMAL, Ib } },
1820 { "movB", { RMCL, Ib } },
1821 { "movB", { RMDL, Ib } },
1822 { "movB", { RMBL, Ib } },
1823 { "movB", { RMAH, Ib } },
1824 { "movB", { RMCH, Ib } },
1825 { "movB", { RMDH, Ib } },
1826 { "movB", { RMBH, Ib } },
1828 { "mov%LV", { RMeAX, Iv64 } },
1829 { "mov%LV", { RMeCX, Iv64 } },
1830 { "mov%LV", { RMeDX, Iv64 } },
1831 { "mov%LV", { RMeBX, Iv64 } },
1832 { "mov%LV", { RMeSP, Iv64 } },
1833 { "mov%LV", { RMeBP, Iv64 } },
1834 { "mov%LV", { RMeSI, Iv64 } },
1835 { "mov%LV", { RMeDI, Iv64 } },
1837 { REG_TABLE (REG_C0) },
1838 { REG_TABLE (REG_C1) },
1841 { X86_64_TABLE (X86_64_C4) },
1842 { X86_64_TABLE (X86_64_C5) },
1843 { REG_TABLE (REG_C6) },
1844 { REG_TABLE (REG_C7) },
1846 { "enterT", { Iw, Ib } },
1847 { "leaveT", { XX } },
1848 { "Jret{|f}P", { Iw } },
1849 { "Jret{|f}P", { XX } },
1852 { X86_64_TABLE (X86_64_CE) },
1853 { "iretP", { XX } },
1855 { REG_TABLE (REG_D0) },
1856 { REG_TABLE (REG_D1) },
1857 { REG_TABLE (REG_D2) },
1858 { REG_TABLE (REG_D3) },
1859 { X86_64_TABLE (X86_64_D4) },
1860 { X86_64_TABLE (X86_64_D5) },
1861 { "(bad)", { XX } },
1862 { "xlat", { DSBX } },
1873 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
1874 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
1875 { "loopFH", { Jb, XX, loop_jcxz_flag } },
1876 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
1877 { "inB", { AL, Ib } },
1878 { "inG", { zAX, Ib } },
1879 { "outB", { Ib, AL } },
1880 { "outG", { Ib, zAX } },
1882 { "callT", { Jv } },
1884 { X86_64_TABLE (X86_64_EA) },
1886 { "inB", { AL, indirDX } },
1887 { "inG", { zAX, indirDX } },
1888 { "outB", { indirDX, AL } },
1889 { "outG", { indirDX, zAX } },
1891 { "(bad)", { XX } }, /* lock prefix */
1892 { "icebp", { XX } },
1893 { "(bad)", { XX } }, /* repne */
1894 { "(bad)", { XX } }, /* repz */
1897 { REG_TABLE (REG_F6) },
1898 { REG_TABLE (REG_F7) },
1906 { REG_TABLE (REG_FE) },
1907 { REG_TABLE (REG_FF) },
1910 static const struct dis386 dis386_twobyte[] = {
1912 { REG_TABLE (REG_0F00 ) },
1913 { REG_TABLE (REG_0F01 ) },
1914 { "larS", { Gv, Ew } },
1915 { "lslS", { Gv, Ew } },
1916 { "(bad)", { XX } },
1917 { "syscall", { XX } },
1919 { "sysretP", { XX } },
1922 { "wbinvd", { XX } },
1923 { "(bad)", { XX } },
1925 { "(bad)", { XX } },
1926 { REG_TABLE (REG_0F0D) },
1927 { "femms", { XX } },
1928 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1930 { PREFIX_TABLE (PREFIX_0F10) },
1931 { PREFIX_TABLE (PREFIX_0F11) },
1932 { PREFIX_TABLE (PREFIX_0F12) },
1933 { MOD_TABLE (MOD_0F13) },
1934 { "unpcklpX", { XM, EXx } },
1935 { "unpckhpX", { XM, EXx } },
1936 { PREFIX_TABLE (PREFIX_0F16) },
1937 { MOD_TABLE (MOD_0F17) },
1939 { REG_TABLE (REG_0F18) },
1948 { MOD_TABLE (MOD_0F20) },
1949 { MOD_TABLE (MOD_0F21) },
1950 { MOD_TABLE (MOD_0F22) },
1951 { MOD_TABLE (MOD_0F23) },
1952 { MOD_TABLE (MOD_0F24) },
1953 { "(bad)", { XX } },
1954 { MOD_TABLE (MOD_0F26) },
1955 { "(bad)", { XX } },
1957 { "movapX", { XM, EXx } },
1958 { "movapX", { EXxS, XM } },
1959 { PREFIX_TABLE (PREFIX_0F2A) },
1960 { PREFIX_TABLE (PREFIX_0F2B) },
1961 { PREFIX_TABLE (PREFIX_0F2C) },
1962 { PREFIX_TABLE (PREFIX_0F2D) },
1963 { PREFIX_TABLE (PREFIX_0F2E) },
1964 { PREFIX_TABLE (PREFIX_0F2F) },
1966 { "wrmsr", { XX } },
1967 { "rdtsc", { XX } },
1968 { "rdmsr", { XX } },
1969 { "rdpmc", { XX } },
1970 { "sysenter", { XX } },
1971 { "sysexit", { XX } },
1972 { "(bad)", { XX } },
1973 { "getsec", { XX } },
1975 { THREE_BYTE_TABLE (THREE_BYTE_0F38) },
1976 { "(bad)", { XX } },
1977 { THREE_BYTE_TABLE (THREE_BYTE_0F3A) },
1978 { "(bad)", { XX } },
1979 { "(bad)", { XX } },
1980 { "(bad)", { XX } },
1981 { "(bad)", { XX } },
1982 { "(bad)", { XX } },
1984 { "cmovoS", { Gv, Ev } },
1985 { "cmovnoS", { Gv, Ev } },
1986 { "cmovbS", { Gv, Ev } },
1987 { "cmovaeS", { Gv, Ev } },
1988 { "cmoveS", { Gv, Ev } },
1989 { "cmovneS", { Gv, Ev } },
1990 { "cmovbeS", { Gv, Ev } },
1991 { "cmovaS", { Gv, Ev } },
1993 { "cmovsS", { Gv, Ev } },
1994 { "cmovnsS", { Gv, Ev } },
1995 { "cmovpS", { Gv, Ev } },
1996 { "cmovnpS", { Gv, Ev } },
1997 { "cmovlS", { Gv, Ev } },
1998 { "cmovgeS", { Gv, Ev } },
1999 { "cmovleS", { Gv, Ev } },
2000 { "cmovgS", { Gv, Ev } },
2002 { MOD_TABLE (MOD_0F51) },
2003 { PREFIX_TABLE (PREFIX_0F51) },
2004 { PREFIX_TABLE (PREFIX_0F52) },
2005 { PREFIX_TABLE (PREFIX_0F53) },
2006 { "andpX", { XM, EXx } },
2007 { "andnpX", { XM, EXx } },
2008 { "orpX", { XM, EXx } },
2009 { "xorpX", { XM, EXx } },
2011 { PREFIX_TABLE (PREFIX_0F58) },
2012 { PREFIX_TABLE (PREFIX_0F59) },
2013 { PREFIX_TABLE (PREFIX_0F5A) },
2014 { PREFIX_TABLE (PREFIX_0F5B) },
2015 { PREFIX_TABLE (PREFIX_0F5C) },
2016 { PREFIX_TABLE (PREFIX_0F5D) },
2017 { PREFIX_TABLE (PREFIX_0F5E) },
2018 { PREFIX_TABLE (PREFIX_0F5F) },
2020 { PREFIX_TABLE (PREFIX_0F60) },
2021 { PREFIX_TABLE (PREFIX_0F61) },
2022 { PREFIX_TABLE (PREFIX_0F62) },
2023 { "packsswb", { MX, EM } },
2024 { "pcmpgtb", { MX, EM } },
2025 { "pcmpgtw", { MX, EM } },
2026 { "pcmpgtd", { MX, EM } },
2027 { "packuswb", { MX, EM } },
2029 { "punpckhbw", { MX, EM } },
2030 { "punpckhwd", { MX, EM } },
2031 { "punpckhdq", { MX, EM } },
2032 { "packssdw", { MX, EM } },
2033 { PREFIX_TABLE (PREFIX_0F6C) },
2034 { PREFIX_TABLE (PREFIX_0F6D) },
2035 { "movK", { MX, Edq } },
2036 { PREFIX_TABLE (PREFIX_0F6F) },
2038 { PREFIX_TABLE (PREFIX_0F70) },
2039 { REG_TABLE (REG_0F71) },
2040 { REG_TABLE (REG_0F72) },
2041 { REG_TABLE (REG_0F73) },
2042 { "pcmpeqb", { MX, EM } },
2043 { "pcmpeqw", { MX, EM } },
2044 { "pcmpeqd", { MX, EM } },
2047 { PREFIX_TABLE (PREFIX_0F78) },
2048 { PREFIX_TABLE (PREFIX_0F79) },
2049 { THREE_BYTE_TABLE (THREE_BYTE_0F7A) },
2050 { "(bad)", { XX } },
2051 { PREFIX_TABLE (PREFIX_0F7C) },
2052 { PREFIX_TABLE (PREFIX_0F7D) },
2053 { PREFIX_TABLE (PREFIX_0F7E) },
2054 { PREFIX_TABLE (PREFIX_0F7F) },
2056 { "joH", { Jv, XX, cond_jump_flag } },
2057 { "jnoH", { Jv, XX, cond_jump_flag } },
2058 { "jbH", { Jv, XX, cond_jump_flag } },
2059 { "jaeH", { Jv, XX, cond_jump_flag } },
2060 { "jeH", { Jv, XX, cond_jump_flag } },
2061 { "jneH", { Jv, XX, cond_jump_flag } },
2062 { "jbeH", { Jv, XX, cond_jump_flag } },
2063 { "jaH", { Jv, XX, cond_jump_flag } },
2065 { "jsH", { Jv, XX, cond_jump_flag } },
2066 { "jnsH", { Jv, XX, cond_jump_flag } },
2067 { "jpH", { Jv, XX, cond_jump_flag } },
2068 { "jnpH", { Jv, XX, cond_jump_flag } },
2069 { "jlH", { Jv, XX, cond_jump_flag } },
2070 { "jgeH", { Jv, XX, cond_jump_flag } },
2071 { "jleH", { Jv, XX, cond_jump_flag } },
2072 { "jgH", { Jv, XX, cond_jump_flag } },
2075 { "setno", { Eb } },
2077 { "setae", { Eb } },
2079 { "setne", { Eb } },
2080 { "setbe", { Eb } },
2084 { "setns", { Eb } },
2086 { "setnp", { Eb } },
2088 { "setge", { Eb } },
2089 { "setle", { Eb } },
2092 { "pushT", { fs } },
2094 { "cpuid", { XX } },
2095 { "btS", { Ev, Gv } },
2096 { "shldS", { Ev, Gv, Ib } },
2097 { "shldS", { Ev, Gv, CL } },
2098 { REG_TABLE (REG_0FA6) },
2099 { REG_TABLE (REG_0FA7) },
2101 { "pushT", { gs } },
2104 { "btsS", { Ev, Gv } },
2105 { "shrdS", { Ev, Gv, Ib } },
2106 { "shrdS", { Ev, Gv, CL } },
2107 { REG_TABLE (REG_0FAE) },
2108 { "imulS", { Gv, Ev } },
2110 { "cmpxchgB", { Eb, Gb } },
2111 { "cmpxchgS", { Ev, Gv } },
2112 { MOD_TABLE (MOD_0FB2) },
2113 { "btrS", { Ev, Gv } },
2114 { MOD_TABLE (MOD_0FB4) },
2115 { MOD_TABLE (MOD_0FB5) },
2116 { "movz{bR|x}", { Gv, Eb } },
2117 { "movz{wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
2119 { PREFIX_TABLE (PREFIX_0FB8) },
2121 { REG_TABLE (REG_0FBA) },
2122 { "btcS", { Ev, Gv } },
2123 { "bsfS", { Gv, Ev } },
2124 { PREFIX_TABLE (PREFIX_0FBD) },
2125 { "movs{bR|x}", { Gv, Eb } },
2126 { "movs{wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
2128 { "xaddB", { Eb, Gb } },
2129 { "xaddS", { Ev, Gv } },
2130 { PREFIX_TABLE (PREFIX_0FC2) },
2131 { PREFIX_TABLE (PREFIX_0FC3) },
2132 { "pinsrw", { MX, Edqw, Ib } },
2133 { "pextrw", { Gdq, MS, Ib } },
2134 { "shufpX", { XM, EXx, Ib } },
2135 { REG_TABLE (REG_0FC7) },
2137 { "bswap", { RMeAX } },
2138 { "bswap", { RMeCX } },
2139 { "bswap", { RMeDX } },
2140 { "bswap", { RMeBX } },
2141 { "bswap", { RMeSP } },
2142 { "bswap", { RMeBP } },
2143 { "bswap", { RMeSI } },
2144 { "bswap", { RMeDI } },
2146 { PREFIX_TABLE (PREFIX_0FD0) },
2147 { "psrlw", { MX, EM } },
2148 { "psrld", { MX, EM } },
2149 { "psrlq", { MX, EM } },
2150 { "paddq", { MX, EM } },
2151 { "pmullw", { MX, EM } },
2152 { PREFIX_TABLE (PREFIX_0FD6) },
2153 { MOD_TABLE (MOD_0FD7) },
2155 { "psubusb", { MX, EM } },
2156 { "psubusw", { MX, EM } },
2157 { "pminub", { MX, EM } },
2158 { "pand", { MX, EM } },
2159 { "paddusb", { MX, EM } },
2160 { "paddusw", { MX, EM } },
2161 { "pmaxub", { MX, EM } },
2162 { "pandn", { MX, EM } },
2164 { "pavgb", { MX, EM } },
2165 { "psraw", { MX, EM } },
2166 { "psrad", { MX, EM } },
2167 { "pavgw", { MX, EM } },
2168 { "pmulhuw", { MX, EM } },
2169 { "pmulhw", { MX, EM } },
2170 { PREFIX_TABLE (PREFIX_0FE6) },
2171 { PREFIX_TABLE (PREFIX_0FE7) },
2173 { "psubsb", { MX, EM } },
2174 { "psubsw", { MX, EM } },
2175 { "pminsw", { MX, EM } },
2176 { "por", { MX, EM } },
2177 { "paddsb", { MX, EM } },
2178 { "paddsw", { MX, EM } },
2179 { "pmaxsw", { MX, EM } },
2180 { "pxor", { MX, EM } },
2182 { PREFIX_TABLE (PREFIX_0FF0) },
2183 { "psllw", { MX, EM } },
2184 { "pslld", { MX, EM } },
2185 { "psllq", { MX, EM } },
2186 { "pmuludq", { MX, EM } },
2187 { "pmaddwd", { MX, EM } },
2188 { "psadbw", { MX, EM } },
2189 { PREFIX_TABLE (PREFIX_0FF7) },
2191 { "psubb", { MX, EM } },
2192 { "psubw", { MX, EM } },
2193 { "psubd", { MX, EM } },
2194 { "psubq", { MX, EM } },
2195 { "paddb", { MX, EM } },
2196 { "paddw", { MX, EM } },
2197 { "paddd", { MX, EM } },
2198 { "(bad)", { XX } },
2201 static const unsigned char onebyte_has_modrm[256] = {
2202 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2203 /* ------------------------------- */
2204 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2205 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2206 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2207 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2208 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2209 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2210 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2211 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2212 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2213 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2214 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2215 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2216 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2217 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2218 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2219 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2220 /* ------------------------------- */
2221 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2224 static const unsigned char twobyte_has_modrm[256] = {
2225 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2226 /* ------------------------------- */
2227 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2228 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2229 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2230 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2231 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2232 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2233 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2234 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2235 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2236 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2237 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2238 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2239 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2240 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2241 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2242 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2243 /* ------------------------------- */
2244 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2247 static char obuf[100];
2249 static char *mnemonicendp;
2250 static char scratchbuf[100];
2251 static unsigned char *start_codep;
2252 static unsigned char *insn_codep;
2253 static unsigned char *codep;
2254 static int last_lock_prefix;
2255 static int last_repz_prefix;
2256 static int last_repnz_prefix;
2257 static int last_data_prefix;
2258 static int last_addr_prefix;
2259 static int last_rex_prefix;
2260 static int last_seg_prefix;
2261 #define MAX_CODE_LENGTH 15
2262 /* We can up to 14 prefixes since the maximum instruction length is
2264 static int all_prefixes[MAX_CODE_LENGTH - 1];
2265 static disassemble_info *the_info;
2273 static unsigned char need_modrm;
2276 int register_specifier;
2282 static unsigned char need_vex;
2283 static unsigned char need_vex_reg;
2284 static unsigned char vex_w_done;
2292 /* If we are accessing mod/rm/reg without need_modrm set, then the
2293 values are stale. Hitting this abort likely indicates that you
2294 need to update onebyte_has_modrm or twobyte_has_modrm. */
2295 #define MODRM_CHECK if (!need_modrm) abort ()
2297 static const char **names64;
2298 static const char **names32;
2299 static const char **names16;
2300 static const char **names8;
2301 static const char **names8rex;
2302 static const char **names_seg;
2303 static const char *index64;
2304 static const char *index32;
2305 static const char **index16;
2307 static const char *intel_names64[] = {
2308 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2309 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2311 static const char *intel_names32[] = {
2312 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2313 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2315 static const char *intel_names16[] = {
2316 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2317 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2319 static const char *intel_names8[] = {
2320 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2322 static const char *intel_names8rex[] = {
2323 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2324 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2326 static const char *intel_names_seg[] = {
2327 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2329 static const char *intel_index64 = "riz";
2330 static const char *intel_index32 = "eiz";
2331 static const char *intel_index16[] = {
2332 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2335 static const char *att_names64[] = {
2336 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2337 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2339 static const char *att_names32[] = {
2340 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2341 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2343 static const char *att_names16[] = {
2344 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2345 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2347 static const char *att_names8[] = {
2348 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2350 static const char *att_names8rex[] = {
2351 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2352 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2354 static const char *att_names_seg[] = {
2355 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2357 static const char *att_index64 = "%riz";
2358 static const char *att_index32 = "%eiz";
2359 static const char *att_index16[] = {
2360 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2363 static const struct dis386 reg_table[][8] = {
2366 { "addA", { Eb, Ib } },
2367 { "orA", { Eb, Ib } },
2368 { "adcA", { Eb, Ib } },
2369 { "sbbA", { Eb, Ib } },
2370 { "andA", { Eb, Ib } },
2371 { "subA", { Eb, Ib } },
2372 { "xorA", { Eb, Ib } },
2373 { "cmpA", { Eb, Ib } },
2377 { "addQ", { Ev, Iv } },
2378 { "orQ", { Ev, Iv } },
2379 { "adcQ", { Ev, Iv } },
2380 { "sbbQ", { Ev, Iv } },
2381 { "andQ", { Ev, Iv } },
2382 { "subQ", { Ev, Iv } },
2383 { "xorQ", { Ev, Iv } },
2384 { "cmpQ", { Ev, Iv } },
2388 { "addQ", { Ev, sIb } },
2389 { "orQ", { Ev, sIb } },
2390 { "adcQ", { Ev, sIb } },
2391 { "sbbQ", { Ev, sIb } },
2392 { "andQ", { Ev, sIb } },
2393 { "subQ", { Ev, sIb } },
2394 { "xorQ", { Ev, sIb } },
2395 { "cmpQ", { Ev, sIb } },
2399 { "popU", { stackEv } },
2400 { XOP_8F_TABLE (XOP_09) },
2401 { "(bad)", { XX } },
2402 { "(bad)", { XX } },
2403 { "(bad)", { XX } },
2404 { XOP_8F_TABLE (XOP_09) },
2405 { "(bad)", { XX } },
2406 { "(bad)", { XX } },
2410 { "rolA", { Eb, Ib } },
2411 { "rorA", { Eb, Ib } },
2412 { "rclA", { Eb, Ib } },
2413 { "rcrA", { Eb, Ib } },
2414 { "shlA", { Eb, Ib } },
2415 { "shrA", { Eb, Ib } },
2416 { "(bad)", { XX } },
2417 { "sarA", { Eb, Ib } },
2421 { "rolQ", { Ev, Ib } },
2422 { "rorQ", { Ev, Ib } },
2423 { "rclQ", { Ev, Ib } },
2424 { "rcrQ", { Ev, Ib } },
2425 { "shlQ", { Ev, Ib } },
2426 { "shrQ", { Ev, Ib } },
2427 { "(bad)", { XX } },
2428 { "sarQ", { Ev, Ib } },
2432 { "movA", { Eb, Ib } },
2433 { "(bad)", { XX } },
2434 { "(bad)", { XX } },
2435 { "(bad)", { XX } },
2436 { "(bad)", { XX } },
2437 { "(bad)", { XX } },
2438 { "(bad)", { XX } },
2439 { "(bad)", { XX } },
2443 { "movQ", { Ev, Iv } },
2444 { "(bad)", { XX } },
2445 { "(bad)", { XX } },
2446 { "(bad)", { XX } },
2447 { "(bad)", { XX } },
2448 { "(bad)", { XX } },
2449 { "(bad)", { XX } },
2450 { "(bad)", { XX } },
2454 { "rolA", { Eb, I1 } },
2455 { "rorA", { Eb, I1 } },
2456 { "rclA", { Eb, I1 } },
2457 { "rcrA", { Eb, I1 } },
2458 { "shlA", { Eb, I1 } },
2459 { "shrA", { Eb, I1 } },
2460 { "(bad)", { XX } },
2461 { "sarA", { Eb, I1 } },
2465 { "rolQ", { Ev, I1 } },
2466 { "rorQ", { Ev, I1 } },
2467 { "rclQ", { Ev, I1 } },
2468 { "rcrQ", { Ev, I1 } },
2469 { "shlQ", { Ev, I1 } },
2470 { "shrQ", { Ev, I1 } },
2471 { "(bad)", { XX } },
2472 { "sarQ", { Ev, I1 } },
2476 { "rolA", { Eb, CL } },
2477 { "rorA", { Eb, CL } },
2478 { "rclA", { Eb, CL } },
2479 { "rcrA", { Eb, CL } },
2480 { "shlA", { Eb, CL } },
2481 { "shrA", { Eb, CL } },
2482 { "(bad)", { XX } },
2483 { "sarA", { Eb, CL } },
2487 { "rolQ", { Ev, CL } },
2488 { "rorQ", { Ev, CL } },
2489 { "rclQ", { Ev, CL } },
2490 { "rcrQ", { Ev, CL } },
2491 { "shlQ", { Ev, CL } },
2492 { "shrQ", { Ev, CL } },
2493 { "(bad)", { XX } },
2494 { "sarQ", { Ev, CL } },
2498 { "testA", { Eb, Ib } },
2499 { "(bad)", { XX } },
2502 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
2503 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
2504 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
2505 { "idivA", { Eb } }, /* and idiv for consistency. */
2509 { "testQ", { Ev, Iv } },
2510 { "(bad)", { XX } },
2513 { "mulQ", { Ev } }, /* Don't print the implicit register. */
2514 { "imulQ", { Ev } },
2516 { "idivQ", { Ev } },
2522 { "(bad)", { XX } },
2523 { "(bad)", { XX } },
2524 { "(bad)", { XX } },
2525 { "(bad)", { XX } },
2526 { "(bad)", { XX } },
2527 { "(bad)", { XX } },
2533 { "callT", { indirEv } },
2534 { "JcallT", { indirEp } },
2535 { "jmpT", { indirEv } },
2536 { "JjmpT", { indirEp } },
2537 { "pushU", { stackEv } },
2538 { "(bad)", { XX } },
2542 { "sldtD", { Sv } },
2548 { "(bad)", { XX } },
2549 { "(bad)", { XX } },
2553 { MOD_TABLE (MOD_0F01_REG_0) },
2554 { MOD_TABLE (MOD_0F01_REG_1) },
2555 { MOD_TABLE (MOD_0F01_REG_2) },
2556 { MOD_TABLE (MOD_0F01_REG_3) },
2557 { "smswD", { Sv } },
2558 { "(bad)", { XX } },
2560 { MOD_TABLE (MOD_0F01_REG_7) },
2564 { "prefetch", { Eb } },
2565 { "prefetchw", { Eb } },
2566 { "(bad)", { XX } },
2567 { "(bad)", { XX } },
2568 { "(bad)", { XX } },
2569 { "(bad)", { XX } },
2570 { "(bad)", { XX } },
2571 { "(bad)", { XX } },
2575 { MOD_TABLE (MOD_0F18_REG_0) },
2576 { MOD_TABLE (MOD_0F18_REG_1) },
2577 { MOD_TABLE (MOD_0F18_REG_2) },
2578 { MOD_TABLE (MOD_0F18_REG_3) },
2579 { "(bad)", { XX } },
2580 { "(bad)", { XX } },
2581 { "(bad)", { XX } },
2582 { "(bad)", { XX } },
2586 { "(bad)", { XX } },
2587 { "(bad)", { XX } },
2588 { MOD_TABLE (MOD_0F71_REG_2) },
2589 { "(bad)", { XX } },
2590 { MOD_TABLE (MOD_0F71_REG_4) },
2591 { "(bad)", { XX } },
2592 { MOD_TABLE (MOD_0F71_REG_6) },
2593 { "(bad)", { XX } },
2597 { "(bad)", { XX } },
2598 { "(bad)", { XX } },
2599 { MOD_TABLE (MOD_0F72_REG_2) },
2600 { "(bad)", { XX } },
2601 { MOD_TABLE (MOD_0F72_REG_4) },
2602 { "(bad)", { XX } },
2603 { MOD_TABLE (MOD_0F72_REG_6) },
2604 { "(bad)", { XX } },
2608 { "(bad)", { XX } },
2609 { "(bad)", { XX } },
2610 { MOD_TABLE (MOD_0F73_REG_2) },
2611 { MOD_TABLE (MOD_0F73_REG_3) },
2612 { "(bad)", { XX } },
2613 { "(bad)", { XX } },
2614 { MOD_TABLE (MOD_0F73_REG_6) },
2615 { MOD_TABLE (MOD_0F73_REG_7) },
2619 { "montmul", { { OP_0f07, 0 } } },
2620 { "xsha1", { { OP_0f07, 0 } } },
2621 { "xsha256", { { OP_0f07, 0 } } },
2622 { "(bad)", { { OP_0f07, 0 } } },
2623 { "(bad)", { { OP_0f07, 0 } } },
2624 { "(bad)", { { OP_0f07, 0 } } },
2625 { "(bad)", { { OP_0f07, 0 } } },
2626 { "(bad)", { { OP_0f07, 0 } } },
2630 { "xstore-rng", { { OP_0f07, 0 } } },
2631 { "xcrypt-ecb", { { OP_0f07, 0 } } },
2632 { "xcrypt-cbc", { { OP_0f07, 0 } } },
2633 { "xcrypt-ctr", { { OP_0f07, 0 } } },
2634 { "xcrypt-cfb", { { OP_0f07, 0 } } },
2635 { "xcrypt-ofb", { { OP_0f07, 0 } } },
2636 { "(bad)", { { OP_0f07, 0 } } },
2637 { "(bad)", { { OP_0f07, 0 } } },
2641 { MOD_TABLE (MOD_0FAE_REG_0) },
2642 { MOD_TABLE (MOD_0FAE_REG_1) },
2643 { MOD_TABLE (MOD_0FAE_REG_2) },
2644 { MOD_TABLE (MOD_0FAE_REG_3) },
2645 { MOD_TABLE (MOD_0FAE_REG_4) },
2646 { MOD_TABLE (MOD_0FAE_REG_5) },
2647 { MOD_TABLE (MOD_0FAE_REG_6) },
2648 { MOD_TABLE (MOD_0FAE_REG_7) },
2652 { "(bad)", { XX } },
2653 { "(bad)", { XX } },
2654 { "(bad)", { XX } },
2655 { "(bad)", { XX } },
2656 { "btQ", { Ev, Ib } },
2657 { "btsQ", { Ev, Ib } },
2658 { "btrQ", { Ev, Ib } },
2659 { "btcQ", { Ev, Ib } },
2663 { "(bad)", { XX } },
2664 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
2665 { "(bad)", { XX } },
2666 { "(bad)", { XX } },
2667 { "(bad)", { XX } },
2668 { "(bad)", { XX } },
2669 { MOD_TABLE (MOD_0FC7_REG_6) },
2670 { MOD_TABLE (MOD_0FC7_REG_7) },
2674 { "(bad)", { XX } },
2675 { "(bad)", { XX } },
2676 { MOD_TABLE (MOD_VEX_71_REG_2) },
2677 { "(bad)", { XX } },
2678 { MOD_TABLE (MOD_VEX_71_REG_4) },
2679 { "(bad)", { XX } },
2680 { MOD_TABLE (MOD_VEX_71_REG_6) },
2681 { "(bad)", { XX } },
2685 { "(bad)", { XX } },
2686 { "(bad)", { XX } },
2687 { MOD_TABLE (MOD_VEX_72_REG_2) },
2688 { "(bad)", { XX } },
2689 { MOD_TABLE (MOD_VEX_72_REG_4) },
2690 { "(bad)", { XX } },
2691 { MOD_TABLE (MOD_VEX_72_REG_6) },
2692 { "(bad)", { XX } },
2696 { "(bad)", { XX } },
2697 { "(bad)", { XX } },
2698 { MOD_TABLE (MOD_VEX_73_REG_2) },
2699 { MOD_TABLE (MOD_VEX_73_REG_3) },
2700 { "(bad)", { XX } },
2701 { "(bad)", { XX } },
2702 { MOD_TABLE (MOD_VEX_73_REG_6) },
2703 { MOD_TABLE (MOD_VEX_73_REG_7) },
2707 { "(bad)", { XX } },
2708 { "(bad)", { XX } },
2709 { MOD_TABLE (MOD_VEX_AE_REG_2) },
2710 { MOD_TABLE (MOD_VEX_AE_REG_3) },
2711 { "(bad)", { XX } },
2712 { "(bad)", { XX } },
2713 { "(bad)", { XX } },
2714 { "(bad)", { XX } },
2718 { "llwpcb", { { OP_LWPCB_E, 0 } } },
2719 { "slwpcb", { { OP_LWPCB_E, 0 } } },
2720 { "(bad)", { XX } },
2721 { "(bad)", { XX } },
2722 { "(bad)", { XX } },
2723 { "(bad)", { XX } },
2724 { "(bad)", { XX } },
2725 { "(bad)", { XX } },
2729 { "lwpins", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2730 { "lwpval", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2731 { "(bad)", { XX } },
2732 { "(bad)", { XX } },
2733 { "(bad)", { XX } },
2734 { "(bad)", { XX } },
2735 { "(bad)", { XX } },
2736 { "(bad)", { XX } },
2740 static const struct dis386 prefix_table[][4] = {
2743 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2744 { "pause", { XX } },
2745 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2746 { "(bad)", { XX } },
2751 { "movups", { XM, EXx } },
2752 { "movss", { XM, EXd } },
2753 { "movupd", { XM, EXx } },
2754 { "movsd", { XM, EXq } },
2759 { "movups", { EXxS, XM } },
2760 { "movss", { EXdS, XM } },
2761 { "movupd", { EXxS, XM } },
2762 { "movsd", { EXqS, XM } },
2767 { MOD_TABLE (MOD_0F12_PREFIX_0) },
2768 { "movsldup", { XM, EXx } },
2769 { "movlpd", { XM, EXq } },
2770 { "movddup", { XM, EXq } },
2775 { MOD_TABLE (MOD_0F16_PREFIX_0) },
2776 { "movshdup", { XM, EXx } },
2777 { "movhpd", { XM, EXq } },
2778 { "(bad)", { XX } },
2783 { "cvtpi2ps", { XM, EMCq } },
2784 { "cvtsi2ss%LQ", { XM, Ev } },
2785 { "cvtpi2pd", { XM, EMCq } },
2786 { "cvtsi2sd%LQ", { XM, Ev } },
2791 { MOD_TABLE (MOD_0F2B_PREFIX_0) },
2792 { MOD_TABLE (MOD_0F2B_PREFIX_1) },
2793 { MOD_TABLE (MOD_0F2B_PREFIX_2) },
2794 { MOD_TABLE (MOD_0F2B_PREFIX_3) },
2799 { "cvttps2pi", { MXC, EXq } },
2800 { "cvttss2siY", { Gv, EXd } },
2801 { "cvttpd2pi", { MXC, EXx } },
2802 { "cvttsd2siY", { Gv, EXq } },
2807 { "cvtps2pi", { MXC, EXq } },
2808 { "cvtss2siY", { Gv, EXd } },
2809 { "cvtpd2pi", { MXC, EXx } },
2810 { "cvtsd2siY", { Gv, EXq } },
2815 { "ucomiss",{ XM, EXd } },
2816 { "(bad)", { XX } },
2817 { "ucomisd",{ XM, EXq } },
2818 { "(bad)", { XX } },
2823 { "comiss", { XM, EXd } },
2824 { "(bad)", { XX } },
2825 { "comisd", { XM, EXq } },
2826 { "(bad)", { XX } },
2831 { "sqrtps", { XM, EXx } },
2832 { "sqrtss", { XM, EXd } },
2833 { "sqrtpd", { XM, EXx } },
2834 { "sqrtsd", { XM, EXq } },
2839 { "rsqrtps",{ XM, EXx } },
2840 { "rsqrtss",{ XM, EXd } },
2841 { "(bad)", { XX } },
2842 { "(bad)", { XX } },
2847 { "rcpps", { XM, EXx } },
2848 { "rcpss", { XM, EXd } },
2849 { "(bad)", { XX } },
2850 { "(bad)", { XX } },
2855 { "addps", { XM, EXx } },
2856 { "addss", { XM, EXd } },
2857 { "addpd", { XM, EXx } },
2858 { "addsd", { XM, EXq } },
2863 { "mulps", { XM, EXx } },
2864 { "mulss", { XM, EXd } },
2865 { "mulpd", { XM, EXx } },
2866 { "mulsd", { XM, EXq } },
2871 { "cvtps2pd", { XM, EXq } },
2872 { "cvtss2sd", { XM, EXd } },
2873 { "cvtpd2ps", { XM, EXx } },
2874 { "cvtsd2ss", { XM, EXq } },
2879 { "cvtdq2ps", { XM, EXx } },
2880 { "cvttps2dq", { XM, EXx } },
2881 { "cvtps2dq", { XM, EXx } },
2882 { "(bad)", { XX } },
2887 { "subps", { XM, EXx } },
2888 { "subss", { XM, EXd } },
2889 { "subpd", { XM, EXx } },
2890 { "subsd", { XM, EXq } },
2895 { "minps", { XM, EXx } },
2896 { "minss", { XM, EXd } },
2897 { "minpd", { XM, EXx } },
2898 { "minsd", { XM, EXq } },
2903 { "divps", { XM, EXx } },
2904 { "divss", { XM, EXd } },
2905 { "divpd", { XM, EXx } },
2906 { "divsd", { XM, EXq } },
2911 { "maxps", { XM, EXx } },
2912 { "maxss", { XM, EXd } },
2913 { "maxpd", { XM, EXx } },
2914 { "maxsd", { XM, EXq } },
2919 { "punpcklbw",{ MX, EMd } },
2920 { "(bad)", { XX } },
2921 { "punpcklbw",{ MX, EMx } },
2922 { "(bad)", { XX } },
2927 { "punpcklwd",{ MX, EMd } },
2928 { "(bad)", { XX } },
2929 { "punpcklwd",{ MX, EMx } },
2930 { "(bad)", { XX } },
2935 { "punpckldq",{ MX, EMd } },
2936 { "(bad)", { XX } },
2937 { "punpckldq",{ MX, EMx } },
2938 { "(bad)", { XX } },
2943 { "(bad)", { XX } },
2944 { "(bad)", { XX } },
2945 { "punpcklqdq", { XM, EXx } },
2946 { "(bad)", { XX } },
2951 { "(bad)", { XX } },
2952 { "(bad)", { XX } },
2953 { "punpckhqdq", { XM, EXx } },
2954 { "(bad)", { XX } },
2959 { "movq", { MX, EM } },
2960 { "movdqu", { XM, EXx } },
2961 { "movdqa", { XM, EXx } },
2962 { "(bad)", { XX } },
2967 { "pshufw", { MX, EM, Ib } },
2968 { "pshufhw",{ XM, EXx, Ib } },
2969 { "pshufd", { XM, EXx, Ib } },
2970 { "pshuflw",{ XM, EXx, Ib } },
2973 /* PREFIX_0F73_REG_3 */
2975 { "(bad)", { XX } },
2976 { "(bad)", { XX } },
2977 { "psrldq", { XS, Ib } },
2978 { "(bad)", { XX } },
2981 /* PREFIX_0F73_REG_7 */
2983 { "(bad)", { XX } },
2984 { "(bad)", { XX } },
2985 { "pslldq", { XS, Ib } },
2986 { "(bad)", { XX } },
2991 {"vmread", { Em, Gm } },
2993 {"extrq", { XS, Ib, Ib } },
2994 {"insertq", { XM, XS, Ib, Ib } },
2999 {"vmwrite", { Gm, Em } },
3001 {"extrq", { XM, XS } },
3002 {"insertq", { XM, XS } },
3007 { "(bad)", { XX } },
3008 { "(bad)", { XX } },
3009 { "haddpd", { XM, EXx } },
3010 { "haddps", { XM, EXx } },
3015 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "hsubpd", { XM, EXx } },
3018 { "hsubps", { XM, EXx } },
3023 { "movK", { Edq, MX } },
3024 { "movq", { XM, EXq } },
3025 { "movK", { Edq, XM } },
3026 { "(bad)", { XX } },
3031 { "movq", { EMS, MX } },
3032 { "movdqu", { EXxS, XM } },
3033 { "movdqa", { EXxS, XM } },
3034 { "(bad)", { XX } },
3039 { "(bad)", { XX } },
3040 { "popcntS", { Gv, Ev } },
3041 { "(bad)", { XX } },
3042 { "(bad)", { XX } },
3047 { "bsrS", { Gv, Ev } },
3048 { "lzcntS", { Gv, Ev } },
3049 { "bsrS", { Gv, Ev } },
3050 { "(bad)", { XX } },
3055 { "cmpps", { XM, EXx, CMP } },
3056 { "cmpss", { XM, EXd, CMP } },
3057 { "cmppd", { XM, EXx, CMP } },
3058 { "cmpsd", { XM, EXq, CMP } },
3063 { "movntiS", { Ma, Gv } },
3064 { "(bad)", { XX } },
3065 { "(bad)", { XX } },
3066 { "(bad)", { XX } },
3069 /* PREFIX_0FC7_REG_6 */
3071 { "vmptrld",{ Mq } },
3072 { "vmxon", { Mq } },
3073 { "vmclear",{ Mq } },
3074 { "(bad)", { XX } },
3079 { "(bad)", { XX } },
3080 { "(bad)", { XX } },
3081 { "addsubpd", { XM, EXx } },
3082 { "addsubps", { XM, EXx } },
3087 { "(bad)", { XX } },
3088 { "movq2dq",{ XM, MS } },
3089 { "movq", { EXqS, XM } },
3090 { "movdq2q",{ MX, XS } },
3095 { "(bad)", { XX } },
3096 { "cvtdq2pd", { XM, EXq } },
3097 { "cvttpd2dq", { XM, EXx } },
3098 { "cvtpd2dq", { XM, EXx } },
3103 { "movntq", { Mq, MX } },
3104 { "(bad)", { XX } },
3105 { MOD_TABLE (MOD_0FE7_PREFIX_2) },
3106 { "(bad)", { XX } },
3111 { "(bad)", { XX } },
3112 { "(bad)", { XX } },
3113 { "(bad)", { XX } },
3114 { MOD_TABLE (MOD_0FF0_PREFIX_3) },
3119 { "maskmovq", { MX, MS } },
3120 { "(bad)", { XX } },
3121 { "maskmovdqu", { XM, XS } },
3122 { "(bad)", { XX } },
3127 { "(bad)", { XX } },
3128 { "(bad)", { XX } },
3129 { "pblendvb", { XM, EXx, XMM0 } },
3130 { "(bad)", { XX } },
3135 { "(bad)", { XX } },
3136 { "(bad)", { XX } },
3137 { "blendvps", { XM, EXx, XMM0 } },
3138 { "(bad)", { XX } },
3143 { "(bad)", { XX } },
3144 { "(bad)", { XX } },
3145 { "blendvpd", { XM, EXx, XMM0 } },
3146 { "(bad)", { XX } },
3151 { "(bad)", { XX } },
3152 { "(bad)", { XX } },
3153 { "ptest", { XM, EXx } },
3154 { "(bad)", { XX } },
3159 { "(bad)", { XX } },
3160 { "(bad)", { XX } },
3161 { "pmovsxbw", { XM, EXq } },
3162 { "(bad)", { XX } },
3167 { "(bad)", { XX } },
3168 { "(bad)", { XX } },
3169 { "pmovsxbd", { XM, EXd } },
3170 { "(bad)", { XX } },
3175 { "(bad)", { XX } },
3176 { "(bad)", { XX } },
3177 { "pmovsxbq", { XM, EXw } },
3178 { "(bad)", { XX } },
3183 { "(bad)", { XX } },
3184 { "(bad)", { XX } },
3185 { "pmovsxwd", { XM, EXq } },
3186 { "(bad)", { XX } },
3191 { "(bad)", { XX } },
3192 { "(bad)", { XX } },
3193 { "pmovsxwq", { XM, EXd } },
3194 { "(bad)", { XX } },
3199 { "(bad)", { XX } },
3200 { "(bad)", { XX } },
3201 { "pmovsxdq", { XM, EXq } },
3202 { "(bad)", { XX } },
3207 { "(bad)", { XX } },
3208 { "(bad)", { XX } },
3209 { "pmuldq", { XM, EXx } },
3210 { "(bad)", { XX } },
3215 { "(bad)", { XX } },
3216 { "(bad)", { XX } },
3217 { "pcmpeqq", { XM, EXx } },
3218 { "(bad)", { XX } },
3223 { "(bad)", { XX } },
3224 { "(bad)", { XX } },
3225 { MOD_TABLE (MOD_0F382A_PREFIX_2) },
3226 { "(bad)", { XX } },
3231 { "(bad)", { XX } },
3232 { "(bad)", { XX } },
3233 { "packusdw", { XM, EXx } },
3234 { "(bad)", { XX } },
3239 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "pmovzxbw", { XM, EXq } },
3242 { "(bad)", { XX } },
3247 { "(bad)", { XX } },
3248 { "(bad)", { XX } },
3249 { "pmovzxbd", { XM, EXd } },
3250 { "(bad)", { XX } },
3255 { "(bad)", { XX } },
3256 { "(bad)", { XX } },
3257 { "pmovzxbq", { XM, EXw } },
3258 { "(bad)", { XX } },
3263 { "(bad)", { XX } },
3264 { "(bad)", { XX } },
3265 { "pmovzxwd", { XM, EXq } },
3266 { "(bad)", { XX } },
3271 { "(bad)", { XX } },
3272 { "(bad)", { XX } },
3273 { "pmovzxwq", { XM, EXd } },
3274 { "(bad)", { XX } },
3279 { "(bad)", { XX } },
3280 { "(bad)", { XX } },
3281 { "pmovzxdq", { XM, EXq } },
3282 { "(bad)", { XX } },
3287 { "(bad)", { XX } },
3288 { "(bad)", { XX } },
3289 { "pcmpgtq", { XM, EXx } },
3290 { "(bad)", { XX } },
3295 { "(bad)", { XX } },
3296 { "(bad)", { XX } },
3297 { "pminsb", { XM, EXx } },
3298 { "(bad)", { XX } },
3303 { "(bad)", { XX } },
3304 { "(bad)", { XX } },
3305 { "pminsd", { XM, EXx } },
3306 { "(bad)", { XX } },
3311 { "(bad)", { XX } },
3312 { "(bad)", { XX } },
3313 { "pminuw", { XM, EXx } },
3314 { "(bad)", { XX } },
3319 { "(bad)", { XX } },
3320 { "(bad)", { XX } },
3321 { "pminud", { XM, EXx } },
3322 { "(bad)", { XX } },
3327 { "(bad)", { XX } },
3328 { "(bad)", { XX } },
3329 { "pmaxsb", { XM, EXx } },
3330 { "(bad)", { XX } },
3335 { "(bad)", { XX } },
3336 { "(bad)", { XX } },
3337 { "pmaxsd", { XM, EXx } },
3338 { "(bad)", { XX } },
3343 { "(bad)", { XX } },
3344 { "(bad)", { XX } },
3345 { "pmaxuw", { XM, EXx } },
3346 { "(bad)", { XX } },
3351 { "(bad)", { XX } },
3352 { "(bad)", { XX } },
3353 { "pmaxud", { XM, EXx } },
3354 { "(bad)", { XX } },
3359 { "(bad)", { XX } },
3360 { "(bad)", { XX } },
3361 { "pmulld", { XM, EXx } },
3362 { "(bad)", { XX } },
3367 { "(bad)", { XX } },
3368 { "(bad)", { XX } },
3369 { "phminposuw", { XM, EXx } },
3370 { "(bad)", { XX } },
3375 { "(bad)", { XX } },
3376 { "(bad)", { XX } },
3377 { "invept", { Gm, Mo } },
3378 { "(bad)", { XX } },
3383 { "(bad)", { XX } },
3384 { "(bad)", { XX } },
3385 { "invvpid", { Gm, Mo } },
3386 { "(bad)", { XX } },
3391 { "(bad)", { XX } },
3392 { "(bad)", { XX } },
3393 { "aesimc", { XM, EXx } },
3394 { "(bad)", { XX } },
3399 { "(bad)", { XX } },
3400 { "(bad)", { XX } },
3401 { "aesenc", { XM, EXx } },
3402 { "(bad)", { XX } },
3407 { "(bad)", { XX } },
3408 { "(bad)", { XX } },
3409 { "aesenclast", { XM, EXx } },
3410 { "(bad)", { XX } },
3415 { "(bad)", { XX } },
3416 { "(bad)", { XX } },
3417 { "aesdec", { XM, EXx } },
3418 { "(bad)", { XX } },
3423 { "(bad)", { XX } },
3424 { "(bad)", { XX } },
3425 { "aesdeclast", { XM, EXx } },
3426 { "(bad)", { XX } },
3431 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3432 { "(bad)", { XX } },
3433 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3434 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
3439 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3440 { "(bad)", { XX } },
3441 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3442 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
3447 { "(bad)", { XX } },
3448 { "(bad)", { XX } },
3449 { "roundps", { XM, EXx, Ib } },
3450 { "(bad)", { XX } },
3455 { "(bad)", { XX } },
3456 { "(bad)", { XX } },
3457 { "roundpd", { XM, EXx, Ib } },
3458 { "(bad)", { XX } },
3463 { "(bad)", { XX } },
3464 { "(bad)", { XX } },
3465 { "roundss", { XM, EXd, Ib } },
3466 { "(bad)", { XX } },
3471 { "(bad)", { XX } },
3472 { "(bad)", { XX } },
3473 { "roundsd", { XM, EXq, Ib } },
3474 { "(bad)", { XX } },
3479 { "(bad)", { XX } },
3480 { "(bad)", { XX } },
3481 { "blendps", { XM, EXx, Ib } },
3482 { "(bad)", { XX } },
3487 { "(bad)", { XX } },
3488 { "(bad)", { XX } },
3489 { "blendpd", { XM, EXx, Ib } },
3490 { "(bad)", { XX } },
3495 { "(bad)", { XX } },
3496 { "(bad)", { XX } },
3497 { "pblendw", { XM, EXx, Ib } },
3498 { "(bad)", { XX } },
3503 { "(bad)", { XX } },
3504 { "(bad)", { XX } },
3505 { "pextrb", { Edqb, XM, Ib } },
3506 { "(bad)", { XX } },
3511 { "(bad)", { XX } },
3512 { "(bad)", { XX } },
3513 { "pextrw", { Edqw, XM, Ib } },
3514 { "(bad)", { XX } },
3519 { "(bad)", { XX } },
3520 { "(bad)", { XX } },
3521 { "pextrK", { Edq, XM, Ib } },
3522 { "(bad)", { XX } },
3527 { "(bad)", { XX } },
3528 { "(bad)", { XX } },
3529 { "extractps", { Edqd, XM, Ib } },
3530 { "(bad)", { XX } },
3535 { "(bad)", { XX } },
3536 { "(bad)", { XX } },
3537 { "pinsrb", { XM, Edqb, Ib } },
3538 { "(bad)", { XX } },
3543 { "(bad)", { XX } },
3544 { "(bad)", { XX } },
3545 { "insertps", { XM, EXd, Ib } },
3546 { "(bad)", { XX } },
3551 { "(bad)", { XX } },
3552 { "(bad)", { XX } },
3553 { "pinsrK", { XM, Edq, Ib } },
3554 { "(bad)", { XX } },
3559 { "(bad)", { XX } },
3560 { "(bad)", { XX } },
3561 { "dpps", { XM, EXx, Ib } },
3562 { "(bad)", { XX } },
3567 { "(bad)", { XX } },
3568 { "(bad)", { XX } },
3569 { "dppd", { XM, EXx, Ib } },
3570 { "(bad)", { XX } },
3575 { "(bad)", { XX } },
3576 { "(bad)", { XX } },
3577 { "mpsadbw", { XM, EXx, Ib } },
3578 { "(bad)", { XX } },
3583 { "(bad)", { XX } },
3584 { "(bad)", { XX } },
3585 { "pclmulqdq", { XM, EXx, PCLMUL } },
3586 { "(bad)", { XX } },
3591 { "(bad)", { XX } },
3592 { "(bad)", { XX } },
3593 { "pcmpestrm", { XM, EXx, Ib } },
3594 { "(bad)", { XX } },
3599 { "(bad)", { XX } },
3600 { "(bad)", { XX } },
3601 { "pcmpestri", { XM, EXx, Ib } },
3602 { "(bad)", { XX } },
3607 { "(bad)", { XX } },
3608 { "(bad)", { XX } },
3609 { "pcmpistrm", { XM, EXx, Ib } },
3610 { "(bad)", { XX } },
3615 { "(bad)", { XX } },
3616 { "(bad)", { XX } },
3617 { "pcmpistri", { XM, EXx, Ib } },
3618 { "(bad)", { XX } },
3623 { "(bad)", { XX } },
3624 { "(bad)", { XX } },
3625 { "aeskeygenassist", { XM, EXx, Ib } },
3626 { "(bad)", { XX } },
3631 { VEX_W_TABLE (VEX_W_10_P_0) },
3632 { VEX_LEN_TABLE (VEX_LEN_10_P_1) },
3633 { VEX_W_TABLE (VEX_W_10_P_2) },
3634 { VEX_LEN_TABLE (VEX_LEN_10_P_3) },
3639 { VEX_W_TABLE (VEX_W_11_P_0) },
3640 { VEX_LEN_TABLE (VEX_LEN_11_P_1) },
3641 { VEX_W_TABLE (VEX_W_11_P_2) },
3642 { VEX_LEN_TABLE (VEX_LEN_11_P_3) },
3647 { MOD_TABLE (MOD_VEX_12_PREFIX_0) },
3648 { VEX_W_TABLE (VEX_W_12_P_1) },
3649 { VEX_LEN_TABLE (VEX_LEN_12_P_2) },
3650 { VEX_W_TABLE (VEX_W_12_P_3) },
3655 { MOD_TABLE (MOD_VEX_16_PREFIX_0) },
3656 { VEX_W_TABLE (VEX_W_16_P_1) },
3657 { VEX_LEN_TABLE (VEX_LEN_16_P_2) },
3658 { "(bad)", { XX } },
3663 { "(bad)", { XX } },
3664 { VEX_LEN_TABLE (VEX_LEN_2A_P_1) },
3665 { "(bad)", { XX } },
3666 { VEX_LEN_TABLE (VEX_LEN_2A_P_3) },
3671 { "(bad)", { XX } },
3672 { VEX_LEN_TABLE (VEX_LEN_2C_P_1) },
3673 { "(bad)", { XX } },
3674 { VEX_LEN_TABLE (VEX_LEN_2C_P_3) },
3679 { "(bad)", { XX } },
3680 { VEX_LEN_TABLE (VEX_LEN_2D_P_1) },
3681 { "(bad)", { XX } },
3682 { VEX_LEN_TABLE (VEX_LEN_2D_P_3) },
3687 { VEX_LEN_TABLE (VEX_LEN_2E_P_0) },
3688 { "(bad)", { XX } },
3689 { VEX_LEN_TABLE (VEX_LEN_2E_P_2) },
3690 { "(bad)", { XX } },
3695 { VEX_LEN_TABLE (VEX_LEN_2F_P_0) },
3696 { "(bad)", { XX } },
3697 { VEX_LEN_TABLE (VEX_LEN_2F_P_2) },
3698 { "(bad)", { XX } },
3703 { VEX_W_TABLE (VEX_W_51_P_0) },
3704 { VEX_LEN_TABLE (VEX_LEN_51_P_1) },
3705 { VEX_W_TABLE (VEX_W_51_P_2) },
3706 { VEX_LEN_TABLE (VEX_LEN_51_P_3) },
3711 { VEX_W_TABLE (VEX_W_52_P_0) },
3712 { VEX_LEN_TABLE (VEX_LEN_52_P_1) },
3713 { "(bad)", { XX } },
3714 { "(bad)", { XX } },
3719 { VEX_W_TABLE (VEX_W_53_P_0) },
3720 { VEX_LEN_TABLE (VEX_LEN_53_P_1) },
3721 { "(bad)", { XX } },
3722 { "(bad)", { XX } },
3727 { VEX_W_TABLE (VEX_W_58_P_0) },
3728 { VEX_LEN_TABLE (VEX_LEN_58_P_1) },
3729 { VEX_W_TABLE (VEX_W_58_P_2) },
3730 { VEX_LEN_TABLE (VEX_LEN_58_P_3) },
3735 { VEX_W_TABLE (VEX_W_59_P_0) },
3736 { VEX_LEN_TABLE (VEX_LEN_59_P_1) },
3737 { VEX_W_TABLE (VEX_W_59_P_2) },
3738 { VEX_LEN_TABLE (VEX_LEN_59_P_3) },
3743 { VEX_W_TABLE (VEX_W_5A_P_0) },
3744 { VEX_LEN_TABLE (VEX_LEN_5A_P_1) },
3745 { "vcvtpd2ps%XY", { XMM, EXx } },
3746 { VEX_LEN_TABLE (VEX_LEN_5A_P_3) },
3751 { VEX_W_TABLE (VEX_W_5B_P_0) },
3752 { VEX_W_TABLE (VEX_W_5B_P_1) },
3753 { VEX_W_TABLE (VEX_W_5B_P_2) },
3754 { "(bad)", { XX } },
3759 { VEX_W_TABLE (VEX_W_5C_P_0) },
3760 { VEX_LEN_TABLE (VEX_LEN_5C_P_1) },
3761 { VEX_W_TABLE (VEX_W_5C_P_2) },
3762 { VEX_LEN_TABLE (VEX_LEN_5C_P_3) },
3767 { VEX_W_TABLE (VEX_W_5D_P_0) },
3768 { VEX_LEN_TABLE (VEX_LEN_5D_P_1) },
3769 { VEX_W_TABLE (VEX_W_5D_P_2) },
3770 { VEX_LEN_TABLE (VEX_LEN_5D_P_3) },
3775 { VEX_W_TABLE (VEX_W_5E_P_0) },
3776 { VEX_LEN_TABLE (VEX_LEN_5E_P_1) },
3777 { VEX_W_TABLE (VEX_W_5E_P_2) },
3778 { VEX_LEN_TABLE (VEX_LEN_5E_P_3) },
3783 { VEX_W_TABLE (VEX_W_5F_P_0) },
3784 { VEX_LEN_TABLE (VEX_LEN_5F_P_1) },
3785 { VEX_W_TABLE (VEX_W_5F_P_2) },
3786 { VEX_LEN_TABLE (VEX_LEN_5F_P_3) },
3791 { "(bad)", { XX } },
3792 { "(bad)", { XX } },
3793 { VEX_LEN_TABLE (VEX_LEN_60_P_2) },
3794 { "(bad)", { XX } },
3799 { "(bad)", { XX } },
3800 { "(bad)", { XX } },
3801 { VEX_LEN_TABLE (VEX_LEN_61_P_2) },
3802 { "(bad)", { XX } },
3807 { "(bad)", { XX } },
3808 { "(bad)", { XX } },
3809 { VEX_LEN_TABLE (VEX_LEN_62_P_2) },
3810 { "(bad)", { XX } },
3815 { "(bad)", { XX } },
3816 { "(bad)", { XX } },
3817 { VEX_LEN_TABLE (VEX_LEN_63_P_2) },
3818 { "(bad)", { XX } },
3823 { "(bad)", { XX } },
3824 { "(bad)", { XX } },
3825 { VEX_LEN_TABLE (VEX_LEN_64_P_2) },
3826 { "(bad)", { XX } },
3831 { "(bad)", { XX } },
3832 { "(bad)", { XX } },
3833 { VEX_LEN_TABLE (VEX_LEN_65_P_2) },
3834 { "(bad)", { XX } },
3839 { "(bad)", { XX } },
3840 { "(bad)", { XX } },
3841 { VEX_LEN_TABLE (VEX_LEN_66_P_2) },
3842 { "(bad)", { XX } },
3847 { "(bad)", { XX } },
3848 { "(bad)", { XX } },
3849 { VEX_LEN_TABLE (VEX_LEN_67_P_2) },
3850 { "(bad)", { XX } },
3855 { "(bad)", { XX } },
3856 { "(bad)", { XX } },
3857 { VEX_LEN_TABLE (VEX_LEN_68_P_2) },
3858 { "(bad)", { XX } },
3863 { "(bad)", { XX } },
3864 { "(bad)", { XX } },
3865 { VEX_LEN_TABLE (VEX_LEN_69_P_2) },
3866 { "(bad)", { XX } },
3871 { "(bad)", { XX } },
3872 { "(bad)", { XX } },
3873 { VEX_LEN_TABLE (VEX_LEN_6A_P_2) },
3874 { "(bad)", { XX } },
3879 { "(bad)", { XX } },
3880 { "(bad)", { XX } },
3881 { VEX_LEN_TABLE (VEX_LEN_6B_P_2) },
3882 { "(bad)", { XX } },
3887 { "(bad)", { XX } },
3888 { "(bad)", { XX } },
3889 { VEX_LEN_TABLE (VEX_LEN_6C_P_2) },
3890 { "(bad)", { XX } },
3895 { "(bad)", { XX } },
3896 { "(bad)", { XX } },
3897 { VEX_LEN_TABLE (VEX_LEN_6D_P_2) },
3898 { "(bad)", { XX } },
3903 { "(bad)", { XX } },
3904 { "(bad)", { XX } },
3905 { VEX_LEN_TABLE (VEX_LEN_6E_P_2) },
3906 { "(bad)", { XX } },
3911 { "(bad)", { XX } },
3912 { VEX_W_TABLE (VEX_W_6F_P_1) },
3913 { VEX_W_TABLE (VEX_W_6F_P_2) },
3914 { "(bad)", { XX } },
3919 { "(bad)", { XX } },
3920 { VEX_LEN_TABLE (VEX_LEN_70_P_1) },
3921 { VEX_LEN_TABLE (VEX_LEN_70_P_2) },
3922 { VEX_LEN_TABLE (VEX_LEN_70_P_3) },
3925 /* PREFIX_VEX_71_REG_2 */
3927 { "(bad)", { XX } },
3928 { "(bad)", { XX } },
3929 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2) },
3930 { "(bad)", { XX } },
3933 /* PREFIX_VEX_71_REG_4 */
3935 { "(bad)", { XX } },
3936 { "(bad)", { XX } },
3937 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2) },
3938 { "(bad)", { XX } },
3941 /* PREFIX_VEX_71_REG_6 */
3943 { "(bad)", { XX } },
3944 { "(bad)", { XX } },
3945 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2) },
3946 { "(bad)", { XX } },
3949 /* PREFIX_VEX_72_REG_2 */
3951 { "(bad)", { XX } },
3952 { "(bad)", { XX } },
3953 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2) },
3954 { "(bad)", { XX } },
3957 /* PREFIX_VEX_72_REG_4 */
3959 { "(bad)", { XX } },
3960 { "(bad)", { XX } },
3961 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2) },
3962 { "(bad)", { XX } },
3965 /* PREFIX_VEX_72_REG_6 */
3967 { "(bad)", { XX } },
3968 { "(bad)", { XX } },
3969 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2) },
3970 { "(bad)", { XX } },
3973 /* PREFIX_VEX_73_REG_2 */
3975 { "(bad)", { XX } },
3976 { "(bad)", { XX } },
3977 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2) },
3978 { "(bad)", { XX } },
3981 /* PREFIX_VEX_73_REG_3 */
3983 { "(bad)", { XX } },
3984 { "(bad)", { XX } },
3985 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2) },
3986 { "(bad)", { XX } },
3989 /* PREFIX_VEX_73_REG_6 */
3991 { "(bad)", { XX } },
3992 { "(bad)", { XX } },
3993 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2) },
3994 { "(bad)", { XX } },
3997 /* PREFIX_VEX_73_REG_7 */
3999 { "(bad)", { XX } },
4000 { "(bad)", { XX } },
4001 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2) },
4002 { "(bad)", { XX } },
4007 { "(bad)", { XX } },
4008 { "(bad)", { XX } },
4009 { VEX_LEN_TABLE (VEX_LEN_74_P_2) },
4010 { "(bad)", { XX } },
4015 { "(bad)", { XX } },
4016 { "(bad)", { XX } },
4017 { VEX_LEN_TABLE (VEX_LEN_75_P_2) },
4018 { "(bad)", { XX } },
4023 { "(bad)", { XX } },
4024 { "(bad)", { XX } },
4025 { VEX_LEN_TABLE (VEX_LEN_76_P_2) },
4026 { "(bad)", { XX } },
4031 { VEX_W_TABLE (VEX_W_77_P_0) },
4032 { "(bad)", { XX } },
4033 { "(bad)", { XX } },
4034 { "(bad)", { XX } },
4039 { "(bad)", { XX } },
4040 { "(bad)", { XX } },
4041 { VEX_W_TABLE (VEX_W_7C_P_2) },
4042 { VEX_W_TABLE (VEX_W_7C_P_3) },
4047 { "(bad)", { XX } },
4048 { "(bad)", { XX } },
4049 { VEX_W_TABLE (VEX_W_7D_P_2) },
4050 { VEX_W_TABLE (VEX_W_7D_P_3) },
4055 { "(bad)", { XX } },
4056 { VEX_LEN_TABLE (VEX_LEN_7E_P_1) },
4057 { VEX_LEN_TABLE (VEX_LEN_7E_P_2) },
4058 { "(bad)", { XX } },
4063 { "(bad)", { XX } },
4064 { VEX_W_TABLE (VEX_W_7F_P_1) },
4065 { VEX_W_TABLE (VEX_W_7F_P_2) },
4066 { "(bad)", { XX } },
4071 { VEX_W_TABLE (VEX_W_C2_P_0) },
4072 { VEX_LEN_TABLE (VEX_LEN_C2_P_1) },
4073 { VEX_W_TABLE (VEX_W_C2_P_2) },
4074 { VEX_LEN_TABLE (VEX_LEN_C2_P_3) },
4079 { "(bad)", { XX } },
4080 { "(bad)", { XX } },
4081 { VEX_LEN_TABLE (VEX_LEN_C4_P_2) },
4082 { "(bad)", { XX } },
4087 { "(bad)", { XX } },
4088 { "(bad)", { XX } },
4089 { VEX_LEN_TABLE (VEX_LEN_C5_P_2) },
4090 { "(bad)", { XX } },
4095 { "(bad)", { XX } },
4096 { "(bad)", { XX } },
4097 { VEX_W_TABLE (VEX_W_D0_P_2) },
4098 { VEX_W_TABLE (VEX_W_D0_P_3) },
4103 { "(bad)", { XX } },
4104 { "(bad)", { XX } },
4105 { VEX_LEN_TABLE (VEX_LEN_D1_P_2) },
4106 { "(bad)", { XX } },
4111 { "(bad)", { XX } },
4112 { "(bad)", { XX } },
4113 { VEX_LEN_TABLE (VEX_LEN_D2_P_2) },
4114 { "(bad)", { XX } },
4119 { "(bad)", { XX } },
4120 { "(bad)", { XX } },
4121 { VEX_LEN_TABLE (VEX_LEN_D3_P_2) },
4122 { "(bad)", { XX } },
4127 { "(bad)", { XX } },
4128 { "(bad)", { XX } },
4129 { VEX_LEN_TABLE (VEX_LEN_D4_P_2) },
4130 { "(bad)", { XX } },
4135 { "(bad)", { XX } },
4136 { "(bad)", { XX } },
4137 { VEX_LEN_TABLE (VEX_LEN_D5_P_2) },
4138 { "(bad)", { XX } },
4143 { "(bad)", { XX } },
4144 { "(bad)", { XX } },
4145 { VEX_LEN_TABLE (VEX_LEN_D6_P_2) },
4146 { "(bad)", { XX } },
4151 { "(bad)", { XX } },
4152 { "(bad)", { XX } },
4153 { MOD_TABLE (MOD_VEX_D7_PREFIX_2) },
4154 { "(bad)", { XX } },
4159 { "(bad)", { XX } },
4160 { "(bad)", { XX } },
4161 { VEX_LEN_TABLE (VEX_LEN_D8_P_2) },
4162 { "(bad)", { XX } },
4167 { "(bad)", { XX } },
4168 { "(bad)", { XX } },
4169 { VEX_LEN_TABLE (VEX_LEN_D9_P_2) },
4170 { "(bad)", { XX } },
4175 { "(bad)", { XX } },
4176 { "(bad)", { XX } },
4177 { VEX_LEN_TABLE (VEX_LEN_DA_P_2) },
4178 { "(bad)", { XX } },
4183 { "(bad)", { XX } },
4184 { "(bad)", { XX } },
4185 { VEX_LEN_TABLE (VEX_LEN_DB_P_2) },
4186 { "(bad)", { XX } },
4191 { "(bad)", { XX } },
4192 { "(bad)", { XX } },
4193 { VEX_LEN_TABLE (VEX_LEN_DC_P_2) },
4194 { "(bad)", { XX } },
4199 { "(bad)", { XX } },
4200 { "(bad)", { XX } },
4201 { VEX_LEN_TABLE (VEX_LEN_DD_P_2) },
4202 { "(bad)", { XX } },
4207 { "(bad)", { XX } },
4208 { "(bad)", { XX } },
4209 { VEX_LEN_TABLE (VEX_LEN_DE_P_2) },
4210 { "(bad)", { XX } },
4215 { "(bad)", { XX } },
4216 { "(bad)", { XX } },
4217 { VEX_LEN_TABLE (VEX_LEN_DF_P_2) },
4218 { "(bad)", { XX } },
4223 { "(bad)", { XX } },
4224 { "(bad)", { XX } },
4225 { VEX_LEN_TABLE (VEX_LEN_E0_P_2) },
4226 { "(bad)", { XX } },
4231 { "(bad)", { XX } },
4232 { "(bad)", { XX } },
4233 { VEX_LEN_TABLE (VEX_LEN_E1_P_2) },
4234 { "(bad)", { XX } },
4239 { "(bad)", { XX } },
4240 { "(bad)", { XX } },
4241 { VEX_LEN_TABLE (VEX_LEN_E2_P_2) },
4242 { "(bad)", { XX } },
4247 { "(bad)", { XX } },
4248 { "(bad)", { XX } },
4249 { VEX_LEN_TABLE (VEX_LEN_E3_P_2) },
4250 { "(bad)", { XX } },
4255 { "(bad)", { XX } },
4256 { "(bad)", { XX } },
4257 { VEX_LEN_TABLE (VEX_LEN_E4_P_2) },
4258 { "(bad)", { XX } },
4263 { "(bad)", { XX } },
4264 { "(bad)", { XX } },
4265 { VEX_LEN_TABLE (VEX_LEN_E5_P_2) },
4266 { "(bad)", { XX } },
4271 { "(bad)", { XX } },
4272 { VEX_W_TABLE (VEX_W_E6_P_1) },
4273 { VEX_W_TABLE (VEX_W_E6_P_2) },
4274 { VEX_W_TABLE (VEX_W_E6_P_3) },
4279 { "(bad)", { XX } },
4280 { "(bad)", { XX } },
4281 { MOD_TABLE (MOD_VEX_E7_PREFIX_2) },
4282 { "(bad)", { XX } },
4287 { "(bad)", { XX } },
4288 { "(bad)", { XX } },
4289 { VEX_LEN_TABLE (VEX_LEN_E8_P_2) },
4290 { "(bad)", { XX } },
4295 { "(bad)", { XX } },
4296 { "(bad)", { XX } },
4297 { VEX_LEN_TABLE (VEX_LEN_E9_P_2) },
4298 { "(bad)", { XX } },
4303 { "(bad)", { XX } },
4304 { "(bad)", { XX } },
4305 { VEX_LEN_TABLE (VEX_LEN_EA_P_2) },
4306 { "(bad)", { XX } },
4311 { "(bad)", { XX } },
4312 { "(bad)", { XX } },
4313 { VEX_LEN_TABLE (VEX_LEN_EB_P_2) },
4314 { "(bad)", { XX } },
4319 { "(bad)", { XX } },
4320 { "(bad)", { XX } },
4321 { VEX_LEN_TABLE (VEX_LEN_EC_P_2) },
4322 { "(bad)", { XX } },
4327 { "(bad)", { XX } },
4328 { "(bad)", { XX } },
4329 { VEX_LEN_TABLE (VEX_LEN_ED_P_2) },
4330 { "(bad)", { XX } },
4335 { "(bad)", { XX } },
4336 { "(bad)", { XX } },
4337 { VEX_LEN_TABLE (VEX_LEN_EE_P_2) },
4338 { "(bad)", { XX } },
4343 { "(bad)", { XX } },
4344 { "(bad)", { XX } },
4345 { VEX_LEN_TABLE (VEX_LEN_EF_P_2) },
4346 { "(bad)", { XX } },
4351 { "(bad)", { XX } },
4352 { "(bad)", { XX } },
4353 { "(bad)", { XX } },
4354 { MOD_TABLE (MOD_VEX_F0_PREFIX_3) },
4359 { "(bad)", { XX } },
4360 { "(bad)", { XX } },
4361 { VEX_LEN_TABLE (VEX_LEN_F1_P_2) },
4362 { "(bad)", { XX } },
4367 { "(bad)", { XX } },
4368 { "(bad)", { XX } },
4369 { VEX_LEN_TABLE (VEX_LEN_F2_P_2) },
4370 { "(bad)", { XX } },
4375 { "(bad)", { XX } },
4376 { "(bad)", { XX } },
4377 { VEX_LEN_TABLE (VEX_LEN_F3_P_2) },
4378 { "(bad)", { XX } },
4383 { "(bad)", { XX } },
4384 { "(bad)", { XX } },
4385 { VEX_LEN_TABLE (VEX_LEN_F4_P_2) },
4386 { "(bad)", { XX } },
4391 { "(bad)", { XX } },
4392 { "(bad)", { XX } },
4393 { VEX_LEN_TABLE (VEX_LEN_F5_P_2) },
4394 { "(bad)", { XX } },
4399 { "(bad)", { XX } },
4400 { "(bad)", { XX } },
4401 { VEX_LEN_TABLE (VEX_LEN_F6_P_2) },
4402 { "(bad)", { XX } },
4407 { "(bad)", { XX } },
4408 { "(bad)", { XX } },
4409 { VEX_LEN_TABLE (VEX_LEN_F7_P_2) },
4410 { "(bad)", { XX } },
4415 { "(bad)", { XX } },
4416 { "(bad)", { XX } },
4417 { VEX_LEN_TABLE (VEX_LEN_F8_P_2) },
4418 { "(bad)", { XX } },
4423 { "(bad)", { XX } },
4424 { "(bad)", { XX } },
4425 { VEX_LEN_TABLE (VEX_LEN_F9_P_2) },
4426 { "(bad)", { XX } },
4431 { "(bad)", { XX } },
4432 { "(bad)", { XX } },
4433 { VEX_LEN_TABLE (VEX_LEN_FA_P_2) },
4434 { "(bad)", { XX } },
4439 { "(bad)", { XX } },
4440 { "(bad)", { XX } },
4441 { VEX_LEN_TABLE (VEX_LEN_FB_P_2) },
4442 { "(bad)", { XX } },
4447 { "(bad)", { XX } },
4448 { "(bad)", { XX } },
4449 { VEX_LEN_TABLE (VEX_LEN_FC_P_2) },
4450 { "(bad)", { XX } },
4455 { "(bad)", { XX } },
4456 { "(bad)", { XX } },
4457 { VEX_LEN_TABLE (VEX_LEN_FD_P_2) },
4458 { "(bad)", { XX } },
4463 { "(bad)", { XX } },
4464 { "(bad)", { XX } },
4465 { VEX_LEN_TABLE (VEX_LEN_FE_P_2) },
4466 { "(bad)", { XX } },
4469 /* PREFIX_VEX_3800 */
4471 { "(bad)", { XX } },
4472 { "(bad)", { XX } },
4473 { VEX_LEN_TABLE (VEX_LEN_3800_P_2) },
4474 { "(bad)", { XX } },
4477 /* PREFIX_VEX_3801 */
4479 { "(bad)", { XX } },
4480 { "(bad)", { XX } },
4481 { VEX_LEN_TABLE (VEX_LEN_3801_P_2) },
4482 { "(bad)", { XX } },
4485 /* PREFIX_VEX_3802 */
4487 { "(bad)", { XX } },
4488 { "(bad)", { XX } },
4489 { VEX_LEN_TABLE (VEX_LEN_3802_P_2) },
4490 { "(bad)", { XX } },
4493 /* PREFIX_VEX_3803 */
4495 { "(bad)", { XX } },
4496 { "(bad)", { XX } },
4497 { VEX_LEN_TABLE (VEX_LEN_3803_P_2) },
4498 { "(bad)", { XX } },
4501 /* PREFIX_VEX_3804 */
4503 { "(bad)", { XX } },
4504 { "(bad)", { XX } },
4505 { VEX_LEN_TABLE (VEX_LEN_3804_P_2) },
4506 { "(bad)", { XX } },
4509 /* PREFIX_VEX_3805 */
4511 { "(bad)", { XX } },
4512 { "(bad)", { XX } },
4513 { VEX_LEN_TABLE (VEX_LEN_3805_P_2) },
4514 { "(bad)", { XX } },
4517 /* PREFIX_VEX_3806 */
4519 { "(bad)", { XX } },
4520 { "(bad)", { XX } },
4521 { VEX_LEN_TABLE (VEX_LEN_3806_P_2) },
4522 { "(bad)", { XX } },
4525 /* PREFIX_VEX_3807 */
4527 { "(bad)", { XX } },
4528 { "(bad)", { XX } },
4529 { VEX_LEN_TABLE (VEX_LEN_3807_P_2) },
4530 { "(bad)", { XX } },
4533 /* PREFIX_VEX_3808 */
4535 { "(bad)", { XX } },
4536 { "(bad)", { XX } },
4537 { VEX_LEN_TABLE (VEX_LEN_3808_P_2) },
4538 { "(bad)", { XX } },
4541 /* PREFIX_VEX_3809 */
4543 { "(bad)", { XX } },
4544 { "(bad)", { XX } },
4545 { VEX_LEN_TABLE (VEX_LEN_3809_P_2) },
4546 { "(bad)", { XX } },
4549 /* PREFIX_VEX_380A */
4551 { "(bad)", { XX } },
4552 { "(bad)", { XX } },
4553 { VEX_LEN_TABLE (VEX_LEN_380A_P_2) },
4554 { "(bad)", { XX } },
4557 /* PREFIX_VEX_380B */
4559 { "(bad)", { XX } },
4560 { "(bad)", { XX } },
4561 { VEX_LEN_TABLE (VEX_LEN_380B_P_2) },
4562 { "(bad)", { XX } },
4565 /* PREFIX_VEX_380C */
4567 { "(bad)", { XX } },
4568 { "(bad)", { XX } },
4569 { VEX_W_TABLE (VEX_W_380C_P_2) },
4570 { "(bad)", { XX } },
4573 /* PREFIX_VEX_380D */
4575 { "(bad)", { XX } },
4576 { "(bad)", { XX } },
4577 { VEX_W_TABLE (VEX_W_380D_P_2) },
4578 { "(bad)", { XX } },
4581 /* PREFIX_VEX_380E */
4583 { "(bad)", { XX } },
4584 { "(bad)", { XX } },
4585 { VEX_W_TABLE (VEX_W_380E_P_2) },
4586 { "(bad)", { XX } },
4589 /* PREFIX_VEX_380F */
4591 { "(bad)", { XX } },
4592 { "(bad)", { XX } },
4593 { VEX_W_TABLE (VEX_W_380F_P_2) },
4594 { "(bad)", { XX } },
4597 /* PREFIX_VEX_3817 */
4599 { "(bad)", { XX } },
4600 { "(bad)", { XX } },
4601 { VEX_W_TABLE (VEX_W_3817_P_2) },
4602 { "(bad)", { XX } },
4605 /* PREFIX_VEX_3818 */
4607 { "(bad)", { XX } },
4608 { "(bad)", { XX } },
4609 { MOD_TABLE (MOD_VEX_3818_PREFIX_2) },
4610 { "(bad)", { XX } },
4613 /* PREFIX_VEX_3819 */
4615 { "(bad)", { XX } },
4616 { "(bad)", { XX } },
4617 { MOD_TABLE (MOD_VEX_3819_PREFIX_2) },
4618 { "(bad)", { XX } },
4621 /* PREFIX_VEX_381A */
4623 { "(bad)", { XX } },
4624 { "(bad)", { XX } },
4625 { MOD_TABLE (MOD_VEX_381A_PREFIX_2) },
4626 { "(bad)", { XX } },
4629 /* PREFIX_VEX_381C */
4631 { "(bad)", { XX } },
4632 { "(bad)", { XX } },
4633 { VEX_LEN_TABLE (VEX_LEN_381C_P_2) },
4634 { "(bad)", { XX } },
4637 /* PREFIX_VEX_381D */
4639 { "(bad)", { XX } },
4640 { "(bad)", { XX } },
4641 { VEX_LEN_TABLE (VEX_LEN_381D_P_2) },
4642 { "(bad)", { XX } },
4645 /* PREFIX_VEX_381E */
4647 { "(bad)", { XX } },
4648 { "(bad)", { XX } },
4649 { VEX_LEN_TABLE (VEX_LEN_381E_P_2) },
4650 { "(bad)", { XX } },
4653 /* PREFIX_VEX_3820 */
4655 { "(bad)", { XX } },
4656 { "(bad)", { XX } },
4657 { VEX_LEN_TABLE (VEX_LEN_3820_P_2) },
4658 { "(bad)", { XX } },
4661 /* PREFIX_VEX_3821 */
4663 { "(bad)", { XX } },
4664 { "(bad)", { XX } },
4665 { VEX_LEN_TABLE (VEX_LEN_3821_P_2) },
4666 { "(bad)", { XX } },
4669 /* PREFIX_VEX_3822 */
4671 { "(bad)", { XX } },
4672 { "(bad)", { XX } },
4673 { VEX_LEN_TABLE (VEX_LEN_3822_P_2) },
4674 { "(bad)", { XX } },
4677 /* PREFIX_VEX_3823 */
4679 { "(bad)", { XX } },
4680 { "(bad)", { XX } },
4681 { VEX_LEN_TABLE (VEX_LEN_3823_P_2) },
4682 { "(bad)", { XX } },
4685 /* PREFIX_VEX_3824 */
4687 { "(bad)", { XX } },
4688 { "(bad)", { XX } },
4689 { VEX_LEN_TABLE (VEX_LEN_3824_P_2) },
4690 { "(bad)", { XX } },
4693 /* PREFIX_VEX_3825 */
4695 { "(bad)", { XX } },
4696 { "(bad)", { XX } },
4697 { VEX_LEN_TABLE (VEX_LEN_3825_P_2) },
4698 { "(bad)", { XX } },
4701 /* PREFIX_VEX_3828 */
4703 { "(bad)", { XX } },
4704 { "(bad)", { XX } },
4705 { VEX_LEN_TABLE (VEX_LEN_3828_P_2) },
4706 { "(bad)", { XX } },
4709 /* PREFIX_VEX_3829 */
4711 { "(bad)", { XX } },
4712 { "(bad)", { XX } },
4713 { VEX_LEN_TABLE (VEX_LEN_3829_P_2) },
4714 { "(bad)", { XX } },
4717 /* PREFIX_VEX_382A */
4719 { "(bad)", { XX } },
4720 { "(bad)", { XX } },
4721 { MOD_TABLE (MOD_VEX_382A_PREFIX_2) },
4722 { "(bad)", { XX } },
4725 /* PREFIX_VEX_382B */
4727 { "(bad)", { XX } },
4728 { "(bad)", { XX } },
4729 { VEX_LEN_TABLE (VEX_LEN_382B_P_2) },
4730 { "(bad)", { XX } },
4733 /* PREFIX_VEX_382C */
4735 { "(bad)", { XX } },
4736 { "(bad)", { XX } },
4737 { MOD_TABLE (MOD_VEX_382C_PREFIX_2) },
4738 { "(bad)", { XX } },
4741 /* PREFIX_VEX_382D */
4743 { "(bad)", { XX } },
4744 { "(bad)", { XX } },
4745 { MOD_TABLE (MOD_VEX_382D_PREFIX_2) },
4746 { "(bad)", { XX } },
4749 /* PREFIX_VEX_382E */
4751 { "(bad)", { XX } },
4752 { "(bad)", { XX } },
4753 { MOD_TABLE (MOD_VEX_382E_PREFIX_2) },
4754 { "(bad)", { XX } },
4757 /* PREFIX_VEX_382F */
4759 { "(bad)", { XX } },
4760 { "(bad)", { XX } },
4761 { MOD_TABLE (MOD_VEX_382F_PREFIX_2) },
4762 { "(bad)", { XX } },
4765 /* PREFIX_VEX_3830 */
4767 { "(bad)", { XX } },
4768 { "(bad)", { XX } },
4769 { VEX_LEN_TABLE (VEX_LEN_3830_P_2) },
4770 { "(bad)", { XX } },
4773 /* PREFIX_VEX_3831 */
4775 { "(bad)", { XX } },
4776 { "(bad)", { XX } },
4777 { VEX_LEN_TABLE (VEX_LEN_3831_P_2) },
4778 { "(bad)", { XX } },
4781 /* PREFIX_VEX_3832 */
4783 { "(bad)", { XX } },
4784 { "(bad)", { XX } },
4785 { VEX_LEN_TABLE (VEX_LEN_3832_P_2) },
4786 { "(bad)", { XX } },
4789 /* PREFIX_VEX_3833 */
4791 { "(bad)", { XX } },
4792 { "(bad)", { XX } },
4793 { VEX_LEN_TABLE (VEX_LEN_3833_P_2) },
4794 { "(bad)", { XX } },
4797 /* PREFIX_VEX_3834 */
4799 { "(bad)", { XX } },
4800 { "(bad)", { XX } },
4801 { VEX_LEN_TABLE (VEX_LEN_3834_P_2) },
4802 { "(bad)", { XX } },
4805 /* PREFIX_VEX_3835 */
4807 { "(bad)", { XX } },
4808 { "(bad)", { XX } },
4809 { VEX_LEN_TABLE (VEX_LEN_3835_P_2) },
4810 { "(bad)", { XX } },
4813 /* PREFIX_VEX_3837 */
4815 { "(bad)", { XX } },
4816 { "(bad)", { XX } },
4817 { VEX_LEN_TABLE (VEX_LEN_3837_P_2) },
4818 { "(bad)", { XX } },
4821 /* PREFIX_VEX_3838 */
4823 { "(bad)", { XX } },
4824 { "(bad)", { XX } },
4825 { VEX_LEN_TABLE (VEX_LEN_3838_P_2) },
4826 { "(bad)", { XX } },
4829 /* PREFIX_VEX_3839 */
4831 { "(bad)", { XX } },
4832 { "(bad)", { XX } },
4833 { VEX_LEN_TABLE (VEX_LEN_3839_P_2) },
4834 { "(bad)", { XX } },
4837 /* PREFIX_VEX_383A */
4839 { "(bad)", { XX } },
4840 { "(bad)", { XX } },
4841 { VEX_LEN_TABLE (VEX_LEN_383A_P_2) },
4842 { "(bad)", { XX } },
4845 /* PREFIX_VEX_383B */
4847 { "(bad)", { XX } },
4848 { "(bad)", { XX } },
4849 { VEX_LEN_TABLE (VEX_LEN_383B_P_2) },
4850 { "(bad)", { XX } },
4853 /* PREFIX_VEX_383C */
4855 { "(bad)", { XX } },
4856 { "(bad)", { XX } },
4857 { VEX_LEN_TABLE (VEX_LEN_383C_P_2) },
4858 { "(bad)", { XX } },
4861 /* PREFIX_VEX_383D */
4863 { "(bad)", { XX } },
4864 { "(bad)", { XX } },
4865 { VEX_LEN_TABLE (VEX_LEN_383D_P_2) },
4866 { "(bad)", { XX } },
4869 /* PREFIX_VEX_383E */
4871 { "(bad)", { XX } },
4872 { "(bad)", { XX } },
4873 { VEX_LEN_TABLE (VEX_LEN_383E_P_2) },
4874 { "(bad)", { XX } },
4877 /* PREFIX_VEX_383F */
4879 { "(bad)", { XX } },
4880 { "(bad)", { XX } },
4881 { VEX_LEN_TABLE (VEX_LEN_383F_P_2) },
4882 { "(bad)", { XX } },
4885 /* PREFIX_VEX_3840 */
4887 { "(bad)", { XX } },
4888 { "(bad)", { XX } },
4889 { VEX_LEN_TABLE (VEX_LEN_3840_P_2) },
4890 { "(bad)", { XX } },
4893 /* PREFIX_VEX_3841 */
4895 { "(bad)", { XX } },
4896 { "(bad)", { XX } },
4897 { VEX_LEN_TABLE (VEX_LEN_3841_P_2) },
4898 { "(bad)", { XX } },
4901 /* PREFIX_VEX_3896 */
4903 { "(bad)", { XX } },
4904 { "(bad)", { XX } },
4905 { "vfmaddsub132p%XW", { XM, Vex, EXx } },
4906 { "(bad)", { XX } },
4909 /* PREFIX_VEX_3897 */
4911 { "(bad)", { XX } },
4912 { "(bad)", { XX } },
4913 { "vfmsubadd132p%XW", { XM, Vex, EXx } },
4914 { "(bad)", { XX } },
4917 /* PREFIX_VEX_3898 */
4919 { "(bad)", { XX } },
4920 { "(bad)", { XX } },
4921 { "vfmadd132p%XW", { XM, Vex, EXx } },
4922 { "(bad)", { XX } },
4925 /* PREFIX_VEX_3899 */
4927 { "(bad)", { XX } },
4928 { "(bad)", { XX } },
4929 { "vfmadd132s%XW", { XM, Vex, EXVexWdq } },
4930 { "(bad)", { XX } },
4933 /* PREFIX_VEX_389A */
4935 { "(bad)", { XX } },
4936 { "(bad)", { XX } },
4937 { "vfmsub132p%XW", { XM, Vex, EXx } },
4938 { "(bad)", { XX } },
4941 /* PREFIX_VEX_389B */
4943 { "(bad)", { XX } },
4944 { "(bad)", { XX } },
4945 { "vfmsub132s%XW", { XM, Vex, EXVexWdq } },
4946 { "(bad)", { XX } },
4949 /* PREFIX_VEX_389C */
4951 { "(bad)", { XX } },
4952 { "(bad)", { XX } },
4953 { "vfnmadd132p%XW", { XM, Vex, EXx } },
4954 { "(bad)", { XX } },
4957 /* PREFIX_VEX_389D */
4959 { "(bad)", { XX } },
4960 { "(bad)", { XX } },
4961 { "vfnmadd132s%XW", { XM, Vex, EXVexWdq } },
4962 { "(bad)", { XX } },
4965 /* PREFIX_VEX_389E */
4967 { "(bad)", { XX } },
4968 { "(bad)", { XX } },
4969 { "vfnmsub132p%XW", { XM, Vex, EXx } },
4970 { "(bad)", { XX } },
4973 /* PREFIX_VEX_389F */
4975 { "(bad)", { XX } },
4976 { "(bad)", { XX } },
4977 { "vfnmsub132s%XW", { XM, Vex, EXVexWdq } },
4978 { "(bad)", { XX } },
4981 /* PREFIX_VEX_38A6 */
4983 { "(bad)", { XX } },
4984 { "(bad)", { XX } },
4985 { "vfmaddsub213p%XW", { XM, Vex, EXx } },
4986 { "(bad)", { XX } },
4989 /* PREFIX_VEX_38A7 */
4991 { "(bad)", { XX } },
4992 { "(bad)", { XX } },
4993 { "vfmsubadd213p%XW", { XM, Vex, EXx } },
4994 { "(bad)", { XX } },
4997 /* PREFIX_VEX_38A8 */
4999 { "(bad)", { XX } },
5000 { "(bad)", { XX } },
5001 { "vfmadd213p%XW", { XM, Vex, EXx } },
5002 { "(bad)", { XX } },
5005 /* PREFIX_VEX_38A9 */
5007 { "(bad)", { XX } },
5008 { "(bad)", { XX } },
5009 { "vfmadd213s%XW", { XM, Vex, EXVexWdq } },
5010 { "(bad)", { XX } },
5013 /* PREFIX_VEX_38AA */
5015 { "(bad)", { XX } },
5016 { "(bad)", { XX } },
5017 { "vfmsub213p%XW", { XM, Vex, EXx } },
5018 { "(bad)", { XX } },
5021 /* PREFIX_VEX_38AB */
5023 { "(bad)", { XX } },
5024 { "(bad)", { XX } },
5025 { "vfmsub213s%XW", { XM, Vex, EXVexWdq } },
5026 { "(bad)", { XX } },
5029 /* PREFIX_VEX_38AC */
5031 { "(bad)", { XX } },
5032 { "(bad)", { XX } },
5033 { "vfnmadd213p%XW", { XM, Vex, EXx } },
5034 { "(bad)", { XX } },
5037 /* PREFIX_VEX_38AD */
5039 { "(bad)", { XX } },
5040 { "(bad)", { XX } },
5041 { "vfnmadd213s%XW", { XM, Vex, EXVexWdq } },
5042 { "(bad)", { XX } },
5045 /* PREFIX_VEX_38AE */
5047 { "(bad)", { XX } },
5048 { "(bad)", { XX } },
5049 { "vfnmsub213p%XW", { XM, Vex, EXx } },
5050 { "(bad)", { XX } },
5053 /* PREFIX_VEX_38AF */
5055 { "(bad)", { XX } },
5056 { "(bad)", { XX } },
5057 { "vfnmsub213s%XW", { XM, Vex, EXVexWdq } },
5058 { "(bad)", { XX } },
5061 /* PREFIX_VEX_38B6 */
5063 { "(bad)", { XX } },
5064 { "(bad)", { XX } },
5065 { "vfmaddsub231p%XW", { XM, Vex, EXx } },
5066 { "(bad)", { XX } },
5069 /* PREFIX_VEX_38B7 */
5071 { "(bad)", { XX } },
5072 { "(bad)", { XX } },
5073 { "vfmsubadd231p%XW", { XM, Vex, EXx } },
5074 { "(bad)", { XX } },
5077 /* PREFIX_VEX_38B8 */
5079 { "(bad)", { XX } },
5080 { "(bad)", { XX } },
5081 { "vfmadd231p%XW", { XM, Vex, EXx } },
5082 { "(bad)", { XX } },
5085 /* PREFIX_VEX_38B9 */
5087 { "(bad)", { XX } },
5088 { "(bad)", { XX } },
5089 { "vfmadd231s%XW", { XM, Vex, EXVexWdq } },
5090 { "(bad)", { XX } },
5093 /* PREFIX_VEX_38BA */
5095 { "(bad)", { XX } },
5096 { "(bad)", { XX } },
5097 { "vfmsub231p%XW", { XM, Vex, EXx } },
5098 { "(bad)", { XX } },
5101 /* PREFIX_VEX_38BB */
5103 { "(bad)", { XX } },
5104 { "(bad)", { XX } },
5105 { "vfmsub231s%XW", { XM, Vex, EXVexWdq } },
5106 { "(bad)", { XX } },
5109 /* PREFIX_VEX_38BC */
5111 { "(bad)", { XX } },
5112 { "(bad)", { XX } },
5113 { "vfnmadd231p%XW", { XM, Vex, EXx } },
5114 { "(bad)", { XX } },
5117 /* PREFIX_VEX_38BD */
5119 { "(bad)", { XX } },
5120 { "(bad)", { XX } },
5121 { "vfnmadd231s%XW", { XM, Vex, EXVexWdq } },
5122 { "(bad)", { XX } },
5125 /* PREFIX_VEX_38BE */
5127 { "(bad)", { XX } },
5128 { "(bad)", { XX } },
5129 { "vfnmsub231p%XW", { XM, Vex, EXx } },
5130 { "(bad)", { XX } },
5133 /* PREFIX_VEX_38BF */
5135 { "(bad)", { XX } },
5136 { "(bad)", { XX } },
5137 { "vfnmsub231s%XW", { XM, Vex, EXVexWdq } },
5138 { "(bad)", { XX } },
5141 /* PREFIX_VEX_38DB */
5143 { "(bad)", { XX } },
5144 { "(bad)", { XX } },
5145 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2) },
5146 { "(bad)", { XX } },
5149 /* PREFIX_VEX_38DC */
5151 { "(bad)", { XX } },
5152 { "(bad)", { XX } },
5153 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2) },
5154 { "(bad)", { XX } },
5157 /* PREFIX_VEX_38DD */
5159 { "(bad)", { XX } },
5160 { "(bad)", { XX } },
5161 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2) },
5162 { "(bad)", { XX } },
5165 /* PREFIX_VEX_38DE */
5167 { "(bad)", { XX } },
5168 { "(bad)", { XX } },
5169 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2) },
5170 { "(bad)", { XX } },
5173 /* PREFIX_VEX_38DF */
5175 { "(bad)", { XX } },
5176 { "(bad)", { XX } },
5177 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2) },
5178 { "(bad)", { XX } },
5181 /* PREFIX_VEX_3A04 */
5183 { "(bad)", { XX } },
5184 { "(bad)", { XX } },
5185 { VEX_W_TABLE (VEX_W_3A04_P_2) },
5186 { "(bad)", { XX } },
5189 /* PREFIX_VEX_3A05 */
5191 { "(bad)", { XX } },
5192 { "(bad)", { XX } },
5193 { VEX_W_TABLE (VEX_W_3A05_P_2) },
5194 { "(bad)", { XX } },
5197 /* PREFIX_VEX_3A06 */
5199 { "(bad)", { XX } },
5200 { "(bad)", { XX } },
5201 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2) },
5202 { "(bad)", { XX } },
5205 /* PREFIX_VEX_3A08 */
5207 { "(bad)", { XX } },
5208 { "(bad)", { XX } },
5209 { VEX_W_TABLE (VEX_W_3A08_P_2) },
5210 { "(bad)", { XX } },
5213 /* PREFIX_VEX_3A09 */
5215 { "(bad)", { XX } },
5216 { "(bad)", { XX } },
5217 { VEX_W_TABLE (VEX_W_3A09_P_2) },
5218 { "(bad)", { XX } },
5221 /* PREFIX_VEX_3A0A */
5223 { "(bad)", { XX } },
5224 { "(bad)", { XX } },
5225 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2) },
5226 { "(bad)", { XX } },
5229 /* PREFIX_VEX_3A0B */
5231 { "(bad)", { XX } },
5232 { "(bad)", { XX } },
5233 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2) },
5234 { "(bad)", { XX } },
5237 /* PREFIX_VEX_3A0C */
5239 { "(bad)", { XX } },
5240 { "(bad)", { XX } },
5241 { VEX_W_TABLE (VEX_W_3A0C_P_2) },
5242 { "(bad)", { XX } },
5245 /* PREFIX_VEX_3A0D */
5247 { "(bad)", { XX } },
5248 { "(bad)", { XX } },
5249 { VEX_W_TABLE (VEX_W_3A0D_P_2) },
5250 { "(bad)", { XX } },
5253 /* PREFIX_VEX_3A0E */
5255 { "(bad)", { XX } },
5256 { "(bad)", { XX } },
5257 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2) },
5258 { "(bad)", { XX } },
5261 /* PREFIX_VEX_3A0F */
5263 { "(bad)", { XX } },
5264 { "(bad)", { XX } },
5265 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2) },
5266 { "(bad)", { XX } },
5269 /* PREFIX_VEX_3A14 */
5271 { "(bad)", { XX } },
5272 { "(bad)", { XX } },
5273 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2) },
5274 { "(bad)", { XX } },
5277 /* PREFIX_VEX_3A15 */
5279 { "(bad)", { XX } },
5280 { "(bad)", { XX } },
5281 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2) },
5282 { "(bad)", { XX } },
5285 /* PREFIX_VEX_3A16 */
5287 { "(bad)", { XX } },
5288 { "(bad)", { XX } },
5289 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2) },
5290 { "(bad)", { XX } },
5293 /* PREFIX_VEX_3A17 */
5295 { "(bad)", { XX } },
5296 { "(bad)", { XX } },
5297 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2) },
5298 { "(bad)", { XX } },
5301 /* PREFIX_VEX_3A18 */
5303 { "(bad)", { XX } },
5304 { "(bad)", { XX } },
5305 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2) },
5306 { "(bad)", { XX } },
5309 /* PREFIX_VEX_3A19 */
5311 { "(bad)", { XX } },
5312 { "(bad)", { XX } },
5313 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2) },
5314 { "(bad)", { XX } },
5317 /* PREFIX_VEX_3A20 */
5319 { "(bad)", { XX } },
5320 { "(bad)", { XX } },
5321 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2) },
5322 { "(bad)", { XX } },
5325 /* PREFIX_VEX_3A21 */
5327 { "(bad)", { XX } },
5328 { "(bad)", { XX } },
5329 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2) },
5330 { "(bad)", { XX } },
5333 /* PREFIX_VEX_3A22 */
5335 { "(bad)", { XX } },
5336 { "(bad)", { XX } },
5337 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2) },
5338 { "(bad)", { XX } },
5341 /* PREFIX_VEX_3A40 */
5343 { "(bad)", { XX } },
5344 { "(bad)", { XX } },
5345 { VEX_W_TABLE (VEX_W_3A40_P_2) },
5346 { "(bad)", { XX } },
5349 /* PREFIX_VEX_3A41 */
5351 { "(bad)", { XX } },
5352 { "(bad)", { XX } },
5353 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2) },
5354 { "(bad)", { XX } },
5357 /* PREFIX_VEX_3A42 */
5359 { "(bad)", { XX } },
5360 { "(bad)", { XX } },
5361 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2) },
5362 { "(bad)", { XX } },
5365 /* PREFIX_VEX_3A44 */
5367 { "(bad)", { XX } },
5368 { "(bad)", { XX } },
5369 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2) },
5370 { "(bad)", { XX } },
5373 /* PREFIX_VEX_3A4A */
5375 { "(bad)", { XX } },
5376 { "(bad)", { XX } },
5377 { VEX_W_TABLE (VEX_W_3A4A_P_2) },
5378 { "(bad)", { XX } },
5381 /* PREFIX_VEX_3A4B */
5383 { "(bad)", { XX } },
5384 { "(bad)", { XX } },
5385 { VEX_W_TABLE (VEX_W_3A4B_P_2) },
5386 { "(bad)", { XX } },
5389 /* PREFIX_VEX_3A4C */
5391 { "(bad)", { XX } },
5392 { "(bad)", { XX } },
5393 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2) },
5394 { "(bad)", { XX } },
5397 /* PREFIX_VEX_3A5C */
5399 { "(bad)", { XX } },
5400 { "(bad)", { XX } },
5401 { "vfmaddsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5402 { "(bad)", { XX } },
5405 /* PREFIX_VEX_3A5D */
5407 { "(bad)", { XX } },
5408 { "(bad)", { XX } },
5409 { "vfmaddsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5410 { "(bad)", { XX } },
5413 /* PREFIX_VEX_3A5E */
5415 { "(bad)", { XX } },
5416 { "(bad)", { XX } },
5417 { "vfmsubaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5418 { "(bad)", { XX } },
5421 /* PREFIX_VEX_3A5F */
5423 { "(bad)", { XX } },
5424 { "(bad)", { XX } },
5425 { "vfmsubaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5426 { "(bad)", { XX } },
5429 /* PREFIX_VEX_3A60 */
5431 { "(bad)", { XX } },
5432 { "(bad)", { XX } },
5433 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2) },
5434 { "(bad)", { XX } },
5437 /* PREFIX_VEX_3A61 */
5439 { "(bad)", { XX } },
5440 { "(bad)", { XX } },
5441 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2) },
5442 { "(bad)", { XX } },
5445 /* PREFIX_VEX_3A62 */
5447 { "(bad)", { XX } },
5448 { "(bad)", { XX } },
5449 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2) },
5450 { "(bad)", { XX } },
5453 /* PREFIX_VEX_3A63 */
5455 { "(bad)", { XX } },
5456 { "(bad)", { XX } },
5457 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2) },
5458 { "(bad)", { XX } },
5461 /* PREFIX_VEX_3A68 */
5463 { "(bad)", { XX } },
5464 { "(bad)", { XX } },
5465 { "vfmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5466 { "(bad)", { XX } },
5469 /* PREFIX_VEX_3A69 */
5471 { "(bad)", { XX } },
5472 { "(bad)", { XX } },
5473 { "vfmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5474 { "(bad)", { XX } },
5477 /* PREFIX_VEX_3A6A */
5479 { "(bad)", { XX } },
5480 { "(bad)", { XX } },
5481 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2) },
5482 { "(bad)", { XX } },
5485 /* PREFIX_VEX_3A6B */
5487 { "(bad)", { XX } },
5488 { "(bad)", { XX } },
5489 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2) },
5490 { "(bad)", { XX } },
5493 /* PREFIX_VEX_3A6C */
5495 { "(bad)", { XX } },
5496 { "(bad)", { XX } },
5497 { "vfmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5498 { "(bad)", { XX } },
5501 /* PREFIX_VEX_3A6D */
5503 { "(bad)", { XX } },
5504 { "(bad)", { XX } },
5505 { "vfmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5506 { "(bad)", { XX } },
5509 /* PREFIX_VEX_3A6E */
5511 { "(bad)", { XX } },
5512 { "(bad)", { XX } },
5513 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2) },
5514 { "(bad)", { XX } },
5517 /* PREFIX_VEX_3A6F */
5519 { "(bad)", { XX } },
5520 { "(bad)", { XX } },
5521 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2) },
5522 { "(bad)", { XX } },
5525 /* PREFIX_VEX_3A78 */
5527 { "(bad)", { XX } },
5528 { "(bad)", { XX } },
5529 { "vfnmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5530 { "(bad)", { XX } },
5533 /* PREFIX_VEX_3A79 */
5535 { "(bad)", { XX } },
5536 { "(bad)", { XX } },
5537 { "vfnmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5538 { "(bad)", { XX } },
5541 /* PREFIX_VEX_3A7A */
5543 { "(bad)", { XX } },
5544 { "(bad)", { XX } },
5545 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2) },
5546 { "(bad)", { XX } },
5549 /* PREFIX_VEX_3A7B */
5551 { "(bad)", { XX } },
5552 { "(bad)", { XX } },
5553 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2) },
5554 { "(bad)", { XX } },
5557 /* PREFIX_VEX_3A7C */
5559 { "(bad)", { XX } },
5560 { "(bad)", { XX } },
5561 { "vfnmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5562 { "(bad)", { XX } },
5565 /* PREFIX_VEX_3A7D */
5567 { "(bad)", { XX } },
5568 { "(bad)", { XX } },
5569 { "vfnmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5570 { "(bad)", { XX } },
5573 /* PREFIX_VEX_3A7E */
5575 { "(bad)", { XX } },
5576 { "(bad)", { XX } },
5577 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2) },
5578 { "(bad)", { XX } },
5581 /* PREFIX_VEX_3A7F */
5583 { "(bad)", { XX } },
5584 { "(bad)", { XX } },
5585 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2) },
5586 { "(bad)", { XX } },
5589 /* PREFIX_VEX_3ADF */
5591 { "(bad)", { XX } },
5592 { "(bad)", { XX } },
5593 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2) },
5594 { "(bad)", { XX } },
5598 static const struct dis386 x86_64_table[][2] = {
5601 { "push{T|}", { es } },
5602 { "(bad)", { XX } },
5607 { "pop{T|}", { es } },
5608 { "(bad)", { XX } },
5613 { "push{T|}", { cs } },
5614 { "(bad)", { XX } },
5619 { "push{T|}", { ss } },
5620 { "(bad)", { XX } },
5625 { "pop{T|}", { ss } },
5626 { "(bad)", { XX } },
5631 { "push{T|}", { ds } },
5632 { "(bad)", { XX } },
5637 { "pop{T|}", { ds } },
5638 { "(bad)", { XX } },
5644 { "(bad)", { XX } },
5650 { "(bad)", { XX } },
5656 { "(bad)", { XX } },
5662 { "(bad)", { XX } },
5667 { "pusha{P|}", { XX } },
5668 { "(bad)", { XX } },
5673 { "popa{P|}", { XX } },
5674 { "(bad)", { XX } },
5679 { MOD_TABLE (MOD_62_32BIT) },
5680 { "(bad)", { XX } },
5685 { "arpl", { Ew, Gw } },
5686 { "movs{lq|xd}", { Gv, Ed } },
5691 { "ins{R|}", { Yzr, indirDX } },
5692 { "ins{G|}", { Yzr, indirDX } },
5697 { "outs{R|}", { indirDXr, Xz } },
5698 { "outs{G|}", { indirDXr, Xz } },
5703 { "Jcall{T|}", { Ap } },
5704 { "(bad)", { XX } },
5709 { MOD_TABLE (MOD_C4_32BIT) },
5710 { VEX_C4_TABLE (VEX_0F) },
5715 { MOD_TABLE (MOD_C5_32BIT) },
5716 { VEX_C5_TABLE (VEX_0F) },
5722 { "(bad)", { XX } },
5728 { "(bad)", { XX } },
5734 { "(bad)", { XX } },
5739 { "Jjmp{T|}", { Ap } },
5740 { "(bad)", { XX } },
5743 /* X86_64_0F01_REG_0 */
5745 { "sgdt{Q|IQ}", { M } },
5749 /* X86_64_0F01_REG_1 */
5751 { "sidt{Q|IQ}", { M } },
5755 /* X86_64_0F01_REG_2 */
5757 { "lgdt{Q|Q}", { M } },
5761 /* X86_64_0F01_REG_3 */
5763 { "lidt{Q|Q}", { M } },
5768 static const struct dis386 three_byte_table[][256] = {
5770 /* THREE_BYTE_0F38 */
5773 { "pshufb", { MX, EM } },
5774 { "phaddw", { MX, EM } },
5775 { "phaddd", { MX, EM } },
5776 { "phaddsw", { MX, EM } },
5777 { "pmaddubsw", { MX, EM } },
5778 { "phsubw", { MX, EM } },
5779 { "phsubd", { MX, EM } },
5780 { "phsubsw", { MX, EM } },
5782 { "psignb", { MX, EM } },
5783 { "psignw", { MX, EM } },
5784 { "psignd", { MX, EM } },
5785 { "pmulhrsw", { MX, EM } },
5786 { "(bad)", { XX } },
5787 { "(bad)", { XX } },
5788 { "(bad)", { XX } },
5789 { "(bad)", { XX } },
5791 { PREFIX_TABLE (PREFIX_0F3810) },
5792 { "(bad)", { XX } },
5793 { "(bad)", { XX } },
5794 { "(bad)", { XX } },
5795 { PREFIX_TABLE (PREFIX_0F3814) },
5796 { PREFIX_TABLE (PREFIX_0F3815) },
5797 { "(bad)", { XX } },
5798 { PREFIX_TABLE (PREFIX_0F3817) },
5800 { "(bad)", { XX } },
5801 { "(bad)", { XX } },
5802 { "(bad)", { XX } },
5803 { "(bad)", { XX } },
5804 { "pabsb", { MX, EM } },
5805 { "pabsw", { MX, EM } },
5806 { "pabsd", { MX, EM } },
5807 { "(bad)", { XX } },
5809 { PREFIX_TABLE (PREFIX_0F3820) },
5810 { PREFIX_TABLE (PREFIX_0F3821) },
5811 { PREFIX_TABLE (PREFIX_0F3822) },
5812 { PREFIX_TABLE (PREFIX_0F3823) },
5813 { PREFIX_TABLE (PREFIX_0F3824) },
5814 { PREFIX_TABLE (PREFIX_0F3825) },
5815 { "(bad)", { XX } },
5816 { "(bad)", { XX } },
5818 { PREFIX_TABLE (PREFIX_0F3828) },
5819 { PREFIX_TABLE (PREFIX_0F3829) },
5820 { PREFIX_TABLE (PREFIX_0F382A) },
5821 { PREFIX_TABLE (PREFIX_0F382B) },
5822 { "(bad)", { XX } },
5823 { "(bad)", { XX } },
5824 { "(bad)", { XX } },
5825 { "(bad)", { XX } },
5827 { PREFIX_TABLE (PREFIX_0F3830) },
5828 { PREFIX_TABLE (PREFIX_0F3831) },
5829 { PREFIX_TABLE (PREFIX_0F3832) },
5830 { PREFIX_TABLE (PREFIX_0F3833) },
5831 { PREFIX_TABLE (PREFIX_0F3834) },
5832 { PREFIX_TABLE (PREFIX_0F3835) },
5833 { "(bad)", { XX } },
5834 { PREFIX_TABLE (PREFIX_0F3837) },
5836 { PREFIX_TABLE (PREFIX_0F3838) },
5837 { PREFIX_TABLE (PREFIX_0F3839) },
5838 { PREFIX_TABLE (PREFIX_0F383A) },
5839 { PREFIX_TABLE (PREFIX_0F383B) },
5840 { PREFIX_TABLE (PREFIX_0F383C) },
5841 { PREFIX_TABLE (PREFIX_0F383D) },
5842 { PREFIX_TABLE (PREFIX_0F383E) },
5843 { PREFIX_TABLE (PREFIX_0F383F) },
5845 { PREFIX_TABLE (PREFIX_0F3840) },
5846 { PREFIX_TABLE (PREFIX_0F3841) },
5847 { "(bad)", { XX } },
5848 { "(bad)", { XX } },
5849 { "(bad)", { XX } },
5850 { "(bad)", { XX } },
5851 { "(bad)", { XX } },
5852 { "(bad)", { XX } },
5854 { "(bad)", { XX } },
5855 { "(bad)", { XX } },
5856 { "(bad)", { XX } },
5857 { "(bad)", { XX } },
5858 { "(bad)", { XX } },
5859 { "(bad)", { XX } },
5860 { "(bad)", { XX } },
5861 { "(bad)", { XX } },
5863 { "(bad)", { XX } },
5864 { "(bad)", { XX } },
5865 { "(bad)", { XX } },
5866 { "(bad)", { XX } },
5867 { "(bad)", { XX } },
5868 { "(bad)", { XX } },
5869 { "(bad)", { XX } },
5870 { "(bad)", { XX } },
5872 { "(bad)", { XX } },
5873 { "(bad)", { XX } },
5874 { "(bad)", { XX } },
5875 { "(bad)", { XX } },
5876 { "(bad)", { XX } },
5877 { "(bad)", { XX } },
5878 { "(bad)", { XX } },
5879 { "(bad)", { XX } },
5881 { "(bad)", { XX } },
5882 { "(bad)", { XX } },
5883 { "(bad)", { XX } },
5884 { "(bad)", { XX } },
5885 { "(bad)", { XX } },
5886 { "(bad)", { XX } },
5887 { "(bad)", { XX } },
5888 { "(bad)", { XX } },
5890 { "(bad)", { XX } },
5891 { "(bad)", { XX } },
5892 { "(bad)", { XX } },
5893 { "(bad)", { XX } },
5894 { "(bad)", { XX } },
5895 { "(bad)", { XX } },
5896 { "(bad)", { XX } },
5897 { "(bad)", { XX } },
5899 { "(bad)", { XX } },
5900 { "(bad)", { XX } },
5901 { "(bad)", { XX } },
5902 { "(bad)", { XX } },
5903 { "(bad)", { XX } },
5904 { "(bad)", { XX } },
5905 { "(bad)", { XX } },
5906 { "(bad)", { XX } },
5908 { "(bad)", { XX } },
5909 { "(bad)", { XX } },
5910 { "(bad)", { XX } },
5911 { "(bad)", { XX } },
5912 { "(bad)", { XX } },
5913 { "(bad)", { XX } },
5914 { "(bad)", { XX } },
5915 { "(bad)", { XX } },
5917 { PREFIX_TABLE (PREFIX_0F3880) },
5918 { PREFIX_TABLE (PREFIX_0F3881) },
5919 { "(bad)", { XX } },
5920 { "(bad)", { XX } },
5921 { "(bad)", { XX } },
5922 { "(bad)", { XX } },
5923 { "(bad)", { XX } },
5924 { "(bad)", { XX } },
5926 { "(bad)", { XX } },
5927 { "(bad)", { XX } },
5928 { "(bad)", { XX } },
5929 { "(bad)", { XX } },
5930 { "(bad)", { XX } },
5931 { "(bad)", { XX } },
5932 { "(bad)", { XX } },
5933 { "(bad)", { XX } },
5935 { "(bad)", { XX } },
5936 { "(bad)", { XX } },
5937 { "(bad)", { XX } },
5938 { "(bad)", { XX } },
5939 { "(bad)", { XX } },
5940 { "(bad)", { XX } },
5941 { "(bad)", { XX } },
5942 { "(bad)", { XX } },
5944 { "(bad)", { XX } },
5945 { "(bad)", { XX } },
5946 { "(bad)", { XX } },
5947 { "(bad)", { XX } },
5948 { "(bad)", { XX } },
5949 { "(bad)", { XX } },
5950 { "(bad)", { XX } },
5951 { "(bad)", { XX } },
5953 { "(bad)", { XX } },
5954 { "(bad)", { XX } },
5955 { "(bad)", { XX } },
5956 { "(bad)", { XX } },
5957 { "(bad)", { XX } },
5958 { "(bad)", { XX } },
5959 { "(bad)", { XX } },
5960 { "(bad)", { XX } },
5962 { "(bad)", { XX } },
5963 { "(bad)", { XX } },
5964 { "(bad)", { XX } },
5965 { "(bad)", { XX } },
5966 { "(bad)", { XX } },
5967 { "(bad)", { XX } },
5968 { "(bad)", { XX } },
5969 { "(bad)", { XX } },
5971 { "(bad)", { XX } },
5972 { "(bad)", { XX } },
5973 { "(bad)", { XX } },
5974 { "(bad)", { XX } },
5975 { "(bad)", { XX } },
5976 { "(bad)", { XX } },
5977 { "(bad)", { XX } },
5978 { "(bad)", { XX } },
5980 { "(bad)", { XX } },
5981 { "(bad)", { XX } },
5982 { "(bad)", { XX } },
5983 { "(bad)", { XX } },
5984 { "(bad)", { XX } },
5985 { "(bad)", { XX } },
5986 { "(bad)", { XX } },
5987 { "(bad)", { XX } },
5989 { "(bad)", { XX } },
5990 { "(bad)", { XX } },
5991 { "(bad)", { XX } },
5992 { "(bad)", { XX } },
5993 { "(bad)", { XX } },
5994 { "(bad)", { XX } },
5995 { "(bad)", { XX } },
5996 { "(bad)", { XX } },
5998 { "(bad)", { XX } },
5999 { "(bad)", { XX } },
6000 { "(bad)", { XX } },
6001 { "(bad)", { XX } },
6002 { "(bad)", { XX } },
6003 { "(bad)", { XX } },
6004 { "(bad)", { XX } },
6005 { "(bad)", { XX } },
6007 { "(bad)", { XX } },
6008 { "(bad)", { XX } },
6009 { "(bad)", { XX } },
6010 { "(bad)", { XX } },
6011 { "(bad)", { XX } },
6012 { "(bad)", { XX } },
6013 { "(bad)", { XX } },
6014 { "(bad)", { XX } },
6016 { "(bad)", { XX } },
6017 { "(bad)", { XX } },
6018 { "(bad)", { XX } },
6019 { PREFIX_TABLE (PREFIX_0F38DB) },
6020 { PREFIX_TABLE (PREFIX_0F38DC) },
6021 { PREFIX_TABLE (PREFIX_0F38DD) },
6022 { PREFIX_TABLE (PREFIX_0F38DE) },
6023 { PREFIX_TABLE (PREFIX_0F38DF) },
6025 { "(bad)", { XX } },
6026 { "(bad)", { XX } },
6027 { "(bad)", { XX } },
6028 { "(bad)", { XX } },
6029 { "(bad)", { XX } },
6030 { "(bad)", { XX } },
6031 { "(bad)", { XX } },
6032 { "(bad)", { XX } },
6034 { "(bad)", { XX } },
6035 { "(bad)", { XX } },
6036 { "(bad)", { XX } },
6037 { "(bad)", { XX } },
6038 { "(bad)", { XX } },
6039 { "(bad)", { XX } },
6040 { "(bad)", { XX } },
6041 { "(bad)", { XX } },
6043 { PREFIX_TABLE (PREFIX_0F38F0) },
6044 { PREFIX_TABLE (PREFIX_0F38F1) },
6045 { "(bad)", { XX } },
6046 { "(bad)", { XX } },
6047 { "(bad)", { XX } },
6048 { "(bad)", { XX } },
6049 { "(bad)", { XX } },
6050 { "(bad)", { XX } },
6052 { "(bad)", { XX } },
6053 { "(bad)", { XX } },
6054 { "(bad)", { XX } },
6055 { "(bad)", { XX } },
6056 { "(bad)", { XX } },
6057 { "(bad)", { XX } },
6058 { "(bad)", { XX } },
6059 { "(bad)", { XX } },
6061 /* THREE_BYTE_0F3A */
6064 { "(bad)", { XX } },
6065 { "(bad)", { XX } },
6066 { "(bad)", { XX } },
6067 { "(bad)", { XX } },
6068 { "(bad)", { XX } },
6069 { "(bad)", { XX } },
6070 { "(bad)", { XX } },
6071 { "(bad)", { XX } },
6073 { PREFIX_TABLE (PREFIX_0F3A08) },
6074 { PREFIX_TABLE (PREFIX_0F3A09) },
6075 { PREFIX_TABLE (PREFIX_0F3A0A) },
6076 { PREFIX_TABLE (PREFIX_0F3A0B) },
6077 { PREFIX_TABLE (PREFIX_0F3A0C) },
6078 { PREFIX_TABLE (PREFIX_0F3A0D) },
6079 { PREFIX_TABLE (PREFIX_0F3A0E) },
6080 { "palignr", { MX, EM, Ib } },
6082 { "(bad)", { XX } },
6083 { "(bad)", { XX } },
6084 { "(bad)", { XX } },
6085 { "(bad)", { XX } },
6086 { PREFIX_TABLE (PREFIX_0F3A14) },
6087 { PREFIX_TABLE (PREFIX_0F3A15) },
6088 { PREFIX_TABLE (PREFIX_0F3A16) },
6089 { PREFIX_TABLE (PREFIX_0F3A17) },
6091 { "(bad)", { XX } },
6092 { "(bad)", { XX } },
6093 { "(bad)", { XX } },
6094 { "(bad)", { XX } },
6095 { "(bad)", { XX } },
6096 { "(bad)", { XX } },
6097 { "(bad)", { XX } },
6098 { "(bad)", { XX } },
6100 { PREFIX_TABLE (PREFIX_0F3A20) },
6101 { PREFIX_TABLE (PREFIX_0F3A21) },
6102 { PREFIX_TABLE (PREFIX_0F3A22) },
6103 { "(bad)", { XX } },
6104 { "(bad)", { XX } },
6105 { "(bad)", { XX } },
6106 { "(bad)", { XX } },
6107 { "(bad)", { XX } },
6109 { "(bad)", { XX } },
6110 { "(bad)", { XX } },
6111 { "(bad)", { XX } },
6112 { "(bad)", { XX } },
6113 { "(bad)", { XX } },
6114 { "(bad)", { XX } },
6115 { "(bad)", { XX } },
6116 { "(bad)", { XX } },
6118 { "(bad)", { XX } },
6119 { "(bad)", { XX } },
6120 { "(bad)", { XX } },
6121 { "(bad)", { XX } },
6122 { "(bad)", { XX } },
6123 { "(bad)", { XX } },
6124 { "(bad)", { XX } },
6125 { "(bad)", { XX } },
6127 { "(bad)", { XX } },
6128 { "(bad)", { XX } },
6129 { "(bad)", { XX } },
6130 { "(bad)", { XX } },
6131 { "(bad)", { XX } },
6132 { "(bad)", { XX } },
6133 { "(bad)", { XX } },
6134 { "(bad)", { XX } },
6136 { PREFIX_TABLE (PREFIX_0F3A40) },
6137 { PREFIX_TABLE (PREFIX_0F3A41) },
6138 { PREFIX_TABLE (PREFIX_0F3A42) },
6139 { "(bad)", { XX } },
6140 { PREFIX_TABLE (PREFIX_0F3A44) },
6141 { "(bad)", { XX } },
6142 { "(bad)", { XX } },
6143 { "(bad)", { XX } },
6145 { "(bad)", { XX } },
6146 { "(bad)", { XX } },
6147 { "(bad)", { XX } },
6148 { "(bad)", { XX } },
6149 { "(bad)", { XX } },
6150 { "(bad)", { XX } },
6151 { "(bad)", { XX } },
6152 { "(bad)", { XX } },
6154 { "(bad)", { XX } },
6155 { "(bad)", { XX } },
6156 { "(bad)", { XX } },
6157 { "(bad)", { XX } },
6158 { "(bad)", { XX } },
6159 { "(bad)", { XX } },
6160 { "(bad)", { XX } },
6161 { "(bad)", { XX } },
6163 { "(bad)", { XX } },
6164 { "(bad)", { XX } },
6165 { "(bad)", { XX } },
6166 { "(bad)", { XX } },
6167 { "(bad)", { XX } },
6168 { "(bad)", { XX } },
6169 { "(bad)", { XX } },
6170 { "(bad)", { XX } },
6172 { PREFIX_TABLE (PREFIX_0F3A60) },
6173 { PREFIX_TABLE (PREFIX_0F3A61) },
6174 { PREFIX_TABLE (PREFIX_0F3A62) },
6175 { PREFIX_TABLE (PREFIX_0F3A63) },
6176 { "(bad)", { XX } },
6177 { "(bad)", { XX } },
6178 { "(bad)", { XX } },
6179 { "(bad)", { XX } },
6181 { "(bad)", { XX } },
6182 { "(bad)", { XX } },
6183 { "(bad)", { XX } },
6184 { "(bad)", { XX } },
6185 { "(bad)", { XX } },
6186 { "(bad)", { XX } },
6187 { "(bad)", { XX } },
6188 { "(bad)", { XX } },
6190 { "(bad)", { XX } },
6191 { "(bad)", { XX } },
6192 { "(bad)", { XX } },
6193 { "(bad)", { XX } },
6194 { "(bad)", { XX } },
6195 { "(bad)", { XX } },
6196 { "(bad)", { XX } },
6197 { "(bad)", { XX } },
6199 { "(bad)", { XX } },
6200 { "(bad)", { XX } },
6201 { "(bad)", { XX } },
6202 { "(bad)", { XX } },
6203 { "(bad)", { XX } },
6204 { "(bad)", { XX } },
6205 { "(bad)", { XX } },
6206 { "(bad)", { XX } },
6208 { "(bad)", { XX } },
6209 { "(bad)", { XX } },
6210 { "(bad)", { XX } },
6211 { "(bad)", { XX } },
6212 { "(bad)", { XX } },
6213 { "(bad)", { XX } },
6214 { "(bad)", { XX } },
6215 { "(bad)", { XX } },
6217 { "(bad)", { XX } },
6218 { "(bad)", { XX } },
6219 { "(bad)", { XX } },
6220 { "(bad)", { XX } },
6221 { "(bad)", { XX } },
6222 { "(bad)", { XX } },
6223 { "(bad)", { XX } },
6224 { "(bad)", { XX } },
6226 { "(bad)", { XX } },
6227 { "(bad)", { XX } },
6228 { "(bad)", { XX } },
6229 { "(bad)", { XX } },
6230 { "(bad)", { XX } },
6231 { "(bad)", { XX } },
6232 { "(bad)", { XX } },
6233 { "(bad)", { XX } },
6235 { "(bad)", { XX } },
6236 { "(bad)", { XX } },
6237 { "(bad)", { XX } },
6238 { "(bad)", { XX } },
6239 { "(bad)", { XX } },
6240 { "(bad)", { XX } },
6241 { "(bad)", { XX } },
6242 { "(bad)", { XX } },
6244 { "(bad)", { XX } },
6245 { "(bad)", { XX } },
6246 { "(bad)", { XX } },
6247 { "(bad)", { XX } },
6248 { "(bad)", { XX } },
6249 { "(bad)", { XX } },
6250 { "(bad)", { XX } },
6251 { "(bad)", { XX } },
6253 { "(bad)", { XX } },
6254 { "(bad)", { XX } },
6255 { "(bad)", { XX } },
6256 { "(bad)", { XX } },
6257 { "(bad)", { XX } },
6258 { "(bad)", { XX } },
6259 { "(bad)", { XX } },
6260 { "(bad)", { XX } },
6262 { "(bad)", { XX } },
6263 { "(bad)", { XX } },
6264 { "(bad)", { XX } },
6265 { "(bad)", { XX } },
6266 { "(bad)", { XX } },
6267 { "(bad)", { XX } },
6268 { "(bad)", { XX } },
6269 { "(bad)", { XX } },
6271 { "(bad)", { XX } },
6272 { "(bad)", { XX } },
6273 { "(bad)", { XX } },
6274 { "(bad)", { XX } },
6275 { "(bad)", { XX } },
6276 { "(bad)", { XX } },
6277 { "(bad)", { XX } },
6278 { "(bad)", { XX } },
6280 { "(bad)", { XX } },
6281 { "(bad)", { XX } },
6282 { "(bad)", { XX } },
6283 { "(bad)", { XX } },
6284 { "(bad)", { XX } },
6285 { "(bad)", { XX } },
6286 { "(bad)", { XX } },
6287 { "(bad)", { XX } },
6289 { "(bad)", { XX } },
6290 { "(bad)", { XX } },
6291 { "(bad)", { XX } },
6292 { "(bad)", { XX } },
6293 { "(bad)", { XX } },
6294 { "(bad)", { XX } },
6295 { "(bad)", { XX } },
6296 { "(bad)", { XX } },
6298 { "(bad)", { XX } },
6299 { "(bad)", { XX } },
6300 { "(bad)", { XX } },
6301 { "(bad)", { XX } },
6302 { "(bad)", { XX } },
6303 { "(bad)", { XX } },
6304 { "(bad)", { XX } },
6305 { "(bad)", { XX } },
6307 { "(bad)", { XX } },
6308 { "(bad)", { XX } },
6309 { "(bad)", { XX } },
6310 { "(bad)", { XX } },
6311 { "(bad)", { XX } },
6312 { "(bad)", { XX } },
6313 { "(bad)", { XX } },
6314 { PREFIX_TABLE (PREFIX_0F3ADF) },
6316 { "(bad)", { XX } },
6317 { "(bad)", { XX } },
6318 { "(bad)", { XX } },
6319 { "(bad)", { XX } },
6320 { "(bad)", { XX } },
6321 { "(bad)", { XX } },
6322 { "(bad)", { XX } },
6323 { "(bad)", { XX } },
6325 { "(bad)", { XX } },
6326 { "(bad)", { XX } },
6327 { "(bad)", { XX } },
6328 { "(bad)", { XX } },
6329 { "(bad)", { XX } },
6330 { "(bad)", { XX } },
6331 { "(bad)", { XX } },
6332 { "(bad)", { XX } },
6334 { "(bad)", { XX } },
6335 { "(bad)", { XX } },
6336 { "(bad)", { XX } },
6337 { "(bad)", { XX } },
6338 { "(bad)", { XX } },
6339 { "(bad)", { XX } },
6340 { "(bad)", { XX } },
6341 { "(bad)", { XX } },
6343 { "(bad)", { XX } },
6344 { "(bad)", { XX } },
6345 { "(bad)", { XX } },
6346 { "(bad)", { XX } },
6347 { "(bad)", { XX } },
6348 { "(bad)", { XX } },
6349 { "(bad)", { XX } },
6350 { "(bad)", { XX } },
6353 /* THREE_BYTE_0F7A */
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 } },
6392 { "ptest", { XX } },
6393 { "(bad)", { XX } },
6394 { "(bad)", { XX } },
6395 { "(bad)", { XX } },
6396 { "(bad)", { XX } },
6397 { "(bad)", { XX } },
6398 { "(bad)", { XX } },
6399 { "(bad)", { XX } },
6401 { "(bad)", { XX } },
6402 { "(bad)", { XX } },
6403 { "(bad)", { XX } },
6404 { "(bad)", { XX } },
6405 { "(bad)", { XX } },
6406 { "(bad)", { XX } },
6407 { "(bad)", { XX } },
6408 { "(bad)", { XX } },
6410 { "(bad)", { XX } },
6411 { "(bad)", { XX } },
6412 { "(bad)", { XX } },
6413 { "(bad)", { XX } },
6414 { "(bad)", { XX } },
6415 { "(bad)", { XX } },
6416 { "(bad)", { XX } },
6417 { "(bad)", { XX } },
6419 { "(bad)", { XX } },
6420 { "(bad)", { XX } },
6421 { "(bad)", { XX } },
6422 { "(bad)", { XX } },
6423 { "(bad)", { XX } },
6424 { "(bad)", { XX } },
6425 { "(bad)", { XX } },
6426 { "(bad)", { XX } },
6428 { "(bad)", { XX } },
6429 { "phaddbw", { XM, EXq } },
6430 { "phaddbd", { XM, EXq } },
6431 { "phaddbq", { XM, EXq } },
6432 { "(bad)", { XX } },
6433 { "(bad)", { XX } },
6434 { "phaddwd", { XM, EXq } },
6435 { "phaddwq", { XM, EXq } },
6437 { "(bad)", { XX } },
6438 { "(bad)", { XX } },
6439 { "(bad)", { XX } },
6440 { "phadddq", { XM, EXq } },
6441 { "(bad)", { XX } },
6442 { "(bad)", { XX } },
6443 { "(bad)", { XX } },
6444 { "(bad)", { XX } },
6446 { "(bad)", { XX } },
6447 { "phaddubw", { XM, EXq } },
6448 { "phaddubd", { XM, EXq } },
6449 { "phaddubq", { XM, EXq } },
6450 { "(bad)", { XX } },
6451 { "(bad)", { XX } },
6452 { "phadduwd", { XM, EXq } },
6453 { "phadduwq", { XM, EXq } },
6455 { "(bad)", { XX } },
6456 { "(bad)", { XX } },
6457 { "(bad)", { XX } },
6458 { "phaddudq", { XM, EXq } },
6459 { "(bad)", { XX } },
6460 { "(bad)", { XX } },
6461 { "(bad)", { XX } },
6462 { "(bad)", { XX } },
6464 { "(bad)", { XX } },
6465 { "phsubbw", { XM, EXq } },
6466 { "phsubbd", { XM, EXq } },
6467 { "phsubbq", { XM, EXq } },
6468 { "(bad)", { XX } },
6469 { "(bad)", { XX } },
6470 { "(bad)", { XX } },
6471 { "(bad)", { XX } },
6473 { "(bad)", { XX } },
6474 { "(bad)", { XX } },
6475 { "(bad)", { XX } },
6476 { "(bad)", { XX } },
6477 { "(bad)", { XX } },
6478 { "(bad)", { XX } },
6479 { "(bad)", { XX } },
6480 { "(bad)", { XX } },
6482 { "(bad)", { XX } },
6483 { "(bad)", { XX } },
6484 { "(bad)", { XX } },
6485 { "(bad)", { XX } },
6486 { "(bad)", { XX } },
6487 { "(bad)", { XX } },
6488 { "(bad)", { XX } },
6489 { "(bad)", { XX } },
6491 { "(bad)", { XX } },
6492 { "(bad)", { XX } },
6493 { "(bad)", { XX } },
6494 { "(bad)", { XX } },
6495 { "(bad)", { XX } },
6496 { "(bad)", { XX } },
6497 { "(bad)", { XX } },
6498 { "(bad)", { XX } },
6500 { "(bad)", { XX } },
6501 { "(bad)", { XX } },
6502 { "(bad)", { XX } },
6503 { "(bad)", { XX } },
6504 { "(bad)", { XX } },
6505 { "(bad)", { XX } },
6506 { "(bad)", { XX } },
6507 { "(bad)", { XX } },
6509 { "(bad)", { XX } },
6510 { "(bad)", { XX } },
6511 { "(bad)", { XX } },
6512 { "(bad)", { XX } },
6513 { "(bad)", { XX } },
6514 { "(bad)", { XX } },
6515 { "(bad)", { XX } },
6516 { "(bad)", { XX } },
6518 { "(bad)", { XX } },
6519 { "(bad)", { XX } },
6520 { "(bad)", { XX } },
6521 { "(bad)", { XX } },
6522 { "(bad)", { XX } },
6523 { "(bad)", { XX } },
6524 { "(bad)", { XX } },
6525 { "(bad)", { XX } },
6527 { "(bad)", { XX } },
6528 { "(bad)", { XX } },
6529 { "(bad)", { XX } },
6530 { "(bad)", { XX } },
6531 { "(bad)", { XX } },
6532 { "(bad)", { XX } },
6533 { "(bad)", { XX } },
6534 { "(bad)", { XX } },
6536 { "(bad)", { XX } },
6537 { "(bad)", { XX } },
6538 { "(bad)", { XX } },
6539 { "(bad)", { XX } },
6540 { "(bad)", { XX } },
6541 { "(bad)", { XX } },
6542 { "(bad)", { XX } },
6543 { "(bad)", { XX } },
6545 { "(bad)", { XX } },
6546 { "(bad)", { XX } },
6547 { "(bad)", { XX } },
6548 { "(bad)", { XX } },
6549 { "(bad)", { XX } },
6550 { "(bad)", { XX } },
6551 { "(bad)", { XX } },
6552 { "(bad)", { XX } },
6554 { "(bad)", { XX } },
6555 { "(bad)", { XX } },
6556 { "(bad)", { XX } },
6557 { "(bad)", { XX } },
6558 { "(bad)", { XX } },
6559 { "(bad)", { XX } },
6560 { "(bad)", { XX } },
6561 { "(bad)", { XX } },
6563 { "(bad)", { XX } },
6564 { "(bad)", { XX } },
6565 { "(bad)", { XX } },
6566 { "(bad)", { XX } },
6567 { "(bad)", { XX } },
6568 { "(bad)", { XX } },
6569 { "(bad)", { XX } },
6570 { "(bad)", { XX } },
6572 { "(bad)", { XX } },
6573 { "(bad)", { XX } },
6574 { "(bad)", { XX } },
6575 { "(bad)", { XX } },
6576 { "(bad)", { XX } },
6577 { "(bad)", { XX } },
6578 { "(bad)", { XX } },
6579 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6582 { "(bad)", { XX } },
6583 { "(bad)", { XX } },
6584 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6591 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6593 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6600 { "(bad)", { XX } },
6601 { "(bad)", { XX } },
6602 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6609 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6611 { "(bad)", { XX } },
6612 { "(bad)", { XX } },
6613 { "(bad)", { XX } },
6614 { "(bad)", { XX } },
6615 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6618 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6620 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6626 { "(bad)", { XX } },
6627 { "(bad)", { XX } },
6628 { "(bad)", { XX } },
6629 { "(bad)", { XX } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6636 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6638 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6646 static const struct dis386 xop_table[][256] = {
6650 { "(bad)", { XX } },
6651 { "(bad)", { XX } },
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6654 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6656 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6660 { "(bad)", { XX } },
6661 { "(bad)", { XX } },
6662 { "(bad)", { XX } },
6663 { "(bad)", { XX } },
6664 { "(bad)", { XX } },
6665 { "(bad)", { XX } },
6666 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6669 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6672 { "(bad)", { XX } },
6673 { "(bad)", { XX } },
6674 { "(bad)", { XX } },
6675 { "(bad)", { XX } },
6677 { "(bad)", { XX } },
6678 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6683 { "(bad)", { XX } },
6684 { "(bad)", { XX } },
6686 { "(bad)", { XX } },
6687 { "(bad)", { XX } },
6688 { "(bad)", { XX } },
6689 { "(bad)", { XX } },
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6693 { "(bad)", { XX } },
6695 { "(bad)", { XX } },
6696 { "(bad)", { XX } },
6697 { "(bad)", { XX } },
6698 { "(bad)", { XX } },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6702 { "(bad)", { XX } },
6704 { "(bad)", { XX } },
6705 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6707 { "(bad)", { XX } },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6711 { "(bad)", { XX } },
6713 { "(bad)", { XX } },
6714 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6716 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6720 { "(bad)", { XX } },
6722 { "(bad)", { XX } },
6723 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6725 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6729 { "(bad)", { XX } },
6731 { "(bad)", { XX } },
6732 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6734 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6738 { "(bad)", { XX } },
6740 { "(bad)", { XX } },
6741 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6743 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6747 { "(bad)", { XX } },
6749 { "(bad)", { XX } },
6750 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6752 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6756 { "(bad)", { XX } },
6758 { "(bad)", { XX } },
6759 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6761 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6765 { "(bad)", { XX } },
6767 { "(bad)", { XX } },
6768 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6770 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6774 { "(bad)", { XX } },
6776 { "(bad)", { XX } },
6777 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6779 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6783 { "(bad)", { XX } },
6785 { "(bad)", { XX } },
6786 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6788 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6792 { "(bad)", { XX } },
6794 { "(bad)", { XX } },
6795 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6797 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "vpmacssww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6800 { "vpmacsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6801 { "vpmacssdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6803 { "(bad)", { XX } },
6804 { "(bad)", { XX } },
6805 { "(bad)", { XX } },
6806 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "vpmacssdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6810 { "vpmacssdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6812 { "(bad)", { XX } },
6813 { "(bad)", { XX } },
6814 { "(bad)", { XX } },
6815 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "vpmacsww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6818 { "vpmacswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6819 { "vpmacsdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6821 { "(bad)", { XX } },
6822 { "(bad)", { XX } },
6823 { "(bad)", { XX } },
6824 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "vpmacsdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6828 { "vpmacsdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6830 { "(bad)", { XX } },
6831 { "(bad)", { XX } },
6832 { "vpcmov", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6833 { "vpperm", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6834 { "(bad)", { XX } },
6835 { "(bad)", { XX } },
6836 { "vpmadcsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6837 { "(bad)", { XX } },
6839 { "(bad)", { XX } },
6840 { "(bad)", { XX } },
6841 { "(bad)", { XX } },
6842 { "(bad)", { XX } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6846 { "(bad)", { XX } },
6848 { "(bad)", { XX } },
6849 { "(bad)", { XX } },
6850 { "(bad)", { XX } },
6851 { "(bad)", { XX } },
6852 { "(bad)", { XX } },
6853 { "(bad)", { XX } },
6854 { "vpmadcswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6855 { "(bad)", { XX } },
6857 { "(bad)", { XX } },
6858 { "(bad)", { XX } },
6859 { "(bad)", { XX } },
6860 { "(bad)", { XX } },
6861 { "(bad)", { XX } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6864 { "(bad)", { XX } },
6866 { "vprotb", { XM, Vex_2src_1, Ib } },
6867 { "vprotw", { XM, Vex_2src_1, Ib } },
6868 { "vprotd", { XM, Vex_2src_1, Ib } },
6869 { "vprotq", { XM, Vex_2src_1, Ib } },
6870 { "(bad)", { XX } },
6871 { "(bad)", { XX } },
6872 { "(bad)", { XX } },
6873 { "(bad)", { XX } },
6875 { "(bad)", { XX } },
6876 { "(bad)", { XX } },
6877 { "(bad)", { XX } },
6878 { "(bad)", { XX } },
6879 { "vpcomb", { XM, Vex128, EXx, Ib } },
6880 { "vpcomw", { XM, Vex128, EXx, Ib } },
6881 { "vpcomd", { XM, Vex128, EXx, Ib } },
6882 { "vpcomq", { XM, Vex128, EXx, Ib } },
6884 { "(bad)", { XX } },
6885 { "(bad)", { XX } },
6886 { "(bad)", { XX } },
6887 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6891 { "(bad)", { XX } },
6893 { "(bad)", { XX } },
6894 { "(bad)", { XX } },
6895 { "(bad)", { XX } },
6896 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6900 { "(bad)", { XX } },
6902 { "(bad)", { XX } },
6903 { "(bad)", { XX } },
6904 { "(bad)", { XX } },
6905 { "(bad)", { XX } },
6906 { "(bad)", { XX } },
6907 { "(bad)", { XX } },
6908 { "(bad)", { XX } },
6909 { "(bad)", { XX } },
6911 { "(bad)", { XX } },
6912 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6914 { "(bad)", { XX } },
6915 { "vpcomub", { XM, Vex128, EXx, Ib } },
6916 { "vpcomuw", { XM, Vex128, EXx, Ib } },
6917 { "vpcomud", { XM, Vex128, EXx, Ib } },
6918 { "vpcomuq", { XM, Vex128, EXx, Ib } },
6920 { "(bad)", { XX } },
6921 { "(bad)", { XX } },
6922 { "(bad)", { XX } },
6923 { "(bad)", { XX } },
6924 { "(bad)", { XX } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6927 { "(bad)", { XX } },
6929 { "(bad)", { XX } },
6930 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6932 { "(bad)", { XX } },
6933 { "(bad)", { XX } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6936 { "(bad)", { XX } },
6941 { "(bad)", { XX } },
6942 { "(bad)", { XX } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6945 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6947 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6950 { "(bad)", { XX } },
6951 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6954 { "(bad)", { XX } },
6955 { "(bad)", { XX } },
6956 { "(bad)", { XX } },
6957 { "(bad)", { XX } },
6959 { "(bad)", { XX } },
6960 { "(bad)", { XX } },
6961 { REG_TABLE (REG_XOP_LWPCB) },
6962 { "(bad)", { XX } },
6963 { "(bad)", { XX } },
6964 { "(bad)", { XX } },
6965 { "(bad)", { XX } },
6966 { "(bad)", { XX } },
6968 { "(bad)", { XX } },
6969 { "(bad)", { XX } },
6970 { "(bad)", { XX } },
6971 { "(bad)", { XX } },
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6974 { "(bad)", { XX } },
6975 { "(bad)", { XX } },
6977 { "(bad)", { XX } },
6978 { "(bad)", { XX } },
6979 { "(bad)", { XX } },
6980 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6986 { "(bad)", { XX } },
6987 { "(bad)", { XX } },
6988 { "(bad)", { XX } },
6989 { "(bad)", { XX } },
6990 { "(bad)", { XX } },
6991 { "(bad)", { XX } },
6992 { "(bad)", { XX } },
6993 { "(bad)", { XX } },
6995 { "(bad)", { XX } },
6996 { "(bad)", { XX } },
6997 { "(bad)", { XX } },
6998 { "(bad)", { XX } },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { "(bad)", { XX } },
7002 { "(bad)", { XX } },
7004 { "(bad)", { XX } },
7005 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7007 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7013 { "(bad)", { XX } },
7014 { "(bad)", { XX } },
7015 { "(bad)", { XX } },
7016 { "(bad)", { XX } },
7017 { "(bad)", { XX } },
7018 { "(bad)", { XX } },
7019 { "(bad)", { XX } },
7020 { "(bad)", { XX } },
7022 { "(bad)", { XX } },
7023 { "(bad)", { XX } },
7024 { "(bad)", { XX } },
7025 { "(bad)", { XX } },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7031 { "(bad)", { XX } },
7032 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7034 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7040 { "(bad)", { XX } },
7041 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7043 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7049 { "(bad)", { XX } },
7050 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7052 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7058 { "(bad)", { XX } },
7059 { "(bad)", { XX } },
7060 { "(bad)", { XX } },
7061 { "(bad)", { XX } },
7062 { "(bad)", { XX } },
7063 { "(bad)", { XX } },
7064 { "(bad)", { XX } },
7065 { "(bad)", { XX } },
7067 { "(bad)", { XX } },
7068 { "(bad)", { XX } },
7069 { "(bad)", { XX } },
7070 { "(bad)", { XX } },
7071 { "(bad)", { XX } },
7072 { "(bad)", { XX } },
7073 { "(bad)", { XX } },
7074 { "(bad)", { XX } },
7076 { "(bad)", { XX } },
7077 { "(bad)", { XX } },
7078 { "(bad)", { XX } },
7079 { "(bad)", { XX } },
7080 { "(bad)", { XX } },
7081 { "(bad)", { XX } },
7082 { "(bad)", { XX } },
7083 { "(bad)", { XX } },
7085 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80) },
7086 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81) },
7087 { "vfrczss", { XM, EXd } },
7088 { "vfrczsd", { XM, EXq } },
7089 { "(bad)", { XX } },
7090 { "(bad)", { XX } },
7091 { "(bad)", { XX } },
7092 { "(bad)", { XX } },
7094 { "(bad)", { XX } },
7095 { "(bad)", { XX } },
7096 { "(bad)", { XX } },
7097 { "(bad)", { XX } },
7098 { "(bad)", { XX } },
7099 { "(bad)", { XX } },
7100 { "(bad)", { XX } },
7101 { "(bad)", { XX } },
7103 { "vprotb", { XM, Vex_2src_1, Vex_2src_2 } },
7104 { "vprotw", { XM, Vex_2src_1, Vex_2src_2 } },
7105 { "vprotd", { XM, Vex_2src_1, Vex_2src_2 } },
7106 { "vprotq", { XM, Vex_2src_1, Vex_2src_2 } },
7107 { "vpshlb", { XM, Vex_2src_1, Vex_2src_2 } },
7108 { "vpshlw", { XM, Vex_2src_1, Vex_2src_2 } },
7109 { "vpshld", { XM, Vex_2src_1, Vex_2src_2 } },
7110 { "vpshlq", { XM, Vex_2src_1, Vex_2src_2 } },
7112 { "vpshab", { XM, Vex_2src_1, Vex_2src_2 } },
7113 { "vpshaw", { XM, Vex_2src_1, Vex_2src_2 } },
7114 { "vpshad", { XM, Vex_2src_1, Vex_2src_2 } },
7115 { "vpshaq", { XM, Vex_2src_1, Vex_2src_2 } },
7116 { "(bad)", { XX } },
7117 { "(bad)", { XX } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7121 { "(bad)", { XX } },
7122 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7124 { "(bad)", { XX } },
7125 { "(bad)", { XX } },
7126 { "(bad)", { XX } },
7127 { "(bad)", { XX } },
7128 { "(bad)", { XX } },
7130 { "(bad)", { XX } },
7131 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7133 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7139 { "(bad)", { XX } },
7140 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7142 { "(bad)", { XX } },
7143 { "(bad)", { XX } },
7144 { "(bad)", { XX } },
7145 { "(bad)", { XX } },
7146 { "(bad)", { XX } },
7148 { "(bad)", { XX } },
7149 { "(bad)", { XX } },
7150 { "(bad)", { XX } },
7151 { "(bad)", { XX } },
7152 { "(bad)", { XX } },
7153 { "(bad)", { XX } },
7154 { "(bad)", { XX } },
7155 { "(bad)", { XX } },
7157 { "(bad)", { XX } },
7158 { "vphaddbw", { XM, EXxmm } },
7159 { "vphaddbd", { XM, EXxmm } },
7160 { "vphaddbq", { XM, EXxmm } },
7161 { "(bad)", { XX } },
7162 { "(bad)", { XX } },
7163 { "vphaddwd", { XM, EXxmm } },
7164 { "vphaddwq", { XM, EXxmm } },
7166 { "(bad)", { XX } },
7167 { "(bad)", { XX } },
7168 { "(bad)", { XX } },
7169 { "vphadddq", { XM, EXxmm } },
7170 { "(bad)", { XX } },
7171 { "(bad)", { XX } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7175 { "(bad)", { XX } },
7176 { "vphaddubw", { XM, EXxmm } },
7177 { "vphaddubd", { XM, EXxmm } },
7178 { "vphaddubq", { XM, EXxmm } },
7179 { "(bad)", { XX } },
7180 { "(bad)", { XX } },
7181 { "vphadduwd", { XM, EXxmm } },
7182 { "vphadduwq", { XM, EXxmm } },
7184 { "(bad)", { XX } },
7185 { "(bad)", { XX } },
7186 { "(bad)", { XX } },
7187 { "vphaddudq", { XM, EXxmm } },
7188 { "(bad)", { XX } },
7189 { "(bad)", { XX } },
7190 { "(bad)", { XX } },
7191 { "(bad)", { XX } },
7193 { "(bad)", { XX } },
7194 { "vphsubbw", { XM, EXxmm } },
7195 { "vphsubwd", { XM, EXxmm } },
7196 { "vphsubdq", { XM, EXxmm } },
7197 { "(bad)", { XX } },
7198 { "(bad)", { XX } },
7199 { "(bad)", { XX } },
7200 { "(bad)", { XX } },
7202 { "(bad)", { XX } },
7203 { "(bad)", { XX } },
7204 { "(bad)", { XX } },
7205 { "(bad)", { XX } },
7206 { "(bad)", { XX } },
7207 { "(bad)", { XX } },
7208 { "(bad)", { XX } },
7209 { "(bad)", { XX } },
7211 { "(bad)", { XX } },
7212 { "(bad)", { XX } },
7213 { "(bad)", { XX } },
7214 { "(bad)", { XX } },
7215 { "(bad)", { XX } },
7216 { "(bad)", { XX } },
7217 { "(bad)", { XX } },
7218 { "(bad)", { XX } },
7220 { "(bad)", { XX } },
7221 { "(bad)", { XX } },
7222 { "(bad)", { XX } },
7223 { "(bad)", { XX } },
7224 { "(bad)", { XX } },
7225 { "(bad)", { XX } },
7226 { "(bad)", { XX } },
7227 { "(bad)", { XX } },
7232 { "(bad)", { XX } },
7233 { "(bad)", { XX } },
7234 { "(bad)", { XX } },
7235 { "(bad)", { XX } },
7236 { "(bad)", { XX } },
7237 { "(bad)", { XX } },
7238 { "(bad)", { XX } },
7239 { "(bad)", { XX } },
7241 { "(bad)", { XX } },
7242 { "(bad)", { XX } },
7243 { "(bad)", { XX } },
7244 { "(bad)", { XX } },
7245 { "(bad)", { XX } },
7246 { "(bad)", { XX } },
7247 { "(bad)", { XX } },
7248 { "(bad)", { XX } },
7250 { "(bad)", { XX } },
7251 { "(bad)", { XX } },
7252 { REG_TABLE (REG_XOP_LWP) },
7253 { "(bad)", { XX } },
7254 { "(bad)", { XX } },
7255 { "(bad)", { XX } },
7256 { "(bad)", { XX } },
7257 { "(bad)", { XX } },
7259 { "(bad)", { XX } },
7260 { "(bad)", { XX } },
7261 { "(bad)", { XX } },
7262 { "(bad)", { XX } },
7263 { "(bad)", { XX } },
7264 { "(bad)", { XX } },
7265 { "(bad)", { XX } },
7266 { "(bad)", { XX } },
7268 { "(bad)", { XX } },
7269 { "(bad)", { XX } },
7270 { "(bad)", { XX } },
7271 { "(bad)", { XX } },
7272 { "(bad)", { XX } },
7273 { "(bad)", { XX } },
7274 { "(bad)", { XX } },
7275 { "(bad)", { XX } },
7277 { "(bad)", { XX } },
7278 { "(bad)", { XX } },
7279 { "(bad)", { XX } },
7280 { "(bad)", { XX } },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7286 { "(bad)", { XX } },
7287 { "(bad)", { XX } },
7288 { "(bad)", { XX } },
7289 { "(bad)", { XX } },
7290 { "(bad)", { XX } },
7291 { "(bad)", { XX } },
7292 { "(bad)", { XX } },
7293 { "(bad)", { XX } },
7295 { "(bad)", { XX } },
7296 { "(bad)", { XX } },
7297 { "(bad)", { XX } },
7298 { "(bad)", { XX } },
7299 { "(bad)", { XX } },
7300 { "(bad)", { XX } },
7301 { "(bad)", { XX } },
7302 { "(bad)", { XX } },
7304 { "(bad)", { XX } },
7305 { "(bad)", { XX } },
7306 { "(bad)", { XX } },
7307 { "(bad)", { XX } },
7308 { "(bad)", { XX } },
7309 { "(bad)", { XX } },
7310 { "(bad)", { XX } },
7311 { "(bad)", { XX } },
7313 { "(bad)", { XX } },
7314 { "(bad)", { XX } },
7315 { "(bad)", { XX } },
7316 { "(bad)", { XX } },
7317 { "(bad)", { XX } },
7318 { "(bad)", { XX } },
7319 { "(bad)", { XX } },
7320 { "(bad)", { XX } },
7322 { "(bad)", { XX } },
7323 { "(bad)", { XX } },
7324 { "(bad)", { XX } },
7325 { "(bad)", { XX } },
7326 { "(bad)", { XX } },
7327 { "(bad)", { XX } },
7328 { "(bad)", { XX } },
7329 { "(bad)", { XX } },
7331 { "(bad)", { XX } },
7332 { "(bad)", { XX } },
7333 { "(bad)", { XX } },
7334 { "(bad)", { XX } },
7335 { "(bad)", { XX } },
7336 { "(bad)", { XX } },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7341 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7343 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7350 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7352 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7359 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7361 { "(bad)", { XX } },
7362 { "(bad)", { XX } },
7363 { "(bad)", { XX } },
7364 { "(bad)", { XX } },
7365 { "(bad)", { XX } },
7367 { "(bad)", { XX } },
7368 { "(bad)", { XX } },
7369 { "(bad)", { XX } },
7370 { "(bad)", { XX } },
7371 { "(bad)", { XX } },
7372 { "(bad)", { XX } },
7373 { "(bad)", { XX } },
7374 { "(bad)", { XX } },
7376 { "(bad)", { XX } },
7377 { "(bad)", { XX } },
7378 { "(bad)", { XX } },
7379 { "(bad)", { XX } },
7380 { "(bad)", { XX } },
7381 { "(bad)", { XX } },
7382 { "(bad)", { XX } },
7383 { "(bad)", { XX } },
7385 { "(bad)", { XX } },
7386 { "(bad)", { XX } },
7387 { "(bad)", { XX } },
7388 { "(bad)", { XX } },
7389 { "(bad)", { XX } },
7390 { "(bad)", { XX } },
7391 { "(bad)", { XX } },
7392 { "(bad)", { XX } },
7394 { "(bad)", { XX } },
7395 { "(bad)", { XX } },
7396 { "(bad)", { XX } },
7397 { "(bad)", { XX } },
7398 { "(bad)", { XX } },
7399 { "(bad)", { XX } },
7400 { "(bad)", { XX } },
7401 { "(bad)", { XX } },
7403 { "(bad)", { XX } },
7404 { "(bad)", { XX } },
7405 { "(bad)", { XX } },
7406 { "(bad)", { XX } },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7412 { "(bad)", { XX } },
7413 { "(bad)", { XX } },
7414 { "(bad)", { XX } },
7415 { "(bad)", { XX } },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7422 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7424 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7430 { "(bad)", { XX } },
7431 { "(bad)", { XX } },
7432 { "(bad)", { XX } },
7433 { "(bad)", { XX } },
7434 { "(bad)", { XX } },
7435 { "(bad)", { XX } },
7436 { "(bad)", { XX } },
7437 { "(bad)", { XX } },
7439 { "(bad)", { XX } },
7440 { "(bad)", { XX } },
7441 { "(bad)", { XX } },
7442 { "(bad)", { XX } },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7448 { "(bad)", { XX } },
7449 { "(bad)", { XX } },
7450 { "(bad)", { XX } },
7451 { "(bad)", { XX } },
7452 { "(bad)", { XX } },
7453 { "(bad)", { XX } },
7454 { "(bad)", { XX } },
7455 { "(bad)", { XX } },
7457 { "(bad)", { XX } },
7458 { "(bad)", { XX } },
7459 { "(bad)", { XX } },
7460 { "(bad)", { XX } },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7466 { "(bad)", { XX } },
7467 { "(bad)", { XX } },
7468 { "(bad)", { XX } },
7469 { "(bad)", { XX } },
7470 { "(bad)", { XX } },
7471 { "(bad)", { XX } },
7472 { "(bad)", { XX } },
7473 { "(bad)", { XX } },
7475 { "(bad)", { XX } },
7476 { "(bad)", { XX } },
7477 { "(bad)", { XX } },
7478 { "(bad)", { XX } },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7485 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7487 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { "(bad)", { XX } },
7491 { "(bad)", { XX } },
7493 { "(bad)", { XX } },
7494 { "(bad)", { XX } },
7495 { "(bad)", { XX } },
7496 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7503 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7505 { "(bad)", { XX } },
7506 { "(bad)", { XX } },
7507 { "(bad)", { XX } },
7508 { "(bad)", { XX } },
7509 { "(bad)", { XX } },
7511 { "(bad)", { XX } },
7512 { "(bad)", { XX } },
7513 { "(bad)", { XX } },
7514 { "(bad)", { XX } },
7515 { "(bad)", { XX } },
7516 { "(bad)", { XX } },
7517 { "(bad)", { XX } },
7518 { "(bad)", { XX } },
7522 static const struct dis386 vex_table[][256] = {
7526 { "(bad)", { XX } },
7527 { "(bad)", { XX } },
7528 { "(bad)", { XX } },
7529 { "(bad)", { XX } },
7530 { "(bad)", { XX } },
7531 { "(bad)", { XX } },
7532 { "(bad)", { XX } },
7533 { "(bad)", { XX } },
7535 { "(bad)", { XX } },
7536 { "(bad)", { XX } },
7537 { "(bad)", { XX } },
7538 { "(bad)", { XX } },
7539 { "(bad)", { XX } },
7540 { "(bad)", { XX } },
7541 { "(bad)", { XX } },
7542 { "(bad)", { XX } },
7544 { PREFIX_TABLE (PREFIX_VEX_10) },
7545 { PREFIX_TABLE (PREFIX_VEX_11) },
7546 { PREFIX_TABLE (PREFIX_VEX_12) },
7547 { MOD_TABLE (MOD_VEX_13) },
7548 { VEX_W_TABLE (VEX_W_14) },
7549 { VEX_W_TABLE (VEX_W_15) },
7550 { PREFIX_TABLE (PREFIX_VEX_16) },
7551 { MOD_TABLE (MOD_VEX_17) },
7553 { "(bad)", { XX } },
7554 { "(bad)", { XX } },
7555 { "(bad)", { XX } },
7556 { "(bad)", { XX } },
7557 { "(bad)", { XX } },
7558 { "(bad)", { XX } },
7559 { "(bad)", { XX } },
7560 { "(bad)", { XX } },
7562 { "(bad)", { XX } },
7563 { "(bad)", { XX } },
7564 { "(bad)", { XX } },
7565 { "(bad)", { XX } },
7566 { "(bad)", { XX } },
7567 { "(bad)", { XX } },
7568 { "(bad)", { XX } },
7569 { "(bad)", { XX } },
7571 { VEX_W_TABLE (VEX_W_28) },
7572 { VEX_W_TABLE (VEX_W_29) },
7573 { PREFIX_TABLE (PREFIX_VEX_2A) },
7574 { MOD_TABLE (MOD_VEX_2B) },
7575 { PREFIX_TABLE (PREFIX_VEX_2C) },
7576 { PREFIX_TABLE (PREFIX_VEX_2D) },
7577 { PREFIX_TABLE (PREFIX_VEX_2E) },
7578 { PREFIX_TABLE (PREFIX_VEX_2F) },
7580 { "(bad)", { XX } },
7581 { "(bad)", { XX } },
7582 { "(bad)", { XX } },
7583 { "(bad)", { XX } },
7584 { "(bad)", { XX } },
7585 { "(bad)", { XX } },
7586 { "(bad)", { XX } },
7587 { "(bad)", { XX } },
7589 { "(bad)", { XX } },
7590 { "(bad)", { XX } },
7591 { "(bad)", { XX } },
7592 { "(bad)", { XX } },
7593 { "(bad)", { XX } },
7594 { "(bad)", { XX } },
7595 { "(bad)", { XX } },
7596 { "(bad)", { XX } },
7598 { "(bad)", { XX } },
7599 { "(bad)", { XX } },
7600 { "(bad)", { XX } },
7601 { "(bad)", { XX } },
7602 { "(bad)", { XX } },
7603 { "(bad)", { XX } },
7604 { "(bad)", { XX } },
7605 { "(bad)", { XX } },
7607 { "(bad)", { XX } },
7608 { "(bad)", { XX } },
7609 { "(bad)", { XX } },
7610 { "(bad)", { XX } },
7611 { "(bad)", { XX } },
7612 { "(bad)", { XX } },
7613 { "(bad)", { XX } },
7614 { "(bad)", { XX } },
7616 { MOD_TABLE (MOD_VEX_50) },
7617 { PREFIX_TABLE (PREFIX_VEX_51) },
7618 { PREFIX_TABLE (PREFIX_VEX_52) },
7619 { PREFIX_TABLE (PREFIX_VEX_53) },
7620 { "vandpX", { XM, Vex, EXx } },
7621 { "vandnpX", { XM, Vex, EXx } },
7622 { "vorpX", { XM, Vex, EXx } },
7623 { "vxorpX", { XM, Vex, EXx } },
7625 { PREFIX_TABLE (PREFIX_VEX_58) },
7626 { PREFIX_TABLE (PREFIX_VEX_59) },
7627 { PREFIX_TABLE (PREFIX_VEX_5A) },
7628 { PREFIX_TABLE (PREFIX_VEX_5B) },
7629 { PREFIX_TABLE (PREFIX_VEX_5C) },
7630 { PREFIX_TABLE (PREFIX_VEX_5D) },
7631 { PREFIX_TABLE (PREFIX_VEX_5E) },
7632 { PREFIX_TABLE (PREFIX_VEX_5F) },
7634 { PREFIX_TABLE (PREFIX_VEX_60) },
7635 { PREFIX_TABLE (PREFIX_VEX_61) },
7636 { PREFIX_TABLE (PREFIX_VEX_62) },
7637 { PREFIX_TABLE (PREFIX_VEX_63) },
7638 { PREFIX_TABLE (PREFIX_VEX_64) },
7639 { PREFIX_TABLE (PREFIX_VEX_65) },
7640 { PREFIX_TABLE (PREFIX_VEX_66) },
7641 { PREFIX_TABLE (PREFIX_VEX_67) },
7643 { PREFIX_TABLE (PREFIX_VEX_68) },
7644 { PREFIX_TABLE (PREFIX_VEX_69) },
7645 { PREFIX_TABLE (PREFIX_VEX_6A) },
7646 { PREFIX_TABLE (PREFIX_VEX_6B) },
7647 { PREFIX_TABLE (PREFIX_VEX_6C) },
7648 { PREFIX_TABLE (PREFIX_VEX_6D) },
7649 { PREFIX_TABLE (PREFIX_VEX_6E) },
7650 { PREFIX_TABLE (PREFIX_VEX_6F) },
7652 { PREFIX_TABLE (PREFIX_VEX_70) },
7653 { REG_TABLE (REG_VEX_71) },
7654 { REG_TABLE (REG_VEX_72) },
7655 { REG_TABLE (REG_VEX_73) },
7656 { PREFIX_TABLE (PREFIX_VEX_74) },
7657 { PREFIX_TABLE (PREFIX_VEX_75) },
7658 { PREFIX_TABLE (PREFIX_VEX_76) },
7659 { PREFIX_TABLE (PREFIX_VEX_77) },
7661 { "(bad)", { XX } },
7662 { "(bad)", { XX } },
7663 { "(bad)", { XX } },
7664 { "(bad)", { XX } },
7665 { PREFIX_TABLE (PREFIX_VEX_7C) },
7666 { PREFIX_TABLE (PREFIX_VEX_7D) },
7667 { PREFIX_TABLE (PREFIX_VEX_7E) },
7668 { PREFIX_TABLE (PREFIX_VEX_7F) },
7670 { "(bad)", { XX } },
7671 { "(bad)", { XX } },
7672 { "(bad)", { XX } },
7673 { "(bad)", { XX } },
7674 { "(bad)", { XX } },
7675 { "(bad)", { XX } },
7676 { "(bad)", { XX } },
7677 { "(bad)", { XX } },
7679 { "(bad)", { XX } },
7680 { "(bad)", { XX } },
7681 { "(bad)", { XX } },
7682 { "(bad)", { XX } },
7683 { "(bad)", { XX } },
7684 { "(bad)", { XX } },
7685 { "(bad)", { XX } },
7686 { "(bad)", { XX } },
7688 { "(bad)", { XX } },
7689 { "(bad)", { XX } },
7690 { "(bad)", { XX } },
7691 { "(bad)", { XX } },
7692 { "(bad)", { XX } },
7693 { "(bad)", { XX } },
7694 { "(bad)", { XX } },
7695 { "(bad)", { XX } },
7697 { "(bad)", { XX } },
7698 { "(bad)", { XX } },
7699 { "(bad)", { XX } },
7700 { "(bad)", { XX } },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7704 { "(bad)", { XX } },
7706 { "(bad)", { XX } },
7707 { "(bad)", { XX } },
7708 { "(bad)", { XX } },
7709 { "(bad)", { XX } },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7713 { "(bad)", { XX } },
7715 { "(bad)", { XX } },
7716 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7718 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { REG_TABLE (REG_VEX_AE) },
7722 { "(bad)", { XX } },
7724 { "(bad)", { XX } },
7725 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7727 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7731 { "(bad)", { XX } },
7733 { "(bad)", { XX } },
7734 { "(bad)", { XX } },
7735 { "(bad)", { XX } },
7736 { "(bad)", { XX } },
7737 { "(bad)", { XX } },
7738 { "(bad)", { XX } },
7739 { "(bad)", { XX } },
7740 { "(bad)", { XX } },
7742 { "(bad)", { XX } },
7743 { "(bad)", { XX } },
7744 { PREFIX_TABLE (PREFIX_VEX_C2) },
7745 { "(bad)", { XX } },
7746 { PREFIX_TABLE (PREFIX_VEX_C4) },
7747 { PREFIX_TABLE (PREFIX_VEX_C5) },
7748 { "vshufpX", { XM, Vex, EXx, Ib } },
7749 { "(bad)", { XX } },
7751 { "(bad)", { XX } },
7752 { "(bad)", { XX } },
7753 { "(bad)", { XX } },
7754 { "(bad)", { XX } },
7755 { "(bad)", { XX } },
7756 { "(bad)", { XX } },
7757 { "(bad)", { XX } },
7758 { "(bad)", { XX } },
7760 { PREFIX_TABLE (PREFIX_VEX_D0) },
7761 { PREFIX_TABLE (PREFIX_VEX_D1) },
7762 { PREFIX_TABLE (PREFIX_VEX_D2) },
7763 { PREFIX_TABLE (PREFIX_VEX_D3) },
7764 { PREFIX_TABLE (PREFIX_VEX_D4) },
7765 { PREFIX_TABLE (PREFIX_VEX_D5) },
7766 { PREFIX_TABLE (PREFIX_VEX_D6) },
7767 { PREFIX_TABLE (PREFIX_VEX_D7) },
7769 { PREFIX_TABLE (PREFIX_VEX_D8) },
7770 { PREFIX_TABLE (PREFIX_VEX_D9) },
7771 { PREFIX_TABLE (PREFIX_VEX_DA) },
7772 { PREFIX_TABLE (PREFIX_VEX_DB) },
7773 { PREFIX_TABLE (PREFIX_VEX_DC) },
7774 { PREFIX_TABLE (PREFIX_VEX_DD) },
7775 { PREFIX_TABLE (PREFIX_VEX_DE) },
7776 { PREFIX_TABLE (PREFIX_VEX_DF) },
7778 { PREFIX_TABLE (PREFIX_VEX_E0) },
7779 { PREFIX_TABLE (PREFIX_VEX_E1) },
7780 { PREFIX_TABLE (PREFIX_VEX_E2) },
7781 { PREFIX_TABLE (PREFIX_VEX_E3) },
7782 { PREFIX_TABLE (PREFIX_VEX_E4) },
7783 { PREFIX_TABLE (PREFIX_VEX_E5) },
7784 { PREFIX_TABLE (PREFIX_VEX_E6) },
7785 { PREFIX_TABLE (PREFIX_VEX_E7) },
7787 { PREFIX_TABLE (PREFIX_VEX_E8) },
7788 { PREFIX_TABLE (PREFIX_VEX_E9) },
7789 { PREFIX_TABLE (PREFIX_VEX_EA) },
7790 { PREFIX_TABLE (PREFIX_VEX_EB) },
7791 { PREFIX_TABLE (PREFIX_VEX_EC) },
7792 { PREFIX_TABLE (PREFIX_VEX_ED) },
7793 { PREFIX_TABLE (PREFIX_VEX_EE) },
7794 { PREFIX_TABLE (PREFIX_VEX_EF) },
7796 { PREFIX_TABLE (PREFIX_VEX_F0) },
7797 { PREFIX_TABLE (PREFIX_VEX_F1) },
7798 { PREFIX_TABLE (PREFIX_VEX_F2) },
7799 { PREFIX_TABLE (PREFIX_VEX_F3) },
7800 { PREFIX_TABLE (PREFIX_VEX_F4) },
7801 { PREFIX_TABLE (PREFIX_VEX_F5) },
7802 { PREFIX_TABLE (PREFIX_VEX_F6) },
7803 { PREFIX_TABLE (PREFIX_VEX_F7) },
7805 { PREFIX_TABLE (PREFIX_VEX_F8) },
7806 { PREFIX_TABLE (PREFIX_VEX_F9) },
7807 { PREFIX_TABLE (PREFIX_VEX_FA) },
7808 { PREFIX_TABLE (PREFIX_VEX_FB) },
7809 { PREFIX_TABLE (PREFIX_VEX_FC) },
7810 { PREFIX_TABLE (PREFIX_VEX_FD) },
7811 { PREFIX_TABLE (PREFIX_VEX_FE) },
7812 { "(bad)", { XX } },
7817 { PREFIX_TABLE (PREFIX_VEX_3800) },
7818 { PREFIX_TABLE (PREFIX_VEX_3801) },
7819 { PREFIX_TABLE (PREFIX_VEX_3802) },
7820 { PREFIX_TABLE (PREFIX_VEX_3803) },
7821 { PREFIX_TABLE (PREFIX_VEX_3804) },
7822 { PREFIX_TABLE (PREFIX_VEX_3805) },
7823 { PREFIX_TABLE (PREFIX_VEX_3806) },
7824 { PREFIX_TABLE (PREFIX_VEX_3807) },
7826 { PREFIX_TABLE (PREFIX_VEX_3808) },
7827 { PREFIX_TABLE (PREFIX_VEX_3809) },
7828 { PREFIX_TABLE (PREFIX_VEX_380A) },
7829 { PREFIX_TABLE (PREFIX_VEX_380B) },
7830 { PREFIX_TABLE (PREFIX_VEX_380C) },
7831 { PREFIX_TABLE (PREFIX_VEX_380D) },
7832 { PREFIX_TABLE (PREFIX_VEX_380E) },
7833 { PREFIX_TABLE (PREFIX_VEX_380F) },
7835 { "(bad)", { XX } },
7836 { "(bad)", { XX } },
7837 { "(bad)", { XX } },
7838 { "(bad)", { XX } },
7839 { "(bad)", { XX } },
7840 { "(bad)", { XX } },
7841 { "(bad)", { XX } },
7842 { PREFIX_TABLE (PREFIX_VEX_3817) },
7844 { PREFIX_TABLE (PREFIX_VEX_3818) },
7845 { PREFIX_TABLE (PREFIX_VEX_3819) },
7846 { PREFIX_TABLE (PREFIX_VEX_381A) },
7847 { "(bad)", { XX } },
7848 { PREFIX_TABLE (PREFIX_VEX_381C) },
7849 { PREFIX_TABLE (PREFIX_VEX_381D) },
7850 { PREFIX_TABLE (PREFIX_VEX_381E) },
7851 { "(bad)", { XX } },
7853 { PREFIX_TABLE (PREFIX_VEX_3820) },
7854 { PREFIX_TABLE (PREFIX_VEX_3821) },
7855 { PREFIX_TABLE (PREFIX_VEX_3822) },
7856 { PREFIX_TABLE (PREFIX_VEX_3823) },
7857 { PREFIX_TABLE (PREFIX_VEX_3824) },
7858 { PREFIX_TABLE (PREFIX_VEX_3825) },
7859 { "(bad)", { XX } },
7860 { "(bad)", { XX } },
7862 { PREFIX_TABLE (PREFIX_VEX_3828) },
7863 { PREFIX_TABLE (PREFIX_VEX_3829) },
7864 { PREFIX_TABLE (PREFIX_VEX_382A) },
7865 { PREFIX_TABLE (PREFIX_VEX_382B) },
7866 { PREFIX_TABLE (PREFIX_VEX_382C) },
7867 { PREFIX_TABLE (PREFIX_VEX_382D) },
7868 { PREFIX_TABLE (PREFIX_VEX_382E) },
7869 { PREFIX_TABLE (PREFIX_VEX_382F) },
7871 { PREFIX_TABLE (PREFIX_VEX_3830) },
7872 { PREFIX_TABLE (PREFIX_VEX_3831) },
7873 { PREFIX_TABLE (PREFIX_VEX_3832) },
7874 { PREFIX_TABLE (PREFIX_VEX_3833) },
7875 { PREFIX_TABLE (PREFIX_VEX_3834) },
7876 { PREFIX_TABLE (PREFIX_VEX_3835) },
7877 { "(bad)", { XX } },
7878 { PREFIX_TABLE (PREFIX_VEX_3837) },
7880 { PREFIX_TABLE (PREFIX_VEX_3838) },
7881 { PREFIX_TABLE (PREFIX_VEX_3839) },
7882 { PREFIX_TABLE (PREFIX_VEX_383A) },
7883 { PREFIX_TABLE (PREFIX_VEX_383B) },
7884 { PREFIX_TABLE (PREFIX_VEX_383C) },
7885 { PREFIX_TABLE (PREFIX_VEX_383D) },
7886 { PREFIX_TABLE (PREFIX_VEX_383E) },
7887 { PREFIX_TABLE (PREFIX_VEX_383F) },
7889 { PREFIX_TABLE (PREFIX_VEX_3840) },
7890 { PREFIX_TABLE (PREFIX_VEX_3841) },
7891 { "(bad)", { XX } },
7892 { "(bad)", { XX } },
7893 { "(bad)", { XX } },
7894 { "(bad)", { XX } },
7895 { "(bad)", { XX } },
7896 { "(bad)", { XX } },
7898 { "(bad)", { XX } },
7899 { "(bad)", { XX } },
7900 { "(bad)", { XX } },
7901 { "(bad)", { XX } },
7902 { "(bad)", { XX } },
7903 { "(bad)", { XX } },
7904 { "(bad)", { XX } },
7905 { "(bad)", { XX } },
7907 { "(bad)", { XX } },
7908 { "(bad)", { XX } },
7909 { "(bad)", { XX } },
7910 { "(bad)", { XX } },
7911 { "(bad)", { XX } },
7912 { "(bad)", { XX } },
7913 { "(bad)", { XX } },
7914 { "(bad)", { XX } },
7916 { "(bad)", { XX } },
7917 { "(bad)", { XX } },
7918 { "(bad)", { XX } },
7919 { "(bad)", { XX } },
7920 { "(bad)", { XX } },
7921 { "(bad)", { XX } },
7922 { "(bad)", { XX } },
7923 { "(bad)", { XX } },
7925 { "(bad)", { XX } },
7926 { "(bad)", { XX } },
7927 { "(bad)", { XX } },
7928 { "(bad)", { XX } },
7929 { "(bad)", { XX } },
7930 { "(bad)", { XX } },
7931 { "(bad)", { XX } },
7932 { "(bad)", { XX } },
7934 { "(bad)", { XX } },
7935 { "(bad)", { XX } },
7936 { "(bad)", { XX } },
7937 { "(bad)", { XX } },
7938 { "(bad)", { XX } },
7939 { "(bad)", { XX } },
7940 { "(bad)", { XX } },
7941 { "(bad)", { XX } },
7943 { "(bad)", { XX } },
7944 { "(bad)", { XX } },
7945 { "(bad)", { XX } },
7946 { "(bad)", { XX } },
7947 { "(bad)", { XX } },
7948 { "(bad)", { XX } },
7949 { "(bad)", { XX } },
7950 { "(bad)", { XX } },
7952 { "(bad)", { XX } },
7953 { "(bad)", { XX } },
7954 { "(bad)", { XX } },
7955 { "(bad)", { XX } },
7956 { "(bad)", { XX } },
7957 { "(bad)", { XX } },
7958 { "(bad)", { XX } },
7959 { "(bad)", { XX } },
7961 { "(bad)", { XX } },
7962 { "(bad)", { XX } },
7963 { "(bad)", { XX } },
7964 { "(bad)", { XX } },
7965 { "(bad)", { XX } },
7966 { "(bad)", { XX } },
7967 { "(bad)", { XX } },
7968 { "(bad)", { XX } },
7970 { "(bad)", { XX } },
7971 { "(bad)", { XX } },
7972 { "(bad)", { XX } },
7973 { "(bad)", { XX } },
7974 { "(bad)", { XX } },
7975 { "(bad)", { XX } },
7976 { "(bad)", { XX } },
7977 { "(bad)", { XX } },
7979 { "(bad)", { XX } },
7980 { "(bad)", { XX } },
7981 { "(bad)", { XX } },
7982 { "(bad)", { XX } },
7983 { "(bad)", { XX } },
7984 { "(bad)", { XX } },
7985 { PREFIX_TABLE (PREFIX_VEX_3896) },
7986 { PREFIX_TABLE (PREFIX_VEX_3897) },
7988 { PREFIX_TABLE (PREFIX_VEX_3898) },
7989 { PREFIX_TABLE (PREFIX_VEX_3899) },
7990 { PREFIX_TABLE (PREFIX_VEX_389A) },
7991 { PREFIX_TABLE (PREFIX_VEX_389B) },
7992 { PREFIX_TABLE (PREFIX_VEX_389C) },
7993 { PREFIX_TABLE (PREFIX_VEX_389D) },
7994 { PREFIX_TABLE (PREFIX_VEX_389E) },
7995 { PREFIX_TABLE (PREFIX_VEX_389F) },
7997 { "(bad)", { XX } },
7998 { "(bad)", { XX } },
7999 { "(bad)", { XX } },
8000 { "(bad)", { XX } },
8001 { "(bad)", { XX } },
8002 { "(bad)", { XX } },
8003 { PREFIX_TABLE (PREFIX_VEX_38A6) },
8004 { PREFIX_TABLE (PREFIX_VEX_38A7) },
8006 { PREFIX_TABLE (PREFIX_VEX_38A8) },
8007 { PREFIX_TABLE (PREFIX_VEX_38A9) },
8008 { PREFIX_TABLE (PREFIX_VEX_38AA) },
8009 { PREFIX_TABLE (PREFIX_VEX_38AB) },
8010 { PREFIX_TABLE (PREFIX_VEX_38AC) },
8011 { PREFIX_TABLE (PREFIX_VEX_38AD) },
8012 { PREFIX_TABLE (PREFIX_VEX_38AE) },
8013 { PREFIX_TABLE (PREFIX_VEX_38AF) },
8015 { "(bad)", { XX } },
8016 { "(bad)", { XX } },
8017 { "(bad)", { XX } },
8018 { "(bad)", { XX } },
8019 { "(bad)", { XX } },
8020 { "(bad)", { XX } },
8021 { PREFIX_TABLE (PREFIX_VEX_38B6) },
8022 { PREFIX_TABLE (PREFIX_VEX_38B7) },
8024 { PREFIX_TABLE (PREFIX_VEX_38B8) },
8025 { PREFIX_TABLE (PREFIX_VEX_38B9) },
8026 { PREFIX_TABLE (PREFIX_VEX_38BA) },
8027 { PREFIX_TABLE (PREFIX_VEX_38BB) },
8028 { PREFIX_TABLE (PREFIX_VEX_38BC) },
8029 { PREFIX_TABLE (PREFIX_VEX_38BD) },
8030 { PREFIX_TABLE (PREFIX_VEX_38BE) },
8031 { PREFIX_TABLE (PREFIX_VEX_38BF) },
8033 { "(bad)", { XX } },
8034 { "(bad)", { XX } },
8035 { "(bad)", { XX } },
8036 { "(bad)", { XX } },
8037 { "(bad)", { XX } },
8038 { "(bad)", { XX } },
8039 { "(bad)", { XX } },
8040 { "(bad)", { XX } },
8042 { "(bad)", { XX } },
8043 { "(bad)", { XX } },
8044 { "(bad)", { XX } },
8045 { "(bad)", { XX } },
8046 { "(bad)", { XX } },
8047 { "(bad)", { XX } },
8048 { "(bad)", { XX } },
8049 { "(bad)", { XX } },
8051 { "(bad)", { XX } },
8052 { "(bad)", { XX } },
8053 { "(bad)", { XX } },
8054 { "(bad)", { XX } },
8055 { "(bad)", { XX } },
8056 { "(bad)", { XX } },
8057 { "(bad)", { XX } },
8058 { "(bad)", { XX } },
8060 { "(bad)", { XX } },
8061 { "(bad)", { XX } },
8062 { "(bad)", { XX } },
8063 { PREFIX_TABLE (PREFIX_VEX_38DB) },
8064 { PREFIX_TABLE (PREFIX_VEX_38DC) },
8065 { PREFIX_TABLE (PREFIX_VEX_38DD) },
8066 { PREFIX_TABLE (PREFIX_VEX_38DE) },
8067 { PREFIX_TABLE (PREFIX_VEX_38DF) },
8069 { "(bad)", { XX } },
8070 { "(bad)", { XX } },
8071 { "(bad)", { XX } },
8072 { "(bad)", { XX } },
8073 { "(bad)", { XX } },
8074 { "(bad)", { XX } },
8075 { "(bad)", { XX } },
8076 { "(bad)", { XX } },
8078 { "(bad)", { XX } },
8079 { "(bad)", { XX } },
8080 { "(bad)", { XX } },
8081 { "(bad)", { XX } },
8082 { "(bad)", { XX } },
8083 { "(bad)", { XX } },
8084 { "(bad)", { XX } },
8085 { "(bad)", { XX } },
8087 { "(bad)", { XX } },
8088 { "(bad)", { XX } },
8089 { "(bad)", { XX } },
8090 { "(bad)", { XX } },
8091 { "(bad)", { XX } },
8092 { "(bad)", { XX } },
8093 { "(bad)", { XX } },
8094 { "(bad)", { XX } },
8096 { "(bad)", { XX } },
8097 { "(bad)", { XX } },
8098 { "(bad)", { XX } },
8099 { "(bad)", { XX } },
8100 { "(bad)", { XX } },
8101 { "(bad)", { XX } },
8102 { "(bad)", { XX } },
8103 { "(bad)", { XX } },
8108 { "(bad)", { XX } },
8109 { "(bad)", { XX } },
8110 { "(bad)", { XX } },
8111 { "(bad)", { XX } },
8112 { PREFIX_TABLE (PREFIX_VEX_3A04) },
8113 { PREFIX_TABLE (PREFIX_VEX_3A05) },
8114 { PREFIX_TABLE (PREFIX_VEX_3A06) },
8115 { "(bad)", { XX } },
8117 { PREFIX_TABLE (PREFIX_VEX_3A08) },
8118 { PREFIX_TABLE (PREFIX_VEX_3A09) },
8119 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
8120 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
8121 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
8122 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
8123 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
8124 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
8126 { "(bad)", { XX } },
8127 { "(bad)", { XX } },
8128 { "(bad)", { XX } },
8129 { "(bad)", { XX } },
8130 { PREFIX_TABLE (PREFIX_VEX_3A14) },
8131 { PREFIX_TABLE (PREFIX_VEX_3A15) },
8132 { PREFIX_TABLE (PREFIX_VEX_3A16) },
8133 { PREFIX_TABLE (PREFIX_VEX_3A17) },
8135 { PREFIX_TABLE (PREFIX_VEX_3A18) },
8136 { PREFIX_TABLE (PREFIX_VEX_3A19) },
8137 { "(bad)", { XX } },
8138 { "(bad)", { XX } },
8139 { "(bad)", { XX } },
8140 { "(bad)", { XX } },
8141 { "(bad)", { XX } },
8142 { "(bad)", { XX } },
8144 { PREFIX_TABLE (PREFIX_VEX_3A20) },
8145 { PREFIX_TABLE (PREFIX_VEX_3A21) },
8146 { PREFIX_TABLE (PREFIX_VEX_3A22) },
8147 { "(bad)", { XX } },
8148 { "(bad)", { XX } },
8149 { "(bad)", { XX } },
8150 { "(bad)", { XX } },
8151 { "(bad)", { XX } },
8153 { "(bad)", { XX } },
8154 { "(bad)", { XX } },
8155 { "(bad)", { XX } },
8156 { "(bad)", { XX } },
8157 { "(bad)", { XX } },
8158 { "(bad)", { XX } },
8159 { "(bad)", { XX } },
8160 { "(bad)", { XX } },
8162 { "(bad)", { XX } },
8163 { "(bad)", { XX } },
8164 { "(bad)", { XX } },
8165 { "(bad)", { XX } },
8166 { "(bad)", { XX } },
8167 { "(bad)", { XX } },
8168 { "(bad)", { XX } },
8169 { "(bad)", { XX } },
8171 { "(bad)", { XX } },
8172 { "(bad)", { XX } },
8173 { "(bad)", { XX } },
8174 { "(bad)", { XX } },
8175 { "(bad)", { XX } },
8176 { "(bad)", { XX } },
8177 { "(bad)", { XX } },
8178 { "(bad)", { XX } },
8180 { PREFIX_TABLE (PREFIX_VEX_3A40) },
8181 { PREFIX_TABLE (PREFIX_VEX_3A41) },
8182 { PREFIX_TABLE (PREFIX_VEX_3A42) },
8183 { "(bad)", { XX } },
8184 { PREFIX_TABLE (PREFIX_VEX_3A44) },
8185 { "(bad)", { XX } },
8186 { "(bad)", { XX } },
8187 { "(bad)", { XX } },
8189 { "(bad)", { XX } },
8190 { "(bad)", { XX } },
8191 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
8192 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
8193 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
8194 { "(bad)", { XX } },
8195 { "(bad)", { XX } },
8196 { "(bad)", { XX } },
8198 { "(bad)", { XX } },
8199 { "(bad)", { XX } },
8200 { "(bad)", { XX } },
8201 { "(bad)", { XX } },
8202 { "(bad)", { XX } },
8203 { "(bad)", { XX } },
8204 { "(bad)", { XX } },
8205 { "(bad)", { XX } },
8207 { "(bad)", { XX } },
8208 { "(bad)", { XX } },
8209 { "(bad)", { XX } },
8210 { "(bad)", { XX } },
8211 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
8212 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
8213 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
8214 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
8216 { PREFIX_TABLE (PREFIX_VEX_3A60) },
8217 { PREFIX_TABLE (PREFIX_VEX_3A61) },
8218 { PREFIX_TABLE (PREFIX_VEX_3A62) },
8219 { PREFIX_TABLE (PREFIX_VEX_3A63) },
8220 { "(bad)", { XX } },
8221 { "(bad)", { XX } },
8222 { "(bad)", { XX } },
8223 { "(bad)", { XX } },
8225 { PREFIX_TABLE (PREFIX_VEX_3A68) },
8226 { PREFIX_TABLE (PREFIX_VEX_3A69) },
8227 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
8228 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
8229 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
8230 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
8231 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
8232 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
8234 { "(bad)", { XX } },
8235 { "(bad)", { XX } },
8236 { "(bad)", { XX } },
8237 { "(bad)", { XX } },
8238 { "(bad)", { XX } },
8239 { "(bad)", { XX } },
8240 { "(bad)", { XX } },
8241 { "(bad)", { XX } },
8243 { PREFIX_TABLE (PREFIX_VEX_3A78) },
8244 { PREFIX_TABLE (PREFIX_VEX_3A79) },
8245 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
8246 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
8247 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
8248 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
8249 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
8250 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
8252 { "(bad)", { XX } },
8253 { "(bad)", { XX } },
8254 { "(bad)", { XX } },
8255 { "(bad)", { XX } },
8256 { "(bad)", { XX } },
8257 { "(bad)", { XX } },
8258 { "(bad)", { XX } },
8259 { "(bad)", { XX } },
8261 { "(bad)", { XX } },
8262 { "(bad)", { XX } },
8263 { "(bad)", { XX } },
8264 { "(bad)", { XX } },
8265 { "(bad)", { XX } },
8266 { "(bad)", { XX } },
8267 { "(bad)", { XX } },
8268 { "(bad)", { XX } },
8270 { "(bad)", { XX } },
8271 { "(bad)", { XX } },
8272 { "(bad)", { XX } },
8273 { "(bad)", { XX } },
8274 { "(bad)", { XX } },
8275 { "(bad)", { XX } },
8276 { "(bad)", { XX } },
8277 { "(bad)", { XX } },
8279 { "(bad)", { XX } },
8280 { "(bad)", { XX } },
8281 { "(bad)", { XX } },
8282 { "(bad)", { XX } },
8283 { "(bad)", { XX } },
8284 { "(bad)", { XX } },
8285 { "(bad)", { XX } },
8286 { "(bad)", { XX } },
8288 { "(bad)", { XX } },
8289 { "(bad)", { XX } },
8290 { "(bad)", { XX } },
8291 { "(bad)", { XX } },
8292 { "(bad)", { XX } },
8293 { "(bad)", { XX } },
8294 { "(bad)", { XX } },
8295 { "(bad)", { XX } },
8297 { "(bad)", { XX } },
8298 { "(bad)", { XX } },
8299 { "(bad)", { XX } },
8300 { "(bad)", { XX } },
8301 { "(bad)", { XX } },
8302 { "(bad)", { XX } },
8303 { "(bad)", { XX } },
8304 { "(bad)", { XX } },
8306 { "(bad)", { XX } },
8307 { "(bad)", { XX } },
8308 { "(bad)", { XX } },
8309 { "(bad)", { XX } },
8310 { "(bad)", { XX } },
8311 { "(bad)", { XX } },
8312 { "(bad)", { XX } },
8313 { "(bad)", { XX } },
8315 { "(bad)", { XX } },
8316 { "(bad)", { XX } },
8317 { "(bad)", { XX } },
8318 { "(bad)", { XX } },
8319 { "(bad)", { XX } },
8320 { "(bad)", { XX } },
8321 { "(bad)", { XX } },
8322 { "(bad)", { XX } },
8324 { "(bad)", { XX } },
8325 { "(bad)", { XX } },
8326 { "(bad)", { XX } },
8327 { "(bad)", { XX } },
8328 { "(bad)", { XX } },
8329 { "(bad)", { XX } },
8330 { "(bad)", { XX } },
8331 { "(bad)", { XX } },
8333 { "(bad)", { XX } },
8334 { "(bad)", { XX } },
8335 { "(bad)", { XX } },
8336 { "(bad)", { XX } },
8337 { "(bad)", { XX } },
8338 { "(bad)", { XX } },
8339 { "(bad)", { XX } },
8340 { "(bad)", { XX } },
8342 { "(bad)", { XX } },
8343 { "(bad)", { XX } },
8344 { "(bad)", { XX } },
8345 { "(bad)", { XX } },
8346 { "(bad)", { XX } },
8347 { "(bad)", { XX } },
8348 { "(bad)", { XX } },
8349 { "(bad)", { XX } },
8351 { "(bad)", { XX } },
8352 { "(bad)", { XX } },
8353 { "(bad)", { XX } },
8354 { "(bad)", { XX } },
8355 { "(bad)", { XX } },
8356 { "(bad)", { XX } },
8357 { "(bad)", { XX } },
8358 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
8360 { "(bad)", { XX } },
8361 { "(bad)", { XX } },
8362 { "(bad)", { XX } },
8363 { "(bad)", { XX } },
8364 { "(bad)", { XX } },
8365 { "(bad)", { XX } },
8366 { "(bad)", { XX } },
8367 { "(bad)", { XX } },
8369 { "(bad)", { XX } },
8370 { "(bad)", { XX } },
8371 { "(bad)", { XX } },
8372 { "(bad)", { XX } },
8373 { "(bad)", { XX } },
8374 { "(bad)", { XX } },
8375 { "(bad)", { XX } },
8376 { "(bad)", { XX } },
8378 { "(bad)", { XX } },
8379 { "(bad)", { XX } },
8380 { "(bad)", { XX } },
8381 { "(bad)", { XX } },
8382 { "(bad)", { XX } },
8383 { "(bad)", { XX } },
8384 { "(bad)", { XX } },
8385 { "(bad)", { XX } },
8387 { "(bad)", { XX } },
8388 { "(bad)", { XX } },
8389 { "(bad)", { XX } },
8390 { "(bad)", { XX } },
8391 { "(bad)", { XX } },
8392 { "(bad)", { XX } },
8393 { "(bad)", { XX } },
8394 { "(bad)", { XX } },
8398 static const struct dis386 vex_len_table[][2] = {
8399 /* VEX_LEN_10_P_1 */
8401 { VEX_W_TABLE (VEX_W_10_P_1) },
8402 { "(bad)", { XX } },
8405 /* VEX_LEN_10_P_3 */
8407 { VEX_W_TABLE (VEX_W_10_P_3) },
8408 { "(bad)", { XX } },
8411 /* VEX_LEN_11_P_1 */
8413 { VEX_W_TABLE (VEX_W_11_P_1) },
8414 { "(bad)", { XX } },
8417 /* VEX_LEN_11_P_3 */
8419 { VEX_W_TABLE (VEX_W_11_P_3) },
8420 { "(bad)", { XX } },
8423 /* VEX_LEN_12_P_0_M_0 */
8425 { VEX_W_TABLE (VEX_W_12_P_0_M_0) },
8426 { "(bad)", { XX } },
8429 /* VEX_LEN_12_P_0_M_1 */
8431 { VEX_W_TABLE (VEX_W_12_P_0_M_1) },
8432 { "(bad)", { XX } },
8435 /* VEX_LEN_12_P_2 */
8437 { VEX_W_TABLE (VEX_W_12_P_2) },
8438 { "(bad)", { XX } },
8441 /* VEX_LEN_13_M_0 */
8443 { VEX_W_TABLE (VEX_W_13_M_0) },
8444 { "(bad)", { XX } },
8447 /* VEX_LEN_16_P_0_M_0 */
8449 { VEX_W_TABLE (VEX_W_16_P_0_M_0) },
8450 { "(bad)", { XX } },
8453 /* VEX_LEN_16_P_0_M_1 */
8455 { VEX_W_TABLE (VEX_W_16_P_0_M_1) },
8456 { "(bad)", { XX } },
8459 /* VEX_LEN_16_P_2 */
8461 { VEX_W_TABLE (VEX_W_16_P_2) },
8462 { "(bad)", { XX } },
8465 /* VEX_LEN_17_M_0 */
8467 { VEX_W_TABLE (VEX_W_17_M_0) },
8468 { "(bad)", { XX } },
8471 /* VEX_LEN_2A_P_1 */
8473 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
8474 { "(bad)", { XX } },
8477 /* VEX_LEN_2A_P_3 */
8479 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
8480 { "(bad)", { XX } },
8483 /* VEX_LEN_2C_P_1 */
8485 { "vcvttss2siY", { Gv, EXd } },
8486 { "(bad)", { XX } },
8489 /* VEX_LEN_2C_P_3 */
8491 { "vcvttsd2siY", { Gv, EXq } },
8492 { "(bad)", { XX } },
8495 /* VEX_LEN_2D_P_1 */
8497 { "vcvtss2siY", { Gv, EXd } },
8498 { "(bad)", { XX } },
8501 /* VEX_LEN_2D_P_3 */
8503 { "vcvtsd2siY", { Gv, EXq } },
8504 { "(bad)", { XX } },
8507 /* VEX_LEN_2E_P_0 */
8509 { VEX_W_TABLE (VEX_W_2E_P_0) },
8510 { "(bad)", { XX } },
8513 /* VEX_LEN_2E_P_2 */
8515 { VEX_W_TABLE (VEX_W_2E_P_2) },
8516 { "(bad)", { XX } },
8519 /* VEX_LEN_2F_P_0 */
8521 { VEX_W_TABLE (VEX_W_2F_P_0) },
8522 { "(bad)", { XX } },
8525 /* VEX_LEN_2F_P_2 */
8527 { VEX_W_TABLE (VEX_W_2F_P_2) },
8528 { "(bad)", { XX } },
8531 /* VEX_LEN_51_P_1 */
8533 { VEX_W_TABLE (VEX_W_51_P_1) },
8534 { "(bad)", { XX } },
8537 /* VEX_LEN_51_P_3 */
8539 { VEX_W_TABLE (VEX_W_51_P_3) },
8540 { "(bad)", { XX } },
8543 /* VEX_LEN_52_P_1 */
8545 { VEX_W_TABLE (VEX_W_52_P_1) },
8546 { "(bad)", { XX } },
8549 /* VEX_LEN_53_P_1 */
8551 { VEX_W_TABLE (VEX_W_53_P_1) },
8552 { "(bad)", { XX } },
8555 /* VEX_LEN_58_P_1 */
8557 { VEX_W_TABLE (VEX_W_58_P_1) },
8558 { "(bad)", { XX } },
8561 /* VEX_LEN_58_P_3 */
8563 { VEX_W_TABLE (VEX_W_58_P_3) },
8564 { "(bad)", { XX } },
8567 /* VEX_LEN_59_P_1 */
8569 { VEX_W_TABLE (VEX_W_59_P_1) },
8570 { "(bad)", { XX } },
8573 /* VEX_LEN_59_P_3 */
8575 { VEX_W_TABLE (VEX_W_59_P_3) },
8576 { "(bad)", { XX } },
8579 /* VEX_LEN_5A_P_1 */
8581 { VEX_W_TABLE (VEX_W_5A_P_1) },
8582 { "(bad)", { XX } },
8585 /* VEX_LEN_5A_P_3 */
8587 { VEX_W_TABLE (VEX_W_5A_P_3) },
8588 { "(bad)", { XX } },
8591 /* VEX_LEN_5C_P_1 */
8593 { VEX_W_TABLE (VEX_W_5C_P_1) },
8594 { "(bad)", { XX } },
8597 /* VEX_LEN_5C_P_3 */
8599 { VEX_W_TABLE (VEX_W_5C_P_3) },
8600 { "(bad)", { XX } },
8603 /* VEX_LEN_5D_P_1 */
8605 { VEX_W_TABLE (VEX_W_5D_P_1) },
8606 { "(bad)", { XX } },
8609 /* VEX_LEN_5D_P_3 */
8611 { VEX_W_TABLE (VEX_W_5D_P_3) },
8612 { "(bad)", { XX } },
8615 /* VEX_LEN_5E_P_1 */
8617 { VEX_W_TABLE (VEX_W_5E_P_1) },
8618 { "(bad)", { XX } },
8621 /* VEX_LEN_5E_P_3 */
8623 { VEX_W_TABLE (VEX_W_5E_P_3) },
8624 { "(bad)", { XX } },
8627 /* VEX_LEN_5F_P_1 */
8629 { VEX_W_TABLE (VEX_W_5F_P_1) },
8630 { "(bad)", { XX } },
8633 /* VEX_LEN_5F_P_3 */
8635 { VEX_W_TABLE (VEX_W_5F_P_3) },
8636 { "(bad)", { XX } },
8639 /* VEX_LEN_60_P_2 */
8641 { VEX_W_TABLE (VEX_W_60_P_2) },
8642 { "(bad)", { XX } },
8645 /* VEX_LEN_61_P_2 */
8647 { VEX_W_TABLE (VEX_W_61_P_2) },
8648 { "(bad)", { XX } },
8651 /* VEX_LEN_62_P_2 */
8653 { VEX_W_TABLE (VEX_W_62_P_2) },
8654 { "(bad)", { XX } },
8657 /* VEX_LEN_63_P_2 */
8659 { VEX_W_TABLE (VEX_W_63_P_2) },
8660 { "(bad)", { XX } },
8663 /* VEX_LEN_64_P_2 */
8665 { VEX_W_TABLE (VEX_W_64_P_2) },
8666 { "(bad)", { XX } },
8669 /* VEX_LEN_65_P_2 */
8671 { VEX_W_TABLE (VEX_W_65_P_2) },
8672 { "(bad)", { XX } },
8675 /* VEX_LEN_66_P_2 */
8677 { VEX_W_TABLE (VEX_W_66_P_2) },
8678 { "(bad)", { XX } },
8681 /* VEX_LEN_67_P_2 */
8683 { VEX_W_TABLE (VEX_W_67_P_2) },
8684 { "(bad)", { XX } },
8687 /* VEX_LEN_68_P_2 */
8689 { VEX_W_TABLE (VEX_W_68_P_2) },
8690 { "(bad)", { XX } },
8693 /* VEX_LEN_69_P_2 */
8695 { VEX_W_TABLE (VEX_W_69_P_2) },
8696 { "(bad)", { XX } },
8699 /* VEX_LEN_6A_P_2 */
8701 { VEX_W_TABLE (VEX_W_6A_P_2) },
8702 { "(bad)", { XX } },
8705 /* VEX_LEN_6B_P_2 */
8707 { VEX_W_TABLE (VEX_W_6B_P_2) },
8708 { "(bad)", { XX } },
8711 /* VEX_LEN_6C_P_2 */
8713 { VEX_W_TABLE (VEX_W_6C_P_2) },
8714 { "(bad)", { XX } },
8717 /* VEX_LEN_6D_P_2 */
8719 { VEX_W_TABLE (VEX_W_6D_P_2) },
8720 { "(bad)", { XX } },
8723 /* VEX_LEN_6E_P_2 */
8725 { "vmovK", { XM, Edq } },
8726 { "(bad)", { XX } },
8729 /* VEX_LEN_70_P_1 */
8731 { VEX_W_TABLE (VEX_W_70_P_1) },
8732 { "(bad)", { XX } },
8735 /* VEX_LEN_70_P_2 */
8737 { VEX_W_TABLE (VEX_W_70_P_2) },
8738 { "(bad)", { XX } },
8741 /* VEX_LEN_70_P_3 */
8743 { VEX_W_TABLE (VEX_W_70_P_3) },
8744 { "(bad)", { XX } },
8747 /* VEX_LEN_71_R_2_P_2 */
8749 { VEX_W_TABLE (VEX_W_71_R_2_P_2) },
8750 { "(bad)", { XX } },
8753 /* VEX_LEN_71_R_4_P_2 */
8755 { VEX_W_TABLE (VEX_W_71_R_4_P_2) },
8756 { "(bad)", { XX } },
8759 /* VEX_LEN_71_R_6_P_2 */
8761 { VEX_W_TABLE (VEX_W_71_R_6_P_2) },
8762 { "(bad)", { XX } },
8765 /* VEX_LEN_72_R_2_P_2 */
8767 { VEX_W_TABLE (VEX_W_72_R_2_P_2) },
8768 { "(bad)", { XX } },
8771 /* VEX_LEN_72_R_4_P_2 */
8773 { VEX_W_TABLE (VEX_W_72_R_4_P_2) },
8774 { "(bad)", { XX } },
8777 /* VEX_LEN_72_R_6_P_2 */
8779 { VEX_W_TABLE (VEX_W_72_R_6_P_2) },
8780 { "(bad)", { XX } },
8783 /* VEX_LEN_73_R_2_P_2 */
8785 { VEX_W_TABLE (VEX_W_73_R_2_P_2) },
8786 { "(bad)", { XX } },
8789 /* VEX_LEN_73_R_3_P_2 */
8791 { VEX_W_TABLE (VEX_W_73_R_3_P_2) },
8792 { "(bad)", { XX } },
8795 /* VEX_LEN_73_R_6_P_2 */
8797 { VEX_W_TABLE (VEX_W_73_R_6_P_2) },
8798 { "(bad)", { XX } },
8801 /* VEX_LEN_73_R_7_P_2 */
8803 { VEX_W_TABLE (VEX_W_73_R_7_P_2) },
8804 { "(bad)", { XX } },
8807 /* VEX_LEN_74_P_2 */
8809 { VEX_W_TABLE (VEX_W_74_P_2) },
8810 { "(bad)", { XX } },
8813 /* VEX_LEN_75_P_2 */
8815 { VEX_W_TABLE (VEX_W_75_P_2) },
8816 { "(bad)", { XX } },
8819 /* VEX_LEN_76_P_2 */
8821 { VEX_W_TABLE (VEX_W_76_P_2) },
8822 { "(bad)", { XX } },
8825 /* VEX_LEN_7E_P_1 */
8827 { VEX_W_TABLE (VEX_W_7E_P_1) },
8828 { "(bad)", { XX } },
8831 /* VEX_LEN_7E_P_2 */
8833 { "vmovK", { Edq, XM } },
8834 { "(bad)", { XX } },
8837 /* VEX_LEN_AE_R_2_M_0 */
8839 { VEX_W_TABLE (VEX_W_AE_R_2_M_0) },
8840 { "(bad)", { XX } },
8843 /* VEX_LEN_AE_R_3_M_0 */
8845 { VEX_W_TABLE (VEX_W_AE_R_3_M_0) },
8846 { "(bad)", { XX } },
8849 /* VEX_LEN_C2_P_1 */
8851 { VEX_W_TABLE (VEX_W_C2_P_1) },
8852 { "(bad)", { XX } },
8855 /* VEX_LEN_C2_P_3 */
8857 { VEX_W_TABLE (VEX_W_C2_P_3) },
8858 { "(bad)", { XX } },
8861 /* VEX_LEN_C4_P_2 */
8863 { VEX_W_TABLE (VEX_W_C4_P_2) },
8864 { "(bad)", { XX } },
8867 /* VEX_LEN_C5_P_2 */
8869 { VEX_W_TABLE (VEX_W_C5_P_2) },
8870 { "(bad)", { XX } },
8873 /* VEX_LEN_D1_P_2 */
8875 { VEX_W_TABLE (VEX_W_D1_P_2) },
8876 { "(bad)", { XX } },
8879 /* VEX_LEN_D2_P_2 */
8881 { VEX_W_TABLE (VEX_W_D2_P_2) },
8882 { "(bad)", { XX } },
8885 /* VEX_LEN_D3_P_2 */
8887 { VEX_W_TABLE (VEX_W_D3_P_2) },
8888 { "(bad)", { XX } },
8891 /* VEX_LEN_D4_P_2 */
8893 { VEX_W_TABLE (VEX_W_D4_P_2) },
8894 { "(bad)", { XX } },
8897 /* VEX_LEN_D5_P_2 */
8899 { VEX_W_TABLE (VEX_W_D5_P_2) },
8900 { "(bad)", { XX } },
8903 /* VEX_LEN_D6_P_2 */
8905 { VEX_W_TABLE (VEX_W_D6_P_2) },
8906 { "(bad)", { XX } },
8909 /* VEX_LEN_D7_P_2_M_1 */
8911 { VEX_W_TABLE (VEX_W_D7_P_2_M_1) },
8912 { "(bad)", { XX } },
8915 /* VEX_LEN_D8_P_2 */
8917 { VEX_W_TABLE (VEX_W_D8_P_2) },
8918 { "(bad)", { XX } },
8921 /* VEX_LEN_D9_P_2 */
8923 { VEX_W_TABLE (VEX_W_D9_P_2) },
8924 { "(bad)", { XX } },
8927 /* VEX_LEN_DA_P_2 */
8929 { VEX_W_TABLE (VEX_W_DA_P_2) },
8930 { "(bad)", { XX } },
8933 /* VEX_LEN_DB_P_2 */
8935 { VEX_W_TABLE (VEX_W_DB_P_2) },
8936 { "(bad)", { XX } },
8939 /* VEX_LEN_DC_P_2 */
8941 { VEX_W_TABLE (VEX_W_DC_P_2) },
8942 { "(bad)", { XX } },
8945 /* VEX_LEN_DD_P_2 */
8947 { VEX_W_TABLE (VEX_W_DD_P_2) },
8948 { "(bad)", { XX } },
8951 /* VEX_LEN_DE_P_2 */
8953 { VEX_W_TABLE (VEX_W_DE_P_2) },
8954 { "(bad)", { XX } },
8957 /* VEX_LEN_DF_P_2 */
8959 { VEX_W_TABLE (VEX_W_DF_P_2) },
8960 { "(bad)", { XX } },
8963 /* VEX_LEN_E0_P_2 */
8965 { VEX_W_TABLE (VEX_W_E0_P_2) },
8966 { "(bad)", { XX } },
8969 /* VEX_LEN_E1_P_2 */
8971 { VEX_W_TABLE (VEX_W_E1_P_2) },
8972 { "(bad)", { XX } },
8975 /* VEX_LEN_E2_P_2 */
8977 { VEX_W_TABLE (VEX_W_E2_P_2) },
8978 { "(bad)", { XX } },
8981 /* VEX_LEN_E3_P_2 */
8983 { VEX_W_TABLE (VEX_W_E3_P_2) },
8984 { "(bad)", { XX } },
8987 /* VEX_LEN_E4_P_2 */
8989 { VEX_W_TABLE (VEX_W_E4_P_2) },
8990 { "(bad)", { XX } },
8993 /* VEX_LEN_E5_P_2 */
8995 { VEX_W_TABLE (VEX_W_E5_P_2) },
8996 { "(bad)", { XX } },
8999 /* VEX_LEN_E8_P_2 */
9001 { VEX_W_TABLE (VEX_W_E8_P_2) },
9002 { "(bad)", { XX } },
9005 /* VEX_LEN_E9_P_2 */
9007 { VEX_W_TABLE (VEX_W_E9_P_2) },
9008 { "(bad)", { XX } },
9011 /* VEX_LEN_EA_P_2 */
9013 { VEX_W_TABLE (VEX_W_EA_P_2) },
9014 { "(bad)", { XX } },
9017 /* VEX_LEN_EB_P_2 */
9019 { VEX_W_TABLE (VEX_W_EB_P_2) },
9020 { "(bad)", { XX } },
9023 /* VEX_LEN_EC_P_2 */
9025 { VEX_W_TABLE (VEX_W_EC_P_2) },
9026 { "(bad)", { XX } },
9029 /* VEX_LEN_ED_P_2 */
9031 { VEX_W_TABLE (VEX_W_ED_P_2) },
9032 { "(bad)", { XX } },
9035 /* VEX_LEN_EE_P_2 */
9037 { VEX_W_TABLE (VEX_W_EE_P_2) },
9038 { "(bad)", { XX } },
9041 /* VEX_LEN_EF_P_2 */
9043 { VEX_W_TABLE (VEX_W_EF_P_2) },
9044 { "(bad)", { XX } },
9047 /* VEX_LEN_F1_P_2 */
9049 { VEX_W_TABLE (VEX_W_F1_P_2) },
9050 { "(bad)", { XX } },
9053 /* VEX_LEN_F2_P_2 */
9055 { VEX_W_TABLE (VEX_W_F2_P_2) },
9056 { "(bad)", { XX } },
9059 /* VEX_LEN_F3_P_2 */
9061 { VEX_W_TABLE (VEX_W_F3_P_2) },
9062 { "(bad)", { XX } },
9065 /* VEX_LEN_F4_P_2 */
9067 { VEX_W_TABLE (VEX_W_F4_P_2) },
9068 { "(bad)", { XX } },
9071 /* VEX_LEN_F5_P_2 */
9073 { VEX_W_TABLE (VEX_W_F5_P_2) },
9074 { "(bad)", { XX } },
9077 /* VEX_LEN_F6_P_2 */
9079 { VEX_W_TABLE (VEX_W_F6_P_2) },
9080 { "(bad)", { XX } },
9083 /* VEX_LEN_F7_P_2 */
9085 { VEX_W_TABLE (VEX_W_F7_P_2) },
9086 { "(bad)", { XX } },
9089 /* VEX_LEN_F8_P_2 */
9091 { VEX_W_TABLE (VEX_W_F8_P_2) },
9092 { "(bad)", { XX } },
9095 /* VEX_LEN_F9_P_2 */
9097 { VEX_W_TABLE (VEX_W_F9_P_2) },
9098 { "(bad)", { XX } },
9101 /* VEX_LEN_FA_P_2 */
9103 { VEX_W_TABLE (VEX_W_FA_P_2) },
9104 { "(bad)", { XX } },
9107 /* VEX_LEN_FB_P_2 */
9109 { VEX_W_TABLE (VEX_W_FB_P_2) },
9110 { "(bad)", { XX } },
9113 /* VEX_LEN_FC_P_2 */
9115 { VEX_W_TABLE (VEX_W_FC_P_2) },
9116 { "(bad)", { XX } },
9119 /* VEX_LEN_FD_P_2 */
9121 { VEX_W_TABLE (VEX_W_FD_P_2) },
9122 { "(bad)", { XX } },
9125 /* VEX_LEN_FE_P_2 */
9127 { VEX_W_TABLE (VEX_W_FE_P_2) },
9128 { "(bad)", { XX } },
9131 /* VEX_LEN_3800_P_2 */
9133 { VEX_W_TABLE (VEX_W_3800_P_2) },
9134 { "(bad)", { XX } },
9137 /* VEX_LEN_3801_P_2 */
9139 { VEX_W_TABLE (VEX_W_3801_P_2) },
9140 { "(bad)", { XX } },
9143 /* VEX_LEN_3802_P_2 */
9145 { VEX_W_TABLE (VEX_W_3802_P_2) },
9146 { "(bad)", { XX } },
9149 /* VEX_LEN_3803_P_2 */
9151 { VEX_W_TABLE (VEX_W_3803_P_2) },
9152 { "(bad)", { XX } },
9155 /* VEX_LEN_3804_P_2 */
9157 { VEX_W_TABLE (VEX_W_3804_P_2) },
9158 { "(bad)", { XX } },
9161 /* VEX_LEN_3805_P_2 */
9163 { VEX_W_TABLE (VEX_W_3805_P_2) },
9164 { "(bad)", { XX } },
9167 /* VEX_LEN_3806_P_2 */
9169 { VEX_W_TABLE (VEX_W_3806_P_2) },
9170 { "(bad)", { XX } },
9173 /* VEX_LEN_3807_P_2 */
9175 { VEX_W_TABLE (VEX_W_3807_P_2) },
9176 { "(bad)", { XX } },
9179 /* VEX_LEN_3808_P_2 */
9181 { VEX_W_TABLE (VEX_W_3808_P_2) },
9182 { "(bad)", { XX } },
9185 /* VEX_LEN_3809_P_2 */
9187 { VEX_W_TABLE (VEX_W_3809_P_2) },
9188 { "(bad)", { XX } },
9191 /* VEX_LEN_380A_P_2 */
9193 { VEX_W_TABLE (VEX_W_380A_P_2) },
9194 { "(bad)", { XX } },
9197 /* VEX_LEN_380B_P_2 */
9199 { VEX_W_TABLE (VEX_W_380B_P_2) },
9200 { "(bad)", { XX } },
9203 /* VEX_LEN_3819_P_2_M_0 */
9205 { "(bad)", { XX } },
9206 { VEX_W_TABLE (VEX_W_3819_P_2_M_0) },
9209 /* VEX_LEN_381A_P_2_M_0 */
9211 { "(bad)", { XX } },
9212 { VEX_W_TABLE (VEX_W_381A_P_2_M_0) },
9215 /* VEX_LEN_381C_P_2 */
9217 { VEX_W_TABLE (VEX_W_381C_P_2) },
9218 { "(bad)", { XX } },
9221 /* VEX_LEN_381D_P_2 */
9223 { VEX_W_TABLE (VEX_W_381D_P_2) },
9224 { "(bad)", { XX } },
9227 /* VEX_LEN_381E_P_2 */
9229 { VEX_W_TABLE (VEX_W_381E_P_2) },
9230 { "(bad)", { XX } },
9233 /* VEX_LEN_3820_P_2 */
9235 { VEX_W_TABLE (VEX_W_3820_P_2) },
9236 { "(bad)", { XX } },
9239 /* VEX_LEN_3821_P_2 */
9241 { VEX_W_TABLE (VEX_W_3821_P_2) },
9242 { "(bad)", { XX } },
9245 /* VEX_LEN_3822_P_2 */
9247 { VEX_W_TABLE (VEX_W_3822_P_2) },
9248 { "(bad)", { XX } },
9251 /* VEX_LEN_3823_P_2 */
9253 { VEX_W_TABLE (VEX_W_3823_P_2) },
9254 { "(bad)", { XX } },
9257 /* VEX_LEN_3824_P_2 */
9259 { VEX_W_TABLE (VEX_W_3824_P_2) },
9260 { "(bad)", { XX } },
9263 /* VEX_LEN_3825_P_2 */
9265 { VEX_W_TABLE (VEX_W_3825_P_2) },
9266 { "(bad)", { XX } },
9269 /* VEX_LEN_3828_P_2 */
9271 { VEX_W_TABLE (VEX_W_3828_P_2) },
9272 { "(bad)", { XX } },
9275 /* VEX_LEN_3829_P_2 */
9277 { VEX_W_TABLE (VEX_W_3829_P_2) },
9278 { "(bad)", { XX } },
9281 /* VEX_LEN_382A_P_2_M_0 */
9283 { VEX_W_TABLE (VEX_W_382A_P_2_M_0) },
9284 { "(bad)", { XX } },
9287 /* VEX_LEN_382B_P_2 */
9289 { VEX_W_TABLE (VEX_W_382B_P_2) },
9290 { "(bad)", { XX } },
9293 /* VEX_LEN_3830_P_2 */
9295 { VEX_W_TABLE (VEX_W_3830_P_2) },
9296 { "(bad)", { XX } },
9299 /* VEX_LEN_3831_P_2 */
9301 { VEX_W_TABLE (VEX_W_3831_P_2) },
9302 { "(bad)", { XX } },
9305 /* VEX_LEN_3832_P_2 */
9307 { VEX_W_TABLE (VEX_W_3832_P_2) },
9308 { "(bad)", { XX } },
9311 /* VEX_LEN_3833_P_2 */
9313 { VEX_W_TABLE (VEX_W_3833_P_2) },
9314 { "(bad)", { XX } },
9317 /* VEX_LEN_3834_P_2 */
9319 { VEX_W_TABLE (VEX_W_3834_P_2) },
9320 { "(bad)", { XX } },
9323 /* VEX_LEN_3835_P_2 */
9325 { VEX_W_TABLE (VEX_W_3835_P_2) },
9326 { "(bad)", { XX } },
9329 /* VEX_LEN_3837_P_2 */
9331 { VEX_W_TABLE (VEX_W_3837_P_2) },
9332 { "(bad)", { XX } },
9335 /* VEX_LEN_3838_P_2 */
9337 { VEX_W_TABLE (VEX_W_3838_P_2) },
9338 { "(bad)", { XX } },
9341 /* VEX_LEN_3839_P_2 */
9343 { VEX_W_TABLE (VEX_W_3839_P_2) },
9344 { "(bad)", { XX } },
9347 /* VEX_LEN_383A_P_2 */
9349 { VEX_W_TABLE (VEX_W_383A_P_2) },
9350 { "(bad)", { XX } },
9353 /* VEX_LEN_383B_P_2 */
9355 { VEX_W_TABLE (VEX_W_383B_P_2) },
9356 { "(bad)", { XX } },
9359 /* VEX_LEN_383C_P_2 */
9361 { VEX_W_TABLE (VEX_W_383C_P_2) },
9362 { "(bad)", { XX } },
9365 /* VEX_LEN_383D_P_2 */
9367 { VEX_W_TABLE (VEX_W_383D_P_2) },
9368 { "(bad)", { XX } },
9371 /* VEX_LEN_383E_P_2 */
9373 { VEX_W_TABLE (VEX_W_383E_P_2) },
9374 { "(bad)", { XX } },
9377 /* VEX_LEN_383F_P_2 */
9379 { VEX_W_TABLE (VEX_W_383F_P_2) },
9380 { "(bad)", { XX } },
9383 /* VEX_LEN_3840_P_2 */
9385 { VEX_W_TABLE (VEX_W_3840_P_2) },
9386 { "(bad)", { XX } },
9389 /* VEX_LEN_3841_P_2 */
9391 { VEX_W_TABLE (VEX_W_3841_P_2) },
9392 { "(bad)", { XX } },
9395 /* VEX_LEN_38DB_P_2 */
9397 { VEX_W_TABLE (VEX_W_38DB_P_2) },
9398 { "(bad)", { XX } },
9401 /* VEX_LEN_38DC_P_2 */
9403 { VEX_W_TABLE (VEX_W_38DC_P_2) },
9404 { "(bad)", { XX } },
9407 /* VEX_LEN_38DD_P_2 */
9409 { VEX_W_TABLE (VEX_W_38DD_P_2) },
9410 { "(bad)", { XX } },
9413 /* VEX_LEN_38DE_P_2 */
9415 { VEX_W_TABLE (VEX_W_38DE_P_2) },
9416 { "(bad)", { XX } },
9419 /* VEX_LEN_38DF_P_2 */
9421 { VEX_W_TABLE (VEX_W_38DF_P_2) },
9422 { "(bad)", { XX } },
9425 /* VEX_LEN_3A06_P_2 */
9427 { "(bad)", { XX } },
9428 { VEX_W_TABLE (VEX_W_3A06_P_2) },
9431 /* VEX_LEN_3A0A_P_2 */
9433 { VEX_W_TABLE (VEX_W_3A0A_P_2) },
9434 { "(bad)", { XX } },
9437 /* VEX_LEN_3A0B_P_2 */
9439 { VEX_W_TABLE (VEX_W_3A0B_P_2) },
9440 { "(bad)", { XX } },
9443 /* VEX_LEN_3A0E_P_2 */
9445 { VEX_W_TABLE (VEX_W_3A0E_P_2) },
9446 { "(bad)", { XX } },
9449 /* VEX_LEN_3A0F_P_2 */
9451 { VEX_W_TABLE (VEX_W_3A0F_P_2) },
9452 { "(bad)", { XX } },
9455 /* VEX_LEN_3A14_P_2 */
9457 { VEX_W_TABLE (VEX_W_3A14_P_2) },
9458 { "(bad)", { XX } },
9461 /* VEX_LEN_3A15_P_2 */
9463 { VEX_W_TABLE (VEX_W_3A15_P_2) },
9464 { "(bad)", { XX } },
9467 /* VEX_LEN_3A16_P_2 */
9469 { "vpextrK", { Edq, XM, Ib } },
9470 { "(bad)", { XX } },
9473 /* VEX_LEN_3A17_P_2 */
9475 { "vextractps", { Edqd, XM, Ib } },
9476 { "(bad)", { XX } },
9479 /* VEX_LEN_3A18_P_2 */
9481 { "(bad)", { XX } },
9482 { VEX_W_TABLE (VEX_W_3A18_P_2) },
9485 /* VEX_LEN_3A19_P_2 */
9487 { "(bad)", { XX } },
9488 { VEX_W_TABLE (VEX_W_3A19_P_2) },
9491 /* VEX_LEN_3A20_P_2 */
9493 { VEX_W_TABLE (VEX_W_3A20_P_2) },
9494 { "(bad)", { XX } },
9497 /* VEX_LEN_3A21_P_2 */
9499 { VEX_W_TABLE (VEX_W_3A21_P_2) },
9500 { "(bad)", { XX } },
9503 /* VEX_LEN_3A22_P_2 */
9505 { "vpinsrK", { XM, Vex128, Edq, Ib } },
9506 { "(bad)", { XX } },
9509 /* VEX_LEN_3A41_P_2 */
9511 { VEX_W_TABLE (VEX_W_3A41_P_2) },
9512 { "(bad)", { XX } },
9515 /* VEX_LEN_3A42_P_2 */
9517 { VEX_W_TABLE (VEX_W_3A42_P_2) },
9518 { "(bad)", { XX } },
9521 /* VEX_LEN_3A44_P_2 */
9523 { VEX_W_TABLE (VEX_W_3A44_P_2) },
9524 { "(bad)", { XX } },
9527 /* VEX_LEN_3A4C_P_2 */
9529 { VEX_W_TABLE (VEX_W_3A4C_P_2) },
9530 { "(bad)", { XX } },
9533 /* VEX_LEN_3A60_P_2 */
9535 { VEX_W_TABLE (VEX_W_3A60_P_2) },
9536 { "(bad)", { XX } },
9539 /* VEX_LEN_3A61_P_2 */
9541 { VEX_W_TABLE (VEX_W_3A61_P_2) },
9542 { "(bad)", { XX } },
9545 /* VEX_LEN_3A62_P_2 */
9547 { VEX_W_TABLE (VEX_W_3A62_P_2) },
9548 { "(bad)", { XX } },
9551 /* VEX_LEN_3A63_P_2 */
9553 { VEX_W_TABLE (VEX_W_3A63_P_2) },
9554 { "(bad)", { XX } },
9557 /* VEX_LEN_3A6A_P_2 */
9559 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9560 { "(bad)", { XX } },
9563 /* VEX_LEN_3A6B_P_2 */
9565 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9566 { "(bad)", { XX } },
9569 /* VEX_LEN_3A6E_P_2 */
9571 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9572 { "(bad)", { XX } },
9575 /* VEX_LEN_3A6F_P_2 */
9577 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9578 { "(bad)", { XX } },
9581 /* VEX_LEN_3A7A_P_2 */
9583 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9584 { "(bad)", { XX } },
9587 /* VEX_LEN_3A7B_P_2 */
9589 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9590 { "(bad)", { XX } },
9593 /* VEX_LEN_3A7E_P_2 */
9595 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9596 { "(bad)", { XX } },
9599 /* VEX_LEN_3A7F_P_2 */
9601 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9602 { "(bad)", { XX } },
9605 /* VEX_LEN_3ADF_P_2 */
9607 { VEX_W_TABLE (VEX_W_3ADF_P_2) },
9608 { "(bad)", { XX } },
9611 /* VEX_LEN_XOP_09_80 */
9613 { "vfrczps", { XM, EXxmm } },
9614 { "vfrczps", { XM, EXymmq } },
9617 /* VEX_LEN_XOP_09_81 */
9619 { "vfrczpd", { XM, EXxmm } },
9620 { "vfrczpd", { XM, EXymmq } },
9624 static const struct dis386 vex_w_table[][2] = {
9627 { "vmovups", { XM, EXx } },
9628 { "(bad)", { XX } },
9632 { "vmovss", { XMVex, Vex128, EXd } },
9633 { "(bad)", { XX } },
9637 { "vmovupd", { XM, EXx } },
9638 { "(bad)", { XX } },
9642 { "vmovsd", { XMVex, Vex128, EXq } },
9643 { "(bad)", { XX } },
9647 { "vmovups", { EXxS, XM } },
9648 { "(bad)", { XX } },
9652 { "vmovss", { EXdVexS, Vex128, XM } },
9653 { "(bad)", { XX } },
9657 { "vmovupd", { EXxS, XM } },
9658 { "(bad)", { XX } },
9662 { "vmovsd", { EXqVexS, Vex128, XM } },
9663 { "(bad)", { XX } },
9666 /* VEX_W_12_P_0_M_0 */
9667 { "vmovlps", { XM, Vex128, EXq } },
9668 { "(bad)", { XX } },
9671 /* VEX_W_12_P_0_M_1 */
9672 { "vmovhlps", { XM, Vex128, EXq } },
9673 { "(bad)", { XX } },
9677 { "vmovsldup", { XM, EXx } },
9678 { "(bad)", { XX } },
9682 { "vmovlpd", { XM, Vex128, EXq } },
9683 { "(bad)", { XX } },
9687 { "vmovddup", { XM, EXymmq } },
9688 { "(bad)", { XX } },
9692 { "vmovlpX", { EXq, XM } },
9693 { "(bad)", { XX } },
9697 { "vunpcklpX", { XM, Vex, EXx } },
9698 { "(bad)", { XX } },
9702 { "vunpckhpX", { XM, Vex, EXx } },
9703 { "(bad)", { XX } },
9706 /* VEX_W_16_P_0_M_0 */
9707 { "vmovhps", { XM, Vex128, EXq } },
9708 { "(bad)", { XX } },
9711 /* VEX_W_16_P_0_M_1 */
9712 { "vmovlhps", { XM, Vex128, EXq } },
9713 { "(bad)", { XX } },
9717 { "vmovshdup", { XM, EXx } },
9718 { "(bad)", { XX } },
9722 { "vmovhpd", { XM, Vex128, EXq } },
9723 { "(bad)", { XX } },
9727 { "vmovhpX", { EXq, XM } },
9728 { "(bad)", { XX } },
9732 { "vmovapX", { XM, EXx } },
9733 { "(bad)", { XX } },
9737 { "vmovapX", { EXxS, XM } },
9738 { "(bad)", { XX } },
9742 { "vmovntpX", { Mx, XM } },
9743 { "(bad)", { XX } },
9747 { "vucomiss", { XM, EXd } },
9748 { "(bad)", { XX } },
9752 { "vucomisd", { XM, EXq } },
9753 { "(bad)", { XX } },
9757 { "vcomiss", { XM, EXd } },
9758 { "(bad)", { XX } },
9762 { "vcomisd", { XM, EXq } },
9763 { "(bad)", { XX } },
9767 { "vmovmskpX", { Gdq, XS } },
9768 { "(bad)", { XX } },
9772 { "vsqrtps", { XM, EXx } },
9773 { "(bad)", { XX } },
9777 { "vsqrtss", { XM, Vex128, EXd } },
9778 { "(bad)", { XX } },
9782 { "vsqrtpd", { XM, EXx } },
9783 { "(bad)", { XX } },
9787 { "vsqrtsd", { XM, Vex128, EXq } },
9788 { "(bad)", { XX } },
9792 { "vrsqrtps", { XM, EXx } },
9793 { "(bad)", { XX } },
9797 { "vrsqrtss", { XM, Vex128, EXd } },
9798 { "(bad)", { XX } },
9802 { "vrcpps", { XM, EXx } },
9803 { "(bad)", { XX } },
9807 { "vrcpss", { XM, Vex128, EXd } },
9808 { "(bad)", { XX } },
9812 { "vaddps", { XM, Vex, EXx } },
9813 { "(bad)", { XX } },
9817 { "vaddss", { XM, Vex128, EXd } },
9818 { "(bad)", { XX } },
9822 { "vaddpd", { XM, Vex, EXx } },
9823 { "(bad)", { XX } },
9827 { "vaddsd", { XM, Vex128, EXq } },
9828 { "(bad)", { XX } },
9832 { "vmulps", { XM, Vex, EXx } },
9833 { "(bad)", { XX } },
9837 { "vmulss", { XM, Vex128, EXd } },
9838 { "(bad)", { XX } },
9842 { "vmulpd", { XM, Vex, EXx } },
9843 { "(bad)", { XX } },
9847 { "vmulsd", { XM, Vex128, EXq } },
9848 { "(bad)", { XX } },
9852 { "vcvtps2pd", { XM, EXxmmq } },
9853 { "(bad)", { XX } },
9857 { "vcvtss2sd", { XM, Vex128, EXd } },
9858 { "(bad)", { XX } },
9862 { "vcvtsd2ss", { XM, Vex128, EXq } },
9863 { "(bad)", { XX } },
9867 { "vcvtdq2ps", { XM, EXx } },
9868 { "(bad)", { XX } },
9872 { "vcvttps2dq", { XM, EXx } },
9873 { "(bad)", { XX } },
9877 { "vcvtps2dq", { XM, EXx } },
9878 { "(bad)", { XX } },
9882 { "vsubps", { XM, Vex, EXx } },
9883 { "(bad)", { XX } },
9887 { "vsubss", { XM, Vex128, EXd } },
9888 { "(bad)", { XX } },
9892 { "vsubpd", { XM, Vex, EXx } },
9893 { "(bad)", { XX } },
9897 { "vsubsd", { XM, Vex128, EXq } },
9898 { "(bad)", { XX } },
9902 { "vminps", { XM, Vex, EXx } },
9903 { "(bad)", { XX } },
9907 { "vminss", { XM, Vex128, EXd } },
9908 { "(bad)", { XX } },
9912 { "vminpd", { XM, Vex, EXx } },
9913 { "(bad)", { XX } },
9917 { "vminsd", { XM, Vex128, EXq } },
9918 { "(bad)", { XX } },
9922 { "vdivps", { XM, Vex, EXx } },
9923 { "(bad)", { XX } },
9927 { "vdivss", { XM, Vex128, EXd } },
9928 { "(bad)", { XX } },
9932 { "vdivpd", { XM, Vex, EXx } },
9933 { "(bad)", { XX } },
9937 { "vdivsd", { XM, Vex128, EXq } },
9938 { "(bad)", { XX } },
9942 { "vmaxps", { XM, Vex, EXx } },
9943 { "(bad)", { XX } },
9947 { "vmaxss", { XM, Vex128, EXd } },
9948 { "(bad)", { XX } },
9952 { "vmaxpd", { XM, Vex, EXx } },
9953 { "(bad)", { XX } },
9957 { "vmaxsd", { XM, Vex128, EXq } },
9958 { "(bad)", { XX } },
9962 { "vpunpcklbw", { XM, Vex128, EXx } },
9963 { "(bad)", { XX } },
9967 { "vpunpcklwd", { XM, Vex128, EXx } },
9968 { "(bad)", { XX } },
9972 { "vpunpckldq", { XM, Vex128, EXx } },
9973 { "(bad)", { XX } },
9977 { "vpacksswb", { XM, Vex128, EXx } },
9978 { "(bad)", { XX } },
9982 { "vpcmpgtb", { XM, Vex128, EXx } },
9983 { "(bad)", { XX } },
9987 { "vpcmpgtw", { XM, Vex128, EXx } },
9988 { "(bad)", { XX } },
9992 { "vpcmpgtd", { XM, Vex128, EXx } },
9993 { "(bad)", { XX } },
9997 { "vpackuswb", { XM, Vex128, EXx } },
9998 { "(bad)", { XX } },
10002 { "vpunpckhbw", { XM, Vex128, EXx } },
10003 { "(bad)", { XX } },
10007 { "vpunpckhwd", { XM, Vex128, EXx } },
10008 { "(bad)", { XX } },
10012 { "vpunpckhdq", { XM, Vex128, EXx } },
10013 { "(bad)", { XX } },
10017 { "vpackssdw", { XM, Vex128, EXx } },
10018 { "(bad)", { XX } },
10022 { "vpunpcklqdq", { XM, Vex128, EXx } },
10023 { "(bad)", { XX } },
10027 { "vpunpckhqdq", { XM, Vex128, EXx } },
10028 { "(bad)", { XX } },
10032 { "vmovdqu", { XM, EXx } },
10033 { "(bad)", { XX } },
10037 { "vmovdqa", { XM, EXx } },
10038 { "(bad)", { XX } },
10042 { "vpshufhw", { XM, EXx, Ib } },
10043 { "(bad)", { XX } },
10047 { "vpshufd", { XM, EXx, Ib } },
10048 { "(bad)", { XX } },
10052 { "vpshuflw", { XM, EXx, Ib } },
10053 { "(bad)", { XX } },
10056 /* VEX_W_71_R_2_P_2 */
10057 { "vpsrlw", { Vex128, XS, Ib } },
10058 { "(bad)", { XX } },
10061 /* VEX_W_71_R_4_P_2 */
10062 { "vpsraw", { Vex128, XS, Ib } },
10063 { "(bad)", { XX } },
10066 /* VEX_W_71_R_6_P_2 */
10067 { "vpsllw", { Vex128, XS, Ib } },
10068 { "(bad)", { XX } },
10071 /* VEX_W_72_R_2_P_2 */
10072 { "vpsrld", { Vex128, XS, Ib } },
10073 { "(bad)", { XX } },
10076 /* VEX_W_72_R_4_P_2 */
10077 { "vpsrad", { Vex128, XS, Ib } },
10078 { "(bad)", { XX } },
10081 /* VEX_W_72_R_6_P_2 */
10082 { "vpslld", { Vex128, XS, Ib } },
10083 { "(bad)", { XX } },
10086 /* VEX_W_73_R_2_P_2 */
10087 { "vpsrlq", { Vex128, XS, Ib } },
10088 { "(bad)", { XX } },
10091 /* VEX_W_73_R_3_P_2 */
10092 { "vpsrldq", { Vex128, XS, Ib } },
10093 { "(bad)", { XX } },
10096 /* VEX_W_73_R_6_P_2 */
10097 { "vpsllq", { Vex128, XS, Ib } },
10098 { "(bad)", { XX } },
10101 /* VEX_W_73_R_7_P_2 */
10102 { "vpslldq", { Vex128, XS, Ib } },
10103 { "(bad)", { XX } },
10107 { "vpcmpeqb", { XM, Vex128, EXx } },
10108 { "(bad)", { XX } },
10112 { "vpcmpeqw", { XM, Vex128, EXx } },
10113 { "(bad)", { XX } },
10117 { "vpcmpeqd", { XM, Vex128, EXx } },
10118 { "(bad)", { XX } },
10123 { "(bad)", { XX } },
10127 { "vhaddpd", { XM, Vex, EXx } },
10128 { "(bad)", { XX } },
10132 { "vhaddps", { XM, Vex, EXx } },
10133 { "(bad)", { XX } },
10137 { "vhsubpd", { XM, Vex, EXx } },
10138 { "(bad)", { XX } },
10142 { "vhsubps", { XM, Vex, EXx } },
10143 { "(bad)", { XX } },
10147 { "vmovq", { XM, EXq } },
10148 { "(bad)", { XX } },
10152 { "vmovdqu", { EXxS, XM } },
10153 { "(bad)", { XX } },
10157 { "vmovdqa", { EXxS, XM } },
10158 { "(bad)", { XX } },
10161 /* VEX_W_AE_R_2_M_0 */
10162 { "vldmxcsr", { Md } },
10163 { "(bad)", { XX } },
10166 /* VEX_W_AE_R_3_M_0 */
10167 { "vstmxcsr", { Md } },
10168 { "(bad)", { XX } },
10172 { "vcmpps", { XM, Vex, EXx, VCMP } },
10173 { "(bad)", { XX } },
10177 { "vcmpss", { XM, Vex128, EXd, VCMP } },
10178 { "(bad)", { XX } },
10182 { "vcmppd", { XM, Vex, EXx, VCMP } },
10183 { "(bad)", { XX } },
10187 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
10188 { "(bad)", { XX } },
10192 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
10193 { "(bad)", { XX } },
10197 { "vpextrw", { Gdq, XS, Ib } },
10198 { "(bad)", { XX } },
10202 { "vaddsubpd", { XM, Vex, EXx } },
10203 { "(bad)", { XX } },
10207 { "vaddsubps", { XM, Vex, EXx } },
10208 { "(bad)", { XX } },
10212 { "vpsrlw", { XM, Vex128, EXx } },
10213 { "(bad)", { XX } },
10217 { "vpsrld", { XM, Vex128, EXx } },
10218 { "(bad)", { XX } },
10222 { "vpsrlq", { XM, Vex128, EXx } },
10223 { "(bad)", { XX } },
10227 { "vpaddq", { XM, Vex128, EXx } },
10228 { "(bad)", { XX } },
10232 { "vpmullw", { XM, Vex128, EXx } },
10233 { "(bad)", { XX } },
10237 { "vmovq", { EXqS, XM } },
10238 { "(bad)", { XX } },
10241 /* VEX_W_D7_P_2_M_1 */
10242 { "vpmovmskb", { Gdq, XS } },
10243 { "(bad)", { XX } },
10247 { "vpsubusb", { XM, Vex128, EXx } },
10248 { "(bad)", { XX } },
10252 { "vpsubusw", { XM, Vex128, EXx } },
10253 { "(bad)", { XX } },
10257 { "vpminub", { XM, Vex128, EXx } },
10258 { "(bad)", { XX } },
10262 { "vpand", { XM, Vex128, EXx } },
10263 { "(bad)", { XX } },
10267 { "vpaddusb", { XM, Vex128, EXx } },
10268 { "(bad)", { XX } },
10272 { "vpaddusw", { XM, Vex128, EXx } },
10273 { "(bad)", { XX } },
10277 { "vpmaxub", { XM, Vex128, EXx } },
10278 { "(bad)", { XX } },
10282 { "vpandn", { XM, Vex128, EXx } },
10283 { "(bad)", { XX } },
10287 { "vpavgb", { XM, Vex128, EXx } },
10288 { "(bad)", { XX } },
10292 { "vpsraw", { XM, Vex128, EXx } },
10293 { "(bad)", { XX } },
10297 { "vpsrad", { XM, Vex128, EXx } },
10298 { "(bad)", { XX } },
10302 { "vpavgw", { XM, Vex128, EXx } },
10303 { "(bad)", { XX } },
10307 { "vpmulhuw", { XM, Vex128, EXx } },
10308 { "(bad)", { XX } },
10312 { "vpmulhw", { XM, Vex128, EXx } },
10313 { "(bad)", { XX } },
10317 { "vcvtdq2pd", { XM, EXxmmq } },
10318 { "(bad)", { XX } },
10322 { "vcvttpd2dq%XY", { XMM, EXx } },
10323 { "(bad)", { XX } },
10327 { "vcvtpd2dq%XY", { XMM, EXx } },
10328 { "(bad)", { XX } },
10331 /* VEX_W_E7_P_2_M_0 */
10332 { "vmovntdq", { Mx, XM } },
10333 { "(bad)", { XX } },
10337 { "vpsubsb", { XM, Vex128, EXx } },
10338 { "(bad)", { XX } },
10342 { "vpsubsw", { XM, Vex128, EXx } },
10343 { "(bad)", { XX } },
10347 { "vpminsw", { XM, Vex128, EXx } },
10348 { "(bad)", { XX } },
10352 { "vpor", { XM, Vex128, EXx } },
10353 { "(bad)", { XX } },
10357 { "vpaddsb", { XM, Vex128, EXx } },
10358 { "(bad)", { XX } },
10362 { "vpaddsw", { XM, Vex128, EXx } },
10363 { "(bad)", { XX } },
10367 { "vpmaxsw", { XM, Vex128, EXx } },
10368 { "(bad)", { XX } },
10372 { "vpxor", { XM, Vex128, EXx } },
10373 { "(bad)", { XX } },
10376 /* VEX_W_F0_P_3_M_0 */
10377 { "vlddqu", { XM, M } },
10378 { "(bad)", { XX } },
10382 { "vpsllw", { XM, Vex128, EXx } },
10383 { "(bad)", { XX } },
10387 { "vpslld", { XM, Vex128, EXx } },
10388 { "(bad)", { XX } },
10392 { "vpsllq", { XM, Vex128, EXx } },
10393 { "(bad)", { XX } },
10397 { "vpmuludq", { XM, Vex128, EXx } },
10398 { "(bad)", { XX } },
10402 { "vpmaddwd", { XM, Vex128, EXx } },
10403 { "(bad)", { XX } },
10407 { "vpsadbw", { XM, Vex128, EXx } },
10408 { "(bad)", { XX } },
10412 { "vmaskmovdqu", { XM, XS } },
10413 { "(bad)", { XX } },
10417 { "vpsubb", { XM, Vex128, EXx } },
10418 { "(bad)", { XX } },
10422 { "vpsubw", { XM, Vex128, EXx } },
10423 { "(bad)", { XX } },
10427 { "vpsubd", { XM, Vex128, EXx } },
10428 { "(bad)", { XX } },
10432 { "vpsubq", { XM, Vex128, EXx } },
10433 { "(bad)", { XX } },
10437 { "vpaddb", { XM, Vex128, EXx } },
10438 { "(bad)", { XX } },
10442 { "vpaddw", { XM, Vex128, EXx } },
10443 { "(bad)", { XX } },
10447 { "vpaddd", { XM, Vex128, EXx } },
10448 { "(bad)", { XX } },
10451 /* VEX_W_3800_P_2 */
10452 { "vpshufb", { XM, Vex128, EXx } },
10453 { "(bad)", { XX } },
10456 /* VEX_W_3801_P_2 */
10457 { "vphaddw", { XM, Vex128, EXx } },
10458 { "(bad)", { XX } },
10461 /* VEX_W_3802_P_2 */
10462 { "vphaddd", { XM, Vex128, EXx } },
10463 { "(bad)", { XX } },
10466 /* VEX_W_3803_P_2 */
10467 { "vphaddsw", { XM, Vex128, EXx } },
10468 { "(bad)", { XX } },
10471 /* VEX_W_3804_P_2 */
10472 { "vpmaddubsw", { XM, Vex128, EXx } },
10473 { "(bad)", { XX } },
10476 /* VEX_W_3805_P_2 */
10477 { "vphsubw", { XM, Vex128, EXx } },
10478 { "(bad)", { XX } },
10481 /* VEX_W_3806_P_2 */
10482 { "vphsubd", { XM, Vex128, EXx } },
10483 { "(bad)", { XX } },
10486 /* VEX_W_3807_P_2 */
10487 { "vphsubsw", { XM, Vex128, EXx } },
10488 { "(bad)", { XX } },
10491 /* VEX_W_3808_P_2 */
10492 { "vpsignb", { XM, Vex128, EXx } },
10493 { "(bad)", { XX } },
10496 /* VEX_W_3809_P_2 */
10497 { "vpsignw", { XM, Vex128, EXx } },
10498 { "(bad)", { XX } },
10501 /* VEX_W_380A_P_2 */
10502 { "vpsignd", { XM, Vex128, EXx } },
10503 { "(bad)", { XX } },
10506 /* VEX_W_380B_P_2 */
10507 { "vpmulhrsw", { XM, Vex128, EXx } },
10508 { "(bad)", { XX } },
10511 /* VEX_W_380C_P_2 */
10512 { "vpermilps", { XM, Vex, EXx } },
10513 { "(bad)", { XX } },
10516 /* VEX_W_380D_P_2 */
10517 { "vpermilpd", { XM, Vex, EXx } },
10518 { "(bad)", { XX } },
10521 /* VEX_W_380E_P_2 */
10522 { "vtestps", { XM, EXx } },
10523 { "(bad)", { XX } },
10526 /* VEX_W_380F_P_2 */
10527 { "vtestpd", { XM, EXx } },
10528 { "(bad)", { XX } },
10531 /* VEX_W_3817_P_2 */
10532 { "vptest", { XM, EXx } },
10533 { "(bad)", { XX } },
10536 /* VEX_W_3819_P_2_M_0 */
10537 { "vbroadcastsd", { XM, Mq } },
10538 { "(bad)", { XX } },
10541 /* VEX_W_381A_P_2_M_0 */
10542 { "vbroadcastf128", { XM, Mxmm } },
10543 { "(bad)", { XX } },
10546 /* VEX_W_381C_P_2 */
10547 { "vpabsb", { XM, EXx } },
10548 { "(bad)", { XX } },
10551 /* VEX_W_381D_P_2 */
10552 { "vpabsw", { XM, EXx } },
10553 { "(bad)", { XX } },
10556 /* VEX_W_381E_P_2 */
10557 { "vpabsd", { XM, EXx } },
10558 { "(bad)", { XX } },
10561 /* VEX_W_3820_P_2 */
10562 { "vpmovsxbw", { XM, EXq } },
10563 { "(bad)", { XX } },
10566 /* VEX_W_3821_P_2 */
10567 { "vpmovsxbd", { XM, EXd } },
10568 { "(bad)", { XX } },
10571 /* VEX_W_3822_P_2 */
10572 { "vpmovsxbq", { XM, EXw } },
10573 { "(bad)", { XX } },
10576 /* VEX_W_3823_P_2 */
10577 { "vpmovsxwd", { XM, EXq } },
10578 { "(bad)", { XX } },
10581 /* VEX_W_3824_P_2 */
10582 { "vpmovsxwq", { XM, EXd } },
10583 { "(bad)", { XX } },
10586 /* VEX_W_3825_P_2 */
10587 { "vpmovsxdq", { XM, EXq } },
10588 { "(bad)", { XX } },
10591 /* VEX_W_3828_P_2 */
10592 { "vpmuldq", { XM, Vex128, EXx } },
10593 { "(bad)", { XX } },
10596 /* VEX_W_3829_P_2 */
10597 { "vpcmpeqq", { XM, Vex128, EXx } },
10598 { "(bad)", { XX } },
10601 /* VEX_W_382A_P_2_M_0 */
10602 { "vmovntdqa", { XM, Mx } },
10603 { "(bad)", { XX } },
10606 /* VEX_W_382B_P_2 */
10607 { "vpackusdw", { XM, Vex128, EXx } },
10608 { "(bad)", { XX } },
10611 /* VEX_W_3830_P_2 */
10612 { "vpmovzxbw", { XM, EXq } },
10613 { "(bad)", { XX } },
10616 /* VEX_W_3831_P_2 */
10617 { "vpmovzxbd", { XM, EXd } },
10618 { "(bad)", { XX } },
10621 /* VEX_W_3832_P_2 */
10622 { "vpmovzxbq", { XM, EXw } },
10623 { "(bad)", { XX } },
10626 /* VEX_W_3833_P_2 */
10627 { "vpmovzxwd", { XM, EXq } },
10628 { "(bad)", { XX } },
10631 /* VEX_W_3834_P_2 */
10632 { "vpmovzxwq", { XM, EXd } },
10633 { "(bad)", { XX } },
10636 /* VEX_W_3835_P_2 */
10637 { "vpmovzxdq", { XM, EXq } },
10638 { "(bad)", { XX } },
10641 /* VEX_W_3837_P_2 */
10642 { "vpcmpgtq", { XM, Vex128, EXx } },
10643 { "(bad)", { XX } },
10646 /* VEX_W_3838_P_2 */
10647 { "vpminsb", { XM, Vex128, EXx } },
10648 { "(bad)", { XX } },
10651 /* VEX_W_3839_P_2 */
10652 { "vpminsd", { XM, Vex128, EXx } },
10653 { "(bad)", { XX } },
10656 /* VEX_W_383A_P_2 */
10657 { "vpminuw", { XM, Vex128, EXx } },
10658 { "(bad)", { XX } },
10661 /* VEX_W_383B_P_2 */
10662 { "vpminud", { XM, Vex128, EXx } },
10663 { "(bad)", { XX } },
10666 /* VEX_W_383C_P_2 */
10667 { "vpmaxsb", { XM, Vex128, EXx } },
10668 { "(bad)", { XX } },
10671 /* VEX_W_383D_P_2 */
10672 { "vpmaxsd", { XM, Vex128, EXx } },
10673 { "(bad)", { XX } },
10676 /* VEX_W_383E_P_2 */
10677 { "vpmaxuw", { XM, Vex128, EXx } },
10678 { "(bad)", { XX } },
10681 /* VEX_W_383F_P_2 */
10682 { "vpmaxud", { XM, Vex128, EXx } },
10683 { "(bad)", { XX } },
10686 /* VEX_W_3840_P_2 */
10687 { "vpmulld", { XM, Vex128, EXx } },
10688 { "(bad)", { XX } },
10691 /* VEX_W_3841_P_2 */
10692 { "vphminposuw", { XM, EXx } },
10693 { "(bad)", { XX } },
10696 /* VEX_W_38DB_P_2 */
10697 { "vaesimc", { XM, EXx } },
10698 { "(bad)", { XX } },
10701 /* VEX_W_38DC_P_2 */
10702 { "vaesenc", { XM, Vex128, EXx } },
10703 { "(bad)", { XX } },
10706 /* VEX_W_38DD_P_2 */
10707 { "vaesenclast", { XM, Vex128, EXx } },
10708 { "(bad)", { XX } },
10711 /* VEX_W_38DE_P_2 */
10712 { "vaesdec", { XM, Vex128, EXx } },
10713 { "(bad)", { XX } },
10716 /* VEX_W_38DF_P_2 */
10717 { "vaesdeclast", { XM, Vex128, EXx } },
10718 { "(bad)", { XX } },
10721 /* VEX_W_3A04_P_2 */
10722 { "vpermilps", { XM, EXx, Ib } },
10723 { "(bad)", { XX } },
10726 /* VEX_W_3A05_P_2 */
10727 { "vpermilpd", { XM, EXx, Ib } },
10728 { "(bad)", { XX } },
10731 /* VEX_W_3A06_P_2 */
10732 { "vperm2f128", { XM, Vex256, EXx, Ib } },
10733 { "(bad)", { XX } },
10736 /* VEX_W_3A08_P_2 */
10737 { "vroundps", { XM, EXx, Ib } },
10738 { "(bad)", { XX } },
10741 /* VEX_W_3A09_P_2 */
10742 { "vroundpd", { XM, EXx, Ib } },
10743 { "(bad)", { XX } },
10746 /* VEX_W_3A0A_P_2 */
10747 { "vroundss", { XM, Vex128, EXd, Ib } },
10748 { "(bad)", { XX } },
10751 /* VEX_W_3A0B_P_2 */
10752 { "vroundsd", { XM, Vex128, EXq, Ib } },
10753 { "(bad)", { XX } },
10756 /* VEX_W_3A0C_P_2 */
10757 { "vblendps", { XM, Vex, EXx, Ib } },
10758 { "(bad)", { XX } },
10761 /* VEX_W_3A0D_P_2 */
10762 { "vblendpd", { XM, Vex, EXx, Ib } },
10763 { "(bad)", { XX } },
10766 /* VEX_W_3A0E_P_2 */
10767 { "vpblendw", { XM, Vex128, EXx, Ib } },
10768 { "(bad)", { XX } },
10771 /* VEX_W_3A0F_P_2 */
10772 { "vpalignr", { XM, Vex128, EXx, Ib } },
10773 { "(bad)", { XX } },
10776 /* VEX_W_3A14_P_2 */
10777 { "vpextrb", { Edqb, XM, Ib } },
10778 { "(bad)", { XX } },
10781 /* VEX_W_3A15_P_2 */
10782 { "vpextrw", { Edqw, XM, Ib } },
10783 { "(bad)", { XX } },
10786 /* VEX_W_3A18_P_2 */
10787 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
10788 { "(bad)", { XX } },
10791 /* VEX_W_3A19_P_2 */
10792 { "vextractf128", { EXxmm, XM, Ib } },
10793 { "(bad)", { XX } },
10796 /* VEX_W_3A20_P_2 */
10797 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
10798 { "(bad)", { XX } },
10801 /* VEX_W_3A21_P_2 */
10802 { "vinsertps", { XM, Vex128, EXd, Ib } },
10803 { "(bad)", { XX } },
10806 /* VEX_W_3A40_P_2 */
10807 { "vdpps", { XM, Vex, EXx, Ib } },
10808 { "(bad)", { XX } },
10811 /* VEX_W_3A41_P_2 */
10812 { "vdppd", { XM, Vex128, EXx, Ib } },
10813 { "(bad)", { XX } },
10816 /* VEX_W_3A42_P_2 */
10817 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
10818 { "(bad)", { XX } },
10821 /* VEX_W_3A44_P_2 */
10822 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
10823 { "(bad)", { XX } },
10826 /* VEX_W_3A4A_P_2 */
10827 { "vblendvps", { XM, Vex, EXx, XMVexI4 } },
10828 { "(bad)", { XX } },
10831 /* VEX_W_3A4B_P_2 */
10832 { "vblendvpd", { XM, Vex, EXx, XMVexI4 } },
10833 { "(bad)", { XX } },
10836 /* VEX_W_3A4C_P_2 */
10837 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
10838 { "(bad)", { XX } },
10841 /* VEX_W_3A60_P_2 */
10842 { "vpcmpestrm", { XM, EXx, Ib } },
10843 { "(bad)", { XX } },
10846 /* VEX_W_3A61_P_2 */
10847 { "vpcmpestri", { XM, EXx, Ib } },
10848 { "(bad)", { XX } },
10851 /* VEX_W_3A62_P_2 */
10852 { "vpcmpistrm", { XM, EXx, Ib } },
10853 { "(bad)", { XX } },
10856 /* VEX_W_3A63_P_2 */
10857 { "vpcmpistri", { XM, EXx, Ib } },
10858 { "(bad)", { XX } },
10861 /* VEX_W_3ADF_P_2 */
10862 { "vaeskeygenassist", { XM, EXx, Ib } },
10863 { "(bad)", { XX } },
10867 static const struct dis386 mod_table[][2] = {
10870 { "leaS", { Gv, M } },
10871 { "(bad)", { XX } },
10874 /* MOD_0F01_REG_0 */
10875 { X86_64_TABLE (X86_64_0F01_REG_0) },
10876 { RM_TABLE (RM_0F01_REG_0) },
10879 /* MOD_0F01_REG_1 */
10880 { X86_64_TABLE (X86_64_0F01_REG_1) },
10881 { RM_TABLE (RM_0F01_REG_1) },
10884 /* MOD_0F01_REG_2 */
10885 { X86_64_TABLE (X86_64_0F01_REG_2) },
10886 { RM_TABLE (RM_0F01_REG_2) },
10889 /* MOD_0F01_REG_3 */
10890 { X86_64_TABLE (X86_64_0F01_REG_3) },
10891 { RM_TABLE (RM_0F01_REG_3) },
10894 /* MOD_0F01_REG_7 */
10895 { "invlpg", { Mb } },
10896 { RM_TABLE (RM_0F01_REG_7) },
10899 /* MOD_0F12_PREFIX_0 */
10900 { "movlps", { XM, EXq } },
10901 { "movhlps", { XM, EXq } },
10905 { "movlpX", { EXq, XM } },
10906 { "(bad)", { XX } },
10909 /* MOD_0F16_PREFIX_0 */
10910 { "movhps", { XM, EXq } },
10911 { "movlhps", { XM, EXq } },
10915 { "movhpX", { EXq, XM } },
10916 { "(bad)", { XX } },
10919 /* MOD_0F18_REG_0 */
10920 { "prefetchnta", { Mb } },
10921 { "(bad)", { XX } },
10924 /* MOD_0F18_REG_1 */
10925 { "prefetcht0", { Mb } },
10926 { "(bad)", { XX } },
10929 /* MOD_0F18_REG_2 */
10930 { "prefetcht1", { Mb } },
10931 { "(bad)", { XX } },
10934 /* MOD_0F18_REG_3 */
10935 { "prefetcht2", { Mb } },
10936 { "(bad)", { XX } },
10940 { "(bad)", { XX } },
10941 { "movZ", { Rm, Cm } },
10945 { "(bad)", { XX } },
10946 { "movZ", { Rm, Dm } },
10950 { "(bad)", { XX } },
10951 { "movZ", { Cm, Rm } },
10955 { "(bad)", { XX } },
10956 { "movZ", { Dm, Rm } },
10960 { "(bad)", { XX } },
10961 { "movL", { Rd, Td } },
10965 { "(bad)", { XX } },
10966 { "movL", { Td, Rd } },
10969 /* MOD_0F2B_PREFIX_0 */
10970 {"movntps", { Mx, XM } },
10971 { "(bad)", { XX } },
10974 /* MOD_0F2B_PREFIX_1 */
10975 {"movntss", { Md, XM } },
10976 { "(bad)", { XX } },
10979 /* MOD_0F2B_PREFIX_2 */
10980 {"movntpd", { Mx, XM } },
10981 { "(bad)", { XX } },
10984 /* MOD_0F2B_PREFIX_3 */
10985 {"movntsd", { Mq, XM } },
10986 { "(bad)", { XX } },
10990 { "(bad)", { XX } },
10991 { "movmskpX", { Gdq, XS } },
10994 /* MOD_0F71_REG_2 */
10995 { "(bad)", { XX } },
10996 { "psrlw", { MS, Ib } },
10999 /* MOD_0F71_REG_4 */
11000 { "(bad)", { XX } },
11001 { "psraw", { MS, Ib } },
11004 /* MOD_0F71_REG_6 */
11005 { "(bad)", { XX } },
11006 { "psllw", { MS, Ib } },
11009 /* MOD_0F72_REG_2 */
11010 { "(bad)", { XX } },
11011 { "psrld", { MS, Ib } },
11014 /* MOD_0F72_REG_4 */
11015 { "(bad)", { XX } },
11016 { "psrad", { MS, Ib } },
11019 /* MOD_0F72_REG_6 */
11020 { "(bad)", { XX } },
11021 { "pslld", { MS, Ib } },
11024 /* MOD_0F73_REG_2 */
11025 { "(bad)", { XX } },
11026 { "psrlq", { MS, Ib } },
11029 /* MOD_0F73_REG_3 */
11030 { "(bad)", { XX } },
11031 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
11034 /* MOD_0F73_REG_6 */
11035 { "(bad)", { XX } },
11036 { "psllq", { MS, Ib } },
11039 /* MOD_0F73_REG_7 */
11040 { "(bad)", { XX } },
11041 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
11044 /* MOD_0FAE_REG_0 */
11045 { "fxsave", { FXSAVE } },
11046 { "(bad)", { XX } },
11049 /* MOD_0FAE_REG_1 */
11050 { "fxrstor", { FXSAVE } },
11051 { "(bad)", { XX } },
11054 /* MOD_0FAE_REG_2 */
11055 { "ldmxcsr", { Md } },
11056 { "(bad)", { XX } },
11059 /* MOD_0FAE_REG_3 */
11060 { "stmxcsr", { Md } },
11061 { "(bad)", { XX } },
11064 /* MOD_0FAE_REG_4 */
11065 { "xsave", { M } },
11066 { "(bad)", { XX } },
11069 /* MOD_0FAE_REG_5 */
11070 { "xrstor", { M } },
11071 { RM_TABLE (RM_0FAE_REG_5) },
11074 /* MOD_0FAE_REG_6 */
11075 { "xsaveopt", { M } },
11076 { RM_TABLE (RM_0FAE_REG_6) },
11079 /* MOD_0FAE_REG_7 */
11080 { "clflush", { Mb } },
11081 { RM_TABLE (RM_0FAE_REG_7) },
11085 { "lssS", { Gv, Mp } },
11086 { "(bad)", { XX } },
11090 { "lfsS", { Gv, Mp } },
11091 { "(bad)", { XX } },
11095 { "lgsS", { Gv, Mp } },
11096 { "(bad)", { XX } },
11099 /* MOD_0FC7_REG_6 */
11100 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
11101 { "(bad)", { XX } },
11104 /* MOD_0FC7_REG_7 */
11105 { "vmptrst", { Mq } },
11106 { "(bad)", { XX } },
11110 { "(bad)", { XX } },
11111 { "pmovmskb", { Gdq, MS } },
11114 /* MOD_0FE7_PREFIX_2 */
11115 { "movntdq", { Mx, XM } },
11116 { "(bad)", { XX } },
11119 /* MOD_0FF0_PREFIX_3 */
11120 { "lddqu", { XM, M } },
11121 { "(bad)", { XX } },
11124 /* MOD_0F382A_PREFIX_2 */
11125 { "movntdqa", { XM, Mx } },
11126 { "(bad)", { XX } },
11130 { "bound{S|}", { Gv, Ma } },
11131 { "(bad)", { XX } },
11135 { "lesS", { Gv, Mp } },
11136 { VEX_C4_TABLE (VEX_0F) },
11140 { "ldsS", { Gv, Mp } },
11141 { VEX_C5_TABLE (VEX_0F) },
11144 /* MOD_VEX_12_PREFIX_0 */
11145 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
11146 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
11150 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
11151 { "(bad)", { XX } },
11154 /* MOD_VEX_16_PREFIX_0 */
11155 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
11156 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
11160 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
11161 { "(bad)", { XX } },
11165 { VEX_W_TABLE (VEX_W_2B_M_0) },
11166 { "(bad)", { XX } },
11170 { "(bad)", { XX } },
11171 { VEX_W_TABLE (VEX_W_50_M_0) },
11174 /* MOD_VEX_71_REG_2 */
11175 { "(bad)", { XX } },
11176 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
11179 /* MOD_VEX_71_REG_4 */
11180 { "(bad)", { XX } },
11181 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
11184 /* MOD_VEX_71_REG_6 */
11185 { "(bad)", { XX } },
11186 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
11189 /* MOD_VEX_72_REG_2 */
11190 { "(bad)", { XX } },
11191 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
11194 /* MOD_VEX_72_REG_4 */
11195 { "(bad)", { XX } },
11196 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
11199 /* MOD_VEX_72_REG_6 */
11200 { "(bad)", { XX } },
11201 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
11204 /* MOD_VEX_73_REG_2 */
11205 { "(bad)", { XX } },
11206 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
11209 /* MOD_VEX_73_REG_3 */
11210 { "(bad)", { XX } },
11211 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
11214 /* MOD_VEX_73_REG_6 */
11215 { "(bad)", { XX } },
11216 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
11219 /* MOD_VEX_73_REG_7 */
11220 { "(bad)", { XX } },
11221 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
11224 /* MOD_VEX_AE_REG_2 */
11225 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
11226 { "(bad)", { XX } },
11229 /* MOD_VEX_AE_REG_3 */
11230 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
11231 { "(bad)", { XX } },
11234 /* MOD_VEX_D7_PREFIX_2 */
11235 { "(bad)", { XX } },
11236 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
11239 /* MOD_VEX_E7_PREFIX_2 */
11240 { VEX_W_TABLE (VEX_W_E7_P_2_M_0) },
11241 { "(bad)", { XX } },
11244 /* MOD_VEX_F0_PREFIX_3 */
11245 { VEX_W_TABLE (VEX_W_F0_P_3_M_0) },
11246 { "(bad)", { XX } },
11249 /* MOD_VEX_3818_PREFIX_2 */
11250 { "vbroadcastss", { XM, Md } },
11251 { "(bad)", { XX } },
11254 /* MOD_VEX_3819_PREFIX_2 */
11255 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
11256 { "(bad)", { XX } },
11259 /* MOD_VEX_381A_PREFIX_2 */
11260 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
11261 { "(bad)", { XX } },
11264 /* MOD_VEX_382A_PREFIX_2 */
11265 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
11266 { "(bad)", { XX } },
11269 /* MOD_VEX_382C_PREFIX_2 */
11270 { "vmaskmovps", { XM, Vex, Mx } },
11271 { "(bad)", { XX } },
11274 /* MOD_VEX_382D_PREFIX_2 */
11275 { "vmaskmovpd", { XM, Vex, Mx } },
11276 { "(bad)", { XX } },
11279 /* MOD_VEX_382E_PREFIX_2 */
11280 { "vmaskmovps", { Mx, Vex, XM } },
11281 { "(bad)", { XX } },
11284 /* MOD_VEX_382F_PREFIX_2 */
11285 { "vmaskmovpd", { Mx, Vex, XM } },
11286 { "(bad)", { XX } },
11290 static const struct dis386 rm_table[][8] = {
11292 /* RM_0F01_REG_0 */
11293 { "(bad)", { XX } },
11294 { "vmcall", { Skip_MODRM } },
11295 { "vmlaunch", { Skip_MODRM } },
11296 { "vmresume", { Skip_MODRM } },
11297 { "vmxoff", { Skip_MODRM } },
11298 { "(bad)", { XX } },
11299 { "(bad)", { XX } },
11300 { "(bad)", { XX } },
11303 /* RM_0F01_REG_1 */
11304 { "monitor", { { OP_Monitor, 0 } } },
11305 { "mwait", { { OP_Mwait, 0 } } },
11306 { "(bad)", { XX } },
11307 { "(bad)", { XX } },
11308 { "(bad)", { XX } },
11309 { "(bad)", { XX } },
11310 { "(bad)", { XX } },
11311 { "(bad)", { XX } },
11314 /* RM_0F01_REG_2 */
11315 { "xgetbv", { Skip_MODRM } },
11316 { "xsetbv", { Skip_MODRM } },
11317 { "(bad)", { XX } },
11318 { "(bad)", { XX } },
11319 { "(bad)", { XX } },
11320 { "(bad)", { XX } },
11321 { "(bad)", { XX } },
11322 { "(bad)", { XX } },
11325 /* RM_0F01_REG_3 */
11326 { "vmrun", { Skip_MODRM } },
11327 { "vmmcall", { Skip_MODRM } },
11328 { "vmload", { Skip_MODRM } },
11329 { "vmsave", { Skip_MODRM } },
11330 { "stgi", { Skip_MODRM } },
11331 { "clgi", { Skip_MODRM } },
11332 { "skinit", { Skip_MODRM } },
11333 { "invlpga", { Skip_MODRM } },
11336 /* RM_0F01_REG_7 */
11337 { "swapgs", { Skip_MODRM } },
11338 { "rdtscp", { Skip_MODRM } },
11339 { "(bad)", { XX } },
11340 { "(bad)", { XX } },
11341 { "(bad)", { XX } },
11342 { "(bad)", { XX } },
11343 { "(bad)", { XX } },
11344 { "(bad)", { XX } },
11347 /* RM_0FAE_REG_5 */
11348 { "lfence", { Skip_MODRM } },
11349 { "(bad)", { XX } },
11350 { "(bad)", { XX } },
11351 { "(bad)", { XX } },
11352 { "(bad)", { XX } },
11353 { "(bad)", { XX } },
11354 { "(bad)", { XX } },
11355 { "(bad)", { XX } },
11358 /* RM_0FAE_REG_6 */
11359 { "mfence", { Skip_MODRM } },
11360 { "(bad)", { XX } },
11361 { "(bad)", { XX } },
11362 { "(bad)", { XX } },
11363 { "(bad)", { XX } },
11364 { "(bad)", { XX } },
11365 { "(bad)", { XX } },
11366 { "(bad)", { XX } },
11369 /* RM_0FAE_REG_7 */
11370 { "sfence", { Skip_MODRM } },
11371 { "(bad)", { XX } },
11372 { "(bad)", { XX } },
11373 { "(bad)", { XX } },
11374 { "(bad)", { XX } },
11375 { "(bad)", { XX } },
11376 { "(bad)", { XX } },
11377 { "(bad)", { XX } },
11381 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
11383 /* We use the high bit to indicate different name for the same
11385 #define ADDR16_PREFIX (0x67 | 0x100)
11386 #define ADDR32_PREFIX (0x67 | 0x200)
11387 #define DATA16_PREFIX (0x66 | 0x100)
11388 #define DATA32_PREFIX (0x66 | 0x200)
11389 #define REP_PREFIX (0xf3 | 0x100)
11394 int newrex, i, length;
11401 last_lock_prefix = -1;
11402 last_repz_prefix = -1;
11403 last_repnz_prefix = -1;
11404 last_data_prefix = -1;
11405 last_addr_prefix = -1;
11406 last_rex_prefix = -1;
11407 last_seg_prefix = -1;
11408 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
11409 all_prefixes[i] = 0;
11412 /* The maximum instruction length is 15bytes. */
11413 while (length < MAX_CODE_LENGTH - 1)
11415 FETCH_DATA (the_info, codep + 1);
11419 /* REX prefixes family. */
11436 if (address_mode == mode_64bit)
11440 last_rex_prefix = i;
11443 prefixes |= PREFIX_REPZ;
11444 last_repz_prefix = i;
11447 prefixes |= PREFIX_REPNZ;
11448 last_repnz_prefix = i;
11451 prefixes |= PREFIX_LOCK;
11452 last_lock_prefix = i;
11455 prefixes |= PREFIX_CS;
11456 last_seg_prefix = i;
11459 prefixes |= PREFIX_SS;
11460 last_seg_prefix = i;
11463 prefixes |= PREFIX_DS;
11464 last_seg_prefix = i;
11467 prefixes |= PREFIX_ES;
11468 last_seg_prefix = i;
11471 prefixes |= PREFIX_FS;
11472 last_seg_prefix = i;
11475 prefixes |= PREFIX_GS;
11476 last_seg_prefix = i;
11479 prefixes |= PREFIX_DATA;
11480 last_data_prefix = i;
11483 prefixes |= PREFIX_ADDR;
11484 last_addr_prefix = i;
11487 /* fwait is really an instruction. If there are prefixes
11488 before the fwait, they belong to the fwait, *not* to the
11489 following instruction. */
11490 if (prefixes || rex)
11492 prefixes |= PREFIX_FWAIT;
11496 prefixes = PREFIX_FWAIT;
11501 /* Rex is ignored when followed by another prefix. */
11507 if (*codep != FWAIT_OPCODE)
11508 all_prefixes[i++] = *codep;
11510 rex_original = rex;
11518 seg_prefix (int pref)
11539 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
11542 static const char *
11543 prefix_name (int pref, int sizeflag)
11545 static const char *rexes [16] =
11548 "rex.B", /* 0x41 */
11549 "rex.X", /* 0x42 */
11550 "rex.XB", /* 0x43 */
11551 "rex.R", /* 0x44 */
11552 "rex.RB", /* 0x45 */
11553 "rex.RX", /* 0x46 */
11554 "rex.RXB", /* 0x47 */
11555 "rex.W", /* 0x48 */
11556 "rex.WB", /* 0x49 */
11557 "rex.WX", /* 0x4a */
11558 "rex.WXB", /* 0x4b */
11559 "rex.WR", /* 0x4c */
11560 "rex.WRB", /* 0x4d */
11561 "rex.WRX", /* 0x4e */
11562 "rex.WRXB", /* 0x4f */
11567 /* REX prefixes family. */
11584 return rexes [pref - 0x40];
11604 return (sizeflag & DFLAG) ? "data16" : "data32";
11606 if (address_mode == mode_64bit)
11607 return (sizeflag & AFLAG) ? "addr32" : "addr64";
11609 return (sizeflag & AFLAG) ? "addr16" : "addr32";
11612 case ADDR16_PREFIX:
11614 case ADDR32_PREFIX:
11616 case DATA16_PREFIX:
11618 case DATA32_PREFIX:
11627 static char op_out[MAX_OPERANDS][100];
11628 static int op_ad, op_index[MAX_OPERANDS];
11629 static int two_source_ops;
11630 static bfd_vma op_address[MAX_OPERANDS];
11631 static bfd_vma op_riprel[MAX_OPERANDS];
11632 static bfd_vma start_pc;
11635 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
11636 * (see topic "Redundant prefixes" in the "Differences from 8086"
11637 * section of the "Virtual 8086 Mode" chapter.)
11638 * 'pc' should be the address of this instruction, it will
11639 * be used to print the target address if this is a relative jump or call
11640 * The function returns the length of this instruction in bytes.
11643 static char intel_syntax;
11644 static char intel_mnemonic = !SYSV386_COMPAT;
11645 static char open_char;
11646 static char close_char;
11647 static char separator_char;
11648 static char scale_char;
11650 /* Here for backwards compatibility. When gdb stops using
11651 print_insn_i386_att and print_insn_i386_intel these functions can
11652 disappear, and print_insn_i386 be merged into print_insn. */
11654 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
11658 return print_insn (pc, info);
11662 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
11666 return print_insn (pc, info);
11670 print_insn_i386 (bfd_vma pc, disassemble_info *info)
11674 return print_insn (pc, info);
11678 print_i386_disassembler_options (FILE *stream)
11680 fprintf (stream, _("\n\
11681 The following i386/x86-64 specific disassembler options are supported for use\n\
11682 with the -M switch (multiple options should be separated by commas):\n"));
11684 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
11685 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
11686 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
11687 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
11688 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
11689 fprintf (stream, _(" att-mnemonic\n"
11690 " Display instruction in AT&T mnemonic\n"));
11691 fprintf (stream, _(" intel-mnemonic\n"
11692 " Display instruction in Intel mnemonic\n"));
11693 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
11694 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
11695 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
11696 fprintf (stream, _(" data32 Assume 32bit data size\n"));
11697 fprintf (stream, _(" data16 Assume 16bit data size\n"));
11698 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
11701 /* Get a pointer to struct dis386 with a valid name. */
11703 static const struct dis386 *
11704 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
11706 int vindex, vex_table_index;
11708 if (dp->name != NULL)
11711 switch (dp->op[0].bytemode)
11713 case USE_REG_TABLE:
11714 dp = ®_table[dp->op[1].bytemode][modrm.reg];
11717 case USE_MOD_TABLE:
11718 vindex = modrm.mod == 0x3 ? 1 : 0;
11719 dp = &mod_table[dp->op[1].bytemode][vindex];
11723 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
11726 case USE_PREFIX_TABLE:
11729 /* The prefix in VEX is implicit. */
11730 switch (vex.prefix)
11735 case REPE_PREFIX_OPCODE:
11738 case DATA_PREFIX_OPCODE:
11741 case REPNE_PREFIX_OPCODE:
11752 used_prefixes |= (prefixes & PREFIX_REPZ);
11753 if (prefixes & PREFIX_REPZ)
11756 all_prefixes[last_repz_prefix] = 0;
11760 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
11762 used_prefixes |= (prefixes & PREFIX_REPNZ);
11763 if (prefixes & PREFIX_REPNZ)
11766 all_prefixes[last_repnz_prefix] = 0;
11770 used_prefixes |= (prefixes & PREFIX_DATA);
11771 if (prefixes & PREFIX_DATA)
11774 all_prefixes[last_data_prefix] = 0;
11779 dp = &prefix_table[dp->op[1].bytemode][vindex];
11782 case USE_X86_64_TABLE:
11783 vindex = address_mode == mode_64bit ? 1 : 0;
11784 dp = &x86_64_table[dp->op[1].bytemode][vindex];
11787 case USE_3BYTE_TABLE:
11788 FETCH_DATA (info, codep + 2);
11790 dp = &three_byte_table[dp->op[1].bytemode][vindex];
11791 modrm.mod = (*codep >> 6) & 3;
11792 modrm.reg = (*codep >> 3) & 7;
11793 modrm.rm = *codep & 7;
11796 case USE_VEX_LEN_TABLE:
11800 switch (vex.length)
11813 dp = &vex_len_table[dp->op[1].bytemode][vindex];
11816 case USE_XOP_8F_TABLE:
11817 FETCH_DATA (info, codep + 3);
11818 /* All bits in the REX prefix are ignored. */
11820 rex = ~(*codep >> 5) & 0x7;
11822 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11823 switch ((*codep & 0x1f))
11828 vex_table_index = XOP_08;
11831 vex_table_index = XOP_09;
11834 vex_table_index = XOP_0A;
11838 vex.w = *codep & 0x80;
11839 if (vex.w && address_mode == mode_64bit)
11842 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11843 if (address_mode != mode_64bit
11844 && vex.register_specifier > 0x7)
11847 vex.length = (*codep & 0x4) ? 256 : 128;
11848 switch ((*codep & 0x3))
11854 vex.prefix = DATA_PREFIX_OPCODE;
11857 vex.prefix = REPE_PREFIX_OPCODE;
11860 vex.prefix = REPNE_PREFIX_OPCODE;
11867 dp = &xop_table[vex_table_index][vindex];
11869 FETCH_DATA (info, codep + 1);
11870 modrm.mod = (*codep >> 6) & 3;
11871 modrm.reg = (*codep >> 3) & 7;
11872 modrm.rm = *codep & 7;
11875 case USE_VEX_C4_TABLE:
11876 FETCH_DATA (info, codep + 3);
11877 /* All bits in the REX prefix are ignored. */
11879 rex = ~(*codep >> 5) & 0x7;
11880 switch ((*codep & 0x1f))
11885 vex_table_index = VEX_0F;
11888 vex_table_index = VEX_0F38;
11891 vex_table_index = VEX_0F3A;
11895 vex.w = *codep & 0x80;
11896 if (vex.w && address_mode == mode_64bit)
11899 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11900 if (address_mode != mode_64bit
11901 && vex.register_specifier > 0x7)
11904 vex.length = (*codep & 0x4) ? 256 : 128;
11905 switch ((*codep & 0x3))
11911 vex.prefix = DATA_PREFIX_OPCODE;
11914 vex.prefix = REPE_PREFIX_OPCODE;
11917 vex.prefix = REPNE_PREFIX_OPCODE;
11924 dp = &vex_table[vex_table_index][vindex];
11925 /* There is no MODRM byte for VEX [82|77]. */
11926 if (vindex != 0x77 && vindex != 0x82)
11928 FETCH_DATA (info, codep + 1);
11929 modrm.mod = (*codep >> 6) & 3;
11930 modrm.reg = (*codep >> 3) & 7;
11931 modrm.rm = *codep & 7;
11935 case USE_VEX_C5_TABLE:
11936 FETCH_DATA (info, codep + 2);
11937 /* All bits in the REX prefix are ignored. */
11939 rex = (*codep & 0x80) ? 0 : REX_R;
11941 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11942 if (address_mode != mode_64bit
11943 && vex.register_specifier > 0x7)
11948 vex.length = (*codep & 0x4) ? 256 : 128;
11949 switch ((*codep & 0x3))
11955 vex.prefix = DATA_PREFIX_OPCODE;
11958 vex.prefix = REPE_PREFIX_OPCODE;
11961 vex.prefix = REPNE_PREFIX_OPCODE;
11968 dp = &vex_table[dp->op[1].bytemode][vindex];
11969 /* There is no MODRM byte for VEX [82|77]. */
11970 if (vindex != 0x77 && vindex != 0x82)
11972 FETCH_DATA (info, codep + 1);
11973 modrm.mod = (*codep >> 6) & 3;
11974 modrm.reg = (*codep >> 3) & 7;
11975 modrm.rm = *codep & 7;
11979 case USE_VEX_W_TABLE:
11983 dp = &vex_w_table[dp->op[1].bytemode][vex.w ? 1 : 0];
11990 if (dp->name != NULL)
11993 return get_valid_dis386 (dp, info);
11997 print_insn (bfd_vma pc, disassemble_info *info)
11999 const struct dis386 *dp;
12001 char *op_txt[MAX_OPERANDS];
12005 struct dis_private priv;
12008 int default_prefixes;
12010 if (info->mach == bfd_mach_x86_64_intel_syntax
12011 || info->mach == bfd_mach_x86_64
12012 || info->mach == bfd_mach_l1om
12013 || info->mach == bfd_mach_l1om_intel_syntax)
12014 address_mode = mode_64bit;
12016 address_mode = mode_32bit;
12018 if (intel_syntax == (char) -1)
12019 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
12020 || info->mach == bfd_mach_x86_64_intel_syntax
12021 || info->mach == bfd_mach_l1om_intel_syntax);
12023 if (info->mach == bfd_mach_i386_i386
12024 || info->mach == bfd_mach_x86_64
12025 || info->mach == bfd_mach_l1om
12026 || info->mach == bfd_mach_i386_i386_intel_syntax
12027 || info->mach == bfd_mach_x86_64_intel_syntax
12028 || info->mach == bfd_mach_l1om_intel_syntax)
12029 priv.orig_sizeflag = AFLAG | DFLAG;
12030 else if (info->mach == bfd_mach_i386_i8086)
12031 priv.orig_sizeflag = 0;
12035 for (p = info->disassembler_options; p != NULL; )
12037 if (CONST_STRNEQ (p, "x86-64"))
12039 address_mode = mode_64bit;
12040 priv.orig_sizeflag = AFLAG | DFLAG;
12042 else if (CONST_STRNEQ (p, "i386"))
12044 address_mode = mode_32bit;
12045 priv.orig_sizeflag = AFLAG | DFLAG;
12047 else if (CONST_STRNEQ (p, "i8086"))
12049 address_mode = mode_16bit;
12050 priv.orig_sizeflag = 0;
12052 else if (CONST_STRNEQ (p, "intel"))
12055 if (CONST_STRNEQ (p + 5, "-mnemonic"))
12056 intel_mnemonic = 1;
12058 else if (CONST_STRNEQ (p, "att"))
12061 if (CONST_STRNEQ (p + 3, "-mnemonic"))
12062 intel_mnemonic = 0;
12064 else if (CONST_STRNEQ (p, "addr"))
12066 if (address_mode == mode_64bit)
12068 if (p[4] == '3' && p[5] == '2')
12069 priv.orig_sizeflag &= ~AFLAG;
12070 else if (p[4] == '6' && p[5] == '4')
12071 priv.orig_sizeflag |= AFLAG;
12075 if (p[4] == '1' && p[5] == '6')
12076 priv.orig_sizeflag &= ~AFLAG;
12077 else if (p[4] == '3' && p[5] == '2')
12078 priv.orig_sizeflag |= AFLAG;
12081 else if (CONST_STRNEQ (p, "data"))
12083 if (p[4] == '1' && p[5] == '6')
12084 priv.orig_sizeflag &= ~DFLAG;
12085 else if (p[4] == '3' && p[5] == '2')
12086 priv.orig_sizeflag |= DFLAG;
12088 else if (CONST_STRNEQ (p, "suffix"))
12089 priv.orig_sizeflag |= SUFFIX_ALWAYS;
12091 p = strchr (p, ',');
12098 names64 = intel_names64;
12099 names32 = intel_names32;
12100 names16 = intel_names16;
12101 names8 = intel_names8;
12102 names8rex = intel_names8rex;
12103 names_seg = intel_names_seg;
12104 index64 = intel_index64;
12105 index32 = intel_index32;
12106 index16 = intel_index16;
12109 separator_char = '+';
12114 names64 = att_names64;
12115 names32 = att_names32;
12116 names16 = att_names16;
12117 names8 = att_names8;
12118 names8rex = att_names8rex;
12119 names_seg = att_names_seg;
12120 index64 = att_index64;
12121 index32 = att_index32;
12122 index16 = att_index16;
12125 separator_char = ',';
12129 /* The output looks better if we put 7 bytes on a line, since that
12130 puts most long word instructions on a single line. Use 8 bytes
12132 if (info->mach == bfd_mach_l1om
12133 || info->mach == bfd_mach_l1om_intel_syntax)
12134 info->bytes_per_line = 8;
12136 info->bytes_per_line = 7;
12138 info->private_data = &priv;
12139 priv.max_fetched = priv.the_buffer;
12140 priv.insn_start = pc;
12143 for (i = 0; i < MAX_OPERANDS; ++i)
12151 start_codep = priv.the_buffer;
12152 codep = priv.the_buffer;
12154 if (setjmp (priv.bailout) != 0)
12158 /* Getting here means we tried for data but didn't get it. That
12159 means we have an incomplete instruction of some sort. Just
12160 print the first byte as a prefix or a .byte pseudo-op. */
12161 if (codep > priv.the_buffer)
12163 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
12165 (*info->fprintf_func) (info->stream, "%s", name);
12168 /* Just print the first byte as a .byte instruction. */
12169 (*info->fprintf_func) (info->stream, ".byte 0x%x",
12170 (unsigned int) priv.the_buffer[0]);
12180 sizeflag = priv.orig_sizeflag;
12182 if (!ckprefix () || rex_used)
12184 /* Too many prefixes or unused REX prefixes. */
12186 all_prefixes[i] && i < (int) ARRAY_SIZE (all_prefixes);
12188 (*info->fprintf_func) (info->stream, "%s",
12189 prefix_name (all_prefixes[i], sizeflag));
12193 insn_codep = codep;
12195 FETCH_DATA (info, codep + 1);
12196 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
12198 if (((prefixes & PREFIX_FWAIT)
12199 && ((*codep < 0xd8) || (*codep > 0xdf))))
12201 (*info->fprintf_func) (info->stream, "fwait");
12207 if (*codep == 0x0f)
12209 unsigned char threebyte;
12210 FETCH_DATA (info, codep + 2);
12211 threebyte = *++codep;
12212 dp = &dis386_twobyte[threebyte];
12213 need_modrm = twobyte_has_modrm[*codep];
12218 dp = &dis386[*codep];
12219 need_modrm = onebyte_has_modrm[*codep];
12223 if ((prefixes & PREFIX_REPZ))
12224 used_prefixes |= PREFIX_REPZ;
12225 if ((prefixes & PREFIX_REPNZ))
12226 used_prefixes |= PREFIX_REPNZ;
12227 if ((prefixes & PREFIX_LOCK))
12228 used_prefixes |= PREFIX_LOCK;
12230 default_prefixes = 0;
12231 if (prefixes & PREFIX_ADDR)
12234 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
12236 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12237 all_prefixes[last_addr_prefix] = ADDR32_PREFIX;
12239 all_prefixes[last_addr_prefix] = ADDR16_PREFIX;
12240 default_prefixes |= PREFIX_ADDR;
12244 if ((prefixes & PREFIX_DATA))
12247 if (dp->op[2].bytemode == cond_jump_mode
12248 && dp->op[0].bytemode == v_mode
12251 if (sizeflag & DFLAG)
12252 all_prefixes[last_data_prefix] = DATA32_PREFIX;
12254 all_prefixes[last_data_prefix] = DATA16_PREFIX;
12255 default_prefixes |= PREFIX_DATA;
12257 else if (rex & REX_W)
12259 /* REX_W will override PREFIX_DATA. */
12260 default_prefixes |= PREFIX_DATA;
12266 FETCH_DATA (info, codep + 1);
12267 modrm.mod = (*codep >> 6) & 3;
12268 modrm.reg = (*codep >> 3) & 7;
12269 modrm.rm = *codep & 7;
12276 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
12278 dofloat (sizeflag);
12282 dp = get_valid_dis386 (dp, info);
12283 if (dp != NULL && putop (dp->name, sizeflag) == 0)
12285 for (i = 0; i < MAX_OPERANDS; ++i)
12288 op_ad = MAX_OPERANDS - 1 - i;
12290 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
12295 /* See if any prefixes were not used. If so, print the first one
12296 separately. If we don't do this, we'll wind up printing an
12297 instruction stream which does not precisely correspond to the
12298 bytes we are disassembling. */
12299 if ((prefixes & ~(used_prefixes | default_prefixes)) != 0)
12301 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12302 if (all_prefixes[i])
12305 name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
12307 name = INTERNAL_DISASSEMBLER_ERROR;
12308 (*info->fprintf_func) (info->stream, "%s", name);
12313 /* Check if the REX prefix used. */
12314 if (rex_ignored == 0 && (rex ^ rex_used) == 0)
12315 all_prefixes[last_rex_prefix] = 0;
12317 /* Check if the SEG prefix used. */
12318 if ((prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
12319 | PREFIX_FS | PREFIX_GS)) != 0
12321 & seg_prefix (all_prefixes[last_seg_prefix])) != 0)
12322 all_prefixes[last_seg_prefix] = 0;
12324 /* Check if the ADDR prefix used. */
12325 if ((prefixes & PREFIX_ADDR) != 0
12326 && (used_prefixes & PREFIX_ADDR) != 0)
12327 all_prefixes[last_addr_prefix] = 0;
12329 /* Check if the DATA prefix used. */
12330 if ((prefixes & PREFIX_DATA) != 0
12331 && (used_prefixes & PREFIX_DATA) != 0)
12332 all_prefixes[last_data_prefix] = 0;
12335 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12336 if (all_prefixes[i])
12339 name = prefix_name (all_prefixes[i], sizeflag);
12342 prefix_length += strlen (name) + 1;
12343 (*info->fprintf_func) (info->stream, "%s ", name);
12346 /* Check maximum code length. */
12347 if ((codep - start_codep) > MAX_CODE_LENGTH)
12349 (*info->fprintf_func) (info->stream, "(bad)");
12350 return MAX_CODE_LENGTH;
12353 obufp = mnemonicendp;
12354 for (i = strlen (obuf) + prefix_length; i < 6; i++)
12357 (*info->fprintf_func) (info->stream, "%s", obuf);
12359 /* The enter and bound instructions are printed with operands in the same
12360 order as the intel book; everything else is printed in reverse order. */
12361 if (intel_syntax || two_source_ops)
12365 for (i = 0; i < MAX_OPERANDS; ++i)
12366 op_txt[i] = op_out[i];
12368 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
12370 op_ad = op_index[i];
12371 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
12372 op_index[MAX_OPERANDS - 1 - i] = op_ad;
12373 riprel = op_riprel[i];
12374 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
12375 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
12380 for (i = 0; i < MAX_OPERANDS; ++i)
12381 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
12385 for (i = 0; i < MAX_OPERANDS; ++i)
12389 (*info->fprintf_func) (info->stream, ",");
12390 if (op_index[i] != -1 && !op_riprel[i])
12391 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
12393 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
12397 for (i = 0; i < MAX_OPERANDS; i++)
12398 if (op_index[i] != -1 && op_riprel[i])
12400 (*info->fprintf_func) (info->stream, " # ");
12401 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
12402 + op_address[op_index[i]]), info);
12405 return codep - priv.the_buffer;
12408 static const char *float_mem[] = {
12483 static const unsigned char float_mem_mode[] = {
12558 #define ST { OP_ST, 0 }
12559 #define STi { OP_STi, 0 }
12561 #define FGRPd9_2 NULL, { { NULL, 0 } }
12562 #define FGRPd9_4 NULL, { { NULL, 1 } }
12563 #define FGRPd9_5 NULL, { { NULL, 2 } }
12564 #define FGRPd9_6 NULL, { { NULL, 3 } }
12565 #define FGRPd9_7 NULL, { { NULL, 4 } }
12566 #define FGRPda_5 NULL, { { NULL, 5 } }
12567 #define FGRPdb_4 NULL, { { NULL, 6 } }
12568 #define FGRPde_3 NULL, { { NULL, 7 } }
12569 #define FGRPdf_4 NULL, { { NULL, 8 } }
12571 static const struct dis386 float_reg[][8] = {
12574 { "fadd", { ST, STi } },
12575 { "fmul", { ST, STi } },
12576 { "fcom", { STi } },
12577 { "fcomp", { STi } },
12578 { "fsub", { ST, STi } },
12579 { "fsubr", { ST, STi } },
12580 { "fdiv", { ST, STi } },
12581 { "fdivr", { ST, STi } },
12585 { "fld", { STi } },
12586 { "fxch", { STi } },
12588 { "(bad)", { XX } },
12596 { "fcmovb", { ST, STi } },
12597 { "fcmove", { ST, STi } },
12598 { "fcmovbe",{ ST, STi } },
12599 { "fcmovu", { ST, STi } },
12600 { "(bad)", { XX } },
12602 { "(bad)", { XX } },
12603 { "(bad)", { XX } },
12607 { "fcmovnb",{ ST, STi } },
12608 { "fcmovne",{ ST, STi } },
12609 { "fcmovnbe",{ ST, STi } },
12610 { "fcmovnu",{ ST, STi } },
12612 { "fucomi", { ST, STi } },
12613 { "fcomi", { ST, STi } },
12614 { "(bad)", { XX } },
12618 { "fadd", { STi, ST } },
12619 { "fmul", { STi, ST } },
12620 { "(bad)", { XX } },
12621 { "(bad)", { XX } },
12622 { "fsub!M", { STi, ST } },
12623 { "fsubM", { STi, ST } },
12624 { "fdiv!M", { STi, ST } },
12625 { "fdivM", { STi, ST } },
12629 { "ffree", { STi } },
12630 { "(bad)", { XX } },
12631 { "fst", { STi } },
12632 { "fstp", { STi } },
12633 { "fucom", { STi } },
12634 { "fucomp", { STi } },
12635 { "(bad)", { XX } },
12636 { "(bad)", { XX } },
12640 { "faddp", { STi, ST } },
12641 { "fmulp", { STi, ST } },
12642 { "(bad)", { XX } },
12644 { "fsub!Mp", { STi, ST } },
12645 { "fsubMp", { STi, ST } },
12646 { "fdiv!Mp", { STi, ST } },
12647 { "fdivMp", { STi, ST } },
12651 { "ffreep", { STi } },
12652 { "(bad)", { XX } },
12653 { "(bad)", { XX } },
12654 { "(bad)", { XX } },
12656 { "fucomip", { ST, STi } },
12657 { "fcomip", { ST, STi } },
12658 { "(bad)", { XX } },
12662 static char *fgrps[][8] = {
12665 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12670 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
12675 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
12680 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
12685 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
12690 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12695 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
12696 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
12701 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12706 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12711 swap_operand (void)
12713 mnemonicendp[0] = '.';
12714 mnemonicendp[1] = 's';
12719 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
12720 int sizeflag ATTRIBUTE_UNUSED)
12722 /* Skip mod/rm byte. */
12728 dofloat (int sizeflag)
12730 const struct dis386 *dp;
12731 unsigned char floatop;
12733 floatop = codep[-1];
12735 if (modrm.mod != 3)
12737 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
12739 putop (float_mem[fp_indx], sizeflag);
12742 OP_E (float_mem_mode[fp_indx], sizeflag);
12745 /* Skip mod/rm byte. */
12749 dp = &float_reg[floatop - 0xd8][modrm.reg];
12750 if (dp->name == NULL)
12752 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
12754 /* Instruction fnstsw is only one with strange arg. */
12755 if (floatop == 0xdf && codep[-1] == 0xe0)
12756 strcpy (op_out[0], names16[0]);
12760 putop (dp->name, sizeflag);
12765 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
12770 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
12775 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12777 oappend ("%st" + intel_syntax);
12781 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12783 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
12784 oappend (scratchbuf + intel_syntax);
12787 /* Capital letters in template are macros. */
12789 putop (const char *in_template, int sizeflag)
12794 unsigned int l = 0, len = 1;
12797 #define SAVE_LAST(c) \
12798 if (l < len && l < sizeof (last)) \
12803 for (p = in_template; *p; p++)
12820 while (*++p != '|')
12821 if (*p == '}' || *p == '\0')
12824 /* Fall through. */
12829 while (*++p != '}')
12840 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
12844 if (l == 0 && len == 1)
12849 if (sizeflag & SUFFIX_ALWAYS)
12862 if (address_mode == mode_64bit
12863 && !(prefixes & PREFIX_ADDR))
12874 if (intel_syntax && !alt)
12876 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
12878 if (sizeflag & DFLAG)
12879 *obufp++ = intel_syntax ? 'd' : 'l';
12881 *obufp++ = intel_syntax ? 'w' : 's';
12882 used_prefixes |= (prefixes & PREFIX_DATA);
12886 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
12889 if (modrm.mod == 3)
12895 if (sizeflag & DFLAG)
12896 *obufp++ = intel_syntax ? 'd' : 'l';
12899 used_prefixes |= (prefixes & PREFIX_DATA);
12905 case 'E': /* For jcxz/jecxz */
12906 if (address_mode == mode_64bit)
12908 if (sizeflag & AFLAG)
12914 if (sizeflag & AFLAG)
12916 used_prefixes |= (prefixes & PREFIX_ADDR);
12921 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
12923 if (sizeflag & AFLAG)
12924 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
12926 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
12927 used_prefixes |= (prefixes & PREFIX_ADDR);
12931 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
12933 if ((rex & REX_W) || (sizeflag & DFLAG))
12937 if (!(rex & REX_W))
12938 used_prefixes |= (prefixes & PREFIX_DATA);
12943 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
12944 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
12946 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
12949 if (prefixes & PREFIX_DS)
12970 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
12975 /* Fall through. */
12978 if (l != 0 || len != 1)
12986 if (sizeflag & SUFFIX_ALWAYS)
12990 if (intel_mnemonic != cond)
12994 if ((prefixes & PREFIX_FWAIT) == 0)
12997 used_prefixes |= PREFIX_FWAIT;
13003 else if (intel_syntax && (sizeflag & DFLAG))
13007 if (!(rex & REX_W))
13008 used_prefixes |= (prefixes & PREFIX_DATA);
13013 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13018 /* Fall through. */
13022 if ((prefixes & PREFIX_DATA)
13024 || (sizeflag & SUFFIX_ALWAYS))
13031 if (sizeflag & DFLAG)
13035 used_prefixes |= (prefixes & PREFIX_DATA);
13042 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13044 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13048 /* Fall through. */
13051 if (l == 0 && len == 1)
13054 if (intel_syntax && !alt)
13057 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13063 if (sizeflag & DFLAG)
13064 *obufp++ = intel_syntax ? 'd' : 'l';
13067 used_prefixes |= (prefixes & PREFIX_DATA);
13073 if (l != 1 || len != 2 || last[0] != 'L')
13079 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13094 else if (sizeflag & DFLAG)
13103 if (intel_syntax && !p[1]
13104 && ((rex & REX_W) || (sizeflag & DFLAG)))
13106 if (!(rex & REX_W))
13107 used_prefixes |= (prefixes & PREFIX_DATA);
13110 if (l == 0 && len == 1)
13114 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13116 if (sizeflag & SUFFIX_ALWAYS)
13138 /* Fall through. */
13141 if (l == 0 && len == 1)
13146 if (sizeflag & SUFFIX_ALWAYS)
13152 if (sizeflag & DFLAG)
13156 used_prefixes |= (prefixes & PREFIX_DATA);
13170 if (address_mode == mode_64bit
13171 && !(prefixes & PREFIX_ADDR))
13182 if (l != 0 || len != 1)
13187 if (need_vex && vex.prefix)
13189 if (vex.prefix == DATA_PREFIX_OPCODE)
13196 if (prefixes & PREFIX_DATA)
13200 used_prefixes |= (prefixes & PREFIX_DATA);
13204 if (l == 0 && len == 1)
13206 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
13217 if (l != 1 || len != 2 || last[0] != 'X')
13225 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13227 switch (vex.length)
13241 if (l == 0 && len == 1)
13243 /* operand size flag for cwtl, cbtw */
13252 else if (sizeflag & DFLAG)
13256 if (!(rex & REX_W))
13257 used_prefixes |= (prefixes & PREFIX_DATA);
13261 if (l != 1 || len != 2 || last[0] != 'X')
13268 *obufp++ = vex.w ? 'd': 's';
13275 mnemonicendp = obufp;
13280 oappend (const char *s)
13282 obufp = stpcpy (obufp, s);
13288 if (prefixes & PREFIX_CS)
13290 used_prefixes |= PREFIX_CS;
13291 oappend ("%cs:" + intel_syntax);
13293 if (prefixes & PREFIX_DS)
13295 used_prefixes |= PREFIX_DS;
13296 oappend ("%ds:" + intel_syntax);
13298 if (prefixes & PREFIX_SS)
13300 used_prefixes |= PREFIX_SS;
13301 oappend ("%ss:" + intel_syntax);
13303 if (prefixes & PREFIX_ES)
13305 used_prefixes |= PREFIX_ES;
13306 oappend ("%es:" + intel_syntax);
13308 if (prefixes & PREFIX_FS)
13310 used_prefixes |= PREFIX_FS;
13311 oappend ("%fs:" + intel_syntax);
13313 if (prefixes & PREFIX_GS)
13315 used_prefixes |= PREFIX_GS;
13316 oappend ("%gs:" + intel_syntax);
13321 OP_indirE (int bytemode, int sizeflag)
13325 OP_E (bytemode, sizeflag);
13329 print_operand_value (char *buf, int hex, bfd_vma disp)
13331 if (address_mode == mode_64bit)
13339 sprintf_vma (tmp, disp);
13340 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
13341 strcpy (buf + 2, tmp + i);
13345 bfd_signed_vma v = disp;
13352 /* Check for possible overflow on 0x8000000000000000. */
13355 strcpy (buf, "9223372036854775808");
13369 tmp[28 - i] = (v % 10) + '0';
13373 strcpy (buf, tmp + 29 - i);
13379 sprintf (buf, "0x%x", (unsigned int) disp);
13381 sprintf (buf, "%d", (int) disp);
13385 /* Put DISP in BUF as signed hex number. */
13388 print_displacement (char *buf, bfd_vma disp)
13390 bfd_signed_vma val = disp;
13399 /* Check for possible overflow. */
13402 switch (address_mode)
13405 strcpy (buf + j, "0x8000000000000000");
13408 strcpy (buf + j, "0x80000000");
13411 strcpy (buf + j, "0x8000");
13421 sprintf_vma (tmp, (bfd_vma) val);
13422 for (i = 0; tmp[i] == '0'; i++)
13424 if (tmp[i] == '\0')
13426 strcpy (buf + j, tmp + i);
13430 intel_operand_size (int bytemode, int sizeflag)
13437 oappend ("BYTE PTR ");
13441 oappend ("WORD PTR ");
13444 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13446 oappend ("QWORD PTR ");
13455 oappend ("QWORD PTR ");
13458 if ((sizeflag & DFLAG) || bytemode == dq_mode)
13459 oappend ("DWORD PTR ");
13461 oappend ("WORD PTR ");
13462 used_prefixes |= (prefixes & PREFIX_DATA);
13466 if ((rex & REX_W) || (sizeflag & DFLAG))
13468 oappend ("WORD PTR ");
13469 if (!(rex & REX_W))
13470 used_prefixes |= (prefixes & PREFIX_DATA);
13473 if (sizeflag & DFLAG)
13474 oappend ("QWORD PTR ");
13476 oappend ("DWORD PTR ");
13477 used_prefixes |= (prefixes & PREFIX_DATA);
13482 oappend ("DWORD PTR ");
13486 oappend ("QWORD PTR ");
13489 if (address_mode == mode_64bit)
13490 oappend ("QWORD PTR ");
13492 oappend ("DWORD PTR ");
13495 if (sizeflag & DFLAG)
13496 oappend ("FWORD PTR ");
13498 oappend ("DWORD PTR ");
13499 used_prefixes |= (prefixes & PREFIX_DATA);
13502 oappend ("TBYTE PTR ");
13508 switch (vex.length)
13511 oappend ("XMMWORD PTR ");
13514 oappend ("YMMWORD PTR ");
13521 oappend ("XMMWORD PTR ");
13524 oappend ("XMMWORD PTR ");
13530 switch (vex.length)
13533 oappend ("QWORD PTR ");
13536 oappend ("XMMWORD PTR ");
13546 switch (vex.length)
13549 oappend ("QWORD PTR ");
13552 oappend ("YMMWORD PTR ");
13559 oappend ("OWORD PTR ");
13561 case vex_w_dq_mode:
13566 oappend ("QWORD PTR ");
13568 oappend ("DWORD PTR ");
13576 OP_E_register (int bytemode, int sizeflag)
13578 int reg = modrm.rm;
13579 const char **names;
13585 if ((sizeflag & SUFFIX_ALWAYS)
13586 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
13609 names = address_mode == mode_64bit ? names64 : names32;
13612 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13630 if ((sizeflag & DFLAG)
13631 || (bytemode != v_mode
13632 && bytemode != v_swap_mode))
13636 used_prefixes |= (prefixes & PREFIX_DATA);
13642 oappend (INTERNAL_DISASSEMBLER_ERROR);
13645 oappend (names[reg]);
13649 OP_E_memory (int bytemode, int sizeflag)
13652 int add = (rex & REX_B) ? 8 : 0;
13657 intel_operand_size (bytemode, sizeflag);
13660 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13662 /* 32/64 bit address mode */
13680 FETCH_DATA (the_info, codep + 1);
13681 vindex = (*codep >> 3) & 7;
13682 scale = (*codep >> 6) & 3;
13687 haveindex = vindex != 4;
13690 rbase = base + add;
13698 if (address_mode == mode_64bit && !havesib)
13704 FETCH_DATA (the_info, codep + 1);
13706 if ((disp & 0x80) != 0)
13714 /* In 32bit mode, we need index register to tell [offset] from
13715 [eiz*1 + offset]. */
13716 needindex = (havesib
13719 && address_mode == mode_32bit);
13720 havedisp = (havebase
13722 || (havesib && (haveindex || scale != 0)));
13725 if (modrm.mod != 0 || base == 5)
13727 if (havedisp || riprel)
13728 print_displacement (scratchbuf, disp);
13730 print_operand_value (scratchbuf, 1, disp);
13731 oappend (scratchbuf);
13735 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
13739 if (havebase || haveindex || riprel)
13740 used_prefixes |= PREFIX_ADDR;
13742 if (havedisp || (intel_syntax && riprel))
13744 *obufp++ = open_char;
13745 if (intel_syntax && riprel)
13748 oappend (sizeflag & AFLAG ? "rip" : "eip");
13752 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
13753 ? names64[rbase] : names32[rbase]);
13756 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13757 print index to tell base + index from base. */
13761 || (havebase && base != ESP_REG_NUM))
13763 if (!intel_syntax || havebase)
13765 *obufp++ = separator_char;
13769 oappend (address_mode == mode_64bit
13770 && (sizeflag & AFLAG)
13771 ? names64[vindex] : names32[vindex]);
13773 oappend (address_mode == mode_64bit
13774 && (sizeflag & AFLAG)
13775 ? index64 : index32);
13777 *obufp++ = scale_char;
13779 sprintf (scratchbuf, "%d", 1 << scale);
13780 oappend (scratchbuf);
13784 && (disp || modrm.mod != 0 || base == 5))
13786 if (!havedisp || (bfd_signed_vma) disp >= 0)
13791 else if (modrm.mod != 1 && disp != -disp)
13795 disp = - (bfd_signed_vma) disp;
13799 print_displacement (scratchbuf, disp);
13801 print_operand_value (scratchbuf, 1, disp);
13802 oappend (scratchbuf);
13805 *obufp++ = close_char;
13808 else if (intel_syntax)
13810 if (modrm.mod != 0 || base == 5)
13812 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13813 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13817 oappend (names_seg[ds_reg - es_reg]);
13820 print_operand_value (scratchbuf, 1, disp);
13821 oappend (scratchbuf);
13827 /* 16 bit address mode */
13828 used_prefixes |= prefixes & PREFIX_ADDR;
13835 if ((disp & 0x8000) != 0)
13840 FETCH_DATA (the_info, codep + 1);
13842 if ((disp & 0x80) != 0)
13847 if ((disp & 0x8000) != 0)
13853 if (modrm.mod != 0 || modrm.rm == 6)
13855 print_displacement (scratchbuf, disp);
13856 oappend (scratchbuf);
13859 if (modrm.mod != 0 || modrm.rm != 6)
13861 *obufp++ = open_char;
13863 oappend (index16[modrm.rm]);
13865 && (disp || modrm.mod != 0 || modrm.rm == 6))
13867 if ((bfd_signed_vma) disp >= 0)
13872 else if (modrm.mod != 1)
13876 disp = - (bfd_signed_vma) disp;
13879 print_displacement (scratchbuf, disp);
13880 oappend (scratchbuf);
13883 *obufp++ = close_char;
13886 else if (intel_syntax)
13888 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13889 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13893 oappend (names_seg[ds_reg - es_reg]);
13896 print_operand_value (scratchbuf, 1, disp & 0xffff);
13897 oappend (scratchbuf);
13903 OP_E (int bytemode, int sizeflag)
13905 /* Skip mod/rm byte. */
13909 if (modrm.mod == 3)
13910 OP_E_register (bytemode, sizeflag);
13912 OP_E_memory (bytemode, sizeflag);
13916 OP_G (int bytemode, int sizeflag)
13927 oappend (names8rex[modrm.reg + add]);
13929 oappend (names8[modrm.reg + add]);
13932 oappend (names16[modrm.reg + add]);
13935 oappend (names32[modrm.reg + add]);
13938 oappend (names64[modrm.reg + add]);
13947 oappend (names64[modrm.reg + add]);
13950 if ((sizeflag & DFLAG) || bytemode != v_mode)
13951 oappend (names32[modrm.reg + add]);
13953 oappend (names16[modrm.reg + add]);
13954 used_prefixes |= (prefixes & PREFIX_DATA);
13958 if (address_mode == mode_64bit)
13959 oappend (names64[modrm.reg + add]);
13961 oappend (names32[modrm.reg + add]);
13964 oappend (INTERNAL_DISASSEMBLER_ERROR);
13977 FETCH_DATA (the_info, codep + 8);
13978 a = *codep++ & 0xff;
13979 a |= (*codep++ & 0xff) << 8;
13980 a |= (*codep++ & 0xff) << 16;
13981 a |= (*codep++ & 0xff) << 24;
13982 b = *codep++ & 0xff;
13983 b |= (*codep++ & 0xff) << 8;
13984 b |= (*codep++ & 0xff) << 16;
13985 b |= (*codep++ & 0xff) << 24;
13986 x = a + ((bfd_vma) b << 32);
13994 static bfd_signed_vma
13997 bfd_signed_vma x = 0;
13999 FETCH_DATA (the_info, codep + 4);
14000 x = *codep++ & (bfd_signed_vma) 0xff;
14001 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14002 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14003 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14007 static bfd_signed_vma
14010 bfd_signed_vma x = 0;
14012 FETCH_DATA (the_info, codep + 4);
14013 x = *codep++ & (bfd_signed_vma) 0xff;
14014 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14015 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14016 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14018 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
14028 FETCH_DATA (the_info, codep + 2);
14029 x = *codep++ & 0xff;
14030 x |= (*codep++ & 0xff) << 8;
14035 set_op (bfd_vma op, int riprel)
14037 op_index[op_ad] = op_ad;
14038 if (address_mode == mode_64bit)
14040 op_address[op_ad] = op;
14041 op_riprel[op_ad] = riprel;
14045 /* Mask to get a 32-bit address. */
14046 op_address[op_ad] = op & 0xffffffff;
14047 op_riprel[op_ad] = riprel & 0xffffffff;
14052 OP_REG (int code, int sizeflag)
14064 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14065 case sp_reg: case bp_reg: case si_reg: case di_reg:
14066 s = names16[code - ax_reg + add];
14068 case es_reg: case ss_reg: case cs_reg:
14069 case ds_reg: case fs_reg: case gs_reg:
14070 s = names_seg[code - es_reg + add];
14072 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14073 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14076 s = names8rex[code - al_reg + add];
14078 s = names8[code - al_reg];
14080 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
14081 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
14082 if (address_mode == mode_64bit && (sizeflag & DFLAG))
14084 s = names64[code - rAX_reg + add];
14087 code += eAX_reg - rAX_reg;
14088 /* Fall through. */
14089 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14090 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14093 s = names64[code - eAX_reg + add];
14096 if (sizeflag & DFLAG)
14097 s = names32[code - eAX_reg + add];
14099 s = names16[code - eAX_reg + add];
14100 used_prefixes |= (prefixes & PREFIX_DATA);
14104 s = INTERNAL_DISASSEMBLER_ERROR;
14111 OP_IMREG (int code, int sizeflag)
14123 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14124 case sp_reg: case bp_reg: case si_reg: case di_reg:
14125 s = names16[code - ax_reg];
14127 case es_reg: case ss_reg: case cs_reg:
14128 case ds_reg: case fs_reg: case gs_reg:
14129 s = names_seg[code - es_reg];
14131 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14132 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14135 s = names8rex[code - al_reg];
14137 s = names8[code - al_reg];
14139 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14140 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14143 s = names64[code - eAX_reg];
14146 if (sizeflag & DFLAG)
14147 s = names32[code - eAX_reg];
14149 s = names16[code - eAX_reg];
14150 used_prefixes |= (prefixes & PREFIX_DATA);
14153 case z_mode_ax_reg:
14154 if ((rex & REX_W) || (sizeflag & DFLAG))
14158 if (!(rex & REX_W))
14159 used_prefixes |= (prefixes & PREFIX_DATA);
14162 s = INTERNAL_DISASSEMBLER_ERROR;
14169 OP_I (int bytemode, int sizeflag)
14172 bfd_signed_vma mask = -1;
14177 FETCH_DATA (the_info, codep + 1);
14182 if (address_mode == mode_64bit)
14187 /* Fall through. */
14194 if (sizeflag & DFLAG)
14204 used_prefixes |= (prefixes & PREFIX_DATA);
14216 oappend (INTERNAL_DISASSEMBLER_ERROR);
14221 scratchbuf[0] = '$';
14222 print_operand_value (scratchbuf + 1, 1, op);
14223 oappend (scratchbuf + intel_syntax);
14224 scratchbuf[0] = '\0';
14228 OP_I64 (int bytemode, int sizeflag)
14231 bfd_signed_vma mask = -1;
14233 if (address_mode != mode_64bit)
14235 OP_I (bytemode, sizeflag);
14242 FETCH_DATA (the_info, codep + 1);
14252 if (sizeflag & DFLAG)
14262 used_prefixes |= (prefixes & PREFIX_DATA);
14270 oappend (INTERNAL_DISASSEMBLER_ERROR);
14275 scratchbuf[0] = '$';
14276 print_operand_value (scratchbuf + 1, 1, op);
14277 oappend (scratchbuf + intel_syntax);
14278 scratchbuf[0] = '\0';
14282 OP_sI (int bytemode, int sizeflag)
14285 bfd_signed_vma mask = -1;
14290 FETCH_DATA (the_info, codep + 1);
14292 if ((op & 0x80) != 0)
14302 if (sizeflag & DFLAG)
14311 if ((op & 0x8000) != 0)
14314 used_prefixes |= (prefixes & PREFIX_DATA);
14320 if ((op & 0x8000) != 0)
14324 oappend (INTERNAL_DISASSEMBLER_ERROR);
14328 scratchbuf[0] = '$';
14329 print_operand_value (scratchbuf + 1, 1, op);
14330 oappend (scratchbuf + intel_syntax);
14334 OP_J (int bytemode, int sizeflag)
14338 bfd_vma segment = 0;
14343 FETCH_DATA (the_info, codep + 1);
14345 if ((disp & 0x80) != 0)
14350 if ((sizeflag & DFLAG) || (rex & REX_W))
14355 if ((disp & 0x8000) != 0)
14357 /* In 16bit mode, address is wrapped around at 64k within
14358 the same segment. Otherwise, a data16 prefix on a jump
14359 instruction means that the pc is masked to 16 bits after
14360 the displacement is added! */
14362 if ((prefixes & PREFIX_DATA) == 0)
14363 segment = ((start_pc + codep - start_codep)
14364 & ~((bfd_vma) 0xffff));
14366 if (!(rex & REX_W))
14367 used_prefixes |= (prefixes & PREFIX_DATA);
14370 oappend (INTERNAL_DISASSEMBLER_ERROR);
14373 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
14375 print_operand_value (scratchbuf, 1, disp);
14376 oappend (scratchbuf);
14380 OP_SEG (int bytemode, int sizeflag)
14382 if (bytemode == w_mode)
14383 oappend (names_seg[modrm.reg]);
14385 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
14389 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
14393 if (sizeflag & DFLAG)
14403 used_prefixes |= (prefixes & PREFIX_DATA);
14405 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
14407 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
14408 oappend (scratchbuf);
14412 OP_OFF (int bytemode, int sizeflag)
14416 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14417 intel_operand_size (bytemode, sizeflag);
14420 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
14427 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14428 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14430 oappend (names_seg[ds_reg - es_reg]);
14434 print_operand_value (scratchbuf, 1, off);
14435 oappend (scratchbuf);
14439 OP_OFF64 (int bytemode, int sizeflag)
14443 if (address_mode != mode_64bit
14444 || (prefixes & PREFIX_ADDR))
14446 OP_OFF (bytemode, sizeflag);
14450 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14451 intel_operand_size (bytemode, sizeflag);
14458 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14459 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14461 oappend (names_seg[ds_reg - es_reg]);
14465 print_operand_value (scratchbuf, 1, off);
14466 oappend (scratchbuf);
14470 ptr_reg (int code, int sizeflag)
14474 *obufp++ = open_char;
14475 used_prefixes |= (prefixes & PREFIX_ADDR);
14476 if (address_mode == mode_64bit)
14478 if (!(sizeflag & AFLAG))
14479 s = names32[code - eAX_reg];
14481 s = names64[code - eAX_reg];
14483 else if (sizeflag & AFLAG)
14484 s = names32[code - eAX_reg];
14486 s = names16[code - eAX_reg];
14488 *obufp++ = close_char;
14493 OP_ESreg (int code, int sizeflag)
14499 case 0x6d: /* insw/insl */
14500 intel_operand_size (z_mode, sizeflag);
14502 case 0xa5: /* movsw/movsl/movsq */
14503 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14504 case 0xab: /* stosw/stosl */
14505 case 0xaf: /* scasw/scasl */
14506 intel_operand_size (v_mode, sizeflag);
14509 intel_operand_size (b_mode, sizeflag);
14512 oappend ("%es:" + intel_syntax);
14513 ptr_reg (code, sizeflag);
14517 OP_DSreg (int code, int sizeflag)
14523 case 0x6f: /* outsw/outsl */
14524 intel_operand_size (z_mode, sizeflag);
14526 case 0xa5: /* movsw/movsl/movsq */
14527 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14528 case 0xad: /* lodsw/lodsl/lodsq */
14529 intel_operand_size (v_mode, sizeflag);
14532 intel_operand_size (b_mode, sizeflag);
14541 | PREFIX_GS)) == 0)
14542 prefixes |= PREFIX_DS;
14544 ptr_reg (code, sizeflag);
14548 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14556 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
14558 all_prefixes[last_lock_prefix] = 0;
14559 used_prefixes |= PREFIX_LOCK;
14564 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
14565 oappend (scratchbuf + intel_syntax);
14569 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14578 sprintf (scratchbuf, "db%d", modrm.reg + add);
14580 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
14581 oappend (scratchbuf);
14585 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14587 sprintf (scratchbuf, "%%tr%d", modrm.reg);
14588 oappend (scratchbuf + intel_syntax);
14592 OP_R (int bytemode, int sizeflag)
14594 if (modrm.mod == 3)
14595 OP_E (bytemode, sizeflag);
14601 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14603 used_prefixes |= (prefixes & PREFIX_DATA);
14604 if (prefixes & PREFIX_DATA)
14612 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14615 sprintf (scratchbuf, "%%mm%d", modrm.reg);
14616 oappend (scratchbuf + intel_syntax);
14620 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14628 if (need_vex && bytemode != xmm_mode)
14630 switch (vex.length)
14633 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14636 sprintf (scratchbuf, "%%ymm%d", modrm.reg + add);
14643 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14644 oappend (scratchbuf + intel_syntax);
14648 OP_EM (int bytemode, int sizeflag)
14650 if (modrm.mod != 3)
14653 && (bytemode == v_mode || bytemode == v_swap_mode))
14655 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14656 used_prefixes |= (prefixes & PREFIX_DATA);
14658 OP_E (bytemode, sizeflag);
14662 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
14665 /* Skip mod/rm byte. */
14668 used_prefixes |= (prefixes & PREFIX_DATA);
14669 if (prefixes & PREFIX_DATA)
14678 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14681 sprintf (scratchbuf, "%%mm%d", modrm.rm);
14682 oappend (scratchbuf + intel_syntax);
14685 /* cvt* are the only instructions in sse2 which have
14686 both SSE and MMX operands and also have 0x66 prefix
14687 in their opcode. 0x66 was originally used to differentiate
14688 between SSE and MMX instruction(operands). So we have to handle the
14689 cvt* separately using OP_EMC and OP_MXC */
14691 OP_EMC (int bytemode, int sizeflag)
14693 if (modrm.mod != 3)
14695 if (intel_syntax && bytemode == v_mode)
14697 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14698 used_prefixes |= (prefixes & PREFIX_DATA);
14700 OP_E (bytemode, sizeflag);
14704 /* Skip mod/rm byte. */
14707 used_prefixes |= (prefixes & PREFIX_DATA);
14708 sprintf (scratchbuf, "%%mm%d", modrm.rm);
14709 oappend (scratchbuf + intel_syntax);
14713 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14715 used_prefixes |= (prefixes & PREFIX_DATA);
14716 sprintf (scratchbuf, "%%mm%d", modrm.reg);
14717 oappend (scratchbuf + intel_syntax);
14721 OP_EX (int bytemode, int sizeflag)
14725 /* Skip mod/rm byte. */
14729 if (modrm.mod != 3)
14731 OP_E_memory (bytemode, sizeflag);
14741 if ((sizeflag & SUFFIX_ALWAYS)
14742 && (bytemode == x_swap_mode
14743 || bytemode == d_swap_mode
14744 || bytemode == q_swap_mode))
14748 && bytemode != xmm_mode
14749 && bytemode != xmmq_mode)
14751 switch (vex.length)
14754 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14757 sprintf (scratchbuf, "%%ymm%d", modrm.rm + add);
14764 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14765 oappend (scratchbuf + intel_syntax);
14769 OP_MS (int bytemode, int sizeflag)
14771 if (modrm.mod == 3)
14772 OP_EM (bytemode, sizeflag);
14778 OP_XS (int bytemode, int sizeflag)
14780 if (modrm.mod == 3)
14781 OP_EX (bytemode, sizeflag);
14787 OP_M (int bytemode, int sizeflag)
14789 if (modrm.mod == 3)
14790 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14793 OP_E (bytemode, sizeflag);
14797 OP_0f07 (int bytemode, int sizeflag)
14799 if (modrm.mod != 3 || modrm.rm != 0)
14802 OP_E (bytemode, sizeflag);
14805 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14806 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14809 NOP_Fixup1 (int bytemode, int sizeflag)
14811 if ((prefixes & PREFIX_DATA) != 0
14814 && address_mode == mode_64bit))
14815 OP_REG (bytemode, sizeflag);
14817 strcpy (obuf, "nop");
14821 NOP_Fixup2 (int bytemode, int sizeflag)
14823 if ((prefixes & PREFIX_DATA) != 0
14826 && address_mode == mode_64bit))
14827 OP_IMREG (bytemode, sizeflag);
14830 static const char *const Suffix3DNow[] = {
14831 /* 00 */ NULL, NULL, NULL, NULL,
14832 /* 04 */ NULL, NULL, NULL, NULL,
14833 /* 08 */ NULL, NULL, NULL, NULL,
14834 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
14835 /* 10 */ NULL, NULL, NULL, NULL,
14836 /* 14 */ NULL, NULL, NULL, NULL,
14837 /* 18 */ NULL, NULL, NULL, NULL,
14838 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
14839 /* 20 */ NULL, NULL, NULL, NULL,
14840 /* 24 */ NULL, NULL, NULL, NULL,
14841 /* 28 */ NULL, NULL, NULL, NULL,
14842 /* 2C */ NULL, NULL, NULL, NULL,
14843 /* 30 */ NULL, NULL, NULL, NULL,
14844 /* 34 */ NULL, NULL, NULL, NULL,
14845 /* 38 */ NULL, NULL, NULL, NULL,
14846 /* 3C */ NULL, NULL, NULL, NULL,
14847 /* 40 */ NULL, NULL, NULL, NULL,
14848 /* 44 */ NULL, NULL, NULL, NULL,
14849 /* 48 */ NULL, NULL, NULL, NULL,
14850 /* 4C */ NULL, NULL, NULL, NULL,
14851 /* 50 */ NULL, NULL, NULL, NULL,
14852 /* 54 */ NULL, NULL, NULL, NULL,
14853 /* 58 */ NULL, NULL, NULL, NULL,
14854 /* 5C */ NULL, NULL, NULL, NULL,
14855 /* 60 */ NULL, NULL, NULL, NULL,
14856 /* 64 */ NULL, NULL, NULL, NULL,
14857 /* 68 */ NULL, NULL, NULL, NULL,
14858 /* 6C */ NULL, NULL, NULL, NULL,
14859 /* 70 */ NULL, NULL, NULL, NULL,
14860 /* 74 */ NULL, NULL, NULL, NULL,
14861 /* 78 */ NULL, NULL, NULL, NULL,
14862 /* 7C */ NULL, NULL, NULL, NULL,
14863 /* 80 */ NULL, NULL, NULL, NULL,
14864 /* 84 */ NULL, NULL, NULL, NULL,
14865 /* 88 */ NULL, NULL, "pfnacc", NULL,
14866 /* 8C */ NULL, NULL, "pfpnacc", NULL,
14867 /* 90 */ "pfcmpge", NULL, NULL, NULL,
14868 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
14869 /* 98 */ NULL, NULL, "pfsub", NULL,
14870 /* 9C */ NULL, NULL, "pfadd", NULL,
14871 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
14872 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
14873 /* A8 */ NULL, NULL, "pfsubr", NULL,
14874 /* AC */ NULL, NULL, "pfacc", NULL,
14875 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
14876 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
14877 /* B8 */ NULL, NULL, NULL, "pswapd",
14878 /* BC */ NULL, NULL, NULL, "pavgusb",
14879 /* C0 */ NULL, NULL, NULL, NULL,
14880 /* C4 */ NULL, NULL, NULL, NULL,
14881 /* C8 */ NULL, NULL, NULL, NULL,
14882 /* CC */ NULL, NULL, NULL, NULL,
14883 /* D0 */ NULL, NULL, NULL, NULL,
14884 /* D4 */ NULL, NULL, NULL, NULL,
14885 /* D8 */ NULL, NULL, NULL, NULL,
14886 /* DC */ NULL, NULL, NULL, NULL,
14887 /* E0 */ NULL, NULL, NULL, NULL,
14888 /* E4 */ NULL, NULL, NULL, NULL,
14889 /* E8 */ NULL, NULL, NULL, NULL,
14890 /* EC */ NULL, NULL, NULL, NULL,
14891 /* F0 */ NULL, NULL, NULL, NULL,
14892 /* F4 */ NULL, NULL, NULL, NULL,
14893 /* F8 */ NULL, NULL, NULL, NULL,
14894 /* FC */ NULL, NULL, NULL, NULL,
14898 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14900 const char *mnemonic;
14902 FETCH_DATA (the_info, codep + 1);
14903 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14904 place where an 8-bit immediate would normally go. ie. the last
14905 byte of the instruction. */
14906 obufp = mnemonicendp;
14907 mnemonic = Suffix3DNow[*codep++ & 0xff];
14909 oappend (mnemonic);
14912 /* Since a variable sized modrm/sib chunk is between the start
14913 of the opcode (0x0f0f) and the opcode suffix, we need to do
14914 all the modrm processing first, and don't know until now that
14915 we have a bad opcode. This necessitates some cleaning up. */
14916 op_out[0][0] = '\0';
14917 op_out[1][0] = '\0';
14920 mnemonicendp = obufp;
14923 static struct op simd_cmp_op[] =
14925 { STRING_COMMA_LEN ("eq") },
14926 { STRING_COMMA_LEN ("lt") },
14927 { STRING_COMMA_LEN ("le") },
14928 { STRING_COMMA_LEN ("unord") },
14929 { STRING_COMMA_LEN ("neq") },
14930 { STRING_COMMA_LEN ("nlt") },
14931 { STRING_COMMA_LEN ("nle") },
14932 { STRING_COMMA_LEN ("ord") }
14936 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14938 unsigned int cmp_type;
14940 FETCH_DATA (the_info, codep + 1);
14941 cmp_type = *codep++ & 0xff;
14942 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
14945 char *p = mnemonicendp - 2;
14949 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
14950 mnemonicendp += simd_cmp_op[cmp_type].len;
14954 /* We have a reserved extension byte. Output it directly. */
14955 scratchbuf[0] = '$';
14956 print_operand_value (scratchbuf + 1, 1, cmp_type);
14957 oappend (scratchbuf + intel_syntax);
14958 scratchbuf[0] = '\0';
14963 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
14964 int sizeflag ATTRIBUTE_UNUSED)
14966 /* mwait %eax,%ecx */
14969 const char **names = (address_mode == mode_64bit
14970 ? names64 : names32);
14971 strcpy (op_out[0], names[0]);
14972 strcpy (op_out[1], names[1]);
14973 two_source_ops = 1;
14975 /* Skip mod/rm byte. */
14981 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
14982 int sizeflag ATTRIBUTE_UNUSED)
14984 /* monitor %eax,%ecx,%edx" */
14987 const char **op1_names;
14988 const char **names = (address_mode == mode_64bit
14989 ? names64 : names32);
14991 if (!(prefixes & PREFIX_ADDR))
14992 op1_names = (address_mode == mode_16bit
14993 ? names16 : names);
14996 /* Remove "addr16/addr32". */
14997 all_prefixes[last_addr_prefix] = 0;
14998 op1_names = (address_mode != mode_32bit
14999 ? names32 : names16);
15000 used_prefixes |= PREFIX_ADDR;
15002 strcpy (op_out[0], op1_names[0]);
15003 strcpy (op_out[1], names[1]);
15004 strcpy (op_out[2], names[2]);
15005 two_source_ops = 1;
15007 /* Skip mod/rm byte. */
15015 /* Throw away prefixes and 1st. opcode byte. */
15016 codep = insn_codep + 1;
15021 REP_Fixup (int bytemode, int sizeflag)
15023 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
15025 if (prefixes & PREFIX_REPZ)
15026 all_prefixes[last_repz_prefix] = REP_PREFIX;
15033 OP_IMREG (bytemode, sizeflag);
15036 OP_ESreg (bytemode, sizeflag);
15039 OP_DSreg (bytemode, sizeflag);
15048 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
15053 /* Change cmpxchg8b to cmpxchg16b. */
15054 char *p = mnemonicendp - 2;
15055 mnemonicendp = stpcpy (p, "16b");
15058 OP_M (bytemode, sizeflag);
15062 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
15066 switch (vex.length)
15069 sprintf (scratchbuf, "%%xmm%d", reg);
15072 sprintf (scratchbuf, "%%ymm%d", reg);
15079 sprintf (scratchbuf, "%%xmm%d", reg);
15080 oappend (scratchbuf + intel_syntax);
15084 CRC32_Fixup (int bytemode, int sizeflag)
15086 /* Add proper suffix to "crc32". */
15087 char *p = mnemonicendp;
15106 if (sizeflag & DFLAG)
15110 used_prefixes |= (prefixes & PREFIX_DATA);
15114 oappend (INTERNAL_DISASSEMBLER_ERROR);
15121 if (modrm.mod == 3)
15125 /* Skip mod/rm byte. */
15130 add = (rex & REX_B) ? 8 : 0;
15131 if (bytemode == b_mode)
15135 oappend (names8rex[modrm.rm + add]);
15137 oappend (names8[modrm.rm + add]);
15143 oappend (names64[modrm.rm + add]);
15144 else if ((prefixes & PREFIX_DATA))
15145 oappend (names16[modrm.rm + add]);
15147 oappend (names32[modrm.rm + add]);
15151 OP_E (bytemode, sizeflag);
15155 FXSAVE_Fixup (int bytemode, int sizeflag)
15157 /* Add proper suffix to "fxsave" and "fxrstor". */
15161 char *p = mnemonicendp;
15167 OP_M (bytemode, sizeflag);
15170 /* Display the destination register operand for instructions with
15174 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15182 switch (vex.length)
15195 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15208 sprintf (scratchbuf, "%%ymm%d", vex.register_specifier);
15214 oappend (scratchbuf + intel_syntax);
15217 /* Get the VEX immediate byte without moving codep. */
15219 static unsigned char
15220 get_vex_imm8 (int sizeflag, int opnum)
15222 int bytes_before_imm = 0;
15224 if (modrm.mod != 3)
15226 /* There are SIB/displacement bytes. */
15227 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
15229 /* 32/64 bit address mode */
15230 int base = modrm.rm;
15232 /* Check SIB byte. */
15235 FETCH_DATA (the_info, codep + 1);
15237 /* When decoding the third source, don't increase
15238 bytes_before_imm as this has already been incremented
15239 by one in OP_E_memory while decoding the second
15242 bytes_before_imm++;
15245 /* Don't increase bytes_before_imm when decoding the third source,
15246 it has already been incremented by OP_E_memory while decoding
15247 the second source operand. */
15253 /* When modrm.rm == 5 or modrm.rm == 4 and base in
15254 SIB == 5, there is a 4 byte displacement. */
15256 /* No displacement. */
15259 /* 4 byte displacement. */
15260 bytes_before_imm += 4;
15263 /* 1 byte displacement. */
15264 bytes_before_imm++;
15271 /* 16 bit address mode */
15272 /* Don't increase bytes_before_imm when decoding the third source,
15273 it has already been incremented by OP_E_memory while decoding
15274 the second source operand. */
15280 /* When modrm.rm == 6, there is a 2 byte displacement. */
15282 /* No displacement. */
15285 /* 2 byte displacement. */
15286 bytes_before_imm += 2;
15289 /* 1 byte displacement: when decoding the third source,
15290 don't increase bytes_before_imm as this has already
15291 been incremented by one in OP_E_memory while decoding
15292 the second source operand. */
15294 bytes_before_imm++;
15302 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
15303 return codep [bytes_before_imm];
15307 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
15309 if (reg == -1 && modrm.mod != 3)
15311 OP_E_memory (bytemode, sizeflag);
15323 else if (reg > 7 && address_mode != mode_64bit)
15327 switch (vex.length)
15330 sprintf (scratchbuf, "%%xmm%d", reg);
15333 sprintf (scratchbuf, "%%ymm%d", reg);
15338 oappend (scratchbuf + intel_syntax);
15342 OP_Vex_2src (int bytemode, int sizeflag)
15344 if (modrm.mod == 3)
15347 sprintf (scratchbuf, "%%xmm%d", rex & REX_B ? modrm.rm + 8 : modrm.rm);
15348 oappend (scratchbuf + intel_syntax);
15353 && (bytemode == v_mode || bytemode == v_swap_mode))
15355 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
15356 used_prefixes |= (prefixes & PREFIX_DATA);
15358 OP_E (bytemode, sizeflag);
15363 OP_Vex_2src_1 (int bytemode, int sizeflag)
15365 if (modrm.mod == 3)
15367 /* Skip mod/rm byte. */
15374 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15375 oappend (scratchbuf + intel_syntax);
15378 OP_Vex_2src (bytemode, sizeflag);
15382 OP_Vex_2src_2 (int bytemode, int sizeflag)
15385 OP_Vex_2src (bytemode, sizeflag);
15388 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15389 oappend (scratchbuf + intel_syntax);
15394 OP_EX_VexW (int bytemode, int sizeflag)
15402 /* Skip mod/rm byte. */
15407 reg = get_vex_imm8 (sizeflag, 0) >> 4;
15412 reg = get_vex_imm8 (sizeflag, 1) >> 4;
15415 OP_EX_VexReg (bytemode, sizeflag, reg);
15419 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
15420 int sizeflag ATTRIBUTE_UNUSED)
15422 /* Skip the immediate byte and check for invalid bits. */
15423 FETCH_DATA (the_info, codep + 1);
15424 if (*codep++ & 0xf)
15429 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15432 FETCH_DATA (the_info, codep + 1);
15435 if (bytemode != x_mode)
15442 if (reg > 7 && address_mode != mode_64bit)
15445 switch (vex.length)
15448 sprintf (scratchbuf, "%%xmm%d", reg);
15451 sprintf (scratchbuf, "%%ymm%d", reg);
15456 oappend (scratchbuf + intel_syntax);
15460 OP_XMM_VexW (int bytemode, int sizeflag)
15462 /* Turn off the REX.W bit since it is used for swapping operands
15465 OP_XMM (bytemode, sizeflag);
15469 OP_EX_Vex (int bytemode, int sizeflag)
15471 if (modrm.mod != 3)
15473 if (vex.register_specifier != 0)
15477 OP_EX (bytemode, sizeflag);
15481 OP_XMM_Vex (int bytemode, int sizeflag)
15483 if (modrm.mod != 3)
15485 if (vex.register_specifier != 0)
15489 OP_XMM (bytemode, sizeflag);
15493 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15495 switch (vex.length)
15498 mnemonicendp = stpcpy (obuf, "vzeroupper");
15501 mnemonicendp = stpcpy (obuf, "vzeroall");
15508 static struct op vex_cmp_op[] =
15510 { STRING_COMMA_LEN ("eq") },
15511 { STRING_COMMA_LEN ("lt") },
15512 { STRING_COMMA_LEN ("le") },
15513 { STRING_COMMA_LEN ("unord") },
15514 { STRING_COMMA_LEN ("neq") },
15515 { STRING_COMMA_LEN ("nlt") },
15516 { STRING_COMMA_LEN ("nle") },
15517 { STRING_COMMA_LEN ("ord") },
15518 { STRING_COMMA_LEN ("eq_uq") },
15519 { STRING_COMMA_LEN ("nge") },
15520 { STRING_COMMA_LEN ("ngt") },
15521 { STRING_COMMA_LEN ("false") },
15522 { STRING_COMMA_LEN ("neq_oq") },
15523 { STRING_COMMA_LEN ("ge") },
15524 { STRING_COMMA_LEN ("gt") },
15525 { STRING_COMMA_LEN ("true") },
15526 { STRING_COMMA_LEN ("eq_os") },
15527 { STRING_COMMA_LEN ("lt_oq") },
15528 { STRING_COMMA_LEN ("le_oq") },
15529 { STRING_COMMA_LEN ("unord_s") },
15530 { STRING_COMMA_LEN ("neq_us") },
15531 { STRING_COMMA_LEN ("nlt_uq") },
15532 { STRING_COMMA_LEN ("nle_uq") },
15533 { STRING_COMMA_LEN ("ord_s") },
15534 { STRING_COMMA_LEN ("eq_us") },
15535 { STRING_COMMA_LEN ("nge_uq") },
15536 { STRING_COMMA_LEN ("ngt_uq") },
15537 { STRING_COMMA_LEN ("false_os") },
15538 { STRING_COMMA_LEN ("neq_os") },
15539 { STRING_COMMA_LEN ("ge_oq") },
15540 { STRING_COMMA_LEN ("gt_oq") },
15541 { STRING_COMMA_LEN ("true_us") },
15545 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15547 unsigned int cmp_type;
15549 FETCH_DATA (the_info, codep + 1);
15550 cmp_type = *codep++ & 0xff;
15551 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
15554 char *p = mnemonicendp - 2;
15558 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
15559 mnemonicendp += vex_cmp_op[cmp_type].len;
15563 /* We have a reserved extension byte. Output it directly. */
15564 scratchbuf[0] = '$';
15565 print_operand_value (scratchbuf + 1, 1, cmp_type);
15566 oappend (scratchbuf + intel_syntax);
15567 scratchbuf[0] = '\0';
15571 static const struct op pclmul_op[] =
15573 { STRING_COMMA_LEN ("lql") },
15574 { STRING_COMMA_LEN ("hql") },
15575 { STRING_COMMA_LEN ("lqh") },
15576 { STRING_COMMA_LEN ("hqh") }
15580 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
15581 int sizeflag ATTRIBUTE_UNUSED)
15583 unsigned int pclmul_type;
15585 FETCH_DATA (the_info, codep + 1);
15586 pclmul_type = *codep++ & 0xff;
15587 switch (pclmul_type)
15598 if (pclmul_type < ARRAY_SIZE (pclmul_op))
15601 char *p = mnemonicendp - 3;
15606 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
15607 mnemonicendp += pclmul_op[pclmul_type].len;
15611 /* We have a reserved extension byte. Output it directly. */
15612 scratchbuf[0] = '$';
15613 print_operand_value (scratchbuf + 1, 1, pclmul_type);
15614 oappend (scratchbuf + intel_syntax);
15615 scratchbuf[0] = '\0';
15620 MOVBE_Fixup (int bytemode, int sizeflag)
15622 /* Add proper suffix to "movbe". */
15623 char *p = mnemonicendp;
15632 if (sizeflag & SUFFIX_ALWAYS)
15638 if (sizeflag & DFLAG)
15642 used_prefixes |= (prefixes & PREFIX_DATA);
15647 oappend (INTERNAL_DISASSEMBLER_ERROR);
15654 OP_M (bytemode, sizeflag);
15658 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15661 const char **names;
15663 /* Skip mod/rm byte. */
15669 else if (vex.length == 256)
15679 oappend (names[reg]);
15683 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15685 const char **names;
15689 else if (vex.length == 256)
15694 oappend (names[vex.register_specifier]);
15698 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
15700 if (vex.w || vex.length == 256)
15701 OP_I (q_mode, sizeflag);
15703 OP_I (w_mode, sizeflag);