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. */
30 /* The main tables describing the instructions is essentially a copy
31 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
32 Programmers Manual. Usually, there is a capital letter, followed
33 by a small letter. The capital letter tell the addressing mode,
34 and the small letter tells about the operand size. Refer to
35 the Intel manual for details. */
40 #include "opcode/i386.h"
41 #include "libiberty.h"
45 static int print_insn (bfd_vma, disassemble_info *);
46 static void dofloat (int);
47 static void OP_ST (int, int);
48 static void OP_STi (int, int);
49 static int putop (const char *, int);
50 static void oappend (const char *);
51 static void append_seg (void);
52 static void OP_indirE (int, int);
53 static void print_operand_value (char *, int, bfd_vma);
54 static void OP_E_register (int, int);
55 static void OP_E_memory (int, int);
56 static void print_displacement (char *, bfd_vma);
57 static void OP_E (int, int);
58 static void OP_G (int, int);
59 static bfd_vma get64 (void);
60 static bfd_signed_vma get32 (void);
61 static bfd_signed_vma get32s (void);
62 static int get16 (void);
63 static void set_op (bfd_vma, int);
64 static void OP_Skip_MODRM (int, int);
65 static void OP_REG (int, int);
66 static void OP_IMREG (int, int);
67 static void OP_I (int, int);
68 static void OP_I64 (int, int);
69 static void OP_sI (int, int);
70 static void OP_J (int, int);
71 static void OP_SEG (int, int);
72 static void OP_DIR (int, int);
73 static void OP_OFF (int, int);
74 static void OP_OFF64 (int, int);
75 static void ptr_reg (int, int);
76 static void OP_ESreg (int, int);
77 static void OP_DSreg (int, int);
78 static void OP_C (int, int);
79 static void OP_D (int, int);
80 static void OP_T (int, int);
81 static void OP_R (int, int);
82 static void OP_MMX (int, int);
83 static void OP_XMM (int, int);
84 static void OP_EM (int, int);
85 static void OP_EX (int, int);
86 static void OP_EMC (int,int);
87 static void OP_MXC (int,int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VEX (int, int);
92 static void OP_EX_Vex (int, int);
93 static void OP_EX_VexW (int, int);
94 static void OP_XMM_Vex (int, int);
95 static void OP_XMM_VexW (int, int);
96 static void OP_REG_VexI4 (int, int);
97 static void PCLMUL_Fixup (int, int);
98 static void VEXI4_Fixup (int, int);
99 static void VZERO_Fixup (int, int);
100 static void VCMP_Fixup (int, int);
101 static void OP_0f07 (int, int);
102 static void OP_Monitor (int, int);
103 static void OP_Mwait (int, int);
104 static void NOP_Fixup1 (int, int);
105 static void NOP_Fixup2 (int, int);
106 static void OP_3DNowSuffix (int, int);
107 static void CMP_Fixup (int, int);
108 static void BadOp (void);
109 static void REP_Fixup (int, int);
110 static void CMPXCHG8B_Fixup (int, int);
111 static void XMM_Fixup (int, int);
112 static void CRC32_Fixup (int, int);
113 static void OP_LWPCB_E (int, int);
114 static void OP_LWP_E (int, int);
115 static void OP_LWP_I (int, int);
117 static void MOVBE_Fixup (int, int);
120 /* Points to first byte not fetched. */
121 bfd_byte *max_fetched;
122 bfd_byte the_buffer[MAX_MNEM_SIZE];
135 enum address_mode address_mode;
137 /* Flags for the prefixes for the current instruction. See below. */
140 /* REX prefix the current instruction. See below. */
142 /* Bits of REX we've already used. */
144 /* Original REX prefix. */
145 static int rex_original;
146 /* REX bits in original REX prefix ignored. It may not be the same
147 as rex_original since some bits may not be ignored. */
148 static int rex_ignored;
149 /* Mark parts used in the REX prefix. When we are testing for
150 empty prefix (for 8bit register REX extension), just mask it
151 out. Otherwise test for REX bit is excuse for existence of REX
152 only in case value is nonzero. */
153 #define USED_REX(value) \
158 rex_used |= (value) | REX_OPCODE; \
161 rex_used |= REX_OPCODE; \
164 /* Flags for prefixes which we somehow handled when printing the
165 current instruction. */
166 static int used_prefixes;
168 /* Flags stored in PREFIXES. */
169 #define PREFIX_REPZ 1
170 #define PREFIX_REPNZ 2
171 #define PREFIX_LOCK 4
173 #define PREFIX_SS 0x10
174 #define PREFIX_DS 0x20
175 #define PREFIX_ES 0x40
176 #define PREFIX_FS 0x80
177 #define PREFIX_GS 0x100
178 #define PREFIX_DATA 0x200
179 #define PREFIX_ADDR 0x400
180 #define PREFIX_FWAIT 0x800
182 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
183 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
185 #define FETCH_DATA(info, addr) \
186 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
187 ? 1 : fetch_data ((info), (addr)))
190 fetch_data (struct disassemble_info *info, bfd_byte *addr)
193 struct dis_private *priv = (struct dis_private *) info->private_data;
194 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
196 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
197 status = (*info->read_memory_func) (start,
199 addr - priv->max_fetched,
205 /* If we did manage to read at least one byte, then
206 print_insn_i386 will do something sensible. Otherwise, print
207 an error. We do that here because this is where we know
209 if (priv->max_fetched == priv->the_buffer)
210 (*info->memory_error_func) (status, start, info);
211 longjmp (priv->bailout, 1);
214 priv->max_fetched = addr;
218 #define XX { NULL, 0 }
220 #define Eb { OP_E, b_mode }
221 #define EbS { OP_E, b_swap_mode }
222 #define Ev { OP_E, v_mode }
223 #define EvS { OP_E, v_swap_mode }
224 #define Ed { OP_E, d_mode }
225 #define Edq { OP_E, dq_mode }
226 #define Edqw { OP_E, dqw_mode }
227 #define Edqb { OP_E, dqb_mode }
228 #define Edqd { OP_E, dqd_mode }
229 #define Eq { OP_E, q_mode }
230 #define indirEv { OP_indirE, stack_v_mode }
231 #define indirEp { OP_indirE, f_mode }
232 #define stackEv { OP_E, stack_v_mode }
233 #define Em { OP_E, m_mode }
234 #define Ew { OP_E, w_mode }
235 #define M { OP_M, 0 } /* lea, lgdt, etc. */
236 #define Ma { OP_M, a_mode }
237 #define Mb { OP_M, b_mode }
238 #define Md { OP_M, d_mode }
239 #define Mo { OP_M, o_mode }
240 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
241 #define Mq { OP_M, q_mode }
242 #define Mx { OP_M, x_mode }
243 #define Mxmm { OP_M, xmm_mode }
244 #define Gb { OP_G, b_mode }
245 #define Gv { OP_G, v_mode }
246 #define Gd { OP_G, d_mode }
247 #define Gdq { OP_G, dq_mode }
248 #define Gm { OP_G, m_mode }
249 #define Gw { OP_G, w_mode }
250 #define Rd { OP_R, d_mode }
251 #define Rm { OP_R, m_mode }
252 #define Ib { OP_I, b_mode }
253 #define sIb { OP_sI, b_mode } /* sign extened byte */
254 #define Iv { OP_I, v_mode }
255 #define Iq { OP_I, q_mode }
256 #define Iv64 { OP_I64, v_mode }
257 #define Iw { OP_I, w_mode }
258 #define I1 { OP_I, const_1_mode }
259 #define Jb { OP_J, b_mode }
260 #define Jv { OP_J, v_mode }
261 #define Cm { OP_C, m_mode }
262 #define Dm { OP_D, m_mode }
263 #define Td { OP_T, d_mode }
264 #define Skip_MODRM { OP_Skip_MODRM, 0 }
266 #define RMeAX { OP_REG, eAX_reg }
267 #define RMeBX { OP_REG, eBX_reg }
268 #define RMeCX { OP_REG, eCX_reg }
269 #define RMeDX { OP_REG, eDX_reg }
270 #define RMeSP { OP_REG, eSP_reg }
271 #define RMeBP { OP_REG, eBP_reg }
272 #define RMeSI { OP_REG, eSI_reg }
273 #define RMeDI { OP_REG, eDI_reg }
274 #define RMrAX { OP_REG, rAX_reg }
275 #define RMrBX { OP_REG, rBX_reg }
276 #define RMrCX { OP_REG, rCX_reg }
277 #define RMrDX { OP_REG, rDX_reg }
278 #define RMrSP { OP_REG, rSP_reg }
279 #define RMrBP { OP_REG, rBP_reg }
280 #define RMrSI { OP_REG, rSI_reg }
281 #define RMrDI { OP_REG, rDI_reg }
282 #define RMAL { OP_REG, al_reg }
283 #define RMAL { OP_REG, al_reg }
284 #define RMCL { OP_REG, cl_reg }
285 #define RMDL { OP_REG, dl_reg }
286 #define RMBL { OP_REG, bl_reg }
287 #define RMAH { OP_REG, ah_reg }
288 #define RMCH { OP_REG, ch_reg }
289 #define RMDH { OP_REG, dh_reg }
290 #define RMBH { OP_REG, bh_reg }
291 #define RMAX { OP_REG, ax_reg }
292 #define RMDX { OP_REG, dx_reg }
294 #define eAX { OP_IMREG, eAX_reg }
295 #define eBX { OP_IMREG, eBX_reg }
296 #define eCX { OP_IMREG, eCX_reg }
297 #define eDX { OP_IMREG, eDX_reg }
298 #define eSP { OP_IMREG, eSP_reg }
299 #define eBP { OP_IMREG, eBP_reg }
300 #define eSI { OP_IMREG, eSI_reg }
301 #define eDI { OP_IMREG, eDI_reg }
302 #define AL { OP_IMREG, al_reg }
303 #define CL { OP_IMREG, cl_reg }
304 #define DL { OP_IMREG, dl_reg }
305 #define BL { OP_IMREG, bl_reg }
306 #define AH { OP_IMREG, ah_reg }
307 #define CH { OP_IMREG, ch_reg }
308 #define DH { OP_IMREG, dh_reg }
309 #define BH { OP_IMREG, bh_reg }
310 #define AX { OP_IMREG, ax_reg }
311 #define DX { OP_IMREG, dx_reg }
312 #define zAX { OP_IMREG, z_mode_ax_reg }
313 #define indirDX { OP_IMREG, indir_dx_reg }
315 #define Sw { OP_SEG, w_mode }
316 #define Sv { OP_SEG, v_mode }
317 #define Ap { OP_DIR, 0 }
318 #define Ob { OP_OFF64, b_mode }
319 #define Ov { OP_OFF64, v_mode }
320 #define Xb { OP_DSreg, eSI_reg }
321 #define Xv { OP_DSreg, eSI_reg }
322 #define Xz { OP_DSreg, eSI_reg }
323 #define Yb { OP_ESreg, eDI_reg }
324 #define Yv { OP_ESreg, eDI_reg }
325 #define DSBX { OP_DSreg, eBX_reg }
327 #define es { OP_REG, es_reg }
328 #define ss { OP_REG, ss_reg }
329 #define cs { OP_REG, cs_reg }
330 #define ds { OP_REG, ds_reg }
331 #define fs { OP_REG, fs_reg }
332 #define gs { OP_REG, gs_reg }
334 #define MX { OP_MMX, 0 }
335 #define XM { OP_XMM, 0 }
336 #define XMM { OP_XMM, xmm_mode }
337 #define EM { OP_EM, v_mode }
338 #define EMS { OP_EM, v_swap_mode }
339 #define EMd { OP_EM, d_mode }
340 #define EMx { OP_EM, x_mode }
341 #define EXw { OP_EX, w_mode }
342 #define EXd { OP_EX, d_mode }
343 #define EXdS { OP_EX, d_swap_mode }
344 #define EXq { OP_EX, q_mode }
345 #define EXqS { OP_EX, q_swap_mode }
346 #define EXx { OP_EX, x_mode }
347 #define EXxS { OP_EX, x_swap_mode }
348 #define EXxmm { OP_EX, xmm_mode }
349 #define EXxmmq { OP_EX, xmmq_mode }
350 #define EXymmq { OP_EX, ymmq_mode }
351 #define EXVexWdq { OP_EX, vex_w_dq_mode }
352 #define MS { OP_MS, v_mode }
353 #define XS { OP_XS, v_mode }
354 #define EMCq { OP_EMC, q_mode }
355 #define MXC { OP_MXC, 0 }
356 #define OPSUF { OP_3DNowSuffix, 0 }
357 #define CMP { CMP_Fixup, 0 }
358 #define XMM0 { XMM_Fixup, 0 }
360 #define Vex { OP_VEX, vex_mode }
361 #define Vex128 { OP_VEX, vex128_mode }
362 #define Vex256 { OP_VEX, vex256_mode }
363 #define VexI4 { VEXI4_Fixup, 0}
364 #define EXdVex { OP_EX_Vex, d_mode }
365 #define EXdVexS { OP_EX_Vex, d_swap_mode }
366 #define EXqVex { OP_EX_Vex, q_mode }
367 #define EXqVexS { OP_EX_Vex, q_swap_mode }
368 #define EXVexW { OP_EX_VexW, x_mode }
369 #define EXdVexW { OP_EX_VexW, d_mode }
370 #define EXqVexW { OP_EX_VexW, q_mode }
371 #define XMVex { OP_XMM_Vex, 0 }
372 #define XMVexW { OP_XMM_VexW, 0 }
373 #define XMVexI4 { OP_REG_VexI4, x_mode }
374 #define PCLMUL { PCLMUL_Fixup, 0 }
375 #define VZERO { VZERO_Fixup, 0 }
376 #define VCMP { VCMP_Fixup, 0 }
378 /* Used handle "rep" prefix for string instructions. */
379 #define Xbr { REP_Fixup, eSI_reg }
380 #define Xvr { REP_Fixup, eSI_reg }
381 #define Ybr { REP_Fixup, eDI_reg }
382 #define Yvr { REP_Fixup, eDI_reg }
383 #define Yzr { REP_Fixup, eDI_reg }
384 #define indirDXr { REP_Fixup, indir_dx_reg }
385 #define ALr { REP_Fixup, al_reg }
386 #define eAXr { REP_Fixup, eAX_reg }
388 #define cond_jump_flag { NULL, cond_jump_mode }
389 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
391 /* bits in sizeflag */
392 #define SUFFIX_ALWAYS 4
400 /* byte operand with operand swapped */
402 /* operand size depends on prefixes */
404 /* operand size depends on prefixes with operand swapped */
408 /* double word operand */
410 /* double word operand with operand swapped */
412 /* quad word operand */
414 /* quad word operand with operand swapped */
416 /* ten-byte operand */
418 /* 16-byte XMM or 32-byte YMM operand */
420 /* 16-byte XMM or 32-byte YMM operand with operand swapped */
422 /* 16-byte XMM operand */
424 /* 16-byte XMM or quad word operand */
426 /* 32-byte YMM or quad word operand */
428 /* d_mode in 32bit, q_mode in 64bit mode. */
430 /* pair of v_mode operands */
434 /* operand size depends on REX prefixes. */
436 /* registers like dq_mode, memory like w_mode. */
438 /* 4- or 6-byte pointer operand */
441 /* v_mode for stack-related opcodes. */
443 /* non-quad operand size depends on prefixes */
445 /* 16-byte operand */
447 /* registers like dq_mode, memory like b_mode. */
449 /* registers like dq_mode, memory like d_mode. */
451 /* normal vex mode */
453 /* 128bit vex mode */
455 /* 256bit vex mode */
457 /* operand size depends on the VEX.W bit. */
522 #define FLOAT NULL, { { NULL, FLOATCODE } }
524 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }
525 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
526 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
527 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
528 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
529 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
530 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
531 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
532 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
533 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
534 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
652 MOD_VEX_3818_PREFIX_2,
653 MOD_VEX_3819_PREFIX_2,
654 MOD_VEX_381A_PREFIX_2,
655 MOD_VEX_382A_PREFIX_2,
656 MOD_VEX_382C_PREFIX_2,
657 MOD_VEX_382D_PREFIX_2,
658 MOD_VEX_382E_PREFIX_2,
659 MOD_VEX_382F_PREFIX_2
1069 THREE_BYTE_0F38 = 0,
1223 VEX_LEN_3819_P_2_M_0,
1224 VEX_LEN_381A_P_2_M_0,
1236 VEX_LEN_382A_P_2_M_0,
1293 typedef void (*op_rtn) (int bytemode, int sizeflag);
1304 /* Upper case letters in the instruction names here are macros.
1305 'A' => print 'b' if no register operands or suffix_always is true
1306 'B' => print 'b' if suffix_always is true
1307 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
1309 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
1310 suffix_always is true
1311 'E' => print 'e' if 32-bit form of jcxz
1312 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
1313 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
1314 'H' => print ",pt" or ",pn" branch hint
1315 'I' => honor following macro letter even in Intel mode (implemented only
1316 for some of the macro letters)
1318 'K' => print 'd' or 'q' if rex prefix is present.
1319 'L' => print 'l' if suffix_always is true
1320 'M' => print 'r' if intel_mnemonic is false.
1321 'N' => print 'n' if instruction has no wait "prefix"
1322 'O' => print 'd' or 'o' (or 'q' in Intel mode)
1323 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
1324 or suffix_always is true. print 'q' if rex prefix is present.
1325 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
1327 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
1328 'S' => print 'w', 'l' or 'q' if suffix_always is true
1329 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
1330 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
1331 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
1332 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
1333 'X' => print 's', 'd' depending on data16 prefix (for XMM)
1334 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
1335 suffix_always is true.
1336 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
1337 '!' => change condition from true to false or from false to true.
1338 '%' => add 1 upper case letter to the macro.
1340 2 upper case letter macros:
1341 "XY" => print 'x' or 'y' if no register operands or suffix_always
1343 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
1344 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
1345 or suffix_always is true
1346 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
1347 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
1348 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
1350 Many of the above letters print nothing in Intel mode. See "putop"
1353 Braces '{' and '}', and vertical bars '|', indicate alternative
1354 mnemonic strings for AT&T and Intel. */
1356 static const struct dis386 dis386[] = {
1358 { "addB", { Eb, Gb } },
1359 { "addS", { Ev, Gv } },
1360 { "addB", { Gb, EbS } },
1361 { "addS", { Gv, EvS } },
1362 { "addB", { AL, Ib } },
1363 { "addS", { eAX, Iv } },
1364 { X86_64_TABLE (X86_64_06) },
1365 { X86_64_TABLE (X86_64_07) },
1367 { "orB", { Eb, Gb } },
1368 { "orS", { Ev, Gv } },
1369 { "orB", { Gb, EbS } },
1370 { "orS", { Gv, EvS } },
1371 { "orB", { AL, Ib } },
1372 { "orS", { eAX, Iv } },
1373 { X86_64_TABLE (X86_64_0D) },
1374 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
1376 { "adcB", { Eb, Gb } },
1377 { "adcS", { Ev, Gv } },
1378 { "adcB", { Gb, EbS } },
1379 { "adcS", { Gv, EvS } },
1380 { "adcB", { AL, Ib } },
1381 { "adcS", { eAX, Iv } },
1382 { X86_64_TABLE (X86_64_16) },
1383 { X86_64_TABLE (X86_64_17) },
1385 { "sbbB", { Eb, Gb } },
1386 { "sbbS", { Ev, Gv } },
1387 { "sbbB", { Gb, EbS } },
1388 { "sbbS", { Gv, EvS } },
1389 { "sbbB", { AL, Ib } },
1390 { "sbbS", { eAX, Iv } },
1391 { X86_64_TABLE (X86_64_1E) },
1392 { X86_64_TABLE (X86_64_1F) },
1394 { "andB", { Eb, Gb } },
1395 { "andS", { Ev, Gv } },
1396 { "andB", { Gb, EbS } },
1397 { "andS", { Gv, EvS } },
1398 { "andB", { AL, Ib } },
1399 { "andS", { eAX, Iv } },
1400 { "(bad)", { XX } }, /* SEG ES prefix */
1401 { X86_64_TABLE (X86_64_27) },
1403 { "subB", { Eb, Gb } },
1404 { "subS", { Ev, Gv } },
1405 { "subB", { Gb, EbS } },
1406 { "subS", { Gv, EvS } },
1407 { "subB", { AL, Ib } },
1408 { "subS", { eAX, Iv } },
1409 { "(bad)", { XX } }, /* SEG CS prefix */
1410 { X86_64_TABLE (X86_64_2F) },
1412 { "xorB", { Eb, Gb } },
1413 { "xorS", { Ev, Gv } },
1414 { "xorB", { Gb, EbS } },
1415 { "xorS", { Gv, EvS } },
1416 { "xorB", { AL, Ib } },
1417 { "xorS", { eAX, Iv } },
1418 { "(bad)", { XX } }, /* SEG SS prefix */
1419 { X86_64_TABLE (X86_64_37) },
1421 { "cmpB", { Eb, Gb } },
1422 { "cmpS", { Ev, Gv } },
1423 { "cmpB", { Gb, EbS } },
1424 { "cmpS", { Gv, EvS } },
1425 { "cmpB", { AL, Ib } },
1426 { "cmpS", { eAX, Iv } },
1427 { "(bad)", { XX } }, /* SEG DS prefix */
1428 { X86_64_TABLE (X86_64_3F) },
1430 { "inc{S|}", { RMeAX } },
1431 { "inc{S|}", { RMeCX } },
1432 { "inc{S|}", { RMeDX } },
1433 { "inc{S|}", { RMeBX } },
1434 { "inc{S|}", { RMeSP } },
1435 { "inc{S|}", { RMeBP } },
1436 { "inc{S|}", { RMeSI } },
1437 { "inc{S|}", { RMeDI } },
1439 { "dec{S|}", { RMeAX } },
1440 { "dec{S|}", { RMeCX } },
1441 { "dec{S|}", { RMeDX } },
1442 { "dec{S|}", { RMeBX } },
1443 { "dec{S|}", { RMeSP } },
1444 { "dec{S|}", { RMeBP } },
1445 { "dec{S|}", { RMeSI } },
1446 { "dec{S|}", { RMeDI } },
1448 { "pushV", { RMrAX } },
1449 { "pushV", { RMrCX } },
1450 { "pushV", { RMrDX } },
1451 { "pushV", { RMrBX } },
1452 { "pushV", { RMrSP } },
1453 { "pushV", { RMrBP } },
1454 { "pushV", { RMrSI } },
1455 { "pushV", { RMrDI } },
1457 { "popV", { RMrAX } },
1458 { "popV", { RMrCX } },
1459 { "popV", { RMrDX } },
1460 { "popV", { RMrBX } },
1461 { "popV", { RMrSP } },
1462 { "popV", { RMrBP } },
1463 { "popV", { RMrSI } },
1464 { "popV", { RMrDI } },
1466 { X86_64_TABLE (X86_64_60) },
1467 { X86_64_TABLE (X86_64_61) },
1468 { X86_64_TABLE (X86_64_62) },
1469 { X86_64_TABLE (X86_64_63) },
1470 { "(bad)", { XX } }, /* seg fs */
1471 { "(bad)", { XX } }, /* seg gs */
1472 { "(bad)", { XX } }, /* op size prefix */
1473 { "(bad)", { XX } }, /* adr size prefix */
1475 { "pushT", { Iq } },
1476 { "imulS", { Gv, Ev, Iv } },
1477 { "pushT", { sIb } },
1478 { "imulS", { Gv, Ev, sIb } },
1479 { "ins{b|}", { Ybr, indirDX } },
1480 { X86_64_TABLE (X86_64_6D) },
1481 { "outs{b|}", { indirDXr, Xb } },
1482 { X86_64_TABLE (X86_64_6F) },
1484 { "joH", { Jb, XX, cond_jump_flag } },
1485 { "jnoH", { Jb, XX, cond_jump_flag } },
1486 { "jbH", { Jb, XX, cond_jump_flag } },
1487 { "jaeH", { Jb, XX, cond_jump_flag } },
1488 { "jeH", { Jb, XX, cond_jump_flag } },
1489 { "jneH", { Jb, XX, cond_jump_flag } },
1490 { "jbeH", { Jb, XX, cond_jump_flag } },
1491 { "jaH", { Jb, XX, cond_jump_flag } },
1493 { "jsH", { Jb, XX, cond_jump_flag } },
1494 { "jnsH", { Jb, XX, cond_jump_flag } },
1495 { "jpH", { Jb, XX, cond_jump_flag } },
1496 { "jnpH", { Jb, XX, cond_jump_flag } },
1497 { "jlH", { Jb, XX, cond_jump_flag } },
1498 { "jgeH", { Jb, XX, cond_jump_flag } },
1499 { "jleH", { Jb, XX, cond_jump_flag } },
1500 { "jgH", { Jb, XX, cond_jump_flag } },
1502 { REG_TABLE (REG_80) },
1503 { REG_TABLE (REG_81) },
1504 { "(bad)", { XX } },
1505 { REG_TABLE (REG_82) },
1506 { "testB", { Eb, Gb } },
1507 { "testS", { Ev, Gv } },
1508 { "xchgB", { Eb, Gb } },
1509 { "xchgS", { Ev, Gv } },
1511 { "movB", { Eb, Gb } },
1512 { "movS", { Ev, Gv } },
1513 { "movB", { Gb, EbS } },
1514 { "movS", { Gv, EvS } },
1515 { "movD", { Sv, Sw } },
1516 { MOD_TABLE (MOD_8D) },
1517 { "movD", { Sw, Sv } },
1518 { REG_TABLE (REG_8F) },
1520 { PREFIX_TABLE (PREFIX_90) },
1521 { "xchgS", { RMeCX, eAX } },
1522 { "xchgS", { RMeDX, eAX } },
1523 { "xchgS", { RMeBX, eAX } },
1524 { "xchgS", { RMeSP, eAX } },
1525 { "xchgS", { RMeBP, eAX } },
1526 { "xchgS", { RMeSI, eAX } },
1527 { "xchgS", { RMeDI, eAX } },
1529 { "cW{t|}R", { XX } },
1530 { "cR{t|}O", { XX } },
1531 { X86_64_TABLE (X86_64_9A) },
1532 { "(bad)", { XX } }, /* fwait */
1533 { "pushfT", { XX } },
1534 { "popfT", { XX } },
1538 { "mov%LB", { AL, Ob } },
1539 { "mov%LS", { eAX, Ov } },
1540 { "mov%LB", { Ob, AL } },
1541 { "mov%LS", { Ov, eAX } },
1542 { "movs{b|}", { Ybr, Xb } },
1543 { "movs{R|}", { Yvr, Xv } },
1544 { "cmps{b|}", { Xb, Yb } },
1545 { "cmps{R|}", { Xv, Yv } },
1547 { "testB", { AL, Ib } },
1548 { "testS", { eAX, Iv } },
1549 { "stosB", { Ybr, AL } },
1550 { "stosS", { Yvr, eAX } },
1551 { "lodsB", { ALr, Xb } },
1552 { "lodsS", { eAXr, Xv } },
1553 { "scasB", { AL, Yb } },
1554 { "scasS", { eAX, Yv } },
1556 { "movB", { RMAL, Ib } },
1557 { "movB", { RMCL, Ib } },
1558 { "movB", { RMDL, Ib } },
1559 { "movB", { RMBL, Ib } },
1560 { "movB", { RMAH, Ib } },
1561 { "movB", { RMCH, Ib } },
1562 { "movB", { RMDH, Ib } },
1563 { "movB", { RMBH, Ib } },
1565 { "mov%LV", { RMeAX, Iv64 } },
1566 { "mov%LV", { RMeCX, Iv64 } },
1567 { "mov%LV", { RMeDX, Iv64 } },
1568 { "mov%LV", { RMeBX, Iv64 } },
1569 { "mov%LV", { RMeSP, Iv64 } },
1570 { "mov%LV", { RMeBP, Iv64 } },
1571 { "mov%LV", { RMeSI, Iv64 } },
1572 { "mov%LV", { RMeDI, Iv64 } },
1574 { REG_TABLE (REG_C0) },
1575 { REG_TABLE (REG_C1) },
1578 { X86_64_TABLE (X86_64_C4) },
1579 { X86_64_TABLE (X86_64_C5) },
1580 { REG_TABLE (REG_C6) },
1581 { REG_TABLE (REG_C7) },
1583 { "enterT", { Iw, Ib } },
1584 { "leaveT", { XX } },
1585 { "Jret{|f}P", { Iw } },
1586 { "Jret{|f}P", { XX } },
1589 { X86_64_TABLE (X86_64_CE) },
1590 { "iretP", { XX } },
1592 { REG_TABLE (REG_D0) },
1593 { REG_TABLE (REG_D1) },
1594 { REG_TABLE (REG_D2) },
1595 { REG_TABLE (REG_D3) },
1596 { X86_64_TABLE (X86_64_D4) },
1597 { X86_64_TABLE (X86_64_D5) },
1598 { "(bad)", { XX } },
1599 { "xlat", { DSBX } },
1610 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
1611 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
1612 { "loopFH", { Jb, XX, loop_jcxz_flag } },
1613 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
1614 { "inB", { AL, Ib } },
1615 { "inG", { zAX, Ib } },
1616 { "outB", { Ib, AL } },
1617 { "outG", { Ib, zAX } },
1619 { "callT", { Jv } },
1621 { X86_64_TABLE (X86_64_EA) },
1623 { "inB", { AL, indirDX } },
1624 { "inG", { zAX, indirDX } },
1625 { "outB", { indirDX, AL } },
1626 { "outG", { indirDX, zAX } },
1628 { "(bad)", { XX } }, /* lock prefix */
1629 { "icebp", { XX } },
1630 { "(bad)", { XX } }, /* repne */
1631 { "(bad)", { XX } }, /* repz */
1634 { REG_TABLE (REG_F6) },
1635 { REG_TABLE (REG_F7) },
1643 { REG_TABLE (REG_FE) },
1644 { REG_TABLE (REG_FF) },
1647 static const struct dis386 dis386_twobyte[] = {
1649 { REG_TABLE (REG_0F00 ) },
1650 { REG_TABLE (REG_0F01 ) },
1651 { "larS", { Gv, Ew } },
1652 { "lslS", { Gv, Ew } },
1653 { "(bad)", { XX } },
1654 { "syscall", { XX } },
1656 { "sysretP", { XX } },
1659 { "wbinvd", { XX } },
1660 { "(bad)", { XX } },
1662 { "(bad)", { XX } },
1663 { REG_TABLE (REG_0F0D) },
1664 { "femms", { XX } },
1665 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1667 { PREFIX_TABLE (PREFIX_0F10) },
1668 { PREFIX_TABLE (PREFIX_0F11) },
1669 { PREFIX_TABLE (PREFIX_0F12) },
1670 { MOD_TABLE (MOD_0F13) },
1671 { "unpcklpX", { XM, EXx } },
1672 { "unpckhpX", { XM, EXx } },
1673 { PREFIX_TABLE (PREFIX_0F16) },
1674 { MOD_TABLE (MOD_0F17) },
1676 { REG_TABLE (REG_0F18) },
1685 { MOD_TABLE (MOD_0F20) },
1686 { MOD_TABLE (MOD_0F21) },
1687 { MOD_TABLE (MOD_0F22) },
1688 { MOD_TABLE (MOD_0F23) },
1689 { MOD_TABLE (MOD_0F24) },
1690 { "(bad)", { XX } },
1691 { MOD_TABLE (MOD_0F26) },
1692 { "(bad)", { XX } },
1694 { "movapX", { XM, EXx } },
1695 { "movapX", { EXxS, XM } },
1696 { PREFIX_TABLE (PREFIX_0F2A) },
1697 { PREFIX_TABLE (PREFIX_0F2B) },
1698 { PREFIX_TABLE (PREFIX_0F2C) },
1699 { PREFIX_TABLE (PREFIX_0F2D) },
1700 { PREFIX_TABLE (PREFIX_0F2E) },
1701 { PREFIX_TABLE (PREFIX_0F2F) },
1703 { "wrmsr", { XX } },
1704 { "rdtsc", { XX } },
1705 { "rdmsr", { XX } },
1706 { "rdpmc", { XX } },
1707 { "sysenter", { XX } },
1708 { "sysexit", { XX } },
1709 { "(bad)", { XX } },
1710 { "getsec", { XX } },
1712 { THREE_BYTE_TABLE (THREE_BYTE_0F38) },
1713 { "(bad)", { XX } },
1714 { THREE_BYTE_TABLE (THREE_BYTE_0F3A) },
1715 { "(bad)", { XX } },
1716 { "(bad)", { XX } },
1717 { "(bad)", { XX } },
1718 { "(bad)", { XX } },
1719 { "(bad)", { XX } },
1721 { "cmovoS", { Gv, Ev } },
1722 { "cmovnoS", { Gv, Ev } },
1723 { "cmovbS", { Gv, Ev } },
1724 { "cmovaeS", { Gv, Ev } },
1725 { "cmoveS", { Gv, Ev } },
1726 { "cmovneS", { Gv, Ev } },
1727 { "cmovbeS", { Gv, Ev } },
1728 { "cmovaS", { Gv, Ev } },
1730 { "cmovsS", { Gv, Ev } },
1731 { "cmovnsS", { Gv, Ev } },
1732 { "cmovpS", { Gv, Ev } },
1733 { "cmovnpS", { Gv, Ev } },
1734 { "cmovlS", { Gv, Ev } },
1735 { "cmovgeS", { Gv, Ev } },
1736 { "cmovleS", { Gv, Ev } },
1737 { "cmovgS", { Gv, Ev } },
1739 { MOD_TABLE (MOD_0F51) },
1740 { PREFIX_TABLE (PREFIX_0F51) },
1741 { PREFIX_TABLE (PREFIX_0F52) },
1742 { PREFIX_TABLE (PREFIX_0F53) },
1743 { "andpX", { XM, EXx } },
1744 { "andnpX", { XM, EXx } },
1745 { "orpX", { XM, EXx } },
1746 { "xorpX", { XM, EXx } },
1748 { PREFIX_TABLE (PREFIX_0F58) },
1749 { PREFIX_TABLE (PREFIX_0F59) },
1750 { PREFIX_TABLE (PREFIX_0F5A) },
1751 { PREFIX_TABLE (PREFIX_0F5B) },
1752 { PREFIX_TABLE (PREFIX_0F5C) },
1753 { PREFIX_TABLE (PREFIX_0F5D) },
1754 { PREFIX_TABLE (PREFIX_0F5E) },
1755 { PREFIX_TABLE (PREFIX_0F5F) },
1757 { PREFIX_TABLE (PREFIX_0F60) },
1758 { PREFIX_TABLE (PREFIX_0F61) },
1759 { PREFIX_TABLE (PREFIX_0F62) },
1760 { "packsswb", { MX, EM } },
1761 { "pcmpgtb", { MX, EM } },
1762 { "pcmpgtw", { MX, EM } },
1763 { "pcmpgtd", { MX, EM } },
1764 { "packuswb", { MX, EM } },
1766 { "punpckhbw", { MX, EM } },
1767 { "punpckhwd", { MX, EM } },
1768 { "punpckhdq", { MX, EM } },
1769 { "packssdw", { MX, EM } },
1770 { PREFIX_TABLE (PREFIX_0F6C) },
1771 { PREFIX_TABLE (PREFIX_0F6D) },
1772 { "movK", { MX, Edq } },
1773 { PREFIX_TABLE (PREFIX_0F6F) },
1775 { PREFIX_TABLE (PREFIX_0F70) },
1776 { REG_TABLE (REG_0F71) },
1777 { REG_TABLE (REG_0F72) },
1778 { REG_TABLE (REG_0F73) },
1779 { "pcmpeqb", { MX, EM } },
1780 { "pcmpeqw", { MX, EM } },
1781 { "pcmpeqd", { MX, EM } },
1784 { PREFIX_TABLE (PREFIX_0F78) },
1785 { PREFIX_TABLE (PREFIX_0F79) },
1786 { THREE_BYTE_TABLE (THREE_BYTE_0F7A) },
1787 { "(bad)", { XX } },
1788 { PREFIX_TABLE (PREFIX_0F7C) },
1789 { PREFIX_TABLE (PREFIX_0F7D) },
1790 { PREFIX_TABLE (PREFIX_0F7E) },
1791 { PREFIX_TABLE (PREFIX_0F7F) },
1793 { "joH", { Jv, XX, cond_jump_flag } },
1794 { "jnoH", { Jv, XX, cond_jump_flag } },
1795 { "jbH", { Jv, XX, cond_jump_flag } },
1796 { "jaeH", { Jv, XX, cond_jump_flag } },
1797 { "jeH", { Jv, XX, cond_jump_flag } },
1798 { "jneH", { Jv, XX, cond_jump_flag } },
1799 { "jbeH", { Jv, XX, cond_jump_flag } },
1800 { "jaH", { Jv, XX, cond_jump_flag } },
1802 { "jsH", { Jv, XX, cond_jump_flag } },
1803 { "jnsH", { Jv, XX, cond_jump_flag } },
1804 { "jpH", { Jv, XX, cond_jump_flag } },
1805 { "jnpH", { Jv, XX, cond_jump_flag } },
1806 { "jlH", { Jv, XX, cond_jump_flag } },
1807 { "jgeH", { Jv, XX, cond_jump_flag } },
1808 { "jleH", { Jv, XX, cond_jump_flag } },
1809 { "jgH", { Jv, XX, cond_jump_flag } },
1812 { "setno", { Eb } },
1814 { "setae", { Eb } },
1816 { "setne", { Eb } },
1817 { "setbe", { Eb } },
1821 { "setns", { Eb } },
1823 { "setnp", { Eb } },
1825 { "setge", { Eb } },
1826 { "setle", { Eb } },
1829 { "pushT", { fs } },
1831 { "cpuid", { XX } },
1832 { "btS", { Ev, Gv } },
1833 { "shldS", { Ev, Gv, Ib } },
1834 { "shldS", { Ev, Gv, CL } },
1835 { REG_TABLE (REG_0FA6) },
1836 { REG_TABLE (REG_0FA7) },
1838 { "pushT", { gs } },
1841 { "btsS", { Ev, Gv } },
1842 { "shrdS", { Ev, Gv, Ib } },
1843 { "shrdS", { Ev, Gv, CL } },
1844 { REG_TABLE (REG_0FAE) },
1845 { "imulS", { Gv, Ev } },
1847 { "cmpxchgB", { Eb, Gb } },
1848 { "cmpxchgS", { Ev, Gv } },
1849 { MOD_TABLE (MOD_0FB2) },
1850 { "btrS", { Ev, Gv } },
1851 { MOD_TABLE (MOD_0FB4) },
1852 { MOD_TABLE (MOD_0FB5) },
1853 { "movz{bR|x}", { Gv, Eb } },
1854 { "movz{wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
1856 { PREFIX_TABLE (PREFIX_0FB8) },
1858 { REG_TABLE (REG_0FBA) },
1859 { "btcS", { Ev, Gv } },
1860 { "bsfS", { Gv, Ev } },
1861 { PREFIX_TABLE (PREFIX_0FBD) },
1862 { "movs{bR|x}", { Gv, Eb } },
1863 { "movs{wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
1865 { "xaddB", { Eb, Gb } },
1866 { "xaddS", { Ev, Gv } },
1867 { PREFIX_TABLE (PREFIX_0FC2) },
1868 { PREFIX_TABLE (PREFIX_0FC3) },
1869 { "pinsrw", { MX, Edqw, Ib } },
1870 { "pextrw", { Gdq, MS, Ib } },
1871 { "shufpX", { XM, EXx, Ib } },
1872 { REG_TABLE (REG_0FC7) },
1874 { "bswap", { RMeAX } },
1875 { "bswap", { RMeCX } },
1876 { "bswap", { RMeDX } },
1877 { "bswap", { RMeBX } },
1878 { "bswap", { RMeSP } },
1879 { "bswap", { RMeBP } },
1880 { "bswap", { RMeSI } },
1881 { "bswap", { RMeDI } },
1883 { PREFIX_TABLE (PREFIX_0FD0) },
1884 { "psrlw", { MX, EM } },
1885 { "psrld", { MX, EM } },
1886 { "psrlq", { MX, EM } },
1887 { "paddq", { MX, EM } },
1888 { "pmullw", { MX, EM } },
1889 { PREFIX_TABLE (PREFIX_0FD6) },
1890 { MOD_TABLE (MOD_0FD7) },
1892 { "psubusb", { MX, EM } },
1893 { "psubusw", { MX, EM } },
1894 { "pminub", { MX, EM } },
1895 { "pand", { MX, EM } },
1896 { "paddusb", { MX, EM } },
1897 { "paddusw", { MX, EM } },
1898 { "pmaxub", { MX, EM } },
1899 { "pandn", { MX, EM } },
1901 { "pavgb", { MX, EM } },
1902 { "psraw", { MX, EM } },
1903 { "psrad", { MX, EM } },
1904 { "pavgw", { MX, EM } },
1905 { "pmulhuw", { MX, EM } },
1906 { "pmulhw", { MX, EM } },
1907 { PREFIX_TABLE (PREFIX_0FE6) },
1908 { PREFIX_TABLE (PREFIX_0FE7) },
1910 { "psubsb", { MX, EM } },
1911 { "psubsw", { MX, EM } },
1912 { "pminsw", { MX, EM } },
1913 { "por", { MX, EM } },
1914 { "paddsb", { MX, EM } },
1915 { "paddsw", { MX, EM } },
1916 { "pmaxsw", { MX, EM } },
1917 { "pxor", { MX, EM } },
1919 { PREFIX_TABLE (PREFIX_0FF0) },
1920 { "psllw", { MX, EM } },
1921 { "pslld", { MX, EM } },
1922 { "psllq", { MX, EM } },
1923 { "pmuludq", { MX, EM } },
1924 { "pmaddwd", { MX, EM } },
1925 { "psadbw", { MX, EM } },
1926 { PREFIX_TABLE (PREFIX_0FF7) },
1928 { "psubb", { MX, EM } },
1929 { "psubw", { MX, EM } },
1930 { "psubd", { MX, EM } },
1931 { "psubq", { MX, EM } },
1932 { "paddb", { MX, EM } },
1933 { "paddw", { MX, EM } },
1934 { "paddd", { MX, EM } },
1935 { "(bad)", { XX } },
1938 static const unsigned char onebyte_has_modrm[256] = {
1939 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1940 /* ------------------------------- */
1941 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1942 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1943 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1944 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1945 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1946 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1947 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1948 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1949 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1950 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1951 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1952 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1953 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1954 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1955 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1956 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1957 /* ------------------------------- */
1958 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1961 static const unsigned char twobyte_has_modrm[256] = {
1962 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1963 /* ------------------------------- */
1964 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1965 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
1966 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1967 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1968 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1969 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1970 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1971 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1972 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1973 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1974 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1975 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1976 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1977 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1978 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1979 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1980 /* ------------------------------- */
1981 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1984 static char obuf[100];
1986 static char *mnemonicendp;
1987 static char scratchbuf[100];
1988 static unsigned char *start_codep;
1989 static unsigned char *insn_codep;
1990 static unsigned char *codep;
1991 static int last_lock_prefix;
1992 static int last_repz_prefix;
1993 static int last_repnz_prefix;
1994 static int last_data_prefix;
1995 static int last_addr_prefix;
1996 static int last_rex_prefix;
1997 static int last_seg_prefix;
1998 #define MAX_CODE_LENGTH 15
1999 /* We can up to 14 prefixes since the maximum instruction length is
2001 static int all_prefixes[MAX_CODE_LENGTH - 1];
2002 static disassemble_info *the_info;
2010 static unsigned char need_modrm;
2013 int register_specifier;
2019 static unsigned char need_vex;
2020 static unsigned char need_vex_reg;
2021 static unsigned char vex_w_done;
2029 /* If we are accessing mod/rm/reg without need_modrm set, then the
2030 values are stale. Hitting this abort likely indicates that you
2031 need to update onebyte_has_modrm or twobyte_has_modrm. */
2032 #define MODRM_CHECK if (!need_modrm) abort ()
2034 static const char **names64;
2035 static const char **names32;
2036 static const char **names16;
2037 static const char **names8;
2038 static const char **names8rex;
2039 static const char **names_seg;
2040 static const char *index64;
2041 static const char *index32;
2042 static const char **index16;
2044 static const char *intel_names64[] = {
2045 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
2046 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
2048 static const char *intel_names32[] = {
2049 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
2050 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
2052 static const char *intel_names16[] = {
2053 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
2054 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
2056 static const char *intel_names8[] = {
2057 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
2059 static const char *intel_names8rex[] = {
2060 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
2061 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
2063 static const char *intel_names_seg[] = {
2064 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
2066 static const char *intel_index64 = "riz";
2067 static const char *intel_index32 = "eiz";
2068 static const char *intel_index16[] = {
2069 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
2072 static const char *att_names64[] = {
2073 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
2074 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
2076 static const char *att_names32[] = {
2077 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
2078 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
2080 static const char *att_names16[] = {
2081 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
2082 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
2084 static const char *att_names8[] = {
2085 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
2087 static const char *att_names8rex[] = {
2088 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
2089 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
2091 static const char *att_names_seg[] = {
2092 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
2094 static const char *att_index64 = "%riz";
2095 static const char *att_index32 = "%eiz";
2096 static const char *att_index16[] = {
2097 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
2100 static const struct dis386 reg_table[][8] = {
2103 { "addA", { Eb, Ib } },
2104 { "orA", { Eb, Ib } },
2105 { "adcA", { Eb, Ib } },
2106 { "sbbA", { Eb, Ib } },
2107 { "andA", { Eb, Ib } },
2108 { "subA", { Eb, Ib } },
2109 { "xorA", { Eb, Ib } },
2110 { "cmpA", { Eb, Ib } },
2114 { "addQ", { Ev, Iv } },
2115 { "orQ", { Ev, Iv } },
2116 { "adcQ", { Ev, Iv } },
2117 { "sbbQ", { Ev, Iv } },
2118 { "andQ", { Ev, Iv } },
2119 { "subQ", { Ev, Iv } },
2120 { "xorQ", { Ev, Iv } },
2121 { "cmpQ", { Ev, Iv } },
2125 { "addQ", { Ev, sIb } },
2126 { "orQ", { Ev, sIb } },
2127 { "adcQ", { Ev, sIb } },
2128 { "sbbQ", { Ev, sIb } },
2129 { "andQ", { Ev, sIb } },
2130 { "subQ", { Ev, sIb } },
2131 { "xorQ", { Ev, sIb } },
2132 { "cmpQ", { Ev, sIb } },
2136 { "popU", { stackEv } },
2137 { XOP_8F_TABLE (XOP_09) },
2138 { "(bad)", { XX } },
2139 { "(bad)", { XX } },
2140 { "(bad)", { XX } },
2141 { XOP_8F_TABLE (XOP_09) },
2142 { "(bad)", { XX } },
2143 { "(bad)", { XX } },
2147 { "rolA", { Eb, Ib } },
2148 { "rorA", { Eb, Ib } },
2149 { "rclA", { Eb, Ib } },
2150 { "rcrA", { Eb, Ib } },
2151 { "shlA", { Eb, Ib } },
2152 { "shrA", { Eb, Ib } },
2153 { "(bad)", { XX } },
2154 { "sarA", { Eb, Ib } },
2158 { "rolQ", { Ev, Ib } },
2159 { "rorQ", { Ev, Ib } },
2160 { "rclQ", { Ev, Ib } },
2161 { "rcrQ", { Ev, Ib } },
2162 { "shlQ", { Ev, Ib } },
2163 { "shrQ", { Ev, Ib } },
2164 { "(bad)", { XX } },
2165 { "sarQ", { Ev, Ib } },
2169 { "movA", { Eb, Ib } },
2170 { "(bad)", { XX } },
2171 { "(bad)", { XX } },
2172 { "(bad)", { XX } },
2173 { "(bad)", { XX } },
2174 { "(bad)", { XX } },
2175 { "(bad)", { XX } },
2176 { "(bad)", { XX } },
2180 { "movQ", { Ev, Iv } },
2181 { "(bad)", { XX } },
2182 { "(bad)", { XX } },
2183 { "(bad)", { XX } },
2184 { "(bad)", { XX } },
2185 { "(bad)", { XX } },
2186 { "(bad)", { XX } },
2187 { "(bad)", { XX } },
2191 { "rolA", { Eb, I1 } },
2192 { "rorA", { Eb, I1 } },
2193 { "rclA", { Eb, I1 } },
2194 { "rcrA", { Eb, I1 } },
2195 { "shlA", { Eb, I1 } },
2196 { "shrA", { Eb, I1 } },
2197 { "(bad)", { XX } },
2198 { "sarA", { Eb, I1 } },
2202 { "rolQ", { Ev, I1 } },
2203 { "rorQ", { Ev, I1 } },
2204 { "rclQ", { Ev, I1 } },
2205 { "rcrQ", { Ev, I1 } },
2206 { "shlQ", { Ev, I1 } },
2207 { "shrQ", { Ev, I1 } },
2208 { "(bad)", { XX } },
2209 { "sarQ", { Ev, I1 } },
2213 { "rolA", { Eb, CL } },
2214 { "rorA", { Eb, CL } },
2215 { "rclA", { Eb, CL } },
2216 { "rcrA", { Eb, CL } },
2217 { "shlA", { Eb, CL } },
2218 { "shrA", { Eb, CL } },
2219 { "(bad)", { XX } },
2220 { "sarA", { Eb, CL } },
2224 { "rolQ", { Ev, CL } },
2225 { "rorQ", { Ev, CL } },
2226 { "rclQ", { Ev, CL } },
2227 { "rcrQ", { Ev, CL } },
2228 { "shlQ", { Ev, CL } },
2229 { "shrQ", { Ev, CL } },
2230 { "(bad)", { XX } },
2231 { "sarQ", { Ev, CL } },
2235 { "testA", { Eb, Ib } },
2236 { "(bad)", { XX } },
2239 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
2240 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
2241 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
2242 { "idivA", { Eb } }, /* and idiv for consistency. */
2246 { "testQ", { Ev, Iv } },
2247 { "(bad)", { XX } },
2250 { "mulQ", { Ev } }, /* Don't print the implicit register. */
2251 { "imulQ", { Ev } },
2253 { "idivQ", { Ev } },
2259 { "(bad)", { XX } },
2260 { "(bad)", { XX } },
2261 { "(bad)", { XX } },
2262 { "(bad)", { XX } },
2263 { "(bad)", { XX } },
2264 { "(bad)", { XX } },
2270 { "callT", { indirEv } },
2271 { "JcallT", { indirEp } },
2272 { "jmpT", { indirEv } },
2273 { "JjmpT", { indirEp } },
2274 { "pushU", { stackEv } },
2275 { "(bad)", { XX } },
2279 { "sldtD", { Sv } },
2285 { "(bad)", { XX } },
2286 { "(bad)", { XX } },
2290 { MOD_TABLE (MOD_0F01_REG_0) },
2291 { MOD_TABLE (MOD_0F01_REG_1) },
2292 { MOD_TABLE (MOD_0F01_REG_2) },
2293 { MOD_TABLE (MOD_0F01_REG_3) },
2294 { "smswD", { Sv } },
2295 { "(bad)", { XX } },
2297 { MOD_TABLE (MOD_0F01_REG_7) },
2301 { "prefetch", { Eb } },
2302 { "prefetchw", { Eb } },
2303 { "(bad)", { XX } },
2304 { "(bad)", { XX } },
2305 { "(bad)", { XX } },
2306 { "(bad)", { XX } },
2307 { "(bad)", { XX } },
2308 { "(bad)", { XX } },
2312 { MOD_TABLE (MOD_0F18_REG_0) },
2313 { MOD_TABLE (MOD_0F18_REG_1) },
2314 { MOD_TABLE (MOD_0F18_REG_2) },
2315 { MOD_TABLE (MOD_0F18_REG_3) },
2316 { "(bad)", { XX } },
2317 { "(bad)", { XX } },
2318 { "(bad)", { XX } },
2319 { "(bad)", { XX } },
2323 { "(bad)", { XX } },
2324 { "(bad)", { XX } },
2325 { MOD_TABLE (MOD_0F71_REG_2) },
2326 { "(bad)", { XX } },
2327 { MOD_TABLE (MOD_0F71_REG_4) },
2328 { "(bad)", { XX } },
2329 { MOD_TABLE (MOD_0F71_REG_6) },
2330 { "(bad)", { XX } },
2334 { "(bad)", { XX } },
2335 { "(bad)", { XX } },
2336 { MOD_TABLE (MOD_0F72_REG_2) },
2337 { "(bad)", { XX } },
2338 { MOD_TABLE (MOD_0F72_REG_4) },
2339 { "(bad)", { XX } },
2340 { MOD_TABLE (MOD_0F72_REG_6) },
2341 { "(bad)", { XX } },
2345 { "(bad)", { XX } },
2346 { "(bad)", { XX } },
2347 { MOD_TABLE (MOD_0F73_REG_2) },
2348 { MOD_TABLE (MOD_0F73_REG_3) },
2349 { "(bad)", { XX } },
2350 { "(bad)", { XX } },
2351 { MOD_TABLE (MOD_0F73_REG_6) },
2352 { MOD_TABLE (MOD_0F73_REG_7) },
2356 { "montmul", { { OP_0f07, 0 } } },
2357 { "xsha1", { { OP_0f07, 0 } } },
2358 { "xsha256", { { OP_0f07, 0 } } },
2359 { "(bad)", { { OP_0f07, 0 } } },
2360 { "(bad)", { { OP_0f07, 0 } } },
2361 { "(bad)", { { OP_0f07, 0 } } },
2362 { "(bad)", { { OP_0f07, 0 } } },
2363 { "(bad)", { { OP_0f07, 0 } } },
2367 { "xstore-rng", { { OP_0f07, 0 } } },
2368 { "xcrypt-ecb", { { OP_0f07, 0 } } },
2369 { "xcrypt-cbc", { { OP_0f07, 0 } } },
2370 { "xcrypt-ctr", { { OP_0f07, 0 } } },
2371 { "xcrypt-cfb", { { OP_0f07, 0 } } },
2372 { "xcrypt-ofb", { { OP_0f07, 0 } } },
2373 { "(bad)", { { OP_0f07, 0 } } },
2374 { "(bad)", { { OP_0f07, 0 } } },
2378 { MOD_TABLE (MOD_0FAE_REG_0) },
2379 { MOD_TABLE (MOD_0FAE_REG_1) },
2380 { MOD_TABLE (MOD_0FAE_REG_2) },
2381 { MOD_TABLE (MOD_0FAE_REG_3) },
2382 { MOD_TABLE (MOD_0FAE_REG_4) },
2383 { MOD_TABLE (MOD_0FAE_REG_5) },
2384 { MOD_TABLE (MOD_0FAE_REG_6) },
2385 { MOD_TABLE (MOD_0FAE_REG_7) },
2389 { "(bad)", { XX } },
2390 { "(bad)", { XX } },
2391 { "(bad)", { XX } },
2392 { "(bad)", { XX } },
2393 { "btQ", { Ev, Ib } },
2394 { "btsQ", { Ev, Ib } },
2395 { "btrQ", { Ev, Ib } },
2396 { "btcQ", { Ev, Ib } },
2400 { "(bad)", { XX } },
2401 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
2402 { "(bad)", { XX } },
2403 { "(bad)", { XX } },
2404 { "(bad)", { XX } },
2405 { "(bad)", { XX } },
2406 { MOD_TABLE (MOD_0FC7_REG_6) },
2407 { MOD_TABLE (MOD_0FC7_REG_7) },
2411 { "(bad)", { XX } },
2412 { "(bad)", { XX } },
2413 { MOD_TABLE (MOD_VEX_71_REG_2) },
2414 { "(bad)", { XX } },
2415 { MOD_TABLE (MOD_VEX_71_REG_4) },
2416 { "(bad)", { XX } },
2417 { MOD_TABLE (MOD_VEX_71_REG_6) },
2418 { "(bad)", { XX } },
2422 { "(bad)", { XX } },
2423 { "(bad)", { XX } },
2424 { MOD_TABLE (MOD_VEX_72_REG_2) },
2425 { "(bad)", { XX } },
2426 { MOD_TABLE (MOD_VEX_72_REG_4) },
2427 { "(bad)", { XX } },
2428 { MOD_TABLE (MOD_VEX_72_REG_6) },
2429 { "(bad)", { XX } },
2433 { "(bad)", { XX } },
2434 { "(bad)", { XX } },
2435 { MOD_TABLE (MOD_VEX_73_REG_2) },
2436 { MOD_TABLE (MOD_VEX_73_REG_3) },
2437 { "(bad)", { XX } },
2438 { "(bad)", { XX } },
2439 { MOD_TABLE (MOD_VEX_73_REG_6) },
2440 { MOD_TABLE (MOD_VEX_73_REG_7) },
2444 { "(bad)", { XX } },
2445 { "(bad)", { XX } },
2446 { MOD_TABLE (MOD_VEX_AE_REG_2) },
2447 { MOD_TABLE (MOD_VEX_AE_REG_3) },
2448 { "(bad)", { XX } },
2449 { "(bad)", { XX } },
2450 { "(bad)", { XX } },
2451 { "(bad)", { XX } },
2455 { "llwpcb", { { OP_LWPCB_E, 0 } } },
2456 { "slwpcb", { { OP_LWPCB_E, 0 } } },
2457 { "(bad)", { XX } },
2458 { "(bad)", { XX } },
2459 { "(bad)", { XX } },
2460 { "(bad)", { XX } },
2461 { "(bad)", { XX } },
2462 { "(bad)", { XX } },
2466 { "lwpins", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2467 { "lwpval", { { OP_LWP_E, 0 }, Ed, { OP_LWP_I, 0 } } },
2468 { "(bad)", { XX } },
2469 { "(bad)", { XX } },
2470 { "(bad)", { XX } },
2471 { "(bad)", { XX } },
2472 { "(bad)", { XX } },
2473 { "(bad)", { XX } },
2477 static const struct dis386 prefix_table[][4] = {
2480 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2481 { "pause", { XX } },
2482 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2483 { "(bad)", { XX } },
2488 { "movups", { XM, EXx } },
2489 { "movss", { XM, EXd } },
2490 { "movupd", { XM, EXx } },
2491 { "movsd", { XM, EXq } },
2496 { "movups", { EXxS, XM } },
2497 { "movss", { EXdS, XM } },
2498 { "movupd", { EXxS, XM } },
2499 { "movsd", { EXqS, XM } },
2504 { MOD_TABLE (MOD_0F12_PREFIX_0) },
2505 { "movsldup", { XM, EXx } },
2506 { "movlpd", { XM, EXq } },
2507 { "movddup", { XM, EXq } },
2512 { MOD_TABLE (MOD_0F16_PREFIX_0) },
2513 { "movshdup", { XM, EXx } },
2514 { "movhpd", { XM, EXq } },
2515 { "(bad)", { XX } },
2520 { "cvtpi2ps", { XM, EMCq } },
2521 { "cvtsi2ss%LQ", { XM, Ev } },
2522 { "cvtpi2pd", { XM, EMCq } },
2523 { "cvtsi2sd%LQ", { XM, Ev } },
2528 { MOD_TABLE (MOD_0F2B_PREFIX_0) },
2529 { MOD_TABLE (MOD_0F2B_PREFIX_1) },
2530 { MOD_TABLE (MOD_0F2B_PREFIX_2) },
2531 { MOD_TABLE (MOD_0F2B_PREFIX_3) },
2536 { "cvttps2pi", { MXC, EXq } },
2537 { "cvttss2siY", { Gv, EXd } },
2538 { "cvttpd2pi", { MXC, EXx } },
2539 { "cvttsd2siY", { Gv, EXq } },
2544 { "cvtps2pi", { MXC, EXq } },
2545 { "cvtss2siY", { Gv, EXd } },
2546 { "cvtpd2pi", { MXC, EXx } },
2547 { "cvtsd2siY", { Gv, EXq } },
2552 { "ucomiss",{ XM, EXd } },
2553 { "(bad)", { XX } },
2554 { "ucomisd",{ XM, EXq } },
2555 { "(bad)", { XX } },
2560 { "comiss", { XM, EXd } },
2561 { "(bad)", { XX } },
2562 { "comisd", { XM, EXq } },
2563 { "(bad)", { XX } },
2568 { "sqrtps", { XM, EXx } },
2569 { "sqrtss", { XM, EXd } },
2570 { "sqrtpd", { XM, EXx } },
2571 { "sqrtsd", { XM, EXq } },
2576 { "rsqrtps",{ XM, EXx } },
2577 { "rsqrtss",{ XM, EXd } },
2578 { "(bad)", { XX } },
2579 { "(bad)", { XX } },
2584 { "rcpps", { XM, EXx } },
2585 { "rcpss", { XM, EXd } },
2586 { "(bad)", { XX } },
2587 { "(bad)", { XX } },
2592 { "addps", { XM, EXx } },
2593 { "addss", { XM, EXd } },
2594 { "addpd", { XM, EXx } },
2595 { "addsd", { XM, EXq } },
2600 { "mulps", { XM, EXx } },
2601 { "mulss", { XM, EXd } },
2602 { "mulpd", { XM, EXx } },
2603 { "mulsd", { XM, EXq } },
2608 { "cvtps2pd", { XM, EXq } },
2609 { "cvtss2sd", { XM, EXd } },
2610 { "cvtpd2ps", { XM, EXx } },
2611 { "cvtsd2ss", { XM, EXq } },
2616 { "cvtdq2ps", { XM, EXx } },
2617 { "cvttps2dq", { XM, EXx } },
2618 { "cvtps2dq", { XM, EXx } },
2619 { "(bad)", { XX } },
2624 { "subps", { XM, EXx } },
2625 { "subss", { XM, EXd } },
2626 { "subpd", { XM, EXx } },
2627 { "subsd", { XM, EXq } },
2632 { "minps", { XM, EXx } },
2633 { "minss", { XM, EXd } },
2634 { "minpd", { XM, EXx } },
2635 { "minsd", { XM, EXq } },
2640 { "divps", { XM, EXx } },
2641 { "divss", { XM, EXd } },
2642 { "divpd", { XM, EXx } },
2643 { "divsd", { XM, EXq } },
2648 { "maxps", { XM, EXx } },
2649 { "maxss", { XM, EXd } },
2650 { "maxpd", { XM, EXx } },
2651 { "maxsd", { XM, EXq } },
2656 { "punpcklbw",{ MX, EMd } },
2657 { "(bad)", { XX } },
2658 { "punpcklbw",{ MX, EMx } },
2659 { "(bad)", { XX } },
2664 { "punpcklwd",{ MX, EMd } },
2665 { "(bad)", { XX } },
2666 { "punpcklwd",{ MX, EMx } },
2667 { "(bad)", { XX } },
2672 { "punpckldq",{ MX, EMd } },
2673 { "(bad)", { XX } },
2674 { "punpckldq",{ MX, EMx } },
2675 { "(bad)", { XX } },
2680 { "(bad)", { XX } },
2681 { "(bad)", { XX } },
2682 { "punpcklqdq", { XM, EXx } },
2683 { "(bad)", { XX } },
2688 { "(bad)", { XX } },
2689 { "(bad)", { XX } },
2690 { "punpckhqdq", { XM, EXx } },
2691 { "(bad)", { XX } },
2696 { "movq", { MX, EM } },
2697 { "movdqu", { XM, EXx } },
2698 { "movdqa", { XM, EXx } },
2699 { "(bad)", { XX } },
2704 { "pshufw", { MX, EM, Ib } },
2705 { "pshufhw",{ XM, EXx, Ib } },
2706 { "pshufd", { XM, EXx, Ib } },
2707 { "pshuflw",{ XM, EXx, Ib } },
2710 /* PREFIX_0F73_REG_3 */
2712 { "(bad)", { XX } },
2713 { "(bad)", { XX } },
2714 { "psrldq", { XS, Ib } },
2715 { "(bad)", { XX } },
2718 /* PREFIX_0F73_REG_7 */
2720 { "(bad)", { XX } },
2721 { "(bad)", { XX } },
2722 { "pslldq", { XS, Ib } },
2723 { "(bad)", { XX } },
2728 {"vmread", { Em, Gm } },
2730 {"extrq", { XS, Ib, Ib } },
2731 {"insertq", { XM, XS, Ib, Ib } },
2736 {"vmwrite", { Gm, Em } },
2738 {"extrq", { XM, XS } },
2739 {"insertq", { XM, XS } },
2744 { "(bad)", { XX } },
2745 { "(bad)", { XX } },
2746 { "haddpd", { XM, EXx } },
2747 { "haddps", { XM, EXx } },
2752 { "(bad)", { XX } },
2753 { "(bad)", { XX } },
2754 { "hsubpd", { XM, EXx } },
2755 { "hsubps", { XM, EXx } },
2760 { "movK", { Edq, MX } },
2761 { "movq", { XM, EXq } },
2762 { "movK", { Edq, XM } },
2763 { "(bad)", { XX } },
2768 { "movq", { EMS, MX } },
2769 { "movdqu", { EXxS, XM } },
2770 { "movdqa", { EXxS, XM } },
2771 { "(bad)", { XX } },
2776 { "(bad)", { XX } },
2777 { "popcntS", { Gv, Ev } },
2778 { "(bad)", { XX } },
2779 { "(bad)", { XX } },
2784 { "bsrS", { Gv, Ev } },
2785 { "lzcntS", { Gv, Ev } },
2786 { "bsrS", { Gv, Ev } },
2787 { "(bad)", { XX } },
2792 { "cmpps", { XM, EXx, CMP } },
2793 { "cmpss", { XM, EXd, CMP } },
2794 { "cmppd", { XM, EXx, CMP } },
2795 { "cmpsd", { XM, EXq, CMP } },
2800 { "movntiS", { Ma, Gv } },
2801 { "(bad)", { XX } },
2802 { "(bad)", { XX } },
2803 { "(bad)", { XX } },
2806 /* PREFIX_0FC7_REG_6 */
2808 { "vmptrld",{ Mq } },
2809 { "vmxon", { Mq } },
2810 { "vmclear",{ Mq } },
2811 { "(bad)", { XX } },
2816 { "(bad)", { XX } },
2817 { "(bad)", { XX } },
2818 { "addsubpd", { XM, EXx } },
2819 { "addsubps", { XM, EXx } },
2824 { "(bad)", { XX } },
2825 { "movq2dq",{ XM, MS } },
2826 { "movq", { EXqS, XM } },
2827 { "movdq2q",{ MX, XS } },
2832 { "(bad)", { XX } },
2833 { "cvtdq2pd", { XM, EXq } },
2834 { "cvttpd2dq", { XM, EXx } },
2835 { "cvtpd2dq", { XM, EXx } },
2840 { "movntq", { Mq, MX } },
2841 { "(bad)", { XX } },
2842 { MOD_TABLE (MOD_0FE7_PREFIX_2) },
2843 { "(bad)", { XX } },
2848 { "(bad)", { XX } },
2849 { "(bad)", { XX } },
2850 { "(bad)", { XX } },
2851 { MOD_TABLE (MOD_0FF0_PREFIX_3) },
2856 { "maskmovq", { MX, MS } },
2857 { "(bad)", { XX } },
2858 { "maskmovdqu", { XM, XS } },
2859 { "(bad)", { XX } },
2864 { "(bad)", { XX } },
2865 { "(bad)", { XX } },
2866 { "pblendvb", { XM, EXx, XMM0 } },
2867 { "(bad)", { XX } },
2872 { "(bad)", { XX } },
2873 { "(bad)", { XX } },
2874 { "blendvps", { XM, EXx, XMM0 } },
2875 { "(bad)", { XX } },
2880 { "(bad)", { XX } },
2881 { "(bad)", { XX } },
2882 { "blendvpd", { XM, EXx, XMM0 } },
2883 { "(bad)", { XX } },
2888 { "(bad)", { XX } },
2889 { "(bad)", { XX } },
2890 { "ptest", { XM, EXx } },
2891 { "(bad)", { XX } },
2896 { "(bad)", { XX } },
2897 { "(bad)", { XX } },
2898 { "pmovsxbw", { XM, EXq } },
2899 { "(bad)", { XX } },
2904 { "(bad)", { XX } },
2905 { "(bad)", { XX } },
2906 { "pmovsxbd", { XM, EXd } },
2907 { "(bad)", { XX } },
2912 { "(bad)", { XX } },
2913 { "(bad)", { XX } },
2914 { "pmovsxbq", { XM, EXw } },
2915 { "(bad)", { XX } },
2920 { "(bad)", { XX } },
2921 { "(bad)", { XX } },
2922 { "pmovsxwd", { XM, EXq } },
2923 { "(bad)", { XX } },
2928 { "(bad)", { XX } },
2929 { "(bad)", { XX } },
2930 { "pmovsxwq", { XM, EXd } },
2931 { "(bad)", { XX } },
2936 { "(bad)", { XX } },
2937 { "(bad)", { XX } },
2938 { "pmovsxdq", { XM, EXq } },
2939 { "(bad)", { XX } },
2944 { "(bad)", { XX } },
2945 { "(bad)", { XX } },
2946 { "pmuldq", { XM, EXx } },
2947 { "(bad)", { XX } },
2952 { "(bad)", { XX } },
2953 { "(bad)", { XX } },
2954 { "pcmpeqq", { XM, EXx } },
2955 { "(bad)", { XX } },
2960 { "(bad)", { XX } },
2961 { "(bad)", { XX } },
2962 { MOD_TABLE (MOD_0F382A_PREFIX_2) },
2963 { "(bad)", { XX } },
2968 { "(bad)", { XX } },
2969 { "(bad)", { XX } },
2970 { "packusdw", { XM, EXx } },
2971 { "(bad)", { XX } },
2976 { "(bad)", { XX } },
2977 { "(bad)", { XX } },
2978 { "pmovzxbw", { XM, EXq } },
2979 { "(bad)", { XX } },
2984 { "(bad)", { XX } },
2985 { "(bad)", { XX } },
2986 { "pmovzxbd", { XM, EXd } },
2987 { "(bad)", { XX } },
2992 { "(bad)", { XX } },
2993 { "(bad)", { XX } },
2994 { "pmovzxbq", { XM, EXw } },
2995 { "(bad)", { XX } },
3000 { "(bad)", { XX } },
3001 { "(bad)", { XX } },
3002 { "pmovzxwd", { XM, EXq } },
3003 { "(bad)", { XX } },
3008 { "(bad)", { XX } },
3009 { "(bad)", { XX } },
3010 { "pmovzxwq", { XM, EXd } },
3011 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "(bad)", { XX } },
3018 { "pmovzxdq", { XM, EXq } },
3019 { "(bad)", { XX } },
3024 { "(bad)", { XX } },
3025 { "(bad)", { XX } },
3026 { "pcmpgtq", { XM, EXx } },
3027 { "(bad)", { XX } },
3032 { "(bad)", { XX } },
3033 { "(bad)", { XX } },
3034 { "pminsb", { XM, EXx } },
3035 { "(bad)", { XX } },
3040 { "(bad)", { XX } },
3041 { "(bad)", { XX } },
3042 { "pminsd", { XM, EXx } },
3043 { "(bad)", { XX } },
3048 { "(bad)", { XX } },
3049 { "(bad)", { XX } },
3050 { "pminuw", { XM, EXx } },
3051 { "(bad)", { XX } },
3056 { "(bad)", { XX } },
3057 { "(bad)", { XX } },
3058 { "pminud", { XM, EXx } },
3059 { "(bad)", { XX } },
3064 { "(bad)", { XX } },
3065 { "(bad)", { XX } },
3066 { "pmaxsb", { XM, EXx } },
3067 { "(bad)", { XX } },
3072 { "(bad)", { XX } },
3073 { "(bad)", { XX } },
3074 { "pmaxsd", { XM, EXx } },
3075 { "(bad)", { XX } },
3080 { "(bad)", { XX } },
3081 { "(bad)", { XX } },
3082 { "pmaxuw", { XM, EXx } },
3083 { "(bad)", { XX } },
3088 { "(bad)", { XX } },
3089 { "(bad)", { XX } },
3090 { "pmaxud", { XM, EXx } },
3091 { "(bad)", { XX } },
3096 { "(bad)", { XX } },
3097 { "(bad)", { XX } },
3098 { "pmulld", { XM, EXx } },
3099 { "(bad)", { XX } },
3104 { "(bad)", { XX } },
3105 { "(bad)", { XX } },
3106 { "phminposuw", { XM, EXx } },
3107 { "(bad)", { XX } },
3112 { "(bad)", { XX } },
3113 { "(bad)", { XX } },
3114 { "invept", { Gm, Mo } },
3115 { "(bad)", { XX } },
3120 { "(bad)", { XX } },
3121 { "(bad)", { XX } },
3122 { "invvpid", { Gm, Mo } },
3123 { "(bad)", { XX } },
3128 { "(bad)", { XX } },
3129 { "(bad)", { XX } },
3130 { "aesimc", { XM, EXx } },
3131 { "(bad)", { XX } },
3136 { "(bad)", { XX } },
3137 { "(bad)", { XX } },
3138 { "aesenc", { XM, EXx } },
3139 { "(bad)", { XX } },
3144 { "(bad)", { XX } },
3145 { "(bad)", { XX } },
3146 { "aesenclast", { XM, EXx } },
3147 { "(bad)", { XX } },
3152 { "(bad)", { XX } },
3153 { "(bad)", { XX } },
3154 { "aesdec", { XM, EXx } },
3155 { "(bad)", { XX } },
3160 { "(bad)", { XX } },
3161 { "(bad)", { XX } },
3162 { "aesdeclast", { XM, EXx } },
3163 { "(bad)", { XX } },
3168 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3169 { "(bad)", { XX } },
3170 { "movbeS", { Gv, { MOVBE_Fixup, v_mode } } },
3171 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
3176 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3177 { "(bad)", { XX } },
3178 { "movbeS", { { MOVBE_Fixup, v_mode }, Gv } },
3179 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
3184 { "(bad)", { XX } },
3185 { "(bad)", { XX } },
3186 { "roundps", { XM, EXx, Ib } },
3187 { "(bad)", { XX } },
3192 { "(bad)", { XX } },
3193 { "(bad)", { XX } },
3194 { "roundpd", { XM, EXx, Ib } },
3195 { "(bad)", { XX } },
3200 { "(bad)", { XX } },
3201 { "(bad)", { XX } },
3202 { "roundss", { XM, EXd, Ib } },
3203 { "(bad)", { XX } },
3208 { "(bad)", { XX } },
3209 { "(bad)", { XX } },
3210 { "roundsd", { XM, EXq, Ib } },
3211 { "(bad)", { XX } },
3216 { "(bad)", { XX } },
3217 { "(bad)", { XX } },
3218 { "blendps", { XM, EXx, Ib } },
3219 { "(bad)", { XX } },
3224 { "(bad)", { XX } },
3225 { "(bad)", { XX } },
3226 { "blendpd", { XM, EXx, Ib } },
3227 { "(bad)", { XX } },
3232 { "(bad)", { XX } },
3233 { "(bad)", { XX } },
3234 { "pblendw", { XM, EXx, Ib } },
3235 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "(bad)", { XX } },
3242 { "pextrb", { Edqb, XM, Ib } },
3243 { "(bad)", { XX } },
3248 { "(bad)", { XX } },
3249 { "(bad)", { XX } },
3250 { "pextrw", { Edqw, XM, Ib } },
3251 { "(bad)", { XX } },
3256 { "(bad)", { XX } },
3257 { "(bad)", { XX } },
3258 { "pextrK", { Edq, XM, Ib } },
3259 { "(bad)", { XX } },
3264 { "(bad)", { XX } },
3265 { "(bad)", { XX } },
3266 { "extractps", { Edqd, XM, Ib } },
3267 { "(bad)", { XX } },
3272 { "(bad)", { XX } },
3273 { "(bad)", { XX } },
3274 { "pinsrb", { XM, Edqb, Ib } },
3275 { "(bad)", { XX } },
3280 { "(bad)", { XX } },
3281 { "(bad)", { XX } },
3282 { "insertps", { XM, EXd, Ib } },
3283 { "(bad)", { XX } },
3288 { "(bad)", { XX } },
3289 { "(bad)", { XX } },
3290 { "pinsrK", { XM, Edq, Ib } },
3291 { "(bad)", { XX } },
3296 { "(bad)", { XX } },
3297 { "(bad)", { XX } },
3298 { "dpps", { XM, EXx, Ib } },
3299 { "(bad)", { XX } },
3304 { "(bad)", { XX } },
3305 { "(bad)", { XX } },
3306 { "dppd", { XM, EXx, Ib } },
3307 { "(bad)", { XX } },
3312 { "(bad)", { XX } },
3313 { "(bad)", { XX } },
3314 { "mpsadbw", { XM, EXx, Ib } },
3315 { "(bad)", { XX } },
3320 { "(bad)", { XX } },
3321 { "(bad)", { XX } },
3322 { "pclmulqdq", { XM, EXx, PCLMUL } },
3323 { "(bad)", { XX } },
3328 { "(bad)", { XX } },
3329 { "(bad)", { XX } },
3330 { "pcmpestrm", { XM, EXx, Ib } },
3331 { "(bad)", { XX } },
3336 { "(bad)", { XX } },
3337 { "(bad)", { XX } },
3338 { "pcmpestri", { XM, EXx, Ib } },
3339 { "(bad)", { XX } },
3344 { "(bad)", { XX } },
3345 { "(bad)", { XX } },
3346 { "pcmpistrm", { XM, EXx, Ib } },
3347 { "(bad)", { XX } },
3352 { "(bad)", { XX } },
3353 { "(bad)", { XX } },
3354 { "pcmpistri", { XM, EXx, Ib } },
3355 { "(bad)", { XX } },
3360 { "(bad)", { XX } },
3361 { "(bad)", { XX } },
3362 { "aeskeygenassist", { XM, EXx, Ib } },
3363 { "(bad)", { XX } },
3368 { "vmovups", { XM, EXx } },
3369 { VEX_LEN_TABLE (VEX_LEN_10_P_1) },
3370 { "vmovupd", { XM, EXx } },
3371 { VEX_LEN_TABLE (VEX_LEN_10_P_3) },
3376 { "vmovups", { EXxS, XM } },
3377 { VEX_LEN_TABLE (VEX_LEN_11_P_1) },
3378 { "vmovupd", { EXxS, XM } },
3379 { VEX_LEN_TABLE (VEX_LEN_11_P_3) },
3384 { MOD_TABLE (MOD_VEX_12_PREFIX_0) },
3385 { "vmovsldup", { XM, EXx } },
3386 { VEX_LEN_TABLE (VEX_LEN_12_P_2) },
3387 { "vmovddup", { XM, EXymmq } },
3392 { MOD_TABLE (MOD_VEX_16_PREFIX_0) },
3393 { "vmovshdup", { XM, EXx } },
3394 { VEX_LEN_TABLE (VEX_LEN_16_P_2) },
3395 { "(bad)", { XX } },
3400 { "(bad)", { XX } },
3401 { VEX_LEN_TABLE (VEX_LEN_2A_P_1) },
3402 { "(bad)", { XX } },
3403 { VEX_LEN_TABLE (VEX_LEN_2A_P_3) },
3408 { "(bad)", { XX } },
3409 { VEX_LEN_TABLE (VEX_LEN_2C_P_1) },
3410 { "(bad)", { XX } },
3411 { VEX_LEN_TABLE (VEX_LEN_2C_P_3) },
3416 { "(bad)", { XX } },
3417 { VEX_LEN_TABLE (VEX_LEN_2D_P_1) },
3418 { "(bad)", { XX } },
3419 { VEX_LEN_TABLE (VEX_LEN_2D_P_3) },
3424 { VEX_LEN_TABLE (VEX_LEN_2E_P_0) },
3425 { "(bad)", { XX } },
3426 { VEX_LEN_TABLE (VEX_LEN_2E_P_2) },
3427 { "(bad)", { XX } },
3432 { VEX_LEN_TABLE (VEX_LEN_2F_P_0) },
3433 { "(bad)", { XX } },
3434 { VEX_LEN_TABLE (VEX_LEN_2F_P_2) },
3435 { "(bad)", { XX } },
3440 { "vsqrtps", { XM, EXx } },
3441 { VEX_LEN_TABLE (VEX_LEN_51_P_1) },
3442 { "vsqrtpd", { XM, EXx } },
3443 { VEX_LEN_TABLE (VEX_LEN_51_P_3) },
3448 { "vrsqrtps", { XM, EXx } },
3449 { VEX_LEN_TABLE (VEX_LEN_52_P_1) },
3450 { "(bad)", { XX } },
3451 { "(bad)", { XX } },
3456 { "vrcpps", { XM, EXx } },
3457 { VEX_LEN_TABLE (VEX_LEN_53_P_1) },
3458 { "(bad)", { XX } },
3459 { "(bad)", { XX } },
3464 { "vaddps", { XM, Vex, EXx } },
3465 { VEX_LEN_TABLE (VEX_LEN_58_P_1) },
3466 { "vaddpd", { XM, Vex, EXx } },
3467 { VEX_LEN_TABLE (VEX_LEN_58_P_3) },
3472 { "vmulps", { XM, Vex, EXx } },
3473 { VEX_LEN_TABLE (VEX_LEN_59_P_1) },
3474 { "vmulpd", { XM, Vex, EXx } },
3475 { VEX_LEN_TABLE (VEX_LEN_59_P_3) },
3480 { "vcvtps2pd", { XM, EXxmmq } },
3481 { VEX_LEN_TABLE (VEX_LEN_5A_P_1) },
3482 { "vcvtpd2ps%XY", { XMM, EXx } },
3483 { VEX_LEN_TABLE (VEX_LEN_5A_P_3) },
3488 { "vcvtdq2ps", { XM, EXx } },
3489 { "vcvttps2dq", { XM, EXx } },
3490 { "vcvtps2dq", { XM, EXx } },
3491 { "(bad)", { XX } },
3496 { "vsubps", { XM, Vex, EXx } },
3497 { VEX_LEN_TABLE (VEX_LEN_5C_P_1) },
3498 { "vsubpd", { XM, Vex, EXx } },
3499 { VEX_LEN_TABLE (VEX_LEN_5C_P_3) },
3504 { "vminps", { XM, Vex, EXx } },
3505 { VEX_LEN_TABLE (VEX_LEN_5D_P_1) },
3506 { "vminpd", { XM, Vex, EXx } },
3507 { VEX_LEN_TABLE (VEX_LEN_5D_P_3) },
3512 { "vdivps", { XM, Vex, EXx } },
3513 { VEX_LEN_TABLE (VEX_LEN_5E_P_1) },
3514 { "vdivpd", { XM, Vex, EXx } },
3515 { VEX_LEN_TABLE (VEX_LEN_5E_P_3) },
3520 { "vmaxps", { XM, Vex, EXx } },
3521 { VEX_LEN_TABLE (VEX_LEN_5F_P_1) },
3522 { "vmaxpd", { XM, Vex, EXx } },
3523 { VEX_LEN_TABLE (VEX_LEN_5F_P_3) },
3528 { "(bad)", { XX } },
3529 { "(bad)", { XX } },
3530 { VEX_LEN_TABLE (VEX_LEN_60_P_2) },
3531 { "(bad)", { XX } },
3536 { "(bad)", { XX } },
3537 { "(bad)", { XX } },
3538 { VEX_LEN_TABLE (VEX_LEN_61_P_2) },
3539 { "(bad)", { XX } },
3544 { "(bad)", { XX } },
3545 { "(bad)", { XX } },
3546 { VEX_LEN_TABLE (VEX_LEN_62_P_2) },
3547 { "(bad)", { XX } },
3552 { "(bad)", { XX } },
3553 { "(bad)", { XX } },
3554 { VEX_LEN_TABLE (VEX_LEN_63_P_2) },
3555 { "(bad)", { XX } },
3560 { "(bad)", { XX } },
3561 { "(bad)", { XX } },
3562 { VEX_LEN_TABLE (VEX_LEN_64_P_2) },
3563 { "(bad)", { XX } },
3568 { "(bad)", { XX } },
3569 { "(bad)", { XX } },
3570 { VEX_LEN_TABLE (VEX_LEN_65_P_2) },
3571 { "(bad)", { XX } },
3576 { "(bad)", { XX } },
3577 { "(bad)", { XX } },
3578 { VEX_LEN_TABLE (VEX_LEN_66_P_2) },
3579 { "(bad)", { XX } },
3584 { "(bad)", { XX } },
3585 { "(bad)", { XX } },
3586 { VEX_LEN_TABLE (VEX_LEN_67_P_2) },
3587 { "(bad)", { XX } },
3592 { "(bad)", { XX } },
3593 { "(bad)", { XX } },
3594 { VEX_LEN_TABLE (VEX_LEN_68_P_2) },
3595 { "(bad)", { XX } },
3600 { "(bad)", { XX } },
3601 { "(bad)", { XX } },
3602 { VEX_LEN_TABLE (VEX_LEN_69_P_2) },
3603 { "(bad)", { XX } },
3608 { "(bad)", { XX } },
3609 { "(bad)", { XX } },
3610 { VEX_LEN_TABLE (VEX_LEN_6A_P_2) },
3611 { "(bad)", { XX } },
3616 { "(bad)", { XX } },
3617 { "(bad)", { XX } },
3618 { VEX_LEN_TABLE (VEX_LEN_6B_P_2) },
3619 { "(bad)", { XX } },
3624 { "(bad)", { XX } },
3625 { "(bad)", { XX } },
3626 { VEX_LEN_TABLE (VEX_LEN_6C_P_2) },
3627 { "(bad)", { XX } },
3632 { "(bad)", { XX } },
3633 { "(bad)", { XX } },
3634 { VEX_LEN_TABLE (VEX_LEN_6D_P_2) },
3635 { "(bad)", { XX } },
3640 { "(bad)", { XX } },
3641 { "(bad)", { XX } },
3642 { VEX_LEN_TABLE (VEX_LEN_6E_P_2) },
3643 { "(bad)", { XX } },
3648 { "(bad)", { XX } },
3649 { "vmovdqu", { XM, EXx } },
3650 { "vmovdqa", { XM, EXx } },
3651 { "(bad)", { XX } },
3656 { "(bad)", { XX } },
3657 { VEX_LEN_TABLE (VEX_LEN_70_P_1) },
3658 { VEX_LEN_TABLE (VEX_LEN_70_P_2) },
3659 { VEX_LEN_TABLE (VEX_LEN_70_P_3) },
3662 /* PREFIX_VEX_71_REG_2 */
3664 { "(bad)", { XX } },
3665 { "(bad)", { XX } },
3666 { VEX_LEN_TABLE (VEX_LEN_71_R_2_P_2) },
3667 { "(bad)", { XX } },
3670 /* PREFIX_VEX_71_REG_4 */
3672 { "(bad)", { XX } },
3673 { "(bad)", { XX } },
3674 { VEX_LEN_TABLE (VEX_LEN_71_R_4_P_2) },
3675 { "(bad)", { XX } },
3678 /* PREFIX_VEX_71_REG_6 */
3680 { "(bad)", { XX } },
3681 { "(bad)", { XX } },
3682 { VEX_LEN_TABLE (VEX_LEN_71_R_6_P_2) },
3683 { "(bad)", { XX } },
3686 /* PREFIX_VEX_72_REG_2 */
3688 { "(bad)", { XX } },
3689 { "(bad)", { XX } },
3690 { VEX_LEN_TABLE (VEX_LEN_72_R_2_P_2) },
3691 { "(bad)", { XX } },
3694 /* PREFIX_VEX_72_REG_4 */
3696 { "(bad)", { XX } },
3697 { "(bad)", { XX } },
3698 { VEX_LEN_TABLE (VEX_LEN_72_R_4_P_2) },
3699 { "(bad)", { XX } },
3702 /* PREFIX_VEX_72_REG_6 */
3704 { "(bad)", { XX } },
3705 { "(bad)", { XX } },
3706 { VEX_LEN_TABLE (VEX_LEN_72_R_6_P_2) },
3707 { "(bad)", { XX } },
3710 /* PREFIX_VEX_73_REG_2 */
3712 { "(bad)", { XX } },
3713 { "(bad)", { XX } },
3714 { VEX_LEN_TABLE (VEX_LEN_73_R_2_P_2) },
3715 { "(bad)", { XX } },
3718 /* PREFIX_VEX_73_REG_3 */
3720 { "(bad)", { XX } },
3721 { "(bad)", { XX } },
3722 { VEX_LEN_TABLE (VEX_LEN_73_R_3_P_2) },
3723 { "(bad)", { XX } },
3726 /* PREFIX_VEX_73_REG_6 */
3728 { "(bad)", { XX } },
3729 { "(bad)", { XX } },
3730 { VEX_LEN_TABLE (VEX_LEN_73_R_6_P_2) },
3731 { "(bad)", { XX } },
3734 /* PREFIX_VEX_73_REG_7 */
3736 { "(bad)", { XX } },
3737 { "(bad)", { XX } },
3738 { VEX_LEN_TABLE (VEX_LEN_73_R_7_P_2) },
3739 { "(bad)", { XX } },
3744 { "(bad)", { XX } },
3745 { "(bad)", { XX } },
3746 { VEX_LEN_TABLE (VEX_LEN_74_P_2) },
3747 { "(bad)", { XX } },
3752 { "(bad)", { XX } },
3753 { "(bad)", { XX } },
3754 { VEX_LEN_TABLE (VEX_LEN_75_P_2) },
3755 { "(bad)", { XX } },
3760 { "(bad)", { XX } },
3761 { "(bad)", { XX } },
3762 { VEX_LEN_TABLE (VEX_LEN_76_P_2) },
3763 { "(bad)", { XX } },
3769 { "(bad)", { XX } },
3770 { "(bad)", { XX } },
3771 { "(bad)", { XX } },
3776 { "(bad)", { XX } },
3777 { "(bad)", { XX } },
3778 { "vhaddpd", { XM, Vex, EXx } },
3779 { "vhaddps", { XM, Vex, EXx } },
3784 { "(bad)", { XX } },
3785 { "(bad)", { XX } },
3786 { "vhsubpd", { XM, Vex, EXx } },
3787 { "vhsubps", { XM, Vex, EXx } },
3792 { "(bad)", { XX } },
3793 { VEX_LEN_TABLE (VEX_LEN_7E_P_1) },
3794 { VEX_LEN_TABLE (VEX_LEN_7E_P_2) },
3795 { "(bad)", { XX } },
3800 { "(bad)", { XX } },
3801 { "vmovdqu", { EXxS, XM } },
3802 { "vmovdqa", { EXxS, XM } },
3803 { "(bad)", { XX } },
3808 { "vcmpps", { XM, Vex, EXx, VCMP } },
3809 { VEX_LEN_TABLE (VEX_LEN_C2_P_1) },
3810 { "vcmppd", { XM, Vex, EXx, VCMP } },
3811 { VEX_LEN_TABLE (VEX_LEN_C2_P_3) },
3816 { "(bad)", { XX } },
3817 { "(bad)", { XX } },
3818 { VEX_LEN_TABLE (VEX_LEN_C4_P_2) },
3819 { "(bad)", { XX } },
3824 { "(bad)", { XX } },
3825 { "(bad)", { XX } },
3826 { VEX_LEN_TABLE (VEX_LEN_C5_P_2) },
3827 { "(bad)", { XX } },
3832 { "(bad)", { XX } },
3833 { "(bad)", { XX } },
3834 { "vaddsubpd", { XM, Vex, EXx } },
3835 { "vaddsubps", { XM, Vex, EXx } },
3840 { "(bad)", { XX } },
3841 { "(bad)", { XX } },
3842 { VEX_LEN_TABLE (VEX_LEN_D1_P_2) },
3843 { "(bad)", { XX } },
3848 { "(bad)", { XX } },
3849 { "(bad)", { XX } },
3850 { VEX_LEN_TABLE (VEX_LEN_D2_P_2) },
3851 { "(bad)", { XX } },
3856 { "(bad)", { XX } },
3857 { "(bad)", { XX } },
3858 { VEX_LEN_TABLE (VEX_LEN_D3_P_2) },
3859 { "(bad)", { XX } },
3864 { "(bad)", { XX } },
3865 { "(bad)", { XX } },
3866 { VEX_LEN_TABLE (VEX_LEN_D4_P_2) },
3867 { "(bad)", { XX } },
3872 { "(bad)", { XX } },
3873 { "(bad)", { XX } },
3874 { VEX_LEN_TABLE (VEX_LEN_D5_P_2) },
3875 { "(bad)", { XX } },
3880 { "(bad)", { XX } },
3881 { "(bad)", { XX } },
3882 { VEX_LEN_TABLE (VEX_LEN_D6_P_2) },
3883 { "(bad)", { XX } },
3888 { "(bad)", { XX } },
3889 { "(bad)", { XX } },
3890 { MOD_TABLE (MOD_VEX_D7_PREFIX_2) },
3891 { "(bad)", { XX } },
3896 { "(bad)", { XX } },
3897 { "(bad)", { XX } },
3898 { VEX_LEN_TABLE (VEX_LEN_D8_P_2) },
3899 { "(bad)", { XX } },
3904 { "(bad)", { XX } },
3905 { "(bad)", { XX } },
3906 { VEX_LEN_TABLE (VEX_LEN_D9_P_2) },
3907 { "(bad)", { XX } },
3912 { "(bad)", { XX } },
3913 { "(bad)", { XX } },
3914 { VEX_LEN_TABLE (VEX_LEN_DA_P_2) },
3915 { "(bad)", { XX } },
3920 { "(bad)", { XX } },
3921 { "(bad)", { XX } },
3922 { VEX_LEN_TABLE (VEX_LEN_DB_P_2) },
3923 { "(bad)", { XX } },
3928 { "(bad)", { XX } },
3929 { "(bad)", { XX } },
3930 { VEX_LEN_TABLE (VEX_LEN_DC_P_2) },
3931 { "(bad)", { XX } },
3936 { "(bad)", { XX } },
3937 { "(bad)", { XX } },
3938 { VEX_LEN_TABLE (VEX_LEN_DD_P_2) },
3939 { "(bad)", { XX } },
3944 { "(bad)", { XX } },
3945 { "(bad)", { XX } },
3946 { VEX_LEN_TABLE (VEX_LEN_DE_P_2) },
3947 { "(bad)", { XX } },
3952 { "(bad)", { XX } },
3953 { "(bad)", { XX } },
3954 { VEX_LEN_TABLE (VEX_LEN_DF_P_2) },
3955 { "(bad)", { XX } },
3960 { "(bad)", { XX } },
3961 { "(bad)", { XX } },
3962 { VEX_LEN_TABLE (VEX_LEN_E0_P_2) },
3963 { "(bad)", { XX } },
3968 { "(bad)", { XX } },
3969 { "(bad)", { XX } },
3970 { VEX_LEN_TABLE (VEX_LEN_E1_P_2) },
3971 { "(bad)", { XX } },
3976 { "(bad)", { XX } },
3977 { "(bad)", { XX } },
3978 { VEX_LEN_TABLE (VEX_LEN_E2_P_2) },
3979 { "(bad)", { XX } },
3984 { "(bad)", { XX } },
3985 { "(bad)", { XX } },
3986 { VEX_LEN_TABLE (VEX_LEN_E3_P_2) },
3987 { "(bad)", { XX } },
3992 { "(bad)", { XX } },
3993 { "(bad)", { XX } },
3994 { VEX_LEN_TABLE (VEX_LEN_E4_P_2) },
3995 { "(bad)", { XX } },
4000 { "(bad)", { XX } },
4001 { "(bad)", { XX } },
4002 { VEX_LEN_TABLE (VEX_LEN_E5_P_2) },
4003 { "(bad)", { XX } },
4008 { "(bad)", { XX } },
4009 { "vcvtdq2pd", { XM, EXxmmq } },
4010 { "vcvttpd2dq%XY", { XMM, EXx } },
4011 { "vcvtpd2dq%XY", { XMM, EXx } },
4016 { "(bad)", { XX } },
4017 { "(bad)", { XX } },
4018 { MOD_TABLE (MOD_VEX_E7_PREFIX_2) },
4019 { "(bad)", { XX } },
4024 { "(bad)", { XX } },
4025 { "(bad)", { XX } },
4026 { VEX_LEN_TABLE (VEX_LEN_E8_P_2) },
4027 { "(bad)", { XX } },
4032 { "(bad)", { XX } },
4033 { "(bad)", { XX } },
4034 { VEX_LEN_TABLE (VEX_LEN_E9_P_2) },
4035 { "(bad)", { XX } },
4040 { "(bad)", { XX } },
4041 { "(bad)", { XX } },
4042 { VEX_LEN_TABLE (VEX_LEN_EA_P_2) },
4043 { "(bad)", { XX } },
4048 { "(bad)", { XX } },
4049 { "(bad)", { XX } },
4050 { VEX_LEN_TABLE (VEX_LEN_EB_P_2) },
4051 { "(bad)", { XX } },
4056 { "(bad)", { XX } },
4057 { "(bad)", { XX } },
4058 { VEX_LEN_TABLE (VEX_LEN_EC_P_2) },
4059 { "(bad)", { XX } },
4064 { "(bad)", { XX } },
4065 { "(bad)", { XX } },
4066 { VEX_LEN_TABLE (VEX_LEN_ED_P_2) },
4067 { "(bad)", { XX } },
4072 { "(bad)", { XX } },
4073 { "(bad)", { XX } },
4074 { VEX_LEN_TABLE (VEX_LEN_EE_P_2) },
4075 { "(bad)", { XX } },
4080 { "(bad)", { XX } },
4081 { "(bad)", { XX } },
4082 { VEX_LEN_TABLE (VEX_LEN_EF_P_2) },
4083 { "(bad)", { XX } },
4088 { "(bad)", { XX } },
4089 { "(bad)", { XX } },
4090 { "(bad)", { XX } },
4091 { MOD_TABLE (MOD_VEX_F0_PREFIX_3) },
4096 { "(bad)", { XX } },
4097 { "(bad)", { XX } },
4098 { VEX_LEN_TABLE (VEX_LEN_F1_P_2) },
4099 { "(bad)", { XX } },
4104 { "(bad)", { XX } },
4105 { "(bad)", { XX } },
4106 { VEX_LEN_TABLE (VEX_LEN_F2_P_2) },
4107 { "(bad)", { XX } },
4112 { "(bad)", { XX } },
4113 { "(bad)", { XX } },
4114 { VEX_LEN_TABLE (VEX_LEN_F3_P_2) },
4115 { "(bad)", { XX } },
4120 { "(bad)", { XX } },
4121 { "(bad)", { XX } },
4122 { VEX_LEN_TABLE (VEX_LEN_F4_P_2) },
4123 { "(bad)", { XX } },
4128 { "(bad)", { XX } },
4129 { "(bad)", { XX } },
4130 { VEX_LEN_TABLE (VEX_LEN_F5_P_2) },
4131 { "(bad)", { XX } },
4136 { "(bad)", { XX } },
4137 { "(bad)", { XX } },
4138 { VEX_LEN_TABLE (VEX_LEN_F6_P_2) },
4139 { "(bad)", { XX } },
4144 { "(bad)", { XX } },
4145 { "(bad)", { XX } },
4146 { VEX_LEN_TABLE (VEX_LEN_F7_P_2) },
4147 { "(bad)", { XX } },
4152 { "(bad)", { XX } },
4153 { "(bad)", { XX } },
4154 { VEX_LEN_TABLE (VEX_LEN_F8_P_2) },
4155 { "(bad)", { XX } },
4160 { "(bad)", { XX } },
4161 { "(bad)", { XX } },
4162 { VEX_LEN_TABLE (VEX_LEN_F9_P_2) },
4163 { "(bad)", { XX } },
4168 { "(bad)", { XX } },
4169 { "(bad)", { XX } },
4170 { VEX_LEN_TABLE (VEX_LEN_FA_P_2) },
4171 { "(bad)", { XX } },
4176 { "(bad)", { XX } },
4177 { "(bad)", { XX } },
4178 { VEX_LEN_TABLE (VEX_LEN_FB_P_2) },
4179 { "(bad)", { XX } },
4184 { "(bad)", { XX } },
4185 { "(bad)", { XX } },
4186 { VEX_LEN_TABLE (VEX_LEN_FC_P_2) },
4187 { "(bad)", { XX } },
4192 { "(bad)", { XX } },
4193 { "(bad)", { XX } },
4194 { VEX_LEN_TABLE (VEX_LEN_FD_P_2) },
4195 { "(bad)", { XX } },
4200 { "(bad)", { XX } },
4201 { "(bad)", { XX } },
4202 { VEX_LEN_TABLE (VEX_LEN_FE_P_2) },
4203 { "(bad)", { XX } },
4206 /* PREFIX_VEX_3800 */
4208 { "(bad)", { XX } },
4209 { "(bad)", { XX } },
4210 { VEX_LEN_TABLE (VEX_LEN_3800_P_2) },
4211 { "(bad)", { XX } },
4214 /* PREFIX_VEX_3801 */
4216 { "(bad)", { XX } },
4217 { "(bad)", { XX } },
4218 { VEX_LEN_TABLE (VEX_LEN_3801_P_2) },
4219 { "(bad)", { XX } },
4222 /* PREFIX_VEX_3802 */
4224 { "(bad)", { XX } },
4225 { "(bad)", { XX } },
4226 { VEX_LEN_TABLE (VEX_LEN_3802_P_2) },
4227 { "(bad)", { XX } },
4230 /* PREFIX_VEX_3803 */
4232 { "(bad)", { XX } },
4233 { "(bad)", { XX } },
4234 { VEX_LEN_TABLE (VEX_LEN_3803_P_2) },
4235 { "(bad)", { XX } },
4238 /* PREFIX_VEX_3804 */
4240 { "(bad)", { XX } },
4241 { "(bad)", { XX } },
4242 { VEX_LEN_TABLE (VEX_LEN_3804_P_2) },
4243 { "(bad)", { XX } },
4246 /* PREFIX_VEX_3805 */
4248 { "(bad)", { XX } },
4249 { "(bad)", { XX } },
4250 { VEX_LEN_TABLE (VEX_LEN_3805_P_2) },
4251 { "(bad)", { XX } },
4254 /* PREFIX_VEX_3806 */
4256 { "(bad)", { XX } },
4257 { "(bad)", { XX } },
4258 { VEX_LEN_TABLE (VEX_LEN_3806_P_2) },
4259 { "(bad)", { XX } },
4262 /* PREFIX_VEX_3807 */
4264 { "(bad)", { XX } },
4265 { "(bad)", { XX } },
4266 { VEX_LEN_TABLE (VEX_LEN_3807_P_2) },
4267 { "(bad)", { XX } },
4270 /* PREFIX_VEX_3808 */
4272 { "(bad)", { XX } },
4273 { "(bad)", { XX } },
4274 { VEX_LEN_TABLE (VEX_LEN_3808_P_2) },
4275 { "(bad)", { XX } },
4278 /* PREFIX_VEX_3809 */
4280 { "(bad)", { XX } },
4281 { "(bad)", { XX } },
4282 { VEX_LEN_TABLE (VEX_LEN_3809_P_2) },
4283 { "(bad)", { XX } },
4286 /* PREFIX_VEX_380A */
4288 { "(bad)", { XX } },
4289 { "(bad)", { XX } },
4290 { VEX_LEN_TABLE (VEX_LEN_380A_P_2) },
4291 { "(bad)", { XX } },
4294 /* PREFIX_VEX_380B */
4296 { "(bad)", { XX } },
4297 { "(bad)", { XX } },
4298 { VEX_LEN_TABLE (VEX_LEN_380B_P_2) },
4299 { "(bad)", { XX } },
4302 /* PREFIX_VEX_380C */
4304 { "(bad)", { XX } },
4305 { "(bad)", { XX } },
4306 { "vpermilps", { XM, Vex, EXx } },
4307 { "(bad)", { XX } },
4310 /* PREFIX_VEX_380D */
4312 { "(bad)", { XX } },
4313 { "(bad)", { XX } },
4314 { "vpermilpd", { XM, Vex, EXx } },
4315 { "(bad)", { XX } },
4318 /* PREFIX_VEX_380E */
4320 { "(bad)", { XX } },
4321 { "(bad)", { XX } },
4322 { "vtestps", { XM, EXx } },
4323 { "(bad)", { XX } },
4326 /* PREFIX_VEX_380F */
4328 { "(bad)", { XX } },
4329 { "(bad)", { XX } },
4330 { "vtestpd", { XM, EXx } },
4331 { "(bad)", { XX } },
4334 /* PREFIX_VEX_3817 */
4336 { "(bad)", { XX } },
4337 { "(bad)", { XX } },
4338 { "vptest", { XM, EXx } },
4339 { "(bad)", { XX } },
4342 /* PREFIX_VEX_3818 */
4344 { "(bad)", { XX } },
4345 { "(bad)", { XX } },
4346 { MOD_TABLE (MOD_VEX_3818_PREFIX_2) },
4347 { "(bad)", { XX } },
4350 /* PREFIX_VEX_3819 */
4352 { "(bad)", { XX } },
4353 { "(bad)", { XX } },
4354 { MOD_TABLE (MOD_VEX_3819_PREFIX_2) },
4355 { "(bad)", { XX } },
4358 /* PREFIX_VEX_381A */
4360 { "(bad)", { XX } },
4361 { "(bad)", { XX } },
4362 { MOD_TABLE (MOD_VEX_381A_PREFIX_2) },
4363 { "(bad)", { XX } },
4366 /* PREFIX_VEX_381C */
4368 { "(bad)", { XX } },
4369 { "(bad)", { XX } },
4370 { VEX_LEN_TABLE (VEX_LEN_381C_P_2) },
4371 { "(bad)", { XX } },
4374 /* PREFIX_VEX_381D */
4376 { "(bad)", { XX } },
4377 { "(bad)", { XX } },
4378 { VEX_LEN_TABLE (VEX_LEN_381D_P_2) },
4379 { "(bad)", { XX } },
4382 /* PREFIX_VEX_381E */
4384 { "(bad)", { XX } },
4385 { "(bad)", { XX } },
4386 { VEX_LEN_TABLE (VEX_LEN_381E_P_2) },
4387 { "(bad)", { XX } },
4390 /* PREFIX_VEX_3820 */
4392 { "(bad)", { XX } },
4393 { "(bad)", { XX } },
4394 { VEX_LEN_TABLE (VEX_LEN_3820_P_2) },
4395 { "(bad)", { XX } },
4398 /* PREFIX_VEX_3821 */
4400 { "(bad)", { XX } },
4401 { "(bad)", { XX } },
4402 { VEX_LEN_TABLE (VEX_LEN_3821_P_2) },
4403 { "(bad)", { XX } },
4406 /* PREFIX_VEX_3822 */
4408 { "(bad)", { XX } },
4409 { "(bad)", { XX } },
4410 { VEX_LEN_TABLE (VEX_LEN_3822_P_2) },
4411 { "(bad)", { XX } },
4414 /* PREFIX_VEX_3823 */
4416 { "(bad)", { XX } },
4417 { "(bad)", { XX } },
4418 { VEX_LEN_TABLE (VEX_LEN_3823_P_2) },
4419 { "(bad)", { XX } },
4422 /* PREFIX_VEX_3824 */
4424 { "(bad)", { XX } },
4425 { "(bad)", { XX } },
4426 { VEX_LEN_TABLE (VEX_LEN_3824_P_2) },
4427 { "(bad)", { XX } },
4430 /* PREFIX_VEX_3825 */
4432 { "(bad)", { XX } },
4433 { "(bad)", { XX } },
4434 { VEX_LEN_TABLE (VEX_LEN_3825_P_2) },
4435 { "(bad)", { XX } },
4438 /* PREFIX_VEX_3828 */
4440 { "(bad)", { XX } },
4441 { "(bad)", { XX } },
4442 { VEX_LEN_TABLE (VEX_LEN_3828_P_2) },
4443 { "(bad)", { XX } },
4446 /* PREFIX_VEX_3829 */
4448 { "(bad)", { XX } },
4449 { "(bad)", { XX } },
4450 { VEX_LEN_TABLE (VEX_LEN_3829_P_2) },
4451 { "(bad)", { XX } },
4454 /* PREFIX_VEX_382A */
4456 { "(bad)", { XX } },
4457 { "(bad)", { XX } },
4458 { MOD_TABLE (MOD_VEX_382A_PREFIX_2) },
4459 { "(bad)", { XX } },
4462 /* PREFIX_VEX_382B */
4464 { "(bad)", { XX } },
4465 { "(bad)", { XX } },
4466 { VEX_LEN_TABLE (VEX_LEN_382B_P_2) },
4467 { "(bad)", { XX } },
4470 /* PREFIX_VEX_382C */
4472 { "(bad)", { XX } },
4473 { "(bad)", { XX } },
4474 { MOD_TABLE (MOD_VEX_382C_PREFIX_2) },
4475 { "(bad)", { XX } },
4478 /* PREFIX_VEX_382D */
4480 { "(bad)", { XX } },
4481 { "(bad)", { XX } },
4482 { MOD_TABLE (MOD_VEX_382D_PREFIX_2) },
4483 { "(bad)", { XX } },
4486 /* PREFIX_VEX_382E */
4488 { "(bad)", { XX } },
4489 { "(bad)", { XX } },
4490 { MOD_TABLE (MOD_VEX_382E_PREFIX_2) },
4491 { "(bad)", { XX } },
4494 /* PREFIX_VEX_382F */
4496 { "(bad)", { XX } },
4497 { "(bad)", { XX } },
4498 { MOD_TABLE (MOD_VEX_382F_PREFIX_2) },
4499 { "(bad)", { XX } },
4502 /* PREFIX_VEX_3830 */
4504 { "(bad)", { XX } },
4505 { "(bad)", { XX } },
4506 { VEX_LEN_TABLE (VEX_LEN_3830_P_2) },
4507 { "(bad)", { XX } },
4510 /* PREFIX_VEX_3831 */
4512 { "(bad)", { XX } },
4513 { "(bad)", { XX } },
4514 { VEX_LEN_TABLE (VEX_LEN_3831_P_2) },
4515 { "(bad)", { XX } },
4518 /* PREFIX_VEX_3832 */
4520 { "(bad)", { XX } },
4521 { "(bad)", { XX } },
4522 { VEX_LEN_TABLE (VEX_LEN_3832_P_2) },
4523 { "(bad)", { XX } },
4526 /* PREFIX_VEX_3833 */
4528 { "(bad)", { XX } },
4529 { "(bad)", { XX } },
4530 { VEX_LEN_TABLE (VEX_LEN_3833_P_2) },
4531 { "(bad)", { XX } },
4534 /* PREFIX_VEX_3834 */
4536 { "(bad)", { XX } },
4537 { "(bad)", { XX } },
4538 { VEX_LEN_TABLE (VEX_LEN_3834_P_2) },
4539 { "(bad)", { XX } },
4542 /* PREFIX_VEX_3835 */
4544 { "(bad)", { XX } },
4545 { "(bad)", { XX } },
4546 { VEX_LEN_TABLE (VEX_LEN_3835_P_2) },
4547 { "(bad)", { XX } },
4550 /* PREFIX_VEX_3837 */
4552 { "(bad)", { XX } },
4553 { "(bad)", { XX } },
4554 { VEX_LEN_TABLE (VEX_LEN_3837_P_2) },
4555 { "(bad)", { XX } },
4558 /* PREFIX_VEX_3838 */
4560 { "(bad)", { XX } },
4561 { "(bad)", { XX } },
4562 { VEX_LEN_TABLE (VEX_LEN_3838_P_2) },
4563 { "(bad)", { XX } },
4566 /* PREFIX_VEX_3839 */
4568 { "(bad)", { XX } },
4569 { "(bad)", { XX } },
4570 { VEX_LEN_TABLE (VEX_LEN_3839_P_2) },
4571 { "(bad)", { XX } },
4574 /* PREFIX_VEX_383A */
4576 { "(bad)", { XX } },
4577 { "(bad)", { XX } },
4578 { VEX_LEN_TABLE (VEX_LEN_383A_P_2) },
4579 { "(bad)", { XX } },
4582 /* PREFIX_VEX_383B */
4584 { "(bad)", { XX } },
4585 { "(bad)", { XX } },
4586 { VEX_LEN_TABLE (VEX_LEN_383B_P_2) },
4587 { "(bad)", { XX } },
4590 /* PREFIX_VEX_383C */
4592 { "(bad)", { XX } },
4593 { "(bad)", { XX } },
4594 { VEX_LEN_TABLE (VEX_LEN_383C_P_2) },
4595 { "(bad)", { XX } },
4598 /* PREFIX_VEX_383D */
4600 { "(bad)", { XX } },
4601 { "(bad)", { XX } },
4602 { VEX_LEN_TABLE (VEX_LEN_383D_P_2) },
4603 { "(bad)", { XX } },
4606 /* PREFIX_VEX_383E */
4608 { "(bad)", { XX } },
4609 { "(bad)", { XX } },
4610 { VEX_LEN_TABLE (VEX_LEN_383E_P_2) },
4611 { "(bad)", { XX } },
4614 /* PREFIX_VEX_383F */
4616 { "(bad)", { XX } },
4617 { "(bad)", { XX } },
4618 { VEX_LEN_TABLE (VEX_LEN_383F_P_2) },
4619 { "(bad)", { XX } },
4622 /* PREFIX_VEX_3840 */
4624 { "(bad)", { XX } },
4625 { "(bad)", { XX } },
4626 { VEX_LEN_TABLE (VEX_LEN_3840_P_2) },
4627 { "(bad)", { XX } },
4630 /* PREFIX_VEX_3841 */
4632 { "(bad)", { XX } },
4633 { "(bad)", { XX } },
4634 { VEX_LEN_TABLE (VEX_LEN_3841_P_2) },
4635 { "(bad)", { XX } },
4638 /* PREFIX_VEX_3896 */
4640 { "(bad)", { XX } },
4641 { "(bad)", { XX } },
4642 { "vfmaddsub132p%XW", { XM, Vex, EXx } },
4643 { "(bad)", { XX } },
4646 /* PREFIX_VEX_3897 */
4648 { "(bad)", { XX } },
4649 { "(bad)", { XX } },
4650 { "vfmsubadd132p%XW", { XM, Vex, EXx } },
4651 { "(bad)", { XX } },
4654 /* PREFIX_VEX_3898 */
4656 { "(bad)", { XX } },
4657 { "(bad)", { XX } },
4658 { "vfmadd132p%XW", { XM, Vex, EXx } },
4659 { "(bad)", { XX } },
4662 /* PREFIX_VEX_3899 */
4664 { "(bad)", { XX } },
4665 { "(bad)", { XX } },
4666 { "vfmadd132s%XW", { XM, Vex, EXVexWdq } },
4667 { "(bad)", { XX } },
4670 /* PREFIX_VEX_389A */
4672 { "(bad)", { XX } },
4673 { "(bad)", { XX } },
4674 { "vfmsub132p%XW", { XM, Vex, EXx } },
4675 { "(bad)", { XX } },
4678 /* PREFIX_VEX_389B */
4680 { "(bad)", { XX } },
4681 { "(bad)", { XX } },
4682 { "vfmsub132s%XW", { XM, Vex, EXVexWdq } },
4683 { "(bad)", { XX } },
4686 /* PREFIX_VEX_389C */
4688 { "(bad)", { XX } },
4689 { "(bad)", { XX } },
4690 { "vfnmadd132p%XW", { XM, Vex, EXx } },
4691 { "(bad)", { XX } },
4694 /* PREFIX_VEX_389D */
4696 { "(bad)", { XX } },
4697 { "(bad)", { XX } },
4698 { "vfnmadd132s%XW", { XM, Vex, EXVexWdq } },
4699 { "(bad)", { XX } },
4702 /* PREFIX_VEX_389E */
4704 { "(bad)", { XX } },
4705 { "(bad)", { XX } },
4706 { "vfnmsub132p%XW", { XM, Vex, EXx } },
4707 { "(bad)", { XX } },
4710 /* PREFIX_VEX_389F */
4712 { "(bad)", { XX } },
4713 { "(bad)", { XX } },
4714 { "vfnmsub132s%XW", { XM, Vex, EXVexWdq } },
4715 { "(bad)", { XX } },
4718 /* PREFIX_VEX_38A6 */
4720 { "(bad)", { XX } },
4721 { "(bad)", { XX } },
4722 { "vfmaddsub213p%XW", { XM, Vex, EXx } },
4723 { "(bad)", { XX } },
4726 /* PREFIX_VEX_38A7 */
4728 { "(bad)", { XX } },
4729 { "(bad)", { XX } },
4730 { "vfmsubadd213p%XW", { XM, Vex, EXx } },
4731 { "(bad)", { XX } },
4734 /* PREFIX_VEX_38A8 */
4736 { "(bad)", { XX } },
4737 { "(bad)", { XX } },
4738 { "vfmadd213p%XW", { XM, Vex, EXx } },
4739 { "(bad)", { XX } },
4742 /* PREFIX_VEX_38A9 */
4744 { "(bad)", { XX } },
4745 { "(bad)", { XX } },
4746 { "vfmadd213s%XW", { XM, Vex, EXVexWdq } },
4747 { "(bad)", { XX } },
4750 /* PREFIX_VEX_38AA */
4752 { "(bad)", { XX } },
4753 { "(bad)", { XX } },
4754 { "vfmsub213p%XW", { XM, Vex, EXx } },
4755 { "(bad)", { XX } },
4758 /* PREFIX_VEX_38AB */
4760 { "(bad)", { XX } },
4761 { "(bad)", { XX } },
4762 { "vfmsub213s%XW", { XM, Vex, EXVexWdq } },
4763 { "(bad)", { XX } },
4766 /* PREFIX_VEX_38AC */
4768 { "(bad)", { XX } },
4769 { "(bad)", { XX } },
4770 { "vfnmadd213p%XW", { XM, Vex, EXx } },
4771 { "(bad)", { XX } },
4774 /* PREFIX_VEX_38AD */
4776 { "(bad)", { XX } },
4777 { "(bad)", { XX } },
4778 { "vfnmadd213s%XW", { XM, Vex, EXVexWdq } },
4779 { "(bad)", { XX } },
4782 /* PREFIX_VEX_38AE */
4784 { "(bad)", { XX } },
4785 { "(bad)", { XX } },
4786 { "vfnmsub213p%XW", { XM, Vex, EXx } },
4787 { "(bad)", { XX } },
4790 /* PREFIX_VEX_38AF */
4792 { "(bad)", { XX } },
4793 { "(bad)", { XX } },
4794 { "vfnmsub213s%XW", { XM, Vex, EXVexWdq } },
4795 { "(bad)", { XX } },
4798 /* PREFIX_VEX_38B6 */
4800 { "(bad)", { XX } },
4801 { "(bad)", { XX } },
4802 { "vfmaddsub231p%XW", { XM, Vex, EXx } },
4803 { "(bad)", { XX } },
4806 /* PREFIX_VEX_38B7 */
4808 { "(bad)", { XX } },
4809 { "(bad)", { XX } },
4810 { "vfmsubadd231p%XW", { XM, Vex, EXx } },
4811 { "(bad)", { XX } },
4814 /* PREFIX_VEX_38B8 */
4816 { "(bad)", { XX } },
4817 { "(bad)", { XX } },
4818 { "vfmadd231p%XW", { XM, Vex, EXx } },
4819 { "(bad)", { XX } },
4822 /* PREFIX_VEX_38B9 */
4824 { "(bad)", { XX } },
4825 { "(bad)", { XX } },
4826 { "vfmadd231s%XW", { XM, Vex, EXVexWdq } },
4827 { "(bad)", { XX } },
4830 /* PREFIX_VEX_38BA */
4832 { "(bad)", { XX } },
4833 { "(bad)", { XX } },
4834 { "vfmsub231p%XW", { XM, Vex, EXx } },
4835 { "(bad)", { XX } },
4838 /* PREFIX_VEX_38BB */
4840 { "(bad)", { XX } },
4841 { "(bad)", { XX } },
4842 { "vfmsub231s%XW", { XM, Vex, EXVexWdq } },
4843 { "(bad)", { XX } },
4846 /* PREFIX_VEX_38BC */
4848 { "(bad)", { XX } },
4849 { "(bad)", { XX } },
4850 { "vfnmadd231p%XW", { XM, Vex, EXx } },
4851 { "(bad)", { XX } },
4854 /* PREFIX_VEX_38BD */
4856 { "(bad)", { XX } },
4857 { "(bad)", { XX } },
4858 { "vfnmadd231s%XW", { XM, Vex, EXVexWdq } },
4859 { "(bad)", { XX } },
4862 /* PREFIX_VEX_38BE */
4864 { "(bad)", { XX } },
4865 { "(bad)", { XX } },
4866 { "vfnmsub231p%XW", { XM, Vex, EXx } },
4867 { "(bad)", { XX } },
4870 /* PREFIX_VEX_38BF */
4872 { "(bad)", { XX } },
4873 { "(bad)", { XX } },
4874 { "vfnmsub231s%XW", { XM, Vex, EXVexWdq } },
4875 { "(bad)", { XX } },
4878 /* PREFIX_VEX_38DB */
4880 { "(bad)", { XX } },
4881 { "(bad)", { XX } },
4882 { VEX_LEN_TABLE (VEX_LEN_38DB_P_2) },
4883 { "(bad)", { XX } },
4886 /* PREFIX_VEX_38DC */
4888 { "(bad)", { XX } },
4889 { "(bad)", { XX } },
4890 { VEX_LEN_TABLE (VEX_LEN_38DC_P_2) },
4891 { "(bad)", { XX } },
4894 /* PREFIX_VEX_38DD */
4896 { "(bad)", { XX } },
4897 { "(bad)", { XX } },
4898 { VEX_LEN_TABLE (VEX_LEN_38DD_P_2) },
4899 { "(bad)", { XX } },
4902 /* PREFIX_VEX_38DE */
4904 { "(bad)", { XX } },
4905 { "(bad)", { XX } },
4906 { VEX_LEN_TABLE (VEX_LEN_38DE_P_2) },
4907 { "(bad)", { XX } },
4910 /* PREFIX_VEX_38DF */
4912 { "(bad)", { XX } },
4913 { "(bad)", { XX } },
4914 { VEX_LEN_TABLE (VEX_LEN_38DF_P_2) },
4915 { "(bad)", { XX } },
4918 /* PREFIX_VEX_3A04 */
4920 { "(bad)", { XX } },
4921 { "(bad)", { XX } },
4922 { "vpermilps", { XM, EXx, Ib } },
4923 { "(bad)", { XX } },
4926 /* PREFIX_VEX_3A05 */
4928 { "(bad)", { XX } },
4929 { "(bad)", { XX } },
4930 { "vpermilpd", { XM, EXx, Ib } },
4931 { "(bad)", { XX } },
4934 /* PREFIX_VEX_3A06 */
4936 { "(bad)", { XX } },
4937 { "(bad)", { XX } },
4938 { VEX_LEN_TABLE (VEX_LEN_3A06_P_2) },
4939 { "(bad)", { XX } },
4942 /* PREFIX_VEX_3A08 */
4944 { "(bad)", { XX } },
4945 { "(bad)", { XX } },
4946 { "vroundps", { XM, EXx, Ib } },
4947 { "(bad)", { XX } },
4950 /* PREFIX_VEX_3A09 */
4952 { "(bad)", { XX } },
4953 { "(bad)", { XX } },
4954 { "vroundpd", { XM, EXx, Ib } },
4955 { "(bad)", { XX } },
4958 /* PREFIX_VEX_3A0A */
4960 { "(bad)", { XX } },
4961 { "(bad)", { XX } },
4962 { VEX_LEN_TABLE (VEX_LEN_3A0A_P_2) },
4963 { "(bad)", { XX } },
4966 /* PREFIX_VEX_3A0B */
4968 { "(bad)", { XX } },
4969 { "(bad)", { XX } },
4970 { VEX_LEN_TABLE (VEX_LEN_3A0B_P_2) },
4971 { "(bad)", { XX } },
4974 /* PREFIX_VEX_3A0C */
4976 { "(bad)", { XX } },
4977 { "(bad)", { XX } },
4978 { "vblendps", { XM, Vex, EXx, Ib } },
4979 { "(bad)", { XX } },
4982 /* PREFIX_VEX_3A0D */
4984 { "(bad)", { XX } },
4985 { "(bad)", { XX } },
4986 { "vblendpd", { XM, Vex, EXx, Ib } },
4987 { "(bad)", { XX } },
4990 /* PREFIX_VEX_3A0E */
4992 { "(bad)", { XX } },
4993 { "(bad)", { XX } },
4994 { VEX_LEN_TABLE (VEX_LEN_3A0E_P_2) },
4995 { "(bad)", { XX } },
4998 /* PREFIX_VEX_3A0F */
5000 { "(bad)", { XX } },
5001 { "(bad)", { XX } },
5002 { VEX_LEN_TABLE (VEX_LEN_3A0F_P_2) },
5003 { "(bad)", { XX } },
5006 /* PREFIX_VEX_3A14 */
5008 { "(bad)", { XX } },
5009 { "(bad)", { XX } },
5010 { VEX_LEN_TABLE (VEX_LEN_3A14_P_2) },
5011 { "(bad)", { XX } },
5014 /* PREFIX_VEX_3A15 */
5016 { "(bad)", { XX } },
5017 { "(bad)", { XX } },
5018 { VEX_LEN_TABLE (VEX_LEN_3A15_P_2) },
5019 { "(bad)", { XX } },
5022 /* PREFIX_VEX_3A16 */
5024 { "(bad)", { XX } },
5025 { "(bad)", { XX } },
5026 { VEX_LEN_TABLE (VEX_LEN_3A16_P_2) },
5027 { "(bad)", { XX } },
5030 /* PREFIX_VEX_3A17 */
5032 { "(bad)", { XX } },
5033 { "(bad)", { XX } },
5034 { VEX_LEN_TABLE (VEX_LEN_3A17_P_2) },
5035 { "(bad)", { XX } },
5038 /* PREFIX_VEX_3A18 */
5040 { "(bad)", { XX } },
5041 { "(bad)", { XX } },
5042 { VEX_LEN_TABLE (VEX_LEN_3A18_P_2) },
5043 { "(bad)", { XX } },
5046 /* PREFIX_VEX_3A19 */
5048 { "(bad)", { XX } },
5049 { "(bad)", { XX } },
5050 { VEX_LEN_TABLE (VEX_LEN_3A19_P_2) },
5051 { "(bad)", { XX } },
5054 /* PREFIX_VEX_3A20 */
5056 { "(bad)", { XX } },
5057 { "(bad)", { XX } },
5058 { VEX_LEN_TABLE (VEX_LEN_3A20_P_2) },
5059 { "(bad)", { XX } },
5062 /* PREFIX_VEX_3A21 */
5064 { "(bad)", { XX } },
5065 { "(bad)", { XX } },
5066 { VEX_LEN_TABLE (VEX_LEN_3A21_P_2) },
5067 { "(bad)", { XX } },
5070 /* PREFIX_VEX_3A22 */
5072 { "(bad)", { XX } },
5073 { "(bad)", { XX } },
5074 { VEX_LEN_TABLE (VEX_LEN_3A22_P_2) },
5075 { "(bad)", { XX } },
5078 /* PREFIX_VEX_3A40 */
5080 { "(bad)", { XX } },
5081 { "(bad)", { XX } },
5082 { "vdpps", { XM, Vex, EXx, Ib } },
5083 { "(bad)", { XX } },
5086 /* PREFIX_VEX_3A41 */
5088 { "(bad)", { XX } },
5089 { "(bad)", { XX } },
5090 { VEX_LEN_TABLE (VEX_LEN_3A41_P_2) },
5091 { "(bad)", { XX } },
5094 /* PREFIX_VEX_3A42 */
5096 { "(bad)", { XX } },
5097 { "(bad)", { XX } },
5098 { VEX_LEN_TABLE (VEX_LEN_3A42_P_2) },
5099 { "(bad)", { XX } },
5102 /* PREFIX_VEX_3A44 */
5104 { "(bad)", { XX } },
5105 { "(bad)", { XX } },
5106 { VEX_LEN_TABLE (VEX_LEN_3A44_P_2) },
5107 { "(bad)", { XX } },
5110 /* PREFIX_VEX_3A4A */
5112 { "(bad)", { XX } },
5113 { "(bad)", { XX } },
5114 { "vblendvps", { XM, Vex, EXx, XMVexI4 } },
5115 { "(bad)", { XX } },
5118 /* PREFIX_VEX_3A4B */
5120 { "(bad)", { XX } },
5121 { "(bad)", { XX } },
5122 { "vblendvpd", { XM, Vex, EXx, XMVexI4 } },
5123 { "(bad)", { XX } },
5126 /* PREFIX_VEX_3A4C */
5128 { "(bad)", { XX } },
5129 { "(bad)", { XX } },
5130 { VEX_LEN_TABLE (VEX_LEN_3A4C_P_2) },
5131 { "(bad)", { XX } },
5134 /* PREFIX_VEX_3A5C */
5136 { "(bad)", { XX } },
5137 { "(bad)", { XX } },
5138 { "vfmaddsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5139 { "(bad)", { XX } },
5142 /* PREFIX_VEX_3A5D */
5144 { "(bad)", { XX } },
5145 { "(bad)", { XX } },
5146 { "vfmaddsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5147 { "(bad)", { XX } },
5150 /* PREFIX_VEX_3A5E */
5152 { "(bad)", { XX } },
5153 { "(bad)", { XX } },
5154 { "vfmsubaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5155 { "(bad)", { XX } },
5158 /* PREFIX_VEX_3A5F */
5160 { "(bad)", { XX } },
5161 { "(bad)", { XX } },
5162 { "vfmsubaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5163 { "(bad)", { XX } },
5166 /* PREFIX_VEX_3A60 */
5168 { "(bad)", { XX } },
5169 { "(bad)", { XX } },
5170 { VEX_LEN_TABLE (VEX_LEN_3A60_P_2) },
5171 { "(bad)", { XX } },
5174 /* PREFIX_VEX_3A61 */
5176 { "(bad)", { XX } },
5177 { "(bad)", { XX } },
5178 { VEX_LEN_TABLE (VEX_LEN_3A61_P_2) },
5179 { "(bad)", { XX } },
5182 /* PREFIX_VEX_3A62 */
5184 { "(bad)", { XX } },
5185 { "(bad)", { XX } },
5186 { VEX_LEN_TABLE (VEX_LEN_3A62_P_2) },
5187 { "(bad)", { XX } },
5190 /* PREFIX_VEX_3A63 */
5192 { "(bad)", { XX } },
5193 { "(bad)", { XX } },
5194 { VEX_LEN_TABLE (VEX_LEN_3A63_P_2) },
5195 { "(bad)", { XX } },
5198 /* PREFIX_VEX_3A68 */
5200 { "(bad)", { XX } },
5201 { "(bad)", { XX } },
5202 { "vfmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5203 { "(bad)", { XX } },
5206 /* PREFIX_VEX_3A69 */
5208 { "(bad)", { XX } },
5209 { "(bad)", { XX } },
5210 { "vfmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5211 { "(bad)", { XX } },
5214 /* PREFIX_VEX_3A6A */
5216 { "(bad)", { XX } },
5217 { "(bad)", { XX } },
5218 { VEX_LEN_TABLE (VEX_LEN_3A6A_P_2) },
5219 { "(bad)", { XX } },
5222 /* PREFIX_VEX_3A6B */
5224 { "(bad)", { XX } },
5225 { "(bad)", { XX } },
5226 { VEX_LEN_TABLE (VEX_LEN_3A6B_P_2) },
5227 { "(bad)", { XX } },
5230 /* PREFIX_VEX_3A6C */
5232 { "(bad)", { XX } },
5233 { "(bad)", { XX } },
5234 { "vfmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5235 { "(bad)", { XX } },
5238 /* PREFIX_VEX_3A6D */
5240 { "(bad)", { XX } },
5241 { "(bad)", { XX } },
5242 { "vfmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5243 { "(bad)", { XX } },
5246 /* PREFIX_VEX_3A6E */
5248 { "(bad)", { XX } },
5249 { "(bad)", { XX } },
5250 { VEX_LEN_TABLE (VEX_LEN_3A6E_P_2) },
5251 { "(bad)", { XX } },
5254 /* PREFIX_VEX_3A6F */
5256 { "(bad)", { XX } },
5257 { "(bad)", { XX } },
5258 { VEX_LEN_TABLE (VEX_LEN_3A6F_P_2) },
5259 { "(bad)", { XX } },
5262 /* PREFIX_VEX_3A78 */
5264 { "(bad)", { XX } },
5265 { "(bad)", { XX } },
5266 { "vfnmaddps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5267 { "(bad)", { XX } },
5270 /* PREFIX_VEX_3A79 */
5272 { "(bad)", { XX } },
5273 { "(bad)", { XX } },
5274 { "vfnmaddpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5275 { "(bad)", { XX } },
5278 /* PREFIX_VEX_3A7A */
5280 { "(bad)", { XX } },
5281 { "(bad)", { XX } },
5282 { VEX_LEN_TABLE (VEX_LEN_3A7A_P_2) },
5283 { "(bad)", { XX } },
5286 /* PREFIX_VEX_3A7B */
5288 { "(bad)", { XX } },
5289 { "(bad)", { XX } },
5290 { VEX_LEN_TABLE (VEX_LEN_3A7B_P_2) },
5291 { "(bad)", { XX } },
5294 /* PREFIX_VEX_3A7C */
5296 { "(bad)", { XX } },
5297 { "(bad)", { XX } },
5298 { "vfnmsubps", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5299 { "(bad)", { XX } },
5302 /* PREFIX_VEX_3A7D */
5304 { "(bad)", { XX } },
5305 { "(bad)", { XX } },
5306 { "vfnmsubpd", { XMVexW, Vex, EXVexW, EXVexW, VexI4 } },
5307 { "(bad)", { XX } },
5310 /* PREFIX_VEX_3A7E */
5312 { "(bad)", { XX } },
5313 { "(bad)", { XX } },
5314 { VEX_LEN_TABLE (VEX_LEN_3A7E_P_2) },
5315 { "(bad)", { XX } },
5318 /* PREFIX_VEX_3A7F */
5320 { "(bad)", { XX } },
5321 { "(bad)", { XX } },
5322 { VEX_LEN_TABLE (VEX_LEN_3A7F_P_2) },
5323 { "(bad)", { XX } },
5326 /* PREFIX_VEX_3ADF */
5328 { "(bad)", { XX } },
5329 { "(bad)", { XX } },
5330 { VEX_LEN_TABLE (VEX_LEN_3ADF_P_2) },
5331 { "(bad)", { XX } },
5335 static const struct dis386 x86_64_table[][2] = {
5338 { "push{T|}", { es } },
5339 { "(bad)", { XX } },
5344 { "pop{T|}", { es } },
5345 { "(bad)", { XX } },
5350 { "push{T|}", { cs } },
5351 { "(bad)", { XX } },
5356 { "push{T|}", { ss } },
5357 { "(bad)", { XX } },
5362 { "pop{T|}", { ss } },
5363 { "(bad)", { XX } },
5368 { "push{T|}", { ds } },
5369 { "(bad)", { XX } },
5374 { "pop{T|}", { ds } },
5375 { "(bad)", { XX } },
5381 { "(bad)", { XX } },
5387 { "(bad)", { XX } },
5393 { "(bad)", { XX } },
5399 { "(bad)", { XX } },
5404 { "pusha{P|}", { XX } },
5405 { "(bad)", { XX } },
5410 { "popa{P|}", { XX } },
5411 { "(bad)", { XX } },
5416 { MOD_TABLE (MOD_62_32BIT) },
5417 { "(bad)", { XX } },
5422 { "arpl", { Ew, Gw } },
5423 { "movs{lq|xd}", { Gv, Ed } },
5428 { "ins{R|}", { Yzr, indirDX } },
5429 { "ins{G|}", { Yzr, indirDX } },
5434 { "outs{R|}", { indirDXr, Xz } },
5435 { "outs{G|}", { indirDXr, Xz } },
5440 { "Jcall{T|}", { Ap } },
5441 { "(bad)", { XX } },
5446 { MOD_TABLE (MOD_C4_32BIT) },
5447 { VEX_C4_TABLE (VEX_0F) },
5452 { MOD_TABLE (MOD_C5_32BIT) },
5453 { VEX_C5_TABLE (VEX_0F) },
5459 { "(bad)", { XX } },
5465 { "(bad)", { XX } },
5471 { "(bad)", { XX } },
5476 { "Jjmp{T|}", { Ap } },
5477 { "(bad)", { XX } },
5480 /* X86_64_0F01_REG_0 */
5482 { "sgdt{Q|IQ}", { M } },
5486 /* X86_64_0F01_REG_1 */
5488 { "sidt{Q|IQ}", { M } },
5492 /* X86_64_0F01_REG_2 */
5494 { "lgdt{Q|Q}", { M } },
5498 /* X86_64_0F01_REG_3 */
5500 { "lidt{Q|Q}", { M } },
5505 static const struct dis386 three_byte_table[][256] = {
5507 /* THREE_BYTE_0F38 */
5510 { "pshufb", { MX, EM } },
5511 { "phaddw", { MX, EM } },
5512 { "phaddd", { MX, EM } },
5513 { "phaddsw", { MX, EM } },
5514 { "pmaddubsw", { MX, EM } },
5515 { "phsubw", { MX, EM } },
5516 { "phsubd", { MX, EM } },
5517 { "phsubsw", { MX, EM } },
5519 { "psignb", { MX, EM } },
5520 { "psignw", { MX, EM } },
5521 { "psignd", { MX, EM } },
5522 { "pmulhrsw", { MX, EM } },
5523 { "(bad)", { XX } },
5524 { "(bad)", { XX } },
5525 { "(bad)", { XX } },
5526 { "(bad)", { XX } },
5528 { PREFIX_TABLE (PREFIX_0F3810) },
5529 { "(bad)", { XX } },
5530 { "(bad)", { XX } },
5531 { "(bad)", { XX } },
5532 { PREFIX_TABLE (PREFIX_0F3814) },
5533 { PREFIX_TABLE (PREFIX_0F3815) },
5534 { "(bad)", { XX } },
5535 { PREFIX_TABLE (PREFIX_0F3817) },
5537 { "(bad)", { XX } },
5538 { "(bad)", { XX } },
5539 { "(bad)", { XX } },
5540 { "(bad)", { XX } },
5541 { "pabsb", { MX, EM } },
5542 { "pabsw", { MX, EM } },
5543 { "pabsd", { MX, EM } },
5544 { "(bad)", { XX } },
5546 { PREFIX_TABLE (PREFIX_0F3820) },
5547 { PREFIX_TABLE (PREFIX_0F3821) },
5548 { PREFIX_TABLE (PREFIX_0F3822) },
5549 { PREFIX_TABLE (PREFIX_0F3823) },
5550 { PREFIX_TABLE (PREFIX_0F3824) },
5551 { PREFIX_TABLE (PREFIX_0F3825) },
5552 { "(bad)", { XX } },
5553 { "(bad)", { XX } },
5555 { PREFIX_TABLE (PREFIX_0F3828) },
5556 { PREFIX_TABLE (PREFIX_0F3829) },
5557 { PREFIX_TABLE (PREFIX_0F382A) },
5558 { PREFIX_TABLE (PREFIX_0F382B) },
5559 { "(bad)", { XX } },
5560 { "(bad)", { XX } },
5561 { "(bad)", { XX } },
5562 { "(bad)", { XX } },
5564 { PREFIX_TABLE (PREFIX_0F3830) },
5565 { PREFIX_TABLE (PREFIX_0F3831) },
5566 { PREFIX_TABLE (PREFIX_0F3832) },
5567 { PREFIX_TABLE (PREFIX_0F3833) },
5568 { PREFIX_TABLE (PREFIX_0F3834) },
5569 { PREFIX_TABLE (PREFIX_0F3835) },
5570 { "(bad)", { XX } },
5571 { PREFIX_TABLE (PREFIX_0F3837) },
5573 { PREFIX_TABLE (PREFIX_0F3838) },
5574 { PREFIX_TABLE (PREFIX_0F3839) },
5575 { PREFIX_TABLE (PREFIX_0F383A) },
5576 { PREFIX_TABLE (PREFIX_0F383B) },
5577 { PREFIX_TABLE (PREFIX_0F383C) },
5578 { PREFIX_TABLE (PREFIX_0F383D) },
5579 { PREFIX_TABLE (PREFIX_0F383E) },
5580 { PREFIX_TABLE (PREFIX_0F383F) },
5582 { PREFIX_TABLE (PREFIX_0F3840) },
5583 { PREFIX_TABLE (PREFIX_0F3841) },
5584 { "(bad)", { XX } },
5585 { "(bad)", { XX } },
5586 { "(bad)", { XX } },
5587 { "(bad)", { XX } },
5588 { "(bad)", { XX } },
5589 { "(bad)", { XX } },
5591 { "(bad)", { XX } },
5592 { "(bad)", { XX } },
5593 { "(bad)", { XX } },
5594 { "(bad)", { XX } },
5595 { "(bad)", { XX } },
5596 { "(bad)", { XX } },
5597 { "(bad)", { XX } },
5598 { "(bad)", { XX } },
5600 { "(bad)", { XX } },
5601 { "(bad)", { XX } },
5602 { "(bad)", { XX } },
5603 { "(bad)", { XX } },
5604 { "(bad)", { XX } },
5605 { "(bad)", { XX } },
5606 { "(bad)", { XX } },
5607 { "(bad)", { XX } },
5609 { "(bad)", { XX } },
5610 { "(bad)", { XX } },
5611 { "(bad)", { XX } },
5612 { "(bad)", { XX } },
5613 { "(bad)", { XX } },
5614 { "(bad)", { XX } },
5615 { "(bad)", { XX } },
5616 { "(bad)", { XX } },
5618 { "(bad)", { XX } },
5619 { "(bad)", { XX } },
5620 { "(bad)", { XX } },
5621 { "(bad)", { XX } },
5622 { "(bad)", { XX } },
5623 { "(bad)", { XX } },
5624 { "(bad)", { XX } },
5625 { "(bad)", { XX } },
5627 { "(bad)", { XX } },
5628 { "(bad)", { XX } },
5629 { "(bad)", { XX } },
5630 { "(bad)", { XX } },
5631 { "(bad)", { XX } },
5632 { "(bad)", { XX } },
5633 { "(bad)", { XX } },
5634 { "(bad)", { XX } },
5636 { "(bad)", { XX } },
5637 { "(bad)", { XX } },
5638 { "(bad)", { XX } },
5639 { "(bad)", { XX } },
5640 { "(bad)", { XX } },
5641 { "(bad)", { XX } },
5642 { "(bad)", { XX } },
5643 { "(bad)", { XX } },
5645 { "(bad)", { XX } },
5646 { "(bad)", { XX } },
5647 { "(bad)", { XX } },
5648 { "(bad)", { XX } },
5649 { "(bad)", { XX } },
5650 { "(bad)", { XX } },
5651 { "(bad)", { XX } },
5652 { "(bad)", { XX } },
5654 { PREFIX_TABLE (PREFIX_0F3880) },
5655 { PREFIX_TABLE (PREFIX_0F3881) },
5656 { "(bad)", { XX } },
5657 { "(bad)", { XX } },
5658 { "(bad)", { XX } },
5659 { "(bad)", { XX } },
5660 { "(bad)", { XX } },
5661 { "(bad)", { XX } },
5663 { "(bad)", { XX } },
5664 { "(bad)", { XX } },
5665 { "(bad)", { XX } },
5666 { "(bad)", { XX } },
5667 { "(bad)", { XX } },
5668 { "(bad)", { XX } },
5669 { "(bad)", { XX } },
5670 { "(bad)", { XX } },
5672 { "(bad)", { XX } },
5673 { "(bad)", { XX } },
5674 { "(bad)", { XX } },
5675 { "(bad)", { XX } },
5676 { "(bad)", { XX } },
5677 { "(bad)", { XX } },
5678 { "(bad)", { XX } },
5679 { "(bad)", { XX } },
5681 { "(bad)", { XX } },
5682 { "(bad)", { XX } },
5683 { "(bad)", { XX } },
5684 { "(bad)", { XX } },
5685 { "(bad)", { XX } },
5686 { "(bad)", { XX } },
5687 { "(bad)", { XX } },
5688 { "(bad)", { XX } },
5690 { "(bad)", { XX } },
5691 { "(bad)", { XX } },
5692 { "(bad)", { XX } },
5693 { "(bad)", { XX } },
5694 { "(bad)", { XX } },
5695 { "(bad)", { XX } },
5696 { "(bad)", { XX } },
5697 { "(bad)", { XX } },
5699 { "(bad)", { XX } },
5700 { "(bad)", { XX } },
5701 { "(bad)", { XX } },
5702 { "(bad)", { XX } },
5703 { "(bad)", { XX } },
5704 { "(bad)", { XX } },
5705 { "(bad)", { XX } },
5706 { "(bad)", { XX } },
5708 { "(bad)", { XX } },
5709 { "(bad)", { XX } },
5710 { "(bad)", { XX } },
5711 { "(bad)", { XX } },
5712 { "(bad)", { XX } },
5713 { "(bad)", { XX } },
5714 { "(bad)", { XX } },
5715 { "(bad)", { XX } },
5717 { "(bad)", { XX } },
5718 { "(bad)", { XX } },
5719 { "(bad)", { XX } },
5720 { "(bad)", { XX } },
5721 { "(bad)", { XX } },
5722 { "(bad)", { XX } },
5723 { "(bad)", { XX } },
5724 { "(bad)", { XX } },
5726 { "(bad)", { XX } },
5727 { "(bad)", { XX } },
5728 { "(bad)", { XX } },
5729 { "(bad)", { XX } },
5730 { "(bad)", { XX } },
5731 { "(bad)", { XX } },
5732 { "(bad)", { XX } },
5733 { "(bad)", { XX } },
5735 { "(bad)", { XX } },
5736 { "(bad)", { XX } },
5737 { "(bad)", { XX } },
5738 { "(bad)", { XX } },
5739 { "(bad)", { XX } },
5740 { "(bad)", { XX } },
5741 { "(bad)", { XX } },
5742 { "(bad)", { XX } },
5744 { "(bad)", { XX } },
5745 { "(bad)", { XX } },
5746 { "(bad)", { XX } },
5747 { "(bad)", { XX } },
5748 { "(bad)", { XX } },
5749 { "(bad)", { XX } },
5750 { "(bad)", { XX } },
5751 { "(bad)", { XX } },
5753 { "(bad)", { XX } },
5754 { "(bad)", { XX } },
5755 { "(bad)", { XX } },
5756 { PREFIX_TABLE (PREFIX_0F38DB) },
5757 { PREFIX_TABLE (PREFIX_0F38DC) },
5758 { PREFIX_TABLE (PREFIX_0F38DD) },
5759 { PREFIX_TABLE (PREFIX_0F38DE) },
5760 { PREFIX_TABLE (PREFIX_0F38DF) },
5762 { "(bad)", { XX } },
5763 { "(bad)", { XX } },
5764 { "(bad)", { XX } },
5765 { "(bad)", { XX } },
5766 { "(bad)", { XX } },
5767 { "(bad)", { XX } },
5768 { "(bad)", { XX } },
5769 { "(bad)", { XX } },
5771 { "(bad)", { XX } },
5772 { "(bad)", { XX } },
5773 { "(bad)", { XX } },
5774 { "(bad)", { XX } },
5775 { "(bad)", { XX } },
5776 { "(bad)", { XX } },
5777 { "(bad)", { XX } },
5778 { "(bad)", { XX } },
5780 { PREFIX_TABLE (PREFIX_0F38F0) },
5781 { PREFIX_TABLE (PREFIX_0F38F1) },
5782 { "(bad)", { XX } },
5783 { "(bad)", { XX } },
5784 { "(bad)", { XX } },
5785 { "(bad)", { XX } },
5786 { "(bad)", { XX } },
5787 { "(bad)", { XX } },
5789 { "(bad)", { XX } },
5790 { "(bad)", { XX } },
5791 { "(bad)", { XX } },
5792 { "(bad)", { XX } },
5793 { "(bad)", { XX } },
5794 { "(bad)", { XX } },
5795 { "(bad)", { XX } },
5796 { "(bad)", { XX } },
5798 /* THREE_BYTE_0F3A */
5801 { "(bad)", { XX } },
5802 { "(bad)", { XX } },
5803 { "(bad)", { XX } },
5804 { "(bad)", { XX } },
5805 { "(bad)", { XX } },
5806 { "(bad)", { XX } },
5807 { "(bad)", { XX } },
5808 { "(bad)", { XX } },
5810 { PREFIX_TABLE (PREFIX_0F3A08) },
5811 { PREFIX_TABLE (PREFIX_0F3A09) },
5812 { PREFIX_TABLE (PREFIX_0F3A0A) },
5813 { PREFIX_TABLE (PREFIX_0F3A0B) },
5814 { PREFIX_TABLE (PREFIX_0F3A0C) },
5815 { PREFIX_TABLE (PREFIX_0F3A0D) },
5816 { PREFIX_TABLE (PREFIX_0F3A0E) },
5817 { "palignr", { MX, EM, Ib } },
5819 { "(bad)", { XX } },
5820 { "(bad)", { XX } },
5821 { "(bad)", { XX } },
5822 { "(bad)", { XX } },
5823 { PREFIX_TABLE (PREFIX_0F3A14) },
5824 { PREFIX_TABLE (PREFIX_0F3A15) },
5825 { PREFIX_TABLE (PREFIX_0F3A16) },
5826 { PREFIX_TABLE (PREFIX_0F3A17) },
5828 { "(bad)", { XX } },
5829 { "(bad)", { XX } },
5830 { "(bad)", { XX } },
5831 { "(bad)", { XX } },
5832 { "(bad)", { XX } },
5833 { "(bad)", { XX } },
5834 { "(bad)", { XX } },
5835 { "(bad)", { XX } },
5837 { PREFIX_TABLE (PREFIX_0F3A20) },
5838 { PREFIX_TABLE (PREFIX_0F3A21) },
5839 { PREFIX_TABLE (PREFIX_0F3A22) },
5840 { "(bad)", { XX } },
5841 { "(bad)", { XX } },
5842 { "(bad)", { XX } },
5843 { "(bad)", { XX } },
5844 { "(bad)", { XX } },
5846 { "(bad)", { XX } },
5847 { "(bad)", { XX } },
5848 { "(bad)", { XX } },
5849 { "(bad)", { XX } },
5850 { "(bad)", { XX } },
5851 { "(bad)", { XX } },
5852 { "(bad)", { XX } },
5853 { "(bad)", { XX } },
5855 { "(bad)", { XX } },
5856 { "(bad)", { XX } },
5857 { "(bad)", { XX } },
5858 { "(bad)", { XX } },
5859 { "(bad)", { XX } },
5860 { "(bad)", { XX } },
5861 { "(bad)", { XX } },
5862 { "(bad)", { XX } },
5864 { "(bad)", { XX } },
5865 { "(bad)", { XX } },
5866 { "(bad)", { XX } },
5867 { "(bad)", { XX } },
5868 { "(bad)", { XX } },
5869 { "(bad)", { XX } },
5870 { "(bad)", { XX } },
5871 { "(bad)", { XX } },
5873 { PREFIX_TABLE (PREFIX_0F3A40) },
5874 { PREFIX_TABLE (PREFIX_0F3A41) },
5875 { PREFIX_TABLE (PREFIX_0F3A42) },
5876 { "(bad)", { XX } },
5877 { PREFIX_TABLE (PREFIX_0F3A44) },
5878 { "(bad)", { XX } },
5879 { "(bad)", { XX } },
5880 { "(bad)", { XX } },
5882 { "(bad)", { XX } },
5883 { "(bad)", { XX } },
5884 { "(bad)", { XX } },
5885 { "(bad)", { XX } },
5886 { "(bad)", { XX } },
5887 { "(bad)", { XX } },
5888 { "(bad)", { XX } },
5889 { "(bad)", { XX } },
5891 { "(bad)", { XX } },
5892 { "(bad)", { XX } },
5893 { "(bad)", { XX } },
5894 { "(bad)", { XX } },
5895 { "(bad)", { XX } },
5896 { "(bad)", { XX } },
5897 { "(bad)", { XX } },
5898 { "(bad)", { XX } },
5900 { "(bad)", { XX } },
5901 { "(bad)", { XX } },
5902 { "(bad)", { XX } },
5903 { "(bad)", { XX } },
5904 { "(bad)", { XX } },
5905 { "(bad)", { XX } },
5906 { "(bad)", { XX } },
5907 { "(bad)", { XX } },
5909 { PREFIX_TABLE (PREFIX_0F3A60) },
5910 { PREFIX_TABLE (PREFIX_0F3A61) },
5911 { PREFIX_TABLE (PREFIX_0F3A62) },
5912 { PREFIX_TABLE (PREFIX_0F3A63) },
5913 { "(bad)", { XX } },
5914 { "(bad)", { XX } },
5915 { "(bad)", { XX } },
5916 { "(bad)", { XX } },
5918 { "(bad)", { XX } },
5919 { "(bad)", { XX } },
5920 { "(bad)", { XX } },
5921 { "(bad)", { XX } },
5922 { "(bad)", { XX } },
5923 { "(bad)", { XX } },
5924 { "(bad)", { XX } },
5925 { "(bad)", { XX } },
5927 { "(bad)", { XX } },
5928 { "(bad)", { XX } },
5929 { "(bad)", { XX } },
5930 { "(bad)", { XX } },
5931 { "(bad)", { XX } },
5932 { "(bad)", { XX } },
5933 { "(bad)", { XX } },
5934 { "(bad)", { XX } },
5936 { "(bad)", { XX } },
5937 { "(bad)", { XX } },
5938 { "(bad)", { XX } },
5939 { "(bad)", { XX } },
5940 { "(bad)", { XX } },
5941 { "(bad)", { XX } },
5942 { "(bad)", { XX } },
5943 { "(bad)", { XX } },
5945 { "(bad)", { XX } },
5946 { "(bad)", { XX } },
5947 { "(bad)", { XX } },
5948 { "(bad)", { XX } },
5949 { "(bad)", { XX } },
5950 { "(bad)", { XX } },
5951 { "(bad)", { XX } },
5952 { "(bad)", { XX } },
5954 { "(bad)", { XX } },
5955 { "(bad)", { XX } },
5956 { "(bad)", { XX } },
5957 { "(bad)", { XX } },
5958 { "(bad)", { XX } },
5959 { "(bad)", { XX } },
5960 { "(bad)", { XX } },
5961 { "(bad)", { XX } },
5963 { "(bad)", { XX } },
5964 { "(bad)", { XX } },
5965 { "(bad)", { XX } },
5966 { "(bad)", { XX } },
5967 { "(bad)", { XX } },
5968 { "(bad)", { XX } },
5969 { "(bad)", { XX } },
5970 { "(bad)", { XX } },
5972 { "(bad)", { XX } },
5973 { "(bad)", { XX } },
5974 { "(bad)", { XX } },
5975 { "(bad)", { XX } },
5976 { "(bad)", { XX } },
5977 { "(bad)", { XX } },
5978 { "(bad)", { XX } },
5979 { "(bad)", { XX } },
5981 { "(bad)", { XX } },
5982 { "(bad)", { XX } },
5983 { "(bad)", { XX } },
5984 { "(bad)", { XX } },
5985 { "(bad)", { XX } },
5986 { "(bad)", { XX } },
5987 { "(bad)", { XX } },
5988 { "(bad)", { XX } },
5990 { "(bad)", { XX } },
5991 { "(bad)", { XX } },
5992 { "(bad)", { XX } },
5993 { "(bad)", { XX } },
5994 { "(bad)", { XX } },
5995 { "(bad)", { XX } },
5996 { "(bad)", { XX } },
5997 { "(bad)", { XX } },
5999 { "(bad)", { XX } },
6000 { "(bad)", { XX } },
6001 { "(bad)", { XX } },
6002 { "(bad)", { XX } },
6003 { "(bad)", { XX } },
6004 { "(bad)", { XX } },
6005 { "(bad)", { XX } },
6006 { "(bad)", { XX } },
6008 { "(bad)", { XX } },
6009 { "(bad)", { XX } },
6010 { "(bad)", { XX } },
6011 { "(bad)", { XX } },
6012 { "(bad)", { XX } },
6013 { "(bad)", { XX } },
6014 { "(bad)", { XX } },
6015 { "(bad)", { XX } },
6017 { "(bad)", { XX } },
6018 { "(bad)", { XX } },
6019 { "(bad)", { XX } },
6020 { "(bad)", { XX } },
6021 { "(bad)", { XX } },
6022 { "(bad)", { XX } },
6023 { "(bad)", { XX } },
6024 { "(bad)", { XX } },
6026 { "(bad)", { XX } },
6027 { "(bad)", { XX } },
6028 { "(bad)", { XX } },
6029 { "(bad)", { XX } },
6030 { "(bad)", { XX } },
6031 { "(bad)", { XX } },
6032 { "(bad)", { XX } },
6033 { "(bad)", { XX } },
6035 { "(bad)", { XX } },
6036 { "(bad)", { XX } },
6037 { "(bad)", { XX } },
6038 { "(bad)", { XX } },
6039 { "(bad)", { XX } },
6040 { "(bad)", { XX } },
6041 { "(bad)", { XX } },
6042 { "(bad)", { XX } },
6044 { "(bad)", { XX } },
6045 { "(bad)", { XX } },
6046 { "(bad)", { XX } },
6047 { "(bad)", { XX } },
6048 { "(bad)", { XX } },
6049 { "(bad)", { XX } },
6050 { "(bad)", { XX } },
6051 { PREFIX_TABLE (PREFIX_0F3ADF) },
6053 { "(bad)", { XX } },
6054 { "(bad)", { XX } },
6055 { "(bad)", { XX } },
6056 { "(bad)", { XX } },
6057 { "(bad)", { XX } },
6058 { "(bad)", { XX } },
6059 { "(bad)", { XX } },
6060 { "(bad)", { XX } },
6062 { "(bad)", { XX } },
6063 { "(bad)", { XX } },
6064 { "(bad)", { XX } },
6065 { "(bad)", { XX } },
6066 { "(bad)", { XX } },
6067 { "(bad)", { XX } },
6068 { "(bad)", { XX } },
6069 { "(bad)", { XX } },
6071 { "(bad)", { XX } },
6072 { "(bad)", { XX } },
6073 { "(bad)", { XX } },
6074 { "(bad)", { XX } },
6075 { "(bad)", { XX } },
6076 { "(bad)", { XX } },
6077 { "(bad)", { XX } },
6078 { "(bad)", { XX } },
6080 { "(bad)", { XX } },
6081 { "(bad)", { XX } },
6082 { "(bad)", { XX } },
6083 { "(bad)", { XX } },
6084 { "(bad)", { XX } },
6085 { "(bad)", { XX } },
6086 { "(bad)", { XX } },
6087 { "(bad)", { XX } },
6090 /* THREE_BYTE_0F7A */
6093 { "(bad)", { XX } },
6094 { "(bad)", { XX } },
6095 { "(bad)", { XX } },
6096 { "(bad)", { XX } },
6097 { "(bad)", { XX } },
6098 { "(bad)", { XX } },
6099 { "(bad)", { XX } },
6100 { "(bad)", { XX } },
6102 { "(bad)", { XX } },
6103 { "(bad)", { XX } },
6104 { "(bad)", { XX } },
6105 { "(bad)", { XX } },
6106 { "(bad)", { XX } },
6107 { "(bad)", { XX } },
6108 { "(bad)", { XX } },
6109 { "(bad)", { XX } },
6111 { "(bad)", { XX } },
6112 { "(bad)", { XX } },
6113 { "(bad)", { XX } },
6114 { "(bad)", { XX } },
6115 { "(bad)", { XX } },
6116 { "(bad)", { XX } },
6117 { "(bad)", { XX } },
6118 { "(bad)", { XX } },
6120 { "(bad)", { XX } },
6121 { "(bad)", { XX } },
6122 { "(bad)", { XX } },
6123 { "(bad)", { XX } },
6124 { "(bad)", { XX } },
6125 { "(bad)", { XX } },
6126 { "(bad)", { XX } },
6127 { "(bad)", { XX } },
6129 { "ptest", { XX } },
6130 { "(bad)", { XX } },
6131 { "(bad)", { XX } },
6132 { "(bad)", { XX } },
6133 { "(bad)", { XX } },
6134 { "(bad)", { XX } },
6135 { "(bad)", { XX } },
6136 { "(bad)", { XX } },
6138 { "(bad)", { XX } },
6139 { "(bad)", { XX } },
6140 { "(bad)", { XX } },
6141 { "(bad)", { XX } },
6142 { "(bad)", { XX } },
6143 { "(bad)", { XX } },
6144 { "(bad)", { XX } },
6145 { "(bad)", { XX } },
6147 { "(bad)", { XX } },
6148 { "(bad)", { XX } },
6149 { "(bad)", { XX } },
6150 { "(bad)", { XX } },
6151 { "(bad)", { XX } },
6152 { "(bad)", { XX } },
6153 { "(bad)", { XX } },
6154 { "(bad)", { XX } },
6156 { "(bad)", { XX } },
6157 { "(bad)", { XX } },
6158 { "(bad)", { XX } },
6159 { "(bad)", { XX } },
6160 { "(bad)", { XX } },
6161 { "(bad)", { XX } },
6162 { "(bad)", { XX } },
6163 { "(bad)", { XX } },
6165 { "(bad)", { XX } },
6166 { "phaddbw", { XM, EXq } },
6167 { "phaddbd", { XM, EXq } },
6168 { "phaddbq", { XM, EXq } },
6169 { "(bad)", { XX } },
6170 { "(bad)", { XX } },
6171 { "phaddwd", { XM, EXq } },
6172 { "phaddwq", { XM, EXq } },
6174 { "(bad)", { XX } },
6175 { "(bad)", { XX } },
6176 { "(bad)", { XX } },
6177 { "phadddq", { XM, EXq } },
6178 { "(bad)", { XX } },
6179 { "(bad)", { XX } },
6180 { "(bad)", { XX } },
6181 { "(bad)", { XX } },
6183 { "(bad)", { XX } },
6184 { "phaddubw", { XM, EXq } },
6185 { "phaddubd", { XM, EXq } },
6186 { "phaddubq", { XM, EXq } },
6187 { "(bad)", { XX } },
6188 { "(bad)", { XX } },
6189 { "phadduwd", { XM, EXq } },
6190 { "phadduwq", { XM, EXq } },
6192 { "(bad)", { XX } },
6193 { "(bad)", { XX } },
6194 { "(bad)", { XX } },
6195 { "phaddudq", { XM, EXq } },
6196 { "(bad)", { XX } },
6197 { "(bad)", { XX } },
6198 { "(bad)", { XX } },
6199 { "(bad)", { XX } },
6201 { "(bad)", { XX } },
6202 { "phsubbw", { XM, EXq } },
6203 { "phsubbd", { XM, EXq } },
6204 { "phsubbq", { XM, EXq } },
6205 { "(bad)", { XX } },
6206 { "(bad)", { XX } },
6207 { "(bad)", { XX } },
6208 { "(bad)", { XX } },
6210 { "(bad)", { XX } },
6211 { "(bad)", { XX } },
6212 { "(bad)", { XX } },
6213 { "(bad)", { XX } },
6214 { "(bad)", { XX } },
6215 { "(bad)", { XX } },
6216 { "(bad)", { XX } },
6217 { "(bad)", { XX } },
6219 { "(bad)", { XX } },
6220 { "(bad)", { XX } },
6221 { "(bad)", { XX } },
6222 { "(bad)", { XX } },
6223 { "(bad)", { XX } },
6224 { "(bad)", { XX } },
6225 { "(bad)", { XX } },
6226 { "(bad)", { XX } },
6228 { "(bad)", { XX } },
6229 { "(bad)", { XX } },
6230 { "(bad)", { XX } },
6231 { "(bad)", { XX } },
6232 { "(bad)", { XX } },
6233 { "(bad)", { XX } },
6234 { "(bad)", { XX } },
6235 { "(bad)", { XX } },
6237 { "(bad)", { XX } },
6238 { "(bad)", { XX } },
6239 { "(bad)", { XX } },
6240 { "(bad)", { XX } },
6241 { "(bad)", { XX } },
6242 { "(bad)", { XX } },
6243 { "(bad)", { XX } },
6244 { "(bad)", { XX } },
6246 { "(bad)", { XX } },
6247 { "(bad)", { XX } },
6248 { "(bad)", { XX } },
6249 { "(bad)", { XX } },
6250 { "(bad)", { XX } },
6251 { "(bad)", { XX } },
6252 { "(bad)", { XX } },
6253 { "(bad)", { XX } },
6255 { "(bad)", { XX } },
6256 { "(bad)", { XX } },
6257 { "(bad)", { XX } },
6258 { "(bad)", { XX } },
6259 { "(bad)", { XX } },
6260 { "(bad)", { XX } },
6261 { "(bad)", { XX } },
6262 { "(bad)", { XX } },
6264 { "(bad)", { XX } },
6265 { "(bad)", { XX } },
6266 { "(bad)", { XX } },
6267 { "(bad)", { XX } },
6268 { "(bad)", { XX } },
6269 { "(bad)", { XX } },
6270 { "(bad)", { XX } },
6271 { "(bad)", { XX } },
6273 { "(bad)", { XX } },
6274 { "(bad)", { XX } },
6275 { "(bad)", { XX } },
6276 { "(bad)", { XX } },
6277 { "(bad)", { XX } },
6278 { "(bad)", { XX } },
6279 { "(bad)", { XX } },
6280 { "(bad)", { XX } },
6282 { "(bad)", { XX } },
6283 { "(bad)", { XX } },
6284 { "(bad)", { XX } },
6285 { "(bad)", { XX } },
6286 { "(bad)", { XX } },
6287 { "(bad)", { XX } },
6288 { "(bad)", { XX } },
6289 { "(bad)", { XX } },
6291 { "(bad)", { XX } },
6292 { "(bad)", { XX } },
6293 { "(bad)", { XX } },
6294 { "(bad)", { XX } },
6295 { "(bad)", { XX } },
6296 { "(bad)", { XX } },
6297 { "(bad)", { XX } },
6298 { "(bad)", { XX } },
6300 { "(bad)", { XX } },
6301 { "(bad)", { XX } },
6302 { "(bad)", { XX } },
6303 { "(bad)", { XX } },
6304 { "(bad)", { XX } },
6305 { "(bad)", { XX } },
6306 { "(bad)", { XX } },
6307 { "(bad)", { XX } },
6309 { "(bad)", { XX } },
6310 { "(bad)", { XX } },
6311 { "(bad)", { XX } },
6312 { "(bad)", { XX } },
6313 { "(bad)", { XX } },
6314 { "(bad)", { XX } },
6315 { "(bad)", { XX } },
6316 { "(bad)", { XX } },
6318 { "(bad)", { XX } },
6319 { "(bad)", { XX } },
6320 { "(bad)", { XX } },
6321 { "(bad)", { XX } },
6322 { "(bad)", { XX } },
6323 { "(bad)", { XX } },
6324 { "(bad)", { XX } },
6325 { "(bad)", { XX } },
6327 { "(bad)", { XX } },
6328 { "(bad)", { XX } },
6329 { "(bad)", { XX } },
6330 { "(bad)", { XX } },
6331 { "(bad)", { XX } },
6332 { "(bad)", { XX } },
6333 { "(bad)", { XX } },
6334 { "(bad)", { XX } },
6336 { "(bad)", { XX } },
6337 { "(bad)", { XX } },
6338 { "(bad)", { XX } },
6339 { "(bad)", { XX } },
6340 { "(bad)", { XX } },
6341 { "(bad)", { XX } },
6342 { "(bad)", { XX } },
6343 { "(bad)", { XX } },
6345 { "(bad)", { XX } },
6346 { "(bad)", { XX } },
6347 { "(bad)", { XX } },
6348 { "(bad)", { XX } },
6349 { "(bad)", { XX } },
6350 { "(bad)", { XX } },
6351 { "(bad)", { XX } },
6352 { "(bad)", { XX } },
6354 { "(bad)", { XX } },
6355 { "(bad)", { XX } },
6356 { "(bad)", { XX } },
6357 { "(bad)", { XX } },
6358 { "(bad)", { XX } },
6359 { "(bad)", { XX } },
6360 { "(bad)", { XX } },
6361 { "(bad)", { XX } },
6363 { "(bad)", { XX } },
6364 { "(bad)", { XX } },
6365 { "(bad)", { XX } },
6366 { "(bad)", { XX } },
6367 { "(bad)", { XX } },
6368 { "(bad)", { XX } },
6369 { "(bad)", { XX } },
6370 { "(bad)", { XX } },
6372 { "(bad)", { XX } },
6373 { "(bad)", { XX } },
6374 { "(bad)", { XX } },
6375 { "(bad)", { XX } },
6376 { "(bad)", { XX } },
6377 { "(bad)", { XX } },
6378 { "(bad)", { XX } },
6379 { "(bad)", { XX } },
6383 static const struct dis386 xop_table[][256] = {
6387 { "(bad)", { XX } },
6388 { "(bad)", { XX } },
6389 { "(bad)", { XX } },
6390 { "(bad)", { XX } },
6391 { "(bad)", { XX } },
6392 { "(bad)", { XX } },
6393 { "(bad)", { XX } },
6394 { "(bad)", { XX } },
6396 { "(bad)", { XX } },
6397 { "(bad)", { XX } },
6398 { "(bad)", { XX } },
6399 { "(bad)", { XX } },
6400 { "(bad)", { XX } },
6401 { "(bad)", { XX } },
6402 { "(bad)", { XX } },
6403 { "(bad)", { XX } },
6405 { "(bad)", { XX } },
6406 { "(bad)", { XX } },
6407 { REG_TABLE (REG_XOP_LWPCB) },
6408 { "(bad)", { XX } },
6409 { "(bad)", { XX } },
6410 { "(bad)", { XX } },
6411 { "(bad)", { XX } },
6412 { "(bad)", { XX } },
6414 { "(bad)", { XX } },
6415 { "(bad)", { XX } },
6416 { "(bad)", { XX } },
6417 { "(bad)", { XX } },
6418 { "(bad)", { XX } },
6419 { "(bad)", { XX } },
6420 { "(bad)", { XX } },
6421 { "(bad)", { XX } },
6423 { "(bad)", { XX } },
6424 { "(bad)", { XX } },
6425 { "(bad)", { XX } },
6426 { "(bad)", { XX } },
6427 { "(bad)", { XX } },
6428 { "(bad)", { XX } },
6429 { "(bad)", { XX } },
6430 { "(bad)", { XX } },
6432 { "(bad)", { XX } },
6433 { "(bad)", { XX } },
6434 { "(bad)", { XX } },
6435 { "(bad)", { XX } },
6436 { "(bad)", { XX } },
6437 { "(bad)", { XX } },
6438 { "(bad)", { XX } },
6439 { "(bad)", { XX } },
6441 { "(bad)", { XX } },
6442 { "(bad)", { XX } },
6443 { "(bad)", { XX } },
6444 { "(bad)", { XX } },
6445 { "(bad)", { XX } },
6446 { "(bad)", { XX } },
6447 { "(bad)", { XX } },
6448 { "(bad)", { XX } },
6450 { "(bad)", { XX } },
6451 { "(bad)", { XX } },
6452 { "(bad)", { XX } },
6453 { "(bad)", { XX } },
6454 { "(bad)", { XX } },
6455 { "(bad)", { XX } },
6456 { "(bad)", { XX } },
6457 { "(bad)", { XX } },
6459 { "(bad)", { XX } },
6460 { "(bad)", { XX } },
6461 { "(bad)", { XX } },
6462 { "(bad)", { XX } },
6463 { "(bad)", { XX } },
6464 { "(bad)", { XX } },
6465 { "(bad)", { XX } },
6466 { "(bad)", { XX } },
6468 { "(bad)", { XX } },
6469 { "(bad)", { XX } },
6470 { "(bad)", { XX } },
6471 { "(bad)", { XX } },
6472 { "(bad)", { XX } },
6473 { "(bad)", { XX } },
6474 { "(bad)", { XX } },
6475 { "(bad)", { XX } },
6477 { "(bad)", { XX } },
6478 { "(bad)", { XX } },
6479 { "(bad)", { XX } },
6480 { "(bad)", { XX } },
6481 { "(bad)", { XX } },
6482 { "(bad)", { XX } },
6483 { "(bad)", { XX } },
6484 { "(bad)", { XX } },
6486 { "(bad)", { XX } },
6487 { "(bad)", { XX } },
6488 { "(bad)", { XX } },
6489 { "(bad)", { XX } },
6490 { "(bad)", { XX } },
6491 { "(bad)", { XX } },
6492 { "(bad)", { XX } },
6493 { "(bad)", { XX } },
6495 { "(bad)", { XX } },
6496 { "(bad)", { XX } },
6497 { "(bad)", { XX } },
6498 { "(bad)", { XX } },
6499 { "(bad)", { XX } },
6500 { "(bad)", { XX } },
6501 { "(bad)", { XX } },
6502 { "(bad)", { XX } },
6504 { "(bad)", { XX } },
6505 { "(bad)", { XX } },
6506 { "(bad)", { XX } },
6507 { "(bad)", { XX } },
6508 { "(bad)", { XX } },
6509 { "(bad)", { XX } },
6510 { "(bad)", { XX } },
6511 { "(bad)", { XX } },
6513 { "(bad)", { XX } },
6514 { "(bad)", { XX } },
6515 { "(bad)", { XX } },
6516 { "(bad)", { XX } },
6517 { "(bad)", { XX } },
6518 { "(bad)", { XX } },
6519 { "(bad)", { XX } },
6520 { "(bad)", { XX } },
6522 { "(bad)", { XX } },
6523 { "(bad)", { XX } },
6524 { "(bad)", { XX } },
6525 { "(bad)", { XX } },
6526 { "(bad)", { XX } },
6527 { "(bad)", { XX } },
6528 { "(bad)", { XX } },
6529 { "(bad)", { XX } },
6531 { "(bad)", { XX } },
6532 { "(bad)", { XX } },
6533 { "(bad)", { XX } },
6534 { "(bad)", { XX } },
6535 { "(bad)", { XX } },
6536 { "(bad)", { XX } },
6537 { "(bad)", { XX } },
6538 { "(bad)", { XX } },
6540 { "(bad)", { XX } },
6541 { "(bad)", { XX } },
6542 { "(bad)", { XX } },
6543 { "(bad)", { XX } },
6544 { "(bad)", { XX } },
6545 { "(bad)", { XX } },
6546 { "(bad)", { XX } },
6547 { "(bad)", { XX } },
6549 { "(bad)", { XX } },
6550 { "(bad)", { XX } },
6551 { "(bad)", { XX } },
6552 { "(bad)", { XX } },
6553 { "(bad)", { XX } },
6554 { "(bad)", { XX } },
6555 { "(bad)", { XX } },
6556 { "(bad)", { XX } },
6558 { "(bad)", { XX } },
6559 { "(bad)", { XX } },
6560 { "(bad)", { XX } },
6561 { "(bad)", { XX } },
6562 { "(bad)", { XX } },
6563 { "(bad)", { XX } },
6564 { "(bad)", { XX } },
6565 { "(bad)", { XX } },
6567 { "(bad)", { XX } },
6568 { "(bad)", { XX } },
6569 { "(bad)", { XX } },
6570 { "(bad)", { XX } },
6571 { "(bad)", { XX } },
6572 { "(bad)", { XX } },
6573 { "(bad)", { XX } },
6574 { "(bad)", { XX } },
6576 { "(bad)", { XX } },
6577 { "(bad)", { XX } },
6578 { "(bad)", { XX } },
6579 { "(bad)", { XX } },
6580 { "(bad)", { XX } },
6581 { "(bad)", { XX } },
6582 { "(bad)", { XX } },
6583 { "(bad)", { XX } },
6585 { "(bad)", { XX } },
6586 { "(bad)", { XX } },
6587 { "(bad)", { XX } },
6588 { "(bad)", { XX } },
6589 { "(bad)", { XX } },
6590 { "(bad)", { XX } },
6591 { "(bad)", { XX } },
6592 { "(bad)", { XX } },
6594 { "(bad)", { XX } },
6595 { "(bad)", { XX } },
6596 { "(bad)", { XX } },
6597 { "(bad)", { XX } },
6598 { "(bad)", { XX } },
6599 { "(bad)", { XX } },
6600 { "(bad)", { XX } },
6601 { "(bad)", { XX } },
6603 { "(bad)", { XX } },
6604 { "(bad)", { XX } },
6605 { "(bad)", { XX } },
6606 { "(bad)", { XX } },
6607 { "(bad)", { XX } },
6608 { "(bad)", { XX } },
6609 { "(bad)", { XX } },
6610 { "(bad)", { XX } },
6612 { "(bad)", { XX } },
6613 { "(bad)", { XX } },
6614 { "(bad)", { XX } },
6615 { "(bad)", { XX } },
6616 { "(bad)", { XX } },
6617 { "(bad)", { XX } },
6618 { "(bad)", { XX } },
6619 { "(bad)", { XX } },
6621 { "(bad)", { XX } },
6622 { "(bad)", { XX } },
6623 { "(bad)", { XX } },
6624 { "(bad)", { XX } },
6625 { "(bad)", { XX } },
6626 { "(bad)", { XX } },
6627 { "(bad)", { XX } },
6628 { "(bad)", { XX } },
6630 { "(bad)", { XX } },
6631 { "(bad)", { XX } },
6632 { "(bad)", { XX } },
6633 { "(bad)", { XX } },
6634 { "(bad)", { XX } },
6635 { "(bad)", { XX } },
6636 { "(bad)", { XX } },
6637 { "(bad)", { XX } },
6639 { "(bad)", { XX } },
6640 { "(bad)", { XX } },
6641 { "(bad)", { XX } },
6642 { "(bad)", { XX } },
6643 { "(bad)", { XX } },
6644 { "(bad)", { XX } },
6645 { "(bad)", { XX } },
6646 { "(bad)", { XX } },
6648 { "(bad)", { XX } },
6649 { "(bad)", { XX } },
6650 { "(bad)", { XX } },
6651 { "(bad)", { XX } },
6652 { "(bad)", { XX } },
6653 { "(bad)", { XX } },
6654 { "(bad)", { XX } },
6655 { "(bad)", { XX } },
6657 { "(bad)", { XX } },
6658 { "(bad)", { XX } },
6659 { "(bad)", { XX } },
6660 { "(bad)", { XX } },
6661 { "(bad)", { XX } },
6662 { "(bad)", { XX } },
6663 { "(bad)", { XX } },
6664 { "(bad)", { XX } },
6666 { "(bad)", { XX } },
6667 { "(bad)", { XX } },
6668 { "(bad)", { XX } },
6669 { "(bad)", { XX } },
6670 { "(bad)", { XX } },
6671 { "(bad)", { XX } },
6672 { "(bad)", { XX } },
6673 { "(bad)", { XX } },
6678 { "(bad)", { XX } },
6679 { "(bad)", { XX } },
6680 { "(bad)", { XX } },
6681 { "(bad)", { XX } },
6682 { "(bad)", { XX } },
6683 { "(bad)", { XX } },
6684 { "(bad)", { XX } },
6685 { "(bad)", { XX } },
6687 { "(bad)", { XX } },
6688 { "(bad)", { XX } },
6689 { "(bad)", { XX } },
6690 { "(bad)", { XX } },
6691 { "(bad)", { XX } },
6692 { "(bad)", { XX } },
6693 { "(bad)", { XX } },
6694 { "(bad)", { XX } },
6696 { "(bad)", { XX } },
6697 { "(bad)", { XX } },
6698 { REG_TABLE (REG_XOP_LWP) },
6699 { "(bad)", { XX } },
6700 { "(bad)", { XX } },
6701 { "(bad)", { XX } },
6702 { "(bad)", { XX } },
6703 { "(bad)", { XX } },
6705 { "(bad)", { XX } },
6706 { "(bad)", { XX } },
6707 { "(bad)", { XX } },
6708 { "(bad)", { XX } },
6709 { "(bad)", { XX } },
6710 { "(bad)", { XX } },
6711 { "(bad)", { XX } },
6712 { "(bad)", { XX } },
6714 { "(bad)", { XX } },
6715 { "(bad)", { XX } },
6716 { "(bad)", { XX } },
6717 { "(bad)", { XX } },
6718 { "(bad)", { XX } },
6719 { "(bad)", { XX } },
6720 { "(bad)", { XX } },
6721 { "(bad)", { XX } },
6723 { "(bad)", { XX } },
6724 { "(bad)", { XX } },
6725 { "(bad)", { XX } },
6726 { "(bad)", { XX } },
6727 { "(bad)", { XX } },
6728 { "(bad)", { XX } },
6729 { "(bad)", { XX } },
6730 { "(bad)", { XX } },
6732 { "(bad)", { XX } },
6733 { "(bad)", { XX } },
6734 { "(bad)", { XX } },
6735 { "(bad)", { XX } },
6736 { "(bad)", { XX } },
6737 { "(bad)", { XX } },
6738 { "(bad)", { XX } },
6739 { "(bad)", { XX } },
6741 { "(bad)", { XX } },
6742 { "(bad)", { XX } },
6743 { "(bad)", { XX } },
6744 { "(bad)", { XX } },
6745 { "(bad)", { XX } },
6746 { "(bad)", { XX } },
6747 { "(bad)", { XX } },
6748 { "(bad)", { XX } },
6750 { "(bad)", { XX } },
6751 { "(bad)", { XX } },
6752 { "(bad)", { XX } },
6753 { "(bad)", { XX } },
6754 { "(bad)", { XX } },
6755 { "(bad)", { XX } },
6756 { "(bad)", { XX } },
6757 { "(bad)", { XX } },
6759 { "(bad)", { XX } },
6760 { "(bad)", { XX } },
6761 { "(bad)", { XX } },
6762 { "(bad)", { XX } },
6763 { "(bad)", { XX } },
6764 { "(bad)", { XX } },
6765 { "(bad)", { XX } },
6766 { "(bad)", { XX } },
6768 { "(bad)", { XX } },
6769 { "(bad)", { XX } },
6770 { "(bad)", { XX } },
6771 { "(bad)", { XX } },
6772 { "(bad)", { XX } },
6773 { "(bad)", { XX } },
6774 { "(bad)", { XX } },
6775 { "(bad)", { XX } },
6777 { "(bad)", { XX } },
6778 { "(bad)", { XX } },
6779 { "(bad)", { XX } },
6780 { "(bad)", { XX } },
6781 { "(bad)", { XX } },
6782 { "(bad)", { XX } },
6783 { "(bad)", { XX } },
6784 { "(bad)", { XX } },
6786 { "(bad)", { XX } },
6787 { "(bad)", { XX } },
6788 { "(bad)", { XX } },
6789 { "(bad)", { XX } },
6790 { "(bad)", { XX } },
6791 { "(bad)", { XX } },
6792 { "(bad)", { XX } },
6793 { "(bad)", { XX } },
6795 { "(bad)", { XX } },
6796 { "(bad)", { XX } },
6797 { "(bad)", { XX } },
6798 { "(bad)", { XX } },
6799 { "(bad)", { XX } },
6800 { "(bad)", { XX } },
6801 { "(bad)", { XX } },
6802 { "(bad)", { XX } },
6804 { "(bad)", { XX } },
6805 { "(bad)", { XX } },
6806 { "(bad)", { XX } },
6807 { "(bad)", { XX } },
6808 { "(bad)", { XX } },
6809 { "(bad)", { XX } },
6810 { "(bad)", { XX } },
6811 { "(bad)", { XX } },
6813 { "(bad)", { XX } },
6814 { "(bad)", { XX } },
6815 { "(bad)", { XX } },
6816 { "(bad)", { XX } },
6817 { "(bad)", { XX } },
6818 { "(bad)", { XX } },
6819 { "(bad)", { XX } },
6820 { "(bad)", { XX } },
6822 { "(bad)", { XX } },
6823 { "(bad)", { XX } },
6824 { "(bad)", { XX } },
6825 { "(bad)", { XX } },
6826 { "(bad)", { XX } },
6827 { "(bad)", { XX } },
6828 { "(bad)", { XX } },
6829 { "(bad)", { XX } },
6831 { "(bad)", { XX } },
6832 { "(bad)", { XX } },
6833 { "(bad)", { XX } },
6834 { "(bad)", { XX } },
6835 { "(bad)", { XX } },
6836 { "(bad)", { XX } },
6837 { "(bad)", { XX } },
6838 { "(bad)", { XX } },
6840 { "(bad)", { XX } },
6841 { "(bad)", { XX } },
6842 { "(bad)", { XX } },
6843 { "(bad)", { XX } },
6844 { "(bad)", { XX } },
6845 { "(bad)", { XX } },
6846 { "(bad)", { XX } },
6847 { "(bad)", { XX } },
6849 { "(bad)", { XX } },
6850 { "(bad)", { XX } },
6851 { "(bad)", { XX } },
6852 { "(bad)", { XX } },
6853 { "(bad)", { XX } },
6854 { "(bad)", { XX } },
6855 { "(bad)", { XX } },
6856 { "(bad)", { XX } },
6858 { "(bad)", { XX } },
6859 { "(bad)", { XX } },
6860 { "(bad)", { XX } },
6861 { "(bad)", { XX } },
6862 { "(bad)", { XX } },
6863 { "(bad)", { XX } },
6864 { "(bad)", { XX } },
6865 { "(bad)", { XX } },
6867 { "(bad)", { XX } },
6868 { "(bad)", { XX } },
6869 { "(bad)", { XX } },
6870 { "(bad)", { XX } },
6871 { "(bad)", { XX } },
6872 { "(bad)", { XX } },
6873 { "(bad)", { XX } },
6874 { "(bad)", { XX } },
6876 { "(bad)", { XX } },
6877 { "(bad)", { XX } },
6878 { "(bad)", { XX } },
6879 { "(bad)", { XX } },
6880 { "(bad)", { XX } },
6881 { "(bad)", { XX } },
6882 { "(bad)", { XX } },
6883 { "(bad)", { XX } },
6885 { "(bad)", { XX } },
6886 { "(bad)", { XX } },
6887 { "(bad)", { XX } },
6888 { "(bad)", { XX } },
6889 { "(bad)", { XX } },
6890 { "(bad)", { XX } },
6891 { "(bad)", { XX } },
6892 { "(bad)", { XX } },
6894 { "(bad)", { XX } },
6895 { "(bad)", { XX } },
6896 { "(bad)", { XX } },
6897 { "(bad)", { XX } },
6898 { "(bad)", { XX } },
6899 { "(bad)", { XX } },
6900 { "(bad)", { XX } },
6901 { "(bad)", { XX } },
6903 { "(bad)", { XX } },
6904 { "(bad)", { XX } },
6905 { "(bad)", { XX } },
6906 { "(bad)", { XX } },
6907 { "(bad)", { XX } },
6908 { "(bad)", { XX } },
6909 { "(bad)", { XX } },
6910 { "(bad)", { XX } },
6912 { "(bad)", { XX } },
6913 { "(bad)", { XX } },
6914 { "(bad)", { XX } },
6915 { "(bad)", { XX } },
6916 { "(bad)", { XX } },
6917 { "(bad)", { XX } },
6918 { "(bad)", { XX } },
6919 { "(bad)", { XX } },
6921 { "(bad)", { XX } },
6922 { "(bad)", { XX } },
6923 { "(bad)", { XX } },
6924 { "(bad)", { XX } },
6925 { "(bad)", { XX } },
6926 { "(bad)", { XX } },
6927 { "(bad)", { XX } },
6928 { "(bad)", { XX } },
6930 { "(bad)", { XX } },
6931 { "(bad)", { XX } },
6932 { "(bad)", { XX } },
6933 { "(bad)", { XX } },
6934 { "(bad)", { XX } },
6935 { "(bad)", { XX } },
6936 { "(bad)", { XX } },
6937 { "(bad)", { XX } },
6939 { "(bad)", { XX } },
6940 { "(bad)", { XX } },
6941 { "(bad)", { XX } },
6942 { "(bad)", { XX } },
6943 { "(bad)", { XX } },
6944 { "(bad)", { XX } },
6945 { "(bad)", { XX } },
6946 { "(bad)", { XX } },
6948 { "(bad)", { XX } },
6949 { "(bad)", { XX } },
6950 { "(bad)", { XX } },
6951 { "(bad)", { XX } },
6952 { "(bad)", { XX } },
6953 { "(bad)", { XX } },
6954 { "(bad)", { XX } },
6955 { "(bad)", { XX } },
6957 { "(bad)", { XX } },
6958 { "(bad)", { XX } },
6959 { "(bad)", { XX } },
6960 { "(bad)", { XX } },
6961 { "(bad)", { XX } },
6962 { "(bad)", { XX } },
6963 { "(bad)", { XX } },
6964 { "(bad)", { XX } },
6968 static const struct dis386 vex_table[][256] = {
6972 { "(bad)", { XX } },
6973 { "(bad)", { XX } },
6974 { "(bad)", { XX } },
6975 { "(bad)", { XX } },
6976 { "(bad)", { XX } },
6977 { "(bad)", { XX } },
6978 { "(bad)", { XX } },
6979 { "(bad)", { XX } },
6981 { "(bad)", { XX } },
6982 { "(bad)", { XX } },
6983 { "(bad)", { XX } },
6984 { "(bad)", { XX } },
6985 { "(bad)", { XX } },
6986 { "(bad)", { XX } },
6987 { "(bad)", { XX } },
6988 { "(bad)", { XX } },
6990 { PREFIX_TABLE (PREFIX_VEX_10) },
6991 { PREFIX_TABLE (PREFIX_VEX_11) },
6992 { PREFIX_TABLE (PREFIX_VEX_12) },
6993 { MOD_TABLE (MOD_VEX_13) },
6994 { "vunpcklpX", { XM, Vex, EXx } },
6995 { "vunpckhpX", { XM, Vex, EXx } },
6996 { PREFIX_TABLE (PREFIX_VEX_16) },
6997 { MOD_TABLE (MOD_VEX_17) },
6999 { "(bad)", { XX } },
7000 { "(bad)", { XX } },
7001 { "(bad)", { XX } },
7002 { "(bad)", { XX } },
7003 { "(bad)", { XX } },
7004 { "(bad)", { XX } },
7005 { "(bad)", { XX } },
7006 { "(bad)", { XX } },
7008 { "(bad)", { XX } },
7009 { "(bad)", { XX } },
7010 { "(bad)", { XX } },
7011 { "(bad)", { XX } },
7012 { "(bad)", { XX } },
7013 { "(bad)", { XX } },
7014 { "(bad)", { XX } },
7015 { "(bad)", { XX } },
7017 { "vmovapX", { XM, EXx } },
7018 { "vmovapX", { EXxS, XM } },
7019 { PREFIX_TABLE (PREFIX_VEX_2A) },
7020 { MOD_TABLE (MOD_VEX_2B) },
7021 { PREFIX_TABLE (PREFIX_VEX_2C) },
7022 { PREFIX_TABLE (PREFIX_VEX_2D) },
7023 { PREFIX_TABLE (PREFIX_VEX_2E) },
7024 { PREFIX_TABLE (PREFIX_VEX_2F) },
7026 { "(bad)", { XX } },
7027 { "(bad)", { XX } },
7028 { "(bad)", { XX } },
7029 { "(bad)", { XX } },
7030 { "(bad)", { XX } },
7031 { "(bad)", { XX } },
7032 { "(bad)", { XX } },
7033 { "(bad)", { XX } },
7035 { "(bad)", { XX } },
7036 { "(bad)", { XX } },
7037 { "(bad)", { XX } },
7038 { "(bad)", { XX } },
7039 { "(bad)", { XX } },
7040 { "(bad)", { XX } },
7041 { "(bad)", { XX } },
7042 { "(bad)", { XX } },
7044 { "(bad)", { XX } },
7045 { "(bad)", { XX } },
7046 { "(bad)", { XX } },
7047 { "(bad)", { XX } },
7048 { "(bad)", { XX } },
7049 { "(bad)", { XX } },
7050 { "(bad)", { XX } },
7051 { "(bad)", { XX } },
7053 { "(bad)", { XX } },
7054 { "(bad)", { XX } },
7055 { "(bad)", { XX } },
7056 { "(bad)", { XX } },
7057 { "(bad)", { XX } },
7058 { "(bad)", { XX } },
7059 { "(bad)", { XX } },
7060 { "(bad)", { XX } },
7062 { MOD_TABLE (MOD_VEX_51) },
7063 { PREFIX_TABLE (PREFIX_VEX_51) },
7064 { PREFIX_TABLE (PREFIX_VEX_52) },
7065 { PREFIX_TABLE (PREFIX_VEX_53) },
7066 { "vandpX", { XM, Vex, EXx } },
7067 { "vandnpX", { XM, Vex, EXx } },
7068 { "vorpX", { XM, Vex, EXx } },
7069 { "vxorpX", { XM, Vex, EXx } },
7071 { PREFIX_TABLE (PREFIX_VEX_58) },
7072 { PREFIX_TABLE (PREFIX_VEX_59) },
7073 { PREFIX_TABLE (PREFIX_VEX_5A) },
7074 { PREFIX_TABLE (PREFIX_VEX_5B) },
7075 { PREFIX_TABLE (PREFIX_VEX_5C) },
7076 { PREFIX_TABLE (PREFIX_VEX_5D) },
7077 { PREFIX_TABLE (PREFIX_VEX_5E) },
7078 { PREFIX_TABLE (PREFIX_VEX_5F) },
7080 { PREFIX_TABLE (PREFIX_VEX_60) },
7081 { PREFIX_TABLE (PREFIX_VEX_61) },
7082 { PREFIX_TABLE (PREFIX_VEX_62) },
7083 { PREFIX_TABLE (PREFIX_VEX_63) },
7084 { PREFIX_TABLE (PREFIX_VEX_64) },
7085 { PREFIX_TABLE (PREFIX_VEX_65) },
7086 { PREFIX_TABLE (PREFIX_VEX_66) },
7087 { PREFIX_TABLE (PREFIX_VEX_67) },
7089 { PREFIX_TABLE (PREFIX_VEX_68) },
7090 { PREFIX_TABLE (PREFIX_VEX_69) },
7091 { PREFIX_TABLE (PREFIX_VEX_6A) },
7092 { PREFIX_TABLE (PREFIX_VEX_6B) },
7093 { PREFIX_TABLE (PREFIX_VEX_6C) },
7094 { PREFIX_TABLE (PREFIX_VEX_6D) },
7095 { PREFIX_TABLE (PREFIX_VEX_6E) },
7096 { PREFIX_TABLE (PREFIX_VEX_6F) },
7098 { PREFIX_TABLE (PREFIX_VEX_70) },
7099 { REG_TABLE (REG_VEX_71) },
7100 { REG_TABLE (REG_VEX_72) },
7101 { REG_TABLE (REG_VEX_73) },
7102 { PREFIX_TABLE (PREFIX_VEX_74) },
7103 { PREFIX_TABLE (PREFIX_VEX_75) },
7104 { PREFIX_TABLE (PREFIX_VEX_76) },
7105 { PREFIX_TABLE (PREFIX_VEX_77) },
7107 { "(bad)", { XX } },
7108 { "(bad)", { XX } },
7109 { "(bad)", { XX } },
7110 { "(bad)", { XX } },
7111 { PREFIX_TABLE (PREFIX_VEX_7C) },
7112 { PREFIX_TABLE (PREFIX_VEX_7D) },
7113 { PREFIX_TABLE (PREFIX_VEX_7E) },
7114 { PREFIX_TABLE (PREFIX_VEX_7F) },
7116 { "(bad)", { XX } },
7117 { "(bad)", { XX } },
7118 { "(bad)", { XX } },
7119 { "(bad)", { XX } },
7120 { "(bad)", { XX } },
7121 { "(bad)", { XX } },
7122 { "(bad)", { XX } },
7123 { "(bad)", { XX } },
7125 { "(bad)", { XX } },
7126 { "(bad)", { XX } },
7127 { "(bad)", { XX } },
7128 { "(bad)", { XX } },
7129 { "(bad)", { XX } },
7130 { "(bad)", { XX } },
7131 { "(bad)", { XX } },
7132 { "(bad)", { XX } },
7134 { "(bad)", { XX } },
7135 { "(bad)", { XX } },
7136 { "(bad)", { XX } },
7137 { "(bad)", { XX } },
7138 { "(bad)", { XX } },
7139 { "(bad)", { XX } },
7140 { "(bad)", { XX } },
7141 { "(bad)", { XX } },
7143 { "(bad)", { XX } },
7144 { "(bad)", { XX } },
7145 { "(bad)", { XX } },
7146 { "(bad)", { XX } },
7147 { "(bad)", { XX } },
7148 { "(bad)", { XX } },
7149 { "(bad)", { XX } },
7150 { "(bad)", { XX } },
7152 { "(bad)", { XX } },
7153 { "(bad)", { XX } },
7154 { "(bad)", { XX } },
7155 { "(bad)", { XX } },
7156 { "(bad)", { XX } },
7157 { "(bad)", { XX } },
7158 { "(bad)", { XX } },
7159 { "(bad)", { XX } },
7161 { "(bad)", { XX } },
7162 { "(bad)", { XX } },
7163 { "(bad)", { XX } },
7164 { "(bad)", { XX } },
7165 { "(bad)", { XX } },
7166 { "(bad)", { XX } },
7167 { REG_TABLE (REG_VEX_AE) },
7168 { "(bad)", { XX } },
7170 { "(bad)", { XX } },
7171 { "(bad)", { XX } },
7172 { "(bad)", { XX } },
7173 { "(bad)", { XX } },
7174 { "(bad)", { XX } },
7175 { "(bad)", { XX } },
7176 { "(bad)", { XX } },
7177 { "(bad)", { XX } },
7179 { "(bad)", { XX } },
7180 { "(bad)", { XX } },
7181 { "(bad)", { XX } },
7182 { "(bad)", { XX } },
7183 { "(bad)", { XX } },
7184 { "(bad)", { XX } },
7185 { "(bad)", { XX } },
7186 { "(bad)", { XX } },
7188 { "(bad)", { XX } },
7189 { "(bad)", { XX } },
7190 { PREFIX_TABLE (PREFIX_VEX_C2) },
7191 { "(bad)", { XX } },
7192 { PREFIX_TABLE (PREFIX_VEX_C4) },
7193 { PREFIX_TABLE (PREFIX_VEX_C5) },
7194 { "vshufpX", { XM, Vex, EXx, Ib } },
7195 { "(bad)", { XX } },
7197 { "(bad)", { XX } },
7198 { "(bad)", { XX } },
7199 { "(bad)", { XX } },
7200 { "(bad)", { XX } },
7201 { "(bad)", { XX } },
7202 { "(bad)", { XX } },
7203 { "(bad)", { XX } },
7204 { "(bad)", { XX } },
7206 { PREFIX_TABLE (PREFIX_VEX_D0) },
7207 { PREFIX_TABLE (PREFIX_VEX_D1) },
7208 { PREFIX_TABLE (PREFIX_VEX_D2) },
7209 { PREFIX_TABLE (PREFIX_VEX_D3) },
7210 { PREFIX_TABLE (PREFIX_VEX_D4) },
7211 { PREFIX_TABLE (PREFIX_VEX_D5) },
7212 { PREFIX_TABLE (PREFIX_VEX_D6) },
7213 { PREFIX_TABLE (PREFIX_VEX_D7) },
7215 { PREFIX_TABLE (PREFIX_VEX_D8) },
7216 { PREFIX_TABLE (PREFIX_VEX_D9) },
7217 { PREFIX_TABLE (PREFIX_VEX_DA) },
7218 { PREFIX_TABLE (PREFIX_VEX_DB) },
7219 { PREFIX_TABLE (PREFIX_VEX_DC) },
7220 { PREFIX_TABLE (PREFIX_VEX_DD) },
7221 { PREFIX_TABLE (PREFIX_VEX_DE) },
7222 { PREFIX_TABLE (PREFIX_VEX_DF) },
7224 { PREFIX_TABLE (PREFIX_VEX_E0) },
7225 { PREFIX_TABLE (PREFIX_VEX_E1) },
7226 { PREFIX_TABLE (PREFIX_VEX_E2) },
7227 { PREFIX_TABLE (PREFIX_VEX_E3) },
7228 { PREFIX_TABLE (PREFIX_VEX_E4) },
7229 { PREFIX_TABLE (PREFIX_VEX_E5) },
7230 { PREFIX_TABLE (PREFIX_VEX_E6) },
7231 { PREFIX_TABLE (PREFIX_VEX_E7) },
7233 { PREFIX_TABLE (PREFIX_VEX_E8) },
7234 { PREFIX_TABLE (PREFIX_VEX_E9) },
7235 { PREFIX_TABLE (PREFIX_VEX_EA) },
7236 { PREFIX_TABLE (PREFIX_VEX_EB) },
7237 { PREFIX_TABLE (PREFIX_VEX_EC) },
7238 { PREFIX_TABLE (PREFIX_VEX_ED) },
7239 { PREFIX_TABLE (PREFIX_VEX_EE) },
7240 { PREFIX_TABLE (PREFIX_VEX_EF) },
7242 { PREFIX_TABLE (PREFIX_VEX_F0) },
7243 { PREFIX_TABLE (PREFIX_VEX_F1) },
7244 { PREFIX_TABLE (PREFIX_VEX_F2) },
7245 { PREFIX_TABLE (PREFIX_VEX_F3) },
7246 { PREFIX_TABLE (PREFIX_VEX_F4) },
7247 { PREFIX_TABLE (PREFIX_VEX_F5) },
7248 { PREFIX_TABLE (PREFIX_VEX_F6) },
7249 { PREFIX_TABLE (PREFIX_VEX_F7) },
7251 { PREFIX_TABLE (PREFIX_VEX_F8) },
7252 { PREFIX_TABLE (PREFIX_VEX_F9) },
7253 { PREFIX_TABLE (PREFIX_VEX_FA) },
7254 { PREFIX_TABLE (PREFIX_VEX_FB) },
7255 { PREFIX_TABLE (PREFIX_VEX_FC) },
7256 { PREFIX_TABLE (PREFIX_VEX_FD) },
7257 { PREFIX_TABLE (PREFIX_VEX_FE) },
7258 { "(bad)", { XX } },
7263 { PREFIX_TABLE (PREFIX_VEX_3800) },
7264 { PREFIX_TABLE (PREFIX_VEX_3801) },
7265 { PREFIX_TABLE (PREFIX_VEX_3802) },
7266 { PREFIX_TABLE (PREFIX_VEX_3803) },
7267 { PREFIX_TABLE (PREFIX_VEX_3804) },
7268 { PREFIX_TABLE (PREFIX_VEX_3805) },
7269 { PREFIX_TABLE (PREFIX_VEX_3806) },
7270 { PREFIX_TABLE (PREFIX_VEX_3807) },
7272 { PREFIX_TABLE (PREFIX_VEX_3808) },
7273 { PREFIX_TABLE (PREFIX_VEX_3809) },
7274 { PREFIX_TABLE (PREFIX_VEX_380A) },
7275 { PREFIX_TABLE (PREFIX_VEX_380B) },
7276 { PREFIX_TABLE (PREFIX_VEX_380C) },
7277 { PREFIX_TABLE (PREFIX_VEX_380D) },
7278 { PREFIX_TABLE (PREFIX_VEX_380E) },
7279 { PREFIX_TABLE (PREFIX_VEX_380F) },
7281 { "(bad)", { XX } },
7282 { "(bad)", { XX } },
7283 { "(bad)", { XX } },
7284 { "(bad)", { XX } },
7285 { "(bad)", { XX } },
7286 { "(bad)", { XX } },
7287 { "(bad)", { XX } },
7288 { PREFIX_TABLE (PREFIX_VEX_3817) },
7290 { PREFIX_TABLE (PREFIX_VEX_3818) },
7291 { PREFIX_TABLE (PREFIX_VEX_3819) },
7292 { PREFIX_TABLE (PREFIX_VEX_381A) },
7293 { "(bad)", { XX } },
7294 { PREFIX_TABLE (PREFIX_VEX_381C) },
7295 { PREFIX_TABLE (PREFIX_VEX_381D) },
7296 { PREFIX_TABLE (PREFIX_VEX_381E) },
7297 { "(bad)", { XX } },
7299 { PREFIX_TABLE (PREFIX_VEX_3820) },
7300 { PREFIX_TABLE (PREFIX_VEX_3821) },
7301 { PREFIX_TABLE (PREFIX_VEX_3822) },
7302 { PREFIX_TABLE (PREFIX_VEX_3823) },
7303 { PREFIX_TABLE (PREFIX_VEX_3824) },
7304 { PREFIX_TABLE (PREFIX_VEX_3825) },
7305 { "(bad)", { XX } },
7306 { "(bad)", { XX } },
7308 { PREFIX_TABLE (PREFIX_VEX_3828) },
7309 { PREFIX_TABLE (PREFIX_VEX_3829) },
7310 { PREFIX_TABLE (PREFIX_VEX_382A) },
7311 { PREFIX_TABLE (PREFIX_VEX_382B) },
7312 { PREFIX_TABLE (PREFIX_VEX_382C) },
7313 { PREFIX_TABLE (PREFIX_VEX_382D) },
7314 { PREFIX_TABLE (PREFIX_VEX_382E) },
7315 { PREFIX_TABLE (PREFIX_VEX_382F) },
7317 { PREFIX_TABLE (PREFIX_VEX_3830) },
7318 { PREFIX_TABLE (PREFIX_VEX_3831) },
7319 { PREFIX_TABLE (PREFIX_VEX_3832) },
7320 { PREFIX_TABLE (PREFIX_VEX_3833) },
7321 { PREFIX_TABLE (PREFIX_VEX_3834) },
7322 { PREFIX_TABLE (PREFIX_VEX_3835) },
7323 { "(bad)", { XX } },
7324 { PREFIX_TABLE (PREFIX_VEX_3837) },
7326 { PREFIX_TABLE (PREFIX_VEX_3838) },
7327 { PREFIX_TABLE (PREFIX_VEX_3839) },
7328 { PREFIX_TABLE (PREFIX_VEX_383A) },
7329 { PREFIX_TABLE (PREFIX_VEX_383B) },
7330 { PREFIX_TABLE (PREFIX_VEX_383C) },
7331 { PREFIX_TABLE (PREFIX_VEX_383D) },
7332 { PREFIX_TABLE (PREFIX_VEX_383E) },
7333 { PREFIX_TABLE (PREFIX_VEX_383F) },
7335 { PREFIX_TABLE (PREFIX_VEX_3840) },
7336 { PREFIX_TABLE (PREFIX_VEX_3841) },
7337 { "(bad)", { XX } },
7338 { "(bad)", { XX } },
7339 { "(bad)", { XX } },
7340 { "(bad)", { XX } },
7341 { "(bad)", { XX } },
7342 { "(bad)", { XX } },
7344 { "(bad)", { XX } },
7345 { "(bad)", { XX } },
7346 { "(bad)", { XX } },
7347 { "(bad)", { XX } },
7348 { "(bad)", { XX } },
7349 { "(bad)", { XX } },
7350 { "(bad)", { XX } },
7351 { "(bad)", { XX } },
7353 { "(bad)", { XX } },
7354 { "(bad)", { XX } },
7355 { "(bad)", { XX } },
7356 { "(bad)", { XX } },
7357 { "(bad)", { XX } },
7358 { "(bad)", { XX } },
7359 { "(bad)", { XX } },
7360 { "(bad)", { XX } },
7362 { "(bad)", { XX } },
7363 { "(bad)", { XX } },
7364 { "(bad)", { XX } },
7365 { "(bad)", { XX } },
7366 { "(bad)", { XX } },
7367 { "(bad)", { XX } },
7368 { "(bad)", { XX } },
7369 { "(bad)", { XX } },
7371 { "(bad)", { XX } },
7372 { "(bad)", { XX } },
7373 { "(bad)", { XX } },
7374 { "(bad)", { XX } },
7375 { "(bad)", { XX } },
7376 { "(bad)", { XX } },
7377 { "(bad)", { XX } },
7378 { "(bad)", { XX } },
7380 { "(bad)", { XX } },
7381 { "(bad)", { XX } },
7382 { "(bad)", { XX } },
7383 { "(bad)", { XX } },
7384 { "(bad)", { XX } },
7385 { "(bad)", { XX } },
7386 { "(bad)", { XX } },
7387 { "(bad)", { XX } },
7389 { "(bad)", { XX } },
7390 { "(bad)", { XX } },
7391 { "(bad)", { XX } },
7392 { "(bad)", { XX } },
7393 { "(bad)", { XX } },
7394 { "(bad)", { XX } },
7395 { "(bad)", { XX } },
7396 { "(bad)", { XX } },
7398 { "(bad)", { XX } },
7399 { "(bad)", { XX } },
7400 { "(bad)", { XX } },
7401 { "(bad)", { XX } },
7402 { "(bad)", { XX } },
7403 { "(bad)", { XX } },
7404 { "(bad)", { XX } },
7405 { "(bad)", { XX } },
7407 { "(bad)", { XX } },
7408 { "(bad)", { XX } },
7409 { "(bad)", { XX } },
7410 { "(bad)", { XX } },
7411 { "(bad)", { XX } },
7412 { "(bad)", { XX } },
7413 { "(bad)", { XX } },
7414 { "(bad)", { XX } },
7416 { "(bad)", { XX } },
7417 { "(bad)", { XX } },
7418 { "(bad)", { XX } },
7419 { "(bad)", { XX } },
7420 { "(bad)", { XX } },
7421 { "(bad)", { XX } },
7422 { "(bad)", { XX } },
7423 { "(bad)", { XX } },
7425 { "(bad)", { XX } },
7426 { "(bad)", { XX } },
7427 { "(bad)", { XX } },
7428 { "(bad)", { XX } },
7429 { "(bad)", { XX } },
7430 { "(bad)", { XX } },
7431 { PREFIX_TABLE (PREFIX_VEX_3896) },
7432 { PREFIX_TABLE (PREFIX_VEX_3897) },
7434 { PREFIX_TABLE (PREFIX_VEX_3898) },
7435 { PREFIX_TABLE (PREFIX_VEX_3899) },
7436 { PREFIX_TABLE (PREFIX_VEX_389A) },
7437 { PREFIX_TABLE (PREFIX_VEX_389B) },
7438 { PREFIX_TABLE (PREFIX_VEX_389C) },
7439 { PREFIX_TABLE (PREFIX_VEX_389D) },
7440 { PREFIX_TABLE (PREFIX_VEX_389E) },
7441 { PREFIX_TABLE (PREFIX_VEX_389F) },
7443 { "(bad)", { XX } },
7444 { "(bad)", { XX } },
7445 { "(bad)", { XX } },
7446 { "(bad)", { XX } },
7447 { "(bad)", { XX } },
7448 { "(bad)", { XX } },
7449 { PREFIX_TABLE (PREFIX_VEX_38A6) },
7450 { PREFIX_TABLE (PREFIX_VEX_38A7) },
7452 { PREFIX_TABLE (PREFIX_VEX_38A8) },
7453 { PREFIX_TABLE (PREFIX_VEX_38A9) },
7454 { PREFIX_TABLE (PREFIX_VEX_38AA) },
7455 { PREFIX_TABLE (PREFIX_VEX_38AB) },
7456 { PREFIX_TABLE (PREFIX_VEX_38AC) },
7457 { PREFIX_TABLE (PREFIX_VEX_38AD) },
7458 { PREFIX_TABLE (PREFIX_VEX_38AE) },
7459 { PREFIX_TABLE (PREFIX_VEX_38AF) },
7461 { "(bad)", { XX } },
7462 { "(bad)", { XX } },
7463 { "(bad)", { XX } },
7464 { "(bad)", { XX } },
7465 { "(bad)", { XX } },
7466 { "(bad)", { XX } },
7467 { PREFIX_TABLE (PREFIX_VEX_38B6) },
7468 { PREFIX_TABLE (PREFIX_VEX_38B7) },
7470 { PREFIX_TABLE (PREFIX_VEX_38B8) },
7471 { PREFIX_TABLE (PREFIX_VEX_38B9) },
7472 { PREFIX_TABLE (PREFIX_VEX_38BA) },
7473 { PREFIX_TABLE (PREFIX_VEX_38BB) },
7474 { PREFIX_TABLE (PREFIX_VEX_38BC) },
7475 { PREFIX_TABLE (PREFIX_VEX_38BD) },
7476 { PREFIX_TABLE (PREFIX_VEX_38BE) },
7477 { PREFIX_TABLE (PREFIX_VEX_38BF) },
7479 { "(bad)", { XX } },
7480 { "(bad)", { XX } },
7481 { "(bad)", { XX } },
7482 { "(bad)", { XX } },
7483 { "(bad)", { XX } },
7484 { "(bad)", { XX } },
7485 { "(bad)", { XX } },
7486 { "(bad)", { XX } },
7488 { "(bad)", { XX } },
7489 { "(bad)", { XX } },
7490 { "(bad)", { XX } },
7491 { "(bad)", { XX } },
7492 { "(bad)", { XX } },
7493 { "(bad)", { XX } },
7494 { "(bad)", { XX } },
7495 { "(bad)", { XX } },
7497 { "(bad)", { XX } },
7498 { "(bad)", { XX } },
7499 { "(bad)", { XX } },
7500 { "(bad)", { XX } },
7501 { "(bad)", { XX } },
7502 { "(bad)", { XX } },
7503 { "(bad)", { XX } },
7504 { "(bad)", { XX } },
7506 { "(bad)", { XX } },
7507 { "(bad)", { XX } },
7508 { "(bad)", { XX } },
7509 { PREFIX_TABLE (PREFIX_VEX_38DB) },
7510 { PREFIX_TABLE (PREFIX_VEX_38DC) },
7511 { PREFIX_TABLE (PREFIX_VEX_38DD) },
7512 { PREFIX_TABLE (PREFIX_VEX_38DE) },
7513 { PREFIX_TABLE (PREFIX_VEX_38DF) },
7515 { "(bad)", { XX } },
7516 { "(bad)", { XX } },
7517 { "(bad)", { XX } },
7518 { "(bad)", { XX } },
7519 { "(bad)", { XX } },
7520 { "(bad)", { XX } },
7521 { "(bad)", { XX } },
7522 { "(bad)", { XX } },
7524 { "(bad)", { XX } },
7525 { "(bad)", { XX } },
7526 { "(bad)", { XX } },
7527 { "(bad)", { XX } },
7528 { "(bad)", { XX } },
7529 { "(bad)", { XX } },
7530 { "(bad)", { XX } },
7531 { "(bad)", { XX } },
7533 { "(bad)", { XX } },
7534 { "(bad)", { XX } },
7535 { "(bad)", { XX } },
7536 { "(bad)", { XX } },
7537 { "(bad)", { XX } },
7538 { "(bad)", { XX } },
7539 { "(bad)", { XX } },
7540 { "(bad)", { XX } },
7542 { "(bad)", { XX } },
7543 { "(bad)", { XX } },
7544 { "(bad)", { XX } },
7545 { "(bad)", { XX } },
7546 { "(bad)", { XX } },
7547 { "(bad)", { XX } },
7548 { "(bad)", { XX } },
7549 { "(bad)", { XX } },
7554 { "(bad)", { XX } },
7555 { "(bad)", { XX } },
7556 { "(bad)", { XX } },
7557 { "(bad)", { XX } },
7558 { PREFIX_TABLE (PREFIX_VEX_3A04) },
7559 { PREFIX_TABLE (PREFIX_VEX_3A05) },
7560 { PREFIX_TABLE (PREFIX_VEX_3A06) },
7561 { "(bad)", { XX } },
7563 { PREFIX_TABLE (PREFIX_VEX_3A08) },
7564 { PREFIX_TABLE (PREFIX_VEX_3A09) },
7565 { PREFIX_TABLE (PREFIX_VEX_3A0A) },
7566 { PREFIX_TABLE (PREFIX_VEX_3A0B) },
7567 { PREFIX_TABLE (PREFIX_VEX_3A0C) },
7568 { PREFIX_TABLE (PREFIX_VEX_3A0D) },
7569 { PREFIX_TABLE (PREFIX_VEX_3A0E) },
7570 { PREFIX_TABLE (PREFIX_VEX_3A0F) },
7572 { "(bad)", { XX } },
7573 { "(bad)", { XX } },
7574 { "(bad)", { XX } },
7575 { "(bad)", { XX } },
7576 { PREFIX_TABLE (PREFIX_VEX_3A14) },
7577 { PREFIX_TABLE (PREFIX_VEX_3A15) },
7578 { PREFIX_TABLE (PREFIX_VEX_3A16) },
7579 { PREFIX_TABLE (PREFIX_VEX_3A17) },
7581 { PREFIX_TABLE (PREFIX_VEX_3A18) },
7582 { PREFIX_TABLE (PREFIX_VEX_3A19) },
7583 { "(bad)", { XX } },
7584 { "(bad)", { XX } },
7585 { "(bad)", { XX } },
7586 { "(bad)", { XX } },
7587 { "(bad)", { XX } },
7588 { "(bad)", { XX } },
7590 { PREFIX_TABLE (PREFIX_VEX_3A20) },
7591 { PREFIX_TABLE (PREFIX_VEX_3A21) },
7592 { PREFIX_TABLE (PREFIX_VEX_3A22) },
7593 { "(bad)", { XX } },
7594 { "(bad)", { XX } },
7595 { "(bad)", { XX } },
7596 { "(bad)", { XX } },
7597 { "(bad)", { XX } },
7599 { "(bad)", { XX } },
7600 { "(bad)", { XX } },
7601 { "(bad)", { XX } },
7602 { "(bad)", { XX } },
7603 { "(bad)", { XX } },
7604 { "(bad)", { XX } },
7605 { "(bad)", { XX } },
7606 { "(bad)", { XX } },
7608 { "(bad)", { XX } },
7609 { "(bad)", { XX } },
7610 { "(bad)", { XX } },
7611 { "(bad)", { XX } },
7612 { "(bad)", { XX } },
7613 { "(bad)", { XX } },
7614 { "(bad)", { XX } },
7615 { "(bad)", { XX } },
7617 { "(bad)", { XX } },
7618 { "(bad)", { XX } },
7619 { "(bad)", { XX } },
7620 { "(bad)", { XX } },
7621 { "(bad)", { XX } },
7622 { "(bad)", { XX } },
7623 { "(bad)", { XX } },
7624 { "(bad)", { XX } },
7626 { PREFIX_TABLE (PREFIX_VEX_3A40) },
7627 { PREFIX_TABLE (PREFIX_VEX_3A41) },
7628 { PREFIX_TABLE (PREFIX_VEX_3A42) },
7629 { "(bad)", { XX } },
7630 { PREFIX_TABLE (PREFIX_VEX_3A44) },
7631 { "(bad)", { XX } },
7632 { "(bad)", { XX } },
7633 { "(bad)", { XX } },
7635 { "(bad)", { XX } },
7636 { "(bad)", { XX } },
7637 { PREFIX_TABLE (PREFIX_VEX_3A4A) },
7638 { PREFIX_TABLE (PREFIX_VEX_3A4B) },
7639 { PREFIX_TABLE (PREFIX_VEX_3A4C) },
7640 { "(bad)", { XX } },
7641 { "(bad)", { XX } },
7642 { "(bad)", { XX } },
7644 { "(bad)", { XX } },
7645 { "(bad)", { XX } },
7646 { "(bad)", { XX } },
7647 { "(bad)", { XX } },
7648 { "(bad)", { XX } },
7649 { "(bad)", { XX } },
7650 { "(bad)", { XX } },
7651 { "(bad)", { XX } },
7653 { "(bad)", { XX } },
7654 { "(bad)", { XX } },
7655 { "(bad)", { XX } },
7656 { "(bad)", { XX } },
7657 { PREFIX_TABLE (PREFIX_VEX_3A5C) },
7658 { PREFIX_TABLE (PREFIX_VEX_3A5D) },
7659 { PREFIX_TABLE (PREFIX_VEX_3A5E) },
7660 { PREFIX_TABLE (PREFIX_VEX_3A5F) },
7662 { PREFIX_TABLE (PREFIX_VEX_3A60) },
7663 { PREFIX_TABLE (PREFIX_VEX_3A61) },
7664 { PREFIX_TABLE (PREFIX_VEX_3A62) },
7665 { PREFIX_TABLE (PREFIX_VEX_3A63) },
7666 { "(bad)", { XX } },
7667 { "(bad)", { XX } },
7668 { "(bad)", { XX } },
7669 { "(bad)", { XX } },
7671 { PREFIX_TABLE (PREFIX_VEX_3A68) },
7672 { PREFIX_TABLE (PREFIX_VEX_3A69) },
7673 { PREFIX_TABLE (PREFIX_VEX_3A6A) },
7674 { PREFIX_TABLE (PREFIX_VEX_3A6B) },
7675 { PREFIX_TABLE (PREFIX_VEX_3A6C) },
7676 { PREFIX_TABLE (PREFIX_VEX_3A6D) },
7677 { PREFIX_TABLE (PREFIX_VEX_3A6E) },
7678 { PREFIX_TABLE (PREFIX_VEX_3A6F) },
7680 { "(bad)", { XX } },
7681 { "(bad)", { XX } },
7682 { "(bad)", { XX } },
7683 { "(bad)", { XX } },
7684 { "(bad)", { XX } },
7685 { "(bad)", { XX } },
7686 { "(bad)", { XX } },
7687 { "(bad)", { XX } },
7689 { PREFIX_TABLE (PREFIX_VEX_3A78) },
7690 { PREFIX_TABLE (PREFIX_VEX_3A79) },
7691 { PREFIX_TABLE (PREFIX_VEX_3A7A) },
7692 { PREFIX_TABLE (PREFIX_VEX_3A7B) },
7693 { PREFIX_TABLE (PREFIX_VEX_3A7C) },
7694 { PREFIX_TABLE (PREFIX_VEX_3A7D) },
7695 { PREFIX_TABLE (PREFIX_VEX_3A7E) },
7696 { PREFIX_TABLE (PREFIX_VEX_3A7F) },
7698 { "(bad)", { XX } },
7699 { "(bad)", { XX } },
7700 { "(bad)", { XX } },
7701 { "(bad)", { XX } },
7702 { "(bad)", { XX } },
7703 { "(bad)", { XX } },
7704 { "(bad)", { XX } },
7705 { "(bad)", { XX } },
7707 { "(bad)", { XX } },
7708 { "(bad)", { XX } },
7709 { "(bad)", { XX } },
7710 { "(bad)", { XX } },
7711 { "(bad)", { XX } },
7712 { "(bad)", { XX } },
7713 { "(bad)", { XX } },
7714 { "(bad)", { XX } },
7716 { "(bad)", { XX } },
7717 { "(bad)", { XX } },
7718 { "(bad)", { XX } },
7719 { "(bad)", { XX } },
7720 { "(bad)", { XX } },
7721 { "(bad)", { XX } },
7722 { "(bad)", { XX } },
7723 { "(bad)", { XX } },
7725 { "(bad)", { XX } },
7726 { "(bad)", { XX } },
7727 { "(bad)", { XX } },
7728 { "(bad)", { XX } },
7729 { "(bad)", { XX } },
7730 { "(bad)", { XX } },
7731 { "(bad)", { XX } },
7732 { "(bad)", { XX } },
7734 { "(bad)", { XX } },
7735 { "(bad)", { XX } },
7736 { "(bad)", { XX } },
7737 { "(bad)", { XX } },
7738 { "(bad)", { XX } },
7739 { "(bad)", { XX } },
7740 { "(bad)", { XX } },
7741 { "(bad)", { XX } },
7743 { "(bad)", { XX } },
7744 { "(bad)", { XX } },
7745 { "(bad)", { XX } },
7746 { "(bad)", { XX } },
7747 { "(bad)", { XX } },
7748 { "(bad)", { XX } },
7749 { "(bad)", { XX } },
7750 { "(bad)", { XX } },
7752 { "(bad)", { XX } },
7753 { "(bad)", { XX } },
7754 { "(bad)", { XX } },
7755 { "(bad)", { XX } },
7756 { "(bad)", { XX } },
7757 { "(bad)", { XX } },
7758 { "(bad)", { XX } },
7759 { "(bad)", { XX } },
7761 { "(bad)", { XX } },
7762 { "(bad)", { XX } },
7763 { "(bad)", { XX } },
7764 { "(bad)", { XX } },
7765 { "(bad)", { XX } },
7766 { "(bad)", { XX } },
7767 { "(bad)", { XX } },
7768 { "(bad)", { XX } },
7770 { "(bad)", { XX } },
7771 { "(bad)", { XX } },
7772 { "(bad)", { XX } },
7773 { "(bad)", { XX } },
7774 { "(bad)", { XX } },
7775 { "(bad)", { XX } },
7776 { "(bad)", { XX } },
7777 { "(bad)", { XX } },
7779 { "(bad)", { XX } },
7780 { "(bad)", { XX } },
7781 { "(bad)", { XX } },
7782 { "(bad)", { XX } },
7783 { "(bad)", { XX } },
7784 { "(bad)", { XX } },
7785 { "(bad)", { XX } },
7786 { "(bad)", { XX } },
7788 { "(bad)", { XX } },
7789 { "(bad)", { XX } },
7790 { "(bad)", { XX } },
7791 { "(bad)", { XX } },
7792 { "(bad)", { XX } },
7793 { "(bad)", { XX } },
7794 { "(bad)", { XX } },
7795 { "(bad)", { XX } },
7797 { "(bad)", { XX } },
7798 { "(bad)", { XX } },
7799 { "(bad)", { XX } },
7800 { "(bad)", { XX } },
7801 { "(bad)", { XX } },
7802 { "(bad)", { XX } },
7803 { "(bad)", { XX } },
7804 { PREFIX_TABLE (PREFIX_VEX_3ADF) },
7806 { "(bad)", { XX } },
7807 { "(bad)", { XX } },
7808 { "(bad)", { XX } },
7809 { "(bad)", { XX } },
7810 { "(bad)", { XX } },
7811 { "(bad)", { XX } },
7812 { "(bad)", { XX } },
7813 { "(bad)", { XX } },
7815 { "(bad)", { XX } },
7816 { "(bad)", { XX } },
7817 { "(bad)", { XX } },
7818 { "(bad)", { XX } },
7819 { "(bad)", { XX } },
7820 { "(bad)", { XX } },
7821 { "(bad)", { XX } },
7822 { "(bad)", { XX } },
7824 { "(bad)", { XX } },
7825 { "(bad)", { XX } },
7826 { "(bad)", { XX } },
7827 { "(bad)", { XX } },
7828 { "(bad)", { XX } },
7829 { "(bad)", { XX } },
7830 { "(bad)", { XX } },
7831 { "(bad)", { XX } },
7833 { "(bad)", { XX } },
7834 { "(bad)", { XX } },
7835 { "(bad)", { XX } },
7836 { "(bad)", { XX } },
7837 { "(bad)", { XX } },
7838 { "(bad)", { XX } },
7839 { "(bad)", { XX } },
7840 { "(bad)", { XX } },
7844 static const struct dis386 vex_len_table[][2] = {
7845 /* VEX_LEN_10_P_1 */
7847 { "vmovss", { XMVex, Vex128, EXd } },
7848 { "(bad)", { XX } },
7851 /* VEX_LEN_10_P_3 */
7853 { "vmovsd", { XMVex, Vex128, EXq } },
7854 { "(bad)", { XX } },
7857 /* VEX_LEN_11_P_1 */
7859 { "vmovss", { EXdVexS, Vex128, XM } },
7860 { "(bad)", { XX } },
7863 /* VEX_LEN_11_P_3 */
7865 { "vmovsd", { EXqVexS, Vex128, XM } },
7866 { "(bad)", { XX } },
7869 /* VEX_LEN_12_P_0_M_0 */
7871 { "vmovlps", { XM, Vex128, EXq } },
7872 { "(bad)", { XX } },
7875 /* VEX_LEN_12_P_0_M_1 */
7877 { "vmovhlps", { XM, Vex128, EXq } },
7878 { "(bad)", { XX } },
7881 /* VEX_LEN_12_P_2 */
7883 { "vmovlpd", { XM, Vex128, EXq } },
7884 { "(bad)", { XX } },
7887 /* VEX_LEN_13_M_0 */
7889 { "vmovlpX", { EXq, XM } },
7890 { "(bad)", { XX } },
7893 /* VEX_LEN_16_P_0_M_0 */
7895 { "vmovhps", { XM, Vex128, EXq } },
7896 { "(bad)", { XX } },
7899 /* VEX_LEN_16_P_0_M_1 */
7901 { "vmovlhps", { XM, Vex128, EXq } },
7902 { "(bad)", { XX } },
7905 /* VEX_LEN_16_P_2 */
7907 { "vmovhpd", { XM, Vex128, EXq } },
7908 { "(bad)", { XX } },
7911 /* VEX_LEN_17_M_0 */
7913 { "vmovhpX", { EXq, XM } },
7914 { "(bad)", { XX } },
7917 /* VEX_LEN_2A_P_1 */
7919 { "vcvtsi2ss%LQ", { XM, Vex128, Ev } },
7920 { "(bad)", { XX } },
7923 /* VEX_LEN_2A_P_3 */
7925 { "vcvtsi2sd%LQ", { XM, Vex128, Ev } },
7926 { "(bad)", { XX } },
7929 /* VEX_LEN_2C_P_1 */
7931 { "vcvttss2siY", { Gv, EXd } },
7932 { "(bad)", { XX } },
7935 /* VEX_LEN_2C_P_3 */
7937 { "vcvttsd2siY", { Gv, EXq } },
7938 { "(bad)", { XX } },
7941 /* VEX_LEN_2D_P_1 */
7943 { "vcvtss2siY", { Gv, EXd } },
7944 { "(bad)", { XX } },
7947 /* VEX_LEN_2D_P_3 */
7949 { "vcvtsd2siY", { Gv, EXq } },
7950 { "(bad)", { XX } },
7953 /* VEX_LEN_2E_P_0 */
7955 { "vucomiss", { XM, EXd } },
7956 { "(bad)", { XX } },
7959 /* VEX_LEN_2E_P_2 */
7961 { "vucomisd", { XM, EXq } },
7962 { "(bad)", { XX } },
7965 /* VEX_LEN_2F_P_0 */
7967 { "vcomiss", { XM, EXd } },
7968 { "(bad)", { XX } },
7971 /* VEX_LEN_2F_P_2 */
7973 { "vcomisd", { XM, EXq } },
7974 { "(bad)", { XX } },
7977 /* VEX_LEN_51_P_1 */
7979 { "vsqrtss", { XM, Vex128, EXd } },
7980 { "(bad)", { XX } },
7983 /* VEX_LEN_51_P_3 */
7985 { "vsqrtsd", { XM, Vex128, EXq } },
7986 { "(bad)", { XX } },
7989 /* VEX_LEN_52_P_1 */
7991 { "vrsqrtss", { XM, Vex128, EXd } },
7992 { "(bad)", { XX } },
7995 /* VEX_LEN_53_P_1 */
7997 { "vrcpss", { XM, Vex128, EXd } },
7998 { "(bad)", { XX } },
8001 /* VEX_LEN_58_P_1 */
8003 { "vaddss", { XM, Vex128, EXd } },
8004 { "(bad)", { XX } },
8007 /* VEX_LEN_58_P_3 */
8009 { "vaddsd", { XM, Vex128, EXq } },
8010 { "(bad)", { XX } },
8013 /* VEX_LEN_59_P_1 */
8015 { "vmulss", { XM, Vex128, EXd } },
8016 { "(bad)", { XX } },
8019 /* VEX_LEN_59_P_3 */
8021 { "vmulsd", { XM, Vex128, EXq } },
8022 { "(bad)", { XX } },
8025 /* VEX_LEN_5A_P_1 */
8027 { "vcvtss2sd", { XM, Vex128, EXd } },
8028 { "(bad)", { XX } },
8031 /* VEX_LEN_5A_P_3 */
8033 { "vcvtsd2ss", { XM, Vex128, EXq } },
8034 { "(bad)", { XX } },
8037 /* VEX_LEN_5C_P_1 */
8039 { "vsubss", { XM, Vex128, EXd } },
8040 { "(bad)", { XX } },
8043 /* VEX_LEN_5C_P_3 */
8045 { "vsubsd", { XM, Vex128, EXq } },
8046 { "(bad)", { XX } },
8049 /* VEX_LEN_5D_P_1 */
8051 { "vminss", { XM, Vex128, EXd } },
8052 { "(bad)", { XX } },
8055 /* VEX_LEN_5D_P_3 */
8057 { "vminsd", { XM, Vex128, EXq } },
8058 { "(bad)", { XX } },
8061 /* VEX_LEN_5E_P_1 */
8063 { "vdivss", { XM, Vex128, EXd } },
8064 { "(bad)", { XX } },
8067 /* VEX_LEN_5E_P_3 */
8069 { "vdivsd", { XM, Vex128, EXq } },
8070 { "(bad)", { XX } },
8073 /* VEX_LEN_5F_P_1 */
8075 { "vmaxss", { XM, Vex128, EXd } },
8076 { "(bad)", { XX } },
8079 /* VEX_LEN_5F_P_3 */
8081 { "vmaxsd", { XM, Vex128, EXq } },
8082 { "(bad)", { XX } },
8085 /* VEX_LEN_60_P_2 */
8087 { "vpunpcklbw", { XM, Vex128, EXx } },
8088 { "(bad)", { XX } },
8091 /* VEX_LEN_61_P_2 */
8093 { "vpunpcklwd", { XM, Vex128, EXx } },
8094 { "(bad)", { XX } },
8097 /* VEX_LEN_62_P_2 */
8099 { "vpunpckldq", { XM, Vex128, EXx } },
8100 { "(bad)", { XX } },
8103 /* VEX_LEN_63_P_2 */
8105 { "vpacksswb", { XM, Vex128, EXx } },
8106 { "(bad)", { XX } },
8109 /* VEX_LEN_64_P_2 */
8111 { "vpcmpgtb", { XM, Vex128, EXx } },
8112 { "(bad)", { XX } },
8115 /* VEX_LEN_65_P_2 */
8117 { "vpcmpgtw", { XM, Vex128, EXx } },
8118 { "(bad)", { XX } },
8121 /* VEX_LEN_66_P_2 */
8123 { "vpcmpgtd", { XM, Vex128, EXx } },
8124 { "(bad)", { XX } },
8127 /* VEX_LEN_67_P_2 */
8129 { "vpackuswb", { XM, Vex128, EXx } },
8130 { "(bad)", { XX } },
8133 /* VEX_LEN_68_P_2 */
8135 { "vpunpckhbw", { XM, Vex128, EXx } },
8136 { "(bad)", { XX } },
8139 /* VEX_LEN_69_P_2 */
8141 { "vpunpckhwd", { XM, Vex128, EXx } },
8142 { "(bad)", { XX } },
8145 /* VEX_LEN_6A_P_2 */
8147 { "vpunpckhdq", { XM, Vex128, EXx } },
8148 { "(bad)", { XX } },
8151 /* VEX_LEN_6B_P_2 */
8153 { "vpackssdw", { XM, Vex128, EXx } },
8154 { "(bad)", { XX } },
8157 /* VEX_LEN_6C_P_2 */
8159 { "vpunpcklqdq", { XM, Vex128, EXx } },
8160 { "(bad)", { XX } },
8163 /* VEX_LEN_6D_P_2 */
8165 { "vpunpckhqdq", { XM, Vex128, EXx } },
8166 { "(bad)", { XX } },
8169 /* VEX_LEN_6E_P_2 */
8171 { "vmovK", { XM, Edq } },
8172 { "(bad)", { XX } },
8175 /* VEX_LEN_70_P_1 */
8177 { "vpshufhw", { XM, EXx, Ib } },
8178 { "(bad)", { XX } },
8181 /* VEX_LEN_70_P_2 */
8183 { "vpshufd", { XM, EXx, Ib } },
8184 { "(bad)", { XX } },
8187 /* VEX_LEN_70_P_3 */
8189 { "vpshuflw", { XM, EXx, Ib } },
8190 { "(bad)", { XX } },
8193 /* VEX_LEN_71_R_2_P_2 */
8195 { "vpsrlw", { Vex128, XS, Ib } },
8196 { "(bad)", { XX } },
8199 /* VEX_LEN_71_R_4_P_2 */
8201 { "vpsraw", { Vex128, XS, Ib } },
8202 { "(bad)", { XX } },
8205 /* VEX_LEN_71_R_6_P_2 */
8207 { "vpsllw", { Vex128, XS, Ib } },
8208 { "(bad)", { XX } },
8211 /* VEX_LEN_72_R_2_P_2 */
8213 { "vpsrld", { Vex128, XS, Ib } },
8214 { "(bad)", { XX } },
8217 /* VEX_LEN_72_R_4_P_2 */
8219 { "vpsrad", { Vex128, XS, Ib } },
8220 { "(bad)", { XX } },
8223 /* VEX_LEN_72_R_6_P_2 */
8225 { "vpslld", { Vex128, XS, Ib } },
8226 { "(bad)", { XX } },
8229 /* VEX_LEN_73_R_2_P_2 */
8231 { "vpsrlq", { Vex128, XS, Ib } },
8232 { "(bad)", { XX } },
8235 /* VEX_LEN_73_R_3_P_2 */
8237 { "vpsrldq", { Vex128, XS, Ib } },
8238 { "(bad)", { XX } },
8241 /* VEX_LEN_73_R_6_P_2 */
8243 { "vpsllq", { Vex128, XS, Ib } },
8244 { "(bad)", { XX } },
8247 /* VEX_LEN_73_R_7_P_2 */
8249 { "vpslldq", { Vex128, XS, Ib } },
8250 { "(bad)", { XX } },
8253 /* VEX_LEN_74_P_2 */
8255 { "vpcmpeqb", { XM, Vex128, EXx } },
8256 { "(bad)", { XX } },
8259 /* VEX_LEN_75_P_2 */
8261 { "vpcmpeqw", { XM, Vex128, EXx } },
8262 { "(bad)", { XX } },
8265 /* VEX_LEN_76_P_2 */
8267 { "vpcmpeqd", { XM, Vex128, EXx } },
8268 { "(bad)", { XX } },
8271 /* VEX_LEN_7E_P_1 */
8273 { "vmovq", { XM, EXq } },
8274 { "(bad)", { XX } },
8277 /* VEX_LEN_7E_P_2 */
8279 { "vmovK", { Edq, XM } },
8280 { "(bad)", { XX } },
8283 /* VEX_LEN_AE_R_2_M_0 */
8285 { "vldmxcsr", { Md } },
8286 { "(bad)", { XX } },
8289 /* VEX_LEN_AE_R_3_M_0 */
8291 { "vstmxcsr", { Md } },
8292 { "(bad)", { XX } },
8295 /* VEX_LEN_C2_P_1 */
8297 { "vcmpss", { XM, Vex128, EXd, VCMP } },
8298 { "(bad)", { XX } },
8301 /* VEX_LEN_C2_P_3 */
8303 { "vcmpsd", { XM, Vex128, EXq, VCMP } },
8304 { "(bad)", { XX } },
8307 /* VEX_LEN_C4_P_2 */
8309 { "vpinsrw", { XM, Vex128, Edqw, Ib } },
8310 { "(bad)", { XX } },
8313 /* VEX_LEN_C5_P_2 */
8315 { "vpextrw", { Gdq, XS, Ib } },
8316 { "(bad)", { XX } },
8319 /* VEX_LEN_D1_P_2 */
8321 { "vpsrlw", { XM, Vex128, EXx } },
8322 { "(bad)", { XX } },
8325 /* VEX_LEN_D2_P_2 */
8327 { "vpsrld", { XM, Vex128, EXx } },
8328 { "(bad)", { XX } },
8331 /* VEX_LEN_D3_P_2 */
8333 { "vpsrlq", { XM, Vex128, EXx } },
8334 { "(bad)", { XX } },
8337 /* VEX_LEN_D4_P_2 */
8339 { "vpaddq", { XM, Vex128, EXx } },
8340 { "(bad)", { XX } },
8343 /* VEX_LEN_D5_P_2 */
8345 { "vpmullw", { XM, Vex128, EXx } },
8346 { "(bad)", { XX } },
8349 /* VEX_LEN_D6_P_2 */
8351 { "vmovq", { EXqS, XM } },
8352 { "(bad)", { XX } },
8355 /* VEX_LEN_D7_P_2_M_1 */
8357 { "vpmovmskb", { Gdq, XS } },
8358 { "(bad)", { XX } },
8361 /* VEX_LEN_D8_P_2 */
8363 { "vpsubusb", { XM, Vex128, EXx } },
8364 { "(bad)", { XX } },
8367 /* VEX_LEN_D9_P_2 */
8369 { "vpsubusw", { XM, Vex128, EXx } },
8370 { "(bad)", { XX } },
8373 /* VEX_LEN_DA_P_2 */
8375 { "vpminub", { XM, Vex128, EXx } },
8376 { "(bad)", { XX } },
8379 /* VEX_LEN_DB_P_2 */
8381 { "vpand", { XM, Vex128, EXx } },
8382 { "(bad)", { XX } },
8385 /* VEX_LEN_DC_P_2 */
8387 { "vpaddusb", { XM, Vex128, EXx } },
8388 { "(bad)", { XX } },
8391 /* VEX_LEN_DD_P_2 */
8393 { "vpaddusw", { XM, Vex128, EXx } },
8394 { "(bad)", { XX } },
8397 /* VEX_LEN_DE_P_2 */
8399 { "vpmaxub", { XM, Vex128, EXx } },
8400 { "(bad)", { XX } },
8403 /* VEX_LEN_DF_P_2 */
8405 { "vpandn", { XM, Vex128, EXx } },
8406 { "(bad)", { XX } },
8409 /* VEX_LEN_E0_P_2 */
8411 { "vpavgb", { XM, Vex128, EXx } },
8412 { "(bad)", { XX } },
8415 /* VEX_LEN_E1_P_2 */
8417 { "vpsraw", { XM, Vex128, EXx } },
8418 { "(bad)", { XX } },
8421 /* VEX_LEN_E2_P_2 */
8423 { "vpsrad", { XM, Vex128, EXx } },
8424 { "(bad)", { XX } },
8427 /* VEX_LEN_E3_P_2 */
8429 { "vpavgw", { XM, Vex128, EXx } },
8430 { "(bad)", { XX } },
8433 /* VEX_LEN_E4_P_2 */
8435 { "vpmulhuw", { XM, Vex128, EXx } },
8436 { "(bad)", { XX } },
8439 /* VEX_LEN_E5_P_2 */
8441 { "vpmulhw", { XM, Vex128, EXx } },
8442 { "(bad)", { XX } },
8445 /* VEX_LEN_E8_P_2 */
8447 { "vpsubsb", { XM, Vex128, EXx } },
8448 { "(bad)", { XX } },
8451 /* VEX_LEN_E9_P_2 */
8453 { "vpsubsw", { XM, Vex128, EXx } },
8454 { "(bad)", { XX } },
8457 /* VEX_LEN_EA_P_2 */
8459 { "vpminsw", { XM, Vex128, EXx } },
8460 { "(bad)", { XX } },
8463 /* VEX_LEN_EB_P_2 */
8465 { "vpor", { XM, Vex128, EXx } },
8466 { "(bad)", { XX } },
8469 /* VEX_LEN_EC_P_2 */
8471 { "vpaddsb", { XM, Vex128, EXx } },
8472 { "(bad)", { XX } },
8475 /* VEX_LEN_ED_P_2 */
8477 { "vpaddsw", { XM, Vex128, EXx } },
8478 { "(bad)", { XX } },
8481 /* VEX_LEN_EE_P_2 */
8483 { "vpmaxsw", { XM, Vex128, EXx } },
8484 { "(bad)", { XX } },
8487 /* VEX_LEN_EF_P_2 */
8489 { "vpxor", { XM, Vex128, EXx } },
8490 { "(bad)", { XX } },
8493 /* VEX_LEN_F1_P_2 */
8495 { "vpsllw", { XM, Vex128, EXx } },
8496 { "(bad)", { XX } },
8499 /* VEX_LEN_F2_P_2 */
8501 { "vpslld", { XM, Vex128, EXx } },
8502 { "(bad)", { XX } },
8505 /* VEX_LEN_F3_P_2 */
8507 { "vpsllq", { XM, Vex128, EXx } },
8508 { "(bad)", { XX } },
8511 /* VEX_LEN_F4_P_2 */
8513 { "vpmuludq", { XM, Vex128, EXx } },
8514 { "(bad)", { XX } },
8517 /* VEX_LEN_F5_P_2 */
8519 { "vpmaddwd", { XM, Vex128, EXx } },
8520 { "(bad)", { XX } },
8523 /* VEX_LEN_F6_P_2 */
8525 { "vpsadbw", { XM, Vex128, EXx } },
8526 { "(bad)", { XX } },
8529 /* VEX_LEN_F7_P_2 */
8531 { "vmaskmovdqu", { XM, XS } },
8532 { "(bad)", { XX } },
8535 /* VEX_LEN_F8_P_2 */
8537 { "vpsubb", { XM, Vex128, EXx } },
8538 { "(bad)", { XX } },
8541 /* VEX_LEN_F9_P_2 */
8543 { "vpsubw", { XM, Vex128, EXx } },
8544 { "(bad)", { XX } },
8547 /* VEX_LEN_FA_P_2 */
8549 { "vpsubd", { XM, Vex128, EXx } },
8550 { "(bad)", { XX } },
8553 /* VEX_LEN_FB_P_2 */
8555 { "vpsubq", { XM, Vex128, EXx } },
8556 { "(bad)", { XX } },
8559 /* VEX_LEN_FC_P_2 */
8561 { "vpaddb", { XM, Vex128, EXx } },
8562 { "(bad)", { XX } },
8565 /* VEX_LEN_FD_P_2 */
8567 { "vpaddw", { XM, Vex128, EXx } },
8568 { "(bad)", { XX } },
8571 /* VEX_LEN_FE_P_2 */
8573 { "vpaddd", { XM, Vex128, EXx } },
8574 { "(bad)", { XX } },
8577 /* VEX_LEN_3800_P_2 */
8579 { "vpshufb", { XM, Vex128, EXx } },
8580 { "(bad)", { XX } },
8583 /* VEX_LEN_3801_P_2 */
8585 { "vphaddw", { XM, Vex128, EXx } },
8586 { "(bad)", { XX } },
8589 /* VEX_LEN_3802_P_2 */
8591 { "vphaddd", { XM, Vex128, EXx } },
8592 { "(bad)", { XX } },
8595 /* VEX_LEN_3803_P_2 */
8597 { "vphaddsw", { XM, Vex128, EXx } },
8598 { "(bad)", { XX } },
8601 /* VEX_LEN_3804_P_2 */
8603 { "vpmaddubsw", { XM, Vex128, EXx } },
8604 { "(bad)", { XX } },
8607 /* VEX_LEN_3805_P_2 */
8609 { "vphsubw", { XM, Vex128, EXx } },
8610 { "(bad)", { XX } },
8613 /* VEX_LEN_3806_P_2 */
8615 { "vphsubd", { XM, Vex128, EXx } },
8616 { "(bad)", { XX } },
8619 /* VEX_LEN_3807_P_2 */
8621 { "vphsubsw", { XM, Vex128, EXx } },
8622 { "(bad)", { XX } },
8625 /* VEX_LEN_3808_P_2 */
8627 { "vpsignb", { XM, Vex128, EXx } },
8628 { "(bad)", { XX } },
8631 /* VEX_LEN_3809_P_2 */
8633 { "vpsignw", { XM, Vex128, EXx } },
8634 { "(bad)", { XX } },
8637 /* VEX_LEN_380A_P_2 */
8639 { "vpsignd", { XM, Vex128, EXx } },
8640 { "(bad)", { XX } },
8643 /* VEX_LEN_380B_P_2 */
8645 { "vpmulhrsw", { XM, Vex128, EXx } },
8646 { "(bad)", { XX } },
8649 /* VEX_LEN_3819_P_2_M_0 */
8651 { "(bad)", { XX } },
8652 { "vbroadcastsd", { XM, Mq } },
8655 /* VEX_LEN_381A_P_2_M_0 */
8657 { "(bad)", { XX } },
8658 { "vbroadcastf128", { XM, Mxmm } },
8661 /* VEX_LEN_381C_P_2 */
8663 { "vpabsb", { XM, EXx } },
8664 { "(bad)", { XX } },
8667 /* VEX_LEN_381D_P_2 */
8669 { "vpabsw", { XM, EXx } },
8670 { "(bad)", { XX } },
8673 /* VEX_LEN_381E_P_2 */
8675 { "vpabsd", { XM, EXx } },
8676 { "(bad)", { XX } },
8679 /* VEX_LEN_3820_P_2 */
8681 { "vpmovsxbw", { XM, EXq } },
8682 { "(bad)", { XX } },
8685 /* VEX_LEN_3821_P_2 */
8687 { "vpmovsxbd", { XM, EXd } },
8688 { "(bad)", { XX } },
8691 /* VEX_LEN_3822_P_2 */
8693 { "vpmovsxbq", { XM, EXw } },
8694 { "(bad)", { XX } },
8697 /* VEX_LEN_3823_P_2 */
8699 { "vpmovsxwd", { XM, EXq } },
8700 { "(bad)", { XX } },
8703 /* VEX_LEN_3824_P_2 */
8705 { "vpmovsxwq", { XM, EXd } },
8706 { "(bad)", { XX } },
8709 /* VEX_LEN_3825_P_2 */
8711 { "vpmovsxdq", { XM, EXq } },
8712 { "(bad)", { XX } },
8715 /* VEX_LEN_3828_P_2 */
8717 { "vpmuldq", { XM, Vex128, EXx } },
8718 { "(bad)", { XX } },
8721 /* VEX_LEN_3829_P_2 */
8723 { "vpcmpeqq", { XM, Vex128, EXx } },
8724 { "(bad)", { XX } },
8727 /* VEX_LEN_382A_P_2_M_0 */
8729 { "vmovntdqa", { XM, Mx } },
8730 { "(bad)", { XX } },
8733 /* VEX_LEN_382B_P_2 */
8735 { "vpackusdw", { XM, Vex128, EXx } },
8736 { "(bad)", { XX } },
8739 /* VEX_LEN_3830_P_2 */
8741 { "vpmovzxbw", { XM, EXq } },
8742 { "(bad)", { XX } },
8745 /* VEX_LEN_3831_P_2 */
8747 { "vpmovzxbd", { XM, EXd } },
8748 { "(bad)", { XX } },
8751 /* VEX_LEN_3832_P_2 */
8753 { "vpmovzxbq", { XM, EXw } },
8754 { "(bad)", { XX } },
8757 /* VEX_LEN_3833_P_2 */
8759 { "vpmovzxwd", { XM, EXq } },
8760 { "(bad)", { XX } },
8763 /* VEX_LEN_3834_P_2 */
8765 { "vpmovzxwq", { XM, EXd } },
8766 { "(bad)", { XX } },
8769 /* VEX_LEN_3835_P_2 */
8771 { "vpmovzxdq", { XM, EXq } },
8772 { "(bad)", { XX } },
8775 /* VEX_LEN_3837_P_2 */
8777 { "vpcmpgtq", { XM, Vex128, EXx } },
8778 { "(bad)", { XX } },
8781 /* VEX_LEN_3838_P_2 */
8783 { "vpminsb", { XM, Vex128, EXx } },
8784 { "(bad)", { XX } },
8787 /* VEX_LEN_3839_P_2 */
8789 { "vpminsd", { XM, Vex128, EXx } },
8790 { "(bad)", { XX } },
8793 /* VEX_LEN_383A_P_2 */
8795 { "vpminuw", { XM, Vex128, EXx } },
8796 { "(bad)", { XX } },
8799 /* VEX_LEN_383B_P_2 */
8801 { "vpminud", { XM, Vex128, EXx } },
8802 { "(bad)", { XX } },
8805 /* VEX_LEN_383C_P_2 */
8807 { "vpmaxsb", { XM, Vex128, EXx } },
8808 { "(bad)", { XX } },
8811 /* VEX_LEN_383D_P_2 */
8813 { "vpmaxsd", { XM, Vex128, EXx } },
8814 { "(bad)", { XX } },
8817 /* VEX_LEN_383E_P_2 */
8819 { "vpmaxuw", { XM, Vex128, EXx } },
8820 { "(bad)", { XX } },
8823 /* VEX_LEN_383F_P_2 */
8825 { "vpmaxud", { XM, Vex128, EXx } },
8826 { "(bad)", { XX } },
8829 /* VEX_LEN_3840_P_2 */
8831 { "vpmulld", { XM, Vex128, EXx } },
8832 { "(bad)", { XX } },
8835 /* VEX_LEN_3841_P_2 */
8837 { "vphminposuw", { XM, EXx } },
8838 { "(bad)", { XX } },
8841 /* VEX_LEN_38DB_P_2 */
8843 { "vaesimc", { XM, EXx } },
8844 { "(bad)", { XX } },
8847 /* VEX_LEN_38DC_P_2 */
8849 { "vaesenc", { XM, Vex128, EXx } },
8850 { "(bad)", { XX } },
8853 /* VEX_LEN_38DD_P_2 */
8855 { "vaesenclast", { XM, Vex128, EXx } },
8856 { "(bad)", { XX } },
8859 /* VEX_LEN_38DE_P_2 */
8861 { "vaesdec", { XM, Vex128, EXx } },
8862 { "(bad)", { XX } },
8865 /* VEX_LEN_38DF_P_2 */
8867 { "vaesdeclast", { XM, Vex128, EXx } },
8868 { "(bad)", { XX } },
8871 /* VEX_LEN_3A06_P_2 */
8873 { "(bad)", { XX } },
8874 { "vperm2f128", { XM, Vex256, EXx, Ib } },
8877 /* VEX_LEN_3A0A_P_2 */
8879 { "vroundss", { XM, Vex128, EXd, Ib } },
8880 { "(bad)", { XX } },
8883 /* VEX_LEN_3A0B_P_2 */
8885 { "vroundsd", { XM, Vex128, EXq, Ib } },
8886 { "(bad)", { XX } },
8889 /* VEX_LEN_3A0E_P_2 */
8891 { "vpblendw", { XM, Vex128, EXx, Ib } },
8892 { "(bad)", { XX } },
8895 /* VEX_LEN_3A0F_P_2 */
8897 { "vpalignr", { XM, Vex128, EXx, Ib } },
8898 { "(bad)", { XX } },
8901 /* VEX_LEN_3A14_P_2 */
8903 { "vpextrb", { Edqb, XM, Ib } },
8904 { "(bad)", { XX } },
8907 /* VEX_LEN_3A15_P_2 */
8909 { "vpextrw", { Edqw, XM, Ib } },
8910 { "(bad)", { XX } },
8913 /* VEX_LEN_3A16_P_2 */
8915 { "vpextrK", { Edq, XM, Ib } },
8916 { "(bad)", { XX } },
8919 /* VEX_LEN_3A17_P_2 */
8921 { "vextractps", { Edqd, XM, Ib } },
8922 { "(bad)", { XX } },
8925 /* VEX_LEN_3A18_P_2 */
8927 { "(bad)", { XX } },
8928 { "vinsertf128", { XM, Vex256, EXxmm, Ib } },
8931 /* VEX_LEN_3A19_P_2 */
8933 { "(bad)", { XX } },
8934 { "vextractf128", { EXxmm, XM, Ib } },
8937 /* VEX_LEN_3A20_P_2 */
8939 { "vpinsrb", { XM, Vex128, Edqb, Ib } },
8940 { "(bad)", { XX } },
8943 /* VEX_LEN_3A21_P_2 */
8945 { "vinsertps", { XM, Vex128, EXd, Ib } },
8946 { "(bad)", { XX } },
8949 /* VEX_LEN_3A22_P_2 */
8951 { "vpinsrK", { XM, Vex128, Edq, Ib } },
8952 { "(bad)", { XX } },
8955 /* VEX_LEN_3A41_P_2 */
8957 { "vdppd", { XM, Vex128, EXx, Ib } },
8958 { "(bad)", { XX } },
8961 /* VEX_LEN_3A42_P_2 */
8963 { "vmpsadbw", { XM, Vex128, EXx, Ib } },
8964 { "(bad)", { XX } },
8967 /* VEX_LEN_3A44_P_2 */
8969 { "vpclmulqdq", { XM, Vex128, EXx, PCLMUL } },
8970 { "(bad)", { XX } },
8973 /* VEX_LEN_3A4C_P_2 */
8975 { "vpblendvb", { XM, Vex128, EXx, XMVexI4 } },
8976 { "(bad)", { XX } },
8979 /* VEX_LEN_3A60_P_2 */
8981 { "vpcmpestrm", { XM, EXx, Ib } },
8982 { "(bad)", { XX } },
8985 /* VEX_LEN_3A61_P_2 */
8987 { "vpcmpestri", { XM, EXx, Ib } },
8988 { "(bad)", { XX } },
8991 /* VEX_LEN_3A62_P_2 */
8993 { "vpcmpistrm", { XM, EXx, Ib } },
8994 { "(bad)", { XX } },
8997 /* VEX_LEN_3A63_P_2 */
8999 { "vpcmpistri", { XM, EXx, Ib } },
9000 { "(bad)", { XX } },
9003 /* VEX_LEN_3A6A_P_2 */
9005 { "vfmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9006 { "(bad)", { XX } },
9009 /* VEX_LEN_3A6B_P_2 */
9011 { "vfmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9012 { "(bad)", { XX } },
9015 /* VEX_LEN_3A6E_P_2 */
9017 { "vfmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9018 { "(bad)", { XX } },
9021 /* VEX_LEN_3A6F_P_2 */
9023 { "vfmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9024 { "(bad)", { XX } },
9027 /* VEX_LEN_3A7A_P_2 */
9029 { "vfnmaddss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9030 { "(bad)", { XX } },
9033 /* VEX_LEN_3A7B_P_2 */
9035 { "vfnmaddsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9036 { "(bad)", { XX } },
9039 /* VEX_LEN_3A7E_P_2 */
9041 { "vfnmsubss", { XMVexW, Vex128, EXdVexW, EXdVexW, VexI4 } },
9042 { "(bad)", { XX } },
9045 /* VEX_LEN_3A7F_P_2 */
9047 { "vfnmsubsd", { XMVexW, Vex128, EXqVexW, EXqVexW, VexI4 } },
9048 { "(bad)", { XX } },
9051 /* VEX_LEN_3ADF_P_2 */
9053 { "vaeskeygenassist", { XM, EXx, Ib } },
9054 { "(bad)", { XX } },
9058 static const struct dis386 mod_table[][2] = {
9061 { "leaS", { Gv, M } },
9062 { "(bad)", { XX } },
9065 /* MOD_0F01_REG_0 */
9066 { X86_64_TABLE (X86_64_0F01_REG_0) },
9067 { RM_TABLE (RM_0F01_REG_0) },
9070 /* MOD_0F01_REG_1 */
9071 { X86_64_TABLE (X86_64_0F01_REG_1) },
9072 { RM_TABLE (RM_0F01_REG_1) },
9075 /* MOD_0F01_REG_2 */
9076 { X86_64_TABLE (X86_64_0F01_REG_2) },
9077 { RM_TABLE (RM_0F01_REG_2) },
9080 /* MOD_0F01_REG_3 */
9081 { X86_64_TABLE (X86_64_0F01_REG_3) },
9082 { RM_TABLE (RM_0F01_REG_3) },
9085 /* MOD_0F01_REG_7 */
9086 { "invlpg", { Mb } },
9087 { RM_TABLE (RM_0F01_REG_7) },
9090 /* MOD_0F12_PREFIX_0 */
9091 { "movlps", { XM, EXq } },
9092 { "movhlps", { XM, EXq } },
9096 { "movlpX", { EXq, XM } },
9097 { "(bad)", { XX } },
9100 /* MOD_0F16_PREFIX_0 */
9101 { "movhps", { XM, EXq } },
9102 { "movlhps", { XM, EXq } },
9106 { "movhpX", { EXq, XM } },
9107 { "(bad)", { XX } },
9110 /* MOD_0F18_REG_0 */
9111 { "prefetchnta", { Mb } },
9112 { "(bad)", { XX } },
9115 /* MOD_0F18_REG_1 */
9116 { "prefetcht0", { Mb } },
9117 { "(bad)", { XX } },
9120 /* MOD_0F18_REG_2 */
9121 { "prefetcht1", { Mb } },
9122 { "(bad)", { XX } },
9125 /* MOD_0F18_REG_3 */
9126 { "prefetcht2", { Mb } },
9127 { "(bad)", { XX } },
9131 { "(bad)", { XX } },
9132 { "movZ", { Rm, Cm } },
9136 { "(bad)", { XX } },
9137 { "movZ", { Rm, Dm } },
9141 { "(bad)", { XX } },
9142 { "movZ", { Cm, Rm } },
9146 { "(bad)", { XX } },
9147 { "movZ", { Dm, Rm } },
9151 { "(bad)", { XX } },
9152 { "movL", { Rd, Td } },
9156 { "(bad)", { XX } },
9157 { "movL", { Td, Rd } },
9160 /* MOD_0F2B_PREFIX_0 */
9161 {"movntps", { Mx, XM } },
9162 { "(bad)", { XX } },
9165 /* MOD_0F2B_PREFIX_1 */
9166 {"movntss", { Md, XM } },
9167 { "(bad)", { XX } },
9170 /* MOD_0F2B_PREFIX_2 */
9171 {"movntpd", { Mx, XM } },
9172 { "(bad)", { XX } },
9175 /* MOD_0F2B_PREFIX_3 */
9176 {"movntsd", { Mq, XM } },
9177 { "(bad)", { XX } },
9181 { "(bad)", { XX } },
9182 { "movmskpX", { Gdq, XS } },
9185 /* MOD_0F71_REG_2 */
9186 { "(bad)", { XX } },
9187 { "psrlw", { MS, Ib } },
9190 /* MOD_0F71_REG_4 */
9191 { "(bad)", { XX } },
9192 { "psraw", { MS, Ib } },
9195 /* MOD_0F71_REG_6 */
9196 { "(bad)", { XX } },
9197 { "psllw", { MS, Ib } },
9200 /* MOD_0F72_REG_2 */
9201 { "(bad)", { XX } },
9202 { "psrld", { MS, Ib } },
9205 /* MOD_0F72_REG_4 */
9206 { "(bad)", { XX } },
9207 { "psrad", { MS, Ib } },
9210 /* MOD_0F72_REG_6 */
9211 { "(bad)", { XX } },
9212 { "pslld", { MS, Ib } },
9215 /* MOD_0F73_REG_2 */
9216 { "(bad)", { XX } },
9217 { "psrlq", { MS, Ib } },
9220 /* MOD_0F73_REG_3 */
9221 { "(bad)", { XX } },
9222 { PREFIX_TABLE (PREFIX_0F73_REG_3) },
9225 /* MOD_0F73_REG_6 */
9226 { "(bad)", { XX } },
9227 { "psllq", { MS, Ib } },
9230 /* MOD_0F73_REG_7 */
9231 { "(bad)", { XX } },
9232 { PREFIX_TABLE (PREFIX_0F73_REG_7) },
9235 /* MOD_0FAE_REG_0 */
9236 { "fxsave", { M } },
9237 { "(bad)", { XX } },
9240 /* MOD_0FAE_REG_1 */
9241 { "fxrstor", { M } },
9242 { "(bad)", { XX } },
9245 /* MOD_0FAE_REG_2 */
9246 { "ldmxcsr", { Md } },
9247 { "(bad)", { XX } },
9250 /* MOD_0FAE_REG_3 */
9251 { "stmxcsr", { Md } },
9252 { "(bad)", { XX } },
9255 /* MOD_0FAE_REG_4 */
9257 { "(bad)", { XX } },
9260 /* MOD_0FAE_REG_5 */
9261 { "xrstor", { M } },
9262 { RM_TABLE (RM_0FAE_REG_5) },
9265 /* MOD_0FAE_REG_6 */
9266 { "xsaveopt", { M } },
9267 { RM_TABLE (RM_0FAE_REG_6) },
9270 /* MOD_0FAE_REG_7 */
9271 { "clflush", { Mb } },
9272 { RM_TABLE (RM_0FAE_REG_7) },
9276 { "lssS", { Gv, Mp } },
9277 { "(bad)", { XX } },
9281 { "lfsS", { Gv, Mp } },
9282 { "(bad)", { XX } },
9286 { "lgsS", { Gv, Mp } },
9287 { "(bad)", { XX } },
9290 /* MOD_0FC7_REG_6 */
9291 { PREFIX_TABLE (PREFIX_0FC7_REG_6) },
9292 { "(bad)", { XX } },
9295 /* MOD_0FC7_REG_7 */
9296 { "vmptrst", { Mq } },
9297 { "(bad)", { XX } },
9301 { "(bad)", { XX } },
9302 { "pmovmskb", { Gdq, MS } },
9305 /* MOD_0FE7_PREFIX_2 */
9306 { "movntdq", { Mx, XM } },
9307 { "(bad)", { XX } },
9310 /* MOD_0FF0_PREFIX_3 */
9311 { "lddqu", { XM, M } },
9312 { "(bad)", { XX } },
9315 /* MOD_0F382A_PREFIX_2 */
9316 { "movntdqa", { XM, Mx } },
9317 { "(bad)", { XX } },
9321 { "bound{S|}", { Gv, Ma } },
9322 { "(bad)", { XX } },
9326 { "lesS", { Gv, Mp } },
9327 { VEX_C4_TABLE (VEX_0F) },
9331 { "ldsS", { Gv, Mp } },
9332 { VEX_C5_TABLE (VEX_0F) },
9335 /* MOD_VEX_12_PREFIX_0 */
9336 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_0) },
9337 { VEX_LEN_TABLE (VEX_LEN_12_P_0_M_1) },
9341 { VEX_LEN_TABLE (VEX_LEN_13_M_0) },
9342 { "(bad)", { XX } },
9345 /* MOD_VEX_16_PREFIX_0 */
9346 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_0) },
9347 { VEX_LEN_TABLE (VEX_LEN_16_P_0_M_1) },
9351 { VEX_LEN_TABLE (VEX_LEN_17_M_0) },
9352 { "(bad)", { XX } },
9356 { "vmovntpX", { Mx, XM } },
9357 { "(bad)", { XX } },
9361 { "(bad)", { XX } },
9362 { "vmovmskpX", { Gdq, XS } },
9365 /* MOD_VEX_71_REG_2 */
9366 { "(bad)", { XX } },
9367 { PREFIX_TABLE (PREFIX_VEX_71_REG_2) },
9370 /* MOD_VEX_71_REG_4 */
9371 { "(bad)", { XX } },
9372 { PREFIX_TABLE (PREFIX_VEX_71_REG_4) },
9375 /* MOD_VEX_71_REG_6 */
9376 { "(bad)", { XX } },
9377 { PREFIX_TABLE (PREFIX_VEX_71_REG_6) },
9380 /* MOD_VEX_72_REG_2 */
9381 { "(bad)", { XX } },
9382 { PREFIX_TABLE (PREFIX_VEX_72_REG_2) },
9385 /* MOD_VEX_72_REG_4 */
9386 { "(bad)", { XX } },
9387 { PREFIX_TABLE (PREFIX_VEX_72_REG_4) },
9390 /* MOD_VEX_72_REG_6 */
9391 { "(bad)", { XX } },
9392 { PREFIX_TABLE (PREFIX_VEX_72_REG_6) },
9395 /* MOD_VEX_73_REG_2 */
9396 { "(bad)", { XX } },
9397 { PREFIX_TABLE (PREFIX_VEX_73_REG_2) },
9400 /* MOD_VEX_73_REG_3 */
9401 { "(bad)", { XX } },
9402 { PREFIX_TABLE (PREFIX_VEX_73_REG_3) },
9405 /* MOD_VEX_73_REG_6 */
9406 { "(bad)", { XX } },
9407 { PREFIX_TABLE (PREFIX_VEX_73_REG_6) },
9410 /* MOD_VEX_73_REG_7 */
9411 { "(bad)", { XX } },
9412 { PREFIX_TABLE (PREFIX_VEX_73_REG_7) },
9415 /* MOD_VEX_AE_REG_2 */
9416 { VEX_LEN_TABLE (VEX_LEN_AE_R_2_M_0) },
9417 { "(bad)", { XX } },
9420 /* MOD_VEX_AE_REG_3 */
9421 { VEX_LEN_TABLE (VEX_LEN_AE_R_3_M_0) },
9422 { "(bad)", { XX } },
9425 /* MOD_VEX_D7_PREFIX_2 */
9426 { "(bad)", { XX } },
9427 { VEX_LEN_TABLE (VEX_LEN_D7_P_2_M_1) },
9430 /* MOD_VEX_E7_PREFIX_2 */
9431 { "vmovntdq", { Mx, XM } },
9432 { "(bad)", { XX } },
9435 /* MOD_VEX_F0_PREFIX_3 */
9436 { "vlddqu", { XM, M } },
9437 { "(bad)", { XX } },
9440 /* MOD_VEX_3818_PREFIX_2 */
9441 { "vbroadcastss", { XM, Md } },
9442 { "(bad)", { XX } },
9445 /* MOD_VEX_3819_PREFIX_2 */
9446 { VEX_LEN_TABLE (VEX_LEN_3819_P_2_M_0) },
9447 { "(bad)", { XX } },
9450 /* MOD_VEX_381A_PREFIX_2 */
9451 { VEX_LEN_TABLE (VEX_LEN_381A_P_2_M_0) },
9452 { "(bad)", { XX } },
9455 /* MOD_VEX_382A_PREFIX_2 */
9456 { VEX_LEN_TABLE (VEX_LEN_382A_P_2_M_0) },
9457 { "(bad)", { XX } },
9460 /* MOD_VEX_382C_PREFIX_2 */
9461 { "vmaskmovps", { XM, Vex, Mx } },
9462 { "(bad)", { XX } },
9465 /* MOD_VEX_382D_PREFIX_2 */
9466 { "vmaskmovpd", { XM, Vex, Mx } },
9467 { "(bad)", { XX } },
9470 /* MOD_VEX_382E_PREFIX_2 */
9471 { "vmaskmovps", { Mx, Vex, XM } },
9472 { "(bad)", { XX } },
9475 /* MOD_VEX_382F_PREFIX_2 */
9476 { "vmaskmovpd", { Mx, Vex, XM } },
9477 { "(bad)", { XX } },
9481 static const struct dis386 rm_table[][8] = {
9484 { "(bad)", { XX } },
9485 { "vmcall", { Skip_MODRM } },
9486 { "vmlaunch", { Skip_MODRM } },
9487 { "vmresume", { Skip_MODRM } },
9488 { "vmxoff", { Skip_MODRM } },
9489 { "(bad)", { XX } },
9490 { "(bad)", { XX } },
9491 { "(bad)", { XX } },
9495 { "monitor", { { OP_Monitor, 0 } } },
9496 { "mwait", { { OP_Mwait, 0 } } },
9497 { "(bad)", { XX } },
9498 { "(bad)", { XX } },
9499 { "(bad)", { XX } },
9500 { "(bad)", { XX } },
9501 { "(bad)", { XX } },
9502 { "(bad)", { XX } },
9506 { "xgetbv", { Skip_MODRM } },
9507 { "xsetbv", { Skip_MODRM } },
9508 { "(bad)", { XX } },
9509 { "(bad)", { XX } },
9510 { "(bad)", { XX } },
9511 { "(bad)", { XX } },
9512 { "(bad)", { XX } },
9513 { "(bad)", { XX } },
9517 { "vmrun", { Skip_MODRM } },
9518 { "vmmcall", { Skip_MODRM } },
9519 { "vmload", { Skip_MODRM } },
9520 { "vmsave", { Skip_MODRM } },
9521 { "stgi", { Skip_MODRM } },
9522 { "clgi", { Skip_MODRM } },
9523 { "skinit", { Skip_MODRM } },
9524 { "invlpga", { Skip_MODRM } },
9528 { "swapgs", { Skip_MODRM } },
9529 { "rdtscp", { Skip_MODRM } },
9530 { "(bad)", { XX } },
9531 { "(bad)", { XX } },
9532 { "(bad)", { XX } },
9533 { "(bad)", { XX } },
9534 { "(bad)", { XX } },
9535 { "(bad)", { XX } },
9539 { "lfence", { Skip_MODRM } },
9540 { "(bad)", { XX } },
9541 { "(bad)", { XX } },
9542 { "(bad)", { XX } },
9543 { "(bad)", { XX } },
9544 { "(bad)", { XX } },
9545 { "(bad)", { XX } },
9546 { "(bad)", { XX } },
9550 { "mfence", { Skip_MODRM } },
9551 { "(bad)", { XX } },
9552 { "(bad)", { XX } },
9553 { "(bad)", { XX } },
9554 { "(bad)", { XX } },
9555 { "(bad)", { XX } },
9556 { "(bad)", { XX } },
9557 { "(bad)", { XX } },
9561 { "sfence", { Skip_MODRM } },
9562 { "(bad)", { XX } },
9563 { "(bad)", { XX } },
9564 { "(bad)", { XX } },
9565 { "(bad)", { XX } },
9566 { "(bad)", { XX } },
9567 { "(bad)", { XX } },
9568 { "(bad)", { XX } },
9572 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
9574 /* We use the high bit to indicate different name for the same
9576 #define ADDR16_PREFIX (0x67 | 0x100)
9577 #define ADDR32_PREFIX (0x67 | 0x200)
9578 #define DATA16_PREFIX (0x66 | 0x100)
9579 #define DATA32_PREFIX (0x66 | 0x200)
9580 #define REP_PREFIX (0xf3 | 0x100)
9585 int newrex, i, length;
9592 last_lock_prefix = -1;
9593 last_repz_prefix = -1;
9594 last_repnz_prefix = -1;
9595 last_data_prefix = -1;
9596 last_addr_prefix = -1;
9597 last_rex_prefix = -1;
9598 last_seg_prefix = -1;
9599 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
9600 all_prefixes[i] = 0;
9603 /* The maximum instruction length is 15bytes. */
9604 while (length < MAX_CODE_LENGTH - 1)
9606 FETCH_DATA (the_info, codep + 1);
9610 /* REX prefixes family. */
9627 if (address_mode == mode_64bit)
9631 last_rex_prefix = i;
9634 prefixes |= PREFIX_REPZ;
9635 last_repz_prefix = i;
9638 prefixes |= PREFIX_REPNZ;
9639 last_repnz_prefix = i;
9642 prefixes |= PREFIX_LOCK;
9643 last_lock_prefix = i;
9646 prefixes |= PREFIX_CS;
9647 last_seg_prefix = i;
9650 prefixes |= PREFIX_SS;
9651 last_seg_prefix = i;
9654 prefixes |= PREFIX_DS;
9655 last_seg_prefix = i;
9658 prefixes |= PREFIX_ES;
9659 last_seg_prefix = i;
9662 prefixes |= PREFIX_FS;
9663 last_seg_prefix = i;
9666 prefixes |= PREFIX_GS;
9667 last_seg_prefix = i;
9670 prefixes |= PREFIX_DATA;
9671 last_data_prefix = i;
9674 prefixes |= PREFIX_ADDR;
9675 last_addr_prefix = i;
9678 /* fwait is really an instruction. If there are prefixes
9679 before the fwait, they belong to the fwait, *not* to the
9680 following instruction. */
9681 if (prefixes || rex)
9683 prefixes |= PREFIX_FWAIT;
9687 prefixes = PREFIX_FWAIT;
9692 /* Rex is ignored when followed by another prefix. */
9698 if (*codep != FWAIT_OPCODE)
9699 all_prefixes[i++] = *codep;
9709 seg_prefix (int pref)
9730 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
9734 prefix_name (int pref, int sizeflag)
9736 static const char *rexes [16] =
9741 "rex.XB", /* 0x43 */
9743 "rex.RB", /* 0x45 */
9744 "rex.RX", /* 0x46 */
9745 "rex.RXB", /* 0x47 */
9747 "rex.WB", /* 0x49 */
9748 "rex.WX", /* 0x4a */
9749 "rex.WXB", /* 0x4b */
9750 "rex.WR", /* 0x4c */
9751 "rex.WRB", /* 0x4d */
9752 "rex.WRX", /* 0x4e */
9753 "rex.WRXB", /* 0x4f */
9758 /* REX prefixes family. */
9775 return rexes [pref - 0x40];
9795 return (sizeflag & DFLAG) ? "data16" : "data32";
9797 if (address_mode == mode_64bit)
9798 return (sizeflag & AFLAG) ? "addr32" : "addr64";
9800 return (sizeflag & AFLAG) ? "addr16" : "addr32";
9818 static char op_out[MAX_OPERANDS][100];
9819 static int op_ad, op_index[MAX_OPERANDS];
9820 static int two_source_ops;
9821 static bfd_vma op_address[MAX_OPERANDS];
9822 static bfd_vma op_riprel[MAX_OPERANDS];
9823 static bfd_vma start_pc;
9826 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
9827 * (see topic "Redundant prefixes" in the "Differences from 8086"
9828 * section of the "Virtual 8086 Mode" chapter.)
9829 * 'pc' should be the address of this instruction, it will
9830 * be used to print the target address if this is a relative jump or call
9831 * The function returns the length of this instruction in bytes.
9834 static char intel_syntax;
9835 static char intel_mnemonic = !SYSV386_COMPAT;
9836 static char open_char;
9837 static char close_char;
9838 static char separator_char;
9839 static char scale_char;
9841 /* Here for backwards compatibility. When gdb stops using
9842 print_insn_i386_att and print_insn_i386_intel these functions can
9843 disappear, and print_insn_i386 be merged into print_insn. */
9845 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
9849 return print_insn (pc, info);
9853 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
9857 return print_insn (pc, info);
9861 print_insn_i386 (bfd_vma pc, disassemble_info *info)
9865 return print_insn (pc, info);
9869 print_i386_disassembler_options (FILE *stream)
9871 fprintf (stream, _("\n\
9872 The following i386/x86-64 specific disassembler options are supported for use\n\
9873 with the -M switch (multiple options should be separated by commas):\n"));
9875 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
9876 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
9877 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
9878 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
9879 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
9880 fprintf (stream, _(" att-mnemonic\n"
9881 " Display instruction in AT&T mnemonic\n"));
9882 fprintf (stream, _(" intel-mnemonic\n"
9883 " Display instruction in Intel mnemonic\n"));
9884 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
9885 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
9886 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
9887 fprintf (stream, _(" data32 Assume 32bit data size\n"));
9888 fprintf (stream, _(" data16 Assume 16bit data size\n"));
9889 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
9892 /* Get a pointer to struct dis386 with a valid name. */
9894 static const struct dis386 *
9895 get_valid_dis386 (const struct dis386 *dp, disassemble_info *info)
9897 int index, vex_table_index;
9899 if (dp->name != NULL)
9902 switch (dp->op[0].bytemode)
9905 dp = ®_table[dp->op[1].bytemode][modrm.reg];
9909 index = modrm.mod == 0x3 ? 1 : 0;
9910 dp = &mod_table[dp->op[1].bytemode][index];
9914 dp = &rm_table[dp->op[1].bytemode][modrm.rm];
9917 case USE_PREFIX_TABLE:
9920 /* The prefix in VEX is implicit. */
9926 case REPE_PREFIX_OPCODE:
9929 case DATA_PREFIX_OPCODE:
9932 case REPNE_PREFIX_OPCODE:
9943 used_prefixes |= (prefixes & PREFIX_REPZ);
9944 if (prefixes & PREFIX_REPZ)
9947 all_prefixes[last_repz_prefix] = 0;
9951 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
9953 used_prefixes |= (prefixes & PREFIX_REPNZ);
9954 if (prefixes & PREFIX_REPNZ)
9957 all_prefixes[last_repnz_prefix] = 0;
9961 used_prefixes |= (prefixes & PREFIX_DATA);
9962 if (prefixes & PREFIX_DATA)
9965 all_prefixes[last_data_prefix] = 0;
9970 dp = &prefix_table[dp->op[1].bytemode][index];
9973 case USE_X86_64_TABLE:
9974 index = address_mode == mode_64bit ? 1 : 0;
9975 dp = &x86_64_table[dp->op[1].bytemode][index];
9978 case USE_3BYTE_TABLE:
9979 FETCH_DATA (info, codep + 2);
9981 dp = &three_byte_table[dp->op[1].bytemode][index];
9982 modrm.mod = (*codep >> 6) & 3;
9983 modrm.reg = (*codep >> 3) & 7;
9984 modrm.rm = *codep & 7;
9987 case USE_VEX_LEN_TABLE:
10004 dp = &vex_len_table[dp->op[1].bytemode][index];
10007 case USE_XOP_8F_TABLE:
10008 FETCH_DATA (info, codep + 3);
10009 /* All bits in the REX prefix are ignored. */
10011 rex = ~(*codep >> 5) & 0x7;
10013 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
10014 switch ((*codep & 0x1f))
10019 vex_table_index = XOP_09;
10022 vex_table_index = XOP_0A;
10026 vex.w = *codep & 0x80;
10027 if (vex.w && address_mode == mode_64bit)
10030 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10031 if (address_mode != mode_64bit
10032 && vex.register_specifier > 0x7)
10035 vex.length = (*codep & 0x4) ? 256 : 128;
10036 switch ((*codep & 0x3))
10042 vex.prefix = DATA_PREFIX_OPCODE;
10045 vex.prefix = REPE_PREFIX_OPCODE;
10048 vex.prefix = REPNE_PREFIX_OPCODE;
10055 dp = &xop_table[vex_table_index][index];
10057 FETCH_DATA (info, codep + 1);
10058 modrm.mod = (*codep >> 6) & 3;
10059 modrm.reg = (*codep >> 3) & 7;
10060 modrm.rm = *codep & 7;
10063 case USE_VEX_C4_TABLE:
10064 FETCH_DATA (info, codep + 3);
10065 /* All bits in the REX prefix are ignored. */
10067 rex = ~(*codep >> 5) & 0x7;
10068 switch ((*codep & 0x1f))
10073 vex_table_index = VEX_0F;
10076 vex_table_index = VEX_0F38;
10079 vex_table_index = VEX_0F3A;
10083 vex.w = *codep & 0x80;
10084 if (vex.w && address_mode == mode_64bit)
10087 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10088 if (address_mode != mode_64bit
10089 && vex.register_specifier > 0x7)
10092 vex.length = (*codep & 0x4) ? 256 : 128;
10093 switch ((*codep & 0x3))
10099 vex.prefix = DATA_PREFIX_OPCODE;
10102 vex.prefix = REPE_PREFIX_OPCODE;
10105 vex.prefix = REPNE_PREFIX_OPCODE;
10112 dp = &vex_table[vex_table_index][index];
10113 /* There is no MODRM byte for VEX [82|77]. */
10114 if (index != 0x77 && index != 0x82)
10116 FETCH_DATA (info, codep + 1);
10117 modrm.mod = (*codep >> 6) & 3;
10118 modrm.reg = (*codep >> 3) & 7;
10119 modrm.rm = *codep & 7;
10123 case USE_VEX_C5_TABLE:
10124 FETCH_DATA (info, codep + 2);
10125 /* All bits in the REX prefix are ignored. */
10127 rex = (*codep & 0x80) ? 0 : REX_R;
10129 vex.register_specifier = (~(*codep >> 3)) & 0xf;
10130 if (address_mode != mode_64bit
10131 && vex.register_specifier > 0x7)
10134 vex.length = (*codep & 0x4) ? 256 : 128;
10135 switch ((*codep & 0x3))
10141 vex.prefix = DATA_PREFIX_OPCODE;
10144 vex.prefix = REPE_PREFIX_OPCODE;
10147 vex.prefix = REPNE_PREFIX_OPCODE;
10154 dp = &vex_table[dp->op[1].bytemode][index];
10155 /* There is no MODRM byte for VEX [82|77]. */
10156 if (index != 0x77 && index != 0x82)
10158 FETCH_DATA (info, codep + 1);
10159 modrm.mod = (*codep >> 6) & 3;
10160 modrm.reg = (*codep >> 3) & 7;
10161 modrm.rm = *codep & 7;
10169 if (dp->name != NULL)
10172 return get_valid_dis386 (dp, info);
10176 print_insn (bfd_vma pc, disassemble_info *info)
10178 const struct dis386 *dp;
10180 char *op_txt[MAX_OPERANDS];
10184 struct dis_private priv;
10187 int default_prefixes;
10189 if (info->mach == bfd_mach_x86_64_intel_syntax
10190 || info->mach == bfd_mach_x86_64
10191 || info->mach == bfd_mach_l1om
10192 || info->mach == bfd_mach_l1om_intel_syntax)
10193 address_mode = mode_64bit;
10195 address_mode = mode_32bit;
10197 if (intel_syntax == (char) -1)
10198 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
10199 || info->mach == bfd_mach_x86_64_intel_syntax
10200 || info->mach == bfd_mach_l1om_intel_syntax);
10202 if (info->mach == bfd_mach_i386_i386
10203 || info->mach == bfd_mach_x86_64
10204 || info->mach == bfd_mach_l1om
10205 || info->mach == bfd_mach_i386_i386_intel_syntax
10206 || info->mach == bfd_mach_x86_64_intel_syntax
10207 || info->mach == bfd_mach_l1om_intel_syntax)
10208 priv.orig_sizeflag = AFLAG | DFLAG;
10209 else if (info->mach == bfd_mach_i386_i8086)
10210 priv.orig_sizeflag = 0;
10214 for (p = info->disassembler_options; p != NULL; )
10216 if (CONST_STRNEQ (p, "x86-64"))
10218 address_mode = mode_64bit;
10219 priv.orig_sizeflag = AFLAG | DFLAG;
10221 else if (CONST_STRNEQ (p, "i386"))
10223 address_mode = mode_32bit;
10224 priv.orig_sizeflag = AFLAG | DFLAG;
10226 else if (CONST_STRNEQ (p, "i8086"))
10228 address_mode = mode_16bit;
10229 priv.orig_sizeflag = 0;
10231 else if (CONST_STRNEQ (p, "intel"))
10234 if (CONST_STRNEQ (p + 5, "-mnemonic"))
10235 intel_mnemonic = 1;
10237 else if (CONST_STRNEQ (p, "att"))
10240 if (CONST_STRNEQ (p + 3, "-mnemonic"))
10241 intel_mnemonic = 0;
10243 else if (CONST_STRNEQ (p, "addr"))
10245 if (address_mode == mode_64bit)
10247 if (p[4] == '3' && p[5] == '2')
10248 priv.orig_sizeflag &= ~AFLAG;
10249 else if (p[4] == '6' && p[5] == '4')
10250 priv.orig_sizeflag |= AFLAG;
10254 if (p[4] == '1' && p[5] == '6')
10255 priv.orig_sizeflag &= ~AFLAG;
10256 else if (p[4] == '3' && p[5] == '2')
10257 priv.orig_sizeflag |= AFLAG;
10260 else if (CONST_STRNEQ (p, "data"))
10262 if (p[4] == '1' && p[5] == '6')
10263 priv.orig_sizeflag &= ~DFLAG;
10264 else if (p[4] == '3' && p[5] == '2')
10265 priv.orig_sizeflag |= DFLAG;
10267 else if (CONST_STRNEQ (p, "suffix"))
10268 priv.orig_sizeflag |= SUFFIX_ALWAYS;
10270 p = strchr (p, ',');
10277 names64 = intel_names64;
10278 names32 = intel_names32;
10279 names16 = intel_names16;
10280 names8 = intel_names8;
10281 names8rex = intel_names8rex;
10282 names_seg = intel_names_seg;
10283 index64 = intel_index64;
10284 index32 = intel_index32;
10285 index16 = intel_index16;
10288 separator_char = '+';
10293 names64 = att_names64;
10294 names32 = att_names32;
10295 names16 = att_names16;
10296 names8 = att_names8;
10297 names8rex = att_names8rex;
10298 names_seg = att_names_seg;
10299 index64 = att_index64;
10300 index32 = att_index32;
10301 index16 = att_index16;
10304 separator_char = ',';
10308 /* The output looks better if we put 7 bytes on a line, since that
10309 puts most long word instructions on a single line. Use 8 bytes
10311 if (info->mach == bfd_mach_l1om
10312 || info->mach == bfd_mach_l1om_intel_syntax)
10313 info->bytes_per_line = 8;
10315 info->bytes_per_line = 7;
10317 info->private_data = &priv;
10318 priv.max_fetched = priv.the_buffer;
10319 priv.insn_start = pc;
10322 for (i = 0; i < MAX_OPERANDS; ++i)
10330 start_codep = priv.the_buffer;
10331 codep = priv.the_buffer;
10333 if (setjmp (priv.bailout) != 0)
10337 /* Getting here means we tried for data but didn't get it. That
10338 means we have an incomplete instruction of some sort. Just
10339 print the first byte as a prefix or a .byte pseudo-op. */
10340 if (codep > priv.the_buffer)
10342 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
10344 (*info->fprintf_func) (info->stream, "%s", name);
10347 /* Just print the first byte as a .byte instruction. */
10348 (*info->fprintf_func) (info->stream, ".byte 0x%x",
10349 (unsigned int) priv.the_buffer[0]);
10359 sizeflag = priv.orig_sizeflag;
10361 if (!ckprefix () || rex_used)
10363 /* Too many prefixes or unused REX prefixes. */
10365 all_prefixes[i] && i < (int) ARRAY_SIZE (all_prefixes);
10367 (*info->fprintf_func) (info->stream, "%s",
10368 prefix_name (all_prefixes[i], sizeflag));
10372 insn_codep = codep;
10374 FETCH_DATA (info, codep + 1);
10375 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
10377 if (((prefixes & PREFIX_FWAIT)
10378 && ((*codep < 0xd8) || (*codep > 0xdf))))
10380 (*info->fprintf_func) (info->stream, "fwait");
10386 if (*codep == 0x0f)
10388 unsigned char threebyte;
10389 FETCH_DATA (info, codep + 2);
10390 threebyte = *++codep;
10391 dp = &dis386_twobyte[threebyte];
10392 need_modrm = twobyte_has_modrm[*codep];
10397 dp = &dis386[*codep];
10398 need_modrm = onebyte_has_modrm[*codep];
10402 if ((prefixes & PREFIX_REPZ))
10403 used_prefixes |= PREFIX_REPZ;
10404 if ((prefixes & PREFIX_REPNZ))
10405 used_prefixes |= PREFIX_REPNZ;
10406 if ((prefixes & PREFIX_LOCK))
10407 used_prefixes |= PREFIX_LOCK;
10409 default_prefixes = 0;
10410 if (prefixes & PREFIX_ADDR)
10413 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
10415 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
10416 all_prefixes[last_addr_prefix] = ADDR32_PREFIX;
10418 all_prefixes[last_addr_prefix] = ADDR16_PREFIX;
10419 default_prefixes |= PREFIX_ADDR;
10423 if ((prefixes & PREFIX_DATA))
10426 if (dp->op[2].bytemode == cond_jump_mode
10427 && dp->op[0].bytemode == v_mode
10430 if (sizeflag & DFLAG)
10431 all_prefixes[last_data_prefix] = DATA32_PREFIX;
10433 all_prefixes[last_data_prefix] = DATA16_PREFIX;
10434 default_prefixes |= PREFIX_DATA;
10436 else if (rex & REX_W)
10438 /* REX_W will override PREFIX_DATA. */
10439 default_prefixes |= PREFIX_DATA;
10445 FETCH_DATA (info, codep + 1);
10446 modrm.mod = (*codep >> 6) & 3;
10447 modrm.reg = (*codep >> 3) & 7;
10448 modrm.rm = *codep & 7;
10455 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
10457 dofloat (sizeflag);
10461 dp = get_valid_dis386 (dp, info);
10462 if (dp != NULL && putop (dp->name, sizeflag) == 0)
10464 for (i = 0; i < MAX_OPERANDS; ++i)
10467 op_ad = MAX_OPERANDS - 1 - i;
10469 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
10474 /* See if any prefixes were not used. If so, print the first one
10475 separately. If we don't do this, we'll wind up printing an
10476 instruction stream which does not precisely correspond to the
10477 bytes we are disassembling. */
10478 if ((prefixes & ~(used_prefixes | default_prefixes)) != 0)
10480 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
10481 if (all_prefixes[i])
10484 name = prefix_name (all_prefixes[i], priv.orig_sizeflag);
10486 name = INTERNAL_DISASSEMBLER_ERROR;
10487 (*info->fprintf_func) (info->stream, "%s", name);
10492 /* Check if the REX prefix used. */
10493 if (rex_ignored == 0 && (rex ^ rex_used) == 0)
10494 all_prefixes[last_rex_prefix] = 0;
10496 /* Check if the SEG prefix used. */
10497 if ((prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS | PREFIX_ES
10498 | PREFIX_FS | PREFIX_GS)) != 0
10500 & seg_prefix (all_prefixes[last_seg_prefix])) != 0)
10501 all_prefixes[last_seg_prefix] = 0;
10503 /* Check if the ADDR prefix used. */
10504 if ((prefixes & PREFIX_ADDR) != 0
10505 && (used_prefixes & PREFIX_ADDR) != 0)
10506 all_prefixes[last_addr_prefix] = 0;
10508 /* Check if the DATA prefix used. */
10509 if ((prefixes & PREFIX_DATA) != 0
10510 && (used_prefixes & PREFIX_DATA) != 0)
10511 all_prefixes[last_data_prefix] = 0;
10514 for (i = 0; i < (int) ARRAY_SIZE (all_prefixes); i++)
10515 if (all_prefixes[i])
10518 name = prefix_name (all_prefixes[i], sizeflag);
10521 prefix_length += strlen (name) + 1;
10522 (*info->fprintf_func) (info->stream, "%s ", name);
10525 /* Check maximum code length. */
10526 if ((codep - start_codep) > MAX_CODE_LENGTH)
10528 (*info->fprintf_func) (info->stream, "(bad)");
10529 return MAX_CODE_LENGTH;
10532 obufp = mnemonicendp;
10533 for (i = strlen (obuf) + prefix_length; i < 6; i++)
10536 (*info->fprintf_func) (info->stream, "%s", obuf);
10538 /* The enter and bound instructions are printed with operands in the same
10539 order as the intel book; everything else is printed in reverse order. */
10540 if (intel_syntax || two_source_ops)
10544 for (i = 0; i < MAX_OPERANDS; ++i)
10545 op_txt[i] = op_out[i];
10547 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
10549 op_ad = op_index[i];
10550 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
10551 op_index[MAX_OPERANDS - 1 - i] = op_ad;
10552 riprel = op_riprel[i];
10553 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
10554 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
10559 for (i = 0; i < MAX_OPERANDS; ++i)
10560 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
10564 for (i = 0; i < MAX_OPERANDS; ++i)
10568 (*info->fprintf_func) (info->stream, ",");
10569 if (op_index[i] != -1 && !op_riprel[i])
10570 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
10572 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
10576 for (i = 0; i < MAX_OPERANDS; i++)
10577 if (op_index[i] != -1 && op_riprel[i])
10579 (*info->fprintf_func) (info->stream, " # ");
10580 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
10581 + op_address[op_index[i]]), info);
10584 return codep - priv.the_buffer;
10587 static const char *float_mem[] = {
10662 static const unsigned char float_mem_mode[] = {
10737 #define ST { OP_ST, 0 }
10738 #define STi { OP_STi, 0 }
10740 #define FGRPd9_2 NULL, { { NULL, 0 } }
10741 #define FGRPd9_4 NULL, { { NULL, 1 } }
10742 #define FGRPd9_5 NULL, { { NULL, 2 } }
10743 #define FGRPd9_6 NULL, { { NULL, 3 } }
10744 #define FGRPd9_7 NULL, { { NULL, 4 } }
10745 #define FGRPda_5 NULL, { { NULL, 5 } }
10746 #define FGRPdb_4 NULL, { { NULL, 6 } }
10747 #define FGRPde_3 NULL, { { NULL, 7 } }
10748 #define FGRPdf_4 NULL, { { NULL, 8 } }
10750 static const struct dis386 float_reg[][8] = {
10753 { "fadd", { ST, STi } },
10754 { "fmul", { ST, STi } },
10755 { "fcom", { STi } },
10756 { "fcomp", { STi } },
10757 { "fsub", { ST, STi } },
10758 { "fsubr", { ST, STi } },
10759 { "fdiv", { ST, STi } },
10760 { "fdivr", { ST, STi } },
10764 { "fld", { STi } },
10765 { "fxch", { STi } },
10767 { "(bad)", { XX } },
10775 { "fcmovb", { ST, STi } },
10776 { "fcmove", { ST, STi } },
10777 { "fcmovbe",{ ST, STi } },
10778 { "fcmovu", { ST, STi } },
10779 { "(bad)", { XX } },
10781 { "(bad)", { XX } },
10782 { "(bad)", { XX } },
10786 { "fcmovnb",{ ST, STi } },
10787 { "fcmovne",{ ST, STi } },
10788 { "fcmovnbe",{ ST, STi } },
10789 { "fcmovnu",{ ST, STi } },
10791 { "fucomi", { ST, STi } },
10792 { "fcomi", { ST, STi } },
10793 { "(bad)", { XX } },
10797 { "fadd", { STi, ST } },
10798 { "fmul", { STi, ST } },
10799 { "(bad)", { XX } },
10800 { "(bad)", { XX } },
10801 { "fsub!M", { STi, ST } },
10802 { "fsubM", { STi, ST } },
10803 { "fdiv!M", { STi, ST } },
10804 { "fdivM", { STi, ST } },
10808 { "ffree", { STi } },
10809 { "(bad)", { XX } },
10810 { "fst", { STi } },
10811 { "fstp", { STi } },
10812 { "fucom", { STi } },
10813 { "fucomp", { STi } },
10814 { "(bad)", { XX } },
10815 { "(bad)", { XX } },
10819 { "faddp", { STi, ST } },
10820 { "fmulp", { STi, ST } },
10821 { "(bad)", { XX } },
10823 { "fsub!Mp", { STi, ST } },
10824 { "fsubMp", { STi, ST } },
10825 { "fdiv!Mp", { STi, ST } },
10826 { "fdivMp", { STi, ST } },
10830 { "ffreep", { STi } },
10831 { "(bad)", { XX } },
10832 { "(bad)", { XX } },
10833 { "(bad)", { XX } },
10835 { "fucomip", { ST, STi } },
10836 { "fcomip", { ST, STi } },
10837 { "(bad)", { XX } },
10841 static char *fgrps[][8] = {
10844 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10849 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
10854 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
10859 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
10864 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
10869 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10874 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
10875 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
10880 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10885 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
10890 swap_operand (void)
10892 mnemonicendp[0] = '.';
10893 mnemonicendp[1] = 's';
10898 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED,
10899 int sizeflag ATTRIBUTE_UNUSED)
10901 /* Skip mod/rm byte. */
10907 dofloat (int sizeflag)
10909 const struct dis386 *dp;
10910 unsigned char floatop;
10912 floatop = codep[-1];
10914 if (modrm.mod != 3)
10916 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
10918 putop (float_mem[fp_indx], sizeflag);
10921 OP_E (float_mem_mode[fp_indx], sizeflag);
10924 /* Skip mod/rm byte. */
10928 dp = &float_reg[floatop - 0xd8][modrm.reg];
10929 if (dp->name == NULL)
10931 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
10933 /* Instruction fnstsw is only one with strange arg. */
10934 if (floatop == 0xdf && codep[-1] == 0xe0)
10935 strcpy (op_out[0], names16[0]);
10939 putop (dp->name, sizeflag);
10944 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
10949 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
10954 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
10956 oappend ("%st" + intel_syntax);
10960 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
10962 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
10963 oappend (scratchbuf + intel_syntax);
10966 /* Capital letters in template are macros. */
10968 putop (const char *in_template, int sizeflag)
10973 unsigned int l = 0, len = 1;
10976 #define SAVE_LAST(c) \
10977 if (l < len && l < sizeof (last)) \
10982 for (p = in_template; *p; p++)
10999 while (*++p != '|')
11000 if (*p == '}' || *p == '\0')
11003 /* Fall through. */
11008 while (*++p != '}')
11019 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11023 if (l == 0 && len == 1)
11028 if (sizeflag & SUFFIX_ALWAYS)
11041 if (address_mode == mode_64bit
11042 && !(prefixes & PREFIX_ADDR))
11053 if (intel_syntax && !alt)
11055 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
11057 if (sizeflag & DFLAG)
11058 *obufp++ = intel_syntax ? 'd' : 'l';
11060 *obufp++ = intel_syntax ? 'w' : 's';
11061 used_prefixes |= (prefixes & PREFIX_DATA);
11065 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
11068 if (modrm.mod == 3)
11074 if (sizeflag & DFLAG)
11075 *obufp++ = intel_syntax ? 'd' : 'l';
11078 used_prefixes |= (prefixes & PREFIX_DATA);
11084 case 'E': /* For jcxz/jecxz */
11085 if (address_mode == mode_64bit)
11087 if (sizeflag & AFLAG)
11093 if (sizeflag & AFLAG)
11095 used_prefixes |= (prefixes & PREFIX_ADDR);
11100 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
11102 if (sizeflag & AFLAG)
11103 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
11105 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
11106 used_prefixes |= (prefixes & PREFIX_ADDR);
11110 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
11112 if ((rex & REX_W) || (sizeflag & DFLAG))
11116 if (!(rex & REX_W))
11117 used_prefixes |= (prefixes & PREFIX_DATA);
11122 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
11123 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
11125 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
11128 if (prefixes & PREFIX_DS)
11149 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
11154 /* Fall through. */
11157 if (l != 0 || len != 1)
11165 if (sizeflag & SUFFIX_ALWAYS)
11169 if (intel_mnemonic != cond)
11173 if ((prefixes & PREFIX_FWAIT) == 0)
11176 used_prefixes |= PREFIX_FWAIT;
11182 else if (intel_syntax && (sizeflag & DFLAG))
11186 if (!(rex & REX_W))
11187 used_prefixes |= (prefixes & PREFIX_DATA);
11192 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11197 /* Fall through. */
11201 if ((prefixes & PREFIX_DATA)
11203 || (sizeflag & SUFFIX_ALWAYS))
11210 if (sizeflag & DFLAG)
11214 used_prefixes |= (prefixes & PREFIX_DATA);
11221 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11223 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11227 /* Fall through. */
11230 if (l == 0 && len == 1)
11233 if (intel_syntax && !alt)
11236 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
11242 if (sizeflag & DFLAG)
11243 *obufp++ = intel_syntax ? 'd' : 'l';
11246 used_prefixes |= (prefixes & PREFIX_DATA);
11252 if (l != 1 || len != 2 || last[0] != 'L')
11258 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11273 else if (sizeflag & DFLAG)
11282 if (intel_syntax && !p[1]
11283 && ((rex & REX_W) || (sizeflag & DFLAG)))
11285 if (!(rex & REX_W))
11286 used_prefixes |= (prefixes & PREFIX_DATA);
11289 if (l == 0 && len == 1)
11293 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11295 if (sizeflag & SUFFIX_ALWAYS)
11317 /* Fall through. */
11320 if (l == 0 && len == 1)
11325 if (sizeflag & SUFFIX_ALWAYS)
11331 if (sizeflag & DFLAG)
11335 used_prefixes |= (prefixes & PREFIX_DATA);
11349 if (address_mode == mode_64bit
11350 && !(prefixes & PREFIX_ADDR))
11361 if (l != 0 || len != 1)
11366 if (need_vex && vex.prefix)
11368 if (vex.prefix == DATA_PREFIX_OPCODE)
11375 if (prefixes & PREFIX_DATA)
11379 used_prefixes |= (prefixes & PREFIX_DATA);
11383 if (l == 0 && len == 1)
11385 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
11396 if (l != 1 || len != 2 || last[0] != 'X')
11404 || (modrm.mod == 3 && !(sizeflag & SUFFIX_ALWAYS)))
11406 switch (vex.length)
11420 if (l == 0 && len == 1)
11422 /* operand size flag for cwtl, cbtw */
11431 else if (sizeflag & DFLAG)
11435 if (!(rex & REX_W))
11436 used_prefixes |= (prefixes & PREFIX_DATA);
11440 if (l != 1 || len != 2 || last[0] != 'X')
11447 *obufp++ = vex.w ? 'd': 's';
11454 mnemonicendp = obufp;
11459 oappend (const char *s)
11461 obufp = stpcpy (obufp, s);
11467 if (prefixes & PREFIX_CS)
11469 used_prefixes |= PREFIX_CS;
11470 oappend ("%cs:" + intel_syntax);
11472 if (prefixes & PREFIX_DS)
11474 used_prefixes |= PREFIX_DS;
11475 oappend ("%ds:" + intel_syntax);
11477 if (prefixes & PREFIX_SS)
11479 used_prefixes |= PREFIX_SS;
11480 oappend ("%ss:" + intel_syntax);
11482 if (prefixes & PREFIX_ES)
11484 used_prefixes |= PREFIX_ES;
11485 oappend ("%es:" + intel_syntax);
11487 if (prefixes & PREFIX_FS)
11489 used_prefixes |= PREFIX_FS;
11490 oappend ("%fs:" + intel_syntax);
11492 if (prefixes & PREFIX_GS)
11494 used_prefixes |= PREFIX_GS;
11495 oappend ("%gs:" + intel_syntax);
11500 OP_indirE (int bytemode, int sizeflag)
11504 OP_E (bytemode, sizeflag);
11508 print_operand_value (char *buf, int hex, bfd_vma disp)
11510 if (address_mode == mode_64bit)
11518 sprintf_vma (tmp, disp);
11519 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
11520 strcpy (buf + 2, tmp + i);
11524 bfd_signed_vma v = disp;
11531 /* Check for possible overflow on 0x8000000000000000. */
11534 strcpy (buf, "9223372036854775808");
11548 tmp[28 - i] = (v % 10) + '0';
11552 strcpy (buf, tmp + 29 - i);
11558 sprintf (buf, "0x%x", (unsigned int) disp);
11560 sprintf (buf, "%d", (int) disp);
11564 /* Put DISP in BUF as signed hex number. */
11567 print_displacement (char *buf, bfd_vma disp)
11569 bfd_signed_vma val = disp;
11578 /* Check for possible overflow. */
11581 switch (address_mode)
11584 strcpy (buf + j, "0x8000000000000000");
11587 strcpy (buf + j, "0x80000000");
11590 strcpy (buf + j, "0x8000");
11600 sprintf_vma (tmp, (bfd_vma) val);
11601 for (i = 0; tmp[i] == '0'; i++)
11603 if (tmp[i] == '\0')
11605 strcpy (buf + j, tmp + i);
11609 intel_operand_size (int bytemode, int sizeflag)
11616 oappend ("BYTE PTR ");
11620 oappend ("WORD PTR ");
11623 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11625 oappend ("QWORD PTR ");
11634 oappend ("QWORD PTR ");
11637 if ((sizeflag & DFLAG) || bytemode == dq_mode)
11638 oappend ("DWORD PTR ");
11640 oappend ("WORD PTR ");
11641 used_prefixes |= (prefixes & PREFIX_DATA);
11645 if ((rex & REX_W) || (sizeflag & DFLAG))
11647 oappend ("WORD PTR ");
11648 if (!(rex & REX_W))
11649 used_prefixes |= (prefixes & PREFIX_DATA);
11652 if (sizeflag & DFLAG)
11653 oappend ("QWORD PTR ");
11655 oappend ("DWORD PTR ");
11656 used_prefixes |= (prefixes & PREFIX_DATA);
11661 oappend ("DWORD PTR ");
11665 oappend ("QWORD PTR ");
11668 if (address_mode == mode_64bit)
11669 oappend ("QWORD PTR ");
11671 oappend ("DWORD PTR ");
11674 if (sizeflag & DFLAG)
11675 oappend ("FWORD PTR ");
11677 oappend ("DWORD PTR ");
11678 used_prefixes |= (prefixes & PREFIX_DATA);
11681 oappend ("TBYTE PTR ");
11687 switch (vex.length)
11690 oappend ("XMMWORD PTR ");
11693 oappend ("YMMWORD PTR ");
11700 oappend ("XMMWORD PTR ");
11703 oappend ("XMMWORD PTR ");
11709 switch (vex.length)
11712 oappend ("QWORD PTR ");
11715 oappend ("XMMWORD PTR ");
11725 switch (vex.length)
11728 oappend ("QWORD PTR ");
11731 oappend ("YMMWORD PTR ");
11738 oappend ("OWORD PTR ");
11740 case vex_w_dq_mode:
11745 oappend ("QWORD PTR ");
11747 oappend ("DWORD PTR ");
11755 OP_E_register (int bytemode, int sizeflag)
11757 int reg = modrm.rm;
11758 const char **names;
11764 if ((sizeflag & SUFFIX_ALWAYS)
11765 && (bytemode == b_swap_mode || bytemode == v_swap_mode))
11788 names = address_mode == mode_64bit ? names64 : names32;
11791 if (address_mode == mode_64bit && (sizeflag & DFLAG))
11809 if ((sizeflag & DFLAG)
11810 || (bytemode != v_mode
11811 && bytemode != v_swap_mode))
11815 used_prefixes |= (prefixes & PREFIX_DATA);
11821 oappend (INTERNAL_DISASSEMBLER_ERROR);
11824 oappend (names[reg]);
11828 OP_E_memory (int bytemode, int sizeflag)
11831 int add = (rex & REX_B) ? 8 : 0;
11836 intel_operand_size (bytemode, sizeflag);
11839 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
11841 /* 32/64 bit address mode */
11859 FETCH_DATA (the_info, codep + 1);
11860 index = (*codep >> 3) & 7;
11861 scale = (*codep >> 6) & 3;
11866 haveindex = index != 4;
11869 rbase = base + add;
11877 if (address_mode == mode_64bit && !havesib)
11883 FETCH_DATA (the_info, codep + 1);
11885 if ((disp & 0x80) != 0)
11893 /* In 32bit mode, we need index register to tell [offset] from
11894 [eiz*1 + offset]. */
11895 needindex = (havesib
11898 && address_mode == mode_32bit);
11899 havedisp = (havebase
11901 || (havesib && (haveindex || scale != 0)));
11904 if (modrm.mod != 0 || base == 5)
11906 if (havedisp || riprel)
11907 print_displacement (scratchbuf, disp);
11909 print_operand_value (scratchbuf, 1, disp);
11910 oappend (scratchbuf);
11914 oappend (sizeflag & AFLAG ? "(%rip)" : "(%eip)");
11918 if (havebase || haveindex || riprel)
11919 used_prefixes |= PREFIX_ADDR;
11921 if (havedisp || (intel_syntax && riprel))
11923 *obufp++ = open_char;
11924 if (intel_syntax && riprel)
11927 oappend (sizeflag & AFLAG ? "rip" : "eip");
11931 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
11932 ? names64[rbase] : names32[rbase]);
11935 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
11936 print index to tell base + index from base. */
11940 || (havebase && base != ESP_REG_NUM))
11942 if (!intel_syntax || havebase)
11944 *obufp++ = separator_char;
11948 oappend (address_mode == mode_64bit
11949 && (sizeflag & AFLAG)
11950 ? names64[index] : names32[index]);
11952 oappend (address_mode == mode_64bit
11953 && (sizeflag & AFLAG)
11954 ? index64 : index32);
11956 *obufp++ = scale_char;
11958 sprintf (scratchbuf, "%d", 1 << scale);
11959 oappend (scratchbuf);
11963 && (disp || modrm.mod != 0 || base == 5))
11965 if (!havedisp || (bfd_signed_vma) disp >= 0)
11970 else if (modrm.mod != 1 && disp != -disp)
11974 disp = - (bfd_signed_vma) disp;
11978 print_displacement (scratchbuf, disp);
11980 print_operand_value (scratchbuf, 1, disp);
11981 oappend (scratchbuf);
11984 *obufp++ = close_char;
11987 else if (intel_syntax)
11989 if (modrm.mod != 0 || base == 5)
11991 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
11992 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
11996 oappend (names_seg[ds_reg - es_reg]);
11999 print_operand_value (scratchbuf, 1, disp);
12000 oappend (scratchbuf);
12006 /* 16 bit address mode */
12007 used_prefixes |= prefixes & PREFIX_ADDR;
12014 if ((disp & 0x8000) != 0)
12019 FETCH_DATA (the_info, codep + 1);
12021 if ((disp & 0x80) != 0)
12026 if ((disp & 0x8000) != 0)
12032 if (modrm.mod != 0 || modrm.rm == 6)
12034 print_displacement (scratchbuf, disp);
12035 oappend (scratchbuf);
12038 if (modrm.mod != 0 || modrm.rm != 6)
12040 *obufp++ = open_char;
12042 oappend (index16[modrm.rm]);
12044 && (disp || modrm.mod != 0 || modrm.rm == 6))
12046 if ((bfd_signed_vma) disp >= 0)
12051 else if (modrm.mod != 1)
12055 disp = - (bfd_signed_vma) disp;
12058 print_displacement (scratchbuf, disp);
12059 oappend (scratchbuf);
12062 *obufp++ = close_char;
12065 else if (intel_syntax)
12067 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12068 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
12072 oappend (names_seg[ds_reg - es_reg]);
12075 print_operand_value (scratchbuf, 1, disp & 0xffff);
12076 oappend (scratchbuf);
12082 OP_E (int bytemode, int sizeflag)
12084 /* Skip mod/rm byte. */
12088 if (modrm.mod == 3)
12089 OP_E_register (bytemode, sizeflag);
12091 OP_E_memory (bytemode, sizeflag);
12095 OP_G (int bytemode, int sizeflag)
12106 oappend (names8rex[modrm.reg + add]);
12108 oappend (names8[modrm.reg + add]);
12111 oappend (names16[modrm.reg + add]);
12114 oappend (names32[modrm.reg + add]);
12117 oappend (names64[modrm.reg + add]);
12126 oappend (names64[modrm.reg + add]);
12129 if ((sizeflag & DFLAG) || bytemode != v_mode)
12130 oappend (names32[modrm.reg + add]);
12132 oappend (names16[modrm.reg + add]);
12133 used_prefixes |= (prefixes & PREFIX_DATA);
12137 if (address_mode == mode_64bit)
12138 oappend (names64[modrm.reg + add]);
12140 oappend (names32[modrm.reg + add]);
12143 oappend (INTERNAL_DISASSEMBLER_ERROR);
12156 FETCH_DATA (the_info, codep + 8);
12157 a = *codep++ & 0xff;
12158 a |= (*codep++ & 0xff) << 8;
12159 a |= (*codep++ & 0xff) << 16;
12160 a |= (*codep++ & 0xff) << 24;
12161 b = *codep++ & 0xff;
12162 b |= (*codep++ & 0xff) << 8;
12163 b |= (*codep++ & 0xff) << 16;
12164 b |= (*codep++ & 0xff) << 24;
12165 x = a + ((bfd_vma) b << 32);
12173 static bfd_signed_vma
12176 bfd_signed_vma x = 0;
12178 FETCH_DATA (the_info, codep + 4);
12179 x = *codep++ & (bfd_signed_vma) 0xff;
12180 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12181 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12182 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12186 static bfd_signed_vma
12189 bfd_signed_vma x = 0;
12191 FETCH_DATA (the_info, codep + 4);
12192 x = *codep++ & (bfd_signed_vma) 0xff;
12193 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
12194 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
12195 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
12197 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
12207 FETCH_DATA (the_info, codep + 2);
12208 x = *codep++ & 0xff;
12209 x |= (*codep++ & 0xff) << 8;
12214 set_op (bfd_vma op, int riprel)
12216 op_index[op_ad] = op_ad;
12217 if (address_mode == mode_64bit)
12219 op_address[op_ad] = op;
12220 op_riprel[op_ad] = riprel;
12224 /* Mask to get a 32-bit address. */
12225 op_address[op_ad] = op & 0xffffffff;
12226 op_riprel[op_ad] = riprel & 0xffffffff;
12231 OP_REG (int code, int sizeflag)
12243 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12244 case sp_reg: case bp_reg: case si_reg: case di_reg:
12245 s = names16[code - ax_reg + add];
12247 case es_reg: case ss_reg: case cs_reg:
12248 case ds_reg: case fs_reg: case gs_reg:
12249 s = names_seg[code - es_reg + add];
12251 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12252 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12255 s = names8rex[code - al_reg + add];
12257 s = names8[code - al_reg];
12259 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
12260 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
12261 if (address_mode == mode_64bit && (sizeflag & DFLAG))
12263 s = names64[code - rAX_reg + add];
12266 code += eAX_reg - rAX_reg;
12267 /* Fall through. */
12268 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12269 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12272 s = names64[code - eAX_reg + add];
12275 if (sizeflag & DFLAG)
12276 s = names32[code - eAX_reg + add];
12278 s = names16[code - eAX_reg + add];
12279 used_prefixes |= (prefixes & PREFIX_DATA);
12283 s = INTERNAL_DISASSEMBLER_ERROR;
12290 OP_IMREG (int code, int sizeflag)
12302 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
12303 case sp_reg: case bp_reg: case si_reg: case di_reg:
12304 s = names16[code - ax_reg];
12306 case es_reg: case ss_reg: case cs_reg:
12307 case ds_reg: case fs_reg: case gs_reg:
12308 s = names_seg[code - es_reg];
12310 case al_reg: case ah_reg: case cl_reg: case ch_reg:
12311 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
12314 s = names8rex[code - al_reg];
12316 s = names8[code - al_reg];
12318 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
12319 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
12322 s = names64[code - eAX_reg];
12325 if (sizeflag & DFLAG)
12326 s = names32[code - eAX_reg];
12328 s = names16[code - eAX_reg];
12329 used_prefixes |= (prefixes & PREFIX_DATA);
12332 case z_mode_ax_reg:
12333 if ((rex & REX_W) || (sizeflag & DFLAG))
12337 if (!(rex & REX_W))
12338 used_prefixes |= (prefixes & PREFIX_DATA);
12341 s = INTERNAL_DISASSEMBLER_ERROR;
12348 OP_I (int bytemode, int sizeflag)
12351 bfd_signed_vma mask = -1;
12356 FETCH_DATA (the_info, codep + 1);
12361 if (address_mode == mode_64bit)
12366 /* Fall through. */
12373 if (sizeflag & DFLAG)
12383 used_prefixes |= (prefixes & PREFIX_DATA);
12395 oappend (INTERNAL_DISASSEMBLER_ERROR);
12400 scratchbuf[0] = '$';
12401 print_operand_value (scratchbuf + 1, 1, op);
12402 oappend (scratchbuf + intel_syntax);
12403 scratchbuf[0] = '\0';
12407 OP_I64 (int bytemode, int sizeflag)
12410 bfd_signed_vma mask = -1;
12412 if (address_mode != mode_64bit)
12414 OP_I (bytemode, sizeflag);
12421 FETCH_DATA (the_info, codep + 1);
12431 if (sizeflag & DFLAG)
12441 used_prefixes |= (prefixes & PREFIX_DATA);
12449 oappend (INTERNAL_DISASSEMBLER_ERROR);
12454 scratchbuf[0] = '$';
12455 print_operand_value (scratchbuf + 1, 1, op);
12456 oappend (scratchbuf + intel_syntax);
12457 scratchbuf[0] = '\0';
12461 OP_sI (int bytemode, int sizeflag)
12464 bfd_signed_vma mask = -1;
12469 FETCH_DATA (the_info, codep + 1);
12471 if ((op & 0x80) != 0)
12481 if (sizeflag & DFLAG)
12490 if ((op & 0x8000) != 0)
12493 used_prefixes |= (prefixes & PREFIX_DATA);
12499 if ((op & 0x8000) != 0)
12503 oappend (INTERNAL_DISASSEMBLER_ERROR);
12507 scratchbuf[0] = '$';
12508 print_operand_value (scratchbuf + 1, 1, op);
12509 oappend (scratchbuf + intel_syntax);
12513 OP_J (int bytemode, int sizeflag)
12517 bfd_vma segment = 0;
12522 FETCH_DATA (the_info, codep + 1);
12524 if ((disp & 0x80) != 0)
12529 if ((sizeflag & DFLAG) || (rex & REX_W))
12534 if ((disp & 0x8000) != 0)
12536 /* In 16bit mode, address is wrapped around at 64k within
12537 the same segment. Otherwise, a data16 prefix on a jump
12538 instruction means that the pc is masked to 16 bits after
12539 the displacement is added! */
12541 if ((prefixes & PREFIX_DATA) == 0)
12542 segment = ((start_pc + codep - start_codep)
12543 & ~((bfd_vma) 0xffff));
12545 if (!(rex & REX_W))
12546 used_prefixes |= (prefixes & PREFIX_DATA);
12549 oappend (INTERNAL_DISASSEMBLER_ERROR);
12552 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
12554 print_operand_value (scratchbuf, 1, disp);
12555 oappend (scratchbuf);
12559 OP_SEG (int bytemode, int sizeflag)
12561 if (bytemode == w_mode)
12562 oappend (names_seg[modrm.reg]);
12564 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
12568 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
12572 if (sizeflag & DFLAG)
12582 used_prefixes |= (prefixes & PREFIX_DATA);
12584 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
12586 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
12587 oappend (scratchbuf);
12591 OP_OFF (int bytemode, int sizeflag)
12595 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12596 intel_operand_size (bytemode, sizeflag);
12599 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
12606 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12607 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12609 oappend (names_seg[ds_reg - es_reg]);
12613 print_operand_value (scratchbuf, 1, off);
12614 oappend (scratchbuf);
12618 OP_OFF64 (int bytemode, int sizeflag)
12622 if (address_mode != mode_64bit
12623 || (prefixes & PREFIX_ADDR))
12625 OP_OFF (bytemode, sizeflag);
12629 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
12630 intel_operand_size (bytemode, sizeflag);
12637 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
12638 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
12640 oappend (names_seg[ds_reg - es_reg]);
12644 print_operand_value (scratchbuf, 1, off);
12645 oappend (scratchbuf);
12649 ptr_reg (int code, int sizeflag)
12653 *obufp++ = open_char;
12654 used_prefixes |= (prefixes & PREFIX_ADDR);
12655 if (address_mode == mode_64bit)
12657 if (!(sizeflag & AFLAG))
12658 s = names32[code - eAX_reg];
12660 s = names64[code - eAX_reg];
12662 else if (sizeflag & AFLAG)
12663 s = names32[code - eAX_reg];
12665 s = names16[code - eAX_reg];
12667 *obufp++ = close_char;
12672 OP_ESreg (int code, int sizeflag)
12678 case 0x6d: /* insw/insl */
12679 intel_operand_size (z_mode, sizeflag);
12681 case 0xa5: /* movsw/movsl/movsq */
12682 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12683 case 0xab: /* stosw/stosl */
12684 case 0xaf: /* scasw/scasl */
12685 intel_operand_size (v_mode, sizeflag);
12688 intel_operand_size (b_mode, sizeflag);
12691 oappend ("%es:" + intel_syntax);
12692 ptr_reg (code, sizeflag);
12696 OP_DSreg (int code, int sizeflag)
12702 case 0x6f: /* outsw/outsl */
12703 intel_operand_size (z_mode, sizeflag);
12705 case 0xa5: /* movsw/movsl/movsq */
12706 case 0xa7: /* cmpsw/cmpsl/cmpsq */
12707 case 0xad: /* lodsw/lodsl/lodsq */
12708 intel_operand_size (v_mode, sizeflag);
12711 intel_operand_size (b_mode, sizeflag);
12720 | PREFIX_GS)) == 0)
12721 prefixes |= PREFIX_DS;
12723 ptr_reg (code, sizeflag);
12727 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12735 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
12737 all_prefixes[last_lock_prefix] = 0;
12738 used_prefixes |= PREFIX_LOCK;
12743 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
12744 oappend (scratchbuf + intel_syntax);
12748 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12757 sprintf (scratchbuf, "db%d", modrm.reg + add);
12759 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
12760 oappend (scratchbuf);
12764 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12766 sprintf (scratchbuf, "%%tr%d", modrm.reg);
12767 oappend (scratchbuf + intel_syntax);
12771 OP_R (int bytemode, int sizeflag)
12773 if (modrm.mod == 3)
12774 OP_E (bytemode, sizeflag);
12780 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12782 used_prefixes |= (prefixes & PREFIX_DATA);
12783 if (prefixes & PREFIX_DATA)
12791 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12794 sprintf (scratchbuf, "%%mm%d", modrm.reg);
12795 oappend (scratchbuf + intel_syntax);
12799 OP_XMM (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
12807 if (need_vex && bytemode != xmm_mode)
12809 switch (vex.length)
12812 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12815 sprintf (scratchbuf, "%%ymm%d", modrm.reg + add);
12822 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
12823 oappend (scratchbuf + intel_syntax);
12827 OP_EM (int bytemode, int sizeflag)
12829 if (modrm.mod != 3)
12832 && (bytemode == v_mode || bytemode == v_swap_mode))
12834 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
12835 used_prefixes |= (prefixes & PREFIX_DATA);
12837 OP_E (bytemode, sizeflag);
12841 if ((sizeflag & SUFFIX_ALWAYS) && bytemode == v_swap_mode)
12844 /* Skip mod/rm byte. */
12847 used_prefixes |= (prefixes & PREFIX_DATA);
12848 if (prefixes & PREFIX_DATA)
12857 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12860 sprintf (scratchbuf, "%%mm%d", modrm.rm);
12861 oappend (scratchbuf + intel_syntax);
12864 /* cvt* are the only instructions in sse2 which have
12865 both SSE and MMX operands and also have 0x66 prefix
12866 in their opcode. 0x66 was originally used to differentiate
12867 between SSE and MMX instruction(operands). So we have to handle the
12868 cvt* separately using OP_EMC and OP_MXC */
12870 OP_EMC (int bytemode, int sizeflag)
12872 if (modrm.mod != 3)
12874 if (intel_syntax && bytemode == v_mode)
12876 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
12877 used_prefixes |= (prefixes & PREFIX_DATA);
12879 OP_E (bytemode, sizeflag);
12883 /* Skip mod/rm byte. */
12886 used_prefixes |= (prefixes & PREFIX_DATA);
12887 sprintf (scratchbuf, "%%mm%d", modrm.rm);
12888 oappend (scratchbuf + intel_syntax);
12892 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
12894 used_prefixes |= (prefixes & PREFIX_DATA);
12895 sprintf (scratchbuf, "%%mm%d", modrm.reg);
12896 oappend (scratchbuf + intel_syntax);
12900 OP_EX (int bytemode, int sizeflag)
12904 /* Skip mod/rm byte. */
12908 if (modrm.mod != 3)
12910 OP_E_memory (bytemode, sizeflag);
12920 if ((sizeflag & SUFFIX_ALWAYS)
12921 && (bytemode == x_swap_mode
12922 || bytemode == d_swap_mode
12923 || bytemode == q_swap_mode))
12927 && bytemode != xmm_mode
12928 && bytemode != xmmq_mode)
12930 switch (vex.length)
12933 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12936 sprintf (scratchbuf, "%%ymm%d", modrm.rm + add);
12943 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
12944 oappend (scratchbuf + intel_syntax);
12948 OP_MS (int bytemode, int sizeflag)
12950 if (modrm.mod == 3)
12951 OP_EM (bytemode, sizeflag);
12957 OP_XS (int bytemode, int sizeflag)
12959 if (modrm.mod == 3)
12960 OP_EX (bytemode, sizeflag);
12966 OP_M (int bytemode, int sizeflag)
12968 if (modrm.mod == 3)
12969 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
12972 OP_E (bytemode, sizeflag);
12976 OP_0f07 (int bytemode, int sizeflag)
12978 if (modrm.mod != 3 || modrm.rm != 0)
12981 OP_E (bytemode, sizeflag);
12984 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
12985 32bit mode and "xchg %rax,%rax" in 64bit mode. */
12988 NOP_Fixup1 (int bytemode, int sizeflag)
12990 if ((prefixes & PREFIX_DATA) != 0
12993 && address_mode == mode_64bit))
12994 OP_REG (bytemode, sizeflag);
12996 strcpy (obuf, "nop");
13000 NOP_Fixup2 (int bytemode, int sizeflag)
13002 if ((prefixes & PREFIX_DATA) != 0
13005 && address_mode == mode_64bit))
13006 OP_IMREG (bytemode, sizeflag);
13009 static const char *const Suffix3DNow[] = {
13010 /* 00 */ NULL, NULL, NULL, NULL,
13011 /* 04 */ NULL, NULL, NULL, NULL,
13012 /* 08 */ NULL, NULL, NULL, NULL,
13013 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
13014 /* 10 */ NULL, NULL, NULL, NULL,
13015 /* 14 */ NULL, NULL, NULL, NULL,
13016 /* 18 */ NULL, NULL, NULL, NULL,
13017 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
13018 /* 20 */ NULL, NULL, NULL, NULL,
13019 /* 24 */ NULL, NULL, NULL, NULL,
13020 /* 28 */ NULL, NULL, NULL, NULL,
13021 /* 2C */ NULL, NULL, NULL, NULL,
13022 /* 30 */ NULL, NULL, NULL, NULL,
13023 /* 34 */ NULL, NULL, NULL, NULL,
13024 /* 38 */ NULL, NULL, NULL, NULL,
13025 /* 3C */ NULL, NULL, NULL, NULL,
13026 /* 40 */ NULL, NULL, NULL, NULL,
13027 /* 44 */ NULL, NULL, NULL, NULL,
13028 /* 48 */ NULL, NULL, NULL, NULL,
13029 /* 4C */ NULL, NULL, NULL, NULL,
13030 /* 50 */ NULL, NULL, NULL, NULL,
13031 /* 54 */ NULL, NULL, NULL, NULL,
13032 /* 58 */ NULL, NULL, NULL, NULL,
13033 /* 5C */ NULL, NULL, NULL, NULL,
13034 /* 60 */ NULL, NULL, NULL, NULL,
13035 /* 64 */ NULL, NULL, NULL, NULL,
13036 /* 68 */ NULL, NULL, NULL, NULL,
13037 /* 6C */ NULL, NULL, NULL, NULL,
13038 /* 70 */ NULL, NULL, NULL, NULL,
13039 /* 74 */ NULL, NULL, NULL, NULL,
13040 /* 78 */ NULL, NULL, NULL, NULL,
13041 /* 7C */ NULL, NULL, NULL, NULL,
13042 /* 80 */ NULL, NULL, NULL, NULL,
13043 /* 84 */ NULL, NULL, NULL, NULL,
13044 /* 88 */ NULL, NULL, "pfnacc", NULL,
13045 /* 8C */ NULL, NULL, "pfpnacc", NULL,
13046 /* 90 */ "pfcmpge", NULL, NULL, NULL,
13047 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
13048 /* 98 */ NULL, NULL, "pfsub", NULL,
13049 /* 9C */ NULL, NULL, "pfadd", NULL,
13050 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
13051 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
13052 /* A8 */ NULL, NULL, "pfsubr", NULL,
13053 /* AC */ NULL, NULL, "pfacc", NULL,
13054 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
13055 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
13056 /* B8 */ NULL, NULL, NULL, "pswapd",
13057 /* BC */ NULL, NULL, NULL, "pavgusb",
13058 /* C0 */ NULL, NULL, NULL, NULL,
13059 /* C4 */ NULL, NULL, NULL, NULL,
13060 /* C8 */ NULL, NULL, NULL, NULL,
13061 /* CC */ NULL, NULL, NULL, NULL,
13062 /* D0 */ NULL, NULL, NULL, NULL,
13063 /* D4 */ NULL, NULL, NULL, NULL,
13064 /* D8 */ NULL, NULL, NULL, NULL,
13065 /* DC */ NULL, NULL, NULL, NULL,
13066 /* E0 */ NULL, NULL, NULL, NULL,
13067 /* E4 */ NULL, NULL, NULL, NULL,
13068 /* E8 */ NULL, NULL, NULL, NULL,
13069 /* EC */ NULL, NULL, NULL, NULL,
13070 /* F0 */ NULL, NULL, NULL, NULL,
13071 /* F4 */ NULL, NULL, NULL, NULL,
13072 /* F8 */ NULL, NULL, NULL, NULL,
13073 /* FC */ NULL, NULL, NULL, NULL,
13077 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13079 const char *mnemonic;
13081 FETCH_DATA (the_info, codep + 1);
13082 /* AMD 3DNow! instructions are specified by an opcode suffix in the
13083 place where an 8-bit immediate would normally go. ie. the last
13084 byte of the instruction. */
13085 obufp = mnemonicendp;
13086 mnemonic = Suffix3DNow[*codep++ & 0xff];
13088 oappend (mnemonic);
13091 /* Since a variable sized modrm/sib chunk is between the start
13092 of the opcode (0x0f0f) and the opcode suffix, we need to do
13093 all the modrm processing first, and don't know until now that
13094 we have a bad opcode. This necessitates some cleaning up. */
13095 op_out[0][0] = '\0';
13096 op_out[1][0] = '\0';
13099 mnemonicendp = obufp;
13102 static struct op simd_cmp_op[] =
13104 { STRING_COMMA_LEN ("eq") },
13105 { STRING_COMMA_LEN ("lt") },
13106 { STRING_COMMA_LEN ("le") },
13107 { STRING_COMMA_LEN ("unord") },
13108 { STRING_COMMA_LEN ("neq") },
13109 { STRING_COMMA_LEN ("nlt") },
13110 { STRING_COMMA_LEN ("nle") },
13111 { STRING_COMMA_LEN ("ord") }
13115 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13117 unsigned int cmp_type;
13119 FETCH_DATA (the_info, codep + 1);
13120 cmp_type = *codep++ & 0xff;
13121 if (cmp_type < ARRAY_SIZE (simd_cmp_op))
13124 char *p = mnemonicendp - 2;
13128 sprintf (p, "%s%s", simd_cmp_op[cmp_type].name, suffix);
13129 mnemonicendp += simd_cmp_op[cmp_type].len;
13133 /* We have a reserved extension byte. Output it directly. */
13134 scratchbuf[0] = '$';
13135 print_operand_value (scratchbuf + 1, 1, cmp_type);
13136 oappend (scratchbuf + intel_syntax);
13137 scratchbuf[0] = '\0';
13142 OP_Mwait (int bytemode ATTRIBUTE_UNUSED,
13143 int sizeflag ATTRIBUTE_UNUSED)
13145 /* mwait %eax,%ecx */
13148 const char **names = (address_mode == mode_64bit
13149 ? names64 : names32);
13150 strcpy (op_out[0], names[0]);
13151 strcpy (op_out[1], names[1]);
13152 two_source_ops = 1;
13154 /* Skip mod/rm byte. */
13160 OP_Monitor (int bytemode ATTRIBUTE_UNUSED,
13161 int sizeflag ATTRIBUTE_UNUSED)
13163 /* monitor %eax,%ecx,%edx" */
13166 const char **op1_names;
13167 const char **names = (address_mode == mode_64bit
13168 ? names64 : names32);
13170 if (!(prefixes & PREFIX_ADDR))
13171 op1_names = (address_mode == mode_16bit
13172 ? names16 : names);
13175 /* Remove "addr16/addr32". */
13176 all_prefixes[last_addr_prefix] = 0;
13177 op1_names = (address_mode != mode_32bit
13178 ? names32 : names16);
13179 used_prefixes |= PREFIX_ADDR;
13181 strcpy (op_out[0], op1_names[0]);
13182 strcpy (op_out[1], names[1]);
13183 strcpy (op_out[2], names[2]);
13184 two_source_ops = 1;
13186 /* Skip mod/rm byte. */
13194 /* Throw away prefixes and 1st. opcode byte. */
13195 codep = insn_codep + 1;
13200 REP_Fixup (int bytemode, int sizeflag)
13202 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
13204 if (prefixes & PREFIX_REPZ)
13205 all_prefixes[last_repz_prefix] = REP_PREFIX;
13212 OP_IMREG (bytemode, sizeflag);
13215 OP_ESreg (bytemode, sizeflag);
13218 OP_DSreg (bytemode, sizeflag);
13227 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
13232 /* Change cmpxchg8b to cmpxchg16b. */
13233 char *p = mnemonicendp - 2;
13234 mnemonicendp = stpcpy (p, "16b");
13237 OP_M (bytemode, sizeflag);
13241 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
13245 switch (vex.length)
13248 sprintf (scratchbuf, "%%xmm%d", reg);
13251 sprintf (scratchbuf, "%%ymm%d", reg);
13258 sprintf (scratchbuf, "%%xmm%d", reg);
13259 oappend (scratchbuf + intel_syntax);
13263 CRC32_Fixup (int bytemode, int sizeflag)
13265 /* Add proper suffix to "crc32". */
13266 char *p = mnemonicendp;
13285 if (sizeflag & DFLAG)
13289 used_prefixes |= (prefixes & PREFIX_DATA);
13293 oappend (INTERNAL_DISASSEMBLER_ERROR);
13300 if (modrm.mod == 3)
13304 /* Skip mod/rm byte. */
13309 add = (rex & REX_B) ? 8 : 0;
13310 if (bytemode == b_mode)
13314 oappend (names8rex[modrm.rm + add]);
13316 oappend (names8[modrm.rm + add]);
13322 oappend (names64[modrm.rm + add]);
13323 else if ((prefixes & PREFIX_DATA))
13324 oappend (names16[modrm.rm + add]);
13326 oappend (names32[modrm.rm + add]);
13330 OP_E (bytemode, sizeflag);
13333 /* Display the destination register operand for instructions with
13337 OP_VEX (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13345 switch (vex.length)
13358 sprintf (scratchbuf, "%%xmm%d", vex.register_specifier);
13371 sprintf (scratchbuf, "%%ymm%d", vex.register_specifier);
13377 oappend (scratchbuf + intel_syntax);
13380 /* Get the VEX immediate byte without moving codep. */
13382 static unsigned char
13383 get_vex_imm8 (int sizeflag)
13385 int bytes_before_imm = 0;
13387 /* Skip mod/rm byte. */
13391 if (modrm.mod != 3)
13393 /* There are SIB/displacement bytes. */
13394 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
13396 /* 32/64 bit address mode */
13397 int base = modrm.rm;
13399 /* Check SIB byte. */
13402 FETCH_DATA (the_info, codep + 1);
13404 bytes_before_imm++;
13410 /* When modrm.rm == 5 or modrm.rm == 4 and base in
13411 SIB == 5, there is a 4 byte displacement. */
13413 /* No displacement. */
13416 /* 4 byte displacement. */
13417 bytes_before_imm += 4;
13420 /* 1 byte displacement. */
13421 bytes_before_imm++;
13426 { /* 16 bit address mode */
13430 /* When modrm.rm == 6, there is a 2 byte displacement. */
13432 /* No displacement. */
13435 /* 2 byte displacement. */
13436 bytes_before_imm += 2;
13439 /* 1 byte displacement. */
13440 bytes_before_imm++;
13446 FETCH_DATA (the_info, codep + bytes_before_imm + 1);
13447 return codep [bytes_before_imm];
13451 OP_EX_VexReg (int bytemode, int sizeflag, int reg)
13453 if (reg == -1 && modrm.mod != 3)
13455 OP_E_memory (bytemode, sizeflag);
13467 else if (reg > 7 && address_mode != mode_64bit)
13471 switch (vex.length)
13474 sprintf (scratchbuf, "%%xmm%d", reg);
13477 sprintf (scratchbuf, "%%ymm%d", reg);
13482 oappend (scratchbuf + intel_syntax);
13486 OP_EX_VexW (int bytemode, int sizeflag)
13494 reg = get_vex_imm8 (sizeflag) >> 4;
13499 reg = get_vex_imm8 (sizeflag) >> 4;
13502 OP_EX_VexReg (bytemode, sizeflag, reg);
13506 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED,
13507 int sizeflag ATTRIBUTE_UNUSED)
13509 /* Skip the immediate byte and check for invalid bits. */
13510 FETCH_DATA (the_info, codep + 1);
13511 if (*codep++ & 0xf)
13516 OP_REG_VexI4 (int bytemode, int sizeflag ATTRIBUTE_UNUSED)
13519 FETCH_DATA (the_info, codep + 1);
13522 if (bytemode != x_mode)
13529 if (reg > 7 && address_mode != mode_64bit)
13532 switch (vex.length)
13535 sprintf (scratchbuf, "%%xmm%d", reg);
13538 sprintf (scratchbuf, "%%ymm%d", reg);
13543 oappend (scratchbuf + intel_syntax);
13547 OP_XMM_VexW (int bytemode, int sizeflag)
13549 /* Turn off the REX.W bit since it is used for swapping operands
13552 OP_XMM (bytemode, sizeflag);
13556 OP_EX_Vex (int bytemode, int sizeflag)
13558 if (modrm.mod != 3)
13560 if (vex.register_specifier != 0)
13564 OP_EX (bytemode, sizeflag);
13568 OP_XMM_Vex (int bytemode, int sizeflag)
13570 if (modrm.mod != 3)
13572 if (vex.register_specifier != 0)
13576 OP_XMM (bytemode, sizeflag);
13580 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13582 switch (vex.length)
13585 mnemonicendp = stpcpy (obuf, "vzeroupper");
13588 mnemonicendp = stpcpy (obuf, "vzeroall");
13595 static struct op vex_cmp_op[] =
13597 { STRING_COMMA_LEN ("eq") },
13598 { STRING_COMMA_LEN ("lt") },
13599 { STRING_COMMA_LEN ("le") },
13600 { STRING_COMMA_LEN ("unord") },
13601 { STRING_COMMA_LEN ("neq") },
13602 { STRING_COMMA_LEN ("nlt") },
13603 { STRING_COMMA_LEN ("nle") },
13604 { STRING_COMMA_LEN ("ord") },
13605 { STRING_COMMA_LEN ("eq_uq") },
13606 { STRING_COMMA_LEN ("nge") },
13607 { STRING_COMMA_LEN ("ngt") },
13608 { STRING_COMMA_LEN ("false") },
13609 { STRING_COMMA_LEN ("neq_oq") },
13610 { STRING_COMMA_LEN ("ge") },
13611 { STRING_COMMA_LEN ("gt") },
13612 { STRING_COMMA_LEN ("true") },
13613 { STRING_COMMA_LEN ("eq_os") },
13614 { STRING_COMMA_LEN ("lt_oq") },
13615 { STRING_COMMA_LEN ("le_oq") },
13616 { STRING_COMMA_LEN ("unord_s") },
13617 { STRING_COMMA_LEN ("neq_us") },
13618 { STRING_COMMA_LEN ("nlt_uq") },
13619 { STRING_COMMA_LEN ("nle_uq") },
13620 { STRING_COMMA_LEN ("ord_s") },
13621 { STRING_COMMA_LEN ("eq_us") },
13622 { STRING_COMMA_LEN ("nge_uq") },
13623 { STRING_COMMA_LEN ("ngt_uq") },
13624 { STRING_COMMA_LEN ("false_os") },
13625 { STRING_COMMA_LEN ("neq_os") },
13626 { STRING_COMMA_LEN ("ge_oq") },
13627 { STRING_COMMA_LEN ("gt_oq") },
13628 { STRING_COMMA_LEN ("true_us") },
13632 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13634 unsigned int cmp_type;
13636 FETCH_DATA (the_info, codep + 1);
13637 cmp_type = *codep++ & 0xff;
13638 if (cmp_type < ARRAY_SIZE (vex_cmp_op))
13641 char *p = mnemonicendp - 2;
13645 sprintf (p, "%s%s", vex_cmp_op[cmp_type].name, suffix);
13646 mnemonicendp += vex_cmp_op[cmp_type].len;
13650 /* We have a reserved extension byte. Output it directly. */
13651 scratchbuf[0] = '$';
13652 print_operand_value (scratchbuf + 1, 1, cmp_type);
13653 oappend (scratchbuf + intel_syntax);
13654 scratchbuf[0] = '\0';
13658 static const struct op pclmul_op[] =
13660 { STRING_COMMA_LEN ("lql") },
13661 { STRING_COMMA_LEN ("hql") },
13662 { STRING_COMMA_LEN ("lqh") },
13663 { STRING_COMMA_LEN ("hqh") }
13667 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED,
13668 int sizeflag ATTRIBUTE_UNUSED)
13670 unsigned int pclmul_type;
13672 FETCH_DATA (the_info, codep + 1);
13673 pclmul_type = *codep++ & 0xff;
13674 switch (pclmul_type)
13685 if (pclmul_type < ARRAY_SIZE (pclmul_op))
13688 char *p = mnemonicendp - 3;
13693 sprintf (p, "%s%s", pclmul_op[pclmul_type].name, suffix);
13694 mnemonicendp += pclmul_op[pclmul_type].len;
13698 /* We have a reserved extension byte. Output it directly. */
13699 scratchbuf[0] = '$';
13700 print_operand_value (scratchbuf + 1, 1, pclmul_type);
13701 oappend (scratchbuf + intel_syntax);
13702 scratchbuf[0] = '\0';
13707 MOVBE_Fixup (int bytemode, int sizeflag)
13709 /* Add proper suffix to "movbe". */
13710 char *p = mnemonicendp;
13719 if (sizeflag & SUFFIX_ALWAYS)
13725 if (sizeflag & DFLAG)
13729 used_prefixes |= (prefixes & PREFIX_DATA);
13734 oappend (INTERNAL_DISASSEMBLER_ERROR);
13741 OP_M (bytemode, sizeflag);
13745 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13748 const char **names;
13750 /* Skip mod/rm byte. */
13756 else if (vex.length == 256)
13766 oappend (names[reg]);
13770 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
13772 const char **names;
13776 else if (vex.length == 256)
13781 oappend (names[vex.register_specifier]);
13785 OP_LWP_I (int bytemode ATTRIBUTE_UNUSED, int sizeflag)
13787 if (vex.w || vex.length == 256)
13788 OP_I (q_mode, sizeflag);
13790 OP_I (w_mode, sizeflag);