1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of the GNU opcodes library.
8 This library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 It is distributed in the hope that it will be useful, but WITHOUT
14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
16 License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
24 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
26 modified by John Hassey (hassey@dg-rtp.dg.com)
27 x86-64 support added by Jan Hubicka (jh@suse.cz)
28 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma, disassemble_info *);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma get64 (void);
60 static bfd_signed_vma get32 (void);
61 static bfd_signed_vma get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void OP_LWPCB_E (int, int);
114 static void OP_LWP_E (int, int);
115 static void OP_LWP_I (int, int);
116 static void OP_Vex_2src_1 (int, int);
117 static void OP_Vex_2src_2 (int, int);
119 static void MOVBE_Fixup (int, int);
122 /* Points to first byte not fetched. */
123 bfd_byte *max_fetched;
124 bfd_byte the_buffer[MAX_MNEM_SIZE];
137 enum address_mode address_mode;
139 /* Flags for the prefixes for the current instruction. See below. */
142 /* REX prefix the current instruction. See below. */
144 /* Bits of REX we've already used. */
146 /* Original REX prefix. */
147 static int rex_original;
148 /* REX bits in original REX prefix ignored. It may not be the same
149 as rex_original since some bits may not be ignored. */
150 static int rex_ignored;
151 /* Mark parts used in the REX prefix. When we are testing for
152 empty prefix (for 8bit register REX extension), just mask it
153 out. Otherwise test for REX bit is excuse for existence of REX
154 only in case value is nonzero. */
155 #define USED_REX(value) \
160 rex_used |= (value) | REX_OPCODE; \
163 rex_used |= REX_OPCODE; \
166 /* Flags for prefixes which we somehow handled when printing the
167 current instruction. */
168 static int used_prefixes;
170 /* Flags stored in PREFIXES. */
171 #define PREFIX_REPZ 1
172 #define PREFIX_REPNZ 2
173 #define PREFIX_LOCK 4
175 #define PREFIX_SS 0x10
176 #define PREFIX_DS 0x20
177 #define PREFIX_ES 0x40
178 #define PREFIX_FS 0x80
179 #define PREFIX_GS 0x100
180 #define PREFIX_DATA 0x200
181 #define PREFIX_ADDR 0x400
182 #define PREFIX_FWAIT 0x800
184 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
185 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
187 #define FETCH_DATA(info, addr) \
188 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
189 ? 1 : fetch_data ((info), (addr)))
192 fetch_data (struct disassemble_info *info, bfd_byte *addr)
195 struct dis_private *priv = (struct dis_private *) info->private_data;
196 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
198 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
199 status = (*info->read_memory_func) (start,
201 addr - priv->max_fetched,
207 /* If we did manage to read at least one byte, then
208 print_insn_i386 will do something sensible. Otherwise, print
209 an error. We do that here because this is where we know
211 if (priv->max_fetched == priv->the_buffer)
212 (*info->memory_error_func) (status, start, info);
213 longjmp (priv->bailout, 1);
216 priv->max_fetched = addr;
220 #define XX { NULL, 0 }
222 #define Eb { OP_E, b_mode }
223 #define EbS { OP_E, b_swap_mode }
224 #define Ev { OP_E, v_mode }
225 #define EvS { OP_E, v_swap_mode }
226 #define Ed { OP_E, d_mode }
227 #define Edq { OP_E, dq_mode }
228 #define Edqw { OP_E, dqw_mode }
229 #define Edqb { OP_E, dqb_mode }
230 #define Edqd { OP_E, dqd_mode }
231 #define Eq { OP_E, q_mode }
232 #define indirEv { OP_indirE, stack_v_mode }
233 #define indirEp { OP_indirE, f_mode }
234 #define stackEv { OP_E, stack_v_mode }
235 #define Em { OP_E, m_mode }
236 #define Ew { OP_E, w_mode }
237 #define M { OP_M, 0 } /* lea, lgdt, etc. */
238 #define Ma { OP_M, a_mode }
239 #define Mb { OP_M, b_mode }
240 #define Md { OP_M, d_mode }
241 #define Mo { OP_M, o_mode }
242 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
243 #define Mq { OP_M, q_mode }
244 #define Mx { OP_M, x_mode }
245 #define Mxmm { OP_M, xmm_mode }
246 #define Gb { OP_G, b_mode }
247 #define Gv { OP_G, v_mode }
248 #define Gd { OP_G, d_mode }
249 #define Gdq { OP_G, dq_mode }
250 #define Gm { OP_G, m_mode }
251 #define Gw { OP_G, w_mode }
252 #define Rd { OP_R, d_mode }
253 #define Rm { OP_R, m_mode }
254 #define Ib { OP_I, b_mode }
255 #define sIb { OP_sI, b_mode } /* sign extened byte */
256 #define Iv { OP_I, v_mode }
257 #define Iq { OP_I, q_mode }
258 #define Iv64 { OP_I64, v_mode }
259 #define Iw { OP_I, w_mode }
260 #define I1 { OP_I, const_1_mode }
261 #define Jb { OP_J, b_mode }
262 #define Jv { OP_J, v_mode }
263 #define Cm { OP_C, m_mode }
264 #define Dm { OP_D, m_mode }
265 #define Td { OP_T, d_mode }
266 #define Skip_MODRM { OP_Skip_MODRM, 0 }
268 #define RMeAX { OP_REG, eAX_reg }
269 #define RMeBX { OP_REG, eBX_reg }
270 #define RMeCX { OP_REG, eCX_reg }
271 #define RMeDX { OP_REG, eDX_reg }
272 #define RMeSP { OP_REG, eSP_reg }
273 #define RMeBP { OP_REG, eBP_reg }
274 #define RMeSI { OP_REG, eSI_reg }
275 #define RMeDI { OP_REG, eDI_reg }
276 #define RMrAX { OP_REG, rAX_reg }
277 #define RMrBX { OP_REG, rBX_reg }
278 #define RMrCX { OP_REG, rCX_reg }
279 #define RMrDX { OP_REG, rDX_reg }
280 #define RMrSP { OP_REG, rSP_reg }
281 #define RMrBP { OP_REG, rBP_reg }
282 #define RMrSI { OP_REG, rSI_reg }
283 #define RMrDI { OP_REG, rDI_reg }
284 #define RMAL { OP_REG, al_reg }
285 #define RMAL { OP_REG, al_reg }
286 #define RMCL { OP_REG, cl_reg }
287 #define RMDL { OP_REG, dl_reg }
288 #define RMBL { OP_REG, bl_reg }
289 #define RMAH { OP_REG, ah_reg }
290 #define RMCH { OP_REG, ch_reg }
291 #define RMDH { OP_REG, dh_reg }
292 #define RMBH { OP_REG, bh_reg }
293 #define RMAX { OP_REG, ax_reg }
294 #define RMDX { OP_REG, dx_reg }
296 #define eAX { OP_IMREG, eAX_reg }
297 #define eBX { OP_IMREG, eBX_reg }
298 #define eCX { OP_IMREG, eCX_reg }
299 #define eDX { OP_IMREG, eDX_reg }
300 #define eSP { OP_IMREG, eSP_reg }
301 #define eBP { OP_IMREG, eBP_reg }
302 #define eSI { OP_IMREG, eSI_reg }
303 #define eDI { OP_IMREG, eDI_reg }
304 #define AL { OP_IMREG, al_reg }
305 #define CL { OP_IMREG, cl_reg }
306 #define DL { OP_IMREG, dl_reg }
307 #define BL { OP_IMREG, bl_reg }
308 #define AH { OP_IMREG, ah_reg }
309 #define CH { OP_IMREG, ch_reg }
310 #define DH { OP_IMREG, dh_reg }
311 #define BH { OP_IMREG, bh_reg }
312 #define AX { OP_IMREG, ax_reg }
313 #define DX { OP_IMREG, dx_reg }
314 #define zAX { OP_IMREG, z_mode_ax_reg }
315 #define indirDX { OP_IMREG, indir_dx_reg }
317 #define Sw { OP_SEG, w_mode }
318 #define Sv { OP_SEG, v_mode }
319 #define Ap { OP_DIR, 0 }
320 #define Ob { OP_OFF64, b_mode }
321 #define Ov { OP_OFF64, v_mode }
322 #define Xb { OP_DSreg, eSI_reg }
323 #define Xv { OP_DSreg, eSI_reg }
324 #define Xz { OP_DSreg, eSI_reg }
325 #define Yb { OP_ESreg, eDI_reg }
326 #define Yv { OP_ESreg, eDI_reg }
327 #define DSBX { OP_DSreg, eBX_reg }
329 #define es { OP_REG, es_reg }
330 #define ss { OP_REG, ss_reg }
331 #define cs { OP_REG, cs_reg }
332 #define ds { OP_REG, ds_reg }
333 #define fs { OP_REG, fs_reg }
334 #define gs { OP_REG, gs_reg }
336 #define MX { OP_MMX, 0 }
337 #define XM { OP_XMM, 0 }
338 #define XMM { OP_XMM, xmm_mode }
339 #define EM { OP_EM, v_mode }
340 #define EMS { OP_EM, v_swap_mode }
341 #define EMd { OP_EM, d_mode }
342 #define EMx { OP_EM, x_mode }
343 #define EXw { OP_EX, w_mode }
344 #define EXd { OP_EX, d_mode }
345 #define EXdS { OP_EX, d_swap_mode }
346 #define EXq { OP_EX, q_mode }
347 #define EXqS { OP_EX, q_swap_mode }
348 #define EXx { OP_EX, x_mode }
349 #define EXxS { OP_EX, x_swap_mode }
350 #define EXxmm { OP_EX, xmm_mode }
351 #define EXxmmq { OP_EX, xmmq_mode }
352 #define EXymmq { OP_EX, ymmq_mode }
353 #define EXVexWdq { OP_EX, vex_w_dq_mode }
354 #define MS { OP_MS, v_mode }
355 #define XS { OP_XS, v_mode }
356 #define EMCq { OP_EMC, q_mode }
357 #define MXC { OP_MXC, 0 }
358 #define OPSUF { OP_3DNowSuffix, 0 }
359 #define CMP { CMP_Fixup, 0 }
360 #define XMM0 { XMM_Fixup, 0 }
361 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
362 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
364 #define Vex { OP_VEX, vex_mode }
365 #define Vex128 { OP_VEX, vex128_mode }
366 #define Vex256 { OP_VEX, vex256_mode }
367 #define VexI4 { VEXI4_Fixup, 0}
368 #define EXdVex { OP_EX_Vex, d_mode }
369 #define EXdVexS { OP_EX_Vex, d_swap_mode }
370 #define EXqVex { OP_EX_Vex, q_mode }
371 #define EXqVexS { OP_EX_Vex, q_swap_mode }
372 #define EXVexW { OP_EX_VexW, x_mode }
373 #define EXdVexW { OP_EX_VexW, d_mode }
374 #define EXqVexW { OP_EX_VexW, q_mode }
375 #define XMVex { OP_XMM_Vex, 0 }
376 #define XMVexW { OP_XMM_VexW, 0 }
377 #define XMVexI4 { OP_REG_VexI4, x_mode }
378 #define PCLMUL { PCLMUL_Fixup, 0 }
379 #define VZERO { VZERO_Fixup, 0 }
380 #define VCMP { VCMP_Fixup, 0 }
382 /* Used handle "rep" prefix for string instructions. */
383 #define Xbr { REP_Fixup, eSI_reg }
384 #define Xvr { REP_Fixup, eSI_reg }
385 #define Ybr { REP_Fixup, eDI_reg }
386 #define Yvr { REP_Fixup, eDI_reg }
387 #define Yzr { REP_Fixup, eDI_reg }
388 #define indirDXr { REP_Fixup, indir_dx_reg }
389 #define ALr { REP_Fixup, al_reg }
390 #define eAXr { REP_Fixup, eAX_reg }
392 #define cond_jump_flag { NULL, cond_jump_mode }
393 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
395 /* bits in sizeflag */
396 #define SUFFIX_ALWAYS 4
404 /* byte operand with operand swapped */
406 /* operand size depends on prefixes */
408 /* operand size depends on prefixes with operand swapped */
412 /* double word operand */
414 /* double word operand with operand swapped */
416 /* quad word operand */
418 /* quad word operand with operand swapped */
420 /* ten-byte operand */
422 /* 16-byte XMM or 32-byte YMM operand */
424 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
426 /* 16-byte XMM operand */
428 /* 16-byte XMM or quad word operand */
430 /* 32-byte YMM or quad word operand */
432 /* d_mode in 32bit, q_mode in 64bit mode. */
434 /* pair of v_mode operands */
438 /* operand size depends on REX prefixes. */
440 /* registers like dq_mode, memory like w_mode. */
442 /* 4- or 6-byte pointer operand */
445 /* v_mode for stack-related opcodes. */
447 /* non-quad operand size depends on prefixes */
449 /* 16-byte operand */
451 /* registers like dq_mode, memory like b_mode. */
453 /* registers like dq_mode, memory like d_mode. */
455 /* normal vex mode */
457 /* 128bit vex mode */
459 /* 256bit vex mode */
461 /* operand size depends on the VEX.W bit. */
526 #define FLOAT NULL, { { NULL, FLOATCODE } }
528 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
529 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
530 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
531 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
532 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
533 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
534 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
535 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
536 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
537 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
538 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
656 MOD_VEX_3818_PREFIX_2,
657 MOD_VEX_3819_PREFIX_2,
658 MOD_VEX_381A_PREFIX_2,
659 MOD_VEX_382A_PREFIX_2,
660 MOD_VEX_382C_PREFIX_2,
661 MOD_VEX_382D_PREFIX_2,
662 MOD_VEX_382E_PREFIX_2,
663 MOD_VEX_382F_PREFIX_2
1073 THREE_BYTE_0F38 = 0,
1228 VEX_LEN_3819_P_2_M_0,
1229 VEX_LEN_381A_P_2_M_0,
1241 VEX_LEN_382A_P_2_M_0,
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 { VEX_LEN_TABLE (VEX_LEN_XOP_08_A0) },
6577 { VEX_LEN_TABLE (VEX_LEN_XOP_08_A1) },
6578 { "vpcmov", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6579 { "vpperm", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6580 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6582 { "vpmadcsswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6583 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6589 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6591 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6598 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6600 { "vpmadcswd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
6601 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6607 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6609 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6612 { "vprotb", { XM, Vex_2src_1, Ib } },
6613 { "vprotw", { XM, Vex_2src_1, Ib } },
6614 { "vprotd", { XM, Vex_2src_1, Ib } },
6615 { "vprotq", { XM, Vex_2src_1, Ib } },
6616 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6618 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6625 { "vpcomb", { XM, Vex128, EXx, Ib } },
6626 { "vpcomw", { XM, Vex128, EXx, Ib } },
6627 { "vpcomd", { XM, Vex128, EXx, Ib } },
6628 { "vpcomq", { XM, Vex128, EXx, Ib } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6634 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6636 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6643 { "(bad)", { XX } },
6644 { "(bad)", { XX } },
6645 { "(bad)", { XX } },
6646 { "(bad)", { XX } },
6648 { "(bad)", { XX } },
6649 { "(bad)", { XX } },
6650 { "(bad)", { XX } },
6651 { "(bad)", { XX } },
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6654 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6658 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6660 { "(bad)", { XX } },
6661 { "vpcomub", { XM, Vex128, EXx, Ib } },
6662 { "vpcomuw", { XM, Vex128, EXx, Ib } },
6663 { "vpcomud", { XM, Vex128, EXx, Ib } },
6664 { "vpcomuq", { XM, Vex128, EXx, Ib } },
6666 { "(bad)", { XX } },
6667 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6669 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6672 { "(bad)", { XX } },
6673 { "(bad)", { XX } },
6675 { "(bad)", { XX } },
6676 { "(bad)", { XX } },
6677 { "(bad)", { XX } },
6678 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6687 { "(bad)", { XX } },
6688 { "(bad)", { XX } },
6689 { "(bad)", { XX } },
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6693 { "(bad)", { XX } },
6694 { "(bad)", { XX } },
6696 { "(bad)", { XX } },
6697 { "(bad)", { XX } },
6698 { "(bad)", { XX } },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6702 { "(bad)", { XX } },
6703 { "(bad)", { XX } },
6705 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6707 { REG_TABLE (REG_XOP_LWPCB) },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6711 { "(bad)", { XX } },
6712 { "(bad)", { XX } },
6714 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6716 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6720 { "(bad)", { XX } },
6721 { "(bad)", { XX } },
6723 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6725 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6729 { "(bad)", { XX } },
6730 { "(bad)", { XX } },
6732 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6734 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6738 { "(bad)", { XX } },
6739 { "(bad)", { XX } },
6741 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6743 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6747 { "(bad)", { XX } },
6748 { "(bad)", { XX } },
6750 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6752 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6756 { "(bad)", { XX } },
6757 { "(bad)", { XX } },
6759 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6761 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6765 { "(bad)", { XX } },
6766 { "(bad)", { XX } },
6768 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6770 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6774 { "(bad)", { XX } },
6775 { "(bad)", { XX } },
6777 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6779 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6783 { "(bad)", { XX } },
6784 { "(bad)", { XX } },
6786 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6788 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6792 { "(bad)", { XX } },
6793 { "(bad)", { XX } },
6795 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6797 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "(bad)", { XX } },
6800 { "(bad)", { XX } },
6801 { "(bad)", { XX } },
6802 { "(bad)", { XX } },
6804 { "(bad)", { XX } },
6805 { "(bad)", { XX } },
6806 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "(bad)", { XX } },
6810 { "(bad)", { XX } },
6811 { "(bad)", { XX } },
6813 { "(bad)", { XX } },
6814 { "(bad)", { XX } },
6815 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "(bad)", { XX } },
6818 { "(bad)", { XX } },
6819 { "(bad)", { XX } },
6820 { "(bad)", { XX } },
6822 { "(bad)", { XX } },
6823 { "(bad)", { XX } },
6824 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "(bad)", { XX } },
6828 { "(bad)", { XX } },
6829 { "(bad)", { XX } },
6831 { VEX_LEN_TABLE (VEX_LEN_XOP_09_80) },
6832 { VEX_LEN_TABLE (VEX_LEN_XOP_09_81) },
6833 { "vfrczss", { XM, EXd } },
6834 { "vfrczsd", { XM, EXq } },
6835 { "(bad)", { XX } },
6836 { "(bad)", { XX } },
6837 { "(bad)", { XX } },
6838 { "(bad)", { XX } },
6840 { "(bad)", { XX } },
6841 { "(bad)", { XX } },
6842 { "(bad)", { XX } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6846 { "(bad)", { XX } },
6847 { "(bad)", { XX } },
6849 { "vprotb", { XM, Vex_2src_1, Vex_2src_2 } },
6850 { "vprotw", { XM, Vex_2src_1, Vex_2src_2 } },
6851 { "vprotd", { XM, Vex_2src_1, Vex_2src_2 } },
6852 { "vprotq", { XM, Vex_2src_1, Vex_2src_2 } },
6853 { "vpshlb", { XM, Vex_2src_1, Vex_2src_2 } },
6854 { "vpshlw", { XM, Vex_2src_1, Vex_2src_2 } },
6855 { "vpshld", { XM, Vex_2src_1, Vex_2src_2 } },
6856 { "vpshlq", { XM, Vex_2src_1, Vex_2src_2 } },
6858 { "vpshab", { XM, Vex_2src_1, Vex_2src_2 } },
6859 { "vpshaw", { XM, Vex_2src_1, Vex_2src_2 } },
6860 { "vpshad", { XM, Vex_2src_1, Vex_2src_2 } },
6861 { "vpshaq", { XM, Vex_2src_1, Vex_2src_2 } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6864 { "(bad)", { XX } },
6865 { "(bad)", { XX } },
6867 { "(bad)", { XX } },
6868 { "(bad)", { XX } },
6869 { "(bad)", { XX } },
6870 { "(bad)", { XX } },
6871 { "(bad)", { XX } },
6872 { "(bad)", { XX } },
6873 { "(bad)", { XX } },
6874 { "(bad)", { XX } },
6876 { "(bad)", { XX } },
6877 { "(bad)", { XX } },
6878 { "(bad)", { XX } },
6879 { "(bad)", { XX } },
6880 { "(bad)", { XX } },
6881 { "(bad)", { XX } },
6882 { "(bad)", { XX } },
6883 { "(bad)", { XX } },
6885 { "(bad)", { XX } },
6886 { "(bad)", { XX } },
6887 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6891 { "(bad)", { XX } },
6892 { "(bad)", { XX } },
6894 { "(bad)", { XX } },
6895 { "(bad)", { XX } },
6896 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6900 { "(bad)", { XX } },
6901 { "(bad)", { XX } },
6903 { "(bad)", { XX } },
6904 { "vphaddbw", { XM, EXxmm } },
6905 { "vphaddbd", { XM, EXxmm } },
6906 { "vphaddbq", { XM, EXxmm } },
6907 { "(bad)", { XX } },
6908 { "(bad)", { XX } },
6909 { "vphaddwd", { XM, EXxmm } },
6910 { "vphaddwq", { XM, EXxmm } },
6912 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6914 { "(bad)", { XX } },
6915 { "vphadddq", { XM, EXxmm } },
6916 { "(bad)", { XX } },
6917 { "(bad)", { XX } },
6918 { "(bad)", { XX } },
6919 { "(bad)", { XX } },
6921 { "(bad)", { XX } },
6922 { "vphaddubw", { XM, EXxmm } },
6923 { "vphaddubd", { XM, EXxmm } },
6924 { "vphaddubq", { XM, EXxmm } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6927 { "vphadduwd", { XM, EXxmm } },
6928 { "vphadduwq", { XM, EXxmm } },
6930 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6932 { "(bad)", { XX } },
6933 { "vphaddudq", { XM, EXxmm } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6936 { "(bad)", { XX } },
6937 { "(bad)", { XX } },
6939 { "(bad)", { XX } },
6940 { "vphsubbw", { XM, EXxmm } },
6941 { "vphsubwd", { XM, EXxmm } },
6942 { "vphsubdq", { XM, EXxmm } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6945 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6949 { "(bad)", { XX } },
6950 { "(bad)", { XX } },
6951 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6954 { "(bad)", { XX } },
6955 { "(bad)", { XX } },
6957 { "(bad)", { XX } },
6958 { "(bad)", { XX } },
6959 { "(bad)", { XX } },
6960 { "(bad)", { XX } },
6961 { "(bad)", { XX } },
6962 { "(bad)", { XX } },
6963 { "(bad)", { XX } },
6964 { "(bad)", { XX } },
6966 { "(bad)", { XX } },
6967 { "(bad)", { XX } },
6968 { "(bad)", { XX } },
6969 { "(bad)", { XX } },
6970 { "(bad)", { XX } },
6971 { "(bad)", { XX } },
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6978 { "(bad)", { XX } },
6979 { "(bad)", { XX } },
6980 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6985 { "(bad)", { XX } },
6987 { "(bad)", { XX } },
6988 { "(bad)", { XX } },
6989 { "(bad)", { XX } },
6990 { "(bad)", { XX } },
6991 { "(bad)", { XX } },
6992 { "(bad)", { XX } },
6993 { "(bad)", { XX } },
6994 { "(bad)", { XX } },
6996 { "(bad)", { XX } },
6997 { "(bad)", { XX } },
6998 { REG_TABLE (REG_XOP_LWP) },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { "(bad)", { XX } },
7002 { "(bad)", { XX } },
7003 { "(bad)", { XX } },
7005 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7007 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7012 { "(bad)", { XX } },
7014 { "(bad)", { XX } },
7015 { "(bad)", { XX } },
7016 { "(bad)", { XX } },
7017 { "(bad)", { XX } },
7018 { "(bad)", { XX } },
7019 { "(bad)", { XX } },
7020 { "(bad)", { XX } },
7021 { "(bad)", { XX } },
7023 { "(bad)", { XX } },
7024 { "(bad)", { XX } },
7025 { "(bad)", { XX } },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7030 { "(bad)", { XX } },
7032 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7034 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7039 { "(bad)", { XX } },
7041 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7043 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7048 { "(bad)", { XX } },
7050 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7052 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7057 { "(bad)", { XX } },
7059 { "(bad)", { XX } },
7060 { "(bad)", { XX } },
7061 { "(bad)", { XX } },
7062 { "(bad)", { XX } },
7063 { "(bad)", { XX } },
7064 { "(bad)", { XX } },
7065 { "(bad)", { XX } },
7066 { "(bad)", { XX } },
7068 { "(bad)", { XX } },
7069 { "(bad)", { XX } },
7070 { "(bad)", { XX } },
7071 { "(bad)", { XX } },
7072 { "(bad)", { XX } },
7073 { "(bad)", { XX } },
7074 { "(bad)", { XX } },
7075 { "(bad)", { XX } },
7077 { "(bad)", { XX } },
7078 { "(bad)", { XX } },
7079 { "(bad)", { XX } },
7080 { "(bad)", { XX } },
7081 { "(bad)", { XX } },
7082 { "(bad)", { XX } },
7083 { "(bad)", { XX } },
7084 { "(bad)", { XX } },
7086 { "(bad)", { XX } },
7087 { "(bad)", { XX } },
7088 { "(bad)", { XX } },
7089 { "(bad)", { XX } },
7090 { "(bad)", { XX } },
7091 { "(bad)", { XX } },
7092 { "(bad)", { XX } },
7093 { "(bad)", { XX } },
7095 { "(bad)", { XX } },
7096 { "(bad)", { XX } },
7097 { "(bad)", { XX } },
7098 { "(bad)", { XX } },
7099 { "(bad)", { XX } },
7100 { "(bad)", { XX } },
7101 { "(bad)", { XX } },
7102 { "(bad)", { XX } },
7104 { "(bad)", { XX } },
7105 { "(bad)", { XX } },
7106 { "(bad)", { XX } },
7107 { "(bad)", { XX } },
7108 { "(bad)", { XX } },
7109 { "(bad)", { XX } },
7110 { "(bad)", { XX } },
7111 { "(bad)", { XX } },
7113 { "(bad)", { XX } },
7114 { "(bad)", { XX } },
7115 { "(bad)", { XX } },
7116 { "(bad)", { XX } },
7117 { "(bad)", { XX } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7120 { "(bad)", { XX } },
7122 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7124 { "(bad)", { XX } },
7125 { "(bad)", { XX } },
7126 { "(bad)", { XX } },
7127 { "(bad)", { XX } },
7128 { "(bad)", { XX } },
7129 { "(bad)", { XX } },
7131 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7133 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7138 { "(bad)", { XX } },
7140 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7142 { "(bad)", { XX } },
7143 { "(bad)", { XX } },
7144 { "(bad)", { XX } },
7145 { "(bad)", { XX } },
7146 { "(bad)", { XX } },
7147 { "(bad)", { XX } },
7149 { "(bad)", { XX } },
7150 { "(bad)", { XX } },
7151 { "(bad)", { XX } },
7152 { "(bad)", { XX } },
7153 { "(bad)", { XX } },
7154 { "(bad)", { XX } },
7155 { "(bad)", { XX } },
7156 { "(bad)", { XX } },
7158 { "(bad)", { XX } },
7159 { "(bad)", { XX } },
7160 { "(bad)", { XX } },
7161 { "(bad)", { XX } },
7162 { "(bad)", { XX } },
7163 { "(bad)", { XX } },
7164 { "(bad)", { XX } },
7165 { "(bad)", { XX } },
7167 { "(bad)", { XX } },
7168 { "(bad)", { XX } },
7169 { "(bad)", { XX } },
7170 { "(bad)", { XX } },
7171 { "(bad)", { XX } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7174 { "(bad)", { XX } },
7176 { "(bad)", { XX } },
7177 { "(bad)", { XX } },
7178 { "(bad)", { XX } },
7179 { "(bad)", { XX } },
7180 { "(bad)", { XX } },
7181 { "(bad)", { XX } },
7182 { "(bad)", { XX } },
7183 { "(bad)", { XX } },
7185 { "(bad)", { XX } },
7186 { "(bad)", { XX } },
7187 { "(bad)", { XX } },
7188 { "(bad)", { XX } },
7189 { "(bad)", { XX } },
7190 { "(bad)", { XX } },
7191 { "(bad)", { XX } },
7192 { "(bad)", { XX } },
7194 { "(bad)", { XX } },
7195 { "(bad)", { XX } },
7196 { "(bad)", { XX } },
7197 { "(bad)", { XX } },
7198 { "(bad)", { XX } },
7199 { "(bad)", { XX } },
7200 { "(bad)", { XX } },
7201 { "(bad)", { XX } },
7203 { "(bad)", { XX } },
7204 { "(bad)", { XX } },
7205 { "(bad)", { XX } },
7206 { "(bad)", { XX } },
7207 { "(bad)", { XX } },
7208 { "(bad)", { XX } },
7209 { "(bad)", { XX } },
7210 { "(bad)", { XX } },
7212 { "(bad)", { XX } },
7213 { "(bad)", { XX } },
7214 { "(bad)", { XX } },
7215 { "(bad)", { XX } },
7216 { "(bad)", { XX } },
7217 { "(bad)", { XX } },
7218 { "(bad)", { XX } },
7219 { "(bad)", { XX } },
7221 { "(bad)", { XX } },
7222 { "(bad)", { XX } },
7223 { "(bad)", { XX } },
7224 { "(bad)", { XX } },
7225 { "(bad)", { XX } },
7226 { "(bad)", { XX } },
7227 { "(bad)", { XX } },
7228 { "(bad)", { XX } },
7230 { "(bad)", { XX } },
7231 { "(bad)", { XX } },
7232 { "(bad)", { XX } },
7233 { "(bad)", { XX } },
7234 { "(bad)", { XX } },
7235 { "(bad)", { XX } },
7236 { "(bad)", { XX } },
7237 { "(bad)", { XX } },
7239 { "(bad)", { XX } },
7240 { "(bad)", { XX } },
7241 { "(bad)", { XX } },
7242 { "(bad)", { XX } },
7243 { "(bad)", { XX } },
7244 { "(bad)", { XX } },
7245 { "(bad)", { XX } },
7246 { "(bad)", { XX } },
7248 { "(bad)", { XX } },
7249 { "(bad)", { XX } },
7250 { "(bad)", { XX } },
7251 { "(bad)", { XX } },
7252 { "(bad)", { XX } },
7253 { "(bad)", { XX } },
7254 { "(bad)", { XX } },
7255 { "(bad)", { XX } },
7257 { "(bad)", { XX } },
7258 { "(bad)", { XX } },
7259 { "(bad)", { XX } },
7260 { "(bad)", { XX } },
7261 { "(bad)", { XX } },
7262 { "(bad)", { XX } },
7263 { "(bad)", { XX } },
7264 { "(bad)", { XX } },
7268 static const struct dis386 vex_table[][256] = {
7272 { "(bad)", { XX } },
7273 { "(bad)", { XX } },
7274 { "(bad)", { XX } },
7275 { "(bad)", { XX } },
7276 { "(bad)", { XX } },
7277 { "(bad)", { XX } },
7278 { "(bad)", { XX } },
7279 { "(bad)", { XX } },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7285 { "(bad)", { XX } },
7286 { "(bad)", { XX } },
7287 { "(bad)", { XX } },
7288 { "(bad)", { XX } },
7290 { PREFIX_TABLE (PREFIX_VEX_10) },
7291 { PREFIX_TABLE (PREFIX_VEX_11) },
7292 { PREFIX_TABLE (PREFIX_VEX_12) },
7293 { MOD_TABLE (MOD_VEX_13) },
7294 { "vunpcklpX", { XM, Vex, EXx } },
7295 { "vunpckhpX", { XM, Vex, EXx } },
7296 { PREFIX_TABLE (PREFIX_VEX_16) },
7297 { MOD_TABLE (MOD_VEX_17) },
7299 { "(bad)", { XX } },
7300 { "(bad)", { XX } },
7301 { "(bad)", { XX } },
7302 { "(bad)", { XX } },
7303 { "(bad)", { XX } },
7304 { "(bad)", { XX } },
7305 { "(bad)", { XX } },
7306 { "(bad)", { XX } },
7308 { "(bad)", { XX } },
7309 { "(bad)", { XX } },
7310 { "(bad)", { XX } },
7311 { "(bad)", { XX } },
7312 { "(bad)", { XX } },
7313 { "(bad)", { XX } },
7314 { "(bad)", { XX } },
7315 { "(bad)", { XX } },
7317 { "vmovapX", { XM, EXx } },
7318 { "vmovapX", { EXxS, XM } },
7319 { PREFIX_TABLE (PREFIX_VEX_2A) },
7320 { MOD_TABLE (MOD_VEX_2B) },
7321 { PREFIX_TABLE (PREFIX_VEX_2C) },
7322 { PREFIX_TABLE (PREFIX_VEX_2D) },
7323 { PREFIX_TABLE (PREFIX_VEX_2E) },
7324 { PREFIX_TABLE (PREFIX_VEX_2F) },
7326 { "(bad)", { XX } },
7327 { "(bad)", { XX } },
7328 { "(bad)", { XX } },
7329 { "(bad)", { XX } },
7330 { "(bad)", { XX } },
7331 { "(bad)", { XX } },
7332 { "(bad)", { XX } },
7333 { "(bad)", { XX } },
7335 { "(bad)", { XX } },
7336 { "(bad)", { XX } },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7339 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7341 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7348 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7350 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7357 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7359 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7362 { MOD_TABLE (MOD_VEX_51) },
7363 { PREFIX_TABLE (PREFIX_VEX_51) },
7364 { PREFIX_TABLE (PREFIX_VEX_52) },
7365 { PREFIX_TABLE (PREFIX_VEX_53) },
7366 { "vandpX", { XM, Vex, EXx } },
7367 { "vandnpX", { XM, Vex, EXx } },
7368 { "vorpX", { XM, Vex, EXx } },
7369 { "vxorpX", { XM, Vex, EXx } },
7371 { PREFIX_TABLE (PREFIX_VEX_58) },
7372 { PREFIX_TABLE (PREFIX_VEX_59) },
7373 { PREFIX_TABLE (PREFIX_VEX_5A) },
7374 { PREFIX_TABLE (PREFIX_VEX_5B) },
7375 { PREFIX_TABLE (PREFIX_VEX_5C) },
7376 { PREFIX_TABLE (PREFIX_VEX_5D) },
7377 { PREFIX_TABLE (PREFIX_VEX_5E) },
7378 { PREFIX_TABLE (PREFIX_VEX_5F) },
7380 { PREFIX_TABLE (PREFIX_VEX_60) },
7381 { PREFIX_TABLE (PREFIX_VEX_61) },
7382 { PREFIX_TABLE (PREFIX_VEX_62) },
7383 { PREFIX_TABLE (PREFIX_VEX_63) },
7384 { PREFIX_TABLE (PREFIX_VEX_64) },
7385 { PREFIX_TABLE (PREFIX_VEX_65) },
7386 { PREFIX_TABLE (PREFIX_VEX_66) },
7387 { PREFIX_TABLE (PREFIX_VEX_67) },
7389 { PREFIX_TABLE (PREFIX_VEX_68) },
7390 { PREFIX_TABLE (PREFIX_VEX_69) },
7391 { PREFIX_TABLE (PREFIX_VEX_6A) },
7392 { PREFIX_TABLE (PREFIX_VEX_6B) },
7393 { PREFIX_TABLE (PREFIX_VEX_6C) },
7394 { PREFIX_TABLE (PREFIX_VEX_6D) },
7395 { PREFIX_TABLE (PREFIX_VEX_6E) },
7396 { PREFIX_TABLE (PREFIX_VEX_6F) },
7398 { PREFIX_TABLE (PREFIX_VEX_70) },
7399 { REG_TABLE (REG_VEX_71) },
7400 { REG_TABLE (REG_VEX_72) },
7401 { REG_TABLE (REG_VEX_73) },
7402 { PREFIX_TABLE (PREFIX_VEX_74) },
7403 { PREFIX_TABLE (PREFIX_VEX_75) },
7404 { PREFIX_TABLE (PREFIX_VEX_76) },
7405 { PREFIX_TABLE (PREFIX_VEX_77) },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7411 { PREFIX_TABLE (PREFIX_VEX_7C) },
7412 { PREFIX_TABLE (PREFIX_VEX_7D) },
7413 { PREFIX_TABLE (PREFIX_VEX_7E) },
7414 { PREFIX_TABLE (PREFIX_VEX_7F) },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7420 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7422 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7429 { "(bad)", { XX } },
7430 { "(bad)", { XX } },
7431 { "(bad)", { XX } },
7432 { "(bad)", { XX } },
7434 { "(bad)", { XX } },
7435 { "(bad)", { XX } },
7436 { "(bad)", { XX } },
7437 { "(bad)", { XX } },
7438 { "(bad)", { XX } },
7439 { "(bad)", { XX } },
7440 { "(bad)", { XX } },
7441 { "(bad)", { XX } },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7447 { "(bad)", { XX } },
7448 { "(bad)", { XX } },
7449 { "(bad)", { XX } },
7450 { "(bad)", { XX } },
7452 { "(bad)", { XX } },
7453 { "(bad)", { XX } },
7454 { "(bad)", { XX } },
7455 { "(bad)", { XX } },
7456 { "(bad)", { XX } },
7457 { "(bad)", { XX } },
7458 { "(bad)", { XX } },
7459 { "(bad)", { XX } },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7465 { "(bad)", { XX } },
7466 { "(bad)", { XX } },
7467 { REG_TABLE (REG_VEX_AE) },
7468 { "(bad)", { XX } },
7470 { "(bad)", { XX } },
7471 { "(bad)", { XX } },
7472 { "(bad)", { XX } },
7473 { "(bad)", { XX } },
7474 { "(bad)", { XX } },
7475 { "(bad)", { XX } },
7476 { "(bad)", { XX } },
7477 { "(bad)", { XX } },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7483 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7485 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { PREFIX_TABLE (PREFIX_VEX_C2) },
7491 { "(bad)", { XX } },
7492 { PREFIX_TABLE (PREFIX_VEX_C4) },
7493 { PREFIX_TABLE (PREFIX_VEX_C5) },
7494 { "vshufpX", { XM, Vex, EXx, Ib } },
7495 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7501 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7503 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7506 { PREFIX_TABLE (PREFIX_VEX_D0) },
7507 { PREFIX_TABLE (PREFIX_VEX_D1) },
7508 { PREFIX_TABLE (PREFIX_VEX_D2) },
7509 { PREFIX_TABLE (PREFIX_VEX_D3) },
7510 { PREFIX_TABLE (PREFIX_VEX_D4) },
7511 { PREFIX_TABLE (PREFIX_VEX_D5) },
7512 { PREFIX_TABLE (PREFIX_VEX_D6) },
7513 { PREFIX_TABLE (PREFIX_VEX_D7) },
7515 { PREFIX_TABLE (PREFIX_VEX_D8) },
7516 { PREFIX_TABLE (PREFIX_VEX_D9) },
7517 { PREFIX_TABLE (PREFIX_VEX_DA) },
7518 { PREFIX_TABLE (PREFIX_VEX_DB) },
7519 { PREFIX_TABLE (PREFIX_VEX_DC) },
7520 { PREFIX_TABLE (PREFIX_VEX_DD) },
7521 { PREFIX_TABLE (PREFIX_VEX_DE) },
7522 { PREFIX_TABLE (PREFIX_VEX_DF) },
7524 { PREFIX_TABLE (PREFIX_VEX_E0) },
7525 { PREFIX_TABLE (PREFIX_VEX_E1) },
7526 { PREFIX_TABLE (PREFIX_VEX_E2) },
7527 { PREFIX_TABLE (PREFIX_VEX_E3) },
7528 { PREFIX_TABLE (PREFIX_VEX_E4) },
7529 { PREFIX_TABLE (PREFIX_VEX_E5) },
7530 { PREFIX_TABLE (PREFIX_VEX_E6) },
7531 { PREFIX_TABLE (PREFIX_VEX_E7) },
7533 { PREFIX_TABLE (PREFIX_VEX_E8) },
7534 { PREFIX_TABLE (PREFIX_VEX_E9) },
7535 { PREFIX_TABLE (PREFIX_VEX_EA) },
7536 { PREFIX_TABLE (PREFIX_VEX_EB) },
7537 { PREFIX_TABLE (PREFIX_VEX_EC) },
7538 { PREFIX_TABLE (PREFIX_VEX_ED) },
7539 { PREFIX_TABLE (PREFIX_VEX_EE) },
7540 { PREFIX_TABLE (PREFIX_VEX_EF) },
7542 { PREFIX_TABLE (PREFIX_VEX_F0) },
7543 { PREFIX_TABLE (PREFIX_VEX_F1) },
7544 { PREFIX_TABLE (PREFIX_VEX_F2) },
7545 { PREFIX_TABLE (PREFIX_VEX_F3) },
7546 { PREFIX_TABLE (PREFIX_VEX_F4) },
7547 { PREFIX_TABLE (PREFIX_VEX_F5) },
7548 { PREFIX_TABLE (PREFIX_VEX_F6) },
7549 { PREFIX_TABLE (PREFIX_VEX_F7) },
7551 { PREFIX_TABLE (PREFIX_VEX_F8) },
7552 { PREFIX_TABLE (PREFIX_VEX_F9) },
7553 { PREFIX_TABLE (PREFIX_VEX_FA) },
7554 { PREFIX_TABLE (PREFIX_VEX_FB) },
7555 { PREFIX_TABLE (PREFIX_VEX_FC) },
7556 { PREFIX_TABLE (PREFIX_VEX_FD) },
7557 { PREFIX_TABLE (PREFIX_VEX_FE) },
7558 { "(bad)", { XX } },
7563 { PREFIX_TABLE (PREFIX_VEX_3800) },
7564 { PREFIX_TABLE (PREFIX_VEX_3801) },
7565 { PREFIX_TABLE (PREFIX_VEX_3802) },
7566 { PREFIX_TABLE (PREFIX_VEX_3803) },
7567 { PREFIX_TABLE (PREFIX_VEX_3804) },
7568 { PREFIX_TABLE (PREFIX_VEX_3805) },
7569 { PREFIX_TABLE (PREFIX_VEX_3806) },
7570 { PREFIX_TABLE (PREFIX_VEX_3807) },
7572 { PREFIX_TABLE (PREFIX_VEX_3808) },
7573 { PREFIX_TABLE (PREFIX_VEX_3809) },
7574 { PREFIX_TABLE (PREFIX_VEX_380A) },
7575 { PREFIX_TABLE (PREFIX_VEX_380B) },
7576 { PREFIX_TABLE (PREFIX_VEX_380C) },
7577 { PREFIX_TABLE (PREFIX_VEX_380D) },
7578 { PREFIX_TABLE (PREFIX_VEX_380E) },
7579 { PREFIX_TABLE (PREFIX_VEX_380F) },
7581 { "(bad)", { XX } },
7582 { "(bad)", { XX } },
7583 { "(bad)", { XX } },
7584 { "(bad)", { XX } },
7585 { "(bad)", { XX } },
7586 { "(bad)", { XX } },
7587 { "(bad)", { XX } },
7588 { PREFIX_TABLE (PREFIX_VEX_3817) },
7590 { PREFIX_TABLE (PREFIX_VEX_3818) },
7591 { PREFIX_TABLE (PREFIX_VEX_3819) },
7592 { PREFIX_TABLE (PREFIX_VEX_381A) },
7593 { "(bad)", { XX } },
7594 { PREFIX_TABLE (PREFIX_VEX_381C) },
7595 { PREFIX_TABLE (PREFIX_VEX_381D) },
7596 { PREFIX_TABLE (PREFIX_VEX_381E) },
7597 { "(bad)", { XX } },
7599 { PREFIX_TABLE (PREFIX_VEX_3820) },
7600 { PREFIX_TABLE (PREFIX_VEX_3821) },
7601 { PREFIX_TABLE (PREFIX_VEX_3822) },
7602 { PREFIX_TABLE (PREFIX_VEX_3823) },
7603 { PREFIX_TABLE (PREFIX_VEX_3824) },
7604 { PREFIX_TABLE (PREFIX_VEX_3825) },
7605 { "(bad)", { XX } },
7606 { "(bad)", { XX } },
7608 { PREFIX_TABLE (PREFIX_VEX_3828) },
7609 { PREFIX_TABLE (PREFIX_VEX_3829) },
7610 { PREFIX_TABLE (PREFIX_VEX_382A) },
7611 { PREFIX_TABLE (PREFIX_VEX_382B) },
7612 { PREFIX_TABLE (PREFIX_VEX_382C) },
7613 { PREFIX_TABLE (PREFIX_VEX_382D) },
7614 { PREFIX_TABLE (PREFIX_VEX_382E) },
7615 { PREFIX_TABLE (PREFIX_VEX_382F) },
7617 { PREFIX_TABLE (PREFIX_VEX_3830) },
7618 { PREFIX_TABLE (PREFIX_VEX_3831) },
7619 { PREFIX_TABLE (PREFIX_VEX_3832) },
7620 { PREFIX_TABLE (PREFIX_VEX_3833) },
7621 { PREFIX_TABLE (PREFIX_VEX_3834) },
7622 { PREFIX_TABLE (PREFIX_VEX_3835) },
7623 { "(bad)", { XX } },
7624 { PREFIX_TABLE (PREFIX_VEX_3837) },
7626 { PREFIX_TABLE (PREFIX_VEX_3838) },
7627 { PREFIX_TABLE (PREFIX_VEX_3839) },
7628 { PREFIX_TABLE (PREFIX_VEX_383A) },
7629 { PREFIX_TABLE (PREFIX_VEX_383B) },
7630 { PREFIX_TABLE (PREFIX_VEX_383C) },
7631 { PREFIX_TABLE (PREFIX_VEX_383D) },
7632 { PREFIX_TABLE (PREFIX_VEX_383E) },
7633 { PREFIX_TABLE (PREFIX_VEX_383F) },
7635 { PREFIX_TABLE (PREFIX_VEX_3840) },
7636 { PREFIX_TABLE (PREFIX_VEX_3841) },
7637 { "(bad)", { XX } },
7638 { "(bad)", { XX } },
7639 { "(bad)", { XX } },
7640 { "(bad)", { XX } },
7641 { "(bad)", { XX } },
7642 { "(bad)", { XX } },
7644 { "(bad)", { XX } },
7645 { "(bad)", { XX } },
7646 { "(bad)", { XX } },
7647 { "(bad)", { XX } },
7648 { "(bad)", { XX } },
7649 { "(bad)", { XX } },
7650 { "(bad)", { XX } },
7651 { "(bad)", { XX } },
7653 { "(bad)", { XX } },
7654 { "(bad)", { XX } },
7655 { "(bad)", { XX } },
7656 { "(bad)", { XX } },
7657 { "(bad)", { XX } },
7658 { "(bad)", { XX } },
7659 { "(bad)", { XX } },
7660 { "(bad)", { XX } },
7662 { "(bad)", { XX } },
7663 { "(bad)", { XX } },
7664 { "(bad)", { XX } },
7665 { "(bad)", { XX } },
7666 { "(bad)", { XX } },
7667 { "(bad)", { XX } },
7668 { "(bad)", { XX } },
7669 { "(bad)", { XX } },
7671 { "(bad)", { XX } },
7672 { "(bad)", { XX } },
7673 { "(bad)", { XX } },
7674 { "(bad)", { XX } },
7675 { "(bad)", { XX } },
7676 { "(bad)", { XX } },
7677 { "(bad)", { XX } },
7678 { "(bad)", { XX } },
7680 { "(bad)", { XX } },
7681 { "(bad)", { XX } },
7682 { "(bad)", { XX } },
7683 { "(bad)", { XX } },
7684 { "(bad)", { XX } },
7685 { "(bad)", { XX } },
7686 { "(bad)", { XX } },
7687 { "(bad)", { XX } },
7689 { "(bad)", { XX } },
7690 { "(bad)", { XX } },
7691 { "(bad)", { XX } },
7692 { "(bad)", { XX } },
7693 { "(bad)", { XX } },
7694 { "(bad)", { XX } },
7695 { "(bad)", { XX } },
7696 { "(bad)", { XX } },
7698 { "(bad)", { XX } },
7699 { "(bad)", { XX } },
7700 { "(bad)", { XX } },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7704 { "(bad)", { XX } },
7705 { "(bad)", { XX } },
7707 { "(bad)", { XX } },
7708 { "(bad)", { XX } },
7709 { "(bad)", { XX } },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7713 { "(bad)", { XX } },
7714 { "(bad)", { XX } },
7716 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7718 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { "(bad)", { XX } },
7722 { "(bad)", { XX } },
7723 { "(bad)", { XX } },
7725 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7727 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7731 { PREFIX_TABLE (PREFIX_VEX_3896) },
7732 { PREFIX_TABLE (PREFIX_VEX_3897) },
7734 { PREFIX_TABLE (PREFIX_VEX_3898) },
7735 { PREFIX_TABLE (PREFIX_VEX_3899) },
7736 { PREFIX_TABLE (PREFIX_VEX_389A) },
7737 { PREFIX_TABLE (PREFIX_VEX_389B) },
7738 { PREFIX_TABLE (PREFIX_VEX_389C) },
7739 { PREFIX_TABLE (PREFIX_VEX_389D) },
7740 { PREFIX_TABLE (PREFIX_VEX_389E) },
7741 { PREFIX_TABLE (PREFIX_VEX_389F) },
7743 { "(bad)", { XX } },
7744 { "(bad)", { XX } },
7745 { "(bad)", { XX } },
7746 { "(bad)", { XX } },
7747 { "(bad)", { XX } },
7748 { "(bad)", { XX } },
7749 { PREFIX_TABLE (PREFIX_VEX_38A6) },
7750 { PREFIX_TABLE (PREFIX_VEX_38A7) },
7752 { PREFIX_TABLE (PREFIX_VEX_38A8) },
7753 { PREFIX_TABLE (PREFIX_VEX_38A9) },
7754 { PREFIX_TABLE (PREFIX_VEX_38AA) },
7755 { PREFIX_TABLE (PREFIX_VEX_38AB) },
7756 { PREFIX_TABLE (PREFIX_VEX_38AC) },
7757 { PREFIX_TABLE (PREFIX_VEX_38AD) },
7758 { PREFIX_TABLE (PREFIX_VEX_38AE) },
7759 { PREFIX_TABLE (PREFIX_VEX_38AF) },
7761 { "(bad)", { XX } },
7762 { "(bad)", { XX } },
7763 { "(bad)", { XX } },
7764 { "(bad)", { XX } },
7765 { "(bad)", { XX } },
7766 { "(bad)", { XX } },
7767 { PREFIX_TABLE (PREFIX_VEX_38B6) },
7768 { PREFIX_TABLE (PREFIX_VEX_38B7) },
7770 { PREFIX_TABLE (PREFIX_VEX_38B8) },
7771 { PREFIX_TABLE (PREFIX_VEX_38B9) },
7772 { PREFIX_TABLE (PREFIX_VEX_38BA) },
7773 { PREFIX_TABLE (PREFIX_VEX_38BB) },
7774 { PREFIX_TABLE (PREFIX_VEX_38BC) },
7775 { PREFIX_TABLE (PREFIX_VEX_38BD) },
7776 { PREFIX_TABLE (PREFIX_VEX_38BE) },
7777 { PREFIX_TABLE (PREFIX_VEX_38BF) },
7779 { "(bad)", { XX } },
7780 { "(bad)", { XX } },
7781 { "(bad)", { XX } },
7782 { "(bad)", { XX } },
7783 { "(bad)", { XX } },
7784 { "(bad)", { XX } },
7785 { "(bad)", { XX } },
7786 { "(bad)", { XX } },
7788 { "(bad)", { XX } },
7789 { "(bad)", { XX } },
7790 { "(bad)", { XX } },
7791 { "(bad)", { XX } },
7792 { "(bad)", { XX } },
7793 { "(bad)", { XX } },
7794 { "(bad)", { XX } },
7795 { "(bad)", { XX } },
7797 { "(bad)", { XX } },
7798 { "(bad)", { XX } },
7799 { "(bad)", { XX } },
7800 { "(bad)", { XX } },
7801 { "(bad)", { XX } },
7802 { "(bad)", { XX } },
7803 { "(bad)", { XX } },
7804 { "(bad)", { XX } },
7806 { "(bad)", { XX } },
7807 { "(bad)", { XX } },
7808 { "(bad)", { XX } },
7809 { PREFIX_TABLE (PREFIX_VEX_38DB) },
7810 { PREFIX_TABLE (PREFIX_VEX_38DC) },
7811 { PREFIX_TABLE (PREFIX_VEX_38DD) },
7812 { PREFIX_TABLE (PREFIX_VEX_38DE) },
7813 { PREFIX_TABLE (PREFIX_VEX_38DF) },
7815 { "(bad)", { XX } },
7816 { "(bad)", { XX } },
7817 { "(bad)", { XX } },
7818 { "(bad)", { XX } },
7819 { "(bad)", { XX } },
7820 { "(bad)", { XX } },
7821 { "(bad)", { XX } },
7822 { "(bad)", { XX } },
7824 { "(bad)", { XX } },
7825 { "(bad)", { XX } },
7826 { "(bad)", { XX } },
7827 { "(bad)", { XX } },
7828 { "(bad)", { XX } },
7829 { "(bad)", { XX } },
7830 { "(bad)", { XX } },
7831 { "(bad)", { XX } },
7833 { "(bad)", { XX } },
7834 { "(bad)", { XX } },
7835 { "(bad)", { XX } },
7836 { "(bad)", { XX } },
7837 { "(bad)", { XX } },
7838 { "(bad)", { XX } },
7839 { "(bad)", { XX } },
7840 { "(bad)", { XX } },
7842 { "(bad)", { XX } },
7843 { "(bad)", { XX } },
7844 { "(bad)", { XX } },
7845 { "(bad)", { XX } },
7846 { "(bad)", { XX } },
7847 { "(bad)", { XX } },
7848 { "(bad)", { XX } },
7849 { "(bad)", { XX } },
7854 { "(bad)", { XX } },
7855 { "(bad)", { XX } },
7856 { "(bad)", { XX } },
7857 { "(bad)", { XX } },
7858 { PREFIX_TABLE (PREFIX_VEX_3A04) },
7859 { PREFIX_TABLE (PREFIX_VEX_3A05) },
7860 { PREFIX_TABLE (PREFIX_VEX_3A06) },
7861 { "(bad)", { XX } },
7863 { PREFIX_TABLE (PREFIX_VEX_3A08) },
7864 { PREFIX_TABLE (PREFIX_VEX_3A09) },
7865 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
7866 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
7867 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
7868 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
7869 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
7870 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
7872 { "(bad)", { XX } },
7873 { "(bad)", { XX } },
7874 { "(bad)", { XX } },
7875 { "(bad)", { XX } },
7876 { PREFIX_TABLE (PREFIX_VEX_3A14) },
7877 { PREFIX_TABLE (PREFIX_VEX_3A15) },
7878 { PREFIX_TABLE (PREFIX_VEX_3A16) },
7879 { PREFIX_TABLE (PREFIX_VEX_3A17) },
7881 { PREFIX_TABLE (PREFIX_VEX_3A18) },
7882 { PREFIX_TABLE (PREFIX_VEX_3A19) },
7883 { "(bad)", { XX } },
7884 { "(bad)", { XX } },
7885 { "(bad)", { XX } },
7886 { "(bad)", { XX } },
7887 { "(bad)", { XX } },
7888 { "(bad)", { XX } },
7890 { PREFIX_TABLE (PREFIX_VEX_3A20) },
7891 { PREFIX_TABLE (PREFIX_VEX_3A21) },
7892 { PREFIX_TABLE (PREFIX_VEX_3A22) },
7893 { "(bad)", { XX } },
7894 { "(bad)", { XX } },
7895 { "(bad)", { XX } },
7896 { "(bad)", { XX } },
7897 { "(bad)", { XX } },
7899 { "(bad)", { XX } },
7900 { "(bad)", { XX } },
7901 { "(bad)", { XX } },
7902 { "(bad)", { XX } },
7903 { "(bad)", { XX } },
7904 { "(bad)", { XX } },
7905 { "(bad)", { XX } },
7906 { "(bad)", { XX } },
7908 { "(bad)", { XX } },
7909 { "(bad)", { XX } },
7910 { "(bad)", { XX } },
7911 { "(bad)", { XX } },
7912 { "(bad)", { XX } },
7913 { "(bad)", { XX } },
7914 { "(bad)", { XX } },
7915 { "(bad)", { XX } },
7917 { "(bad)", { XX } },
7918 { "(bad)", { XX } },
7919 { "(bad)", { XX } },
7920 { "(bad)", { XX } },
7921 { "(bad)", { XX } },
7922 { "(bad)", { XX } },
7923 { "(bad)", { XX } },
7924 { "(bad)", { XX } },
7926 { PREFIX_TABLE (PREFIX_VEX_3A40) },
7927 { PREFIX_TABLE (PREFIX_VEX_3A41) },
7928 { PREFIX_TABLE (PREFIX_VEX_3A42) },
7929 { "(bad)", { XX } },
7930 { PREFIX_TABLE (PREFIX_VEX_3A44) },
7931 { "(bad)", { XX } },
7932 { "(bad)", { XX } },
7933 { "(bad)", { XX } },
7935 { "(bad)", { XX } },
7936 { "(bad)", { XX } },
7937 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
7938 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
7939 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
7940 { "(bad)", { XX } },
7941 { "(bad)", { XX } },
7942 { "(bad)", { XX } },
7944 { "(bad)", { XX } },
7945 { "(bad)", { XX } },
7946 { "(bad)", { XX } },
7947 { "(bad)", { XX } },
7948 { "(bad)", { XX } },
7949 { "(bad)", { XX } },
7950 { "(bad)", { XX } },
7951 { "(bad)", { XX } },
7953 { "(bad)", { XX } },
7954 { "(bad)", { XX } },
7955 { "(bad)", { XX } },
7956 { "(bad)", { XX } },
7957 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
7958 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
7959 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
7960 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
7962 { PREFIX_TABLE (PREFIX_VEX_3A60) },
7963 { PREFIX_TABLE (PREFIX_VEX_3A61) },
7964 { PREFIX_TABLE (PREFIX_VEX_3A62) },
7965 { PREFIX_TABLE (PREFIX_VEX_3A63) },
7966 { "(bad)", { XX } },
7967 { "(bad)", { XX } },
7968 { "(bad)", { XX } },
7969 { "(bad)", { XX } },
7971 { PREFIX_TABLE (PREFIX_VEX_3A68) },
7972 { PREFIX_TABLE (PREFIX_VEX_3A69) },
7973 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
7974 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
7975 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
7976 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
7977 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
7978 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
7980 { "(bad)", { XX } },
7981 { "(bad)", { XX } },
7982 { "(bad)", { XX } },
7983 { "(bad)", { XX } },
7984 { "(bad)", { XX } },
7985 { "(bad)", { XX } },
7986 { "(bad)", { XX } },
7987 { "(bad)", { XX } },
7989 { PREFIX_TABLE (PREFIX_VEX_3A78) },
7990 { PREFIX_TABLE (PREFIX_VEX_3A79) },
7991 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
7992 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
7993 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
7994 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
7995 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
7996 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
7998 { "(bad)", { XX } },
7999 { "(bad)", { XX } },
8000 { "(bad)", { XX } },
8001 { "(bad)", { XX } },
8002 { "(bad)", { XX } },
8003 { "(bad)", { XX } },
8004 { "(bad)", { XX } },
8005 { "(bad)", { XX } },
8007 { "(bad)", { XX } },
8008 { "(bad)", { XX } },
8009 { "(bad)", { XX } },
8010 { "(bad)", { XX } },
8011 { "(bad)", { XX } },
8012 { "(bad)", { XX } },
8013 { "(bad)", { XX } },
8014 { "(bad)", { XX } },
8016 { "(bad)", { XX } },
8017 { "(bad)", { XX } },
8018 { "(bad)", { XX } },
8019 { "(bad)", { XX } },
8020 { "(bad)", { XX } },
8021 { "(bad)", { XX } },
8022 { "(bad)", { XX } },
8023 { "(bad)", { XX } },
8025 { "(bad)", { XX } },
8026 { "(bad)", { XX } },
8027 { "(bad)", { XX } },
8028 { "(bad)", { XX } },
8029 { "(bad)", { XX } },
8030 { "(bad)", { XX } },
8031 { "(bad)", { XX } },
8032 { "(bad)", { XX } },
8034 { "(bad)", { XX } },
8035 { "(bad)", { XX } },
8036 { "(bad)", { XX } },
8037 { "(bad)", { XX } },
8038 { "(bad)", { XX } },
8039 { "(bad)", { XX } },
8040 { "(bad)", { XX } },
8041 { "(bad)", { XX } },
8043 { "(bad)", { XX } },
8044 { "(bad)", { XX } },
8045 { "(bad)", { XX } },
8046 { "(bad)", { XX } },
8047 { "(bad)", { XX } },
8048 { "(bad)", { XX } },
8049 { "(bad)", { XX } },
8050 { "(bad)", { XX } },
8052 { "(bad)", { XX } },
8053 { "(bad)", { XX } },
8054 { "(bad)", { XX } },
8055 { "(bad)", { XX } },
8056 { "(bad)", { XX } },
8057 { "(bad)", { XX } },
8058 { "(bad)", { XX } },
8059 { "(bad)", { XX } },
8061 { "(bad)", { XX } },
8062 { "(bad)", { XX } },
8063 { "(bad)", { XX } },
8064 { "(bad)", { XX } },
8065 { "(bad)", { XX } },
8066 { "(bad)", { XX } },
8067 { "(bad)", { XX } },
8068 { "(bad)", { XX } },
8070 { "(bad)", { XX } },
8071 { "(bad)", { XX } },
8072 { "(bad)", { XX } },
8073 { "(bad)", { XX } },
8074 { "(bad)", { XX } },
8075 { "(bad)", { XX } },
8076 { "(bad)", { XX } },
8077 { "(bad)", { XX } },
8079 { "(bad)", { XX } },
8080 { "(bad)", { XX } },
8081 { "(bad)", { XX } },
8082 { "(bad)", { XX } },
8083 { "(bad)", { XX } },
8084 { "(bad)", { XX } },
8085 { "(bad)", { XX } },
8086 { "(bad)", { XX } },
8088 { "(bad)", { XX } },
8089 { "(bad)", { XX } },
8090 { "(bad)", { XX } },
8091 { "(bad)", { XX } },
8092 { "(bad)", { XX } },
8093 { "(bad)", { XX } },
8094 { "(bad)", { XX } },
8095 { "(bad)", { XX } },
8097 { "(bad)", { XX } },
8098 { "(bad)", { XX } },
8099 { "(bad)", { XX } },
8100 { "(bad)", { XX } },
8101 { "(bad)", { XX } },
8102 { "(bad)", { XX } },
8103 { "(bad)", { XX } },
8104 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
8106 { "(bad)", { XX } },
8107 { "(bad)", { XX } },
8108 { "(bad)", { XX } },
8109 { "(bad)", { XX } },
8110 { "(bad)", { XX } },
8111 { "(bad)", { XX } },
8112 { "(bad)", { XX } },
8113 { "(bad)", { XX } },
8115 { "(bad)", { XX } },
8116 { "(bad)", { XX } },
8117 { "(bad)", { XX } },
8118 { "(bad)", { XX } },
8119 { "(bad)", { XX } },
8120 { "(bad)", { XX } },
8121 { "(bad)", { XX } },
8122 { "(bad)", { XX } },
8124 { "(bad)", { XX } },
8125 { "(bad)", { XX } },
8126 { "(bad)", { XX } },
8127 { "(bad)", { XX } },
8128 { "(bad)", { XX } },
8129 { "(bad)", { XX } },
8130 { "(bad)", { XX } },
8131 { "(bad)", { XX } },
8133 { "(bad)", { XX } },
8134 { "(bad)", { XX } },
8135 { "(bad)", { XX } },
8136 { "(bad)", { XX } },
8137 { "(bad)", { XX } },
8138 { "(bad)", { XX } },
8139 { "(bad)", { XX } },
8140 { "(bad)", { XX } },
8144 static const struct dis386 vex_len_table[][2] = {
8145 /* VEX_LEN_10_P_1 */
8147 { "vmovss", { XMVex, Vex128, EXd } },
8148 { "(bad)", { XX } },
8151 /* VEX_LEN_10_P_3 */
8153 { "vmovsd", { XMVex, Vex128, EXq } },
8154 { "(bad)", { XX } },
8157 /* VEX_LEN_11_P_1 */
8159 { "vmovss", { EXdVexS, Vex128, XM } },
8160 { "(bad)", { XX } },
8163 /* VEX_LEN_11_P_3 */
8165 { "vmovsd", { EXqVexS, Vex128, XM } },
8166 { "(bad)", { XX } },
8169 /* VEX_LEN_12_P_0_M_0 */
8171 { "vmovlps", { XM, Vex128, EXq } },
8172 { "(bad)", { XX } },
8175 /* VEX_LEN_12_P_0_M_1 */
8177 { "vmovhlps", { XM, Vex128, EXq } },
8178 { "(bad)", { XX } },
8181 /* VEX_LEN_12_P_2 */
8183 { "vmovlpd", { XM, Vex128, EXq } },
8184 { "(bad)", { XX } },
8187 /* VEX_LEN_13_M_0 */
8189 { "vmovlpX", { EXq, XM } },
8190 { "(bad)", { XX } },
8193 /* VEX_LEN_16_P_0_M_0 */
8195 { "vmovhps", { XM, Vex128, EXq } },
8196 { "(bad)", { XX } },
8199 /* VEX_LEN_16_P_0_M_1 */
8201 { "vmovlhps", { XM, Vex128, EXq } },
8202 { "(bad)", { XX } },
8205 /* VEX_LEN_16_P_2 */
8207 { "vmovhpd", { XM, Vex128, EXq } },
8208 { "(bad)", { XX } },
8211 /* VEX_LEN_17_M_0 */
8213 { "vmovhpX", { EXq, XM } },
8214 { "(bad)", { XX } },
8217 /* VEX_LEN_2A_P_1 */
8219 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
8220 { "(bad)", { XX } },
8223 /* VEX_LEN_2A_P_3 */
8225 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
8226 { "(bad)", { XX } },
8229 /* VEX_LEN_2C_P_1 */
8231 { "vcvttss2siY", { Gv, EXd } },
8232 { "(bad)", { XX } },
8235 /* VEX_LEN_2C_P_3 */
8237 { "vcvttsd2siY", { Gv, EXq } },
8238 { "(bad)", { XX } },
8241 /* VEX_LEN_2D_P_1 */
8243 { "vcvtss2siY", { Gv, EXd } },
8244 { "(bad)", { XX } },
8247 /* VEX_LEN_2D_P_3 */
8249 { "vcvtsd2siY", { Gv, EXq } },
8250 { "(bad)", { XX } },
8253 /* VEX_LEN_2E_P_0 */
8255 { "vucomiss", { XM, EXd } },
8256 { "(bad)", { XX } },
8259 /* VEX_LEN_2E_P_2 */
8261 { "vucomisd", { XM, EXq } },
8262 { "(bad)", { XX } },
8265 /* VEX_LEN_2F_P_0 */
8267 { "vcomiss", { XM, EXd } },
8268 { "(bad)", { XX } },
8271 /* VEX_LEN_2F_P_2 */
8273 { "vcomisd", { XM, EXq } },
8274 { "(bad)", { XX } },
8277 /* VEX_LEN_51_P_1 */
8279 { "vsqrtss", { XM, Vex128, EXd } },
8280 { "(bad)", { XX } },
8283 /* VEX_LEN_51_P_3 */
8285 { "vsqrtsd", { XM, Vex128, EXq } },
8286 { "(bad)", { XX } },
8289 /* VEX_LEN_52_P_1 */
8291 { "vrsqrtss", { XM, Vex128, EXd } },
8292 { "(bad)", { XX } },
8295 /* VEX_LEN_53_P_1 */
8297 { "vrcpss", { XM, Vex128, EXd } },
8298 { "(bad)", { XX } },
8301 /* VEX_LEN_58_P_1 */
8303 { "vaddss", { XM, Vex128, EXd } },
8304 { "(bad)", { XX } },
8307 /* VEX_LEN_58_P_3 */
8309 { "vaddsd", { XM, Vex128, EXq } },
8310 { "(bad)", { XX } },
8313 /* VEX_LEN_59_P_1 */
8315 { "vmulss", { XM, Vex128, EXd } },
8316 { "(bad)", { XX } },
8319 /* VEX_LEN_59_P_3 */
8321 { "vmulsd", { XM, Vex128, EXq } },
8322 { "(bad)", { XX } },
8325 /* VEX_LEN_5A_P_1 */
8327 { "vcvtss2sd", { XM, Vex128, EXd } },
8328 { "(bad)", { XX } },
8331 /* VEX_LEN_5A_P_3 */
8333 { "vcvtsd2ss", { XM, Vex128, EXq } },
8334 { "(bad)", { XX } },
8337 /* VEX_LEN_5C_P_1 */
8339 { "vsubss", { XM, Vex128, EXd } },
8340 { "(bad)", { XX } },
8343 /* VEX_LEN_5C_P_3 */
8345 { "vsubsd", { XM, Vex128, EXq } },
8346 { "(bad)", { XX } },
8349 /* VEX_LEN_5D_P_1 */
8351 { "vminss", { XM, Vex128, EXd } },
8352 { "(bad)", { XX } },
8355 /* VEX_LEN_5D_P_3 */
8357 { "vminsd", { XM, Vex128, EXq } },
8358 { "(bad)", { XX } },
8361 /* VEX_LEN_5E_P_1 */
8363 { "vdivss", { XM, Vex128, EXd } },
8364 { "(bad)", { XX } },
8367 /* VEX_LEN_5E_P_3 */
8369 { "vdivsd", { XM, Vex128, EXq } },
8370 { "(bad)", { XX } },
8373 /* VEX_LEN_5F_P_1 */
8375 { "vmaxss", { XM, Vex128, EXd } },
8376 { "(bad)", { XX } },
8379 /* VEX_LEN_5F_P_3 */
8381 { "vmaxsd", { XM, Vex128, EXq } },
8382 { "(bad)", { XX } },
8385 /* VEX_LEN_60_P_2 */
8387 { "vpunpcklbw", { XM, Vex128, EXx } },
8388 { "(bad)", { XX } },
8391 /* VEX_LEN_61_P_2 */
8393 { "vpunpcklwd", { XM, Vex128, EXx } },
8394 { "(bad)", { XX } },
8397 /* VEX_LEN_62_P_2 */
8399 { "vpunpckldq", { XM, Vex128, EXx } },
8400 { "(bad)", { XX } },
8403 /* VEX_LEN_63_P_2 */
8405 { "vpacksswb", { XM, Vex128, EXx } },
8406 { "(bad)", { XX } },
8409 /* VEX_LEN_64_P_2 */
8411 { "vpcmpgtb", { XM, Vex128, EXx } },
8412 { "(bad)", { XX } },
8415 /* VEX_LEN_65_P_2 */
8417 { "vpcmpgtw", { XM, Vex128, EXx } },
8418 { "(bad)", { XX } },
8421 /* VEX_LEN_66_P_2 */
8423 { "vpcmpgtd", { XM, Vex128, EXx } },
8424 { "(bad)", { XX } },
8427 /* VEX_LEN_67_P_2 */
8429 { "vpackuswb", { XM, Vex128, EXx } },
8430 { "(bad)", { XX } },
8433 /* VEX_LEN_68_P_2 */
8435 { "vpunpckhbw", { XM, Vex128, EXx } },
8436 { "(bad)", { XX } },
8439 /* VEX_LEN_69_P_2 */
8441 { "vpunpckhwd", { XM, Vex128, EXx } },
8442 { "(bad)", { XX } },
8445 /* VEX_LEN_6A_P_2 */
8447 { "vpunpckhdq", { XM, Vex128, EXx } },
8448 { "(bad)", { XX } },
8451 /* VEX_LEN_6B_P_2 */
8453 { "vpackssdw", { XM, Vex128, EXx } },
8454 { "(bad)", { XX } },
8457 /* VEX_LEN_6C_P_2 */
8459 { "vpunpcklqdq", { XM, Vex128, EXx } },
8460 { "(bad)", { XX } },
8463 /* VEX_LEN_6D_P_2 */
8465 { "vpunpckhqdq", { XM, Vex128, EXx } },
8466 { "(bad)", { XX } },
8469 /* VEX_LEN_6E_P_2 */
8471 { "vmovK", { XM, Edq } },
8472 { "(bad)", { XX } },
8475 /* VEX_LEN_70_P_1 */
8477 { "vpshufhw", { XM, EXx, Ib } },
8478 { "(bad)", { XX } },
8481 /* VEX_LEN_70_P_2 */
8483 { "vpshufd", { XM, EXx, Ib } },
8484 { "(bad)", { XX } },
8487 /* VEX_LEN_70_P_3 */
8489 { "vpshuflw", { XM, EXx, Ib } },
8490 { "(bad)", { XX } },
8493 /* VEX_LEN_71_R_2_P_2 */
8495 { "vpsrlw", { Vex128, XS, Ib } },
8496 { "(bad)", { XX } },
8499 /* VEX_LEN_71_R_4_P_2 */
8501 { "vpsraw", { Vex128, XS, Ib } },
8502 { "(bad)", { XX } },
8505 /* VEX_LEN_71_R_6_P_2 */
8507 { "vpsllw", { Vex128, XS, Ib } },
8508 { "(bad)", { XX } },
8511 /* VEX_LEN_72_R_2_P_2 */
8513 { "vpsrld", { Vex128, XS, Ib } },
8514 { "(bad)", { XX } },
8517 /* VEX_LEN_72_R_4_P_2 */
8519 { "vpsrad", { Vex128, XS, Ib } },
8520 { "(bad)", { XX } },
8523 /* VEX_LEN_72_R_6_P_2 */
8525 { "vpslld", { Vex128, XS, Ib } },
8526 { "(bad)", { XX } },
8529 /* VEX_LEN_73_R_2_P_2 */
8531 { "vpsrlq", { Vex128, XS, Ib } },
8532 { "(bad)", { XX } },
8535 /* VEX_LEN_73_R_3_P_2 */
8537 { "vpsrldq", { Vex128, XS, Ib } },
8538 { "(bad)", { XX } },
8541 /* VEX_LEN_73_R_6_P_2 */
8543 { "vpsllq", { Vex128, XS, Ib } },
8544 { "(bad)", { XX } },
8547 /* VEX_LEN_73_R_7_P_2 */
8549 { "vpslldq", { Vex128, XS, Ib } },
8550 { "(bad)", { XX } },
8553 /* VEX_LEN_74_P_2 */
8555 { "vpcmpeqb", { XM, Vex128, EXx } },
8556 { "(bad)", { XX } },
8559 /* VEX_LEN_75_P_2 */
8561 { "vpcmpeqw", { XM, Vex128, EXx } },
8562 { "(bad)", { XX } },
8565 /* VEX_LEN_76_P_2 */
8567 { "vpcmpeqd", { XM, Vex128, EXx } },
8568 { "(bad)", { XX } },
8571 /* VEX_LEN_7E_P_1 */
8573 { "vmovq", { XM, EXq } },
8574 { "(bad)", { XX } },
8577 /* VEX_LEN_7E_P_2 */
8579 { "vmovK", { Edq, XM } },
8580 { "(bad)", { XX } },
8583 /* VEX_LEN_AE_R_2_M_0 */
8585 { "vldmxcsr", { Md } },
8586 { "(bad)", { XX } },
8589 /* VEX_LEN_AE_R_3_M_0 */
8591 { "vstmxcsr", { Md } },
8592 { "(bad)", { XX } },
8595 /* VEX_LEN_C2_P_1 */
8597 { "vcmpss", { XM, Vex128, EXd, VCMP } },
8598 { "(bad)", { XX } },
8601 /* VEX_LEN_C2_P_3 */
8603 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
8604 { "(bad)", { XX } },
8607 /* VEX_LEN_C4_P_2 */
8609 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
8610 { "(bad)", { XX } },
8613 /* VEX_LEN_C5_P_2 */
8615 { "vpextrw", { Gdq, XS, Ib } },
8616 { "(bad)", { XX } },
8619 /* VEX_LEN_D1_P_2 */
8621 { "vpsrlw", { XM, Vex128, EXx } },
8622 { "(bad)", { XX } },
8625 /* VEX_LEN_D2_P_2 */
8627 { "vpsrld", { XM, Vex128, EXx } },
8628 { "(bad)", { XX } },
8631 /* VEX_LEN_D3_P_2 */
8633 { "vpsrlq", { XM, Vex128, EXx } },
8634 { "(bad)", { XX } },
8637 /* VEX_LEN_D4_P_2 */
8639 { "vpaddq", { XM, Vex128, EXx } },
8640 { "(bad)", { XX } },
8643 /* VEX_LEN_D5_P_2 */
8645 { "vpmullw", { XM, Vex128, EXx } },
8646 { "(bad)", { XX } },
8649 /* VEX_LEN_D6_P_2 */
8651 { "vmovq", { EXqS, XM } },
8652 { "(bad)", { XX } },
8655 /* VEX_LEN_D7_P_2_M_1 */
8657 { "vpmovmskb", { Gdq, XS } },
8658 { "(bad)", { XX } },
8661 /* VEX_LEN_D8_P_2 */
8663 { "vpsubusb", { XM, Vex128, EXx } },
8664 { "(bad)", { XX } },
8667 /* VEX_LEN_D9_P_2 */
8669 { "vpsubusw", { XM, Vex128, EXx } },
8670 { "(bad)", { XX } },
8673 /* VEX_LEN_DA_P_2 */
8675 { "vpminub", { XM, Vex128, EXx } },
8676 { "(bad)", { XX } },
8679 /* VEX_LEN_DB_P_2 */
8681 { "vpand", { XM, Vex128, EXx } },
8682 { "(bad)", { XX } },
8685 /* VEX_LEN_DC_P_2 */
8687 { "vpaddusb", { XM, Vex128, EXx } },
8688 { "(bad)", { XX } },
8691 /* VEX_LEN_DD_P_2 */
8693 { "vpaddusw", { XM, Vex128, EXx } },
8694 { "(bad)", { XX } },
8697 /* VEX_LEN_DE_P_2 */
8699 { "vpmaxub", { XM, Vex128, EXx } },
8700 { "(bad)", { XX } },
8703 /* VEX_LEN_DF_P_2 */
8705 { "vpandn", { XM, Vex128, EXx } },
8706 { "(bad)", { XX } },
8709 /* VEX_LEN_E0_P_2 */
8711 { "vpavgb", { XM, Vex128, EXx } },
8712 { "(bad)", { XX } },
8715 /* VEX_LEN_E1_P_2 */
8717 { "vpsraw", { XM, Vex128, EXx } },
8718 { "(bad)", { XX } },
8721 /* VEX_LEN_E2_P_2 */
8723 { "vpsrad", { XM, Vex128, EXx } },
8724 { "(bad)", { XX } },
8727 /* VEX_LEN_E3_P_2 */
8729 { "vpavgw", { XM, Vex128, EXx } },
8730 { "(bad)", { XX } },
8733 /* VEX_LEN_E4_P_2 */
8735 { "vpmulhuw", { XM, Vex128, EXx } },
8736 { "(bad)", { XX } },
8739 /* VEX_LEN_E5_P_2 */
8741 { "vpmulhw", { XM, Vex128, EXx } },
8742 { "(bad)", { XX } },
8745 /* VEX_LEN_E8_P_2 */
8747 { "vpsubsb", { XM, Vex128, EXx } },
8748 { "(bad)", { XX } },
8751 /* VEX_LEN_E9_P_2 */
8753 { "vpsubsw", { XM, Vex128, EXx } },
8754 { "(bad)", { XX } },
8757 /* VEX_LEN_EA_P_2 */
8759 { "vpminsw", { XM, Vex128, EXx } },
8760 { "(bad)", { XX } },
8763 /* VEX_LEN_EB_P_2 */
8765 { "vpor", { XM, Vex128, EXx } },
8766 { "(bad)", { XX } },
8769 /* VEX_LEN_EC_P_2 */
8771 { "vpaddsb", { XM, Vex128, EXx } },
8772 { "(bad)", { XX } },
8775 /* VEX_LEN_ED_P_2 */
8777 { "vpaddsw", { XM, Vex128, EXx } },
8778 { "(bad)", { XX } },
8781 /* VEX_LEN_EE_P_2 */
8783 { "vpmaxsw", { XM, Vex128, EXx } },
8784 { "(bad)", { XX } },
8787 /* VEX_LEN_EF_P_2 */
8789 { "vpxor", { XM, Vex128, EXx } },
8790 { "(bad)", { XX } },
8793 /* VEX_LEN_F1_P_2 */
8795 { "vpsllw", { XM, Vex128, EXx } },
8796 { "(bad)", { XX } },
8799 /* VEX_LEN_F2_P_2 */
8801 { "vpslld", { XM, Vex128, EXx } },
8802 { "(bad)", { XX } },
8805 /* VEX_LEN_F3_P_2 */
8807 { "vpsllq", { XM, Vex128, EXx } },
8808 { "(bad)", { XX } },
8811 /* VEX_LEN_F4_P_2 */
8813 { "vpmuludq", { XM, Vex128, EXx } },
8814 { "(bad)", { XX } },
8817 /* VEX_LEN_F5_P_2 */
8819 { "vpmaddwd", { XM, Vex128, EXx } },
8820 { "(bad)", { XX } },
8823 /* VEX_LEN_F6_P_2 */
8825 { "vpsadbw", { XM, Vex128, EXx } },
8826 { "(bad)", { XX } },
8829 /* VEX_LEN_F7_P_2 */
8831 { "vmaskmovdqu", { XM, XS } },
8832 { "(bad)", { XX } },
8835 /* VEX_LEN_F8_P_2 */
8837 { "vpsubb", { XM, Vex128, EXx } },
8838 { "(bad)", { XX } },
8841 /* VEX_LEN_F9_P_2 */
8843 { "vpsubw", { XM, Vex128, EXx } },
8844 { "(bad)", { XX } },
8847 /* VEX_LEN_FA_P_2 */
8849 { "vpsubd", { XM, Vex128, EXx } },
8850 { "(bad)", { XX } },
8853 /* VEX_LEN_FB_P_2 */
8855 { "vpsubq", { XM, Vex128, EXx } },
8856 { "(bad)", { XX } },
8859 /* VEX_LEN_FC_P_2 */
8861 { "vpaddb", { XM, Vex128, EXx } },
8862 { "(bad)", { XX } },
8865 /* VEX_LEN_FD_P_2 */
8867 { "vpaddw", { XM, Vex128, EXx } },
8868 { "(bad)", { XX } },
8871 /* VEX_LEN_FE_P_2 */
8873 { "vpaddd", { XM, Vex128, EXx } },
8874 { "(bad)", { XX } },
8877 /* VEX_LEN_3800_P_2 */
8879 { "vpshufb", { XM, Vex128, EXx } },
8880 { "(bad)", { XX } },
8883 /* VEX_LEN_3801_P_2 */
8885 { "vphaddw", { XM, Vex128, EXx } },
8886 { "(bad)", { XX } },
8889 /* VEX_LEN_3802_P_2 */
8891 { "vphaddd", { XM, Vex128, EXx } },
8892 { "(bad)", { XX } },
8895 /* VEX_LEN_3803_P_2 */
8897 { "vphaddsw", { XM, Vex128, EXx } },
8898 { "(bad)", { XX } },
8901 /* VEX_LEN_3804_P_2 */
8903 { "vpmaddubsw", { XM, Vex128, EXx } },
8904 { "(bad)", { XX } },
8907 /* VEX_LEN_3805_P_2 */
8909 { "vphsubw", { XM, Vex128, EXx } },
8910 { "(bad)", { XX } },
8913 /* VEX_LEN_3806_P_2 */
8915 { "vphsubd", { XM, Vex128, EXx } },
8916 { "(bad)", { XX } },
8919 /* VEX_LEN_3807_P_2 */
8921 { "vphsubsw", { XM, Vex128, EXx } },
8922 { "(bad)", { XX } },
8925 /* VEX_LEN_3808_P_2 */
8927 { "vpsignb", { XM, Vex128, EXx } },
8928 { "(bad)", { XX } },
8931 /* VEX_LEN_3809_P_2 */
8933 { "vpsignw", { XM, Vex128, EXx } },
8934 { "(bad)", { XX } },
8937 /* VEX_LEN_380A_P_2 */
8939 { "vpsignd", { XM, Vex128, EXx } },
8940 { "(bad)", { XX } },
8943 /* VEX_LEN_380B_P_2 */
8945 { "vpmulhrsw", { XM, Vex128, EXx } },
8946 { "(bad)", { XX } },
8949 /* VEX_LEN_3819_P_2_M_0 */
8951 { "(bad)", { XX } },
8952 { "vbroadcastsd", { XM, Mq } },
8955 /* VEX_LEN_381A_P_2_M_0 */
8957 { "(bad)", { XX } },
8958 { "vbroadcastf128", { XM, Mxmm } },
8961 /* VEX_LEN_381C_P_2 */
8963 { "vpabsb", { XM, EXx } },
8964 { "(bad)", { XX } },
8967 /* VEX_LEN_381D_P_2 */
8969 { "vpabsw", { XM, EXx } },
8970 { "(bad)", { XX } },
8973 /* VEX_LEN_381E_P_2 */
8975 { "vpabsd", { XM, EXx } },
8976 { "(bad)", { XX } },
8979 /* VEX_LEN_3820_P_2 */
8981 { "vpmovsxbw", { XM, EXq } },
8982 { "(bad)", { XX } },
8985 /* VEX_LEN_3821_P_2 */
8987 { "vpmovsxbd", { XM, EXd } },
8988 { "(bad)", { XX } },
8991 /* VEX_LEN_3822_P_2 */
8993 { "vpmovsxbq", { XM, EXw } },
8994 { "(bad)", { XX } },
8997 /* VEX_LEN_3823_P_2 */
8999 { "vpmovsxwd", { XM, EXq } },
9000 { "(bad)", { XX } },
9003 /* VEX_LEN_3824_P_2 */
9005 { "vpmovsxwq", { XM, EXd } },
9006 { "(bad)", { XX } },
9009 /* VEX_LEN_3825_P_2 */
9011 { "vpmovsxdq", { XM, EXq } },
9012 { "(bad)", { XX } },
9015 /* VEX_LEN_3828_P_2 */
9017 { "vpmuldq", { XM, Vex128, EXx } },
9018 { "(bad)", { XX } },
9021 /* VEX_LEN_3829_P_2 */
9023 { "vpcmpeqq", { XM, Vex128, EXx } },
9024 { "(bad)", { XX } },
9027 /* VEX_LEN_382A_P_2_M_0 */
9029 { "vmovntdqa", { XM, Mx } },
9030 { "(bad)", { XX } },
9033 /* VEX_LEN_382B_P_2 */
9035 { "vpackusdw", { XM, Vex128, EXx } },
9036 { "(bad)", { XX } },
9039 /* VEX_LEN_3830_P_2 */
9041 { "vpmovzxbw", { XM, EXq } },
9042 { "(bad)", { XX } },
9045 /* VEX_LEN_3831_P_2 */
9047 { "vpmovzxbd", { XM, EXd } },
9048 { "(bad)", { XX } },
9051 /* VEX_LEN_3832_P_2 */
9053 { "vpmovzxbq", { XM, EXw } },
9054 { "(bad)", { XX } },
9057 /* VEX_LEN_3833_P_2 */
9059 { "vpmovzxwd", { XM, EXq } },
9060 { "(bad)", { XX } },
9063 /* VEX_LEN_3834_P_2 */
9065 { "vpmovzxwq", { XM, EXd } },
9066 { "(bad)", { XX } },
9069 /* VEX_LEN_3835_P_2 */
9071 { "vpmovzxdq", { XM, EXq } },
9072 { "(bad)", { XX } },
9075 /* VEX_LEN_3837_P_2 */
9077 { "vpcmpgtq", { XM, Vex128, EXx } },
9078 { "(bad)", { XX } },
9081 /* VEX_LEN_3838_P_2 */
9083 { "vpminsb", { XM, Vex128, EXx } },
9084 { "(bad)", { XX } },
9087 /* VEX_LEN_3839_P_2 */
9089 { "vpminsd", { XM, Vex128, EXx } },
9090 { "(bad)", { XX } },
9093 /* VEX_LEN_383A_P_2 */
9095 { "vpminuw", { XM, Vex128, EXx } },
9096 { "(bad)", { XX } },
9099 /* VEX_LEN_383B_P_2 */
9101 { "vpminud", { XM, Vex128, EXx } },
9102 { "(bad)", { XX } },
9105 /* VEX_LEN_383C_P_2 */
9107 { "vpmaxsb", { XM, Vex128, EXx } },
9108 { "(bad)", { XX } },
9111 /* VEX_LEN_383D_P_2 */
9113 { "vpmaxsd", { XM, Vex128, EXx } },
9114 { "(bad)", { XX } },
9117 /* VEX_LEN_383E_P_2 */
9119 { "vpmaxuw", { XM, Vex128, EXx } },
9120 { "(bad)", { XX } },
9123 /* VEX_LEN_383F_P_2 */
9125 { "vpmaxud", { XM, Vex128, EXx } },
9126 { "(bad)", { XX } },
9129 /* VEX_LEN_3840_P_2 */
9131 { "vpmulld", { XM, Vex128, EXx } },
9132 { "(bad)", { XX } },
9135 /* VEX_LEN_3841_P_2 */
9137 { "vphminposuw", { XM, EXx } },
9138 { "(bad)", { XX } },
9141 /* VEX_LEN_38DB_P_2 */
9143 { "vaesimc", { XM, EXx } },
9144 { "(bad)", { XX } },
9147 /* VEX_LEN_38DC_P_2 */
9149 { "vaesenc", { XM, Vex128, EXx } },
9150 { "(bad)", { XX } },
9153 /* VEX_LEN_38DD_P_2 */
9155 { "vaesenclast", { XM, Vex128, EXx } },
9156 { "(bad)", { XX } },
9159 /* VEX_LEN_38DE_P_2 */
9161 { "vaesdec", { XM, Vex128, EXx } },
9162 { "(bad)", { XX } },
9165 /* VEX_LEN_38DF_P_2 */
9167 { "vaesdeclast", { XM, Vex128, EXx } },
9168 { "(bad)", { XX } },
9171 /* VEX_LEN_3A06_P_2 */
9173 { "(bad)", { XX } },
9174 { "vperm2f128", { XM, Vex256, EXx, Ib } },
9177 /* VEX_LEN_3A0A_P_2 */
9179 { "vroundss", { XM, Vex128, EXd, Ib } },
9180 { "(bad)", { XX } },
9183 /* VEX_LEN_3A0B_P_2 */
9185 { "vroundsd", { XM, Vex128, EXq, Ib } },
9186 { "(bad)", { XX } },
9189 /* VEX_LEN_3A0E_P_2 */
9191 { "vpblendw", { XM, Vex128, EXx, Ib } },
9192 { "(bad)", { XX } },
9195 /* VEX_LEN_3A0F_P_2 */
9197 { "vpalignr", { XM, Vex128, EXx, Ib } },
9198 { "(bad)", { XX } },
9201 /* VEX_LEN_3A14_P_2 */
9203 { "vpextrb", { Edqb, XM, Ib } },
9204 { "(bad)", { XX } },
9207 /* VEX_LEN_3A15_P_2 */
9209 { "vpextrw", { Edqw, XM, Ib } },
9210 { "(bad)", { XX } },
9213 /* VEX_LEN_3A16_P_2 */
9215 { "vpextrK", { Edq, XM, Ib } },
9216 { "(bad)", { XX } },
9219 /* VEX_LEN_3A17_P_2 */
9221 { "vextractps", { Edqd, XM, Ib } },
9222 { "(bad)", { XX } },
9225 /* VEX_LEN_3A18_P_2 */
9227 { "(bad)", { XX } },
9228 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
9231 /* VEX_LEN_3A19_P_2 */
9233 { "(bad)", { XX } },
9234 { "vextractf128", { EXxmm, XM, Ib } },
9237 /* VEX_LEN_3A20_P_2 */
9239 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
9240 { "(bad)", { XX } },
9243 /* VEX_LEN_3A21_P_2 */
9245 { "vinsertps", { XM, Vex128, EXd, Ib } },
9246 { "(bad)", { XX } },
9249 /* VEX_LEN_3A22_P_2 */
9251 { "vpinsrK", { XM, Vex128, Edq, Ib } },
9252 { "(bad)", { XX } },
9255 /* VEX_LEN_3A41_P_2 */
9257 { "vdppd", { XM, Vex128, EXx, Ib } },
9258 { "(bad)", { XX } },
9261 /* VEX_LEN_3A42_P_2 */
9263 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
9264 { "(bad)", { XX } },
9267 /* VEX_LEN_3A44_P_2 */
9269 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
9270 { "(bad)", { XX } },
9273 /* VEX_LEN_3A4C_P_2 */
9275 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
9276 { "(bad)", { XX } },
9279 /* VEX_LEN_3A60_P_2 */
9281 { "vpcmpestrm", { XM, EXx, Ib } },
9282 { "(bad)", { XX } },
9285 /* VEX_LEN_3A61_P_2 */
9287 { "vpcmpestri", { XM, EXx, Ib } },
9288 { "(bad)", { XX } },
9291 /* VEX_LEN_3A62_P_2 */
9293 { "vpcmpistrm", { XM, EXx, Ib } },
9294 { "(bad)", { XX } },
9297 /* VEX_LEN_3A63_P_2 */
9299 { "vpcmpistri", { XM, EXx, Ib } },
9300 { "(bad)", { XX } },
9303 /* VEX_LEN_3A6A_P_2 */
9305 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9306 { "(bad)", { XX } },
9309 /* VEX_LEN_3A6B_P_2 */
9311 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9312 { "(bad)", { XX } },
9315 /* VEX_LEN_3A6E_P_2 */
9317 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9318 { "(bad)", { XX } },
9321 /* VEX_LEN_3A6F_P_2 */
9323 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9324 { "(bad)", { XX } },
9327 /* VEX_LEN_3A7A_P_2 */
9329 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9330 { "(bad)", { XX } },
9333 /* VEX_LEN_3A7B_P_2 */
9335 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9336 { "(bad)", { XX } },
9339 /* VEX_LEN_3A7E_P_2 */
9341 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9342 { "(bad)", { XX } },
9345 /* VEX_LEN_3A7F_P_2 */
9347 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9348 { "(bad)", { XX } },
9351 /* VEX_LEN_3ADF_P_2 */
9353 { "vaeskeygenassist", { XM, EXx, Ib } },
9354 { "(bad)", { XX } },
9356 /* VEX_LEN_XOP_08_A0 */
9358 { "vcvtph2ps", { XM, EXq, Ib } },
9359 { "vcvtph2ps", { XM, EXxmm, Ib } },
9361 /* VEX_LEN_XOP_08_A1 */
9363 { "vcvtps2ph", { EXq, XM, Ib } },
9364 { "vcvtps2ph", { EXxmm, XM, Ib } },
9366 /* VEX_LEN_XOP_09_80 */
9368 { "vfrczps", { XM, EXxmm } },
9369 { "vfrczps", { XM, EXymmq } },
9371 /* VEX_LEN_XOP_09_81 */
9373 { "vfrczpd", { XM, EXxmm } },
9374 { "vfrczpd", { XM, EXymmq } },
9378 static const struct dis386 mod_table[][2] = {
9381 { "leaS", { Gv, M } },
9382 { "(bad)", { XX } },
9385 /* MOD_0F01_REG_0 */
9386 { X86_64_TABLE (X86_64_0F01_REG_0) },
9387 { RM_TABLE (RM_0F01_REG_0) },
9390 /* MOD_0F01_REG_1 */
9391 { X86_64_TABLE (X86_64_0F01_REG_1) },
9392 { RM_TABLE (RM_0F01_REG_1) },
9395 /* MOD_0F01_REG_2 */
9396 { X86_64_TABLE (X86_64_0F01_REG_2) },
9397 { RM_TABLE (RM_0F01_REG_2) },
9400 /* MOD_0F01_REG_3 */
9401 { X86_64_TABLE (X86_64_0F01_REG_3) },
9402 { RM_TABLE (RM_0F01_REG_3) },
9405 /* MOD_0F01_REG_7 */
9406 { "invlpg", { Mb } },
9407 { RM_TABLE (RM_0F01_REG_7) },
9410 /* MOD_0F12_PREFIX_0 */
9411 { "movlps", { XM, EXq } },
9412 { "movhlps", { XM, EXq } },
9416 { "movlpX", { EXq, XM } },
9417 { "(bad)", { XX } },
9420 /* MOD_0F16_PREFIX_0 */
9421 { "movhps", { XM, EXq } },
9422 { "movlhps", { XM, EXq } },
9426 { "movhpX", { EXq, XM } },
9427 { "(bad)", { XX } },
9430 /* MOD_0F18_REG_0 */
9431 { "prefetchnta", { Mb } },
9432 { "(bad)", { XX } },
9435 /* MOD_0F18_REG_1 */
9436 { "prefetcht0", { Mb } },
9437 { "(bad)", { XX } },
9440 /* MOD_0F18_REG_2 */
9441 { "prefetcht1", { Mb } },
9442 { "(bad)", { XX } },
9445 /* MOD_0F18_REG_3 */
9446 { "prefetcht2", { Mb } },
9447 { "(bad)", { XX } },
9451 { "(bad)", { XX } },
9452 { "movZ", { Rm, Cm } },
9456 { "(bad)", { XX } },
9457 { "movZ", { Rm, Dm } },
9461 { "(bad)", { XX } },
9462 { "movZ", { Cm, Rm } },
9466 { "(bad)", { XX } },
9467 { "movZ", { Dm, Rm } },
9471 { "(bad)", { XX } },
9472 { "movL", { Rd, Td } },
9476 { "(bad)", { XX } },
9477 { "movL", { Td, Rd } },
9480 /* MOD_0F2B_PREFIX_0 */
9481 {"movntps", { Mx, XM } },
9482 { "(bad)", { XX } },
9485 /* MOD_0F2B_PREFIX_1 */
9486 {"movntss", { Md, XM } },
9487 { "(bad)", { XX } },
9490 /* MOD_0F2B_PREFIX_2 */
9491 {"movntpd", { Mx, XM } },
9492 { "(bad)", { XX } },
9495 /* MOD_0F2B_PREFIX_3 */
9496 {"movntsd", { Mq, XM } },
9497 { "(bad)", { XX } },
9501 { "(bad)", { XX } },
9502 { "movmskpX", { Gdq, XS } },
9505 /* MOD_0F71_REG_2 */
9506 { "(bad)", { XX } },
9507 { "psrlw", { MS, Ib } },
9510 /* MOD_0F71_REG_4 */
9511 { "(bad)", { XX } },
9512 { "psraw", { MS, Ib } },
9515 /* MOD_0F71_REG_6 */
9516 { "(bad)", { XX } },
9517 { "psllw", { MS, Ib } },
9520 /* MOD_0F72_REG_2 */
9521 { "(bad)", { XX } },
9522 { "psrld", { MS, Ib } },
9525 /* MOD_0F72_REG_4 */
9526 { "(bad)", { XX } },
9527 { "psrad", { MS, Ib } },
9530 /* MOD_0F72_REG_6 */
9531 { "(bad)", { XX } },
9532 { "pslld", { MS, Ib } },
9535 /* MOD_0F73_REG_2 */
9536 { "(bad)", { XX } },
9537 { "psrlq", { MS, Ib } },
9540 /* MOD_0F73_REG_3 */
9541 { "(bad)", { XX } },
9542 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
9545 /* MOD_0F73_REG_6 */
9546 { "(bad)", { XX } },
9547 { "psllq", { MS, Ib } },
9550 /* MOD_0F73_REG_7 */
9551 { "(bad)", { XX } },
9552 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
9555 /* MOD_0FAE_REG_0 */
9556 { "fxsave", { M } },
9557 { "(bad)", { XX } },
9560 /* MOD_0FAE_REG_1 */
9561 { "fxrstor", { M } },
9562 { "(bad)", { XX } },
9565 /* MOD_0FAE_REG_2 */
9566 { "ldmxcsr", { Md } },
9567 { "(bad)", { XX } },
9570 /* MOD_0FAE_REG_3 */
9571 { "stmxcsr", { Md } },
9572 { "(bad)", { XX } },
9575 /* MOD_0FAE_REG_4 */
9577 { "(bad)", { XX } },
9580 /* MOD_0FAE_REG_5 */
9581 { "xrstor", { M } },
9582 { RM_TABLE (RM_0FAE_REG_5) },
9585 /* MOD_0FAE_REG_6 */
9586 { "xsaveopt", { M } },
9587 { RM_TABLE (RM_0FAE_REG_6) },
9590 /* MOD_0FAE_REG_7 */
9591 { "clflush", { Mb } },
9592 { RM_TABLE (RM_0FAE_REG_7) },
9596 { "lssS", { Gv, Mp } },
9597 { "(bad)", { XX } },
9601 { "lfsS", { Gv, Mp } },
9602 { "(bad)", { XX } },
9606 { "lgsS", { Gv, Mp } },
9607 { "(bad)", { XX } },
9610 /* MOD_0FC7_REG_6 */
9611 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
9612 { "(bad)", { XX } },
9615 /* MOD_0FC7_REG_7 */
9616 { "vmptrst", { Mq } },
9617 { "(bad)", { XX } },
9621 { "(bad)", { XX } },
9622 { "pmovmskb", { Gdq, MS } },
9625 /* MOD_0FE7_PREFIX_2 */
9626 { "movntdq", { Mx, XM } },
9627 { "(bad)", { XX } },
9630 /* MOD_0FF0_PREFIX_3 */
9631 { "lddqu", { XM, M } },
9632 { "(bad)", { XX } },
9635 /* MOD_0F382A_PREFIX_2 */
9636 { "movntdqa", { XM, Mx } },
9637 { "(bad)", { XX } },
9641 { "bound{S|}", { Gv, Ma } },
9642 { "(bad)", { XX } },
9646 { "lesS", { Gv, Mp } },
9647 { VEX_C4_TABLE (VEX_0F) },
9651 { "ldsS", { Gv, Mp } },
9652 { VEX_C5_TABLE (VEX_0F) },
9655 /* MOD_VEX_12_PREFIX_0 */
9656 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
9657 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
9661 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
9662 { "(bad)", { XX } },
9665 /* MOD_VEX_16_PREFIX_0 */
9666 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
9667 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
9671 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
9672 { "(bad)", { XX } },
9676 { "vmovntpX", { Mx, XM } },
9677 { "(bad)", { XX } },
9681 { "(bad)", { XX } },
9682 { "vmovmskpX", { Gdq, XS } },
9685 /* MOD_VEX_71_REG_2 */
9686 { "(bad)", { XX } },
9687 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
9690 /* MOD_VEX_71_REG_4 */
9691 { "(bad)", { XX } },
9692 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
9695 /* MOD_VEX_71_REG_6 */
9696 { "(bad)", { XX } },
9697 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
9700 /* MOD_VEX_72_REG_2 */
9701 { "(bad)", { XX } },
9702 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
9705 /* MOD_VEX_72_REG_4 */
9706 { "(bad)", { XX } },
9707 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
9710 /* MOD_VEX_72_REG_6 */
9711 { "(bad)", { XX } },
9712 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
9715 /* MOD_VEX_73_REG_2 */
9716 { "(bad)", { XX } },
9717 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
9720 /* MOD_VEX_73_REG_3 */
9721 { "(bad)", { XX } },
9722 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
9725 /* MOD_VEX_73_REG_6 */
9726 { "(bad)", { XX } },
9727 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
9730 /* MOD_VEX_73_REG_7 */
9731 { "(bad)", { XX } },
9732 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
9735 /* MOD_VEX_AE_REG_2 */
9736 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
9737 { "(bad)", { XX } },
9740 /* MOD_VEX_AE_REG_3 */
9741 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
9742 { "(bad)", { XX } },
9745 /* MOD_VEX_D7_PREFIX_2 */
9746 { "(bad)", { XX } },
9747 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
9750 /* MOD_VEX_E7_PREFIX_2 */
9751 { "vmovntdq", { Mx, XM } },
9752 { "(bad)", { XX } },
9755 /* MOD_VEX_F0_PREFIX_3 */
9756 { "vlddqu", { XM, M } },
9757 { "(bad)", { XX } },
9760 /* MOD_VEX_3818_PREFIX_2 */
9761 { "vbroadcastss", { XM, Md } },
9762 { "(bad)", { XX } },
9765 /* MOD_VEX_3819_PREFIX_2 */
9766 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
9767 { "(bad)", { XX } },
9770 /* MOD_VEX_381A_PREFIX_2 */
9771 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
9772 { "(bad)", { XX } },
9775 /* MOD_VEX_382A_PREFIX_2 */
9776 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
9777 { "(bad)", { XX } },
9780 /* MOD_VEX_382C_PREFIX_2 */
9781 { "vmaskmovps", { XM, Vex, Mx } },
9782 { "(bad)", { XX } },
9785 /* MOD_VEX_382D_PREFIX_2 */
9786 { "vmaskmovpd", { XM, Vex, Mx } },
9787 { "(bad)", { XX } },
9790 /* MOD_VEX_382E_PREFIX_2 */
9791 { "vmaskmovps", { Mx, Vex, XM } },
9792 { "(bad)", { XX } },
9795 /* MOD_VEX_382F_PREFIX_2 */
9796 { "vmaskmovpd", { Mx, Vex, XM } },
9797 { "(bad)", { XX } },
9801 static const struct dis386 rm_table[][8] = {
9804 { "(bad)", { XX } },
9805 { "vmcall", { Skip_MODRM } },
9806 { "vmlaunch", { Skip_MODRM } },
9807 { "vmresume", { Skip_MODRM } },
9808 { "vmxoff", { Skip_MODRM } },
9809 { "(bad)", { XX } },
9810 { "(bad)", { XX } },
9811 { "(bad)", { XX } },
9815 { "monitor", { { OP_Monitor, 0 } } },
9816 { "mwait", { { OP_Mwait, 0 } } },
9817 { "(bad)", { XX } },
9818 { "(bad)", { XX } },
9819 { "(bad)", { XX } },
9820 { "(bad)", { XX } },
9821 { "(bad)", { XX } },
9822 { "(bad)", { XX } },
9826 { "xgetbv", { Skip_MODRM } },
9827 { "xsetbv", { Skip_MODRM } },
9828 { "(bad)", { XX } },
9829 { "(bad)", { XX } },
9830 { "(bad)", { XX } },
9831 { "(bad)", { XX } },
9832 { "(bad)", { XX } },
9833 { "(bad)", { XX } },
9837 { "vmrun", { Skip_MODRM } },
9838 { "vmmcall", { Skip_MODRM } },
9839 { "vmload", { Skip_MODRM } },
9840 { "vmsave", { Skip_MODRM } },
9841 { "stgi", { Skip_MODRM } },
9842 { "clgi", { Skip_MODRM } },
9843 { "skinit", { Skip_MODRM } },
9844 { "invlpga", { Skip_MODRM } },
9848 { "swapgs", { Skip_MODRM } },
9849 { "rdtscp", { Skip_MODRM } },
9850 { "(bad)", { XX } },
9851 { "(bad)", { XX } },
9852 { "(bad)", { XX } },
9853 { "(bad)", { XX } },
9854 { "(bad)", { XX } },
9855 { "(bad)", { XX } },
9859 { "lfence", { Skip_MODRM } },
9860 { "(bad)", { XX } },
9861 { "(bad)", { XX } },
9862 { "(bad)", { XX } },
9863 { "(bad)", { XX } },
9864 { "(bad)", { XX } },
9865 { "(bad)", { XX } },
9866 { "(bad)", { XX } },
9870 { "mfence", { Skip_MODRM } },
9871 { "(bad)", { XX } },
9872 { "(bad)", { XX } },
9873 { "(bad)", { XX } },
9874 { "(bad)", { XX } },
9875 { "(bad)", { XX } },
9876 { "(bad)", { XX } },
9877 { "(bad)", { XX } },
9881 { "sfence", { Skip_MODRM } },
9882 { "(bad)", { XX } },
9883 { "(bad)", { XX } },
9884 { "(bad)", { XX } },
9885 { "(bad)", { XX } },
9886 { "(bad)", { XX } },
9887 { "(bad)", { XX } },
9888 { "(bad)", { XX } },
9892 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9894 /* We use the high bit to indicate different name for the same
9896 #define ADDR16_PREFIX (0x67 | 0x100)
9897 #define ADDR32_PREFIX (0x67 | 0x200)
9898 #define DATA16_PREFIX (0x66 | 0x100)
9899 #define DATA32_PREFIX (0x66 | 0x200)
9900 #define REP_PREFIX (0xf3 | 0x100)
9905 int newrex, i, length;
9912 last_lock_prefix = -1;
9913 last_repz_prefix = -1;
9914 last_repnz_prefix = -1;
9915 last_data_prefix = -1;
9916 last_addr_prefix = -1;
9917 last_rex_prefix = -1;
9918 last_seg_prefix = -1;
9919 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
9920 all_prefixes[i] = 0;
9923 /* The maximum instruction length is 15bytes. */
9924 while (length < MAX_CODE_LENGTH - 1)
9926 FETCH_DATA (the_info, codep + 1);
9930 /* REX prefixes family. */
9947 if (address_mode == mode_64bit)
9951 last_rex_prefix = i;
9954 prefixes |= PREFIX_REPZ;
9955 last_repz_prefix = i;
9958 prefixes |= PREFIX_REPNZ;
9959 last_repnz_prefix = i;
9962 prefixes |= PREFIX_LOCK;
9963 last_lock_prefix = i;
9966 prefixes |= PREFIX_CS;
9967 last_seg_prefix = i;
9970 prefixes |= PREFIX_SS;
9971 last_seg_prefix = i;
9974 prefixes |= PREFIX_DS;
9975 last_seg_prefix = i;
9978 prefixes |= PREFIX_ES;
9979 last_seg_prefix = i;
9982 prefixes |= PREFIX_FS;
9983 last_seg_prefix = i;
9986 prefixes |= PREFIX_GS;
9987 last_seg_prefix = i;
9990 prefixes |= PREFIX_DATA;
9991 last_data_prefix = i;
9994 prefixes |= PREFIX_ADDR;
9995 last_addr_prefix = i;
9998 /* fwait is really an instruction. If there are prefixes
9999 before the fwait, they belong to the fwait, *not* to the
10000 following instruction. */
10001 if (prefixes || rex)
10003 prefixes |= PREFIX_FWAIT;
10007 prefixes = PREFIX_FWAIT;
10012 /* Rex is ignored when followed by another prefix. */
10018 if (*codep != FWAIT_OPCODE)
10019 all_prefixes[i++] = *codep;
10021 rex_original = rex;
10029 seg_prefix (int pref)
10050 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
10053 static const char *
10054 prefix_name (int pref, int sizeflag)
10056 static const char *rexes [16] =
10059 "rex.B", /* 0x41 */
10060 "rex.X", /* 0x42 */
10061 "rex.XB", /* 0x43 */
10062 "rex.R", /* 0x44 */
10063 "rex.RB", /* 0x45 */
10064 "rex.RX", /* 0x46 */
10065 "rex.RXB", /* 0x47 */
10066 "rex.W", /* 0x48 */
10067 "rex.WB", /* 0x49 */
10068 "rex.WX", /* 0x4a */
10069 "rex.WXB", /* 0x4b */
10070 "rex.WR", /* 0x4c */
10071 "rex.WRB", /* 0x4d */
10072 "rex.WRX", /* 0x4e */
10073 "rex.WRXB", /* 0x4f */
10078 /* REX prefixes family. */
10095 return rexes [pref - 0x40];
10115 return (sizeflag & DFLAG) ? "data16" : "data32";
10117 if (address_mode == mode_64bit)
10118 return (sizeflag & AFLAG) ? "addr32" : "addr64";
10120 return (sizeflag & AFLAG) ? "addr16" : "addr32";
10123 case ADDR16_PREFIX:
10125 case ADDR32_PREFIX:
10127 case DATA16_PREFIX:
10129 case DATA32_PREFIX:
10138 static char op_out[MAX_OPERANDS][100];
10139 static int op_ad, op_index[MAX_OPERANDS];
10140 static int two_source_ops;
10141 static bfd_vma op_address[MAX_OPERANDS];
10142 static bfd_vma op_riprel[MAX_OPERANDS];
10143 static bfd_vma start_pc;
10146 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
10147 * (see topic "Redundant prefixes" in the "Differences from 8086"
10148 * section of the "Virtual 8086 Mode" chapter.)
10149 * 'pc' should be the address of this instruction, it will
10150 * be used to print the target address if this is a relative jump or call
10151 * The function returns the length of this instruction in bytes.
10154 static char intel_syntax;
10155 static char intel_mnemonic = !SYSV386_COMPAT;
10156 static char open_char;
10157 static char close_char;
10158 static char separator_char;
10159 static char scale_char;
10161 /* Here for backwards compatibility. When gdb stops using
10162 print_insn_i386_att and print_insn_i386_intel these functions can
10163 disappear, and print_insn_i386 be merged into print_insn. */
10165 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
10169 return print_insn (pc, info);
10173 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
10177 return print_insn (pc, info);
10181 print_insn_i386 (bfd_vma pc, disassemble_info *info)
10185 return print_insn (pc, info);
10189 print_i386_disassembler_options (FILE *stream)
10191 fprintf (stream, _("\n\
10192 The following i386/x86-64 specific disassembler options are supported for use\n\
10193 with the -M switch (multiple options should be separated by commas):\n"));
10195 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
10196 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
10197 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
10198 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
10199 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
10200 fprintf (stream, _(" att-mnemonic\n"
10201 " Display instruction in AT&T mnemonic\n"));
10202 fprintf (stream, _(" intel-mnemonic\n"
10203 " Display instruction in Intel mnemonic\n"));
10204 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
10205 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
10206 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
10207 fprintf (stream, _(" data32 Assume 32bit data size\n"));
10208 fprintf (stream, _(" data16 Assume 16bit data size\n"));
10209 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
10212 /* Get a pointer to struct dis386 with a valid name. */
10214 static const struct dis386 *
10215 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
10217 int index, vex_table_index;
10219 if (dp->name != NULL)
10222 switch (dp->op[0].bytemode)
10224 case USE_REG_TABLE:
10225 dp = ®_table[dp->op[1].bytemode][modrm.reg];
10228 case USE_MOD_TABLE:
10229 index = modrm.mod == 0x3 ? 1 : 0;
10230 dp = &mod_table[dp->op[1].bytemode][index];
10234 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
10237 case USE_PREFIX_TABLE:
10240 /* The prefix in VEX is implicit. */
10241 switch (vex.prefix)
10246 case REPE_PREFIX_OPCODE:
10249 case DATA_PREFIX_OPCODE:
10252 case REPNE_PREFIX_OPCODE:
10263 used_prefixes |= (prefixes & PREFIX_REPZ);
10264 if (prefixes & PREFIX_REPZ)
10267 all_prefixes[last_repz_prefix] = 0;
10271 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
10273 used_prefixes |= (prefixes & PREFIX_REPNZ);
10274 if (prefixes & PREFIX_REPNZ)
10277 all_prefixes[last_repnz_prefix] = 0;
10281 used_prefixes |= (prefixes & PREFIX_DATA);
10282 if (prefixes & PREFIX_DATA)
10285 all_prefixes[last_data_prefix] = 0;
10290 dp = &prefix_table[dp->op[1].bytemode][index];
10293 case USE_X86_64_TABLE:
10294 index = address_mode == mode_64bit ? 1 : 0;
10295 dp = &x86_64_table[dp->op[1].bytemode][index];
10298 case USE_3BYTE_TABLE:
10299 FETCH_DATA (info, codep + 2);
10301 dp = &three_byte_table[dp->op[1].bytemode][index];
10302 modrm.mod = (*codep >> 6) & 3;
10303 modrm.reg = (*codep >> 3) & 7;
10304 modrm.rm = *codep & 7;
10307 case USE_VEX_LEN_TABLE:
10311 switch (vex.length)
10324 dp = &vex_len_table[dp->op[1].bytemode][index];
10327 case USE_XOP_8F_TABLE:
10328 FETCH_DATA (info, codep + 3);
10329 /* All bits in the REX prefix are ignored. */
10331 rex = ~(*codep >> 5) & 0x7;
10333 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10334 switch ((*codep & 0x1f))
10339 vex_table_index = XOP_08;
10342 vex_table_index = XOP_09;
10345 vex_table_index = XOP_0A;
10349 vex.w = *codep & 0x80;
10350 if (vex.w && address_mode == mode_64bit)
10353 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10354 if (address_mode != mode_64bit
10355 && vex.register_specifier > 0x7)
10358 vex.length = (*codep & 0x4) ? 256 : 128;
10359 switch ((*codep & 0x3))
10365 vex.prefix = DATA_PREFIX_OPCODE;
10368 vex.prefix = REPE_PREFIX_OPCODE;
10371 vex.prefix = REPNE_PREFIX_OPCODE;
10378 dp = &xop_table[vex_table_index][index];
10380 FETCH_DATA (info, codep + 1);
10381 modrm.mod = (*codep >> 6) & 3;
10382 modrm.reg = (*codep >> 3) & 7;
10383 modrm.rm = *codep & 7;
10386 case USE_VEX_C4_TABLE:
10387 FETCH_DATA (info, codep + 3);
10388 /* All bits in the REX prefix are ignored. */
10390 rex = ~(*codep >> 5) & 0x7;
10391 switch ((*codep & 0x1f))
10396 vex_table_index = VEX_0F;
10399 vex_table_index = VEX_0F38;
10402 vex_table_index = VEX_0F3A;
10406 vex.w = *codep & 0x80;
10407 if (vex.w && address_mode == mode_64bit)
10410 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10411 if (address_mode != mode_64bit
10412 && vex.register_specifier > 0x7)
10415 vex.length = (*codep & 0x4) ? 256 : 128;
10416 switch ((*codep & 0x3))
10422 vex.prefix = DATA_PREFIX_OPCODE;
10425 vex.prefix = REPE_PREFIX_OPCODE;
10428 vex.prefix = REPNE_PREFIX_OPCODE;
10435 dp = &vex_table[vex_table_index][index];
10436 /* There is no MODRM byte for VEX [82|77]. */
10437 if (index != 0x77 && index != 0x82)
10439 FETCH_DATA (info, codep + 1);
10440 modrm.mod = (*codep >> 6) & 3;
10441 modrm.reg = (*codep >> 3) & 7;
10442 modrm.rm = *codep & 7;
10446 case USE_VEX_C5_TABLE:
10447 FETCH_DATA (info, codep + 2);
10448 /* All bits in the REX prefix are ignored. */
10450 rex = (*codep & 0x80) ? 0 : REX_R;
10452 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10453 if (address_mode != mode_64bit
10454 && vex.register_specifier > 0x7)
10457 vex.length = (*codep & 0x4) ? 256 : 128;
10458 switch ((*codep & 0x3))
10464 vex.prefix = DATA_PREFIX_OPCODE;
10467 vex.prefix = REPE_PREFIX_OPCODE;
10470 vex.prefix = REPNE_PREFIX_OPCODE;
10477 dp = &vex_table[dp->op[1].bytemode][index];
10478 /* There is no MODRM byte for VEX [82|77]. */
10479 if (index != 0x77 && index != 0x82)
10481 FETCH_DATA (info, codep + 1);
10482 modrm.mod = (*codep >> 6) & 3;
10483 modrm.reg = (*codep >> 3) & 7;
10484 modrm.rm = *codep & 7;
10492 if (dp->name != NULL)
10495 return get_valid_dis386 (dp, info);
10499 print_insn (bfd_vma pc, disassemble_info *info)
10501 const struct dis386 *dp;
10503 char *op_txt[MAX_OPERANDS];
10507 struct dis_private priv;
10510 int default_prefixes;
10512 if (info->mach == bfd_mach_x86_64_intel_syntax
10513 || info->mach == bfd_mach_x86_64
10514 || info->mach == bfd_mach_l1om
10515 || info->mach == bfd_mach_l1om_intel_syntax)
10516 address_mode = mode_64bit;
10518 address_mode = mode_32bit;
10520 if (intel_syntax == (char) -1)
10521 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
10522 || info->mach == bfd_mach_x86_64_intel_syntax
10523 || info->mach == bfd_mach_l1om_intel_syntax);
10525 if (info->mach == bfd_mach_i386_i386
10526 || info->mach == bfd_mach_x86_64
10527 || info->mach == bfd_mach_l1om
10528 || info->mach == bfd_mach_i386_i386_intel_syntax
10529 || info->mach == bfd_mach_x86_64_intel_syntax
10530 || info->mach == bfd_mach_l1om_intel_syntax)
10531 priv.orig_sizeflag = AFLAG | DFLAG;
10532 else if (info->mach == bfd_mach_i386_i8086)
10533 priv.orig_sizeflag = 0;
10537 for (p = info->disassembler_options; p != NULL; )
10539 if (CONST_STRNEQ (p, "x86-64"))
10541 address_mode = mode_64bit;
10542 priv.orig_sizeflag = AFLAG | DFLAG;
10544 else if (CONST_STRNEQ (p, "i386"))
10546 address_mode = mode_32bit;
10547 priv.orig_sizeflag = AFLAG | DFLAG;
10549 else if (CONST_STRNEQ (p, "i8086"))
10551 address_mode = mode_16bit;
10552 priv.orig_sizeflag = 0;
10554 else if (CONST_STRNEQ (p, "intel"))
10557 if (CONST_STRNEQ (p + 5, "-mnemonic"))
10558 intel_mnemonic = 1;
10560 else if (CONST_STRNEQ (p, "att"))
10563 if (CONST_STRNEQ (p + 3, "-mnemonic"))
10564 intel_mnemonic = 0;
10566 else if (CONST_STRNEQ (p, "addr"))
10568 if (address_mode == mode_64bit)
10570 if (p[4] == '3' && p[5] == '2')
10571 priv.orig_sizeflag &= ~AFLAG;
10572 else if (p[4] == '6' && p[5] == '4')
10573 priv.orig_sizeflag |= AFLAG;
10577 if (p[4] == '1' && p[5] == '6')
10578 priv.orig_sizeflag &= ~AFLAG;
10579 else if (p[4] == '3' && p[5] == '2')
10580 priv.orig_sizeflag |= AFLAG;
10583 else if (CONST_STRNEQ (p, "data"))
10585 if (p[4] == '1' && p[5] == '6')
10586 priv.orig_sizeflag &= ~DFLAG;
10587 else if (p[4] == '3' && p[5] == '2')
10588 priv.orig_sizeflag |= DFLAG;
10590 else if (CONST_STRNEQ (p, "suffix"))
10591 priv.orig_sizeflag |= SUFFIX_ALWAYS;
10593 p = strchr (p, ',');
10600 names64 = intel_names64;
10601 names32 = intel_names32;
10602 names16 = intel_names16;
10603 names8 = intel_names8;
10604 names8rex = intel_names8rex;
10605 names_seg = intel_names_seg;
10606 index64 = intel_index64;
10607 index32 = intel_index32;
10608 index16 = intel_index16;
10611 separator_char = '+';
10616 names64 = att_names64;
10617 names32 = att_names32;
10618 names16 = att_names16;
10619 names8 = att_names8;
10620 names8rex = att_names8rex;
10621 names_seg = att_names_seg;
10622 index64 = att_index64;
10623 index32 = att_index32;
10624 index16 = att_index16;
10627 separator_char = ',';
10631 /* The output looks better if we put 7 bytes on a line, since that
10632 puts most long word instructions on a single line. Use 8 bytes
10634 if (info->mach == bfd_mach_l1om
10635 || info->mach == bfd_mach_l1om_intel_syntax)
10636 info->bytes_per_line = 8;
10638 info->bytes_per_line = 7;
10640 info->private_data = &priv;
10641 priv.max_fetched = priv.the_buffer;
10642 priv.insn_start = pc;
10645 for (i = 0; i < MAX_OPERANDS; ++i)
10653 start_codep = priv.the_buffer;
10654 codep = priv.the_buffer;
10656 if (setjmp (priv.bailout) != 0)
10660 /* Getting here means we tried for data but didn't get it. That
10661 means we have an incomplete instruction of some sort. Just
10662 print the first byte as a prefix or a .byte pseudo-op. */
10663 if (codep > priv.the_buffer)
10665 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
10667 (*info->fprintf_func) (info->stream, "%s", name);
10670 /* Just print the first byte as a .byte instruction. */
10671 (*info->fprintf_func) (info->stream, ".byte 0x%x",
10672 (unsigned int) priv.the_buffer[0]);
10682 sizeflag = priv.orig_sizeflag;
10684 if (!ckprefix () || rex_used)
10686 /* Too many prefixes or unused REX prefixes. */
10688 all_prefixes[i] && i < (int) ARRAY_SIZE (all_prefixes);
10690 (*info->fprintf_func) (info->stream, "%s",
10691 prefix_name (all_prefixes[i], sizeflag));
10695 insn_codep = codep;
10697 FETCH_DATA (info, codep + 1);
10698 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
10700 if (((prefixes & PREFIX_FWAIT)
10701 && ((*codep < 0xd8) || (*codep > 0xdf))))
10703 (*info->fprintf_func) (info->stream, "fwait");
10709 if (*codep == 0x0f)
10711 unsigned char threebyte;
10712 FETCH_DATA (info, codep + 2);
10713 threebyte = *++codep;
10714 dp = &dis386_twobyte[threebyte];
10715 need_modrm = twobyte_has_modrm[*codep];
10720 dp = &dis386[*codep];
10721 need_modrm = onebyte_has_modrm[*codep];
10725 if ((prefixes & PREFIX_REPZ))
10726 used_prefixes |= PREFIX_REPZ;
10727 if ((prefixes & PREFIX_REPNZ))
10728 used_prefixes |= PREFIX_REPNZ;
10729 if ((prefixes & PREFIX_LOCK))
10730 used_prefixes |= PREFIX_LOCK;
10732 default_prefixes = 0;
10733 if (prefixes & PREFIX_ADDR)
10736 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
10738 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
10739 all_prefixes[last_addr_prefix] = ADDR32_PREFIX;
10741 all_prefixes[last_addr_prefix] = ADDR16_PREFIX;
10742 default_prefixes |= PREFIX_ADDR;
10746 if ((prefixes & PREFIX_DATA))
10749 if (dp->op[2].bytemode == cond_jump_mode
10750 && dp->op[0].bytemode == v_mode
10753 if (sizeflag & DFLAG)
10754 all_prefixes[last_data_prefix] = DATA32_PREFIX;
10756 all_prefixes[last_data_prefix] = DATA16_PREFIX;
10757 default_prefixes |= PREFIX_DATA;
10759 else if (rex & REX_W)
10761 /* REX_W will override PREFIX_DATA. */
10762 default_prefixes |= PREFIX_DATA;
10768 FETCH_DATA (info, codep + 1);
10769 modrm.mod = (*codep >> 6) & 3;
10770 modrm.reg = (*codep >> 3) & 7;
10771 modrm.rm = *codep & 7;
10778 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
10780 dofloat (sizeflag);
10784 dp = get_valid_dis386 (dp, info);
10785 if (dp != NULL && putop (dp->name, sizeflag) == 0)
10787 for (i = 0; i < MAX_OPERANDS; ++i)
10790 op_ad = MAX_OPERANDS - 1 - i;
10792 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
10797 /* See if any prefixes were not used. If so, print the first one
10798 separately. If we don't do this, we'll wind up printing an
10799 instruction stream which does not precisely correspond to the
10800 bytes we are disassembling. */
10801 if ((prefixes & ~(used_prefixes | default_prefixes)) != 0)
10803 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
10804 if (all_prefixes[i])
10807 name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
10809 name = INTERNAL_DISASSEMBLER_ERROR;
10810 (*info->fprintf_func) (info->stream, "%s", name);
10815 /* Check if the REX prefix used. */
10816 if (rex_ignored == 0 && (rex ^ rex_used) == 0)
10817 all_prefixes[last_rex_prefix] = 0;
10819 /* Check if the SEG prefix used. */
10820 if ((prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
10821 | PREFIX_FS | PREFIX_GS)) != 0
10823 & seg_prefix (all_prefixes[last_seg_prefix])) != 0)
10824 all_prefixes[last_seg_prefix] = 0;
10826 /* Check if the ADDR prefix used. */
10827 if ((prefixes & PREFIX_ADDR) != 0
10828 && (used_prefixes & PREFIX_ADDR) != 0)
10829 all_prefixes[last_addr_prefix] = 0;
10831 /* Check if the DATA prefix used. */
10832 if ((prefixes & PREFIX_DATA) != 0
10833 && (used_prefixes & PREFIX_DATA) != 0)
10834 all_prefixes[last_data_prefix] = 0;
10837 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
10838 if (all_prefixes[i])
10841 name = prefix_name (all_prefixes[i], sizeflag);
10844 prefix_length += strlen (name) + 1;
10845 (*info->fprintf_func) (info->stream, "%s ", name);
10848 /* Check maximum code length. */
10849 if ((codep - start_codep) > MAX_CODE_LENGTH)
10851 (*info->fprintf_func) (info->stream, "(bad)");
10852 return MAX_CODE_LENGTH;
10855 obufp = mnemonicendp;
10856 for (i = strlen (obuf) + prefix_length; i < 6; i++)
10859 (*info->fprintf_func) (info->stream, "%s", obuf);
10861 /* The enter and bound instructions are printed with operands in the same
10862 order as the intel book; everything else is printed in reverse order. */
10863 if (intel_syntax || two_source_ops)
10867 for (i = 0; i < MAX_OPERANDS; ++i)
10868 op_txt[i] = op_out[i];
10870 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
10872 op_ad = op_index[i];
10873 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
10874 op_index[MAX_OPERANDS - 1 - i] = op_ad;
10875 riprel = op_riprel[i];
10876 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
10877 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10882 for (i = 0; i < MAX_OPERANDS; ++i)
10883 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
10887 for (i = 0; i < MAX_OPERANDS; ++i)
10891 (*info->fprintf_func) (info->stream, ",");
10892 if (op_index[i] != -1 && !op_riprel[i])
10893 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
10895 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
10899 for (i = 0; i < MAX_OPERANDS; i++)
10900 if (op_index[i] != -1 && op_riprel[i])
10902 (*info->fprintf_func) (info->stream, " # ");
10903 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
10904 + op_address[op_index[i]]), info);
10907 return codep - priv.the_buffer;
10910 static const char *float_mem[] = {
10985 static const unsigned char float_mem_mode[] = {
11060 #define ST { OP_ST, 0 }
11061 #define STi { OP_STi, 0 }
11063 #define FGRPd9_2 NULL, { { NULL, 0 } }
11064 #define FGRPd9_4 NULL, { { NULL, 1 } }
11065 #define FGRPd9_5 NULL, { { NULL, 2 } }
11066 #define FGRPd9_6 NULL, { { NULL, 3 } }
11067 #define FGRPd9_7 NULL, { { NULL, 4 } }
11068 #define FGRPda_5 NULL, { { NULL, 5 } }
11069 #define FGRPdb_4 NULL, { { NULL, 6 } }
11070 #define FGRPde_3 NULL, { { NULL, 7 } }
11071 #define FGRPdf_4 NULL, { { NULL, 8 } }
11073 static const struct dis386 float_reg[][8] = {
11076 { "fadd", { ST, STi } },
11077 { "fmul", { ST, STi } },
11078 { "fcom", { STi } },
11079 { "fcomp", { STi } },
11080 { "fsub", { ST, STi } },
11081 { "fsubr", { ST, STi } },
11082 { "fdiv", { ST, STi } },
11083 { "fdivr", { ST, STi } },
11087 { "fld", { STi } },
11088 { "fxch", { STi } },
11090 { "(bad)", { XX } },
11098 { "fcmovb", { ST, STi } },
11099 { "fcmove", { ST, STi } },
11100 { "fcmovbe",{ ST, STi } },
11101 { "fcmovu", { ST, STi } },
11102 { "(bad)", { XX } },
11104 { "(bad)", { XX } },
11105 { "(bad)", { XX } },
11109 { "fcmovnb",{ ST, STi } },
11110 { "fcmovne",{ ST, STi } },
11111 { "fcmovnbe",{ ST, STi } },
11112 { "fcmovnu",{ ST, STi } },
11114 { "fucomi", { ST, STi } },
11115 { "fcomi", { ST, STi } },
11116 { "(bad)", { XX } },
11120 { "fadd", { STi, ST } },
11121 { "fmul", { STi, ST } },
11122 { "(bad)", { XX } },
11123 { "(bad)", { XX } },
11124 { "fsub!M", { STi, ST } },
11125 { "fsubM", { STi, ST } },
11126 { "fdiv!M", { STi, ST } },
11127 { "fdivM", { STi, ST } },
11131 { "ffree", { STi } },
11132 { "(bad)", { XX } },
11133 { "fst", { STi } },
11134 { "fstp", { STi } },
11135 { "fucom", { STi } },
11136 { "fucomp", { STi } },
11137 { "(bad)", { XX } },
11138 { "(bad)", { XX } },
11142 { "faddp", { STi, ST } },
11143 { "fmulp", { STi, ST } },
11144 { "(bad)", { XX } },
11146 { "fsub!Mp", { STi, ST } },
11147 { "fsubMp", { STi, ST } },
11148 { "fdiv!Mp", { STi, ST } },
11149 { "fdivMp", { STi, ST } },
11153 { "ffreep", { STi } },
11154 { "(bad)", { XX } },
11155 { "(bad)", { XX } },
11156 { "(bad)", { XX } },
11158 { "fucomip", { ST, STi } },
11159 { "fcomip", { ST, STi } },
11160 { "(bad)", { XX } },
11164 static char *fgrps[][8] = {
11167 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11172 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
11177 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
11182 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
11187 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
11192 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11197 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
11198 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
11203 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11208 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
11213 swap_operand (void)
11215 mnemonicendp[0] = '.';
11216 mnemonicendp[1] = 's';
11221 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
11222 int sizeflag ATTRIBUTE_UNUSED)
11224 /* Skip mod/rm byte. */
11230 dofloat (int sizeflag)
11232 const struct dis386 *dp;
11233 unsigned char floatop;
11235 floatop = codep[-1];
11237 if (modrm.mod != 3)
11239 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
11241 putop (float_mem[fp_indx], sizeflag);
11244 OP_E (float_mem_mode[fp_indx], sizeflag);
11247 /* Skip mod/rm byte. */
11251 dp = &float_reg[floatop - 0xd8][modrm.reg];
11252 if (dp->name == NULL)
11254 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
11256 /* Instruction fnstsw is only one with strange arg. */
11257 if (floatop == 0xdf && codep[-1] == 0xe0)
11258 strcpy (op_out[0], names16[0]);
11262 putop (dp->name, sizeflag);
11267 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
11272 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
11277 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
11279 oappend ("%st" + intel_syntax);
11283 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
11285 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
11286 oappend (scratchbuf + intel_syntax);
11289 /* Capital letters in template are macros. */
11291 putop (const char *in_template, int sizeflag)
11296 unsigned int l = 0, len = 1;
11299 #define SAVE_LAST(c) \
11300 if (l < len && l < sizeof (last)) \
11305 for (p = in_template; *p; p++)
11322 while (*++p != '|')
11323 if (*p == '}' || *p == '\0')
11326 /* Fall through. */
11331 while (*++p != '}')
11342 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11346 if (l == 0 && len == 1)
11351 if (sizeflag & SUFFIX_ALWAYS)
11364 if (address_mode == mode_64bit
11365 && !(prefixes & PREFIX_ADDR))
11376 if (intel_syntax && !alt)
11378 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11380 if (sizeflag & DFLAG)
11381 *obufp++ = intel_syntax ? 'd' : 'l';
11383 *obufp++ = intel_syntax ? 'w' : 's';
11384 used_prefixes |= (prefixes & PREFIX_DATA);
11388 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
11391 if (modrm.mod == 3)
11397 if (sizeflag & DFLAG)
11398 *obufp++ = intel_syntax ? 'd' : 'l';
11401 used_prefixes |= (prefixes & PREFIX_DATA);
11407 case 'E': /* For jcxz/jecxz */
11408 if (address_mode == mode_64bit)
11410 if (sizeflag & AFLAG)
11416 if (sizeflag & AFLAG)
11418 used_prefixes |= (prefixes & PREFIX_ADDR);
11423 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11425 if (sizeflag & AFLAG)
11426 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
11428 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
11429 used_prefixes |= (prefixes & PREFIX_ADDR);
11433 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
11435 if ((rex & REX_W) || (sizeflag & DFLAG))
11439 if (!(rex & REX_W))
11440 used_prefixes |= (prefixes & PREFIX_DATA);
11445 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11446 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11448 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
11451 if (prefixes & PREFIX_DS)
11472 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
11477 /* Fall through. */
11480 if (l != 0 || len != 1)
11488 if (sizeflag & SUFFIX_ALWAYS)
11492 if (intel_mnemonic != cond)
11496 if ((prefixes & PREFIX_FWAIT) == 0)
11499 used_prefixes |= PREFIX_FWAIT;
11505 else if (intel_syntax && (sizeflag & DFLAG))
11509 if (!(rex & REX_W))
11510 used_prefixes |= (prefixes & PREFIX_DATA);
11515 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11520 /* Fall through. */
11524 if ((prefixes & PREFIX_DATA)
11526 || (sizeflag & SUFFIX_ALWAYS))
11533 if (sizeflag & DFLAG)
11537 used_prefixes |= (prefixes & PREFIX_DATA);
11544 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11546 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11550 /* Fall through. */
11553 if (l == 0 && len == 1)
11556 if (intel_syntax && !alt)
11559 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11565 if (sizeflag & DFLAG)
11566 *obufp++ = intel_syntax ? 'd' : 'l';
11569 used_prefixes |= (prefixes & PREFIX_DATA);
11575 if (l != 1 || len != 2 || last[0] != 'L')
11581 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11596 else if (sizeflag & DFLAG)
11605 if (intel_syntax && !p[1]
11606 && ((rex & REX_W) || (sizeflag & DFLAG)))
11608 if (!(rex & REX_W))
11609 used_prefixes |= (prefixes & PREFIX_DATA);
11612 if (l == 0 && len == 1)
11616 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11618 if (sizeflag & SUFFIX_ALWAYS)
11640 /* Fall through. */
11643 if (l == 0 && len == 1)
11648 if (sizeflag & SUFFIX_ALWAYS)
11654 if (sizeflag & DFLAG)
11658 used_prefixes |= (prefixes & PREFIX_DATA);
11672 if (address_mode == mode_64bit
11673 && !(prefixes & PREFIX_ADDR))
11684 if (l != 0 || len != 1)
11689 if (need_vex && vex.prefix)
11691 if (vex.prefix == DATA_PREFIX_OPCODE)
11698 if (prefixes & PREFIX_DATA)
11702 used_prefixes |= (prefixes & PREFIX_DATA);
11706 if (l == 0 && len == 1)
11708 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
11719 if (l != 1 || len != 2 || last[0] != 'X')
11727 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11729 switch (vex.length)
11743 if (l == 0 && len == 1)
11745 /* operand size flag for cwtl, cbtw */
11754 else if (sizeflag & DFLAG)
11758 if (!(rex & REX_W))
11759 used_prefixes |= (prefixes & PREFIX_DATA);
11763 if (l != 1 || len != 2 || last[0] != 'X')
11770 *obufp++ = vex.w ? 'd': 's';
11777 mnemonicendp = obufp;
11782 oappend (const char *s)
11784 obufp = stpcpy (obufp, s);
11790 if (prefixes & PREFIX_CS)
11792 used_prefixes |= PREFIX_CS;
11793 oappend ("%cs:" + intel_syntax);
11795 if (prefixes & PREFIX_DS)
11797 used_prefixes |= PREFIX_DS;
11798 oappend ("%ds:" + intel_syntax);
11800 if (prefixes & PREFIX_SS)
11802 used_prefixes |= PREFIX_SS;
11803 oappend ("%ss:" + intel_syntax);
11805 if (prefixes & PREFIX_ES)
11807 used_prefixes |= PREFIX_ES;
11808 oappend ("%es:" + intel_syntax);
11810 if (prefixes & PREFIX_FS)
11812 used_prefixes |= PREFIX_FS;
11813 oappend ("%fs:" + intel_syntax);
11815 if (prefixes & PREFIX_GS)
11817 used_prefixes |= PREFIX_GS;
11818 oappend ("%gs:" + intel_syntax);
11823 OP_indirE (int bytemode, int sizeflag)
11827 OP_E (bytemode, sizeflag);
11831 print_operand_value (char *buf, int hex, bfd_vma disp)
11833 if (address_mode == mode_64bit)
11841 sprintf_vma (tmp, disp);
11842 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
11843 strcpy (buf + 2, tmp + i);
11847 bfd_signed_vma v = disp;
11854 /* Check for possible overflow on 0x8000000000000000. */
11857 strcpy (buf, "9223372036854775808");
11871 tmp[28 - i] = (v % 10) + '0';
11875 strcpy (buf, tmp + 29 - i);
11881 sprintf (buf, "0x%x", (unsigned int) disp);
11883 sprintf (buf, "%d", (int) disp);
11887 /* Put DISP in BUF as signed hex number. */
11890 print_displacement (char *buf, bfd_vma disp)
11892 bfd_signed_vma val = disp;
11901 /* Check for possible overflow. */
11904 switch (address_mode)
11907 strcpy (buf + j, "0x8000000000000000");
11910 strcpy (buf + j, "0x80000000");
11913 strcpy (buf + j, "0x8000");
11923 sprintf_vma (tmp, (bfd_vma) val);
11924 for (i = 0; tmp[i] == '0'; i++)
11926 if (tmp[i] == '\0')
11928 strcpy (buf + j, tmp + i);
11932 intel_operand_size (int bytemode, int sizeflag)
11939 oappend ("BYTE PTR ");
11943 oappend ("WORD PTR ");
11946 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11948 oappend ("QWORD PTR ");
11957 oappend ("QWORD PTR ");
11960 if ((sizeflag & DFLAG) || bytemode == dq_mode)
11961 oappend ("DWORD PTR ");
11963 oappend ("WORD PTR ");
11964 used_prefixes |= (prefixes & PREFIX_DATA);
11968 if ((rex & REX_W) || (sizeflag & DFLAG))
11970 oappend ("WORD PTR ");
11971 if (!(rex & REX_W))
11972 used_prefixes |= (prefixes & PREFIX_DATA);
11975 if (sizeflag & DFLAG)
11976 oappend ("QWORD PTR ");
11978 oappend ("DWORD PTR ");
11979 used_prefixes |= (prefixes & PREFIX_DATA);
11984 oappend ("DWORD PTR ");
11988 oappend ("QWORD PTR ");
11991 if (address_mode == mode_64bit)
11992 oappend ("QWORD PTR ");
11994 oappend ("DWORD PTR ");
11997 if (sizeflag & DFLAG)
11998 oappend ("FWORD PTR ");
12000 oappend ("DWORD PTR ");
12001 used_prefixes |= (prefixes & PREFIX_DATA);
12004 oappend ("TBYTE PTR ");
12010 switch (vex.length)
12013 oappend ("XMMWORD PTR ");
12016 oappend ("YMMWORD PTR ");
12023 oappend ("XMMWORD PTR ");
12026 oappend ("XMMWORD PTR ");
12032 switch (vex.length)
12035 oappend ("QWORD PTR ");
12038 oappend ("XMMWORD PTR ");
12048 switch (vex.length)
12051 oappend ("QWORD PTR ");
12054 oappend ("YMMWORD PTR ");
12061 oappend ("OWORD PTR ");
12063 case vex_w_dq_mode:
12068 oappend ("QWORD PTR ");
12070 oappend ("DWORD PTR ");
12078 OP_E_register (int bytemode, int sizeflag)
12080 int reg = modrm.rm;
12081 const char **names;
12087 if ((sizeflag & SUFFIX_ALWAYS)
12088 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
12111 names = address_mode == mode_64bit ? names64 : names32;
12114 if (address_mode == mode_64bit && (sizeflag & DFLAG))
12132 if ((sizeflag & DFLAG)
12133 || (bytemode != v_mode
12134 && bytemode != v_swap_mode))
12138 used_prefixes |= (prefixes & PREFIX_DATA);
12144 oappend (INTERNAL_DISASSEMBLER_ERROR);
12147 oappend (names[reg]);
12151 OP_E_memory (int bytemode, int sizeflag)
12154 int add = (rex & REX_B) ? 8 : 0;
12159 intel_operand_size (bytemode, sizeflag);
12162 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12164 /* 32/64 bit address mode */
12182 FETCH_DATA (the_info, codep + 1);
12183 index = (*codep >> 3) & 7;
12184 scale = (*codep >> 6) & 3;
12189 haveindex = index != 4;
12192 rbase = base + add;
12200 if (address_mode == mode_64bit && !havesib)
12206 FETCH_DATA (the_info, codep + 1);
12208 if ((disp & 0x80) != 0)
12216 /* In 32bit mode, we need index register to tell [offset] from
12217 [eiz*1 + offset]. */
12218 needindex = (havesib
12221 && address_mode == mode_32bit);
12222 havedisp = (havebase
12224 || (havesib && (haveindex || scale != 0)));
12227 if (modrm.mod != 0 || base == 5)
12229 if (havedisp || riprel)
12230 print_displacement (scratchbuf, disp);
12232 print_operand_value (scratchbuf, 1, disp);
12233 oappend (scratchbuf);
12237 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
12241 if (havebase || haveindex || riprel)
12242 used_prefixes |= PREFIX_ADDR;
12244 if (havedisp || (intel_syntax && riprel))
12246 *obufp++ = open_char;
12247 if (intel_syntax && riprel)
12250 oappend (sizeflag & AFLAG ? "rip" : "eip");
12254 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
12255 ? names64[rbase] : names32[rbase]);
12258 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
12259 print index to tell base + index from base. */
12263 || (havebase && base != ESP_REG_NUM))
12265 if (!intel_syntax || havebase)
12267 *obufp++ = separator_char;
12271 oappend (address_mode == mode_64bit
12272 && (sizeflag & AFLAG)
12273 ? names64[index] : names32[index]);
12275 oappend (address_mode == mode_64bit
12276 && (sizeflag & AFLAG)
12277 ? index64 : index32);
12279 *obufp++ = scale_char;
12281 sprintf (scratchbuf, "%d", 1 << scale);
12282 oappend (scratchbuf);
12286 && (disp || modrm.mod != 0 || base == 5))
12288 if (!havedisp || (bfd_signed_vma) disp >= 0)
12293 else if (modrm.mod != 1 && disp != -disp)
12297 disp = - (bfd_signed_vma) disp;
12301 print_displacement (scratchbuf, disp);
12303 print_operand_value (scratchbuf, 1, disp);
12304 oappend (scratchbuf);
12307 *obufp++ = close_char;
12310 else if (intel_syntax)
12312 if (modrm.mod != 0 || base == 5)
12314 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12315 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
12319 oappend (names_seg[ds_reg - es_reg]);
12322 print_operand_value (scratchbuf, 1, disp);
12323 oappend (scratchbuf);
12329 /* 16 bit address mode */
12330 used_prefixes |= prefixes & PREFIX_ADDR;
12337 if ((disp & 0x8000) != 0)
12342 FETCH_DATA (the_info, codep + 1);
12344 if ((disp & 0x80) != 0)
12349 if ((disp & 0x8000) != 0)
12355 if (modrm.mod != 0 || modrm.rm == 6)
12357 print_displacement (scratchbuf, disp);
12358 oappend (scratchbuf);
12361 if (modrm.mod != 0 || modrm.rm != 6)
12363 *obufp++ = open_char;
12365 oappend (index16[modrm.rm]);
12367 && (disp || modrm.mod != 0 || modrm.rm == 6))
12369 if ((bfd_signed_vma) disp >= 0)
12374 else if (modrm.mod != 1)
12378 disp = - (bfd_signed_vma) disp;
12381 print_displacement (scratchbuf, disp);
12382 oappend (scratchbuf);
12385 *obufp++ = close_char;
12388 else if (intel_syntax)
12390 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12391 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
12395 oappend (names_seg[ds_reg - es_reg]);
12398 print_operand_value (scratchbuf, 1, disp & 0xffff);
12399 oappend (scratchbuf);
12405 OP_E (int bytemode, int sizeflag)
12407 /* Skip mod/rm byte. */
12411 if (modrm.mod == 3)
12412 OP_E_register (bytemode, sizeflag);
12414 OP_E_memory (bytemode, sizeflag);
12418 OP_G (int bytemode, int sizeflag)
12429 oappend (names8rex[modrm.reg + add]);
12431 oappend (names8[modrm.reg + add]);
12434 oappend (names16[modrm.reg + add]);
12437 oappend (names32[modrm.reg + add]);
12440 oappend (names64[modrm.reg + add]);
12449 oappend (names64[modrm.reg + add]);
12452 if ((sizeflag & DFLAG) || bytemode != v_mode)
12453 oappend (names32[modrm.reg + add]);
12455 oappend (names16[modrm.reg + add]);
12456 used_prefixes |= (prefixes & PREFIX_DATA);
12460 if (address_mode == mode_64bit)
12461 oappend (names64[modrm.reg + add]);
12463 oappend (names32[modrm.reg + add]);
12466 oappend (INTERNAL_DISASSEMBLER_ERROR);
12479 FETCH_DATA (the_info, codep + 8);
12480 a = *codep++ & 0xff;
12481 a |= (*codep++ & 0xff) << 8;
12482 a |= (*codep++ & 0xff) << 16;
12483 a |= (*codep++ & 0xff) << 24;
12484 b = *codep++ & 0xff;
12485 b |= (*codep++ & 0xff) << 8;
12486 b |= (*codep++ & 0xff) << 16;
12487 b |= (*codep++ & 0xff) << 24;
12488 x = a + ((bfd_vma) b << 32);
12496 static bfd_signed_vma
12499 bfd_signed_vma x = 0;
12501 FETCH_DATA (the_info, codep + 4);
12502 x = *codep++ & (bfd_signed_vma) 0xff;
12503 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12504 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12505 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12509 static bfd_signed_vma
12512 bfd_signed_vma x = 0;
12514 FETCH_DATA (the_info, codep + 4);
12515 x = *codep++ & (bfd_signed_vma) 0xff;
12516 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12517 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12518 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12520 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
12530 FETCH_DATA (the_info, codep + 2);
12531 x = *codep++ & 0xff;
12532 x |= (*codep++ & 0xff) << 8;
12537 set_op (bfd_vma op, int riprel)
12539 op_index[op_ad] = op_ad;
12540 if (address_mode == mode_64bit)
12542 op_address[op_ad] = op;
12543 op_riprel[op_ad] = riprel;
12547 /* Mask to get a 32-bit address. */
12548 op_address[op_ad] = op & 0xffffffff;
12549 op_riprel[op_ad] = riprel & 0xffffffff;
12554 OP_REG (int code, int sizeflag)
12566 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12567 case sp_reg: case bp_reg: case si_reg: case di_reg:
12568 s = names16[code - ax_reg + add];
12570 case es_reg: case ss_reg: case cs_reg:
12571 case ds_reg: case fs_reg: case gs_reg:
12572 s = names_seg[code - es_reg + add];
12574 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12575 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12578 s = names8rex[code - al_reg + add];
12580 s = names8[code - al_reg];
12582 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
12583 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
12584 if (address_mode == mode_64bit && (sizeflag & DFLAG))
12586 s = names64[code - rAX_reg + add];
12589 code += eAX_reg - rAX_reg;
12590 /* Fall through. */
12591 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12592 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12595 s = names64[code - eAX_reg + add];
12598 if (sizeflag & DFLAG)
12599 s = names32[code - eAX_reg + add];
12601 s = names16[code - eAX_reg + add];
12602 used_prefixes |= (prefixes & PREFIX_DATA);
12606 s = INTERNAL_DISASSEMBLER_ERROR;
12613 OP_IMREG (int code, int sizeflag)
12625 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12626 case sp_reg: case bp_reg: case si_reg: case di_reg:
12627 s = names16[code - ax_reg];
12629 case es_reg: case ss_reg: case cs_reg:
12630 case ds_reg: case fs_reg: case gs_reg:
12631 s = names_seg[code - es_reg];
12633 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12634 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12637 s = names8rex[code - al_reg];
12639 s = names8[code - al_reg];
12641 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12642 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12645 s = names64[code - eAX_reg];
12648 if (sizeflag & DFLAG)
12649 s = names32[code - eAX_reg];
12651 s = names16[code - eAX_reg];
12652 used_prefixes |= (prefixes & PREFIX_DATA);
12655 case z_mode_ax_reg:
12656 if ((rex & REX_W) || (sizeflag & DFLAG))
12660 if (!(rex & REX_W))
12661 used_prefixes |= (prefixes & PREFIX_DATA);
12664 s = INTERNAL_DISASSEMBLER_ERROR;
12671 OP_I (int bytemode, int sizeflag)
12674 bfd_signed_vma mask = -1;
12679 FETCH_DATA (the_info, codep + 1);
12684 if (address_mode == mode_64bit)
12689 /* Fall through. */
12696 if (sizeflag & DFLAG)
12706 used_prefixes |= (prefixes & PREFIX_DATA);
12718 oappend (INTERNAL_DISASSEMBLER_ERROR);
12723 scratchbuf[0] = '$';
12724 print_operand_value (scratchbuf + 1, 1, op);
12725 oappend (scratchbuf + intel_syntax);
12726 scratchbuf[0] = '\0';
12730 OP_I64 (int bytemode, int sizeflag)
12733 bfd_signed_vma mask = -1;
12735 if (address_mode != mode_64bit)
12737 OP_I (bytemode, sizeflag);
12744 FETCH_DATA (the_info, codep + 1);
12754 if (sizeflag & DFLAG)
12764 used_prefixes |= (prefixes & PREFIX_DATA);
12772 oappend (INTERNAL_DISASSEMBLER_ERROR);
12777 scratchbuf[0] = '$';
12778 print_operand_value (scratchbuf + 1, 1, op);
12779 oappend (scratchbuf + intel_syntax);
12780 scratchbuf[0] = '\0';
12784 OP_sI (int bytemode, int sizeflag)
12787 bfd_signed_vma mask = -1;
12792 FETCH_DATA (the_info, codep + 1);
12794 if ((op & 0x80) != 0)
12804 if (sizeflag & DFLAG)
12813 if ((op & 0x8000) != 0)
12816 used_prefixes |= (prefixes & PREFIX_DATA);
12822 if ((op & 0x8000) != 0)
12826 oappend (INTERNAL_DISASSEMBLER_ERROR);
12830 scratchbuf[0] = '$';
12831 print_operand_value (scratchbuf + 1, 1, op);
12832 oappend (scratchbuf + intel_syntax);
12836 OP_J (int bytemode, int sizeflag)
12840 bfd_vma segment = 0;
12845 FETCH_DATA (the_info, codep + 1);
12847 if ((disp & 0x80) != 0)
12852 if ((sizeflag & DFLAG) || (rex & REX_W))
12857 if ((disp & 0x8000) != 0)
12859 /* In 16bit mode, address is wrapped around at 64k within
12860 the same segment. Otherwise, a data16 prefix on a jump
12861 instruction means that the pc is masked to 16 bits after
12862 the displacement is added! */
12864 if ((prefixes & PREFIX_DATA) == 0)
12865 segment = ((start_pc + codep - start_codep)
12866 & ~((bfd_vma) 0xffff));
12868 if (!(rex & REX_W))
12869 used_prefixes |= (prefixes & PREFIX_DATA);
12872 oappend (INTERNAL_DISASSEMBLER_ERROR);
12875 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
12877 print_operand_value (scratchbuf, 1, disp);
12878 oappend (scratchbuf);
12882 OP_SEG (int bytemode, int sizeflag)
12884 if (bytemode == w_mode)
12885 oappend (names_seg[modrm.reg]);
12887 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
12891 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
12895 if (sizeflag & DFLAG)
12905 used_prefixes |= (prefixes & PREFIX_DATA);
12907 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
12909 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
12910 oappend (scratchbuf);
12914 OP_OFF (int bytemode, int sizeflag)
12918 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12919 intel_operand_size (bytemode, sizeflag);
12922 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12929 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12930 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12932 oappend (names_seg[ds_reg - es_reg]);
12936 print_operand_value (scratchbuf, 1, off);
12937 oappend (scratchbuf);
12941 OP_OFF64 (int bytemode, int sizeflag)
12945 if (address_mode != mode_64bit
12946 || (prefixes & PREFIX_ADDR))
12948 OP_OFF (bytemode, sizeflag);
12952 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12953 intel_operand_size (bytemode, sizeflag);
12960 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12961 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12963 oappend (names_seg[ds_reg - es_reg]);
12967 print_operand_value (scratchbuf, 1, off);
12968 oappend (scratchbuf);
12972 ptr_reg (int code, int sizeflag)
12976 *obufp++ = open_char;
12977 used_prefixes |= (prefixes & PREFIX_ADDR);
12978 if (address_mode == mode_64bit)
12980 if (!(sizeflag & AFLAG))
12981 s = names32[code - eAX_reg];
12983 s = names64[code - eAX_reg];
12985 else if (sizeflag & AFLAG)
12986 s = names32[code - eAX_reg];
12988 s = names16[code - eAX_reg];
12990 *obufp++ = close_char;
12995 OP_ESreg (int code, int sizeflag)
13001 case 0x6d: /* insw/insl */
13002 intel_operand_size (z_mode, sizeflag);
13004 case 0xa5: /* movsw/movsl/movsq */
13005 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13006 case 0xab: /* stosw/stosl */
13007 case 0xaf: /* scasw/scasl */
13008 intel_operand_size (v_mode, sizeflag);
13011 intel_operand_size (b_mode, sizeflag);
13014 oappend ("%es:" + intel_syntax);
13015 ptr_reg (code, sizeflag);
13019 OP_DSreg (int code, int sizeflag)
13025 case 0x6f: /* outsw/outsl */
13026 intel_operand_size (z_mode, sizeflag);
13028 case 0xa5: /* movsw/movsl/movsq */
13029 case 0xa7: /* cmpsw/cmpsl/cmpsq */
13030 case 0xad: /* lodsw/lodsl/lodsq */
13031 intel_operand_size (v_mode, sizeflag);
13034 intel_operand_size (b_mode, sizeflag);
13043 | PREFIX_GS)) == 0)
13044 prefixes |= PREFIX_DS;
13046 ptr_reg (code, sizeflag);
13050 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13058 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
13060 all_prefixes[last_lock_prefix] = 0;
13061 used_prefixes |= PREFIX_LOCK;
13066 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
13067 oappend (scratchbuf + intel_syntax);
13071 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13080 sprintf (scratchbuf, "db%d", modrm.reg + add);
13082 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
13083 oappend (scratchbuf);
13087 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13089 sprintf (scratchbuf, "%%tr%d", modrm.reg);
13090 oappend (scratchbuf + intel_syntax);
13094 OP_R (int bytemode, int sizeflag)
13096 if (modrm.mod == 3)
13097 OP_E (bytemode, sizeflag);
13103 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13105 used_prefixes |= (prefixes & PREFIX_DATA);
13106 if (prefixes & PREFIX_DATA)
13114 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
13117 sprintf (scratchbuf, "%%mm%d", modrm.reg);
13118 oappend (scratchbuf + intel_syntax);
13122 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13130 if (need_vex && bytemode != xmm_mode)
13132 switch (vex.length)
13135 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
13138 sprintf (scratchbuf, "%%ymm%d", modrm.reg + add);
13145 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
13146 oappend (scratchbuf + intel_syntax);
13150 OP_EM (int bytemode, int sizeflag)
13152 if (modrm.mod != 3)
13155 && (bytemode == v_mode || bytemode == v_swap_mode))
13157 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
13158 used_prefixes |= (prefixes & PREFIX_DATA);
13160 OP_E (bytemode, sizeflag);
13164 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
13167 /* Skip mod/rm byte. */
13170 used_prefixes |= (prefixes & PREFIX_DATA);
13171 if (prefixes & PREFIX_DATA)
13180 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
13183 sprintf (scratchbuf, "%%mm%d", modrm.rm);
13184 oappend (scratchbuf + intel_syntax);
13187 /* cvt* are the only instructions in sse2 which have
13188 both SSE and MMX operands and also have 0x66 prefix
13189 in their opcode. 0x66 was originally used to differentiate
13190 between SSE and MMX instruction(operands). So we have to handle the
13191 cvt* separately using OP_EMC and OP_MXC */
13193 OP_EMC (int bytemode, int sizeflag)
13195 if (modrm.mod != 3)
13197 if (intel_syntax && bytemode == v_mode)
13199 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
13200 used_prefixes |= (prefixes & PREFIX_DATA);
13202 OP_E (bytemode, sizeflag);
13206 /* Skip mod/rm byte. */
13209 used_prefixes |= (prefixes & PREFIX_DATA);
13210 sprintf (scratchbuf, "%%mm%d", modrm.rm);
13211 oappend (scratchbuf + intel_syntax);
13215 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13217 used_prefixes |= (prefixes & PREFIX_DATA);
13218 sprintf (scratchbuf, "%%mm%d", modrm.reg);
13219 oappend (scratchbuf + intel_syntax);
13223 OP_EX (int bytemode, int sizeflag)
13227 /* Skip mod/rm byte. */
13231 if (modrm.mod != 3)
13233 OP_E_memory (bytemode, sizeflag);
13243 if ((sizeflag & SUFFIX_ALWAYS)
13244 && (bytemode == x_swap_mode
13245 || bytemode == d_swap_mode
13246 || bytemode == q_swap_mode))
13250 && bytemode != xmm_mode
13251 && bytemode != xmmq_mode)
13253 switch (vex.length)
13256 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
13259 sprintf (scratchbuf, "%%ymm%d", modrm.rm + add);
13266 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
13267 oappend (scratchbuf + intel_syntax);
13271 OP_MS (int bytemode, int sizeflag)
13273 if (modrm.mod == 3)
13274 OP_EM (bytemode, sizeflag);
13280 OP_XS (int bytemode, int sizeflag)
13282 if (modrm.mod == 3)
13283 OP_EX (bytemode, sizeflag);
13289 OP_M (int bytemode, int sizeflag)
13291 if (modrm.mod == 3)
13292 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
13295 OP_E (bytemode, sizeflag);
13299 OP_0f07 (int bytemode, int sizeflag)
13301 if (modrm.mod != 3 || modrm.rm != 0)
13304 OP_E (bytemode, sizeflag);
13307 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
13308 32bit mode and "xchg %rax,%rax" in 64bit mode. */
13311 NOP_Fixup1 (int bytemode, int sizeflag)
13313 if ((prefixes & PREFIX_DATA) != 0
13316 && address_mode == mode_64bit))
13317 OP_REG (bytemode, sizeflag);
13319 strcpy (obuf, "nop");
13323 NOP_Fixup2 (int bytemode, int sizeflag)
13325 if ((prefixes & PREFIX_DATA) != 0
13328 && address_mode == mode_64bit))
13329 OP_IMREG (bytemode, sizeflag);
13332 static const char *const Suffix3DNow[] = {
13333 /* 00 */ NULL, NULL, NULL, NULL,
13334 /* 04 */ NULL, NULL, NULL, NULL,
13335 /* 08 */ NULL, NULL, NULL, NULL,
13336 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
13337 /* 10 */ NULL, NULL, NULL, NULL,
13338 /* 14 */ NULL, NULL, NULL, NULL,
13339 /* 18 */ NULL, NULL, NULL, NULL,
13340 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
13341 /* 20 */ NULL, NULL, NULL, NULL,
13342 /* 24 */ NULL, NULL, NULL, NULL,
13343 /* 28 */ NULL, NULL, NULL, NULL,
13344 /* 2C */ NULL, NULL, NULL, NULL,
13345 /* 30 */ NULL, NULL, NULL, NULL,
13346 /* 34 */ NULL, NULL, NULL, NULL,
13347 /* 38 */ NULL, NULL, NULL, NULL,
13348 /* 3C */ NULL, NULL, NULL, NULL,
13349 /* 40 */ NULL, NULL, NULL, NULL,
13350 /* 44 */ NULL, NULL, NULL, NULL,
13351 /* 48 */ NULL, NULL, NULL, NULL,
13352 /* 4C */ NULL, NULL, NULL, NULL,
13353 /* 50 */ NULL, NULL, NULL, NULL,
13354 /* 54 */ NULL, NULL, NULL, NULL,
13355 /* 58 */ NULL, NULL, NULL, NULL,
13356 /* 5C */ NULL, NULL, NULL, NULL,
13357 /* 60 */ NULL, NULL, NULL, NULL,
13358 /* 64 */ NULL, NULL, NULL, NULL,
13359 /* 68 */ NULL, NULL, NULL, NULL,
13360 /* 6C */ NULL, NULL, NULL, NULL,
13361 /* 70 */ NULL, NULL, NULL, NULL,
13362 /* 74 */ NULL, NULL, NULL, NULL,
13363 /* 78 */ NULL, NULL, NULL, NULL,
13364 /* 7C */ NULL, NULL, NULL, NULL,
13365 /* 80 */ NULL, NULL, NULL, NULL,
13366 /* 84 */ NULL, NULL, NULL, NULL,
13367 /* 88 */ NULL, NULL, "pfnacc", NULL,
13368 /* 8C */ NULL, NULL, "pfpnacc", NULL,
13369 /* 90 */ "pfcmpge", NULL, NULL, NULL,
13370 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
13371 /* 98 */ NULL, NULL, "pfsub", NULL,
13372 /* 9C */ NULL, NULL, "pfadd", NULL,
13373 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
13374 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
13375 /* A8 */ NULL, NULL, "pfsubr", NULL,
13376 /* AC */ NULL, NULL, "pfacc", NULL,
13377 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
13378 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
13379 /* B8 */ NULL, NULL, NULL, "pswapd",
13380 /* BC */ NULL, NULL, NULL, "pavgusb",
13381 /* C0 */ NULL, NULL, NULL, NULL,
13382 /* C4 */ NULL, NULL, NULL, NULL,
13383 /* C8 */ NULL, NULL, NULL, NULL,
13384 /* CC */ NULL, NULL, NULL, NULL,
13385 /* D0 */ NULL, NULL, NULL, NULL,
13386 /* D4 */ NULL, NULL, NULL, NULL,
13387 /* D8 */ NULL, NULL, NULL, NULL,
13388 /* DC */ NULL, NULL, NULL, NULL,
13389 /* E0 */ NULL, NULL, NULL, NULL,
13390 /* E4 */ NULL, NULL, NULL, NULL,
13391 /* E8 */ NULL, NULL, NULL, NULL,
13392 /* EC */ NULL, NULL, NULL, NULL,
13393 /* F0 */ NULL, NULL, NULL, NULL,
13394 /* F4 */ NULL, NULL, NULL, NULL,
13395 /* F8 */ NULL, NULL, NULL, NULL,
13396 /* FC */ NULL, NULL, NULL, NULL,
13400 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13402 const char *mnemonic;
13404 FETCH_DATA (the_info, codep + 1);
13405 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13406 place where an 8-bit immediate would normally go. ie. the last
13407 byte of the instruction. */
13408 obufp = mnemonicendp;
13409 mnemonic = Suffix3DNow[*codep++ & 0xff];
13411 oappend (mnemonic);
13414 /* Since a variable sized modrm/sib chunk is between the start
13415 of the opcode (0x0f0f) and the opcode suffix, we need to do
13416 all the modrm processing first, and don't know until now that
13417 we have a bad opcode. This necessitates some cleaning up. */
13418 op_out[0][0] = '\0';
13419 op_out[1][0] = '\0';
13422 mnemonicendp = obufp;
13425 static struct op simd_cmp_op[] =
13427 { STRING_COMMA_LEN ("eq") },
13428 { STRING_COMMA_LEN ("lt") },
13429 { STRING_COMMA_LEN ("le") },
13430 { STRING_COMMA_LEN ("unord") },
13431 { STRING_COMMA_LEN ("neq") },
13432 { STRING_COMMA_LEN ("nlt") },
13433 { STRING_COMMA_LEN ("nle") },
13434 { STRING_COMMA_LEN ("ord") }
13438 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13440 unsigned int cmp_type;
13442 FETCH_DATA (the_info, codep + 1);
13443 cmp_type = *codep++ & 0xff;
13444 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
13447 char *p = mnemonicendp - 2;
13451 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
13452 mnemonicendp += simd_cmp_op[cmp_type].len;
13456 /* We have a reserved extension byte. Output it directly. */
13457 scratchbuf[0] = '$';
13458 print_operand_value (scratchbuf + 1, 1, cmp_type);
13459 oappend (scratchbuf + intel_syntax);
13460 scratchbuf[0] = '\0';
13465 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
13466 int sizeflag ATTRIBUTE_UNUSED)
13468 /* mwait %eax,%ecx */
13471 const char **names = (address_mode == mode_64bit
13472 ? names64 : names32);
13473 strcpy (op_out[0], names[0]);
13474 strcpy (op_out[1], names[1]);
13475 two_source_ops = 1;
13477 /* Skip mod/rm byte. */
13483 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
13484 int sizeflag ATTRIBUTE_UNUSED)
13486 /* monitor %eax,%ecx,%edx" */
13489 const char **op1_names;
13490 const char **names = (address_mode == mode_64bit
13491 ? names64 : names32);
13493 if (!(prefixes & PREFIX_ADDR))
13494 op1_names = (address_mode == mode_16bit
13495 ? names16 : names);
13498 /* Remove "addr16/addr32". */
13499 all_prefixes[last_addr_prefix] = 0;
13500 op1_names = (address_mode != mode_32bit
13501 ? names32 : names16);
13502 used_prefixes |= PREFIX_ADDR;
13504 strcpy (op_out[0], op1_names[0]);
13505 strcpy (op_out[1], names[1]);
13506 strcpy (op_out[2], names[2]);
13507 two_source_ops = 1;
13509 /* Skip mod/rm byte. */
13517 /* Throw away prefixes and 1st. opcode byte. */
13518 codep = insn_codep + 1;
13523 REP_Fixup (int bytemode, int sizeflag)
13525 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13527 if (prefixes & PREFIX_REPZ)
13528 all_prefixes[last_repz_prefix] = REP_PREFIX;
13535 OP_IMREG (bytemode, sizeflag);
13538 OP_ESreg (bytemode, sizeflag);
13541 OP_DSreg (bytemode, sizeflag);
13550 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
13555 /* Change cmpxchg8b to cmpxchg16b. */
13556 char *p = mnemonicendp - 2;
13557 mnemonicendp = stpcpy (p, "16b");
13560 OP_M (bytemode, sizeflag);
13564 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
13568 switch (vex.length)
13571 sprintf (scratchbuf, "%%xmm%d", reg);
13574 sprintf (scratchbuf, "%%ymm%d", reg);
13581 sprintf (scratchbuf, "%%xmm%d", reg);
13582 oappend (scratchbuf + intel_syntax);
13586 CRC32_Fixup (int bytemode, int sizeflag)
13588 /* Add proper suffix to "crc32". */
13589 char *p = mnemonicendp;
13608 if (sizeflag & DFLAG)
13612 used_prefixes |= (prefixes & PREFIX_DATA);
13616 oappend (INTERNAL_DISASSEMBLER_ERROR);
13623 if (modrm.mod == 3)
13627 /* Skip mod/rm byte. */
13632 add = (rex & REX_B) ? 8 : 0;
13633 if (bytemode == b_mode)
13637 oappend (names8rex[modrm.rm + add]);
13639 oappend (names8[modrm.rm + add]);
13645 oappend (names64[modrm.rm + add]);
13646 else if ((prefixes & PREFIX_DATA))
13647 oappend (names16[modrm.rm + add]);
13649 oappend (names32[modrm.rm + add]);
13653 OP_E (bytemode, sizeflag);
13656 /* Display the destination register operand for instructions with
13660 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13668 switch (vex.length)
13681 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
13694 sprintf (scratchbuf, "%%ymm%d", vex.register_specifier);
13700 oappend (scratchbuf + intel_syntax);
13703 /* Get the VEX immediate byte without moving codep. */
13705 static unsigned char
13706 get_vex_imm8 (int sizeflag)
13708 int bytes_before_imm = 0;
13710 /* Skip mod/rm byte. */
13714 if (modrm.mod != 3)
13716 /* There are SIB/displacement bytes. */
13717 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13719 /* 32/64 bit address mode */
13720 int base = modrm.rm;
13722 /* Check SIB byte. */
13725 FETCH_DATA (the_info, codep + 1);
13727 bytes_before_imm++;
13733 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13734 SIB == 5, there is a 4 byte displacement. */
13736 /* No displacement. */
13739 /* 4 byte displacement. */
13740 bytes_before_imm += 4;
13743 /* 1 byte displacement. */
13744 bytes_before_imm++;
13749 { /* 16 bit address mode */
13753 /* When modrm.rm == 6, there is a 2 byte displacement. */
13755 /* No displacement. */
13758 /* 2 byte displacement. */
13759 bytes_before_imm += 2;
13762 /* 1 byte displacement. */
13763 bytes_before_imm++;
13769 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
13770 return codep [bytes_before_imm];
13774 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
13776 if (reg == -1 && modrm.mod != 3)
13778 OP_E_memory (bytemode, sizeflag);
13790 else if (reg > 7 && address_mode != mode_64bit)
13794 switch (vex.length)
13797 sprintf (scratchbuf, "%%xmm%d", reg);
13800 sprintf (scratchbuf, "%%ymm%d", reg);
13805 oappend (scratchbuf + intel_syntax);
13809 OP_Vex_2src (int bytemode, int sizeflag)
13811 if (modrm.mod == 3)
13814 sprintf (scratchbuf, "%%xmm%d", rex & REX_B ? modrm.rm + 8 : modrm.rm);
13815 oappend (scratchbuf + intel_syntax);
13820 && (bytemode == v_mode || bytemode == v_swap_mode))
13822 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
13823 used_prefixes |= (prefixes & PREFIX_DATA);
13825 OP_E (bytemode, sizeflag);
13830 OP_Vex_2src_1 (int bytemode, int sizeflag)
13832 if (modrm.mod == 3)
13834 /* Skip mod/rm byte. */
13841 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
13842 oappend (scratchbuf + intel_syntax);
13845 OP_Vex_2src (bytemode, sizeflag);
13849 OP_Vex_2src_2 (int bytemode, int sizeflag)
13852 OP_Vex_2src (bytemode, sizeflag);
13855 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
13856 oappend (scratchbuf + intel_syntax);
13861 OP_EX_VexW (int bytemode, int sizeflag)
13869 reg = get_vex_imm8 (sizeflag) >> 4;
13874 reg = get_vex_imm8 (sizeflag) >> 4;
13877 OP_EX_VexReg (bytemode, sizeflag, reg);
13881 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
13882 int sizeflag ATTRIBUTE_UNUSED)
13884 /* Skip the immediate byte and check for invalid bits. */
13885 FETCH_DATA (the_info, codep + 1);
13886 if (*codep++ & 0xf)
13891 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13894 FETCH_DATA (the_info, codep + 1);
13897 if (bytemode != x_mode)
13904 if (reg > 7 && address_mode != mode_64bit)
13907 switch (vex.length)
13910 sprintf (scratchbuf, "%%xmm%d", reg);
13913 sprintf (scratchbuf, "%%ymm%d", reg);
13918 oappend (scratchbuf + intel_syntax);
13922 OP_XMM_VexW (int bytemode, int sizeflag)
13924 /* Turn off the REX.W bit since it is used for swapping operands
13927 OP_XMM (bytemode, sizeflag);
13931 OP_EX_Vex (int bytemode, int sizeflag)
13933 if (modrm.mod != 3)
13935 if (vex.register_specifier != 0)
13939 OP_EX (bytemode, sizeflag);
13943 OP_XMM_Vex (int bytemode, int sizeflag)
13945 if (modrm.mod != 3)
13947 if (vex.register_specifier != 0)
13951 OP_XMM (bytemode, sizeflag);
13955 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13957 switch (vex.length)
13960 mnemonicendp = stpcpy (obuf, "vzeroupper");
13963 mnemonicendp = stpcpy (obuf, "vzeroall");
13970 static struct op vex_cmp_op[] =
13972 { STRING_COMMA_LEN ("eq") },
13973 { STRING_COMMA_LEN ("lt") },
13974 { STRING_COMMA_LEN ("le") },
13975 { STRING_COMMA_LEN ("unord") },
13976 { STRING_COMMA_LEN ("neq") },
13977 { STRING_COMMA_LEN ("nlt") },
13978 { STRING_COMMA_LEN ("nle") },
13979 { STRING_COMMA_LEN ("ord") },
13980 { STRING_COMMA_LEN ("eq_uq") },
13981 { STRING_COMMA_LEN ("nge") },
13982 { STRING_COMMA_LEN ("ngt") },
13983 { STRING_COMMA_LEN ("false") },
13984 { STRING_COMMA_LEN ("neq_oq") },
13985 { STRING_COMMA_LEN ("ge") },
13986 { STRING_COMMA_LEN ("gt") },
13987 { STRING_COMMA_LEN ("true") },
13988 { STRING_COMMA_LEN ("eq_os") },
13989 { STRING_COMMA_LEN ("lt_oq") },
13990 { STRING_COMMA_LEN ("le_oq") },
13991 { STRING_COMMA_LEN ("unord_s") },
13992 { STRING_COMMA_LEN ("neq_us") },
13993 { STRING_COMMA_LEN ("nlt_uq") },
13994 { STRING_COMMA_LEN ("nle_uq") },
13995 { STRING_COMMA_LEN ("ord_s") },
13996 { STRING_COMMA_LEN ("eq_us") },
13997 { STRING_COMMA_LEN ("nge_uq") },
13998 { STRING_COMMA_LEN ("ngt_uq") },
13999 { STRING_COMMA_LEN ("false_os") },
14000 { STRING_COMMA_LEN ("neq_os") },
14001 { STRING_COMMA_LEN ("ge_oq") },
14002 { STRING_COMMA_LEN ("gt_oq") },
14003 { STRING_COMMA_LEN ("true_us") },
14007 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14009 unsigned int cmp_type;
14011 FETCH_DATA (the_info, codep + 1);
14012 cmp_type = *codep++ & 0xff;
14013 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
14016 char *p = mnemonicendp - 2;
14020 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
14021 mnemonicendp += vex_cmp_op[cmp_type].len;
14025 /* We have a reserved extension byte. Output it directly. */
14026 scratchbuf[0] = '$';
14027 print_operand_value (scratchbuf + 1, 1, cmp_type);
14028 oappend (scratchbuf + intel_syntax);
14029 scratchbuf[0] = '\0';
14033 static const struct op pclmul_op[] =
14035 { STRING_COMMA_LEN ("lql") },
14036 { STRING_COMMA_LEN ("hql") },
14037 { STRING_COMMA_LEN ("lqh") },
14038 { STRING_COMMA_LEN ("hqh") }
14042 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
14043 int sizeflag ATTRIBUTE_UNUSED)
14045 unsigned int pclmul_type;
14047 FETCH_DATA (the_info, codep + 1);
14048 pclmul_type = *codep++ & 0xff;
14049 switch (pclmul_type)
14060 if (pclmul_type < ARRAY_SIZE (pclmul_op))
14063 char *p = mnemonicendp - 3;
14068 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
14069 mnemonicendp += pclmul_op[pclmul_type].len;
14073 /* We have a reserved extension byte. Output it directly. */
14074 scratchbuf[0] = '$';
14075 print_operand_value (scratchbuf + 1, 1, pclmul_type);
14076 oappend (scratchbuf + intel_syntax);
14077 scratchbuf[0] = '\0';
14082 MOVBE_Fixup (int bytemode, int sizeflag)
14084 /* Add proper suffix to "movbe". */
14085 char *p = mnemonicendp;
14094 if (sizeflag & SUFFIX_ALWAYS)
14100 if (sizeflag & DFLAG)
14104 used_prefixes |= (prefixes & PREFIX_DATA);
14109 oappend (INTERNAL_DISASSEMBLER_ERROR);
14116 OP_M (bytemode, sizeflag);
14120 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14123 const char **names;
14125 /* Skip mod/rm byte. */
14131 else if (vex.length == 256)
14141 oappend (names[reg]);
14145 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
14147 const char **names;
14151 else if (vex.length == 256)
14156 oappend (names[vex.register_specifier]);
14160 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
14162 if (vex.w || vex.length == 256)
14163 OP_I (q_mode, sizeflag);
14165 OP_I (w_mode, sizeflag);