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 fetch_data (struct disassemble_info *, bfd_byte *);
46 static void ckprefix (void);
47 static const char *prefix_name (int, int);
48 static int print_insn (bfd_vma, disassemble_info *);
49 static void dofloat (int);
50 static void OP_ST (int, int);
51 static void OP_STi (int, int);
52 static int putop (const char *, int);
53 static void oappend (const char *);
54 static void append_seg (void);
55 static void OP_indirE (int, int);
56 static void print_operand_value (char *, int, bfd_vma);
57 static void OP_E_register (int, int);
58 static void OP_E_memory (int, int);
59 static void OP_E_extended (int, int);
60 static void print_displacement (char *, bfd_vma);
61 static void OP_E (int, int);
62 static void OP_G (int, int);
63 static bfd_vma get64 (void);
64 static bfd_signed_vma get32 (void);
65 static bfd_signed_vma get32s (void);
66 static int get16 (void);
67 static void set_op (bfd_vma, int);
68 static void OP_Skip_MODRM (int, int);
69 static void OP_REG (int, int);
70 static void OP_IMREG (int, int);
71 static void OP_I (int, int);
72 static void OP_I64 (int, int);
73 static void OP_sI (int, int);
74 static void OP_J (int, int);
75 static void OP_SEG (int, int);
76 static void OP_DIR (int, int);
77 static void OP_OFF (int, int);
78 static void OP_OFF64 (int, int);
79 static void ptr_reg (int, int);
80 static void OP_ESreg (int, int);
81 static void OP_DSreg (int, int);
82 static void OP_C (int, int);
83 static void OP_D (int, int);
84 static void OP_T (int, int);
85 static void OP_R (int, int);
86 static void OP_MMX (int, int);
87 static void OP_XMM (int, int);
88 static void OP_EM (int, int);
89 static void OP_EX (int, int);
90 static void OP_EMC (int,int);
91 static void OP_MXC (int,int);
92 static void OP_MS (int, int);
93 static void OP_XS (int, int);
94 static void OP_M (int, int);
95 static void OP_VEX (int, int);
96 static void OP_EX_Vex (int, int);
97 static void OP_EX_VexW (int, int);
98 static void OP_XMM_Vex (int, int);
99 static void OP_XMM_VexW (int, int);
100 static void OP_REG_VexI4 (int, int);
101 static void PCLMUL_Fixup (int, int);
102 static void VEXI4_Fixup (int, int);
103 static void VZERO_Fixup (int, int);
104 static void VCMP_Fixup (int, int);
105 static void OP_0f07 (int, int);
106 static void OP_Monitor (int, int);
107 static void OP_Mwait (int, int);
108 static void NOP_Fixup1 (int, int);
109 static void NOP_Fixup2 (int, int);
110 static void OP_3DNowSuffix (int, int);
111 static void CMP_Fixup (int, int);
112 static void BadOp (void);
113 static void REP_Fixup (int, int);
114 static void CMPXCHG8B_Fixup (int, int);
115 static void XMM_Fixup (int, int);
116 static void CRC32_Fixup (int, int);
117 static void OP_LWPCB_E (int, int);
118 static void OP_LWP_E (int, int);
119 static void OP_LWP_I (int, int);
121 static void MOVBE_Fixup (int, int);
124 /* Points to first byte not fetched. */
125 bfd_byte *max_fetched;
126 bfd_byte the_buffer[MAX_MNEM_SIZE];
139 enum address_mode address_mode;
141 /* Flags for the prefixes for the current instruction. See below. */
144 /* REX prefix the current instruction. See below. */
146 /* Bits of REX we've already used. */
148 /* Original REX prefix. */
149 static int rex_original;
150 /* REX bits in original REX prefix ignored. It may not be the same
151 as rex_original since some bits may not be ignored. */
152 static int rex_ignored;
153 /* Mark parts used in the REX prefix. When we are testing for
154 empty prefix (for 8bit register REX extension), just mask it
155 out. Otherwise test for REX bit is excuse for existence of REX
156 only in case value is nonzero. */
157 #define USED_REX(value) \
162 rex_used |= (value) | REX_OPCODE; \
165 rex_used |= REX_OPCODE; \
168 /* Flags for prefixes which we somehow handled when printing the
169 current instruction. */
170 static int used_prefixes;
172 /* Flags stored in PREFIXES. */
173 #define PREFIX_REPZ 1
174 #define PREFIX_REPNZ 2
175 #define PREFIX_LOCK 4
177 #define PREFIX_SS 0x10
178 #define PREFIX_DS 0x20
179 #define PREFIX_ES 0x40
180 #define PREFIX_FS 0x80
181 #define PREFIX_GS 0x100
182 #define PREFIX_DATA 0x200
183 #define PREFIX_ADDR 0x400
184 #define PREFIX_FWAIT 0x800
186 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
187 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
189 #define FETCH_DATA(info, addr) \
190 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
191 ? 1 : fetch_data ((info), (addr)))
194 fetch_data (struct disassemble_info *info, bfd_byte *addr)
197 struct dis_private *priv = (struct dis_private *) info->private_data;
198 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
200 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
201 status = (*info->read_memory_func) (start,
203 addr - priv->max_fetched,
209 /* If we did manage to read at least one byte, then
210 print_insn_i386 will do something sensible. Otherwise, print
211 an error. We do that here because this is where we know
213 if (priv->max_fetched == priv->the_buffer)
214 (*info->memory_error_func) (status, start, info);
215 longjmp (priv->bailout, 1);
218 priv->max_fetched = addr;
222 #define XX { NULL, 0 }
224 #define Eb { OP_E, b_mode }
225 #define EbS { OP_E, b_swap_mode }
226 #define Ev { OP_E, v_mode }
227 #define EvS { OP_E, v_swap_mode }
228 #define Ed { OP_E, d_mode }
229 #define Edq { OP_E, dq_mode }
230 #define Edqw { OP_E, dqw_mode }
231 #define Edqb { OP_E, dqb_mode }
232 #define Edqd { OP_E, dqd_mode }
233 #define Eq { OP_E, q_mode }
234 #define indirEv { OP_indirE, stack_v_mode }
235 #define indirEp { OP_indirE, f_mode }
236 #define stackEv { OP_E, stack_v_mode }
237 #define Em { OP_E, m_mode }
238 #define Ew { OP_E, w_mode }
239 #define M { OP_M, 0 } /* lea, lgdt, etc. */
240 #define Ma { OP_M, a_mode }
241 #define Mb { OP_M, b_mode }
242 #define Md { OP_M, d_mode }
243 #define Mo { OP_M, o_mode }
244 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
245 #define Mq { OP_M, q_mode }
246 #define Mx { OP_M, x_mode }
247 #define Mxmm { OP_M, xmm_mode }
248 #define Gb { OP_G, b_mode }
249 #define Gv { OP_G, v_mode }
250 #define Gd { OP_G, d_mode }
251 #define Gdq { OP_G, dq_mode }
252 #define Gm { OP_G, m_mode }
253 #define Gw { OP_G, w_mode }
254 #define Rd { OP_R, d_mode }
255 #define Rm { OP_R, m_mode }
256 #define Ib { OP_I, b_mode }
257 #define sIb { OP_sI, b_mode } /* sign extened byte */
258 #define Iv { OP_I, v_mode }
259 #define Iq { OP_I, q_mode }
260 #define Iv64 { OP_I64, v_mode }
261 #define Iw { OP_I, w_mode }
262 #define I1 { OP_I, const_1_mode }
263 #define Jb { OP_J, b_mode }
264 #define Jv { OP_J, v_mode }
265 #define Cm { OP_C, m_mode }
266 #define Dm { OP_D, m_mode }
267 #define Td { OP_T, d_mode }
268 #define Skip_MODRM { OP_Skip_MODRM, 0 }
270 #define RMeAX { OP_REG, eAX_reg }
271 #define RMeBX { OP_REG, eBX_reg }
272 #define RMeCX { OP_REG, eCX_reg }
273 #define RMeDX { OP_REG, eDX_reg }
274 #define RMeSP { OP_REG, eSP_reg }
275 #define RMeBP { OP_REG, eBP_reg }
276 #define RMeSI { OP_REG, eSI_reg }
277 #define RMeDI { OP_REG, eDI_reg }
278 #define RMrAX { OP_REG, rAX_reg }
279 #define RMrBX { OP_REG, rBX_reg }
280 #define RMrCX { OP_REG, rCX_reg }
281 #define RMrDX { OP_REG, rDX_reg }
282 #define RMrSP { OP_REG, rSP_reg }
283 #define RMrBP { OP_REG, rBP_reg }
284 #define RMrSI { OP_REG, rSI_reg }
285 #define RMrDI { OP_REG, rDI_reg }
286 #define RMAL { OP_REG, al_reg }
287 #define RMAL { OP_REG, al_reg }
288 #define RMCL { OP_REG, cl_reg }
289 #define RMDL { OP_REG, dl_reg }
290 #define RMBL { OP_REG, bl_reg }
291 #define RMAH { OP_REG, ah_reg }
292 #define RMCH { OP_REG, ch_reg }
293 #define RMDH { OP_REG, dh_reg }
294 #define RMBH { OP_REG, bh_reg }
295 #define RMAX { OP_REG, ax_reg }
296 #define RMDX { OP_REG, dx_reg }
298 #define eAX { OP_IMREG, eAX_reg }
299 #define eBX { OP_IMREG, eBX_reg }
300 #define eCX { OP_IMREG, eCX_reg }
301 #define eDX { OP_IMREG, eDX_reg }
302 #define eSP { OP_IMREG, eSP_reg }
303 #define eBP { OP_IMREG, eBP_reg }
304 #define eSI { OP_IMREG, eSI_reg }
305 #define eDI { OP_IMREG, eDI_reg }
306 #define AL { OP_IMREG, al_reg }
307 #define CL { OP_IMREG, cl_reg }
308 #define DL { OP_IMREG, dl_reg }
309 #define BL { OP_IMREG, bl_reg }
310 #define AH { OP_IMREG, ah_reg }
311 #define CH { OP_IMREG, ch_reg }
312 #define DH { OP_IMREG, dh_reg }
313 #define BH { OP_IMREG, bh_reg }
314 #define AX { OP_IMREG, ax_reg }
315 #define DX { OP_IMREG, dx_reg }
316 #define zAX { OP_IMREG, z_mode_ax_reg }
317 #define indirDX { OP_IMREG, indir_dx_reg }
319 #define Sw { OP_SEG, w_mode }
320 #define Sv { OP_SEG, v_mode }
321 #define Ap { OP_DIR, 0 }
322 #define Ob { OP_OFF64, b_mode }
323 #define Ov { OP_OFF64, v_mode }
324 #define Xb { OP_DSreg, eSI_reg }
325 #define Xv { OP_DSreg, eSI_reg }
326 #define Xz { OP_DSreg, eSI_reg }
327 #define Yb { OP_ESreg, eDI_reg }
328 #define Yv { OP_ESreg, eDI_reg }
329 #define DSBX { OP_DSreg, eBX_reg }
331 #define es { OP_REG, es_reg }
332 #define ss { OP_REG, ss_reg }
333 #define cs { OP_REG, cs_reg }
334 #define ds { OP_REG, ds_reg }
335 #define fs { OP_REG, fs_reg }
336 #define gs { OP_REG, gs_reg }
338 #define MX { OP_MMX, 0 }
339 #define XM { OP_XMM, 0 }
340 #define XMM { OP_XMM, xmm_mode }
341 #define EM { OP_EM, v_mode }
342 #define EMS { OP_EM, v_swap_mode }
343 #define EMd { OP_EM, d_mode }
344 #define EMx { OP_EM, x_mode }
345 #define EXw { OP_EX, w_mode }
346 #define EXd { OP_EX, d_mode }
347 #define EXdS { OP_EX, d_swap_mode }
348 #define EXq { OP_EX, q_mode }
349 #define EXqS { OP_EX, q_swap_mode }
350 #define EXx { OP_EX, x_mode }
351 #define EXxS { OP_EX, x_swap_mode }
352 #define EXxmm { OP_EX, xmm_mode }
353 #define EXxmmq { OP_EX, xmmq_mode }
354 #define EXymmq { OP_EX, ymmq_mode }
355 #define EXVexWdq { OP_EX, vex_w_dq_mode }
356 #define MS { OP_MS, v_mode }
357 #define XS { OP_XS, v_mode }
358 #define EMCq { OP_EMC, q_mode }
359 #define MXC { OP_MXC, 0 }
360 #define OPSUF { OP_3DNowSuffix, 0 }
361 #define CMP { CMP_Fixup, 0 }
362 #define XMM0 { XMM_Fixup, 0 }
364 #define Vex { OP_VEX, vex_mode }
365 #define Vex128 { OP_VEX, vex128_mode }
366 #define Vex256 { OP_VEX, vex256_mode }
367 #define VexI4 { VEXI4_Fixup, 0}
368 #define EXdVex { OP_EX_Vex, d_mode }
369 #define EXdVexS { OP_EX_Vex, d_swap_mode }
370 #define EXqVex { OP_EX_Vex, q_mode }
371 #define EXqVexS { OP_EX_Vex, q_swap_mode }
372 #define EXVexW { OP_EX_VexW, x_mode }
373 #define EXdVexW { OP_EX_VexW, d_mode }
374 #define EXqVexW { OP_EX_VexW, q_mode }
375 #define XMVex { OP_XMM_Vex, 0 }
376 #define XMVexW { OP_XMM_VexW, 0 }
377 #define XMVexI4 { OP_REG_VexI4, x_mode }
378 #define PCLMUL { PCLMUL_Fixup, 0 }
379 #define VZERO { VZERO_Fixup, 0 }
380 #define VCMP { VCMP_Fixup, 0 }
382 /* Used handle "rep" prefix for string instructions. */
383 #define Xbr { REP_Fixup, eSI_reg }
384 #define Xvr { REP_Fixup, eSI_reg }
385 #define Ybr { REP_Fixup, eDI_reg }
386 #define Yvr { REP_Fixup, eDI_reg }
387 #define Yzr { REP_Fixup, eDI_reg }
388 #define indirDXr { REP_Fixup, indir_dx_reg }
389 #define ALr { REP_Fixup, al_reg }
390 #define eAXr { REP_Fixup, eAX_reg }
392 #define cond_jump_flag { NULL, cond_jump_mode }
393 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
395 /* bits in sizeflag */
396 #define SUFFIX_ALWAYS 4
404 /* byte operand with operand swapped */
406 /* operand size depends on prefixes */
408 /* operand size depends on prefixes with operand swapped */
412 /* double word operand */
414 /* double word operand with operand swapped */
416 /* quad word operand */
418 /* quad word operand with operand swapped */
420 /* ten-byte operand */
422 /* 16-byte XMM or 32-byte YMM operand */
424 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
426 /* 16-byte XMM operand */
428 /* 16-byte XMM or quad word operand */
430 /* 32-byte YMM or quad word operand */
432 /* d_mode in 32bit, q_mode in 64bit mode. */
434 /* pair of v_mode operands */
438 /* operand size depends on REX prefixes. */
440 /* registers like dq_mode, memory like w_mode. */
442 /* 4- or 6-byte pointer operand */
445 /* v_mode for stack-related opcodes. */
447 /* non-quad operand size depends on prefixes */
449 /* 16-byte operand */
451 /* registers like dq_mode, memory like b_mode. */
453 /* registers like dq_mode, memory like d_mode. */
455 /* normal vex mode */
457 /* 128bit vex mode */
459 /* 256bit vex mode */
461 /* operand size depends on the VEX.W bit. */
526 #define FLOAT NULL, { { NULL, FLOATCODE } }
528 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
529 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
530 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
531 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
532 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
533 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
534 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
535 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
536 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
537 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
538 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
656 MOD_VEX_3818_PREFIX_2,
657 MOD_VEX_3819_PREFIX_2,
658 MOD_VEX_381A_PREFIX_2,
659 MOD_VEX_382A_PREFIX_2,
660 MOD_VEX_382C_PREFIX_2,
661 MOD_VEX_382D_PREFIX_2,
662 MOD_VEX_382E_PREFIX_2,
663 MOD_VEX_382F_PREFIX_2
1073 THREE_BYTE_0F38 = 0,
1227 VEX_LEN_3819_P_2_M_0,
1228 VEX_LEN_381A_P_2_M_0,
1240 VEX_LEN_382A_P_2_M_0,
1297 typedef void (*op_rtn) (int bytemode, int sizeflag);
1308 /* Upper case letters in the instruction names here are macros.
1309 'A' => print 'b' if no register operands or suffix_always is true
1310 'B' => print 'b' if suffix_always is true
1311 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1313 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1314 suffix_always is true
1315 'E' => print 'e' if 32-bit form of jcxz
1316 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1317 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1318 'H' => print ",pt" or ",pn" branch hint
1319 'I' => honor following macro letter even in Intel mode (implemented only
1320 for some of the macro letters)
1322 'K' => print 'd' or 'q' if rex prefix is present.
1323 'L' => print 'l' if suffix_always is true
1324 'M' => print 'r' if intel_mnemonic is false.
1325 'N' => print 'n' if instruction has no wait "prefix"
1326 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1327 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1328 or suffix_always is true. print 'q' if rex prefix is present.
1329 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1331 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1332 'S' => print 'w', 'l' or 'q' if suffix_always is true
1333 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1334 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1335 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1336 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1337 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1338 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1339 suffix_always is true.
1340 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1341 '!' => change condition from true to false or from false to true.
1342 '%' => add 1 upper case letter to the macro.
1344 2 upper case letter macros:
1345 "XY" => print 'x' or 'y' if no register operands or suffix_always
1347 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1348 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1349 or suffix_always is true
1350 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1351 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1352 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1354 Many of the above letters print nothing in Intel mode. See "putop"
1357 Braces '{' and '}', and vertical bars '|', indicate alternative
1358 mnemonic strings for AT&T and Intel. */
1360 static const struct dis386 dis386[] = {
1362 { "addB", { Eb, Gb } },
1363 { "addS", { Ev, Gv } },
1364 { "addB", { Gb, EbS } },
1365 { "addS", { Gv, EvS } },
1366 { "addB", { AL, Ib } },
1367 { "addS", { eAX, Iv } },
1368 { X86_64_TABLE (X86_64_06) },
1369 { X86_64_TABLE (X86_64_07) },
1371 { "orB", { Eb, Gb } },
1372 { "orS", { Ev, Gv } },
1373 { "orB", { Gb, EbS } },
1374 { "orS", { Gv, EvS } },
1375 { "orB", { AL, Ib } },
1376 { "orS", { eAX, Iv } },
1377 { X86_64_TABLE (X86_64_0D) },
1378 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
1380 { "adcB", { Eb, Gb } },
1381 { "adcS", { Ev, Gv } },
1382 { "adcB", { Gb, EbS } },
1383 { "adcS", { Gv, EvS } },
1384 { "adcB", { AL, Ib } },
1385 { "adcS", { eAX, Iv } },
1386 { X86_64_TABLE (X86_64_16) },
1387 { X86_64_TABLE (X86_64_17) },
1389 { "sbbB", { Eb, Gb } },
1390 { "sbbS", { Ev, Gv } },
1391 { "sbbB", { Gb, EbS } },
1392 { "sbbS", { Gv, EvS } },
1393 { "sbbB", { AL, Ib } },
1394 { "sbbS", { eAX, Iv } },
1395 { X86_64_TABLE (X86_64_1E) },
1396 { X86_64_TABLE (X86_64_1F) },
1398 { "andB", { Eb, Gb } },
1399 { "andS", { Ev, Gv } },
1400 { "andB", { Gb, EbS } },
1401 { "andS", { Gv, EvS } },
1402 { "andB", { AL, Ib } },
1403 { "andS", { eAX, Iv } },
1404 { "(bad)", { XX } }, /* SEG ES prefix */
1405 { X86_64_TABLE (X86_64_27) },
1407 { "subB", { Eb, Gb } },
1408 { "subS", { Ev, Gv } },
1409 { "subB", { Gb, EbS } },
1410 { "subS", { Gv, EvS } },
1411 { "subB", { AL, Ib } },
1412 { "subS", { eAX, Iv } },
1413 { "(bad)", { XX } }, /* SEG CS prefix */
1414 { X86_64_TABLE (X86_64_2F) },
1416 { "xorB", { Eb, Gb } },
1417 { "xorS", { Ev, Gv } },
1418 { "xorB", { Gb, EbS } },
1419 { "xorS", { Gv, EvS } },
1420 { "xorB", { AL, Ib } },
1421 { "xorS", { eAX, Iv } },
1422 { "(bad)", { XX } }, /* SEG SS prefix */
1423 { X86_64_TABLE (X86_64_37) },
1425 { "cmpB", { Eb, Gb } },
1426 { "cmpS", { Ev, Gv } },
1427 { "cmpB", { Gb, EbS } },
1428 { "cmpS", { Gv, EvS } },
1429 { "cmpB", { AL, Ib } },
1430 { "cmpS", { eAX, Iv } },
1431 { "(bad)", { XX } }, /* SEG DS prefix */
1432 { X86_64_TABLE (X86_64_3F) },
1434 { "inc{S|}", { RMeAX } },
1435 { "inc{S|}", { RMeCX } },
1436 { "inc{S|}", { RMeDX } },
1437 { "inc{S|}", { RMeBX } },
1438 { "inc{S|}", { RMeSP } },
1439 { "inc{S|}", { RMeBP } },
1440 { "inc{S|}", { RMeSI } },
1441 { "inc{S|}", { RMeDI } },
1443 { "dec{S|}", { RMeAX } },
1444 { "dec{S|}", { RMeCX } },
1445 { "dec{S|}", { RMeDX } },
1446 { "dec{S|}", { RMeBX } },
1447 { "dec{S|}", { RMeSP } },
1448 { "dec{S|}", { RMeBP } },
1449 { "dec{S|}", { RMeSI } },
1450 { "dec{S|}", { RMeDI } },
1452 { "pushV", { RMrAX } },
1453 { "pushV", { RMrCX } },
1454 { "pushV", { RMrDX } },
1455 { "pushV", { RMrBX } },
1456 { "pushV", { RMrSP } },
1457 { "pushV", { RMrBP } },
1458 { "pushV", { RMrSI } },
1459 { "pushV", { RMrDI } },
1461 { "popV", { RMrAX } },
1462 { "popV", { RMrCX } },
1463 { "popV", { RMrDX } },
1464 { "popV", { RMrBX } },
1465 { "popV", { RMrSP } },
1466 { "popV", { RMrBP } },
1467 { "popV", { RMrSI } },
1468 { "popV", { RMrDI } },
1470 { X86_64_TABLE (X86_64_60) },
1471 { X86_64_TABLE (X86_64_61) },
1472 { X86_64_TABLE (X86_64_62) },
1473 { X86_64_TABLE (X86_64_63) },
1474 { "(bad)", { XX } }, /* seg fs */
1475 { "(bad)", { XX } }, /* seg gs */
1476 { "(bad)", { XX } }, /* op size prefix */
1477 { "(bad)", { XX } }, /* adr size prefix */
1479 { "pushT", { Iq } },
1480 { "imulS", { Gv, Ev, Iv } },
1481 { "pushT", { sIb } },
1482 { "imulS", { Gv, Ev, sIb } },
1483 { "ins{b|}", { Ybr, indirDX } },
1484 { X86_64_TABLE (X86_64_6D) },
1485 { "outs{b|}", { indirDXr, Xb } },
1486 { X86_64_TABLE (X86_64_6F) },
1488 { "joH", { Jb, XX, cond_jump_flag } },
1489 { "jnoH", { Jb, XX, cond_jump_flag } },
1490 { "jbH", { Jb, XX, cond_jump_flag } },
1491 { "jaeH", { Jb, XX, cond_jump_flag } },
1492 { "jeH", { Jb, XX, cond_jump_flag } },
1493 { "jneH", { Jb, XX, cond_jump_flag } },
1494 { "jbeH", { Jb, XX, cond_jump_flag } },
1495 { "jaH", { Jb, XX, cond_jump_flag } },
1497 { "jsH", { Jb, XX, cond_jump_flag } },
1498 { "jnsH", { Jb, XX, cond_jump_flag } },
1499 { "jpH", { Jb, XX, cond_jump_flag } },
1500 { "jnpH", { Jb, XX, cond_jump_flag } },
1501 { "jlH", { Jb, XX, cond_jump_flag } },
1502 { "jgeH", { Jb, XX, cond_jump_flag } },
1503 { "jleH", { Jb, XX, cond_jump_flag } },
1504 { "jgH", { Jb, XX, cond_jump_flag } },
1506 { REG_TABLE (REG_80) },
1507 { REG_TABLE (REG_81) },
1508 { "(bad)", { XX } },
1509 { REG_TABLE (REG_82) },
1510 { "testB", { Eb, Gb } },
1511 { "testS", { Ev, Gv } },
1512 { "xchgB", { Eb, Gb } },
1513 { "xchgS", { Ev, Gv } },
1515 { "movB", { Eb, Gb } },
1516 { "movS", { Ev, Gv } },
1517 { "movB", { Gb, EbS } },
1518 { "movS", { Gv, EvS } },
1519 { "movD", { Sv, Sw } },
1520 { MOD_TABLE (MOD_8D) },
1521 { "movD", { Sw, Sv } },
1522 { REG_TABLE (REG_8F) },
1524 { PREFIX_TABLE (PREFIX_90) },
1525 { "xchgS", { RMeCX, eAX } },
1526 { "xchgS", { RMeDX, eAX } },
1527 { "xchgS", { RMeBX, eAX } },
1528 { "xchgS", { RMeSP, eAX } },
1529 { "xchgS", { RMeBP, eAX } },
1530 { "xchgS", { RMeSI, eAX } },
1531 { "xchgS", { RMeDI, eAX } },
1533 { "cW{t|}R", { XX } },
1534 { "cR{t|}O", { XX } },
1535 { X86_64_TABLE (X86_64_9A) },
1536 { "(bad)", { XX } }, /* fwait */
1537 { "pushfT", { XX } },
1538 { "popfT", { XX } },
1542 { "mov%LB", { AL, Ob } },
1543 { "mov%LS", { eAX, Ov } },
1544 { "mov%LB", { Ob, AL } },
1545 { "mov%LS", { Ov, eAX } },
1546 { "movs{b|}", { Ybr, Xb } },
1547 { "movs{R|}", { Yvr, Xv } },
1548 { "cmps{b|}", { Xb, Yb } },
1549 { "cmps{R|}", { Xv, Yv } },
1551 { "testB", { AL, Ib } },
1552 { "testS", { eAX, Iv } },
1553 { "stosB", { Ybr, AL } },
1554 { "stosS", { Yvr, eAX } },
1555 { "lodsB", { ALr, Xb } },
1556 { "lodsS", { eAXr, Xv } },
1557 { "scasB", { AL, Yb } },
1558 { "scasS", { eAX, Yv } },
1560 { "movB", { RMAL, Ib } },
1561 { "movB", { RMCL, Ib } },
1562 { "movB", { RMDL, Ib } },
1563 { "movB", { RMBL, Ib } },
1564 { "movB", { RMAH, Ib } },
1565 { "movB", { RMCH, Ib } },
1566 { "movB", { RMDH, Ib } },
1567 { "movB", { RMBH, Ib } },
1569 { "mov%LV", { RMeAX, Iv64 } },
1570 { "mov%LV", { RMeCX, Iv64 } },
1571 { "mov%LV", { RMeDX, Iv64 } },
1572 { "mov%LV", { RMeBX, Iv64 } },
1573 { "mov%LV", { RMeSP, Iv64 } },
1574 { "mov%LV", { RMeBP, Iv64 } },
1575 { "mov%LV", { RMeSI, Iv64 } },
1576 { "mov%LV", { RMeDI, Iv64 } },
1578 { REG_TABLE (REG_C0) },
1579 { REG_TABLE (REG_C1) },
1582 { X86_64_TABLE (X86_64_C4) },
1583 { X86_64_TABLE (X86_64_C5) },
1584 { REG_TABLE (REG_C6) },
1585 { REG_TABLE (REG_C7) },
1587 { "enterT", { Iw, Ib } },
1588 { "leaveT", { XX } },
1589 { "Jret{|f}P", { Iw } },
1590 { "Jret{|f}P", { XX } },
1593 { X86_64_TABLE (X86_64_CE) },
1594 { "iretP", { XX } },
1596 { REG_TABLE (REG_D0) },
1597 { REG_TABLE (REG_D1) },
1598 { REG_TABLE (REG_D2) },
1599 { REG_TABLE (REG_D3) },
1600 { X86_64_TABLE (X86_64_D4) },
1601 { X86_64_TABLE (X86_64_D5) },
1602 { "(bad)", { XX } },
1603 { "xlat", { DSBX } },
1614 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
1615 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
1616 { "loopFH", { Jb, XX, loop_jcxz_flag } },
1617 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
1618 { "inB", { AL, Ib } },
1619 { "inG", { zAX, Ib } },
1620 { "outB", { Ib, AL } },
1621 { "outG", { Ib, zAX } },
1623 { "callT", { Jv } },
1625 { X86_64_TABLE (X86_64_EA) },
1627 { "inB", { AL, indirDX } },
1628 { "inG", { zAX, indirDX } },
1629 { "outB", { indirDX, AL } },
1630 { "outG", { indirDX, zAX } },
1632 { "(bad)", { XX } }, /* lock prefix */
1633 { "icebp", { XX } },
1634 { "(bad)", { XX } }, /* repne */
1635 { "(bad)", { XX } }, /* repz */
1638 { REG_TABLE (REG_F6) },
1639 { REG_TABLE (REG_F7) },
1647 { REG_TABLE (REG_FE) },
1648 { REG_TABLE (REG_FF) },
1651 static const struct dis386 dis386_twobyte[] = {
1653 { REG_TABLE (REG_0F00 ) },
1654 { REG_TABLE (REG_0F01 ) },
1655 { "larS", { Gv, Ew } },
1656 { "lslS", { Gv, Ew } },
1657 { "(bad)", { XX } },
1658 { "syscall", { XX } },
1660 { "sysretP", { XX } },
1663 { "wbinvd", { XX } },
1664 { "(bad)", { XX } },
1666 { "(bad)", { XX } },
1667 { REG_TABLE (REG_0F0D) },
1668 { "femms", { XX } },
1669 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1671 { PREFIX_TABLE (PREFIX_0F10) },
1672 { PREFIX_TABLE (PREFIX_0F11) },
1673 { PREFIX_TABLE (PREFIX_0F12) },
1674 { MOD_TABLE (MOD_0F13) },
1675 { "unpcklpX", { XM, EXx } },
1676 { "unpckhpX", { XM, EXx } },
1677 { PREFIX_TABLE (PREFIX_0F16) },
1678 { MOD_TABLE (MOD_0F17) },
1680 { REG_TABLE (REG_0F18) },
1689 { MOD_TABLE (MOD_0F20) },
1690 { MOD_TABLE (MOD_0F21) },
1691 { MOD_TABLE (MOD_0F22) },
1692 { MOD_TABLE (MOD_0F23) },
1693 { MOD_TABLE (MOD_0F24) },
1694 { "(bad)", { XX } },
1695 { MOD_TABLE (MOD_0F26) },
1696 { "(bad)", { XX } },
1698 { "movapX", { XM, EXx } },
1699 { "movapX", { EXxS, XM } },
1700 { PREFIX_TABLE (PREFIX_0F2A) },
1701 { PREFIX_TABLE (PREFIX_0F2B) },
1702 { PREFIX_TABLE (PREFIX_0F2C) },
1703 { PREFIX_TABLE (PREFIX_0F2D) },
1704 { PREFIX_TABLE (PREFIX_0F2E) },
1705 { PREFIX_TABLE (PREFIX_0F2F) },
1707 { "wrmsr", { XX } },
1708 { "rdtsc", { XX } },
1709 { "rdmsr", { XX } },
1710 { "rdpmc", { XX } },
1711 { "sysenter", { XX } },
1712 { "sysexit", { XX } },
1713 { "(bad)", { XX } },
1714 { "getsec", { XX } },
1716 { THREE_BYTE_TABLE (THREE_BYTE_0F38) },
1717 { "(bad)", { XX } },
1718 { THREE_BYTE_TABLE (THREE_BYTE_0F3A) },
1719 { "(bad)", { XX } },
1720 { "(bad)", { XX } },
1721 { "(bad)", { XX } },
1722 { "(bad)", { XX } },
1723 { "(bad)", { XX } },
1725 { "cmovoS", { Gv, Ev } },
1726 { "cmovnoS", { Gv, Ev } },
1727 { "cmovbS", { Gv, Ev } },
1728 { "cmovaeS", { Gv, Ev } },
1729 { "cmoveS", { Gv, Ev } },
1730 { "cmovneS", { Gv, Ev } },
1731 { "cmovbeS", { Gv, Ev } },
1732 { "cmovaS", { Gv, Ev } },
1734 { "cmovsS", { Gv, Ev } },
1735 { "cmovnsS", { Gv, Ev } },
1736 { "cmovpS", { Gv, Ev } },
1737 { "cmovnpS", { Gv, Ev } },
1738 { "cmovlS", { Gv, Ev } },
1739 { "cmovgeS", { Gv, Ev } },
1740 { "cmovleS", { Gv, Ev } },
1741 { "cmovgS", { Gv, Ev } },
1743 { MOD_TABLE (MOD_0F51) },
1744 { PREFIX_TABLE (PREFIX_0F51) },
1745 { PREFIX_TABLE (PREFIX_0F52) },
1746 { PREFIX_TABLE (PREFIX_0F53) },
1747 { "andpX", { XM, EXx } },
1748 { "andnpX", { XM, EXx } },
1749 { "orpX", { XM, EXx } },
1750 { "xorpX", { XM, EXx } },
1752 { PREFIX_TABLE (PREFIX_0F58) },
1753 { PREFIX_TABLE (PREFIX_0F59) },
1754 { PREFIX_TABLE (PREFIX_0F5A) },
1755 { PREFIX_TABLE (PREFIX_0F5B) },
1756 { PREFIX_TABLE (PREFIX_0F5C) },
1757 { PREFIX_TABLE (PREFIX_0F5D) },
1758 { PREFIX_TABLE (PREFIX_0F5E) },
1759 { PREFIX_TABLE (PREFIX_0F5F) },
1761 { PREFIX_TABLE (PREFIX_0F60) },
1762 { PREFIX_TABLE (PREFIX_0F61) },
1763 { PREFIX_TABLE (PREFIX_0F62) },
1764 { "packsswb", { MX, EM } },
1765 { "pcmpgtb", { MX, EM } },
1766 { "pcmpgtw", { MX, EM } },
1767 { "pcmpgtd", { MX, EM } },
1768 { "packuswb", { MX, EM } },
1770 { "punpckhbw", { MX, EM } },
1771 { "punpckhwd", { MX, EM } },
1772 { "punpckhdq", { MX, EM } },
1773 { "packssdw", { MX, EM } },
1774 { PREFIX_TABLE (PREFIX_0F6C) },
1775 { PREFIX_TABLE (PREFIX_0F6D) },
1776 { "movK", { MX, Edq } },
1777 { PREFIX_TABLE (PREFIX_0F6F) },
1779 { PREFIX_TABLE (PREFIX_0F70) },
1780 { REG_TABLE (REG_0F71) },
1781 { REG_TABLE (REG_0F72) },
1782 { REG_TABLE (REG_0F73) },
1783 { "pcmpeqb", { MX, EM } },
1784 { "pcmpeqw", { MX, EM } },
1785 { "pcmpeqd", { MX, EM } },
1788 { PREFIX_TABLE (PREFIX_0F78) },
1789 { PREFIX_TABLE (PREFIX_0F79) },
1790 { THREE_BYTE_TABLE (THREE_BYTE_0F7A) },
1791 { "(bad)", { XX } },
1792 { PREFIX_TABLE (PREFIX_0F7C) },
1793 { PREFIX_TABLE (PREFIX_0F7D) },
1794 { PREFIX_TABLE (PREFIX_0F7E) },
1795 { PREFIX_TABLE (PREFIX_0F7F) },
1797 { "joH", { Jv, XX, cond_jump_flag } },
1798 { "jnoH", { Jv, XX, cond_jump_flag } },
1799 { "jbH", { Jv, XX, cond_jump_flag } },
1800 { "jaeH", { Jv, XX, cond_jump_flag } },
1801 { "jeH", { Jv, XX, cond_jump_flag } },
1802 { "jneH", { Jv, XX, cond_jump_flag } },
1803 { "jbeH", { Jv, XX, cond_jump_flag } },
1804 { "jaH", { Jv, XX, cond_jump_flag } },
1806 { "jsH", { Jv, XX, cond_jump_flag } },
1807 { "jnsH", { Jv, XX, cond_jump_flag } },
1808 { "jpH", { Jv, XX, cond_jump_flag } },
1809 { "jnpH", { Jv, XX, cond_jump_flag } },
1810 { "jlH", { Jv, XX, cond_jump_flag } },
1811 { "jgeH", { Jv, XX, cond_jump_flag } },
1812 { "jleH", { Jv, XX, cond_jump_flag } },
1813 { "jgH", { Jv, XX, cond_jump_flag } },
1816 { "setno", { Eb } },
1818 { "setae", { Eb } },
1820 { "setne", { Eb } },
1821 { "setbe", { Eb } },
1825 { "setns", { Eb } },
1827 { "setnp", { Eb } },
1829 { "setge", { Eb } },
1830 { "setle", { Eb } },
1833 { "pushT", { fs } },
1835 { "cpuid", { XX } },
1836 { "btS", { Ev, Gv } },
1837 { "shldS", { Ev, Gv, Ib } },
1838 { "shldS", { Ev, Gv, CL } },
1839 { REG_TABLE (REG_0FA6) },
1840 { REG_TABLE (REG_0FA7) },
1842 { "pushT", { gs } },
1845 { "btsS", { Ev, Gv } },
1846 { "shrdS", { Ev, Gv, Ib } },
1847 { "shrdS", { Ev, Gv, CL } },
1848 { REG_TABLE (REG_0FAE) },
1849 { "imulS", { Gv, Ev } },
1851 { "cmpxchgB", { Eb, Gb } },
1852 { "cmpxchgS", { Ev, Gv } },
1853 { MOD_TABLE (MOD_0FB2) },
1854 { "btrS", { Ev, Gv } },
1855 { MOD_TABLE (MOD_0FB4) },
1856 { MOD_TABLE (MOD_0FB5) },
1857 { "movz{bR|x}", { Gv, Eb } },
1858 { "movz{wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
1860 { PREFIX_TABLE (PREFIX_0FB8) },
1862 { REG_TABLE (REG_0FBA) },
1863 { "btcS", { Ev, Gv } },
1864 { "bsfS", { Gv, Ev } },
1865 { PREFIX_TABLE (PREFIX_0FBD) },
1866 { "movs{bR|x}", { Gv, Eb } },
1867 { "movs{wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
1869 { "xaddB", { Eb, Gb } },
1870 { "xaddS", { Ev, Gv } },
1871 { PREFIX_TABLE (PREFIX_0FC2) },
1872 { PREFIX_TABLE (PREFIX_0FC3) },
1873 { "pinsrw", { MX, Edqw, Ib } },
1874 { "pextrw", { Gdq, MS, Ib } },
1875 { "shufpX", { XM, EXx, Ib } },
1876 { REG_TABLE (REG_0FC7) },
1878 { "bswap", { RMeAX } },
1879 { "bswap", { RMeCX } },
1880 { "bswap", { RMeDX } },
1881 { "bswap", { RMeBX } },
1882 { "bswap", { RMeSP } },
1883 { "bswap", { RMeBP } },
1884 { "bswap", { RMeSI } },
1885 { "bswap", { RMeDI } },
1887 { PREFIX_TABLE (PREFIX_0FD0) },
1888 { "psrlw", { MX, EM } },
1889 { "psrld", { MX, EM } },
1890 { "psrlq", { MX, EM } },
1891 { "paddq", { MX, EM } },
1892 { "pmullw", { MX, EM } },
1893 { PREFIX_TABLE (PREFIX_0FD6) },
1894 { MOD_TABLE (MOD_0FD7) },
1896 { "psubusb", { MX, EM } },
1897 { "psubusw", { MX, EM } },
1898 { "pminub", { MX, EM } },
1899 { "pand", { MX, EM } },
1900 { "paddusb", { MX, EM } },
1901 { "paddusw", { MX, EM } },
1902 { "pmaxub", { MX, EM } },
1903 { "pandn", { MX, EM } },
1905 { "pavgb", { MX, EM } },
1906 { "psraw", { MX, EM } },
1907 { "psrad", { MX, EM } },
1908 { "pavgw", { MX, EM } },
1909 { "pmulhuw", { MX, EM } },
1910 { "pmulhw", { MX, EM } },
1911 { PREFIX_TABLE (PREFIX_0FE6) },
1912 { PREFIX_TABLE (PREFIX_0FE7) },
1914 { "psubsb", { MX, EM } },
1915 { "psubsw", { MX, EM } },
1916 { "pminsw", { MX, EM } },
1917 { "por", { MX, EM } },
1918 { "paddsb", { MX, EM } },
1919 { "paddsw", { MX, EM } },
1920 { "pmaxsw", { MX, EM } },
1921 { "pxor", { MX, EM } },
1923 { PREFIX_TABLE (PREFIX_0FF0) },
1924 { "psllw", { MX, EM } },
1925 { "pslld", { MX, EM } },
1926 { "psllq", { MX, EM } },
1927 { "pmuludq", { MX, EM } },
1928 { "pmaddwd", { MX, EM } },
1929 { "psadbw", { MX, EM } },
1930 { PREFIX_TABLE (PREFIX_0FF7) },
1932 { "psubb", { MX, EM } },
1933 { "psubw", { MX, EM } },
1934 { "psubd", { MX, EM } },
1935 { "psubq", { MX, EM } },
1936 { "paddb", { MX, EM } },
1937 { "paddw", { MX, EM } },
1938 { "paddd", { MX, EM } },
1939 { "(bad)", { XX } },
1942 static const unsigned char onebyte_has_modrm[256] = {
1943 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1944 /* ------------------------------- */
1945 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1946 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1947 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1948 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1949 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1950 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1951 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1952 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1953 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1954 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1955 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1956 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1957 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1958 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1959 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1960 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1961 /* ------------------------------- */
1962 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1965 static const unsigned char twobyte_has_modrm[256] = {
1966 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1967 /* ------------------------------- */
1968 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1969 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
1970 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1971 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1972 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1973 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1974 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1975 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1976 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1977 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1978 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1979 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1980 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1981 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1982 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1983 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1984 /* ------------------------------- */
1985 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1988 static char obuf[100];
1990 static char *mnemonicendp;
1991 static char scratchbuf[100];
1992 static unsigned char *start_codep;
1993 static unsigned char *insn_codep;
1994 static unsigned char *codep;
1995 static const char *lock_prefix;
1996 static const char *data_prefix;
1997 static const char *addr_prefix;
1998 static const char *repz_prefix;
1999 static const char *repnz_prefix;
2000 static disassemble_info *the_info;
2008 static unsigned char need_modrm;
2011 int register_specifier;
2017 static unsigned char need_vex;
2018 static unsigned char need_vex_reg;
2019 static unsigned char vex_w_done;
2027 /* If we are accessing mod/rm/reg without need_modrm set, then the
2028 values are stale. Hitting this abort likely indicates that you
2029 need to update onebyte_has_modrm or twobyte_has_modrm. */
2030 #define MODRM_CHECK if (!need_modrm) abort ()
2032 static const char **names64;
2033 static const char **names32;
2034 static const char **names16;
2035 static const char **names8;
2036 static const char **names8rex;
2037 static const char **names_seg;
2038 static const char *index64;
2039 static const char *index32;
2040 static const char **index16;
2042 static const char *intel_names64[] = {
2043 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2044 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2046 static const char *intel_names32[] = {
2047 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2048 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2050 static const char *intel_names16[] = {
2051 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2052 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2054 static const char *intel_names8[] = {
2055 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2057 static const char *intel_names8rex[] = {
2058 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2059 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2061 static const char *intel_names_seg[] = {
2062 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2064 static const char *intel_index64 = "riz";
2065 static const char *intel_index32 = "eiz";
2066 static const char *intel_index16[] = {
2067 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2070 static const char *att_names64[] = {
2071 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2072 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2074 static const char *att_names32[] = {
2075 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2076 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2078 static const char *att_names16[] = {
2079 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2080 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2082 static const char *att_names8[] = {
2083 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2085 static const char *att_names8rex[] = {
2086 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2087 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2089 static const char *att_names_seg[] = {
2090 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2092 static const char *att_index64 = "%riz";
2093 static const char *att_index32 = "%eiz";
2094 static const char *att_index16[] = {
2095 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2098 static const struct dis386 reg_table[][8] = {
2101 { "addA", { Eb, Ib } },
2102 { "orA", { Eb, Ib } },
2103 { "adcA", { Eb, Ib } },
2104 { "sbbA", { Eb, Ib } },
2105 { "andA", { Eb, Ib } },
2106 { "subA", { Eb, Ib } },
2107 { "xorA", { Eb, Ib } },
2108 { "cmpA", { Eb, Ib } },
2112 { "addQ", { Ev, Iv } },
2113 { "orQ", { Ev, Iv } },
2114 { "adcQ", { Ev, Iv } },
2115 { "sbbQ", { Ev, Iv } },
2116 { "andQ", { Ev, Iv } },
2117 { "subQ", { Ev, Iv } },
2118 { "xorQ", { Ev, Iv } },
2119 { "cmpQ", { Ev, Iv } },
2123 { "addQ", { Ev, sIb } },
2124 { "orQ", { Ev, sIb } },
2125 { "adcQ", { Ev, sIb } },
2126 { "sbbQ", { Ev, sIb } },
2127 { "andQ", { Ev, sIb } },
2128 { "subQ", { Ev, sIb } },
2129 { "xorQ", { Ev, sIb } },
2130 { "cmpQ", { Ev, sIb } },
2134 { "popU", { stackEv } },
2135 { "(bad)", { XX } },
2136 { "(bad)", { XX } },
2137 { "(bad)", { XX } },
2138 { "(bad)", { XX } },
2139 { XOP_8F_TABLE (XOP_09) },
2140 { "(bad)", { XX } },
2141 { "(bad)", { XX } },
2145 { "rolA", { Eb, Ib } },
2146 { "rorA", { Eb, Ib } },
2147 { "rclA", { Eb, Ib } },
2148 { "rcrA", { Eb, Ib } },
2149 { "shlA", { Eb, Ib } },
2150 { "shrA", { Eb, Ib } },
2151 { "(bad)", { XX } },
2152 { "sarA", { Eb, Ib } },
2156 { "rolQ", { Ev, Ib } },
2157 { "rorQ", { Ev, Ib } },
2158 { "rclQ", { Ev, Ib } },
2159 { "rcrQ", { Ev, Ib } },
2160 { "shlQ", { Ev, Ib } },
2161 { "shrQ", { Ev, Ib } },
2162 { "(bad)", { XX } },
2163 { "sarQ", { Ev, Ib } },
2167 { "movA", { Eb, Ib } },
2168 { "(bad)", { XX } },
2169 { "(bad)", { XX } },
2170 { "(bad)", { XX } },
2171 { "(bad)", { XX } },
2172 { "(bad)", { XX } },
2173 { "(bad)", { XX } },
2174 { "(bad)", { XX } },
2178 { "movQ", { Ev, Iv } },
2179 { "(bad)", { XX } },
2180 { "(bad)", { XX } },
2181 { "(bad)", { XX } },
2182 { "(bad)", { XX } },
2183 { "(bad)", { XX } },
2184 { "(bad)", { XX } },
2185 { "(bad)", { XX } },
2189 { "rolA", { Eb, I1 } },
2190 { "rorA", { Eb, I1 } },
2191 { "rclA", { Eb, I1 } },
2192 { "rcrA", { Eb, I1 } },
2193 { "shlA", { Eb, I1 } },
2194 { "shrA", { Eb, I1 } },
2195 { "(bad)", { XX } },
2196 { "sarA", { Eb, I1 } },
2200 { "rolQ", { Ev, I1 } },
2201 { "rorQ", { Ev, I1 } },
2202 { "rclQ", { Ev, I1 } },
2203 { "rcrQ", { Ev, I1 } },
2204 { "shlQ", { Ev, I1 } },
2205 { "shrQ", { Ev, I1 } },
2206 { "(bad)", { XX } },
2207 { "sarQ", { Ev, I1 } },
2211 { "rolA", { Eb, CL } },
2212 { "rorA", { Eb, CL } },
2213 { "rclA", { Eb, CL } },
2214 { "rcrA", { Eb, CL } },
2215 { "shlA", { Eb, CL } },
2216 { "shrA", { Eb, CL } },
2217 { "(bad)", { XX } },
2218 { "sarA", { Eb, CL } },
2222 { "rolQ", { Ev, CL } },
2223 { "rorQ", { Ev, CL } },
2224 { "rclQ", { Ev, CL } },
2225 { "rcrQ", { Ev, CL } },
2226 { "shlQ", { Ev, CL } },
2227 { "shrQ", { Ev, CL } },
2228 { "(bad)", { XX } },
2229 { "sarQ", { Ev, CL } },
2233 { "testA", { Eb, Ib } },
2234 { "(bad)", { XX } },
2237 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
2238 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
2239 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
2240 { "idivA", { Eb } }, /* and idiv for consistency. */
2244 { "testQ", { Ev, Iv } },
2245 { "(bad)", { XX } },
2248 { "mulQ", { Ev } }, /* Don't print the implicit register. */
2249 { "imulQ", { Ev } },
2251 { "idivQ", { Ev } },
2257 { "(bad)", { XX } },
2258 { "(bad)", { XX } },
2259 { "(bad)", { XX } },
2260 { "(bad)", { XX } },
2261 { "(bad)", { XX } },
2262 { "(bad)", { XX } },
2268 { "callT", { indirEv } },
2269 { "JcallT", { indirEp } },
2270 { "jmpT", { indirEv } },
2271 { "JjmpT", { indirEp } },
2272 { "pushU", { stackEv } },
2273 { "(bad)", { XX } },
2277 { "sldtD", { Sv } },
2283 { "(bad)", { XX } },
2284 { "(bad)", { XX } },
2288 { MOD_TABLE (MOD_0F01_REG_0) },
2289 { MOD_TABLE (MOD_0F01_REG_1) },
2290 { MOD_TABLE (MOD_0F01_REG_2) },
2291 { MOD_TABLE (MOD_0F01_REG_3) },
2292 { "smswD", { Sv } },
2293 { "(bad)", { XX } },
2295 { MOD_TABLE (MOD_0F01_REG_7) },
2299 { "prefetch", { Eb } },
2300 { "prefetchw", { Eb } },
2301 { "(bad)", { XX } },
2302 { "(bad)", { XX } },
2303 { "(bad)", { XX } },
2304 { "(bad)", { XX } },
2305 { "(bad)", { XX } },
2306 { "(bad)", { XX } },
2310 { MOD_TABLE (MOD_0F18_REG_0) },
2311 { MOD_TABLE (MOD_0F18_REG_1) },
2312 { MOD_TABLE (MOD_0F18_REG_2) },
2313 { MOD_TABLE (MOD_0F18_REG_3) },
2314 { "(bad)", { XX } },
2315 { "(bad)", { XX } },
2316 { "(bad)", { XX } },
2317 { "(bad)", { XX } },
2321 { "(bad)", { XX } },
2322 { "(bad)", { XX } },
2323 { MOD_TABLE (MOD_0F71_REG_2) },
2324 { "(bad)", { XX } },
2325 { MOD_TABLE (MOD_0F71_REG_4) },
2326 { "(bad)", { XX } },
2327 { MOD_TABLE (MOD_0F71_REG_6) },
2328 { "(bad)", { XX } },
2332 { "(bad)", { XX } },
2333 { "(bad)", { XX } },
2334 { MOD_TABLE (MOD_0F72_REG_2) },
2335 { "(bad)", { XX } },
2336 { MOD_TABLE (MOD_0F72_REG_4) },
2337 { "(bad)", { XX } },
2338 { MOD_TABLE (MOD_0F72_REG_6) },
2339 { "(bad)", { XX } },
2343 { "(bad)", { XX } },
2344 { "(bad)", { XX } },
2345 { MOD_TABLE (MOD_0F73_REG_2) },
2346 { MOD_TABLE (MOD_0F73_REG_3) },
2347 { "(bad)", { XX } },
2348 { "(bad)", { XX } },
2349 { MOD_TABLE (MOD_0F73_REG_6) },
2350 { MOD_TABLE (MOD_0F73_REG_7) },
2354 { "montmul", { { OP_0f07, 0 } } },
2355 { "xsha1", { { OP_0f07, 0 } } },
2356 { "xsha256", { { OP_0f07, 0 } } },
2357 { "(bad)", { { OP_0f07, 0 } } },
2358 { "(bad)", { { OP_0f07, 0 } } },
2359 { "(bad)", { { OP_0f07, 0 } } },
2360 { "(bad)", { { OP_0f07, 0 } } },
2361 { "(bad)", { { OP_0f07, 0 } } },
2365 { "xstore-rng", { { OP_0f07, 0 } } },
2366 { "xcrypt-ecb", { { OP_0f07, 0 } } },
2367 { "xcrypt-cbc", { { OP_0f07, 0 } } },
2368 { "xcrypt-ctr", { { OP_0f07, 0 } } },
2369 { "xcrypt-cfb", { { OP_0f07, 0 } } },
2370 { "xcrypt-ofb", { { OP_0f07, 0 } } },
2371 { "(bad)", { { OP_0f07, 0 } } },
2372 { "(bad)", { { OP_0f07, 0 } } },
2376 { MOD_TABLE (MOD_0FAE_REG_0) },
2377 { MOD_TABLE (MOD_0FAE_REG_1) },
2378 { MOD_TABLE (MOD_0FAE_REG_2) },
2379 { MOD_TABLE (MOD_0FAE_REG_3) },
2380 { MOD_TABLE (MOD_0FAE_REG_4) },
2381 { MOD_TABLE (MOD_0FAE_REG_5) },
2382 { MOD_TABLE (MOD_0FAE_REG_6) },
2383 { MOD_TABLE (MOD_0FAE_REG_7) },
2387 { "(bad)", { XX } },
2388 { "(bad)", { XX } },
2389 { "(bad)", { XX } },
2390 { "(bad)", { XX } },
2391 { "btQ", { Ev, Ib } },
2392 { "btsQ", { Ev, Ib } },
2393 { "btrQ", { Ev, Ib } },
2394 { "btcQ", { Ev, Ib } },
2398 { "(bad)", { XX } },
2399 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
2400 { "(bad)", { XX } },
2401 { "(bad)", { XX } },
2402 { "(bad)", { XX } },
2403 { "(bad)", { XX } },
2404 { MOD_TABLE (MOD_0FC7_REG_6) },
2405 { MOD_TABLE (MOD_0FC7_REG_7) },
2409 { "(bad)", { XX } },
2410 { "(bad)", { XX } },
2411 { MOD_TABLE (MOD_VEX_71_REG_2) },
2412 { "(bad)", { XX } },
2413 { MOD_TABLE (MOD_VEX_71_REG_4) },
2414 { "(bad)", { XX } },
2415 { MOD_TABLE (MOD_VEX_71_REG_6) },
2416 { "(bad)", { XX } },
2420 { "(bad)", { XX } },
2421 { "(bad)", { XX } },
2422 { MOD_TABLE (MOD_VEX_72_REG_2) },
2423 { "(bad)", { XX } },
2424 { MOD_TABLE (MOD_VEX_72_REG_4) },
2425 { "(bad)", { XX } },
2426 { MOD_TABLE (MOD_VEX_72_REG_6) },
2427 { "(bad)", { XX } },
2431 { "(bad)", { XX } },
2432 { "(bad)", { XX } },
2433 { MOD_TABLE (MOD_VEX_73_REG_2) },
2434 { MOD_TABLE (MOD_VEX_73_REG_3) },
2435 { "(bad)", { XX } },
2436 { "(bad)", { XX } },
2437 { MOD_TABLE (MOD_VEX_73_REG_6) },
2438 { MOD_TABLE (MOD_VEX_73_REG_7) },
2442 { "(bad)", { XX } },
2443 { "(bad)", { XX } },
2444 { MOD_TABLE (MOD_VEX_AE_REG_2) },
2445 { MOD_TABLE (MOD_VEX_AE_REG_3) },
2446 { "(bad)", { XX } },
2447 { "(bad)", { XX } },
2448 { "(bad)", { XX } },
2449 { "(bad)", { XX } },
2453 { "llwpcb", { { OP_LWPCB_E, 0 } } },
2454 { "slwpcb", { { OP_LWPCB_E, 0 } } },
2455 { "(bad)", { XX } },
2456 { "(bad)", { XX } },
2457 { "(bad)", { XX } },
2458 { "(bad)", { XX } },
2459 { "(bad)", { XX } },
2460 { "(bad)", { XX } },
2464 { "lwpins", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2465 { "lwpval", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2466 { "(bad)", { XX } },
2467 { "(bad)", { XX } },
2468 { "(bad)", { XX } },
2469 { "(bad)", { XX } },
2470 { "(bad)", { XX } },
2471 { "(bad)", { XX } },
2475 static const struct dis386 prefix_table[][4] = {
2478 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2479 { "pause", { XX } },
2480 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2481 { "(bad)", { XX } },
2486 { "movups", { XM, EXx } },
2487 { "movss", { XM, EXd } },
2488 { "movupd", { XM, EXx } },
2489 { "movsd", { XM, EXq } },
2494 { "movups", { EXxS, XM } },
2495 { "movss", { EXdS, XM } },
2496 { "movupd", { EXxS, XM } },
2497 { "movsd", { EXqS, XM } },
2502 { MOD_TABLE (MOD_0F12_PREFIX_0) },
2503 { "movsldup", { XM, EXx } },
2504 { "movlpd", { XM, EXq } },
2505 { "movddup", { XM, EXq } },
2510 { MOD_TABLE (MOD_0F16_PREFIX_0) },
2511 { "movshdup", { XM, EXx } },
2512 { "movhpd", { XM, EXq } },
2513 { "(bad)", { XX } },
2518 { "cvtpi2ps", { XM, EMCq } },
2519 { "cvtsi2ss%LQ", { XM, Ev } },
2520 { "cvtpi2pd", { XM, EMCq } },
2521 { "cvtsi2sd%LQ", { XM, Ev } },
2526 { MOD_TABLE (MOD_0F2B_PREFIX_0) },
2527 { MOD_TABLE (MOD_0F2B_PREFIX_1) },
2528 { MOD_TABLE (MOD_0F2B_PREFIX_2) },
2529 { MOD_TABLE (MOD_0F2B_PREFIX_3) },
2534 { "cvttps2pi", { MXC, EXq } },
2535 { "cvttss2siY", { Gv, EXd } },
2536 { "cvttpd2pi", { MXC, EXx } },
2537 { "cvttsd2siY", { Gv, EXq } },
2542 { "cvtps2pi", { MXC, EXq } },
2543 { "cvtss2siY", { Gv, EXd } },
2544 { "cvtpd2pi", { MXC, EXx } },
2545 { "cvtsd2siY", { Gv, EXq } },
2550 { "ucomiss",{ XM, EXd } },
2551 { "(bad)", { XX } },
2552 { "ucomisd",{ XM, EXq } },
2553 { "(bad)", { XX } },
2558 { "comiss", { XM, EXd } },
2559 { "(bad)", { XX } },
2560 { "comisd", { XM, EXq } },
2561 { "(bad)", { XX } },
2566 { "sqrtps", { XM, EXx } },
2567 { "sqrtss", { XM, EXd } },
2568 { "sqrtpd", { XM, EXx } },
2569 { "sqrtsd", { XM, EXq } },
2574 { "rsqrtps",{ XM, EXx } },
2575 { "rsqrtss",{ XM, EXd } },
2576 { "(bad)", { XX } },
2577 { "(bad)", { XX } },
2582 { "rcpps", { XM, EXx } },
2583 { "rcpss", { XM, EXd } },
2584 { "(bad)", { XX } },
2585 { "(bad)", { XX } },
2590 { "addps", { XM, EXx } },
2591 { "addss", { XM, EXd } },
2592 { "addpd", { XM, EXx } },
2593 { "addsd", { XM, EXq } },
2598 { "mulps", { XM, EXx } },
2599 { "mulss", { XM, EXd } },
2600 { "mulpd", { XM, EXx } },
2601 { "mulsd", { XM, EXq } },
2606 { "cvtps2pd", { XM, EXq } },
2607 { "cvtss2sd", { XM, EXd } },
2608 { "cvtpd2ps", { XM, EXx } },
2609 { "cvtsd2ss", { XM, EXq } },
2614 { "cvtdq2ps", { XM, EXx } },
2615 { "cvttps2dq", { XM, EXx } },
2616 { "cvtps2dq", { XM, EXx } },
2617 { "(bad)", { XX } },
2622 { "subps", { XM, EXx } },
2623 { "subss", { XM, EXd } },
2624 { "subpd", { XM, EXx } },
2625 { "subsd", { XM, EXq } },
2630 { "minps", { XM, EXx } },
2631 { "minss", { XM, EXd } },
2632 { "minpd", { XM, EXx } },
2633 { "minsd", { XM, EXq } },
2638 { "divps", { XM, EXx } },
2639 { "divss", { XM, EXd } },
2640 { "divpd", { XM, EXx } },
2641 { "divsd", { XM, EXq } },
2646 { "maxps", { XM, EXx } },
2647 { "maxss", { XM, EXd } },
2648 { "maxpd", { XM, EXx } },
2649 { "maxsd", { XM, EXq } },
2654 { "punpcklbw",{ MX, EMd } },
2655 { "(bad)", { XX } },
2656 { "punpcklbw",{ MX, EMx } },
2657 { "(bad)", { XX } },
2662 { "punpcklwd",{ MX, EMd } },
2663 { "(bad)", { XX } },
2664 { "punpcklwd",{ MX, EMx } },
2665 { "(bad)", { XX } },
2670 { "punpckldq",{ MX, EMd } },
2671 { "(bad)", { XX } },
2672 { "punpckldq",{ MX, EMx } },
2673 { "(bad)", { XX } },
2678 { "(bad)", { XX } },
2679 { "(bad)", { XX } },
2680 { "punpcklqdq", { XM, EXx } },
2681 { "(bad)", { XX } },
2686 { "(bad)", { XX } },
2687 { "(bad)", { XX } },
2688 { "punpckhqdq", { XM, EXx } },
2689 { "(bad)", { XX } },
2694 { "movq", { MX, EM } },
2695 { "movdqu", { XM, EXx } },
2696 { "movdqa", { XM, EXx } },
2697 { "(bad)", { XX } },
2702 { "pshufw", { MX, EM, Ib } },
2703 { "pshufhw",{ XM, EXx, Ib } },
2704 { "pshufd", { XM, EXx, Ib } },
2705 { "pshuflw",{ XM, EXx, Ib } },
2708 /* PREFIX_0F73_REG_3 */
2710 { "(bad)", { XX } },
2711 { "(bad)", { XX } },
2712 { "psrldq", { XS, Ib } },
2713 { "(bad)", { XX } },
2716 /* PREFIX_0F73_REG_7 */
2718 { "(bad)", { XX } },
2719 { "(bad)", { XX } },
2720 { "pslldq", { XS, Ib } },
2721 { "(bad)", { XX } },
2726 {"vmread", { Em, Gm } },
2728 {"extrq", { XS, Ib, Ib } },
2729 {"insertq", { XM, XS, Ib, Ib } },
2734 {"vmwrite", { Gm, Em } },
2736 {"extrq", { XM, XS } },
2737 {"insertq", { XM, XS } },
2742 { "(bad)", { XX } },
2743 { "(bad)", { XX } },
2744 { "haddpd", { XM, EXx } },
2745 { "haddps", { XM, EXx } },
2750 { "(bad)", { XX } },
2751 { "(bad)", { XX } },
2752 { "hsubpd", { XM, EXx } },
2753 { "hsubps", { XM, EXx } },
2758 { "movK", { Edq, MX } },
2759 { "movq", { XM, EXq } },
2760 { "movK", { Edq, XM } },
2761 { "(bad)", { XX } },
2766 { "movq", { EMS, MX } },
2767 { "movdqu", { EXxS, XM } },
2768 { "movdqa", { EXxS, XM } },
2769 { "(bad)", { XX } },
2774 { "(bad)", { XX } },
2775 { "popcntS", { Gv, Ev } },
2776 { "(bad)", { XX } },
2777 { "(bad)", { XX } },
2782 { "bsrS", { Gv, Ev } },
2783 { "lzcntS", { Gv, Ev } },
2784 { "bsrS", { Gv, Ev } },
2785 { "(bad)", { XX } },
2790 { "cmpps", { XM, EXx, CMP } },
2791 { "cmpss", { XM, EXd, CMP } },
2792 { "cmppd", { XM, EXx, CMP } },
2793 { "cmpsd", { XM, EXq, CMP } },
2798 { "movntiS", { Ma, Gv } },
2799 { "(bad)", { XX } },
2800 { "(bad)", { XX } },
2801 { "(bad)", { XX } },
2804 /* PREFIX_0FC7_REG_6 */
2806 { "vmptrld",{ Mq } },
2807 { "vmxon", { Mq } },
2808 { "vmclear",{ Mq } },
2809 { "(bad)", { XX } },
2814 { "(bad)", { XX } },
2815 { "(bad)", { XX } },
2816 { "addsubpd", { XM, EXx } },
2817 { "addsubps", { XM, EXx } },
2822 { "(bad)", { XX } },
2823 { "movq2dq",{ XM, MS } },
2824 { "movq", { EXqS, XM } },
2825 { "movdq2q",{ MX, XS } },
2830 { "(bad)", { XX } },
2831 { "cvtdq2pd", { XM, EXq } },
2832 { "cvttpd2dq", { XM, EXx } },
2833 { "cvtpd2dq", { XM, EXx } },
2838 { "movntq", { Mq, MX } },
2839 { "(bad)", { XX } },
2840 { MOD_TABLE (MOD_0FE7_PREFIX_2) },
2841 { "(bad)", { XX } },
2846 { "(bad)", { XX } },
2847 { "(bad)", { XX } },
2848 { "(bad)", { XX } },
2849 { MOD_TABLE (MOD_0FF0_PREFIX_3) },
2854 { "maskmovq", { MX, MS } },
2855 { "(bad)", { XX } },
2856 { "maskmovdqu", { XM, XS } },
2857 { "(bad)", { XX } },
2862 { "(bad)", { XX } },
2863 { "(bad)", { XX } },
2864 { "pblendvb", { XM, EXx, XMM0 } },
2865 { "(bad)", { XX } },
2870 { "(bad)", { XX } },
2871 { "(bad)", { XX } },
2872 { "blendvps", { XM, EXx, XMM0 } },
2873 { "(bad)", { XX } },
2878 { "(bad)", { XX } },
2879 { "(bad)", { XX } },
2880 { "blendvpd", { XM, EXx, XMM0 } },
2881 { "(bad)", { XX } },
2886 { "(bad)", { XX } },
2887 { "(bad)", { XX } },
2888 { "ptest", { XM, EXx } },
2889 { "(bad)", { XX } },
2894 { "(bad)", { XX } },
2895 { "(bad)", { XX } },
2896 { "pmovsxbw", { XM, EXq } },
2897 { "(bad)", { XX } },
2902 { "(bad)", { XX } },
2903 { "(bad)", { XX } },
2904 { "pmovsxbd", { XM, EXd } },
2905 { "(bad)", { XX } },
2910 { "(bad)", { XX } },
2911 { "(bad)", { XX } },
2912 { "pmovsxbq", { XM, EXw } },
2913 { "(bad)", { XX } },
2918 { "(bad)", { XX } },
2919 { "(bad)", { XX } },
2920 { "pmovsxwd", { XM, EXq } },
2921 { "(bad)", { XX } },
2926 { "(bad)", { XX } },
2927 { "(bad)", { XX } },
2928 { "pmovsxwq", { XM, EXd } },
2929 { "(bad)", { XX } },
2934 { "(bad)", { XX } },
2935 { "(bad)", { XX } },
2936 { "pmovsxdq", { XM, EXq } },
2937 { "(bad)", { XX } },
2942 { "(bad)", { XX } },
2943 { "(bad)", { XX } },
2944 { "pmuldq", { XM, EXx } },
2945 { "(bad)", { XX } },
2950 { "(bad)", { XX } },
2951 { "(bad)", { XX } },
2952 { "pcmpeqq", { XM, EXx } },
2953 { "(bad)", { XX } },
2958 { "(bad)", { XX } },
2959 { "(bad)", { XX } },
2960 { MOD_TABLE (MOD_0F382A_PREFIX_2) },
2961 { "(bad)", { XX } },
2966 { "(bad)", { XX } },
2967 { "(bad)", { XX } },
2968 { "packusdw", { XM, EXx } },
2969 { "(bad)", { XX } },
2974 { "(bad)", { XX } },
2975 { "(bad)", { XX } },
2976 { "pmovzxbw", { XM, EXq } },
2977 { "(bad)", { XX } },
2982 { "(bad)", { XX } },
2983 { "(bad)", { XX } },
2984 { "pmovzxbd", { XM, EXd } },
2985 { "(bad)", { XX } },
2990 { "(bad)", { XX } },
2991 { "(bad)", { XX } },
2992 { "pmovzxbq", { XM, EXw } },
2993 { "(bad)", { XX } },
2998 { "(bad)", { XX } },
2999 { "(bad)", { XX } },
3000 { "pmovzxwd", { XM, EXq } },
3001 { "(bad)", { XX } },
3006 { "(bad)", { XX } },
3007 { "(bad)", { XX } },
3008 { "pmovzxwq", { XM, EXd } },
3009 { "(bad)", { XX } },
3014 { "(bad)", { XX } },
3015 { "(bad)", { XX } },
3016 { "pmovzxdq", { XM, EXq } },
3017 { "(bad)", { XX } },
3022 { "(bad)", { XX } },
3023 { "(bad)", { XX } },
3024 { "pcmpgtq", { XM, EXx } },
3025 { "(bad)", { XX } },
3030 { "(bad)", { XX } },
3031 { "(bad)", { XX } },
3032 { "pminsb", { XM, EXx } },
3033 { "(bad)", { XX } },
3038 { "(bad)", { XX } },
3039 { "(bad)", { XX } },
3040 { "pminsd", { XM, EXx } },
3041 { "(bad)", { XX } },
3046 { "(bad)", { XX } },
3047 { "(bad)", { XX } },
3048 { "pminuw", { XM, EXx } },
3049 { "(bad)", { XX } },
3054 { "(bad)", { XX } },
3055 { "(bad)", { XX } },
3056 { "pminud", { XM, EXx } },
3057 { "(bad)", { XX } },
3062 { "(bad)", { XX } },
3063 { "(bad)", { XX } },
3064 { "pmaxsb", { XM, EXx } },
3065 { "(bad)", { XX } },
3070 { "(bad)", { XX } },
3071 { "(bad)", { XX } },
3072 { "pmaxsd", { XM, EXx } },
3073 { "(bad)", { XX } },
3078 { "(bad)", { XX } },
3079 { "(bad)", { XX } },
3080 { "pmaxuw", { XM, EXx } },
3081 { "(bad)", { XX } },
3086 { "(bad)", { XX } },
3087 { "(bad)", { XX } },
3088 { "pmaxud", { XM, EXx } },
3089 { "(bad)", { XX } },
3094 { "(bad)", { XX } },
3095 { "(bad)", { XX } },
3096 { "pmulld", { XM, EXx } },
3097 { "(bad)", { XX } },
3102 { "(bad)", { XX } },
3103 { "(bad)", { XX } },
3104 { "phminposuw", { XM, EXx } },
3105 { "(bad)", { XX } },
3110 { "(bad)", { XX } },
3111 { "(bad)", { XX } },
3112 { "invept", { Gm, Mo } },
3113 { "(bad)", { XX } },
3118 { "(bad)", { XX } },
3119 { "(bad)", { XX } },
3120 { "invvpid", { Gm, Mo } },
3121 { "(bad)", { XX } },
3126 { "(bad)", { XX } },
3127 { "(bad)", { XX } },
3128 { "aesimc", { XM, EXx } },
3129 { "(bad)", { XX } },
3134 { "(bad)", { XX } },
3135 { "(bad)", { XX } },
3136 { "aesenc", { XM, EXx } },
3137 { "(bad)", { XX } },
3142 { "(bad)", { XX } },
3143 { "(bad)", { XX } },
3144 { "aesenclast", { XM, EXx } },
3145 { "(bad)", { XX } },
3150 { "(bad)", { XX } },
3151 { "(bad)", { XX } },
3152 { "aesdec", { XM, EXx } },
3153 { "(bad)", { XX } },
3158 { "(bad)", { XX } },
3159 { "(bad)", { XX } },
3160 { "aesdeclast", { XM, EXx } },
3161 { "(bad)", { XX } },
3166 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3167 { "(bad)", { XX } },
3168 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3169 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
3174 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3175 { "(bad)", { XX } },
3176 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3177 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
3182 { "(bad)", { XX } },
3183 { "(bad)", { XX } },
3184 { "roundps", { XM, EXx, Ib } },
3185 { "(bad)", { XX } },
3190 { "(bad)", { XX } },
3191 { "(bad)", { XX } },
3192 { "roundpd", { XM, EXx, Ib } },
3193 { "(bad)", { XX } },
3198 { "(bad)", { XX } },
3199 { "(bad)", { XX } },
3200 { "roundss", { XM, EXd, Ib } },
3201 { "(bad)", { XX } },
3206 { "(bad)", { XX } },
3207 { "(bad)", { XX } },
3208 { "roundsd", { XM, EXq, Ib } },
3209 { "(bad)", { XX } },
3214 { "(bad)", { XX } },
3215 { "(bad)", { XX } },
3216 { "blendps", { XM, EXx, Ib } },
3217 { "(bad)", { XX } },
3222 { "(bad)", { XX } },
3223 { "(bad)", { XX } },
3224 { "blendpd", { XM, EXx, Ib } },
3225 { "(bad)", { XX } },
3230 { "(bad)", { XX } },
3231 { "(bad)", { XX } },
3232 { "pblendw", { XM, EXx, Ib } },
3233 { "(bad)", { XX } },
3238 { "(bad)", { XX } },
3239 { "(bad)", { XX } },
3240 { "pextrb", { Edqb, XM, Ib } },
3241 { "(bad)", { XX } },
3246 { "(bad)", { XX } },
3247 { "(bad)", { XX } },
3248 { "pextrw", { Edqw, XM, Ib } },
3249 { "(bad)", { XX } },
3254 { "(bad)", { XX } },
3255 { "(bad)", { XX } },
3256 { "pextrK", { Edq, XM, Ib } },
3257 { "(bad)", { XX } },
3262 { "(bad)", { XX } },
3263 { "(bad)", { XX } },
3264 { "extractps", { Edqd, XM, Ib } },
3265 { "(bad)", { XX } },
3270 { "(bad)", { XX } },
3271 { "(bad)", { XX } },
3272 { "pinsrb", { XM, Edqb, Ib } },
3273 { "(bad)", { XX } },
3278 { "(bad)", { XX } },
3279 { "(bad)", { XX } },
3280 { "insertps", { XM, EXd, Ib } },
3281 { "(bad)", { XX } },
3286 { "(bad)", { XX } },
3287 { "(bad)", { XX } },
3288 { "pinsrK", { XM, Edq, Ib } },
3289 { "(bad)", { XX } },
3294 { "(bad)", { XX } },
3295 { "(bad)", { XX } },
3296 { "dpps", { XM, EXx, Ib } },
3297 { "(bad)", { XX } },
3302 { "(bad)", { XX } },
3303 { "(bad)", { XX } },
3304 { "dppd", { XM, EXx, Ib } },
3305 { "(bad)", { XX } },
3310 { "(bad)", { XX } },
3311 { "(bad)", { XX } },
3312 { "mpsadbw", { XM, EXx, Ib } },
3313 { "(bad)", { XX } },
3318 { "(bad)", { XX } },
3319 { "(bad)", { XX } },
3320 { "pclmulqdq", { XM, EXx, PCLMUL } },
3321 { "(bad)", { XX } },
3326 { "(bad)", { XX } },
3327 { "(bad)", { XX } },
3328 { "pcmpestrm", { XM, EXx, Ib } },
3329 { "(bad)", { XX } },
3334 { "(bad)", { XX } },
3335 { "(bad)", { XX } },
3336 { "pcmpestri", { XM, EXx, Ib } },
3337 { "(bad)", { XX } },
3342 { "(bad)", { XX } },
3343 { "(bad)", { XX } },
3344 { "pcmpistrm", { XM, EXx, Ib } },
3345 { "(bad)", { XX } },
3350 { "(bad)", { XX } },
3351 { "(bad)", { XX } },
3352 { "pcmpistri", { XM, EXx, Ib } },
3353 { "(bad)", { XX } },
3358 { "(bad)", { XX } },
3359 { "(bad)", { XX } },
3360 { "aeskeygenassist", { XM, EXx, Ib } },
3361 { "(bad)", { XX } },
3366 { "vmovups", { XM, EXx } },
3367 { VEX_LEN_TABLE (VEX_LEN_10_P_1) },
3368 { "vmovupd", { XM, EXx } },
3369 { VEX_LEN_TABLE (VEX_LEN_10_P_3) },
3374 { "vmovups", { EXxS, XM } },
3375 { VEX_LEN_TABLE (VEX_LEN_11_P_1) },
3376 { "vmovupd", { EXxS, XM } },
3377 { VEX_LEN_TABLE (VEX_LEN_11_P_3) },
3382 { MOD_TABLE (MOD_VEX_12_PREFIX_0) },
3383 { "vmovsldup", { XM, EXx } },
3384 { VEX_LEN_TABLE (VEX_LEN_12_P_2) },
3385 { "vmovddup", { XM, EXymmq } },
3390 { MOD_TABLE (MOD_VEX_16_PREFIX_0) },
3391 { "vmovshdup", { XM, EXx } },
3392 { VEX_LEN_TABLE (VEX_LEN_16_P_2) },
3393 { "(bad)", { XX } },
3398 { "(bad)", { XX } },
3399 { VEX_LEN_TABLE (VEX_LEN_2A_P_1) },
3400 { "(bad)", { XX } },
3401 { VEX_LEN_TABLE (VEX_LEN_2A_P_3) },
3406 { "(bad)", { XX } },
3407 { VEX_LEN_TABLE (VEX_LEN_2C_P_1) },
3408 { "(bad)", { XX } },
3409 { VEX_LEN_TABLE (VEX_LEN_2C_P_3) },
3414 { "(bad)", { XX } },
3415 { VEX_LEN_TABLE (VEX_LEN_2D_P_1) },
3416 { "(bad)", { XX } },
3417 { VEX_LEN_TABLE (VEX_LEN_2D_P_3) },
3422 { VEX_LEN_TABLE (VEX_LEN_2E_P_0) },
3423 { "(bad)", { XX } },
3424 { VEX_LEN_TABLE (VEX_LEN_2E_P_2) },
3425 { "(bad)", { XX } },
3430 { VEX_LEN_TABLE (VEX_LEN_2F_P_0) },
3431 { "(bad)", { XX } },
3432 { VEX_LEN_TABLE (VEX_LEN_2F_P_2) },
3433 { "(bad)", { XX } },
3438 { "vsqrtps", { XM, EXx } },
3439 { VEX_LEN_TABLE (VEX_LEN_51_P_1) },
3440 { "vsqrtpd", { XM, EXx } },
3441 { VEX_LEN_TABLE (VEX_LEN_51_P_3) },
3446 { "vrsqrtps", { XM, EXx } },
3447 { VEX_LEN_TABLE (VEX_LEN_52_P_1) },
3448 { "(bad)", { XX } },
3449 { "(bad)", { XX } },
3454 { "vrcpps", { XM, EXx } },
3455 { VEX_LEN_TABLE (VEX_LEN_53_P_1) },
3456 { "(bad)", { XX } },
3457 { "(bad)", { XX } },
3462 { "vaddps", { XM, Vex, EXx } },
3463 { VEX_LEN_TABLE (VEX_LEN_58_P_1) },
3464 { "vaddpd", { XM, Vex, EXx } },
3465 { VEX_LEN_TABLE (VEX_LEN_58_P_3) },
3470 { "vmulps", { XM, Vex, EXx } },
3471 { VEX_LEN_TABLE (VEX_LEN_59_P_1) },
3472 { "vmulpd", { XM, Vex, EXx } },
3473 { VEX_LEN_TABLE (VEX_LEN_59_P_3) },
3478 { "vcvtps2pd", { XM, EXxmmq } },
3479 { VEX_LEN_TABLE (VEX_LEN_5A_P_1) },
3480 { "vcvtpd2ps%XY", { XMM, EXx } },
3481 { VEX_LEN_TABLE (VEX_LEN_5A_P_3) },
3486 { "vcvtdq2ps", { XM, EXx } },
3487 { "vcvttps2dq", { XM, EXx } },
3488 { "vcvtps2dq", { XM, EXx } },
3489 { "(bad)", { XX } },
3494 { "vsubps", { XM, Vex, EXx } },
3495 { VEX_LEN_TABLE (VEX_LEN_5C_P_1) },
3496 { "vsubpd", { XM, Vex, EXx } },
3497 { VEX_LEN_TABLE (VEX_LEN_5C_P_3) },
3502 { "vminps", { XM, Vex, EXx } },
3503 { VEX_LEN_TABLE (VEX_LEN_5D_P_1) },
3504 { "vminpd", { XM, Vex, EXx } },
3505 { VEX_LEN_TABLE (VEX_LEN_5D_P_3) },
3510 { "vdivps", { XM, Vex, EXx } },
3511 { VEX_LEN_TABLE (VEX_LEN_5E_P_1) },
3512 { "vdivpd", { XM, Vex, EXx } },
3513 { VEX_LEN_TABLE (VEX_LEN_5E_P_3) },
3518 { "vmaxps", { XM, Vex, EXx } },
3519 { VEX_LEN_TABLE (VEX_LEN_5F_P_1) },
3520 { "vmaxpd", { XM, Vex, EXx } },
3521 { VEX_LEN_TABLE (VEX_LEN_5F_P_3) },
3526 { "(bad)", { XX } },
3527 { "(bad)", { XX } },
3528 { VEX_LEN_TABLE (VEX_LEN_60_P_2) },
3529 { "(bad)", { XX } },
3534 { "(bad)", { XX } },
3535 { "(bad)", { XX } },
3536 { VEX_LEN_TABLE (VEX_LEN_61_P_2) },
3537 { "(bad)", { XX } },
3542 { "(bad)", { XX } },
3543 { "(bad)", { XX } },
3544 { VEX_LEN_TABLE (VEX_LEN_62_P_2) },
3545 { "(bad)", { XX } },
3550 { "(bad)", { XX } },
3551 { "(bad)", { XX } },
3552 { VEX_LEN_TABLE (VEX_LEN_63_P_2) },
3553 { "(bad)", { XX } },
3558 { "(bad)", { XX } },
3559 { "(bad)", { XX } },
3560 { VEX_LEN_TABLE (VEX_LEN_64_P_2) },
3561 { "(bad)", { XX } },
3566 { "(bad)", { XX } },
3567 { "(bad)", { XX } },
3568 { VEX_LEN_TABLE (VEX_LEN_65_P_2) },
3569 { "(bad)", { XX } },
3574 { "(bad)", { XX } },
3575 { "(bad)", { XX } },
3576 { VEX_LEN_TABLE (VEX_LEN_66_P_2) },
3577 { "(bad)", { XX } },
3582 { "(bad)", { XX } },
3583 { "(bad)", { XX } },
3584 { VEX_LEN_TABLE (VEX_LEN_67_P_2) },
3585 { "(bad)", { XX } },
3590 { "(bad)", { XX } },
3591 { "(bad)", { XX } },
3592 { VEX_LEN_TABLE (VEX_LEN_68_P_2) },
3593 { "(bad)", { XX } },
3598 { "(bad)", { XX } },
3599 { "(bad)", { XX } },
3600 { VEX_LEN_TABLE (VEX_LEN_69_P_2) },
3601 { "(bad)", { XX } },
3606 { "(bad)", { XX } },
3607 { "(bad)", { XX } },
3608 { VEX_LEN_TABLE (VEX_LEN_6A_P_2) },
3609 { "(bad)", { XX } },
3614 { "(bad)", { XX } },
3615 { "(bad)", { XX } },
3616 { VEX_LEN_TABLE (VEX_LEN_6B_P_2) },
3617 { "(bad)", { XX } },
3622 { "(bad)", { XX } },
3623 { "(bad)", { XX } },
3624 { VEX_LEN_TABLE (VEX_LEN_6C_P_2) },
3625 { "(bad)", { XX } },
3630 { "(bad)", { XX } },
3631 { "(bad)", { XX } },
3632 { VEX_LEN_TABLE (VEX_LEN_6D_P_2) },
3633 { "(bad)", { XX } },
3638 { "(bad)", { XX } },
3639 { "(bad)", { XX } },
3640 { VEX_LEN_TABLE (VEX_LEN_6E_P_2) },
3641 { "(bad)", { XX } },
3646 { "(bad)", { XX } },
3647 { "vmovdqu", { XM, EXx } },
3648 { "vmovdqa", { XM, EXx } },
3649 { "(bad)", { XX } },
3654 { "(bad)", { XX } },
3655 { VEX_LEN_TABLE (VEX_LEN_70_P_1) },
3656 { VEX_LEN_TABLE (VEX_LEN_70_P_2) },
3657 { VEX_LEN_TABLE (VEX_LEN_70_P_3) },
3660 /* PREFIX_VEX_71_REG_2 */
3662 { "(bad)", { XX } },
3663 { "(bad)", { XX } },
3664 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2) },
3665 { "(bad)", { XX } },
3668 /* PREFIX_VEX_71_REG_4 */
3670 { "(bad)", { XX } },
3671 { "(bad)", { XX } },
3672 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2) },
3673 { "(bad)", { XX } },
3676 /* PREFIX_VEX_71_REG_6 */
3678 { "(bad)", { XX } },
3679 { "(bad)", { XX } },
3680 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2) },
3681 { "(bad)", { XX } },
3684 /* PREFIX_VEX_72_REG_2 */
3686 { "(bad)", { XX } },
3687 { "(bad)", { XX } },
3688 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2) },
3689 { "(bad)", { XX } },
3692 /* PREFIX_VEX_72_REG_4 */
3694 { "(bad)", { XX } },
3695 { "(bad)", { XX } },
3696 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2) },
3697 { "(bad)", { XX } },
3700 /* PREFIX_VEX_72_REG_6 */
3702 { "(bad)", { XX } },
3703 { "(bad)", { XX } },
3704 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2) },
3705 { "(bad)", { XX } },
3708 /* PREFIX_VEX_73_REG_2 */
3710 { "(bad)", { XX } },
3711 { "(bad)", { XX } },
3712 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2) },
3713 { "(bad)", { XX } },
3716 /* PREFIX_VEX_73_REG_3 */
3718 { "(bad)", { XX } },
3719 { "(bad)", { XX } },
3720 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2) },
3721 { "(bad)", { XX } },
3724 /* PREFIX_VEX_73_REG_6 */
3726 { "(bad)", { XX } },
3727 { "(bad)", { XX } },
3728 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2) },
3729 { "(bad)", { XX } },
3732 /* PREFIX_VEX_73_REG_7 */
3734 { "(bad)", { XX } },
3735 { "(bad)", { XX } },
3736 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2) },
3737 { "(bad)", { XX } },
3742 { "(bad)", { XX } },
3743 { "(bad)", { XX } },
3744 { VEX_LEN_TABLE (VEX_LEN_74_P_2) },
3745 { "(bad)", { XX } },
3750 { "(bad)", { XX } },
3751 { "(bad)", { XX } },
3752 { VEX_LEN_TABLE (VEX_LEN_75_P_2) },
3753 { "(bad)", { XX } },
3758 { "(bad)", { XX } },
3759 { "(bad)", { XX } },
3760 { VEX_LEN_TABLE (VEX_LEN_76_P_2) },
3761 { "(bad)", { XX } },
3767 { "(bad)", { XX } },
3768 { "(bad)", { XX } },
3769 { "(bad)", { XX } },
3774 { "(bad)", { XX } },
3775 { "(bad)", { XX } },
3776 { "vhaddpd", { XM, Vex, EXx } },
3777 { "vhaddps", { XM, Vex, EXx } },
3782 { "(bad)", { XX } },
3783 { "(bad)", { XX } },
3784 { "vhsubpd", { XM, Vex, EXx } },
3785 { "vhsubps", { XM, Vex, EXx } },
3790 { "(bad)", { XX } },
3791 { VEX_LEN_TABLE (VEX_LEN_7E_P_1) },
3792 { VEX_LEN_TABLE (VEX_LEN_7E_P_2) },
3793 { "(bad)", { XX } },
3798 { "(bad)", { XX } },
3799 { "vmovdqu", { EXxS, XM } },
3800 { "vmovdqa", { EXxS, XM } },
3801 { "(bad)", { XX } },
3806 { "vcmpps", { XM, Vex, EXx, VCMP } },
3807 { VEX_LEN_TABLE (VEX_LEN_C2_P_1) },
3808 { "vcmppd", { XM, Vex, EXx, VCMP } },
3809 { VEX_LEN_TABLE (VEX_LEN_C2_P_3) },
3814 { "(bad)", { XX } },
3815 { "(bad)", { XX } },
3816 { VEX_LEN_TABLE (VEX_LEN_C4_P_2) },
3817 { "(bad)", { XX } },
3822 { "(bad)", { XX } },
3823 { "(bad)", { XX } },
3824 { VEX_LEN_TABLE (VEX_LEN_C5_P_2) },
3825 { "(bad)", { XX } },
3830 { "(bad)", { XX } },
3831 { "(bad)", { XX } },
3832 { "vaddsubpd", { XM, Vex, EXx } },
3833 { "vaddsubps", { XM, Vex, EXx } },
3838 { "(bad)", { XX } },
3839 { "(bad)", { XX } },
3840 { VEX_LEN_TABLE (VEX_LEN_D1_P_2) },
3841 { "(bad)", { XX } },
3846 { "(bad)", { XX } },
3847 { "(bad)", { XX } },
3848 { VEX_LEN_TABLE (VEX_LEN_D2_P_2) },
3849 { "(bad)", { XX } },
3854 { "(bad)", { XX } },
3855 { "(bad)", { XX } },
3856 { VEX_LEN_TABLE (VEX_LEN_D3_P_2) },
3857 { "(bad)", { XX } },
3862 { "(bad)", { XX } },
3863 { "(bad)", { XX } },
3864 { VEX_LEN_TABLE (VEX_LEN_D4_P_2) },
3865 { "(bad)", { XX } },
3870 { "(bad)", { XX } },
3871 { "(bad)", { XX } },
3872 { VEX_LEN_TABLE (VEX_LEN_D5_P_2) },
3873 { "(bad)", { XX } },
3878 { "(bad)", { XX } },
3879 { "(bad)", { XX } },
3880 { VEX_LEN_TABLE (VEX_LEN_D6_P_2) },
3881 { "(bad)", { XX } },
3886 { "(bad)", { XX } },
3887 { "(bad)", { XX } },
3888 { MOD_TABLE (MOD_VEX_D7_PREFIX_2) },
3889 { "(bad)", { XX } },
3894 { "(bad)", { XX } },
3895 { "(bad)", { XX } },
3896 { VEX_LEN_TABLE (VEX_LEN_D8_P_2) },
3897 { "(bad)", { XX } },
3902 { "(bad)", { XX } },
3903 { "(bad)", { XX } },
3904 { VEX_LEN_TABLE (VEX_LEN_D9_P_2) },
3905 { "(bad)", { XX } },
3910 { "(bad)", { XX } },
3911 { "(bad)", { XX } },
3912 { VEX_LEN_TABLE (VEX_LEN_DA_P_2) },
3913 { "(bad)", { XX } },
3918 { "(bad)", { XX } },
3919 { "(bad)", { XX } },
3920 { VEX_LEN_TABLE (VEX_LEN_DB_P_2) },
3921 { "(bad)", { XX } },
3926 { "(bad)", { XX } },
3927 { "(bad)", { XX } },
3928 { VEX_LEN_TABLE (VEX_LEN_DC_P_2) },
3929 { "(bad)", { XX } },
3934 { "(bad)", { XX } },
3935 { "(bad)", { XX } },
3936 { VEX_LEN_TABLE (VEX_LEN_DD_P_2) },
3937 { "(bad)", { XX } },
3942 { "(bad)", { XX } },
3943 { "(bad)", { XX } },
3944 { VEX_LEN_TABLE (VEX_LEN_DE_P_2) },
3945 { "(bad)", { XX } },
3950 { "(bad)", { XX } },
3951 { "(bad)", { XX } },
3952 { VEX_LEN_TABLE (VEX_LEN_DF_P_2) },
3953 { "(bad)", { XX } },
3958 { "(bad)", { XX } },
3959 { "(bad)", { XX } },
3960 { VEX_LEN_TABLE (VEX_LEN_E0_P_2) },
3961 { "(bad)", { XX } },
3966 { "(bad)", { XX } },
3967 { "(bad)", { XX } },
3968 { VEX_LEN_TABLE (VEX_LEN_E1_P_2) },
3969 { "(bad)", { XX } },
3974 { "(bad)", { XX } },
3975 { "(bad)", { XX } },
3976 { VEX_LEN_TABLE (VEX_LEN_E2_P_2) },
3977 { "(bad)", { XX } },
3982 { "(bad)", { XX } },
3983 { "(bad)", { XX } },
3984 { VEX_LEN_TABLE (VEX_LEN_E3_P_2) },
3985 { "(bad)", { XX } },
3990 { "(bad)", { XX } },
3991 { "(bad)", { XX } },
3992 { VEX_LEN_TABLE (VEX_LEN_E4_P_2) },
3993 { "(bad)", { XX } },
3998 { "(bad)", { XX } },
3999 { "(bad)", { XX } },
4000 { VEX_LEN_TABLE (VEX_LEN_E5_P_2) },
4001 { "(bad)", { XX } },
4006 { "(bad)", { XX } },
4007 { "vcvtdq2pd", { XM, EXxmmq } },
4008 { "vcvttpd2dq%XY", { XMM, EXx } },
4009 { "vcvtpd2dq%XY", { XMM, EXx } },
4014 { "(bad)", { XX } },
4015 { "(bad)", { XX } },
4016 { MOD_TABLE (MOD_VEX_E7_PREFIX_2) },
4017 { "(bad)", { XX } },
4022 { "(bad)", { XX } },
4023 { "(bad)", { XX } },
4024 { VEX_LEN_TABLE (VEX_LEN_E8_P_2) },
4025 { "(bad)", { XX } },
4030 { "(bad)", { XX } },
4031 { "(bad)", { XX } },
4032 { VEX_LEN_TABLE (VEX_LEN_E9_P_2) },
4033 { "(bad)", { XX } },
4038 { "(bad)", { XX } },
4039 { "(bad)", { XX } },
4040 { VEX_LEN_TABLE (VEX_LEN_EA_P_2) },
4041 { "(bad)", { XX } },
4046 { "(bad)", { XX } },
4047 { "(bad)", { XX } },
4048 { VEX_LEN_TABLE (VEX_LEN_EB_P_2) },
4049 { "(bad)", { XX } },
4054 { "(bad)", { XX } },
4055 { "(bad)", { XX } },
4056 { VEX_LEN_TABLE (VEX_LEN_EC_P_2) },
4057 { "(bad)", { XX } },
4062 { "(bad)", { XX } },
4063 { "(bad)", { XX } },
4064 { VEX_LEN_TABLE (VEX_LEN_ED_P_2) },
4065 { "(bad)", { XX } },
4070 { "(bad)", { XX } },
4071 { "(bad)", { XX } },
4072 { VEX_LEN_TABLE (VEX_LEN_EE_P_2) },
4073 { "(bad)", { XX } },
4078 { "(bad)", { XX } },
4079 { "(bad)", { XX } },
4080 { VEX_LEN_TABLE (VEX_LEN_EF_P_2) },
4081 { "(bad)", { XX } },
4086 { "(bad)", { XX } },
4087 { "(bad)", { XX } },
4088 { "(bad)", { XX } },
4089 { MOD_TABLE (MOD_VEX_F0_PREFIX_3) },
4094 { "(bad)", { XX } },
4095 { "(bad)", { XX } },
4096 { VEX_LEN_TABLE (VEX_LEN_F1_P_2) },
4097 { "(bad)", { XX } },
4102 { "(bad)", { XX } },
4103 { "(bad)", { XX } },
4104 { VEX_LEN_TABLE (VEX_LEN_F2_P_2) },
4105 { "(bad)", { XX } },
4110 { "(bad)", { XX } },
4111 { "(bad)", { XX } },
4112 { VEX_LEN_TABLE (VEX_LEN_F3_P_2) },
4113 { "(bad)", { XX } },
4118 { "(bad)", { XX } },
4119 { "(bad)", { XX } },
4120 { VEX_LEN_TABLE (VEX_LEN_F4_P_2) },
4121 { "(bad)", { XX } },
4126 { "(bad)", { XX } },
4127 { "(bad)", { XX } },
4128 { VEX_LEN_TABLE (VEX_LEN_F5_P_2) },
4129 { "(bad)", { XX } },
4134 { "(bad)", { XX } },
4135 { "(bad)", { XX } },
4136 { VEX_LEN_TABLE (VEX_LEN_F6_P_2) },
4137 { "(bad)", { XX } },
4142 { "(bad)", { XX } },
4143 { "(bad)", { XX } },
4144 { VEX_LEN_TABLE (VEX_LEN_F7_P_2) },
4145 { "(bad)", { XX } },
4150 { "(bad)", { XX } },
4151 { "(bad)", { XX } },
4152 { VEX_LEN_TABLE (VEX_LEN_F8_P_2) },
4153 { "(bad)", { XX } },
4158 { "(bad)", { XX } },
4159 { "(bad)", { XX } },
4160 { VEX_LEN_TABLE (VEX_LEN_F9_P_2) },
4161 { "(bad)", { XX } },
4166 { "(bad)", { XX } },
4167 { "(bad)", { XX } },
4168 { VEX_LEN_TABLE (VEX_LEN_FA_P_2) },
4169 { "(bad)", { XX } },
4174 { "(bad)", { XX } },
4175 { "(bad)", { XX } },
4176 { VEX_LEN_TABLE (VEX_LEN_FB_P_2) },
4177 { "(bad)", { XX } },
4182 { "(bad)", { XX } },
4183 { "(bad)", { XX } },
4184 { VEX_LEN_TABLE (VEX_LEN_FC_P_2) },
4185 { "(bad)", { XX } },
4190 { "(bad)", { XX } },
4191 { "(bad)", { XX } },
4192 { VEX_LEN_TABLE (VEX_LEN_FD_P_2) },
4193 { "(bad)", { XX } },
4198 { "(bad)", { XX } },
4199 { "(bad)", { XX } },
4200 { VEX_LEN_TABLE (VEX_LEN_FE_P_2) },
4201 { "(bad)", { XX } },
4204 /* PREFIX_VEX_3800 */
4206 { "(bad)", { XX } },
4207 { "(bad)", { XX } },
4208 { VEX_LEN_TABLE (VEX_LEN_3800_P_2) },
4209 { "(bad)", { XX } },
4212 /* PREFIX_VEX_3801 */
4214 { "(bad)", { XX } },
4215 { "(bad)", { XX } },
4216 { VEX_LEN_TABLE (VEX_LEN_3801_P_2) },
4217 { "(bad)", { XX } },
4220 /* PREFIX_VEX_3802 */
4222 { "(bad)", { XX } },
4223 { "(bad)", { XX } },
4224 { VEX_LEN_TABLE (VEX_LEN_3802_P_2) },
4225 { "(bad)", { XX } },
4228 /* PREFIX_VEX_3803 */
4230 { "(bad)", { XX } },
4231 { "(bad)", { XX } },
4232 { VEX_LEN_TABLE (VEX_LEN_3803_P_2) },
4233 { "(bad)", { XX } },
4236 /* PREFIX_VEX_3804 */
4238 { "(bad)", { XX } },
4239 { "(bad)", { XX } },
4240 { VEX_LEN_TABLE (VEX_LEN_3804_P_2) },
4241 { "(bad)", { XX } },
4244 /* PREFIX_VEX_3805 */
4246 { "(bad)", { XX } },
4247 { "(bad)", { XX } },
4248 { VEX_LEN_TABLE (VEX_LEN_3805_P_2) },
4249 { "(bad)", { XX } },
4252 /* PREFIX_VEX_3806 */
4254 { "(bad)", { XX } },
4255 { "(bad)", { XX } },
4256 { VEX_LEN_TABLE (VEX_LEN_3806_P_2) },
4257 { "(bad)", { XX } },
4260 /* PREFIX_VEX_3807 */
4262 { "(bad)", { XX } },
4263 { "(bad)", { XX } },
4264 { VEX_LEN_TABLE (VEX_LEN_3807_P_2) },
4265 { "(bad)", { XX } },
4268 /* PREFIX_VEX_3808 */
4270 { "(bad)", { XX } },
4271 { "(bad)", { XX } },
4272 { VEX_LEN_TABLE (VEX_LEN_3808_P_2) },
4273 { "(bad)", { XX } },
4276 /* PREFIX_VEX_3809 */
4278 { "(bad)", { XX } },
4279 { "(bad)", { XX } },
4280 { VEX_LEN_TABLE (VEX_LEN_3809_P_2) },
4281 { "(bad)", { XX } },
4284 /* PREFIX_VEX_380A */
4286 { "(bad)", { XX } },
4287 { "(bad)", { XX } },
4288 { VEX_LEN_TABLE (VEX_LEN_380A_P_2) },
4289 { "(bad)", { XX } },
4292 /* PREFIX_VEX_380B */
4294 { "(bad)", { XX } },
4295 { "(bad)", { XX } },
4296 { VEX_LEN_TABLE (VEX_LEN_380B_P_2) },
4297 { "(bad)", { XX } },
4300 /* PREFIX_VEX_380C */
4302 { "(bad)", { XX } },
4303 { "(bad)", { XX } },
4304 { "vpermilps", { XM, Vex, EXx } },
4305 { "(bad)", { XX } },
4308 /* PREFIX_VEX_380D */
4310 { "(bad)", { XX } },
4311 { "(bad)", { XX } },
4312 { "vpermilpd", { XM, Vex, EXx } },
4313 { "(bad)", { XX } },
4316 /* PREFIX_VEX_380E */
4318 { "(bad)", { XX } },
4319 { "(bad)", { XX } },
4320 { "vtestps", { XM, EXx } },
4321 { "(bad)", { XX } },
4324 /* PREFIX_VEX_380F */
4326 { "(bad)", { XX } },
4327 { "(bad)", { XX } },
4328 { "vtestpd", { XM, EXx } },
4329 { "(bad)", { XX } },
4332 /* PREFIX_VEX_3817 */
4334 { "(bad)", { XX } },
4335 { "(bad)", { XX } },
4336 { "vptest", { XM, EXx } },
4337 { "(bad)", { XX } },
4340 /* PREFIX_VEX_3818 */
4342 { "(bad)", { XX } },
4343 { "(bad)", { XX } },
4344 { MOD_TABLE (MOD_VEX_3818_PREFIX_2) },
4345 { "(bad)", { XX } },
4348 /* PREFIX_VEX_3819 */
4350 { "(bad)", { XX } },
4351 { "(bad)", { XX } },
4352 { MOD_TABLE (MOD_VEX_3819_PREFIX_2) },
4353 { "(bad)", { XX } },
4356 /* PREFIX_VEX_381A */
4358 { "(bad)", { XX } },
4359 { "(bad)", { XX } },
4360 { MOD_TABLE (MOD_VEX_381A_PREFIX_2) },
4361 { "(bad)", { XX } },
4364 /* PREFIX_VEX_381C */
4366 { "(bad)", { XX } },
4367 { "(bad)", { XX } },
4368 { VEX_LEN_TABLE (VEX_LEN_381C_P_2) },
4369 { "(bad)", { XX } },
4372 /* PREFIX_VEX_381D */
4374 { "(bad)", { XX } },
4375 { "(bad)", { XX } },
4376 { VEX_LEN_TABLE (VEX_LEN_381D_P_2) },
4377 { "(bad)", { XX } },
4380 /* PREFIX_VEX_381E */
4382 { "(bad)", { XX } },
4383 { "(bad)", { XX } },
4384 { VEX_LEN_TABLE (VEX_LEN_381E_P_2) },
4385 { "(bad)", { XX } },
4388 /* PREFIX_VEX_3820 */
4390 { "(bad)", { XX } },
4391 { "(bad)", { XX } },
4392 { VEX_LEN_TABLE (VEX_LEN_3820_P_2) },
4393 { "(bad)", { XX } },
4396 /* PREFIX_VEX_3821 */
4398 { "(bad)", { XX } },
4399 { "(bad)", { XX } },
4400 { VEX_LEN_TABLE (VEX_LEN_3821_P_2) },
4401 { "(bad)", { XX } },
4404 /* PREFIX_VEX_3822 */
4406 { "(bad)", { XX } },
4407 { "(bad)", { XX } },
4408 { VEX_LEN_TABLE (VEX_LEN_3822_P_2) },
4409 { "(bad)", { XX } },
4412 /* PREFIX_VEX_3823 */
4414 { "(bad)", { XX } },
4415 { "(bad)", { XX } },
4416 { VEX_LEN_TABLE (VEX_LEN_3823_P_2) },
4417 { "(bad)", { XX } },
4420 /* PREFIX_VEX_3824 */
4422 { "(bad)", { XX } },
4423 { "(bad)", { XX } },
4424 { VEX_LEN_TABLE (VEX_LEN_3824_P_2) },
4425 { "(bad)", { XX } },
4428 /* PREFIX_VEX_3825 */
4430 { "(bad)", { XX } },
4431 { "(bad)", { XX } },
4432 { VEX_LEN_TABLE (VEX_LEN_3825_P_2) },
4433 { "(bad)", { XX } },
4436 /* PREFIX_VEX_3828 */
4438 { "(bad)", { XX } },
4439 { "(bad)", { XX } },
4440 { VEX_LEN_TABLE (VEX_LEN_3828_P_2) },
4441 { "(bad)", { XX } },
4444 /* PREFIX_VEX_3829 */
4446 { "(bad)", { XX } },
4447 { "(bad)", { XX } },
4448 { VEX_LEN_TABLE (VEX_LEN_3829_P_2) },
4449 { "(bad)", { XX } },
4452 /* PREFIX_VEX_382A */
4454 { "(bad)", { XX } },
4455 { "(bad)", { XX } },
4456 { MOD_TABLE (MOD_VEX_382A_PREFIX_2) },
4457 { "(bad)", { XX } },
4460 /* PREFIX_VEX_382B */
4462 { "(bad)", { XX } },
4463 { "(bad)", { XX } },
4464 { VEX_LEN_TABLE (VEX_LEN_382B_P_2) },
4465 { "(bad)", { XX } },
4468 /* PREFIX_VEX_382C */
4470 { "(bad)", { XX } },
4471 { "(bad)", { XX } },
4472 { MOD_TABLE (MOD_VEX_382C_PREFIX_2) },
4473 { "(bad)", { XX } },
4476 /* PREFIX_VEX_382D */
4478 { "(bad)", { XX } },
4479 { "(bad)", { XX } },
4480 { MOD_TABLE (MOD_VEX_382D_PREFIX_2) },
4481 { "(bad)", { XX } },
4484 /* PREFIX_VEX_382E */
4486 { "(bad)", { XX } },
4487 { "(bad)", { XX } },
4488 { MOD_TABLE (MOD_VEX_382E_PREFIX_2) },
4489 { "(bad)", { XX } },
4492 /* PREFIX_VEX_382F */
4494 { "(bad)", { XX } },
4495 { "(bad)", { XX } },
4496 { MOD_TABLE (MOD_VEX_382F_PREFIX_2) },
4497 { "(bad)", { XX } },
4500 /* PREFIX_VEX_3830 */
4502 { "(bad)", { XX } },
4503 { "(bad)", { XX } },
4504 { VEX_LEN_TABLE (VEX_LEN_3830_P_2) },
4505 { "(bad)", { XX } },
4508 /* PREFIX_VEX_3831 */
4510 { "(bad)", { XX } },
4511 { "(bad)", { XX } },
4512 { VEX_LEN_TABLE (VEX_LEN_3831_P_2) },
4513 { "(bad)", { XX } },
4516 /* PREFIX_VEX_3832 */
4518 { "(bad)", { XX } },
4519 { "(bad)", { XX } },
4520 { VEX_LEN_TABLE (VEX_LEN_3832_P_2) },
4521 { "(bad)", { XX } },
4524 /* PREFIX_VEX_3833 */
4526 { "(bad)", { XX } },
4527 { "(bad)", { XX } },
4528 { VEX_LEN_TABLE (VEX_LEN_3833_P_2) },
4529 { "(bad)", { XX } },
4532 /* PREFIX_VEX_3834 */
4534 { "(bad)", { XX } },
4535 { "(bad)", { XX } },
4536 { VEX_LEN_TABLE (VEX_LEN_3834_P_2) },
4537 { "(bad)", { XX } },
4540 /* PREFIX_VEX_3835 */
4542 { "(bad)", { XX } },
4543 { "(bad)", { XX } },
4544 { VEX_LEN_TABLE (VEX_LEN_3835_P_2) },
4545 { "(bad)", { XX } },
4548 /* PREFIX_VEX_3837 */
4550 { "(bad)", { XX } },
4551 { "(bad)", { XX } },
4552 { VEX_LEN_TABLE (VEX_LEN_3837_P_2) },
4553 { "(bad)", { XX } },
4556 /* PREFIX_VEX_3838 */
4558 { "(bad)", { XX } },
4559 { "(bad)", { XX } },
4560 { VEX_LEN_TABLE (VEX_LEN_3838_P_2) },
4561 { "(bad)", { XX } },
4564 /* PREFIX_VEX_3839 */
4566 { "(bad)", { XX } },
4567 { "(bad)", { XX } },
4568 { VEX_LEN_TABLE (VEX_LEN_3839_P_2) },
4569 { "(bad)", { XX } },
4572 /* PREFIX_VEX_383A */
4574 { "(bad)", { XX } },
4575 { "(bad)", { XX } },
4576 { VEX_LEN_TABLE (VEX_LEN_383A_P_2) },
4577 { "(bad)", { XX } },
4580 /* PREFIX_VEX_383B */
4582 { "(bad)", { XX } },
4583 { "(bad)", { XX } },
4584 { VEX_LEN_TABLE (VEX_LEN_383B_P_2) },
4585 { "(bad)", { XX } },
4588 /* PREFIX_VEX_383C */
4590 { "(bad)", { XX } },
4591 { "(bad)", { XX } },
4592 { VEX_LEN_TABLE (VEX_LEN_383C_P_2) },
4593 { "(bad)", { XX } },
4596 /* PREFIX_VEX_383D */
4598 { "(bad)", { XX } },
4599 { "(bad)", { XX } },
4600 { VEX_LEN_TABLE (VEX_LEN_383D_P_2) },
4601 { "(bad)", { XX } },
4604 /* PREFIX_VEX_383E */
4606 { "(bad)", { XX } },
4607 { "(bad)", { XX } },
4608 { VEX_LEN_TABLE (VEX_LEN_383E_P_2) },
4609 { "(bad)", { XX } },
4612 /* PREFIX_VEX_383F */
4614 { "(bad)", { XX } },
4615 { "(bad)", { XX } },
4616 { VEX_LEN_TABLE (VEX_LEN_383F_P_2) },
4617 { "(bad)", { XX } },
4620 /* PREFIX_VEX_3840 */
4622 { "(bad)", { XX } },
4623 { "(bad)", { XX } },
4624 { VEX_LEN_TABLE (VEX_LEN_3840_P_2) },
4625 { "(bad)", { XX } },
4628 /* PREFIX_VEX_3841 */
4630 { "(bad)", { XX } },
4631 { "(bad)", { XX } },
4632 { VEX_LEN_TABLE (VEX_LEN_3841_P_2) },
4633 { "(bad)", { XX } },
4636 /* PREFIX_VEX_3896 */
4638 { "(bad)", { XX } },
4639 { "(bad)", { XX } },
4640 { "vfmaddsub132p%XW", { XM, Vex, EXx } },
4641 { "(bad)", { XX } },
4644 /* PREFIX_VEX_3897 */
4646 { "(bad)", { XX } },
4647 { "(bad)", { XX } },
4648 { "vfmsubadd132p%XW", { XM, Vex, EXx } },
4649 { "(bad)", { XX } },
4652 /* PREFIX_VEX_3898 */
4654 { "(bad)", { XX } },
4655 { "(bad)", { XX } },
4656 { "vfmadd132p%XW", { XM, Vex, EXx } },
4657 { "(bad)", { XX } },
4660 /* PREFIX_VEX_3899 */
4662 { "(bad)", { XX } },
4663 { "(bad)", { XX } },
4664 { "vfmadd132s%XW", { XM, Vex, EXVexWdq } },
4665 { "(bad)", { XX } },
4668 /* PREFIX_VEX_389A */
4670 { "(bad)", { XX } },
4671 { "(bad)", { XX } },
4672 { "vfmsub132p%XW", { XM, Vex, EXx } },
4673 { "(bad)", { XX } },
4676 /* PREFIX_VEX_389B */
4678 { "(bad)", { XX } },
4679 { "(bad)", { XX } },
4680 { "vfmsub132s%XW", { XM, Vex, EXVexWdq } },
4681 { "(bad)", { XX } },
4684 /* PREFIX_VEX_389C */
4686 { "(bad)", { XX } },
4687 { "(bad)", { XX } },
4688 { "vfnmadd132p%XW", { XM, Vex, EXx } },
4689 { "(bad)", { XX } },
4692 /* PREFIX_VEX_389D */
4694 { "(bad)", { XX } },
4695 { "(bad)", { XX } },
4696 { "vfnmadd132s%XW", { XM, Vex, EXVexWdq } },
4697 { "(bad)", { XX } },
4700 /* PREFIX_VEX_389E */
4702 { "(bad)", { XX } },
4703 { "(bad)", { XX } },
4704 { "vfnmsub132p%XW", { XM, Vex, EXx } },
4705 { "(bad)", { XX } },
4708 /* PREFIX_VEX_389F */
4710 { "(bad)", { XX } },
4711 { "(bad)", { XX } },
4712 { "vfnmsub132s%XW", { XM, Vex, EXVexWdq } },
4713 { "(bad)", { XX } },
4716 /* PREFIX_VEX_38A6 */
4718 { "(bad)", { XX } },
4719 { "(bad)", { XX } },
4720 { "vfmaddsub213p%XW", { XM, Vex, EXx } },
4721 { "(bad)", { XX } },
4724 /* PREFIX_VEX_38A7 */
4726 { "(bad)", { XX } },
4727 { "(bad)", { XX } },
4728 { "vfmsubadd213p%XW", { XM, Vex, EXx } },
4729 { "(bad)", { XX } },
4732 /* PREFIX_VEX_38A8 */
4734 { "(bad)", { XX } },
4735 { "(bad)", { XX } },
4736 { "vfmadd213p%XW", { XM, Vex, EXx } },
4737 { "(bad)", { XX } },
4740 /* PREFIX_VEX_38A9 */
4742 { "(bad)", { XX } },
4743 { "(bad)", { XX } },
4744 { "vfmadd213s%XW", { XM, Vex, EXVexWdq } },
4745 { "(bad)", { XX } },
4748 /* PREFIX_VEX_38AA */
4750 { "(bad)", { XX } },
4751 { "(bad)", { XX } },
4752 { "vfmsub213p%XW", { XM, Vex, EXx } },
4753 { "(bad)", { XX } },
4756 /* PREFIX_VEX_38AB */
4758 { "(bad)", { XX } },
4759 { "(bad)", { XX } },
4760 { "vfmsub213s%XW", { XM, Vex, EXVexWdq } },
4761 { "(bad)", { XX } },
4764 /* PREFIX_VEX_38AC */
4766 { "(bad)", { XX } },
4767 { "(bad)", { XX } },
4768 { "vfnmadd213p%XW", { XM, Vex, EXx } },
4769 { "(bad)", { XX } },
4772 /* PREFIX_VEX_38AD */
4774 { "(bad)", { XX } },
4775 { "(bad)", { XX } },
4776 { "vfnmadd213s%XW", { XM, Vex, EXVexWdq } },
4777 { "(bad)", { XX } },
4780 /* PREFIX_VEX_38AE */
4782 { "(bad)", { XX } },
4783 { "(bad)", { XX } },
4784 { "vfnmsub213p%XW", { XM, Vex, EXx } },
4785 { "(bad)", { XX } },
4788 /* PREFIX_VEX_38AF */
4790 { "(bad)", { XX } },
4791 { "(bad)", { XX } },
4792 { "vfnmsub213s%XW", { XM, Vex, EXVexWdq } },
4793 { "(bad)", { XX } },
4796 /* PREFIX_VEX_38B6 */
4798 { "(bad)", { XX } },
4799 { "(bad)", { XX } },
4800 { "vfmaddsub231p%XW", { XM, Vex, EXx } },
4801 { "(bad)", { XX } },
4804 /* PREFIX_VEX_38B7 */
4806 { "(bad)", { XX } },
4807 { "(bad)", { XX } },
4808 { "vfmsubadd231p%XW", { XM, Vex, EXx } },
4809 { "(bad)", { XX } },
4812 /* PREFIX_VEX_38B8 */
4814 { "(bad)", { XX } },
4815 { "(bad)", { XX } },
4816 { "vfmadd231p%XW", { XM, Vex, EXx } },
4817 { "(bad)", { XX } },
4820 /* PREFIX_VEX_38B9 */
4822 { "(bad)", { XX } },
4823 { "(bad)", { XX } },
4824 { "vfmadd231s%XW", { XM, Vex, EXVexWdq } },
4825 { "(bad)", { XX } },
4828 /* PREFIX_VEX_38BA */
4830 { "(bad)", { XX } },
4831 { "(bad)", { XX } },
4832 { "vfmsub231p%XW", { XM, Vex, EXx } },
4833 { "(bad)", { XX } },
4836 /* PREFIX_VEX_38BB */
4838 { "(bad)", { XX } },
4839 { "(bad)", { XX } },
4840 { "vfmsub231s%XW", { XM, Vex, EXVexWdq } },
4841 { "(bad)", { XX } },
4844 /* PREFIX_VEX_38BC */
4846 { "(bad)", { XX } },
4847 { "(bad)", { XX } },
4848 { "vfnmadd231p%XW", { XM, Vex, EXx } },
4849 { "(bad)", { XX } },
4852 /* PREFIX_VEX_38BD */
4854 { "(bad)", { XX } },
4855 { "(bad)", { XX } },
4856 { "vfnmadd231s%XW", { XM, Vex, EXVexWdq } },
4857 { "(bad)", { XX } },
4860 /* PREFIX_VEX_38BE */
4862 { "(bad)", { XX } },
4863 { "(bad)", { XX } },
4864 { "vfnmsub231p%XW", { XM, Vex, EXx } },
4865 { "(bad)", { XX } },
4868 /* PREFIX_VEX_38BF */
4870 { "(bad)", { XX } },
4871 { "(bad)", { XX } },
4872 { "vfnmsub231s%XW", { XM, Vex, EXVexWdq } },
4873 { "(bad)", { XX } },
4876 /* PREFIX_VEX_38DB */
4878 { "(bad)", { XX } },
4879 { "(bad)", { XX } },
4880 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2) },
4881 { "(bad)", { XX } },
4884 /* PREFIX_VEX_38DC */
4886 { "(bad)", { XX } },
4887 { "(bad)", { XX } },
4888 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2) },
4889 { "(bad)", { XX } },
4892 /* PREFIX_VEX_38DD */
4894 { "(bad)", { XX } },
4895 { "(bad)", { XX } },
4896 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2) },
4897 { "(bad)", { XX } },
4900 /* PREFIX_VEX_38DE */
4902 { "(bad)", { XX } },
4903 { "(bad)", { XX } },
4904 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2) },
4905 { "(bad)", { XX } },
4908 /* PREFIX_VEX_38DF */
4910 { "(bad)", { XX } },
4911 { "(bad)", { XX } },
4912 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2) },
4913 { "(bad)", { XX } },
4916 /* PREFIX_VEX_3A04 */
4918 { "(bad)", { XX } },
4919 { "(bad)", { XX } },
4920 { "vpermilps", { XM, EXx, Ib } },
4921 { "(bad)", { XX } },
4924 /* PREFIX_VEX_3A05 */
4926 { "(bad)", { XX } },
4927 { "(bad)", { XX } },
4928 { "vpermilpd", { XM, EXx, Ib } },
4929 { "(bad)", { XX } },
4932 /* PREFIX_VEX_3A06 */
4934 { "(bad)", { XX } },
4935 { "(bad)", { XX } },
4936 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2) },
4937 { "(bad)", { XX } },
4940 /* PREFIX_VEX_3A08 */
4942 { "(bad)", { XX } },
4943 { "(bad)", { XX } },
4944 { "vroundps", { XM, EXx, Ib } },
4945 { "(bad)", { XX } },
4948 /* PREFIX_VEX_3A09 */
4950 { "(bad)", { XX } },
4951 { "(bad)", { XX } },
4952 { "vroundpd", { XM, EXx, Ib } },
4953 { "(bad)", { XX } },
4956 /* PREFIX_VEX_3A0A */
4958 { "(bad)", { XX } },
4959 { "(bad)", { XX } },
4960 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2) },
4961 { "(bad)", { XX } },
4964 /* PREFIX_VEX_3A0B */
4966 { "(bad)", { XX } },
4967 { "(bad)", { XX } },
4968 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2) },
4969 { "(bad)", { XX } },
4972 /* PREFIX_VEX_3A0C */
4974 { "(bad)", { XX } },
4975 { "(bad)", { XX } },
4976 { "vblendps", { XM, Vex, EXx, Ib } },
4977 { "(bad)", { XX } },
4980 /* PREFIX_VEX_3A0D */
4982 { "(bad)", { XX } },
4983 { "(bad)", { XX } },
4984 { "vblendpd", { XM, Vex, EXx, Ib } },
4985 { "(bad)", { XX } },
4988 /* PREFIX_VEX_3A0E */
4990 { "(bad)", { XX } },
4991 { "(bad)", { XX } },
4992 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2) },
4993 { "(bad)", { XX } },
4996 /* PREFIX_VEX_3A0F */
4998 { "(bad)", { XX } },
4999 { "(bad)", { XX } },
5000 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2) },
5001 { "(bad)", { XX } },
5004 /* PREFIX_VEX_3A14 */
5006 { "(bad)", { XX } },
5007 { "(bad)", { XX } },
5008 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2) },
5009 { "(bad)", { XX } },
5012 /* PREFIX_VEX_3A15 */
5014 { "(bad)", { XX } },
5015 { "(bad)", { XX } },
5016 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2) },
5017 { "(bad)", { XX } },
5020 /* PREFIX_VEX_3A16 */
5022 { "(bad)", { XX } },
5023 { "(bad)", { XX } },
5024 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2) },
5025 { "(bad)", { XX } },
5028 /* PREFIX_VEX_3A17 */
5030 { "(bad)", { XX } },
5031 { "(bad)", { XX } },
5032 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2) },
5033 { "(bad)", { XX } },
5036 /* PREFIX_VEX_3A18 */
5038 { "(bad)", { XX } },
5039 { "(bad)", { XX } },
5040 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2) },
5041 { "(bad)", { XX } },
5044 /* PREFIX_VEX_3A19 */
5046 { "(bad)", { XX } },
5047 { "(bad)", { XX } },
5048 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2) },
5049 { "(bad)", { XX } },
5052 /* PREFIX_VEX_3A20 */
5054 { "(bad)", { XX } },
5055 { "(bad)", { XX } },
5056 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2) },
5057 { "(bad)", { XX } },
5060 /* PREFIX_VEX_3A21 */
5062 { "(bad)", { XX } },
5063 { "(bad)", { XX } },
5064 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2) },
5065 { "(bad)", { XX } },
5068 /* PREFIX_VEX_3A22 */
5070 { "(bad)", { XX } },
5071 { "(bad)", { XX } },
5072 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2) },
5073 { "(bad)", { XX } },
5076 /* PREFIX_VEX_3A40 */
5078 { "(bad)", { XX } },
5079 { "(bad)", { XX } },
5080 { "vdpps", { XM, Vex, EXx, Ib } },
5081 { "(bad)", { XX } },
5084 /* PREFIX_VEX_3A41 */
5086 { "(bad)", { XX } },
5087 { "(bad)", { XX } },
5088 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2) },
5089 { "(bad)", { XX } },
5092 /* PREFIX_VEX_3A42 */
5094 { "(bad)", { XX } },
5095 { "(bad)", { XX } },
5096 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2) },
5097 { "(bad)", { XX } },
5100 /* PREFIX_VEX_3A44 */
5102 { "(bad)", { XX } },
5103 { "(bad)", { XX } },
5104 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2) },
5105 { "(bad)", { XX } },
5108 /* PREFIX_VEX_3A4A */
5110 { "(bad)", { XX } },
5111 { "(bad)", { XX } },
5112 { "vblendvps", { XM, Vex, EXx, XMVexI4 } },
5113 { "(bad)", { XX } },
5116 /* PREFIX_VEX_3A4B */
5118 { "(bad)", { XX } },
5119 { "(bad)", { XX } },
5120 { "vblendvpd", { XM, Vex, EXx, XMVexI4 } },
5121 { "(bad)", { XX } },
5124 /* PREFIX_VEX_3A4C */
5126 { "(bad)", { XX } },
5127 { "(bad)", { XX } },
5128 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2) },
5129 { "(bad)", { XX } },
5132 /* PREFIX_VEX_3A5C */
5134 { "(bad)", { XX } },
5135 { "(bad)", { XX } },
5136 { "vfmaddsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5137 { "(bad)", { XX } },
5140 /* PREFIX_VEX_3A5D */
5142 { "(bad)", { XX } },
5143 { "(bad)", { XX } },
5144 { "vfmaddsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5145 { "(bad)", { XX } },
5148 /* PREFIX_VEX_3A5E */
5150 { "(bad)", { XX } },
5151 { "(bad)", { XX } },
5152 { "vfmsubaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5153 { "(bad)", { XX } },
5156 /* PREFIX_VEX_3A5F */
5158 { "(bad)", { XX } },
5159 { "(bad)", { XX } },
5160 { "vfmsubaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5161 { "(bad)", { XX } },
5164 /* PREFIX_VEX_3A60 */
5166 { "(bad)", { XX } },
5167 { "(bad)", { XX } },
5168 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2) },
5169 { "(bad)", { XX } },
5172 /* PREFIX_VEX_3A61 */
5174 { "(bad)", { XX } },
5175 { "(bad)", { XX } },
5176 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2) },
5177 { "(bad)", { XX } },
5180 /* PREFIX_VEX_3A62 */
5182 { "(bad)", { XX } },
5183 { "(bad)", { XX } },
5184 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2) },
5185 { "(bad)", { XX } },
5188 /* PREFIX_VEX_3A63 */
5190 { "(bad)", { XX } },
5191 { "(bad)", { XX } },
5192 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2) },
5193 { "(bad)", { XX } },
5196 /* PREFIX_VEX_3A68 */
5198 { "(bad)", { XX } },
5199 { "(bad)", { XX } },
5200 { "vfmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5201 { "(bad)", { XX } },
5204 /* PREFIX_VEX_3A69 */
5206 { "(bad)", { XX } },
5207 { "(bad)", { XX } },
5208 { "vfmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5209 { "(bad)", { XX } },
5212 /* PREFIX_VEX_3A6A */
5214 { "(bad)", { XX } },
5215 { "(bad)", { XX } },
5216 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2) },
5217 { "(bad)", { XX } },
5220 /* PREFIX_VEX_3A6B */
5222 { "(bad)", { XX } },
5223 { "(bad)", { XX } },
5224 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2) },
5225 { "(bad)", { XX } },
5228 /* PREFIX_VEX_3A6C */
5230 { "(bad)", { XX } },
5231 { "(bad)", { XX } },
5232 { "vfmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5233 { "(bad)", { XX } },
5236 /* PREFIX_VEX_3A6D */
5238 { "(bad)", { XX } },
5239 { "(bad)", { XX } },
5240 { "vfmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5241 { "(bad)", { XX } },
5244 /* PREFIX_VEX_3A6E */
5246 { "(bad)", { XX } },
5247 { "(bad)", { XX } },
5248 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2) },
5249 { "(bad)", { XX } },
5252 /* PREFIX_VEX_3A6F */
5254 { "(bad)", { XX } },
5255 { "(bad)", { XX } },
5256 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2) },
5257 { "(bad)", { XX } },
5260 /* PREFIX_VEX_3A78 */
5262 { "(bad)", { XX } },
5263 { "(bad)", { XX } },
5264 { "vfnmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5265 { "(bad)", { XX } },
5268 /* PREFIX_VEX_3A79 */
5270 { "(bad)", { XX } },
5271 { "(bad)", { XX } },
5272 { "vfnmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5273 { "(bad)", { XX } },
5276 /* PREFIX_VEX_3A7A */
5278 { "(bad)", { XX } },
5279 { "(bad)", { XX } },
5280 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2) },
5281 { "(bad)", { XX } },
5284 /* PREFIX_VEX_3A7B */
5286 { "(bad)", { XX } },
5287 { "(bad)", { XX } },
5288 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2) },
5289 { "(bad)", { XX } },
5292 /* PREFIX_VEX_3A7C */
5294 { "(bad)", { XX } },
5295 { "(bad)", { XX } },
5296 { "vfnmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5297 { "(bad)", { XX } },
5300 /* PREFIX_VEX_3A7D */
5302 { "(bad)", { XX } },
5303 { "(bad)", { XX } },
5304 { "vfnmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5305 { "(bad)", { XX } },
5308 /* PREFIX_VEX_3A7E */
5310 { "(bad)", { XX } },
5311 { "(bad)", { XX } },
5312 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2) },
5313 { "(bad)", { XX } },
5316 /* PREFIX_VEX_3A7F */
5318 { "(bad)", { XX } },
5319 { "(bad)", { XX } },
5320 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2) },
5321 { "(bad)", { XX } },
5324 /* PREFIX_VEX_3ADF */
5326 { "(bad)", { XX } },
5327 { "(bad)", { XX } },
5328 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2) },
5329 { "(bad)", { XX } },
5333 static const struct dis386 x86_64_table[][2] = {
5336 { "push{T|}", { es } },
5337 { "(bad)", { XX } },
5342 { "pop{T|}", { es } },
5343 { "(bad)", { XX } },
5348 { "push{T|}", { cs } },
5349 { "(bad)", { XX } },
5354 { "push{T|}", { ss } },
5355 { "(bad)", { XX } },
5360 { "pop{T|}", { ss } },
5361 { "(bad)", { XX } },
5366 { "push{T|}", { ds } },
5367 { "(bad)", { XX } },
5372 { "pop{T|}", { ds } },
5373 { "(bad)", { XX } },
5379 { "(bad)", { XX } },
5385 { "(bad)", { XX } },
5391 { "(bad)", { XX } },
5397 { "(bad)", { XX } },
5402 { "pusha{P|}", { XX } },
5403 { "(bad)", { XX } },
5408 { "popa{P|}", { XX } },
5409 { "(bad)", { XX } },
5414 { MOD_TABLE (MOD_62_32BIT) },
5415 { "(bad)", { XX } },
5420 { "arpl", { Ew, Gw } },
5421 { "movs{lq|xd}", { Gv, Ed } },
5426 { "ins{R|}", { Yzr, indirDX } },
5427 { "ins{G|}", { Yzr, indirDX } },
5432 { "outs{R|}", { indirDXr, Xz } },
5433 { "outs{G|}", { indirDXr, Xz } },
5438 { "Jcall{T|}", { Ap } },
5439 { "(bad)", { XX } },
5444 { MOD_TABLE (MOD_C4_32BIT) },
5445 { VEX_C4_TABLE (VEX_0F) },
5450 { MOD_TABLE (MOD_C5_32BIT) },
5451 { VEX_C5_TABLE (VEX_0F) },
5457 { "(bad)", { XX } },
5463 { "(bad)", { XX } },
5469 { "(bad)", { XX } },
5474 { "Jjmp{T|}", { Ap } },
5475 { "(bad)", { XX } },
5478 /* X86_64_0F01_REG_0 */
5480 { "sgdt{Q|IQ}", { M } },
5484 /* X86_64_0F01_REG_1 */
5486 { "sidt{Q|IQ}", { M } },
5490 /* X86_64_0F01_REG_2 */
5492 { "lgdt{Q|Q}", { M } },
5496 /* X86_64_0F01_REG_3 */
5498 { "lidt{Q|Q}", { M } },
5503 static const struct dis386 three_byte_table[][256] = {
5505 /* THREE_BYTE_0F38 */
5508 { "pshufb", { MX, EM } },
5509 { "phaddw", { MX, EM } },
5510 { "phaddd", { MX, EM } },
5511 { "phaddsw", { MX, EM } },
5512 { "pmaddubsw", { MX, EM } },
5513 { "phsubw", { MX, EM } },
5514 { "phsubd", { MX, EM } },
5515 { "phsubsw", { MX, EM } },
5517 { "psignb", { MX, EM } },
5518 { "psignw", { MX, EM } },
5519 { "psignd", { MX, EM } },
5520 { "pmulhrsw", { MX, EM } },
5521 { "(bad)", { XX } },
5522 { "(bad)", { XX } },
5523 { "(bad)", { XX } },
5524 { "(bad)", { XX } },
5526 { PREFIX_TABLE (PREFIX_0F3810) },
5527 { "(bad)", { XX } },
5528 { "(bad)", { XX } },
5529 { "(bad)", { XX } },
5530 { PREFIX_TABLE (PREFIX_0F3814) },
5531 { PREFIX_TABLE (PREFIX_0F3815) },
5532 { "(bad)", { XX } },
5533 { PREFIX_TABLE (PREFIX_0F3817) },
5535 { "(bad)", { XX } },
5536 { "(bad)", { XX } },
5537 { "(bad)", { XX } },
5538 { "(bad)", { XX } },
5539 { "pabsb", { MX, EM } },
5540 { "pabsw", { MX, EM } },
5541 { "pabsd", { MX, EM } },
5542 { "(bad)", { XX } },
5544 { PREFIX_TABLE (PREFIX_0F3820) },
5545 { PREFIX_TABLE (PREFIX_0F3821) },
5546 { PREFIX_TABLE (PREFIX_0F3822) },
5547 { PREFIX_TABLE (PREFIX_0F3823) },
5548 { PREFIX_TABLE (PREFIX_0F3824) },
5549 { PREFIX_TABLE (PREFIX_0F3825) },
5550 { "(bad)", { XX } },
5551 { "(bad)", { XX } },
5553 { PREFIX_TABLE (PREFIX_0F3828) },
5554 { PREFIX_TABLE (PREFIX_0F3829) },
5555 { PREFIX_TABLE (PREFIX_0F382A) },
5556 { PREFIX_TABLE (PREFIX_0F382B) },
5557 { "(bad)", { XX } },
5558 { "(bad)", { XX } },
5559 { "(bad)", { XX } },
5560 { "(bad)", { XX } },
5562 { PREFIX_TABLE (PREFIX_0F3830) },
5563 { PREFIX_TABLE (PREFIX_0F3831) },
5564 { PREFIX_TABLE (PREFIX_0F3832) },
5565 { PREFIX_TABLE (PREFIX_0F3833) },
5566 { PREFIX_TABLE (PREFIX_0F3834) },
5567 { PREFIX_TABLE (PREFIX_0F3835) },
5568 { "(bad)", { XX } },
5569 { PREFIX_TABLE (PREFIX_0F3837) },
5571 { PREFIX_TABLE (PREFIX_0F3838) },
5572 { PREFIX_TABLE (PREFIX_0F3839) },
5573 { PREFIX_TABLE (PREFIX_0F383A) },
5574 { PREFIX_TABLE (PREFIX_0F383B) },
5575 { PREFIX_TABLE (PREFIX_0F383C) },
5576 { PREFIX_TABLE (PREFIX_0F383D) },
5577 { PREFIX_TABLE (PREFIX_0F383E) },
5578 { PREFIX_TABLE (PREFIX_0F383F) },
5580 { PREFIX_TABLE (PREFIX_0F3840) },
5581 { PREFIX_TABLE (PREFIX_0F3841) },
5582 { "(bad)", { XX } },
5583 { "(bad)", { XX } },
5584 { "(bad)", { XX } },
5585 { "(bad)", { XX } },
5586 { "(bad)", { XX } },
5587 { "(bad)", { XX } },
5589 { "(bad)", { XX } },
5590 { "(bad)", { XX } },
5591 { "(bad)", { XX } },
5592 { "(bad)", { XX } },
5593 { "(bad)", { XX } },
5594 { "(bad)", { XX } },
5595 { "(bad)", { XX } },
5596 { "(bad)", { XX } },
5598 { "(bad)", { XX } },
5599 { "(bad)", { XX } },
5600 { "(bad)", { XX } },
5601 { "(bad)", { XX } },
5602 { "(bad)", { XX } },
5603 { "(bad)", { XX } },
5604 { "(bad)", { XX } },
5605 { "(bad)", { XX } },
5607 { "(bad)", { XX } },
5608 { "(bad)", { XX } },
5609 { "(bad)", { XX } },
5610 { "(bad)", { XX } },
5611 { "(bad)", { XX } },
5612 { "(bad)", { XX } },
5613 { "(bad)", { XX } },
5614 { "(bad)", { XX } },
5616 { "(bad)", { XX } },
5617 { "(bad)", { XX } },
5618 { "(bad)", { XX } },
5619 { "(bad)", { XX } },
5620 { "(bad)", { XX } },
5621 { "(bad)", { XX } },
5622 { "(bad)", { XX } },
5623 { "(bad)", { XX } },
5625 { "(bad)", { XX } },
5626 { "(bad)", { XX } },
5627 { "(bad)", { XX } },
5628 { "(bad)", { XX } },
5629 { "(bad)", { XX } },
5630 { "(bad)", { XX } },
5631 { "(bad)", { XX } },
5632 { "(bad)", { XX } },
5634 { "(bad)", { XX } },
5635 { "(bad)", { XX } },
5636 { "(bad)", { XX } },
5637 { "(bad)", { XX } },
5638 { "(bad)", { XX } },
5639 { "(bad)", { XX } },
5640 { "(bad)", { XX } },
5641 { "(bad)", { XX } },
5643 { "(bad)", { XX } },
5644 { "(bad)", { XX } },
5645 { "(bad)", { XX } },
5646 { "(bad)", { XX } },
5647 { "(bad)", { XX } },
5648 { "(bad)", { XX } },
5649 { "(bad)", { XX } },
5650 { "(bad)", { XX } },
5652 { PREFIX_TABLE (PREFIX_0F3880) },
5653 { PREFIX_TABLE (PREFIX_0F3881) },
5654 { "(bad)", { XX } },
5655 { "(bad)", { XX } },
5656 { "(bad)", { XX } },
5657 { "(bad)", { XX } },
5658 { "(bad)", { XX } },
5659 { "(bad)", { XX } },
5661 { "(bad)", { XX } },
5662 { "(bad)", { XX } },
5663 { "(bad)", { XX } },
5664 { "(bad)", { XX } },
5665 { "(bad)", { XX } },
5666 { "(bad)", { XX } },
5667 { "(bad)", { XX } },
5668 { "(bad)", { XX } },
5670 { "(bad)", { XX } },
5671 { "(bad)", { XX } },
5672 { "(bad)", { XX } },
5673 { "(bad)", { XX } },
5674 { "(bad)", { XX } },
5675 { "(bad)", { XX } },
5676 { "(bad)", { XX } },
5677 { "(bad)", { XX } },
5679 { "(bad)", { XX } },
5680 { "(bad)", { XX } },
5681 { "(bad)", { XX } },
5682 { "(bad)", { XX } },
5683 { "(bad)", { XX } },
5684 { "(bad)", { XX } },
5685 { "(bad)", { XX } },
5686 { "(bad)", { XX } },
5688 { "(bad)", { XX } },
5689 { "(bad)", { XX } },
5690 { "(bad)", { XX } },
5691 { "(bad)", { XX } },
5692 { "(bad)", { XX } },
5693 { "(bad)", { XX } },
5694 { "(bad)", { XX } },
5695 { "(bad)", { XX } },
5697 { "(bad)", { XX } },
5698 { "(bad)", { XX } },
5699 { "(bad)", { XX } },
5700 { "(bad)", { XX } },
5701 { "(bad)", { XX } },
5702 { "(bad)", { XX } },
5703 { "(bad)", { XX } },
5704 { "(bad)", { XX } },
5706 { "(bad)", { XX } },
5707 { "(bad)", { XX } },
5708 { "(bad)", { XX } },
5709 { "(bad)", { XX } },
5710 { "(bad)", { XX } },
5711 { "(bad)", { XX } },
5712 { "(bad)", { XX } },
5713 { "(bad)", { XX } },
5715 { "(bad)", { XX } },
5716 { "(bad)", { XX } },
5717 { "(bad)", { XX } },
5718 { "(bad)", { XX } },
5719 { "(bad)", { XX } },
5720 { "(bad)", { XX } },
5721 { "(bad)", { XX } },
5722 { "(bad)", { XX } },
5724 { "(bad)", { XX } },
5725 { "(bad)", { XX } },
5726 { "(bad)", { XX } },
5727 { "(bad)", { XX } },
5728 { "(bad)", { XX } },
5729 { "(bad)", { XX } },
5730 { "(bad)", { XX } },
5731 { "(bad)", { XX } },
5733 { "(bad)", { XX } },
5734 { "(bad)", { XX } },
5735 { "(bad)", { XX } },
5736 { "(bad)", { XX } },
5737 { "(bad)", { XX } },
5738 { "(bad)", { XX } },
5739 { "(bad)", { XX } },
5740 { "(bad)", { XX } },
5742 { "(bad)", { XX } },
5743 { "(bad)", { XX } },
5744 { "(bad)", { XX } },
5745 { "(bad)", { XX } },
5746 { "(bad)", { XX } },
5747 { "(bad)", { XX } },
5748 { "(bad)", { XX } },
5749 { "(bad)", { XX } },
5751 { "(bad)", { XX } },
5752 { "(bad)", { XX } },
5753 { "(bad)", { XX } },
5754 { PREFIX_TABLE (PREFIX_0F38DB) },
5755 { PREFIX_TABLE (PREFIX_0F38DC) },
5756 { PREFIX_TABLE (PREFIX_0F38DD) },
5757 { PREFIX_TABLE (PREFIX_0F38DE) },
5758 { PREFIX_TABLE (PREFIX_0F38DF) },
5760 { "(bad)", { XX } },
5761 { "(bad)", { XX } },
5762 { "(bad)", { XX } },
5763 { "(bad)", { XX } },
5764 { "(bad)", { XX } },
5765 { "(bad)", { XX } },
5766 { "(bad)", { XX } },
5767 { "(bad)", { XX } },
5769 { "(bad)", { XX } },
5770 { "(bad)", { XX } },
5771 { "(bad)", { XX } },
5772 { "(bad)", { XX } },
5773 { "(bad)", { XX } },
5774 { "(bad)", { XX } },
5775 { "(bad)", { XX } },
5776 { "(bad)", { XX } },
5778 { PREFIX_TABLE (PREFIX_0F38F0) },
5779 { PREFIX_TABLE (PREFIX_0F38F1) },
5780 { "(bad)", { XX } },
5781 { "(bad)", { XX } },
5782 { "(bad)", { XX } },
5783 { "(bad)", { XX } },
5784 { "(bad)", { XX } },
5785 { "(bad)", { XX } },
5787 { "(bad)", { XX } },
5788 { "(bad)", { XX } },
5789 { "(bad)", { XX } },
5790 { "(bad)", { XX } },
5791 { "(bad)", { XX } },
5792 { "(bad)", { XX } },
5793 { "(bad)", { XX } },
5794 { "(bad)", { XX } },
5796 /* THREE_BYTE_0F3A */
5799 { "(bad)", { XX } },
5800 { "(bad)", { XX } },
5801 { "(bad)", { XX } },
5802 { "(bad)", { XX } },
5803 { "(bad)", { XX } },
5804 { "(bad)", { XX } },
5805 { "(bad)", { XX } },
5806 { "(bad)", { XX } },
5808 { PREFIX_TABLE (PREFIX_0F3A08) },
5809 { PREFIX_TABLE (PREFIX_0F3A09) },
5810 { PREFIX_TABLE (PREFIX_0F3A0A) },
5811 { PREFIX_TABLE (PREFIX_0F3A0B) },
5812 { PREFIX_TABLE (PREFIX_0F3A0C) },
5813 { PREFIX_TABLE (PREFIX_0F3A0D) },
5814 { PREFIX_TABLE (PREFIX_0F3A0E) },
5815 { "palignr", { MX, EM, Ib } },
5817 { "(bad)", { XX } },
5818 { "(bad)", { XX } },
5819 { "(bad)", { XX } },
5820 { "(bad)", { XX } },
5821 { PREFIX_TABLE (PREFIX_0F3A14) },
5822 { PREFIX_TABLE (PREFIX_0F3A15) },
5823 { PREFIX_TABLE (PREFIX_0F3A16) },
5824 { PREFIX_TABLE (PREFIX_0F3A17) },
5826 { "(bad)", { XX } },
5827 { "(bad)", { XX } },
5828 { "(bad)", { XX } },
5829 { "(bad)", { XX } },
5830 { "(bad)", { XX } },
5831 { "(bad)", { XX } },
5832 { "(bad)", { XX } },
5833 { "(bad)", { XX } },
5835 { PREFIX_TABLE (PREFIX_0F3A20) },
5836 { PREFIX_TABLE (PREFIX_0F3A21) },
5837 { PREFIX_TABLE (PREFIX_0F3A22) },
5838 { "(bad)", { XX } },
5839 { "(bad)", { XX } },
5840 { "(bad)", { XX } },
5841 { "(bad)", { XX } },
5842 { "(bad)", { XX } },
5844 { "(bad)", { XX } },
5845 { "(bad)", { XX } },
5846 { "(bad)", { XX } },
5847 { "(bad)", { XX } },
5848 { "(bad)", { XX } },
5849 { "(bad)", { XX } },
5850 { "(bad)", { XX } },
5851 { "(bad)", { XX } },
5853 { "(bad)", { XX } },
5854 { "(bad)", { XX } },
5855 { "(bad)", { XX } },
5856 { "(bad)", { XX } },
5857 { "(bad)", { XX } },
5858 { "(bad)", { XX } },
5859 { "(bad)", { XX } },
5860 { "(bad)", { XX } },
5862 { "(bad)", { XX } },
5863 { "(bad)", { XX } },
5864 { "(bad)", { XX } },
5865 { "(bad)", { XX } },
5866 { "(bad)", { XX } },
5867 { "(bad)", { XX } },
5868 { "(bad)", { XX } },
5869 { "(bad)", { XX } },
5871 { PREFIX_TABLE (PREFIX_0F3A40) },
5872 { PREFIX_TABLE (PREFIX_0F3A41) },
5873 { PREFIX_TABLE (PREFIX_0F3A42) },
5874 { "(bad)", { XX } },
5875 { PREFIX_TABLE (PREFIX_0F3A44) },
5876 { "(bad)", { XX } },
5877 { "(bad)", { XX } },
5878 { "(bad)", { XX } },
5880 { "(bad)", { XX } },
5881 { "(bad)", { XX } },
5882 { "(bad)", { XX } },
5883 { "(bad)", { XX } },
5884 { "(bad)", { XX } },
5885 { "(bad)", { XX } },
5886 { "(bad)", { XX } },
5887 { "(bad)", { XX } },
5889 { "(bad)", { XX } },
5890 { "(bad)", { XX } },
5891 { "(bad)", { XX } },
5892 { "(bad)", { XX } },
5893 { "(bad)", { XX } },
5894 { "(bad)", { XX } },
5895 { "(bad)", { XX } },
5896 { "(bad)", { XX } },
5898 { "(bad)", { XX } },
5899 { "(bad)", { XX } },
5900 { "(bad)", { XX } },
5901 { "(bad)", { XX } },
5902 { "(bad)", { XX } },
5903 { "(bad)", { XX } },
5904 { "(bad)", { XX } },
5905 { "(bad)", { XX } },
5907 { PREFIX_TABLE (PREFIX_0F3A60) },
5908 { PREFIX_TABLE (PREFIX_0F3A61) },
5909 { PREFIX_TABLE (PREFIX_0F3A62) },
5910 { PREFIX_TABLE (PREFIX_0F3A63) },
5911 { "(bad)", { XX } },
5912 { "(bad)", { XX } },
5913 { "(bad)", { XX } },
5914 { "(bad)", { XX } },
5916 { "(bad)", { XX } },
5917 { "(bad)", { XX } },
5918 { "(bad)", { XX } },
5919 { "(bad)", { XX } },
5920 { "(bad)", { XX } },
5921 { "(bad)", { XX } },
5922 { "(bad)", { XX } },
5923 { "(bad)", { XX } },
5925 { "(bad)", { XX } },
5926 { "(bad)", { XX } },
5927 { "(bad)", { XX } },
5928 { "(bad)", { XX } },
5929 { "(bad)", { XX } },
5930 { "(bad)", { XX } },
5931 { "(bad)", { XX } },
5932 { "(bad)", { XX } },
5934 { "(bad)", { XX } },
5935 { "(bad)", { XX } },
5936 { "(bad)", { XX } },
5937 { "(bad)", { XX } },
5938 { "(bad)", { XX } },
5939 { "(bad)", { XX } },
5940 { "(bad)", { XX } },
5941 { "(bad)", { XX } },
5943 { "(bad)", { XX } },
5944 { "(bad)", { XX } },
5945 { "(bad)", { XX } },
5946 { "(bad)", { XX } },
5947 { "(bad)", { XX } },
5948 { "(bad)", { XX } },
5949 { "(bad)", { XX } },
5950 { "(bad)", { XX } },
5952 { "(bad)", { XX } },
5953 { "(bad)", { XX } },
5954 { "(bad)", { XX } },
5955 { "(bad)", { XX } },
5956 { "(bad)", { XX } },
5957 { "(bad)", { XX } },
5958 { "(bad)", { XX } },
5959 { "(bad)", { XX } },
5961 { "(bad)", { XX } },
5962 { "(bad)", { XX } },
5963 { "(bad)", { XX } },
5964 { "(bad)", { XX } },
5965 { "(bad)", { XX } },
5966 { "(bad)", { XX } },
5967 { "(bad)", { XX } },
5968 { "(bad)", { XX } },
5970 { "(bad)", { XX } },
5971 { "(bad)", { XX } },
5972 { "(bad)", { XX } },
5973 { "(bad)", { XX } },
5974 { "(bad)", { XX } },
5975 { "(bad)", { XX } },
5976 { "(bad)", { XX } },
5977 { "(bad)", { XX } },
5979 { "(bad)", { XX } },
5980 { "(bad)", { XX } },
5981 { "(bad)", { XX } },
5982 { "(bad)", { XX } },
5983 { "(bad)", { XX } },
5984 { "(bad)", { XX } },
5985 { "(bad)", { XX } },
5986 { "(bad)", { XX } },
5988 { "(bad)", { XX } },
5989 { "(bad)", { XX } },
5990 { "(bad)", { XX } },
5991 { "(bad)", { XX } },
5992 { "(bad)", { XX } },
5993 { "(bad)", { XX } },
5994 { "(bad)", { XX } },
5995 { "(bad)", { XX } },
5997 { "(bad)", { XX } },
5998 { "(bad)", { XX } },
5999 { "(bad)", { XX } },
6000 { "(bad)", { XX } },
6001 { "(bad)", { XX } },
6002 { "(bad)", { XX } },
6003 { "(bad)", { XX } },
6004 { "(bad)", { XX } },
6006 { "(bad)", { XX } },
6007 { "(bad)", { XX } },
6008 { "(bad)", { XX } },
6009 { "(bad)", { XX } },
6010 { "(bad)", { XX } },
6011 { "(bad)", { XX } },
6012 { "(bad)", { XX } },
6013 { "(bad)", { XX } },
6015 { "(bad)", { XX } },
6016 { "(bad)", { XX } },
6017 { "(bad)", { XX } },
6018 { "(bad)", { XX } },
6019 { "(bad)", { XX } },
6020 { "(bad)", { XX } },
6021 { "(bad)", { XX } },
6022 { "(bad)", { XX } },
6024 { "(bad)", { XX } },
6025 { "(bad)", { XX } },
6026 { "(bad)", { XX } },
6027 { "(bad)", { XX } },
6028 { "(bad)", { XX } },
6029 { "(bad)", { XX } },
6030 { "(bad)", { XX } },
6031 { "(bad)", { XX } },
6033 { "(bad)", { XX } },
6034 { "(bad)", { XX } },
6035 { "(bad)", { XX } },
6036 { "(bad)", { XX } },
6037 { "(bad)", { XX } },
6038 { "(bad)", { XX } },
6039 { "(bad)", { XX } },
6040 { "(bad)", { XX } },
6042 { "(bad)", { XX } },
6043 { "(bad)", { XX } },
6044 { "(bad)", { XX } },
6045 { "(bad)", { XX } },
6046 { "(bad)", { XX } },
6047 { "(bad)", { XX } },
6048 { "(bad)", { XX } },
6049 { PREFIX_TABLE (PREFIX_0F3ADF) },
6051 { "(bad)", { XX } },
6052 { "(bad)", { XX } },
6053 { "(bad)", { XX } },
6054 { "(bad)", { XX } },
6055 { "(bad)", { XX } },
6056 { "(bad)", { XX } },
6057 { "(bad)", { XX } },
6058 { "(bad)", { XX } },
6060 { "(bad)", { XX } },
6061 { "(bad)", { XX } },
6062 { "(bad)", { XX } },
6063 { "(bad)", { XX } },
6064 { "(bad)", { XX } },
6065 { "(bad)", { XX } },
6066 { "(bad)", { XX } },
6067 { "(bad)", { XX } },
6069 { "(bad)", { XX } },
6070 { "(bad)", { XX } },
6071 { "(bad)", { XX } },
6072 { "(bad)", { XX } },
6073 { "(bad)", { XX } },
6074 { "(bad)", { XX } },
6075 { "(bad)", { XX } },
6076 { "(bad)", { XX } },
6078 { "(bad)", { XX } },
6079 { "(bad)", { XX } },
6080 { "(bad)", { XX } },
6081 { "(bad)", { XX } },
6082 { "(bad)", { XX } },
6083 { "(bad)", { XX } },
6084 { "(bad)", { XX } },
6085 { "(bad)", { XX } },
6088 /* THREE_BYTE_0F7A */
6091 { "(bad)", { XX } },
6092 { "(bad)", { XX } },
6093 { "(bad)", { XX } },
6094 { "(bad)", { XX } },
6095 { "(bad)", { XX } },
6096 { "(bad)", { XX } },
6097 { "(bad)", { XX } },
6098 { "(bad)", { XX } },
6100 { "(bad)", { XX } },
6101 { "(bad)", { XX } },
6102 { "(bad)", { XX } },
6103 { "(bad)", { XX } },
6104 { "(bad)", { XX } },
6105 { "(bad)", { XX } },
6106 { "(bad)", { XX } },
6107 { "(bad)", { XX } },
6109 { "(bad)", { XX } },
6110 { "(bad)", { XX } },
6111 { "(bad)", { XX } },
6112 { "(bad)", { XX } },
6113 { "(bad)", { XX } },
6114 { "(bad)", { XX } },
6115 { "(bad)", { XX } },
6116 { "(bad)", { XX } },
6118 { "(bad)", { XX } },
6119 { "(bad)", { XX } },
6120 { "(bad)", { XX } },
6121 { "(bad)", { XX } },
6122 { "(bad)", { XX } },
6123 { "(bad)", { XX } },
6124 { "(bad)", { XX } },
6125 { "(bad)", { XX } },
6127 { "ptest", { XX } },
6128 { "(bad)", { XX } },
6129 { "(bad)", { XX } },
6130 { "(bad)", { XX } },
6131 { "(bad)", { XX } },
6132 { "(bad)", { XX } },
6133 { "(bad)", { XX } },
6134 { "(bad)", { XX } },
6136 { "(bad)", { XX } },
6137 { "(bad)", { XX } },
6138 { "(bad)", { XX } },
6139 { "(bad)", { XX } },
6140 { "(bad)", { XX } },
6141 { "(bad)", { XX } },
6142 { "(bad)", { XX } },
6143 { "(bad)", { XX } },
6145 { "(bad)", { XX } },
6146 { "(bad)", { XX } },
6147 { "(bad)", { XX } },
6148 { "(bad)", { XX } },
6149 { "(bad)", { XX } },
6150 { "(bad)", { XX } },
6151 { "(bad)", { XX } },
6152 { "(bad)", { XX } },
6154 { "(bad)", { XX } },
6155 { "(bad)", { XX } },
6156 { "(bad)", { XX } },
6157 { "(bad)", { XX } },
6158 { "(bad)", { XX } },
6159 { "(bad)", { XX } },
6160 { "(bad)", { XX } },
6161 { "(bad)", { XX } },
6163 { "(bad)", { XX } },
6164 { "phaddbw", { XM, EXq } },
6165 { "phaddbd", { XM, EXq } },
6166 { "phaddbq", { XM, EXq } },
6167 { "(bad)", { XX } },
6168 { "(bad)", { XX } },
6169 { "phaddwd", { XM, EXq } },
6170 { "phaddwq", { XM, EXq } },
6172 { "(bad)", { XX } },
6173 { "(bad)", { XX } },
6174 { "(bad)", { XX } },
6175 { "phadddq", { XM, EXq } },
6176 { "(bad)", { XX } },
6177 { "(bad)", { XX } },
6178 { "(bad)", { XX } },
6179 { "(bad)", { XX } },
6181 { "(bad)", { XX } },
6182 { "phaddubw", { XM, EXq } },
6183 { "phaddubd", { XM, EXq } },
6184 { "phaddubq", { XM, EXq } },
6185 { "(bad)", { XX } },
6186 { "(bad)", { XX } },
6187 { "phadduwd", { XM, EXq } },
6188 { "phadduwq", { XM, EXq } },
6190 { "(bad)", { XX } },
6191 { "(bad)", { XX } },
6192 { "(bad)", { XX } },
6193 { "phaddudq", { XM, EXq } },
6194 { "(bad)", { XX } },
6195 { "(bad)", { XX } },
6196 { "(bad)", { XX } },
6197 { "(bad)", { XX } },
6199 { "(bad)", { XX } },
6200 { "phsubbw", { XM, EXq } },
6201 { "phsubbd", { XM, EXq } },
6202 { "phsubbq", { XM, EXq } },
6203 { "(bad)", { XX } },
6204 { "(bad)", { XX } },
6205 { "(bad)", { XX } },
6206 { "(bad)", { XX } },
6208 { "(bad)", { XX } },
6209 { "(bad)", { XX } },
6210 { "(bad)", { XX } },
6211 { "(bad)", { XX } },
6212 { "(bad)", { XX } },
6213 { "(bad)", { XX } },
6214 { "(bad)", { XX } },
6215 { "(bad)", { XX } },
6217 { "(bad)", { XX } },
6218 { "(bad)", { XX } },
6219 { "(bad)", { XX } },
6220 { "(bad)", { XX } },
6221 { "(bad)", { XX } },
6222 { "(bad)", { XX } },
6223 { "(bad)", { XX } },
6224 { "(bad)", { XX } },
6226 { "(bad)", { XX } },
6227 { "(bad)", { XX } },
6228 { "(bad)", { XX } },
6229 { "(bad)", { XX } },
6230 { "(bad)", { XX } },
6231 { "(bad)", { XX } },
6232 { "(bad)", { XX } },
6233 { "(bad)", { XX } },
6235 { "(bad)", { XX } },
6236 { "(bad)", { XX } },
6237 { "(bad)", { XX } },
6238 { "(bad)", { XX } },
6239 { "(bad)", { XX } },
6240 { "(bad)", { XX } },
6241 { "(bad)", { XX } },
6242 { "(bad)", { XX } },
6244 { "(bad)", { XX } },
6245 { "(bad)", { XX } },
6246 { "(bad)", { XX } },
6247 { "(bad)", { XX } },
6248 { "(bad)", { XX } },
6249 { "(bad)", { XX } },
6250 { "(bad)", { XX } },
6251 { "(bad)", { XX } },
6253 { "(bad)", { XX } },
6254 { "(bad)", { XX } },
6255 { "(bad)", { XX } },
6256 { "(bad)", { XX } },
6257 { "(bad)", { XX } },
6258 { "(bad)", { XX } },
6259 { "(bad)", { XX } },
6260 { "(bad)", { XX } },
6262 { "(bad)", { XX } },
6263 { "(bad)", { XX } },
6264 { "(bad)", { XX } },
6265 { "(bad)", { XX } },
6266 { "(bad)", { XX } },
6267 { "(bad)", { XX } },
6268 { "(bad)", { XX } },
6269 { "(bad)", { XX } },
6271 { "(bad)", { XX } },
6272 { "(bad)", { XX } },
6273 { "(bad)", { XX } },
6274 { "(bad)", { XX } },
6275 { "(bad)", { XX } },
6276 { "(bad)", { XX } },
6277 { "(bad)", { XX } },
6278 { "(bad)", { XX } },
6280 { "(bad)", { XX } },
6281 { "(bad)", { XX } },
6282 { "(bad)", { XX } },
6283 { "(bad)", { XX } },
6284 { "(bad)", { XX } },
6285 { "(bad)", { XX } },
6286 { "(bad)", { XX } },
6287 { "(bad)", { XX } },
6289 { "(bad)", { XX } },
6290 { "(bad)", { XX } },
6291 { "(bad)", { XX } },
6292 { "(bad)", { XX } },
6293 { "(bad)", { XX } },
6294 { "(bad)", { XX } },
6295 { "(bad)", { XX } },
6296 { "(bad)", { XX } },
6298 { "(bad)", { XX } },
6299 { "(bad)", { XX } },
6300 { "(bad)", { XX } },
6301 { "(bad)", { XX } },
6302 { "(bad)", { XX } },
6303 { "(bad)", { XX } },
6304 { "(bad)", { XX } },
6305 { "(bad)", { XX } },
6307 { "(bad)", { XX } },
6308 { "(bad)", { XX } },
6309 { "(bad)", { XX } },
6310 { "(bad)", { XX } },
6311 { "(bad)", { XX } },
6312 { "(bad)", { XX } },
6313 { "(bad)", { XX } },
6314 { "(bad)", { XX } },
6316 { "(bad)", { XX } },
6317 { "(bad)", { XX } },
6318 { "(bad)", { XX } },
6319 { "(bad)", { XX } },
6320 { "(bad)", { XX } },
6321 { "(bad)", { XX } },
6322 { "(bad)", { XX } },
6323 { "(bad)", { XX } },
6325 { "(bad)", { XX } },
6326 { "(bad)", { XX } },
6327 { "(bad)", { XX } },
6328 { "(bad)", { XX } },
6329 { "(bad)", { XX } },
6330 { "(bad)", { XX } },
6331 { "(bad)", { XX } },
6332 { "(bad)", { XX } },
6334 { "(bad)", { XX } },
6335 { "(bad)", { XX } },
6336 { "(bad)", { XX } },
6337 { "(bad)", { XX } },
6338 { "(bad)", { XX } },
6339 { "(bad)", { XX } },
6340 { "(bad)", { XX } },
6341 { "(bad)", { XX } },
6343 { "(bad)", { XX } },
6344 { "(bad)", { XX } },
6345 { "(bad)", { XX } },
6346 { "(bad)", { XX } },
6347 { "(bad)", { XX } },
6348 { "(bad)", { XX } },
6349 { "(bad)", { XX } },
6350 { "(bad)", { XX } },
6352 { "(bad)", { XX } },
6353 { "(bad)", { XX } },
6354 { "(bad)", { XX } },
6355 { "(bad)", { XX } },
6356 { "(bad)", { XX } },
6357 { "(bad)", { XX } },
6358 { "(bad)", { XX } },
6359 { "(bad)", { XX } },
6361 { "(bad)", { XX } },
6362 { "(bad)", { XX } },
6363 { "(bad)", { XX } },
6364 { "(bad)", { XX } },
6365 { "(bad)", { XX } },
6366 { "(bad)", { XX } },
6367 { "(bad)", { XX } },
6368 { "(bad)", { XX } },
6370 { "(bad)", { XX } },
6371 { "(bad)", { XX } },
6372 { "(bad)", { XX } },
6373 { "(bad)", { XX } },
6374 { "(bad)", { XX } },
6375 { "(bad)", { XX } },
6376 { "(bad)", { XX } },
6377 { "(bad)", { XX } },
6381 static const struct dis386 xop_table[][256] = {
6385 { "(bad)", { XX } },
6386 { "(bad)", { XX } },
6387 { "(bad)", { XX } },
6388 { "(bad)", { XX } },
6389 { "(bad)", { XX } },
6390 { "(bad)", { XX } },
6391 { "(bad)", { XX } },
6392 { "(bad)", { XX } },
6394 { "(bad)", { XX } },
6395 { "(bad)", { XX } },
6396 { "(bad)", { XX } },
6397 { "(bad)", { XX } },
6398 { "(bad)", { XX } },
6399 { "(bad)", { XX } },
6400 { "(bad)", { XX } },
6401 { "(bad)", { XX } },
6403 { "(bad)", { XX } },
6404 { "(bad)", { XX } },
6405 { REG_TABLE (REG_XOP_LWPCB) },
6406 { "(bad)", { XX } },
6407 { "(bad)", { XX } },
6408 { "(bad)", { XX } },
6409 { "(bad)", { XX } },
6410 { "(bad)", { XX } },
6412 { "(bad)", { XX } },
6413 { "(bad)", { XX } },
6414 { "(bad)", { XX } },
6415 { "(bad)", { XX } },
6416 { "(bad)", { XX } },
6417 { "(bad)", { XX } },
6418 { "(bad)", { XX } },
6419 { "(bad)", { XX } },
6421 { "(bad)", { XX } },
6422 { "(bad)", { XX } },
6423 { "(bad)", { XX } },
6424 { "(bad)", { XX } },
6425 { "(bad)", { XX } },
6426 { "(bad)", { XX } },
6427 { "(bad)", { XX } },
6428 { "(bad)", { XX } },
6430 { "(bad)", { XX } },
6431 { "(bad)", { XX } },
6432 { "(bad)", { XX } },
6433 { "(bad)", { XX } },
6434 { "(bad)", { XX } },
6435 { "(bad)", { XX } },
6436 { "(bad)", { XX } },
6437 { "(bad)", { XX } },
6439 { "(bad)", { XX } },
6440 { "(bad)", { XX } },
6441 { "(bad)", { XX } },
6442 { "(bad)", { XX } },
6443 { "(bad)", { XX } },
6444 { "(bad)", { XX } },
6445 { "(bad)", { XX } },
6446 { "(bad)", { XX } },
6448 { "(bad)", { XX } },
6449 { "(bad)", { XX } },
6450 { "(bad)", { XX } },
6451 { "(bad)", { XX } },
6452 { "(bad)", { XX } },
6453 { "(bad)", { XX } },
6454 { "(bad)", { XX } },
6455 { "(bad)", { XX } },
6457 { "(bad)", { XX } },
6458 { "(bad)", { XX } },
6459 { "(bad)", { XX } },
6460 { "(bad)", { XX } },
6461 { "(bad)", { XX } },
6462 { "(bad)", { XX } },
6463 { "(bad)", { XX } },
6464 { "(bad)", { XX } },
6466 { "(bad)", { XX } },
6467 { "(bad)", { XX } },
6468 { "(bad)", { XX } },
6469 { "(bad)", { XX } },
6470 { "(bad)", { XX } },
6471 { "(bad)", { XX } },
6472 { "(bad)", { XX } },
6473 { "(bad)", { XX } },
6475 { "(bad)", { XX } },
6476 { "(bad)", { XX } },
6477 { "(bad)", { XX } },
6478 { "(bad)", { XX } },
6479 { "(bad)", { XX } },
6480 { "(bad)", { XX } },
6481 { "(bad)", { XX } },
6482 { "(bad)", { XX } },
6484 { "(bad)", { XX } },
6485 { "(bad)", { XX } },
6486 { "(bad)", { XX } },
6487 { "(bad)", { XX } },
6488 { "(bad)", { XX } },
6489 { "(bad)", { XX } },
6490 { "(bad)", { XX } },
6491 { "(bad)", { XX } },
6493 { "(bad)", { XX } },
6494 { "(bad)", { XX } },
6495 { "(bad)", { XX } },
6496 { "(bad)", { XX } },
6497 { "(bad)", { XX } },
6498 { "(bad)", { XX } },
6499 { "(bad)", { XX } },
6500 { "(bad)", { XX } },
6502 { "(bad)", { XX } },
6503 { "(bad)", { XX } },
6504 { "(bad)", { XX } },
6505 { "(bad)", { XX } },
6506 { "(bad)", { XX } },
6507 { "(bad)", { XX } },
6508 { "(bad)", { XX } },
6509 { "(bad)", { XX } },
6511 { "(bad)", { XX } },
6512 { "(bad)", { XX } },
6513 { "(bad)", { XX } },
6514 { "(bad)", { XX } },
6515 { "(bad)", { XX } },
6516 { "(bad)", { XX } },
6517 { "(bad)", { XX } },
6518 { "(bad)", { XX } },
6520 { "(bad)", { XX } },
6521 { "(bad)", { XX } },
6522 { "(bad)", { XX } },
6523 { "(bad)", { XX } },
6524 { "(bad)", { XX } },
6525 { "(bad)", { XX } },
6526 { "(bad)", { XX } },
6527 { "(bad)", { XX } },
6529 { "(bad)", { XX } },
6530 { "(bad)", { XX } },
6531 { "(bad)", { XX } },
6532 { "(bad)", { XX } },
6533 { "(bad)", { XX } },
6534 { "(bad)", { XX } },
6535 { "(bad)", { XX } },
6536 { "(bad)", { XX } },
6538 { "(bad)", { XX } },
6539 { "(bad)", { XX } },
6540 { "(bad)", { XX } },
6541 { "(bad)", { XX } },
6542 { "(bad)", { XX } },
6543 { "(bad)", { XX } },
6544 { "(bad)", { XX } },
6545 { "(bad)", { XX } },
6547 { "(bad)", { XX } },
6548 { "(bad)", { XX } },
6549 { "(bad)", { XX } },
6550 { "(bad)", { XX } },
6551 { "(bad)", { XX } },
6552 { "(bad)", { XX } },
6553 { "(bad)", { XX } },
6554 { "(bad)", { XX } },
6556 { "(bad)", { XX } },
6557 { "(bad)", { XX } },
6558 { "(bad)", { XX } },
6559 { "(bad)", { XX } },
6560 { "(bad)", { XX } },
6561 { "(bad)", { XX } },
6562 { "(bad)", { XX } },
6563 { "(bad)", { XX } },
6565 { "(bad)", { XX } },
6566 { "(bad)", { XX } },
6567 { "(bad)", { XX } },
6568 { "(bad)", { XX } },
6569 { "(bad)", { XX } },
6570 { "(bad)", { XX } },
6571 { "(bad)", { XX } },
6572 { "(bad)", { XX } },
6574 { "(bad)", { XX } },
6575 { "(bad)", { XX } },
6576 { "(bad)", { XX } },
6577 { "(bad)", { XX } },
6578 { "(bad)", { XX } },
6579 { "(bad)", { XX } },
6580 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6583 { "(bad)", { XX } },
6584 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6589 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6593 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6598 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6601 { "(bad)", { XX } },
6602 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6607 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6611 { "(bad)", { XX } },
6612 { "(bad)", { XX } },
6613 { "(bad)", { XX } },
6614 { "(bad)", { XX } },
6615 { "(bad)", { XX } },
6616 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6620 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6625 { "(bad)", { XX } },
6626 { "(bad)", { XX } },
6628 { "(bad)", { XX } },
6629 { "(bad)", { XX } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6634 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6638 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6643 { "(bad)", { XX } },
6644 { "(bad)", { XX } },
6646 { "(bad)", { XX } },
6647 { "(bad)", { XX } },
6648 { "(bad)", { XX } },
6649 { "(bad)", { XX } },
6650 { "(bad)", { XX } },
6651 { "(bad)", { XX } },
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6656 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6658 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6660 { "(bad)", { XX } },
6661 { "(bad)", { XX } },
6662 { "(bad)", { XX } },
6664 { "(bad)", { XX } },
6665 { "(bad)", { XX } },
6666 { "(bad)", { XX } },
6667 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6669 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6676 { "(bad)", { XX } },
6677 { "(bad)", { XX } },
6678 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6683 { "(bad)", { XX } },
6685 { "(bad)", { XX } },
6686 { "(bad)", { XX } },
6687 { "(bad)", { XX } },
6688 { "(bad)", { XX } },
6689 { "(bad)", { XX } },
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6694 { "(bad)", { XX } },
6695 { "(bad)", { XX } },
6696 { REG_TABLE (REG_XOP_LWP) },
6697 { "(bad)", { XX } },
6698 { "(bad)", { XX } },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6703 { "(bad)", { XX } },
6704 { "(bad)", { XX } },
6705 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6707 { "(bad)", { XX } },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6712 { "(bad)", { XX } },
6713 { "(bad)", { XX } },
6714 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6716 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6721 { "(bad)", { XX } },
6722 { "(bad)", { XX } },
6723 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6725 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6730 { "(bad)", { XX } },
6731 { "(bad)", { XX } },
6732 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6734 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6739 { "(bad)", { XX } },
6740 { "(bad)", { XX } },
6741 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6743 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6748 { "(bad)", { XX } },
6749 { "(bad)", { XX } },
6750 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6752 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6757 { "(bad)", { XX } },
6758 { "(bad)", { XX } },
6759 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6761 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6766 { "(bad)", { XX } },
6767 { "(bad)", { XX } },
6768 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6770 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6775 { "(bad)", { XX } },
6776 { "(bad)", { XX } },
6777 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6779 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6784 { "(bad)", { XX } },
6785 { "(bad)", { XX } },
6786 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6788 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6793 { "(bad)", { XX } },
6794 { "(bad)", { XX } },
6795 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6797 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "(bad)", { XX } },
6800 { "(bad)", { XX } },
6802 { "(bad)", { XX } },
6803 { "(bad)", { XX } },
6804 { "(bad)", { XX } },
6805 { "(bad)", { XX } },
6806 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "(bad)", { XX } },
6811 { "(bad)", { XX } },
6812 { "(bad)", { XX } },
6813 { "(bad)", { XX } },
6814 { "(bad)", { XX } },
6815 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "(bad)", { XX } },
6818 { "(bad)", { XX } },
6820 { "(bad)", { XX } },
6821 { "(bad)", { XX } },
6822 { "(bad)", { XX } },
6823 { "(bad)", { XX } },
6824 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "(bad)", { XX } },
6829 { "(bad)", { XX } },
6830 { "(bad)", { XX } },
6831 { "(bad)", { XX } },
6832 { "(bad)", { XX } },
6833 { "(bad)", { XX } },
6834 { "(bad)", { XX } },
6835 { "(bad)", { XX } },
6836 { "(bad)", { XX } },
6838 { "(bad)", { XX } },
6839 { "(bad)", { XX } },
6840 { "(bad)", { XX } },
6841 { "(bad)", { XX } },
6842 { "(bad)", { XX } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6847 { "(bad)", { XX } },
6848 { "(bad)", { XX } },
6849 { "(bad)", { XX } },
6850 { "(bad)", { XX } },
6851 { "(bad)", { XX } },
6852 { "(bad)", { XX } },
6853 { "(bad)", { XX } },
6854 { "(bad)", { XX } },
6856 { "(bad)", { XX } },
6857 { "(bad)", { XX } },
6858 { "(bad)", { XX } },
6859 { "(bad)", { XX } },
6860 { "(bad)", { XX } },
6861 { "(bad)", { XX } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6865 { "(bad)", { XX } },
6866 { "(bad)", { XX } },
6867 { "(bad)", { XX } },
6868 { "(bad)", { XX } },
6869 { "(bad)", { XX } },
6870 { "(bad)", { XX } },
6871 { "(bad)", { XX } },
6872 { "(bad)", { XX } },
6874 { "(bad)", { XX } },
6875 { "(bad)", { XX } },
6876 { "(bad)", { XX } },
6877 { "(bad)", { XX } },
6878 { "(bad)", { XX } },
6879 { "(bad)", { XX } },
6880 { "(bad)", { XX } },
6881 { "(bad)", { XX } },
6883 { "(bad)", { XX } },
6884 { "(bad)", { XX } },
6885 { "(bad)", { XX } },
6886 { "(bad)", { XX } },
6887 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6892 { "(bad)", { XX } },
6893 { "(bad)", { XX } },
6894 { "(bad)", { XX } },
6895 { "(bad)", { XX } },
6896 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6901 { "(bad)", { XX } },
6902 { "(bad)", { XX } },
6903 { "(bad)", { XX } },
6904 { "(bad)", { XX } },
6905 { "(bad)", { XX } },
6906 { "(bad)", { XX } },
6907 { "(bad)", { XX } },
6908 { "(bad)", { XX } },
6910 { "(bad)", { XX } },
6911 { "(bad)", { XX } },
6912 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6914 { "(bad)", { XX } },
6915 { "(bad)", { XX } },
6916 { "(bad)", { XX } },
6917 { "(bad)", { XX } },
6919 { "(bad)", { XX } },
6920 { "(bad)", { XX } },
6921 { "(bad)", { XX } },
6922 { "(bad)", { XX } },
6923 { "(bad)", { XX } },
6924 { "(bad)", { XX } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6928 { "(bad)", { XX } },
6929 { "(bad)", { XX } },
6930 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6932 { "(bad)", { XX } },
6933 { "(bad)", { XX } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6937 { "(bad)", { XX } },
6938 { "(bad)", { XX } },
6939 { "(bad)", { XX } },
6940 { "(bad)", { XX } },
6941 { "(bad)", { XX } },
6942 { "(bad)", { XX } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6947 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6949 { "(bad)", { XX } },
6950 { "(bad)", { XX } },
6951 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6955 { "(bad)", { XX } },
6956 { "(bad)", { XX } },
6957 { "(bad)", { XX } },
6958 { "(bad)", { XX } },
6959 { "(bad)", { XX } },
6960 { "(bad)", { XX } },
6961 { "(bad)", { XX } },
6962 { "(bad)", { XX } },
6966 static const struct dis386 vex_table[][256] = {
6970 { "(bad)", { XX } },
6971 { "(bad)", { XX } },
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6974 { "(bad)", { XX } },
6975 { "(bad)", { XX } },
6976 { "(bad)", { XX } },
6977 { "(bad)", { XX } },
6979 { "(bad)", { XX } },
6980 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6985 { "(bad)", { XX } },
6986 { "(bad)", { XX } },
6988 { PREFIX_TABLE (PREFIX_VEX_10) },
6989 { PREFIX_TABLE (PREFIX_VEX_11) },
6990 { PREFIX_TABLE (PREFIX_VEX_12) },
6991 { MOD_TABLE (MOD_VEX_13) },
6992 { "vunpcklpX", { XM, Vex, EXx } },
6993 { "vunpckhpX", { XM, Vex, EXx } },
6994 { PREFIX_TABLE (PREFIX_VEX_16) },
6995 { MOD_TABLE (MOD_VEX_17) },
6997 { "(bad)", { XX } },
6998 { "(bad)", { XX } },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { "(bad)", { XX } },
7002 { "(bad)", { XX } },
7003 { "(bad)", { XX } },
7004 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7007 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7012 { "(bad)", { XX } },
7013 { "(bad)", { XX } },
7015 { "vmovapX", { XM, EXx } },
7016 { "vmovapX", { EXxS, XM } },
7017 { PREFIX_TABLE (PREFIX_VEX_2A) },
7018 { MOD_TABLE (MOD_VEX_2B) },
7019 { PREFIX_TABLE (PREFIX_VEX_2C) },
7020 { PREFIX_TABLE (PREFIX_VEX_2D) },
7021 { PREFIX_TABLE (PREFIX_VEX_2E) },
7022 { PREFIX_TABLE (PREFIX_VEX_2F) },
7024 { "(bad)", { XX } },
7025 { "(bad)", { XX } },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7030 { "(bad)", { XX } },
7031 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7034 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7039 { "(bad)", { XX } },
7040 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7043 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7048 { "(bad)", { XX } },
7049 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7052 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7057 { "(bad)", { XX } },
7058 { "(bad)", { XX } },
7060 { MOD_TABLE (MOD_VEX_51) },
7061 { PREFIX_TABLE (PREFIX_VEX_51) },
7062 { PREFIX_TABLE (PREFIX_VEX_52) },
7063 { PREFIX_TABLE (PREFIX_VEX_53) },
7064 { "vandpX", { XM, Vex, EXx } },
7065 { "vandnpX", { XM, Vex, EXx } },
7066 { "vorpX", { XM, Vex, EXx } },
7067 { "vxorpX", { XM, Vex, EXx } },
7069 { PREFIX_TABLE (PREFIX_VEX_58) },
7070 { PREFIX_TABLE (PREFIX_VEX_59) },
7071 { PREFIX_TABLE (PREFIX_VEX_5A) },
7072 { PREFIX_TABLE (PREFIX_VEX_5B) },
7073 { PREFIX_TABLE (PREFIX_VEX_5C) },
7074 { PREFIX_TABLE (PREFIX_VEX_5D) },
7075 { PREFIX_TABLE (PREFIX_VEX_5E) },
7076 { PREFIX_TABLE (PREFIX_VEX_5F) },
7078 { PREFIX_TABLE (PREFIX_VEX_60) },
7079 { PREFIX_TABLE (PREFIX_VEX_61) },
7080 { PREFIX_TABLE (PREFIX_VEX_62) },
7081 { PREFIX_TABLE (PREFIX_VEX_63) },
7082 { PREFIX_TABLE (PREFIX_VEX_64) },
7083 { PREFIX_TABLE (PREFIX_VEX_65) },
7084 { PREFIX_TABLE (PREFIX_VEX_66) },
7085 { PREFIX_TABLE (PREFIX_VEX_67) },
7087 { PREFIX_TABLE (PREFIX_VEX_68) },
7088 { PREFIX_TABLE (PREFIX_VEX_69) },
7089 { PREFIX_TABLE (PREFIX_VEX_6A) },
7090 { PREFIX_TABLE (PREFIX_VEX_6B) },
7091 { PREFIX_TABLE (PREFIX_VEX_6C) },
7092 { PREFIX_TABLE (PREFIX_VEX_6D) },
7093 { PREFIX_TABLE (PREFIX_VEX_6E) },
7094 { PREFIX_TABLE (PREFIX_VEX_6F) },
7096 { PREFIX_TABLE (PREFIX_VEX_70) },
7097 { REG_TABLE (REG_VEX_71) },
7098 { REG_TABLE (REG_VEX_72) },
7099 { REG_TABLE (REG_VEX_73) },
7100 { PREFIX_TABLE (PREFIX_VEX_74) },
7101 { PREFIX_TABLE (PREFIX_VEX_75) },
7102 { PREFIX_TABLE (PREFIX_VEX_76) },
7103 { PREFIX_TABLE (PREFIX_VEX_77) },
7105 { "(bad)", { XX } },
7106 { "(bad)", { XX } },
7107 { "(bad)", { XX } },
7108 { "(bad)", { XX } },
7109 { PREFIX_TABLE (PREFIX_VEX_7C) },
7110 { PREFIX_TABLE (PREFIX_VEX_7D) },
7111 { PREFIX_TABLE (PREFIX_VEX_7E) },
7112 { PREFIX_TABLE (PREFIX_VEX_7F) },
7114 { "(bad)", { XX } },
7115 { "(bad)", { XX } },
7116 { "(bad)", { XX } },
7117 { "(bad)", { XX } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7120 { "(bad)", { XX } },
7121 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7124 { "(bad)", { XX } },
7125 { "(bad)", { XX } },
7126 { "(bad)", { XX } },
7127 { "(bad)", { XX } },
7128 { "(bad)", { XX } },
7129 { "(bad)", { XX } },
7130 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7133 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7138 { "(bad)", { XX } },
7139 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7142 { "(bad)", { XX } },
7143 { "(bad)", { XX } },
7144 { "(bad)", { XX } },
7145 { "(bad)", { XX } },
7146 { "(bad)", { XX } },
7147 { "(bad)", { XX } },
7148 { "(bad)", { XX } },
7150 { "(bad)", { XX } },
7151 { "(bad)", { XX } },
7152 { "(bad)", { XX } },
7153 { "(bad)", { XX } },
7154 { "(bad)", { XX } },
7155 { "(bad)", { XX } },
7156 { "(bad)", { XX } },
7157 { "(bad)", { XX } },
7159 { "(bad)", { XX } },
7160 { "(bad)", { XX } },
7161 { "(bad)", { XX } },
7162 { "(bad)", { XX } },
7163 { "(bad)", { XX } },
7164 { "(bad)", { XX } },
7165 { REG_TABLE (REG_VEX_AE) },
7166 { "(bad)", { XX } },
7168 { "(bad)", { XX } },
7169 { "(bad)", { XX } },
7170 { "(bad)", { XX } },
7171 { "(bad)", { XX } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7174 { "(bad)", { XX } },
7175 { "(bad)", { XX } },
7177 { "(bad)", { XX } },
7178 { "(bad)", { XX } },
7179 { "(bad)", { XX } },
7180 { "(bad)", { XX } },
7181 { "(bad)", { XX } },
7182 { "(bad)", { XX } },
7183 { "(bad)", { XX } },
7184 { "(bad)", { XX } },
7186 { "(bad)", { XX } },
7187 { "(bad)", { XX } },
7188 { PREFIX_TABLE (PREFIX_VEX_C2) },
7189 { "(bad)", { XX } },
7190 { PREFIX_TABLE (PREFIX_VEX_C4) },
7191 { PREFIX_TABLE (PREFIX_VEX_C5) },
7192 { "vshufpX", { XM, Vex, EXx, Ib } },
7193 { "(bad)", { XX } },
7195 { "(bad)", { XX } },
7196 { "(bad)", { XX } },
7197 { "(bad)", { XX } },
7198 { "(bad)", { XX } },
7199 { "(bad)", { XX } },
7200 { "(bad)", { XX } },
7201 { "(bad)", { XX } },
7202 { "(bad)", { XX } },
7204 { PREFIX_TABLE (PREFIX_VEX_D0) },
7205 { PREFIX_TABLE (PREFIX_VEX_D1) },
7206 { PREFIX_TABLE (PREFIX_VEX_D2) },
7207 { PREFIX_TABLE (PREFIX_VEX_D3) },
7208 { PREFIX_TABLE (PREFIX_VEX_D4) },
7209 { PREFIX_TABLE (PREFIX_VEX_D5) },
7210 { PREFIX_TABLE (PREFIX_VEX_D6) },
7211 { PREFIX_TABLE (PREFIX_VEX_D7) },
7213 { PREFIX_TABLE (PREFIX_VEX_D8) },
7214 { PREFIX_TABLE (PREFIX_VEX_D9) },
7215 { PREFIX_TABLE (PREFIX_VEX_DA) },
7216 { PREFIX_TABLE (PREFIX_VEX_DB) },
7217 { PREFIX_TABLE (PREFIX_VEX_DC) },
7218 { PREFIX_TABLE (PREFIX_VEX_DD) },
7219 { PREFIX_TABLE (PREFIX_VEX_DE) },
7220 { PREFIX_TABLE (PREFIX_VEX_DF) },
7222 { PREFIX_TABLE (PREFIX_VEX_E0) },
7223 { PREFIX_TABLE (PREFIX_VEX_E1) },
7224 { PREFIX_TABLE (PREFIX_VEX_E2) },
7225 { PREFIX_TABLE (PREFIX_VEX_E3) },
7226 { PREFIX_TABLE (PREFIX_VEX_E4) },
7227 { PREFIX_TABLE (PREFIX_VEX_E5) },
7228 { PREFIX_TABLE (PREFIX_VEX_E6) },
7229 { PREFIX_TABLE (PREFIX_VEX_E7) },
7231 { PREFIX_TABLE (PREFIX_VEX_E8) },
7232 { PREFIX_TABLE (PREFIX_VEX_E9) },
7233 { PREFIX_TABLE (PREFIX_VEX_EA) },
7234 { PREFIX_TABLE (PREFIX_VEX_EB) },
7235 { PREFIX_TABLE (PREFIX_VEX_EC) },
7236 { PREFIX_TABLE (PREFIX_VEX_ED) },
7237 { PREFIX_TABLE (PREFIX_VEX_EE) },
7238 { PREFIX_TABLE (PREFIX_VEX_EF) },
7240 { PREFIX_TABLE (PREFIX_VEX_F0) },
7241 { PREFIX_TABLE (PREFIX_VEX_F1) },
7242 { PREFIX_TABLE (PREFIX_VEX_F2) },
7243 { PREFIX_TABLE (PREFIX_VEX_F3) },
7244 { PREFIX_TABLE (PREFIX_VEX_F4) },
7245 { PREFIX_TABLE (PREFIX_VEX_F5) },
7246 { PREFIX_TABLE (PREFIX_VEX_F6) },
7247 { PREFIX_TABLE (PREFIX_VEX_F7) },
7249 { PREFIX_TABLE (PREFIX_VEX_F8) },
7250 { PREFIX_TABLE (PREFIX_VEX_F9) },
7251 { PREFIX_TABLE (PREFIX_VEX_FA) },
7252 { PREFIX_TABLE (PREFIX_VEX_FB) },
7253 { PREFIX_TABLE (PREFIX_VEX_FC) },
7254 { PREFIX_TABLE (PREFIX_VEX_FD) },
7255 { PREFIX_TABLE (PREFIX_VEX_FE) },
7256 { "(bad)", { XX } },
7261 { PREFIX_TABLE (PREFIX_VEX_3800) },
7262 { PREFIX_TABLE (PREFIX_VEX_3801) },
7263 { PREFIX_TABLE (PREFIX_VEX_3802) },
7264 { PREFIX_TABLE (PREFIX_VEX_3803) },
7265 { PREFIX_TABLE (PREFIX_VEX_3804) },
7266 { PREFIX_TABLE (PREFIX_VEX_3805) },
7267 { PREFIX_TABLE (PREFIX_VEX_3806) },
7268 { PREFIX_TABLE (PREFIX_VEX_3807) },
7270 { PREFIX_TABLE (PREFIX_VEX_3808) },
7271 { PREFIX_TABLE (PREFIX_VEX_3809) },
7272 { PREFIX_TABLE (PREFIX_VEX_380A) },
7273 { PREFIX_TABLE (PREFIX_VEX_380B) },
7274 { PREFIX_TABLE (PREFIX_VEX_380C) },
7275 { PREFIX_TABLE (PREFIX_VEX_380D) },
7276 { PREFIX_TABLE (PREFIX_VEX_380E) },
7277 { PREFIX_TABLE (PREFIX_VEX_380F) },
7279 { "(bad)", { XX } },
7280 { "(bad)", { XX } },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7285 { "(bad)", { XX } },
7286 { PREFIX_TABLE (PREFIX_VEX_3817) },
7288 { PREFIX_TABLE (PREFIX_VEX_3818) },
7289 { PREFIX_TABLE (PREFIX_VEX_3819) },
7290 { PREFIX_TABLE (PREFIX_VEX_381A) },
7291 { "(bad)", { XX } },
7292 { PREFIX_TABLE (PREFIX_VEX_381C) },
7293 { PREFIX_TABLE (PREFIX_VEX_381D) },
7294 { PREFIX_TABLE (PREFIX_VEX_381E) },
7295 { "(bad)", { XX } },
7297 { PREFIX_TABLE (PREFIX_VEX_3820) },
7298 { PREFIX_TABLE (PREFIX_VEX_3821) },
7299 { PREFIX_TABLE (PREFIX_VEX_3822) },
7300 { PREFIX_TABLE (PREFIX_VEX_3823) },
7301 { PREFIX_TABLE (PREFIX_VEX_3824) },
7302 { PREFIX_TABLE (PREFIX_VEX_3825) },
7303 { "(bad)", { XX } },
7304 { "(bad)", { XX } },
7306 { PREFIX_TABLE (PREFIX_VEX_3828) },
7307 { PREFIX_TABLE (PREFIX_VEX_3829) },
7308 { PREFIX_TABLE (PREFIX_VEX_382A) },
7309 { PREFIX_TABLE (PREFIX_VEX_382B) },
7310 { PREFIX_TABLE (PREFIX_VEX_382C) },
7311 { PREFIX_TABLE (PREFIX_VEX_382D) },
7312 { PREFIX_TABLE (PREFIX_VEX_382E) },
7313 { PREFIX_TABLE (PREFIX_VEX_382F) },
7315 { PREFIX_TABLE (PREFIX_VEX_3830) },
7316 { PREFIX_TABLE (PREFIX_VEX_3831) },
7317 { PREFIX_TABLE (PREFIX_VEX_3832) },
7318 { PREFIX_TABLE (PREFIX_VEX_3833) },
7319 { PREFIX_TABLE (PREFIX_VEX_3834) },
7320 { PREFIX_TABLE (PREFIX_VEX_3835) },
7321 { "(bad)", { XX } },
7322 { PREFIX_TABLE (PREFIX_VEX_3837) },
7324 { PREFIX_TABLE (PREFIX_VEX_3838) },
7325 { PREFIX_TABLE (PREFIX_VEX_3839) },
7326 { PREFIX_TABLE (PREFIX_VEX_383A) },
7327 { PREFIX_TABLE (PREFIX_VEX_383B) },
7328 { PREFIX_TABLE (PREFIX_VEX_383C) },
7329 { PREFIX_TABLE (PREFIX_VEX_383D) },
7330 { PREFIX_TABLE (PREFIX_VEX_383E) },
7331 { PREFIX_TABLE (PREFIX_VEX_383F) },
7333 { PREFIX_TABLE (PREFIX_VEX_3840) },
7334 { PREFIX_TABLE (PREFIX_VEX_3841) },
7335 { "(bad)", { XX } },
7336 { "(bad)", { XX } },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7339 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7343 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7348 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7352 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7357 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7361 { "(bad)", { XX } },
7362 { "(bad)", { XX } },
7363 { "(bad)", { XX } },
7364 { "(bad)", { XX } },
7365 { "(bad)", { XX } },
7366 { "(bad)", { XX } },
7367 { "(bad)", { XX } },
7369 { "(bad)", { XX } },
7370 { "(bad)", { XX } },
7371 { "(bad)", { XX } },
7372 { "(bad)", { XX } },
7373 { "(bad)", { XX } },
7374 { "(bad)", { XX } },
7375 { "(bad)", { XX } },
7376 { "(bad)", { XX } },
7378 { "(bad)", { XX } },
7379 { "(bad)", { XX } },
7380 { "(bad)", { XX } },
7381 { "(bad)", { XX } },
7382 { "(bad)", { XX } },
7383 { "(bad)", { XX } },
7384 { "(bad)", { XX } },
7385 { "(bad)", { XX } },
7387 { "(bad)", { XX } },
7388 { "(bad)", { XX } },
7389 { "(bad)", { XX } },
7390 { "(bad)", { XX } },
7391 { "(bad)", { XX } },
7392 { "(bad)", { XX } },
7393 { "(bad)", { XX } },
7394 { "(bad)", { XX } },
7396 { "(bad)", { XX } },
7397 { "(bad)", { XX } },
7398 { "(bad)", { XX } },
7399 { "(bad)", { XX } },
7400 { "(bad)", { XX } },
7401 { "(bad)", { XX } },
7402 { "(bad)", { XX } },
7403 { "(bad)", { XX } },
7405 { "(bad)", { XX } },
7406 { "(bad)", { XX } },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7411 { "(bad)", { XX } },
7412 { "(bad)", { XX } },
7414 { "(bad)", { XX } },
7415 { "(bad)", { XX } },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7420 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7424 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7429 { PREFIX_TABLE (PREFIX_VEX_3896) },
7430 { PREFIX_TABLE (PREFIX_VEX_3897) },
7432 { PREFIX_TABLE (PREFIX_VEX_3898) },
7433 { PREFIX_TABLE (PREFIX_VEX_3899) },
7434 { PREFIX_TABLE (PREFIX_VEX_389A) },
7435 { PREFIX_TABLE (PREFIX_VEX_389B) },
7436 { PREFIX_TABLE (PREFIX_VEX_389C) },
7437 { PREFIX_TABLE (PREFIX_VEX_389D) },
7438 { PREFIX_TABLE (PREFIX_VEX_389E) },
7439 { PREFIX_TABLE (PREFIX_VEX_389F) },
7441 { "(bad)", { XX } },
7442 { "(bad)", { XX } },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7447 { PREFIX_TABLE (PREFIX_VEX_38A6) },
7448 { PREFIX_TABLE (PREFIX_VEX_38A7) },
7450 { PREFIX_TABLE (PREFIX_VEX_38A8) },
7451 { PREFIX_TABLE (PREFIX_VEX_38A9) },
7452 { PREFIX_TABLE (PREFIX_VEX_38AA) },
7453 { PREFIX_TABLE (PREFIX_VEX_38AB) },
7454 { PREFIX_TABLE (PREFIX_VEX_38AC) },
7455 { PREFIX_TABLE (PREFIX_VEX_38AD) },
7456 { PREFIX_TABLE (PREFIX_VEX_38AE) },
7457 { PREFIX_TABLE (PREFIX_VEX_38AF) },
7459 { "(bad)", { XX } },
7460 { "(bad)", { XX } },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7465 { PREFIX_TABLE (PREFIX_VEX_38B6) },
7466 { PREFIX_TABLE (PREFIX_VEX_38B7) },
7468 { PREFIX_TABLE (PREFIX_VEX_38B8) },
7469 { PREFIX_TABLE (PREFIX_VEX_38B9) },
7470 { PREFIX_TABLE (PREFIX_VEX_38BA) },
7471 { PREFIX_TABLE (PREFIX_VEX_38BB) },
7472 { PREFIX_TABLE (PREFIX_VEX_38BC) },
7473 { PREFIX_TABLE (PREFIX_VEX_38BD) },
7474 { PREFIX_TABLE (PREFIX_VEX_38BE) },
7475 { PREFIX_TABLE (PREFIX_VEX_38BF) },
7477 { "(bad)", { XX } },
7478 { "(bad)", { XX } },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7483 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7487 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { "(bad)", { XX } },
7491 { "(bad)", { XX } },
7492 { "(bad)", { XX } },
7493 { "(bad)", { XX } },
7495 { "(bad)", { XX } },
7496 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7501 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7505 { "(bad)", { XX } },
7506 { "(bad)", { XX } },
7507 { PREFIX_TABLE (PREFIX_VEX_38DB) },
7508 { PREFIX_TABLE (PREFIX_VEX_38DC) },
7509 { PREFIX_TABLE (PREFIX_VEX_38DD) },
7510 { PREFIX_TABLE (PREFIX_VEX_38DE) },
7511 { PREFIX_TABLE (PREFIX_VEX_38DF) },
7513 { "(bad)", { XX } },
7514 { "(bad)", { XX } },
7515 { "(bad)", { XX } },
7516 { "(bad)", { XX } },
7517 { "(bad)", { XX } },
7518 { "(bad)", { XX } },
7519 { "(bad)", { XX } },
7520 { "(bad)", { XX } },
7522 { "(bad)", { XX } },
7523 { "(bad)", { XX } },
7524 { "(bad)", { XX } },
7525 { "(bad)", { XX } },
7526 { "(bad)", { XX } },
7527 { "(bad)", { XX } },
7528 { "(bad)", { XX } },
7529 { "(bad)", { XX } },
7531 { "(bad)", { XX } },
7532 { "(bad)", { XX } },
7533 { "(bad)", { XX } },
7534 { "(bad)", { XX } },
7535 { "(bad)", { XX } },
7536 { "(bad)", { XX } },
7537 { "(bad)", { XX } },
7538 { "(bad)", { XX } },
7540 { "(bad)", { XX } },
7541 { "(bad)", { XX } },
7542 { "(bad)", { XX } },
7543 { "(bad)", { XX } },
7544 { "(bad)", { XX } },
7545 { "(bad)", { XX } },
7546 { "(bad)", { XX } },
7547 { "(bad)", { XX } },
7552 { "(bad)", { XX } },
7553 { "(bad)", { XX } },
7554 { "(bad)", { XX } },
7555 { "(bad)", { XX } },
7556 { PREFIX_TABLE (PREFIX_VEX_3A04) },
7557 { PREFIX_TABLE (PREFIX_VEX_3A05) },
7558 { PREFIX_TABLE (PREFIX_VEX_3A06) },
7559 { "(bad)", { XX } },
7561 { PREFIX_TABLE (PREFIX_VEX_3A08) },
7562 { PREFIX_TABLE (PREFIX_VEX_3A09) },
7563 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
7564 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
7565 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
7566 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
7567 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
7568 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
7570 { "(bad)", { XX } },
7571 { "(bad)", { XX } },
7572 { "(bad)", { XX } },
7573 { "(bad)", { XX } },
7574 { PREFIX_TABLE (PREFIX_VEX_3A14) },
7575 { PREFIX_TABLE (PREFIX_VEX_3A15) },
7576 { PREFIX_TABLE (PREFIX_VEX_3A16) },
7577 { PREFIX_TABLE (PREFIX_VEX_3A17) },
7579 { PREFIX_TABLE (PREFIX_VEX_3A18) },
7580 { PREFIX_TABLE (PREFIX_VEX_3A19) },
7581 { "(bad)", { XX } },
7582 { "(bad)", { XX } },
7583 { "(bad)", { XX } },
7584 { "(bad)", { XX } },
7585 { "(bad)", { XX } },
7586 { "(bad)", { XX } },
7588 { PREFIX_TABLE (PREFIX_VEX_3A20) },
7589 { PREFIX_TABLE (PREFIX_VEX_3A21) },
7590 { PREFIX_TABLE (PREFIX_VEX_3A22) },
7591 { "(bad)", { XX } },
7592 { "(bad)", { XX } },
7593 { "(bad)", { XX } },
7594 { "(bad)", { XX } },
7595 { "(bad)", { XX } },
7597 { "(bad)", { XX } },
7598 { "(bad)", { XX } },
7599 { "(bad)", { XX } },
7600 { "(bad)", { XX } },
7601 { "(bad)", { XX } },
7602 { "(bad)", { XX } },
7603 { "(bad)", { XX } },
7604 { "(bad)", { XX } },
7606 { "(bad)", { XX } },
7607 { "(bad)", { XX } },
7608 { "(bad)", { XX } },
7609 { "(bad)", { XX } },
7610 { "(bad)", { XX } },
7611 { "(bad)", { XX } },
7612 { "(bad)", { XX } },
7613 { "(bad)", { XX } },
7615 { "(bad)", { XX } },
7616 { "(bad)", { XX } },
7617 { "(bad)", { XX } },
7618 { "(bad)", { XX } },
7619 { "(bad)", { XX } },
7620 { "(bad)", { XX } },
7621 { "(bad)", { XX } },
7622 { "(bad)", { XX } },
7624 { PREFIX_TABLE (PREFIX_VEX_3A40) },
7625 { PREFIX_TABLE (PREFIX_VEX_3A41) },
7626 { PREFIX_TABLE (PREFIX_VEX_3A42) },
7627 { "(bad)", { XX } },
7628 { PREFIX_TABLE (PREFIX_VEX_3A44) },
7629 { "(bad)", { XX } },
7630 { "(bad)", { XX } },
7631 { "(bad)", { XX } },
7633 { "(bad)", { XX } },
7634 { "(bad)", { XX } },
7635 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
7636 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
7637 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
7638 { "(bad)", { XX } },
7639 { "(bad)", { XX } },
7640 { "(bad)", { XX } },
7642 { "(bad)", { XX } },
7643 { "(bad)", { XX } },
7644 { "(bad)", { XX } },
7645 { "(bad)", { XX } },
7646 { "(bad)", { XX } },
7647 { "(bad)", { XX } },
7648 { "(bad)", { XX } },
7649 { "(bad)", { XX } },
7651 { "(bad)", { XX } },
7652 { "(bad)", { XX } },
7653 { "(bad)", { XX } },
7654 { "(bad)", { XX } },
7655 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
7656 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
7657 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
7658 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
7660 { PREFIX_TABLE (PREFIX_VEX_3A60) },
7661 { PREFIX_TABLE (PREFIX_VEX_3A61) },
7662 { PREFIX_TABLE (PREFIX_VEX_3A62) },
7663 { PREFIX_TABLE (PREFIX_VEX_3A63) },
7664 { "(bad)", { XX } },
7665 { "(bad)", { XX } },
7666 { "(bad)", { XX } },
7667 { "(bad)", { XX } },
7669 { PREFIX_TABLE (PREFIX_VEX_3A68) },
7670 { PREFIX_TABLE (PREFIX_VEX_3A69) },
7671 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
7672 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
7673 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
7674 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
7675 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
7676 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
7678 { "(bad)", { XX } },
7679 { "(bad)", { XX } },
7680 { "(bad)", { XX } },
7681 { "(bad)", { XX } },
7682 { "(bad)", { XX } },
7683 { "(bad)", { XX } },
7684 { "(bad)", { XX } },
7685 { "(bad)", { XX } },
7687 { PREFIX_TABLE (PREFIX_VEX_3A78) },
7688 { PREFIX_TABLE (PREFIX_VEX_3A79) },
7689 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
7690 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
7691 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
7692 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
7693 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
7694 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
7696 { "(bad)", { XX } },
7697 { "(bad)", { XX } },
7698 { "(bad)", { XX } },
7699 { "(bad)", { XX } },
7700 { "(bad)", { XX } },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7705 { "(bad)", { XX } },
7706 { "(bad)", { XX } },
7707 { "(bad)", { XX } },
7708 { "(bad)", { XX } },
7709 { "(bad)", { XX } },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7714 { "(bad)", { XX } },
7715 { "(bad)", { XX } },
7716 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7718 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { "(bad)", { XX } },
7723 { "(bad)", { XX } },
7724 { "(bad)", { XX } },
7725 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7727 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7732 { "(bad)", { XX } },
7733 { "(bad)", { XX } },
7734 { "(bad)", { XX } },
7735 { "(bad)", { XX } },
7736 { "(bad)", { XX } },
7737 { "(bad)", { XX } },
7738 { "(bad)", { XX } },
7739 { "(bad)", { XX } },
7741 { "(bad)", { XX } },
7742 { "(bad)", { XX } },
7743 { "(bad)", { XX } },
7744 { "(bad)", { XX } },
7745 { "(bad)", { XX } },
7746 { "(bad)", { XX } },
7747 { "(bad)", { XX } },
7748 { "(bad)", { XX } },
7750 { "(bad)", { XX } },
7751 { "(bad)", { XX } },
7752 { "(bad)", { XX } },
7753 { "(bad)", { XX } },
7754 { "(bad)", { XX } },
7755 { "(bad)", { XX } },
7756 { "(bad)", { XX } },
7757 { "(bad)", { XX } },
7759 { "(bad)", { XX } },
7760 { "(bad)", { XX } },
7761 { "(bad)", { XX } },
7762 { "(bad)", { XX } },
7763 { "(bad)", { XX } },
7764 { "(bad)", { XX } },
7765 { "(bad)", { XX } },
7766 { "(bad)", { XX } },
7768 { "(bad)", { XX } },
7769 { "(bad)", { XX } },
7770 { "(bad)", { XX } },
7771 { "(bad)", { XX } },
7772 { "(bad)", { XX } },
7773 { "(bad)", { XX } },
7774 { "(bad)", { XX } },
7775 { "(bad)", { XX } },
7777 { "(bad)", { XX } },
7778 { "(bad)", { XX } },
7779 { "(bad)", { XX } },
7780 { "(bad)", { XX } },
7781 { "(bad)", { XX } },
7782 { "(bad)", { XX } },
7783 { "(bad)", { XX } },
7784 { "(bad)", { XX } },
7786 { "(bad)", { XX } },
7787 { "(bad)", { XX } },
7788 { "(bad)", { XX } },
7789 { "(bad)", { XX } },
7790 { "(bad)", { XX } },
7791 { "(bad)", { XX } },
7792 { "(bad)", { XX } },
7793 { "(bad)", { XX } },
7795 { "(bad)", { XX } },
7796 { "(bad)", { XX } },
7797 { "(bad)", { XX } },
7798 { "(bad)", { XX } },
7799 { "(bad)", { XX } },
7800 { "(bad)", { XX } },
7801 { "(bad)", { XX } },
7802 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
7804 { "(bad)", { XX } },
7805 { "(bad)", { XX } },
7806 { "(bad)", { XX } },
7807 { "(bad)", { XX } },
7808 { "(bad)", { XX } },
7809 { "(bad)", { XX } },
7810 { "(bad)", { XX } },
7811 { "(bad)", { XX } },
7813 { "(bad)", { XX } },
7814 { "(bad)", { XX } },
7815 { "(bad)", { XX } },
7816 { "(bad)", { XX } },
7817 { "(bad)", { XX } },
7818 { "(bad)", { XX } },
7819 { "(bad)", { XX } },
7820 { "(bad)", { XX } },
7822 { "(bad)", { XX } },
7823 { "(bad)", { XX } },
7824 { "(bad)", { XX } },
7825 { "(bad)", { XX } },
7826 { "(bad)", { XX } },
7827 { "(bad)", { XX } },
7828 { "(bad)", { XX } },
7829 { "(bad)", { XX } },
7831 { "(bad)", { XX } },
7832 { "(bad)", { XX } },
7833 { "(bad)", { XX } },
7834 { "(bad)", { XX } },
7835 { "(bad)", { XX } },
7836 { "(bad)", { XX } },
7837 { "(bad)", { XX } },
7838 { "(bad)", { XX } },
7842 static const struct dis386 vex_len_table[][2] = {
7843 /* VEX_LEN_10_P_1 */
7845 { "vmovss", { XMVex, Vex128, EXd } },
7846 { "(bad)", { XX } },
7849 /* VEX_LEN_10_P_3 */
7851 { "vmovsd", { XMVex, Vex128, EXq } },
7852 { "(bad)", { XX } },
7855 /* VEX_LEN_11_P_1 */
7857 { "vmovss", { EXdVexS, Vex128, XM } },
7858 { "(bad)", { XX } },
7861 /* VEX_LEN_11_P_3 */
7863 { "vmovsd", { EXqVexS, Vex128, XM } },
7864 { "(bad)", { XX } },
7867 /* VEX_LEN_12_P_0_M_0 */
7869 { "vmovlps", { XM, Vex128, EXq } },
7870 { "(bad)", { XX } },
7873 /* VEX_LEN_12_P_0_M_1 */
7875 { "vmovhlps", { XM, Vex128, EXq } },
7876 { "(bad)", { XX } },
7879 /* VEX_LEN_12_P_2 */
7881 { "vmovlpd", { XM, Vex128, EXq } },
7882 { "(bad)", { XX } },
7885 /* VEX_LEN_13_M_0 */
7887 { "vmovlpX", { EXq, XM } },
7888 { "(bad)", { XX } },
7891 /* VEX_LEN_16_P_0_M_0 */
7893 { "vmovhps", { XM, Vex128, EXq } },
7894 { "(bad)", { XX } },
7897 /* VEX_LEN_16_P_0_M_1 */
7899 { "vmovlhps", { XM, Vex128, EXq } },
7900 { "(bad)", { XX } },
7903 /* VEX_LEN_16_P_2 */
7905 { "vmovhpd", { XM, Vex128, EXq } },
7906 { "(bad)", { XX } },
7909 /* VEX_LEN_17_M_0 */
7911 { "vmovhpX", { EXq, XM } },
7912 { "(bad)", { XX } },
7915 /* VEX_LEN_2A_P_1 */
7917 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
7918 { "(bad)", { XX } },
7921 /* VEX_LEN_2A_P_3 */
7923 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
7924 { "(bad)", { XX } },
7927 /* VEX_LEN_2C_P_1 */
7929 { "vcvttss2siY", { Gv, EXd } },
7930 { "(bad)", { XX } },
7933 /* VEX_LEN_2C_P_3 */
7935 { "vcvttsd2siY", { Gv, EXq } },
7936 { "(bad)", { XX } },
7939 /* VEX_LEN_2D_P_1 */
7941 { "vcvtss2siY", { Gv, EXd } },
7942 { "(bad)", { XX } },
7945 /* VEX_LEN_2D_P_3 */
7947 { "vcvtsd2siY", { Gv, EXq } },
7948 { "(bad)", { XX } },
7951 /* VEX_LEN_2E_P_0 */
7953 { "vucomiss", { XM, EXd } },
7954 { "(bad)", { XX } },
7957 /* VEX_LEN_2E_P_2 */
7959 { "vucomisd", { XM, EXq } },
7960 { "(bad)", { XX } },
7963 /* VEX_LEN_2F_P_0 */
7965 { "vcomiss", { XM, EXd } },
7966 { "(bad)", { XX } },
7969 /* VEX_LEN_2F_P_2 */
7971 { "vcomisd", { XM, EXq } },
7972 { "(bad)", { XX } },
7975 /* VEX_LEN_51_P_1 */
7977 { "vsqrtss", { XM, Vex128, EXd } },
7978 { "(bad)", { XX } },
7981 /* VEX_LEN_51_P_3 */
7983 { "vsqrtsd", { XM, Vex128, EXq } },
7984 { "(bad)", { XX } },
7987 /* VEX_LEN_52_P_1 */
7989 { "vrsqrtss", { XM, Vex128, EXd } },
7990 { "(bad)", { XX } },
7993 /* VEX_LEN_53_P_1 */
7995 { "vrcpss", { XM, Vex128, EXd } },
7996 { "(bad)", { XX } },
7999 /* VEX_LEN_58_P_1 */
8001 { "vaddss", { XM, Vex128, EXd } },
8002 { "(bad)", { XX } },
8005 /* VEX_LEN_58_P_3 */
8007 { "vaddsd", { XM, Vex128, EXq } },
8008 { "(bad)", { XX } },
8011 /* VEX_LEN_59_P_1 */
8013 { "vmulss", { XM, Vex128, EXd } },
8014 { "(bad)", { XX } },
8017 /* VEX_LEN_59_P_3 */
8019 { "vmulsd", { XM, Vex128, EXq } },
8020 { "(bad)", { XX } },
8023 /* VEX_LEN_5A_P_1 */
8025 { "vcvtss2sd", { XM, Vex128, EXd } },
8026 { "(bad)", { XX } },
8029 /* VEX_LEN_5A_P_3 */
8031 { "vcvtsd2ss", { XM, Vex128, EXq } },
8032 { "(bad)", { XX } },
8035 /* VEX_LEN_5C_P_1 */
8037 { "vsubss", { XM, Vex128, EXd } },
8038 { "(bad)", { XX } },
8041 /* VEX_LEN_5C_P_3 */
8043 { "vsubsd", { XM, Vex128, EXq } },
8044 { "(bad)", { XX } },
8047 /* VEX_LEN_5D_P_1 */
8049 { "vminss", { XM, Vex128, EXd } },
8050 { "(bad)", { XX } },
8053 /* VEX_LEN_5D_P_3 */
8055 { "vminsd", { XM, Vex128, EXq } },
8056 { "(bad)", { XX } },
8059 /* VEX_LEN_5E_P_1 */
8061 { "vdivss", { XM, Vex128, EXd } },
8062 { "(bad)", { XX } },
8065 /* VEX_LEN_5E_P_3 */
8067 { "vdivsd", { XM, Vex128, EXq } },
8068 { "(bad)", { XX } },
8071 /* VEX_LEN_5F_P_1 */
8073 { "vmaxss", { XM, Vex128, EXd } },
8074 { "(bad)", { XX } },
8077 /* VEX_LEN_5F_P_3 */
8079 { "vmaxsd", { XM, Vex128, EXq } },
8080 { "(bad)", { XX } },
8083 /* VEX_LEN_60_P_2 */
8085 { "vpunpcklbw", { XM, Vex128, EXx } },
8086 { "(bad)", { XX } },
8089 /* VEX_LEN_61_P_2 */
8091 { "vpunpcklwd", { XM, Vex128, EXx } },
8092 { "(bad)", { XX } },
8095 /* VEX_LEN_62_P_2 */
8097 { "vpunpckldq", { XM, Vex128, EXx } },
8098 { "(bad)", { XX } },
8101 /* VEX_LEN_63_P_2 */
8103 { "vpacksswb", { XM, Vex128, EXx } },
8104 { "(bad)", { XX } },
8107 /* VEX_LEN_64_P_2 */
8109 { "vpcmpgtb", { XM, Vex128, EXx } },
8110 { "(bad)", { XX } },
8113 /* VEX_LEN_65_P_2 */
8115 { "vpcmpgtw", { XM, Vex128, EXx } },
8116 { "(bad)", { XX } },
8119 /* VEX_LEN_66_P_2 */
8121 { "vpcmpgtd", { XM, Vex128, EXx } },
8122 { "(bad)", { XX } },
8125 /* VEX_LEN_67_P_2 */
8127 { "vpackuswb", { XM, Vex128, EXx } },
8128 { "(bad)", { XX } },
8131 /* VEX_LEN_68_P_2 */
8133 { "vpunpckhbw", { XM, Vex128, EXx } },
8134 { "(bad)", { XX } },
8137 /* VEX_LEN_69_P_2 */
8139 { "vpunpckhwd", { XM, Vex128, EXx } },
8140 { "(bad)", { XX } },
8143 /* VEX_LEN_6A_P_2 */
8145 { "vpunpckhdq", { XM, Vex128, EXx } },
8146 { "(bad)", { XX } },
8149 /* VEX_LEN_6B_P_2 */
8151 { "vpackssdw", { XM, Vex128, EXx } },
8152 { "(bad)", { XX } },
8155 /* VEX_LEN_6C_P_2 */
8157 { "vpunpcklqdq", { XM, Vex128, EXx } },
8158 { "(bad)", { XX } },
8161 /* VEX_LEN_6D_P_2 */
8163 { "vpunpckhqdq", { XM, Vex128, EXx } },
8164 { "(bad)", { XX } },
8167 /* VEX_LEN_6E_P_2 */
8169 { "vmovK", { XM, Edq } },
8170 { "(bad)", { XX } },
8173 /* VEX_LEN_70_P_1 */
8175 { "vpshufhw", { XM, EXx, Ib } },
8176 { "(bad)", { XX } },
8179 /* VEX_LEN_70_P_2 */
8181 { "vpshufd", { XM, EXx, Ib } },
8182 { "(bad)", { XX } },
8185 /* VEX_LEN_70_P_3 */
8187 { "vpshuflw", { XM, EXx, Ib } },
8188 { "(bad)", { XX } },
8191 /* VEX_LEN_71_R_2_P_2 */
8193 { "vpsrlw", { Vex128, XS, Ib } },
8194 { "(bad)", { XX } },
8197 /* VEX_LEN_71_R_4_P_2 */
8199 { "vpsraw", { Vex128, XS, Ib } },
8200 { "(bad)", { XX } },
8203 /* VEX_LEN_71_R_6_P_2 */
8205 { "vpsllw", { Vex128, XS, Ib } },
8206 { "(bad)", { XX } },
8209 /* VEX_LEN_72_R_2_P_2 */
8211 { "vpsrld", { Vex128, XS, Ib } },
8212 { "(bad)", { XX } },
8215 /* VEX_LEN_72_R_4_P_2 */
8217 { "vpsrad", { Vex128, XS, Ib } },
8218 { "(bad)", { XX } },
8221 /* VEX_LEN_72_R_6_P_2 */
8223 { "vpslld", { Vex128, XS, Ib } },
8224 { "(bad)", { XX } },
8227 /* VEX_LEN_73_R_2_P_2 */
8229 { "vpsrlq", { Vex128, XS, Ib } },
8230 { "(bad)", { XX } },
8233 /* VEX_LEN_73_R_3_P_2 */
8235 { "vpsrldq", { Vex128, XS, Ib } },
8236 { "(bad)", { XX } },
8239 /* VEX_LEN_73_R_6_P_2 */
8241 { "vpsllq", { Vex128, XS, Ib } },
8242 { "(bad)", { XX } },
8245 /* VEX_LEN_73_R_7_P_2 */
8247 { "vpslldq", { Vex128, XS, Ib } },
8248 { "(bad)", { XX } },
8251 /* VEX_LEN_74_P_2 */
8253 { "vpcmpeqb", { XM, Vex128, EXx } },
8254 { "(bad)", { XX } },
8257 /* VEX_LEN_75_P_2 */
8259 { "vpcmpeqw", { XM, Vex128, EXx } },
8260 { "(bad)", { XX } },
8263 /* VEX_LEN_76_P_2 */
8265 { "vpcmpeqd", { XM, Vex128, EXx } },
8266 { "(bad)", { XX } },
8269 /* VEX_LEN_7E_P_1 */
8271 { "vmovq", { XM, EXq } },
8272 { "(bad)", { XX } },
8275 /* VEX_LEN_7E_P_2 */
8277 { "vmovK", { Edq, XM } },
8278 { "(bad)", { XX } },
8281 /* VEX_LEN_AE_R_2_M_0 */
8283 { "vldmxcsr", { Md } },
8284 { "(bad)", { XX } },
8287 /* VEX_LEN_AE_R_3_M_0 */
8289 { "vstmxcsr", { Md } },
8290 { "(bad)", { XX } },
8293 /* VEX_LEN_C2_P_1 */
8295 { "vcmpss", { XM, Vex128, EXd, VCMP } },
8296 { "(bad)", { XX } },
8299 /* VEX_LEN_C2_P_3 */
8301 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
8302 { "(bad)", { XX } },
8305 /* VEX_LEN_C4_P_2 */
8307 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
8308 { "(bad)", { XX } },
8311 /* VEX_LEN_C5_P_2 */
8313 { "vpextrw", { Gdq, XS, Ib } },
8314 { "(bad)", { XX } },
8317 /* VEX_LEN_D1_P_2 */
8319 { "vpsrlw", { XM, Vex128, EXx } },
8320 { "(bad)", { XX } },
8323 /* VEX_LEN_D2_P_2 */
8325 { "vpsrld", { XM, Vex128, EXx } },
8326 { "(bad)", { XX } },
8329 /* VEX_LEN_D3_P_2 */
8331 { "vpsrlq", { XM, Vex128, EXx } },
8332 { "(bad)", { XX } },
8335 /* VEX_LEN_D4_P_2 */
8337 { "vpaddq", { XM, Vex128, EXx } },
8338 { "(bad)", { XX } },
8341 /* VEX_LEN_D5_P_2 */
8343 { "vpmullw", { XM, Vex128, EXx } },
8344 { "(bad)", { XX } },
8347 /* VEX_LEN_D6_P_2 */
8349 { "vmovq", { EXqS, XM } },
8350 { "(bad)", { XX } },
8353 /* VEX_LEN_D7_P_2_M_1 */
8355 { "vpmovmskb", { Gdq, XS } },
8356 { "(bad)", { XX } },
8359 /* VEX_LEN_D8_P_2 */
8361 { "vpsubusb", { XM, Vex128, EXx } },
8362 { "(bad)", { XX } },
8365 /* VEX_LEN_D9_P_2 */
8367 { "vpsubusw", { XM, Vex128, EXx } },
8368 { "(bad)", { XX } },
8371 /* VEX_LEN_DA_P_2 */
8373 { "vpminub", { XM, Vex128, EXx } },
8374 { "(bad)", { XX } },
8377 /* VEX_LEN_DB_P_2 */
8379 { "vpand", { XM, Vex128, EXx } },
8380 { "(bad)", { XX } },
8383 /* VEX_LEN_DC_P_2 */
8385 { "vpaddusb", { XM, Vex128, EXx } },
8386 { "(bad)", { XX } },
8389 /* VEX_LEN_DD_P_2 */
8391 { "vpaddusw", { XM, Vex128, EXx } },
8392 { "(bad)", { XX } },
8395 /* VEX_LEN_DE_P_2 */
8397 { "vpmaxub", { XM, Vex128, EXx } },
8398 { "(bad)", { XX } },
8401 /* VEX_LEN_DF_P_2 */
8403 { "vpandn", { XM, Vex128, EXx } },
8404 { "(bad)", { XX } },
8407 /* VEX_LEN_E0_P_2 */
8409 { "vpavgb", { XM, Vex128, EXx } },
8410 { "(bad)", { XX } },
8413 /* VEX_LEN_E1_P_2 */
8415 { "vpsraw", { XM, Vex128, EXx } },
8416 { "(bad)", { XX } },
8419 /* VEX_LEN_E2_P_2 */
8421 { "vpsrad", { XM, Vex128, EXx } },
8422 { "(bad)", { XX } },
8425 /* VEX_LEN_E3_P_2 */
8427 { "vpavgw", { XM, Vex128, EXx } },
8428 { "(bad)", { XX } },
8431 /* VEX_LEN_E4_P_2 */
8433 { "vpmulhuw", { XM, Vex128, EXx } },
8434 { "(bad)", { XX } },
8437 /* VEX_LEN_E5_P_2 */
8439 { "vpmulhw", { XM, Vex128, EXx } },
8440 { "(bad)", { XX } },
8443 /* VEX_LEN_E8_P_2 */
8445 { "vpsubsb", { XM, Vex128, EXx } },
8446 { "(bad)", { XX } },
8449 /* VEX_LEN_E9_P_2 */
8451 { "vpsubsw", { XM, Vex128, EXx } },
8452 { "(bad)", { XX } },
8455 /* VEX_LEN_EA_P_2 */
8457 { "vpminsw", { XM, Vex128, EXx } },
8458 { "(bad)", { XX } },
8461 /* VEX_LEN_EB_P_2 */
8463 { "vpor", { XM, Vex128, EXx } },
8464 { "(bad)", { XX } },
8467 /* VEX_LEN_EC_P_2 */
8469 { "vpaddsb", { XM, Vex128, EXx } },
8470 { "(bad)", { XX } },
8473 /* VEX_LEN_ED_P_2 */
8475 { "vpaddsw", { XM, Vex128, EXx } },
8476 { "(bad)", { XX } },
8479 /* VEX_LEN_EE_P_2 */
8481 { "vpmaxsw", { XM, Vex128, EXx } },
8482 { "(bad)", { XX } },
8485 /* VEX_LEN_EF_P_2 */
8487 { "vpxor", { XM, Vex128, EXx } },
8488 { "(bad)", { XX } },
8491 /* VEX_LEN_F1_P_2 */
8493 { "vpsllw", { XM, Vex128, EXx } },
8494 { "(bad)", { XX } },
8497 /* VEX_LEN_F2_P_2 */
8499 { "vpslld", { XM, Vex128, EXx } },
8500 { "(bad)", { XX } },
8503 /* VEX_LEN_F3_P_2 */
8505 { "vpsllq", { XM, Vex128, EXx } },
8506 { "(bad)", { XX } },
8509 /* VEX_LEN_F4_P_2 */
8511 { "vpmuludq", { XM, Vex128, EXx } },
8512 { "(bad)", { XX } },
8515 /* VEX_LEN_F5_P_2 */
8517 { "vpmaddwd", { XM, Vex128, EXx } },
8518 { "(bad)", { XX } },
8521 /* VEX_LEN_F6_P_2 */
8523 { "vpsadbw", { XM, Vex128, EXx } },
8524 { "(bad)", { XX } },
8527 /* VEX_LEN_F7_P_2 */
8529 { "vmaskmovdqu", { XM, XS } },
8530 { "(bad)", { XX } },
8533 /* VEX_LEN_F8_P_2 */
8535 { "vpsubb", { XM, Vex128, EXx } },
8536 { "(bad)", { XX } },
8539 /* VEX_LEN_F9_P_2 */
8541 { "vpsubw", { XM, Vex128, EXx } },
8542 { "(bad)", { XX } },
8545 /* VEX_LEN_FA_P_2 */
8547 { "vpsubd", { XM, Vex128, EXx } },
8548 { "(bad)", { XX } },
8551 /* VEX_LEN_FB_P_2 */
8553 { "vpsubq", { XM, Vex128, EXx } },
8554 { "(bad)", { XX } },
8557 /* VEX_LEN_FC_P_2 */
8559 { "vpaddb", { XM, Vex128, EXx } },
8560 { "(bad)", { XX } },
8563 /* VEX_LEN_FD_P_2 */
8565 { "vpaddw", { XM, Vex128, EXx } },
8566 { "(bad)", { XX } },
8569 /* VEX_LEN_FE_P_2 */
8571 { "vpaddd", { XM, Vex128, EXx } },
8572 { "(bad)", { XX } },
8575 /* VEX_LEN_3800_P_2 */
8577 { "vpshufb", { XM, Vex128, EXx } },
8578 { "(bad)", { XX } },
8581 /* VEX_LEN_3801_P_2 */
8583 { "vphaddw", { XM, Vex128, EXx } },
8584 { "(bad)", { XX } },
8587 /* VEX_LEN_3802_P_2 */
8589 { "vphaddd", { XM, Vex128, EXx } },
8590 { "(bad)", { XX } },
8593 /* VEX_LEN_3803_P_2 */
8595 { "vphaddsw", { XM, Vex128, EXx } },
8596 { "(bad)", { XX } },
8599 /* VEX_LEN_3804_P_2 */
8601 { "vpmaddubsw", { XM, Vex128, EXx } },
8602 { "(bad)", { XX } },
8605 /* VEX_LEN_3805_P_2 */
8607 { "vphsubw", { XM, Vex128, EXx } },
8608 { "(bad)", { XX } },
8611 /* VEX_LEN_3806_P_2 */
8613 { "vphsubd", { XM, Vex128, EXx } },
8614 { "(bad)", { XX } },
8617 /* VEX_LEN_3807_P_2 */
8619 { "vphsubsw", { XM, Vex128, EXx } },
8620 { "(bad)", { XX } },
8623 /* VEX_LEN_3808_P_2 */
8625 { "vpsignb", { XM, Vex128, EXx } },
8626 { "(bad)", { XX } },
8629 /* VEX_LEN_3809_P_2 */
8631 { "vpsignw", { XM, Vex128, EXx } },
8632 { "(bad)", { XX } },
8635 /* VEX_LEN_380A_P_2 */
8637 { "vpsignd", { XM, Vex128, EXx } },
8638 { "(bad)", { XX } },
8641 /* VEX_LEN_380B_P_2 */
8643 { "vpmulhrsw", { XM, Vex128, EXx } },
8644 { "(bad)", { XX } },
8647 /* VEX_LEN_3819_P_2_M_0 */
8649 { "(bad)", { XX } },
8650 { "vbroadcastsd", { XM, Mq } },
8653 /* VEX_LEN_381A_P_2_M_0 */
8655 { "(bad)", { XX } },
8656 { "vbroadcastf128", { XM, Mxmm } },
8659 /* VEX_LEN_381C_P_2 */
8661 { "vpabsb", { XM, EXx } },
8662 { "(bad)", { XX } },
8665 /* VEX_LEN_381D_P_2 */
8667 { "vpabsw", { XM, EXx } },
8668 { "(bad)", { XX } },
8671 /* VEX_LEN_381E_P_2 */
8673 { "vpabsd", { XM, EXx } },
8674 { "(bad)", { XX } },
8677 /* VEX_LEN_3820_P_2 */
8679 { "vpmovsxbw", { XM, EXq } },
8680 { "(bad)", { XX } },
8683 /* VEX_LEN_3821_P_2 */
8685 { "vpmovsxbd", { XM, EXd } },
8686 { "(bad)", { XX } },
8689 /* VEX_LEN_3822_P_2 */
8691 { "vpmovsxbq", { XM, EXw } },
8692 { "(bad)", { XX } },
8695 /* VEX_LEN_3823_P_2 */
8697 { "vpmovsxwd", { XM, EXq } },
8698 { "(bad)", { XX } },
8701 /* VEX_LEN_3824_P_2 */
8703 { "vpmovsxwq", { XM, EXd } },
8704 { "(bad)", { XX } },
8707 /* VEX_LEN_3825_P_2 */
8709 { "vpmovsxdq", { XM, EXq } },
8710 { "(bad)", { XX } },
8713 /* VEX_LEN_3828_P_2 */
8715 { "vpmuldq", { XM, Vex128, EXx } },
8716 { "(bad)", { XX } },
8719 /* VEX_LEN_3829_P_2 */
8721 { "vpcmpeqq", { XM, Vex128, EXx } },
8722 { "(bad)", { XX } },
8725 /* VEX_LEN_382A_P_2_M_0 */
8727 { "vmovntdqa", { XM, Mx } },
8728 { "(bad)", { XX } },
8731 /* VEX_LEN_382B_P_2 */
8733 { "vpackusdw", { XM, Vex128, EXx } },
8734 { "(bad)", { XX } },
8737 /* VEX_LEN_3830_P_2 */
8739 { "vpmovzxbw", { XM, EXq } },
8740 { "(bad)", { XX } },
8743 /* VEX_LEN_3831_P_2 */
8745 { "vpmovzxbd", { XM, EXd } },
8746 { "(bad)", { XX } },
8749 /* VEX_LEN_3832_P_2 */
8751 { "vpmovzxbq", { XM, EXw } },
8752 { "(bad)", { XX } },
8755 /* VEX_LEN_3833_P_2 */
8757 { "vpmovzxwd", { XM, EXq } },
8758 { "(bad)", { XX } },
8761 /* VEX_LEN_3834_P_2 */
8763 { "vpmovzxwq", { XM, EXd } },
8764 { "(bad)", { XX } },
8767 /* VEX_LEN_3835_P_2 */
8769 { "vpmovzxdq", { XM, EXq } },
8770 { "(bad)", { XX } },
8773 /* VEX_LEN_3837_P_2 */
8775 { "vpcmpgtq", { XM, Vex128, EXx } },
8776 { "(bad)", { XX } },
8779 /* VEX_LEN_3838_P_2 */
8781 { "vpminsb", { XM, Vex128, EXx } },
8782 { "(bad)", { XX } },
8785 /* VEX_LEN_3839_P_2 */
8787 { "vpminsd", { XM, Vex128, EXx } },
8788 { "(bad)", { XX } },
8791 /* VEX_LEN_383A_P_2 */
8793 { "vpminuw", { XM, Vex128, EXx } },
8794 { "(bad)", { XX } },
8797 /* VEX_LEN_383B_P_2 */
8799 { "vpminud", { XM, Vex128, EXx } },
8800 { "(bad)", { XX } },
8803 /* VEX_LEN_383C_P_2 */
8805 { "vpmaxsb", { XM, Vex128, EXx } },
8806 { "(bad)", { XX } },
8809 /* VEX_LEN_383D_P_2 */
8811 { "vpmaxsd", { XM, Vex128, EXx } },
8812 { "(bad)", { XX } },
8815 /* VEX_LEN_383E_P_2 */
8817 { "vpmaxuw", { XM, Vex128, EXx } },
8818 { "(bad)", { XX } },
8821 /* VEX_LEN_383F_P_2 */
8823 { "vpmaxud", { XM, Vex128, EXx } },
8824 { "(bad)", { XX } },
8827 /* VEX_LEN_3840_P_2 */
8829 { "vpmulld", { XM, Vex128, EXx } },
8830 { "(bad)", { XX } },
8833 /* VEX_LEN_3841_P_2 */
8835 { "vphminposuw", { XM, EXx } },
8836 { "(bad)", { XX } },
8839 /* VEX_LEN_38DB_P_2 */
8841 { "vaesimc", { XM, EXx } },
8842 { "(bad)", { XX } },
8845 /* VEX_LEN_38DC_P_2 */
8847 { "vaesenc", { XM, Vex128, EXx } },
8848 { "(bad)", { XX } },
8851 /* VEX_LEN_38DD_P_2 */
8853 { "vaesenclast", { XM, Vex128, EXx } },
8854 { "(bad)", { XX } },
8857 /* VEX_LEN_38DE_P_2 */
8859 { "vaesdec", { XM, Vex128, EXx } },
8860 { "(bad)", { XX } },
8863 /* VEX_LEN_38DF_P_2 */
8865 { "vaesdeclast", { XM, Vex128, EXx } },
8866 { "(bad)", { XX } },
8869 /* VEX_LEN_3A06_P_2 */
8871 { "(bad)", { XX } },
8872 { "vperm2f128", { XM, Vex256, EXx, Ib } },
8875 /* VEX_LEN_3A0A_P_2 */
8877 { "vroundss", { XM, Vex128, EXd, Ib } },
8878 { "(bad)", { XX } },
8881 /* VEX_LEN_3A0B_P_2 */
8883 { "vroundsd", { XM, Vex128, EXq, Ib } },
8884 { "(bad)", { XX } },
8887 /* VEX_LEN_3A0E_P_2 */
8889 { "vpblendw", { XM, Vex128, EXx, Ib } },
8890 { "(bad)", { XX } },
8893 /* VEX_LEN_3A0F_P_2 */
8895 { "vpalignr", { XM, Vex128, EXx, Ib } },
8896 { "(bad)", { XX } },
8899 /* VEX_LEN_3A14_P_2 */
8901 { "vpextrb", { Edqb, XM, Ib } },
8902 { "(bad)", { XX } },
8905 /* VEX_LEN_3A15_P_2 */
8907 { "vpextrw", { Edqw, XM, Ib } },
8908 { "(bad)", { XX } },
8911 /* VEX_LEN_3A16_P_2 */
8913 { "vpextrK", { Edq, XM, Ib } },
8914 { "(bad)", { XX } },
8917 /* VEX_LEN_3A17_P_2 */
8919 { "vextractps", { Edqd, XM, Ib } },
8920 { "(bad)", { XX } },
8923 /* VEX_LEN_3A18_P_2 */
8925 { "(bad)", { XX } },
8926 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
8929 /* VEX_LEN_3A19_P_2 */
8931 { "(bad)", { XX } },
8932 { "vextractf128", { EXxmm, XM, Ib } },
8935 /* VEX_LEN_3A20_P_2 */
8937 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
8938 { "(bad)", { XX } },
8941 /* VEX_LEN_3A21_P_2 */
8943 { "vinsertps", { XM, Vex128, EXd, Ib } },
8944 { "(bad)", { XX } },
8947 /* VEX_LEN_3A22_P_2 */
8949 { "vpinsrK", { XM, Vex128, Edq, Ib } },
8950 { "(bad)", { XX } },
8953 /* VEX_LEN_3A41_P_2 */
8955 { "vdppd", { XM, Vex128, EXx, Ib } },
8956 { "(bad)", { XX } },
8959 /* VEX_LEN_3A42_P_2 */
8961 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
8962 { "(bad)", { XX } },
8965 /* VEX_LEN_3A44_P_2 */
8967 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
8968 { "(bad)", { XX } },
8971 /* VEX_LEN_3A4C_P_2 */
8973 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
8974 { "(bad)", { XX } },
8977 /* VEX_LEN_3A60_P_2 */
8979 { "vpcmpestrm", { XM, EXx, Ib } },
8980 { "(bad)", { XX } },
8983 /* VEX_LEN_3A61_P_2 */
8985 { "vpcmpestri", { XM, EXx, Ib } },
8986 { "(bad)", { XX } },
8989 /* VEX_LEN_3A62_P_2 */
8991 { "vpcmpistrm", { XM, EXx, Ib } },
8992 { "(bad)", { XX } },
8995 /* VEX_LEN_3A63_P_2 */
8997 { "vpcmpistri", { XM, EXx, Ib } },
8998 { "(bad)", { XX } },
9001 /* VEX_LEN_3A6A_P_2 */
9003 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9004 { "(bad)", { XX } },
9007 /* VEX_LEN_3A6B_P_2 */
9009 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9010 { "(bad)", { XX } },
9013 /* VEX_LEN_3A6E_P_2 */
9015 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9016 { "(bad)", { XX } },
9019 /* VEX_LEN_3A6F_P_2 */
9021 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9022 { "(bad)", { XX } },
9025 /* VEX_LEN_3A7A_P_2 */
9027 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9028 { "(bad)", { XX } },
9031 /* VEX_LEN_3A7B_P_2 */
9033 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9034 { "(bad)", { XX } },
9037 /* VEX_LEN_3A7E_P_2 */
9039 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9040 { "(bad)", { XX } },
9043 /* VEX_LEN_3A7F_P_2 */
9045 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9046 { "(bad)", { XX } },
9049 /* VEX_LEN_3ADF_P_2 */
9051 { "vaeskeygenassist", { XM, EXx, Ib } },
9052 { "(bad)", { XX } },
9056 static const struct dis386 mod_table[][2] = {
9059 { "leaS", { Gv, M } },
9060 { "(bad)", { XX } },
9063 /* MOD_0F01_REG_0 */
9064 { X86_64_TABLE (X86_64_0F01_REG_0) },
9065 { RM_TABLE (RM_0F01_REG_0) },
9068 /* MOD_0F01_REG_1 */
9069 { X86_64_TABLE (X86_64_0F01_REG_1) },
9070 { RM_TABLE (RM_0F01_REG_1) },
9073 /* MOD_0F01_REG_2 */
9074 { X86_64_TABLE (X86_64_0F01_REG_2) },
9075 { RM_TABLE (RM_0F01_REG_2) },
9078 /* MOD_0F01_REG_3 */
9079 { X86_64_TABLE (X86_64_0F01_REG_3) },
9080 { RM_TABLE (RM_0F01_REG_3) },
9083 /* MOD_0F01_REG_7 */
9084 { "invlpg", { Mb } },
9085 { RM_TABLE (RM_0F01_REG_7) },
9088 /* MOD_0F12_PREFIX_0 */
9089 { "movlps", { XM, EXq } },
9090 { "movhlps", { XM, EXq } },
9094 { "movlpX", { EXq, XM } },
9095 { "(bad)", { XX } },
9098 /* MOD_0F16_PREFIX_0 */
9099 { "movhps", { XM, EXq } },
9100 { "movlhps", { XM, EXq } },
9104 { "movhpX", { EXq, XM } },
9105 { "(bad)", { XX } },
9108 /* MOD_0F18_REG_0 */
9109 { "prefetchnta", { Mb } },
9110 { "(bad)", { XX } },
9113 /* MOD_0F18_REG_1 */
9114 { "prefetcht0", { Mb } },
9115 { "(bad)", { XX } },
9118 /* MOD_0F18_REG_2 */
9119 { "prefetcht1", { Mb } },
9120 { "(bad)", { XX } },
9123 /* MOD_0F18_REG_3 */
9124 { "prefetcht2", { Mb } },
9125 { "(bad)", { XX } },
9129 { "(bad)", { XX } },
9130 { "movZ", { Rm, Cm } },
9134 { "(bad)", { XX } },
9135 { "movZ", { Rm, Dm } },
9139 { "(bad)", { XX } },
9140 { "movZ", { Cm, Rm } },
9144 { "(bad)", { XX } },
9145 { "movZ", { Dm, Rm } },
9149 { "(bad)", { XX } },
9150 { "movL", { Rd, Td } },
9154 { "(bad)", { XX } },
9155 { "movL", { Td, Rd } },
9158 /* MOD_0F2B_PREFIX_0 */
9159 {"movntps", { Mx, XM } },
9160 { "(bad)", { XX } },
9163 /* MOD_0F2B_PREFIX_1 */
9164 {"movntss", { Md, XM } },
9165 { "(bad)", { XX } },
9168 /* MOD_0F2B_PREFIX_2 */
9169 {"movntpd", { Mx, XM } },
9170 { "(bad)", { XX } },
9173 /* MOD_0F2B_PREFIX_3 */
9174 {"movntsd", { Mq, XM } },
9175 { "(bad)", { XX } },
9179 { "(bad)", { XX } },
9180 { "movmskpX", { Gdq, XS } },
9183 /* MOD_0F71_REG_2 */
9184 { "(bad)", { XX } },
9185 { "psrlw", { MS, Ib } },
9188 /* MOD_0F71_REG_4 */
9189 { "(bad)", { XX } },
9190 { "psraw", { MS, Ib } },
9193 /* MOD_0F71_REG_6 */
9194 { "(bad)", { XX } },
9195 { "psllw", { MS, Ib } },
9198 /* MOD_0F72_REG_2 */
9199 { "(bad)", { XX } },
9200 { "psrld", { MS, Ib } },
9203 /* MOD_0F72_REG_4 */
9204 { "(bad)", { XX } },
9205 { "psrad", { MS, Ib } },
9208 /* MOD_0F72_REG_6 */
9209 { "(bad)", { XX } },
9210 { "pslld", { MS, Ib } },
9213 /* MOD_0F73_REG_2 */
9214 { "(bad)", { XX } },
9215 { "psrlq", { MS, Ib } },
9218 /* MOD_0F73_REG_3 */
9219 { "(bad)", { XX } },
9220 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
9223 /* MOD_0F73_REG_6 */
9224 { "(bad)", { XX } },
9225 { "psllq", { MS, Ib } },
9228 /* MOD_0F73_REG_7 */
9229 { "(bad)", { XX } },
9230 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
9233 /* MOD_0FAE_REG_0 */
9234 { "fxsave", { M } },
9235 { "(bad)", { XX } },
9238 /* MOD_0FAE_REG_1 */
9239 { "fxrstor", { M } },
9240 { "(bad)", { XX } },
9243 /* MOD_0FAE_REG_2 */
9244 { "ldmxcsr", { Md } },
9245 { "(bad)", { XX } },
9248 /* MOD_0FAE_REG_3 */
9249 { "stmxcsr", { Md } },
9250 { "(bad)", { XX } },
9253 /* MOD_0FAE_REG_4 */
9255 { "(bad)", { XX } },
9258 /* MOD_0FAE_REG_5 */
9259 { "xrstor", { M } },
9260 { RM_TABLE (RM_0FAE_REG_5) },
9263 /* MOD_0FAE_REG_6 */
9264 { "xsaveopt", { M } },
9265 { RM_TABLE (RM_0FAE_REG_6) },
9268 /* MOD_0FAE_REG_7 */
9269 { "clflush", { Mb } },
9270 { RM_TABLE (RM_0FAE_REG_7) },
9274 { "lssS", { Gv, Mp } },
9275 { "(bad)", { XX } },
9279 { "lfsS", { Gv, Mp } },
9280 { "(bad)", { XX } },
9284 { "lgsS", { Gv, Mp } },
9285 { "(bad)", { XX } },
9288 /* MOD_0FC7_REG_6 */
9289 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
9290 { "(bad)", { XX } },
9293 /* MOD_0FC7_REG_7 */
9294 { "vmptrst", { Mq } },
9295 { "(bad)", { XX } },
9299 { "(bad)", { XX } },
9300 { "pmovmskb", { Gdq, MS } },
9303 /* MOD_0FE7_PREFIX_2 */
9304 { "movntdq", { Mx, XM } },
9305 { "(bad)", { XX } },
9308 /* MOD_0FF0_PREFIX_3 */
9309 { "lddqu", { XM, M } },
9310 { "(bad)", { XX } },
9313 /* MOD_0F382A_PREFIX_2 */
9314 { "movntdqa", { XM, Mx } },
9315 { "(bad)", { XX } },
9319 { "bound{S|}", { Gv, Ma } },
9320 { "(bad)", { XX } },
9324 { "lesS", { Gv, Mp } },
9325 { VEX_C4_TABLE (VEX_0F) },
9329 { "ldsS", { Gv, Mp } },
9330 { VEX_C5_TABLE (VEX_0F) },
9333 /* MOD_VEX_12_PREFIX_0 */
9334 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
9335 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
9339 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
9340 { "(bad)", { XX } },
9343 /* MOD_VEX_16_PREFIX_0 */
9344 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
9345 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
9349 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
9350 { "(bad)", { XX } },
9354 { "vmovntpX", { Mx, XM } },
9355 { "(bad)", { XX } },
9359 { "(bad)", { XX } },
9360 { "vmovmskpX", { Gdq, XS } },
9363 /* MOD_VEX_71_REG_2 */
9364 { "(bad)", { XX } },
9365 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
9368 /* MOD_VEX_71_REG_4 */
9369 { "(bad)", { XX } },
9370 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
9373 /* MOD_VEX_71_REG_6 */
9374 { "(bad)", { XX } },
9375 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
9378 /* MOD_VEX_72_REG_2 */
9379 { "(bad)", { XX } },
9380 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
9383 /* MOD_VEX_72_REG_4 */
9384 { "(bad)", { XX } },
9385 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
9388 /* MOD_VEX_72_REG_6 */
9389 { "(bad)", { XX } },
9390 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
9393 /* MOD_VEX_73_REG_2 */
9394 { "(bad)", { XX } },
9395 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
9398 /* MOD_VEX_73_REG_3 */
9399 { "(bad)", { XX } },
9400 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
9403 /* MOD_VEX_73_REG_6 */
9404 { "(bad)", { XX } },
9405 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
9408 /* MOD_VEX_73_REG_7 */
9409 { "(bad)", { XX } },
9410 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
9413 /* MOD_VEX_AE_REG_2 */
9414 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
9415 { "(bad)", { XX } },
9418 /* MOD_VEX_AE_REG_3 */
9419 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
9420 { "(bad)", { XX } },
9423 /* MOD_VEX_D7_PREFIX_2 */
9424 { "(bad)", { XX } },
9425 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
9428 /* MOD_VEX_E7_PREFIX_2 */
9429 { "vmovntdq", { Mx, XM } },
9430 { "(bad)", { XX } },
9433 /* MOD_VEX_F0_PREFIX_3 */
9434 { "vlddqu", { XM, M } },
9435 { "(bad)", { XX } },
9438 /* MOD_VEX_3818_PREFIX_2 */
9439 { "vbroadcastss", { XM, Md } },
9440 { "(bad)", { XX } },
9443 /* MOD_VEX_3819_PREFIX_2 */
9444 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
9445 { "(bad)", { XX } },
9448 /* MOD_VEX_381A_PREFIX_2 */
9449 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
9450 { "(bad)", { XX } },
9453 /* MOD_VEX_382A_PREFIX_2 */
9454 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
9455 { "(bad)", { XX } },
9458 /* MOD_VEX_382C_PREFIX_2 */
9459 { "vmaskmovps", { XM, Vex, Mx } },
9460 { "(bad)", { XX } },
9463 /* MOD_VEX_382D_PREFIX_2 */
9464 { "vmaskmovpd", { XM, Vex, Mx } },
9465 { "(bad)", { XX } },
9468 /* MOD_VEX_382E_PREFIX_2 */
9469 { "vmaskmovps", { Mx, Vex, XM } },
9470 { "(bad)", { XX } },
9473 /* MOD_VEX_382F_PREFIX_2 */
9474 { "vmaskmovpd", { Mx, Vex, XM } },
9475 { "(bad)", { XX } },
9479 static const struct dis386 rm_table[][8] = {
9482 { "(bad)", { XX } },
9483 { "vmcall", { Skip_MODRM } },
9484 { "vmlaunch", { Skip_MODRM } },
9485 { "vmresume", { Skip_MODRM } },
9486 { "vmxoff", { Skip_MODRM } },
9487 { "(bad)", { XX } },
9488 { "(bad)", { XX } },
9489 { "(bad)", { XX } },
9493 { "monitor", { { OP_Monitor, 0 } } },
9494 { "mwait", { { OP_Mwait, 0 } } },
9495 { "(bad)", { XX } },
9496 { "(bad)", { XX } },
9497 { "(bad)", { XX } },
9498 { "(bad)", { XX } },
9499 { "(bad)", { XX } },
9500 { "(bad)", { XX } },
9504 { "xgetbv", { Skip_MODRM } },
9505 { "xsetbv", { Skip_MODRM } },
9506 { "(bad)", { XX } },
9507 { "(bad)", { XX } },
9508 { "(bad)", { XX } },
9509 { "(bad)", { XX } },
9510 { "(bad)", { XX } },
9511 { "(bad)", { XX } },
9515 { "vmrun", { Skip_MODRM } },
9516 { "vmmcall", { Skip_MODRM } },
9517 { "vmload", { Skip_MODRM } },
9518 { "vmsave", { Skip_MODRM } },
9519 { "stgi", { Skip_MODRM } },
9520 { "clgi", { Skip_MODRM } },
9521 { "skinit", { Skip_MODRM } },
9522 { "invlpga", { Skip_MODRM } },
9526 { "swapgs", { Skip_MODRM } },
9527 { "rdtscp", { Skip_MODRM } },
9528 { "(bad)", { XX } },
9529 { "(bad)", { XX } },
9530 { "(bad)", { XX } },
9531 { "(bad)", { XX } },
9532 { "(bad)", { XX } },
9533 { "(bad)", { XX } },
9537 { "lfence", { Skip_MODRM } },
9538 { "(bad)", { XX } },
9539 { "(bad)", { XX } },
9540 { "(bad)", { XX } },
9541 { "(bad)", { XX } },
9542 { "(bad)", { XX } },
9543 { "(bad)", { XX } },
9544 { "(bad)", { XX } },
9548 { "mfence", { Skip_MODRM } },
9549 { "(bad)", { XX } },
9550 { "(bad)", { XX } },
9551 { "(bad)", { XX } },
9552 { "(bad)", { XX } },
9553 { "(bad)", { XX } },
9554 { "(bad)", { XX } },
9555 { "(bad)", { XX } },
9559 { "sfence", { Skip_MODRM } },
9560 { "(bad)", { XX } },
9561 { "(bad)", { XX } },
9562 { "(bad)", { XX } },
9563 { "(bad)", { XX } },
9564 { "(bad)", { XX } },
9565 { "(bad)", { XX } },
9566 { "(bad)", { XX } },
9570 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9584 FETCH_DATA (the_info, codep + 1);
9588 /* REX prefixes family. */
9605 if (address_mode == mode_64bit)
9611 prefixes |= PREFIX_REPZ;
9614 prefixes |= PREFIX_REPNZ;
9617 prefixes |= PREFIX_LOCK;
9620 prefixes |= PREFIX_CS;
9623 prefixes |= PREFIX_SS;
9626 prefixes |= PREFIX_DS;
9629 prefixes |= PREFIX_ES;
9632 prefixes |= PREFIX_FS;
9635 prefixes |= PREFIX_GS;
9638 prefixes |= PREFIX_DATA;
9641 prefixes |= PREFIX_ADDR;
9644 /* fwait is really an instruction. If there are prefixes
9645 before the fwait, they belong to the fwait, *not* to the
9646 following instruction. */
9647 if (prefixes || rex)
9649 prefixes |= PREFIX_FWAIT;
9653 prefixes = PREFIX_FWAIT;
9658 /* Rex is ignored when followed by another prefix. */
9670 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
9674 prefix_name (int pref, int sizeflag)
9676 static const char *rexes [16] =
9681 "rex.XB", /* 0x43 */
9683 "rex.RB", /* 0x45 */
9684 "rex.RX", /* 0x46 */
9685 "rex.RXB", /* 0x47 */
9687 "rex.WB", /* 0x49 */
9688 "rex.WX", /* 0x4a */
9689 "rex.WXB", /* 0x4b */
9690 "rex.WR", /* 0x4c */
9691 "rex.WRB", /* 0x4d */
9692 "rex.WRX", /* 0x4e */
9693 "rex.WRXB", /* 0x4f */
9698 /* REX prefixes family. */
9715 return rexes [pref - 0x40];
9735 return (sizeflag & DFLAG) ? "data16" : "data32";
9737 if (address_mode == mode_64bit)
9738 return (sizeflag & AFLAG) ? "addr32" : "addr64";
9740 return (sizeflag & AFLAG) ? "addr16" : "addr32";
9748 static char op_out[MAX_OPERANDS][100];
9749 static int op_ad, op_index[MAX_OPERANDS];
9750 static int two_source_ops;
9751 static bfd_vma op_address[MAX_OPERANDS];
9752 static bfd_vma op_riprel[MAX_OPERANDS];
9753 static bfd_vma start_pc;
9756 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
9757 * (see topic "Redundant prefixes" in the "Differences from 8086"
9758 * section of the "Virtual 8086 Mode" chapter.)
9759 * 'pc' should be the address of this instruction, it will
9760 * be used to print the target address if this is a relative jump or call
9761 * The function returns the length of this instruction in bytes.
9764 static char intel_syntax;
9765 static char intel_mnemonic = !SYSV386_COMPAT;
9766 static char open_char;
9767 static char close_char;
9768 static char separator_char;
9769 static char scale_char;
9771 /* Here for backwards compatibility. When gdb stops using
9772 print_insn_i386_att and print_insn_i386_intel these functions can
9773 disappear, and print_insn_i386 be merged into print_insn. */
9775 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
9779 return print_insn (pc, info);
9783 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
9787 return print_insn (pc, info);
9791 print_insn_i386 (bfd_vma pc, disassemble_info *info)
9795 return print_insn (pc, info);
9799 print_i386_disassembler_options (FILE *stream)
9801 fprintf (stream, _("\n\
9802 The following i386/x86-64 specific disassembler options are supported for use\n\
9803 with the -M switch (multiple options should be separated by commas):\n"));
9805 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
9806 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
9807 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
9808 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
9809 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
9810 fprintf (stream, _(" att-mnemonic\n"
9811 " Display instruction in AT&T mnemonic\n"));
9812 fprintf (stream, _(" intel-mnemonic\n"
9813 " Display instruction in Intel mnemonic\n"));
9814 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
9815 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
9816 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
9817 fprintf (stream, _(" data32 Assume 32bit data size\n"));
9818 fprintf (stream, _(" data16 Assume 16bit data size\n"));
9819 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
9822 /* Get a pointer to struct dis386 with a valid name. */
9824 static const struct dis386 *
9825 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
9827 int index, vex_table_index;
9829 if (dp->name != NULL)
9832 switch (dp->op[0].bytemode)
9835 dp = ®_table[dp->op[1].bytemode][modrm.reg];
9839 index = modrm.mod == 0x3 ? 1 : 0;
9840 dp = &mod_table[dp->op[1].bytemode][index];
9844 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
9847 case USE_PREFIX_TABLE:
9850 /* The prefix in VEX is implicit. */
9856 case REPE_PREFIX_OPCODE:
9859 case DATA_PREFIX_OPCODE:
9862 case REPNE_PREFIX_OPCODE:
9873 used_prefixes |= (prefixes & PREFIX_REPZ);
9874 if (prefixes & PREFIX_REPZ)
9881 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
9883 used_prefixes |= (prefixes & PREFIX_REPNZ);
9884 if (prefixes & PREFIX_REPNZ)
9887 repnz_prefix = NULL;
9891 used_prefixes |= (prefixes & PREFIX_DATA);
9892 if (prefixes & PREFIX_DATA)
9900 dp = &prefix_table[dp->op[1].bytemode][index];
9903 case USE_X86_64_TABLE:
9904 index = address_mode == mode_64bit ? 1 : 0;
9905 dp = &x86_64_table[dp->op[1].bytemode][index];
9908 case USE_3BYTE_TABLE:
9909 FETCH_DATA (info, codep + 2);
9911 dp = &three_byte_table[dp->op[1].bytemode][index];
9912 modrm.mod = (*codep >> 6) & 3;
9913 modrm.reg = (*codep >> 3) & 7;
9914 modrm.rm = *codep & 7;
9917 case USE_VEX_LEN_TABLE:
9934 dp = &vex_len_table[dp->op[1].bytemode][index];
9937 case USE_XOP_8F_TABLE:
9938 FETCH_DATA (info, codep + 3);
9939 /* All bits in the REX prefix are ignored. */
9941 rex = ~(*codep >> 5) & 0x7;
9943 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
9944 switch ((*codep & 0x1f))
9949 vex_table_index = XOP_09;
9952 vex_table_index = XOP_0A;
9956 vex.w = *codep & 0x80;
9957 if (vex.w && address_mode == mode_64bit)
9960 vex.register_specifier = (~(*codep >> 3)) & 0xf;
9961 if (address_mode != mode_64bit
9962 && vex.register_specifier > 0x7)
9965 vex.length = (*codep & 0x4) ? 256 : 128;
9966 switch ((*codep & 0x3))
9972 vex.prefix = DATA_PREFIX_OPCODE;
9975 vex.prefix = REPE_PREFIX_OPCODE;
9978 vex.prefix = REPNE_PREFIX_OPCODE;
9985 dp = &xop_table[vex_table_index][index];
9986 /* There is no MODRM byte for VEX [82|77]. */
9987 if (index != 0x77 && index != 0x82)
9989 FETCH_DATA (info, codep + 1);
9990 modrm.mod = (*codep >> 6) & 3;
9991 modrm.reg = (*codep >> 3) & 7;
9992 modrm.rm = *codep & 7;
9996 case USE_VEX_C4_TABLE:
9997 FETCH_DATA (info, codep + 3);
9998 /* All bits in the REX prefix are ignored. */
10000 rex = ~(*codep >> 5) & 0x7;
10001 switch ((*codep & 0x1f))
10006 vex_table_index = VEX_0F;
10009 vex_table_index = VEX_0F38;
10012 vex_table_index = VEX_0F3A;
10016 vex.w = *codep & 0x80;
10017 if (vex.w && address_mode == mode_64bit)
10020 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10021 if (address_mode != mode_64bit
10022 && vex.register_specifier > 0x7)
10025 vex.length = (*codep & 0x4) ? 256 : 128;
10026 switch ((*codep & 0x3))
10032 vex.prefix = DATA_PREFIX_OPCODE;
10035 vex.prefix = REPE_PREFIX_OPCODE;
10038 vex.prefix = REPNE_PREFIX_OPCODE;
10045 dp = &vex_table[vex_table_index][index];
10046 /* There is no MODRM byte for VEX [82|77]. */
10047 if (index != 0x77 && index != 0x82)
10049 FETCH_DATA (info, codep + 1);
10050 modrm.mod = (*codep >> 6) & 3;
10051 modrm.reg = (*codep >> 3) & 7;
10052 modrm.rm = *codep & 7;
10056 case USE_VEX_C5_TABLE:
10057 FETCH_DATA (info, codep + 2);
10058 /* All bits in the REX prefix are ignored. */
10060 rex = (*codep & 0x80) ? 0 : REX_R;
10062 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10063 if (address_mode != mode_64bit
10064 && vex.register_specifier > 0x7)
10067 vex.length = (*codep & 0x4) ? 256 : 128;
10068 switch ((*codep & 0x3))
10074 vex.prefix = DATA_PREFIX_OPCODE;
10077 vex.prefix = REPE_PREFIX_OPCODE;
10080 vex.prefix = REPNE_PREFIX_OPCODE;
10087 dp = &vex_table[dp->op[1].bytemode][index];
10088 /* There is no MODRM byte for VEX [82|77]. */
10089 if (index != 0x77 && index != 0x82)
10091 FETCH_DATA (info, codep + 1);
10092 modrm.mod = (*codep >> 6) & 3;
10093 modrm.reg = (*codep >> 3) & 7;
10094 modrm.rm = *codep & 7;
10102 if (dp->name != NULL)
10105 return get_valid_dis386 (dp, info);
10109 print_insn (bfd_vma pc, disassemble_info *info)
10111 const struct dis386 *dp;
10113 char *op_txt[MAX_OPERANDS];
10117 struct dis_private priv;
10119 char prefix_obuf[32];
10120 char *prefix_obufp;
10122 if (info->mach == bfd_mach_x86_64_intel_syntax
10123 || info->mach == bfd_mach_x86_64
10124 || info->mach == bfd_mach_l1om
10125 || info->mach == bfd_mach_l1om_intel_syntax)
10126 address_mode = mode_64bit;
10128 address_mode = mode_32bit;
10130 if (intel_syntax == (char) -1)
10131 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
10132 || info->mach == bfd_mach_x86_64_intel_syntax
10133 || info->mach == bfd_mach_l1om_intel_syntax);
10135 if (info->mach == bfd_mach_i386_i386
10136 || info->mach == bfd_mach_x86_64
10137 || info->mach == bfd_mach_l1om
10138 || info->mach == bfd_mach_i386_i386_intel_syntax
10139 || info->mach == bfd_mach_x86_64_intel_syntax
10140 || info->mach == bfd_mach_l1om_intel_syntax)
10141 priv.orig_sizeflag = AFLAG | DFLAG;
10142 else if (info->mach == bfd_mach_i386_i8086)
10143 priv.orig_sizeflag = 0;
10147 for (p = info->disassembler_options; p != NULL; )
10149 if (CONST_STRNEQ (p, "x86-64"))
10151 address_mode = mode_64bit;
10152 priv.orig_sizeflag = AFLAG | DFLAG;
10154 else if (CONST_STRNEQ (p, "i386"))
10156 address_mode = mode_32bit;
10157 priv.orig_sizeflag = AFLAG | DFLAG;
10159 else if (CONST_STRNEQ (p, "i8086"))
10161 address_mode = mode_16bit;
10162 priv.orig_sizeflag = 0;
10164 else if (CONST_STRNEQ (p, "intel"))
10167 if (CONST_STRNEQ (p + 5, "-mnemonic"))
10168 intel_mnemonic = 1;
10170 else if (CONST_STRNEQ (p, "att"))
10173 if (CONST_STRNEQ (p + 3, "-mnemonic"))
10174 intel_mnemonic = 0;
10176 else if (CONST_STRNEQ (p, "addr"))
10178 if (address_mode == mode_64bit)
10180 if (p[4] == '3' && p[5] == '2')
10181 priv.orig_sizeflag &= ~AFLAG;
10182 else if (p[4] == '6' && p[5] == '4')
10183 priv.orig_sizeflag |= AFLAG;
10187 if (p[4] == '1' && p[5] == '6')
10188 priv.orig_sizeflag &= ~AFLAG;
10189 else if (p[4] == '3' && p[5] == '2')
10190 priv.orig_sizeflag |= AFLAG;
10193 else if (CONST_STRNEQ (p, "data"))
10195 if (p[4] == '1' && p[5] == '6')
10196 priv.orig_sizeflag &= ~DFLAG;
10197 else if (p[4] == '3' && p[5] == '2')
10198 priv.orig_sizeflag |= DFLAG;
10200 else if (CONST_STRNEQ (p, "suffix"))
10201 priv.orig_sizeflag |= SUFFIX_ALWAYS;
10203 p = strchr (p, ',');
10210 names64 = intel_names64;
10211 names32 = intel_names32;
10212 names16 = intel_names16;
10213 names8 = intel_names8;
10214 names8rex = intel_names8rex;
10215 names_seg = intel_names_seg;
10216 index64 = intel_index64;
10217 index32 = intel_index32;
10218 index16 = intel_index16;
10221 separator_char = '+';
10226 names64 = att_names64;
10227 names32 = att_names32;
10228 names16 = att_names16;
10229 names8 = att_names8;
10230 names8rex = att_names8rex;
10231 names_seg = att_names_seg;
10232 index64 = att_index64;
10233 index32 = att_index32;
10234 index16 = att_index16;
10237 separator_char = ',';
10241 /* The output looks better if we put 7 bytes on a line, since that
10242 puts most long word instructions on a single line. Use 8 bytes
10244 if (info->mach == bfd_mach_l1om
10245 || info->mach == bfd_mach_l1om_intel_syntax)
10246 info->bytes_per_line = 8;
10248 info->bytes_per_line = 7;
10250 info->private_data = &priv;
10251 priv.max_fetched = priv.the_buffer;
10252 priv.insn_start = pc;
10255 for (i = 0; i < MAX_OPERANDS; ++i)
10263 start_codep = priv.the_buffer;
10264 codep = priv.the_buffer;
10266 if (setjmp (priv.bailout) != 0)
10270 /* Getting here means we tried for data but didn't get it. That
10271 means we have an incomplete instruction of some sort. Just
10272 print the first byte as a prefix or a .byte pseudo-op. */
10273 if (codep > priv.the_buffer)
10275 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
10277 (*info->fprintf_func) (info->stream, "%s", name);
10280 /* Just print the first byte as a .byte instruction. */
10281 (*info->fprintf_func) (info->stream, ".byte 0x%x",
10282 (unsigned int) priv.the_buffer[0]);
10294 insn_codep = codep;
10295 sizeflag = priv.orig_sizeflag;
10297 FETCH_DATA (info, codep + 1);
10298 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
10300 if (((prefixes & PREFIX_FWAIT)
10301 && ((*codep < 0xd8) || (*codep > 0xdf)))
10302 || (rex && rex_used))
10306 /* fwait not followed by floating point instruction, or rex followed
10307 by other prefixes. Print the first prefix. */
10308 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
10310 name = INTERNAL_DISASSEMBLER_ERROR;
10311 (*info->fprintf_func) (info->stream, "%s", name);
10317 if (*codep == 0x0f)
10319 unsigned char threebyte;
10320 FETCH_DATA (info, codep + 2);
10321 threebyte = *++codep;
10322 dp = &dis386_twobyte[threebyte];
10323 need_modrm = twobyte_has_modrm[*codep];
10328 dp = &dis386[*codep];
10329 need_modrm = onebyte_has_modrm[*codep];
10333 if ((prefixes & PREFIX_REPZ))
10335 repz_prefix = "repz ";
10336 used_prefixes |= PREFIX_REPZ;
10339 repz_prefix = NULL;
10341 if ((prefixes & PREFIX_REPNZ))
10343 repnz_prefix = "repnz ";
10344 used_prefixes |= PREFIX_REPNZ;
10347 repnz_prefix = NULL;
10349 if ((prefixes & PREFIX_LOCK))
10351 lock_prefix = "lock ";
10352 used_prefixes |= PREFIX_LOCK;
10355 lock_prefix = NULL;
10357 addr_prefix = NULL;
10358 if (prefixes & PREFIX_ADDR)
10361 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
10363 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
10364 addr_prefix = "addr32 ";
10366 addr_prefix = "addr16 ";
10367 used_prefixes |= PREFIX_ADDR;
10371 data_prefix = NULL;
10372 if ((prefixes & PREFIX_DATA))
10375 if (dp->op[2].bytemode == cond_jump_mode
10376 && dp->op[0].bytemode == v_mode
10379 if (sizeflag & DFLAG)
10380 data_prefix = "data32 ";
10382 data_prefix = "data16 ";
10383 used_prefixes |= PREFIX_DATA;
10389 FETCH_DATA (info, codep + 1);
10390 modrm.mod = (*codep >> 6) & 3;
10391 modrm.reg = (*codep >> 3) & 7;
10392 modrm.rm = *codep & 7;
10399 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
10401 dofloat (sizeflag);
10405 dp = get_valid_dis386 (dp, info);
10406 if (dp != NULL && putop (dp->name, sizeflag) == 0)
10408 for (i = 0; i < MAX_OPERANDS; ++i)
10411 op_ad = MAX_OPERANDS - 1 - i;
10413 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
10418 /* See if any prefixes were not used. If so, print the first one
10419 separately. If we don't do this, we'll wind up printing an
10420 instruction stream which does not precisely correspond to the
10421 bytes we are disassembling. */
10422 if ((prefixes & ~used_prefixes) != 0)
10426 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
10428 name = INTERNAL_DISASSEMBLER_ERROR;
10429 (*info->fprintf_func) (info->stream, "%s", name);
10432 if ((rex_original & ~rex_used) || rex_ignored)
10435 name = prefix_name (rex_original, priv.orig_sizeflag);
10437 name = INTERNAL_DISASSEMBLER_ERROR;
10438 (*info->fprintf_func) (info->stream, "%s ", name);
10441 prefix_obuf[0] = 0;
10442 prefix_obufp = prefix_obuf;
10444 prefix_obufp = stpcpy (prefix_obufp, lock_prefix);
10446 prefix_obufp = stpcpy (prefix_obufp, repz_prefix);
10448 prefix_obufp = stpcpy (prefix_obufp, repnz_prefix);
10450 prefix_obufp = stpcpy (prefix_obufp, addr_prefix);
10452 prefix_obufp = stpcpy (prefix_obufp, data_prefix);
10454 if (prefix_obuf[0] != 0)
10455 (*info->fprintf_func) (info->stream, "%s", prefix_obuf);
10457 obufp = mnemonicendp;
10458 for (i = strlen (obuf) + strlen (prefix_obuf); i < 6; i++)
10461 (*info->fprintf_func) (info->stream, "%s", obuf);
10463 /* The enter and bound instructions are printed with operands in the same
10464 order as the intel book; everything else is printed in reverse order. */
10465 if (intel_syntax || two_source_ops)
10469 for (i = 0; i < MAX_OPERANDS; ++i)
10470 op_txt[i] = op_out[i];
10472 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
10474 op_ad = op_index[i];
10475 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
10476 op_index[MAX_OPERANDS - 1 - i] = op_ad;
10477 riprel = op_riprel[i];
10478 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
10479 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10484 for (i = 0; i < MAX_OPERANDS; ++i)
10485 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
10489 for (i = 0; i < MAX_OPERANDS; ++i)
10493 (*info->fprintf_func) (info->stream, ",");
10494 if (op_index[i] != -1 && !op_riprel[i])
10495 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
10497 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
10501 for (i = 0; i < MAX_OPERANDS; i++)
10502 if (op_index[i] != -1 && op_riprel[i])
10504 (*info->fprintf_func) (info->stream, " # ");
10505 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
10506 + op_address[op_index[i]]), info);
10509 return codep - priv.the_buffer;
10512 static const char *float_mem[] = {
10587 static const unsigned char float_mem_mode[] = {
10662 #define ST { OP_ST, 0 }
10663 #define STi { OP_STi, 0 }
10665 #define FGRPd9_2 NULL, { { NULL, 0 } }
10666 #define FGRPd9_4 NULL, { { NULL, 1 } }
10667 #define FGRPd9_5 NULL, { { NULL, 2 } }
10668 #define FGRPd9_6 NULL, { { NULL, 3 } }
10669 #define FGRPd9_7 NULL, { { NULL, 4 } }
10670 #define FGRPda_5 NULL, { { NULL, 5 } }
10671 #define FGRPdb_4 NULL, { { NULL, 6 } }
10672 #define FGRPde_3 NULL, { { NULL, 7 } }
10673 #define FGRPdf_4 NULL, { { NULL, 8 } }
10675 static const struct dis386 float_reg[][8] = {
10678 { "fadd", { ST, STi } },
10679 { "fmul", { ST, STi } },
10680 { "fcom", { STi } },
10681 { "fcomp", { STi } },
10682 { "fsub", { ST, STi } },
10683 { "fsubr", { ST, STi } },
10684 { "fdiv", { ST, STi } },
10685 { "fdivr", { ST, STi } },
10689 { "fld", { STi } },
10690 { "fxch", { STi } },
10692 { "(bad)", { XX } },
10700 { "fcmovb", { ST, STi } },
10701 { "fcmove", { ST, STi } },
10702 { "fcmovbe",{ ST, STi } },
10703 { "fcmovu", { ST, STi } },
10704 { "(bad)", { XX } },
10706 { "(bad)", { XX } },
10707 { "(bad)", { XX } },
10711 { "fcmovnb",{ ST, STi } },
10712 { "fcmovne",{ ST, STi } },
10713 { "fcmovnbe",{ ST, STi } },
10714 { "fcmovnu",{ ST, STi } },
10716 { "fucomi", { ST, STi } },
10717 { "fcomi", { ST, STi } },
10718 { "(bad)", { XX } },
10722 { "fadd", { STi, ST } },
10723 { "fmul", { STi, ST } },
10724 { "(bad)", { XX } },
10725 { "(bad)", { XX } },
10726 { "fsub!M", { STi, ST } },
10727 { "fsubM", { STi, ST } },
10728 { "fdiv!M", { STi, ST } },
10729 { "fdivM", { STi, ST } },
10733 { "ffree", { STi } },
10734 { "(bad)", { XX } },
10735 { "fst", { STi } },
10736 { "fstp", { STi } },
10737 { "fucom", { STi } },
10738 { "fucomp", { STi } },
10739 { "(bad)", { XX } },
10740 { "(bad)", { XX } },
10744 { "faddp", { STi, ST } },
10745 { "fmulp", { STi, ST } },
10746 { "(bad)", { XX } },
10748 { "fsub!Mp", { STi, ST } },
10749 { "fsubMp", { STi, ST } },
10750 { "fdiv!Mp", { STi, ST } },
10751 { "fdivMp", { STi, ST } },
10755 { "ffreep", { STi } },
10756 { "(bad)", { XX } },
10757 { "(bad)", { XX } },
10758 { "(bad)", { XX } },
10760 { "fucomip", { ST, STi } },
10761 { "fcomip", { ST, STi } },
10762 { "(bad)", { XX } },
10766 static char *fgrps[][8] = {
10769 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10774 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
10779 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
10784 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
10789 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
10794 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10799 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
10800 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
10805 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10810 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10815 swap_operand (void)
10817 mnemonicendp[0] = '.';
10818 mnemonicendp[1] = 's';
10823 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
10824 int sizeflag ATTRIBUTE_UNUSED)
10826 /* Skip mod/rm byte. */
10832 dofloat (int sizeflag)
10834 const struct dis386 *dp;
10835 unsigned char floatop;
10837 floatop = codep[-1];
10839 if (modrm.mod != 3)
10841 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
10843 putop (float_mem[fp_indx], sizeflag);
10846 OP_E (float_mem_mode[fp_indx], sizeflag);
10849 /* Skip mod/rm byte. */
10853 dp = &float_reg[floatop - 0xd8][modrm.reg];
10854 if (dp->name == NULL)
10856 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
10858 /* Instruction fnstsw is only one with strange arg. */
10859 if (floatop == 0xdf && codep[-1] == 0xe0)
10860 strcpy (op_out[0], names16[0]);
10864 putop (dp->name, sizeflag);
10869 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
10874 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
10879 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
10881 oappend ("%st" + intel_syntax);
10885 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
10887 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
10888 oappend (scratchbuf + intel_syntax);
10891 /* Capital letters in template are macros. */
10893 putop (const char *in_template, int sizeflag)
10898 unsigned int l = 0, len = 1;
10901 #define SAVE_LAST(c) \
10902 if (l < len && l < sizeof (last)) \
10907 for (p = in_template; *p; p++)
10924 while (*++p != '|')
10925 if (*p == '}' || *p == '\0')
10928 /* Fall through. */
10933 while (*++p != '}')
10944 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
10948 if (l == 0 && len == 1)
10953 if (sizeflag & SUFFIX_ALWAYS)
10966 if (address_mode == mode_64bit
10967 && !(prefixes & PREFIX_ADDR))
10978 if (intel_syntax && !alt)
10980 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
10982 if (sizeflag & DFLAG)
10983 *obufp++ = intel_syntax ? 'd' : 'l';
10985 *obufp++ = intel_syntax ? 'w' : 's';
10986 used_prefixes |= (prefixes & PREFIX_DATA);
10990 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
10993 if (modrm.mod == 3)
10997 else if (sizeflag & DFLAG)
10998 *obufp++ = intel_syntax ? 'd' : 'l';
11001 used_prefixes |= (prefixes & PREFIX_DATA);
11006 case 'E': /* For jcxz/jecxz */
11007 if (address_mode == mode_64bit)
11009 if (sizeflag & AFLAG)
11015 if (sizeflag & AFLAG)
11017 used_prefixes |= (prefixes & PREFIX_ADDR);
11022 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11024 if (sizeflag & AFLAG)
11025 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
11027 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
11028 used_prefixes |= (prefixes & PREFIX_ADDR);
11032 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
11034 if ((rex & REX_W) || (sizeflag & DFLAG))
11038 if (!(rex & REX_W))
11039 used_prefixes |= (prefixes & PREFIX_DATA);
11044 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11045 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11047 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
11050 if (prefixes & PREFIX_DS)
11071 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
11076 /* Fall through. */
11079 if (l != 0 || len != 1)
11087 if (sizeflag & SUFFIX_ALWAYS)
11091 if (intel_mnemonic != cond)
11095 if ((prefixes & PREFIX_FWAIT) == 0)
11098 used_prefixes |= PREFIX_FWAIT;
11104 else if (intel_syntax && (sizeflag & DFLAG))
11108 if (!(rex & REX_W))
11109 used_prefixes |= (prefixes & PREFIX_DATA);
11114 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11119 /* Fall through. */
11123 if ((prefixes & PREFIX_DATA)
11125 || (sizeflag & SUFFIX_ALWAYS))
11132 if (sizeflag & DFLAG)
11137 used_prefixes |= (prefixes & PREFIX_DATA);
11143 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11145 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11149 /* Fall through. */
11152 if (l == 0 && len == 1)
11155 if (intel_syntax && !alt)
11158 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11164 if (sizeflag & DFLAG)
11165 *obufp++ = intel_syntax ? 'd' : 'l';
11169 used_prefixes |= (prefixes & PREFIX_DATA);
11174 if (l != 1 || len != 2 || last[0] != 'L')
11180 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11195 else if (sizeflag & DFLAG)
11204 if (intel_syntax && !p[1]
11205 && ((rex & REX_W) || (sizeflag & DFLAG)))
11207 if (!(rex & REX_W))
11208 used_prefixes |= (prefixes & PREFIX_DATA);
11211 if (l == 0 && len == 1)
11215 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11217 if (sizeflag & SUFFIX_ALWAYS)
11239 /* Fall through. */
11242 if (l == 0 && len == 1)
11247 if (sizeflag & SUFFIX_ALWAYS)
11253 if (sizeflag & DFLAG)
11257 used_prefixes |= (prefixes & PREFIX_DATA);
11271 if (address_mode == mode_64bit
11272 && !(prefixes & PREFIX_ADDR))
11283 if (l != 0 || len != 1)
11288 if (need_vex && vex.prefix)
11290 if (vex.prefix == DATA_PREFIX_OPCODE)
11295 else if (prefixes & PREFIX_DATA)
11299 used_prefixes |= (prefixes & PREFIX_DATA);
11302 if (l == 0 && len == 1)
11304 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
11315 if (l != 1 || len != 2 || last[0] != 'X')
11323 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11325 switch (vex.length)
11339 if (l == 0 && len == 1)
11341 /* operand size flag for cwtl, cbtw */
11350 else if (sizeflag & DFLAG)
11354 if (!(rex & REX_W))
11355 used_prefixes |= (prefixes & PREFIX_DATA);
11359 if (l != 1 || len != 2 || last[0] != 'X')
11366 *obufp++ = vex.w ? 'd': 's';
11373 mnemonicendp = obufp;
11378 oappend (const char *s)
11380 obufp = stpcpy (obufp, s);
11386 if (prefixes & PREFIX_CS)
11388 used_prefixes |= PREFIX_CS;
11389 oappend ("%cs:" + intel_syntax);
11391 if (prefixes & PREFIX_DS)
11393 used_prefixes |= PREFIX_DS;
11394 oappend ("%ds:" + intel_syntax);
11396 if (prefixes & PREFIX_SS)
11398 used_prefixes |= PREFIX_SS;
11399 oappend ("%ss:" + intel_syntax);
11401 if (prefixes & PREFIX_ES)
11403 used_prefixes |= PREFIX_ES;
11404 oappend ("%es:" + intel_syntax);
11406 if (prefixes & PREFIX_FS)
11408 used_prefixes |= PREFIX_FS;
11409 oappend ("%fs:" + intel_syntax);
11411 if (prefixes & PREFIX_GS)
11413 used_prefixes |= PREFIX_GS;
11414 oappend ("%gs:" + intel_syntax);
11419 OP_indirE (int bytemode, int sizeflag)
11423 OP_E (bytemode, sizeflag);
11427 print_operand_value (char *buf, int hex, bfd_vma disp)
11429 if (address_mode == mode_64bit)
11437 sprintf_vma (tmp, disp);
11438 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
11439 strcpy (buf + 2, tmp + i);
11443 bfd_signed_vma v = disp;
11450 /* Check for possible overflow on 0x8000000000000000. */
11453 strcpy (buf, "9223372036854775808");
11467 tmp[28 - i] = (v % 10) + '0';
11471 strcpy (buf, tmp + 29 - i);
11477 sprintf (buf, "0x%x", (unsigned int) disp);
11479 sprintf (buf, "%d", (int) disp);
11483 /* Put DISP in BUF as signed hex number. */
11486 print_displacement (char *buf, bfd_vma disp)
11488 bfd_signed_vma val = disp;
11497 /* Check for possible overflow. */
11500 switch (address_mode)
11503 strcpy (buf + j, "0x8000000000000000");
11506 strcpy (buf + j, "0x80000000");
11509 strcpy (buf + j, "0x8000");
11519 sprintf_vma (tmp, (bfd_vma) val);
11520 for (i = 0; tmp[i] == '0'; i++)
11522 if (tmp[i] == '\0')
11524 strcpy (buf + j, tmp + i);
11528 intel_operand_size (int bytemode, int sizeflag)
11535 oappend ("BYTE PTR ");
11539 oappend ("WORD PTR ");
11542 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11544 oappend ("QWORD PTR ");
11545 used_prefixes |= (prefixes & PREFIX_DATA);
11554 oappend ("QWORD PTR ");
11555 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
11556 oappend ("DWORD PTR ");
11558 oappend ("WORD PTR ");
11559 used_prefixes |= (prefixes & PREFIX_DATA);
11562 if ((rex & REX_W) || (sizeflag & DFLAG))
11564 oappend ("WORD PTR ");
11565 if (!(rex & REX_W))
11566 used_prefixes |= (prefixes & PREFIX_DATA);
11569 if (sizeflag & DFLAG)
11570 oappend ("QWORD PTR ");
11572 oappend ("DWORD PTR ");
11573 used_prefixes |= (prefixes & PREFIX_DATA);
11578 oappend ("DWORD PTR ");
11582 oappend ("QWORD PTR ");
11585 if (address_mode == mode_64bit)
11586 oappend ("QWORD PTR ");
11588 oappend ("DWORD PTR ");
11591 if (sizeflag & DFLAG)
11592 oappend ("FWORD PTR ");
11594 oappend ("DWORD PTR ");
11595 used_prefixes |= (prefixes & PREFIX_DATA);
11598 oappend ("TBYTE PTR ");
11604 switch (vex.length)
11607 oappend ("XMMWORD PTR ");
11610 oappend ("YMMWORD PTR ");
11617 oappend ("XMMWORD PTR ");
11620 oappend ("XMMWORD PTR ");
11626 switch (vex.length)
11629 oappend ("QWORD PTR ");
11632 oappend ("XMMWORD PTR ");
11642 switch (vex.length)
11645 oappend ("QWORD PTR ");
11648 oappend ("YMMWORD PTR ");
11655 oappend ("OWORD PTR ");
11657 case vex_w_dq_mode:
11662 oappend ("QWORD PTR ");
11664 oappend ("DWORD PTR ");
11672 OP_E_register (int bytemode, int sizeflag)
11674 int reg = modrm.rm;
11675 const char **names;
11681 if ((sizeflag & SUFFIX_ALWAYS)
11682 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
11705 names = address_mode == mode_64bit ? names64 : names32;
11708 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11711 used_prefixes |= (prefixes & PREFIX_DATA);
11725 else if ((sizeflag & DFLAG)
11726 || (bytemode != v_mode
11727 && bytemode != v_swap_mode))
11731 used_prefixes |= (prefixes & PREFIX_DATA);
11736 oappend (INTERNAL_DISASSEMBLER_ERROR);
11739 oappend (names[reg]);
11743 OP_E_memory (int bytemode, int sizeflag)
11746 int add = (rex & REX_B) ? 8 : 0;
11751 intel_operand_size (bytemode, sizeflag);
11754 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
11756 /* 32/64 bit address mode */
11774 FETCH_DATA (the_info, codep + 1);
11775 index = (*codep >> 3) & 7;
11776 scale = (*codep >> 6) & 3;
11781 haveindex = index != 4;
11784 rbase = base + add;
11792 if (address_mode == mode_64bit && !havesib)
11798 FETCH_DATA (the_info, codep + 1);
11800 if ((disp & 0x80) != 0)
11808 /* In 32bit mode, we need index register to tell [offset] from
11809 [eiz*1 + offset]. */
11810 needindex = (havesib
11813 && address_mode == mode_32bit);
11814 havedisp = (havebase
11816 || (havesib && (haveindex || scale != 0)));
11819 if (modrm.mod != 0 || base == 5)
11821 if (havedisp || riprel)
11822 print_displacement (scratchbuf, disp);
11824 print_operand_value (scratchbuf, 1, disp);
11825 oappend (scratchbuf);
11829 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
11833 if (havebase || haveindex || riprel)
11834 used_prefixes |= PREFIX_ADDR;
11836 if (havedisp || (intel_syntax && riprel))
11838 *obufp++ = open_char;
11839 if (intel_syntax && riprel)
11842 oappend (sizeflag & AFLAG ? "rip" : "eip");
11846 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
11847 ? names64[rbase] : names32[rbase]);
11850 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
11851 print index to tell base + index from base. */
11855 || (havebase && base != ESP_REG_NUM))
11857 if (!intel_syntax || havebase)
11859 *obufp++ = separator_char;
11863 oappend (address_mode == mode_64bit
11864 && (sizeflag & AFLAG)
11865 ? names64[index] : names32[index]);
11867 oappend (address_mode == mode_64bit
11868 && (sizeflag & AFLAG)
11869 ? index64 : index32);
11871 *obufp++ = scale_char;
11873 sprintf (scratchbuf, "%d", 1 << scale);
11874 oappend (scratchbuf);
11878 && (disp || modrm.mod != 0 || base == 5))
11880 if (!havedisp || (bfd_signed_vma) disp >= 0)
11885 else if (modrm.mod != 1 && disp != -disp)
11889 disp = - (bfd_signed_vma) disp;
11893 print_displacement (scratchbuf, disp);
11895 print_operand_value (scratchbuf, 1, disp);
11896 oappend (scratchbuf);
11899 *obufp++ = close_char;
11902 else if (intel_syntax)
11904 if (modrm.mod != 0 || base == 5)
11906 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
11907 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
11911 oappend (names_seg[ds_reg - es_reg]);
11914 print_operand_value (scratchbuf, 1, disp);
11915 oappend (scratchbuf);
11920 { /* 16 bit address mode */
11927 if ((disp & 0x8000) != 0)
11932 FETCH_DATA (the_info, codep + 1);
11934 if ((disp & 0x80) != 0)
11939 if ((disp & 0x8000) != 0)
11945 if (modrm.mod != 0 || modrm.rm == 6)
11947 print_displacement (scratchbuf, disp);
11948 oappend (scratchbuf);
11951 if (modrm.mod != 0 || modrm.rm != 6)
11953 *obufp++ = open_char;
11955 oappend (index16[modrm.rm]);
11957 && (disp || modrm.mod != 0 || modrm.rm == 6))
11959 if ((bfd_signed_vma) disp >= 0)
11964 else if (modrm.mod != 1)
11968 disp = - (bfd_signed_vma) disp;
11971 print_displacement (scratchbuf, disp);
11972 oappend (scratchbuf);
11975 *obufp++ = close_char;
11978 else if (intel_syntax)
11980 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
11981 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
11985 oappend (names_seg[ds_reg - es_reg]);
11988 print_operand_value (scratchbuf, 1, disp & 0xffff);
11989 oappend (scratchbuf);
11995 OP_E_extended (int bytemode, int sizeflag)
11997 /* Skip mod/rm byte. */
12001 if (modrm.mod == 3)
12002 OP_E_register (bytemode, sizeflag);
12004 OP_E_memory (bytemode, sizeflag);
12008 OP_E (int bytemode, int sizeflag)
12010 OP_E_extended (bytemode, sizeflag);
12015 OP_G (int bytemode, int sizeflag)
12026 oappend (names8rex[modrm.reg + add]);
12028 oappend (names8[modrm.reg + add]);
12031 oappend (names16[modrm.reg + add]);
12034 oappend (names32[modrm.reg + add]);
12037 oappend (names64[modrm.reg + add]);
12046 oappend (names64[modrm.reg + add]);
12047 else if ((sizeflag & DFLAG) || bytemode != v_mode)
12048 oappend (names32[modrm.reg + add]);
12050 oappend (names16[modrm.reg + add]);
12051 used_prefixes |= (prefixes & PREFIX_DATA);
12054 if (address_mode == mode_64bit)
12055 oappend (names64[modrm.reg + add]);
12057 oappend (names32[modrm.reg + add]);
12060 oappend (INTERNAL_DISASSEMBLER_ERROR);
12073 FETCH_DATA (the_info, codep + 8);
12074 a = *codep++ & 0xff;
12075 a |= (*codep++ & 0xff) << 8;
12076 a |= (*codep++ & 0xff) << 16;
12077 a |= (*codep++ & 0xff) << 24;
12078 b = *codep++ & 0xff;
12079 b |= (*codep++ & 0xff) << 8;
12080 b |= (*codep++ & 0xff) << 16;
12081 b |= (*codep++ & 0xff) << 24;
12082 x = a + ((bfd_vma) b << 32);
12090 static bfd_signed_vma
12093 bfd_signed_vma x = 0;
12095 FETCH_DATA (the_info, codep + 4);
12096 x = *codep++ & (bfd_signed_vma) 0xff;
12097 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12098 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12099 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12103 static bfd_signed_vma
12106 bfd_signed_vma x = 0;
12108 FETCH_DATA (the_info, codep + 4);
12109 x = *codep++ & (bfd_signed_vma) 0xff;
12110 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12111 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12112 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12114 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
12124 FETCH_DATA (the_info, codep + 2);
12125 x = *codep++ & 0xff;
12126 x |= (*codep++ & 0xff) << 8;
12131 set_op (bfd_vma op, int riprel)
12133 op_index[op_ad] = op_ad;
12134 if (address_mode == mode_64bit)
12136 op_address[op_ad] = op;
12137 op_riprel[op_ad] = riprel;
12141 /* Mask to get a 32-bit address. */
12142 op_address[op_ad] = op & 0xffffffff;
12143 op_riprel[op_ad] = riprel & 0xffffffff;
12148 OP_REG (int code, int sizeflag)
12160 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12161 case sp_reg: case bp_reg: case si_reg: case di_reg:
12162 s = names16[code - ax_reg + add];
12164 case es_reg: case ss_reg: case cs_reg:
12165 case ds_reg: case fs_reg: case gs_reg:
12166 s = names_seg[code - es_reg + add];
12168 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12169 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12172 s = names8rex[code - al_reg + add];
12174 s = names8[code - al_reg];
12176 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
12177 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
12178 if (address_mode == mode_64bit && (sizeflag & DFLAG))
12180 s = names64[code - rAX_reg + add];
12183 code += eAX_reg - rAX_reg;
12184 /* Fall through. */
12185 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12186 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12189 s = names64[code - eAX_reg + add];
12190 else if (sizeflag & DFLAG)
12191 s = names32[code - eAX_reg + add];
12193 s = names16[code - eAX_reg + add];
12194 used_prefixes |= (prefixes & PREFIX_DATA);
12197 s = INTERNAL_DISASSEMBLER_ERROR;
12204 OP_IMREG (int code, int sizeflag)
12216 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12217 case sp_reg: case bp_reg: case si_reg: case di_reg:
12218 s = names16[code - ax_reg];
12220 case es_reg: case ss_reg: case cs_reg:
12221 case ds_reg: case fs_reg: case gs_reg:
12222 s = names_seg[code - es_reg];
12224 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12225 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12228 s = names8rex[code - al_reg];
12230 s = names8[code - al_reg];
12232 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12233 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12236 s = names64[code - eAX_reg];
12237 else if (sizeflag & DFLAG)
12238 s = names32[code - eAX_reg];
12240 s = names16[code - eAX_reg];
12241 used_prefixes |= (prefixes & PREFIX_DATA);
12243 case z_mode_ax_reg:
12244 if ((rex & REX_W) || (sizeflag & DFLAG))
12248 if (!(rex & REX_W))
12249 used_prefixes |= (prefixes & PREFIX_DATA);
12252 s = INTERNAL_DISASSEMBLER_ERROR;
12259 OP_I (int bytemode, int sizeflag)
12262 bfd_signed_vma mask = -1;
12267 FETCH_DATA (the_info, codep + 1);
12272 if (address_mode == mode_64bit)
12277 /* Fall through. */
12282 else if (sizeflag & DFLAG)
12292 used_prefixes |= (prefixes & PREFIX_DATA);
12303 oappend (INTERNAL_DISASSEMBLER_ERROR);
12308 scratchbuf[0] = '$';
12309 print_operand_value (scratchbuf + 1, 1, op);
12310 oappend (scratchbuf + intel_syntax);
12311 scratchbuf[0] = '\0';
12315 OP_I64 (int bytemode, int sizeflag)
12318 bfd_signed_vma mask = -1;
12320 if (address_mode != mode_64bit)
12322 OP_I (bytemode, sizeflag);
12329 FETCH_DATA (the_info, codep + 1);
12337 else if (sizeflag & DFLAG)
12347 used_prefixes |= (prefixes & PREFIX_DATA);
12354 oappend (INTERNAL_DISASSEMBLER_ERROR);
12359 scratchbuf[0] = '$';
12360 print_operand_value (scratchbuf + 1, 1, op);
12361 oappend (scratchbuf + intel_syntax);
12362 scratchbuf[0] = '\0';
12366 OP_sI (int bytemode, int sizeflag)
12369 bfd_signed_vma mask = -1;
12374 FETCH_DATA (the_info, codep + 1);
12376 if ((op & 0x80) != 0)
12384 else if (sizeflag & DFLAG)
12393 if ((op & 0x8000) != 0)
12396 used_prefixes |= (prefixes & PREFIX_DATA);
12401 if ((op & 0x8000) != 0)
12405 oappend (INTERNAL_DISASSEMBLER_ERROR);
12409 scratchbuf[0] = '$';
12410 print_operand_value (scratchbuf + 1, 1, op);
12411 oappend (scratchbuf + intel_syntax);
12415 OP_J (int bytemode, int sizeflag)
12419 bfd_vma segment = 0;
12424 FETCH_DATA (the_info, codep + 1);
12426 if ((disp & 0x80) != 0)
12430 if ((sizeflag & DFLAG) || (rex & REX_W))
12435 if ((disp & 0x8000) != 0)
12437 /* In 16bit mode, address is wrapped around at 64k within
12438 the same segment. Otherwise, a data16 prefix on a jump
12439 instruction means that the pc is masked to 16 bits after
12440 the displacement is added! */
12442 if ((prefixes & PREFIX_DATA) == 0)
12443 segment = ((start_pc + codep - start_codep)
12444 & ~((bfd_vma) 0xffff));
12446 used_prefixes |= (prefixes & PREFIX_DATA);
12449 oappend (INTERNAL_DISASSEMBLER_ERROR);
12452 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
12454 print_operand_value (scratchbuf, 1, disp);
12455 oappend (scratchbuf);
12459 OP_SEG (int bytemode, int sizeflag)
12461 if (bytemode == w_mode)
12462 oappend (names_seg[modrm.reg]);
12464 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
12468 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
12472 if (sizeflag & DFLAG)
12482 used_prefixes |= (prefixes & PREFIX_DATA);
12484 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
12486 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
12487 oappend (scratchbuf);
12491 OP_OFF (int bytemode, int sizeflag)
12495 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12496 intel_operand_size (bytemode, sizeflag);
12499 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12506 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12507 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12509 oappend (names_seg[ds_reg - es_reg]);
12513 print_operand_value (scratchbuf, 1, off);
12514 oappend (scratchbuf);
12518 OP_OFF64 (int bytemode, int sizeflag)
12522 if (address_mode != mode_64bit
12523 || (prefixes & PREFIX_ADDR))
12525 OP_OFF (bytemode, sizeflag);
12529 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12530 intel_operand_size (bytemode, sizeflag);
12537 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12538 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12540 oappend (names_seg[ds_reg - es_reg]);
12544 print_operand_value (scratchbuf, 1, off);
12545 oappend (scratchbuf);
12549 ptr_reg (int code, int sizeflag)
12553 *obufp++ = open_char;
12554 used_prefixes |= (prefixes & PREFIX_ADDR);
12555 if (address_mode == mode_64bit)
12557 if (!(sizeflag & AFLAG))
12558 s = names32[code - eAX_reg];
12560 s = names64[code - eAX_reg];
12562 else if (sizeflag & AFLAG)
12563 s = names32[code - eAX_reg];
12565 s = names16[code - eAX_reg];
12567 *obufp++ = close_char;
12572 OP_ESreg (int code, int sizeflag)
12578 case 0x6d: /* insw/insl */
12579 intel_operand_size (z_mode, sizeflag);
12581 case 0xa5: /* movsw/movsl/movsq */
12582 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12583 case 0xab: /* stosw/stosl */
12584 case 0xaf: /* scasw/scasl */
12585 intel_operand_size (v_mode, sizeflag);
12588 intel_operand_size (b_mode, sizeflag);
12591 oappend ("%es:" + intel_syntax);
12592 ptr_reg (code, sizeflag);
12596 OP_DSreg (int code, int sizeflag)
12602 case 0x6f: /* outsw/outsl */
12603 intel_operand_size (z_mode, sizeflag);
12605 case 0xa5: /* movsw/movsl/movsq */
12606 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12607 case 0xad: /* lodsw/lodsl/lodsq */
12608 intel_operand_size (v_mode, sizeflag);
12611 intel_operand_size (b_mode, sizeflag);
12620 | PREFIX_GS)) == 0)
12621 prefixes |= PREFIX_DS;
12623 ptr_reg (code, sizeflag);
12627 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12635 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
12637 lock_prefix = NULL;
12638 used_prefixes |= PREFIX_LOCK;
12643 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
12644 oappend (scratchbuf + intel_syntax);
12648 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12657 sprintf (scratchbuf, "db%d", modrm.reg + add);
12659 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
12660 oappend (scratchbuf);
12664 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12666 sprintf (scratchbuf, "%%tr%d", modrm.reg);
12667 oappend (scratchbuf + intel_syntax);
12671 OP_R (int bytemode, int sizeflag)
12673 if (modrm.mod == 3)
12674 OP_E (bytemode, sizeflag);
12680 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12682 used_prefixes |= (prefixes & PREFIX_DATA);
12683 if (prefixes & PREFIX_DATA)
12691 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12694 sprintf (scratchbuf, "%%mm%d", modrm.reg);
12695 oappend (scratchbuf + intel_syntax);
12699 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
12707 if (need_vex && bytemode != xmm_mode)
12709 switch (vex.length)
12712 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12715 sprintf (scratchbuf, "%%ymm%d", modrm.reg + add);
12722 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12723 oappend (scratchbuf + intel_syntax);
12727 OP_EM (int bytemode, int sizeflag)
12729 if (modrm.mod != 3)
12732 && (bytemode == v_mode || bytemode == v_swap_mode))
12734 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
12735 used_prefixes |= (prefixes & PREFIX_DATA);
12737 OP_E (bytemode, sizeflag);
12741 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
12744 /* Skip mod/rm byte. */
12747 used_prefixes |= (prefixes & PREFIX_DATA);
12748 if (prefixes & PREFIX_DATA)
12757 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12760 sprintf (scratchbuf, "%%mm%d", modrm.rm);
12761 oappend (scratchbuf + intel_syntax);
12764 /* cvt* are the only instructions in sse2 which have
12765 both SSE and MMX operands and also have 0x66 prefix
12766 in their opcode. 0x66 was originally used to differentiate
12767 between SSE and MMX instruction(operands). So we have to handle the
12768 cvt* separately using OP_EMC and OP_MXC */
12770 OP_EMC (int bytemode, int sizeflag)
12772 if (modrm.mod != 3)
12774 if (intel_syntax && bytemode == v_mode)
12776 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
12777 used_prefixes |= (prefixes & PREFIX_DATA);
12779 OP_E (bytemode, sizeflag);
12783 /* Skip mod/rm byte. */
12786 used_prefixes |= (prefixes & PREFIX_DATA);
12787 sprintf (scratchbuf, "%%mm%d", modrm.rm);
12788 oappend (scratchbuf + intel_syntax);
12792 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12794 used_prefixes |= (prefixes & PREFIX_DATA);
12795 sprintf (scratchbuf, "%%mm%d", modrm.reg);
12796 oappend (scratchbuf + intel_syntax);
12800 OP_EX (int bytemode, int sizeflag)
12804 /* Skip mod/rm byte. */
12808 if (modrm.mod != 3)
12810 OP_E_memory (bytemode, sizeflag);
12820 if ((sizeflag & SUFFIX_ALWAYS)
12821 && (bytemode == x_swap_mode
12822 || bytemode == d_swap_mode
12823 || bytemode == q_swap_mode))
12827 && bytemode != xmm_mode
12828 && bytemode != xmmq_mode)
12830 switch (vex.length)
12833 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12836 sprintf (scratchbuf, "%%ymm%d", modrm.rm + add);
12843 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12844 oappend (scratchbuf + intel_syntax);
12848 OP_MS (int bytemode, int sizeflag)
12850 if (modrm.mod == 3)
12851 OP_EM (bytemode, sizeflag);
12857 OP_XS (int bytemode, int sizeflag)
12859 if (modrm.mod == 3)
12860 OP_EX (bytemode, sizeflag);
12866 OP_M (int bytemode, int sizeflag)
12868 if (modrm.mod == 3)
12869 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
12872 OP_E (bytemode, sizeflag);
12876 OP_0f07 (int bytemode, int sizeflag)
12878 if (modrm.mod != 3 || modrm.rm != 0)
12881 OP_E (bytemode, sizeflag);
12884 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
12885 32bit mode and "xchg %rax,%rax" in 64bit mode. */
12888 NOP_Fixup1 (int bytemode, int sizeflag)
12890 if ((prefixes & PREFIX_DATA) != 0
12893 && address_mode == mode_64bit))
12894 OP_REG (bytemode, sizeflag);
12896 strcpy (obuf, "nop");
12900 NOP_Fixup2 (int bytemode, int sizeflag)
12902 if ((prefixes & PREFIX_DATA) != 0
12905 && address_mode == mode_64bit))
12906 OP_IMREG (bytemode, sizeflag);
12909 static const char *const Suffix3DNow[] = {
12910 /* 00 */ NULL, NULL, NULL, NULL,
12911 /* 04 */ NULL, NULL, NULL, NULL,
12912 /* 08 */ NULL, NULL, NULL, NULL,
12913 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
12914 /* 10 */ NULL, NULL, NULL, NULL,
12915 /* 14 */ NULL, NULL, NULL, NULL,
12916 /* 18 */ NULL, NULL, NULL, NULL,
12917 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
12918 /* 20 */ NULL, NULL, NULL, NULL,
12919 /* 24 */ NULL, NULL, NULL, NULL,
12920 /* 28 */ NULL, NULL, NULL, NULL,
12921 /* 2C */ NULL, NULL, NULL, NULL,
12922 /* 30 */ NULL, NULL, NULL, NULL,
12923 /* 34 */ NULL, NULL, NULL, NULL,
12924 /* 38 */ NULL, NULL, NULL, NULL,
12925 /* 3C */ NULL, NULL, NULL, NULL,
12926 /* 40 */ NULL, NULL, NULL, NULL,
12927 /* 44 */ NULL, NULL, NULL, NULL,
12928 /* 48 */ NULL, NULL, NULL, NULL,
12929 /* 4C */ NULL, NULL, NULL, NULL,
12930 /* 50 */ NULL, NULL, NULL, NULL,
12931 /* 54 */ NULL, NULL, NULL, NULL,
12932 /* 58 */ NULL, NULL, NULL, NULL,
12933 /* 5C */ NULL, NULL, NULL, NULL,
12934 /* 60 */ NULL, NULL, NULL, NULL,
12935 /* 64 */ NULL, NULL, NULL, NULL,
12936 /* 68 */ NULL, NULL, NULL, NULL,
12937 /* 6C */ NULL, NULL, NULL, NULL,
12938 /* 70 */ NULL, NULL, NULL, NULL,
12939 /* 74 */ NULL, NULL, NULL, NULL,
12940 /* 78 */ NULL, NULL, NULL, NULL,
12941 /* 7C */ NULL, NULL, NULL, NULL,
12942 /* 80 */ NULL, NULL, NULL, NULL,
12943 /* 84 */ NULL, NULL, NULL, NULL,
12944 /* 88 */ NULL, NULL, "pfnacc", NULL,
12945 /* 8C */ NULL, NULL, "pfpnacc", NULL,
12946 /* 90 */ "pfcmpge", NULL, NULL, NULL,
12947 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
12948 /* 98 */ NULL, NULL, "pfsub", NULL,
12949 /* 9C */ NULL, NULL, "pfadd", NULL,
12950 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
12951 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
12952 /* A8 */ NULL, NULL, "pfsubr", NULL,
12953 /* AC */ NULL, NULL, "pfacc", NULL,
12954 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
12955 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
12956 /* B8 */ NULL, NULL, NULL, "pswapd",
12957 /* BC */ NULL, NULL, NULL, "pavgusb",
12958 /* C0 */ NULL, NULL, NULL, NULL,
12959 /* C4 */ NULL, NULL, NULL, NULL,
12960 /* C8 */ NULL, NULL, NULL, NULL,
12961 /* CC */ NULL, NULL, NULL, NULL,
12962 /* D0 */ NULL, NULL, NULL, NULL,
12963 /* D4 */ NULL, NULL, NULL, NULL,
12964 /* D8 */ NULL, NULL, NULL, NULL,
12965 /* DC */ NULL, NULL, NULL, NULL,
12966 /* E0 */ NULL, NULL, NULL, NULL,
12967 /* E4 */ NULL, NULL, NULL, NULL,
12968 /* E8 */ NULL, NULL, NULL, NULL,
12969 /* EC */ NULL, NULL, NULL, NULL,
12970 /* F0 */ NULL, NULL, NULL, NULL,
12971 /* F4 */ NULL, NULL, NULL, NULL,
12972 /* F8 */ NULL, NULL, NULL, NULL,
12973 /* FC */ NULL, NULL, NULL, NULL,
12977 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12979 const char *mnemonic;
12981 FETCH_DATA (the_info, codep + 1);
12982 /* AMD 3DNow! instructions are specified by an opcode suffix in the
12983 place where an 8-bit immediate would normally go. ie. the last
12984 byte of the instruction. */
12985 obufp = mnemonicendp;
12986 mnemonic = Suffix3DNow[*codep++ & 0xff];
12988 oappend (mnemonic);
12991 /* Since a variable sized modrm/sib chunk is between the start
12992 of the opcode (0x0f0f) and the opcode suffix, we need to do
12993 all the modrm processing first, and don't know until now that
12994 we have a bad opcode. This necessitates some cleaning up. */
12995 op_out[0][0] = '\0';
12996 op_out[1][0] = '\0';
12999 mnemonicendp = obufp;
13002 static struct op simd_cmp_op[] =
13004 { STRING_COMMA_LEN ("eq") },
13005 { STRING_COMMA_LEN ("lt") },
13006 { STRING_COMMA_LEN ("le") },
13007 { STRING_COMMA_LEN ("unord") },
13008 { STRING_COMMA_LEN ("neq") },
13009 { STRING_COMMA_LEN ("nlt") },
13010 { STRING_COMMA_LEN ("nle") },
13011 { STRING_COMMA_LEN ("ord") }
13015 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13017 unsigned int cmp_type;
13019 FETCH_DATA (the_info, codep + 1);
13020 cmp_type = *codep++ & 0xff;
13021 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
13024 char *p = mnemonicendp - 2;
13028 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
13029 mnemonicendp += simd_cmp_op[cmp_type].len;
13033 /* We have a reserved extension byte. Output it directly. */
13034 scratchbuf[0] = '$';
13035 print_operand_value (scratchbuf + 1, 1, cmp_type);
13036 oappend (scratchbuf + intel_syntax);
13037 scratchbuf[0] = '\0';
13042 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
13043 int sizeflag ATTRIBUTE_UNUSED)
13045 /* mwait %eax,%ecx */
13048 const char **names = (address_mode == mode_64bit
13049 ? names64 : names32);
13050 strcpy (op_out[0], names[0]);
13051 strcpy (op_out[1], names[1]);
13052 two_source_ops = 1;
13054 /* Skip mod/rm byte. */
13060 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
13061 int sizeflag ATTRIBUTE_UNUSED)
13063 /* monitor %eax,%ecx,%edx" */
13066 const char **op1_names;
13067 const char **names = (address_mode == mode_64bit
13068 ? names64 : names32);
13070 if (!(prefixes & PREFIX_ADDR))
13071 op1_names = (address_mode == mode_16bit
13072 ? names16 : names);
13075 /* Remove "addr16/addr32". */
13076 addr_prefix = NULL;
13077 op1_names = (address_mode != mode_32bit
13078 ? names32 : names16);
13079 used_prefixes |= PREFIX_ADDR;
13081 strcpy (op_out[0], op1_names[0]);
13082 strcpy (op_out[1], names[1]);
13083 strcpy (op_out[2], names[2]);
13084 two_source_ops = 1;
13086 /* Skip mod/rm byte. */
13094 /* Throw away prefixes and 1st. opcode byte. */
13095 codep = insn_codep + 1;
13100 REP_Fixup (int bytemode, int sizeflag)
13102 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13104 if (prefixes & PREFIX_REPZ)
13105 repz_prefix = "rep ";
13112 OP_IMREG (bytemode, sizeflag);
13115 OP_ESreg (bytemode, sizeflag);
13118 OP_DSreg (bytemode, sizeflag);
13127 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
13132 /* Change cmpxchg8b to cmpxchg16b. */
13133 char *p = mnemonicendp - 2;
13134 mnemonicendp = stpcpy (p, "16b");
13137 OP_M (bytemode, sizeflag);
13141 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
13145 switch (vex.length)
13148 sprintf (scratchbuf, "%%xmm%d", reg);
13151 sprintf (scratchbuf, "%%ymm%d", reg);
13158 sprintf (scratchbuf, "%%xmm%d", reg);
13159 oappend (scratchbuf + intel_syntax);
13163 CRC32_Fixup (int bytemode, int sizeflag)
13165 /* Add proper suffix to "crc32". */
13166 char *p = mnemonicendp;
13183 else if (sizeflag & DFLAG)
13187 used_prefixes |= (prefixes & PREFIX_DATA);
13190 oappend (INTERNAL_DISASSEMBLER_ERROR);
13197 if (modrm.mod == 3)
13201 /* Skip mod/rm byte. */
13206 add = (rex & REX_B) ? 8 : 0;
13207 if (bytemode == b_mode)
13211 oappend (names8rex[modrm.rm + add]);
13213 oappend (names8[modrm.rm + add]);
13219 oappend (names64[modrm.rm + add]);
13220 else if ((prefixes & PREFIX_DATA))
13221 oappend (names16[modrm.rm + add]);
13223 oappend (names32[modrm.rm + add]);
13227 OP_E (bytemode, sizeflag);
13230 /* Display the destination register operand for instructions with
13234 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13242 switch (vex.length)
13255 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
13268 sprintf (scratchbuf, "%%ymm%d", vex.register_specifier);
13274 oappend (scratchbuf + intel_syntax);
13277 /* Get the VEX immediate byte without moving codep. */
13279 static unsigned char
13280 get_vex_imm8 (int sizeflag)
13282 int bytes_before_imm = 0;
13284 /* Skip mod/rm byte. */
13288 if (modrm.mod != 3)
13290 /* There are SIB/displacement bytes. */
13291 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13293 /* 32/64 bit address mode */
13294 int base = modrm.rm;
13296 /* Check SIB byte. */
13299 FETCH_DATA (the_info, codep + 1);
13301 bytes_before_imm++;
13307 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13308 SIB == 5, there is a 4 byte displacement. */
13310 /* No displacement. */
13313 /* 4 byte displacement. */
13314 bytes_before_imm += 4;
13317 /* 1 byte displacement. */
13318 bytes_before_imm++;
13323 { /* 16 bit address mode */
13327 /* When modrm.rm == 6, there is a 2 byte displacement. */
13329 /* No displacement. */
13332 /* 2 byte displacement. */
13333 bytes_before_imm += 2;
13336 /* 1 byte displacement. */
13337 bytes_before_imm++;
13343 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
13344 return codep [bytes_before_imm];
13348 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
13350 if (reg == -1 && modrm.mod != 3)
13352 OP_E_memory (bytemode, sizeflag);
13364 else if (reg > 7 && address_mode != mode_64bit)
13368 switch (vex.length)
13371 sprintf (scratchbuf, "%%xmm%d", reg);
13374 sprintf (scratchbuf, "%%ymm%d", reg);
13379 oappend (scratchbuf + intel_syntax);
13383 OP_EX_VexW (int bytemode, int sizeflag)
13391 reg = get_vex_imm8 (sizeflag) >> 4;
13396 reg = get_vex_imm8 (sizeflag) >> 4;
13399 OP_EX_VexReg (bytemode, sizeflag, reg);
13403 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
13404 int sizeflag ATTRIBUTE_UNUSED)
13406 /* Skip the immediate byte and check for invalid bits. */
13407 FETCH_DATA (the_info, codep + 1);
13408 if (*codep++ & 0xf)
13413 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13416 FETCH_DATA (the_info, codep + 1);
13419 if (bytemode != x_mode)
13426 if (reg > 7 && address_mode != mode_64bit)
13429 switch (vex.length)
13432 sprintf (scratchbuf, "%%xmm%d", reg);
13435 sprintf (scratchbuf, "%%ymm%d", reg);
13440 oappend (scratchbuf + intel_syntax);
13444 OP_XMM_VexW (int bytemode, int sizeflag)
13446 /* Turn off the REX.W bit since it is used for swapping operands
13449 OP_XMM (bytemode, sizeflag);
13453 OP_EX_Vex (int bytemode, int sizeflag)
13455 if (modrm.mod != 3)
13457 if (vex.register_specifier != 0)
13461 OP_EX (bytemode, sizeflag);
13465 OP_XMM_Vex (int bytemode, int sizeflag)
13467 if (modrm.mod != 3)
13469 if (vex.register_specifier != 0)
13473 OP_XMM (bytemode, sizeflag);
13477 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13479 switch (vex.length)
13482 mnemonicendp = stpcpy (obuf, "vzeroupper");
13485 mnemonicendp = stpcpy (obuf, "vzeroall");
13492 static struct op vex_cmp_op[] =
13494 { STRING_COMMA_LEN ("eq") },
13495 { STRING_COMMA_LEN ("lt") },
13496 { STRING_COMMA_LEN ("le") },
13497 { STRING_COMMA_LEN ("unord") },
13498 { STRING_COMMA_LEN ("neq") },
13499 { STRING_COMMA_LEN ("nlt") },
13500 { STRING_COMMA_LEN ("nle") },
13501 { STRING_COMMA_LEN ("ord") },
13502 { STRING_COMMA_LEN ("eq_uq") },
13503 { STRING_COMMA_LEN ("nge") },
13504 { STRING_COMMA_LEN ("ngt") },
13505 { STRING_COMMA_LEN ("false") },
13506 { STRING_COMMA_LEN ("neq_oq") },
13507 { STRING_COMMA_LEN ("ge") },
13508 { STRING_COMMA_LEN ("gt") },
13509 { STRING_COMMA_LEN ("true") },
13510 { STRING_COMMA_LEN ("eq_os") },
13511 { STRING_COMMA_LEN ("lt_oq") },
13512 { STRING_COMMA_LEN ("le_oq") },
13513 { STRING_COMMA_LEN ("unord_s") },
13514 { STRING_COMMA_LEN ("neq_us") },
13515 { STRING_COMMA_LEN ("nlt_uq") },
13516 { STRING_COMMA_LEN ("nle_uq") },
13517 { STRING_COMMA_LEN ("ord_s") },
13518 { STRING_COMMA_LEN ("eq_us") },
13519 { STRING_COMMA_LEN ("nge_uq") },
13520 { STRING_COMMA_LEN ("ngt_uq") },
13521 { STRING_COMMA_LEN ("false_os") },
13522 { STRING_COMMA_LEN ("neq_os") },
13523 { STRING_COMMA_LEN ("ge_oq") },
13524 { STRING_COMMA_LEN ("gt_oq") },
13525 { STRING_COMMA_LEN ("true_us") },
13529 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13531 unsigned int cmp_type;
13533 FETCH_DATA (the_info, codep + 1);
13534 cmp_type = *codep++ & 0xff;
13535 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
13538 char *p = mnemonicendp - 2;
13542 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
13543 mnemonicendp += vex_cmp_op[cmp_type].len;
13547 /* We have a reserved extension byte. Output it directly. */
13548 scratchbuf[0] = '$';
13549 print_operand_value (scratchbuf + 1, 1, cmp_type);
13550 oappend (scratchbuf + intel_syntax);
13551 scratchbuf[0] = '\0';
13555 static const struct op pclmul_op[] =
13557 { STRING_COMMA_LEN ("lql") },
13558 { STRING_COMMA_LEN ("hql") },
13559 { STRING_COMMA_LEN ("lqh") },
13560 { STRING_COMMA_LEN ("hqh") }
13564 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
13565 int sizeflag ATTRIBUTE_UNUSED)
13567 unsigned int pclmul_type;
13569 FETCH_DATA (the_info, codep + 1);
13570 pclmul_type = *codep++ & 0xff;
13571 switch (pclmul_type)
13582 if (pclmul_type < ARRAY_SIZE (pclmul_op))
13585 char *p = mnemonicendp - 3;
13590 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
13591 mnemonicendp += pclmul_op[pclmul_type].len;
13595 /* We have a reserved extension byte. Output it directly. */
13596 scratchbuf[0] = '$';
13597 print_operand_value (scratchbuf + 1, 1, pclmul_type);
13598 oappend (scratchbuf + intel_syntax);
13599 scratchbuf[0] = '\0';
13604 MOVBE_Fixup (int bytemode, int sizeflag)
13606 /* Add proper suffix to "movbe". */
13607 char *p = mnemonicendp;
13616 if (sizeflag & SUFFIX_ALWAYS)
13620 else if (sizeflag & DFLAG)
13625 used_prefixes |= (prefixes & PREFIX_DATA);
13628 oappend (INTERNAL_DISASSEMBLER_ERROR);
13635 OP_M (bytemode, sizeflag);
13639 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13642 const char **names;
13644 /* Skip mod/rm byte. */
13650 else if (vex.length == 256)
13660 oappend (names[reg]);
13664 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13666 const char **names;
13670 else if (vex.length == 256)
13675 oappend (names[vex.register_specifier]);
13679 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
13681 if (vex.w || vex.length == 256)
13682 OP_I (q_mode, sizeflag);
13684 OP_I (w_mode, sizeflag);