1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma, disassemble_info *);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma get64 (void);
60 static bfd_signed_vma get32 (void);
61 static bfd_signed_vma get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte *max_fetched;
125 bfd_byte the_buffer[MAX_MNEM_SIZE];
138 enum address_mode address_mode;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* REX bits in original REX prefix ignored. */
148 static int rex_ignored;
149 /* Mark parts used in the REX prefix. When we are testing for
150 empty prefix (for 8bit register REX extension), just mask it
151 out. Otherwise test for REX bit is excuse for existence of REX
152 only in case value is nonzero. */
153 #define USED_REX(value) \
158 rex_used |= (value) | REX_OPCODE; \
161 rex_used |= REX_OPCODE; \
164 /* Flags for prefixes which we somehow handled when printing the
165 current instruction. */
166 static int used_prefixes;
168 /* Flags stored in PREFIXES. */
169 #define PREFIX_REPZ 1
170 #define PREFIX_REPNZ 2
171 #define PREFIX_LOCK 4
173 #define PREFIX_SS 0x10
174 #define PREFIX_DS 0x20
175 #define PREFIX_ES 0x40
176 #define PREFIX_FS 0x80
177 #define PREFIX_GS 0x100
178 #define PREFIX_DATA 0x200
179 #define PREFIX_ADDR 0x400
180 #define PREFIX_FWAIT 0x800
182 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
183 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
185 #define FETCH_DATA(info, addr) \
186 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
187 ? 1 : fetch_data ((info), (addr)))
190 fetch_data (struct disassemble_info *info, bfd_byte *addr)
193 struct dis_private *priv = (struct dis_private *) info->private_data;
194 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
196 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
197 status = (*info->read_memory_func) (start,
199 addr - priv->max_fetched,
205 /* If we did manage to read at least one byte, then
206 print_insn_i386 will do something sensible. Otherwise, print
207 an error. We do that here because this is where we know
209 if (priv->max_fetched == priv->the_buffer)
210 (*info->memory_error_func) (status, start, info);
211 longjmp (priv->bailout, 1);
214 priv->max_fetched = addr;
218 #define XX { NULL, 0 }
220 #define Eb { OP_E, b_mode }
221 #define EbS { OP_E, b_swap_mode }
222 #define Ev { OP_E, v_mode }
223 #define EvS { OP_E, v_swap_mode }
224 #define Ed { OP_E, d_mode }
225 #define Edq { OP_E, dq_mode }
226 #define Edqw { OP_E, dqw_mode }
227 #define Edqb { OP_E, dqb_mode }
228 #define Edqd { OP_E, dqd_mode }
229 #define Eq { OP_E, q_mode }
230 #define indirEv { OP_indirE, stack_v_mode }
231 #define indirEp { OP_indirE, f_mode }
232 #define stackEv { OP_E, stack_v_mode }
233 #define Em { OP_E, m_mode }
234 #define Ew { OP_E, w_mode }
235 #define M { OP_M, 0 } /* lea, lgdt, etc. */
236 #define Ma { OP_M, a_mode }
237 #define Mb { OP_M, b_mode }
238 #define Md { OP_M, d_mode }
239 #define Mo { OP_M, o_mode }
240 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
241 #define Mq { OP_M, q_mode }
242 #define Mx { OP_M, x_mode }
243 #define Mxmm { OP_M, xmm_mode }
244 #define Gb { OP_G, b_mode }
245 #define Gv { OP_G, v_mode }
246 #define Gd { OP_G, d_mode }
247 #define Gdq { OP_G, dq_mode }
248 #define Gm { OP_G, m_mode }
249 #define Gw { OP_G, w_mode }
250 #define Rd { OP_R, d_mode }
251 #define Rm { OP_R, m_mode }
252 #define Ib { OP_I, b_mode }
253 #define sIb { OP_sI, b_mode } /* sign extened byte */
254 #define Iv { OP_I, v_mode }
255 #define Iq { OP_I, q_mode }
256 #define Iv64 { OP_I64, v_mode }
257 #define Iw { OP_I, w_mode }
258 #define I1 { OP_I, const_1_mode }
259 #define Jb { OP_J, b_mode }
260 #define Jv { OP_J, v_mode }
261 #define Cm { OP_C, m_mode }
262 #define Dm { OP_D, m_mode }
263 #define Td { OP_T, d_mode }
264 #define Skip_MODRM { OP_Skip_MODRM, 0 }
266 #define RMeAX { OP_REG, eAX_reg }
267 #define RMeBX { OP_REG, eBX_reg }
268 #define RMeCX { OP_REG, eCX_reg }
269 #define RMeDX { OP_REG, eDX_reg }
270 #define RMeSP { OP_REG, eSP_reg }
271 #define RMeBP { OP_REG, eBP_reg }
272 #define RMeSI { OP_REG, eSI_reg }
273 #define RMeDI { OP_REG, eDI_reg }
274 #define RMrAX { OP_REG, rAX_reg }
275 #define RMrBX { OP_REG, rBX_reg }
276 #define RMrCX { OP_REG, rCX_reg }
277 #define RMrDX { OP_REG, rDX_reg }
278 #define RMrSP { OP_REG, rSP_reg }
279 #define RMrBP { OP_REG, rBP_reg }
280 #define RMrSI { OP_REG, rSI_reg }
281 #define RMrDI { OP_REG, rDI_reg }
282 #define RMAL { OP_REG, al_reg }
283 #define RMAL { OP_REG, al_reg }
284 #define RMCL { OP_REG, cl_reg }
285 #define RMDL { OP_REG, dl_reg }
286 #define RMBL { OP_REG, bl_reg }
287 #define RMAH { OP_REG, ah_reg }
288 #define RMCH { OP_REG, ch_reg }
289 #define RMDH { OP_REG, dh_reg }
290 #define RMBH { OP_REG, bh_reg }
291 #define RMAX { OP_REG, ax_reg }
292 #define RMDX { OP_REG, dx_reg }
294 #define eAX { OP_IMREG, eAX_reg }
295 #define eBX { OP_IMREG, eBX_reg }
296 #define eCX { OP_IMREG, eCX_reg }
297 #define eDX { OP_IMREG, eDX_reg }
298 #define eSP { OP_IMREG, eSP_reg }
299 #define eBP { OP_IMREG, eBP_reg }
300 #define eSI { OP_IMREG, eSI_reg }
301 #define eDI { OP_IMREG, eDI_reg }
302 #define AL { OP_IMREG, al_reg }
303 #define CL { OP_IMREG, cl_reg }
304 #define DL { OP_IMREG, dl_reg }
305 #define BL { OP_IMREG, bl_reg }
306 #define AH { OP_IMREG, ah_reg }
307 #define CH { OP_IMREG, ch_reg }
308 #define DH { OP_IMREG, dh_reg }
309 #define BH { OP_IMREG, bh_reg }
310 #define AX { OP_IMREG, ax_reg }
311 #define DX { OP_IMREG, dx_reg }
312 #define zAX { OP_IMREG, z_mode_ax_reg }
313 #define indirDX { OP_IMREG, indir_dx_reg }
315 #define Sw { OP_SEG, w_mode }
316 #define Sv { OP_SEG, v_mode }
317 #define Ap { OP_DIR, 0 }
318 #define Ob { OP_OFF64, b_mode }
319 #define Ov { OP_OFF64, v_mode }
320 #define Xb { OP_DSreg, eSI_reg }
321 #define Xv { OP_DSreg, eSI_reg }
322 #define Xz { OP_DSreg, eSI_reg }
323 #define Yb { OP_ESreg, eDI_reg }
324 #define Yv { OP_ESreg, eDI_reg }
325 #define DSBX { OP_DSreg, eBX_reg }
327 #define es { OP_REG, es_reg }
328 #define ss { OP_REG, ss_reg }
329 #define cs { OP_REG, cs_reg }
330 #define ds { OP_REG, ds_reg }
331 #define fs { OP_REG, fs_reg }
332 #define gs { OP_REG, gs_reg }
334 #define MX { OP_MMX, 0 }
335 #define XM { OP_XMM, 0 }
336 #define XMM { OP_XMM, xmm_mode }
337 #define EM { OP_EM, v_mode }
338 #define EMS { OP_EM, v_swap_mode }
339 #define EMd { OP_EM, d_mode }
340 #define EMx { OP_EM, x_mode }
341 #define EXw { OP_EX, w_mode }
342 #define EXd { OP_EX, d_mode }
343 #define EXdS { OP_EX, d_swap_mode }
344 #define EXq { OP_EX, q_mode }
345 #define EXqS { OP_EX, q_swap_mode }
346 #define EXx { OP_EX, x_mode }
347 #define EXxS { OP_EX, x_swap_mode }
348 #define EXxmm { OP_EX, xmm_mode }
349 #define EXxmmq { OP_EX, xmmq_mode }
350 #define EXymmq { OP_EX, ymmq_mode }
351 #define EXVexWdq { OP_EX, vex_w_dq_mode }
352 #define MS { OP_MS, v_mode }
353 #define XS { OP_XS, v_mode }
354 #define EMCq { OP_EMC, q_mode }
355 #define MXC { OP_MXC, 0 }
356 #define OPSUF { OP_3DNowSuffix, 0 }
357 #define CMP { CMP_Fixup, 0 }
358 #define XMM0 { XMM_Fixup, 0 }
359 #define FXSAVE { FXSAVE_Fixup, 0 }
360 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
361 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
363 #define Vex { OP_VEX, vex_mode }
364 #define Vex128 { OP_VEX, vex128_mode }
365 #define Vex256 { OP_VEX, vex256_mode }
366 #define VexI4 { VEXI4_Fixup, 0}
367 #define EXdVex { OP_EX_Vex, d_mode }
368 #define EXdVexS { OP_EX_Vex, d_swap_mode }
369 #define EXqVex { OP_EX_Vex, q_mode }
370 #define EXqVexS { OP_EX_Vex, q_swap_mode }
371 #define EXVexW { OP_EX_VexW, x_mode }
372 #define EXdVexW { OP_EX_VexW, d_mode }
373 #define EXqVexW { OP_EX_VexW, q_mode }
374 #define XMVex { OP_XMM_Vex, 0 }
375 #define XMVexW { OP_XMM_VexW, 0 }
376 #define XMVexI4 { OP_REG_VexI4, x_mode }
377 #define PCLMUL { PCLMUL_Fixup, 0 }
378 #define VZERO { VZERO_Fixup, 0 }
379 #define VCMP { VCMP_Fixup, 0 }
381 /* Used handle "rep" prefix for string instructions. */
382 #define Xbr { REP_Fixup, eSI_reg }
383 #define Xvr { REP_Fixup, eSI_reg }
384 #define Ybr { REP_Fixup, eDI_reg }
385 #define Yvr { REP_Fixup, eDI_reg }
386 #define Yzr { REP_Fixup, eDI_reg }
387 #define indirDXr { REP_Fixup, indir_dx_reg }
388 #define ALr { REP_Fixup, al_reg }
389 #define eAXr { REP_Fixup, eAX_reg }
391 #define cond_jump_flag { NULL, cond_jump_mode }
392 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
394 /* bits in sizeflag */
395 #define SUFFIX_ALWAYS 4
403 /* byte operand with operand swapped */
405 /* operand size depends on prefixes */
407 /* operand size depends on prefixes with operand swapped */
411 /* double word operand */
413 /* double word operand with operand swapped */
415 /* quad word operand */
417 /* quad word operand with operand swapped */
419 /* ten-byte operand */
421 /* 16-byte XMM or 32-byte YMM operand */
423 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
425 /* 16-byte XMM operand */
427 /* 16-byte XMM or quad word operand */
429 /* 32-byte YMM or quad word operand */
431 /* d_mode in 32bit, q_mode in 64bit mode. */
433 /* pair of v_mode operands */
437 /* operand size depends on REX prefixes. */
439 /* registers like dq_mode, memory like w_mode. */
441 /* 4- or 6-byte pointer operand */
444 /* v_mode for stack-related opcodes. */
446 /* non-quad operand size depends on prefixes */
448 /* 16-byte operand */
450 /* registers like dq_mode, memory like b_mode. */
452 /* registers like dq_mode, memory like d_mode. */
454 /* normal vex mode */
456 /* 128bit vex mode */
458 /* 256bit vex mode */
460 /* operand size depends on the VEX.W bit. */
526 #define FLOAT NULL, { { NULL, FLOATCODE } }
528 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
529 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
530 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
531 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
532 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
533 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
534 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
535 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
536 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
537 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
538 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
539 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
657 MOD_VEX_3818_PREFIX_2,
658 MOD_VEX_3819_PREFIX_2,
659 MOD_VEX_381A_PREFIX_2,
660 MOD_VEX_382A_PREFIX_2,
661 MOD_VEX_382C_PREFIX_2,
662 MOD_VEX_382D_PREFIX_2,
663 MOD_VEX_382E_PREFIX_2,
664 MOD_VEX_382F_PREFIX_2
1074 THREE_BYTE_0F38 = 0,
1229 VEX_LEN_3819_P_2_M_0,
1230 VEX_LEN_381A_P_2_M_0,
1242 VEX_LEN_382A_P_2_M_0,
1558 typedef void (*op_rtn) (int bytemode, int sizeflag);
1569 /* Upper case letters in the instruction names here are macros.
1570 'A' => print 'b' if no register operands or suffix_always is true
1571 'B' => print 'b' if suffix_always is true
1572 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1574 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1575 suffix_always is true
1576 'E' => print 'e' if 32-bit form of jcxz
1577 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1578 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1579 'H' => print ",pt" or ",pn" branch hint
1580 'I' => honor following macro letter even in Intel mode (implemented only
1581 for some of the macro letters)
1583 'K' => print 'd' or 'q' if rex prefix is present.
1584 'L' => print 'l' if suffix_always is true
1585 'M' => print 'r' if intel_mnemonic is false.
1586 'N' => print 'n' if instruction has no wait "prefix"
1587 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1588 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1589 or suffix_always is true. print 'q' if rex prefix is present.
1590 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1592 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1593 'S' => print 'w', 'l' or 'q' if suffix_always is true
1594 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1595 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1596 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1597 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1598 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1599 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1600 suffix_always is true.
1601 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1602 '!' => change condition from true to false or from false to true.
1603 '%' => add 1 upper case letter to the macro.
1605 2 upper case letter macros:
1606 "XY" => print 'x' or 'y' if no register operands or suffix_always
1608 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1609 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1610 or suffix_always is true
1611 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1612 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1613 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1615 Many of the above letters print nothing in Intel mode. See "putop"
1618 Braces '{' and '}', and vertical bars '|', indicate alternative
1619 mnemonic strings for AT&T and Intel. */
1621 static const struct dis386 dis386[] = {
1623 { "addB", { Eb, Gb } },
1624 { "addS", { Ev, Gv } },
1625 { "addB", { Gb, EbS } },
1626 { "addS", { Gv, EvS } },
1627 { "addB", { AL, Ib } },
1628 { "addS", { eAX, Iv } },
1629 { X86_64_TABLE (X86_64_06) },
1630 { X86_64_TABLE (X86_64_07) },
1632 { "orB", { Eb, Gb } },
1633 { "orS", { Ev, Gv } },
1634 { "orB", { Gb, EbS } },
1635 { "orS", { Gv, EvS } },
1636 { "orB", { AL, Ib } },
1637 { "orS", { eAX, Iv } },
1638 { X86_64_TABLE (X86_64_0D) },
1639 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
1641 { "adcB", { Eb, Gb } },
1642 { "adcS", { Ev, Gv } },
1643 { "adcB", { Gb, EbS } },
1644 { "adcS", { Gv, EvS } },
1645 { "adcB", { AL, Ib } },
1646 { "adcS", { eAX, Iv } },
1647 { X86_64_TABLE (X86_64_16) },
1648 { X86_64_TABLE (X86_64_17) },
1650 { "sbbB", { Eb, Gb } },
1651 { "sbbS", { Ev, Gv } },
1652 { "sbbB", { Gb, EbS } },
1653 { "sbbS", { Gv, EvS } },
1654 { "sbbB", { AL, Ib } },
1655 { "sbbS", { eAX, Iv } },
1656 { X86_64_TABLE (X86_64_1E) },
1657 { X86_64_TABLE (X86_64_1F) },
1659 { "andB", { Eb, Gb } },
1660 { "andS", { Ev, Gv } },
1661 { "andB", { Gb, EbS } },
1662 { "andS", { Gv, EvS } },
1663 { "andB", { AL, Ib } },
1664 { "andS", { eAX, Iv } },
1665 { "(bad)", { XX } }, /* SEG ES prefix */
1666 { X86_64_TABLE (X86_64_27) },
1668 { "subB", { Eb, Gb } },
1669 { "subS", { Ev, Gv } },
1670 { "subB", { Gb, EbS } },
1671 { "subS", { Gv, EvS } },
1672 { "subB", { AL, Ib } },
1673 { "subS", { eAX, Iv } },
1674 { "(bad)", { XX } }, /* SEG CS prefix */
1675 { X86_64_TABLE (X86_64_2F) },
1677 { "xorB", { Eb, Gb } },
1678 { "xorS", { Ev, Gv } },
1679 { "xorB", { Gb, EbS } },
1680 { "xorS", { Gv, EvS } },
1681 { "xorB", { AL, Ib } },
1682 { "xorS", { eAX, Iv } },
1683 { "(bad)", { XX } }, /* SEG SS prefix */
1684 { X86_64_TABLE (X86_64_37) },
1686 { "cmpB", { Eb, Gb } },
1687 { "cmpS", { Ev, Gv } },
1688 { "cmpB", { Gb, EbS } },
1689 { "cmpS", { Gv, EvS } },
1690 { "cmpB", { AL, Ib } },
1691 { "cmpS", { eAX, Iv } },
1692 { "(bad)", { XX } }, /* SEG DS prefix */
1693 { X86_64_TABLE (X86_64_3F) },
1695 { "inc{S|}", { RMeAX } },
1696 { "inc{S|}", { RMeCX } },
1697 { "inc{S|}", { RMeDX } },
1698 { "inc{S|}", { RMeBX } },
1699 { "inc{S|}", { RMeSP } },
1700 { "inc{S|}", { RMeBP } },
1701 { "inc{S|}", { RMeSI } },
1702 { "inc{S|}", { RMeDI } },
1704 { "dec{S|}", { RMeAX } },
1705 { "dec{S|}", { RMeCX } },
1706 { "dec{S|}", { RMeDX } },
1707 { "dec{S|}", { RMeBX } },
1708 { "dec{S|}", { RMeSP } },
1709 { "dec{S|}", { RMeBP } },
1710 { "dec{S|}", { RMeSI } },
1711 { "dec{S|}", { RMeDI } },
1713 { "pushV", { RMrAX } },
1714 { "pushV", { RMrCX } },
1715 { "pushV", { RMrDX } },
1716 { "pushV", { RMrBX } },
1717 { "pushV", { RMrSP } },
1718 { "pushV", { RMrBP } },
1719 { "pushV", { RMrSI } },
1720 { "pushV", { RMrDI } },
1722 { "popV", { RMrAX } },
1723 { "popV", { RMrCX } },
1724 { "popV", { RMrDX } },
1725 { "popV", { RMrBX } },
1726 { "popV", { RMrSP } },
1727 { "popV", { RMrBP } },
1728 { "popV", { RMrSI } },
1729 { "popV", { RMrDI } },
1731 { X86_64_TABLE (X86_64_60) },
1732 { X86_64_TABLE (X86_64_61) },
1733 { X86_64_TABLE (X86_64_62) },
1734 { X86_64_TABLE (X86_64_63) },
1735 { "(bad)", { XX } }, /* seg fs */
1736 { "(bad)", { XX } }, /* seg gs */
1737 { "(bad)", { XX } }, /* op size prefix */
1738 { "(bad)", { XX } }, /* adr size prefix */
1740 { "pushT", { Iq } },
1741 { "imulS", { Gv, Ev, Iv } },
1742 { "pushT", { sIb } },
1743 { "imulS", { Gv, Ev, sIb } },
1744 { "ins{b|}", { Ybr, indirDX } },
1745 { X86_64_TABLE (X86_64_6D) },
1746 { "outs{b|}", { indirDXr, Xb } },
1747 { X86_64_TABLE (X86_64_6F) },
1749 { "joH", { Jb, XX, cond_jump_flag } },
1750 { "jnoH", { Jb, XX, cond_jump_flag } },
1751 { "jbH", { Jb, XX, cond_jump_flag } },
1752 { "jaeH", { Jb, XX, cond_jump_flag } },
1753 { "jeH", { Jb, XX, cond_jump_flag } },
1754 { "jneH", { Jb, XX, cond_jump_flag } },
1755 { "jbeH", { Jb, XX, cond_jump_flag } },
1756 { "jaH", { Jb, XX, cond_jump_flag } },
1758 { "jsH", { Jb, XX, cond_jump_flag } },
1759 { "jnsH", { Jb, XX, cond_jump_flag } },
1760 { "jpH", { Jb, XX, cond_jump_flag } },
1761 { "jnpH", { Jb, XX, cond_jump_flag } },
1762 { "jlH", { Jb, XX, cond_jump_flag } },
1763 { "jgeH", { Jb, XX, cond_jump_flag } },
1764 { "jleH", { Jb, XX, cond_jump_flag } },
1765 { "jgH", { Jb, XX, cond_jump_flag } },
1767 { REG_TABLE (REG_80) },
1768 { REG_TABLE (REG_81) },
1769 { "(bad)", { XX } },
1770 { REG_TABLE (REG_82) },
1771 { "testB", { Eb, Gb } },
1772 { "testS", { Ev, Gv } },
1773 { "xchgB", { Eb, Gb } },
1774 { "xchgS", { Ev, Gv } },
1776 { "movB", { Eb, Gb } },
1777 { "movS", { Ev, Gv } },
1778 { "movB", { Gb, EbS } },
1779 { "movS", { Gv, EvS } },
1780 { "movD", { Sv, Sw } },
1781 { MOD_TABLE (MOD_8D) },
1782 { "movD", { Sw, Sv } },
1783 { REG_TABLE (REG_8F) },
1785 { PREFIX_TABLE (PREFIX_90) },
1786 { "xchgS", { RMeCX, eAX } },
1787 { "xchgS", { RMeDX, eAX } },
1788 { "xchgS", { RMeBX, eAX } },
1789 { "xchgS", { RMeSP, eAX } },
1790 { "xchgS", { RMeBP, eAX } },
1791 { "xchgS", { RMeSI, eAX } },
1792 { "xchgS", { RMeDI, eAX } },
1794 { "cW{t|}R", { XX } },
1795 { "cR{t|}O", { XX } },
1796 { X86_64_TABLE (X86_64_9A) },
1797 { "(bad)", { XX } }, /* fwait */
1798 { "pushfT", { XX } },
1799 { "popfT", { XX } },
1803 { "mov%LB", { AL, Ob } },
1804 { "mov%LS", { eAX, Ov } },
1805 { "mov%LB", { Ob, AL } },
1806 { "mov%LS", { Ov, eAX } },
1807 { "movs{b|}", { Ybr, Xb } },
1808 { "movs{R|}", { Yvr, Xv } },
1809 { "cmps{b|}", { Xb, Yb } },
1810 { "cmps{R|}", { Xv, Yv } },
1812 { "testB", { AL, Ib } },
1813 { "testS", { eAX, Iv } },
1814 { "stosB", { Ybr, AL } },
1815 { "stosS", { Yvr, eAX } },
1816 { "lodsB", { ALr, Xb } },
1817 { "lodsS", { eAXr, Xv } },
1818 { "scasB", { AL, Yb } },
1819 { "scasS", { eAX, Yv } },
1821 { "movB", { RMAL, Ib } },
1822 { "movB", { RMCL, Ib } },
1823 { "movB", { RMDL, Ib } },
1824 { "movB", { RMBL, Ib } },
1825 { "movB", { RMAH, Ib } },
1826 { "movB", { RMCH, Ib } },
1827 { "movB", { RMDH, Ib } },
1828 { "movB", { RMBH, Ib } },
1830 { "mov%LV", { RMeAX, Iv64 } },
1831 { "mov%LV", { RMeCX, Iv64 } },
1832 { "mov%LV", { RMeDX, Iv64 } },
1833 { "mov%LV", { RMeBX, Iv64 } },
1834 { "mov%LV", { RMeSP, Iv64 } },
1835 { "mov%LV", { RMeBP, Iv64 } },
1836 { "mov%LV", { RMeSI, Iv64 } },
1837 { "mov%LV", { RMeDI, Iv64 } },
1839 { REG_TABLE (REG_C0) },
1840 { REG_TABLE (REG_C1) },
1843 { X86_64_TABLE (X86_64_C4) },
1844 { X86_64_TABLE (X86_64_C5) },
1845 { REG_TABLE (REG_C6) },
1846 { REG_TABLE (REG_C7) },
1848 { "enterT", { Iw, Ib } },
1849 { "leaveT", { XX } },
1850 { "Jret{|f}P", { Iw } },
1851 { "Jret{|f}P", { XX } },
1854 { X86_64_TABLE (X86_64_CE) },
1855 { "iretP", { XX } },
1857 { REG_TABLE (REG_D0) },
1858 { REG_TABLE (REG_D1) },
1859 { REG_TABLE (REG_D2) },
1860 { REG_TABLE (REG_D3) },
1861 { X86_64_TABLE (X86_64_D4) },
1862 { X86_64_TABLE (X86_64_D5) },
1863 { "(bad)", { XX } },
1864 { "xlat", { DSBX } },
1875 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
1876 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
1877 { "loopFH", { Jb, XX, loop_jcxz_flag } },
1878 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
1879 { "inB", { AL, Ib } },
1880 { "inG", { zAX, Ib } },
1881 { "outB", { Ib, AL } },
1882 { "outG", { Ib, zAX } },
1884 { "callT", { Jv } },
1886 { X86_64_TABLE (X86_64_EA) },
1888 { "inB", { AL, indirDX } },
1889 { "inG", { zAX, indirDX } },
1890 { "outB", { indirDX, AL } },
1891 { "outG", { indirDX, zAX } },
1893 { "(bad)", { XX } }, /* lock prefix */
1894 { "icebp", { XX } },
1895 { "(bad)", { XX } }, /* repne */
1896 { "(bad)", { XX } }, /* repz */
1899 { REG_TABLE (REG_F6) },
1900 { REG_TABLE (REG_F7) },
1908 { REG_TABLE (REG_FE) },
1909 { REG_TABLE (REG_FF) },
1912 static const struct dis386 dis386_twobyte[] = {
1914 { REG_TABLE (REG_0F00 ) },
1915 { REG_TABLE (REG_0F01 ) },
1916 { "larS", { Gv, Ew } },
1917 { "lslS", { Gv, Ew } },
1918 { "(bad)", { XX } },
1919 { "syscall", { XX } },
1921 { "sysretP", { XX } },
1924 { "wbinvd", { XX } },
1925 { "(bad)", { XX } },
1927 { "(bad)", { XX } },
1928 { REG_TABLE (REG_0F0D) },
1929 { "femms", { XX } },
1930 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1932 { PREFIX_TABLE (PREFIX_0F10) },
1933 { PREFIX_TABLE (PREFIX_0F11) },
1934 { PREFIX_TABLE (PREFIX_0F12) },
1935 { MOD_TABLE (MOD_0F13) },
1936 { "unpcklpX", { XM, EXx } },
1937 { "unpckhpX", { XM, EXx } },
1938 { PREFIX_TABLE (PREFIX_0F16) },
1939 { MOD_TABLE (MOD_0F17) },
1941 { REG_TABLE (REG_0F18) },
1950 { MOD_TABLE (MOD_0F20) },
1951 { MOD_TABLE (MOD_0F21) },
1952 { MOD_TABLE (MOD_0F22) },
1953 { MOD_TABLE (MOD_0F23) },
1954 { MOD_TABLE (MOD_0F24) },
1955 { "(bad)", { XX } },
1956 { MOD_TABLE (MOD_0F26) },
1957 { "(bad)", { XX } },
1959 { "movapX", { XM, EXx } },
1960 { "movapX", { EXxS, XM } },
1961 { PREFIX_TABLE (PREFIX_0F2A) },
1962 { PREFIX_TABLE (PREFIX_0F2B) },
1963 { PREFIX_TABLE (PREFIX_0F2C) },
1964 { PREFIX_TABLE (PREFIX_0F2D) },
1965 { PREFIX_TABLE (PREFIX_0F2E) },
1966 { PREFIX_TABLE (PREFIX_0F2F) },
1968 { "wrmsr", { XX } },
1969 { "rdtsc", { XX } },
1970 { "rdmsr", { XX } },
1971 { "rdpmc", { XX } },
1972 { "sysenter", { XX } },
1973 { "sysexit", { XX } },
1974 { "(bad)", { XX } },
1975 { "getsec", { XX } },
1977 { THREE_BYTE_TABLE (THREE_BYTE_0F38) },
1978 { "(bad)", { XX } },
1979 { THREE_BYTE_TABLE (THREE_BYTE_0F3A) },
1980 { "(bad)", { XX } },
1981 { "(bad)", { XX } },
1982 { "(bad)", { XX } },
1983 { "(bad)", { XX } },
1984 { "(bad)", { XX } },
1986 { "cmovoS", { Gv, Ev } },
1987 { "cmovnoS", { Gv, Ev } },
1988 { "cmovbS", { Gv, Ev } },
1989 { "cmovaeS", { Gv, Ev } },
1990 { "cmoveS", { Gv, Ev } },
1991 { "cmovneS", { Gv, Ev } },
1992 { "cmovbeS", { Gv, Ev } },
1993 { "cmovaS", { Gv, Ev } },
1995 { "cmovsS", { Gv, Ev } },
1996 { "cmovnsS", { Gv, Ev } },
1997 { "cmovpS", { Gv, Ev } },
1998 { "cmovnpS", { Gv, Ev } },
1999 { "cmovlS", { Gv, Ev } },
2000 { "cmovgeS", { Gv, Ev } },
2001 { "cmovleS", { Gv, Ev } },
2002 { "cmovgS", { Gv, Ev } },
2004 { MOD_TABLE (MOD_0F51) },
2005 { PREFIX_TABLE (PREFIX_0F51) },
2006 { PREFIX_TABLE (PREFIX_0F52) },
2007 { PREFIX_TABLE (PREFIX_0F53) },
2008 { "andpX", { XM, EXx } },
2009 { "andnpX", { XM, EXx } },
2010 { "orpX", { XM, EXx } },
2011 { "xorpX", { XM, EXx } },
2013 { PREFIX_TABLE (PREFIX_0F58) },
2014 { PREFIX_TABLE (PREFIX_0F59) },
2015 { PREFIX_TABLE (PREFIX_0F5A) },
2016 { PREFIX_TABLE (PREFIX_0F5B) },
2017 { PREFIX_TABLE (PREFIX_0F5C) },
2018 { PREFIX_TABLE (PREFIX_0F5D) },
2019 { PREFIX_TABLE (PREFIX_0F5E) },
2020 { PREFIX_TABLE (PREFIX_0F5F) },
2022 { PREFIX_TABLE (PREFIX_0F60) },
2023 { PREFIX_TABLE (PREFIX_0F61) },
2024 { PREFIX_TABLE (PREFIX_0F62) },
2025 { "packsswb", { MX, EM } },
2026 { "pcmpgtb", { MX, EM } },
2027 { "pcmpgtw", { MX, EM } },
2028 { "pcmpgtd", { MX, EM } },
2029 { "packuswb", { MX, EM } },
2031 { "punpckhbw", { MX, EM } },
2032 { "punpckhwd", { MX, EM } },
2033 { "punpckhdq", { MX, EM } },
2034 { "packssdw", { MX, EM } },
2035 { PREFIX_TABLE (PREFIX_0F6C) },
2036 { PREFIX_TABLE (PREFIX_0F6D) },
2037 { "movK", { MX, Edq } },
2038 { PREFIX_TABLE (PREFIX_0F6F) },
2040 { PREFIX_TABLE (PREFIX_0F70) },
2041 { REG_TABLE (REG_0F71) },
2042 { REG_TABLE (REG_0F72) },
2043 { REG_TABLE (REG_0F73) },
2044 { "pcmpeqb", { MX, EM } },
2045 { "pcmpeqw", { MX, EM } },
2046 { "pcmpeqd", { MX, EM } },
2049 { PREFIX_TABLE (PREFIX_0F78) },
2050 { PREFIX_TABLE (PREFIX_0F79) },
2051 { THREE_BYTE_TABLE (THREE_BYTE_0F7A) },
2052 { "(bad)", { XX } },
2053 { PREFIX_TABLE (PREFIX_0F7C) },
2054 { PREFIX_TABLE (PREFIX_0F7D) },
2055 { PREFIX_TABLE (PREFIX_0F7E) },
2056 { PREFIX_TABLE (PREFIX_0F7F) },
2058 { "joH", { Jv, XX, cond_jump_flag } },
2059 { "jnoH", { Jv, XX, cond_jump_flag } },
2060 { "jbH", { Jv, XX, cond_jump_flag } },
2061 { "jaeH", { Jv, XX, cond_jump_flag } },
2062 { "jeH", { Jv, XX, cond_jump_flag } },
2063 { "jneH", { Jv, XX, cond_jump_flag } },
2064 { "jbeH", { Jv, XX, cond_jump_flag } },
2065 { "jaH", { Jv, XX, cond_jump_flag } },
2067 { "jsH", { Jv, XX, cond_jump_flag } },
2068 { "jnsH", { Jv, XX, cond_jump_flag } },
2069 { "jpH", { Jv, XX, cond_jump_flag } },
2070 { "jnpH", { Jv, XX, cond_jump_flag } },
2071 { "jlH", { Jv, XX, cond_jump_flag } },
2072 { "jgeH", { Jv, XX, cond_jump_flag } },
2073 { "jleH", { Jv, XX, cond_jump_flag } },
2074 { "jgH", { Jv, XX, cond_jump_flag } },
2077 { "setno", { Eb } },
2079 { "setae", { Eb } },
2081 { "setne", { Eb } },
2082 { "setbe", { Eb } },
2086 { "setns", { Eb } },
2088 { "setnp", { Eb } },
2090 { "setge", { Eb } },
2091 { "setle", { Eb } },
2094 { "pushT", { fs } },
2096 { "cpuid", { XX } },
2097 { "btS", { Ev, Gv } },
2098 { "shldS", { Ev, Gv, Ib } },
2099 { "shldS", { Ev, Gv, CL } },
2100 { REG_TABLE (REG_0FA6) },
2101 { REG_TABLE (REG_0FA7) },
2103 { "pushT", { gs } },
2106 { "btsS", { Ev, Gv } },
2107 { "shrdS", { Ev, Gv, Ib } },
2108 { "shrdS", { Ev, Gv, CL } },
2109 { REG_TABLE (REG_0FAE) },
2110 { "imulS", { Gv, Ev } },
2112 { "cmpxchgB", { Eb, Gb } },
2113 { "cmpxchgS", { Ev, Gv } },
2114 { MOD_TABLE (MOD_0FB2) },
2115 { "btrS", { Ev, Gv } },
2116 { MOD_TABLE (MOD_0FB4) },
2117 { MOD_TABLE (MOD_0FB5) },
2118 { "movz{bR|x}", { Gv, Eb } },
2119 { "movz{wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
2121 { PREFIX_TABLE (PREFIX_0FB8) },
2123 { REG_TABLE (REG_0FBA) },
2124 { "btcS", { Ev, Gv } },
2125 { "bsfS", { Gv, Ev } },
2126 { PREFIX_TABLE (PREFIX_0FBD) },
2127 { "movs{bR|x}", { Gv, Eb } },
2128 { "movs{wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
2130 { "xaddB", { Eb, Gb } },
2131 { "xaddS", { Ev, Gv } },
2132 { PREFIX_TABLE (PREFIX_0FC2) },
2133 { PREFIX_TABLE (PREFIX_0FC3) },
2134 { "pinsrw", { MX, Edqw, Ib } },
2135 { "pextrw", { Gdq, MS, Ib } },
2136 { "shufpX", { XM, EXx, Ib } },
2137 { REG_TABLE (REG_0FC7) },
2139 { "bswap", { RMeAX } },
2140 { "bswap", { RMeCX } },
2141 { "bswap", { RMeDX } },
2142 { "bswap", { RMeBX } },
2143 { "bswap", { RMeSP } },
2144 { "bswap", { RMeBP } },
2145 { "bswap", { RMeSI } },
2146 { "bswap", { RMeDI } },
2148 { PREFIX_TABLE (PREFIX_0FD0) },
2149 { "psrlw", { MX, EM } },
2150 { "psrld", { MX, EM } },
2151 { "psrlq", { MX, EM } },
2152 { "paddq", { MX, EM } },
2153 { "pmullw", { MX, EM } },
2154 { PREFIX_TABLE (PREFIX_0FD6) },
2155 { MOD_TABLE (MOD_0FD7) },
2157 { "psubusb", { MX, EM } },
2158 { "psubusw", { MX, EM } },
2159 { "pminub", { MX, EM } },
2160 { "pand", { MX, EM } },
2161 { "paddusb", { MX, EM } },
2162 { "paddusw", { MX, EM } },
2163 { "pmaxub", { MX, EM } },
2164 { "pandn", { MX, EM } },
2166 { "pavgb", { MX, EM } },
2167 { "psraw", { MX, EM } },
2168 { "psrad", { MX, EM } },
2169 { "pavgw", { MX, EM } },
2170 { "pmulhuw", { MX, EM } },
2171 { "pmulhw", { MX, EM } },
2172 { PREFIX_TABLE (PREFIX_0FE6) },
2173 { PREFIX_TABLE (PREFIX_0FE7) },
2175 { "psubsb", { MX, EM } },
2176 { "psubsw", { MX, EM } },
2177 { "pminsw", { MX, EM } },
2178 { "por", { MX, EM } },
2179 { "paddsb", { MX, EM } },
2180 { "paddsw", { MX, EM } },
2181 { "pmaxsw", { MX, EM } },
2182 { "pxor", { MX, EM } },
2184 { PREFIX_TABLE (PREFIX_0FF0) },
2185 { "psllw", { MX, EM } },
2186 { "pslld", { MX, EM } },
2187 { "psllq", { MX, EM } },
2188 { "pmuludq", { MX, EM } },
2189 { "pmaddwd", { MX, EM } },
2190 { "psadbw", { MX, EM } },
2191 { PREFIX_TABLE (PREFIX_0FF7) },
2193 { "psubb", { MX, EM } },
2194 { "psubw", { MX, EM } },
2195 { "psubd", { MX, EM } },
2196 { "psubq", { MX, EM } },
2197 { "paddb", { MX, EM } },
2198 { "paddw", { MX, EM } },
2199 { "paddd", { MX, EM } },
2200 { "(bad)", { XX } },
2203 static const unsigned char onebyte_has_modrm[256] = {
2204 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2205 /* ------------------------------- */
2206 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
2207 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
2208 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
2209 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
2210 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
2211 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
2212 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
2213 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
2214 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
2215 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
2216 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
2217 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
2218 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
2219 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
2220 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
2221 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
2222 /* ------------------------------- */
2223 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2226 static const unsigned char twobyte_has_modrm[256] = {
2227 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2228 /* ------------------------------- */
2229 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
2230 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
2231 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
2232 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
2233 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
2234 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
2235 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
2236 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
2237 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
2238 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
2239 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
2240 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
2241 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
2242 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
2243 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
2244 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
2245 /* ------------------------------- */
2246 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
2249 static char obuf[100];
2251 static char *mnemonicendp;
2252 static char scratchbuf[100];
2253 static unsigned char *start_codep;
2254 static unsigned char *insn_codep;
2255 static unsigned char *codep;
2256 static int last_lock_prefix;
2257 static int last_repz_prefix;
2258 static int last_repnz_prefix;
2259 static int last_data_prefix;
2260 static int last_addr_prefix;
2261 static int last_rex_prefix;
2262 static int last_seg_prefix;
2263 #define MAX_CODE_LENGTH 15
2264 /* We can up to 14 prefixes since the maximum instruction length is
2266 static int all_prefixes[MAX_CODE_LENGTH - 1];
2267 static disassemble_info *the_info;
2275 static unsigned char need_modrm;
2278 int register_specifier;
2284 static unsigned char need_vex;
2285 static unsigned char need_vex_reg;
2286 static unsigned char vex_w_done;
2294 /* If we are accessing mod/rm/reg without need_modrm set, then the
2295 values are stale. Hitting this abort likely indicates that you
2296 need to update onebyte_has_modrm or twobyte_has_modrm. */
2297 #define MODRM_CHECK if (!need_modrm) abort ()
2299 static const char **names64;
2300 static const char **names32;
2301 static const char **names16;
2302 static const char **names8;
2303 static const char **names8rex;
2304 static const char **names_seg;
2305 static const char *index64;
2306 static const char *index32;
2307 static const char **index16;
2309 static const char *intel_names64[] = {
2310 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2311 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2313 static const char *intel_names32[] = {
2314 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2315 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2317 static const char *intel_names16[] = {
2318 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2319 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2321 static const char *intel_names8[] = {
2322 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2324 static const char *intel_names8rex[] = {
2325 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2326 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2328 static const char *intel_names_seg[] = {
2329 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2331 static const char *intel_index64 = "riz";
2332 static const char *intel_index32 = "eiz";
2333 static const char *intel_index16[] = {
2334 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2337 static const char *att_names64[] = {
2338 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2339 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2341 static const char *att_names32[] = {
2342 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2343 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2345 static const char *att_names16[] = {
2346 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2347 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2349 static const char *att_names8[] = {
2350 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2352 static const char *att_names8rex[] = {
2353 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2354 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2356 static const char *att_names_seg[] = {
2357 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2359 static const char *att_index64 = "%riz";
2360 static const char *att_index32 = "%eiz";
2361 static const char *att_index16[] = {
2362 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2365 static const struct dis386 reg_table[][8] = {
2368 { "addA", { Eb, Ib } },
2369 { "orA", { Eb, Ib } },
2370 { "adcA", { Eb, Ib } },
2371 { "sbbA", { Eb, Ib } },
2372 { "andA", { Eb, Ib } },
2373 { "subA", { Eb, Ib } },
2374 { "xorA", { Eb, Ib } },
2375 { "cmpA", { Eb, Ib } },
2379 { "addQ", { Ev, Iv } },
2380 { "orQ", { Ev, Iv } },
2381 { "adcQ", { Ev, Iv } },
2382 { "sbbQ", { Ev, Iv } },
2383 { "andQ", { Ev, Iv } },
2384 { "subQ", { Ev, Iv } },
2385 { "xorQ", { Ev, Iv } },
2386 { "cmpQ", { Ev, Iv } },
2390 { "addQ", { Ev, sIb } },
2391 { "orQ", { Ev, sIb } },
2392 { "adcQ", { Ev, sIb } },
2393 { "sbbQ", { Ev, sIb } },
2394 { "andQ", { Ev, sIb } },
2395 { "subQ", { Ev, sIb } },
2396 { "xorQ", { Ev, sIb } },
2397 { "cmpQ", { Ev, sIb } },
2401 { "popU", { stackEv } },
2402 { XOP_8F_TABLE (XOP_09) },
2403 { "(bad)", { XX } },
2404 { "(bad)", { XX } },
2405 { "(bad)", { XX } },
2406 { XOP_8F_TABLE (XOP_09) },
2407 { "(bad)", { XX } },
2408 { "(bad)", { XX } },
2412 { "rolA", { Eb, Ib } },
2413 { "rorA", { Eb, Ib } },
2414 { "rclA", { Eb, Ib } },
2415 { "rcrA", { Eb, Ib } },
2416 { "shlA", { Eb, Ib } },
2417 { "shrA", { Eb, Ib } },
2418 { "(bad)", { XX } },
2419 { "sarA", { Eb, Ib } },
2423 { "rolQ", { Ev, Ib } },
2424 { "rorQ", { Ev, Ib } },
2425 { "rclQ", { Ev, Ib } },
2426 { "rcrQ", { Ev, Ib } },
2427 { "shlQ", { Ev, Ib } },
2428 { "shrQ", { Ev, Ib } },
2429 { "(bad)", { XX } },
2430 { "sarQ", { Ev, Ib } },
2434 { "movA", { Eb, Ib } },
2435 { "(bad)", { XX } },
2436 { "(bad)", { XX } },
2437 { "(bad)", { XX } },
2438 { "(bad)", { XX } },
2439 { "(bad)", { XX } },
2440 { "(bad)", { XX } },
2441 { "(bad)", { XX } },
2445 { "movQ", { Ev, Iv } },
2446 { "(bad)", { XX } },
2447 { "(bad)", { XX } },
2448 { "(bad)", { XX } },
2449 { "(bad)", { XX } },
2450 { "(bad)", { XX } },
2451 { "(bad)", { XX } },
2452 { "(bad)", { XX } },
2456 { "rolA", { Eb, I1 } },
2457 { "rorA", { Eb, I1 } },
2458 { "rclA", { Eb, I1 } },
2459 { "rcrA", { Eb, I1 } },
2460 { "shlA", { Eb, I1 } },
2461 { "shrA", { Eb, I1 } },
2462 { "(bad)", { XX } },
2463 { "sarA", { Eb, I1 } },
2467 { "rolQ", { Ev, I1 } },
2468 { "rorQ", { Ev, I1 } },
2469 { "rclQ", { Ev, I1 } },
2470 { "rcrQ", { Ev, I1 } },
2471 { "shlQ", { Ev, I1 } },
2472 { "shrQ", { Ev, I1 } },
2473 { "(bad)", { XX } },
2474 { "sarQ", { Ev, I1 } },
2478 { "rolA", { Eb, CL } },
2479 { "rorA", { Eb, CL } },
2480 { "rclA", { Eb, CL } },
2481 { "rcrA", { Eb, CL } },
2482 { "shlA", { Eb, CL } },
2483 { "shrA", { Eb, CL } },
2484 { "(bad)", { XX } },
2485 { "sarA", { Eb, CL } },
2489 { "rolQ", { Ev, CL } },
2490 { "rorQ", { Ev, CL } },
2491 { "rclQ", { Ev, CL } },
2492 { "rcrQ", { Ev, CL } },
2493 { "shlQ", { Ev, CL } },
2494 { "shrQ", { Ev, CL } },
2495 { "(bad)", { XX } },
2496 { "sarQ", { Ev, CL } },
2500 { "testA", { Eb, Ib } },
2501 { "(bad)", { XX } },
2504 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
2505 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
2506 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
2507 { "idivA", { Eb } }, /* and idiv for consistency. */
2511 { "testQ", { Ev, Iv } },
2512 { "(bad)", { XX } },
2515 { "mulQ", { Ev } }, /* Don't print the implicit register. */
2516 { "imulQ", { Ev } },
2518 { "idivQ", { Ev } },
2524 { "(bad)", { XX } },
2525 { "(bad)", { XX } },
2526 { "(bad)", { XX } },
2527 { "(bad)", { XX } },
2528 { "(bad)", { XX } },
2529 { "(bad)", { XX } },
2535 { "callT", { indirEv } },
2536 { "JcallT", { indirEp } },
2537 { "jmpT", { indirEv } },
2538 { "JjmpT", { indirEp } },
2539 { "pushU", { stackEv } },
2540 { "(bad)", { XX } },
2544 { "sldtD", { Sv } },
2550 { "(bad)", { XX } },
2551 { "(bad)", { XX } },
2555 { MOD_TABLE (MOD_0F01_REG_0) },
2556 { MOD_TABLE (MOD_0F01_REG_1) },
2557 { MOD_TABLE (MOD_0F01_REG_2) },
2558 { MOD_TABLE (MOD_0F01_REG_3) },
2559 { "smswD", { Sv } },
2560 { "(bad)", { XX } },
2562 { MOD_TABLE (MOD_0F01_REG_7) },
2566 { "prefetch", { Eb } },
2567 { "prefetchw", { Eb } },
2568 { "(bad)", { XX } },
2569 { "(bad)", { XX } },
2570 { "(bad)", { XX } },
2571 { "(bad)", { XX } },
2572 { "(bad)", { XX } },
2573 { "(bad)", { XX } },
2577 { MOD_TABLE (MOD_0F18_REG_0) },
2578 { MOD_TABLE (MOD_0F18_REG_1) },
2579 { MOD_TABLE (MOD_0F18_REG_2) },
2580 { MOD_TABLE (MOD_0F18_REG_3) },
2581 { "(bad)", { XX } },
2582 { "(bad)", { XX } },
2583 { "(bad)", { XX } },
2584 { "(bad)", { XX } },
2588 { "(bad)", { XX } },
2589 { "(bad)", { XX } },
2590 { MOD_TABLE (MOD_0F71_REG_2) },
2591 { "(bad)", { XX } },
2592 { MOD_TABLE (MOD_0F71_REG_4) },
2593 { "(bad)", { XX } },
2594 { MOD_TABLE (MOD_0F71_REG_6) },
2595 { "(bad)", { XX } },
2599 { "(bad)", { XX } },
2600 { "(bad)", { XX } },
2601 { MOD_TABLE (MOD_0F72_REG_2) },
2602 { "(bad)", { XX } },
2603 { MOD_TABLE (MOD_0F72_REG_4) },
2604 { "(bad)", { XX } },
2605 { MOD_TABLE (MOD_0F72_REG_6) },
2606 { "(bad)", { XX } },
2610 { "(bad)", { XX } },
2611 { "(bad)", { XX } },
2612 { MOD_TABLE (MOD_0F73_REG_2) },
2613 { MOD_TABLE (MOD_0F73_REG_3) },
2614 { "(bad)", { XX } },
2615 { "(bad)", { XX } },
2616 { MOD_TABLE (MOD_0F73_REG_6) },
2617 { MOD_TABLE (MOD_0F73_REG_7) },
2621 { "montmul", { { OP_0f07, 0 } } },
2622 { "xsha1", { { OP_0f07, 0 } } },
2623 { "xsha256", { { OP_0f07, 0 } } },
2624 { "(bad)", { { OP_0f07, 0 } } },
2625 { "(bad)", { { OP_0f07, 0 } } },
2626 { "(bad)", { { OP_0f07, 0 } } },
2627 { "(bad)", { { OP_0f07, 0 } } },
2628 { "(bad)", { { OP_0f07, 0 } } },
2632 { "xstore-rng", { { OP_0f07, 0 } } },
2633 { "xcrypt-ecb", { { OP_0f07, 0 } } },
2634 { "xcrypt-cbc", { { OP_0f07, 0 } } },
2635 { "xcrypt-ctr", { { OP_0f07, 0 } } },
2636 { "xcrypt-cfb", { { OP_0f07, 0 } } },
2637 { "xcrypt-ofb", { { OP_0f07, 0 } } },
2638 { "(bad)", { { OP_0f07, 0 } } },
2639 { "(bad)", { { OP_0f07, 0 } } },
2643 { MOD_TABLE (MOD_0FAE_REG_0) },
2644 { MOD_TABLE (MOD_0FAE_REG_1) },
2645 { MOD_TABLE (MOD_0FAE_REG_2) },
2646 { MOD_TABLE (MOD_0FAE_REG_3) },
2647 { MOD_TABLE (MOD_0FAE_REG_4) },
2648 { MOD_TABLE (MOD_0FAE_REG_5) },
2649 { MOD_TABLE (MOD_0FAE_REG_6) },
2650 { MOD_TABLE (MOD_0FAE_REG_7) },
2654 { "(bad)", { XX } },
2655 { "(bad)", { XX } },
2656 { "(bad)", { XX } },
2657 { "(bad)", { XX } },
2658 { "btQ", { Ev, Ib } },
2659 { "btsQ", { Ev, Ib } },
2660 { "btrQ", { Ev, Ib } },
2661 { "btcQ", { Ev, Ib } },
2665 { "(bad)", { XX } },
2666 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
2667 { "(bad)", { XX } },
2668 { "(bad)", { XX } },
2669 { "(bad)", { XX } },
2670 { "(bad)", { XX } },
2671 { MOD_TABLE (MOD_0FC7_REG_6) },
2672 { MOD_TABLE (MOD_0FC7_REG_7) },
2676 { "(bad)", { XX } },
2677 { "(bad)", { XX } },
2678 { MOD_TABLE (MOD_VEX_71_REG_2) },
2679 { "(bad)", { XX } },
2680 { MOD_TABLE (MOD_VEX_71_REG_4) },
2681 { "(bad)", { XX } },
2682 { MOD_TABLE (MOD_VEX_71_REG_6) },
2683 { "(bad)", { XX } },
2687 { "(bad)", { XX } },
2688 { "(bad)", { XX } },
2689 { MOD_TABLE (MOD_VEX_72_REG_2) },
2690 { "(bad)", { XX } },
2691 { MOD_TABLE (MOD_VEX_72_REG_4) },
2692 { "(bad)", { XX } },
2693 { MOD_TABLE (MOD_VEX_72_REG_6) },
2694 { "(bad)", { XX } },
2698 { "(bad)", { XX } },
2699 { "(bad)", { XX } },
2700 { MOD_TABLE (MOD_VEX_73_REG_2) },
2701 { MOD_TABLE (MOD_VEX_73_REG_3) },
2702 { "(bad)", { XX } },
2703 { "(bad)", { XX } },
2704 { MOD_TABLE (MOD_VEX_73_REG_6) },
2705 { MOD_TABLE (MOD_VEX_73_REG_7) },
2709 { "(bad)", { XX } },
2710 { "(bad)", { XX } },
2711 { MOD_TABLE (MOD_VEX_AE_REG_2) },
2712 { MOD_TABLE (MOD_VEX_AE_REG_3) },
2713 { "(bad)", { XX } },
2714 { "(bad)", { XX } },
2715 { "(bad)", { XX } },
2716 { "(bad)", { XX } },
2720 { "llwpcb", { { OP_LWPCB_E, 0 } } },
2721 { "slwpcb", { { OP_LWPCB_E, 0 } } },
2722 { "(bad)", { XX } },
2723 { "(bad)", { XX } },
2724 { "(bad)", { XX } },
2725 { "(bad)", { XX } },
2726 { "(bad)", { XX } },
2727 { "(bad)", { XX } },
2731 { "lwpins", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2732 { "lwpval", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2733 { "(bad)", { XX } },
2734 { "(bad)", { XX } },
2735 { "(bad)", { XX } },
2736 { "(bad)", { XX } },
2737 { "(bad)", { XX } },
2738 { "(bad)", { XX } },
2742 static const struct dis386 prefix_table[][4] = {
2745 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2746 { "pause", { XX } },
2747 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2748 { "(bad)", { XX } },
2753 { "movups", { XM, EXx } },
2754 { "movss", { XM, EXd } },
2755 { "movupd", { XM, EXx } },
2756 { "movsd", { XM, EXq } },
2761 { "movups", { EXxS, XM } },
2762 { "movss", { EXdS, XM } },
2763 { "movupd", { EXxS, XM } },
2764 { "movsd", { EXqS, XM } },
2769 { MOD_TABLE (MOD_0F12_PREFIX_0) },
2770 { "movsldup", { XM, EXx } },
2771 { "movlpd", { XM, EXq } },
2772 { "movddup", { XM, EXq } },
2777 { MOD_TABLE (MOD_0F16_PREFIX_0) },
2778 { "movshdup", { XM, EXx } },
2779 { "movhpd", { XM, EXq } },
2780 { "(bad)", { XX } },
2785 { "cvtpi2ps", { XM, EMCq } },
2786 { "cvtsi2ss%LQ", { XM, Ev } },
2787 { "cvtpi2pd", { XM, EMCq } },
2788 { "cvtsi2sd%LQ", { XM, Ev } },
2793 { MOD_TABLE (MOD_0F2B_PREFIX_0) },
2794 { MOD_TABLE (MOD_0F2B_PREFIX_1) },
2795 { MOD_TABLE (MOD_0F2B_PREFIX_2) },
2796 { MOD_TABLE (MOD_0F2B_PREFIX_3) },
2801 { "cvttps2pi", { MXC, EXq } },
2802 { "cvttss2siY", { Gv, EXd } },
2803 { "cvttpd2pi", { MXC, EXx } },
2804 { "cvttsd2siY", { Gv, EXq } },
2809 { "cvtps2pi", { MXC, EXq } },
2810 { "cvtss2siY", { Gv, EXd } },
2811 { "cvtpd2pi", { MXC, EXx } },
2812 { "cvtsd2siY", { Gv, EXq } },
2817 { "ucomiss",{ XM, EXd } },
2818 { "(bad)", { XX } },
2819 { "ucomisd",{ XM, EXq } },
2820 { "(bad)", { XX } },
2825 { "comiss", { XM, EXd } },
2826 { "(bad)", { XX } },
2827 { "comisd", { XM, EXq } },
2828 { "(bad)", { XX } },
2833 { "sqrtps", { XM, EXx } },
2834 { "sqrtss", { XM, EXd } },
2835 { "sqrtpd", { XM, EXx } },
2836 { "sqrtsd", { XM, EXq } },
2841 { "rsqrtps",{ XM, EXx } },
2842 { "rsqrtss",{ XM, EXd } },
2843 { "(bad)", { XX } },
2844 { "(bad)", { XX } },
2849 { "rcpps", { XM, EXx } },
2850 { "rcpss", { XM, EXd } },
2851 { "(bad)", { XX } },
2852 { "(bad)", { XX } },
2857 { "addps", { XM, EXx } },
2858 { "addss", { XM, EXd } },
2859 { "addpd", { XM, EXx } },
2860 { "addsd", { XM, EXq } },
2865 { "mulps", { XM, EXx } },
2866 { "mulss", { XM, EXd } },
2867 { "mulpd", { XM, EXx } },
2868 { "mulsd", { XM, EXq } },
2873 { "cvtps2pd", { XM, EXq } },
2874 { "cvtss2sd", { XM, EXd } },
2875 { "cvtpd2ps", { XM, EXx } },
2876 { "cvtsd2ss", { XM, EXq } },
2881 { "cvtdq2ps", { XM, EXx } },
2882 { "cvttps2dq", { XM, EXx } },
2883 { "cvtps2dq", { XM, EXx } },
2884 { "(bad)", { XX } },
2889 { "subps", { XM, EXx } },
2890 { "subss", { XM, EXd } },
2891 { "subpd", { XM, EXx } },
2892 { "subsd", { XM, EXq } },
2897 { "minps", { XM, EXx } },
2898 { "minss", { XM, EXd } },
2899 { "minpd", { XM, EXx } },
2900 { "minsd", { XM, EXq } },
2905 { "divps", { XM, EXx } },
2906 { "divss", { XM, EXd } },
2907 { "divpd", { XM, EXx } },
2908 { "divsd", { XM, EXq } },
2913 { "maxps", { XM, EXx } },
2914 { "maxss", { XM, EXd } },
2915 { "maxpd", { XM, EXx } },
2916 { "maxsd", { XM, EXq } },
2921 { "punpcklbw",{ MX, EMd } },
2922 { "(bad)", { XX } },
2923 { "punpcklbw",{ MX, EMx } },
2924 { "(bad)", { XX } },
2929 { "punpcklwd",{ MX, EMd } },
2930 { "(bad)", { XX } },
2931 { "punpcklwd",{ MX, EMx } },
2932 { "(bad)", { XX } },
2937 { "punpckldq",{ MX, EMd } },
2938 { "(bad)", { XX } },
2939 { "punpckldq",{ MX, EMx } },
2940 { "(bad)", { XX } },
2945 { "(bad)", { XX } },
2946 { "(bad)", { XX } },
2947 { "punpcklqdq", { XM, EXx } },
2948 { "(bad)", { XX } },
2953 { "(bad)", { XX } },
2954 { "(bad)", { XX } },
2955 { "punpckhqdq", { XM, EXx } },
2956 { "(bad)", { XX } },
2961 { "movq", { MX, EM } },
2962 { "movdqu", { XM, EXx } },
2963 { "movdqa", { XM, EXx } },
2964 { "(bad)", { XX } },
2969 { "pshufw", { MX, EM, Ib } },
2970 { "pshufhw",{ XM, EXx, Ib } },
2971 { "pshufd", { XM, EXx, Ib } },
2972 { "pshuflw",{ XM, EXx, Ib } },
2975 /* PREFIX_0F73_REG_3 */
2977 { "(bad)", { XX } },
2978 { "(bad)", { XX } },
2979 { "psrldq", { XS, Ib } },
2980 { "(bad)", { XX } },
2983 /* PREFIX_0F73_REG_7 */
2985 { "(bad)", { XX } },
2986 { "(bad)", { XX } },
2987 { "pslldq", { XS, Ib } },
2988 { "(bad)", { XX } },
2993 {"vmread", { Em, Gm } },
2995 {"extrq", { XS, Ib, Ib } },
2996 {"insertq", { XM, XS, Ib, Ib } },
3001 {"vmwrite", { Gm, Em } },
3003 {"extrq", { XM, XS } },
3004 {"insertq", { XM, XS } },
3009 { "(bad)", { XX } },
3010 { "(bad)", { XX } },
3011 { "haddpd", { XM, EXx } },
3012 { "haddps", { XM, EXx } },
3017 { "(bad)", { XX } },
3018 { "(bad)", { XX } },
3019 { "hsubpd", { XM, EXx } },
3020 { "hsubps", { XM, EXx } },
3025 { "movK", { Edq, MX } },
3026 { "movq", { XM, EXq } },
3027 { "movK", { Edq, XM } },
3028 { "(bad)", { XX } },
3033 { "movq", { EMS, MX } },
3034 { "movdqu", { EXxS, XM } },
3035 { "movdqa", { EXxS, XM } },
3036 { "(bad)", { XX } },
3041 { "(bad)", { XX } },
3042 { "popcntS", { Gv, Ev } },
3043 { "(bad)", { XX } },
3044 { "(bad)", { XX } },
3049 { "bsrS", { Gv, Ev } },
3050 { "lzcntS", { Gv, Ev } },
3051 { "bsrS", { Gv, Ev } },
3052 { "(bad)", { XX } },
3057 { "cmpps", { XM, EXx, CMP } },
3058 { "cmpss", { XM, EXd, CMP } },
3059 { "cmppd", { XM, EXx, CMP } },
3060 { "cmpsd", { XM, EXq, CMP } },
3065 { "movntiS", { Ma, Gv } },
3066 { "(bad)", { XX } },
3067 { "(bad)", { XX } },
3068 { "(bad)", { XX } },
3071 /* PREFIX_0FC7_REG_6 */
3073 { "vmptrld",{ Mq } },
3074 { "vmxon", { Mq } },
3075 { "vmclear",{ Mq } },
3076 { "(bad)", { XX } },
3081 { "(bad)", { XX } },
3082 { "(bad)", { XX } },
3083 { "addsubpd", { XM, EXx } },
3084 { "addsubps", { XM, EXx } },
3089 { "(bad)", { XX } },
3090 { "movq2dq",{ XM, MS } },
3091 { "movq", { EXqS, XM } },
3092 { "movdq2q",{ MX, XS } },
3097 { "(bad)", { XX } },
3098 { "cvtdq2pd", { XM, EXq } },
3099 { "cvttpd2dq", { XM, EXx } },
3100 { "cvtpd2dq", { XM, EXx } },
3105 { "movntq", { Mq, MX } },
3106 { "(bad)", { XX } },
3107 { MOD_TABLE (MOD_0FE7_PREFIX_2) },
3108 { "(bad)", { XX } },
3113 { "(bad)", { XX } },
3114 { "(bad)", { XX } },
3115 { "(bad)", { XX } },
3116 { MOD_TABLE (MOD_0FF0_PREFIX_3) },
3121 { "maskmovq", { MX, MS } },
3122 { "(bad)", { XX } },
3123 { "maskmovdqu", { XM, XS } },
3124 { "(bad)", { XX } },
3129 { "(bad)", { XX } },
3130 { "(bad)", { XX } },
3131 { "pblendvb", { XM, EXx, XMM0 } },
3132 { "(bad)", { XX } },
3137 { "(bad)", { XX } },
3138 { "(bad)", { XX } },
3139 { "blendvps", { XM, EXx, XMM0 } },
3140 { "(bad)", { XX } },
3145 { "(bad)", { XX } },
3146 { "(bad)", { XX } },
3147 { "blendvpd", { XM, EXx, XMM0 } },
3148 { "(bad)", { XX } },
3153 { "(bad)", { XX } },
3154 { "(bad)", { XX } },
3155 { "ptest", { XM, EXx } },
3156 { "(bad)", { XX } },
3161 { "(bad)", { XX } },
3162 { "(bad)", { XX } },
3163 { "pmovsxbw", { XM, EXq } },
3164 { "(bad)", { XX } },
3169 { "(bad)", { XX } },
3170 { "(bad)", { XX } },
3171 { "pmovsxbd", { XM, EXd } },
3172 { "(bad)", { XX } },
3177 { "(bad)", { XX } },
3178 { "(bad)", { XX } },
3179 { "pmovsxbq", { XM, EXw } },
3180 { "(bad)", { XX } },
3185 { "(bad)", { XX } },
3186 { "(bad)", { XX } },
3187 { "pmovsxwd", { XM, EXq } },
3188 { "(bad)", { XX } },
3193 { "(bad)", { XX } },
3194 { "(bad)", { XX } },
3195 { "pmovsxwq", { XM, EXd } },
3196 { "(bad)", { XX } },
3201 { "(bad)", { XX } },
3202 { "(bad)", { XX } },
3203 { "pmovsxdq", { XM, EXq } },
3204 { "(bad)", { XX } },
3209 { "(bad)", { XX } },
3210 { "(bad)", { XX } },
3211 { "pmuldq", { XM, EXx } },
3212 { "(bad)", { XX } },
3217 { "(bad)", { XX } },
3218 { "(bad)", { XX } },
3219 { "pcmpeqq", { XM, EXx } },
3220 { "(bad)", { XX } },
3225 { "(bad)", { XX } },
3226 { "(bad)", { XX } },
3227 { MOD_TABLE (MOD_0F382A_PREFIX_2) },
3228 { "(bad)", { XX } },
3233 { "(bad)", { XX } },
3234 { "(bad)", { XX } },
3235 { "packusdw", { XM, EXx } },
3236 { "(bad)", { XX } },
3241 { "(bad)", { XX } },
3242 { "(bad)", { XX } },
3243 { "pmovzxbw", { XM, EXq } },
3244 { "(bad)", { XX } },
3249 { "(bad)", { XX } },
3250 { "(bad)", { XX } },
3251 { "pmovzxbd", { XM, EXd } },
3252 { "(bad)", { XX } },
3257 { "(bad)", { XX } },
3258 { "(bad)", { XX } },
3259 { "pmovzxbq", { XM, EXw } },
3260 { "(bad)", { XX } },
3265 { "(bad)", { XX } },
3266 { "(bad)", { XX } },
3267 { "pmovzxwd", { XM, EXq } },
3268 { "(bad)", { XX } },
3273 { "(bad)", { XX } },
3274 { "(bad)", { XX } },
3275 { "pmovzxwq", { XM, EXd } },
3276 { "(bad)", { XX } },
3281 { "(bad)", { XX } },
3282 { "(bad)", { XX } },
3283 { "pmovzxdq", { XM, EXq } },
3284 { "(bad)", { XX } },
3289 { "(bad)", { XX } },
3290 { "(bad)", { XX } },
3291 { "pcmpgtq", { XM, EXx } },
3292 { "(bad)", { XX } },
3297 { "(bad)", { XX } },
3298 { "(bad)", { XX } },
3299 { "pminsb", { XM, EXx } },
3300 { "(bad)", { XX } },
3305 { "(bad)", { XX } },
3306 { "(bad)", { XX } },
3307 { "pminsd", { XM, EXx } },
3308 { "(bad)", { XX } },
3313 { "(bad)", { XX } },
3314 { "(bad)", { XX } },
3315 { "pminuw", { XM, EXx } },
3316 { "(bad)", { XX } },
3321 { "(bad)", { XX } },
3322 { "(bad)", { XX } },
3323 { "pminud", { XM, EXx } },
3324 { "(bad)", { XX } },
3329 { "(bad)", { XX } },
3330 { "(bad)", { XX } },
3331 { "pmaxsb", { XM, EXx } },
3332 { "(bad)", { XX } },
3337 { "(bad)", { XX } },
3338 { "(bad)", { XX } },
3339 { "pmaxsd", { XM, EXx } },
3340 { "(bad)", { XX } },
3345 { "(bad)", { XX } },
3346 { "(bad)", { XX } },
3347 { "pmaxuw", { XM, EXx } },
3348 { "(bad)", { XX } },
3353 { "(bad)", { XX } },
3354 { "(bad)", { XX } },
3355 { "pmaxud", { XM, EXx } },
3356 { "(bad)", { XX } },
3361 { "(bad)", { XX } },
3362 { "(bad)", { XX } },
3363 { "pmulld", { XM, EXx } },
3364 { "(bad)", { XX } },
3369 { "(bad)", { XX } },
3370 { "(bad)", { XX } },
3371 { "phminposuw", { XM, EXx } },
3372 { "(bad)", { XX } },
3377 { "(bad)", { XX } },
3378 { "(bad)", { XX } },
3379 { "invept", { Gm, Mo } },
3380 { "(bad)", { XX } },
3385 { "(bad)", { XX } },
3386 { "(bad)", { XX } },
3387 { "invvpid", { Gm, Mo } },
3388 { "(bad)", { XX } },
3393 { "(bad)", { XX } },
3394 { "(bad)", { XX } },
3395 { "aesimc", { XM, EXx } },
3396 { "(bad)", { XX } },
3401 { "(bad)", { XX } },
3402 { "(bad)", { XX } },
3403 { "aesenc", { XM, EXx } },
3404 { "(bad)", { XX } },
3409 { "(bad)", { XX } },
3410 { "(bad)", { XX } },
3411 { "aesenclast", { XM, EXx } },
3412 { "(bad)", { XX } },
3417 { "(bad)", { XX } },
3418 { "(bad)", { XX } },
3419 { "aesdec", { XM, EXx } },
3420 { "(bad)", { XX } },
3425 { "(bad)", { XX } },
3426 { "(bad)", { XX } },
3427 { "aesdeclast", { XM, EXx } },
3428 { "(bad)", { XX } },
3433 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3434 { "(bad)", { XX } },
3435 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3436 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
3441 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3442 { "(bad)", { XX } },
3443 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3444 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
3449 { "(bad)", { XX } },
3450 { "(bad)", { XX } },
3451 { "roundps", { XM, EXx, Ib } },
3452 { "(bad)", { XX } },
3457 { "(bad)", { XX } },
3458 { "(bad)", { XX } },
3459 { "roundpd", { XM, EXx, Ib } },
3460 { "(bad)", { XX } },
3465 { "(bad)", { XX } },
3466 { "(bad)", { XX } },
3467 { "roundss", { XM, EXd, Ib } },
3468 { "(bad)", { XX } },
3473 { "(bad)", { XX } },
3474 { "(bad)", { XX } },
3475 { "roundsd", { XM, EXq, Ib } },
3476 { "(bad)", { XX } },
3481 { "(bad)", { XX } },
3482 { "(bad)", { XX } },
3483 { "blendps", { XM, EXx, Ib } },
3484 { "(bad)", { XX } },
3489 { "(bad)", { XX } },
3490 { "(bad)", { XX } },
3491 { "blendpd", { XM, EXx, Ib } },
3492 { "(bad)", { XX } },
3497 { "(bad)", { XX } },
3498 { "(bad)", { XX } },
3499 { "pblendw", { XM, EXx, Ib } },
3500 { "(bad)", { XX } },
3505 { "(bad)", { XX } },
3506 { "(bad)", { XX } },
3507 { "pextrb", { Edqb, XM, Ib } },
3508 { "(bad)", { XX } },
3513 { "(bad)", { XX } },
3514 { "(bad)", { XX } },
3515 { "pextrw", { Edqw, XM, Ib } },
3516 { "(bad)", { XX } },
3521 { "(bad)", { XX } },
3522 { "(bad)", { XX } },
3523 { "pextrK", { Edq, XM, Ib } },
3524 { "(bad)", { XX } },
3529 { "(bad)", { XX } },
3530 { "(bad)", { XX } },
3531 { "extractps", { Edqd, XM, Ib } },
3532 { "(bad)", { XX } },
3537 { "(bad)", { XX } },
3538 { "(bad)", { XX } },
3539 { "pinsrb", { XM, Edqb, Ib } },
3540 { "(bad)", { XX } },
3545 { "(bad)", { XX } },
3546 { "(bad)", { XX } },
3547 { "insertps", { XM, EXd, Ib } },
3548 { "(bad)", { XX } },
3553 { "(bad)", { XX } },
3554 { "(bad)", { XX } },
3555 { "pinsrK", { XM, Edq, Ib } },
3556 { "(bad)", { XX } },
3561 { "(bad)", { XX } },
3562 { "(bad)", { XX } },
3563 { "dpps", { XM, EXx, Ib } },
3564 { "(bad)", { XX } },
3569 { "(bad)", { XX } },
3570 { "(bad)", { XX } },
3571 { "dppd", { XM, EXx, Ib } },
3572 { "(bad)", { XX } },
3577 { "(bad)", { XX } },
3578 { "(bad)", { XX } },
3579 { "mpsadbw", { XM, EXx, Ib } },
3580 { "(bad)", { XX } },
3585 { "(bad)", { XX } },
3586 { "(bad)", { XX } },
3587 { "pclmulqdq", { XM, EXx, PCLMUL } },
3588 { "(bad)", { XX } },
3593 { "(bad)", { XX } },
3594 { "(bad)", { XX } },
3595 { "pcmpestrm", { XM, EXx, Ib } },
3596 { "(bad)", { XX } },
3601 { "(bad)", { XX } },
3602 { "(bad)", { XX } },
3603 { "pcmpestri", { XM, EXx, Ib } },
3604 { "(bad)", { XX } },
3609 { "(bad)", { XX } },
3610 { "(bad)", { XX } },
3611 { "pcmpistrm", { XM, EXx, Ib } },
3612 { "(bad)", { XX } },
3617 { "(bad)", { XX } },
3618 { "(bad)", { XX } },
3619 { "pcmpistri", { XM, EXx, Ib } },
3620 { "(bad)", { XX } },
3625 { "(bad)", { XX } },
3626 { "(bad)", { XX } },
3627 { "aeskeygenassist", { XM, EXx, Ib } },
3628 { "(bad)", { XX } },
3633 { VEX_W_TABLE (VEX_W_10_P_0) },
3634 { VEX_LEN_TABLE (VEX_LEN_10_P_1) },
3635 { VEX_W_TABLE (VEX_W_10_P_2) },
3636 { VEX_LEN_TABLE (VEX_LEN_10_P_3) },
3641 { VEX_W_TABLE (VEX_W_11_P_0) },
3642 { VEX_LEN_TABLE (VEX_LEN_11_P_1) },
3643 { VEX_W_TABLE (VEX_W_11_P_2) },
3644 { VEX_LEN_TABLE (VEX_LEN_11_P_3) },
3649 { MOD_TABLE (MOD_VEX_12_PREFIX_0) },
3650 { VEX_W_TABLE (VEX_W_12_P_1) },
3651 { VEX_LEN_TABLE (VEX_LEN_12_P_2) },
3652 { VEX_W_TABLE (VEX_W_12_P_3) },
3657 { MOD_TABLE (MOD_VEX_16_PREFIX_0) },
3658 { VEX_W_TABLE (VEX_W_16_P_1) },
3659 { VEX_LEN_TABLE (VEX_LEN_16_P_2) },
3660 { "(bad)", { XX } },
3665 { "(bad)", { XX } },
3666 { VEX_LEN_TABLE (VEX_LEN_2A_P_1) },
3667 { "(bad)", { XX } },
3668 { VEX_LEN_TABLE (VEX_LEN_2A_P_3) },
3673 { "(bad)", { XX } },
3674 { VEX_LEN_TABLE (VEX_LEN_2C_P_1) },
3675 { "(bad)", { XX } },
3676 { VEX_LEN_TABLE (VEX_LEN_2C_P_3) },
3681 { "(bad)", { XX } },
3682 { VEX_LEN_TABLE (VEX_LEN_2D_P_1) },
3683 { "(bad)", { XX } },
3684 { VEX_LEN_TABLE (VEX_LEN_2D_P_3) },
3689 { VEX_LEN_TABLE (VEX_LEN_2E_P_0) },
3690 { "(bad)", { XX } },
3691 { VEX_LEN_TABLE (VEX_LEN_2E_P_2) },
3692 { "(bad)", { XX } },
3697 { VEX_LEN_TABLE (VEX_LEN_2F_P_0) },
3698 { "(bad)", { XX } },
3699 { VEX_LEN_TABLE (VEX_LEN_2F_P_2) },
3700 { "(bad)", { XX } },
3705 { VEX_W_TABLE (VEX_W_51_P_0) },
3706 { VEX_LEN_TABLE (VEX_LEN_51_P_1) },
3707 { VEX_W_TABLE (VEX_W_51_P_2) },
3708 { VEX_LEN_TABLE (VEX_LEN_51_P_3) },
3713 { VEX_W_TABLE (VEX_W_52_P_0) },
3714 { VEX_LEN_TABLE (VEX_LEN_52_P_1) },
3715 { "(bad)", { XX } },
3716 { "(bad)", { XX } },
3721 { VEX_W_TABLE (VEX_W_53_P_0) },
3722 { VEX_LEN_TABLE (VEX_LEN_53_P_1) },
3723 { "(bad)", { XX } },
3724 { "(bad)", { XX } },
3729 { VEX_W_TABLE (VEX_W_58_P_0) },
3730 { VEX_LEN_TABLE (VEX_LEN_58_P_1) },
3731 { VEX_W_TABLE (VEX_W_58_P_2) },
3732 { VEX_LEN_TABLE (VEX_LEN_58_P_3) },
3737 { VEX_W_TABLE (VEX_W_59_P_0) },
3738 { VEX_LEN_TABLE (VEX_LEN_59_P_1) },
3739 { VEX_W_TABLE (VEX_W_59_P_2) },
3740 { VEX_LEN_TABLE (VEX_LEN_59_P_3) },
3745 { VEX_W_TABLE (VEX_W_5A_P_0) },
3746 { VEX_LEN_TABLE (VEX_LEN_5A_P_1) },
3747 { "vcvtpd2ps%XY", { XMM, EXx } },
3748 { VEX_LEN_TABLE (VEX_LEN_5A_P_3) },
3753 { VEX_W_TABLE (VEX_W_5B_P_0) },
3754 { VEX_W_TABLE (VEX_W_5B_P_1) },
3755 { VEX_W_TABLE (VEX_W_5B_P_2) },
3756 { "(bad)", { XX } },
3761 { VEX_W_TABLE (VEX_W_5C_P_0) },
3762 { VEX_LEN_TABLE (VEX_LEN_5C_P_1) },
3763 { VEX_W_TABLE (VEX_W_5C_P_2) },
3764 { VEX_LEN_TABLE (VEX_LEN_5C_P_3) },
3769 { VEX_W_TABLE (VEX_W_5D_P_0) },
3770 { VEX_LEN_TABLE (VEX_LEN_5D_P_1) },
3771 { VEX_W_TABLE (VEX_W_5D_P_2) },
3772 { VEX_LEN_TABLE (VEX_LEN_5D_P_3) },
3777 { VEX_W_TABLE (VEX_W_5E_P_0) },
3778 { VEX_LEN_TABLE (VEX_LEN_5E_P_1) },
3779 { VEX_W_TABLE (VEX_W_5E_P_2) },
3780 { VEX_LEN_TABLE (VEX_LEN_5E_P_3) },
3785 { VEX_W_TABLE (VEX_W_5F_P_0) },
3786 { VEX_LEN_TABLE (VEX_LEN_5F_P_1) },
3787 { VEX_W_TABLE (VEX_W_5F_P_2) },
3788 { VEX_LEN_TABLE (VEX_LEN_5F_P_3) },
3793 { "(bad)", { XX } },
3794 { "(bad)", { XX } },
3795 { VEX_LEN_TABLE (VEX_LEN_60_P_2) },
3796 { "(bad)", { XX } },
3801 { "(bad)", { XX } },
3802 { "(bad)", { XX } },
3803 { VEX_LEN_TABLE (VEX_LEN_61_P_2) },
3804 { "(bad)", { XX } },
3809 { "(bad)", { XX } },
3810 { "(bad)", { XX } },
3811 { VEX_LEN_TABLE (VEX_LEN_62_P_2) },
3812 { "(bad)", { XX } },
3817 { "(bad)", { XX } },
3818 { "(bad)", { XX } },
3819 { VEX_LEN_TABLE (VEX_LEN_63_P_2) },
3820 { "(bad)", { XX } },
3825 { "(bad)", { XX } },
3826 { "(bad)", { XX } },
3827 { VEX_LEN_TABLE (VEX_LEN_64_P_2) },
3828 { "(bad)", { XX } },
3833 { "(bad)", { XX } },
3834 { "(bad)", { XX } },
3835 { VEX_LEN_TABLE (VEX_LEN_65_P_2) },
3836 { "(bad)", { XX } },
3841 { "(bad)", { XX } },
3842 { "(bad)", { XX } },
3843 { VEX_LEN_TABLE (VEX_LEN_66_P_2) },
3844 { "(bad)", { XX } },
3849 { "(bad)", { XX } },
3850 { "(bad)", { XX } },
3851 { VEX_LEN_TABLE (VEX_LEN_67_P_2) },
3852 { "(bad)", { XX } },
3857 { "(bad)", { XX } },
3858 { "(bad)", { XX } },
3859 { VEX_LEN_TABLE (VEX_LEN_68_P_2) },
3860 { "(bad)", { XX } },
3865 { "(bad)", { XX } },
3866 { "(bad)", { XX } },
3867 { VEX_LEN_TABLE (VEX_LEN_69_P_2) },
3868 { "(bad)", { XX } },
3873 { "(bad)", { XX } },
3874 { "(bad)", { XX } },
3875 { VEX_LEN_TABLE (VEX_LEN_6A_P_2) },
3876 { "(bad)", { XX } },
3881 { "(bad)", { XX } },
3882 { "(bad)", { XX } },
3883 { VEX_LEN_TABLE (VEX_LEN_6B_P_2) },
3884 { "(bad)", { XX } },
3889 { "(bad)", { XX } },
3890 { "(bad)", { XX } },
3891 { VEX_LEN_TABLE (VEX_LEN_6C_P_2) },
3892 { "(bad)", { XX } },
3897 { "(bad)", { XX } },
3898 { "(bad)", { XX } },
3899 { VEX_LEN_TABLE (VEX_LEN_6D_P_2) },
3900 { "(bad)", { XX } },
3905 { "(bad)", { XX } },
3906 { "(bad)", { XX } },
3907 { VEX_LEN_TABLE (VEX_LEN_6E_P_2) },
3908 { "(bad)", { XX } },
3913 { "(bad)", { XX } },
3914 { VEX_W_TABLE (VEX_W_6F_P_1) },
3915 { VEX_W_TABLE (VEX_W_6F_P_2) },
3916 { "(bad)", { XX } },
3921 { "(bad)", { XX } },
3922 { VEX_LEN_TABLE (VEX_LEN_70_P_1) },
3923 { VEX_LEN_TABLE (VEX_LEN_70_P_2) },
3924 { VEX_LEN_TABLE (VEX_LEN_70_P_3) },
3927 /* PREFIX_VEX_71_REG_2 */
3929 { "(bad)", { XX } },
3930 { "(bad)", { XX } },
3931 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2) },
3932 { "(bad)", { XX } },
3935 /* PREFIX_VEX_71_REG_4 */
3937 { "(bad)", { XX } },
3938 { "(bad)", { XX } },
3939 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2) },
3940 { "(bad)", { XX } },
3943 /* PREFIX_VEX_71_REG_6 */
3945 { "(bad)", { XX } },
3946 { "(bad)", { XX } },
3947 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2) },
3948 { "(bad)", { XX } },
3951 /* PREFIX_VEX_72_REG_2 */
3953 { "(bad)", { XX } },
3954 { "(bad)", { XX } },
3955 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2) },
3956 { "(bad)", { XX } },
3959 /* PREFIX_VEX_72_REG_4 */
3961 { "(bad)", { XX } },
3962 { "(bad)", { XX } },
3963 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2) },
3964 { "(bad)", { XX } },
3967 /* PREFIX_VEX_72_REG_6 */
3969 { "(bad)", { XX } },
3970 { "(bad)", { XX } },
3971 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2) },
3972 { "(bad)", { XX } },
3975 /* PREFIX_VEX_73_REG_2 */
3977 { "(bad)", { XX } },
3978 { "(bad)", { XX } },
3979 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2) },
3980 { "(bad)", { XX } },
3983 /* PREFIX_VEX_73_REG_3 */
3985 { "(bad)", { XX } },
3986 { "(bad)", { XX } },
3987 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2) },
3988 { "(bad)", { XX } },
3991 /* PREFIX_VEX_73_REG_6 */
3993 { "(bad)", { XX } },
3994 { "(bad)", { XX } },
3995 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2) },
3996 { "(bad)", { XX } },
3999 /* PREFIX_VEX_73_REG_7 */
4001 { "(bad)", { XX } },
4002 { "(bad)", { XX } },
4003 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2) },
4004 { "(bad)", { XX } },
4009 { "(bad)", { XX } },
4010 { "(bad)", { XX } },
4011 { VEX_LEN_TABLE (VEX_LEN_74_P_2) },
4012 { "(bad)", { XX } },
4017 { "(bad)", { XX } },
4018 { "(bad)", { XX } },
4019 { VEX_LEN_TABLE (VEX_LEN_75_P_2) },
4020 { "(bad)", { XX } },
4025 { "(bad)", { XX } },
4026 { "(bad)", { XX } },
4027 { VEX_LEN_TABLE (VEX_LEN_76_P_2) },
4028 { "(bad)", { XX } },
4033 { VEX_W_TABLE (VEX_W_77_P_0) },
4034 { "(bad)", { XX } },
4035 { "(bad)", { XX } },
4036 { "(bad)", { XX } },
4041 { "(bad)", { XX } },
4042 { "(bad)", { XX } },
4043 { VEX_W_TABLE (VEX_W_7C_P_2) },
4044 { VEX_W_TABLE (VEX_W_7C_P_3) },
4049 { "(bad)", { XX } },
4050 { "(bad)", { XX } },
4051 { VEX_W_TABLE (VEX_W_7D_P_2) },
4052 { VEX_W_TABLE (VEX_W_7D_P_3) },
4057 { "(bad)", { XX } },
4058 { VEX_LEN_TABLE (VEX_LEN_7E_P_1) },
4059 { VEX_LEN_TABLE (VEX_LEN_7E_P_2) },
4060 { "(bad)", { XX } },
4065 { "(bad)", { XX } },
4066 { VEX_W_TABLE (VEX_W_7F_P_1) },
4067 { VEX_W_TABLE (VEX_W_7F_P_2) },
4068 { "(bad)", { XX } },
4073 { VEX_W_TABLE (VEX_W_C2_P_0) },
4074 { VEX_LEN_TABLE (VEX_LEN_C2_P_1) },
4075 { VEX_W_TABLE (VEX_W_C2_P_2) },
4076 { VEX_LEN_TABLE (VEX_LEN_C2_P_3) },
4081 { "(bad)", { XX } },
4082 { "(bad)", { XX } },
4083 { VEX_LEN_TABLE (VEX_LEN_C4_P_2) },
4084 { "(bad)", { XX } },
4089 { "(bad)", { XX } },
4090 { "(bad)", { XX } },
4091 { VEX_LEN_TABLE (VEX_LEN_C5_P_2) },
4092 { "(bad)", { XX } },
4097 { "(bad)", { XX } },
4098 { "(bad)", { XX } },
4099 { VEX_W_TABLE (VEX_W_D0_P_2) },
4100 { VEX_W_TABLE (VEX_W_D0_P_3) },
4105 { "(bad)", { XX } },
4106 { "(bad)", { XX } },
4107 { VEX_LEN_TABLE (VEX_LEN_D1_P_2) },
4108 { "(bad)", { XX } },
4113 { "(bad)", { XX } },
4114 { "(bad)", { XX } },
4115 { VEX_LEN_TABLE (VEX_LEN_D2_P_2) },
4116 { "(bad)", { XX } },
4121 { "(bad)", { XX } },
4122 { "(bad)", { XX } },
4123 { VEX_LEN_TABLE (VEX_LEN_D3_P_2) },
4124 { "(bad)", { XX } },
4129 { "(bad)", { XX } },
4130 { "(bad)", { XX } },
4131 { VEX_LEN_TABLE (VEX_LEN_D4_P_2) },
4132 { "(bad)", { XX } },
4137 { "(bad)", { XX } },
4138 { "(bad)", { XX } },
4139 { VEX_LEN_TABLE (VEX_LEN_D5_P_2) },
4140 { "(bad)", { XX } },
4145 { "(bad)", { XX } },
4146 { "(bad)", { XX } },
4147 { VEX_LEN_TABLE (VEX_LEN_D6_P_2) },
4148 { "(bad)", { XX } },
4153 { "(bad)", { XX } },
4154 { "(bad)", { XX } },
4155 { MOD_TABLE (MOD_VEX_D7_PREFIX_2) },
4156 { "(bad)", { XX } },
4161 { "(bad)", { XX } },
4162 { "(bad)", { XX } },
4163 { VEX_LEN_TABLE (VEX_LEN_D8_P_2) },
4164 { "(bad)", { XX } },
4169 { "(bad)", { XX } },
4170 { "(bad)", { XX } },
4171 { VEX_LEN_TABLE (VEX_LEN_D9_P_2) },
4172 { "(bad)", { XX } },
4177 { "(bad)", { XX } },
4178 { "(bad)", { XX } },
4179 { VEX_LEN_TABLE (VEX_LEN_DA_P_2) },
4180 { "(bad)", { XX } },
4185 { "(bad)", { XX } },
4186 { "(bad)", { XX } },
4187 { VEX_LEN_TABLE (VEX_LEN_DB_P_2) },
4188 { "(bad)", { XX } },
4193 { "(bad)", { XX } },
4194 { "(bad)", { XX } },
4195 { VEX_LEN_TABLE (VEX_LEN_DC_P_2) },
4196 { "(bad)", { XX } },
4201 { "(bad)", { XX } },
4202 { "(bad)", { XX } },
4203 { VEX_LEN_TABLE (VEX_LEN_DD_P_2) },
4204 { "(bad)", { XX } },
4209 { "(bad)", { XX } },
4210 { "(bad)", { XX } },
4211 { VEX_LEN_TABLE (VEX_LEN_DE_P_2) },
4212 { "(bad)", { XX } },
4217 { "(bad)", { XX } },
4218 { "(bad)", { XX } },
4219 { VEX_LEN_TABLE (VEX_LEN_DF_P_2) },
4220 { "(bad)", { XX } },
4225 { "(bad)", { XX } },
4226 { "(bad)", { XX } },
4227 { VEX_LEN_TABLE (VEX_LEN_E0_P_2) },
4228 { "(bad)", { XX } },
4233 { "(bad)", { XX } },
4234 { "(bad)", { XX } },
4235 { VEX_LEN_TABLE (VEX_LEN_E1_P_2) },
4236 { "(bad)", { XX } },
4241 { "(bad)", { XX } },
4242 { "(bad)", { XX } },
4243 { VEX_LEN_TABLE (VEX_LEN_E2_P_2) },
4244 { "(bad)", { XX } },
4249 { "(bad)", { XX } },
4250 { "(bad)", { XX } },
4251 { VEX_LEN_TABLE (VEX_LEN_E3_P_2) },
4252 { "(bad)", { XX } },
4257 { "(bad)", { XX } },
4258 { "(bad)", { XX } },
4259 { VEX_LEN_TABLE (VEX_LEN_E4_P_2) },
4260 { "(bad)", { XX } },
4265 { "(bad)", { XX } },
4266 { "(bad)", { XX } },
4267 { VEX_LEN_TABLE (VEX_LEN_E5_P_2) },
4268 { "(bad)", { XX } },
4273 { "(bad)", { XX } },
4274 { VEX_W_TABLE (VEX_W_E6_P_1) },
4275 { VEX_W_TABLE (VEX_W_E6_P_2) },
4276 { VEX_W_TABLE (VEX_W_E6_P_3) },
4281 { "(bad)", { XX } },
4282 { "(bad)", { XX } },
4283 { MOD_TABLE (MOD_VEX_E7_PREFIX_2) },
4284 { "(bad)", { XX } },
4289 { "(bad)", { XX } },
4290 { "(bad)", { XX } },
4291 { VEX_LEN_TABLE (VEX_LEN_E8_P_2) },
4292 { "(bad)", { XX } },
4297 { "(bad)", { XX } },
4298 { "(bad)", { XX } },
4299 { VEX_LEN_TABLE (VEX_LEN_E9_P_2) },
4300 { "(bad)", { XX } },
4305 { "(bad)", { XX } },
4306 { "(bad)", { XX } },
4307 { VEX_LEN_TABLE (VEX_LEN_EA_P_2) },
4308 { "(bad)", { XX } },
4313 { "(bad)", { XX } },
4314 { "(bad)", { XX } },
4315 { VEX_LEN_TABLE (VEX_LEN_EB_P_2) },
4316 { "(bad)", { XX } },
4321 { "(bad)", { XX } },
4322 { "(bad)", { XX } },
4323 { VEX_LEN_TABLE (VEX_LEN_EC_P_2) },
4324 { "(bad)", { XX } },
4329 { "(bad)", { XX } },
4330 { "(bad)", { XX } },
4331 { VEX_LEN_TABLE (VEX_LEN_ED_P_2) },
4332 { "(bad)", { XX } },
4337 { "(bad)", { XX } },
4338 { "(bad)", { XX } },
4339 { VEX_LEN_TABLE (VEX_LEN_EE_P_2) },
4340 { "(bad)", { XX } },
4345 { "(bad)", { XX } },
4346 { "(bad)", { XX } },
4347 { VEX_LEN_TABLE (VEX_LEN_EF_P_2) },
4348 { "(bad)", { XX } },
4353 { "(bad)", { XX } },
4354 { "(bad)", { XX } },
4355 { "(bad)", { XX } },
4356 { MOD_TABLE (MOD_VEX_F0_PREFIX_3) },
4361 { "(bad)", { XX } },
4362 { "(bad)", { XX } },
4363 { VEX_LEN_TABLE (VEX_LEN_F1_P_2) },
4364 { "(bad)", { XX } },
4369 { "(bad)", { XX } },
4370 { "(bad)", { XX } },
4371 { VEX_LEN_TABLE (VEX_LEN_F2_P_2) },
4372 { "(bad)", { XX } },
4377 { "(bad)", { XX } },
4378 { "(bad)", { XX } },
4379 { VEX_LEN_TABLE (VEX_LEN_F3_P_2) },
4380 { "(bad)", { XX } },
4385 { "(bad)", { XX } },
4386 { "(bad)", { XX } },
4387 { VEX_LEN_TABLE (VEX_LEN_F4_P_2) },
4388 { "(bad)", { XX } },
4393 { "(bad)", { XX } },
4394 { "(bad)", { XX } },
4395 { VEX_LEN_TABLE (VEX_LEN_F5_P_2) },
4396 { "(bad)", { XX } },
4401 { "(bad)", { XX } },
4402 { "(bad)", { XX } },
4403 { VEX_LEN_TABLE (VEX_LEN_F6_P_2) },
4404 { "(bad)", { XX } },
4409 { "(bad)", { XX } },
4410 { "(bad)", { XX } },
4411 { VEX_LEN_TABLE (VEX_LEN_F7_P_2) },
4412 { "(bad)", { XX } },
4417 { "(bad)", { XX } },
4418 { "(bad)", { XX } },
4419 { VEX_LEN_TABLE (VEX_LEN_F8_P_2) },
4420 { "(bad)", { XX } },
4425 { "(bad)", { XX } },
4426 { "(bad)", { XX } },
4427 { VEX_LEN_TABLE (VEX_LEN_F9_P_2) },
4428 { "(bad)", { XX } },
4433 { "(bad)", { XX } },
4434 { "(bad)", { XX } },
4435 { VEX_LEN_TABLE (VEX_LEN_FA_P_2) },
4436 { "(bad)", { XX } },
4441 { "(bad)", { XX } },
4442 { "(bad)", { XX } },
4443 { VEX_LEN_TABLE (VEX_LEN_FB_P_2) },
4444 { "(bad)", { XX } },
4449 { "(bad)", { XX } },
4450 { "(bad)", { XX } },
4451 { VEX_LEN_TABLE (VEX_LEN_FC_P_2) },
4452 { "(bad)", { XX } },
4457 { "(bad)", { XX } },
4458 { "(bad)", { XX } },
4459 { VEX_LEN_TABLE (VEX_LEN_FD_P_2) },
4460 { "(bad)", { XX } },
4465 { "(bad)", { XX } },
4466 { "(bad)", { XX } },
4467 { VEX_LEN_TABLE (VEX_LEN_FE_P_2) },
4468 { "(bad)", { XX } },
4471 /* PREFIX_VEX_3800 */
4473 { "(bad)", { XX } },
4474 { "(bad)", { XX } },
4475 { VEX_LEN_TABLE (VEX_LEN_3800_P_2) },
4476 { "(bad)", { XX } },
4479 /* PREFIX_VEX_3801 */
4481 { "(bad)", { XX } },
4482 { "(bad)", { XX } },
4483 { VEX_LEN_TABLE (VEX_LEN_3801_P_2) },
4484 { "(bad)", { XX } },
4487 /* PREFIX_VEX_3802 */
4489 { "(bad)", { XX } },
4490 { "(bad)", { XX } },
4491 { VEX_LEN_TABLE (VEX_LEN_3802_P_2) },
4492 { "(bad)", { XX } },
4495 /* PREFIX_VEX_3803 */
4497 { "(bad)", { XX } },
4498 { "(bad)", { XX } },
4499 { VEX_LEN_TABLE (VEX_LEN_3803_P_2) },
4500 { "(bad)", { XX } },
4503 /* PREFIX_VEX_3804 */
4505 { "(bad)", { XX } },
4506 { "(bad)", { XX } },
4507 { VEX_LEN_TABLE (VEX_LEN_3804_P_2) },
4508 { "(bad)", { XX } },
4511 /* PREFIX_VEX_3805 */
4513 { "(bad)", { XX } },
4514 { "(bad)", { XX } },
4515 { VEX_LEN_TABLE (VEX_LEN_3805_P_2) },
4516 { "(bad)", { XX } },
4519 /* PREFIX_VEX_3806 */
4521 { "(bad)", { XX } },
4522 { "(bad)", { XX } },
4523 { VEX_LEN_TABLE (VEX_LEN_3806_P_2) },
4524 { "(bad)", { XX } },
4527 /* PREFIX_VEX_3807 */
4529 { "(bad)", { XX } },
4530 { "(bad)", { XX } },
4531 { VEX_LEN_TABLE (VEX_LEN_3807_P_2) },
4532 { "(bad)", { XX } },
4535 /* PREFIX_VEX_3808 */
4537 { "(bad)", { XX } },
4538 { "(bad)", { XX } },
4539 { VEX_LEN_TABLE (VEX_LEN_3808_P_2) },
4540 { "(bad)", { XX } },
4543 /* PREFIX_VEX_3809 */
4545 { "(bad)", { XX } },
4546 { "(bad)", { XX } },
4547 { VEX_LEN_TABLE (VEX_LEN_3809_P_2) },
4548 { "(bad)", { XX } },
4551 /* PREFIX_VEX_380A */
4553 { "(bad)", { XX } },
4554 { "(bad)", { XX } },
4555 { VEX_LEN_TABLE (VEX_LEN_380A_P_2) },
4556 { "(bad)", { XX } },
4559 /* PREFIX_VEX_380B */
4561 { "(bad)", { XX } },
4562 { "(bad)", { XX } },
4563 { VEX_LEN_TABLE (VEX_LEN_380B_P_2) },
4564 { "(bad)", { XX } },
4567 /* PREFIX_VEX_380C */
4569 { "(bad)", { XX } },
4570 { "(bad)", { XX } },
4571 { VEX_W_TABLE (VEX_W_380C_P_2) },
4572 { "(bad)", { XX } },
4575 /* PREFIX_VEX_380D */
4577 { "(bad)", { XX } },
4578 { "(bad)", { XX } },
4579 { VEX_W_TABLE (VEX_W_380D_P_2) },
4580 { "(bad)", { XX } },
4583 /* PREFIX_VEX_380E */
4585 { "(bad)", { XX } },
4586 { "(bad)", { XX } },
4587 { VEX_W_TABLE (VEX_W_380E_P_2) },
4588 { "(bad)", { XX } },
4591 /* PREFIX_VEX_380F */
4593 { "(bad)", { XX } },
4594 { "(bad)", { XX } },
4595 { VEX_W_TABLE (VEX_W_380F_P_2) },
4596 { "(bad)", { XX } },
4599 /* PREFIX_VEX_3817 */
4601 { "(bad)", { XX } },
4602 { "(bad)", { XX } },
4603 { VEX_W_TABLE (VEX_W_3817_P_2) },
4604 { "(bad)", { XX } },
4607 /* PREFIX_VEX_3818 */
4609 { "(bad)", { XX } },
4610 { "(bad)", { XX } },
4611 { MOD_TABLE (MOD_VEX_3818_PREFIX_2) },
4612 { "(bad)", { XX } },
4615 /* PREFIX_VEX_3819 */
4617 { "(bad)", { XX } },
4618 { "(bad)", { XX } },
4619 { MOD_TABLE (MOD_VEX_3819_PREFIX_2) },
4620 { "(bad)", { XX } },
4623 /* PREFIX_VEX_381A */
4625 { "(bad)", { XX } },
4626 { "(bad)", { XX } },
4627 { MOD_TABLE (MOD_VEX_381A_PREFIX_2) },
4628 { "(bad)", { XX } },
4631 /* PREFIX_VEX_381C */
4633 { "(bad)", { XX } },
4634 { "(bad)", { XX } },
4635 { VEX_LEN_TABLE (VEX_LEN_381C_P_2) },
4636 { "(bad)", { XX } },
4639 /* PREFIX_VEX_381D */
4641 { "(bad)", { XX } },
4642 { "(bad)", { XX } },
4643 { VEX_LEN_TABLE (VEX_LEN_381D_P_2) },
4644 { "(bad)", { XX } },
4647 /* PREFIX_VEX_381E */
4649 { "(bad)", { XX } },
4650 { "(bad)", { XX } },
4651 { VEX_LEN_TABLE (VEX_LEN_381E_P_2) },
4652 { "(bad)", { XX } },
4655 /* PREFIX_VEX_3820 */
4657 { "(bad)", { XX } },
4658 { "(bad)", { XX } },
4659 { VEX_LEN_TABLE (VEX_LEN_3820_P_2) },
4660 { "(bad)", { XX } },
4663 /* PREFIX_VEX_3821 */
4665 { "(bad)", { XX } },
4666 { "(bad)", { XX } },
4667 { VEX_LEN_TABLE (VEX_LEN_3821_P_2) },
4668 { "(bad)", { XX } },
4671 /* PREFIX_VEX_3822 */
4673 { "(bad)", { XX } },
4674 { "(bad)", { XX } },
4675 { VEX_LEN_TABLE (VEX_LEN_3822_P_2) },
4676 { "(bad)", { XX } },
4679 /* PREFIX_VEX_3823 */
4681 { "(bad)", { XX } },
4682 { "(bad)", { XX } },
4683 { VEX_LEN_TABLE (VEX_LEN_3823_P_2) },
4684 { "(bad)", { XX } },
4687 /* PREFIX_VEX_3824 */
4689 { "(bad)", { XX } },
4690 { "(bad)", { XX } },
4691 { VEX_LEN_TABLE (VEX_LEN_3824_P_2) },
4692 { "(bad)", { XX } },
4695 /* PREFIX_VEX_3825 */
4697 { "(bad)", { XX } },
4698 { "(bad)", { XX } },
4699 { VEX_LEN_TABLE (VEX_LEN_3825_P_2) },
4700 { "(bad)", { XX } },
4703 /* PREFIX_VEX_3828 */
4705 { "(bad)", { XX } },
4706 { "(bad)", { XX } },
4707 { VEX_LEN_TABLE (VEX_LEN_3828_P_2) },
4708 { "(bad)", { XX } },
4711 /* PREFIX_VEX_3829 */
4713 { "(bad)", { XX } },
4714 { "(bad)", { XX } },
4715 { VEX_LEN_TABLE (VEX_LEN_3829_P_2) },
4716 { "(bad)", { XX } },
4719 /* PREFIX_VEX_382A */
4721 { "(bad)", { XX } },
4722 { "(bad)", { XX } },
4723 { MOD_TABLE (MOD_VEX_382A_PREFIX_2) },
4724 { "(bad)", { XX } },
4727 /* PREFIX_VEX_382B */
4729 { "(bad)", { XX } },
4730 { "(bad)", { XX } },
4731 { VEX_LEN_TABLE (VEX_LEN_382B_P_2) },
4732 { "(bad)", { XX } },
4735 /* PREFIX_VEX_382C */
4737 { "(bad)", { XX } },
4738 { "(bad)", { XX } },
4739 { MOD_TABLE (MOD_VEX_382C_PREFIX_2) },
4740 { "(bad)", { XX } },
4743 /* PREFIX_VEX_382D */
4745 { "(bad)", { XX } },
4746 { "(bad)", { XX } },
4747 { MOD_TABLE (MOD_VEX_382D_PREFIX_2) },
4748 { "(bad)", { XX } },
4751 /* PREFIX_VEX_382E */
4753 { "(bad)", { XX } },
4754 { "(bad)", { XX } },
4755 { MOD_TABLE (MOD_VEX_382E_PREFIX_2) },
4756 { "(bad)", { XX } },
4759 /* PREFIX_VEX_382F */
4761 { "(bad)", { XX } },
4762 { "(bad)", { XX } },
4763 { MOD_TABLE (MOD_VEX_382F_PREFIX_2) },
4764 { "(bad)", { XX } },
4767 /* PREFIX_VEX_3830 */
4769 { "(bad)", { XX } },
4770 { "(bad)", { XX } },
4771 { VEX_LEN_TABLE (VEX_LEN_3830_P_2) },
4772 { "(bad)", { XX } },
4775 /* PREFIX_VEX_3831 */
4777 { "(bad)", { XX } },
4778 { "(bad)", { XX } },
4779 { VEX_LEN_TABLE (VEX_LEN_3831_P_2) },
4780 { "(bad)", { XX } },
4783 /* PREFIX_VEX_3832 */
4785 { "(bad)", { XX } },
4786 { "(bad)", { XX } },
4787 { VEX_LEN_TABLE (VEX_LEN_3832_P_2) },
4788 { "(bad)", { XX } },
4791 /* PREFIX_VEX_3833 */
4793 { "(bad)", { XX } },
4794 { "(bad)", { XX } },
4795 { VEX_LEN_TABLE (VEX_LEN_3833_P_2) },
4796 { "(bad)", { XX } },
4799 /* PREFIX_VEX_3834 */
4801 { "(bad)", { XX } },
4802 { "(bad)", { XX } },
4803 { VEX_LEN_TABLE (VEX_LEN_3834_P_2) },
4804 { "(bad)", { XX } },
4807 /* PREFIX_VEX_3835 */
4809 { "(bad)", { XX } },
4810 { "(bad)", { XX } },
4811 { VEX_LEN_TABLE (VEX_LEN_3835_P_2) },
4812 { "(bad)", { XX } },
4815 /* PREFIX_VEX_3837 */
4817 { "(bad)", { XX } },
4818 { "(bad)", { XX } },
4819 { VEX_LEN_TABLE (VEX_LEN_3837_P_2) },
4820 { "(bad)", { XX } },
4823 /* PREFIX_VEX_3838 */
4825 { "(bad)", { XX } },
4826 { "(bad)", { XX } },
4827 { VEX_LEN_TABLE (VEX_LEN_3838_P_2) },
4828 { "(bad)", { XX } },
4831 /* PREFIX_VEX_3839 */
4833 { "(bad)", { XX } },
4834 { "(bad)", { XX } },
4835 { VEX_LEN_TABLE (VEX_LEN_3839_P_2) },
4836 { "(bad)", { XX } },
4839 /* PREFIX_VEX_383A */
4841 { "(bad)", { XX } },
4842 { "(bad)", { XX } },
4843 { VEX_LEN_TABLE (VEX_LEN_383A_P_2) },
4844 { "(bad)", { XX } },
4847 /* PREFIX_VEX_383B */
4849 { "(bad)", { XX } },
4850 { "(bad)", { XX } },
4851 { VEX_LEN_TABLE (VEX_LEN_383B_P_2) },
4852 { "(bad)", { XX } },
4855 /* PREFIX_VEX_383C */
4857 { "(bad)", { XX } },
4858 { "(bad)", { XX } },
4859 { VEX_LEN_TABLE (VEX_LEN_383C_P_2) },
4860 { "(bad)", { XX } },
4863 /* PREFIX_VEX_383D */
4865 { "(bad)", { XX } },
4866 { "(bad)", { XX } },
4867 { VEX_LEN_TABLE (VEX_LEN_383D_P_2) },
4868 { "(bad)", { XX } },
4871 /* PREFIX_VEX_383E */
4873 { "(bad)", { XX } },
4874 { "(bad)", { XX } },
4875 { VEX_LEN_TABLE (VEX_LEN_383E_P_2) },
4876 { "(bad)", { XX } },
4879 /* PREFIX_VEX_383F */
4881 { "(bad)", { XX } },
4882 { "(bad)", { XX } },
4883 { VEX_LEN_TABLE (VEX_LEN_383F_P_2) },
4884 { "(bad)", { XX } },
4887 /* PREFIX_VEX_3840 */
4889 { "(bad)", { XX } },
4890 { "(bad)", { XX } },
4891 { VEX_LEN_TABLE (VEX_LEN_3840_P_2) },
4892 { "(bad)", { XX } },
4895 /* PREFIX_VEX_3841 */
4897 { "(bad)", { XX } },
4898 { "(bad)", { XX } },
4899 { VEX_LEN_TABLE (VEX_LEN_3841_P_2) },
4900 { "(bad)", { XX } },
4903 /* PREFIX_VEX_3896 */
4905 { "(bad)", { XX } },
4906 { "(bad)", { XX } },
4907 { "vfmaddsub132p%XW", { XM, Vex, EXx } },
4908 { "(bad)", { XX } },
4911 /* PREFIX_VEX_3897 */
4913 { "(bad)", { XX } },
4914 { "(bad)", { XX } },
4915 { "vfmsubadd132p%XW", { XM, Vex, EXx } },
4916 { "(bad)", { XX } },
4919 /* PREFIX_VEX_3898 */
4921 { "(bad)", { XX } },
4922 { "(bad)", { XX } },
4923 { "vfmadd132p%XW", { XM, Vex, EXx } },
4924 { "(bad)", { XX } },
4927 /* PREFIX_VEX_3899 */
4929 { "(bad)", { XX } },
4930 { "(bad)", { XX } },
4931 { "vfmadd132s%XW", { XM, Vex, EXVexWdq } },
4932 { "(bad)", { XX } },
4935 /* PREFIX_VEX_389A */
4937 { "(bad)", { XX } },
4938 { "(bad)", { XX } },
4939 { "vfmsub132p%XW", { XM, Vex, EXx } },
4940 { "(bad)", { XX } },
4943 /* PREFIX_VEX_389B */
4945 { "(bad)", { XX } },
4946 { "(bad)", { XX } },
4947 { "vfmsub132s%XW", { XM, Vex, EXVexWdq } },
4948 { "(bad)", { XX } },
4951 /* PREFIX_VEX_389C */
4953 { "(bad)", { XX } },
4954 { "(bad)", { XX } },
4955 { "vfnmadd132p%XW", { XM, Vex, EXx } },
4956 { "(bad)", { XX } },
4959 /* PREFIX_VEX_389D */
4961 { "(bad)", { XX } },
4962 { "(bad)", { XX } },
4963 { "vfnmadd132s%XW", { XM, Vex, EXVexWdq } },
4964 { "(bad)", { XX } },
4967 /* PREFIX_VEX_389E */
4969 { "(bad)", { XX } },
4970 { "(bad)", { XX } },
4971 { "vfnmsub132p%XW", { XM, Vex, EXx } },
4972 { "(bad)", { XX } },
4975 /* PREFIX_VEX_389F */
4977 { "(bad)", { XX } },
4978 { "(bad)", { XX } },
4979 { "vfnmsub132s%XW", { XM, Vex, EXVexWdq } },
4980 { "(bad)", { XX } },
4983 /* PREFIX_VEX_38A6 */
4985 { "(bad)", { XX } },
4986 { "(bad)", { XX } },
4987 { "vfmaddsub213p%XW", { XM, Vex, EXx } },
4988 { "(bad)", { XX } },
4991 /* PREFIX_VEX_38A7 */
4993 { "(bad)", { XX } },
4994 { "(bad)", { XX } },
4995 { "vfmsubadd213p%XW", { XM, Vex, EXx } },
4996 { "(bad)", { XX } },
4999 /* PREFIX_VEX_38A8 */
5001 { "(bad)", { XX } },
5002 { "(bad)", { XX } },
5003 { "vfmadd213p%XW", { XM, Vex, EXx } },
5004 { "(bad)", { XX } },
5007 /* PREFIX_VEX_38A9 */
5009 { "(bad)", { XX } },
5010 { "(bad)", { XX } },
5011 { "vfmadd213s%XW", { XM, Vex, EXVexWdq } },
5012 { "(bad)", { XX } },
5015 /* PREFIX_VEX_38AA */
5017 { "(bad)", { XX } },
5018 { "(bad)", { XX } },
5019 { "vfmsub213p%XW", { XM, Vex, EXx } },
5020 { "(bad)", { XX } },
5023 /* PREFIX_VEX_38AB */
5025 { "(bad)", { XX } },
5026 { "(bad)", { XX } },
5027 { "vfmsub213s%XW", { XM, Vex, EXVexWdq } },
5028 { "(bad)", { XX } },
5031 /* PREFIX_VEX_38AC */
5033 { "(bad)", { XX } },
5034 { "(bad)", { XX } },
5035 { "vfnmadd213p%XW", { XM, Vex, EXx } },
5036 { "(bad)", { XX } },
5039 /* PREFIX_VEX_38AD */
5041 { "(bad)", { XX } },
5042 { "(bad)", { XX } },
5043 { "vfnmadd213s%XW", { XM, Vex, EXVexWdq } },
5044 { "(bad)", { XX } },
5047 /* PREFIX_VEX_38AE */
5049 { "(bad)", { XX } },
5050 { "(bad)", { XX } },
5051 { "vfnmsub213p%XW", { XM, Vex, EXx } },
5052 { "(bad)", { XX } },
5055 /* PREFIX_VEX_38AF */
5057 { "(bad)", { XX } },
5058 { "(bad)", { XX } },
5059 { "vfnmsub213s%XW", { XM, Vex, EXVexWdq } },
5060 { "(bad)", { XX } },
5063 /* PREFIX_VEX_38B6 */
5065 { "(bad)", { XX } },
5066 { "(bad)", { XX } },
5067 { "vfmaddsub231p%XW", { XM, Vex, EXx } },
5068 { "(bad)", { XX } },
5071 /* PREFIX_VEX_38B7 */
5073 { "(bad)", { XX } },
5074 { "(bad)", { XX } },
5075 { "vfmsubadd231p%XW", { XM, Vex, EXx } },
5076 { "(bad)", { XX } },
5079 /* PREFIX_VEX_38B8 */
5081 { "(bad)", { XX } },
5082 { "(bad)", { XX } },
5083 { "vfmadd231p%XW", { XM, Vex, EXx } },
5084 { "(bad)", { XX } },
5087 /* PREFIX_VEX_38B9 */
5089 { "(bad)", { XX } },
5090 { "(bad)", { XX } },
5091 { "vfmadd231s%XW", { XM, Vex, EXVexWdq } },
5092 { "(bad)", { XX } },
5095 /* PREFIX_VEX_38BA */
5097 { "(bad)", { XX } },
5098 { "(bad)", { XX } },
5099 { "vfmsub231p%XW", { XM, Vex, EXx } },
5100 { "(bad)", { XX } },
5103 /* PREFIX_VEX_38BB */
5105 { "(bad)", { XX } },
5106 { "(bad)", { XX } },
5107 { "vfmsub231s%XW", { XM, Vex, EXVexWdq } },
5108 { "(bad)", { XX } },
5111 /* PREFIX_VEX_38BC */
5113 { "(bad)", { XX } },
5114 { "(bad)", { XX } },
5115 { "vfnmadd231p%XW", { XM, Vex, EXx } },
5116 { "(bad)", { XX } },
5119 /* PREFIX_VEX_38BD */
5121 { "(bad)", { XX } },
5122 { "(bad)", { XX } },
5123 { "vfnmadd231s%XW", { XM, Vex, EXVexWdq } },
5124 { "(bad)", { XX } },
5127 /* PREFIX_VEX_38BE */
5129 { "(bad)", { XX } },
5130 { "(bad)", { XX } },
5131 { "vfnmsub231p%XW", { XM, Vex, EXx } },
5132 { "(bad)", { XX } },
5135 /* PREFIX_VEX_38BF */
5137 { "(bad)", { XX } },
5138 { "(bad)", { XX } },
5139 { "vfnmsub231s%XW", { XM, Vex, EXVexWdq } },
5140 { "(bad)", { XX } },
5143 /* PREFIX_VEX_38DB */
5145 { "(bad)", { XX } },
5146 { "(bad)", { XX } },
5147 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2) },
5148 { "(bad)", { XX } },
5151 /* PREFIX_VEX_38DC */
5153 { "(bad)", { XX } },
5154 { "(bad)", { XX } },
5155 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2) },
5156 { "(bad)", { XX } },
5159 /* PREFIX_VEX_38DD */
5161 { "(bad)", { XX } },
5162 { "(bad)", { XX } },
5163 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2) },
5164 { "(bad)", { XX } },
5167 /* PREFIX_VEX_38DE */
5169 { "(bad)", { XX } },
5170 { "(bad)", { XX } },
5171 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2) },
5172 { "(bad)", { XX } },
5175 /* PREFIX_VEX_38DF */
5177 { "(bad)", { XX } },
5178 { "(bad)", { XX } },
5179 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2) },
5180 { "(bad)", { XX } },
5183 /* PREFIX_VEX_3A04 */
5185 { "(bad)", { XX } },
5186 { "(bad)", { XX } },
5187 { VEX_W_TABLE (VEX_W_3A04_P_2) },
5188 { "(bad)", { XX } },
5191 /* PREFIX_VEX_3A05 */
5193 { "(bad)", { XX } },
5194 { "(bad)", { XX } },
5195 { VEX_W_TABLE (VEX_W_3A05_P_2) },
5196 { "(bad)", { XX } },
5199 /* PREFIX_VEX_3A06 */
5201 { "(bad)", { XX } },
5202 { "(bad)", { XX } },
5203 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2) },
5204 { "(bad)", { XX } },
5207 /* PREFIX_VEX_3A08 */
5209 { "(bad)", { XX } },
5210 { "(bad)", { XX } },
5211 { VEX_W_TABLE (VEX_W_3A08_P_2) },
5212 { "(bad)", { XX } },
5215 /* PREFIX_VEX_3A09 */
5217 { "(bad)", { XX } },
5218 { "(bad)", { XX } },
5219 { VEX_W_TABLE (VEX_W_3A09_P_2) },
5220 { "(bad)", { XX } },
5223 /* PREFIX_VEX_3A0A */
5225 { "(bad)", { XX } },
5226 { "(bad)", { XX } },
5227 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2) },
5228 { "(bad)", { XX } },
5231 /* PREFIX_VEX_3A0B */
5233 { "(bad)", { XX } },
5234 { "(bad)", { XX } },
5235 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2) },
5236 { "(bad)", { XX } },
5239 /* PREFIX_VEX_3A0C */
5241 { "(bad)", { XX } },
5242 { "(bad)", { XX } },
5243 { VEX_W_TABLE (VEX_W_3A0C_P_2) },
5244 { "(bad)", { XX } },
5247 /* PREFIX_VEX_3A0D */
5249 { "(bad)", { XX } },
5250 { "(bad)", { XX } },
5251 { VEX_W_TABLE (VEX_W_3A0D_P_2) },
5252 { "(bad)", { XX } },
5255 /* PREFIX_VEX_3A0E */
5257 { "(bad)", { XX } },
5258 { "(bad)", { XX } },
5259 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2) },
5260 { "(bad)", { XX } },
5263 /* PREFIX_VEX_3A0F */
5265 { "(bad)", { XX } },
5266 { "(bad)", { XX } },
5267 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2) },
5268 { "(bad)", { XX } },
5271 /* PREFIX_VEX_3A14 */
5273 { "(bad)", { XX } },
5274 { "(bad)", { XX } },
5275 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2) },
5276 { "(bad)", { XX } },
5279 /* PREFIX_VEX_3A15 */
5281 { "(bad)", { XX } },
5282 { "(bad)", { XX } },
5283 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2) },
5284 { "(bad)", { XX } },
5287 /* PREFIX_VEX_3A16 */
5289 { "(bad)", { XX } },
5290 { "(bad)", { XX } },
5291 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2) },
5292 { "(bad)", { XX } },
5295 /* PREFIX_VEX_3A17 */
5297 { "(bad)", { XX } },
5298 { "(bad)", { XX } },
5299 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2) },
5300 { "(bad)", { XX } },
5303 /* PREFIX_VEX_3A18 */
5305 { "(bad)", { XX } },
5306 { "(bad)", { XX } },
5307 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2) },
5308 { "(bad)", { XX } },
5311 /* PREFIX_VEX_3A19 */
5313 { "(bad)", { XX } },
5314 { "(bad)", { XX } },
5315 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2) },
5316 { "(bad)", { XX } },
5319 /* PREFIX_VEX_3A20 */
5321 { "(bad)", { XX } },
5322 { "(bad)", { XX } },
5323 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2) },
5324 { "(bad)", { XX } },
5327 /* PREFIX_VEX_3A21 */
5329 { "(bad)", { XX } },
5330 { "(bad)", { XX } },
5331 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2) },
5332 { "(bad)", { XX } },
5335 /* PREFIX_VEX_3A22 */
5337 { "(bad)", { XX } },
5338 { "(bad)", { XX } },
5339 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2) },
5340 { "(bad)", { XX } },
5343 /* PREFIX_VEX_3A40 */
5345 { "(bad)", { XX } },
5346 { "(bad)", { XX } },
5347 { VEX_W_TABLE (VEX_W_3A40_P_2) },
5348 { "(bad)", { XX } },
5351 /* PREFIX_VEX_3A41 */
5353 { "(bad)", { XX } },
5354 { "(bad)", { XX } },
5355 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2) },
5356 { "(bad)", { XX } },
5359 /* PREFIX_VEX_3A42 */
5361 { "(bad)", { XX } },
5362 { "(bad)", { XX } },
5363 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2) },
5364 { "(bad)", { XX } },
5367 /* PREFIX_VEX_3A44 */
5369 { "(bad)", { XX } },
5370 { "(bad)", { XX } },
5371 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2) },
5372 { "(bad)", { XX } },
5375 /* PREFIX_VEX_3A4A */
5377 { "(bad)", { XX } },
5378 { "(bad)", { XX } },
5379 { VEX_W_TABLE (VEX_W_3A4A_P_2) },
5380 { "(bad)", { XX } },
5383 /* PREFIX_VEX_3A4B */
5385 { "(bad)", { XX } },
5386 { "(bad)", { XX } },
5387 { VEX_W_TABLE (VEX_W_3A4B_P_2) },
5388 { "(bad)", { XX } },
5391 /* PREFIX_VEX_3A4C */
5393 { "(bad)", { XX } },
5394 { "(bad)", { XX } },
5395 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2) },
5396 { "(bad)", { XX } },
5399 /* PREFIX_VEX_3A5C */
5401 { "(bad)", { XX } },
5402 { "(bad)", { XX } },
5403 { "vfmaddsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5404 { "(bad)", { XX } },
5407 /* PREFIX_VEX_3A5D */
5409 { "(bad)", { XX } },
5410 { "(bad)", { XX } },
5411 { "vfmaddsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5412 { "(bad)", { XX } },
5415 /* PREFIX_VEX_3A5E */
5417 { "(bad)", { XX } },
5418 { "(bad)", { XX } },
5419 { "vfmsubaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5420 { "(bad)", { XX } },
5423 /* PREFIX_VEX_3A5F */
5425 { "(bad)", { XX } },
5426 { "(bad)", { XX } },
5427 { "vfmsubaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5428 { "(bad)", { XX } },
5431 /* PREFIX_VEX_3A60 */
5433 { "(bad)", { XX } },
5434 { "(bad)", { XX } },
5435 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2) },
5436 { "(bad)", { XX } },
5439 /* PREFIX_VEX_3A61 */
5441 { "(bad)", { XX } },
5442 { "(bad)", { XX } },
5443 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2) },
5444 { "(bad)", { XX } },
5447 /* PREFIX_VEX_3A62 */
5449 { "(bad)", { XX } },
5450 { "(bad)", { XX } },
5451 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2) },
5452 { "(bad)", { XX } },
5455 /* PREFIX_VEX_3A63 */
5457 { "(bad)", { XX } },
5458 { "(bad)", { XX } },
5459 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2) },
5460 { "(bad)", { XX } },
5463 /* PREFIX_VEX_3A68 */
5465 { "(bad)", { XX } },
5466 { "(bad)", { XX } },
5467 { "vfmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5468 { "(bad)", { XX } },
5471 /* PREFIX_VEX_3A69 */
5473 { "(bad)", { XX } },
5474 { "(bad)", { XX } },
5475 { "vfmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5476 { "(bad)", { XX } },
5479 /* PREFIX_VEX_3A6A */
5481 { "(bad)", { XX } },
5482 { "(bad)", { XX } },
5483 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2) },
5484 { "(bad)", { XX } },
5487 /* PREFIX_VEX_3A6B */
5489 { "(bad)", { XX } },
5490 { "(bad)", { XX } },
5491 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2) },
5492 { "(bad)", { XX } },
5495 /* PREFIX_VEX_3A6C */
5497 { "(bad)", { XX } },
5498 { "(bad)", { XX } },
5499 { "vfmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5500 { "(bad)", { XX } },
5503 /* PREFIX_VEX_3A6D */
5505 { "(bad)", { XX } },
5506 { "(bad)", { XX } },
5507 { "vfmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5508 { "(bad)", { XX } },
5511 /* PREFIX_VEX_3A6E */
5513 { "(bad)", { XX } },
5514 { "(bad)", { XX } },
5515 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2) },
5516 { "(bad)", { XX } },
5519 /* PREFIX_VEX_3A6F */
5521 { "(bad)", { XX } },
5522 { "(bad)", { XX } },
5523 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2) },
5524 { "(bad)", { XX } },
5527 /* PREFIX_VEX_3A78 */
5529 { "(bad)", { XX } },
5530 { "(bad)", { XX } },
5531 { "vfnmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5532 { "(bad)", { XX } },
5535 /* PREFIX_VEX_3A79 */
5537 { "(bad)", { XX } },
5538 { "(bad)", { XX } },
5539 { "vfnmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5540 { "(bad)", { XX } },
5543 /* PREFIX_VEX_3A7A */
5545 { "(bad)", { XX } },
5546 { "(bad)", { XX } },
5547 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2) },
5548 { "(bad)", { XX } },
5551 /* PREFIX_VEX_3A7B */
5553 { "(bad)", { XX } },
5554 { "(bad)", { XX } },
5555 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2) },
5556 { "(bad)", { XX } },
5559 /* PREFIX_VEX_3A7C */
5561 { "(bad)", { XX } },
5562 { "(bad)", { XX } },
5563 { "vfnmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5564 { "(bad)", { XX } },
5567 /* PREFIX_VEX_3A7D */
5569 { "(bad)", { XX } },
5570 { "(bad)", { XX } },
5571 { "vfnmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5572 { "(bad)", { XX } },
5575 /* PREFIX_VEX_3A7E */
5577 { "(bad)", { XX } },
5578 { "(bad)", { XX } },
5579 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2) },
5580 { "(bad)", { XX } },
5583 /* PREFIX_VEX_3A7F */
5585 { "(bad)", { XX } },
5586 { "(bad)", { XX } },
5587 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2) },
5588 { "(bad)", { XX } },
5591 /* PREFIX_VEX_3ADF */
5593 { "(bad)", { XX } },
5594 { "(bad)", { XX } },
5595 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2) },
5596 { "(bad)", { XX } },
5600 static const struct dis386 x86_64_table[][2] = {
5603 { "push{T|}", { es } },
5604 { "(bad)", { XX } },
5609 { "pop{T|}", { es } },
5610 { "(bad)", { XX } },
5615 { "push{T|}", { cs } },
5616 { "(bad)", { XX } },
5621 { "push{T|}", { ss } },
5622 { "(bad)", { XX } },
5627 { "pop{T|}", { ss } },
5628 { "(bad)", { XX } },
5633 { "push{T|}", { ds } },
5634 { "(bad)", { XX } },
5639 { "pop{T|}", { ds } },
5640 { "(bad)", { XX } },
5646 { "(bad)", { XX } },
5652 { "(bad)", { XX } },
5658 { "(bad)", { XX } },
5664 { "(bad)", { XX } },
5669 { "pusha{P|}", { XX } },
5670 { "(bad)", { XX } },
5675 { "popa{P|}", { XX } },
5676 { "(bad)", { XX } },
5681 { MOD_TABLE (MOD_62_32BIT) },
5682 { "(bad)", { XX } },
5687 { "arpl", { Ew, Gw } },
5688 { "movs{lq|xd}", { Gv, Ed } },
5693 { "ins{R|}", { Yzr, indirDX } },
5694 { "ins{G|}", { Yzr, indirDX } },
5699 { "outs{R|}", { indirDXr, Xz } },
5700 { "outs{G|}", { indirDXr, Xz } },
5705 { "Jcall{T|}", { Ap } },
5706 { "(bad)", { XX } },
5711 { MOD_TABLE (MOD_C4_32BIT) },
5712 { VEX_C4_TABLE (VEX_0F) },
5717 { MOD_TABLE (MOD_C5_32BIT) },
5718 { VEX_C5_TABLE (VEX_0F) },
5724 { "(bad)", { XX } },
5730 { "(bad)", { XX } },
5736 { "(bad)", { XX } },
5741 { "Jjmp{T|}", { Ap } },
5742 { "(bad)", { XX } },
5745 /* X86_64_0F01_REG_0 */
5747 { "sgdt{Q|IQ}", { M } },
5751 /* X86_64_0F01_REG_1 */
5753 { "sidt{Q|IQ}", { M } },
5757 /* X86_64_0F01_REG_2 */
5759 { "lgdt{Q|Q}", { M } },
5763 /* X86_64_0F01_REG_3 */
5765 { "lidt{Q|Q}", { M } },
5770 static const struct dis386 three_byte_table[][256] = {
5772 /* THREE_BYTE_0F38 */
5775 { "pshufb", { MX, EM } },
5776 { "phaddw", { MX, EM } },
5777 { "phaddd", { MX, EM } },
5778 { "phaddsw", { MX, EM } },
5779 { "pmaddubsw", { MX, EM } },
5780 { "phsubw", { MX, EM } },
5781 { "phsubd", { MX, EM } },
5782 { "phsubsw", { MX, EM } },
5784 { "psignb", { MX, EM } },
5785 { "psignw", { MX, EM } },
5786 { "psignd", { MX, EM } },
5787 { "pmulhrsw", { MX, EM } },
5788 { "(bad)", { XX } },
5789 { "(bad)", { XX } },
5790 { "(bad)", { XX } },
5791 { "(bad)", { XX } },
5793 { PREFIX_TABLE (PREFIX_0F3810) },
5794 { "(bad)", { XX } },
5795 { "(bad)", { XX } },
5796 { "(bad)", { XX } },
5797 { PREFIX_TABLE (PREFIX_0F3814) },
5798 { PREFIX_TABLE (PREFIX_0F3815) },
5799 { "(bad)", { XX } },
5800 { PREFIX_TABLE (PREFIX_0F3817) },
5802 { "(bad)", { XX } },
5803 { "(bad)", { XX } },
5804 { "(bad)", { XX } },
5805 { "(bad)", { XX } },
5806 { "pabsb", { MX, EM } },
5807 { "pabsw", { MX, EM } },
5808 { "pabsd", { MX, EM } },
5809 { "(bad)", { XX } },
5811 { PREFIX_TABLE (PREFIX_0F3820) },
5812 { PREFIX_TABLE (PREFIX_0F3821) },
5813 { PREFIX_TABLE (PREFIX_0F3822) },
5814 { PREFIX_TABLE (PREFIX_0F3823) },
5815 { PREFIX_TABLE (PREFIX_0F3824) },
5816 { PREFIX_TABLE (PREFIX_0F3825) },
5817 { "(bad)", { XX } },
5818 { "(bad)", { XX } },
5820 { PREFIX_TABLE (PREFIX_0F3828) },
5821 { PREFIX_TABLE (PREFIX_0F3829) },
5822 { PREFIX_TABLE (PREFIX_0F382A) },
5823 { PREFIX_TABLE (PREFIX_0F382B) },
5824 { "(bad)", { XX } },
5825 { "(bad)", { XX } },
5826 { "(bad)", { XX } },
5827 { "(bad)", { XX } },
5829 { PREFIX_TABLE (PREFIX_0F3830) },
5830 { PREFIX_TABLE (PREFIX_0F3831) },
5831 { PREFIX_TABLE (PREFIX_0F3832) },
5832 { PREFIX_TABLE (PREFIX_0F3833) },
5833 { PREFIX_TABLE (PREFIX_0F3834) },
5834 { PREFIX_TABLE (PREFIX_0F3835) },
5835 { "(bad)", { XX } },
5836 { PREFIX_TABLE (PREFIX_0F3837) },
5838 { PREFIX_TABLE (PREFIX_0F3838) },
5839 { PREFIX_TABLE (PREFIX_0F3839) },
5840 { PREFIX_TABLE (PREFIX_0F383A) },
5841 { PREFIX_TABLE (PREFIX_0F383B) },
5842 { PREFIX_TABLE (PREFIX_0F383C) },
5843 { PREFIX_TABLE (PREFIX_0F383D) },
5844 { PREFIX_TABLE (PREFIX_0F383E) },
5845 { PREFIX_TABLE (PREFIX_0F383F) },
5847 { PREFIX_TABLE (PREFIX_0F3840) },
5848 { PREFIX_TABLE (PREFIX_0F3841) },
5849 { "(bad)", { XX } },
5850 { "(bad)", { XX } },
5851 { "(bad)", { XX } },
5852 { "(bad)", { XX } },
5853 { "(bad)", { XX } },
5854 { "(bad)", { XX } },
5856 { "(bad)", { XX } },
5857 { "(bad)", { XX } },
5858 { "(bad)", { XX } },
5859 { "(bad)", { XX } },
5860 { "(bad)", { XX } },
5861 { "(bad)", { XX } },
5862 { "(bad)", { XX } },
5863 { "(bad)", { XX } },
5865 { "(bad)", { XX } },
5866 { "(bad)", { XX } },
5867 { "(bad)", { XX } },
5868 { "(bad)", { XX } },
5869 { "(bad)", { XX } },
5870 { "(bad)", { XX } },
5871 { "(bad)", { XX } },
5872 { "(bad)", { XX } },
5874 { "(bad)", { XX } },
5875 { "(bad)", { XX } },
5876 { "(bad)", { XX } },
5877 { "(bad)", { XX } },
5878 { "(bad)", { XX } },
5879 { "(bad)", { XX } },
5880 { "(bad)", { XX } },
5881 { "(bad)", { XX } },
5883 { "(bad)", { XX } },
5884 { "(bad)", { XX } },
5885 { "(bad)", { XX } },
5886 { "(bad)", { XX } },
5887 { "(bad)", { XX } },
5888 { "(bad)", { XX } },
5889 { "(bad)", { XX } },
5890 { "(bad)", { XX } },
5892 { "(bad)", { XX } },
5893 { "(bad)", { XX } },
5894 { "(bad)", { XX } },
5895 { "(bad)", { XX } },
5896 { "(bad)", { XX } },
5897 { "(bad)", { XX } },
5898 { "(bad)", { XX } },
5899 { "(bad)", { XX } },
5901 { "(bad)", { XX } },
5902 { "(bad)", { XX } },
5903 { "(bad)", { XX } },
5904 { "(bad)", { XX } },
5905 { "(bad)", { XX } },
5906 { "(bad)", { XX } },
5907 { "(bad)", { XX } },
5908 { "(bad)", { XX } },
5910 { "(bad)", { XX } },
5911 { "(bad)", { XX } },
5912 { "(bad)", { XX } },
5913 { "(bad)", { XX } },
5914 { "(bad)", { XX } },
5915 { "(bad)", { XX } },
5916 { "(bad)", { XX } },
5917 { "(bad)", { XX } },
5919 { PREFIX_TABLE (PREFIX_0F3880) },
5920 { PREFIX_TABLE (PREFIX_0F3881) },
5921 { "(bad)", { XX } },
5922 { "(bad)", { XX } },
5923 { "(bad)", { XX } },
5924 { "(bad)", { XX } },
5925 { "(bad)", { XX } },
5926 { "(bad)", { XX } },
5928 { "(bad)", { XX } },
5929 { "(bad)", { XX } },
5930 { "(bad)", { XX } },
5931 { "(bad)", { XX } },
5932 { "(bad)", { XX } },
5933 { "(bad)", { XX } },
5934 { "(bad)", { XX } },
5935 { "(bad)", { XX } },
5937 { "(bad)", { XX } },
5938 { "(bad)", { XX } },
5939 { "(bad)", { XX } },
5940 { "(bad)", { XX } },
5941 { "(bad)", { XX } },
5942 { "(bad)", { XX } },
5943 { "(bad)", { XX } },
5944 { "(bad)", { XX } },
5946 { "(bad)", { XX } },
5947 { "(bad)", { XX } },
5948 { "(bad)", { XX } },
5949 { "(bad)", { XX } },
5950 { "(bad)", { XX } },
5951 { "(bad)", { XX } },
5952 { "(bad)", { XX } },
5953 { "(bad)", { XX } },
5955 { "(bad)", { XX } },
5956 { "(bad)", { XX } },
5957 { "(bad)", { XX } },
5958 { "(bad)", { XX } },
5959 { "(bad)", { XX } },
5960 { "(bad)", { XX } },
5961 { "(bad)", { XX } },
5962 { "(bad)", { XX } },
5964 { "(bad)", { XX } },
5965 { "(bad)", { XX } },
5966 { "(bad)", { XX } },
5967 { "(bad)", { XX } },
5968 { "(bad)", { XX } },
5969 { "(bad)", { XX } },
5970 { "(bad)", { XX } },
5971 { "(bad)", { XX } },
5973 { "(bad)", { XX } },
5974 { "(bad)", { XX } },
5975 { "(bad)", { XX } },
5976 { "(bad)", { XX } },
5977 { "(bad)", { XX } },
5978 { "(bad)", { XX } },
5979 { "(bad)", { XX } },
5980 { "(bad)", { XX } },
5982 { "(bad)", { XX } },
5983 { "(bad)", { XX } },
5984 { "(bad)", { XX } },
5985 { "(bad)", { XX } },
5986 { "(bad)", { XX } },
5987 { "(bad)", { XX } },
5988 { "(bad)", { XX } },
5989 { "(bad)", { XX } },
5991 { "(bad)", { XX } },
5992 { "(bad)", { XX } },
5993 { "(bad)", { XX } },
5994 { "(bad)", { XX } },
5995 { "(bad)", { XX } },
5996 { "(bad)", { XX } },
5997 { "(bad)", { XX } },
5998 { "(bad)", { XX } },
6000 { "(bad)", { XX } },
6001 { "(bad)", { XX } },
6002 { "(bad)", { XX } },
6003 { "(bad)", { XX } },
6004 { "(bad)", { XX } },
6005 { "(bad)", { XX } },
6006 { "(bad)", { XX } },
6007 { "(bad)", { XX } },
6009 { "(bad)", { XX } },
6010 { "(bad)", { XX } },
6011 { "(bad)", { XX } },
6012 { "(bad)", { XX } },
6013 { "(bad)", { XX } },
6014 { "(bad)", { XX } },
6015 { "(bad)", { XX } },
6016 { "(bad)", { XX } },
6018 { "(bad)", { XX } },
6019 { "(bad)", { XX } },
6020 { "(bad)", { XX } },
6021 { PREFIX_TABLE (PREFIX_0F38DB) },
6022 { PREFIX_TABLE (PREFIX_0F38DC) },
6023 { PREFIX_TABLE (PREFIX_0F38DD) },
6024 { PREFIX_TABLE (PREFIX_0F38DE) },
6025 { PREFIX_TABLE (PREFIX_0F38DF) },
6027 { "(bad)", { XX } },
6028 { "(bad)", { XX } },
6029 { "(bad)", { XX } },
6030 { "(bad)", { XX } },
6031 { "(bad)", { XX } },
6032 { "(bad)", { XX } },
6033 { "(bad)", { XX } },
6034 { "(bad)", { XX } },
6036 { "(bad)", { XX } },
6037 { "(bad)", { XX } },
6038 { "(bad)", { XX } },
6039 { "(bad)", { XX } },
6040 { "(bad)", { XX } },
6041 { "(bad)", { XX } },
6042 { "(bad)", { XX } },
6043 { "(bad)", { XX } },
6045 { PREFIX_TABLE (PREFIX_0F38F0) },
6046 { PREFIX_TABLE (PREFIX_0F38F1) },
6047 { "(bad)", { XX } },
6048 { "(bad)", { XX } },
6049 { "(bad)", { XX } },
6050 { "(bad)", { XX } },
6051 { "(bad)", { XX } },
6052 { "(bad)", { XX } },
6054 { "(bad)", { XX } },
6055 { "(bad)", { XX } },
6056 { "(bad)", { XX } },
6057 { "(bad)", { XX } },
6058 { "(bad)", { XX } },
6059 { "(bad)", { XX } },
6060 { "(bad)", { XX } },
6061 { "(bad)", { XX } },
6063 /* THREE_BYTE_0F3A */
6066 { "(bad)", { XX } },
6067 { "(bad)", { XX } },
6068 { "(bad)", { XX } },
6069 { "(bad)", { XX } },
6070 { "(bad)", { XX } },
6071 { "(bad)", { XX } },
6072 { "(bad)", { XX } },
6073 { "(bad)", { XX } },
6075 { PREFIX_TABLE (PREFIX_0F3A08) },
6076 { PREFIX_TABLE (PREFIX_0F3A09) },
6077 { PREFIX_TABLE (PREFIX_0F3A0A) },
6078 { PREFIX_TABLE (PREFIX_0F3A0B) },
6079 { PREFIX_TABLE (PREFIX_0F3A0C) },
6080 { PREFIX_TABLE (PREFIX_0F3A0D) },
6081 { PREFIX_TABLE (PREFIX_0F3A0E) },
6082 { "palignr", { MX, EM, Ib } },
6084 { "(bad)", { XX } },
6085 { "(bad)", { XX } },
6086 { "(bad)", { XX } },
6087 { "(bad)", { XX } },
6088 { PREFIX_TABLE (PREFIX_0F3A14) },
6089 { PREFIX_TABLE (PREFIX_0F3A15) },
6090 { PREFIX_TABLE (PREFIX_0F3A16) },
6091 { PREFIX_TABLE (PREFIX_0F3A17) },
6093 { "(bad)", { XX } },
6094 { "(bad)", { XX } },
6095 { "(bad)", { XX } },
6096 { "(bad)", { XX } },
6097 { "(bad)", { XX } },
6098 { "(bad)", { XX } },
6099 { "(bad)", { XX } },
6100 { "(bad)", { XX } },
6102 { PREFIX_TABLE (PREFIX_0F3A20) },
6103 { PREFIX_TABLE (PREFIX_0F3A21) },
6104 { PREFIX_TABLE (PREFIX_0F3A22) },
6105 { "(bad)", { XX } },
6106 { "(bad)", { XX } },
6107 { "(bad)", { XX } },
6108 { "(bad)", { XX } },
6109 { "(bad)", { XX } },
6111 { "(bad)", { XX } },
6112 { "(bad)", { XX } },
6113 { "(bad)", { XX } },
6114 { "(bad)", { XX } },
6115 { "(bad)", { XX } },
6116 { "(bad)", { XX } },
6117 { "(bad)", { XX } },
6118 { "(bad)", { XX } },
6120 { "(bad)", { XX } },
6121 { "(bad)", { XX } },
6122 { "(bad)", { XX } },
6123 { "(bad)", { XX } },
6124 { "(bad)", { XX } },
6125 { "(bad)", { XX } },
6126 { "(bad)", { XX } },
6127 { "(bad)", { XX } },
6129 { "(bad)", { XX } },
6130 { "(bad)", { XX } },
6131 { "(bad)", { XX } },
6132 { "(bad)", { XX } },
6133 { "(bad)", { XX } },
6134 { "(bad)", { XX } },
6135 { "(bad)", { XX } },
6136 { "(bad)", { XX } },
6138 { PREFIX_TABLE (PREFIX_0F3A40) },
6139 { PREFIX_TABLE (PREFIX_0F3A41) },
6140 { PREFIX_TABLE (PREFIX_0F3A42) },
6141 { "(bad)", { XX } },
6142 { PREFIX_TABLE (PREFIX_0F3A44) },
6143 { "(bad)", { XX } },
6144 { "(bad)", { XX } },
6145 { "(bad)", { XX } },
6147 { "(bad)", { XX } },
6148 { "(bad)", { XX } },
6149 { "(bad)", { XX } },
6150 { "(bad)", { XX } },
6151 { "(bad)", { XX } },
6152 { "(bad)", { XX } },
6153 { "(bad)", { XX } },
6154 { "(bad)", { XX } },
6156 { "(bad)", { XX } },
6157 { "(bad)", { XX } },
6158 { "(bad)", { XX } },
6159 { "(bad)", { XX } },
6160 { "(bad)", { XX } },
6161 { "(bad)", { XX } },
6162 { "(bad)", { XX } },
6163 { "(bad)", { XX } },
6165 { "(bad)", { XX } },
6166 { "(bad)", { XX } },
6167 { "(bad)", { XX } },
6168 { "(bad)", { XX } },
6169 { "(bad)", { XX } },
6170 { "(bad)", { XX } },
6171 { "(bad)", { XX } },
6172 { "(bad)", { XX } },
6174 { PREFIX_TABLE (PREFIX_0F3A60) },
6175 { PREFIX_TABLE (PREFIX_0F3A61) },
6176 { PREFIX_TABLE (PREFIX_0F3A62) },
6177 { PREFIX_TABLE (PREFIX_0F3A63) },
6178 { "(bad)", { XX } },
6179 { "(bad)", { XX } },
6180 { "(bad)", { XX } },
6181 { "(bad)", { XX } },
6183 { "(bad)", { XX } },
6184 { "(bad)", { XX } },
6185 { "(bad)", { XX } },
6186 { "(bad)", { XX } },
6187 { "(bad)", { XX } },
6188 { "(bad)", { XX } },
6189 { "(bad)", { XX } },
6190 { "(bad)", { XX } },
6192 { "(bad)", { XX } },
6193 { "(bad)", { XX } },
6194 { "(bad)", { XX } },
6195 { "(bad)", { XX } },
6196 { "(bad)", { XX } },
6197 { "(bad)", { XX } },
6198 { "(bad)", { XX } },
6199 { "(bad)", { XX } },
6201 { "(bad)", { XX } },
6202 { "(bad)", { XX } },
6203 { "(bad)", { XX } },
6204 { "(bad)", { XX } },
6205 { "(bad)", { XX } },
6206 { "(bad)", { XX } },
6207 { "(bad)", { XX } },
6208 { "(bad)", { XX } },
6210 { "(bad)", { XX } },
6211 { "(bad)", { XX } },
6212 { "(bad)", { XX } },
6213 { "(bad)", { XX } },
6214 { "(bad)", { XX } },
6215 { "(bad)", { XX } },
6216 { "(bad)", { XX } },
6217 { "(bad)", { XX } },
6219 { "(bad)", { XX } },
6220 { "(bad)", { XX } },
6221 { "(bad)", { XX } },
6222 { "(bad)", { XX } },
6223 { "(bad)", { XX } },
6224 { "(bad)", { XX } },
6225 { "(bad)", { XX } },
6226 { "(bad)", { XX } },
6228 { "(bad)", { XX } },
6229 { "(bad)", { XX } },
6230 { "(bad)", { XX } },
6231 { "(bad)", { XX } },
6232 { "(bad)", { XX } },
6233 { "(bad)", { XX } },
6234 { "(bad)", { XX } },
6235 { "(bad)", { XX } },
6237 { "(bad)", { XX } },
6238 { "(bad)", { XX } },
6239 { "(bad)", { XX } },
6240 { "(bad)", { XX } },
6241 { "(bad)", { XX } },
6242 { "(bad)", { XX } },
6243 { "(bad)", { XX } },
6244 { "(bad)", { XX } },
6246 { "(bad)", { XX } },
6247 { "(bad)", { XX } },
6248 { "(bad)", { XX } },
6249 { "(bad)", { XX } },
6250 { "(bad)", { XX } },
6251 { "(bad)", { XX } },
6252 { "(bad)", { XX } },
6253 { "(bad)", { XX } },
6255 { "(bad)", { XX } },
6256 { "(bad)", { XX } },
6257 { "(bad)", { XX } },
6258 { "(bad)", { XX } },
6259 { "(bad)", { XX } },
6260 { "(bad)", { XX } },
6261 { "(bad)", { XX } },
6262 { "(bad)", { XX } },
6264 { "(bad)", { XX } },
6265 { "(bad)", { XX } },
6266 { "(bad)", { XX } },
6267 { "(bad)", { XX } },
6268 { "(bad)", { XX } },
6269 { "(bad)", { XX } },
6270 { "(bad)", { XX } },
6271 { "(bad)", { XX } },
6273 { "(bad)", { XX } },
6274 { "(bad)", { XX } },
6275 { "(bad)", { XX } },
6276 { "(bad)", { XX } },
6277 { "(bad)", { XX } },
6278 { "(bad)", { XX } },
6279 { "(bad)", { XX } },
6280 { "(bad)", { XX } },
6282 { "(bad)", { XX } },
6283 { "(bad)", { XX } },
6284 { "(bad)", { XX } },
6285 { "(bad)", { XX } },
6286 { "(bad)", { XX } },
6287 { "(bad)", { XX } },
6288 { "(bad)", { XX } },
6289 { "(bad)", { XX } },
6291 { "(bad)", { XX } },
6292 { "(bad)", { XX } },
6293 { "(bad)", { XX } },
6294 { "(bad)", { XX } },
6295 { "(bad)", { XX } },
6296 { "(bad)", { XX } },
6297 { "(bad)", { XX } },
6298 { "(bad)", { XX } },
6300 { "(bad)", { XX } },
6301 { "(bad)", { XX } },
6302 { "(bad)", { XX } },
6303 { "(bad)", { XX } },
6304 { "(bad)", { XX } },
6305 { "(bad)", { XX } },
6306 { "(bad)", { XX } },
6307 { "(bad)", { XX } },
6309 { "(bad)", { XX } },
6310 { "(bad)", { XX } },
6311 { "(bad)", { XX } },
6312 { "(bad)", { XX } },
6313 { "(bad)", { XX } },
6314 { "(bad)", { XX } },
6315 { "(bad)", { XX } },
6316 { PREFIX_TABLE (PREFIX_0F3ADF) },
6318 { "(bad)", { XX } },
6319 { "(bad)", { XX } },
6320 { "(bad)", { XX } },
6321 { "(bad)", { XX } },
6322 { "(bad)", { XX } },
6323 { "(bad)", { XX } },
6324 { "(bad)", { XX } },
6325 { "(bad)", { XX } },
6327 { "(bad)", { XX } },
6328 { "(bad)", { XX } },
6329 { "(bad)", { XX } },
6330 { "(bad)", { XX } },
6331 { "(bad)", { XX } },
6332 { "(bad)", { XX } },
6333 { "(bad)", { XX } },
6334 { "(bad)", { XX } },
6336 { "(bad)", { XX } },
6337 { "(bad)", { XX } },
6338 { "(bad)", { XX } },
6339 { "(bad)", { XX } },
6340 { "(bad)", { XX } },
6341 { "(bad)", { XX } },
6342 { "(bad)", { XX } },
6343 { "(bad)", { XX } },
6345 { "(bad)", { XX } },
6346 { "(bad)", { XX } },
6347 { "(bad)", { XX } },
6348 { "(bad)", { XX } },
6349 { "(bad)", { XX } },
6350 { "(bad)", { XX } },
6351 { "(bad)", { XX } },
6352 { "(bad)", { XX } },
6355 /* THREE_BYTE_0F7A */
6358 { "(bad)", { XX } },
6359 { "(bad)", { XX } },
6360 { "(bad)", { XX } },
6361 { "(bad)", { XX } },
6362 { "(bad)", { XX } },
6363 { "(bad)", { XX } },
6364 { "(bad)", { XX } },
6365 { "(bad)", { XX } },
6367 { "(bad)", { XX } },
6368 { "(bad)", { XX } },
6369 { "(bad)", { XX } },
6370 { "(bad)", { XX } },
6371 { "(bad)", { XX } },
6372 { "(bad)", { XX } },
6373 { "(bad)", { XX } },
6374 { "(bad)", { XX } },
6376 { "(bad)", { XX } },
6377 { "(bad)", { XX } },
6378 { "(bad)", { XX } },
6379 { "(bad)", { XX } },
6380 { "(bad)", { XX } },
6381 { "(bad)", { XX } },
6382 { "(bad)", { XX } },
6383 { "(bad)", { XX } },
6385 { "(bad)", { XX } },
6386 { "(bad)", { XX } },
6387 { "(bad)", { XX } },
6388 { "(bad)", { XX } },
6389 { "(bad)", { XX } },
6390 { "(bad)", { XX } },
6391 { "(bad)", { XX } },
6392 { "(bad)", { XX } },
6394 { "ptest", { XX } },
6395 { "(bad)", { XX } },
6396 { "(bad)", { XX } },
6397 { "(bad)", { XX } },
6398 { "(bad)", { XX } },
6399 { "(bad)", { XX } },
6400 { "(bad)", { XX } },
6401 { "(bad)", { XX } },
6403 { "(bad)", { XX } },
6404 { "(bad)", { XX } },
6405 { "(bad)", { XX } },
6406 { "(bad)", { XX } },
6407 { "(bad)", { XX } },
6408 { "(bad)", { XX } },
6409 { "(bad)", { XX } },
6410 { "(bad)", { XX } },
6412 { "(bad)", { XX } },
6413 { "(bad)", { XX } },
6414 { "(bad)", { XX } },
6415 { "(bad)", { XX } },
6416 { "(bad)", { XX } },
6417 { "(bad)", { XX } },
6418 { "(bad)", { XX } },
6419 { "(bad)", { XX } },
6421 { "(bad)", { XX } },
6422 { "(bad)", { XX } },
6423 { "(bad)", { XX } },
6424 { "(bad)", { XX } },
6425 { "(bad)", { XX } },
6426 { "(bad)", { XX } },
6427 { "(bad)", { XX } },
6428 { "(bad)", { XX } },
6430 { "(bad)", { XX } },
6431 { "phaddbw", { XM, EXq } },
6432 { "phaddbd", { XM, EXq } },
6433 { "phaddbq", { XM, EXq } },
6434 { "(bad)", { XX } },
6435 { "(bad)", { XX } },
6436 { "phaddwd", { XM, EXq } },
6437 { "phaddwq", { XM, EXq } },
6439 { "(bad)", { XX } },
6440 { "(bad)", { XX } },
6441 { "(bad)", { XX } },
6442 { "phadddq", { XM, EXq } },
6443 { "(bad)", { XX } },
6444 { "(bad)", { XX } },
6445 { "(bad)", { XX } },
6446 { "(bad)", { XX } },
6448 { "(bad)", { XX } },
6449 { "phaddubw", { XM, EXq } },
6450 { "phaddubd", { XM, EXq } },
6451 { "phaddubq", { XM, EXq } },
6452 { "(bad)", { XX } },
6453 { "(bad)", { XX } },
6454 { "phadduwd", { XM, EXq } },
6455 { "phadduwq", { XM, EXq } },
6457 { "(bad)", { XX } },
6458 { "(bad)", { XX } },
6459 { "(bad)", { XX } },
6460 { "phaddudq", { XM, EXq } },
6461 { "(bad)", { XX } },
6462 { "(bad)", { XX } },
6463 { "(bad)", { XX } },
6464 { "(bad)", { XX } },
6466 { "(bad)", { XX } },
6467 { "phsubbw", { XM, EXq } },
6468 { "phsubbd", { XM, EXq } },
6469 { "phsubbq", { XM, EXq } },
6470 { "(bad)", { XX } },
6471 { "(bad)", { XX } },
6472 { "(bad)", { XX } },
6473 { "(bad)", { XX } },
6475 { "(bad)", { XX } },
6476 { "(bad)", { XX } },
6477 { "(bad)", { XX } },
6478 { "(bad)", { XX } },
6479 { "(bad)", { XX } },
6480 { "(bad)", { XX } },
6481 { "(bad)", { XX } },
6482 { "(bad)", { XX } },
6484 { "(bad)", { XX } },
6485 { "(bad)", { XX } },
6486 { "(bad)", { XX } },
6487 { "(bad)", { XX } },
6488 { "(bad)", { XX } },
6489 { "(bad)", { XX } },
6490 { "(bad)", { XX } },
6491 { "(bad)", { XX } },
6493 { "(bad)", { XX } },
6494 { "(bad)", { XX } },
6495 { "(bad)", { XX } },
6496 { "(bad)", { XX } },
6497 { "(bad)", { XX } },
6498 { "(bad)", { XX } },
6499 { "(bad)", { XX } },
6500 { "(bad)", { XX } },
6502 { "(bad)", { XX } },
6503 { "(bad)", { XX } },
6504 { "(bad)", { XX } },
6505 { "(bad)", { XX } },
6506 { "(bad)", { XX } },
6507 { "(bad)", { XX } },
6508 { "(bad)", { XX } },
6509 { "(bad)", { XX } },
6511 { "(bad)", { XX } },
6512 { "(bad)", { XX } },
6513 { "(bad)", { XX } },
6514 { "(bad)", { XX } },
6515 { "(bad)", { XX } },
6516 { "(bad)", { XX } },
6517 { "(bad)", { XX } },
6518 { "(bad)", { XX } },
6520 { "(bad)", { XX } },
6521 { "(bad)", { XX } },
6522 { "(bad)", { XX } },
6523 { "(bad)", { XX } },
6524 { "(bad)", { XX } },
6525 { "(bad)", { XX } },
6526 { "(bad)", { XX } },
6527 { "(bad)", { XX } },
6529 { "(bad)", { XX } },
6530 { "(bad)", { XX } },
6531 { "(bad)", { XX } },
6532 { "(bad)", { XX } },
6533 { "(bad)", { XX } },
6534 { "(bad)", { XX } },
6535 { "(bad)", { XX } },
6536 { "(bad)", { XX } },
6538 { "(bad)", { XX } },
6539 { "(bad)", { XX } },
6540 { "(bad)", { XX } },
6541 { "(bad)", { XX } },
6542 { "(bad)", { XX } },
6543 { "(bad)", { XX } },
6544 { "(bad)", { XX } },
6545 { "(bad)", { XX } },
6547 { "(bad)", { XX } },
6548 { "(bad)", { XX } },
6549 { "(bad)", { XX } },
6550 { "(bad)", { XX } },
6551 { "(bad)", { XX } },
6552 { "(bad)", { XX } },
6553 { "(bad)", { XX } },
6554 { "(bad)", { XX } },
6556 { "(bad)", { XX } },
6557 { "(bad)", { XX } },
6558 { "(bad)", { XX } },
6559 { "(bad)", { XX } },
6560 { "(bad)", { XX } },
6561 { "(bad)", { XX } },
6562 { "(bad)", { XX } },
6563 { "(bad)", { XX } },
6565 { "(bad)", { XX } },
6566 { "(bad)", { XX } },
6567 { "(bad)", { XX } },
6568 { "(bad)", { XX } },
6569 { "(bad)", { XX } },
6570 { "(bad)", { XX } },
6571 { "(bad)", { XX } },
6572 { "(bad)", { XX } },
6574 { "(bad)", { XX } },
6575 { "(bad)", { XX } },
6576 { "(bad)", { XX } },
6577 { "(bad)", { XX } },
6578 { "(bad)", { XX } },
6579 { "(bad)", { XX } },
6580 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6583 { "(bad)", { XX } },
6584 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6589 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6593 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6598 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6601 { "(bad)", { XX } },
6602 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6607 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6611 { "(bad)", { XX } },
6612 { "(bad)", { XX } },
6613 { "(bad)", { XX } },
6614 { "(bad)", { XX } },
6615 { "(bad)", { XX } },
6616 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6620 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6625 { "(bad)", { XX } },
6626 { "(bad)", { XX } },
6628 { "(bad)", { XX } },
6629 { "(bad)", { XX } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6634 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6638 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6643 { "(bad)", { XX } },
6644 { "(bad)", { XX } },
6648 static const struct dis386 xop_table[][256] = {
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6654 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6656 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6658 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6661 { "(bad)", { XX } },
6662 { "(bad)", { XX } },
6663 { "(bad)", { XX } },
6664 { "(bad)", { XX } },
6665 { "(bad)", { XX } },
6666 { "(bad)", { XX } },
6667 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6672 { "(bad)", { XX } },
6673 { "(bad)", { XX } },
6674 { "(bad)", { XX } },
6675 { "(bad)", { XX } },
6676 { "(bad)", { XX } },
6677 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6683 { "(bad)", { XX } },
6684 { "(bad)", { XX } },
6685 { "(bad)", { XX } },
6686 { "(bad)", { XX } },
6688 { "(bad)", { XX } },
6689 { "(bad)", { XX } },
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6693 { "(bad)", { XX } },
6694 { "(bad)", { XX } },
6695 { "(bad)", { XX } },
6697 { "(bad)", { XX } },
6698 { "(bad)", { XX } },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6702 { "(bad)", { XX } },
6703 { "(bad)", { XX } },
6704 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6707 { "(bad)", { XX } },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6711 { "(bad)", { XX } },
6712 { "(bad)", { XX } },
6713 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6716 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6720 { "(bad)", { XX } },
6721 { "(bad)", { XX } },
6722 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6725 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6729 { "(bad)", { XX } },
6730 { "(bad)", { XX } },
6731 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6734 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6738 { "(bad)", { XX } },
6739 { "(bad)", { XX } },
6740 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6743 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6747 { "(bad)", { XX } },
6748 { "(bad)", { XX } },
6749 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6752 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6756 { "(bad)", { XX } },
6757 { "(bad)", { XX } },
6758 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6761 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6765 { "(bad)", { XX } },
6766 { "(bad)", { XX } },
6767 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6770 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6774 { "(bad)", { XX } },
6775 { "(bad)", { XX } },
6776 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6779 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6783 { "(bad)", { XX } },
6784 { "(bad)", { XX } },
6785 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6788 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6792 { "(bad)", { XX } },
6793 { "(bad)", { XX } },
6794 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6797 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "(bad)", { XX } },
6800 { "(bad)", { XX } },
6801 { "vpmacssww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6802 { "vpmacsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6803 { "vpmacssdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6805 { "(bad)", { XX } },
6806 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "(bad)", { XX } },
6810 { "(bad)", { XX } },
6811 { "vpmacssdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6812 { "vpmacssdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6814 { "(bad)", { XX } },
6815 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "(bad)", { XX } },
6818 { "(bad)", { XX } },
6819 { "vpmacsww", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6820 { "vpmacswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6821 { "vpmacsdql", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6823 { "(bad)", { XX } },
6824 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "(bad)", { XX } },
6828 { "(bad)", { XX } },
6829 { "vpmacsdd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6830 { "vpmacsdqh", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6832 { "(bad)", { XX } },
6833 { "(bad)", { XX } },
6834 { "vpcmov", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6835 { "vpperm", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6836 { "(bad)", { XX } },
6837 { "(bad)", { XX } },
6838 { "vpmadcsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6839 { "(bad)", { XX } },
6841 { "(bad)", { XX } },
6842 { "(bad)", { XX } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6846 { "(bad)", { XX } },
6847 { "(bad)", { XX } },
6848 { "(bad)", { XX } },
6850 { "(bad)", { XX } },
6851 { "(bad)", { XX } },
6852 { "(bad)", { XX } },
6853 { "(bad)", { XX } },
6854 { "(bad)", { XX } },
6855 { "(bad)", { XX } },
6856 { "vpmadcswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6857 { "(bad)", { XX } },
6859 { "(bad)", { XX } },
6860 { "(bad)", { XX } },
6861 { "(bad)", { XX } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6864 { "(bad)", { XX } },
6865 { "(bad)", { XX } },
6866 { "(bad)", { XX } },
6868 { "vprotb", { XM, Vex_2src_1, Ib } },
6869 { "vprotw", { XM, Vex_2src_1, Ib } },
6870 { "vprotd", { XM, Vex_2src_1, Ib } },
6871 { "vprotq", { XM, Vex_2src_1, Ib } },
6872 { "(bad)", { XX } },
6873 { "(bad)", { XX } },
6874 { "(bad)", { XX } },
6875 { "(bad)", { XX } },
6877 { "(bad)", { XX } },
6878 { "(bad)", { XX } },
6879 { "(bad)", { XX } },
6880 { "(bad)", { XX } },
6881 { "vpcomb", { XM, Vex128, EXx, Ib } },
6882 { "vpcomw", { XM, Vex128, EXx, Ib } },
6883 { "vpcomd", { XM, Vex128, EXx, Ib } },
6884 { "vpcomq", { XM, Vex128, EXx, Ib } },
6886 { "(bad)", { XX } },
6887 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6891 { "(bad)", { XX } },
6892 { "(bad)", { XX } },
6893 { "(bad)", { XX } },
6895 { "(bad)", { XX } },
6896 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6900 { "(bad)", { XX } },
6901 { "(bad)", { XX } },
6902 { "(bad)", { XX } },
6904 { "(bad)", { XX } },
6905 { "(bad)", { XX } },
6906 { "(bad)", { XX } },
6907 { "(bad)", { XX } },
6908 { "(bad)", { XX } },
6909 { "(bad)", { XX } },
6910 { "(bad)", { XX } },
6911 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6914 { "(bad)", { XX } },
6915 { "(bad)", { XX } },
6916 { "(bad)", { XX } },
6917 { "vpcomub", { XM, Vex128, EXx, Ib } },
6918 { "vpcomuw", { XM, Vex128, EXx, Ib } },
6919 { "vpcomud", { XM, Vex128, EXx, Ib } },
6920 { "vpcomuq", { XM, Vex128, EXx, Ib } },
6922 { "(bad)", { XX } },
6923 { "(bad)", { XX } },
6924 { "(bad)", { XX } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6927 { "(bad)", { XX } },
6928 { "(bad)", { XX } },
6929 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6932 { "(bad)", { XX } },
6933 { "(bad)", { XX } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6936 { "(bad)", { XX } },
6937 { "(bad)", { XX } },
6938 { "(bad)", { XX } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6945 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6947 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6949 { "(bad)", { XX } },
6950 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6954 { "(bad)", { XX } },
6955 { "(bad)", { XX } },
6956 { "(bad)", { XX } },
6957 { "(bad)", { XX } },
6958 { "(bad)", { XX } },
6959 { "(bad)", { XX } },
6961 { "(bad)", { XX } },
6962 { "(bad)", { XX } },
6963 { REG_TABLE (REG_XOP_LWPCB) },
6964 { "(bad)", { XX } },
6965 { "(bad)", { XX } },
6966 { "(bad)", { XX } },
6967 { "(bad)", { XX } },
6968 { "(bad)", { XX } },
6970 { "(bad)", { XX } },
6971 { "(bad)", { XX } },
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6974 { "(bad)", { XX } },
6975 { "(bad)", { XX } },
6976 { "(bad)", { XX } },
6977 { "(bad)", { XX } },
6979 { "(bad)", { XX } },
6980 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6985 { "(bad)", { XX } },
6986 { "(bad)", { XX } },
6988 { "(bad)", { XX } },
6989 { "(bad)", { XX } },
6990 { "(bad)", { XX } },
6991 { "(bad)", { XX } },
6992 { "(bad)", { XX } },
6993 { "(bad)", { XX } },
6994 { "(bad)", { XX } },
6995 { "(bad)", { XX } },
6997 { "(bad)", { XX } },
6998 { "(bad)", { XX } },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { "(bad)", { XX } },
7002 { "(bad)", { XX } },
7003 { "(bad)", { XX } },
7004 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7007 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7012 { "(bad)", { XX } },
7013 { "(bad)", { XX } },
7015 { "(bad)", { XX } },
7016 { "(bad)", { XX } },
7017 { "(bad)", { XX } },
7018 { "(bad)", { XX } },
7019 { "(bad)", { XX } },
7020 { "(bad)", { XX } },
7021 { "(bad)", { XX } },
7022 { "(bad)", { XX } },
7024 { "(bad)", { XX } },
7025 { "(bad)", { XX } },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7030 { "(bad)", { XX } },
7031 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7034 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7039 { "(bad)", { XX } },
7040 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7043 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7048 { "(bad)", { XX } },
7049 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7052 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7057 { "(bad)", { XX } },
7058 { "(bad)", { XX } },
7060 { "(bad)", { XX } },
7061 { "(bad)", { XX } },
7062 { "(bad)", { XX } },
7063 { "(bad)", { XX } },
7064 { "(bad)", { XX } },
7065 { "(bad)", { XX } },
7066 { "(bad)", { XX } },
7067 { "(bad)", { XX } },
7069 { "(bad)", { XX } },
7070 { "(bad)", { XX } },
7071 { "(bad)", { XX } },
7072 { "(bad)", { XX } },
7073 { "(bad)", { XX } },
7074 { "(bad)", { XX } },
7075 { "(bad)", { XX } },
7076 { "(bad)", { XX } },
7078 { "(bad)", { XX } },
7079 { "(bad)", { XX } },
7080 { "(bad)", { XX } },
7081 { "(bad)", { XX } },
7082 { "(bad)", { XX } },
7083 { "(bad)", { XX } },
7084 { "(bad)", { XX } },
7085 { "(bad)", { XX } },
7087 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80) },
7088 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81) },
7089 { "vfrczss", { XM, EXd } },
7090 { "vfrczsd", { XM, EXq } },
7091 { "(bad)", { XX } },
7092 { "(bad)", { XX } },
7093 { "(bad)", { XX } },
7094 { "(bad)", { XX } },
7096 { "(bad)", { XX } },
7097 { "(bad)", { XX } },
7098 { "(bad)", { XX } },
7099 { "(bad)", { XX } },
7100 { "(bad)", { XX } },
7101 { "(bad)", { XX } },
7102 { "(bad)", { XX } },
7103 { "(bad)", { XX } },
7105 { "vprotb", { XM, Vex_2src_1, Vex_2src_2 } },
7106 { "vprotw", { XM, Vex_2src_1, Vex_2src_2 } },
7107 { "vprotd", { XM, Vex_2src_1, Vex_2src_2 } },
7108 { "vprotq", { XM, Vex_2src_1, Vex_2src_2 } },
7109 { "vpshlb", { XM, Vex_2src_1, Vex_2src_2 } },
7110 { "vpshlw", { XM, Vex_2src_1, Vex_2src_2 } },
7111 { "vpshld", { XM, Vex_2src_1, Vex_2src_2 } },
7112 { "vpshlq", { XM, Vex_2src_1, Vex_2src_2 } },
7114 { "vpshab", { XM, Vex_2src_1, Vex_2src_2 } },
7115 { "vpshaw", { XM, Vex_2src_1, Vex_2src_2 } },
7116 { "vpshad", { XM, Vex_2src_1, Vex_2src_2 } },
7117 { "vpshaq", { XM, Vex_2src_1, Vex_2src_2 } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7120 { "(bad)", { XX } },
7121 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7124 { "(bad)", { XX } },
7125 { "(bad)", { XX } },
7126 { "(bad)", { XX } },
7127 { "(bad)", { XX } },
7128 { "(bad)", { XX } },
7129 { "(bad)", { XX } },
7130 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7133 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7138 { "(bad)", { XX } },
7139 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7142 { "(bad)", { XX } },
7143 { "(bad)", { XX } },
7144 { "(bad)", { XX } },
7145 { "(bad)", { XX } },
7146 { "(bad)", { XX } },
7147 { "(bad)", { XX } },
7148 { "(bad)", { XX } },
7150 { "(bad)", { XX } },
7151 { "(bad)", { XX } },
7152 { "(bad)", { XX } },
7153 { "(bad)", { XX } },
7154 { "(bad)", { XX } },
7155 { "(bad)", { XX } },
7156 { "(bad)", { XX } },
7157 { "(bad)", { XX } },
7159 { "(bad)", { XX } },
7160 { "vphaddbw", { XM, EXxmm } },
7161 { "vphaddbd", { XM, EXxmm } },
7162 { "vphaddbq", { XM, EXxmm } },
7163 { "(bad)", { XX } },
7164 { "(bad)", { XX } },
7165 { "vphaddwd", { XM, EXxmm } },
7166 { "vphaddwq", { XM, EXxmm } },
7168 { "(bad)", { XX } },
7169 { "(bad)", { XX } },
7170 { "(bad)", { XX } },
7171 { "vphadddq", { XM, EXxmm } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7174 { "(bad)", { XX } },
7175 { "(bad)", { XX } },
7177 { "(bad)", { XX } },
7178 { "vphaddubw", { XM, EXxmm } },
7179 { "vphaddubd", { XM, EXxmm } },
7180 { "vphaddubq", { XM, EXxmm } },
7181 { "(bad)", { XX } },
7182 { "(bad)", { XX } },
7183 { "vphadduwd", { XM, EXxmm } },
7184 { "vphadduwq", { XM, EXxmm } },
7186 { "(bad)", { XX } },
7187 { "(bad)", { XX } },
7188 { "(bad)", { XX } },
7189 { "vphaddudq", { XM, EXxmm } },
7190 { "(bad)", { XX } },
7191 { "(bad)", { XX } },
7192 { "(bad)", { XX } },
7193 { "(bad)", { XX } },
7195 { "(bad)", { XX } },
7196 { "vphsubbw", { XM, EXxmm } },
7197 { "vphsubwd", { XM, EXxmm } },
7198 { "vphsubdq", { XM, EXxmm } },
7199 { "(bad)", { XX } },
7200 { "(bad)", { XX } },
7201 { "(bad)", { XX } },
7202 { "(bad)", { XX } },
7204 { "(bad)", { XX } },
7205 { "(bad)", { XX } },
7206 { "(bad)", { XX } },
7207 { "(bad)", { XX } },
7208 { "(bad)", { XX } },
7209 { "(bad)", { XX } },
7210 { "(bad)", { XX } },
7211 { "(bad)", { XX } },
7213 { "(bad)", { XX } },
7214 { "(bad)", { XX } },
7215 { "(bad)", { XX } },
7216 { "(bad)", { XX } },
7217 { "(bad)", { XX } },
7218 { "(bad)", { XX } },
7219 { "(bad)", { XX } },
7220 { "(bad)", { XX } },
7222 { "(bad)", { XX } },
7223 { "(bad)", { XX } },
7224 { "(bad)", { XX } },
7225 { "(bad)", { XX } },
7226 { "(bad)", { XX } },
7227 { "(bad)", { XX } },
7228 { "(bad)", { XX } },
7229 { "(bad)", { XX } },
7234 { "(bad)", { XX } },
7235 { "(bad)", { XX } },
7236 { "(bad)", { XX } },
7237 { "(bad)", { XX } },
7238 { "(bad)", { XX } },
7239 { "(bad)", { XX } },
7240 { "(bad)", { XX } },
7241 { "(bad)", { XX } },
7243 { "(bad)", { XX } },
7244 { "(bad)", { XX } },
7245 { "(bad)", { XX } },
7246 { "(bad)", { XX } },
7247 { "(bad)", { XX } },
7248 { "(bad)", { XX } },
7249 { "(bad)", { XX } },
7250 { "(bad)", { XX } },
7252 { "(bad)", { XX } },
7253 { "(bad)", { XX } },
7254 { REG_TABLE (REG_XOP_LWP) },
7255 { "(bad)", { XX } },
7256 { "(bad)", { XX } },
7257 { "(bad)", { XX } },
7258 { "(bad)", { XX } },
7259 { "(bad)", { XX } },
7261 { "(bad)", { XX } },
7262 { "(bad)", { XX } },
7263 { "(bad)", { XX } },
7264 { "(bad)", { XX } },
7265 { "(bad)", { XX } },
7266 { "(bad)", { XX } },
7267 { "(bad)", { XX } },
7268 { "(bad)", { XX } },
7270 { "(bad)", { XX } },
7271 { "(bad)", { XX } },
7272 { "(bad)", { XX } },
7273 { "(bad)", { XX } },
7274 { "(bad)", { XX } },
7275 { "(bad)", { XX } },
7276 { "(bad)", { XX } },
7277 { "(bad)", { XX } },
7279 { "(bad)", { XX } },
7280 { "(bad)", { XX } },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7285 { "(bad)", { XX } },
7286 { "(bad)", { XX } },
7288 { "(bad)", { XX } },
7289 { "(bad)", { XX } },
7290 { "(bad)", { XX } },
7291 { "(bad)", { XX } },
7292 { "(bad)", { XX } },
7293 { "(bad)", { XX } },
7294 { "(bad)", { XX } },
7295 { "(bad)", { XX } },
7297 { "(bad)", { XX } },
7298 { "(bad)", { XX } },
7299 { "(bad)", { XX } },
7300 { "(bad)", { XX } },
7301 { "(bad)", { XX } },
7302 { "(bad)", { XX } },
7303 { "(bad)", { XX } },
7304 { "(bad)", { XX } },
7306 { "(bad)", { XX } },
7307 { "(bad)", { XX } },
7308 { "(bad)", { XX } },
7309 { "(bad)", { XX } },
7310 { "(bad)", { XX } },
7311 { "(bad)", { XX } },
7312 { "(bad)", { XX } },
7313 { "(bad)", { XX } },
7315 { "(bad)", { XX } },
7316 { "(bad)", { XX } },
7317 { "(bad)", { XX } },
7318 { "(bad)", { XX } },
7319 { "(bad)", { XX } },
7320 { "(bad)", { XX } },
7321 { "(bad)", { XX } },
7322 { "(bad)", { XX } },
7324 { "(bad)", { XX } },
7325 { "(bad)", { XX } },
7326 { "(bad)", { XX } },
7327 { "(bad)", { XX } },
7328 { "(bad)", { XX } },
7329 { "(bad)", { XX } },
7330 { "(bad)", { XX } },
7331 { "(bad)", { XX } },
7333 { "(bad)", { XX } },
7334 { "(bad)", { XX } },
7335 { "(bad)", { XX } },
7336 { "(bad)", { XX } },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7339 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7343 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7348 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7352 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7357 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7361 { "(bad)", { XX } },
7362 { "(bad)", { XX } },
7363 { "(bad)", { XX } },
7364 { "(bad)", { XX } },
7365 { "(bad)", { XX } },
7366 { "(bad)", { XX } },
7367 { "(bad)", { XX } },
7369 { "(bad)", { XX } },
7370 { "(bad)", { XX } },
7371 { "(bad)", { XX } },
7372 { "(bad)", { XX } },
7373 { "(bad)", { XX } },
7374 { "(bad)", { XX } },
7375 { "(bad)", { XX } },
7376 { "(bad)", { XX } },
7378 { "(bad)", { XX } },
7379 { "(bad)", { XX } },
7380 { "(bad)", { XX } },
7381 { "(bad)", { XX } },
7382 { "(bad)", { XX } },
7383 { "(bad)", { XX } },
7384 { "(bad)", { XX } },
7385 { "(bad)", { XX } },
7387 { "(bad)", { XX } },
7388 { "(bad)", { XX } },
7389 { "(bad)", { XX } },
7390 { "(bad)", { XX } },
7391 { "(bad)", { XX } },
7392 { "(bad)", { XX } },
7393 { "(bad)", { XX } },
7394 { "(bad)", { XX } },
7396 { "(bad)", { XX } },
7397 { "(bad)", { XX } },
7398 { "(bad)", { XX } },
7399 { "(bad)", { XX } },
7400 { "(bad)", { XX } },
7401 { "(bad)", { XX } },
7402 { "(bad)", { XX } },
7403 { "(bad)", { XX } },
7405 { "(bad)", { XX } },
7406 { "(bad)", { XX } },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7411 { "(bad)", { XX } },
7412 { "(bad)", { XX } },
7414 { "(bad)", { XX } },
7415 { "(bad)", { XX } },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7420 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7424 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7429 { "(bad)", { XX } },
7430 { "(bad)", { XX } },
7432 { "(bad)", { XX } },
7433 { "(bad)", { XX } },
7434 { "(bad)", { XX } },
7435 { "(bad)", { XX } },
7436 { "(bad)", { XX } },
7437 { "(bad)", { XX } },
7438 { "(bad)", { XX } },
7439 { "(bad)", { XX } },
7441 { "(bad)", { XX } },
7442 { "(bad)", { XX } },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7447 { "(bad)", { XX } },
7448 { "(bad)", { XX } },
7450 { "(bad)", { XX } },
7451 { "(bad)", { XX } },
7452 { "(bad)", { XX } },
7453 { "(bad)", { XX } },
7454 { "(bad)", { XX } },
7455 { "(bad)", { XX } },
7456 { "(bad)", { XX } },
7457 { "(bad)", { XX } },
7459 { "(bad)", { XX } },
7460 { "(bad)", { XX } },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7465 { "(bad)", { XX } },
7466 { "(bad)", { XX } },
7468 { "(bad)", { XX } },
7469 { "(bad)", { XX } },
7470 { "(bad)", { XX } },
7471 { "(bad)", { XX } },
7472 { "(bad)", { XX } },
7473 { "(bad)", { XX } },
7474 { "(bad)", { XX } },
7475 { "(bad)", { XX } },
7477 { "(bad)", { XX } },
7478 { "(bad)", { XX } },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7483 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7487 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { "(bad)", { XX } },
7491 { "(bad)", { XX } },
7492 { "(bad)", { XX } },
7493 { "(bad)", { XX } },
7495 { "(bad)", { XX } },
7496 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7501 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7505 { "(bad)", { XX } },
7506 { "(bad)", { XX } },
7507 { "(bad)", { XX } },
7508 { "(bad)", { XX } },
7509 { "(bad)", { XX } },
7510 { "(bad)", { XX } },
7511 { "(bad)", { XX } },
7513 { "(bad)", { XX } },
7514 { "(bad)", { XX } },
7515 { "(bad)", { XX } },
7516 { "(bad)", { XX } },
7517 { "(bad)", { XX } },
7518 { "(bad)", { XX } },
7519 { "(bad)", { XX } },
7520 { "(bad)", { XX } },
7524 static const struct dis386 vex_table[][256] = {
7528 { "(bad)", { XX } },
7529 { "(bad)", { XX } },
7530 { "(bad)", { XX } },
7531 { "(bad)", { XX } },
7532 { "(bad)", { XX } },
7533 { "(bad)", { XX } },
7534 { "(bad)", { XX } },
7535 { "(bad)", { XX } },
7537 { "(bad)", { XX } },
7538 { "(bad)", { XX } },
7539 { "(bad)", { XX } },
7540 { "(bad)", { XX } },
7541 { "(bad)", { XX } },
7542 { "(bad)", { XX } },
7543 { "(bad)", { XX } },
7544 { "(bad)", { XX } },
7546 { PREFIX_TABLE (PREFIX_VEX_10) },
7547 { PREFIX_TABLE (PREFIX_VEX_11) },
7548 { PREFIX_TABLE (PREFIX_VEX_12) },
7549 { MOD_TABLE (MOD_VEX_13) },
7550 { VEX_W_TABLE (VEX_W_14) },
7551 { VEX_W_TABLE (VEX_W_15) },
7552 { PREFIX_TABLE (PREFIX_VEX_16) },
7553 { MOD_TABLE (MOD_VEX_17) },
7555 { "(bad)", { XX } },
7556 { "(bad)", { XX } },
7557 { "(bad)", { XX } },
7558 { "(bad)", { XX } },
7559 { "(bad)", { XX } },
7560 { "(bad)", { XX } },
7561 { "(bad)", { XX } },
7562 { "(bad)", { XX } },
7564 { "(bad)", { XX } },
7565 { "(bad)", { XX } },
7566 { "(bad)", { XX } },
7567 { "(bad)", { XX } },
7568 { "(bad)", { XX } },
7569 { "(bad)", { XX } },
7570 { "(bad)", { XX } },
7571 { "(bad)", { XX } },
7573 { VEX_W_TABLE (VEX_W_28) },
7574 { VEX_W_TABLE (VEX_W_29) },
7575 { PREFIX_TABLE (PREFIX_VEX_2A) },
7576 { MOD_TABLE (MOD_VEX_2B) },
7577 { PREFIX_TABLE (PREFIX_VEX_2C) },
7578 { PREFIX_TABLE (PREFIX_VEX_2D) },
7579 { PREFIX_TABLE (PREFIX_VEX_2E) },
7580 { PREFIX_TABLE (PREFIX_VEX_2F) },
7582 { "(bad)", { XX } },
7583 { "(bad)", { XX } },
7584 { "(bad)", { XX } },
7585 { "(bad)", { XX } },
7586 { "(bad)", { XX } },
7587 { "(bad)", { XX } },
7588 { "(bad)", { XX } },
7589 { "(bad)", { XX } },
7591 { "(bad)", { XX } },
7592 { "(bad)", { XX } },
7593 { "(bad)", { XX } },
7594 { "(bad)", { XX } },
7595 { "(bad)", { XX } },
7596 { "(bad)", { XX } },
7597 { "(bad)", { XX } },
7598 { "(bad)", { XX } },
7600 { "(bad)", { XX } },
7601 { "(bad)", { XX } },
7602 { "(bad)", { XX } },
7603 { "(bad)", { XX } },
7604 { "(bad)", { XX } },
7605 { "(bad)", { XX } },
7606 { "(bad)", { XX } },
7607 { "(bad)", { XX } },
7609 { "(bad)", { XX } },
7610 { "(bad)", { XX } },
7611 { "(bad)", { XX } },
7612 { "(bad)", { XX } },
7613 { "(bad)", { XX } },
7614 { "(bad)", { XX } },
7615 { "(bad)", { XX } },
7616 { "(bad)", { XX } },
7618 { MOD_TABLE (MOD_VEX_50) },
7619 { PREFIX_TABLE (PREFIX_VEX_51) },
7620 { PREFIX_TABLE (PREFIX_VEX_52) },
7621 { PREFIX_TABLE (PREFIX_VEX_53) },
7622 { "vandpX", { XM, Vex, EXx } },
7623 { "vandnpX", { XM, Vex, EXx } },
7624 { "vorpX", { XM, Vex, EXx } },
7625 { "vxorpX", { XM, Vex, EXx } },
7627 { PREFIX_TABLE (PREFIX_VEX_58) },
7628 { PREFIX_TABLE (PREFIX_VEX_59) },
7629 { PREFIX_TABLE (PREFIX_VEX_5A) },
7630 { PREFIX_TABLE (PREFIX_VEX_5B) },
7631 { PREFIX_TABLE (PREFIX_VEX_5C) },
7632 { PREFIX_TABLE (PREFIX_VEX_5D) },
7633 { PREFIX_TABLE (PREFIX_VEX_5E) },
7634 { PREFIX_TABLE (PREFIX_VEX_5F) },
7636 { PREFIX_TABLE (PREFIX_VEX_60) },
7637 { PREFIX_TABLE (PREFIX_VEX_61) },
7638 { PREFIX_TABLE (PREFIX_VEX_62) },
7639 { PREFIX_TABLE (PREFIX_VEX_63) },
7640 { PREFIX_TABLE (PREFIX_VEX_64) },
7641 { PREFIX_TABLE (PREFIX_VEX_65) },
7642 { PREFIX_TABLE (PREFIX_VEX_66) },
7643 { PREFIX_TABLE (PREFIX_VEX_67) },
7645 { PREFIX_TABLE (PREFIX_VEX_68) },
7646 { PREFIX_TABLE (PREFIX_VEX_69) },
7647 { PREFIX_TABLE (PREFIX_VEX_6A) },
7648 { PREFIX_TABLE (PREFIX_VEX_6B) },
7649 { PREFIX_TABLE (PREFIX_VEX_6C) },
7650 { PREFIX_TABLE (PREFIX_VEX_6D) },
7651 { PREFIX_TABLE (PREFIX_VEX_6E) },
7652 { PREFIX_TABLE (PREFIX_VEX_6F) },
7654 { PREFIX_TABLE (PREFIX_VEX_70) },
7655 { REG_TABLE (REG_VEX_71) },
7656 { REG_TABLE (REG_VEX_72) },
7657 { REG_TABLE (REG_VEX_73) },
7658 { PREFIX_TABLE (PREFIX_VEX_74) },
7659 { PREFIX_TABLE (PREFIX_VEX_75) },
7660 { PREFIX_TABLE (PREFIX_VEX_76) },
7661 { PREFIX_TABLE (PREFIX_VEX_77) },
7663 { "(bad)", { XX } },
7664 { "(bad)", { XX } },
7665 { "(bad)", { XX } },
7666 { "(bad)", { XX } },
7667 { PREFIX_TABLE (PREFIX_VEX_7C) },
7668 { PREFIX_TABLE (PREFIX_VEX_7D) },
7669 { PREFIX_TABLE (PREFIX_VEX_7E) },
7670 { PREFIX_TABLE (PREFIX_VEX_7F) },
7672 { "(bad)", { XX } },
7673 { "(bad)", { XX } },
7674 { "(bad)", { XX } },
7675 { "(bad)", { XX } },
7676 { "(bad)", { XX } },
7677 { "(bad)", { XX } },
7678 { "(bad)", { XX } },
7679 { "(bad)", { XX } },
7681 { "(bad)", { XX } },
7682 { "(bad)", { XX } },
7683 { "(bad)", { XX } },
7684 { "(bad)", { XX } },
7685 { "(bad)", { XX } },
7686 { "(bad)", { XX } },
7687 { "(bad)", { XX } },
7688 { "(bad)", { XX } },
7690 { "(bad)", { XX } },
7691 { "(bad)", { XX } },
7692 { "(bad)", { XX } },
7693 { "(bad)", { XX } },
7694 { "(bad)", { XX } },
7695 { "(bad)", { XX } },
7696 { "(bad)", { XX } },
7697 { "(bad)", { XX } },
7699 { "(bad)", { XX } },
7700 { "(bad)", { XX } },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7704 { "(bad)", { XX } },
7705 { "(bad)", { XX } },
7706 { "(bad)", { XX } },
7708 { "(bad)", { XX } },
7709 { "(bad)", { XX } },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7713 { "(bad)", { XX } },
7714 { "(bad)", { XX } },
7715 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7718 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { "(bad)", { XX } },
7722 { "(bad)", { XX } },
7723 { REG_TABLE (REG_VEX_AE) },
7724 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7727 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7731 { "(bad)", { XX } },
7732 { "(bad)", { XX } },
7733 { "(bad)", { XX } },
7735 { "(bad)", { XX } },
7736 { "(bad)", { XX } },
7737 { "(bad)", { XX } },
7738 { "(bad)", { XX } },
7739 { "(bad)", { XX } },
7740 { "(bad)", { XX } },
7741 { "(bad)", { XX } },
7742 { "(bad)", { XX } },
7744 { "(bad)", { XX } },
7745 { "(bad)", { XX } },
7746 { PREFIX_TABLE (PREFIX_VEX_C2) },
7747 { "(bad)", { XX } },
7748 { PREFIX_TABLE (PREFIX_VEX_C4) },
7749 { PREFIX_TABLE (PREFIX_VEX_C5) },
7750 { "vshufpX", { XM, Vex, EXx, Ib } },
7751 { "(bad)", { XX } },
7753 { "(bad)", { XX } },
7754 { "(bad)", { XX } },
7755 { "(bad)", { XX } },
7756 { "(bad)", { XX } },
7757 { "(bad)", { XX } },
7758 { "(bad)", { XX } },
7759 { "(bad)", { XX } },
7760 { "(bad)", { XX } },
7762 { PREFIX_TABLE (PREFIX_VEX_D0) },
7763 { PREFIX_TABLE (PREFIX_VEX_D1) },
7764 { PREFIX_TABLE (PREFIX_VEX_D2) },
7765 { PREFIX_TABLE (PREFIX_VEX_D3) },
7766 { PREFIX_TABLE (PREFIX_VEX_D4) },
7767 { PREFIX_TABLE (PREFIX_VEX_D5) },
7768 { PREFIX_TABLE (PREFIX_VEX_D6) },
7769 { PREFIX_TABLE (PREFIX_VEX_D7) },
7771 { PREFIX_TABLE (PREFIX_VEX_D8) },
7772 { PREFIX_TABLE (PREFIX_VEX_D9) },
7773 { PREFIX_TABLE (PREFIX_VEX_DA) },
7774 { PREFIX_TABLE (PREFIX_VEX_DB) },
7775 { PREFIX_TABLE (PREFIX_VEX_DC) },
7776 { PREFIX_TABLE (PREFIX_VEX_DD) },
7777 { PREFIX_TABLE (PREFIX_VEX_DE) },
7778 { PREFIX_TABLE (PREFIX_VEX_DF) },
7780 { PREFIX_TABLE (PREFIX_VEX_E0) },
7781 { PREFIX_TABLE (PREFIX_VEX_E1) },
7782 { PREFIX_TABLE (PREFIX_VEX_E2) },
7783 { PREFIX_TABLE (PREFIX_VEX_E3) },
7784 { PREFIX_TABLE (PREFIX_VEX_E4) },
7785 { PREFIX_TABLE (PREFIX_VEX_E5) },
7786 { PREFIX_TABLE (PREFIX_VEX_E6) },
7787 { PREFIX_TABLE (PREFIX_VEX_E7) },
7789 { PREFIX_TABLE (PREFIX_VEX_E8) },
7790 { PREFIX_TABLE (PREFIX_VEX_E9) },
7791 { PREFIX_TABLE (PREFIX_VEX_EA) },
7792 { PREFIX_TABLE (PREFIX_VEX_EB) },
7793 { PREFIX_TABLE (PREFIX_VEX_EC) },
7794 { PREFIX_TABLE (PREFIX_VEX_ED) },
7795 { PREFIX_TABLE (PREFIX_VEX_EE) },
7796 { PREFIX_TABLE (PREFIX_VEX_EF) },
7798 { PREFIX_TABLE (PREFIX_VEX_F0) },
7799 { PREFIX_TABLE (PREFIX_VEX_F1) },
7800 { PREFIX_TABLE (PREFIX_VEX_F2) },
7801 { PREFIX_TABLE (PREFIX_VEX_F3) },
7802 { PREFIX_TABLE (PREFIX_VEX_F4) },
7803 { PREFIX_TABLE (PREFIX_VEX_F5) },
7804 { PREFIX_TABLE (PREFIX_VEX_F6) },
7805 { PREFIX_TABLE (PREFIX_VEX_F7) },
7807 { PREFIX_TABLE (PREFIX_VEX_F8) },
7808 { PREFIX_TABLE (PREFIX_VEX_F9) },
7809 { PREFIX_TABLE (PREFIX_VEX_FA) },
7810 { PREFIX_TABLE (PREFIX_VEX_FB) },
7811 { PREFIX_TABLE (PREFIX_VEX_FC) },
7812 { PREFIX_TABLE (PREFIX_VEX_FD) },
7813 { PREFIX_TABLE (PREFIX_VEX_FE) },
7814 { "(bad)", { XX } },
7819 { PREFIX_TABLE (PREFIX_VEX_3800) },
7820 { PREFIX_TABLE (PREFIX_VEX_3801) },
7821 { PREFIX_TABLE (PREFIX_VEX_3802) },
7822 { PREFIX_TABLE (PREFIX_VEX_3803) },
7823 { PREFIX_TABLE (PREFIX_VEX_3804) },
7824 { PREFIX_TABLE (PREFIX_VEX_3805) },
7825 { PREFIX_TABLE (PREFIX_VEX_3806) },
7826 { PREFIX_TABLE (PREFIX_VEX_3807) },
7828 { PREFIX_TABLE (PREFIX_VEX_3808) },
7829 { PREFIX_TABLE (PREFIX_VEX_3809) },
7830 { PREFIX_TABLE (PREFIX_VEX_380A) },
7831 { PREFIX_TABLE (PREFIX_VEX_380B) },
7832 { PREFIX_TABLE (PREFIX_VEX_380C) },
7833 { PREFIX_TABLE (PREFIX_VEX_380D) },
7834 { PREFIX_TABLE (PREFIX_VEX_380E) },
7835 { PREFIX_TABLE (PREFIX_VEX_380F) },
7837 { "(bad)", { XX } },
7838 { "(bad)", { XX } },
7839 { "(bad)", { XX } },
7840 { "(bad)", { XX } },
7841 { "(bad)", { XX } },
7842 { "(bad)", { XX } },
7843 { "(bad)", { XX } },
7844 { PREFIX_TABLE (PREFIX_VEX_3817) },
7846 { PREFIX_TABLE (PREFIX_VEX_3818) },
7847 { PREFIX_TABLE (PREFIX_VEX_3819) },
7848 { PREFIX_TABLE (PREFIX_VEX_381A) },
7849 { "(bad)", { XX } },
7850 { PREFIX_TABLE (PREFIX_VEX_381C) },
7851 { PREFIX_TABLE (PREFIX_VEX_381D) },
7852 { PREFIX_TABLE (PREFIX_VEX_381E) },
7853 { "(bad)", { XX } },
7855 { PREFIX_TABLE (PREFIX_VEX_3820) },
7856 { PREFIX_TABLE (PREFIX_VEX_3821) },
7857 { PREFIX_TABLE (PREFIX_VEX_3822) },
7858 { PREFIX_TABLE (PREFIX_VEX_3823) },
7859 { PREFIX_TABLE (PREFIX_VEX_3824) },
7860 { PREFIX_TABLE (PREFIX_VEX_3825) },
7861 { "(bad)", { XX } },
7862 { "(bad)", { XX } },
7864 { PREFIX_TABLE (PREFIX_VEX_3828) },
7865 { PREFIX_TABLE (PREFIX_VEX_3829) },
7866 { PREFIX_TABLE (PREFIX_VEX_382A) },
7867 { PREFIX_TABLE (PREFIX_VEX_382B) },
7868 { PREFIX_TABLE (PREFIX_VEX_382C) },
7869 { PREFIX_TABLE (PREFIX_VEX_382D) },
7870 { PREFIX_TABLE (PREFIX_VEX_382E) },
7871 { PREFIX_TABLE (PREFIX_VEX_382F) },
7873 { PREFIX_TABLE (PREFIX_VEX_3830) },
7874 { PREFIX_TABLE (PREFIX_VEX_3831) },
7875 { PREFIX_TABLE (PREFIX_VEX_3832) },
7876 { PREFIX_TABLE (PREFIX_VEX_3833) },
7877 { PREFIX_TABLE (PREFIX_VEX_3834) },
7878 { PREFIX_TABLE (PREFIX_VEX_3835) },
7879 { "(bad)", { XX } },
7880 { PREFIX_TABLE (PREFIX_VEX_3837) },
7882 { PREFIX_TABLE (PREFIX_VEX_3838) },
7883 { PREFIX_TABLE (PREFIX_VEX_3839) },
7884 { PREFIX_TABLE (PREFIX_VEX_383A) },
7885 { PREFIX_TABLE (PREFIX_VEX_383B) },
7886 { PREFIX_TABLE (PREFIX_VEX_383C) },
7887 { PREFIX_TABLE (PREFIX_VEX_383D) },
7888 { PREFIX_TABLE (PREFIX_VEX_383E) },
7889 { PREFIX_TABLE (PREFIX_VEX_383F) },
7891 { PREFIX_TABLE (PREFIX_VEX_3840) },
7892 { PREFIX_TABLE (PREFIX_VEX_3841) },
7893 { "(bad)", { XX } },
7894 { "(bad)", { XX } },
7895 { "(bad)", { XX } },
7896 { "(bad)", { XX } },
7897 { "(bad)", { XX } },
7898 { "(bad)", { XX } },
7900 { "(bad)", { XX } },
7901 { "(bad)", { XX } },
7902 { "(bad)", { XX } },
7903 { "(bad)", { XX } },
7904 { "(bad)", { XX } },
7905 { "(bad)", { XX } },
7906 { "(bad)", { XX } },
7907 { "(bad)", { XX } },
7909 { "(bad)", { XX } },
7910 { "(bad)", { XX } },
7911 { "(bad)", { XX } },
7912 { "(bad)", { XX } },
7913 { "(bad)", { XX } },
7914 { "(bad)", { XX } },
7915 { "(bad)", { XX } },
7916 { "(bad)", { XX } },
7918 { "(bad)", { XX } },
7919 { "(bad)", { XX } },
7920 { "(bad)", { XX } },
7921 { "(bad)", { XX } },
7922 { "(bad)", { XX } },
7923 { "(bad)", { XX } },
7924 { "(bad)", { XX } },
7925 { "(bad)", { XX } },
7927 { "(bad)", { XX } },
7928 { "(bad)", { XX } },
7929 { "(bad)", { XX } },
7930 { "(bad)", { XX } },
7931 { "(bad)", { XX } },
7932 { "(bad)", { XX } },
7933 { "(bad)", { XX } },
7934 { "(bad)", { XX } },
7936 { "(bad)", { XX } },
7937 { "(bad)", { XX } },
7938 { "(bad)", { XX } },
7939 { "(bad)", { XX } },
7940 { "(bad)", { XX } },
7941 { "(bad)", { XX } },
7942 { "(bad)", { XX } },
7943 { "(bad)", { XX } },
7945 { "(bad)", { XX } },
7946 { "(bad)", { XX } },
7947 { "(bad)", { XX } },
7948 { "(bad)", { XX } },
7949 { "(bad)", { XX } },
7950 { "(bad)", { XX } },
7951 { "(bad)", { XX } },
7952 { "(bad)", { XX } },
7954 { "(bad)", { XX } },
7955 { "(bad)", { XX } },
7956 { "(bad)", { XX } },
7957 { "(bad)", { XX } },
7958 { "(bad)", { XX } },
7959 { "(bad)", { XX } },
7960 { "(bad)", { XX } },
7961 { "(bad)", { XX } },
7963 { "(bad)", { XX } },
7964 { "(bad)", { XX } },
7965 { "(bad)", { XX } },
7966 { "(bad)", { XX } },
7967 { "(bad)", { XX } },
7968 { "(bad)", { XX } },
7969 { "(bad)", { XX } },
7970 { "(bad)", { XX } },
7972 { "(bad)", { XX } },
7973 { "(bad)", { XX } },
7974 { "(bad)", { XX } },
7975 { "(bad)", { XX } },
7976 { "(bad)", { XX } },
7977 { "(bad)", { XX } },
7978 { "(bad)", { XX } },
7979 { "(bad)", { XX } },
7981 { "(bad)", { XX } },
7982 { "(bad)", { XX } },
7983 { "(bad)", { XX } },
7984 { "(bad)", { XX } },
7985 { "(bad)", { XX } },
7986 { "(bad)", { XX } },
7987 { PREFIX_TABLE (PREFIX_VEX_3896) },
7988 { PREFIX_TABLE (PREFIX_VEX_3897) },
7990 { PREFIX_TABLE (PREFIX_VEX_3898) },
7991 { PREFIX_TABLE (PREFIX_VEX_3899) },
7992 { PREFIX_TABLE (PREFIX_VEX_389A) },
7993 { PREFIX_TABLE (PREFIX_VEX_389B) },
7994 { PREFIX_TABLE (PREFIX_VEX_389C) },
7995 { PREFIX_TABLE (PREFIX_VEX_389D) },
7996 { PREFIX_TABLE (PREFIX_VEX_389E) },
7997 { PREFIX_TABLE (PREFIX_VEX_389F) },
7999 { "(bad)", { XX } },
8000 { "(bad)", { XX } },
8001 { "(bad)", { XX } },
8002 { "(bad)", { XX } },
8003 { "(bad)", { XX } },
8004 { "(bad)", { XX } },
8005 { PREFIX_TABLE (PREFIX_VEX_38A6) },
8006 { PREFIX_TABLE (PREFIX_VEX_38A7) },
8008 { PREFIX_TABLE (PREFIX_VEX_38A8) },
8009 { PREFIX_TABLE (PREFIX_VEX_38A9) },
8010 { PREFIX_TABLE (PREFIX_VEX_38AA) },
8011 { PREFIX_TABLE (PREFIX_VEX_38AB) },
8012 { PREFIX_TABLE (PREFIX_VEX_38AC) },
8013 { PREFIX_TABLE (PREFIX_VEX_38AD) },
8014 { PREFIX_TABLE (PREFIX_VEX_38AE) },
8015 { PREFIX_TABLE (PREFIX_VEX_38AF) },
8017 { "(bad)", { XX } },
8018 { "(bad)", { XX } },
8019 { "(bad)", { XX } },
8020 { "(bad)", { XX } },
8021 { "(bad)", { XX } },
8022 { "(bad)", { XX } },
8023 { PREFIX_TABLE (PREFIX_VEX_38B6) },
8024 { PREFIX_TABLE (PREFIX_VEX_38B7) },
8026 { PREFIX_TABLE (PREFIX_VEX_38B8) },
8027 { PREFIX_TABLE (PREFIX_VEX_38B9) },
8028 { PREFIX_TABLE (PREFIX_VEX_38BA) },
8029 { PREFIX_TABLE (PREFIX_VEX_38BB) },
8030 { PREFIX_TABLE (PREFIX_VEX_38BC) },
8031 { PREFIX_TABLE (PREFIX_VEX_38BD) },
8032 { PREFIX_TABLE (PREFIX_VEX_38BE) },
8033 { PREFIX_TABLE (PREFIX_VEX_38BF) },
8035 { "(bad)", { XX } },
8036 { "(bad)", { XX } },
8037 { "(bad)", { XX } },
8038 { "(bad)", { XX } },
8039 { "(bad)", { XX } },
8040 { "(bad)", { XX } },
8041 { "(bad)", { XX } },
8042 { "(bad)", { XX } },
8044 { "(bad)", { XX } },
8045 { "(bad)", { XX } },
8046 { "(bad)", { XX } },
8047 { "(bad)", { XX } },
8048 { "(bad)", { XX } },
8049 { "(bad)", { XX } },
8050 { "(bad)", { XX } },
8051 { "(bad)", { XX } },
8053 { "(bad)", { XX } },
8054 { "(bad)", { XX } },
8055 { "(bad)", { XX } },
8056 { "(bad)", { XX } },
8057 { "(bad)", { XX } },
8058 { "(bad)", { XX } },
8059 { "(bad)", { XX } },
8060 { "(bad)", { XX } },
8062 { "(bad)", { XX } },
8063 { "(bad)", { XX } },
8064 { "(bad)", { XX } },
8065 { PREFIX_TABLE (PREFIX_VEX_38DB) },
8066 { PREFIX_TABLE (PREFIX_VEX_38DC) },
8067 { PREFIX_TABLE (PREFIX_VEX_38DD) },
8068 { PREFIX_TABLE (PREFIX_VEX_38DE) },
8069 { PREFIX_TABLE (PREFIX_VEX_38DF) },
8071 { "(bad)", { XX } },
8072 { "(bad)", { XX } },
8073 { "(bad)", { XX } },
8074 { "(bad)", { XX } },
8075 { "(bad)", { XX } },
8076 { "(bad)", { XX } },
8077 { "(bad)", { XX } },
8078 { "(bad)", { XX } },
8080 { "(bad)", { XX } },
8081 { "(bad)", { XX } },
8082 { "(bad)", { XX } },
8083 { "(bad)", { XX } },
8084 { "(bad)", { XX } },
8085 { "(bad)", { XX } },
8086 { "(bad)", { XX } },
8087 { "(bad)", { XX } },
8089 { "(bad)", { XX } },
8090 { "(bad)", { XX } },
8091 { "(bad)", { XX } },
8092 { "(bad)", { XX } },
8093 { "(bad)", { XX } },
8094 { "(bad)", { XX } },
8095 { "(bad)", { XX } },
8096 { "(bad)", { XX } },
8098 { "(bad)", { XX } },
8099 { "(bad)", { XX } },
8100 { "(bad)", { XX } },
8101 { "(bad)", { XX } },
8102 { "(bad)", { XX } },
8103 { "(bad)", { XX } },
8104 { "(bad)", { XX } },
8105 { "(bad)", { XX } },
8110 { "(bad)", { XX } },
8111 { "(bad)", { XX } },
8112 { "(bad)", { XX } },
8113 { "(bad)", { XX } },
8114 { PREFIX_TABLE (PREFIX_VEX_3A04) },
8115 { PREFIX_TABLE (PREFIX_VEX_3A05) },
8116 { PREFIX_TABLE (PREFIX_VEX_3A06) },
8117 { "(bad)", { XX } },
8119 { PREFIX_TABLE (PREFIX_VEX_3A08) },
8120 { PREFIX_TABLE (PREFIX_VEX_3A09) },
8121 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
8122 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
8123 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
8124 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
8125 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
8126 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
8128 { "(bad)", { XX } },
8129 { "(bad)", { XX } },
8130 { "(bad)", { XX } },
8131 { "(bad)", { XX } },
8132 { PREFIX_TABLE (PREFIX_VEX_3A14) },
8133 { PREFIX_TABLE (PREFIX_VEX_3A15) },
8134 { PREFIX_TABLE (PREFIX_VEX_3A16) },
8135 { PREFIX_TABLE (PREFIX_VEX_3A17) },
8137 { PREFIX_TABLE (PREFIX_VEX_3A18) },
8138 { PREFIX_TABLE (PREFIX_VEX_3A19) },
8139 { "(bad)", { XX } },
8140 { "(bad)", { XX } },
8141 { "(bad)", { XX } },
8142 { "(bad)", { XX } },
8143 { "(bad)", { XX } },
8144 { "(bad)", { XX } },
8146 { PREFIX_TABLE (PREFIX_VEX_3A20) },
8147 { PREFIX_TABLE (PREFIX_VEX_3A21) },
8148 { PREFIX_TABLE (PREFIX_VEX_3A22) },
8149 { "(bad)", { XX } },
8150 { "(bad)", { XX } },
8151 { "(bad)", { XX } },
8152 { "(bad)", { XX } },
8153 { "(bad)", { XX } },
8155 { "(bad)", { XX } },
8156 { "(bad)", { XX } },
8157 { "(bad)", { XX } },
8158 { "(bad)", { XX } },
8159 { "(bad)", { XX } },
8160 { "(bad)", { XX } },
8161 { "(bad)", { XX } },
8162 { "(bad)", { XX } },
8164 { "(bad)", { XX } },
8165 { "(bad)", { XX } },
8166 { "(bad)", { XX } },
8167 { "(bad)", { XX } },
8168 { "(bad)", { XX } },
8169 { "(bad)", { XX } },
8170 { "(bad)", { XX } },
8171 { "(bad)", { XX } },
8173 { "(bad)", { XX } },
8174 { "(bad)", { XX } },
8175 { "(bad)", { XX } },
8176 { "(bad)", { XX } },
8177 { "(bad)", { XX } },
8178 { "(bad)", { XX } },
8179 { "(bad)", { XX } },
8180 { "(bad)", { XX } },
8182 { PREFIX_TABLE (PREFIX_VEX_3A40) },
8183 { PREFIX_TABLE (PREFIX_VEX_3A41) },
8184 { PREFIX_TABLE (PREFIX_VEX_3A42) },
8185 { "(bad)", { XX } },
8186 { PREFIX_TABLE (PREFIX_VEX_3A44) },
8187 { "(bad)", { XX } },
8188 { "(bad)", { XX } },
8189 { "(bad)", { XX } },
8191 { "(bad)", { XX } },
8192 { "(bad)", { XX } },
8193 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
8194 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
8195 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
8196 { "(bad)", { XX } },
8197 { "(bad)", { XX } },
8198 { "(bad)", { XX } },
8200 { "(bad)", { XX } },
8201 { "(bad)", { XX } },
8202 { "(bad)", { XX } },
8203 { "(bad)", { XX } },
8204 { "(bad)", { XX } },
8205 { "(bad)", { XX } },
8206 { "(bad)", { XX } },
8207 { "(bad)", { XX } },
8209 { "(bad)", { XX } },
8210 { "(bad)", { XX } },
8211 { "(bad)", { XX } },
8212 { "(bad)", { XX } },
8213 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
8214 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
8215 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
8216 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
8218 { PREFIX_TABLE (PREFIX_VEX_3A60) },
8219 { PREFIX_TABLE (PREFIX_VEX_3A61) },
8220 { PREFIX_TABLE (PREFIX_VEX_3A62) },
8221 { PREFIX_TABLE (PREFIX_VEX_3A63) },
8222 { "(bad)", { XX } },
8223 { "(bad)", { XX } },
8224 { "(bad)", { XX } },
8225 { "(bad)", { XX } },
8227 { PREFIX_TABLE (PREFIX_VEX_3A68) },
8228 { PREFIX_TABLE (PREFIX_VEX_3A69) },
8229 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
8230 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
8231 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
8232 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
8233 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
8234 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
8236 { "(bad)", { XX } },
8237 { "(bad)", { XX } },
8238 { "(bad)", { XX } },
8239 { "(bad)", { XX } },
8240 { "(bad)", { XX } },
8241 { "(bad)", { XX } },
8242 { "(bad)", { XX } },
8243 { "(bad)", { XX } },
8245 { PREFIX_TABLE (PREFIX_VEX_3A78) },
8246 { PREFIX_TABLE (PREFIX_VEX_3A79) },
8247 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
8248 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
8249 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
8250 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
8251 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
8252 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
8254 { "(bad)", { XX } },
8255 { "(bad)", { XX } },
8256 { "(bad)", { XX } },
8257 { "(bad)", { XX } },
8258 { "(bad)", { XX } },
8259 { "(bad)", { XX } },
8260 { "(bad)", { XX } },
8261 { "(bad)", { XX } },
8263 { "(bad)", { XX } },
8264 { "(bad)", { XX } },
8265 { "(bad)", { XX } },
8266 { "(bad)", { XX } },
8267 { "(bad)", { XX } },
8268 { "(bad)", { XX } },
8269 { "(bad)", { XX } },
8270 { "(bad)", { XX } },
8272 { "(bad)", { XX } },
8273 { "(bad)", { XX } },
8274 { "(bad)", { XX } },
8275 { "(bad)", { XX } },
8276 { "(bad)", { XX } },
8277 { "(bad)", { XX } },
8278 { "(bad)", { XX } },
8279 { "(bad)", { XX } },
8281 { "(bad)", { XX } },
8282 { "(bad)", { XX } },
8283 { "(bad)", { XX } },
8284 { "(bad)", { XX } },
8285 { "(bad)", { XX } },
8286 { "(bad)", { XX } },
8287 { "(bad)", { XX } },
8288 { "(bad)", { XX } },
8290 { "(bad)", { XX } },
8291 { "(bad)", { XX } },
8292 { "(bad)", { XX } },
8293 { "(bad)", { XX } },
8294 { "(bad)", { XX } },
8295 { "(bad)", { XX } },
8296 { "(bad)", { XX } },
8297 { "(bad)", { XX } },
8299 { "(bad)", { XX } },
8300 { "(bad)", { XX } },
8301 { "(bad)", { XX } },
8302 { "(bad)", { XX } },
8303 { "(bad)", { XX } },
8304 { "(bad)", { XX } },
8305 { "(bad)", { XX } },
8306 { "(bad)", { XX } },
8308 { "(bad)", { XX } },
8309 { "(bad)", { XX } },
8310 { "(bad)", { XX } },
8311 { "(bad)", { XX } },
8312 { "(bad)", { XX } },
8313 { "(bad)", { XX } },
8314 { "(bad)", { XX } },
8315 { "(bad)", { XX } },
8317 { "(bad)", { XX } },
8318 { "(bad)", { XX } },
8319 { "(bad)", { XX } },
8320 { "(bad)", { XX } },
8321 { "(bad)", { XX } },
8322 { "(bad)", { XX } },
8323 { "(bad)", { XX } },
8324 { "(bad)", { XX } },
8326 { "(bad)", { XX } },
8327 { "(bad)", { XX } },
8328 { "(bad)", { XX } },
8329 { "(bad)", { XX } },
8330 { "(bad)", { XX } },
8331 { "(bad)", { XX } },
8332 { "(bad)", { XX } },
8333 { "(bad)", { XX } },
8335 { "(bad)", { XX } },
8336 { "(bad)", { XX } },
8337 { "(bad)", { XX } },
8338 { "(bad)", { XX } },
8339 { "(bad)", { XX } },
8340 { "(bad)", { XX } },
8341 { "(bad)", { XX } },
8342 { "(bad)", { XX } },
8344 { "(bad)", { XX } },
8345 { "(bad)", { XX } },
8346 { "(bad)", { XX } },
8347 { "(bad)", { XX } },
8348 { "(bad)", { XX } },
8349 { "(bad)", { XX } },
8350 { "(bad)", { XX } },
8351 { "(bad)", { XX } },
8353 { "(bad)", { XX } },
8354 { "(bad)", { XX } },
8355 { "(bad)", { XX } },
8356 { "(bad)", { XX } },
8357 { "(bad)", { XX } },
8358 { "(bad)", { XX } },
8359 { "(bad)", { XX } },
8360 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
8362 { "(bad)", { XX } },
8363 { "(bad)", { XX } },
8364 { "(bad)", { XX } },
8365 { "(bad)", { XX } },
8366 { "(bad)", { XX } },
8367 { "(bad)", { XX } },
8368 { "(bad)", { XX } },
8369 { "(bad)", { XX } },
8371 { "(bad)", { XX } },
8372 { "(bad)", { XX } },
8373 { "(bad)", { XX } },
8374 { "(bad)", { XX } },
8375 { "(bad)", { XX } },
8376 { "(bad)", { XX } },
8377 { "(bad)", { XX } },
8378 { "(bad)", { XX } },
8380 { "(bad)", { XX } },
8381 { "(bad)", { XX } },
8382 { "(bad)", { XX } },
8383 { "(bad)", { XX } },
8384 { "(bad)", { XX } },
8385 { "(bad)", { XX } },
8386 { "(bad)", { XX } },
8387 { "(bad)", { XX } },
8389 { "(bad)", { XX } },
8390 { "(bad)", { XX } },
8391 { "(bad)", { XX } },
8392 { "(bad)", { XX } },
8393 { "(bad)", { XX } },
8394 { "(bad)", { XX } },
8395 { "(bad)", { XX } },
8396 { "(bad)", { XX } },
8400 static const struct dis386 vex_len_table[][2] = {
8401 /* VEX_LEN_10_P_1 */
8403 { VEX_W_TABLE (VEX_W_10_P_1) },
8404 { "(bad)", { XX } },
8407 /* VEX_LEN_10_P_3 */
8409 { VEX_W_TABLE (VEX_W_10_P_3) },
8410 { "(bad)", { XX } },
8413 /* VEX_LEN_11_P_1 */
8415 { VEX_W_TABLE (VEX_W_11_P_1) },
8416 { "(bad)", { XX } },
8419 /* VEX_LEN_11_P_3 */
8421 { VEX_W_TABLE (VEX_W_11_P_3) },
8422 { "(bad)", { XX } },
8425 /* VEX_LEN_12_P_0_M_0 */
8427 { VEX_W_TABLE (VEX_W_12_P_0_M_0) },
8428 { "(bad)", { XX } },
8431 /* VEX_LEN_12_P_0_M_1 */
8433 { VEX_W_TABLE (VEX_W_12_P_0_M_1) },
8434 { "(bad)", { XX } },
8437 /* VEX_LEN_12_P_2 */
8439 { VEX_W_TABLE (VEX_W_12_P_2) },
8440 { "(bad)", { XX } },
8443 /* VEX_LEN_13_M_0 */
8445 { VEX_W_TABLE (VEX_W_13_M_0) },
8446 { "(bad)", { XX } },
8449 /* VEX_LEN_16_P_0_M_0 */
8451 { VEX_W_TABLE (VEX_W_16_P_0_M_0) },
8452 { "(bad)", { XX } },
8455 /* VEX_LEN_16_P_0_M_1 */
8457 { VEX_W_TABLE (VEX_W_16_P_0_M_1) },
8458 { "(bad)", { XX } },
8461 /* VEX_LEN_16_P_2 */
8463 { VEX_W_TABLE (VEX_W_16_P_2) },
8464 { "(bad)", { XX } },
8467 /* VEX_LEN_17_M_0 */
8469 { VEX_W_TABLE (VEX_W_17_M_0) },
8470 { "(bad)", { XX } },
8473 /* VEX_LEN_2A_P_1 */
8475 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
8476 { "(bad)", { XX } },
8479 /* VEX_LEN_2A_P_3 */
8481 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
8482 { "(bad)", { XX } },
8485 /* VEX_LEN_2C_P_1 */
8487 { "vcvttss2siY", { Gv, EXd } },
8488 { "(bad)", { XX } },
8491 /* VEX_LEN_2C_P_3 */
8493 { "vcvttsd2siY", { Gv, EXq } },
8494 { "(bad)", { XX } },
8497 /* VEX_LEN_2D_P_1 */
8499 { "vcvtss2siY", { Gv, EXd } },
8500 { "(bad)", { XX } },
8503 /* VEX_LEN_2D_P_3 */
8505 { "vcvtsd2siY", { Gv, EXq } },
8506 { "(bad)", { XX } },
8509 /* VEX_LEN_2E_P_0 */
8511 { VEX_W_TABLE (VEX_W_2E_P_0) },
8512 { "(bad)", { XX } },
8515 /* VEX_LEN_2E_P_2 */
8517 { VEX_W_TABLE (VEX_W_2E_P_2) },
8518 { "(bad)", { XX } },
8521 /* VEX_LEN_2F_P_0 */
8523 { VEX_W_TABLE (VEX_W_2F_P_0) },
8524 { "(bad)", { XX } },
8527 /* VEX_LEN_2F_P_2 */
8529 { VEX_W_TABLE (VEX_W_2F_P_2) },
8530 { "(bad)", { XX } },
8533 /* VEX_LEN_51_P_1 */
8535 { VEX_W_TABLE (VEX_W_51_P_1) },
8536 { "(bad)", { XX } },
8539 /* VEX_LEN_51_P_3 */
8541 { VEX_W_TABLE (VEX_W_51_P_3) },
8542 { "(bad)", { XX } },
8545 /* VEX_LEN_52_P_1 */
8547 { VEX_W_TABLE (VEX_W_52_P_1) },
8548 { "(bad)", { XX } },
8551 /* VEX_LEN_53_P_1 */
8553 { VEX_W_TABLE (VEX_W_53_P_1) },
8554 { "(bad)", { XX } },
8557 /* VEX_LEN_58_P_1 */
8559 { VEX_W_TABLE (VEX_W_58_P_1) },
8560 { "(bad)", { XX } },
8563 /* VEX_LEN_58_P_3 */
8565 { VEX_W_TABLE (VEX_W_58_P_3) },
8566 { "(bad)", { XX } },
8569 /* VEX_LEN_59_P_1 */
8571 { VEX_W_TABLE (VEX_W_59_P_1) },
8572 { "(bad)", { XX } },
8575 /* VEX_LEN_59_P_3 */
8577 { VEX_W_TABLE (VEX_W_59_P_3) },
8578 { "(bad)", { XX } },
8581 /* VEX_LEN_5A_P_1 */
8583 { VEX_W_TABLE (VEX_W_5A_P_1) },
8584 { "(bad)", { XX } },
8587 /* VEX_LEN_5A_P_3 */
8589 { VEX_W_TABLE (VEX_W_5A_P_3) },
8590 { "(bad)", { XX } },
8593 /* VEX_LEN_5C_P_1 */
8595 { VEX_W_TABLE (VEX_W_5C_P_1) },
8596 { "(bad)", { XX } },
8599 /* VEX_LEN_5C_P_3 */
8601 { VEX_W_TABLE (VEX_W_5C_P_3) },
8602 { "(bad)", { XX } },
8605 /* VEX_LEN_5D_P_1 */
8607 { VEX_W_TABLE (VEX_W_5D_P_1) },
8608 { "(bad)", { XX } },
8611 /* VEX_LEN_5D_P_3 */
8613 { VEX_W_TABLE (VEX_W_5D_P_3) },
8614 { "(bad)", { XX } },
8617 /* VEX_LEN_5E_P_1 */
8619 { VEX_W_TABLE (VEX_W_5E_P_1) },
8620 { "(bad)", { XX } },
8623 /* VEX_LEN_5E_P_3 */
8625 { VEX_W_TABLE (VEX_W_5E_P_3) },
8626 { "(bad)", { XX } },
8629 /* VEX_LEN_5F_P_1 */
8631 { VEX_W_TABLE (VEX_W_5F_P_1) },
8632 { "(bad)", { XX } },
8635 /* VEX_LEN_5F_P_3 */
8637 { VEX_W_TABLE (VEX_W_5F_P_3) },
8638 { "(bad)", { XX } },
8641 /* VEX_LEN_60_P_2 */
8643 { VEX_W_TABLE (VEX_W_60_P_2) },
8644 { "(bad)", { XX } },
8647 /* VEX_LEN_61_P_2 */
8649 { VEX_W_TABLE (VEX_W_61_P_2) },
8650 { "(bad)", { XX } },
8653 /* VEX_LEN_62_P_2 */
8655 { VEX_W_TABLE (VEX_W_62_P_2) },
8656 { "(bad)", { XX } },
8659 /* VEX_LEN_63_P_2 */
8661 { VEX_W_TABLE (VEX_W_63_P_2) },
8662 { "(bad)", { XX } },
8665 /* VEX_LEN_64_P_2 */
8667 { VEX_W_TABLE (VEX_W_64_P_2) },
8668 { "(bad)", { XX } },
8671 /* VEX_LEN_65_P_2 */
8673 { VEX_W_TABLE (VEX_W_65_P_2) },
8674 { "(bad)", { XX } },
8677 /* VEX_LEN_66_P_2 */
8679 { VEX_W_TABLE (VEX_W_66_P_2) },
8680 { "(bad)", { XX } },
8683 /* VEX_LEN_67_P_2 */
8685 { VEX_W_TABLE (VEX_W_67_P_2) },
8686 { "(bad)", { XX } },
8689 /* VEX_LEN_68_P_2 */
8691 { VEX_W_TABLE (VEX_W_68_P_2) },
8692 { "(bad)", { XX } },
8695 /* VEX_LEN_69_P_2 */
8697 { VEX_W_TABLE (VEX_W_69_P_2) },
8698 { "(bad)", { XX } },
8701 /* VEX_LEN_6A_P_2 */
8703 { VEX_W_TABLE (VEX_W_6A_P_2) },
8704 { "(bad)", { XX } },
8707 /* VEX_LEN_6B_P_2 */
8709 { VEX_W_TABLE (VEX_W_6B_P_2) },
8710 { "(bad)", { XX } },
8713 /* VEX_LEN_6C_P_2 */
8715 { VEX_W_TABLE (VEX_W_6C_P_2) },
8716 { "(bad)", { XX } },
8719 /* VEX_LEN_6D_P_2 */
8721 { VEX_W_TABLE (VEX_W_6D_P_2) },
8722 { "(bad)", { XX } },
8725 /* VEX_LEN_6E_P_2 */
8727 { "vmovK", { XM, Edq } },
8728 { "(bad)", { XX } },
8731 /* VEX_LEN_70_P_1 */
8733 { VEX_W_TABLE (VEX_W_70_P_1) },
8734 { "(bad)", { XX } },
8737 /* VEX_LEN_70_P_2 */
8739 { VEX_W_TABLE (VEX_W_70_P_2) },
8740 { "(bad)", { XX } },
8743 /* VEX_LEN_70_P_3 */
8745 { VEX_W_TABLE (VEX_W_70_P_3) },
8746 { "(bad)", { XX } },
8749 /* VEX_LEN_71_R_2_P_2 */
8751 { VEX_W_TABLE (VEX_W_71_R_2_P_2) },
8752 { "(bad)", { XX } },
8755 /* VEX_LEN_71_R_4_P_2 */
8757 { VEX_W_TABLE (VEX_W_71_R_4_P_2) },
8758 { "(bad)", { XX } },
8761 /* VEX_LEN_71_R_6_P_2 */
8763 { VEX_W_TABLE (VEX_W_71_R_6_P_2) },
8764 { "(bad)", { XX } },
8767 /* VEX_LEN_72_R_2_P_2 */
8769 { VEX_W_TABLE (VEX_W_72_R_2_P_2) },
8770 { "(bad)", { XX } },
8773 /* VEX_LEN_72_R_4_P_2 */
8775 { VEX_W_TABLE (VEX_W_72_R_4_P_2) },
8776 { "(bad)", { XX } },
8779 /* VEX_LEN_72_R_6_P_2 */
8781 { VEX_W_TABLE (VEX_W_72_R_6_P_2) },
8782 { "(bad)", { XX } },
8785 /* VEX_LEN_73_R_2_P_2 */
8787 { VEX_W_TABLE (VEX_W_73_R_2_P_2) },
8788 { "(bad)", { XX } },
8791 /* VEX_LEN_73_R_3_P_2 */
8793 { VEX_W_TABLE (VEX_W_73_R_3_P_2) },
8794 { "(bad)", { XX } },
8797 /* VEX_LEN_73_R_6_P_2 */
8799 { VEX_W_TABLE (VEX_W_73_R_6_P_2) },
8800 { "(bad)", { XX } },
8803 /* VEX_LEN_73_R_7_P_2 */
8805 { VEX_W_TABLE (VEX_W_73_R_7_P_2) },
8806 { "(bad)", { XX } },
8809 /* VEX_LEN_74_P_2 */
8811 { VEX_W_TABLE (VEX_W_74_P_2) },
8812 { "(bad)", { XX } },
8815 /* VEX_LEN_75_P_2 */
8817 { VEX_W_TABLE (VEX_W_75_P_2) },
8818 { "(bad)", { XX } },
8821 /* VEX_LEN_76_P_2 */
8823 { VEX_W_TABLE (VEX_W_76_P_2) },
8824 { "(bad)", { XX } },
8827 /* VEX_LEN_7E_P_1 */
8829 { VEX_W_TABLE (VEX_W_7E_P_1) },
8830 { "(bad)", { XX } },
8833 /* VEX_LEN_7E_P_2 */
8835 { "vmovK", { Edq, XM } },
8836 { "(bad)", { XX } },
8839 /* VEX_LEN_AE_R_2_M_0 */
8841 { VEX_W_TABLE (VEX_W_AE_R_2_M_0) },
8842 { "(bad)", { XX } },
8845 /* VEX_LEN_AE_R_3_M_0 */
8847 { VEX_W_TABLE (VEX_W_AE_R_3_M_0) },
8848 { "(bad)", { XX } },
8851 /* VEX_LEN_C2_P_1 */
8853 { VEX_W_TABLE (VEX_W_C2_P_1) },
8854 { "(bad)", { XX } },
8857 /* VEX_LEN_C2_P_3 */
8859 { VEX_W_TABLE (VEX_W_C2_P_3) },
8860 { "(bad)", { XX } },
8863 /* VEX_LEN_C4_P_2 */
8865 { VEX_W_TABLE (VEX_W_C4_P_2) },
8866 { "(bad)", { XX } },
8869 /* VEX_LEN_C5_P_2 */
8871 { VEX_W_TABLE (VEX_W_C5_P_2) },
8872 { "(bad)", { XX } },
8875 /* VEX_LEN_D1_P_2 */
8877 { VEX_W_TABLE (VEX_W_D1_P_2) },
8878 { "(bad)", { XX } },
8881 /* VEX_LEN_D2_P_2 */
8883 { VEX_W_TABLE (VEX_W_D2_P_2) },
8884 { "(bad)", { XX } },
8887 /* VEX_LEN_D3_P_2 */
8889 { VEX_W_TABLE (VEX_W_D3_P_2) },
8890 { "(bad)", { XX } },
8893 /* VEX_LEN_D4_P_2 */
8895 { VEX_W_TABLE (VEX_W_D4_P_2) },
8896 { "(bad)", { XX } },
8899 /* VEX_LEN_D5_P_2 */
8901 { VEX_W_TABLE (VEX_W_D5_P_2) },
8902 { "(bad)", { XX } },
8905 /* VEX_LEN_D6_P_2 */
8907 { VEX_W_TABLE (VEX_W_D6_P_2) },
8908 { "(bad)", { XX } },
8911 /* VEX_LEN_D7_P_2_M_1 */
8913 { VEX_W_TABLE (VEX_W_D7_P_2_M_1) },
8914 { "(bad)", { XX } },
8917 /* VEX_LEN_D8_P_2 */
8919 { VEX_W_TABLE (VEX_W_D8_P_2) },
8920 { "(bad)", { XX } },
8923 /* VEX_LEN_D9_P_2 */
8925 { VEX_W_TABLE (VEX_W_D9_P_2) },
8926 { "(bad)", { XX } },
8929 /* VEX_LEN_DA_P_2 */
8931 { VEX_W_TABLE (VEX_W_DA_P_2) },
8932 { "(bad)", { XX } },
8935 /* VEX_LEN_DB_P_2 */
8937 { VEX_W_TABLE (VEX_W_DB_P_2) },
8938 { "(bad)", { XX } },
8941 /* VEX_LEN_DC_P_2 */
8943 { VEX_W_TABLE (VEX_W_DC_P_2) },
8944 { "(bad)", { XX } },
8947 /* VEX_LEN_DD_P_2 */
8949 { VEX_W_TABLE (VEX_W_DD_P_2) },
8950 { "(bad)", { XX } },
8953 /* VEX_LEN_DE_P_2 */
8955 { VEX_W_TABLE (VEX_W_DE_P_2) },
8956 { "(bad)", { XX } },
8959 /* VEX_LEN_DF_P_2 */
8961 { VEX_W_TABLE (VEX_W_DF_P_2) },
8962 { "(bad)", { XX } },
8965 /* VEX_LEN_E0_P_2 */
8967 { VEX_W_TABLE (VEX_W_E0_P_2) },
8968 { "(bad)", { XX } },
8971 /* VEX_LEN_E1_P_2 */
8973 { VEX_W_TABLE (VEX_W_E1_P_2) },
8974 { "(bad)", { XX } },
8977 /* VEX_LEN_E2_P_2 */
8979 { VEX_W_TABLE (VEX_W_E2_P_2) },
8980 { "(bad)", { XX } },
8983 /* VEX_LEN_E3_P_2 */
8985 { VEX_W_TABLE (VEX_W_E3_P_2) },
8986 { "(bad)", { XX } },
8989 /* VEX_LEN_E4_P_2 */
8991 { VEX_W_TABLE (VEX_W_E4_P_2) },
8992 { "(bad)", { XX } },
8995 /* VEX_LEN_E5_P_2 */
8997 { VEX_W_TABLE (VEX_W_E5_P_2) },
8998 { "(bad)", { XX } },
9001 /* VEX_LEN_E8_P_2 */
9003 { VEX_W_TABLE (VEX_W_E8_P_2) },
9004 { "(bad)", { XX } },
9007 /* VEX_LEN_E9_P_2 */
9009 { VEX_W_TABLE (VEX_W_E9_P_2) },
9010 { "(bad)", { XX } },
9013 /* VEX_LEN_EA_P_2 */
9015 { VEX_W_TABLE (VEX_W_EA_P_2) },
9016 { "(bad)", { XX } },
9019 /* VEX_LEN_EB_P_2 */
9021 { VEX_W_TABLE (VEX_W_EB_P_2) },
9022 { "(bad)", { XX } },
9025 /* VEX_LEN_EC_P_2 */
9027 { VEX_W_TABLE (VEX_W_EC_P_2) },
9028 { "(bad)", { XX } },
9031 /* VEX_LEN_ED_P_2 */
9033 { VEX_W_TABLE (VEX_W_ED_P_2) },
9034 { "(bad)", { XX } },
9037 /* VEX_LEN_EE_P_2 */
9039 { VEX_W_TABLE (VEX_W_EE_P_2) },
9040 { "(bad)", { XX } },
9043 /* VEX_LEN_EF_P_2 */
9045 { VEX_W_TABLE (VEX_W_EF_P_2) },
9046 { "(bad)", { XX } },
9049 /* VEX_LEN_F1_P_2 */
9051 { VEX_W_TABLE (VEX_W_F1_P_2) },
9052 { "(bad)", { XX } },
9055 /* VEX_LEN_F2_P_2 */
9057 { VEX_W_TABLE (VEX_W_F2_P_2) },
9058 { "(bad)", { XX } },
9061 /* VEX_LEN_F3_P_2 */
9063 { VEX_W_TABLE (VEX_W_F3_P_2) },
9064 { "(bad)", { XX } },
9067 /* VEX_LEN_F4_P_2 */
9069 { VEX_W_TABLE (VEX_W_F4_P_2) },
9070 { "(bad)", { XX } },
9073 /* VEX_LEN_F5_P_2 */
9075 { VEX_W_TABLE (VEX_W_F5_P_2) },
9076 { "(bad)", { XX } },
9079 /* VEX_LEN_F6_P_2 */
9081 { VEX_W_TABLE (VEX_W_F6_P_2) },
9082 { "(bad)", { XX } },
9085 /* VEX_LEN_F7_P_2 */
9087 { VEX_W_TABLE (VEX_W_F7_P_2) },
9088 { "(bad)", { XX } },
9091 /* VEX_LEN_F8_P_2 */
9093 { VEX_W_TABLE (VEX_W_F8_P_2) },
9094 { "(bad)", { XX } },
9097 /* VEX_LEN_F9_P_2 */
9099 { VEX_W_TABLE (VEX_W_F9_P_2) },
9100 { "(bad)", { XX } },
9103 /* VEX_LEN_FA_P_2 */
9105 { VEX_W_TABLE (VEX_W_FA_P_2) },
9106 { "(bad)", { XX } },
9109 /* VEX_LEN_FB_P_2 */
9111 { VEX_W_TABLE (VEX_W_FB_P_2) },
9112 { "(bad)", { XX } },
9115 /* VEX_LEN_FC_P_2 */
9117 { VEX_W_TABLE (VEX_W_FC_P_2) },
9118 { "(bad)", { XX } },
9121 /* VEX_LEN_FD_P_2 */
9123 { VEX_W_TABLE (VEX_W_FD_P_2) },
9124 { "(bad)", { XX } },
9127 /* VEX_LEN_FE_P_2 */
9129 { VEX_W_TABLE (VEX_W_FE_P_2) },
9130 { "(bad)", { XX } },
9133 /* VEX_LEN_3800_P_2 */
9135 { VEX_W_TABLE (VEX_W_3800_P_2) },
9136 { "(bad)", { XX } },
9139 /* VEX_LEN_3801_P_2 */
9141 { VEX_W_TABLE (VEX_W_3801_P_2) },
9142 { "(bad)", { XX } },
9145 /* VEX_LEN_3802_P_2 */
9147 { VEX_W_TABLE (VEX_W_3802_P_2) },
9148 { "(bad)", { XX } },
9151 /* VEX_LEN_3803_P_2 */
9153 { VEX_W_TABLE (VEX_W_3803_P_2) },
9154 { "(bad)", { XX } },
9157 /* VEX_LEN_3804_P_2 */
9159 { VEX_W_TABLE (VEX_W_3804_P_2) },
9160 { "(bad)", { XX } },
9163 /* VEX_LEN_3805_P_2 */
9165 { VEX_W_TABLE (VEX_W_3805_P_2) },
9166 { "(bad)", { XX } },
9169 /* VEX_LEN_3806_P_2 */
9171 { VEX_W_TABLE (VEX_W_3806_P_2) },
9172 { "(bad)", { XX } },
9175 /* VEX_LEN_3807_P_2 */
9177 { VEX_W_TABLE (VEX_W_3807_P_2) },
9178 { "(bad)", { XX } },
9181 /* VEX_LEN_3808_P_2 */
9183 { VEX_W_TABLE (VEX_W_3808_P_2) },
9184 { "(bad)", { XX } },
9187 /* VEX_LEN_3809_P_2 */
9189 { VEX_W_TABLE (VEX_W_3809_P_2) },
9190 { "(bad)", { XX } },
9193 /* VEX_LEN_380A_P_2 */
9195 { VEX_W_TABLE (VEX_W_380A_P_2) },
9196 { "(bad)", { XX } },
9199 /* VEX_LEN_380B_P_2 */
9201 { VEX_W_TABLE (VEX_W_380B_P_2) },
9202 { "(bad)", { XX } },
9205 /* VEX_LEN_3819_P_2_M_0 */
9207 { "(bad)", { XX } },
9208 { VEX_W_TABLE (VEX_W_3819_P_2_M_0) },
9211 /* VEX_LEN_381A_P_2_M_0 */
9213 { "(bad)", { XX } },
9214 { VEX_W_TABLE (VEX_W_381A_P_2_M_0) },
9217 /* VEX_LEN_381C_P_2 */
9219 { VEX_W_TABLE (VEX_W_381C_P_2) },
9220 { "(bad)", { XX } },
9223 /* VEX_LEN_381D_P_2 */
9225 { VEX_W_TABLE (VEX_W_381D_P_2) },
9226 { "(bad)", { XX } },
9229 /* VEX_LEN_381E_P_2 */
9231 { VEX_W_TABLE (VEX_W_381E_P_2) },
9232 { "(bad)", { XX } },
9235 /* VEX_LEN_3820_P_2 */
9237 { VEX_W_TABLE (VEX_W_3820_P_2) },
9238 { "(bad)", { XX } },
9241 /* VEX_LEN_3821_P_2 */
9243 { VEX_W_TABLE (VEX_W_3821_P_2) },
9244 { "(bad)", { XX } },
9247 /* VEX_LEN_3822_P_2 */
9249 { VEX_W_TABLE (VEX_W_3822_P_2) },
9250 { "(bad)", { XX } },
9253 /* VEX_LEN_3823_P_2 */
9255 { VEX_W_TABLE (VEX_W_3823_P_2) },
9256 { "(bad)", { XX } },
9259 /* VEX_LEN_3824_P_2 */
9261 { VEX_W_TABLE (VEX_W_3824_P_2) },
9262 { "(bad)", { XX } },
9265 /* VEX_LEN_3825_P_2 */
9267 { VEX_W_TABLE (VEX_W_3825_P_2) },
9268 { "(bad)", { XX } },
9271 /* VEX_LEN_3828_P_2 */
9273 { VEX_W_TABLE (VEX_W_3828_P_2) },
9274 { "(bad)", { XX } },
9277 /* VEX_LEN_3829_P_2 */
9279 { VEX_W_TABLE (VEX_W_3829_P_2) },
9280 { "(bad)", { XX } },
9283 /* VEX_LEN_382A_P_2_M_0 */
9285 { VEX_W_TABLE (VEX_W_382A_P_2_M_0) },
9286 { "(bad)", { XX } },
9289 /* VEX_LEN_382B_P_2 */
9291 { VEX_W_TABLE (VEX_W_382B_P_2) },
9292 { "(bad)", { XX } },
9295 /* VEX_LEN_3830_P_2 */
9297 { VEX_W_TABLE (VEX_W_3830_P_2) },
9298 { "(bad)", { XX } },
9301 /* VEX_LEN_3831_P_2 */
9303 { VEX_W_TABLE (VEX_W_3831_P_2) },
9304 { "(bad)", { XX } },
9307 /* VEX_LEN_3832_P_2 */
9309 { VEX_W_TABLE (VEX_W_3832_P_2) },
9310 { "(bad)", { XX } },
9313 /* VEX_LEN_3833_P_2 */
9315 { VEX_W_TABLE (VEX_W_3833_P_2) },
9316 { "(bad)", { XX } },
9319 /* VEX_LEN_3834_P_2 */
9321 { VEX_W_TABLE (VEX_W_3834_P_2) },
9322 { "(bad)", { XX } },
9325 /* VEX_LEN_3835_P_2 */
9327 { VEX_W_TABLE (VEX_W_3835_P_2) },
9328 { "(bad)", { XX } },
9331 /* VEX_LEN_3837_P_2 */
9333 { VEX_W_TABLE (VEX_W_3837_P_2) },
9334 { "(bad)", { XX } },
9337 /* VEX_LEN_3838_P_2 */
9339 { VEX_W_TABLE (VEX_W_3838_P_2) },
9340 { "(bad)", { XX } },
9343 /* VEX_LEN_3839_P_2 */
9345 { VEX_W_TABLE (VEX_W_3839_P_2) },
9346 { "(bad)", { XX } },
9349 /* VEX_LEN_383A_P_2 */
9351 { VEX_W_TABLE (VEX_W_383A_P_2) },
9352 { "(bad)", { XX } },
9355 /* VEX_LEN_383B_P_2 */
9357 { VEX_W_TABLE (VEX_W_383B_P_2) },
9358 { "(bad)", { XX } },
9361 /* VEX_LEN_383C_P_2 */
9363 { VEX_W_TABLE (VEX_W_383C_P_2) },
9364 { "(bad)", { XX } },
9367 /* VEX_LEN_383D_P_2 */
9369 { VEX_W_TABLE (VEX_W_383D_P_2) },
9370 { "(bad)", { XX } },
9373 /* VEX_LEN_383E_P_2 */
9375 { VEX_W_TABLE (VEX_W_383E_P_2) },
9376 { "(bad)", { XX } },
9379 /* VEX_LEN_383F_P_2 */
9381 { VEX_W_TABLE (VEX_W_383F_P_2) },
9382 { "(bad)", { XX } },
9385 /* VEX_LEN_3840_P_2 */
9387 { VEX_W_TABLE (VEX_W_3840_P_2) },
9388 { "(bad)", { XX } },
9391 /* VEX_LEN_3841_P_2 */
9393 { VEX_W_TABLE (VEX_W_3841_P_2) },
9394 { "(bad)", { XX } },
9397 /* VEX_LEN_38DB_P_2 */
9399 { VEX_W_TABLE (VEX_W_38DB_P_2) },
9400 { "(bad)", { XX } },
9403 /* VEX_LEN_38DC_P_2 */
9405 { VEX_W_TABLE (VEX_W_38DC_P_2) },
9406 { "(bad)", { XX } },
9409 /* VEX_LEN_38DD_P_2 */
9411 { VEX_W_TABLE (VEX_W_38DD_P_2) },
9412 { "(bad)", { XX } },
9415 /* VEX_LEN_38DE_P_2 */
9417 { VEX_W_TABLE (VEX_W_38DE_P_2) },
9418 { "(bad)", { XX } },
9421 /* VEX_LEN_38DF_P_2 */
9423 { VEX_W_TABLE (VEX_W_38DF_P_2) },
9424 { "(bad)", { XX } },
9427 /* VEX_LEN_3A06_P_2 */
9429 { "(bad)", { XX } },
9430 { VEX_W_TABLE (VEX_W_3A06_P_2) },
9433 /* VEX_LEN_3A0A_P_2 */
9435 { VEX_W_TABLE (VEX_W_3A0A_P_2) },
9436 { "(bad)", { XX } },
9439 /* VEX_LEN_3A0B_P_2 */
9441 { VEX_W_TABLE (VEX_W_3A0B_P_2) },
9442 { "(bad)", { XX } },
9445 /* VEX_LEN_3A0E_P_2 */
9447 { VEX_W_TABLE (VEX_W_3A0E_P_2) },
9448 { "(bad)", { XX } },
9451 /* VEX_LEN_3A0F_P_2 */
9453 { VEX_W_TABLE (VEX_W_3A0F_P_2) },
9454 { "(bad)", { XX } },
9457 /* VEX_LEN_3A14_P_2 */
9459 { VEX_W_TABLE (VEX_W_3A14_P_2) },
9460 { "(bad)", { XX } },
9463 /* VEX_LEN_3A15_P_2 */
9465 { VEX_W_TABLE (VEX_W_3A15_P_2) },
9466 { "(bad)", { XX } },
9469 /* VEX_LEN_3A16_P_2 */
9471 { "vpextrK", { Edq, XM, Ib } },
9472 { "(bad)", { XX } },
9475 /* VEX_LEN_3A17_P_2 */
9477 { "vextractps", { Edqd, XM, Ib } },
9478 { "(bad)", { XX } },
9481 /* VEX_LEN_3A18_P_2 */
9483 { "(bad)", { XX } },
9484 { VEX_W_TABLE (VEX_W_3A18_P_2) },
9487 /* VEX_LEN_3A19_P_2 */
9489 { "(bad)", { XX } },
9490 { VEX_W_TABLE (VEX_W_3A19_P_2) },
9493 /* VEX_LEN_3A20_P_2 */
9495 { VEX_W_TABLE (VEX_W_3A20_P_2) },
9496 { "(bad)", { XX } },
9499 /* VEX_LEN_3A21_P_2 */
9501 { VEX_W_TABLE (VEX_W_3A21_P_2) },
9502 { "(bad)", { XX } },
9505 /* VEX_LEN_3A22_P_2 */
9507 { "vpinsrK", { XM, Vex128, Edq, Ib } },
9508 { "(bad)", { XX } },
9511 /* VEX_LEN_3A41_P_2 */
9513 { VEX_W_TABLE (VEX_W_3A41_P_2) },
9514 { "(bad)", { XX } },
9517 /* VEX_LEN_3A42_P_2 */
9519 { VEX_W_TABLE (VEX_W_3A42_P_2) },
9520 { "(bad)", { XX } },
9523 /* VEX_LEN_3A44_P_2 */
9525 { VEX_W_TABLE (VEX_W_3A44_P_2) },
9526 { "(bad)", { XX } },
9529 /* VEX_LEN_3A4C_P_2 */
9531 { VEX_W_TABLE (VEX_W_3A4C_P_2) },
9532 { "(bad)", { XX } },
9535 /* VEX_LEN_3A60_P_2 */
9537 { VEX_W_TABLE (VEX_W_3A60_P_2) },
9538 { "(bad)", { XX } },
9541 /* VEX_LEN_3A61_P_2 */
9543 { VEX_W_TABLE (VEX_W_3A61_P_2) },
9544 { "(bad)", { XX } },
9547 /* VEX_LEN_3A62_P_2 */
9549 { VEX_W_TABLE (VEX_W_3A62_P_2) },
9550 { "(bad)", { XX } },
9553 /* VEX_LEN_3A63_P_2 */
9555 { VEX_W_TABLE (VEX_W_3A63_P_2) },
9556 { "(bad)", { XX } },
9559 /* VEX_LEN_3A6A_P_2 */
9561 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9562 { "(bad)", { XX } },
9565 /* VEX_LEN_3A6B_P_2 */
9567 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9568 { "(bad)", { XX } },
9571 /* VEX_LEN_3A6E_P_2 */
9573 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9574 { "(bad)", { XX } },
9577 /* VEX_LEN_3A6F_P_2 */
9579 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9580 { "(bad)", { XX } },
9583 /* VEX_LEN_3A7A_P_2 */
9585 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9586 { "(bad)", { XX } },
9589 /* VEX_LEN_3A7B_P_2 */
9591 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9592 { "(bad)", { XX } },
9595 /* VEX_LEN_3A7E_P_2 */
9597 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9598 { "(bad)", { XX } },
9601 /* VEX_LEN_3A7F_P_2 */
9603 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9604 { "(bad)", { XX } },
9607 /* VEX_LEN_3ADF_P_2 */
9609 { VEX_W_TABLE (VEX_W_3ADF_P_2) },
9610 { "(bad)", { XX } },
9613 /* VEX_LEN_XOP_09_80 */
9615 { "vfrczps", { XM, EXxmm } },
9616 { "vfrczps", { XM, EXymmq } },
9619 /* VEX_LEN_XOP_09_81 */
9621 { "vfrczpd", { XM, EXxmm } },
9622 { "vfrczpd", { XM, EXymmq } },
9626 static const struct dis386 vex_w_table[][2] = {
9629 { "vmovups", { XM, EXx } },
9630 { "(bad)", { XX } },
9634 { "vmovss", { XMVex, Vex128, EXd } },
9635 { "(bad)", { XX } },
9639 { "vmovupd", { XM, EXx } },
9640 { "(bad)", { XX } },
9644 { "vmovsd", { XMVex, Vex128, EXq } },
9645 { "(bad)", { XX } },
9649 { "vmovups", { EXxS, XM } },
9650 { "(bad)", { XX } },
9654 { "vmovss", { EXdVexS, Vex128, XM } },
9655 { "(bad)", { XX } },
9659 { "vmovupd", { EXxS, XM } },
9660 { "(bad)", { XX } },
9664 { "vmovsd", { EXqVexS, Vex128, XM } },
9665 { "(bad)", { XX } },
9668 /* VEX_W_12_P_0_M_0 */
9669 { "vmovlps", { XM, Vex128, EXq } },
9670 { "(bad)", { XX } },
9673 /* VEX_W_12_P_0_M_1 */
9674 { "vmovhlps", { XM, Vex128, EXq } },
9675 { "(bad)", { XX } },
9679 { "vmovsldup", { XM, EXx } },
9680 { "(bad)", { XX } },
9684 { "vmovlpd", { XM, Vex128, EXq } },
9685 { "(bad)", { XX } },
9689 { "vmovddup", { XM, EXymmq } },
9690 { "(bad)", { XX } },
9694 { "vmovlpX", { EXq, XM } },
9695 { "(bad)", { XX } },
9699 { "vunpcklpX", { XM, Vex, EXx } },
9700 { "(bad)", { XX } },
9704 { "vunpckhpX", { XM, Vex, EXx } },
9705 { "(bad)", { XX } },
9708 /* VEX_W_16_P_0_M_0 */
9709 { "vmovhps", { XM, Vex128, EXq } },
9710 { "(bad)", { XX } },
9713 /* VEX_W_16_P_0_M_1 */
9714 { "vmovlhps", { XM, Vex128, EXq } },
9715 { "(bad)", { XX } },
9719 { "vmovshdup", { XM, EXx } },
9720 { "(bad)", { XX } },
9724 { "vmovhpd", { XM, Vex128, EXq } },
9725 { "(bad)", { XX } },
9729 { "vmovhpX", { EXq, XM } },
9730 { "(bad)", { XX } },
9734 { "vmovapX", { XM, EXx } },
9735 { "(bad)", { XX } },
9739 { "vmovapX", { EXxS, XM } },
9740 { "(bad)", { XX } },
9744 { "vmovntpX", { Mx, XM } },
9745 { "(bad)", { XX } },
9749 { "vucomiss", { XM, EXd } },
9750 { "(bad)", { XX } },
9754 { "vucomisd", { XM, EXq } },
9755 { "(bad)", { XX } },
9759 { "vcomiss", { XM, EXd } },
9760 { "(bad)", { XX } },
9764 { "vcomisd", { XM, EXq } },
9765 { "(bad)", { XX } },
9769 { "vmovmskpX", { Gdq, XS } },
9770 { "(bad)", { XX } },
9774 { "vsqrtps", { XM, EXx } },
9775 { "(bad)", { XX } },
9779 { "vsqrtss", { XM, Vex128, EXd } },
9780 { "(bad)", { XX } },
9784 { "vsqrtpd", { XM, EXx } },
9785 { "(bad)", { XX } },
9789 { "vsqrtsd", { XM, Vex128, EXq } },
9790 { "(bad)", { XX } },
9794 { "vrsqrtps", { XM, EXx } },
9795 { "(bad)", { XX } },
9799 { "vrsqrtss", { XM, Vex128, EXd } },
9800 { "(bad)", { XX } },
9804 { "vrcpps", { XM, EXx } },
9805 { "(bad)", { XX } },
9809 { "vrcpss", { XM, Vex128, EXd } },
9810 { "(bad)", { XX } },
9814 { "vaddps", { XM, Vex, EXx } },
9815 { "(bad)", { XX } },
9819 { "vaddss", { XM, Vex128, EXd } },
9820 { "(bad)", { XX } },
9824 { "vaddpd", { XM, Vex, EXx } },
9825 { "(bad)", { XX } },
9829 { "vaddsd", { XM, Vex128, EXq } },
9830 { "(bad)", { XX } },
9834 { "vmulps", { XM, Vex, EXx } },
9835 { "(bad)", { XX } },
9839 { "vmulss", { XM, Vex128, EXd } },
9840 { "(bad)", { XX } },
9844 { "vmulpd", { XM, Vex, EXx } },
9845 { "(bad)", { XX } },
9849 { "vmulsd", { XM, Vex128, EXq } },
9850 { "(bad)", { XX } },
9854 { "vcvtps2pd", { XM, EXxmmq } },
9855 { "(bad)", { XX } },
9859 { "vcvtss2sd", { XM, Vex128, EXd } },
9860 { "(bad)", { XX } },
9864 { "vcvtsd2ss", { XM, Vex128, EXq } },
9865 { "(bad)", { XX } },
9869 { "vcvtdq2ps", { XM, EXx } },
9870 { "(bad)", { XX } },
9874 { "vcvttps2dq", { XM, EXx } },
9875 { "(bad)", { XX } },
9879 { "vcvtps2dq", { XM, EXx } },
9880 { "(bad)", { XX } },
9884 { "vsubps", { XM, Vex, EXx } },
9885 { "(bad)", { XX } },
9889 { "vsubss", { XM, Vex128, EXd } },
9890 { "(bad)", { XX } },
9894 { "vsubpd", { XM, Vex, EXx } },
9895 { "(bad)", { XX } },
9899 { "vsubsd", { XM, Vex128, EXq } },
9900 { "(bad)", { XX } },
9904 { "vminps", { XM, Vex, EXx } },
9905 { "(bad)", { XX } },
9909 { "vminss", { XM, Vex128, EXd } },
9910 { "(bad)", { XX } },
9914 { "vminpd", { XM, Vex, EXx } },
9915 { "(bad)", { XX } },
9919 { "vminsd", { XM, Vex128, EXq } },
9920 { "(bad)", { XX } },
9924 { "vdivps", { XM, Vex, EXx } },
9925 { "(bad)", { XX } },
9929 { "vdivss", { XM, Vex128, EXd } },
9930 { "(bad)", { XX } },
9934 { "vdivpd", { XM, Vex, EXx } },
9935 { "(bad)", { XX } },
9939 { "vdivsd", { XM, Vex128, EXq } },
9940 { "(bad)", { XX } },
9944 { "vmaxps", { XM, Vex, EXx } },
9945 { "(bad)", { XX } },
9949 { "vmaxss", { XM, Vex128, EXd } },
9950 { "(bad)", { XX } },
9954 { "vmaxpd", { XM, Vex, EXx } },
9955 { "(bad)", { XX } },
9959 { "vmaxsd", { XM, Vex128, EXq } },
9960 { "(bad)", { XX } },
9964 { "vpunpcklbw", { XM, Vex128, EXx } },
9965 { "(bad)", { XX } },
9969 { "vpunpcklwd", { XM, Vex128, EXx } },
9970 { "(bad)", { XX } },
9974 { "vpunpckldq", { XM, Vex128, EXx } },
9975 { "(bad)", { XX } },
9979 { "vpacksswb", { XM, Vex128, EXx } },
9980 { "(bad)", { XX } },
9984 { "vpcmpgtb", { XM, Vex128, EXx } },
9985 { "(bad)", { XX } },
9989 { "vpcmpgtw", { XM, Vex128, EXx } },
9990 { "(bad)", { XX } },
9994 { "vpcmpgtd", { XM, Vex128, EXx } },
9995 { "(bad)", { XX } },
9999 { "vpackuswb", { XM, Vex128, EXx } },
10000 { "(bad)", { XX } },
10004 { "vpunpckhbw", { XM, Vex128, EXx } },
10005 { "(bad)", { XX } },
10009 { "vpunpckhwd", { XM, Vex128, EXx } },
10010 { "(bad)", { XX } },
10014 { "vpunpckhdq", { XM, Vex128, EXx } },
10015 { "(bad)", { XX } },
10019 { "vpackssdw", { XM, Vex128, EXx } },
10020 { "(bad)", { XX } },
10024 { "vpunpcklqdq", { XM, Vex128, EXx } },
10025 { "(bad)", { XX } },
10029 { "vpunpckhqdq", { XM, Vex128, EXx } },
10030 { "(bad)", { XX } },
10034 { "vmovdqu", { XM, EXx } },
10035 { "(bad)", { XX } },
10039 { "vmovdqa", { XM, EXx } },
10040 { "(bad)", { XX } },
10044 { "vpshufhw", { XM, EXx, Ib } },
10045 { "(bad)", { XX } },
10049 { "vpshufd", { XM, EXx, Ib } },
10050 { "(bad)", { XX } },
10054 { "vpshuflw", { XM, EXx, Ib } },
10055 { "(bad)", { XX } },
10058 /* VEX_W_71_R_2_P_2 */
10059 { "vpsrlw", { Vex128, XS, Ib } },
10060 { "(bad)", { XX } },
10063 /* VEX_W_71_R_4_P_2 */
10064 { "vpsraw", { Vex128, XS, Ib } },
10065 { "(bad)", { XX } },
10068 /* VEX_W_71_R_6_P_2 */
10069 { "vpsllw", { Vex128, XS, Ib } },
10070 { "(bad)", { XX } },
10073 /* VEX_W_72_R_2_P_2 */
10074 { "vpsrld", { Vex128, XS, Ib } },
10075 { "(bad)", { XX } },
10078 /* VEX_W_72_R_4_P_2 */
10079 { "vpsrad", { Vex128, XS, Ib } },
10080 { "(bad)", { XX } },
10083 /* VEX_W_72_R_6_P_2 */
10084 { "vpslld", { Vex128, XS, Ib } },
10085 { "(bad)", { XX } },
10088 /* VEX_W_73_R_2_P_2 */
10089 { "vpsrlq", { Vex128, XS, Ib } },
10090 { "(bad)", { XX } },
10093 /* VEX_W_73_R_3_P_2 */
10094 { "vpsrldq", { Vex128, XS, Ib } },
10095 { "(bad)", { XX } },
10098 /* VEX_W_73_R_6_P_2 */
10099 { "vpsllq", { Vex128, XS, Ib } },
10100 { "(bad)", { XX } },
10103 /* VEX_W_73_R_7_P_2 */
10104 { "vpslldq", { Vex128, XS, Ib } },
10105 { "(bad)", { XX } },
10109 { "vpcmpeqb", { XM, Vex128, EXx } },
10110 { "(bad)", { XX } },
10114 { "vpcmpeqw", { XM, Vex128, EXx } },
10115 { "(bad)", { XX } },
10119 { "vpcmpeqd", { XM, Vex128, EXx } },
10120 { "(bad)", { XX } },
10125 { "(bad)", { XX } },
10129 { "vhaddpd", { XM, Vex, EXx } },
10130 { "(bad)", { XX } },
10134 { "vhaddps", { XM, Vex, EXx } },
10135 { "(bad)", { XX } },
10139 { "vhsubpd", { XM, Vex, EXx } },
10140 { "(bad)", { XX } },
10144 { "vhsubps", { XM, Vex, EXx } },
10145 { "(bad)", { XX } },
10149 { "vmovq", { XM, EXq } },
10150 { "(bad)", { XX } },
10154 { "vmovdqu", { EXxS, XM } },
10155 { "(bad)", { XX } },
10159 { "vmovdqa", { EXxS, XM } },
10160 { "(bad)", { XX } },
10163 /* VEX_W_AE_R_2_M_0 */
10164 { "vldmxcsr", { Md } },
10165 { "(bad)", { XX } },
10168 /* VEX_W_AE_R_3_M_0 */
10169 { "vstmxcsr", { Md } },
10170 { "(bad)", { XX } },
10174 { "vcmpps", { XM, Vex, EXx, VCMP } },
10175 { "(bad)", { XX } },
10179 { "vcmpss", { XM, Vex128, EXd, VCMP } },
10180 { "(bad)", { XX } },
10184 { "vcmppd", { XM, Vex, EXx, VCMP } },
10185 { "(bad)", { XX } },
10189 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
10190 { "(bad)", { XX } },
10194 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
10195 { "(bad)", { XX } },
10199 { "vpextrw", { Gdq, XS, Ib } },
10200 { "(bad)", { XX } },
10204 { "vaddsubpd", { XM, Vex, EXx } },
10205 { "(bad)", { XX } },
10209 { "vaddsubps", { XM, Vex, EXx } },
10210 { "(bad)", { XX } },
10214 { "vpsrlw", { XM, Vex128, EXx } },
10215 { "(bad)", { XX } },
10219 { "vpsrld", { XM, Vex128, EXx } },
10220 { "(bad)", { XX } },
10224 { "vpsrlq", { XM, Vex128, EXx } },
10225 { "(bad)", { XX } },
10229 { "vpaddq", { XM, Vex128, EXx } },
10230 { "(bad)", { XX } },
10234 { "vpmullw", { XM, Vex128, EXx } },
10235 { "(bad)", { XX } },
10239 { "vmovq", { EXqS, XM } },
10240 { "(bad)", { XX } },
10243 /* VEX_W_D7_P_2_M_1 */
10244 { "vpmovmskb", { Gdq, XS } },
10245 { "(bad)", { XX } },
10249 { "vpsubusb", { XM, Vex128, EXx } },
10250 { "(bad)", { XX } },
10254 { "vpsubusw", { XM, Vex128, EXx } },
10255 { "(bad)", { XX } },
10259 { "vpminub", { XM, Vex128, EXx } },
10260 { "(bad)", { XX } },
10264 { "vpand", { XM, Vex128, EXx } },
10265 { "(bad)", { XX } },
10269 { "vpaddusb", { XM, Vex128, EXx } },
10270 { "(bad)", { XX } },
10274 { "vpaddusw", { XM, Vex128, EXx } },
10275 { "(bad)", { XX } },
10279 { "vpmaxub", { XM, Vex128, EXx } },
10280 { "(bad)", { XX } },
10284 { "vpandn", { XM, Vex128, EXx } },
10285 { "(bad)", { XX } },
10289 { "vpavgb", { XM, Vex128, EXx } },
10290 { "(bad)", { XX } },
10294 { "vpsraw", { XM, Vex128, EXx } },
10295 { "(bad)", { XX } },
10299 { "vpsrad", { XM, Vex128, EXx } },
10300 { "(bad)", { XX } },
10304 { "vpavgw", { XM, Vex128, EXx } },
10305 { "(bad)", { XX } },
10309 { "vpmulhuw", { XM, Vex128, EXx } },
10310 { "(bad)", { XX } },
10314 { "vpmulhw", { XM, Vex128, EXx } },
10315 { "(bad)", { XX } },
10319 { "vcvtdq2pd", { XM, EXxmmq } },
10320 { "(bad)", { XX } },
10324 { "vcvttpd2dq%XY", { XMM, EXx } },
10325 { "(bad)", { XX } },
10329 { "vcvtpd2dq%XY", { XMM, EXx } },
10330 { "(bad)", { XX } },
10333 /* VEX_W_E7_P_2_M_0 */
10334 { "vmovntdq", { Mx, XM } },
10335 { "(bad)", { XX } },
10339 { "vpsubsb", { XM, Vex128, EXx } },
10340 { "(bad)", { XX } },
10344 { "vpsubsw", { XM, Vex128, EXx } },
10345 { "(bad)", { XX } },
10349 { "vpminsw", { XM, Vex128, EXx } },
10350 { "(bad)", { XX } },
10354 { "vpor", { XM, Vex128, EXx } },
10355 { "(bad)", { XX } },
10359 { "vpaddsb", { XM, Vex128, EXx } },
10360 { "(bad)", { XX } },
10364 { "vpaddsw", { XM, Vex128, EXx } },
10365 { "(bad)", { XX } },
10369 { "vpmaxsw", { XM, Vex128, EXx } },
10370 { "(bad)", { XX } },
10374 { "vpxor", { XM, Vex128, EXx } },
10375 { "(bad)", { XX } },
10378 /* VEX_W_F0_P_3_M_0 */
10379 { "vlddqu", { XM, M } },
10380 { "(bad)", { XX } },
10384 { "vpsllw", { XM, Vex128, EXx } },
10385 { "(bad)", { XX } },
10389 { "vpslld", { XM, Vex128, EXx } },
10390 { "(bad)", { XX } },
10394 { "vpsllq", { XM, Vex128, EXx } },
10395 { "(bad)", { XX } },
10399 { "vpmuludq", { XM, Vex128, EXx } },
10400 { "(bad)", { XX } },
10404 { "vpmaddwd", { XM, Vex128, EXx } },
10405 { "(bad)", { XX } },
10409 { "vpsadbw", { XM, Vex128, EXx } },
10410 { "(bad)", { XX } },
10414 { "vmaskmovdqu", { XM, XS } },
10415 { "(bad)", { XX } },
10419 { "vpsubb", { XM, Vex128, EXx } },
10420 { "(bad)", { XX } },
10424 { "vpsubw", { XM, Vex128, EXx } },
10425 { "(bad)", { XX } },
10429 { "vpsubd", { XM, Vex128, EXx } },
10430 { "(bad)", { XX } },
10434 { "vpsubq", { XM, Vex128, EXx } },
10435 { "(bad)", { XX } },
10439 { "vpaddb", { XM, Vex128, EXx } },
10440 { "(bad)", { XX } },
10444 { "vpaddw", { XM, Vex128, EXx } },
10445 { "(bad)", { XX } },
10449 { "vpaddd", { XM, Vex128, EXx } },
10450 { "(bad)", { XX } },
10453 /* VEX_W_3800_P_2 */
10454 { "vpshufb", { XM, Vex128, EXx } },
10455 { "(bad)", { XX } },
10458 /* VEX_W_3801_P_2 */
10459 { "vphaddw", { XM, Vex128, EXx } },
10460 { "(bad)", { XX } },
10463 /* VEX_W_3802_P_2 */
10464 { "vphaddd", { XM, Vex128, EXx } },
10465 { "(bad)", { XX } },
10468 /* VEX_W_3803_P_2 */
10469 { "vphaddsw", { XM, Vex128, EXx } },
10470 { "(bad)", { XX } },
10473 /* VEX_W_3804_P_2 */
10474 { "vpmaddubsw", { XM, Vex128, EXx } },
10475 { "(bad)", { XX } },
10478 /* VEX_W_3805_P_2 */
10479 { "vphsubw", { XM, Vex128, EXx } },
10480 { "(bad)", { XX } },
10483 /* VEX_W_3806_P_2 */
10484 { "vphsubd", { XM, Vex128, EXx } },
10485 { "(bad)", { XX } },
10488 /* VEX_W_3807_P_2 */
10489 { "vphsubsw", { XM, Vex128, EXx } },
10490 { "(bad)", { XX } },
10493 /* VEX_W_3808_P_2 */
10494 { "vpsignb", { XM, Vex128, EXx } },
10495 { "(bad)", { XX } },
10498 /* VEX_W_3809_P_2 */
10499 { "vpsignw", { XM, Vex128, EXx } },
10500 { "(bad)", { XX } },
10503 /* VEX_W_380A_P_2 */
10504 { "vpsignd", { XM, Vex128, EXx } },
10505 { "(bad)", { XX } },
10508 /* VEX_W_380B_P_2 */
10509 { "vpmulhrsw", { XM, Vex128, EXx } },
10510 { "(bad)", { XX } },
10513 /* VEX_W_380C_P_2 */
10514 { "vpermilps", { XM, Vex, EXx } },
10515 { "(bad)", { XX } },
10518 /* VEX_W_380D_P_2 */
10519 { "vpermilpd", { XM, Vex, EXx } },
10520 { "(bad)", { XX } },
10523 /* VEX_W_380E_P_2 */
10524 { "vtestps", { XM, EXx } },
10525 { "(bad)", { XX } },
10528 /* VEX_W_380F_P_2 */
10529 { "vtestpd", { XM, EXx } },
10530 { "(bad)", { XX } },
10533 /* VEX_W_3817_P_2 */
10534 { "vptest", { XM, EXx } },
10535 { "(bad)", { XX } },
10538 /* VEX_W_3818_P_2_M_0 */
10539 { "vbroadcastss", { XM, Md } },
10540 { "(bad)", { XX } },
10543 /* VEX_W_3819_P_2_M_0 */
10544 { "vbroadcastsd", { XM, Mq } },
10545 { "(bad)", { XX } },
10548 /* VEX_W_381A_P_2_M_0 */
10549 { "vbroadcastf128", { XM, Mxmm } },
10550 { "(bad)", { XX } },
10553 /* VEX_W_381C_P_2 */
10554 { "vpabsb", { XM, EXx } },
10555 { "(bad)", { XX } },
10558 /* VEX_W_381D_P_2 */
10559 { "vpabsw", { XM, EXx } },
10560 { "(bad)", { XX } },
10563 /* VEX_W_381E_P_2 */
10564 { "vpabsd", { XM, EXx } },
10565 { "(bad)", { XX } },
10568 /* VEX_W_3820_P_2 */
10569 { "vpmovsxbw", { XM, EXq } },
10570 { "(bad)", { XX } },
10573 /* VEX_W_3821_P_2 */
10574 { "vpmovsxbd", { XM, EXd } },
10575 { "(bad)", { XX } },
10578 /* VEX_W_3822_P_2 */
10579 { "vpmovsxbq", { XM, EXw } },
10580 { "(bad)", { XX } },
10583 /* VEX_W_3823_P_2 */
10584 { "vpmovsxwd", { XM, EXq } },
10585 { "(bad)", { XX } },
10588 /* VEX_W_3824_P_2 */
10589 { "vpmovsxwq", { XM, EXd } },
10590 { "(bad)", { XX } },
10593 /* VEX_W_3825_P_2 */
10594 { "vpmovsxdq", { XM, EXq } },
10595 { "(bad)", { XX } },
10598 /* VEX_W_3828_P_2 */
10599 { "vpmuldq", { XM, Vex128, EXx } },
10600 { "(bad)", { XX } },
10603 /* VEX_W_3829_P_2 */
10604 { "vpcmpeqq", { XM, Vex128, EXx } },
10605 { "(bad)", { XX } },
10608 /* VEX_W_382A_P_2_M_0 */
10609 { "vmovntdqa", { XM, Mx } },
10610 { "(bad)", { XX } },
10613 /* VEX_W_382B_P_2 */
10614 { "vpackusdw", { XM, Vex128, EXx } },
10615 { "(bad)", { XX } },
10618 /* VEX_W_382C_P_2_M_0 */
10619 { "vmaskmovps", { XM, Vex, Mx } },
10620 { "(bad)", { XX } },
10623 /* VEX_W_382D_P_2_M_0 */
10624 { "vmaskmovpd", { XM, Vex, Mx } },
10625 { "(bad)", { XX } },
10628 /* VEX_W_382E_P_2_M_0 */
10629 { "vmaskmovps", { Mx, Vex, XM } },
10630 { "(bad)", { XX } },
10633 /* VEX_W_382F_P_2_M_0 */
10634 { "vmaskmovpd", { Mx, Vex, XM } },
10635 { "(bad)", { XX } },
10638 /* VEX_W_3830_P_2 */
10639 { "vpmovzxbw", { XM, EXq } },
10640 { "(bad)", { XX } },
10643 /* VEX_W_3831_P_2 */
10644 { "vpmovzxbd", { XM, EXd } },
10645 { "(bad)", { XX } },
10648 /* VEX_W_3832_P_2 */
10649 { "vpmovzxbq", { XM, EXw } },
10650 { "(bad)", { XX } },
10653 /* VEX_W_3833_P_2 */
10654 { "vpmovzxwd", { XM, EXq } },
10655 { "(bad)", { XX } },
10658 /* VEX_W_3834_P_2 */
10659 { "vpmovzxwq", { XM, EXd } },
10660 { "(bad)", { XX } },
10663 /* VEX_W_3835_P_2 */
10664 { "vpmovzxdq", { XM, EXq } },
10665 { "(bad)", { XX } },
10668 /* VEX_W_3837_P_2 */
10669 { "vpcmpgtq", { XM, Vex128, EXx } },
10670 { "(bad)", { XX } },
10673 /* VEX_W_3838_P_2 */
10674 { "vpminsb", { XM, Vex128, EXx } },
10675 { "(bad)", { XX } },
10678 /* VEX_W_3839_P_2 */
10679 { "vpminsd", { XM, Vex128, EXx } },
10680 { "(bad)", { XX } },
10683 /* VEX_W_383A_P_2 */
10684 { "vpminuw", { XM, Vex128, EXx } },
10685 { "(bad)", { XX } },
10688 /* VEX_W_383B_P_2 */
10689 { "vpminud", { XM, Vex128, EXx } },
10690 { "(bad)", { XX } },
10693 /* VEX_W_383C_P_2 */
10694 { "vpmaxsb", { XM, Vex128, EXx } },
10695 { "(bad)", { XX } },
10698 /* VEX_W_383D_P_2 */
10699 { "vpmaxsd", { XM, Vex128, EXx } },
10700 { "(bad)", { XX } },
10703 /* VEX_W_383E_P_2 */
10704 { "vpmaxuw", { XM, Vex128, EXx } },
10705 { "(bad)", { XX } },
10708 /* VEX_W_383F_P_2 */
10709 { "vpmaxud", { XM, Vex128, EXx } },
10710 { "(bad)", { XX } },
10713 /* VEX_W_3840_P_2 */
10714 { "vpmulld", { XM, Vex128, EXx } },
10715 { "(bad)", { XX } },
10718 /* VEX_W_3841_P_2 */
10719 { "vphminposuw", { XM, EXx } },
10720 { "(bad)", { XX } },
10723 /* VEX_W_38DB_P_2 */
10724 { "vaesimc", { XM, EXx } },
10725 { "(bad)", { XX } },
10728 /* VEX_W_38DC_P_2 */
10729 { "vaesenc", { XM, Vex128, EXx } },
10730 { "(bad)", { XX } },
10733 /* VEX_W_38DD_P_2 */
10734 { "vaesenclast", { XM, Vex128, EXx } },
10735 { "(bad)", { XX } },
10738 /* VEX_W_38DE_P_2 */
10739 { "vaesdec", { XM, Vex128, EXx } },
10740 { "(bad)", { XX } },
10743 /* VEX_W_38DF_P_2 */
10744 { "vaesdeclast", { XM, Vex128, EXx } },
10745 { "(bad)", { XX } },
10748 /* VEX_W_3A04_P_2 */
10749 { "vpermilps", { XM, EXx, Ib } },
10750 { "(bad)", { XX } },
10753 /* VEX_W_3A05_P_2 */
10754 { "vpermilpd", { XM, EXx, Ib } },
10755 { "(bad)", { XX } },
10758 /* VEX_W_3A06_P_2 */
10759 { "vperm2f128", { XM, Vex256, EXx, Ib } },
10760 { "(bad)", { XX } },
10763 /* VEX_W_3A08_P_2 */
10764 { "vroundps", { XM, EXx, Ib } },
10765 { "(bad)", { XX } },
10768 /* VEX_W_3A09_P_2 */
10769 { "vroundpd", { XM, EXx, Ib } },
10770 { "(bad)", { XX } },
10773 /* VEX_W_3A0A_P_2 */
10774 { "vroundss", { XM, Vex128, EXd, Ib } },
10775 { "(bad)", { XX } },
10778 /* VEX_W_3A0B_P_2 */
10779 { "vroundsd", { XM, Vex128, EXq, Ib } },
10780 { "(bad)", { XX } },
10783 /* VEX_W_3A0C_P_2 */
10784 { "vblendps", { XM, Vex, EXx, Ib } },
10785 { "(bad)", { XX } },
10788 /* VEX_W_3A0D_P_2 */
10789 { "vblendpd", { XM, Vex, EXx, Ib } },
10790 { "(bad)", { XX } },
10793 /* VEX_W_3A0E_P_2 */
10794 { "vpblendw", { XM, Vex128, EXx, Ib } },
10795 { "(bad)", { XX } },
10798 /* VEX_W_3A0F_P_2 */
10799 { "vpalignr", { XM, Vex128, EXx, Ib } },
10800 { "(bad)", { XX } },
10803 /* VEX_W_3A14_P_2 */
10804 { "vpextrb", { Edqb, XM, Ib } },
10805 { "(bad)", { XX } },
10808 /* VEX_W_3A15_P_2 */
10809 { "vpextrw", { Edqw, XM, Ib } },
10810 { "(bad)", { XX } },
10813 /* VEX_W_3A18_P_2 */
10814 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
10815 { "(bad)", { XX } },
10818 /* VEX_W_3A19_P_2 */
10819 { "vextractf128", { EXxmm, XM, Ib } },
10820 { "(bad)", { XX } },
10823 /* VEX_W_3A20_P_2 */
10824 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
10825 { "(bad)", { XX } },
10828 /* VEX_W_3A21_P_2 */
10829 { "vinsertps", { XM, Vex128, EXd, Ib } },
10830 { "(bad)", { XX } },
10833 /* VEX_W_3A40_P_2 */
10834 { "vdpps", { XM, Vex, EXx, Ib } },
10835 { "(bad)", { XX } },
10838 /* VEX_W_3A41_P_2 */
10839 { "vdppd", { XM, Vex128, EXx, Ib } },
10840 { "(bad)", { XX } },
10843 /* VEX_W_3A42_P_2 */
10844 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
10845 { "(bad)", { XX } },
10848 /* VEX_W_3A44_P_2 */
10849 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
10850 { "(bad)", { XX } },
10853 /* VEX_W_3A4A_P_2 */
10854 { "vblendvps", { XM, Vex, EXx, XMVexI4 } },
10855 { "(bad)", { XX } },
10858 /* VEX_W_3A4B_P_2 */
10859 { "vblendvpd", { XM, Vex, EXx, XMVexI4 } },
10860 { "(bad)", { XX } },
10863 /* VEX_W_3A4C_P_2 */
10864 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
10865 { "(bad)", { XX } },
10868 /* VEX_W_3A60_P_2 */
10869 { "vpcmpestrm", { XM, EXx, Ib } },
10870 { "(bad)", { XX } },
10873 /* VEX_W_3A61_P_2 */
10874 { "vpcmpestri", { XM, EXx, Ib } },
10875 { "(bad)", { XX } },
10878 /* VEX_W_3A62_P_2 */
10879 { "vpcmpistrm", { XM, EXx, Ib } },
10880 { "(bad)", { XX } },
10883 /* VEX_W_3A63_P_2 */
10884 { "vpcmpistri", { XM, EXx, Ib } },
10885 { "(bad)", { XX } },
10888 /* VEX_W_3ADF_P_2 */
10889 { "vaeskeygenassist", { XM, EXx, Ib } },
10890 { "(bad)", { XX } },
10894 static const struct dis386 mod_table[][2] = {
10897 { "leaS", { Gv, M } },
10898 { "(bad)", { XX } },
10901 /* MOD_0F01_REG_0 */
10902 { X86_64_TABLE (X86_64_0F01_REG_0) },
10903 { RM_TABLE (RM_0F01_REG_0) },
10906 /* MOD_0F01_REG_1 */
10907 { X86_64_TABLE (X86_64_0F01_REG_1) },
10908 { RM_TABLE (RM_0F01_REG_1) },
10911 /* MOD_0F01_REG_2 */
10912 { X86_64_TABLE (X86_64_0F01_REG_2) },
10913 { RM_TABLE (RM_0F01_REG_2) },
10916 /* MOD_0F01_REG_3 */
10917 { X86_64_TABLE (X86_64_0F01_REG_3) },
10918 { RM_TABLE (RM_0F01_REG_3) },
10921 /* MOD_0F01_REG_7 */
10922 { "invlpg", { Mb } },
10923 { RM_TABLE (RM_0F01_REG_7) },
10926 /* MOD_0F12_PREFIX_0 */
10927 { "movlps", { XM, EXq } },
10928 { "movhlps", { XM, EXq } },
10932 { "movlpX", { EXq, XM } },
10933 { "(bad)", { XX } },
10936 /* MOD_0F16_PREFIX_0 */
10937 { "movhps", { XM, EXq } },
10938 { "movlhps", { XM, EXq } },
10942 { "movhpX", { EXq, XM } },
10943 { "(bad)", { XX } },
10946 /* MOD_0F18_REG_0 */
10947 { "prefetchnta", { Mb } },
10948 { "(bad)", { XX } },
10951 /* MOD_0F18_REG_1 */
10952 { "prefetcht0", { Mb } },
10953 { "(bad)", { XX } },
10956 /* MOD_0F18_REG_2 */
10957 { "prefetcht1", { Mb } },
10958 { "(bad)", { XX } },
10961 /* MOD_0F18_REG_3 */
10962 { "prefetcht2", { Mb } },
10963 { "(bad)", { XX } },
10967 { "(bad)", { XX } },
10968 { "movZ", { Rm, Cm } },
10972 { "(bad)", { XX } },
10973 { "movZ", { Rm, Dm } },
10977 { "(bad)", { XX } },
10978 { "movZ", { Cm, Rm } },
10982 { "(bad)", { XX } },
10983 { "movZ", { Dm, Rm } },
10987 { "(bad)", { XX } },
10988 { "movL", { Rd, Td } },
10992 { "(bad)", { XX } },
10993 { "movL", { Td, Rd } },
10996 /* MOD_0F2B_PREFIX_0 */
10997 {"movntps", { Mx, XM } },
10998 { "(bad)", { XX } },
11001 /* MOD_0F2B_PREFIX_1 */
11002 {"movntss", { Md, XM } },
11003 { "(bad)", { XX } },
11006 /* MOD_0F2B_PREFIX_2 */
11007 {"movntpd", { Mx, XM } },
11008 { "(bad)", { XX } },
11011 /* MOD_0F2B_PREFIX_3 */
11012 {"movntsd", { Mq, XM } },
11013 { "(bad)", { XX } },
11017 { "(bad)", { XX } },
11018 { "movmskpX", { Gdq, XS } },
11021 /* MOD_0F71_REG_2 */
11022 { "(bad)", { XX } },
11023 { "psrlw", { MS, Ib } },
11026 /* MOD_0F71_REG_4 */
11027 { "(bad)", { XX } },
11028 { "psraw", { MS, Ib } },
11031 /* MOD_0F71_REG_6 */
11032 { "(bad)", { XX } },
11033 { "psllw", { MS, Ib } },
11036 /* MOD_0F72_REG_2 */
11037 { "(bad)", { XX } },
11038 { "psrld", { MS, Ib } },
11041 /* MOD_0F72_REG_4 */
11042 { "(bad)", { XX } },
11043 { "psrad", { MS, Ib } },
11046 /* MOD_0F72_REG_6 */
11047 { "(bad)", { XX } },
11048 { "pslld", { MS, Ib } },
11051 /* MOD_0F73_REG_2 */
11052 { "(bad)", { XX } },
11053 { "psrlq", { MS, Ib } },
11056 /* MOD_0F73_REG_3 */
11057 { "(bad)", { XX } },
11058 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
11061 /* MOD_0F73_REG_6 */
11062 { "(bad)", { XX } },
11063 { "psllq", { MS, Ib } },
11066 /* MOD_0F73_REG_7 */
11067 { "(bad)", { XX } },
11068 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
11071 /* MOD_0FAE_REG_0 */
11072 { "fxsave", { FXSAVE } },
11073 { "(bad)", { XX } },
11076 /* MOD_0FAE_REG_1 */
11077 { "fxrstor", { FXSAVE } },
11078 { "(bad)", { XX } },
11081 /* MOD_0FAE_REG_2 */
11082 { "ldmxcsr", { Md } },
11083 { "(bad)", { XX } },
11086 /* MOD_0FAE_REG_3 */
11087 { "stmxcsr", { Md } },
11088 { "(bad)", { XX } },
11091 /* MOD_0FAE_REG_4 */
11092 { "xsave", { M } },
11093 { "(bad)", { XX } },
11096 /* MOD_0FAE_REG_5 */
11097 { "xrstor", { M } },
11098 { RM_TABLE (RM_0FAE_REG_5) },
11101 /* MOD_0FAE_REG_6 */
11102 { "xsaveopt", { M } },
11103 { RM_TABLE (RM_0FAE_REG_6) },
11106 /* MOD_0FAE_REG_7 */
11107 { "clflush", { Mb } },
11108 { RM_TABLE (RM_0FAE_REG_7) },
11112 { "lssS", { Gv, Mp } },
11113 { "(bad)", { XX } },
11117 { "lfsS", { Gv, Mp } },
11118 { "(bad)", { XX } },
11122 { "lgsS", { Gv, Mp } },
11123 { "(bad)", { XX } },
11126 /* MOD_0FC7_REG_6 */
11127 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
11128 { "(bad)", { XX } },
11131 /* MOD_0FC7_REG_7 */
11132 { "vmptrst", { Mq } },
11133 { "(bad)", { XX } },
11137 { "(bad)", { XX } },
11138 { "pmovmskb", { Gdq, MS } },
11141 /* MOD_0FE7_PREFIX_2 */
11142 { "movntdq", { Mx, XM } },
11143 { "(bad)", { XX } },
11146 /* MOD_0FF0_PREFIX_3 */
11147 { "lddqu", { XM, M } },
11148 { "(bad)", { XX } },
11151 /* MOD_0F382A_PREFIX_2 */
11152 { "movntdqa", { XM, Mx } },
11153 { "(bad)", { XX } },
11157 { "bound{S|}", { Gv, Ma } },
11158 { "(bad)", { XX } },
11162 { "lesS", { Gv, Mp } },
11163 { VEX_C4_TABLE (VEX_0F) },
11167 { "ldsS", { Gv, Mp } },
11168 { VEX_C5_TABLE (VEX_0F) },
11171 /* MOD_VEX_12_PREFIX_0 */
11172 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
11173 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
11177 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
11178 { "(bad)", { XX } },
11181 /* MOD_VEX_16_PREFIX_0 */
11182 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
11183 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
11187 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
11188 { "(bad)", { XX } },
11192 { VEX_W_TABLE (VEX_W_2B_M_0) },
11193 { "(bad)", { XX } },
11197 { "(bad)", { XX } },
11198 { VEX_W_TABLE (VEX_W_50_M_0) },
11201 /* MOD_VEX_71_REG_2 */
11202 { "(bad)", { XX } },
11203 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
11206 /* MOD_VEX_71_REG_4 */
11207 { "(bad)", { XX } },
11208 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
11211 /* MOD_VEX_71_REG_6 */
11212 { "(bad)", { XX } },
11213 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
11216 /* MOD_VEX_72_REG_2 */
11217 { "(bad)", { XX } },
11218 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
11221 /* MOD_VEX_72_REG_4 */
11222 { "(bad)", { XX } },
11223 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
11226 /* MOD_VEX_72_REG_6 */
11227 { "(bad)", { XX } },
11228 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
11231 /* MOD_VEX_73_REG_2 */
11232 { "(bad)", { XX } },
11233 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
11236 /* MOD_VEX_73_REG_3 */
11237 { "(bad)", { XX } },
11238 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
11241 /* MOD_VEX_73_REG_6 */
11242 { "(bad)", { XX } },
11243 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
11246 /* MOD_VEX_73_REG_7 */
11247 { "(bad)", { XX } },
11248 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
11251 /* MOD_VEX_AE_REG_2 */
11252 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
11253 { "(bad)", { XX } },
11256 /* MOD_VEX_AE_REG_3 */
11257 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
11258 { "(bad)", { XX } },
11261 /* MOD_VEX_D7_PREFIX_2 */
11262 { "(bad)", { XX } },
11263 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
11266 /* MOD_VEX_E7_PREFIX_2 */
11267 { VEX_W_TABLE (VEX_W_E7_P_2_M_0) },
11268 { "(bad)", { XX } },
11271 /* MOD_VEX_F0_PREFIX_3 */
11272 { VEX_W_TABLE (VEX_W_F0_P_3_M_0) },
11273 { "(bad)", { XX } },
11276 /* MOD_VEX_3818_PREFIX_2 */
11277 { VEX_W_TABLE (VEX_W_3818_P_2_M_0) },
11278 { "(bad)", { XX } },
11281 /* MOD_VEX_3819_PREFIX_2 */
11282 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
11283 { "(bad)", { XX } },
11286 /* MOD_VEX_381A_PREFIX_2 */
11287 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
11288 { "(bad)", { XX } },
11291 /* MOD_VEX_382A_PREFIX_2 */
11292 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
11293 { "(bad)", { XX } },
11296 /* MOD_VEX_382C_PREFIX_2 */
11297 { VEX_W_TABLE (VEX_W_382C_P_2_M_0) },
11298 { "(bad)", { XX } },
11301 /* MOD_VEX_382D_PREFIX_2 */
11302 { VEX_W_TABLE (VEX_W_382D_P_2_M_0) },
11303 { "(bad)", { XX } },
11306 /* MOD_VEX_382E_PREFIX_2 */
11307 { VEX_W_TABLE (VEX_W_382E_P_2_M_0) },
11308 { "(bad)", { XX } },
11311 /* MOD_VEX_382F_PREFIX_2 */
11312 { VEX_W_TABLE (VEX_W_382F_P_2_M_0) },
11313 { "(bad)", { XX } },
11317 static const struct dis386 rm_table[][8] = {
11319 /* RM_0F01_REG_0 */
11320 { "(bad)", { XX } },
11321 { "vmcall", { Skip_MODRM } },
11322 { "vmlaunch", { Skip_MODRM } },
11323 { "vmresume", { Skip_MODRM } },
11324 { "vmxoff", { Skip_MODRM } },
11325 { "(bad)", { XX } },
11326 { "(bad)", { XX } },
11327 { "(bad)", { XX } },
11330 /* RM_0F01_REG_1 */
11331 { "monitor", { { OP_Monitor, 0 } } },
11332 { "mwait", { { OP_Mwait, 0 } } },
11333 { "(bad)", { XX } },
11334 { "(bad)", { XX } },
11335 { "(bad)", { XX } },
11336 { "(bad)", { XX } },
11337 { "(bad)", { XX } },
11338 { "(bad)", { XX } },
11341 /* RM_0F01_REG_2 */
11342 { "xgetbv", { Skip_MODRM } },
11343 { "xsetbv", { Skip_MODRM } },
11344 { "(bad)", { XX } },
11345 { "(bad)", { XX } },
11346 { "(bad)", { XX } },
11347 { "(bad)", { XX } },
11348 { "(bad)", { XX } },
11349 { "(bad)", { XX } },
11352 /* RM_0F01_REG_3 */
11353 { "vmrun", { Skip_MODRM } },
11354 { "vmmcall", { Skip_MODRM } },
11355 { "vmload", { Skip_MODRM } },
11356 { "vmsave", { Skip_MODRM } },
11357 { "stgi", { Skip_MODRM } },
11358 { "clgi", { Skip_MODRM } },
11359 { "skinit", { Skip_MODRM } },
11360 { "invlpga", { Skip_MODRM } },
11363 /* RM_0F01_REG_7 */
11364 { "swapgs", { Skip_MODRM } },
11365 { "rdtscp", { Skip_MODRM } },
11366 { "(bad)", { XX } },
11367 { "(bad)", { XX } },
11368 { "(bad)", { XX } },
11369 { "(bad)", { XX } },
11370 { "(bad)", { XX } },
11371 { "(bad)", { XX } },
11374 /* RM_0FAE_REG_5 */
11375 { "lfence", { Skip_MODRM } },
11376 { "(bad)", { XX } },
11377 { "(bad)", { XX } },
11378 { "(bad)", { XX } },
11379 { "(bad)", { XX } },
11380 { "(bad)", { XX } },
11381 { "(bad)", { XX } },
11382 { "(bad)", { XX } },
11385 /* RM_0FAE_REG_6 */
11386 { "mfence", { Skip_MODRM } },
11387 { "(bad)", { XX } },
11388 { "(bad)", { XX } },
11389 { "(bad)", { XX } },
11390 { "(bad)", { XX } },
11391 { "(bad)", { XX } },
11392 { "(bad)", { XX } },
11393 { "(bad)", { XX } },
11396 /* RM_0FAE_REG_7 */
11397 { "sfence", { Skip_MODRM } },
11398 { "(bad)", { XX } },
11399 { "(bad)", { XX } },
11400 { "(bad)", { XX } },
11401 { "(bad)", { XX } },
11402 { "(bad)", { XX } },
11403 { "(bad)", { XX } },
11404 { "(bad)", { XX } },
11408 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
11410 /* We use the high bit to indicate different name for the same
11412 #define ADDR16_PREFIX (0x67 | 0x100)
11413 #define ADDR32_PREFIX (0x67 | 0x200)
11414 #define DATA16_PREFIX (0x66 | 0x100)
11415 #define DATA32_PREFIX (0x66 | 0x200)
11416 #define REP_PREFIX (0xf3 | 0x100)
11421 int newrex, i, length;
11427 last_lock_prefix = -1;
11428 last_repz_prefix = -1;
11429 last_repnz_prefix = -1;
11430 last_data_prefix = -1;
11431 last_addr_prefix = -1;
11432 last_rex_prefix = -1;
11433 last_seg_prefix = -1;
11434 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
11435 all_prefixes[i] = 0;
11438 /* The maximum instruction length is 15bytes. */
11439 while (length < MAX_CODE_LENGTH - 1)
11441 FETCH_DATA (the_info, codep + 1);
11445 /* REX prefixes family. */
11462 if (address_mode == mode_64bit)
11466 last_rex_prefix = i;
11469 prefixes |= PREFIX_REPZ;
11470 last_repz_prefix = i;
11473 prefixes |= PREFIX_REPNZ;
11474 last_repnz_prefix = i;
11477 prefixes |= PREFIX_LOCK;
11478 last_lock_prefix = i;
11481 prefixes |= PREFIX_CS;
11482 last_seg_prefix = i;
11485 prefixes |= PREFIX_SS;
11486 last_seg_prefix = i;
11489 prefixes |= PREFIX_DS;
11490 last_seg_prefix = i;
11493 prefixes |= PREFIX_ES;
11494 last_seg_prefix = i;
11497 prefixes |= PREFIX_FS;
11498 last_seg_prefix = i;
11501 prefixes |= PREFIX_GS;
11502 last_seg_prefix = i;
11505 prefixes |= PREFIX_DATA;
11506 last_data_prefix = i;
11509 prefixes |= PREFIX_ADDR;
11510 last_addr_prefix = i;
11513 /* fwait is really an instruction. If there are prefixes
11514 before the fwait, they belong to the fwait, *not* to the
11515 following instruction. */
11516 if (prefixes || rex)
11518 prefixes |= PREFIX_FWAIT;
11522 prefixes = PREFIX_FWAIT;
11527 /* Rex is ignored when followed by another prefix. */
11533 if (*codep != FWAIT_OPCODE)
11534 all_prefixes[i++] = *codep;
11543 seg_prefix (int pref)
11564 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
11567 static const char *
11568 prefix_name (int pref, int sizeflag)
11570 static const char *rexes [16] =
11573 "rex.B", /* 0x41 */
11574 "rex.X", /* 0x42 */
11575 "rex.XB", /* 0x43 */
11576 "rex.R", /* 0x44 */
11577 "rex.RB", /* 0x45 */
11578 "rex.RX", /* 0x46 */
11579 "rex.RXB", /* 0x47 */
11580 "rex.W", /* 0x48 */
11581 "rex.WB", /* 0x49 */
11582 "rex.WX", /* 0x4a */
11583 "rex.WXB", /* 0x4b */
11584 "rex.WR", /* 0x4c */
11585 "rex.WRB", /* 0x4d */
11586 "rex.WRX", /* 0x4e */
11587 "rex.WRXB", /* 0x4f */
11592 /* REX prefixes family. */
11609 return rexes [pref - 0x40];
11629 return (sizeflag & DFLAG) ? "data16" : "data32";
11631 if (address_mode == mode_64bit)
11632 return (sizeflag & AFLAG) ? "addr32" : "addr64";
11634 return (sizeflag & AFLAG) ? "addr16" : "addr32";
11637 case ADDR16_PREFIX:
11639 case ADDR32_PREFIX:
11641 case DATA16_PREFIX:
11643 case DATA32_PREFIX:
11652 static char op_out[MAX_OPERANDS][100];
11653 static int op_ad, op_index[MAX_OPERANDS];
11654 static int two_source_ops;
11655 static bfd_vma op_address[MAX_OPERANDS];
11656 static bfd_vma op_riprel[MAX_OPERANDS];
11657 static bfd_vma start_pc;
11660 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
11661 * (see topic "Redundant prefixes" in the "Differences from 8086"
11662 * section of the "Virtual 8086 Mode" chapter.)
11663 * 'pc' should be the address of this instruction, it will
11664 * be used to print the target address if this is a relative jump or call
11665 * The function returns the length of this instruction in bytes.
11668 static char intel_syntax;
11669 static char intel_mnemonic = !SYSV386_COMPAT;
11670 static char open_char;
11671 static char close_char;
11672 static char separator_char;
11673 static char scale_char;
11675 /* Here for backwards compatibility. When gdb stops using
11676 print_insn_i386_att and print_insn_i386_intel these functions can
11677 disappear, and print_insn_i386 be merged into print_insn. */
11679 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
11683 return print_insn (pc, info);
11687 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
11691 return print_insn (pc, info);
11695 print_insn_i386 (bfd_vma pc, disassemble_info *info)
11699 return print_insn (pc, info);
11703 print_i386_disassembler_options (FILE *stream)
11705 fprintf (stream, _("\n\
11706 The following i386/x86-64 specific disassembler options are supported for use\n\
11707 with the -M switch (multiple options should be separated by commas):\n"));
11709 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
11710 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
11711 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
11712 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
11713 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
11714 fprintf (stream, _(" att-mnemonic\n"
11715 " Display instruction in AT&T mnemonic\n"));
11716 fprintf (stream, _(" intel-mnemonic\n"
11717 " Display instruction in Intel mnemonic\n"));
11718 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
11719 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
11720 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
11721 fprintf (stream, _(" data32 Assume 32bit data size\n"));
11722 fprintf (stream, _(" data16 Assume 16bit data size\n"));
11723 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
11726 /* Get a pointer to struct dis386 with a valid name. */
11728 static const struct dis386 *
11729 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
11731 int vindex, vex_table_index;
11733 if (dp->name != NULL)
11736 switch (dp->op[0].bytemode)
11738 case USE_REG_TABLE:
11739 dp = ®_table[dp->op[1].bytemode][modrm.reg];
11742 case USE_MOD_TABLE:
11743 vindex = modrm.mod == 0x3 ? 1 : 0;
11744 dp = &mod_table[dp->op[1].bytemode][vindex];
11748 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
11751 case USE_PREFIX_TABLE:
11754 /* The prefix in VEX is implicit. */
11755 switch (vex.prefix)
11760 case REPE_PREFIX_OPCODE:
11763 case DATA_PREFIX_OPCODE:
11766 case REPNE_PREFIX_OPCODE:
11777 used_prefixes |= (prefixes & PREFIX_REPZ);
11778 if (prefixes & PREFIX_REPZ)
11781 all_prefixes[last_repz_prefix] = 0;
11785 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
11787 used_prefixes |= (prefixes & PREFIX_REPNZ);
11788 if (prefixes & PREFIX_REPNZ)
11791 all_prefixes[last_repnz_prefix] = 0;
11795 used_prefixes |= (prefixes & PREFIX_DATA);
11796 if (prefixes & PREFIX_DATA)
11799 all_prefixes[last_data_prefix] = 0;
11804 dp = &prefix_table[dp->op[1].bytemode][vindex];
11807 case USE_X86_64_TABLE:
11808 vindex = address_mode == mode_64bit ? 1 : 0;
11809 dp = &x86_64_table[dp->op[1].bytemode][vindex];
11812 case USE_3BYTE_TABLE:
11813 FETCH_DATA (info, codep + 2);
11815 dp = &three_byte_table[dp->op[1].bytemode][vindex];
11816 modrm.mod = (*codep >> 6) & 3;
11817 modrm.reg = (*codep >> 3) & 7;
11818 modrm.rm = *codep & 7;
11821 case USE_VEX_LEN_TABLE:
11825 switch (vex.length)
11838 dp = &vex_len_table[dp->op[1].bytemode][vindex];
11841 case USE_XOP_8F_TABLE:
11842 FETCH_DATA (info, codep + 3);
11843 /* All bits in the REX prefix are ignored. */
11845 rex = ~(*codep >> 5) & 0x7;
11847 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
11848 switch ((*codep & 0x1f))
11853 vex_table_index = XOP_08;
11856 vex_table_index = XOP_09;
11859 vex_table_index = XOP_0A;
11863 vex.w = *codep & 0x80;
11864 if (vex.w && address_mode == mode_64bit)
11867 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11868 if (address_mode != mode_64bit
11869 && vex.register_specifier > 0x7)
11872 vex.length = (*codep & 0x4) ? 256 : 128;
11873 switch ((*codep & 0x3))
11879 vex.prefix = DATA_PREFIX_OPCODE;
11882 vex.prefix = REPE_PREFIX_OPCODE;
11885 vex.prefix = REPNE_PREFIX_OPCODE;
11892 dp = &xop_table[vex_table_index][vindex];
11894 FETCH_DATA (info, codep + 1);
11895 modrm.mod = (*codep >> 6) & 3;
11896 modrm.reg = (*codep >> 3) & 7;
11897 modrm.rm = *codep & 7;
11900 case USE_VEX_C4_TABLE:
11901 FETCH_DATA (info, codep + 3);
11902 /* All bits in the REX prefix are ignored. */
11904 rex = ~(*codep >> 5) & 0x7;
11905 switch ((*codep & 0x1f))
11910 vex_table_index = VEX_0F;
11913 vex_table_index = VEX_0F38;
11916 vex_table_index = VEX_0F3A;
11920 vex.w = *codep & 0x80;
11921 if (vex.w && address_mode == mode_64bit)
11924 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11925 if (address_mode != mode_64bit
11926 && vex.register_specifier > 0x7)
11929 vex.length = (*codep & 0x4) ? 256 : 128;
11930 switch ((*codep & 0x3))
11936 vex.prefix = DATA_PREFIX_OPCODE;
11939 vex.prefix = REPE_PREFIX_OPCODE;
11942 vex.prefix = REPNE_PREFIX_OPCODE;
11949 dp = &vex_table[vex_table_index][vindex];
11950 /* There is no MODRM byte for VEX [82|77]. */
11951 if (vindex != 0x77 && vindex != 0x82)
11953 FETCH_DATA (info, codep + 1);
11954 modrm.mod = (*codep >> 6) & 3;
11955 modrm.reg = (*codep >> 3) & 7;
11956 modrm.rm = *codep & 7;
11960 case USE_VEX_C5_TABLE:
11961 FETCH_DATA (info, codep + 2);
11962 /* All bits in the REX prefix are ignored. */
11964 rex = (*codep & 0x80) ? 0 : REX_R;
11966 vex.register_specifier = (~(*codep >> 3)) & 0xf;
11967 if (address_mode != mode_64bit
11968 && vex.register_specifier > 0x7)
11973 vex.length = (*codep & 0x4) ? 256 : 128;
11974 switch ((*codep & 0x3))
11980 vex.prefix = DATA_PREFIX_OPCODE;
11983 vex.prefix = REPE_PREFIX_OPCODE;
11986 vex.prefix = REPNE_PREFIX_OPCODE;
11993 dp = &vex_table[dp->op[1].bytemode][vindex];
11994 /* There is no MODRM byte for VEX [82|77]. */
11995 if (vindex != 0x77 && vindex != 0x82)
11997 FETCH_DATA (info, codep + 1);
11998 modrm.mod = (*codep >> 6) & 3;
11999 modrm.reg = (*codep >> 3) & 7;
12000 modrm.rm = *codep & 7;
12004 case USE_VEX_W_TABLE:
12008 dp = &vex_w_table[dp->op[1].bytemode][vex.w ? 1 : 0];
12015 if (dp->name != NULL)
12018 return get_valid_dis386 (dp, info);
12022 print_insn (bfd_vma pc, disassemble_info *info)
12024 const struct dis386 *dp;
12026 char *op_txt[MAX_OPERANDS];
12030 struct dis_private priv;
12033 int default_prefixes;
12035 if (info->mach == bfd_mach_x86_64_intel_syntax
12036 || info->mach == bfd_mach_x86_64
12037 || info->mach == bfd_mach_l1om
12038 || info->mach == bfd_mach_l1om_intel_syntax)
12039 address_mode = mode_64bit;
12041 address_mode = mode_32bit;
12043 if (intel_syntax == (char) -1)
12044 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
12045 || info->mach == bfd_mach_x86_64_intel_syntax
12046 || info->mach == bfd_mach_l1om_intel_syntax);
12048 if (info->mach == bfd_mach_i386_i386
12049 || info->mach == bfd_mach_x86_64
12050 || info->mach == bfd_mach_l1om
12051 || info->mach == bfd_mach_i386_i386_intel_syntax
12052 || info->mach == bfd_mach_x86_64_intel_syntax
12053 || info->mach == bfd_mach_l1om_intel_syntax)
12054 priv.orig_sizeflag = AFLAG | DFLAG;
12055 else if (info->mach == bfd_mach_i386_i8086)
12056 priv.orig_sizeflag = 0;
12060 for (p = info->disassembler_options; p != NULL; )
12062 if (CONST_STRNEQ (p, "x86-64"))
12064 address_mode = mode_64bit;
12065 priv.orig_sizeflag = AFLAG | DFLAG;
12067 else if (CONST_STRNEQ (p, "i386"))
12069 address_mode = mode_32bit;
12070 priv.orig_sizeflag = AFLAG | DFLAG;
12072 else if (CONST_STRNEQ (p, "i8086"))
12074 address_mode = mode_16bit;
12075 priv.orig_sizeflag = 0;
12077 else if (CONST_STRNEQ (p, "intel"))
12080 if (CONST_STRNEQ (p + 5, "-mnemonic"))
12081 intel_mnemonic = 1;
12083 else if (CONST_STRNEQ (p, "att"))
12086 if (CONST_STRNEQ (p + 3, "-mnemonic"))
12087 intel_mnemonic = 0;
12089 else if (CONST_STRNEQ (p, "addr"))
12091 if (address_mode == mode_64bit)
12093 if (p[4] == '3' && p[5] == '2')
12094 priv.orig_sizeflag &= ~AFLAG;
12095 else if (p[4] == '6' && p[5] == '4')
12096 priv.orig_sizeflag |= AFLAG;
12100 if (p[4] == '1' && p[5] == '6')
12101 priv.orig_sizeflag &= ~AFLAG;
12102 else if (p[4] == '3' && p[5] == '2')
12103 priv.orig_sizeflag |= AFLAG;
12106 else if (CONST_STRNEQ (p, "data"))
12108 if (p[4] == '1' && p[5] == '6')
12109 priv.orig_sizeflag &= ~DFLAG;
12110 else if (p[4] == '3' && p[5] == '2')
12111 priv.orig_sizeflag |= DFLAG;
12113 else if (CONST_STRNEQ (p, "suffix"))
12114 priv.orig_sizeflag |= SUFFIX_ALWAYS;
12116 p = strchr (p, ',');
12123 names64 = intel_names64;
12124 names32 = intel_names32;
12125 names16 = intel_names16;
12126 names8 = intel_names8;
12127 names8rex = intel_names8rex;
12128 names_seg = intel_names_seg;
12129 index64 = intel_index64;
12130 index32 = intel_index32;
12131 index16 = intel_index16;
12134 separator_char = '+';
12139 names64 = att_names64;
12140 names32 = att_names32;
12141 names16 = att_names16;
12142 names8 = att_names8;
12143 names8rex = att_names8rex;
12144 names_seg = att_names_seg;
12145 index64 = att_index64;
12146 index32 = att_index32;
12147 index16 = att_index16;
12150 separator_char = ',';
12154 /* The output looks better if we put 7 bytes on a line, since that
12155 puts most long word instructions on a single line. Use 8 bytes
12157 if (info->mach == bfd_mach_l1om
12158 || info->mach == bfd_mach_l1om_intel_syntax)
12159 info->bytes_per_line = 8;
12161 info->bytes_per_line = 7;
12163 info->private_data = &priv;
12164 priv.max_fetched = priv.the_buffer;
12165 priv.insn_start = pc;
12168 for (i = 0; i < MAX_OPERANDS; ++i)
12176 start_codep = priv.the_buffer;
12177 codep = priv.the_buffer;
12179 if (setjmp (priv.bailout) != 0)
12183 /* Getting here means we tried for data but didn't get it. That
12184 means we have an incomplete instruction of some sort. Just
12185 print the first byte as a prefix or a .byte pseudo-op. */
12186 if (codep > priv.the_buffer)
12188 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
12190 (*info->fprintf_func) (info->stream, "%s", name);
12193 /* Just print the first byte as a .byte instruction. */
12194 (*info->fprintf_func) (info->stream, ".byte 0x%x",
12195 (unsigned int) priv.the_buffer[0]);
12205 sizeflag = priv.orig_sizeflag;
12207 if (!ckprefix () || rex_used)
12209 /* Too many prefixes or unused REX prefixes. */
12211 all_prefixes[i] && i < (int) ARRAY_SIZE (all_prefixes);
12213 (*info->fprintf_func) (info->stream, "%s",
12214 prefix_name (all_prefixes[i], sizeflag));
12218 insn_codep = codep;
12220 FETCH_DATA (info, codep + 1);
12221 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
12223 if (((prefixes & PREFIX_FWAIT)
12224 && ((*codep < 0xd8) || (*codep > 0xdf))))
12226 (*info->fprintf_func) (info->stream, "fwait");
12232 if (*codep == 0x0f)
12234 unsigned char threebyte;
12235 FETCH_DATA (info, codep + 2);
12236 threebyte = *++codep;
12237 dp = &dis386_twobyte[threebyte];
12238 need_modrm = twobyte_has_modrm[*codep];
12243 dp = &dis386[*codep];
12244 need_modrm = onebyte_has_modrm[*codep];
12248 if ((prefixes & PREFIX_REPZ))
12249 used_prefixes |= PREFIX_REPZ;
12250 if ((prefixes & PREFIX_REPNZ))
12251 used_prefixes |= PREFIX_REPNZ;
12252 if ((prefixes & PREFIX_LOCK))
12253 used_prefixes |= PREFIX_LOCK;
12255 default_prefixes = 0;
12256 if (prefixes & PREFIX_ADDR)
12259 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
12261 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12262 all_prefixes[last_addr_prefix] = ADDR32_PREFIX;
12264 all_prefixes[last_addr_prefix] = ADDR16_PREFIX;
12265 default_prefixes |= PREFIX_ADDR;
12269 if ((prefixes & PREFIX_DATA))
12272 if (dp->op[2].bytemode == cond_jump_mode
12273 && dp->op[0].bytemode == v_mode
12276 if (sizeflag & DFLAG)
12277 all_prefixes[last_data_prefix] = DATA32_PREFIX;
12279 all_prefixes[last_data_prefix] = DATA16_PREFIX;
12280 default_prefixes |= PREFIX_DATA;
12282 else if (rex & REX_W)
12284 /* REX_W will override PREFIX_DATA. */
12285 default_prefixes |= PREFIX_DATA;
12291 FETCH_DATA (info, codep + 1);
12292 modrm.mod = (*codep >> 6) & 3;
12293 modrm.reg = (*codep >> 3) & 7;
12294 modrm.rm = *codep & 7;
12301 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
12303 dofloat (sizeflag);
12307 dp = get_valid_dis386 (dp, info);
12308 if (dp != NULL && putop (dp->name, sizeflag) == 0)
12310 for (i = 0; i < MAX_OPERANDS; ++i)
12313 op_ad = MAX_OPERANDS - 1 - i;
12315 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
12320 /* See if any prefixes were not used. If so, print the first one
12321 separately. If we don't do this, we'll wind up printing an
12322 instruction stream which does not precisely correspond to the
12323 bytes we are disassembling. */
12324 if ((prefixes & ~(used_prefixes | default_prefixes)) != 0)
12326 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12327 if (all_prefixes[i])
12330 name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
12332 name = INTERNAL_DISASSEMBLER_ERROR;
12333 (*info->fprintf_func) (info->stream, "%s", name);
12338 /* Check if the REX prefix is used. */
12339 if (rex_ignored == 0 && (rex ^ rex_used) == 0)
12340 all_prefixes[last_rex_prefix] = 0;
12342 /* Check if the SEG prefix is used. */
12343 if ((prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
12344 | PREFIX_FS | PREFIX_GS)) != 0
12346 & seg_prefix (all_prefixes[last_seg_prefix])) != 0)
12347 all_prefixes[last_seg_prefix] = 0;
12349 /* Check if the ADDR prefix is used. */
12350 if ((prefixes & PREFIX_ADDR) != 0
12351 && (used_prefixes & PREFIX_ADDR) != 0)
12352 all_prefixes[last_addr_prefix] = 0;
12354 /* Check if the DATA prefix is used. */
12355 if ((prefixes & PREFIX_DATA) != 0
12356 && (used_prefixes & PREFIX_DATA) != 0)
12357 all_prefixes[last_data_prefix] = 0;
12360 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
12361 if (all_prefixes[i])
12364 name = prefix_name (all_prefixes[i], sizeflag);
12367 prefix_length += strlen (name) + 1;
12368 (*info->fprintf_func) (info->stream, "%s ", name);
12371 /* Check maximum code length. */
12372 if ((codep - start_codep) > MAX_CODE_LENGTH)
12374 (*info->fprintf_func) (info->stream, "(bad)");
12375 return MAX_CODE_LENGTH;
12378 obufp = mnemonicendp;
12379 for (i = strlen (obuf) + prefix_length; i < 6; i++)
12382 (*info->fprintf_func) (info->stream, "%s", obuf);
12384 /* The enter and bound instructions are printed with operands in the same
12385 order as the intel book; everything else is printed in reverse order. */
12386 if (intel_syntax || two_source_ops)
12390 for (i = 0; i < MAX_OPERANDS; ++i)
12391 op_txt[i] = op_out[i];
12393 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
12395 op_ad = op_index[i];
12396 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
12397 op_index[MAX_OPERANDS - 1 - i] = op_ad;
12398 riprel = op_riprel[i];
12399 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
12400 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
12405 for (i = 0; i < MAX_OPERANDS; ++i)
12406 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
12410 for (i = 0; i < MAX_OPERANDS; ++i)
12414 (*info->fprintf_func) (info->stream, ",");
12415 if (op_index[i] != -1 && !op_riprel[i])
12416 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
12418 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
12422 for (i = 0; i < MAX_OPERANDS; i++)
12423 if (op_index[i] != -1 && op_riprel[i])
12425 (*info->fprintf_func) (info->stream, " # ");
12426 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
12427 + op_address[op_index[i]]), info);
12430 return codep - priv.the_buffer;
12433 static const char *float_mem[] = {
12508 static const unsigned char float_mem_mode[] = {
12583 #define ST { OP_ST, 0 }
12584 #define STi { OP_STi, 0 }
12586 #define FGRPd9_2 NULL, { { NULL, 0 } }
12587 #define FGRPd9_4 NULL, { { NULL, 1 } }
12588 #define FGRPd9_5 NULL, { { NULL, 2 } }
12589 #define FGRPd9_6 NULL, { { NULL, 3 } }
12590 #define FGRPd9_7 NULL, { { NULL, 4 } }
12591 #define FGRPda_5 NULL, { { NULL, 5 } }
12592 #define FGRPdb_4 NULL, { { NULL, 6 } }
12593 #define FGRPde_3 NULL, { { NULL, 7 } }
12594 #define FGRPdf_4 NULL, { { NULL, 8 } }
12596 static const struct dis386 float_reg[][8] = {
12599 { "fadd", { ST, STi } },
12600 { "fmul", { ST, STi } },
12601 { "fcom", { STi } },
12602 { "fcomp", { STi } },
12603 { "fsub", { ST, STi } },
12604 { "fsubr", { ST, STi } },
12605 { "fdiv", { ST, STi } },
12606 { "fdivr", { ST, STi } },
12610 { "fld", { STi } },
12611 { "fxch", { STi } },
12613 { "(bad)", { XX } },
12621 { "fcmovb", { ST, STi } },
12622 { "fcmove", { ST, STi } },
12623 { "fcmovbe",{ ST, STi } },
12624 { "fcmovu", { ST, STi } },
12625 { "(bad)", { XX } },
12627 { "(bad)", { XX } },
12628 { "(bad)", { XX } },
12632 { "fcmovnb",{ ST, STi } },
12633 { "fcmovne",{ ST, STi } },
12634 { "fcmovnbe",{ ST, STi } },
12635 { "fcmovnu",{ ST, STi } },
12637 { "fucomi", { ST, STi } },
12638 { "fcomi", { ST, STi } },
12639 { "(bad)", { XX } },
12643 { "fadd", { STi, ST } },
12644 { "fmul", { STi, ST } },
12645 { "(bad)", { XX } },
12646 { "(bad)", { XX } },
12647 { "fsub!M", { STi, ST } },
12648 { "fsubM", { STi, ST } },
12649 { "fdiv!M", { STi, ST } },
12650 { "fdivM", { STi, ST } },
12654 { "ffree", { STi } },
12655 { "(bad)", { XX } },
12656 { "fst", { STi } },
12657 { "fstp", { STi } },
12658 { "fucom", { STi } },
12659 { "fucomp", { STi } },
12660 { "(bad)", { XX } },
12661 { "(bad)", { XX } },
12665 { "faddp", { STi, ST } },
12666 { "fmulp", { STi, ST } },
12667 { "(bad)", { XX } },
12669 { "fsub!Mp", { STi, ST } },
12670 { "fsubMp", { STi, ST } },
12671 { "fdiv!Mp", { STi, ST } },
12672 { "fdivMp", { STi, ST } },
12676 { "ffreep", { STi } },
12677 { "(bad)", { XX } },
12678 { "(bad)", { XX } },
12679 { "(bad)", { XX } },
12681 { "fucomip", { ST, STi } },
12682 { "fcomip", { ST, STi } },
12683 { "(bad)", { XX } },
12687 static char *fgrps[][8] = {
12690 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12695 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
12700 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
12705 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
12710 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
12715 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12720 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
12721 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
12726 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12731 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
12736 swap_operand (void)
12738 mnemonicendp[0] = '.';
12739 mnemonicendp[1] = 's';
12744 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
12745 int sizeflag ATTRIBUTE_UNUSED)
12747 /* Skip mod/rm byte. */
12753 dofloat (int sizeflag)
12755 const struct dis386 *dp;
12756 unsigned char floatop;
12758 floatop = codep[-1];
12760 if (modrm.mod != 3)
12762 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
12764 putop (float_mem[fp_indx], sizeflag);
12767 OP_E (float_mem_mode[fp_indx], sizeflag);
12770 /* Skip mod/rm byte. */
12774 dp = &float_reg[floatop - 0xd8][modrm.reg];
12775 if (dp->name == NULL)
12777 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
12779 /* Instruction fnstsw is only one with strange arg. */
12780 if (floatop == 0xdf && codep[-1] == 0xe0)
12781 strcpy (op_out[0], names16[0]);
12785 putop (dp->name, sizeflag);
12790 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
12795 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
12800 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12802 oappend ("%st" + intel_syntax);
12806 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12808 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
12809 oappend (scratchbuf + intel_syntax);
12812 /* Capital letters in template are macros. */
12814 putop (const char *in_template, int sizeflag)
12819 unsigned int l = 0, len = 1;
12822 #define SAVE_LAST(c) \
12823 if (l < len && l < sizeof (last)) \
12828 for (p = in_template; *p; p++)
12845 while (*++p != '|')
12846 if (*p == '}' || *p == '\0')
12849 /* Fall through. */
12854 while (*++p != '}')
12865 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
12869 if (l == 0 && len == 1)
12874 if (sizeflag & SUFFIX_ALWAYS)
12887 if (address_mode == mode_64bit
12888 && !(prefixes & PREFIX_ADDR))
12899 if (intel_syntax && !alt)
12901 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
12903 if (sizeflag & DFLAG)
12904 *obufp++ = intel_syntax ? 'd' : 'l';
12906 *obufp++ = intel_syntax ? 'w' : 's';
12907 used_prefixes |= (prefixes & PREFIX_DATA);
12911 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
12914 if (modrm.mod == 3)
12920 if (sizeflag & DFLAG)
12921 *obufp++ = intel_syntax ? 'd' : 'l';
12924 used_prefixes |= (prefixes & PREFIX_DATA);
12930 case 'E': /* For jcxz/jecxz */
12931 if (address_mode == mode_64bit)
12933 if (sizeflag & AFLAG)
12939 if (sizeflag & AFLAG)
12941 used_prefixes |= (prefixes & PREFIX_ADDR);
12946 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
12948 if (sizeflag & AFLAG)
12949 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
12951 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
12952 used_prefixes |= (prefixes & PREFIX_ADDR);
12956 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
12958 if ((rex & REX_W) || (sizeflag & DFLAG))
12962 if (!(rex & REX_W))
12963 used_prefixes |= (prefixes & PREFIX_DATA);
12968 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
12969 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
12971 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
12974 if (prefixes & PREFIX_DS)
12995 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
13000 /* Fall through. */
13003 if (l != 0 || len != 1)
13011 if (sizeflag & SUFFIX_ALWAYS)
13015 if (intel_mnemonic != cond)
13019 if ((prefixes & PREFIX_FWAIT) == 0)
13022 used_prefixes |= PREFIX_FWAIT;
13028 else if (intel_syntax && (sizeflag & DFLAG))
13032 if (!(rex & REX_W))
13033 used_prefixes |= (prefixes & PREFIX_DATA);
13038 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13043 /* Fall through. */
13047 if ((prefixes & PREFIX_DATA)
13049 || (sizeflag & SUFFIX_ALWAYS))
13056 if (sizeflag & DFLAG)
13060 used_prefixes |= (prefixes & PREFIX_DATA);
13067 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13069 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13073 /* Fall through. */
13076 if (l == 0 && len == 1)
13079 if (intel_syntax && !alt)
13082 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
13088 if (sizeflag & DFLAG)
13089 *obufp++ = intel_syntax ? 'd' : 'l';
13092 used_prefixes |= (prefixes & PREFIX_DATA);
13098 if (l != 1 || len != 2 || last[0] != 'L')
13104 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13119 else if (sizeflag & DFLAG)
13128 if (intel_syntax && !p[1]
13129 && ((rex & REX_W) || (sizeflag & DFLAG)))
13131 if (!(rex & REX_W))
13132 used_prefixes |= (prefixes & PREFIX_DATA);
13135 if (l == 0 && len == 1)
13139 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13141 if (sizeflag & SUFFIX_ALWAYS)
13163 /* Fall through. */
13166 if (l == 0 && len == 1)
13171 if (sizeflag & SUFFIX_ALWAYS)
13177 if (sizeflag & DFLAG)
13181 used_prefixes |= (prefixes & PREFIX_DATA);
13195 if (address_mode == mode_64bit
13196 && !(prefixes & PREFIX_ADDR))
13207 if (l != 0 || len != 1)
13212 if (need_vex && vex.prefix)
13214 if (vex.prefix == DATA_PREFIX_OPCODE)
13221 if (prefixes & PREFIX_DATA)
13225 used_prefixes |= (prefixes & PREFIX_DATA);
13229 if (l == 0 && len == 1)
13231 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
13242 if (l != 1 || len != 2 || last[0] != 'X')
13250 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
13252 switch (vex.length)
13266 if (l == 0 && len == 1)
13268 /* operand size flag for cwtl, cbtw */
13277 else if (sizeflag & DFLAG)
13281 if (!(rex & REX_W))
13282 used_prefixes |= (prefixes & PREFIX_DATA);
13286 if (l != 1 || len != 2 || last[0] != 'X')
13293 *obufp++ = vex.w ? 'd': 's';
13300 mnemonicendp = obufp;
13305 oappend (const char *s)
13307 obufp = stpcpy (obufp, s);
13313 if (prefixes & PREFIX_CS)
13315 used_prefixes |= PREFIX_CS;
13316 oappend ("%cs:" + intel_syntax);
13318 if (prefixes & PREFIX_DS)
13320 used_prefixes |= PREFIX_DS;
13321 oappend ("%ds:" + intel_syntax);
13323 if (prefixes & PREFIX_SS)
13325 used_prefixes |= PREFIX_SS;
13326 oappend ("%ss:" + intel_syntax);
13328 if (prefixes & PREFIX_ES)
13330 used_prefixes |= PREFIX_ES;
13331 oappend ("%es:" + intel_syntax);
13333 if (prefixes & PREFIX_FS)
13335 used_prefixes |= PREFIX_FS;
13336 oappend ("%fs:" + intel_syntax);
13338 if (prefixes & PREFIX_GS)
13340 used_prefixes |= PREFIX_GS;
13341 oappend ("%gs:" + intel_syntax);
13346 OP_indirE (int bytemode, int sizeflag)
13350 OP_E (bytemode, sizeflag);
13354 print_operand_value (char *buf, int hex, bfd_vma disp)
13356 if (address_mode == mode_64bit)
13364 sprintf_vma (tmp, disp);
13365 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
13366 strcpy (buf + 2, tmp + i);
13370 bfd_signed_vma v = disp;
13377 /* Check for possible overflow on 0x8000000000000000. */
13380 strcpy (buf, "9223372036854775808");
13394 tmp[28 - i] = (v % 10) + '0';
13398 strcpy (buf, tmp + 29 - i);
13404 sprintf (buf, "0x%x", (unsigned int) disp);
13406 sprintf (buf, "%d", (int) disp);
13410 /* Put DISP in BUF as signed hex number. */
13413 print_displacement (char *buf, bfd_vma disp)
13415 bfd_signed_vma val = disp;
13424 /* Check for possible overflow. */
13427 switch (address_mode)
13430 strcpy (buf + j, "0x8000000000000000");
13433 strcpy (buf + j, "0x80000000");
13436 strcpy (buf + j, "0x8000");
13446 sprintf_vma (tmp, (bfd_vma) val);
13447 for (i = 0; tmp[i] == '0'; i++)
13449 if (tmp[i] == '\0')
13451 strcpy (buf + j, tmp + i);
13455 intel_operand_size (int bytemode, int sizeflag)
13462 oappend ("BYTE PTR ");
13466 oappend ("WORD PTR ");
13469 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13471 oappend ("QWORD PTR ");
13480 oappend ("QWORD PTR ");
13483 if ((sizeflag & DFLAG) || bytemode == dq_mode)
13484 oappend ("DWORD PTR ");
13486 oappend ("WORD PTR ");
13487 used_prefixes |= (prefixes & PREFIX_DATA);
13491 if ((rex & REX_W) || (sizeflag & DFLAG))
13493 oappend ("WORD PTR ");
13494 if (!(rex & REX_W))
13495 used_prefixes |= (prefixes & PREFIX_DATA);
13498 if (sizeflag & DFLAG)
13499 oappend ("QWORD PTR ");
13501 oappend ("DWORD PTR ");
13502 used_prefixes |= (prefixes & PREFIX_DATA);
13507 oappend ("DWORD PTR ");
13511 oappend ("QWORD PTR ");
13514 if (address_mode == mode_64bit)
13515 oappend ("QWORD PTR ");
13517 oappend ("DWORD PTR ");
13520 if (sizeflag & DFLAG)
13521 oappend ("FWORD PTR ");
13523 oappend ("DWORD PTR ");
13524 used_prefixes |= (prefixes & PREFIX_DATA);
13527 oappend ("TBYTE PTR ");
13533 switch (vex.length)
13536 oappend ("XMMWORD PTR ");
13539 oappend ("YMMWORD PTR ");
13546 oappend ("XMMWORD PTR ");
13549 oappend ("XMMWORD PTR ");
13555 switch (vex.length)
13558 oappend ("QWORD PTR ");
13561 oappend ("XMMWORD PTR ");
13571 switch (vex.length)
13574 oappend ("QWORD PTR ");
13577 oappend ("YMMWORD PTR ");
13584 oappend ("OWORD PTR ");
13586 case vex_w_dq_mode:
13591 oappend ("QWORD PTR ");
13593 oappend ("DWORD PTR ");
13601 OP_E_register (int bytemode, int sizeflag)
13603 int reg = modrm.rm;
13604 const char **names;
13610 if ((sizeflag & SUFFIX_ALWAYS)
13611 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
13634 names = address_mode == mode_64bit ? names64 : names32;
13637 if (address_mode == mode_64bit && (sizeflag & DFLAG))
13655 if ((sizeflag & DFLAG)
13656 || (bytemode != v_mode
13657 && bytemode != v_swap_mode))
13661 used_prefixes |= (prefixes & PREFIX_DATA);
13667 oappend (INTERNAL_DISASSEMBLER_ERROR);
13670 oappend (names[reg]);
13674 OP_E_memory (int bytemode, int sizeflag)
13677 int add = (rex & REX_B) ? 8 : 0;
13682 intel_operand_size (bytemode, sizeflag);
13685 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13687 /* 32/64 bit address mode */
13705 FETCH_DATA (the_info, codep + 1);
13706 vindex = (*codep >> 3) & 7;
13707 scale = (*codep >> 6) & 3;
13712 haveindex = vindex != 4;
13715 rbase = base + add;
13723 if (address_mode == mode_64bit && !havesib)
13729 FETCH_DATA (the_info, codep + 1);
13731 if ((disp & 0x80) != 0)
13739 /* In 32bit mode, we need index register to tell [offset] from
13740 [eiz*1 + offset]. */
13741 needindex = (havesib
13744 && address_mode == mode_32bit);
13745 havedisp = (havebase
13747 || (havesib && (haveindex || scale != 0)));
13750 if (modrm.mod != 0 || base == 5)
13752 if (havedisp || riprel)
13753 print_displacement (scratchbuf, disp);
13755 print_operand_value (scratchbuf, 1, disp);
13756 oappend (scratchbuf);
13760 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
13764 if (havebase || haveindex || riprel)
13765 used_prefixes |= PREFIX_ADDR;
13767 if (havedisp || (intel_syntax && riprel))
13769 *obufp++ = open_char;
13770 if (intel_syntax && riprel)
13773 oappend (sizeflag & AFLAG ? "rip" : "eip");
13777 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
13778 ? names64[rbase] : names32[rbase]);
13781 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
13782 print index to tell base + index from base. */
13786 || (havebase && base != ESP_REG_NUM))
13788 if (!intel_syntax || havebase)
13790 *obufp++ = separator_char;
13794 oappend (address_mode == mode_64bit
13795 && (sizeflag & AFLAG)
13796 ? names64[vindex] : names32[vindex]);
13798 oappend (address_mode == mode_64bit
13799 && (sizeflag & AFLAG)
13800 ? index64 : index32);
13802 *obufp++ = scale_char;
13804 sprintf (scratchbuf, "%d", 1 << scale);
13805 oappend (scratchbuf);
13809 && (disp || modrm.mod != 0 || base == 5))
13811 if (!havedisp || (bfd_signed_vma) disp >= 0)
13816 else if (modrm.mod != 1 && disp != -disp)
13820 disp = - (bfd_signed_vma) disp;
13824 print_displacement (scratchbuf, disp);
13826 print_operand_value (scratchbuf, 1, disp);
13827 oappend (scratchbuf);
13830 *obufp++ = close_char;
13833 else if (intel_syntax)
13835 if (modrm.mod != 0 || base == 5)
13837 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13838 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13842 oappend (names_seg[ds_reg - es_reg]);
13845 print_operand_value (scratchbuf, 1, disp);
13846 oappend (scratchbuf);
13852 /* 16 bit address mode */
13853 used_prefixes |= prefixes & PREFIX_ADDR;
13860 if ((disp & 0x8000) != 0)
13865 FETCH_DATA (the_info, codep + 1);
13867 if ((disp & 0x80) != 0)
13872 if ((disp & 0x8000) != 0)
13878 if (modrm.mod != 0 || modrm.rm == 6)
13880 print_displacement (scratchbuf, disp);
13881 oappend (scratchbuf);
13884 if (modrm.mod != 0 || modrm.rm != 6)
13886 *obufp++ = open_char;
13888 oappend (index16[modrm.rm]);
13890 && (disp || modrm.mod != 0 || modrm.rm == 6))
13892 if ((bfd_signed_vma) disp >= 0)
13897 else if (modrm.mod != 1)
13901 disp = - (bfd_signed_vma) disp;
13904 print_displacement (scratchbuf, disp);
13905 oappend (scratchbuf);
13908 *obufp++ = close_char;
13911 else if (intel_syntax)
13913 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
13914 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
13918 oappend (names_seg[ds_reg - es_reg]);
13921 print_operand_value (scratchbuf, 1, disp & 0xffff);
13922 oappend (scratchbuf);
13928 OP_E (int bytemode, int sizeflag)
13930 /* Skip mod/rm byte. */
13934 if (modrm.mod == 3)
13935 OP_E_register (bytemode, sizeflag);
13937 OP_E_memory (bytemode, sizeflag);
13941 OP_G (int bytemode, int sizeflag)
13952 oappend (names8rex[modrm.reg + add]);
13954 oappend (names8[modrm.reg + add]);
13957 oappend (names16[modrm.reg + add]);
13960 oappend (names32[modrm.reg + add]);
13963 oappend (names64[modrm.reg + add]);
13972 oappend (names64[modrm.reg + add]);
13975 if ((sizeflag & DFLAG) || bytemode != v_mode)
13976 oappend (names32[modrm.reg + add]);
13978 oappend (names16[modrm.reg + add]);
13979 used_prefixes |= (prefixes & PREFIX_DATA);
13983 if (address_mode == mode_64bit)
13984 oappend (names64[modrm.reg + add]);
13986 oappend (names32[modrm.reg + add]);
13989 oappend (INTERNAL_DISASSEMBLER_ERROR);
14002 FETCH_DATA (the_info, codep + 8);
14003 a = *codep++ & 0xff;
14004 a |= (*codep++ & 0xff) << 8;
14005 a |= (*codep++ & 0xff) << 16;
14006 a |= (*codep++ & 0xff) << 24;
14007 b = *codep++ & 0xff;
14008 b |= (*codep++ & 0xff) << 8;
14009 b |= (*codep++ & 0xff) << 16;
14010 b |= (*codep++ & 0xff) << 24;
14011 x = a + ((bfd_vma) b << 32);
14019 static bfd_signed_vma
14022 bfd_signed_vma x = 0;
14024 FETCH_DATA (the_info, codep + 4);
14025 x = *codep++ & (bfd_signed_vma) 0xff;
14026 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14027 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14028 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14032 static bfd_signed_vma
14035 bfd_signed_vma x = 0;
14037 FETCH_DATA (the_info, codep + 4);
14038 x = *codep++ & (bfd_signed_vma) 0xff;
14039 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
14040 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
14041 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
14043 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
14053 FETCH_DATA (the_info, codep + 2);
14054 x = *codep++ & 0xff;
14055 x |= (*codep++ & 0xff) << 8;
14060 set_op (bfd_vma op, int riprel)
14062 op_index[op_ad] = op_ad;
14063 if (address_mode == mode_64bit)
14065 op_address[op_ad] = op;
14066 op_riprel[op_ad] = riprel;
14070 /* Mask to get a 32-bit address. */
14071 op_address[op_ad] = op & 0xffffffff;
14072 op_riprel[op_ad] = riprel & 0xffffffff;
14077 OP_REG (int code, int sizeflag)
14089 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14090 case sp_reg: case bp_reg: case si_reg: case di_reg:
14091 s = names16[code - ax_reg + add];
14093 case es_reg: case ss_reg: case cs_reg:
14094 case ds_reg: case fs_reg: case gs_reg:
14095 s = names_seg[code - es_reg + add];
14097 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14098 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14101 s = names8rex[code - al_reg + add];
14103 s = names8[code - al_reg];
14105 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
14106 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
14107 if (address_mode == mode_64bit && (sizeflag & DFLAG))
14109 s = names64[code - rAX_reg + add];
14112 code += eAX_reg - rAX_reg;
14113 /* Fall through. */
14114 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14115 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14118 s = names64[code - eAX_reg + add];
14121 if (sizeflag & DFLAG)
14122 s = names32[code - eAX_reg + add];
14124 s = names16[code - eAX_reg + add];
14125 used_prefixes |= (prefixes & PREFIX_DATA);
14129 s = INTERNAL_DISASSEMBLER_ERROR;
14136 OP_IMREG (int code, int sizeflag)
14148 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
14149 case sp_reg: case bp_reg: case si_reg: case di_reg:
14150 s = names16[code - ax_reg];
14152 case es_reg: case ss_reg: case cs_reg:
14153 case ds_reg: case fs_reg: case gs_reg:
14154 s = names_seg[code - es_reg];
14156 case al_reg: case ah_reg: case cl_reg: case ch_reg:
14157 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
14160 s = names8rex[code - al_reg];
14162 s = names8[code - al_reg];
14164 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
14165 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
14168 s = names64[code - eAX_reg];
14171 if (sizeflag & DFLAG)
14172 s = names32[code - eAX_reg];
14174 s = names16[code - eAX_reg];
14175 used_prefixes |= (prefixes & PREFIX_DATA);
14178 case z_mode_ax_reg:
14179 if ((rex & REX_W) || (sizeflag & DFLAG))
14183 if (!(rex & REX_W))
14184 used_prefixes |= (prefixes & PREFIX_DATA);
14187 s = INTERNAL_DISASSEMBLER_ERROR;
14194 OP_I (int bytemode, int sizeflag)
14197 bfd_signed_vma mask = -1;
14202 FETCH_DATA (the_info, codep + 1);
14207 if (address_mode == mode_64bit)
14212 /* Fall through. */
14219 if (sizeflag & DFLAG)
14229 used_prefixes |= (prefixes & PREFIX_DATA);
14241 oappend (INTERNAL_DISASSEMBLER_ERROR);
14246 scratchbuf[0] = '$';
14247 print_operand_value (scratchbuf + 1, 1, op);
14248 oappend (scratchbuf + intel_syntax);
14249 scratchbuf[0] = '\0';
14253 OP_I64 (int bytemode, int sizeflag)
14256 bfd_signed_vma mask = -1;
14258 if (address_mode != mode_64bit)
14260 OP_I (bytemode, sizeflag);
14267 FETCH_DATA (the_info, codep + 1);
14277 if (sizeflag & DFLAG)
14287 used_prefixes |= (prefixes & PREFIX_DATA);
14295 oappend (INTERNAL_DISASSEMBLER_ERROR);
14300 scratchbuf[0] = '$';
14301 print_operand_value (scratchbuf + 1, 1, op);
14302 oappend (scratchbuf + intel_syntax);
14303 scratchbuf[0] = '\0';
14307 OP_sI (int bytemode, int sizeflag)
14310 bfd_signed_vma mask = -1;
14315 FETCH_DATA (the_info, codep + 1);
14317 if ((op & 0x80) != 0)
14327 if (sizeflag & DFLAG)
14336 if ((op & 0x8000) != 0)
14339 used_prefixes |= (prefixes & PREFIX_DATA);
14345 if ((op & 0x8000) != 0)
14349 oappend (INTERNAL_DISASSEMBLER_ERROR);
14353 scratchbuf[0] = '$';
14354 print_operand_value (scratchbuf + 1, 1, op);
14355 oappend (scratchbuf + intel_syntax);
14359 OP_J (int bytemode, int sizeflag)
14363 bfd_vma segment = 0;
14368 FETCH_DATA (the_info, codep + 1);
14370 if ((disp & 0x80) != 0)
14375 if ((sizeflag & DFLAG) || (rex & REX_W))
14380 if ((disp & 0x8000) != 0)
14382 /* In 16bit mode, address is wrapped around at 64k within
14383 the same segment. Otherwise, a data16 prefix on a jump
14384 instruction means that the pc is masked to 16 bits after
14385 the displacement is added! */
14387 if ((prefixes & PREFIX_DATA) == 0)
14388 segment = ((start_pc + codep - start_codep)
14389 & ~((bfd_vma) 0xffff));
14391 if (!(rex & REX_W))
14392 used_prefixes |= (prefixes & PREFIX_DATA);
14395 oappend (INTERNAL_DISASSEMBLER_ERROR);
14398 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
14400 print_operand_value (scratchbuf, 1, disp);
14401 oappend (scratchbuf);
14405 OP_SEG (int bytemode, int sizeflag)
14407 if (bytemode == w_mode)
14408 oappend (names_seg[modrm.reg]);
14410 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
14414 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
14418 if (sizeflag & DFLAG)
14428 used_prefixes |= (prefixes & PREFIX_DATA);
14430 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
14432 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
14433 oappend (scratchbuf);
14437 OP_OFF (int bytemode, int sizeflag)
14441 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14442 intel_operand_size (bytemode, sizeflag);
14445 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
14452 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14453 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14455 oappend (names_seg[ds_reg - es_reg]);
14459 print_operand_value (scratchbuf, 1, off);
14460 oappend (scratchbuf);
14464 OP_OFF64 (int bytemode, int sizeflag)
14468 if (address_mode != mode_64bit
14469 || (prefixes & PREFIX_ADDR))
14471 OP_OFF (bytemode, sizeflag);
14475 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
14476 intel_operand_size (bytemode, sizeflag);
14483 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
14484 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
14486 oappend (names_seg[ds_reg - es_reg]);
14490 print_operand_value (scratchbuf, 1, off);
14491 oappend (scratchbuf);
14495 ptr_reg (int code, int sizeflag)
14499 *obufp++ = open_char;
14500 used_prefixes |= (prefixes & PREFIX_ADDR);
14501 if (address_mode == mode_64bit)
14503 if (!(sizeflag & AFLAG))
14504 s = names32[code - eAX_reg];
14506 s = names64[code - eAX_reg];
14508 else if (sizeflag & AFLAG)
14509 s = names32[code - eAX_reg];
14511 s = names16[code - eAX_reg];
14513 *obufp++ = close_char;
14518 OP_ESreg (int code, int sizeflag)
14524 case 0x6d: /* insw/insl */
14525 intel_operand_size (z_mode, sizeflag);
14527 case 0xa5: /* movsw/movsl/movsq */
14528 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14529 case 0xab: /* stosw/stosl */
14530 case 0xaf: /* scasw/scasl */
14531 intel_operand_size (v_mode, sizeflag);
14534 intel_operand_size (b_mode, sizeflag);
14537 oappend ("%es:" + intel_syntax);
14538 ptr_reg (code, sizeflag);
14542 OP_DSreg (int code, int sizeflag)
14548 case 0x6f: /* outsw/outsl */
14549 intel_operand_size (z_mode, sizeflag);
14551 case 0xa5: /* movsw/movsl/movsq */
14552 case 0xa7: /* cmpsw/cmpsl/cmpsq */
14553 case 0xad: /* lodsw/lodsl/lodsq */
14554 intel_operand_size (v_mode, sizeflag);
14557 intel_operand_size (b_mode, sizeflag);
14566 | PREFIX_GS)) == 0)
14567 prefixes |= PREFIX_DS;
14569 ptr_reg (code, sizeflag);
14573 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14581 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
14583 all_prefixes[last_lock_prefix] = 0;
14584 used_prefixes |= PREFIX_LOCK;
14589 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
14590 oappend (scratchbuf + intel_syntax);
14594 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14603 sprintf (scratchbuf, "db%d", modrm.reg + add);
14605 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
14606 oappend (scratchbuf);
14610 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14612 sprintf (scratchbuf, "%%tr%d", modrm.reg);
14613 oappend (scratchbuf + intel_syntax);
14617 OP_R (int bytemode, int sizeflag)
14619 if (modrm.mod == 3)
14620 OP_E (bytemode, sizeflag);
14626 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14628 used_prefixes |= (prefixes & PREFIX_DATA);
14629 if (prefixes & PREFIX_DATA)
14637 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14640 sprintf (scratchbuf, "%%mm%d", modrm.reg);
14641 oappend (scratchbuf + intel_syntax);
14645 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
14653 if (need_vex && bytemode != xmm_mode)
14655 switch (vex.length)
14658 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14661 sprintf (scratchbuf, "%%ymm%d", modrm.reg + add);
14668 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
14669 oappend (scratchbuf + intel_syntax);
14673 OP_EM (int bytemode, int sizeflag)
14675 if (modrm.mod != 3)
14678 && (bytemode == v_mode || bytemode == v_swap_mode))
14680 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14681 used_prefixes |= (prefixes & PREFIX_DATA);
14683 OP_E (bytemode, sizeflag);
14687 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
14690 /* Skip mod/rm byte. */
14693 used_prefixes |= (prefixes & PREFIX_DATA);
14694 if (prefixes & PREFIX_DATA)
14703 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14706 sprintf (scratchbuf, "%%mm%d", modrm.rm);
14707 oappend (scratchbuf + intel_syntax);
14710 /* cvt* are the only instructions in sse2 which have
14711 both SSE and MMX operands and also have 0x66 prefix
14712 in their opcode. 0x66 was originally used to differentiate
14713 between SSE and MMX instruction(operands). So we have to handle the
14714 cvt* separately using OP_EMC and OP_MXC */
14716 OP_EMC (int bytemode, int sizeflag)
14718 if (modrm.mod != 3)
14720 if (intel_syntax && bytemode == v_mode)
14722 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
14723 used_prefixes |= (prefixes & PREFIX_DATA);
14725 OP_E (bytemode, sizeflag);
14729 /* Skip mod/rm byte. */
14732 used_prefixes |= (prefixes & PREFIX_DATA);
14733 sprintf (scratchbuf, "%%mm%d", modrm.rm);
14734 oappend (scratchbuf + intel_syntax);
14738 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14740 used_prefixes |= (prefixes & PREFIX_DATA);
14741 sprintf (scratchbuf, "%%mm%d", modrm.reg);
14742 oappend (scratchbuf + intel_syntax);
14746 OP_EX (int bytemode, int sizeflag)
14750 /* Skip mod/rm byte. */
14754 if (modrm.mod != 3)
14756 OP_E_memory (bytemode, sizeflag);
14766 if ((sizeflag & SUFFIX_ALWAYS)
14767 && (bytemode == x_swap_mode
14768 || bytemode == d_swap_mode
14769 || bytemode == q_swap_mode))
14773 && bytemode != xmm_mode
14774 && bytemode != xmmq_mode)
14776 switch (vex.length)
14779 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14782 sprintf (scratchbuf, "%%ymm%d", modrm.rm + add);
14789 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
14790 oappend (scratchbuf + intel_syntax);
14794 OP_MS (int bytemode, int sizeflag)
14796 if (modrm.mod == 3)
14797 OP_EM (bytemode, sizeflag);
14803 OP_XS (int bytemode, int sizeflag)
14805 if (modrm.mod == 3)
14806 OP_EX (bytemode, sizeflag);
14812 OP_M (int bytemode, int sizeflag)
14814 if (modrm.mod == 3)
14815 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
14818 OP_E (bytemode, sizeflag);
14822 OP_0f07 (int bytemode, int sizeflag)
14824 if (modrm.mod != 3 || modrm.rm != 0)
14827 OP_E (bytemode, sizeflag);
14830 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
14831 32bit mode and "xchg %rax,%rax" in 64bit mode. */
14834 NOP_Fixup1 (int bytemode, int sizeflag)
14836 if ((prefixes & PREFIX_DATA) != 0
14839 && address_mode == mode_64bit))
14840 OP_REG (bytemode, sizeflag);
14842 strcpy (obuf, "nop");
14846 NOP_Fixup2 (int bytemode, int sizeflag)
14848 if ((prefixes & PREFIX_DATA) != 0
14851 && address_mode == mode_64bit))
14852 OP_IMREG (bytemode, sizeflag);
14855 static const char *const Suffix3DNow[] = {
14856 /* 00 */ NULL, NULL, NULL, NULL,
14857 /* 04 */ NULL, NULL, NULL, NULL,
14858 /* 08 */ NULL, NULL, NULL, NULL,
14859 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
14860 /* 10 */ NULL, NULL, NULL, NULL,
14861 /* 14 */ NULL, NULL, NULL, NULL,
14862 /* 18 */ NULL, NULL, NULL, NULL,
14863 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
14864 /* 20 */ NULL, NULL, NULL, NULL,
14865 /* 24 */ NULL, NULL, NULL, NULL,
14866 /* 28 */ NULL, NULL, NULL, NULL,
14867 /* 2C */ NULL, NULL, NULL, NULL,
14868 /* 30 */ NULL, NULL, NULL, NULL,
14869 /* 34 */ NULL, NULL, NULL, NULL,
14870 /* 38 */ NULL, NULL, NULL, NULL,
14871 /* 3C */ NULL, NULL, NULL, NULL,
14872 /* 40 */ NULL, NULL, NULL, NULL,
14873 /* 44 */ NULL, NULL, NULL, NULL,
14874 /* 48 */ NULL, NULL, NULL, NULL,
14875 /* 4C */ NULL, NULL, NULL, NULL,
14876 /* 50 */ NULL, NULL, NULL, NULL,
14877 /* 54 */ NULL, NULL, NULL, NULL,
14878 /* 58 */ NULL, NULL, NULL, NULL,
14879 /* 5C */ NULL, NULL, NULL, NULL,
14880 /* 60 */ NULL, NULL, NULL, NULL,
14881 /* 64 */ NULL, NULL, NULL, NULL,
14882 /* 68 */ NULL, NULL, NULL, NULL,
14883 /* 6C */ NULL, NULL, NULL, NULL,
14884 /* 70 */ NULL, NULL, NULL, NULL,
14885 /* 74 */ NULL, NULL, NULL, NULL,
14886 /* 78 */ NULL, NULL, NULL, NULL,
14887 /* 7C */ NULL, NULL, NULL, NULL,
14888 /* 80 */ NULL, NULL, NULL, NULL,
14889 /* 84 */ NULL, NULL, NULL, NULL,
14890 /* 88 */ NULL, NULL, "pfnacc", NULL,
14891 /* 8C */ NULL, NULL, "pfpnacc", NULL,
14892 /* 90 */ "pfcmpge", NULL, NULL, NULL,
14893 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
14894 /* 98 */ NULL, NULL, "pfsub", NULL,
14895 /* 9C */ NULL, NULL, "pfadd", NULL,
14896 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
14897 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
14898 /* A8 */ NULL, NULL, "pfsubr", NULL,
14899 /* AC */ NULL, NULL, "pfacc", NULL,
14900 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
14901 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
14902 /* B8 */ NULL, NULL, NULL, "pswapd",
14903 /* BC */ NULL, NULL, NULL, "pavgusb",
14904 /* C0 */ NULL, NULL, NULL, NULL,
14905 /* C4 */ NULL, NULL, NULL, NULL,
14906 /* C8 */ NULL, NULL, NULL, NULL,
14907 /* CC */ NULL, NULL, NULL, NULL,
14908 /* D0 */ NULL, NULL, NULL, NULL,
14909 /* D4 */ NULL, NULL, NULL, NULL,
14910 /* D8 */ NULL, NULL, NULL, NULL,
14911 /* DC */ NULL, NULL, NULL, NULL,
14912 /* E0 */ NULL, NULL, NULL, NULL,
14913 /* E4 */ NULL, NULL, NULL, NULL,
14914 /* E8 */ NULL, NULL, NULL, NULL,
14915 /* EC */ NULL, NULL, NULL, NULL,
14916 /* F0 */ NULL, NULL, NULL, NULL,
14917 /* F4 */ NULL, NULL, NULL, NULL,
14918 /* F8 */ NULL, NULL, NULL, NULL,
14919 /* FC */ NULL, NULL, NULL, NULL,
14923 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14925 const char *mnemonic;
14927 FETCH_DATA (the_info, codep + 1);
14928 /* AMD 3DNow! instructions are specified by an opcode suffix in the
14929 place where an 8-bit immediate would normally go. ie. the last
14930 byte of the instruction. */
14931 obufp = mnemonicendp;
14932 mnemonic = Suffix3DNow[*codep++ & 0xff];
14934 oappend (mnemonic);
14937 /* Since a variable sized modrm/sib chunk is between the start
14938 of the opcode (0x0f0f) and the opcode suffix, we need to do
14939 all the modrm processing first, and don't know until now that
14940 we have a bad opcode. This necessitates some cleaning up. */
14941 op_out[0][0] = '\0';
14942 op_out[1][0] = '\0';
14945 mnemonicendp = obufp;
14948 static struct op simd_cmp_op[] =
14950 { STRING_COMMA_LEN ("eq") },
14951 { STRING_COMMA_LEN ("lt") },
14952 { STRING_COMMA_LEN ("le") },
14953 { STRING_COMMA_LEN ("unord") },
14954 { STRING_COMMA_LEN ("neq") },
14955 { STRING_COMMA_LEN ("nlt") },
14956 { STRING_COMMA_LEN ("nle") },
14957 { STRING_COMMA_LEN ("ord") }
14961 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14963 unsigned int cmp_type;
14965 FETCH_DATA (the_info, codep + 1);
14966 cmp_type = *codep++ & 0xff;
14967 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
14970 char *p = mnemonicendp - 2;
14974 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
14975 mnemonicendp += simd_cmp_op[cmp_type].len;
14979 /* We have a reserved extension byte. Output it directly. */
14980 scratchbuf[0] = '$';
14981 print_operand_value (scratchbuf + 1, 1, cmp_type);
14982 oappend (scratchbuf + intel_syntax);
14983 scratchbuf[0] = '\0';
14988 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
14989 int sizeflag ATTRIBUTE_UNUSED)
14991 /* mwait %eax,%ecx */
14994 const char **names = (address_mode == mode_64bit
14995 ? names64 : names32);
14996 strcpy (op_out[0], names[0]);
14997 strcpy (op_out[1], names[1]);
14998 two_source_ops = 1;
15000 /* Skip mod/rm byte. */
15006 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
15007 int sizeflag ATTRIBUTE_UNUSED)
15009 /* monitor %eax,%ecx,%edx" */
15012 const char **op1_names;
15013 const char **names = (address_mode == mode_64bit
15014 ? names64 : names32);
15016 if (!(prefixes & PREFIX_ADDR))
15017 op1_names = (address_mode == mode_16bit
15018 ? names16 : names);
15021 /* Remove "addr16/addr32". */
15022 all_prefixes[last_addr_prefix] = 0;
15023 op1_names = (address_mode != mode_32bit
15024 ? names32 : names16);
15025 used_prefixes |= PREFIX_ADDR;
15027 strcpy (op_out[0], op1_names[0]);
15028 strcpy (op_out[1], names[1]);
15029 strcpy (op_out[2], names[2]);
15030 two_source_ops = 1;
15032 /* Skip mod/rm byte. */
15040 /* Throw away prefixes and 1st. opcode byte. */
15041 codep = insn_codep + 1;
15046 REP_Fixup (int bytemode, int sizeflag)
15048 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
15050 if (prefixes & PREFIX_REPZ)
15051 all_prefixes[last_repz_prefix] = REP_PREFIX;
15058 OP_IMREG (bytemode, sizeflag);
15061 OP_ESreg (bytemode, sizeflag);
15064 OP_DSreg (bytemode, sizeflag);
15073 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
15078 /* Change cmpxchg8b to cmpxchg16b. */
15079 char *p = mnemonicendp - 2;
15080 mnemonicendp = stpcpy (p, "16b");
15083 OP_M (bytemode, sizeflag);
15087 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
15091 switch (vex.length)
15094 sprintf (scratchbuf, "%%xmm%d", reg);
15097 sprintf (scratchbuf, "%%ymm%d", reg);
15104 sprintf (scratchbuf, "%%xmm%d", reg);
15105 oappend (scratchbuf + intel_syntax);
15109 CRC32_Fixup (int bytemode, int sizeflag)
15111 /* Add proper suffix to "crc32". */
15112 char *p = mnemonicendp;
15131 if (sizeflag & DFLAG)
15135 used_prefixes |= (prefixes & PREFIX_DATA);
15139 oappend (INTERNAL_DISASSEMBLER_ERROR);
15146 if (modrm.mod == 3)
15150 /* Skip mod/rm byte. */
15155 add = (rex & REX_B) ? 8 : 0;
15156 if (bytemode == b_mode)
15160 oappend (names8rex[modrm.rm + add]);
15162 oappend (names8[modrm.rm + add]);
15168 oappend (names64[modrm.rm + add]);
15169 else if ((prefixes & PREFIX_DATA))
15170 oappend (names16[modrm.rm + add]);
15172 oappend (names32[modrm.rm + add]);
15176 OP_E (bytemode, sizeflag);
15180 FXSAVE_Fixup (int bytemode, int sizeflag)
15182 /* Add proper suffix to "fxsave" and "fxrstor". */
15186 char *p = mnemonicendp;
15192 OP_M (bytemode, sizeflag);
15195 /* Display the destination register operand for instructions with
15199 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15207 switch (vex.length)
15220 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15233 sprintf (scratchbuf, "%%ymm%d", vex.register_specifier);
15239 oappend (scratchbuf + intel_syntax);
15242 /* Get the VEX immediate byte without moving codep. */
15244 static unsigned char
15245 get_vex_imm8 (int sizeflag, int opnum)
15247 int bytes_before_imm = 0;
15249 if (modrm.mod != 3)
15251 /* There are SIB/displacement bytes. */
15252 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
15254 /* 32/64 bit address mode */
15255 int base = modrm.rm;
15257 /* Check SIB byte. */
15260 FETCH_DATA (the_info, codep + 1);
15262 /* When decoding the third source, don't increase
15263 bytes_before_imm as this has already been incremented
15264 by one in OP_E_memory while decoding the second
15267 bytes_before_imm++;
15270 /* Don't increase bytes_before_imm when decoding the third source,
15271 it has already been incremented by OP_E_memory while decoding
15272 the second source operand. */
15278 /* When modrm.rm == 5 or modrm.rm == 4 and base in
15279 SIB == 5, there is a 4 byte displacement. */
15281 /* No displacement. */
15284 /* 4 byte displacement. */
15285 bytes_before_imm += 4;
15288 /* 1 byte displacement. */
15289 bytes_before_imm++;
15296 /* 16 bit address mode */
15297 /* Don't increase bytes_before_imm when decoding the third source,
15298 it has already been incremented by OP_E_memory while decoding
15299 the second source operand. */
15305 /* When modrm.rm == 6, there is a 2 byte displacement. */
15307 /* No displacement. */
15310 /* 2 byte displacement. */
15311 bytes_before_imm += 2;
15314 /* 1 byte displacement: when decoding the third source,
15315 don't increase bytes_before_imm as this has already
15316 been incremented by one in OP_E_memory while decoding
15317 the second source operand. */
15319 bytes_before_imm++;
15327 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
15328 return codep [bytes_before_imm];
15332 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
15334 if (reg == -1 && modrm.mod != 3)
15336 OP_E_memory (bytemode, sizeflag);
15348 else if (reg > 7 && address_mode != mode_64bit)
15352 switch (vex.length)
15355 sprintf (scratchbuf, "%%xmm%d", reg);
15358 sprintf (scratchbuf, "%%ymm%d", reg);
15363 oappend (scratchbuf + intel_syntax);
15367 OP_Vex_2src (int bytemode, int sizeflag)
15369 if (modrm.mod == 3)
15372 sprintf (scratchbuf, "%%xmm%d", rex & REX_B ? modrm.rm + 8 : modrm.rm);
15373 oappend (scratchbuf + intel_syntax);
15378 && (bytemode == v_mode || bytemode == v_swap_mode))
15380 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
15381 used_prefixes |= (prefixes & PREFIX_DATA);
15383 OP_E (bytemode, sizeflag);
15388 OP_Vex_2src_1 (int bytemode, int sizeflag)
15390 if (modrm.mod == 3)
15392 /* Skip mod/rm byte. */
15399 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15400 oappend (scratchbuf + intel_syntax);
15403 OP_Vex_2src (bytemode, sizeflag);
15407 OP_Vex_2src_2 (int bytemode, int sizeflag)
15410 OP_Vex_2src (bytemode, sizeflag);
15413 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
15414 oappend (scratchbuf + intel_syntax);
15419 OP_EX_VexW (int bytemode, int sizeflag)
15427 /* Skip mod/rm byte. */
15432 reg = get_vex_imm8 (sizeflag, 0) >> 4;
15437 reg = get_vex_imm8 (sizeflag, 1) >> 4;
15440 OP_EX_VexReg (bytemode, sizeflag, reg);
15444 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
15445 int sizeflag ATTRIBUTE_UNUSED)
15447 /* Skip the immediate byte and check for invalid bits. */
15448 FETCH_DATA (the_info, codep + 1);
15449 if (*codep++ & 0xf)
15454 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
15457 FETCH_DATA (the_info, codep + 1);
15460 if (bytemode != x_mode)
15467 if (reg > 7 && address_mode != mode_64bit)
15470 switch (vex.length)
15473 sprintf (scratchbuf, "%%xmm%d", reg);
15476 sprintf (scratchbuf, "%%ymm%d", reg);
15481 oappend (scratchbuf + intel_syntax);
15485 OP_XMM_VexW (int bytemode, int sizeflag)
15487 /* Turn off the REX.W bit since it is used for swapping operands
15490 OP_XMM (bytemode, sizeflag);
15494 OP_EX_Vex (int bytemode, int sizeflag)
15496 if (modrm.mod != 3)
15498 if (vex.register_specifier != 0)
15502 OP_EX (bytemode, sizeflag);
15506 OP_XMM_Vex (int bytemode, int sizeflag)
15508 if (modrm.mod != 3)
15510 if (vex.register_specifier != 0)
15514 OP_XMM (bytemode, sizeflag);
15518 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15520 switch (vex.length)
15523 mnemonicendp = stpcpy (obuf, "vzeroupper");
15526 mnemonicendp = stpcpy (obuf, "vzeroall");
15533 static struct op vex_cmp_op[] =
15535 { STRING_COMMA_LEN ("eq") },
15536 { STRING_COMMA_LEN ("lt") },
15537 { STRING_COMMA_LEN ("le") },
15538 { STRING_COMMA_LEN ("unord") },
15539 { STRING_COMMA_LEN ("neq") },
15540 { STRING_COMMA_LEN ("nlt") },
15541 { STRING_COMMA_LEN ("nle") },
15542 { STRING_COMMA_LEN ("ord") },
15543 { STRING_COMMA_LEN ("eq_uq") },
15544 { STRING_COMMA_LEN ("nge") },
15545 { STRING_COMMA_LEN ("ngt") },
15546 { STRING_COMMA_LEN ("false") },
15547 { STRING_COMMA_LEN ("neq_oq") },
15548 { STRING_COMMA_LEN ("ge") },
15549 { STRING_COMMA_LEN ("gt") },
15550 { STRING_COMMA_LEN ("true") },
15551 { STRING_COMMA_LEN ("eq_os") },
15552 { STRING_COMMA_LEN ("lt_oq") },
15553 { STRING_COMMA_LEN ("le_oq") },
15554 { STRING_COMMA_LEN ("unord_s") },
15555 { STRING_COMMA_LEN ("neq_us") },
15556 { STRING_COMMA_LEN ("nlt_uq") },
15557 { STRING_COMMA_LEN ("nle_uq") },
15558 { STRING_COMMA_LEN ("ord_s") },
15559 { STRING_COMMA_LEN ("eq_us") },
15560 { STRING_COMMA_LEN ("nge_uq") },
15561 { STRING_COMMA_LEN ("ngt_uq") },
15562 { STRING_COMMA_LEN ("false_os") },
15563 { STRING_COMMA_LEN ("neq_os") },
15564 { STRING_COMMA_LEN ("ge_oq") },
15565 { STRING_COMMA_LEN ("gt_oq") },
15566 { STRING_COMMA_LEN ("true_us") },
15570 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15572 unsigned int cmp_type;
15574 FETCH_DATA (the_info, codep + 1);
15575 cmp_type = *codep++ & 0xff;
15576 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
15579 char *p = mnemonicendp - 2;
15583 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
15584 mnemonicendp += vex_cmp_op[cmp_type].len;
15588 /* We have a reserved extension byte. Output it directly. */
15589 scratchbuf[0] = '$';
15590 print_operand_value (scratchbuf + 1, 1, cmp_type);
15591 oappend (scratchbuf + intel_syntax);
15592 scratchbuf[0] = '\0';
15596 static const struct op pclmul_op[] =
15598 { STRING_COMMA_LEN ("lql") },
15599 { STRING_COMMA_LEN ("hql") },
15600 { STRING_COMMA_LEN ("lqh") },
15601 { STRING_COMMA_LEN ("hqh") }
15605 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
15606 int sizeflag ATTRIBUTE_UNUSED)
15608 unsigned int pclmul_type;
15610 FETCH_DATA (the_info, codep + 1);
15611 pclmul_type = *codep++ & 0xff;
15612 switch (pclmul_type)
15623 if (pclmul_type < ARRAY_SIZE (pclmul_op))
15626 char *p = mnemonicendp - 3;
15631 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
15632 mnemonicendp += pclmul_op[pclmul_type].len;
15636 /* We have a reserved extension byte. Output it directly. */
15637 scratchbuf[0] = '$';
15638 print_operand_value (scratchbuf + 1, 1, pclmul_type);
15639 oappend (scratchbuf + intel_syntax);
15640 scratchbuf[0] = '\0';
15645 MOVBE_Fixup (int bytemode, int sizeflag)
15647 /* Add proper suffix to "movbe". */
15648 char *p = mnemonicendp;
15657 if (sizeflag & SUFFIX_ALWAYS)
15663 if (sizeflag & DFLAG)
15667 used_prefixes |= (prefixes & PREFIX_DATA);
15672 oappend (INTERNAL_DISASSEMBLER_ERROR);
15679 OP_M (bytemode, sizeflag);
15683 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15686 const char **names;
15688 /* Skip mod/rm byte. */
15694 else if (vex.length == 256)
15704 oappend (names[reg]);
15708 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
15710 const char **names;
15714 else if (vex.length == 256)
15719 oappend (names[vex.register_specifier]);
15723 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
15725 if (vex.w || vex.length == 256)
15726 OP_I (q_mode, sizeflag);
15728 OP_I (w_mode, sizeflag);