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