1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright (C) 1988-2015 Free Software Foundation, Inc.
4 This file is part of the GNU opcodes library.
6 This library is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 It is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
14 License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
22 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
24 modified by John Hassey (hassey@dg-rtp.dg.com)
25 x86-64 support added by Jan Hubicka (jh@suse.cz)
26 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
28 /* The main tables describing the instructions is essentially a copy
29 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
30 Programmers Manual. Usually, there is a capital letter, followed
31 by a small letter. The capital letter tell the addressing mode,
32 and the small letter tells about the operand size. Refer to
33 the Intel manual for details. */
38 #include "opcode/i386.h"
39 #include "libiberty.h"
43 static int print_insn (bfd_vma
, disassemble_info
*);
44 static void dofloat (int);
45 static void OP_ST (int, int);
46 static void OP_STi (int, int);
47 static int putop (const char *, int);
48 static void oappend (const char *);
49 static void append_seg (void);
50 static void OP_indirE (int, int);
51 static void print_operand_value (char *, int, bfd_vma
);
52 static void OP_E_register (int, int);
53 static void OP_E_memory (int, int);
54 static void print_displacement (char *, bfd_vma
);
55 static void OP_E (int, int);
56 static void OP_G (int, int);
57 static bfd_vma
get64 (void);
58 static bfd_signed_vma
get32 (void);
59 static bfd_signed_vma
get32s (void);
60 static int get16 (void);
61 static void set_op (bfd_vma
, int);
62 static void OP_Skip_MODRM (int, int);
63 static void OP_REG (int, int);
64 static void OP_IMREG (int, int);
65 static void OP_I (int, int);
66 static void OP_I64 (int, int);
67 static void OP_sI (int, int);
68 static void OP_J (int, int);
69 static void OP_SEG (int, int);
70 static void OP_DIR (int, int);
71 static void OP_OFF (int, int);
72 static void OP_OFF64 (int, int);
73 static void ptr_reg (int, int);
74 static void OP_ESreg (int, int);
75 static void OP_DSreg (int, int);
76 static void OP_C (int, int);
77 static void OP_D (int, int);
78 static void OP_T (int, int);
79 static void OP_R (int, int);
80 static void OP_MMX (int, int);
81 static void OP_XMM (int, int);
82 static void OP_EM (int, int);
83 static void OP_EX (int, int);
84 static void OP_EMC (int,int);
85 static void OP_MXC (int,int);
86 static void OP_MS (int, int);
87 static void OP_XS (int, int);
88 static void OP_M (int, int);
89 static void OP_VEX (int, int);
90 static void OP_EX_Vex (int, int);
91 static void OP_EX_VexW (int, int);
92 static void OP_EX_VexImmW (int, int);
93 static void OP_XMM_Vex (int, int);
94 static void OP_XMM_VexW (int, int);
95 static void OP_Rounding (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 VPCMP_Fixup (int, int);
102 static void OP_0f07 (int, int);
103 static void OP_Monitor (int, int);
104 static void OP_Mwait (int, int);
105 static void NOP_Fixup1 (int, int);
106 static void NOP_Fixup2 (int, int);
107 static void OP_3DNowSuffix (int, int);
108 static void CMP_Fixup (int, int);
109 static void BadOp (void);
110 static void REP_Fixup (int, int);
111 static void BND_Fixup (int, int);
112 static void HLE_Fixup1 (int, int);
113 static void HLE_Fixup2 (int, int);
114 static void HLE_Fixup3 (int, int);
115 static void CMPXCHG8B_Fixup (int, int);
116 static void XMM_Fixup (int, int);
117 static void CRC32_Fixup (int, int);
118 static void FXSAVE_Fixup (int, int);
119 static void OP_LWPCB_E (int, int);
120 static void OP_LWP_E (int, int);
121 static void OP_Vex_2src_1 (int, int);
122 static void OP_Vex_2src_2 (int, int);
124 static void MOVBE_Fixup (int, int);
126 static void OP_Mask (int, int);
129 /* Points to first byte not fetched. */
130 bfd_byte
*max_fetched
;
131 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
134 OPCODES_SIGJMP_BUF bailout
;
144 enum address_mode address_mode
;
146 /* Flags for the prefixes for the current instruction. See below. */
149 /* REX prefix the current instruction. See below. */
151 /* Bits of REX we've already used. */
153 /* REX bits in original REX prefix ignored. */
154 static int rex_ignored
;
155 /* Mark parts used in the REX prefix. When we are testing for
156 empty prefix (for 8bit register REX extension), just mask it
157 out. Otherwise test for REX bit is excuse for existence of REX
158 only in case value is nonzero. */
159 #define USED_REX(value) \
164 rex_used |= (value) | REX_OPCODE; \
167 rex_used |= REX_OPCODE; \
170 /* Flags for prefixes which we somehow handled when printing the
171 current instruction. */
172 static int used_prefixes
;
174 /* Flags stored in PREFIXES. */
175 #define PREFIX_REPZ 1
176 #define PREFIX_REPNZ 2
177 #define PREFIX_LOCK 4
179 #define PREFIX_SS 0x10
180 #define PREFIX_DS 0x20
181 #define PREFIX_ES 0x40
182 #define PREFIX_FS 0x80
183 #define PREFIX_GS 0x100
184 #define PREFIX_DATA 0x200
185 #define PREFIX_ADDR 0x400
186 #define PREFIX_FWAIT 0x800
188 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
189 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
191 #define FETCH_DATA(info, addr) \
192 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
193 ? 1 : fetch_data ((info), (addr)))
196 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
199 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
200 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
202 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
203 status
= (*info
->read_memory_func
) (start
,
205 addr
- priv
->max_fetched
,
211 /* If we did manage to read at least one byte, then
212 print_insn_i386 will do something sensible. Otherwise, print
213 an error. We do that here because this is where we know
215 if (priv
->max_fetched
== priv
->the_buffer
)
216 (*info
->memory_error_func
) (status
, start
, info
);
217 OPCODES_SIGLONGJMP (priv
->bailout
, 1);
220 priv
->max_fetched
= addr
;
224 /* Possible values for prefix requirement. */
225 #define PREFIX_IGNORED_SHIFT 16
226 #define PREFIX_IGNORED_REPZ (PREFIX_REPZ << PREFIX_IGNORED_SHIFT)
227 #define PREFIX_IGNORED_REPNZ (PREFIX_REPNZ << PREFIX_IGNORED_SHIFT)
228 #define PREFIX_IGNORED_DATA (PREFIX_DATA << PREFIX_IGNORED_SHIFT)
229 #define PREFIX_IGNORED_ADDR (PREFIX_ADDR << PREFIX_IGNORED_SHIFT)
230 #define PREFIX_IGNORED_LOCK (PREFIX_LOCK << PREFIX_IGNORED_SHIFT)
232 /* Opcode prefixes. */
233 #define PREFIX_OPCODE (PREFIX_REPZ \
237 /* Prefixes ignored. */
238 #define PREFIX_IGNORED (PREFIX_IGNORED_REPZ \
239 | PREFIX_IGNORED_REPNZ \
240 | PREFIX_IGNORED_DATA)
242 #define XX { NULL, 0 }
243 #define Bad_Opcode NULL, { { NULL, 0 } }, 0
245 #define Eb { OP_E, b_mode }
246 #define Ebnd { OP_E, bnd_mode }
247 #define EbS { OP_E, b_swap_mode }
248 #define Ev { OP_E, v_mode }
249 #define Ev_bnd { OP_E, v_bnd_mode }
250 #define EvS { OP_E, v_swap_mode }
251 #define Ed { OP_E, d_mode }
252 #define Edq { OP_E, dq_mode }
253 #define Edqw { OP_E, dqw_mode }
254 #define EdqwS { OP_E, dqw_swap_mode }
255 #define Edqb { OP_E, dqb_mode }
256 #define Edb { OP_E, db_mode }
257 #define Edw { OP_E, dw_mode }
258 #define Edqd { OP_E, dqd_mode }
259 #define Eq { OP_E, q_mode }
260 #define indirEv { OP_indirE, stack_v_mode }
261 #define indirEp { OP_indirE, f_mode }
262 #define stackEv { OP_E, stack_v_mode }
263 #define Em { OP_E, m_mode }
264 #define Ew { OP_E, w_mode }
265 #define M { OP_M, 0 } /* lea, lgdt, etc. */
266 #define Ma { OP_M, a_mode }
267 #define Mb { OP_M, b_mode }
268 #define Md { OP_M, d_mode }
269 #define Mo { OP_M, o_mode }
270 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
271 #define Mq { OP_M, q_mode }
272 #define Mx { OP_M, x_mode }
273 #define Mxmm { OP_M, xmm_mode }
274 #define Gb { OP_G, b_mode }
275 #define Gbnd { OP_G, bnd_mode }
276 #define Gv { OP_G, v_mode }
277 #define Gd { OP_G, d_mode }
278 #define Gdq { OP_G, dq_mode }
279 #define Gm { OP_G, m_mode }
280 #define Gw { OP_G, w_mode }
281 #define Rd { OP_R, d_mode }
282 #define Rdq { OP_R, dq_mode }
283 #define Rm { OP_R, m_mode }
284 #define Ib { OP_I, b_mode }
285 #define sIb { OP_sI, b_mode } /* sign extened byte */
286 #define sIbT { OP_sI, b_T_mode } /* sign extened byte like 'T' */
287 #define Iv { OP_I, v_mode }
288 #define sIv { OP_sI, v_mode }
289 #define Iq { OP_I, q_mode }
290 #define Iv64 { OP_I64, v_mode }
291 #define Iw { OP_I, w_mode }
292 #define I1 { OP_I, const_1_mode }
293 #define Jb { OP_J, b_mode }
294 #define Jv { OP_J, v_mode }
295 #define Cm { OP_C, m_mode }
296 #define Dm { OP_D, m_mode }
297 #define Td { OP_T, d_mode }
298 #define Skip_MODRM { OP_Skip_MODRM, 0 }
300 #define RMeAX { OP_REG, eAX_reg }
301 #define RMeBX { OP_REG, eBX_reg }
302 #define RMeCX { OP_REG, eCX_reg }
303 #define RMeDX { OP_REG, eDX_reg }
304 #define RMeSP { OP_REG, eSP_reg }
305 #define RMeBP { OP_REG, eBP_reg }
306 #define RMeSI { OP_REG, eSI_reg }
307 #define RMeDI { OP_REG, eDI_reg }
308 #define RMrAX { OP_REG, rAX_reg }
309 #define RMrBX { OP_REG, rBX_reg }
310 #define RMrCX { OP_REG, rCX_reg }
311 #define RMrDX { OP_REG, rDX_reg }
312 #define RMrSP { OP_REG, rSP_reg }
313 #define RMrBP { OP_REG, rBP_reg }
314 #define RMrSI { OP_REG, rSI_reg }
315 #define RMrDI { OP_REG, rDI_reg }
316 #define RMAL { OP_REG, al_reg }
317 #define RMCL { OP_REG, cl_reg }
318 #define RMDL { OP_REG, dl_reg }
319 #define RMBL { OP_REG, bl_reg }
320 #define RMAH { OP_REG, ah_reg }
321 #define RMCH { OP_REG, ch_reg }
322 #define RMDH { OP_REG, dh_reg }
323 #define RMBH { OP_REG, bh_reg }
324 #define RMAX { OP_REG, ax_reg }
325 #define RMDX { OP_REG, dx_reg }
327 #define eAX { OP_IMREG, eAX_reg }
328 #define eBX { OP_IMREG, eBX_reg }
329 #define eCX { OP_IMREG, eCX_reg }
330 #define eDX { OP_IMREG, eDX_reg }
331 #define eSP { OP_IMREG, eSP_reg }
332 #define eBP { OP_IMREG, eBP_reg }
333 #define eSI { OP_IMREG, eSI_reg }
334 #define eDI { OP_IMREG, eDI_reg }
335 #define AL { OP_IMREG, al_reg }
336 #define CL { OP_IMREG, cl_reg }
337 #define DL { OP_IMREG, dl_reg }
338 #define BL { OP_IMREG, bl_reg }
339 #define AH { OP_IMREG, ah_reg }
340 #define CH { OP_IMREG, ch_reg }
341 #define DH { OP_IMREG, dh_reg }
342 #define BH { OP_IMREG, bh_reg }
343 #define AX { OP_IMREG, ax_reg }
344 #define DX { OP_IMREG, dx_reg }
345 #define zAX { OP_IMREG, z_mode_ax_reg }
346 #define indirDX { OP_IMREG, indir_dx_reg }
348 #define Sw { OP_SEG, w_mode }
349 #define Sv { OP_SEG, v_mode }
350 #define Ap { OP_DIR, 0 }
351 #define Ob { OP_OFF64, b_mode }
352 #define Ov { OP_OFF64, v_mode }
353 #define Xb { OP_DSreg, eSI_reg }
354 #define Xv { OP_DSreg, eSI_reg }
355 #define Xz { OP_DSreg, eSI_reg }
356 #define Yb { OP_ESreg, eDI_reg }
357 #define Yv { OP_ESreg, eDI_reg }
358 #define DSBX { OP_DSreg, eBX_reg }
360 #define es { OP_REG, es_reg }
361 #define ss { OP_REG, ss_reg }
362 #define cs { OP_REG, cs_reg }
363 #define ds { OP_REG, ds_reg }
364 #define fs { OP_REG, fs_reg }
365 #define gs { OP_REG, gs_reg }
367 #define MX { OP_MMX, 0 }
368 #define XM { OP_XMM, 0 }
369 #define XMScalar { OP_XMM, scalar_mode }
370 #define XMGatherQ { OP_XMM, vex_vsib_q_w_dq_mode }
371 #define XMM { OP_XMM, xmm_mode }
372 #define XMxmmq { OP_XMM, xmmq_mode }
373 #define EM { OP_EM, v_mode }
374 #define EMS { OP_EM, v_swap_mode }
375 #define EMd { OP_EM, d_mode }
376 #define EMx { OP_EM, x_mode }
377 #define EXw { OP_EX, w_mode }
378 #define EXd { OP_EX, d_mode }
379 #define EXdScalar { OP_EX, d_scalar_mode }
380 #define EXdS { OP_EX, d_swap_mode }
381 #define EXdScalarS { OP_EX, d_scalar_swap_mode }
382 #define EXq { OP_EX, q_mode }
383 #define EXqScalar { OP_EX, q_scalar_mode }
384 #define EXqScalarS { OP_EX, q_scalar_swap_mode }
385 #define EXqS { OP_EX, q_swap_mode }
386 #define EXx { OP_EX, x_mode }
387 #define EXxS { OP_EX, x_swap_mode }
388 #define EXxmm { OP_EX, xmm_mode }
389 #define EXymm { OP_EX, ymm_mode }
390 #define EXxmmq { OP_EX, xmmq_mode }
391 #define EXEvexHalfBcstXmmq { OP_EX, evex_half_bcst_xmmq_mode }
392 #define EXxmm_mb { OP_EX, xmm_mb_mode }
393 #define EXxmm_mw { OP_EX, xmm_mw_mode }
394 #define EXxmm_md { OP_EX, xmm_md_mode }
395 #define EXxmm_mq { OP_EX, xmm_mq_mode }
396 #define EXxmm_mdq { OP_EX, xmm_mdq_mode }
397 #define EXxmmdw { OP_EX, xmmdw_mode }
398 #define EXxmmqd { OP_EX, xmmqd_mode }
399 #define EXymmq { OP_EX, ymmq_mode }
400 #define EXVexWdq { OP_EX, vex_w_dq_mode }
401 #define EXVexWdqScalar { OP_EX, vex_scalar_w_dq_mode }
402 #define EXEvexXGscat { OP_EX, evex_x_gscat_mode }
403 #define EXEvexXNoBcst { OP_EX, evex_x_nobcst_mode }
404 #define MS { OP_MS, v_mode }
405 #define XS { OP_XS, v_mode }
406 #define EMCq { OP_EMC, q_mode }
407 #define MXC { OP_MXC, 0 }
408 #define OPSUF { OP_3DNowSuffix, 0 }
409 #define CMP { CMP_Fixup, 0 }
410 #define XMM0 { XMM_Fixup, 0 }
411 #define FXSAVE { FXSAVE_Fixup, 0 }
412 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
413 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
415 #define Vex { OP_VEX, vex_mode }
416 #define VexScalar { OP_VEX, vex_scalar_mode }
417 #define VexGatherQ { OP_VEX, vex_vsib_q_w_dq_mode }
418 #define Vex128 { OP_VEX, vex128_mode }
419 #define Vex256 { OP_VEX, vex256_mode }
420 #define VexGdq { OP_VEX, dq_mode }
421 #define VexI4 { VEXI4_Fixup, 0}
422 #define EXdVex { OP_EX_Vex, d_mode }
423 #define EXdVexS { OP_EX_Vex, d_swap_mode }
424 #define EXdVexScalarS { OP_EX_Vex, d_scalar_swap_mode }
425 #define EXqVex { OP_EX_Vex, q_mode }
426 #define EXqVexS { OP_EX_Vex, q_swap_mode }
427 #define EXqVexScalarS { OP_EX_Vex, q_scalar_swap_mode }
428 #define EXVexW { OP_EX_VexW, x_mode }
429 #define EXdVexW { OP_EX_VexW, d_mode }
430 #define EXqVexW { OP_EX_VexW, q_mode }
431 #define EXVexImmW { OP_EX_VexImmW, x_mode }
432 #define XMVex { OP_XMM_Vex, 0 }
433 #define XMVexScalar { OP_XMM_Vex, scalar_mode }
434 #define XMVexW { OP_XMM_VexW, 0 }
435 #define XMVexI4 { OP_REG_VexI4, x_mode }
436 #define PCLMUL { PCLMUL_Fixup, 0 }
437 #define VZERO { VZERO_Fixup, 0 }
438 #define VCMP { VCMP_Fixup, 0 }
439 #define VPCMP { VPCMP_Fixup, 0 }
441 #define EXxEVexR { OP_Rounding, evex_rounding_mode }
442 #define EXxEVexS { OP_Rounding, evex_sae_mode }
444 #define XMask { OP_Mask, mask_mode }
445 #define MaskG { OP_G, mask_mode }
446 #define MaskE { OP_E, mask_mode }
447 #define MaskBDE { OP_E, mask_bd_mode }
448 #define MaskR { OP_R, mask_mode }
449 #define MaskVex { OP_VEX, mask_mode }
451 #define MVexVSIBDWpX { OP_M, vex_vsib_d_w_dq_mode }
452 #define MVexVSIBDQWpX { OP_M, vex_vsib_d_w_d_mode }
453 #define MVexVSIBQWpX { OP_M, vex_vsib_q_w_dq_mode }
454 #define MVexVSIBQDWpX { OP_M, vex_vsib_q_w_d_mode }
456 /* Used handle "rep" prefix for string instructions. */
457 #define Xbr { REP_Fixup, eSI_reg }
458 #define Xvr { REP_Fixup, eSI_reg }
459 #define Ybr { REP_Fixup, eDI_reg }
460 #define Yvr { REP_Fixup, eDI_reg }
461 #define Yzr { REP_Fixup, eDI_reg }
462 #define indirDXr { REP_Fixup, indir_dx_reg }
463 #define ALr { REP_Fixup, al_reg }
464 #define eAXr { REP_Fixup, eAX_reg }
466 /* Used handle HLE prefix for lockable instructions. */
467 #define Ebh1 { HLE_Fixup1, b_mode }
468 #define Evh1 { HLE_Fixup1, v_mode }
469 #define Ebh2 { HLE_Fixup2, b_mode }
470 #define Evh2 { HLE_Fixup2, v_mode }
471 #define Ebh3 { HLE_Fixup3, b_mode }
472 #define Evh3 { HLE_Fixup3, v_mode }
474 #define BND { BND_Fixup, 0 }
476 #define cond_jump_flag { NULL, cond_jump_mode }
477 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
479 /* bits in sizeflag */
480 #define SUFFIX_ALWAYS 4
488 /* byte operand with operand swapped */
490 /* byte operand, sign extend like 'T' suffix */
492 /* operand size depends on prefixes */
494 /* operand size depends on prefixes with operand swapped */
498 /* double word operand */
500 /* double word operand with operand swapped */
502 /* quad word operand */
504 /* quad word operand with operand swapped */
506 /* ten-byte operand */
508 /* 16-byte XMM, 32-byte YMM or 64-byte ZMM operand. In EVEX with
509 broadcast enabled. */
511 /* Similar to x_mode, but with different EVEX mem shifts. */
513 /* Similar to x_mode, but with disabled broadcast. */
515 /* Similar to x_mode, but with operands swapped and disabled broadcast
518 /* 16-byte XMM operand */
520 /* XMM, XMM or YMM register operand, or quad word, xmmword or ymmword
521 memory operand (depending on vector length). Broadcast isn't
524 /* Same as xmmq_mode, but broadcast is allowed. */
525 evex_half_bcst_xmmq_mode
,
526 /* XMM register or byte memory operand */
528 /* XMM register or word memory operand */
530 /* XMM register or double word memory operand */
532 /* XMM register or quad word memory operand */
534 /* XMM register or double/quad word memory operand, depending on
537 /* 16-byte XMM, word, double word or quad word operand. */
539 /* 16-byte XMM, double word, quad word operand or xmm word operand. */
541 /* 32-byte YMM operand */
543 /* quad word, ymmword or zmmword memory operand. */
545 /* 32-byte YMM or 16-byte word operand */
547 /* d_mode in 32bit, q_mode in 64bit mode. */
549 /* pair of v_mode operands */
554 /* operand size depends on REX prefixes. */
556 /* registers like dq_mode, memory like w_mode. */
560 /* 4- or 6-byte pointer operand */
563 /* v_mode for stack-related opcodes. */
565 /* non-quad operand size depends on prefixes */
567 /* 16-byte operand */
569 /* registers like dq_mode, memory like b_mode. */
571 /* registers like d_mode, memory like b_mode. */
573 /* registers like d_mode, memory like w_mode. */
575 /* registers like dq_mode, memory like d_mode. */
577 /* normal vex mode */
579 /* 128bit vex mode */
581 /* 256bit vex mode */
583 /* operand size depends on the VEX.W bit. */
586 /* Similar to vex_w_dq_mode, with VSIB dword indices. */
587 vex_vsib_d_w_dq_mode
,
588 /* Similar to vex_vsib_d_w_dq_mode, with smaller memory. */
590 /* Similar to vex_w_dq_mode, with VSIB qword indices. */
591 vex_vsib_q_w_dq_mode
,
592 /* Similar to vex_vsib_q_w_dq_mode, with smaller memory. */
595 /* scalar, ignore vector length. */
597 /* like d_mode, ignore vector length. */
599 /* like d_swap_mode, ignore vector length. */
601 /* like q_mode, ignore vector length. */
603 /* like q_swap_mode, ignore vector length. */
605 /* like vex_mode, ignore vector length. */
607 /* like vex_w_dq_mode, ignore vector length. */
608 vex_scalar_w_dq_mode
,
610 /* Static rounding. */
612 /* Supress all exceptions. */
615 /* Mask register operand. */
617 /* Mask register operand. */
684 #define FLOAT NULL, { { NULL, FLOATCODE } }, 0
686 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }, 0
687 #define DIS386_PREFIX(T, I, P) NULL, { { NULL, (T)}, { NULL, (I) } }, P
688 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
689 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
690 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
691 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
692 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
693 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
694 #define THREE_BYTE_TABLE_PREFIX(I, P) DIS386_PREFIX (USE_3BYTE_TABLE, (I), P)
695 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
696 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
697 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
698 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
699 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
700 #define EVEX_TABLE(I) DIS386 (USE_EVEX_TABLE, (I))
816 MOD_VEX_0F12_PREFIX_0
,
818 MOD_VEX_0F16_PREFIX_0
,
834 MOD_VEX_0FD7_PREFIX_2
,
835 MOD_VEX_0FE7_PREFIX_2
,
836 MOD_VEX_0FF0_PREFIX_3
,
837 MOD_VEX_0F381A_PREFIX_2
,
838 MOD_VEX_0F382A_PREFIX_2
,
839 MOD_VEX_0F382C_PREFIX_2
,
840 MOD_VEX_0F382D_PREFIX_2
,
841 MOD_VEX_0F382E_PREFIX_2
,
842 MOD_VEX_0F382F_PREFIX_2
,
843 MOD_VEX_0F385A_PREFIX_2
,
844 MOD_VEX_0F388C_PREFIX_2
,
845 MOD_VEX_0F388E_PREFIX_2
,
847 MOD_EVEX_0F10_PREFIX_1
,
848 MOD_EVEX_0F10_PREFIX_3
,
849 MOD_EVEX_0F11_PREFIX_1
,
850 MOD_EVEX_0F11_PREFIX_3
,
851 MOD_EVEX_0F12_PREFIX_0
,
852 MOD_EVEX_0F16_PREFIX_0
,
853 MOD_EVEX_0F38C6_REG_1
,
854 MOD_EVEX_0F38C6_REG_2
,
855 MOD_EVEX_0F38C6_REG_5
,
856 MOD_EVEX_0F38C6_REG_6
,
857 MOD_EVEX_0F38C7_REG_1
,
858 MOD_EVEX_0F38C7_REG_2
,
859 MOD_EVEX_0F38C7_REG_5
,
860 MOD_EVEX_0F38C7_REG_6
924 PREFIX_RM_0_0FAE_REG_7
,
930 PREFIX_MOD_0_0FC7_REG_6
,
931 PREFIX_MOD_3_0FC7_REG_6
,
932 PREFIX_MOD_3_0FC7_REG_7
,
1056 PREFIX_VEX_0F71_REG_2
,
1057 PREFIX_VEX_0F71_REG_4
,
1058 PREFIX_VEX_0F71_REG_6
,
1059 PREFIX_VEX_0F72_REG_2
,
1060 PREFIX_VEX_0F72_REG_4
,
1061 PREFIX_VEX_0F72_REG_6
,
1062 PREFIX_VEX_0F73_REG_2
,
1063 PREFIX_VEX_0F73_REG_3
,
1064 PREFIX_VEX_0F73_REG_6
,
1065 PREFIX_VEX_0F73_REG_7
,
1237 PREFIX_VEX_0F38F3_REG_1
,
1238 PREFIX_VEX_0F38F3_REG_2
,
1239 PREFIX_VEX_0F38F3_REG_3
,
1356 PREFIX_EVEX_0F71_REG_2
,
1357 PREFIX_EVEX_0F71_REG_4
,
1358 PREFIX_EVEX_0F71_REG_6
,
1359 PREFIX_EVEX_0F72_REG_0
,
1360 PREFIX_EVEX_0F72_REG_1
,
1361 PREFIX_EVEX_0F72_REG_2
,
1362 PREFIX_EVEX_0F72_REG_4
,
1363 PREFIX_EVEX_0F72_REG_6
,
1364 PREFIX_EVEX_0F73_REG_2
,
1365 PREFIX_EVEX_0F73_REG_3
,
1366 PREFIX_EVEX_0F73_REG_6
,
1367 PREFIX_EVEX_0F73_REG_7
,
1550 PREFIX_EVEX_0F38C6_REG_1
,
1551 PREFIX_EVEX_0F38C6_REG_2
,
1552 PREFIX_EVEX_0F38C6_REG_5
,
1553 PREFIX_EVEX_0F38C6_REG_6
,
1554 PREFIX_EVEX_0F38C7_REG_1
,
1555 PREFIX_EVEX_0F38C7_REG_2
,
1556 PREFIX_EVEX_0F38C7_REG_5
,
1557 PREFIX_EVEX_0F38C7_REG_6
,
1646 THREE_BYTE_0F38
= 0,
1674 VEX_LEN_0F10_P_1
= 0,
1678 VEX_LEN_0F12_P_0_M_0
,
1679 VEX_LEN_0F12_P_0_M_1
,
1682 VEX_LEN_0F16_P_0_M_0
,
1683 VEX_LEN_0F16_P_0_M_1
,
1747 VEX_LEN_0FAE_R_2_M_0
,
1748 VEX_LEN_0FAE_R_3_M_0
,
1757 VEX_LEN_0F381A_P_2_M_0
,
1760 VEX_LEN_0F385A_P_2_M_0
,
1767 VEX_LEN_0F38F3_R_1_P_0
,
1768 VEX_LEN_0F38F3_R_2_P_0
,
1769 VEX_LEN_0F38F3_R_3_P_0
,
1815 VEX_LEN_0FXOP_08_CC
,
1816 VEX_LEN_0FXOP_08_CD
,
1817 VEX_LEN_0FXOP_08_CE
,
1818 VEX_LEN_0FXOP_08_CF
,
1819 VEX_LEN_0FXOP_08_EC
,
1820 VEX_LEN_0FXOP_08_ED
,
1821 VEX_LEN_0FXOP_08_EE
,
1822 VEX_LEN_0FXOP_08_EF
,
1823 VEX_LEN_0FXOP_09_80
,
1857 VEX_W_0F41_P_0_LEN_1
,
1858 VEX_W_0F41_P_2_LEN_1
,
1859 VEX_W_0F42_P_0_LEN_1
,
1860 VEX_W_0F42_P_2_LEN_1
,
1861 VEX_W_0F44_P_0_LEN_0
,
1862 VEX_W_0F44_P_2_LEN_0
,
1863 VEX_W_0F45_P_0_LEN_1
,
1864 VEX_W_0F45_P_2_LEN_1
,
1865 VEX_W_0F46_P_0_LEN_1
,
1866 VEX_W_0F46_P_2_LEN_1
,
1867 VEX_W_0F47_P_0_LEN_1
,
1868 VEX_W_0F47_P_2_LEN_1
,
1869 VEX_W_0F4A_P_0_LEN_1
,
1870 VEX_W_0F4A_P_2_LEN_1
,
1871 VEX_W_0F4B_P_0_LEN_1
,
1872 VEX_W_0F4B_P_2_LEN_1
,
1952 VEX_W_0F90_P_0_LEN_0
,
1953 VEX_W_0F90_P_2_LEN_0
,
1954 VEX_W_0F91_P_0_LEN_0
,
1955 VEX_W_0F91_P_2_LEN_0
,
1956 VEX_W_0F92_P_0_LEN_0
,
1957 VEX_W_0F92_P_2_LEN_0
,
1958 VEX_W_0F92_P_3_LEN_0
,
1959 VEX_W_0F93_P_0_LEN_0
,
1960 VEX_W_0F93_P_2_LEN_0
,
1961 VEX_W_0F93_P_3_LEN_0
,
1962 VEX_W_0F98_P_0_LEN_0
,
1963 VEX_W_0F98_P_2_LEN_0
,
1964 VEX_W_0F99_P_0_LEN_0
,
1965 VEX_W_0F99_P_2_LEN_0
,
2044 VEX_W_0F381A_P_2_M_0
,
2056 VEX_W_0F382A_P_2_M_0
,
2058 VEX_W_0F382C_P_2_M_0
,
2059 VEX_W_0F382D_P_2_M_0
,
2060 VEX_W_0F382E_P_2_M_0
,
2061 VEX_W_0F382F_P_2_M_0
,
2083 VEX_W_0F385A_P_2_M_0
,
2111 VEX_W_0F3A30_P_2_LEN_0
,
2112 VEX_W_0F3A31_P_2_LEN_0
,
2113 VEX_W_0F3A32_P_2_LEN_0
,
2114 VEX_W_0F3A33_P_2_LEN_0
,
2134 EVEX_W_0F10_P_1_M_0
,
2135 EVEX_W_0F10_P_1_M_1
,
2137 EVEX_W_0F10_P_3_M_0
,
2138 EVEX_W_0F10_P_3_M_1
,
2140 EVEX_W_0F11_P_1_M_0
,
2141 EVEX_W_0F11_P_1_M_1
,
2143 EVEX_W_0F11_P_3_M_0
,
2144 EVEX_W_0F11_P_3_M_1
,
2145 EVEX_W_0F12_P_0_M_0
,
2146 EVEX_W_0F12_P_0_M_1
,
2156 EVEX_W_0F16_P_0_M_0
,
2157 EVEX_W_0F16_P_0_M_1
,
2228 EVEX_W_0F72_R_2_P_2
,
2229 EVEX_W_0F72_R_6_P_2
,
2230 EVEX_W_0F73_R_2_P_2
,
2231 EVEX_W_0F73_R_6_P_2
,
2331 EVEX_W_0F38C7_R_1_P_2
,
2332 EVEX_W_0F38C7_R_2_P_2
,
2333 EVEX_W_0F38C7_R_5_P_2
,
2334 EVEX_W_0F38C7_R_6_P_2
,
2369 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
2378 unsigned int prefix_requirement
;
2381 /* Upper case letters in the instruction names here are macros.
2382 'A' => print 'b' if no register operands or suffix_always is true
2383 'B' => print 'b' if suffix_always is true
2384 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
2386 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
2387 suffix_always is true
2388 'E' => print 'e' if 32-bit form of jcxz
2389 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
2390 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
2391 'H' => print ",pt" or ",pn" branch hint
2392 'I' => honor following macro letter even in Intel mode (implemented only
2393 for some of the macro letters)
2395 'K' => print 'd' or 'q' if rex prefix is present.
2396 'L' => print 'l' if suffix_always is true
2397 'M' => print 'r' if intel_mnemonic is false.
2398 'N' => print 'n' if instruction has no wait "prefix"
2399 'O' => print 'd' or 'o' (or 'q' in Intel mode)
2400 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
2401 or suffix_always is true. print 'q' if rex prefix is present.
2402 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
2404 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
2405 'S' => print 'w', 'l' or 'q' if suffix_always is true
2406 'T' => print 'q' in 64bit mode if instruction has no operand size
2407 prefix and behave as 'P' otherwise
2408 'U' => print 'q' in 64bit mode if instruction has no operand size
2409 prefix and behave as 'Q' otherwise
2410 'V' => print 'q' in 64bit mode if instruction has no operand size
2411 prefix and behave as 'S' otherwise
2412 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
2413 'X' => print 's', 'd' depending on data16 prefix (for XMM)
2414 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
2415 suffix_always is true.
2416 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
2417 '!' => change condition from true to false or from false to true.
2418 '%' => add 1 upper case letter to the macro.
2419 '^' => print 'w' or 'l' depending on operand size prefix or
2420 suffix_always is true (lcall/ljmp).
2421 '@' => print 'q' for Intel64 ISA, 'w' or 'q' for AMD64 ISA depending
2422 on operand size prefix.
2424 2 upper case letter macros:
2425 "XY" => print 'x' or 'y' if suffix_always is true or no register
2426 operands and no broadcast.
2427 "XZ" => print 'x', 'y', or 'z' if suffix_always is true or no
2428 register operands and no broadcast.
2429 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
2430 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
2431 or suffix_always is true
2432 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
2433 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
2434 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
2435 "LW" => print 'd', 'q' depending on the VEX.W bit
2436 "LP" => print 'w' or 'l' ('d' in Intel mode) if instruction has
2437 an operand size prefix, or suffix_always is true. print
2438 'q' if rex prefix is present.
2440 Many of the above letters print nothing in Intel mode. See "putop"
2443 Braces '{' and '}', and vertical bars '|', indicate alternative
2444 mnemonic strings for AT&T and Intel. */
2446 static const struct dis386 dis386
[] = {
2448 { "addB", { Ebh1
, Gb
}, 0 },
2449 { "addS", { Evh1
, Gv
}, 0 },
2450 { "addB", { Gb
, EbS
}, 0 },
2451 { "addS", { Gv
, EvS
}, 0 },
2452 { "addB", { AL
, Ib
}, 0 },
2453 { "addS", { eAX
, Iv
}, 0 },
2454 { X86_64_TABLE (X86_64_06
) },
2455 { X86_64_TABLE (X86_64_07
) },
2457 { "orB", { Ebh1
, Gb
}, 0 },
2458 { "orS", { Evh1
, Gv
}, 0 },
2459 { "orB", { Gb
, EbS
}, 0 },
2460 { "orS", { Gv
, EvS
}, 0 },
2461 { "orB", { AL
, Ib
}, 0 },
2462 { "orS", { eAX
, Iv
}, 0 },
2463 { X86_64_TABLE (X86_64_0D
) },
2464 { Bad_Opcode
}, /* 0x0f extended opcode escape */
2466 { "adcB", { Ebh1
, Gb
}, 0 },
2467 { "adcS", { Evh1
, Gv
}, 0 },
2468 { "adcB", { Gb
, EbS
}, 0 },
2469 { "adcS", { Gv
, EvS
}, 0 },
2470 { "adcB", { AL
, Ib
}, 0 },
2471 { "adcS", { eAX
, Iv
}, 0 },
2472 { X86_64_TABLE (X86_64_16
) },
2473 { X86_64_TABLE (X86_64_17
) },
2475 { "sbbB", { Ebh1
, Gb
}, 0 },
2476 { "sbbS", { Evh1
, Gv
}, 0 },
2477 { "sbbB", { Gb
, EbS
}, 0 },
2478 { "sbbS", { Gv
, EvS
}, 0 },
2479 { "sbbB", { AL
, Ib
}, 0 },
2480 { "sbbS", { eAX
, Iv
}, 0 },
2481 { X86_64_TABLE (X86_64_1E
) },
2482 { X86_64_TABLE (X86_64_1F
) },
2484 { "andB", { Ebh1
, Gb
}, 0 },
2485 { "andS", { Evh1
, Gv
}, 0 },
2486 { "andB", { Gb
, EbS
}, 0 },
2487 { "andS", { Gv
, EvS
}, 0 },
2488 { "andB", { AL
, Ib
}, 0 },
2489 { "andS", { eAX
, Iv
}, 0 },
2490 { Bad_Opcode
}, /* SEG ES prefix */
2491 { X86_64_TABLE (X86_64_27
) },
2493 { "subB", { Ebh1
, Gb
}, 0 },
2494 { "subS", { Evh1
, Gv
}, 0 },
2495 { "subB", { Gb
, EbS
}, 0 },
2496 { "subS", { Gv
, EvS
}, 0 },
2497 { "subB", { AL
, Ib
}, 0 },
2498 { "subS", { eAX
, Iv
}, 0 },
2499 { Bad_Opcode
}, /* SEG CS prefix */
2500 { X86_64_TABLE (X86_64_2F
) },
2502 { "xorB", { Ebh1
, Gb
}, 0 },
2503 { "xorS", { Evh1
, Gv
}, 0 },
2504 { "xorB", { Gb
, EbS
}, 0 },
2505 { "xorS", { Gv
, EvS
}, 0 },
2506 { "xorB", { AL
, Ib
}, 0 },
2507 { "xorS", { eAX
, Iv
}, 0 },
2508 { Bad_Opcode
}, /* SEG SS prefix */
2509 { X86_64_TABLE (X86_64_37
) },
2511 { "cmpB", { Eb
, Gb
}, 0 },
2512 { "cmpS", { Ev
, Gv
}, 0 },
2513 { "cmpB", { Gb
, EbS
}, 0 },
2514 { "cmpS", { Gv
, EvS
}, 0 },
2515 { "cmpB", { AL
, Ib
}, 0 },
2516 { "cmpS", { eAX
, Iv
}, 0 },
2517 { Bad_Opcode
}, /* SEG DS prefix */
2518 { X86_64_TABLE (X86_64_3F
) },
2520 { "inc{S|}", { RMeAX
}, 0 },
2521 { "inc{S|}", { RMeCX
}, 0 },
2522 { "inc{S|}", { RMeDX
}, 0 },
2523 { "inc{S|}", { RMeBX
}, 0 },
2524 { "inc{S|}", { RMeSP
}, 0 },
2525 { "inc{S|}", { RMeBP
}, 0 },
2526 { "inc{S|}", { RMeSI
}, 0 },
2527 { "inc{S|}", { RMeDI
}, 0 },
2529 { "dec{S|}", { RMeAX
}, 0 },
2530 { "dec{S|}", { RMeCX
}, 0 },
2531 { "dec{S|}", { RMeDX
}, 0 },
2532 { "dec{S|}", { RMeBX
}, 0 },
2533 { "dec{S|}", { RMeSP
}, 0 },
2534 { "dec{S|}", { RMeBP
}, 0 },
2535 { "dec{S|}", { RMeSI
}, 0 },
2536 { "dec{S|}", { RMeDI
}, 0 },
2538 { "pushV", { RMrAX
}, 0 },
2539 { "pushV", { RMrCX
}, 0 },
2540 { "pushV", { RMrDX
}, 0 },
2541 { "pushV", { RMrBX
}, 0 },
2542 { "pushV", { RMrSP
}, 0 },
2543 { "pushV", { RMrBP
}, 0 },
2544 { "pushV", { RMrSI
}, 0 },
2545 { "pushV", { RMrDI
}, 0 },
2547 { "popV", { RMrAX
}, 0 },
2548 { "popV", { RMrCX
}, 0 },
2549 { "popV", { RMrDX
}, 0 },
2550 { "popV", { RMrBX
}, 0 },
2551 { "popV", { RMrSP
}, 0 },
2552 { "popV", { RMrBP
}, 0 },
2553 { "popV", { RMrSI
}, 0 },
2554 { "popV", { RMrDI
}, 0 },
2556 { X86_64_TABLE (X86_64_60
) },
2557 { X86_64_TABLE (X86_64_61
) },
2558 { X86_64_TABLE (X86_64_62
) },
2559 { X86_64_TABLE (X86_64_63
) },
2560 { Bad_Opcode
}, /* seg fs */
2561 { Bad_Opcode
}, /* seg gs */
2562 { Bad_Opcode
}, /* op size prefix */
2563 { Bad_Opcode
}, /* adr size prefix */
2565 { "pushT", { sIv
}, 0 },
2566 { "imulS", { Gv
, Ev
, Iv
}, 0 },
2567 { "pushT", { sIbT
}, 0 },
2568 { "imulS", { Gv
, Ev
, sIb
}, 0 },
2569 { "ins{b|}", { Ybr
, indirDX
}, 0 },
2570 { X86_64_TABLE (X86_64_6D
) },
2571 { "outs{b|}", { indirDXr
, Xb
}, 0 },
2572 { X86_64_TABLE (X86_64_6F
) },
2574 { "joH", { Jb
, BND
, cond_jump_flag
}, 0 },
2575 { "jnoH", { Jb
, BND
, cond_jump_flag
}, 0 },
2576 { "jbH", { Jb
, BND
, cond_jump_flag
}, 0 },
2577 { "jaeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2578 { "jeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2579 { "jneH", { Jb
, BND
, cond_jump_flag
}, 0 },
2580 { "jbeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2581 { "jaH", { Jb
, BND
, cond_jump_flag
}, 0 },
2583 { "jsH", { Jb
, BND
, cond_jump_flag
}, 0 },
2584 { "jnsH", { Jb
, BND
, cond_jump_flag
}, 0 },
2585 { "jpH", { Jb
, BND
, cond_jump_flag
}, 0 },
2586 { "jnpH", { Jb
, BND
, cond_jump_flag
}, 0 },
2587 { "jlH", { Jb
, BND
, cond_jump_flag
}, 0 },
2588 { "jgeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2589 { "jleH", { Jb
, BND
, cond_jump_flag
}, 0 },
2590 { "jgH", { Jb
, BND
, cond_jump_flag
}, 0 },
2592 { REG_TABLE (REG_80
) },
2593 { REG_TABLE (REG_81
) },
2595 { REG_TABLE (REG_82
) },
2596 { "testB", { Eb
, Gb
}, 0 },
2597 { "testS", { Ev
, Gv
}, 0 },
2598 { "xchgB", { Ebh2
, Gb
}, 0 },
2599 { "xchgS", { Evh2
, Gv
}, 0 },
2601 { "movB", { Ebh3
, Gb
}, 0 },
2602 { "movS", { Evh3
, Gv
}, 0 },
2603 { "movB", { Gb
, EbS
}, 0 },
2604 { "movS", { Gv
, EvS
}, 0 },
2605 { "movD", { Sv
, Sw
}, 0 },
2606 { MOD_TABLE (MOD_8D
) },
2607 { "movD", { Sw
, Sv
}, 0 },
2608 { REG_TABLE (REG_8F
) },
2610 { PREFIX_TABLE (PREFIX_90
) },
2611 { "xchgS", { RMeCX
, eAX
}, 0 },
2612 { "xchgS", { RMeDX
, eAX
}, 0 },
2613 { "xchgS", { RMeBX
, eAX
}, 0 },
2614 { "xchgS", { RMeSP
, eAX
}, 0 },
2615 { "xchgS", { RMeBP
, eAX
}, 0 },
2616 { "xchgS", { RMeSI
, eAX
}, 0 },
2617 { "xchgS", { RMeDI
, eAX
}, 0 },
2619 { "cW{t|}R", { XX
}, 0 },
2620 { "cR{t|}O", { XX
}, 0 },
2621 { X86_64_TABLE (X86_64_9A
) },
2622 { Bad_Opcode
}, /* fwait */
2623 { "pushfT", { XX
}, 0 },
2624 { "popfT", { XX
}, 0 },
2625 { "sahf", { XX
}, 0 },
2626 { "lahf", { XX
}, 0 },
2628 { "mov%LB", { AL
, Ob
}, 0 },
2629 { "mov%LS", { eAX
, Ov
}, 0 },
2630 { "mov%LB", { Ob
, AL
}, 0 },
2631 { "mov%LS", { Ov
, eAX
}, 0 },
2632 { "movs{b|}", { Ybr
, Xb
}, 0 },
2633 { "movs{R|}", { Yvr
, Xv
}, 0 },
2634 { "cmps{b|}", { Xb
, Yb
}, 0 },
2635 { "cmps{R|}", { Xv
, Yv
}, 0 },
2637 { "testB", { AL
, Ib
}, 0 },
2638 { "testS", { eAX
, Iv
}, 0 },
2639 { "stosB", { Ybr
, AL
}, 0 },
2640 { "stosS", { Yvr
, eAX
}, 0 },
2641 { "lodsB", { ALr
, Xb
}, 0 },
2642 { "lodsS", { eAXr
, Xv
}, 0 },
2643 { "scasB", { AL
, Yb
}, 0 },
2644 { "scasS", { eAX
, Yv
}, 0 },
2646 { "movB", { RMAL
, Ib
}, 0 },
2647 { "movB", { RMCL
, Ib
}, 0 },
2648 { "movB", { RMDL
, Ib
}, 0 },
2649 { "movB", { RMBL
, Ib
}, 0 },
2650 { "movB", { RMAH
, Ib
}, 0 },
2651 { "movB", { RMCH
, Ib
}, 0 },
2652 { "movB", { RMDH
, Ib
}, 0 },
2653 { "movB", { RMBH
, Ib
}, 0 },
2655 { "mov%LV", { RMeAX
, Iv64
}, 0 },
2656 { "mov%LV", { RMeCX
, Iv64
}, 0 },
2657 { "mov%LV", { RMeDX
, Iv64
}, 0 },
2658 { "mov%LV", { RMeBX
, Iv64
}, 0 },
2659 { "mov%LV", { RMeSP
, Iv64
}, 0 },
2660 { "mov%LV", { RMeBP
, Iv64
}, 0 },
2661 { "mov%LV", { RMeSI
, Iv64
}, 0 },
2662 { "mov%LV", { RMeDI
, Iv64
}, 0 },
2664 { REG_TABLE (REG_C0
) },
2665 { REG_TABLE (REG_C1
) },
2666 { "retT", { Iw
, BND
}, 0 },
2667 { "retT", { BND
}, 0 },
2668 { X86_64_TABLE (X86_64_C4
) },
2669 { X86_64_TABLE (X86_64_C5
) },
2670 { REG_TABLE (REG_C6
) },
2671 { REG_TABLE (REG_C7
) },
2673 { "enterT", { Iw
, Ib
}, 0 },
2674 { "leaveT", { XX
}, 0 },
2675 { "Jret{|f}P", { Iw
}, 0 },
2676 { "Jret{|f}P", { XX
}, 0 },
2677 { "int3", { XX
}, 0 },
2678 { "int", { Ib
}, 0 },
2679 { X86_64_TABLE (X86_64_CE
) },
2680 { "iret%LP", { XX
}, 0 },
2682 { REG_TABLE (REG_D0
) },
2683 { REG_TABLE (REG_D1
) },
2684 { REG_TABLE (REG_D2
) },
2685 { REG_TABLE (REG_D3
) },
2686 { X86_64_TABLE (X86_64_D4
) },
2687 { X86_64_TABLE (X86_64_D5
) },
2689 { "xlat", { DSBX
}, 0 },
2700 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2701 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2702 { "loopFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2703 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2704 { "inB", { AL
, Ib
}, 0 },
2705 { "inG", { zAX
, Ib
}, 0 },
2706 { "outB", { Ib
, AL
}, 0 },
2707 { "outG", { Ib
, zAX
}, 0 },
2709 { X86_64_TABLE (X86_64_E8
) },
2710 { X86_64_TABLE (X86_64_E9
) },
2711 { X86_64_TABLE (X86_64_EA
) },
2712 { "jmp", { Jb
, BND
}, 0 },
2713 { "inB", { AL
, indirDX
}, 0 },
2714 { "inG", { zAX
, indirDX
}, 0 },
2715 { "outB", { indirDX
, AL
}, 0 },
2716 { "outG", { indirDX
, zAX
}, 0 },
2718 { Bad_Opcode
}, /* lock prefix */
2719 { "icebp", { XX
}, 0 },
2720 { Bad_Opcode
}, /* repne */
2721 { Bad_Opcode
}, /* repz */
2722 { "hlt", { XX
}, 0 },
2723 { "cmc", { XX
}, 0 },
2724 { REG_TABLE (REG_F6
) },
2725 { REG_TABLE (REG_F7
) },
2727 { "clc", { XX
}, 0 },
2728 { "stc", { XX
}, 0 },
2729 { "cli", { XX
}, 0 },
2730 { "sti", { XX
}, 0 },
2731 { "cld", { XX
}, 0 },
2732 { "std", { XX
}, 0 },
2733 { REG_TABLE (REG_FE
) },
2734 { REG_TABLE (REG_FF
) },
2737 static const struct dis386 dis386_twobyte
[] = {
2739 { REG_TABLE (REG_0F00
) },
2740 { REG_TABLE (REG_0F01
) },
2741 { "larS", { Gv
, Ew
}, 0 },
2742 { "lslS", { Gv
, Ew
}, 0 },
2744 { "syscall", { XX
}, 0 },
2745 { "clts", { XX
}, 0 },
2746 { "sysret%LP", { XX
}, 0 },
2748 { "invd", { XX
}, 0 },
2749 { "wbinvd", { XX
}, 0 },
2751 { "ud2", { XX
}, 0 },
2753 { REG_TABLE (REG_0F0D
) },
2754 { "femms", { XX
}, 0 },
2755 { "", { MX
, EM
, OPSUF
}, 0 }, /* See OP_3DNowSuffix. */
2757 { PREFIX_TABLE (PREFIX_0F10
) },
2758 { PREFIX_TABLE (PREFIX_0F11
) },
2759 { PREFIX_TABLE (PREFIX_0F12
) },
2760 { MOD_TABLE (MOD_0F13
) },
2761 { "unpcklpX", { XM
, EXx
}, PREFIX_OPCODE
},
2762 { "unpckhpX", { XM
, EXx
}, PREFIX_OPCODE
},
2763 { PREFIX_TABLE (PREFIX_0F16
) },
2764 { MOD_TABLE (MOD_0F17
) },
2766 { REG_TABLE (REG_0F18
) },
2767 { "nopQ", { Ev
}, 0 },
2768 { PREFIX_TABLE (PREFIX_0F1A
) },
2769 { PREFIX_TABLE (PREFIX_0F1B
) },
2770 { "nopQ", { Ev
}, 0 },
2771 { "nopQ", { Ev
}, 0 },
2772 { "nopQ", { Ev
}, 0 },
2773 { "nopQ", { Ev
}, 0 },
2775 { "movZ", { Rm
, Cm
}, 0 },
2776 { "movZ", { Rm
, Dm
}, 0 },
2777 { "movZ", { Cm
, Rm
}, 0 },
2778 { "movZ", { Dm
, Rm
}, 0 },
2779 { MOD_TABLE (MOD_0F24
) },
2781 { MOD_TABLE (MOD_0F26
) },
2784 { "movapX", { XM
, EXx
}, PREFIX_OPCODE
},
2785 { "movapX", { EXxS
, XM
}, PREFIX_OPCODE
},
2786 { PREFIX_TABLE (PREFIX_0F2A
) },
2787 { PREFIX_TABLE (PREFIX_0F2B
) },
2788 { PREFIX_TABLE (PREFIX_0F2C
) },
2789 { PREFIX_TABLE (PREFIX_0F2D
) },
2790 { PREFIX_TABLE (PREFIX_0F2E
) },
2791 { PREFIX_TABLE (PREFIX_0F2F
) },
2793 { "wrmsr", { XX
}, 0 },
2794 { "rdtsc", { XX
}, 0 },
2795 { "rdmsr", { XX
}, 0 },
2796 { "rdpmc", { XX
}, 0 },
2797 { "sysenter", { XX
}, 0 },
2798 { "sysexit", { XX
}, 0 },
2800 { "getsec", { XX
}, 0 },
2802 { THREE_BYTE_TABLE_PREFIX (THREE_BYTE_0F38
, PREFIX_OPCODE
) },
2804 { THREE_BYTE_TABLE_PREFIX (THREE_BYTE_0F3A
, PREFIX_OPCODE
) },
2811 { "cmovoS", { Gv
, Ev
}, 0 },
2812 { "cmovnoS", { Gv
, Ev
}, 0 },
2813 { "cmovbS", { Gv
, Ev
}, 0 },
2814 { "cmovaeS", { Gv
, Ev
}, 0 },
2815 { "cmoveS", { Gv
, Ev
}, 0 },
2816 { "cmovneS", { Gv
, Ev
}, 0 },
2817 { "cmovbeS", { Gv
, Ev
}, 0 },
2818 { "cmovaS", { Gv
, Ev
}, 0 },
2820 { "cmovsS", { Gv
, Ev
}, 0 },
2821 { "cmovnsS", { Gv
, Ev
}, 0 },
2822 { "cmovpS", { Gv
, Ev
}, 0 },
2823 { "cmovnpS", { Gv
, Ev
}, 0 },
2824 { "cmovlS", { Gv
, Ev
}, 0 },
2825 { "cmovgeS", { Gv
, Ev
}, 0 },
2826 { "cmovleS", { Gv
, Ev
}, 0 },
2827 { "cmovgS", { Gv
, Ev
}, 0 },
2829 { MOD_TABLE (MOD_0F51
) },
2830 { PREFIX_TABLE (PREFIX_0F51
) },
2831 { PREFIX_TABLE (PREFIX_0F52
) },
2832 { PREFIX_TABLE (PREFIX_0F53
) },
2833 { "andpX", { XM
, EXx
}, PREFIX_OPCODE
},
2834 { "andnpX", { XM
, EXx
}, PREFIX_OPCODE
},
2835 { "orpX", { XM
, EXx
}, PREFIX_OPCODE
},
2836 { "xorpX", { XM
, EXx
}, PREFIX_OPCODE
},
2838 { PREFIX_TABLE (PREFIX_0F58
) },
2839 { PREFIX_TABLE (PREFIX_0F59
) },
2840 { PREFIX_TABLE (PREFIX_0F5A
) },
2841 { PREFIX_TABLE (PREFIX_0F5B
) },
2842 { PREFIX_TABLE (PREFIX_0F5C
) },
2843 { PREFIX_TABLE (PREFIX_0F5D
) },
2844 { PREFIX_TABLE (PREFIX_0F5E
) },
2845 { PREFIX_TABLE (PREFIX_0F5F
) },
2847 { PREFIX_TABLE (PREFIX_0F60
) },
2848 { PREFIX_TABLE (PREFIX_0F61
) },
2849 { PREFIX_TABLE (PREFIX_0F62
) },
2850 { "packsswb", { MX
, EM
}, PREFIX_OPCODE
},
2851 { "pcmpgtb", { MX
, EM
}, PREFIX_OPCODE
},
2852 { "pcmpgtw", { MX
, EM
}, PREFIX_OPCODE
},
2853 { "pcmpgtd", { MX
, EM
}, PREFIX_OPCODE
},
2854 { "packuswb", { MX
, EM
}, PREFIX_OPCODE
},
2856 { "punpckhbw", { MX
, EM
}, PREFIX_OPCODE
},
2857 { "punpckhwd", { MX
, EM
}, PREFIX_OPCODE
},
2858 { "punpckhdq", { MX
, EM
}, PREFIX_OPCODE
},
2859 { "packssdw", { MX
, EM
}, PREFIX_OPCODE
},
2860 { PREFIX_TABLE (PREFIX_0F6C
) },
2861 { PREFIX_TABLE (PREFIX_0F6D
) },
2862 { "movK", { MX
, Edq
}, PREFIX_OPCODE
},
2863 { PREFIX_TABLE (PREFIX_0F6F
) },
2865 { PREFIX_TABLE (PREFIX_0F70
) },
2866 { REG_TABLE (REG_0F71
) },
2867 { REG_TABLE (REG_0F72
) },
2868 { REG_TABLE (REG_0F73
) },
2869 { "pcmpeqb", { MX
, EM
}, PREFIX_OPCODE
},
2870 { "pcmpeqw", { MX
, EM
}, PREFIX_OPCODE
},
2871 { "pcmpeqd", { MX
, EM
}, PREFIX_OPCODE
},
2872 { "emms", { XX
}, PREFIX_OPCODE
},
2874 { PREFIX_TABLE (PREFIX_0F78
) },
2875 { PREFIX_TABLE (PREFIX_0F79
) },
2876 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2878 { PREFIX_TABLE (PREFIX_0F7C
) },
2879 { PREFIX_TABLE (PREFIX_0F7D
) },
2880 { PREFIX_TABLE (PREFIX_0F7E
) },
2881 { PREFIX_TABLE (PREFIX_0F7F
) },
2883 { "joH", { Jv
, BND
, cond_jump_flag
}, 0 },
2884 { "jnoH", { Jv
, BND
, cond_jump_flag
}, 0 },
2885 { "jbH", { Jv
, BND
, cond_jump_flag
}, 0 },
2886 { "jaeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2887 { "jeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2888 { "jneH", { Jv
, BND
, cond_jump_flag
}, 0 },
2889 { "jbeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2890 { "jaH", { Jv
, BND
, cond_jump_flag
}, 0 },
2892 { "jsH", { Jv
, BND
, cond_jump_flag
}, 0 },
2893 { "jnsH", { Jv
, BND
, cond_jump_flag
}, 0 },
2894 { "jpH", { Jv
, BND
, cond_jump_flag
}, 0 },
2895 { "jnpH", { Jv
, BND
, cond_jump_flag
}, 0 },
2896 { "jlH", { Jv
, BND
, cond_jump_flag
}, 0 },
2897 { "jgeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2898 { "jleH", { Jv
, BND
, cond_jump_flag
}, 0 },
2899 { "jgH", { Jv
, BND
, cond_jump_flag
}, 0 },
2901 { "seto", { Eb
}, 0 },
2902 { "setno", { Eb
}, 0 },
2903 { "setb", { Eb
}, 0 },
2904 { "setae", { Eb
}, 0 },
2905 { "sete", { Eb
}, 0 },
2906 { "setne", { Eb
}, 0 },
2907 { "setbe", { Eb
}, 0 },
2908 { "seta", { Eb
}, 0 },
2910 { "sets", { Eb
}, 0 },
2911 { "setns", { Eb
}, 0 },
2912 { "setp", { Eb
}, 0 },
2913 { "setnp", { Eb
}, 0 },
2914 { "setl", { Eb
}, 0 },
2915 { "setge", { Eb
}, 0 },
2916 { "setle", { Eb
}, 0 },
2917 { "setg", { Eb
}, 0 },
2919 { "pushT", { fs
}, 0 },
2920 { "popT", { fs
}, 0 },
2921 { "cpuid", { XX
}, 0 },
2922 { "btS", { Ev
, Gv
}, 0 },
2923 { "shldS", { Ev
, Gv
, Ib
}, 0 },
2924 { "shldS", { Ev
, Gv
, CL
}, 0 },
2925 { REG_TABLE (REG_0FA6
) },
2926 { REG_TABLE (REG_0FA7
) },
2928 { "pushT", { gs
}, 0 },
2929 { "popT", { gs
}, 0 },
2930 { "rsm", { XX
}, 0 },
2931 { "btsS", { Evh1
, Gv
}, 0 },
2932 { "shrdS", { Ev
, Gv
, Ib
}, 0 },
2933 { "shrdS", { Ev
, Gv
, CL
}, 0 },
2934 { REG_TABLE (REG_0FAE
) },
2935 { "imulS", { Gv
, Ev
}, 0 },
2937 { "cmpxchgB", { Ebh1
, Gb
}, 0 },
2938 { "cmpxchgS", { Evh1
, Gv
}, 0 },
2939 { MOD_TABLE (MOD_0FB2
) },
2940 { "btrS", { Evh1
, Gv
}, 0 },
2941 { MOD_TABLE (MOD_0FB4
) },
2942 { MOD_TABLE (MOD_0FB5
) },
2943 { "movz{bR|x}", { Gv
, Eb
}, 0 },
2944 { "movz{wR|x}", { Gv
, Ew
}, 0 }, /* yes, there really is movzww ! */
2946 { PREFIX_TABLE (PREFIX_0FB8
) },
2947 { "ud1", { XX
}, 0 },
2948 { REG_TABLE (REG_0FBA
) },
2949 { "btcS", { Evh1
, Gv
}, 0 },
2950 { PREFIX_TABLE (PREFIX_0FBC
) },
2951 { PREFIX_TABLE (PREFIX_0FBD
) },
2952 { "movs{bR|x}", { Gv
, Eb
}, 0 },
2953 { "movs{wR|x}", { Gv
, Ew
}, 0 }, /* yes, there really is movsww ! */
2955 { "xaddB", { Ebh1
, Gb
}, 0 },
2956 { "xaddS", { Evh1
, Gv
}, 0 },
2957 { PREFIX_TABLE (PREFIX_0FC2
) },
2958 { PREFIX_TABLE (PREFIX_0FC3
) },
2959 { "pinsrw", { MX
, Edqw
, Ib
}, PREFIX_OPCODE
},
2960 { "pextrw", { Gdq
, MS
, Ib
}, PREFIX_OPCODE
},
2961 { "shufpX", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
2962 { REG_TABLE (REG_0FC7
) },
2964 { "bswap", { RMeAX
}, 0 },
2965 { "bswap", { RMeCX
}, 0 },
2966 { "bswap", { RMeDX
}, 0 },
2967 { "bswap", { RMeBX
}, 0 },
2968 { "bswap", { RMeSP
}, 0 },
2969 { "bswap", { RMeBP
}, 0 },
2970 { "bswap", { RMeSI
}, 0 },
2971 { "bswap", { RMeDI
}, 0 },
2973 { PREFIX_TABLE (PREFIX_0FD0
) },
2974 { "psrlw", { MX
, EM
}, PREFIX_OPCODE
},
2975 { "psrld", { MX
, EM
}, PREFIX_OPCODE
},
2976 { "psrlq", { MX
, EM
}, PREFIX_OPCODE
},
2977 { "paddq", { MX
, EM
}, PREFIX_OPCODE
},
2978 { "pmullw", { MX
, EM
}, PREFIX_OPCODE
},
2979 { PREFIX_TABLE (PREFIX_0FD6
) },
2980 { MOD_TABLE (MOD_0FD7
) },
2982 { "psubusb", { MX
, EM
}, PREFIX_OPCODE
},
2983 { "psubusw", { MX
, EM
}, PREFIX_OPCODE
},
2984 { "pminub", { MX
, EM
}, PREFIX_OPCODE
},
2985 { "pand", { MX
, EM
}, PREFIX_OPCODE
},
2986 { "paddusb", { MX
, EM
}, PREFIX_OPCODE
},
2987 { "paddusw", { MX
, EM
}, PREFIX_OPCODE
},
2988 { "pmaxub", { MX
, EM
}, PREFIX_OPCODE
},
2989 { "pandn", { MX
, EM
}, PREFIX_OPCODE
},
2991 { "pavgb", { MX
, EM
}, PREFIX_OPCODE
},
2992 { "psraw", { MX
, EM
}, PREFIX_OPCODE
},
2993 { "psrad", { MX
, EM
}, PREFIX_OPCODE
},
2994 { "pavgw", { MX
, EM
}, PREFIX_OPCODE
},
2995 { "pmulhuw", { MX
, EM
}, PREFIX_OPCODE
},
2996 { "pmulhw", { MX
, EM
}, PREFIX_OPCODE
},
2997 { PREFIX_TABLE (PREFIX_0FE6
) },
2998 { PREFIX_TABLE (PREFIX_0FE7
) },
3000 { "psubsb", { MX
, EM
}, PREFIX_OPCODE
},
3001 { "psubsw", { MX
, EM
}, PREFIX_OPCODE
},
3002 { "pminsw", { MX
, EM
}, PREFIX_OPCODE
},
3003 { "por", { MX
, EM
}, PREFIX_OPCODE
},
3004 { "paddsb", { MX
, EM
}, PREFIX_OPCODE
},
3005 { "paddsw", { MX
, EM
}, PREFIX_OPCODE
},
3006 { "pmaxsw", { MX
, EM
}, PREFIX_OPCODE
},
3007 { "pxor", { MX
, EM
}, PREFIX_OPCODE
},
3009 { PREFIX_TABLE (PREFIX_0FF0
) },
3010 { "psllw", { MX
, EM
}, PREFIX_OPCODE
},
3011 { "pslld", { MX
, EM
}, PREFIX_OPCODE
},
3012 { "psllq", { MX
, EM
}, PREFIX_OPCODE
},
3013 { "pmuludq", { MX
, EM
}, PREFIX_OPCODE
},
3014 { "pmaddwd", { MX
, EM
}, PREFIX_OPCODE
},
3015 { "psadbw", { MX
, EM
}, PREFIX_OPCODE
},
3016 { PREFIX_TABLE (PREFIX_0FF7
) },
3018 { "psubb", { MX
, EM
}, PREFIX_OPCODE
},
3019 { "psubw", { MX
, EM
}, PREFIX_OPCODE
},
3020 { "psubd", { MX
, EM
}, PREFIX_OPCODE
},
3021 { "psubq", { MX
, EM
}, PREFIX_OPCODE
},
3022 { "paddb", { MX
, EM
}, PREFIX_OPCODE
},
3023 { "paddw", { MX
, EM
}, PREFIX_OPCODE
},
3024 { "paddd", { MX
, EM
}, PREFIX_OPCODE
},
3028 static const unsigned char onebyte_has_modrm
[256] = {
3029 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3030 /* ------------------------------- */
3031 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
3032 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
3033 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
3034 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
3035 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
3036 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
3037 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
3038 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
3039 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
3040 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
3041 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
3042 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
3043 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
3044 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
3045 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
3046 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
3047 /* ------------------------------- */
3048 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3051 static const unsigned char twobyte_has_modrm
[256] = {
3052 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3053 /* ------------------------------- */
3054 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
3055 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
3056 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
3057 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
3058 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
3059 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
3060 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
3061 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
3062 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
3063 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
3064 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
3065 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
3066 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
3067 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
3068 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
3069 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
3070 /* ------------------------------- */
3071 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3074 static char obuf
[100];
3076 static char *mnemonicendp
;
3077 static char scratchbuf
[100];
3078 static unsigned char *start_codep
;
3079 static unsigned char *insn_codep
;
3080 static unsigned char *codep
;
3081 static unsigned char *end_codep
;
3082 static int last_lock_prefix
;
3083 static int last_repz_prefix
;
3084 static int last_repnz_prefix
;
3085 static int last_data_prefix
;
3086 static int last_addr_prefix
;
3087 static int last_rex_prefix
;
3088 static int last_seg_prefix
;
3089 static int fwait_prefix
;
3090 /* The active segment register prefix. */
3091 static int active_seg_prefix
;
3092 #define MAX_CODE_LENGTH 15
3093 /* We can up to 14 prefixes since the maximum instruction length is
3095 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
3096 static disassemble_info
*the_info
;
3104 static unsigned char need_modrm
;
3114 int register_specifier
;
3121 int mask_register_specifier
;
3127 static unsigned char need_vex
;
3128 static unsigned char need_vex_reg
;
3129 static unsigned char vex_w_done
;
3137 /* If we are accessing mod/rm/reg without need_modrm set, then the
3138 values are stale. Hitting this abort likely indicates that you
3139 need to update onebyte_has_modrm or twobyte_has_modrm. */
3140 #define MODRM_CHECK if (!need_modrm) abort ()
3142 static const char **names64
;
3143 static const char **names32
;
3144 static const char **names16
;
3145 static const char **names8
;
3146 static const char **names8rex
;
3147 static const char **names_seg
;
3148 static const char *index64
;
3149 static const char *index32
;
3150 static const char **index16
;
3151 static const char **names_bnd
;
3153 static const char *intel_names64
[] = {
3154 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
3155 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3157 static const char *intel_names32
[] = {
3158 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
3159 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
3161 static const char *intel_names16
[] = {
3162 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
3163 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
3165 static const char *intel_names8
[] = {
3166 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
3168 static const char *intel_names8rex
[] = {
3169 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
3170 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
3172 static const char *intel_names_seg
[] = {
3173 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
3175 static const char *intel_index64
= "riz";
3176 static const char *intel_index32
= "eiz";
3177 static const char *intel_index16
[] = {
3178 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
3181 static const char *att_names64
[] = {
3182 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
3183 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
3185 static const char *att_names32
[] = {
3186 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
3187 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
3189 static const char *att_names16
[] = {
3190 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
3191 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
3193 static const char *att_names8
[] = {
3194 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
3196 static const char *att_names8rex
[] = {
3197 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
3198 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
3200 static const char *att_names_seg
[] = {
3201 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
3203 static const char *att_index64
= "%riz";
3204 static const char *att_index32
= "%eiz";
3205 static const char *att_index16
[] = {
3206 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
3209 static const char **names_mm
;
3210 static const char *intel_names_mm
[] = {
3211 "mm0", "mm1", "mm2", "mm3",
3212 "mm4", "mm5", "mm6", "mm7"
3214 static const char *att_names_mm
[] = {
3215 "%mm0", "%mm1", "%mm2", "%mm3",
3216 "%mm4", "%mm5", "%mm6", "%mm7"
3219 static const char *intel_names_bnd
[] = {
3220 "bnd0", "bnd1", "bnd2", "bnd3"
3223 static const char *att_names_bnd
[] = {
3224 "%bnd0", "%bnd1", "%bnd2", "%bnd3"
3227 static const char **names_xmm
;
3228 static const char *intel_names_xmm
[] = {
3229 "xmm0", "xmm1", "xmm2", "xmm3",
3230 "xmm4", "xmm5", "xmm6", "xmm7",
3231 "xmm8", "xmm9", "xmm10", "xmm11",
3232 "xmm12", "xmm13", "xmm14", "xmm15",
3233 "xmm16", "xmm17", "xmm18", "xmm19",
3234 "xmm20", "xmm21", "xmm22", "xmm23",
3235 "xmm24", "xmm25", "xmm26", "xmm27",
3236 "xmm28", "xmm29", "xmm30", "xmm31"
3238 static const char *att_names_xmm
[] = {
3239 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
3240 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
3241 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
3242 "%xmm12", "%xmm13", "%xmm14", "%xmm15",
3243 "%xmm16", "%xmm17", "%xmm18", "%xmm19",
3244 "%xmm20", "%xmm21", "%xmm22", "%xmm23",
3245 "%xmm24", "%xmm25", "%xmm26", "%xmm27",
3246 "%xmm28", "%xmm29", "%xmm30", "%xmm31"
3249 static const char **names_ymm
;
3250 static const char *intel_names_ymm
[] = {
3251 "ymm0", "ymm1", "ymm2", "ymm3",
3252 "ymm4", "ymm5", "ymm6", "ymm7",
3253 "ymm8", "ymm9", "ymm10", "ymm11",
3254 "ymm12", "ymm13", "ymm14", "ymm15",
3255 "ymm16", "ymm17", "ymm18", "ymm19",
3256 "ymm20", "ymm21", "ymm22", "ymm23",
3257 "ymm24", "ymm25", "ymm26", "ymm27",
3258 "ymm28", "ymm29", "ymm30", "ymm31"
3260 static const char *att_names_ymm
[] = {
3261 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
3262 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
3263 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
3264 "%ymm12", "%ymm13", "%ymm14", "%ymm15",
3265 "%ymm16", "%ymm17", "%ymm18", "%ymm19",
3266 "%ymm20", "%ymm21", "%ymm22", "%ymm23",
3267 "%ymm24", "%ymm25", "%ymm26", "%ymm27",
3268 "%ymm28", "%ymm29", "%ymm30", "%ymm31"
3271 static const char **names_zmm
;
3272 static const char *intel_names_zmm
[] = {
3273 "zmm0", "zmm1", "zmm2", "zmm3",
3274 "zmm4", "zmm5", "zmm6", "zmm7",
3275 "zmm8", "zmm9", "zmm10", "zmm11",
3276 "zmm12", "zmm13", "zmm14", "zmm15",
3277 "zmm16", "zmm17", "zmm18", "zmm19",
3278 "zmm20", "zmm21", "zmm22", "zmm23",
3279 "zmm24", "zmm25", "zmm26", "zmm27",
3280 "zmm28", "zmm29", "zmm30", "zmm31"
3282 static const char *att_names_zmm
[] = {
3283 "%zmm0", "%zmm1", "%zmm2", "%zmm3",
3284 "%zmm4", "%zmm5", "%zmm6", "%zmm7",
3285 "%zmm8", "%zmm9", "%zmm10", "%zmm11",
3286 "%zmm12", "%zmm13", "%zmm14", "%zmm15",
3287 "%zmm16", "%zmm17", "%zmm18", "%zmm19",
3288 "%zmm20", "%zmm21", "%zmm22", "%zmm23",
3289 "%zmm24", "%zmm25", "%zmm26", "%zmm27",
3290 "%zmm28", "%zmm29", "%zmm30", "%zmm31"
3293 static const char **names_mask
;
3294 static const char *intel_names_mask
[] = {
3295 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
3297 static const char *att_names_mask
[] = {
3298 "%k0", "%k1", "%k2", "%k3", "%k4", "%k5", "%k6", "%k7"
3301 static const char *names_rounding
[] =
3309 static const struct dis386 reg_table
[][8] = {
3312 { "addA", { Ebh1
, Ib
}, 0 },
3313 { "orA", { Ebh1
, Ib
}, 0 },
3314 { "adcA", { Ebh1
, Ib
}, 0 },
3315 { "sbbA", { Ebh1
, Ib
}, 0 },
3316 { "andA", { Ebh1
, Ib
}, 0 },
3317 { "subA", { Ebh1
, Ib
}, 0 },
3318 { "xorA", { Ebh1
, Ib
}, 0 },
3319 { "cmpA", { Eb
, Ib
}, 0 },
3323 { "addQ", { Evh1
, Iv
}, 0 },
3324 { "orQ", { Evh1
, Iv
}, 0 },
3325 { "adcQ", { Evh1
, Iv
}, 0 },
3326 { "sbbQ", { Evh1
, Iv
}, 0 },
3327 { "andQ", { Evh1
, Iv
}, 0 },
3328 { "subQ", { Evh1
, Iv
}, 0 },
3329 { "xorQ", { Evh1
, Iv
}, 0 },
3330 { "cmpQ", { Ev
, Iv
}, 0 },
3334 { "addQ", { Evh1
, sIb
}, 0 },
3335 { "orQ", { Evh1
, sIb
}, 0 },
3336 { "adcQ", { Evh1
, sIb
}, 0 },
3337 { "sbbQ", { Evh1
, sIb
}, 0 },
3338 { "andQ", { Evh1
, sIb
}, 0 },
3339 { "subQ", { Evh1
, sIb
}, 0 },
3340 { "xorQ", { Evh1
, sIb
}, 0 },
3341 { "cmpQ", { Ev
, sIb
}, 0 },
3345 { "popU", { stackEv
}, 0 },
3346 { XOP_8F_TABLE (XOP_09
) },
3350 { XOP_8F_TABLE (XOP_09
) },
3354 { "rolA", { Eb
, Ib
}, 0 },
3355 { "rorA", { Eb
, Ib
}, 0 },
3356 { "rclA", { Eb
, Ib
}, 0 },
3357 { "rcrA", { Eb
, Ib
}, 0 },
3358 { "shlA", { Eb
, Ib
}, 0 },
3359 { "shrA", { Eb
, Ib
}, 0 },
3361 { "sarA", { Eb
, Ib
}, 0 },
3365 { "rolQ", { Ev
, Ib
}, 0 },
3366 { "rorQ", { Ev
, Ib
}, 0 },
3367 { "rclQ", { Ev
, Ib
}, 0 },
3368 { "rcrQ", { Ev
, Ib
}, 0 },
3369 { "shlQ", { Ev
, Ib
}, 0 },
3370 { "shrQ", { Ev
, Ib
}, 0 },
3372 { "sarQ", { Ev
, Ib
}, 0 },
3376 { "movA", { Ebh3
, Ib
}, 0 },
3383 { MOD_TABLE (MOD_C6_REG_7
) },
3387 { "movQ", { Evh3
, Iv
}, 0 },
3394 { MOD_TABLE (MOD_C7_REG_7
) },
3398 { "rolA", { Eb
, I1
}, 0 },
3399 { "rorA", { Eb
, I1
}, 0 },
3400 { "rclA", { Eb
, I1
}, 0 },
3401 { "rcrA", { Eb
, I1
}, 0 },
3402 { "shlA", { Eb
, I1
}, 0 },
3403 { "shrA", { Eb
, I1
}, 0 },
3405 { "sarA", { Eb
, I1
}, 0 },
3409 { "rolQ", { Ev
, I1
}, 0 },
3410 { "rorQ", { Ev
, I1
}, 0 },
3411 { "rclQ", { Ev
, I1
}, 0 },
3412 { "rcrQ", { Ev
, I1
}, 0 },
3413 { "shlQ", { Ev
, I1
}, 0 },
3414 { "shrQ", { Ev
, I1
}, 0 },
3416 { "sarQ", { Ev
, I1
}, 0 },
3420 { "rolA", { Eb
, CL
}, 0 },
3421 { "rorA", { Eb
, CL
}, 0 },
3422 { "rclA", { Eb
, CL
}, 0 },
3423 { "rcrA", { Eb
, CL
}, 0 },
3424 { "shlA", { Eb
, CL
}, 0 },
3425 { "shrA", { Eb
, CL
}, 0 },
3427 { "sarA", { Eb
, CL
}, 0 },
3431 { "rolQ", { Ev
, CL
}, 0 },
3432 { "rorQ", { Ev
, CL
}, 0 },
3433 { "rclQ", { Ev
, CL
}, 0 },
3434 { "rcrQ", { Ev
, CL
}, 0 },
3435 { "shlQ", { Ev
, CL
}, 0 },
3436 { "shrQ", { Ev
, CL
}, 0 },
3438 { "sarQ", { Ev
, CL
}, 0 },
3442 { "testA", { Eb
, Ib
}, 0 },
3444 { "notA", { Ebh1
}, 0 },
3445 { "negA", { Ebh1
}, 0 },
3446 { "mulA", { Eb
}, 0 }, /* Don't print the implicit %al register, */
3447 { "imulA", { Eb
}, 0 }, /* to distinguish these opcodes from other */
3448 { "divA", { Eb
}, 0 }, /* mul/imul opcodes. Do the same for div */
3449 { "idivA", { Eb
}, 0 }, /* and idiv for consistency. */
3453 { "testQ", { Ev
, Iv
}, 0 },
3455 { "notQ", { Evh1
}, 0 },
3456 { "negQ", { Evh1
}, 0 },
3457 { "mulQ", { Ev
}, 0 }, /* Don't print the implicit register. */
3458 { "imulQ", { Ev
}, 0 },
3459 { "divQ", { Ev
}, 0 },
3460 { "idivQ", { Ev
}, 0 },
3464 { "incA", { Ebh1
}, 0 },
3465 { "decA", { Ebh1
}, 0 },
3469 { "incQ", { Evh1
}, 0 },
3470 { "decQ", { Evh1
}, 0 },
3471 { "call{T|}", { indirEv
, BND
}, 0 },
3472 { MOD_TABLE (MOD_FF_REG_3
) },
3473 { "jmp{T|}", { indirEv
, BND
}, 0 },
3474 { MOD_TABLE (MOD_FF_REG_5
) },
3475 { "pushU", { stackEv
}, 0 },
3480 { "sldtD", { Sv
}, 0 },
3481 { "strD", { Sv
}, 0 },
3482 { "lldt", { Ew
}, 0 },
3483 { "ltr", { Ew
}, 0 },
3484 { "verr", { Ew
}, 0 },
3485 { "verw", { Ew
}, 0 },
3491 { MOD_TABLE (MOD_0F01_REG_0
) },
3492 { MOD_TABLE (MOD_0F01_REG_1
) },
3493 { MOD_TABLE (MOD_0F01_REG_2
) },
3494 { MOD_TABLE (MOD_0F01_REG_3
) },
3495 { "smswD", { Sv
}, 0 },
3497 { "lmsw", { Ew
}, 0 },
3498 { MOD_TABLE (MOD_0F01_REG_7
) },
3502 { "prefetch", { Mb
}, 0 },
3503 { "prefetchw", { Mb
}, 0 },
3504 { "prefetchwt1", { Mb
}, 0 },
3505 { "prefetch", { Mb
}, 0 },
3506 { "prefetch", { Mb
}, 0 },
3507 { "prefetch", { Mb
}, 0 },
3508 { "prefetch", { Mb
}, 0 },
3509 { "prefetch", { Mb
}, 0 },
3513 { MOD_TABLE (MOD_0F18_REG_0
) },
3514 { MOD_TABLE (MOD_0F18_REG_1
) },
3515 { MOD_TABLE (MOD_0F18_REG_2
) },
3516 { MOD_TABLE (MOD_0F18_REG_3
) },
3517 { MOD_TABLE (MOD_0F18_REG_4
) },
3518 { MOD_TABLE (MOD_0F18_REG_5
) },
3519 { MOD_TABLE (MOD_0F18_REG_6
) },
3520 { MOD_TABLE (MOD_0F18_REG_7
) },
3526 { MOD_TABLE (MOD_0F71_REG_2
) },
3528 { MOD_TABLE (MOD_0F71_REG_4
) },
3530 { MOD_TABLE (MOD_0F71_REG_6
) },
3536 { MOD_TABLE (MOD_0F72_REG_2
) },
3538 { MOD_TABLE (MOD_0F72_REG_4
) },
3540 { MOD_TABLE (MOD_0F72_REG_6
) },
3546 { MOD_TABLE (MOD_0F73_REG_2
) },
3547 { MOD_TABLE (MOD_0F73_REG_3
) },
3550 { MOD_TABLE (MOD_0F73_REG_6
) },
3551 { MOD_TABLE (MOD_0F73_REG_7
) },
3555 { "montmul", { { OP_0f07
, 0 } }, 0 },
3556 { "xsha1", { { OP_0f07
, 0 } }, 0 },
3557 { "xsha256", { { OP_0f07
, 0 } }, 0 },
3561 { "xstore-rng", { { OP_0f07
, 0 } }, 0 },
3562 { "xcrypt-ecb", { { OP_0f07
, 0 } }, 0 },
3563 { "xcrypt-cbc", { { OP_0f07
, 0 } }, 0 },
3564 { "xcrypt-ctr", { { OP_0f07
, 0 } }, 0 },
3565 { "xcrypt-cfb", { { OP_0f07
, 0 } }, 0 },
3566 { "xcrypt-ofb", { { OP_0f07
, 0 } }, 0 },
3570 { MOD_TABLE (MOD_0FAE_REG_0
) },
3571 { MOD_TABLE (MOD_0FAE_REG_1
) },
3572 { MOD_TABLE (MOD_0FAE_REG_2
) },
3573 { MOD_TABLE (MOD_0FAE_REG_3
) },
3574 { MOD_TABLE (MOD_0FAE_REG_4
) },
3575 { MOD_TABLE (MOD_0FAE_REG_5
) },
3576 { MOD_TABLE (MOD_0FAE_REG_6
) },
3577 { MOD_TABLE (MOD_0FAE_REG_7
) },
3585 { "btQ", { Ev
, Ib
}, 0 },
3586 { "btsQ", { Evh1
, Ib
}, 0 },
3587 { "btrQ", { Evh1
, Ib
}, 0 },
3588 { "btcQ", { Evh1
, Ib
}, 0 },
3593 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} }, 0 },
3595 { MOD_TABLE (MOD_0FC7_REG_3
) },
3596 { MOD_TABLE (MOD_0FC7_REG_4
) },
3597 { MOD_TABLE (MOD_0FC7_REG_5
) },
3598 { MOD_TABLE (MOD_0FC7_REG_6
) },
3599 { MOD_TABLE (MOD_0FC7_REG_7
) },
3605 { MOD_TABLE (MOD_VEX_0F71_REG_2
) },
3607 { MOD_TABLE (MOD_VEX_0F71_REG_4
) },
3609 { MOD_TABLE (MOD_VEX_0F71_REG_6
) },
3615 { MOD_TABLE (MOD_VEX_0F72_REG_2
) },
3617 { MOD_TABLE (MOD_VEX_0F72_REG_4
) },
3619 { MOD_TABLE (MOD_VEX_0F72_REG_6
) },
3625 { MOD_TABLE (MOD_VEX_0F73_REG_2
) },
3626 { MOD_TABLE (MOD_VEX_0F73_REG_3
) },
3629 { MOD_TABLE (MOD_VEX_0F73_REG_6
) },
3630 { MOD_TABLE (MOD_VEX_0F73_REG_7
) },
3636 { MOD_TABLE (MOD_VEX_0FAE_REG_2
) },
3637 { MOD_TABLE (MOD_VEX_0FAE_REG_3
) },
3639 /* REG_VEX_0F38F3 */
3642 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_1
) },
3643 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_2
) },
3644 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_3
) },
3648 { "llwpcb", { { OP_LWPCB_E
, 0 } }, 0 },
3649 { "slwpcb", { { OP_LWPCB_E
, 0 } }, 0 },
3653 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, Iq
}, 0 },
3654 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, Iq
}, 0 },
3656 /* REG_XOP_TBM_01 */
3659 { "blcfill", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3660 { "blsfill", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3661 { "blcs", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3662 { "tzmsk", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3663 { "blcic", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3664 { "blsic", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3665 { "t1mskc", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3667 /* REG_XOP_TBM_02 */
3670 { "blcmsk", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3675 { "blci", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3677 #define NEED_REG_TABLE
3678 #include "i386-dis-evex.h"
3679 #undef NEED_REG_TABLE
3682 static const struct dis386 prefix_table
[][4] = {
3685 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} }, 0 },
3686 { "pause", { XX
}, 0 },
3687 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} }, 0 },
3688 { NULL
, { { NULL
, 0 } }, PREFIX_IGNORED
}
3693 { "movups", { XM
, EXx
}, PREFIX_OPCODE
},
3694 { "movss", { XM
, EXd
}, PREFIX_OPCODE
},
3695 { "movupd", { XM
, EXx
}, PREFIX_OPCODE
},
3696 { "movsd", { XM
, EXq
}, PREFIX_OPCODE
},
3701 { "movups", { EXxS
, XM
}, PREFIX_OPCODE
},
3702 { "movss", { EXdS
, XM
}, PREFIX_OPCODE
},
3703 { "movupd", { EXxS
, XM
}, PREFIX_OPCODE
},
3704 { "movsd", { EXqS
, XM
}, PREFIX_OPCODE
},
3709 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
3710 { "movsldup", { XM
, EXx
}, PREFIX_OPCODE
},
3711 { "movlpd", { XM
, EXq
}, PREFIX_OPCODE
},
3712 { "movddup", { XM
, EXq
}, PREFIX_OPCODE
},
3717 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
3718 { "movshdup", { XM
, EXx
}, PREFIX_OPCODE
},
3719 { "movhpd", { XM
, EXq
}, PREFIX_OPCODE
},
3724 { MOD_TABLE (MOD_0F1A_PREFIX_0
) },
3725 { "bndcl", { Gbnd
, Ev_bnd
}, 0 },
3726 { "bndmov", { Gbnd
, Ebnd
}, 0 },
3727 { "bndcu", { Gbnd
, Ev_bnd
}, 0 },
3732 { MOD_TABLE (MOD_0F1B_PREFIX_0
) },
3733 { MOD_TABLE (MOD_0F1B_PREFIX_1
) },
3734 { "bndmov", { Ebnd
, Gbnd
}, 0 },
3735 { "bndcn", { Gbnd
, Ev_bnd
}, 0 },
3740 { "cvtpi2ps", { XM
, EMCq
}, PREFIX_OPCODE
},
3741 { "cvtsi2ss%LQ", { XM
, Ev
}, PREFIX_OPCODE
},
3742 { "cvtpi2pd", { XM
, EMCq
}, PREFIX_OPCODE
},
3743 { "cvtsi2sd%LQ", { XM
, Ev
}, 0 },
3748 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
3749 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
3750 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
3751 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
3756 { "cvttps2pi", { MXC
, EXq
}, PREFIX_OPCODE
},
3757 { "cvttss2siY", { Gv
, EXd
}, PREFIX_OPCODE
},
3758 { "cvttpd2pi", { MXC
, EXx
}, PREFIX_OPCODE
},
3759 { "cvttsd2siY", { Gv
, EXq
}, PREFIX_OPCODE
},
3764 { "cvtps2pi", { MXC
, EXq
}, PREFIX_OPCODE
},
3765 { "cvtss2siY", { Gv
, EXd
}, PREFIX_OPCODE
},
3766 { "cvtpd2pi", { MXC
, EXx
}, PREFIX_OPCODE
},
3767 { "cvtsd2siY", { Gv
, EXq
}, PREFIX_OPCODE
},
3772 { "ucomiss",{ XM
, EXd
}, 0 },
3774 { "ucomisd",{ XM
, EXq
}, 0 },
3779 { "comiss", { XM
, EXd
}, 0 },
3781 { "comisd", { XM
, EXq
}, 0 },
3786 { "sqrtps", { XM
, EXx
}, PREFIX_OPCODE
},
3787 { "sqrtss", { XM
, EXd
}, PREFIX_OPCODE
},
3788 { "sqrtpd", { XM
, EXx
}, PREFIX_OPCODE
},
3789 { "sqrtsd", { XM
, EXq
}, PREFIX_OPCODE
},
3794 { "rsqrtps",{ XM
, EXx
}, PREFIX_OPCODE
},
3795 { "rsqrtss",{ XM
, EXd
}, PREFIX_OPCODE
},
3800 { "rcpps", { XM
, EXx
}, PREFIX_OPCODE
},
3801 { "rcpss", { XM
, EXd
}, PREFIX_OPCODE
},
3806 { "addps", { XM
, EXx
}, PREFIX_OPCODE
},
3807 { "addss", { XM
, EXd
}, PREFIX_OPCODE
},
3808 { "addpd", { XM
, EXx
}, PREFIX_OPCODE
},
3809 { "addsd", { XM
, EXq
}, PREFIX_OPCODE
},
3814 { "mulps", { XM
, EXx
}, PREFIX_OPCODE
},
3815 { "mulss", { XM
, EXd
}, PREFIX_OPCODE
},
3816 { "mulpd", { XM
, EXx
}, PREFIX_OPCODE
},
3817 { "mulsd", { XM
, EXq
}, PREFIX_OPCODE
},
3822 { "cvtps2pd", { XM
, EXq
}, PREFIX_OPCODE
},
3823 { "cvtss2sd", { XM
, EXd
}, PREFIX_OPCODE
},
3824 { "cvtpd2ps", { XM
, EXx
}, PREFIX_OPCODE
},
3825 { "cvtsd2ss", { XM
, EXq
}, PREFIX_OPCODE
},
3830 { "cvtdq2ps", { XM
, EXx
}, PREFIX_OPCODE
},
3831 { "cvttps2dq", { XM
, EXx
}, PREFIX_OPCODE
},
3832 { "cvtps2dq", { XM
, EXx
}, PREFIX_OPCODE
},
3837 { "subps", { XM
, EXx
}, PREFIX_OPCODE
},
3838 { "subss", { XM
, EXd
}, PREFIX_OPCODE
},
3839 { "subpd", { XM
, EXx
}, PREFIX_OPCODE
},
3840 { "subsd", { XM
, EXq
}, PREFIX_OPCODE
},
3845 { "minps", { XM
, EXx
}, PREFIX_OPCODE
},
3846 { "minss", { XM
, EXd
}, PREFIX_OPCODE
},
3847 { "minpd", { XM
, EXx
}, PREFIX_OPCODE
},
3848 { "minsd", { XM
, EXq
}, PREFIX_OPCODE
},
3853 { "divps", { XM
, EXx
}, PREFIX_OPCODE
},
3854 { "divss", { XM
, EXd
}, PREFIX_OPCODE
},
3855 { "divpd", { XM
, EXx
}, PREFIX_OPCODE
},
3856 { "divsd", { XM
, EXq
}, PREFIX_OPCODE
},
3861 { "maxps", { XM
, EXx
}, PREFIX_OPCODE
},
3862 { "maxss", { XM
, EXd
}, PREFIX_OPCODE
},
3863 { "maxpd", { XM
, EXx
}, PREFIX_OPCODE
},
3864 { "maxsd", { XM
, EXq
}, PREFIX_OPCODE
},
3869 { "punpcklbw",{ MX
, EMd
}, PREFIX_OPCODE
},
3871 { "punpcklbw",{ MX
, EMx
}, PREFIX_OPCODE
},
3876 { "punpcklwd",{ MX
, EMd
}, PREFIX_OPCODE
},
3878 { "punpcklwd",{ MX
, EMx
}, PREFIX_OPCODE
},
3883 { "punpckldq",{ MX
, EMd
}, PREFIX_OPCODE
},
3885 { "punpckldq",{ MX
, EMx
}, PREFIX_OPCODE
},
3892 { "punpcklqdq", { XM
, EXx
}, PREFIX_OPCODE
},
3899 { "punpckhqdq", { XM
, EXx
}, PREFIX_OPCODE
},
3904 { "movq", { MX
, EM
}, PREFIX_OPCODE
},
3905 { "movdqu", { XM
, EXx
}, PREFIX_OPCODE
},
3906 { "movdqa", { XM
, EXx
}, PREFIX_OPCODE
},
3911 { "pshufw", { MX
, EM
, Ib
}, PREFIX_OPCODE
},
3912 { "pshufhw",{ XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3913 { "pshufd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3914 { "pshuflw",{ XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3917 /* PREFIX_0F73_REG_3 */
3921 { "psrldq", { XS
, Ib
}, 0 },
3924 /* PREFIX_0F73_REG_7 */
3928 { "pslldq", { XS
, Ib
}, 0 },
3933 {"vmread", { Em
, Gm
}, 0 },
3935 {"extrq", { XS
, Ib
, Ib
}, 0 },
3936 {"insertq", { XM
, XS
, Ib
, Ib
}, 0 },
3941 {"vmwrite", { Gm
, Em
}, 0 },
3943 {"extrq", { XM
, XS
}, 0 },
3944 {"insertq", { XM
, XS
}, 0 },
3951 { "haddpd", { XM
, EXx
}, PREFIX_OPCODE
},
3952 { "haddps", { XM
, EXx
}, PREFIX_OPCODE
},
3959 { "hsubpd", { XM
, EXx
}, PREFIX_OPCODE
},
3960 { "hsubps", { XM
, EXx
}, PREFIX_OPCODE
},
3965 { "movK", { Edq
, MX
}, PREFIX_OPCODE
},
3966 { "movq", { XM
, EXq
}, PREFIX_OPCODE
},
3967 { "movK", { Edq
, XM
}, PREFIX_OPCODE
},
3972 { "movq", { EMS
, MX
}, PREFIX_OPCODE
},
3973 { "movdqu", { EXxS
, XM
}, PREFIX_OPCODE
},
3974 { "movdqa", { EXxS
, XM
}, PREFIX_OPCODE
},
3977 /* PREFIX_0FAE_REG_0 */
3980 { "rdfsbase", { Ev
}, 0 },
3983 /* PREFIX_0FAE_REG_1 */
3986 { "rdgsbase", { Ev
}, 0 },
3989 /* PREFIX_0FAE_REG_2 */
3992 { "wrfsbase", { Ev
}, 0 },
3995 /* PREFIX_0FAE_REG_3 */
3998 { "wrgsbase", { Ev
}, 0 },
4001 /* PREFIX_0FAE_REG_6 */
4003 { "xsaveopt", { FXSAVE
}, 0 },
4005 { "clwb", { Mb
}, 0 },
4008 /* PREFIX_0FAE_REG_7 */
4010 { "clflush", { Mb
}, 0 },
4012 { "clflushopt", { Mb
}, 0 },
4015 /* PREFIX_RM_0_0FAE_REG_7 */
4017 { "sfence", { Skip_MODRM
}, 0 },
4019 { "pcommit", { Skip_MODRM
}, 0 },
4025 { "popcntS", { Gv
, Ev
}, 0 },
4030 { "bsfS", { Gv
, Ev
}, 0 },
4031 { "tzcntS", { Gv
, Ev
}, 0 },
4032 { "bsfS", { Gv
, Ev
}, 0 },
4037 { "bsrS", { Gv
, Ev
}, 0 },
4038 { "lzcntS", { Gv
, Ev
}, 0 },
4039 { "bsrS", { Gv
, Ev
}, 0 },
4044 { "cmpps", { XM
, EXx
, CMP
}, PREFIX_OPCODE
},
4045 { "cmpss", { XM
, EXd
, CMP
}, PREFIX_OPCODE
},
4046 { "cmppd", { XM
, EXx
, CMP
}, PREFIX_OPCODE
},
4047 { "cmpsd", { XM
, EXq
, CMP
}, PREFIX_OPCODE
},
4052 { "movntiS", { Ma
, Gv
}, PREFIX_OPCODE
},
4055 /* PREFIX_MOD_0_0FC7_REG_6 */
4057 { "vmptrld",{ Mq
}, 0 },
4058 { "vmxon", { Mq
}, 0 },
4059 { "vmclear",{ Mq
}, 0 },
4062 /* PREFIX_MOD_3_0FC7_REG_6 */
4064 { "rdrand", { Ev
}, 0 },
4066 { "rdrand", { Ev
}, 0 }
4069 /* PREFIX_MOD_3_0FC7_REG_7 */
4071 { "rdseed", { Ev
}, 0 },
4073 { "rdseed", { Ev
}, 0 },
4080 { "addsubpd", { XM
, EXx
}, 0 },
4081 { "addsubps", { XM
, EXx
}, 0 },
4087 { "movq2dq",{ XM
, MS
}, 0 },
4088 { "movq", { EXqS
, XM
}, 0 },
4089 { "movdq2q",{ MX
, XS
}, 0 },
4095 { "cvtdq2pd", { XM
, EXq
}, PREFIX_OPCODE
},
4096 { "cvttpd2dq", { XM
, EXx
}, PREFIX_OPCODE
},
4097 { "cvtpd2dq", { XM
, EXx
}, PREFIX_OPCODE
},
4102 { "movntq", { Mq
, MX
}, PREFIX_OPCODE
},
4104 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
4112 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
4117 { "maskmovq", { MX
, MS
}, PREFIX_OPCODE
},
4119 { "maskmovdqu", { XM
, XS
}, PREFIX_OPCODE
},
4126 { "pblendvb", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4133 { "blendvps", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4140 { "blendvpd", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4147 { "ptest", { XM
, EXx
}, PREFIX_OPCODE
},
4154 { "pmovsxbw", { XM
, EXq
}, PREFIX_OPCODE
},
4161 { "pmovsxbd", { XM
, EXd
}, PREFIX_OPCODE
},
4168 { "pmovsxbq", { XM
, EXw
}, PREFIX_OPCODE
},
4175 { "pmovsxwd", { XM
, EXq
}, PREFIX_OPCODE
},
4182 { "pmovsxwq", { XM
, EXd
}, PREFIX_OPCODE
},
4189 { "pmovsxdq", { XM
, EXq
}, PREFIX_OPCODE
},
4196 { "pmuldq", { XM
, EXx
}, PREFIX_OPCODE
},
4203 { "pcmpeqq", { XM
, EXx
}, PREFIX_OPCODE
},
4210 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
4217 { "packusdw", { XM
, EXx
}, PREFIX_OPCODE
},
4224 { "pmovzxbw", { XM
, EXq
}, PREFIX_OPCODE
},
4231 { "pmovzxbd", { XM
, EXd
}, PREFIX_OPCODE
},
4238 { "pmovzxbq", { XM
, EXw
}, PREFIX_OPCODE
},
4245 { "pmovzxwd", { XM
, EXq
}, PREFIX_OPCODE
},
4252 { "pmovzxwq", { XM
, EXd
}, PREFIX_OPCODE
},
4259 { "pmovzxdq", { XM
, EXq
}, PREFIX_OPCODE
},
4266 { "pcmpgtq", { XM
, EXx
}, PREFIX_OPCODE
},
4273 { "pminsb", { XM
, EXx
}, PREFIX_OPCODE
},
4280 { "pminsd", { XM
, EXx
}, PREFIX_OPCODE
},
4287 { "pminuw", { XM
, EXx
}, PREFIX_OPCODE
},
4294 { "pminud", { XM
, EXx
}, PREFIX_OPCODE
},
4301 { "pmaxsb", { XM
, EXx
}, PREFIX_OPCODE
},
4308 { "pmaxsd", { XM
, EXx
}, PREFIX_OPCODE
},
4315 { "pmaxuw", { XM
, EXx
}, PREFIX_OPCODE
},
4322 { "pmaxud", { XM
, EXx
}, PREFIX_OPCODE
},
4329 { "pmulld", { XM
, EXx
}, PREFIX_OPCODE
},
4336 { "phminposuw", { XM
, EXx
}, PREFIX_OPCODE
},
4343 { "invept", { Gm
, Mo
}, PREFIX_OPCODE
},
4350 { "invvpid", { Gm
, Mo
}, PREFIX_OPCODE
},
4357 { "invpcid", { Gm
, M
}, PREFIX_OPCODE
},
4362 { "sha1nexte", { XM
, EXxmm
}, PREFIX_OPCODE
},
4367 { "sha1msg1", { XM
, EXxmm
}, PREFIX_OPCODE
},
4372 { "sha1msg2", { XM
, EXxmm
}, PREFIX_OPCODE
},
4377 { "sha256rnds2", { XM
, EXxmm
, XMM0
}, PREFIX_OPCODE
},
4382 { "sha256msg1", { XM
, EXxmm
}, PREFIX_OPCODE
},
4387 { "sha256msg2", { XM
, EXxmm
}, PREFIX_OPCODE
},
4394 { "aesimc", { XM
, EXx
}, PREFIX_OPCODE
},
4401 { "aesenc", { XM
, EXx
}, PREFIX_OPCODE
},
4408 { "aesenclast", { XM
, EXx
}, PREFIX_OPCODE
},
4415 { "aesdec", { XM
, EXx
}, PREFIX_OPCODE
},
4422 { "aesdeclast", { XM
, EXx
}, PREFIX_OPCODE
},
4427 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4429 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4430 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} }, PREFIX_OPCODE
},
4435 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
}, PREFIX_OPCODE
},
4437 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
}, PREFIX_OPCODE
},
4438 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4444 { "adoxS", { Gdq
, Edq
}, PREFIX_OPCODE
},
4445 { "adcxS", { Gdq
, Edq
}, PREFIX_OPCODE
},
4453 { "roundps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4460 { "roundpd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4467 { "roundss", { XM
, EXd
, Ib
}, PREFIX_OPCODE
},
4474 { "roundsd", { XM
, EXq
, Ib
}, PREFIX_OPCODE
},
4481 { "blendps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4488 { "blendpd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4495 { "pblendw", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4502 { "pextrb", { Edqb
, XM
, Ib
}, PREFIX_OPCODE
},
4509 { "pextrw", { Edqw
, XM
, Ib
}, PREFIX_OPCODE
},
4516 { "pextrK", { Edq
, XM
, Ib
}, PREFIX_OPCODE
},
4523 { "extractps", { Edqd
, XM
, Ib
}, PREFIX_OPCODE
},
4530 { "pinsrb", { XM
, Edqb
, Ib
}, PREFIX_OPCODE
},
4537 { "insertps", { XM
, EXd
, Ib
}, PREFIX_OPCODE
},
4544 { "pinsrK", { XM
, Edq
, Ib
}, PREFIX_OPCODE
},
4551 { "dpps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4558 { "dppd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4565 { "mpsadbw", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4572 { "pclmulqdq", { XM
, EXx
, PCLMUL
}, PREFIX_OPCODE
},
4579 { "pcmpestrm", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4586 { "pcmpestri", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4593 { "pcmpistrm", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4600 { "pcmpistri", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4605 { "sha1rnds4", { XM
, EXxmm
, Ib
}, PREFIX_OPCODE
},
4612 { "aeskeygenassist", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4615 /* PREFIX_VEX_0F10 */
4617 { VEX_W_TABLE (VEX_W_0F10_P_0
) },
4618 { VEX_LEN_TABLE (VEX_LEN_0F10_P_1
) },
4619 { VEX_W_TABLE (VEX_W_0F10_P_2
) },
4620 { VEX_LEN_TABLE (VEX_LEN_0F10_P_3
) },
4623 /* PREFIX_VEX_0F11 */
4625 { VEX_W_TABLE (VEX_W_0F11_P_0
) },
4626 { VEX_LEN_TABLE (VEX_LEN_0F11_P_1
) },
4627 { VEX_W_TABLE (VEX_W_0F11_P_2
) },
4628 { VEX_LEN_TABLE (VEX_LEN_0F11_P_3
) },
4631 /* PREFIX_VEX_0F12 */
4633 { MOD_TABLE (MOD_VEX_0F12_PREFIX_0
) },
4634 { VEX_W_TABLE (VEX_W_0F12_P_1
) },
4635 { VEX_LEN_TABLE (VEX_LEN_0F12_P_2
) },
4636 { VEX_W_TABLE (VEX_W_0F12_P_3
) },
4639 /* PREFIX_VEX_0F16 */
4641 { MOD_TABLE (MOD_VEX_0F16_PREFIX_0
) },
4642 { VEX_W_TABLE (VEX_W_0F16_P_1
) },
4643 { VEX_LEN_TABLE (VEX_LEN_0F16_P_2
) },
4646 /* PREFIX_VEX_0F2A */
4649 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_1
) },
4651 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_3
) },
4654 /* PREFIX_VEX_0F2C */
4657 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_1
) },
4659 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_3
) },
4662 /* PREFIX_VEX_0F2D */
4665 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_1
) },
4667 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_3
) },
4670 /* PREFIX_VEX_0F2E */
4672 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_0
) },
4674 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_2
) },
4677 /* PREFIX_VEX_0F2F */
4679 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_0
) },
4681 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_2
) },
4684 /* PREFIX_VEX_0F41 */
4686 { VEX_LEN_TABLE (VEX_LEN_0F41_P_0
) },
4688 { VEX_LEN_TABLE (VEX_LEN_0F41_P_2
) },
4691 /* PREFIX_VEX_0F42 */
4693 { VEX_LEN_TABLE (VEX_LEN_0F42_P_0
) },
4695 { VEX_LEN_TABLE (VEX_LEN_0F42_P_2
) },
4698 /* PREFIX_VEX_0F44 */
4700 { VEX_LEN_TABLE (VEX_LEN_0F44_P_0
) },
4702 { VEX_LEN_TABLE (VEX_LEN_0F44_P_2
) },
4705 /* PREFIX_VEX_0F45 */
4707 { VEX_LEN_TABLE (VEX_LEN_0F45_P_0
) },
4709 { VEX_LEN_TABLE (VEX_LEN_0F45_P_2
) },
4712 /* PREFIX_VEX_0F46 */
4714 { VEX_LEN_TABLE (VEX_LEN_0F46_P_0
) },
4716 { VEX_LEN_TABLE (VEX_LEN_0F46_P_2
) },
4719 /* PREFIX_VEX_0F47 */
4721 { VEX_LEN_TABLE (VEX_LEN_0F47_P_0
) },
4723 { VEX_LEN_TABLE (VEX_LEN_0F47_P_2
) },
4726 /* PREFIX_VEX_0F4A */
4728 { VEX_LEN_TABLE (VEX_LEN_0F4A_P_0
) },
4730 { VEX_LEN_TABLE (VEX_LEN_0F4A_P_2
) },
4733 /* PREFIX_VEX_0F4B */
4735 { VEX_LEN_TABLE (VEX_LEN_0F4B_P_0
) },
4737 { VEX_LEN_TABLE (VEX_LEN_0F4B_P_2
) },
4740 /* PREFIX_VEX_0F51 */
4742 { VEX_W_TABLE (VEX_W_0F51_P_0
) },
4743 { VEX_LEN_TABLE (VEX_LEN_0F51_P_1
) },
4744 { VEX_W_TABLE (VEX_W_0F51_P_2
) },
4745 { VEX_LEN_TABLE (VEX_LEN_0F51_P_3
) },
4748 /* PREFIX_VEX_0F52 */
4750 { VEX_W_TABLE (VEX_W_0F52_P_0
) },
4751 { VEX_LEN_TABLE (VEX_LEN_0F52_P_1
) },
4754 /* PREFIX_VEX_0F53 */
4756 { VEX_W_TABLE (VEX_W_0F53_P_0
) },
4757 { VEX_LEN_TABLE (VEX_LEN_0F53_P_1
) },
4760 /* PREFIX_VEX_0F58 */
4762 { VEX_W_TABLE (VEX_W_0F58_P_0
) },
4763 { VEX_LEN_TABLE (VEX_LEN_0F58_P_1
) },
4764 { VEX_W_TABLE (VEX_W_0F58_P_2
) },
4765 { VEX_LEN_TABLE (VEX_LEN_0F58_P_3
) },
4768 /* PREFIX_VEX_0F59 */
4770 { VEX_W_TABLE (VEX_W_0F59_P_0
) },
4771 { VEX_LEN_TABLE (VEX_LEN_0F59_P_1
) },
4772 { VEX_W_TABLE (VEX_W_0F59_P_2
) },
4773 { VEX_LEN_TABLE (VEX_LEN_0F59_P_3
) },
4776 /* PREFIX_VEX_0F5A */
4778 { VEX_W_TABLE (VEX_W_0F5A_P_0
) },
4779 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_1
) },
4780 { "vcvtpd2ps%XY", { XMM
, EXx
}, 0 },
4781 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_3
) },
4784 /* PREFIX_VEX_0F5B */
4786 { VEX_W_TABLE (VEX_W_0F5B_P_0
) },
4787 { VEX_W_TABLE (VEX_W_0F5B_P_1
) },
4788 { VEX_W_TABLE (VEX_W_0F5B_P_2
) },
4791 /* PREFIX_VEX_0F5C */
4793 { VEX_W_TABLE (VEX_W_0F5C_P_0
) },
4794 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_1
) },
4795 { VEX_W_TABLE (VEX_W_0F5C_P_2
) },
4796 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_3
) },
4799 /* PREFIX_VEX_0F5D */
4801 { VEX_W_TABLE (VEX_W_0F5D_P_0
) },
4802 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_1
) },
4803 { VEX_W_TABLE (VEX_W_0F5D_P_2
) },
4804 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_3
) },
4807 /* PREFIX_VEX_0F5E */
4809 { VEX_W_TABLE (VEX_W_0F5E_P_0
) },
4810 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_1
) },
4811 { VEX_W_TABLE (VEX_W_0F5E_P_2
) },
4812 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_3
) },
4815 /* PREFIX_VEX_0F5F */
4817 { VEX_W_TABLE (VEX_W_0F5F_P_0
) },
4818 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_1
) },
4819 { VEX_W_TABLE (VEX_W_0F5F_P_2
) },
4820 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_3
) },
4823 /* PREFIX_VEX_0F60 */
4827 { VEX_W_TABLE (VEX_W_0F60_P_2
) },
4830 /* PREFIX_VEX_0F61 */
4834 { VEX_W_TABLE (VEX_W_0F61_P_2
) },
4837 /* PREFIX_VEX_0F62 */
4841 { VEX_W_TABLE (VEX_W_0F62_P_2
) },
4844 /* PREFIX_VEX_0F63 */
4848 { VEX_W_TABLE (VEX_W_0F63_P_2
) },
4851 /* PREFIX_VEX_0F64 */
4855 { VEX_W_TABLE (VEX_W_0F64_P_2
) },
4858 /* PREFIX_VEX_0F65 */
4862 { VEX_W_TABLE (VEX_W_0F65_P_2
) },
4865 /* PREFIX_VEX_0F66 */
4869 { VEX_W_TABLE (VEX_W_0F66_P_2
) },
4872 /* PREFIX_VEX_0F67 */
4876 { VEX_W_TABLE (VEX_W_0F67_P_2
) },
4879 /* PREFIX_VEX_0F68 */
4883 { VEX_W_TABLE (VEX_W_0F68_P_2
) },
4886 /* PREFIX_VEX_0F69 */
4890 { VEX_W_TABLE (VEX_W_0F69_P_2
) },
4893 /* PREFIX_VEX_0F6A */
4897 { VEX_W_TABLE (VEX_W_0F6A_P_2
) },
4900 /* PREFIX_VEX_0F6B */
4904 { VEX_W_TABLE (VEX_W_0F6B_P_2
) },
4907 /* PREFIX_VEX_0F6C */
4911 { VEX_W_TABLE (VEX_W_0F6C_P_2
) },
4914 /* PREFIX_VEX_0F6D */
4918 { VEX_W_TABLE (VEX_W_0F6D_P_2
) },
4921 /* PREFIX_VEX_0F6E */
4925 { VEX_LEN_TABLE (VEX_LEN_0F6E_P_2
) },
4928 /* PREFIX_VEX_0F6F */
4931 { VEX_W_TABLE (VEX_W_0F6F_P_1
) },
4932 { VEX_W_TABLE (VEX_W_0F6F_P_2
) },
4935 /* PREFIX_VEX_0F70 */
4938 { VEX_W_TABLE (VEX_W_0F70_P_1
) },
4939 { VEX_W_TABLE (VEX_W_0F70_P_2
) },
4940 { VEX_W_TABLE (VEX_W_0F70_P_3
) },
4943 /* PREFIX_VEX_0F71_REG_2 */
4947 { VEX_W_TABLE (VEX_W_0F71_R_2_P_2
) },
4950 /* PREFIX_VEX_0F71_REG_4 */
4954 { VEX_W_TABLE (VEX_W_0F71_R_4_P_2
) },
4957 /* PREFIX_VEX_0F71_REG_6 */
4961 { VEX_W_TABLE (VEX_W_0F71_R_6_P_2
) },
4964 /* PREFIX_VEX_0F72_REG_2 */
4968 { VEX_W_TABLE (VEX_W_0F72_R_2_P_2
) },
4971 /* PREFIX_VEX_0F72_REG_4 */
4975 { VEX_W_TABLE (VEX_W_0F72_R_4_P_2
) },
4978 /* PREFIX_VEX_0F72_REG_6 */
4982 { VEX_W_TABLE (VEX_W_0F72_R_6_P_2
) },
4985 /* PREFIX_VEX_0F73_REG_2 */
4989 { VEX_W_TABLE (VEX_W_0F73_R_2_P_2
) },
4992 /* PREFIX_VEX_0F73_REG_3 */
4996 { VEX_W_TABLE (VEX_W_0F73_R_3_P_2
) },
4999 /* PREFIX_VEX_0F73_REG_6 */
5003 { VEX_W_TABLE (VEX_W_0F73_R_6_P_2
) },
5006 /* PREFIX_VEX_0F73_REG_7 */
5010 { VEX_W_TABLE (VEX_W_0F73_R_7_P_2
) },
5013 /* PREFIX_VEX_0F74 */
5017 { VEX_W_TABLE (VEX_W_0F74_P_2
) },
5020 /* PREFIX_VEX_0F75 */
5024 { VEX_W_TABLE (VEX_W_0F75_P_2
) },
5027 /* PREFIX_VEX_0F76 */
5031 { VEX_W_TABLE (VEX_W_0F76_P_2
) },
5034 /* PREFIX_VEX_0F77 */
5036 { VEX_W_TABLE (VEX_W_0F77_P_0
) },
5039 /* PREFIX_VEX_0F7C */
5043 { VEX_W_TABLE (VEX_W_0F7C_P_2
) },
5044 { VEX_W_TABLE (VEX_W_0F7C_P_3
) },
5047 /* PREFIX_VEX_0F7D */
5051 { VEX_W_TABLE (VEX_W_0F7D_P_2
) },
5052 { VEX_W_TABLE (VEX_W_0F7D_P_3
) },
5055 /* PREFIX_VEX_0F7E */
5058 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_1
) },
5059 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_2
) },
5062 /* PREFIX_VEX_0F7F */
5065 { VEX_W_TABLE (VEX_W_0F7F_P_1
) },
5066 { VEX_W_TABLE (VEX_W_0F7F_P_2
) },
5069 /* PREFIX_VEX_0F90 */
5071 { VEX_LEN_TABLE (VEX_LEN_0F90_P_0
) },
5073 { VEX_LEN_TABLE (VEX_LEN_0F90_P_2
) },
5076 /* PREFIX_VEX_0F91 */
5078 { VEX_LEN_TABLE (VEX_LEN_0F91_P_0
) },
5080 { VEX_LEN_TABLE (VEX_LEN_0F91_P_2
) },
5083 /* PREFIX_VEX_0F92 */
5085 { VEX_LEN_TABLE (VEX_LEN_0F92_P_0
) },
5087 { VEX_LEN_TABLE (VEX_LEN_0F92_P_2
) },
5088 { VEX_LEN_TABLE (VEX_LEN_0F92_P_3
) },
5091 /* PREFIX_VEX_0F93 */
5093 { VEX_LEN_TABLE (VEX_LEN_0F93_P_0
) },
5095 { VEX_LEN_TABLE (VEX_LEN_0F93_P_2
) },
5096 { VEX_LEN_TABLE (VEX_LEN_0F93_P_3
) },
5099 /* PREFIX_VEX_0F98 */
5101 { VEX_LEN_TABLE (VEX_LEN_0F98_P_0
) },
5103 { VEX_LEN_TABLE (VEX_LEN_0F98_P_2
) },
5106 /* PREFIX_VEX_0F99 */
5108 { VEX_LEN_TABLE (VEX_LEN_0F99_P_0
) },
5110 { VEX_LEN_TABLE (VEX_LEN_0F99_P_2
) },
5113 /* PREFIX_VEX_0FC2 */
5115 { VEX_W_TABLE (VEX_W_0FC2_P_0
) },
5116 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_1
) },
5117 { VEX_W_TABLE (VEX_W_0FC2_P_2
) },
5118 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_3
) },
5121 /* PREFIX_VEX_0FC4 */
5125 { VEX_LEN_TABLE (VEX_LEN_0FC4_P_2
) },
5128 /* PREFIX_VEX_0FC5 */
5132 { VEX_LEN_TABLE (VEX_LEN_0FC5_P_2
) },
5135 /* PREFIX_VEX_0FD0 */
5139 { VEX_W_TABLE (VEX_W_0FD0_P_2
) },
5140 { VEX_W_TABLE (VEX_W_0FD0_P_3
) },
5143 /* PREFIX_VEX_0FD1 */
5147 { VEX_W_TABLE (VEX_W_0FD1_P_2
) },
5150 /* PREFIX_VEX_0FD2 */
5154 { VEX_W_TABLE (VEX_W_0FD2_P_2
) },
5157 /* PREFIX_VEX_0FD3 */
5161 { VEX_W_TABLE (VEX_W_0FD3_P_2
) },
5164 /* PREFIX_VEX_0FD4 */
5168 { VEX_W_TABLE (VEX_W_0FD4_P_2
) },
5171 /* PREFIX_VEX_0FD5 */
5175 { VEX_W_TABLE (VEX_W_0FD5_P_2
) },
5178 /* PREFIX_VEX_0FD6 */
5182 { VEX_LEN_TABLE (VEX_LEN_0FD6_P_2
) },
5185 /* PREFIX_VEX_0FD7 */
5189 { MOD_TABLE (MOD_VEX_0FD7_PREFIX_2
) },
5192 /* PREFIX_VEX_0FD8 */
5196 { VEX_W_TABLE (VEX_W_0FD8_P_2
) },
5199 /* PREFIX_VEX_0FD9 */
5203 { VEX_W_TABLE (VEX_W_0FD9_P_2
) },
5206 /* PREFIX_VEX_0FDA */
5210 { VEX_W_TABLE (VEX_W_0FDA_P_2
) },
5213 /* PREFIX_VEX_0FDB */
5217 { VEX_W_TABLE (VEX_W_0FDB_P_2
) },
5220 /* PREFIX_VEX_0FDC */
5224 { VEX_W_TABLE (VEX_W_0FDC_P_2
) },
5227 /* PREFIX_VEX_0FDD */
5231 { VEX_W_TABLE (VEX_W_0FDD_P_2
) },
5234 /* PREFIX_VEX_0FDE */
5238 { VEX_W_TABLE (VEX_W_0FDE_P_2
) },
5241 /* PREFIX_VEX_0FDF */
5245 { VEX_W_TABLE (VEX_W_0FDF_P_2
) },
5248 /* PREFIX_VEX_0FE0 */
5252 { VEX_W_TABLE (VEX_W_0FE0_P_2
) },
5255 /* PREFIX_VEX_0FE1 */
5259 { VEX_W_TABLE (VEX_W_0FE1_P_2
) },
5262 /* PREFIX_VEX_0FE2 */
5266 { VEX_W_TABLE (VEX_W_0FE2_P_2
) },
5269 /* PREFIX_VEX_0FE3 */
5273 { VEX_W_TABLE (VEX_W_0FE3_P_2
) },
5276 /* PREFIX_VEX_0FE4 */
5280 { VEX_W_TABLE (VEX_W_0FE4_P_2
) },
5283 /* PREFIX_VEX_0FE5 */
5287 { VEX_W_TABLE (VEX_W_0FE5_P_2
) },
5290 /* PREFIX_VEX_0FE6 */
5293 { VEX_W_TABLE (VEX_W_0FE6_P_1
) },
5294 { VEX_W_TABLE (VEX_W_0FE6_P_2
) },
5295 { VEX_W_TABLE (VEX_W_0FE6_P_3
) },
5298 /* PREFIX_VEX_0FE7 */
5302 { MOD_TABLE (MOD_VEX_0FE7_PREFIX_2
) },
5305 /* PREFIX_VEX_0FE8 */
5309 { VEX_W_TABLE (VEX_W_0FE8_P_2
) },
5312 /* PREFIX_VEX_0FE9 */
5316 { VEX_W_TABLE (VEX_W_0FE9_P_2
) },
5319 /* PREFIX_VEX_0FEA */
5323 { VEX_W_TABLE (VEX_W_0FEA_P_2
) },
5326 /* PREFIX_VEX_0FEB */
5330 { VEX_W_TABLE (VEX_W_0FEB_P_2
) },
5333 /* PREFIX_VEX_0FEC */
5337 { VEX_W_TABLE (VEX_W_0FEC_P_2
) },
5340 /* PREFIX_VEX_0FED */
5344 { VEX_W_TABLE (VEX_W_0FED_P_2
) },
5347 /* PREFIX_VEX_0FEE */
5351 { VEX_W_TABLE (VEX_W_0FEE_P_2
) },
5354 /* PREFIX_VEX_0FEF */
5358 { VEX_W_TABLE (VEX_W_0FEF_P_2
) },
5361 /* PREFIX_VEX_0FF0 */
5366 { MOD_TABLE (MOD_VEX_0FF0_PREFIX_3
) },
5369 /* PREFIX_VEX_0FF1 */
5373 { VEX_W_TABLE (VEX_W_0FF1_P_2
) },
5376 /* PREFIX_VEX_0FF2 */
5380 { VEX_W_TABLE (VEX_W_0FF2_P_2
) },
5383 /* PREFIX_VEX_0FF3 */
5387 { VEX_W_TABLE (VEX_W_0FF3_P_2
) },
5390 /* PREFIX_VEX_0FF4 */
5394 { VEX_W_TABLE (VEX_W_0FF4_P_2
) },
5397 /* PREFIX_VEX_0FF5 */
5401 { VEX_W_TABLE (VEX_W_0FF5_P_2
) },
5404 /* PREFIX_VEX_0FF6 */
5408 { VEX_W_TABLE (VEX_W_0FF6_P_2
) },
5411 /* PREFIX_VEX_0FF7 */
5415 { VEX_LEN_TABLE (VEX_LEN_0FF7_P_2
) },
5418 /* PREFIX_VEX_0FF8 */
5422 { VEX_W_TABLE (VEX_W_0FF8_P_2
) },
5425 /* PREFIX_VEX_0FF9 */
5429 { VEX_W_TABLE (VEX_W_0FF9_P_2
) },
5432 /* PREFIX_VEX_0FFA */
5436 { VEX_W_TABLE (VEX_W_0FFA_P_2
) },
5439 /* PREFIX_VEX_0FFB */
5443 { VEX_W_TABLE (VEX_W_0FFB_P_2
) },
5446 /* PREFIX_VEX_0FFC */
5450 { VEX_W_TABLE (VEX_W_0FFC_P_2
) },
5453 /* PREFIX_VEX_0FFD */
5457 { VEX_W_TABLE (VEX_W_0FFD_P_2
) },
5460 /* PREFIX_VEX_0FFE */
5464 { VEX_W_TABLE (VEX_W_0FFE_P_2
) },
5467 /* PREFIX_VEX_0F3800 */
5471 { VEX_W_TABLE (VEX_W_0F3800_P_2
) },
5474 /* PREFIX_VEX_0F3801 */
5478 { VEX_W_TABLE (VEX_W_0F3801_P_2
) },
5481 /* PREFIX_VEX_0F3802 */
5485 { VEX_W_TABLE (VEX_W_0F3802_P_2
) },
5488 /* PREFIX_VEX_0F3803 */
5492 { VEX_W_TABLE (VEX_W_0F3803_P_2
) },
5495 /* PREFIX_VEX_0F3804 */
5499 { VEX_W_TABLE (VEX_W_0F3804_P_2
) },
5502 /* PREFIX_VEX_0F3805 */
5506 { VEX_W_TABLE (VEX_W_0F3805_P_2
) },
5509 /* PREFIX_VEX_0F3806 */
5513 { VEX_W_TABLE (VEX_W_0F3806_P_2
) },
5516 /* PREFIX_VEX_0F3807 */
5520 { VEX_W_TABLE (VEX_W_0F3807_P_2
) },
5523 /* PREFIX_VEX_0F3808 */
5527 { VEX_W_TABLE (VEX_W_0F3808_P_2
) },
5530 /* PREFIX_VEX_0F3809 */
5534 { VEX_W_TABLE (VEX_W_0F3809_P_2
) },
5537 /* PREFIX_VEX_0F380A */
5541 { VEX_W_TABLE (VEX_W_0F380A_P_2
) },
5544 /* PREFIX_VEX_0F380B */
5548 { VEX_W_TABLE (VEX_W_0F380B_P_2
) },
5551 /* PREFIX_VEX_0F380C */
5555 { VEX_W_TABLE (VEX_W_0F380C_P_2
) },
5558 /* PREFIX_VEX_0F380D */
5562 { VEX_W_TABLE (VEX_W_0F380D_P_2
) },
5565 /* PREFIX_VEX_0F380E */
5569 { VEX_W_TABLE (VEX_W_0F380E_P_2
) },
5572 /* PREFIX_VEX_0F380F */
5576 { VEX_W_TABLE (VEX_W_0F380F_P_2
) },
5579 /* PREFIX_VEX_0F3813 */
5583 { "vcvtph2ps", { XM
, EXxmmq
}, 0 },
5586 /* PREFIX_VEX_0F3816 */
5590 { VEX_LEN_TABLE (VEX_LEN_0F3816_P_2
) },
5593 /* PREFIX_VEX_0F3817 */
5597 { VEX_W_TABLE (VEX_W_0F3817_P_2
) },
5600 /* PREFIX_VEX_0F3818 */
5604 { VEX_W_TABLE (VEX_W_0F3818_P_2
) },
5607 /* PREFIX_VEX_0F3819 */
5611 { VEX_LEN_TABLE (VEX_LEN_0F3819_P_2
) },
5614 /* PREFIX_VEX_0F381A */
5618 { MOD_TABLE (MOD_VEX_0F381A_PREFIX_2
) },
5621 /* PREFIX_VEX_0F381C */
5625 { VEX_W_TABLE (VEX_W_0F381C_P_2
) },
5628 /* PREFIX_VEX_0F381D */
5632 { VEX_W_TABLE (VEX_W_0F381D_P_2
) },
5635 /* PREFIX_VEX_0F381E */
5639 { VEX_W_TABLE (VEX_W_0F381E_P_2
) },
5642 /* PREFIX_VEX_0F3820 */
5646 { VEX_W_TABLE (VEX_W_0F3820_P_2
) },
5649 /* PREFIX_VEX_0F3821 */
5653 { VEX_W_TABLE (VEX_W_0F3821_P_2
) },
5656 /* PREFIX_VEX_0F3822 */
5660 { VEX_W_TABLE (VEX_W_0F3822_P_2
) },
5663 /* PREFIX_VEX_0F3823 */
5667 { VEX_W_TABLE (VEX_W_0F3823_P_2
) },
5670 /* PREFIX_VEX_0F3824 */
5674 { VEX_W_TABLE (VEX_W_0F3824_P_2
) },
5677 /* PREFIX_VEX_0F3825 */
5681 { VEX_W_TABLE (VEX_W_0F3825_P_2
) },
5684 /* PREFIX_VEX_0F3828 */
5688 { VEX_W_TABLE (VEX_W_0F3828_P_2
) },
5691 /* PREFIX_VEX_0F3829 */
5695 { VEX_W_TABLE (VEX_W_0F3829_P_2
) },
5698 /* PREFIX_VEX_0F382A */
5702 { MOD_TABLE (MOD_VEX_0F382A_PREFIX_2
) },
5705 /* PREFIX_VEX_0F382B */
5709 { VEX_W_TABLE (VEX_W_0F382B_P_2
) },
5712 /* PREFIX_VEX_0F382C */
5716 { MOD_TABLE (MOD_VEX_0F382C_PREFIX_2
) },
5719 /* PREFIX_VEX_0F382D */
5723 { MOD_TABLE (MOD_VEX_0F382D_PREFIX_2
) },
5726 /* PREFIX_VEX_0F382E */
5730 { MOD_TABLE (MOD_VEX_0F382E_PREFIX_2
) },
5733 /* PREFIX_VEX_0F382F */
5737 { MOD_TABLE (MOD_VEX_0F382F_PREFIX_2
) },
5740 /* PREFIX_VEX_0F3830 */
5744 { VEX_W_TABLE (VEX_W_0F3830_P_2
) },
5747 /* PREFIX_VEX_0F3831 */
5751 { VEX_W_TABLE (VEX_W_0F3831_P_2
) },
5754 /* PREFIX_VEX_0F3832 */
5758 { VEX_W_TABLE (VEX_W_0F3832_P_2
) },
5761 /* PREFIX_VEX_0F3833 */
5765 { VEX_W_TABLE (VEX_W_0F3833_P_2
) },
5768 /* PREFIX_VEX_0F3834 */
5772 { VEX_W_TABLE (VEX_W_0F3834_P_2
) },
5775 /* PREFIX_VEX_0F3835 */
5779 { VEX_W_TABLE (VEX_W_0F3835_P_2
) },
5782 /* PREFIX_VEX_0F3836 */
5786 { VEX_LEN_TABLE (VEX_LEN_0F3836_P_2
) },
5789 /* PREFIX_VEX_0F3837 */
5793 { VEX_W_TABLE (VEX_W_0F3837_P_2
) },
5796 /* PREFIX_VEX_0F3838 */
5800 { VEX_W_TABLE (VEX_W_0F3838_P_2
) },
5803 /* PREFIX_VEX_0F3839 */
5807 { VEX_W_TABLE (VEX_W_0F3839_P_2
) },
5810 /* PREFIX_VEX_0F383A */
5814 { VEX_W_TABLE (VEX_W_0F383A_P_2
) },
5817 /* PREFIX_VEX_0F383B */
5821 { VEX_W_TABLE (VEX_W_0F383B_P_2
) },
5824 /* PREFIX_VEX_0F383C */
5828 { VEX_W_TABLE (VEX_W_0F383C_P_2
) },
5831 /* PREFIX_VEX_0F383D */
5835 { VEX_W_TABLE (VEX_W_0F383D_P_2
) },
5838 /* PREFIX_VEX_0F383E */
5842 { VEX_W_TABLE (VEX_W_0F383E_P_2
) },
5845 /* PREFIX_VEX_0F383F */
5849 { VEX_W_TABLE (VEX_W_0F383F_P_2
) },
5852 /* PREFIX_VEX_0F3840 */
5856 { VEX_W_TABLE (VEX_W_0F3840_P_2
) },
5859 /* PREFIX_VEX_0F3841 */
5863 { VEX_LEN_TABLE (VEX_LEN_0F3841_P_2
) },
5866 /* PREFIX_VEX_0F3845 */
5870 { "vpsrlv%LW", { XM
, Vex
, EXx
}, 0 },
5873 /* PREFIX_VEX_0F3846 */
5877 { VEX_W_TABLE (VEX_W_0F3846_P_2
) },
5880 /* PREFIX_VEX_0F3847 */
5884 { "vpsllv%LW", { XM
, Vex
, EXx
}, 0 },
5887 /* PREFIX_VEX_0F3858 */
5891 { VEX_W_TABLE (VEX_W_0F3858_P_2
) },
5894 /* PREFIX_VEX_0F3859 */
5898 { VEX_W_TABLE (VEX_W_0F3859_P_2
) },
5901 /* PREFIX_VEX_0F385A */
5905 { MOD_TABLE (MOD_VEX_0F385A_PREFIX_2
) },
5908 /* PREFIX_VEX_0F3878 */
5912 { VEX_W_TABLE (VEX_W_0F3878_P_2
) },
5915 /* PREFIX_VEX_0F3879 */
5919 { VEX_W_TABLE (VEX_W_0F3879_P_2
) },
5922 /* PREFIX_VEX_0F388C */
5926 { MOD_TABLE (MOD_VEX_0F388C_PREFIX_2
) },
5929 /* PREFIX_VEX_0F388E */
5933 { MOD_TABLE (MOD_VEX_0F388E_PREFIX_2
) },
5936 /* PREFIX_VEX_0F3890 */
5940 { "vpgatherd%LW", { XM
, MVexVSIBDWpX
, Vex
}, 0 },
5943 /* PREFIX_VEX_0F3891 */
5947 { "vpgatherq%LW", { XMGatherQ
, MVexVSIBQWpX
, VexGatherQ
}, 0 },
5950 /* PREFIX_VEX_0F3892 */
5954 { "vgatherdp%XW", { XM
, MVexVSIBDWpX
, Vex
}, 0 },
5957 /* PREFIX_VEX_0F3893 */
5961 { "vgatherqp%XW", { XMGatherQ
, MVexVSIBQWpX
, VexGatherQ
}, 0 },
5964 /* PREFIX_VEX_0F3896 */
5968 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
}, 0 },
5971 /* PREFIX_VEX_0F3897 */
5975 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
}, 0 },
5978 /* PREFIX_VEX_0F3898 */
5982 { "vfmadd132p%XW", { XM
, Vex
, EXx
}, 0 },
5985 /* PREFIX_VEX_0F3899 */
5989 { "vfmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
5992 /* PREFIX_VEX_0F389A */
5996 { "vfmsub132p%XW", { XM
, Vex
, EXx
}, 0 },
5999 /* PREFIX_VEX_0F389B */
6003 { "vfmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6006 /* PREFIX_VEX_0F389C */
6010 { "vfnmadd132p%XW", { XM
, Vex
, EXx
}, 0 },
6013 /* PREFIX_VEX_0F389D */
6017 { "vfnmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6020 /* PREFIX_VEX_0F389E */
6024 { "vfnmsub132p%XW", { XM
, Vex
, EXx
}, 0 },
6027 /* PREFIX_VEX_0F389F */
6031 { "vfnmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6034 /* PREFIX_VEX_0F38A6 */
6038 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6042 /* PREFIX_VEX_0F38A7 */
6046 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6049 /* PREFIX_VEX_0F38A8 */
6053 { "vfmadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6056 /* PREFIX_VEX_0F38A9 */
6060 { "vfmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6063 /* PREFIX_VEX_0F38AA */
6067 { "vfmsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6070 /* PREFIX_VEX_0F38AB */
6074 { "vfmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6077 /* PREFIX_VEX_0F38AC */
6081 { "vfnmadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6084 /* PREFIX_VEX_0F38AD */
6088 { "vfnmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6091 /* PREFIX_VEX_0F38AE */
6095 { "vfnmsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6098 /* PREFIX_VEX_0F38AF */
6102 { "vfnmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6105 /* PREFIX_VEX_0F38B6 */
6109 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6112 /* PREFIX_VEX_0F38B7 */
6116 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6119 /* PREFIX_VEX_0F38B8 */
6123 { "vfmadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6126 /* PREFIX_VEX_0F38B9 */
6130 { "vfmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6133 /* PREFIX_VEX_0F38BA */
6137 { "vfmsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6140 /* PREFIX_VEX_0F38BB */
6144 { "vfmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6147 /* PREFIX_VEX_0F38BC */
6151 { "vfnmadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6154 /* PREFIX_VEX_0F38BD */
6158 { "vfnmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6161 /* PREFIX_VEX_0F38BE */
6165 { "vfnmsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6168 /* PREFIX_VEX_0F38BF */
6172 { "vfnmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6175 /* PREFIX_VEX_0F38DB */
6179 { VEX_LEN_TABLE (VEX_LEN_0F38DB_P_2
) },
6182 /* PREFIX_VEX_0F38DC */
6186 { VEX_LEN_TABLE (VEX_LEN_0F38DC_P_2
) },
6189 /* PREFIX_VEX_0F38DD */
6193 { VEX_LEN_TABLE (VEX_LEN_0F38DD_P_2
) },
6196 /* PREFIX_VEX_0F38DE */
6200 { VEX_LEN_TABLE (VEX_LEN_0F38DE_P_2
) },
6203 /* PREFIX_VEX_0F38DF */
6207 { VEX_LEN_TABLE (VEX_LEN_0F38DF_P_2
) },
6210 /* PREFIX_VEX_0F38F2 */
6212 { VEX_LEN_TABLE (VEX_LEN_0F38F2_P_0
) },
6215 /* PREFIX_VEX_0F38F3_REG_1 */
6217 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_1_P_0
) },
6220 /* PREFIX_VEX_0F38F3_REG_2 */
6222 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_2_P_0
) },
6225 /* PREFIX_VEX_0F38F3_REG_3 */
6227 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_3_P_0
) },
6230 /* PREFIX_VEX_0F38F5 */
6232 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_0
) },
6233 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_1
) },
6235 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_3
) },
6238 /* PREFIX_VEX_0F38F6 */
6243 { VEX_LEN_TABLE (VEX_LEN_0F38F6_P_3
) },
6246 /* PREFIX_VEX_0F38F7 */
6248 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_0
) },
6249 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_1
) },
6250 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_2
) },
6251 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_3
) },
6254 /* PREFIX_VEX_0F3A00 */
6258 { VEX_LEN_TABLE (VEX_LEN_0F3A00_P_2
) },
6261 /* PREFIX_VEX_0F3A01 */
6265 { VEX_LEN_TABLE (VEX_LEN_0F3A01_P_2
) },
6268 /* PREFIX_VEX_0F3A02 */
6272 { VEX_W_TABLE (VEX_W_0F3A02_P_2
) },
6275 /* PREFIX_VEX_0F3A04 */
6279 { VEX_W_TABLE (VEX_W_0F3A04_P_2
) },
6282 /* PREFIX_VEX_0F3A05 */
6286 { VEX_W_TABLE (VEX_W_0F3A05_P_2
) },
6289 /* PREFIX_VEX_0F3A06 */
6293 { VEX_LEN_TABLE (VEX_LEN_0F3A06_P_2
) },
6296 /* PREFIX_VEX_0F3A08 */
6300 { VEX_W_TABLE (VEX_W_0F3A08_P_2
) },
6303 /* PREFIX_VEX_0F3A09 */
6307 { VEX_W_TABLE (VEX_W_0F3A09_P_2
) },
6310 /* PREFIX_VEX_0F3A0A */
6314 { VEX_LEN_TABLE (VEX_LEN_0F3A0A_P_2
) },
6317 /* PREFIX_VEX_0F3A0B */
6321 { VEX_LEN_TABLE (VEX_LEN_0F3A0B_P_2
) },
6324 /* PREFIX_VEX_0F3A0C */
6328 { VEX_W_TABLE (VEX_W_0F3A0C_P_2
) },
6331 /* PREFIX_VEX_0F3A0D */
6335 { VEX_W_TABLE (VEX_W_0F3A0D_P_2
) },
6338 /* PREFIX_VEX_0F3A0E */
6342 { VEX_W_TABLE (VEX_W_0F3A0E_P_2
) },
6345 /* PREFIX_VEX_0F3A0F */
6349 { VEX_W_TABLE (VEX_W_0F3A0F_P_2
) },
6352 /* PREFIX_VEX_0F3A14 */
6356 { VEX_LEN_TABLE (VEX_LEN_0F3A14_P_2
) },
6359 /* PREFIX_VEX_0F3A15 */
6363 { VEX_LEN_TABLE (VEX_LEN_0F3A15_P_2
) },
6366 /* PREFIX_VEX_0F3A16 */
6370 { VEX_LEN_TABLE (VEX_LEN_0F3A16_P_2
) },
6373 /* PREFIX_VEX_0F3A17 */
6377 { VEX_LEN_TABLE (VEX_LEN_0F3A17_P_2
) },
6380 /* PREFIX_VEX_0F3A18 */
6384 { VEX_LEN_TABLE (VEX_LEN_0F3A18_P_2
) },
6387 /* PREFIX_VEX_0F3A19 */
6391 { VEX_LEN_TABLE (VEX_LEN_0F3A19_P_2
) },
6394 /* PREFIX_VEX_0F3A1D */
6398 { "vcvtps2ph", { EXxmmq
, XM
, Ib
}, 0 },
6401 /* PREFIX_VEX_0F3A20 */
6405 { VEX_LEN_TABLE (VEX_LEN_0F3A20_P_2
) },
6408 /* PREFIX_VEX_0F3A21 */
6412 { VEX_LEN_TABLE (VEX_LEN_0F3A21_P_2
) },
6415 /* PREFIX_VEX_0F3A22 */
6419 { VEX_LEN_TABLE (VEX_LEN_0F3A22_P_2
) },
6422 /* PREFIX_VEX_0F3A30 */
6426 { VEX_LEN_TABLE (VEX_LEN_0F3A30_P_2
) },
6429 /* PREFIX_VEX_0F3A31 */
6433 { VEX_LEN_TABLE (VEX_LEN_0F3A31_P_2
) },
6436 /* PREFIX_VEX_0F3A32 */
6440 { VEX_LEN_TABLE (VEX_LEN_0F3A32_P_2
) },
6443 /* PREFIX_VEX_0F3A33 */
6447 { VEX_LEN_TABLE (VEX_LEN_0F3A33_P_2
) },
6450 /* PREFIX_VEX_0F3A38 */
6454 { VEX_LEN_TABLE (VEX_LEN_0F3A38_P_2
) },
6457 /* PREFIX_VEX_0F3A39 */
6461 { VEX_LEN_TABLE (VEX_LEN_0F3A39_P_2
) },
6464 /* PREFIX_VEX_0F3A40 */
6468 { VEX_W_TABLE (VEX_W_0F3A40_P_2
) },
6471 /* PREFIX_VEX_0F3A41 */
6475 { VEX_LEN_TABLE (VEX_LEN_0F3A41_P_2
) },
6478 /* PREFIX_VEX_0F3A42 */
6482 { VEX_W_TABLE (VEX_W_0F3A42_P_2
) },
6485 /* PREFIX_VEX_0F3A44 */
6489 { VEX_LEN_TABLE (VEX_LEN_0F3A44_P_2
) },
6492 /* PREFIX_VEX_0F3A46 */
6496 { VEX_LEN_TABLE (VEX_LEN_0F3A46_P_2
) },
6499 /* PREFIX_VEX_0F3A48 */
6503 { VEX_W_TABLE (VEX_W_0F3A48_P_2
) },
6506 /* PREFIX_VEX_0F3A49 */
6510 { VEX_W_TABLE (VEX_W_0F3A49_P_2
) },
6513 /* PREFIX_VEX_0F3A4A */
6517 { VEX_W_TABLE (VEX_W_0F3A4A_P_2
) },
6520 /* PREFIX_VEX_0F3A4B */
6524 { VEX_W_TABLE (VEX_W_0F3A4B_P_2
) },
6527 /* PREFIX_VEX_0F3A4C */
6531 { VEX_W_TABLE (VEX_W_0F3A4C_P_2
) },
6534 /* PREFIX_VEX_0F3A5C */
6538 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6541 /* PREFIX_VEX_0F3A5D */
6545 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6548 /* PREFIX_VEX_0F3A5E */
6552 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6555 /* PREFIX_VEX_0F3A5F */
6559 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6562 /* PREFIX_VEX_0F3A60 */
6566 { VEX_LEN_TABLE (VEX_LEN_0F3A60_P_2
) },
6570 /* PREFIX_VEX_0F3A61 */
6574 { VEX_LEN_TABLE (VEX_LEN_0F3A61_P_2
) },
6577 /* PREFIX_VEX_0F3A62 */
6581 { VEX_LEN_TABLE (VEX_LEN_0F3A62_P_2
) },
6584 /* PREFIX_VEX_0F3A63 */
6588 { VEX_LEN_TABLE (VEX_LEN_0F3A63_P_2
) },
6591 /* PREFIX_VEX_0F3A68 */
6595 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6598 /* PREFIX_VEX_0F3A69 */
6602 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6605 /* PREFIX_VEX_0F3A6A */
6609 { VEX_LEN_TABLE (VEX_LEN_0F3A6A_P_2
) },
6612 /* PREFIX_VEX_0F3A6B */
6616 { VEX_LEN_TABLE (VEX_LEN_0F3A6B_P_2
) },
6619 /* PREFIX_VEX_0F3A6C */
6623 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6626 /* PREFIX_VEX_0F3A6D */
6630 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6633 /* PREFIX_VEX_0F3A6E */
6637 { VEX_LEN_TABLE (VEX_LEN_0F3A6E_P_2
) },
6640 /* PREFIX_VEX_0F3A6F */
6644 { VEX_LEN_TABLE (VEX_LEN_0F3A6F_P_2
) },
6647 /* PREFIX_VEX_0F3A78 */
6651 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6654 /* PREFIX_VEX_0F3A79 */
6658 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6661 /* PREFIX_VEX_0F3A7A */
6665 { VEX_LEN_TABLE (VEX_LEN_0F3A7A_P_2
) },
6668 /* PREFIX_VEX_0F3A7B */
6672 { VEX_LEN_TABLE (VEX_LEN_0F3A7B_P_2
) },
6675 /* PREFIX_VEX_0F3A7C */
6679 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6683 /* PREFIX_VEX_0F3A7D */
6687 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6690 /* PREFIX_VEX_0F3A7E */
6694 { VEX_LEN_TABLE (VEX_LEN_0F3A7E_P_2
) },
6697 /* PREFIX_VEX_0F3A7F */
6701 { VEX_LEN_TABLE (VEX_LEN_0F3A7F_P_2
) },
6704 /* PREFIX_VEX_0F3ADF */
6708 { VEX_LEN_TABLE (VEX_LEN_0F3ADF_P_2
) },
6711 /* PREFIX_VEX_0F3AF0 */
6716 { VEX_LEN_TABLE (VEX_LEN_0F3AF0_P_3
) },
6719 #define NEED_PREFIX_TABLE
6720 #include "i386-dis-evex.h"
6721 #undef NEED_PREFIX_TABLE
6724 static const struct dis386 x86_64_table
[][2] = {
6727 { "pushP", { es
}, 0 },
6732 { "popP", { es
}, 0 },
6737 { "pushP", { cs
}, 0 },
6742 { "pushP", { ss
}, 0 },
6747 { "popP", { ss
}, 0 },
6752 { "pushP", { ds
}, 0 },
6757 { "popP", { ds
}, 0 },
6762 { "daa", { XX
}, 0 },
6767 { "das", { XX
}, 0 },
6772 { "aaa", { XX
}, 0 },
6777 { "aas", { XX
}, 0 },
6782 { "pushaP", { XX
}, 0 },
6787 { "popaP", { XX
}, 0 },
6792 { MOD_TABLE (MOD_62_32BIT
) },
6793 { EVEX_TABLE (EVEX_0F
) },
6798 { "arpl", { Ew
, Gw
}, 0 },
6799 { "movs{lq|xd}", { Gv
, Ed
}, 0 },
6804 { "ins{R|}", { Yzr
, indirDX
}, 0 },
6805 { "ins{G|}", { Yzr
, indirDX
}, 0 },
6810 { "outs{R|}", { indirDXr
, Xz
}, 0 },
6811 { "outs{G|}", { indirDXr
, Xz
}, 0 },
6816 { "Jcall{T|}", { Ap
}, 0 },
6821 { MOD_TABLE (MOD_C4_32BIT
) },
6822 { VEX_C4_TABLE (VEX_0F
) },
6827 { MOD_TABLE (MOD_C5_32BIT
) },
6828 { VEX_C5_TABLE (VEX_0F
) },
6833 { "into", { XX
}, 0 },
6838 { "aam", { Ib
}, 0 },
6843 { "aad", { Ib
}, 0 },
6848 { "callP", { Jv
, BND
}, 0 },
6849 { "call@", { Jv
, BND
}, 0 }
6854 { "jmpP", { Jv
, BND
}, 0 },
6855 { "jmp@", { Jv
, BND
}, 0 }
6860 { "Jjmp{T|}", { Ap
}, 0 },
6863 /* X86_64_0F01_REG_0 */
6865 { "sgdt{Q|IQ}", { M
}, 0 },
6866 { "sgdt", { M
}, 0 },
6869 /* X86_64_0F01_REG_1 */
6871 { "sidt{Q|IQ}", { M
}, 0 },
6872 { "sidt", { M
}, 0 },
6875 /* X86_64_0F01_REG_2 */
6877 { "lgdt{Q|Q}", { M
}, 0 },
6878 { "lgdt", { M
}, 0 },
6881 /* X86_64_0F01_REG_3 */
6883 { "lidt{Q|Q}", { M
}, 0 },
6884 { "lidt", { M
}, 0 },
6888 static const struct dis386 three_byte_table
[][256] = {
6890 /* THREE_BYTE_0F38 */
6893 { "pshufb", { MX
, EM
}, PREFIX_OPCODE
},
6894 { "phaddw", { MX
, EM
}, PREFIX_OPCODE
},
6895 { "phaddd", { MX
, EM
}, PREFIX_OPCODE
},
6896 { "phaddsw", { MX
, EM
}, PREFIX_OPCODE
},
6897 { "pmaddubsw", { MX
, EM
}, PREFIX_OPCODE
},
6898 { "phsubw", { MX
, EM
}, PREFIX_OPCODE
},
6899 { "phsubd", { MX
, EM
}, PREFIX_OPCODE
},
6900 { "phsubsw", { MX
, EM
}, PREFIX_OPCODE
},
6902 { "psignb", { MX
, EM
}, PREFIX_OPCODE
},
6903 { "psignw", { MX
, EM
}, PREFIX_OPCODE
},
6904 { "psignd", { MX
, EM
}, PREFIX_OPCODE
},
6905 { "pmulhrsw", { MX
, EM
}, PREFIX_OPCODE
},
6911 { PREFIX_TABLE (PREFIX_0F3810
) },
6915 { PREFIX_TABLE (PREFIX_0F3814
) },
6916 { PREFIX_TABLE (PREFIX_0F3815
) },
6918 { PREFIX_TABLE (PREFIX_0F3817
) },
6924 { "pabsb", { MX
, EM
}, PREFIX_OPCODE
},
6925 { "pabsw", { MX
, EM
}, PREFIX_OPCODE
},
6926 { "pabsd", { MX
, EM
}, PREFIX_OPCODE
},
6929 { PREFIX_TABLE (PREFIX_0F3820
) },
6930 { PREFIX_TABLE (PREFIX_0F3821
) },
6931 { PREFIX_TABLE (PREFIX_0F3822
) },
6932 { PREFIX_TABLE (PREFIX_0F3823
) },
6933 { PREFIX_TABLE (PREFIX_0F3824
) },
6934 { PREFIX_TABLE (PREFIX_0F3825
) },
6938 { PREFIX_TABLE (PREFIX_0F3828
) },
6939 { PREFIX_TABLE (PREFIX_0F3829
) },
6940 { PREFIX_TABLE (PREFIX_0F382A
) },
6941 { PREFIX_TABLE (PREFIX_0F382B
) },
6947 { PREFIX_TABLE (PREFIX_0F3830
) },
6948 { PREFIX_TABLE (PREFIX_0F3831
) },
6949 { PREFIX_TABLE (PREFIX_0F3832
) },
6950 { PREFIX_TABLE (PREFIX_0F3833
) },
6951 { PREFIX_TABLE (PREFIX_0F3834
) },
6952 { PREFIX_TABLE (PREFIX_0F3835
) },
6954 { PREFIX_TABLE (PREFIX_0F3837
) },
6956 { PREFIX_TABLE (PREFIX_0F3838
) },
6957 { PREFIX_TABLE (PREFIX_0F3839
) },
6958 { PREFIX_TABLE (PREFIX_0F383A
) },
6959 { PREFIX_TABLE (PREFIX_0F383B
) },
6960 { PREFIX_TABLE (PREFIX_0F383C
) },
6961 { PREFIX_TABLE (PREFIX_0F383D
) },
6962 { PREFIX_TABLE (PREFIX_0F383E
) },
6963 { PREFIX_TABLE (PREFIX_0F383F
) },
6965 { PREFIX_TABLE (PREFIX_0F3840
) },
6966 { PREFIX_TABLE (PREFIX_0F3841
) },
7037 { PREFIX_TABLE (PREFIX_0F3880
) },
7038 { PREFIX_TABLE (PREFIX_0F3881
) },
7039 { PREFIX_TABLE (PREFIX_0F3882
) },
7118 { PREFIX_TABLE (PREFIX_0F38C8
) },
7119 { PREFIX_TABLE (PREFIX_0F38C9
) },
7120 { PREFIX_TABLE (PREFIX_0F38CA
) },
7121 { PREFIX_TABLE (PREFIX_0F38CB
) },
7122 { PREFIX_TABLE (PREFIX_0F38CC
) },
7123 { PREFIX_TABLE (PREFIX_0F38CD
) },
7139 { PREFIX_TABLE (PREFIX_0F38DB
) },
7140 { PREFIX_TABLE (PREFIX_0F38DC
) },
7141 { PREFIX_TABLE (PREFIX_0F38DD
) },
7142 { PREFIX_TABLE (PREFIX_0F38DE
) },
7143 { PREFIX_TABLE (PREFIX_0F38DF
) },
7163 { PREFIX_TABLE (PREFIX_0F38F0
) },
7164 { PREFIX_TABLE (PREFIX_0F38F1
) },
7169 { PREFIX_TABLE (PREFIX_0F38F6
) },
7181 /* THREE_BYTE_0F3A */
7193 { PREFIX_TABLE (PREFIX_0F3A08
) },
7194 { PREFIX_TABLE (PREFIX_0F3A09
) },
7195 { PREFIX_TABLE (PREFIX_0F3A0A
) },
7196 { PREFIX_TABLE (PREFIX_0F3A0B
) },
7197 { PREFIX_TABLE (PREFIX_0F3A0C
) },
7198 { PREFIX_TABLE (PREFIX_0F3A0D
) },
7199 { PREFIX_TABLE (PREFIX_0F3A0E
) },
7200 { "palignr", { MX
, EM
, Ib
}, PREFIX_OPCODE
},
7206 { PREFIX_TABLE (PREFIX_0F3A14
) },
7207 { PREFIX_TABLE (PREFIX_0F3A15
) },
7208 { PREFIX_TABLE (PREFIX_0F3A16
) },
7209 { PREFIX_TABLE (PREFIX_0F3A17
) },
7220 { PREFIX_TABLE (PREFIX_0F3A20
) },
7221 { PREFIX_TABLE (PREFIX_0F3A21
) },
7222 { PREFIX_TABLE (PREFIX_0F3A22
) },
7256 { PREFIX_TABLE (PREFIX_0F3A40
) },
7257 { PREFIX_TABLE (PREFIX_0F3A41
) },
7258 { PREFIX_TABLE (PREFIX_0F3A42
) },
7260 { PREFIX_TABLE (PREFIX_0F3A44
) },
7292 { PREFIX_TABLE (PREFIX_0F3A60
) },
7293 { PREFIX_TABLE (PREFIX_0F3A61
) },
7294 { PREFIX_TABLE (PREFIX_0F3A62
) },
7295 { PREFIX_TABLE (PREFIX_0F3A63
) },
7413 { PREFIX_TABLE (PREFIX_0F3ACC
) },
7434 { PREFIX_TABLE (PREFIX_0F3ADF
) },
7473 /* THREE_BYTE_0F7A */
7512 { "ptest", { XX
}, PREFIX_OPCODE
},
7549 { "phaddbw", { XM
, EXq
}, PREFIX_OPCODE
},
7550 { "phaddbd", { XM
, EXq
}, PREFIX_OPCODE
},
7551 { "phaddbq", { XM
, EXq
}, PREFIX_OPCODE
},
7554 { "phaddwd", { XM
, EXq
}, PREFIX_OPCODE
},
7555 { "phaddwq", { XM
, EXq
}, PREFIX_OPCODE
},
7560 { "phadddq", { XM
, EXq
}, PREFIX_OPCODE
},
7567 { "phaddubw", { XM
, EXq
}, PREFIX_OPCODE
},
7568 { "phaddubd", { XM
, EXq
}, PREFIX_OPCODE
},
7569 { "phaddubq", { XM
, EXq
}, PREFIX_OPCODE
},
7572 { "phadduwd", { XM
, EXq
}, PREFIX_OPCODE
},
7573 { "phadduwq", { XM
, EXq
}, PREFIX_OPCODE
},
7578 { "phaddudq", { XM
, EXq
}, PREFIX_OPCODE
},
7585 { "phsubbw", { XM
, EXq
}, PREFIX_OPCODE
},
7586 { "phsubbd", { XM
, EXq
}, PREFIX_OPCODE
},
7587 { "phsubbq", { XM
, EXq
}, PREFIX_OPCODE
},
7766 static const struct dis386 xop_table
[][256] = {
7919 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7920 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7921 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7929 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7930 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7937 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7938 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7939 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7947 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7948 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7952 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7953 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7956 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7974 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7986 { "vprotb", { XM
, Vex_2src_1
, Ib
}, 0 },
7987 { "vprotw", { XM
, Vex_2src_1
, Ib
}, 0 },
7988 { "vprotd", { XM
, Vex_2src_1
, Ib
}, 0 },
7989 { "vprotq", { XM
, Vex_2src_1
, Ib
}, 0 },
7999 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CC
) },
8000 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CD
) },
8001 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CE
) },
8002 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CF
) },
8035 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EC
) },
8036 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_ED
) },
8037 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EE
) },
8038 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EF
) },
8062 { REG_TABLE (REG_XOP_TBM_01
) },
8063 { REG_TABLE (REG_XOP_TBM_02
) },
8081 { REG_TABLE (REG_XOP_LWPCB
) },
8205 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_80
) },
8206 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_81
) },
8207 { "vfrczss", { XM
, EXd
}, 0 },
8208 { "vfrczsd", { XM
, EXq
}, 0 },
8223 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8224 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8225 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8226 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8227 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8228 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8229 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8230 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8232 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8233 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8234 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8235 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8278 { "vphaddbw", { XM
, EXxmm
}, 0 },
8279 { "vphaddbd", { XM
, EXxmm
}, 0 },
8280 { "vphaddbq", { XM
, EXxmm
}, 0 },
8283 { "vphaddwd", { XM
, EXxmm
}, 0 },
8284 { "vphaddwq", { XM
, EXxmm
}, 0 },
8289 { "vphadddq", { XM
, EXxmm
}, 0 },
8296 { "vphaddubw", { XM
, EXxmm
}, 0 },
8297 { "vphaddubd", { XM
, EXxmm
}, 0 },
8298 { "vphaddubq", { XM
, EXxmm
}, 0 },
8301 { "vphadduwd", { XM
, EXxmm
}, 0 },
8302 { "vphadduwq", { XM
, EXxmm
}, 0 },
8307 { "vphaddudq", { XM
, EXxmm
}, 0 },
8314 { "vphsubbw", { XM
, EXxmm
}, 0 },
8315 { "vphsubwd", { XM
, EXxmm
}, 0 },
8316 { "vphsubdq", { XM
, EXxmm
}, 0 },
8370 { "bextr", { Gv
, Ev
, Iq
}, 0 },
8372 { REG_TABLE (REG_XOP_LWP
) },
8642 static const struct dis386 vex_table
[][256] = {
8664 { PREFIX_TABLE (PREFIX_VEX_0F10
) },
8665 { PREFIX_TABLE (PREFIX_VEX_0F11
) },
8666 { PREFIX_TABLE (PREFIX_VEX_0F12
) },
8667 { MOD_TABLE (MOD_VEX_0F13
) },
8668 { VEX_W_TABLE (VEX_W_0F14
) },
8669 { VEX_W_TABLE (VEX_W_0F15
) },
8670 { PREFIX_TABLE (PREFIX_VEX_0F16
) },
8671 { MOD_TABLE (MOD_VEX_0F17
) },
8691 { VEX_W_TABLE (VEX_W_0F28
) },
8692 { VEX_W_TABLE (VEX_W_0F29
) },
8693 { PREFIX_TABLE (PREFIX_VEX_0F2A
) },
8694 { MOD_TABLE (MOD_VEX_0F2B
) },
8695 { PREFIX_TABLE (PREFIX_VEX_0F2C
) },
8696 { PREFIX_TABLE (PREFIX_VEX_0F2D
) },
8697 { PREFIX_TABLE (PREFIX_VEX_0F2E
) },
8698 { PREFIX_TABLE (PREFIX_VEX_0F2F
) },
8719 { PREFIX_TABLE (PREFIX_VEX_0F41
) },
8720 { PREFIX_TABLE (PREFIX_VEX_0F42
) },
8722 { PREFIX_TABLE (PREFIX_VEX_0F44
) },
8723 { PREFIX_TABLE (PREFIX_VEX_0F45
) },
8724 { PREFIX_TABLE (PREFIX_VEX_0F46
) },
8725 { PREFIX_TABLE (PREFIX_VEX_0F47
) },
8729 { PREFIX_TABLE (PREFIX_VEX_0F4A
) },
8730 { PREFIX_TABLE (PREFIX_VEX_0F4B
) },
8736 { MOD_TABLE (MOD_VEX_0F50
) },
8737 { PREFIX_TABLE (PREFIX_VEX_0F51
) },
8738 { PREFIX_TABLE (PREFIX_VEX_0F52
) },
8739 { PREFIX_TABLE (PREFIX_VEX_0F53
) },
8740 { "vandpX", { XM
, Vex
, EXx
}, 0 },
8741 { "vandnpX", { XM
, Vex
, EXx
}, 0 },
8742 { "vorpX", { XM
, Vex
, EXx
}, 0 },
8743 { "vxorpX", { XM
, Vex
, EXx
}, 0 },
8745 { PREFIX_TABLE (PREFIX_VEX_0F58
) },
8746 { PREFIX_TABLE (PREFIX_VEX_0F59
) },
8747 { PREFIX_TABLE (PREFIX_VEX_0F5A
) },
8748 { PREFIX_TABLE (PREFIX_VEX_0F5B
) },
8749 { PREFIX_TABLE (PREFIX_VEX_0F5C
) },
8750 { PREFIX_TABLE (PREFIX_VEX_0F5D
) },
8751 { PREFIX_TABLE (PREFIX_VEX_0F5E
) },
8752 { PREFIX_TABLE (PREFIX_VEX_0F5F
) },
8754 { PREFIX_TABLE (PREFIX_VEX_0F60
) },
8755 { PREFIX_TABLE (PREFIX_VEX_0F61
) },
8756 { PREFIX_TABLE (PREFIX_VEX_0F62
) },
8757 { PREFIX_TABLE (PREFIX_VEX_0F63
) },
8758 { PREFIX_TABLE (PREFIX_VEX_0F64
) },
8759 { PREFIX_TABLE (PREFIX_VEX_0F65
) },
8760 { PREFIX_TABLE (PREFIX_VEX_0F66
) },
8761 { PREFIX_TABLE (PREFIX_VEX_0F67
) },
8763 { PREFIX_TABLE (PREFIX_VEX_0F68
) },
8764 { PREFIX_TABLE (PREFIX_VEX_0F69
) },
8765 { PREFIX_TABLE (PREFIX_VEX_0F6A
) },
8766 { PREFIX_TABLE (PREFIX_VEX_0F6B
) },
8767 { PREFIX_TABLE (PREFIX_VEX_0F6C
) },
8768 { PREFIX_TABLE (PREFIX_VEX_0F6D
) },
8769 { PREFIX_TABLE (PREFIX_VEX_0F6E
) },
8770 { PREFIX_TABLE (PREFIX_VEX_0F6F
) },
8772 { PREFIX_TABLE (PREFIX_VEX_0F70
) },
8773 { REG_TABLE (REG_VEX_0F71
) },
8774 { REG_TABLE (REG_VEX_0F72
) },
8775 { REG_TABLE (REG_VEX_0F73
) },
8776 { PREFIX_TABLE (PREFIX_VEX_0F74
) },
8777 { PREFIX_TABLE (PREFIX_VEX_0F75
) },
8778 { PREFIX_TABLE (PREFIX_VEX_0F76
) },
8779 { PREFIX_TABLE (PREFIX_VEX_0F77
) },
8785 { PREFIX_TABLE (PREFIX_VEX_0F7C
) },
8786 { PREFIX_TABLE (PREFIX_VEX_0F7D
) },
8787 { PREFIX_TABLE (PREFIX_VEX_0F7E
) },
8788 { PREFIX_TABLE (PREFIX_VEX_0F7F
) },
8808 { PREFIX_TABLE (PREFIX_VEX_0F90
) },
8809 { PREFIX_TABLE (PREFIX_VEX_0F91
) },
8810 { PREFIX_TABLE (PREFIX_VEX_0F92
) },
8811 { PREFIX_TABLE (PREFIX_VEX_0F93
) },
8817 { PREFIX_TABLE (PREFIX_VEX_0F98
) },
8818 { PREFIX_TABLE (PREFIX_VEX_0F99
) },
8841 { REG_TABLE (REG_VEX_0FAE
) },
8864 { PREFIX_TABLE (PREFIX_VEX_0FC2
) },
8866 { PREFIX_TABLE (PREFIX_VEX_0FC4
) },
8867 { PREFIX_TABLE (PREFIX_VEX_0FC5
) },
8868 { "vshufpX", { XM
, Vex
, EXx
, Ib
}, 0 },
8880 { PREFIX_TABLE (PREFIX_VEX_0FD0
) },
8881 { PREFIX_TABLE (PREFIX_VEX_0FD1
) },
8882 { PREFIX_TABLE (PREFIX_VEX_0FD2
) },
8883 { PREFIX_TABLE (PREFIX_VEX_0FD3
) },
8884 { PREFIX_TABLE (PREFIX_VEX_0FD4
) },
8885 { PREFIX_TABLE (PREFIX_VEX_0FD5
) },
8886 { PREFIX_TABLE (PREFIX_VEX_0FD6
) },
8887 { PREFIX_TABLE (PREFIX_VEX_0FD7
) },
8889 { PREFIX_TABLE (PREFIX_VEX_0FD8
) },
8890 { PREFIX_TABLE (PREFIX_VEX_0FD9
) },
8891 { PREFIX_TABLE (PREFIX_VEX_0FDA
) },
8892 { PREFIX_TABLE (PREFIX_VEX_0FDB
) },
8893 { PREFIX_TABLE (PREFIX_VEX_0FDC
) },
8894 { PREFIX_TABLE (PREFIX_VEX_0FDD
) },
8895 { PREFIX_TABLE (PREFIX_VEX_0FDE
) },
8896 { PREFIX_TABLE (PREFIX_VEX_0FDF
) },
8898 { PREFIX_TABLE (PREFIX_VEX_0FE0
) },
8899 { PREFIX_TABLE (PREFIX_VEX_0FE1
) },
8900 { PREFIX_TABLE (PREFIX_VEX_0FE2
) },
8901 { PREFIX_TABLE (PREFIX_VEX_0FE3
) },
8902 { PREFIX_TABLE (PREFIX_VEX_0FE4
) },
8903 { PREFIX_TABLE (PREFIX_VEX_0FE5
) },
8904 { PREFIX_TABLE (PREFIX_VEX_0FE6
) },
8905 { PREFIX_TABLE (PREFIX_VEX_0FE7
) },
8907 { PREFIX_TABLE (PREFIX_VEX_0FE8
) },
8908 { PREFIX_TABLE (PREFIX_VEX_0FE9
) },
8909 { PREFIX_TABLE (PREFIX_VEX_0FEA
) },
8910 { PREFIX_TABLE (PREFIX_VEX_0FEB
) },
8911 { PREFIX_TABLE (PREFIX_VEX_0FEC
) },
8912 { PREFIX_TABLE (PREFIX_VEX_0FED
) },
8913 { PREFIX_TABLE (PREFIX_VEX_0FEE
) },
8914 { PREFIX_TABLE (PREFIX_VEX_0FEF
) },
8916 { PREFIX_TABLE (PREFIX_VEX_0FF0
) },
8917 { PREFIX_TABLE (PREFIX_VEX_0FF1
) },
8918 { PREFIX_TABLE (PREFIX_VEX_0FF2
) },
8919 { PREFIX_TABLE (PREFIX_VEX_0FF3
) },
8920 { PREFIX_TABLE (PREFIX_VEX_0FF4
) },
8921 { PREFIX_TABLE (PREFIX_VEX_0FF5
) },
8922 { PREFIX_TABLE (PREFIX_VEX_0FF6
) },
8923 { PREFIX_TABLE (PREFIX_VEX_0FF7
) },
8925 { PREFIX_TABLE (PREFIX_VEX_0FF8
) },
8926 { PREFIX_TABLE (PREFIX_VEX_0FF9
) },
8927 { PREFIX_TABLE (PREFIX_VEX_0FFA
) },
8928 { PREFIX_TABLE (PREFIX_VEX_0FFB
) },
8929 { PREFIX_TABLE (PREFIX_VEX_0FFC
) },
8930 { PREFIX_TABLE (PREFIX_VEX_0FFD
) },
8931 { PREFIX_TABLE (PREFIX_VEX_0FFE
) },
8937 { PREFIX_TABLE (PREFIX_VEX_0F3800
) },
8938 { PREFIX_TABLE (PREFIX_VEX_0F3801
) },
8939 { PREFIX_TABLE (PREFIX_VEX_0F3802
) },
8940 { PREFIX_TABLE (PREFIX_VEX_0F3803
) },
8941 { PREFIX_TABLE (PREFIX_VEX_0F3804
) },
8942 { PREFIX_TABLE (PREFIX_VEX_0F3805
) },
8943 { PREFIX_TABLE (PREFIX_VEX_0F3806
) },
8944 { PREFIX_TABLE (PREFIX_VEX_0F3807
) },
8946 { PREFIX_TABLE (PREFIX_VEX_0F3808
) },
8947 { PREFIX_TABLE (PREFIX_VEX_0F3809
) },
8948 { PREFIX_TABLE (PREFIX_VEX_0F380A
) },
8949 { PREFIX_TABLE (PREFIX_VEX_0F380B
) },
8950 { PREFIX_TABLE (PREFIX_VEX_0F380C
) },
8951 { PREFIX_TABLE (PREFIX_VEX_0F380D
) },
8952 { PREFIX_TABLE (PREFIX_VEX_0F380E
) },
8953 { PREFIX_TABLE (PREFIX_VEX_0F380F
) },
8958 { PREFIX_TABLE (PREFIX_VEX_0F3813
) },
8961 { PREFIX_TABLE (PREFIX_VEX_0F3816
) },
8962 { PREFIX_TABLE (PREFIX_VEX_0F3817
) },
8964 { PREFIX_TABLE (PREFIX_VEX_0F3818
) },
8965 { PREFIX_TABLE (PREFIX_VEX_0F3819
) },
8966 { PREFIX_TABLE (PREFIX_VEX_0F381A
) },
8968 { PREFIX_TABLE (PREFIX_VEX_0F381C
) },
8969 { PREFIX_TABLE (PREFIX_VEX_0F381D
) },
8970 { PREFIX_TABLE (PREFIX_VEX_0F381E
) },
8973 { PREFIX_TABLE (PREFIX_VEX_0F3820
) },
8974 { PREFIX_TABLE (PREFIX_VEX_0F3821
) },
8975 { PREFIX_TABLE (PREFIX_VEX_0F3822
) },
8976 { PREFIX_TABLE (PREFIX_VEX_0F3823
) },
8977 { PREFIX_TABLE (PREFIX_VEX_0F3824
) },
8978 { PREFIX_TABLE (PREFIX_VEX_0F3825
) },
8982 { PREFIX_TABLE (PREFIX_VEX_0F3828
) },
8983 { PREFIX_TABLE (PREFIX_VEX_0F3829
) },
8984 { PREFIX_TABLE (PREFIX_VEX_0F382A
) },
8985 { PREFIX_TABLE (PREFIX_VEX_0F382B
) },
8986 { PREFIX_TABLE (PREFIX_VEX_0F382C
) },
8987 { PREFIX_TABLE (PREFIX_VEX_0F382D
) },
8988 { PREFIX_TABLE (PREFIX_VEX_0F382E
) },
8989 { PREFIX_TABLE (PREFIX_VEX_0F382F
) },
8991 { PREFIX_TABLE (PREFIX_VEX_0F3830
) },
8992 { PREFIX_TABLE (PREFIX_VEX_0F3831
) },
8993 { PREFIX_TABLE (PREFIX_VEX_0F3832
) },
8994 { PREFIX_TABLE (PREFIX_VEX_0F3833
) },
8995 { PREFIX_TABLE (PREFIX_VEX_0F3834
) },
8996 { PREFIX_TABLE (PREFIX_VEX_0F3835
) },
8997 { PREFIX_TABLE (PREFIX_VEX_0F3836
) },
8998 { PREFIX_TABLE (PREFIX_VEX_0F3837
) },
9000 { PREFIX_TABLE (PREFIX_VEX_0F3838
) },
9001 { PREFIX_TABLE (PREFIX_VEX_0F3839
) },
9002 { PREFIX_TABLE (PREFIX_VEX_0F383A
) },
9003 { PREFIX_TABLE (PREFIX_VEX_0F383B
) },
9004 { PREFIX_TABLE (PREFIX_VEX_0F383C
) },
9005 { PREFIX_TABLE (PREFIX_VEX_0F383D
) },
9006 { PREFIX_TABLE (PREFIX_VEX_0F383E
) },
9007 { PREFIX_TABLE (PREFIX_VEX_0F383F
) },
9009 { PREFIX_TABLE (PREFIX_VEX_0F3840
) },
9010 { PREFIX_TABLE (PREFIX_VEX_0F3841
) },
9014 { PREFIX_TABLE (PREFIX_VEX_0F3845
) },
9015 { PREFIX_TABLE (PREFIX_VEX_0F3846
) },
9016 { PREFIX_TABLE (PREFIX_VEX_0F3847
) },
9036 { PREFIX_TABLE (PREFIX_VEX_0F3858
) },
9037 { PREFIX_TABLE (PREFIX_VEX_0F3859
) },
9038 { PREFIX_TABLE (PREFIX_VEX_0F385A
) },
9072 { PREFIX_TABLE (PREFIX_VEX_0F3878
) },
9073 { PREFIX_TABLE (PREFIX_VEX_0F3879
) },
9094 { PREFIX_TABLE (PREFIX_VEX_0F388C
) },
9096 { PREFIX_TABLE (PREFIX_VEX_0F388E
) },
9099 { PREFIX_TABLE (PREFIX_VEX_0F3890
) },
9100 { PREFIX_TABLE (PREFIX_VEX_0F3891
) },
9101 { PREFIX_TABLE (PREFIX_VEX_0F3892
) },
9102 { PREFIX_TABLE (PREFIX_VEX_0F3893
) },
9105 { PREFIX_TABLE (PREFIX_VEX_0F3896
) },
9106 { PREFIX_TABLE (PREFIX_VEX_0F3897
) },
9108 { PREFIX_TABLE (PREFIX_VEX_0F3898
) },
9109 { PREFIX_TABLE (PREFIX_VEX_0F3899
) },
9110 { PREFIX_TABLE (PREFIX_VEX_0F389A
) },
9111 { PREFIX_TABLE (PREFIX_VEX_0F389B
) },
9112 { PREFIX_TABLE (PREFIX_VEX_0F389C
) },
9113 { PREFIX_TABLE (PREFIX_VEX_0F389D
) },
9114 { PREFIX_TABLE (PREFIX_VEX_0F389E
) },
9115 { PREFIX_TABLE (PREFIX_VEX_0F389F
) },
9123 { PREFIX_TABLE (PREFIX_VEX_0F38A6
) },
9124 { PREFIX_TABLE (PREFIX_VEX_0F38A7
) },
9126 { PREFIX_TABLE (PREFIX_VEX_0F38A8
) },
9127 { PREFIX_TABLE (PREFIX_VEX_0F38A9
) },
9128 { PREFIX_TABLE (PREFIX_VEX_0F38AA
) },
9129 { PREFIX_TABLE (PREFIX_VEX_0F38AB
) },
9130 { PREFIX_TABLE (PREFIX_VEX_0F38AC
) },
9131 { PREFIX_TABLE (PREFIX_VEX_0F38AD
) },
9132 { PREFIX_TABLE (PREFIX_VEX_0F38AE
) },
9133 { PREFIX_TABLE (PREFIX_VEX_0F38AF
) },
9141 { PREFIX_TABLE (PREFIX_VEX_0F38B6
) },
9142 { PREFIX_TABLE (PREFIX_VEX_0F38B7
) },
9144 { PREFIX_TABLE (PREFIX_VEX_0F38B8
) },
9145 { PREFIX_TABLE (PREFIX_VEX_0F38B9
) },
9146 { PREFIX_TABLE (PREFIX_VEX_0F38BA
) },
9147 { PREFIX_TABLE (PREFIX_VEX_0F38BB
) },
9148 { PREFIX_TABLE (PREFIX_VEX_0F38BC
) },
9149 { PREFIX_TABLE (PREFIX_VEX_0F38BD
) },
9150 { PREFIX_TABLE (PREFIX_VEX_0F38BE
) },
9151 { PREFIX_TABLE (PREFIX_VEX_0F38BF
) },
9183 { PREFIX_TABLE (PREFIX_VEX_0F38DB
) },
9184 { PREFIX_TABLE (PREFIX_VEX_0F38DC
) },
9185 { PREFIX_TABLE (PREFIX_VEX_0F38DD
) },
9186 { PREFIX_TABLE (PREFIX_VEX_0F38DE
) },
9187 { PREFIX_TABLE (PREFIX_VEX_0F38DF
) },
9209 { PREFIX_TABLE (PREFIX_VEX_0F38F2
) },
9210 { REG_TABLE (REG_VEX_0F38F3
) },
9212 { PREFIX_TABLE (PREFIX_VEX_0F38F5
) },
9213 { PREFIX_TABLE (PREFIX_VEX_0F38F6
) },
9214 { PREFIX_TABLE (PREFIX_VEX_0F38F7
) },
9228 { PREFIX_TABLE (PREFIX_VEX_0F3A00
) },
9229 { PREFIX_TABLE (PREFIX_VEX_0F3A01
) },
9230 { PREFIX_TABLE (PREFIX_VEX_0F3A02
) },
9232 { PREFIX_TABLE (PREFIX_VEX_0F3A04
) },
9233 { PREFIX_TABLE (PREFIX_VEX_0F3A05
) },
9234 { PREFIX_TABLE (PREFIX_VEX_0F3A06
) },
9237 { PREFIX_TABLE (PREFIX_VEX_0F3A08
) },
9238 { PREFIX_TABLE (PREFIX_VEX_0F3A09
) },
9239 { PREFIX_TABLE (PREFIX_VEX_0F3A0A
) },
9240 { PREFIX_TABLE (PREFIX_VEX_0F3A0B
) },
9241 { PREFIX_TABLE (PREFIX_VEX_0F3A0C
) },
9242 { PREFIX_TABLE (PREFIX_VEX_0F3A0D
) },
9243 { PREFIX_TABLE (PREFIX_VEX_0F3A0E
) },
9244 { PREFIX_TABLE (PREFIX_VEX_0F3A0F
) },
9250 { PREFIX_TABLE (PREFIX_VEX_0F3A14
) },
9251 { PREFIX_TABLE (PREFIX_VEX_0F3A15
) },
9252 { PREFIX_TABLE (PREFIX_VEX_0F3A16
) },
9253 { PREFIX_TABLE (PREFIX_VEX_0F3A17
) },
9255 { PREFIX_TABLE (PREFIX_VEX_0F3A18
) },
9256 { PREFIX_TABLE (PREFIX_VEX_0F3A19
) },
9260 { PREFIX_TABLE (PREFIX_VEX_0F3A1D
) },
9264 { PREFIX_TABLE (PREFIX_VEX_0F3A20
) },
9265 { PREFIX_TABLE (PREFIX_VEX_0F3A21
) },
9266 { PREFIX_TABLE (PREFIX_VEX_0F3A22
) },
9282 { PREFIX_TABLE (PREFIX_VEX_0F3A30
) },
9283 { PREFIX_TABLE (PREFIX_VEX_0F3A31
) },
9284 { PREFIX_TABLE (PREFIX_VEX_0F3A32
) },
9285 { PREFIX_TABLE (PREFIX_VEX_0F3A33
) },
9291 { PREFIX_TABLE (PREFIX_VEX_0F3A38
) },
9292 { PREFIX_TABLE (PREFIX_VEX_0F3A39
) },
9300 { PREFIX_TABLE (PREFIX_VEX_0F3A40
) },
9301 { PREFIX_TABLE (PREFIX_VEX_0F3A41
) },
9302 { PREFIX_TABLE (PREFIX_VEX_0F3A42
) },
9304 { PREFIX_TABLE (PREFIX_VEX_0F3A44
) },
9306 { PREFIX_TABLE (PREFIX_VEX_0F3A46
) },
9309 { PREFIX_TABLE (PREFIX_VEX_0F3A48
) },
9310 { PREFIX_TABLE (PREFIX_VEX_0F3A49
) },
9311 { PREFIX_TABLE (PREFIX_VEX_0F3A4A
) },
9312 { PREFIX_TABLE (PREFIX_VEX_0F3A4B
) },
9313 { PREFIX_TABLE (PREFIX_VEX_0F3A4C
) },
9331 { PREFIX_TABLE (PREFIX_VEX_0F3A5C
) },
9332 { PREFIX_TABLE (PREFIX_VEX_0F3A5D
) },
9333 { PREFIX_TABLE (PREFIX_VEX_0F3A5E
) },
9334 { PREFIX_TABLE (PREFIX_VEX_0F3A5F
) },
9336 { PREFIX_TABLE (PREFIX_VEX_0F3A60
) },
9337 { PREFIX_TABLE (PREFIX_VEX_0F3A61
) },
9338 { PREFIX_TABLE (PREFIX_VEX_0F3A62
) },
9339 { PREFIX_TABLE (PREFIX_VEX_0F3A63
) },
9345 { PREFIX_TABLE (PREFIX_VEX_0F3A68
) },
9346 { PREFIX_TABLE (PREFIX_VEX_0F3A69
) },
9347 { PREFIX_TABLE (PREFIX_VEX_0F3A6A
) },
9348 { PREFIX_TABLE (PREFIX_VEX_0F3A6B
) },
9349 { PREFIX_TABLE (PREFIX_VEX_0F3A6C
) },
9350 { PREFIX_TABLE (PREFIX_VEX_0F3A6D
) },
9351 { PREFIX_TABLE (PREFIX_VEX_0F3A6E
) },
9352 { PREFIX_TABLE (PREFIX_VEX_0F3A6F
) },
9363 { PREFIX_TABLE (PREFIX_VEX_0F3A78
) },
9364 { PREFIX_TABLE (PREFIX_VEX_0F3A79
) },
9365 { PREFIX_TABLE (PREFIX_VEX_0F3A7A
) },
9366 { PREFIX_TABLE (PREFIX_VEX_0F3A7B
) },
9367 { PREFIX_TABLE (PREFIX_VEX_0F3A7C
) },
9368 { PREFIX_TABLE (PREFIX_VEX_0F3A7D
) },
9369 { PREFIX_TABLE (PREFIX_VEX_0F3A7E
) },
9370 { PREFIX_TABLE (PREFIX_VEX_0F3A7F
) },
9478 { PREFIX_TABLE (PREFIX_VEX_0F3ADF
) },
9498 { PREFIX_TABLE (PREFIX_VEX_0F3AF0
) },
9518 #define NEED_OPCODE_TABLE
9519 #include "i386-dis-evex.h"
9520 #undef NEED_OPCODE_TABLE
9521 static const struct dis386 vex_len_table
[][2] = {
9522 /* VEX_LEN_0F10_P_1 */
9524 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
9525 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
9528 /* VEX_LEN_0F10_P_3 */
9530 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
9531 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
9534 /* VEX_LEN_0F11_P_1 */
9536 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
9537 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
9540 /* VEX_LEN_0F11_P_3 */
9542 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
9543 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
9546 /* VEX_LEN_0F12_P_0_M_0 */
9548 { VEX_W_TABLE (VEX_W_0F12_P_0_M_0
) },
9551 /* VEX_LEN_0F12_P_0_M_1 */
9553 { VEX_W_TABLE (VEX_W_0F12_P_0_M_1
) },
9556 /* VEX_LEN_0F12_P_2 */
9558 { VEX_W_TABLE (VEX_W_0F12_P_2
) },
9561 /* VEX_LEN_0F13_M_0 */
9563 { VEX_W_TABLE (VEX_W_0F13_M_0
) },
9566 /* VEX_LEN_0F16_P_0_M_0 */
9568 { VEX_W_TABLE (VEX_W_0F16_P_0_M_0
) },
9571 /* VEX_LEN_0F16_P_0_M_1 */
9573 { VEX_W_TABLE (VEX_W_0F16_P_0_M_1
) },
9576 /* VEX_LEN_0F16_P_2 */
9578 { VEX_W_TABLE (VEX_W_0F16_P_2
) },
9581 /* VEX_LEN_0F17_M_0 */
9583 { VEX_W_TABLE (VEX_W_0F17_M_0
) },
9586 /* VEX_LEN_0F2A_P_1 */
9588 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9589 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9592 /* VEX_LEN_0F2A_P_3 */
9594 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9595 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9598 /* VEX_LEN_0F2C_P_1 */
9600 { "vcvttss2siY", { Gv
, EXdScalar
}, 0 },
9601 { "vcvttss2siY", { Gv
, EXdScalar
}, 0 },
9604 /* VEX_LEN_0F2C_P_3 */
9606 { "vcvttsd2siY", { Gv
, EXqScalar
}, 0 },
9607 { "vcvttsd2siY", { Gv
, EXqScalar
}, 0 },
9610 /* VEX_LEN_0F2D_P_1 */
9612 { "vcvtss2siY", { Gv
, EXdScalar
}, 0 },
9613 { "vcvtss2siY", { Gv
, EXdScalar
}, 0 },
9616 /* VEX_LEN_0F2D_P_3 */
9618 { "vcvtsd2siY", { Gv
, EXqScalar
}, 0 },
9619 { "vcvtsd2siY", { Gv
, EXqScalar
}, 0 },
9622 /* VEX_LEN_0F2E_P_0 */
9624 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
9625 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
9628 /* VEX_LEN_0F2E_P_2 */
9630 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
9631 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
9634 /* VEX_LEN_0F2F_P_0 */
9636 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
9637 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
9640 /* VEX_LEN_0F2F_P_2 */
9642 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
9643 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
9646 /* VEX_LEN_0F41_P_0 */
9649 { VEX_W_TABLE (VEX_W_0F41_P_0_LEN_1
) },
9651 /* VEX_LEN_0F41_P_2 */
9654 { VEX_W_TABLE (VEX_W_0F41_P_2_LEN_1
) },
9656 /* VEX_LEN_0F42_P_0 */
9659 { VEX_W_TABLE (VEX_W_0F42_P_0_LEN_1
) },
9661 /* VEX_LEN_0F42_P_2 */
9664 { VEX_W_TABLE (VEX_W_0F42_P_2_LEN_1
) },
9666 /* VEX_LEN_0F44_P_0 */
9668 { VEX_W_TABLE (VEX_W_0F44_P_0_LEN_0
) },
9670 /* VEX_LEN_0F44_P_2 */
9672 { VEX_W_TABLE (VEX_W_0F44_P_2_LEN_0
) },
9674 /* VEX_LEN_0F45_P_0 */
9677 { VEX_W_TABLE (VEX_W_0F45_P_0_LEN_1
) },
9679 /* VEX_LEN_0F45_P_2 */
9682 { VEX_W_TABLE (VEX_W_0F45_P_2_LEN_1
) },
9684 /* VEX_LEN_0F46_P_0 */
9687 { VEX_W_TABLE (VEX_W_0F46_P_0_LEN_1
) },
9689 /* VEX_LEN_0F46_P_2 */
9692 { VEX_W_TABLE (VEX_W_0F46_P_2_LEN_1
) },
9694 /* VEX_LEN_0F47_P_0 */
9697 { VEX_W_TABLE (VEX_W_0F47_P_0_LEN_1
) },
9699 /* VEX_LEN_0F47_P_2 */
9702 { VEX_W_TABLE (VEX_W_0F47_P_2_LEN_1
) },
9704 /* VEX_LEN_0F4A_P_0 */
9707 { VEX_W_TABLE (VEX_W_0F4A_P_0_LEN_1
) },
9709 /* VEX_LEN_0F4A_P_2 */
9712 { VEX_W_TABLE (VEX_W_0F4A_P_2_LEN_1
) },
9714 /* VEX_LEN_0F4B_P_0 */
9717 { VEX_W_TABLE (VEX_W_0F4B_P_0_LEN_1
) },
9719 /* VEX_LEN_0F4B_P_2 */
9722 { VEX_W_TABLE (VEX_W_0F4B_P_2_LEN_1
) },
9725 /* VEX_LEN_0F51_P_1 */
9727 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
9728 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
9731 /* VEX_LEN_0F51_P_3 */
9733 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
9734 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
9737 /* VEX_LEN_0F52_P_1 */
9739 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
9740 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
9743 /* VEX_LEN_0F53_P_1 */
9745 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
9746 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
9749 /* VEX_LEN_0F58_P_1 */
9751 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
9752 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
9755 /* VEX_LEN_0F58_P_3 */
9757 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
9758 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
9761 /* VEX_LEN_0F59_P_1 */
9763 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
9764 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
9767 /* VEX_LEN_0F59_P_3 */
9769 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
9770 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
9773 /* VEX_LEN_0F5A_P_1 */
9775 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
9776 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
9779 /* VEX_LEN_0F5A_P_3 */
9781 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
9782 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
9785 /* VEX_LEN_0F5C_P_1 */
9787 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
9788 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
9791 /* VEX_LEN_0F5C_P_3 */
9793 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
9794 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
9797 /* VEX_LEN_0F5D_P_1 */
9799 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
9800 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
9803 /* VEX_LEN_0F5D_P_3 */
9805 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
9806 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
9809 /* VEX_LEN_0F5E_P_1 */
9811 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
9812 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
9815 /* VEX_LEN_0F5E_P_3 */
9817 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
9818 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
9821 /* VEX_LEN_0F5F_P_1 */
9823 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
9824 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
9827 /* VEX_LEN_0F5F_P_3 */
9829 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
9830 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
9833 /* VEX_LEN_0F6E_P_2 */
9835 { "vmovK", { XMScalar
, Edq
}, 0 },
9836 { "vmovK", { XMScalar
, Edq
}, 0 },
9839 /* VEX_LEN_0F7E_P_1 */
9841 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
9842 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
9845 /* VEX_LEN_0F7E_P_2 */
9847 { "vmovK", { Edq
, XMScalar
}, 0 },
9848 { "vmovK", { Edq
, XMScalar
}, 0 },
9851 /* VEX_LEN_0F90_P_0 */
9853 { VEX_W_TABLE (VEX_W_0F90_P_0_LEN_0
) },
9856 /* VEX_LEN_0F90_P_2 */
9858 { VEX_W_TABLE (VEX_W_0F90_P_2_LEN_0
) },
9861 /* VEX_LEN_0F91_P_0 */
9863 { VEX_W_TABLE (VEX_W_0F91_P_0_LEN_0
) },
9866 /* VEX_LEN_0F91_P_2 */
9868 { VEX_W_TABLE (VEX_W_0F91_P_2_LEN_0
) },
9871 /* VEX_LEN_0F92_P_0 */
9873 { VEX_W_TABLE (VEX_W_0F92_P_0_LEN_0
) },
9876 /* VEX_LEN_0F92_P_2 */
9878 { VEX_W_TABLE (VEX_W_0F92_P_2_LEN_0
) },
9881 /* VEX_LEN_0F92_P_3 */
9883 { VEX_W_TABLE (VEX_W_0F92_P_3_LEN_0
) },
9886 /* VEX_LEN_0F93_P_0 */
9888 { VEX_W_TABLE (VEX_W_0F93_P_0_LEN_0
) },
9891 /* VEX_LEN_0F93_P_2 */
9893 { VEX_W_TABLE (VEX_W_0F93_P_2_LEN_0
) },
9896 /* VEX_LEN_0F93_P_3 */
9898 { VEX_W_TABLE (VEX_W_0F93_P_3_LEN_0
) },
9901 /* VEX_LEN_0F98_P_0 */
9903 { VEX_W_TABLE (VEX_W_0F98_P_0_LEN_0
) },
9906 /* VEX_LEN_0F98_P_2 */
9908 { VEX_W_TABLE (VEX_W_0F98_P_2_LEN_0
) },
9911 /* VEX_LEN_0F99_P_0 */
9913 { VEX_W_TABLE (VEX_W_0F99_P_0_LEN_0
) },
9916 /* VEX_LEN_0F99_P_2 */
9918 { VEX_W_TABLE (VEX_W_0F99_P_2_LEN_0
) },
9921 /* VEX_LEN_0FAE_R_2_M_0 */
9923 { VEX_W_TABLE (VEX_W_0FAE_R_2_M_0
) },
9926 /* VEX_LEN_0FAE_R_3_M_0 */
9928 { VEX_W_TABLE (VEX_W_0FAE_R_3_M_0
) },
9931 /* VEX_LEN_0FC2_P_1 */
9933 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
9934 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
9937 /* VEX_LEN_0FC2_P_3 */
9939 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
9940 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
9943 /* VEX_LEN_0FC4_P_2 */
9945 { VEX_W_TABLE (VEX_W_0FC4_P_2
) },
9948 /* VEX_LEN_0FC5_P_2 */
9950 { VEX_W_TABLE (VEX_W_0FC5_P_2
) },
9953 /* VEX_LEN_0FD6_P_2 */
9955 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
9956 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
9959 /* VEX_LEN_0FF7_P_2 */
9961 { VEX_W_TABLE (VEX_W_0FF7_P_2
) },
9964 /* VEX_LEN_0F3816_P_2 */
9967 { VEX_W_TABLE (VEX_W_0F3816_P_2
) },
9970 /* VEX_LEN_0F3819_P_2 */
9973 { VEX_W_TABLE (VEX_W_0F3819_P_2
) },
9976 /* VEX_LEN_0F381A_P_2_M_0 */
9979 { VEX_W_TABLE (VEX_W_0F381A_P_2_M_0
) },
9982 /* VEX_LEN_0F3836_P_2 */
9985 { VEX_W_TABLE (VEX_W_0F3836_P_2
) },
9988 /* VEX_LEN_0F3841_P_2 */
9990 { VEX_W_TABLE (VEX_W_0F3841_P_2
) },
9993 /* VEX_LEN_0F385A_P_2_M_0 */
9996 { VEX_W_TABLE (VEX_W_0F385A_P_2_M_0
) },
9999 /* VEX_LEN_0F38DB_P_2 */
10001 { VEX_W_TABLE (VEX_W_0F38DB_P_2
) },
10004 /* VEX_LEN_0F38DC_P_2 */
10006 { VEX_W_TABLE (VEX_W_0F38DC_P_2
) },
10009 /* VEX_LEN_0F38DD_P_2 */
10011 { VEX_W_TABLE (VEX_W_0F38DD_P_2
) },
10014 /* VEX_LEN_0F38DE_P_2 */
10016 { VEX_W_TABLE (VEX_W_0F38DE_P_2
) },
10019 /* VEX_LEN_0F38DF_P_2 */
10021 { VEX_W_TABLE (VEX_W_0F38DF_P_2
) },
10024 /* VEX_LEN_0F38F2_P_0 */
10026 { "andnS", { Gdq
, VexGdq
, Edq
}, 0 },
10029 /* VEX_LEN_0F38F3_R_1_P_0 */
10031 { "blsrS", { VexGdq
, Edq
}, 0 },
10034 /* VEX_LEN_0F38F3_R_2_P_0 */
10036 { "blsmskS", { VexGdq
, Edq
}, 0 },
10039 /* VEX_LEN_0F38F3_R_3_P_0 */
10041 { "blsiS", { VexGdq
, Edq
}, 0 },
10044 /* VEX_LEN_0F38F5_P_0 */
10046 { "bzhiS", { Gdq
, Edq
, VexGdq
}, 0 },
10049 /* VEX_LEN_0F38F5_P_1 */
10051 { "pextS", { Gdq
, VexGdq
, Edq
}, 0 },
10054 /* VEX_LEN_0F38F5_P_3 */
10056 { "pdepS", { Gdq
, VexGdq
, Edq
}, 0 },
10059 /* VEX_LEN_0F38F6_P_3 */
10061 { "mulxS", { Gdq
, VexGdq
, Edq
}, 0 },
10064 /* VEX_LEN_0F38F7_P_0 */
10066 { "bextrS", { Gdq
, Edq
, VexGdq
}, 0 },
10069 /* VEX_LEN_0F38F7_P_1 */
10071 { "sarxS", { Gdq
, Edq
, VexGdq
}, 0 },
10074 /* VEX_LEN_0F38F7_P_2 */
10076 { "shlxS", { Gdq
, Edq
, VexGdq
}, 0 },
10079 /* VEX_LEN_0F38F7_P_3 */
10081 { "shrxS", { Gdq
, Edq
, VexGdq
}, 0 },
10084 /* VEX_LEN_0F3A00_P_2 */
10087 { VEX_W_TABLE (VEX_W_0F3A00_P_2
) },
10090 /* VEX_LEN_0F3A01_P_2 */
10093 { VEX_W_TABLE (VEX_W_0F3A01_P_2
) },
10096 /* VEX_LEN_0F3A06_P_2 */
10099 { VEX_W_TABLE (VEX_W_0F3A06_P_2
) },
10102 /* VEX_LEN_0F3A0A_P_2 */
10104 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
10105 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
10108 /* VEX_LEN_0F3A0B_P_2 */
10110 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
10111 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
10114 /* VEX_LEN_0F3A14_P_2 */
10116 { VEX_W_TABLE (VEX_W_0F3A14_P_2
) },
10119 /* VEX_LEN_0F3A15_P_2 */
10121 { VEX_W_TABLE (VEX_W_0F3A15_P_2
) },
10124 /* VEX_LEN_0F3A16_P_2 */
10126 { "vpextrK", { Edq
, XM
, Ib
}, 0 },
10129 /* VEX_LEN_0F3A17_P_2 */
10131 { "vextractps", { Edqd
, XM
, Ib
}, 0 },
10134 /* VEX_LEN_0F3A18_P_2 */
10137 { VEX_W_TABLE (VEX_W_0F3A18_P_2
) },
10140 /* VEX_LEN_0F3A19_P_2 */
10143 { VEX_W_TABLE (VEX_W_0F3A19_P_2
) },
10146 /* VEX_LEN_0F3A20_P_2 */
10148 { VEX_W_TABLE (VEX_W_0F3A20_P_2
) },
10151 /* VEX_LEN_0F3A21_P_2 */
10153 { VEX_W_TABLE (VEX_W_0F3A21_P_2
) },
10156 /* VEX_LEN_0F3A22_P_2 */
10158 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
}, 0 },
10161 /* VEX_LEN_0F3A30_P_2 */
10163 { VEX_W_TABLE (VEX_W_0F3A30_P_2_LEN_0
) },
10166 /* VEX_LEN_0F3A31_P_2 */
10168 { VEX_W_TABLE (VEX_W_0F3A31_P_2_LEN_0
) },
10171 /* VEX_LEN_0F3A32_P_2 */
10173 { VEX_W_TABLE (VEX_W_0F3A32_P_2_LEN_0
) },
10176 /* VEX_LEN_0F3A33_P_2 */
10178 { VEX_W_TABLE (VEX_W_0F3A33_P_2_LEN_0
) },
10181 /* VEX_LEN_0F3A38_P_2 */
10184 { VEX_W_TABLE (VEX_W_0F3A38_P_2
) },
10187 /* VEX_LEN_0F3A39_P_2 */
10190 { VEX_W_TABLE (VEX_W_0F3A39_P_2
) },
10193 /* VEX_LEN_0F3A41_P_2 */
10195 { VEX_W_TABLE (VEX_W_0F3A41_P_2
) },
10198 /* VEX_LEN_0F3A44_P_2 */
10200 { VEX_W_TABLE (VEX_W_0F3A44_P_2
) },
10203 /* VEX_LEN_0F3A46_P_2 */
10206 { VEX_W_TABLE (VEX_W_0F3A46_P_2
) },
10209 /* VEX_LEN_0F3A60_P_2 */
10211 { VEX_W_TABLE (VEX_W_0F3A60_P_2
) },
10214 /* VEX_LEN_0F3A61_P_2 */
10216 { VEX_W_TABLE (VEX_W_0F3A61_P_2
) },
10219 /* VEX_LEN_0F3A62_P_2 */
10221 { VEX_W_TABLE (VEX_W_0F3A62_P_2
) },
10224 /* VEX_LEN_0F3A63_P_2 */
10226 { VEX_W_TABLE (VEX_W_0F3A63_P_2
) },
10229 /* VEX_LEN_0F3A6A_P_2 */
10231 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10234 /* VEX_LEN_0F3A6B_P_2 */
10236 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10239 /* VEX_LEN_0F3A6E_P_2 */
10241 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10244 /* VEX_LEN_0F3A6F_P_2 */
10246 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10249 /* VEX_LEN_0F3A7A_P_2 */
10251 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10254 /* VEX_LEN_0F3A7B_P_2 */
10256 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10259 /* VEX_LEN_0F3A7E_P_2 */
10261 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10264 /* VEX_LEN_0F3A7F_P_2 */
10266 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10269 /* VEX_LEN_0F3ADF_P_2 */
10271 { VEX_W_TABLE (VEX_W_0F3ADF_P_2
) },
10274 /* VEX_LEN_0F3AF0_P_3 */
10276 { "rorxS", { Gdq
, Edq
, Ib
}, 0 },
10279 /* VEX_LEN_0FXOP_08_CC */
10281 { "vpcomb", { XM
, Vex128
, EXx
, Ib
}, 0 },
10284 /* VEX_LEN_0FXOP_08_CD */
10286 { "vpcomw", { XM
, Vex128
, EXx
, Ib
}, 0 },
10289 /* VEX_LEN_0FXOP_08_CE */
10291 { "vpcomd", { XM
, Vex128
, EXx
, Ib
}, 0 },
10294 /* VEX_LEN_0FXOP_08_CF */
10296 { "vpcomq", { XM
, Vex128
, EXx
, Ib
}, 0 },
10299 /* VEX_LEN_0FXOP_08_EC */
10301 { "vpcomub", { XM
, Vex128
, EXx
, Ib
}, 0 },
10304 /* VEX_LEN_0FXOP_08_ED */
10306 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
}, 0 },
10309 /* VEX_LEN_0FXOP_08_EE */
10311 { "vpcomud", { XM
, Vex128
, EXx
, Ib
}, 0 },
10314 /* VEX_LEN_0FXOP_08_EF */
10316 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
}, 0 },
10319 /* VEX_LEN_0FXOP_09_80 */
10321 { "vfrczps", { XM
, EXxmm
}, 0 },
10322 { "vfrczps", { XM
, EXymmq
}, 0 },
10325 /* VEX_LEN_0FXOP_09_81 */
10327 { "vfrczpd", { XM
, EXxmm
}, 0 },
10328 { "vfrczpd", { XM
, EXymmq
}, 0 },
10332 static const struct dis386 vex_w_table
[][2] = {
10334 /* VEX_W_0F10_P_0 */
10335 { "vmovups", { XM
, EXx
}, 0 },
10338 /* VEX_W_0F10_P_1 */
10339 { "vmovss", { XMVexScalar
, VexScalar
, EXdScalar
}, 0 },
10342 /* VEX_W_0F10_P_2 */
10343 { "vmovupd", { XM
, EXx
}, 0 },
10346 /* VEX_W_0F10_P_3 */
10347 { "vmovsd", { XMVexScalar
, VexScalar
, EXqScalar
}, 0 },
10350 /* VEX_W_0F11_P_0 */
10351 { "vmovups", { EXxS
, XM
}, 0 },
10354 /* VEX_W_0F11_P_1 */
10355 { "vmovss", { EXdVexScalarS
, VexScalar
, XMScalar
}, 0 },
10358 /* VEX_W_0F11_P_2 */
10359 { "vmovupd", { EXxS
, XM
}, 0 },
10362 /* VEX_W_0F11_P_3 */
10363 { "vmovsd", { EXqVexScalarS
, VexScalar
, XMScalar
}, 0 },
10366 /* VEX_W_0F12_P_0_M_0 */
10367 { "vmovlps", { XM
, Vex128
, EXq
}, 0 },
10370 /* VEX_W_0F12_P_0_M_1 */
10371 { "vmovhlps", { XM
, Vex128
, EXq
}, 0 },
10374 /* VEX_W_0F12_P_1 */
10375 { "vmovsldup", { XM
, EXx
}, 0 },
10378 /* VEX_W_0F12_P_2 */
10379 { "vmovlpd", { XM
, Vex128
, EXq
}, 0 },
10382 /* VEX_W_0F12_P_3 */
10383 { "vmovddup", { XM
, EXymmq
}, 0 },
10386 /* VEX_W_0F13_M_0 */
10387 { "vmovlpX", { EXq
, XM
}, 0 },
10391 { "vunpcklpX", { XM
, Vex
, EXx
}, 0 },
10395 { "vunpckhpX", { XM
, Vex
, EXx
}, 0 },
10398 /* VEX_W_0F16_P_0_M_0 */
10399 { "vmovhps", { XM
, Vex128
, EXq
}, 0 },
10402 /* VEX_W_0F16_P_0_M_1 */
10403 { "vmovlhps", { XM
, Vex128
, EXq
}, 0 },
10406 /* VEX_W_0F16_P_1 */
10407 { "vmovshdup", { XM
, EXx
}, 0 },
10410 /* VEX_W_0F16_P_2 */
10411 { "vmovhpd", { XM
, Vex128
, EXq
}, 0 },
10414 /* VEX_W_0F17_M_0 */
10415 { "vmovhpX", { EXq
, XM
}, 0 },
10419 { "vmovapX", { XM
, EXx
}, 0 },
10423 { "vmovapX", { EXxS
, XM
}, 0 },
10426 /* VEX_W_0F2B_M_0 */
10427 { "vmovntpX", { Mx
, XM
}, 0 },
10430 /* VEX_W_0F2E_P_0 */
10431 { "vucomiss", { XMScalar
, EXdScalar
}, 0 },
10434 /* VEX_W_0F2E_P_2 */
10435 { "vucomisd", { XMScalar
, EXqScalar
}, 0 },
10438 /* VEX_W_0F2F_P_0 */
10439 { "vcomiss", { XMScalar
, EXdScalar
}, 0 },
10442 /* VEX_W_0F2F_P_2 */
10443 { "vcomisd", { XMScalar
, EXqScalar
}, 0 },
10446 /* VEX_W_0F41_P_0_LEN_1 */
10447 { "kandw", { MaskG
, MaskVex
, MaskR
}, 0 },
10448 { "kandq", { MaskG
, MaskVex
, MaskR
}, 0 },
10451 /* VEX_W_0F41_P_2_LEN_1 */
10452 { "kandb", { MaskG
, MaskVex
, MaskR
}, 0 },
10453 { "kandd", { MaskG
, MaskVex
, MaskR
}, 0 },
10456 /* VEX_W_0F42_P_0_LEN_1 */
10457 { "kandnw", { MaskG
, MaskVex
, MaskR
}, 0 },
10458 { "kandnq", { MaskG
, MaskVex
, MaskR
}, 0 },
10461 /* VEX_W_0F42_P_2_LEN_1 */
10462 { "kandnb", { MaskG
, MaskVex
, MaskR
}, 0 },
10463 { "kandnd", { MaskG
, MaskVex
, MaskR
}, 0 },
10466 /* VEX_W_0F44_P_0_LEN_0 */
10467 { "knotw", { MaskG
, MaskR
}, 0 },
10468 { "knotq", { MaskG
, MaskR
}, 0 },
10471 /* VEX_W_0F44_P_2_LEN_0 */
10472 { "knotb", { MaskG
, MaskR
}, 0 },
10473 { "knotd", { MaskG
, MaskR
}, 0 },
10476 /* VEX_W_0F45_P_0_LEN_1 */
10477 { "korw", { MaskG
, MaskVex
, MaskR
}, 0 },
10478 { "korq", { MaskG
, MaskVex
, MaskR
}, 0 },
10481 /* VEX_W_0F45_P_2_LEN_1 */
10482 { "korb", { MaskG
, MaskVex
, MaskR
}, 0 },
10483 { "kord", { MaskG
, MaskVex
, MaskR
}, 0 },
10486 /* VEX_W_0F46_P_0_LEN_1 */
10487 { "kxnorw", { MaskG
, MaskVex
, MaskR
}, 0 },
10488 { "kxnorq", { MaskG
, MaskVex
, MaskR
}, 0 },
10491 /* VEX_W_0F46_P_2_LEN_1 */
10492 { "kxnorb", { MaskG
, MaskVex
, MaskR
}, 0 },
10493 { "kxnord", { MaskG
, MaskVex
, MaskR
}, 0 },
10496 /* VEX_W_0F47_P_0_LEN_1 */
10497 { "kxorw", { MaskG
, MaskVex
, MaskR
}, 0 },
10498 { "kxorq", { MaskG
, MaskVex
, MaskR
}, 0 },
10501 /* VEX_W_0F47_P_2_LEN_1 */
10502 { "kxorb", { MaskG
, MaskVex
, MaskR
}, 0 },
10503 { "kxord", { MaskG
, MaskVex
, MaskR
}, 0 },
10506 /* VEX_W_0F4A_P_0_LEN_1 */
10507 { "kaddw", { MaskG
, MaskVex
, MaskR
}, 0 },
10508 { "kaddq", { MaskG
, MaskVex
, MaskR
}, 0 },
10511 /* VEX_W_0F4A_P_2_LEN_1 */
10512 { "kaddb", { MaskG
, MaskVex
, MaskR
}, 0 },
10513 { "kaddd", { MaskG
, MaskVex
, MaskR
}, 0 },
10516 /* VEX_W_0F4B_P_0_LEN_1 */
10517 { "kunpckwd", { MaskG
, MaskVex
, MaskR
}, 0 },
10518 { "kunpckdq", { MaskG
, MaskVex
, MaskR
}, 0 },
10521 /* VEX_W_0F4B_P_2_LEN_1 */
10522 { "kunpckbw", { MaskG
, MaskVex
, MaskR
}, 0 },
10525 /* VEX_W_0F50_M_0 */
10526 { "vmovmskpX", { Gdq
, XS
}, 0 },
10529 /* VEX_W_0F51_P_0 */
10530 { "vsqrtps", { XM
, EXx
}, 0 },
10533 /* VEX_W_0F51_P_1 */
10534 { "vsqrtss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10537 /* VEX_W_0F51_P_2 */
10538 { "vsqrtpd", { XM
, EXx
}, 0 },
10541 /* VEX_W_0F51_P_3 */
10542 { "vsqrtsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10545 /* VEX_W_0F52_P_0 */
10546 { "vrsqrtps", { XM
, EXx
}, 0 },
10549 /* VEX_W_0F52_P_1 */
10550 { "vrsqrtss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10553 /* VEX_W_0F53_P_0 */
10554 { "vrcpps", { XM
, EXx
}, 0 },
10557 /* VEX_W_0F53_P_1 */
10558 { "vrcpss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10561 /* VEX_W_0F58_P_0 */
10562 { "vaddps", { XM
, Vex
, EXx
}, 0 },
10565 /* VEX_W_0F58_P_1 */
10566 { "vaddss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10569 /* VEX_W_0F58_P_2 */
10570 { "vaddpd", { XM
, Vex
, EXx
}, 0 },
10573 /* VEX_W_0F58_P_3 */
10574 { "vaddsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10577 /* VEX_W_0F59_P_0 */
10578 { "vmulps", { XM
, Vex
, EXx
}, 0 },
10581 /* VEX_W_0F59_P_1 */
10582 { "vmulss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10585 /* VEX_W_0F59_P_2 */
10586 { "vmulpd", { XM
, Vex
, EXx
}, 0 },
10589 /* VEX_W_0F59_P_3 */
10590 { "vmulsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10593 /* VEX_W_0F5A_P_0 */
10594 { "vcvtps2pd", { XM
, EXxmmq
}, 0 },
10597 /* VEX_W_0F5A_P_1 */
10598 { "vcvtss2sd", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10601 /* VEX_W_0F5A_P_3 */
10602 { "vcvtsd2ss", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10605 /* VEX_W_0F5B_P_0 */
10606 { "vcvtdq2ps", { XM
, EXx
}, 0 },
10609 /* VEX_W_0F5B_P_1 */
10610 { "vcvttps2dq", { XM
, EXx
}, 0 },
10613 /* VEX_W_0F5B_P_2 */
10614 { "vcvtps2dq", { XM
, EXx
}, 0 },
10617 /* VEX_W_0F5C_P_0 */
10618 { "vsubps", { XM
, Vex
, EXx
}, 0 },
10621 /* VEX_W_0F5C_P_1 */
10622 { "vsubss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10625 /* VEX_W_0F5C_P_2 */
10626 { "vsubpd", { XM
, Vex
, EXx
}, 0 },
10629 /* VEX_W_0F5C_P_3 */
10630 { "vsubsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10633 /* VEX_W_0F5D_P_0 */
10634 { "vminps", { XM
, Vex
, EXx
}, 0 },
10637 /* VEX_W_0F5D_P_1 */
10638 { "vminss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10641 /* VEX_W_0F5D_P_2 */
10642 { "vminpd", { XM
, Vex
, EXx
}, 0 },
10645 /* VEX_W_0F5D_P_3 */
10646 { "vminsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10649 /* VEX_W_0F5E_P_0 */
10650 { "vdivps", { XM
, Vex
, EXx
}, 0 },
10653 /* VEX_W_0F5E_P_1 */
10654 { "vdivss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10657 /* VEX_W_0F5E_P_2 */
10658 { "vdivpd", { XM
, Vex
, EXx
}, 0 },
10661 /* VEX_W_0F5E_P_3 */
10662 { "vdivsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10665 /* VEX_W_0F5F_P_0 */
10666 { "vmaxps", { XM
, Vex
, EXx
}, 0 },
10669 /* VEX_W_0F5F_P_1 */
10670 { "vmaxss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10673 /* VEX_W_0F5F_P_2 */
10674 { "vmaxpd", { XM
, Vex
, EXx
}, 0 },
10677 /* VEX_W_0F5F_P_3 */
10678 { "vmaxsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10681 /* VEX_W_0F60_P_2 */
10682 { "vpunpcklbw", { XM
, Vex
, EXx
}, 0 },
10685 /* VEX_W_0F61_P_2 */
10686 { "vpunpcklwd", { XM
, Vex
, EXx
}, 0 },
10689 /* VEX_W_0F62_P_2 */
10690 { "vpunpckldq", { XM
, Vex
, EXx
}, 0 },
10693 /* VEX_W_0F63_P_2 */
10694 { "vpacksswb", { XM
, Vex
, EXx
}, 0 },
10697 /* VEX_W_0F64_P_2 */
10698 { "vpcmpgtb", { XM
, Vex
, EXx
}, 0 },
10701 /* VEX_W_0F65_P_2 */
10702 { "vpcmpgtw", { XM
, Vex
, EXx
}, 0 },
10705 /* VEX_W_0F66_P_2 */
10706 { "vpcmpgtd", { XM
, Vex
, EXx
}, 0 },
10709 /* VEX_W_0F67_P_2 */
10710 { "vpackuswb", { XM
, Vex
, EXx
}, 0 },
10713 /* VEX_W_0F68_P_2 */
10714 { "vpunpckhbw", { XM
, Vex
, EXx
}, 0 },
10717 /* VEX_W_0F69_P_2 */
10718 { "vpunpckhwd", { XM
, Vex
, EXx
}, 0 },
10721 /* VEX_W_0F6A_P_2 */
10722 { "vpunpckhdq", { XM
, Vex
, EXx
}, 0 },
10725 /* VEX_W_0F6B_P_2 */
10726 { "vpackssdw", { XM
, Vex
, EXx
}, 0 },
10729 /* VEX_W_0F6C_P_2 */
10730 { "vpunpcklqdq", { XM
, Vex
, EXx
}, 0 },
10733 /* VEX_W_0F6D_P_2 */
10734 { "vpunpckhqdq", { XM
, Vex
, EXx
}, 0 },
10737 /* VEX_W_0F6F_P_1 */
10738 { "vmovdqu", { XM
, EXx
}, 0 },
10741 /* VEX_W_0F6F_P_2 */
10742 { "vmovdqa", { XM
, EXx
}, 0 },
10745 /* VEX_W_0F70_P_1 */
10746 { "vpshufhw", { XM
, EXx
, Ib
}, 0 },
10749 /* VEX_W_0F70_P_2 */
10750 { "vpshufd", { XM
, EXx
, Ib
}, 0 },
10753 /* VEX_W_0F70_P_3 */
10754 { "vpshuflw", { XM
, EXx
, Ib
}, 0 },
10757 /* VEX_W_0F71_R_2_P_2 */
10758 { "vpsrlw", { Vex
, XS
, Ib
}, 0 },
10761 /* VEX_W_0F71_R_4_P_2 */
10762 { "vpsraw", { Vex
, XS
, Ib
}, 0 },
10765 /* VEX_W_0F71_R_6_P_2 */
10766 { "vpsllw", { Vex
, XS
, Ib
}, 0 },
10769 /* VEX_W_0F72_R_2_P_2 */
10770 { "vpsrld", { Vex
, XS
, Ib
}, 0 },
10773 /* VEX_W_0F72_R_4_P_2 */
10774 { "vpsrad", { Vex
, XS
, Ib
}, 0 },
10777 /* VEX_W_0F72_R_6_P_2 */
10778 { "vpslld", { Vex
, XS
, Ib
}, 0 },
10781 /* VEX_W_0F73_R_2_P_2 */
10782 { "vpsrlq", { Vex
, XS
, Ib
}, 0 },
10785 /* VEX_W_0F73_R_3_P_2 */
10786 { "vpsrldq", { Vex
, XS
, Ib
}, 0 },
10789 /* VEX_W_0F73_R_6_P_2 */
10790 { "vpsllq", { Vex
, XS
, Ib
}, 0 },
10793 /* VEX_W_0F73_R_7_P_2 */
10794 { "vpslldq", { Vex
, XS
, Ib
}, 0 },
10797 /* VEX_W_0F74_P_2 */
10798 { "vpcmpeqb", { XM
, Vex
, EXx
}, 0 },
10801 /* VEX_W_0F75_P_2 */
10802 { "vpcmpeqw", { XM
, Vex
, EXx
}, 0 },
10805 /* VEX_W_0F76_P_2 */
10806 { "vpcmpeqd", { XM
, Vex
, EXx
}, 0 },
10809 /* VEX_W_0F77_P_0 */
10810 { "", { VZERO
}, 0 },
10813 /* VEX_W_0F7C_P_2 */
10814 { "vhaddpd", { XM
, Vex
, EXx
}, 0 },
10817 /* VEX_W_0F7C_P_3 */
10818 { "vhaddps", { XM
, Vex
, EXx
}, 0 },
10821 /* VEX_W_0F7D_P_2 */
10822 { "vhsubpd", { XM
, Vex
, EXx
}, 0 },
10825 /* VEX_W_0F7D_P_3 */
10826 { "vhsubps", { XM
, Vex
, EXx
}, 0 },
10829 /* VEX_W_0F7E_P_1 */
10830 { "vmovq", { XMScalar
, EXqScalar
}, 0 },
10833 /* VEX_W_0F7F_P_1 */
10834 { "vmovdqu", { EXxS
, XM
}, 0 },
10837 /* VEX_W_0F7F_P_2 */
10838 { "vmovdqa", { EXxS
, XM
}, 0 },
10841 /* VEX_W_0F90_P_0_LEN_0 */
10842 { "kmovw", { MaskG
, MaskE
}, 0 },
10843 { "kmovq", { MaskG
, MaskE
}, 0 },
10846 /* VEX_W_0F90_P_2_LEN_0 */
10847 { "kmovb", { MaskG
, MaskBDE
}, 0 },
10848 { "kmovd", { MaskG
, MaskBDE
}, 0 },
10851 /* VEX_W_0F91_P_0_LEN_0 */
10852 { "kmovw", { Ew
, MaskG
}, 0 },
10853 { "kmovq", { Eq
, MaskG
}, 0 },
10856 /* VEX_W_0F91_P_2_LEN_0 */
10857 { "kmovb", { Eb
, MaskG
}, 0 },
10858 { "kmovd", { Ed
, MaskG
}, 0 },
10861 /* VEX_W_0F92_P_0_LEN_0 */
10862 { "kmovw", { MaskG
, Rdq
}, 0 },
10865 /* VEX_W_0F92_P_2_LEN_0 */
10866 { "kmovb", { MaskG
, Rdq
}, 0 },
10869 /* VEX_W_0F92_P_3_LEN_0 */
10870 { "kmovd", { MaskG
, Rdq
}, 0 },
10871 { "kmovq", { MaskG
, Rdq
}, 0 },
10874 /* VEX_W_0F93_P_0_LEN_0 */
10875 { "kmovw", { Gdq
, MaskR
}, 0 },
10878 /* VEX_W_0F93_P_2_LEN_0 */
10879 { "kmovb", { Gdq
, MaskR
}, 0 },
10882 /* VEX_W_0F93_P_3_LEN_0 */
10883 { "kmovd", { Gdq
, MaskR
}, 0 },
10884 { "kmovq", { Gdq
, MaskR
}, 0 },
10887 /* VEX_W_0F98_P_0_LEN_0 */
10888 { "kortestw", { MaskG
, MaskR
}, 0 },
10889 { "kortestq", { MaskG
, MaskR
}, 0 },
10892 /* VEX_W_0F98_P_2_LEN_0 */
10893 { "kortestb", { MaskG
, MaskR
}, 0 },
10894 { "kortestd", { MaskG
, MaskR
}, 0 },
10897 /* VEX_W_0F99_P_0_LEN_0 */
10898 { "ktestw", { MaskG
, MaskR
}, 0 },
10899 { "ktestq", { MaskG
, MaskR
}, 0 },
10902 /* VEX_W_0F99_P_2_LEN_0 */
10903 { "ktestb", { MaskG
, MaskR
}, 0 },
10904 { "ktestd", { MaskG
, MaskR
}, 0 },
10907 /* VEX_W_0FAE_R_2_M_0 */
10908 { "vldmxcsr", { Md
}, 0 },
10911 /* VEX_W_0FAE_R_3_M_0 */
10912 { "vstmxcsr", { Md
}, 0 },
10915 /* VEX_W_0FC2_P_0 */
10916 { "vcmpps", { XM
, Vex
, EXx
, VCMP
}, 0 },
10919 /* VEX_W_0FC2_P_1 */
10920 { "vcmpss", { XMScalar
, VexScalar
, EXdScalar
, VCMP
}, 0 },
10923 /* VEX_W_0FC2_P_2 */
10924 { "vcmppd", { XM
, Vex
, EXx
, VCMP
}, 0 },
10927 /* VEX_W_0FC2_P_3 */
10928 { "vcmpsd", { XMScalar
, VexScalar
, EXqScalar
, VCMP
}, 0 },
10931 /* VEX_W_0FC4_P_2 */
10932 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
}, 0 },
10935 /* VEX_W_0FC5_P_2 */
10936 { "vpextrw", { Gdq
, XS
, Ib
}, 0 },
10939 /* VEX_W_0FD0_P_2 */
10940 { "vaddsubpd", { XM
, Vex
, EXx
}, 0 },
10943 /* VEX_W_0FD0_P_3 */
10944 { "vaddsubps", { XM
, Vex
, EXx
}, 0 },
10947 /* VEX_W_0FD1_P_2 */
10948 { "vpsrlw", { XM
, Vex
, EXxmm
}, 0 },
10951 /* VEX_W_0FD2_P_2 */
10952 { "vpsrld", { XM
, Vex
, EXxmm
}, 0 },
10955 /* VEX_W_0FD3_P_2 */
10956 { "vpsrlq", { XM
, Vex
, EXxmm
}, 0 },
10959 /* VEX_W_0FD4_P_2 */
10960 { "vpaddq", { XM
, Vex
, EXx
}, 0 },
10963 /* VEX_W_0FD5_P_2 */
10964 { "vpmullw", { XM
, Vex
, EXx
}, 0 },
10967 /* VEX_W_0FD6_P_2 */
10968 { "vmovq", { EXqScalarS
, XMScalar
}, 0 },
10971 /* VEX_W_0FD7_P_2_M_1 */
10972 { "vpmovmskb", { Gdq
, XS
}, 0 },
10975 /* VEX_W_0FD8_P_2 */
10976 { "vpsubusb", { XM
, Vex
, EXx
}, 0 },
10979 /* VEX_W_0FD9_P_2 */
10980 { "vpsubusw", { XM
, Vex
, EXx
}, 0 },
10983 /* VEX_W_0FDA_P_2 */
10984 { "vpminub", { XM
, Vex
, EXx
}, 0 },
10987 /* VEX_W_0FDB_P_2 */
10988 { "vpand", { XM
, Vex
, EXx
}, 0 },
10991 /* VEX_W_0FDC_P_2 */
10992 { "vpaddusb", { XM
, Vex
, EXx
}, 0 },
10995 /* VEX_W_0FDD_P_2 */
10996 { "vpaddusw", { XM
, Vex
, EXx
}, 0 },
10999 /* VEX_W_0FDE_P_2 */
11000 { "vpmaxub", { XM
, Vex
, EXx
}, 0 },
11003 /* VEX_W_0FDF_P_2 */
11004 { "vpandn", { XM
, Vex
, EXx
}, 0 },
11007 /* VEX_W_0FE0_P_2 */
11008 { "vpavgb", { XM
, Vex
, EXx
}, 0 },
11011 /* VEX_W_0FE1_P_2 */
11012 { "vpsraw", { XM
, Vex
, EXxmm
}, 0 },
11015 /* VEX_W_0FE2_P_2 */
11016 { "vpsrad", { XM
, Vex
, EXxmm
}, 0 },
11019 /* VEX_W_0FE3_P_2 */
11020 { "vpavgw", { XM
, Vex
, EXx
}, 0 },
11023 /* VEX_W_0FE4_P_2 */
11024 { "vpmulhuw", { XM
, Vex
, EXx
}, 0 },
11027 /* VEX_W_0FE5_P_2 */
11028 { "vpmulhw", { XM
, Vex
, EXx
}, 0 },
11031 /* VEX_W_0FE6_P_1 */
11032 { "vcvtdq2pd", { XM
, EXxmmq
}, 0 },
11035 /* VEX_W_0FE6_P_2 */
11036 { "vcvttpd2dq%XY", { XMM
, EXx
}, 0 },
11039 /* VEX_W_0FE6_P_3 */
11040 { "vcvtpd2dq%XY", { XMM
, EXx
}, 0 },
11043 /* VEX_W_0FE7_P_2_M_0 */
11044 { "vmovntdq", { Mx
, XM
}, 0 },
11047 /* VEX_W_0FE8_P_2 */
11048 { "vpsubsb", { XM
, Vex
, EXx
}, 0 },
11051 /* VEX_W_0FE9_P_2 */
11052 { "vpsubsw", { XM
, Vex
, EXx
}, 0 },
11055 /* VEX_W_0FEA_P_2 */
11056 { "vpminsw", { XM
, Vex
, EXx
}, 0 },
11059 /* VEX_W_0FEB_P_2 */
11060 { "vpor", { XM
, Vex
, EXx
}, 0 },
11063 /* VEX_W_0FEC_P_2 */
11064 { "vpaddsb", { XM
, Vex
, EXx
}, 0 },
11067 /* VEX_W_0FED_P_2 */
11068 { "vpaddsw", { XM
, Vex
, EXx
}, 0 },
11071 /* VEX_W_0FEE_P_2 */
11072 { "vpmaxsw", { XM
, Vex
, EXx
}, 0 },
11075 /* VEX_W_0FEF_P_2 */
11076 { "vpxor", { XM
, Vex
, EXx
}, 0 },
11079 /* VEX_W_0FF0_P_3_M_0 */
11080 { "vlddqu", { XM
, M
}, 0 },
11083 /* VEX_W_0FF1_P_2 */
11084 { "vpsllw", { XM
, Vex
, EXxmm
}, 0 },
11087 /* VEX_W_0FF2_P_2 */
11088 { "vpslld", { XM
, Vex
, EXxmm
}, 0 },
11091 /* VEX_W_0FF3_P_2 */
11092 { "vpsllq", { XM
, Vex
, EXxmm
}, 0 },
11095 /* VEX_W_0FF4_P_2 */
11096 { "vpmuludq", { XM
, Vex
, EXx
}, 0 },
11099 /* VEX_W_0FF5_P_2 */
11100 { "vpmaddwd", { XM
, Vex
, EXx
}, 0 },
11103 /* VEX_W_0FF6_P_2 */
11104 { "vpsadbw", { XM
, Vex
, EXx
}, 0 },
11107 /* VEX_W_0FF7_P_2 */
11108 { "vmaskmovdqu", { XM
, XS
}, 0 },
11111 /* VEX_W_0FF8_P_2 */
11112 { "vpsubb", { XM
, Vex
, EXx
}, 0 },
11115 /* VEX_W_0FF9_P_2 */
11116 { "vpsubw", { XM
, Vex
, EXx
}, 0 },
11119 /* VEX_W_0FFA_P_2 */
11120 { "vpsubd", { XM
, Vex
, EXx
}, 0 },
11123 /* VEX_W_0FFB_P_2 */
11124 { "vpsubq", { XM
, Vex
, EXx
}, 0 },
11127 /* VEX_W_0FFC_P_2 */
11128 { "vpaddb", { XM
, Vex
, EXx
}, 0 },
11131 /* VEX_W_0FFD_P_2 */
11132 { "vpaddw", { XM
, Vex
, EXx
}, 0 },
11135 /* VEX_W_0FFE_P_2 */
11136 { "vpaddd", { XM
, Vex
, EXx
}, 0 },
11139 /* VEX_W_0F3800_P_2 */
11140 { "vpshufb", { XM
, Vex
, EXx
}, 0 },
11143 /* VEX_W_0F3801_P_2 */
11144 { "vphaddw", { XM
, Vex
, EXx
}, 0 },
11147 /* VEX_W_0F3802_P_2 */
11148 { "vphaddd", { XM
, Vex
, EXx
}, 0 },
11151 /* VEX_W_0F3803_P_2 */
11152 { "vphaddsw", { XM
, Vex
, EXx
}, 0 },
11155 /* VEX_W_0F3804_P_2 */
11156 { "vpmaddubsw", { XM
, Vex
, EXx
}, 0 },
11159 /* VEX_W_0F3805_P_2 */
11160 { "vphsubw", { XM
, Vex
, EXx
}, 0 },
11163 /* VEX_W_0F3806_P_2 */
11164 { "vphsubd", { XM
, Vex
, EXx
}, 0 },
11167 /* VEX_W_0F3807_P_2 */
11168 { "vphsubsw", { XM
, Vex
, EXx
}, 0 },
11171 /* VEX_W_0F3808_P_2 */
11172 { "vpsignb", { XM
, Vex
, EXx
}, 0 },
11175 /* VEX_W_0F3809_P_2 */
11176 { "vpsignw", { XM
, Vex
, EXx
}, 0 },
11179 /* VEX_W_0F380A_P_2 */
11180 { "vpsignd", { XM
, Vex
, EXx
}, 0 },
11183 /* VEX_W_0F380B_P_2 */
11184 { "vpmulhrsw", { XM
, Vex
, EXx
}, 0 },
11187 /* VEX_W_0F380C_P_2 */
11188 { "vpermilps", { XM
, Vex
, EXx
}, 0 },
11191 /* VEX_W_0F380D_P_2 */
11192 { "vpermilpd", { XM
, Vex
, EXx
}, 0 },
11195 /* VEX_W_0F380E_P_2 */
11196 { "vtestps", { XM
, EXx
}, 0 },
11199 /* VEX_W_0F380F_P_2 */
11200 { "vtestpd", { XM
, EXx
}, 0 },
11203 /* VEX_W_0F3816_P_2 */
11204 { "vpermps", { XM
, Vex
, EXx
}, 0 },
11207 /* VEX_W_0F3817_P_2 */
11208 { "vptest", { XM
, EXx
}, 0 },
11211 /* VEX_W_0F3818_P_2 */
11212 { "vbroadcastss", { XM
, EXxmm_md
}, 0 },
11215 /* VEX_W_0F3819_P_2 */
11216 { "vbroadcastsd", { XM
, EXxmm_mq
}, 0 },
11219 /* VEX_W_0F381A_P_2_M_0 */
11220 { "vbroadcastf128", { XM
, Mxmm
}, 0 },
11223 /* VEX_W_0F381C_P_2 */
11224 { "vpabsb", { XM
, EXx
}, 0 },
11227 /* VEX_W_0F381D_P_2 */
11228 { "vpabsw", { XM
, EXx
}, 0 },
11231 /* VEX_W_0F381E_P_2 */
11232 { "vpabsd", { XM
, EXx
}, 0 },
11235 /* VEX_W_0F3820_P_2 */
11236 { "vpmovsxbw", { XM
, EXxmmq
}, 0 },
11239 /* VEX_W_0F3821_P_2 */
11240 { "vpmovsxbd", { XM
, EXxmmqd
}, 0 },
11243 /* VEX_W_0F3822_P_2 */
11244 { "vpmovsxbq", { XM
, EXxmmdw
}, 0 },
11247 /* VEX_W_0F3823_P_2 */
11248 { "vpmovsxwd", { XM
, EXxmmq
}, 0 },
11251 /* VEX_W_0F3824_P_2 */
11252 { "vpmovsxwq", { XM
, EXxmmqd
}, 0 },
11255 /* VEX_W_0F3825_P_2 */
11256 { "vpmovsxdq", { XM
, EXxmmq
}, 0 },
11259 /* VEX_W_0F3828_P_2 */
11260 { "vpmuldq", { XM
, Vex
, EXx
}, 0 },
11263 /* VEX_W_0F3829_P_2 */
11264 { "vpcmpeqq", { XM
, Vex
, EXx
}, 0 },
11267 /* VEX_W_0F382A_P_2_M_0 */
11268 { "vmovntdqa", { XM
, Mx
}, 0 },
11271 /* VEX_W_0F382B_P_2 */
11272 { "vpackusdw", { XM
, Vex
, EXx
}, 0 },
11275 /* VEX_W_0F382C_P_2_M_0 */
11276 { "vmaskmovps", { XM
, Vex
, Mx
}, 0 },
11279 /* VEX_W_0F382D_P_2_M_0 */
11280 { "vmaskmovpd", { XM
, Vex
, Mx
}, 0 },
11283 /* VEX_W_0F382E_P_2_M_0 */
11284 { "vmaskmovps", { Mx
, Vex
, XM
}, 0 },
11287 /* VEX_W_0F382F_P_2_M_0 */
11288 { "vmaskmovpd", { Mx
, Vex
, XM
}, 0 },
11291 /* VEX_W_0F3830_P_2 */
11292 { "vpmovzxbw", { XM
, EXxmmq
}, 0 },
11295 /* VEX_W_0F3831_P_2 */
11296 { "vpmovzxbd", { XM
, EXxmmqd
}, 0 },
11299 /* VEX_W_0F3832_P_2 */
11300 { "vpmovzxbq", { XM
, EXxmmdw
}, 0 },
11303 /* VEX_W_0F3833_P_2 */
11304 { "vpmovzxwd", { XM
, EXxmmq
}, 0 },
11307 /* VEX_W_0F3834_P_2 */
11308 { "vpmovzxwq", { XM
, EXxmmqd
}, 0 },
11311 /* VEX_W_0F3835_P_2 */
11312 { "vpmovzxdq", { XM
, EXxmmq
}, 0 },
11315 /* VEX_W_0F3836_P_2 */
11316 { "vpermd", { XM
, Vex
, EXx
}, 0 },
11319 /* VEX_W_0F3837_P_2 */
11320 { "vpcmpgtq", { XM
, Vex
, EXx
}, 0 },
11323 /* VEX_W_0F3838_P_2 */
11324 { "vpminsb", { XM
, Vex
, EXx
}, 0 },
11327 /* VEX_W_0F3839_P_2 */
11328 { "vpminsd", { XM
, Vex
, EXx
}, 0 },
11331 /* VEX_W_0F383A_P_2 */
11332 { "vpminuw", { XM
, Vex
, EXx
}, 0 },
11335 /* VEX_W_0F383B_P_2 */
11336 { "vpminud", { XM
, Vex
, EXx
}, 0 },
11339 /* VEX_W_0F383C_P_2 */
11340 { "vpmaxsb", { XM
, Vex
, EXx
}, 0 },
11343 /* VEX_W_0F383D_P_2 */
11344 { "vpmaxsd", { XM
, Vex
, EXx
}, 0 },
11347 /* VEX_W_0F383E_P_2 */
11348 { "vpmaxuw", { XM
, Vex
, EXx
}, 0 },
11351 /* VEX_W_0F383F_P_2 */
11352 { "vpmaxud", { XM
, Vex
, EXx
}, 0 },
11355 /* VEX_W_0F3840_P_2 */
11356 { "vpmulld", { XM
, Vex
, EXx
}, 0 },
11359 /* VEX_W_0F3841_P_2 */
11360 { "vphminposuw", { XM
, EXx
}, 0 },
11363 /* VEX_W_0F3846_P_2 */
11364 { "vpsravd", { XM
, Vex
, EXx
}, 0 },
11367 /* VEX_W_0F3858_P_2 */
11368 { "vpbroadcastd", { XM
, EXxmm_md
}, 0 },
11371 /* VEX_W_0F3859_P_2 */
11372 { "vpbroadcastq", { XM
, EXxmm_mq
}, 0 },
11375 /* VEX_W_0F385A_P_2_M_0 */
11376 { "vbroadcasti128", { XM
, Mxmm
}, 0 },
11379 /* VEX_W_0F3878_P_2 */
11380 { "vpbroadcastb", { XM
, EXxmm_mb
}, 0 },
11383 /* VEX_W_0F3879_P_2 */
11384 { "vpbroadcastw", { XM
, EXxmm_mw
}, 0 },
11387 /* VEX_W_0F38DB_P_2 */
11388 { "vaesimc", { XM
, EXx
}, 0 },
11391 /* VEX_W_0F38DC_P_2 */
11392 { "vaesenc", { XM
, Vex128
, EXx
}, 0 },
11395 /* VEX_W_0F38DD_P_2 */
11396 { "vaesenclast", { XM
, Vex128
, EXx
}, 0 },
11399 /* VEX_W_0F38DE_P_2 */
11400 { "vaesdec", { XM
, Vex128
, EXx
}, 0 },
11403 /* VEX_W_0F38DF_P_2 */
11404 { "vaesdeclast", { XM
, Vex128
, EXx
}, 0 },
11407 /* VEX_W_0F3A00_P_2 */
11409 { "vpermq", { XM
, EXx
, Ib
}, 0 },
11412 /* VEX_W_0F3A01_P_2 */
11414 { "vpermpd", { XM
, EXx
, Ib
}, 0 },
11417 /* VEX_W_0F3A02_P_2 */
11418 { "vpblendd", { XM
, Vex
, EXx
, Ib
}, 0 },
11421 /* VEX_W_0F3A04_P_2 */
11422 { "vpermilps", { XM
, EXx
, Ib
}, 0 },
11425 /* VEX_W_0F3A05_P_2 */
11426 { "vpermilpd", { XM
, EXx
, Ib
}, 0 },
11429 /* VEX_W_0F3A06_P_2 */
11430 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
}, 0 },
11433 /* VEX_W_0F3A08_P_2 */
11434 { "vroundps", { XM
, EXx
, Ib
}, 0 },
11437 /* VEX_W_0F3A09_P_2 */
11438 { "vroundpd", { XM
, EXx
, Ib
}, 0 },
11441 /* VEX_W_0F3A0A_P_2 */
11442 { "vroundss", { XMScalar
, VexScalar
, EXdScalar
, Ib
}, 0 },
11445 /* VEX_W_0F3A0B_P_2 */
11446 { "vroundsd", { XMScalar
, VexScalar
, EXqScalar
, Ib
}, 0 },
11449 /* VEX_W_0F3A0C_P_2 */
11450 { "vblendps", { XM
, Vex
, EXx
, Ib
}, 0 },
11453 /* VEX_W_0F3A0D_P_2 */
11454 { "vblendpd", { XM
, Vex
, EXx
, Ib
}, 0 },
11457 /* VEX_W_0F3A0E_P_2 */
11458 { "vpblendw", { XM
, Vex
, EXx
, Ib
}, 0 },
11461 /* VEX_W_0F3A0F_P_2 */
11462 { "vpalignr", { XM
, Vex
, EXx
, Ib
}, 0 },
11465 /* VEX_W_0F3A14_P_2 */
11466 { "vpextrb", { Edqb
, XM
, Ib
}, 0 },
11469 /* VEX_W_0F3A15_P_2 */
11470 { "vpextrw", { Edqw
, XM
, Ib
}, 0 },
11473 /* VEX_W_0F3A18_P_2 */
11474 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
}, 0 },
11477 /* VEX_W_0F3A19_P_2 */
11478 { "vextractf128", { EXxmm
, XM
, Ib
}, 0 },
11481 /* VEX_W_0F3A20_P_2 */
11482 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
}, 0 },
11485 /* VEX_W_0F3A21_P_2 */
11486 { "vinsertps", { XM
, Vex128
, EXd
, Ib
}, 0 },
11489 /* VEX_W_0F3A30_P_2_LEN_0 */
11490 { "kshiftrb", { MaskG
, MaskR
, Ib
}, 0 },
11491 { "kshiftrw", { MaskG
, MaskR
, Ib
}, 0 },
11494 /* VEX_W_0F3A31_P_2_LEN_0 */
11495 { "kshiftrd", { MaskG
, MaskR
, Ib
}, 0 },
11496 { "kshiftrq", { MaskG
, MaskR
, Ib
}, 0 },
11499 /* VEX_W_0F3A32_P_2_LEN_0 */
11500 { "kshiftlb", { MaskG
, MaskR
, Ib
}, 0 },
11501 { "kshiftlw", { MaskG
, MaskR
, Ib
}, 0 },
11504 /* VEX_W_0F3A33_P_2_LEN_0 */
11505 { "kshiftld", { MaskG
, MaskR
, Ib
}, 0 },
11506 { "kshiftlq", { MaskG
, MaskR
, Ib
}, 0 },
11509 /* VEX_W_0F3A38_P_2 */
11510 { "vinserti128", { XM
, Vex256
, EXxmm
, Ib
}, 0 },
11513 /* VEX_W_0F3A39_P_2 */
11514 { "vextracti128", { EXxmm
, XM
, Ib
}, 0 },
11517 /* VEX_W_0F3A40_P_2 */
11518 { "vdpps", { XM
, Vex
, EXx
, Ib
}, 0 },
11521 /* VEX_W_0F3A41_P_2 */
11522 { "vdppd", { XM
, Vex128
, EXx
, Ib
}, 0 },
11525 /* VEX_W_0F3A42_P_2 */
11526 { "vmpsadbw", { XM
, Vex
, EXx
, Ib
}, 0 },
11529 /* VEX_W_0F3A44_P_2 */
11530 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
}, 0 },
11533 /* VEX_W_0F3A46_P_2 */
11534 { "vperm2i128", { XM
, Vex256
, EXx
, Ib
}, 0 },
11537 /* VEX_W_0F3A48_P_2 */
11538 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11539 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11542 /* VEX_W_0F3A49_P_2 */
11543 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11544 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11547 /* VEX_W_0F3A4A_P_2 */
11548 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11551 /* VEX_W_0F3A4B_P_2 */
11552 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11555 /* VEX_W_0F3A4C_P_2 */
11556 { "vpblendvb", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11559 /* VEX_W_0F3A60_P_2 */
11560 { "vpcmpestrm", { XM
, EXx
, Ib
}, 0 },
11563 /* VEX_W_0F3A61_P_2 */
11564 { "vpcmpestri", { XM
, EXx
, Ib
}, 0 },
11567 /* VEX_W_0F3A62_P_2 */
11568 { "vpcmpistrm", { XM
, EXx
, Ib
}, 0 },
11571 /* VEX_W_0F3A63_P_2 */
11572 { "vpcmpistri", { XM
, EXx
, Ib
}, 0 },
11575 /* VEX_W_0F3ADF_P_2 */
11576 { "vaeskeygenassist", { XM
, EXx
, Ib
}, 0 },
11578 #define NEED_VEX_W_TABLE
11579 #include "i386-dis-evex.h"
11580 #undef NEED_VEX_W_TABLE
11583 static const struct dis386 mod_table
[][2] = {
11586 { "leaS", { Gv
, M
}, 0 },
11591 { RM_TABLE (RM_C6_REG_7
) },
11596 { RM_TABLE (RM_C7_REG_7
) },
11600 { "Jcall^", { indirEp
}, 0 },
11604 { "Jjmp^", { indirEp
}, 0 },
11607 /* MOD_0F01_REG_0 */
11608 { X86_64_TABLE (X86_64_0F01_REG_0
) },
11609 { RM_TABLE (RM_0F01_REG_0
) },
11612 /* MOD_0F01_REG_1 */
11613 { X86_64_TABLE (X86_64_0F01_REG_1
) },
11614 { RM_TABLE (RM_0F01_REG_1
) },
11617 /* MOD_0F01_REG_2 */
11618 { X86_64_TABLE (X86_64_0F01_REG_2
) },
11619 { RM_TABLE (RM_0F01_REG_2
) },
11622 /* MOD_0F01_REG_3 */
11623 { X86_64_TABLE (X86_64_0F01_REG_3
) },
11624 { RM_TABLE (RM_0F01_REG_3
) },
11627 /* MOD_0F01_REG_7 */
11628 { "invlpg", { Mb
}, 0 },
11629 { RM_TABLE (RM_0F01_REG_7
) },
11632 /* MOD_0F12_PREFIX_0 */
11633 { "movlps", { XM
, EXq
}, PREFIX_OPCODE
},
11634 { "movhlps", { XM
, EXq
}, PREFIX_OPCODE
},
11638 { "movlpX", { EXq
, XM
}, PREFIX_OPCODE
},
11641 /* MOD_0F16_PREFIX_0 */
11642 { "movhps", { XM
, EXq
}, 0 },
11643 { "movlhps", { XM
, EXq
}, 0 },
11647 { "movhpX", { EXq
, XM
}, PREFIX_OPCODE
},
11650 /* MOD_0F18_REG_0 */
11651 { "prefetchnta", { Mb
}, 0 },
11654 /* MOD_0F18_REG_1 */
11655 { "prefetcht0", { Mb
}, 0 },
11658 /* MOD_0F18_REG_2 */
11659 { "prefetcht1", { Mb
}, 0 },
11662 /* MOD_0F18_REG_3 */
11663 { "prefetcht2", { Mb
}, 0 },
11666 /* MOD_0F18_REG_4 */
11667 { "nop/reserved", { Mb
}, 0 },
11670 /* MOD_0F18_REG_5 */
11671 { "nop/reserved", { Mb
}, 0 },
11674 /* MOD_0F18_REG_6 */
11675 { "nop/reserved", { Mb
}, 0 },
11678 /* MOD_0F18_REG_7 */
11679 { "nop/reserved", { Mb
}, 0 },
11682 /* MOD_0F1A_PREFIX_0 */
11683 { "bndldx", { Gbnd
, Ev_bnd
}, 0 },
11684 { "nopQ", { Ev
}, 0 },
11687 /* MOD_0F1B_PREFIX_0 */
11688 { "bndstx", { Ev_bnd
, Gbnd
}, 0 },
11689 { "nopQ", { Ev
}, 0 },
11692 /* MOD_0F1B_PREFIX_1 */
11693 { "bndmk", { Gbnd
, Ev_bnd
}, 0 },
11694 { "nopQ", { Ev
}, 0 },
11699 { "movL", { Rd
, Td
}, 0 },
11704 { "movL", { Td
, Rd
}, 0 },
11707 /* MOD_0F2B_PREFIX_0 */
11708 {"movntps", { Mx
, XM
}, PREFIX_OPCODE
},
11711 /* MOD_0F2B_PREFIX_1 */
11712 {"movntss", { Md
, XM
}, PREFIX_OPCODE
},
11715 /* MOD_0F2B_PREFIX_2 */
11716 {"movntpd", { Mx
, XM
}, PREFIX_OPCODE
},
11719 /* MOD_0F2B_PREFIX_3 */
11720 {"movntsd", { Mq
, XM
}, PREFIX_OPCODE
},
11725 { "movmskpX", { Gdq
, XS
}, PREFIX_OPCODE
},
11728 /* MOD_0F71_REG_2 */
11730 { "psrlw", { MS
, Ib
}, 0 },
11733 /* MOD_0F71_REG_4 */
11735 { "psraw", { MS
, Ib
}, 0 },
11738 /* MOD_0F71_REG_6 */
11740 { "psllw", { MS
, Ib
}, 0 },
11743 /* MOD_0F72_REG_2 */
11745 { "psrld", { MS
, Ib
}, 0 },
11748 /* MOD_0F72_REG_4 */
11750 { "psrad", { MS
, Ib
}, 0 },
11753 /* MOD_0F72_REG_6 */
11755 { "pslld", { MS
, Ib
}, 0 },
11758 /* MOD_0F73_REG_2 */
11760 { "psrlq", { MS
, Ib
}, 0 },
11763 /* MOD_0F73_REG_3 */
11765 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
11768 /* MOD_0F73_REG_6 */
11770 { "psllq", { MS
, Ib
}, 0 },
11773 /* MOD_0F73_REG_7 */
11775 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
11778 /* MOD_0FAE_REG_0 */
11779 { "fxsave", { FXSAVE
}, 0 },
11780 { PREFIX_TABLE (PREFIX_0FAE_REG_0
) },
11783 /* MOD_0FAE_REG_1 */
11784 { "fxrstor", { FXSAVE
}, 0 },
11785 { PREFIX_TABLE (PREFIX_0FAE_REG_1
) },
11788 /* MOD_0FAE_REG_2 */
11789 { "ldmxcsr", { Md
}, 0 },
11790 { PREFIX_TABLE (PREFIX_0FAE_REG_2
) },
11793 /* MOD_0FAE_REG_3 */
11794 { "stmxcsr", { Md
}, 0 },
11795 { PREFIX_TABLE (PREFIX_0FAE_REG_3
) },
11798 /* MOD_0FAE_REG_4 */
11799 { "xsave", { FXSAVE
}, 0 },
11802 /* MOD_0FAE_REG_5 */
11803 { "xrstor", { FXSAVE
}, 0 },
11804 { RM_TABLE (RM_0FAE_REG_5
) },
11807 /* MOD_0FAE_REG_6 */
11808 { PREFIX_TABLE (PREFIX_0FAE_REG_6
) },
11809 { RM_TABLE (RM_0FAE_REG_6
) },
11812 /* MOD_0FAE_REG_7 */
11813 { PREFIX_TABLE (PREFIX_0FAE_REG_7
) },
11814 { RM_TABLE (RM_0FAE_REG_7
) },
11818 { "lssS", { Gv
, Mp
}, 0 },
11822 { "lfsS", { Gv
, Mp
}, 0 },
11826 { "lgsS", { Gv
, Mp
}, 0 },
11829 /* MOD_0FC7_REG_3 */
11830 { "xrstors", { FXSAVE
}, 0 },
11833 /* MOD_0FC7_REG_4 */
11834 { "xsavec", { FXSAVE
}, 0 },
11837 /* MOD_0FC7_REG_5 */
11838 { "xsaves", { FXSAVE
}, 0 },
11841 /* MOD_0FC7_REG_6 */
11842 { PREFIX_TABLE (PREFIX_MOD_0_0FC7_REG_6
) },
11843 { PREFIX_TABLE (PREFIX_MOD_3_0FC7_REG_6
) }
11846 /* MOD_0FC7_REG_7 */
11847 { "vmptrst", { Mq
}, 0 },
11848 { PREFIX_TABLE (PREFIX_MOD_3_0FC7_REG_7
) }
11853 { "pmovmskb", { Gdq
, MS
}, 0 },
11856 /* MOD_0FE7_PREFIX_2 */
11857 { "movntdq", { Mx
, XM
}, 0 },
11860 /* MOD_0FF0_PREFIX_3 */
11861 { "lddqu", { XM
, M
}, 0 },
11864 /* MOD_0F382A_PREFIX_2 */
11865 { "movntdqa", { XM
, Mx
}, 0 },
11869 { "bound{S|}", { Gv
, Ma
}, 0 },
11870 { EVEX_TABLE (EVEX_0F
) },
11874 { "lesS", { Gv
, Mp
}, 0 },
11875 { VEX_C4_TABLE (VEX_0F
) },
11879 { "ldsS", { Gv
, Mp
}, 0 },
11880 { VEX_C5_TABLE (VEX_0F
) },
11883 /* MOD_VEX_0F12_PREFIX_0 */
11884 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_0
) },
11885 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_1
) },
11889 { VEX_LEN_TABLE (VEX_LEN_0F13_M_0
) },
11892 /* MOD_VEX_0F16_PREFIX_0 */
11893 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_0
) },
11894 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_1
) },
11898 { VEX_LEN_TABLE (VEX_LEN_0F17_M_0
) },
11902 { VEX_W_TABLE (VEX_W_0F2B_M_0
) },
11907 { VEX_W_TABLE (VEX_W_0F50_M_0
) },
11910 /* MOD_VEX_0F71_REG_2 */
11912 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_2
) },
11915 /* MOD_VEX_0F71_REG_4 */
11917 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_4
) },
11920 /* MOD_VEX_0F71_REG_6 */
11922 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_6
) },
11925 /* MOD_VEX_0F72_REG_2 */
11927 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_2
) },
11930 /* MOD_VEX_0F72_REG_4 */
11932 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_4
) },
11935 /* MOD_VEX_0F72_REG_6 */
11937 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_6
) },
11940 /* MOD_VEX_0F73_REG_2 */
11942 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_2
) },
11945 /* MOD_VEX_0F73_REG_3 */
11947 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_3
) },
11950 /* MOD_VEX_0F73_REG_6 */
11952 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_6
) },
11955 /* MOD_VEX_0F73_REG_7 */
11957 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_7
) },
11960 /* MOD_VEX_0FAE_REG_2 */
11961 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_2_M_0
) },
11964 /* MOD_VEX_0FAE_REG_3 */
11965 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_3_M_0
) },
11968 /* MOD_VEX_0FD7_PREFIX_2 */
11970 { VEX_W_TABLE (VEX_W_0FD7_P_2_M_1
) },
11973 /* MOD_VEX_0FE7_PREFIX_2 */
11974 { VEX_W_TABLE (VEX_W_0FE7_P_2_M_0
) },
11977 /* MOD_VEX_0FF0_PREFIX_3 */
11978 { VEX_W_TABLE (VEX_W_0FF0_P_3_M_0
) },
11981 /* MOD_VEX_0F381A_PREFIX_2 */
11982 { VEX_LEN_TABLE (VEX_LEN_0F381A_P_2_M_0
) },
11985 /* MOD_VEX_0F382A_PREFIX_2 */
11986 { VEX_W_TABLE (VEX_W_0F382A_P_2_M_0
) },
11989 /* MOD_VEX_0F382C_PREFIX_2 */
11990 { VEX_W_TABLE (VEX_W_0F382C_P_2_M_0
) },
11993 /* MOD_VEX_0F382D_PREFIX_2 */
11994 { VEX_W_TABLE (VEX_W_0F382D_P_2_M_0
) },
11997 /* MOD_VEX_0F382E_PREFIX_2 */
11998 { VEX_W_TABLE (VEX_W_0F382E_P_2_M_0
) },
12001 /* MOD_VEX_0F382F_PREFIX_2 */
12002 { VEX_W_TABLE (VEX_W_0F382F_P_2_M_0
) },
12005 /* MOD_VEX_0F385A_PREFIX_2 */
12006 { VEX_LEN_TABLE (VEX_LEN_0F385A_P_2_M_0
) },
12009 /* MOD_VEX_0F388C_PREFIX_2 */
12010 { "vpmaskmov%LW", { XM
, Vex
, Mx
}, 0 },
12013 /* MOD_VEX_0F388E_PREFIX_2 */
12014 { "vpmaskmov%LW", { Mx
, Vex
, XM
}, 0 },
12016 #define NEED_MOD_TABLE
12017 #include "i386-dis-evex.h"
12018 #undef NEED_MOD_TABLE
12021 static const struct dis386 rm_table
[][8] = {
12024 { "xabort", { Skip_MODRM
, Ib
}, 0 },
12028 { "xbeginT", { Skip_MODRM
, Jv
}, 0 },
12031 /* RM_0F01_REG_0 */
12033 { "vmcall", { Skip_MODRM
}, 0 },
12034 { "vmlaunch", { Skip_MODRM
}, 0 },
12035 { "vmresume", { Skip_MODRM
}, 0 },
12036 { "vmxoff", { Skip_MODRM
}, 0 },
12039 /* RM_0F01_REG_1 */
12040 { "monitor", { { OP_Monitor
, 0 } }, 0 },
12041 { "mwait", { { OP_Mwait
, 0 } }, 0 },
12042 { "clac", { Skip_MODRM
}, 0 },
12043 { "stac", { Skip_MODRM
}, 0 },
12047 { "encls", { Skip_MODRM
}, 0 },
12050 /* RM_0F01_REG_2 */
12051 { "xgetbv", { Skip_MODRM
}, 0 },
12052 { "xsetbv", { Skip_MODRM
}, 0 },
12055 { "vmfunc", { Skip_MODRM
}, 0 },
12056 { "xend", { Skip_MODRM
}, 0 },
12057 { "xtest", { Skip_MODRM
}, 0 },
12058 { "enclu", { Skip_MODRM
}, 0 },
12061 /* RM_0F01_REG_3 */
12062 { "vmrun", { Skip_MODRM
}, 0 },
12063 { "vmmcall", { Skip_MODRM
}, 0 },
12064 { "vmload", { Skip_MODRM
}, 0 },
12065 { "vmsave", { Skip_MODRM
}, 0 },
12066 { "stgi", { Skip_MODRM
}, 0 },
12067 { "clgi", { Skip_MODRM
}, 0 },
12068 { "skinit", { Skip_MODRM
}, 0 },
12069 { "invlpga", { Skip_MODRM
}, 0 },
12072 /* RM_0F01_REG_7 */
12073 { "swapgs", { Skip_MODRM
}, 0 },
12074 { "rdtscp", { Skip_MODRM
}, 0 },
12077 { "clzero", { Skip_MODRM
}, 0 },
12080 /* RM_0FAE_REG_5 */
12081 { "lfence", { Skip_MODRM
}, 0 },
12084 /* RM_0FAE_REG_6 */
12085 { "mfence", { Skip_MODRM
}, 0 },
12088 /* RM_0FAE_REG_7 */
12089 { PREFIX_TABLE (PREFIX_RM_0_0FAE_REG_7
) },
12093 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
12095 /* We use the high bit to indicate different name for the same
12097 #define REP_PREFIX (0xf3 | 0x100)
12098 #define XACQUIRE_PREFIX (0xf2 | 0x200)
12099 #define XRELEASE_PREFIX (0xf3 | 0x400)
12100 #define BND_PREFIX (0xf2 | 0x400)
12105 int newrex
, i
, length
;
12111 last_lock_prefix
= -1;
12112 last_repz_prefix
= -1;
12113 last_repnz_prefix
= -1;
12114 last_data_prefix
= -1;
12115 last_addr_prefix
= -1;
12116 last_rex_prefix
= -1;
12117 last_seg_prefix
= -1;
12119 active_seg_prefix
= 0;
12120 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
12121 all_prefixes
[i
] = 0;
12124 /* The maximum instruction length is 15bytes. */
12125 while (length
< MAX_CODE_LENGTH
- 1)
12127 FETCH_DATA (the_info
, codep
+ 1);
12131 /* REX prefixes family. */
12148 if (address_mode
== mode_64bit
)
12152 last_rex_prefix
= i
;
12155 prefixes
|= PREFIX_REPZ
;
12156 last_repz_prefix
= i
;
12159 prefixes
|= PREFIX_REPNZ
;
12160 last_repnz_prefix
= i
;
12163 prefixes
|= PREFIX_LOCK
;
12164 last_lock_prefix
= i
;
12167 prefixes
|= PREFIX_CS
;
12168 last_seg_prefix
= i
;
12169 active_seg_prefix
= PREFIX_CS
;
12172 prefixes
|= PREFIX_SS
;
12173 last_seg_prefix
= i
;
12174 active_seg_prefix
= PREFIX_SS
;
12177 prefixes
|= PREFIX_DS
;
12178 last_seg_prefix
= i
;
12179 active_seg_prefix
= PREFIX_DS
;
12182 prefixes
|= PREFIX_ES
;
12183 last_seg_prefix
= i
;
12184 active_seg_prefix
= PREFIX_ES
;
12187 prefixes
|= PREFIX_FS
;
12188 last_seg_prefix
= i
;
12189 active_seg_prefix
= PREFIX_FS
;
12192 prefixes
|= PREFIX_GS
;
12193 last_seg_prefix
= i
;
12194 active_seg_prefix
= PREFIX_GS
;
12197 prefixes
|= PREFIX_DATA
;
12198 last_data_prefix
= i
;
12201 prefixes
|= PREFIX_ADDR
;
12202 last_addr_prefix
= i
;
12205 /* fwait is really an instruction. If there are prefixes
12206 before the fwait, they belong to the fwait, *not* to the
12207 following instruction. */
12209 if (prefixes
|| rex
)
12211 prefixes
|= PREFIX_FWAIT
;
12213 /* This ensures that the previous REX prefixes are noticed
12214 as unused prefixes, as in the return case below. */
12218 prefixes
= PREFIX_FWAIT
;
12223 /* Rex is ignored when followed by another prefix. */
12229 if (*codep
!= FWAIT_OPCODE
)
12230 all_prefixes
[i
++] = *codep
;
12238 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
12241 static const char *
12242 prefix_name (int pref
, int sizeflag
)
12244 static const char *rexes
[16] =
12247 "rex.B", /* 0x41 */
12248 "rex.X", /* 0x42 */
12249 "rex.XB", /* 0x43 */
12250 "rex.R", /* 0x44 */
12251 "rex.RB", /* 0x45 */
12252 "rex.RX", /* 0x46 */
12253 "rex.RXB", /* 0x47 */
12254 "rex.W", /* 0x48 */
12255 "rex.WB", /* 0x49 */
12256 "rex.WX", /* 0x4a */
12257 "rex.WXB", /* 0x4b */
12258 "rex.WR", /* 0x4c */
12259 "rex.WRB", /* 0x4d */
12260 "rex.WRX", /* 0x4e */
12261 "rex.WRXB", /* 0x4f */
12266 /* REX prefixes family. */
12283 return rexes
[pref
- 0x40];
12303 return (sizeflag
& DFLAG
) ? "data16" : "data32";
12305 if (address_mode
== mode_64bit
)
12306 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
12308 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
12313 case XACQUIRE_PREFIX
:
12315 case XRELEASE_PREFIX
:
12324 static char op_out
[MAX_OPERANDS
][100];
12325 static int op_ad
, op_index
[MAX_OPERANDS
];
12326 static int two_source_ops
;
12327 static bfd_vma op_address
[MAX_OPERANDS
];
12328 static bfd_vma op_riprel
[MAX_OPERANDS
];
12329 static bfd_vma start_pc
;
12332 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
12333 * (see topic "Redundant prefixes" in the "Differences from 8086"
12334 * section of the "Virtual 8086 Mode" chapter.)
12335 * 'pc' should be the address of this instruction, it will
12336 * be used to print the target address if this is a relative jump or call
12337 * The function returns the length of this instruction in bytes.
12340 static char intel_syntax
;
12341 static char intel_mnemonic
= !SYSV386_COMPAT
;
12342 static char open_char
;
12343 static char close_char
;
12344 static char separator_char
;
12345 static char scale_char
;
12353 static enum x86_64_isa isa64
;
12355 /* Here for backwards compatibility. When gdb stops using
12356 print_insn_i386_att and print_insn_i386_intel these functions can
12357 disappear, and print_insn_i386 be merged into print_insn. */
12359 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
12363 return print_insn (pc
, info
);
12367 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
12371 return print_insn (pc
, info
);
12375 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
12379 return print_insn (pc
, info
);
12383 print_i386_disassembler_options (FILE *stream
)
12385 fprintf (stream
, _("\n\
12386 The following i386/x86-64 specific disassembler options are supported for use\n\
12387 with the -M switch (multiple options should be separated by commas):\n"));
12389 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
12390 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
12391 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
12392 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
12393 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
12394 fprintf (stream
, _(" att-mnemonic\n"
12395 " Display instruction in AT&T mnemonic\n"));
12396 fprintf (stream
, _(" intel-mnemonic\n"
12397 " Display instruction in Intel mnemonic\n"));
12398 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
12399 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
12400 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
12401 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
12402 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
12403 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
12404 fprintf (stream
, _(" amd64 Display instruction in AMD64 ISA\n"));
12405 fprintf (stream
, _(" intel64 Display instruction in Intel64 ISA\n"));
12409 static const struct dis386 bad_opcode
= { "(bad)", { XX
}, 0 };
12411 /* Get a pointer to struct dis386 with a valid name. */
12413 static const struct dis386
*
12414 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
12416 int vindex
, vex_table_index
;
12418 if (dp
->name
!= NULL
)
12421 switch (dp
->op
[0].bytemode
)
12423 case USE_REG_TABLE
:
12424 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
12427 case USE_MOD_TABLE
:
12428 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
12429 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
12433 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
12436 case USE_PREFIX_TABLE
:
12439 /* The prefix in VEX is implicit. */
12440 switch (vex
.prefix
)
12445 case REPE_PREFIX_OPCODE
:
12448 case DATA_PREFIX_OPCODE
:
12451 case REPNE_PREFIX_OPCODE
:
12461 int last_prefix
= -1;
12464 /* We check PREFIX_REPNZ and PREFIX_REPZ before PREFIX_DATA.
12465 When there are multiple PREFIX_REPNZ and PREFIX_REPZ, the
12467 if ((prefixes
& (PREFIX_REPZ
| PREFIX_REPNZ
)) != 0)
12469 if (last_repz_prefix
> last_repnz_prefix
)
12472 prefix
= PREFIX_REPZ
;
12473 last_prefix
= last_repz_prefix
;
12478 prefix
= PREFIX_REPNZ
;
12479 last_prefix
= last_repnz_prefix
;
12482 /* Check if prefix should be ignored. */
12483 if ((((prefix_table
[dp
->op
[1].bytemode
][vindex
].prefix_requirement
12484 & PREFIX_IGNORED
) >> PREFIX_IGNORED_SHIFT
)
12489 if (vindex
== 0 && (prefixes
& PREFIX_DATA
) != 0)
12492 prefix
= PREFIX_DATA
;
12493 last_prefix
= last_data_prefix
;
12498 used_prefixes
|= prefix
;
12499 all_prefixes
[last_prefix
] = 0;
12502 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
12505 case USE_X86_64_TABLE
:
12506 vindex
= address_mode
== mode_64bit
? 1 : 0;
12507 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
12510 case USE_3BYTE_TABLE
:
12511 FETCH_DATA (info
, codep
+ 2);
12513 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
12515 modrm
.mod
= (*codep
>> 6) & 3;
12516 modrm
.reg
= (*codep
>> 3) & 7;
12517 modrm
.rm
= *codep
& 7;
12520 case USE_VEX_LEN_TABLE
:
12524 switch (vex
.length
)
12537 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
12540 case USE_XOP_8F_TABLE
:
12541 FETCH_DATA (info
, codep
+ 3);
12542 /* All bits in the REX prefix are ignored. */
12544 rex
= ~(*codep
>> 5) & 0x7;
12546 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
12547 switch ((*codep
& 0x1f))
12553 vex_table_index
= XOP_08
;
12556 vex_table_index
= XOP_09
;
12559 vex_table_index
= XOP_0A
;
12563 vex
.w
= *codep
& 0x80;
12564 if (vex
.w
&& address_mode
== mode_64bit
)
12567 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12568 if (address_mode
!= mode_64bit
12569 && vex
.register_specifier
> 0x7)
12575 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12576 switch ((*codep
& 0x3))
12582 vex
.prefix
= DATA_PREFIX_OPCODE
;
12585 vex
.prefix
= REPE_PREFIX_OPCODE
;
12588 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12595 dp
= &xop_table
[vex_table_index
][vindex
];
12598 FETCH_DATA (info
, codep
+ 1);
12599 modrm
.mod
= (*codep
>> 6) & 3;
12600 modrm
.reg
= (*codep
>> 3) & 7;
12601 modrm
.rm
= *codep
& 7;
12604 case USE_VEX_C4_TABLE
:
12606 FETCH_DATA (info
, codep
+ 3);
12607 /* All bits in the REX prefix are ignored. */
12609 rex
= ~(*codep
>> 5) & 0x7;
12610 switch ((*codep
& 0x1f))
12616 vex_table_index
= VEX_0F
;
12619 vex_table_index
= VEX_0F38
;
12622 vex_table_index
= VEX_0F3A
;
12626 vex
.w
= *codep
& 0x80;
12627 if (vex
.w
&& address_mode
== mode_64bit
)
12630 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12631 if (address_mode
!= mode_64bit
12632 && vex
.register_specifier
> 0x7)
12638 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12639 switch ((*codep
& 0x3))
12645 vex
.prefix
= DATA_PREFIX_OPCODE
;
12648 vex
.prefix
= REPE_PREFIX_OPCODE
;
12651 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12658 dp
= &vex_table
[vex_table_index
][vindex
];
12660 /* There is no MODRM byte for VEX [82|77]. */
12661 if (vindex
!= 0x77 && vindex
!= 0x82)
12663 FETCH_DATA (info
, codep
+ 1);
12664 modrm
.mod
= (*codep
>> 6) & 3;
12665 modrm
.reg
= (*codep
>> 3) & 7;
12666 modrm
.rm
= *codep
& 7;
12670 case USE_VEX_C5_TABLE
:
12672 FETCH_DATA (info
, codep
+ 2);
12673 /* All bits in the REX prefix are ignored. */
12675 rex
= (*codep
& 0x80) ? 0 : REX_R
;
12677 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12678 if (address_mode
!= mode_64bit
12679 && vex
.register_specifier
> 0x7)
12687 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12688 switch ((*codep
& 0x3))
12694 vex
.prefix
= DATA_PREFIX_OPCODE
;
12697 vex
.prefix
= REPE_PREFIX_OPCODE
;
12700 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12707 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
12709 /* There is no MODRM byte for VEX [82|77]. */
12710 if (vindex
!= 0x77 && vindex
!= 0x82)
12712 FETCH_DATA (info
, codep
+ 1);
12713 modrm
.mod
= (*codep
>> 6) & 3;
12714 modrm
.reg
= (*codep
>> 3) & 7;
12715 modrm
.rm
= *codep
& 7;
12719 case USE_VEX_W_TABLE
:
12723 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
12726 case USE_EVEX_TABLE
:
12727 two_source_ops
= 0;
12730 FETCH_DATA (info
, codep
+ 4);
12731 /* All bits in the REX prefix are ignored. */
12733 /* The first byte after 0x62. */
12734 rex
= ~(*codep
>> 5) & 0x7;
12735 vex
.r
= *codep
& 0x10;
12736 switch ((*codep
& 0xf))
12739 return &bad_opcode
;
12741 vex_table_index
= EVEX_0F
;
12744 vex_table_index
= EVEX_0F38
;
12747 vex_table_index
= EVEX_0F3A
;
12751 /* The second byte after 0x62. */
12753 vex
.w
= *codep
& 0x80;
12754 if (vex
.w
&& address_mode
== mode_64bit
)
12757 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12758 if (address_mode
!= mode_64bit
)
12760 /* In 16/32-bit mode silently ignore following bits. */
12764 vex
.register_specifier
&= 0x7;
12768 if (!(*codep
& 0x4))
12769 return &bad_opcode
;
12771 switch ((*codep
& 0x3))
12777 vex
.prefix
= DATA_PREFIX_OPCODE
;
12780 vex
.prefix
= REPE_PREFIX_OPCODE
;
12783 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12787 /* The third byte after 0x62. */
12790 /* Remember the static rounding bits. */
12791 vex
.ll
= (*codep
>> 5) & 3;
12792 vex
.b
= (*codep
& 0x10) != 0;
12794 vex
.v
= *codep
& 0x8;
12795 vex
.mask_register_specifier
= *codep
& 0x7;
12796 vex
.zeroing
= *codep
& 0x80;
12802 dp
= &evex_table
[vex_table_index
][vindex
];
12804 FETCH_DATA (info
, codep
+ 1);
12805 modrm
.mod
= (*codep
>> 6) & 3;
12806 modrm
.reg
= (*codep
>> 3) & 7;
12807 modrm
.rm
= *codep
& 7;
12809 /* Set vector length. */
12810 if (modrm
.mod
== 3 && vex
.b
)
12826 return &bad_opcode
;
12839 if (dp
->name
!= NULL
)
12842 return get_valid_dis386 (dp
, info
);
12846 get_sib (disassemble_info
*info
, int sizeflag
)
12848 /* If modrm.mod == 3, operand must be register. */
12850 && ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12854 FETCH_DATA (info
, codep
+ 2);
12855 sib
.index
= (codep
[1] >> 3) & 7;
12856 sib
.scale
= (codep
[1] >> 6) & 3;
12857 sib
.base
= codep
[1] & 7;
12862 print_insn (bfd_vma pc
, disassemble_info
*info
)
12864 const struct dis386
*dp
;
12866 char *op_txt
[MAX_OPERANDS
];
12868 int sizeflag
, orig_sizeflag
;
12870 struct dis_private priv
;
12873 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12874 if ((info
->mach
& bfd_mach_i386_i386
) != 0)
12875 address_mode
= mode_32bit
;
12876 else if (info
->mach
== bfd_mach_i386_i8086
)
12878 address_mode
= mode_16bit
;
12879 priv
.orig_sizeflag
= 0;
12882 address_mode
= mode_64bit
;
12884 if (intel_syntax
== (char) -1)
12885 intel_syntax
= (info
->mach
& bfd_mach_i386_intel_syntax
) != 0;
12887 for (p
= info
->disassembler_options
; p
!= NULL
; )
12889 if (CONST_STRNEQ (p
, "amd64"))
12891 else if (CONST_STRNEQ (p
, "intel64"))
12893 else if (CONST_STRNEQ (p
, "x86-64"))
12895 address_mode
= mode_64bit
;
12896 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12898 else if (CONST_STRNEQ (p
, "i386"))
12900 address_mode
= mode_32bit
;
12901 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12903 else if (CONST_STRNEQ (p
, "i8086"))
12905 address_mode
= mode_16bit
;
12906 priv
.orig_sizeflag
= 0;
12908 else if (CONST_STRNEQ (p
, "intel"))
12911 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
12912 intel_mnemonic
= 1;
12914 else if (CONST_STRNEQ (p
, "att"))
12917 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
12918 intel_mnemonic
= 0;
12920 else if (CONST_STRNEQ (p
, "addr"))
12922 if (address_mode
== mode_64bit
)
12924 if (p
[4] == '3' && p
[5] == '2')
12925 priv
.orig_sizeflag
&= ~AFLAG
;
12926 else if (p
[4] == '6' && p
[5] == '4')
12927 priv
.orig_sizeflag
|= AFLAG
;
12931 if (p
[4] == '1' && p
[5] == '6')
12932 priv
.orig_sizeflag
&= ~AFLAG
;
12933 else if (p
[4] == '3' && p
[5] == '2')
12934 priv
.orig_sizeflag
|= AFLAG
;
12937 else if (CONST_STRNEQ (p
, "data"))
12939 if (p
[4] == '1' && p
[5] == '6')
12940 priv
.orig_sizeflag
&= ~DFLAG
;
12941 else if (p
[4] == '3' && p
[5] == '2')
12942 priv
.orig_sizeflag
|= DFLAG
;
12944 else if (CONST_STRNEQ (p
, "suffix"))
12945 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
12947 p
= strchr (p
, ',');
12954 names64
= intel_names64
;
12955 names32
= intel_names32
;
12956 names16
= intel_names16
;
12957 names8
= intel_names8
;
12958 names8rex
= intel_names8rex
;
12959 names_seg
= intel_names_seg
;
12960 names_mm
= intel_names_mm
;
12961 names_bnd
= intel_names_bnd
;
12962 names_xmm
= intel_names_xmm
;
12963 names_ymm
= intel_names_ymm
;
12964 names_zmm
= intel_names_zmm
;
12965 index64
= intel_index64
;
12966 index32
= intel_index32
;
12967 names_mask
= intel_names_mask
;
12968 index16
= intel_index16
;
12971 separator_char
= '+';
12976 names64
= att_names64
;
12977 names32
= att_names32
;
12978 names16
= att_names16
;
12979 names8
= att_names8
;
12980 names8rex
= att_names8rex
;
12981 names_seg
= att_names_seg
;
12982 names_mm
= att_names_mm
;
12983 names_bnd
= att_names_bnd
;
12984 names_xmm
= att_names_xmm
;
12985 names_ymm
= att_names_ymm
;
12986 names_zmm
= att_names_zmm
;
12987 index64
= att_index64
;
12988 index32
= att_index32
;
12989 names_mask
= att_names_mask
;
12990 index16
= att_index16
;
12993 separator_char
= ',';
12997 /* The output looks better if we put 7 bytes on a line, since that
12998 puts most long word instructions on a single line. Use 8 bytes
13000 if ((info
->mach
& bfd_mach_l1om
) != 0)
13001 info
->bytes_per_line
= 8;
13003 info
->bytes_per_line
= 7;
13005 info
->private_data
= &priv
;
13006 priv
.max_fetched
= priv
.the_buffer
;
13007 priv
.insn_start
= pc
;
13010 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13018 start_codep
= priv
.the_buffer
;
13019 codep
= priv
.the_buffer
;
13021 if (OPCODES_SIGSETJMP (priv
.bailout
) != 0)
13025 /* Getting here means we tried for data but didn't get it. That
13026 means we have an incomplete instruction of some sort. Just
13027 print the first byte as a prefix or a .byte pseudo-op. */
13028 if (codep
> priv
.the_buffer
)
13030 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
13032 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
13035 /* Just print the first byte as a .byte instruction. */
13036 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
13037 (unsigned int) priv
.the_buffer
[0]);
13047 sizeflag
= priv
.orig_sizeflag
;
13049 if (!ckprefix () || rex_used
)
13051 /* Too many prefixes or unused REX prefixes. */
13053 i
< (int) ARRAY_SIZE (all_prefixes
) && all_prefixes
[i
];
13055 (*info
->fprintf_func
) (info
->stream
, "%s%s",
13057 prefix_name (all_prefixes
[i
], sizeflag
));
13061 insn_codep
= codep
;
13063 FETCH_DATA (info
, codep
+ 1);
13064 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
13066 if (((prefixes
& PREFIX_FWAIT
)
13067 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
13069 /* Handle prefixes before fwait. */
13070 for (i
= 0; i
< fwait_prefix
&& all_prefixes
[i
];
13072 (*info
->fprintf_func
) (info
->stream
, "%s ",
13073 prefix_name (all_prefixes
[i
], sizeflag
));
13074 (*info
->fprintf_func
) (info
->stream
, "fwait");
13078 if (*codep
== 0x0f)
13080 unsigned char threebyte
;
13081 FETCH_DATA (info
, codep
+ 2);
13082 threebyte
= *++codep
;
13083 dp
= &dis386_twobyte
[threebyte
];
13084 need_modrm
= twobyte_has_modrm
[*codep
];
13089 dp
= &dis386
[*codep
];
13090 need_modrm
= onebyte_has_modrm
[*codep
];
13094 /* Save sizeflag for printing the extra prefixes later before updating
13095 it for mnemonic and operand processing. The prefix names depend
13096 only on the address mode. */
13097 orig_sizeflag
= sizeflag
;
13098 if (prefixes
& PREFIX_ADDR
)
13100 if ((prefixes
& PREFIX_DATA
))
13106 FETCH_DATA (info
, codep
+ 1);
13107 modrm
.mod
= (*codep
>> 6) & 3;
13108 modrm
.reg
= (*codep
>> 3) & 7;
13109 modrm
.rm
= *codep
& 7;
13117 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
13119 get_sib (info
, sizeflag
);
13120 dofloat (sizeflag
);
13124 dp
= get_valid_dis386 (dp
, info
);
13125 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
13127 get_sib (info
, sizeflag
);
13128 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13131 op_ad
= MAX_OPERANDS
- 1 - i
;
13133 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
13134 /* For EVEX instruction after the last operand masking
13135 should be printed. */
13136 if (i
== 0 && vex
.evex
)
13138 /* Don't print {%k0}. */
13139 if (vex
.mask_register_specifier
)
13142 oappend (names_mask
[vex
.mask_register_specifier
]);
13152 /* Check if the REX prefix is used. */
13153 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0 && last_rex_prefix
>= 0)
13154 all_prefixes
[last_rex_prefix
] = 0;
13156 /* Check if the SEG prefix is used. */
13157 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
13158 | PREFIX_FS
| PREFIX_GS
)) != 0
13159 && (used_prefixes
& active_seg_prefix
) != 0)
13160 all_prefixes
[last_seg_prefix
] = 0;
13162 /* Check if the ADDR prefix is used. */
13163 if ((prefixes
& PREFIX_ADDR
) != 0
13164 && (used_prefixes
& PREFIX_ADDR
) != 0)
13165 all_prefixes
[last_addr_prefix
] = 0;
13167 /* Check if the DATA prefix is used. */
13168 if ((prefixes
& PREFIX_DATA
) != 0
13169 && (used_prefixes
& PREFIX_DATA
) != 0)
13170 all_prefixes
[last_data_prefix
] = 0;
13172 /* Print the extra prefixes. */
13174 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
13175 if (all_prefixes
[i
])
13178 name
= prefix_name (all_prefixes
[i
], orig_sizeflag
);
13181 prefix_length
+= strlen (name
) + 1;
13182 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
13185 /* If the mandatory PREFIX_REPZ/PREFIX_REPNZ/PREFIX_DATA prefix is
13186 unused, opcode is invalid. Since the PREFIX_DATA prefix may be
13187 used by putop and MMX/SSE operand and may be overriden by the
13188 PREFIX_REPZ/PREFIX_REPNZ fix, we check the PREFIX_DATA prefix
13190 if (dp
->prefix_requirement
== PREFIX_OPCODE
13191 && dp
!= &bad_opcode
13193 & (PREFIX_REPZ
| PREFIX_REPNZ
)) != 0
13195 & (PREFIX_REPZ
| PREFIX_REPNZ
)) == 0)
13197 & (PREFIX_REPZ
| PREFIX_REPNZ
| PREFIX_DATA
))
13199 && (used_prefixes
& PREFIX_DATA
) == 0))))
13201 (*info
->fprintf_func
) (info
->stream
, "(bad)");
13202 return end_codep
- priv
.the_buffer
;
13205 /* Check maximum code length. */
13206 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
13208 (*info
->fprintf_func
) (info
->stream
, "(bad)");
13209 return MAX_CODE_LENGTH
;
13212 obufp
= mnemonicendp
;
13213 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
13216 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
13218 /* The enter and bound instructions are printed with operands in the same
13219 order as the intel book; everything else is printed in reverse order. */
13220 if (intel_syntax
|| two_source_ops
)
13224 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13225 op_txt
[i
] = op_out
[i
];
13227 if (intel_syntax
&& dp
&& dp
->op
[2].rtn
== OP_Rounding
13228 && dp
->op
[3].rtn
== OP_E
&& dp
->op
[4].rtn
== NULL
)
13230 op_txt
[2] = op_out
[3];
13231 op_txt
[3] = op_out
[2];
13234 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
13236 op_ad
= op_index
[i
];
13237 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
13238 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
13239 riprel
= op_riprel
[i
];
13240 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
13241 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
13246 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13247 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
13251 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13255 (*info
->fprintf_func
) (info
->stream
, ",");
13256 if (op_index
[i
] != -1 && !op_riprel
[i
])
13257 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
13259 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
13263 for (i
= 0; i
< MAX_OPERANDS
; i
++)
13264 if (op_index
[i
] != -1 && op_riprel
[i
])
13266 (*info
->fprintf_func
) (info
->stream
, " # ");
13267 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
13268 + op_address
[op_index
[i
]]), info
);
13271 return codep
- priv
.the_buffer
;
13274 static const char *float_mem
[] = {
13349 static const unsigned char float_mem_mode
[] = {
13424 #define ST { OP_ST, 0 }
13425 #define STi { OP_STi, 0 }
13427 #define FGRPd9_2 NULL, { { NULL, 0 } }, 0
13428 #define FGRPd9_4 NULL, { { NULL, 1 } }, 0
13429 #define FGRPd9_5 NULL, { { NULL, 2 } }, 0
13430 #define FGRPd9_6 NULL, { { NULL, 3 } }, 0
13431 #define FGRPd9_7 NULL, { { NULL, 4 } }, 0
13432 #define FGRPda_5 NULL, { { NULL, 5 } }, 0
13433 #define FGRPdb_4 NULL, { { NULL, 6 } }, 0
13434 #define FGRPde_3 NULL, { { NULL, 7 } }, 0
13435 #define FGRPdf_4 NULL, { { NULL, 8 } }, 0
13437 static const struct dis386 float_reg
[][8] = {
13440 { "fadd", { ST
, STi
}, 0 },
13441 { "fmul", { ST
, STi
}, 0 },
13442 { "fcom", { STi
}, 0 },
13443 { "fcomp", { STi
}, 0 },
13444 { "fsub", { ST
, STi
}, 0 },
13445 { "fsubr", { ST
, STi
}, 0 },
13446 { "fdiv", { ST
, STi
}, 0 },
13447 { "fdivr", { ST
, STi
}, 0 },
13451 { "fld", { STi
}, 0 },
13452 { "fxch", { STi
}, 0 },
13462 { "fcmovb", { ST
, STi
}, 0 },
13463 { "fcmove", { ST
, STi
}, 0 },
13464 { "fcmovbe",{ ST
, STi
}, 0 },
13465 { "fcmovu", { ST
, STi
}, 0 },
13473 { "fcmovnb",{ ST
, STi
}, 0 },
13474 { "fcmovne",{ ST
, STi
}, 0 },
13475 { "fcmovnbe",{ ST
, STi
}, 0 },
13476 { "fcmovnu",{ ST
, STi
}, 0 },
13478 { "fucomi", { ST
, STi
}, 0 },
13479 { "fcomi", { ST
, STi
}, 0 },
13484 { "fadd", { STi
, ST
}, 0 },
13485 { "fmul", { STi
, ST
}, 0 },
13488 { "fsub!M", { STi
, ST
}, 0 },
13489 { "fsubM", { STi
, ST
}, 0 },
13490 { "fdiv!M", { STi
, ST
}, 0 },
13491 { "fdivM", { STi
, ST
}, 0 },
13495 { "ffree", { STi
}, 0 },
13497 { "fst", { STi
}, 0 },
13498 { "fstp", { STi
}, 0 },
13499 { "fucom", { STi
}, 0 },
13500 { "fucomp", { STi
}, 0 },
13506 { "faddp", { STi
, ST
}, 0 },
13507 { "fmulp", { STi
, ST
}, 0 },
13510 { "fsub!Mp", { STi
, ST
}, 0 },
13511 { "fsubMp", { STi
, ST
}, 0 },
13512 { "fdiv!Mp", { STi
, ST
}, 0 },
13513 { "fdivMp", { STi
, ST
}, 0 },
13517 { "ffreep", { STi
}, 0 },
13522 { "fucomip", { ST
, STi
}, 0 },
13523 { "fcomip", { ST
, STi
}, 0 },
13528 static char *fgrps
[][8] = {
13531 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13536 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
13541 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
13546 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
13551 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
13556 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13561 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
13562 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
13567 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13572 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13577 swap_operand (void)
13579 mnemonicendp
[0] = '.';
13580 mnemonicendp
[1] = 's';
13585 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
13586 int sizeflag ATTRIBUTE_UNUSED
)
13588 /* Skip mod/rm byte. */
13594 dofloat (int sizeflag
)
13596 const struct dis386
*dp
;
13597 unsigned char floatop
;
13599 floatop
= codep
[-1];
13601 if (modrm
.mod
!= 3)
13603 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
13605 putop (float_mem
[fp_indx
], sizeflag
);
13608 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
13611 /* Skip mod/rm byte. */
13615 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
13616 if (dp
->name
== NULL
)
13618 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
13620 /* Instruction fnstsw is only one with strange arg. */
13621 if (floatop
== 0xdf && codep
[-1] == 0xe0)
13622 strcpy (op_out
[0], names16
[0]);
13626 putop (dp
->name
, sizeflag
);
13631 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
13636 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
13640 /* Like oappend (below), but S is a string starting with '%'.
13641 In Intel syntax, the '%' is elided. */
13643 oappend_maybe_intel (const char *s
)
13645 oappend (s
+ intel_syntax
);
13649 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13651 oappend_maybe_intel ("%st");
13655 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13657 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
13658 oappend_maybe_intel (scratchbuf
);
13661 /* Capital letters in template are macros. */
13663 putop (const char *in_template
, int sizeflag
)
13668 unsigned int l
= 0, len
= 1;
13671 #define SAVE_LAST(c) \
13672 if (l < len && l < sizeof (last)) \
13677 for (p
= in_template
; *p
; p
++)
13694 while (*++p
!= '|')
13695 if (*p
== '}' || *p
== '\0')
13698 /* Fall through. */
13703 while (*++p
!= '}')
13714 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13718 if (l
== 0 && len
== 1)
13723 if (sizeflag
& SUFFIX_ALWAYS
)
13736 if (address_mode
== mode_64bit
13737 && !(prefixes
& PREFIX_ADDR
))
13748 if (intel_syntax
&& !alt
)
13750 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
13752 if (sizeflag
& DFLAG
)
13753 *obufp
++ = intel_syntax
? 'd' : 'l';
13755 *obufp
++ = intel_syntax
? 'w' : 's';
13756 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13760 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
13763 if (modrm
.mod
== 3)
13769 if (sizeflag
& DFLAG
)
13770 *obufp
++ = intel_syntax
? 'd' : 'l';
13773 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13779 case 'E': /* For jcxz/jecxz */
13780 if (address_mode
== mode_64bit
)
13782 if (sizeflag
& AFLAG
)
13788 if (sizeflag
& AFLAG
)
13790 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13795 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
13797 if (sizeflag
& AFLAG
)
13798 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
13800 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
13801 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13805 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
13807 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13811 if (!(rex
& REX_W
))
13812 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13817 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
13818 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
13820 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
13823 if (prefixes
& PREFIX_DS
)
13842 if (l
!= 0 || len
!= 1)
13844 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
13849 if (!need_vex
|| !vex
.evex
)
13852 || ((modrm
.mod
== 3 || vex
.b
) && !(sizeflag
& SUFFIX_ALWAYS
)))
13854 switch (vex
.length
)
13872 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
13877 /* Fall through. */
13880 if (l
!= 0 || len
!= 1)
13888 if (sizeflag
& SUFFIX_ALWAYS
)
13892 if (intel_mnemonic
!= cond
)
13896 if ((prefixes
& PREFIX_FWAIT
) == 0)
13899 used_prefixes
|= PREFIX_FWAIT
;
13905 else if (intel_syntax
&& (sizeflag
& DFLAG
))
13909 if (!(rex
& REX_W
))
13910 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13914 && address_mode
== mode_64bit
13915 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
13920 /* Fall through. */
13923 if (l
== 0 && len
== 1)
13928 if ((rex
& REX_W
) == 0
13929 && (prefixes
& PREFIX_DATA
))
13931 if ((sizeflag
& DFLAG
) == 0)
13933 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13937 if ((prefixes
& PREFIX_DATA
)
13939 || (sizeflag
& SUFFIX_ALWAYS
))
13946 if (sizeflag
& DFLAG
)
13950 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13956 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
13962 if ((prefixes
& PREFIX_DATA
)
13964 || (sizeflag
& SUFFIX_ALWAYS
))
13971 if (sizeflag
& DFLAG
)
13972 *obufp
++ = intel_syntax
? 'd' : 'l';
13975 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13983 if (address_mode
== mode_64bit
13984 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
13986 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13990 /* Fall through. */
13993 if (l
== 0 && len
== 1)
13996 if (intel_syntax
&& !alt
)
13999 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
14005 if (sizeflag
& DFLAG
)
14006 *obufp
++ = intel_syntax
? 'd' : 'l';
14009 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14015 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
14021 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
14036 else if (sizeflag
& DFLAG
)
14045 if (intel_syntax
&& !p
[1]
14046 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
14048 if (!(rex
& REX_W
))
14049 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14052 if (l
== 0 && len
== 1)
14056 if (address_mode
== mode_64bit
14057 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
14059 if (sizeflag
& SUFFIX_ALWAYS
)
14081 /* Fall through. */
14084 if (l
== 0 && len
== 1)
14089 if (sizeflag
& SUFFIX_ALWAYS
)
14095 if (sizeflag
& DFLAG
)
14099 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14113 if (address_mode
== mode_64bit
14114 && !(prefixes
& PREFIX_ADDR
))
14125 if (l
!= 0 || len
!= 1)
14130 if (need_vex
&& vex
.prefix
)
14132 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
14139 if (prefixes
& PREFIX_DATA
)
14143 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14147 if (l
== 0 && len
== 1)
14149 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
14160 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
14168 || ((modrm
.mod
== 3 || vex
.b
) && !(sizeflag
& SUFFIX_ALWAYS
)))
14170 switch (vex
.length
)
14186 if (l
== 0 && len
== 1)
14188 /* operand size flag for cwtl, cbtw */
14197 else if (sizeflag
& DFLAG
)
14201 if (!(rex
& REX_W
))
14202 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14209 && last
[0] != 'L'))
14216 if (last
[0] == 'X')
14217 *obufp
++ = vex
.w
? 'd': 's';
14219 *obufp
++ = vex
.w
? 'q': 'd';
14225 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
14227 if (sizeflag
& DFLAG
)
14231 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14237 if (address_mode
== mode_64bit
14238 && (isa64
== intel64
14239 || ((sizeflag
& DFLAG
) || (rex
& REX_W
))))
14241 else if ((prefixes
& PREFIX_DATA
))
14243 if (!(sizeflag
& DFLAG
))
14245 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14252 mnemonicendp
= obufp
;
14257 oappend (const char *s
)
14259 obufp
= stpcpy (obufp
, s
);
14265 /* Only print the active segment register. */
14266 if (!active_seg_prefix
)
14269 used_prefixes
|= active_seg_prefix
;
14270 switch (active_seg_prefix
)
14273 oappend_maybe_intel ("%cs:");
14276 oappend_maybe_intel ("%ds:");
14279 oappend_maybe_intel ("%ss:");
14282 oappend_maybe_intel ("%es:");
14285 oappend_maybe_intel ("%fs:");
14288 oappend_maybe_intel ("%gs:");
14296 OP_indirE (int bytemode
, int sizeflag
)
14300 OP_E (bytemode
, sizeflag
);
14304 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
14306 if (address_mode
== mode_64bit
)
14314 sprintf_vma (tmp
, disp
);
14315 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
14316 strcpy (buf
+ 2, tmp
+ i
);
14320 bfd_signed_vma v
= disp
;
14327 /* Check for possible overflow on 0x8000000000000000. */
14330 strcpy (buf
, "9223372036854775808");
14344 tmp
[28 - i
] = (v
% 10) + '0';
14348 strcpy (buf
, tmp
+ 29 - i
);
14354 sprintf (buf
, "0x%x", (unsigned int) disp
);
14356 sprintf (buf
, "%d", (int) disp
);
14360 /* Put DISP in BUF as signed hex number. */
14363 print_displacement (char *buf
, bfd_vma disp
)
14365 bfd_signed_vma val
= disp
;
14374 /* Check for possible overflow. */
14377 switch (address_mode
)
14380 strcpy (buf
+ j
, "0x8000000000000000");
14383 strcpy (buf
+ j
, "0x80000000");
14386 strcpy (buf
+ j
, "0x8000");
14396 sprintf_vma (tmp
, (bfd_vma
) val
);
14397 for (i
= 0; tmp
[i
] == '0'; i
++)
14399 if (tmp
[i
] == '\0')
14401 strcpy (buf
+ j
, tmp
+ i
);
14405 intel_operand_size (int bytemode
, int sizeflag
)
14409 && (bytemode
== x_mode
14410 || bytemode
== evex_half_bcst_xmmq_mode
))
14413 oappend ("QWORD PTR ");
14415 oappend ("DWORD PTR ");
14424 oappend ("BYTE PTR ");
14429 case dqw_swap_mode
:
14430 oappend ("WORD PTR ");
14433 if (address_mode
== mode_64bit
&& ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
14435 oappend ("QWORD PTR ");
14444 oappend ("QWORD PTR ");
14447 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
14448 oappend ("DWORD PTR ");
14450 oappend ("WORD PTR ");
14451 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14455 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
14457 oappend ("WORD PTR ");
14458 if (!(rex
& REX_W
))
14459 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14462 if (sizeflag
& DFLAG
)
14463 oappend ("QWORD PTR ");
14465 oappend ("DWORD PTR ");
14466 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14469 case d_scalar_mode
:
14470 case d_scalar_swap_mode
:
14473 oappend ("DWORD PTR ");
14476 case q_scalar_mode
:
14477 case q_scalar_swap_mode
:
14479 oappend ("QWORD PTR ");
14482 if (address_mode
== mode_64bit
)
14483 oappend ("QWORD PTR ");
14485 oappend ("DWORD PTR ");
14488 if (sizeflag
& DFLAG
)
14489 oappend ("FWORD PTR ");
14491 oappend ("DWORD PTR ");
14492 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14495 oappend ("TBYTE PTR ");
14499 case evex_x_gscat_mode
:
14500 case evex_x_nobcst_mode
:
14503 switch (vex
.length
)
14506 oappend ("XMMWORD PTR ");
14509 oappend ("YMMWORD PTR ");
14512 oappend ("ZMMWORD PTR ");
14519 oappend ("XMMWORD PTR ");
14522 oappend ("XMMWORD PTR ");
14525 oappend ("YMMWORD PTR ");
14528 case evex_half_bcst_xmmq_mode
:
14532 switch (vex
.length
)
14535 oappend ("QWORD PTR ");
14538 oappend ("XMMWORD PTR ");
14541 oappend ("YMMWORD PTR ");
14551 switch (vex
.length
)
14556 oappend ("BYTE PTR ");
14566 switch (vex
.length
)
14571 oappend ("WORD PTR ");
14581 switch (vex
.length
)
14586 oappend ("DWORD PTR ");
14596 switch (vex
.length
)
14601 oappend ("QWORD PTR ");
14611 switch (vex
.length
)
14614 oappend ("WORD PTR ");
14617 oappend ("DWORD PTR ");
14620 oappend ("QWORD PTR ");
14630 switch (vex
.length
)
14633 oappend ("DWORD PTR ");
14636 oappend ("QWORD PTR ");
14639 oappend ("XMMWORD PTR ");
14649 switch (vex
.length
)
14652 oappend ("QWORD PTR ");
14655 oappend ("YMMWORD PTR ");
14658 oappend ("ZMMWORD PTR ");
14668 switch (vex
.length
)
14672 oappend ("XMMWORD PTR ");
14679 oappend ("OWORD PTR ");
14682 case vex_w_dq_mode
:
14683 case vex_scalar_w_dq_mode
:
14688 oappend ("QWORD PTR ");
14690 oappend ("DWORD PTR ");
14692 case vex_vsib_d_w_dq_mode
:
14693 case vex_vsib_q_w_dq_mode
:
14700 oappend ("QWORD PTR ");
14702 oappend ("DWORD PTR ");
14706 switch (vex
.length
)
14709 oappend ("XMMWORD PTR ");
14712 oappend ("YMMWORD PTR ");
14715 oappend ("ZMMWORD PTR ");
14722 case vex_vsib_q_w_d_mode
:
14723 case vex_vsib_d_w_d_mode
:
14724 if (!need_vex
|| !vex
.evex
)
14727 switch (vex
.length
)
14730 oappend ("QWORD PTR ");
14733 oappend ("XMMWORD PTR ");
14736 oappend ("YMMWORD PTR ");
14744 if (!need_vex
|| vex
.length
!= 128)
14747 oappend ("DWORD PTR ");
14749 oappend ("BYTE PTR ");
14755 oappend ("QWORD PTR ");
14757 oappend ("WORD PTR ");
14766 OP_E_register (int bytemode
, int sizeflag
)
14768 int reg
= modrm
.rm
;
14769 const char **names
;
14775 if ((sizeflag
& SUFFIX_ALWAYS
)
14776 && (bytemode
== b_swap_mode
14777 || bytemode
== v_swap_mode
14778 || bytemode
== dqw_swap_mode
))
14804 names
= address_mode
== mode_64bit
? names64
: names32
;
14810 if (address_mode
== mode_64bit
&& ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
14823 case dqw_swap_mode
:
14829 if ((sizeflag
& DFLAG
)
14830 || (bytemode
!= v_mode
14831 && bytemode
!= v_swap_mode
))
14835 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14840 names
= names_mask
;
14845 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14848 oappend (names
[reg
]);
14852 OP_E_memory (int bytemode
, int sizeflag
)
14855 int add
= (rex
& REX_B
) ? 8 : 0;
14861 /* In EVEX, if operand doesn't allow broadcast, vex.b should be 0. */
14863 && bytemode
!= x_mode
14864 && bytemode
!= xmmq_mode
14865 && bytemode
!= evex_half_bcst_xmmq_mode
)
14874 case dqw_swap_mode
:
14881 case vex_vsib_d_w_dq_mode
:
14882 case vex_vsib_d_w_d_mode
:
14883 case vex_vsib_q_w_dq_mode
:
14884 case vex_vsib_q_w_d_mode
:
14885 case evex_x_gscat_mode
:
14887 shift
= vex
.w
? 3 : 2;
14890 case evex_half_bcst_xmmq_mode
:
14894 shift
= vex
.w
? 3 : 2;
14897 /* Fall through if vex.b == 0. */
14901 case evex_x_nobcst_mode
:
14903 switch (vex
.length
)
14926 case q_scalar_mode
:
14928 case q_scalar_swap_mode
:
14934 case d_scalar_mode
:
14936 case d_scalar_swap_mode
:
14948 /* Make necessary corrections to shift for modes that need it.
14949 For these modes we currently have shift 4, 5 or 6 depending on
14950 vex.length (it corresponds to xmmword, ymmword or zmmword
14951 operand). We might want to make it 3, 4 or 5 (e.g. for
14952 xmmq_mode). In case of broadcast enabled the corrections
14953 aren't needed, as element size is always 32 or 64 bits. */
14955 && (bytemode
== xmmq_mode
14956 || bytemode
== evex_half_bcst_xmmq_mode
))
14958 else if (bytemode
== xmmqd_mode
)
14960 else if (bytemode
== xmmdw_mode
)
14962 else if (bytemode
== ymmq_mode
&& vex
.length
== 128)
14970 intel_operand_size (bytemode
, sizeflag
);
14973 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14975 /* 32/64 bit address mode */
14984 int addr32flag
= !((sizeflag
& AFLAG
)
14985 || bytemode
== v_bnd_mode
14986 || bytemode
== bnd_mode
);
14987 const char **indexes64
= names64
;
14988 const char **indexes32
= names32
;
14998 vindex
= sib
.index
;
15004 case vex_vsib_d_w_dq_mode
:
15005 case vex_vsib_d_w_d_mode
:
15006 case vex_vsib_q_w_dq_mode
:
15007 case vex_vsib_q_w_d_mode
:
15017 switch (vex
.length
)
15020 indexes64
= indexes32
= names_xmm
;
15024 || bytemode
== vex_vsib_q_w_dq_mode
15025 || bytemode
== vex_vsib_q_w_d_mode
)
15026 indexes64
= indexes32
= names_ymm
;
15028 indexes64
= indexes32
= names_xmm
;
15032 || bytemode
== vex_vsib_q_w_dq_mode
15033 || bytemode
== vex_vsib_q_w_d_mode
)
15034 indexes64
= indexes32
= names_zmm
;
15036 indexes64
= indexes32
= names_ymm
;
15043 haveindex
= vindex
!= 4;
15050 rbase
= base
+ add
;
15058 if (address_mode
== mode_64bit
&& !havesib
)
15064 FETCH_DATA (the_info
, codep
+ 1);
15066 if ((disp
& 0x80) != 0)
15068 if (vex
.evex
&& shift
> 0)
15076 /* In 32bit mode, we need index register to tell [offset] from
15077 [eiz*1 + offset]. */
15078 needindex
= (havesib
15081 && address_mode
== mode_32bit
);
15082 havedisp
= (havebase
15084 || (havesib
&& (haveindex
|| scale
!= 0)));
15087 if (modrm
.mod
!= 0 || base
== 5)
15089 if (havedisp
|| riprel
)
15090 print_displacement (scratchbuf
, disp
);
15092 print_operand_value (scratchbuf
, 1, disp
);
15093 oappend (scratchbuf
);
15097 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
15101 if ((havebase
|| haveindex
|| riprel
)
15102 && (bytemode
!= v_bnd_mode
)
15103 && (bytemode
!= bnd_mode
))
15104 used_prefixes
|= PREFIX_ADDR
;
15106 if (havedisp
|| (intel_syntax
&& riprel
))
15108 *obufp
++ = open_char
;
15109 if (intel_syntax
&& riprel
)
15112 oappend (sizeflag
& AFLAG
? "rip" : "eip");
15116 oappend (address_mode
== mode_64bit
&& !addr32flag
15117 ? names64
[rbase
] : names32
[rbase
]);
15120 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
15121 print index to tell base + index from base. */
15125 || (havebase
&& base
!= ESP_REG_NUM
))
15127 if (!intel_syntax
|| havebase
)
15129 *obufp
++ = separator_char
;
15133 oappend (address_mode
== mode_64bit
&& !addr32flag
15134 ? indexes64
[vindex
] : indexes32
[vindex
]);
15136 oappend (address_mode
== mode_64bit
&& !addr32flag
15137 ? index64
: index32
);
15139 *obufp
++ = scale_char
;
15141 sprintf (scratchbuf
, "%d", 1 << scale
);
15142 oappend (scratchbuf
);
15146 && (disp
|| modrm
.mod
!= 0 || base
== 5))
15148 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
15153 else if (modrm
.mod
!= 1 && disp
!= -disp
)
15157 disp
= - (bfd_signed_vma
) disp
;
15161 print_displacement (scratchbuf
, disp
);
15163 print_operand_value (scratchbuf
, 1, disp
);
15164 oappend (scratchbuf
);
15167 *obufp
++ = close_char
;
15170 else if (intel_syntax
)
15172 if (modrm
.mod
!= 0 || base
== 5)
15174 if (!active_seg_prefix
)
15176 oappend (names_seg
[ds_reg
- es_reg
]);
15179 print_operand_value (scratchbuf
, 1, disp
);
15180 oappend (scratchbuf
);
15186 /* 16 bit address mode */
15187 used_prefixes
|= prefixes
& PREFIX_ADDR
;
15194 if ((disp
& 0x8000) != 0)
15199 FETCH_DATA (the_info
, codep
+ 1);
15201 if ((disp
& 0x80) != 0)
15206 if ((disp
& 0x8000) != 0)
15212 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
15214 print_displacement (scratchbuf
, disp
);
15215 oappend (scratchbuf
);
15218 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
15220 *obufp
++ = open_char
;
15222 oappend (index16
[modrm
.rm
]);
15224 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
15226 if ((bfd_signed_vma
) disp
>= 0)
15231 else if (modrm
.mod
!= 1)
15235 disp
= - (bfd_signed_vma
) disp
;
15238 print_displacement (scratchbuf
, disp
);
15239 oappend (scratchbuf
);
15242 *obufp
++ = close_char
;
15245 else if (intel_syntax
)
15247 if (!active_seg_prefix
)
15249 oappend (names_seg
[ds_reg
- es_reg
]);
15252 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
15253 oappend (scratchbuf
);
15256 if (vex
.evex
&& vex
.b
15257 && (bytemode
== x_mode
15258 || bytemode
== xmmq_mode
15259 || bytemode
== evex_half_bcst_xmmq_mode
))
15262 || bytemode
== xmmq_mode
15263 || bytemode
== evex_half_bcst_xmmq_mode
)
15265 switch (vex
.length
)
15268 oappend ("{1to2}");
15271 oappend ("{1to4}");
15274 oappend ("{1to8}");
15282 switch (vex
.length
)
15285 oappend ("{1to4}");
15288 oappend ("{1to8}");
15291 oappend ("{1to16}");
15301 OP_E (int bytemode
, int sizeflag
)
15303 /* Skip mod/rm byte. */
15307 if (modrm
.mod
== 3)
15308 OP_E_register (bytemode
, sizeflag
);
15310 OP_E_memory (bytemode
, sizeflag
);
15314 OP_G (int bytemode
, int sizeflag
)
15325 oappend (names8rex
[modrm
.reg
+ add
]);
15327 oappend (names8
[modrm
.reg
+ add
]);
15330 oappend (names16
[modrm
.reg
+ add
]);
15335 oappend (names32
[modrm
.reg
+ add
]);
15338 oappend (names64
[modrm
.reg
+ add
]);
15341 oappend (names_bnd
[modrm
.reg
]);
15348 case dqw_swap_mode
:
15351 oappend (names64
[modrm
.reg
+ add
]);
15354 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
15355 oappend (names32
[modrm
.reg
+ add
]);
15357 oappend (names16
[modrm
.reg
+ add
]);
15358 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15362 if (address_mode
== mode_64bit
)
15363 oappend (names64
[modrm
.reg
+ add
]);
15365 oappend (names32
[modrm
.reg
+ add
]);
15369 oappend (names_mask
[modrm
.reg
+ add
]);
15372 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15385 FETCH_DATA (the_info
, codep
+ 8);
15386 a
= *codep
++ & 0xff;
15387 a
|= (*codep
++ & 0xff) << 8;
15388 a
|= (*codep
++ & 0xff) << 16;
15389 a
|= (*codep
++ & 0xff) << 24;
15390 b
= *codep
++ & 0xff;
15391 b
|= (*codep
++ & 0xff) << 8;
15392 b
|= (*codep
++ & 0xff) << 16;
15393 b
|= (*codep
++ & 0xff) << 24;
15394 x
= a
+ ((bfd_vma
) b
<< 32);
15402 static bfd_signed_vma
15405 bfd_signed_vma x
= 0;
15407 FETCH_DATA (the_info
, codep
+ 4);
15408 x
= *codep
++ & (bfd_signed_vma
) 0xff;
15409 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
15410 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
15411 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
15415 static bfd_signed_vma
15418 bfd_signed_vma x
= 0;
15420 FETCH_DATA (the_info
, codep
+ 4);
15421 x
= *codep
++ & (bfd_signed_vma
) 0xff;
15422 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
15423 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
15424 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
15426 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
15436 FETCH_DATA (the_info
, codep
+ 2);
15437 x
= *codep
++ & 0xff;
15438 x
|= (*codep
++ & 0xff) << 8;
15443 set_op (bfd_vma op
, int riprel
)
15445 op_index
[op_ad
] = op_ad
;
15446 if (address_mode
== mode_64bit
)
15448 op_address
[op_ad
] = op
;
15449 op_riprel
[op_ad
] = riprel
;
15453 /* Mask to get a 32-bit address. */
15454 op_address
[op_ad
] = op
& 0xffffffff;
15455 op_riprel
[op_ad
] = riprel
& 0xffffffff;
15460 OP_REG (int code
, int sizeflag
)
15467 case es_reg
: case ss_reg
: case cs_reg
:
15468 case ds_reg
: case fs_reg
: case gs_reg
:
15469 oappend (names_seg
[code
- es_reg
]);
15481 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
15482 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
15483 s
= names16
[code
- ax_reg
+ add
];
15485 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
15486 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
15489 s
= names8rex
[code
- al_reg
+ add
];
15491 s
= names8
[code
- al_reg
];
15493 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
15494 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
15495 if (address_mode
== mode_64bit
15496 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
15498 s
= names64
[code
- rAX_reg
+ add
];
15501 code
+= eAX_reg
- rAX_reg
;
15502 /* Fall through. */
15503 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
15504 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
15507 s
= names64
[code
- eAX_reg
+ add
];
15510 if (sizeflag
& DFLAG
)
15511 s
= names32
[code
- eAX_reg
+ add
];
15513 s
= names16
[code
- eAX_reg
+ add
];
15514 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15518 s
= INTERNAL_DISASSEMBLER_ERROR
;
15525 OP_IMREG (int code
, int sizeflag
)
15537 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
15538 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
15539 s
= names16
[code
- ax_reg
];
15541 case es_reg
: case ss_reg
: case cs_reg
:
15542 case ds_reg
: case fs_reg
: case gs_reg
:
15543 s
= names_seg
[code
- es_reg
];
15545 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
15546 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
15549 s
= names8rex
[code
- al_reg
];
15551 s
= names8
[code
- al_reg
];
15553 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
15554 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
15557 s
= names64
[code
- eAX_reg
];
15560 if (sizeflag
& DFLAG
)
15561 s
= names32
[code
- eAX_reg
];
15563 s
= names16
[code
- eAX_reg
];
15564 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15567 case z_mode_ax_reg
:
15568 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
15572 if (!(rex
& REX_W
))
15573 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15576 s
= INTERNAL_DISASSEMBLER_ERROR
;
15583 OP_I (int bytemode
, int sizeflag
)
15586 bfd_signed_vma mask
= -1;
15591 FETCH_DATA (the_info
, codep
+ 1);
15596 if (address_mode
== mode_64bit
)
15601 /* Fall through. */
15608 if (sizeflag
& DFLAG
)
15618 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15630 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15635 scratchbuf
[0] = '$';
15636 print_operand_value (scratchbuf
+ 1, 1, op
);
15637 oappend_maybe_intel (scratchbuf
);
15638 scratchbuf
[0] = '\0';
15642 OP_I64 (int bytemode
, int sizeflag
)
15645 bfd_signed_vma mask
= -1;
15647 if (address_mode
!= mode_64bit
)
15649 OP_I (bytemode
, sizeflag
);
15656 FETCH_DATA (the_info
, codep
+ 1);
15666 if (sizeflag
& DFLAG
)
15676 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15684 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15689 scratchbuf
[0] = '$';
15690 print_operand_value (scratchbuf
+ 1, 1, op
);
15691 oappend_maybe_intel (scratchbuf
);
15692 scratchbuf
[0] = '\0';
15696 OP_sI (int bytemode
, int sizeflag
)
15704 FETCH_DATA (the_info
, codep
+ 1);
15706 if ((op
& 0x80) != 0)
15708 if (bytemode
== b_T_mode
)
15710 if (address_mode
!= mode_64bit
15711 || !((sizeflag
& DFLAG
) || (rex
& REX_W
)))
15713 /* The operand-size prefix is overridden by a REX prefix. */
15714 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
15722 if (!(rex
& REX_W
))
15724 if (sizeflag
& DFLAG
)
15732 /* The operand-size prefix is overridden by a REX prefix. */
15733 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
15739 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15743 scratchbuf
[0] = '$';
15744 print_operand_value (scratchbuf
+ 1, 1, op
);
15745 oappend_maybe_intel (scratchbuf
);
15749 OP_J (int bytemode
, int sizeflag
)
15753 bfd_vma segment
= 0;
15758 FETCH_DATA (the_info
, codep
+ 1);
15760 if ((disp
& 0x80) != 0)
15764 if (isa64
== amd64
)
15766 if ((sizeflag
& DFLAG
)
15767 || (address_mode
== mode_64bit
15768 && (isa64
!= amd64
|| (rex
& REX_W
))))
15773 if ((disp
& 0x8000) != 0)
15775 /* In 16bit mode, address is wrapped around at 64k within
15776 the same segment. Otherwise, a data16 prefix on a jump
15777 instruction means that the pc is masked to 16 bits after
15778 the displacement is added! */
15780 if ((prefixes
& PREFIX_DATA
) == 0)
15781 segment
= ((start_pc
+ codep
- start_codep
)
15782 & ~((bfd_vma
) 0xffff));
15784 if (address_mode
!= mode_64bit
15785 || (isa64
== amd64
&& !(rex
& REX_W
)))
15786 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15789 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15792 disp
= ((start_pc
+ (codep
- start_codep
) + disp
) & mask
) | segment
;
15794 print_operand_value (scratchbuf
, 1, disp
);
15795 oappend (scratchbuf
);
15799 OP_SEG (int bytemode
, int sizeflag
)
15801 if (bytemode
== w_mode
)
15802 oappend (names_seg
[modrm
.reg
]);
15804 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
15808 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
15812 if (sizeflag
& DFLAG
)
15822 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15824 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
15826 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
15827 oappend (scratchbuf
);
15831 OP_OFF (int bytemode
, int sizeflag
)
15835 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
15836 intel_operand_size (bytemode
, sizeflag
);
15839 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
15846 if (!active_seg_prefix
)
15848 oappend (names_seg
[ds_reg
- es_reg
]);
15852 print_operand_value (scratchbuf
, 1, off
);
15853 oappend (scratchbuf
);
15857 OP_OFF64 (int bytemode
, int sizeflag
)
15861 if (address_mode
!= mode_64bit
15862 || (prefixes
& PREFIX_ADDR
))
15864 OP_OFF (bytemode
, sizeflag
);
15868 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
15869 intel_operand_size (bytemode
, sizeflag
);
15876 if (!active_seg_prefix
)
15878 oappend (names_seg
[ds_reg
- es_reg
]);
15882 print_operand_value (scratchbuf
, 1, off
);
15883 oappend (scratchbuf
);
15887 ptr_reg (int code
, int sizeflag
)
15891 *obufp
++ = open_char
;
15892 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
15893 if (address_mode
== mode_64bit
)
15895 if (!(sizeflag
& AFLAG
))
15896 s
= names32
[code
- eAX_reg
];
15898 s
= names64
[code
- eAX_reg
];
15900 else if (sizeflag
& AFLAG
)
15901 s
= names32
[code
- eAX_reg
];
15903 s
= names16
[code
- eAX_reg
];
15905 *obufp
++ = close_char
;
15910 OP_ESreg (int code
, int sizeflag
)
15916 case 0x6d: /* insw/insl */
15917 intel_operand_size (z_mode
, sizeflag
);
15919 case 0xa5: /* movsw/movsl/movsq */
15920 case 0xa7: /* cmpsw/cmpsl/cmpsq */
15921 case 0xab: /* stosw/stosl */
15922 case 0xaf: /* scasw/scasl */
15923 intel_operand_size (v_mode
, sizeflag
);
15926 intel_operand_size (b_mode
, sizeflag
);
15929 oappend_maybe_intel ("%es:");
15930 ptr_reg (code
, sizeflag
);
15934 OP_DSreg (int code
, int sizeflag
)
15940 case 0x6f: /* outsw/outsl */
15941 intel_operand_size (z_mode
, sizeflag
);
15943 case 0xa5: /* movsw/movsl/movsq */
15944 case 0xa7: /* cmpsw/cmpsl/cmpsq */
15945 case 0xad: /* lodsw/lodsl/lodsq */
15946 intel_operand_size (v_mode
, sizeflag
);
15949 intel_operand_size (b_mode
, sizeflag
);
15952 /* Set active_seg_prefix to PREFIX_DS if it is unset so that the
15953 default segment register DS is printed. */
15954 if (!active_seg_prefix
)
15955 active_seg_prefix
= PREFIX_DS
;
15957 ptr_reg (code
, sizeflag
);
15961 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15969 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
15971 all_prefixes
[last_lock_prefix
] = 0;
15972 used_prefixes
|= PREFIX_LOCK
;
15977 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
15978 oappend_maybe_intel (scratchbuf
);
15982 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15991 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
15993 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
15994 oappend (scratchbuf
);
15998 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16000 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
16001 oappend_maybe_intel (scratchbuf
);
16005 OP_R (int bytemode
, int sizeflag
)
16007 /* Skip mod/rm byte. */
16010 OP_E_register (bytemode
, sizeflag
);
16014 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16016 int reg
= modrm
.reg
;
16017 const char **names
;
16019 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16020 if (prefixes
& PREFIX_DATA
)
16029 oappend (names
[reg
]);
16033 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
16035 int reg
= modrm
.reg
;
16036 const char **names
;
16048 && bytemode
!= xmm_mode
16049 && bytemode
!= xmmq_mode
16050 && bytemode
!= evex_half_bcst_xmmq_mode
16051 && bytemode
!= ymm_mode
16052 && bytemode
!= scalar_mode
)
16054 switch (vex
.length
)
16061 || (bytemode
!= vex_vsib_q_w_dq_mode
16062 && bytemode
!= vex_vsib_q_w_d_mode
))
16074 else if (bytemode
== xmmq_mode
16075 || bytemode
== evex_half_bcst_xmmq_mode
)
16077 switch (vex
.length
)
16090 else if (bytemode
== ymm_mode
)
16094 oappend (names
[reg
]);
16098 OP_EM (int bytemode
, int sizeflag
)
16101 const char **names
;
16103 if (modrm
.mod
!= 3)
16106 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
16108 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
16109 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16111 OP_E (bytemode
, sizeflag
);
16115 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
16118 /* Skip mod/rm byte. */
16121 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16123 if (prefixes
& PREFIX_DATA
)
16132 oappend (names
[reg
]);
16135 /* cvt* are the only instructions in sse2 which have
16136 both SSE and MMX operands and also have 0x66 prefix
16137 in their opcode. 0x66 was originally used to differentiate
16138 between SSE and MMX instruction(operands). So we have to handle the
16139 cvt* separately using OP_EMC and OP_MXC */
16141 OP_EMC (int bytemode
, int sizeflag
)
16143 if (modrm
.mod
!= 3)
16145 if (intel_syntax
&& bytemode
== v_mode
)
16147 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
16148 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16150 OP_E (bytemode
, sizeflag
);
16154 /* Skip mod/rm byte. */
16157 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16158 oappend (names_mm
[modrm
.rm
]);
16162 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16164 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16165 oappend (names_mm
[modrm
.reg
]);
16169 OP_EX (int bytemode
, int sizeflag
)
16172 const char **names
;
16174 /* Skip mod/rm byte. */
16178 if (modrm
.mod
!= 3)
16180 OP_E_memory (bytemode
, sizeflag
);
16195 if ((sizeflag
& SUFFIX_ALWAYS
)
16196 && (bytemode
== x_swap_mode
16197 || bytemode
== d_swap_mode
16198 || bytemode
== dqw_swap_mode
16199 || bytemode
== d_scalar_swap_mode
16200 || bytemode
== q_swap_mode
16201 || bytemode
== q_scalar_swap_mode
))
16205 && bytemode
!= xmm_mode
16206 && bytemode
!= xmmdw_mode
16207 && bytemode
!= xmmqd_mode
16208 && bytemode
!= xmm_mb_mode
16209 && bytemode
!= xmm_mw_mode
16210 && bytemode
!= xmm_md_mode
16211 && bytemode
!= xmm_mq_mode
16212 && bytemode
!= xmm_mdq_mode
16213 && bytemode
!= xmmq_mode
16214 && bytemode
!= evex_half_bcst_xmmq_mode
16215 && bytemode
!= ymm_mode
16216 && bytemode
!= d_scalar_mode
16217 && bytemode
!= d_scalar_swap_mode
16218 && bytemode
!= q_scalar_mode
16219 && bytemode
!= q_scalar_swap_mode
16220 && bytemode
!= vex_scalar_w_dq_mode
)
16222 switch (vex
.length
)
16237 else if (bytemode
== xmmq_mode
16238 || bytemode
== evex_half_bcst_xmmq_mode
)
16240 switch (vex
.length
)
16253 else if (bytemode
== ymm_mode
)
16257 oappend (names
[reg
]);
16261 OP_MS (int bytemode
, int sizeflag
)
16263 if (modrm
.mod
== 3)
16264 OP_EM (bytemode
, sizeflag
);
16270 OP_XS (int bytemode
, int sizeflag
)
16272 if (modrm
.mod
== 3)
16273 OP_EX (bytemode
, sizeflag
);
16279 OP_M (int bytemode
, int sizeflag
)
16281 if (modrm
.mod
== 3)
16282 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
16285 OP_E (bytemode
, sizeflag
);
16289 OP_0f07 (int bytemode
, int sizeflag
)
16291 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
16294 OP_E (bytemode
, sizeflag
);
16297 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
16298 32bit mode and "xchg %rax,%rax" in 64bit mode. */
16301 NOP_Fixup1 (int bytemode
, int sizeflag
)
16303 if ((prefixes
& PREFIX_DATA
) != 0
16306 && address_mode
== mode_64bit
))
16307 OP_REG (bytemode
, sizeflag
);
16309 strcpy (obuf
, "nop");
16313 NOP_Fixup2 (int bytemode
, int sizeflag
)
16315 if ((prefixes
& PREFIX_DATA
) != 0
16318 && address_mode
== mode_64bit
))
16319 OP_IMREG (bytemode
, sizeflag
);
16322 static const char *const Suffix3DNow
[] = {
16323 /* 00 */ NULL
, NULL
, NULL
, NULL
,
16324 /* 04 */ NULL
, NULL
, NULL
, NULL
,
16325 /* 08 */ NULL
, NULL
, NULL
, NULL
,
16326 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
16327 /* 10 */ NULL
, NULL
, NULL
, NULL
,
16328 /* 14 */ NULL
, NULL
, NULL
, NULL
,
16329 /* 18 */ NULL
, NULL
, NULL
, NULL
,
16330 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
16331 /* 20 */ NULL
, NULL
, NULL
, NULL
,
16332 /* 24 */ NULL
, NULL
, NULL
, NULL
,
16333 /* 28 */ NULL
, NULL
, NULL
, NULL
,
16334 /* 2C */ NULL
, NULL
, NULL
, NULL
,
16335 /* 30 */ NULL
, NULL
, NULL
, NULL
,
16336 /* 34 */ NULL
, NULL
, NULL
, NULL
,
16337 /* 38 */ NULL
, NULL
, NULL
, NULL
,
16338 /* 3C */ NULL
, NULL
, NULL
, NULL
,
16339 /* 40 */ NULL
, NULL
, NULL
, NULL
,
16340 /* 44 */ NULL
, NULL
, NULL
, NULL
,
16341 /* 48 */ NULL
, NULL
, NULL
, NULL
,
16342 /* 4C */ NULL
, NULL
, NULL
, NULL
,
16343 /* 50 */ NULL
, NULL
, NULL
, NULL
,
16344 /* 54 */ NULL
, NULL
, NULL
, NULL
,
16345 /* 58 */ NULL
, NULL
, NULL
, NULL
,
16346 /* 5C */ NULL
, NULL
, NULL
, NULL
,
16347 /* 60 */ NULL
, NULL
, NULL
, NULL
,
16348 /* 64 */ NULL
, NULL
, NULL
, NULL
,
16349 /* 68 */ NULL
, NULL
, NULL
, NULL
,
16350 /* 6C */ NULL
, NULL
, NULL
, NULL
,
16351 /* 70 */ NULL
, NULL
, NULL
, NULL
,
16352 /* 74 */ NULL
, NULL
, NULL
, NULL
,
16353 /* 78 */ NULL
, NULL
, NULL
, NULL
,
16354 /* 7C */ NULL
, NULL
, NULL
, NULL
,
16355 /* 80 */ NULL
, NULL
, NULL
, NULL
,
16356 /* 84 */ NULL
, NULL
, NULL
, NULL
,
16357 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
16358 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
16359 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
16360 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
16361 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
16362 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
16363 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
16364 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
16365 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
16366 /* AC */ NULL
, NULL
, "pfacc", NULL
,
16367 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
16368 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
16369 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
16370 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
16371 /* C0 */ NULL
, NULL
, NULL
, NULL
,
16372 /* C4 */ NULL
, NULL
, NULL
, NULL
,
16373 /* C8 */ NULL
, NULL
, NULL
, NULL
,
16374 /* CC */ NULL
, NULL
, NULL
, NULL
,
16375 /* D0 */ NULL
, NULL
, NULL
, NULL
,
16376 /* D4 */ NULL
, NULL
, NULL
, NULL
,
16377 /* D8 */ NULL
, NULL
, NULL
, NULL
,
16378 /* DC */ NULL
, NULL
, NULL
, NULL
,
16379 /* E0 */ NULL
, NULL
, NULL
, NULL
,
16380 /* E4 */ NULL
, NULL
, NULL
, NULL
,
16381 /* E8 */ NULL
, NULL
, NULL
, NULL
,
16382 /* EC */ NULL
, NULL
, NULL
, NULL
,
16383 /* F0 */ NULL
, NULL
, NULL
, NULL
,
16384 /* F4 */ NULL
, NULL
, NULL
, NULL
,
16385 /* F8 */ NULL
, NULL
, NULL
, NULL
,
16386 /* FC */ NULL
, NULL
, NULL
, NULL
,
16390 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16392 const char *mnemonic
;
16394 FETCH_DATA (the_info
, codep
+ 1);
16395 /* AMD 3DNow! instructions are specified by an opcode suffix in the
16396 place where an 8-bit immediate would normally go. ie. the last
16397 byte of the instruction. */
16398 obufp
= mnemonicendp
;
16399 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
16401 oappend (mnemonic
);
16404 /* Since a variable sized modrm/sib chunk is between the start
16405 of the opcode (0x0f0f) and the opcode suffix, we need to do
16406 all the modrm processing first, and don't know until now that
16407 we have a bad opcode. This necessitates some cleaning up. */
16408 op_out
[0][0] = '\0';
16409 op_out
[1][0] = '\0';
16412 mnemonicendp
= obufp
;
16415 static struct op simd_cmp_op
[] =
16417 { STRING_COMMA_LEN ("eq") },
16418 { STRING_COMMA_LEN ("lt") },
16419 { STRING_COMMA_LEN ("le") },
16420 { STRING_COMMA_LEN ("unord") },
16421 { STRING_COMMA_LEN ("neq") },
16422 { STRING_COMMA_LEN ("nlt") },
16423 { STRING_COMMA_LEN ("nle") },
16424 { STRING_COMMA_LEN ("ord") }
16428 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16430 unsigned int cmp_type
;
16432 FETCH_DATA (the_info
, codep
+ 1);
16433 cmp_type
= *codep
++ & 0xff;
16434 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
16437 char *p
= mnemonicendp
- 2;
16441 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
16442 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
16446 /* We have a reserved extension byte. Output it directly. */
16447 scratchbuf
[0] = '$';
16448 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
16449 oappend_maybe_intel (scratchbuf
);
16450 scratchbuf
[0] = '\0';
16455 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
16456 int sizeflag ATTRIBUTE_UNUSED
)
16458 /* mwait %eax,%ecx */
16461 const char **names
= (address_mode
== mode_64bit
16462 ? names64
: names32
);
16463 strcpy (op_out
[0], names
[0]);
16464 strcpy (op_out
[1], names
[1]);
16465 two_source_ops
= 1;
16467 /* Skip mod/rm byte. */
16473 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
16474 int sizeflag ATTRIBUTE_UNUSED
)
16476 /* monitor %eax,%ecx,%edx" */
16479 const char **op1_names
;
16480 const char **names
= (address_mode
== mode_64bit
16481 ? names64
: names32
);
16483 if (!(prefixes
& PREFIX_ADDR
))
16484 op1_names
= (address_mode
== mode_16bit
16485 ? names16
: names
);
16488 /* Remove "addr16/addr32". */
16489 all_prefixes
[last_addr_prefix
] = 0;
16490 op1_names
= (address_mode
!= mode_32bit
16491 ? names32
: names16
);
16492 used_prefixes
|= PREFIX_ADDR
;
16494 strcpy (op_out
[0], op1_names
[0]);
16495 strcpy (op_out
[1], names
[1]);
16496 strcpy (op_out
[2], names
[2]);
16497 two_source_ops
= 1;
16499 /* Skip mod/rm byte. */
16507 /* Throw away prefixes and 1st. opcode byte. */
16508 codep
= insn_codep
+ 1;
16513 REP_Fixup (int bytemode
, int sizeflag
)
16515 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
16517 if (prefixes
& PREFIX_REPZ
)
16518 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
16525 OP_IMREG (bytemode
, sizeflag
);
16528 OP_ESreg (bytemode
, sizeflag
);
16531 OP_DSreg (bytemode
, sizeflag
);
16539 /* For BND-prefixed instructions 0xF2 prefix should be displayed as
16543 BND_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16545 if (prefixes
& PREFIX_REPNZ
)
16546 all_prefixes
[last_repnz_prefix
] = BND_PREFIX
;
16549 /* Similar to OP_E. But the 0xf2/0xf3 prefixes should be displayed as
16550 "xacquire"/"xrelease" for memory operand if there is a LOCK prefix.
16554 HLE_Fixup1 (int bytemode
, int sizeflag
)
16557 && (prefixes
& PREFIX_LOCK
) != 0)
16559 if (prefixes
& PREFIX_REPZ
)
16560 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16561 if (prefixes
& PREFIX_REPNZ
)
16562 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16565 OP_E (bytemode
, sizeflag
);
16568 /* Similar to OP_E. But the 0xf2/0xf3 prefixes should be displayed as
16569 "xacquire"/"xrelease" for memory operand. No check for LOCK prefix.
16573 HLE_Fixup2 (int bytemode
, int sizeflag
)
16575 if (modrm
.mod
!= 3)
16577 if (prefixes
& PREFIX_REPZ
)
16578 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16579 if (prefixes
& PREFIX_REPNZ
)
16580 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16583 OP_E (bytemode
, sizeflag
);
16586 /* Similar to OP_E. But the 0xf3 prefixes should be displayed as
16587 "xrelease" for memory operand. No check for LOCK prefix. */
16590 HLE_Fixup3 (int bytemode
, int sizeflag
)
16593 && last_repz_prefix
> last_repnz_prefix
16594 && (prefixes
& PREFIX_REPZ
) != 0)
16595 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16597 OP_E (bytemode
, sizeflag
);
16601 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
16606 /* Change cmpxchg8b to cmpxchg16b. */
16607 char *p
= mnemonicendp
- 2;
16608 mnemonicendp
= stpcpy (p
, "16b");
16611 else if ((prefixes
& PREFIX_LOCK
) != 0)
16613 if (prefixes
& PREFIX_REPZ
)
16614 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16615 if (prefixes
& PREFIX_REPNZ
)
16616 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16619 OP_M (bytemode
, sizeflag
);
16623 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
16625 const char **names
;
16629 switch (vex
.length
)
16643 oappend (names
[reg
]);
16647 CRC32_Fixup (int bytemode
, int sizeflag
)
16649 /* Add proper suffix to "crc32". */
16650 char *p
= mnemonicendp
;
16669 if (sizeflag
& DFLAG
)
16673 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16677 oappend (INTERNAL_DISASSEMBLER_ERROR
);
16684 if (modrm
.mod
== 3)
16688 /* Skip mod/rm byte. */
16693 add
= (rex
& REX_B
) ? 8 : 0;
16694 if (bytemode
== b_mode
)
16698 oappend (names8rex
[modrm
.rm
+ add
]);
16700 oappend (names8
[modrm
.rm
+ add
]);
16706 oappend (names64
[modrm
.rm
+ add
]);
16707 else if ((prefixes
& PREFIX_DATA
))
16708 oappend (names16
[modrm
.rm
+ add
]);
16710 oappend (names32
[modrm
.rm
+ add
]);
16714 OP_E (bytemode
, sizeflag
);
16718 FXSAVE_Fixup (int bytemode
, int sizeflag
)
16720 /* Add proper suffix to "fxsave" and "fxrstor". */
16724 char *p
= mnemonicendp
;
16730 OP_M (bytemode
, sizeflag
);
16733 /* Display the destination register operand for instructions with
16737 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
16740 const char **names
;
16748 reg
= vex
.register_specifier
;
16755 if (bytemode
== vex_scalar_mode
)
16757 oappend (names_xmm
[reg
]);
16761 switch (vex
.length
)
16768 case vex_vsib_q_w_dq_mode
:
16769 case vex_vsib_q_w_d_mode
:
16780 names
= names_mask
;
16794 case vex_vsib_q_w_dq_mode
:
16795 case vex_vsib_q_w_d_mode
:
16796 names
= vex
.w
? names_ymm
: names_xmm
;
16800 names
= names_mask
;
16814 oappend (names
[reg
]);
16817 /* Get the VEX immediate byte without moving codep. */
16819 static unsigned char
16820 get_vex_imm8 (int sizeflag
, int opnum
)
16822 int bytes_before_imm
= 0;
16824 if (modrm
.mod
!= 3)
16826 /* There are SIB/displacement bytes. */
16827 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
16829 /* 32/64 bit address mode */
16830 int base
= modrm
.rm
;
16832 /* Check SIB byte. */
16835 FETCH_DATA (the_info
, codep
+ 1);
16837 /* When decoding the third source, don't increase
16838 bytes_before_imm as this has already been incremented
16839 by one in OP_E_memory while decoding the second
16842 bytes_before_imm
++;
16845 /* Don't increase bytes_before_imm when decoding the third source,
16846 it has already been incremented by OP_E_memory while decoding
16847 the second source operand. */
16853 /* When modrm.rm == 5 or modrm.rm == 4 and base in
16854 SIB == 5, there is a 4 byte displacement. */
16856 /* No displacement. */
16859 /* 4 byte displacement. */
16860 bytes_before_imm
+= 4;
16863 /* 1 byte displacement. */
16864 bytes_before_imm
++;
16871 /* 16 bit address mode */
16872 /* Don't increase bytes_before_imm when decoding the third source,
16873 it has already been incremented by OP_E_memory while decoding
16874 the second source operand. */
16880 /* When modrm.rm == 6, there is a 2 byte displacement. */
16882 /* No displacement. */
16885 /* 2 byte displacement. */
16886 bytes_before_imm
+= 2;
16889 /* 1 byte displacement: when decoding the third source,
16890 don't increase bytes_before_imm as this has already
16891 been incremented by one in OP_E_memory while decoding
16892 the second source operand. */
16894 bytes_before_imm
++;
16902 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
16903 return codep
[bytes_before_imm
];
16907 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
16909 const char **names
;
16911 if (reg
== -1 && modrm
.mod
!= 3)
16913 OP_E_memory (bytemode
, sizeflag
);
16925 else if (reg
> 7 && address_mode
!= mode_64bit
)
16929 switch (vex
.length
)
16940 oappend (names
[reg
]);
16944 OP_EX_VexImmW (int bytemode
, int sizeflag
)
16947 static unsigned char vex_imm8
;
16949 if (vex_w_done
== 0)
16953 /* Skip mod/rm byte. */
16957 vex_imm8
= get_vex_imm8 (sizeflag
, 0);
16960 reg
= vex_imm8
>> 4;
16962 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
16964 else if (vex_w_done
== 1)
16969 reg
= vex_imm8
>> 4;
16971 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
16975 /* Output the imm8 directly. */
16976 scratchbuf
[0] = '$';
16977 print_operand_value (scratchbuf
+ 1, 1, vex_imm8
& 0xf);
16978 oappend_maybe_intel (scratchbuf
);
16979 scratchbuf
[0] = '\0';
16985 OP_Vex_2src (int bytemode
, int sizeflag
)
16987 if (modrm
.mod
== 3)
16989 int reg
= modrm
.rm
;
16993 oappend (names_xmm
[reg
]);
16998 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
17000 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
17001 used_prefixes
|= (prefixes
& PREFIX_DATA
);
17003 OP_E (bytemode
, sizeflag
);
17008 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
17010 if (modrm
.mod
== 3)
17012 /* Skip mod/rm byte. */
17018 oappend (names_xmm
[vex
.register_specifier
]);
17020 OP_Vex_2src (bytemode
, sizeflag
);
17024 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
17027 OP_Vex_2src (bytemode
, sizeflag
);
17029 oappend (names_xmm
[vex
.register_specifier
]);
17033 OP_EX_VexW (int bytemode
, int sizeflag
)
17041 /* Skip mod/rm byte. */
17046 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
17051 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
17054 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
17058 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
17059 int sizeflag ATTRIBUTE_UNUSED
)
17061 /* Skip the immediate byte and check for invalid bits. */
17062 FETCH_DATA (the_info
, codep
+ 1);
17063 if (*codep
++ & 0xf)
17068 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
17071 const char **names
;
17073 FETCH_DATA (the_info
, codep
+ 1);
17076 if (bytemode
!= x_mode
)
17083 if (reg
> 7 && address_mode
!= mode_64bit
)
17086 switch (vex
.length
)
17097 oappend (names
[reg
]);
17101 OP_XMM_VexW (int bytemode
, int sizeflag
)
17103 /* Turn off the REX.W bit since it is used for swapping operands
17106 OP_XMM (bytemode
, sizeflag
);
17110 OP_EX_Vex (int bytemode
, int sizeflag
)
17112 if (modrm
.mod
!= 3)
17114 if (vex
.register_specifier
!= 0)
17118 OP_EX (bytemode
, sizeflag
);
17122 OP_XMM_Vex (int bytemode
, int sizeflag
)
17124 if (modrm
.mod
!= 3)
17126 if (vex
.register_specifier
!= 0)
17130 OP_XMM (bytemode
, sizeflag
);
17134 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17136 switch (vex
.length
)
17139 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
17142 mnemonicendp
= stpcpy (obuf
, "vzeroall");
17149 static struct op vex_cmp_op
[] =
17151 { STRING_COMMA_LEN ("eq") },
17152 { STRING_COMMA_LEN ("lt") },
17153 { STRING_COMMA_LEN ("le") },
17154 { STRING_COMMA_LEN ("unord") },
17155 { STRING_COMMA_LEN ("neq") },
17156 { STRING_COMMA_LEN ("nlt") },
17157 { STRING_COMMA_LEN ("nle") },
17158 { STRING_COMMA_LEN ("ord") },
17159 { STRING_COMMA_LEN ("eq_uq") },
17160 { STRING_COMMA_LEN ("nge") },
17161 { STRING_COMMA_LEN ("ngt") },
17162 { STRING_COMMA_LEN ("false") },
17163 { STRING_COMMA_LEN ("neq_oq") },
17164 { STRING_COMMA_LEN ("ge") },
17165 { STRING_COMMA_LEN ("gt") },
17166 { STRING_COMMA_LEN ("true") },
17167 { STRING_COMMA_LEN ("eq_os") },
17168 { STRING_COMMA_LEN ("lt_oq") },
17169 { STRING_COMMA_LEN ("le_oq") },
17170 { STRING_COMMA_LEN ("unord_s") },
17171 { STRING_COMMA_LEN ("neq_us") },
17172 { STRING_COMMA_LEN ("nlt_uq") },
17173 { STRING_COMMA_LEN ("nle_uq") },
17174 { STRING_COMMA_LEN ("ord_s") },
17175 { STRING_COMMA_LEN ("eq_us") },
17176 { STRING_COMMA_LEN ("nge_uq") },
17177 { STRING_COMMA_LEN ("ngt_uq") },
17178 { STRING_COMMA_LEN ("false_os") },
17179 { STRING_COMMA_LEN ("neq_os") },
17180 { STRING_COMMA_LEN ("ge_oq") },
17181 { STRING_COMMA_LEN ("gt_oq") },
17182 { STRING_COMMA_LEN ("true_us") },
17186 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17188 unsigned int cmp_type
;
17190 FETCH_DATA (the_info
, codep
+ 1);
17191 cmp_type
= *codep
++ & 0xff;
17192 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
17195 char *p
= mnemonicendp
- 2;
17199 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
17200 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
17204 /* We have a reserved extension byte. Output it directly. */
17205 scratchbuf
[0] = '$';
17206 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
17207 oappend_maybe_intel (scratchbuf
);
17208 scratchbuf
[0] = '\0';
17213 VPCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
,
17214 int sizeflag ATTRIBUTE_UNUSED
)
17216 unsigned int cmp_type
;
17221 FETCH_DATA (the_info
, codep
+ 1);
17222 cmp_type
= *codep
++ & 0xff;
17223 /* There are aliases for immediates 0, 1, 2, 4, 5, 6.
17224 If it's the case, print suffix, otherwise - print the immediate. */
17225 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
)
17230 char *p
= mnemonicendp
- 2;
17232 /* vpcmp* can have both one- and two-lettered suffix. */
17246 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
17247 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
17251 /* We have a reserved extension byte. Output it directly. */
17252 scratchbuf
[0] = '$';
17253 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
17254 oappend_maybe_intel (scratchbuf
);
17255 scratchbuf
[0] = '\0';
17259 static const struct op pclmul_op
[] =
17261 { STRING_COMMA_LEN ("lql") },
17262 { STRING_COMMA_LEN ("hql") },
17263 { STRING_COMMA_LEN ("lqh") },
17264 { STRING_COMMA_LEN ("hqh") }
17268 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
17269 int sizeflag ATTRIBUTE_UNUSED
)
17271 unsigned int pclmul_type
;
17273 FETCH_DATA (the_info
, codep
+ 1);
17274 pclmul_type
= *codep
++ & 0xff;
17275 switch (pclmul_type
)
17286 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
17289 char *p
= mnemonicendp
- 3;
17294 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
17295 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
17299 /* We have a reserved extension byte. Output it directly. */
17300 scratchbuf
[0] = '$';
17301 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
17302 oappend_maybe_intel (scratchbuf
);
17303 scratchbuf
[0] = '\0';
17308 MOVBE_Fixup (int bytemode
, int sizeflag
)
17310 /* Add proper suffix to "movbe". */
17311 char *p
= mnemonicendp
;
17320 if (sizeflag
& SUFFIX_ALWAYS
)
17326 if (sizeflag
& DFLAG
)
17330 used_prefixes
|= (prefixes
& PREFIX_DATA
);
17335 oappend (INTERNAL_DISASSEMBLER_ERROR
);
17342 OP_M (bytemode
, sizeflag
);
17346 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17349 const char **names
;
17351 /* Skip mod/rm byte. */
17365 oappend (names
[reg
]);
17369 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17371 const char **names
;
17378 oappend (names
[vex
.register_specifier
]);
17382 OP_Mask (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
17385 || (bytemode
!= mask_mode
&& bytemode
!= mask_bd_mode
))
17389 if ((rex
& REX_R
) != 0 || !vex
.r
)
17395 oappend (names_mask
[modrm
.reg
]);
17399 OP_Rounding (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
17402 || (bytemode
!= evex_rounding_mode
17403 && bytemode
!= evex_sae_mode
))
17405 if (modrm
.mod
== 3 && vex
.b
)
17408 case evex_rounding_mode
:
17409 oappend (names_rounding
[vex
.ll
]);
17411 case evex_sae_mode
: