1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma
, disassemble_info
*);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma
);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma
);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma
get64 (void);
60 static bfd_signed_vma
get32 (void);
61 static bfd_signed_vma
get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma
, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void FXSAVE_Fixup (int, int);
114 static void OP_LWPCB_E (int, int);
115 static void OP_LWP_E (int, int);
116 static void OP_LWP_I (int, int);
117 static void OP_Vex_2src_1 (int, int);
118 static void OP_Vex_2src_2 (int, int);
120 static void MOVBE_Fixup (int, int);
123 /* Points to first byte not fetched. */
124 bfd_byte
*max_fetched
;
125 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
138 enum address_mode address_mode
;
140 /* Flags for the prefixes for the current instruction. See below. */
143 /* REX prefix the current instruction. See below. */
145 /* Bits of REX we've already used. */
147 /* Original REX prefix. */
148 static int rex_original
;
149 /* REX bits in original REX prefix ignored. It may not be the same
150 as rex_original since some bits may not be ignored. */
151 static int rex_ignored
;
152 /* Mark parts used in the REX prefix. When we are testing for
153 empty prefix (for 8bit register REX extension), just mask it
154 out. Otherwise test for REX bit is excuse for existence of REX
155 only in case value is nonzero. */
156 #define USED_REX(value) \
161 rex_used |= (value) | REX_OPCODE; \
164 rex_used |= REX_OPCODE; \
167 /* Flags for prefixes which we somehow handled when printing the
168 current instruction. */
169 static int used_prefixes
;
171 /* Flags stored in PREFIXES. */
172 #define PREFIX_REPZ 1
173 #define PREFIX_REPNZ 2
174 #define PREFIX_LOCK 4
176 #define PREFIX_SS 0x10
177 #define PREFIX_DS 0x20
178 #define PREFIX_ES 0x40
179 #define PREFIX_FS 0x80
180 #define PREFIX_GS 0x100
181 #define PREFIX_DATA 0x200
182 #define PREFIX_ADDR 0x400
183 #define PREFIX_FWAIT 0x800
185 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
186 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
188 #define FETCH_DATA(info, addr) \
189 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
190 ? 1 : fetch_data ((info), (addr)))
193 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
196 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
197 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
199 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
200 status
= (*info
->read_memory_func
) (start
,
202 addr
- priv
->max_fetched
,
208 /* If we did manage to read at least one byte, then
209 print_insn_i386 will do something sensible. Otherwise, print
210 an error. We do that here because this is where we know
212 if (priv
->max_fetched
== priv
->the_buffer
)
213 (*info
->memory_error_func
) (status
, start
, info
);
214 longjmp (priv
->bailout
, 1);
217 priv
->max_fetched
= addr
;
221 #define XX { NULL, 0 }
223 #define Eb { OP_E, b_mode }
224 #define EbS { OP_E, b_swap_mode }
225 #define Ev { OP_E, v_mode }
226 #define EvS { OP_E, v_swap_mode }
227 #define Ed { OP_E, d_mode }
228 #define Edq { OP_E, dq_mode }
229 #define Edqw { OP_E, dqw_mode }
230 #define Edqb { OP_E, dqb_mode }
231 #define Edqd { OP_E, dqd_mode }
232 #define Eq { OP_E, q_mode }
233 #define indirEv { OP_indirE, stack_v_mode }
234 #define indirEp { OP_indirE, f_mode }
235 #define stackEv { OP_E, stack_v_mode }
236 #define Em { OP_E, m_mode }
237 #define Ew { OP_E, w_mode }
238 #define M { OP_M, 0 } /* lea, lgdt, etc. */
239 #define Ma { OP_M, a_mode }
240 #define Mb { OP_M, b_mode }
241 #define Md { OP_M, d_mode }
242 #define Mo { OP_M, o_mode }
243 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
244 #define Mq { OP_M, q_mode }
245 #define Mx { OP_M, x_mode }
246 #define Mxmm { OP_M, xmm_mode }
247 #define Gb { OP_G, b_mode }
248 #define Gv { OP_G, v_mode }
249 #define Gd { OP_G, d_mode }
250 #define Gdq { OP_G, dq_mode }
251 #define Gm { OP_G, m_mode }
252 #define Gw { OP_G, w_mode }
253 #define Rd { OP_R, d_mode }
254 #define Rm { OP_R, m_mode }
255 #define Ib { OP_I, b_mode }
256 #define sIb { OP_sI, b_mode } /* sign extened byte */
257 #define Iv { OP_I, v_mode }
258 #define Iq { OP_I, q_mode }
259 #define Iv64 { OP_I64, v_mode }
260 #define Iw { OP_I, w_mode }
261 #define I1 { OP_I, const_1_mode }
262 #define Jb { OP_J, b_mode }
263 #define Jv { OP_J, v_mode }
264 #define Cm { OP_C, m_mode }
265 #define Dm { OP_D, m_mode }
266 #define Td { OP_T, d_mode }
267 #define Skip_MODRM { OP_Skip_MODRM, 0 }
269 #define RMeAX { OP_REG, eAX_reg }
270 #define RMeBX { OP_REG, eBX_reg }
271 #define RMeCX { OP_REG, eCX_reg }
272 #define RMeDX { OP_REG, eDX_reg }
273 #define RMeSP { OP_REG, eSP_reg }
274 #define RMeBP { OP_REG, eBP_reg }
275 #define RMeSI { OP_REG, eSI_reg }
276 #define RMeDI { OP_REG, eDI_reg }
277 #define RMrAX { OP_REG, rAX_reg }
278 #define RMrBX { OP_REG, rBX_reg }
279 #define RMrCX { OP_REG, rCX_reg }
280 #define RMrDX { OP_REG, rDX_reg }
281 #define RMrSP { OP_REG, rSP_reg }
282 #define RMrBP { OP_REG, rBP_reg }
283 #define RMrSI { OP_REG, rSI_reg }
284 #define RMrDI { OP_REG, rDI_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMAL { OP_REG, al_reg }
287 #define RMCL { OP_REG, cl_reg }
288 #define RMDL { OP_REG, dl_reg }
289 #define RMBL { OP_REG, bl_reg }
290 #define RMAH { OP_REG, ah_reg }
291 #define RMCH { OP_REG, ch_reg }
292 #define RMDH { OP_REG, dh_reg }
293 #define RMBH { OP_REG, bh_reg }
294 #define RMAX { OP_REG, ax_reg }
295 #define RMDX { OP_REG, dx_reg }
297 #define eAX { OP_IMREG, eAX_reg }
298 #define eBX { OP_IMREG, eBX_reg }
299 #define eCX { OP_IMREG, eCX_reg }
300 #define eDX { OP_IMREG, eDX_reg }
301 #define eSP { OP_IMREG, eSP_reg }
302 #define eBP { OP_IMREG, eBP_reg }
303 #define eSI { OP_IMREG, eSI_reg }
304 #define eDI { OP_IMREG, eDI_reg }
305 #define AL { OP_IMREG, al_reg }
306 #define CL { OP_IMREG, cl_reg }
307 #define DL { OP_IMREG, dl_reg }
308 #define BL { OP_IMREG, bl_reg }
309 #define AH { OP_IMREG, ah_reg }
310 #define CH { OP_IMREG, ch_reg }
311 #define DH { OP_IMREG, dh_reg }
312 #define BH { OP_IMREG, bh_reg }
313 #define AX { OP_IMREG, ax_reg }
314 #define DX { OP_IMREG, dx_reg }
315 #define zAX { OP_IMREG, z_mode_ax_reg }
316 #define indirDX { OP_IMREG, indir_dx_reg }
318 #define Sw { OP_SEG, w_mode }
319 #define Sv { OP_SEG, v_mode }
320 #define Ap { OP_DIR, 0 }
321 #define Ob { OP_OFF64, b_mode }
322 #define Ov { OP_OFF64, v_mode }
323 #define Xb { OP_DSreg, eSI_reg }
324 #define Xv { OP_DSreg, eSI_reg }
325 #define Xz { OP_DSreg, eSI_reg }
326 #define Yb { OP_ESreg, eDI_reg }
327 #define Yv { OP_ESreg, eDI_reg }
328 #define DSBX { OP_DSreg, eBX_reg }
330 #define es { OP_REG, es_reg }
331 #define ss { OP_REG, ss_reg }
332 #define cs { OP_REG, cs_reg }
333 #define ds { OP_REG, ds_reg }
334 #define fs { OP_REG, fs_reg }
335 #define gs { OP_REG, gs_reg }
337 #define MX { OP_MMX, 0 }
338 #define XM { OP_XMM, 0 }
339 #define XMM { OP_XMM, xmm_mode }
340 #define EM { OP_EM, v_mode }
341 #define EMS { OP_EM, v_swap_mode }
342 #define EMd { OP_EM, d_mode }
343 #define EMx { OP_EM, x_mode }
344 #define EXw { OP_EX, w_mode }
345 #define EXd { OP_EX, d_mode }
346 #define EXdS { OP_EX, d_swap_mode }
347 #define EXq { OP_EX, q_mode }
348 #define EXqS { OP_EX, q_swap_mode }
349 #define EXx { OP_EX, x_mode }
350 #define EXxS { OP_EX, x_swap_mode }
351 #define EXxmm { OP_EX, xmm_mode }
352 #define EXxmmq { OP_EX, xmmq_mode }
353 #define EXymmq { OP_EX, ymmq_mode }
354 #define EXVexWdq { OP_EX, vex_w_dq_mode }
355 #define MS { OP_MS, v_mode }
356 #define XS { OP_XS, v_mode }
357 #define EMCq { OP_EMC, q_mode }
358 #define MXC { OP_MXC, 0 }
359 #define OPSUF { OP_3DNowSuffix, 0 }
360 #define CMP { CMP_Fixup, 0 }
361 #define XMM0 { XMM_Fixup, 0 }
362 #define FXSAVE { FXSAVE_Fixup, 0 }
363 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
364 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
366 #define Vex { OP_VEX, vex_mode }
367 #define Vex128 { OP_VEX, vex128_mode }
368 #define Vex256 { OP_VEX, vex256_mode }
369 #define VexI4 { VEXI4_Fixup, 0}
370 #define EXdVex { OP_EX_Vex, d_mode }
371 #define EXdVexS { OP_EX_Vex, d_swap_mode }
372 #define EXqVex { OP_EX_Vex, q_mode }
373 #define EXqVexS { OP_EX_Vex, q_swap_mode }
374 #define EXVexW { OP_EX_VexW, x_mode }
375 #define EXdVexW { OP_EX_VexW, d_mode }
376 #define EXqVexW { OP_EX_VexW, q_mode }
377 #define XMVex { OP_XMM_Vex, 0 }
378 #define XMVexW { OP_XMM_VexW, 0 }
379 #define XMVexI4 { OP_REG_VexI4, x_mode }
380 #define PCLMUL { PCLMUL_Fixup, 0 }
381 #define VZERO { VZERO_Fixup, 0 }
382 #define VCMP { VCMP_Fixup, 0 }
384 /* Used handle "rep" prefix for string instructions. */
385 #define Xbr { REP_Fixup, eSI_reg }
386 #define Xvr { REP_Fixup, eSI_reg }
387 #define Ybr { REP_Fixup, eDI_reg }
388 #define Yvr { REP_Fixup, eDI_reg }
389 #define Yzr { REP_Fixup, eDI_reg }
390 #define indirDXr { REP_Fixup, indir_dx_reg }
391 #define ALr { REP_Fixup, al_reg }
392 #define eAXr { REP_Fixup, eAX_reg }
394 #define cond_jump_flag { NULL, cond_jump_mode }
395 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
397 /* bits in sizeflag */
398 #define SUFFIX_ALWAYS 4
406 /* byte operand with operand swapped */
408 /* operand size depends on prefixes */
410 /* operand size depends on prefixes with operand swapped */
414 /* double word operand */
416 /* double word operand with operand swapped */
418 /* quad word operand */
420 /* quad word operand with operand swapped */
422 /* ten-byte operand */
424 /* 16-byte XMM or 32-byte YMM operand */
426 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
428 /* 16-byte XMM operand */
430 /* 16-byte XMM or quad word operand */
432 /* 32-byte YMM or quad word operand */
434 /* d_mode in 32bit, q_mode in 64bit mode. */
436 /* pair of v_mode operands */
440 /* operand size depends on REX prefixes. */
442 /* registers like dq_mode, memory like w_mode. */
444 /* 4- or 6-byte pointer operand */
447 /* v_mode for stack-related opcodes. */
449 /* non-quad operand size depends on prefixes */
451 /* 16-byte operand */
453 /* registers like dq_mode, memory like b_mode. */
455 /* registers like dq_mode, memory like d_mode. */
457 /* normal vex mode */
459 /* 128bit vex mode */
461 /* 256bit vex mode */
463 /* operand size depends on the VEX.W bit. */
528 #define FLOAT NULL, { { NULL, FLOATCODE } }
530 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
531 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
532 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
533 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
534 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
535 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
536 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
537 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
538 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
539 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
540 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
658 MOD_VEX_3818_PREFIX_2
,
659 MOD_VEX_3819_PREFIX_2
,
660 MOD_VEX_381A_PREFIX_2
,
661 MOD_VEX_382A_PREFIX_2
,
662 MOD_VEX_382C_PREFIX_2
,
663 MOD_VEX_382D_PREFIX_2
,
664 MOD_VEX_382E_PREFIX_2
,
665 MOD_VEX_382F_PREFIX_2
1075 THREE_BYTE_0F38
= 0,
1230 VEX_LEN_3819_P_2_M_0
,
1231 VEX_LEN_381A_P_2_M_0
,
1243 VEX_LEN_382A_P_2_M_0
,
1302 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
1313 /* Upper case letters in the instruction names here are macros.
1314 'A' => print 'b' if no register operands or suffix_always is true
1315 'B' => print 'b' if suffix_always is true
1316 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1318 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1319 suffix_always is true
1320 'E' => print 'e' if 32-bit form of jcxz
1321 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1322 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1323 'H' => print ",pt" or ",pn" branch hint
1324 'I' => honor following macro letter even in Intel mode (implemented only
1325 for some of the macro letters)
1327 'K' => print 'd' or 'q' if rex prefix is present.
1328 'L' => print 'l' if suffix_always is true
1329 'M' => print 'r' if intel_mnemonic is false.
1330 'N' => print 'n' if instruction has no wait "prefix"
1331 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1332 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1333 or suffix_always is true. print 'q' if rex prefix is present.
1334 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1336 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1337 'S' => print 'w', 'l' or 'q' if suffix_always is true
1338 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1339 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1340 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1341 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1342 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1343 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1344 suffix_always is true.
1345 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1346 '!' => change condition from true to false or from false to true.
1347 '%' => add 1 upper case letter to the macro.
1349 2 upper case letter macros:
1350 "XY" => print 'x' or 'y' if no register operands or suffix_always
1352 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1353 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1354 or suffix_always is true
1355 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1356 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1357 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1359 Many of the above letters print nothing in Intel mode. See "putop"
1362 Braces '{' and '}', and vertical bars '|', indicate alternative
1363 mnemonic strings for AT&T and Intel. */
1365 static const struct dis386 dis386
[] = {
1367 { "addB", { Eb
, Gb
} },
1368 { "addS", { Ev
, Gv
} },
1369 { "addB", { Gb
, EbS
} },
1370 { "addS", { Gv
, EvS
} },
1371 { "addB", { AL
, Ib
} },
1372 { "addS", { eAX
, Iv
} },
1373 { X86_64_TABLE (X86_64_06
) },
1374 { X86_64_TABLE (X86_64_07
) },
1376 { "orB", { Eb
, Gb
} },
1377 { "orS", { Ev
, Gv
} },
1378 { "orB", { Gb
, EbS
} },
1379 { "orS", { Gv
, EvS
} },
1380 { "orB", { AL
, Ib
} },
1381 { "orS", { eAX
, Iv
} },
1382 { X86_64_TABLE (X86_64_0D
) },
1383 { "(bad)", { XX
} }, /* 0x0f extended opcode escape */
1385 { "adcB", { Eb
, Gb
} },
1386 { "adcS", { Ev
, Gv
} },
1387 { "adcB", { Gb
, EbS
} },
1388 { "adcS", { Gv
, EvS
} },
1389 { "adcB", { AL
, Ib
} },
1390 { "adcS", { eAX
, Iv
} },
1391 { X86_64_TABLE (X86_64_16
) },
1392 { X86_64_TABLE (X86_64_17
) },
1394 { "sbbB", { Eb
, Gb
} },
1395 { "sbbS", { Ev
, Gv
} },
1396 { "sbbB", { Gb
, EbS
} },
1397 { "sbbS", { Gv
, EvS
} },
1398 { "sbbB", { AL
, Ib
} },
1399 { "sbbS", { eAX
, Iv
} },
1400 { X86_64_TABLE (X86_64_1E
) },
1401 { X86_64_TABLE (X86_64_1F
) },
1403 { "andB", { Eb
, Gb
} },
1404 { "andS", { Ev
, Gv
} },
1405 { "andB", { Gb
, EbS
} },
1406 { "andS", { Gv
, EvS
} },
1407 { "andB", { AL
, Ib
} },
1408 { "andS", { eAX
, Iv
} },
1409 { "(bad)", { XX
} }, /* SEG ES prefix */
1410 { X86_64_TABLE (X86_64_27
) },
1412 { "subB", { Eb
, Gb
} },
1413 { "subS", { Ev
, Gv
} },
1414 { "subB", { Gb
, EbS
} },
1415 { "subS", { Gv
, EvS
} },
1416 { "subB", { AL
, Ib
} },
1417 { "subS", { eAX
, Iv
} },
1418 { "(bad)", { XX
} }, /* SEG CS prefix */
1419 { X86_64_TABLE (X86_64_2F
) },
1421 { "xorB", { Eb
, Gb
} },
1422 { "xorS", { Ev
, Gv
} },
1423 { "xorB", { Gb
, EbS
} },
1424 { "xorS", { Gv
, EvS
} },
1425 { "xorB", { AL
, Ib
} },
1426 { "xorS", { eAX
, Iv
} },
1427 { "(bad)", { XX
} }, /* SEG SS prefix */
1428 { X86_64_TABLE (X86_64_37
) },
1430 { "cmpB", { Eb
, Gb
} },
1431 { "cmpS", { Ev
, Gv
} },
1432 { "cmpB", { Gb
, EbS
} },
1433 { "cmpS", { Gv
, EvS
} },
1434 { "cmpB", { AL
, Ib
} },
1435 { "cmpS", { eAX
, Iv
} },
1436 { "(bad)", { XX
} }, /* SEG DS prefix */
1437 { X86_64_TABLE (X86_64_3F
) },
1439 { "inc{S|}", { RMeAX
} },
1440 { "inc{S|}", { RMeCX
} },
1441 { "inc{S|}", { RMeDX
} },
1442 { "inc{S|}", { RMeBX
} },
1443 { "inc{S|}", { RMeSP
} },
1444 { "inc{S|}", { RMeBP
} },
1445 { "inc{S|}", { RMeSI
} },
1446 { "inc{S|}", { RMeDI
} },
1448 { "dec{S|}", { RMeAX
} },
1449 { "dec{S|}", { RMeCX
} },
1450 { "dec{S|}", { RMeDX
} },
1451 { "dec{S|}", { RMeBX
} },
1452 { "dec{S|}", { RMeSP
} },
1453 { "dec{S|}", { RMeBP
} },
1454 { "dec{S|}", { RMeSI
} },
1455 { "dec{S|}", { RMeDI
} },
1457 { "pushV", { RMrAX
} },
1458 { "pushV", { RMrCX
} },
1459 { "pushV", { RMrDX
} },
1460 { "pushV", { RMrBX
} },
1461 { "pushV", { RMrSP
} },
1462 { "pushV", { RMrBP
} },
1463 { "pushV", { RMrSI
} },
1464 { "pushV", { RMrDI
} },
1466 { "popV", { RMrAX
} },
1467 { "popV", { RMrCX
} },
1468 { "popV", { RMrDX
} },
1469 { "popV", { RMrBX
} },
1470 { "popV", { RMrSP
} },
1471 { "popV", { RMrBP
} },
1472 { "popV", { RMrSI
} },
1473 { "popV", { RMrDI
} },
1475 { X86_64_TABLE (X86_64_60
) },
1476 { X86_64_TABLE (X86_64_61
) },
1477 { X86_64_TABLE (X86_64_62
) },
1478 { X86_64_TABLE (X86_64_63
) },
1479 { "(bad)", { XX
} }, /* seg fs */
1480 { "(bad)", { XX
} }, /* seg gs */
1481 { "(bad)", { XX
} }, /* op size prefix */
1482 { "(bad)", { XX
} }, /* adr size prefix */
1484 { "pushT", { Iq
} },
1485 { "imulS", { Gv
, Ev
, Iv
} },
1486 { "pushT", { sIb
} },
1487 { "imulS", { Gv
, Ev
, sIb
} },
1488 { "ins{b|}", { Ybr
, indirDX
} },
1489 { X86_64_TABLE (X86_64_6D
) },
1490 { "outs{b|}", { indirDXr
, Xb
} },
1491 { X86_64_TABLE (X86_64_6F
) },
1493 { "joH", { Jb
, XX
, cond_jump_flag
} },
1494 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
1495 { "jbH", { Jb
, XX
, cond_jump_flag
} },
1496 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
1497 { "jeH", { Jb
, XX
, cond_jump_flag
} },
1498 { "jneH", { Jb
, XX
, cond_jump_flag
} },
1499 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
1500 { "jaH", { Jb
, XX
, cond_jump_flag
} },
1502 { "jsH", { Jb
, XX
, cond_jump_flag
} },
1503 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
1504 { "jpH", { Jb
, XX
, cond_jump_flag
} },
1505 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
1506 { "jlH", { Jb
, XX
, cond_jump_flag
} },
1507 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
1508 { "jleH", { Jb
, XX
, cond_jump_flag
} },
1509 { "jgH", { Jb
, XX
, cond_jump_flag
} },
1511 { REG_TABLE (REG_80
) },
1512 { REG_TABLE (REG_81
) },
1513 { "(bad)", { XX
} },
1514 { REG_TABLE (REG_82
) },
1515 { "testB", { Eb
, Gb
} },
1516 { "testS", { Ev
, Gv
} },
1517 { "xchgB", { Eb
, Gb
} },
1518 { "xchgS", { Ev
, Gv
} },
1520 { "movB", { Eb
, Gb
} },
1521 { "movS", { Ev
, Gv
} },
1522 { "movB", { Gb
, EbS
} },
1523 { "movS", { Gv
, EvS
} },
1524 { "movD", { Sv
, Sw
} },
1525 { MOD_TABLE (MOD_8D
) },
1526 { "movD", { Sw
, Sv
} },
1527 { REG_TABLE (REG_8F
) },
1529 { PREFIX_TABLE (PREFIX_90
) },
1530 { "xchgS", { RMeCX
, eAX
} },
1531 { "xchgS", { RMeDX
, eAX
} },
1532 { "xchgS", { RMeBX
, eAX
} },
1533 { "xchgS", { RMeSP
, eAX
} },
1534 { "xchgS", { RMeBP
, eAX
} },
1535 { "xchgS", { RMeSI
, eAX
} },
1536 { "xchgS", { RMeDI
, eAX
} },
1538 { "cW{t|}R", { XX
} },
1539 { "cR{t|}O", { XX
} },
1540 { X86_64_TABLE (X86_64_9A
) },
1541 { "(bad)", { XX
} }, /* fwait */
1542 { "pushfT", { XX
} },
1543 { "popfT", { XX
} },
1547 { "mov%LB", { AL
, Ob
} },
1548 { "mov%LS", { eAX
, Ov
} },
1549 { "mov%LB", { Ob
, AL
} },
1550 { "mov%LS", { Ov
, eAX
} },
1551 { "movs{b|}", { Ybr
, Xb
} },
1552 { "movs{R|}", { Yvr
, Xv
} },
1553 { "cmps{b|}", { Xb
, Yb
} },
1554 { "cmps{R|}", { Xv
, Yv
} },
1556 { "testB", { AL
, Ib
} },
1557 { "testS", { eAX
, Iv
} },
1558 { "stosB", { Ybr
, AL
} },
1559 { "stosS", { Yvr
, eAX
} },
1560 { "lodsB", { ALr
, Xb
} },
1561 { "lodsS", { eAXr
, Xv
} },
1562 { "scasB", { AL
, Yb
} },
1563 { "scasS", { eAX
, Yv
} },
1565 { "movB", { RMAL
, Ib
} },
1566 { "movB", { RMCL
, Ib
} },
1567 { "movB", { RMDL
, Ib
} },
1568 { "movB", { RMBL
, Ib
} },
1569 { "movB", { RMAH
, Ib
} },
1570 { "movB", { RMCH
, Ib
} },
1571 { "movB", { RMDH
, Ib
} },
1572 { "movB", { RMBH
, Ib
} },
1574 { "mov%LV", { RMeAX
, Iv64
} },
1575 { "mov%LV", { RMeCX
, Iv64
} },
1576 { "mov%LV", { RMeDX
, Iv64
} },
1577 { "mov%LV", { RMeBX
, Iv64
} },
1578 { "mov%LV", { RMeSP
, Iv64
} },
1579 { "mov%LV", { RMeBP
, Iv64
} },
1580 { "mov%LV", { RMeSI
, Iv64
} },
1581 { "mov%LV", { RMeDI
, Iv64
} },
1583 { REG_TABLE (REG_C0
) },
1584 { REG_TABLE (REG_C1
) },
1587 { X86_64_TABLE (X86_64_C4
) },
1588 { X86_64_TABLE (X86_64_C5
) },
1589 { REG_TABLE (REG_C6
) },
1590 { REG_TABLE (REG_C7
) },
1592 { "enterT", { Iw
, Ib
} },
1593 { "leaveT", { XX
} },
1594 { "Jret{|f}P", { Iw
} },
1595 { "Jret{|f}P", { XX
} },
1598 { X86_64_TABLE (X86_64_CE
) },
1599 { "iretP", { XX
} },
1601 { REG_TABLE (REG_D0
) },
1602 { REG_TABLE (REG_D1
) },
1603 { REG_TABLE (REG_D2
) },
1604 { REG_TABLE (REG_D3
) },
1605 { X86_64_TABLE (X86_64_D4
) },
1606 { X86_64_TABLE (X86_64_D5
) },
1607 { "(bad)", { XX
} },
1608 { "xlat", { DSBX
} },
1619 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
1620 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
1621 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
1622 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
1623 { "inB", { AL
, Ib
} },
1624 { "inG", { zAX
, Ib
} },
1625 { "outB", { Ib
, AL
} },
1626 { "outG", { Ib
, zAX
} },
1628 { "callT", { Jv
} },
1630 { X86_64_TABLE (X86_64_EA
) },
1632 { "inB", { AL
, indirDX
} },
1633 { "inG", { zAX
, indirDX
} },
1634 { "outB", { indirDX
, AL
} },
1635 { "outG", { indirDX
, zAX
} },
1637 { "(bad)", { XX
} }, /* lock prefix */
1638 { "icebp", { XX
} },
1639 { "(bad)", { XX
} }, /* repne */
1640 { "(bad)", { XX
} }, /* repz */
1643 { REG_TABLE (REG_F6
) },
1644 { REG_TABLE (REG_F7
) },
1652 { REG_TABLE (REG_FE
) },
1653 { REG_TABLE (REG_FF
) },
1656 static const struct dis386 dis386_twobyte
[] = {
1658 { REG_TABLE (REG_0F00
) },
1659 { REG_TABLE (REG_0F01
) },
1660 { "larS", { Gv
, Ew
} },
1661 { "lslS", { Gv
, Ew
} },
1662 { "(bad)", { XX
} },
1663 { "syscall", { XX
} },
1665 { "sysretP", { XX
} },
1668 { "wbinvd", { XX
} },
1669 { "(bad)", { XX
} },
1671 { "(bad)", { XX
} },
1672 { REG_TABLE (REG_0F0D
) },
1673 { "femms", { XX
} },
1674 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1676 { PREFIX_TABLE (PREFIX_0F10
) },
1677 { PREFIX_TABLE (PREFIX_0F11
) },
1678 { PREFIX_TABLE (PREFIX_0F12
) },
1679 { MOD_TABLE (MOD_0F13
) },
1680 { "unpcklpX", { XM
, EXx
} },
1681 { "unpckhpX", { XM
, EXx
} },
1682 { PREFIX_TABLE (PREFIX_0F16
) },
1683 { MOD_TABLE (MOD_0F17
) },
1685 { REG_TABLE (REG_0F18
) },
1694 { MOD_TABLE (MOD_0F20
) },
1695 { MOD_TABLE (MOD_0F21
) },
1696 { MOD_TABLE (MOD_0F22
) },
1697 { MOD_TABLE (MOD_0F23
) },
1698 { MOD_TABLE (MOD_0F24
) },
1699 { "(bad)", { XX
} },
1700 { MOD_TABLE (MOD_0F26
) },
1701 { "(bad)", { XX
} },
1703 { "movapX", { XM
, EXx
} },
1704 { "movapX", { EXxS
, XM
} },
1705 { PREFIX_TABLE (PREFIX_0F2A
) },
1706 { PREFIX_TABLE (PREFIX_0F2B
) },
1707 { PREFIX_TABLE (PREFIX_0F2C
) },
1708 { PREFIX_TABLE (PREFIX_0F2D
) },
1709 { PREFIX_TABLE (PREFIX_0F2E
) },
1710 { PREFIX_TABLE (PREFIX_0F2F
) },
1712 { "wrmsr", { XX
} },
1713 { "rdtsc", { XX
} },
1714 { "rdmsr", { XX
} },
1715 { "rdpmc", { XX
} },
1716 { "sysenter", { XX
} },
1717 { "sysexit", { XX
} },
1718 { "(bad)", { XX
} },
1719 { "getsec", { XX
} },
1721 { THREE_BYTE_TABLE (THREE_BYTE_0F38
) },
1722 { "(bad)", { XX
} },
1723 { THREE_BYTE_TABLE (THREE_BYTE_0F3A
) },
1724 { "(bad)", { XX
} },
1725 { "(bad)", { XX
} },
1726 { "(bad)", { XX
} },
1727 { "(bad)", { XX
} },
1728 { "(bad)", { XX
} },
1730 { "cmovoS", { Gv
, Ev
} },
1731 { "cmovnoS", { Gv
, Ev
} },
1732 { "cmovbS", { Gv
, Ev
} },
1733 { "cmovaeS", { Gv
, Ev
} },
1734 { "cmoveS", { Gv
, Ev
} },
1735 { "cmovneS", { Gv
, Ev
} },
1736 { "cmovbeS", { Gv
, Ev
} },
1737 { "cmovaS", { Gv
, Ev
} },
1739 { "cmovsS", { Gv
, Ev
} },
1740 { "cmovnsS", { Gv
, Ev
} },
1741 { "cmovpS", { Gv
, Ev
} },
1742 { "cmovnpS", { Gv
, Ev
} },
1743 { "cmovlS", { Gv
, Ev
} },
1744 { "cmovgeS", { Gv
, Ev
} },
1745 { "cmovleS", { Gv
, Ev
} },
1746 { "cmovgS", { Gv
, Ev
} },
1748 { MOD_TABLE (MOD_0F51
) },
1749 { PREFIX_TABLE (PREFIX_0F51
) },
1750 { PREFIX_TABLE (PREFIX_0F52
) },
1751 { PREFIX_TABLE (PREFIX_0F53
) },
1752 { "andpX", { XM
, EXx
} },
1753 { "andnpX", { XM
, EXx
} },
1754 { "orpX", { XM
, EXx
} },
1755 { "xorpX", { XM
, EXx
} },
1757 { PREFIX_TABLE (PREFIX_0F58
) },
1758 { PREFIX_TABLE (PREFIX_0F59
) },
1759 { PREFIX_TABLE (PREFIX_0F5A
) },
1760 { PREFIX_TABLE (PREFIX_0F5B
) },
1761 { PREFIX_TABLE (PREFIX_0F5C
) },
1762 { PREFIX_TABLE (PREFIX_0F5D
) },
1763 { PREFIX_TABLE (PREFIX_0F5E
) },
1764 { PREFIX_TABLE (PREFIX_0F5F
) },
1766 { PREFIX_TABLE (PREFIX_0F60
) },
1767 { PREFIX_TABLE (PREFIX_0F61
) },
1768 { PREFIX_TABLE (PREFIX_0F62
) },
1769 { "packsswb", { MX
, EM
} },
1770 { "pcmpgtb", { MX
, EM
} },
1771 { "pcmpgtw", { MX
, EM
} },
1772 { "pcmpgtd", { MX
, EM
} },
1773 { "packuswb", { MX
, EM
} },
1775 { "punpckhbw", { MX
, EM
} },
1776 { "punpckhwd", { MX
, EM
} },
1777 { "punpckhdq", { MX
, EM
} },
1778 { "packssdw", { MX
, EM
} },
1779 { PREFIX_TABLE (PREFIX_0F6C
) },
1780 { PREFIX_TABLE (PREFIX_0F6D
) },
1781 { "movK", { MX
, Edq
} },
1782 { PREFIX_TABLE (PREFIX_0F6F
) },
1784 { PREFIX_TABLE (PREFIX_0F70
) },
1785 { REG_TABLE (REG_0F71
) },
1786 { REG_TABLE (REG_0F72
) },
1787 { REG_TABLE (REG_0F73
) },
1788 { "pcmpeqb", { MX
, EM
} },
1789 { "pcmpeqw", { MX
, EM
} },
1790 { "pcmpeqd", { MX
, EM
} },
1793 { PREFIX_TABLE (PREFIX_0F78
) },
1794 { PREFIX_TABLE (PREFIX_0F79
) },
1795 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
1796 { "(bad)", { XX
} },
1797 { PREFIX_TABLE (PREFIX_0F7C
) },
1798 { PREFIX_TABLE (PREFIX_0F7D
) },
1799 { PREFIX_TABLE (PREFIX_0F7E
) },
1800 { PREFIX_TABLE (PREFIX_0F7F
) },
1802 { "joH", { Jv
, XX
, cond_jump_flag
} },
1803 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
1804 { "jbH", { Jv
, XX
, cond_jump_flag
} },
1805 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
1806 { "jeH", { Jv
, XX
, cond_jump_flag
} },
1807 { "jneH", { Jv
, XX
, cond_jump_flag
} },
1808 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
1809 { "jaH", { Jv
, XX
, cond_jump_flag
} },
1811 { "jsH", { Jv
, XX
, cond_jump_flag
} },
1812 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
1813 { "jpH", { Jv
, XX
, cond_jump_flag
} },
1814 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
1815 { "jlH", { Jv
, XX
, cond_jump_flag
} },
1816 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
1817 { "jleH", { Jv
, XX
, cond_jump_flag
} },
1818 { "jgH", { Jv
, XX
, cond_jump_flag
} },
1821 { "setno", { Eb
} },
1823 { "setae", { Eb
} },
1825 { "setne", { Eb
} },
1826 { "setbe", { Eb
} },
1830 { "setns", { Eb
} },
1832 { "setnp", { Eb
} },
1834 { "setge", { Eb
} },
1835 { "setle", { Eb
} },
1838 { "pushT", { fs
} },
1840 { "cpuid", { XX
} },
1841 { "btS", { Ev
, Gv
} },
1842 { "shldS", { Ev
, Gv
, Ib
} },
1843 { "shldS", { Ev
, Gv
, CL
} },
1844 { REG_TABLE (REG_0FA6
) },
1845 { REG_TABLE (REG_0FA7
) },
1847 { "pushT", { gs
} },
1850 { "btsS", { Ev
, Gv
} },
1851 { "shrdS", { Ev
, Gv
, Ib
} },
1852 { "shrdS", { Ev
, Gv
, CL
} },
1853 { REG_TABLE (REG_0FAE
) },
1854 { "imulS", { Gv
, Ev
} },
1856 { "cmpxchgB", { Eb
, Gb
} },
1857 { "cmpxchgS", { Ev
, Gv
} },
1858 { MOD_TABLE (MOD_0FB2
) },
1859 { "btrS", { Ev
, Gv
} },
1860 { MOD_TABLE (MOD_0FB4
) },
1861 { MOD_TABLE (MOD_0FB5
) },
1862 { "movz{bR|x}", { Gv
, Eb
} },
1863 { "movz{wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
1865 { PREFIX_TABLE (PREFIX_0FB8
) },
1867 { REG_TABLE (REG_0FBA
) },
1868 { "btcS", { Ev
, Gv
} },
1869 { "bsfS", { Gv
, Ev
} },
1870 { PREFIX_TABLE (PREFIX_0FBD
) },
1871 { "movs{bR|x}", { Gv
, Eb
} },
1872 { "movs{wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
1874 { "xaddB", { Eb
, Gb
} },
1875 { "xaddS", { Ev
, Gv
} },
1876 { PREFIX_TABLE (PREFIX_0FC2
) },
1877 { PREFIX_TABLE (PREFIX_0FC3
) },
1878 { "pinsrw", { MX
, Edqw
, Ib
} },
1879 { "pextrw", { Gdq
, MS
, Ib
} },
1880 { "shufpX", { XM
, EXx
, Ib
} },
1881 { REG_TABLE (REG_0FC7
) },
1883 { "bswap", { RMeAX
} },
1884 { "bswap", { RMeCX
} },
1885 { "bswap", { RMeDX
} },
1886 { "bswap", { RMeBX
} },
1887 { "bswap", { RMeSP
} },
1888 { "bswap", { RMeBP
} },
1889 { "bswap", { RMeSI
} },
1890 { "bswap", { RMeDI
} },
1892 { PREFIX_TABLE (PREFIX_0FD0
) },
1893 { "psrlw", { MX
, EM
} },
1894 { "psrld", { MX
, EM
} },
1895 { "psrlq", { MX
, EM
} },
1896 { "paddq", { MX
, EM
} },
1897 { "pmullw", { MX
, EM
} },
1898 { PREFIX_TABLE (PREFIX_0FD6
) },
1899 { MOD_TABLE (MOD_0FD7
) },
1901 { "psubusb", { MX
, EM
} },
1902 { "psubusw", { MX
, EM
} },
1903 { "pminub", { MX
, EM
} },
1904 { "pand", { MX
, EM
} },
1905 { "paddusb", { MX
, EM
} },
1906 { "paddusw", { MX
, EM
} },
1907 { "pmaxub", { MX
, EM
} },
1908 { "pandn", { MX
, EM
} },
1910 { "pavgb", { MX
, EM
} },
1911 { "psraw", { MX
, EM
} },
1912 { "psrad", { MX
, EM
} },
1913 { "pavgw", { MX
, EM
} },
1914 { "pmulhuw", { MX
, EM
} },
1915 { "pmulhw", { MX
, EM
} },
1916 { PREFIX_TABLE (PREFIX_0FE6
) },
1917 { PREFIX_TABLE (PREFIX_0FE7
) },
1919 { "psubsb", { MX
, EM
} },
1920 { "psubsw", { MX
, EM
} },
1921 { "pminsw", { MX
, EM
} },
1922 { "por", { MX
, EM
} },
1923 { "paddsb", { MX
, EM
} },
1924 { "paddsw", { MX
, EM
} },
1925 { "pmaxsw", { MX
, EM
} },
1926 { "pxor", { MX
, EM
} },
1928 { PREFIX_TABLE (PREFIX_0FF0
) },
1929 { "psllw", { MX
, EM
} },
1930 { "pslld", { MX
, EM
} },
1931 { "psllq", { MX
, EM
} },
1932 { "pmuludq", { MX
, EM
} },
1933 { "pmaddwd", { MX
, EM
} },
1934 { "psadbw", { MX
, EM
} },
1935 { PREFIX_TABLE (PREFIX_0FF7
) },
1937 { "psubb", { MX
, EM
} },
1938 { "psubw", { MX
, EM
} },
1939 { "psubd", { MX
, EM
} },
1940 { "psubq", { MX
, EM
} },
1941 { "paddb", { MX
, EM
} },
1942 { "paddw", { MX
, EM
} },
1943 { "paddd", { MX
, EM
} },
1944 { "(bad)", { XX
} },
1947 static const unsigned char onebyte_has_modrm
[256] = {
1948 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1949 /* ------------------------------- */
1950 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1951 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1952 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1953 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1954 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1955 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1956 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1957 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1958 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1959 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1960 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1961 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1962 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1963 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1964 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1965 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1966 /* ------------------------------- */
1967 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1970 static const unsigned char twobyte_has_modrm
[256] = {
1971 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1972 /* ------------------------------- */
1973 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1974 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
1975 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1976 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1977 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1978 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1979 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1980 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1981 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1982 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1983 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1984 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1985 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1986 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1987 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1988 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1989 /* ------------------------------- */
1990 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1993 static char obuf
[100];
1995 static char *mnemonicendp
;
1996 static char scratchbuf
[100];
1997 static unsigned char *start_codep
;
1998 static unsigned char *insn_codep
;
1999 static unsigned char *codep
;
2000 static int last_lock_prefix
;
2001 static int last_repz_prefix
;
2002 static int last_repnz_prefix
;
2003 static int last_data_prefix
;
2004 static int last_addr_prefix
;
2005 static int last_rex_prefix
;
2006 static int last_seg_prefix
;
2007 #define MAX_CODE_LENGTH 15
2008 /* We can up to 14 prefixes since the maximum instruction length is
2010 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
2011 static disassemble_info
*the_info
;
2019 static unsigned char need_modrm
;
2022 int register_specifier
;
2028 static unsigned char need_vex
;
2029 static unsigned char need_vex_reg
;
2030 static unsigned char vex_w_done
;
2038 /* If we are accessing mod/rm/reg without need_modrm set, then the
2039 values are stale. Hitting this abort likely indicates that you
2040 need to update onebyte_has_modrm or twobyte_has_modrm. */
2041 #define MODRM_CHECK if (!need_modrm) abort ()
2043 static const char **names64
;
2044 static const char **names32
;
2045 static const char **names16
;
2046 static const char **names8
;
2047 static const char **names8rex
;
2048 static const char **names_seg
;
2049 static const char *index64
;
2050 static const char *index32
;
2051 static const char **index16
;
2053 static const char *intel_names64
[] = {
2054 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2055 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2057 static const char *intel_names32
[] = {
2058 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2059 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2061 static const char *intel_names16
[] = {
2062 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2063 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2065 static const char *intel_names8
[] = {
2066 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2068 static const char *intel_names8rex
[] = {
2069 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2070 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2072 static const char *intel_names_seg
[] = {
2073 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2075 static const char *intel_index64
= "riz";
2076 static const char *intel_index32
= "eiz";
2077 static const char *intel_index16
[] = {
2078 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2081 static const char *att_names64
[] = {
2082 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2083 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2085 static const char *att_names32
[] = {
2086 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2087 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2089 static const char *att_names16
[] = {
2090 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2091 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2093 static const char *att_names8
[] = {
2094 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2096 static const char *att_names8rex
[] = {
2097 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2098 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2100 static const char *att_names_seg
[] = {
2101 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2103 static const char *att_index64
= "%riz";
2104 static const char *att_index32
= "%eiz";
2105 static const char *att_index16
[] = {
2106 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2109 static const struct dis386 reg_table
[][8] = {
2112 { "addA", { Eb
, Ib
} },
2113 { "orA", { Eb
, Ib
} },
2114 { "adcA", { Eb
, Ib
} },
2115 { "sbbA", { Eb
, Ib
} },
2116 { "andA", { Eb
, Ib
} },
2117 { "subA", { Eb
, Ib
} },
2118 { "xorA", { Eb
, Ib
} },
2119 { "cmpA", { Eb
, Ib
} },
2123 { "addQ", { Ev
, Iv
} },
2124 { "orQ", { Ev
, Iv
} },
2125 { "adcQ", { Ev
, Iv
} },
2126 { "sbbQ", { Ev
, Iv
} },
2127 { "andQ", { Ev
, Iv
} },
2128 { "subQ", { Ev
, Iv
} },
2129 { "xorQ", { Ev
, Iv
} },
2130 { "cmpQ", { Ev
, Iv
} },
2134 { "addQ", { Ev
, sIb
} },
2135 { "orQ", { Ev
, sIb
} },
2136 { "adcQ", { Ev
, sIb
} },
2137 { "sbbQ", { Ev
, sIb
} },
2138 { "andQ", { Ev
, sIb
} },
2139 { "subQ", { Ev
, sIb
} },
2140 { "xorQ", { Ev
, sIb
} },
2141 { "cmpQ", { Ev
, sIb
} },
2145 { "popU", { stackEv
} },
2146 { XOP_8F_TABLE (XOP_09
) },
2147 { "(bad)", { XX
} },
2148 { "(bad)", { XX
} },
2149 { "(bad)", { XX
} },
2150 { XOP_8F_TABLE (XOP_09
) },
2151 { "(bad)", { XX
} },
2152 { "(bad)", { XX
} },
2156 { "rolA", { Eb
, Ib
} },
2157 { "rorA", { Eb
, Ib
} },
2158 { "rclA", { Eb
, Ib
} },
2159 { "rcrA", { Eb
, Ib
} },
2160 { "shlA", { Eb
, Ib
} },
2161 { "shrA", { Eb
, Ib
} },
2162 { "(bad)", { XX
} },
2163 { "sarA", { Eb
, Ib
} },
2167 { "rolQ", { Ev
, Ib
} },
2168 { "rorQ", { Ev
, Ib
} },
2169 { "rclQ", { Ev
, Ib
} },
2170 { "rcrQ", { Ev
, Ib
} },
2171 { "shlQ", { Ev
, Ib
} },
2172 { "shrQ", { Ev
, Ib
} },
2173 { "(bad)", { XX
} },
2174 { "sarQ", { Ev
, Ib
} },
2178 { "movA", { Eb
, Ib
} },
2179 { "(bad)", { XX
} },
2180 { "(bad)", { XX
} },
2181 { "(bad)", { XX
} },
2182 { "(bad)", { XX
} },
2183 { "(bad)", { XX
} },
2184 { "(bad)", { XX
} },
2185 { "(bad)", { XX
} },
2189 { "movQ", { Ev
, Iv
} },
2190 { "(bad)", { XX
} },
2191 { "(bad)", { XX
} },
2192 { "(bad)", { XX
} },
2193 { "(bad)", { XX
} },
2194 { "(bad)", { XX
} },
2195 { "(bad)", { XX
} },
2196 { "(bad)", { XX
} },
2200 { "rolA", { Eb
, I1
} },
2201 { "rorA", { Eb
, I1
} },
2202 { "rclA", { Eb
, I1
} },
2203 { "rcrA", { Eb
, I1
} },
2204 { "shlA", { Eb
, I1
} },
2205 { "shrA", { Eb
, I1
} },
2206 { "(bad)", { XX
} },
2207 { "sarA", { Eb
, I1
} },
2211 { "rolQ", { Ev
, I1
} },
2212 { "rorQ", { Ev
, I1
} },
2213 { "rclQ", { Ev
, I1
} },
2214 { "rcrQ", { Ev
, I1
} },
2215 { "shlQ", { Ev
, I1
} },
2216 { "shrQ", { Ev
, I1
} },
2217 { "(bad)", { XX
} },
2218 { "sarQ", { Ev
, I1
} },
2222 { "rolA", { Eb
, CL
} },
2223 { "rorA", { Eb
, CL
} },
2224 { "rclA", { Eb
, CL
} },
2225 { "rcrA", { Eb
, CL
} },
2226 { "shlA", { Eb
, CL
} },
2227 { "shrA", { Eb
, CL
} },
2228 { "(bad)", { XX
} },
2229 { "sarA", { Eb
, CL
} },
2233 { "rolQ", { Ev
, CL
} },
2234 { "rorQ", { Ev
, CL
} },
2235 { "rclQ", { Ev
, CL
} },
2236 { "rcrQ", { Ev
, CL
} },
2237 { "shlQ", { Ev
, CL
} },
2238 { "shrQ", { Ev
, CL
} },
2239 { "(bad)", { XX
} },
2240 { "sarQ", { Ev
, CL
} },
2244 { "testA", { Eb
, Ib
} },
2245 { "(bad)", { XX
} },
2248 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
2249 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
2250 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
2251 { "idivA", { Eb
} }, /* and idiv for consistency. */
2255 { "testQ", { Ev
, Iv
} },
2256 { "(bad)", { XX
} },
2259 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
2260 { "imulQ", { Ev
} },
2262 { "idivQ", { Ev
} },
2268 { "(bad)", { XX
} },
2269 { "(bad)", { XX
} },
2270 { "(bad)", { XX
} },
2271 { "(bad)", { XX
} },
2272 { "(bad)", { XX
} },
2273 { "(bad)", { XX
} },
2279 { "callT", { indirEv
} },
2280 { "JcallT", { indirEp
} },
2281 { "jmpT", { indirEv
} },
2282 { "JjmpT", { indirEp
} },
2283 { "pushU", { stackEv
} },
2284 { "(bad)", { XX
} },
2288 { "sldtD", { Sv
} },
2294 { "(bad)", { XX
} },
2295 { "(bad)", { XX
} },
2299 { MOD_TABLE (MOD_0F01_REG_0
) },
2300 { MOD_TABLE (MOD_0F01_REG_1
) },
2301 { MOD_TABLE (MOD_0F01_REG_2
) },
2302 { MOD_TABLE (MOD_0F01_REG_3
) },
2303 { "smswD", { Sv
} },
2304 { "(bad)", { XX
} },
2306 { MOD_TABLE (MOD_0F01_REG_7
) },
2310 { "prefetch", { Eb
} },
2311 { "prefetchw", { Eb
} },
2312 { "(bad)", { XX
} },
2313 { "(bad)", { XX
} },
2314 { "(bad)", { XX
} },
2315 { "(bad)", { XX
} },
2316 { "(bad)", { XX
} },
2317 { "(bad)", { XX
} },
2321 { MOD_TABLE (MOD_0F18_REG_0
) },
2322 { MOD_TABLE (MOD_0F18_REG_1
) },
2323 { MOD_TABLE (MOD_0F18_REG_2
) },
2324 { MOD_TABLE (MOD_0F18_REG_3
) },
2325 { "(bad)", { XX
} },
2326 { "(bad)", { XX
} },
2327 { "(bad)", { XX
} },
2328 { "(bad)", { XX
} },
2332 { "(bad)", { XX
} },
2333 { "(bad)", { XX
} },
2334 { MOD_TABLE (MOD_0F71_REG_2
) },
2335 { "(bad)", { XX
} },
2336 { MOD_TABLE (MOD_0F71_REG_4
) },
2337 { "(bad)", { XX
} },
2338 { MOD_TABLE (MOD_0F71_REG_6
) },
2339 { "(bad)", { XX
} },
2343 { "(bad)", { XX
} },
2344 { "(bad)", { XX
} },
2345 { MOD_TABLE (MOD_0F72_REG_2
) },
2346 { "(bad)", { XX
} },
2347 { MOD_TABLE (MOD_0F72_REG_4
) },
2348 { "(bad)", { XX
} },
2349 { MOD_TABLE (MOD_0F72_REG_6
) },
2350 { "(bad)", { XX
} },
2354 { "(bad)", { XX
} },
2355 { "(bad)", { XX
} },
2356 { MOD_TABLE (MOD_0F73_REG_2
) },
2357 { MOD_TABLE (MOD_0F73_REG_3
) },
2358 { "(bad)", { XX
} },
2359 { "(bad)", { XX
} },
2360 { MOD_TABLE (MOD_0F73_REG_6
) },
2361 { MOD_TABLE (MOD_0F73_REG_7
) },
2365 { "montmul", { { OP_0f07
, 0 } } },
2366 { "xsha1", { { OP_0f07
, 0 } } },
2367 { "xsha256", { { OP_0f07
, 0 } } },
2368 { "(bad)", { { OP_0f07
, 0 } } },
2369 { "(bad)", { { OP_0f07
, 0 } } },
2370 { "(bad)", { { OP_0f07
, 0 } } },
2371 { "(bad)", { { OP_0f07
, 0 } } },
2372 { "(bad)", { { OP_0f07
, 0 } } },
2376 { "xstore-rng", { { OP_0f07
, 0 } } },
2377 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
2378 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
2379 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
2380 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
2381 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
2382 { "(bad)", { { OP_0f07
, 0 } } },
2383 { "(bad)", { { OP_0f07
, 0 } } },
2387 { MOD_TABLE (MOD_0FAE_REG_0
) },
2388 { MOD_TABLE (MOD_0FAE_REG_1
) },
2389 { MOD_TABLE (MOD_0FAE_REG_2
) },
2390 { MOD_TABLE (MOD_0FAE_REG_3
) },
2391 { MOD_TABLE (MOD_0FAE_REG_4
) },
2392 { MOD_TABLE (MOD_0FAE_REG_5
) },
2393 { MOD_TABLE (MOD_0FAE_REG_6
) },
2394 { MOD_TABLE (MOD_0FAE_REG_7
) },
2398 { "(bad)", { XX
} },
2399 { "(bad)", { XX
} },
2400 { "(bad)", { XX
} },
2401 { "(bad)", { XX
} },
2402 { "btQ", { Ev
, Ib
} },
2403 { "btsQ", { Ev
, Ib
} },
2404 { "btrQ", { Ev
, Ib
} },
2405 { "btcQ", { Ev
, Ib
} },
2409 { "(bad)", { XX
} },
2410 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
2411 { "(bad)", { XX
} },
2412 { "(bad)", { XX
} },
2413 { "(bad)", { XX
} },
2414 { "(bad)", { XX
} },
2415 { MOD_TABLE (MOD_0FC7_REG_6
) },
2416 { MOD_TABLE (MOD_0FC7_REG_7
) },
2420 { "(bad)", { XX
} },
2421 { "(bad)", { XX
} },
2422 { MOD_TABLE (MOD_VEX_71_REG_2
) },
2423 { "(bad)", { XX
} },
2424 { MOD_TABLE (MOD_VEX_71_REG_4
) },
2425 { "(bad)", { XX
} },
2426 { MOD_TABLE (MOD_VEX_71_REG_6
) },
2427 { "(bad)", { XX
} },
2431 { "(bad)", { XX
} },
2432 { "(bad)", { XX
} },
2433 { MOD_TABLE (MOD_VEX_72_REG_2
) },
2434 { "(bad)", { XX
} },
2435 { MOD_TABLE (MOD_VEX_72_REG_4
) },
2436 { "(bad)", { XX
} },
2437 { MOD_TABLE (MOD_VEX_72_REG_6
) },
2438 { "(bad)", { XX
} },
2442 { "(bad)", { XX
} },
2443 { "(bad)", { XX
} },
2444 { MOD_TABLE (MOD_VEX_73_REG_2
) },
2445 { MOD_TABLE (MOD_VEX_73_REG_3
) },
2446 { "(bad)", { XX
} },
2447 { "(bad)", { XX
} },
2448 { MOD_TABLE (MOD_VEX_73_REG_6
) },
2449 { MOD_TABLE (MOD_VEX_73_REG_7
) },
2453 { "(bad)", { XX
} },
2454 { "(bad)", { XX
} },
2455 { MOD_TABLE (MOD_VEX_AE_REG_2
) },
2456 { MOD_TABLE (MOD_VEX_AE_REG_3
) },
2457 { "(bad)", { XX
} },
2458 { "(bad)", { XX
} },
2459 { "(bad)", { XX
} },
2460 { "(bad)", { XX
} },
2464 { "llwpcb", { { OP_LWPCB_E
, 0 } } },
2465 { "slwpcb", { { OP_LWPCB_E
, 0 } } },
2466 { "(bad)", { XX
} },
2467 { "(bad)", { XX
} },
2468 { "(bad)", { XX
} },
2469 { "(bad)", { XX
} },
2470 { "(bad)", { XX
} },
2471 { "(bad)", { XX
} },
2475 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2476 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, { OP_LWP_I
, 0 } } },
2477 { "(bad)", { XX
} },
2478 { "(bad)", { XX
} },
2479 { "(bad)", { XX
} },
2480 { "(bad)", { XX
} },
2481 { "(bad)", { XX
} },
2482 { "(bad)", { XX
} },
2486 static const struct dis386 prefix_table
[][4] = {
2489 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2490 { "pause", { XX
} },
2491 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
2492 { "(bad)", { XX
} },
2497 { "movups", { XM
, EXx
} },
2498 { "movss", { XM
, EXd
} },
2499 { "movupd", { XM
, EXx
} },
2500 { "movsd", { XM
, EXq
} },
2505 { "movups", { EXxS
, XM
} },
2506 { "movss", { EXdS
, XM
} },
2507 { "movupd", { EXxS
, XM
} },
2508 { "movsd", { EXqS
, XM
} },
2513 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
2514 { "movsldup", { XM
, EXx
} },
2515 { "movlpd", { XM
, EXq
} },
2516 { "movddup", { XM
, EXq
} },
2521 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
2522 { "movshdup", { XM
, EXx
} },
2523 { "movhpd", { XM
, EXq
} },
2524 { "(bad)", { XX
} },
2529 { "cvtpi2ps", { XM
, EMCq
} },
2530 { "cvtsi2ss%LQ", { XM
, Ev
} },
2531 { "cvtpi2pd", { XM
, EMCq
} },
2532 { "cvtsi2sd%LQ", { XM
, Ev
} },
2537 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
2538 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
2539 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
2540 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
2545 { "cvttps2pi", { MXC
, EXq
} },
2546 { "cvttss2siY", { Gv
, EXd
} },
2547 { "cvttpd2pi", { MXC
, EXx
} },
2548 { "cvttsd2siY", { Gv
, EXq
} },
2553 { "cvtps2pi", { MXC
, EXq
} },
2554 { "cvtss2siY", { Gv
, EXd
} },
2555 { "cvtpd2pi", { MXC
, EXx
} },
2556 { "cvtsd2siY", { Gv
, EXq
} },
2561 { "ucomiss",{ XM
, EXd
} },
2562 { "(bad)", { XX
} },
2563 { "ucomisd",{ XM
, EXq
} },
2564 { "(bad)", { XX
} },
2569 { "comiss", { XM
, EXd
} },
2570 { "(bad)", { XX
} },
2571 { "comisd", { XM
, EXq
} },
2572 { "(bad)", { XX
} },
2577 { "sqrtps", { XM
, EXx
} },
2578 { "sqrtss", { XM
, EXd
} },
2579 { "sqrtpd", { XM
, EXx
} },
2580 { "sqrtsd", { XM
, EXq
} },
2585 { "rsqrtps",{ XM
, EXx
} },
2586 { "rsqrtss",{ XM
, EXd
} },
2587 { "(bad)", { XX
} },
2588 { "(bad)", { XX
} },
2593 { "rcpps", { XM
, EXx
} },
2594 { "rcpss", { XM
, EXd
} },
2595 { "(bad)", { XX
} },
2596 { "(bad)", { XX
} },
2601 { "addps", { XM
, EXx
} },
2602 { "addss", { XM
, EXd
} },
2603 { "addpd", { XM
, EXx
} },
2604 { "addsd", { XM
, EXq
} },
2609 { "mulps", { XM
, EXx
} },
2610 { "mulss", { XM
, EXd
} },
2611 { "mulpd", { XM
, EXx
} },
2612 { "mulsd", { XM
, EXq
} },
2617 { "cvtps2pd", { XM
, EXq
} },
2618 { "cvtss2sd", { XM
, EXd
} },
2619 { "cvtpd2ps", { XM
, EXx
} },
2620 { "cvtsd2ss", { XM
, EXq
} },
2625 { "cvtdq2ps", { XM
, EXx
} },
2626 { "cvttps2dq", { XM
, EXx
} },
2627 { "cvtps2dq", { XM
, EXx
} },
2628 { "(bad)", { XX
} },
2633 { "subps", { XM
, EXx
} },
2634 { "subss", { XM
, EXd
} },
2635 { "subpd", { XM
, EXx
} },
2636 { "subsd", { XM
, EXq
} },
2641 { "minps", { XM
, EXx
} },
2642 { "minss", { XM
, EXd
} },
2643 { "minpd", { XM
, EXx
} },
2644 { "minsd", { XM
, EXq
} },
2649 { "divps", { XM
, EXx
} },
2650 { "divss", { XM
, EXd
} },
2651 { "divpd", { XM
, EXx
} },
2652 { "divsd", { XM
, EXq
} },
2657 { "maxps", { XM
, EXx
} },
2658 { "maxss", { XM
, EXd
} },
2659 { "maxpd", { XM
, EXx
} },
2660 { "maxsd", { XM
, EXq
} },
2665 { "punpcklbw",{ MX
, EMd
} },
2666 { "(bad)", { XX
} },
2667 { "punpcklbw",{ MX
, EMx
} },
2668 { "(bad)", { XX
} },
2673 { "punpcklwd",{ MX
, EMd
} },
2674 { "(bad)", { XX
} },
2675 { "punpcklwd",{ MX
, EMx
} },
2676 { "(bad)", { XX
} },
2681 { "punpckldq",{ MX
, EMd
} },
2682 { "(bad)", { XX
} },
2683 { "punpckldq",{ MX
, EMx
} },
2684 { "(bad)", { XX
} },
2689 { "(bad)", { XX
} },
2690 { "(bad)", { XX
} },
2691 { "punpcklqdq", { XM
, EXx
} },
2692 { "(bad)", { XX
} },
2697 { "(bad)", { XX
} },
2698 { "(bad)", { XX
} },
2699 { "punpckhqdq", { XM
, EXx
} },
2700 { "(bad)", { XX
} },
2705 { "movq", { MX
, EM
} },
2706 { "movdqu", { XM
, EXx
} },
2707 { "movdqa", { XM
, EXx
} },
2708 { "(bad)", { XX
} },
2713 { "pshufw", { MX
, EM
, Ib
} },
2714 { "pshufhw",{ XM
, EXx
, Ib
} },
2715 { "pshufd", { XM
, EXx
, Ib
} },
2716 { "pshuflw",{ XM
, EXx
, Ib
} },
2719 /* PREFIX_0F73_REG_3 */
2721 { "(bad)", { XX
} },
2722 { "(bad)", { XX
} },
2723 { "psrldq", { XS
, Ib
} },
2724 { "(bad)", { XX
} },
2727 /* PREFIX_0F73_REG_7 */
2729 { "(bad)", { XX
} },
2730 { "(bad)", { XX
} },
2731 { "pslldq", { XS
, Ib
} },
2732 { "(bad)", { XX
} },
2737 {"vmread", { Em
, Gm
} },
2739 {"extrq", { XS
, Ib
, Ib
} },
2740 {"insertq", { XM
, XS
, Ib
, Ib
} },
2745 {"vmwrite", { Gm
, Em
} },
2747 {"extrq", { XM
, XS
} },
2748 {"insertq", { XM
, XS
} },
2753 { "(bad)", { XX
} },
2754 { "(bad)", { XX
} },
2755 { "haddpd", { XM
, EXx
} },
2756 { "haddps", { XM
, EXx
} },
2761 { "(bad)", { XX
} },
2762 { "(bad)", { XX
} },
2763 { "hsubpd", { XM
, EXx
} },
2764 { "hsubps", { XM
, EXx
} },
2769 { "movK", { Edq
, MX
} },
2770 { "movq", { XM
, EXq
} },
2771 { "movK", { Edq
, XM
} },
2772 { "(bad)", { XX
} },
2777 { "movq", { EMS
, MX
} },
2778 { "movdqu", { EXxS
, XM
} },
2779 { "movdqa", { EXxS
, XM
} },
2780 { "(bad)", { XX
} },
2785 { "(bad)", { XX
} },
2786 { "popcntS", { Gv
, Ev
} },
2787 { "(bad)", { XX
} },
2788 { "(bad)", { XX
} },
2793 { "bsrS", { Gv
, Ev
} },
2794 { "lzcntS", { Gv
, Ev
} },
2795 { "bsrS", { Gv
, Ev
} },
2796 { "(bad)", { XX
} },
2801 { "cmpps", { XM
, EXx
, CMP
} },
2802 { "cmpss", { XM
, EXd
, CMP
} },
2803 { "cmppd", { XM
, EXx
, CMP
} },
2804 { "cmpsd", { XM
, EXq
, CMP
} },
2809 { "movntiS", { Ma
, Gv
} },
2810 { "(bad)", { XX
} },
2811 { "(bad)", { XX
} },
2812 { "(bad)", { XX
} },
2815 /* PREFIX_0FC7_REG_6 */
2817 { "vmptrld",{ Mq
} },
2818 { "vmxon", { Mq
} },
2819 { "vmclear",{ Mq
} },
2820 { "(bad)", { XX
} },
2825 { "(bad)", { XX
} },
2826 { "(bad)", { XX
} },
2827 { "addsubpd", { XM
, EXx
} },
2828 { "addsubps", { XM
, EXx
} },
2833 { "(bad)", { XX
} },
2834 { "movq2dq",{ XM
, MS
} },
2835 { "movq", { EXqS
, XM
} },
2836 { "movdq2q",{ MX
, XS
} },
2841 { "(bad)", { XX
} },
2842 { "cvtdq2pd", { XM
, EXq
} },
2843 { "cvttpd2dq", { XM
, EXx
} },
2844 { "cvtpd2dq", { XM
, EXx
} },
2849 { "movntq", { Mq
, MX
} },
2850 { "(bad)", { XX
} },
2851 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
2852 { "(bad)", { XX
} },
2857 { "(bad)", { XX
} },
2858 { "(bad)", { XX
} },
2859 { "(bad)", { XX
} },
2860 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
2865 { "maskmovq", { MX
, MS
} },
2866 { "(bad)", { XX
} },
2867 { "maskmovdqu", { XM
, XS
} },
2868 { "(bad)", { XX
} },
2873 { "(bad)", { XX
} },
2874 { "(bad)", { XX
} },
2875 { "pblendvb", { XM
, EXx
, XMM0
} },
2876 { "(bad)", { XX
} },
2881 { "(bad)", { XX
} },
2882 { "(bad)", { XX
} },
2883 { "blendvps", { XM
, EXx
, XMM0
} },
2884 { "(bad)", { XX
} },
2889 { "(bad)", { XX
} },
2890 { "(bad)", { XX
} },
2891 { "blendvpd", { XM
, EXx
, XMM0
} },
2892 { "(bad)", { XX
} },
2897 { "(bad)", { XX
} },
2898 { "(bad)", { XX
} },
2899 { "ptest", { XM
, EXx
} },
2900 { "(bad)", { XX
} },
2905 { "(bad)", { XX
} },
2906 { "(bad)", { XX
} },
2907 { "pmovsxbw", { XM
, EXq
} },
2908 { "(bad)", { XX
} },
2913 { "(bad)", { XX
} },
2914 { "(bad)", { XX
} },
2915 { "pmovsxbd", { XM
, EXd
} },
2916 { "(bad)", { XX
} },
2921 { "(bad)", { XX
} },
2922 { "(bad)", { XX
} },
2923 { "pmovsxbq", { XM
, EXw
} },
2924 { "(bad)", { XX
} },
2929 { "(bad)", { XX
} },
2930 { "(bad)", { XX
} },
2931 { "pmovsxwd", { XM
, EXq
} },
2932 { "(bad)", { XX
} },
2937 { "(bad)", { XX
} },
2938 { "(bad)", { XX
} },
2939 { "pmovsxwq", { XM
, EXd
} },
2940 { "(bad)", { XX
} },
2945 { "(bad)", { XX
} },
2946 { "(bad)", { XX
} },
2947 { "pmovsxdq", { XM
, EXq
} },
2948 { "(bad)", { XX
} },
2953 { "(bad)", { XX
} },
2954 { "(bad)", { XX
} },
2955 { "pmuldq", { XM
, EXx
} },
2956 { "(bad)", { XX
} },
2961 { "(bad)", { XX
} },
2962 { "(bad)", { XX
} },
2963 { "pcmpeqq", { XM
, EXx
} },
2964 { "(bad)", { XX
} },
2969 { "(bad)", { XX
} },
2970 { "(bad)", { XX
} },
2971 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
2972 { "(bad)", { XX
} },
2977 { "(bad)", { XX
} },
2978 { "(bad)", { XX
} },
2979 { "packusdw", { XM
, EXx
} },
2980 { "(bad)", { XX
} },
2985 { "(bad)", { XX
} },
2986 { "(bad)", { XX
} },
2987 { "pmovzxbw", { XM
, EXq
} },
2988 { "(bad)", { XX
} },
2993 { "(bad)", { XX
} },
2994 { "(bad)", { XX
} },
2995 { "pmovzxbd", { XM
, EXd
} },
2996 { "(bad)", { XX
} },
3001 { "(bad)", { XX
} },
3002 { "(bad)", { XX
} },
3003 { "pmovzxbq", { XM
, EXw
} },
3004 { "(bad)", { XX
} },
3009 { "(bad)", { XX
} },
3010 { "(bad)", { XX
} },
3011 { "pmovzxwd", { XM
, EXq
} },
3012 { "(bad)", { XX
} },
3017 { "(bad)", { XX
} },
3018 { "(bad)", { XX
} },
3019 { "pmovzxwq", { XM
, EXd
} },
3020 { "(bad)", { XX
} },
3025 { "(bad)", { XX
} },
3026 { "(bad)", { XX
} },
3027 { "pmovzxdq", { XM
, EXq
} },
3028 { "(bad)", { XX
} },
3033 { "(bad)", { XX
} },
3034 { "(bad)", { XX
} },
3035 { "pcmpgtq", { XM
, EXx
} },
3036 { "(bad)", { XX
} },
3041 { "(bad)", { XX
} },
3042 { "(bad)", { XX
} },
3043 { "pminsb", { XM
, EXx
} },
3044 { "(bad)", { XX
} },
3049 { "(bad)", { XX
} },
3050 { "(bad)", { XX
} },
3051 { "pminsd", { XM
, EXx
} },
3052 { "(bad)", { XX
} },
3057 { "(bad)", { XX
} },
3058 { "(bad)", { XX
} },
3059 { "pminuw", { XM
, EXx
} },
3060 { "(bad)", { XX
} },
3065 { "(bad)", { XX
} },
3066 { "(bad)", { XX
} },
3067 { "pminud", { XM
, EXx
} },
3068 { "(bad)", { XX
} },
3073 { "(bad)", { XX
} },
3074 { "(bad)", { XX
} },
3075 { "pmaxsb", { XM
, EXx
} },
3076 { "(bad)", { XX
} },
3081 { "(bad)", { XX
} },
3082 { "(bad)", { XX
} },
3083 { "pmaxsd", { XM
, EXx
} },
3084 { "(bad)", { XX
} },
3089 { "(bad)", { XX
} },
3090 { "(bad)", { XX
} },
3091 { "pmaxuw", { XM
, EXx
} },
3092 { "(bad)", { XX
} },
3097 { "(bad)", { XX
} },
3098 { "(bad)", { XX
} },
3099 { "pmaxud", { XM
, EXx
} },
3100 { "(bad)", { XX
} },
3105 { "(bad)", { XX
} },
3106 { "(bad)", { XX
} },
3107 { "pmulld", { XM
, EXx
} },
3108 { "(bad)", { XX
} },
3113 { "(bad)", { XX
} },
3114 { "(bad)", { XX
} },
3115 { "phminposuw", { XM
, EXx
} },
3116 { "(bad)", { XX
} },
3121 { "(bad)", { XX
} },
3122 { "(bad)", { XX
} },
3123 { "invept", { Gm
, Mo
} },
3124 { "(bad)", { XX
} },
3129 { "(bad)", { XX
} },
3130 { "(bad)", { XX
} },
3131 { "invvpid", { Gm
, Mo
} },
3132 { "(bad)", { XX
} },
3137 { "(bad)", { XX
} },
3138 { "(bad)", { XX
} },
3139 { "aesimc", { XM
, EXx
} },
3140 { "(bad)", { XX
} },
3145 { "(bad)", { XX
} },
3146 { "(bad)", { XX
} },
3147 { "aesenc", { XM
, EXx
} },
3148 { "(bad)", { XX
} },
3153 { "(bad)", { XX
} },
3154 { "(bad)", { XX
} },
3155 { "aesenclast", { XM
, EXx
} },
3156 { "(bad)", { XX
} },
3161 { "(bad)", { XX
} },
3162 { "(bad)", { XX
} },
3163 { "aesdec", { XM
, EXx
} },
3164 { "(bad)", { XX
} },
3169 { "(bad)", { XX
} },
3170 { "(bad)", { XX
} },
3171 { "aesdeclast", { XM
, EXx
} },
3172 { "(bad)", { XX
} },
3177 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3178 { "(bad)", { XX
} },
3179 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} } },
3180 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
3185 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3186 { "(bad)", { XX
} },
3187 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
} },
3188 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
3193 { "(bad)", { XX
} },
3194 { "(bad)", { XX
} },
3195 { "roundps", { XM
, EXx
, Ib
} },
3196 { "(bad)", { XX
} },
3201 { "(bad)", { XX
} },
3202 { "(bad)", { XX
} },
3203 { "roundpd", { XM
, EXx
, Ib
} },
3204 { "(bad)", { XX
} },
3209 { "(bad)", { XX
} },
3210 { "(bad)", { XX
} },
3211 { "roundss", { XM
, EXd
, Ib
} },
3212 { "(bad)", { XX
} },
3217 { "(bad)", { XX
} },
3218 { "(bad)", { XX
} },
3219 { "roundsd", { XM
, EXq
, Ib
} },
3220 { "(bad)", { XX
} },
3225 { "(bad)", { XX
} },
3226 { "(bad)", { XX
} },
3227 { "blendps", { XM
, EXx
, Ib
} },
3228 { "(bad)", { XX
} },
3233 { "(bad)", { XX
} },
3234 { "(bad)", { XX
} },
3235 { "blendpd", { XM
, EXx
, Ib
} },
3236 { "(bad)", { XX
} },
3241 { "(bad)", { XX
} },
3242 { "(bad)", { XX
} },
3243 { "pblendw", { XM
, EXx
, Ib
} },
3244 { "(bad)", { XX
} },
3249 { "(bad)", { XX
} },
3250 { "(bad)", { XX
} },
3251 { "pextrb", { Edqb
, XM
, Ib
} },
3252 { "(bad)", { XX
} },
3257 { "(bad)", { XX
} },
3258 { "(bad)", { XX
} },
3259 { "pextrw", { Edqw
, XM
, Ib
} },
3260 { "(bad)", { XX
} },
3265 { "(bad)", { XX
} },
3266 { "(bad)", { XX
} },
3267 { "pextrK", { Edq
, XM
, Ib
} },
3268 { "(bad)", { XX
} },
3273 { "(bad)", { XX
} },
3274 { "(bad)", { XX
} },
3275 { "extractps", { Edqd
, XM
, Ib
} },
3276 { "(bad)", { XX
} },
3281 { "(bad)", { XX
} },
3282 { "(bad)", { XX
} },
3283 { "pinsrb", { XM
, Edqb
, Ib
} },
3284 { "(bad)", { XX
} },
3289 { "(bad)", { XX
} },
3290 { "(bad)", { XX
} },
3291 { "insertps", { XM
, EXd
, Ib
} },
3292 { "(bad)", { XX
} },
3297 { "(bad)", { XX
} },
3298 { "(bad)", { XX
} },
3299 { "pinsrK", { XM
, Edq
, Ib
} },
3300 { "(bad)", { XX
} },
3305 { "(bad)", { XX
} },
3306 { "(bad)", { XX
} },
3307 { "dpps", { XM
, EXx
, Ib
} },
3308 { "(bad)", { XX
} },
3313 { "(bad)", { XX
} },
3314 { "(bad)", { XX
} },
3315 { "dppd", { XM
, EXx
, Ib
} },
3316 { "(bad)", { XX
} },
3321 { "(bad)", { XX
} },
3322 { "(bad)", { XX
} },
3323 { "mpsadbw", { XM
, EXx
, Ib
} },
3324 { "(bad)", { XX
} },
3329 { "(bad)", { XX
} },
3330 { "(bad)", { XX
} },
3331 { "pclmulqdq", { XM
, EXx
, PCLMUL
} },
3332 { "(bad)", { XX
} },
3337 { "(bad)", { XX
} },
3338 { "(bad)", { XX
} },
3339 { "pcmpestrm", { XM
, EXx
, Ib
} },
3340 { "(bad)", { XX
} },
3345 { "(bad)", { XX
} },
3346 { "(bad)", { XX
} },
3347 { "pcmpestri", { XM
, EXx
, Ib
} },
3348 { "(bad)", { XX
} },
3353 { "(bad)", { XX
} },
3354 { "(bad)", { XX
} },
3355 { "pcmpistrm", { XM
, EXx
, Ib
} },
3356 { "(bad)", { XX
} },
3361 { "(bad)", { XX
} },
3362 { "(bad)", { XX
} },
3363 { "pcmpistri", { XM
, EXx
, Ib
} },
3364 { "(bad)", { XX
} },
3369 { "(bad)", { XX
} },
3370 { "(bad)", { XX
} },
3371 { "aeskeygenassist", { XM
, EXx
, Ib
} },
3372 { "(bad)", { XX
} },
3377 { "vmovups", { XM
, EXx
} },
3378 { VEX_LEN_TABLE (VEX_LEN_10_P_1
) },
3379 { "vmovupd", { XM
, EXx
} },
3380 { VEX_LEN_TABLE (VEX_LEN_10_P_3
) },
3385 { "vmovups", { EXxS
, XM
} },
3386 { VEX_LEN_TABLE (VEX_LEN_11_P_1
) },
3387 { "vmovupd", { EXxS
, XM
} },
3388 { VEX_LEN_TABLE (VEX_LEN_11_P_3
) },
3393 { MOD_TABLE (MOD_VEX_12_PREFIX_0
) },
3394 { "vmovsldup", { XM
, EXx
} },
3395 { VEX_LEN_TABLE (VEX_LEN_12_P_2
) },
3396 { "vmovddup", { XM
, EXymmq
} },
3401 { MOD_TABLE (MOD_VEX_16_PREFIX_0
) },
3402 { "vmovshdup", { XM
, EXx
} },
3403 { VEX_LEN_TABLE (VEX_LEN_16_P_2
) },
3404 { "(bad)", { XX
} },
3409 { "(bad)", { XX
} },
3410 { VEX_LEN_TABLE (VEX_LEN_2A_P_1
) },
3411 { "(bad)", { XX
} },
3412 { VEX_LEN_TABLE (VEX_LEN_2A_P_3
) },
3417 { "(bad)", { XX
} },
3418 { VEX_LEN_TABLE (VEX_LEN_2C_P_1
) },
3419 { "(bad)", { XX
} },
3420 { VEX_LEN_TABLE (VEX_LEN_2C_P_3
) },
3425 { "(bad)", { XX
} },
3426 { VEX_LEN_TABLE (VEX_LEN_2D_P_1
) },
3427 { "(bad)", { XX
} },
3428 { VEX_LEN_TABLE (VEX_LEN_2D_P_3
) },
3433 { VEX_LEN_TABLE (VEX_LEN_2E_P_0
) },
3434 { "(bad)", { XX
} },
3435 { VEX_LEN_TABLE (VEX_LEN_2E_P_2
) },
3436 { "(bad)", { XX
} },
3441 { VEX_LEN_TABLE (VEX_LEN_2F_P_0
) },
3442 { "(bad)", { XX
} },
3443 { VEX_LEN_TABLE (VEX_LEN_2F_P_2
) },
3444 { "(bad)", { XX
} },
3449 { "vsqrtps", { XM
, EXx
} },
3450 { VEX_LEN_TABLE (VEX_LEN_51_P_1
) },
3451 { "vsqrtpd", { XM
, EXx
} },
3452 { VEX_LEN_TABLE (VEX_LEN_51_P_3
) },
3457 { "vrsqrtps", { XM
, EXx
} },
3458 { VEX_LEN_TABLE (VEX_LEN_52_P_1
) },
3459 { "(bad)", { XX
} },
3460 { "(bad)", { XX
} },
3465 { "vrcpps", { XM
, EXx
} },
3466 { VEX_LEN_TABLE (VEX_LEN_53_P_1
) },
3467 { "(bad)", { XX
} },
3468 { "(bad)", { XX
} },
3473 { "vaddps", { XM
, Vex
, EXx
} },
3474 { VEX_LEN_TABLE (VEX_LEN_58_P_1
) },
3475 { "vaddpd", { XM
, Vex
, EXx
} },
3476 { VEX_LEN_TABLE (VEX_LEN_58_P_3
) },
3481 { "vmulps", { XM
, Vex
, EXx
} },
3482 { VEX_LEN_TABLE (VEX_LEN_59_P_1
) },
3483 { "vmulpd", { XM
, Vex
, EXx
} },
3484 { VEX_LEN_TABLE (VEX_LEN_59_P_3
) },
3489 { "vcvtps2pd", { XM
, EXxmmq
} },
3490 { VEX_LEN_TABLE (VEX_LEN_5A_P_1
) },
3491 { "vcvtpd2ps%XY", { XMM
, EXx
} },
3492 { VEX_LEN_TABLE (VEX_LEN_5A_P_3
) },
3497 { "vcvtdq2ps", { XM
, EXx
} },
3498 { "vcvttps2dq", { XM
, EXx
} },
3499 { "vcvtps2dq", { XM
, EXx
} },
3500 { "(bad)", { XX
} },
3505 { "vsubps", { XM
, Vex
, EXx
} },
3506 { VEX_LEN_TABLE (VEX_LEN_5C_P_1
) },
3507 { "vsubpd", { XM
, Vex
, EXx
} },
3508 { VEX_LEN_TABLE (VEX_LEN_5C_P_3
) },
3513 { "vminps", { XM
, Vex
, EXx
} },
3514 { VEX_LEN_TABLE (VEX_LEN_5D_P_1
) },
3515 { "vminpd", { XM
, Vex
, EXx
} },
3516 { VEX_LEN_TABLE (VEX_LEN_5D_P_3
) },
3521 { "vdivps", { XM
, Vex
, EXx
} },
3522 { VEX_LEN_TABLE (VEX_LEN_5E_P_1
) },
3523 { "vdivpd", { XM
, Vex
, EXx
} },
3524 { VEX_LEN_TABLE (VEX_LEN_5E_P_3
) },
3529 { "vmaxps", { XM
, Vex
, EXx
} },
3530 { VEX_LEN_TABLE (VEX_LEN_5F_P_1
) },
3531 { "vmaxpd", { XM
, Vex
, EXx
} },
3532 { VEX_LEN_TABLE (VEX_LEN_5F_P_3
) },
3537 { "(bad)", { XX
} },
3538 { "(bad)", { XX
} },
3539 { VEX_LEN_TABLE (VEX_LEN_60_P_2
) },
3540 { "(bad)", { XX
} },
3545 { "(bad)", { XX
} },
3546 { "(bad)", { XX
} },
3547 { VEX_LEN_TABLE (VEX_LEN_61_P_2
) },
3548 { "(bad)", { XX
} },
3553 { "(bad)", { XX
} },
3554 { "(bad)", { XX
} },
3555 { VEX_LEN_TABLE (VEX_LEN_62_P_2
) },
3556 { "(bad)", { XX
} },
3561 { "(bad)", { XX
} },
3562 { "(bad)", { XX
} },
3563 { VEX_LEN_TABLE (VEX_LEN_63_P_2
) },
3564 { "(bad)", { XX
} },
3569 { "(bad)", { XX
} },
3570 { "(bad)", { XX
} },
3571 { VEX_LEN_TABLE (VEX_LEN_64_P_2
) },
3572 { "(bad)", { XX
} },
3577 { "(bad)", { XX
} },
3578 { "(bad)", { XX
} },
3579 { VEX_LEN_TABLE (VEX_LEN_65_P_2
) },
3580 { "(bad)", { XX
} },
3585 { "(bad)", { XX
} },
3586 { "(bad)", { XX
} },
3587 { VEX_LEN_TABLE (VEX_LEN_66_P_2
) },
3588 { "(bad)", { XX
} },
3593 { "(bad)", { XX
} },
3594 { "(bad)", { XX
} },
3595 { VEX_LEN_TABLE (VEX_LEN_67_P_2
) },
3596 { "(bad)", { XX
} },
3601 { "(bad)", { XX
} },
3602 { "(bad)", { XX
} },
3603 { VEX_LEN_TABLE (VEX_LEN_68_P_2
) },
3604 { "(bad)", { XX
} },
3609 { "(bad)", { XX
} },
3610 { "(bad)", { XX
} },
3611 { VEX_LEN_TABLE (VEX_LEN_69_P_2
) },
3612 { "(bad)", { XX
} },
3617 { "(bad)", { XX
} },
3618 { "(bad)", { XX
} },
3619 { VEX_LEN_TABLE (VEX_LEN_6A_P_2
) },
3620 { "(bad)", { XX
} },
3625 { "(bad)", { XX
} },
3626 { "(bad)", { XX
} },
3627 { VEX_LEN_TABLE (VEX_LEN_6B_P_2
) },
3628 { "(bad)", { XX
} },
3633 { "(bad)", { XX
} },
3634 { "(bad)", { XX
} },
3635 { VEX_LEN_TABLE (VEX_LEN_6C_P_2
) },
3636 { "(bad)", { XX
} },
3641 { "(bad)", { XX
} },
3642 { "(bad)", { XX
} },
3643 { VEX_LEN_TABLE (VEX_LEN_6D_P_2
) },
3644 { "(bad)", { XX
} },
3649 { "(bad)", { XX
} },
3650 { "(bad)", { XX
} },
3651 { VEX_LEN_TABLE (VEX_LEN_6E_P_2
) },
3652 { "(bad)", { XX
} },
3657 { "(bad)", { XX
} },
3658 { "vmovdqu", { XM
, EXx
} },
3659 { "vmovdqa", { XM
, EXx
} },
3660 { "(bad)", { XX
} },
3665 { "(bad)", { XX
} },
3666 { VEX_LEN_TABLE (VEX_LEN_70_P_1
) },
3667 { VEX_LEN_TABLE (VEX_LEN_70_P_2
) },
3668 { VEX_LEN_TABLE (VEX_LEN_70_P_3
) },
3671 /* PREFIX_VEX_71_REG_2 */
3673 { "(bad)", { XX
} },
3674 { "(bad)", { XX
} },
3675 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2
) },
3676 { "(bad)", { XX
} },
3679 /* PREFIX_VEX_71_REG_4 */
3681 { "(bad)", { XX
} },
3682 { "(bad)", { XX
} },
3683 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2
) },
3684 { "(bad)", { XX
} },
3687 /* PREFIX_VEX_71_REG_6 */
3689 { "(bad)", { XX
} },
3690 { "(bad)", { XX
} },
3691 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2
) },
3692 { "(bad)", { XX
} },
3695 /* PREFIX_VEX_72_REG_2 */
3697 { "(bad)", { XX
} },
3698 { "(bad)", { XX
} },
3699 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2
) },
3700 { "(bad)", { XX
} },
3703 /* PREFIX_VEX_72_REG_4 */
3705 { "(bad)", { XX
} },
3706 { "(bad)", { XX
} },
3707 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2
) },
3708 { "(bad)", { XX
} },
3711 /* PREFIX_VEX_72_REG_6 */
3713 { "(bad)", { XX
} },
3714 { "(bad)", { XX
} },
3715 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2
) },
3716 { "(bad)", { XX
} },
3719 /* PREFIX_VEX_73_REG_2 */
3721 { "(bad)", { XX
} },
3722 { "(bad)", { XX
} },
3723 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2
) },
3724 { "(bad)", { XX
} },
3727 /* PREFIX_VEX_73_REG_3 */
3729 { "(bad)", { XX
} },
3730 { "(bad)", { XX
} },
3731 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2
) },
3732 { "(bad)", { XX
} },
3735 /* PREFIX_VEX_73_REG_6 */
3737 { "(bad)", { XX
} },
3738 { "(bad)", { XX
} },
3739 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2
) },
3740 { "(bad)", { XX
} },
3743 /* PREFIX_VEX_73_REG_7 */
3745 { "(bad)", { XX
} },
3746 { "(bad)", { XX
} },
3747 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2
) },
3748 { "(bad)", { XX
} },
3753 { "(bad)", { XX
} },
3754 { "(bad)", { XX
} },
3755 { VEX_LEN_TABLE (VEX_LEN_74_P_2
) },
3756 { "(bad)", { XX
} },
3761 { "(bad)", { XX
} },
3762 { "(bad)", { XX
} },
3763 { VEX_LEN_TABLE (VEX_LEN_75_P_2
) },
3764 { "(bad)", { XX
} },
3769 { "(bad)", { XX
} },
3770 { "(bad)", { XX
} },
3771 { VEX_LEN_TABLE (VEX_LEN_76_P_2
) },
3772 { "(bad)", { XX
} },
3778 { "(bad)", { XX
} },
3779 { "(bad)", { XX
} },
3780 { "(bad)", { XX
} },
3785 { "(bad)", { XX
} },
3786 { "(bad)", { XX
} },
3787 { "vhaddpd", { XM
, Vex
, EXx
} },
3788 { "vhaddps", { XM
, Vex
, EXx
} },
3793 { "(bad)", { XX
} },
3794 { "(bad)", { XX
} },
3795 { "vhsubpd", { XM
, Vex
, EXx
} },
3796 { "vhsubps", { XM
, Vex
, EXx
} },
3801 { "(bad)", { XX
} },
3802 { VEX_LEN_TABLE (VEX_LEN_7E_P_1
) },
3803 { VEX_LEN_TABLE (VEX_LEN_7E_P_2
) },
3804 { "(bad)", { XX
} },
3809 { "(bad)", { XX
} },
3810 { "vmovdqu", { EXxS
, XM
} },
3811 { "vmovdqa", { EXxS
, XM
} },
3812 { "(bad)", { XX
} },
3817 { "vcmpps", { XM
, Vex
, EXx
, VCMP
} },
3818 { VEX_LEN_TABLE (VEX_LEN_C2_P_1
) },
3819 { "vcmppd", { XM
, Vex
, EXx
, VCMP
} },
3820 { VEX_LEN_TABLE (VEX_LEN_C2_P_3
) },
3825 { "(bad)", { XX
} },
3826 { "(bad)", { XX
} },
3827 { VEX_LEN_TABLE (VEX_LEN_C4_P_2
) },
3828 { "(bad)", { XX
} },
3833 { "(bad)", { XX
} },
3834 { "(bad)", { XX
} },
3835 { VEX_LEN_TABLE (VEX_LEN_C5_P_2
) },
3836 { "(bad)", { XX
} },
3841 { "(bad)", { XX
} },
3842 { "(bad)", { XX
} },
3843 { "vaddsubpd", { XM
, Vex
, EXx
} },
3844 { "vaddsubps", { XM
, Vex
, EXx
} },
3849 { "(bad)", { XX
} },
3850 { "(bad)", { XX
} },
3851 { VEX_LEN_TABLE (VEX_LEN_D1_P_2
) },
3852 { "(bad)", { XX
} },
3857 { "(bad)", { XX
} },
3858 { "(bad)", { XX
} },
3859 { VEX_LEN_TABLE (VEX_LEN_D2_P_2
) },
3860 { "(bad)", { XX
} },
3865 { "(bad)", { XX
} },
3866 { "(bad)", { XX
} },
3867 { VEX_LEN_TABLE (VEX_LEN_D3_P_2
) },
3868 { "(bad)", { XX
} },
3873 { "(bad)", { XX
} },
3874 { "(bad)", { XX
} },
3875 { VEX_LEN_TABLE (VEX_LEN_D4_P_2
) },
3876 { "(bad)", { XX
} },
3881 { "(bad)", { XX
} },
3882 { "(bad)", { XX
} },
3883 { VEX_LEN_TABLE (VEX_LEN_D5_P_2
) },
3884 { "(bad)", { XX
} },
3889 { "(bad)", { XX
} },
3890 { "(bad)", { XX
} },
3891 { VEX_LEN_TABLE (VEX_LEN_D6_P_2
) },
3892 { "(bad)", { XX
} },
3897 { "(bad)", { XX
} },
3898 { "(bad)", { XX
} },
3899 { MOD_TABLE (MOD_VEX_D7_PREFIX_2
) },
3900 { "(bad)", { XX
} },
3905 { "(bad)", { XX
} },
3906 { "(bad)", { XX
} },
3907 { VEX_LEN_TABLE (VEX_LEN_D8_P_2
) },
3908 { "(bad)", { XX
} },
3913 { "(bad)", { XX
} },
3914 { "(bad)", { XX
} },
3915 { VEX_LEN_TABLE (VEX_LEN_D9_P_2
) },
3916 { "(bad)", { XX
} },
3921 { "(bad)", { XX
} },
3922 { "(bad)", { XX
} },
3923 { VEX_LEN_TABLE (VEX_LEN_DA_P_2
) },
3924 { "(bad)", { XX
} },
3929 { "(bad)", { XX
} },
3930 { "(bad)", { XX
} },
3931 { VEX_LEN_TABLE (VEX_LEN_DB_P_2
) },
3932 { "(bad)", { XX
} },
3937 { "(bad)", { XX
} },
3938 { "(bad)", { XX
} },
3939 { VEX_LEN_TABLE (VEX_LEN_DC_P_2
) },
3940 { "(bad)", { XX
} },
3945 { "(bad)", { XX
} },
3946 { "(bad)", { XX
} },
3947 { VEX_LEN_TABLE (VEX_LEN_DD_P_2
) },
3948 { "(bad)", { XX
} },
3953 { "(bad)", { XX
} },
3954 { "(bad)", { XX
} },
3955 { VEX_LEN_TABLE (VEX_LEN_DE_P_2
) },
3956 { "(bad)", { XX
} },
3961 { "(bad)", { XX
} },
3962 { "(bad)", { XX
} },
3963 { VEX_LEN_TABLE (VEX_LEN_DF_P_2
) },
3964 { "(bad)", { XX
} },
3969 { "(bad)", { XX
} },
3970 { "(bad)", { XX
} },
3971 { VEX_LEN_TABLE (VEX_LEN_E0_P_2
) },
3972 { "(bad)", { XX
} },
3977 { "(bad)", { XX
} },
3978 { "(bad)", { XX
} },
3979 { VEX_LEN_TABLE (VEX_LEN_E1_P_2
) },
3980 { "(bad)", { XX
} },
3985 { "(bad)", { XX
} },
3986 { "(bad)", { XX
} },
3987 { VEX_LEN_TABLE (VEX_LEN_E2_P_2
) },
3988 { "(bad)", { XX
} },
3993 { "(bad)", { XX
} },
3994 { "(bad)", { XX
} },
3995 { VEX_LEN_TABLE (VEX_LEN_E3_P_2
) },
3996 { "(bad)", { XX
} },
4001 { "(bad)", { XX
} },
4002 { "(bad)", { XX
} },
4003 { VEX_LEN_TABLE (VEX_LEN_E4_P_2
) },
4004 { "(bad)", { XX
} },
4009 { "(bad)", { XX
} },
4010 { "(bad)", { XX
} },
4011 { VEX_LEN_TABLE (VEX_LEN_E5_P_2
) },
4012 { "(bad)", { XX
} },
4017 { "(bad)", { XX
} },
4018 { "vcvtdq2pd", { XM
, EXxmmq
} },
4019 { "vcvttpd2dq%XY", { XMM
, EXx
} },
4020 { "vcvtpd2dq%XY", { XMM
, EXx
} },
4025 { "(bad)", { XX
} },
4026 { "(bad)", { XX
} },
4027 { MOD_TABLE (MOD_VEX_E7_PREFIX_2
) },
4028 { "(bad)", { XX
} },
4033 { "(bad)", { XX
} },
4034 { "(bad)", { XX
} },
4035 { VEX_LEN_TABLE (VEX_LEN_E8_P_2
) },
4036 { "(bad)", { XX
} },
4041 { "(bad)", { XX
} },
4042 { "(bad)", { XX
} },
4043 { VEX_LEN_TABLE (VEX_LEN_E9_P_2
) },
4044 { "(bad)", { XX
} },
4049 { "(bad)", { XX
} },
4050 { "(bad)", { XX
} },
4051 { VEX_LEN_TABLE (VEX_LEN_EA_P_2
) },
4052 { "(bad)", { XX
} },
4057 { "(bad)", { XX
} },
4058 { "(bad)", { XX
} },
4059 { VEX_LEN_TABLE (VEX_LEN_EB_P_2
) },
4060 { "(bad)", { XX
} },
4065 { "(bad)", { XX
} },
4066 { "(bad)", { XX
} },
4067 { VEX_LEN_TABLE (VEX_LEN_EC_P_2
) },
4068 { "(bad)", { XX
} },
4073 { "(bad)", { XX
} },
4074 { "(bad)", { XX
} },
4075 { VEX_LEN_TABLE (VEX_LEN_ED_P_2
) },
4076 { "(bad)", { XX
} },
4081 { "(bad)", { XX
} },
4082 { "(bad)", { XX
} },
4083 { VEX_LEN_TABLE (VEX_LEN_EE_P_2
) },
4084 { "(bad)", { XX
} },
4089 { "(bad)", { XX
} },
4090 { "(bad)", { XX
} },
4091 { VEX_LEN_TABLE (VEX_LEN_EF_P_2
) },
4092 { "(bad)", { XX
} },
4097 { "(bad)", { XX
} },
4098 { "(bad)", { XX
} },
4099 { "(bad)", { XX
} },
4100 { MOD_TABLE (MOD_VEX_F0_PREFIX_3
) },
4105 { "(bad)", { XX
} },
4106 { "(bad)", { XX
} },
4107 { VEX_LEN_TABLE (VEX_LEN_F1_P_2
) },
4108 { "(bad)", { XX
} },
4113 { "(bad)", { XX
} },
4114 { "(bad)", { XX
} },
4115 { VEX_LEN_TABLE (VEX_LEN_F2_P_2
) },
4116 { "(bad)", { XX
} },
4121 { "(bad)", { XX
} },
4122 { "(bad)", { XX
} },
4123 { VEX_LEN_TABLE (VEX_LEN_F3_P_2
) },
4124 { "(bad)", { XX
} },
4129 { "(bad)", { XX
} },
4130 { "(bad)", { XX
} },
4131 { VEX_LEN_TABLE (VEX_LEN_F4_P_2
) },
4132 { "(bad)", { XX
} },
4137 { "(bad)", { XX
} },
4138 { "(bad)", { XX
} },
4139 { VEX_LEN_TABLE (VEX_LEN_F5_P_2
) },
4140 { "(bad)", { XX
} },
4145 { "(bad)", { XX
} },
4146 { "(bad)", { XX
} },
4147 { VEX_LEN_TABLE (VEX_LEN_F6_P_2
) },
4148 { "(bad)", { XX
} },
4153 { "(bad)", { XX
} },
4154 { "(bad)", { XX
} },
4155 { VEX_LEN_TABLE (VEX_LEN_F7_P_2
) },
4156 { "(bad)", { XX
} },
4161 { "(bad)", { XX
} },
4162 { "(bad)", { XX
} },
4163 { VEX_LEN_TABLE (VEX_LEN_F8_P_2
) },
4164 { "(bad)", { XX
} },
4169 { "(bad)", { XX
} },
4170 { "(bad)", { XX
} },
4171 { VEX_LEN_TABLE (VEX_LEN_F9_P_2
) },
4172 { "(bad)", { XX
} },
4177 { "(bad)", { XX
} },
4178 { "(bad)", { XX
} },
4179 { VEX_LEN_TABLE (VEX_LEN_FA_P_2
) },
4180 { "(bad)", { XX
} },
4185 { "(bad)", { XX
} },
4186 { "(bad)", { XX
} },
4187 { VEX_LEN_TABLE (VEX_LEN_FB_P_2
) },
4188 { "(bad)", { XX
} },
4193 { "(bad)", { XX
} },
4194 { "(bad)", { XX
} },
4195 { VEX_LEN_TABLE (VEX_LEN_FC_P_2
) },
4196 { "(bad)", { XX
} },
4201 { "(bad)", { XX
} },
4202 { "(bad)", { XX
} },
4203 { VEX_LEN_TABLE (VEX_LEN_FD_P_2
) },
4204 { "(bad)", { XX
} },
4209 { "(bad)", { XX
} },
4210 { "(bad)", { XX
} },
4211 { VEX_LEN_TABLE (VEX_LEN_FE_P_2
) },
4212 { "(bad)", { XX
} },
4215 /* PREFIX_VEX_3800 */
4217 { "(bad)", { XX
} },
4218 { "(bad)", { XX
} },
4219 { VEX_LEN_TABLE (VEX_LEN_3800_P_2
) },
4220 { "(bad)", { XX
} },
4223 /* PREFIX_VEX_3801 */
4225 { "(bad)", { XX
} },
4226 { "(bad)", { XX
} },
4227 { VEX_LEN_TABLE (VEX_LEN_3801_P_2
) },
4228 { "(bad)", { XX
} },
4231 /* PREFIX_VEX_3802 */
4233 { "(bad)", { XX
} },
4234 { "(bad)", { XX
} },
4235 { VEX_LEN_TABLE (VEX_LEN_3802_P_2
) },
4236 { "(bad)", { XX
} },
4239 /* PREFIX_VEX_3803 */
4241 { "(bad)", { XX
} },
4242 { "(bad)", { XX
} },
4243 { VEX_LEN_TABLE (VEX_LEN_3803_P_2
) },
4244 { "(bad)", { XX
} },
4247 /* PREFIX_VEX_3804 */
4249 { "(bad)", { XX
} },
4250 { "(bad)", { XX
} },
4251 { VEX_LEN_TABLE (VEX_LEN_3804_P_2
) },
4252 { "(bad)", { XX
} },
4255 /* PREFIX_VEX_3805 */
4257 { "(bad)", { XX
} },
4258 { "(bad)", { XX
} },
4259 { VEX_LEN_TABLE (VEX_LEN_3805_P_2
) },
4260 { "(bad)", { XX
} },
4263 /* PREFIX_VEX_3806 */
4265 { "(bad)", { XX
} },
4266 { "(bad)", { XX
} },
4267 { VEX_LEN_TABLE (VEX_LEN_3806_P_2
) },
4268 { "(bad)", { XX
} },
4271 /* PREFIX_VEX_3807 */
4273 { "(bad)", { XX
} },
4274 { "(bad)", { XX
} },
4275 { VEX_LEN_TABLE (VEX_LEN_3807_P_2
) },
4276 { "(bad)", { XX
} },
4279 /* PREFIX_VEX_3808 */
4281 { "(bad)", { XX
} },
4282 { "(bad)", { XX
} },
4283 { VEX_LEN_TABLE (VEX_LEN_3808_P_2
) },
4284 { "(bad)", { XX
} },
4287 /* PREFIX_VEX_3809 */
4289 { "(bad)", { XX
} },
4290 { "(bad)", { XX
} },
4291 { VEX_LEN_TABLE (VEX_LEN_3809_P_2
) },
4292 { "(bad)", { XX
} },
4295 /* PREFIX_VEX_380A */
4297 { "(bad)", { XX
} },
4298 { "(bad)", { XX
} },
4299 { VEX_LEN_TABLE (VEX_LEN_380A_P_2
) },
4300 { "(bad)", { XX
} },
4303 /* PREFIX_VEX_380B */
4305 { "(bad)", { XX
} },
4306 { "(bad)", { XX
} },
4307 { VEX_LEN_TABLE (VEX_LEN_380B_P_2
) },
4308 { "(bad)", { XX
} },
4311 /* PREFIX_VEX_380C */
4313 { "(bad)", { XX
} },
4314 { "(bad)", { XX
} },
4315 { "vpermilps", { XM
, Vex
, EXx
} },
4316 { "(bad)", { XX
} },
4319 /* PREFIX_VEX_380D */
4321 { "(bad)", { XX
} },
4322 { "(bad)", { XX
} },
4323 { "vpermilpd", { XM
, Vex
, EXx
} },
4324 { "(bad)", { XX
} },
4327 /* PREFIX_VEX_380E */
4329 { "(bad)", { XX
} },
4330 { "(bad)", { XX
} },
4331 { "vtestps", { XM
, EXx
} },
4332 { "(bad)", { XX
} },
4335 /* PREFIX_VEX_380F */
4337 { "(bad)", { XX
} },
4338 { "(bad)", { XX
} },
4339 { "vtestpd", { XM
, EXx
} },
4340 { "(bad)", { XX
} },
4343 /* PREFIX_VEX_3817 */
4345 { "(bad)", { XX
} },
4346 { "(bad)", { XX
} },
4347 { "vptest", { XM
, EXx
} },
4348 { "(bad)", { XX
} },
4351 /* PREFIX_VEX_3818 */
4353 { "(bad)", { XX
} },
4354 { "(bad)", { XX
} },
4355 { MOD_TABLE (MOD_VEX_3818_PREFIX_2
) },
4356 { "(bad)", { XX
} },
4359 /* PREFIX_VEX_3819 */
4361 { "(bad)", { XX
} },
4362 { "(bad)", { XX
} },
4363 { MOD_TABLE (MOD_VEX_3819_PREFIX_2
) },
4364 { "(bad)", { XX
} },
4367 /* PREFIX_VEX_381A */
4369 { "(bad)", { XX
} },
4370 { "(bad)", { XX
} },
4371 { MOD_TABLE (MOD_VEX_381A_PREFIX_2
) },
4372 { "(bad)", { XX
} },
4375 /* PREFIX_VEX_381C */
4377 { "(bad)", { XX
} },
4378 { "(bad)", { XX
} },
4379 { VEX_LEN_TABLE (VEX_LEN_381C_P_2
) },
4380 { "(bad)", { XX
} },
4383 /* PREFIX_VEX_381D */
4385 { "(bad)", { XX
} },
4386 { "(bad)", { XX
} },
4387 { VEX_LEN_TABLE (VEX_LEN_381D_P_2
) },
4388 { "(bad)", { XX
} },
4391 /* PREFIX_VEX_381E */
4393 { "(bad)", { XX
} },
4394 { "(bad)", { XX
} },
4395 { VEX_LEN_TABLE (VEX_LEN_381E_P_2
) },
4396 { "(bad)", { XX
} },
4399 /* PREFIX_VEX_3820 */
4401 { "(bad)", { XX
} },
4402 { "(bad)", { XX
} },
4403 { VEX_LEN_TABLE (VEX_LEN_3820_P_2
) },
4404 { "(bad)", { XX
} },
4407 /* PREFIX_VEX_3821 */
4409 { "(bad)", { XX
} },
4410 { "(bad)", { XX
} },
4411 { VEX_LEN_TABLE (VEX_LEN_3821_P_2
) },
4412 { "(bad)", { XX
} },
4415 /* PREFIX_VEX_3822 */
4417 { "(bad)", { XX
} },
4418 { "(bad)", { XX
} },
4419 { VEX_LEN_TABLE (VEX_LEN_3822_P_2
) },
4420 { "(bad)", { XX
} },
4423 /* PREFIX_VEX_3823 */
4425 { "(bad)", { XX
} },
4426 { "(bad)", { XX
} },
4427 { VEX_LEN_TABLE (VEX_LEN_3823_P_2
) },
4428 { "(bad)", { XX
} },
4431 /* PREFIX_VEX_3824 */
4433 { "(bad)", { XX
} },
4434 { "(bad)", { XX
} },
4435 { VEX_LEN_TABLE (VEX_LEN_3824_P_2
) },
4436 { "(bad)", { XX
} },
4439 /* PREFIX_VEX_3825 */
4441 { "(bad)", { XX
} },
4442 { "(bad)", { XX
} },
4443 { VEX_LEN_TABLE (VEX_LEN_3825_P_2
) },
4444 { "(bad)", { XX
} },
4447 /* PREFIX_VEX_3828 */
4449 { "(bad)", { XX
} },
4450 { "(bad)", { XX
} },
4451 { VEX_LEN_TABLE (VEX_LEN_3828_P_2
) },
4452 { "(bad)", { XX
} },
4455 /* PREFIX_VEX_3829 */
4457 { "(bad)", { XX
} },
4458 { "(bad)", { XX
} },
4459 { VEX_LEN_TABLE (VEX_LEN_3829_P_2
) },
4460 { "(bad)", { XX
} },
4463 /* PREFIX_VEX_382A */
4465 { "(bad)", { XX
} },
4466 { "(bad)", { XX
} },
4467 { MOD_TABLE (MOD_VEX_382A_PREFIX_2
) },
4468 { "(bad)", { XX
} },
4471 /* PREFIX_VEX_382B */
4473 { "(bad)", { XX
} },
4474 { "(bad)", { XX
} },
4475 { VEX_LEN_TABLE (VEX_LEN_382B_P_2
) },
4476 { "(bad)", { XX
} },
4479 /* PREFIX_VEX_382C */
4481 { "(bad)", { XX
} },
4482 { "(bad)", { XX
} },
4483 { MOD_TABLE (MOD_VEX_382C_PREFIX_2
) },
4484 { "(bad)", { XX
} },
4487 /* PREFIX_VEX_382D */
4489 { "(bad)", { XX
} },
4490 { "(bad)", { XX
} },
4491 { MOD_TABLE (MOD_VEX_382D_PREFIX_2
) },
4492 { "(bad)", { XX
} },
4495 /* PREFIX_VEX_382E */
4497 { "(bad)", { XX
} },
4498 { "(bad)", { XX
} },
4499 { MOD_TABLE (MOD_VEX_382E_PREFIX_2
) },
4500 { "(bad)", { XX
} },
4503 /* PREFIX_VEX_382F */
4505 { "(bad)", { XX
} },
4506 { "(bad)", { XX
} },
4507 { MOD_TABLE (MOD_VEX_382F_PREFIX_2
) },
4508 { "(bad)", { XX
} },
4511 /* PREFIX_VEX_3830 */
4513 { "(bad)", { XX
} },
4514 { "(bad)", { XX
} },
4515 { VEX_LEN_TABLE (VEX_LEN_3830_P_2
) },
4516 { "(bad)", { XX
} },
4519 /* PREFIX_VEX_3831 */
4521 { "(bad)", { XX
} },
4522 { "(bad)", { XX
} },
4523 { VEX_LEN_TABLE (VEX_LEN_3831_P_2
) },
4524 { "(bad)", { XX
} },
4527 /* PREFIX_VEX_3832 */
4529 { "(bad)", { XX
} },
4530 { "(bad)", { XX
} },
4531 { VEX_LEN_TABLE (VEX_LEN_3832_P_2
) },
4532 { "(bad)", { XX
} },
4535 /* PREFIX_VEX_3833 */
4537 { "(bad)", { XX
} },
4538 { "(bad)", { XX
} },
4539 { VEX_LEN_TABLE (VEX_LEN_3833_P_2
) },
4540 { "(bad)", { XX
} },
4543 /* PREFIX_VEX_3834 */
4545 { "(bad)", { XX
} },
4546 { "(bad)", { XX
} },
4547 { VEX_LEN_TABLE (VEX_LEN_3834_P_2
) },
4548 { "(bad)", { XX
} },
4551 /* PREFIX_VEX_3835 */
4553 { "(bad)", { XX
} },
4554 { "(bad)", { XX
} },
4555 { VEX_LEN_TABLE (VEX_LEN_3835_P_2
) },
4556 { "(bad)", { XX
} },
4559 /* PREFIX_VEX_3837 */
4561 { "(bad)", { XX
} },
4562 { "(bad)", { XX
} },
4563 { VEX_LEN_TABLE (VEX_LEN_3837_P_2
) },
4564 { "(bad)", { XX
} },
4567 /* PREFIX_VEX_3838 */
4569 { "(bad)", { XX
} },
4570 { "(bad)", { XX
} },
4571 { VEX_LEN_TABLE (VEX_LEN_3838_P_2
) },
4572 { "(bad)", { XX
} },
4575 /* PREFIX_VEX_3839 */
4577 { "(bad)", { XX
} },
4578 { "(bad)", { XX
} },
4579 { VEX_LEN_TABLE (VEX_LEN_3839_P_2
) },
4580 { "(bad)", { XX
} },
4583 /* PREFIX_VEX_383A */
4585 { "(bad)", { XX
} },
4586 { "(bad)", { XX
} },
4587 { VEX_LEN_TABLE (VEX_LEN_383A_P_2
) },
4588 { "(bad)", { XX
} },
4591 /* PREFIX_VEX_383B */
4593 { "(bad)", { XX
} },
4594 { "(bad)", { XX
} },
4595 { VEX_LEN_TABLE (VEX_LEN_383B_P_2
) },
4596 { "(bad)", { XX
} },
4599 /* PREFIX_VEX_383C */
4601 { "(bad)", { XX
} },
4602 { "(bad)", { XX
} },
4603 { VEX_LEN_TABLE (VEX_LEN_383C_P_2
) },
4604 { "(bad)", { XX
} },
4607 /* PREFIX_VEX_383D */
4609 { "(bad)", { XX
} },
4610 { "(bad)", { XX
} },
4611 { VEX_LEN_TABLE (VEX_LEN_383D_P_2
) },
4612 { "(bad)", { XX
} },
4615 /* PREFIX_VEX_383E */
4617 { "(bad)", { XX
} },
4618 { "(bad)", { XX
} },
4619 { VEX_LEN_TABLE (VEX_LEN_383E_P_2
) },
4620 { "(bad)", { XX
} },
4623 /* PREFIX_VEX_383F */
4625 { "(bad)", { XX
} },
4626 { "(bad)", { XX
} },
4627 { VEX_LEN_TABLE (VEX_LEN_383F_P_2
) },
4628 { "(bad)", { XX
} },
4631 /* PREFIX_VEX_3840 */
4633 { "(bad)", { XX
} },
4634 { "(bad)", { XX
} },
4635 { VEX_LEN_TABLE (VEX_LEN_3840_P_2
) },
4636 { "(bad)", { XX
} },
4639 /* PREFIX_VEX_3841 */
4641 { "(bad)", { XX
} },
4642 { "(bad)", { XX
} },
4643 { VEX_LEN_TABLE (VEX_LEN_3841_P_2
) },
4644 { "(bad)", { XX
} },
4647 /* PREFIX_VEX_3896 */
4649 { "(bad)", { XX
} },
4650 { "(bad)", { XX
} },
4651 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
} },
4652 { "(bad)", { XX
} },
4655 /* PREFIX_VEX_3897 */
4657 { "(bad)", { XX
} },
4658 { "(bad)", { XX
} },
4659 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
} },
4660 { "(bad)", { XX
} },
4663 /* PREFIX_VEX_3898 */
4665 { "(bad)", { XX
} },
4666 { "(bad)", { XX
} },
4667 { "vfmadd132p%XW", { XM
, Vex
, EXx
} },
4668 { "(bad)", { XX
} },
4671 /* PREFIX_VEX_3899 */
4673 { "(bad)", { XX
} },
4674 { "(bad)", { XX
} },
4675 { "vfmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4676 { "(bad)", { XX
} },
4679 /* PREFIX_VEX_389A */
4681 { "(bad)", { XX
} },
4682 { "(bad)", { XX
} },
4683 { "vfmsub132p%XW", { XM
, Vex
, EXx
} },
4684 { "(bad)", { XX
} },
4687 /* PREFIX_VEX_389B */
4689 { "(bad)", { XX
} },
4690 { "(bad)", { XX
} },
4691 { "vfmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4692 { "(bad)", { XX
} },
4695 /* PREFIX_VEX_389C */
4697 { "(bad)", { XX
} },
4698 { "(bad)", { XX
} },
4699 { "vfnmadd132p%XW", { XM
, Vex
, EXx
} },
4700 { "(bad)", { XX
} },
4703 /* PREFIX_VEX_389D */
4705 { "(bad)", { XX
} },
4706 { "(bad)", { XX
} },
4707 { "vfnmadd132s%XW", { XM
, Vex
, EXVexWdq
} },
4708 { "(bad)", { XX
} },
4711 /* PREFIX_VEX_389E */
4713 { "(bad)", { XX
} },
4714 { "(bad)", { XX
} },
4715 { "vfnmsub132p%XW", { XM
, Vex
, EXx
} },
4716 { "(bad)", { XX
} },
4719 /* PREFIX_VEX_389F */
4721 { "(bad)", { XX
} },
4722 { "(bad)", { XX
} },
4723 { "vfnmsub132s%XW", { XM
, Vex
, EXVexWdq
} },
4724 { "(bad)", { XX
} },
4727 /* PREFIX_VEX_38A6 */
4729 { "(bad)", { XX
} },
4730 { "(bad)", { XX
} },
4731 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
} },
4732 { "(bad)", { XX
} },
4735 /* PREFIX_VEX_38A7 */
4737 { "(bad)", { XX
} },
4738 { "(bad)", { XX
} },
4739 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
} },
4740 { "(bad)", { XX
} },
4743 /* PREFIX_VEX_38A8 */
4745 { "(bad)", { XX
} },
4746 { "(bad)", { XX
} },
4747 { "vfmadd213p%XW", { XM
, Vex
, EXx
} },
4748 { "(bad)", { XX
} },
4751 /* PREFIX_VEX_38A9 */
4753 { "(bad)", { XX
} },
4754 { "(bad)", { XX
} },
4755 { "vfmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4756 { "(bad)", { XX
} },
4759 /* PREFIX_VEX_38AA */
4761 { "(bad)", { XX
} },
4762 { "(bad)", { XX
} },
4763 { "vfmsub213p%XW", { XM
, Vex
, EXx
} },
4764 { "(bad)", { XX
} },
4767 /* PREFIX_VEX_38AB */
4769 { "(bad)", { XX
} },
4770 { "(bad)", { XX
} },
4771 { "vfmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4772 { "(bad)", { XX
} },
4775 /* PREFIX_VEX_38AC */
4777 { "(bad)", { XX
} },
4778 { "(bad)", { XX
} },
4779 { "vfnmadd213p%XW", { XM
, Vex
, EXx
} },
4780 { "(bad)", { XX
} },
4783 /* PREFIX_VEX_38AD */
4785 { "(bad)", { XX
} },
4786 { "(bad)", { XX
} },
4787 { "vfnmadd213s%XW", { XM
, Vex
, EXVexWdq
} },
4788 { "(bad)", { XX
} },
4791 /* PREFIX_VEX_38AE */
4793 { "(bad)", { XX
} },
4794 { "(bad)", { XX
} },
4795 { "vfnmsub213p%XW", { XM
, Vex
, EXx
} },
4796 { "(bad)", { XX
} },
4799 /* PREFIX_VEX_38AF */
4801 { "(bad)", { XX
} },
4802 { "(bad)", { XX
} },
4803 { "vfnmsub213s%XW", { XM
, Vex
, EXVexWdq
} },
4804 { "(bad)", { XX
} },
4807 /* PREFIX_VEX_38B6 */
4809 { "(bad)", { XX
} },
4810 { "(bad)", { XX
} },
4811 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
} },
4812 { "(bad)", { XX
} },
4815 /* PREFIX_VEX_38B7 */
4817 { "(bad)", { XX
} },
4818 { "(bad)", { XX
} },
4819 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
} },
4820 { "(bad)", { XX
} },
4823 /* PREFIX_VEX_38B8 */
4825 { "(bad)", { XX
} },
4826 { "(bad)", { XX
} },
4827 { "vfmadd231p%XW", { XM
, Vex
, EXx
} },
4828 { "(bad)", { XX
} },
4831 /* PREFIX_VEX_38B9 */
4833 { "(bad)", { XX
} },
4834 { "(bad)", { XX
} },
4835 { "vfmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4836 { "(bad)", { XX
} },
4839 /* PREFIX_VEX_38BA */
4841 { "(bad)", { XX
} },
4842 { "(bad)", { XX
} },
4843 { "vfmsub231p%XW", { XM
, Vex
, EXx
} },
4844 { "(bad)", { XX
} },
4847 /* PREFIX_VEX_38BB */
4849 { "(bad)", { XX
} },
4850 { "(bad)", { XX
} },
4851 { "vfmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4852 { "(bad)", { XX
} },
4855 /* PREFIX_VEX_38BC */
4857 { "(bad)", { XX
} },
4858 { "(bad)", { XX
} },
4859 { "vfnmadd231p%XW", { XM
, Vex
, EXx
} },
4860 { "(bad)", { XX
} },
4863 /* PREFIX_VEX_38BD */
4865 { "(bad)", { XX
} },
4866 { "(bad)", { XX
} },
4867 { "vfnmadd231s%XW", { XM
, Vex
, EXVexWdq
} },
4868 { "(bad)", { XX
} },
4871 /* PREFIX_VEX_38BE */
4873 { "(bad)", { XX
} },
4874 { "(bad)", { XX
} },
4875 { "vfnmsub231p%XW", { XM
, Vex
, EXx
} },
4876 { "(bad)", { XX
} },
4879 /* PREFIX_VEX_38BF */
4881 { "(bad)", { XX
} },
4882 { "(bad)", { XX
} },
4883 { "vfnmsub231s%XW", { XM
, Vex
, EXVexWdq
} },
4884 { "(bad)", { XX
} },
4887 /* PREFIX_VEX_38DB */
4889 { "(bad)", { XX
} },
4890 { "(bad)", { XX
} },
4891 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2
) },
4892 { "(bad)", { XX
} },
4895 /* PREFIX_VEX_38DC */
4897 { "(bad)", { XX
} },
4898 { "(bad)", { XX
} },
4899 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2
) },
4900 { "(bad)", { XX
} },
4903 /* PREFIX_VEX_38DD */
4905 { "(bad)", { XX
} },
4906 { "(bad)", { XX
} },
4907 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2
) },
4908 { "(bad)", { XX
} },
4911 /* PREFIX_VEX_38DE */
4913 { "(bad)", { XX
} },
4914 { "(bad)", { XX
} },
4915 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2
) },
4916 { "(bad)", { XX
} },
4919 /* PREFIX_VEX_38DF */
4921 { "(bad)", { XX
} },
4922 { "(bad)", { XX
} },
4923 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2
) },
4924 { "(bad)", { XX
} },
4927 /* PREFIX_VEX_3A04 */
4929 { "(bad)", { XX
} },
4930 { "(bad)", { XX
} },
4931 { "vpermilps", { XM
, EXx
, Ib
} },
4932 { "(bad)", { XX
} },
4935 /* PREFIX_VEX_3A05 */
4937 { "(bad)", { XX
} },
4938 { "(bad)", { XX
} },
4939 { "vpermilpd", { XM
, EXx
, Ib
} },
4940 { "(bad)", { XX
} },
4943 /* PREFIX_VEX_3A06 */
4945 { "(bad)", { XX
} },
4946 { "(bad)", { XX
} },
4947 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2
) },
4948 { "(bad)", { XX
} },
4951 /* PREFIX_VEX_3A08 */
4953 { "(bad)", { XX
} },
4954 { "(bad)", { XX
} },
4955 { "vroundps", { XM
, EXx
, Ib
} },
4956 { "(bad)", { XX
} },
4959 /* PREFIX_VEX_3A09 */
4961 { "(bad)", { XX
} },
4962 { "(bad)", { XX
} },
4963 { "vroundpd", { XM
, EXx
, Ib
} },
4964 { "(bad)", { XX
} },
4967 /* PREFIX_VEX_3A0A */
4969 { "(bad)", { XX
} },
4970 { "(bad)", { XX
} },
4971 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2
) },
4972 { "(bad)", { XX
} },
4975 /* PREFIX_VEX_3A0B */
4977 { "(bad)", { XX
} },
4978 { "(bad)", { XX
} },
4979 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2
) },
4980 { "(bad)", { XX
} },
4983 /* PREFIX_VEX_3A0C */
4985 { "(bad)", { XX
} },
4986 { "(bad)", { XX
} },
4987 { "vblendps", { XM
, Vex
, EXx
, Ib
} },
4988 { "(bad)", { XX
} },
4991 /* PREFIX_VEX_3A0D */
4993 { "(bad)", { XX
} },
4994 { "(bad)", { XX
} },
4995 { "vblendpd", { XM
, Vex
, EXx
, Ib
} },
4996 { "(bad)", { XX
} },
4999 /* PREFIX_VEX_3A0E */
5001 { "(bad)", { XX
} },
5002 { "(bad)", { XX
} },
5003 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2
) },
5004 { "(bad)", { XX
} },
5007 /* PREFIX_VEX_3A0F */
5009 { "(bad)", { XX
} },
5010 { "(bad)", { XX
} },
5011 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2
) },
5012 { "(bad)", { XX
} },
5015 /* PREFIX_VEX_3A14 */
5017 { "(bad)", { XX
} },
5018 { "(bad)", { XX
} },
5019 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2
) },
5020 { "(bad)", { XX
} },
5023 /* PREFIX_VEX_3A15 */
5025 { "(bad)", { XX
} },
5026 { "(bad)", { XX
} },
5027 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2
) },
5028 { "(bad)", { XX
} },
5031 /* PREFIX_VEX_3A16 */
5033 { "(bad)", { XX
} },
5034 { "(bad)", { XX
} },
5035 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2
) },
5036 { "(bad)", { XX
} },
5039 /* PREFIX_VEX_3A17 */
5041 { "(bad)", { XX
} },
5042 { "(bad)", { XX
} },
5043 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2
) },
5044 { "(bad)", { XX
} },
5047 /* PREFIX_VEX_3A18 */
5049 { "(bad)", { XX
} },
5050 { "(bad)", { XX
} },
5051 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2
) },
5052 { "(bad)", { XX
} },
5055 /* PREFIX_VEX_3A19 */
5057 { "(bad)", { XX
} },
5058 { "(bad)", { XX
} },
5059 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2
) },
5060 { "(bad)", { XX
} },
5063 /* PREFIX_VEX_3A20 */
5065 { "(bad)", { XX
} },
5066 { "(bad)", { XX
} },
5067 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2
) },
5068 { "(bad)", { XX
} },
5071 /* PREFIX_VEX_3A21 */
5073 { "(bad)", { XX
} },
5074 { "(bad)", { XX
} },
5075 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2
) },
5076 { "(bad)", { XX
} },
5079 /* PREFIX_VEX_3A22 */
5081 { "(bad)", { XX
} },
5082 { "(bad)", { XX
} },
5083 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2
) },
5084 { "(bad)", { XX
} },
5087 /* PREFIX_VEX_3A40 */
5089 { "(bad)", { XX
} },
5090 { "(bad)", { XX
} },
5091 { "vdpps", { XM
, Vex
, EXx
, Ib
} },
5092 { "(bad)", { XX
} },
5095 /* PREFIX_VEX_3A41 */
5097 { "(bad)", { XX
} },
5098 { "(bad)", { XX
} },
5099 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2
) },
5100 { "(bad)", { XX
} },
5103 /* PREFIX_VEX_3A42 */
5105 { "(bad)", { XX
} },
5106 { "(bad)", { XX
} },
5107 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2
) },
5108 { "(bad)", { XX
} },
5111 /* PREFIX_VEX_3A44 */
5113 { "(bad)", { XX
} },
5114 { "(bad)", { XX
} },
5115 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2
) },
5116 { "(bad)", { XX
} },
5119 /* PREFIX_VEX_3A4A */
5121 { "(bad)", { XX
} },
5122 { "(bad)", { XX
} },
5123 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
} },
5124 { "(bad)", { XX
} },
5127 /* PREFIX_VEX_3A4B */
5129 { "(bad)", { XX
} },
5130 { "(bad)", { XX
} },
5131 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
} },
5132 { "(bad)", { XX
} },
5135 /* PREFIX_VEX_3A4C */
5137 { "(bad)", { XX
} },
5138 { "(bad)", { XX
} },
5139 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2
) },
5140 { "(bad)", { XX
} },
5143 /* PREFIX_VEX_3A5C */
5145 { "(bad)", { XX
} },
5146 { "(bad)", { XX
} },
5147 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5148 { "(bad)", { XX
} },
5151 /* PREFIX_VEX_3A5D */
5153 { "(bad)", { XX
} },
5154 { "(bad)", { XX
} },
5155 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5156 { "(bad)", { XX
} },
5159 /* PREFIX_VEX_3A5E */
5161 { "(bad)", { XX
} },
5162 { "(bad)", { XX
} },
5163 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5164 { "(bad)", { XX
} },
5167 /* PREFIX_VEX_3A5F */
5169 { "(bad)", { XX
} },
5170 { "(bad)", { XX
} },
5171 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5172 { "(bad)", { XX
} },
5175 /* PREFIX_VEX_3A60 */
5177 { "(bad)", { XX
} },
5178 { "(bad)", { XX
} },
5179 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2
) },
5180 { "(bad)", { XX
} },
5183 /* PREFIX_VEX_3A61 */
5185 { "(bad)", { XX
} },
5186 { "(bad)", { XX
} },
5187 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2
) },
5188 { "(bad)", { XX
} },
5191 /* PREFIX_VEX_3A62 */
5193 { "(bad)", { XX
} },
5194 { "(bad)", { XX
} },
5195 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2
) },
5196 { "(bad)", { XX
} },
5199 /* PREFIX_VEX_3A63 */
5201 { "(bad)", { XX
} },
5202 { "(bad)", { XX
} },
5203 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2
) },
5204 { "(bad)", { XX
} },
5207 /* PREFIX_VEX_3A68 */
5209 { "(bad)", { XX
} },
5210 { "(bad)", { XX
} },
5211 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5212 { "(bad)", { XX
} },
5215 /* PREFIX_VEX_3A69 */
5217 { "(bad)", { XX
} },
5218 { "(bad)", { XX
} },
5219 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5220 { "(bad)", { XX
} },
5223 /* PREFIX_VEX_3A6A */
5225 { "(bad)", { XX
} },
5226 { "(bad)", { XX
} },
5227 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2
) },
5228 { "(bad)", { XX
} },
5231 /* PREFIX_VEX_3A6B */
5233 { "(bad)", { XX
} },
5234 { "(bad)", { XX
} },
5235 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2
) },
5236 { "(bad)", { XX
} },
5239 /* PREFIX_VEX_3A6C */
5241 { "(bad)", { XX
} },
5242 { "(bad)", { XX
} },
5243 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5244 { "(bad)", { XX
} },
5247 /* PREFIX_VEX_3A6D */
5249 { "(bad)", { XX
} },
5250 { "(bad)", { XX
} },
5251 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5252 { "(bad)", { XX
} },
5255 /* PREFIX_VEX_3A6E */
5257 { "(bad)", { XX
} },
5258 { "(bad)", { XX
} },
5259 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2
) },
5260 { "(bad)", { XX
} },
5263 /* PREFIX_VEX_3A6F */
5265 { "(bad)", { XX
} },
5266 { "(bad)", { XX
} },
5267 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2
) },
5268 { "(bad)", { XX
} },
5271 /* PREFIX_VEX_3A78 */
5273 { "(bad)", { XX
} },
5274 { "(bad)", { XX
} },
5275 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5276 { "(bad)", { XX
} },
5279 /* PREFIX_VEX_3A79 */
5281 { "(bad)", { XX
} },
5282 { "(bad)", { XX
} },
5283 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5284 { "(bad)", { XX
} },
5287 /* PREFIX_VEX_3A7A */
5289 { "(bad)", { XX
} },
5290 { "(bad)", { XX
} },
5291 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2
) },
5292 { "(bad)", { XX
} },
5295 /* PREFIX_VEX_3A7B */
5297 { "(bad)", { XX
} },
5298 { "(bad)", { XX
} },
5299 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2
) },
5300 { "(bad)", { XX
} },
5303 /* PREFIX_VEX_3A7C */
5305 { "(bad)", { XX
} },
5306 { "(bad)", { XX
} },
5307 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5308 { "(bad)", { XX
} },
5311 /* PREFIX_VEX_3A7D */
5313 { "(bad)", { XX
} },
5314 { "(bad)", { XX
} },
5315 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
5316 { "(bad)", { XX
} },
5319 /* PREFIX_VEX_3A7E */
5321 { "(bad)", { XX
} },
5322 { "(bad)", { XX
} },
5323 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2
) },
5324 { "(bad)", { XX
} },
5327 /* PREFIX_VEX_3A7F */
5329 { "(bad)", { XX
} },
5330 { "(bad)", { XX
} },
5331 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2
) },
5332 { "(bad)", { XX
} },
5335 /* PREFIX_VEX_3ADF */
5337 { "(bad)", { XX
} },
5338 { "(bad)", { XX
} },
5339 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2
) },
5340 { "(bad)", { XX
} },
5344 static const struct dis386 x86_64_table
[][2] = {
5347 { "push{T|}", { es
} },
5348 { "(bad)", { XX
} },
5353 { "pop{T|}", { es
} },
5354 { "(bad)", { XX
} },
5359 { "push{T|}", { cs
} },
5360 { "(bad)", { XX
} },
5365 { "push{T|}", { ss
} },
5366 { "(bad)", { XX
} },
5371 { "pop{T|}", { ss
} },
5372 { "(bad)", { XX
} },
5377 { "push{T|}", { ds
} },
5378 { "(bad)", { XX
} },
5383 { "pop{T|}", { ds
} },
5384 { "(bad)", { XX
} },
5390 { "(bad)", { XX
} },
5396 { "(bad)", { XX
} },
5402 { "(bad)", { XX
} },
5408 { "(bad)", { XX
} },
5413 { "pusha{P|}", { XX
} },
5414 { "(bad)", { XX
} },
5419 { "popa{P|}", { XX
} },
5420 { "(bad)", { XX
} },
5425 { MOD_TABLE (MOD_62_32BIT
) },
5426 { "(bad)", { XX
} },
5431 { "arpl", { Ew
, Gw
} },
5432 { "movs{lq|xd}", { Gv
, Ed
} },
5437 { "ins{R|}", { Yzr
, indirDX
} },
5438 { "ins{G|}", { Yzr
, indirDX
} },
5443 { "outs{R|}", { indirDXr
, Xz
} },
5444 { "outs{G|}", { indirDXr
, Xz
} },
5449 { "Jcall{T|}", { Ap
} },
5450 { "(bad)", { XX
} },
5455 { MOD_TABLE (MOD_C4_32BIT
) },
5456 { VEX_C4_TABLE (VEX_0F
) },
5461 { MOD_TABLE (MOD_C5_32BIT
) },
5462 { VEX_C5_TABLE (VEX_0F
) },
5468 { "(bad)", { XX
} },
5474 { "(bad)", { XX
} },
5480 { "(bad)", { XX
} },
5485 { "Jjmp{T|}", { Ap
} },
5486 { "(bad)", { XX
} },
5489 /* X86_64_0F01_REG_0 */
5491 { "sgdt{Q|IQ}", { M
} },
5495 /* X86_64_0F01_REG_1 */
5497 { "sidt{Q|IQ}", { M
} },
5501 /* X86_64_0F01_REG_2 */
5503 { "lgdt{Q|Q}", { M
} },
5507 /* X86_64_0F01_REG_3 */
5509 { "lidt{Q|Q}", { M
} },
5514 static const struct dis386 three_byte_table
[][256] = {
5516 /* THREE_BYTE_0F38 */
5519 { "pshufb", { MX
, EM
} },
5520 { "phaddw", { MX
, EM
} },
5521 { "phaddd", { MX
, EM
} },
5522 { "phaddsw", { MX
, EM
} },
5523 { "pmaddubsw", { MX
, EM
} },
5524 { "phsubw", { MX
, EM
} },
5525 { "phsubd", { MX
, EM
} },
5526 { "phsubsw", { MX
, EM
} },
5528 { "psignb", { MX
, EM
} },
5529 { "psignw", { MX
, EM
} },
5530 { "psignd", { MX
, EM
} },
5531 { "pmulhrsw", { MX
, EM
} },
5532 { "(bad)", { XX
} },
5533 { "(bad)", { XX
} },
5534 { "(bad)", { XX
} },
5535 { "(bad)", { XX
} },
5537 { PREFIX_TABLE (PREFIX_0F3810
) },
5538 { "(bad)", { XX
} },
5539 { "(bad)", { XX
} },
5540 { "(bad)", { XX
} },
5541 { PREFIX_TABLE (PREFIX_0F3814
) },
5542 { PREFIX_TABLE (PREFIX_0F3815
) },
5543 { "(bad)", { XX
} },
5544 { PREFIX_TABLE (PREFIX_0F3817
) },
5546 { "(bad)", { XX
} },
5547 { "(bad)", { XX
} },
5548 { "(bad)", { XX
} },
5549 { "(bad)", { XX
} },
5550 { "pabsb", { MX
, EM
} },
5551 { "pabsw", { MX
, EM
} },
5552 { "pabsd", { MX
, EM
} },
5553 { "(bad)", { XX
} },
5555 { PREFIX_TABLE (PREFIX_0F3820
) },
5556 { PREFIX_TABLE (PREFIX_0F3821
) },
5557 { PREFIX_TABLE (PREFIX_0F3822
) },
5558 { PREFIX_TABLE (PREFIX_0F3823
) },
5559 { PREFIX_TABLE (PREFIX_0F3824
) },
5560 { PREFIX_TABLE (PREFIX_0F3825
) },
5561 { "(bad)", { XX
} },
5562 { "(bad)", { XX
} },
5564 { PREFIX_TABLE (PREFIX_0F3828
) },
5565 { PREFIX_TABLE (PREFIX_0F3829
) },
5566 { PREFIX_TABLE (PREFIX_0F382A
) },
5567 { PREFIX_TABLE (PREFIX_0F382B
) },
5568 { "(bad)", { XX
} },
5569 { "(bad)", { XX
} },
5570 { "(bad)", { XX
} },
5571 { "(bad)", { XX
} },
5573 { PREFIX_TABLE (PREFIX_0F3830
) },
5574 { PREFIX_TABLE (PREFIX_0F3831
) },
5575 { PREFIX_TABLE (PREFIX_0F3832
) },
5576 { PREFIX_TABLE (PREFIX_0F3833
) },
5577 { PREFIX_TABLE (PREFIX_0F3834
) },
5578 { PREFIX_TABLE (PREFIX_0F3835
) },
5579 { "(bad)", { XX
} },
5580 { PREFIX_TABLE (PREFIX_0F3837
) },
5582 { PREFIX_TABLE (PREFIX_0F3838
) },
5583 { PREFIX_TABLE (PREFIX_0F3839
) },
5584 { PREFIX_TABLE (PREFIX_0F383A
) },
5585 { PREFIX_TABLE (PREFIX_0F383B
) },
5586 { PREFIX_TABLE (PREFIX_0F383C
) },
5587 { PREFIX_TABLE (PREFIX_0F383D
) },
5588 { PREFIX_TABLE (PREFIX_0F383E
) },
5589 { PREFIX_TABLE (PREFIX_0F383F
) },
5591 { PREFIX_TABLE (PREFIX_0F3840
) },
5592 { PREFIX_TABLE (PREFIX_0F3841
) },
5593 { "(bad)", { XX
} },
5594 { "(bad)", { XX
} },
5595 { "(bad)", { XX
} },
5596 { "(bad)", { XX
} },
5597 { "(bad)", { XX
} },
5598 { "(bad)", { XX
} },
5600 { "(bad)", { XX
} },
5601 { "(bad)", { XX
} },
5602 { "(bad)", { XX
} },
5603 { "(bad)", { XX
} },
5604 { "(bad)", { XX
} },
5605 { "(bad)", { XX
} },
5606 { "(bad)", { XX
} },
5607 { "(bad)", { XX
} },
5609 { "(bad)", { XX
} },
5610 { "(bad)", { XX
} },
5611 { "(bad)", { XX
} },
5612 { "(bad)", { XX
} },
5613 { "(bad)", { XX
} },
5614 { "(bad)", { XX
} },
5615 { "(bad)", { XX
} },
5616 { "(bad)", { XX
} },
5618 { "(bad)", { XX
} },
5619 { "(bad)", { XX
} },
5620 { "(bad)", { XX
} },
5621 { "(bad)", { XX
} },
5622 { "(bad)", { XX
} },
5623 { "(bad)", { XX
} },
5624 { "(bad)", { XX
} },
5625 { "(bad)", { XX
} },
5627 { "(bad)", { XX
} },
5628 { "(bad)", { XX
} },
5629 { "(bad)", { XX
} },
5630 { "(bad)", { XX
} },
5631 { "(bad)", { XX
} },
5632 { "(bad)", { XX
} },
5633 { "(bad)", { XX
} },
5634 { "(bad)", { XX
} },
5636 { "(bad)", { XX
} },
5637 { "(bad)", { XX
} },
5638 { "(bad)", { XX
} },
5639 { "(bad)", { XX
} },
5640 { "(bad)", { XX
} },
5641 { "(bad)", { XX
} },
5642 { "(bad)", { XX
} },
5643 { "(bad)", { XX
} },
5645 { "(bad)", { XX
} },
5646 { "(bad)", { XX
} },
5647 { "(bad)", { XX
} },
5648 { "(bad)", { XX
} },
5649 { "(bad)", { XX
} },
5650 { "(bad)", { XX
} },
5651 { "(bad)", { XX
} },
5652 { "(bad)", { XX
} },
5654 { "(bad)", { XX
} },
5655 { "(bad)", { XX
} },
5656 { "(bad)", { XX
} },
5657 { "(bad)", { XX
} },
5658 { "(bad)", { XX
} },
5659 { "(bad)", { XX
} },
5660 { "(bad)", { XX
} },
5661 { "(bad)", { XX
} },
5663 { PREFIX_TABLE (PREFIX_0F3880
) },
5664 { PREFIX_TABLE (PREFIX_0F3881
) },
5665 { "(bad)", { XX
} },
5666 { "(bad)", { XX
} },
5667 { "(bad)", { XX
} },
5668 { "(bad)", { XX
} },
5669 { "(bad)", { XX
} },
5670 { "(bad)", { XX
} },
5672 { "(bad)", { XX
} },
5673 { "(bad)", { XX
} },
5674 { "(bad)", { XX
} },
5675 { "(bad)", { XX
} },
5676 { "(bad)", { XX
} },
5677 { "(bad)", { XX
} },
5678 { "(bad)", { XX
} },
5679 { "(bad)", { XX
} },
5681 { "(bad)", { XX
} },
5682 { "(bad)", { XX
} },
5683 { "(bad)", { XX
} },
5684 { "(bad)", { XX
} },
5685 { "(bad)", { XX
} },
5686 { "(bad)", { XX
} },
5687 { "(bad)", { XX
} },
5688 { "(bad)", { XX
} },
5690 { "(bad)", { XX
} },
5691 { "(bad)", { XX
} },
5692 { "(bad)", { XX
} },
5693 { "(bad)", { XX
} },
5694 { "(bad)", { XX
} },
5695 { "(bad)", { XX
} },
5696 { "(bad)", { XX
} },
5697 { "(bad)", { XX
} },
5699 { "(bad)", { XX
} },
5700 { "(bad)", { XX
} },
5701 { "(bad)", { XX
} },
5702 { "(bad)", { XX
} },
5703 { "(bad)", { XX
} },
5704 { "(bad)", { XX
} },
5705 { "(bad)", { XX
} },
5706 { "(bad)", { XX
} },
5708 { "(bad)", { XX
} },
5709 { "(bad)", { XX
} },
5710 { "(bad)", { XX
} },
5711 { "(bad)", { XX
} },
5712 { "(bad)", { XX
} },
5713 { "(bad)", { XX
} },
5714 { "(bad)", { XX
} },
5715 { "(bad)", { XX
} },
5717 { "(bad)", { XX
} },
5718 { "(bad)", { XX
} },
5719 { "(bad)", { XX
} },
5720 { "(bad)", { XX
} },
5721 { "(bad)", { XX
} },
5722 { "(bad)", { XX
} },
5723 { "(bad)", { XX
} },
5724 { "(bad)", { XX
} },
5726 { "(bad)", { XX
} },
5727 { "(bad)", { XX
} },
5728 { "(bad)", { XX
} },
5729 { "(bad)", { XX
} },
5730 { "(bad)", { XX
} },
5731 { "(bad)", { XX
} },
5732 { "(bad)", { XX
} },
5733 { "(bad)", { XX
} },
5735 { "(bad)", { XX
} },
5736 { "(bad)", { XX
} },
5737 { "(bad)", { XX
} },
5738 { "(bad)", { XX
} },
5739 { "(bad)", { XX
} },
5740 { "(bad)", { XX
} },
5741 { "(bad)", { XX
} },
5742 { "(bad)", { XX
} },
5744 { "(bad)", { XX
} },
5745 { "(bad)", { XX
} },
5746 { "(bad)", { XX
} },
5747 { "(bad)", { XX
} },
5748 { "(bad)", { XX
} },
5749 { "(bad)", { XX
} },
5750 { "(bad)", { XX
} },
5751 { "(bad)", { XX
} },
5753 { "(bad)", { XX
} },
5754 { "(bad)", { XX
} },
5755 { "(bad)", { XX
} },
5756 { "(bad)", { XX
} },
5757 { "(bad)", { XX
} },
5758 { "(bad)", { XX
} },
5759 { "(bad)", { XX
} },
5760 { "(bad)", { XX
} },
5762 { "(bad)", { XX
} },
5763 { "(bad)", { XX
} },
5764 { "(bad)", { XX
} },
5765 { PREFIX_TABLE (PREFIX_0F38DB
) },
5766 { PREFIX_TABLE (PREFIX_0F38DC
) },
5767 { PREFIX_TABLE (PREFIX_0F38DD
) },
5768 { PREFIX_TABLE (PREFIX_0F38DE
) },
5769 { PREFIX_TABLE (PREFIX_0F38DF
) },
5771 { "(bad)", { XX
} },
5772 { "(bad)", { XX
} },
5773 { "(bad)", { XX
} },
5774 { "(bad)", { XX
} },
5775 { "(bad)", { XX
} },
5776 { "(bad)", { XX
} },
5777 { "(bad)", { XX
} },
5778 { "(bad)", { XX
} },
5780 { "(bad)", { XX
} },
5781 { "(bad)", { XX
} },
5782 { "(bad)", { XX
} },
5783 { "(bad)", { XX
} },
5784 { "(bad)", { XX
} },
5785 { "(bad)", { XX
} },
5786 { "(bad)", { XX
} },
5787 { "(bad)", { XX
} },
5789 { PREFIX_TABLE (PREFIX_0F38F0
) },
5790 { PREFIX_TABLE (PREFIX_0F38F1
) },
5791 { "(bad)", { XX
} },
5792 { "(bad)", { XX
} },
5793 { "(bad)", { XX
} },
5794 { "(bad)", { XX
} },
5795 { "(bad)", { XX
} },
5796 { "(bad)", { XX
} },
5798 { "(bad)", { XX
} },
5799 { "(bad)", { XX
} },
5800 { "(bad)", { XX
} },
5801 { "(bad)", { XX
} },
5802 { "(bad)", { XX
} },
5803 { "(bad)", { XX
} },
5804 { "(bad)", { XX
} },
5805 { "(bad)", { XX
} },
5807 /* THREE_BYTE_0F3A */
5810 { "(bad)", { XX
} },
5811 { "(bad)", { XX
} },
5812 { "(bad)", { XX
} },
5813 { "(bad)", { XX
} },
5814 { "(bad)", { XX
} },
5815 { "(bad)", { XX
} },
5816 { "(bad)", { XX
} },
5817 { "(bad)", { XX
} },
5819 { PREFIX_TABLE (PREFIX_0F3A08
) },
5820 { PREFIX_TABLE (PREFIX_0F3A09
) },
5821 { PREFIX_TABLE (PREFIX_0F3A0A
) },
5822 { PREFIX_TABLE (PREFIX_0F3A0B
) },
5823 { PREFIX_TABLE (PREFIX_0F3A0C
) },
5824 { PREFIX_TABLE (PREFIX_0F3A0D
) },
5825 { PREFIX_TABLE (PREFIX_0F3A0E
) },
5826 { "palignr", { MX
, EM
, Ib
} },
5828 { "(bad)", { XX
} },
5829 { "(bad)", { XX
} },
5830 { "(bad)", { XX
} },
5831 { "(bad)", { XX
} },
5832 { PREFIX_TABLE (PREFIX_0F3A14
) },
5833 { PREFIX_TABLE (PREFIX_0F3A15
) },
5834 { PREFIX_TABLE (PREFIX_0F3A16
) },
5835 { PREFIX_TABLE (PREFIX_0F3A17
) },
5837 { "(bad)", { XX
} },
5838 { "(bad)", { XX
} },
5839 { "(bad)", { XX
} },
5840 { "(bad)", { XX
} },
5841 { "(bad)", { XX
} },
5842 { "(bad)", { XX
} },
5843 { "(bad)", { XX
} },
5844 { "(bad)", { XX
} },
5846 { PREFIX_TABLE (PREFIX_0F3A20
) },
5847 { PREFIX_TABLE (PREFIX_0F3A21
) },
5848 { PREFIX_TABLE (PREFIX_0F3A22
) },
5849 { "(bad)", { XX
} },
5850 { "(bad)", { XX
} },
5851 { "(bad)", { XX
} },
5852 { "(bad)", { XX
} },
5853 { "(bad)", { XX
} },
5855 { "(bad)", { XX
} },
5856 { "(bad)", { XX
} },
5857 { "(bad)", { XX
} },
5858 { "(bad)", { XX
} },
5859 { "(bad)", { XX
} },
5860 { "(bad)", { XX
} },
5861 { "(bad)", { XX
} },
5862 { "(bad)", { XX
} },
5864 { "(bad)", { XX
} },
5865 { "(bad)", { XX
} },
5866 { "(bad)", { XX
} },
5867 { "(bad)", { XX
} },
5868 { "(bad)", { XX
} },
5869 { "(bad)", { XX
} },
5870 { "(bad)", { XX
} },
5871 { "(bad)", { XX
} },
5873 { "(bad)", { XX
} },
5874 { "(bad)", { XX
} },
5875 { "(bad)", { XX
} },
5876 { "(bad)", { XX
} },
5877 { "(bad)", { XX
} },
5878 { "(bad)", { XX
} },
5879 { "(bad)", { XX
} },
5880 { "(bad)", { XX
} },
5882 { PREFIX_TABLE (PREFIX_0F3A40
) },
5883 { PREFIX_TABLE (PREFIX_0F3A41
) },
5884 { PREFIX_TABLE (PREFIX_0F3A42
) },
5885 { "(bad)", { XX
} },
5886 { PREFIX_TABLE (PREFIX_0F3A44
) },
5887 { "(bad)", { XX
} },
5888 { "(bad)", { XX
} },
5889 { "(bad)", { XX
} },
5891 { "(bad)", { XX
} },
5892 { "(bad)", { XX
} },
5893 { "(bad)", { XX
} },
5894 { "(bad)", { XX
} },
5895 { "(bad)", { XX
} },
5896 { "(bad)", { XX
} },
5897 { "(bad)", { XX
} },
5898 { "(bad)", { XX
} },
5900 { "(bad)", { XX
} },
5901 { "(bad)", { XX
} },
5902 { "(bad)", { XX
} },
5903 { "(bad)", { XX
} },
5904 { "(bad)", { XX
} },
5905 { "(bad)", { XX
} },
5906 { "(bad)", { XX
} },
5907 { "(bad)", { XX
} },
5909 { "(bad)", { XX
} },
5910 { "(bad)", { XX
} },
5911 { "(bad)", { XX
} },
5912 { "(bad)", { XX
} },
5913 { "(bad)", { XX
} },
5914 { "(bad)", { XX
} },
5915 { "(bad)", { XX
} },
5916 { "(bad)", { XX
} },
5918 { PREFIX_TABLE (PREFIX_0F3A60
) },
5919 { PREFIX_TABLE (PREFIX_0F3A61
) },
5920 { PREFIX_TABLE (PREFIX_0F3A62
) },
5921 { PREFIX_TABLE (PREFIX_0F3A63
) },
5922 { "(bad)", { XX
} },
5923 { "(bad)", { XX
} },
5924 { "(bad)", { XX
} },
5925 { "(bad)", { XX
} },
5927 { "(bad)", { XX
} },
5928 { "(bad)", { XX
} },
5929 { "(bad)", { XX
} },
5930 { "(bad)", { XX
} },
5931 { "(bad)", { XX
} },
5932 { "(bad)", { XX
} },
5933 { "(bad)", { XX
} },
5934 { "(bad)", { XX
} },
5936 { "(bad)", { XX
} },
5937 { "(bad)", { XX
} },
5938 { "(bad)", { XX
} },
5939 { "(bad)", { XX
} },
5940 { "(bad)", { XX
} },
5941 { "(bad)", { XX
} },
5942 { "(bad)", { XX
} },
5943 { "(bad)", { XX
} },
5945 { "(bad)", { XX
} },
5946 { "(bad)", { XX
} },
5947 { "(bad)", { XX
} },
5948 { "(bad)", { XX
} },
5949 { "(bad)", { XX
} },
5950 { "(bad)", { XX
} },
5951 { "(bad)", { XX
} },
5952 { "(bad)", { XX
} },
5954 { "(bad)", { XX
} },
5955 { "(bad)", { XX
} },
5956 { "(bad)", { XX
} },
5957 { "(bad)", { XX
} },
5958 { "(bad)", { XX
} },
5959 { "(bad)", { XX
} },
5960 { "(bad)", { XX
} },
5961 { "(bad)", { XX
} },
5963 { "(bad)", { XX
} },
5964 { "(bad)", { XX
} },
5965 { "(bad)", { XX
} },
5966 { "(bad)", { XX
} },
5967 { "(bad)", { XX
} },
5968 { "(bad)", { XX
} },
5969 { "(bad)", { XX
} },
5970 { "(bad)", { XX
} },
5972 { "(bad)", { XX
} },
5973 { "(bad)", { XX
} },
5974 { "(bad)", { XX
} },
5975 { "(bad)", { XX
} },
5976 { "(bad)", { XX
} },
5977 { "(bad)", { XX
} },
5978 { "(bad)", { XX
} },
5979 { "(bad)", { XX
} },
5981 { "(bad)", { XX
} },
5982 { "(bad)", { XX
} },
5983 { "(bad)", { XX
} },
5984 { "(bad)", { XX
} },
5985 { "(bad)", { XX
} },
5986 { "(bad)", { XX
} },
5987 { "(bad)", { XX
} },
5988 { "(bad)", { XX
} },
5990 { "(bad)", { XX
} },
5991 { "(bad)", { XX
} },
5992 { "(bad)", { XX
} },
5993 { "(bad)", { XX
} },
5994 { "(bad)", { XX
} },
5995 { "(bad)", { XX
} },
5996 { "(bad)", { XX
} },
5997 { "(bad)", { XX
} },
5999 { "(bad)", { XX
} },
6000 { "(bad)", { XX
} },
6001 { "(bad)", { XX
} },
6002 { "(bad)", { XX
} },
6003 { "(bad)", { XX
} },
6004 { "(bad)", { XX
} },
6005 { "(bad)", { XX
} },
6006 { "(bad)", { XX
} },
6008 { "(bad)", { XX
} },
6009 { "(bad)", { XX
} },
6010 { "(bad)", { XX
} },
6011 { "(bad)", { XX
} },
6012 { "(bad)", { XX
} },
6013 { "(bad)", { XX
} },
6014 { "(bad)", { XX
} },
6015 { "(bad)", { XX
} },
6017 { "(bad)", { XX
} },
6018 { "(bad)", { XX
} },
6019 { "(bad)", { XX
} },
6020 { "(bad)", { XX
} },
6021 { "(bad)", { XX
} },
6022 { "(bad)", { XX
} },
6023 { "(bad)", { XX
} },
6024 { "(bad)", { XX
} },
6026 { "(bad)", { XX
} },
6027 { "(bad)", { XX
} },
6028 { "(bad)", { XX
} },
6029 { "(bad)", { XX
} },
6030 { "(bad)", { XX
} },
6031 { "(bad)", { XX
} },
6032 { "(bad)", { XX
} },
6033 { "(bad)", { XX
} },
6035 { "(bad)", { XX
} },
6036 { "(bad)", { XX
} },
6037 { "(bad)", { XX
} },
6038 { "(bad)", { XX
} },
6039 { "(bad)", { XX
} },
6040 { "(bad)", { XX
} },
6041 { "(bad)", { XX
} },
6042 { "(bad)", { XX
} },
6044 { "(bad)", { XX
} },
6045 { "(bad)", { XX
} },
6046 { "(bad)", { XX
} },
6047 { "(bad)", { XX
} },
6048 { "(bad)", { XX
} },
6049 { "(bad)", { XX
} },
6050 { "(bad)", { XX
} },
6051 { "(bad)", { XX
} },
6053 { "(bad)", { XX
} },
6054 { "(bad)", { XX
} },
6055 { "(bad)", { XX
} },
6056 { "(bad)", { XX
} },
6057 { "(bad)", { XX
} },
6058 { "(bad)", { XX
} },
6059 { "(bad)", { XX
} },
6060 { PREFIX_TABLE (PREFIX_0F3ADF
) },
6062 { "(bad)", { XX
} },
6063 { "(bad)", { XX
} },
6064 { "(bad)", { XX
} },
6065 { "(bad)", { XX
} },
6066 { "(bad)", { XX
} },
6067 { "(bad)", { XX
} },
6068 { "(bad)", { XX
} },
6069 { "(bad)", { XX
} },
6071 { "(bad)", { XX
} },
6072 { "(bad)", { XX
} },
6073 { "(bad)", { XX
} },
6074 { "(bad)", { XX
} },
6075 { "(bad)", { XX
} },
6076 { "(bad)", { XX
} },
6077 { "(bad)", { XX
} },
6078 { "(bad)", { XX
} },
6080 { "(bad)", { XX
} },
6081 { "(bad)", { XX
} },
6082 { "(bad)", { XX
} },
6083 { "(bad)", { XX
} },
6084 { "(bad)", { XX
} },
6085 { "(bad)", { XX
} },
6086 { "(bad)", { XX
} },
6087 { "(bad)", { XX
} },
6089 { "(bad)", { XX
} },
6090 { "(bad)", { XX
} },
6091 { "(bad)", { XX
} },
6092 { "(bad)", { XX
} },
6093 { "(bad)", { XX
} },
6094 { "(bad)", { XX
} },
6095 { "(bad)", { XX
} },
6096 { "(bad)", { XX
} },
6099 /* THREE_BYTE_0F7A */
6102 { "(bad)", { XX
} },
6103 { "(bad)", { XX
} },
6104 { "(bad)", { XX
} },
6105 { "(bad)", { XX
} },
6106 { "(bad)", { XX
} },
6107 { "(bad)", { XX
} },
6108 { "(bad)", { XX
} },
6109 { "(bad)", { XX
} },
6111 { "(bad)", { XX
} },
6112 { "(bad)", { XX
} },
6113 { "(bad)", { XX
} },
6114 { "(bad)", { XX
} },
6115 { "(bad)", { XX
} },
6116 { "(bad)", { XX
} },
6117 { "(bad)", { XX
} },
6118 { "(bad)", { XX
} },
6120 { "(bad)", { XX
} },
6121 { "(bad)", { XX
} },
6122 { "(bad)", { XX
} },
6123 { "(bad)", { XX
} },
6124 { "(bad)", { XX
} },
6125 { "(bad)", { XX
} },
6126 { "(bad)", { XX
} },
6127 { "(bad)", { XX
} },
6129 { "(bad)", { XX
} },
6130 { "(bad)", { XX
} },
6131 { "(bad)", { XX
} },
6132 { "(bad)", { XX
} },
6133 { "(bad)", { XX
} },
6134 { "(bad)", { XX
} },
6135 { "(bad)", { XX
} },
6136 { "(bad)", { XX
} },
6138 { "ptest", { XX
} },
6139 { "(bad)", { XX
} },
6140 { "(bad)", { XX
} },
6141 { "(bad)", { XX
} },
6142 { "(bad)", { XX
} },
6143 { "(bad)", { XX
} },
6144 { "(bad)", { XX
} },
6145 { "(bad)", { XX
} },
6147 { "(bad)", { XX
} },
6148 { "(bad)", { XX
} },
6149 { "(bad)", { XX
} },
6150 { "(bad)", { XX
} },
6151 { "(bad)", { XX
} },
6152 { "(bad)", { XX
} },
6153 { "(bad)", { XX
} },
6154 { "(bad)", { XX
} },
6156 { "(bad)", { XX
} },
6157 { "(bad)", { XX
} },
6158 { "(bad)", { XX
} },
6159 { "(bad)", { XX
} },
6160 { "(bad)", { XX
} },
6161 { "(bad)", { XX
} },
6162 { "(bad)", { XX
} },
6163 { "(bad)", { XX
} },
6165 { "(bad)", { XX
} },
6166 { "(bad)", { XX
} },
6167 { "(bad)", { XX
} },
6168 { "(bad)", { XX
} },
6169 { "(bad)", { XX
} },
6170 { "(bad)", { XX
} },
6171 { "(bad)", { XX
} },
6172 { "(bad)", { XX
} },
6174 { "(bad)", { XX
} },
6175 { "phaddbw", { XM
, EXq
} },
6176 { "phaddbd", { XM
, EXq
} },
6177 { "phaddbq", { XM
, EXq
} },
6178 { "(bad)", { XX
} },
6179 { "(bad)", { XX
} },
6180 { "phaddwd", { XM
, EXq
} },
6181 { "phaddwq", { XM
, EXq
} },
6183 { "(bad)", { XX
} },
6184 { "(bad)", { XX
} },
6185 { "(bad)", { XX
} },
6186 { "phadddq", { XM
, EXq
} },
6187 { "(bad)", { XX
} },
6188 { "(bad)", { XX
} },
6189 { "(bad)", { XX
} },
6190 { "(bad)", { XX
} },
6192 { "(bad)", { XX
} },
6193 { "phaddubw", { XM
, EXq
} },
6194 { "phaddubd", { XM
, EXq
} },
6195 { "phaddubq", { XM
, EXq
} },
6196 { "(bad)", { XX
} },
6197 { "(bad)", { XX
} },
6198 { "phadduwd", { XM
, EXq
} },
6199 { "phadduwq", { XM
, EXq
} },
6201 { "(bad)", { XX
} },
6202 { "(bad)", { XX
} },
6203 { "(bad)", { XX
} },
6204 { "phaddudq", { XM
, EXq
} },
6205 { "(bad)", { XX
} },
6206 { "(bad)", { XX
} },
6207 { "(bad)", { XX
} },
6208 { "(bad)", { XX
} },
6210 { "(bad)", { XX
} },
6211 { "phsubbw", { XM
, EXq
} },
6212 { "phsubbd", { XM
, EXq
} },
6213 { "phsubbq", { XM
, EXq
} },
6214 { "(bad)", { XX
} },
6215 { "(bad)", { XX
} },
6216 { "(bad)", { XX
} },
6217 { "(bad)", { XX
} },
6219 { "(bad)", { XX
} },
6220 { "(bad)", { XX
} },
6221 { "(bad)", { XX
} },
6222 { "(bad)", { XX
} },
6223 { "(bad)", { XX
} },
6224 { "(bad)", { XX
} },
6225 { "(bad)", { XX
} },
6226 { "(bad)", { XX
} },
6228 { "(bad)", { XX
} },
6229 { "(bad)", { XX
} },
6230 { "(bad)", { XX
} },
6231 { "(bad)", { XX
} },
6232 { "(bad)", { XX
} },
6233 { "(bad)", { XX
} },
6234 { "(bad)", { XX
} },
6235 { "(bad)", { XX
} },
6237 { "(bad)", { XX
} },
6238 { "(bad)", { XX
} },
6239 { "(bad)", { XX
} },
6240 { "(bad)", { XX
} },
6241 { "(bad)", { XX
} },
6242 { "(bad)", { XX
} },
6243 { "(bad)", { XX
} },
6244 { "(bad)", { XX
} },
6246 { "(bad)", { XX
} },
6247 { "(bad)", { XX
} },
6248 { "(bad)", { XX
} },
6249 { "(bad)", { XX
} },
6250 { "(bad)", { XX
} },
6251 { "(bad)", { XX
} },
6252 { "(bad)", { XX
} },
6253 { "(bad)", { XX
} },
6255 { "(bad)", { XX
} },
6256 { "(bad)", { XX
} },
6257 { "(bad)", { XX
} },
6258 { "(bad)", { XX
} },
6259 { "(bad)", { XX
} },
6260 { "(bad)", { XX
} },
6261 { "(bad)", { XX
} },
6262 { "(bad)", { XX
} },
6264 { "(bad)", { XX
} },
6265 { "(bad)", { XX
} },
6266 { "(bad)", { XX
} },
6267 { "(bad)", { XX
} },
6268 { "(bad)", { XX
} },
6269 { "(bad)", { XX
} },
6270 { "(bad)", { XX
} },
6271 { "(bad)", { XX
} },
6273 { "(bad)", { XX
} },
6274 { "(bad)", { XX
} },
6275 { "(bad)", { XX
} },
6276 { "(bad)", { XX
} },
6277 { "(bad)", { XX
} },
6278 { "(bad)", { XX
} },
6279 { "(bad)", { XX
} },
6280 { "(bad)", { XX
} },
6282 { "(bad)", { XX
} },
6283 { "(bad)", { XX
} },
6284 { "(bad)", { XX
} },
6285 { "(bad)", { XX
} },
6286 { "(bad)", { XX
} },
6287 { "(bad)", { XX
} },
6288 { "(bad)", { XX
} },
6289 { "(bad)", { XX
} },
6291 { "(bad)", { XX
} },
6292 { "(bad)", { XX
} },
6293 { "(bad)", { XX
} },
6294 { "(bad)", { XX
} },
6295 { "(bad)", { XX
} },
6296 { "(bad)", { XX
} },
6297 { "(bad)", { XX
} },
6298 { "(bad)", { XX
} },
6300 { "(bad)", { XX
} },
6301 { "(bad)", { XX
} },
6302 { "(bad)", { XX
} },
6303 { "(bad)", { XX
} },
6304 { "(bad)", { XX
} },
6305 { "(bad)", { XX
} },
6306 { "(bad)", { XX
} },
6307 { "(bad)", { XX
} },
6309 { "(bad)", { XX
} },
6310 { "(bad)", { XX
} },
6311 { "(bad)", { XX
} },
6312 { "(bad)", { XX
} },
6313 { "(bad)", { XX
} },
6314 { "(bad)", { XX
} },
6315 { "(bad)", { XX
} },
6316 { "(bad)", { XX
} },
6318 { "(bad)", { XX
} },
6319 { "(bad)", { XX
} },
6320 { "(bad)", { XX
} },
6321 { "(bad)", { XX
} },
6322 { "(bad)", { XX
} },
6323 { "(bad)", { XX
} },
6324 { "(bad)", { XX
} },
6325 { "(bad)", { XX
} },
6327 { "(bad)", { XX
} },
6328 { "(bad)", { XX
} },
6329 { "(bad)", { XX
} },
6330 { "(bad)", { XX
} },
6331 { "(bad)", { XX
} },
6332 { "(bad)", { XX
} },
6333 { "(bad)", { XX
} },
6334 { "(bad)", { XX
} },
6336 { "(bad)", { XX
} },
6337 { "(bad)", { XX
} },
6338 { "(bad)", { XX
} },
6339 { "(bad)", { XX
} },
6340 { "(bad)", { XX
} },
6341 { "(bad)", { XX
} },
6342 { "(bad)", { XX
} },
6343 { "(bad)", { XX
} },
6345 { "(bad)", { XX
} },
6346 { "(bad)", { XX
} },
6347 { "(bad)", { XX
} },
6348 { "(bad)", { XX
} },
6349 { "(bad)", { XX
} },
6350 { "(bad)", { XX
} },
6351 { "(bad)", { XX
} },
6352 { "(bad)", { XX
} },
6354 { "(bad)", { XX
} },
6355 { "(bad)", { XX
} },
6356 { "(bad)", { XX
} },
6357 { "(bad)", { XX
} },
6358 { "(bad)", { XX
} },
6359 { "(bad)", { XX
} },
6360 { "(bad)", { XX
} },
6361 { "(bad)", { XX
} },
6363 { "(bad)", { XX
} },
6364 { "(bad)", { XX
} },
6365 { "(bad)", { XX
} },
6366 { "(bad)", { XX
} },
6367 { "(bad)", { XX
} },
6368 { "(bad)", { XX
} },
6369 { "(bad)", { XX
} },
6370 { "(bad)", { XX
} },
6372 { "(bad)", { XX
} },
6373 { "(bad)", { XX
} },
6374 { "(bad)", { XX
} },
6375 { "(bad)", { XX
} },
6376 { "(bad)", { XX
} },
6377 { "(bad)", { XX
} },
6378 { "(bad)", { XX
} },
6379 { "(bad)", { XX
} },
6381 { "(bad)", { XX
} },
6382 { "(bad)", { XX
} },
6383 { "(bad)", { XX
} },
6384 { "(bad)", { XX
} },
6385 { "(bad)", { XX
} },
6386 { "(bad)", { XX
} },
6387 { "(bad)", { XX
} },
6388 { "(bad)", { XX
} },
6392 static const struct dis386 xop_table
[][256] = {
6396 { "(bad)", { XX
} },
6397 { "(bad)", { XX
} },
6398 { "(bad)", { XX
} },
6399 { "(bad)", { XX
} },
6400 { "(bad)", { XX
} },
6401 { "(bad)", { XX
} },
6402 { "(bad)", { XX
} },
6403 { "(bad)", { XX
} },
6405 { "(bad)", { XX
} },
6406 { "(bad)", { XX
} },
6407 { "(bad)", { XX
} },
6408 { "(bad)", { XX
} },
6409 { "(bad)", { XX
} },
6410 { "(bad)", { XX
} },
6411 { "(bad)", { XX
} },
6412 { "(bad)", { XX
} },
6414 { "(bad)", { XX
} },
6415 { "(bad)", { XX
} },
6416 { "(bad)", { XX
} },
6417 { "(bad)", { XX
} },
6418 { "(bad)", { XX
} },
6419 { "(bad)", { XX
} },
6420 { "(bad)", { XX
} },
6421 { "(bad)", { XX
} },
6423 { "(bad)", { XX
} },
6424 { "(bad)", { XX
} },
6425 { "(bad)", { XX
} },
6426 { "(bad)", { XX
} },
6427 { "(bad)", { XX
} },
6428 { "(bad)", { XX
} },
6429 { "(bad)", { XX
} },
6430 { "(bad)", { XX
} },
6432 { "(bad)", { XX
} },
6433 { "(bad)", { XX
} },
6434 { "(bad)", { XX
} },
6435 { "(bad)", { XX
} },
6436 { "(bad)", { XX
} },
6437 { "(bad)", { XX
} },
6438 { "(bad)", { XX
} },
6439 { "(bad)", { XX
} },
6441 { "(bad)", { XX
} },
6442 { "(bad)", { XX
} },
6443 { "(bad)", { XX
} },
6444 { "(bad)", { XX
} },
6445 { "(bad)", { XX
} },
6446 { "(bad)", { XX
} },
6447 { "(bad)", { XX
} },
6448 { "(bad)", { XX
} },
6450 { "(bad)", { XX
} },
6451 { "(bad)", { XX
} },
6452 { "(bad)", { XX
} },
6453 { "(bad)", { XX
} },
6454 { "(bad)", { XX
} },
6455 { "(bad)", { XX
} },
6456 { "(bad)", { XX
} },
6457 { "(bad)", { XX
} },
6459 { "(bad)", { XX
} },
6460 { "(bad)", { XX
} },
6461 { "(bad)", { XX
} },
6462 { "(bad)", { XX
} },
6463 { "(bad)", { XX
} },
6464 { "(bad)", { XX
} },
6465 { "(bad)", { XX
} },
6466 { "(bad)", { XX
} },
6468 { "(bad)", { XX
} },
6469 { "(bad)", { XX
} },
6470 { "(bad)", { XX
} },
6471 { "(bad)", { XX
} },
6472 { "(bad)", { XX
} },
6473 { "(bad)", { XX
} },
6474 { "(bad)", { XX
} },
6475 { "(bad)", { XX
} },
6477 { "(bad)", { XX
} },
6478 { "(bad)", { XX
} },
6479 { "(bad)", { XX
} },
6480 { "(bad)", { XX
} },
6481 { "(bad)", { XX
} },
6482 { "(bad)", { XX
} },
6483 { "(bad)", { XX
} },
6484 { "(bad)", { XX
} },
6486 { "(bad)", { XX
} },
6487 { "(bad)", { XX
} },
6488 { "(bad)", { XX
} },
6489 { "(bad)", { XX
} },
6490 { "(bad)", { XX
} },
6491 { "(bad)", { XX
} },
6492 { "(bad)", { XX
} },
6493 { "(bad)", { XX
} },
6495 { "(bad)", { XX
} },
6496 { "(bad)", { XX
} },
6497 { "(bad)", { XX
} },
6498 { "(bad)", { XX
} },
6499 { "(bad)", { XX
} },
6500 { "(bad)", { XX
} },
6501 { "(bad)", { XX
} },
6502 { "(bad)", { XX
} },
6504 { "(bad)", { XX
} },
6505 { "(bad)", { XX
} },
6506 { "(bad)", { XX
} },
6507 { "(bad)", { XX
} },
6508 { "(bad)", { XX
} },
6509 { "(bad)", { XX
} },
6510 { "(bad)", { XX
} },
6511 { "(bad)", { XX
} },
6513 { "(bad)", { XX
} },
6514 { "(bad)", { XX
} },
6515 { "(bad)", { XX
} },
6516 { "(bad)", { XX
} },
6517 { "(bad)", { XX
} },
6518 { "(bad)", { XX
} },
6519 { "(bad)", { XX
} },
6520 { "(bad)", { XX
} },
6522 { "(bad)", { XX
} },
6523 { "(bad)", { XX
} },
6524 { "(bad)", { XX
} },
6525 { "(bad)", { XX
} },
6526 { "(bad)", { XX
} },
6527 { "(bad)", { XX
} },
6528 { "(bad)", { XX
} },
6529 { "(bad)", { XX
} },
6531 { "(bad)", { XX
} },
6532 { "(bad)", { XX
} },
6533 { "(bad)", { XX
} },
6534 { "(bad)", { XX
} },
6535 { "(bad)", { XX
} },
6536 { "(bad)", { XX
} },
6537 { "(bad)", { XX
} },
6538 { "(bad)", { XX
} },
6540 { "(bad)", { XX
} },
6541 { "(bad)", { XX
} },
6542 { "(bad)", { XX
} },
6543 { "(bad)", { XX
} },
6544 { "(bad)", { XX
} },
6545 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6546 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6547 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6549 { "(bad)", { XX
} },
6550 { "(bad)", { XX
} },
6551 { "(bad)", { XX
} },
6552 { "(bad)", { XX
} },
6553 { "(bad)", { XX
} },
6554 { "(bad)", { XX
} },
6555 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6556 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6558 { "(bad)", { XX
} },
6559 { "(bad)", { XX
} },
6560 { "(bad)", { XX
} },
6561 { "(bad)", { XX
} },
6562 { "(bad)", { XX
} },
6563 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6564 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6565 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6567 { "(bad)", { XX
} },
6568 { "(bad)", { XX
} },
6569 { "(bad)", { XX
} },
6570 { "(bad)", { XX
} },
6571 { "(bad)", { XX
} },
6572 { "(bad)", { XX
} },
6573 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6574 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6576 { "(bad)", { XX
} },
6577 { "(bad)", { XX
} },
6578 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6579 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6580 { "(bad)", { XX
} },
6581 { "(bad)", { XX
} },
6582 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6583 { "(bad)", { XX
} },
6585 { "(bad)", { XX
} },
6586 { "(bad)", { XX
} },
6587 { "(bad)", { XX
} },
6588 { "(bad)", { XX
} },
6589 { "(bad)", { XX
} },
6590 { "(bad)", { XX
} },
6591 { "(bad)", { XX
} },
6592 { "(bad)", { XX
} },
6594 { "(bad)", { XX
} },
6595 { "(bad)", { XX
} },
6596 { "(bad)", { XX
} },
6597 { "(bad)", { XX
} },
6598 { "(bad)", { XX
} },
6599 { "(bad)", { XX
} },
6600 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
} },
6601 { "(bad)", { XX
} },
6603 { "(bad)", { XX
} },
6604 { "(bad)", { XX
} },
6605 { "(bad)", { XX
} },
6606 { "(bad)", { XX
} },
6607 { "(bad)", { XX
} },
6608 { "(bad)", { XX
} },
6609 { "(bad)", { XX
} },
6610 { "(bad)", { XX
} },
6612 { "vprotb", { XM
, Vex_2src_1
, Ib
} },
6613 { "vprotw", { XM
, Vex_2src_1
, Ib
} },
6614 { "vprotd", { XM
, Vex_2src_1
, Ib
} },
6615 { "vprotq", { XM
, Vex_2src_1
, Ib
} },
6616 { "(bad)", { XX
} },
6617 { "(bad)", { XX
} },
6618 { "(bad)", { XX
} },
6619 { "(bad)", { XX
} },
6621 { "(bad)", { XX
} },
6622 { "(bad)", { XX
} },
6623 { "(bad)", { XX
} },
6624 { "(bad)", { XX
} },
6625 { "vpcomb", { XM
, Vex128
, EXx
, Ib
} },
6626 { "vpcomw", { XM
, Vex128
, EXx
, Ib
} },
6627 { "vpcomd", { XM
, Vex128
, EXx
, Ib
} },
6628 { "vpcomq", { XM
, Vex128
, EXx
, Ib
} },
6630 { "(bad)", { XX
} },
6631 { "(bad)", { XX
} },
6632 { "(bad)", { XX
} },
6633 { "(bad)", { XX
} },
6634 { "(bad)", { XX
} },
6635 { "(bad)", { XX
} },
6636 { "(bad)", { XX
} },
6637 { "(bad)", { XX
} },
6639 { "(bad)", { XX
} },
6640 { "(bad)", { XX
} },
6641 { "(bad)", { XX
} },
6642 { "(bad)", { XX
} },
6643 { "(bad)", { XX
} },
6644 { "(bad)", { XX
} },
6645 { "(bad)", { XX
} },
6646 { "(bad)", { XX
} },
6648 { "(bad)", { XX
} },
6649 { "(bad)", { XX
} },
6650 { "(bad)", { XX
} },
6651 { "(bad)", { XX
} },
6652 { "(bad)", { XX
} },
6653 { "(bad)", { XX
} },
6654 { "(bad)", { XX
} },
6655 { "(bad)", { XX
} },
6657 { "(bad)", { XX
} },
6658 { "(bad)", { XX
} },
6659 { "(bad)", { XX
} },
6660 { "(bad)", { XX
} },
6661 { "vpcomub", { XM
, Vex128
, EXx
, Ib
} },
6662 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
} },
6663 { "vpcomud", { XM
, Vex128
, EXx
, Ib
} },
6664 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
} },
6666 { "(bad)", { XX
} },
6667 { "(bad)", { XX
} },
6668 { "(bad)", { XX
} },
6669 { "(bad)", { XX
} },
6670 { "(bad)", { XX
} },
6671 { "(bad)", { XX
} },
6672 { "(bad)", { XX
} },
6673 { "(bad)", { XX
} },
6675 { "(bad)", { XX
} },
6676 { "(bad)", { XX
} },
6677 { "(bad)", { XX
} },
6678 { "(bad)", { XX
} },
6679 { "(bad)", { XX
} },
6680 { "(bad)", { XX
} },
6681 { "(bad)", { XX
} },
6682 { "(bad)", { XX
} },
6687 { "(bad)", { XX
} },
6688 { "(bad)", { XX
} },
6689 { "(bad)", { XX
} },
6690 { "(bad)", { XX
} },
6691 { "(bad)", { XX
} },
6692 { "(bad)", { XX
} },
6693 { "(bad)", { XX
} },
6694 { "(bad)", { XX
} },
6696 { "(bad)", { XX
} },
6697 { "(bad)", { XX
} },
6698 { "(bad)", { XX
} },
6699 { "(bad)", { XX
} },
6700 { "(bad)", { XX
} },
6701 { "(bad)", { XX
} },
6702 { "(bad)", { XX
} },
6703 { "(bad)", { XX
} },
6705 { "(bad)", { XX
} },
6706 { "(bad)", { XX
} },
6707 { REG_TABLE (REG_XOP_LWPCB
) },
6708 { "(bad)", { XX
} },
6709 { "(bad)", { XX
} },
6710 { "(bad)", { XX
} },
6711 { "(bad)", { XX
} },
6712 { "(bad)", { XX
} },
6714 { "(bad)", { XX
} },
6715 { "(bad)", { XX
} },
6716 { "(bad)", { XX
} },
6717 { "(bad)", { XX
} },
6718 { "(bad)", { XX
} },
6719 { "(bad)", { XX
} },
6720 { "(bad)", { XX
} },
6721 { "(bad)", { XX
} },
6723 { "(bad)", { XX
} },
6724 { "(bad)", { XX
} },
6725 { "(bad)", { XX
} },
6726 { "(bad)", { XX
} },
6727 { "(bad)", { XX
} },
6728 { "(bad)", { XX
} },
6729 { "(bad)", { XX
} },
6730 { "(bad)", { XX
} },
6732 { "(bad)", { XX
} },
6733 { "(bad)", { XX
} },
6734 { "(bad)", { XX
} },
6735 { "(bad)", { XX
} },
6736 { "(bad)", { XX
} },
6737 { "(bad)", { XX
} },
6738 { "(bad)", { XX
} },
6739 { "(bad)", { XX
} },
6741 { "(bad)", { XX
} },
6742 { "(bad)", { XX
} },
6743 { "(bad)", { XX
} },
6744 { "(bad)", { XX
} },
6745 { "(bad)", { XX
} },
6746 { "(bad)", { XX
} },
6747 { "(bad)", { XX
} },
6748 { "(bad)", { XX
} },
6750 { "(bad)", { XX
} },
6751 { "(bad)", { XX
} },
6752 { "(bad)", { XX
} },
6753 { "(bad)", { XX
} },
6754 { "(bad)", { XX
} },
6755 { "(bad)", { XX
} },
6756 { "(bad)", { XX
} },
6757 { "(bad)", { XX
} },
6759 { "(bad)", { XX
} },
6760 { "(bad)", { XX
} },
6761 { "(bad)", { XX
} },
6762 { "(bad)", { XX
} },
6763 { "(bad)", { XX
} },
6764 { "(bad)", { XX
} },
6765 { "(bad)", { XX
} },
6766 { "(bad)", { XX
} },
6768 { "(bad)", { XX
} },
6769 { "(bad)", { XX
} },
6770 { "(bad)", { XX
} },
6771 { "(bad)", { XX
} },
6772 { "(bad)", { XX
} },
6773 { "(bad)", { XX
} },
6774 { "(bad)", { XX
} },
6775 { "(bad)", { XX
} },
6777 { "(bad)", { XX
} },
6778 { "(bad)", { XX
} },
6779 { "(bad)", { XX
} },
6780 { "(bad)", { XX
} },
6781 { "(bad)", { XX
} },
6782 { "(bad)", { XX
} },
6783 { "(bad)", { XX
} },
6784 { "(bad)", { XX
} },
6786 { "(bad)", { XX
} },
6787 { "(bad)", { XX
} },
6788 { "(bad)", { XX
} },
6789 { "(bad)", { XX
} },
6790 { "(bad)", { XX
} },
6791 { "(bad)", { XX
} },
6792 { "(bad)", { XX
} },
6793 { "(bad)", { XX
} },
6795 { "(bad)", { XX
} },
6796 { "(bad)", { XX
} },
6797 { "(bad)", { XX
} },
6798 { "(bad)", { XX
} },
6799 { "(bad)", { XX
} },
6800 { "(bad)", { XX
} },
6801 { "(bad)", { XX
} },
6802 { "(bad)", { XX
} },
6804 { "(bad)", { XX
} },
6805 { "(bad)", { XX
} },
6806 { "(bad)", { XX
} },
6807 { "(bad)", { XX
} },
6808 { "(bad)", { XX
} },
6809 { "(bad)", { XX
} },
6810 { "(bad)", { XX
} },
6811 { "(bad)", { XX
} },
6813 { "(bad)", { XX
} },
6814 { "(bad)", { XX
} },
6815 { "(bad)", { XX
} },
6816 { "(bad)", { XX
} },
6817 { "(bad)", { XX
} },
6818 { "(bad)", { XX
} },
6819 { "(bad)", { XX
} },
6820 { "(bad)", { XX
} },
6822 { "(bad)", { XX
} },
6823 { "(bad)", { XX
} },
6824 { "(bad)", { XX
} },
6825 { "(bad)", { XX
} },
6826 { "(bad)", { XX
} },
6827 { "(bad)", { XX
} },
6828 { "(bad)", { XX
} },
6829 { "(bad)", { XX
} },
6831 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80
) },
6832 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81
) },
6833 { "vfrczss", { XM
, EXd
} },
6834 { "vfrczsd", { XM
, EXq
} },
6835 { "(bad)", { XX
} },
6836 { "(bad)", { XX
} },
6837 { "(bad)", { XX
} },
6838 { "(bad)", { XX
} },
6840 { "(bad)", { XX
} },
6841 { "(bad)", { XX
} },
6842 { "(bad)", { XX
} },
6843 { "(bad)", { XX
} },
6844 { "(bad)", { XX
} },
6845 { "(bad)", { XX
} },
6846 { "(bad)", { XX
} },
6847 { "(bad)", { XX
} },
6849 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6850 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6851 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
} },
6852 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6853 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
} },
6854 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6855 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
} },
6856 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6858 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
} },
6859 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
} },
6860 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
} },
6861 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
} },
6862 { "(bad)", { XX
} },
6863 { "(bad)", { XX
} },
6864 { "(bad)", { XX
} },
6865 { "(bad)", { XX
} },
6867 { "(bad)", { XX
} },
6868 { "(bad)", { XX
} },
6869 { "(bad)", { XX
} },
6870 { "(bad)", { XX
} },
6871 { "(bad)", { XX
} },
6872 { "(bad)", { XX
} },
6873 { "(bad)", { XX
} },
6874 { "(bad)", { XX
} },
6876 { "(bad)", { XX
} },
6877 { "(bad)", { XX
} },
6878 { "(bad)", { XX
} },
6879 { "(bad)", { XX
} },
6880 { "(bad)", { XX
} },
6881 { "(bad)", { XX
} },
6882 { "(bad)", { XX
} },
6883 { "(bad)", { XX
} },
6885 { "(bad)", { XX
} },
6886 { "(bad)", { XX
} },
6887 { "(bad)", { XX
} },
6888 { "(bad)", { XX
} },
6889 { "(bad)", { XX
} },
6890 { "(bad)", { XX
} },
6891 { "(bad)", { XX
} },
6892 { "(bad)", { XX
} },
6894 { "(bad)", { XX
} },
6895 { "(bad)", { XX
} },
6896 { "(bad)", { XX
} },
6897 { "(bad)", { XX
} },
6898 { "(bad)", { XX
} },
6899 { "(bad)", { XX
} },
6900 { "(bad)", { XX
} },
6901 { "(bad)", { XX
} },
6903 { "(bad)", { XX
} },
6904 { "vphaddbw", { XM
, EXxmm
} },
6905 { "vphaddbd", { XM
, EXxmm
} },
6906 { "vphaddbq", { XM
, EXxmm
} },
6907 { "(bad)", { XX
} },
6908 { "(bad)", { XX
} },
6909 { "vphaddwd", { XM
, EXxmm
} },
6910 { "vphaddwq", { XM
, EXxmm
} },
6912 { "(bad)", { XX
} },
6913 { "(bad)", { XX
} },
6914 { "(bad)", { XX
} },
6915 { "vphadddq", { XM
, EXxmm
} },
6916 { "(bad)", { XX
} },
6917 { "(bad)", { XX
} },
6918 { "(bad)", { XX
} },
6919 { "(bad)", { XX
} },
6921 { "(bad)", { XX
} },
6922 { "vphaddubw", { XM
, EXxmm
} },
6923 { "vphaddubd", { XM
, EXxmm
} },
6924 { "vphaddubq", { XM
, EXxmm
} },
6925 { "(bad)", { XX
} },
6926 { "(bad)", { XX
} },
6927 { "vphadduwd", { XM
, EXxmm
} },
6928 { "vphadduwq", { XM
, EXxmm
} },
6930 { "(bad)", { XX
} },
6931 { "(bad)", { XX
} },
6932 { "(bad)", { XX
} },
6933 { "vphaddudq", { XM
, EXxmm
} },
6934 { "(bad)", { XX
} },
6935 { "(bad)", { XX
} },
6936 { "(bad)", { XX
} },
6937 { "(bad)", { XX
} },
6939 { "(bad)", { XX
} },
6940 { "vphsubbw", { XM
, EXxmm
} },
6941 { "vphsubwd", { XM
, EXxmm
} },
6942 { "vphsubdq", { XM
, EXxmm
} },
6943 { "(bad)", { XX
} },
6944 { "(bad)", { XX
} },
6945 { "(bad)", { XX
} },
6946 { "(bad)", { XX
} },
6948 { "(bad)", { XX
} },
6949 { "(bad)", { XX
} },
6950 { "(bad)", { XX
} },
6951 { "(bad)", { XX
} },
6952 { "(bad)", { XX
} },
6953 { "(bad)", { XX
} },
6954 { "(bad)", { XX
} },
6955 { "(bad)", { XX
} },
6957 { "(bad)", { XX
} },
6958 { "(bad)", { XX
} },
6959 { "(bad)", { XX
} },
6960 { "(bad)", { XX
} },
6961 { "(bad)", { XX
} },
6962 { "(bad)", { XX
} },
6963 { "(bad)", { XX
} },
6964 { "(bad)", { XX
} },
6966 { "(bad)", { XX
} },
6967 { "(bad)", { XX
} },
6968 { "(bad)", { XX
} },
6969 { "(bad)", { XX
} },
6970 { "(bad)", { XX
} },
6971 { "(bad)", { XX
} },
6972 { "(bad)", { XX
} },
6973 { "(bad)", { XX
} },
6978 { "(bad)", { XX
} },
6979 { "(bad)", { XX
} },
6980 { "(bad)", { XX
} },
6981 { "(bad)", { XX
} },
6982 { "(bad)", { XX
} },
6983 { "(bad)", { XX
} },
6984 { "(bad)", { XX
} },
6985 { "(bad)", { XX
} },
6987 { "(bad)", { XX
} },
6988 { "(bad)", { XX
} },
6989 { "(bad)", { XX
} },
6990 { "(bad)", { XX
} },
6991 { "(bad)", { XX
} },
6992 { "(bad)", { XX
} },
6993 { "(bad)", { XX
} },
6994 { "(bad)", { XX
} },
6996 { "(bad)", { XX
} },
6997 { "(bad)", { XX
} },
6998 { REG_TABLE (REG_XOP_LWP
) },
6999 { "(bad)", { XX
} },
7000 { "(bad)", { XX
} },
7001 { "(bad)", { XX
} },
7002 { "(bad)", { XX
} },
7003 { "(bad)", { XX
} },
7005 { "(bad)", { XX
} },
7006 { "(bad)", { XX
} },
7007 { "(bad)", { XX
} },
7008 { "(bad)", { XX
} },
7009 { "(bad)", { XX
} },
7010 { "(bad)", { XX
} },
7011 { "(bad)", { XX
} },
7012 { "(bad)", { XX
} },
7014 { "(bad)", { XX
} },
7015 { "(bad)", { XX
} },
7016 { "(bad)", { XX
} },
7017 { "(bad)", { XX
} },
7018 { "(bad)", { XX
} },
7019 { "(bad)", { XX
} },
7020 { "(bad)", { XX
} },
7021 { "(bad)", { XX
} },
7023 { "(bad)", { XX
} },
7024 { "(bad)", { XX
} },
7025 { "(bad)", { XX
} },
7026 { "(bad)", { XX
} },
7027 { "(bad)", { XX
} },
7028 { "(bad)", { XX
} },
7029 { "(bad)", { XX
} },
7030 { "(bad)", { XX
} },
7032 { "(bad)", { XX
} },
7033 { "(bad)", { XX
} },
7034 { "(bad)", { XX
} },
7035 { "(bad)", { XX
} },
7036 { "(bad)", { XX
} },
7037 { "(bad)", { XX
} },
7038 { "(bad)", { XX
} },
7039 { "(bad)", { XX
} },
7041 { "(bad)", { XX
} },
7042 { "(bad)", { XX
} },
7043 { "(bad)", { XX
} },
7044 { "(bad)", { XX
} },
7045 { "(bad)", { XX
} },
7046 { "(bad)", { XX
} },
7047 { "(bad)", { XX
} },
7048 { "(bad)", { XX
} },
7050 { "(bad)", { XX
} },
7051 { "(bad)", { XX
} },
7052 { "(bad)", { XX
} },
7053 { "(bad)", { XX
} },
7054 { "(bad)", { XX
} },
7055 { "(bad)", { XX
} },
7056 { "(bad)", { XX
} },
7057 { "(bad)", { XX
} },
7059 { "(bad)", { XX
} },
7060 { "(bad)", { XX
} },
7061 { "(bad)", { XX
} },
7062 { "(bad)", { XX
} },
7063 { "(bad)", { XX
} },
7064 { "(bad)", { XX
} },
7065 { "(bad)", { XX
} },
7066 { "(bad)", { XX
} },
7068 { "(bad)", { XX
} },
7069 { "(bad)", { XX
} },
7070 { "(bad)", { XX
} },
7071 { "(bad)", { XX
} },
7072 { "(bad)", { XX
} },
7073 { "(bad)", { XX
} },
7074 { "(bad)", { XX
} },
7075 { "(bad)", { XX
} },
7077 { "(bad)", { XX
} },
7078 { "(bad)", { XX
} },
7079 { "(bad)", { XX
} },
7080 { "(bad)", { XX
} },
7081 { "(bad)", { XX
} },
7082 { "(bad)", { XX
} },
7083 { "(bad)", { XX
} },
7084 { "(bad)", { XX
} },
7086 { "(bad)", { XX
} },
7087 { "(bad)", { XX
} },
7088 { "(bad)", { XX
} },
7089 { "(bad)", { XX
} },
7090 { "(bad)", { XX
} },
7091 { "(bad)", { XX
} },
7092 { "(bad)", { XX
} },
7093 { "(bad)", { XX
} },
7095 { "(bad)", { XX
} },
7096 { "(bad)", { XX
} },
7097 { "(bad)", { XX
} },
7098 { "(bad)", { XX
} },
7099 { "(bad)", { XX
} },
7100 { "(bad)", { XX
} },
7101 { "(bad)", { XX
} },
7102 { "(bad)", { XX
} },
7104 { "(bad)", { XX
} },
7105 { "(bad)", { XX
} },
7106 { "(bad)", { XX
} },
7107 { "(bad)", { XX
} },
7108 { "(bad)", { XX
} },
7109 { "(bad)", { XX
} },
7110 { "(bad)", { XX
} },
7111 { "(bad)", { XX
} },
7113 { "(bad)", { XX
} },
7114 { "(bad)", { XX
} },
7115 { "(bad)", { XX
} },
7116 { "(bad)", { XX
} },
7117 { "(bad)", { XX
} },
7118 { "(bad)", { XX
} },
7119 { "(bad)", { XX
} },
7120 { "(bad)", { XX
} },
7122 { "(bad)", { XX
} },
7123 { "(bad)", { XX
} },
7124 { "(bad)", { XX
} },
7125 { "(bad)", { XX
} },
7126 { "(bad)", { XX
} },
7127 { "(bad)", { XX
} },
7128 { "(bad)", { XX
} },
7129 { "(bad)", { XX
} },
7131 { "(bad)", { XX
} },
7132 { "(bad)", { XX
} },
7133 { "(bad)", { XX
} },
7134 { "(bad)", { XX
} },
7135 { "(bad)", { XX
} },
7136 { "(bad)", { XX
} },
7137 { "(bad)", { XX
} },
7138 { "(bad)", { XX
} },
7140 { "(bad)", { XX
} },
7141 { "(bad)", { XX
} },
7142 { "(bad)", { XX
} },
7143 { "(bad)", { XX
} },
7144 { "(bad)", { XX
} },
7145 { "(bad)", { XX
} },
7146 { "(bad)", { XX
} },
7147 { "(bad)", { XX
} },
7149 { "(bad)", { XX
} },
7150 { "(bad)", { XX
} },
7151 { "(bad)", { XX
} },
7152 { "(bad)", { XX
} },
7153 { "(bad)", { XX
} },
7154 { "(bad)", { XX
} },
7155 { "(bad)", { XX
} },
7156 { "(bad)", { XX
} },
7158 { "(bad)", { XX
} },
7159 { "(bad)", { XX
} },
7160 { "(bad)", { XX
} },
7161 { "(bad)", { XX
} },
7162 { "(bad)", { XX
} },
7163 { "(bad)", { XX
} },
7164 { "(bad)", { XX
} },
7165 { "(bad)", { XX
} },
7167 { "(bad)", { XX
} },
7168 { "(bad)", { XX
} },
7169 { "(bad)", { XX
} },
7170 { "(bad)", { XX
} },
7171 { "(bad)", { XX
} },
7172 { "(bad)", { XX
} },
7173 { "(bad)", { XX
} },
7174 { "(bad)", { XX
} },
7176 { "(bad)", { XX
} },
7177 { "(bad)", { XX
} },
7178 { "(bad)", { XX
} },
7179 { "(bad)", { XX
} },
7180 { "(bad)", { XX
} },
7181 { "(bad)", { XX
} },
7182 { "(bad)", { XX
} },
7183 { "(bad)", { XX
} },
7185 { "(bad)", { XX
} },
7186 { "(bad)", { XX
} },
7187 { "(bad)", { XX
} },
7188 { "(bad)", { XX
} },
7189 { "(bad)", { XX
} },
7190 { "(bad)", { XX
} },
7191 { "(bad)", { XX
} },
7192 { "(bad)", { XX
} },
7194 { "(bad)", { XX
} },
7195 { "(bad)", { XX
} },
7196 { "(bad)", { XX
} },
7197 { "(bad)", { XX
} },
7198 { "(bad)", { XX
} },
7199 { "(bad)", { XX
} },
7200 { "(bad)", { XX
} },
7201 { "(bad)", { XX
} },
7203 { "(bad)", { XX
} },
7204 { "(bad)", { XX
} },
7205 { "(bad)", { XX
} },
7206 { "(bad)", { XX
} },
7207 { "(bad)", { XX
} },
7208 { "(bad)", { XX
} },
7209 { "(bad)", { XX
} },
7210 { "(bad)", { XX
} },
7212 { "(bad)", { XX
} },
7213 { "(bad)", { XX
} },
7214 { "(bad)", { XX
} },
7215 { "(bad)", { XX
} },
7216 { "(bad)", { XX
} },
7217 { "(bad)", { XX
} },
7218 { "(bad)", { XX
} },
7219 { "(bad)", { XX
} },
7221 { "(bad)", { XX
} },
7222 { "(bad)", { XX
} },
7223 { "(bad)", { XX
} },
7224 { "(bad)", { XX
} },
7225 { "(bad)", { XX
} },
7226 { "(bad)", { XX
} },
7227 { "(bad)", { XX
} },
7228 { "(bad)", { XX
} },
7230 { "(bad)", { XX
} },
7231 { "(bad)", { XX
} },
7232 { "(bad)", { XX
} },
7233 { "(bad)", { XX
} },
7234 { "(bad)", { XX
} },
7235 { "(bad)", { XX
} },
7236 { "(bad)", { XX
} },
7237 { "(bad)", { XX
} },
7239 { "(bad)", { XX
} },
7240 { "(bad)", { XX
} },
7241 { "(bad)", { XX
} },
7242 { "(bad)", { XX
} },
7243 { "(bad)", { XX
} },
7244 { "(bad)", { XX
} },
7245 { "(bad)", { XX
} },
7246 { "(bad)", { XX
} },
7248 { "(bad)", { XX
} },
7249 { "(bad)", { XX
} },
7250 { "(bad)", { XX
} },
7251 { "(bad)", { XX
} },
7252 { "(bad)", { XX
} },
7253 { "(bad)", { XX
} },
7254 { "(bad)", { XX
} },
7255 { "(bad)", { XX
} },
7257 { "(bad)", { XX
} },
7258 { "(bad)", { XX
} },
7259 { "(bad)", { XX
} },
7260 { "(bad)", { XX
} },
7261 { "(bad)", { XX
} },
7262 { "(bad)", { XX
} },
7263 { "(bad)", { XX
} },
7264 { "(bad)", { XX
} },
7268 static const struct dis386 vex_table
[][256] = {
7272 { "(bad)", { XX
} },
7273 { "(bad)", { XX
} },
7274 { "(bad)", { XX
} },
7275 { "(bad)", { XX
} },
7276 { "(bad)", { XX
} },
7277 { "(bad)", { XX
} },
7278 { "(bad)", { XX
} },
7279 { "(bad)", { XX
} },
7281 { "(bad)", { XX
} },
7282 { "(bad)", { XX
} },
7283 { "(bad)", { XX
} },
7284 { "(bad)", { XX
} },
7285 { "(bad)", { XX
} },
7286 { "(bad)", { XX
} },
7287 { "(bad)", { XX
} },
7288 { "(bad)", { XX
} },
7290 { PREFIX_TABLE (PREFIX_VEX_10
) },
7291 { PREFIX_TABLE (PREFIX_VEX_11
) },
7292 { PREFIX_TABLE (PREFIX_VEX_12
) },
7293 { MOD_TABLE (MOD_VEX_13
) },
7294 { "vunpcklpX", { XM
, Vex
, EXx
} },
7295 { "vunpckhpX", { XM
, Vex
, EXx
} },
7296 { PREFIX_TABLE (PREFIX_VEX_16
) },
7297 { MOD_TABLE (MOD_VEX_17
) },
7299 { "(bad)", { XX
} },
7300 { "(bad)", { XX
} },
7301 { "(bad)", { XX
} },
7302 { "(bad)", { XX
} },
7303 { "(bad)", { XX
} },
7304 { "(bad)", { XX
} },
7305 { "(bad)", { XX
} },
7306 { "(bad)", { XX
} },
7308 { "(bad)", { XX
} },
7309 { "(bad)", { XX
} },
7310 { "(bad)", { XX
} },
7311 { "(bad)", { XX
} },
7312 { "(bad)", { XX
} },
7313 { "(bad)", { XX
} },
7314 { "(bad)", { XX
} },
7315 { "(bad)", { XX
} },
7317 { "vmovapX", { XM
, EXx
} },
7318 { "vmovapX", { EXxS
, XM
} },
7319 { PREFIX_TABLE (PREFIX_VEX_2A
) },
7320 { MOD_TABLE (MOD_VEX_2B
) },
7321 { PREFIX_TABLE (PREFIX_VEX_2C
) },
7322 { PREFIX_TABLE (PREFIX_VEX_2D
) },
7323 { PREFIX_TABLE (PREFIX_VEX_2E
) },
7324 { PREFIX_TABLE (PREFIX_VEX_2F
) },
7326 { "(bad)", { XX
} },
7327 { "(bad)", { XX
} },
7328 { "(bad)", { XX
} },
7329 { "(bad)", { XX
} },
7330 { "(bad)", { XX
} },
7331 { "(bad)", { XX
} },
7332 { "(bad)", { XX
} },
7333 { "(bad)", { XX
} },
7335 { "(bad)", { XX
} },
7336 { "(bad)", { XX
} },
7337 { "(bad)", { XX
} },
7338 { "(bad)", { XX
} },
7339 { "(bad)", { XX
} },
7340 { "(bad)", { XX
} },
7341 { "(bad)", { XX
} },
7342 { "(bad)", { XX
} },
7344 { "(bad)", { XX
} },
7345 { "(bad)", { XX
} },
7346 { "(bad)", { XX
} },
7347 { "(bad)", { XX
} },
7348 { "(bad)", { XX
} },
7349 { "(bad)", { XX
} },
7350 { "(bad)", { XX
} },
7351 { "(bad)", { XX
} },
7353 { "(bad)", { XX
} },
7354 { "(bad)", { XX
} },
7355 { "(bad)", { XX
} },
7356 { "(bad)", { XX
} },
7357 { "(bad)", { XX
} },
7358 { "(bad)", { XX
} },
7359 { "(bad)", { XX
} },
7360 { "(bad)", { XX
} },
7362 { MOD_TABLE (MOD_VEX_51
) },
7363 { PREFIX_TABLE (PREFIX_VEX_51
) },
7364 { PREFIX_TABLE (PREFIX_VEX_52
) },
7365 { PREFIX_TABLE (PREFIX_VEX_53
) },
7366 { "vandpX", { XM
, Vex
, EXx
} },
7367 { "vandnpX", { XM
, Vex
, EXx
} },
7368 { "vorpX", { XM
, Vex
, EXx
} },
7369 { "vxorpX", { XM
, Vex
, EXx
} },
7371 { PREFIX_TABLE (PREFIX_VEX_58
) },
7372 { PREFIX_TABLE (PREFIX_VEX_59
) },
7373 { PREFIX_TABLE (PREFIX_VEX_5A
) },
7374 { PREFIX_TABLE (PREFIX_VEX_5B
) },
7375 { PREFIX_TABLE (PREFIX_VEX_5C
) },
7376 { PREFIX_TABLE (PREFIX_VEX_5D
) },
7377 { PREFIX_TABLE (PREFIX_VEX_5E
) },
7378 { PREFIX_TABLE (PREFIX_VEX_5F
) },
7380 { PREFIX_TABLE (PREFIX_VEX_60
) },
7381 { PREFIX_TABLE (PREFIX_VEX_61
) },
7382 { PREFIX_TABLE (PREFIX_VEX_62
) },
7383 { PREFIX_TABLE (PREFIX_VEX_63
) },
7384 { PREFIX_TABLE (PREFIX_VEX_64
) },
7385 { PREFIX_TABLE (PREFIX_VEX_65
) },
7386 { PREFIX_TABLE (PREFIX_VEX_66
) },
7387 { PREFIX_TABLE (PREFIX_VEX_67
) },
7389 { PREFIX_TABLE (PREFIX_VEX_68
) },
7390 { PREFIX_TABLE (PREFIX_VEX_69
) },
7391 { PREFIX_TABLE (PREFIX_VEX_6A
) },
7392 { PREFIX_TABLE (PREFIX_VEX_6B
) },
7393 { PREFIX_TABLE (PREFIX_VEX_6C
) },
7394 { PREFIX_TABLE (PREFIX_VEX_6D
) },
7395 { PREFIX_TABLE (PREFIX_VEX_6E
) },
7396 { PREFIX_TABLE (PREFIX_VEX_6F
) },
7398 { PREFIX_TABLE (PREFIX_VEX_70
) },
7399 { REG_TABLE (REG_VEX_71
) },
7400 { REG_TABLE (REG_VEX_72
) },
7401 { REG_TABLE (REG_VEX_73
) },
7402 { PREFIX_TABLE (PREFIX_VEX_74
) },
7403 { PREFIX_TABLE (PREFIX_VEX_75
) },
7404 { PREFIX_TABLE (PREFIX_VEX_76
) },
7405 { PREFIX_TABLE (PREFIX_VEX_77
) },
7407 { "(bad)", { XX
} },
7408 { "(bad)", { XX
} },
7409 { "(bad)", { XX
} },
7410 { "(bad)", { XX
} },
7411 { PREFIX_TABLE (PREFIX_VEX_7C
) },
7412 { PREFIX_TABLE (PREFIX_VEX_7D
) },
7413 { PREFIX_TABLE (PREFIX_VEX_7E
) },
7414 { PREFIX_TABLE (PREFIX_VEX_7F
) },
7416 { "(bad)", { XX
} },
7417 { "(bad)", { XX
} },
7418 { "(bad)", { XX
} },
7419 { "(bad)", { XX
} },
7420 { "(bad)", { XX
} },
7421 { "(bad)", { XX
} },
7422 { "(bad)", { XX
} },
7423 { "(bad)", { XX
} },
7425 { "(bad)", { XX
} },
7426 { "(bad)", { XX
} },
7427 { "(bad)", { XX
} },
7428 { "(bad)", { XX
} },
7429 { "(bad)", { XX
} },
7430 { "(bad)", { XX
} },
7431 { "(bad)", { XX
} },
7432 { "(bad)", { XX
} },
7434 { "(bad)", { XX
} },
7435 { "(bad)", { XX
} },
7436 { "(bad)", { XX
} },
7437 { "(bad)", { XX
} },
7438 { "(bad)", { XX
} },
7439 { "(bad)", { XX
} },
7440 { "(bad)", { XX
} },
7441 { "(bad)", { XX
} },
7443 { "(bad)", { XX
} },
7444 { "(bad)", { XX
} },
7445 { "(bad)", { XX
} },
7446 { "(bad)", { XX
} },
7447 { "(bad)", { XX
} },
7448 { "(bad)", { XX
} },
7449 { "(bad)", { XX
} },
7450 { "(bad)", { XX
} },
7452 { "(bad)", { XX
} },
7453 { "(bad)", { XX
} },
7454 { "(bad)", { XX
} },
7455 { "(bad)", { XX
} },
7456 { "(bad)", { XX
} },
7457 { "(bad)", { XX
} },
7458 { "(bad)", { XX
} },
7459 { "(bad)", { XX
} },
7461 { "(bad)", { XX
} },
7462 { "(bad)", { XX
} },
7463 { "(bad)", { XX
} },
7464 { "(bad)", { XX
} },
7465 { "(bad)", { XX
} },
7466 { "(bad)", { XX
} },
7467 { REG_TABLE (REG_VEX_AE
) },
7468 { "(bad)", { XX
} },
7470 { "(bad)", { XX
} },
7471 { "(bad)", { XX
} },
7472 { "(bad)", { XX
} },
7473 { "(bad)", { XX
} },
7474 { "(bad)", { XX
} },
7475 { "(bad)", { XX
} },
7476 { "(bad)", { XX
} },
7477 { "(bad)", { XX
} },
7479 { "(bad)", { XX
} },
7480 { "(bad)", { XX
} },
7481 { "(bad)", { XX
} },
7482 { "(bad)", { XX
} },
7483 { "(bad)", { XX
} },
7484 { "(bad)", { XX
} },
7485 { "(bad)", { XX
} },
7486 { "(bad)", { XX
} },
7488 { "(bad)", { XX
} },
7489 { "(bad)", { XX
} },
7490 { PREFIX_TABLE (PREFIX_VEX_C2
) },
7491 { "(bad)", { XX
} },
7492 { PREFIX_TABLE (PREFIX_VEX_C4
) },
7493 { PREFIX_TABLE (PREFIX_VEX_C5
) },
7494 { "vshufpX", { XM
, Vex
, EXx
, Ib
} },
7495 { "(bad)", { XX
} },
7497 { "(bad)", { XX
} },
7498 { "(bad)", { XX
} },
7499 { "(bad)", { XX
} },
7500 { "(bad)", { XX
} },
7501 { "(bad)", { XX
} },
7502 { "(bad)", { XX
} },
7503 { "(bad)", { XX
} },
7504 { "(bad)", { XX
} },
7506 { PREFIX_TABLE (PREFIX_VEX_D0
) },
7507 { PREFIX_TABLE (PREFIX_VEX_D1
) },
7508 { PREFIX_TABLE (PREFIX_VEX_D2
) },
7509 { PREFIX_TABLE (PREFIX_VEX_D3
) },
7510 { PREFIX_TABLE (PREFIX_VEX_D4
) },
7511 { PREFIX_TABLE (PREFIX_VEX_D5
) },
7512 { PREFIX_TABLE (PREFIX_VEX_D6
) },
7513 { PREFIX_TABLE (PREFIX_VEX_D7
) },
7515 { PREFIX_TABLE (PREFIX_VEX_D8
) },
7516 { PREFIX_TABLE (PREFIX_VEX_D9
) },
7517 { PREFIX_TABLE (PREFIX_VEX_DA
) },
7518 { PREFIX_TABLE (PREFIX_VEX_DB
) },
7519 { PREFIX_TABLE (PREFIX_VEX_DC
) },
7520 { PREFIX_TABLE (PREFIX_VEX_DD
) },
7521 { PREFIX_TABLE (PREFIX_VEX_DE
) },
7522 { PREFIX_TABLE (PREFIX_VEX_DF
) },
7524 { PREFIX_TABLE (PREFIX_VEX_E0
) },
7525 { PREFIX_TABLE (PREFIX_VEX_E1
) },
7526 { PREFIX_TABLE (PREFIX_VEX_E2
) },
7527 { PREFIX_TABLE (PREFIX_VEX_E3
) },
7528 { PREFIX_TABLE (PREFIX_VEX_E4
) },
7529 { PREFIX_TABLE (PREFIX_VEX_E5
) },
7530 { PREFIX_TABLE (PREFIX_VEX_E6
) },
7531 { PREFIX_TABLE (PREFIX_VEX_E7
) },
7533 { PREFIX_TABLE (PREFIX_VEX_E8
) },
7534 { PREFIX_TABLE (PREFIX_VEX_E9
) },
7535 { PREFIX_TABLE (PREFIX_VEX_EA
) },
7536 { PREFIX_TABLE (PREFIX_VEX_EB
) },
7537 { PREFIX_TABLE (PREFIX_VEX_EC
) },
7538 { PREFIX_TABLE (PREFIX_VEX_ED
) },
7539 { PREFIX_TABLE (PREFIX_VEX_EE
) },
7540 { PREFIX_TABLE (PREFIX_VEX_EF
) },
7542 { PREFIX_TABLE (PREFIX_VEX_F0
) },
7543 { PREFIX_TABLE (PREFIX_VEX_F1
) },
7544 { PREFIX_TABLE (PREFIX_VEX_F2
) },
7545 { PREFIX_TABLE (PREFIX_VEX_F3
) },
7546 { PREFIX_TABLE (PREFIX_VEX_F4
) },
7547 { PREFIX_TABLE (PREFIX_VEX_F5
) },
7548 { PREFIX_TABLE (PREFIX_VEX_F6
) },
7549 { PREFIX_TABLE (PREFIX_VEX_F7
) },
7551 { PREFIX_TABLE (PREFIX_VEX_F8
) },
7552 { PREFIX_TABLE (PREFIX_VEX_F9
) },
7553 { PREFIX_TABLE (PREFIX_VEX_FA
) },
7554 { PREFIX_TABLE (PREFIX_VEX_FB
) },
7555 { PREFIX_TABLE (PREFIX_VEX_FC
) },
7556 { PREFIX_TABLE (PREFIX_VEX_FD
) },
7557 { PREFIX_TABLE (PREFIX_VEX_FE
) },
7558 { "(bad)", { XX
} },
7563 { PREFIX_TABLE (PREFIX_VEX_3800
) },
7564 { PREFIX_TABLE (PREFIX_VEX_3801
) },
7565 { PREFIX_TABLE (PREFIX_VEX_3802
) },
7566 { PREFIX_TABLE (PREFIX_VEX_3803
) },
7567 { PREFIX_TABLE (PREFIX_VEX_3804
) },
7568 { PREFIX_TABLE (PREFIX_VEX_3805
) },
7569 { PREFIX_TABLE (PREFIX_VEX_3806
) },
7570 { PREFIX_TABLE (PREFIX_VEX_3807
) },
7572 { PREFIX_TABLE (PREFIX_VEX_3808
) },
7573 { PREFIX_TABLE (PREFIX_VEX_3809
) },
7574 { PREFIX_TABLE (PREFIX_VEX_380A
) },
7575 { PREFIX_TABLE (PREFIX_VEX_380B
) },
7576 { PREFIX_TABLE (PREFIX_VEX_380C
) },
7577 { PREFIX_TABLE (PREFIX_VEX_380D
) },
7578 { PREFIX_TABLE (PREFIX_VEX_380E
) },
7579 { PREFIX_TABLE (PREFIX_VEX_380F
) },
7581 { "(bad)", { XX
} },
7582 { "(bad)", { XX
} },
7583 { "(bad)", { XX
} },
7584 { "(bad)", { XX
} },
7585 { "(bad)", { XX
} },
7586 { "(bad)", { XX
} },
7587 { "(bad)", { XX
} },
7588 { PREFIX_TABLE (PREFIX_VEX_3817
) },
7590 { PREFIX_TABLE (PREFIX_VEX_3818
) },
7591 { PREFIX_TABLE (PREFIX_VEX_3819
) },
7592 { PREFIX_TABLE (PREFIX_VEX_381A
) },
7593 { "(bad)", { XX
} },
7594 { PREFIX_TABLE (PREFIX_VEX_381C
) },
7595 { PREFIX_TABLE (PREFIX_VEX_381D
) },
7596 { PREFIX_TABLE (PREFIX_VEX_381E
) },
7597 { "(bad)", { XX
} },
7599 { PREFIX_TABLE (PREFIX_VEX_3820
) },
7600 { PREFIX_TABLE (PREFIX_VEX_3821
) },
7601 { PREFIX_TABLE (PREFIX_VEX_3822
) },
7602 { PREFIX_TABLE (PREFIX_VEX_3823
) },
7603 { PREFIX_TABLE (PREFIX_VEX_3824
) },
7604 { PREFIX_TABLE (PREFIX_VEX_3825
) },
7605 { "(bad)", { XX
} },
7606 { "(bad)", { XX
} },
7608 { PREFIX_TABLE (PREFIX_VEX_3828
) },
7609 { PREFIX_TABLE (PREFIX_VEX_3829
) },
7610 { PREFIX_TABLE (PREFIX_VEX_382A
) },
7611 { PREFIX_TABLE (PREFIX_VEX_382B
) },
7612 { PREFIX_TABLE (PREFIX_VEX_382C
) },
7613 { PREFIX_TABLE (PREFIX_VEX_382D
) },
7614 { PREFIX_TABLE (PREFIX_VEX_382E
) },
7615 { PREFIX_TABLE (PREFIX_VEX_382F
) },
7617 { PREFIX_TABLE (PREFIX_VEX_3830
) },
7618 { PREFIX_TABLE (PREFIX_VEX_3831
) },
7619 { PREFIX_TABLE (PREFIX_VEX_3832
) },
7620 { PREFIX_TABLE (PREFIX_VEX_3833
) },
7621 { PREFIX_TABLE (PREFIX_VEX_3834
) },
7622 { PREFIX_TABLE (PREFIX_VEX_3835
) },
7623 { "(bad)", { XX
} },
7624 { PREFIX_TABLE (PREFIX_VEX_3837
) },
7626 { PREFIX_TABLE (PREFIX_VEX_3838
) },
7627 { PREFIX_TABLE (PREFIX_VEX_3839
) },
7628 { PREFIX_TABLE (PREFIX_VEX_383A
) },
7629 { PREFIX_TABLE (PREFIX_VEX_383B
) },
7630 { PREFIX_TABLE (PREFIX_VEX_383C
) },
7631 { PREFIX_TABLE (PREFIX_VEX_383D
) },
7632 { PREFIX_TABLE (PREFIX_VEX_383E
) },
7633 { PREFIX_TABLE (PREFIX_VEX_383F
) },
7635 { PREFIX_TABLE (PREFIX_VEX_3840
) },
7636 { PREFIX_TABLE (PREFIX_VEX_3841
) },
7637 { "(bad)", { XX
} },
7638 { "(bad)", { XX
} },
7639 { "(bad)", { XX
} },
7640 { "(bad)", { XX
} },
7641 { "(bad)", { XX
} },
7642 { "(bad)", { XX
} },
7644 { "(bad)", { XX
} },
7645 { "(bad)", { XX
} },
7646 { "(bad)", { XX
} },
7647 { "(bad)", { XX
} },
7648 { "(bad)", { XX
} },
7649 { "(bad)", { XX
} },
7650 { "(bad)", { XX
} },
7651 { "(bad)", { XX
} },
7653 { "(bad)", { XX
} },
7654 { "(bad)", { XX
} },
7655 { "(bad)", { XX
} },
7656 { "(bad)", { XX
} },
7657 { "(bad)", { XX
} },
7658 { "(bad)", { XX
} },
7659 { "(bad)", { XX
} },
7660 { "(bad)", { XX
} },
7662 { "(bad)", { XX
} },
7663 { "(bad)", { XX
} },
7664 { "(bad)", { XX
} },
7665 { "(bad)", { XX
} },
7666 { "(bad)", { XX
} },
7667 { "(bad)", { XX
} },
7668 { "(bad)", { XX
} },
7669 { "(bad)", { XX
} },
7671 { "(bad)", { XX
} },
7672 { "(bad)", { XX
} },
7673 { "(bad)", { XX
} },
7674 { "(bad)", { XX
} },
7675 { "(bad)", { XX
} },
7676 { "(bad)", { XX
} },
7677 { "(bad)", { XX
} },
7678 { "(bad)", { XX
} },
7680 { "(bad)", { XX
} },
7681 { "(bad)", { XX
} },
7682 { "(bad)", { XX
} },
7683 { "(bad)", { XX
} },
7684 { "(bad)", { XX
} },
7685 { "(bad)", { XX
} },
7686 { "(bad)", { XX
} },
7687 { "(bad)", { XX
} },
7689 { "(bad)", { XX
} },
7690 { "(bad)", { XX
} },
7691 { "(bad)", { XX
} },
7692 { "(bad)", { XX
} },
7693 { "(bad)", { XX
} },
7694 { "(bad)", { XX
} },
7695 { "(bad)", { XX
} },
7696 { "(bad)", { XX
} },
7698 { "(bad)", { XX
} },
7699 { "(bad)", { XX
} },
7700 { "(bad)", { XX
} },
7701 { "(bad)", { XX
} },
7702 { "(bad)", { XX
} },
7703 { "(bad)", { XX
} },
7704 { "(bad)", { XX
} },
7705 { "(bad)", { XX
} },
7707 { "(bad)", { XX
} },
7708 { "(bad)", { XX
} },
7709 { "(bad)", { XX
} },
7710 { "(bad)", { XX
} },
7711 { "(bad)", { XX
} },
7712 { "(bad)", { XX
} },
7713 { "(bad)", { XX
} },
7714 { "(bad)", { XX
} },
7716 { "(bad)", { XX
} },
7717 { "(bad)", { XX
} },
7718 { "(bad)", { XX
} },
7719 { "(bad)", { XX
} },
7720 { "(bad)", { XX
} },
7721 { "(bad)", { XX
} },
7722 { "(bad)", { XX
} },
7723 { "(bad)", { XX
} },
7725 { "(bad)", { XX
} },
7726 { "(bad)", { XX
} },
7727 { "(bad)", { XX
} },
7728 { "(bad)", { XX
} },
7729 { "(bad)", { XX
} },
7730 { "(bad)", { XX
} },
7731 { PREFIX_TABLE (PREFIX_VEX_3896
) },
7732 { PREFIX_TABLE (PREFIX_VEX_3897
) },
7734 { PREFIX_TABLE (PREFIX_VEX_3898
) },
7735 { PREFIX_TABLE (PREFIX_VEX_3899
) },
7736 { PREFIX_TABLE (PREFIX_VEX_389A
) },
7737 { PREFIX_TABLE (PREFIX_VEX_389B
) },
7738 { PREFIX_TABLE (PREFIX_VEX_389C
) },
7739 { PREFIX_TABLE (PREFIX_VEX_389D
) },
7740 { PREFIX_TABLE (PREFIX_VEX_389E
) },
7741 { PREFIX_TABLE (PREFIX_VEX_389F
) },
7743 { "(bad)", { XX
} },
7744 { "(bad)", { XX
} },
7745 { "(bad)", { XX
} },
7746 { "(bad)", { XX
} },
7747 { "(bad)", { XX
} },
7748 { "(bad)", { XX
} },
7749 { PREFIX_TABLE (PREFIX_VEX_38A6
) },
7750 { PREFIX_TABLE (PREFIX_VEX_38A7
) },
7752 { PREFIX_TABLE (PREFIX_VEX_38A8
) },
7753 { PREFIX_TABLE (PREFIX_VEX_38A9
) },
7754 { PREFIX_TABLE (PREFIX_VEX_38AA
) },
7755 { PREFIX_TABLE (PREFIX_VEX_38AB
) },
7756 { PREFIX_TABLE (PREFIX_VEX_38AC
) },
7757 { PREFIX_TABLE (PREFIX_VEX_38AD
) },
7758 { PREFIX_TABLE (PREFIX_VEX_38AE
) },
7759 { PREFIX_TABLE (PREFIX_VEX_38AF
) },
7761 { "(bad)", { XX
} },
7762 { "(bad)", { XX
} },
7763 { "(bad)", { XX
} },
7764 { "(bad)", { XX
} },
7765 { "(bad)", { XX
} },
7766 { "(bad)", { XX
} },
7767 { PREFIX_TABLE (PREFIX_VEX_38B6
) },
7768 { PREFIX_TABLE (PREFIX_VEX_38B7
) },
7770 { PREFIX_TABLE (PREFIX_VEX_38B8
) },
7771 { PREFIX_TABLE (PREFIX_VEX_38B9
) },
7772 { PREFIX_TABLE (PREFIX_VEX_38BA
) },
7773 { PREFIX_TABLE (PREFIX_VEX_38BB
) },
7774 { PREFIX_TABLE (PREFIX_VEX_38BC
) },
7775 { PREFIX_TABLE (PREFIX_VEX_38BD
) },
7776 { PREFIX_TABLE (PREFIX_VEX_38BE
) },
7777 { PREFIX_TABLE (PREFIX_VEX_38BF
) },
7779 { "(bad)", { XX
} },
7780 { "(bad)", { XX
} },
7781 { "(bad)", { XX
} },
7782 { "(bad)", { XX
} },
7783 { "(bad)", { XX
} },
7784 { "(bad)", { XX
} },
7785 { "(bad)", { XX
} },
7786 { "(bad)", { XX
} },
7788 { "(bad)", { XX
} },
7789 { "(bad)", { XX
} },
7790 { "(bad)", { XX
} },
7791 { "(bad)", { XX
} },
7792 { "(bad)", { XX
} },
7793 { "(bad)", { XX
} },
7794 { "(bad)", { XX
} },
7795 { "(bad)", { XX
} },
7797 { "(bad)", { XX
} },
7798 { "(bad)", { XX
} },
7799 { "(bad)", { XX
} },
7800 { "(bad)", { XX
} },
7801 { "(bad)", { XX
} },
7802 { "(bad)", { XX
} },
7803 { "(bad)", { XX
} },
7804 { "(bad)", { XX
} },
7806 { "(bad)", { XX
} },
7807 { "(bad)", { XX
} },
7808 { "(bad)", { XX
} },
7809 { PREFIX_TABLE (PREFIX_VEX_38DB
) },
7810 { PREFIX_TABLE (PREFIX_VEX_38DC
) },
7811 { PREFIX_TABLE (PREFIX_VEX_38DD
) },
7812 { PREFIX_TABLE (PREFIX_VEX_38DE
) },
7813 { PREFIX_TABLE (PREFIX_VEX_38DF
) },
7815 { "(bad)", { XX
} },
7816 { "(bad)", { XX
} },
7817 { "(bad)", { XX
} },
7818 { "(bad)", { XX
} },
7819 { "(bad)", { XX
} },
7820 { "(bad)", { XX
} },
7821 { "(bad)", { XX
} },
7822 { "(bad)", { XX
} },
7824 { "(bad)", { XX
} },
7825 { "(bad)", { XX
} },
7826 { "(bad)", { XX
} },
7827 { "(bad)", { XX
} },
7828 { "(bad)", { XX
} },
7829 { "(bad)", { XX
} },
7830 { "(bad)", { XX
} },
7831 { "(bad)", { XX
} },
7833 { "(bad)", { XX
} },
7834 { "(bad)", { XX
} },
7835 { "(bad)", { XX
} },
7836 { "(bad)", { XX
} },
7837 { "(bad)", { XX
} },
7838 { "(bad)", { XX
} },
7839 { "(bad)", { XX
} },
7840 { "(bad)", { XX
} },
7842 { "(bad)", { XX
} },
7843 { "(bad)", { XX
} },
7844 { "(bad)", { XX
} },
7845 { "(bad)", { XX
} },
7846 { "(bad)", { XX
} },
7847 { "(bad)", { XX
} },
7848 { "(bad)", { XX
} },
7849 { "(bad)", { XX
} },
7854 { "(bad)", { XX
} },
7855 { "(bad)", { XX
} },
7856 { "(bad)", { XX
} },
7857 { "(bad)", { XX
} },
7858 { PREFIX_TABLE (PREFIX_VEX_3A04
) },
7859 { PREFIX_TABLE (PREFIX_VEX_3A05
) },
7860 { PREFIX_TABLE (PREFIX_VEX_3A06
) },
7861 { "(bad)", { XX
} },
7863 { PREFIX_TABLE (PREFIX_VEX_3A08
) },
7864 { PREFIX_TABLE (PREFIX_VEX_3A09
) },
7865 { PREFIX_TABLE (PREFIX_VEX_3A0A
) },
7866 { PREFIX_TABLE (PREFIX_VEX_3A0B
) },
7867 { PREFIX_TABLE (PREFIX_VEX_3A0C
) },
7868 { PREFIX_TABLE (PREFIX_VEX_3A0D
) },
7869 { PREFIX_TABLE (PREFIX_VEX_3A0E
) },
7870 { PREFIX_TABLE (PREFIX_VEX_3A0F
) },
7872 { "(bad)", { XX
} },
7873 { "(bad)", { XX
} },
7874 { "(bad)", { XX
} },
7875 { "(bad)", { XX
} },
7876 { PREFIX_TABLE (PREFIX_VEX_3A14
) },
7877 { PREFIX_TABLE (PREFIX_VEX_3A15
) },
7878 { PREFIX_TABLE (PREFIX_VEX_3A16
) },
7879 { PREFIX_TABLE (PREFIX_VEX_3A17
) },
7881 { PREFIX_TABLE (PREFIX_VEX_3A18
) },
7882 { PREFIX_TABLE (PREFIX_VEX_3A19
) },
7883 { "(bad)", { XX
} },
7884 { "(bad)", { XX
} },
7885 { "(bad)", { XX
} },
7886 { "(bad)", { XX
} },
7887 { "(bad)", { XX
} },
7888 { "(bad)", { XX
} },
7890 { PREFIX_TABLE (PREFIX_VEX_3A20
) },
7891 { PREFIX_TABLE (PREFIX_VEX_3A21
) },
7892 { PREFIX_TABLE (PREFIX_VEX_3A22
) },
7893 { "(bad)", { XX
} },
7894 { "(bad)", { XX
} },
7895 { "(bad)", { XX
} },
7896 { "(bad)", { XX
} },
7897 { "(bad)", { XX
} },
7899 { "(bad)", { XX
} },
7900 { "(bad)", { XX
} },
7901 { "(bad)", { XX
} },
7902 { "(bad)", { XX
} },
7903 { "(bad)", { XX
} },
7904 { "(bad)", { XX
} },
7905 { "(bad)", { XX
} },
7906 { "(bad)", { XX
} },
7908 { "(bad)", { XX
} },
7909 { "(bad)", { XX
} },
7910 { "(bad)", { XX
} },
7911 { "(bad)", { XX
} },
7912 { "(bad)", { XX
} },
7913 { "(bad)", { XX
} },
7914 { "(bad)", { XX
} },
7915 { "(bad)", { XX
} },
7917 { "(bad)", { XX
} },
7918 { "(bad)", { XX
} },
7919 { "(bad)", { XX
} },
7920 { "(bad)", { XX
} },
7921 { "(bad)", { XX
} },
7922 { "(bad)", { XX
} },
7923 { "(bad)", { XX
} },
7924 { "(bad)", { XX
} },
7926 { PREFIX_TABLE (PREFIX_VEX_3A40
) },
7927 { PREFIX_TABLE (PREFIX_VEX_3A41
) },
7928 { PREFIX_TABLE (PREFIX_VEX_3A42
) },
7929 { "(bad)", { XX
} },
7930 { PREFIX_TABLE (PREFIX_VEX_3A44
) },
7931 { "(bad)", { XX
} },
7932 { "(bad)", { XX
} },
7933 { "(bad)", { XX
} },
7935 { "(bad)", { XX
} },
7936 { "(bad)", { XX
} },
7937 { PREFIX_TABLE (PREFIX_VEX_3A4A
) },
7938 { PREFIX_TABLE (PREFIX_VEX_3A4B
) },
7939 { PREFIX_TABLE (PREFIX_VEX_3A4C
) },
7940 { "(bad)", { XX
} },
7941 { "(bad)", { XX
} },
7942 { "(bad)", { XX
} },
7944 { "(bad)", { XX
} },
7945 { "(bad)", { XX
} },
7946 { "(bad)", { XX
} },
7947 { "(bad)", { XX
} },
7948 { "(bad)", { XX
} },
7949 { "(bad)", { XX
} },
7950 { "(bad)", { XX
} },
7951 { "(bad)", { XX
} },
7953 { "(bad)", { XX
} },
7954 { "(bad)", { XX
} },
7955 { "(bad)", { XX
} },
7956 { "(bad)", { XX
} },
7957 { PREFIX_TABLE (PREFIX_VEX_3A5C
) },
7958 { PREFIX_TABLE (PREFIX_VEX_3A5D
) },
7959 { PREFIX_TABLE (PREFIX_VEX_3A5E
) },
7960 { PREFIX_TABLE (PREFIX_VEX_3A5F
) },
7962 { PREFIX_TABLE (PREFIX_VEX_3A60
) },
7963 { PREFIX_TABLE (PREFIX_VEX_3A61
) },
7964 { PREFIX_TABLE (PREFIX_VEX_3A62
) },
7965 { PREFIX_TABLE (PREFIX_VEX_3A63
) },
7966 { "(bad)", { XX
} },
7967 { "(bad)", { XX
} },
7968 { "(bad)", { XX
} },
7969 { "(bad)", { XX
} },
7971 { PREFIX_TABLE (PREFIX_VEX_3A68
) },
7972 { PREFIX_TABLE (PREFIX_VEX_3A69
) },
7973 { PREFIX_TABLE (PREFIX_VEX_3A6A
) },
7974 { PREFIX_TABLE (PREFIX_VEX_3A6B
) },
7975 { PREFIX_TABLE (PREFIX_VEX_3A6C
) },
7976 { PREFIX_TABLE (PREFIX_VEX_3A6D
) },
7977 { PREFIX_TABLE (PREFIX_VEX_3A6E
) },
7978 { PREFIX_TABLE (PREFIX_VEX_3A6F
) },
7980 { "(bad)", { XX
} },
7981 { "(bad)", { XX
} },
7982 { "(bad)", { XX
} },
7983 { "(bad)", { XX
} },
7984 { "(bad)", { XX
} },
7985 { "(bad)", { XX
} },
7986 { "(bad)", { XX
} },
7987 { "(bad)", { XX
} },
7989 { PREFIX_TABLE (PREFIX_VEX_3A78
) },
7990 { PREFIX_TABLE (PREFIX_VEX_3A79
) },
7991 { PREFIX_TABLE (PREFIX_VEX_3A7A
) },
7992 { PREFIX_TABLE (PREFIX_VEX_3A7B
) },
7993 { PREFIX_TABLE (PREFIX_VEX_3A7C
) },
7994 { PREFIX_TABLE (PREFIX_VEX_3A7D
) },
7995 { PREFIX_TABLE (PREFIX_VEX_3A7E
) },
7996 { PREFIX_TABLE (PREFIX_VEX_3A7F
) },
7998 { "(bad)", { XX
} },
7999 { "(bad)", { XX
} },
8000 { "(bad)", { XX
} },
8001 { "(bad)", { XX
} },
8002 { "(bad)", { XX
} },
8003 { "(bad)", { XX
} },
8004 { "(bad)", { XX
} },
8005 { "(bad)", { XX
} },
8007 { "(bad)", { XX
} },
8008 { "(bad)", { XX
} },
8009 { "(bad)", { XX
} },
8010 { "(bad)", { XX
} },
8011 { "(bad)", { XX
} },
8012 { "(bad)", { XX
} },
8013 { "(bad)", { XX
} },
8014 { "(bad)", { XX
} },
8016 { "(bad)", { XX
} },
8017 { "(bad)", { XX
} },
8018 { "(bad)", { XX
} },
8019 { "(bad)", { XX
} },
8020 { "(bad)", { XX
} },
8021 { "(bad)", { XX
} },
8022 { "(bad)", { XX
} },
8023 { "(bad)", { XX
} },
8025 { "(bad)", { XX
} },
8026 { "(bad)", { XX
} },
8027 { "(bad)", { XX
} },
8028 { "(bad)", { XX
} },
8029 { "(bad)", { XX
} },
8030 { "(bad)", { XX
} },
8031 { "(bad)", { XX
} },
8032 { "(bad)", { XX
} },
8034 { "(bad)", { XX
} },
8035 { "(bad)", { XX
} },
8036 { "(bad)", { XX
} },
8037 { "(bad)", { XX
} },
8038 { "(bad)", { XX
} },
8039 { "(bad)", { XX
} },
8040 { "(bad)", { XX
} },
8041 { "(bad)", { XX
} },
8043 { "(bad)", { XX
} },
8044 { "(bad)", { XX
} },
8045 { "(bad)", { XX
} },
8046 { "(bad)", { XX
} },
8047 { "(bad)", { XX
} },
8048 { "(bad)", { XX
} },
8049 { "(bad)", { XX
} },
8050 { "(bad)", { XX
} },
8052 { "(bad)", { XX
} },
8053 { "(bad)", { XX
} },
8054 { "(bad)", { XX
} },
8055 { "(bad)", { XX
} },
8056 { "(bad)", { XX
} },
8057 { "(bad)", { XX
} },
8058 { "(bad)", { XX
} },
8059 { "(bad)", { XX
} },
8061 { "(bad)", { XX
} },
8062 { "(bad)", { XX
} },
8063 { "(bad)", { XX
} },
8064 { "(bad)", { XX
} },
8065 { "(bad)", { XX
} },
8066 { "(bad)", { XX
} },
8067 { "(bad)", { XX
} },
8068 { "(bad)", { XX
} },
8070 { "(bad)", { XX
} },
8071 { "(bad)", { XX
} },
8072 { "(bad)", { XX
} },
8073 { "(bad)", { XX
} },
8074 { "(bad)", { XX
} },
8075 { "(bad)", { XX
} },
8076 { "(bad)", { XX
} },
8077 { "(bad)", { XX
} },
8079 { "(bad)", { XX
} },
8080 { "(bad)", { XX
} },
8081 { "(bad)", { XX
} },
8082 { "(bad)", { XX
} },
8083 { "(bad)", { XX
} },
8084 { "(bad)", { XX
} },
8085 { "(bad)", { XX
} },
8086 { "(bad)", { XX
} },
8088 { "(bad)", { XX
} },
8089 { "(bad)", { XX
} },
8090 { "(bad)", { XX
} },
8091 { "(bad)", { XX
} },
8092 { "(bad)", { XX
} },
8093 { "(bad)", { XX
} },
8094 { "(bad)", { XX
} },
8095 { "(bad)", { XX
} },
8097 { "(bad)", { XX
} },
8098 { "(bad)", { XX
} },
8099 { "(bad)", { XX
} },
8100 { "(bad)", { XX
} },
8101 { "(bad)", { XX
} },
8102 { "(bad)", { XX
} },
8103 { "(bad)", { XX
} },
8104 { PREFIX_TABLE (PREFIX_VEX_3ADF
) },
8106 { "(bad)", { XX
} },
8107 { "(bad)", { XX
} },
8108 { "(bad)", { XX
} },
8109 { "(bad)", { XX
} },
8110 { "(bad)", { XX
} },
8111 { "(bad)", { XX
} },
8112 { "(bad)", { XX
} },
8113 { "(bad)", { XX
} },
8115 { "(bad)", { XX
} },
8116 { "(bad)", { XX
} },
8117 { "(bad)", { XX
} },
8118 { "(bad)", { XX
} },
8119 { "(bad)", { XX
} },
8120 { "(bad)", { XX
} },
8121 { "(bad)", { XX
} },
8122 { "(bad)", { XX
} },
8124 { "(bad)", { XX
} },
8125 { "(bad)", { XX
} },
8126 { "(bad)", { XX
} },
8127 { "(bad)", { XX
} },
8128 { "(bad)", { XX
} },
8129 { "(bad)", { XX
} },
8130 { "(bad)", { XX
} },
8131 { "(bad)", { XX
} },
8133 { "(bad)", { XX
} },
8134 { "(bad)", { XX
} },
8135 { "(bad)", { XX
} },
8136 { "(bad)", { XX
} },
8137 { "(bad)", { XX
} },
8138 { "(bad)", { XX
} },
8139 { "(bad)", { XX
} },
8140 { "(bad)", { XX
} },
8144 static const struct dis386 vex_len_table
[][2] = {
8145 /* VEX_LEN_10_P_1 */
8147 { "vmovss", { XMVex
, Vex128
, EXd
} },
8148 { "(bad)", { XX
} },
8151 /* VEX_LEN_10_P_3 */
8153 { "vmovsd", { XMVex
, Vex128
, EXq
} },
8154 { "(bad)", { XX
} },
8157 /* VEX_LEN_11_P_1 */
8159 { "vmovss", { EXdVexS
, Vex128
, XM
} },
8160 { "(bad)", { XX
} },
8163 /* VEX_LEN_11_P_3 */
8165 { "vmovsd", { EXqVexS
, Vex128
, XM
} },
8166 { "(bad)", { XX
} },
8169 /* VEX_LEN_12_P_0_M_0 */
8171 { "vmovlps", { XM
, Vex128
, EXq
} },
8172 { "(bad)", { XX
} },
8175 /* VEX_LEN_12_P_0_M_1 */
8177 { "vmovhlps", { XM
, Vex128
, EXq
} },
8178 { "(bad)", { XX
} },
8181 /* VEX_LEN_12_P_2 */
8183 { "vmovlpd", { XM
, Vex128
, EXq
} },
8184 { "(bad)", { XX
} },
8187 /* VEX_LEN_13_M_0 */
8189 { "vmovlpX", { EXq
, XM
} },
8190 { "(bad)", { XX
} },
8193 /* VEX_LEN_16_P_0_M_0 */
8195 { "vmovhps", { XM
, Vex128
, EXq
} },
8196 { "(bad)", { XX
} },
8199 /* VEX_LEN_16_P_0_M_1 */
8201 { "vmovlhps", { XM
, Vex128
, EXq
} },
8202 { "(bad)", { XX
} },
8205 /* VEX_LEN_16_P_2 */
8207 { "vmovhpd", { XM
, Vex128
, EXq
} },
8208 { "(bad)", { XX
} },
8211 /* VEX_LEN_17_M_0 */
8213 { "vmovhpX", { EXq
, XM
} },
8214 { "(bad)", { XX
} },
8217 /* VEX_LEN_2A_P_1 */
8219 { "vcvtsi2ss%LQ", { XM
, Vex128
, Ev
} },
8220 { "(bad)", { XX
} },
8223 /* VEX_LEN_2A_P_3 */
8225 { "vcvtsi2sd%LQ", { XM
, Vex128
, Ev
} },
8226 { "(bad)", { XX
} },
8229 /* VEX_LEN_2C_P_1 */
8231 { "vcvttss2siY", { Gv
, EXd
} },
8232 { "(bad)", { XX
} },
8235 /* VEX_LEN_2C_P_3 */
8237 { "vcvttsd2siY", { Gv
, EXq
} },
8238 { "(bad)", { XX
} },
8241 /* VEX_LEN_2D_P_1 */
8243 { "vcvtss2siY", { Gv
, EXd
} },
8244 { "(bad)", { XX
} },
8247 /* VEX_LEN_2D_P_3 */
8249 { "vcvtsd2siY", { Gv
, EXq
} },
8250 { "(bad)", { XX
} },
8253 /* VEX_LEN_2E_P_0 */
8255 { "vucomiss", { XM
, EXd
} },
8256 { "(bad)", { XX
} },
8259 /* VEX_LEN_2E_P_2 */
8261 { "vucomisd", { XM
, EXq
} },
8262 { "(bad)", { XX
} },
8265 /* VEX_LEN_2F_P_0 */
8267 { "vcomiss", { XM
, EXd
} },
8268 { "(bad)", { XX
} },
8271 /* VEX_LEN_2F_P_2 */
8273 { "vcomisd", { XM
, EXq
} },
8274 { "(bad)", { XX
} },
8277 /* VEX_LEN_51_P_1 */
8279 { "vsqrtss", { XM
, Vex128
, EXd
} },
8280 { "(bad)", { XX
} },
8283 /* VEX_LEN_51_P_3 */
8285 { "vsqrtsd", { XM
, Vex128
, EXq
} },
8286 { "(bad)", { XX
} },
8289 /* VEX_LEN_52_P_1 */
8291 { "vrsqrtss", { XM
, Vex128
, EXd
} },
8292 { "(bad)", { XX
} },
8295 /* VEX_LEN_53_P_1 */
8297 { "vrcpss", { XM
, Vex128
, EXd
} },
8298 { "(bad)", { XX
} },
8301 /* VEX_LEN_58_P_1 */
8303 { "vaddss", { XM
, Vex128
, EXd
} },
8304 { "(bad)", { XX
} },
8307 /* VEX_LEN_58_P_3 */
8309 { "vaddsd", { XM
, Vex128
, EXq
} },
8310 { "(bad)", { XX
} },
8313 /* VEX_LEN_59_P_1 */
8315 { "vmulss", { XM
, Vex128
, EXd
} },
8316 { "(bad)", { XX
} },
8319 /* VEX_LEN_59_P_3 */
8321 { "vmulsd", { XM
, Vex128
, EXq
} },
8322 { "(bad)", { XX
} },
8325 /* VEX_LEN_5A_P_1 */
8327 { "vcvtss2sd", { XM
, Vex128
, EXd
} },
8328 { "(bad)", { XX
} },
8331 /* VEX_LEN_5A_P_3 */
8333 { "vcvtsd2ss", { XM
, Vex128
, EXq
} },
8334 { "(bad)", { XX
} },
8337 /* VEX_LEN_5C_P_1 */
8339 { "vsubss", { XM
, Vex128
, EXd
} },
8340 { "(bad)", { XX
} },
8343 /* VEX_LEN_5C_P_3 */
8345 { "vsubsd", { XM
, Vex128
, EXq
} },
8346 { "(bad)", { XX
} },
8349 /* VEX_LEN_5D_P_1 */
8351 { "vminss", { XM
, Vex128
, EXd
} },
8352 { "(bad)", { XX
} },
8355 /* VEX_LEN_5D_P_3 */
8357 { "vminsd", { XM
, Vex128
, EXq
} },
8358 { "(bad)", { XX
} },
8361 /* VEX_LEN_5E_P_1 */
8363 { "vdivss", { XM
, Vex128
, EXd
} },
8364 { "(bad)", { XX
} },
8367 /* VEX_LEN_5E_P_3 */
8369 { "vdivsd", { XM
, Vex128
, EXq
} },
8370 { "(bad)", { XX
} },
8373 /* VEX_LEN_5F_P_1 */
8375 { "vmaxss", { XM
, Vex128
, EXd
} },
8376 { "(bad)", { XX
} },
8379 /* VEX_LEN_5F_P_3 */
8381 { "vmaxsd", { XM
, Vex128
, EXq
} },
8382 { "(bad)", { XX
} },
8385 /* VEX_LEN_60_P_2 */
8387 { "vpunpcklbw", { XM
, Vex128
, EXx
} },
8388 { "(bad)", { XX
} },
8391 /* VEX_LEN_61_P_2 */
8393 { "vpunpcklwd", { XM
, Vex128
, EXx
} },
8394 { "(bad)", { XX
} },
8397 /* VEX_LEN_62_P_2 */
8399 { "vpunpckldq", { XM
, Vex128
, EXx
} },
8400 { "(bad)", { XX
} },
8403 /* VEX_LEN_63_P_2 */
8405 { "vpacksswb", { XM
, Vex128
, EXx
} },
8406 { "(bad)", { XX
} },
8409 /* VEX_LEN_64_P_2 */
8411 { "vpcmpgtb", { XM
, Vex128
, EXx
} },
8412 { "(bad)", { XX
} },
8415 /* VEX_LEN_65_P_2 */
8417 { "vpcmpgtw", { XM
, Vex128
, EXx
} },
8418 { "(bad)", { XX
} },
8421 /* VEX_LEN_66_P_2 */
8423 { "vpcmpgtd", { XM
, Vex128
, EXx
} },
8424 { "(bad)", { XX
} },
8427 /* VEX_LEN_67_P_2 */
8429 { "vpackuswb", { XM
, Vex128
, EXx
} },
8430 { "(bad)", { XX
} },
8433 /* VEX_LEN_68_P_2 */
8435 { "vpunpckhbw", { XM
, Vex128
, EXx
} },
8436 { "(bad)", { XX
} },
8439 /* VEX_LEN_69_P_2 */
8441 { "vpunpckhwd", { XM
, Vex128
, EXx
} },
8442 { "(bad)", { XX
} },
8445 /* VEX_LEN_6A_P_2 */
8447 { "vpunpckhdq", { XM
, Vex128
, EXx
} },
8448 { "(bad)", { XX
} },
8451 /* VEX_LEN_6B_P_2 */
8453 { "vpackssdw", { XM
, Vex128
, EXx
} },
8454 { "(bad)", { XX
} },
8457 /* VEX_LEN_6C_P_2 */
8459 { "vpunpcklqdq", { XM
, Vex128
, EXx
} },
8460 { "(bad)", { XX
} },
8463 /* VEX_LEN_6D_P_2 */
8465 { "vpunpckhqdq", { XM
, Vex128
, EXx
} },
8466 { "(bad)", { XX
} },
8469 /* VEX_LEN_6E_P_2 */
8471 { "vmovK", { XM
, Edq
} },
8472 { "(bad)", { XX
} },
8475 /* VEX_LEN_70_P_1 */
8477 { "vpshufhw", { XM
, EXx
, Ib
} },
8478 { "(bad)", { XX
} },
8481 /* VEX_LEN_70_P_2 */
8483 { "vpshufd", { XM
, EXx
, Ib
} },
8484 { "(bad)", { XX
} },
8487 /* VEX_LEN_70_P_3 */
8489 { "vpshuflw", { XM
, EXx
, Ib
} },
8490 { "(bad)", { XX
} },
8493 /* VEX_LEN_71_R_2_P_2 */
8495 { "vpsrlw", { Vex128
, XS
, Ib
} },
8496 { "(bad)", { XX
} },
8499 /* VEX_LEN_71_R_4_P_2 */
8501 { "vpsraw", { Vex128
, XS
, Ib
} },
8502 { "(bad)", { XX
} },
8505 /* VEX_LEN_71_R_6_P_2 */
8507 { "vpsllw", { Vex128
, XS
, Ib
} },
8508 { "(bad)", { XX
} },
8511 /* VEX_LEN_72_R_2_P_2 */
8513 { "vpsrld", { Vex128
, XS
, Ib
} },
8514 { "(bad)", { XX
} },
8517 /* VEX_LEN_72_R_4_P_2 */
8519 { "vpsrad", { Vex128
, XS
, Ib
} },
8520 { "(bad)", { XX
} },
8523 /* VEX_LEN_72_R_6_P_2 */
8525 { "vpslld", { Vex128
, XS
, Ib
} },
8526 { "(bad)", { XX
} },
8529 /* VEX_LEN_73_R_2_P_2 */
8531 { "vpsrlq", { Vex128
, XS
, Ib
} },
8532 { "(bad)", { XX
} },
8535 /* VEX_LEN_73_R_3_P_2 */
8537 { "vpsrldq", { Vex128
, XS
, Ib
} },
8538 { "(bad)", { XX
} },
8541 /* VEX_LEN_73_R_6_P_2 */
8543 { "vpsllq", { Vex128
, XS
, Ib
} },
8544 { "(bad)", { XX
} },
8547 /* VEX_LEN_73_R_7_P_2 */
8549 { "vpslldq", { Vex128
, XS
, Ib
} },
8550 { "(bad)", { XX
} },
8553 /* VEX_LEN_74_P_2 */
8555 { "vpcmpeqb", { XM
, Vex128
, EXx
} },
8556 { "(bad)", { XX
} },
8559 /* VEX_LEN_75_P_2 */
8561 { "vpcmpeqw", { XM
, Vex128
, EXx
} },
8562 { "(bad)", { XX
} },
8565 /* VEX_LEN_76_P_2 */
8567 { "vpcmpeqd", { XM
, Vex128
, EXx
} },
8568 { "(bad)", { XX
} },
8571 /* VEX_LEN_7E_P_1 */
8573 { "vmovq", { XM
, EXq
} },
8574 { "(bad)", { XX
} },
8577 /* VEX_LEN_7E_P_2 */
8579 { "vmovK", { Edq
, XM
} },
8580 { "(bad)", { XX
} },
8583 /* VEX_LEN_AE_R_2_M_0 */
8585 { "vldmxcsr", { Md
} },
8586 { "(bad)", { XX
} },
8589 /* VEX_LEN_AE_R_3_M_0 */
8591 { "vstmxcsr", { Md
} },
8592 { "(bad)", { XX
} },
8595 /* VEX_LEN_C2_P_1 */
8597 { "vcmpss", { XM
, Vex128
, EXd
, VCMP
} },
8598 { "(bad)", { XX
} },
8601 /* VEX_LEN_C2_P_3 */
8603 { "vcmpsd", { XM
, Vex128
, EXq
, VCMP
} },
8604 { "(bad)", { XX
} },
8607 /* VEX_LEN_C4_P_2 */
8609 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
} },
8610 { "(bad)", { XX
} },
8613 /* VEX_LEN_C5_P_2 */
8615 { "vpextrw", { Gdq
, XS
, Ib
} },
8616 { "(bad)", { XX
} },
8619 /* VEX_LEN_D1_P_2 */
8621 { "vpsrlw", { XM
, Vex128
, EXx
} },
8622 { "(bad)", { XX
} },
8625 /* VEX_LEN_D2_P_2 */
8627 { "vpsrld", { XM
, Vex128
, EXx
} },
8628 { "(bad)", { XX
} },
8631 /* VEX_LEN_D3_P_2 */
8633 { "vpsrlq", { XM
, Vex128
, EXx
} },
8634 { "(bad)", { XX
} },
8637 /* VEX_LEN_D4_P_2 */
8639 { "vpaddq", { XM
, Vex128
, EXx
} },
8640 { "(bad)", { XX
} },
8643 /* VEX_LEN_D5_P_2 */
8645 { "vpmullw", { XM
, Vex128
, EXx
} },
8646 { "(bad)", { XX
} },
8649 /* VEX_LEN_D6_P_2 */
8651 { "vmovq", { EXqS
, XM
} },
8652 { "(bad)", { XX
} },
8655 /* VEX_LEN_D7_P_2_M_1 */
8657 { "vpmovmskb", { Gdq
, XS
} },
8658 { "(bad)", { XX
} },
8661 /* VEX_LEN_D8_P_2 */
8663 { "vpsubusb", { XM
, Vex128
, EXx
} },
8664 { "(bad)", { XX
} },
8667 /* VEX_LEN_D9_P_2 */
8669 { "vpsubusw", { XM
, Vex128
, EXx
} },
8670 { "(bad)", { XX
} },
8673 /* VEX_LEN_DA_P_2 */
8675 { "vpminub", { XM
, Vex128
, EXx
} },
8676 { "(bad)", { XX
} },
8679 /* VEX_LEN_DB_P_2 */
8681 { "vpand", { XM
, Vex128
, EXx
} },
8682 { "(bad)", { XX
} },
8685 /* VEX_LEN_DC_P_2 */
8687 { "vpaddusb", { XM
, Vex128
, EXx
} },
8688 { "(bad)", { XX
} },
8691 /* VEX_LEN_DD_P_2 */
8693 { "vpaddusw", { XM
, Vex128
, EXx
} },
8694 { "(bad)", { XX
} },
8697 /* VEX_LEN_DE_P_2 */
8699 { "vpmaxub", { XM
, Vex128
, EXx
} },
8700 { "(bad)", { XX
} },
8703 /* VEX_LEN_DF_P_2 */
8705 { "vpandn", { XM
, Vex128
, EXx
} },
8706 { "(bad)", { XX
} },
8709 /* VEX_LEN_E0_P_2 */
8711 { "vpavgb", { XM
, Vex128
, EXx
} },
8712 { "(bad)", { XX
} },
8715 /* VEX_LEN_E1_P_2 */
8717 { "vpsraw", { XM
, Vex128
, EXx
} },
8718 { "(bad)", { XX
} },
8721 /* VEX_LEN_E2_P_2 */
8723 { "vpsrad", { XM
, Vex128
, EXx
} },
8724 { "(bad)", { XX
} },
8727 /* VEX_LEN_E3_P_2 */
8729 { "vpavgw", { XM
, Vex128
, EXx
} },
8730 { "(bad)", { XX
} },
8733 /* VEX_LEN_E4_P_2 */
8735 { "vpmulhuw", { XM
, Vex128
, EXx
} },
8736 { "(bad)", { XX
} },
8739 /* VEX_LEN_E5_P_2 */
8741 { "vpmulhw", { XM
, Vex128
, EXx
} },
8742 { "(bad)", { XX
} },
8745 /* VEX_LEN_E8_P_2 */
8747 { "vpsubsb", { XM
, Vex128
, EXx
} },
8748 { "(bad)", { XX
} },
8751 /* VEX_LEN_E9_P_2 */
8753 { "vpsubsw", { XM
, Vex128
, EXx
} },
8754 { "(bad)", { XX
} },
8757 /* VEX_LEN_EA_P_2 */
8759 { "vpminsw", { XM
, Vex128
, EXx
} },
8760 { "(bad)", { XX
} },
8763 /* VEX_LEN_EB_P_2 */
8765 { "vpor", { XM
, Vex128
, EXx
} },
8766 { "(bad)", { XX
} },
8769 /* VEX_LEN_EC_P_2 */
8771 { "vpaddsb", { XM
, Vex128
, EXx
} },
8772 { "(bad)", { XX
} },
8775 /* VEX_LEN_ED_P_2 */
8777 { "vpaddsw", { XM
, Vex128
, EXx
} },
8778 { "(bad)", { XX
} },
8781 /* VEX_LEN_EE_P_2 */
8783 { "vpmaxsw", { XM
, Vex128
, EXx
} },
8784 { "(bad)", { XX
} },
8787 /* VEX_LEN_EF_P_2 */
8789 { "vpxor", { XM
, Vex128
, EXx
} },
8790 { "(bad)", { XX
} },
8793 /* VEX_LEN_F1_P_2 */
8795 { "vpsllw", { XM
, Vex128
, EXx
} },
8796 { "(bad)", { XX
} },
8799 /* VEX_LEN_F2_P_2 */
8801 { "vpslld", { XM
, Vex128
, EXx
} },
8802 { "(bad)", { XX
} },
8805 /* VEX_LEN_F3_P_2 */
8807 { "vpsllq", { XM
, Vex128
, EXx
} },
8808 { "(bad)", { XX
} },
8811 /* VEX_LEN_F4_P_2 */
8813 { "vpmuludq", { XM
, Vex128
, EXx
} },
8814 { "(bad)", { XX
} },
8817 /* VEX_LEN_F5_P_2 */
8819 { "vpmaddwd", { XM
, Vex128
, EXx
} },
8820 { "(bad)", { XX
} },
8823 /* VEX_LEN_F6_P_2 */
8825 { "vpsadbw", { XM
, Vex128
, EXx
} },
8826 { "(bad)", { XX
} },
8829 /* VEX_LEN_F7_P_2 */
8831 { "vmaskmovdqu", { XM
, XS
} },
8832 { "(bad)", { XX
} },
8835 /* VEX_LEN_F8_P_2 */
8837 { "vpsubb", { XM
, Vex128
, EXx
} },
8838 { "(bad)", { XX
} },
8841 /* VEX_LEN_F9_P_2 */
8843 { "vpsubw", { XM
, Vex128
, EXx
} },
8844 { "(bad)", { XX
} },
8847 /* VEX_LEN_FA_P_2 */
8849 { "vpsubd", { XM
, Vex128
, EXx
} },
8850 { "(bad)", { XX
} },
8853 /* VEX_LEN_FB_P_2 */
8855 { "vpsubq", { XM
, Vex128
, EXx
} },
8856 { "(bad)", { XX
} },
8859 /* VEX_LEN_FC_P_2 */
8861 { "vpaddb", { XM
, Vex128
, EXx
} },
8862 { "(bad)", { XX
} },
8865 /* VEX_LEN_FD_P_2 */
8867 { "vpaddw", { XM
, Vex128
, EXx
} },
8868 { "(bad)", { XX
} },
8871 /* VEX_LEN_FE_P_2 */
8873 { "vpaddd", { XM
, Vex128
, EXx
} },
8874 { "(bad)", { XX
} },
8877 /* VEX_LEN_3800_P_2 */
8879 { "vpshufb", { XM
, Vex128
, EXx
} },
8880 { "(bad)", { XX
} },
8883 /* VEX_LEN_3801_P_2 */
8885 { "vphaddw", { XM
, Vex128
, EXx
} },
8886 { "(bad)", { XX
} },
8889 /* VEX_LEN_3802_P_2 */
8891 { "vphaddd", { XM
, Vex128
, EXx
} },
8892 { "(bad)", { XX
} },
8895 /* VEX_LEN_3803_P_2 */
8897 { "vphaddsw", { XM
, Vex128
, EXx
} },
8898 { "(bad)", { XX
} },
8901 /* VEX_LEN_3804_P_2 */
8903 { "vpmaddubsw", { XM
, Vex128
, EXx
} },
8904 { "(bad)", { XX
} },
8907 /* VEX_LEN_3805_P_2 */
8909 { "vphsubw", { XM
, Vex128
, EXx
} },
8910 { "(bad)", { XX
} },
8913 /* VEX_LEN_3806_P_2 */
8915 { "vphsubd", { XM
, Vex128
, EXx
} },
8916 { "(bad)", { XX
} },
8919 /* VEX_LEN_3807_P_2 */
8921 { "vphsubsw", { XM
, Vex128
, EXx
} },
8922 { "(bad)", { XX
} },
8925 /* VEX_LEN_3808_P_2 */
8927 { "vpsignb", { XM
, Vex128
, EXx
} },
8928 { "(bad)", { XX
} },
8931 /* VEX_LEN_3809_P_2 */
8933 { "vpsignw", { XM
, Vex128
, EXx
} },
8934 { "(bad)", { XX
} },
8937 /* VEX_LEN_380A_P_2 */
8939 { "vpsignd", { XM
, Vex128
, EXx
} },
8940 { "(bad)", { XX
} },
8943 /* VEX_LEN_380B_P_2 */
8945 { "vpmulhrsw", { XM
, Vex128
, EXx
} },
8946 { "(bad)", { XX
} },
8949 /* VEX_LEN_3819_P_2_M_0 */
8951 { "(bad)", { XX
} },
8952 { "vbroadcastsd", { XM
, Mq
} },
8955 /* VEX_LEN_381A_P_2_M_0 */
8957 { "(bad)", { XX
} },
8958 { "vbroadcastf128", { XM
, Mxmm
} },
8961 /* VEX_LEN_381C_P_2 */
8963 { "vpabsb", { XM
, EXx
} },
8964 { "(bad)", { XX
} },
8967 /* VEX_LEN_381D_P_2 */
8969 { "vpabsw", { XM
, EXx
} },
8970 { "(bad)", { XX
} },
8973 /* VEX_LEN_381E_P_2 */
8975 { "vpabsd", { XM
, EXx
} },
8976 { "(bad)", { XX
} },
8979 /* VEX_LEN_3820_P_2 */
8981 { "vpmovsxbw", { XM
, EXq
} },
8982 { "(bad)", { XX
} },
8985 /* VEX_LEN_3821_P_2 */
8987 { "vpmovsxbd", { XM
, EXd
} },
8988 { "(bad)", { XX
} },
8991 /* VEX_LEN_3822_P_2 */
8993 { "vpmovsxbq", { XM
, EXw
} },
8994 { "(bad)", { XX
} },
8997 /* VEX_LEN_3823_P_2 */
8999 { "vpmovsxwd", { XM
, EXq
} },
9000 { "(bad)", { XX
} },
9003 /* VEX_LEN_3824_P_2 */
9005 { "vpmovsxwq", { XM
, EXd
} },
9006 { "(bad)", { XX
} },
9009 /* VEX_LEN_3825_P_2 */
9011 { "vpmovsxdq", { XM
, EXq
} },
9012 { "(bad)", { XX
} },
9015 /* VEX_LEN_3828_P_2 */
9017 { "vpmuldq", { XM
, Vex128
, EXx
} },
9018 { "(bad)", { XX
} },
9021 /* VEX_LEN_3829_P_2 */
9023 { "vpcmpeqq", { XM
, Vex128
, EXx
} },
9024 { "(bad)", { XX
} },
9027 /* VEX_LEN_382A_P_2_M_0 */
9029 { "vmovntdqa", { XM
, Mx
} },
9030 { "(bad)", { XX
} },
9033 /* VEX_LEN_382B_P_2 */
9035 { "vpackusdw", { XM
, Vex128
, EXx
} },
9036 { "(bad)", { XX
} },
9039 /* VEX_LEN_3830_P_2 */
9041 { "vpmovzxbw", { XM
, EXq
} },
9042 { "(bad)", { XX
} },
9045 /* VEX_LEN_3831_P_2 */
9047 { "vpmovzxbd", { XM
, EXd
} },
9048 { "(bad)", { XX
} },
9051 /* VEX_LEN_3832_P_2 */
9053 { "vpmovzxbq", { XM
, EXw
} },
9054 { "(bad)", { XX
} },
9057 /* VEX_LEN_3833_P_2 */
9059 { "vpmovzxwd", { XM
, EXq
} },
9060 { "(bad)", { XX
} },
9063 /* VEX_LEN_3834_P_2 */
9065 { "vpmovzxwq", { XM
, EXd
} },
9066 { "(bad)", { XX
} },
9069 /* VEX_LEN_3835_P_2 */
9071 { "vpmovzxdq", { XM
, EXq
} },
9072 { "(bad)", { XX
} },
9075 /* VEX_LEN_3837_P_2 */
9077 { "vpcmpgtq", { XM
, Vex128
, EXx
} },
9078 { "(bad)", { XX
} },
9081 /* VEX_LEN_3838_P_2 */
9083 { "vpminsb", { XM
, Vex128
, EXx
} },
9084 { "(bad)", { XX
} },
9087 /* VEX_LEN_3839_P_2 */
9089 { "vpminsd", { XM
, Vex128
, EXx
} },
9090 { "(bad)", { XX
} },
9093 /* VEX_LEN_383A_P_2 */
9095 { "vpminuw", { XM
, Vex128
, EXx
} },
9096 { "(bad)", { XX
} },
9099 /* VEX_LEN_383B_P_2 */
9101 { "vpminud", { XM
, Vex128
, EXx
} },
9102 { "(bad)", { XX
} },
9105 /* VEX_LEN_383C_P_2 */
9107 { "vpmaxsb", { XM
, Vex128
, EXx
} },
9108 { "(bad)", { XX
} },
9111 /* VEX_LEN_383D_P_2 */
9113 { "vpmaxsd", { XM
, Vex128
, EXx
} },
9114 { "(bad)", { XX
} },
9117 /* VEX_LEN_383E_P_2 */
9119 { "vpmaxuw", { XM
, Vex128
, EXx
} },
9120 { "(bad)", { XX
} },
9123 /* VEX_LEN_383F_P_2 */
9125 { "vpmaxud", { XM
, Vex128
, EXx
} },
9126 { "(bad)", { XX
} },
9129 /* VEX_LEN_3840_P_2 */
9131 { "vpmulld", { XM
, Vex128
, EXx
} },
9132 { "(bad)", { XX
} },
9135 /* VEX_LEN_3841_P_2 */
9137 { "vphminposuw", { XM
, EXx
} },
9138 { "(bad)", { XX
} },
9141 /* VEX_LEN_38DB_P_2 */
9143 { "vaesimc", { XM
, EXx
} },
9144 { "(bad)", { XX
} },
9147 /* VEX_LEN_38DC_P_2 */
9149 { "vaesenc", { XM
, Vex128
, EXx
} },
9150 { "(bad)", { XX
} },
9153 /* VEX_LEN_38DD_P_2 */
9155 { "vaesenclast", { XM
, Vex128
, EXx
} },
9156 { "(bad)", { XX
} },
9159 /* VEX_LEN_38DE_P_2 */
9161 { "vaesdec", { XM
, Vex128
, EXx
} },
9162 { "(bad)", { XX
} },
9165 /* VEX_LEN_38DF_P_2 */
9167 { "vaesdeclast", { XM
, Vex128
, EXx
} },
9168 { "(bad)", { XX
} },
9171 /* VEX_LEN_3A06_P_2 */
9173 { "(bad)", { XX
} },
9174 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
} },
9177 /* VEX_LEN_3A0A_P_2 */
9179 { "vroundss", { XM
, Vex128
, EXd
, Ib
} },
9180 { "(bad)", { XX
} },
9183 /* VEX_LEN_3A0B_P_2 */
9185 { "vroundsd", { XM
, Vex128
, EXq
, Ib
} },
9186 { "(bad)", { XX
} },
9189 /* VEX_LEN_3A0E_P_2 */
9191 { "vpblendw", { XM
, Vex128
, EXx
, Ib
} },
9192 { "(bad)", { XX
} },
9195 /* VEX_LEN_3A0F_P_2 */
9197 { "vpalignr", { XM
, Vex128
, EXx
, Ib
} },
9198 { "(bad)", { XX
} },
9201 /* VEX_LEN_3A14_P_2 */
9203 { "vpextrb", { Edqb
, XM
, Ib
} },
9204 { "(bad)", { XX
} },
9207 /* VEX_LEN_3A15_P_2 */
9209 { "vpextrw", { Edqw
, XM
, Ib
} },
9210 { "(bad)", { XX
} },
9213 /* VEX_LEN_3A16_P_2 */
9215 { "vpextrK", { Edq
, XM
, Ib
} },
9216 { "(bad)", { XX
} },
9219 /* VEX_LEN_3A17_P_2 */
9221 { "vextractps", { Edqd
, XM
, Ib
} },
9222 { "(bad)", { XX
} },
9225 /* VEX_LEN_3A18_P_2 */
9227 { "(bad)", { XX
} },
9228 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
} },
9231 /* VEX_LEN_3A19_P_2 */
9233 { "(bad)", { XX
} },
9234 { "vextractf128", { EXxmm
, XM
, Ib
} },
9237 /* VEX_LEN_3A20_P_2 */
9239 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
} },
9240 { "(bad)", { XX
} },
9243 /* VEX_LEN_3A21_P_2 */
9245 { "vinsertps", { XM
, Vex128
, EXd
, Ib
} },
9246 { "(bad)", { XX
} },
9249 /* VEX_LEN_3A22_P_2 */
9251 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
} },
9252 { "(bad)", { XX
} },
9255 /* VEX_LEN_3A41_P_2 */
9257 { "vdppd", { XM
, Vex128
, EXx
, Ib
} },
9258 { "(bad)", { XX
} },
9261 /* VEX_LEN_3A42_P_2 */
9263 { "vmpsadbw", { XM
, Vex128
, EXx
, Ib
} },
9264 { "(bad)", { XX
} },
9267 /* VEX_LEN_3A44_P_2 */
9269 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
} },
9270 { "(bad)", { XX
} },
9273 /* VEX_LEN_3A4C_P_2 */
9275 { "vpblendvb", { XM
, Vex128
, EXx
, XMVexI4
} },
9276 { "(bad)", { XX
} },
9279 /* VEX_LEN_3A60_P_2 */
9281 { "vpcmpestrm", { XM
, EXx
, Ib
} },
9282 { "(bad)", { XX
} },
9285 /* VEX_LEN_3A61_P_2 */
9287 { "vpcmpestri", { XM
, EXx
, Ib
} },
9288 { "(bad)", { XX
} },
9291 /* VEX_LEN_3A62_P_2 */
9293 { "vpcmpistrm", { XM
, EXx
, Ib
} },
9294 { "(bad)", { XX
} },
9297 /* VEX_LEN_3A63_P_2 */
9299 { "vpcmpistri", { XM
, EXx
, Ib
} },
9300 { "(bad)", { XX
} },
9303 /* VEX_LEN_3A6A_P_2 */
9305 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9306 { "(bad)", { XX
} },
9309 /* VEX_LEN_3A6B_P_2 */
9311 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9312 { "(bad)", { XX
} },
9315 /* VEX_LEN_3A6E_P_2 */
9317 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9318 { "(bad)", { XX
} },
9321 /* VEX_LEN_3A6F_P_2 */
9323 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9324 { "(bad)", { XX
} },
9327 /* VEX_LEN_3A7A_P_2 */
9329 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9330 { "(bad)", { XX
} },
9333 /* VEX_LEN_3A7B_P_2 */
9335 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9336 { "(bad)", { XX
} },
9339 /* VEX_LEN_3A7E_P_2 */
9341 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
} },
9342 { "(bad)", { XX
} },
9345 /* VEX_LEN_3A7F_P_2 */
9347 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
} },
9348 { "(bad)", { XX
} },
9351 /* VEX_LEN_3ADF_P_2 */
9353 { "vaeskeygenassist", { XM
, EXx
, Ib
} },
9354 { "(bad)", { XX
} },
9356 /* VEX_LEN_XOP_09_80 */
9358 { "vfrczps", { XM
, EXxmm
} },
9359 { "vfrczps", { XM
, EXymmq
} },
9361 /* VEX_LEN_XOP_09_81 */
9363 { "vfrczpd", { XM
, EXxmm
} },
9364 { "vfrczpd", { XM
, EXymmq
} },
9368 static const struct dis386 mod_table
[][2] = {
9371 { "leaS", { Gv
, M
} },
9372 { "(bad)", { XX
} },
9375 /* MOD_0F01_REG_0 */
9376 { X86_64_TABLE (X86_64_0F01_REG_0
) },
9377 { RM_TABLE (RM_0F01_REG_0
) },
9380 /* MOD_0F01_REG_1 */
9381 { X86_64_TABLE (X86_64_0F01_REG_1
) },
9382 { RM_TABLE (RM_0F01_REG_1
) },
9385 /* MOD_0F01_REG_2 */
9386 { X86_64_TABLE (X86_64_0F01_REG_2
) },
9387 { RM_TABLE (RM_0F01_REG_2
) },
9390 /* MOD_0F01_REG_3 */
9391 { X86_64_TABLE (X86_64_0F01_REG_3
) },
9392 { RM_TABLE (RM_0F01_REG_3
) },
9395 /* MOD_0F01_REG_7 */
9396 { "invlpg", { Mb
} },
9397 { RM_TABLE (RM_0F01_REG_7
) },
9400 /* MOD_0F12_PREFIX_0 */
9401 { "movlps", { XM
, EXq
} },
9402 { "movhlps", { XM
, EXq
} },
9406 { "movlpX", { EXq
, XM
} },
9407 { "(bad)", { XX
} },
9410 /* MOD_0F16_PREFIX_0 */
9411 { "movhps", { XM
, EXq
} },
9412 { "movlhps", { XM
, EXq
} },
9416 { "movhpX", { EXq
, XM
} },
9417 { "(bad)", { XX
} },
9420 /* MOD_0F18_REG_0 */
9421 { "prefetchnta", { Mb
} },
9422 { "(bad)", { XX
} },
9425 /* MOD_0F18_REG_1 */
9426 { "prefetcht0", { Mb
} },
9427 { "(bad)", { XX
} },
9430 /* MOD_0F18_REG_2 */
9431 { "prefetcht1", { Mb
} },
9432 { "(bad)", { XX
} },
9435 /* MOD_0F18_REG_3 */
9436 { "prefetcht2", { Mb
} },
9437 { "(bad)", { XX
} },
9441 { "(bad)", { XX
} },
9442 { "movZ", { Rm
, Cm
} },
9446 { "(bad)", { XX
} },
9447 { "movZ", { Rm
, Dm
} },
9451 { "(bad)", { XX
} },
9452 { "movZ", { Cm
, Rm
} },
9456 { "(bad)", { XX
} },
9457 { "movZ", { Dm
, Rm
} },
9461 { "(bad)", { XX
} },
9462 { "movL", { Rd
, Td
} },
9466 { "(bad)", { XX
} },
9467 { "movL", { Td
, Rd
} },
9470 /* MOD_0F2B_PREFIX_0 */
9471 {"movntps", { Mx
, XM
} },
9472 { "(bad)", { XX
} },
9475 /* MOD_0F2B_PREFIX_1 */
9476 {"movntss", { Md
, XM
} },
9477 { "(bad)", { XX
} },
9480 /* MOD_0F2B_PREFIX_2 */
9481 {"movntpd", { Mx
, XM
} },
9482 { "(bad)", { XX
} },
9485 /* MOD_0F2B_PREFIX_3 */
9486 {"movntsd", { Mq
, XM
} },
9487 { "(bad)", { XX
} },
9491 { "(bad)", { XX
} },
9492 { "movmskpX", { Gdq
, XS
} },
9495 /* MOD_0F71_REG_2 */
9496 { "(bad)", { XX
} },
9497 { "psrlw", { MS
, Ib
} },
9500 /* MOD_0F71_REG_4 */
9501 { "(bad)", { XX
} },
9502 { "psraw", { MS
, Ib
} },
9505 /* MOD_0F71_REG_6 */
9506 { "(bad)", { XX
} },
9507 { "psllw", { MS
, Ib
} },
9510 /* MOD_0F72_REG_2 */
9511 { "(bad)", { XX
} },
9512 { "psrld", { MS
, Ib
} },
9515 /* MOD_0F72_REG_4 */
9516 { "(bad)", { XX
} },
9517 { "psrad", { MS
, Ib
} },
9520 /* MOD_0F72_REG_6 */
9521 { "(bad)", { XX
} },
9522 { "pslld", { MS
, Ib
} },
9525 /* MOD_0F73_REG_2 */
9526 { "(bad)", { XX
} },
9527 { "psrlq", { MS
, Ib
} },
9530 /* MOD_0F73_REG_3 */
9531 { "(bad)", { XX
} },
9532 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
9535 /* MOD_0F73_REG_6 */
9536 { "(bad)", { XX
} },
9537 { "psllq", { MS
, Ib
} },
9540 /* MOD_0F73_REG_7 */
9541 { "(bad)", { XX
} },
9542 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
9545 /* MOD_0FAE_REG_0 */
9546 { "fxsave", { FXSAVE
} },
9547 { "(bad)", { XX
} },
9550 /* MOD_0FAE_REG_1 */
9551 { "fxrstor", { FXSAVE
} },
9552 { "(bad)", { XX
} },
9555 /* MOD_0FAE_REG_2 */
9556 { "ldmxcsr", { Md
} },
9557 { "(bad)", { XX
} },
9560 /* MOD_0FAE_REG_3 */
9561 { "stmxcsr", { Md
} },
9562 { "(bad)", { XX
} },
9565 /* MOD_0FAE_REG_4 */
9567 { "(bad)", { XX
} },
9570 /* MOD_0FAE_REG_5 */
9571 { "xrstor", { M
} },
9572 { RM_TABLE (RM_0FAE_REG_5
) },
9575 /* MOD_0FAE_REG_6 */
9576 { "xsaveopt", { M
} },
9577 { RM_TABLE (RM_0FAE_REG_6
) },
9580 /* MOD_0FAE_REG_7 */
9581 { "clflush", { Mb
} },
9582 { RM_TABLE (RM_0FAE_REG_7
) },
9586 { "lssS", { Gv
, Mp
} },
9587 { "(bad)", { XX
} },
9591 { "lfsS", { Gv
, Mp
} },
9592 { "(bad)", { XX
} },
9596 { "lgsS", { Gv
, Mp
} },
9597 { "(bad)", { XX
} },
9600 /* MOD_0FC7_REG_6 */
9601 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
9602 { "(bad)", { XX
} },
9605 /* MOD_0FC7_REG_7 */
9606 { "vmptrst", { Mq
} },
9607 { "(bad)", { XX
} },
9611 { "(bad)", { XX
} },
9612 { "pmovmskb", { Gdq
, MS
} },
9615 /* MOD_0FE7_PREFIX_2 */
9616 { "movntdq", { Mx
, XM
} },
9617 { "(bad)", { XX
} },
9620 /* MOD_0FF0_PREFIX_3 */
9621 { "lddqu", { XM
, M
} },
9622 { "(bad)", { XX
} },
9625 /* MOD_0F382A_PREFIX_2 */
9626 { "movntdqa", { XM
, Mx
} },
9627 { "(bad)", { XX
} },
9631 { "bound{S|}", { Gv
, Ma
} },
9632 { "(bad)", { XX
} },
9636 { "lesS", { Gv
, Mp
} },
9637 { VEX_C4_TABLE (VEX_0F
) },
9641 { "ldsS", { Gv
, Mp
} },
9642 { VEX_C5_TABLE (VEX_0F
) },
9645 /* MOD_VEX_12_PREFIX_0 */
9646 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
9647 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
9651 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
9652 { "(bad)", { XX
} },
9655 /* MOD_VEX_16_PREFIX_0 */
9656 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
9657 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
9661 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
9662 { "(bad)", { XX
} },
9666 { "vmovntpX", { Mx
, XM
} },
9667 { "(bad)", { XX
} },
9671 { "(bad)", { XX
} },
9672 { "vmovmskpX", { Gdq
, XS
} },
9675 /* MOD_VEX_71_REG_2 */
9676 { "(bad)", { XX
} },
9677 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
9680 /* MOD_VEX_71_REG_4 */
9681 { "(bad)", { XX
} },
9682 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
9685 /* MOD_VEX_71_REG_6 */
9686 { "(bad)", { XX
} },
9687 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
9690 /* MOD_VEX_72_REG_2 */
9691 { "(bad)", { XX
} },
9692 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
9695 /* MOD_VEX_72_REG_4 */
9696 { "(bad)", { XX
} },
9697 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
9700 /* MOD_VEX_72_REG_6 */
9701 { "(bad)", { XX
} },
9702 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
9705 /* MOD_VEX_73_REG_2 */
9706 { "(bad)", { XX
} },
9707 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
9710 /* MOD_VEX_73_REG_3 */
9711 { "(bad)", { XX
} },
9712 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
9715 /* MOD_VEX_73_REG_6 */
9716 { "(bad)", { XX
} },
9717 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
9720 /* MOD_VEX_73_REG_7 */
9721 { "(bad)", { XX
} },
9722 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
9725 /* MOD_VEX_AE_REG_2 */
9726 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
9727 { "(bad)", { XX
} },
9730 /* MOD_VEX_AE_REG_3 */
9731 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
9732 { "(bad)", { XX
} },
9735 /* MOD_VEX_D7_PREFIX_2 */
9736 { "(bad)", { XX
} },
9737 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
9740 /* MOD_VEX_E7_PREFIX_2 */
9741 { "vmovntdq", { Mx
, XM
} },
9742 { "(bad)", { XX
} },
9745 /* MOD_VEX_F0_PREFIX_3 */
9746 { "vlddqu", { XM
, M
} },
9747 { "(bad)", { XX
} },
9750 /* MOD_VEX_3818_PREFIX_2 */
9751 { "vbroadcastss", { XM
, Md
} },
9752 { "(bad)", { XX
} },
9755 /* MOD_VEX_3819_PREFIX_2 */
9756 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
9757 { "(bad)", { XX
} },
9760 /* MOD_VEX_381A_PREFIX_2 */
9761 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
9762 { "(bad)", { XX
} },
9765 /* MOD_VEX_382A_PREFIX_2 */
9766 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
9767 { "(bad)", { XX
} },
9770 /* MOD_VEX_382C_PREFIX_2 */
9771 { "vmaskmovps", { XM
, Vex
, Mx
} },
9772 { "(bad)", { XX
} },
9775 /* MOD_VEX_382D_PREFIX_2 */
9776 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9777 { "(bad)", { XX
} },
9780 /* MOD_VEX_382E_PREFIX_2 */
9781 { "vmaskmovps", { Mx
, Vex
, XM
} },
9782 { "(bad)", { XX
} },
9785 /* MOD_VEX_382F_PREFIX_2 */
9786 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9787 { "(bad)", { XX
} },
9791 static const struct dis386 rm_table
[][8] = {
9794 { "(bad)", { XX
} },
9795 { "vmcall", { Skip_MODRM
} },
9796 { "vmlaunch", { Skip_MODRM
} },
9797 { "vmresume", { Skip_MODRM
} },
9798 { "vmxoff", { Skip_MODRM
} },
9799 { "(bad)", { XX
} },
9800 { "(bad)", { XX
} },
9801 { "(bad)", { XX
} },
9805 { "monitor", { { OP_Monitor
, 0 } } },
9806 { "mwait", { { OP_Mwait
, 0 } } },
9807 { "(bad)", { XX
} },
9808 { "(bad)", { XX
} },
9809 { "(bad)", { XX
} },
9810 { "(bad)", { XX
} },
9811 { "(bad)", { XX
} },
9812 { "(bad)", { XX
} },
9816 { "xgetbv", { Skip_MODRM
} },
9817 { "xsetbv", { Skip_MODRM
} },
9818 { "(bad)", { XX
} },
9819 { "(bad)", { XX
} },
9820 { "(bad)", { XX
} },
9821 { "(bad)", { XX
} },
9822 { "(bad)", { XX
} },
9823 { "(bad)", { XX
} },
9827 { "vmrun", { Skip_MODRM
} },
9828 { "vmmcall", { Skip_MODRM
} },
9829 { "vmload", { Skip_MODRM
} },
9830 { "vmsave", { Skip_MODRM
} },
9831 { "stgi", { Skip_MODRM
} },
9832 { "clgi", { Skip_MODRM
} },
9833 { "skinit", { Skip_MODRM
} },
9834 { "invlpga", { Skip_MODRM
} },
9838 { "swapgs", { Skip_MODRM
} },
9839 { "rdtscp", { Skip_MODRM
} },
9840 { "(bad)", { XX
} },
9841 { "(bad)", { XX
} },
9842 { "(bad)", { XX
} },
9843 { "(bad)", { XX
} },
9844 { "(bad)", { XX
} },
9845 { "(bad)", { XX
} },
9849 { "lfence", { Skip_MODRM
} },
9850 { "(bad)", { XX
} },
9851 { "(bad)", { XX
} },
9852 { "(bad)", { XX
} },
9853 { "(bad)", { XX
} },
9854 { "(bad)", { XX
} },
9855 { "(bad)", { XX
} },
9856 { "(bad)", { XX
} },
9860 { "mfence", { Skip_MODRM
} },
9861 { "(bad)", { XX
} },
9862 { "(bad)", { XX
} },
9863 { "(bad)", { XX
} },
9864 { "(bad)", { XX
} },
9865 { "(bad)", { XX
} },
9866 { "(bad)", { XX
} },
9867 { "(bad)", { XX
} },
9871 { "sfence", { Skip_MODRM
} },
9872 { "(bad)", { XX
} },
9873 { "(bad)", { XX
} },
9874 { "(bad)", { XX
} },
9875 { "(bad)", { XX
} },
9876 { "(bad)", { XX
} },
9877 { "(bad)", { XX
} },
9878 { "(bad)", { XX
} },
9882 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9884 /* We use the high bit to indicate different name for the same
9886 #define ADDR16_PREFIX (0x67 | 0x100)
9887 #define ADDR32_PREFIX (0x67 | 0x200)
9888 #define DATA16_PREFIX (0x66 | 0x100)
9889 #define DATA32_PREFIX (0x66 | 0x200)
9890 #define REP_PREFIX (0xf3 | 0x100)
9895 int newrex
, i
, length
;
9902 last_lock_prefix
= -1;
9903 last_repz_prefix
= -1;
9904 last_repnz_prefix
= -1;
9905 last_data_prefix
= -1;
9906 last_addr_prefix
= -1;
9907 last_rex_prefix
= -1;
9908 last_seg_prefix
= -1;
9909 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
9910 all_prefixes
[i
] = 0;
9913 /* The maximum instruction length is 15bytes. */
9914 while (length
< MAX_CODE_LENGTH
- 1)
9916 FETCH_DATA (the_info
, codep
+ 1);
9920 /* REX prefixes family. */
9937 if (address_mode
== mode_64bit
)
9941 last_rex_prefix
= i
;
9944 prefixes
|= PREFIX_REPZ
;
9945 last_repz_prefix
= i
;
9948 prefixes
|= PREFIX_REPNZ
;
9949 last_repnz_prefix
= i
;
9952 prefixes
|= PREFIX_LOCK
;
9953 last_lock_prefix
= i
;
9956 prefixes
|= PREFIX_CS
;
9957 last_seg_prefix
= i
;
9960 prefixes
|= PREFIX_SS
;
9961 last_seg_prefix
= i
;
9964 prefixes
|= PREFIX_DS
;
9965 last_seg_prefix
= i
;
9968 prefixes
|= PREFIX_ES
;
9969 last_seg_prefix
= i
;
9972 prefixes
|= PREFIX_FS
;
9973 last_seg_prefix
= i
;
9976 prefixes
|= PREFIX_GS
;
9977 last_seg_prefix
= i
;
9980 prefixes
|= PREFIX_DATA
;
9981 last_data_prefix
= i
;
9984 prefixes
|= PREFIX_ADDR
;
9985 last_addr_prefix
= i
;
9988 /* fwait is really an instruction. If there are prefixes
9989 before the fwait, they belong to the fwait, *not* to the
9990 following instruction. */
9991 if (prefixes
|| rex
)
9993 prefixes
|= PREFIX_FWAIT
;
9997 prefixes
= PREFIX_FWAIT
;
10002 /* Rex is ignored when followed by another prefix. */
10008 if (*codep
!= FWAIT_OPCODE
)
10009 all_prefixes
[i
++] = *codep
;
10011 rex_original
= rex
;
10019 seg_prefix (int pref
)
10040 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10043 static const char *
10044 prefix_name (int pref
, int sizeflag
)
10046 static const char *rexes
[16] =
10049 "rex.B", /* 0x41 */
10050 "rex.X", /* 0x42 */
10051 "rex.XB", /* 0x43 */
10052 "rex.R", /* 0x44 */
10053 "rex.RB", /* 0x45 */
10054 "rex.RX", /* 0x46 */
10055 "rex.RXB", /* 0x47 */
10056 "rex.W", /* 0x48 */
10057 "rex.WB", /* 0x49 */
10058 "rex.WX", /* 0x4a */
10059 "rex.WXB", /* 0x4b */
10060 "rex.WR", /* 0x4c */
10061 "rex.WRB", /* 0x4d */
10062 "rex.WRX", /* 0x4e */
10063 "rex.WRXB", /* 0x4f */
10068 /* REX prefixes family. */
10085 return rexes
[pref
- 0x40];
10105 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10107 if (address_mode
== mode_64bit
)
10108 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10110 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10113 case ADDR16_PREFIX
:
10115 case ADDR32_PREFIX
:
10117 case DATA16_PREFIX
:
10119 case DATA32_PREFIX
:
10128 static char op_out
[MAX_OPERANDS
][100];
10129 static int op_ad
, op_index
[MAX_OPERANDS
];
10130 static int two_source_ops
;
10131 static bfd_vma op_address
[MAX_OPERANDS
];
10132 static bfd_vma op_riprel
[MAX_OPERANDS
];
10133 static bfd_vma start_pc
;
10136 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10137 * (see topic "Redundant prefixes" in the "Differences from 8086"
10138 * section of the "Virtual 8086 Mode" chapter.)
10139 * 'pc' should be the address of this instruction, it will
10140 * be used to print the target address if this is a relative jump or call
10141 * The function returns the length of this instruction in bytes.
10144 static char intel_syntax
;
10145 static char intel_mnemonic
= !SYSV386_COMPAT
;
10146 static char open_char
;
10147 static char close_char
;
10148 static char separator_char
;
10149 static char scale_char
;
10151 /* Here for backwards compatibility. When gdb stops using
10152 print_insn_i386_att and print_insn_i386_intel these functions can
10153 disappear, and print_insn_i386 be merged into print_insn. */
10155 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10159 return print_insn (pc
, info
);
10163 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10167 return print_insn (pc
, info
);
10171 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10175 return print_insn (pc
, info
);
10179 print_i386_disassembler_options (FILE *stream
)
10181 fprintf (stream
, _("\n\
10182 The following i386/x86-64 specific disassembler options are supported for use\n\
10183 with the -M switch (multiple options should be separated by commas):\n"));
10185 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10186 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10187 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10188 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10189 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10190 fprintf (stream
, _(" att-mnemonic\n"
10191 " Display instruction in AT&T mnemonic\n"));
10192 fprintf (stream
, _(" intel-mnemonic\n"
10193 " Display instruction in Intel mnemonic\n"));
10194 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10195 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10196 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10197 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10198 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10199 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10202 /* Get a pointer to struct dis386 with a valid name. */
10204 static const struct dis386
*
10205 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10207 int vindex
, vex_table_index
;
10209 if (dp
->name
!= NULL
)
10212 switch (dp
->op
[0].bytemode
)
10214 case USE_REG_TABLE
:
10215 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10218 case USE_MOD_TABLE
:
10219 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
10220 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
10224 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10227 case USE_PREFIX_TABLE
:
10230 /* The prefix in VEX is implicit. */
10231 switch (vex
.prefix
)
10236 case REPE_PREFIX_OPCODE
:
10239 case DATA_PREFIX_OPCODE
:
10242 case REPNE_PREFIX_OPCODE
:
10253 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10254 if (prefixes
& PREFIX_REPZ
)
10257 all_prefixes
[last_repz_prefix
] = 0;
10261 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10263 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10264 if (prefixes
& PREFIX_REPNZ
)
10267 all_prefixes
[last_repnz_prefix
] = 0;
10271 used_prefixes
|= (prefixes
& PREFIX_DATA
);
10272 if (prefixes
& PREFIX_DATA
)
10275 all_prefixes
[last_data_prefix
] = 0;
10280 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
10283 case USE_X86_64_TABLE
:
10284 vindex
= address_mode
== mode_64bit
? 1 : 0;
10285 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
10288 case USE_3BYTE_TABLE
:
10289 FETCH_DATA (info
, codep
+ 2);
10291 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
10292 modrm
.mod
= (*codep
>> 6) & 3;
10293 modrm
.reg
= (*codep
>> 3) & 7;
10294 modrm
.rm
= *codep
& 7;
10297 case USE_VEX_LEN_TABLE
:
10301 switch (vex
.length
)
10314 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
10317 case USE_XOP_8F_TABLE
:
10318 FETCH_DATA (info
, codep
+ 3);
10319 /* All bits in the REX prefix are ignored. */
10321 rex
= ~(*codep
>> 5) & 0x7;
10323 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10324 switch ((*codep
& 0x1f))
10329 vex_table_index
= XOP_08
;
10332 vex_table_index
= XOP_09
;
10335 vex_table_index
= XOP_0A
;
10339 vex
.w
= *codep
& 0x80;
10340 if (vex
.w
&& address_mode
== mode_64bit
)
10343 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10344 if (address_mode
!= mode_64bit
10345 && vex
.register_specifier
> 0x7)
10348 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10349 switch ((*codep
& 0x3))
10355 vex
.prefix
= DATA_PREFIX_OPCODE
;
10358 vex
.prefix
= REPE_PREFIX_OPCODE
;
10361 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10368 dp
= &xop_table
[vex_table_index
][vindex
];
10370 FETCH_DATA (info
, codep
+ 1);
10371 modrm
.mod
= (*codep
>> 6) & 3;
10372 modrm
.reg
= (*codep
>> 3) & 7;
10373 modrm
.rm
= *codep
& 7;
10376 case USE_VEX_C4_TABLE
:
10377 FETCH_DATA (info
, codep
+ 3);
10378 /* All bits in the REX prefix are ignored. */
10380 rex
= ~(*codep
>> 5) & 0x7;
10381 switch ((*codep
& 0x1f))
10386 vex_table_index
= VEX_0F
;
10389 vex_table_index
= VEX_0F38
;
10392 vex_table_index
= VEX_0F3A
;
10396 vex
.w
= *codep
& 0x80;
10397 if (vex
.w
&& address_mode
== mode_64bit
)
10400 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10401 if (address_mode
!= mode_64bit
10402 && vex
.register_specifier
> 0x7)
10405 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10406 switch ((*codep
& 0x3))
10412 vex
.prefix
= DATA_PREFIX_OPCODE
;
10415 vex
.prefix
= REPE_PREFIX_OPCODE
;
10418 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10425 dp
= &vex_table
[vex_table_index
][vindex
];
10426 /* There is no MODRM byte for VEX [82|77]. */
10427 if (vindex
!= 0x77 && vindex
!= 0x82)
10429 FETCH_DATA (info
, codep
+ 1);
10430 modrm
.mod
= (*codep
>> 6) & 3;
10431 modrm
.reg
= (*codep
>> 3) & 7;
10432 modrm
.rm
= *codep
& 7;
10436 case USE_VEX_C5_TABLE
:
10437 FETCH_DATA (info
, codep
+ 2);
10438 /* All bits in the REX prefix are ignored. */
10440 rex
= (*codep
& 0x80) ? 0 : REX_R
;
10442 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10443 if (address_mode
!= mode_64bit
10444 && vex
.register_specifier
> 0x7)
10449 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10450 switch ((*codep
& 0x3))
10456 vex
.prefix
= DATA_PREFIX_OPCODE
;
10459 vex
.prefix
= REPE_PREFIX_OPCODE
;
10462 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10469 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
10470 /* There is no MODRM byte for VEX [82|77]. */
10471 if (vindex
!= 0x77 && vindex
!= 0x82)
10473 FETCH_DATA (info
, codep
+ 1);
10474 modrm
.mod
= (*codep
>> 6) & 3;
10475 modrm
.reg
= (*codep
>> 3) & 7;
10476 modrm
.rm
= *codep
& 7;
10484 if (dp
->name
!= NULL
)
10487 return get_valid_dis386 (dp
, info
);
10491 print_insn (bfd_vma pc
, disassemble_info
*info
)
10493 const struct dis386
*dp
;
10495 char *op_txt
[MAX_OPERANDS
];
10499 struct dis_private priv
;
10502 int default_prefixes
;
10504 if (info
->mach
== bfd_mach_x86_64_intel_syntax
10505 || info
->mach
== bfd_mach_x86_64
10506 || info
->mach
== bfd_mach_l1om
10507 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10508 address_mode
= mode_64bit
;
10510 address_mode
= mode_32bit
;
10512 if (intel_syntax
== (char) -1)
10513 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
10514 || info
->mach
== bfd_mach_x86_64_intel_syntax
10515 || info
->mach
== bfd_mach_l1om_intel_syntax
);
10517 if (info
->mach
== bfd_mach_i386_i386
10518 || info
->mach
== bfd_mach_x86_64
10519 || info
->mach
== bfd_mach_l1om
10520 || info
->mach
== bfd_mach_i386_i386_intel_syntax
10521 || info
->mach
== bfd_mach_x86_64_intel_syntax
10522 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10523 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10524 else if (info
->mach
== bfd_mach_i386_i8086
)
10525 priv
.orig_sizeflag
= 0;
10529 for (p
= info
->disassembler_options
; p
!= NULL
; )
10531 if (CONST_STRNEQ (p
, "x86-64"))
10533 address_mode
= mode_64bit
;
10534 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10536 else if (CONST_STRNEQ (p
, "i386"))
10538 address_mode
= mode_32bit
;
10539 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10541 else if (CONST_STRNEQ (p
, "i8086"))
10543 address_mode
= mode_16bit
;
10544 priv
.orig_sizeflag
= 0;
10546 else if (CONST_STRNEQ (p
, "intel"))
10549 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
10550 intel_mnemonic
= 1;
10552 else if (CONST_STRNEQ (p
, "att"))
10555 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
10556 intel_mnemonic
= 0;
10558 else if (CONST_STRNEQ (p
, "addr"))
10560 if (address_mode
== mode_64bit
)
10562 if (p
[4] == '3' && p
[5] == '2')
10563 priv
.orig_sizeflag
&= ~AFLAG
;
10564 else if (p
[4] == '6' && p
[5] == '4')
10565 priv
.orig_sizeflag
|= AFLAG
;
10569 if (p
[4] == '1' && p
[5] == '6')
10570 priv
.orig_sizeflag
&= ~AFLAG
;
10571 else if (p
[4] == '3' && p
[5] == '2')
10572 priv
.orig_sizeflag
|= AFLAG
;
10575 else if (CONST_STRNEQ (p
, "data"))
10577 if (p
[4] == '1' && p
[5] == '6')
10578 priv
.orig_sizeflag
&= ~DFLAG
;
10579 else if (p
[4] == '3' && p
[5] == '2')
10580 priv
.orig_sizeflag
|= DFLAG
;
10582 else if (CONST_STRNEQ (p
, "suffix"))
10583 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
10585 p
= strchr (p
, ',');
10592 names64
= intel_names64
;
10593 names32
= intel_names32
;
10594 names16
= intel_names16
;
10595 names8
= intel_names8
;
10596 names8rex
= intel_names8rex
;
10597 names_seg
= intel_names_seg
;
10598 index64
= intel_index64
;
10599 index32
= intel_index32
;
10600 index16
= intel_index16
;
10603 separator_char
= '+';
10608 names64
= att_names64
;
10609 names32
= att_names32
;
10610 names16
= att_names16
;
10611 names8
= att_names8
;
10612 names8rex
= att_names8rex
;
10613 names_seg
= att_names_seg
;
10614 index64
= att_index64
;
10615 index32
= att_index32
;
10616 index16
= att_index16
;
10619 separator_char
= ',';
10623 /* The output looks better if we put 7 bytes on a line, since that
10624 puts most long word instructions on a single line. Use 8 bytes
10626 if (info
->mach
== bfd_mach_l1om
10627 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10628 info
->bytes_per_line
= 8;
10630 info
->bytes_per_line
= 7;
10632 info
->private_data
= &priv
;
10633 priv
.max_fetched
= priv
.the_buffer
;
10634 priv
.insn_start
= pc
;
10637 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10645 start_codep
= priv
.the_buffer
;
10646 codep
= priv
.the_buffer
;
10648 if (setjmp (priv
.bailout
) != 0)
10652 /* Getting here means we tried for data but didn't get it. That
10653 means we have an incomplete instruction of some sort. Just
10654 print the first byte as a prefix or a .byte pseudo-op. */
10655 if (codep
> priv
.the_buffer
)
10657 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
10659 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10662 /* Just print the first byte as a .byte instruction. */
10663 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
10664 (unsigned int) priv
.the_buffer
[0]);
10674 sizeflag
= priv
.orig_sizeflag
;
10676 if (!ckprefix () || rex_used
)
10678 /* Too many prefixes or unused REX prefixes. */
10680 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
10682 (*info
->fprintf_func
) (info
->stream
, "%s",
10683 prefix_name (all_prefixes
[i
], sizeflag
));
10687 insn_codep
= codep
;
10689 FETCH_DATA (info
, codep
+ 1);
10690 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
10692 if (((prefixes
& PREFIX_FWAIT
)
10693 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
10695 (*info
->fprintf_func
) (info
->stream
, "fwait");
10701 if (*codep
== 0x0f)
10703 unsigned char threebyte
;
10704 FETCH_DATA (info
, codep
+ 2);
10705 threebyte
= *++codep
;
10706 dp
= &dis386_twobyte
[threebyte
];
10707 need_modrm
= twobyte_has_modrm
[*codep
];
10712 dp
= &dis386
[*codep
];
10713 need_modrm
= onebyte_has_modrm
[*codep
];
10717 if ((prefixes
& PREFIX_REPZ
))
10718 used_prefixes
|= PREFIX_REPZ
;
10719 if ((prefixes
& PREFIX_REPNZ
))
10720 used_prefixes
|= PREFIX_REPNZ
;
10721 if ((prefixes
& PREFIX_LOCK
))
10722 used_prefixes
|= PREFIX_LOCK
;
10724 default_prefixes
= 0;
10725 if (prefixes
& PREFIX_ADDR
)
10728 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
10730 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
10731 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
10733 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
10734 default_prefixes
|= PREFIX_ADDR
;
10738 if ((prefixes
& PREFIX_DATA
))
10741 if (dp
->op
[2].bytemode
== cond_jump_mode
10742 && dp
->op
[0].bytemode
== v_mode
10745 if (sizeflag
& DFLAG
)
10746 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
10748 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
10749 default_prefixes
|= PREFIX_DATA
;
10751 else if (rex
& REX_W
)
10753 /* REX_W will override PREFIX_DATA. */
10754 default_prefixes
|= PREFIX_DATA
;
10760 FETCH_DATA (info
, codep
+ 1);
10761 modrm
.mod
= (*codep
>> 6) & 3;
10762 modrm
.reg
= (*codep
>> 3) & 7;
10763 modrm
.rm
= *codep
& 7;
10770 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
10772 dofloat (sizeflag
);
10776 dp
= get_valid_dis386 (dp
, info
);
10777 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
10779 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10782 op_ad
= MAX_OPERANDS
- 1 - i
;
10784 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
10789 /* See if any prefixes were not used. If so, print the first one
10790 separately. If we don't do this, we'll wind up printing an
10791 instruction stream which does not precisely correspond to the
10792 bytes we are disassembling. */
10793 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
10795 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10796 if (all_prefixes
[i
])
10799 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
10801 name
= INTERNAL_DISASSEMBLER_ERROR
;
10802 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10807 /* Check if the REX prefix used. */
10808 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
10809 all_prefixes
[last_rex_prefix
] = 0;
10811 /* Check if the SEG prefix used. */
10812 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
10813 | PREFIX_FS
| PREFIX_GS
)) != 0
10815 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
10816 all_prefixes
[last_seg_prefix
] = 0;
10818 /* Check if the ADDR prefix used. */
10819 if ((prefixes
& PREFIX_ADDR
) != 0
10820 && (used_prefixes
& PREFIX_ADDR
) != 0)
10821 all_prefixes
[last_addr_prefix
] = 0;
10823 /* Check if the DATA prefix used. */
10824 if ((prefixes
& PREFIX_DATA
) != 0
10825 && (used_prefixes
& PREFIX_DATA
) != 0)
10826 all_prefixes
[last_data_prefix
] = 0;
10829 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10830 if (all_prefixes
[i
])
10833 name
= prefix_name (all_prefixes
[i
], sizeflag
);
10836 prefix_length
+= strlen (name
) + 1;
10837 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
10840 /* Check maximum code length. */
10841 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
10843 (*info
->fprintf_func
) (info
->stream
, "(bad)");
10844 return MAX_CODE_LENGTH
;
10847 obufp
= mnemonicendp
;
10848 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
10851 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
10853 /* The enter and bound instructions are printed with operands in the same
10854 order as the intel book; everything else is printed in reverse order. */
10855 if (intel_syntax
|| two_source_ops
)
10859 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10860 op_txt
[i
] = op_out
[i
];
10862 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
10864 op_ad
= op_index
[i
];
10865 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
10866 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
10867 riprel
= op_riprel
[i
];
10868 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
10869 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
10874 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10875 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
10879 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10883 (*info
->fprintf_func
) (info
->stream
, ",");
10884 if (op_index
[i
] != -1 && !op_riprel
[i
])
10885 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
10887 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
10891 for (i
= 0; i
< MAX_OPERANDS
; i
++)
10892 if (op_index
[i
] != -1 && op_riprel
[i
])
10894 (*info
->fprintf_func
) (info
->stream
, " # ");
10895 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
10896 + op_address
[op_index
[i
]]), info
);
10899 return codep
- priv
.the_buffer
;
10902 static const char *float_mem
[] = {
10977 static const unsigned char float_mem_mode
[] = {
11052 #define ST { OP_ST, 0 }
11053 #define STi { OP_STi, 0 }
11055 #define FGRPd9_2 NULL, { { NULL, 0 } }
11056 #define FGRPd9_4 NULL, { { NULL, 1 } }
11057 #define FGRPd9_5 NULL, { { NULL, 2 } }
11058 #define FGRPd9_6 NULL, { { NULL, 3 } }
11059 #define FGRPd9_7 NULL, { { NULL, 4 } }
11060 #define FGRPda_5 NULL, { { NULL, 5 } }
11061 #define FGRPdb_4 NULL, { { NULL, 6 } }
11062 #define FGRPde_3 NULL, { { NULL, 7 } }
11063 #define FGRPdf_4 NULL, { { NULL, 8 } }
11065 static const struct dis386 float_reg
[][8] = {
11068 { "fadd", { ST
, STi
} },
11069 { "fmul", { ST
, STi
} },
11070 { "fcom", { STi
} },
11071 { "fcomp", { STi
} },
11072 { "fsub", { ST
, STi
} },
11073 { "fsubr", { ST
, STi
} },
11074 { "fdiv", { ST
, STi
} },
11075 { "fdivr", { ST
, STi
} },
11079 { "fld", { STi
} },
11080 { "fxch", { STi
} },
11082 { "(bad)", { XX
} },
11090 { "fcmovb", { ST
, STi
} },
11091 { "fcmove", { ST
, STi
} },
11092 { "fcmovbe",{ ST
, STi
} },
11093 { "fcmovu", { ST
, STi
} },
11094 { "(bad)", { XX
} },
11096 { "(bad)", { XX
} },
11097 { "(bad)", { XX
} },
11101 { "fcmovnb",{ ST
, STi
} },
11102 { "fcmovne",{ ST
, STi
} },
11103 { "fcmovnbe",{ ST
, STi
} },
11104 { "fcmovnu",{ ST
, STi
} },
11106 { "fucomi", { ST
, STi
} },
11107 { "fcomi", { ST
, STi
} },
11108 { "(bad)", { XX
} },
11112 { "fadd", { STi
, ST
} },
11113 { "fmul", { STi
, ST
} },
11114 { "(bad)", { XX
} },
11115 { "(bad)", { XX
} },
11116 { "fsub!M", { STi
, ST
} },
11117 { "fsubM", { STi
, ST
} },
11118 { "fdiv!M", { STi
, ST
} },
11119 { "fdivM", { STi
, ST
} },
11123 { "ffree", { STi
} },
11124 { "(bad)", { XX
} },
11125 { "fst", { STi
} },
11126 { "fstp", { STi
} },
11127 { "fucom", { STi
} },
11128 { "fucomp", { STi
} },
11129 { "(bad)", { XX
} },
11130 { "(bad)", { XX
} },
11134 { "faddp", { STi
, ST
} },
11135 { "fmulp", { STi
, ST
} },
11136 { "(bad)", { XX
} },
11138 { "fsub!Mp", { STi
, ST
} },
11139 { "fsubMp", { STi
, ST
} },
11140 { "fdiv!Mp", { STi
, ST
} },
11141 { "fdivMp", { STi
, ST
} },
11145 { "ffreep", { STi
} },
11146 { "(bad)", { XX
} },
11147 { "(bad)", { XX
} },
11148 { "(bad)", { XX
} },
11150 { "fucomip", { ST
, STi
} },
11151 { "fcomip", { ST
, STi
} },
11152 { "(bad)", { XX
} },
11156 static char *fgrps
[][8] = {
11159 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11164 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11169 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11174 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11179 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11184 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11189 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11190 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11195 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11200 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11205 swap_operand (void)
11207 mnemonicendp
[0] = '.';
11208 mnemonicendp
[1] = 's';
11213 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11214 int sizeflag ATTRIBUTE_UNUSED
)
11216 /* Skip mod/rm byte. */
11222 dofloat (int sizeflag
)
11224 const struct dis386
*dp
;
11225 unsigned char floatop
;
11227 floatop
= codep
[-1];
11229 if (modrm
.mod
!= 3)
11231 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11233 putop (float_mem
[fp_indx
], sizeflag
);
11236 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11239 /* Skip mod/rm byte. */
11243 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11244 if (dp
->name
== NULL
)
11246 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
11248 /* Instruction fnstsw is only one with strange arg. */
11249 if (floatop
== 0xdf && codep
[-1] == 0xe0)
11250 strcpy (op_out
[0], names16
[0]);
11254 putop (dp
->name
, sizeflag
);
11259 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
11264 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
11269 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11271 oappend ("%st" + intel_syntax
);
11275 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11277 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
11278 oappend (scratchbuf
+ intel_syntax
);
11281 /* Capital letters in template are macros. */
11283 putop (const char *in_template
, int sizeflag
)
11288 unsigned int l
= 0, len
= 1;
11291 #define SAVE_LAST(c) \
11292 if (l < len && l < sizeof (last)) \
11297 for (p
= in_template
; *p
; p
++)
11314 while (*++p
!= '|')
11315 if (*p
== '}' || *p
== '\0')
11318 /* Fall through. */
11323 while (*++p
!= '}')
11334 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11338 if (l
== 0 && len
== 1)
11343 if (sizeflag
& SUFFIX_ALWAYS
)
11356 if (address_mode
== mode_64bit
11357 && !(prefixes
& PREFIX_ADDR
))
11368 if (intel_syntax
&& !alt
)
11370 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
11372 if (sizeflag
& DFLAG
)
11373 *obufp
++ = intel_syntax
? 'd' : 'l';
11375 *obufp
++ = intel_syntax
? 'w' : 's';
11376 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11380 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11383 if (modrm
.mod
== 3)
11389 if (sizeflag
& DFLAG
)
11390 *obufp
++ = intel_syntax
? 'd' : 'l';
11393 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11399 case 'E': /* For jcxz/jecxz */
11400 if (address_mode
== mode_64bit
)
11402 if (sizeflag
& AFLAG
)
11408 if (sizeflag
& AFLAG
)
11410 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11415 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
11417 if (sizeflag
& AFLAG
)
11418 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
11420 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
11421 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11425 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
11427 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11431 if (!(rex
& REX_W
))
11432 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11437 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
11438 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
11440 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
11443 if (prefixes
& PREFIX_DS
)
11464 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
11469 /* Fall through. */
11472 if (l
!= 0 || len
!= 1)
11480 if (sizeflag
& SUFFIX_ALWAYS
)
11484 if (intel_mnemonic
!= cond
)
11488 if ((prefixes
& PREFIX_FWAIT
) == 0)
11491 used_prefixes
|= PREFIX_FWAIT
;
11497 else if (intel_syntax
&& (sizeflag
& DFLAG
))
11501 if (!(rex
& REX_W
))
11502 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11507 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11512 /* Fall through. */
11516 if ((prefixes
& PREFIX_DATA
)
11518 || (sizeflag
& SUFFIX_ALWAYS
))
11525 if (sizeflag
& DFLAG
)
11529 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11536 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11538 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11542 /* Fall through. */
11545 if (l
== 0 && len
== 1)
11548 if (intel_syntax
&& !alt
)
11551 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11557 if (sizeflag
& DFLAG
)
11558 *obufp
++ = intel_syntax
? 'd' : 'l';
11561 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11567 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
11573 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11588 else if (sizeflag
& DFLAG
)
11597 if (intel_syntax
&& !p
[1]
11598 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
11600 if (!(rex
& REX_W
))
11601 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11604 if (l
== 0 && len
== 1)
11608 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11610 if (sizeflag
& SUFFIX_ALWAYS
)
11632 /* Fall through. */
11635 if (l
== 0 && len
== 1)
11640 if (sizeflag
& SUFFIX_ALWAYS
)
11646 if (sizeflag
& DFLAG
)
11650 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11664 if (address_mode
== mode_64bit
11665 && !(prefixes
& PREFIX_ADDR
))
11676 if (l
!= 0 || len
!= 1)
11681 if (need_vex
&& vex
.prefix
)
11683 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
11690 if (prefixes
& PREFIX_DATA
)
11694 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11698 if (l
== 0 && len
== 1)
11700 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11711 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11719 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11721 switch (vex
.length
)
11735 if (l
== 0 && len
== 1)
11737 /* operand size flag for cwtl, cbtw */
11746 else if (sizeflag
& DFLAG
)
11750 if (!(rex
& REX_W
))
11751 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11755 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11762 *obufp
++ = vex
.w
? 'd': 's';
11769 mnemonicendp
= obufp
;
11774 oappend (const char *s
)
11776 obufp
= stpcpy (obufp
, s
);
11782 if (prefixes
& PREFIX_CS
)
11784 used_prefixes
|= PREFIX_CS
;
11785 oappend ("%cs:" + intel_syntax
);
11787 if (prefixes
& PREFIX_DS
)
11789 used_prefixes
|= PREFIX_DS
;
11790 oappend ("%ds:" + intel_syntax
);
11792 if (prefixes
& PREFIX_SS
)
11794 used_prefixes
|= PREFIX_SS
;
11795 oappend ("%ss:" + intel_syntax
);
11797 if (prefixes
& PREFIX_ES
)
11799 used_prefixes
|= PREFIX_ES
;
11800 oappend ("%es:" + intel_syntax
);
11802 if (prefixes
& PREFIX_FS
)
11804 used_prefixes
|= PREFIX_FS
;
11805 oappend ("%fs:" + intel_syntax
);
11807 if (prefixes
& PREFIX_GS
)
11809 used_prefixes
|= PREFIX_GS
;
11810 oappend ("%gs:" + intel_syntax
);
11815 OP_indirE (int bytemode
, int sizeflag
)
11819 OP_E (bytemode
, sizeflag
);
11823 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
11825 if (address_mode
== mode_64bit
)
11833 sprintf_vma (tmp
, disp
);
11834 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
11835 strcpy (buf
+ 2, tmp
+ i
);
11839 bfd_signed_vma v
= disp
;
11846 /* Check for possible overflow on 0x8000000000000000. */
11849 strcpy (buf
, "9223372036854775808");
11863 tmp
[28 - i
] = (v
% 10) + '0';
11867 strcpy (buf
, tmp
+ 29 - i
);
11873 sprintf (buf
, "0x%x", (unsigned int) disp
);
11875 sprintf (buf
, "%d", (int) disp
);
11879 /* Put DISP in BUF as signed hex number. */
11882 print_displacement (char *buf
, bfd_vma disp
)
11884 bfd_signed_vma val
= disp
;
11893 /* Check for possible overflow. */
11896 switch (address_mode
)
11899 strcpy (buf
+ j
, "0x8000000000000000");
11902 strcpy (buf
+ j
, "0x80000000");
11905 strcpy (buf
+ j
, "0x8000");
11915 sprintf_vma (tmp
, (bfd_vma
) val
);
11916 for (i
= 0; tmp
[i
] == '0'; i
++)
11918 if (tmp
[i
] == '\0')
11920 strcpy (buf
+ j
, tmp
+ i
);
11924 intel_operand_size (int bytemode
, int sizeflag
)
11931 oappend ("BYTE PTR ");
11935 oappend ("WORD PTR ");
11938 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11940 oappend ("QWORD PTR ");
11949 oappend ("QWORD PTR ");
11952 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
11953 oappend ("DWORD PTR ");
11955 oappend ("WORD PTR ");
11956 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11960 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11962 oappend ("WORD PTR ");
11963 if (!(rex
& REX_W
))
11964 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11967 if (sizeflag
& DFLAG
)
11968 oappend ("QWORD PTR ");
11970 oappend ("DWORD PTR ");
11971 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11976 oappend ("DWORD PTR ");
11980 oappend ("QWORD PTR ");
11983 if (address_mode
== mode_64bit
)
11984 oappend ("QWORD PTR ");
11986 oappend ("DWORD PTR ");
11989 if (sizeflag
& DFLAG
)
11990 oappend ("FWORD PTR ");
11992 oappend ("DWORD PTR ");
11993 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11996 oappend ("TBYTE PTR ");
12002 switch (vex
.length
)
12005 oappend ("XMMWORD PTR ");
12008 oappend ("YMMWORD PTR ");
12015 oappend ("XMMWORD PTR ");
12018 oappend ("XMMWORD PTR ");
12024 switch (vex
.length
)
12027 oappend ("QWORD PTR ");
12030 oappend ("XMMWORD PTR ");
12040 switch (vex
.length
)
12043 oappend ("QWORD PTR ");
12046 oappend ("YMMWORD PTR ");
12053 oappend ("OWORD PTR ");
12055 case vex_w_dq_mode
:
12060 oappend ("QWORD PTR ");
12062 oappend ("DWORD PTR ");
12070 OP_E_register (int bytemode
, int sizeflag
)
12072 int reg
= modrm
.rm
;
12073 const char **names
;
12079 if ((sizeflag
& SUFFIX_ALWAYS
)
12080 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12103 names
= address_mode
== mode_64bit
? names64
: names32
;
12106 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12124 if ((sizeflag
& DFLAG
)
12125 || (bytemode
!= v_mode
12126 && bytemode
!= v_swap_mode
))
12130 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12136 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12139 oappend (names
[reg
]);
12143 OP_E_memory (int bytemode
, int sizeflag
)
12146 int add
= (rex
& REX_B
) ? 8 : 0;
12151 intel_operand_size (bytemode
, sizeflag
);
12154 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12156 /* 32/64 bit address mode */
12174 FETCH_DATA (the_info
, codep
+ 1);
12175 vindex
= (*codep
>> 3) & 7;
12176 scale
= (*codep
>> 6) & 3;
12181 haveindex
= vindex
!= 4;
12184 rbase
= base
+ add
;
12192 if (address_mode
== mode_64bit
&& !havesib
)
12198 FETCH_DATA (the_info
, codep
+ 1);
12200 if ((disp
& 0x80) != 0)
12208 /* In 32bit mode, we need index register to tell [offset] from
12209 [eiz*1 + offset]. */
12210 needindex
= (havesib
12213 && address_mode
== mode_32bit
);
12214 havedisp
= (havebase
12216 || (havesib
&& (haveindex
|| scale
!= 0)));
12219 if (modrm
.mod
!= 0 || base
== 5)
12221 if (havedisp
|| riprel
)
12222 print_displacement (scratchbuf
, disp
);
12224 print_operand_value (scratchbuf
, 1, disp
);
12225 oappend (scratchbuf
);
12229 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12233 if (havebase
|| haveindex
|| riprel
)
12234 used_prefixes
|= PREFIX_ADDR
;
12236 if (havedisp
|| (intel_syntax
&& riprel
))
12238 *obufp
++ = open_char
;
12239 if (intel_syntax
&& riprel
)
12242 oappend (sizeflag
& AFLAG
? "rip" : "eip");
12246 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
12247 ? names64
[rbase
] : names32
[rbase
]);
12250 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12251 print index to tell base + index from base. */
12255 || (havebase
&& base
!= ESP_REG_NUM
))
12257 if (!intel_syntax
|| havebase
)
12259 *obufp
++ = separator_char
;
12263 oappend (address_mode
== mode_64bit
12264 && (sizeflag
& AFLAG
)
12265 ? names64
[vindex
] : names32
[vindex
]);
12267 oappend (address_mode
== mode_64bit
12268 && (sizeflag
& AFLAG
)
12269 ? index64
: index32
);
12271 *obufp
++ = scale_char
;
12273 sprintf (scratchbuf
, "%d", 1 << scale
);
12274 oappend (scratchbuf
);
12278 && (disp
|| modrm
.mod
!= 0 || base
== 5))
12280 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
12285 else if (modrm
.mod
!= 1 && disp
!= -disp
)
12289 disp
= - (bfd_signed_vma
) disp
;
12293 print_displacement (scratchbuf
, disp
);
12295 print_operand_value (scratchbuf
, 1, disp
);
12296 oappend (scratchbuf
);
12299 *obufp
++ = close_char
;
12302 else if (intel_syntax
)
12304 if (modrm
.mod
!= 0 || base
== 5)
12306 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12307 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12311 oappend (names_seg
[ds_reg
- es_reg
]);
12314 print_operand_value (scratchbuf
, 1, disp
);
12315 oappend (scratchbuf
);
12321 /* 16 bit address mode */
12322 used_prefixes
|= prefixes
& PREFIX_ADDR
;
12329 if ((disp
& 0x8000) != 0)
12334 FETCH_DATA (the_info
, codep
+ 1);
12336 if ((disp
& 0x80) != 0)
12341 if ((disp
& 0x8000) != 0)
12347 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
12349 print_displacement (scratchbuf
, disp
);
12350 oappend (scratchbuf
);
12353 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
12355 *obufp
++ = open_char
;
12357 oappend (index16
[modrm
.rm
]);
12359 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
12361 if ((bfd_signed_vma
) disp
>= 0)
12366 else if (modrm
.mod
!= 1)
12370 disp
= - (bfd_signed_vma
) disp
;
12373 print_displacement (scratchbuf
, disp
);
12374 oappend (scratchbuf
);
12377 *obufp
++ = close_char
;
12380 else if (intel_syntax
)
12382 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12383 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12387 oappend (names_seg
[ds_reg
- es_reg
]);
12390 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
12391 oappend (scratchbuf
);
12397 OP_E (int bytemode
, int sizeflag
)
12399 /* Skip mod/rm byte. */
12403 if (modrm
.mod
== 3)
12404 OP_E_register (bytemode
, sizeflag
);
12406 OP_E_memory (bytemode
, sizeflag
);
12410 OP_G (int bytemode
, int sizeflag
)
12421 oappend (names8rex
[modrm
.reg
+ add
]);
12423 oappend (names8
[modrm
.reg
+ add
]);
12426 oappend (names16
[modrm
.reg
+ add
]);
12429 oappend (names32
[modrm
.reg
+ add
]);
12432 oappend (names64
[modrm
.reg
+ add
]);
12441 oappend (names64
[modrm
.reg
+ add
]);
12444 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
12445 oappend (names32
[modrm
.reg
+ add
]);
12447 oappend (names16
[modrm
.reg
+ add
]);
12448 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12452 if (address_mode
== mode_64bit
)
12453 oappend (names64
[modrm
.reg
+ add
]);
12455 oappend (names32
[modrm
.reg
+ add
]);
12458 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12471 FETCH_DATA (the_info
, codep
+ 8);
12472 a
= *codep
++ & 0xff;
12473 a
|= (*codep
++ & 0xff) << 8;
12474 a
|= (*codep
++ & 0xff) << 16;
12475 a
|= (*codep
++ & 0xff) << 24;
12476 b
= *codep
++ & 0xff;
12477 b
|= (*codep
++ & 0xff) << 8;
12478 b
|= (*codep
++ & 0xff) << 16;
12479 b
|= (*codep
++ & 0xff) << 24;
12480 x
= a
+ ((bfd_vma
) b
<< 32);
12488 static bfd_signed_vma
12491 bfd_signed_vma x
= 0;
12493 FETCH_DATA (the_info
, codep
+ 4);
12494 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12495 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12496 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12497 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12501 static bfd_signed_vma
12504 bfd_signed_vma x
= 0;
12506 FETCH_DATA (the_info
, codep
+ 4);
12507 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12508 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12509 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12510 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12512 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
12522 FETCH_DATA (the_info
, codep
+ 2);
12523 x
= *codep
++ & 0xff;
12524 x
|= (*codep
++ & 0xff) << 8;
12529 set_op (bfd_vma op
, int riprel
)
12531 op_index
[op_ad
] = op_ad
;
12532 if (address_mode
== mode_64bit
)
12534 op_address
[op_ad
] = op
;
12535 op_riprel
[op_ad
] = riprel
;
12539 /* Mask to get a 32-bit address. */
12540 op_address
[op_ad
] = op
& 0xffffffff;
12541 op_riprel
[op_ad
] = riprel
& 0xffffffff;
12546 OP_REG (int code
, int sizeflag
)
12558 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12559 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12560 s
= names16
[code
- ax_reg
+ add
];
12562 case es_reg
: case ss_reg
: case cs_reg
:
12563 case ds_reg
: case fs_reg
: case gs_reg
:
12564 s
= names_seg
[code
- es_reg
+ add
];
12566 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12567 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12570 s
= names8rex
[code
- al_reg
+ add
];
12572 s
= names8
[code
- al_reg
];
12574 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
12575 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
12576 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12578 s
= names64
[code
- rAX_reg
+ add
];
12581 code
+= eAX_reg
- rAX_reg
;
12582 /* Fall through. */
12583 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12584 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12587 s
= names64
[code
- eAX_reg
+ add
];
12590 if (sizeflag
& DFLAG
)
12591 s
= names32
[code
- eAX_reg
+ add
];
12593 s
= names16
[code
- eAX_reg
+ add
];
12594 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12598 s
= INTERNAL_DISASSEMBLER_ERROR
;
12605 OP_IMREG (int code
, int sizeflag
)
12617 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12618 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12619 s
= names16
[code
- ax_reg
];
12621 case es_reg
: case ss_reg
: case cs_reg
:
12622 case ds_reg
: case fs_reg
: case gs_reg
:
12623 s
= names_seg
[code
- es_reg
];
12625 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12626 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12629 s
= names8rex
[code
- al_reg
];
12631 s
= names8
[code
- al_reg
];
12633 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12634 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12637 s
= names64
[code
- eAX_reg
];
12640 if (sizeflag
& DFLAG
)
12641 s
= names32
[code
- eAX_reg
];
12643 s
= names16
[code
- eAX_reg
];
12644 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12647 case z_mode_ax_reg
:
12648 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12652 if (!(rex
& REX_W
))
12653 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12656 s
= INTERNAL_DISASSEMBLER_ERROR
;
12663 OP_I (int bytemode
, int sizeflag
)
12666 bfd_signed_vma mask
= -1;
12671 FETCH_DATA (the_info
, codep
+ 1);
12676 if (address_mode
== mode_64bit
)
12681 /* Fall through. */
12688 if (sizeflag
& DFLAG
)
12698 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12710 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12715 scratchbuf
[0] = '$';
12716 print_operand_value (scratchbuf
+ 1, 1, op
);
12717 oappend (scratchbuf
+ intel_syntax
);
12718 scratchbuf
[0] = '\0';
12722 OP_I64 (int bytemode
, int sizeflag
)
12725 bfd_signed_vma mask
= -1;
12727 if (address_mode
!= mode_64bit
)
12729 OP_I (bytemode
, sizeflag
);
12736 FETCH_DATA (the_info
, codep
+ 1);
12746 if (sizeflag
& DFLAG
)
12756 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12764 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12769 scratchbuf
[0] = '$';
12770 print_operand_value (scratchbuf
+ 1, 1, op
);
12771 oappend (scratchbuf
+ intel_syntax
);
12772 scratchbuf
[0] = '\0';
12776 OP_sI (int bytemode
, int sizeflag
)
12779 bfd_signed_vma mask
= -1;
12784 FETCH_DATA (the_info
, codep
+ 1);
12786 if ((op
& 0x80) != 0)
12796 if (sizeflag
& DFLAG
)
12805 if ((op
& 0x8000) != 0)
12808 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12814 if ((op
& 0x8000) != 0)
12818 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12822 scratchbuf
[0] = '$';
12823 print_operand_value (scratchbuf
+ 1, 1, op
);
12824 oappend (scratchbuf
+ intel_syntax
);
12828 OP_J (int bytemode
, int sizeflag
)
12832 bfd_vma segment
= 0;
12837 FETCH_DATA (the_info
, codep
+ 1);
12839 if ((disp
& 0x80) != 0)
12844 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
12849 if ((disp
& 0x8000) != 0)
12851 /* In 16bit mode, address is wrapped around at 64k within
12852 the same segment. Otherwise, a data16 prefix on a jump
12853 instruction means that the pc is masked to 16 bits after
12854 the displacement is added! */
12856 if ((prefixes
& PREFIX_DATA
) == 0)
12857 segment
= ((start_pc
+ codep
- start_codep
)
12858 & ~((bfd_vma
) 0xffff));
12860 if (!(rex
& REX_W
))
12861 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12864 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12867 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
12869 print_operand_value (scratchbuf
, 1, disp
);
12870 oappend (scratchbuf
);
12874 OP_SEG (int bytemode
, int sizeflag
)
12876 if (bytemode
== w_mode
)
12877 oappend (names_seg
[modrm
.reg
]);
12879 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
12883 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
12887 if (sizeflag
& DFLAG
)
12897 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12899 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
12901 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
12902 oappend (scratchbuf
);
12906 OP_OFF (int bytemode
, int sizeflag
)
12910 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12911 intel_operand_size (bytemode
, sizeflag
);
12914 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12921 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12922 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12924 oappend (names_seg
[ds_reg
- es_reg
]);
12928 print_operand_value (scratchbuf
, 1, off
);
12929 oappend (scratchbuf
);
12933 OP_OFF64 (int bytemode
, int sizeflag
)
12937 if (address_mode
!= mode_64bit
12938 || (prefixes
& PREFIX_ADDR
))
12940 OP_OFF (bytemode
, sizeflag
);
12944 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12945 intel_operand_size (bytemode
, sizeflag
);
12952 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12953 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12955 oappend (names_seg
[ds_reg
- es_reg
]);
12959 print_operand_value (scratchbuf
, 1, off
);
12960 oappend (scratchbuf
);
12964 ptr_reg (int code
, int sizeflag
)
12968 *obufp
++ = open_char
;
12969 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12970 if (address_mode
== mode_64bit
)
12972 if (!(sizeflag
& AFLAG
))
12973 s
= names32
[code
- eAX_reg
];
12975 s
= names64
[code
- eAX_reg
];
12977 else if (sizeflag
& AFLAG
)
12978 s
= names32
[code
- eAX_reg
];
12980 s
= names16
[code
- eAX_reg
];
12982 *obufp
++ = close_char
;
12987 OP_ESreg (int code
, int sizeflag
)
12993 case 0x6d: /* insw/insl */
12994 intel_operand_size (z_mode
, sizeflag
);
12996 case 0xa5: /* movsw/movsl/movsq */
12997 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12998 case 0xab: /* stosw/stosl */
12999 case 0xaf: /* scasw/scasl */
13000 intel_operand_size (v_mode
, sizeflag
);
13003 intel_operand_size (b_mode
, sizeflag
);
13006 oappend ("%es:" + intel_syntax
);
13007 ptr_reg (code
, sizeflag
);
13011 OP_DSreg (int code
, int sizeflag
)
13017 case 0x6f: /* outsw/outsl */
13018 intel_operand_size (z_mode
, sizeflag
);
13020 case 0xa5: /* movsw/movsl/movsq */
13021 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13022 case 0xad: /* lodsw/lodsl/lodsq */
13023 intel_operand_size (v_mode
, sizeflag
);
13026 intel_operand_size (b_mode
, sizeflag
);
13035 | PREFIX_GS
)) == 0)
13036 prefixes
|= PREFIX_DS
;
13038 ptr_reg (code
, sizeflag
);
13042 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13050 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13052 all_prefixes
[last_lock_prefix
] = 0;
13053 used_prefixes
|= PREFIX_LOCK
;
13058 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13059 oappend (scratchbuf
+ intel_syntax
);
13063 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13072 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13074 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13075 oappend (scratchbuf
);
13079 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13081 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13082 oappend (scratchbuf
+ intel_syntax
);
13086 OP_R (int bytemode
, int sizeflag
)
13088 if (modrm
.mod
== 3)
13089 OP_E (bytemode
, sizeflag
);
13095 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13097 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13098 if (prefixes
& PREFIX_DATA
)
13106 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13109 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13110 oappend (scratchbuf
+ intel_syntax
);
13114 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13122 if (need_vex
&& bytemode
!= xmm_mode
)
13124 switch (vex
.length
)
13127 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13130 sprintf (scratchbuf
, "%%ymm%d", modrm
.reg
+ add
);
13137 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13138 oappend (scratchbuf
+ intel_syntax
);
13142 OP_EM (int bytemode
, int sizeflag
)
13144 if (modrm
.mod
!= 3)
13147 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13149 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13150 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13152 OP_E (bytemode
, sizeflag
);
13156 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13159 /* Skip mod/rm byte. */
13162 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13163 if (prefixes
& PREFIX_DATA
)
13172 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13175 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13176 oappend (scratchbuf
+ intel_syntax
);
13179 /* cvt* are the only instructions in sse2 which have
13180 both SSE and MMX operands and also have 0x66 prefix
13181 in their opcode. 0x66 was originally used to differentiate
13182 between SSE and MMX instruction(operands). So we have to handle the
13183 cvt* separately using OP_EMC and OP_MXC */
13185 OP_EMC (int bytemode
, int sizeflag
)
13187 if (modrm
.mod
!= 3)
13189 if (intel_syntax
&& bytemode
== v_mode
)
13191 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13192 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13194 OP_E (bytemode
, sizeflag
);
13198 /* Skip mod/rm byte. */
13201 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13202 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13203 oappend (scratchbuf
+ intel_syntax
);
13207 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13209 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13210 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13211 oappend (scratchbuf
+ intel_syntax
);
13215 OP_EX (int bytemode
, int sizeflag
)
13219 /* Skip mod/rm byte. */
13223 if (modrm
.mod
!= 3)
13225 OP_E_memory (bytemode
, sizeflag
);
13235 if ((sizeflag
& SUFFIX_ALWAYS
)
13236 && (bytemode
== x_swap_mode
13237 || bytemode
== d_swap_mode
13238 || bytemode
== q_swap_mode
))
13242 && bytemode
!= xmm_mode
13243 && bytemode
!= xmmq_mode
)
13245 switch (vex
.length
)
13248 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13251 sprintf (scratchbuf
, "%%ymm%d", modrm
.rm
+ add
);
13258 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13259 oappend (scratchbuf
+ intel_syntax
);
13263 OP_MS (int bytemode
, int sizeflag
)
13265 if (modrm
.mod
== 3)
13266 OP_EM (bytemode
, sizeflag
);
13272 OP_XS (int bytemode
, int sizeflag
)
13274 if (modrm
.mod
== 3)
13275 OP_EX (bytemode
, sizeflag
);
13281 OP_M (int bytemode
, int sizeflag
)
13283 if (modrm
.mod
== 3)
13284 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
13287 OP_E (bytemode
, sizeflag
);
13291 OP_0f07 (int bytemode
, int sizeflag
)
13293 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
13296 OP_E (bytemode
, sizeflag
);
13299 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
13300 32bit mode and "xchg %rax,%rax" in 64bit mode. */
13303 NOP_Fixup1 (int bytemode
, int sizeflag
)
13305 if ((prefixes
& PREFIX_DATA
) != 0
13308 && address_mode
== mode_64bit
))
13309 OP_REG (bytemode
, sizeflag
);
13311 strcpy (obuf
, "nop");
13315 NOP_Fixup2 (int bytemode
, int sizeflag
)
13317 if ((prefixes
& PREFIX_DATA
) != 0
13320 && address_mode
== mode_64bit
))
13321 OP_IMREG (bytemode
, sizeflag
);
13324 static const char *const Suffix3DNow
[] = {
13325 /* 00 */ NULL
, NULL
, NULL
, NULL
,
13326 /* 04 */ NULL
, NULL
, NULL
, NULL
,
13327 /* 08 */ NULL
, NULL
, NULL
, NULL
,
13328 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
13329 /* 10 */ NULL
, NULL
, NULL
, NULL
,
13330 /* 14 */ NULL
, NULL
, NULL
, NULL
,
13331 /* 18 */ NULL
, NULL
, NULL
, NULL
,
13332 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
13333 /* 20 */ NULL
, NULL
, NULL
, NULL
,
13334 /* 24 */ NULL
, NULL
, NULL
, NULL
,
13335 /* 28 */ NULL
, NULL
, NULL
, NULL
,
13336 /* 2C */ NULL
, NULL
, NULL
, NULL
,
13337 /* 30 */ NULL
, NULL
, NULL
, NULL
,
13338 /* 34 */ NULL
, NULL
, NULL
, NULL
,
13339 /* 38 */ NULL
, NULL
, NULL
, NULL
,
13340 /* 3C */ NULL
, NULL
, NULL
, NULL
,
13341 /* 40 */ NULL
, NULL
, NULL
, NULL
,
13342 /* 44 */ NULL
, NULL
, NULL
, NULL
,
13343 /* 48 */ NULL
, NULL
, NULL
, NULL
,
13344 /* 4C */ NULL
, NULL
, NULL
, NULL
,
13345 /* 50 */ NULL
, NULL
, NULL
, NULL
,
13346 /* 54 */ NULL
, NULL
, NULL
, NULL
,
13347 /* 58 */ NULL
, NULL
, NULL
, NULL
,
13348 /* 5C */ NULL
, NULL
, NULL
, NULL
,
13349 /* 60 */ NULL
, NULL
, NULL
, NULL
,
13350 /* 64 */ NULL
, NULL
, NULL
, NULL
,
13351 /* 68 */ NULL
, NULL
, NULL
, NULL
,
13352 /* 6C */ NULL
, NULL
, NULL
, NULL
,
13353 /* 70 */ NULL
, NULL
, NULL
, NULL
,
13354 /* 74 */ NULL
, NULL
, NULL
, NULL
,
13355 /* 78 */ NULL
, NULL
, NULL
, NULL
,
13356 /* 7C */ NULL
, NULL
, NULL
, NULL
,
13357 /* 80 */ NULL
, NULL
, NULL
, NULL
,
13358 /* 84 */ NULL
, NULL
, NULL
, NULL
,
13359 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
13360 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
13361 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
13362 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
13363 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
13364 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
13365 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
13366 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
13367 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
13368 /* AC */ NULL
, NULL
, "pfacc", NULL
,
13369 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
13370 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
13371 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
13372 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
13373 /* C0 */ NULL
, NULL
, NULL
, NULL
,
13374 /* C4 */ NULL
, NULL
, NULL
, NULL
,
13375 /* C8 */ NULL
, NULL
, NULL
, NULL
,
13376 /* CC */ NULL
, NULL
, NULL
, NULL
,
13377 /* D0 */ NULL
, NULL
, NULL
, NULL
,
13378 /* D4 */ NULL
, NULL
, NULL
, NULL
,
13379 /* D8 */ NULL
, NULL
, NULL
, NULL
,
13380 /* DC */ NULL
, NULL
, NULL
, NULL
,
13381 /* E0 */ NULL
, NULL
, NULL
, NULL
,
13382 /* E4 */ NULL
, NULL
, NULL
, NULL
,
13383 /* E8 */ NULL
, NULL
, NULL
, NULL
,
13384 /* EC */ NULL
, NULL
, NULL
, NULL
,
13385 /* F0 */ NULL
, NULL
, NULL
, NULL
,
13386 /* F4 */ NULL
, NULL
, NULL
, NULL
,
13387 /* F8 */ NULL
, NULL
, NULL
, NULL
,
13388 /* FC */ NULL
, NULL
, NULL
, NULL
,
13392 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13394 const char *mnemonic
;
13396 FETCH_DATA (the_info
, codep
+ 1);
13397 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13398 place where an 8-bit immediate would normally go. ie. the last
13399 byte of the instruction. */
13400 obufp
= mnemonicendp
;
13401 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
13403 oappend (mnemonic
);
13406 /* Since a variable sized modrm/sib chunk is between the start
13407 of the opcode (0x0f0f) and the opcode suffix, we need to do
13408 all the modrm processing first, and don't know until now that
13409 we have a bad opcode. This necessitates some cleaning up. */
13410 op_out
[0][0] = '\0';
13411 op_out
[1][0] = '\0';
13414 mnemonicendp
= obufp
;
13417 static struct op simd_cmp_op
[] =
13419 { STRING_COMMA_LEN ("eq") },
13420 { STRING_COMMA_LEN ("lt") },
13421 { STRING_COMMA_LEN ("le") },
13422 { STRING_COMMA_LEN ("unord") },
13423 { STRING_COMMA_LEN ("neq") },
13424 { STRING_COMMA_LEN ("nlt") },
13425 { STRING_COMMA_LEN ("nle") },
13426 { STRING_COMMA_LEN ("ord") }
13430 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13432 unsigned int cmp_type
;
13434 FETCH_DATA (the_info
, codep
+ 1);
13435 cmp_type
= *codep
++ & 0xff;
13436 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
13439 char *p
= mnemonicendp
- 2;
13443 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
13444 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
13448 /* We have a reserved extension byte. Output it directly. */
13449 scratchbuf
[0] = '$';
13450 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
13451 oappend (scratchbuf
+ intel_syntax
);
13452 scratchbuf
[0] = '\0';
13457 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
13458 int sizeflag ATTRIBUTE_UNUSED
)
13460 /* mwait %eax,%ecx */
13463 const char **names
= (address_mode
== mode_64bit
13464 ? names64
: names32
);
13465 strcpy (op_out
[0], names
[0]);
13466 strcpy (op_out
[1], names
[1]);
13467 two_source_ops
= 1;
13469 /* Skip mod/rm byte. */
13475 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
13476 int sizeflag ATTRIBUTE_UNUSED
)
13478 /* monitor %eax,%ecx,%edx" */
13481 const char **op1_names
;
13482 const char **names
= (address_mode
== mode_64bit
13483 ? names64
: names32
);
13485 if (!(prefixes
& PREFIX_ADDR
))
13486 op1_names
= (address_mode
== mode_16bit
13487 ? names16
: names
);
13490 /* Remove "addr16/addr32". */
13491 all_prefixes
[last_addr_prefix
] = 0;
13492 op1_names
= (address_mode
!= mode_32bit
13493 ? names32
: names16
);
13494 used_prefixes
|= PREFIX_ADDR
;
13496 strcpy (op_out
[0], op1_names
[0]);
13497 strcpy (op_out
[1], names
[1]);
13498 strcpy (op_out
[2], names
[2]);
13499 two_source_ops
= 1;
13501 /* Skip mod/rm byte. */
13509 /* Throw away prefixes and 1st. opcode byte. */
13510 codep
= insn_codep
+ 1;
13515 REP_Fixup (int bytemode
, int sizeflag
)
13517 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13519 if (prefixes
& PREFIX_REPZ
)
13520 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
13527 OP_IMREG (bytemode
, sizeflag
);
13530 OP_ESreg (bytemode
, sizeflag
);
13533 OP_DSreg (bytemode
, sizeflag
);
13542 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
13547 /* Change cmpxchg8b to cmpxchg16b. */
13548 char *p
= mnemonicendp
- 2;
13549 mnemonicendp
= stpcpy (p
, "16b");
13552 OP_M (bytemode
, sizeflag
);
13556 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
13560 switch (vex
.length
)
13563 sprintf (scratchbuf
, "%%xmm%d", reg
);
13566 sprintf (scratchbuf
, "%%ymm%d", reg
);
13573 sprintf (scratchbuf
, "%%xmm%d", reg
);
13574 oappend (scratchbuf
+ intel_syntax
);
13578 CRC32_Fixup (int bytemode
, int sizeflag
)
13580 /* Add proper suffix to "crc32". */
13581 char *p
= mnemonicendp
;
13600 if (sizeflag
& DFLAG
)
13604 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13608 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13615 if (modrm
.mod
== 3)
13619 /* Skip mod/rm byte. */
13624 add
= (rex
& REX_B
) ? 8 : 0;
13625 if (bytemode
== b_mode
)
13629 oappend (names8rex
[modrm
.rm
+ add
]);
13631 oappend (names8
[modrm
.rm
+ add
]);
13637 oappend (names64
[modrm
.rm
+ add
]);
13638 else if ((prefixes
& PREFIX_DATA
))
13639 oappend (names16
[modrm
.rm
+ add
]);
13641 oappend (names32
[modrm
.rm
+ add
]);
13645 OP_E (bytemode
, sizeflag
);
13649 FXSAVE_Fixup (int bytemode
, int sizeflag
)
13651 /* Add proper suffix to "fxsave" and "fxrstor". */
13655 char *p
= mnemonicendp
;
13661 OP_M (bytemode
, sizeflag
);
13664 /* Display the destination register operand for instructions with
13668 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13676 switch (vex
.length
)
13689 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13702 sprintf (scratchbuf
, "%%ymm%d", vex
.register_specifier
);
13708 oappend (scratchbuf
+ intel_syntax
);
13711 /* Get the VEX immediate byte without moving codep. */
13713 static unsigned char
13714 get_vex_imm8 (int sizeflag
, int opnum
)
13716 int bytes_before_imm
= 0;
13718 if (modrm
.mod
!= 3)
13720 /* There are SIB/displacement bytes. */
13721 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13723 /* 32/64 bit address mode */
13724 int base
= modrm
.rm
;
13726 /* Check SIB byte. */
13729 FETCH_DATA (the_info
, codep
+ 1);
13731 /* When decoding the third source, don't increase
13732 bytes_before_imm as this has already been incremented
13733 by one in OP_E_memory while decoding the second
13736 bytes_before_imm
++;
13739 /* Don't increase bytes_before_imm when decoding the third source,
13740 it has already been incremented by OP_E_memory while decoding
13741 the second source operand. */
13747 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13748 SIB == 5, there is a 4 byte displacement. */
13750 /* No displacement. */
13753 /* 4 byte displacement. */
13754 bytes_before_imm
+= 4;
13757 /* 1 byte displacement. */
13758 bytes_before_imm
++;
13765 /* 16 bit address mode */
13766 /* Don't increase bytes_before_imm when decoding the third source,
13767 it has already been incremented by OP_E_memory while decoding
13768 the second source operand. */
13774 /* When modrm.rm == 6, there is a 2 byte displacement. */
13776 /* No displacement. */
13779 /* 2 byte displacement. */
13780 bytes_before_imm
+= 2;
13783 /* 1 byte displacement: when decoding the third source,
13784 don't increase bytes_before_imm as this has already
13785 been incremented by one in OP_E_memory while decoding
13786 the second source operand. */
13788 bytes_before_imm
++;
13796 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
13797 return codep
[bytes_before_imm
];
13801 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
13803 if (reg
== -1 && modrm
.mod
!= 3)
13805 OP_E_memory (bytemode
, sizeflag
);
13817 else if (reg
> 7 && address_mode
!= mode_64bit
)
13821 switch (vex
.length
)
13824 sprintf (scratchbuf
, "%%xmm%d", reg
);
13827 sprintf (scratchbuf
, "%%ymm%d", reg
);
13832 oappend (scratchbuf
+ intel_syntax
);
13836 OP_Vex_2src (int bytemode
, int sizeflag
)
13838 if (modrm
.mod
== 3)
13841 sprintf (scratchbuf
, "%%xmm%d", rex
& REX_B
? modrm
.rm
+ 8 : modrm
.rm
);
13842 oappend (scratchbuf
+ intel_syntax
);
13847 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13849 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13850 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13852 OP_E (bytemode
, sizeflag
);
13857 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
13859 if (modrm
.mod
== 3)
13861 /* Skip mod/rm byte. */
13868 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13869 oappend (scratchbuf
+ intel_syntax
);
13872 OP_Vex_2src (bytemode
, sizeflag
);
13876 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
13879 OP_Vex_2src (bytemode
, sizeflag
);
13882 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13883 oappend (scratchbuf
+ intel_syntax
);
13888 OP_EX_VexW (int bytemode
, int sizeflag
)
13896 /* Skip mod/rm byte. */
13901 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
13906 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
13909 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
13913 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
13914 int sizeflag ATTRIBUTE_UNUSED
)
13916 /* Skip the immediate byte and check for invalid bits. */
13917 FETCH_DATA (the_info
, codep
+ 1);
13918 if (*codep
++ & 0xf)
13923 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13926 FETCH_DATA (the_info
, codep
+ 1);
13929 if (bytemode
!= x_mode
)
13936 if (reg
> 7 && address_mode
!= mode_64bit
)
13939 switch (vex
.length
)
13942 sprintf (scratchbuf
, "%%xmm%d", reg
);
13945 sprintf (scratchbuf
, "%%ymm%d", reg
);
13950 oappend (scratchbuf
+ intel_syntax
);
13954 OP_XMM_VexW (int bytemode
, int sizeflag
)
13956 /* Turn off the REX.W bit since it is used for swapping operands
13959 OP_XMM (bytemode
, sizeflag
);
13963 OP_EX_Vex (int bytemode
, int sizeflag
)
13965 if (modrm
.mod
!= 3)
13967 if (vex
.register_specifier
!= 0)
13971 OP_EX (bytemode
, sizeflag
);
13975 OP_XMM_Vex (int bytemode
, int sizeflag
)
13977 if (modrm
.mod
!= 3)
13979 if (vex
.register_specifier
!= 0)
13983 OP_XMM (bytemode
, sizeflag
);
13987 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13989 switch (vex
.length
)
13992 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
13995 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14002 static struct op vex_cmp_op
[] =
14004 { STRING_COMMA_LEN ("eq") },
14005 { STRING_COMMA_LEN ("lt") },
14006 { STRING_COMMA_LEN ("le") },
14007 { STRING_COMMA_LEN ("unord") },
14008 { STRING_COMMA_LEN ("neq") },
14009 { STRING_COMMA_LEN ("nlt") },
14010 { STRING_COMMA_LEN ("nle") },
14011 { STRING_COMMA_LEN ("ord") },
14012 { STRING_COMMA_LEN ("eq_uq") },
14013 { STRING_COMMA_LEN ("nge") },
14014 { STRING_COMMA_LEN ("ngt") },
14015 { STRING_COMMA_LEN ("false") },
14016 { STRING_COMMA_LEN ("neq_oq") },
14017 { STRING_COMMA_LEN ("ge") },
14018 { STRING_COMMA_LEN ("gt") },
14019 { STRING_COMMA_LEN ("true") },
14020 { STRING_COMMA_LEN ("eq_os") },
14021 { STRING_COMMA_LEN ("lt_oq") },
14022 { STRING_COMMA_LEN ("le_oq") },
14023 { STRING_COMMA_LEN ("unord_s") },
14024 { STRING_COMMA_LEN ("neq_us") },
14025 { STRING_COMMA_LEN ("nlt_uq") },
14026 { STRING_COMMA_LEN ("nle_uq") },
14027 { STRING_COMMA_LEN ("ord_s") },
14028 { STRING_COMMA_LEN ("eq_us") },
14029 { STRING_COMMA_LEN ("nge_uq") },
14030 { STRING_COMMA_LEN ("ngt_uq") },
14031 { STRING_COMMA_LEN ("false_os") },
14032 { STRING_COMMA_LEN ("neq_os") },
14033 { STRING_COMMA_LEN ("ge_oq") },
14034 { STRING_COMMA_LEN ("gt_oq") },
14035 { STRING_COMMA_LEN ("true_us") },
14039 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14041 unsigned int cmp_type
;
14043 FETCH_DATA (the_info
, codep
+ 1);
14044 cmp_type
= *codep
++ & 0xff;
14045 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14048 char *p
= mnemonicendp
- 2;
14052 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14053 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14057 /* We have a reserved extension byte. Output it directly. */
14058 scratchbuf
[0] = '$';
14059 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14060 oappend (scratchbuf
+ intel_syntax
);
14061 scratchbuf
[0] = '\0';
14065 static const struct op pclmul_op
[] =
14067 { STRING_COMMA_LEN ("lql") },
14068 { STRING_COMMA_LEN ("hql") },
14069 { STRING_COMMA_LEN ("lqh") },
14070 { STRING_COMMA_LEN ("hqh") }
14074 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14075 int sizeflag ATTRIBUTE_UNUSED
)
14077 unsigned int pclmul_type
;
14079 FETCH_DATA (the_info
, codep
+ 1);
14080 pclmul_type
= *codep
++ & 0xff;
14081 switch (pclmul_type
)
14092 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14095 char *p
= mnemonicendp
- 3;
14100 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14101 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14105 /* We have a reserved extension byte. Output it directly. */
14106 scratchbuf
[0] = '$';
14107 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14108 oappend (scratchbuf
+ intel_syntax
);
14109 scratchbuf
[0] = '\0';
14114 MOVBE_Fixup (int bytemode
, int sizeflag
)
14116 /* Add proper suffix to "movbe". */
14117 char *p
= mnemonicendp
;
14126 if (sizeflag
& SUFFIX_ALWAYS
)
14132 if (sizeflag
& DFLAG
)
14136 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14141 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14148 OP_M (bytemode
, sizeflag
);
14152 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14155 const char **names
;
14157 /* Skip mod/rm byte. */
14163 else if (vex
.length
== 256)
14173 oappend (names
[reg
]);
14177 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14179 const char **names
;
14183 else if (vex
.length
== 256)
14188 oappend (names
[vex
.register_specifier
]);
14192 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
14194 if (vex
.w
|| vex
.length
== 256)
14195 OP_I (q_mode
, sizeflag
);
14197 OP_I (w_mode
, sizeflag
);