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_50
) },
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
} },
9357 /* VEX_LEN_XOP_09_80 */
9359 { "vfrczps", { XM
, EXxmm
} },
9360 { "vfrczps", { XM
, EXymmq
} },
9363 /* VEX_LEN_XOP_09_81 */
9365 { "vfrczpd", { XM
, EXxmm
} },
9366 { "vfrczpd", { XM
, EXymmq
} },
9370 static const struct dis386 mod_table
[][2] = {
9373 { "leaS", { Gv
, M
} },
9374 { "(bad)", { XX
} },
9377 /* MOD_0F01_REG_0 */
9378 { X86_64_TABLE (X86_64_0F01_REG_0
) },
9379 { RM_TABLE (RM_0F01_REG_0
) },
9382 /* MOD_0F01_REG_1 */
9383 { X86_64_TABLE (X86_64_0F01_REG_1
) },
9384 { RM_TABLE (RM_0F01_REG_1
) },
9387 /* MOD_0F01_REG_2 */
9388 { X86_64_TABLE (X86_64_0F01_REG_2
) },
9389 { RM_TABLE (RM_0F01_REG_2
) },
9392 /* MOD_0F01_REG_3 */
9393 { X86_64_TABLE (X86_64_0F01_REG_3
) },
9394 { RM_TABLE (RM_0F01_REG_3
) },
9397 /* MOD_0F01_REG_7 */
9398 { "invlpg", { Mb
} },
9399 { RM_TABLE (RM_0F01_REG_7
) },
9402 /* MOD_0F12_PREFIX_0 */
9403 { "movlps", { XM
, EXq
} },
9404 { "movhlps", { XM
, EXq
} },
9408 { "movlpX", { EXq
, XM
} },
9409 { "(bad)", { XX
} },
9412 /* MOD_0F16_PREFIX_0 */
9413 { "movhps", { XM
, EXq
} },
9414 { "movlhps", { XM
, EXq
} },
9418 { "movhpX", { EXq
, XM
} },
9419 { "(bad)", { XX
} },
9422 /* MOD_0F18_REG_0 */
9423 { "prefetchnta", { Mb
} },
9424 { "(bad)", { XX
} },
9427 /* MOD_0F18_REG_1 */
9428 { "prefetcht0", { Mb
} },
9429 { "(bad)", { XX
} },
9432 /* MOD_0F18_REG_2 */
9433 { "prefetcht1", { Mb
} },
9434 { "(bad)", { XX
} },
9437 /* MOD_0F18_REG_3 */
9438 { "prefetcht2", { Mb
} },
9439 { "(bad)", { XX
} },
9443 { "(bad)", { XX
} },
9444 { "movZ", { Rm
, Cm
} },
9448 { "(bad)", { XX
} },
9449 { "movZ", { Rm
, Dm
} },
9453 { "(bad)", { XX
} },
9454 { "movZ", { Cm
, Rm
} },
9458 { "(bad)", { XX
} },
9459 { "movZ", { Dm
, Rm
} },
9463 { "(bad)", { XX
} },
9464 { "movL", { Rd
, Td
} },
9468 { "(bad)", { XX
} },
9469 { "movL", { Td
, Rd
} },
9472 /* MOD_0F2B_PREFIX_0 */
9473 {"movntps", { Mx
, XM
} },
9474 { "(bad)", { XX
} },
9477 /* MOD_0F2B_PREFIX_1 */
9478 {"movntss", { Md
, XM
} },
9479 { "(bad)", { XX
} },
9482 /* MOD_0F2B_PREFIX_2 */
9483 {"movntpd", { Mx
, XM
} },
9484 { "(bad)", { XX
} },
9487 /* MOD_0F2B_PREFIX_3 */
9488 {"movntsd", { Mq
, XM
} },
9489 { "(bad)", { XX
} },
9493 { "(bad)", { XX
} },
9494 { "movmskpX", { Gdq
, XS
} },
9497 /* MOD_0F71_REG_2 */
9498 { "(bad)", { XX
} },
9499 { "psrlw", { MS
, Ib
} },
9502 /* MOD_0F71_REG_4 */
9503 { "(bad)", { XX
} },
9504 { "psraw", { MS
, Ib
} },
9507 /* MOD_0F71_REG_6 */
9508 { "(bad)", { XX
} },
9509 { "psllw", { MS
, Ib
} },
9512 /* MOD_0F72_REG_2 */
9513 { "(bad)", { XX
} },
9514 { "psrld", { MS
, Ib
} },
9517 /* MOD_0F72_REG_4 */
9518 { "(bad)", { XX
} },
9519 { "psrad", { MS
, Ib
} },
9522 /* MOD_0F72_REG_6 */
9523 { "(bad)", { XX
} },
9524 { "pslld", { MS
, Ib
} },
9527 /* MOD_0F73_REG_2 */
9528 { "(bad)", { XX
} },
9529 { "psrlq", { MS
, Ib
} },
9532 /* MOD_0F73_REG_3 */
9533 { "(bad)", { XX
} },
9534 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
9537 /* MOD_0F73_REG_6 */
9538 { "(bad)", { XX
} },
9539 { "psllq", { MS
, Ib
} },
9542 /* MOD_0F73_REG_7 */
9543 { "(bad)", { XX
} },
9544 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
9547 /* MOD_0FAE_REG_0 */
9548 { "fxsave", { FXSAVE
} },
9549 { "(bad)", { XX
} },
9552 /* MOD_0FAE_REG_1 */
9553 { "fxrstor", { FXSAVE
} },
9554 { "(bad)", { XX
} },
9557 /* MOD_0FAE_REG_2 */
9558 { "ldmxcsr", { Md
} },
9559 { "(bad)", { XX
} },
9562 /* MOD_0FAE_REG_3 */
9563 { "stmxcsr", { Md
} },
9564 { "(bad)", { XX
} },
9567 /* MOD_0FAE_REG_4 */
9569 { "(bad)", { XX
} },
9572 /* MOD_0FAE_REG_5 */
9573 { "xrstor", { M
} },
9574 { RM_TABLE (RM_0FAE_REG_5
) },
9577 /* MOD_0FAE_REG_6 */
9578 { "xsaveopt", { M
} },
9579 { RM_TABLE (RM_0FAE_REG_6
) },
9582 /* MOD_0FAE_REG_7 */
9583 { "clflush", { Mb
} },
9584 { RM_TABLE (RM_0FAE_REG_7
) },
9588 { "lssS", { Gv
, Mp
} },
9589 { "(bad)", { XX
} },
9593 { "lfsS", { Gv
, Mp
} },
9594 { "(bad)", { XX
} },
9598 { "lgsS", { Gv
, Mp
} },
9599 { "(bad)", { XX
} },
9602 /* MOD_0FC7_REG_6 */
9603 { PREFIX_TABLE (PREFIX_0FC7_REG_6
) },
9604 { "(bad)", { XX
} },
9607 /* MOD_0FC7_REG_7 */
9608 { "vmptrst", { Mq
} },
9609 { "(bad)", { XX
} },
9613 { "(bad)", { XX
} },
9614 { "pmovmskb", { Gdq
, MS
} },
9617 /* MOD_0FE7_PREFIX_2 */
9618 { "movntdq", { Mx
, XM
} },
9619 { "(bad)", { XX
} },
9622 /* MOD_0FF0_PREFIX_3 */
9623 { "lddqu", { XM
, M
} },
9624 { "(bad)", { XX
} },
9627 /* MOD_0F382A_PREFIX_2 */
9628 { "movntdqa", { XM
, Mx
} },
9629 { "(bad)", { XX
} },
9633 { "bound{S|}", { Gv
, Ma
} },
9634 { "(bad)", { XX
} },
9638 { "lesS", { Gv
, Mp
} },
9639 { VEX_C4_TABLE (VEX_0F
) },
9643 { "ldsS", { Gv
, Mp
} },
9644 { VEX_C5_TABLE (VEX_0F
) },
9647 /* MOD_VEX_12_PREFIX_0 */
9648 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0
) },
9649 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1
) },
9653 { VEX_LEN_TABLE (VEX_LEN_13_M_0
) },
9654 { "(bad)", { XX
} },
9657 /* MOD_VEX_16_PREFIX_0 */
9658 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0
) },
9659 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1
) },
9663 { VEX_LEN_TABLE (VEX_LEN_17_M_0
) },
9664 { "(bad)", { XX
} },
9668 { "vmovntpX", { Mx
, XM
} },
9669 { "(bad)", { XX
} },
9673 { "(bad)", { XX
} },
9674 { "vmovmskpX", { Gdq
, XS
} },
9677 /* MOD_VEX_71_REG_2 */
9678 { "(bad)", { XX
} },
9679 { PREFIX_TABLE (PREFIX_VEX_71_REG_2
) },
9682 /* MOD_VEX_71_REG_4 */
9683 { "(bad)", { XX
} },
9684 { PREFIX_TABLE (PREFIX_VEX_71_REG_4
) },
9687 /* MOD_VEX_71_REG_6 */
9688 { "(bad)", { XX
} },
9689 { PREFIX_TABLE (PREFIX_VEX_71_REG_6
) },
9692 /* MOD_VEX_72_REG_2 */
9693 { "(bad)", { XX
} },
9694 { PREFIX_TABLE (PREFIX_VEX_72_REG_2
) },
9697 /* MOD_VEX_72_REG_4 */
9698 { "(bad)", { XX
} },
9699 { PREFIX_TABLE (PREFIX_VEX_72_REG_4
) },
9702 /* MOD_VEX_72_REG_6 */
9703 { "(bad)", { XX
} },
9704 { PREFIX_TABLE (PREFIX_VEX_72_REG_6
) },
9707 /* MOD_VEX_73_REG_2 */
9708 { "(bad)", { XX
} },
9709 { PREFIX_TABLE (PREFIX_VEX_73_REG_2
) },
9712 /* MOD_VEX_73_REG_3 */
9713 { "(bad)", { XX
} },
9714 { PREFIX_TABLE (PREFIX_VEX_73_REG_3
) },
9717 /* MOD_VEX_73_REG_6 */
9718 { "(bad)", { XX
} },
9719 { PREFIX_TABLE (PREFIX_VEX_73_REG_6
) },
9722 /* MOD_VEX_73_REG_7 */
9723 { "(bad)", { XX
} },
9724 { PREFIX_TABLE (PREFIX_VEX_73_REG_7
) },
9727 /* MOD_VEX_AE_REG_2 */
9728 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0
) },
9729 { "(bad)", { XX
} },
9732 /* MOD_VEX_AE_REG_3 */
9733 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0
) },
9734 { "(bad)", { XX
} },
9737 /* MOD_VEX_D7_PREFIX_2 */
9738 { "(bad)", { XX
} },
9739 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1
) },
9742 /* MOD_VEX_E7_PREFIX_2 */
9743 { "vmovntdq", { Mx
, XM
} },
9744 { "(bad)", { XX
} },
9747 /* MOD_VEX_F0_PREFIX_3 */
9748 { "vlddqu", { XM
, M
} },
9749 { "(bad)", { XX
} },
9752 /* MOD_VEX_3818_PREFIX_2 */
9753 { "vbroadcastss", { XM
, Md
} },
9754 { "(bad)", { XX
} },
9757 /* MOD_VEX_3819_PREFIX_2 */
9758 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0
) },
9759 { "(bad)", { XX
} },
9762 /* MOD_VEX_381A_PREFIX_2 */
9763 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0
) },
9764 { "(bad)", { XX
} },
9767 /* MOD_VEX_382A_PREFIX_2 */
9768 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0
) },
9769 { "(bad)", { XX
} },
9772 /* MOD_VEX_382C_PREFIX_2 */
9773 { "vmaskmovps", { XM
, Vex
, Mx
} },
9774 { "(bad)", { XX
} },
9777 /* MOD_VEX_382D_PREFIX_2 */
9778 { "vmaskmovpd", { XM
, Vex
, Mx
} },
9779 { "(bad)", { XX
} },
9782 /* MOD_VEX_382E_PREFIX_2 */
9783 { "vmaskmovps", { Mx
, Vex
, XM
} },
9784 { "(bad)", { XX
} },
9787 /* MOD_VEX_382F_PREFIX_2 */
9788 { "vmaskmovpd", { Mx
, Vex
, XM
} },
9789 { "(bad)", { XX
} },
9793 static const struct dis386 rm_table
[][8] = {
9796 { "(bad)", { XX
} },
9797 { "vmcall", { Skip_MODRM
} },
9798 { "vmlaunch", { Skip_MODRM
} },
9799 { "vmresume", { Skip_MODRM
} },
9800 { "vmxoff", { Skip_MODRM
} },
9801 { "(bad)", { XX
} },
9802 { "(bad)", { XX
} },
9803 { "(bad)", { XX
} },
9807 { "monitor", { { OP_Monitor
, 0 } } },
9808 { "mwait", { { OP_Mwait
, 0 } } },
9809 { "(bad)", { XX
} },
9810 { "(bad)", { XX
} },
9811 { "(bad)", { XX
} },
9812 { "(bad)", { XX
} },
9813 { "(bad)", { XX
} },
9814 { "(bad)", { XX
} },
9818 { "xgetbv", { Skip_MODRM
} },
9819 { "xsetbv", { Skip_MODRM
} },
9820 { "(bad)", { XX
} },
9821 { "(bad)", { XX
} },
9822 { "(bad)", { XX
} },
9823 { "(bad)", { XX
} },
9824 { "(bad)", { XX
} },
9825 { "(bad)", { XX
} },
9829 { "vmrun", { Skip_MODRM
} },
9830 { "vmmcall", { Skip_MODRM
} },
9831 { "vmload", { Skip_MODRM
} },
9832 { "vmsave", { Skip_MODRM
} },
9833 { "stgi", { Skip_MODRM
} },
9834 { "clgi", { Skip_MODRM
} },
9835 { "skinit", { Skip_MODRM
} },
9836 { "invlpga", { Skip_MODRM
} },
9840 { "swapgs", { Skip_MODRM
} },
9841 { "rdtscp", { Skip_MODRM
} },
9842 { "(bad)", { XX
} },
9843 { "(bad)", { XX
} },
9844 { "(bad)", { XX
} },
9845 { "(bad)", { XX
} },
9846 { "(bad)", { XX
} },
9847 { "(bad)", { XX
} },
9851 { "lfence", { Skip_MODRM
} },
9852 { "(bad)", { XX
} },
9853 { "(bad)", { XX
} },
9854 { "(bad)", { XX
} },
9855 { "(bad)", { XX
} },
9856 { "(bad)", { XX
} },
9857 { "(bad)", { XX
} },
9858 { "(bad)", { XX
} },
9862 { "mfence", { Skip_MODRM
} },
9863 { "(bad)", { XX
} },
9864 { "(bad)", { XX
} },
9865 { "(bad)", { XX
} },
9866 { "(bad)", { XX
} },
9867 { "(bad)", { XX
} },
9868 { "(bad)", { XX
} },
9869 { "(bad)", { XX
} },
9873 { "sfence", { Skip_MODRM
} },
9874 { "(bad)", { XX
} },
9875 { "(bad)", { XX
} },
9876 { "(bad)", { XX
} },
9877 { "(bad)", { XX
} },
9878 { "(bad)", { XX
} },
9879 { "(bad)", { XX
} },
9880 { "(bad)", { XX
} },
9884 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9886 /* We use the high bit to indicate different name for the same
9888 #define ADDR16_PREFIX (0x67 | 0x100)
9889 #define ADDR32_PREFIX (0x67 | 0x200)
9890 #define DATA16_PREFIX (0x66 | 0x100)
9891 #define DATA32_PREFIX (0x66 | 0x200)
9892 #define REP_PREFIX (0xf3 | 0x100)
9897 int newrex
, i
, length
;
9904 last_lock_prefix
= -1;
9905 last_repz_prefix
= -1;
9906 last_repnz_prefix
= -1;
9907 last_data_prefix
= -1;
9908 last_addr_prefix
= -1;
9909 last_rex_prefix
= -1;
9910 last_seg_prefix
= -1;
9911 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
9912 all_prefixes
[i
] = 0;
9915 /* The maximum instruction length is 15bytes. */
9916 while (length
< MAX_CODE_LENGTH
- 1)
9918 FETCH_DATA (the_info
, codep
+ 1);
9922 /* REX prefixes family. */
9939 if (address_mode
== mode_64bit
)
9943 last_rex_prefix
= i
;
9946 prefixes
|= PREFIX_REPZ
;
9947 last_repz_prefix
= i
;
9950 prefixes
|= PREFIX_REPNZ
;
9951 last_repnz_prefix
= i
;
9954 prefixes
|= PREFIX_LOCK
;
9955 last_lock_prefix
= i
;
9958 prefixes
|= PREFIX_CS
;
9959 last_seg_prefix
= i
;
9962 prefixes
|= PREFIX_SS
;
9963 last_seg_prefix
= i
;
9966 prefixes
|= PREFIX_DS
;
9967 last_seg_prefix
= i
;
9970 prefixes
|= PREFIX_ES
;
9971 last_seg_prefix
= i
;
9974 prefixes
|= PREFIX_FS
;
9975 last_seg_prefix
= i
;
9978 prefixes
|= PREFIX_GS
;
9979 last_seg_prefix
= i
;
9982 prefixes
|= PREFIX_DATA
;
9983 last_data_prefix
= i
;
9986 prefixes
|= PREFIX_ADDR
;
9987 last_addr_prefix
= i
;
9990 /* fwait is really an instruction. If there are prefixes
9991 before the fwait, they belong to the fwait, *not* to the
9992 following instruction. */
9993 if (prefixes
|| rex
)
9995 prefixes
|= PREFIX_FWAIT
;
9999 prefixes
= PREFIX_FWAIT
;
10004 /* Rex is ignored when followed by another prefix. */
10010 if (*codep
!= FWAIT_OPCODE
)
10011 all_prefixes
[i
++] = *codep
;
10013 rex_original
= rex
;
10021 seg_prefix (int pref
)
10042 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10045 static const char *
10046 prefix_name (int pref
, int sizeflag
)
10048 static const char *rexes
[16] =
10051 "rex.B", /* 0x41 */
10052 "rex.X", /* 0x42 */
10053 "rex.XB", /* 0x43 */
10054 "rex.R", /* 0x44 */
10055 "rex.RB", /* 0x45 */
10056 "rex.RX", /* 0x46 */
10057 "rex.RXB", /* 0x47 */
10058 "rex.W", /* 0x48 */
10059 "rex.WB", /* 0x49 */
10060 "rex.WX", /* 0x4a */
10061 "rex.WXB", /* 0x4b */
10062 "rex.WR", /* 0x4c */
10063 "rex.WRB", /* 0x4d */
10064 "rex.WRX", /* 0x4e */
10065 "rex.WRXB", /* 0x4f */
10070 /* REX prefixes family. */
10087 return rexes
[pref
- 0x40];
10107 return (sizeflag
& DFLAG
) ? "data16" : "data32";
10109 if (address_mode
== mode_64bit
)
10110 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
10112 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
10115 case ADDR16_PREFIX
:
10117 case ADDR32_PREFIX
:
10119 case DATA16_PREFIX
:
10121 case DATA32_PREFIX
:
10130 static char op_out
[MAX_OPERANDS
][100];
10131 static int op_ad
, op_index
[MAX_OPERANDS
];
10132 static int two_source_ops
;
10133 static bfd_vma op_address
[MAX_OPERANDS
];
10134 static bfd_vma op_riprel
[MAX_OPERANDS
];
10135 static bfd_vma start_pc
;
10138 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10139 * (see topic "Redundant prefixes" in the "Differences from 8086"
10140 * section of the "Virtual 8086 Mode" chapter.)
10141 * 'pc' should be the address of this instruction, it will
10142 * be used to print the target address if this is a relative jump or call
10143 * The function returns the length of this instruction in bytes.
10146 static char intel_syntax
;
10147 static char intel_mnemonic
= !SYSV386_COMPAT
;
10148 static char open_char
;
10149 static char close_char
;
10150 static char separator_char
;
10151 static char scale_char
;
10153 /* Here for backwards compatibility. When gdb stops using
10154 print_insn_i386_att and print_insn_i386_intel these functions can
10155 disappear, and print_insn_i386 be merged into print_insn. */
10157 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
10161 return print_insn (pc
, info
);
10165 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
10169 return print_insn (pc
, info
);
10173 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
10177 return print_insn (pc
, info
);
10181 print_i386_disassembler_options (FILE *stream
)
10183 fprintf (stream
, _("\n\
10184 The following i386/x86-64 specific disassembler options are supported for use\n\
10185 with the -M switch (multiple options should be separated by commas):\n"));
10187 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
10188 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
10189 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
10190 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
10191 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
10192 fprintf (stream
, _(" att-mnemonic\n"
10193 " Display instruction in AT&T mnemonic\n"));
10194 fprintf (stream
, _(" intel-mnemonic\n"
10195 " Display instruction in Intel mnemonic\n"));
10196 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
10197 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
10198 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
10199 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
10200 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
10201 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10204 /* Get a pointer to struct dis386 with a valid name. */
10206 static const struct dis386
*
10207 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
10209 int vindex
, vex_table_index
;
10211 if (dp
->name
!= NULL
)
10214 switch (dp
->op
[0].bytemode
)
10216 case USE_REG_TABLE
:
10217 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
10220 case USE_MOD_TABLE
:
10221 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
10222 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
10226 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
10229 case USE_PREFIX_TABLE
:
10232 /* The prefix in VEX is implicit. */
10233 switch (vex
.prefix
)
10238 case REPE_PREFIX_OPCODE
:
10241 case DATA_PREFIX_OPCODE
:
10244 case REPNE_PREFIX_OPCODE
:
10255 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
10256 if (prefixes
& PREFIX_REPZ
)
10259 all_prefixes
[last_repz_prefix
] = 0;
10263 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10265 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
10266 if (prefixes
& PREFIX_REPNZ
)
10269 all_prefixes
[last_repnz_prefix
] = 0;
10273 used_prefixes
|= (prefixes
& PREFIX_DATA
);
10274 if (prefixes
& PREFIX_DATA
)
10277 all_prefixes
[last_data_prefix
] = 0;
10282 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
10285 case USE_X86_64_TABLE
:
10286 vindex
= address_mode
== mode_64bit
? 1 : 0;
10287 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
10290 case USE_3BYTE_TABLE
:
10291 FETCH_DATA (info
, codep
+ 2);
10293 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
10294 modrm
.mod
= (*codep
>> 6) & 3;
10295 modrm
.reg
= (*codep
>> 3) & 7;
10296 modrm
.rm
= *codep
& 7;
10299 case USE_VEX_LEN_TABLE
:
10303 switch (vex
.length
)
10316 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
10319 case USE_XOP_8F_TABLE
:
10320 FETCH_DATA (info
, codep
+ 3);
10321 /* All bits in the REX prefix are ignored. */
10323 rex
= ~(*codep
>> 5) & 0x7;
10325 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10326 switch ((*codep
& 0x1f))
10331 vex_table_index
= XOP_08
;
10334 vex_table_index
= XOP_09
;
10337 vex_table_index
= XOP_0A
;
10341 vex
.w
= *codep
& 0x80;
10342 if (vex
.w
&& address_mode
== mode_64bit
)
10345 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10346 if (address_mode
!= mode_64bit
10347 && vex
.register_specifier
> 0x7)
10350 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10351 switch ((*codep
& 0x3))
10357 vex
.prefix
= DATA_PREFIX_OPCODE
;
10360 vex
.prefix
= REPE_PREFIX_OPCODE
;
10363 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10370 dp
= &xop_table
[vex_table_index
][vindex
];
10372 FETCH_DATA (info
, codep
+ 1);
10373 modrm
.mod
= (*codep
>> 6) & 3;
10374 modrm
.reg
= (*codep
>> 3) & 7;
10375 modrm
.rm
= *codep
& 7;
10378 case USE_VEX_C4_TABLE
:
10379 FETCH_DATA (info
, codep
+ 3);
10380 /* All bits in the REX prefix are ignored. */
10382 rex
= ~(*codep
>> 5) & 0x7;
10383 switch ((*codep
& 0x1f))
10388 vex_table_index
= VEX_0F
;
10391 vex_table_index
= VEX_0F38
;
10394 vex_table_index
= VEX_0F3A
;
10398 vex
.w
= *codep
& 0x80;
10399 if (vex
.w
&& address_mode
== mode_64bit
)
10402 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10403 if (address_mode
!= mode_64bit
10404 && vex
.register_specifier
> 0x7)
10407 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10408 switch ((*codep
& 0x3))
10414 vex
.prefix
= DATA_PREFIX_OPCODE
;
10417 vex
.prefix
= REPE_PREFIX_OPCODE
;
10420 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10427 dp
= &vex_table
[vex_table_index
][vindex
];
10428 /* There is no MODRM byte for VEX [82|77]. */
10429 if (vindex
!= 0x77 && vindex
!= 0x82)
10431 FETCH_DATA (info
, codep
+ 1);
10432 modrm
.mod
= (*codep
>> 6) & 3;
10433 modrm
.reg
= (*codep
>> 3) & 7;
10434 modrm
.rm
= *codep
& 7;
10438 case USE_VEX_C5_TABLE
:
10439 FETCH_DATA (info
, codep
+ 2);
10440 /* All bits in the REX prefix are ignored. */
10442 rex
= (*codep
& 0x80) ? 0 : REX_R
;
10444 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
10445 if (address_mode
!= mode_64bit
10446 && vex
.register_specifier
> 0x7)
10451 vex
.length
= (*codep
& 0x4) ? 256 : 128;
10452 switch ((*codep
& 0x3))
10458 vex
.prefix
= DATA_PREFIX_OPCODE
;
10461 vex
.prefix
= REPE_PREFIX_OPCODE
;
10464 vex
.prefix
= REPNE_PREFIX_OPCODE
;
10471 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
10472 /* There is no MODRM byte for VEX [82|77]. */
10473 if (vindex
!= 0x77 && vindex
!= 0x82)
10475 FETCH_DATA (info
, codep
+ 1);
10476 modrm
.mod
= (*codep
>> 6) & 3;
10477 modrm
.reg
= (*codep
>> 3) & 7;
10478 modrm
.rm
= *codep
& 7;
10486 if (dp
->name
!= NULL
)
10489 return get_valid_dis386 (dp
, info
);
10493 print_insn (bfd_vma pc
, disassemble_info
*info
)
10495 const struct dis386
*dp
;
10497 char *op_txt
[MAX_OPERANDS
];
10501 struct dis_private priv
;
10504 int default_prefixes
;
10506 if (info
->mach
== bfd_mach_x86_64_intel_syntax
10507 || info
->mach
== bfd_mach_x86_64
10508 || info
->mach
== bfd_mach_l1om
10509 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10510 address_mode
= mode_64bit
;
10512 address_mode
= mode_32bit
;
10514 if (intel_syntax
== (char) -1)
10515 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
10516 || info
->mach
== bfd_mach_x86_64_intel_syntax
10517 || info
->mach
== bfd_mach_l1om_intel_syntax
);
10519 if (info
->mach
== bfd_mach_i386_i386
10520 || info
->mach
== bfd_mach_x86_64
10521 || info
->mach
== bfd_mach_l1om
10522 || info
->mach
== bfd_mach_i386_i386_intel_syntax
10523 || info
->mach
== bfd_mach_x86_64_intel_syntax
10524 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10525 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10526 else if (info
->mach
== bfd_mach_i386_i8086
)
10527 priv
.orig_sizeflag
= 0;
10531 for (p
= info
->disassembler_options
; p
!= NULL
; )
10533 if (CONST_STRNEQ (p
, "x86-64"))
10535 address_mode
= mode_64bit
;
10536 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10538 else if (CONST_STRNEQ (p
, "i386"))
10540 address_mode
= mode_32bit
;
10541 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
10543 else if (CONST_STRNEQ (p
, "i8086"))
10545 address_mode
= mode_16bit
;
10546 priv
.orig_sizeflag
= 0;
10548 else if (CONST_STRNEQ (p
, "intel"))
10551 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
10552 intel_mnemonic
= 1;
10554 else if (CONST_STRNEQ (p
, "att"))
10557 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
10558 intel_mnemonic
= 0;
10560 else if (CONST_STRNEQ (p
, "addr"))
10562 if (address_mode
== mode_64bit
)
10564 if (p
[4] == '3' && p
[5] == '2')
10565 priv
.orig_sizeflag
&= ~AFLAG
;
10566 else if (p
[4] == '6' && p
[5] == '4')
10567 priv
.orig_sizeflag
|= AFLAG
;
10571 if (p
[4] == '1' && p
[5] == '6')
10572 priv
.orig_sizeflag
&= ~AFLAG
;
10573 else if (p
[4] == '3' && p
[5] == '2')
10574 priv
.orig_sizeflag
|= AFLAG
;
10577 else if (CONST_STRNEQ (p
, "data"))
10579 if (p
[4] == '1' && p
[5] == '6')
10580 priv
.orig_sizeflag
&= ~DFLAG
;
10581 else if (p
[4] == '3' && p
[5] == '2')
10582 priv
.orig_sizeflag
|= DFLAG
;
10584 else if (CONST_STRNEQ (p
, "suffix"))
10585 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
10587 p
= strchr (p
, ',');
10594 names64
= intel_names64
;
10595 names32
= intel_names32
;
10596 names16
= intel_names16
;
10597 names8
= intel_names8
;
10598 names8rex
= intel_names8rex
;
10599 names_seg
= intel_names_seg
;
10600 index64
= intel_index64
;
10601 index32
= intel_index32
;
10602 index16
= intel_index16
;
10605 separator_char
= '+';
10610 names64
= att_names64
;
10611 names32
= att_names32
;
10612 names16
= att_names16
;
10613 names8
= att_names8
;
10614 names8rex
= att_names8rex
;
10615 names_seg
= att_names_seg
;
10616 index64
= att_index64
;
10617 index32
= att_index32
;
10618 index16
= att_index16
;
10621 separator_char
= ',';
10625 /* The output looks better if we put 7 bytes on a line, since that
10626 puts most long word instructions on a single line. Use 8 bytes
10628 if (info
->mach
== bfd_mach_l1om
10629 || info
->mach
== bfd_mach_l1om_intel_syntax
)
10630 info
->bytes_per_line
= 8;
10632 info
->bytes_per_line
= 7;
10634 info
->private_data
= &priv
;
10635 priv
.max_fetched
= priv
.the_buffer
;
10636 priv
.insn_start
= pc
;
10639 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10647 start_codep
= priv
.the_buffer
;
10648 codep
= priv
.the_buffer
;
10650 if (setjmp (priv
.bailout
) != 0)
10654 /* Getting here means we tried for data but didn't get it. That
10655 means we have an incomplete instruction of some sort. Just
10656 print the first byte as a prefix or a .byte pseudo-op. */
10657 if (codep
> priv
.the_buffer
)
10659 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
10661 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10664 /* Just print the first byte as a .byte instruction. */
10665 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
10666 (unsigned int) priv
.the_buffer
[0]);
10676 sizeflag
= priv
.orig_sizeflag
;
10678 if (!ckprefix () || rex_used
)
10680 /* Too many prefixes or unused REX prefixes. */
10682 all_prefixes
[i
] && i
< (int) ARRAY_SIZE (all_prefixes
);
10684 (*info
->fprintf_func
) (info
->stream
, "%s",
10685 prefix_name (all_prefixes
[i
], sizeflag
));
10689 insn_codep
= codep
;
10691 FETCH_DATA (info
, codep
+ 1);
10692 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
10694 if (((prefixes
& PREFIX_FWAIT
)
10695 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
10697 (*info
->fprintf_func
) (info
->stream
, "fwait");
10703 if (*codep
== 0x0f)
10705 unsigned char threebyte
;
10706 FETCH_DATA (info
, codep
+ 2);
10707 threebyte
= *++codep
;
10708 dp
= &dis386_twobyte
[threebyte
];
10709 need_modrm
= twobyte_has_modrm
[*codep
];
10714 dp
= &dis386
[*codep
];
10715 need_modrm
= onebyte_has_modrm
[*codep
];
10719 if ((prefixes
& PREFIX_REPZ
))
10720 used_prefixes
|= PREFIX_REPZ
;
10721 if ((prefixes
& PREFIX_REPNZ
))
10722 used_prefixes
|= PREFIX_REPNZ
;
10723 if ((prefixes
& PREFIX_LOCK
))
10724 used_prefixes
|= PREFIX_LOCK
;
10726 default_prefixes
= 0;
10727 if (prefixes
& PREFIX_ADDR
)
10730 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
10732 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
10733 all_prefixes
[last_addr_prefix
] = ADDR32_PREFIX
;
10735 all_prefixes
[last_addr_prefix
] = ADDR16_PREFIX
;
10736 default_prefixes
|= PREFIX_ADDR
;
10740 if ((prefixes
& PREFIX_DATA
))
10743 if (dp
->op
[2].bytemode
== cond_jump_mode
10744 && dp
->op
[0].bytemode
== v_mode
10747 if (sizeflag
& DFLAG
)
10748 all_prefixes
[last_data_prefix
] = DATA32_PREFIX
;
10750 all_prefixes
[last_data_prefix
] = DATA16_PREFIX
;
10751 default_prefixes
|= PREFIX_DATA
;
10753 else if (rex
& REX_W
)
10755 /* REX_W will override PREFIX_DATA. */
10756 default_prefixes
|= PREFIX_DATA
;
10762 FETCH_DATA (info
, codep
+ 1);
10763 modrm
.mod
= (*codep
>> 6) & 3;
10764 modrm
.reg
= (*codep
>> 3) & 7;
10765 modrm
.rm
= *codep
& 7;
10772 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
10774 dofloat (sizeflag
);
10778 dp
= get_valid_dis386 (dp
, info
);
10779 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
10781 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10784 op_ad
= MAX_OPERANDS
- 1 - i
;
10786 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
10791 /* See if any prefixes were not used. If so, print the first one
10792 separately. If we don't do this, we'll wind up printing an
10793 instruction stream which does not precisely correspond to the
10794 bytes we are disassembling. */
10795 if ((prefixes
& ~(used_prefixes
| default_prefixes
)) != 0)
10797 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10798 if (all_prefixes
[i
])
10801 name
= prefix_name (all_prefixes
[i
], priv
.orig_sizeflag
);
10803 name
= INTERNAL_DISASSEMBLER_ERROR
;
10804 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
10809 /* Check if the REX prefix used. */
10810 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0)
10811 all_prefixes
[last_rex_prefix
] = 0;
10813 /* Check if the SEG prefix used. */
10814 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
10815 | PREFIX_FS
| PREFIX_GS
)) != 0
10817 & seg_prefix (all_prefixes
[last_seg_prefix
])) != 0)
10818 all_prefixes
[last_seg_prefix
] = 0;
10820 /* Check if the ADDR prefix used. */
10821 if ((prefixes
& PREFIX_ADDR
) != 0
10822 && (used_prefixes
& PREFIX_ADDR
) != 0)
10823 all_prefixes
[last_addr_prefix
] = 0;
10825 /* Check if the DATA prefix used. */
10826 if ((prefixes
& PREFIX_DATA
) != 0
10827 && (used_prefixes
& PREFIX_DATA
) != 0)
10828 all_prefixes
[last_data_prefix
] = 0;
10831 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
10832 if (all_prefixes
[i
])
10835 name
= prefix_name (all_prefixes
[i
], sizeflag
);
10838 prefix_length
+= strlen (name
) + 1;
10839 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
10842 /* Check maximum code length. */
10843 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
10845 (*info
->fprintf_func
) (info
->stream
, "(bad)");
10846 return MAX_CODE_LENGTH
;
10849 obufp
= mnemonicendp
;
10850 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
10853 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
10855 /* The enter and bound instructions are printed with operands in the same
10856 order as the intel book; everything else is printed in reverse order. */
10857 if (intel_syntax
|| two_source_ops
)
10861 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10862 op_txt
[i
] = op_out
[i
];
10864 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
10866 op_ad
= op_index
[i
];
10867 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
10868 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
10869 riprel
= op_riprel
[i
];
10870 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
10871 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
10876 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10877 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
10881 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
10885 (*info
->fprintf_func
) (info
->stream
, ",");
10886 if (op_index
[i
] != -1 && !op_riprel
[i
])
10887 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
10889 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
10893 for (i
= 0; i
< MAX_OPERANDS
; i
++)
10894 if (op_index
[i
] != -1 && op_riprel
[i
])
10896 (*info
->fprintf_func
) (info
->stream
, " # ");
10897 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
10898 + op_address
[op_index
[i
]]), info
);
10901 return codep
- priv
.the_buffer
;
10904 static const char *float_mem
[] = {
10979 static const unsigned char float_mem_mode
[] = {
11054 #define ST { OP_ST, 0 }
11055 #define STi { OP_STi, 0 }
11057 #define FGRPd9_2 NULL, { { NULL, 0 } }
11058 #define FGRPd9_4 NULL, { { NULL, 1 } }
11059 #define FGRPd9_5 NULL, { { NULL, 2 } }
11060 #define FGRPd9_6 NULL, { { NULL, 3 } }
11061 #define FGRPd9_7 NULL, { { NULL, 4 } }
11062 #define FGRPda_5 NULL, { { NULL, 5 } }
11063 #define FGRPdb_4 NULL, { { NULL, 6 } }
11064 #define FGRPde_3 NULL, { { NULL, 7 } }
11065 #define FGRPdf_4 NULL, { { NULL, 8 } }
11067 static const struct dis386 float_reg
[][8] = {
11070 { "fadd", { ST
, STi
} },
11071 { "fmul", { ST
, STi
} },
11072 { "fcom", { STi
} },
11073 { "fcomp", { STi
} },
11074 { "fsub", { ST
, STi
} },
11075 { "fsubr", { ST
, STi
} },
11076 { "fdiv", { ST
, STi
} },
11077 { "fdivr", { ST
, STi
} },
11081 { "fld", { STi
} },
11082 { "fxch", { STi
} },
11084 { "(bad)", { XX
} },
11092 { "fcmovb", { ST
, STi
} },
11093 { "fcmove", { ST
, STi
} },
11094 { "fcmovbe",{ ST
, STi
} },
11095 { "fcmovu", { ST
, STi
} },
11096 { "(bad)", { XX
} },
11098 { "(bad)", { XX
} },
11099 { "(bad)", { XX
} },
11103 { "fcmovnb",{ ST
, STi
} },
11104 { "fcmovne",{ ST
, STi
} },
11105 { "fcmovnbe",{ ST
, STi
} },
11106 { "fcmovnu",{ ST
, STi
} },
11108 { "fucomi", { ST
, STi
} },
11109 { "fcomi", { ST
, STi
} },
11110 { "(bad)", { XX
} },
11114 { "fadd", { STi
, ST
} },
11115 { "fmul", { STi
, ST
} },
11116 { "(bad)", { XX
} },
11117 { "(bad)", { XX
} },
11118 { "fsub!M", { STi
, ST
} },
11119 { "fsubM", { STi
, ST
} },
11120 { "fdiv!M", { STi
, ST
} },
11121 { "fdivM", { STi
, ST
} },
11125 { "ffree", { STi
} },
11126 { "(bad)", { XX
} },
11127 { "fst", { STi
} },
11128 { "fstp", { STi
} },
11129 { "fucom", { STi
} },
11130 { "fucomp", { STi
} },
11131 { "(bad)", { XX
} },
11132 { "(bad)", { XX
} },
11136 { "faddp", { STi
, ST
} },
11137 { "fmulp", { STi
, ST
} },
11138 { "(bad)", { XX
} },
11140 { "fsub!Mp", { STi
, ST
} },
11141 { "fsubMp", { STi
, ST
} },
11142 { "fdiv!Mp", { STi
, ST
} },
11143 { "fdivMp", { STi
, ST
} },
11147 { "ffreep", { STi
} },
11148 { "(bad)", { XX
} },
11149 { "(bad)", { XX
} },
11150 { "(bad)", { XX
} },
11152 { "fucomip", { ST
, STi
} },
11153 { "fcomip", { ST
, STi
} },
11154 { "(bad)", { XX
} },
11158 static char *fgrps
[][8] = {
11161 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11166 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11171 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11176 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11181 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11186 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11191 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11192 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11197 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11202 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11207 swap_operand (void)
11209 mnemonicendp
[0] = '.';
11210 mnemonicendp
[1] = 's';
11215 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
11216 int sizeflag ATTRIBUTE_UNUSED
)
11218 /* Skip mod/rm byte. */
11224 dofloat (int sizeflag
)
11226 const struct dis386
*dp
;
11227 unsigned char floatop
;
11229 floatop
= codep
[-1];
11231 if (modrm
.mod
!= 3)
11233 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
11235 putop (float_mem
[fp_indx
], sizeflag
);
11238 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
11241 /* Skip mod/rm byte. */
11245 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
11246 if (dp
->name
== NULL
)
11248 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
11250 /* Instruction fnstsw is only one with strange arg. */
11251 if (floatop
== 0xdf && codep
[-1] == 0xe0)
11252 strcpy (op_out
[0], names16
[0]);
11256 putop (dp
->name
, sizeflag
);
11261 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
11266 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
11271 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11273 oappend ("%st" + intel_syntax
);
11277 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
11279 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
11280 oappend (scratchbuf
+ intel_syntax
);
11283 /* Capital letters in template are macros. */
11285 putop (const char *in_template
, int sizeflag
)
11290 unsigned int l
= 0, len
= 1;
11293 #define SAVE_LAST(c) \
11294 if (l < len && l < sizeof (last)) \
11299 for (p
= in_template
; *p
; p
++)
11316 while (*++p
!= '|')
11317 if (*p
== '}' || *p
== '\0')
11320 /* Fall through. */
11325 while (*++p
!= '}')
11336 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11340 if (l
== 0 && len
== 1)
11345 if (sizeflag
& SUFFIX_ALWAYS
)
11358 if (address_mode
== mode_64bit
11359 && !(prefixes
& PREFIX_ADDR
))
11370 if (intel_syntax
&& !alt
)
11372 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
11374 if (sizeflag
& DFLAG
)
11375 *obufp
++ = intel_syntax
? 'd' : 'l';
11377 *obufp
++ = intel_syntax
? 'w' : 's';
11378 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11382 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11385 if (modrm
.mod
== 3)
11391 if (sizeflag
& DFLAG
)
11392 *obufp
++ = intel_syntax
? 'd' : 'l';
11395 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11401 case 'E': /* For jcxz/jecxz */
11402 if (address_mode
== mode_64bit
)
11404 if (sizeflag
& AFLAG
)
11410 if (sizeflag
& AFLAG
)
11412 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11417 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
11419 if (sizeflag
& AFLAG
)
11420 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
11422 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
11423 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
11427 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
11429 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11433 if (!(rex
& REX_W
))
11434 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11439 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
11440 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
11442 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
11445 if (prefixes
& PREFIX_DS
)
11466 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
11471 /* Fall through. */
11474 if (l
!= 0 || len
!= 1)
11482 if (sizeflag
& SUFFIX_ALWAYS
)
11486 if (intel_mnemonic
!= cond
)
11490 if ((prefixes
& PREFIX_FWAIT
) == 0)
11493 used_prefixes
|= PREFIX_FWAIT
;
11499 else if (intel_syntax
&& (sizeflag
& DFLAG
))
11503 if (!(rex
& REX_W
))
11504 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11509 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11514 /* Fall through. */
11518 if ((prefixes
& PREFIX_DATA
)
11520 || (sizeflag
& SUFFIX_ALWAYS
))
11527 if (sizeflag
& DFLAG
)
11531 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11538 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11540 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11544 /* Fall through. */
11547 if (l
== 0 && len
== 1)
11550 if (intel_syntax
&& !alt
)
11553 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
11559 if (sizeflag
& DFLAG
)
11560 *obufp
++ = intel_syntax
? 'd' : 'l';
11563 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11569 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
11575 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11590 else if (sizeflag
& DFLAG
)
11599 if (intel_syntax
&& !p
[1]
11600 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
11602 if (!(rex
& REX_W
))
11603 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11606 if (l
== 0 && len
== 1)
11610 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11612 if (sizeflag
& SUFFIX_ALWAYS
)
11634 /* Fall through. */
11637 if (l
== 0 && len
== 1)
11642 if (sizeflag
& SUFFIX_ALWAYS
)
11648 if (sizeflag
& DFLAG
)
11652 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11666 if (address_mode
== mode_64bit
11667 && !(prefixes
& PREFIX_ADDR
))
11678 if (l
!= 0 || len
!= 1)
11683 if (need_vex
&& vex
.prefix
)
11685 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
11692 if (prefixes
& PREFIX_DATA
)
11696 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11700 if (l
== 0 && len
== 1)
11702 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
11713 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11721 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
11723 switch (vex
.length
)
11737 if (l
== 0 && len
== 1)
11739 /* operand size flag for cwtl, cbtw */
11748 else if (sizeflag
& DFLAG
)
11752 if (!(rex
& REX_W
))
11753 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11757 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
11764 *obufp
++ = vex
.w
? 'd': 's';
11771 mnemonicendp
= obufp
;
11776 oappend (const char *s
)
11778 obufp
= stpcpy (obufp
, s
);
11784 if (prefixes
& PREFIX_CS
)
11786 used_prefixes
|= PREFIX_CS
;
11787 oappend ("%cs:" + intel_syntax
);
11789 if (prefixes
& PREFIX_DS
)
11791 used_prefixes
|= PREFIX_DS
;
11792 oappend ("%ds:" + intel_syntax
);
11794 if (prefixes
& PREFIX_SS
)
11796 used_prefixes
|= PREFIX_SS
;
11797 oappend ("%ss:" + intel_syntax
);
11799 if (prefixes
& PREFIX_ES
)
11801 used_prefixes
|= PREFIX_ES
;
11802 oappend ("%es:" + intel_syntax
);
11804 if (prefixes
& PREFIX_FS
)
11806 used_prefixes
|= PREFIX_FS
;
11807 oappend ("%fs:" + intel_syntax
);
11809 if (prefixes
& PREFIX_GS
)
11811 used_prefixes
|= PREFIX_GS
;
11812 oappend ("%gs:" + intel_syntax
);
11817 OP_indirE (int bytemode
, int sizeflag
)
11821 OP_E (bytemode
, sizeflag
);
11825 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
11827 if (address_mode
== mode_64bit
)
11835 sprintf_vma (tmp
, disp
);
11836 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
11837 strcpy (buf
+ 2, tmp
+ i
);
11841 bfd_signed_vma v
= disp
;
11848 /* Check for possible overflow on 0x8000000000000000. */
11851 strcpy (buf
, "9223372036854775808");
11865 tmp
[28 - i
] = (v
% 10) + '0';
11869 strcpy (buf
, tmp
+ 29 - i
);
11875 sprintf (buf
, "0x%x", (unsigned int) disp
);
11877 sprintf (buf
, "%d", (int) disp
);
11881 /* Put DISP in BUF as signed hex number. */
11884 print_displacement (char *buf
, bfd_vma disp
)
11886 bfd_signed_vma val
= disp
;
11895 /* Check for possible overflow. */
11898 switch (address_mode
)
11901 strcpy (buf
+ j
, "0x8000000000000000");
11904 strcpy (buf
+ j
, "0x80000000");
11907 strcpy (buf
+ j
, "0x8000");
11917 sprintf_vma (tmp
, (bfd_vma
) val
);
11918 for (i
= 0; tmp
[i
] == '0'; i
++)
11920 if (tmp
[i
] == '\0')
11922 strcpy (buf
+ j
, tmp
+ i
);
11926 intel_operand_size (int bytemode
, int sizeflag
)
11933 oappend ("BYTE PTR ");
11937 oappend ("WORD PTR ");
11940 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
11942 oappend ("QWORD PTR ");
11951 oappend ("QWORD PTR ");
11954 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
11955 oappend ("DWORD PTR ");
11957 oappend ("WORD PTR ");
11958 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11962 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
11964 oappend ("WORD PTR ");
11965 if (!(rex
& REX_W
))
11966 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11969 if (sizeflag
& DFLAG
)
11970 oappend ("QWORD PTR ");
11972 oappend ("DWORD PTR ");
11973 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11978 oappend ("DWORD PTR ");
11982 oappend ("QWORD PTR ");
11985 if (address_mode
== mode_64bit
)
11986 oappend ("QWORD PTR ");
11988 oappend ("DWORD PTR ");
11991 if (sizeflag
& DFLAG
)
11992 oappend ("FWORD PTR ");
11994 oappend ("DWORD PTR ");
11995 used_prefixes
|= (prefixes
& PREFIX_DATA
);
11998 oappend ("TBYTE PTR ");
12004 switch (vex
.length
)
12007 oappend ("XMMWORD PTR ");
12010 oappend ("YMMWORD PTR ");
12017 oappend ("XMMWORD PTR ");
12020 oappend ("XMMWORD PTR ");
12026 switch (vex
.length
)
12029 oappend ("QWORD PTR ");
12032 oappend ("XMMWORD PTR ");
12042 switch (vex
.length
)
12045 oappend ("QWORD PTR ");
12048 oappend ("YMMWORD PTR ");
12055 oappend ("OWORD PTR ");
12057 case vex_w_dq_mode
:
12062 oappend ("QWORD PTR ");
12064 oappend ("DWORD PTR ");
12072 OP_E_register (int bytemode
, int sizeflag
)
12074 int reg
= modrm
.rm
;
12075 const char **names
;
12081 if ((sizeflag
& SUFFIX_ALWAYS
)
12082 && (bytemode
== b_swap_mode
|| bytemode
== v_swap_mode
))
12105 names
= address_mode
== mode_64bit
? names64
: names32
;
12108 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12126 if ((sizeflag
& DFLAG
)
12127 || (bytemode
!= v_mode
12128 && bytemode
!= v_swap_mode
))
12132 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12138 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12141 oappend (names
[reg
]);
12145 OP_E_memory (int bytemode
, int sizeflag
)
12148 int add
= (rex
& REX_B
) ? 8 : 0;
12153 intel_operand_size (bytemode
, sizeflag
);
12156 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12158 /* 32/64 bit address mode */
12176 FETCH_DATA (the_info
, codep
+ 1);
12177 vindex
= (*codep
>> 3) & 7;
12178 scale
= (*codep
>> 6) & 3;
12183 haveindex
= vindex
!= 4;
12186 rbase
= base
+ add
;
12194 if (address_mode
== mode_64bit
&& !havesib
)
12200 FETCH_DATA (the_info
, codep
+ 1);
12202 if ((disp
& 0x80) != 0)
12210 /* In 32bit mode, we need index register to tell [offset] from
12211 [eiz*1 + offset]. */
12212 needindex
= (havesib
12215 && address_mode
== mode_32bit
);
12216 havedisp
= (havebase
12218 || (havesib
&& (haveindex
|| scale
!= 0)));
12221 if (modrm
.mod
!= 0 || base
== 5)
12223 if (havedisp
|| riprel
)
12224 print_displacement (scratchbuf
, disp
);
12226 print_operand_value (scratchbuf
, 1, disp
);
12227 oappend (scratchbuf
);
12231 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
12235 if (havebase
|| haveindex
|| riprel
)
12236 used_prefixes
|= PREFIX_ADDR
;
12238 if (havedisp
|| (intel_syntax
&& riprel
))
12240 *obufp
++ = open_char
;
12241 if (intel_syntax
&& riprel
)
12244 oappend (sizeflag
& AFLAG
? "rip" : "eip");
12248 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
12249 ? names64
[rbase
] : names32
[rbase
]);
12252 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12253 print index to tell base + index from base. */
12257 || (havebase
&& base
!= ESP_REG_NUM
))
12259 if (!intel_syntax
|| havebase
)
12261 *obufp
++ = separator_char
;
12265 oappend (address_mode
== mode_64bit
12266 && (sizeflag
& AFLAG
)
12267 ? names64
[vindex
] : names32
[vindex
]);
12269 oappend (address_mode
== mode_64bit
12270 && (sizeflag
& AFLAG
)
12271 ? index64
: index32
);
12273 *obufp
++ = scale_char
;
12275 sprintf (scratchbuf
, "%d", 1 << scale
);
12276 oappend (scratchbuf
);
12280 && (disp
|| modrm
.mod
!= 0 || base
== 5))
12282 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
12287 else if (modrm
.mod
!= 1 && disp
!= -disp
)
12291 disp
= - (bfd_signed_vma
) disp
;
12295 print_displacement (scratchbuf
, disp
);
12297 print_operand_value (scratchbuf
, 1, disp
);
12298 oappend (scratchbuf
);
12301 *obufp
++ = close_char
;
12304 else if (intel_syntax
)
12306 if (modrm
.mod
!= 0 || base
== 5)
12308 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12309 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12313 oappend (names_seg
[ds_reg
- es_reg
]);
12316 print_operand_value (scratchbuf
, 1, disp
);
12317 oappend (scratchbuf
);
12323 /* 16 bit address mode */
12324 used_prefixes
|= prefixes
& PREFIX_ADDR
;
12331 if ((disp
& 0x8000) != 0)
12336 FETCH_DATA (the_info
, codep
+ 1);
12338 if ((disp
& 0x80) != 0)
12343 if ((disp
& 0x8000) != 0)
12349 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
12351 print_displacement (scratchbuf
, disp
);
12352 oappend (scratchbuf
);
12355 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
12357 *obufp
++ = open_char
;
12359 oappend (index16
[modrm
.rm
]);
12361 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
12363 if ((bfd_signed_vma
) disp
>= 0)
12368 else if (modrm
.mod
!= 1)
12372 disp
= - (bfd_signed_vma
) disp
;
12375 print_displacement (scratchbuf
, disp
);
12376 oappend (scratchbuf
);
12379 *obufp
++ = close_char
;
12382 else if (intel_syntax
)
12384 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12385 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
12389 oappend (names_seg
[ds_reg
- es_reg
]);
12392 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
12393 oappend (scratchbuf
);
12399 OP_E (int bytemode
, int sizeflag
)
12401 /* Skip mod/rm byte. */
12405 if (modrm
.mod
== 3)
12406 OP_E_register (bytemode
, sizeflag
);
12408 OP_E_memory (bytemode
, sizeflag
);
12412 OP_G (int bytemode
, int sizeflag
)
12423 oappend (names8rex
[modrm
.reg
+ add
]);
12425 oappend (names8
[modrm
.reg
+ add
]);
12428 oappend (names16
[modrm
.reg
+ add
]);
12431 oappend (names32
[modrm
.reg
+ add
]);
12434 oappend (names64
[modrm
.reg
+ add
]);
12443 oappend (names64
[modrm
.reg
+ add
]);
12446 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
12447 oappend (names32
[modrm
.reg
+ add
]);
12449 oappend (names16
[modrm
.reg
+ add
]);
12450 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12454 if (address_mode
== mode_64bit
)
12455 oappend (names64
[modrm
.reg
+ add
]);
12457 oappend (names32
[modrm
.reg
+ add
]);
12460 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12473 FETCH_DATA (the_info
, codep
+ 8);
12474 a
= *codep
++ & 0xff;
12475 a
|= (*codep
++ & 0xff) << 8;
12476 a
|= (*codep
++ & 0xff) << 16;
12477 a
|= (*codep
++ & 0xff) << 24;
12478 b
= *codep
++ & 0xff;
12479 b
|= (*codep
++ & 0xff) << 8;
12480 b
|= (*codep
++ & 0xff) << 16;
12481 b
|= (*codep
++ & 0xff) << 24;
12482 x
= a
+ ((bfd_vma
) b
<< 32);
12490 static bfd_signed_vma
12493 bfd_signed_vma x
= 0;
12495 FETCH_DATA (the_info
, codep
+ 4);
12496 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12497 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12498 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12499 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12503 static bfd_signed_vma
12506 bfd_signed_vma x
= 0;
12508 FETCH_DATA (the_info
, codep
+ 4);
12509 x
= *codep
++ & (bfd_signed_vma
) 0xff;
12510 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
12511 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
12512 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
12514 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
12524 FETCH_DATA (the_info
, codep
+ 2);
12525 x
= *codep
++ & 0xff;
12526 x
|= (*codep
++ & 0xff) << 8;
12531 set_op (bfd_vma op
, int riprel
)
12533 op_index
[op_ad
] = op_ad
;
12534 if (address_mode
== mode_64bit
)
12536 op_address
[op_ad
] = op
;
12537 op_riprel
[op_ad
] = riprel
;
12541 /* Mask to get a 32-bit address. */
12542 op_address
[op_ad
] = op
& 0xffffffff;
12543 op_riprel
[op_ad
] = riprel
& 0xffffffff;
12548 OP_REG (int code
, int sizeflag
)
12560 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12561 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12562 s
= names16
[code
- ax_reg
+ add
];
12564 case es_reg
: case ss_reg
: case cs_reg
:
12565 case ds_reg
: case fs_reg
: case gs_reg
:
12566 s
= names_seg
[code
- es_reg
+ add
];
12568 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12569 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12572 s
= names8rex
[code
- al_reg
+ add
];
12574 s
= names8
[code
- al_reg
];
12576 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
12577 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
12578 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
12580 s
= names64
[code
- rAX_reg
+ add
];
12583 code
+= eAX_reg
- rAX_reg
;
12584 /* Fall through. */
12585 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12586 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12589 s
= names64
[code
- eAX_reg
+ add
];
12592 if (sizeflag
& DFLAG
)
12593 s
= names32
[code
- eAX_reg
+ add
];
12595 s
= names16
[code
- eAX_reg
+ add
];
12596 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12600 s
= INTERNAL_DISASSEMBLER_ERROR
;
12607 OP_IMREG (int code
, int sizeflag
)
12619 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
12620 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
12621 s
= names16
[code
- ax_reg
];
12623 case es_reg
: case ss_reg
: case cs_reg
:
12624 case ds_reg
: case fs_reg
: case gs_reg
:
12625 s
= names_seg
[code
- es_reg
];
12627 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
12628 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
12631 s
= names8rex
[code
- al_reg
];
12633 s
= names8
[code
- al_reg
];
12635 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
12636 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
12639 s
= names64
[code
- eAX_reg
];
12642 if (sizeflag
& DFLAG
)
12643 s
= names32
[code
- eAX_reg
];
12645 s
= names16
[code
- eAX_reg
];
12646 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12649 case z_mode_ax_reg
:
12650 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
12654 if (!(rex
& REX_W
))
12655 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12658 s
= INTERNAL_DISASSEMBLER_ERROR
;
12665 OP_I (int bytemode
, int sizeflag
)
12668 bfd_signed_vma mask
= -1;
12673 FETCH_DATA (the_info
, codep
+ 1);
12678 if (address_mode
== mode_64bit
)
12683 /* Fall through. */
12690 if (sizeflag
& DFLAG
)
12700 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12712 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12717 scratchbuf
[0] = '$';
12718 print_operand_value (scratchbuf
+ 1, 1, op
);
12719 oappend (scratchbuf
+ intel_syntax
);
12720 scratchbuf
[0] = '\0';
12724 OP_I64 (int bytemode
, int sizeflag
)
12727 bfd_signed_vma mask
= -1;
12729 if (address_mode
!= mode_64bit
)
12731 OP_I (bytemode
, sizeflag
);
12738 FETCH_DATA (the_info
, codep
+ 1);
12748 if (sizeflag
& DFLAG
)
12758 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12766 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12771 scratchbuf
[0] = '$';
12772 print_operand_value (scratchbuf
+ 1, 1, op
);
12773 oappend (scratchbuf
+ intel_syntax
);
12774 scratchbuf
[0] = '\0';
12778 OP_sI (int bytemode
, int sizeflag
)
12781 bfd_signed_vma mask
= -1;
12786 FETCH_DATA (the_info
, codep
+ 1);
12788 if ((op
& 0x80) != 0)
12798 if (sizeflag
& DFLAG
)
12807 if ((op
& 0x8000) != 0)
12810 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12816 if ((op
& 0x8000) != 0)
12820 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12824 scratchbuf
[0] = '$';
12825 print_operand_value (scratchbuf
+ 1, 1, op
);
12826 oappend (scratchbuf
+ intel_syntax
);
12830 OP_J (int bytemode
, int sizeflag
)
12834 bfd_vma segment
= 0;
12839 FETCH_DATA (the_info
, codep
+ 1);
12841 if ((disp
& 0x80) != 0)
12846 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
12851 if ((disp
& 0x8000) != 0)
12853 /* In 16bit mode, address is wrapped around at 64k within
12854 the same segment. Otherwise, a data16 prefix on a jump
12855 instruction means that the pc is masked to 16 bits after
12856 the displacement is added! */
12858 if ((prefixes
& PREFIX_DATA
) == 0)
12859 segment
= ((start_pc
+ codep
- start_codep
)
12860 & ~((bfd_vma
) 0xffff));
12862 if (!(rex
& REX_W
))
12863 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12866 oappend (INTERNAL_DISASSEMBLER_ERROR
);
12869 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
12871 print_operand_value (scratchbuf
, 1, disp
);
12872 oappend (scratchbuf
);
12876 OP_SEG (int bytemode
, int sizeflag
)
12878 if (bytemode
== w_mode
)
12879 oappend (names_seg
[modrm
.reg
]);
12881 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
12885 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
12889 if (sizeflag
& DFLAG
)
12899 used_prefixes
|= (prefixes
& PREFIX_DATA
);
12901 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
12903 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
12904 oappend (scratchbuf
);
12908 OP_OFF (int bytemode
, int sizeflag
)
12912 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12913 intel_operand_size (bytemode
, sizeflag
);
12916 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12923 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12924 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12926 oappend (names_seg
[ds_reg
- es_reg
]);
12930 print_operand_value (scratchbuf
, 1, off
);
12931 oappend (scratchbuf
);
12935 OP_OFF64 (int bytemode
, int sizeflag
)
12939 if (address_mode
!= mode_64bit
12940 || (prefixes
& PREFIX_ADDR
))
12942 OP_OFF (bytemode
, sizeflag
);
12946 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
12947 intel_operand_size (bytemode
, sizeflag
);
12954 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
12955 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
12957 oappend (names_seg
[ds_reg
- es_reg
]);
12961 print_operand_value (scratchbuf
, 1, off
);
12962 oappend (scratchbuf
);
12966 ptr_reg (int code
, int sizeflag
)
12970 *obufp
++ = open_char
;
12971 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
12972 if (address_mode
== mode_64bit
)
12974 if (!(sizeflag
& AFLAG
))
12975 s
= names32
[code
- eAX_reg
];
12977 s
= names64
[code
- eAX_reg
];
12979 else if (sizeflag
& AFLAG
)
12980 s
= names32
[code
- eAX_reg
];
12982 s
= names16
[code
- eAX_reg
];
12984 *obufp
++ = close_char
;
12989 OP_ESreg (int code
, int sizeflag
)
12995 case 0x6d: /* insw/insl */
12996 intel_operand_size (z_mode
, sizeflag
);
12998 case 0xa5: /* movsw/movsl/movsq */
12999 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13000 case 0xab: /* stosw/stosl */
13001 case 0xaf: /* scasw/scasl */
13002 intel_operand_size (v_mode
, sizeflag
);
13005 intel_operand_size (b_mode
, sizeflag
);
13008 oappend ("%es:" + intel_syntax
);
13009 ptr_reg (code
, sizeflag
);
13013 OP_DSreg (int code
, int sizeflag
)
13019 case 0x6f: /* outsw/outsl */
13020 intel_operand_size (z_mode
, sizeflag
);
13022 case 0xa5: /* movsw/movsl/movsq */
13023 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13024 case 0xad: /* lodsw/lodsl/lodsq */
13025 intel_operand_size (v_mode
, sizeflag
);
13028 intel_operand_size (b_mode
, sizeflag
);
13037 | PREFIX_GS
)) == 0)
13038 prefixes
|= PREFIX_DS
;
13040 ptr_reg (code
, sizeflag
);
13044 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13052 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
13054 all_prefixes
[last_lock_prefix
] = 0;
13055 used_prefixes
|= PREFIX_LOCK
;
13060 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
13061 oappend (scratchbuf
+ intel_syntax
);
13065 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13074 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
13076 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
13077 oappend (scratchbuf
);
13081 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13083 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
13084 oappend (scratchbuf
+ intel_syntax
);
13088 OP_R (int bytemode
, int sizeflag
)
13090 if (modrm
.mod
== 3)
13091 OP_E (bytemode
, sizeflag
);
13097 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13099 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13100 if (prefixes
& PREFIX_DATA
)
13108 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13111 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13112 oappend (scratchbuf
+ intel_syntax
);
13116 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13124 if (need_vex
&& bytemode
!= xmm_mode
)
13126 switch (vex
.length
)
13129 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13132 sprintf (scratchbuf
, "%%ymm%d", modrm
.reg
+ add
);
13139 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
13140 oappend (scratchbuf
+ intel_syntax
);
13144 OP_EM (int bytemode
, int sizeflag
)
13146 if (modrm
.mod
!= 3)
13149 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13151 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13152 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13154 OP_E (bytemode
, sizeflag
);
13158 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
13161 /* Skip mod/rm byte. */
13164 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13165 if (prefixes
& PREFIX_DATA
)
13174 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13177 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13178 oappend (scratchbuf
+ intel_syntax
);
13181 /* cvt* are the only instructions in sse2 which have
13182 both SSE and MMX operands and also have 0x66 prefix
13183 in their opcode. 0x66 was originally used to differentiate
13184 between SSE and MMX instruction(operands). So we have to handle the
13185 cvt* separately using OP_EMC and OP_MXC */
13187 OP_EMC (int bytemode
, int sizeflag
)
13189 if (modrm
.mod
!= 3)
13191 if (intel_syntax
&& bytemode
== v_mode
)
13193 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13194 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13196 OP_E (bytemode
, sizeflag
);
13200 /* Skip mod/rm byte. */
13203 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13204 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
13205 oappend (scratchbuf
+ intel_syntax
);
13209 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13211 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13212 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
13213 oappend (scratchbuf
+ intel_syntax
);
13217 OP_EX (int bytemode
, int sizeflag
)
13221 /* Skip mod/rm byte. */
13225 if (modrm
.mod
!= 3)
13227 OP_E_memory (bytemode
, sizeflag
);
13237 if ((sizeflag
& SUFFIX_ALWAYS
)
13238 && (bytemode
== x_swap_mode
13239 || bytemode
== d_swap_mode
13240 || bytemode
== q_swap_mode
))
13244 && bytemode
!= xmm_mode
13245 && bytemode
!= xmmq_mode
)
13247 switch (vex
.length
)
13250 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13253 sprintf (scratchbuf
, "%%ymm%d", modrm
.rm
+ add
);
13260 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
13261 oappend (scratchbuf
+ intel_syntax
);
13265 OP_MS (int bytemode
, int sizeflag
)
13267 if (modrm
.mod
== 3)
13268 OP_EM (bytemode
, sizeflag
);
13274 OP_XS (int bytemode
, int sizeflag
)
13276 if (modrm
.mod
== 3)
13277 OP_EX (bytemode
, sizeflag
);
13283 OP_M (int bytemode
, int sizeflag
)
13285 if (modrm
.mod
== 3)
13286 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
13289 OP_E (bytemode
, sizeflag
);
13293 OP_0f07 (int bytemode
, int sizeflag
)
13295 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
13298 OP_E (bytemode
, sizeflag
);
13301 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
13302 32bit mode and "xchg %rax,%rax" in 64bit mode. */
13305 NOP_Fixup1 (int bytemode
, int sizeflag
)
13307 if ((prefixes
& PREFIX_DATA
) != 0
13310 && address_mode
== mode_64bit
))
13311 OP_REG (bytemode
, sizeflag
);
13313 strcpy (obuf
, "nop");
13317 NOP_Fixup2 (int bytemode
, int sizeflag
)
13319 if ((prefixes
& PREFIX_DATA
) != 0
13322 && address_mode
== mode_64bit
))
13323 OP_IMREG (bytemode
, sizeflag
);
13326 static const char *const Suffix3DNow
[] = {
13327 /* 00 */ NULL
, NULL
, NULL
, NULL
,
13328 /* 04 */ NULL
, NULL
, NULL
, NULL
,
13329 /* 08 */ NULL
, NULL
, NULL
, NULL
,
13330 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
13331 /* 10 */ NULL
, NULL
, NULL
, NULL
,
13332 /* 14 */ NULL
, NULL
, NULL
, NULL
,
13333 /* 18 */ NULL
, NULL
, NULL
, NULL
,
13334 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
13335 /* 20 */ NULL
, NULL
, NULL
, NULL
,
13336 /* 24 */ NULL
, NULL
, NULL
, NULL
,
13337 /* 28 */ NULL
, NULL
, NULL
, NULL
,
13338 /* 2C */ NULL
, NULL
, NULL
, NULL
,
13339 /* 30 */ NULL
, NULL
, NULL
, NULL
,
13340 /* 34 */ NULL
, NULL
, NULL
, NULL
,
13341 /* 38 */ NULL
, NULL
, NULL
, NULL
,
13342 /* 3C */ NULL
, NULL
, NULL
, NULL
,
13343 /* 40 */ NULL
, NULL
, NULL
, NULL
,
13344 /* 44 */ NULL
, NULL
, NULL
, NULL
,
13345 /* 48 */ NULL
, NULL
, NULL
, NULL
,
13346 /* 4C */ NULL
, NULL
, NULL
, NULL
,
13347 /* 50 */ NULL
, NULL
, NULL
, NULL
,
13348 /* 54 */ NULL
, NULL
, NULL
, NULL
,
13349 /* 58 */ NULL
, NULL
, NULL
, NULL
,
13350 /* 5C */ NULL
, NULL
, NULL
, NULL
,
13351 /* 60 */ NULL
, NULL
, NULL
, NULL
,
13352 /* 64 */ NULL
, NULL
, NULL
, NULL
,
13353 /* 68 */ NULL
, NULL
, NULL
, NULL
,
13354 /* 6C */ NULL
, NULL
, NULL
, NULL
,
13355 /* 70 */ NULL
, NULL
, NULL
, NULL
,
13356 /* 74 */ NULL
, NULL
, NULL
, NULL
,
13357 /* 78 */ NULL
, NULL
, NULL
, NULL
,
13358 /* 7C */ NULL
, NULL
, NULL
, NULL
,
13359 /* 80 */ NULL
, NULL
, NULL
, NULL
,
13360 /* 84 */ NULL
, NULL
, NULL
, NULL
,
13361 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
13362 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
13363 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
13364 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
13365 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
13366 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
13367 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
13368 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
13369 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
13370 /* AC */ NULL
, NULL
, "pfacc", NULL
,
13371 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
13372 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
13373 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
13374 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
13375 /* C0 */ NULL
, NULL
, NULL
, NULL
,
13376 /* C4 */ NULL
, NULL
, NULL
, NULL
,
13377 /* C8 */ NULL
, NULL
, NULL
, NULL
,
13378 /* CC */ NULL
, NULL
, NULL
, NULL
,
13379 /* D0 */ NULL
, NULL
, NULL
, NULL
,
13380 /* D4 */ NULL
, NULL
, NULL
, NULL
,
13381 /* D8 */ NULL
, NULL
, NULL
, NULL
,
13382 /* DC */ NULL
, NULL
, NULL
, NULL
,
13383 /* E0 */ NULL
, NULL
, NULL
, NULL
,
13384 /* E4 */ NULL
, NULL
, NULL
, NULL
,
13385 /* E8 */ NULL
, NULL
, NULL
, NULL
,
13386 /* EC */ NULL
, NULL
, NULL
, NULL
,
13387 /* F0 */ NULL
, NULL
, NULL
, NULL
,
13388 /* F4 */ NULL
, NULL
, NULL
, NULL
,
13389 /* F8 */ NULL
, NULL
, NULL
, NULL
,
13390 /* FC */ NULL
, NULL
, NULL
, NULL
,
13394 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13396 const char *mnemonic
;
13398 FETCH_DATA (the_info
, codep
+ 1);
13399 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13400 place where an 8-bit immediate would normally go. ie. the last
13401 byte of the instruction. */
13402 obufp
= mnemonicendp
;
13403 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
13405 oappend (mnemonic
);
13408 /* Since a variable sized modrm/sib chunk is between the start
13409 of the opcode (0x0f0f) and the opcode suffix, we need to do
13410 all the modrm processing first, and don't know until now that
13411 we have a bad opcode. This necessitates some cleaning up. */
13412 op_out
[0][0] = '\0';
13413 op_out
[1][0] = '\0';
13416 mnemonicendp
= obufp
;
13419 static struct op simd_cmp_op
[] =
13421 { STRING_COMMA_LEN ("eq") },
13422 { STRING_COMMA_LEN ("lt") },
13423 { STRING_COMMA_LEN ("le") },
13424 { STRING_COMMA_LEN ("unord") },
13425 { STRING_COMMA_LEN ("neq") },
13426 { STRING_COMMA_LEN ("nlt") },
13427 { STRING_COMMA_LEN ("nle") },
13428 { STRING_COMMA_LEN ("ord") }
13432 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13434 unsigned int cmp_type
;
13436 FETCH_DATA (the_info
, codep
+ 1);
13437 cmp_type
= *codep
++ & 0xff;
13438 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
13441 char *p
= mnemonicendp
- 2;
13445 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
13446 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
13450 /* We have a reserved extension byte. Output it directly. */
13451 scratchbuf
[0] = '$';
13452 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
13453 oappend (scratchbuf
+ intel_syntax
);
13454 scratchbuf
[0] = '\0';
13459 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
13460 int sizeflag ATTRIBUTE_UNUSED
)
13462 /* mwait %eax,%ecx */
13465 const char **names
= (address_mode
== mode_64bit
13466 ? names64
: names32
);
13467 strcpy (op_out
[0], names
[0]);
13468 strcpy (op_out
[1], names
[1]);
13469 two_source_ops
= 1;
13471 /* Skip mod/rm byte. */
13477 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
13478 int sizeflag ATTRIBUTE_UNUSED
)
13480 /* monitor %eax,%ecx,%edx" */
13483 const char **op1_names
;
13484 const char **names
= (address_mode
== mode_64bit
13485 ? names64
: names32
);
13487 if (!(prefixes
& PREFIX_ADDR
))
13488 op1_names
= (address_mode
== mode_16bit
13489 ? names16
: names
);
13492 /* Remove "addr16/addr32". */
13493 all_prefixes
[last_addr_prefix
] = 0;
13494 op1_names
= (address_mode
!= mode_32bit
13495 ? names32
: names16
);
13496 used_prefixes
|= PREFIX_ADDR
;
13498 strcpy (op_out
[0], op1_names
[0]);
13499 strcpy (op_out
[1], names
[1]);
13500 strcpy (op_out
[2], names
[2]);
13501 two_source_ops
= 1;
13503 /* Skip mod/rm byte. */
13511 /* Throw away prefixes and 1st. opcode byte. */
13512 codep
= insn_codep
+ 1;
13517 REP_Fixup (int bytemode
, int sizeflag
)
13519 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13521 if (prefixes
& PREFIX_REPZ
)
13522 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
13529 OP_IMREG (bytemode
, sizeflag
);
13532 OP_ESreg (bytemode
, sizeflag
);
13535 OP_DSreg (bytemode
, sizeflag
);
13544 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
13549 /* Change cmpxchg8b to cmpxchg16b. */
13550 char *p
= mnemonicendp
- 2;
13551 mnemonicendp
= stpcpy (p
, "16b");
13554 OP_M (bytemode
, sizeflag
);
13558 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
13562 switch (vex
.length
)
13565 sprintf (scratchbuf
, "%%xmm%d", reg
);
13568 sprintf (scratchbuf
, "%%ymm%d", reg
);
13575 sprintf (scratchbuf
, "%%xmm%d", reg
);
13576 oappend (scratchbuf
+ intel_syntax
);
13580 CRC32_Fixup (int bytemode
, int sizeflag
)
13582 /* Add proper suffix to "crc32". */
13583 char *p
= mnemonicendp
;
13602 if (sizeflag
& DFLAG
)
13606 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13610 oappend (INTERNAL_DISASSEMBLER_ERROR
);
13617 if (modrm
.mod
== 3)
13621 /* Skip mod/rm byte. */
13626 add
= (rex
& REX_B
) ? 8 : 0;
13627 if (bytemode
== b_mode
)
13631 oappend (names8rex
[modrm
.rm
+ add
]);
13633 oappend (names8
[modrm
.rm
+ add
]);
13639 oappend (names64
[modrm
.rm
+ add
]);
13640 else if ((prefixes
& PREFIX_DATA
))
13641 oappend (names16
[modrm
.rm
+ add
]);
13643 oappend (names32
[modrm
.rm
+ add
]);
13647 OP_E (bytemode
, sizeflag
);
13651 FXSAVE_Fixup (int bytemode
, int sizeflag
)
13653 /* Add proper suffix to "fxsave" and "fxrstor". */
13657 char *p
= mnemonicendp
;
13663 OP_M (bytemode
, sizeflag
);
13666 /* Display the destination register operand for instructions with
13670 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13678 switch (vex
.length
)
13691 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13704 sprintf (scratchbuf
, "%%ymm%d", vex
.register_specifier
);
13710 oappend (scratchbuf
+ intel_syntax
);
13713 /* Get the VEX immediate byte without moving codep. */
13715 static unsigned char
13716 get_vex_imm8 (int sizeflag
, int opnum
)
13718 int bytes_before_imm
= 0;
13720 if (modrm
.mod
!= 3)
13722 /* There are SIB/displacement bytes. */
13723 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
13725 /* 32/64 bit address mode */
13726 int base
= modrm
.rm
;
13728 /* Check SIB byte. */
13731 FETCH_DATA (the_info
, codep
+ 1);
13733 /* When decoding the third source, don't increase
13734 bytes_before_imm as this has already been incremented
13735 by one in OP_E_memory while decoding the second
13738 bytes_before_imm
++;
13741 /* Don't increase bytes_before_imm when decoding the third source,
13742 it has already been incremented by OP_E_memory while decoding
13743 the second source operand. */
13749 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13750 SIB == 5, there is a 4 byte displacement. */
13752 /* No displacement. */
13755 /* 4 byte displacement. */
13756 bytes_before_imm
+= 4;
13759 /* 1 byte displacement. */
13760 bytes_before_imm
++;
13767 /* 16 bit address mode */
13768 /* Don't increase bytes_before_imm when decoding the third source,
13769 it has already been incremented by OP_E_memory while decoding
13770 the second source operand. */
13776 /* When modrm.rm == 6, there is a 2 byte displacement. */
13778 /* No displacement. */
13781 /* 2 byte displacement. */
13782 bytes_before_imm
+= 2;
13785 /* 1 byte displacement: when decoding the third source,
13786 don't increase bytes_before_imm as this has already
13787 been incremented by one in OP_E_memory while decoding
13788 the second source operand. */
13790 bytes_before_imm
++;
13798 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
13799 return codep
[bytes_before_imm
];
13803 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
13805 if (reg
== -1 && modrm
.mod
!= 3)
13807 OP_E_memory (bytemode
, sizeflag
);
13819 else if (reg
> 7 && address_mode
!= mode_64bit
)
13823 switch (vex
.length
)
13826 sprintf (scratchbuf
, "%%xmm%d", reg
);
13829 sprintf (scratchbuf
, "%%ymm%d", reg
);
13834 oappend (scratchbuf
+ intel_syntax
);
13838 OP_Vex_2src (int bytemode
, int sizeflag
)
13840 if (modrm
.mod
== 3)
13843 sprintf (scratchbuf
, "%%xmm%d", rex
& REX_B
? modrm
.rm
+ 8 : modrm
.rm
);
13844 oappend (scratchbuf
+ intel_syntax
);
13849 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
13851 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
13852 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13854 OP_E (bytemode
, sizeflag
);
13859 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
13861 if (modrm
.mod
== 3)
13863 /* Skip mod/rm byte. */
13870 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13871 oappend (scratchbuf
+ intel_syntax
);
13874 OP_Vex_2src (bytemode
, sizeflag
);
13878 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
13881 OP_Vex_2src (bytemode
, sizeflag
);
13884 sprintf (scratchbuf
, "%%xmm%d", vex
.register_specifier
);
13885 oappend (scratchbuf
+ intel_syntax
);
13890 OP_EX_VexW (int bytemode
, int sizeflag
)
13898 /* Skip mod/rm byte. */
13903 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
13908 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
13911 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
13915 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
13916 int sizeflag ATTRIBUTE_UNUSED
)
13918 /* Skip the immediate byte and check for invalid bits. */
13919 FETCH_DATA (the_info
, codep
+ 1);
13920 if (*codep
++ & 0xf)
13925 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
13928 FETCH_DATA (the_info
, codep
+ 1);
13931 if (bytemode
!= x_mode
)
13938 if (reg
> 7 && address_mode
!= mode_64bit
)
13941 switch (vex
.length
)
13944 sprintf (scratchbuf
, "%%xmm%d", reg
);
13947 sprintf (scratchbuf
, "%%ymm%d", reg
);
13952 oappend (scratchbuf
+ intel_syntax
);
13956 OP_XMM_VexW (int bytemode
, int sizeflag
)
13958 /* Turn off the REX.W bit since it is used for swapping operands
13961 OP_XMM (bytemode
, sizeflag
);
13965 OP_EX_Vex (int bytemode
, int sizeflag
)
13967 if (modrm
.mod
!= 3)
13969 if (vex
.register_specifier
!= 0)
13973 OP_EX (bytemode
, sizeflag
);
13977 OP_XMM_Vex (int bytemode
, int sizeflag
)
13979 if (modrm
.mod
!= 3)
13981 if (vex
.register_specifier
!= 0)
13985 OP_XMM (bytemode
, sizeflag
);
13989 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13991 switch (vex
.length
)
13994 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
13997 mnemonicendp
= stpcpy (obuf
, "vzeroall");
14004 static struct op vex_cmp_op
[] =
14006 { STRING_COMMA_LEN ("eq") },
14007 { STRING_COMMA_LEN ("lt") },
14008 { STRING_COMMA_LEN ("le") },
14009 { STRING_COMMA_LEN ("unord") },
14010 { STRING_COMMA_LEN ("neq") },
14011 { STRING_COMMA_LEN ("nlt") },
14012 { STRING_COMMA_LEN ("nle") },
14013 { STRING_COMMA_LEN ("ord") },
14014 { STRING_COMMA_LEN ("eq_uq") },
14015 { STRING_COMMA_LEN ("nge") },
14016 { STRING_COMMA_LEN ("ngt") },
14017 { STRING_COMMA_LEN ("false") },
14018 { STRING_COMMA_LEN ("neq_oq") },
14019 { STRING_COMMA_LEN ("ge") },
14020 { STRING_COMMA_LEN ("gt") },
14021 { STRING_COMMA_LEN ("true") },
14022 { STRING_COMMA_LEN ("eq_os") },
14023 { STRING_COMMA_LEN ("lt_oq") },
14024 { STRING_COMMA_LEN ("le_oq") },
14025 { STRING_COMMA_LEN ("unord_s") },
14026 { STRING_COMMA_LEN ("neq_us") },
14027 { STRING_COMMA_LEN ("nlt_uq") },
14028 { STRING_COMMA_LEN ("nle_uq") },
14029 { STRING_COMMA_LEN ("ord_s") },
14030 { STRING_COMMA_LEN ("eq_us") },
14031 { STRING_COMMA_LEN ("nge_uq") },
14032 { STRING_COMMA_LEN ("ngt_uq") },
14033 { STRING_COMMA_LEN ("false_os") },
14034 { STRING_COMMA_LEN ("neq_os") },
14035 { STRING_COMMA_LEN ("ge_oq") },
14036 { STRING_COMMA_LEN ("gt_oq") },
14037 { STRING_COMMA_LEN ("true_us") },
14041 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14043 unsigned int cmp_type
;
14045 FETCH_DATA (the_info
, codep
+ 1);
14046 cmp_type
= *codep
++ & 0xff;
14047 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
14050 char *p
= mnemonicendp
- 2;
14054 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
14055 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
14059 /* We have a reserved extension byte. Output it directly. */
14060 scratchbuf
[0] = '$';
14061 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
14062 oappend (scratchbuf
+ intel_syntax
);
14063 scratchbuf
[0] = '\0';
14067 static const struct op pclmul_op
[] =
14069 { STRING_COMMA_LEN ("lql") },
14070 { STRING_COMMA_LEN ("hql") },
14071 { STRING_COMMA_LEN ("lqh") },
14072 { STRING_COMMA_LEN ("hqh") }
14076 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
14077 int sizeflag ATTRIBUTE_UNUSED
)
14079 unsigned int pclmul_type
;
14081 FETCH_DATA (the_info
, codep
+ 1);
14082 pclmul_type
= *codep
++ & 0xff;
14083 switch (pclmul_type
)
14094 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
14097 char *p
= mnemonicendp
- 3;
14102 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
14103 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
14107 /* We have a reserved extension byte. Output it directly. */
14108 scratchbuf
[0] = '$';
14109 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
14110 oappend (scratchbuf
+ intel_syntax
);
14111 scratchbuf
[0] = '\0';
14116 MOVBE_Fixup (int bytemode
, int sizeflag
)
14118 /* Add proper suffix to "movbe". */
14119 char *p
= mnemonicendp
;
14128 if (sizeflag
& SUFFIX_ALWAYS
)
14134 if (sizeflag
& DFLAG
)
14138 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14143 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14150 OP_M (bytemode
, sizeflag
);
14154 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14157 const char **names
;
14159 /* Skip mod/rm byte. */
14165 else if (vex
.length
== 256)
14175 oappend (names
[reg
]);
14179 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
14181 const char **names
;
14185 else if (vex
.length
== 256)
14190 oappend (names
[vex
.register_specifier
]);
14194 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED
, int sizeflag
)
14196 if (vex
.w
|| vex
.length
== 256)
14197 OP_I (q_mode
, sizeflag
);
14199 OP_I (w_mode
, sizeflag
);