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 OP_E_extended (int, int);
57 static void print_displacement (char *, bfd_vma
);
58 static void OP_E (int, int);
59 static void OP_G (int, int);
60 static bfd_vma
get64 (void);
61 static bfd_signed_vma
get32 (void);
62 static bfd_signed_vma
get32s (void);
63 static int get16 (void);
64 static void set_op (bfd_vma
, int);
65 static void OP_Skip_MODRM (int, int);
66 static void OP_REG (int, int);
67 static void OP_IMREG (int, int);
68 static void OP_I (int, int);
69 static void OP_I64 (int, int);
70 static void OP_sI (int, int);
71 static void OP_J (int, int);
72 static void OP_SEG (int, int);
73 static void OP_DIR (int, int);
74 static void OP_OFF (int, int);
75 static void OP_OFF64 (int, int);
76 static void ptr_reg (int, int);
77 static void OP_ESreg (int, int);
78 static void OP_DSreg (int, int);
79 static void OP_C (int, int);
80 static void OP_D (int, int);
81 static void OP_T (int, int);
82 static void OP_R (int, int);
83 static void OP_MMX (int, int);
84 static void OP_XMM (int, int);
85 static void OP_EM (int, int);
86 static void OP_EX (int, int);
87 static void OP_EMC (int,int);
88 static void OP_MXC (int,int);
89 static void OP_MS (int, int);
90 static void OP_XS (int, int);
91 static void OP_M (int, int);
92 static void OP_VEX (int, int);
93 static void OP_EX_Vex (int, int);
94 static void OP_EX_VexW (int, int);
95 static void OP_XMM_Vex (int, int);
96 static void OP_XMM_VexW (int, int);
97 static void OP_REG_VexI4 (int, int);
98 static void PCLMUL_Fixup (int, int);
99 static void VEXI4_Fixup (int, int);
100 static void VZERO_Fixup (int, int);
101 static void VCMP_Fixup (int, int);
102 static void OP_0f07 (int, int);
103 static void OP_Monitor (int, int);
104 static void OP_Mwait (int, int);
105 static void NOP_Fixup1 (int, int);
106 static void NOP_Fixup2 (int, int);
107 static void OP_3DNowSuffix (int, int);
108 static void CMP_Fixup (int, int);
109 static void BadOp (void);
110 static void REP_Fixup (int, int);
111 static void CMPXCHG8B_Fixup (int, int);
112 static void XMM_Fixup (int, int);
113 static void CRC32_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
118 static void MOVBE_Fixup (int, int);
121 /* Points to first byte not fetched. */
122 bfd_byte
*max_fetched
;
123 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
136 enum address_mode address_mode
;
138 /* Flags for the prefixes for the current instruction. See below. */
141 /* REX prefix the current instruction. See below. */
143 /* Bits of REX we've already used. */
145 /* Original REX prefix. */
146 static int rex_original
;
147 /* REX bits in original REX prefix ignored. It may not be the same
148 as rex_original since some bits may not be ignored. */
149 static int rex_ignored
;
150 /* Mark parts used in the REX prefix. When we are testing for
151 empty prefix (for 8bit register REX extension), just mask it
152 out. Otherwise test for REX bit is excuse for existence of REX
153 only in case value is nonzero. */
154 #define USED_REX(value) \
159 rex_used |= (value) | REX_OPCODE; \
162 rex_used |= REX_OPCODE; \
165 /* Flags for prefixes which we somehow handled when printing the
166 current instruction. */
167 static int used_prefixes
;
169 /* Flags stored in PREFIXES. */
170 #define PREFIX_REPZ 1
171 #define PREFIX_REPNZ 2
172 #define PREFIX_LOCK 4
174 #define PREFIX_SS 0x10
175 #define PREFIX_DS 0x20
176 #define PREFIX_ES 0x40
177 #define PREFIX_FS 0x80
178 #define PREFIX_GS 0x100
179 #define PREFIX_DATA 0x200
180 #define PREFIX_ADDR 0x400
181 #define PREFIX_FWAIT 0x800
183 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
184 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
186 #define FETCH_DATA(info, addr) \
187 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
188 ? 1 : fetch_data ((info), (addr)))
191 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
194 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
195 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
197 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
198 status
= (*info
->read_memory_func
) (start
,
200 addr
- priv
->max_fetched
,
206 /* If we did manage to read at least one byte, then
207 print_insn_i386 will do something sensible. Otherwise, print
208 an error. We do that here because this is where we know
210 if (priv
->max_fetched
== priv
->the_buffer
)
211 (*info
->memory_error_func
) (status
, start
, info
);
212 longjmp (priv
->bailout
, 1);
215 priv
->max_fetched
= addr
;
219 #define XX { NULL, 0 }
221 #define Eb { OP_E, b_mode }
222 #define EbS { OP_E, b_swap_mode }
223 #define Ev { OP_E, v_mode }
224 #define EvS { OP_E, v_swap_mode }
225 #define Ed { OP_E, d_mode }
226 #define Edq { OP_E, dq_mode }
227 #define Edqw { OP_E, dqw_mode }
228 #define Edqb { OP_E, dqb_mode }
229 #define Edqd { OP_E, dqd_mode }
230 #define Eq { OP_E, q_mode }
231 #define indirEv { OP_indirE, stack_v_mode }
232 #define indirEp { OP_indirE, f_mode }
233 #define stackEv { OP_E, stack_v_mode }
234 #define Em { OP_E, m_mode }
235 #define Ew { OP_E, w_mode }
236 #define M { OP_M, 0 } /* lea, lgdt, etc. */
237 #define Ma { OP_M, a_mode }
238 #define Mb { OP_M, b_mode }
239 #define Md { OP_M, d_mode }
240 #define Mo { OP_M, o_mode }
241 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
242 #define Mq { OP_M, q_mode }
243 #define Mx { OP_M, x_mode }
244 #define Mxmm { OP_M, xmm_mode }
245 #define Gb { OP_G, b_mode }
246 #define Gv { OP_G, v_mode }
247 #define Gd { OP_G, d_mode }
248 #define Gdq { OP_G, dq_mode }
249 #define Gm { OP_G, m_mode }
250 #define Gw { OP_G, w_mode }
251 #define Rd { OP_R, d_mode }
252 #define Rm { OP_R, m_mode }
253 #define Ib { OP_I, b_mode }
254 #define sIb { OP_sI, b_mode } /* sign extened byte */
255 #define Iv { OP_I, v_mode }
256 #define Iq { OP_I, q_mode }
257 #define Iv64 { OP_I64, v_mode }
258 #define Iw { OP_I, w_mode }
259 #define I1 { OP_I, const_1_mode }
260 #define Jb { OP_J, b_mode }
261 #define Jv { OP_J, v_mode }
262 #define Cm { OP_C, m_mode }
263 #define Dm { OP_D, m_mode }
264 #define Td { OP_T, d_mode }
265 #define Skip_MODRM { OP_Skip_MODRM, 0 }
267 #define RMeAX { OP_REG, eAX_reg }
268 #define RMeBX { OP_REG, eBX_reg }
269 #define RMeCX { OP_REG, eCX_reg }
270 #define RMeDX { OP_REG, eDX_reg }
271 #define RMeSP { OP_REG, eSP_reg }
272 #define RMeBP { OP_REG, eBP_reg }
273 #define RMeSI { OP_REG, eSI_reg }
274 #define RMeDI { OP_REG, eDI_reg }
275 #define RMrAX { OP_REG, rAX_reg }
276 #define RMrBX { OP_REG, rBX_reg }
277 #define RMrCX { OP_REG, rCX_reg }
278 #define RMrDX { OP_REG, rDX_reg }
279 #define RMrSP { OP_REG, rSP_reg }
280 #define RMrBP { OP_REG, rBP_reg }
281 #define RMrSI { OP_REG, rSI_reg }
282 #define RMrDI { OP_REG, rDI_reg }
283 #define RMAL { OP_REG, al_reg }
284 #define RMAL { OP_REG, al_reg }
285 #define RMCL { OP_REG, cl_reg }
286 #define RMDL { OP_REG, dl_reg }
287 #define RMBL { OP_REG, bl_reg }
288 #define RMAH { OP_REG, ah_reg }
289 #define RMCH { OP_REG, ch_reg }
290 #define RMDH { OP_REG, dh_reg }
291 #define RMBH { OP_REG, bh_reg }
292 #define RMAX { OP_REG, ax_reg }
293 #define RMDX { OP_REG, dx_reg }
295 #define eAX { OP_IMREG, eAX_reg }
296 #define eBX { OP_IMREG, eBX_reg }
297 #define eCX { OP_IMREG, eCX_reg }
298 #define eDX { OP_IMREG, eDX_reg }
299 #define eSP { OP_IMREG, eSP_reg }
300 #define eBP { OP_IMREG, eBP_reg }
301 #define eSI { OP_IMREG, eSI_reg }
302 #define eDI { OP_IMREG, eDI_reg }
303 #define AL { OP_IMREG, al_reg }
304 #define CL { OP_IMREG, cl_reg }
305 #define DL { OP_IMREG, dl_reg }
306 #define BL { OP_IMREG, bl_reg }
307 #define AH { OP_IMREG, ah_reg }
308 #define CH { OP_IMREG, ch_reg }
309 #define DH { OP_IMREG, dh_reg }
310 #define BH { OP_IMREG, bh_reg }
311 #define AX { OP_IMREG, ax_reg }
312 #define DX { OP_IMREG, dx_reg }
313 #define zAX { OP_IMREG, z_mode_ax_reg }
314 #define indirDX { OP_IMREG, indir_dx_reg }
316 #define Sw { OP_SEG, w_mode }
317 #define Sv { OP_SEG, v_mode }
318 #define Ap { OP_DIR, 0 }
319 #define Ob { OP_OFF64, b_mode }
320 #define Ov { OP_OFF64, v_mode }
321 #define Xb { OP_DSreg, eSI_reg }
322 #define Xv { OP_DSreg, eSI_reg }
323 #define Xz { OP_DSreg, eSI_reg }
324 #define Yb { OP_ESreg, eDI_reg }
325 #define Yv { OP_ESreg, eDI_reg }
326 #define DSBX { OP_DSreg, eBX_reg }
328 #define es { OP_REG, es_reg }
329 #define ss { OP_REG, ss_reg }
330 #define cs { OP_REG, cs_reg }
331 #define ds { OP_REG, ds_reg }
332 #define fs { OP_REG, fs_reg }
333 #define gs { OP_REG, gs_reg }
335 #define MX { OP_MMX, 0 }
336 #define XM { OP_XMM, 0 }
337 #define XMM { OP_XMM, xmm_mode }
338 #define EM { OP_EM, v_mode }
339 #define EMS { OP_EM, v_swap_mode }
340 #define EMd { OP_EM, d_mode }
341 #define EMx { OP_EM, x_mode }
342 #define EXw { OP_EX, w_mode }
343 #define EXd { OP_EX, d_mode }
344 #define EXdS { OP_EX, d_swap_mode }
345 #define EXq { OP_EX, q_mode }
346 #define EXqS { OP_EX, q_swap_mode }
347 #define EXx { OP_EX, x_mode }
348 #define EXxS { OP_EX, x_swap_mode }
349 #define EXxmm { OP_EX, xmm_mode }
350 #define EXxmmq { OP_EX, xmmq_mode }
351 #define EXymmq { OP_EX, ymmq_mode }
352 #define EXVexWdq { OP_EX, vex_w_dq_mode }
353 #define MS { OP_MS, v_mode }
354 #define XS { OP_XS, v_mode }
355 #define EMCq { OP_EMC, q_mode }
356 #define MXC { OP_MXC, 0 }
357 #define OPSUF { OP_3DNowSuffix, 0 }
358 #define CMP { CMP_Fixup, 0 }
359 #define XMM0 { XMM_Fixup, 0 }
361 #define Vex { OP_VEX, vex_mode }
362 #define Vex128 { OP_VEX, vex128_mode }
363 #define Vex256 { OP_VEX, vex256_mode }
364 #define VexI4 { VEXI4_Fixup, 0}
365 #define EXdVex { OP_EX_Vex, d_mode }
366 #define EXdVexS { OP_EX_Vex, d_swap_mode }
367 #define EXqVex { OP_EX_Vex, q_mode }
368 #define EXqVexS { OP_EX_Vex, q_swap_mode }
369 #define EXVexW { OP_EX_VexW, x_mode }
370 #define EXdVexW { OP_EX_VexW, d_mode }
371 #define EXqVexW { OP_EX_VexW, q_mode }
372 #define XMVex { OP_XMM_Vex, 0 }
373 #define XMVexW { OP_XMM_VexW, 0 }
374 #define XMVexI4 { OP_REG_VexI4, x_mode }
375 #define PCLMUL { PCLMUL_Fixup, 0 }
376 #define VZERO { VZERO_Fixup, 0 }
377 #define VCMP { VCMP_Fixup, 0 }
379 /* Used handle "rep" prefix for string instructions. */
380 #define Xbr { REP_Fixup, eSI_reg }
381 #define Xvr { REP_Fixup, eSI_reg }
382 #define Ybr { REP_Fixup, eDI_reg }
383 #define Yvr { REP_Fixup, eDI_reg }
384 #define Yzr { REP_Fixup, eDI_reg }
385 #define indirDXr { REP_Fixup, indir_dx_reg }
386 #define ALr { REP_Fixup, al_reg }
387 #define eAXr { REP_Fixup, eAX_reg }
389 #define cond_jump_flag { NULL, cond_jump_mode }
390 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
392 /* bits in sizeflag */
393 #define SUFFIX_ALWAYS 4
401 /* byte operand with operand swapped */
403 /* operand size depends on prefixes */
405 /* operand size depends on prefixes with operand swapped */
409 /* double word operand */
411 /* double word operand with operand swapped */
413 /* quad word operand */
415 /* quad word operand with operand swapped */
417 /* ten-byte operand */
419 /* 16-byte XMM or 32-byte YMM operand */
421 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
423 /* 16-byte XMM operand */
425 /* 16-byte XMM or quad word operand */
427 /* 32-byte YMM or quad word operand */
429 /* d_mode in 32bit, q_mode in 64bit mode. */
431 /* pair of v_mode operands */
435 /* operand size depends on REX prefixes. */
437 /* registers like dq_mode, memory like w_mode. */
439 /* 4- or 6-byte pointer operand */
442 /* v_mode for stack-related opcodes. */
444 /* non-quad operand size depends on prefixes */
446 /* 16-byte operand */
448 /* registers like dq_mode, memory like b_mode. */
450 /* registers like dq_mode, memory like d_mode. */
452 /* normal vex mode */
454 /* 128bit vex mode */
456 /* 256bit vex mode */
458 /* operand size depends on the VEX.W bit. */
523 #define FLOAT NULL, { { NULL, FLOATCODE } }
525 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
526 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
527 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
528 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
529 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
530 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
531 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
532 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
533 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
534 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
535 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
653 MOD_VEX_3818_PREFIX_2
,
654 MOD_VEX_3819_PREFIX_2
,
655 MOD_VEX_381A_PREFIX_2
,
656 MOD_VEX_382A_PREFIX_2
,
657 MOD_VEX_382C_PREFIX_2
,
658 MOD_VEX_382D_PREFIX_2
,
659 MOD_VEX_382E_PREFIX_2
,
660 MOD_VEX_382F_PREFIX_2
1070 THREE_BYTE_0F38
= 0,
1224 VEX_LEN_3819_P_2_M_0
,
1225 VEX_LEN_381A_P_2_M_0
,
1237 VEX_LEN_382A_P_2_M_0
,
1294 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1305 /* Upper case letters in the instruction names here are macros.
1306 'A' => print 'b' if no register operands or suffix_always is true
1307 'B' => print 'b' if suffix_always is true
1308 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1310 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1311 suffix_always is true
1312 'E' => print 'e' if 32-bit form of jcxz
1313 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1314 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1315 'H' => print ",pt" or ",pn" branch hint
1316 'I' => honor following macro letter even in Intel mode (implemented only
1317 for some of the macro letters)
1319 'K' => print 'd' or 'q' if rex prefix is present.
1320 'L' => print 'l' if suffix_always is true
1321 'M' => print 'r' if intel_mnemonic is false.
1322 'N' => print 'n' if instruction has no wait "prefix"
1323 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1324 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1325 or suffix_always is true. print 'q' if rex prefix is present.
1326 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1328 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1329 'S' => print 'w', 'l' or 'q' if suffix_always is true
1330 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1331 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1332 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1333 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1334 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1335 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1336 suffix_always is true.
1337 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1338 '!' => change condition from true to false or from false to true.
1339 '%' => add 1 upper case letter to the macro.
1341 2 upper case letter macros:
1342 "XY" => print 'x' or 'y' if no register operands or suffix_always
1344 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1345 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1346 or suffix_always is true
1347 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1348 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1349 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1351 Many of the above letters print nothing in Intel mode. See "putop"
1354 Braces '{' and '}', and vertical bars '|', indicate alternative
1355 mnemonic strings for AT&T and Intel. */
1357 static const struct dis386 dis386
[] = {
1359 { "addB", { Eb
, Gb
} },
1360 { "addS", { Ev
, Gv
} },
1361 { "addB", { Gb
, EbS
} },
1362 { "addS", { Gv
, EvS
} },
1363 { "addB", { AL
, Ib
} },
1364 { "addS", { eAX
, Iv
} },
1365 { X86_64_TABLE (X86_64_06
) },
1366 { X86_64_TABLE (X86_64_07
) },
1368 { "orB", { Eb
, Gb
} },
1369 { "orS", { Ev
, Gv
} },
1370 { "orB", { Gb
, EbS
} },
1371 { "orS", { Gv
, EvS
} },
1372 { "orB", { AL
, Ib
} },
1373 { "orS", { eAX
, Iv
} },
1374 { X86_64_TABLE (X86_64_0D
) },
1375 { "(bad)", { XX
} }, /* 0x0f extended opcode escape */
1377 { "adcB", { Eb
, Gb
} },
1378 { "adcS", { Ev
, Gv
} },
1379 { "adcB", { Gb
, EbS
} },
1380 { "adcS", { Gv
, EvS
} },
1381 { "adcB", { AL
, Ib
} },
1382 { "adcS", { eAX
, Iv
} },
1383 { X86_64_TABLE (X86_64_16
) },
1384 { X86_64_TABLE (X86_64_17
) },
1386 { "sbbB", { Eb
, Gb
} },
1387 { "sbbS", { Ev
, Gv
} },
1388 { "sbbB", { Gb
, EbS
} },
1389 { "sbbS", { Gv
, EvS
} },
1390 { "sbbB", { AL
, Ib
} },
1391 { "sbbS", { eAX
, Iv
} },
1392 { X86_64_TABLE (X86_64_1E
) },
1393 { X86_64_TABLE (X86_64_1F
) },
1395 { "andB", { Eb
, Gb
} },
1396 { "andS", { Ev
, Gv
} },
1397 { "andB", { Gb
, EbS
} },
1398 { "andS", { Gv
, EvS
} },
1399 { "andB", { AL
, Ib
} },
1400 { "andS", { eAX
, Iv
} },
1401 { "(bad)", { XX
} }, /* SEG ES prefix */
1402 { X86_64_TABLE (X86_64_27
) },
1404 { "subB", { Eb
, Gb
} },
1405 { "subS", { Ev
, Gv
} },
1406 { "subB", { Gb
, EbS
} },
1407 { "subS", { Gv
, EvS
} },
1408 { "subB", { AL
, Ib
} },
1409 { "subS", { eAX
, Iv
} },
1410 { "(bad)", { XX
} }, /* SEG CS prefix */
1411 { X86_64_TABLE (X86_64_2F
) },
1413 { "xorB", { Eb
, Gb
} },
1414 { "xorS", { Ev
, Gv
} },
1415 { "xorB", { Gb
, EbS
} },
1416 { "xorS", { Gv
, EvS
} },
1417 { "xorB", { AL
, Ib
} },
1418 { "xorS", { eAX
, Iv
} },
1419 { "(bad)", { XX
} }, /* SEG SS prefix */
1420 { X86_64_TABLE (X86_64_37
) },
1422 { "cmpB", { Eb
, Gb
} },
1423 { "cmpS", { Ev
, Gv
} },
1424 { "cmpB", { Gb
, EbS
} },
1425 { "cmpS", { Gv
, EvS
} },
1426 { "cmpB", { AL
, Ib
} },
1427 { "cmpS", { eAX
, Iv
} },
1428 { "(bad)", { XX
} }, /* SEG DS prefix */
1429 { X86_64_TABLE (X86_64_3F
) },
1431 { "inc{S|}", { RMeAX
} },
1432 { "inc{S|}", { RMeCX
} },
1433 { "inc{S|}", { RMeDX
} },
1434 { "inc{S|}", { RMeBX
} },
1435 { "inc{S|}", { RMeSP
} },
1436 { "inc{S|}", { RMeBP
} },
1437 { "inc{S|}", { RMeSI
} },
1438 { "inc{S|}", { RMeDI
} },
1440 { "dec{S|}", { RMeAX
} },
1441 { "dec{S|}", { RMeCX
} },
1442 { "dec{S|}", { RMeDX
} },
1443 { "dec{S|}", { RMeBX
} },
1444 { "dec{S|}", { RMeSP
} },
1445 { "dec{S|}", { RMeBP
} },
1446 { "dec{S|}", { RMeSI
} },
1447 { "dec{S|}", { RMeDI
} },
1449 { "pushV", { RMrAX
} },
1450 { "pushV", { RMrCX
} },
1451 { "pushV", { RMrDX
} },
1452 { "pushV", { RMrBX
} },
1453 { "pushV", { RMrSP
} },
1454 { "pushV", { RMrBP
} },
1455 { "pushV", { RMrSI
} },
1456 { "pushV", { RMrDI
} },
1458 { "popV", { RMrAX
} },
1459 { "popV", { RMrCX
} },
1460 { "popV", { RMrDX
} },
1461 { "popV", { RMrBX
} },
1462 { "popV", { RMrSP
} },
1463 { "popV", { RMrBP
} },
1464 { "popV", { RMrSI
} },
1465 { "popV", { RMrDI
} },
1467 { X86_64_TABLE (X86_64_60
) },
1468 { X86_64_TABLE (X86_64_61
) },
1469 { X86_64_TABLE (X86_64_62
) },
1470 { X86_64_TABLE (X86_64_63
) },
1471 { "(bad)", { XX
} }, /* seg fs */
1472 { "(bad)", { XX
} }, /* seg gs */
1473 { "(bad)", { XX
} }, /* op size prefix */
1474 { "(bad)", { XX
} }, /* adr size prefix */
1476 { "pushT", { Iq
} },
1477 { "imulS", { Gv
, Ev
, Iv
} },
1478 { "pushT", { sIb
} },
1479 { "imulS", { Gv
, Ev
, sIb
} },
1480 { "ins{b|}", { Ybr
, indirDX
} },
1481 { X86_64_TABLE (X86_64_6D
) },
1482 { "outs{b|}", { indirDXr
, Xb
} },
1483 { X86_64_TABLE (X86_64_6F
) },
1485 { "joH", { Jb
, XX
, cond_jump_flag
} },
1486 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1487 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1488 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1489 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1490 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1491 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1492 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1494 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1495 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1496 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1497 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1498 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1499 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1500 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1501 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1503 { REG_TABLE (REG_80
) },
1504 { REG_TABLE (REG_81
) },
1505 { "(bad)", { XX
} },
1506 { REG_TABLE (REG_82
) },
1507 { "testB", { Eb
, Gb
} },
1508 { "testS", { Ev
, Gv
} },
1509 { "xchgB", { Eb
, Gb
} },
1510 { "xchgS", { Ev
, Gv
} },
1512 { "movB", { Eb
, Gb
} },
1513 { "movS", { Ev
, Gv
} },
1514 { "movB", { Gb
, EbS
} },
1515 { "movS", { Gv
, EvS
} },
1516 { "movD", { Sv
, Sw
} },
1517 { MOD_TABLE (MOD_8D
) },
1518 { "movD", { Sw
, Sv
} },
1519 { REG_TABLE (REG_8F
) },
1521 { PREFIX_TABLE (PREFIX_90
) },
1522 { "xchgS", { RMeCX
, eAX
} },
1523 { "xchgS", { RMeDX
, eAX
} },
1524 { "xchgS", { RMeBX
, eAX
} },
1525 { "xchgS", { RMeSP
, eAX
} },
1526 { "xchgS", { RMeBP
, eAX
} },
1527 { "xchgS", { RMeSI
, eAX
} },
1528 { "xchgS", { RMeDI
, eAX
} },
1530 { "cW{t|}R", { XX
} },
1531 { "cR{t|}O", { XX
} },
1532 { X86_64_TABLE (X86_64_9A
) },
1533 { "(bad)", { XX
} }, /* fwait */
1534 { "pushfT", { XX
} },
1535 { "popfT", { XX
} },
1539 { "mov%LB", { AL
, Ob
} },
1540 { "mov%LS", { eAX
, Ov
} },
1541 { "mov%LB", { Ob
, AL
} },
1542 { "mov%LS", { Ov
, eAX
} },
1543 { "movs{b|}", { Ybr
, Xb
} },
1544 { "movs{R|}", { Yvr
, Xv
} },
1545 { "cmps{b|}", { Xb
, Yb
} },
1546 { "cmps{R|}", { Xv
, Yv
} },
1548 { "testB", { AL
, Ib
} },
1549 { "testS", { eAX
, Iv
} },
1550 { "stosB", { Ybr
, AL
} },
1551 { "stosS", { Yvr
, eAX
} },
1552 { "lodsB", { ALr
, Xb
} },
1553 { "lodsS", { eAXr
, Xv
} },
1554 { "scasB", { AL
, Yb
} },
1555 { "scasS", { eAX
, Yv
} },
1557 { "movB", { RMAL
, Ib
} },
1558 { "movB", { RMCL
, Ib
} },
1559 { "movB", { RMDL
, Ib
} },
1560 { "movB", { RMBL
, Ib
} },
1561 { "movB", { RMAH
, Ib
} },
1562 { "movB", { RMCH
, Ib
} },
1563 { "movB", { RMDH
, Ib
} },
1564 { "movB", { RMBH
, Ib
} },
1566 { "mov%LV", { RMeAX
, Iv64
} },
1567 { "mov%LV", { RMeCX
, Iv64
} },
1568 { "mov%LV", { RMeDX
, Iv64
} },
1569 { "mov%LV", { RMeBX
, Iv64
} },
1570 { "mov%LV", { RMeSP
, Iv64
} },
1571 { "mov%LV", { RMeBP
, Iv64
} },
1572 { "mov%LV", { RMeSI
, Iv64
} },
1573 { "mov%LV", { RMeDI
, Iv64
} },
1575 { REG_TABLE (REG_C0
) },
1576 { REG_TABLE (REG_C1
) },
1579 { X86_64_TABLE (X86_64_C4
) },
1580 { X86_64_TABLE (X86_64_C5
) },
1581 { REG_TABLE (REG_C6
) },
1582 { REG_TABLE (REG_C7
) },
1584 { "enterT", { Iw
, Ib
} },
1585 { "leaveT", { XX
} },
1586 { "Jret{|f}P", { Iw
} },
1587 { "Jret{|f}P", { XX
} },
1590 { X86_64_TABLE (X86_64_CE
) },
1591 { "iretP", { XX
} },
1593 { REG_TABLE (REG_D0
) },
1594 { REG_TABLE (REG_D1
) },
1595 { REG_TABLE (REG_D2
) },
1596 { REG_TABLE (REG_D3
) },
1597 { X86_64_TABLE (X86_64_D4
) },
1598 { X86_64_TABLE (X86_64_D5
) },
1599 { "(bad)", { XX
} },
1600 { "xlat", { DSBX
} },
1611 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1612 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1613 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1614 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1615 { "inB", { AL
, Ib
} },
1616 { "inG", { zAX
, Ib
} },
1617 { "outB", { Ib
, AL
} },
1618 { "outG", { Ib
, zAX
} },
1620 { "callT", { Jv
} },
1622 { X86_64_TABLE (X86_64_EA
) },
1624 { "inB", { AL
, indirDX
} },
1625 { "inG", { zAX
, indirDX
} },
1626 { "outB", { indirDX
, AL
} },
1627 { "outG", { indirDX
, zAX
} },
1629 { "(bad)", { XX
} }, /* lock prefix */
1630 { "icebp", { XX
} },
1631 { "(bad)", { XX
} }, /* repne */
1632 { "(bad)", { XX
} }, /* repz */
1635 { REG_TABLE (REG_F6
) },
1636 { REG_TABLE (REG_F7
) },
1644 { REG_TABLE (REG_FE
) },
1645 { REG_TABLE (REG_FF
) },
1648 static const struct dis386 dis386_twobyte
[] = {
1650 { REG_TABLE (REG_0F00
) },
1651 { REG_TABLE (REG_0F01
) },
1652 { "larS", { Gv
, Ew
} },
1653 { "lslS", { Gv
, Ew
} },
1654 { "(bad)", { XX
} },
1655 { "syscall", { XX
} },
1657 { "sysretP", { XX
} },
1660 { "wbinvd", { XX
} },
1661 { "(bad)", { XX
} },
1663 { "(bad)", { XX
} },
1664 { REG_TABLE (REG_0F0D
) },
1665 { "femms", { XX
} },
1666 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1668 { PREFIX_TABLE (PREFIX_0F10
) },
1669 { PREFIX_TABLE (PREFIX_0F11
) },
1670 { PREFIX_TABLE (PREFIX_0F12
) },
1671 { MOD_TABLE (MOD_0F13
) },
1672 { "unpcklpX", { XM
, EXx
} },
1673 { "unpckhpX", { XM
, EXx
} },
1674 { PREFIX_TABLE (PREFIX_0F16
) },
1675 { MOD_TABLE (MOD_0F17
) },
1677 { REG_TABLE (REG_0F18
) },
1686 { MOD_TABLE (MOD_0F20
) },
1687 { MOD_TABLE (MOD_0F21
) },
1688 { MOD_TABLE (MOD_0F22
) },
1689 { MOD_TABLE (MOD_0F23
) },
1690 { MOD_TABLE (MOD_0F24
) },
1691 { "(bad)", { XX
} },
1692 { MOD_TABLE (MOD_0F26
) },
1693 { "(bad)", { XX
} },
1695 { "movapX", { XM
, EXx
} },
1696 { "movapX", { EXxS
, XM
} },
1697 { PREFIX_TABLE (PREFIX_0F2A
) },
1698 { PREFIX_TABLE (PREFIX_0F2B
) },
1699 { PREFIX_TABLE (PREFIX_0F2C
) },
1700 { PREFIX_TABLE (PREFIX_0F2D
) },
1701 { PREFIX_TABLE (PREFIX_0F2E
) },
1702 { PREFIX_TABLE (PREFIX_0F2F
) },
1704 { "wrmsr", { XX
} },
1705 { "rdtsc", { XX
} },
1706 { "rdmsr", { XX
} },
1707 { "rdpmc", { XX
} },
1708 { "sysenter", { XX
} },
1709 { "sysexit", { XX
} },
1710 { "(bad)", { XX
} },
1711 { "getsec", { XX
} },
1713 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
1714 { "(bad)", { XX
} },
1715 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
1716 { "(bad)", { XX
} },
1717 { "(bad)", { XX
} },
1718 { "(bad)", { XX
} },
1719 { "(bad)", { XX
} },
1720 { "(bad)", { XX
} },
1722 { "cmovoS", { Gv
, Ev
} },
1723 { "cmovnoS", { Gv
, Ev
} },
1724 { "cmovbS", { Gv
, Ev
} },
1725 { "cmovaeS", { Gv
, Ev
} },
1726 { "cmoveS", { Gv
, Ev
} },
1727 { "cmovneS", { Gv
, Ev
} },
1728 { "cmovbeS", { Gv
, Ev
} },
1729 { "cmovaS", { Gv
, Ev
} },
1731 { "cmovsS", { Gv
, Ev
} },
1732 { "cmovnsS", { Gv
, Ev
} },
1733 { "cmovpS", { Gv
, Ev
} },
1734 { "cmovnpS", { Gv
, Ev
} },
1735 { "cmovlS", { Gv
, Ev
} },
1736 { "cmovgeS", { Gv
, Ev
} },
1737 { "cmovleS", { Gv
, Ev
} },
1738 { "cmovgS", { Gv
, Ev
} },
1740 { MOD_TABLE (MOD_0F51
) },
1741 { PREFIX_TABLE (PREFIX_0F51
) },
1742 { PREFIX_TABLE (PREFIX_0F52
) },
1743 { PREFIX_TABLE (PREFIX_0F53
) },
1744 { "andpX", { XM
, EXx
} },
1745 { "andnpX", { XM
, EXx
} },
1746 { "orpX", { XM
, EXx
} },
1747 { "xorpX", { XM
, EXx
} },
1749 { PREFIX_TABLE (PREFIX_0F58
) },
1750 { PREFIX_TABLE (PREFIX_0F59
) },
1751 { PREFIX_TABLE (PREFIX_0F5A
) },
1752 { PREFIX_TABLE (PREFIX_0F5B
) },
1753 { PREFIX_TABLE (PREFIX_0F5C
) },
1754 { PREFIX_TABLE (PREFIX_0F5D
) },
1755 { PREFIX_TABLE (PREFIX_0F5E
) },
1756 { PREFIX_TABLE (PREFIX_0F5F
) },
1758 { PREFIX_TABLE (PREFIX_0F60
) },
1759 { PREFIX_TABLE (PREFIX_0F61
) },
1760 { PREFIX_TABLE (PREFIX_0F62
) },
1761 { "packsswb", { MX
, EM
} },
1762 { "pcmpgtb", { MX
, EM
} },
1763 { "pcmpgtw", { MX
, EM
} },
1764 { "pcmpgtd", { MX
, EM
} },
1765 { "packuswb", { MX
, EM
} },
1767 { "punpckhbw", { MX
, EM
} },
1768 { "punpckhwd", { MX
, EM
} },
1769 { "punpckhdq", { MX
, EM
} },
1770 { "packssdw", { MX
, EM
} },
1771 { PREFIX_TABLE (PREFIX_0F6C
) },
1772 { PREFIX_TABLE (PREFIX_0F6D
) },
1773 { "movK", { MX
, Edq
} },
1774 { PREFIX_TABLE (PREFIX_0F6F
) },
1776 { PREFIX_TABLE (PREFIX_0F70
) },
1777 { REG_TABLE (REG_0F71
) },
1778 { REG_TABLE (REG_0F72
) },
1779 { REG_TABLE (REG_0F73
) },
1780 { "pcmpeqb", { MX
, EM
} },
1781 { "pcmpeqw", { MX
, EM
} },
1782 { "pcmpeqd", { MX
, EM
} },
1785 { PREFIX_TABLE (PREFIX_0F78
) },
1786 { PREFIX_TABLE (PREFIX_0F79
) },
1787 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
1788 { "(bad)", { XX
} },
1789 { PREFIX_TABLE (PREFIX_0F7C
) },
1790 { PREFIX_TABLE (PREFIX_0F7D
) },
1791 { PREFIX_TABLE (PREFIX_0F7E
) },
1792 { PREFIX_TABLE (PREFIX_0F7F
) },
1794 { "joH", { Jv
, XX
, cond_jump_flag
} },
1795 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
1796 { "jbH", { Jv
, XX
, cond_jump_flag
} },
1797 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
1798 { "jeH", { Jv
, XX
, cond_jump_flag
} },
1799 { "jneH", { Jv
, XX
, cond_jump_flag
} },
1800 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
1801 { "jaH", { Jv
, XX
, cond_jump_flag
} },
1803 { "jsH", { Jv
, XX
, cond_jump_flag
} },
1804 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
1805 { "jpH", { Jv
, XX
, cond_jump_flag
} },
1806 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
1807 { "jlH", { Jv
, XX
, cond_jump_flag
} },
1808 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
1809 { "jleH", { Jv
, XX
, cond_jump_flag
} },
1810 { "jgH", { Jv
, XX
, cond_jump_flag
} },
1813 { "setno", { Eb
} },
1815 { "setae", { Eb
} },
1817 { "setne", { Eb
} },
1818 { "setbe", { Eb
} },
1822 { "setns", { Eb
} },
1824 { "setnp", { Eb
} },
1826 { "setge", { Eb
} },
1827 { "setle", { Eb
} },
1830 { "pushT", { fs
} },
1832 { "cpuid", { XX
} },
1833 { "btS", { Ev
, Gv
} },
1834 { "shldS", { Ev
, Gv
, Ib
} },
1835 { "shldS", { Ev
, Gv
, CL
} },
1836 { REG_TABLE (REG_0FA6
) },
1837 { REG_TABLE (REG_0FA7
) },
1839 { "pushT", { gs
} },
1842 { "btsS", { Ev
, Gv
} },
1843 { "shrdS", { Ev
, Gv
, Ib
} },
1844 { "shrdS", { Ev
, Gv
, CL
} },
1845 { REG_TABLE (REG_0FAE
) },
1846 { "imulS", { Gv
, Ev
} },
1848 { "cmpxchgB", { Eb
, Gb
} },
1849 { "cmpxchgS", { Ev
, Gv
} },
1850 { MOD_TABLE (MOD_0FB2
) },
1851 { "btrS", { Ev
, Gv
} },
1852 { MOD_TABLE (MOD_0FB4
) },
1853 { MOD_TABLE (MOD_0FB5
) },
1854 { "movz{bR|x}", { Gv
, Eb
} },
1855 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
1857 { PREFIX_TABLE (PREFIX_0FB8
) },
1859 { REG_TABLE (REG_0FBA
) },
1860 { "btcS", { Ev
, Gv
} },
1861 { "bsfS", { Gv
, Ev
} },
1862 { PREFIX_TABLE (PREFIX_0FBD
) },
1863 { "movs{bR|x}", { Gv
, Eb
} },
1864 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
1866 { "xaddB", { Eb
, Gb
} },
1867 { "xaddS", { Ev
, Gv
} },
1868 { PREFIX_TABLE (PREFIX_0FC2
) },
1869 { PREFIX_TABLE (PREFIX_0FC3
) },
1870 { "pinsrw", { MX
, Edqw
, Ib
} },
1871 { "pextrw", { Gdq
, MS
, Ib
} },
1872 { "shufpX", { XM
, EXx
, Ib
} },
1873 { REG_TABLE (REG_0FC7
) },
1875 { "bswap", { RMeAX
} },
1876 { "bswap", { RMeCX
} },
1877 { "bswap", { RMeDX
} },
1878 { "bswap", { RMeBX
} },
1879 { "bswap", { RMeSP
} },
1880 { "bswap", { RMeBP
} },
1881 { "bswap", { RMeSI
} },
1882 { "bswap", { RMeDI
} },
1884 { PREFIX_TABLE (PREFIX_0FD0
) },
1885 { "psrlw", { MX
, EM
} },
1886 { "psrld", { MX
, EM
} },
1887 { "psrlq", { MX
, EM
} },
1888 { "paddq", { MX
, EM
} },
1889 { "pmullw", { MX
, EM
} },
1890 { PREFIX_TABLE (PREFIX_0FD6
) },
1891 { MOD_TABLE (MOD_0FD7
) },
1893 { "psubusb", { MX
, EM
} },
1894 { "psubusw", { MX
, EM
} },
1895 { "pminub", { MX
, EM
} },
1896 { "pand", { MX
, EM
} },
1897 { "paddusb", { MX
, EM
} },
1898 { "paddusw", { MX
, EM
} },
1899 { "pmaxub", { MX
, EM
} },
1900 { "pandn", { MX
, EM
} },
1902 { "pavgb", { MX
, EM
} },
1903 { "psraw", { MX
, EM
} },
1904 { "psrad", { MX
, EM
} },
1905 { "pavgw", { MX
, EM
} },
1906 { "pmulhuw", { MX
, EM
} },
1907 { "pmulhw", { MX
, EM
} },
1908 { PREFIX_TABLE (PREFIX_0FE6
) },
1909 { PREFIX_TABLE (PREFIX_0FE7
) },
1911 { "psubsb", { MX
, EM
} },
1912 { "psubsw", { MX
, EM
} },
1913 { "pminsw", { MX
, EM
} },
1914 { "por", { MX
, EM
} },
1915 { "paddsb", { MX
, EM
} },
1916 { "paddsw", { MX
, EM
} },
1917 { "pmaxsw", { MX
, EM
} },
1918 { "pxor", { MX
, EM
} },
1920 { PREFIX_TABLE (PREFIX_0FF0
) },
1921 { "psllw", { MX
, EM
} },
1922 { "pslld", { MX
, EM
} },
1923 { "psllq", { MX
, EM
} },
1924 { "pmuludq", { MX
, EM
} },
1925 { "pmaddwd", { MX
, EM
} },
1926 { "psadbw", { MX
, EM
} },
1927 { PREFIX_TABLE (PREFIX_0FF7
) },
1929 { "psubb", { MX
, EM
} },
1930 { "psubw", { MX
, EM
} },
1931 { "psubd", { MX
, EM
} },
1932 { "psubq", { MX
, EM
} },
1933 { "paddb", { MX
, EM
} },
1934 { "paddw", { MX
, EM
} },
1935 { "paddd", { MX
, EM
} },
1936 { "(bad)", { XX
} },
1939 static const unsigned char onebyte_has_modrm
[256] = {
1940 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1941 /* ------------------------------- */
1942 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1943 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1944 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1945 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1946 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1947 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1948 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1949 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1950 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1951 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1952 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1953 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1954 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1955 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1956 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1957 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1958 /* ------------------------------- */
1959 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1962 static const unsigned char twobyte_has_modrm
[256] = {
1963 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1964 /* ------------------------------- */
1965 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1966 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
1967 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1968 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1969 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1970 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1971 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1972 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1973 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1974 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1975 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1976 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1977 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1978 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1979 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1980 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1981 /* ------------------------------- */
1982 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1985 static char obuf
[100];
1987 static char *mnemonicendp
;
1988 static char scratchbuf
[100];
1989 static unsigned char *start_codep
;
1990 static unsigned char *insn_codep
;
1991 static unsigned char *codep
;
1992 static int last_lock_prefix
;
1993 static int last_repz_prefix
;
1994 static int last_repnz_prefix
;
1995 static int last_data_prefix
;
1996 static int last_addr_prefix
;
1997 static int last_rex_prefix
;
1998 static int last_seg_prefix
;
1999 #define MAX_CODE_LENGTH 15
2000 /* We can up to 14 prefixes since the maximum instruction length is
2002 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2003 static disassemble_info
*the_info
;
2011 static unsigned char need_modrm
;
2014 int register_specifier
;
2020 static unsigned char need_vex
;
2021 static unsigned char need_vex_reg
;
2022 static unsigned char vex_w_done
;
2030 /* If we are accessing mod/rm/reg without need_modrm set, then the
2031 values are stale. Hitting this abort likely indicates that you
2032 need to update onebyte_has_modrm or twobyte_has_modrm. */
2033 #define MODRM_CHECK if (!need_modrm) abort ()
2035 static const char **names64
;
2036 static const char **names32
;
2037 static const char **names16
;
2038 static const char **names8
;
2039 static const char **names8rex
;
2040 static const char **names_seg
;
2041 static const char *index64
;
2042 static const char *index32
;
2043 static const char **index16
;
2045 static const char *intel_names64
[] = {
2046 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2047 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2049 static const char *intel_names32
[] = {
2050 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2051 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2053 static const char *intel_names16
[] = {
2054 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2055 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2057 static const char *intel_names8
[] = {
2058 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2060 static const char *intel_names8rex
[] = {
2061 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2062 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2064 static const char *intel_names_seg
[] = {
2065 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2067 static const char *intel_index64
= "riz";
2068 static const char *intel_index32
= "eiz";
2069 static const char *intel_index16
[] = {
2070 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2073 static const char *att_names64
[] = {
2074 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2075 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2077 static const char *att_names32
[] = {
2078 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2079 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2081 static const char *att_names16
[] = {
2082 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2083 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2085 static const char *att_names8
[] = {
2086 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2088 static const char *att_names8rex
[] = {
2089 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2090 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2092 static const char *att_names_seg
[] = {
2093 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2095 static const char *att_index64
= "%riz";
2096 static const char *att_index32
= "%eiz";
2097 static const char *att_index16
[] = {
2098 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2101 static const struct dis386 reg_table
[][8] = {
2104 { "addA", { Eb
, Ib
} },
2105 { "orA", { Eb
, Ib
} },
2106 { "adcA", { Eb
, Ib
} },
2107 { "sbbA", { Eb
, Ib
} },
2108 { "andA", { Eb
, Ib
} },
2109 { "subA", { Eb
, Ib
} },
2110 { "xorA", { Eb
, Ib
} },
2111 { "cmpA", { Eb
, Ib
} },
2115 { "addQ", { Ev
, Iv
} },
2116 { "orQ", { Ev
, Iv
} },
2117 { "adcQ", { Ev
, Iv
} },
2118 { "sbbQ", { Ev
, Iv
} },
2119 { "andQ", { Ev
, Iv
} },
2120 { "subQ", { Ev
, Iv
} },
2121 { "xorQ", { Ev
, Iv
} },
2122 { "cmpQ", { Ev
, Iv
} },
2126 { "addQ", { Ev
, sIb
} },
2127 { "orQ", { Ev
, sIb
} },
2128 { "adcQ", { Ev
, sIb
} },
2129 { "sbbQ", { Ev
, sIb
} },
2130 { "andQ", { Ev
, sIb
} },
2131 { "subQ", { Ev
, sIb
} },
2132 { "xorQ", { Ev
, sIb
} },
2133 { "cmpQ", { Ev
, sIb
} },
2137 { "popU", { stackEv
} },
2138 { XOP_8F_TABLE (XOP_09
) },
2139 { "(bad)", { XX
} },
2140 { "(bad)", { XX
} },
2141 { "(bad)", { XX
} },
2142 { XOP_8F_TABLE (XOP_09
) },
2143 { "(bad)", { XX
} },
2144 { "(bad)", { XX
} },
2148 { "rolA", { Eb
, Ib
} },
2149 { "rorA", { Eb
, Ib
} },
2150 { "rclA", { Eb
, Ib
} },
2151 { "rcrA", { Eb
, Ib
} },
2152 { "shlA", { Eb
, Ib
} },
2153 { "shrA", { Eb
, Ib
} },
2154 { "(bad)", { XX
} },
2155 { "sarA", { Eb
, Ib
} },
2159 { "rolQ", { Ev
, Ib
} },
2160 { "rorQ", { Ev
, Ib
} },
2161 { "rclQ", { Ev
, Ib
} },
2162 { "rcrQ", { Ev
, Ib
} },
2163 { "shlQ", { Ev
, Ib
} },
2164 { "shrQ", { Ev
, Ib
} },
2165 { "(bad)", { XX
} },
2166 { "sarQ", { Ev
, Ib
} },
2170 { "movA", { Eb
, Ib
} },
2171 { "(bad)", { XX
} },
2172 { "(bad)", { XX
} },
2173 { "(bad)", { XX
} },
2174 { "(bad)", { XX
} },
2175 { "(bad)", { XX
} },
2176 { "(bad)", { XX
} },
2177 { "(bad)", { XX
} },
2181 { "movQ", { Ev
, Iv
} },
2182 { "(bad)", { XX
} },
2183 { "(bad)", { XX
} },
2184 { "(bad)", { XX
} },
2185 { "(bad)", { XX
} },
2186 { "(bad)", { XX
} },
2187 { "(bad)", { XX
} },
2188 { "(bad)", { XX
} },
2192 { "rolA", { Eb
, I1
} },
2193 { "rorA", { Eb
, I1
} },
2194 { "rclA", { Eb
, I1
} },
2195 { "rcrA", { Eb
, I1
} },
2196 { "shlA", { Eb
, I1
} },
2197 { "shrA", { Eb
, I1
} },
2198 { "(bad)", { XX
} },
2199 { "sarA", { Eb
, I1
} },
2203 { "rolQ", { Ev
, I1
} },
2204 { "rorQ", { Ev
, I1
} },
2205 { "rclQ", { Ev
, I1
} },
2206 { "rcrQ", { Ev
, I1
} },
2207 { "shlQ", { Ev
, I1
} },
2208 { "shrQ", { Ev
, I1
} },
2209 { "(bad)", { XX
} },
2210 { "sarQ", { Ev
, I1
} },
2214 { "rolA", { Eb
, CL
} },
2215 { "rorA", { Eb
, CL
} },
2216 { "rclA", { Eb
, CL
} },
2217 { "rcrA", { Eb
, CL
} },
2218 { "shlA", { Eb
, CL
} },
2219 { "shrA", { Eb
, CL
} },
2220 { "(bad)", { XX
} },
2221 { "sarA", { Eb
, CL
} },
2225 { "rolQ", { Ev
, CL
} },
2226 { "rorQ", { Ev
, CL
} },
2227 { "rclQ", { Ev
, CL
} },
2228 { "rcrQ", { Ev
, CL
} },
2229 { "shlQ", { Ev
, CL
} },
2230 { "shrQ", { Ev
, CL
} },
2231 { "(bad)", { XX
} },
2232 { "sarQ", { Ev
, CL
} },
2236 { "testA", { Eb
, Ib
} },
2237 { "(bad)", { XX
} },
2240 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2241 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2242 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2243 { "idivA", { Eb
} }, /* and idiv for consistency. */
2247 { "testQ", { Ev
, Iv
} },
2248 { "(bad)", { XX
} },
2251 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2252 { "imulQ", { Ev
} },
2254 { "idivQ", { Ev
} },
2260 { "(bad)", { XX
} },
2261 { "(bad)", { XX
} },
2262 { "(bad)", { XX
} },
2263 { "(bad)", { XX
} },
2264 { "(bad)", { XX
} },
2265 { "(bad)", { XX
} },
2271 { "callT", { indirEv
} },
2272 { "JcallT", { indirEp
} },
2273 { "jmpT", { indirEv
} },
2274 { "JjmpT", { indirEp
} },
2275 { "pushU", { stackEv
} },
2276 { "(bad)", { XX
} },
2280 { "sldtD", { Sv
} },
2286 { "(bad)", { XX
} },
2287 { "(bad)", { XX
} },
2291 { MOD_TABLE (MOD_0F01_REG_0
) },
2292 { MOD_TABLE (MOD_0F01_REG_1
) },
2293 { MOD_TABLE (MOD_0F01_REG_2
) },
2294 { MOD_TABLE (MOD_0F01_REG_3
) },
2295 { "smswD", { Sv
} },
2296 { "(bad)", { XX
} },
2298 { MOD_TABLE (MOD_0F01_REG_7
) },
2302 { "prefetch", { Eb
} },
2303 { "prefetchw", { Eb
} },
2304 { "(bad)", { XX
} },
2305 { "(bad)", { XX
} },
2306 { "(bad)", { XX
} },
2307 { "(bad)", { XX
} },
2308 { "(bad)", { XX
} },
2309 { "(bad)", { XX
} },
2313 { MOD_TABLE (MOD_0F18_REG_0
) },
2314 { MOD_TABLE (MOD_0F18_REG_1
) },
2315 { MOD_TABLE (MOD_0F18_REG_2
) },
2316 { MOD_TABLE (MOD_0F18_REG_3
) },
2317 { "(bad)", { XX
} },
2318 { "(bad)", { XX
} },
2319 { "(bad)", { XX
} },
2320 { "(bad)", { XX
} },
2324 { "(bad)", { XX
} },
2325 { "(bad)", { XX
} },
2326 { MOD_TABLE (MOD_0F71_REG_2
) },
2327 { "(bad)", { XX
} },
2328 { MOD_TABLE (MOD_0F71_REG_4
) },
2329 { "(bad)", { XX
} },
2330 { MOD_TABLE (MOD_0F71_REG_6
) },
2331 { "(bad)", { XX
} },
2335 { "(bad)", { XX
} },
2336 { "(bad)", { XX
} },
2337 { MOD_TABLE (MOD_0F72_REG_2
) },
2338 { "(bad)", { XX
} },
2339 { MOD_TABLE (MOD_0F72_REG_4
) },
2340 { "(bad)", { XX
} },
2341 { MOD_TABLE (MOD_0F72_REG_6
) },
2342 { "(bad)", { XX
} },
2346 { "(bad)", { XX
} },
2347 { "(bad)", { XX
} },
2348 { MOD_TABLE (MOD_0F73_REG_2
) },
2349 { MOD_TABLE (MOD_0F73_REG_3
) },
2350 { "(bad)", { XX
} },
2351 { "(bad)", { XX
} },
2352 { MOD_TABLE (MOD_0F73_REG_6
) },
2353 { MOD_TABLE (MOD_0F73_REG_7
) },
2357 { "montmul", { { OP_0f07
, 0 } } },
2358 { "xsha1", { { OP_0f07
, 0 } } },
2359 { "xsha256", { { OP_0f07
, 0 } } },
2360 { "(bad)", { { OP_0f07
, 0 } } },
2361 { "(bad)", { { OP_0f07
, 0 } } },
2362 { "(bad)", { { OP_0f07
, 0 } } },
2363 { "(bad)", { { OP_0f07
, 0 } } },
2364 { "(bad)", { { OP_0f07
, 0 } } },
2368 { "xstore-rng", { { OP_0f07
, 0 } } },
2369 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2370 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2371 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2372 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2373 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2374 { "(bad)", { { OP_0f07
, 0 } } },
2375 { "(bad)", { { OP_0f07
, 0 } } },
2379 { MOD_TABLE (MOD_0FAE_REG_0
) },
2380 { MOD_TABLE (MOD_0FAE_REG_1
) },
2381 { MOD_TABLE (MOD_0FAE_REG_2
) },
2382 { MOD_TABLE (MOD_0FAE_REG_3
) },
2383 { MOD_TABLE (MOD_0FAE_REG_4
) },
2384 { MOD_TABLE (MOD_0FAE_REG_5
) },
2385 { MOD_TABLE (MOD_0FAE_REG_6
) },
2386 { MOD_TABLE (MOD_0FAE_REG_7
) },
2390 { "(bad)", { XX
} },
2391 { "(bad)", { XX
} },
2392 { "(bad)", { XX
} },
2393 { "(bad)", { XX
} },
2394 { "btQ", { Ev
, Ib
} },
2395 { "btsQ", { Ev
, Ib
} },
2396 { "btrQ", { Ev
, Ib
} },
2397 { "btcQ", { Ev
, Ib
} },
2401 { "(bad)", { XX
} },
2402 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2403 { "(bad)", { XX
} },
2404 { "(bad)", { XX
} },
2405 { "(bad)", { XX
} },
2406 { "(bad)", { XX
} },
2407 { MOD_TABLE (MOD_0FC7_REG_6
) },
2408 { MOD_TABLE (MOD_0FC7_REG_7
) },
2412 { "(bad)", { XX
} },
2413 { "(bad)", { XX
} },
2414 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2415 { "(bad)", { XX
} },
2416 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2417 { "(bad)", { XX
} },
2418 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2419 { "(bad)", { XX
} },
2423 { "(bad)", { XX
} },
2424 { "(bad)", { XX
} },
2425 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2426 { "(bad)", { XX
} },
2427 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2428 { "(bad)", { XX
} },
2429 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2430 { "(bad)", { XX
} },
2434 { "(bad)", { XX
} },
2435 { "(bad)", { XX
} },
2436 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2437 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2438 { "(bad)", { XX
} },
2439 { "(bad)", { XX
} },
2440 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2441 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2445 { "(bad)", { XX
} },
2446 { "(bad)", { XX
} },
2447 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2448 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2449 { "(bad)", { XX
} },
2450 { "(bad)", { XX
} },
2451 { "(bad)", { XX
} },
2452 { "(bad)", { XX
} },
2456 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2457 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2458 { "(bad)", { XX
} },
2459 { "(bad)", { XX
} },
2460 { "(bad)", { XX
} },
2461 { "(bad)", { XX
} },
2462 { "(bad)", { XX
} },
2463 { "(bad)", { XX
} },
2467 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2468 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2469 { "(bad)", { XX
} },
2470 { "(bad)", { XX
} },
2471 { "(bad)", { XX
} },
2472 { "(bad)", { XX
} },
2473 { "(bad)", { XX
} },
2474 { "(bad)", { XX
} },
2478 static const struct dis386 prefix_table
[][4] = {
2481 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2482 { "pause", { XX
} },
2483 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2484 { "(bad)", { XX
} },
2489 { "movups", { XM
, EXx
} },
2490 { "movss", { XM
, EXd
} },
2491 { "movupd", { XM
, EXx
} },
2492 { "movsd", { XM
, EXq
} },
2497 { "movups", { EXxS
, XM
} },
2498 { "movss", { EXdS
, XM
} },
2499 { "movupd", { EXxS
, XM
} },
2500 { "movsd", { EXqS
, XM
} },
2505 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2506 { "movsldup", { XM
, EXx
} },
2507 { "movlpd", { XM
, EXq
} },
2508 { "movddup", { XM
, EXq
} },
2513 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2514 { "movshdup", { XM
, EXx
} },
2515 { "movhpd", { XM
, EXq
} },
2516 { "(bad)", { XX
} },
2521 { "cvtpi2ps", { XM
, EMCq
} },
2522 { "cvtsi2ss%LQ", { XM
, Ev
} },
2523 { "cvtpi2pd", { XM
, EMCq
} },
2524 { "cvtsi2sd%LQ", { XM
, Ev
} },
2529 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2530 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2531 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2532 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2537 { "cvttps2pi", { MXC
, EXq
} },
2538 { "cvttss2siY", { Gv
, EXd
} },
2539 { "cvttpd2pi", { MXC
, EXx
} },
2540 { "cvttsd2siY", { Gv
, EXq
} },
2545 { "cvtps2pi", { MXC
, EXq
} },
2546 { "cvtss2siY", { Gv
, EXd
} },
2547 { "cvtpd2pi", { MXC
, EXx
} },
2548 { "cvtsd2siY", { Gv
, EXq
} },
2553 { "ucomiss",{ XM
, EXd
} },
2554 { "(bad)", { XX
} },
2555 { "ucomisd",{ XM
, EXq
} },
2556 { "(bad)", { XX
} },
2561 { "comiss", { XM
, EXd
} },
2562 { "(bad)", { XX
} },
2563 { "comisd", { XM
, EXq
} },
2564 { "(bad)", { XX
} },
2569 { "sqrtps", { XM
, EXx
} },
2570 { "sqrtss", { XM
, EXd
} },
2571 { "sqrtpd", { XM
, EXx
} },
2572 { "sqrtsd", { XM
, EXq
} },
2577 { "rsqrtps",{ XM
, EXx
} },
2578 { "rsqrtss",{ XM
, EXd
} },
2579 { "(bad)", { XX
} },
2580 { "(bad)", { XX
} },
2585 { "rcpps", { XM
, EXx
} },
2586 { "rcpss", { XM
, EXd
} },
2587 { "(bad)", { XX
} },
2588 { "(bad)", { XX
} },
2593 { "addps", { XM
, EXx
} },
2594 { "addss", { XM
, EXd
} },
2595 { "addpd", { XM
, EXx
} },
2596 { "addsd", { XM
, EXq
} },
2601 { "mulps", { XM
, EXx
} },
2602 { "mulss", { XM
, EXd
} },
2603 { "mulpd", { XM
, EXx
} },
2604 { "mulsd", { XM
, EXq
} },
2609 { "cvtps2pd", { XM
, EXq
} },
2610 { "cvtss2sd", { XM
, EXd
} },
2611 { "cvtpd2ps", { XM
, EXx
} },
2612 { "cvtsd2ss", { XM
, EXq
} },
2617 { "cvtdq2ps", { XM
, EXx
} },
2618 { "cvttps2dq", { XM
, EXx
} },
2619 { "cvtps2dq", { XM
, EXx
} },
2620 { "(bad)", { XX
} },
2625 { "subps", { XM
, EXx
} },
2626 { "subss", { XM
, EXd
} },
2627 { "subpd", { XM
, EXx
} },
2628 { "subsd", { XM
, EXq
} },
2633 { "minps", { XM
, EXx
} },
2634 { "minss", { XM
, EXd
} },
2635 { "minpd", { XM
, EXx
} },
2636 { "minsd", { XM
, EXq
} },
2641 { "divps", { XM
, EXx
} },
2642 { "divss", { XM
, EXd
} },
2643 { "divpd", { XM
, EXx
} },
2644 { "divsd", { XM
, EXq
} },
2649 { "maxps", { XM
, EXx
} },
2650 { "maxss", { XM
, EXd
} },
2651 { "maxpd", { XM
, EXx
} },
2652 { "maxsd", { XM
, EXq
} },
2657 { "punpcklbw",{ MX
, EMd
} },
2658 { "(bad)", { XX
} },
2659 { "punpcklbw",{ MX
, EMx
} },
2660 { "(bad)", { XX
} },
2665 { "punpcklwd",{ MX
, EMd
} },
2666 { "(bad)", { XX
} },
2667 { "punpcklwd",{ MX
, EMx
} },
2668 { "(bad)", { XX
} },
2673 { "punpckldq",{ MX
, EMd
} },
2674 { "(bad)", { XX
} },
2675 { "punpckldq",{ MX
, EMx
} },
2676 { "(bad)", { XX
} },
2681 { "(bad)", { XX
} },
2682 { "(bad)", { XX
} },
2683 { "punpcklqdq", { XM
, EXx
} },
2684 { "(bad)", { XX
} },
2689 { "(bad)", { XX
} },
2690 { "(bad)", { XX
} },
2691 { "punpckhqdq", { XM
, EXx
} },
2692 { "(bad)", { XX
} },
2697 { "movq", { MX
, EM
} },
2698 { "movdqu", { XM
, EXx
} },
2699 { "movdqa", { XM
, EXx
} },
2700 { "(bad)", { XX
} },
2705 { "pshufw", { MX
, EM
, Ib
} },
2706 { "pshufhw",{ XM
, EXx
, Ib
} },
2707 { "pshufd", { XM
, EXx
, Ib
} },
2708 { "pshuflw",{ XM
, EXx
, Ib
} },
2711 /* PREFIX_0F73_REG_3 */
2713 { "(bad)", { XX
} },
2714 { "(bad)", { XX
} },
2715 { "psrldq", { XS
, Ib
} },
2716 { "(bad)", { XX
} },
2719 /* PREFIX_0F73_REG_7 */
2721 { "(bad)", { XX
} },
2722 { "(bad)", { XX
} },
2723 { "pslldq", { XS
, Ib
} },
2724 { "(bad)", { XX
} },
2729 {"vmread", { Em
, Gm
} },
2731 {"extrq", { XS
, Ib
, Ib
} },
2732 {"insertq", { XM
, XS
, Ib
, Ib
} },
2737 {"vmwrite", { Gm
, Em
} },
2739 {"extrq", { XM
, XS
} },
2740 {"insertq", { XM
, XS
} },
2745 { "(bad)", { XX
} },
2746 { "(bad)", { XX
} },
2747 { "haddpd", { XM
, EXx
} },
2748 { "haddps", { XM
, EXx
} },
2753 { "(bad)", { XX
} },
2754 { "(bad)", { XX
} },
2755 { "hsubpd", { XM
, EXx
} },
2756 { "hsubps", { XM
, EXx
} },
2761 { "movK", { Edq
, MX
} },
2762 { "movq", { XM
, EXq
} },
2763 { "movK", { Edq
, XM
} },
2764 { "(bad)", { XX
} },
2769 { "movq", { EMS
, MX
} },
2770 { "movdqu", { EXxS
, XM
} },
2771 { "movdqa", { EXxS
, XM
} },
2772 { "(bad)", { XX
} },
2777 { "(bad)", { XX
} },
2778 { "popcntS", { Gv
, Ev
} },
2779 { "(bad)", { XX
} },
2780 { "(bad)", { XX
} },
2785 { "bsrS", { Gv
, Ev
} },
2786 { "lzcntS", { Gv
, Ev
} },
2787 { "bsrS", { Gv
, Ev
} },
2788 { "(bad)", { XX
} },
2793 { "cmpps", { XM
, EXx
, CMP
} },
2794 { "cmpss", { XM
, EXd
, CMP
} },
2795 { "cmppd", { XM
, EXx
, CMP
} },
2796 { "cmpsd", { XM
, EXq
, CMP
} },
2801 { "movntiS", { Ma
, Gv
} },
2802 { "(bad)", { XX
} },
2803 { "(bad)", { XX
} },
2804 { "(bad)", { XX
} },
2807 /* PREFIX_0FC7_REG_6 */
2809 { "vmptrld",{ Mq
} },
2810 { "vmxon", { Mq
} },
2811 { "vmclear",{ Mq
} },
2812 { "(bad)", { XX
} },
2817 { "(bad)", { XX
} },
2818 { "(bad)", { XX
} },
2819 { "addsubpd", { XM
, EXx
} },
2820 { "addsubps", { XM
, EXx
} },
2825 { "(bad)", { XX
} },
2826 { "movq2dq",{ XM
, MS
} },
2827 { "movq", { EXqS
, XM
} },
2828 { "movdq2q",{ MX
, XS
} },
2833 { "(bad)", { XX
} },
2834 { "cvtdq2pd", { XM
, EXq
} },
2835 { "cvttpd2dq", { XM
, EXx
} },
2836 { "cvtpd2dq", { XM
, EXx
} },
2841 { "movntq", { Mq
, MX
} },
2842 { "(bad)", { XX
} },
2843 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
2844 { "(bad)", { XX
} },
2849 { "(bad)", { XX
} },
2850 { "(bad)", { XX
} },
2851 { "(bad)", { XX
} },
2852 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
2857 { "maskmovq", { MX
, MS
} },
2858 { "(bad)", { XX
} },
2859 { "maskmovdqu", { XM
, XS
} },
2860 { "(bad)", { XX
} },
2865 { "(bad)", { XX
} },
2866 { "(bad)", { XX
} },
2867 { "pblendvb", { XM
, EXx
, XMM0
} },
2868 { "(bad)", { XX
} },
2873 { "(bad)", { XX
} },
2874 { "(bad)", { XX
} },
2875 { "blendvps", { XM
, EXx
, XMM0
} },
2876 { "(bad)", { XX
} },
2881 { "(bad)", { XX
} },
2882 { "(bad)", { XX
} },
2883 { "blendvpd", { XM
, EXx
, XMM0
} },
2884 { "(bad)", { XX
} },
2889 { "(bad)", { XX
} },
2890 { "(bad)", { XX
} },
2891 { "ptest", { XM
, EXx
} },
2892 { "(bad)", { XX
} },
2897 { "(bad)", { XX
} },
2898 { "(bad)", { XX
} },
2899 { "pmovsxbw", { XM
, EXq
} },
2900 { "(bad)", { XX
} },
2905 { "(bad)", { XX
} },
2906 { "(bad)", { XX
} },
2907 { "pmovsxbd", { XM
, EXd
} },
2908 { "(bad)", { XX
} },
2913 { "(bad)", { XX
} },
2914 { "(bad)", { XX
} },
2915 { "pmovsxbq", { XM
, EXw
} },
2916 { "(bad)", { XX
} },
2921 { "(bad)", { XX
} },
2922 { "(bad)", { XX
} },
2923 { "pmovsxwd", { XM
, EXq
} },
2924 { "(bad)", { XX
} },
2929 { "(bad)", { XX
} },
2930 { "(bad)", { XX
} },
2931 { "pmovsxwq", { XM
, EXd
} },
2932 { "(bad)", { XX
} },
2937 { "(bad)", { XX
} },
2938 { "(bad)", { XX
} },
2939 { "pmovsxdq", { XM
, EXq
} },
2940 { "(bad)", { XX
} },
2945 { "(bad)", { XX
} },
2946 { "(bad)", { XX
} },
2947 { "pmuldq", { XM
, EXx
} },
2948 { "(bad)", { XX
} },
2953 { "(bad)", { XX
} },
2954 { "(bad)", { XX
} },
2955 { "pcmpeqq", { XM
, EXx
} },
2956 { "(bad)", { XX
} },
2961 { "(bad)", { XX
} },
2962 { "(bad)", { XX
} },
2963 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
2964 { "(bad)", { XX
} },
2969 { "(bad)", { XX
} },
2970 { "(bad)", { XX
} },
2971 { "packusdw", { XM
, EXx
} },
2972 { "(bad)", { XX
} },
2977 { "(bad)", { XX
} },
2978 { "(bad)", { XX
} },
2979 { "pmovzxbw", { XM
, EXq
} },
2980 { "(bad)", { XX
} },
2985 { "(bad)", { XX
} },
2986 { "(bad)", { XX
} },
2987 { "pmovzxbd", { XM
, EXd
} },
2988 { "(bad)", { XX
} },
2993 { "(bad)", { XX
} },
2994 { "(bad)", { XX
} },
2995 { "pmovzxbq", { XM
, EXw
} },
2996 { "(bad)", { XX
} },
3001 { "(bad)", { XX
} },
3002 { "(bad)", { XX
} },
3003 { "pmovzxwd", { XM
, EXq
} },
3004 { "(bad)", { XX
} },
3009 { "(bad)", { XX
} },
3010 { "(bad)", { XX
} },
3011 { "pmovzxwq", { XM
, EXd
} },
3012 { "(bad)", { XX
} },
3017 { "(bad)", { XX
} },
3018 { "(bad)", { XX
} },
3019 { "pmovzxdq", { XM
, EXq
} },
3020 { "(bad)", { XX
} },
3025 { "(bad)", { XX
} },
3026 { "(bad)", { XX
} },
3027 { "pcmpgtq", { XM
, EXx
} },
3028 { "(bad)", { XX
} },
3033 { "(bad)", { XX
} },
3034 { "(bad)", { XX
} },
3035 { "pminsb", { XM
, EXx
} },
3036 { "(bad)", { XX
} },
3041 { "(bad)", { XX
} },
3042 { "(bad)", { XX
} },
3043 { "pminsd", { XM
, EXx
} },
3044 { "(bad)", { XX
} },
3049 { "(bad)", { XX
} },
3050 { "(bad)", { XX
} },
3051 { "pminuw", { XM
, EXx
} },
3052 { "(bad)", { XX
} },
3057 { "(bad)", { XX
} },
3058 { "(bad)", { XX
} },
3059 { "pminud", { XM
, EXx
} },
3060 { "(bad)", { XX
} },
3065 { "(bad)", { XX
} },
3066 { "(bad)", { XX
} },
3067 { "pmaxsb", { XM
, EXx
} },
3068 { "(bad)", { XX
} },
3073 { "(bad)", { XX
} },
3074 { "(bad)", { XX
} },
3075 { "pmaxsd", { XM
, EXx
} },
3076 { "(bad)", { XX
} },
3081 { "(bad)", { XX
} },
3082 { "(bad)", { XX
} },
3083 { "pmaxuw", { XM
, EXx
} },
3084 { "(bad)", { XX
} },
3089 { "(bad)", { XX
} },
3090 { "(bad)", { XX
} },
3091 { "pmaxud", { XM
, EXx
} },
3092 { "(bad)", { XX
} },
3097 { "(bad)", { XX
} },
3098 { "(bad)", { XX
} },
3099 { "pmulld", { XM
, EXx
} },
3100 { "(bad)", { XX
} },
3105 { "(bad)", { XX
} },
3106 { "(bad)", { XX
} },
3107 { "phminposuw", { XM
, EXx
} },
3108 { "(bad)", { XX
} },
3113 { "(bad)", { XX
} },
3114 { "(bad)", { XX
} },
3115 { "invept", { Gm
, Mo
} },
3116 { "(bad)", { XX
} },
3121 { "(bad)", { XX
} },
3122 { "(bad)", { XX
} },
3123 { "invvpid", { Gm
, Mo
} },
3124 { "(bad)", { XX
} },
3129 { "(bad)", { XX
} },
3130 { "(bad)", { XX
} },
3131 { "aesimc", { XM
, EXx
} },
3132 { "(bad)", { XX
} },
3137 { "(bad)", { XX
} },
3138 { "(bad)", { XX
} },
3139 { "aesenc", { XM
, EXx
} },
3140 { "(bad)", { XX
} },
3145 { "(bad)", { XX
} },
3146 { "(bad)", { XX
} },
3147 { "aesenclast", { XM
, EXx
} },
3148 { "(bad)", { XX
} },
3153 { "(bad)", { XX
} },
3154 { "(bad)", { XX
} },
3155 { "aesdec", { XM
, EXx
} },
3156 { "(bad)", { XX
} },
3161 { "(bad)", { XX
} },
3162 { "(bad)", { XX
} },
3163 { "aesdeclast", { XM
, EXx
} },
3164 { "(bad)", { XX
} },
3169 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3170 { "(bad)", { XX
} },
3171 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3172 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3177 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3178 { "(bad)", { XX
} },
3179 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3180 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3185 { "(bad)", { XX
} },
3186 { "(bad)", { XX
} },
3187 { "roundps", { XM
, EXx
, Ib
} },
3188 { "(bad)", { XX
} },
3193 { "(bad)", { XX
} },
3194 { "(bad)", { XX
} },
3195 { "roundpd", { XM
, EXx
, Ib
} },
3196 { "(bad)", { XX
} },
3201 { "(bad)", { XX
} },
3202 { "(bad)", { XX
} },
3203 { "roundss", { XM
, EXd
, Ib
} },
3204 { "(bad)", { XX
} },
3209 { "(bad)", { XX
} },
3210 { "(bad)", { XX
} },
3211 { "roundsd", { XM
, EXq
, Ib
} },
3212 { "(bad)", { XX
} },
3217 { "(bad)", { XX
} },
3218 { "(bad)", { XX
} },
3219 { "blendps", { XM
, EXx
, Ib
} },
3220 { "(bad)", { XX
} },
3225 { "(bad)", { XX
} },
3226 { "(bad)", { XX
} },
3227 { "blendpd", { XM
, EXx
, Ib
} },
3228 { "(bad)", { XX
} },
3233 { "(bad)", { XX
} },
3234 { "(bad)", { XX
} },
3235 { "pblendw", { XM
, EXx
, Ib
} },
3236 { "(bad)", { XX
} },
3241 { "(bad)", { XX
} },
3242 { "(bad)", { XX
} },
3243 { "pextrb", { Edqb
, XM
, Ib
} },
3244 { "(bad)", { XX
} },
3249 { "(bad)", { XX
} },
3250 { "(bad)", { XX
} },
3251 { "pextrw", { Edqw
, XM
, Ib
} },
3252 { "(bad)", { XX
} },
3257 { "(bad)", { XX
} },
3258 { "(bad)", { XX
} },
3259 { "pextrK", { Edq
, XM
, Ib
} },
3260 { "(bad)", { XX
} },
3265 { "(bad)", { XX
} },
3266 { "(bad)", { XX
} },
3267 { "extractps", { Edqd
, XM
, Ib
} },
3268 { "(bad)", { XX
} },
3273 { "(bad)", { XX
} },
3274 { "(bad)", { XX
} },
3275 { "pinsrb", { XM
, Edqb
, Ib
} },
3276 { "(bad)", { XX
} },
3281 { "(bad)", { XX
} },
3282 { "(bad)", { XX
} },
3283 { "insertps", { XM
, EXd
, Ib
} },
3284 { "(bad)", { XX
} },
3289 { "(bad)", { XX
} },
3290 { "(bad)", { XX
} },
3291 { "pinsrK", { XM
, Edq
, Ib
} },
3292 { "(bad)", { XX
} },
3297 { "(bad)", { XX
} },
3298 { "(bad)", { XX
} },
3299 { "dpps", { XM
, EXx
, Ib
} },
3300 { "(bad)", { XX
} },
3305 { "(bad)", { XX
} },
3306 { "(bad)", { XX
} },
3307 { "dppd", { XM
, EXx
, Ib
} },
3308 { "(bad)", { XX
} },
3313 { "(bad)", { XX
} },
3314 { "(bad)", { XX
} },
3315 { "mpsadbw", { XM
, EXx
, Ib
} },
3316 { "(bad)", { XX
} },
3321 { "(bad)", { XX
} },
3322 { "(bad)", { XX
} },
3323 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3324 { "(bad)", { XX
} },
3329 { "(bad)", { XX
} },
3330 { "(bad)", { XX
} },
3331 { "pcmpestrm", { XM
, EXx
, Ib
} },
3332 { "(bad)", { XX
} },
3337 { "(bad)", { XX
} },
3338 { "(bad)", { XX
} },
3339 { "pcmpestri", { XM
, EXx
, Ib
} },
3340 { "(bad)", { XX
} },
3345 { "(bad)", { XX
} },
3346 { "(bad)", { XX
} },
3347 { "pcmpistrm", { XM
, EXx
, Ib
} },
3348 { "(bad)", { XX
} },
3353 { "(bad)", { XX
} },
3354 { "(bad)", { XX
} },
3355 { "pcmpistri", { XM
, EXx
, Ib
} },
3356 { "(bad)", { XX
} },
3361 { "(bad)", { XX
} },
3362 { "(bad)", { XX
} },
3363 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3364 { "(bad)", { XX
} },
3369 { "vmovups", { XM
, EXx
} },
3370 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3371 { "vmovupd", { XM
, EXx
} },
3372 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3377 { "vmovups", { EXxS
, XM
} },
3378 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3379 { "vmovupd", { EXxS
, XM
} },
3380 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3385 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3386 { "vmovsldup", { XM
, EXx
} },
3387 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3388 { "vmovddup", { XM
, EXymmq
} },
3393 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3394 { "vmovshdup", { XM
, EXx
} },
3395 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3396 { "(bad)", { XX
} },
3401 { "(bad)", { XX
} },
3402 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3403 { "(bad)", { XX
} },
3404 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3409 { "(bad)", { XX
} },
3410 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3411 { "(bad)", { XX
} },
3412 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3417 { "(bad)", { XX
} },
3418 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3419 { "(bad)", { XX
} },
3420 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3425 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3426 { "(bad)", { XX
} },
3427 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3428 { "(bad)", { XX
} },
3433 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3434 { "(bad)", { XX
} },
3435 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3436 { "(bad)", { XX
} },
3441 { "vsqrtps", { XM
, EXx
} },
3442 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3443 { "vsqrtpd", { XM
, EXx
} },
3444 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3449 { "vrsqrtps", { XM
, EXx
} },
3450 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3451 { "(bad)", { XX
} },
3452 { "(bad)", { XX
} },
3457 { "vrcpps", { XM
, EXx
} },
3458 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3459 { "(bad)", { XX
} },
3460 { "(bad)", { XX
} },
3465 { "vaddps", { XM
, Vex
, EXx
} },
3466 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3467 { "vaddpd", { XM
, Vex
, EXx
} },
3468 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3473 { "vmulps", { XM
, Vex
, EXx
} },
3474 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3475 { "vmulpd", { XM
, Vex
, EXx
} },
3476 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3481 { "vcvtps2pd", { XM
, EXxmmq
} },
3482 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3483 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3484 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3489 { "vcvtdq2ps", { XM
, EXx
} },
3490 { "vcvttps2dq", { XM
, EXx
} },
3491 { "vcvtps2dq", { XM
, EXx
} },
3492 { "(bad)", { XX
} },
3497 { "vsubps", { XM
, Vex
, EXx
} },
3498 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3499 { "vsubpd", { XM
, Vex
, EXx
} },
3500 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3505 { "vminps", { XM
, Vex
, EXx
} },
3506 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3507 { "vminpd", { XM
, Vex
, EXx
} },
3508 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3513 { "vdivps", { XM
, Vex
, EXx
} },
3514 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3515 { "vdivpd", { XM
, Vex
, EXx
} },
3516 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3521 { "vmaxps", { XM
, Vex
, EXx
} },
3522 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3523 { "vmaxpd", { XM
, Vex
, EXx
} },
3524 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3529 { "(bad)", { XX
} },
3530 { "(bad)", { XX
} },
3531 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3532 { "(bad)", { XX
} },
3537 { "(bad)", { XX
} },
3538 { "(bad)", { XX
} },
3539 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3540 { "(bad)", { XX
} },
3545 { "(bad)", { XX
} },
3546 { "(bad)", { XX
} },
3547 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3548 { "(bad)", { XX
} },
3553 { "(bad)", { XX
} },
3554 { "(bad)", { XX
} },
3555 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3556 { "(bad)", { XX
} },
3561 { "(bad)", { XX
} },
3562 { "(bad)", { XX
} },
3563 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3564 { "(bad)", { XX
} },
3569 { "(bad)", { XX
} },
3570 { "(bad)", { XX
} },
3571 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3572 { "(bad)", { XX
} },
3577 { "(bad)", { XX
} },
3578 { "(bad)", { XX
} },
3579 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3580 { "(bad)", { XX
} },
3585 { "(bad)", { XX
} },
3586 { "(bad)", { XX
} },
3587 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3588 { "(bad)", { XX
} },
3593 { "(bad)", { XX
} },
3594 { "(bad)", { XX
} },
3595 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3596 { "(bad)", { XX
} },
3601 { "(bad)", { XX
} },
3602 { "(bad)", { XX
} },
3603 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3604 { "(bad)", { XX
} },
3609 { "(bad)", { XX
} },
3610 { "(bad)", { XX
} },
3611 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3612 { "(bad)", { XX
} },
3617 { "(bad)", { XX
} },
3618 { "(bad)", { XX
} },
3619 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3620 { "(bad)", { XX
} },
3625 { "(bad)", { XX
} },
3626 { "(bad)", { XX
} },
3627 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3628 { "(bad)", { XX
} },
3633 { "(bad)", { XX
} },
3634 { "(bad)", { XX
} },
3635 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3636 { "(bad)", { XX
} },
3641 { "(bad)", { XX
} },
3642 { "(bad)", { XX
} },
3643 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3644 { "(bad)", { XX
} },
3649 { "(bad)", { XX
} },
3650 { "vmovdqu", { XM
, EXx
} },
3651 { "vmovdqa", { XM
, EXx
} },
3652 { "(bad)", { XX
} },
3657 { "(bad)", { XX
} },
3658 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3659 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3660 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3663 /* PREFIX_VEX_71_REG_2 */
3665 { "(bad)", { XX
} },
3666 { "(bad)", { XX
} },
3667 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3668 { "(bad)", { XX
} },
3671 /* PREFIX_VEX_71_REG_4 */
3673 { "(bad)", { XX
} },
3674 { "(bad)", { XX
} },
3675 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3676 { "(bad)", { XX
} },
3679 /* PREFIX_VEX_71_REG_6 */
3681 { "(bad)", { XX
} },
3682 { "(bad)", { XX
} },
3683 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3684 { "(bad)", { XX
} },
3687 /* PREFIX_VEX_72_REG_2 */
3689 { "(bad)", { XX
} },
3690 { "(bad)", { XX
} },
3691 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3692 { "(bad)", { XX
} },
3695 /* PREFIX_VEX_72_REG_4 */
3697 { "(bad)", { XX
} },
3698 { "(bad)", { XX
} },
3699 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3700 { "(bad)", { XX
} },
3703 /* PREFIX_VEX_72_REG_6 */
3705 { "(bad)", { XX
} },
3706 { "(bad)", { XX
} },
3707 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3708 { "(bad)", { XX
} },
3711 /* PREFIX_VEX_73_REG_2 */
3713 { "(bad)", { XX
} },
3714 { "(bad)", { XX
} },
3715 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3716 { "(bad)", { XX
} },
3719 /* PREFIX_VEX_73_REG_3 */
3721 { "(bad)", { XX
} },
3722 { "(bad)", { XX
} },
3723 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3724 { "(bad)", { XX
} },
3727 /* PREFIX_VEX_73_REG_6 */
3729 { "(bad)", { XX
} },
3730 { "(bad)", { XX
} },
3731 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3732 { "(bad)", { XX
} },
3735 /* PREFIX_VEX_73_REG_7 */
3737 { "(bad)", { XX
} },
3738 { "(bad)", { XX
} },
3739 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3740 { "(bad)", { XX
} },
3745 { "(bad)", { XX
} },
3746 { "(bad)", { XX
} },
3747 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3748 { "(bad)", { XX
} },
3753 { "(bad)", { XX
} },
3754 { "(bad)", { XX
} },
3755 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3756 { "(bad)", { XX
} },
3761 { "(bad)", { XX
} },
3762 { "(bad)", { XX
} },
3763 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3764 { "(bad)", { XX
} },
3770 { "(bad)", { XX
} },
3771 { "(bad)", { XX
} },
3772 { "(bad)", { XX
} },
3777 { "(bad)", { XX
} },
3778 { "(bad)", { XX
} },
3779 { "vhaddpd", { XM
, Vex
, EXx
} },
3780 { "vhaddps", { XM
, Vex
, EXx
} },
3785 { "(bad)", { XX
} },
3786 { "(bad)", { XX
} },
3787 { "vhsubpd", { XM
, Vex
, EXx
} },
3788 { "vhsubps", { XM
, Vex
, EXx
} },
3793 { "(bad)", { XX
} },
3794 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3795 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3796 { "(bad)", { XX
} },
3801 { "(bad)", { XX
} },
3802 { "vmovdqu", { EXxS
, XM
} },
3803 { "vmovdqa", { EXxS
, XM
} },
3804 { "(bad)", { XX
} },
3809 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
3810 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3811 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
3812 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3817 { "(bad)", { XX
} },
3818 { "(bad)", { XX
} },
3819 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3820 { "(bad)", { XX
} },
3825 { "(bad)", { XX
} },
3826 { "(bad)", { XX
} },
3827 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3828 { "(bad)", { XX
} },
3833 { "(bad)", { XX
} },
3834 { "(bad)", { XX
} },
3835 { "vaddsubpd", { XM
, Vex
, EXx
} },
3836 { "vaddsubps", { XM
, Vex
, EXx
} },
3841 { "(bad)", { XX
} },
3842 { "(bad)", { XX
} },
3843 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3844 { "(bad)", { XX
} },
3849 { "(bad)", { XX
} },
3850 { "(bad)", { XX
} },
3851 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3852 { "(bad)", { XX
} },
3857 { "(bad)", { XX
} },
3858 { "(bad)", { XX
} },
3859 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
3860 { "(bad)", { XX
} },
3865 { "(bad)", { XX
} },
3866 { "(bad)", { XX
} },
3867 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
3868 { "(bad)", { XX
} },
3873 { "(bad)", { XX
} },
3874 { "(bad)", { XX
} },
3875 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
3876 { "(bad)", { XX
} },
3881 { "(bad)", { XX
} },
3882 { "(bad)", { XX
} },
3883 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
3884 { "(bad)", { XX
} },
3889 { "(bad)", { XX
} },
3890 { "(bad)", { XX
} },
3891 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
3892 { "(bad)", { XX
} },
3897 { "(bad)", { XX
} },
3898 { "(bad)", { XX
} },
3899 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
3900 { "(bad)", { XX
} },
3905 { "(bad)", { XX
} },
3906 { "(bad)", { XX
} },
3907 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
3908 { "(bad)", { XX
} },
3913 { "(bad)", { XX
} },
3914 { "(bad)", { XX
} },
3915 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
3916 { "(bad)", { XX
} },
3921 { "(bad)", { XX
} },
3922 { "(bad)", { XX
} },
3923 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
3924 { "(bad)", { XX
} },
3929 { "(bad)", { XX
} },
3930 { "(bad)", { XX
} },
3931 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
3932 { "(bad)", { XX
} },
3937 { "(bad)", { XX
} },
3938 { "(bad)", { XX
} },
3939 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
3940 { "(bad)", { XX
} },
3945 { "(bad)", { XX
} },
3946 { "(bad)", { XX
} },
3947 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
3948 { "(bad)", { XX
} },
3953 { "(bad)", { XX
} },
3954 { "(bad)", { XX
} },
3955 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
3956 { "(bad)", { XX
} },
3961 { "(bad)", { XX
} },
3962 { "(bad)", { XX
} },
3963 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
3964 { "(bad)", { XX
} },
3969 { "(bad)", { XX
} },
3970 { "(bad)", { XX
} },
3971 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
3972 { "(bad)", { XX
} },
3977 { "(bad)", { XX
} },
3978 { "(bad)", { XX
} },
3979 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
3980 { "(bad)", { XX
} },
3985 { "(bad)", { XX
} },
3986 { "(bad)", { XX
} },
3987 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
3988 { "(bad)", { XX
} },
3993 { "(bad)", { XX
} },
3994 { "(bad)", { XX
} },
3995 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
3996 { "(bad)", { XX
} },
4001 { "(bad)", { XX
} },
4002 { "(bad)", { XX
} },
4003 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4004 { "(bad)", { XX
} },
4009 { "(bad)", { XX
} },
4010 { "vcvtdq2pd", { XM
, EXxmmq
} },
4011 { "vcvttpd2dq%XY", { XMM
, EXx
} },
4012 { "vcvtpd2dq%XY", { XMM
, EXx
} },
4017 { "(bad)", { XX
} },
4018 { "(bad)", { XX
} },
4019 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4020 { "(bad)", { XX
} },
4025 { "(bad)", { XX
} },
4026 { "(bad)", { XX
} },
4027 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4028 { "(bad)", { XX
} },
4033 { "(bad)", { XX
} },
4034 { "(bad)", { XX
} },
4035 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4036 { "(bad)", { XX
} },
4041 { "(bad)", { XX
} },
4042 { "(bad)", { XX
} },
4043 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4044 { "(bad)", { XX
} },
4049 { "(bad)", { XX
} },
4050 { "(bad)", { XX
} },
4051 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4052 { "(bad)", { XX
} },
4057 { "(bad)", { XX
} },
4058 { "(bad)", { XX
} },
4059 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4060 { "(bad)", { XX
} },
4065 { "(bad)", { XX
} },
4066 { "(bad)", { XX
} },
4067 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4068 { "(bad)", { XX
} },
4073 { "(bad)", { XX
} },
4074 { "(bad)", { XX
} },
4075 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4076 { "(bad)", { XX
} },
4081 { "(bad)", { XX
} },
4082 { "(bad)", { XX
} },
4083 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4084 { "(bad)", { XX
} },
4089 { "(bad)", { XX
} },
4090 { "(bad)", { XX
} },
4091 { "(bad)", { XX
} },
4092 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4097 { "(bad)", { XX
} },
4098 { "(bad)", { XX
} },
4099 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4100 { "(bad)", { XX
} },
4105 { "(bad)", { XX
} },
4106 { "(bad)", { XX
} },
4107 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4108 { "(bad)", { XX
} },
4113 { "(bad)", { XX
} },
4114 { "(bad)", { XX
} },
4115 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4116 { "(bad)", { XX
} },
4121 { "(bad)", { XX
} },
4122 { "(bad)", { XX
} },
4123 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4124 { "(bad)", { XX
} },
4129 { "(bad)", { XX
} },
4130 { "(bad)", { XX
} },
4131 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4132 { "(bad)", { XX
} },
4137 { "(bad)", { XX
} },
4138 { "(bad)", { XX
} },
4139 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4140 { "(bad)", { XX
} },
4145 { "(bad)", { XX
} },
4146 { "(bad)", { XX
} },
4147 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4148 { "(bad)", { XX
} },
4153 { "(bad)", { XX
} },
4154 { "(bad)", { XX
} },
4155 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4156 { "(bad)", { XX
} },
4161 { "(bad)", { XX
} },
4162 { "(bad)", { XX
} },
4163 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4164 { "(bad)", { XX
} },
4169 { "(bad)", { XX
} },
4170 { "(bad)", { XX
} },
4171 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4172 { "(bad)", { XX
} },
4177 { "(bad)", { XX
} },
4178 { "(bad)", { XX
} },
4179 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4180 { "(bad)", { XX
} },
4185 { "(bad)", { XX
} },
4186 { "(bad)", { XX
} },
4187 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4188 { "(bad)", { XX
} },
4193 { "(bad)", { XX
} },
4194 { "(bad)", { XX
} },
4195 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4196 { "(bad)", { XX
} },
4201 { "(bad)", { XX
} },
4202 { "(bad)", { XX
} },
4203 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4204 { "(bad)", { XX
} },
4207 /* PREFIX_VEX_3800 */
4209 { "(bad)", { XX
} },
4210 { "(bad)", { XX
} },
4211 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4212 { "(bad)", { XX
} },
4215 /* PREFIX_VEX_3801 */
4217 { "(bad)", { XX
} },
4218 { "(bad)", { XX
} },
4219 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4220 { "(bad)", { XX
} },
4223 /* PREFIX_VEX_3802 */
4225 { "(bad)", { XX
} },
4226 { "(bad)", { XX
} },
4227 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4228 { "(bad)", { XX
} },
4231 /* PREFIX_VEX_3803 */
4233 { "(bad)", { XX
} },
4234 { "(bad)", { XX
} },
4235 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4236 { "(bad)", { XX
} },
4239 /* PREFIX_VEX_3804 */
4241 { "(bad)", { XX
} },
4242 { "(bad)", { XX
} },
4243 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4244 { "(bad)", { XX
} },
4247 /* PREFIX_VEX_3805 */
4249 { "(bad)", { XX
} },
4250 { "(bad)", { XX
} },
4251 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4252 { "(bad)", { XX
} },
4255 /* PREFIX_VEX_3806 */
4257 { "(bad)", { XX
} },
4258 { "(bad)", { XX
} },
4259 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4260 { "(bad)", { XX
} },
4263 /* PREFIX_VEX_3807 */
4265 { "(bad)", { XX
} },
4266 { "(bad)", { XX
} },
4267 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4268 { "(bad)", { XX
} },
4271 /* PREFIX_VEX_3808 */
4273 { "(bad)", { XX
} },
4274 { "(bad)", { XX
} },
4275 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4276 { "(bad)", { XX
} },
4279 /* PREFIX_VEX_3809 */
4281 { "(bad)", { XX
} },
4282 { "(bad)", { XX
} },
4283 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4284 { "(bad)", { XX
} },
4287 /* PREFIX_VEX_380A */
4289 { "(bad)", { XX
} },
4290 { "(bad)", { XX
} },
4291 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4292 { "(bad)", { XX
} },
4295 /* PREFIX_VEX_380B */
4297 { "(bad)", { XX
} },
4298 { "(bad)", { XX
} },
4299 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4300 { "(bad)", { XX
} },
4303 /* PREFIX_VEX_380C */
4305 { "(bad)", { XX
} },
4306 { "(bad)", { XX
} },
4307 { "vpermilps", { XM
, Vex
, EXx
} },
4308 { "(bad)", { XX
} },
4311 /* PREFIX_VEX_380D */
4313 { "(bad)", { XX
} },
4314 { "(bad)", { XX
} },
4315 { "vpermilpd", { XM
, Vex
, EXx
} },
4316 { "(bad)", { XX
} },
4319 /* PREFIX_VEX_380E */
4321 { "(bad)", { XX
} },
4322 { "(bad)", { XX
} },
4323 { "vtestps", { XM
, EXx
} },
4324 { "(bad)", { XX
} },
4327 /* PREFIX_VEX_380F */
4329 { "(bad)", { XX
} },
4330 { "(bad)", { XX
} },
4331 { "vtestpd", { XM
, EXx
} },
4332 { "(bad)", { XX
} },
4335 /* PREFIX_VEX_3817 */
4337 { "(bad)", { XX
} },
4338 { "(bad)", { XX
} },
4339 { "vptest", { XM
, EXx
} },
4340 { "(bad)", { XX
} },
4343 /* PREFIX_VEX_3818 */
4345 { "(bad)", { XX
} },
4346 { "(bad)", { XX
} },
4347 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4348 { "(bad)", { XX
} },
4351 /* PREFIX_VEX_3819 */
4353 { "(bad)", { XX
} },
4354 { "(bad)", { XX
} },
4355 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4356 { "(bad)", { XX
} },
4359 /* PREFIX_VEX_381A */
4361 { "(bad)", { XX
} },
4362 { "(bad)", { XX
} },
4363 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4364 { "(bad)", { XX
} },
4367 /* PREFIX_VEX_381C */
4369 { "(bad)", { XX
} },
4370 { "(bad)", { XX
} },
4371 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4372 { "(bad)", { XX
} },
4375 /* PREFIX_VEX_381D */
4377 { "(bad)", { XX
} },
4378 { "(bad)", { XX
} },
4379 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4380 { "(bad)", { XX
} },
4383 /* PREFIX_VEX_381E */
4385 { "(bad)", { XX
} },
4386 { "(bad)", { XX
} },
4387 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4388 { "(bad)", { XX
} },
4391 /* PREFIX_VEX_3820 */
4393 { "(bad)", { XX
} },
4394 { "(bad)", { XX
} },
4395 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4396 { "(bad)", { XX
} },
4399 /* PREFIX_VEX_3821 */
4401 { "(bad)", { XX
} },
4402 { "(bad)", { XX
} },
4403 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4404 { "(bad)", { XX
} },
4407 /* PREFIX_VEX_3822 */
4409 { "(bad)", { XX
} },
4410 { "(bad)", { XX
} },
4411 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4412 { "(bad)", { XX
} },
4415 /* PREFIX_VEX_3823 */
4417 { "(bad)", { XX
} },
4418 { "(bad)", { XX
} },
4419 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4420 { "(bad)", { XX
} },
4423 /* PREFIX_VEX_3824 */
4425 { "(bad)", { XX
} },
4426 { "(bad)", { XX
} },
4427 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4428 { "(bad)", { XX
} },
4431 /* PREFIX_VEX_3825 */
4433 { "(bad)", { XX
} },
4434 { "(bad)", { XX
} },
4435 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4436 { "(bad)", { XX
} },
4439 /* PREFIX_VEX_3828 */
4441 { "(bad)", { XX
} },
4442 { "(bad)", { XX
} },
4443 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4444 { "(bad)", { XX
} },
4447 /* PREFIX_VEX_3829 */
4449 { "(bad)", { XX
} },
4450 { "(bad)", { XX
} },
4451 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4452 { "(bad)", { XX
} },
4455 /* PREFIX_VEX_382A */
4457 { "(bad)", { XX
} },
4458 { "(bad)", { XX
} },
4459 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4460 { "(bad)", { XX
} },
4463 /* PREFIX_VEX_382B */
4465 { "(bad)", { XX
} },
4466 { "(bad)", { XX
} },
4467 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4468 { "(bad)", { XX
} },
4471 /* PREFIX_VEX_382C */
4473 { "(bad)", { XX
} },
4474 { "(bad)", { XX
} },
4475 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4476 { "(bad)", { XX
} },
4479 /* PREFIX_VEX_382D */
4481 { "(bad)", { XX
} },
4482 { "(bad)", { XX
} },
4483 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4484 { "(bad)", { XX
} },
4487 /* PREFIX_VEX_382E */
4489 { "(bad)", { XX
} },
4490 { "(bad)", { XX
} },
4491 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4492 { "(bad)", { XX
} },
4495 /* PREFIX_VEX_382F */
4497 { "(bad)", { XX
} },
4498 { "(bad)", { XX
} },
4499 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4500 { "(bad)", { XX
} },
4503 /* PREFIX_VEX_3830 */
4505 { "(bad)", { XX
} },
4506 { "(bad)", { XX
} },
4507 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4508 { "(bad)", { XX
} },
4511 /* PREFIX_VEX_3831 */
4513 { "(bad)", { XX
} },
4514 { "(bad)", { XX
} },
4515 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4516 { "(bad)", { XX
} },
4519 /* PREFIX_VEX_3832 */
4521 { "(bad)", { XX
} },
4522 { "(bad)", { XX
} },
4523 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4524 { "(bad)", { XX
} },
4527 /* PREFIX_VEX_3833 */
4529 { "(bad)", { XX
} },
4530 { "(bad)", { XX
} },
4531 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4532 { "(bad)", { XX
} },
4535 /* PREFIX_VEX_3834 */
4537 { "(bad)", { XX
} },
4538 { "(bad)", { XX
} },
4539 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4540 { "(bad)", { XX
} },
4543 /* PREFIX_VEX_3835 */
4545 { "(bad)", { XX
} },
4546 { "(bad)", { XX
} },
4547 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4548 { "(bad)", { XX
} },
4551 /* PREFIX_VEX_3837 */
4553 { "(bad)", { XX
} },
4554 { "(bad)", { XX
} },
4555 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4556 { "(bad)", { XX
} },
4559 /* PREFIX_VEX_3838 */
4561 { "(bad)", { XX
} },
4562 { "(bad)", { XX
} },
4563 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4564 { "(bad)", { XX
} },
4567 /* PREFIX_VEX_3839 */
4569 { "(bad)", { XX
} },
4570 { "(bad)", { XX
} },
4571 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4572 { "(bad)", { XX
} },
4575 /* PREFIX_VEX_383A */
4577 { "(bad)", { XX
} },
4578 { "(bad)", { XX
} },
4579 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4580 { "(bad)", { XX
} },
4583 /* PREFIX_VEX_383B */
4585 { "(bad)", { XX
} },
4586 { "(bad)", { XX
} },
4587 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4588 { "(bad)", { XX
} },
4591 /* PREFIX_VEX_383C */
4593 { "(bad)", { XX
} },
4594 { "(bad)", { XX
} },
4595 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4596 { "(bad)", { XX
} },
4599 /* PREFIX_VEX_383D */
4601 { "(bad)", { XX
} },
4602 { "(bad)", { XX
} },
4603 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4604 { "(bad)", { XX
} },
4607 /* PREFIX_VEX_383E */
4609 { "(bad)", { XX
} },
4610 { "(bad)", { XX
} },
4611 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4612 { "(bad)", { XX
} },
4615 /* PREFIX_VEX_383F */
4617 { "(bad)", { XX
} },
4618 { "(bad)", { XX
} },
4619 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4620 { "(bad)", { XX
} },
4623 /* PREFIX_VEX_3840 */
4625 { "(bad)", { XX
} },
4626 { "(bad)", { XX
} },
4627 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4628 { "(bad)", { XX
} },
4631 /* PREFIX_VEX_3841 */
4633 { "(bad)", { XX
} },
4634 { "(bad)", { XX
} },
4635 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4636 { "(bad)", { XX
} },
4639 /* PREFIX_VEX_3896 */
4641 { "(bad)", { XX
} },
4642 { "(bad)", { XX
} },
4643 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4644 { "(bad)", { XX
} },
4647 /* PREFIX_VEX_3897 */
4649 { "(bad)", { XX
} },
4650 { "(bad)", { XX
} },
4651 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4652 { "(bad)", { XX
} },
4655 /* PREFIX_VEX_3898 */
4657 { "(bad)", { XX
} },
4658 { "(bad)", { XX
} },
4659 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4660 { "(bad)", { XX
} },
4663 /* PREFIX_VEX_3899 */
4665 { "(bad)", { XX
} },
4666 { "(bad)", { XX
} },
4667 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4668 { "(bad)", { XX
} },
4671 /* PREFIX_VEX_389A */
4673 { "(bad)", { XX
} },
4674 { "(bad)", { XX
} },
4675 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4676 { "(bad)", { XX
} },
4679 /* PREFIX_VEX_389B */
4681 { "(bad)", { XX
} },
4682 { "(bad)", { XX
} },
4683 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4684 { "(bad)", { XX
} },
4687 /* PREFIX_VEX_389C */
4689 { "(bad)", { XX
} },
4690 { "(bad)", { XX
} },
4691 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4692 { "(bad)", { XX
} },
4695 /* PREFIX_VEX_389D */
4697 { "(bad)", { XX
} },
4698 { "(bad)", { XX
} },
4699 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4700 { "(bad)", { XX
} },
4703 /* PREFIX_VEX_389E */
4705 { "(bad)", { XX
} },
4706 { "(bad)", { XX
} },
4707 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4708 { "(bad)", { XX
} },
4711 /* PREFIX_VEX_389F */
4713 { "(bad)", { XX
} },
4714 { "(bad)", { XX
} },
4715 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4716 { "(bad)", { XX
} },
4719 /* PREFIX_VEX_38A6 */
4721 { "(bad)", { XX
} },
4722 { "(bad)", { XX
} },
4723 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4724 { "(bad)", { XX
} },
4727 /* PREFIX_VEX_38A7 */
4729 { "(bad)", { XX
} },
4730 { "(bad)", { XX
} },
4731 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4732 { "(bad)", { XX
} },
4735 /* PREFIX_VEX_38A8 */
4737 { "(bad)", { XX
} },
4738 { "(bad)", { XX
} },
4739 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4740 { "(bad)", { XX
} },
4743 /* PREFIX_VEX_38A9 */
4745 { "(bad)", { XX
} },
4746 { "(bad)", { XX
} },
4747 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4748 { "(bad)", { XX
} },
4751 /* PREFIX_VEX_38AA */
4753 { "(bad)", { XX
} },
4754 { "(bad)", { XX
} },
4755 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4756 { "(bad)", { XX
} },
4759 /* PREFIX_VEX_38AB */
4761 { "(bad)", { XX
} },
4762 { "(bad)", { XX
} },
4763 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4764 { "(bad)", { XX
} },
4767 /* PREFIX_VEX_38AC */
4769 { "(bad)", { XX
} },
4770 { "(bad)", { XX
} },
4771 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4772 { "(bad)", { XX
} },
4775 /* PREFIX_VEX_38AD */
4777 { "(bad)", { XX
} },
4778 { "(bad)", { XX
} },
4779 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4780 { "(bad)", { XX
} },
4783 /* PREFIX_VEX_38AE */
4785 { "(bad)", { XX
} },
4786 { "(bad)", { XX
} },
4787 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4788 { "(bad)", { XX
} },
4791 /* PREFIX_VEX_38AF */
4793 { "(bad)", { XX
} },
4794 { "(bad)", { XX
} },
4795 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4796 { "(bad)", { XX
} },
4799 /* PREFIX_VEX_38B6 */
4801 { "(bad)", { XX
} },
4802 { "(bad)", { XX
} },
4803 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4804 { "(bad)", { XX
} },
4807 /* PREFIX_VEX_38B7 */
4809 { "(bad)", { XX
} },
4810 { "(bad)", { XX
} },
4811 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4812 { "(bad)", { XX
} },
4815 /* PREFIX_VEX_38B8 */
4817 { "(bad)", { XX
} },
4818 { "(bad)", { XX
} },
4819 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4820 { "(bad)", { XX
} },
4823 /* PREFIX_VEX_38B9 */
4825 { "(bad)", { XX
} },
4826 { "(bad)", { XX
} },
4827 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4828 { "(bad)", { XX
} },
4831 /* PREFIX_VEX_38BA */
4833 { "(bad)", { XX
} },
4834 { "(bad)", { XX
} },
4835 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4836 { "(bad)", { XX
} },
4839 /* PREFIX_VEX_38BB */
4841 { "(bad)", { XX
} },
4842 { "(bad)", { XX
} },
4843 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4844 { "(bad)", { XX
} },
4847 /* PREFIX_VEX_38BC */
4849 { "(bad)", { XX
} },
4850 { "(bad)", { XX
} },
4851 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4852 { "(bad)", { XX
} },
4855 /* PREFIX_VEX_38BD */
4857 { "(bad)", { XX
} },
4858 { "(bad)", { XX
} },
4859 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4860 { "(bad)", { XX
} },
4863 /* PREFIX_VEX_38BE */
4865 { "(bad)", { XX
} },
4866 { "(bad)", { XX
} },
4867 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4868 { "(bad)", { XX
} },
4871 /* PREFIX_VEX_38BF */
4873 { "(bad)", { XX
} },
4874 { "(bad)", { XX
} },
4875 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4876 { "(bad)", { XX
} },
4879 /* PREFIX_VEX_38DB */
4881 { "(bad)", { XX
} },
4882 { "(bad)", { XX
} },
4883 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4884 { "(bad)", { XX
} },
4887 /* PREFIX_VEX_38DC */
4889 { "(bad)", { XX
} },
4890 { "(bad)", { XX
} },
4891 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4892 { "(bad)", { XX
} },
4895 /* PREFIX_VEX_38DD */
4897 { "(bad)", { XX
} },
4898 { "(bad)", { XX
} },
4899 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4900 { "(bad)", { XX
} },
4903 /* PREFIX_VEX_38DE */
4905 { "(bad)", { XX
} },
4906 { "(bad)", { XX
} },
4907 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4908 { "(bad)", { XX
} },
4911 /* PREFIX_VEX_38DF */
4913 { "(bad)", { XX
} },
4914 { "(bad)", { XX
} },
4915 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4916 { "(bad)", { XX
} },
4919 /* PREFIX_VEX_3A04 */
4921 { "(bad)", { XX
} },
4922 { "(bad)", { XX
} },
4923 { "vpermilps", { XM
, EXx
, Ib
} },
4924 { "(bad)", { XX
} },
4927 /* PREFIX_VEX_3A05 */
4929 { "(bad)", { XX
} },
4930 { "(bad)", { XX
} },
4931 { "vpermilpd", { XM
, EXx
, Ib
} },
4932 { "(bad)", { XX
} },
4935 /* PREFIX_VEX_3A06 */
4937 { "(bad)", { XX
} },
4938 { "(bad)", { XX
} },
4939 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4940 { "(bad)", { XX
} },
4943 /* PREFIX_VEX_3A08 */
4945 { "(bad)", { XX
} },
4946 { "(bad)", { XX
} },
4947 { "vroundps", { XM
, EXx
, Ib
} },
4948 { "(bad)", { XX
} },
4951 /* PREFIX_VEX_3A09 */
4953 { "(bad)", { XX
} },
4954 { "(bad)", { XX
} },
4955 { "vroundpd", { XM
, EXx
, Ib
} },
4956 { "(bad)", { XX
} },
4959 /* PREFIX_VEX_3A0A */
4961 { "(bad)", { XX
} },
4962 { "(bad)", { XX
} },
4963 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4964 { "(bad)", { XX
} },
4967 /* PREFIX_VEX_3A0B */
4969 { "(bad)", { XX
} },
4970 { "(bad)", { XX
} },
4971 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4972 { "(bad)", { XX
} },
4975 /* PREFIX_VEX_3A0C */
4977 { "(bad)", { XX
} },
4978 { "(bad)", { XX
} },
4979 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
4980 { "(bad)", { XX
} },
4983 /* PREFIX_VEX_3A0D */
4985 { "(bad)", { XX
} },
4986 { "(bad)", { XX
} },
4987 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
4988 { "(bad)", { XX
} },
4991 /* PREFIX_VEX_3A0E */
4993 { "(bad)", { XX
} },
4994 { "(bad)", { XX
} },
4995 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
4996 { "(bad)", { XX
} },
4999 /* PREFIX_VEX_3A0F */
5001 { "(bad)", { XX
} },
5002 { "(bad)", { XX
} },
5003 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
5004 { "(bad)", { XX
} },
5007 /* PREFIX_VEX_3A14 */
5009 { "(bad)", { XX
} },
5010 { "(bad)", { XX
} },
5011 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5012 { "(bad)", { XX
} },
5015 /* PREFIX_VEX_3A15 */
5017 { "(bad)", { XX
} },
5018 { "(bad)", { XX
} },
5019 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5020 { "(bad)", { XX
} },
5023 /* PREFIX_VEX_3A16 */
5025 { "(bad)", { XX
} },
5026 { "(bad)", { XX
} },
5027 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5028 { "(bad)", { XX
} },
5031 /* PREFIX_VEX_3A17 */
5033 { "(bad)", { XX
} },
5034 { "(bad)", { XX
} },
5035 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5036 { "(bad)", { XX
} },
5039 /* PREFIX_VEX_3A18 */
5041 { "(bad)", { XX
} },
5042 { "(bad)", { XX
} },
5043 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5044 { "(bad)", { XX
} },
5047 /* PREFIX_VEX_3A19 */
5049 { "(bad)", { XX
} },
5050 { "(bad)", { XX
} },
5051 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5052 { "(bad)", { XX
} },
5055 /* PREFIX_VEX_3A20 */
5057 { "(bad)", { XX
} },
5058 { "(bad)", { XX
} },
5059 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5060 { "(bad)", { XX
} },
5063 /* PREFIX_VEX_3A21 */
5065 { "(bad)", { XX
} },
5066 { "(bad)", { XX
} },
5067 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5068 { "(bad)", { XX
} },
5071 /* PREFIX_VEX_3A22 */
5073 { "(bad)", { XX
} },
5074 { "(bad)", { XX
} },
5075 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5076 { "(bad)", { XX
} },
5079 /* PREFIX_VEX_3A40 */
5081 { "(bad)", { XX
} },
5082 { "(bad)", { XX
} },
5083 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
5084 { "(bad)", { XX
} },
5087 /* PREFIX_VEX_3A41 */
5089 { "(bad)", { XX
} },
5090 { "(bad)", { XX
} },
5091 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5092 { "(bad)", { XX
} },
5095 /* PREFIX_VEX_3A42 */
5097 { "(bad)", { XX
} },
5098 { "(bad)", { XX
} },
5099 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5100 { "(bad)", { XX
} },
5103 /* PREFIX_VEX_3A44 */
5105 { "(bad)", { XX
} },
5106 { "(bad)", { XX
} },
5107 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5108 { "(bad)", { XX
} },
5111 /* PREFIX_VEX_3A4A */
5113 { "(bad)", { XX
} },
5114 { "(bad)", { XX
} },
5115 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
5116 { "(bad)", { XX
} },
5119 /* PREFIX_VEX_3A4B */
5121 { "(bad)", { XX
} },
5122 { "(bad)", { XX
} },
5123 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
5124 { "(bad)", { XX
} },
5127 /* PREFIX_VEX_3A4C */
5129 { "(bad)", { XX
} },
5130 { "(bad)", { XX
} },
5131 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5132 { "(bad)", { XX
} },
5135 /* PREFIX_VEX_3A5C */
5137 { "(bad)", { XX
} },
5138 { "(bad)", { XX
} },
5139 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5140 { "(bad)", { XX
} },
5143 /* PREFIX_VEX_3A5D */
5145 { "(bad)", { XX
} },
5146 { "(bad)", { XX
} },
5147 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5148 { "(bad)", { XX
} },
5151 /* PREFIX_VEX_3A5E */
5153 { "(bad)", { XX
} },
5154 { "(bad)", { XX
} },
5155 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5156 { "(bad)", { XX
} },
5159 /* PREFIX_VEX_3A5F */
5161 { "(bad)", { XX
} },
5162 { "(bad)", { XX
} },
5163 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5164 { "(bad)", { XX
} },
5167 /* PREFIX_VEX_3A60 */
5169 { "(bad)", { XX
} },
5170 { "(bad)", { XX
} },
5171 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5172 { "(bad)", { XX
} },
5175 /* PREFIX_VEX_3A61 */
5177 { "(bad)", { XX
} },
5178 { "(bad)", { XX
} },
5179 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5180 { "(bad)", { XX
} },
5183 /* PREFIX_VEX_3A62 */
5185 { "(bad)", { XX
} },
5186 { "(bad)", { XX
} },
5187 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5188 { "(bad)", { XX
} },
5191 /* PREFIX_VEX_3A63 */
5193 { "(bad)", { XX
} },
5194 { "(bad)", { XX
} },
5195 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5196 { "(bad)", { XX
} },
5199 /* PREFIX_VEX_3A68 */
5201 { "(bad)", { XX
} },
5202 { "(bad)", { XX
} },
5203 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5204 { "(bad)", { XX
} },
5207 /* PREFIX_VEX_3A69 */
5209 { "(bad)", { XX
} },
5210 { "(bad)", { XX
} },
5211 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5212 { "(bad)", { XX
} },
5215 /* PREFIX_VEX_3A6A */
5217 { "(bad)", { XX
} },
5218 { "(bad)", { XX
} },
5219 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5220 { "(bad)", { XX
} },
5223 /* PREFIX_VEX_3A6B */
5225 { "(bad)", { XX
} },
5226 { "(bad)", { XX
} },
5227 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5228 { "(bad)", { XX
} },
5231 /* PREFIX_VEX_3A6C */
5233 { "(bad)", { XX
} },
5234 { "(bad)", { XX
} },
5235 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5236 { "(bad)", { XX
} },
5239 /* PREFIX_VEX_3A6D */
5241 { "(bad)", { XX
} },
5242 { "(bad)", { XX
} },
5243 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5244 { "(bad)", { XX
} },
5247 /* PREFIX_VEX_3A6E */
5249 { "(bad)", { XX
} },
5250 { "(bad)", { XX
} },
5251 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5252 { "(bad)", { XX
} },
5255 /* PREFIX_VEX_3A6F */
5257 { "(bad)", { XX
} },
5258 { "(bad)", { XX
} },
5259 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5260 { "(bad)", { XX
} },
5263 /* PREFIX_VEX_3A78 */
5265 { "(bad)", { XX
} },
5266 { "(bad)", { XX
} },
5267 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5268 { "(bad)", { XX
} },
5271 /* PREFIX_VEX_3A79 */
5273 { "(bad)", { XX
} },
5274 { "(bad)", { XX
} },
5275 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5276 { "(bad)", { XX
} },
5279 /* PREFIX_VEX_3A7A */
5281 { "(bad)", { XX
} },
5282 { "(bad)", { XX
} },
5283 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5284 { "(bad)", { XX
} },
5287 /* PREFIX_VEX_3A7B */
5289 { "(bad)", { XX
} },
5290 { "(bad)", { XX
} },
5291 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5292 { "(bad)", { XX
} },
5295 /* PREFIX_VEX_3A7C */
5297 { "(bad)", { XX
} },
5298 { "(bad)", { XX
} },
5299 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5300 { "(bad)", { XX
} },
5303 /* PREFIX_VEX_3A7D */
5305 { "(bad)", { XX
} },
5306 { "(bad)", { XX
} },
5307 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5308 { "(bad)", { XX
} },
5311 /* PREFIX_VEX_3A7E */
5313 { "(bad)", { XX
} },
5314 { "(bad)", { XX
} },
5315 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5316 { "(bad)", { XX
} },
5319 /* PREFIX_VEX_3A7F */
5321 { "(bad)", { XX
} },
5322 { "(bad)", { XX
} },
5323 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5324 { "(bad)", { XX
} },
5327 /* PREFIX_VEX_3ADF */
5329 { "(bad)", { XX
} },
5330 { "(bad)", { XX
} },
5331 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5332 { "(bad)", { XX
} },
5336 static const struct dis386 x86_64_table
[][2] = {
5339 { "push{T|}", { es
} },
5340 { "(bad)", { XX
} },
5345 { "pop{T|}", { es
} },
5346 { "(bad)", { XX
} },
5351 { "push{T|}", { cs
} },
5352 { "(bad)", { XX
} },
5357 { "push{T|}", { ss
} },
5358 { "(bad)", { XX
} },
5363 { "pop{T|}", { ss
} },
5364 { "(bad)", { XX
} },
5369 { "push{T|}", { ds
} },
5370 { "(bad)", { XX
} },
5375 { "pop{T|}", { ds
} },
5376 { "(bad)", { XX
} },
5382 { "(bad)", { XX
} },
5388 { "(bad)", { XX
} },
5394 { "(bad)", { XX
} },
5400 { "(bad)", { XX
} },
5405 { "pusha{P|}", { XX
} },
5406 { "(bad)", { XX
} },
5411 { "popa{P|}", { XX
} },
5412 { "(bad)", { XX
} },
5417 { MOD_TABLE (MOD_62_32BIT
) },
5418 { "(bad)", { XX
} },
5423 { "arpl", { Ew
, Gw
} },
5424 { "movs{lq|xd}", { Gv
, Ed
} },
5429 { "ins{R|}", { Yzr
, indirDX
} },
5430 { "ins{G|}", { Yzr
, indirDX
} },
5435 { "outs{R|}", { indirDXr
, Xz
} },
5436 { "outs{G|}", { indirDXr
, Xz
} },
5441 { "Jcall{T|}", { Ap
} },
5442 { "(bad)", { XX
} },
5447 { MOD_TABLE (MOD_C4_32BIT
) },
5448 { VEX_C4_TABLE (VEX_0F
) },
5453 { MOD_TABLE (MOD_C5_32BIT
) },
5454 { VEX_C5_TABLE (VEX_0F
) },
5460 { "(bad)", { XX
} },
5466 { "(bad)", { XX
} },
5472 { "(bad)", { XX
} },
5477 { "Jjmp{T|}", { Ap
} },
5478 { "(bad)", { XX
} },
5481 /* X86_64_0F01_REG_0 */
5483 { "sgdt{Q|IQ}", { M
} },
5487 /* X86_64_0F01_REG_1 */
5489 { "sidt{Q|IQ}", { M
} },
5493 /* X86_64_0F01_REG_2 */
5495 { "lgdt{Q|Q}", { M
} },
5499 /* X86_64_0F01_REG_3 */
5501 { "lidt{Q|Q}", { M
} },
5506 static const struct dis386 three_byte_table
[][256] = {
5508 /* THREE_BYTE_0F38 */
5511 { "pshufb", { MX
, EM
} },
5512 { "phaddw", { MX
, EM
} },
5513 { "phaddd", { MX
, EM
} },
5514 { "phaddsw", { MX
, EM
} },
5515 { "pmaddubsw", { MX
, EM
} },
5516 { "phsubw", { MX
, EM
} },
5517 { "phsubd", { MX
, EM
} },
5518 { "phsubsw", { MX
, EM
} },
5520 { "psignb", { MX
, EM
} },
5521 { "psignw", { MX
, EM
} },
5522 { "psignd", { MX
, EM
} },
5523 { "pmulhrsw", { MX
, EM
} },
5524 { "(bad)", { XX
} },
5525 { "(bad)", { XX
} },
5526 { "(bad)", { XX
} },
5527 { "(bad)", { XX
} },
5529 { PREFIX_TABLE (PREFIX_0F3810
) },
5530 { "(bad)", { XX
} },
5531 { "(bad)", { XX
} },
5532 { "(bad)", { XX
} },
5533 { PREFIX_TABLE (PREFIX_0F3814
) },
5534 { PREFIX_TABLE (PREFIX_0F3815
) },
5535 { "(bad)", { XX
} },
5536 { PREFIX_TABLE (PREFIX_0F3817
) },
5538 { "(bad)", { XX
} },
5539 { "(bad)", { XX
} },
5540 { "(bad)", { XX
} },
5541 { "(bad)", { XX
} },
5542 { "pabsb", { MX
, EM
} },
5543 { "pabsw", { MX
, EM
} },
5544 { "pabsd", { MX
, EM
} },
5545 { "(bad)", { XX
} },
5547 { PREFIX_TABLE (PREFIX_0F3820
) },
5548 { PREFIX_TABLE (PREFIX_0F3821
) },
5549 { PREFIX_TABLE (PREFIX_0F3822
) },
5550 { PREFIX_TABLE (PREFIX_0F3823
) },
5551 { PREFIX_TABLE (PREFIX_0F3824
) },
5552 { PREFIX_TABLE (PREFIX_0F3825
) },
5553 { "(bad)", { XX
} },
5554 { "(bad)", { XX
} },
5556 { PREFIX_TABLE (PREFIX_0F3828
) },
5557 { PREFIX_TABLE (PREFIX_0F3829
) },
5558 { PREFIX_TABLE (PREFIX_0F382A
) },
5559 { PREFIX_TABLE (PREFIX_0F382B
) },
5560 { "(bad)", { XX
} },
5561 { "(bad)", { XX
} },
5562 { "(bad)", { XX
} },
5563 { "(bad)", { XX
} },
5565 { PREFIX_TABLE (PREFIX_0F3830
) },
5566 { PREFIX_TABLE (PREFIX_0F3831
) },
5567 { PREFIX_TABLE (PREFIX_0F3832
) },
5568 { PREFIX_TABLE (PREFIX_0F3833
) },
5569 { PREFIX_TABLE (PREFIX_0F3834
) },
5570 { PREFIX_TABLE (PREFIX_0F3835
) },
5571 { "(bad)", { XX
} },
5572 { PREFIX_TABLE (PREFIX_0F3837
) },
5574 { PREFIX_TABLE (PREFIX_0F3838
) },
5575 { PREFIX_TABLE (PREFIX_0F3839
) },
5576 { PREFIX_TABLE (PREFIX_0F383A
) },
5577 { PREFIX_TABLE (PREFIX_0F383B
) },
5578 { PREFIX_TABLE (PREFIX_0F383C
) },
5579 { PREFIX_TABLE (PREFIX_0F383D
) },
5580 { PREFIX_TABLE (PREFIX_0F383E
) },
5581 { PREFIX_TABLE (PREFIX_0F383F
) },
5583 { PREFIX_TABLE (PREFIX_0F3840
) },
5584 { PREFIX_TABLE (PREFIX_0F3841
) },
5585 { "(bad)", { XX
} },
5586 { "(bad)", { XX
} },
5587 { "(bad)", { XX
} },
5588 { "(bad)", { XX
} },
5589 { "(bad)", { XX
} },
5590 { "(bad)", { XX
} },
5592 { "(bad)", { XX
} },
5593 { "(bad)", { XX
} },
5594 { "(bad)", { XX
} },
5595 { "(bad)", { XX
} },
5596 { "(bad)", { XX
} },
5597 { "(bad)", { XX
} },
5598 { "(bad)", { XX
} },
5599 { "(bad)", { XX
} },
5601 { "(bad)", { XX
} },
5602 { "(bad)", { XX
} },
5603 { "(bad)", { XX
} },
5604 { "(bad)", { XX
} },
5605 { "(bad)", { XX
} },
5606 { "(bad)", { XX
} },
5607 { "(bad)", { XX
} },
5608 { "(bad)", { XX
} },
5610 { "(bad)", { XX
} },
5611 { "(bad)", { XX
} },
5612 { "(bad)", { XX
} },
5613 { "(bad)", { XX
} },
5614 { "(bad)", { XX
} },
5615 { "(bad)", { XX
} },
5616 { "(bad)", { XX
} },
5617 { "(bad)", { XX
} },
5619 { "(bad)", { XX
} },
5620 { "(bad)", { XX
} },
5621 { "(bad)", { XX
} },
5622 { "(bad)", { XX
} },
5623 { "(bad)", { XX
} },
5624 { "(bad)", { XX
} },
5625 { "(bad)", { XX
} },
5626 { "(bad)", { XX
} },
5628 { "(bad)", { XX
} },
5629 { "(bad)", { XX
} },
5630 { "(bad)", { XX
} },
5631 { "(bad)", { XX
} },
5632 { "(bad)", { XX
} },
5633 { "(bad)", { XX
} },
5634 { "(bad)", { XX
} },
5635 { "(bad)", { XX
} },
5637 { "(bad)", { XX
} },
5638 { "(bad)", { XX
} },
5639 { "(bad)", { XX
} },
5640 { "(bad)", { XX
} },
5641 { "(bad)", { XX
} },
5642 { "(bad)", { XX
} },
5643 { "(bad)", { XX
} },
5644 { "(bad)", { XX
} },
5646 { "(bad)", { XX
} },
5647 { "(bad)", { XX
} },
5648 { "(bad)", { XX
} },
5649 { "(bad)", { XX
} },
5650 { "(bad)", { XX
} },
5651 { "(bad)", { XX
} },
5652 { "(bad)", { XX
} },
5653 { "(bad)", { XX
} },
5655 { PREFIX_TABLE (PREFIX_0F3880
) },
5656 { PREFIX_TABLE (PREFIX_0F3881
) },
5657 { "(bad)", { XX
} },
5658 { "(bad)", { XX
} },
5659 { "(bad)", { XX
} },
5660 { "(bad)", { XX
} },
5661 { "(bad)", { XX
} },
5662 { "(bad)", { XX
} },
5664 { "(bad)", { XX
} },
5665 { "(bad)", { XX
} },
5666 { "(bad)", { XX
} },
5667 { "(bad)", { XX
} },
5668 { "(bad)", { XX
} },
5669 { "(bad)", { XX
} },
5670 { "(bad)", { XX
} },
5671 { "(bad)", { XX
} },
5673 { "(bad)", { XX
} },
5674 { "(bad)", { XX
} },
5675 { "(bad)", { XX
} },
5676 { "(bad)", { XX
} },
5677 { "(bad)", { XX
} },
5678 { "(bad)", { XX
} },
5679 { "(bad)", { XX
} },
5680 { "(bad)", { XX
} },
5682 { "(bad)", { XX
} },
5683 { "(bad)", { XX
} },
5684 { "(bad)", { XX
} },
5685 { "(bad)", { XX
} },
5686 { "(bad)", { XX
} },
5687 { "(bad)", { XX
} },
5688 { "(bad)", { XX
} },
5689 { "(bad)", { XX
} },
5691 { "(bad)", { XX
} },
5692 { "(bad)", { XX
} },
5693 { "(bad)", { XX
} },
5694 { "(bad)", { XX
} },
5695 { "(bad)", { XX
} },
5696 { "(bad)", { XX
} },
5697 { "(bad)", { XX
} },
5698 { "(bad)", { XX
} },
5700 { "(bad)", { XX
} },
5701 { "(bad)", { XX
} },
5702 { "(bad)", { XX
} },
5703 { "(bad)", { XX
} },
5704 { "(bad)", { XX
} },
5705 { "(bad)", { XX
} },
5706 { "(bad)", { XX
} },
5707 { "(bad)", { XX
} },
5709 { "(bad)", { XX
} },
5710 { "(bad)", { XX
} },
5711 { "(bad)", { XX
} },
5712 { "(bad)", { XX
} },
5713 { "(bad)", { XX
} },
5714 { "(bad)", { XX
} },
5715 { "(bad)", { XX
} },
5716 { "(bad)", { XX
} },
5718 { "(bad)", { XX
} },
5719 { "(bad)", { XX
} },
5720 { "(bad)", { XX
} },
5721 { "(bad)", { XX
} },
5722 { "(bad)", { XX
} },
5723 { "(bad)", { XX
} },
5724 { "(bad)", { XX
} },
5725 { "(bad)", { XX
} },
5727 { "(bad)", { XX
} },
5728 { "(bad)", { XX
} },
5729 { "(bad)", { XX
} },
5730 { "(bad)", { XX
} },
5731 { "(bad)", { XX
} },
5732 { "(bad)", { XX
} },
5733 { "(bad)", { XX
} },
5734 { "(bad)", { XX
} },
5736 { "(bad)", { XX
} },
5737 { "(bad)", { XX
} },
5738 { "(bad)", { XX
} },
5739 { "(bad)", { XX
} },
5740 { "(bad)", { XX
} },
5741 { "(bad)", { XX
} },
5742 { "(bad)", { XX
} },
5743 { "(bad)", { XX
} },
5745 { "(bad)", { XX
} },
5746 { "(bad)", { XX
} },
5747 { "(bad)", { XX
} },
5748 { "(bad)", { XX
} },
5749 { "(bad)", { XX
} },
5750 { "(bad)", { XX
} },
5751 { "(bad)", { XX
} },
5752 { "(bad)", { XX
} },
5754 { "(bad)", { XX
} },
5755 { "(bad)", { XX
} },
5756 { "(bad)", { XX
} },
5757 { PREFIX_TABLE (PREFIX_0F38DB
) },
5758 { PREFIX_TABLE (PREFIX_0F38DC
) },
5759 { PREFIX_TABLE (PREFIX_0F38DD
) },
5760 { PREFIX_TABLE (PREFIX_0F38DE
) },
5761 { PREFIX_TABLE (PREFIX_0F38DF
) },
5763 { "(bad)", { XX
} },
5764 { "(bad)", { XX
} },
5765 { "(bad)", { XX
} },
5766 { "(bad)", { XX
} },
5767 { "(bad)", { XX
} },
5768 { "(bad)", { XX
} },
5769 { "(bad)", { XX
} },
5770 { "(bad)", { XX
} },
5772 { "(bad)", { XX
} },
5773 { "(bad)", { XX
} },
5774 { "(bad)", { XX
} },
5775 { "(bad)", { XX
} },
5776 { "(bad)", { XX
} },
5777 { "(bad)", { XX
} },
5778 { "(bad)", { XX
} },
5779 { "(bad)", { XX
} },
5781 { PREFIX_TABLE (PREFIX_0F38F0
) },
5782 { PREFIX_TABLE (PREFIX_0F38F1
) },
5783 { "(bad)", { XX
} },
5784 { "(bad)", { XX
} },
5785 { "(bad)", { XX
} },
5786 { "(bad)", { XX
} },
5787 { "(bad)", { XX
} },
5788 { "(bad)", { XX
} },
5790 { "(bad)", { XX
} },
5791 { "(bad)", { XX
} },
5792 { "(bad)", { XX
} },
5793 { "(bad)", { XX
} },
5794 { "(bad)", { XX
} },
5795 { "(bad)", { XX
} },
5796 { "(bad)", { XX
} },
5797 { "(bad)", { XX
} },
5799 /* THREE_BYTE_0F3A */
5802 { "(bad)", { XX
} },
5803 { "(bad)", { XX
} },
5804 { "(bad)", { XX
} },
5805 { "(bad)", { XX
} },
5806 { "(bad)", { XX
} },
5807 { "(bad)", { XX
} },
5808 { "(bad)", { XX
} },
5809 { "(bad)", { XX
} },
5811 { PREFIX_TABLE (PREFIX_0F3A08
) },
5812 { PREFIX_TABLE (PREFIX_0F3A09
) },
5813 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5814 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5815 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5816 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5817 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5818 { "palignr", { MX
, EM
, Ib
} },
5820 { "(bad)", { XX
} },
5821 { "(bad)", { XX
} },
5822 { "(bad)", { XX
} },
5823 { "(bad)", { XX
} },
5824 { PREFIX_TABLE (PREFIX_0F3A14
) },
5825 { PREFIX_TABLE (PREFIX_0F3A15
) },
5826 { PREFIX_TABLE (PREFIX_0F3A16
) },
5827 { PREFIX_TABLE (PREFIX_0F3A17
) },
5829 { "(bad)", { XX
} },
5830 { "(bad)", { XX
} },
5831 { "(bad)", { XX
} },
5832 { "(bad)", { XX
} },
5833 { "(bad)", { XX
} },
5834 { "(bad)", { XX
} },
5835 { "(bad)", { XX
} },
5836 { "(bad)", { XX
} },
5838 { PREFIX_TABLE (PREFIX_0F3A20
) },
5839 { PREFIX_TABLE (PREFIX_0F3A21
) },
5840 { PREFIX_TABLE (PREFIX_0F3A22
) },
5841 { "(bad)", { XX
} },
5842 { "(bad)", { XX
} },
5843 { "(bad)", { XX
} },
5844 { "(bad)", { XX
} },
5845 { "(bad)", { XX
} },
5847 { "(bad)", { XX
} },
5848 { "(bad)", { XX
} },
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 { PREFIX_TABLE (PREFIX_0F3A40
) },
5875 { PREFIX_TABLE (PREFIX_0F3A41
) },
5876 { PREFIX_TABLE (PREFIX_0F3A42
) },
5877 { "(bad)", { XX
} },
5878 { PREFIX_TABLE (PREFIX_0F3A44
) },
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 { PREFIX_TABLE (PREFIX_0F3A60
) },
5911 { PREFIX_TABLE (PREFIX_0F3A61
) },
5912 { PREFIX_TABLE (PREFIX_0F3A62
) },
5913 { PREFIX_TABLE (PREFIX_0F3A63
) },
5914 { "(bad)", { XX
} },
5915 { "(bad)", { XX
} },
5916 { "(bad)", { XX
} },
5917 { "(bad)", { XX
} },
5919 { "(bad)", { XX
} },
5920 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
6022 { "(bad)", { XX
} },
6023 { "(bad)", { XX
} },
6024 { "(bad)", { XX
} },
6025 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
6046 { "(bad)", { XX
} },
6047 { "(bad)", { XX
} },
6048 { "(bad)", { XX
} },
6049 { "(bad)", { XX
} },
6050 { "(bad)", { XX
} },
6051 { "(bad)", { XX
} },
6052 { PREFIX_TABLE (PREFIX_0F3ADF
) },
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 { "(bad)", { XX
} },
6064 { "(bad)", { XX
} },
6065 { "(bad)", { XX
} },
6066 { "(bad)", { XX
} },
6067 { "(bad)", { XX
} },
6068 { "(bad)", { XX
} },
6069 { "(bad)", { XX
} },
6070 { "(bad)", { XX
} },
6072 { "(bad)", { XX
} },
6073 { "(bad)", { XX
} },
6074 { "(bad)", { XX
} },
6075 { "(bad)", { XX
} },
6076 { "(bad)", { XX
} },
6077 { "(bad)", { XX
} },
6078 { "(bad)", { XX
} },
6079 { "(bad)", { XX
} },
6081 { "(bad)", { XX
} },
6082 { "(bad)", { XX
} },
6083 { "(bad)", { XX
} },
6084 { "(bad)", { XX
} },
6085 { "(bad)", { XX
} },
6086 { "(bad)", { XX
} },
6087 { "(bad)", { XX
} },
6088 { "(bad)", { XX
} },
6091 /* THREE_BYTE_0F7A */
6094 { "(bad)", { XX
} },
6095 { "(bad)", { XX
} },
6096 { "(bad)", { XX
} },
6097 { "(bad)", { XX
} },
6098 { "(bad)", { XX
} },
6099 { "(bad)", { XX
} },
6100 { "(bad)", { XX
} },
6101 { "(bad)", { XX
} },
6103 { "(bad)", { XX
} },
6104 { "(bad)", { XX
} },
6105 { "(bad)", { XX
} },
6106 { "(bad)", { XX
} },
6107 { "(bad)", { XX
} },
6108 { "(bad)", { XX
} },
6109 { "(bad)", { XX
} },
6110 { "(bad)", { XX
} },
6112 { "(bad)", { XX
} },
6113 { "(bad)", { XX
} },
6114 { "(bad)", { XX
} },
6115 { "(bad)", { XX
} },
6116 { "(bad)", { XX
} },
6117 { "(bad)", { XX
} },
6118 { "(bad)", { XX
} },
6119 { "(bad)", { XX
} },
6121 { "(bad)", { XX
} },
6122 { "(bad)", { XX
} },
6123 { "(bad)", { XX
} },
6124 { "(bad)", { XX
} },
6125 { "(bad)", { XX
} },
6126 { "(bad)", { XX
} },
6127 { "(bad)", { XX
} },
6128 { "(bad)", { XX
} },
6130 { "ptest", { XX
} },
6131 { "(bad)", { XX
} },
6132 { "(bad)", { XX
} },
6133 { "(bad)", { XX
} },
6134 { "(bad)", { XX
} },
6135 { "(bad)", { XX
} },
6136 { "(bad)", { XX
} },
6137 { "(bad)", { XX
} },
6139 { "(bad)", { XX
} },
6140 { "(bad)", { XX
} },
6141 { "(bad)", { XX
} },
6142 { "(bad)", { XX
} },
6143 { "(bad)", { XX
} },
6144 { "(bad)", { XX
} },
6145 { "(bad)", { XX
} },
6146 { "(bad)", { XX
} },
6148 { "(bad)", { XX
} },
6149 { "(bad)", { XX
} },
6150 { "(bad)", { XX
} },
6151 { "(bad)", { XX
} },
6152 { "(bad)", { XX
} },
6153 { "(bad)", { XX
} },
6154 { "(bad)", { XX
} },
6155 { "(bad)", { XX
} },
6157 { "(bad)", { XX
} },
6158 { "(bad)", { XX
} },
6159 { "(bad)", { XX
} },
6160 { "(bad)", { XX
} },
6161 { "(bad)", { XX
} },
6162 { "(bad)", { XX
} },
6163 { "(bad)", { XX
} },
6164 { "(bad)", { XX
} },
6166 { "(bad)", { XX
} },
6167 { "phaddbw", { XM
, EXq
} },
6168 { "phaddbd", { XM
, EXq
} },
6169 { "phaddbq", { XM
, EXq
} },
6170 { "(bad)", { XX
} },
6171 { "(bad)", { XX
} },
6172 { "phaddwd", { XM
, EXq
} },
6173 { "phaddwq", { XM
, EXq
} },
6175 { "(bad)", { XX
} },
6176 { "(bad)", { XX
} },
6177 { "(bad)", { XX
} },
6178 { "phadddq", { XM
, EXq
} },
6179 { "(bad)", { XX
} },
6180 { "(bad)", { XX
} },
6181 { "(bad)", { XX
} },
6182 { "(bad)", { XX
} },
6184 { "(bad)", { XX
} },
6185 { "phaddubw", { XM
, EXq
} },
6186 { "phaddubd", { XM
, EXq
} },
6187 { "phaddubq", { XM
, EXq
} },
6188 { "(bad)", { XX
} },
6189 { "(bad)", { XX
} },
6190 { "phadduwd", { XM
, EXq
} },
6191 { "phadduwq", { XM
, EXq
} },
6193 { "(bad)", { XX
} },
6194 { "(bad)", { XX
} },
6195 { "(bad)", { XX
} },
6196 { "phaddudq", { XM
, EXq
} },
6197 { "(bad)", { XX
} },
6198 { "(bad)", { XX
} },
6199 { "(bad)", { XX
} },
6200 { "(bad)", { XX
} },
6202 { "(bad)", { XX
} },
6203 { "phsubbw", { XM
, EXq
} },
6204 { "phsubbd", { XM
, EXq
} },
6205 { "phsubbq", { XM
, EXq
} },
6206 { "(bad)", { XX
} },
6207 { "(bad)", { XX
} },
6208 { "(bad)", { XX
} },
6209 { "(bad)", { XX
} },
6211 { "(bad)", { XX
} },
6212 { "(bad)", { XX
} },
6213 { "(bad)", { XX
} },
6214 { "(bad)", { XX
} },
6215 { "(bad)", { XX
} },
6216 { "(bad)", { XX
} },
6217 { "(bad)", { XX
} },
6218 { "(bad)", { XX
} },
6220 { "(bad)", { XX
} },
6221 { "(bad)", { XX
} },
6222 { "(bad)", { XX
} },
6223 { "(bad)", { XX
} },
6224 { "(bad)", { XX
} },
6225 { "(bad)", { XX
} },
6226 { "(bad)", { XX
} },
6227 { "(bad)", { XX
} },
6229 { "(bad)", { XX
} },
6230 { "(bad)", { XX
} },
6231 { "(bad)", { XX
} },
6232 { "(bad)", { XX
} },
6233 { "(bad)", { XX
} },
6234 { "(bad)", { XX
} },
6235 { "(bad)", { XX
} },
6236 { "(bad)", { XX
} },
6238 { "(bad)", { XX
} },
6239 { "(bad)", { XX
} },
6240 { "(bad)", { XX
} },
6241 { "(bad)", { XX
} },
6242 { "(bad)", { XX
} },
6243 { "(bad)", { XX
} },
6244 { "(bad)", { XX
} },
6245 { "(bad)", { XX
} },
6247 { "(bad)", { XX
} },
6248 { "(bad)", { XX
} },
6249 { "(bad)", { XX
} },
6250 { "(bad)", { XX
} },
6251 { "(bad)", { XX
} },
6252 { "(bad)", { XX
} },
6253 { "(bad)", { XX
} },
6254 { "(bad)", { XX
} },
6256 { "(bad)", { XX
} },
6257 { "(bad)", { XX
} },
6258 { "(bad)", { XX
} },
6259 { "(bad)", { XX
} },
6260 { "(bad)", { XX
} },
6261 { "(bad)", { XX
} },
6262 { "(bad)", { XX
} },
6263 { "(bad)", { XX
} },
6265 { "(bad)", { XX
} },
6266 { "(bad)", { XX
} },
6267 { "(bad)", { XX
} },
6268 { "(bad)", { XX
} },
6269 { "(bad)", { XX
} },
6270 { "(bad)", { XX
} },
6271 { "(bad)", { XX
} },
6272 { "(bad)", { XX
} },
6274 { "(bad)", { XX
} },
6275 { "(bad)", { XX
} },
6276 { "(bad)", { XX
} },
6277 { "(bad)", { XX
} },
6278 { "(bad)", { XX
} },
6279 { "(bad)", { XX
} },
6280 { "(bad)", { XX
} },
6281 { "(bad)", { XX
} },
6283 { "(bad)", { XX
} },
6284 { "(bad)", { XX
} },
6285 { "(bad)", { XX
} },
6286 { "(bad)", { XX
} },
6287 { "(bad)", { XX
} },
6288 { "(bad)", { XX
} },
6289 { "(bad)", { XX
} },
6290 { "(bad)", { XX
} },
6292 { "(bad)", { XX
} },
6293 { "(bad)", { XX
} },
6294 { "(bad)", { XX
} },
6295 { "(bad)", { XX
} },
6296 { "(bad)", { XX
} },
6297 { "(bad)", { XX
} },
6298 { "(bad)", { XX
} },
6299 { "(bad)", { XX
} },
6301 { "(bad)", { XX
} },
6302 { "(bad)", { XX
} },
6303 { "(bad)", { XX
} },
6304 { "(bad)", { XX
} },
6305 { "(bad)", { XX
} },
6306 { "(bad)", { XX
} },
6307 { "(bad)", { XX
} },
6308 { "(bad)", { XX
} },
6310 { "(bad)", { XX
} },
6311 { "(bad)", { XX
} },
6312 { "(bad)", { XX
} },
6313 { "(bad)", { XX
} },
6314 { "(bad)", { XX
} },
6315 { "(bad)", { XX
} },
6316 { "(bad)", { XX
} },
6317 { "(bad)", { XX
} },
6319 { "(bad)", { XX
} },
6320 { "(bad)", { XX
} },
6321 { "(bad)", { XX
} },
6322 { "(bad)", { XX
} },
6323 { "(bad)", { XX
} },
6324 { "(bad)", { XX
} },
6325 { "(bad)", { XX
} },
6326 { "(bad)", { XX
} },
6328 { "(bad)", { XX
} },
6329 { "(bad)", { XX
} },
6330 { "(bad)", { XX
} },
6331 { "(bad)", { XX
} },
6332 { "(bad)", { XX
} },
6333 { "(bad)", { XX
} },
6334 { "(bad)", { XX
} },
6335 { "(bad)", { XX
} },
6337 { "(bad)", { XX
} },
6338 { "(bad)", { XX
} },
6339 { "(bad)", { XX
} },
6340 { "(bad)", { XX
} },
6341 { "(bad)", { XX
} },
6342 { "(bad)", { XX
} },
6343 { "(bad)", { XX
} },
6344 { "(bad)", { XX
} },
6346 { "(bad)", { XX
} },
6347 { "(bad)", { XX
} },
6348 { "(bad)", { XX
} },
6349 { "(bad)", { XX
} },
6350 { "(bad)", { XX
} },
6351 { "(bad)", { XX
} },
6352 { "(bad)", { XX
} },
6353 { "(bad)", { XX
} },
6355 { "(bad)", { XX
} },
6356 { "(bad)", { XX
} },
6357 { "(bad)", { XX
} },
6358 { "(bad)", { XX
} },
6359 { "(bad)", { XX
} },
6360 { "(bad)", { XX
} },
6361 { "(bad)", { XX
} },
6362 { "(bad)", { XX
} },
6364 { "(bad)", { XX
} },
6365 { "(bad)", { XX
} },
6366 { "(bad)", { XX
} },
6367 { "(bad)", { XX
} },
6368 { "(bad)", { XX
} },
6369 { "(bad)", { XX
} },
6370 { "(bad)", { XX
} },
6371 { "(bad)", { XX
} },
6373 { "(bad)", { XX
} },
6374 { "(bad)", { XX
} },
6375 { "(bad)", { XX
} },
6376 { "(bad)", { XX
} },
6377 { "(bad)", { XX
} },
6378 { "(bad)", { XX
} },
6379 { "(bad)", { XX
} },
6380 { "(bad)", { XX
} },
6384 static const struct dis386 xop_table
[][256] = {
6388 { "(bad)", { XX
} },
6389 { "(bad)", { XX
} },
6390 { "(bad)", { XX
} },
6391 { "(bad)", { XX
} },
6392 { "(bad)", { XX
} },
6393 { "(bad)", { XX
} },
6394 { "(bad)", { XX
} },
6395 { "(bad)", { XX
} },
6397 { "(bad)", { XX
} },
6398 { "(bad)", { XX
} },
6399 { "(bad)", { XX
} },
6400 { "(bad)", { XX
} },
6401 { "(bad)", { XX
} },
6402 { "(bad)", { XX
} },
6403 { "(bad)", { XX
} },
6404 { "(bad)", { XX
} },
6406 { "(bad)", { XX
} },
6407 { "(bad)", { XX
} },
6408 { REG_TABLE (REG_XOP_LWPCB
) },
6409 { "(bad)", { XX
} },
6410 { "(bad)", { XX
} },
6411 { "(bad)", { XX
} },
6412 { "(bad)", { XX
} },
6413 { "(bad)", { XX
} },
6415 { "(bad)", { XX
} },
6416 { "(bad)", { XX
} },
6417 { "(bad)", { XX
} },
6418 { "(bad)", { XX
} },
6419 { "(bad)", { XX
} },
6420 { "(bad)", { XX
} },
6421 { "(bad)", { XX
} },
6422 { "(bad)", { XX
} },
6424 { "(bad)", { XX
} },
6425 { "(bad)", { XX
} },
6426 { "(bad)", { XX
} },
6427 { "(bad)", { XX
} },
6428 { "(bad)", { XX
} },
6429 { "(bad)", { XX
} },
6430 { "(bad)", { XX
} },
6431 { "(bad)", { XX
} },
6433 { "(bad)", { XX
} },
6434 { "(bad)", { XX
} },
6435 { "(bad)", { XX
} },
6436 { "(bad)", { XX
} },
6437 { "(bad)", { XX
} },
6438 { "(bad)", { XX
} },
6439 { "(bad)", { XX
} },
6440 { "(bad)", { XX
} },
6442 { "(bad)", { XX
} },
6443 { "(bad)", { XX
} },
6444 { "(bad)", { XX
} },
6445 { "(bad)", { XX
} },
6446 { "(bad)", { XX
} },
6447 { "(bad)", { XX
} },
6448 { "(bad)", { XX
} },
6449 { "(bad)", { XX
} },
6451 { "(bad)", { XX
} },
6452 { "(bad)", { XX
} },
6453 { "(bad)", { XX
} },
6454 { "(bad)", { XX
} },
6455 { "(bad)", { XX
} },
6456 { "(bad)", { XX
} },
6457 { "(bad)", { XX
} },
6458 { "(bad)", { XX
} },
6460 { "(bad)", { XX
} },
6461 { "(bad)", { XX
} },
6462 { "(bad)", { XX
} },
6463 { "(bad)", { XX
} },
6464 { "(bad)", { XX
} },
6465 { "(bad)", { XX
} },
6466 { "(bad)", { XX
} },
6467 { "(bad)", { XX
} },
6469 { "(bad)", { XX
} },
6470 { "(bad)", { XX
} },
6471 { "(bad)", { XX
} },
6472 { "(bad)", { XX
} },
6473 { "(bad)", { XX
} },
6474 { "(bad)", { XX
} },
6475 { "(bad)", { XX
} },
6476 { "(bad)", { XX
} },
6478 { "(bad)", { XX
} },
6479 { "(bad)", { XX
} },
6480 { "(bad)", { XX
} },
6481 { "(bad)", { XX
} },
6482 { "(bad)", { XX
} },
6483 { "(bad)", { XX
} },
6484 { "(bad)", { XX
} },
6485 { "(bad)", { XX
} },
6487 { "(bad)", { XX
} },
6488 { "(bad)", { XX
} },
6489 { "(bad)", { XX
} },
6490 { "(bad)", { XX
} },
6491 { "(bad)", { XX
} },
6492 { "(bad)", { XX
} },
6493 { "(bad)", { XX
} },
6494 { "(bad)", { XX
} },
6496 { "(bad)", { XX
} },
6497 { "(bad)", { XX
} },
6498 { "(bad)", { XX
} },
6499 { "(bad)", { XX
} },
6500 { "(bad)", { XX
} },
6501 { "(bad)", { XX
} },
6502 { "(bad)", { XX
} },
6503 { "(bad)", { XX
} },
6505 { "(bad)", { XX
} },
6506 { "(bad)", { XX
} },
6507 { "(bad)", { XX
} },
6508 { "(bad)", { XX
} },
6509 { "(bad)", { XX
} },
6510 { "(bad)", { XX
} },
6511 { "(bad)", { XX
} },
6512 { "(bad)", { XX
} },
6514 { "(bad)", { XX
} },
6515 { "(bad)", { XX
} },
6516 { "(bad)", { XX
} },
6517 { "(bad)", { XX
} },
6518 { "(bad)", { XX
} },
6519 { "(bad)", { XX
} },
6520 { "(bad)", { XX
} },
6521 { "(bad)", { XX
} },
6523 { "(bad)", { XX
} },
6524 { "(bad)", { XX
} },
6525 { "(bad)", { XX
} },
6526 { "(bad)", { XX
} },
6527 { "(bad)", { XX
} },
6528 { "(bad)", { XX
} },
6529 { "(bad)", { XX
} },
6530 { "(bad)", { XX
} },
6532 { "(bad)", { XX
} },
6533 { "(bad)", { XX
} },
6534 { "(bad)", { XX
} },
6535 { "(bad)", { XX
} },
6536 { "(bad)", { XX
} },
6537 { "(bad)", { XX
} },
6538 { "(bad)", { XX
} },
6539 { "(bad)", { XX
} },
6541 { "(bad)", { XX
} },
6542 { "(bad)", { XX
} },
6543 { "(bad)", { XX
} },
6544 { "(bad)", { XX
} },
6545 { "(bad)", { XX
} },
6546 { "(bad)", { XX
} },
6547 { "(bad)", { XX
} },
6548 { "(bad)", { XX
} },
6550 { "(bad)", { XX
} },
6551 { "(bad)", { XX
} },
6552 { "(bad)", { XX
} },
6553 { "(bad)", { XX
} },
6554 { "(bad)", { XX
} },
6555 { "(bad)", { XX
} },
6556 { "(bad)", { XX
} },
6557 { "(bad)", { XX
} },
6559 { "(bad)", { XX
} },
6560 { "(bad)", { XX
} },
6561 { "(bad)", { XX
} },
6562 { "(bad)", { XX
} },
6563 { "(bad)", { XX
} },
6564 { "(bad)", { XX
} },
6565 { "(bad)", { XX
} },
6566 { "(bad)", { XX
} },
6568 { "(bad)", { XX
} },
6569 { "(bad)", { XX
} },
6570 { "(bad)", { XX
} },
6571 { "(bad)", { XX
} },
6572 { "(bad)", { XX
} },
6573 { "(bad)", { XX
} },
6574 { "(bad)", { XX
} },
6575 { "(bad)", { XX
} },
6577 { "(bad)", { XX
} },
6578 { "(bad)", { XX
} },
6579 { "(bad)", { XX
} },
6580 { "(bad)", { XX
} },
6581 { "(bad)", { XX
} },
6582 { "(bad)", { XX
} },
6583 { "(bad)", { XX
} },
6584 { "(bad)", { XX
} },
6586 { "(bad)", { XX
} },
6587 { "(bad)", { XX
} },
6588 { "(bad)", { XX
} },
6589 { "(bad)", { XX
} },
6590 { "(bad)", { XX
} },
6591 { "(bad)", { XX
} },
6592 { "(bad)", { XX
} },
6593 { "(bad)", { XX
} },
6595 { "(bad)", { XX
} },
6596 { "(bad)", { XX
} },
6597 { "(bad)", { XX
} },
6598 { "(bad)", { XX
} },
6599 { "(bad)", { XX
} },
6600 { "(bad)", { XX
} },
6601 { "(bad)", { XX
} },
6602 { "(bad)", { XX
} },
6604 { "(bad)", { XX
} },
6605 { "(bad)", { XX
} },
6606 { "(bad)", { XX
} },
6607 { "(bad)", { XX
} },
6608 { "(bad)", { XX
} },
6609 { "(bad)", { XX
} },
6610 { "(bad)", { XX
} },
6611 { "(bad)", { XX
} },
6613 { "(bad)", { XX
} },
6614 { "(bad)", { XX
} },
6615 { "(bad)", { XX
} },
6616 { "(bad)", { XX
} },
6617 { "(bad)", { XX
} },
6618 { "(bad)", { XX
} },
6619 { "(bad)", { XX
} },
6620 { "(bad)", { XX
} },
6622 { "(bad)", { XX
} },
6623 { "(bad)", { XX
} },
6624 { "(bad)", { XX
} },
6625 { "(bad)", { XX
} },
6626 { "(bad)", { XX
} },
6627 { "(bad)", { XX
} },
6628 { "(bad)", { XX
} },
6629 { "(bad)", { XX
} },
6631 { "(bad)", { XX
} },
6632 { "(bad)", { XX
} },
6633 { "(bad)", { XX
} },
6634 { "(bad)", { XX
} },
6635 { "(bad)", { XX
} },
6636 { "(bad)", { XX
} },
6637 { "(bad)", { XX
} },
6638 { "(bad)", { XX
} },
6640 { "(bad)", { XX
} },
6641 { "(bad)", { XX
} },
6642 { "(bad)", { XX
} },
6643 { "(bad)", { XX
} },
6644 { "(bad)", { XX
} },
6645 { "(bad)", { XX
} },
6646 { "(bad)", { XX
} },
6647 { "(bad)", { XX
} },
6649 { "(bad)", { XX
} },
6650 { "(bad)", { XX
} },
6651 { "(bad)", { XX
} },
6652 { "(bad)", { XX
} },
6653 { "(bad)", { XX
} },
6654 { "(bad)", { XX
} },
6655 { "(bad)", { XX
} },
6656 { "(bad)", { XX
} },
6658 { "(bad)", { XX
} },
6659 { "(bad)", { XX
} },
6660 { "(bad)", { XX
} },
6661 { "(bad)", { XX
} },
6662 { "(bad)", { XX
} },
6663 { "(bad)", { XX
} },
6664 { "(bad)", { XX
} },
6665 { "(bad)", { XX
} },
6667 { "(bad)", { XX
} },
6668 { "(bad)", { XX
} },
6669 { "(bad)", { XX
} },
6670 { "(bad)", { XX
} },
6671 { "(bad)", { XX
} },
6672 { "(bad)", { XX
} },
6673 { "(bad)", { XX
} },
6674 { "(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 { REG_TABLE (REG_XOP_LWP
) },
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 { "(bad)", { XX
} },
6802 { "(bad)", { XX
} },
6803 { "(bad)", { XX
} },
6805 { "(bad)", { XX
} },
6806 { "(bad)", { XX
} },
6807 { "(bad)", { XX
} },
6808 { "(bad)", { XX
} },
6809 { "(bad)", { XX
} },
6810 { "(bad)", { XX
} },
6811 { "(bad)", { XX
} },
6812 { "(bad)", { XX
} },
6814 { "(bad)", { XX
} },
6815 { "(bad)", { XX
} },
6816 { "(bad)", { XX
} },
6817 { "(bad)", { XX
} },
6818 { "(bad)", { XX
} },
6819 { "(bad)", { XX
} },
6820 { "(bad)", { XX
} },
6821 { "(bad)", { XX
} },
6823 { "(bad)", { XX
} },
6824 { "(bad)", { XX
} },
6825 { "(bad)", { XX
} },
6826 { "(bad)", { XX
} },
6827 { "(bad)", { XX
} },
6828 { "(bad)", { XX
} },
6829 { "(bad)", { XX
} },
6830 { "(bad)", { XX
} },
6832 { "(bad)", { XX
} },
6833 { "(bad)", { XX
} },
6834 { "(bad)", { XX
} },
6835 { "(bad)", { XX
} },
6836 { "(bad)", { XX
} },
6837 { "(bad)", { XX
} },
6838 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
6869 { "(bad)", { XX
} },
6870 { "(bad)", { XX
} },
6871 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
6882 { "(bad)", { XX
} },
6883 { "(bad)", { XX
} },
6884 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
6918 { "(bad)", { XX
} },
6919 { "(bad)", { XX
} },
6920 { "(bad)", { XX
} },
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
} },
6940 { "(bad)", { XX
} },
6941 { "(bad)", { XX
} },
6942 { "(bad)", { XX
} },
6943 { "(bad)", { XX
} },
6944 { "(bad)", { XX
} },
6945 { "(bad)", { XX
} },
6946 { "(bad)", { XX
} },
6947 { "(bad)", { XX
} },
6949 { "(bad)", { XX
} },
6950 { "(bad)", { XX
} },
6951 { "(bad)", { XX
} },
6952 { "(bad)", { XX
} },
6953 { "(bad)", { XX
} },
6954 { "(bad)", { XX
} },
6955 { "(bad)", { XX
} },
6956 { "(bad)", { XX
} },
6958 { "(bad)", { XX
} },
6959 { "(bad)", { XX
} },
6960 { "(bad)", { XX
} },
6961 { "(bad)", { XX
} },
6962 { "(bad)", { XX
} },
6963 { "(bad)", { XX
} },
6964 { "(bad)", { XX
} },
6965 { "(bad)", { XX
} },
6969 static const struct dis386 vex_table
[][256] = {
6973 { "(bad)", { XX
} },
6974 { "(bad)", { XX
} },
6975 { "(bad)", { XX
} },
6976 { "(bad)", { XX
} },
6977 { "(bad)", { XX
} },
6978 { "(bad)", { XX
} },
6979 { "(bad)", { XX
} },
6980 { "(bad)", { XX
} },
6982 { "(bad)", { XX
} },
6983 { "(bad)", { XX
} },
6984 { "(bad)", { XX
} },
6985 { "(bad)", { XX
} },
6986 { "(bad)", { XX
} },
6987 { "(bad)", { XX
} },
6988 { "(bad)", { XX
} },
6989 { "(bad)", { XX
} },
6991 { PREFIX_TABLE (PREFIX_VEX_10
) },
6992 { PREFIX_TABLE (PREFIX_VEX_11
) },
6993 { PREFIX_TABLE (PREFIX_VEX_12
) },
6994 { MOD_TABLE (MOD_VEX_13
) },
6995 { "vunpcklpX", { XM
, Vex
, EXx
} },
6996 { "vunpckhpX", { XM
, Vex
, EXx
} },
6997 { PREFIX_TABLE (PREFIX_VEX_16
) },
6998 { MOD_TABLE (MOD_VEX_17
) },
7000 { "(bad)", { XX
} },
7001 { "(bad)", { XX
} },
7002 { "(bad)", { XX
} },
7003 { "(bad)", { XX
} },
7004 { "(bad)", { XX
} },
7005 { "(bad)", { XX
} },
7006 { "(bad)", { XX
} },
7007 { "(bad)", { XX
} },
7009 { "(bad)", { XX
} },
7010 { "(bad)", { XX
} },
7011 { "(bad)", { XX
} },
7012 { "(bad)", { XX
} },
7013 { "(bad)", { XX
} },
7014 { "(bad)", { XX
} },
7015 { "(bad)", { XX
} },
7016 { "(bad)", { XX
} },
7018 { "vmovapX", { XM
, EXx
} },
7019 { "vmovapX", { EXxS
, XM
} },
7020 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7021 { MOD_TABLE (MOD_VEX_2B
) },
7022 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7023 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7024 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7025 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7027 { "(bad)", { XX
} },
7028 { "(bad)", { XX
} },
7029 { "(bad)", { XX
} },
7030 { "(bad)", { XX
} },
7031 { "(bad)", { XX
} },
7032 { "(bad)", { XX
} },
7033 { "(bad)", { XX
} },
7034 { "(bad)", { XX
} },
7036 { "(bad)", { XX
} },
7037 { "(bad)", { XX
} },
7038 { "(bad)", { XX
} },
7039 { "(bad)", { XX
} },
7040 { "(bad)", { XX
} },
7041 { "(bad)", { XX
} },
7042 { "(bad)", { XX
} },
7043 { "(bad)", { XX
} },
7045 { "(bad)", { XX
} },
7046 { "(bad)", { XX
} },
7047 { "(bad)", { XX
} },
7048 { "(bad)", { XX
} },
7049 { "(bad)", { XX
} },
7050 { "(bad)", { XX
} },
7051 { "(bad)", { XX
} },
7052 { "(bad)", { XX
} },
7054 { "(bad)", { XX
} },
7055 { "(bad)", { XX
} },
7056 { "(bad)", { XX
} },
7057 { "(bad)", { XX
} },
7058 { "(bad)", { XX
} },
7059 { "(bad)", { XX
} },
7060 { "(bad)", { XX
} },
7061 { "(bad)", { XX
} },
7063 { MOD_TABLE (MOD_VEX_51
) },
7064 { PREFIX_TABLE (PREFIX_VEX_51
) },
7065 { PREFIX_TABLE (PREFIX_VEX_52
) },
7066 { PREFIX_TABLE (PREFIX_VEX_53
) },
7067 { "vandpX", { XM
, Vex
, EXx
} },
7068 { "vandnpX", { XM
, Vex
, EXx
} },
7069 { "vorpX", { XM
, Vex
, EXx
} },
7070 { "vxorpX", { XM
, Vex
, EXx
} },
7072 { PREFIX_TABLE (PREFIX_VEX_58
) },
7073 { PREFIX_TABLE (PREFIX_VEX_59
) },
7074 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7075 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7076 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7077 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7078 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7079 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7081 { PREFIX_TABLE (PREFIX_VEX_60
) },
7082 { PREFIX_TABLE (PREFIX_VEX_61
) },
7083 { PREFIX_TABLE (PREFIX_VEX_62
) },
7084 { PREFIX_TABLE (PREFIX_VEX_63
) },
7085 { PREFIX_TABLE (PREFIX_VEX_64
) },
7086 { PREFIX_TABLE (PREFIX_VEX_65
) },
7087 { PREFIX_TABLE (PREFIX_VEX_66
) },
7088 { PREFIX_TABLE (PREFIX_VEX_67
) },
7090 { PREFIX_TABLE (PREFIX_VEX_68
) },
7091 { PREFIX_TABLE (PREFIX_VEX_69
) },
7092 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7093 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7094 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7095 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7096 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7097 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7099 { PREFIX_TABLE (PREFIX_VEX_70
) },
7100 { REG_TABLE (REG_VEX_71
) },
7101 { REG_TABLE (REG_VEX_72
) },
7102 { REG_TABLE (REG_VEX_73
) },
7103 { PREFIX_TABLE (PREFIX_VEX_74
) },
7104 { PREFIX_TABLE (PREFIX_VEX_75
) },
7105 { PREFIX_TABLE (PREFIX_VEX_76
) },
7106 { PREFIX_TABLE (PREFIX_VEX_77
) },
7108 { "(bad)", { XX
} },
7109 { "(bad)", { XX
} },
7110 { "(bad)", { XX
} },
7111 { "(bad)", { XX
} },
7112 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7113 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7114 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7115 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7117 { "(bad)", { XX
} },
7118 { "(bad)", { XX
} },
7119 { "(bad)", { XX
} },
7120 { "(bad)", { XX
} },
7121 { "(bad)", { XX
} },
7122 { "(bad)", { XX
} },
7123 { "(bad)", { XX
} },
7124 { "(bad)", { XX
} },
7126 { "(bad)", { XX
} },
7127 { "(bad)", { XX
} },
7128 { "(bad)", { XX
} },
7129 { "(bad)", { XX
} },
7130 { "(bad)", { XX
} },
7131 { "(bad)", { XX
} },
7132 { "(bad)", { XX
} },
7133 { "(bad)", { XX
} },
7135 { "(bad)", { XX
} },
7136 { "(bad)", { XX
} },
7137 { "(bad)", { XX
} },
7138 { "(bad)", { XX
} },
7139 { "(bad)", { XX
} },
7140 { "(bad)", { XX
} },
7141 { "(bad)", { XX
} },
7142 { "(bad)", { XX
} },
7144 { "(bad)", { XX
} },
7145 { "(bad)", { XX
} },
7146 { "(bad)", { XX
} },
7147 { "(bad)", { XX
} },
7148 { "(bad)", { XX
} },
7149 { "(bad)", { XX
} },
7150 { "(bad)", { XX
} },
7151 { "(bad)", { XX
} },
7153 { "(bad)", { XX
} },
7154 { "(bad)", { XX
} },
7155 { "(bad)", { XX
} },
7156 { "(bad)", { XX
} },
7157 { "(bad)", { XX
} },
7158 { "(bad)", { XX
} },
7159 { "(bad)", { XX
} },
7160 { "(bad)", { XX
} },
7162 { "(bad)", { XX
} },
7163 { "(bad)", { XX
} },
7164 { "(bad)", { XX
} },
7165 { "(bad)", { XX
} },
7166 { "(bad)", { XX
} },
7167 { "(bad)", { XX
} },
7168 { REG_TABLE (REG_VEX_AE
) },
7169 { "(bad)", { XX
} },
7171 { "(bad)", { XX
} },
7172 { "(bad)", { XX
} },
7173 { "(bad)", { XX
} },
7174 { "(bad)", { XX
} },
7175 { "(bad)", { XX
} },
7176 { "(bad)", { XX
} },
7177 { "(bad)", { XX
} },
7178 { "(bad)", { XX
} },
7180 { "(bad)", { XX
} },
7181 { "(bad)", { XX
} },
7182 { "(bad)", { XX
} },
7183 { "(bad)", { XX
} },
7184 { "(bad)", { XX
} },
7185 { "(bad)", { XX
} },
7186 { "(bad)", { XX
} },
7187 { "(bad)", { XX
} },
7189 { "(bad)", { XX
} },
7190 { "(bad)", { XX
} },
7191 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7192 { "(bad)", { XX
} },
7193 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7194 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7195 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7196 { "(bad)", { XX
} },
7198 { "(bad)", { XX
} },
7199 { "(bad)", { XX
} },
7200 { "(bad)", { XX
} },
7201 { "(bad)", { XX
} },
7202 { "(bad)", { XX
} },
7203 { "(bad)", { XX
} },
7204 { "(bad)", { XX
} },
7205 { "(bad)", { XX
} },
7207 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7208 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7209 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7210 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7211 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7212 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7213 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7214 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7216 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7217 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7218 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7219 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7220 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7221 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7222 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7223 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7225 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7226 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7227 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7228 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7229 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7230 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7231 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7232 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7234 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7235 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7236 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7237 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7238 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7239 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7240 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7241 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7243 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7244 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7245 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7246 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7247 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7248 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7249 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7250 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7252 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7253 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7254 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7255 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7256 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7257 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7258 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7259 { "(bad)", { XX
} },
7264 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7265 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7266 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7267 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7268 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7269 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7270 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7271 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7273 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7274 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7275 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7276 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7277 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7278 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7279 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7280 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7282 { "(bad)", { XX
} },
7283 { "(bad)", { XX
} },
7284 { "(bad)", { XX
} },
7285 { "(bad)", { XX
} },
7286 { "(bad)", { XX
} },
7287 { "(bad)", { XX
} },
7288 { "(bad)", { XX
} },
7289 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7291 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7292 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7293 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7294 { "(bad)", { XX
} },
7295 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7296 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7297 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7298 { "(bad)", { XX
} },
7300 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7301 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7302 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7303 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7304 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7305 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7306 { "(bad)", { XX
} },
7307 { "(bad)", { XX
} },
7309 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7310 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7311 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7312 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7313 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7314 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7315 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7316 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7318 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7319 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7320 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7321 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7322 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7323 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7324 { "(bad)", { XX
} },
7325 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7327 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7328 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7329 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7330 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7331 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7332 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7333 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7334 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7336 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7337 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7338 { "(bad)", { XX
} },
7339 { "(bad)", { XX
} },
7340 { "(bad)", { XX
} },
7341 { "(bad)", { XX
} },
7342 { "(bad)", { XX
} },
7343 { "(bad)", { XX
} },
7345 { "(bad)", { XX
} },
7346 { "(bad)", { XX
} },
7347 { "(bad)", { XX
} },
7348 { "(bad)", { XX
} },
7349 { "(bad)", { XX
} },
7350 { "(bad)", { XX
} },
7351 { "(bad)", { XX
} },
7352 { "(bad)", { XX
} },
7354 { "(bad)", { XX
} },
7355 { "(bad)", { XX
} },
7356 { "(bad)", { XX
} },
7357 { "(bad)", { XX
} },
7358 { "(bad)", { XX
} },
7359 { "(bad)", { XX
} },
7360 { "(bad)", { XX
} },
7361 { "(bad)", { XX
} },
7363 { "(bad)", { XX
} },
7364 { "(bad)", { XX
} },
7365 { "(bad)", { XX
} },
7366 { "(bad)", { XX
} },
7367 { "(bad)", { XX
} },
7368 { "(bad)", { XX
} },
7369 { "(bad)", { XX
} },
7370 { "(bad)", { XX
} },
7372 { "(bad)", { XX
} },
7373 { "(bad)", { XX
} },
7374 { "(bad)", { XX
} },
7375 { "(bad)", { XX
} },
7376 { "(bad)", { XX
} },
7377 { "(bad)", { XX
} },
7378 { "(bad)", { XX
} },
7379 { "(bad)", { XX
} },
7381 { "(bad)", { XX
} },
7382 { "(bad)", { XX
} },
7383 { "(bad)", { XX
} },
7384 { "(bad)", { XX
} },
7385 { "(bad)", { XX
} },
7386 { "(bad)", { XX
} },
7387 { "(bad)", { XX
} },
7388 { "(bad)", { XX
} },
7390 { "(bad)", { XX
} },
7391 { "(bad)", { XX
} },
7392 { "(bad)", { XX
} },
7393 { "(bad)", { XX
} },
7394 { "(bad)", { XX
} },
7395 { "(bad)", { XX
} },
7396 { "(bad)", { XX
} },
7397 { "(bad)", { XX
} },
7399 { "(bad)", { XX
} },
7400 { "(bad)", { XX
} },
7401 { "(bad)", { XX
} },
7402 { "(bad)", { XX
} },
7403 { "(bad)", { XX
} },
7404 { "(bad)", { XX
} },
7405 { "(bad)", { XX
} },
7406 { "(bad)", { XX
} },
7408 { "(bad)", { XX
} },
7409 { "(bad)", { XX
} },
7410 { "(bad)", { XX
} },
7411 { "(bad)", { XX
} },
7412 { "(bad)", { XX
} },
7413 { "(bad)", { XX
} },
7414 { "(bad)", { XX
} },
7415 { "(bad)", { XX
} },
7417 { "(bad)", { XX
} },
7418 { "(bad)", { XX
} },
7419 { "(bad)", { XX
} },
7420 { "(bad)", { XX
} },
7421 { "(bad)", { XX
} },
7422 { "(bad)", { XX
} },
7423 { "(bad)", { XX
} },
7424 { "(bad)", { XX
} },
7426 { "(bad)", { XX
} },
7427 { "(bad)", { XX
} },
7428 { "(bad)", { XX
} },
7429 { "(bad)", { XX
} },
7430 { "(bad)", { XX
} },
7431 { "(bad)", { XX
} },
7432 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7433 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7435 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7436 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7437 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7438 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7439 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7440 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7441 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7442 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7444 { "(bad)", { XX
} },
7445 { "(bad)", { XX
} },
7446 { "(bad)", { XX
} },
7447 { "(bad)", { XX
} },
7448 { "(bad)", { XX
} },
7449 { "(bad)", { XX
} },
7450 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7451 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7453 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7454 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7455 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7456 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7457 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7458 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7459 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7460 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7462 { "(bad)", { XX
} },
7463 { "(bad)", { XX
} },
7464 { "(bad)", { XX
} },
7465 { "(bad)", { XX
} },
7466 { "(bad)", { XX
} },
7467 { "(bad)", { XX
} },
7468 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7469 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7471 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7472 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7473 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7474 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7475 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7476 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7477 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7478 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7480 { "(bad)", { XX
} },
7481 { "(bad)", { XX
} },
7482 { "(bad)", { XX
} },
7483 { "(bad)", { XX
} },
7484 { "(bad)", { XX
} },
7485 { "(bad)", { XX
} },
7486 { "(bad)", { XX
} },
7487 { "(bad)", { XX
} },
7489 { "(bad)", { XX
} },
7490 { "(bad)", { XX
} },
7491 { "(bad)", { XX
} },
7492 { "(bad)", { XX
} },
7493 { "(bad)", { XX
} },
7494 { "(bad)", { XX
} },
7495 { "(bad)", { XX
} },
7496 { "(bad)", { XX
} },
7498 { "(bad)", { XX
} },
7499 { "(bad)", { XX
} },
7500 { "(bad)", { XX
} },
7501 { "(bad)", { XX
} },
7502 { "(bad)", { XX
} },
7503 { "(bad)", { XX
} },
7504 { "(bad)", { XX
} },
7505 { "(bad)", { XX
} },
7507 { "(bad)", { XX
} },
7508 { "(bad)", { XX
} },
7509 { "(bad)", { XX
} },
7510 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7511 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7512 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7513 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7514 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7516 { "(bad)", { XX
} },
7517 { "(bad)", { XX
} },
7518 { "(bad)", { XX
} },
7519 { "(bad)", { XX
} },
7520 { "(bad)", { XX
} },
7521 { "(bad)", { XX
} },
7522 { "(bad)", { XX
} },
7523 { "(bad)", { XX
} },
7525 { "(bad)", { XX
} },
7526 { "(bad)", { XX
} },
7527 { "(bad)", { XX
} },
7528 { "(bad)", { XX
} },
7529 { "(bad)", { XX
} },
7530 { "(bad)", { XX
} },
7531 { "(bad)", { XX
} },
7532 { "(bad)", { XX
} },
7534 { "(bad)", { XX
} },
7535 { "(bad)", { XX
} },
7536 { "(bad)", { XX
} },
7537 { "(bad)", { XX
} },
7538 { "(bad)", { XX
} },
7539 { "(bad)", { XX
} },
7540 { "(bad)", { XX
} },
7541 { "(bad)", { XX
} },
7543 { "(bad)", { XX
} },
7544 { "(bad)", { XX
} },
7545 { "(bad)", { XX
} },
7546 { "(bad)", { XX
} },
7547 { "(bad)", { XX
} },
7548 { "(bad)", { XX
} },
7549 { "(bad)", { XX
} },
7550 { "(bad)", { XX
} },
7555 { "(bad)", { XX
} },
7556 { "(bad)", { XX
} },
7557 { "(bad)", { XX
} },
7558 { "(bad)", { XX
} },
7559 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7560 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7561 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7562 { "(bad)", { XX
} },
7564 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7565 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7566 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7567 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7568 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7569 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7570 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7571 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7573 { "(bad)", { XX
} },
7574 { "(bad)", { XX
} },
7575 { "(bad)", { XX
} },
7576 { "(bad)", { XX
} },
7577 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7578 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7579 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7580 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7582 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7583 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7584 { "(bad)", { XX
} },
7585 { "(bad)", { XX
} },
7586 { "(bad)", { XX
} },
7587 { "(bad)", { XX
} },
7588 { "(bad)", { XX
} },
7589 { "(bad)", { XX
} },
7591 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7592 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7593 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
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 { "(bad)", { XX
} },
7619 { "(bad)", { XX
} },
7620 { "(bad)", { XX
} },
7621 { "(bad)", { XX
} },
7622 { "(bad)", { XX
} },
7623 { "(bad)", { XX
} },
7624 { "(bad)", { XX
} },
7625 { "(bad)", { XX
} },
7627 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7628 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7629 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7630 { "(bad)", { XX
} },
7631 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7632 { "(bad)", { XX
} },
7633 { "(bad)", { XX
} },
7634 { "(bad)", { XX
} },
7636 { "(bad)", { XX
} },
7637 { "(bad)", { XX
} },
7638 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7639 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7640 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7641 { "(bad)", { XX
} },
7642 { "(bad)", { XX
} },
7643 { "(bad)", { XX
} },
7645 { "(bad)", { XX
} },
7646 { "(bad)", { XX
} },
7647 { "(bad)", { XX
} },
7648 { "(bad)", { XX
} },
7649 { "(bad)", { XX
} },
7650 { "(bad)", { XX
} },
7651 { "(bad)", { XX
} },
7652 { "(bad)", { XX
} },
7654 { "(bad)", { XX
} },
7655 { "(bad)", { XX
} },
7656 { "(bad)", { XX
} },
7657 { "(bad)", { XX
} },
7658 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7659 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7660 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7661 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7663 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7664 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7665 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7666 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7667 { "(bad)", { XX
} },
7668 { "(bad)", { XX
} },
7669 { "(bad)", { XX
} },
7670 { "(bad)", { XX
} },
7672 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7673 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7674 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7675 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7676 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7677 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7678 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7679 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
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 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7691 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7692 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7693 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7694 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7695 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7696 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7697 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
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 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
7747 { "(bad)", { XX
} },
7748 { "(bad)", { XX
} },
7749 { "(bad)", { XX
} },
7750 { "(bad)", { XX
} },
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 { "(bad)", { XX
} },
7763 { "(bad)", { XX
} },
7764 { "(bad)", { XX
} },
7765 { "(bad)", { XX
} },
7766 { "(bad)", { XX
} },
7767 { "(bad)", { XX
} },
7768 { "(bad)", { XX
} },
7769 { "(bad)", { XX
} },
7771 { "(bad)", { XX
} },
7772 { "(bad)", { XX
} },
7773 { "(bad)", { XX
} },
7774 { "(bad)", { XX
} },
7775 { "(bad)", { XX
} },
7776 { "(bad)", { XX
} },
7777 { "(bad)", { XX
} },
7778 { "(bad)", { XX
} },
7780 { "(bad)", { XX
} },
7781 { "(bad)", { XX
} },
7782 { "(bad)", { XX
} },
7783 { "(bad)", { XX
} },
7784 { "(bad)", { XX
} },
7785 { "(bad)", { XX
} },
7786 { "(bad)", { XX
} },
7787 { "(bad)", { XX
} },
7789 { "(bad)", { XX
} },
7790 { "(bad)", { XX
} },
7791 { "(bad)", { XX
} },
7792 { "(bad)", { XX
} },
7793 { "(bad)", { XX
} },
7794 { "(bad)", { XX
} },
7795 { "(bad)", { XX
} },
7796 { "(bad)", { XX
} },
7798 { "(bad)", { XX
} },
7799 { "(bad)", { XX
} },
7800 { "(bad)", { XX
} },
7801 { "(bad)", { XX
} },
7802 { "(bad)", { XX
} },
7803 { "(bad)", { XX
} },
7804 { "(bad)", { XX
} },
7805 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
7807 { "(bad)", { XX
} },
7808 { "(bad)", { XX
} },
7809 { "(bad)", { XX
} },
7810 { "(bad)", { XX
} },
7811 { "(bad)", { XX
} },
7812 { "(bad)", { XX
} },
7813 { "(bad)", { XX
} },
7814 { "(bad)", { XX
} },
7816 { "(bad)", { XX
} },
7817 { "(bad)", { XX
} },
7818 { "(bad)", { XX
} },
7819 { "(bad)", { XX
} },
7820 { "(bad)", { XX
} },
7821 { "(bad)", { XX
} },
7822 { "(bad)", { XX
} },
7823 { "(bad)", { XX
} },
7825 { "(bad)", { XX
} },
7826 { "(bad)", { XX
} },
7827 { "(bad)", { XX
} },
7828 { "(bad)", { XX
} },
7829 { "(bad)", { XX
} },
7830 { "(bad)", { XX
} },
7831 { "(bad)", { XX
} },
7832 { "(bad)", { XX
} },
7834 { "(bad)", { XX
} },
7835 { "(bad)", { XX
} },
7836 { "(bad)", { XX
} },
7837 { "(bad)", { XX
} },
7838 { "(bad)", { XX
} },
7839 { "(bad)", { XX
} },
7840 { "(bad)", { XX
} },
7841 { "(bad)", { XX
} },
7845 static const struct dis386 vex_len_table
[][2] = {
7846 /* VEX_LEN_10_P_1 */
7848 { "vmovss", { XMVex
, Vex128
, EXd
} },
7849 { "(bad)", { XX
} },
7852 /* VEX_LEN_10_P_3 */
7854 { "vmovsd", { XMVex
, Vex128
, EXq
} },
7855 { "(bad)", { XX
} },
7858 /* VEX_LEN_11_P_1 */
7860 { "vmovss", { EXdVexS
, Vex128
, XM
} },
7861 { "(bad)", { XX
} },
7864 /* VEX_LEN_11_P_3 */
7866 { "vmovsd", { EXqVexS
, Vex128
, XM
} },
7867 { "(bad)", { XX
} },
7870 /* VEX_LEN_12_P_0_M_0 */
7872 { "vmovlps", { XM
, Vex128
, EXq
} },
7873 { "(bad)", { XX
} },
7876 /* VEX_LEN_12_P_0_M_1 */
7878 { "vmovhlps", { XM
, Vex128
, EXq
} },
7879 { "(bad)", { XX
} },
7882 /* VEX_LEN_12_P_2 */
7884 { "vmovlpd", { XM
, Vex128
, EXq
} },
7885 { "(bad)", { XX
} },
7888 /* VEX_LEN_13_M_0 */
7890 { "vmovlpX", { EXq
, XM
} },
7891 { "(bad)", { XX
} },
7894 /* VEX_LEN_16_P_0_M_0 */
7896 { "vmovhps", { XM
, Vex128
, EXq
} },
7897 { "(bad)", { XX
} },
7900 /* VEX_LEN_16_P_0_M_1 */
7902 { "vmovlhps", { XM
, Vex128
, EXq
} },
7903 { "(bad)", { XX
} },
7906 /* VEX_LEN_16_P_2 */
7908 { "vmovhpd", { XM
, Vex128
, EXq
} },
7909 { "(bad)", { XX
} },
7912 /* VEX_LEN_17_M_0 */
7914 { "vmovhpX", { EXq
, XM
} },
7915 { "(bad)", { XX
} },
7918 /* VEX_LEN_2A_P_1 */
7920 { "vcvtsi2ss%LQ", { XM
, Vex128
, Ev
} },
7921 { "(bad)", { XX
} },
7924 /* VEX_LEN_2A_P_3 */
7926 { "vcvtsi2sd%LQ", { XM
, Vex128
, Ev
} },
7927 { "(bad)", { XX
} },
7930 /* VEX_LEN_2C_P_1 */
7932 { "vcvttss2siY", { Gv
, EXd
} },
7933 { "(bad)", { XX
} },
7936 /* VEX_LEN_2C_P_3 */
7938 { "vcvttsd2siY", { Gv
, EXq
} },
7939 { "(bad)", { XX
} },
7942 /* VEX_LEN_2D_P_1 */
7944 { "vcvtss2siY", { Gv
, EXd
} },
7945 { "(bad)", { XX
} },
7948 /* VEX_LEN_2D_P_3 */
7950 { "vcvtsd2siY", { Gv
, EXq
} },
7951 { "(bad)", { XX
} },
7954 /* VEX_LEN_2E_P_0 */
7956 { "vucomiss", { XM
, EXd
} },
7957 { "(bad)", { XX
} },
7960 /* VEX_LEN_2E_P_2 */
7962 { "vucomisd", { XM
, EXq
} },
7963 { "(bad)", { XX
} },
7966 /* VEX_LEN_2F_P_0 */
7968 { "vcomiss", { XM
, EXd
} },
7969 { "(bad)", { XX
} },
7972 /* VEX_LEN_2F_P_2 */
7974 { "vcomisd", { XM
, EXq
} },
7975 { "(bad)", { XX
} },
7978 /* VEX_LEN_51_P_1 */
7980 { "vsqrtss", { XM
, Vex128
, EXd
} },
7981 { "(bad)", { XX
} },
7984 /* VEX_LEN_51_P_3 */
7986 { "vsqrtsd", { XM
, Vex128
, EXq
} },
7987 { "(bad)", { XX
} },
7990 /* VEX_LEN_52_P_1 */
7992 { "vrsqrtss", { XM
, Vex128
, EXd
} },
7993 { "(bad)", { XX
} },
7996 /* VEX_LEN_53_P_1 */
7998 { "vrcpss", { XM
, Vex128
, EXd
} },
7999 { "(bad)", { XX
} },
8002 /* VEX_LEN_58_P_1 */
8004 { "vaddss", { XM
, Vex128
, EXd
} },
8005 { "(bad)", { XX
} },
8008 /* VEX_LEN_58_P_3 */
8010 { "vaddsd", { XM
, Vex128
, EXq
} },
8011 { "(bad)", { XX
} },
8014 /* VEX_LEN_59_P_1 */
8016 { "vmulss", { XM
, Vex128
, EXd
} },
8017 { "(bad)", { XX
} },
8020 /* VEX_LEN_59_P_3 */
8022 { "vmulsd", { XM
, Vex128
, EXq
} },
8023 { "(bad)", { XX
} },
8026 /* VEX_LEN_5A_P_1 */
8028 { "vcvtss2sd", { XM
, Vex128
, EXd
} },
8029 { "(bad)", { XX
} },
8032 /* VEX_LEN_5A_P_3 */
8034 { "vcvtsd2ss", { XM
, Vex128
, EXq
} },
8035 { "(bad)", { XX
} },
8038 /* VEX_LEN_5C_P_1 */
8040 { "vsubss", { XM
, Vex128
, EXd
} },
8041 { "(bad)", { XX
} },
8044 /* VEX_LEN_5C_P_3 */
8046 { "vsubsd", { XM
, Vex128
, EXq
} },
8047 { "(bad)", { XX
} },
8050 /* VEX_LEN_5D_P_1 */
8052 { "vminss", { XM
, Vex128
, EXd
} },
8053 { "(bad)", { XX
} },
8056 /* VEX_LEN_5D_P_3 */
8058 { "vminsd", { XM
, Vex128
, EXq
} },
8059 { "(bad)", { XX
} },
8062 /* VEX_LEN_5E_P_1 */
8064 { "vdivss", { XM
, Vex128
, EXd
} },
8065 { "(bad)", { XX
} },
8068 /* VEX_LEN_5E_P_3 */
8070 { "vdivsd", { XM
, Vex128
, EXq
} },
8071 { "(bad)", { XX
} },
8074 /* VEX_LEN_5F_P_1 */
8076 { "vmaxss", { XM
, Vex128
, EXd
} },
8077 { "(bad)", { XX
} },
8080 /* VEX_LEN_5F_P_3 */
8082 { "vmaxsd", { XM
, Vex128
, EXq
} },
8083 { "(bad)", { XX
} },
8086 /* VEX_LEN_60_P_2 */
8088 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
8089 { "(bad)", { XX
} },
8092 /* VEX_LEN_61_P_2 */
8094 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
8095 { "(bad)", { XX
} },
8098 /* VEX_LEN_62_P_2 */
8100 { "vpunpckldq", { XM
, Vex128
, EXx
} },
8101 { "(bad)", { XX
} },
8104 /* VEX_LEN_63_P_2 */
8106 { "vpacksswb", { XM
, Vex128
, EXx
} },
8107 { "(bad)", { XX
} },
8110 /* VEX_LEN_64_P_2 */
8112 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
8113 { "(bad)", { XX
} },
8116 /* VEX_LEN_65_P_2 */
8118 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
8119 { "(bad)", { XX
} },
8122 /* VEX_LEN_66_P_2 */
8124 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
8125 { "(bad)", { XX
} },
8128 /* VEX_LEN_67_P_2 */
8130 { "vpackuswb", { XM
, Vex128
, EXx
} },
8131 { "(bad)", { XX
} },
8134 /* VEX_LEN_68_P_2 */
8136 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
8137 { "(bad)", { XX
} },
8140 /* VEX_LEN_69_P_2 */
8142 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
8143 { "(bad)", { XX
} },
8146 /* VEX_LEN_6A_P_2 */
8148 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
8149 { "(bad)", { XX
} },
8152 /* VEX_LEN_6B_P_2 */
8154 { "vpackssdw", { XM
, Vex128
, EXx
} },
8155 { "(bad)", { XX
} },
8158 /* VEX_LEN_6C_P_2 */
8160 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
8161 { "(bad)", { XX
} },
8164 /* VEX_LEN_6D_P_2 */
8166 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
8167 { "(bad)", { XX
} },
8170 /* VEX_LEN_6E_P_2 */
8172 { "vmovK", { XM
, Edq
} },
8173 { "(bad)", { XX
} },
8176 /* VEX_LEN_70_P_1 */
8178 { "vpshufhw", { XM
, EXx
, Ib
} },
8179 { "(bad)", { XX
} },
8182 /* VEX_LEN_70_P_2 */
8184 { "vpshufd", { XM
, EXx
, Ib
} },
8185 { "(bad)", { XX
} },
8188 /* VEX_LEN_70_P_3 */
8190 { "vpshuflw", { XM
, EXx
, Ib
} },
8191 { "(bad)", { XX
} },
8194 /* VEX_LEN_71_R_2_P_2 */
8196 { "vpsrlw", { Vex128
, XS
, Ib
} },
8197 { "(bad)", { XX
} },
8200 /* VEX_LEN_71_R_4_P_2 */
8202 { "vpsraw", { Vex128
, XS
, Ib
} },
8203 { "(bad)", { XX
} },
8206 /* VEX_LEN_71_R_6_P_2 */
8208 { "vpsllw", { Vex128
, XS
, Ib
} },
8209 { "(bad)", { XX
} },
8212 /* VEX_LEN_72_R_2_P_2 */
8214 { "vpsrld", { Vex128
, XS
, Ib
} },
8215 { "(bad)", { XX
} },
8218 /* VEX_LEN_72_R_4_P_2 */
8220 { "vpsrad", { Vex128
, XS
, Ib
} },
8221 { "(bad)", { XX
} },
8224 /* VEX_LEN_72_R_6_P_2 */
8226 { "vpslld", { Vex128
, XS
, Ib
} },
8227 { "(bad)", { XX
} },
8230 /* VEX_LEN_73_R_2_P_2 */
8232 { "vpsrlq", { Vex128
, XS
, Ib
} },
8233 { "(bad)", { XX
} },
8236 /* VEX_LEN_73_R_3_P_2 */
8238 { "vpsrldq", { Vex128
, XS
, Ib
} },
8239 { "(bad)", { XX
} },
8242 /* VEX_LEN_73_R_6_P_2 */
8244 { "vpsllq", { Vex128
, XS
, Ib
} },
8245 { "(bad)", { XX
} },
8248 /* VEX_LEN_73_R_7_P_2 */
8250 { "vpslldq", { Vex128
, XS
, Ib
} },
8251 { "(bad)", { XX
} },
8254 /* VEX_LEN_74_P_2 */
8256 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
8257 { "(bad)", { XX
} },
8260 /* VEX_LEN_75_P_2 */
8262 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
8263 { "(bad)", { XX
} },
8266 /* VEX_LEN_76_P_2 */
8268 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
8269 { "(bad)", { XX
} },
8272 /* VEX_LEN_7E_P_1 */
8274 { "vmovq", { XM
, EXq
} },
8275 { "(bad)", { XX
} },
8278 /* VEX_LEN_7E_P_2 */
8280 { "vmovK", { Edq
, XM
} },
8281 { "(bad)", { XX
} },
8284 /* VEX_LEN_AE_R_2_M_0 */
8286 { "vldmxcsr", { Md
} },
8287 { "(bad)", { XX
} },
8290 /* VEX_LEN_AE_R_3_M_0 */
8292 { "vstmxcsr", { Md
} },
8293 { "(bad)", { XX
} },
8296 /* VEX_LEN_C2_P_1 */
8298 { "vcmpss", { XM
, Vex128
, EXd
, VCMP
} },
8299 { "(bad)", { XX
} },
8302 /* VEX_LEN_C2_P_3 */
8304 { "vcmpsd", { XM
, Vex128
, EXq
, VCMP
} },
8305 { "(bad)", { XX
} },
8308 /* VEX_LEN_C4_P_2 */
8310 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
8311 { "(bad)", { XX
} },
8314 /* VEX_LEN_C5_P_2 */
8316 { "vpextrw", { Gdq
, XS
, Ib
} },
8317 { "(bad)", { XX
} },
8320 /* VEX_LEN_D1_P_2 */
8322 { "vpsrlw", { XM
, Vex128
, EXx
} },
8323 { "(bad)", { XX
} },
8326 /* VEX_LEN_D2_P_2 */
8328 { "vpsrld", { XM
, Vex128
, EXx
} },
8329 { "(bad)", { XX
} },
8332 /* VEX_LEN_D3_P_2 */
8334 { "vpsrlq", { XM
, Vex128
, EXx
} },
8335 { "(bad)", { XX
} },
8338 /* VEX_LEN_D4_P_2 */
8340 { "vpaddq", { XM
, Vex128
, EXx
} },
8341 { "(bad)", { XX
} },
8344 /* VEX_LEN_D5_P_2 */
8346 { "vpmullw", { XM
, Vex128
, EXx
} },
8347 { "(bad)", { XX
} },
8350 /* VEX_LEN_D6_P_2 */
8352 { "vmovq", { EXqS
, XM
} },
8353 { "(bad)", { XX
} },
8356 /* VEX_LEN_D7_P_2_M_1 */
8358 { "vpmovmskb", { Gdq
, XS
} },
8359 { "(bad)", { XX
} },
8362 /* VEX_LEN_D8_P_2 */
8364 { "vpsubusb", { XM
, Vex128
, EXx
} },
8365 { "(bad)", { XX
} },
8368 /* VEX_LEN_D9_P_2 */
8370 { "vpsubusw", { XM
, Vex128
, EXx
} },
8371 { "(bad)", { XX
} },
8374 /* VEX_LEN_DA_P_2 */
8376 { "vpminub", { XM
, Vex128
, EXx
} },
8377 { "(bad)", { XX
} },
8380 /* VEX_LEN_DB_P_2 */
8382 { "vpand", { XM
, Vex128
, EXx
} },
8383 { "(bad)", { XX
} },
8386 /* VEX_LEN_DC_P_2 */
8388 { "vpaddusb", { XM
, Vex128
, EXx
} },
8389 { "(bad)", { XX
} },
8392 /* VEX_LEN_DD_P_2 */
8394 { "vpaddusw", { XM
, Vex128
, EXx
} },
8395 { "(bad)", { XX
} },
8398 /* VEX_LEN_DE_P_2 */
8400 { "vpmaxub", { XM
, Vex128
, EXx
} },
8401 { "(bad)", { XX
} },
8404 /* VEX_LEN_DF_P_2 */
8406 { "vpandn", { XM
, Vex128
, EXx
} },
8407 { "(bad)", { XX
} },
8410 /* VEX_LEN_E0_P_2 */
8412 { "vpavgb", { XM
, Vex128
, EXx
} },
8413 { "(bad)", { XX
} },
8416 /* VEX_LEN_E1_P_2 */
8418 { "vpsraw", { XM
, Vex128
, EXx
} },
8419 { "(bad)", { XX
} },
8422 /* VEX_LEN_E2_P_2 */
8424 { "vpsrad", { XM
, Vex128
, EXx
} },
8425 { "(bad)", { XX
} },
8428 /* VEX_LEN_E3_P_2 */
8430 { "vpavgw", { XM
, Vex128
, EXx
} },
8431 { "(bad)", { XX
} },
8434 /* VEX_LEN_E4_P_2 */
8436 { "vpmulhuw", { XM
, Vex128
, EXx
} },
8437 { "(bad)", { XX
} },
8440 /* VEX_LEN_E5_P_2 */
8442 { "vpmulhw", { XM
, Vex128
, EXx
} },
8443 { "(bad)", { XX
} },
8446 /* VEX_LEN_E8_P_2 */
8448 { "vpsubsb", { XM
, Vex128
, EXx
} },
8449 { "(bad)", { XX
} },
8452 /* VEX_LEN_E9_P_2 */
8454 { "vpsubsw", { XM
, Vex128
, EXx
} },
8455 { "(bad)", { XX
} },
8458 /* VEX_LEN_EA_P_2 */
8460 { "vpminsw", { XM
, Vex128
, EXx
} },
8461 { "(bad)", { XX
} },
8464 /* VEX_LEN_EB_P_2 */
8466 { "vpor", { XM
, Vex128
, EXx
} },
8467 { "(bad)", { XX
} },
8470 /* VEX_LEN_EC_P_2 */
8472 { "vpaddsb", { XM
, Vex128
, EXx
} },
8473 { "(bad)", { XX
} },
8476 /* VEX_LEN_ED_P_2 */
8478 { "vpaddsw", { XM
, Vex128
, EXx
} },
8479 { "(bad)", { XX
} },
8482 /* VEX_LEN_EE_P_2 */
8484 { "vpmaxsw", { XM
, Vex128
, EXx
} },
8485 { "(bad)", { XX
} },
8488 /* VEX_LEN_EF_P_2 */
8490 { "vpxor", { XM
, Vex128
, EXx
} },
8491 { "(bad)", { XX
} },
8494 /* VEX_LEN_F1_P_2 */
8496 { "vpsllw", { XM
, Vex128
, EXx
} },
8497 { "(bad)", { XX
} },
8500 /* VEX_LEN_F2_P_2 */
8502 { "vpslld", { XM
, Vex128
, EXx
} },
8503 { "(bad)", { XX
} },
8506 /* VEX_LEN_F3_P_2 */
8508 { "vpsllq", { XM
, Vex128
, EXx
} },
8509 { "(bad)", { XX
} },
8512 /* VEX_LEN_F4_P_2 */
8514 { "vpmuludq", { XM
, Vex128
, EXx
} },
8515 { "(bad)", { XX
} },
8518 /* VEX_LEN_F5_P_2 */
8520 { "vpmaddwd", { XM
, Vex128
, EXx
} },
8521 { "(bad)", { XX
} },
8524 /* VEX_LEN_F6_P_2 */
8526 { "vpsadbw", { XM
, Vex128
, EXx
} },
8527 { "(bad)", { XX
} },
8530 /* VEX_LEN_F7_P_2 */
8532 { "vmaskmovdqu", { XM
, XS
} },
8533 { "(bad)", { XX
} },
8536 /* VEX_LEN_F8_P_2 */
8538 { "vpsubb", { XM
, Vex128
, EXx
} },
8539 { "(bad)", { XX
} },
8542 /* VEX_LEN_F9_P_2 */
8544 { "vpsubw", { XM
, Vex128
, EXx
} },
8545 { "(bad)", { XX
} },
8548 /* VEX_LEN_FA_P_2 */
8550 { "vpsubd", { XM
, Vex128
, EXx
} },
8551 { "(bad)", { XX
} },
8554 /* VEX_LEN_FB_P_2 */
8556 { "vpsubq", { XM
, Vex128
, EXx
} },
8557 { "(bad)", { XX
} },
8560 /* VEX_LEN_FC_P_2 */
8562 { "vpaddb", { XM
, Vex128
, EXx
} },
8563 { "(bad)", { XX
} },
8566 /* VEX_LEN_FD_P_2 */
8568 { "vpaddw", { XM
, Vex128
, EXx
} },
8569 { "(bad)", { XX
} },
8572 /* VEX_LEN_FE_P_2 */
8574 { "vpaddd", { XM
, Vex128
, EXx
} },
8575 { "(bad)", { XX
} },
8578 /* VEX_LEN_3800_P_2 */
8580 { "vpshufb", { XM
, Vex128
, EXx
} },
8581 { "(bad)", { XX
} },
8584 /* VEX_LEN_3801_P_2 */
8586 { "vphaddw", { XM
, Vex128
, EXx
} },
8587 { "(bad)", { XX
} },
8590 /* VEX_LEN_3802_P_2 */
8592 { "vphaddd", { XM
, Vex128
, EXx
} },
8593 { "(bad)", { XX
} },
8596 /* VEX_LEN_3803_P_2 */
8598 { "vphaddsw", { XM
, Vex128
, EXx
} },
8599 { "(bad)", { XX
} },
8602 /* VEX_LEN_3804_P_2 */
8604 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
8605 { "(bad)", { XX
} },
8608 /* VEX_LEN_3805_P_2 */
8610 { "vphsubw", { XM
, Vex128
, EXx
} },
8611 { "(bad)", { XX
} },
8614 /* VEX_LEN_3806_P_2 */
8616 { "vphsubd", { XM
, Vex128
, EXx
} },
8617 { "(bad)", { XX
} },
8620 /* VEX_LEN_3807_P_2 */
8622 { "vphsubsw", { XM
, Vex128
, EXx
} },
8623 { "(bad)", { XX
} },
8626 /* VEX_LEN_3808_P_2 */
8628 { "vpsignb", { XM
, Vex128
, EXx
} },
8629 { "(bad)", { XX
} },
8632 /* VEX_LEN_3809_P_2 */
8634 { "vpsignw", { XM
, Vex128
, EXx
} },
8635 { "(bad)", { XX
} },
8638 /* VEX_LEN_380A_P_2 */
8640 { "vpsignd", { XM
, Vex128
, EXx
} },
8641 { "(bad)", { XX
} },
8644 /* VEX_LEN_380B_P_2 */
8646 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
8647 { "(bad)", { XX
} },
8650 /* VEX_LEN_3819_P_2_M_0 */
8652 { "(bad)", { XX
} },
8653 { "vbroadcastsd", { XM
, Mq
} },
8656 /* VEX_LEN_381A_P_2_M_0 */
8658 { "(bad)", { XX
} },
8659 { "vbroadcastf128", { XM
, Mxmm
} },
8662 /* VEX_LEN_381C_P_2 */
8664 { "vpabsb", { XM
, EXx
} },
8665 { "(bad)", { XX
} },
8668 /* VEX_LEN_381D_P_2 */
8670 { "vpabsw", { XM
, EXx
} },
8671 { "(bad)", { XX
} },
8674 /* VEX_LEN_381E_P_2 */
8676 { "vpabsd", { XM
, EXx
} },
8677 { "(bad)", { XX
} },
8680 /* VEX_LEN_3820_P_2 */
8682 { "vpmovsxbw", { XM
, EXq
} },
8683 { "(bad)", { XX
} },
8686 /* VEX_LEN_3821_P_2 */
8688 { "vpmovsxbd", { XM
, EXd
} },
8689 { "(bad)", { XX
} },
8692 /* VEX_LEN_3822_P_2 */
8694 { "vpmovsxbq", { XM
, EXw
} },
8695 { "(bad)", { XX
} },
8698 /* VEX_LEN_3823_P_2 */
8700 { "vpmovsxwd", { XM
, EXq
} },
8701 { "(bad)", { XX
} },
8704 /* VEX_LEN_3824_P_2 */
8706 { "vpmovsxwq", { XM
, EXd
} },
8707 { "(bad)", { XX
} },
8710 /* VEX_LEN_3825_P_2 */
8712 { "vpmovsxdq", { XM
, EXq
} },
8713 { "(bad)", { XX
} },
8716 /* VEX_LEN_3828_P_2 */
8718 { "vpmuldq", { XM
, Vex128
, EXx
} },
8719 { "(bad)", { XX
} },
8722 /* VEX_LEN_3829_P_2 */
8724 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
8725 { "(bad)", { XX
} },
8728 /* VEX_LEN_382A_P_2_M_0 */
8730 { "vmovntdqa", { XM
, Mx
} },
8731 { "(bad)", { XX
} },
8734 /* VEX_LEN_382B_P_2 */
8736 { "vpackusdw", { XM
, Vex128
, EXx
} },
8737 { "(bad)", { XX
} },
8740 /* VEX_LEN_3830_P_2 */
8742 { "vpmovzxbw", { XM
, EXq
} },
8743 { "(bad)", { XX
} },
8746 /* VEX_LEN_3831_P_2 */
8748 { "vpmovzxbd", { XM
, EXd
} },
8749 { "(bad)", { XX
} },
8752 /* VEX_LEN_3832_P_2 */
8754 { "vpmovzxbq", { XM
, EXw
} },
8755 { "(bad)", { XX
} },
8758 /* VEX_LEN_3833_P_2 */
8760 { "vpmovzxwd", { XM
, EXq
} },
8761 { "(bad)", { XX
} },
8764 /* VEX_LEN_3834_P_2 */
8766 { "vpmovzxwq", { XM
, EXd
} },
8767 { "(bad)", { XX
} },
8770 /* VEX_LEN_3835_P_2 */
8772 { "vpmovzxdq", { XM
, EXq
} },
8773 { "(bad)", { XX
} },
8776 /* VEX_LEN_3837_P_2 */
8778 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
8779 { "(bad)", { XX
} },
8782 /* VEX_LEN_3838_P_2 */
8784 { "vpminsb", { XM
, Vex128
, EXx
} },
8785 { "(bad)", { XX
} },
8788 /* VEX_LEN_3839_P_2 */
8790 { "vpminsd", { XM
, Vex128
, EXx
} },
8791 { "(bad)", { XX
} },
8794 /* VEX_LEN_383A_P_2 */
8796 { "vpminuw", { XM
, Vex128
, EXx
} },
8797 { "(bad)", { XX
} },
8800 /* VEX_LEN_383B_P_2 */
8802 { "vpminud", { XM
, Vex128
, EXx
} },
8803 { "(bad)", { XX
} },
8806 /* VEX_LEN_383C_P_2 */
8808 { "vpmaxsb", { XM
, Vex128
, EXx
} },
8809 { "(bad)", { XX
} },
8812 /* VEX_LEN_383D_P_2 */
8814 { "vpmaxsd", { XM
, Vex128
, EXx
} },
8815 { "(bad)", { XX
} },
8818 /* VEX_LEN_383E_P_2 */
8820 { "vpmaxuw", { XM
, Vex128
, EXx
} },
8821 { "(bad)", { XX
} },
8824 /* VEX_LEN_383F_P_2 */
8826 { "vpmaxud", { XM
, Vex128
, EXx
} },
8827 { "(bad)", { XX
} },
8830 /* VEX_LEN_3840_P_2 */
8832 { "vpmulld", { XM
, Vex128
, EXx
} },
8833 { "(bad)", { XX
} },
8836 /* VEX_LEN_3841_P_2 */
8838 { "vphminposuw", { XM
, EXx
} },
8839 { "(bad)", { XX
} },
8842 /* VEX_LEN_38DB_P_2 */
8844 { "vaesimc", { XM
, EXx
} },
8845 { "(bad)", { XX
} },
8848 /* VEX_LEN_38DC_P_2 */
8850 { "vaesenc", { XM
, Vex128
, EXx
} },
8851 { "(bad)", { XX
} },
8854 /* VEX_LEN_38DD_P_2 */
8856 { "vaesenclast", { XM
, Vex128
, EXx
} },
8857 { "(bad)", { XX
} },
8860 /* VEX_LEN_38DE_P_2 */
8862 { "vaesdec", { XM
, Vex128
, EXx
} },
8863 { "(bad)", { XX
} },
8866 /* VEX_LEN_38DF_P_2 */
8868 { "vaesdeclast", { XM
, Vex128
, EXx
} },
8869 { "(bad)", { XX
} },
8872 /* VEX_LEN_3A06_P_2 */
8874 { "(bad)", { XX
} },
8875 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
8878 /* VEX_LEN_3A0A_P_2 */
8880 { "vroundss", { XM
, Vex128
, EXd
, Ib
} },
8881 { "(bad)", { XX
} },
8884 /* VEX_LEN_3A0B_P_2 */
8886 { "vroundsd", { XM
, Vex128
, EXq
, Ib
} },
8887 { "(bad)", { XX
} },
8890 /* VEX_LEN_3A0E_P_2 */
8892 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
8893 { "(bad)", { XX
} },
8896 /* VEX_LEN_3A0F_P_2 */
8898 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
8899 { "(bad)", { XX
} },
8902 /* VEX_LEN_3A14_P_2 */
8904 { "vpextrb", { Edqb
, XM
, Ib
} },
8905 { "(bad)", { XX
} },
8908 /* VEX_LEN_3A15_P_2 */
8910 { "vpextrw", { Edqw
, XM
, Ib
} },
8911 { "(bad)", { XX
} },
8914 /* VEX_LEN_3A16_P_2 */
8916 { "vpextrK", { Edq
, XM
, Ib
} },
8917 { "(bad)", { XX
} },
8920 /* VEX_LEN_3A17_P_2 */
8922 { "vextractps", { Edqd
, XM
, Ib
} },
8923 { "(bad)", { XX
} },
8926 /* VEX_LEN_3A18_P_2 */
8928 { "(bad)", { XX
} },
8929 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
8932 /* VEX_LEN_3A19_P_2 */
8934 { "(bad)", { XX
} },
8935 { "vextractf128", { EXxmm
, XM
, Ib
} },
8938 /* VEX_LEN_3A20_P_2 */
8940 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
8941 { "(bad)", { XX
} },
8944 /* VEX_LEN_3A21_P_2 */
8946 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
8947 { "(bad)", { XX
} },
8950 /* VEX_LEN_3A22_P_2 */
8952 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
8953 { "(bad)", { XX
} },
8956 /* VEX_LEN_3A41_P_2 */
8958 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
8959 { "(bad)", { XX
} },
8962 /* VEX_LEN_3A42_P_2 */
8964 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
8965 { "(bad)", { XX
} },
8968 /* VEX_LEN_3A44_P_2 */
8970 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
8971 { "(bad)", { XX
} },
8974 /* VEX_LEN_3A4C_P_2 */
8976 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
8977 { "(bad)", { XX
} },
8980 /* VEX_LEN_3A60_P_2 */
8982 { "vpcmpestrm", { XM
, EXx
, Ib
} },
8983 { "(bad)", { XX
} },
8986 /* VEX_LEN_3A61_P_2 */
8988 { "vpcmpestri", { XM
, EXx
, Ib
} },
8989 { "(bad)", { XX
} },
8992 /* VEX_LEN_3A62_P_2 */
8994 { "vpcmpistrm", { XM
, EXx
, Ib
} },
8995 { "(bad)", { XX
} },
8998 /* VEX_LEN_3A63_P_2 */
9000 { "vpcmpistri", { XM
, EXx
, Ib
} },
9001 { "(bad)", { XX
} },
9004 /* VEX_LEN_3A6A_P_2 */
9006 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9007 { "(bad)", { XX
} },
9010 /* VEX_LEN_3A6B_P_2 */
9012 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9013 { "(bad)", { XX
} },
9016 /* VEX_LEN_3A6E_P_2 */
9018 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9019 { "(bad)", { XX
} },
9022 /* VEX_LEN_3A6F_P_2 */
9024 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9025 { "(bad)", { XX
} },
9028 /* VEX_LEN_3A7A_P_2 */
9030 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9031 { "(bad)", { XX
} },
9034 /* VEX_LEN_3A7B_P_2 */
9036 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9037 { "(bad)", { XX
} },
9040 /* VEX_LEN_3A7E_P_2 */
9042 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9043 { "(bad)", { XX
} },
9046 /* VEX_LEN_3A7F_P_2 */
9048 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9049 { "(bad)", { XX
} },
9052 /* VEX_LEN_3ADF_P_2 */
9054 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
9055 { "(bad)", { XX
} },
9059 static const struct dis386 mod_table
[][2] = {
9062 { "leaS", { Gv
, M
} },
9063 { "(bad)", { XX
} },
9066 /* MOD_0F01_REG_0 */
9067 { X86_64_TABLE (X86_64_0F01_REG_0
) },
9068 { RM_TABLE (RM_0F01_REG_0
) },
9071 /* MOD_0F01_REG_1 */
9072 { X86_64_TABLE (X86_64_0F01_REG_1
) },
9073 { RM_TABLE (RM_0F01_REG_1
) },
9076 /* MOD_0F01_REG_2 */
9077 { X86_64_TABLE (X86_64_0F01_REG_2
) },
9078 { RM_TABLE (RM_0F01_REG_2
) },
9081 /* MOD_0F01_REG_3 */
9082 { X86_64_TABLE (X86_64_0F01_REG_3
) },
9083 { RM_TABLE (RM_0F01_REG_3
) },
9086 /* MOD_0F01_REG_7 */
9087 { "invlpg", { Mb
} },
9088 { RM_TABLE (RM_0F01_REG_7
) },
9091 /* MOD_0F12_PREFIX_0 */
9092 { "movlps", { XM
, EXq
} },
9093 { "movhlps", { XM
, EXq
} },
9097 { "movlpX", { EXq
, XM
} },
9098 { "(bad)", { XX
} },
9101 /* MOD_0F16_PREFIX_0 */
9102 { "movhps", { XM
, EXq
} },
9103 { "movlhps", { XM
, EXq
} },
9107 { "movhpX", { EXq
, XM
} },
9108 { "(bad)", { XX
} },
9111 /* MOD_0F18_REG_0 */
9112 { "prefetchnta", { Mb
} },
9113 { "(bad)", { XX
} },
9116 /* MOD_0F18_REG_1 */
9117 { "prefetcht0", { Mb
} },
9118 { "(bad)", { XX
} },
9121 /* MOD_0F18_REG_2 */
9122 { "prefetcht1", { Mb
} },
9123 { "(bad)", { XX
} },
9126 /* MOD_0F18_REG_3 */
9127 { "prefetcht2", { Mb
} },
9128 { "(bad)", { XX
} },
9132 { "(bad)", { XX
} },
9133 { "movZ", { Rm
, Cm
} },
9137 { "(bad)", { XX
} },
9138 { "movZ", { Rm
, Dm
} },
9142 { "(bad)", { XX
} },
9143 { "movZ", { Cm
, Rm
} },
9147 { "(bad)", { XX
} },
9148 { "movZ", { Dm
, Rm
} },
9152 { "(bad)", { XX
} },
9153 { "movL", { Rd
, Td
} },
9157 { "(bad)", { XX
} },
9158 { "movL", { Td
, Rd
} },
9161 /* MOD_0F2B_PREFIX_0 */
9162 {"movntps", { Mx
, XM
} },
9163 { "(bad)", { XX
} },
9166 /* MOD_0F2B_PREFIX_1 */
9167 {"movntss", { Md
, XM
} },
9168 { "(bad)", { XX
} },
9171 /* MOD_0F2B_PREFIX_2 */
9172 {"movntpd", { Mx
, XM
} },
9173 { "(bad)", { XX
} },
9176 /* MOD_0F2B_PREFIX_3 */
9177 {"movntsd", { Mq
, XM
} },
9178 { "(bad)", { XX
} },
9182 { "(bad)", { XX
} },
9183 { "movmskpX", { Gdq
, XS
} },
9186 /* MOD_0F71_REG_2 */
9187 { "(bad)", { XX
} },
9188 { "psrlw", { MS
, Ib
} },
9191 /* MOD_0F71_REG_4 */
9192 { "(bad)", { XX
} },
9193 { "psraw", { MS
, Ib
} },
9196 /* MOD_0F71_REG_6 */
9197 { "(bad)", { XX
} },
9198 { "psllw", { MS
, Ib
} },
9201 /* MOD_0F72_REG_2 */
9202 { "(bad)", { XX
} },
9203 { "psrld", { MS
, Ib
} },
9206 /* MOD_0F72_REG_4 */
9207 { "(bad)", { XX
} },
9208 { "psrad", { MS
, Ib
} },
9211 /* MOD_0F72_REG_6 */
9212 { "(bad)", { XX
} },
9213 { "pslld", { MS
, Ib
} },
9216 /* MOD_0F73_REG_2 */
9217 { "(bad)", { XX
} },
9218 { "psrlq", { MS
, Ib
} },
9221 /* MOD_0F73_REG_3 */
9222 { "(bad)", { XX
} },
9223 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
9226 /* MOD_0F73_REG_6 */
9227 { "(bad)", { XX
} },
9228 { "psllq", { MS
, Ib
} },
9231 /* MOD_0F73_REG_7 */
9232 { "(bad)", { XX
} },
9233 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
9236 /* MOD_0FAE_REG_0 */
9237 { "fxsave", { M
} },
9238 { "(bad)", { XX
} },
9241 /* MOD_0FAE_REG_1 */
9242 { "fxrstor", { M
} },
9243 { "(bad)", { XX
} },
9246 /* MOD_0FAE_REG_2 */
9247 { "ldmxcsr", { Md
} },
9248 { "(bad)", { XX
} },
9251 /* MOD_0FAE_REG_3 */
9252 { "stmxcsr", { Md
} },
9253 { "(bad)", { XX
} },
9256 /* MOD_0FAE_REG_4 */
9258 { "(bad)", { XX
} },
9261 /* MOD_0FAE_REG_5 */
9262 { "xrstor", { M
} },
9263 { RM_TABLE (RM_0FAE_REG_5
) },
9266 /* MOD_0FAE_REG_6 */
9267 { "xsaveopt", { M
} },
9268 { RM_TABLE (RM_0FAE_REG_6
) },
9271 /* MOD_0FAE_REG_7 */
9272 { "clflush", { Mb
} },
9273 { RM_TABLE (RM_0FAE_REG_7
) },
9277 { "lssS", { Gv
, Mp
} },
9278 { "(bad)", { XX
} },
9282 { "lfsS", { Gv
, Mp
} },
9283 { "(bad)", { XX
} },
9287 { "lgsS", { Gv
, Mp
} },
9288 { "(bad)", { XX
} },
9291 /* MOD_0FC7_REG_6 */
9292 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
9293 { "(bad)", { XX
} },
9296 /* MOD_0FC7_REG_7 */
9297 { "vmptrst", { Mq
} },
9298 { "(bad)", { XX
} },
9302 { "(bad)", { XX
} },
9303 { "pmovmskb", { Gdq
, MS
} },
9306 /* MOD_0FE7_PREFIX_2 */
9307 { "movntdq", { Mx
, XM
} },
9308 { "(bad)", { XX
} },
9311 /* MOD_0FF0_PREFIX_3 */
9312 { "lddqu", { XM
, M
} },
9313 { "(bad)", { XX
} },
9316 /* MOD_0F382A_PREFIX_2 */
9317 { "movntdqa", { XM
, Mx
} },
9318 { "(bad)", { XX
} },
9322 { "bound{S|}", { Gv
, Ma
} },
9323 { "(bad)", { XX
} },
9327 { "lesS", { Gv
, Mp
} },
9328 { VEX_C4_TABLE (VEX_0F
) },
9332 { "ldsS", { Gv
, Mp
} },
9333 { VEX_C5_TABLE (VEX_0F
) },
9336 /* MOD_VEX_12_PREFIX_0 */
9337 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
9338 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
9342 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
9343 { "(bad)", { XX
} },
9346 /* MOD_VEX_16_PREFIX_0 */
9347 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
9348 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
9352 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
9353 { "(bad)", { XX
} },
9357 { "vmovntpX", { Mx
, XM
} },
9358 { "(bad)", { XX
} },
9362 { "(bad)", { XX
} },
9363 { "vmovmskpX", { Gdq
, XS
} },
9366 /* MOD_VEX_71_REG_2 */
9367 { "(bad)", { XX
} },
9368 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
9371 /* MOD_VEX_71_REG_4 */
9372 { "(bad)", { XX
} },
9373 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
9376 /* MOD_VEX_71_REG_6 */
9377 { "(bad)", { XX
} },
9378 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
9381 /* MOD_VEX_72_REG_2 */
9382 { "(bad)", { XX
} },
9383 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
9386 /* MOD_VEX_72_REG_4 */
9387 { "(bad)", { XX
} },
9388 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
9391 /* MOD_VEX_72_REG_6 */
9392 { "(bad)", { XX
} },
9393 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
9396 /* MOD_VEX_73_REG_2 */
9397 { "(bad)", { XX
} },
9398 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
9401 /* MOD_VEX_73_REG_3 */
9402 { "(bad)", { XX
} },
9403 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
9406 /* MOD_VEX_73_REG_6 */
9407 { "(bad)", { XX
} },
9408 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
9411 /* MOD_VEX_73_REG_7 */
9412 { "(bad)", { XX
} },
9413 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
9416 /* MOD_VEX_AE_REG_2 */
9417 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
9418 { "(bad)", { XX
} },
9421 /* MOD_VEX_AE_REG_3 */
9422 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
9423 { "(bad)", { XX
} },
9426 /* MOD_VEX_D7_PREFIX_2 */
9427 { "(bad)", { XX
} },
9428 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
9431 /* MOD_VEX_E7_PREFIX_2 */
9432 { "vmovntdq", { Mx
, XM
} },
9433 { "(bad)", { XX
} },
9436 /* MOD_VEX_F0_PREFIX_3 */
9437 { "vlddqu", { XM
, M
} },
9438 { "(bad)", { XX
} },
9441 /* MOD_VEX_3818_PREFIX_2 */
9442 { "vbroadcastss", { XM
, Md
} },
9443 { "(bad)", { XX
} },
9446 /* MOD_VEX_3819_PREFIX_2 */
9447 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
9448 { "(bad)", { XX
} },
9451 /* MOD_VEX_381A_PREFIX_2 */
9452 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
9453 { "(bad)", { XX
} },
9456 /* MOD_VEX_382A_PREFIX_2 */
9457 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
9458 { "(bad)", { XX
} },
9461 /* MOD_VEX_382C_PREFIX_2 */
9462 { "vmaskmovps", { XM
, Vex
, Mx
} },
9463 { "(bad)", { XX
} },
9466 /* MOD_VEX_382D_PREFIX_2 */
9467 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9468 { "(bad)", { XX
} },
9471 /* MOD_VEX_382E_PREFIX_2 */
9472 { "vmaskmovps", { Mx
, Vex
, XM
} },
9473 { "(bad)", { XX
} },
9476 /* MOD_VEX_382F_PREFIX_2 */
9477 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9478 { "(bad)", { XX
} },
9482 static const struct dis386 rm_table
[][8] = {
9485 { "(bad)", { XX
} },
9486 { "vmcall", { Skip_MODRM
} },
9487 { "vmlaunch", { Skip_MODRM
} },
9488 { "vmresume", { Skip_MODRM
} },
9489 { "vmxoff", { Skip_MODRM
} },
9490 { "(bad)", { XX
} },
9491 { "(bad)", { XX
} },
9492 { "(bad)", { XX
} },
9496 { "monitor", { { OP_Monitor
, 0 } } },
9497 { "mwait", { { OP_Mwait
, 0 } } },
9498 { "(bad)", { XX
} },
9499 { "(bad)", { XX
} },
9500 { "(bad)", { XX
} },
9501 { "(bad)", { XX
} },
9502 { "(bad)", { XX
} },
9503 { "(bad)", { XX
} },
9507 { "xgetbv", { Skip_MODRM
} },
9508 { "xsetbv", { Skip_MODRM
} },
9509 { "(bad)", { XX
} },
9510 { "(bad)", { XX
} },
9511 { "(bad)", { XX
} },
9512 { "(bad)", { XX
} },
9513 { "(bad)", { XX
} },
9514 { "(bad)", { XX
} },
9518 { "vmrun", { Skip_MODRM
} },
9519 { "vmmcall", { Skip_MODRM
} },
9520 { "vmload", { Skip_MODRM
} },
9521 { "vmsave", { Skip_MODRM
} },
9522 { "stgi", { Skip_MODRM
} },
9523 { "clgi", { Skip_MODRM
} },
9524 { "skinit", { Skip_MODRM
} },
9525 { "invlpga", { Skip_MODRM
} },
9529 { "swapgs", { Skip_MODRM
} },
9530 { "rdtscp", { Skip_MODRM
} },
9531 { "(bad)", { XX
} },
9532 { "(bad)", { XX
} },
9533 { "(bad)", { XX
} },
9534 { "(bad)", { XX
} },
9535 { "(bad)", { XX
} },
9536 { "(bad)", { XX
} },
9540 { "lfence", { Skip_MODRM
} },
9541 { "(bad)", { XX
} },
9542 { "(bad)", { XX
} },
9543 { "(bad)", { XX
} },
9544 { "(bad)", { XX
} },
9545 { "(bad)", { XX
} },
9546 { "(bad)", { XX
} },
9547 { "(bad)", { XX
} },
9551 { "mfence", { Skip_MODRM
} },
9552 { "(bad)", { XX
} },
9553 { "(bad)", { XX
} },
9554 { "(bad)", { XX
} },
9555 { "(bad)", { XX
} },
9556 { "(bad)", { XX
} },
9557 { "(bad)", { XX
} },
9558 { "(bad)", { XX
} },
9562 { "sfence", { Skip_MODRM
} },
9563 { "(bad)", { XX
} },
9564 { "(bad)", { XX
} },
9565 { "(bad)", { XX
} },
9566 { "(bad)", { XX
} },
9567 { "(bad)", { XX
} },
9568 { "(bad)", { XX
} },
9569 { "(bad)", { XX
} },
9573 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9575 /* We use the high bit to indicate different name for the same
9577 #define ADDR16_PREFIX (0x67 | 0x100)
9578 #define ADDR32_PREFIX (0x67 | 0x200)
9579 #define DATA16_PREFIX (0x66 | 0x100)
9580 #define DATA32_PREFIX (0x66 | 0x200)
9581 #define REP_PREFIX (0xf3 | 0x100)
9586 int newrex
, i
, length
;
9593 last_lock_prefix
= -1;
9594 last_repz_prefix
= -1;
9595 last_repnz_prefix
= -1;
9596 last_data_prefix
= -1;
9597 last_addr_prefix
= -1;
9598 last_rex_prefix
= -1;
9599 last_seg_prefix
= -1;
9600 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
9601 all_prefixes
[i
] = 0;
9604 /* The maximum instruction length is 15bytes. */
9605 while (length
< MAX_CODE_LENGTH
- 1)
9607 FETCH_DATA (the_info
, codep
+ 1);
9611 /* REX prefixes family. */
9628 if (address_mode
== mode_64bit
)
9632 last_rex_prefix
= i
;
9635 prefixes
|= PREFIX_REPZ
;
9636 last_repz_prefix
= i
;
9639 prefixes
|= PREFIX_REPNZ
;
9640 last_repnz_prefix
= i
;
9643 prefixes
|= PREFIX_LOCK
;
9644 last_lock_prefix
= i
;
9647 prefixes
|= PREFIX_CS
;
9648 last_seg_prefix
= i
;
9651 prefixes
|= PREFIX_SS
;
9652 last_seg_prefix
= i
;
9655 prefixes
|= PREFIX_DS
;
9656 last_seg_prefix
= i
;
9659 prefixes
|= PREFIX_ES
;
9660 last_seg_prefix
= i
;
9663 prefixes
|= PREFIX_FS
;
9664 last_seg_prefix
= i
;
9667 prefixes
|= PREFIX_GS
;
9668 last_seg_prefix
= i
;
9671 prefixes
|= PREFIX_DATA
;
9672 last_data_prefix
= i
;
9675 prefixes
|= PREFIX_ADDR
;
9676 last_addr_prefix
= i
;
9679 /* fwait is really an instruction. If there are prefixes
9680 before the fwait, they belong to the fwait, *not* to the
9681 following instruction. */
9682 if (prefixes
|| rex
)
9684 prefixes
|= PREFIX_FWAIT
;
9688 prefixes
= PREFIX_FWAIT
;
9693 /* Rex is ignored when followed by another prefix. */
9699 if (*codep
!= FWAIT_OPCODE
)
9700 all_prefixes
[i
++] = *codep
;
9710 seg_prefix (int pref
)
9731 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
9735 prefix_name (int pref
, int sizeflag
)
9737 static const char *rexes
[16] =
9742 "rex.XB", /* 0x43 */
9744 "rex.RB", /* 0x45 */
9745 "rex.RX", /* 0x46 */
9746 "rex.RXB", /* 0x47 */
9748 "rex.WB", /* 0x49 */
9749 "rex.WX", /* 0x4a */
9750 "rex.WXB", /* 0x4b */
9751 "rex.WR", /* 0x4c */
9752 "rex.WRB", /* 0x4d */
9753 "rex.WRX", /* 0x4e */
9754 "rex.WRXB", /* 0x4f */
9759 /* REX prefixes family. */
9776 return rexes
[pref
- 0x40];
9796 return (sizeflag
& DFLAG
) ? "data16" : "data32";
9798 if (address_mode
== mode_64bit
)
9799 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
9801 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
9819 static char op_out
[MAX_OPERANDS
][100];
9820 static int op_ad
, op_index
[MAX_OPERANDS
];
9821 static int two_source_ops
;
9822 static bfd_vma op_address
[MAX_OPERANDS
];
9823 static bfd_vma op_riprel
[MAX_OPERANDS
];
9824 static bfd_vma start_pc
;
9827 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
9828 * (see topic "Redundant prefixes" in the "Differences from 8086"
9829 * section of the "Virtual 8086 Mode" chapter.)
9830 * 'pc' should be the address of this instruction, it will
9831 * be used to print the target address if this is a relative jump or call
9832 * The function returns the length of this instruction in bytes.
9835 static char intel_syntax
;
9836 static char intel_mnemonic
= !SYSV386_COMPAT
;
9837 static char open_char
;
9838 static char close_char
;
9839 static char separator_char
;
9840 static char scale_char
;
9842 /* Here for backwards compatibility. When gdb stops using
9843 print_insn_i386_att and print_insn_i386_intel these functions can
9844 disappear, and print_insn_i386 be merged into print_insn. */
9846 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
9850 return print_insn (pc
, info
);
9854 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
9858 return print_insn (pc
, info
);
9862 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
9866 return print_insn (pc
, info
);
9870 print_i386_disassembler_options (FILE *stream
)
9872 fprintf (stream
, _("\n\
9873 The following i386/x86-64 specific disassembler options are supported for use\n\
9874 with the -M switch (multiple options should be separated by commas):\n"));
9876 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
9877 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
9878 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
9879 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
9880 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
9881 fprintf (stream
, _(" att-mnemonic\n"
9882 " Display instruction in AT&T mnemonic\n"));
9883 fprintf (stream
, _(" intel-mnemonic\n"
9884 " Display instruction in Intel mnemonic\n"));
9885 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
9886 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
9887 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
9888 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
9889 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
9890 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
9893 /* Get a pointer to struct dis386 with a valid name. */
9895 static const struct dis386
*
9896 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
9898 int index
, vex_table_index
;
9900 if (dp
->name
!= NULL
)
9903 switch (dp
->op
[0].bytemode
)
9906 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
9910 index
= modrm
.mod
== 0x3 ? 1 : 0;
9911 dp
= &mod_table
[dp
->op
[1].bytemode
][index
];
9915 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
9918 case USE_PREFIX_TABLE
:
9921 /* The prefix in VEX is implicit. */
9927 case REPE_PREFIX_OPCODE
:
9930 case DATA_PREFIX_OPCODE
:
9933 case REPNE_PREFIX_OPCODE
:
9944 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
9945 if (prefixes
& PREFIX_REPZ
)
9948 all_prefixes
[last_repz_prefix
] = 0;
9952 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
9954 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
9955 if (prefixes
& PREFIX_REPNZ
)
9958 all_prefixes
[last_repnz_prefix
] = 0;
9962 used_prefixes
|= (prefixes
& PREFIX_DATA
);
9963 if (prefixes
& PREFIX_DATA
)
9966 all_prefixes
[last_data_prefix
] = 0;
9971 dp
= &prefix_table
[dp
->op
[1].bytemode
][index
];
9974 case USE_X86_64_TABLE
:
9975 index
= address_mode
== mode_64bit
? 1 : 0;
9976 dp
= &x86_64_table
[dp
->op
[1].bytemode
][index
];
9979 case USE_3BYTE_TABLE
:
9980 FETCH_DATA (info
, codep
+ 2);
9982 dp
= &three_byte_table
[dp
->op
[1].bytemode
][index
];
9983 modrm
.mod
= (*codep
>> 6) & 3;
9984 modrm
.reg
= (*codep
>> 3) & 7;
9985 modrm
.rm
= *codep
& 7;
9988 case USE_VEX_LEN_TABLE
:
10005 dp
= &vex_len_table
[dp
->op
[1].bytemode
][index
];
10008 case USE_XOP_8F_TABLE
:
10009 FETCH_DATA (info
, codep
+ 3);
10010 /* All bits in the REX prefix are ignored. */
10012 rex
= ~(*codep
>> 5) & 0x7;
10014 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10015 switch ((*codep
& 0x1f))
10020 vex_table_index
= XOP_09
;
10023 vex_table_index
= XOP_0A
;
10027 vex
.w
= *codep
& 0x80;
10028 if (vex
.w
&& address_mode
== mode_64bit
)
10031 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10032 if (address_mode
!= mode_64bit
10033 && vex
.register_specifier
> 0x7)
10036 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10037 switch ((*codep
& 0x3))
10043 vex
.prefix
= DATA_PREFIX_OPCODE
;
10046 vex
.prefix
= REPE_PREFIX_OPCODE
;
10049 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10056 dp
= &xop_table
[vex_table_index
][index
];
10058 FETCH_DATA (info
, codep
+ 1);
10059 modrm
.mod
= (*codep
>> 6) & 3;
10060 modrm
.reg
= (*codep
>> 3) & 7;
10061 modrm
.rm
= *codep
& 7;
10064 case USE_VEX_C4_TABLE
:
10065 FETCH_DATA (info
, codep
+ 3);
10066 /* All bits in the REX prefix are ignored. */
10068 rex
= ~(*codep
>> 5) & 0x7;
10069 switch ((*codep
& 0x1f))
10074 vex_table_index
= VEX_0F
;
10077 vex_table_index
= VEX_0F38
;
10080 vex_table_index
= VEX_0F3A
;
10084 vex
.w
= *codep
& 0x80;
10085 if (vex
.w
&& address_mode
== mode_64bit
)
10088 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10089 if (address_mode
!= mode_64bit
10090 && vex
.register_specifier
> 0x7)
10093 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10094 switch ((*codep
& 0x3))
10100 vex
.prefix
= DATA_PREFIX_OPCODE
;
10103 vex
.prefix
= REPE_PREFIX_OPCODE
;
10106 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10113 dp
= &vex_table
[vex_table_index
][index
];
10114 /* There is no MODRM byte for VEX [82|77]. */
10115 if (index
!= 0x77 && index
!= 0x82)
10117 FETCH_DATA (info
, codep
+ 1);
10118 modrm
.mod
= (*codep
>> 6) & 3;
10119 modrm
.reg
= (*codep
>> 3) & 7;
10120 modrm
.rm
= *codep
& 7;
10124 case USE_VEX_C5_TABLE
:
10125 FETCH_DATA (info
, codep
+ 2);
10126 /* All bits in the REX prefix are ignored. */
10128 rex
= (*codep
& 0x80) ? 0 : REX_R
;
10130 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10131 if (address_mode
!= mode_64bit
10132 && vex
.register_specifier
> 0x7)
10135 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10136 switch ((*codep
& 0x3))
10142 vex
.prefix
= DATA_PREFIX_OPCODE
;
10145 vex
.prefix
= REPE_PREFIX_OPCODE
;
10148 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10155 dp
= &vex_table
[dp
->op
[1].bytemode
][index
];
10156 /* There is no MODRM byte for VEX [82|77]. */
10157 if (index
!= 0x77 && index
!= 0x82)
10159 FETCH_DATA (info
, codep
+ 1);
10160 modrm
.mod
= (*codep
>> 6) & 3;
10161 modrm
.reg
= (*codep
>> 3) & 7;
10162 modrm
.rm
= *codep
& 7;
10170 if (dp
->name
!= NULL
)
10173 return get_valid_dis386 (dp
, info
);
10177 print_insn (bfd_vma pc
, disassemble_info
*info
)
10179 const struct dis386
*dp
;
10181 char *op_txt
[MAX_OPERANDS
];
10185 struct dis_private priv
;
10188 int default_prefixes
;
10190 if (info
->mach
== bfd_mach_x86_64_intel_syntax
10191 || info
->mach
== bfd_mach_x86_64
10192 || info
->mach
== bfd_mach_l1om
10193 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10194 address_mode
= mode_64bit
;
10196 address_mode
= mode_32bit
;
10198 if (intel_syntax
== (char) -1)
10199 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
10200 || info
->mach
== bfd_mach_x86_64_intel_syntax
10201 || info
->mach
== bfd_mach_l1om_intel_syntax
);
10203 if (info
->mach
== bfd_mach_i386_i386
10204 || info
->mach
== bfd_mach_x86_64
10205 || info
->mach
== bfd_mach_l1om
10206 || info
->mach
== bfd_mach_i386_i386_intel_syntax
10207 || info
->mach
== bfd_mach_x86_64_intel_syntax
10208 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10209 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10210 else if (info
->mach
== bfd_mach_i386_i8086
)
10211 priv
.orig_sizeflag
= 0;
10215 for (p
= info
->disassembler_options
; p
!= NULL
; )
10217 if (CONST_STRNEQ (p
, "x86-64"))
10219 address_mode
= mode_64bit
;
10220 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10222 else if (CONST_STRNEQ (p
, "i386"))
10224 address_mode
= mode_32bit
;
10225 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10227 else if (CONST_STRNEQ (p
, "i8086"))
10229 address_mode
= mode_16bit
;
10230 priv
.orig_sizeflag
= 0;
10232 else if (CONST_STRNEQ (p
, "intel"))
10235 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
10236 intel_mnemonic
= 1;
10238 else if (CONST_STRNEQ (p
, "att"))
10241 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
10242 intel_mnemonic
= 0;
10244 else if (CONST_STRNEQ (p
, "addr"))
10246 if (address_mode
== mode_64bit
)
10248 if (p
[4] == '3' && p
[5] == '2')
10249 priv
.orig_sizeflag
&= ~AFLAG
;
10250 else if (p
[4] == '6' && p
[5] == '4')
10251 priv
.orig_sizeflag
|= AFLAG
;
10255 if (p
[4] == '1' && p
[5] == '6')
10256 priv
.orig_sizeflag
&= ~AFLAG
;
10257 else if (p
[4] == '3' && p
[5] == '2')
10258 priv
.orig_sizeflag
|= AFLAG
;
10261 else if (CONST_STRNEQ (p
, "data"))
10263 if (p
[4] == '1' && p
[5] == '6')
10264 priv
.orig_sizeflag
&= ~DFLAG
;
10265 else if (p
[4] == '3' && p
[5] == '2')
10266 priv
.orig_sizeflag
|= DFLAG
;
10268 else if (CONST_STRNEQ (p
, "suffix"))
10269 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
10271 p
= strchr (p
, ',');
10278 names64
= intel_names64
;
10279 names32
= intel_names32
;
10280 names16
= intel_names16
;
10281 names8
= intel_names8
;
10282 names8rex
= intel_names8rex
;
10283 names_seg
= intel_names_seg
;
10284 index64
= intel_index64
;
10285 index32
= intel_index32
;
10286 index16
= intel_index16
;
10289 separator_char
= '+';
10294 names64
= att_names64
;
10295 names32
= att_names32
;
10296 names16
= att_names16
;
10297 names8
= att_names8
;
10298 names8rex
= att_names8rex
;
10299 names_seg
= att_names_seg
;
10300 index64
= att_index64
;
10301 index32
= att_index32
;
10302 index16
= att_index16
;
10305 separator_char
= ',';
10309 /* The output looks better if we put 7 bytes on a line, since that
10310 puts most long word instructions on a single line. Use 8 bytes
10312 if (info
->mach
== bfd_mach_l1om
10313 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10314 info
->bytes_per_line
= 8;
10316 info
->bytes_per_line
= 7;
10318 info
->private_data
= &priv
;
10319 priv
.max_fetched
= priv
.the_buffer
;
10320 priv
.insn_start
= pc
;
10323 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10331 start_codep
= priv
.the_buffer
;
10332 codep
= priv
.the_buffer
;
10334 if (setjmp (priv
.bailout
) != 0)
10338 /* Getting here means we tried for data but didn't get it. That
10339 means we have an incomplete instruction of some sort. Just
10340 print the first byte as a prefix or a .byte pseudo-op. */
10341 if (codep
> priv
.the_buffer
)
10343 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
10345 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10348 /* Just print the first byte as a .byte instruction. */
10349 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
10350 (unsigned int) priv
.the_buffer
[0]);
10360 sizeflag
= priv
.orig_sizeflag
;
10362 if (!ckprefix () || rex_used
)
10364 /* Too many prefixes or unused REX prefixes. */
10366 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
10368 (*info
->fprintf_func
) (info
->stream
, "%s",
10369 prefix_name (all_prefixes
[i
], sizeflag
));
10373 insn_codep
= codep
;
10375 FETCH_DATA (info
, codep
+ 1);
10376 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
10378 if (((prefixes
& PREFIX_FWAIT
)
10379 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
10381 (*info
->fprintf_func
) (info
->stream
, "fwait");
10387 if (*codep
== 0x0f)
10389 unsigned char threebyte
;
10390 FETCH_DATA (info
, codep
+ 2);
10391 threebyte
= *++codep
;
10392 dp
= &dis386_twobyte
[threebyte
];
10393 need_modrm
= twobyte_has_modrm
[*codep
];
10398 dp
= &dis386
[*codep
];
10399 need_modrm
= onebyte_has_modrm
[*codep
];
10403 if ((prefixes
& PREFIX_REPZ
))
10404 used_prefixes
|= PREFIX_REPZ
;
10405 if ((prefixes
& PREFIX_REPNZ
))
10406 used_prefixes
|= PREFIX_REPNZ
;
10407 if ((prefixes
& PREFIX_LOCK
))
10408 used_prefixes
|= PREFIX_LOCK
;
10410 default_prefixes
= 0;
10411 if (prefixes
& PREFIX_ADDR
)
10414 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
10416 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
10417 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
10419 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
10420 default_prefixes
|= PREFIX_ADDR
;
10424 if ((prefixes
& PREFIX_DATA
))
10427 if (dp
->op
[2].bytemode
== cond_jump_mode
10428 && dp
->op
[0].bytemode
== v_mode
10431 if (sizeflag
& DFLAG
)
10432 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
10434 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
10435 default_prefixes
|= PREFIX_DATA
;
10437 else if (rex
& REX_W
)
10439 /* REX_W will override PREFIX_DATA. */
10440 default_prefixes
|= PREFIX_DATA
;
10446 FETCH_DATA (info
, codep
+ 1);
10447 modrm
.mod
= (*codep
>> 6) & 3;
10448 modrm
.reg
= (*codep
>> 3) & 7;
10449 modrm
.rm
= *codep
& 7;
10456 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
10458 dofloat (sizeflag
);
10462 dp
= get_valid_dis386 (dp
, info
);
10463 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
10465 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10468 op_ad
= MAX_OPERANDS
- 1 - i
;
10470 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
10475 /* See if any prefixes were not used. If so, print the first one
10476 separately. If we don't do this, we'll wind up printing an
10477 instruction stream which does not precisely correspond to the
10478 bytes we are disassembling. */
10479 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
10481 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10482 if (all_prefixes
[i
])
10485 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
10487 name
= INTERNAL_DISASSEMBLER_ERROR
;
10488 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10493 /* Check if the REX prefix used. */
10494 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
10495 all_prefixes
[last_rex_prefix
] = 0;
10497 /* Check if the SEG prefix used. */
10498 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
10499 | PREFIX_FS
| PREFIX_GS
)) != 0
10501 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
10502 all_prefixes
[last_seg_prefix
] = 0;
10504 /* Check if the ADDR prefix used. */
10505 if ((prefixes
& PREFIX_ADDR
) != 0
10506 && (used_prefixes
& PREFIX_ADDR
) != 0)
10507 all_prefixes
[last_addr_prefix
] = 0;
10509 /* Check if the DATA prefix used. */
10510 if ((prefixes
& PREFIX_DATA
) != 0
10511 && (used_prefixes
& PREFIX_DATA
) != 0)
10512 all_prefixes
[last_data_prefix
] = 0;
10515 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10516 if (all_prefixes
[i
])
10519 name
= prefix_name (all_prefixes
[i
], sizeflag
);
10522 prefix_length
+= strlen (name
) + 1;
10523 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
10526 /* Check maximum code length. */
10527 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
10529 (*info
->fprintf_func
) (info
->stream
, "(bad)");
10530 return MAX_CODE_LENGTH
;
10533 obufp
= mnemonicendp
;
10534 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
10537 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
10539 /* The enter and bound instructions are printed with operands in the same
10540 order as the intel book; everything else is printed in reverse order. */
10541 if (intel_syntax
|| two_source_ops
)
10545 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10546 op_txt
[i
] = op_out
[i
];
10548 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
10550 op_ad
= op_index
[i
];
10551 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
10552 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
10553 riprel
= op_riprel
[i
];
10554 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
10555 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
10560 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10561 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
10565 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10569 (*info
->fprintf_func
) (info
->stream
, ",");
10570 if (op_index
[i
] != -1 && !op_riprel
[i
])
10571 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
10573 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
10577 for (i
= 0; i
< MAX_OPERANDS
; i
++)
10578 if (op_index
[i
] != -1 && op_riprel
[i
])
10580 (*info
->fprintf_func
) (info
->stream
, " # ");
10581 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
10582 + op_address
[op_index
[i
]]), info
);
10585 return codep
- priv
.the_buffer
;
10588 static const char *float_mem
[] = {
10663 static const unsigned char float_mem_mode
[] = {
10738 #define ST { OP_ST, 0 }
10739 #define STi { OP_STi, 0 }
10741 #define FGRPd9_2 NULL, { { NULL, 0 } }
10742 #define FGRPd9_4 NULL, { { NULL, 1 } }
10743 #define FGRPd9_5 NULL, { { NULL, 2 } }
10744 #define FGRPd9_6 NULL, { { NULL, 3 } }
10745 #define FGRPd9_7 NULL, { { NULL, 4 } }
10746 #define FGRPda_5 NULL, { { NULL, 5 } }
10747 #define FGRPdb_4 NULL, { { NULL, 6 } }
10748 #define FGRPde_3 NULL, { { NULL, 7 } }
10749 #define FGRPdf_4 NULL, { { NULL, 8 } }
10751 static const struct dis386 float_reg
[][8] = {
10754 { "fadd", { ST
, STi
} },
10755 { "fmul", { ST
, STi
} },
10756 { "fcom", { STi
} },
10757 { "fcomp", { STi
} },
10758 { "fsub", { ST
, STi
} },
10759 { "fsubr", { ST
, STi
} },
10760 { "fdiv", { ST
, STi
} },
10761 { "fdivr", { ST
, STi
} },
10765 { "fld", { STi
} },
10766 { "fxch", { STi
} },
10768 { "(bad)", { XX
} },
10776 { "fcmovb", { ST
, STi
} },
10777 { "fcmove", { ST
, STi
} },
10778 { "fcmovbe",{ ST
, STi
} },
10779 { "fcmovu", { ST
, STi
} },
10780 { "(bad)", { XX
} },
10782 { "(bad)", { XX
} },
10783 { "(bad)", { XX
} },
10787 { "fcmovnb",{ ST
, STi
} },
10788 { "fcmovne",{ ST
, STi
} },
10789 { "fcmovnbe",{ ST
, STi
} },
10790 { "fcmovnu",{ ST
, STi
} },
10792 { "fucomi", { ST
, STi
} },
10793 { "fcomi", { ST
, STi
} },
10794 { "(bad)", { XX
} },
10798 { "fadd", { STi
, ST
} },
10799 { "fmul", { STi
, ST
} },
10800 { "(bad)", { XX
} },
10801 { "(bad)", { XX
} },
10802 { "fsub!M", { STi
, ST
} },
10803 { "fsubM", { STi
, ST
} },
10804 { "fdiv!M", { STi
, ST
} },
10805 { "fdivM", { STi
, ST
} },
10809 { "ffree", { STi
} },
10810 { "(bad)", { XX
} },
10811 { "fst", { STi
} },
10812 { "fstp", { STi
} },
10813 { "fucom", { STi
} },
10814 { "fucomp", { STi
} },
10815 { "(bad)", { XX
} },
10816 { "(bad)", { XX
} },
10820 { "faddp", { STi
, ST
} },
10821 { "fmulp", { STi
, ST
} },
10822 { "(bad)", { XX
} },
10824 { "fsub!Mp", { STi
, ST
} },
10825 { "fsubMp", { STi
, ST
} },
10826 { "fdiv!Mp", { STi
, ST
} },
10827 { "fdivMp", { STi
, ST
} },
10831 { "ffreep", { STi
} },
10832 { "(bad)", { XX
} },
10833 { "(bad)", { XX
} },
10834 { "(bad)", { XX
} },
10836 { "fucomip", { ST
, STi
} },
10837 { "fcomip", { ST
, STi
} },
10838 { "(bad)", { XX
} },
10842 static char *fgrps
[][8] = {
10845 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10850 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
10855 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
10860 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
10865 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
10870 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10875 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
10876 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
10881 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10886 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10891 swap_operand (void)
10893 mnemonicendp
[0] = '.';
10894 mnemonicendp
[1] = 's';
10899 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
10900 int sizeflag ATTRIBUTE_UNUSED
)
10902 /* Skip mod/rm byte. */
10908 dofloat (int sizeflag
)
10910 const struct dis386
*dp
;
10911 unsigned char floatop
;
10913 floatop
= codep
[-1];
10915 if (modrm
.mod
!= 3)
10917 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
10919 putop (float_mem
[fp_indx
], sizeflag
);
10922 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
10925 /* Skip mod/rm byte. */
10929 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
10930 if (dp
->name
== NULL
)
10932 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
10934 /* Instruction fnstsw is only one with strange arg. */
10935 if (floatop
== 0xdf && codep
[-1] == 0xe0)
10936 strcpy (op_out
[0], names16
[0]);
10940 putop (dp
->name
, sizeflag
);
10945 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
10950 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
10955 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
10957 oappend ("%st" + intel_syntax
);
10961 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
10963 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
10964 oappend (scratchbuf
+ intel_syntax
);
10967 /* Capital letters in template are macros. */
10969 putop (const char *in_template
, int sizeflag
)
10974 unsigned int l
= 0, len
= 1;
10977 #define SAVE_LAST(c) \
10978 if (l < len && l < sizeof (last)) \
10983 for (p
= in_template
; *p
; p
++)
11000 while (*++p
!= '|')
11001 if (*p
== '}' || *p
== '\0')
11004 /* Fall through. */
11009 while (*++p
!= '}')
11020 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11024 if (l
== 0 && len
== 1)
11029 if (sizeflag
& SUFFIX_ALWAYS
)
11042 if (address_mode
== mode_64bit
11043 && !(prefixes
& PREFIX_ADDR
))
11054 if (intel_syntax
&& !alt
)
11056 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
11058 if (sizeflag
& DFLAG
)
11059 *obufp
++ = intel_syntax
? 'd' : 'l';
11061 *obufp
++ = intel_syntax
? 'w' : 's';
11062 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11066 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11069 if (modrm
.mod
== 3)
11075 if (sizeflag
& DFLAG
)
11076 *obufp
++ = intel_syntax
? 'd' : 'l';
11079 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11085 case 'E': /* For jcxz/jecxz */
11086 if (address_mode
== mode_64bit
)
11088 if (sizeflag
& AFLAG
)
11094 if (sizeflag
& AFLAG
)
11096 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11101 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
11103 if (sizeflag
& AFLAG
)
11104 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
11106 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
11107 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11111 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
11113 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11117 if (!(rex
& REX_W
))
11118 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11123 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
11124 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
11126 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
11129 if (prefixes
& PREFIX_DS
)
11150 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
11155 /* Fall through. */
11158 if (l
!= 0 || len
!= 1)
11166 if (sizeflag
& SUFFIX_ALWAYS
)
11170 if (intel_mnemonic
!= cond
)
11174 if ((prefixes
& PREFIX_FWAIT
) == 0)
11177 used_prefixes
|= PREFIX_FWAIT
;
11183 else if (intel_syntax
&& (sizeflag
& DFLAG
))
11187 if (!(rex
& REX_W
))
11188 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11193 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11198 /* Fall through. */
11202 if ((prefixes
& PREFIX_DATA
)
11204 || (sizeflag
& SUFFIX_ALWAYS
))
11211 if (sizeflag
& DFLAG
)
11215 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11222 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11224 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11228 /* Fall through. */
11231 if (l
== 0 && len
== 1)
11234 if (intel_syntax
&& !alt
)
11237 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11243 if (sizeflag
& DFLAG
)
11244 *obufp
++ = intel_syntax
? 'd' : 'l';
11247 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11253 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
11259 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11274 else if (sizeflag
& DFLAG
)
11283 if (intel_syntax
&& !p
[1]
11284 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
11286 if (!(rex
& REX_W
))
11287 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11290 if (l
== 0 && len
== 1)
11294 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11296 if (sizeflag
& SUFFIX_ALWAYS
)
11318 /* Fall through. */
11321 if (l
== 0 && len
== 1)
11326 if (sizeflag
& SUFFIX_ALWAYS
)
11332 if (sizeflag
& DFLAG
)
11336 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11350 if (address_mode
== mode_64bit
11351 && !(prefixes
& PREFIX_ADDR
))
11362 if (l
!= 0 || len
!= 1)
11367 if (need_vex
&& vex
.prefix
)
11369 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
11376 if (prefixes
& PREFIX_DATA
)
11380 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11384 if (l
== 0 && len
== 1)
11386 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11397 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11405 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11407 switch (vex
.length
)
11421 if (l
== 0 && len
== 1)
11423 /* operand size flag for cwtl, cbtw */
11432 else if (sizeflag
& DFLAG
)
11436 if (!(rex
& REX_W
))
11437 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11441 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11448 *obufp
++ = vex
.w
? 'd': 's';
11455 mnemonicendp
= obufp
;
11460 oappend (const char *s
)
11462 obufp
= stpcpy (obufp
, s
);
11468 if (prefixes
& PREFIX_CS
)
11470 used_prefixes
|= PREFIX_CS
;
11471 oappend ("%cs:" + intel_syntax
);
11473 if (prefixes
& PREFIX_DS
)
11475 used_prefixes
|= PREFIX_DS
;
11476 oappend ("%ds:" + intel_syntax
);
11478 if (prefixes
& PREFIX_SS
)
11480 used_prefixes
|= PREFIX_SS
;
11481 oappend ("%ss:" + intel_syntax
);
11483 if (prefixes
& PREFIX_ES
)
11485 used_prefixes
|= PREFIX_ES
;
11486 oappend ("%es:" + intel_syntax
);
11488 if (prefixes
& PREFIX_FS
)
11490 used_prefixes
|= PREFIX_FS
;
11491 oappend ("%fs:" + intel_syntax
);
11493 if (prefixes
& PREFIX_GS
)
11495 used_prefixes
|= PREFIX_GS
;
11496 oappend ("%gs:" + intel_syntax
);
11501 OP_indirE (int bytemode
, int sizeflag
)
11505 OP_E (bytemode
, sizeflag
);
11509 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
11511 if (address_mode
== mode_64bit
)
11519 sprintf_vma (tmp
, disp
);
11520 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
11521 strcpy (buf
+ 2, tmp
+ i
);
11525 bfd_signed_vma v
= disp
;
11532 /* Check for possible overflow on 0x8000000000000000. */
11535 strcpy (buf
, "9223372036854775808");
11549 tmp
[28 - i
] = (v
% 10) + '0';
11553 strcpy (buf
, tmp
+ 29 - i
);
11559 sprintf (buf
, "0x%x", (unsigned int) disp
);
11561 sprintf (buf
, "%d", (int) disp
);
11565 /* Put DISP in BUF as signed hex number. */
11568 print_displacement (char *buf
, bfd_vma disp
)
11570 bfd_signed_vma val
= disp
;
11579 /* Check for possible overflow. */
11582 switch (address_mode
)
11585 strcpy (buf
+ j
, "0x8000000000000000");
11588 strcpy (buf
+ j
, "0x80000000");
11591 strcpy (buf
+ j
, "0x8000");
11601 sprintf_vma (tmp
, (bfd_vma
) val
);
11602 for (i
= 0; tmp
[i
] == '0'; i
++)
11604 if (tmp
[i
] == '\0')
11606 strcpy (buf
+ j
, tmp
+ i
);
11610 intel_operand_size (int bytemode
, int sizeflag
)
11617 oappend ("BYTE PTR ");
11621 oappend ("WORD PTR ");
11624 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11626 oappend ("QWORD PTR ");
11635 oappend ("QWORD PTR ");
11638 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
11639 oappend ("DWORD PTR ");
11641 oappend ("WORD PTR ");
11642 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11646 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11648 oappend ("WORD PTR ");
11649 if (!(rex
& REX_W
))
11650 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11653 if (sizeflag
& DFLAG
)
11654 oappend ("QWORD PTR ");
11656 oappend ("DWORD PTR ");
11657 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11662 oappend ("DWORD PTR ");
11666 oappend ("QWORD PTR ");
11669 if (address_mode
== mode_64bit
)
11670 oappend ("QWORD PTR ");
11672 oappend ("DWORD PTR ");
11675 if (sizeflag
& DFLAG
)
11676 oappend ("FWORD PTR ");
11678 oappend ("DWORD PTR ");
11679 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11682 oappend ("TBYTE PTR ");
11688 switch (vex
.length
)
11691 oappend ("XMMWORD PTR ");
11694 oappend ("YMMWORD PTR ");
11701 oappend ("XMMWORD PTR ");
11704 oappend ("XMMWORD PTR ");
11710 switch (vex
.length
)
11713 oappend ("QWORD PTR ");
11716 oappend ("XMMWORD PTR ");
11726 switch (vex
.length
)
11729 oappend ("QWORD PTR ");
11732 oappend ("YMMWORD PTR ");
11739 oappend ("OWORD PTR ");
11741 case vex_w_dq_mode
:
11746 oappend ("QWORD PTR ");
11748 oappend ("DWORD PTR ");
11756 OP_E_register (int bytemode
, int sizeflag
)
11758 int reg
= modrm
.rm
;
11759 const char **names
;
11765 if ((sizeflag
& SUFFIX_ALWAYS
)
11766 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
11789 names
= address_mode
== mode_64bit
? names64
: names32
;
11792 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11810 if ((sizeflag
& DFLAG
)
11811 || (bytemode
!= v_mode
11812 && bytemode
!= v_swap_mode
))
11816 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11822 oappend (INTERNAL_DISASSEMBLER_ERROR
);
11825 oappend (names
[reg
]);
11829 OP_E_memory (int bytemode
, int sizeflag
)
11832 int add
= (rex
& REX_B
) ? 8 : 0;
11837 intel_operand_size (bytemode
, sizeflag
);
11840 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
11842 /* 32/64 bit address mode */
11860 FETCH_DATA (the_info
, codep
+ 1);
11861 index
= (*codep
>> 3) & 7;
11862 scale
= (*codep
>> 6) & 3;
11867 haveindex
= index
!= 4;
11870 rbase
= base
+ add
;
11878 if (address_mode
== mode_64bit
&& !havesib
)
11884 FETCH_DATA (the_info
, codep
+ 1);
11886 if ((disp
& 0x80) != 0)
11894 /* In 32bit mode, we need index register to tell [offset] from
11895 [eiz*1 + offset]. */
11896 needindex
= (havesib
11899 && address_mode
== mode_32bit
);
11900 havedisp
= (havebase
11902 || (havesib
&& (haveindex
|| scale
!= 0)));
11905 if (modrm
.mod
!= 0 || base
== 5)
11907 if (havedisp
|| riprel
)
11908 print_displacement (scratchbuf
, disp
);
11910 print_operand_value (scratchbuf
, 1, disp
);
11911 oappend (scratchbuf
);
11915 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
11919 if (havebase
|| haveindex
|| riprel
)
11920 used_prefixes
|= PREFIX_ADDR
;
11922 if (havedisp
|| (intel_syntax
&& riprel
))
11924 *obufp
++ = open_char
;
11925 if (intel_syntax
&& riprel
)
11928 oappend (sizeflag
& AFLAG
? "rip" : "eip");
11932 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
11933 ? names64
[rbase
] : names32
[rbase
]);
11936 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
11937 print index to tell base + index from base. */
11941 || (havebase
&& base
!= ESP_REG_NUM
))
11943 if (!intel_syntax
|| havebase
)
11945 *obufp
++ = separator_char
;
11949 oappend (address_mode
== mode_64bit
11950 && (sizeflag
& AFLAG
)
11951 ? names64
[index
] : names32
[index
]);
11953 oappend (address_mode
== mode_64bit
11954 && (sizeflag
& AFLAG
)
11955 ? index64
: index32
);
11957 *obufp
++ = scale_char
;
11959 sprintf (scratchbuf
, "%d", 1 << scale
);
11960 oappend (scratchbuf
);
11964 && (disp
|| modrm
.mod
!= 0 || base
== 5))
11966 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
11971 else if (modrm
.mod
!= 1 && disp
!= -disp
)
11975 disp
= - (bfd_signed_vma
) disp
;
11979 print_displacement (scratchbuf
, disp
);
11981 print_operand_value (scratchbuf
, 1, disp
);
11982 oappend (scratchbuf
);
11985 *obufp
++ = close_char
;
11988 else if (intel_syntax
)
11990 if (modrm
.mod
!= 0 || base
== 5)
11992 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
11993 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
11997 oappend (names_seg
[ds_reg
- es_reg
]);
12000 print_operand_value (scratchbuf
, 1, disp
);
12001 oappend (scratchbuf
);
12007 /* 16 bit address mode */
12008 used_prefixes
|= prefixes
& PREFIX_ADDR
;
12015 if ((disp
& 0x8000) != 0)
12020 FETCH_DATA (the_info
, codep
+ 1);
12022 if ((disp
& 0x80) != 0)
12027 if ((disp
& 0x8000) != 0)
12033 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
12035 print_displacement (scratchbuf
, disp
);
12036 oappend (scratchbuf
);
12039 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
12041 *obufp
++ = open_char
;
12043 oappend (index16
[modrm
.rm
]);
12045 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
12047 if ((bfd_signed_vma
) disp
>= 0)
12052 else if (modrm
.mod
!= 1)
12056 disp
= - (bfd_signed_vma
) disp
;
12059 print_displacement (scratchbuf
, disp
);
12060 oappend (scratchbuf
);
12063 *obufp
++ = close_char
;
12066 else if (intel_syntax
)
12068 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12069 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12073 oappend (names_seg
[ds_reg
- es_reg
]);
12076 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
12077 oappend (scratchbuf
);
12083 OP_E_extended (int bytemode
, int sizeflag
)
12085 /* Skip mod/rm byte. */
12089 if (modrm
.mod
== 3)
12090 OP_E_register (bytemode
, sizeflag
);
12092 OP_E_memory (bytemode
, sizeflag
);
12096 OP_E (int bytemode
, int sizeflag
)
12098 OP_E_extended (bytemode
, sizeflag
);
12103 OP_G (int bytemode
, int sizeflag
)
12114 oappend (names8rex
[modrm
.reg
+ add
]);
12116 oappend (names8
[modrm
.reg
+ add
]);
12119 oappend (names16
[modrm
.reg
+ add
]);
12122 oappend (names32
[modrm
.reg
+ add
]);
12125 oappend (names64
[modrm
.reg
+ add
]);
12134 oappend (names64
[modrm
.reg
+ add
]);
12137 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
12138 oappend (names32
[modrm
.reg
+ add
]);
12140 oappend (names16
[modrm
.reg
+ add
]);
12141 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12145 if (address_mode
== mode_64bit
)
12146 oappend (names64
[modrm
.reg
+ add
]);
12148 oappend (names32
[modrm
.reg
+ add
]);
12151 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12164 FETCH_DATA (the_info
, codep
+ 8);
12165 a
= *codep
++ & 0xff;
12166 a
|= (*codep
++ & 0xff) << 8;
12167 a
|= (*codep
++ & 0xff) << 16;
12168 a
|= (*codep
++ & 0xff) << 24;
12169 b
= *codep
++ & 0xff;
12170 b
|= (*codep
++ & 0xff) << 8;
12171 b
|= (*codep
++ & 0xff) << 16;
12172 b
|= (*codep
++ & 0xff) << 24;
12173 x
= a
+ ((bfd_vma
) b
<< 32);
12181 static bfd_signed_vma
12184 bfd_signed_vma x
= 0;
12186 FETCH_DATA (the_info
, codep
+ 4);
12187 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12188 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12189 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12190 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12194 static bfd_signed_vma
12197 bfd_signed_vma x
= 0;
12199 FETCH_DATA (the_info
, codep
+ 4);
12200 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12201 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12202 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12203 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12205 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
12215 FETCH_DATA (the_info
, codep
+ 2);
12216 x
= *codep
++ & 0xff;
12217 x
|= (*codep
++ & 0xff) << 8;
12222 set_op (bfd_vma op
, int riprel
)
12224 op_index
[op_ad
] = op_ad
;
12225 if (address_mode
== mode_64bit
)
12227 op_address
[op_ad
] = op
;
12228 op_riprel
[op_ad
] = riprel
;
12232 /* Mask to get a 32-bit address. */
12233 op_address
[op_ad
] = op
& 0xffffffff;
12234 op_riprel
[op_ad
] = riprel
& 0xffffffff;
12239 OP_REG (int code
, int sizeflag
)
12251 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12252 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12253 s
= names16
[code
- ax_reg
+ add
];
12255 case es_reg
: case ss_reg
: case cs_reg
:
12256 case ds_reg
: case fs_reg
: case gs_reg
:
12257 s
= names_seg
[code
- es_reg
+ add
];
12259 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12260 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12263 s
= names8rex
[code
- al_reg
+ add
];
12265 s
= names8
[code
- al_reg
];
12267 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
12268 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
12269 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12271 s
= names64
[code
- rAX_reg
+ add
];
12274 code
+= eAX_reg
- rAX_reg
;
12275 /* Fall through. */
12276 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12277 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12280 s
= names64
[code
- eAX_reg
+ add
];
12283 if (sizeflag
& DFLAG
)
12284 s
= names32
[code
- eAX_reg
+ add
];
12286 s
= names16
[code
- eAX_reg
+ add
];
12287 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12291 s
= INTERNAL_DISASSEMBLER_ERROR
;
12298 OP_IMREG (int code
, int sizeflag
)
12310 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12311 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12312 s
= names16
[code
- ax_reg
];
12314 case es_reg
: case ss_reg
: case cs_reg
:
12315 case ds_reg
: case fs_reg
: case gs_reg
:
12316 s
= names_seg
[code
- es_reg
];
12318 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12319 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12322 s
= names8rex
[code
- al_reg
];
12324 s
= names8
[code
- al_reg
];
12326 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12327 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12330 s
= names64
[code
- eAX_reg
];
12333 if (sizeflag
& DFLAG
)
12334 s
= names32
[code
- eAX_reg
];
12336 s
= names16
[code
- eAX_reg
];
12337 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12340 case z_mode_ax_reg
:
12341 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12345 if (!(rex
& REX_W
))
12346 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12349 s
= INTERNAL_DISASSEMBLER_ERROR
;
12356 OP_I (int bytemode
, int sizeflag
)
12359 bfd_signed_vma mask
= -1;
12364 FETCH_DATA (the_info
, codep
+ 1);
12369 if (address_mode
== mode_64bit
)
12374 /* Fall through. */
12381 if (sizeflag
& DFLAG
)
12391 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12403 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12408 scratchbuf
[0] = '$';
12409 print_operand_value (scratchbuf
+ 1, 1, op
);
12410 oappend (scratchbuf
+ intel_syntax
);
12411 scratchbuf
[0] = '\0';
12415 OP_I64 (int bytemode
, int sizeflag
)
12418 bfd_signed_vma mask
= -1;
12420 if (address_mode
!= mode_64bit
)
12422 OP_I (bytemode
, sizeflag
);
12429 FETCH_DATA (the_info
, codep
+ 1);
12439 if (sizeflag
& DFLAG
)
12449 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12457 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12462 scratchbuf
[0] = '$';
12463 print_operand_value (scratchbuf
+ 1, 1, op
);
12464 oappend (scratchbuf
+ intel_syntax
);
12465 scratchbuf
[0] = '\0';
12469 OP_sI (int bytemode
, int sizeflag
)
12472 bfd_signed_vma mask
= -1;
12477 FETCH_DATA (the_info
, codep
+ 1);
12479 if ((op
& 0x80) != 0)
12489 if (sizeflag
& DFLAG
)
12498 if ((op
& 0x8000) != 0)
12501 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12507 if ((op
& 0x8000) != 0)
12511 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12515 scratchbuf
[0] = '$';
12516 print_operand_value (scratchbuf
+ 1, 1, op
);
12517 oappend (scratchbuf
+ intel_syntax
);
12521 OP_J (int bytemode
, int sizeflag
)
12525 bfd_vma segment
= 0;
12530 FETCH_DATA (the_info
, codep
+ 1);
12532 if ((disp
& 0x80) != 0)
12537 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
12542 if ((disp
& 0x8000) != 0)
12544 /* In 16bit mode, address is wrapped around at 64k within
12545 the same segment. Otherwise, a data16 prefix on a jump
12546 instruction means that the pc is masked to 16 bits after
12547 the displacement is added! */
12549 if ((prefixes
& PREFIX_DATA
) == 0)
12550 segment
= ((start_pc
+ codep
- start_codep
)
12551 & ~((bfd_vma
) 0xffff));
12553 if (!(rex
& REX_W
))
12554 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12557 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12560 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
12562 print_operand_value (scratchbuf
, 1, disp
);
12563 oappend (scratchbuf
);
12567 OP_SEG (int bytemode
, int sizeflag
)
12569 if (bytemode
== w_mode
)
12570 oappend (names_seg
[modrm
.reg
]);
12572 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
12576 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
12580 if (sizeflag
& DFLAG
)
12590 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12592 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
12594 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
12595 oappend (scratchbuf
);
12599 OP_OFF (int bytemode
, int sizeflag
)
12603 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12604 intel_operand_size (bytemode
, sizeflag
);
12607 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12614 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12615 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12617 oappend (names_seg
[ds_reg
- es_reg
]);
12621 print_operand_value (scratchbuf
, 1, off
);
12622 oappend (scratchbuf
);
12626 OP_OFF64 (int bytemode
, int sizeflag
)
12630 if (address_mode
!= mode_64bit
12631 || (prefixes
& PREFIX_ADDR
))
12633 OP_OFF (bytemode
, sizeflag
);
12637 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12638 intel_operand_size (bytemode
, sizeflag
);
12645 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12646 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12648 oappend (names_seg
[ds_reg
- es_reg
]);
12652 print_operand_value (scratchbuf
, 1, off
);
12653 oappend (scratchbuf
);
12657 ptr_reg (int code
, int sizeflag
)
12661 *obufp
++ = open_char
;
12662 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12663 if (address_mode
== mode_64bit
)
12665 if (!(sizeflag
& AFLAG
))
12666 s
= names32
[code
- eAX_reg
];
12668 s
= names64
[code
- eAX_reg
];
12670 else if (sizeflag
& AFLAG
)
12671 s
= names32
[code
- eAX_reg
];
12673 s
= names16
[code
- eAX_reg
];
12675 *obufp
++ = close_char
;
12680 OP_ESreg (int code
, int sizeflag
)
12686 case 0x6d: /* insw/insl */
12687 intel_operand_size (z_mode
, sizeflag
);
12689 case 0xa5: /* movsw/movsl/movsq */
12690 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12691 case 0xab: /* stosw/stosl */
12692 case 0xaf: /* scasw/scasl */
12693 intel_operand_size (v_mode
, sizeflag
);
12696 intel_operand_size (b_mode
, sizeflag
);
12699 oappend ("%es:" + intel_syntax
);
12700 ptr_reg (code
, sizeflag
);
12704 OP_DSreg (int code
, int sizeflag
)
12710 case 0x6f: /* outsw/outsl */
12711 intel_operand_size (z_mode
, sizeflag
);
12713 case 0xa5: /* movsw/movsl/movsq */
12714 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12715 case 0xad: /* lodsw/lodsl/lodsq */
12716 intel_operand_size (v_mode
, sizeflag
);
12719 intel_operand_size (b_mode
, sizeflag
);
12728 | PREFIX_GS
)) == 0)
12729 prefixes
|= PREFIX_DS
;
12731 ptr_reg (code
, sizeflag
);
12735 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12743 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
12745 all_prefixes
[last_lock_prefix
] = 0;
12746 used_prefixes
|= PREFIX_LOCK
;
12751 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
12752 oappend (scratchbuf
+ intel_syntax
);
12756 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12765 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
12767 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
12768 oappend (scratchbuf
);
12772 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12774 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
12775 oappend (scratchbuf
+ intel_syntax
);
12779 OP_R (int bytemode
, int sizeflag
)
12781 if (modrm
.mod
== 3)
12782 OP_E (bytemode
, sizeflag
);
12788 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12790 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12791 if (prefixes
& PREFIX_DATA
)
12799 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
12802 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
12803 oappend (scratchbuf
+ intel_syntax
);
12807 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
12815 if (need_vex
&& bytemode
!= xmm_mode
)
12817 switch (vex
.length
)
12820 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
12823 sprintf (scratchbuf
, "%%ymm%d", modrm
.reg
+ add
);
12830 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
12831 oappend (scratchbuf
+ intel_syntax
);
12835 OP_EM (int bytemode
, int sizeflag
)
12837 if (modrm
.mod
!= 3)
12840 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
12842 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
12843 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12845 OP_E (bytemode
, sizeflag
);
12849 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
12852 /* Skip mod/rm byte. */
12855 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12856 if (prefixes
& PREFIX_DATA
)
12865 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
12868 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
12869 oappend (scratchbuf
+ intel_syntax
);
12872 /* cvt* are the only instructions in sse2 which have
12873 both SSE and MMX operands and also have 0x66 prefix
12874 in their opcode. 0x66 was originally used to differentiate
12875 between SSE and MMX instruction(operands). So we have to handle the
12876 cvt* separately using OP_EMC and OP_MXC */
12878 OP_EMC (int bytemode
, int sizeflag
)
12880 if (modrm
.mod
!= 3)
12882 if (intel_syntax
&& bytemode
== v_mode
)
12884 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
12885 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12887 OP_E (bytemode
, sizeflag
);
12891 /* Skip mod/rm byte. */
12894 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12895 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
12896 oappend (scratchbuf
+ intel_syntax
);
12900 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
12902 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12903 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
12904 oappend (scratchbuf
+ intel_syntax
);
12908 OP_EX (int bytemode
, int sizeflag
)
12912 /* Skip mod/rm byte. */
12916 if (modrm
.mod
!= 3)
12918 OP_E_memory (bytemode
, sizeflag
);
12928 if ((sizeflag
& SUFFIX_ALWAYS
)
12929 && (bytemode
== x_swap_mode
12930 || bytemode
== d_swap_mode
12931 || bytemode
== q_swap_mode
))
12935 && bytemode
!= xmm_mode
12936 && bytemode
!= xmmq_mode
)
12938 switch (vex
.length
)
12941 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
12944 sprintf (scratchbuf
, "%%ymm%d", modrm
.rm
+ add
);
12951 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
12952 oappend (scratchbuf
+ intel_syntax
);
12956 OP_MS (int bytemode
, int sizeflag
)
12958 if (modrm
.mod
== 3)
12959 OP_EM (bytemode
, sizeflag
);
12965 OP_XS (int bytemode
, int sizeflag
)
12967 if (modrm
.mod
== 3)
12968 OP_EX (bytemode
, sizeflag
);
12974 OP_M (int bytemode
, int sizeflag
)
12976 if (modrm
.mod
== 3)
12977 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
12980 OP_E (bytemode
, sizeflag
);
12984 OP_0f07 (int bytemode
, int sizeflag
)
12986 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
12989 OP_E (bytemode
, sizeflag
);
12992 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
12993 32bit mode and "xchg %rax,%rax" in 64bit mode. */
12996 NOP_Fixup1 (int bytemode
, int sizeflag
)
12998 if ((prefixes
& PREFIX_DATA
) != 0
13001 && address_mode
== mode_64bit
))
13002 OP_REG (bytemode
, sizeflag
);
13004 strcpy (obuf
, "nop");
13008 NOP_Fixup2 (int bytemode
, int sizeflag
)
13010 if ((prefixes
& PREFIX_DATA
) != 0
13013 && address_mode
== mode_64bit
))
13014 OP_IMREG (bytemode
, sizeflag
);
13017 static const char *const Suffix3DNow
[] = {
13018 /* 00 */ NULL
, NULL
, NULL
, NULL
,
13019 /* 04 */ NULL
, NULL
, NULL
, NULL
,
13020 /* 08 */ NULL
, NULL
, NULL
, NULL
,
13021 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
13022 /* 10 */ NULL
, NULL
, NULL
, NULL
,
13023 /* 14 */ NULL
, NULL
, NULL
, NULL
,
13024 /* 18 */ NULL
, NULL
, NULL
, NULL
,
13025 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
13026 /* 20 */ NULL
, NULL
, NULL
, NULL
,
13027 /* 24 */ NULL
, NULL
, NULL
, NULL
,
13028 /* 28 */ NULL
, NULL
, NULL
, NULL
,
13029 /* 2C */ NULL
, NULL
, NULL
, NULL
,
13030 /* 30 */ NULL
, NULL
, NULL
, NULL
,
13031 /* 34 */ NULL
, NULL
, NULL
, NULL
,
13032 /* 38 */ NULL
, NULL
, NULL
, NULL
,
13033 /* 3C */ NULL
, NULL
, NULL
, NULL
,
13034 /* 40 */ NULL
, NULL
, NULL
, NULL
,
13035 /* 44 */ NULL
, NULL
, NULL
, NULL
,
13036 /* 48 */ NULL
, NULL
, NULL
, NULL
,
13037 /* 4C */ NULL
, NULL
, NULL
, NULL
,
13038 /* 50 */ NULL
, NULL
, NULL
, NULL
,
13039 /* 54 */ NULL
, NULL
, NULL
, NULL
,
13040 /* 58 */ NULL
, NULL
, NULL
, NULL
,
13041 /* 5C */ NULL
, NULL
, NULL
, NULL
,
13042 /* 60 */ NULL
, NULL
, NULL
, NULL
,
13043 /* 64 */ NULL
, NULL
, NULL
, NULL
,
13044 /* 68 */ NULL
, NULL
, NULL
, NULL
,
13045 /* 6C */ NULL
, NULL
, NULL
, NULL
,
13046 /* 70 */ NULL
, NULL
, NULL
, NULL
,
13047 /* 74 */ NULL
, NULL
, NULL
, NULL
,
13048 /* 78 */ NULL
, NULL
, NULL
, NULL
,
13049 /* 7C */ NULL
, NULL
, NULL
, NULL
,
13050 /* 80 */ NULL
, NULL
, NULL
, NULL
,
13051 /* 84 */ NULL
, NULL
, NULL
, NULL
,
13052 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
13053 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
13054 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
13055 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
13056 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
13057 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
13058 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
13059 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
13060 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
13061 /* AC */ NULL
, NULL
, "pfacc", NULL
,
13062 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
13063 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
13064 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
13065 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
13066 /* C0 */ NULL
, NULL
, NULL
, NULL
,
13067 /* C4 */ NULL
, NULL
, NULL
, NULL
,
13068 /* C8 */ NULL
, NULL
, NULL
, NULL
,
13069 /* CC */ NULL
, NULL
, NULL
, NULL
,
13070 /* D0 */ NULL
, NULL
, NULL
, NULL
,
13071 /* D4 */ NULL
, NULL
, NULL
, NULL
,
13072 /* D8 */ NULL
, NULL
, NULL
, NULL
,
13073 /* DC */ NULL
, NULL
, NULL
, NULL
,
13074 /* E0 */ NULL
, NULL
, NULL
, NULL
,
13075 /* E4 */ NULL
, NULL
, NULL
, NULL
,
13076 /* E8 */ NULL
, NULL
, NULL
, NULL
,
13077 /* EC */ NULL
, NULL
, NULL
, NULL
,
13078 /* F0 */ NULL
, NULL
, NULL
, NULL
,
13079 /* F4 */ NULL
, NULL
, NULL
, NULL
,
13080 /* F8 */ NULL
, NULL
, NULL
, NULL
,
13081 /* FC */ NULL
, NULL
, NULL
, NULL
,
13085 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13087 const char *mnemonic
;
13089 FETCH_DATA (the_info
, codep
+ 1);
13090 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13091 place where an 8-bit immediate would normally go. ie. the last
13092 byte of the instruction. */
13093 obufp
= mnemonicendp
;
13094 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
13096 oappend (mnemonic
);
13099 /* Since a variable sized modrm/sib chunk is between the start
13100 of the opcode (0x0f0f) and the opcode suffix, we need to do
13101 all the modrm processing first, and don't know until now that
13102 we have a bad opcode. This necessitates some cleaning up. */
13103 op_out
[0][0] = '\0';
13104 op_out
[1][0] = '\0';
13107 mnemonicendp
= obufp
;
13110 static struct op simd_cmp_op
[] =
13112 { STRING_COMMA_LEN ("eq") },
13113 { STRING_COMMA_LEN ("lt") },
13114 { STRING_COMMA_LEN ("le") },
13115 { STRING_COMMA_LEN ("unord") },
13116 { STRING_COMMA_LEN ("neq") },
13117 { STRING_COMMA_LEN ("nlt") },
13118 { STRING_COMMA_LEN ("nle") },
13119 { STRING_COMMA_LEN ("ord") }
13123 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13125 unsigned int cmp_type
;
13127 FETCH_DATA (the_info
, codep
+ 1);
13128 cmp_type
= *codep
++ & 0xff;
13129 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
13132 char *p
= mnemonicendp
- 2;
13136 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
13137 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
13141 /* We have a reserved extension byte. Output it directly. */
13142 scratchbuf
[0] = '$';
13143 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
13144 oappend (scratchbuf
+ intel_syntax
);
13145 scratchbuf
[0] = '\0';
13150 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
13151 int sizeflag ATTRIBUTE_UNUSED
)
13153 /* mwait %eax,%ecx */
13156 const char **names
= (address_mode
== mode_64bit
13157 ? names64
: names32
);
13158 strcpy (op_out
[0], names
[0]);
13159 strcpy (op_out
[1], names
[1]);
13160 two_source_ops
= 1;
13162 /* Skip mod/rm byte. */
13168 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
13169 int sizeflag ATTRIBUTE_UNUSED
)
13171 /* monitor %eax,%ecx,%edx" */
13174 const char **op1_names
;
13175 const char **names
= (address_mode
== mode_64bit
13176 ? names64
: names32
);
13178 if (!(prefixes
& PREFIX_ADDR
))
13179 op1_names
= (address_mode
== mode_16bit
13180 ? names16
: names
);
13183 /* Remove "addr16/addr32". */
13184 all_prefixes
[last_addr_prefix
] = 0;
13185 op1_names
= (address_mode
!= mode_32bit
13186 ? names32
: names16
);
13187 used_prefixes
|= PREFIX_ADDR
;
13189 strcpy (op_out
[0], op1_names
[0]);
13190 strcpy (op_out
[1], names
[1]);
13191 strcpy (op_out
[2], names
[2]);
13192 two_source_ops
= 1;
13194 /* Skip mod/rm byte. */
13202 /* Throw away prefixes and 1st. opcode byte. */
13203 codep
= insn_codep
+ 1;
13208 REP_Fixup (int bytemode
, int sizeflag
)
13210 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13212 if (prefixes
& PREFIX_REPZ
)
13213 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
13220 OP_IMREG (bytemode
, sizeflag
);
13223 OP_ESreg (bytemode
, sizeflag
);
13226 OP_DSreg (bytemode
, sizeflag
);
13235 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
13240 /* Change cmpxchg8b to cmpxchg16b. */
13241 char *p
= mnemonicendp
- 2;
13242 mnemonicendp
= stpcpy (p
, "16b");
13245 OP_M (bytemode
, sizeflag
);
13249 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
13253 switch (vex
.length
)
13256 sprintf (scratchbuf
, "%%xmm%d", reg
);
13259 sprintf (scratchbuf
, "%%ymm%d", reg
);
13266 sprintf (scratchbuf
, "%%xmm%d", reg
);
13267 oappend (scratchbuf
+ intel_syntax
);
13271 CRC32_Fixup (int bytemode
, int sizeflag
)
13273 /* Add proper suffix to "crc32". */
13274 char *p
= mnemonicendp
;
13293 if (sizeflag
& DFLAG
)
13297 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13301 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13308 if (modrm
.mod
== 3)
13312 /* Skip mod/rm byte. */
13317 add
= (rex
& REX_B
) ? 8 : 0;
13318 if (bytemode
== b_mode
)
13322 oappend (names8rex
[modrm
.rm
+ add
]);
13324 oappend (names8
[modrm
.rm
+ add
]);
13330 oappend (names64
[modrm
.rm
+ add
]);
13331 else if ((prefixes
& PREFIX_DATA
))
13332 oappend (names16
[modrm
.rm
+ add
]);
13334 oappend (names32
[modrm
.rm
+ add
]);
13338 OP_E (bytemode
, sizeflag
);
13341 /* Display the destination register operand for instructions with
13345 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13353 switch (vex
.length
)
13366 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13379 sprintf (scratchbuf
, "%%ymm%d", vex
.register_specifier
);
13385 oappend (scratchbuf
+ intel_syntax
);
13388 /* Get the VEX immediate byte without moving codep. */
13390 static unsigned char
13391 get_vex_imm8 (int sizeflag
)
13393 int bytes_before_imm
= 0;
13395 /* Skip mod/rm byte. */
13399 if (modrm
.mod
!= 3)
13401 /* There are SIB/displacement bytes. */
13402 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13404 /* 32/64 bit address mode */
13405 int base
= modrm
.rm
;
13407 /* Check SIB byte. */
13410 FETCH_DATA (the_info
, codep
+ 1);
13412 bytes_before_imm
++;
13418 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13419 SIB == 5, there is a 4 byte displacement. */
13421 /* No displacement. */
13424 /* 4 byte displacement. */
13425 bytes_before_imm
+= 4;
13428 /* 1 byte displacement. */
13429 bytes_before_imm
++;
13434 { /* 16 bit address mode */
13438 /* When modrm.rm == 6, there is a 2 byte displacement. */
13440 /* No displacement. */
13443 /* 2 byte displacement. */
13444 bytes_before_imm
+= 2;
13447 /* 1 byte displacement. */
13448 bytes_before_imm
++;
13454 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
13455 return codep
[bytes_before_imm
];
13459 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
13461 if (reg
== -1 && modrm
.mod
!= 3)
13463 OP_E_memory (bytemode
, sizeflag
);
13475 else if (reg
> 7 && address_mode
!= mode_64bit
)
13479 switch (vex
.length
)
13482 sprintf (scratchbuf
, "%%xmm%d", reg
);
13485 sprintf (scratchbuf
, "%%ymm%d", reg
);
13490 oappend (scratchbuf
+ intel_syntax
);
13494 OP_EX_VexW (int bytemode
, int sizeflag
)
13502 reg
= get_vex_imm8 (sizeflag
) >> 4;
13507 reg
= get_vex_imm8 (sizeflag
) >> 4;
13510 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
13514 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
13515 int sizeflag ATTRIBUTE_UNUSED
)
13517 /* Skip the immediate byte and check for invalid bits. */
13518 FETCH_DATA (the_info
, codep
+ 1);
13519 if (*codep
++ & 0xf)
13524 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13527 FETCH_DATA (the_info
, codep
+ 1);
13530 if (bytemode
!= x_mode
)
13537 if (reg
> 7 && address_mode
!= mode_64bit
)
13540 switch (vex
.length
)
13543 sprintf (scratchbuf
, "%%xmm%d", reg
);
13546 sprintf (scratchbuf
, "%%ymm%d", reg
);
13551 oappend (scratchbuf
+ intel_syntax
);
13555 OP_XMM_VexW (int bytemode
, int sizeflag
)
13557 /* Turn off the REX.W bit since it is used for swapping operands
13560 OP_XMM (bytemode
, sizeflag
);
13564 OP_EX_Vex (int bytemode
, int sizeflag
)
13566 if (modrm
.mod
!= 3)
13568 if (vex
.register_specifier
!= 0)
13572 OP_EX (bytemode
, sizeflag
);
13576 OP_XMM_Vex (int bytemode
, int sizeflag
)
13578 if (modrm
.mod
!= 3)
13580 if (vex
.register_specifier
!= 0)
13584 OP_XMM (bytemode
, sizeflag
);
13588 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13590 switch (vex
.length
)
13593 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
13596 mnemonicendp
= stpcpy (obuf
, "vzeroall");
13603 static struct op vex_cmp_op
[] =
13605 { STRING_COMMA_LEN ("eq") },
13606 { STRING_COMMA_LEN ("lt") },
13607 { STRING_COMMA_LEN ("le") },
13608 { STRING_COMMA_LEN ("unord") },
13609 { STRING_COMMA_LEN ("neq") },
13610 { STRING_COMMA_LEN ("nlt") },
13611 { STRING_COMMA_LEN ("nle") },
13612 { STRING_COMMA_LEN ("ord") },
13613 { STRING_COMMA_LEN ("eq_uq") },
13614 { STRING_COMMA_LEN ("nge") },
13615 { STRING_COMMA_LEN ("ngt") },
13616 { STRING_COMMA_LEN ("false") },
13617 { STRING_COMMA_LEN ("neq_oq") },
13618 { STRING_COMMA_LEN ("ge") },
13619 { STRING_COMMA_LEN ("gt") },
13620 { STRING_COMMA_LEN ("true") },
13621 { STRING_COMMA_LEN ("eq_os") },
13622 { STRING_COMMA_LEN ("lt_oq") },
13623 { STRING_COMMA_LEN ("le_oq") },
13624 { STRING_COMMA_LEN ("unord_s") },
13625 { STRING_COMMA_LEN ("neq_us") },
13626 { STRING_COMMA_LEN ("nlt_uq") },
13627 { STRING_COMMA_LEN ("nle_uq") },
13628 { STRING_COMMA_LEN ("ord_s") },
13629 { STRING_COMMA_LEN ("eq_us") },
13630 { STRING_COMMA_LEN ("nge_uq") },
13631 { STRING_COMMA_LEN ("ngt_uq") },
13632 { STRING_COMMA_LEN ("false_os") },
13633 { STRING_COMMA_LEN ("neq_os") },
13634 { STRING_COMMA_LEN ("ge_oq") },
13635 { STRING_COMMA_LEN ("gt_oq") },
13636 { STRING_COMMA_LEN ("true_us") },
13640 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13642 unsigned int cmp_type
;
13644 FETCH_DATA (the_info
, codep
+ 1);
13645 cmp_type
= *codep
++ & 0xff;
13646 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
13649 char *p
= mnemonicendp
- 2;
13653 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
13654 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
13658 /* We have a reserved extension byte. Output it directly. */
13659 scratchbuf
[0] = '$';
13660 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
13661 oappend (scratchbuf
+ intel_syntax
);
13662 scratchbuf
[0] = '\0';
13666 static const struct op pclmul_op
[] =
13668 { STRING_COMMA_LEN ("lql") },
13669 { STRING_COMMA_LEN ("hql") },
13670 { STRING_COMMA_LEN ("lqh") },
13671 { STRING_COMMA_LEN ("hqh") }
13675 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
13676 int sizeflag ATTRIBUTE_UNUSED
)
13678 unsigned int pclmul_type
;
13680 FETCH_DATA (the_info
, codep
+ 1);
13681 pclmul_type
= *codep
++ & 0xff;
13682 switch (pclmul_type
)
13693 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
13696 char *p
= mnemonicendp
- 3;
13701 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
13702 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
13706 /* We have a reserved extension byte. Output it directly. */
13707 scratchbuf
[0] = '$';
13708 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
13709 oappend (scratchbuf
+ intel_syntax
);
13710 scratchbuf
[0] = '\0';
13715 MOVBE_Fixup (int bytemode
, int sizeflag
)
13717 /* Add proper suffix to "movbe". */
13718 char *p
= mnemonicendp
;
13727 if (sizeflag
& SUFFIX_ALWAYS
)
13733 if (sizeflag
& DFLAG
)
13737 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13742 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13749 OP_M (bytemode
, sizeflag
);
13753 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13756 const char **names
;
13758 /* Skip mod/rm byte. */
13764 else if (vex
.length
== 256)
13774 oappend (names
[reg
]);
13778 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13780 const char **names
;
13784 else if (vex
.length
== 256)
13789 oappend (names
[vex
.register_specifier
]);
13793 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
13795 if (vex
.w
|| vex
.length
== 256)
13796 OP_I (q_mode
, sizeflag
);
13798 OP_I (w_mode
, sizeflag
);