1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma
, disassemble_info
*);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma
);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma
);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma
get64 (void);
60 static bfd_signed_vma
get32 (void);
61 static bfd_signed_vma
get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma
, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void OP_LWPCB_E (int, int);
114 static void OP_LWP_E (int, int);
115 static void OP_LWP_I (int, int);
116 static void OP_Vex_2src_1 (int, int);
117 static void OP_Vex_2src_2 (int, int);
119 static void MOVBE_Fixup (int, int);
122 /* Points to first byte not fetched. */
123 bfd_byte
*max_fetched
;
124 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
137 enum address_mode address_mode
;
139 /* Flags for the prefixes for the current instruction. See below. */
142 /* REX prefix the current instruction. See below. */
144 /* Bits of REX we've already used. */
146 /* Original REX prefix. */
147 static int rex_original
;
148 /* REX bits in original REX prefix ignored. It may not be the same
149 as rex_original since some bits may not be ignored. */
150 static int rex_ignored
;
151 /* Mark parts used in the REX prefix. When we are testing for
152 empty prefix (for 8bit register REX extension), just mask it
153 out. Otherwise test for REX bit is excuse for existence of REX
154 only in case value is nonzero. */
155 #define USED_REX(value) \
160 rex_used |= (value) | REX_OPCODE; \
163 rex_used |= REX_OPCODE; \
166 /* Flags for prefixes which we somehow handled when printing the
167 current instruction. */
168 static int used_prefixes
;
170 /* Flags stored in PREFIXES. */
171 #define PREFIX_REPZ 1
172 #define PREFIX_REPNZ 2
173 #define PREFIX_LOCK 4
175 #define PREFIX_SS 0x10
176 #define PREFIX_DS 0x20
177 #define PREFIX_ES 0x40
178 #define PREFIX_FS 0x80
179 #define PREFIX_GS 0x100
180 #define PREFIX_DATA 0x200
181 #define PREFIX_ADDR 0x400
182 #define PREFIX_FWAIT 0x800
184 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
185 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
187 #define FETCH_DATA(info, addr) \
188 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
189 ? 1 : fetch_data ((info), (addr)))
192 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
195 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
196 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
198 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
199 status
= (*info
->read_memory_func
) (start
,
201 addr
- priv
->max_fetched
,
207 /* If we did manage to read at least one byte, then
208 print_insn_i386 will do something sensible. Otherwise, print
209 an error. We do that here because this is where we know
211 if (priv
->max_fetched
== priv
->the_buffer
)
212 (*info
->memory_error_func
) (status
, start
, info
);
213 longjmp (priv
->bailout
, 1);
216 priv
->max_fetched
= addr
;
220 #define XX { NULL, 0 }
222 #define Eb { OP_E, b_mode }
223 #define EbS { OP_E, b_swap_mode }
224 #define Ev { OP_E, v_mode }
225 #define EvS { OP_E, v_swap_mode }
226 #define Ed { OP_E, d_mode }
227 #define Edq { OP_E, dq_mode }
228 #define Edqw { OP_E, dqw_mode }
229 #define Edqb { OP_E, dqb_mode }
230 #define Edqd { OP_E, dqd_mode }
231 #define Eq { OP_E, q_mode }
232 #define indirEv { OP_indirE, stack_v_mode }
233 #define indirEp { OP_indirE, f_mode }
234 #define stackEv { OP_E, stack_v_mode }
235 #define Em { OP_E, m_mode }
236 #define Ew { OP_E, w_mode }
237 #define M { OP_M, 0 } /* lea, lgdt, etc. */
238 #define Ma { OP_M, a_mode }
239 #define Mb { OP_M, b_mode }
240 #define Md { OP_M, d_mode }
241 #define Mo { OP_M, o_mode }
242 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
243 #define Mq { OP_M, q_mode }
244 #define Mx { OP_M, x_mode }
245 #define Mxmm { OP_M, xmm_mode }
246 #define Gb { OP_G, b_mode }
247 #define Gv { OP_G, v_mode }
248 #define Gd { OP_G, d_mode }
249 #define Gdq { OP_G, dq_mode }
250 #define Gm { OP_G, m_mode }
251 #define Gw { OP_G, w_mode }
252 #define Rd { OP_R, d_mode }
253 #define Rm { OP_R, m_mode }
254 #define Ib { OP_I, b_mode }
255 #define sIb { OP_sI, b_mode } /* sign extened byte */
256 #define Iv { OP_I, v_mode }
257 #define Iq { OP_I, q_mode }
258 #define Iv64 { OP_I64, v_mode }
259 #define Iw { OP_I, w_mode }
260 #define I1 { OP_I, const_1_mode }
261 #define Jb { OP_J, b_mode }
262 #define Jv { OP_J, v_mode }
263 #define Cm { OP_C, m_mode }
264 #define Dm { OP_D, m_mode }
265 #define Td { OP_T, d_mode }
266 #define Skip_MODRM { OP_Skip_MODRM, 0 }
268 #define RMeAX { OP_REG, eAX_reg }
269 #define RMeBX { OP_REG, eBX_reg }
270 #define RMeCX { OP_REG, eCX_reg }
271 #define RMeDX { OP_REG, eDX_reg }
272 #define RMeSP { OP_REG, eSP_reg }
273 #define RMeBP { OP_REG, eBP_reg }
274 #define RMeSI { OP_REG, eSI_reg }
275 #define RMeDI { OP_REG, eDI_reg }
276 #define RMrAX { OP_REG, rAX_reg }
277 #define RMrBX { OP_REG, rBX_reg }
278 #define RMrCX { OP_REG, rCX_reg }
279 #define RMrDX { OP_REG, rDX_reg }
280 #define RMrSP { OP_REG, rSP_reg }
281 #define RMrBP { OP_REG, rBP_reg }
282 #define RMrSI { OP_REG, rSI_reg }
283 #define RMrDI { OP_REG, rDI_reg }
284 #define RMAL { OP_REG, al_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMCL { OP_REG, cl_reg }
287 #define RMDL { OP_REG, dl_reg }
288 #define RMBL { OP_REG, bl_reg }
289 #define RMAH { OP_REG, ah_reg }
290 #define RMCH { OP_REG, ch_reg }
291 #define RMDH { OP_REG, dh_reg }
292 #define RMBH { OP_REG, bh_reg }
293 #define RMAX { OP_REG, ax_reg }
294 #define RMDX { OP_REG, dx_reg }
296 #define eAX { OP_IMREG, eAX_reg }
297 #define eBX { OP_IMREG, eBX_reg }
298 #define eCX { OP_IMREG, eCX_reg }
299 #define eDX { OP_IMREG, eDX_reg }
300 #define eSP { OP_IMREG, eSP_reg }
301 #define eBP { OP_IMREG, eBP_reg }
302 #define eSI { OP_IMREG, eSI_reg }
303 #define eDI { OP_IMREG, eDI_reg }
304 #define AL { OP_IMREG, al_reg }
305 #define CL { OP_IMREG, cl_reg }
306 #define DL { OP_IMREG, dl_reg }
307 #define BL { OP_IMREG, bl_reg }
308 #define AH { OP_IMREG, ah_reg }
309 #define CH { OP_IMREG, ch_reg }
310 #define DH { OP_IMREG, dh_reg }
311 #define BH { OP_IMREG, bh_reg }
312 #define AX { OP_IMREG, ax_reg }
313 #define DX { OP_IMREG, dx_reg }
314 #define zAX { OP_IMREG, z_mode_ax_reg }
315 #define indirDX { OP_IMREG, indir_dx_reg }
317 #define Sw { OP_SEG, w_mode }
318 #define Sv { OP_SEG, v_mode }
319 #define Ap { OP_DIR, 0 }
320 #define Ob { OP_OFF64, b_mode }
321 #define Ov { OP_OFF64, v_mode }
322 #define Xb { OP_DSreg, eSI_reg }
323 #define Xv { OP_DSreg, eSI_reg }
324 #define Xz { OP_DSreg, eSI_reg }
325 #define Yb { OP_ESreg, eDI_reg }
326 #define Yv { OP_ESreg, eDI_reg }
327 #define DSBX { OP_DSreg, eBX_reg }
329 #define es { OP_REG, es_reg }
330 #define ss { OP_REG, ss_reg }
331 #define cs { OP_REG, cs_reg }
332 #define ds { OP_REG, ds_reg }
333 #define fs { OP_REG, fs_reg }
334 #define gs { OP_REG, gs_reg }
336 #define MX { OP_MMX, 0 }
337 #define XM { OP_XMM, 0 }
338 #define XMM { OP_XMM, xmm_mode }
339 #define EM { OP_EM, v_mode }
340 #define EMS { OP_EM, v_swap_mode }
341 #define EMd { OP_EM, d_mode }
342 #define EMx { OP_EM, x_mode }
343 #define EXw { OP_EX, w_mode }
344 #define EXd { OP_EX, d_mode }
345 #define EXdS { OP_EX, d_swap_mode }
346 #define EXq { OP_EX, q_mode }
347 #define EXqS { OP_EX, q_swap_mode }
348 #define EXx { OP_EX, x_mode }
349 #define EXxS { OP_EX, x_swap_mode }
350 #define EXxmm { OP_EX, xmm_mode }
351 #define EXxmmq { OP_EX, xmmq_mode }
352 #define EXymmq { OP_EX, ymmq_mode }
353 #define EXVexWdq { OP_EX, vex_w_dq_mode }
354 #define MS { OP_MS, v_mode }
355 #define XS { OP_XS, v_mode }
356 #define EMCq { OP_EMC, q_mode }
357 #define MXC { OP_MXC, 0 }
358 #define OPSUF { OP_3DNowSuffix, 0 }
359 #define CMP { CMP_Fixup, 0 }
360 #define XMM0 { XMM_Fixup, 0 }
361 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
362 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
364 #define Vex { OP_VEX, vex_mode }
365 #define Vex128 { OP_VEX, vex128_mode }
366 #define Vex256 { OP_VEX, vex256_mode }
367 #define VexI4 { VEXI4_Fixup, 0}
368 #define EXdVex { OP_EX_Vex, d_mode }
369 #define EXdVexS { OP_EX_Vex, d_swap_mode }
370 #define EXqVex { OP_EX_Vex, q_mode }
371 #define EXqVexS { OP_EX_Vex, q_swap_mode }
372 #define EXVexW { OP_EX_VexW, x_mode }
373 #define EXdVexW { OP_EX_VexW, d_mode }
374 #define EXqVexW { OP_EX_VexW, q_mode }
375 #define XMVex { OP_XMM_Vex, 0 }
376 #define XMVexW { OP_XMM_VexW, 0 }
377 #define XMVexI4 { OP_REG_VexI4, x_mode }
378 #define PCLMUL { PCLMUL_Fixup, 0 }
379 #define VZERO { VZERO_Fixup, 0 }
380 #define VCMP { VCMP_Fixup, 0 }
382 /* Used handle "rep" prefix for string instructions. */
383 #define Xbr { REP_Fixup, eSI_reg }
384 #define Xvr { REP_Fixup, eSI_reg }
385 #define Ybr { REP_Fixup, eDI_reg }
386 #define Yvr { REP_Fixup, eDI_reg }
387 #define Yzr { REP_Fixup, eDI_reg }
388 #define indirDXr { REP_Fixup, indir_dx_reg }
389 #define ALr { REP_Fixup, al_reg }
390 #define eAXr { REP_Fixup, eAX_reg }
392 #define cond_jump_flag { NULL, cond_jump_mode }
393 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
395 /* bits in sizeflag */
396 #define SUFFIX_ALWAYS 4
404 /* byte operand with operand swapped */
406 /* operand size depends on prefixes */
408 /* operand size depends on prefixes with operand swapped */
412 /* double word operand */
414 /* double word operand with operand swapped */
416 /* quad word operand */
418 /* quad word operand with operand swapped */
420 /* ten-byte operand */
422 /* 16-byte XMM or 32-byte YMM operand */
424 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
426 /* 16-byte XMM operand */
428 /* 16-byte XMM or quad word operand */
430 /* 32-byte YMM or quad word operand */
432 /* d_mode in 32bit, q_mode in 64bit mode. */
434 /* pair of v_mode operands */
438 /* operand size depends on REX prefixes. */
440 /* registers like dq_mode, memory like w_mode. */
442 /* 4- or 6-byte pointer operand */
445 /* v_mode for stack-related opcodes. */
447 /* non-quad operand size depends on prefixes */
449 /* 16-byte operand */
451 /* registers like dq_mode, memory like b_mode. */
453 /* registers like dq_mode, memory like d_mode. */
455 /* normal vex mode */
457 /* 128bit vex mode */
459 /* 256bit vex mode */
461 /* operand size depends on the VEX.W bit. */
526 #define FLOAT NULL, { { NULL, FLOATCODE } }
528 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
529 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
530 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
531 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
532 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
533 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
534 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
535 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
536 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
537 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
538 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
656 MOD_VEX_3818_PREFIX_2
,
657 MOD_VEX_3819_PREFIX_2
,
658 MOD_VEX_381A_PREFIX_2
,
659 MOD_VEX_382A_PREFIX_2
,
660 MOD_VEX_382C_PREFIX_2
,
661 MOD_VEX_382D_PREFIX_2
,
662 MOD_VEX_382E_PREFIX_2
,
663 MOD_VEX_382F_PREFIX_2
1073 THREE_BYTE_0F38
= 0,
1228 VEX_LEN_3819_P_2_M_0
,
1229 VEX_LEN_381A_P_2_M_0
,
1241 VEX_LEN_382A_P_2_M_0
,
1300 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1311 /* Upper case letters in the instruction names here are macros.
1312 'A' => print 'b' if no register operands or suffix_always is true
1313 'B' => print 'b' if suffix_always is true
1314 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1316 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1317 suffix_always is true
1318 'E' => print 'e' if 32-bit form of jcxz
1319 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1320 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1321 'H' => print ",pt" or ",pn" branch hint
1322 'I' => honor following macro letter even in Intel mode (implemented only
1323 for some of the macro letters)
1325 'K' => print 'd' or 'q' if rex prefix is present.
1326 'L' => print 'l' if suffix_always is true
1327 'M' => print 'r' if intel_mnemonic is false.
1328 'N' => print 'n' if instruction has no wait "prefix"
1329 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1330 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1331 or suffix_always is true. print 'q' if rex prefix is present.
1332 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1334 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1335 'S' => print 'w', 'l' or 'q' if suffix_always is true
1336 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1337 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1338 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1339 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1340 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1341 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1342 suffix_always is true.
1343 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1344 '!' => change condition from true to false or from false to true.
1345 '%' => add 1 upper case letter to the macro.
1347 2 upper case letter macros:
1348 "XY" => print 'x' or 'y' if no register operands or suffix_always
1350 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1351 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1352 or suffix_always is true
1353 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1354 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1355 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1357 Many of the above letters print nothing in Intel mode. See "putop"
1360 Braces '{' and '}', and vertical bars '|', indicate alternative
1361 mnemonic strings for AT&T and Intel. */
1363 static const struct dis386 dis386
[] = {
1365 { "addB", { Eb
, Gb
} },
1366 { "addS", { Ev
, Gv
} },
1367 { "addB", { Gb
, EbS
} },
1368 { "addS", { Gv
, EvS
} },
1369 { "addB", { AL
, Ib
} },
1370 { "addS", { eAX
, Iv
} },
1371 { X86_64_TABLE (X86_64_06
) },
1372 { X86_64_TABLE (X86_64_07
) },
1374 { "orB", { Eb
, Gb
} },
1375 { "orS", { Ev
, Gv
} },
1376 { "orB", { Gb
, EbS
} },
1377 { "orS", { Gv
, EvS
} },
1378 { "orB", { AL
, Ib
} },
1379 { "orS", { eAX
, Iv
} },
1380 { X86_64_TABLE (X86_64_0D
) },
1381 { "(bad)", { XX
} }, /* 0x0f extended opcode escape */
1383 { "adcB", { Eb
, Gb
} },
1384 { "adcS", { Ev
, Gv
} },
1385 { "adcB", { Gb
, EbS
} },
1386 { "adcS", { Gv
, EvS
} },
1387 { "adcB", { AL
, Ib
} },
1388 { "adcS", { eAX
, Iv
} },
1389 { X86_64_TABLE (X86_64_16
) },
1390 { X86_64_TABLE (X86_64_17
) },
1392 { "sbbB", { Eb
, Gb
} },
1393 { "sbbS", { Ev
, Gv
} },
1394 { "sbbB", { Gb
, EbS
} },
1395 { "sbbS", { Gv
, EvS
} },
1396 { "sbbB", { AL
, Ib
} },
1397 { "sbbS", { eAX
, Iv
} },
1398 { X86_64_TABLE (X86_64_1E
) },
1399 { X86_64_TABLE (X86_64_1F
) },
1401 { "andB", { Eb
, Gb
} },
1402 { "andS", { Ev
, Gv
} },
1403 { "andB", { Gb
, EbS
} },
1404 { "andS", { Gv
, EvS
} },
1405 { "andB", { AL
, Ib
} },
1406 { "andS", { eAX
, Iv
} },
1407 { "(bad)", { XX
} }, /* SEG ES prefix */
1408 { X86_64_TABLE (X86_64_27
) },
1410 { "subB", { Eb
, Gb
} },
1411 { "subS", { Ev
, Gv
} },
1412 { "subB", { Gb
, EbS
} },
1413 { "subS", { Gv
, EvS
} },
1414 { "subB", { AL
, Ib
} },
1415 { "subS", { eAX
, Iv
} },
1416 { "(bad)", { XX
} }, /* SEG CS prefix */
1417 { X86_64_TABLE (X86_64_2F
) },
1419 { "xorB", { Eb
, Gb
} },
1420 { "xorS", { Ev
, Gv
} },
1421 { "xorB", { Gb
, EbS
} },
1422 { "xorS", { Gv
, EvS
} },
1423 { "xorB", { AL
, Ib
} },
1424 { "xorS", { eAX
, Iv
} },
1425 { "(bad)", { XX
} }, /* SEG SS prefix */
1426 { X86_64_TABLE (X86_64_37
) },
1428 { "cmpB", { Eb
, Gb
} },
1429 { "cmpS", { Ev
, Gv
} },
1430 { "cmpB", { Gb
, EbS
} },
1431 { "cmpS", { Gv
, EvS
} },
1432 { "cmpB", { AL
, Ib
} },
1433 { "cmpS", { eAX
, Iv
} },
1434 { "(bad)", { XX
} }, /* SEG DS prefix */
1435 { X86_64_TABLE (X86_64_3F
) },
1437 { "inc{S|}", { RMeAX
} },
1438 { "inc{S|}", { RMeCX
} },
1439 { "inc{S|}", { RMeDX
} },
1440 { "inc{S|}", { RMeBX
} },
1441 { "inc{S|}", { RMeSP
} },
1442 { "inc{S|}", { RMeBP
} },
1443 { "inc{S|}", { RMeSI
} },
1444 { "inc{S|}", { RMeDI
} },
1446 { "dec{S|}", { RMeAX
} },
1447 { "dec{S|}", { RMeCX
} },
1448 { "dec{S|}", { RMeDX
} },
1449 { "dec{S|}", { RMeBX
} },
1450 { "dec{S|}", { RMeSP
} },
1451 { "dec{S|}", { RMeBP
} },
1452 { "dec{S|}", { RMeSI
} },
1453 { "dec{S|}", { RMeDI
} },
1455 { "pushV", { RMrAX
} },
1456 { "pushV", { RMrCX
} },
1457 { "pushV", { RMrDX
} },
1458 { "pushV", { RMrBX
} },
1459 { "pushV", { RMrSP
} },
1460 { "pushV", { RMrBP
} },
1461 { "pushV", { RMrSI
} },
1462 { "pushV", { RMrDI
} },
1464 { "popV", { RMrAX
} },
1465 { "popV", { RMrCX
} },
1466 { "popV", { RMrDX
} },
1467 { "popV", { RMrBX
} },
1468 { "popV", { RMrSP
} },
1469 { "popV", { RMrBP
} },
1470 { "popV", { RMrSI
} },
1471 { "popV", { RMrDI
} },
1473 { X86_64_TABLE (X86_64_60
) },
1474 { X86_64_TABLE (X86_64_61
) },
1475 { X86_64_TABLE (X86_64_62
) },
1476 { X86_64_TABLE (X86_64_63
) },
1477 { "(bad)", { XX
} }, /* seg fs */
1478 { "(bad)", { XX
} }, /* seg gs */
1479 { "(bad)", { XX
} }, /* op size prefix */
1480 { "(bad)", { XX
} }, /* adr size prefix */
1482 { "pushT", { Iq
} },
1483 { "imulS", { Gv
, Ev
, Iv
} },
1484 { "pushT", { sIb
} },
1485 { "imulS", { Gv
, Ev
, sIb
} },
1486 { "ins{b|}", { Ybr
, indirDX
} },
1487 { X86_64_TABLE (X86_64_6D
) },
1488 { "outs{b|}", { indirDXr
, Xb
} },
1489 { X86_64_TABLE (X86_64_6F
) },
1491 { "joH", { Jb
, XX
, cond_jump_flag
} },
1492 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1493 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1494 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1495 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1496 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1497 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1498 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1500 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1501 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1502 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1503 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1504 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1505 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1506 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1507 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1509 { REG_TABLE (REG_80
) },
1510 { REG_TABLE (REG_81
) },
1511 { "(bad)", { XX
} },
1512 { REG_TABLE (REG_82
) },
1513 { "testB", { Eb
, Gb
} },
1514 { "testS", { Ev
, Gv
} },
1515 { "xchgB", { Eb
, Gb
} },
1516 { "xchgS", { Ev
, Gv
} },
1518 { "movB", { Eb
, Gb
} },
1519 { "movS", { Ev
, Gv
} },
1520 { "movB", { Gb
, EbS
} },
1521 { "movS", { Gv
, EvS
} },
1522 { "movD", { Sv
, Sw
} },
1523 { MOD_TABLE (MOD_8D
) },
1524 { "movD", { Sw
, Sv
} },
1525 { REG_TABLE (REG_8F
) },
1527 { PREFIX_TABLE (PREFIX_90
) },
1528 { "xchgS", { RMeCX
, eAX
} },
1529 { "xchgS", { RMeDX
, eAX
} },
1530 { "xchgS", { RMeBX
, eAX
} },
1531 { "xchgS", { RMeSP
, eAX
} },
1532 { "xchgS", { RMeBP
, eAX
} },
1533 { "xchgS", { RMeSI
, eAX
} },
1534 { "xchgS", { RMeDI
, eAX
} },
1536 { "cW{t|}R", { XX
} },
1537 { "cR{t|}O", { XX
} },
1538 { X86_64_TABLE (X86_64_9A
) },
1539 { "(bad)", { XX
} }, /* fwait */
1540 { "pushfT", { XX
} },
1541 { "popfT", { XX
} },
1545 { "mov%LB", { AL
, Ob
} },
1546 { "mov%LS", { eAX
, Ov
} },
1547 { "mov%LB", { Ob
, AL
} },
1548 { "mov%LS", { Ov
, eAX
} },
1549 { "movs{b|}", { Ybr
, Xb
} },
1550 { "movs{R|}", { Yvr
, Xv
} },
1551 { "cmps{b|}", { Xb
, Yb
} },
1552 { "cmps{R|}", { Xv
, Yv
} },
1554 { "testB", { AL
, Ib
} },
1555 { "testS", { eAX
, Iv
} },
1556 { "stosB", { Ybr
, AL
} },
1557 { "stosS", { Yvr
, eAX
} },
1558 { "lodsB", { ALr
, Xb
} },
1559 { "lodsS", { eAXr
, Xv
} },
1560 { "scasB", { AL
, Yb
} },
1561 { "scasS", { eAX
, Yv
} },
1563 { "movB", { RMAL
, Ib
} },
1564 { "movB", { RMCL
, Ib
} },
1565 { "movB", { RMDL
, Ib
} },
1566 { "movB", { RMBL
, Ib
} },
1567 { "movB", { RMAH
, Ib
} },
1568 { "movB", { RMCH
, Ib
} },
1569 { "movB", { RMDH
, Ib
} },
1570 { "movB", { RMBH
, Ib
} },
1572 { "mov%LV", { RMeAX
, Iv64
} },
1573 { "mov%LV", { RMeCX
, Iv64
} },
1574 { "mov%LV", { RMeDX
, Iv64
} },
1575 { "mov%LV", { RMeBX
, Iv64
} },
1576 { "mov%LV", { RMeSP
, Iv64
} },
1577 { "mov%LV", { RMeBP
, Iv64
} },
1578 { "mov%LV", { RMeSI
, Iv64
} },
1579 { "mov%LV", { RMeDI
, Iv64
} },
1581 { REG_TABLE (REG_C0
) },
1582 { REG_TABLE (REG_C1
) },
1585 { X86_64_TABLE (X86_64_C4
) },
1586 { X86_64_TABLE (X86_64_C5
) },
1587 { REG_TABLE (REG_C6
) },
1588 { REG_TABLE (REG_C7
) },
1590 { "enterT", { Iw
, Ib
} },
1591 { "leaveT", { XX
} },
1592 { "Jret{|f}P", { Iw
} },
1593 { "Jret{|f}P", { XX
} },
1596 { X86_64_TABLE (X86_64_CE
) },
1597 { "iretP", { XX
} },
1599 { REG_TABLE (REG_D0
) },
1600 { REG_TABLE (REG_D1
) },
1601 { REG_TABLE (REG_D2
) },
1602 { REG_TABLE (REG_D3
) },
1603 { X86_64_TABLE (X86_64_D4
) },
1604 { X86_64_TABLE (X86_64_D5
) },
1605 { "(bad)", { XX
} },
1606 { "xlat", { DSBX
} },
1617 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1618 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1619 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1620 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1621 { "inB", { AL
, Ib
} },
1622 { "inG", { zAX
, Ib
} },
1623 { "outB", { Ib
, AL
} },
1624 { "outG", { Ib
, zAX
} },
1626 { "callT", { Jv
} },
1628 { X86_64_TABLE (X86_64_EA
) },
1630 { "inB", { AL
, indirDX
} },
1631 { "inG", { zAX
, indirDX
} },
1632 { "outB", { indirDX
, AL
} },
1633 { "outG", { indirDX
, zAX
} },
1635 { "(bad)", { XX
} }, /* lock prefix */
1636 { "icebp", { XX
} },
1637 { "(bad)", { XX
} }, /* repne */
1638 { "(bad)", { XX
} }, /* repz */
1641 { REG_TABLE (REG_F6
) },
1642 { REG_TABLE (REG_F7
) },
1650 { REG_TABLE (REG_FE
) },
1651 { REG_TABLE (REG_FF
) },
1654 static const struct dis386 dis386_twobyte
[] = {
1656 { REG_TABLE (REG_0F00
) },
1657 { REG_TABLE (REG_0F01
) },
1658 { "larS", { Gv
, Ew
} },
1659 { "lslS", { Gv
, Ew
} },
1660 { "(bad)", { XX
} },
1661 { "syscall", { XX
} },
1663 { "sysretP", { XX
} },
1666 { "wbinvd", { XX
} },
1667 { "(bad)", { XX
} },
1669 { "(bad)", { XX
} },
1670 { REG_TABLE (REG_0F0D
) },
1671 { "femms", { XX
} },
1672 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1674 { PREFIX_TABLE (PREFIX_0F10
) },
1675 { PREFIX_TABLE (PREFIX_0F11
) },
1676 { PREFIX_TABLE (PREFIX_0F12
) },
1677 { MOD_TABLE (MOD_0F13
) },
1678 { "unpcklpX", { XM
, EXx
} },
1679 { "unpckhpX", { XM
, EXx
} },
1680 { PREFIX_TABLE (PREFIX_0F16
) },
1681 { MOD_TABLE (MOD_0F17
) },
1683 { REG_TABLE (REG_0F18
) },
1692 { MOD_TABLE (MOD_0F20
) },
1693 { MOD_TABLE (MOD_0F21
) },
1694 { MOD_TABLE (MOD_0F22
) },
1695 { MOD_TABLE (MOD_0F23
) },
1696 { MOD_TABLE (MOD_0F24
) },
1697 { "(bad)", { XX
} },
1698 { MOD_TABLE (MOD_0F26
) },
1699 { "(bad)", { XX
} },
1701 { "movapX", { XM
, EXx
} },
1702 { "movapX", { EXxS
, XM
} },
1703 { PREFIX_TABLE (PREFIX_0F2A
) },
1704 { PREFIX_TABLE (PREFIX_0F2B
) },
1705 { PREFIX_TABLE (PREFIX_0F2C
) },
1706 { PREFIX_TABLE (PREFIX_0F2D
) },
1707 { PREFIX_TABLE (PREFIX_0F2E
) },
1708 { PREFIX_TABLE (PREFIX_0F2F
) },
1710 { "wrmsr", { XX
} },
1711 { "rdtsc", { XX
} },
1712 { "rdmsr", { XX
} },
1713 { "rdpmc", { XX
} },
1714 { "sysenter", { XX
} },
1715 { "sysexit", { XX
} },
1716 { "(bad)", { XX
} },
1717 { "getsec", { XX
} },
1719 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
1720 { "(bad)", { XX
} },
1721 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
1722 { "(bad)", { XX
} },
1723 { "(bad)", { XX
} },
1724 { "(bad)", { XX
} },
1725 { "(bad)", { XX
} },
1726 { "(bad)", { XX
} },
1728 { "cmovoS", { Gv
, Ev
} },
1729 { "cmovnoS", { Gv
, Ev
} },
1730 { "cmovbS", { Gv
, Ev
} },
1731 { "cmovaeS", { Gv
, Ev
} },
1732 { "cmoveS", { Gv
, Ev
} },
1733 { "cmovneS", { Gv
, Ev
} },
1734 { "cmovbeS", { Gv
, Ev
} },
1735 { "cmovaS", { Gv
, Ev
} },
1737 { "cmovsS", { Gv
, Ev
} },
1738 { "cmovnsS", { Gv
, Ev
} },
1739 { "cmovpS", { Gv
, Ev
} },
1740 { "cmovnpS", { Gv
, Ev
} },
1741 { "cmovlS", { Gv
, Ev
} },
1742 { "cmovgeS", { Gv
, Ev
} },
1743 { "cmovleS", { Gv
, Ev
} },
1744 { "cmovgS", { Gv
, Ev
} },
1746 { MOD_TABLE (MOD_0F51
) },
1747 { PREFIX_TABLE (PREFIX_0F51
) },
1748 { PREFIX_TABLE (PREFIX_0F52
) },
1749 { PREFIX_TABLE (PREFIX_0F53
) },
1750 { "andpX", { XM
, EXx
} },
1751 { "andnpX", { XM
, EXx
} },
1752 { "orpX", { XM
, EXx
} },
1753 { "xorpX", { XM
, EXx
} },
1755 { PREFIX_TABLE (PREFIX_0F58
) },
1756 { PREFIX_TABLE (PREFIX_0F59
) },
1757 { PREFIX_TABLE (PREFIX_0F5A
) },
1758 { PREFIX_TABLE (PREFIX_0F5B
) },
1759 { PREFIX_TABLE (PREFIX_0F5C
) },
1760 { PREFIX_TABLE (PREFIX_0F5D
) },
1761 { PREFIX_TABLE (PREFIX_0F5E
) },
1762 { PREFIX_TABLE (PREFIX_0F5F
) },
1764 { PREFIX_TABLE (PREFIX_0F60
) },
1765 { PREFIX_TABLE (PREFIX_0F61
) },
1766 { PREFIX_TABLE (PREFIX_0F62
) },
1767 { "packsswb", { MX
, EM
} },
1768 { "pcmpgtb", { MX
, EM
} },
1769 { "pcmpgtw", { MX
, EM
} },
1770 { "pcmpgtd", { MX
, EM
} },
1771 { "packuswb", { MX
, EM
} },
1773 { "punpckhbw", { MX
, EM
} },
1774 { "punpckhwd", { MX
, EM
} },
1775 { "punpckhdq", { MX
, EM
} },
1776 { "packssdw", { MX
, EM
} },
1777 { PREFIX_TABLE (PREFIX_0F6C
) },
1778 { PREFIX_TABLE (PREFIX_0F6D
) },
1779 { "movK", { MX
, Edq
} },
1780 { PREFIX_TABLE (PREFIX_0F6F
) },
1782 { PREFIX_TABLE (PREFIX_0F70
) },
1783 { REG_TABLE (REG_0F71
) },
1784 { REG_TABLE (REG_0F72
) },
1785 { REG_TABLE (REG_0F73
) },
1786 { "pcmpeqb", { MX
, EM
} },
1787 { "pcmpeqw", { MX
, EM
} },
1788 { "pcmpeqd", { MX
, EM
} },
1791 { PREFIX_TABLE (PREFIX_0F78
) },
1792 { PREFIX_TABLE (PREFIX_0F79
) },
1793 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
1794 { "(bad)", { XX
} },
1795 { PREFIX_TABLE (PREFIX_0F7C
) },
1796 { PREFIX_TABLE (PREFIX_0F7D
) },
1797 { PREFIX_TABLE (PREFIX_0F7E
) },
1798 { PREFIX_TABLE (PREFIX_0F7F
) },
1800 { "joH", { Jv
, XX
, cond_jump_flag
} },
1801 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
1802 { "jbH", { Jv
, XX
, cond_jump_flag
} },
1803 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
1804 { "jeH", { Jv
, XX
, cond_jump_flag
} },
1805 { "jneH", { Jv
, XX
, cond_jump_flag
} },
1806 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
1807 { "jaH", { Jv
, XX
, cond_jump_flag
} },
1809 { "jsH", { Jv
, XX
, cond_jump_flag
} },
1810 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
1811 { "jpH", { Jv
, XX
, cond_jump_flag
} },
1812 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
1813 { "jlH", { Jv
, XX
, cond_jump_flag
} },
1814 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
1815 { "jleH", { Jv
, XX
, cond_jump_flag
} },
1816 { "jgH", { Jv
, XX
, cond_jump_flag
} },
1819 { "setno", { Eb
} },
1821 { "setae", { Eb
} },
1823 { "setne", { Eb
} },
1824 { "setbe", { Eb
} },
1828 { "setns", { Eb
} },
1830 { "setnp", { Eb
} },
1832 { "setge", { Eb
} },
1833 { "setle", { Eb
} },
1836 { "pushT", { fs
} },
1838 { "cpuid", { XX
} },
1839 { "btS", { Ev
, Gv
} },
1840 { "shldS", { Ev
, Gv
, Ib
} },
1841 { "shldS", { Ev
, Gv
, CL
} },
1842 { REG_TABLE (REG_0FA6
) },
1843 { REG_TABLE (REG_0FA7
) },
1845 { "pushT", { gs
} },
1848 { "btsS", { Ev
, Gv
} },
1849 { "shrdS", { Ev
, Gv
, Ib
} },
1850 { "shrdS", { Ev
, Gv
, CL
} },
1851 { REG_TABLE (REG_0FAE
) },
1852 { "imulS", { Gv
, Ev
} },
1854 { "cmpxchgB", { Eb
, Gb
} },
1855 { "cmpxchgS", { Ev
, Gv
} },
1856 { MOD_TABLE (MOD_0FB2
) },
1857 { "btrS", { Ev
, Gv
} },
1858 { MOD_TABLE (MOD_0FB4
) },
1859 { MOD_TABLE (MOD_0FB5
) },
1860 { "movz{bR|x}", { Gv
, Eb
} },
1861 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
1863 { PREFIX_TABLE (PREFIX_0FB8
) },
1865 { REG_TABLE (REG_0FBA
) },
1866 { "btcS", { Ev
, Gv
} },
1867 { "bsfS", { Gv
, Ev
} },
1868 { PREFIX_TABLE (PREFIX_0FBD
) },
1869 { "movs{bR|x}", { Gv
, Eb
} },
1870 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
1872 { "xaddB", { Eb
, Gb
} },
1873 { "xaddS", { Ev
, Gv
} },
1874 { PREFIX_TABLE (PREFIX_0FC2
) },
1875 { PREFIX_TABLE (PREFIX_0FC3
) },
1876 { "pinsrw", { MX
, Edqw
, Ib
} },
1877 { "pextrw", { Gdq
, MS
, Ib
} },
1878 { "shufpX", { XM
, EXx
, Ib
} },
1879 { REG_TABLE (REG_0FC7
) },
1881 { "bswap", { RMeAX
} },
1882 { "bswap", { RMeCX
} },
1883 { "bswap", { RMeDX
} },
1884 { "bswap", { RMeBX
} },
1885 { "bswap", { RMeSP
} },
1886 { "bswap", { RMeBP
} },
1887 { "bswap", { RMeSI
} },
1888 { "bswap", { RMeDI
} },
1890 { PREFIX_TABLE (PREFIX_0FD0
) },
1891 { "psrlw", { MX
, EM
} },
1892 { "psrld", { MX
, EM
} },
1893 { "psrlq", { MX
, EM
} },
1894 { "paddq", { MX
, EM
} },
1895 { "pmullw", { MX
, EM
} },
1896 { PREFIX_TABLE (PREFIX_0FD6
) },
1897 { MOD_TABLE (MOD_0FD7
) },
1899 { "psubusb", { MX
, EM
} },
1900 { "psubusw", { MX
, EM
} },
1901 { "pminub", { MX
, EM
} },
1902 { "pand", { MX
, EM
} },
1903 { "paddusb", { MX
, EM
} },
1904 { "paddusw", { MX
, EM
} },
1905 { "pmaxub", { MX
, EM
} },
1906 { "pandn", { MX
, EM
} },
1908 { "pavgb", { MX
, EM
} },
1909 { "psraw", { MX
, EM
} },
1910 { "psrad", { MX
, EM
} },
1911 { "pavgw", { MX
, EM
} },
1912 { "pmulhuw", { MX
, EM
} },
1913 { "pmulhw", { MX
, EM
} },
1914 { PREFIX_TABLE (PREFIX_0FE6
) },
1915 { PREFIX_TABLE (PREFIX_0FE7
) },
1917 { "psubsb", { MX
, EM
} },
1918 { "psubsw", { MX
, EM
} },
1919 { "pminsw", { MX
, EM
} },
1920 { "por", { MX
, EM
} },
1921 { "paddsb", { MX
, EM
} },
1922 { "paddsw", { MX
, EM
} },
1923 { "pmaxsw", { MX
, EM
} },
1924 { "pxor", { MX
, EM
} },
1926 { PREFIX_TABLE (PREFIX_0FF0
) },
1927 { "psllw", { MX
, EM
} },
1928 { "pslld", { MX
, EM
} },
1929 { "psllq", { MX
, EM
} },
1930 { "pmuludq", { MX
, EM
} },
1931 { "pmaddwd", { MX
, EM
} },
1932 { "psadbw", { MX
, EM
} },
1933 { PREFIX_TABLE (PREFIX_0FF7
) },
1935 { "psubb", { MX
, EM
} },
1936 { "psubw", { MX
, EM
} },
1937 { "psubd", { MX
, EM
} },
1938 { "psubq", { MX
, EM
} },
1939 { "paddb", { MX
, EM
} },
1940 { "paddw", { MX
, EM
} },
1941 { "paddd", { MX
, EM
} },
1942 { "(bad)", { XX
} },
1945 static const unsigned char onebyte_has_modrm
[256] = {
1946 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1947 /* ------------------------------- */
1948 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1949 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1950 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1951 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1952 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1953 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1954 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1955 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1956 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1957 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1958 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1959 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1960 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1961 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1962 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1963 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1964 /* ------------------------------- */
1965 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1968 static const unsigned char twobyte_has_modrm
[256] = {
1969 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1970 /* ------------------------------- */
1971 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1972 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
1973 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1974 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1975 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1976 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1977 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1978 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1979 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1980 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1981 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1982 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1983 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1984 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1985 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1986 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1987 /* ------------------------------- */
1988 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1991 static char obuf
[100];
1993 static char *mnemonicendp
;
1994 static char scratchbuf
[100];
1995 static unsigned char *start_codep
;
1996 static unsigned char *insn_codep
;
1997 static unsigned char *codep
;
1998 static int last_lock_prefix
;
1999 static int last_repz_prefix
;
2000 static int last_repnz_prefix
;
2001 static int last_data_prefix
;
2002 static int last_addr_prefix
;
2003 static int last_rex_prefix
;
2004 static int last_seg_prefix
;
2005 #define MAX_CODE_LENGTH 15
2006 /* We can up to 14 prefixes since the maximum instruction length is
2008 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2009 static disassemble_info
*the_info
;
2017 static unsigned char need_modrm
;
2020 int register_specifier
;
2026 static unsigned char need_vex
;
2027 static unsigned char need_vex_reg
;
2028 static unsigned char vex_w_done
;
2036 /* If we are accessing mod/rm/reg without need_modrm set, then the
2037 values are stale. Hitting this abort likely indicates that you
2038 need to update onebyte_has_modrm or twobyte_has_modrm. */
2039 #define MODRM_CHECK if (!need_modrm) abort ()
2041 static const char **names64
;
2042 static const char **names32
;
2043 static const char **names16
;
2044 static const char **names8
;
2045 static const char **names8rex
;
2046 static const char **names_seg
;
2047 static const char *index64
;
2048 static const char *index32
;
2049 static const char **index16
;
2051 static const char *intel_names64
[] = {
2052 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2053 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2055 static const char *intel_names32
[] = {
2056 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2057 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2059 static const char *intel_names16
[] = {
2060 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2061 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2063 static const char *intel_names8
[] = {
2064 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2066 static const char *intel_names8rex
[] = {
2067 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2068 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2070 static const char *intel_names_seg
[] = {
2071 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2073 static const char *intel_index64
= "riz";
2074 static const char *intel_index32
= "eiz";
2075 static const char *intel_index16
[] = {
2076 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2079 static const char *att_names64
[] = {
2080 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2081 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2083 static const char *att_names32
[] = {
2084 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2085 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2087 static const char *att_names16
[] = {
2088 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2089 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2091 static const char *att_names8
[] = {
2092 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2094 static const char *att_names8rex
[] = {
2095 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2096 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2098 static const char *att_names_seg
[] = {
2099 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2101 static const char *att_index64
= "%riz";
2102 static const char *att_index32
= "%eiz";
2103 static const char *att_index16
[] = {
2104 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2107 static const struct dis386 reg_table
[][8] = {
2110 { "addA", { Eb
, Ib
} },
2111 { "orA", { Eb
, Ib
} },
2112 { "adcA", { Eb
, Ib
} },
2113 { "sbbA", { Eb
, Ib
} },
2114 { "andA", { Eb
, Ib
} },
2115 { "subA", { Eb
, Ib
} },
2116 { "xorA", { Eb
, Ib
} },
2117 { "cmpA", { Eb
, Ib
} },
2121 { "addQ", { Ev
, Iv
} },
2122 { "orQ", { Ev
, Iv
} },
2123 { "adcQ", { Ev
, Iv
} },
2124 { "sbbQ", { Ev
, Iv
} },
2125 { "andQ", { Ev
, Iv
} },
2126 { "subQ", { Ev
, Iv
} },
2127 { "xorQ", { Ev
, Iv
} },
2128 { "cmpQ", { Ev
, Iv
} },
2132 { "addQ", { Ev
, sIb
} },
2133 { "orQ", { Ev
, sIb
} },
2134 { "adcQ", { Ev
, sIb
} },
2135 { "sbbQ", { Ev
, sIb
} },
2136 { "andQ", { Ev
, sIb
} },
2137 { "subQ", { Ev
, sIb
} },
2138 { "xorQ", { Ev
, sIb
} },
2139 { "cmpQ", { Ev
, sIb
} },
2143 { "popU", { stackEv
} },
2144 { XOP_8F_TABLE (XOP_09
) },
2145 { "(bad)", { XX
} },
2146 { "(bad)", { XX
} },
2147 { "(bad)", { XX
} },
2148 { XOP_8F_TABLE (XOP_09
) },
2149 { "(bad)", { XX
} },
2150 { "(bad)", { XX
} },
2154 { "rolA", { Eb
, Ib
} },
2155 { "rorA", { Eb
, Ib
} },
2156 { "rclA", { Eb
, Ib
} },
2157 { "rcrA", { Eb
, Ib
} },
2158 { "shlA", { Eb
, Ib
} },
2159 { "shrA", { Eb
, Ib
} },
2160 { "(bad)", { XX
} },
2161 { "sarA", { Eb
, Ib
} },
2165 { "rolQ", { Ev
, Ib
} },
2166 { "rorQ", { Ev
, Ib
} },
2167 { "rclQ", { Ev
, Ib
} },
2168 { "rcrQ", { Ev
, Ib
} },
2169 { "shlQ", { Ev
, Ib
} },
2170 { "shrQ", { Ev
, Ib
} },
2171 { "(bad)", { XX
} },
2172 { "sarQ", { Ev
, Ib
} },
2176 { "movA", { Eb
, Ib
} },
2177 { "(bad)", { XX
} },
2178 { "(bad)", { XX
} },
2179 { "(bad)", { XX
} },
2180 { "(bad)", { XX
} },
2181 { "(bad)", { XX
} },
2182 { "(bad)", { XX
} },
2183 { "(bad)", { XX
} },
2187 { "movQ", { Ev
, Iv
} },
2188 { "(bad)", { XX
} },
2189 { "(bad)", { XX
} },
2190 { "(bad)", { XX
} },
2191 { "(bad)", { XX
} },
2192 { "(bad)", { XX
} },
2193 { "(bad)", { XX
} },
2194 { "(bad)", { XX
} },
2198 { "rolA", { Eb
, I1
} },
2199 { "rorA", { Eb
, I1
} },
2200 { "rclA", { Eb
, I1
} },
2201 { "rcrA", { Eb
, I1
} },
2202 { "shlA", { Eb
, I1
} },
2203 { "shrA", { Eb
, I1
} },
2204 { "(bad)", { XX
} },
2205 { "sarA", { Eb
, I1
} },
2209 { "rolQ", { Ev
, I1
} },
2210 { "rorQ", { Ev
, I1
} },
2211 { "rclQ", { Ev
, I1
} },
2212 { "rcrQ", { Ev
, I1
} },
2213 { "shlQ", { Ev
, I1
} },
2214 { "shrQ", { Ev
, I1
} },
2215 { "(bad)", { XX
} },
2216 { "sarQ", { Ev
, I1
} },
2220 { "rolA", { Eb
, CL
} },
2221 { "rorA", { Eb
, CL
} },
2222 { "rclA", { Eb
, CL
} },
2223 { "rcrA", { Eb
, CL
} },
2224 { "shlA", { Eb
, CL
} },
2225 { "shrA", { Eb
, CL
} },
2226 { "(bad)", { XX
} },
2227 { "sarA", { Eb
, CL
} },
2231 { "rolQ", { Ev
, CL
} },
2232 { "rorQ", { Ev
, CL
} },
2233 { "rclQ", { Ev
, CL
} },
2234 { "rcrQ", { Ev
, CL
} },
2235 { "shlQ", { Ev
, CL
} },
2236 { "shrQ", { Ev
, CL
} },
2237 { "(bad)", { XX
} },
2238 { "sarQ", { Ev
, CL
} },
2242 { "testA", { Eb
, Ib
} },
2243 { "(bad)", { XX
} },
2246 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2247 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2248 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2249 { "idivA", { Eb
} }, /* and idiv for consistency. */
2253 { "testQ", { Ev
, Iv
} },
2254 { "(bad)", { XX
} },
2257 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2258 { "imulQ", { Ev
} },
2260 { "idivQ", { Ev
} },
2266 { "(bad)", { XX
} },
2267 { "(bad)", { XX
} },
2268 { "(bad)", { XX
} },
2269 { "(bad)", { XX
} },
2270 { "(bad)", { XX
} },
2271 { "(bad)", { XX
} },
2277 { "callT", { indirEv
} },
2278 { "JcallT", { indirEp
} },
2279 { "jmpT", { indirEv
} },
2280 { "JjmpT", { indirEp
} },
2281 { "pushU", { stackEv
} },
2282 { "(bad)", { XX
} },
2286 { "sldtD", { Sv
} },
2292 { "(bad)", { XX
} },
2293 { "(bad)", { XX
} },
2297 { MOD_TABLE (MOD_0F01_REG_0
) },
2298 { MOD_TABLE (MOD_0F01_REG_1
) },
2299 { MOD_TABLE (MOD_0F01_REG_2
) },
2300 { MOD_TABLE (MOD_0F01_REG_3
) },
2301 { "smswD", { Sv
} },
2302 { "(bad)", { XX
} },
2304 { MOD_TABLE (MOD_0F01_REG_7
) },
2308 { "prefetch", { Eb
} },
2309 { "prefetchw", { Eb
} },
2310 { "(bad)", { XX
} },
2311 { "(bad)", { XX
} },
2312 { "(bad)", { XX
} },
2313 { "(bad)", { XX
} },
2314 { "(bad)", { XX
} },
2315 { "(bad)", { XX
} },
2319 { MOD_TABLE (MOD_0F18_REG_0
) },
2320 { MOD_TABLE (MOD_0F18_REG_1
) },
2321 { MOD_TABLE (MOD_0F18_REG_2
) },
2322 { MOD_TABLE (MOD_0F18_REG_3
) },
2323 { "(bad)", { XX
} },
2324 { "(bad)", { XX
} },
2325 { "(bad)", { XX
} },
2326 { "(bad)", { XX
} },
2330 { "(bad)", { XX
} },
2331 { "(bad)", { XX
} },
2332 { MOD_TABLE (MOD_0F71_REG_2
) },
2333 { "(bad)", { XX
} },
2334 { MOD_TABLE (MOD_0F71_REG_4
) },
2335 { "(bad)", { XX
} },
2336 { MOD_TABLE (MOD_0F71_REG_6
) },
2337 { "(bad)", { XX
} },
2341 { "(bad)", { XX
} },
2342 { "(bad)", { XX
} },
2343 { MOD_TABLE (MOD_0F72_REG_2
) },
2344 { "(bad)", { XX
} },
2345 { MOD_TABLE (MOD_0F72_REG_4
) },
2346 { "(bad)", { XX
} },
2347 { MOD_TABLE (MOD_0F72_REG_6
) },
2348 { "(bad)", { XX
} },
2352 { "(bad)", { XX
} },
2353 { "(bad)", { XX
} },
2354 { MOD_TABLE (MOD_0F73_REG_2
) },
2355 { MOD_TABLE (MOD_0F73_REG_3
) },
2356 { "(bad)", { XX
} },
2357 { "(bad)", { XX
} },
2358 { MOD_TABLE (MOD_0F73_REG_6
) },
2359 { MOD_TABLE (MOD_0F73_REG_7
) },
2363 { "montmul", { { OP_0f07
, 0 } } },
2364 { "xsha1", { { OP_0f07
, 0 } } },
2365 { "xsha256", { { OP_0f07
, 0 } } },
2366 { "(bad)", { { OP_0f07
, 0 } } },
2367 { "(bad)", { { OP_0f07
, 0 } } },
2368 { "(bad)", { { OP_0f07
, 0 } } },
2369 { "(bad)", { { OP_0f07
, 0 } } },
2370 { "(bad)", { { OP_0f07
, 0 } } },
2374 { "xstore-rng", { { OP_0f07
, 0 } } },
2375 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2376 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2377 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2378 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2379 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2380 { "(bad)", { { OP_0f07
, 0 } } },
2381 { "(bad)", { { OP_0f07
, 0 } } },
2385 { MOD_TABLE (MOD_0FAE_REG_0
) },
2386 { MOD_TABLE (MOD_0FAE_REG_1
) },
2387 { MOD_TABLE (MOD_0FAE_REG_2
) },
2388 { MOD_TABLE (MOD_0FAE_REG_3
) },
2389 { MOD_TABLE (MOD_0FAE_REG_4
) },
2390 { MOD_TABLE (MOD_0FAE_REG_5
) },
2391 { MOD_TABLE (MOD_0FAE_REG_6
) },
2392 { MOD_TABLE (MOD_0FAE_REG_7
) },
2396 { "(bad)", { XX
} },
2397 { "(bad)", { XX
} },
2398 { "(bad)", { XX
} },
2399 { "(bad)", { XX
} },
2400 { "btQ", { Ev
, Ib
} },
2401 { "btsQ", { Ev
, Ib
} },
2402 { "btrQ", { Ev
, Ib
} },
2403 { "btcQ", { Ev
, Ib
} },
2407 { "(bad)", { XX
} },
2408 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2409 { "(bad)", { XX
} },
2410 { "(bad)", { XX
} },
2411 { "(bad)", { XX
} },
2412 { "(bad)", { XX
} },
2413 { MOD_TABLE (MOD_0FC7_REG_6
) },
2414 { MOD_TABLE (MOD_0FC7_REG_7
) },
2418 { "(bad)", { XX
} },
2419 { "(bad)", { XX
} },
2420 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2421 { "(bad)", { XX
} },
2422 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2423 { "(bad)", { XX
} },
2424 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2425 { "(bad)", { XX
} },
2429 { "(bad)", { XX
} },
2430 { "(bad)", { XX
} },
2431 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2432 { "(bad)", { XX
} },
2433 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2434 { "(bad)", { XX
} },
2435 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2436 { "(bad)", { XX
} },
2440 { "(bad)", { XX
} },
2441 { "(bad)", { XX
} },
2442 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2443 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2444 { "(bad)", { XX
} },
2445 { "(bad)", { XX
} },
2446 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2447 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2451 { "(bad)", { XX
} },
2452 { "(bad)", { XX
} },
2453 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2454 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2455 { "(bad)", { XX
} },
2456 { "(bad)", { XX
} },
2457 { "(bad)", { XX
} },
2458 { "(bad)", { XX
} },
2462 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2463 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2464 { "(bad)", { XX
} },
2465 { "(bad)", { XX
} },
2466 { "(bad)", { XX
} },
2467 { "(bad)", { XX
} },
2468 { "(bad)", { XX
} },
2469 { "(bad)", { XX
} },
2473 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2474 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2475 { "(bad)", { XX
} },
2476 { "(bad)", { XX
} },
2477 { "(bad)", { XX
} },
2478 { "(bad)", { XX
} },
2479 { "(bad)", { XX
} },
2480 { "(bad)", { XX
} },
2484 static const struct dis386 prefix_table
[][4] = {
2487 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2488 { "pause", { XX
} },
2489 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2490 { "(bad)", { XX
} },
2495 { "movups", { XM
, EXx
} },
2496 { "movss", { XM
, EXd
} },
2497 { "movupd", { XM
, EXx
} },
2498 { "movsd", { XM
, EXq
} },
2503 { "movups", { EXxS
, XM
} },
2504 { "movss", { EXdS
, XM
} },
2505 { "movupd", { EXxS
, XM
} },
2506 { "movsd", { EXqS
, XM
} },
2511 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2512 { "movsldup", { XM
, EXx
} },
2513 { "movlpd", { XM
, EXq
} },
2514 { "movddup", { XM
, EXq
} },
2519 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2520 { "movshdup", { XM
, EXx
} },
2521 { "movhpd", { XM
, EXq
} },
2522 { "(bad)", { XX
} },
2527 { "cvtpi2ps", { XM
, EMCq
} },
2528 { "cvtsi2ss%LQ", { XM
, Ev
} },
2529 { "cvtpi2pd", { XM
, EMCq
} },
2530 { "cvtsi2sd%LQ", { XM
, Ev
} },
2535 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2536 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2537 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2538 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2543 { "cvttps2pi", { MXC
, EXq
} },
2544 { "cvttss2siY", { Gv
, EXd
} },
2545 { "cvttpd2pi", { MXC
, EXx
} },
2546 { "cvttsd2siY", { Gv
, EXq
} },
2551 { "cvtps2pi", { MXC
, EXq
} },
2552 { "cvtss2siY", { Gv
, EXd
} },
2553 { "cvtpd2pi", { MXC
, EXx
} },
2554 { "cvtsd2siY", { Gv
, EXq
} },
2559 { "ucomiss",{ XM
, EXd
} },
2560 { "(bad)", { XX
} },
2561 { "ucomisd",{ XM
, EXq
} },
2562 { "(bad)", { XX
} },
2567 { "comiss", { XM
, EXd
} },
2568 { "(bad)", { XX
} },
2569 { "comisd", { XM
, EXq
} },
2570 { "(bad)", { XX
} },
2575 { "sqrtps", { XM
, EXx
} },
2576 { "sqrtss", { XM
, EXd
} },
2577 { "sqrtpd", { XM
, EXx
} },
2578 { "sqrtsd", { XM
, EXq
} },
2583 { "rsqrtps",{ XM
, EXx
} },
2584 { "rsqrtss",{ XM
, EXd
} },
2585 { "(bad)", { XX
} },
2586 { "(bad)", { XX
} },
2591 { "rcpps", { XM
, EXx
} },
2592 { "rcpss", { XM
, EXd
} },
2593 { "(bad)", { XX
} },
2594 { "(bad)", { XX
} },
2599 { "addps", { XM
, EXx
} },
2600 { "addss", { XM
, EXd
} },
2601 { "addpd", { XM
, EXx
} },
2602 { "addsd", { XM
, EXq
} },
2607 { "mulps", { XM
, EXx
} },
2608 { "mulss", { XM
, EXd
} },
2609 { "mulpd", { XM
, EXx
} },
2610 { "mulsd", { XM
, EXq
} },
2615 { "cvtps2pd", { XM
, EXq
} },
2616 { "cvtss2sd", { XM
, EXd
} },
2617 { "cvtpd2ps", { XM
, EXx
} },
2618 { "cvtsd2ss", { XM
, EXq
} },
2623 { "cvtdq2ps", { XM
, EXx
} },
2624 { "cvttps2dq", { XM
, EXx
} },
2625 { "cvtps2dq", { XM
, EXx
} },
2626 { "(bad)", { XX
} },
2631 { "subps", { XM
, EXx
} },
2632 { "subss", { XM
, EXd
} },
2633 { "subpd", { XM
, EXx
} },
2634 { "subsd", { XM
, EXq
} },
2639 { "minps", { XM
, EXx
} },
2640 { "minss", { XM
, EXd
} },
2641 { "minpd", { XM
, EXx
} },
2642 { "minsd", { XM
, EXq
} },
2647 { "divps", { XM
, EXx
} },
2648 { "divss", { XM
, EXd
} },
2649 { "divpd", { XM
, EXx
} },
2650 { "divsd", { XM
, EXq
} },
2655 { "maxps", { XM
, EXx
} },
2656 { "maxss", { XM
, EXd
} },
2657 { "maxpd", { XM
, EXx
} },
2658 { "maxsd", { XM
, EXq
} },
2663 { "punpcklbw",{ MX
, EMd
} },
2664 { "(bad)", { XX
} },
2665 { "punpcklbw",{ MX
, EMx
} },
2666 { "(bad)", { XX
} },
2671 { "punpcklwd",{ MX
, EMd
} },
2672 { "(bad)", { XX
} },
2673 { "punpcklwd",{ MX
, EMx
} },
2674 { "(bad)", { XX
} },
2679 { "punpckldq",{ MX
, EMd
} },
2680 { "(bad)", { XX
} },
2681 { "punpckldq",{ MX
, EMx
} },
2682 { "(bad)", { XX
} },
2687 { "(bad)", { XX
} },
2688 { "(bad)", { XX
} },
2689 { "punpcklqdq", { XM
, EXx
} },
2690 { "(bad)", { XX
} },
2695 { "(bad)", { XX
} },
2696 { "(bad)", { XX
} },
2697 { "punpckhqdq", { XM
, EXx
} },
2698 { "(bad)", { XX
} },
2703 { "movq", { MX
, EM
} },
2704 { "movdqu", { XM
, EXx
} },
2705 { "movdqa", { XM
, EXx
} },
2706 { "(bad)", { XX
} },
2711 { "pshufw", { MX
, EM
, Ib
} },
2712 { "pshufhw",{ XM
, EXx
, Ib
} },
2713 { "pshufd", { XM
, EXx
, Ib
} },
2714 { "pshuflw",{ XM
, EXx
, Ib
} },
2717 /* PREFIX_0F73_REG_3 */
2719 { "(bad)", { XX
} },
2720 { "(bad)", { XX
} },
2721 { "psrldq", { XS
, Ib
} },
2722 { "(bad)", { XX
} },
2725 /* PREFIX_0F73_REG_7 */
2727 { "(bad)", { XX
} },
2728 { "(bad)", { XX
} },
2729 { "pslldq", { XS
, Ib
} },
2730 { "(bad)", { XX
} },
2735 {"vmread", { Em
, Gm
} },
2737 {"extrq", { XS
, Ib
, Ib
} },
2738 {"insertq", { XM
, XS
, Ib
, Ib
} },
2743 {"vmwrite", { Gm
, Em
} },
2745 {"extrq", { XM
, XS
} },
2746 {"insertq", { XM
, XS
} },
2751 { "(bad)", { XX
} },
2752 { "(bad)", { XX
} },
2753 { "haddpd", { XM
, EXx
} },
2754 { "haddps", { XM
, EXx
} },
2759 { "(bad)", { XX
} },
2760 { "(bad)", { XX
} },
2761 { "hsubpd", { XM
, EXx
} },
2762 { "hsubps", { XM
, EXx
} },
2767 { "movK", { Edq
, MX
} },
2768 { "movq", { XM
, EXq
} },
2769 { "movK", { Edq
, XM
} },
2770 { "(bad)", { XX
} },
2775 { "movq", { EMS
, MX
} },
2776 { "movdqu", { EXxS
, XM
} },
2777 { "movdqa", { EXxS
, XM
} },
2778 { "(bad)", { XX
} },
2783 { "(bad)", { XX
} },
2784 { "popcntS", { Gv
, Ev
} },
2785 { "(bad)", { XX
} },
2786 { "(bad)", { XX
} },
2791 { "bsrS", { Gv
, Ev
} },
2792 { "lzcntS", { Gv
, Ev
} },
2793 { "bsrS", { Gv
, Ev
} },
2794 { "(bad)", { XX
} },
2799 { "cmpps", { XM
, EXx
, CMP
} },
2800 { "cmpss", { XM
, EXd
, CMP
} },
2801 { "cmppd", { XM
, EXx
, CMP
} },
2802 { "cmpsd", { XM
, EXq
, CMP
} },
2807 { "movntiS", { Ma
, Gv
} },
2808 { "(bad)", { XX
} },
2809 { "(bad)", { XX
} },
2810 { "(bad)", { XX
} },
2813 /* PREFIX_0FC7_REG_6 */
2815 { "vmptrld",{ Mq
} },
2816 { "vmxon", { Mq
} },
2817 { "vmclear",{ Mq
} },
2818 { "(bad)", { XX
} },
2823 { "(bad)", { XX
} },
2824 { "(bad)", { XX
} },
2825 { "addsubpd", { XM
, EXx
} },
2826 { "addsubps", { XM
, EXx
} },
2831 { "(bad)", { XX
} },
2832 { "movq2dq",{ XM
, MS
} },
2833 { "movq", { EXqS
, XM
} },
2834 { "movdq2q",{ MX
, XS
} },
2839 { "(bad)", { XX
} },
2840 { "cvtdq2pd", { XM
, EXq
} },
2841 { "cvttpd2dq", { XM
, EXx
} },
2842 { "cvtpd2dq", { XM
, EXx
} },
2847 { "movntq", { Mq
, MX
} },
2848 { "(bad)", { XX
} },
2849 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
2850 { "(bad)", { XX
} },
2855 { "(bad)", { XX
} },
2856 { "(bad)", { XX
} },
2857 { "(bad)", { XX
} },
2858 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
2863 { "maskmovq", { MX
, MS
} },
2864 { "(bad)", { XX
} },
2865 { "maskmovdqu", { XM
, XS
} },
2866 { "(bad)", { XX
} },
2871 { "(bad)", { XX
} },
2872 { "(bad)", { XX
} },
2873 { "pblendvb", { XM
, EXx
, XMM0
} },
2874 { "(bad)", { XX
} },
2879 { "(bad)", { XX
} },
2880 { "(bad)", { XX
} },
2881 { "blendvps", { XM
, EXx
, XMM0
} },
2882 { "(bad)", { XX
} },
2887 { "(bad)", { XX
} },
2888 { "(bad)", { XX
} },
2889 { "blendvpd", { XM
, EXx
, XMM0
} },
2890 { "(bad)", { XX
} },
2895 { "(bad)", { XX
} },
2896 { "(bad)", { XX
} },
2897 { "ptest", { XM
, EXx
} },
2898 { "(bad)", { XX
} },
2903 { "(bad)", { XX
} },
2904 { "(bad)", { XX
} },
2905 { "pmovsxbw", { XM
, EXq
} },
2906 { "(bad)", { XX
} },
2911 { "(bad)", { XX
} },
2912 { "(bad)", { XX
} },
2913 { "pmovsxbd", { XM
, EXd
} },
2914 { "(bad)", { XX
} },
2919 { "(bad)", { XX
} },
2920 { "(bad)", { XX
} },
2921 { "pmovsxbq", { XM
, EXw
} },
2922 { "(bad)", { XX
} },
2927 { "(bad)", { XX
} },
2928 { "(bad)", { XX
} },
2929 { "pmovsxwd", { XM
, EXq
} },
2930 { "(bad)", { XX
} },
2935 { "(bad)", { XX
} },
2936 { "(bad)", { XX
} },
2937 { "pmovsxwq", { XM
, EXd
} },
2938 { "(bad)", { XX
} },
2943 { "(bad)", { XX
} },
2944 { "(bad)", { XX
} },
2945 { "pmovsxdq", { XM
, EXq
} },
2946 { "(bad)", { XX
} },
2951 { "(bad)", { XX
} },
2952 { "(bad)", { XX
} },
2953 { "pmuldq", { XM
, EXx
} },
2954 { "(bad)", { XX
} },
2959 { "(bad)", { XX
} },
2960 { "(bad)", { XX
} },
2961 { "pcmpeqq", { XM
, EXx
} },
2962 { "(bad)", { XX
} },
2967 { "(bad)", { XX
} },
2968 { "(bad)", { XX
} },
2969 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
2970 { "(bad)", { XX
} },
2975 { "(bad)", { XX
} },
2976 { "(bad)", { XX
} },
2977 { "packusdw", { XM
, EXx
} },
2978 { "(bad)", { XX
} },
2983 { "(bad)", { XX
} },
2984 { "(bad)", { XX
} },
2985 { "pmovzxbw", { XM
, EXq
} },
2986 { "(bad)", { XX
} },
2991 { "(bad)", { XX
} },
2992 { "(bad)", { XX
} },
2993 { "pmovzxbd", { XM
, EXd
} },
2994 { "(bad)", { XX
} },
2999 { "(bad)", { XX
} },
3000 { "(bad)", { XX
} },
3001 { "pmovzxbq", { XM
, EXw
} },
3002 { "(bad)", { XX
} },
3007 { "(bad)", { XX
} },
3008 { "(bad)", { XX
} },
3009 { "pmovzxwd", { XM
, EXq
} },
3010 { "(bad)", { XX
} },
3015 { "(bad)", { XX
} },
3016 { "(bad)", { XX
} },
3017 { "pmovzxwq", { XM
, EXd
} },
3018 { "(bad)", { XX
} },
3023 { "(bad)", { XX
} },
3024 { "(bad)", { XX
} },
3025 { "pmovzxdq", { XM
, EXq
} },
3026 { "(bad)", { XX
} },
3031 { "(bad)", { XX
} },
3032 { "(bad)", { XX
} },
3033 { "pcmpgtq", { XM
, EXx
} },
3034 { "(bad)", { XX
} },
3039 { "(bad)", { XX
} },
3040 { "(bad)", { XX
} },
3041 { "pminsb", { XM
, EXx
} },
3042 { "(bad)", { XX
} },
3047 { "(bad)", { XX
} },
3048 { "(bad)", { XX
} },
3049 { "pminsd", { XM
, EXx
} },
3050 { "(bad)", { XX
} },
3055 { "(bad)", { XX
} },
3056 { "(bad)", { XX
} },
3057 { "pminuw", { XM
, EXx
} },
3058 { "(bad)", { XX
} },
3063 { "(bad)", { XX
} },
3064 { "(bad)", { XX
} },
3065 { "pminud", { XM
, EXx
} },
3066 { "(bad)", { XX
} },
3071 { "(bad)", { XX
} },
3072 { "(bad)", { XX
} },
3073 { "pmaxsb", { XM
, EXx
} },
3074 { "(bad)", { XX
} },
3079 { "(bad)", { XX
} },
3080 { "(bad)", { XX
} },
3081 { "pmaxsd", { XM
, EXx
} },
3082 { "(bad)", { XX
} },
3087 { "(bad)", { XX
} },
3088 { "(bad)", { XX
} },
3089 { "pmaxuw", { XM
, EXx
} },
3090 { "(bad)", { XX
} },
3095 { "(bad)", { XX
} },
3096 { "(bad)", { XX
} },
3097 { "pmaxud", { XM
, EXx
} },
3098 { "(bad)", { XX
} },
3103 { "(bad)", { XX
} },
3104 { "(bad)", { XX
} },
3105 { "pmulld", { XM
, EXx
} },
3106 { "(bad)", { XX
} },
3111 { "(bad)", { XX
} },
3112 { "(bad)", { XX
} },
3113 { "phminposuw", { XM
, EXx
} },
3114 { "(bad)", { XX
} },
3119 { "(bad)", { XX
} },
3120 { "(bad)", { XX
} },
3121 { "invept", { Gm
, Mo
} },
3122 { "(bad)", { XX
} },
3127 { "(bad)", { XX
} },
3128 { "(bad)", { XX
} },
3129 { "invvpid", { Gm
, Mo
} },
3130 { "(bad)", { XX
} },
3135 { "(bad)", { XX
} },
3136 { "(bad)", { XX
} },
3137 { "aesimc", { XM
, EXx
} },
3138 { "(bad)", { XX
} },
3143 { "(bad)", { XX
} },
3144 { "(bad)", { XX
} },
3145 { "aesenc", { XM
, EXx
} },
3146 { "(bad)", { XX
} },
3151 { "(bad)", { XX
} },
3152 { "(bad)", { XX
} },
3153 { "aesenclast", { XM
, EXx
} },
3154 { "(bad)", { XX
} },
3159 { "(bad)", { XX
} },
3160 { "(bad)", { XX
} },
3161 { "aesdec", { XM
, EXx
} },
3162 { "(bad)", { XX
} },
3167 { "(bad)", { XX
} },
3168 { "(bad)", { XX
} },
3169 { "aesdeclast", { XM
, EXx
} },
3170 { "(bad)", { XX
} },
3175 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3176 { "(bad)", { XX
} },
3177 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3178 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3183 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3184 { "(bad)", { XX
} },
3185 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3186 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3191 { "(bad)", { XX
} },
3192 { "(bad)", { XX
} },
3193 { "roundps", { XM
, EXx
, Ib
} },
3194 { "(bad)", { XX
} },
3199 { "(bad)", { XX
} },
3200 { "(bad)", { XX
} },
3201 { "roundpd", { XM
, EXx
, Ib
} },
3202 { "(bad)", { XX
} },
3207 { "(bad)", { XX
} },
3208 { "(bad)", { XX
} },
3209 { "roundss", { XM
, EXd
, Ib
} },
3210 { "(bad)", { XX
} },
3215 { "(bad)", { XX
} },
3216 { "(bad)", { XX
} },
3217 { "roundsd", { XM
, EXq
, Ib
} },
3218 { "(bad)", { XX
} },
3223 { "(bad)", { XX
} },
3224 { "(bad)", { XX
} },
3225 { "blendps", { XM
, EXx
, Ib
} },
3226 { "(bad)", { XX
} },
3231 { "(bad)", { XX
} },
3232 { "(bad)", { XX
} },
3233 { "blendpd", { XM
, EXx
, Ib
} },
3234 { "(bad)", { XX
} },
3239 { "(bad)", { XX
} },
3240 { "(bad)", { XX
} },
3241 { "pblendw", { XM
, EXx
, Ib
} },
3242 { "(bad)", { XX
} },
3247 { "(bad)", { XX
} },
3248 { "(bad)", { XX
} },
3249 { "pextrb", { Edqb
, XM
, Ib
} },
3250 { "(bad)", { XX
} },
3255 { "(bad)", { XX
} },
3256 { "(bad)", { XX
} },
3257 { "pextrw", { Edqw
, XM
, Ib
} },
3258 { "(bad)", { XX
} },
3263 { "(bad)", { XX
} },
3264 { "(bad)", { XX
} },
3265 { "pextrK", { Edq
, XM
, Ib
} },
3266 { "(bad)", { XX
} },
3271 { "(bad)", { XX
} },
3272 { "(bad)", { XX
} },
3273 { "extractps", { Edqd
, XM
, Ib
} },
3274 { "(bad)", { XX
} },
3279 { "(bad)", { XX
} },
3280 { "(bad)", { XX
} },
3281 { "pinsrb", { XM
, Edqb
, Ib
} },
3282 { "(bad)", { XX
} },
3287 { "(bad)", { XX
} },
3288 { "(bad)", { XX
} },
3289 { "insertps", { XM
, EXd
, Ib
} },
3290 { "(bad)", { XX
} },
3295 { "(bad)", { XX
} },
3296 { "(bad)", { XX
} },
3297 { "pinsrK", { XM
, Edq
, Ib
} },
3298 { "(bad)", { XX
} },
3303 { "(bad)", { XX
} },
3304 { "(bad)", { XX
} },
3305 { "dpps", { XM
, EXx
, Ib
} },
3306 { "(bad)", { XX
} },
3311 { "(bad)", { XX
} },
3312 { "(bad)", { XX
} },
3313 { "dppd", { XM
, EXx
, Ib
} },
3314 { "(bad)", { XX
} },
3319 { "(bad)", { XX
} },
3320 { "(bad)", { XX
} },
3321 { "mpsadbw", { XM
, EXx
, Ib
} },
3322 { "(bad)", { XX
} },
3327 { "(bad)", { XX
} },
3328 { "(bad)", { XX
} },
3329 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3330 { "(bad)", { XX
} },
3335 { "(bad)", { XX
} },
3336 { "(bad)", { XX
} },
3337 { "pcmpestrm", { XM
, EXx
, Ib
} },
3338 { "(bad)", { XX
} },
3343 { "(bad)", { XX
} },
3344 { "(bad)", { XX
} },
3345 { "pcmpestri", { XM
, EXx
, Ib
} },
3346 { "(bad)", { XX
} },
3351 { "(bad)", { XX
} },
3352 { "(bad)", { XX
} },
3353 { "pcmpistrm", { XM
, EXx
, Ib
} },
3354 { "(bad)", { XX
} },
3359 { "(bad)", { XX
} },
3360 { "(bad)", { XX
} },
3361 { "pcmpistri", { XM
, EXx
, Ib
} },
3362 { "(bad)", { XX
} },
3367 { "(bad)", { XX
} },
3368 { "(bad)", { XX
} },
3369 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3370 { "(bad)", { XX
} },
3375 { "vmovups", { XM
, EXx
} },
3376 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3377 { "vmovupd", { XM
, EXx
} },
3378 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3383 { "vmovups", { EXxS
, XM
} },
3384 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3385 { "vmovupd", { EXxS
, XM
} },
3386 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3391 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3392 { "vmovsldup", { XM
, EXx
} },
3393 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3394 { "vmovddup", { XM
, EXymmq
} },
3399 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3400 { "vmovshdup", { XM
, EXx
} },
3401 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3402 { "(bad)", { XX
} },
3407 { "(bad)", { XX
} },
3408 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3409 { "(bad)", { XX
} },
3410 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3415 { "(bad)", { XX
} },
3416 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3417 { "(bad)", { XX
} },
3418 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3423 { "(bad)", { XX
} },
3424 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3425 { "(bad)", { XX
} },
3426 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3431 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3432 { "(bad)", { XX
} },
3433 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3434 { "(bad)", { XX
} },
3439 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3440 { "(bad)", { XX
} },
3441 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3442 { "(bad)", { XX
} },
3447 { "vsqrtps", { XM
, EXx
} },
3448 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3449 { "vsqrtpd", { XM
, EXx
} },
3450 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3455 { "vrsqrtps", { XM
, EXx
} },
3456 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3457 { "(bad)", { XX
} },
3458 { "(bad)", { XX
} },
3463 { "vrcpps", { XM
, EXx
} },
3464 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3465 { "(bad)", { XX
} },
3466 { "(bad)", { XX
} },
3471 { "vaddps", { XM
, Vex
, EXx
} },
3472 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3473 { "vaddpd", { XM
, Vex
, EXx
} },
3474 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3479 { "vmulps", { XM
, Vex
, EXx
} },
3480 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3481 { "vmulpd", { XM
, Vex
, EXx
} },
3482 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3487 { "vcvtps2pd", { XM
, EXxmmq
} },
3488 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3489 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3490 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3495 { "vcvtdq2ps", { XM
, EXx
} },
3496 { "vcvttps2dq", { XM
, EXx
} },
3497 { "vcvtps2dq", { XM
, EXx
} },
3498 { "(bad)", { XX
} },
3503 { "vsubps", { XM
, Vex
, EXx
} },
3504 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3505 { "vsubpd", { XM
, Vex
, EXx
} },
3506 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3511 { "vminps", { XM
, Vex
, EXx
} },
3512 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3513 { "vminpd", { XM
, Vex
, EXx
} },
3514 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3519 { "vdivps", { XM
, Vex
, EXx
} },
3520 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3521 { "vdivpd", { XM
, Vex
, EXx
} },
3522 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3527 { "vmaxps", { XM
, Vex
, EXx
} },
3528 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3529 { "vmaxpd", { XM
, Vex
, EXx
} },
3530 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3535 { "(bad)", { XX
} },
3536 { "(bad)", { XX
} },
3537 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3538 { "(bad)", { XX
} },
3543 { "(bad)", { XX
} },
3544 { "(bad)", { XX
} },
3545 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3546 { "(bad)", { XX
} },
3551 { "(bad)", { XX
} },
3552 { "(bad)", { XX
} },
3553 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3554 { "(bad)", { XX
} },
3559 { "(bad)", { XX
} },
3560 { "(bad)", { XX
} },
3561 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3562 { "(bad)", { XX
} },
3567 { "(bad)", { XX
} },
3568 { "(bad)", { XX
} },
3569 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3570 { "(bad)", { XX
} },
3575 { "(bad)", { XX
} },
3576 { "(bad)", { XX
} },
3577 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3578 { "(bad)", { XX
} },
3583 { "(bad)", { XX
} },
3584 { "(bad)", { XX
} },
3585 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3586 { "(bad)", { XX
} },
3591 { "(bad)", { XX
} },
3592 { "(bad)", { XX
} },
3593 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3594 { "(bad)", { XX
} },
3599 { "(bad)", { XX
} },
3600 { "(bad)", { XX
} },
3601 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3602 { "(bad)", { XX
} },
3607 { "(bad)", { XX
} },
3608 { "(bad)", { XX
} },
3609 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3610 { "(bad)", { XX
} },
3615 { "(bad)", { XX
} },
3616 { "(bad)", { XX
} },
3617 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3618 { "(bad)", { XX
} },
3623 { "(bad)", { XX
} },
3624 { "(bad)", { XX
} },
3625 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3626 { "(bad)", { XX
} },
3631 { "(bad)", { XX
} },
3632 { "(bad)", { XX
} },
3633 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3634 { "(bad)", { XX
} },
3639 { "(bad)", { XX
} },
3640 { "(bad)", { XX
} },
3641 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3642 { "(bad)", { XX
} },
3647 { "(bad)", { XX
} },
3648 { "(bad)", { XX
} },
3649 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3650 { "(bad)", { XX
} },
3655 { "(bad)", { XX
} },
3656 { "vmovdqu", { XM
, EXx
} },
3657 { "vmovdqa", { XM
, EXx
} },
3658 { "(bad)", { XX
} },
3663 { "(bad)", { XX
} },
3664 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3665 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3666 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3669 /* PREFIX_VEX_71_REG_2 */
3671 { "(bad)", { XX
} },
3672 { "(bad)", { XX
} },
3673 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3674 { "(bad)", { XX
} },
3677 /* PREFIX_VEX_71_REG_4 */
3679 { "(bad)", { XX
} },
3680 { "(bad)", { XX
} },
3681 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3682 { "(bad)", { XX
} },
3685 /* PREFIX_VEX_71_REG_6 */
3687 { "(bad)", { XX
} },
3688 { "(bad)", { XX
} },
3689 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3690 { "(bad)", { XX
} },
3693 /* PREFIX_VEX_72_REG_2 */
3695 { "(bad)", { XX
} },
3696 { "(bad)", { XX
} },
3697 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3698 { "(bad)", { XX
} },
3701 /* PREFIX_VEX_72_REG_4 */
3703 { "(bad)", { XX
} },
3704 { "(bad)", { XX
} },
3705 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3706 { "(bad)", { XX
} },
3709 /* PREFIX_VEX_72_REG_6 */
3711 { "(bad)", { XX
} },
3712 { "(bad)", { XX
} },
3713 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3714 { "(bad)", { XX
} },
3717 /* PREFIX_VEX_73_REG_2 */
3719 { "(bad)", { XX
} },
3720 { "(bad)", { XX
} },
3721 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3722 { "(bad)", { XX
} },
3725 /* PREFIX_VEX_73_REG_3 */
3727 { "(bad)", { XX
} },
3728 { "(bad)", { XX
} },
3729 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3730 { "(bad)", { XX
} },
3733 /* PREFIX_VEX_73_REG_6 */
3735 { "(bad)", { XX
} },
3736 { "(bad)", { XX
} },
3737 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3738 { "(bad)", { XX
} },
3741 /* PREFIX_VEX_73_REG_7 */
3743 { "(bad)", { XX
} },
3744 { "(bad)", { XX
} },
3745 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3746 { "(bad)", { XX
} },
3751 { "(bad)", { XX
} },
3752 { "(bad)", { XX
} },
3753 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3754 { "(bad)", { XX
} },
3759 { "(bad)", { XX
} },
3760 { "(bad)", { XX
} },
3761 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3762 { "(bad)", { XX
} },
3767 { "(bad)", { XX
} },
3768 { "(bad)", { XX
} },
3769 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3770 { "(bad)", { XX
} },
3776 { "(bad)", { XX
} },
3777 { "(bad)", { XX
} },
3778 { "(bad)", { XX
} },
3783 { "(bad)", { XX
} },
3784 { "(bad)", { XX
} },
3785 { "vhaddpd", { XM
, Vex
, EXx
} },
3786 { "vhaddps", { XM
, Vex
, EXx
} },
3791 { "(bad)", { XX
} },
3792 { "(bad)", { XX
} },
3793 { "vhsubpd", { XM
, Vex
, EXx
} },
3794 { "vhsubps", { XM
, Vex
, EXx
} },
3799 { "(bad)", { XX
} },
3800 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3801 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3802 { "(bad)", { XX
} },
3807 { "(bad)", { XX
} },
3808 { "vmovdqu", { EXxS
, XM
} },
3809 { "vmovdqa", { EXxS
, XM
} },
3810 { "(bad)", { XX
} },
3815 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
3816 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3817 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
3818 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3823 { "(bad)", { XX
} },
3824 { "(bad)", { XX
} },
3825 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3826 { "(bad)", { XX
} },
3831 { "(bad)", { XX
} },
3832 { "(bad)", { XX
} },
3833 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3834 { "(bad)", { XX
} },
3839 { "(bad)", { XX
} },
3840 { "(bad)", { XX
} },
3841 { "vaddsubpd", { XM
, Vex
, EXx
} },
3842 { "vaddsubps", { XM
, Vex
, EXx
} },
3847 { "(bad)", { XX
} },
3848 { "(bad)", { XX
} },
3849 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3850 { "(bad)", { XX
} },
3855 { "(bad)", { XX
} },
3856 { "(bad)", { XX
} },
3857 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3858 { "(bad)", { XX
} },
3863 { "(bad)", { XX
} },
3864 { "(bad)", { XX
} },
3865 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
3866 { "(bad)", { XX
} },
3871 { "(bad)", { XX
} },
3872 { "(bad)", { XX
} },
3873 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
3874 { "(bad)", { XX
} },
3879 { "(bad)", { XX
} },
3880 { "(bad)", { XX
} },
3881 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
3882 { "(bad)", { XX
} },
3887 { "(bad)", { XX
} },
3888 { "(bad)", { XX
} },
3889 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
3890 { "(bad)", { XX
} },
3895 { "(bad)", { XX
} },
3896 { "(bad)", { XX
} },
3897 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
3898 { "(bad)", { XX
} },
3903 { "(bad)", { XX
} },
3904 { "(bad)", { XX
} },
3905 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
3906 { "(bad)", { XX
} },
3911 { "(bad)", { XX
} },
3912 { "(bad)", { XX
} },
3913 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
3914 { "(bad)", { XX
} },
3919 { "(bad)", { XX
} },
3920 { "(bad)", { XX
} },
3921 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
3922 { "(bad)", { XX
} },
3927 { "(bad)", { XX
} },
3928 { "(bad)", { XX
} },
3929 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
3930 { "(bad)", { XX
} },
3935 { "(bad)", { XX
} },
3936 { "(bad)", { XX
} },
3937 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
3938 { "(bad)", { XX
} },
3943 { "(bad)", { XX
} },
3944 { "(bad)", { XX
} },
3945 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
3946 { "(bad)", { XX
} },
3951 { "(bad)", { XX
} },
3952 { "(bad)", { XX
} },
3953 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
3954 { "(bad)", { XX
} },
3959 { "(bad)", { XX
} },
3960 { "(bad)", { XX
} },
3961 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
3962 { "(bad)", { XX
} },
3967 { "(bad)", { XX
} },
3968 { "(bad)", { XX
} },
3969 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
3970 { "(bad)", { XX
} },
3975 { "(bad)", { XX
} },
3976 { "(bad)", { XX
} },
3977 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
3978 { "(bad)", { XX
} },
3983 { "(bad)", { XX
} },
3984 { "(bad)", { XX
} },
3985 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
3986 { "(bad)", { XX
} },
3991 { "(bad)", { XX
} },
3992 { "(bad)", { XX
} },
3993 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
3994 { "(bad)", { XX
} },
3999 { "(bad)", { XX
} },
4000 { "(bad)", { XX
} },
4001 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4002 { "(bad)", { XX
} },
4007 { "(bad)", { XX
} },
4008 { "(bad)", { XX
} },
4009 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4010 { "(bad)", { XX
} },
4015 { "(bad)", { XX
} },
4016 { "vcvtdq2pd", { XM
, EXxmmq
} },
4017 { "vcvttpd2dq%XY", { XMM
, EXx
} },
4018 { "vcvtpd2dq%XY", { XMM
, EXx
} },
4023 { "(bad)", { XX
} },
4024 { "(bad)", { XX
} },
4025 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4026 { "(bad)", { XX
} },
4031 { "(bad)", { XX
} },
4032 { "(bad)", { XX
} },
4033 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4034 { "(bad)", { XX
} },
4039 { "(bad)", { XX
} },
4040 { "(bad)", { XX
} },
4041 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4042 { "(bad)", { XX
} },
4047 { "(bad)", { XX
} },
4048 { "(bad)", { XX
} },
4049 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4050 { "(bad)", { XX
} },
4055 { "(bad)", { XX
} },
4056 { "(bad)", { XX
} },
4057 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4058 { "(bad)", { XX
} },
4063 { "(bad)", { XX
} },
4064 { "(bad)", { XX
} },
4065 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4066 { "(bad)", { XX
} },
4071 { "(bad)", { XX
} },
4072 { "(bad)", { XX
} },
4073 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4074 { "(bad)", { XX
} },
4079 { "(bad)", { XX
} },
4080 { "(bad)", { XX
} },
4081 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4082 { "(bad)", { XX
} },
4087 { "(bad)", { XX
} },
4088 { "(bad)", { XX
} },
4089 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4090 { "(bad)", { XX
} },
4095 { "(bad)", { XX
} },
4096 { "(bad)", { XX
} },
4097 { "(bad)", { XX
} },
4098 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4103 { "(bad)", { XX
} },
4104 { "(bad)", { XX
} },
4105 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4106 { "(bad)", { XX
} },
4111 { "(bad)", { XX
} },
4112 { "(bad)", { XX
} },
4113 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4114 { "(bad)", { XX
} },
4119 { "(bad)", { XX
} },
4120 { "(bad)", { XX
} },
4121 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4122 { "(bad)", { XX
} },
4127 { "(bad)", { XX
} },
4128 { "(bad)", { XX
} },
4129 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4130 { "(bad)", { XX
} },
4135 { "(bad)", { XX
} },
4136 { "(bad)", { XX
} },
4137 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4138 { "(bad)", { XX
} },
4143 { "(bad)", { XX
} },
4144 { "(bad)", { XX
} },
4145 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4146 { "(bad)", { XX
} },
4151 { "(bad)", { XX
} },
4152 { "(bad)", { XX
} },
4153 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4154 { "(bad)", { XX
} },
4159 { "(bad)", { XX
} },
4160 { "(bad)", { XX
} },
4161 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4162 { "(bad)", { XX
} },
4167 { "(bad)", { XX
} },
4168 { "(bad)", { XX
} },
4169 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4170 { "(bad)", { XX
} },
4175 { "(bad)", { XX
} },
4176 { "(bad)", { XX
} },
4177 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4178 { "(bad)", { XX
} },
4183 { "(bad)", { XX
} },
4184 { "(bad)", { XX
} },
4185 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4186 { "(bad)", { XX
} },
4191 { "(bad)", { XX
} },
4192 { "(bad)", { XX
} },
4193 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4194 { "(bad)", { XX
} },
4199 { "(bad)", { XX
} },
4200 { "(bad)", { XX
} },
4201 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4202 { "(bad)", { XX
} },
4207 { "(bad)", { XX
} },
4208 { "(bad)", { XX
} },
4209 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4210 { "(bad)", { XX
} },
4213 /* PREFIX_VEX_3800 */
4215 { "(bad)", { XX
} },
4216 { "(bad)", { XX
} },
4217 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4218 { "(bad)", { XX
} },
4221 /* PREFIX_VEX_3801 */
4223 { "(bad)", { XX
} },
4224 { "(bad)", { XX
} },
4225 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4226 { "(bad)", { XX
} },
4229 /* PREFIX_VEX_3802 */
4231 { "(bad)", { XX
} },
4232 { "(bad)", { XX
} },
4233 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4234 { "(bad)", { XX
} },
4237 /* PREFIX_VEX_3803 */
4239 { "(bad)", { XX
} },
4240 { "(bad)", { XX
} },
4241 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4242 { "(bad)", { XX
} },
4245 /* PREFIX_VEX_3804 */
4247 { "(bad)", { XX
} },
4248 { "(bad)", { XX
} },
4249 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4250 { "(bad)", { XX
} },
4253 /* PREFIX_VEX_3805 */
4255 { "(bad)", { XX
} },
4256 { "(bad)", { XX
} },
4257 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4258 { "(bad)", { XX
} },
4261 /* PREFIX_VEX_3806 */
4263 { "(bad)", { XX
} },
4264 { "(bad)", { XX
} },
4265 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4266 { "(bad)", { XX
} },
4269 /* PREFIX_VEX_3807 */
4271 { "(bad)", { XX
} },
4272 { "(bad)", { XX
} },
4273 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4274 { "(bad)", { XX
} },
4277 /* PREFIX_VEX_3808 */
4279 { "(bad)", { XX
} },
4280 { "(bad)", { XX
} },
4281 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4282 { "(bad)", { XX
} },
4285 /* PREFIX_VEX_3809 */
4287 { "(bad)", { XX
} },
4288 { "(bad)", { XX
} },
4289 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4290 { "(bad)", { XX
} },
4293 /* PREFIX_VEX_380A */
4295 { "(bad)", { XX
} },
4296 { "(bad)", { XX
} },
4297 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4298 { "(bad)", { XX
} },
4301 /* PREFIX_VEX_380B */
4303 { "(bad)", { XX
} },
4304 { "(bad)", { XX
} },
4305 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4306 { "(bad)", { XX
} },
4309 /* PREFIX_VEX_380C */
4311 { "(bad)", { XX
} },
4312 { "(bad)", { XX
} },
4313 { "vpermilps", { XM
, Vex
, EXx
} },
4314 { "(bad)", { XX
} },
4317 /* PREFIX_VEX_380D */
4319 { "(bad)", { XX
} },
4320 { "(bad)", { XX
} },
4321 { "vpermilpd", { XM
, Vex
, EXx
} },
4322 { "(bad)", { XX
} },
4325 /* PREFIX_VEX_380E */
4327 { "(bad)", { XX
} },
4328 { "(bad)", { XX
} },
4329 { "vtestps", { XM
, EXx
} },
4330 { "(bad)", { XX
} },
4333 /* PREFIX_VEX_380F */
4335 { "(bad)", { XX
} },
4336 { "(bad)", { XX
} },
4337 { "vtestpd", { XM
, EXx
} },
4338 { "(bad)", { XX
} },
4341 /* PREFIX_VEX_3817 */
4343 { "(bad)", { XX
} },
4344 { "(bad)", { XX
} },
4345 { "vptest", { XM
, EXx
} },
4346 { "(bad)", { XX
} },
4349 /* PREFIX_VEX_3818 */
4351 { "(bad)", { XX
} },
4352 { "(bad)", { XX
} },
4353 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4354 { "(bad)", { XX
} },
4357 /* PREFIX_VEX_3819 */
4359 { "(bad)", { XX
} },
4360 { "(bad)", { XX
} },
4361 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4362 { "(bad)", { XX
} },
4365 /* PREFIX_VEX_381A */
4367 { "(bad)", { XX
} },
4368 { "(bad)", { XX
} },
4369 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4370 { "(bad)", { XX
} },
4373 /* PREFIX_VEX_381C */
4375 { "(bad)", { XX
} },
4376 { "(bad)", { XX
} },
4377 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4378 { "(bad)", { XX
} },
4381 /* PREFIX_VEX_381D */
4383 { "(bad)", { XX
} },
4384 { "(bad)", { XX
} },
4385 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4386 { "(bad)", { XX
} },
4389 /* PREFIX_VEX_381E */
4391 { "(bad)", { XX
} },
4392 { "(bad)", { XX
} },
4393 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4394 { "(bad)", { XX
} },
4397 /* PREFIX_VEX_3820 */
4399 { "(bad)", { XX
} },
4400 { "(bad)", { XX
} },
4401 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4402 { "(bad)", { XX
} },
4405 /* PREFIX_VEX_3821 */
4407 { "(bad)", { XX
} },
4408 { "(bad)", { XX
} },
4409 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4410 { "(bad)", { XX
} },
4413 /* PREFIX_VEX_3822 */
4415 { "(bad)", { XX
} },
4416 { "(bad)", { XX
} },
4417 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4418 { "(bad)", { XX
} },
4421 /* PREFIX_VEX_3823 */
4423 { "(bad)", { XX
} },
4424 { "(bad)", { XX
} },
4425 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4426 { "(bad)", { XX
} },
4429 /* PREFIX_VEX_3824 */
4431 { "(bad)", { XX
} },
4432 { "(bad)", { XX
} },
4433 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4434 { "(bad)", { XX
} },
4437 /* PREFIX_VEX_3825 */
4439 { "(bad)", { XX
} },
4440 { "(bad)", { XX
} },
4441 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4442 { "(bad)", { XX
} },
4445 /* PREFIX_VEX_3828 */
4447 { "(bad)", { XX
} },
4448 { "(bad)", { XX
} },
4449 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4450 { "(bad)", { XX
} },
4453 /* PREFIX_VEX_3829 */
4455 { "(bad)", { XX
} },
4456 { "(bad)", { XX
} },
4457 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4458 { "(bad)", { XX
} },
4461 /* PREFIX_VEX_382A */
4463 { "(bad)", { XX
} },
4464 { "(bad)", { XX
} },
4465 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4466 { "(bad)", { XX
} },
4469 /* PREFIX_VEX_382B */
4471 { "(bad)", { XX
} },
4472 { "(bad)", { XX
} },
4473 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4474 { "(bad)", { XX
} },
4477 /* PREFIX_VEX_382C */
4479 { "(bad)", { XX
} },
4480 { "(bad)", { XX
} },
4481 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4482 { "(bad)", { XX
} },
4485 /* PREFIX_VEX_382D */
4487 { "(bad)", { XX
} },
4488 { "(bad)", { XX
} },
4489 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4490 { "(bad)", { XX
} },
4493 /* PREFIX_VEX_382E */
4495 { "(bad)", { XX
} },
4496 { "(bad)", { XX
} },
4497 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4498 { "(bad)", { XX
} },
4501 /* PREFIX_VEX_382F */
4503 { "(bad)", { XX
} },
4504 { "(bad)", { XX
} },
4505 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4506 { "(bad)", { XX
} },
4509 /* PREFIX_VEX_3830 */
4511 { "(bad)", { XX
} },
4512 { "(bad)", { XX
} },
4513 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4514 { "(bad)", { XX
} },
4517 /* PREFIX_VEX_3831 */
4519 { "(bad)", { XX
} },
4520 { "(bad)", { XX
} },
4521 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4522 { "(bad)", { XX
} },
4525 /* PREFIX_VEX_3832 */
4527 { "(bad)", { XX
} },
4528 { "(bad)", { XX
} },
4529 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4530 { "(bad)", { XX
} },
4533 /* PREFIX_VEX_3833 */
4535 { "(bad)", { XX
} },
4536 { "(bad)", { XX
} },
4537 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4538 { "(bad)", { XX
} },
4541 /* PREFIX_VEX_3834 */
4543 { "(bad)", { XX
} },
4544 { "(bad)", { XX
} },
4545 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4546 { "(bad)", { XX
} },
4549 /* PREFIX_VEX_3835 */
4551 { "(bad)", { XX
} },
4552 { "(bad)", { XX
} },
4553 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4554 { "(bad)", { XX
} },
4557 /* PREFIX_VEX_3837 */
4559 { "(bad)", { XX
} },
4560 { "(bad)", { XX
} },
4561 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4562 { "(bad)", { XX
} },
4565 /* PREFIX_VEX_3838 */
4567 { "(bad)", { XX
} },
4568 { "(bad)", { XX
} },
4569 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4570 { "(bad)", { XX
} },
4573 /* PREFIX_VEX_3839 */
4575 { "(bad)", { XX
} },
4576 { "(bad)", { XX
} },
4577 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4578 { "(bad)", { XX
} },
4581 /* PREFIX_VEX_383A */
4583 { "(bad)", { XX
} },
4584 { "(bad)", { XX
} },
4585 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4586 { "(bad)", { XX
} },
4589 /* PREFIX_VEX_383B */
4591 { "(bad)", { XX
} },
4592 { "(bad)", { XX
} },
4593 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4594 { "(bad)", { XX
} },
4597 /* PREFIX_VEX_383C */
4599 { "(bad)", { XX
} },
4600 { "(bad)", { XX
} },
4601 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4602 { "(bad)", { XX
} },
4605 /* PREFIX_VEX_383D */
4607 { "(bad)", { XX
} },
4608 { "(bad)", { XX
} },
4609 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4610 { "(bad)", { XX
} },
4613 /* PREFIX_VEX_383E */
4615 { "(bad)", { XX
} },
4616 { "(bad)", { XX
} },
4617 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4618 { "(bad)", { XX
} },
4621 /* PREFIX_VEX_383F */
4623 { "(bad)", { XX
} },
4624 { "(bad)", { XX
} },
4625 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4626 { "(bad)", { XX
} },
4629 /* PREFIX_VEX_3840 */
4631 { "(bad)", { XX
} },
4632 { "(bad)", { XX
} },
4633 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4634 { "(bad)", { XX
} },
4637 /* PREFIX_VEX_3841 */
4639 { "(bad)", { XX
} },
4640 { "(bad)", { XX
} },
4641 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4642 { "(bad)", { XX
} },
4645 /* PREFIX_VEX_3896 */
4647 { "(bad)", { XX
} },
4648 { "(bad)", { XX
} },
4649 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4650 { "(bad)", { XX
} },
4653 /* PREFIX_VEX_3897 */
4655 { "(bad)", { XX
} },
4656 { "(bad)", { XX
} },
4657 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4658 { "(bad)", { XX
} },
4661 /* PREFIX_VEX_3898 */
4663 { "(bad)", { XX
} },
4664 { "(bad)", { XX
} },
4665 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4666 { "(bad)", { XX
} },
4669 /* PREFIX_VEX_3899 */
4671 { "(bad)", { XX
} },
4672 { "(bad)", { XX
} },
4673 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4674 { "(bad)", { XX
} },
4677 /* PREFIX_VEX_389A */
4679 { "(bad)", { XX
} },
4680 { "(bad)", { XX
} },
4681 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4682 { "(bad)", { XX
} },
4685 /* PREFIX_VEX_389B */
4687 { "(bad)", { XX
} },
4688 { "(bad)", { XX
} },
4689 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4690 { "(bad)", { XX
} },
4693 /* PREFIX_VEX_389C */
4695 { "(bad)", { XX
} },
4696 { "(bad)", { XX
} },
4697 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4698 { "(bad)", { XX
} },
4701 /* PREFIX_VEX_389D */
4703 { "(bad)", { XX
} },
4704 { "(bad)", { XX
} },
4705 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4706 { "(bad)", { XX
} },
4709 /* PREFIX_VEX_389E */
4711 { "(bad)", { XX
} },
4712 { "(bad)", { XX
} },
4713 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4714 { "(bad)", { XX
} },
4717 /* PREFIX_VEX_389F */
4719 { "(bad)", { XX
} },
4720 { "(bad)", { XX
} },
4721 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4722 { "(bad)", { XX
} },
4725 /* PREFIX_VEX_38A6 */
4727 { "(bad)", { XX
} },
4728 { "(bad)", { XX
} },
4729 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4730 { "(bad)", { XX
} },
4733 /* PREFIX_VEX_38A7 */
4735 { "(bad)", { XX
} },
4736 { "(bad)", { XX
} },
4737 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4738 { "(bad)", { XX
} },
4741 /* PREFIX_VEX_38A8 */
4743 { "(bad)", { XX
} },
4744 { "(bad)", { XX
} },
4745 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4746 { "(bad)", { XX
} },
4749 /* PREFIX_VEX_38A9 */
4751 { "(bad)", { XX
} },
4752 { "(bad)", { XX
} },
4753 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4754 { "(bad)", { XX
} },
4757 /* PREFIX_VEX_38AA */
4759 { "(bad)", { XX
} },
4760 { "(bad)", { XX
} },
4761 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4762 { "(bad)", { XX
} },
4765 /* PREFIX_VEX_38AB */
4767 { "(bad)", { XX
} },
4768 { "(bad)", { XX
} },
4769 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4770 { "(bad)", { XX
} },
4773 /* PREFIX_VEX_38AC */
4775 { "(bad)", { XX
} },
4776 { "(bad)", { XX
} },
4777 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4778 { "(bad)", { XX
} },
4781 /* PREFIX_VEX_38AD */
4783 { "(bad)", { XX
} },
4784 { "(bad)", { XX
} },
4785 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4786 { "(bad)", { XX
} },
4789 /* PREFIX_VEX_38AE */
4791 { "(bad)", { XX
} },
4792 { "(bad)", { XX
} },
4793 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4794 { "(bad)", { XX
} },
4797 /* PREFIX_VEX_38AF */
4799 { "(bad)", { XX
} },
4800 { "(bad)", { XX
} },
4801 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4802 { "(bad)", { XX
} },
4805 /* PREFIX_VEX_38B6 */
4807 { "(bad)", { XX
} },
4808 { "(bad)", { XX
} },
4809 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4810 { "(bad)", { XX
} },
4813 /* PREFIX_VEX_38B7 */
4815 { "(bad)", { XX
} },
4816 { "(bad)", { XX
} },
4817 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4818 { "(bad)", { XX
} },
4821 /* PREFIX_VEX_38B8 */
4823 { "(bad)", { XX
} },
4824 { "(bad)", { XX
} },
4825 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4826 { "(bad)", { XX
} },
4829 /* PREFIX_VEX_38B9 */
4831 { "(bad)", { XX
} },
4832 { "(bad)", { XX
} },
4833 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4834 { "(bad)", { XX
} },
4837 /* PREFIX_VEX_38BA */
4839 { "(bad)", { XX
} },
4840 { "(bad)", { XX
} },
4841 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4842 { "(bad)", { XX
} },
4845 /* PREFIX_VEX_38BB */
4847 { "(bad)", { XX
} },
4848 { "(bad)", { XX
} },
4849 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4850 { "(bad)", { XX
} },
4853 /* PREFIX_VEX_38BC */
4855 { "(bad)", { XX
} },
4856 { "(bad)", { XX
} },
4857 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4858 { "(bad)", { XX
} },
4861 /* PREFIX_VEX_38BD */
4863 { "(bad)", { XX
} },
4864 { "(bad)", { XX
} },
4865 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4866 { "(bad)", { XX
} },
4869 /* PREFIX_VEX_38BE */
4871 { "(bad)", { XX
} },
4872 { "(bad)", { XX
} },
4873 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4874 { "(bad)", { XX
} },
4877 /* PREFIX_VEX_38BF */
4879 { "(bad)", { XX
} },
4880 { "(bad)", { XX
} },
4881 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4882 { "(bad)", { XX
} },
4885 /* PREFIX_VEX_38DB */
4887 { "(bad)", { XX
} },
4888 { "(bad)", { XX
} },
4889 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4890 { "(bad)", { XX
} },
4893 /* PREFIX_VEX_38DC */
4895 { "(bad)", { XX
} },
4896 { "(bad)", { XX
} },
4897 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4898 { "(bad)", { XX
} },
4901 /* PREFIX_VEX_38DD */
4903 { "(bad)", { XX
} },
4904 { "(bad)", { XX
} },
4905 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4906 { "(bad)", { XX
} },
4909 /* PREFIX_VEX_38DE */
4911 { "(bad)", { XX
} },
4912 { "(bad)", { XX
} },
4913 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4914 { "(bad)", { XX
} },
4917 /* PREFIX_VEX_38DF */
4919 { "(bad)", { XX
} },
4920 { "(bad)", { XX
} },
4921 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4922 { "(bad)", { XX
} },
4925 /* PREFIX_VEX_3A04 */
4927 { "(bad)", { XX
} },
4928 { "(bad)", { XX
} },
4929 { "vpermilps", { XM
, EXx
, Ib
} },
4930 { "(bad)", { XX
} },
4933 /* PREFIX_VEX_3A05 */
4935 { "(bad)", { XX
} },
4936 { "(bad)", { XX
} },
4937 { "vpermilpd", { XM
, EXx
, Ib
} },
4938 { "(bad)", { XX
} },
4941 /* PREFIX_VEX_3A06 */
4943 { "(bad)", { XX
} },
4944 { "(bad)", { XX
} },
4945 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4946 { "(bad)", { XX
} },
4949 /* PREFIX_VEX_3A08 */
4951 { "(bad)", { XX
} },
4952 { "(bad)", { XX
} },
4953 { "vroundps", { XM
, EXx
, Ib
} },
4954 { "(bad)", { XX
} },
4957 /* PREFIX_VEX_3A09 */
4959 { "(bad)", { XX
} },
4960 { "(bad)", { XX
} },
4961 { "vroundpd", { XM
, EXx
, Ib
} },
4962 { "(bad)", { XX
} },
4965 /* PREFIX_VEX_3A0A */
4967 { "(bad)", { XX
} },
4968 { "(bad)", { XX
} },
4969 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4970 { "(bad)", { XX
} },
4973 /* PREFIX_VEX_3A0B */
4975 { "(bad)", { XX
} },
4976 { "(bad)", { XX
} },
4977 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4978 { "(bad)", { XX
} },
4981 /* PREFIX_VEX_3A0C */
4983 { "(bad)", { XX
} },
4984 { "(bad)", { XX
} },
4985 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
4986 { "(bad)", { XX
} },
4989 /* PREFIX_VEX_3A0D */
4991 { "(bad)", { XX
} },
4992 { "(bad)", { XX
} },
4993 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
4994 { "(bad)", { XX
} },
4997 /* PREFIX_VEX_3A0E */
4999 { "(bad)", { XX
} },
5000 { "(bad)", { XX
} },
5001 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
5002 { "(bad)", { XX
} },
5005 /* PREFIX_VEX_3A0F */
5007 { "(bad)", { XX
} },
5008 { "(bad)", { XX
} },
5009 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
5010 { "(bad)", { XX
} },
5013 /* PREFIX_VEX_3A14 */
5015 { "(bad)", { XX
} },
5016 { "(bad)", { XX
} },
5017 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5018 { "(bad)", { XX
} },
5021 /* PREFIX_VEX_3A15 */
5023 { "(bad)", { XX
} },
5024 { "(bad)", { XX
} },
5025 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5026 { "(bad)", { XX
} },
5029 /* PREFIX_VEX_3A16 */
5031 { "(bad)", { XX
} },
5032 { "(bad)", { XX
} },
5033 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5034 { "(bad)", { XX
} },
5037 /* PREFIX_VEX_3A17 */
5039 { "(bad)", { XX
} },
5040 { "(bad)", { XX
} },
5041 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5042 { "(bad)", { XX
} },
5045 /* PREFIX_VEX_3A18 */
5047 { "(bad)", { XX
} },
5048 { "(bad)", { XX
} },
5049 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5050 { "(bad)", { XX
} },
5053 /* PREFIX_VEX_3A19 */
5055 { "(bad)", { XX
} },
5056 { "(bad)", { XX
} },
5057 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5058 { "(bad)", { XX
} },
5061 /* PREFIX_VEX_3A20 */
5063 { "(bad)", { XX
} },
5064 { "(bad)", { XX
} },
5065 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5066 { "(bad)", { XX
} },
5069 /* PREFIX_VEX_3A21 */
5071 { "(bad)", { XX
} },
5072 { "(bad)", { XX
} },
5073 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5074 { "(bad)", { XX
} },
5077 /* PREFIX_VEX_3A22 */
5079 { "(bad)", { XX
} },
5080 { "(bad)", { XX
} },
5081 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5082 { "(bad)", { XX
} },
5085 /* PREFIX_VEX_3A40 */
5087 { "(bad)", { XX
} },
5088 { "(bad)", { XX
} },
5089 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
5090 { "(bad)", { XX
} },
5093 /* PREFIX_VEX_3A41 */
5095 { "(bad)", { XX
} },
5096 { "(bad)", { XX
} },
5097 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5098 { "(bad)", { XX
} },
5101 /* PREFIX_VEX_3A42 */
5103 { "(bad)", { XX
} },
5104 { "(bad)", { XX
} },
5105 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5106 { "(bad)", { XX
} },
5109 /* PREFIX_VEX_3A44 */
5111 { "(bad)", { XX
} },
5112 { "(bad)", { XX
} },
5113 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5114 { "(bad)", { XX
} },
5117 /* PREFIX_VEX_3A4A */
5119 { "(bad)", { XX
} },
5120 { "(bad)", { XX
} },
5121 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
5122 { "(bad)", { XX
} },
5125 /* PREFIX_VEX_3A4B */
5127 { "(bad)", { XX
} },
5128 { "(bad)", { XX
} },
5129 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
5130 { "(bad)", { XX
} },
5133 /* PREFIX_VEX_3A4C */
5135 { "(bad)", { XX
} },
5136 { "(bad)", { XX
} },
5137 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5138 { "(bad)", { XX
} },
5141 /* PREFIX_VEX_3A5C */
5143 { "(bad)", { XX
} },
5144 { "(bad)", { XX
} },
5145 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5146 { "(bad)", { XX
} },
5149 /* PREFIX_VEX_3A5D */
5151 { "(bad)", { XX
} },
5152 { "(bad)", { XX
} },
5153 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5154 { "(bad)", { XX
} },
5157 /* PREFIX_VEX_3A5E */
5159 { "(bad)", { XX
} },
5160 { "(bad)", { XX
} },
5161 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5162 { "(bad)", { XX
} },
5165 /* PREFIX_VEX_3A5F */
5167 { "(bad)", { XX
} },
5168 { "(bad)", { XX
} },
5169 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5170 { "(bad)", { XX
} },
5173 /* PREFIX_VEX_3A60 */
5175 { "(bad)", { XX
} },
5176 { "(bad)", { XX
} },
5177 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5178 { "(bad)", { XX
} },
5181 /* PREFIX_VEX_3A61 */
5183 { "(bad)", { XX
} },
5184 { "(bad)", { XX
} },
5185 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5186 { "(bad)", { XX
} },
5189 /* PREFIX_VEX_3A62 */
5191 { "(bad)", { XX
} },
5192 { "(bad)", { XX
} },
5193 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5194 { "(bad)", { XX
} },
5197 /* PREFIX_VEX_3A63 */
5199 { "(bad)", { XX
} },
5200 { "(bad)", { XX
} },
5201 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5202 { "(bad)", { XX
} },
5205 /* PREFIX_VEX_3A68 */
5207 { "(bad)", { XX
} },
5208 { "(bad)", { XX
} },
5209 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5210 { "(bad)", { XX
} },
5213 /* PREFIX_VEX_3A69 */
5215 { "(bad)", { XX
} },
5216 { "(bad)", { XX
} },
5217 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5218 { "(bad)", { XX
} },
5221 /* PREFIX_VEX_3A6A */
5223 { "(bad)", { XX
} },
5224 { "(bad)", { XX
} },
5225 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5226 { "(bad)", { XX
} },
5229 /* PREFIX_VEX_3A6B */
5231 { "(bad)", { XX
} },
5232 { "(bad)", { XX
} },
5233 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5234 { "(bad)", { XX
} },
5237 /* PREFIX_VEX_3A6C */
5239 { "(bad)", { XX
} },
5240 { "(bad)", { XX
} },
5241 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5242 { "(bad)", { XX
} },
5245 /* PREFIX_VEX_3A6D */
5247 { "(bad)", { XX
} },
5248 { "(bad)", { XX
} },
5249 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5250 { "(bad)", { XX
} },
5253 /* PREFIX_VEX_3A6E */
5255 { "(bad)", { XX
} },
5256 { "(bad)", { XX
} },
5257 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5258 { "(bad)", { XX
} },
5261 /* PREFIX_VEX_3A6F */
5263 { "(bad)", { XX
} },
5264 { "(bad)", { XX
} },
5265 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5266 { "(bad)", { XX
} },
5269 /* PREFIX_VEX_3A78 */
5271 { "(bad)", { XX
} },
5272 { "(bad)", { XX
} },
5273 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5274 { "(bad)", { XX
} },
5277 /* PREFIX_VEX_3A79 */
5279 { "(bad)", { XX
} },
5280 { "(bad)", { XX
} },
5281 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5282 { "(bad)", { XX
} },
5285 /* PREFIX_VEX_3A7A */
5287 { "(bad)", { XX
} },
5288 { "(bad)", { XX
} },
5289 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5290 { "(bad)", { XX
} },
5293 /* PREFIX_VEX_3A7B */
5295 { "(bad)", { XX
} },
5296 { "(bad)", { XX
} },
5297 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5298 { "(bad)", { XX
} },
5301 /* PREFIX_VEX_3A7C */
5303 { "(bad)", { XX
} },
5304 { "(bad)", { XX
} },
5305 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5306 { "(bad)", { XX
} },
5309 /* PREFIX_VEX_3A7D */
5311 { "(bad)", { XX
} },
5312 { "(bad)", { XX
} },
5313 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5314 { "(bad)", { XX
} },
5317 /* PREFIX_VEX_3A7E */
5319 { "(bad)", { XX
} },
5320 { "(bad)", { XX
} },
5321 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5322 { "(bad)", { XX
} },
5325 /* PREFIX_VEX_3A7F */
5327 { "(bad)", { XX
} },
5328 { "(bad)", { XX
} },
5329 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5330 { "(bad)", { XX
} },
5333 /* PREFIX_VEX_3ADF */
5335 { "(bad)", { XX
} },
5336 { "(bad)", { XX
} },
5337 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5338 { "(bad)", { XX
} },
5342 static const struct dis386 x86_64_table
[][2] = {
5345 { "push{T|}", { es
} },
5346 { "(bad)", { XX
} },
5351 { "pop{T|}", { es
} },
5352 { "(bad)", { XX
} },
5357 { "push{T|}", { cs
} },
5358 { "(bad)", { XX
} },
5363 { "push{T|}", { ss
} },
5364 { "(bad)", { XX
} },
5369 { "pop{T|}", { ss
} },
5370 { "(bad)", { XX
} },
5375 { "push{T|}", { ds
} },
5376 { "(bad)", { XX
} },
5381 { "pop{T|}", { ds
} },
5382 { "(bad)", { XX
} },
5388 { "(bad)", { XX
} },
5394 { "(bad)", { XX
} },
5400 { "(bad)", { XX
} },
5406 { "(bad)", { XX
} },
5411 { "pusha{P|}", { XX
} },
5412 { "(bad)", { XX
} },
5417 { "popa{P|}", { XX
} },
5418 { "(bad)", { XX
} },
5423 { MOD_TABLE (MOD_62_32BIT
) },
5424 { "(bad)", { XX
} },
5429 { "arpl", { Ew
, Gw
} },
5430 { "movs{lq|xd}", { Gv
, Ed
} },
5435 { "ins{R|}", { Yzr
, indirDX
} },
5436 { "ins{G|}", { Yzr
, indirDX
} },
5441 { "outs{R|}", { indirDXr
, Xz
} },
5442 { "outs{G|}", { indirDXr
, Xz
} },
5447 { "Jcall{T|}", { Ap
} },
5448 { "(bad)", { XX
} },
5453 { MOD_TABLE (MOD_C4_32BIT
) },
5454 { VEX_C4_TABLE (VEX_0F
) },
5459 { MOD_TABLE (MOD_C5_32BIT
) },
5460 { VEX_C5_TABLE (VEX_0F
) },
5466 { "(bad)", { XX
} },
5472 { "(bad)", { XX
} },
5478 { "(bad)", { XX
} },
5483 { "Jjmp{T|}", { Ap
} },
5484 { "(bad)", { XX
} },
5487 /* X86_64_0F01_REG_0 */
5489 { "sgdt{Q|IQ}", { M
} },
5493 /* X86_64_0F01_REG_1 */
5495 { "sidt{Q|IQ}", { M
} },
5499 /* X86_64_0F01_REG_2 */
5501 { "lgdt{Q|Q}", { M
} },
5505 /* X86_64_0F01_REG_3 */
5507 { "lidt{Q|Q}", { M
} },
5512 static const struct dis386 three_byte_table
[][256] = {
5514 /* THREE_BYTE_0F38 */
5517 { "pshufb", { MX
, EM
} },
5518 { "phaddw", { MX
, EM
} },
5519 { "phaddd", { MX
, EM
} },
5520 { "phaddsw", { MX
, EM
} },
5521 { "pmaddubsw", { MX
, EM
} },
5522 { "phsubw", { MX
, EM
} },
5523 { "phsubd", { MX
, EM
} },
5524 { "phsubsw", { MX
, EM
} },
5526 { "psignb", { MX
, EM
} },
5527 { "psignw", { MX
, EM
} },
5528 { "psignd", { MX
, EM
} },
5529 { "pmulhrsw", { MX
, EM
} },
5530 { "(bad)", { XX
} },
5531 { "(bad)", { XX
} },
5532 { "(bad)", { XX
} },
5533 { "(bad)", { XX
} },
5535 { PREFIX_TABLE (PREFIX_0F3810
) },
5536 { "(bad)", { XX
} },
5537 { "(bad)", { XX
} },
5538 { "(bad)", { XX
} },
5539 { PREFIX_TABLE (PREFIX_0F3814
) },
5540 { PREFIX_TABLE (PREFIX_0F3815
) },
5541 { "(bad)", { XX
} },
5542 { PREFIX_TABLE (PREFIX_0F3817
) },
5544 { "(bad)", { XX
} },
5545 { "(bad)", { XX
} },
5546 { "(bad)", { XX
} },
5547 { "(bad)", { XX
} },
5548 { "pabsb", { MX
, EM
} },
5549 { "pabsw", { MX
, EM
} },
5550 { "pabsd", { MX
, EM
} },
5551 { "(bad)", { XX
} },
5553 { PREFIX_TABLE (PREFIX_0F3820
) },
5554 { PREFIX_TABLE (PREFIX_0F3821
) },
5555 { PREFIX_TABLE (PREFIX_0F3822
) },
5556 { PREFIX_TABLE (PREFIX_0F3823
) },
5557 { PREFIX_TABLE (PREFIX_0F3824
) },
5558 { PREFIX_TABLE (PREFIX_0F3825
) },
5559 { "(bad)", { XX
} },
5560 { "(bad)", { XX
} },
5562 { PREFIX_TABLE (PREFIX_0F3828
) },
5563 { PREFIX_TABLE (PREFIX_0F3829
) },
5564 { PREFIX_TABLE (PREFIX_0F382A
) },
5565 { PREFIX_TABLE (PREFIX_0F382B
) },
5566 { "(bad)", { XX
} },
5567 { "(bad)", { XX
} },
5568 { "(bad)", { XX
} },
5569 { "(bad)", { XX
} },
5571 { PREFIX_TABLE (PREFIX_0F3830
) },
5572 { PREFIX_TABLE (PREFIX_0F3831
) },
5573 { PREFIX_TABLE (PREFIX_0F3832
) },
5574 { PREFIX_TABLE (PREFIX_0F3833
) },
5575 { PREFIX_TABLE (PREFIX_0F3834
) },
5576 { PREFIX_TABLE (PREFIX_0F3835
) },
5577 { "(bad)", { XX
} },
5578 { PREFIX_TABLE (PREFIX_0F3837
) },
5580 { PREFIX_TABLE (PREFIX_0F3838
) },
5581 { PREFIX_TABLE (PREFIX_0F3839
) },
5582 { PREFIX_TABLE (PREFIX_0F383A
) },
5583 { PREFIX_TABLE (PREFIX_0F383B
) },
5584 { PREFIX_TABLE (PREFIX_0F383C
) },
5585 { PREFIX_TABLE (PREFIX_0F383D
) },
5586 { PREFIX_TABLE (PREFIX_0F383E
) },
5587 { PREFIX_TABLE (PREFIX_0F383F
) },
5589 { PREFIX_TABLE (PREFIX_0F3840
) },
5590 { PREFIX_TABLE (PREFIX_0F3841
) },
5591 { "(bad)", { XX
} },
5592 { "(bad)", { XX
} },
5593 { "(bad)", { XX
} },
5594 { "(bad)", { XX
} },
5595 { "(bad)", { XX
} },
5596 { "(bad)", { XX
} },
5598 { "(bad)", { XX
} },
5599 { "(bad)", { XX
} },
5600 { "(bad)", { XX
} },
5601 { "(bad)", { XX
} },
5602 { "(bad)", { XX
} },
5603 { "(bad)", { XX
} },
5604 { "(bad)", { XX
} },
5605 { "(bad)", { XX
} },
5607 { "(bad)", { XX
} },
5608 { "(bad)", { XX
} },
5609 { "(bad)", { XX
} },
5610 { "(bad)", { XX
} },
5611 { "(bad)", { XX
} },
5612 { "(bad)", { XX
} },
5613 { "(bad)", { XX
} },
5614 { "(bad)", { XX
} },
5616 { "(bad)", { XX
} },
5617 { "(bad)", { XX
} },
5618 { "(bad)", { XX
} },
5619 { "(bad)", { XX
} },
5620 { "(bad)", { XX
} },
5621 { "(bad)", { XX
} },
5622 { "(bad)", { XX
} },
5623 { "(bad)", { XX
} },
5625 { "(bad)", { XX
} },
5626 { "(bad)", { XX
} },
5627 { "(bad)", { XX
} },
5628 { "(bad)", { XX
} },
5629 { "(bad)", { XX
} },
5630 { "(bad)", { XX
} },
5631 { "(bad)", { XX
} },
5632 { "(bad)", { XX
} },
5634 { "(bad)", { XX
} },
5635 { "(bad)", { XX
} },
5636 { "(bad)", { XX
} },
5637 { "(bad)", { XX
} },
5638 { "(bad)", { XX
} },
5639 { "(bad)", { XX
} },
5640 { "(bad)", { XX
} },
5641 { "(bad)", { XX
} },
5643 { "(bad)", { XX
} },
5644 { "(bad)", { XX
} },
5645 { "(bad)", { XX
} },
5646 { "(bad)", { XX
} },
5647 { "(bad)", { XX
} },
5648 { "(bad)", { XX
} },
5649 { "(bad)", { XX
} },
5650 { "(bad)", { XX
} },
5652 { "(bad)", { XX
} },
5653 { "(bad)", { XX
} },
5654 { "(bad)", { XX
} },
5655 { "(bad)", { XX
} },
5656 { "(bad)", { XX
} },
5657 { "(bad)", { XX
} },
5658 { "(bad)", { XX
} },
5659 { "(bad)", { XX
} },
5661 { PREFIX_TABLE (PREFIX_0F3880
) },
5662 { PREFIX_TABLE (PREFIX_0F3881
) },
5663 { "(bad)", { XX
} },
5664 { "(bad)", { XX
} },
5665 { "(bad)", { XX
} },
5666 { "(bad)", { XX
} },
5667 { "(bad)", { XX
} },
5668 { "(bad)", { XX
} },
5670 { "(bad)", { XX
} },
5671 { "(bad)", { XX
} },
5672 { "(bad)", { XX
} },
5673 { "(bad)", { XX
} },
5674 { "(bad)", { XX
} },
5675 { "(bad)", { XX
} },
5676 { "(bad)", { XX
} },
5677 { "(bad)", { XX
} },
5679 { "(bad)", { XX
} },
5680 { "(bad)", { XX
} },
5681 { "(bad)", { XX
} },
5682 { "(bad)", { XX
} },
5683 { "(bad)", { XX
} },
5684 { "(bad)", { XX
} },
5685 { "(bad)", { XX
} },
5686 { "(bad)", { XX
} },
5688 { "(bad)", { XX
} },
5689 { "(bad)", { XX
} },
5690 { "(bad)", { XX
} },
5691 { "(bad)", { XX
} },
5692 { "(bad)", { XX
} },
5693 { "(bad)", { XX
} },
5694 { "(bad)", { XX
} },
5695 { "(bad)", { XX
} },
5697 { "(bad)", { XX
} },
5698 { "(bad)", { XX
} },
5699 { "(bad)", { XX
} },
5700 { "(bad)", { XX
} },
5701 { "(bad)", { XX
} },
5702 { "(bad)", { XX
} },
5703 { "(bad)", { XX
} },
5704 { "(bad)", { XX
} },
5706 { "(bad)", { XX
} },
5707 { "(bad)", { XX
} },
5708 { "(bad)", { XX
} },
5709 { "(bad)", { XX
} },
5710 { "(bad)", { XX
} },
5711 { "(bad)", { XX
} },
5712 { "(bad)", { XX
} },
5713 { "(bad)", { XX
} },
5715 { "(bad)", { XX
} },
5716 { "(bad)", { XX
} },
5717 { "(bad)", { XX
} },
5718 { "(bad)", { XX
} },
5719 { "(bad)", { XX
} },
5720 { "(bad)", { XX
} },
5721 { "(bad)", { XX
} },
5722 { "(bad)", { XX
} },
5724 { "(bad)", { XX
} },
5725 { "(bad)", { XX
} },
5726 { "(bad)", { XX
} },
5727 { "(bad)", { XX
} },
5728 { "(bad)", { XX
} },
5729 { "(bad)", { XX
} },
5730 { "(bad)", { XX
} },
5731 { "(bad)", { XX
} },
5733 { "(bad)", { XX
} },
5734 { "(bad)", { XX
} },
5735 { "(bad)", { XX
} },
5736 { "(bad)", { XX
} },
5737 { "(bad)", { XX
} },
5738 { "(bad)", { XX
} },
5739 { "(bad)", { XX
} },
5740 { "(bad)", { XX
} },
5742 { "(bad)", { XX
} },
5743 { "(bad)", { XX
} },
5744 { "(bad)", { XX
} },
5745 { "(bad)", { XX
} },
5746 { "(bad)", { XX
} },
5747 { "(bad)", { XX
} },
5748 { "(bad)", { XX
} },
5749 { "(bad)", { XX
} },
5751 { "(bad)", { XX
} },
5752 { "(bad)", { XX
} },
5753 { "(bad)", { XX
} },
5754 { "(bad)", { XX
} },
5755 { "(bad)", { XX
} },
5756 { "(bad)", { XX
} },
5757 { "(bad)", { XX
} },
5758 { "(bad)", { XX
} },
5760 { "(bad)", { XX
} },
5761 { "(bad)", { XX
} },
5762 { "(bad)", { XX
} },
5763 { PREFIX_TABLE (PREFIX_0F38DB
) },
5764 { PREFIX_TABLE (PREFIX_0F38DC
) },
5765 { PREFIX_TABLE (PREFIX_0F38DD
) },
5766 { PREFIX_TABLE (PREFIX_0F38DE
) },
5767 { PREFIX_TABLE (PREFIX_0F38DF
) },
5769 { "(bad)", { XX
} },
5770 { "(bad)", { XX
} },
5771 { "(bad)", { XX
} },
5772 { "(bad)", { XX
} },
5773 { "(bad)", { XX
} },
5774 { "(bad)", { XX
} },
5775 { "(bad)", { XX
} },
5776 { "(bad)", { XX
} },
5778 { "(bad)", { XX
} },
5779 { "(bad)", { XX
} },
5780 { "(bad)", { XX
} },
5781 { "(bad)", { XX
} },
5782 { "(bad)", { XX
} },
5783 { "(bad)", { XX
} },
5784 { "(bad)", { XX
} },
5785 { "(bad)", { XX
} },
5787 { PREFIX_TABLE (PREFIX_0F38F0
) },
5788 { PREFIX_TABLE (PREFIX_0F38F1
) },
5789 { "(bad)", { XX
} },
5790 { "(bad)", { XX
} },
5791 { "(bad)", { XX
} },
5792 { "(bad)", { XX
} },
5793 { "(bad)", { XX
} },
5794 { "(bad)", { XX
} },
5796 { "(bad)", { XX
} },
5797 { "(bad)", { XX
} },
5798 { "(bad)", { XX
} },
5799 { "(bad)", { XX
} },
5800 { "(bad)", { XX
} },
5801 { "(bad)", { XX
} },
5802 { "(bad)", { XX
} },
5803 { "(bad)", { XX
} },
5805 /* THREE_BYTE_0F3A */
5808 { "(bad)", { XX
} },
5809 { "(bad)", { XX
} },
5810 { "(bad)", { XX
} },
5811 { "(bad)", { XX
} },
5812 { "(bad)", { XX
} },
5813 { "(bad)", { XX
} },
5814 { "(bad)", { XX
} },
5815 { "(bad)", { XX
} },
5817 { PREFIX_TABLE (PREFIX_0F3A08
) },
5818 { PREFIX_TABLE (PREFIX_0F3A09
) },
5819 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5820 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5821 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5822 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5823 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5824 { "palignr", { MX
, EM
, Ib
} },
5826 { "(bad)", { XX
} },
5827 { "(bad)", { XX
} },
5828 { "(bad)", { XX
} },
5829 { "(bad)", { XX
} },
5830 { PREFIX_TABLE (PREFIX_0F3A14
) },
5831 { PREFIX_TABLE (PREFIX_0F3A15
) },
5832 { PREFIX_TABLE (PREFIX_0F3A16
) },
5833 { PREFIX_TABLE (PREFIX_0F3A17
) },
5835 { "(bad)", { XX
} },
5836 { "(bad)", { XX
} },
5837 { "(bad)", { XX
} },
5838 { "(bad)", { XX
} },
5839 { "(bad)", { XX
} },
5840 { "(bad)", { XX
} },
5841 { "(bad)", { XX
} },
5842 { "(bad)", { XX
} },
5844 { PREFIX_TABLE (PREFIX_0F3A20
) },
5845 { PREFIX_TABLE (PREFIX_0F3A21
) },
5846 { PREFIX_TABLE (PREFIX_0F3A22
) },
5847 { "(bad)", { XX
} },
5848 { "(bad)", { XX
} },
5849 { "(bad)", { XX
} },
5850 { "(bad)", { XX
} },
5851 { "(bad)", { XX
} },
5853 { "(bad)", { XX
} },
5854 { "(bad)", { XX
} },
5855 { "(bad)", { XX
} },
5856 { "(bad)", { XX
} },
5857 { "(bad)", { XX
} },
5858 { "(bad)", { XX
} },
5859 { "(bad)", { XX
} },
5860 { "(bad)", { XX
} },
5862 { "(bad)", { XX
} },
5863 { "(bad)", { XX
} },
5864 { "(bad)", { XX
} },
5865 { "(bad)", { XX
} },
5866 { "(bad)", { XX
} },
5867 { "(bad)", { XX
} },
5868 { "(bad)", { XX
} },
5869 { "(bad)", { XX
} },
5871 { "(bad)", { XX
} },
5872 { "(bad)", { XX
} },
5873 { "(bad)", { XX
} },
5874 { "(bad)", { XX
} },
5875 { "(bad)", { XX
} },
5876 { "(bad)", { XX
} },
5877 { "(bad)", { XX
} },
5878 { "(bad)", { XX
} },
5880 { PREFIX_TABLE (PREFIX_0F3A40
) },
5881 { PREFIX_TABLE (PREFIX_0F3A41
) },
5882 { PREFIX_TABLE (PREFIX_0F3A42
) },
5883 { "(bad)", { XX
} },
5884 { PREFIX_TABLE (PREFIX_0F3A44
) },
5885 { "(bad)", { XX
} },
5886 { "(bad)", { XX
} },
5887 { "(bad)", { XX
} },
5889 { "(bad)", { XX
} },
5890 { "(bad)", { XX
} },
5891 { "(bad)", { XX
} },
5892 { "(bad)", { XX
} },
5893 { "(bad)", { XX
} },
5894 { "(bad)", { XX
} },
5895 { "(bad)", { XX
} },
5896 { "(bad)", { XX
} },
5898 { "(bad)", { XX
} },
5899 { "(bad)", { XX
} },
5900 { "(bad)", { XX
} },
5901 { "(bad)", { XX
} },
5902 { "(bad)", { XX
} },
5903 { "(bad)", { XX
} },
5904 { "(bad)", { XX
} },
5905 { "(bad)", { XX
} },
5907 { "(bad)", { XX
} },
5908 { "(bad)", { XX
} },
5909 { "(bad)", { XX
} },
5910 { "(bad)", { XX
} },
5911 { "(bad)", { XX
} },
5912 { "(bad)", { XX
} },
5913 { "(bad)", { XX
} },
5914 { "(bad)", { XX
} },
5916 { PREFIX_TABLE (PREFIX_0F3A60
) },
5917 { PREFIX_TABLE (PREFIX_0F3A61
) },
5918 { PREFIX_TABLE (PREFIX_0F3A62
) },
5919 { PREFIX_TABLE (PREFIX_0F3A63
) },
5920 { "(bad)", { XX
} },
5921 { "(bad)", { XX
} },
5922 { "(bad)", { XX
} },
5923 { "(bad)", { XX
} },
5925 { "(bad)", { XX
} },
5926 { "(bad)", { XX
} },
5927 { "(bad)", { XX
} },
5928 { "(bad)", { XX
} },
5929 { "(bad)", { XX
} },
5930 { "(bad)", { XX
} },
5931 { "(bad)", { XX
} },
5932 { "(bad)", { XX
} },
5934 { "(bad)", { XX
} },
5935 { "(bad)", { XX
} },
5936 { "(bad)", { XX
} },
5937 { "(bad)", { XX
} },
5938 { "(bad)", { XX
} },
5939 { "(bad)", { XX
} },
5940 { "(bad)", { XX
} },
5941 { "(bad)", { XX
} },
5943 { "(bad)", { XX
} },
5944 { "(bad)", { XX
} },
5945 { "(bad)", { XX
} },
5946 { "(bad)", { XX
} },
5947 { "(bad)", { XX
} },
5948 { "(bad)", { XX
} },
5949 { "(bad)", { XX
} },
5950 { "(bad)", { XX
} },
5952 { "(bad)", { XX
} },
5953 { "(bad)", { XX
} },
5954 { "(bad)", { XX
} },
5955 { "(bad)", { XX
} },
5956 { "(bad)", { XX
} },
5957 { "(bad)", { XX
} },
5958 { "(bad)", { XX
} },
5959 { "(bad)", { XX
} },
5961 { "(bad)", { XX
} },
5962 { "(bad)", { XX
} },
5963 { "(bad)", { XX
} },
5964 { "(bad)", { XX
} },
5965 { "(bad)", { XX
} },
5966 { "(bad)", { XX
} },
5967 { "(bad)", { XX
} },
5968 { "(bad)", { XX
} },
5970 { "(bad)", { XX
} },
5971 { "(bad)", { XX
} },
5972 { "(bad)", { XX
} },
5973 { "(bad)", { XX
} },
5974 { "(bad)", { XX
} },
5975 { "(bad)", { XX
} },
5976 { "(bad)", { XX
} },
5977 { "(bad)", { XX
} },
5979 { "(bad)", { XX
} },
5980 { "(bad)", { XX
} },
5981 { "(bad)", { XX
} },
5982 { "(bad)", { XX
} },
5983 { "(bad)", { XX
} },
5984 { "(bad)", { XX
} },
5985 { "(bad)", { XX
} },
5986 { "(bad)", { XX
} },
5988 { "(bad)", { XX
} },
5989 { "(bad)", { XX
} },
5990 { "(bad)", { XX
} },
5991 { "(bad)", { XX
} },
5992 { "(bad)", { XX
} },
5993 { "(bad)", { XX
} },
5994 { "(bad)", { XX
} },
5995 { "(bad)", { XX
} },
5997 { "(bad)", { XX
} },
5998 { "(bad)", { XX
} },
5999 { "(bad)", { XX
} },
6000 { "(bad)", { XX
} },
6001 { "(bad)", { XX
} },
6002 { "(bad)", { XX
} },
6003 { "(bad)", { XX
} },
6004 { "(bad)", { XX
} },
6006 { "(bad)", { XX
} },
6007 { "(bad)", { XX
} },
6008 { "(bad)", { XX
} },
6009 { "(bad)", { XX
} },
6010 { "(bad)", { XX
} },
6011 { "(bad)", { XX
} },
6012 { "(bad)", { XX
} },
6013 { "(bad)", { XX
} },
6015 { "(bad)", { XX
} },
6016 { "(bad)", { XX
} },
6017 { "(bad)", { XX
} },
6018 { "(bad)", { XX
} },
6019 { "(bad)", { XX
} },
6020 { "(bad)", { XX
} },
6021 { "(bad)", { XX
} },
6022 { "(bad)", { XX
} },
6024 { "(bad)", { XX
} },
6025 { "(bad)", { XX
} },
6026 { "(bad)", { XX
} },
6027 { "(bad)", { XX
} },
6028 { "(bad)", { XX
} },
6029 { "(bad)", { XX
} },
6030 { "(bad)", { XX
} },
6031 { "(bad)", { XX
} },
6033 { "(bad)", { XX
} },
6034 { "(bad)", { XX
} },
6035 { "(bad)", { XX
} },
6036 { "(bad)", { XX
} },
6037 { "(bad)", { XX
} },
6038 { "(bad)", { XX
} },
6039 { "(bad)", { XX
} },
6040 { "(bad)", { XX
} },
6042 { "(bad)", { XX
} },
6043 { "(bad)", { XX
} },
6044 { "(bad)", { XX
} },
6045 { "(bad)", { XX
} },
6046 { "(bad)", { XX
} },
6047 { "(bad)", { XX
} },
6048 { "(bad)", { XX
} },
6049 { "(bad)", { XX
} },
6051 { "(bad)", { XX
} },
6052 { "(bad)", { XX
} },
6053 { "(bad)", { XX
} },
6054 { "(bad)", { XX
} },
6055 { "(bad)", { XX
} },
6056 { "(bad)", { XX
} },
6057 { "(bad)", { XX
} },
6058 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6060 { "(bad)", { XX
} },
6061 { "(bad)", { XX
} },
6062 { "(bad)", { XX
} },
6063 { "(bad)", { XX
} },
6064 { "(bad)", { XX
} },
6065 { "(bad)", { XX
} },
6066 { "(bad)", { XX
} },
6067 { "(bad)", { XX
} },
6069 { "(bad)", { XX
} },
6070 { "(bad)", { XX
} },
6071 { "(bad)", { XX
} },
6072 { "(bad)", { XX
} },
6073 { "(bad)", { XX
} },
6074 { "(bad)", { XX
} },
6075 { "(bad)", { XX
} },
6076 { "(bad)", { XX
} },
6078 { "(bad)", { XX
} },
6079 { "(bad)", { XX
} },
6080 { "(bad)", { XX
} },
6081 { "(bad)", { XX
} },
6082 { "(bad)", { XX
} },
6083 { "(bad)", { XX
} },
6084 { "(bad)", { XX
} },
6085 { "(bad)", { XX
} },
6087 { "(bad)", { XX
} },
6088 { "(bad)", { XX
} },
6089 { "(bad)", { XX
} },
6090 { "(bad)", { XX
} },
6091 { "(bad)", { XX
} },
6092 { "(bad)", { XX
} },
6093 { "(bad)", { XX
} },
6094 { "(bad)", { XX
} },
6097 /* THREE_BYTE_0F7A */
6100 { "(bad)", { XX
} },
6101 { "(bad)", { XX
} },
6102 { "(bad)", { XX
} },
6103 { "(bad)", { XX
} },
6104 { "(bad)", { XX
} },
6105 { "(bad)", { XX
} },
6106 { "(bad)", { XX
} },
6107 { "(bad)", { XX
} },
6109 { "(bad)", { XX
} },
6110 { "(bad)", { XX
} },
6111 { "(bad)", { XX
} },
6112 { "(bad)", { XX
} },
6113 { "(bad)", { XX
} },
6114 { "(bad)", { XX
} },
6115 { "(bad)", { XX
} },
6116 { "(bad)", { XX
} },
6118 { "(bad)", { XX
} },
6119 { "(bad)", { XX
} },
6120 { "(bad)", { XX
} },
6121 { "(bad)", { XX
} },
6122 { "(bad)", { XX
} },
6123 { "(bad)", { XX
} },
6124 { "(bad)", { XX
} },
6125 { "(bad)", { XX
} },
6127 { "(bad)", { XX
} },
6128 { "(bad)", { XX
} },
6129 { "(bad)", { XX
} },
6130 { "(bad)", { XX
} },
6131 { "(bad)", { XX
} },
6132 { "(bad)", { XX
} },
6133 { "(bad)", { XX
} },
6134 { "(bad)", { XX
} },
6136 { "ptest", { XX
} },
6137 { "(bad)", { XX
} },
6138 { "(bad)", { XX
} },
6139 { "(bad)", { XX
} },
6140 { "(bad)", { XX
} },
6141 { "(bad)", { XX
} },
6142 { "(bad)", { XX
} },
6143 { "(bad)", { XX
} },
6145 { "(bad)", { XX
} },
6146 { "(bad)", { XX
} },
6147 { "(bad)", { XX
} },
6148 { "(bad)", { XX
} },
6149 { "(bad)", { XX
} },
6150 { "(bad)", { XX
} },
6151 { "(bad)", { XX
} },
6152 { "(bad)", { XX
} },
6154 { "(bad)", { XX
} },
6155 { "(bad)", { XX
} },
6156 { "(bad)", { XX
} },
6157 { "(bad)", { XX
} },
6158 { "(bad)", { XX
} },
6159 { "(bad)", { XX
} },
6160 { "(bad)", { XX
} },
6161 { "(bad)", { XX
} },
6163 { "(bad)", { XX
} },
6164 { "(bad)", { XX
} },
6165 { "(bad)", { XX
} },
6166 { "(bad)", { XX
} },
6167 { "(bad)", { XX
} },
6168 { "(bad)", { XX
} },
6169 { "(bad)", { XX
} },
6170 { "(bad)", { XX
} },
6172 { "(bad)", { XX
} },
6173 { "phaddbw", { XM
, EXq
} },
6174 { "phaddbd", { XM
, EXq
} },
6175 { "phaddbq", { XM
, EXq
} },
6176 { "(bad)", { XX
} },
6177 { "(bad)", { XX
} },
6178 { "phaddwd", { XM
, EXq
} },
6179 { "phaddwq", { XM
, EXq
} },
6181 { "(bad)", { XX
} },
6182 { "(bad)", { XX
} },
6183 { "(bad)", { XX
} },
6184 { "phadddq", { XM
, EXq
} },
6185 { "(bad)", { XX
} },
6186 { "(bad)", { XX
} },
6187 { "(bad)", { XX
} },
6188 { "(bad)", { XX
} },
6190 { "(bad)", { XX
} },
6191 { "phaddubw", { XM
, EXq
} },
6192 { "phaddubd", { XM
, EXq
} },
6193 { "phaddubq", { XM
, EXq
} },
6194 { "(bad)", { XX
} },
6195 { "(bad)", { XX
} },
6196 { "phadduwd", { XM
, EXq
} },
6197 { "phadduwq", { XM
, EXq
} },
6199 { "(bad)", { XX
} },
6200 { "(bad)", { XX
} },
6201 { "(bad)", { XX
} },
6202 { "phaddudq", { XM
, EXq
} },
6203 { "(bad)", { XX
} },
6204 { "(bad)", { XX
} },
6205 { "(bad)", { XX
} },
6206 { "(bad)", { XX
} },
6208 { "(bad)", { XX
} },
6209 { "phsubbw", { XM
, EXq
} },
6210 { "phsubbd", { XM
, EXq
} },
6211 { "phsubbq", { XM
, EXq
} },
6212 { "(bad)", { XX
} },
6213 { "(bad)", { XX
} },
6214 { "(bad)", { XX
} },
6215 { "(bad)", { XX
} },
6217 { "(bad)", { XX
} },
6218 { "(bad)", { XX
} },
6219 { "(bad)", { XX
} },
6220 { "(bad)", { XX
} },
6221 { "(bad)", { XX
} },
6222 { "(bad)", { XX
} },
6223 { "(bad)", { XX
} },
6224 { "(bad)", { XX
} },
6226 { "(bad)", { XX
} },
6227 { "(bad)", { XX
} },
6228 { "(bad)", { XX
} },
6229 { "(bad)", { XX
} },
6230 { "(bad)", { XX
} },
6231 { "(bad)", { XX
} },
6232 { "(bad)", { XX
} },
6233 { "(bad)", { XX
} },
6235 { "(bad)", { XX
} },
6236 { "(bad)", { XX
} },
6237 { "(bad)", { XX
} },
6238 { "(bad)", { XX
} },
6239 { "(bad)", { XX
} },
6240 { "(bad)", { XX
} },
6241 { "(bad)", { XX
} },
6242 { "(bad)", { XX
} },
6244 { "(bad)", { XX
} },
6245 { "(bad)", { XX
} },
6246 { "(bad)", { XX
} },
6247 { "(bad)", { XX
} },
6248 { "(bad)", { XX
} },
6249 { "(bad)", { XX
} },
6250 { "(bad)", { XX
} },
6251 { "(bad)", { XX
} },
6253 { "(bad)", { XX
} },
6254 { "(bad)", { XX
} },
6255 { "(bad)", { XX
} },
6256 { "(bad)", { XX
} },
6257 { "(bad)", { XX
} },
6258 { "(bad)", { XX
} },
6259 { "(bad)", { XX
} },
6260 { "(bad)", { XX
} },
6262 { "(bad)", { XX
} },
6263 { "(bad)", { XX
} },
6264 { "(bad)", { XX
} },
6265 { "(bad)", { XX
} },
6266 { "(bad)", { XX
} },
6267 { "(bad)", { XX
} },
6268 { "(bad)", { XX
} },
6269 { "(bad)", { XX
} },
6271 { "(bad)", { XX
} },
6272 { "(bad)", { XX
} },
6273 { "(bad)", { XX
} },
6274 { "(bad)", { XX
} },
6275 { "(bad)", { XX
} },
6276 { "(bad)", { XX
} },
6277 { "(bad)", { XX
} },
6278 { "(bad)", { XX
} },
6280 { "(bad)", { XX
} },
6281 { "(bad)", { XX
} },
6282 { "(bad)", { XX
} },
6283 { "(bad)", { XX
} },
6284 { "(bad)", { XX
} },
6285 { "(bad)", { XX
} },
6286 { "(bad)", { XX
} },
6287 { "(bad)", { XX
} },
6289 { "(bad)", { XX
} },
6290 { "(bad)", { XX
} },
6291 { "(bad)", { XX
} },
6292 { "(bad)", { XX
} },
6293 { "(bad)", { XX
} },
6294 { "(bad)", { XX
} },
6295 { "(bad)", { XX
} },
6296 { "(bad)", { XX
} },
6298 { "(bad)", { XX
} },
6299 { "(bad)", { XX
} },
6300 { "(bad)", { XX
} },
6301 { "(bad)", { XX
} },
6302 { "(bad)", { XX
} },
6303 { "(bad)", { XX
} },
6304 { "(bad)", { XX
} },
6305 { "(bad)", { XX
} },
6307 { "(bad)", { XX
} },
6308 { "(bad)", { XX
} },
6309 { "(bad)", { XX
} },
6310 { "(bad)", { XX
} },
6311 { "(bad)", { XX
} },
6312 { "(bad)", { XX
} },
6313 { "(bad)", { XX
} },
6314 { "(bad)", { XX
} },
6316 { "(bad)", { XX
} },
6317 { "(bad)", { XX
} },
6318 { "(bad)", { XX
} },
6319 { "(bad)", { XX
} },
6320 { "(bad)", { XX
} },
6321 { "(bad)", { XX
} },
6322 { "(bad)", { XX
} },
6323 { "(bad)", { XX
} },
6325 { "(bad)", { XX
} },
6326 { "(bad)", { XX
} },
6327 { "(bad)", { XX
} },
6328 { "(bad)", { XX
} },
6329 { "(bad)", { XX
} },
6330 { "(bad)", { XX
} },
6331 { "(bad)", { XX
} },
6332 { "(bad)", { XX
} },
6334 { "(bad)", { XX
} },
6335 { "(bad)", { XX
} },
6336 { "(bad)", { XX
} },
6337 { "(bad)", { XX
} },
6338 { "(bad)", { XX
} },
6339 { "(bad)", { XX
} },
6340 { "(bad)", { XX
} },
6341 { "(bad)", { XX
} },
6343 { "(bad)", { XX
} },
6344 { "(bad)", { XX
} },
6345 { "(bad)", { XX
} },
6346 { "(bad)", { XX
} },
6347 { "(bad)", { XX
} },
6348 { "(bad)", { XX
} },
6349 { "(bad)", { XX
} },
6350 { "(bad)", { XX
} },
6352 { "(bad)", { XX
} },
6353 { "(bad)", { XX
} },
6354 { "(bad)", { XX
} },
6355 { "(bad)", { XX
} },
6356 { "(bad)", { XX
} },
6357 { "(bad)", { XX
} },
6358 { "(bad)", { XX
} },
6359 { "(bad)", { XX
} },
6361 { "(bad)", { XX
} },
6362 { "(bad)", { XX
} },
6363 { "(bad)", { XX
} },
6364 { "(bad)", { XX
} },
6365 { "(bad)", { XX
} },
6366 { "(bad)", { XX
} },
6367 { "(bad)", { XX
} },
6368 { "(bad)", { XX
} },
6370 { "(bad)", { XX
} },
6371 { "(bad)", { XX
} },
6372 { "(bad)", { XX
} },
6373 { "(bad)", { XX
} },
6374 { "(bad)", { XX
} },
6375 { "(bad)", { XX
} },
6376 { "(bad)", { XX
} },
6377 { "(bad)", { XX
} },
6379 { "(bad)", { XX
} },
6380 { "(bad)", { XX
} },
6381 { "(bad)", { XX
} },
6382 { "(bad)", { XX
} },
6383 { "(bad)", { XX
} },
6384 { "(bad)", { XX
} },
6385 { "(bad)", { XX
} },
6386 { "(bad)", { XX
} },
6390 static const struct dis386 xop_table
[][256] = {
6394 { "(bad)", { XX
} },
6395 { "(bad)", { XX
} },
6396 { "(bad)", { XX
} },
6397 { "(bad)", { XX
} },
6398 { "(bad)", { XX
} },
6399 { "(bad)", { XX
} },
6400 { "(bad)", { XX
} },
6401 { "(bad)", { XX
} },
6403 { "(bad)", { XX
} },
6404 { "(bad)", { XX
} },
6405 { "(bad)", { XX
} },
6406 { "(bad)", { XX
} },
6407 { "(bad)", { XX
} },
6408 { "(bad)", { XX
} },
6409 { "(bad)", { XX
} },
6410 { "(bad)", { XX
} },
6412 { "(bad)", { XX
} },
6413 { "(bad)", { XX
} },
6414 { "(bad)", { XX
} },
6415 { "(bad)", { XX
} },
6416 { "(bad)", { XX
} },
6417 { "(bad)", { XX
} },
6418 { "(bad)", { XX
} },
6419 { "(bad)", { XX
} },
6421 { "(bad)", { XX
} },
6422 { "(bad)", { XX
} },
6423 { "(bad)", { XX
} },
6424 { "(bad)", { XX
} },
6425 { "(bad)", { XX
} },
6426 { "(bad)", { XX
} },
6427 { "(bad)", { XX
} },
6428 { "(bad)", { XX
} },
6430 { "(bad)", { XX
} },
6431 { "(bad)", { XX
} },
6432 { "(bad)", { XX
} },
6433 { "(bad)", { XX
} },
6434 { "(bad)", { XX
} },
6435 { "(bad)", { XX
} },
6436 { "(bad)", { XX
} },
6437 { "(bad)", { XX
} },
6439 { "(bad)", { XX
} },
6440 { "(bad)", { XX
} },
6441 { "(bad)", { XX
} },
6442 { "(bad)", { XX
} },
6443 { "(bad)", { XX
} },
6444 { "(bad)", { XX
} },
6445 { "(bad)", { XX
} },
6446 { "(bad)", { XX
} },
6448 { "(bad)", { XX
} },
6449 { "(bad)", { XX
} },
6450 { "(bad)", { XX
} },
6451 { "(bad)", { XX
} },
6452 { "(bad)", { XX
} },
6453 { "(bad)", { XX
} },
6454 { "(bad)", { XX
} },
6455 { "(bad)", { XX
} },
6457 { "(bad)", { XX
} },
6458 { "(bad)", { XX
} },
6459 { "(bad)", { XX
} },
6460 { "(bad)", { XX
} },
6461 { "(bad)", { XX
} },
6462 { "(bad)", { XX
} },
6463 { "(bad)", { XX
} },
6464 { "(bad)", { XX
} },
6466 { "(bad)", { XX
} },
6467 { "(bad)", { XX
} },
6468 { "(bad)", { XX
} },
6469 { "(bad)", { XX
} },
6470 { "(bad)", { XX
} },
6471 { "(bad)", { XX
} },
6472 { "(bad)", { XX
} },
6473 { "(bad)", { XX
} },
6475 { "(bad)", { XX
} },
6476 { "(bad)", { XX
} },
6477 { "(bad)", { XX
} },
6478 { "(bad)", { XX
} },
6479 { "(bad)", { XX
} },
6480 { "(bad)", { XX
} },
6481 { "(bad)", { XX
} },
6482 { "(bad)", { XX
} },
6484 { "(bad)", { XX
} },
6485 { "(bad)", { XX
} },
6486 { "(bad)", { XX
} },
6487 { "(bad)", { XX
} },
6488 { "(bad)", { XX
} },
6489 { "(bad)", { XX
} },
6490 { "(bad)", { XX
} },
6491 { "(bad)", { XX
} },
6493 { "(bad)", { XX
} },
6494 { "(bad)", { XX
} },
6495 { "(bad)", { XX
} },
6496 { "(bad)", { XX
} },
6497 { "(bad)", { XX
} },
6498 { "(bad)", { XX
} },
6499 { "(bad)", { XX
} },
6500 { "(bad)", { XX
} },
6502 { "(bad)", { XX
} },
6503 { "(bad)", { XX
} },
6504 { "(bad)", { XX
} },
6505 { "(bad)", { XX
} },
6506 { "(bad)", { XX
} },
6507 { "(bad)", { XX
} },
6508 { "(bad)", { XX
} },
6509 { "(bad)", { XX
} },
6511 { "(bad)", { XX
} },
6512 { "(bad)", { XX
} },
6513 { "(bad)", { XX
} },
6514 { "(bad)", { XX
} },
6515 { "(bad)", { XX
} },
6516 { "(bad)", { XX
} },
6517 { "(bad)", { XX
} },
6518 { "(bad)", { XX
} },
6520 { "(bad)", { XX
} },
6521 { "(bad)", { XX
} },
6522 { "(bad)", { XX
} },
6523 { "(bad)", { XX
} },
6524 { "(bad)", { XX
} },
6525 { "(bad)", { XX
} },
6526 { "(bad)", { XX
} },
6527 { "(bad)", { XX
} },
6529 { "(bad)", { XX
} },
6530 { "(bad)", { XX
} },
6531 { "(bad)", { XX
} },
6532 { "(bad)", { XX
} },
6533 { "(bad)", { XX
} },
6534 { "(bad)", { XX
} },
6535 { "(bad)", { XX
} },
6536 { "(bad)", { XX
} },
6538 { "(bad)", { XX
} },
6539 { "(bad)", { XX
} },
6540 { "(bad)", { XX
} },
6541 { "(bad)", { XX
} },
6542 { "(bad)", { XX
} },
6543 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6544 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6545 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6547 { "(bad)", { XX
} },
6548 { "(bad)", { XX
} },
6549 { "(bad)", { XX
} },
6550 { "(bad)", { XX
} },
6551 { "(bad)", { XX
} },
6552 { "(bad)", { XX
} },
6553 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6554 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6556 { "(bad)", { XX
} },
6557 { "(bad)", { XX
} },
6558 { "(bad)", { XX
} },
6559 { "(bad)", { XX
} },
6560 { "(bad)", { XX
} },
6561 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6562 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6563 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6565 { "(bad)", { XX
} },
6566 { "(bad)", { XX
} },
6567 { "(bad)", { XX
} },
6568 { "(bad)", { XX
} },
6569 { "(bad)", { XX
} },
6570 { "(bad)", { XX
} },
6571 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6572 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6574 { "(bad)", { XX
} },
6575 { "(bad)", { XX
} },
6576 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6577 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6578 { "(bad)", { XX
} },
6579 { "(bad)", { XX
} },
6580 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6581 { "(bad)", { XX
} },
6583 { "(bad)", { XX
} },
6584 { "(bad)", { XX
} },
6585 { "(bad)", { XX
} },
6586 { "(bad)", { XX
} },
6587 { "(bad)", { XX
} },
6588 { "(bad)", { XX
} },
6589 { "(bad)", { XX
} },
6590 { "(bad)", { XX
} },
6592 { "(bad)", { XX
} },
6593 { "(bad)", { XX
} },
6594 { "(bad)", { XX
} },
6595 { "(bad)", { XX
} },
6596 { "(bad)", { XX
} },
6597 { "(bad)", { XX
} },
6598 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6599 { "(bad)", { XX
} },
6601 { "(bad)", { XX
} },
6602 { "(bad)", { XX
} },
6603 { "(bad)", { XX
} },
6604 { "(bad)", { XX
} },
6605 { "(bad)", { XX
} },
6606 { "(bad)", { XX
} },
6607 { "(bad)", { XX
} },
6608 { "(bad)", { XX
} },
6610 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6611 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6612 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6613 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6614 { "(bad)", { XX
} },
6615 { "(bad)", { XX
} },
6616 { "(bad)", { XX
} },
6617 { "(bad)", { XX
} },
6619 { "(bad)", { XX
} },
6620 { "(bad)", { XX
} },
6621 { "(bad)", { XX
} },
6622 { "(bad)", { XX
} },
6623 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6624 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6625 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6626 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6628 { "(bad)", { XX
} },
6629 { "(bad)", { XX
} },
6630 { "(bad)", { XX
} },
6631 { "(bad)", { XX
} },
6632 { "(bad)", { XX
} },
6633 { "(bad)", { XX
} },
6634 { "(bad)", { XX
} },
6635 { "(bad)", { XX
} },
6637 { "(bad)", { XX
} },
6638 { "(bad)", { XX
} },
6639 { "(bad)", { XX
} },
6640 { "(bad)", { XX
} },
6641 { "(bad)", { XX
} },
6642 { "(bad)", { XX
} },
6643 { "(bad)", { XX
} },
6644 { "(bad)", { XX
} },
6646 { "(bad)", { XX
} },
6647 { "(bad)", { XX
} },
6648 { "(bad)", { XX
} },
6649 { "(bad)", { XX
} },
6650 { "(bad)", { XX
} },
6651 { "(bad)", { XX
} },
6652 { "(bad)", { XX
} },
6653 { "(bad)", { XX
} },
6655 { "(bad)", { XX
} },
6656 { "(bad)", { XX
} },
6657 { "(bad)", { XX
} },
6658 { "(bad)", { XX
} },
6659 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6660 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6661 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6662 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6664 { "(bad)", { XX
} },
6665 { "(bad)", { XX
} },
6666 { "(bad)", { XX
} },
6667 { "(bad)", { XX
} },
6668 { "(bad)", { XX
} },
6669 { "(bad)", { XX
} },
6670 { "(bad)", { XX
} },
6671 { "(bad)", { XX
} },
6673 { "(bad)", { XX
} },
6674 { "(bad)", { XX
} },
6675 { "(bad)", { XX
} },
6676 { "(bad)", { XX
} },
6677 { "(bad)", { XX
} },
6678 { "(bad)", { XX
} },
6679 { "(bad)", { XX
} },
6680 { "(bad)", { XX
} },
6685 { "(bad)", { XX
} },
6686 { "(bad)", { XX
} },
6687 { "(bad)", { XX
} },
6688 { "(bad)", { XX
} },
6689 { "(bad)", { XX
} },
6690 { "(bad)", { XX
} },
6691 { "(bad)", { XX
} },
6692 { "(bad)", { XX
} },
6694 { "(bad)", { XX
} },
6695 { "(bad)", { XX
} },
6696 { "(bad)", { XX
} },
6697 { "(bad)", { XX
} },
6698 { "(bad)", { XX
} },
6699 { "(bad)", { XX
} },
6700 { "(bad)", { XX
} },
6701 { "(bad)", { XX
} },
6703 { "(bad)", { XX
} },
6704 { "(bad)", { XX
} },
6705 { REG_TABLE (REG_XOP_LWPCB
) },
6706 { "(bad)", { XX
} },
6707 { "(bad)", { XX
} },
6708 { "(bad)", { XX
} },
6709 { "(bad)", { XX
} },
6710 { "(bad)", { XX
} },
6712 { "(bad)", { XX
} },
6713 { "(bad)", { XX
} },
6714 { "(bad)", { XX
} },
6715 { "(bad)", { XX
} },
6716 { "(bad)", { XX
} },
6717 { "(bad)", { XX
} },
6718 { "(bad)", { XX
} },
6719 { "(bad)", { XX
} },
6721 { "(bad)", { XX
} },
6722 { "(bad)", { XX
} },
6723 { "(bad)", { XX
} },
6724 { "(bad)", { XX
} },
6725 { "(bad)", { XX
} },
6726 { "(bad)", { XX
} },
6727 { "(bad)", { XX
} },
6728 { "(bad)", { XX
} },
6730 { "(bad)", { XX
} },
6731 { "(bad)", { XX
} },
6732 { "(bad)", { XX
} },
6733 { "(bad)", { XX
} },
6734 { "(bad)", { XX
} },
6735 { "(bad)", { XX
} },
6736 { "(bad)", { XX
} },
6737 { "(bad)", { XX
} },
6739 { "(bad)", { XX
} },
6740 { "(bad)", { XX
} },
6741 { "(bad)", { XX
} },
6742 { "(bad)", { XX
} },
6743 { "(bad)", { XX
} },
6744 { "(bad)", { XX
} },
6745 { "(bad)", { XX
} },
6746 { "(bad)", { XX
} },
6748 { "(bad)", { XX
} },
6749 { "(bad)", { XX
} },
6750 { "(bad)", { XX
} },
6751 { "(bad)", { XX
} },
6752 { "(bad)", { XX
} },
6753 { "(bad)", { XX
} },
6754 { "(bad)", { XX
} },
6755 { "(bad)", { XX
} },
6757 { "(bad)", { XX
} },
6758 { "(bad)", { XX
} },
6759 { "(bad)", { XX
} },
6760 { "(bad)", { XX
} },
6761 { "(bad)", { XX
} },
6762 { "(bad)", { XX
} },
6763 { "(bad)", { XX
} },
6764 { "(bad)", { XX
} },
6766 { "(bad)", { XX
} },
6767 { "(bad)", { XX
} },
6768 { "(bad)", { XX
} },
6769 { "(bad)", { XX
} },
6770 { "(bad)", { XX
} },
6771 { "(bad)", { XX
} },
6772 { "(bad)", { XX
} },
6773 { "(bad)", { XX
} },
6775 { "(bad)", { XX
} },
6776 { "(bad)", { XX
} },
6777 { "(bad)", { XX
} },
6778 { "(bad)", { XX
} },
6779 { "(bad)", { XX
} },
6780 { "(bad)", { XX
} },
6781 { "(bad)", { XX
} },
6782 { "(bad)", { XX
} },
6784 { "(bad)", { XX
} },
6785 { "(bad)", { XX
} },
6786 { "(bad)", { XX
} },
6787 { "(bad)", { XX
} },
6788 { "(bad)", { XX
} },
6789 { "(bad)", { XX
} },
6790 { "(bad)", { XX
} },
6791 { "(bad)", { XX
} },
6793 { "(bad)", { XX
} },
6794 { "(bad)", { XX
} },
6795 { "(bad)", { XX
} },
6796 { "(bad)", { XX
} },
6797 { "(bad)", { XX
} },
6798 { "(bad)", { XX
} },
6799 { "(bad)", { XX
} },
6800 { "(bad)", { XX
} },
6802 { "(bad)", { XX
} },
6803 { "(bad)", { XX
} },
6804 { "(bad)", { XX
} },
6805 { "(bad)", { XX
} },
6806 { "(bad)", { XX
} },
6807 { "(bad)", { XX
} },
6808 { "(bad)", { XX
} },
6809 { "(bad)", { XX
} },
6811 { "(bad)", { XX
} },
6812 { "(bad)", { XX
} },
6813 { "(bad)", { XX
} },
6814 { "(bad)", { XX
} },
6815 { "(bad)", { XX
} },
6816 { "(bad)", { XX
} },
6817 { "(bad)", { XX
} },
6818 { "(bad)", { XX
} },
6820 { "(bad)", { XX
} },
6821 { "(bad)", { XX
} },
6822 { "(bad)", { XX
} },
6823 { "(bad)", { XX
} },
6824 { "(bad)", { XX
} },
6825 { "(bad)", { XX
} },
6826 { "(bad)", { XX
} },
6827 { "(bad)", { XX
} },
6829 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
6830 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
6831 { "vfrczss", { XM
, EXd
} },
6832 { "vfrczsd", { XM
, EXq
} },
6833 { "(bad)", { XX
} },
6834 { "(bad)", { XX
} },
6835 { "(bad)", { XX
} },
6836 { "(bad)", { XX
} },
6838 { "(bad)", { XX
} },
6839 { "(bad)", { XX
} },
6840 { "(bad)", { XX
} },
6841 { "(bad)", { XX
} },
6842 { "(bad)", { XX
} },
6843 { "(bad)", { XX
} },
6844 { "(bad)", { XX
} },
6845 { "(bad)", { XX
} },
6847 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6848 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6849 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6850 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6851 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6852 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6853 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6854 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6856 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6857 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6858 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6859 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6860 { "(bad)", { XX
} },
6861 { "(bad)", { XX
} },
6862 { "(bad)", { XX
} },
6863 { "(bad)", { XX
} },
6865 { "(bad)", { XX
} },
6866 { "(bad)", { XX
} },
6867 { "(bad)", { XX
} },
6868 { "(bad)", { XX
} },
6869 { "(bad)", { XX
} },
6870 { "(bad)", { XX
} },
6871 { "(bad)", { XX
} },
6872 { "(bad)", { XX
} },
6874 { "(bad)", { XX
} },
6875 { "(bad)", { XX
} },
6876 { "(bad)", { XX
} },
6877 { "(bad)", { XX
} },
6878 { "(bad)", { XX
} },
6879 { "(bad)", { XX
} },
6880 { "(bad)", { XX
} },
6881 { "(bad)", { XX
} },
6883 { "(bad)", { XX
} },
6884 { "(bad)", { XX
} },
6885 { "(bad)", { XX
} },
6886 { "(bad)", { XX
} },
6887 { "(bad)", { XX
} },
6888 { "(bad)", { XX
} },
6889 { "(bad)", { XX
} },
6890 { "(bad)", { XX
} },
6892 { "(bad)", { XX
} },
6893 { "(bad)", { XX
} },
6894 { "(bad)", { XX
} },
6895 { "(bad)", { XX
} },
6896 { "(bad)", { XX
} },
6897 { "(bad)", { XX
} },
6898 { "(bad)", { XX
} },
6899 { "(bad)", { XX
} },
6901 { "(bad)", { XX
} },
6902 { "vphaddbw", { XM
, EXxmm
} },
6903 { "vphaddbd", { XM
, EXxmm
} },
6904 { "vphaddbq", { XM
, EXxmm
} },
6905 { "(bad)", { XX
} },
6906 { "(bad)", { XX
} },
6907 { "vphaddwd", { XM
, EXxmm
} },
6908 { "vphaddwq", { XM
, EXxmm
} },
6910 { "(bad)", { XX
} },
6911 { "(bad)", { XX
} },
6912 { "(bad)", { XX
} },
6913 { "vphadddq", { XM
, EXxmm
} },
6914 { "(bad)", { XX
} },
6915 { "(bad)", { XX
} },
6916 { "(bad)", { XX
} },
6917 { "(bad)", { XX
} },
6919 { "(bad)", { XX
} },
6920 { "vphaddubw", { XM
, EXxmm
} },
6921 { "vphaddubd", { XM
, EXxmm
} },
6922 { "vphaddubq", { XM
, EXxmm
} },
6923 { "(bad)", { XX
} },
6924 { "(bad)", { XX
} },
6925 { "vphadduwd", { XM
, EXxmm
} },
6926 { "vphadduwq", { XM
, EXxmm
} },
6928 { "(bad)", { XX
} },
6929 { "(bad)", { XX
} },
6930 { "(bad)", { XX
} },
6931 { "vphaddudq", { XM
, EXxmm
} },
6932 { "(bad)", { XX
} },
6933 { "(bad)", { XX
} },
6934 { "(bad)", { XX
} },
6935 { "(bad)", { XX
} },
6937 { "(bad)", { XX
} },
6938 { "vphsubbw", { XM
, EXxmm
} },
6939 { "vphsubwd", { XM
, EXxmm
} },
6940 { "vphsubdq", { XM
, EXxmm
} },
6941 { "(bad)", { XX
} },
6942 { "(bad)", { XX
} },
6943 { "(bad)", { XX
} },
6944 { "(bad)", { XX
} },
6946 { "(bad)", { XX
} },
6947 { "(bad)", { XX
} },
6948 { "(bad)", { XX
} },
6949 { "(bad)", { XX
} },
6950 { "(bad)", { XX
} },
6951 { "(bad)", { XX
} },
6952 { "(bad)", { XX
} },
6953 { "(bad)", { XX
} },
6955 { "(bad)", { XX
} },
6956 { "(bad)", { XX
} },
6957 { "(bad)", { XX
} },
6958 { "(bad)", { XX
} },
6959 { "(bad)", { XX
} },
6960 { "(bad)", { XX
} },
6961 { "(bad)", { XX
} },
6962 { "(bad)", { XX
} },
6964 { "(bad)", { XX
} },
6965 { "(bad)", { XX
} },
6966 { "(bad)", { XX
} },
6967 { "(bad)", { XX
} },
6968 { "(bad)", { XX
} },
6969 { "(bad)", { XX
} },
6970 { "(bad)", { XX
} },
6971 { "(bad)", { XX
} },
6976 { "(bad)", { XX
} },
6977 { "(bad)", { XX
} },
6978 { "(bad)", { XX
} },
6979 { "(bad)", { XX
} },
6980 { "(bad)", { XX
} },
6981 { "(bad)", { XX
} },
6982 { "(bad)", { XX
} },
6983 { "(bad)", { XX
} },
6985 { "(bad)", { XX
} },
6986 { "(bad)", { XX
} },
6987 { "(bad)", { XX
} },
6988 { "(bad)", { XX
} },
6989 { "(bad)", { XX
} },
6990 { "(bad)", { XX
} },
6991 { "(bad)", { XX
} },
6992 { "(bad)", { XX
} },
6994 { "(bad)", { XX
} },
6995 { "(bad)", { XX
} },
6996 { REG_TABLE (REG_XOP_LWP
) },
6997 { "(bad)", { XX
} },
6998 { "(bad)", { XX
} },
6999 { "(bad)", { XX
} },
7000 { "(bad)", { XX
} },
7001 { "(bad)", { XX
} },
7003 { "(bad)", { XX
} },
7004 { "(bad)", { XX
} },
7005 { "(bad)", { XX
} },
7006 { "(bad)", { XX
} },
7007 { "(bad)", { XX
} },
7008 { "(bad)", { XX
} },
7009 { "(bad)", { XX
} },
7010 { "(bad)", { XX
} },
7012 { "(bad)", { XX
} },
7013 { "(bad)", { XX
} },
7014 { "(bad)", { XX
} },
7015 { "(bad)", { XX
} },
7016 { "(bad)", { XX
} },
7017 { "(bad)", { XX
} },
7018 { "(bad)", { XX
} },
7019 { "(bad)", { XX
} },
7021 { "(bad)", { XX
} },
7022 { "(bad)", { XX
} },
7023 { "(bad)", { XX
} },
7024 { "(bad)", { XX
} },
7025 { "(bad)", { XX
} },
7026 { "(bad)", { XX
} },
7027 { "(bad)", { XX
} },
7028 { "(bad)", { XX
} },
7030 { "(bad)", { XX
} },
7031 { "(bad)", { XX
} },
7032 { "(bad)", { XX
} },
7033 { "(bad)", { XX
} },
7034 { "(bad)", { XX
} },
7035 { "(bad)", { XX
} },
7036 { "(bad)", { XX
} },
7037 { "(bad)", { XX
} },
7039 { "(bad)", { XX
} },
7040 { "(bad)", { XX
} },
7041 { "(bad)", { XX
} },
7042 { "(bad)", { XX
} },
7043 { "(bad)", { XX
} },
7044 { "(bad)", { XX
} },
7045 { "(bad)", { XX
} },
7046 { "(bad)", { XX
} },
7048 { "(bad)", { XX
} },
7049 { "(bad)", { XX
} },
7050 { "(bad)", { XX
} },
7051 { "(bad)", { XX
} },
7052 { "(bad)", { XX
} },
7053 { "(bad)", { XX
} },
7054 { "(bad)", { XX
} },
7055 { "(bad)", { XX
} },
7057 { "(bad)", { XX
} },
7058 { "(bad)", { XX
} },
7059 { "(bad)", { XX
} },
7060 { "(bad)", { XX
} },
7061 { "(bad)", { XX
} },
7062 { "(bad)", { XX
} },
7063 { "(bad)", { XX
} },
7064 { "(bad)", { XX
} },
7066 { "(bad)", { XX
} },
7067 { "(bad)", { XX
} },
7068 { "(bad)", { XX
} },
7069 { "(bad)", { XX
} },
7070 { "(bad)", { XX
} },
7071 { "(bad)", { XX
} },
7072 { "(bad)", { XX
} },
7073 { "(bad)", { XX
} },
7075 { "(bad)", { XX
} },
7076 { "(bad)", { XX
} },
7077 { "(bad)", { XX
} },
7078 { "(bad)", { XX
} },
7079 { "(bad)", { XX
} },
7080 { "(bad)", { XX
} },
7081 { "(bad)", { XX
} },
7082 { "(bad)", { XX
} },
7084 { "(bad)", { XX
} },
7085 { "(bad)", { XX
} },
7086 { "(bad)", { XX
} },
7087 { "(bad)", { XX
} },
7088 { "(bad)", { XX
} },
7089 { "(bad)", { XX
} },
7090 { "(bad)", { XX
} },
7091 { "(bad)", { XX
} },
7093 { "(bad)", { XX
} },
7094 { "(bad)", { XX
} },
7095 { "(bad)", { XX
} },
7096 { "(bad)", { XX
} },
7097 { "(bad)", { XX
} },
7098 { "(bad)", { XX
} },
7099 { "(bad)", { XX
} },
7100 { "(bad)", { XX
} },
7102 { "(bad)", { XX
} },
7103 { "(bad)", { XX
} },
7104 { "(bad)", { XX
} },
7105 { "(bad)", { XX
} },
7106 { "(bad)", { XX
} },
7107 { "(bad)", { XX
} },
7108 { "(bad)", { XX
} },
7109 { "(bad)", { XX
} },
7111 { "(bad)", { XX
} },
7112 { "(bad)", { XX
} },
7113 { "(bad)", { XX
} },
7114 { "(bad)", { XX
} },
7115 { "(bad)", { XX
} },
7116 { "(bad)", { XX
} },
7117 { "(bad)", { XX
} },
7118 { "(bad)", { XX
} },
7120 { "(bad)", { XX
} },
7121 { "(bad)", { XX
} },
7122 { "(bad)", { XX
} },
7123 { "(bad)", { XX
} },
7124 { "(bad)", { XX
} },
7125 { "(bad)", { XX
} },
7126 { "(bad)", { XX
} },
7127 { "(bad)", { XX
} },
7129 { "(bad)", { XX
} },
7130 { "(bad)", { XX
} },
7131 { "(bad)", { XX
} },
7132 { "(bad)", { XX
} },
7133 { "(bad)", { XX
} },
7134 { "(bad)", { XX
} },
7135 { "(bad)", { XX
} },
7136 { "(bad)", { XX
} },
7138 { "(bad)", { XX
} },
7139 { "(bad)", { XX
} },
7140 { "(bad)", { XX
} },
7141 { "(bad)", { XX
} },
7142 { "(bad)", { XX
} },
7143 { "(bad)", { XX
} },
7144 { "(bad)", { XX
} },
7145 { "(bad)", { XX
} },
7147 { "(bad)", { XX
} },
7148 { "(bad)", { XX
} },
7149 { "(bad)", { XX
} },
7150 { "(bad)", { XX
} },
7151 { "(bad)", { XX
} },
7152 { "(bad)", { XX
} },
7153 { "(bad)", { XX
} },
7154 { "(bad)", { XX
} },
7156 { "(bad)", { XX
} },
7157 { "(bad)", { XX
} },
7158 { "(bad)", { XX
} },
7159 { "(bad)", { XX
} },
7160 { "(bad)", { XX
} },
7161 { "(bad)", { XX
} },
7162 { "(bad)", { XX
} },
7163 { "(bad)", { XX
} },
7165 { "(bad)", { XX
} },
7166 { "(bad)", { XX
} },
7167 { "(bad)", { XX
} },
7168 { "(bad)", { XX
} },
7169 { "(bad)", { XX
} },
7170 { "(bad)", { XX
} },
7171 { "(bad)", { XX
} },
7172 { "(bad)", { XX
} },
7174 { "(bad)", { XX
} },
7175 { "(bad)", { XX
} },
7176 { "(bad)", { XX
} },
7177 { "(bad)", { XX
} },
7178 { "(bad)", { XX
} },
7179 { "(bad)", { XX
} },
7180 { "(bad)", { XX
} },
7181 { "(bad)", { XX
} },
7183 { "(bad)", { XX
} },
7184 { "(bad)", { XX
} },
7185 { "(bad)", { XX
} },
7186 { "(bad)", { XX
} },
7187 { "(bad)", { XX
} },
7188 { "(bad)", { XX
} },
7189 { "(bad)", { XX
} },
7190 { "(bad)", { XX
} },
7192 { "(bad)", { XX
} },
7193 { "(bad)", { XX
} },
7194 { "(bad)", { XX
} },
7195 { "(bad)", { XX
} },
7196 { "(bad)", { XX
} },
7197 { "(bad)", { XX
} },
7198 { "(bad)", { XX
} },
7199 { "(bad)", { XX
} },
7201 { "(bad)", { XX
} },
7202 { "(bad)", { XX
} },
7203 { "(bad)", { XX
} },
7204 { "(bad)", { XX
} },
7205 { "(bad)", { XX
} },
7206 { "(bad)", { XX
} },
7207 { "(bad)", { XX
} },
7208 { "(bad)", { XX
} },
7210 { "(bad)", { XX
} },
7211 { "(bad)", { XX
} },
7212 { "(bad)", { XX
} },
7213 { "(bad)", { XX
} },
7214 { "(bad)", { XX
} },
7215 { "(bad)", { XX
} },
7216 { "(bad)", { XX
} },
7217 { "(bad)", { XX
} },
7219 { "(bad)", { XX
} },
7220 { "(bad)", { XX
} },
7221 { "(bad)", { XX
} },
7222 { "(bad)", { XX
} },
7223 { "(bad)", { XX
} },
7224 { "(bad)", { XX
} },
7225 { "(bad)", { XX
} },
7226 { "(bad)", { XX
} },
7228 { "(bad)", { XX
} },
7229 { "(bad)", { XX
} },
7230 { "(bad)", { XX
} },
7231 { "(bad)", { XX
} },
7232 { "(bad)", { XX
} },
7233 { "(bad)", { XX
} },
7234 { "(bad)", { XX
} },
7235 { "(bad)", { XX
} },
7237 { "(bad)", { XX
} },
7238 { "(bad)", { XX
} },
7239 { "(bad)", { XX
} },
7240 { "(bad)", { XX
} },
7241 { "(bad)", { XX
} },
7242 { "(bad)", { XX
} },
7243 { "(bad)", { XX
} },
7244 { "(bad)", { XX
} },
7246 { "(bad)", { XX
} },
7247 { "(bad)", { XX
} },
7248 { "(bad)", { XX
} },
7249 { "(bad)", { XX
} },
7250 { "(bad)", { XX
} },
7251 { "(bad)", { XX
} },
7252 { "(bad)", { XX
} },
7253 { "(bad)", { XX
} },
7255 { "(bad)", { XX
} },
7256 { "(bad)", { XX
} },
7257 { "(bad)", { XX
} },
7258 { "(bad)", { XX
} },
7259 { "(bad)", { XX
} },
7260 { "(bad)", { XX
} },
7261 { "(bad)", { XX
} },
7262 { "(bad)", { XX
} },
7266 static const struct dis386 vex_table
[][256] = {
7270 { "(bad)", { XX
} },
7271 { "(bad)", { XX
} },
7272 { "(bad)", { XX
} },
7273 { "(bad)", { XX
} },
7274 { "(bad)", { XX
} },
7275 { "(bad)", { XX
} },
7276 { "(bad)", { XX
} },
7277 { "(bad)", { XX
} },
7279 { "(bad)", { XX
} },
7280 { "(bad)", { XX
} },
7281 { "(bad)", { XX
} },
7282 { "(bad)", { XX
} },
7283 { "(bad)", { XX
} },
7284 { "(bad)", { XX
} },
7285 { "(bad)", { XX
} },
7286 { "(bad)", { XX
} },
7288 { PREFIX_TABLE (PREFIX_VEX_10
) },
7289 { PREFIX_TABLE (PREFIX_VEX_11
) },
7290 { PREFIX_TABLE (PREFIX_VEX_12
) },
7291 { MOD_TABLE (MOD_VEX_13
) },
7292 { "vunpcklpX", { XM
, Vex
, EXx
} },
7293 { "vunpckhpX", { XM
, Vex
, EXx
} },
7294 { PREFIX_TABLE (PREFIX_VEX_16
) },
7295 { MOD_TABLE (MOD_VEX_17
) },
7297 { "(bad)", { XX
} },
7298 { "(bad)", { XX
} },
7299 { "(bad)", { XX
} },
7300 { "(bad)", { XX
} },
7301 { "(bad)", { XX
} },
7302 { "(bad)", { XX
} },
7303 { "(bad)", { XX
} },
7304 { "(bad)", { XX
} },
7306 { "(bad)", { XX
} },
7307 { "(bad)", { XX
} },
7308 { "(bad)", { XX
} },
7309 { "(bad)", { XX
} },
7310 { "(bad)", { XX
} },
7311 { "(bad)", { XX
} },
7312 { "(bad)", { XX
} },
7313 { "(bad)", { XX
} },
7315 { "vmovapX", { XM
, EXx
} },
7316 { "vmovapX", { EXxS
, XM
} },
7317 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7318 { MOD_TABLE (MOD_VEX_2B
) },
7319 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7320 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7321 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7322 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7324 { "(bad)", { XX
} },
7325 { "(bad)", { XX
} },
7326 { "(bad)", { XX
} },
7327 { "(bad)", { XX
} },
7328 { "(bad)", { XX
} },
7329 { "(bad)", { XX
} },
7330 { "(bad)", { XX
} },
7331 { "(bad)", { XX
} },
7333 { "(bad)", { XX
} },
7334 { "(bad)", { XX
} },
7335 { "(bad)", { XX
} },
7336 { "(bad)", { XX
} },
7337 { "(bad)", { XX
} },
7338 { "(bad)", { XX
} },
7339 { "(bad)", { XX
} },
7340 { "(bad)", { XX
} },
7342 { "(bad)", { XX
} },
7343 { "(bad)", { XX
} },
7344 { "(bad)", { XX
} },
7345 { "(bad)", { XX
} },
7346 { "(bad)", { XX
} },
7347 { "(bad)", { XX
} },
7348 { "(bad)", { XX
} },
7349 { "(bad)", { XX
} },
7351 { "(bad)", { XX
} },
7352 { "(bad)", { XX
} },
7353 { "(bad)", { XX
} },
7354 { "(bad)", { XX
} },
7355 { "(bad)", { XX
} },
7356 { "(bad)", { XX
} },
7357 { "(bad)", { XX
} },
7358 { "(bad)", { XX
} },
7360 { MOD_TABLE (MOD_VEX_51
) },
7361 { PREFIX_TABLE (PREFIX_VEX_51
) },
7362 { PREFIX_TABLE (PREFIX_VEX_52
) },
7363 { PREFIX_TABLE (PREFIX_VEX_53
) },
7364 { "vandpX", { XM
, Vex
, EXx
} },
7365 { "vandnpX", { XM
, Vex
, EXx
} },
7366 { "vorpX", { XM
, Vex
, EXx
} },
7367 { "vxorpX", { XM
, Vex
, EXx
} },
7369 { PREFIX_TABLE (PREFIX_VEX_58
) },
7370 { PREFIX_TABLE (PREFIX_VEX_59
) },
7371 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7372 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7373 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7374 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7375 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7376 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7378 { PREFIX_TABLE (PREFIX_VEX_60
) },
7379 { PREFIX_TABLE (PREFIX_VEX_61
) },
7380 { PREFIX_TABLE (PREFIX_VEX_62
) },
7381 { PREFIX_TABLE (PREFIX_VEX_63
) },
7382 { PREFIX_TABLE (PREFIX_VEX_64
) },
7383 { PREFIX_TABLE (PREFIX_VEX_65
) },
7384 { PREFIX_TABLE (PREFIX_VEX_66
) },
7385 { PREFIX_TABLE (PREFIX_VEX_67
) },
7387 { PREFIX_TABLE (PREFIX_VEX_68
) },
7388 { PREFIX_TABLE (PREFIX_VEX_69
) },
7389 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7390 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7391 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7392 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7393 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7394 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7396 { PREFIX_TABLE (PREFIX_VEX_70
) },
7397 { REG_TABLE (REG_VEX_71
) },
7398 { REG_TABLE (REG_VEX_72
) },
7399 { REG_TABLE (REG_VEX_73
) },
7400 { PREFIX_TABLE (PREFIX_VEX_74
) },
7401 { PREFIX_TABLE (PREFIX_VEX_75
) },
7402 { PREFIX_TABLE (PREFIX_VEX_76
) },
7403 { PREFIX_TABLE (PREFIX_VEX_77
) },
7405 { "(bad)", { XX
} },
7406 { "(bad)", { XX
} },
7407 { "(bad)", { XX
} },
7408 { "(bad)", { XX
} },
7409 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7410 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7411 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7412 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7414 { "(bad)", { XX
} },
7415 { "(bad)", { XX
} },
7416 { "(bad)", { XX
} },
7417 { "(bad)", { XX
} },
7418 { "(bad)", { XX
} },
7419 { "(bad)", { XX
} },
7420 { "(bad)", { XX
} },
7421 { "(bad)", { XX
} },
7423 { "(bad)", { XX
} },
7424 { "(bad)", { XX
} },
7425 { "(bad)", { XX
} },
7426 { "(bad)", { XX
} },
7427 { "(bad)", { XX
} },
7428 { "(bad)", { XX
} },
7429 { "(bad)", { XX
} },
7430 { "(bad)", { XX
} },
7432 { "(bad)", { XX
} },
7433 { "(bad)", { XX
} },
7434 { "(bad)", { XX
} },
7435 { "(bad)", { XX
} },
7436 { "(bad)", { XX
} },
7437 { "(bad)", { XX
} },
7438 { "(bad)", { XX
} },
7439 { "(bad)", { XX
} },
7441 { "(bad)", { XX
} },
7442 { "(bad)", { XX
} },
7443 { "(bad)", { XX
} },
7444 { "(bad)", { XX
} },
7445 { "(bad)", { XX
} },
7446 { "(bad)", { XX
} },
7447 { "(bad)", { XX
} },
7448 { "(bad)", { XX
} },
7450 { "(bad)", { XX
} },
7451 { "(bad)", { XX
} },
7452 { "(bad)", { XX
} },
7453 { "(bad)", { XX
} },
7454 { "(bad)", { XX
} },
7455 { "(bad)", { XX
} },
7456 { "(bad)", { XX
} },
7457 { "(bad)", { XX
} },
7459 { "(bad)", { XX
} },
7460 { "(bad)", { XX
} },
7461 { "(bad)", { XX
} },
7462 { "(bad)", { XX
} },
7463 { "(bad)", { XX
} },
7464 { "(bad)", { XX
} },
7465 { REG_TABLE (REG_VEX_AE
) },
7466 { "(bad)", { XX
} },
7468 { "(bad)", { XX
} },
7469 { "(bad)", { XX
} },
7470 { "(bad)", { XX
} },
7471 { "(bad)", { XX
} },
7472 { "(bad)", { XX
} },
7473 { "(bad)", { XX
} },
7474 { "(bad)", { XX
} },
7475 { "(bad)", { XX
} },
7477 { "(bad)", { XX
} },
7478 { "(bad)", { XX
} },
7479 { "(bad)", { XX
} },
7480 { "(bad)", { XX
} },
7481 { "(bad)", { XX
} },
7482 { "(bad)", { XX
} },
7483 { "(bad)", { XX
} },
7484 { "(bad)", { XX
} },
7486 { "(bad)", { XX
} },
7487 { "(bad)", { XX
} },
7488 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7489 { "(bad)", { XX
} },
7490 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7491 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7492 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7493 { "(bad)", { XX
} },
7495 { "(bad)", { XX
} },
7496 { "(bad)", { XX
} },
7497 { "(bad)", { XX
} },
7498 { "(bad)", { XX
} },
7499 { "(bad)", { XX
} },
7500 { "(bad)", { XX
} },
7501 { "(bad)", { XX
} },
7502 { "(bad)", { XX
} },
7504 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7505 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7506 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7507 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7508 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7509 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7510 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7511 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7513 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7514 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7515 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7516 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7517 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7518 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7519 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7520 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7522 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7523 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7524 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7525 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7526 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7527 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7528 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7529 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7531 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7532 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7533 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7534 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7535 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7536 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7537 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7538 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7540 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7541 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7542 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7543 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7544 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7545 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7546 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7547 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7549 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7550 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7551 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7552 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7553 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7554 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7555 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7556 { "(bad)", { XX
} },
7561 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7562 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7563 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7564 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7565 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7566 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7567 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7568 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7570 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7571 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7572 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7573 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7574 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7575 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7576 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7577 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7579 { "(bad)", { XX
} },
7580 { "(bad)", { XX
} },
7581 { "(bad)", { XX
} },
7582 { "(bad)", { XX
} },
7583 { "(bad)", { XX
} },
7584 { "(bad)", { XX
} },
7585 { "(bad)", { XX
} },
7586 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7588 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7589 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7590 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7591 { "(bad)", { XX
} },
7592 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7593 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7594 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7595 { "(bad)", { XX
} },
7597 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7598 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7599 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7600 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7601 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7602 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7603 { "(bad)", { XX
} },
7604 { "(bad)", { XX
} },
7606 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7607 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7608 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7609 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7610 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7611 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7612 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7613 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7615 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7616 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7617 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7618 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7619 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7620 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7621 { "(bad)", { XX
} },
7622 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7624 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7625 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7626 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7627 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7628 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7629 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7630 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7631 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7633 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7634 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7635 { "(bad)", { XX
} },
7636 { "(bad)", { XX
} },
7637 { "(bad)", { XX
} },
7638 { "(bad)", { XX
} },
7639 { "(bad)", { XX
} },
7640 { "(bad)", { XX
} },
7642 { "(bad)", { XX
} },
7643 { "(bad)", { XX
} },
7644 { "(bad)", { XX
} },
7645 { "(bad)", { XX
} },
7646 { "(bad)", { XX
} },
7647 { "(bad)", { XX
} },
7648 { "(bad)", { XX
} },
7649 { "(bad)", { XX
} },
7651 { "(bad)", { XX
} },
7652 { "(bad)", { XX
} },
7653 { "(bad)", { XX
} },
7654 { "(bad)", { XX
} },
7655 { "(bad)", { XX
} },
7656 { "(bad)", { XX
} },
7657 { "(bad)", { XX
} },
7658 { "(bad)", { XX
} },
7660 { "(bad)", { XX
} },
7661 { "(bad)", { XX
} },
7662 { "(bad)", { XX
} },
7663 { "(bad)", { XX
} },
7664 { "(bad)", { XX
} },
7665 { "(bad)", { XX
} },
7666 { "(bad)", { XX
} },
7667 { "(bad)", { XX
} },
7669 { "(bad)", { XX
} },
7670 { "(bad)", { XX
} },
7671 { "(bad)", { XX
} },
7672 { "(bad)", { XX
} },
7673 { "(bad)", { XX
} },
7674 { "(bad)", { XX
} },
7675 { "(bad)", { XX
} },
7676 { "(bad)", { XX
} },
7678 { "(bad)", { XX
} },
7679 { "(bad)", { XX
} },
7680 { "(bad)", { XX
} },
7681 { "(bad)", { XX
} },
7682 { "(bad)", { XX
} },
7683 { "(bad)", { XX
} },
7684 { "(bad)", { XX
} },
7685 { "(bad)", { XX
} },
7687 { "(bad)", { XX
} },
7688 { "(bad)", { XX
} },
7689 { "(bad)", { XX
} },
7690 { "(bad)", { XX
} },
7691 { "(bad)", { XX
} },
7692 { "(bad)", { XX
} },
7693 { "(bad)", { XX
} },
7694 { "(bad)", { XX
} },
7696 { "(bad)", { XX
} },
7697 { "(bad)", { XX
} },
7698 { "(bad)", { XX
} },
7699 { "(bad)", { XX
} },
7700 { "(bad)", { XX
} },
7701 { "(bad)", { XX
} },
7702 { "(bad)", { XX
} },
7703 { "(bad)", { XX
} },
7705 { "(bad)", { XX
} },
7706 { "(bad)", { XX
} },
7707 { "(bad)", { XX
} },
7708 { "(bad)", { XX
} },
7709 { "(bad)", { XX
} },
7710 { "(bad)", { XX
} },
7711 { "(bad)", { XX
} },
7712 { "(bad)", { XX
} },
7714 { "(bad)", { XX
} },
7715 { "(bad)", { XX
} },
7716 { "(bad)", { XX
} },
7717 { "(bad)", { XX
} },
7718 { "(bad)", { XX
} },
7719 { "(bad)", { XX
} },
7720 { "(bad)", { XX
} },
7721 { "(bad)", { XX
} },
7723 { "(bad)", { XX
} },
7724 { "(bad)", { XX
} },
7725 { "(bad)", { XX
} },
7726 { "(bad)", { XX
} },
7727 { "(bad)", { XX
} },
7728 { "(bad)", { XX
} },
7729 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7730 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7732 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7733 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7734 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7735 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7736 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7737 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7738 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7739 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7741 { "(bad)", { XX
} },
7742 { "(bad)", { XX
} },
7743 { "(bad)", { XX
} },
7744 { "(bad)", { XX
} },
7745 { "(bad)", { XX
} },
7746 { "(bad)", { XX
} },
7747 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7748 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7750 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7751 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7752 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7753 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7754 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7755 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7756 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7757 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7759 { "(bad)", { XX
} },
7760 { "(bad)", { XX
} },
7761 { "(bad)", { XX
} },
7762 { "(bad)", { XX
} },
7763 { "(bad)", { XX
} },
7764 { "(bad)", { XX
} },
7765 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7766 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7768 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7769 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7770 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7771 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7772 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7773 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7774 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7775 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7777 { "(bad)", { XX
} },
7778 { "(bad)", { XX
} },
7779 { "(bad)", { XX
} },
7780 { "(bad)", { XX
} },
7781 { "(bad)", { XX
} },
7782 { "(bad)", { XX
} },
7783 { "(bad)", { XX
} },
7784 { "(bad)", { XX
} },
7786 { "(bad)", { XX
} },
7787 { "(bad)", { XX
} },
7788 { "(bad)", { XX
} },
7789 { "(bad)", { XX
} },
7790 { "(bad)", { XX
} },
7791 { "(bad)", { XX
} },
7792 { "(bad)", { XX
} },
7793 { "(bad)", { XX
} },
7795 { "(bad)", { XX
} },
7796 { "(bad)", { XX
} },
7797 { "(bad)", { XX
} },
7798 { "(bad)", { XX
} },
7799 { "(bad)", { XX
} },
7800 { "(bad)", { XX
} },
7801 { "(bad)", { XX
} },
7802 { "(bad)", { XX
} },
7804 { "(bad)", { XX
} },
7805 { "(bad)", { XX
} },
7806 { "(bad)", { XX
} },
7807 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7808 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7809 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7810 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7811 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7813 { "(bad)", { XX
} },
7814 { "(bad)", { XX
} },
7815 { "(bad)", { XX
} },
7816 { "(bad)", { XX
} },
7817 { "(bad)", { XX
} },
7818 { "(bad)", { XX
} },
7819 { "(bad)", { XX
} },
7820 { "(bad)", { XX
} },
7822 { "(bad)", { XX
} },
7823 { "(bad)", { XX
} },
7824 { "(bad)", { XX
} },
7825 { "(bad)", { XX
} },
7826 { "(bad)", { XX
} },
7827 { "(bad)", { XX
} },
7828 { "(bad)", { XX
} },
7829 { "(bad)", { XX
} },
7831 { "(bad)", { XX
} },
7832 { "(bad)", { XX
} },
7833 { "(bad)", { XX
} },
7834 { "(bad)", { XX
} },
7835 { "(bad)", { XX
} },
7836 { "(bad)", { XX
} },
7837 { "(bad)", { XX
} },
7838 { "(bad)", { XX
} },
7840 { "(bad)", { XX
} },
7841 { "(bad)", { XX
} },
7842 { "(bad)", { XX
} },
7843 { "(bad)", { XX
} },
7844 { "(bad)", { XX
} },
7845 { "(bad)", { XX
} },
7846 { "(bad)", { XX
} },
7847 { "(bad)", { XX
} },
7852 { "(bad)", { XX
} },
7853 { "(bad)", { XX
} },
7854 { "(bad)", { XX
} },
7855 { "(bad)", { XX
} },
7856 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7857 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7858 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7859 { "(bad)", { XX
} },
7861 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7862 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7863 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7864 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7865 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7866 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7867 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7868 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7870 { "(bad)", { XX
} },
7871 { "(bad)", { XX
} },
7872 { "(bad)", { XX
} },
7873 { "(bad)", { XX
} },
7874 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7875 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7876 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7877 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7879 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7880 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7881 { "(bad)", { XX
} },
7882 { "(bad)", { XX
} },
7883 { "(bad)", { XX
} },
7884 { "(bad)", { XX
} },
7885 { "(bad)", { XX
} },
7886 { "(bad)", { XX
} },
7888 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7889 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7890 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
7891 { "(bad)", { XX
} },
7892 { "(bad)", { XX
} },
7893 { "(bad)", { XX
} },
7894 { "(bad)", { XX
} },
7895 { "(bad)", { XX
} },
7897 { "(bad)", { XX
} },
7898 { "(bad)", { XX
} },
7899 { "(bad)", { XX
} },
7900 { "(bad)", { XX
} },
7901 { "(bad)", { XX
} },
7902 { "(bad)", { XX
} },
7903 { "(bad)", { XX
} },
7904 { "(bad)", { XX
} },
7906 { "(bad)", { XX
} },
7907 { "(bad)", { XX
} },
7908 { "(bad)", { XX
} },
7909 { "(bad)", { XX
} },
7910 { "(bad)", { XX
} },
7911 { "(bad)", { XX
} },
7912 { "(bad)", { XX
} },
7913 { "(bad)", { XX
} },
7915 { "(bad)", { XX
} },
7916 { "(bad)", { XX
} },
7917 { "(bad)", { XX
} },
7918 { "(bad)", { XX
} },
7919 { "(bad)", { XX
} },
7920 { "(bad)", { XX
} },
7921 { "(bad)", { XX
} },
7922 { "(bad)", { XX
} },
7924 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7925 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7926 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7927 { "(bad)", { XX
} },
7928 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7929 { "(bad)", { XX
} },
7930 { "(bad)", { XX
} },
7931 { "(bad)", { XX
} },
7933 { "(bad)", { XX
} },
7934 { "(bad)", { XX
} },
7935 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7936 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7937 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7938 { "(bad)", { XX
} },
7939 { "(bad)", { XX
} },
7940 { "(bad)", { XX
} },
7942 { "(bad)", { XX
} },
7943 { "(bad)", { XX
} },
7944 { "(bad)", { XX
} },
7945 { "(bad)", { XX
} },
7946 { "(bad)", { XX
} },
7947 { "(bad)", { XX
} },
7948 { "(bad)", { XX
} },
7949 { "(bad)", { XX
} },
7951 { "(bad)", { XX
} },
7952 { "(bad)", { XX
} },
7953 { "(bad)", { XX
} },
7954 { "(bad)", { XX
} },
7955 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7956 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7957 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7958 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7960 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7961 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7962 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7963 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7964 { "(bad)", { XX
} },
7965 { "(bad)", { XX
} },
7966 { "(bad)", { XX
} },
7967 { "(bad)", { XX
} },
7969 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7970 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7971 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7972 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7973 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7974 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7975 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7976 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
7978 { "(bad)", { XX
} },
7979 { "(bad)", { XX
} },
7980 { "(bad)", { XX
} },
7981 { "(bad)", { XX
} },
7982 { "(bad)", { XX
} },
7983 { "(bad)", { XX
} },
7984 { "(bad)", { XX
} },
7985 { "(bad)", { XX
} },
7987 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7988 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7989 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7990 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7991 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7992 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7993 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7994 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
7996 { "(bad)", { XX
} },
7997 { "(bad)", { XX
} },
7998 { "(bad)", { XX
} },
7999 { "(bad)", { XX
} },
8000 { "(bad)", { XX
} },
8001 { "(bad)", { XX
} },
8002 { "(bad)", { XX
} },
8003 { "(bad)", { XX
} },
8005 { "(bad)", { XX
} },
8006 { "(bad)", { XX
} },
8007 { "(bad)", { XX
} },
8008 { "(bad)", { XX
} },
8009 { "(bad)", { XX
} },
8010 { "(bad)", { XX
} },
8011 { "(bad)", { XX
} },
8012 { "(bad)", { XX
} },
8014 { "(bad)", { XX
} },
8015 { "(bad)", { XX
} },
8016 { "(bad)", { XX
} },
8017 { "(bad)", { XX
} },
8018 { "(bad)", { XX
} },
8019 { "(bad)", { XX
} },
8020 { "(bad)", { XX
} },
8021 { "(bad)", { XX
} },
8023 { "(bad)", { XX
} },
8024 { "(bad)", { XX
} },
8025 { "(bad)", { XX
} },
8026 { "(bad)", { XX
} },
8027 { "(bad)", { XX
} },
8028 { "(bad)", { XX
} },
8029 { "(bad)", { XX
} },
8030 { "(bad)", { XX
} },
8032 { "(bad)", { XX
} },
8033 { "(bad)", { XX
} },
8034 { "(bad)", { XX
} },
8035 { "(bad)", { XX
} },
8036 { "(bad)", { XX
} },
8037 { "(bad)", { XX
} },
8038 { "(bad)", { XX
} },
8039 { "(bad)", { XX
} },
8041 { "(bad)", { XX
} },
8042 { "(bad)", { XX
} },
8043 { "(bad)", { XX
} },
8044 { "(bad)", { XX
} },
8045 { "(bad)", { XX
} },
8046 { "(bad)", { XX
} },
8047 { "(bad)", { XX
} },
8048 { "(bad)", { XX
} },
8050 { "(bad)", { XX
} },
8051 { "(bad)", { XX
} },
8052 { "(bad)", { XX
} },
8053 { "(bad)", { XX
} },
8054 { "(bad)", { XX
} },
8055 { "(bad)", { XX
} },
8056 { "(bad)", { XX
} },
8057 { "(bad)", { XX
} },
8059 { "(bad)", { XX
} },
8060 { "(bad)", { XX
} },
8061 { "(bad)", { XX
} },
8062 { "(bad)", { XX
} },
8063 { "(bad)", { XX
} },
8064 { "(bad)", { XX
} },
8065 { "(bad)", { XX
} },
8066 { "(bad)", { XX
} },
8068 { "(bad)", { XX
} },
8069 { "(bad)", { XX
} },
8070 { "(bad)", { XX
} },
8071 { "(bad)", { XX
} },
8072 { "(bad)", { XX
} },
8073 { "(bad)", { XX
} },
8074 { "(bad)", { XX
} },
8075 { "(bad)", { XX
} },
8077 { "(bad)", { XX
} },
8078 { "(bad)", { XX
} },
8079 { "(bad)", { XX
} },
8080 { "(bad)", { XX
} },
8081 { "(bad)", { XX
} },
8082 { "(bad)", { XX
} },
8083 { "(bad)", { XX
} },
8084 { "(bad)", { XX
} },
8086 { "(bad)", { XX
} },
8087 { "(bad)", { XX
} },
8088 { "(bad)", { XX
} },
8089 { "(bad)", { XX
} },
8090 { "(bad)", { XX
} },
8091 { "(bad)", { XX
} },
8092 { "(bad)", { XX
} },
8093 { "(bad)", { XX
} },
8095 { "(bad)", { XX
} },
8096 { "(bad)", { XX
} },
8097 { "(bad)", { XX
} },
8098 { "(bad)", { XX
} },
8099 { "(bad)", { XX
} },
8100 { "(bad)", { XX
} },
8101 { "(bad)", { XX
} },
8102 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8104 { "(bad)", { XX
} },
8105 { "(bad)", { XX
} },
8106 { "(bad)", { XX
} },
8107 { "(bad)", { XX
} },
8108 { "(bad)", { XX
} },
8109 { "(bad)", { XX
} },
8110 { "(bad)", { XX
} },
8111 { "(bad)", { XX
} },
8113 { "(bad)", { XX
} },
8114 { "(bad)", { XX
} },
8115 { "(bad)", { XX
} },
8116 { "(bad)", { XX
} },
8117 { "(bad)", { XX
} },
8118 { "(bad)", { XX
} },
8119 { "(bad)", { XX
} },
8120 { "(bad)", { XX
} },
8122 { "(bad)", { XX
} },
8123 { "(bad)", { XX
} },
8124 { "(bad)", { XX
} },
8125 { "(bad)", { XX
} },
8126 { "(bad)", { XX
} },
8127 { "(bad)", { XX
} },
8128 { "(bad)", { XX
} },
8129 { "(bad)", { XX
} },
8131 { "(bad)", { XX
} },
8132 { "(bad)", { XX
} },
8133 { "(bad)", { XX
} },
8134 { "(bad)", { XX
} },
8135 { "(bad)", { XX
} },
8136 { "(bad)", { XX
} },
8137 { "(bad)", { XX
} },
8138 { "(bad)", { XX
} },
8142 static const struct dis386 vex_len_table
[][2] = {
8143 /* VEX_LEN_10_P_1 */
8145 { "vmovss", { XMVex
, Vex128
, EXd
} },
8146 { "(bad)", { XX
} },
8149 /* VEX_LEN_10_P_3 */
8151 { "vmovsd", { XMVex
, Vex128
, EXq
} },
8152 { "(bad)", { XX
} },
8155 /* VEX_LEN_11_P_1 */
8157 { "vmovss", { EXdVexS
, Vex128
, XM
} },
8158 { "(bad)", { XX
} },
8161 /* VEX_LEN_11_P_3 */
8163 { "vmovsd", { EXqVexS
, Vex128
, XM
} },
8164 { "(bad)", { XX
} },
8167 /* VEX_LEN_12_P_0_M_0 */
8169 { "vmovlps", { XM
, Vex128
, EXq
} },
8170 { "(bad)", { XX
} },
8173 /* VEX_LEN_12_P_0_M_1 */
8175 { "vmovhlps", { XM
, Vex128
, EXq
} },
8176 { "(bad)", { XX
} },
8179 /* VEX_LEN_12_P_2 */
8181 { "vmovlpd", { XM
, Vex128
, EXq
} },
8182 { "(bad)", { XX
} },
8185 /* VEX_LEN_13_M_0 */
8187 { "vmovlpX", { EXq
, XM
} },
8188 { "(bad)", { XX
} },
8191 /* VEX_LEN_16_P_0_M_0 */
8193 { "vmovhps", { XM
, Vex128
, EXq
} },
8194 { "(bad)", { XX
} },
8197 /* VEX_LEN_16_P_0_M_1 */
8199 { "vmovlhps", { XM
, Vex128
, EXq
} },
8200 { "(bad)", { XX
} },
8203 /* VEX_LEN_16_P_2 */
8205 { "vmovhpd", { XM
, Vex128
, EXq
} },
8206 { "(bad)", { XX
} },
8209 /* VEX_LEN_17_M_0 */
8211 { "vmovhpX", { EXq
, XM
} },
8212 { "(bad)", { XX
} },
8215 /* VEX_LEN_2A_P_1 */
8217 { "vcvtsi2ss%LQ", { XM
, Vex128
, Ev
} },
8218 { "(bad)", { XX
} },
8221 /* VEX_LEN_2A_P_3 */
8223 { "vcvtsi2sd%LQ", { XM
, Vex128
, Ev
} },
8224 { "(bad)", { XX
} },
8227 /* VEX_LEN_2C_P_1 */
8229 { "vcvttss2siY", { Gv
, EXd
} },
8230 { "(bad)", { XX
} },
8233 /* VEX_LEN_2C_P_3 */
8235 { "vcvttsd2siY", { Gv
, EXq
} },
8236 { "(bad)", { XX
} },
8239 /* VEX_LEN_2D_P_1 */
8241 { "vcvtss2siY", { Gv
, EXd
} },
8242 { "(bad)", { XX
} },
8245 /* VEX_LEN_2D_P_3 */
8247 { "vcvtsd2siY", { Gv
, EXq
} },
8248 { "(bad)", { XX
} },
8251 /* VEX_LEN_2E_P_0 */
8253 { "vucomiss", { XM
, EXd
} },
8254 { "(bad)", { XX
} },
8257 /* VEX_LEN_2E_P_2 */
8259 { "vucomisd", { XM
, EXq
} },
8260 { "(bad)", { XX
} },
8263 /* VEX_LEN_2F_P_0 */
8265 { "vcomiss", { XM
, EXd
} },
8266 { "(bad)", { XX
} },
8269 /* VEX_LEN_2F_P_2 */
8271 { "vcomisd", { XM
, EXq
} },
8272 { "(bad)", { XX
} },
8275 /* VEX_LEN_51_P_1 */
8277 { "vsqrtss", { XM
, Vex128
, EXd
} },
8278 { "(bad)", { XX
} },
8281 /* VEX_LEN_51_P_3 */
8283 { "vsqrtsd", { XM
, Vex128
, EXq
} },
8284 { "(bad)", { XX
} },
8287 /* VEX_LEN_52_P_1 */
8289 { "vrsqrtss", { XM
, Vex128
, EXd
} },
8290 { "(bad)", { XX
} },
8293 /* VEX_LEN_53_P_1 */
8295 { "vrcpss", { XM
, Vex128
, EXd
} },
8296 { "(bad)", { XX
} },
8299 /* VEX_LEN_58_P_1 */
8301 { "vaddss", { XM
, Vex128
, EXd
} },
8302 { "(bad)", { XX
} },
8305 /* VEX_LEN_58_P_3 */
8307 { "vaddsd", { XM
, Vex128
, EXq
} },
8308 { "(bad)", { XX
} },
8311 /* VEX_LEN_59_P_1 */
8313 { "vmulss", { XM
, Vex128
, EXd
} },
8314 { "(bad)", { XX
} },
8317 /* VEX_LEN_59_P_3 */
8319 { "vmulsd", { XM
, Vex128
, EXq
} },
8320 { "(bad)", { XX
} },
8323 /* VEX_LEN_5A_P_1 */
8325 { "vcvtss2sd", { XM
, Vex128
, EXd
} },
8326 { "(bad)", { XX
} },
8329 /* VEX_LEN_5A_P_3 */
8331 { "vcvtsd2ss", { XM
, Vex128
, EXq
} },
8332 { "(bad)", { XX
} },
8335 /* VEX_LEN_5C_P_1 */
8337 { "vsubss", { XM
, Vex128
, EXd
} },
8338 { "(bad)", { XX
} },
8341 /* VEX_LEN_5C_P_3 */
8343 { "vsubsd", { XM
, Vex128
, EXq
} },
8344 { "(bad)", { XX
} },
8347 /* VEX_LEN_5D_P_1 */
8349 { "vminss", { XM
, Vex128
, EXd
} },
8350 { "(bad)", { XX
} },
8353 /* VEX_LEN_5D_P_3 */
8355 { "vminsd", { XM
, Vex128
, EXq
} },
8356 { "(bad)", { XX
} },
8359 /* VEX_LEN_5E_P_1 */
8361 { "vdivss", { XM
, Vex128
, EXd
} },
8362 { "(bad)", { XX
} },
8365 /* VEX_LEN_5E_P_3 */
8367 { "vdivsd", { XM
, Vex128
, EXq
} },
8368 { "(bad)", { XX
} },
8371 /* VEX_LEN_5F_P_1 */
8373 { "vmaxss", { XM
, Vex128
, EXd
} },
8374 { "(bad)", { XX
} },
8377 /* VEX_LEN_5F_P_3 */
8379 { "vmaxsd", { XM
, Vex128
, EXq
} },
8380 { "(bad)", { XX
} },
8383 /* VEX_LEN_60_P_2 */
8385 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
8386 { "(bad)", { XX
} },
8389 /* VEX_LEN_61_P_2 */
8391 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
8392 { "(bad)", { XX
} },
8395 /* VEX_LEN_62_P_2 */
8397 { "vpunpckldq", { XM
, Vex128
, EXx
} },
8398 { "(bad)", { XX
} },
8401 /* VEX_LEN_63_P_2 */
8403 { "vpacksswb", { XM
, Vex128
, EXx
} },
8404 { "(bad)", { XX
} },
8407 /* VEX_LEN_64_P_2 */
8409 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
8410 { "(bad)", { XX
} },
8413 /* VEX_LEN_65_P_2 */
8415 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
8416 { "(bad)", { XX
} },
8419 /* VEX_LEN_66_P_2 */
8421 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
8422 { "(bad)", { XX
} },
8425 /* VEX_LEN_67_P_2 */
8427 { "vpackuswb", { XM
, Vex128
, EXx
} },
8428 { "(bad)", { XX
} },
8431 /* VEX_LEN_68_P_2 */
8433 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
8434 { "(bad)", { XX
} },
8437 /* VEX_LEN_69_P_2 */
8439 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
8440 { "(bad)", { XX
} },
8443 /* VEX_LEN_6A_P_2 */
8445 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
8446 { "(bad)", { XX
} },
8449 /* VEX_LEN_6B_P_2 */
8451 { "vpackssdw", { XM
, Vex128
, EXx
} },
8452 { "(bad)", { XX
} },
8455 /* VEX_LEN_6C_P_2 */
8457 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
8458 { "(bad)", { XX
} },
8461 /* VEX_LEN_6D_P_2 */
8463 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
8464 { "(bad)", { XX
} },
8467 /* VEX_LEN_6E_P_2 */
8469 { "vmovK", { XM
, Edq
} },
8470 { "(bad)", { XX
} },
8473 /* VEX_LEN_70_P_1 */
8475 { "vpshufhw", { XM
, EXx
, Ib
} },
8476 { "(bad)", { XX
} },
8479 /* VEX_LEN_70_P_2 */
8481 { "vpshufd", { XM
, EXx
, Ib
} },
8482 { "(bad)", { XX
} },
8485 /* VEX_LEN_70_P_3 */
8487 { "vpshuflw", { XM
, EXx
, Ib
} },
8488 { "(bad)", { XX
} },
8491 /* VEX_LEN_71_R_2_P_2 */
8493 { "vpsrlw", { Vex128
, XS
, Ib
} },
8494 { "(bad)", { XX
} },
8497 /* VEX_LEN_71_R_4_P_2 */
8499 { "vpsraw", { Vex128
, XS
, Ib
} },
8500 { "(bad)", { XX
} },
8503 /* VEX_LEN_71_R_6_P_2 */
8505 { "vpsllw", { Vex128
, XS
, Ib
} },
8506 { "(bad)", { XX
} },
8509 /* VEX_LEN_72_R_2_P_2 */
8511 { "vpsrld", { Vex128
, XS
, Ib
} },
8512 { "(bad)", { XX
} },
8515 /* VEX_LEN_72_R_4_P_2 */
8517 { "vpsrad", { Vex128
, XS
, Ib
} },
8518 { "(bad)", { XX
} },
8521 /* VEX_LEN_72_R_6_P_2 */
8523 { "vpslld", { Vex128
, XS
, Ib
} },
8524 { "(bad)", { XX
} },
8527 /* VEX_LEN_73_R_2_P_2 */
8529 { "vpsrlq", { Vex128
, XS
, Ib
} },
8530 { "(bad)", { XX
} },
8533 /* VEX_LEN_73_R_3_P_2 */
8535 { "vpsrldq", { Vex128
, XS
, Ib
} },
8536 { "(bad)", { XX
} },
8539 /* VEX_LEN_73_R_6_P_2 */
8541 { "vpsllq", { Vex128
, XS
, Ib
} },
8542 { "(bad)", { XX
} },
8545 /* VEX_LEN_73_R_7_P_2 */
8547 { "vpslldq", { Vex128
, XS
, Ib
} },
8548 { "(bad)", { XX
} },
8551 /* VEX_LEN_74_P_2 */
8553 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
8554 { "(bad)", { XX
} },
8557 /* VEX_LEN_75_P_2 */
8559 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
8560 { "(bad)", { XX
} },
8563 /* VEX_LEN_76_P_2 */
8565 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
8566 { "(bad)", { XX
} },
8569 /* VEX_LEN_7E_P_1 */
8571 { "vmovq", { XM
, EXq
} },
8572 { "(bad)", { XX
} },
8575 /* VEX_LEN_7E_P_2 */
8577 { "vmovK", { Edq
, XM
} },
8578 { "(bad)", { XX
} },
8581 /* VEX_LEN_AE_R_2_M_0 */
8583 { "vldmxcsr", { Md
} },
8584 { "(bad)", { XX
} },
8587 /* VEX_LEN_AE_R_3_M_0 */
8589 { "vstmxcsr", { Md
} },
8590 { "(bad)", { XX
} },
8593 /* VEX_LEN_C2_P_1 */
8595 { "vcmpss", { XM
, Vex128
, EXd
, VCMP
} },
8596 { "(bad)", { XX
} },
8599 /* VEX_LEN_C2_P_3 */
8601 { "vcmpsd", { XM
, Vex128
, EXq
, VCMP
} },
8602 { "(bad)", { XX
} },
8605 /* VEX_LEN_C4_P_2 */
8607 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
8608 { "(bad)", { XX
} },
8611 /* VEX_LEN_C5_P_2 */
8613 { "vpextrw", { Gdq
, XS
, Ib
} },
8614 { "(bad)", { XX
} },
8617 /* VEX_LEN_D1_P_2 */
8619 { "vpsrlw", { XM
, Vex128
, EXx
} },
8620 { "(bad)", { XX
} },
8623 /* VEX_LEN_D2_P_2 */
8625 { "vpsrld", { XM
, Vex128
, EXx
} },
8626 { "(bad)", { XX
} },
8629 /* VEX_LEN_D3_P_2 */
8631 { "vpsrlq", { XM
, Vex128
, EXx
} },
8632 { "(bad)", { XX
} },
8635 /* VEX_LEN_D4_P_2 */
8637 { "vpaddq", { XM
, Vex128
, EXx
} },
8638 { "(bad)", { XX
} },
8641 /* VEX_LEN_D5_P_2 */
8643 { "vpmullw", { XM
, Vex128
, EXx
} },
8644 { "(bad)", { XX
} },
8647 /* VEX_LEN_D6_P_2 */
8649 { "vmovq", { EXqS
, XM
} },
8650 { "(bad)", { XX
} },
8653 /* VEX_LEN_D7_P_2_M_1 */
8655 { "vpmovmskb", { Gdq
, XS
} },
8656 { "(bad)", { XX
} },
8659 /* VEX_LEN_D8_P_2 */
8661 { "vpsubusb", { XM
, Vex128
, EXx
} },
8662 { "(bad)", { XX
} },
8665 /* VEX_LEN_D9_P_2 */
8667 { "vpsubusw", { XM
, Vex128
, EXx
} },
8668 { "(bad)", { XX
} },
8671 /* VEX_LEN_DA_P_2 */
8673 { "vpminub", { XM
, Vex128
, EXx
} },
8674 { "(bad)", { XX
} },
8677 /* VEX_LEN_DB_P_2 */
8679 { "vpand", { XM
, Vex128
, EXx
} },
8680 { "(bad)", { XX
} },
8683 /* VEX_LEN_DC_P_2 */
8685 { "vpaddusb", { XM
, Vex128
, EXx
} },
8686 { "(bad)", { XX
} },
8689 /* VEX_LEN_DD_P_2 */
8691 { "vpaddusw", { XM
, Vex128
, EXx
} },
8692 { "(bad)", { XX
} },
8695 /* VEX_LEN_DE_P_2 */
8697 { "vpmaxub", { XM
, Vex128
, EXx
} },
8698 { "(bad)", { XX
} },
8701 /* VEX_LEN_DF_P_2 */
8703 { "vpandn", { XM
, Vex128
, EXx
} },
8704 { "(bad)", { XX
} },
8707 /* VEX_LEN_E0_P_2 */
8709 { "vpavgb", { XM
, Vex128
, EXx
} },
8710 { "(bad)", { XX
} },
8713 /* VEX_LEN_E1_P_2 */
8715 { "vpsraw", { XM
, Vex128
, EXx
} },
8716 { "(bad)", { XX
} },
8719 /* VEX_LEN_E2_P_2 */
8721 { "vpsrad", { XM
, Vex128
, EXx
} },
8722 { "(bad)", { XX
} },
8725 /* VEX_LEN_E3_P_2 */
8727 { "vpavgw", { XM
, Vex128
, EXx
} },
8728 { "(bad)", { XX
} },
8731 /* VEX_LEN_E4_P_2 */
8733 { "vpmulhuw", { XM
, Vex128
, EXx
} },
8734 { "(bad)", { XX
} },
8737 /* VEX_LEN_E5_P_2 */
8739 { "vpmulhw", { XM
, Vex128
, EXx
} },
8740 { "(bad)", { XX
} },
8743 /* VEX_LEN_E8_P_2 */
8745 { "vpsubsb", { XM
, Vex128
, EXx
} },
8746 { "(bad)", { XX
} },
8749 /* VEX_LEN_E9_P_2 */
8751 { "vpsubsw", { XM
, Vex128
, EXx
} },
8752 { "(bad)", { XX
} },
8755 /* VEX_LEN_EA_P_2 */
8757 { "vpminsw", { XM
, Vex128
, EXx
} },
8758 { "(bad)", { XX
} },
8761 /* VEX_LEN_EB_P_2 */
8763 { "vpor", { XM
, Vex128
, EXx
} },
8764 { "(bad)", { XX
} },
8767 /* VEX_LEN_EC_P_2 */
8769 { "vpaddsb", { XM
, Vex128
, EXx
} },
8770 { "(bad)", { XX
} },
8773 /* VEX_LEN_ED_P_2 */
8775 { "vpaddsw", { XM
, Vex128
, EXx
} },
8776 { "(bad)", { XX
} },
8779 /* VEX_LEN_EE_P_2 */
8781 { "vpmaxsw", { XM
, Vex128
, EXx
} },
8782 { "(bad)", { XX
} },
8785 /* VEX_LEN_EF_P_2 */
8787 { "vpxor", { XM
, Vex128
, EXx
} },
8788 { "(bad)", { XX
} },
8791 /* VEX_LEN_F1_P_2 */
8793 { "vpsllw", { XM
, Vex128
, EXx
} },
8794 { "(bad)", { XX
} },
8797 /* VEX_LEN_F2_P_2 */
8799 { "vpslld", { XM
, Vex128
, EXx
} },
8800 { "(bad)", { XX
} },
8803 /* VEX_LEN_F3_P_2 */
8805 { "vpsllq", { XM
, Vex128
, EXx
} },
8806 { "(bad)", { XX
} },
8809 /* VEX_LEN_F4_P_2 */
8811 { "vpmuludq", { XM
, Vex128
, EXx
} },
8812 { "(bad)", { XX
} },
8815 /* VEX_LEN_F5_P_2 */
8817 { "vpmaddwd", { XM
, Vex128
, EXx
} },
8818 { "(bad)", { XX
} },
8821 /* VEX_LEN_F6_P_2 */
8823 { "vpsadbw", { XM
, Vex128
, EXx
} },
8824 { "(bad)", { XX
} },
8827 /* VEX_LEN_F7_P_2 */
8829 { "vmaskmovdqu", { XM
, XS
} },
8830 { "(bad)", { XX
} },
8833 /* VEX_LEN_F8_P_2 */
8835 { "vpsubb", { XM
, Vex128
, EXx
} },
8836 { "(bad)", { XX
} },
8839 /* VEX_LEN_F9_P_2 */
8841 { "vpsubw", { XM
, Vex128
, EXx
} },
8842 { "(bad)", { XX
} },
8845 /* VEX_LEN_FA_P_2 */
8847 { "vpsubd", { XM
, Vex128
, EXx
} },
8848 { "(bad)", { XX
} },
8851 /* VEX_LEN_FB_P_2 */
8853 { "vpsubq", { XM
, Vex128
, EXx
} },
8854 { "(bad)", { XX
} },
8857 /* VEX_LEN_FC_P_2 */
8859 { "vpaddb", { XM
, Vex128
, EXx
} },
8860 { "(bad)", { XX
} },
8863 /* VEX_LEN_FD_P_2 */
8865 { "vpaddw", { XM
, Vex128
, EXx
} },
8866 { "(bad)", { XX
} },
8869 /* VEX_LEN_FE_P_2 */
8871 { "vpaddd", { XM
, Vex128
, EXx
} },
8872 { "(bad)", { XX
} },
8875 /* VEX_LEN_3800_P_2 */
8877 { "vpshufb", { XM
, Vex128
, EXx
} },
8878 { "(bad)", { XX
} },
8881 /* VEX_LEN_3801_P_2 */
8883 { "vphaddw", { XM
, Vex128
, EXx
} },
8884 { "(bad)", { XX
} },
8887 /* VEX_LEN_3802_P_2 */
8889 { "vphaddd", { XM
, Vex128
, EXx
} },
8890 { "(bad)", { XX
} },
8893 /* VEX_LEN_3803_P_2 */
8895 { "vphaddsw", { XM
, Vex128
, EXx
} },
8896 { "(bad)", { XX
} },
8899 /* VEX_LEN_3804_P_2 */
8901 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
8902 { "(bad)", { XX
} },
8905 /* VEX_LEN_3805_P_2 */
8907 { "vphsubw", { XM
, Vex128
, EXx
} },
8908 { "(bad)", { XX
} },
8911 /* VEX_LEN_3806_P_2 */
8913 { "vphsubd", { XM
, Vex128
, EXx
} },
8914 { "(bad)", { XX
} },
8917 /* VEX_LEN_3807_P_2 */
8919 { "vphsubsw", { XM
, Vex128
, EXx
} },
8920 { "(bad)", { XX
} },
8923 /* VEX_LEN_3808_P_2 */
8925 { "vpsignb", { XM
, Vex128
, EXx
} },
8926 { "(bad)", { XX
} },
8929 /* VEX_LEN_3809_P_2 */
8931 { "vpsignw", { XM
, Vex128
, EXx
} },
8932 { "(bad)", { XX
} },
8935 /* VEX_LEN_380A_P_2 */
8937 { "vpsignd", { XM
, Vex128
, EXx
} },
8938 { "(bad)", { XX
} },
8941 /* VEX_LEN_380B_P_2 */
8943 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
8944 { "(bad)", { XX
} },
8947 /* VEX_LEN_3819_P_2_M_0 */
8949 { "(bad)", { XX
} },
8950 { "vbroadcastsd", { XM
, Mq
} },
8953 /* VEX_LEN_381A_P_2_M_0 */
8955 { "(bad)", { XX
} },
8956 { "vbroadcastf128", { XM
, Mxmm
} },
8959 /* VEX_LEN_381C_P_2 */
8961 { "vpabsb", { XM
, EXx
} },
8962 { "(bad)", { XX
} },
8965 /* VEX_LEN_381D_P_2 */
8967 { "vpabsw", { XM
, EXx
} },
8968 { "(bad)", { XX
} },
8971 /* VEX_LEN_381E_P_2 */
8973 { "vpabsd", { XM
, EXx
} },
8974 { "(bad)", { XX
} },
8977 /* VEX_LEN_3820_P_2 */
8979 { "vpmovsxbw", { XM
, EXq
} },
8980 { "(bad)", { XX
} },
8983 /* VEX_LEN_3821_P_2 */
8985 { "vpmovsxbd", { XM
, EXd
} },
8986 { "(bad)", { XX
} },
8989 /* VEX_LEN_3822_P_2 */
8991 { "vpmovsxbq", { XM
, EXw
} },
8992 { "(bad)", { XX
} },
8995 /* VEX_LEN_3823_P_2 */
8997 { "vpmovsxwd", { XM
, EXq
} },
8998 { "(bad)", { XX
} },
9001 /* VEX_LEN_3824_P_2 */
9003 { "vpmovsxwq", { XM
, EXd
} },
9004 { "(bad)", { XX
} },
9007 /* VEX_LEN_3825_P_2 */
9009 { "vpmovsxdq", { XM
, EXq
} },
9010 { "(bad)", { XX
} },
9013 /* VEX_LEN_3828_P_2 */
9015 { "vpmuldq", { XM
, Vex128
, EXx
} },
9016 { "(bad)", { XX
} },
9019 /* VEX_LEN_3829_P_2 */
9021 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
9022 { "(bad)", { XX
} },
9025 /* VEX_LEN_382A_P_2_M_0 */
9027 { "vmovntdqa", { XM
, Mx
} },
9028 { "(bad)", { XX
} },
9031 /* VEX_LEN_382B_P_2 */
9033 { "vpackusdw", { XM
, Vex128
, EXx
} },
9034 { "(bad)", { XX
} },
9037 /* VEX_LEN_3830_P_2 */
9039 { "vpmovzxbw", { XM
, EXq
} },
9040 { "(bad)", { XX
} },
9043 /* VEX_LEN_3831_P_2 */
9045 { "vpmovzxbd", { XM
, EXd
} },
9046 { "(bad)", { XX
} },
9049 /* VEX_LEN_3832_P_2 */
9051 { "vpmovzxbq", { XM
, EXw
} },
9052 { "(bad)", { XX
} },
9055 /* VEX_LEN_3833_P_2 */
9057 { "vpmovzxwd", { XM
, EXq
} },
9058 { "(bad)", { XX
} },
9061 /* VEX_LEN_3834_P_2 */
9063 { "vpmovzxwq", { XM
, EXd
} },
9064 { "(bad)", { XX
} },
9067 /* VEX_LEN_3835_P_2 */
9069 { "vpmovzxdq", { XM
, EXq
} },
9070 { "(bad)", { XX
} },
9073 /* VEX_LEN_3837_P_2 */
9075 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
9076 { "(bad)", { XX
} },
9079 /* VEX_LEN_3838_P_2 */
9081 { "vpminsb", { XM
, Vex128
, EXx
} },
9082 { "(bad)", { XX
} },
9085 /* VEX_LEN_3839_P_2 */
9087 { "vpminsd", { XM
, Vex128
, EXx
} },
9088 { "(bad)", { XX
} },
9091 /* VEX_LEN_383A_P_2 */
9093 { "vpminuw", { XM
, Vex128
, EXx
} },
9094 { "(bad)", { XX
} },
9097 /* VEX_LEN_383B_P_2 */
9099 { "vpminud", { XM
, Vex128
, EXx
} },
9100 { "(bad)", { XX
} },
9103 /* VEX_LEN_383C_P_2 */
9105 { "vpmaxsb", { XM
, Vex128
, EXx
} },
9106 { "(bad)", { XX
} },
9109 /* VEX_LEN_383D_P_2 */
9111 { "vpmaxsd", { XM
, Vex128
, EXx
} },
9112 { "(bad)", { XX
} },
9115 /* VEX_LEN_383E_P_2 */
9117 { "vpmaxuw", { XM
, Vex128
, EXx
} },
9118 { "(bad)", { XX
} },
9121 /* VEX_LEN_383F_P_2 */
9123 { "vpmaxud", { XM
, Vex128
, EXx
} },
9124 { "(bad)", { XX
} },
9127 /* VEX_LEN_3840_P_2 */
9129 { "vpmulld", { XM
, Vex128
, EXx
} },
9130 { "(bad)", { XX
} },
9133 /* VEX_LEN_3841_P_2 */
9135 { "vphminposuw", { XM
, EXx
} },
9136 { "(bad)", { XX
} },
9139 /* VEX_LEN_38DB_P_2 */
9141 { "vaesimc", { XM
, EXx
} },
9142 { "(bad)", { XX
} },
9145 /* VEX_LEN_38DC_P_2 */
9147 { "vaesenc", { XM
, Vex128
, EXx
} },
9148 { "(bad)", { XX
} },
9151 /* VEX_LEN_38DD_P_2 */
9153 { "vaesenclast", { XM
, Vex128
, EXx
} },
9154 { "(bad)", { XX
} },
9157 /* VEX_LEN_38DE_P_2 */
9159 { "vaesdec", { XM
, Vex128
, EXx
} },
9160 { "(bad)", { XX
} },
9163 /* VEX_LEN_38DF_P_2 */
9165 { "vaesdeclast", { XM
, Vex128
, EXx
} },
9166 { "(bad)", { XX
} },
9169 /* VEX_LEN_3A06_P_2 */
9171 { "(bad)", { XX
} },
9172 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
9175 /* VEX_LEN_3A0A_P_2 */
9177 { "vroundss", { XM
, Vex128
, EXd
, Ib
} },
9178 { "(bad)", { XX
} },
9181 /* VEX_LEN_3A0B_P_2 */
9183 { "vroundsd", { XM
, Vex128
, EXq
, Ib
} },
9184 { "(bad)", { XX
} },
9187 /* VEX_LEN_3A0E_P_2 */
9189 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
9190 { "(bad)", { XX
} },
9193 /* VEX_LEN_3A0F_P_2 */
9195 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
9196 { "(bad)", { XX
} },
9199 /* VEX_LEN_3A14_P_2 */
9201 { "vpextrb", { Edqb
, XM
, Ib
} },
9202 { "(bad)", { XX
} },
9205 /* VEX_LEN_3A15_P_2 */
9207 { "vpextrw", { Edqw
, XM
, Ib
} },
9208 { "(bad)", { XX
} },
9211 /* VEX_LEN_3A16_P_2 */
9213 { "vpextrK", { Edq
, XM
, Ib
} },
9214 { "(bad)", { XX
} },
9217 /* VEX_LEN_3A17_P_2 */
9219 { "vextractps", { Edqd
, XM
, Ib
} },
9220 { "(bad)", { XX
} },
9223 /* VEX_LEN_3A18_P_2 */
9225 { "(bad)", { XX
} },
9226 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
9229 /* VEX_LEN_3A19_P_2 */
9231 { "(bad)", { XX
} },
9232 { "vextractf128", { EXxmm
, XM
, Ib
} },
9235 /* VEX_LEN_3A20_P_2 */
9237 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
9238 { "(bad)", { XX
} },
9241 /* VEX_LEN_3A21_P_2 */
9243 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
9244 { "(bad)", { XX
} },
9247 /* VEX_LEN_3A22_P_2 */
9249 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9250 { "(bad)", { XX
} },
9253 /* VEX_LEN_3A41_P_2 */
9255 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
9256 { "(bad)", { XX
} },
9259 /* VEX_LEN_3A42_P_2 */
9261 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
9262 { "(bad)", { XX
} },
9265 /* VEX_LEN_3A44_P_2 */
9267 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
9268 { "(bad)", { XX
} },
9271 /* VEX_LEN_3A4C_P_2 */
9273 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
9274 { "(bad)", { XX
} },
9277 /* VEX_LEN_3A60_P_2 */
9279 { "vpcmpestrm", { XM
, EXx
, Ib
} },
9280 { "(bad)", { XX
} },
9283 /* VEX_LEN_3A61_P_2 */
9285 { "vpcmpestri", { XM
, EXx
, Ib
} },
9286 { "(bad)", { XX
} },
9289 /* VEX_LEN_3A62_P_2 */
9291 { "vpcmpistrm", { XM
, EXx
, Ib
} },
9292 { "(bad)", { XX
} },
9295 /* VEX_LEN_3A63_P_2 */
9297 { "vpcmpistri", { XM
, EXx
, Ib
} },
9298 { "(bad)", { XX
} },
9301 /* VEX_LEN_3A6A_P_2 */
9303 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9304 { "(bad)", { XX
} },
9307 /* VEX_LEN_3A6B_P_2 */
9309 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9310 { "(bad)", { XX
} },
9313 /* VEX_LEN_3A6E_P_2 */
9315 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9316 { "(bad)", { XX
} },
9319 /* VEX_LEN_3A6F_P_2 */
9321 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9322 { "(bad)", { XX
} },
9325 /* VEX_LEN_3A7A_P_2 */
9327 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9328 { "(bad)", { XX
} },
9331 /* VEX_LEN_3A7B_P_2 */
9333 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9334 { "(bad)", { XX
} },
9337 /* VEX_LEN_3A7E_P_2 */
9339 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9340 { "(bad)", { XX
} },
9343 /* VEX_LEN_3A7F_P_2 */
9345 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9346 { "(bad)", { XX
} },
9349 /* VEX_LEN_3ADF_P_2 */
9351 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
9352 { "(bad)", { XX
} },
9354 /* VEX_LEN_XOP_09_80 */
9356 { "vfrczps", { XM
, EXxmm
} },
9357 { "vfrczps", { XM
, EXymmq
} },
9359 /* VEX_LEN_XOP_09_81 */
9361 { "vfrczpd", { XM
, EXxmm
} },
9362 { "vfrczpd", { XM
, EXymmq
} },
9366 static const struct dis386 mod_table
[][2] = {
9369 { "leaS", { Gv
, M
} },
9370 { "(bad)", { XX
} },
9373 /* MOD_0F01_REG_0 */
9374 { X86_64_TABLE (X86_64_0F01_REG_0
) },
9375 { RM_TABLE (RM_0F01_REG_0
) },
9378 /* MOD_0F01_REG_1 */
9379 { X86_64_TABLE (X86_64_0F01_REG_1
) },
9380 { RM_TABLE (RM_0F01_REG_1
) },
9383 /* MOD_0F01_REG_2 */
9384 { X86_64_TABLE (X86_64_0F01_REG_2
) },
9385 { RM_TABLE (RM_0F01_REG_2
) },
9388 /* MOD_0F01_REG_3 */
9389 { X86_64_TABLE (X86_64_0F01_REG_3
) },
9390 { RM_TABLE (RM_0F01_REG_3
) },
9393 /* MOD_0F01_REG_7 */
9394 { "invlpg", { Mb
} },
9395 { RM_TABLE (RM_0F01_REG_7
) },
9398 /* MOD_0F12_PREFIX_0 */
9399 { "movlps", { XM
, EXq
} },
9400 { "movhlps", { XM
, EXq
} },
9404 { "movlpX", { EXq
, XM
} },
9405 { "(bad)", { XX
} },
9408 /* MOD_0F16_PREFIX_0 */
9409 { "movhps", { XM
, EXq
} },
9410 { "movlhps", { XM
, EXq
} },
9414 { "movhpX", { EXq
, XM
} },
9415 { "(bad)", { XX
} },
9418 /* MOD_0F18_REG_0 */
9419 { "prefetchnta", { Mb
} },
9420 { "(bad)", { XX
} },
9423 /* MOD_0F18_REG_1 */
9424 { "prefetcht0", { Mb
} },
9425 { "(bad)", { XX
} },
9428 /* MOD_0F18_REG_2 */
9429 { "prefetcht1", { Mb
} },
9430 { "(bad)", { XX
} },
9433 /* MOD_0F18_REG_3 */
9434 { "prefetcht2", { Mb
} },
9435 { "(bad)", { XX
} },
9439 { "(bad)", { XX
} },
9440 { "movZ", { Rm
, Cm
} },
9444 { "(bad)", { XX
} },
9445 { "movZ", { Rm
, Dm
} },
9449 { "(bad)", { XX
} },
9450 { "movZ", { Cm
, Rm
} },
9454 { "(bad)", { XX
} },
9455 { "movZ", { Dm
, Rm
} },
9459 { "(bad)", { XX
} },
9460 { "movL", { Rd
, Td
} },
9464 { "(bad)", { XX
} },
9465 { "movL", { Td
, Rd
} },
9468 /* MOD_0F2B_PREFIX_0 */
9469 {"movntps", { Mx
, XM
} },
9470 { "(bad)", { XX
} },
9473 /* MOD_0F2B_PREFIX_1 */
9474 {"movntss", { Md
, XM
} },
9475 { "(bad)", { XX
} },
9478 /* MOD_0F2B_PREFIX_2 */
9479 {"movntpd", { Mx
, XM
} },
9480 { "(bad)", { XX
} },
9483 /* MOD_0F2B_PREFIX_3 */
9484 {"movntsd", { Mq
, XM
} },
9485 { "(bad)", { XX
} },
9489 { "(bad)", { XX
} },
9490 { "movmskpX", { Gdq
, XS
} },
9493 /* MOD_0F71_REG_2 */
9494 { "(bad)", { XX
} },
9495 { "psrlw", { MS
, Ib
} },
9498 /* MOD_0F71_REG_4 */
9499 { "(bad)", { XX
} },
9500 { "psraw", { MS
, Ib
} },
9503 /* MOD_0F71_REG_6 */
9504 { "(bad)", { XX
} },
9505 { "psllw", { MS
, Ib
} },
9508 /* MOD_0F72_REG_2 */
9509 { "(bad)", { XX
} },
9510 { "psrld", { MS
, Ib
} },
9513 /* MOD_0F72_REG_4 */
9514 { "(bad)", { XX
} },
9515 { "psrad", { MS
, Ib
} },
9518 /* MOD_0F72_REG_6 */
9519 { "(bad)", { XX
} },
9520 { "pslld", { MS
, Ib
} },
9523 /* MOD_0F73_REG_2 */
9524 { "(bad)", { XX
} },
9525 { "psrlq", { MS
, Ib
} },
9528 /* MOD_0F73_REG_3 */
9529 { "(bad)", { XX
} },
9530 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
9533 /* MOD_0F73_REG_6 */
9534 { "(bad)", { XX
} },
9535 { "psllq", { MS
, Ib
} },
9538 /* MOD_0F73_REG_7 */
9539 { "(bad)", { XX
} },
9540 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
9543 /* MOD_0FAE_REG_0 */
9544 { "fxsave", { M
} },
9545 { "(bad)", { XX
} },
9548 /* MOD_0FAE_REG_1 */
9549 { "fxrstor", { M
} },
9550 { "(bad)", { XX
} },
9553 /* MOD_0FAE_REG_2 */
9554 { "ldmxcsr", { Md
} },
9555 { "(bad)", { XX
} },
9558 /* MOD_0FAE_REG_3 */
9559 { "stmxcsr", { Md
} },
9560 { "(bad)", { XX
} },
9563 /* MOD_0FAE_REG_4 */
9565 { "(bad)", { XX
} },
9568 /* MOD_0FAE_REG_5 */
9569 { "xrstor", { M
} },
9570 { RM_TABLE (RM_0FAE_REG_5
) },
9573 /* MOD_0FAE_REG_6 */
9574 { "xsaveopt", { M
} },
9575 { RM_TABLE (RM_0FAE_REG_6
) },
9578 /* MOD_0FAE_REG_7 */
9579 { "clflush", { Mb
} },
9580 { RM_TABLE (RM_0FAE_REG_7
) },
9584 { "lssS", { Gv
, Mp
} },
9585 { "(bad)", { XX
} },
9589 { "lfsS", { Gv
, Mp
} },
9590 { "(bad)", { XX
} },
9594 { "lgsS", { Gv
, Mp
} },
9595 { "(bad)", { XX
} },
9598 /* MOD_0FC7_REG_6 */
9599 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
9600 { "(bad)", { XX
} },
9603 /* MOD_0FC7_REG_7 */
9604 { "vmptrst", { Mq
} },
9605 { "(bad)", { XX
} },
9609 { "(bad)", { XX
} },
9610 { "pmovmskb", { Gdq
, MS
} },
9613 /* MOD_0FE7_PREFIX_2 */
9614 { "movntdq", { Mx
, XM
} },
9615 { "(bad)", { XX
} },
9618 /* MOD_0FF0_PREFIX_3 */
9619 { "lddqu", { XM
, M
} },
9620 { "(bad)", { XX
} },
9623 /* MOD_0F382A_PREFIX_2 */
9624 { "movntdqa", { XM
, Mx
} },
9625 { "(bad)", { XX
} },
9629 { "bound{S|}", { Gv
, Ma
} },
9630 { "(bad)", { XX
} },
9634 { "lesS", { Gv
, Mp
} },
9635 { VEX_C4_TABLE (VEX_0F
) },
9639 { "ldsS", { Gv
, Mp
} },
9640 { VEX_C5_TABLE (VEX_0F
) },
9643 /* MOD_VEX_12_PREFIX_0 */
9644 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
9645 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
9649 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
9650 { "(bad)", { XX
} },
9653 /* MOD_VEX_16_PREFIX_0 */
9654 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
9655 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
9659 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
9660 { "(bad)", { XX
} },
9664 { "vmovntpX", { Mx
, XM
} },
9665 { "(bad)", { XX
} },
9669 { "(bad)", { XX
} },
9670 { "vmovmskpX", { Gdq
, XS
} },
9673 /* MOD_VEX_71_REG_2 */
9674 { "(bad)", { XX
} },
9675 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
9678 /* MOD_VEX_71_REG_4 */
9679 { "(bad)", { XX
} },
9680 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
9683 /* MOD_VEX_71_REG_6 */
9684 { "(bad)", { XX
} },
9685 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
9688 /* MOD_VEX_72_REG_2 */
9689 { "(bad)", { XX
} },
9690 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
9693 /* MOD_VEX_72_REG_4 */
9694 { "(bad)", { XX
} },
9695 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
9698 /* MOD_VEX_72_REG_6 */
9699 { "(bad)", { XX
} },
9700 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
9703 /* MOD_VEX_73_REG_2 */
9704 { "(bad)", { XX
} },
9705 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
9708 /* MOD_VEX_73_REG_3 */
9709 { "(bad)", { XX
} },
9710 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
9713 /* MOD_VEX_73_REG_6 */
9714 { "(bad)", { XX
} },
9715 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
9718 /* MOD_VEX_73_REG_7 */
9719 { "(bad)", { XX
} },
9720 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
9723 /* MOD_VEX_AE_REG_2 */
9724 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
9725 { "(bad)", { XX
} },
9728 /* MOD_VEX_AE_REG_3 */
9729 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
9730 { "(bad)", { XX
} },
9733 /* MOD_VEX_D7_PREFIX_2 */
9734 { "(bad)", { XX
} },
9735 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
9738 /* MOD_VEX_E7_PREFIX_2 */
9739 { "vmovntdq", { Mx
, XM
} },
9740 { "(bad)", { XX
} },
9743 /* MOD_VEX_F0_PREFIX_3 */
9744 { "vlddqu", { XM
, M
} },
9745 { "(bad)", { XX
} },
9748 /* MOD_VEX_3818_PREFIX_2 */
9749 { "vbroadcastss", { XM
, Md
} },
9750 { "(bad)", { XX
} },
9753 /* MOD_VEX_3819_PREFIX_2 */
9754 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
9755 { "(bad)", { XX
} },
9758 /* MOD_VEX_381A_PREFIX_2 */
9759 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
9760 { "(bad)", { XX
} },
9763 /* MOD_VEX_382A_PREFIX_2 */
9764 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
9765 { "(bad)", { XX
} },
9768 /* MOD_VEX_382C_PREFIX_2 */
9769 { "vmaskmovps", { XM
, Vex
, Mx
} },
9770 { "(bad)", { XX
} },
9773 /* MOD_VEX_382D_PREFIX_2 */
9774 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9775 { "(bad)", { XX
} },
9778 /* MOD_VEX_382E_PREFIX_2 */
9779 { "vmaskmovps", { Mx
, Vex
, XM
} },
9780 { "(bad)", { XX
} },
9783 /* MOD_VEX_382F_PREFIX_2 */
9784 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9785 { "(bad)", { XX
} },
9789 static const struct dis386 rm_table
[][8] = {
9792 { "(bad)", { XX
} },
9793 { "vmcall", { Skip_MODRM
} },
9794 { "vmlaunch", { Skip_MODRM
} },
9795 { "vmresume", { Skip_MODRM
} },
9796 { "vmxoff", { Skip_MODRM
} },
9797 { "(bad)", { XX
} },
9798 { "(bad)", { XX
} },
9799 { "(bad)", { XX
} },
9803 { "monitor", { { OP_Monitor
, 0 } } },
9804 { "mwait", { { OP_Mwait
, 0 } } },
9805 { "(bad)", { XX
} },
9806 { "(bad)", { XX
} },
9807 { "(bad)", { XX
} },
9808 { "(bad)", { XX
} },
9809 { "(bad)", { XX
} },
9810 { "(bad)", { XX
} },
9814 { "xgetbv", { Skip_MODRM
} },
9815 { "xsetbv", { Skip_MODRM
} },
9816 { "(bad)", { XX
} },
9817 { "(bad)", { XX
} },
9818 { "(bad)", { XX
} },
9819 { "(bad)", { XX
} },
9820 { "(bad)", { XX
} },
9821 { "(bad)", { XX
} },
9825 { "vmrun", { Skip_MODRM
} },
9826 { "vmmcall", { Skip_MODRM
} },
9827 { "vmload", { Skip_MODRM
} },
9828 { "vmsave", { Skip_MODRM
} },
9829 { "stgi", { Skip_MODRM
} },
9830 { "clgi", { Skip_MODRM
} },
9831 { "skinit", { Skip_MODRM
} },
9832 { "invlpga", { Skip_MODRM
} },
9836 { "swapgs", { Skip_MODRM
} },
9837 { "rdtscp", { Skip_MODRM
} },
9838 { "(bad)", { XX
} },
9839 { "(bad)", { XX
} },
9840 { "(bad)", { XX
} },
9841 { "(bad)", { XX
} },
9842 { "(bad)", { XX
} },
9843 { "(bad)", { XX
} },
9847 { "lfence", { Skip_MODRM
} },
9848 { "(bad)", { XX
} },
9849 { "(bad)", { XX
} },
9850 { "(bad)", { XX
} },
9851 { "(bad)", { XX
} },
9852 { "(bad)", { XX
} },
9853 { "(bad)", { XX
} },
9854 { "(bad)", { XX
} },
9858 { "mfence", { Skip_MODRM
} },
9859 { "(bad)", { XX
} },
9860 { "(bad)", { XX
} },
9861 { "(bad)", { XX
} },
9862 { "(bad)", { XX
} },
9863 { "(bad)", { XX
} },
9864 { "(bad)", { XX
} },
9865 { "(bad)", { XX
} },
9869 { "sfence", { Skip_MODRM
} },
9870 { "(bad)", { XX
} },
9871 { "(bad)", { XX
} },
9872 { "(bad)", { XX
} },
9873 { "(bad)", { XX
} },
9874 { "(bad)", { XX
} },
9875 { "(bad)", { XX
} },
9876 { "(bad)", { XX
} },
9880 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9882 /* We use the high bit to indicate different name for the same
9884 #define ADDR16_PREFIX (0x67 | 0x100)
9885 #define ADDR32_PREFIX (0x67 | 0x200)
9886 #define DATA16_PREFIX (0x66 | 0x100)
9887 #define DATA32_PREFIX (0x66 | 0x200)
9888 #define REP_PREFIX (0xf3 | 0x100)
9893 int newrex
, i
, length
;
9900 last_lock_prefix
= -1;
9901 last_repz_prefix
= -1;
9902 last_repnz_prefix
= -1;
9903 last_data_prefix
= -1;
9904 last_addr_prefix
= -1;
9905 last_rex_prefix
= -1;
9906 last_seg_prefix
= -1;
9907 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
9908 all_prefixes
[i
] = 0;
9911 /* The maximum instruction length is 15bytes. */
9912 while (length
< MAX_CODE_LENGTH
- 1)
9914 FETCH_DATA (the_info
, codep
+ 1);
9918 /* REX prefixes family. */
9935 if (address_mode
== mode_64bit
)
9939 last_rex_prefix
= i
;
9942 prefixes
|= PREFIX_REPZ
;
9943 last_repz_prefix
= i
;
9946 prefixes
|= PREFIX_REPNZ
;
9947 last_repnz_prefix
= i
;
9950 prefixes
|= PREFIX_LOCK
;
9951 last_lock_prefix
= i
;
9954 prefixes
|= PREFIX_CS
;
9955 last_seg_prefix
= i
;
9958 prefixes
|= PREFIX_SS
;
9959 last_seg_prefix
= i
;
9962 prefixes
|= PREFIX_DS
;
9963 last_seg_prefix
= i
;
9966 prefixes
|= PREFIX_ES
;
9967 last_seg_prefix
= i
;
9970 prefixes
|= PREFIX_FS
;
9971 last_seg_prefix
= i
;
9974 prefixes
|= PREFIX_GS
;
9975 last_seg_prefix
= i
;
9978 prefixes
|= PREFIX_DATA
;
9979 last_data_prefix
= i
;
9982 prefixes
|= PREFIX_ADDR
;
9983 last_addr_prefix
= i
;
9986 /* fwait is really an instruction. If there are prefixes
9987 before the fwait, they belong to the fwait, *not* to the
9988 following instruction. */
9989 if (prefixes
|| rex
)
9991 prefixes
|= PREFIX_FWAIT
;
9995 prefixes
= PREFIX_FWAIT
;
10000 /* Rex is ignored when followed by another prefix. */
10006 if (*codep
!= FWAIT_OPCODE
)
10007 all_prefixes
[i
++] = *codep
;
10009 rex_original
= rex
;
10017 seg_prefix (int pref
)
10038 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10041 static const char *
10042 prefix_name (int pref
, int sizeflag
)
10044 static const char *rexes
[16] =
10047 "rex.B", /* 0x41 */
10048 "rex.X", /* 0x42 */
10049 "rex.XB", /* 0x43 */
10050 "rex.R", /* 0x44 */
10051 "rex.RB", /* 0x45 */
10052 "rex.RX", /* 0x46 */
10053 "rex.RXB", /* 0x47 */
10054 "rex.W", /* 0x48 */
10055 "rex.WB", /* 0x49 */
10056 "rex.WX", /* 0x4a */
10057 "rex.WXB", /* 0x4b */
10058 "rex.WR", /* 0x4c */
10059 "rex.WRB", /* 0x4d */
10060 "rex.WRX", /* 0x4e */
10061 "rex.WRXB", /* 0x4f */
10066 /* REX prefixes family. */
10083 return rexes
[pref
- 0x40];
10103 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10105 if (address_mode
== mode_64bit
)
10106 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10108 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10111 case ADDR16_PREFIX
:
10113 case ADDR32_PREFIX
:
10115 case DATA16_PREFIX
:
10117 case DATA32_PREFIX
:
10126 static char op_out
[MAX_OPERANDS
][100];
10127 static int op_ad
, op_index
[MAX_OPERANDS
];
10128 static int two_source_ops
;
10129 static bfd_vma op_address
[MAX_OPERANDS
];
10130 static bfd_vma op_riprel
[MAX_OPERANDS
];
10131 static bfd_vma start_pc
;
10134 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10135 * (see topic "Redundant prefixes" in the "Differences from 8086"
10136 * section of the "Virtual 8086 Mode" chapter.)
10137 * 'pc' should be the address of this instruction, it will
10138 * be used to print the target address if this is a relative jump or call
10139 * The function returns the length of this instruction in bytes.
10142 static char intel_syntax
;
10143 static char intel_mnemonic
= !SYSV386_COMPAT
;
10144 static char open_char
;
10145 static char close_char
;
10146 static char separator_char
;
10147 static char scale_char
;
10149 /* Here for backwards compatibility. When gdb stops using
10150 print_insn_i386_att and print_insn_i386_intel these functions can
10151 disappear, and print_insn_i386 be merged into print_insn. */
10153 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10157 return print_insn (pc
, info
);
10161 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10165 return print_insn (pc
, info
);
10169 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10173 return print_insn (pc
, info
);
10177 print_i386_disassembler_options (FILE *stream
)
10179 fprintf (stream
, _("\n\
10180 The following i386/x86-64 specific disassembler options are supported for use\n\
10181 with the -M switch (multiple options should be separated by commas):\n"));
10183 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10184 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10185 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10186 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10187 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10188 fprintf (stream
, _(" att-mnemonic\n"
10189 " Display instruction in AT&T mnemonic\n"));
10190 fprintf (stream
, _(" intel-mnemonic\n"
10191 " Display instruction in Intel mnemonic\n"));
10192 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10193 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10194 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10195 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10196 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10197 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10200 /* Get a pointer to struct dis386 with a valid name. */
10202 static const struct dis386
*
10203 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10205 int index
, vex_table_index
;
10207 if (dp
->name
!= NULL
)
10210 switch (dp
->op
[0].bytemode
)
10212 case USE_REG_TABLE
:
10213 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10216 case USE_MOD_TABLE
:
10217 index
= modrm
.mod
== 0x3 ? 1 : 0;
10218 dp
= &mod_table
[dp
->op
[1].bytemode
][index
];
10222 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10225 case USE_PREFIX_TABLE
:
10228 /* The prefix in VEX is implicit. */
10229 switch (vex
.prefix
)
10234 case REPE_PREFIX_OPCODE
:
10237 case DATA_PREFIX_OPCODE
:
10240 case REPNE_PREFIX_OPCODE
:
10251 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10252 if (prefixes
& PREFIX_REPZ
)
10255 all_prefixes
[last_repz_prefix
] = 0;
10259 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10261 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10262 if (prefixes
& PREFIX_REPNZ
)
10265 all_prefixes
[last_repnz_prefix
] = 0;
10269 used_prefixes
|= (prefixes
& PREFIX_DATA
);
10270 if (prefixes
& PREFIX_DATA
)
10273 all_prefixes
[last_data_prefix
] = 0;
10278 dp
= &prefix_table
[dp
->op
[1].bytemode
][index
];
10281 case USE_X86_64_TABLE
:
10282 index
= address_mode
== mode_64bit
? 1 : 0;
10283 dp
= &x86_64_table
[dp
->op
[1].bytemode
][index
];
10286 case USE_3BYTE_TABLE
:
10287 FETCH_DATA (info
, codep
+ 2);
10289 dp
= &three_byte_table
[dp
->op
[1].bytemode
][index
];
10290 modrm
.mod
= (*codep
>> 6) & 3;
10291 modrm
.reg
= (*codep
>> 3) & 7;
10292 modrm
.rm
= *codep
& 7;
10295 case USE_VEX_LEN_TABLE
:
10299 switch (vex
.length
)
10312 dp
= &vex_len_table
[dp
->op
[1].bytemode
][index
];
10315 case USE_XOP_8F_TABLE
:
10316 FETCH_DATA (info
, codep
+ 3);
10317 /* All bits in the REX prefix are ignored. */
10319 rex
= ~(*codep
>> 5) & 0x7;
10321 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10322 switch ((*codep
& 0x1f))
10327 vex_table_index
= XOP_08
;
10330 vex_table_index
= XOP_09
;
10333 vex_table_index
= XOP_0A
;
10337 vex
.w
= *codep
& 0x80;
10338 if (vex
.w
&& address_mode
== mode_64bit
)
10341 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10342 if (address_mode
!= mode_64bit
10343 && vex
.register_specifier
> 0x7)
10346 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10347 switch ((*codep
& 0x3))
10353 vex
.prefix
= DATA_PREFIX_OPCODE
;
10356 vex
.prefix
= REPE_PREFIX_OPCODE
;
10359 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10366 dp
= &xop_table
[vex_table_index
][index
];
10368 FETCH_DATA (info
, codep
+ 1);
10369 modrm
.mod
= (*codep
>> 6) & 3;
10370 modrm
.reg
= (*codep
>> 3) & 7;
10371 modrm
.rm
= *codep
& 7;
10374 case USE_VEX_C4_TABLE
:
10375 FETCH_DATA (info
, codep
+ 3);
10376 /* All bits in the REX prefix are ignored. */
10378 rex
= ~(*codep
>> 5) & 0x7;
10379 switch ((*codep
& 0x1f))
10384 vex_table_index
= VEX_0F
;
10387 vex_table_index
= VEX_0F38
;
10390 vex_table_index
= VEX_0F3A
;
10394 vex
.w
= *codep
& 0x80;
10395 if (vex
.w
&& address_mode
== mode_64bit
)
10398 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10399 if (address_mode
!= mode_64bit
10400 && vex
.register_specifier
> 0x7)
10403 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10404 switch ((*codep
& 0x3))
10410 vex
.prefix
= DATA_PREFIX_OPCODE
;
10413 vex
.prefix
= REPE_PREFIX_OPCODE
;
10416 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10423 dp
= &vex_table
[vex_table_index
][index
];
10424 /* There is no MODRM byte for VEX [82|77]. */
10425 if (index
!= 0x77 && index
!= 0x82)
10427 FETCH_DATA (info
, codep
+ 1);
10428 modrm
.mod
= (*codep
>> 6) & 3;
10429 modrm
.reg
= (*codep
>> 3) & 7;
10430 modrm
.rm
= *codep
& 7;
10434 case USE_VEX_C5_TABLE
:
10435 FETCH_DATA (info
, codep
+ 2);
10436 /* All bits in the REX prefix are ignored. */
10438 rex
= (*codep
& 0x80) ? 0 : REX_R
;
10440 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10441 if (address_mode
!= mode_64bit
10442 && vex
.register_specifier
> 0x7)
10445 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10446 switch ((*codep
& 0x3))
10452 vex
.prefix
= DATA_PREFIX_OPCODE
;
10455 vex
.prefix
= REPE_PREFIX_OPCODE
;
10458 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10465 dp
= &vex_table
[dp
->op
[1].bytemode
][index
];
10466 /* There is no MODRM byte for VEX [82|77]. */
10467 if (index
!= 0x77 && index
!= 0x82)
10469 FETCH_DATA (info
, codep
+ 1);
10470 modrm
.mod
= (*codep
>> 6) & 3;
10471 modrm
.reg
= (*codep
>> 3) & 7;
10472 modrm
.rm
= *codep
& 7;
10480 if (dp
->name
!= NULL
)
10483 return get_valid_dis386 (dp
, info
);
10487 print_insn (bfd_vma pc
, disassemble_info
*info
)
10489 const struct dis386
*dp
;
10491 char *op_txt
[MAX_OPERANDS
];
10495 struct dis_private priv
;
10498 int default_prefixes
;
10500 if (info
->mach
== bfd_mach_x86_64_intel_syntax
10501 || info
->mach
== bfd_mach_x86_64
10502 || info
->mach
== bfd_mach_l1om
10503 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10504 address_mode
= mode_64bit
;
10506 address_mode
= mode_32bit
;
10508 if (intel_syntax
== (char) -1)
10509 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
10510 || info
->mach
== bfd_mach_x86_64_intel_syntax
10511 || info
->mach
== bfd_mach_l1om_intel_syntax
);
10513 if (info
->mach
== bfd_mach_i386_i386
10514 || info
->mach
== bfd_mach_x86_64
10515 || info
->mach
== bfd_mach_l1om
10516 || info
->mach
== bfd_mach_i386_i386_intel_syntax
10517 || info
->mach
== bfd_mach_x86_64_intel_syntax
10518 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10519 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10520 else if (info
->mach
== bfd_mach_i386_i8086
)
10521 priv
.orig_sizeflag
= 0;
10525 for (p
= info
->disassembler_options
; p
!= NULL
; )
10527 if (CONST_STRNEQ (p
, "x86-64"))
10529 address_mode
= mode_64bit
;
10530 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10532 else if (CONST_STRNEQ (p
, "i386"))
10534 address_mode
= mode_32bit
;
10535 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10537 else if (CONST_STRNEQ (p
, "i8086"))
10539 address_mode
= mode_16bit
;
10540 priv
.orig_sizeflag
= 0;
10542 else if (CONST_STRNEQ (p
, "intel"))
10545 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
10546 intel_mnemonic
= 1;
10548 else if (CONST_STRNEQ (p
, "att"))
10551 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
10552 intel_mnemonic
= 0;
10554 else if (CONST_STRNEQ (p
, "addr"))
10556 if (address_mode
== mode_64bit
)
10558 if (p
[4] == '3' && p
[5] == '2')
10559 priv
.orig_sizeflag
&= ~AFLAG
;
10560 else if (p
[4] == '6' && p
[5] == '4')
10561 priv
.orig_sizeflag
|= AFLAG
;
10565 if (p
[4] == '1' && p
[5] == '6')
10566 priv
.orig_sizeflag
&= ~AFLAG
;
10567 else if (p
[4] == '3' && p
[5] == '2')
10568 priv
.orig_sizeflag
|= AFLAG
;
10571 else if (CONST_STRNEQ (p
, "data"))
10573 if (p
[4] == '1' && p
[5] == '6')
10574 priv
.orig_sizeflag
&= ~DFLAG
;
10575 else if (p
[4] == '3' && p
[5] == '2')
10576 priv
.orig_sizeflag
|= DFLAG
;
10578 else if (CONST_STRNEQ (p
, "suffix"))
10579 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
10581 p
= strchr (p
, ',');
10588 names64
= intel_names64
;
10589 names32
= intel_names32
;
10590 names16
= intel_names16
;
10591 names8
= intel_names8
;
10592 names8rex
= intel_names8rex
;
10593 names_seg
= intel_names_seg
;
10594 index64
= intel_index64
;
10595 index32
= intel_index32
;
10596 index16
= intel_index16
;
10599 separator_char
= '+';
10604 names64
= att_names64
;
10605 names32
= att_names32
;
10606 names16
= att_names16
;
10607 names8
= att_names8
;
10608 names8rex
= att_names8rex
;
10609 names_seg
= att_names_seg
;
10610 index64
= att_index64
;
10611 index32
= att_index32
;
10612 index16
= att_index16
;
10615 separator_char
= ',';
10619 /* The output looks better if we put 7 bytes on a line, since that
10620 puts most long word instructions on a single line. Use 8 bytes
10622 if (info
->mach
== bfd_mach_l1om
10623 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10624 info
->bytes_per_line
= 8;
10626 info
->bytes_per_line
= 7;
10628 info
->private_data
= &priv
;
10629 priv
.max_fetched
= priv
.the_buffer
;
10630 priv
.insn_start
= pc
;
10633 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10641 start_codep
= priv
.the_buffer
;
10642 codep
= priv
.the_buffer
;
10644 if (setjmp (priv
.bailout
) != 0)
10648 /* Getting here means we tried for data but didn't get it. That
10649 means we have an incomplete instruction of some sort. Just
10650 print the first byte as a prefix or a .byte pseudo-op. */
10651 if (codep
> priv
.the_buffer
)
10653 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
10655 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10658 /* Just print the first byte as a .byte instruction. */
10659 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
10660 (unsigned int) priv
.the_buffer
[0]);
10670 sizeflag
= priv
.orig_sizeflag
;
10672 if (!ckprefix () || rex_used
)
10674 /* Too many prefixes or unused REX prefixes. */
10676 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
10678 (*info
->fprintf_func
) (info
->stream
, "%s",
10679 prefix_name (all_prefixes
[i
], sizeflag
));
10683 insn_codep
= codep
;
10685 FETCH_DATA (info
, codep
+ 1);
10686 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
10688 if (((prefixes
& PREFIX_FWAIT
)
10689 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
10691 (*info
->fprintf_func
) (info
->stream
, "fwait");
10697 if (*codep
== 0x0f)
10699 unsigned char threebyte
;
10700 FETCH_DATA (info
, codep
+ 2);
10701 threebyte
= *++codep
;
10702 dp
= &dis386_twobyte
[threebyte
];
10703 need_modrm
= twobyte_has_modrm
[*codep
];
10708 dp
= &dis386
[*codep
];
10709 need_modrm
= onebyte_has_modrm
[*codep
];
10713 if ((prefixes
& PREFIX_REPZ
))
10714 used_prefixes
|= PREFIX_REPZ
;
10715 if ((prefixes
& PREFIX_REPNZ
))
10716 used_prefixes
|= PREFIX_REPNZ
;
10717 if ((prefixes
& PREFIX_LOCK
))
10718 used_prefixes
|= PREFIX_LOCK
;
10720 default_prefixes
= 0;
10721 if (prefixes
& PREFIX_ADDR
)
10724 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
10726 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
10727 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
10729 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
10730 default_prefixes
|= PREFIX_ADDR
;
10734 if ((prefixes
& PREFIX_DATA
))
10737 if (dp
->op
[2].bytemode
== cond_jump_mode
10738 && dp
->op
[0].bytemode
== v_mode
10741 if (sizeflag
& DFLAG
)
10742 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
10744 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
10745 default_prefixes
|= PREFIX_DATA
;
10747 else if (rex
& REX_W
)
10749 /* REX_W will override PREFIX_DATA. */
10750 default_prefixes
|= PREFIX_DATA
;
10756 FETCH_DATA (info
, codep
+ 1);
10757 modrm
.mod
= (*codep
>> 6) & 3;
10758 modrm
.reg
= (*codep
>> 3) & 7;
10759 modrm
.rm
= *codep
& 7;
10766 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
10768 dofloat (sizeflag
);
10772 dp
= get_valid_dis386 (dp
, info
);
10773 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
10775 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10778 op_ad
= MAX_OPERANDS
- 1 - i
;
10780 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
10785 /* See if any prefixes were not used. If so, print the first one
10786 separately. If we don't do this, we'll wind up printing an
10787 instruction stream which does not precisely correspond to the
10788 bytes we are disassembling. */
10789 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
10791 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10792 if (all_prefixes
[i
])
10795 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
10797 name
= INTERNAL_DISASSEMBLER_ERROR
;
10798 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10803 /* Check if the REX prefix used. */
10804 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
10805 all_prefixes
[last_rex_prefix
] = 0;
10807 /* Check if the SEG prefix used. */
10808 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
10809 | PREFIX_FS
| PREFIX_GS
)) != 0
10811 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
10812 all_prefixes
[last_seg_prefix
] = 0;
10814 /* Check if the ADDR prefix used. */
10815 if ((prefixes
& PREFIX_ADDR
) != 0
10816 && (used_prefixes
& PREFIX_ADDR
) != 0)
10817 all_prefixes
[last_addr_prefix
] = 0;
10819 /* Check if the DATA prefix used. */
10820 if ((prefixes
& PREFIX_DATA
) != 0
10821 && (used_prefixes
& PREFIX_DATA
) != 0)
10822 all_prefixes
[last_data_prefix
] = 0;
10825 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10826 if (all_prefixes
[i
])
10829 name
= prefix_name (all_prefixes
[i
], sizeflag
);
10832 prefix_length
+= strlen (name
) + 1;
10833 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
10836 /* Check maximum code length. */
10837 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
10839 (*info
->fprintf_func
) (info
->stream
, "(bad)");
10840 return MAX_CODE_LENGTH
;
10843 obufp
= mnemonicendp
;
10844 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
10847 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
10849 /* The enter and bound instructions are printed with operands in the same
10850 order as the intel book; everything else is printed in reverse order. */
10851 if (intel_syntax
|| two_source_ops
)
10855 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10856 op_txt
[i
] = op_out
[i
];
10858 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
10860 op_ad
= op_index
[i
];
10861 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
10862 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
10863 riprel
= op_riprel
[i
];
10864 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
10865 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
10870 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10871 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
10875 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10879 (*info
->fprintf_func
) (info
->stream
, ",");
10880 if (op_index
[i
] != -1 && !op_riprel
[i
])
10881 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
10883 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
10887 for (i
= 0; i
< MAX_OPERANDS
; i
++)
10888 if (op_index
[i
] != -1 && op_riprel
[i
])
10890 (*info
->fprintf_func
) (info
->stream
, " # ");
10891 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
10892 + op_address
[op_index
[i
]]), info
);
10895 return codep
- priv
.the_buffer
;
10898 static const char *float_mem
[] = {
10973 static const unsigned char float_mem_mode
[] = {
11048 #define ST { OP_ST, 0 }
11049 #define STi { OP_STi, 0 }
11051 #define FGRPd9_2 NULL, { { NULL, 0 } }
11052 #define FGRPd9_4 NULL, { { NULL, 1 } }
11053 #define FGRPd9_5 NULL, { { NULL, 2 } }
11054 #define FGRPd9_6 NULL, { { NULL, 3 } }
11055 #define FGRPd9_7 NULL, { { NULL, 4 } }
11056 #define FGRPda_5 NULL, { { NULL, 5 } }
11057 #define FGRPdb_4 NULL, { { NULL, 6 } }
11058 #define FGRPde_3 NULL, { { NULL, 7 } }
11059 #define FGRPdf_4 NULL, { { NULL, 8 } }
11061 static const struct dis386 float_reg
[][8] = {
11064 { "fadd", { ST
, STi
} },
11065 { "fmul", { ST
, STi
} },
11066 { "fcom", { STi
} },
11067 { "fcomp", { STi
} },
11068 { "fsub", { ST
, STi
} },
11069 { "fsubr", { ST
, STi
} },
11070 { "fdiv", { ST
, STi
} },
11071 { "fdivr", { ST
, STi
} },
11075 { "fld", { STi
} },
11076 { "fxch", { STi
} },
11078 { "(bad)", { XX
} },
11086 { "fcmovb", { ST
, STi
} },
11087 { "fcmove", { ST
, STi
} },
11088 { "fcmovbe",{ ST
, STi
} },
11089 { "fcmovu", { ST
, STi
} },
11090 { "(bad)", { XX
} },
11092 { "(bad)", { XX
} },
11093 { "(bad)", { XX
} },
11097 { "fcmovnb",{ ST
, STi
} },
11098 { "fcmovne",{ ST
, STi
} },
11099 { "fcmovnbe",{ ST
, STi
} },
11100 { "fcmovnu",{ ST
, STi
} },
11102 { "fucomi", { ST
, STi
} },
11103 { "fcomi", { ST
, STi
} },
11104 { "(bad)", { XX
} },
11108 { "fadd", { STi
, ST
} },
11109 { "fmul", { STi
, ST
} },
11110 { "(bad)", { XX
} },
11111 { "(bad)", { XX
} },
11112 { "fsub!M", { STi
, ST
} },
11113 { "fsubM", { STi
, ST
} },
11114 { "fdiv!M", { STi
, ST
} },
11115 { "fdivM", { STi
, ST
} },
11119 { "ffree", { STi
} },
11120 { "(bad)", { XX
} },
11121 { "fst", { STi
} },
11122 { "fstp", { STi
} },
11123 { "fucom", { STi
} },
11124 { "fucomp", { STi
} },
11125 { "(bad)", { XX
} },
11126 { "(bad)", { XX
} },
11130 { "faddp", { STi
, ST
} },
11131 { "fmulp", { STi
, ST
} },
11132 { "(bad)", { XX
} },
11134 { "fsub!Mp", { STi
, ST
} },
11135 { "fsubMp", { STi
, ST
} },
11136 { "fdiv!Mp", { STi
, ST
} },
11137 { "fdivMp", { STi
, ST
} },
11141 { "ffreep", { STi
} },
11142 { "(bad)", { XX
} },
11143 { "(bad)", { XX
} },
11144 { "(bad)", { XX
} },
11146 { "fucomip", { ST
, STi
} },
11147 { "fcomip", { ST
, STi
} },
11148 { "(bad)", { XX
} },
11152 static char *fgrps
[][8] = {
11155 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11160 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11165 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11170 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11175 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11180 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11185 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11186 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11191 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11196 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11201 swap_operand (void)
11203 mnemonicendp
[0] = '.';
11204 mnemonicendp
[1] = 's';
11209 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11210 int sizeflag ATTRIBUTE_UNUSED
)
11212 /* Skip mod/rm byte. */
11218 dofloat (int sizeflag
)
11220 const struct dis386
*dp
;
11221 unsigned char floatop
;
11223 floatop
= codep
[-1];
11225 if (modrm
.mod
!= 3)
11227 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11229 putop (float_mem
[fp_indx
], sizeflag
);
11232 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11235 /* Skip mod/rm byte. */
11239 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11240 if (dp
->name
== NULL
)
11242 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
11244 /* Instruction fnstsw is only one with strange arg. */
11245 if (floatop
== 0xdf && codep
[-1] == 0xe0)
11246 strcpy (op_out
[0], names16
[0]);
11250 putop (dp
->name
, sizeflag
);
11255 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
11260 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
11265 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11267 oappend ("%st" + intel_syntax
);
11271 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11273 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
11274 oappend (scratchbuf
+ intel_syntax
);
11277 /* Capital letters in template are macros. */
11279 putop (const char *in_template
, int sizeflag
)
11284 unsigned int l
= 0, len
= 1;
11287 #define SAVE_LAST(c) \
11288 if (l < len && l < sizeof (last)) \
11293 for (p
= in_template
; *p
; p
++)
11310 while (*++p
!= '|')
11311 if (*p
== '}' || *p
== '\0')
11314 /* Fall through. */
11319 while (*++p
!= '}')
11330 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11334 if (l
== 0 && len
== 1)
11339 if (sizeflag
& SUFFIX_ALWAYS
)
11352 if (address_mode
== mode_64bit
11353 && !(prefixes
& PREFIX_ADDR
))
11364 if (intel_syntax
&& !alt
)
11366 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
11368 if (sizeflag
& DFLAG
)
11369 *obufp
++ = intel_syntax
? 'd' : 'l';
11371 *obufp
++ = intel_syntax
? 'w' : 's';
11372 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11376 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11379 if (modrm
.mod
== 3)
11385 if (sizeflag
& DFLAG
)
11386 *obufp
++ = intel_syntax
? 'd' : 'l';
11389 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11395 case 'E': /* For jcxz/jecxz */
11396 if (address_mode
== mode_64bit
)
11398 if (sizeflag
& AFLAG
)
11404 if (sizeflag
& AFLAG
)
11406 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11411 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
11413 if (sizeflag
& AFLAG
)
11414 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
11416 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
11417 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11421 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
11423 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11427 if (!(rex
& REX_W
))
11428 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11433 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
11434 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
11436 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
11439 if (prefixes
& PREFIX_DS
)
11460 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
11465 /* Fall through. */
11468 if (l
!= 0 || len
!= 1)
11476 if (sizeflag
& SUFFIX_ALWAYS
)
11480 if (intel_mnemonic
!= cond
)
11484 if ((prefixes
& PREFIX_FWAIT
) == 0)
11487 used_prefixes
|= PREFIX_FWAIT
;
11493 else if (intel_syntax
&& (sizeflag
& DFLAG
))
11497 if (!(rex
& REX_W
))
11498 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11503 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11508 /* Fall through. */
11512 if ((prefixes
& PREFIX_DATA
)
11514 || (sizeflag
& SUFFIX_ALWAYS
))
11521 if (sizeflag
& DFLAG
)
11525 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11532 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11534 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11538 /* Fall through. */
11541 if (l
== 0 && len
== 1)
11544 if (intel_syntax
&& !alt
)
11547 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11553 if (sizeflag
& DFLAG
)
11554 *obufp
++ = intel_syntax
? 'd' : 'l';
11557 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11563 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
11569 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11584 else if (sizeflag
& DFLAG
)
11593 if (intel_syntax
&& !p
[1]
11594 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
11596 if (!(rex
& REX_W
))
11597 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11600 if (l
== 0 && len
== 1)
11604 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11606 if (sizeflag
& SUFFIX_ALWAYS
)
11628 /* Fall through. */
11631 if (l
== 0 && len
== 1)
11636 if (sizeflag
& SUFFIX_ALWAYS
)
11642 if (sizeflag
& DFLAG
)
11646 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11660 if (address_mode
== mode_64bit
11661 && !(prefixes
& PREFIX_ADDR
))
11672 if (l
!= 0 || len
!= 1)
11677 if (need_vex
&& vex
.prefix
)
11679 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
11686 if (prefixes
& PREFIX_DATA
)
11690 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11694 if (l
== 0 && len
== 1)
11696 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11707 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11715 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11717 switch (vex
.length
)
11731 if (l
== 0 && len
== 1)
11733 /* operand size flag for cwtl, cbtw */
11742 else if (sizeflag
& DFLAG
)
11746 if (!(rex
& REX_W
))
11747 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11751 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11758 *obufp
++ = vex
.w
? 'd': 's';
11765 mnemonicendp
= obufp
;
11770 oappend (const char *s
)
11772 obufp
= stpcpy (obufp
, s
);
11778 if (prefixes
& PREFIX_CS
)
11780 used_prefixes
|= PREFIX_CS
;
11781 oappend ("%cs:" + intel_syntax
);
11783 if (prefixes
& PREFIX_DS
)
11785 used_prefixes
|= PREFIX_DS
;
11786 oappend ("%ds:" + intel_syntax
);
11788 if (prefixes
& PREFIX_SS
)
11790 used_prefixes
|= PREFIX_SS
;
11791 oappend ("%ss:" + intel_syntax
);
11793 if (prefixes
& PREFIX_ES
)
11795 used_prefixes
|= PREFIX_ES
;
11796 oappend ("%es:" + intel_syntax
);
11798 if (prefixes
& PREFIX_FS
)
11800 used_prefixes
|= PREFIX_FS
;
11801 oappend ("%fs:" + intel_syntax
);
11803 if (prefixes
& PREFIX_GS
)
11805 used_prefixes
|= PREFIX_GS
;
11806 oappend ("%gs:" + intel_syntax
);
11811 OP_indirE (int bytemode
, int sizeflag
)
11815 OP_E (bytemode
, sizeflag
);
11819 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
11821 if (address_mode
== mode_64bit
)
11829 sprintf_vma (tmp
, disp
);
11830 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
11831 strcpy (buf
+ 2, tmp
+ i
);
11835 bfd_signed_vma v
= disp
;
11842 /* Check for possible overflow on 0x8000000000000000. */
11845 strcpy (buf
, "9223372036854775808");
11859 tmp
[28 - i
] = (v
% 10) + '0';
11863 strcpy (buf
, tmp
+ 29 - i
);
11869 sprintf (buf
, "0x%x", (unsigned int) disp
);
11871 sprintf (buf
, "%d", (int) disp
);
11875 /* Put DISP in BUF as signed hex number. */
11878 print_displacement (char *buf
, bfd_vma disp
)
11880 bfd_signed_vma val
= disp
;
11889 /* Check for possible overflow. */
11892 switch (address_mode
)
11895 strcpy (buf
+ j
, "0x8000000000000000");
11898 strcpy (buf
+ j
, "0x80000000");
11901 strcpy (buf
+ j
, "0x8000");
11911 sprintf_vma (tmp
, (bfd_vma
) val
);
11912 for (i
= 0; tmp
[i
] == '0'; i
++)
11914 if (tmp
[i
] == '\0')
11916 strcpy (buf
+ j
, tmp
+ i
);
11920 intel_operand_size (int bytemode
, int sizeflag
)
11927 oappend ("BYTE PTR ");
11931 oappend ("WORD PTR ");
11934 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11936 oappend ("QWORD PTR ");
11945 oappend ("QWORD PTR ");
11948 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
11949 oappend ("DWORD PTR ");
11951 oappend ("WORD PTR ");
11952 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11956 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11958 oappend ("WORD PTR ");
11959 if (!(rex
& REX_W
))
11960 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11963 if (sizeflag
& DFLAG
)
11964 oappend ("QWORD PTR ");
11966 oappend ("DWORD PTR ");
11967 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11972 oappend ("DWORD PTR ");
11976 oappend ("QWORD PTR ");
11979 if (address_mode
== mode_64bit
)
11980 oappend ("QWORD PTR ");
11982 oappend ("DWORD PTR ");
11985 if (sizeflag
& DFLAG
)
11986 oappend ("FWORD PTR ");
11988 oappend ("DWORD PTR ");
11989 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11992 oappend ("TBYTE PTR ");
11998 switch (vex
.length
)
12001 oappend ("XMMWORD PTR ");
12004 oappend ("YMMWORD PTR ");
12011 oappend ("XMMWORD PTR ");
12014 oappend ("XMMWORD PTR ");
12020 switch (vex
.length
)
12023 oappend ("QWORD PTR ");
12026 oappend ("XMMWORD PTR ");
12036 switch (vex
.length
)
12039 oappend ("QWORD PTR ");
12042 oappend ("YMMWORD PTR ");
12049 oappend ("OWORD PTR ");
12051 case vex_w_dq_mode
:
12056 oappend ("QWORD PTR ");
12058 oappend ("DWORD PTR ");
12066 OP_E_register (int bytemode
, int sizeflag
)
12068 int reg
= modrm
.rm
;
12069 const char **names
;
12075 if ((sizeflag
& SUFFIX_ALWAYS
)
12076 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12099 names
= address_mode
== mode_64bit
? names64
: names32
;
12102 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12120 if ((sizeflag
& DFLAG
)
12121 || (bytemode
!= v_mode
12122 && bytemode
!= v_swap_mode
))
12126 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12132 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12135 oappend (names
[reg
]);
12139 OP_E_memory (int bytemode
, int sizeflag
)
12142 int add
= (rex
& REX_B
) ? 8 : 0;
12147 intel_operand_size (bytemode
, sizeflag
);
12150 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12152 /* 32/64 bit address mode */
12170 FETCH_DATA (the_info
, codep
+ 1);
12171 index
= (*codep
>> 3) & 7;
12172 scale
= (*codep
>> 6) & 3;
12177 haveindex
= index
!= 4;
12180 rbase
= base
+ add
;
12188 if (address_mode
== mode_64bit
&& !havesib
)
12194 FETCH_DATA (the_info
, codep
+ 1);
12196 if ((disp
& 0x80) != 0)
12204 /* In 32bit mode, we need index register to tell [offset] from
12205 [eiz*1 + offset]. */
12206 needindex
= (havesib
12209 && address_mode
== mode_32bit
);
12210 havedisp
= (havebase
12212 || (havesib
&& (haveindex
|| scale
!= 0)));
12215 if (modrm
.mod
!= 0 || base
== 5)
12217 if (havedisp
|| riprel
)
12218 print_displacement (scratchbuf
, disp
);
12220 print_operand_value (scratchbuf
, 1, disp
);
12221 oappend (scratchbuf
);
12225 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12229 if (havebase
|| haveindex
|| riprel
)
12230 used_prefixes
|= PREFIX_ADDR
;
12232 if (havedisp
|| (intel_syntax
&& riprel
))
12234 *obufp
++ = open_char
;
12235 if (intel_syntax
&& riprel
)
12238 oappend (sizeflag
& AFLAG
? "rip" : "eip");
12242 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
12243 ? names64
[rbase
] : names32
[rbase
]);
12246 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12247 print index to tell base + index from base. */
12251 || (havebase
&& base
!= ESP_REG_NUM
))
12253 if (!intel_syntax
|| havebase
)
12255 *obufp
++ = separator_char
;
12259 oappend (address_mode
== mode_64bit
12260 && (sizeflag
& AFLAG
)
12261 ? names64
[index
] : names32
[index
]);
12263 oappend (address_mode
== mode_64bit
12264 && (sizeflag
& AFLAG
)
12265 ? index64
: index32
);
12267 *obufp
++ = scale_char
;
12269 sprintf (scratchbuf
, "%d", 1 << scale
);
12270 oappend (scratchbuf
);
12274 && (disp
|| modrm
.mod
!= 0 || base
== 5))
12276 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
12281 else if (modrm
.mod
!= 1 && disp
!= -disp
)
12285 disp
= - (bfd_signed_vma
) disp
;
12289 print_displacement (scratchbuf
, disp
);
12291 print_operand_value (scratchbuf
, 1, disp
);
12292 oappend (scratchbuf
);
12295 *obufp
++ = close_char
;
12298 else if (intel_syntax
)
12300 if (modrm
.mod
!= 0 || base
== 5)
12302 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12303 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12307 oappend (names_seg
[ds_reg
- es_reg
]);
12310 print_operand_value (scratchbuf
, 1, disp
);
12311 oappend (scratchbuf
);
12317 /* 16 bit address mode */
12318 used_prefixes
|= prefixes
& PREFIX_ADDR
;
12325 if ((disp
& 0x8000) != 0)
12330 FETCH_DATA (the_info
, codep
+ 1);
12332 if ((disp
& 0x80) != 0)
12337 if ((disp
& 0x8000) != 0)
12343 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
12345 print_displacement (scratchbuf
, disp
);
12346 oappend (scratchbuf
);
12349 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
12351 *obufp
++ = open_char
;
12353 oappend (index16
[modrm
.rm
]);
12355 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
12357 if ((bfd_signed_vma
) disp
>= 0)
12362 else if (modrm
.mod
!= 1)
12366 disp
= - (bfd_signed_vma
) disp
;
12369 print_displacement (scratchbuf
, disp
);
12370 oappend (scratchbuf
);
12373 *obufp
++ = close_char
;
12376 else if (intel_syntax
)
12378 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12379 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12383 oappend (names_seg
[ds_reg
- es_reg
]);
12386 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
12387 oappend (scratchbuf
);
12393 OP_E (int bytemode
, int sizeflag
)
12395 /* Skip mod/rm byte. */
12399 if (modrm
.mod
== 3)
12400 OP_E_register (bytemode
, sizeflag
);
12402 OP_E_memory (bytemode
, sizeflag
);
12406 OP_G (int bytemode
, int sizeflag
)
12417 oappend (names8rex
[modrm
.reg
+ add
]);
12419 oappend (names8
[modrm
.reg
+ add
]);
12422 oappend (names16
[modrm
.reg
+ add
]);
12425 oappend (names32
[modrm
.reg
+ add
]);
12428 oappend (names64
[modrm
.reg
+ add
]);
12437 oappend (names64
[modrm
.reg
+ add
]);
12440 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
12441 oappend (names32
[modrm
.reg
+ add
]);
12443 oappend (names16
[modrm
.reg
+ add
]);
12444 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12448 if (address_mode
== mode_64bit
)
12449 oappend (names64
[modrm
.reg
+ add
]);
12451 oappend (names32
[modrm
.reg
+ add
]);
12454 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12467 FETCH_DATA (the_info
, codep
+ 8);
12468 a
= *codep
++ & 0xff;
12469 a
|= (*codep
++ & 0xff) << 8;
12470 a
|= (*codep
++ & 0xff) << 16;
12471 a
|= (*codep
++ & 0xff) << 24;
12472 b
= *codep
++ & 0xff;
12473 b
|= (*codep
++ & 0xff) << 8;
12474 b
|= (*codep
++ & 0xff) << 16;
12475 b
|= (*codep
++ & 0xff) << 24;
12476 x
= a
+ ((bfd_vma
) b
<< 32);
12484 static bfd_signed_vma
12487 bfd_signed_vma x
= 0;
12489 FETCH_DATA (the_info
, codep
+ 4);
12490 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12491 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12492 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12493 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12497 static bfd_signed_vma
12500 bfd_signed_vma x
= 0;
12502 FETCH_DATA (the_info
, codep
+ 4);
12503 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12504 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12505 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12506 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12508 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
12518 FETCH_DATA (the_info
, codep
+ 2);
12519 x
= *codep
++ & 0xff;
12520 x
|= (*codep
++ & 0xff) << 8;
12525 set_op (bfd_vma op
, int riprel
)
12527 op_index
[op_ad
] = op_ad
;
12528 if (address_mode
== mode_64bit
)
12530 op_address
[op_ad
] = op
;
12531 op_riprel
[op_ad
] = riprel
;
12535 /* Mask to get a 32-bit address. */
12536 op_address
[op_ad
] = op
& 0xffffffff;
12537 op_riprel
[op_ad
] = riprel
& 0xffffffff;
12542 OP_REG (int code
, int sizeflag
)
12554 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12555 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12556 s
= names16
[code
- ax_reg
+ add
];
12558 case es_reg
: case ss_reg
: case cs_reg
:
12559 case ds_reg
: case fs_reg
: case gs_reg
:
12560 s
= names_seg
[code
- es_reg
+ add
];
12562 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12563 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12566 s
= names8rex
[code
- al_reg
+ add
];
12568 s
= names8
[code
- al_reg
];
12570 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
12571 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
12572 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12574 s
= names64
[code
- rAX_reg
+ add
];
12577 code
+= eAX_reg
- rAX_reg
;
12578 /* Fall through. */
12579 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12580 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12583 s
= names64
[code
- eAX_reg
+ add
];
12586 if (sizeflag
& DFLAG
)
12587 s
= names32
[code
- eAX_reg
+ add
];
12589 s
= names16
[code
- eAX_reg
+ add
];
12590 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12594 s
= INTERNAL_DISASSEMBLER_ERROR
;
12601 OP_IMREG (int code
, int sizeflag
)
12613 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12614 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12615 s
= names16
[code
- ax_reg
];
12617 case es_reg
: case ss_reg
: case cs_reg
:
12618 case ds_reg
: case fs_reg
: case gs_reg
:
12619 s
= names_seg
[code
- es_reg
];
12621 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12622 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12625 s
= names8rex
[code
- al_reg
];
12627 s
= names8
[code
- al_reg
];
12629 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12630 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12633 s
= names64
[code
- eAX_reg
];
12636 if (sizeflag
& DFLAG
)
12637 s
= names32
[code
- eAX_reg
];
12639 s
= names16
[code
- eAX_reg
];
12640 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12643 case z_mode_ax_reg
:
12644 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12648 if (!(rex
& REX_W
))
12649 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12652 s
= INTERNAL_DISASSEMBLER_ERROR
;
12659 OP_I (int bytemode
, int sizeflag
)
12662 bfd_signed_vma mask
= -1;
12667 FETCH_DATA (the_info
, codep
+ 1);
12672 if (address_mode
== mode_64bit
)
12677 /* Fall through. */
12684 if (sizeflag
& DFLAG
)
12694 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12706 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12711 scratchbuf
[0] = '$';
12712 print_operand_value (scratchbuf
+ 1, 1, op
);
12713 oappend (scratchbuf
+ intel_syntax
);
12714 scratchbuf
[0] = '\0';
12718 OP_I64 (int bytemode
, int sizeflag
)
12721 bfd_signed_vma mask
= -1;
12723 if (address_mode
!= mode_64bit
)
12725 OP_I (bytemode
, sizeflag
);
12732 FETCH_DATA (the_info
, codep
+ 1);
12742 if (sizeflag
& DFLAG
)
12752 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12760 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12765 scratchbuf
[0] = '$';
12766 print_operand_value (scratchbuf
+ 1, 1, op
);
12767 oappend (scratchbuf
+ intel_syntax
);
12768 scratchbuf
[0] = '\0';
12772 OP_sI (int bytemode
, int sizeflag
)
12775 bfd_signed_vma mask
= -1;
12780 FETCH_DATA (the_info
, codep
+ 1);
12782 if ((op
& 0x80) != 0)
12792 if (sizeflag
& DFLAG
)
12801 if ((op
& 0x8000) != 0)
12804 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12810 if ((op
& 0x8000) != 0)
12814 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12818 scratchbuf
[0] = '$';
12819 print_operand_value (scratchbuf
+ 1, 1, op
);
12820 oappend (scratchbuf
+ intel_syntax
);
12824 OP_J (int bytemode
, int sizeflag
)
12828 bfd_vma segment
= 0;
12833 FETCH_DATA (the_info
, codep
+ 1);
12835 if ((disp
& 0x80) != 0)
12840 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
12845 if ((disp
& 0x8000) != 0)
12847 /* In 16bit mode, address is wrapped around at 64k within
12848 the same segment. Otherwise, a data16 prefix on a jump
12849 instruction means that the pc is masked to 16 bits after
12850 the displacement is added! */
12852 if ((prefixes
& PREFIX_DATA
) == 0)
12853 segment
= ((start_pc
+ codep
- start_codep
)
12854 & ~((bfd_vma
) 0xffff));
12856 if (!(rex
& REX_W
))
12857 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12860 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12863 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
12865 print_operand_value (scratchbuf
, 1, disp
);
12866 oappend (scratchbuf
);
12870 OP_SEG (int bytemode
, int sizeflag
)
12872 if (bytemode
== w_mode
)
12873 oappend (names_seg
[modrm
.reg
]);
12875 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
12879 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
12883 if (sizeflag
& DFLAG
)
12893 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12895 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
12897 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
12898 oappend (scratchbuf
);
12902 OP_OFF (int bytemode
, int sizeflag
)
12906 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12907 intel_operand_size (bytemode
, sizeflag
);
12910 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12917 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12918 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12920 oappend (names_seg
[ds_reg
- es_reg
]);
12924 print_operand_value (scratchbuf
, 1, off
);
12925 oappend (scratchbuf
);
12929 OP_OFF64 (int bytemode
, int sizeflag
)
12933 if (address_mode
!= mode_64bit
12934 || (prefixes
& PREFIX_ADDR
))
12936 OP_OFF (bytemode
, sizeflag
);
12940 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12941 intel_operand_size (bytemode
, sizeflag
);
12948 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12949 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12951 oappend (names_seg
[ds_reg
- es_reg
]);
12955 print_operand_value (scratchbuf
, 1, off
);
12956 oappend (scratchbuf
);
12960 ptr_reg (int code
, int sizeflag
)
12964 *obufp
++ = open_char
;
12965 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12966 if (address_mode
== mode_64bit
)
12968 if (!(sizeflag
& AFLAG
))
12969 s
= names32
[code
- eAX_reg
];
12971 s
= names64
[code
- eAX_reg
];
12973 else if (sizeflag
& AFLAG
)
12974 s
= names32
[code
- eAX_reg
];
12976 s
= names16
[code
- eAX_reg
];
12978 *obufp
++ = close_char
;
12983 OP_ESreg (int code
, int sizeflag
)
12989 case 0x6d: /* insw/insl */
12990 intel_operand_size (z_mode
, sizeflag
);
12992 case 0xa5: /* movsw/movsl/movsq */
12993 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12994 case 0xab: /* stosw/stosl */
12995 case 0xaf: /* scasw/scasl */
12996 intel_operand_size (v_mode
, sizeflag
);
12999 intel_operand_size (b_mode
, sizeflag
);
13002 oappend ("%es:" + intel_syntax
);
13003 ptr_reg (code
, sizeflag
);
13007 OP_DSreg (int code
, int sizeflag
)
13013 case 0x6f: /* outsw/outsl */
13014 intel_operand_size (z_mode
, sizeflag
);
13016 case 0xa5: /* movsw/movsl/movsq */
13017 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13018 case 0xad: /* lodsw/lodsl/lodsq */
13019 intel_operand_size (v_mode
, sizeflag
);
13022 intel_operand_size (b_mode
, sizeflag
);
13031 | PREFIX_GS
)) == 0)
13032 prefixes
|= PREFIX_DS
;
13034 ptr_reg (code
, sizeflag
);
13038 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13046 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13048 all_prefixes
[last_lock_prefix
] = 0;
13049 used_prefixes
|= PREFIX_LOCK
;
13054 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13055 oappend (scratchbuf
+ intel_syntax
);
13059 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13068 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13070 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13071 oappend (scratchbuf
);
13075 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13077 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13078 oappend (scratchbuf
+ intel_syntax
);
13082 OP_R (int bytemode
, int sizeflag
)
13084 if (modrm
.mod
== 3)
13085 OP_E (bytemode
, sizeflag
);
13091 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13093 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13094 if (prefixes
& PREFIX_DATA
)
13102 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13105 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13106 oappend (scratchbuf
+ intel_syntax
);
13110 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13118 if (need_vex
&& bytemode
!= xmm_mode
)
13120 switch (vex
.length
)
13123 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13126 sprintf (scratchbuf
, "%%ymm%d", modrm
.reg
+ add
);
13133 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13134 oappend (scratchbuf
+ intel_syntax
);
13138 OP_EM (int bytemode
, int sizeflag
)
13140 if (modrm
.mod
!= 3)
13143 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13145 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13146 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13148 OP_E (bytemode
, sizeflag
);
13152 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13155 /* Skip mod/rm byte. */
13158 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13159 if (prefixes
& PREFIX_DATA
)
13168 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13171 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13172 oappend (scratchbuf
+ intel_syntax
);
13175 /* cvt* are the only instructions in sse2 which have
13176 both SSE and MMX operands and also have 0x66 prefix
13177 in their opcode. 0x66 was originally used to differentiate
13178 between SSE and MMX instruction(operands). So we have to handle the
13179 cvt* separately using OP_EMC and OP_MXC */
13181 OP_EMC (int bytemode
, int sizeflag
)
13183 if (modrm
.mod
!= 3)
13185 if (intel_syntax
&& bytemode
== v_mode
)
13187 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13188 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13190 OP_E (bytemode
, sizeflag
);
13194 /* Skip mod/rm byte. */
13197 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13198 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13199 oappend (scratchbuf
+ intel_syntax
);
13203 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13205 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13206 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13207 oappend (scratchbuf
+ intel_syntax
);
13211 OP_EX (int bytemode
, int sizeflag
)
13215 /* Skip mod/rm byte. */
13219 if (modrm
.mod
!= 3)
13221 OP_E_memory (bytemode
, sizeflag
);
13231 if ((sizeflag
& SUFFIX_ALWAYS
)
13232 && (bytemode
== x_swap_mode
13233 || bytemode
== d_swap_mode
13234 || bytemode
== q_swap_mode
))
13238 && bytemode
!= xmm_mode
13239 && bytemode
!= xmmq_mode
)
13241 switch (vex
.length
)
13244 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13247 sprintf (scratchbuf
, "%%ymm%d", modrm
.rm
+ add
);
13254 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13255 oappend (scratchbuf
+ intel_syntax
);
13259 OP_MS (int bytemode
, int sizeflag
)
13261 if (modrm
.mod
== 3)
13262 OP_EM (bytemode
, sizeflag
);
13268 OP_XS (int bytemode
, int sizeflag
)
13270 if (modrm
.mod
== 3)
13271 OP_EX (bytemode
, sizeflag
);
13277 OP_M (int bytemode
, int sizeflag
)
13279 if (modrm
.mod
== 3)
13280 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
13283 OP_E (bytemode
, sizeflag
);
13287 OP_0f07 (int bytemode
, int sizeflag
)
13289 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
13292 OP_E (bytemode
, sizeflag
);
13295 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
13296 32bit mode and "xchg %rax,%rax" in 64bit mode. */
13299 NOP_Fixup1 (int bytemode
, int sizeflag
)
13301 if ((prefixes
& PREFIX_DATA
) != 0
13304 && address_mode
== mode_64bit
))
13305 OP_REG (bytemode
, sizeflag
);
13307 strcpy (obuf
, "nop");
13311 NOP_Fixup2 (int bytemode
, int sizeflag
)
13313 if ((prefixes
& PREFIX_DATA
) != 0
13316 && address_mode
== mode_64bit
))
13317 OP_IMREG (bytemode
, sizeflag
);
13320 static const char *const Suffix3DNow
[] = {
13321 /* 00 */ NULL
, NULL
, NULL
, NULL
,
13322 /* 04 */ NULL
, NULL
, NULL
, NULL
,
13323 /* 08 */ NULL
, NULL
, NULL
, NULL
,
13324 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
13325 /* 10 */ NULL
, NULL
, NULL
, NULL
,
13326 /* 14 */ NULL
, NULL
, NULL
, NULL
,
13327 /* 18 */ NULL
, NULL
, NULL
, NULL
,
13328 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
13329 /* 20 */ NULL
, NULL
, NULL
, NULL
,
13330 /* 24 */ NULL
, NULL
, NULL
, NULL
,
13331 /* 28 */ NULL
, NULL
, NULL
, NULL
,
13332 /* 2C */ NULL
, NULL
, NULL
, NULL
,
13333 /* 30 */ NULL
, NULL
, NULL
, NULL
,
13334 /* 34 */ NULL
, NULL
, NULL
, NULL
,
13335 /* 38 */ NULL
, NULL
, NULL
, NULL
,
13336 /* 3C */ NULL
, NULL
, NULL
, NULL
,
13337 /* 40 */ NULL
, NULL
, NULL
, NULL
,
13338 /* 44 */ NULL
, NULL
, NULL
, NULL
,
13339 /* 48 */ NULL
, NULL
, NULL
, NULL
,
13340 /* 4C */ NULL
, NULL
, NULL
, NULL
,
13341 /* 50 */ NULL
, NULL
, NULL
, NULL
,
13342 /* 54 */ NULL
, NULL
, NULL
, NULL
,
13343 /* 58 */ NULL
, NULL
, NULL
, NULL
,
13344 /* 5C */ NULL
, NULL
, NULL
, NULL
,
13345 /* 60 */ NULL
, NULL
, NULL
, NULL
,
13346 /* 64 */ NULL
, NULL
, NULL
, NULL
,
13347 /* 68 */ NULL
, NULL
, NULL
, NULL
,
13348 /* 6C */ NULL
, NULL
, NULL
, NULL
,
13349 /* 70 */ NULL
, NULL
, NULL
, NULL
,
13350 /* 74 */ NULL
, NULL
, NULL
, NULL
,
13351 /* 78 */ NULL
, NULL
, NULL
, NULL
,
13352 /* 7C */ NULL
, NULL
, NULL
, NULL
,
13353 /* 80 */ NULL
, NULL
, NULL
, NULL
,
13354 /* 84 */ NULL
, NULL
, NULL
, NULL
,
13355 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
13356 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
13357 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
13358 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
13359 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
13360 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
13361 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
13362 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
13363 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
13364 /* AC */ NULL
, NULL
, "pfacc", NULL
,
13365 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
13366 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
13367 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
13368 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
13369 /* C0 */ NULL
, NULL
, NULL
, NULL
,
13370 /* C4 */ NULL
, NULL
, NULL
, NULL
,
13371 /* C8 */ NULL
, NULL
, NULL
, NULL
,
13372 /* CC */ NULL
, NULL
, NULL
, NULL
,
13373 /* D0 */ NULL
, NULL
, NULL
, NULL
,
13374 /* D4 */ NULL
, NULL
, NULL
, NULL
,
13375 /* D8 */ NULL
, NULL
, NULL
, NULL
,
13376 /* DC */ NULL
, NULL
, NULL
, NULL
,
13377 /* E0 */ NULL
, NULL
, NULL
, NULL
,
13378 /* E4 */ NULL
, NULL
, NULL
, NULL
,
13379 /* E8 */ NULL
, NULL
, NULL
, NULL
,
13380 /* EC */ NULL
, NULL
, NULL
, NULL
,
13381 /* F0 */ NULL
, NULL
, NULL
, NULL
,
13382 /* F4 */ NULL
, NULL
, NULL
, NULL
,
13383 /* F8 */ NULL
, NULL
, NULL
, NULL
,
13384 /* FC */ NULL
, NULL
, NULL
, NULL
,
13388 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13390 const char *mnemonic
;
13392 FETCH_DATA (the_info
, codep
+ 1);
13393 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13394 place where an 8-bit immediate would normally go. ie. the last
13395 byte of the instruction. */
13396 obufp
= mnemonicendp
;
13397 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
13399 oappend (mnemonic
);
13402 /* Since a variable sized modrm/sib chunk is between the start
13403 of the opcode (0x0f0f) and the opcode suffix, we need to do
13404 all the modrm processing first, and don't know until now that
13405 we have a bad opcode. This necessitates some cleaning up. */
13406 op_out
[0][0] = '\0';
13407 op_out
[1][0] = '\0';
13410 mnemonicendp
= obufp
;
13413 static struct op simd_cmp_op
[] =
13415 { STRING_COMMA_LEN ("eq") },
13416 { STRING_COMMA_LEN ("lt") },
13417 { STRING_COMMA_LEN ("le") },
13418 { STRING_COMMA_LEN ("unord") },
13419 { STRING_COMMA_LEN ("neq") },
13420 { STRING_COMMA_LEN ("nlt") },
13421 { STRING_COMMA_LEN ("nle") },
13422 { STRING_COMMA_LEN ("ord") }
13426 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13428 unsigned int cmp_type
;
13430 FETCH_DATA (the_info
, codep
+ 1);
13431 cmp_type
= *codep
++ & 0xff;
13432 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
13435 char *p
= mnemonicendp
- 2;
13439 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
13440 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
13444 /* We have a reserved extension byte. Output it directly. */
13445 scratchbuf
[0] = '$';
13446 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
13447 oappend (scratchbuf
+ intel_syntax
);
13448 scratchbuf
[0] = '\0';
13453 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
13454 int sizeflag ATTRIBUTE_UNUSED
)
13456 /* mwait %eax,%ecx */
13459 const char **names
= (address_mode
== mode_64bit
13460 ? names64
: names32
);
13461 strcpy (op_out
[0], names
[0]);
13462 strcpy (op_out
[1], names
[1]);
13463 two_source_ops
= 1;
13465 /* Skip mod/rm byte. */
13471 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
13472 int sizeflag ATTRIBUTE_UNUSED
)
13474 /* monitor %eax,%ecx,%edx" */
13477 const char **op1_names
;
13478 const char **names
= (address_mode
== mode_64bit
13479 ? names64
: names32
);
13481 if (!(prefixes
& PREFIX_ADDR
))
13482 op1_names
= (address_mode
== mode_16bit
13483 ? names16
: names
);
13486 /* Remove "addr16/addr32". */
13487 all_prefixes
[last_addr_prefix
] = 0;
13488 op1_names
= (address_mode
!= mode_32bit
13489 ? names32
: names16
);
13490 used_prefixes
|= PREFIX_ADDR
;
13492 strcpy (op_out
[0], op1_names
[0]);
13493 strcpy (op_out
[1], names
[1]);
13494 strcpy (op_out
[2], names
[2]);
13495 two_source_ops
= 1;
13497 /* Skip mod/rm byte. */
13505 /* Throw away prefixes and 1st. opcode byte. */
13506 codep
= insn_codep
+ 1;
13511 REP_Fixup (int bytemode
, int sizeflag
)
13513 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13515 if (prefixes
& PREFIX_REPZ
)
13516 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
13523 OP_IMREG (bytemode
, sizeflag
);
13526 OP_ESreg (bytemode
, sizeflag
);
13529 OP_DSreg (bytemode
, sizeflag
);
13538 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
13543 /* Change cmpxchg8b to cmpxchg16b. */
13544 char *p
= mnemonicendp
- 2;
13545 mnemonicendp
= stpcpy (p
, "16b");
13548 OP_M (bytemode
, sizeflag
);
13552 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
13556 switch (vex
.length
)
13559 sprintf (scratchbuf
, "%%xmm%d", reg
);
13562 sprintf (scratchbuf
, "%%ymm%d", reg
);
13569 sprintf (scratchbuf
, "%%xmm%d", reg
);
13570 oappend (scratchbuf
+ intel_syntax
);
13574 CRC32_Fixup (int bytemode
, int sizeflag
)
13576 /* Add proper suffix to "crc32". */
13577 char *p
= mnemonicendp
;
13596 if (sizeflag
& DFLAG
)
13600 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13604 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13611 if (modrm
.mod
== 3)
13615 /* Skip mod/rm byte. */
13620 add
= (rex
& REX_B
) ? 8 : 0;
13621 if (bytemode
== b_mode
)
13625 oappend (names8rex
[modrm
.rm
+ add
]);
13627 oappend (names8
[modrm
.rm
+ add
]);
13633 oappend (names64
[modrm
.rm
+ add
]);
13634 else if ((prefixes
& PREFIX_DATA
))
13635 oappend (names16
[modrm
.rm
+ add
]);
13637 oappend (names32
[modrm
.rm
+ add
]);
13641 OP_E (bytemode
, sizeflag
);
13644 /* Display the destination register operand for instructions with
13648 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13656 switch (vex
.length
)
13669 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13682 sprintf (scratchbuf
, "%%ymm%d", vex
.register_specifier
);
13688 oappend (scratchbuf
+ intel_syntax
);
13691 /* Get the VEX immediate byte without moving codep. */
13693 static unsigned char
13694 get_vex_imm8 (int sizeflag
, int opnum
)
13696 int bytes_before_imm
= 0;
13698 if (modrm
.mod
!= 3)
13700 /* There are SIB/displacement bytes. */
13701 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13703 /* 32/64 bit address mode */
13704 int base
= modrm
.rm
;
13706 /* Check SIB byte. */
13709 FETCH_DATA (the_info
, codep
+ 1);
13711 /* When decoding the third source, don't increase
13712 bytes_before_imm as this has already been incremented
13713 by one in OP_E_memory while decoding the second
13716 bytes_before_imm
++;
13721 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13722 SIB == 5, there is a 4 byte displacement. */
13724 /* No displacement. */
13727 /* 4 byte displacement. */
13728 bytes_before_imm
+= 4;
13731 /* 1 byte displacement: when decoding the third source,
13732 don't increase bytes_before_imm as this has already
13733 been incremented by one in OP_E_memory while decoding
13734 the second source operand. */
13736 bytes_before_imm
++;
13742 { /* 16 bit address mode */
13746 /* When modrm.rm == 6, there is a 2 byte displacement. */
13748 /* No displacement. */
13751 /* 2 byte displacement. */
13752 bytes_before_imm
+= 2;
13755 /* 1 byte displacement: when decoding the third source,
13756 don't increase bytes_before_imm as this has already
13757 been incremented by one in OP_E_memory while decoding
13758 the second source operand. */
13760 bytes_before_imm
++;
13767 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
13768 return codep
[bytes_before_imm
];
13772 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
13774 if (reg
== -1 && modrm
.mod
!= 3)
13776 OP_E_memory (bytemode
, sizeflag
);
13788 else if (reg
> 7 && address_mode
!= mode_64bit
)
13792 switch (vex
.length
)
13795 sprintf (scratchbuf
, "%%xmm%d", reg
);
13798 sprintf (scratchbuf
, "%%ymm%d", reg
);
13803 oappend (scratchbuf
+ intel_syntax
);
13807 OP_Vex_2src (int bytemode
, int sizeflag
)
13809 if (modrm
.mod
== 3)
13812 sprintf (scratchbuf
, "%%xmm%d", rex
& REX_B
? modrm
.rm
+ 8 : modrm
.rm
);
13813 oappend (scratchbuf
+ intel_syntax
);
13818 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13820 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13821 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13823 OP_E (bytemode
, sizeflag
);
13828 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
13830 if (modrm
.mod
== 3)
13832 /* Skip mod/rm byte. */
13839 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13840 oappend (scratchbuf
+ intel_syntax
);
13843 OP_Vex_2src (bytemode
, sizeflag
);
13847 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
13850 OP_Vex_2src (bytemode
, sizeflag
);
13853 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13854 oappend (scratchbuf
+ intel_syntax
);
13859 OP_EX_VexW (int bytemode
, int sizeflag
)
13867 /* Skip mod/rm byte. */
13872 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
13877 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
13880 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
13884 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
13885 int sizeflag ATTRIBUTE_UNUSED
)
13887 /* Skip the immediate byte and check for invalid bits. */
13888 FETCH_DATA (the_info
, codep
+ 1);
13889 if (*codep
++ & 0xf)
13894 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13897 FETCH_DATA (the_info
, codep
+ 1);
13900 if (bytemode
!= x_mode
)
13907 if (reg
> 7 && address_mode
!= mode_64bit
)
13910 switch (vex
.length
)
13913 sprintf (scratchbuf
, "%%xmm%d", reg
);
13916 sprintf (scratchbuf
, "%%ymm%d", reg
);
13921 oappend (scratchbuf
+ intel_syntax
);
13925 OP_XMM_VexW (int bytemode
, int sizeflag
)
13927 /* Turn off the REX.W bit since it is used for swapping operands
13930 OP_XMM (bytemode
, sizeflag
);
13934 OP_EX_Vex (int bytemode
, int sizeflag
)
13936 if (modrm
.mod
!= 3)
13938 if (vex
.register_specifier
!= 0)
13942 OP_EX (bytemode
, sizeflag
);
13946 OP_XMM_Vex (int bytemode
, int sizeflag
)
13948 if (modrm
.mod
!= 3)
13950 if (vex
.register_specifier
!= 0)
13954 OP_XMM (bytemode
, sizeflag
);
13958 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13960 switch (vex
.length
)
13963 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
13966 mnemonicendp
= stpcpy (obuf
, "vzeroall");
13973 static struct op vex_cmp_op
[] =
13975 { STRING_COMMA_LEN ("eq") },
13976 { STRING_COMMA_LEN ("lt") },
13977 { STRING_COMMA_LEN ("le") },
13978 { STRING_COMMA_LEN ("unord") },
13979 { STRING_COMMA_LEN ("neq") },
13980 { STRING_COMMA_LEN ("nlt") },
13981 { STRING_COMMA_LEN ("nle") },
13982 { STRING_COMMA_LEN ("ord") },
13983 { STRING_COMMA_LEN ("eq_uq") },
13984 { STRING_COMMA_LEN ("nge") },
13985 { STRING_COMMA_LEN ("ngt") },
13986 { STRING_COMMA_LEN ("false") },
13987 { STRING_COMMA_LEN ("neq_oq") },
13988 { STRING_COMMA_LEN ("ge") },
13989 { STRING_COMMA_LEN ("gt") },
13990 { STRING_COMMA_LEN ("true") },
13991 { STRING_COMMA_LEN ("eq_os") },
13992 { STRING_COMMA_LEN ("lt_oq") },
13993 { STRING_COMMA_LEN ("le_oq") },
13994 { STRING_COMMA_LEN ("unord_s") },
13995 { STRING_COMMA_LEN ("neq_us") },
13996 { STRING_COMMA_LEN ("nlt_uq") },
13997 { STRING_COMMA_LEN ("nle_uq") },
13998 { STRING_COMMA_LEN ("ord_s") },
13999 { STRING_COMMA_LEN ("eq_us") },
14000 { STRING_COMMA_LEN ("nge_uq") },
14001 { STRING_COMMA_LEN ("ngt_uq") },
14002 { STRING_COMMA_LEN ("false_os") },
14003 { STRING_COMMA_LEN ("neq_os") },
14004 { STRING_COMMA_LEN ("ge_oq") },
14005 { STRING_COMMA_LEN ("gt_oq") },
14006 { STRING_COMMA_LEN ("true_us") },
14010 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14012 unsigned int cmp_type
;
14014 FETCH_DATA (the_info
, codep
+ 1);
14015 cmp_type
= *codep
++ & 0xff;
14016 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14019 char *p
= mnemonicendp
- 2;
14023 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14024 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14028 /* We have a reserved extension byte. Output it directly. */
14029 scratchbuf
[0] = '$';
14030 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14031 oappend (scratchbuf
+ intel_syntax
);
14032 scratchbuf
[0] = '\0';
14036 static const struct op pclmul_op
[] =
14038 { STRING_COMMA_LEN ("lql") },
14039 { STRING_COMMA_LEN ("hql") },
14040 { STRING_COMMA_LEN ("lqh") },
14041 { STRING_COMMA_LEN ("hqh") }
14045 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14046 int sizeflag ATTRIBUTE_UNUSED
)
14048 unsigned int pclmul_type
;
14050 FETCH_DATA (the_info
, codep
+ 1);
14051 pclmul_type
= *codep
++ & 0xff;
14052 switch (pclmul_type
)
14063 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14066 char *p
= mnemonicendp
- 3;
14071 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14072 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14076 /* We have a reserved extension byte. Output it directly. */
14077 scratchbuf
[0] = '$';
14078 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14079 oappend (scratchbuf
+ intel_syntax
);
14080 scratchbuf
[0] = '\0';
14085 MOVBE_Fixup (int bytemode
, int sizeflag
)
14087 /* Add proper suffix to "movbe". */
14088 char *p
= mnemonicendp
;
14097 if (sizeflag
& SUFFIX_ALWAYS
)
14103 if (sizeflag
& DFLAG
)
14107 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14112 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14119 OP_M (bytemode
, sizeflag
);
14123 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14126 const char **names
;
14128 /* Skip mod/rm byte. */
14134 else if (vex
.length
== 256)
14144 oappend (names
[reg
]);
14148 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14150 const char **names
;
14154 else if (vex
.length
== 256)
14159 oappend (names
[vex
.register_specifier
]);
14163 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
14165 if (vex
.w
|| vex
.length
== 256)
14166 OP_I (q_mode
, sizeflag
);
14168 OP_I (w_mode
, sizeflag
);