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_UD_SHIFT 8
226 #define PREFIX_UD_REPZ (PREFIX_REPZ << PREFIX_UD_SHIFT)
227 #define PREFIX_UD_REPNZ (PREFIX_REPNZ << PREFIX_UD_SHIFT)
228 #define PREFIX_UD_DATA (PREFIX_DATA << PREFIX_UD_SHIFT)
229 #define PREFIX_UD_ADDR (PREFIX_ADDR << PREFIX_UD_SHIFT)
230 #define PREFIX_UD_LOCK (PREFIX_LOCK << PREFIX_UD_SHIFT)
231 #define PREFIX_IGNORED_SHIFT 16
232 #define PREFIX_IGNORED_REPZ (PREFIX_REPZ << PREFIX_IGNORED_SHIFT)
233 #define PREFIX_IGNORED_REPNZ (PREFIX_REPNZ << PREFIX_IGNORED_SHIFT)
234 #define PREFIX_IGNORED_DATA (PREFIX_DATA << PREFIX_IGNORED_SHIFT)
235 #define PREFIX_IGNORED_ADDR (PREFIX_ADDR << PREFIX_IGNORED_SHIFT)
236 #define PREFIX_IGNORED_LOCK (PREFIX_LOCK << PREFIX_IGNORED_SHIFT)
238 /* Opcode prefixes. */
239 #define PREFIX_OPCODE (PREFIX_REPZ \
243 /* Prefixes ignored. */
244 #define PREFIX_IGNORED (PREFIX_IGNORED_REPZ \
245 | PREFIX_IGNORED_REPNZ \
246 | PREFIX_IGNORED_DATA)
248 #define XX { NULL, 0 }
249 #define Bad_Opcode NULL, { { NULL, 0 } }, 0
251 #define Eb { OP_E, b_mode }
252 #define Ebnd { OP_E, bnd_mode }
253 #define EbS { OP_E, b_swap_mode }
254 #define Ev { OP_E, v_mode }
255 #define Ev_bnd { OP_E, v_bnd_mode }
256 #define EvS { OP_E, v_swap_mode }
257 #define Ed { OP_E, d_mode }
258 #define Edq { OP_E, dq_mode }
259 #define Edqw { OP_E, dqw_mode }
260 #define EdqwS { OP_E, dqw_swap_mode }
261 #define Edqb { OP_E, dqb_mode }
262 #define Edb { OP_E, db_mode }
263 #define Edw { OP_E, dw_mode }
264 #define Edqd { OP_E, dqd_mode }
265 #define Eq { OP_E, q_mode }
266 #define indirEv { OP_indirE, stack_v_mode }
267 #define indirEp { OP_indirE, f_mode }
268 #define stackEv { OP_E, stack_v_mode }
269 #define Em { OP_E, m_mode }
270 #define Ew { OP_E, w_mode }
271 #define M { OP_M, 0 } /* lea, lgdt, etc. */
272 #define Ma { OP_M, a_mode }
273 #define Mb { OP_M, b_mode }
274 #define Md { OP_M, d_mode }
275 #define Mo { OP_M, o_mode }
276 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
277 #define Mq { OP_M, q_mode }
278 #define Mx { OP_M, x_mode }
279 #define Mxmm { OP_M, xmm_mode }
280 #define Gb { OP_G, b_mode }
281 #define Gbnd { OP_G, bnd_mode }
282 #define Gv { OP_G, v_mode }
283 #define Gd { OP_G, d_mode }
284 #define Gdq { OP_G, dq_mode }
285 #define Gm { OP_G, m_mode }
286 #define Gw { OP_G, w_mode }
287 #define Rd { OP_R, d_mode }
288 #define Rdq { OP_R, dq_mode }
289 #define Rm { OP_R, m_mode }
290 #define Ib { OP_I, b_mode }
291 #define sIb { OP_sI, b_mode } /* sign extened byte */
292 #define sIbT { OP_sI, b_T_mode } /* sign extened byte like 'T' */
293 #define Iv { OP_I, v_mode }
294 #define sIv { OP_sI, v_mode }
295 #define Iq { OP_I, q_mode }
296 #define Iv64 { OP_I64, v_mode }
297 #define Iw { OP_I, w_mode }
298 #define I1 { OP_I, const_1_mode }
299 #define Jb { OP_J, b_mode }
300 #define Jv { OP_J, v_mode }
301 #define Cm { OP_C, m_mode }
302 #define Dm { OP_D, m_mode }
303 #define Td { OP_T, d_mode }
304 #define Skip_MODRM { OP_Skip_MODRM, 0 }
306 #define RMeAX { OP_REG, eAX_reg }
307 #define RMeBX { OP_REG, eBX_reg }
308 #define RMeCX { OP_REG, eCX_reg }
309 #define RMeDX { OP_REG, eDX_reg }
310 #define RMeSP { OP_REG, eSP_reg }
311 #define RMeBP { OP_REG, eBP_reg }
312 #define RMeSI { OP_REG, eSI_reg }
313 #define RMeDI { OP_REG, eDI_reg }
314 #define RMrAX { OP_REG, rAX_reg }
315 #define RMrBX { OP_REG, rBX_reg }
316 #define RMrCX { OP_REG, rCX_reg }
317 #define RMrDX { OP_REG, rDX_reg }
318 #define RMrSP { OP_REG, rSP_reg }
319 #define RMrBP { OP_REG, rBP_reg }
320 #define RMrSI { OP_REG, rSI_reg }
321 #define RMrDI { OP_REG, rDI_reg }
322 #define RMAL { OP_REG, al_reg }
323 #define RMCL { OP_REG, cl_reg }
324 #define RMDL { OP_REG, dl_reg }
325 #define RMBL { OP_REG, bl_reg }
326 #define RMAH { OP_REG, ah_reg }
327 #define RMCH { OP_REG, ch_reg }
328 #define RMDH { OP_REG, dh_reg }
329 #define RMBH { OP_REG, bh_reg }
330 #define RMAX { OP_REG, ax_reg }
331 #define RMDX { OP_REG, dx_reg }
333 #define eAX { OP_IMREG, eAX_reg }
334 #define eBX { OP_IMREG, eBX_reg }
335 #define eCX { OP_IMREG, eCX_reg }
336 #define eDX { OP_IMREG, eDX_reg }
337 #define eSP { OP_IMREG, eSP_reg }
338 #define eBP { OP_IMREG, eBP_reg }
339 #define eSI { OP_IMREG, eSI_reg }
340 #define eDI { OP_IMREG, eDI_reg }
341 #define AL { OP_IMREG, al_reg }
342 #define CL { OP_IMREG, cl_reg }
343 #define DL { OP_IMREG, dl_reg }
344 #define BL { OP_IMREG, bl_reg }
345 #define AH { OP_IMREG, ah_reg }
346 #define CH { OP_IMREG, ch_reg }
347 #define DH { OP_IMREG, dh_reg }
348 #define BH { OP_IMREG, bh_reg }
349 #define AX { OP_IMREG, ax_reg }
350 #define DX { OP_IMREG, dx_reg }
351 #define zAX { OP_IMREG, z_mode_ax_reg }
352 #define indirDX { OP_IMREG, indir_dx_reg }
354 #define Sw { OP_SEG, w_mode }
355 #define Sv { OP_SEG, v_mode }
356 #define Ap { OP_DIR, 0 }
357 #define Ob { OP_OFF64, b_mode }
358 #define Ov { OP_OFF64, v_mode }
359 #define Xb { OP_DSreg, eSI_reg }
360 #define Xv { OP_DSreg, eSI_reg }
361 #define Xz { OP_DSreg, eSI_reg }
362 #define Yb { OP_ESreg, eDI_reg }
363 #define Yv { OP_ESreg, eDI_reg }
364 #define DSBX { OP_DSreg, eBX_reg }
366 #define es { OP_REG, es_reg }
367 #define ss { OP_REG, ss_reg }
368 #define cs { OP_REG, cs_reg }
369 #define ds { OP_REG, ds_reg }
370 #define fs { OP_REG, fs_reg }
371 #define gs { OP_REG, gs_reg }
373 #define MX { OP_MMX, 0 }
374 #define XM { OP_XMM, 0 }
375 #define XMScalar { OP_XMM, scalar_mode }
376 #define XMGatherQ { OP_XMM, vex_vsib_q_w_dq_mode }
377 #define XMM { OP_XMM, xmm_mode }
378 #define XMxmmq { OP_XMM, xmmq_mode }
379 #define EM { OP_EM, v_mode }
380 #define EMS { OP_EM, v_swap_mode }
381 #define EMd { OP_EM, d_mode }
382 #define EMx { OP_EM, x_mode }
383 #define EXw { OP_EX, w_mode }
384 #define EXd { OP_EX, d_mode }
385 #define EXdScalar { OP_EX, d_scalar_mode }
386 #define EXdS { OP_EX, d_swap_mode }
387 #define EXdScalarS { OP_EX, d_scalar_swap_mode }
388 #define EXq { OP_EX, q_mode }
389 #define EXqScalar { OP_EX, q_scalar_mode }
390 #define EXqScalarS { OP_EX, q_scalar_swap_mode }
391 #define EXqS { OP_EX, q_swap_mode }
392 #define EXx { OP_EX, x_mode }
393 #define EXxS { OP_EX, x_swap_mode }
394 #define EXxmm { OP_EX, xmm_mode }
395 #define EXymm { OP_EX, ymm_mode }
396 #define EXxmmq { OP_EX, xmmq_mode }
397 #define EXEvexHalfBcstXmmq { OP_EX, evex_half_bcst_xmmq_mode }
398 #define EXxmm_mb { OP_EX, xmm_mb_mode }
399 #define EXxmm_mw { OP_EX, xmm_mw_mode }
400 #define EXxmm_md { OP_EX, xmm_md_mode }
401 #define EXxmm_mq { OP_EX, xmm_mq_mode }
402 #define EXxmm_mdq { OP_EX, xmm_mdq_mode }
403 #define EXxmmdw { OP_EX, xmmdw_mode }
404 #define EXxmmqd { OP_EX, xmmqd_mode }
405 #define EXymmq { OP_EX, ymmq_mode }
406 #define EXVexWdq { OP_EX, vex_w_dq_mode }
407 #define EXVexWdqScalar { OP_EX, vex_scalar_w_dq_mode }
408 #define EXEvexXGscat { OP_EX, evex_x_gscat_mode }
409 #define EXEvexXNoBcst { OP_EX, evex_x_nobcst_mode }
410 #define MS { OP_MS, v_mode }
411 #define XS { OP_XS, v_mode }
412 #define EMCq { OP_EMC, q_mode }
413 #define MXC { OP_MXC, 0 }
414 #define OPSUF { OP_3DNowSuffix, 0 }
415 #define CMP { CMP_Fixup, 0 }
416 #define XMM0 { XMM_Fixup, 0 }
417 #define FXSAVE { FXSAVE_Fixup, 0 }
418 #define Vex_2src_1 { OP_Vex_2src_1, 0 }
419 #define Vex_2src_2 { OP_Vex_2src_2, 0 }
421 #define Vex { OP_VEX, vex_mode }
422 #define VexScalar { OP_VEX, vex_scalar_mode }
423 #define VexGatherQ { OP_VEX, vex_vsib_q_w_dq_mode }
424 #define Vex128 { OP_VEX, vex128_mode }
425 #define Vex256 { OP_VEX, vex256_mode }
426 #define VexGdq { OP_VEX, dq_mode }
427 #define VexI4 { VEXI4_Fixup, 0}
428 #define EXdVex { OP_EX_Vex, d_mode }
429 #define EXdVexS { OP_EX_Vex, d_swap_mode }
430 #define EXdVexScalarS { OP_EX_Vex, d_scalar_swap_mode }
431 #define EXqVex { OP_EX_Vex, q_mode }
432 #define EXqVexS { OP_EX_Vex, q_swap_mode }
433 #define EXqVexScalarS { OP_EX_Vex, q_scalar_swap_mode }
434 #define EXVexW { OP_EX_VexW, x_mode }
435 #define EXdVexW { OP_EX_VexW, d_mode }
436 #define EXqVexW { OP_EX_VexW, q_mode }
437 #define EXVexImmW { OP_EX_VexImmW, x_mode }
438 #define XMVex { OP_XMM_Vex, 0 }
439 #define XMVexScalar { OP_XMM_Vex, scalar_mode }
440 #define XMVexW { OP_XMM_VexW, 0 }
441 #define XMVexI4 { OP_REG_VexI4, x_mode }
442 #define PCLMUL { PCLMUL_Fixup, 0 }
443 #define VZERO { VZERO_Fixup, 0 }
444 #define VCMP { VCMP_Fixup, 0 }
445 #define VPCMP { VPCMP_Fixup, 0 }
447 #define EXxEVexR { OP_Rounding, evex_rounding_mode }
448 #define EXxEVexS { OP_Rounding, evex_sae_mode }
450 #define XMask { OP_Mask, mask_mode }
451 #define MaskG { OP_G, mask_mode }
452 #define MaskE { OP_E, mask_mode }
453 #define MaskBDE { OP_E, mask_bd_mode }
454 #define MaskR { OP_R, mask_mode }
455 #define MaskVex { OP_VEX, mask_mode }
457 #define MVexVSIBDWpX { OP_M, vex_vsib_d_w_dq_mode }
458 #define MVexVSIBDQWpX { OP_M, vex_vsib_d_w_d_mode }
459 #define MVexVSIBQWpX { OP_M, vex_vsib_q_w_dq_mode }
460 #define MVexVSIBQDWpX { OP_M, vex_vsib_q_w_d_mode }
462 /* Used handle "rep" prefix for string instructions. */
463 #define Xbr { REP_Fixup, eSI_reg }
464 #define Xvr { REP_Fixup, eSI_reg }
465 #define Ybr { REP_Fixup, eDI_reg }
466 #define Yvr { REP_Fixup, eDI_reg }
467 #define Yzr { REP_Fixup, eDI_reg }
468 #define indirDXr { REP_Fixup, indir_dx_reg }
469 #define ALr { REP_Fixup, al_reg }
470 #define eAXr { REP_Fixup, eAX_reg }
472 /* Used handle HLE prefix for lockable instructions. */
473 #define Ebh1 { HLE_Fixup1, b_mode }
474 #define Evh1 { HLE_Fixup1, v_mode }
475 #define Ebh2 { HLE_Fixup2, b_mode }
476 #define Evh2 { HLE_Fixup2, v_mode }
477 #define Ebh3 { HLE_Fixup3, b_mode }
478 #define Evh3 { HLE_Fixup3, v_mode }
480 #define BND { BND_Fixup, 0 }
482 #define cond_jump_flag { NULL, cond_jump_mode }
483 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
485 /* bits in sizeflag */
486 #define SUFFIX_ALWAYS 4
494 /* byte operand with operand swapped */
496 /* byte operand, sign extend like 'T' suffix */
498 /* operand size depends on prefixes */
500 /* operand size depends on prefixes with operand swapped */
504 /* double word operand */
506 /* double word operand with operand swapped */
508 /* quad word operand */
510 /* quad word operand with operand swapped */
512 /* ten-byte operand */
514 /* 16-byte XMM, 32-byte YMM or 64-byte ZMM operand. In EVEX with
515 broadcast enabled. */
517 /* Similar to x_mode, but with different EVEX mem shifts. */
519 /* Similar to x_mode, but with disabled broadcast. */
521 /* Similar to x_mode, but with operands swapped and disabled broadcast
524 /* 16-byte XMM operand */
526 /* XMM, XMM or YMM register operand, or quad word, xmmword or ymmword
527 memory operand (depending on vector length). Broadcast isn't
530 /* Same as xmmq_mode, but broadcast is allowed. */
531 evex_half_bcst_xmmq_mode
,
532 /* XMM register or byte memory operand */
534 /* XMM register or word memory operand */
536 /* XMM register or double word memory operand */
538 /* XMM register or quad word memory operand */
540 /* XMM register or double/quad word memory operand, depending on
543 /* 16-byte XMM, word, double word or quad word operand. */
545 /* 16-byte XMM, double word, quad word operand or xmm word operand. */
547 /* 32-byte YMM operand */
549 /* quad word, ymmword or zmmword memory operand. */
551 /* 32-byte YMM or 16-byte word operand */
553 /* d_mode in 32bit, q_mode in 64bit mode. */
555 /* pair of v_mode operands */
560 /* operand size depends on REX prefixes. */
562 /* registers like dq_mode, memory like w_mode. */
566 /* 4- or 6-byte pointer operand */
569 /* v_mode for stack-related opcodes. */
571 /* non-quad operand size depends on prefixes */
573 /* 16-byte operand */
575 /* registers like dq_mode, memory like b_mode. */
577 /* registers like d_mode, memory like b_mode. */
579 /* registers like d_mode, memory like w_mode. */
581 /* registers like dq_mode, memory like d_mode. */
583 /* normal vex mode */
585 /* 128bit vex mode */
587 /* 256bit vex mode */
589 /* operand size depends on the VEX.W bit. */
592 /* Similar to vex_w_dq_mode, with VSIB dword indices. */
593 vex_vsib_d_w_dq_mode
,
594 /* Similar to vex_vsib_d_w_dq_mode, with smaller memory. */
596 /* Similar to vex_w_dq_mode, with VSIB qword indices. */
597 vex_vsib_q_w_dq_mode
,
598 /* Similar to vex_vsib_q_w_dq_mode, with smaller memory. */
601 /* scalar, ignore vector length. */
603 /* like d_mode, ignore vector length. */
605 /* like d_swap_mode, ignore vector length. */
607 /* like q_mode, ignore vector length. */
609 /* like q_swap_mode, ignore vector length. */
611 /* like vex_mode, ignore vector length. */
613 /* like vex_w_dq_mode, ignore vector length. */
614 vex_scalar_w_dq_mode
,
616 /* Static rounding. */
618 /* Supress all exceptions. */
621 /* Mask register operand. */
623 /* Mask register operand. */
690 #define FLOAT NULL, { { NULL, FLOATCODE } }, 0
692 #define DIS386(T, I) NULL, { { NULL, (T)}, { NULL, (I) } }, 0
693 #define DIS386_PREFIX(T, I, P) NULL, { { NULL, (T)}, { NULL, (I) } }, P
694 #define REG_TABLE(I) DIS386 (USE_REG_TABLE, (I))
695 #define MOD_TABLE(I) DIS386 (USE_MOD_TABLE, (I))
696 #define RM_TABLE(I) DIS386 (USE_RM_TABLE, (I))
697 #define PREFIX_TABLE(I) DIS386 (USE_PREFIX_TABLE, (I))
698 #define X86_64_TABLE(I) DIS386 (USE_X86_64_TABLE, (I))
699 #define THREE_BYTE_TABLE(I) DIS386 (USE_3BYTE_TABLE, (I))
700 #define THREE_BYTE_TABLE_PREFIX(I, P) DIS386_PREFIX (USE_3BYTE_TABLE, (I), P)
701 #define XOP_8F_TABLE(I) DIS386 (USE_XOP_8F_TABLE, (I))
702 #define VEX_C4_TABLE(I) DIS386 (USE_VEX_C4_TABLE, (I))
703 #define VEX_C5_TABLE(I) DIS386 (USE_VEX_C5_TABLE, (I))
704 #define VEX_LEN_TABLE(I) DIS386 (USE_VEX_LEN_TABLE, (I))
705 #define VEX_W_TABLE(I) DIS386 (USE_VEX_W_TABLE, (I))
706 #define EVEX_TABLE(I) DIS386 (USE_EVEX_TABLE, (I))
822 MOD_VEX_0F12_PREFIX_0
,
824 MOD_VEX_0F16_PREFIX_0
,
840 MOD_VEX_0FD7_PREFIX_2
,
841 MOD_VEX_0FE7_PREFIX_2
,
842 MOD_VEX_0FF0_PREFIX_3
,
843 MOD_VEX_0F381A_PREFIX_2
,
844 MOD_VEX_0F382A_PREFIX_2
,
845 MOD_VEX_0F382C_PREFIX_2
,
846 MOD_VEX_0F382D_PREFIX_2
,
847 MOD_VEX_0F382E_PREFIX_2
,
848 MOD_VEX_0F382F_PREFIX_2
,
849 MOD_VEX_0F385A_PREFIX_2
,
850 MOD_VEX_0F388C_PREFIX_2
,
851 MOD_VEX_0F388E_PREFIX_2
,
853 MOD_EVEX_0F10_PREFIX_1
,
854 MOD_EVEX_0F10_PREFIX_3
,
855 MOD_EVEX_0F11_PREFIX_1
,
856 MOD_EVEX_0F11_PREFIX_3
,
857 MOD_EVEX_0F12_PREFIX_0
,
858 MOD_EVEX_0F16_PREFIX_0
,
859 MOD_EVEX_0F38C6_REG_1
,
860 MOD_EVEX_0F38C6_REG_2
,
861 MOD_EVEX_0F38C6_REG_5
,
862 MOD_EVEX_0F38C6_REG_6
,
863 MOD_EVEX_0F38C7_REG_1
,
864 MOD_EVEX_0F38C7_REG_2
,
865 MOD_EVEX_0F38C7_REG_5
,
866 MOD_EVEX_0F38C7_REG_6
930 PREFIX_RM_0_0FAE_REG_7
,
936 PREFIX_MOD_0_0FC7_REG_6
,
937 PREFIX_MOD_3_0FC7_REG_6
,
938 PREFIX_MOD_3_0FC7_REG_7
,
1062 PREFIX_VEX_0F71_REG_2
,
1063 PREFIX_VEX_0F71_REG_4
,
1064 PREFIX_VEX_0F71_REG_6
,
1065 PREFIX_VEX_0F72_REG_2
,
1066 PREFIX_VEX_0F72_REG_4
,
1067 PREFIX_VEX_0F72_REG_6
,
1068 PREFIX_VEX_0F73_REG_2
,
1069 PREFIX_VEX_0F73_REG_3
,
1070 PREFIX_VEX_0F73_REG_6
,
1071 PREFIX_VEX_0F73_REG_7
,
1243 PREFIX_VEX_0F38F3_REG_1
,
1244 PREFIX_VEX_0F38F3_REG_2
,
1245 PREFIX_VEX_0F38F3_REG_3
,
1362 PREFIX_EVEX_0F71_REG_2
,
1363 PREFIX_EVEX_0F71_REG_4
,
1364 PREFIX_EVEX_0F71_REG_6
,
1365 PREFIX_EVEX_0F72_REG_0
,
1366 PREFIX_EVEX_0F72_REG_1
,
1367 PREFIX_EVEX_0F72_REG_2
,
1368 PREFIX_EVEX_0F72_REG_4
,
1369 PREFIX_EVEX_0F72_REG_6
,
1370 PREFIX_EVEX_0F73_REG_2
,
1371 PREFIX_EVEX_0F73_REG_3
,
1372 PREFIX_EVEX_0F73_REG_6
,
1373 PREFIX_EVEX_0F73_REG_7
,
1556 PREFIX_EVEX_0F38C6_REG_1
,
1557 PREFIX_EVEX_0F38C6_REG_2
,
1558 PREFIX_EVEX_0F38C6_REG_5
,
1559 PREFIX_EVEX_0F38C6_REG_6
,
1560 PREFIX_EVEX_0F38C7_REG_1
,
1561 PREFIX_EVEX_0F38C7_REG_2
,
1562 PREFIX_EVEX_0F38C7_REG_5
,
1563 PREFIX_EVEX_0F38C7_REG_6
,
1650 THREE_BYTE_0F38
= 0,
1678 VEX_LEN_0F10_P_1
= 0,
1682 VEX_LEN_0F12_P_0_M_0
,
1683 VEX_LEN_0F12_P_0_M_1
,
1686 VEX_LEN_0F16_P_0_M_0
,
1687 VEX_LEN_0F16_P_0_M_1
,
1751 VEX_LEN_0FAE_R_2_M_0
,
1752 VEX_LEN_0FAE_R_3_M_0
,
1761 VEX_LEN_0F381A_P_2_M_0
,
1764 VEX_LEN_0F385A_P_2_M_0
,
1771 VEX_LEN_0F38F3_R_1_P_0
,
1772 VEX_LEN_0F38F3_R_2_P_0
,
1773 VEX_LEN_0F38F3_R_3_P_0
,
1819 VEX_LEN_0FXOP_08_CC
,
1820 VEX_LEN_0FXOP_08_CD
,
1821 VEX_LEN_0FXOP_08_CE
,
1822 VEX_LEN_0FXOP_08_CF
,
1823 VEX_LEN_0FXOP_08_EC
,
1824 VEX_LEN_0FXOP_08_ED
,
1825 VEX_LEN_0FXOP_08_EE
,
1826 VEX_LEN_0FXOP_08_EF
,
1827 VEX_LEN_0FXOP_09_80
,
1861 VEX_W_0F41_P_0_LEN_1
,
1862 VEX_W_0F41_P_2_LEN_1
,
1863 VEX_W_0F42_P_0_LEN_1
,
1864 VEX_W_0F42_P_2_LEN_1
,
1865 VEX_W_0F44_P_0_LEN_0
,
1866 VEX_W_0F44_P_2_LEN_0
,
1867 VEX_W_0F45_P_0_LEN_1
,
1868 VEX_W_0F45_P_2_LEN_1
,
1869 VEX_W_0F46_P_0_LEN_1
,
1870 VEX_W_0F46_P_2_LEN_1
,
1871 VEX_W_0F47_P_0_LEN_1
,
1872 VEX_W_0F47_P_2_LEN_1
,
1873 VEX_W_0F4A_P_0_LEN_1
,
1874 VEX_W_0F4A_P_2_LEN_1
,
1875 VEX_W_0F4B_P_0_LEN_1
,
1876 VEX_W_0F4B_P_2_LEN_1
,
1956 VEX_W_0F90_P_0_LEN_0
,
1957 VEX_W_0F90_P_2_LEN_0
,
1958 VEX_W_0F91_P_0_LEN_0
,
1959 VEX_W_0F91_P_2_LEN_0
,
1960 VEX_W_0F92_P_0_LEN_0
,
1961 VEX_W_0F92_P_2_LEN_0
,
1962 VEX_W_0F92_P_3_LEN_0
,
1963 VEX_W_0F93_P_0_LEN_0
,
1964 VEX_W_0F93_P_2_LEN_0
,
1965 VEX_W_0F93_P_3_LEN_0
,
1966 VEX_W_0F98_P_0_LEN_0
,
1967 VEX_W_0F98_P_2_LEN_0
,
1968 VEX_W_0F99_P_0_LEN_0
,
1969 VEX_W_0F99_P_2_LEN_0
,
2048 VEX_W_0F381A_P_2_M_0
,
2060 VEX_W_0F382A_P_2_M_0
,
2062 VEX_W_0F382C_P_2_M_0
,
2063 VEX_W_0F382D_P_2_M_0
,
2064 VEX_W_0F382E_P_2_M_0
,
2065 VEX_W_0F382F_P_2_M_0
,
2087 VEX_W_0F385A_P_2_M_0
,
2115 VEX_W_0F3A30_P_2_LEN_0
,
2116 VEX_W_0F3A31_P_2_LEN_0
,
2117 VEX_W_0F3A32_P_2_LEN_0
,
2118 VEX_W_0F3A33_P_2_LEN_0
,
2138 EVEX_W_0F10_P_1_M_0
,
2139 EVEX_W_0F10_P_1_M_1
,
2141 EVEX_W_0F10_P_3_M_0
,
2142 EVEX_W_0F10_P_3_M_1
,
2144 EVEX_W_0F11_P_1_M_0
,
2145 EVEX_W_0F11_P_1_M_1
,
2147 EVEX_W_0F11_P_3_M_0
,
2148 EVEX_W_0F11_P_3_M_1
,
2149 EVEX_W_0F12_P_0_M_0
,
2150 EVEX_W_0F12_P_0_M_1
,
2160 EVEX_W_0F16_P_0_M_0
,
2161 EVEX_W_0F16_P_0_M_1
,
2232 EVEX_W_0F72_R_2_P_2
,
2233 EVEX_W_0F72_R_6_P_2
,
2234 EVEX_W_0F73_R_2_P_2
,
2235 EVEX_W_0F73_R_6_P_2
,
2335 EVEX_W_0F38C7_R_1_P_2
,
2336 EVEX_W_0F38C7_R_2_P_2
,
2337 EVEX_W_0F38C7_R_5_P_2
,
2338 EVEX_W_0F38C7_R_6_P_2
,
2373 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
2382 unsigned int prefix_requirement
;
2385 /* Upper case letters in the instruction names here are macros.
2386 'A' => print 'b' if no register operands or suffix_always is true
2387 'B' => print 'b' if suffix_always is true
2388 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
2390 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
2391 suffix_always is true
2392 'E' => print 'e' if 32-bit form of jcxz
2393 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
2394 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
2395 'H' => print ",pt" or ",pn" branch hint
2396 'I' => honor following macro letter even in Intel mode (implemented only
2397 for some of the macro letters)
2399 'K' => print 'd' or 'q' if rex prefix is present.
2400 'L' => print 'l' if suffix_always is true
2401 'M' => print 'r' if intel_mnemonic is false.
2402 'N' => print 'n' if instruction has no wait "prefix"
2403 'O' => print 'd' or 'o' (or 'q' in Intel mode)
2404 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
2405 or suffix_always is true. print 'q' if rex prefix is present.
2406 'Q' => print 'w', 'l' or 'q' for memory operand or suffix_always
2408 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
2409 'S' => print 'w', 'l' or 'q' if suffix_always is true
2410 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
2411 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
2412 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
2413 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
2414 'X' => print 's', 'd' depending on data16 prefix (for XMM)
2415 'Y' => 'q' if instruction has an REX 64bit overwrite prefix and
2416 suffix_always is true.
2417 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
2418 '!' => change condition from true to false or from false to true.
2419 '%' => add 1 upper case letter to the macro.
2421 2 upper case letter macros:
2422 "XY" => print 'x' or 'y' if no register operands or suffix_always
2424 "XW" => print 's', 'd' depending on the VEX.W bit (for FMA)
2425 "LQ" => print 'l' ('d' in Intel mode) or 'q' for memory operand
2426 or suffix_always is true
2427 "LB" => print "abs" in 64bit mode and behave as 'B' otherwise
2428 "LS" => print "abs" in 64bit mode and behave as 'S' otherwise
2429 "LV" => print "abs" for 64bit operand and behave as 'S' otherwise
2430 "LW" => print 'd', 'q' depending on the VEX.W bit
2431 "LP" => print 'w' or 'l' ('d' in Intel mode) if instruction has
2432 an operand size prefix, or suffix_always is true. print
2433 'q' if rex prefix is present.
2435 Many of the above letters print nothing in Intel mode. See "putop"
2438 Braces '{' and '}', and vertical bars '|', indicate alternative
2439 mnemonic strings for AT&T and Intel. */
2441 static const struct dis386 dis386
[] = {
2443 { "addB", { Ebh1
, Gb
}, 0 },
2444 { "addS", { Evh1
, Gv
}, 0 },
2445 { "addB", { Gb
, EbS
}, 0 },
2446 { "addS", { Gv
, EvS
}, 0 },
2447 { "addB", { AL
, Ib
}, 0 },
2448 { "addS", { eAX
, Iv
}, 0 },
2449 { X86_64_TABLE (X86_64_06
) },
2450 { X86_64_TABLE (X86_64_07
) },
2452 { "orB", { Ebh1
, Gb
}, 0 },
2453 { "orS", { Evh1
, Gv
}, 0 },
2454 { "orB", { Gb
, EbS
}, 0 },
2455 { "orS", { Gv
, EvS
}, 0 },
2456 { "orB", { AL
, Ib
}, 0 },
2457 { "orS", { eAX
, Iv
}, 0 },
2458 { X86_64_TABLE (X86_64_0D
) },
2459 { Bad_Opcode
}, /* 0x0f extended opcode escape */
2461 { "adcB", { Ebh1
, Gb
}, 0 },
2462 { "adcS", { Evh1
, Gv
}, 0 },
2463 { "adcB", { Gb
, EbS
}, 0 },
2464 { "adcS", { Gv
, EvS
}, 0 },
2465 { "adcB", { AL
, Ib
}, 0 },
2466 { "adcS", { eAX
, Iv
}, 0 },
2467 { X86_64_TABLE (X86_64_16
) },
2468 { X86_64_TABLE (X86_64_17
) },
2470 { "sbbB", { Ebh1
, Gb
}, 0 },
2471 { "sbbS", { Evh1
, Gv
}, 0 },
2472 { "sbbB", { Gb
, EbS
}, 0 },
2473 { "sbbS", { Gv
, EvS
}, 0 },
2474 { "sbbB", { AL
, Ib
}, 0 },
2475 { "sbbS", { eAX
, Iv
}, 0 },
2476 { X86_64_TABLE (X86_64_1E
) },
2477 { X86_64_TABLE (X86_64_1F
) },
2479 { "andB", { Ebh1
, Gb
}, 0 },
2480 { "andS", { Evh1
, Gv
}, 0 },
2481 { "andB", { Gb
, EbS
}, 0 },
2482 { "andS", { Gv
, EvS
}, 0 },
2483 { "andB", { AL
, Ib
}, 0 },
2484 { "andS", { eAX
, Iv
}, 0 },
2485 { Bad_Opcode
}, /* SEG ES prefix */
2486 { X86_64_TABLE (X86_64_27
) },
2488 { "subB", { Ebh1
, Gb
}, 0 },
2489 { "subS", { Evh1
, Gv
}, 0 },
2490 { "subB", { Gb
, EbS
}, 0 },
2491 { "subS", { Gv
, EvS
}, 0 },
2492 { "subB", { AL
, Ib
}, 0 },
2493 { "subS", { eAX
, Iv
}, 0 },
2494 { Bad_Opcode
}, /* SEG CS prefix */
2495 { X86_64_TABLE (X86_64_2F
) },
2497 { "xorB", { Ebh1
, Gb
}, 0 },
2498 { "xorS", { Evh1
, Gv
}, 0 },
2499 { "xorB", { Gb
, EbS
}, 0 },
2500 { "xorS", { Gv
, EvS
}, 0 },
2501 { "xorB", { AL
, Ib
}, 0 },
2502 { "xorS", { eAX
, Iv
}, 0 },
2503 { Bad_Opcode
}, /* SEG SS prefix */
2504 { X86_64_TABLE (X86_64_37
) },
2506 { "cmpB", { Eb
, Gb
}, 0 },
2507 { "cmpS", { Ev
, Gv
}, 0 },
2508 { "cmpB", { Gb
, EbS
}, 0 },
2509 { "cmpS", { Gv
, EvS
}, 0 },
2510 { "cmpB", { AL
, Ib
}, 0 },
2511 { "cmpS", { eAX
, Iv
}, 0 },
2512 { Bad_Opcode
}, /* SEG DS prefix */
2513 { X86_64_TABLE (X86_64_3F
) },
2515 { "inc{S|}", { RMeAX
}, 0 },
2516 { "inc{S|}", { RMeCX
}, 0 },
2517 { "inc{S|}", { RMeDX
}, 0 },
2518 { "inc{S|}", { RMeBX
}, 0 },
2519 { "inc{S|}", { RMeSP
}, 0 },
2520 { "inc{S|}", { RMeBP
}, 0 },
2521 { "inc{S|}", { RMeSI
}, 0 },
2522 { "inc{S|}", { RMeDI
}, 0 },
2524 { "dec{S|}", { RMeAX
}, 0 },
2525 { "dec{S|}", { RMeCX
}, 0 },
2526 { "dec{S|}", { RMeDX
}, 0 },
2527 { "dec{S|}", { RMeBX
}, 0 },
2528 { "dec{S|}", { RMeSP
}, 0 },
2529 { "dec{S|}", { RMeBP
}, 0 },
2530 { "dec{S|}", { RMeSI
}, 0 },
2531 { "dec{S|}", { RMeDI
}, 0 },
2533 { "pushV", { RMrAX
}, 0 },
2534 { "pushV", { RMrCX
}, 0 },
2535 { "pushV", { RMrDX
}, 0 },
2536 { "pushV", { RMrBX
}, 0 },
2537 { "pushV", { RMrSP
}, 0 },
2538 { "pushV", { RMrBP
}, 0 },
2539 { "pushV", { RMrSI
}, 0 },
2540 { "pushV", { RMrDI
}, 0 },
2542 { "popV", { RMrAX
}, 0 },
2543 { "popV", { RMrCX
}, 0 },
2544 { "popV", { RMrDX
}, 0 },
2545 { "popV", { RMrBX
}, 0 },
2546 { "popV", { RMrSP
}, 0 },
2547 { "popV", { RMrBP
}, 0 },
2548 { "popV", { RMrSI
}, 0 },
2549 { "popV", { RMrDI
}, 0 },
2551 { X86_64_TABLE (X86_64_60
) },
2552 { X86_64_TABLE (X86_64_61
) },
2553 { X86_64_TABLE (X86_64_62
) },
2554 { X86_64_TABLE (X86_64_63
) },
2555 { Bad_Opcode
}, /* seg fs */
2556 { Bad_Opcode
}, /* seg gs */
2557 { Bad_Opcode
}, /* op size prefix */
2558 { Bad_Opcode
}, /* adr size prefix */
2560 { "pushT", { sIv
}, 0 },
2561 { "imulS", { Gv
, Ev
, Iv
}, 0 },
2562 { "pushT", { sIbT
}, 0 },
2563 { "imulS", { Gv
, Ev
, sIb
}, 0 },
2564 { "ins{b|}", { Ybr
, indirDX
}, 0 },
2565 { X86_64_TABLE (X86_64_6D
) },
2566 { "outs{b|}", { indirDXr
, Xb
}, 0 },
2567 { X86_64_TABLE (X86_64_6F
) },
2569 { "joH", { Jb
, BND
, cond_jump_flag
}, 0 },
2570 { "jnoH", { Jb
, BND
, cond_jump_flag
}, 0 },
2571 { "jbH", { Jb
, BND
, cond_jump_flag
}, 0 },
2572 { "jaeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2573 { "jeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2574 { "jneH", { Jb
, BND
, cond_jump_flag
}, 0 },
2575 { "jbeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2576 { "jaH", { Jb
, BND
, cond_jump_flag
}, 0 },
2578 { "jsH", { Jb
, BND
, cond_jump_flag
}, 0 },
2579 { "jnsH", { Jb
, BND
, cond_jump_flag
}, 0 },
2580 { "jpH", { Jb
, BND
, cond_jump_flag
}, 0 },
2581 { "jnpH", { Jb
, BND
, cond_jump_flag
}, 0 },
2582 { "jlH", { Jb
, BND
, cond_jump_flag
}, 0 },
2583 { "jgeH", { Jb
, BND
, cond_jump_flag
}, 0 },
2584 { "jleH", { Jb
, BND
, cond_jump_flag
}, 0 },
2585 { "jgH", { Jb
, BND
, cond_jump_flag
}, 0 },
2587 { REG_TABLE (REG_80
) },
2588 { REG_TABLE (REG_81
) },
2590 { REG_TABLE (REG_82
) },
2591 { "testB", { Eb
, Gb
}, 0 },
2592 { "testS", { Ev
, Gv
}, 0 },
2593 { "xchgB", { Ebh2
, Gb
}, 0 },
2594 { "xchgS", { Evh2
, Gv
}, 0 },
2596 { "movB", { Ebh3
, Gb
}, 0 },
2597 { "movS", { Evh3
, Gv
}, 0 },
2598 { "movB", { Gb
, EbS
}, 0 },
2599 { "movS", { Gv
, EvS
}, 0 },
2600 { "movD", { Sv
, Sw
}, 0 },
2601 { MOD_TABLE (MOD_8D
) },
2602 { "movD", { Sw
, Sv
}, 0 },
2603 { REG_TABLE (REG_8F
) },
2605 { PREFIX_TABLE (PREFIX_90
) },
2606 { "xchgS", { RMeCX
, eAX
}, 0 },
2607 { "xchgS", { RMeDX
, eAX
}, 0 },
2608 { "xchgS", { RMeBX
, eAX
}, 0 },
2609 { "xchgS", { RMeSP
, eAX
}, 0 },
2610 { "xchgS", { RMeBP
, eAX
}, 0 },
2611 { "xchgS", { RMeSI
, eAX
}, 0 },
2612 { "xchgS", { RMeDI
, eAX
}, 0 },
2614 { "cW{t|}R", { XX
}, 0 },
2615 { "cR{t|}O", { XX
}, 0 },
2616 { X86_64_TABLE (X86_64_9A
) },
2617 { Bad_Opcode
}, /* fwait */
2618 { "pushfT", { XX
}, 0 },
2619 { "popfT", { XX
}, 0 },
2620 { "sahf", { XX
}, 0 },
2621 { "lahf", { XX
}, 0 },
2623 { "mov%LB", { AL
, Ob
}, 0 },
2624 { "mov%LS", { eAX
, Ov
}, 0 },
2625 { "mov%LB", { Ob
, AL
}, 0 },
2626 { "mov%LS", { Ov
, eAX
}, 0 },
2627 { "movs{b|}", { Ybr
, Xb
}, 0 },
2628 { "movs{R|}", { Yvr
, Xv
}, 0 },
2629 { "cmps{b|}", { Xb
, Yb
}, 0 },
2630 { "cmps{R|}", { Xv
, Yv
}, 0 },
2632 { "testB", { AL
, Ib
}, 0 },
2633 { "testS", { eAX
, Iv
}, 0 },
2634 { "stosB", { Ybr
, AL
}, 0 },
2635 { "stosS", { Yvr
, eAX
}, 0 },
2636 { "lodsB", { ALr
, Xb
}, 0 },
2637 { "lodsS", { eAXr
, Xv
}, 0 },
2638 { "scasB", { AL
, Yb
}, 0 },
2639 { "scasS", { eAX
, Yv
}, 0 },
2641 { "movB", { RMAL
, Ib
}, 0 },
2642 { "movB", { RMCL
, Ib
}, 0 },
2643 { "movB", { RMDL
, Ib
}, 0 },
2644 { "movB", { RMBL
, Ib
}, 0 },
2645 { "movB", { RMAH
, Ib
}, 0 },
2646 { "movB", { RMCH
, Ib
}, 0 },
2647 { "movB", { RMDH
, Ib
}, 0 },
2648 { "movB", { RMBH
, Ib
}, 0 },
2650 { "mov%LV", { RMeAX
, Iv64
}, 0 },
2651 { "mov%LV", { RMeCX
, Iv64
}, 0 },
2652 { "mov%LV", { RMeDX
, Iv64
}, 0 },
2653 { "mov%LV", { RMeBX
, Iv64
}, 0 },
2654 { "mov%LV", { RMeSP
, Iv64
}, 0 },
2655 { "mov%LV", { RMeBP
, Iv64
}, 0 },
2656 { "mov%LV", { RMeSI
, Iv64
}, 0 },
2657 { "mov%LV", { RMeDI
, Iv64
}, 0 },
2659 { REG_TABLE (REG_C0
) },
2660 { REG_TABLE (REG_C1
) },
2661 { "retT", { Iw
, BND
}, 0 },
2662 { "retT", { BND
}, 0 },
2663 { X86_64_TABLE (X86_64_C4
) },
2664 { X86_64_TABLE (X86_64_C5
) },
2665 { REG_TABLE (REG_C6
) },
2666 { REG_TABLE (REG_C7
) },
2668 { "enterT", { Iw
, Ib
}, 0 },
2669 { "leaveT", { XX
}, 0 },
2670 { "Jret{|f}P", { Iw
}, 0 },
2671 { "Jret{|f}P", { XX
}, 0 },
2672 { "int3", { XX
}, 0 },
2673 { "int", { Ib
}, 0 },
2674 { X86_64_TABLE (X86_64_CE
) },
2675 { "iret%LP", { XX
}, 0 },
2677 { REG_TABLE (REG_D0
) },
2678 { REG_TABLE (REG_D1
) },
2679 { REG_TABLE (REG_D2
) },
2680 { REG_TABLE (REG_D3
) },
2681 { X86_64_TABLE (X86_64_D4
) },
2682 { X86_64_TABLE (X86_64_D5
) },
2684 { "xlat", { DSBX
}, 0 },
2695 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2696 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2697 { "loopFH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2698 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
}, 0 },
2699 { "inB", { AL
, Ib
}, 0 },
2700 { "inG", { zAX
, Ib
}, 0 },
2701 { "outB", { Ib
, AL
}, 0 },
2702 { "outG", { Ib
, zAX
}, 0 },
2704 { "callT", { Jv
, BND
}, 0 },
2705 { "jmpT", { Jv
, BND
}, 0 },
2706 { X86_64_TABLE (X86_64_EA
) },
2707 { "jmp", { Jb
, BND
}, 0 },
2708 { "inB", { AL
, indirDX
}, 0 },
2709 { "inG", { zAX
, indirDX
}, 0 },
2710 { "outB", { indirDX
, AL
}, 0 },
2711 { "outG", { indirDX
, zAX
}, 0 },
2713 { Bad_Opcode
}, /* lock prefix */
2714 { "icebp", { XX
}, 0 },
2715 { Bad_Opcode
}, /* repne */
2716 { Bad_Opcode
}, /* repz */
2717 { "hlt", { XX
}, 0 },
2718 { "cmc", { XX
}, 0 },
2719 { REG_TABLE (REG_F6
) },
2720 { REG_TABLE (REG_F7
) },
2722 { "clc", { XX
}, 0 },
2723 { "stc", { XX
}, 0 },
2724 { "cli", { XX
}, 0 },
2725 { "sti", { XX
}, 0 },
2726 { "cld", { XX
}, 0 },
2727 { "std", { XX
}, 0 },
2728 { REG_TABLE (REG_FE
) },
2729 { REG_TABLE (REG_FF
) },
2732 static const struct dis386 dis386_twobyte
[] = {
2734 { REG_TABLE (REG_0F00
) },
2735 { REG_TABLE (REG_0F01
) },
2736 { "larS", { Gv
, Ew
}, 0 },
2737 { "lslS", { Gv
, Ew
}, 0 },
2739 { "syscall", { XX
}, 0 },
2740 { "clts", { XX
}, 0 },
2741 { "sysret%LP", { XX
}, 0 },
2743 { "invd", { XX
}, 0 },
2744 { "wbinvd", { XX
}, 0 },
2746 { "ud2", { XX
}, 0 },
2748 { REG_TABLE (REG_0F0D
) },
2749 { "femms", { XX
}, 0 },
2750 { "", { MX
, EM
, OPSUF
}, 0 }, /* See OP_3DNowSuffix. */
2752 { PREFIX_TABLE (PREFIX_0F10
) },
2753 { PREFIX_TABLE (PREFIX_0F11
) },
2754 { PREFIX_TABLE (PREFIX_0F12
) },
2755 { MOD_TABLE (MOD_0F13
) },
2756 { "unpcklpX", { XM
, EXx
}, PREFIX_OPCODE
},
2757 { "unpckhpX", { XM
, EXx
}, PREFIX_OPCODE
},
2758 { PREFIX_TABLE (PREFIX_0F16
) },
2759 { MOD_TABLE (MOD_0F17
) },
2761 { REG_TABLE (REG_0F18
) },
2762 { "nopQ", { Ev
}, 0 },
2763 { PREFIX_TABLE (PREFIX_0F1A
) },
2764 { PREFIX_TABLE (PREFIX_0F1B
) },
2765 { "nopQ", { Ev
}, 0 },
2766 { "nopQ", { Ev
}, 0 },
2767 { "nopQ", { Ev
}, 0 },
2768 { "nopQ", { Ev
}, 0 },
2770 { "movZ", { Rm
, Cm
}, 0 },
2771 { "movZ", { Rm
, Dm
}, 0 },
2772 { "movZ", { Cm
, Rm
}, 0 },
2773 { "movZ", { Dm
, Rm
}, 0 },
2774 { MOD_TABLE (MOD_0F24
) },
2776 { MOD_TABLE (MOD_0F26
) },
2779 { "movapX", { XM
, EXx
}, PREFIX_OPCODE
},
2780 { "movapX", { EXxS
, XM
}, PREFIX_OPCODE
},
2781 { PREFIX_TABLE (PREFIX_0F2A
) },
2782 { PREFIX_TABLE (PREFIX_0F2B
) },
2783 { PREFIX_TABLE (PREFIX_0F2C
) },
2784 { PREFIX_TABLE (PREFIX_0F2D
) },
2785 { PREFIX_TABLE (PREFIX_0F2E
) },
2786 { PREFIX_TABLE (PREFIX_0F2F
) },
2788 { "wrmsr", { XX
}, 0 },
2789 { "rdtsc", { XX
}, 0 },
2790 { "rdmsr", { XX
}, 0 },
2791 { "rdpmc", { XX
}, 0 },
2792 { "sysenter", { XX
}, 0 },
2793 { "sysexit", { XX
}, 0 },
2795 { "getsec", { XX
}, 0 },
2797 { THREE_BYTE_TABLE_PREFIX (THREE_BYTE_0F38
, PREFIX_OPCODE
) },
2799 { THREE_BYTE_TABLE_PREFIX (THREE_BYTE_0F3A
, PREFIX_OPCODE
) },
2806 { "cmovoS", { Gv
, Ev
}, 0 },
2807 { "cmovnoS", { Gv
, Ev
}, 0 },
2808 { "cmovbS", { Gv
, Ev
}, 0 },
2809 { "cmovaeS", { Gv
, Ev
}, 0 },
2810 { "cmoveS", { Gv
, Ev
}, 0 },
2811 { "cmovneS", { Gv
, Ev
}, 0 },
2812 { "cmovbeS", { Gv
, Ev
}, 0 },
2813 { "cmovaS", { Gv
, Ev
}, 0 },
2815 { "cmovsS", { Gv
, Ev
}, 0 },
2816 { "cmovnsS", { Gv
, Ev
}, 0 },
2817 { "cmovpS", { Gv
, Ev
}, 0 },
2818 { "cmovnpS", { Gv
, Ev
}, 0 },
2819 { "cmovlS", { Gv
, Ev
}, 0 },
2820 { "cmovgeS", { Gv
, Ev
}, 0 },
2821 { "cmovleS", { Gv
, Ev
}, 0 },
2822 { "cmovgS", { Gv
, Ev
}, 0 },
2824 { MOD_TABLE (MOD_0F51
) },
2825 { PREFIX_TABLE (PREFIX_0F51
) },
2826 { PREFIX_TABLE (PREFIX_0F52
) },
2827 { PREFIX_TABLE (PREFIX_0F53
) },
2828 { "andpX", { XM
, EXx
}, PREFIX_OPCODE
},
2829 { "andnpX", { XM
, EXx
}, PREFIX_OPCODE
},
2830 { "orpX", { XM
, EXx
}, PREFIX_OPCODE
},
2831 { "xorpX", { XM
, EXx
}, PREFIX_OPCODE
},
2833 { PREFIX_TABLE (PREFIX_0F58
) },
2834 { PREFIX_TABLE (PREFIX_0F59
) },
2835 { PREFIX_TABLE (PREFIX_0F5A
) },
2836 { PREFIX_TABLE (PREFIX_0F5B
) },
2837 { PREFIX_TABLE (PREFIX_0F5C
) },
2838 { PREFIX_TABLE (PREFIX_0F5D
) },
2839 { PREFIX_TABLE (PREFIX_0F5E
) },
2840 { PREFIX_TABLE (PREFIX_0F5F
) },
2842 { PREFIX_TABLE (PREFIX_0F60
) },
2843 { PREFIX_TABLE (PREFIX_0F61
) },
2844 { PREFIX_TABLE (PREFIX_0F62
) },
2845 { "packsswb", { MX
, EM
}, PREFIX_OPCODE
},
2846 { "pcmpgtb", { MX
, EM
}, PREFIX_OPCODE
},
2847 { "pcmpgtw", { MX
, EM
}, PREFIX_OPCODE
},
2848 { "pcmpgtd", { MX
, EM
}, PREFIX_OPCODE
},
2849 { "packuswb", { MX
, EM
}, PREFIX_OPCODE
},
2851 { "punpckhbw", { MX
, EM
}, PREFIX_OPCODE
},
2852 { "punpckhwd", { MX
, EM
}, PREFIX_OPCODE
},
2853 { "punpckhdq", { MX
, EM
}, PREFIX_OPCODE
},
2854 { "packssdw", { MX
, EM
}, PREFIX_OPCODE
},
2855 { PREFIX_TABLE (PREFIX_0F6C
) },
2856 { PREFIX_TABLE (PREFIX_0F6D
) },
2857 { "movK", { MX
, Edq
}, PREFIX_OPCODE
},
2858 { PREFIX_TABLE (PREFIX_0F6F
) },
2860 { PREFIX_TABLE (PREFIX_0F70
) },
2861 { REG_TABLE (REG_0F71
) },
2862 { REG_TABLE (REG_0F72
) },
2863 { REG_TABLE (REG_0F73
) },
2864 { "pcmpeqb", { MX
, EM
}, PREFIX_OPCODE
},
2865 { "pcmpeqw", { MX
, EM
}, PREFIX_OPCODE
},
2866 { "pcmpeqd", { MX
, EM
}, PREFIX_OPCODE
},
2867 { "emms", { XX
}, PREFIX_OPCODE
},
2869 { PREFIX_TABLE (PREFIX_0F78
) },
2870 { PREFIX_TABLE (PREFIX_0F79
) },
2871 { THREE_BYTE_TABLE (THREE_BYTE_0F7A
) },
2873 { PREFIX_TABLE (PREFIX_0F7C
) },
2874 { PREFIX_TABLE (PREFIX_0F7D
) },
2875 { PREFIX_TABLE (PREFIX_0F7E
) },
2876 { PREFIX_TABLE (PREFIX_0F7F
) },
2878 { "joH", { Jv
, BND
, cond_jump_flag
}, 0 },
2879 { "jnoH", { Jv
, BND
, cond_jump_flag
}, 0 },
2880 { "jbH", { Jv
, BND
, cond_jump_flag
}, 0 },
2881 { "jaeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2882 { "jeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2883 { "jneH", { Jv
, BND
, cond_jump_flag
}, 0 },
2884 { "jbeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2885 { "jaH", { Jv
, BND
, cond_jump_flag
}, 0 },
2887 { "jsH", { Jv
, BND
, cond_jump_flag
}, 0 },
2888 { "jnsH", { Jv
, BND
, cond_jump_flag
}, 0 },
2889 { "jpH", { Jv
, BND
, cond_jump_flag
}, 0 },
2890 { "jnpH", { Jv
, BND
, cond_jump_flag
}, 0 },
2891 { "jlH", { Jv
, BND
, cond_jump_flag
}, 0 },
2892 { "jgeH", { Jv
, BND
, cond_jump_flag
}, 0 },
2893 { "jleH", { Jv
, BND
, cond_jump_flag
}, 0 },
2894 { "jgH", { Jv
, BND
, cond_jump_flag
}, 0 },
2896 { "seto", { Eb
}, 0 },
2897 { "setno", { Eb
}, 0 },
2898 { "setb", { Eb
}, 0 },
2899 { "setae", { Eb
}, 0 },
2900 { "sete", { Eb
}, 0 },
2901 { "setne", { Eb
}, 0 },
2902 { "setbe", { Eb
}, 0 },
2903 { "seta", { Eb
}, 0 },
2905 { "sets", { Eb
}, 0 },
2906 { "setns", { Eb
}, 0 },
2907 { "setp", { Eb
}, 0 },
2908 { "setnp", { Eb
}, 0 },
2909 { "setl", { Eb
}, 0 },
2910 { "setge", { Eb
}, 0 },
2911 { "setle", { Eb
}, 0 },
2912 { "setg", { Eb
}, 0 },
2914 { "pushT", { fs
}, 0 },
2915 { "popT", { fs
}, 0 },
2916 { "cpuid", { XX
}, 0 },
2917 { "btS", { Ev
, Gv
}, 0 },
2918 { "shldS", { Ev
, Gv
, Ib
}, 0 },
2919 { "shldS", { Ev
, Gv
, CL
}, 0 },
2920 { REG_TABLE (REG_0FA6
) },
2921 { REG_TABLE (REG_0FA7
) },
2923 { "pushT", { gs
}, 0 },
2924 { "popT", { gs
}, 0 },
2925 { "rsm", { XX
}, 0 },
2926 { "btsS", { Evh1
, Gv
}, 0 },
2927 { "shrdS", { Ev
, Gv
, Ib
}, 0 },
2928 { "shrdS", { Ev
, Gv
, CL
}, 0 },
2929 { REG_TABLE (REG_0FAE
) },
2930 { "imulS", { Gv
, Ev
}, 0 },
2932 { "cmpxchgB", { Ebh1
, Gb
}, 0 },
2933 { "cmpxchgS", { Evh1
, Gv
}, 0 },
2934 { MOD_TABLE (MOD_0FB2
) },
2935 { "btrS", { Evh1
, Gv
}, 0 },
2936 { MOD_TABLE (MOD_0FB4
) },
2937 { MOD_TABLE (MOD_0FB5
) },
2938 { "movz{bR|x}", { Gv
, Eb
}, 0 },
2939 { "movz{wR|x}", { Gv
, Ew
}, 0 }, /* yes, there really is movzww ! */
2941 { PREFIX_TABLE (PREFIX_0FB8
) },
2942 { "ud1", { XX
}, 0 },
2943 { REG_TABLE (REG_0FBA
) },
2944 { "btcS", { Evh1
, Gv
}, 0 },
2945 { PREFIX_TABLE (PREFIX_0FBC
) },
2946 { PREFIX_TABLE (PREFIX_0FBD
) },
2947 { "movs{bR|x}", { Gv
, Eb
}, 0 },
2948 { "movs{wR|x}", { Gv
, Ew
}, 0 }, /* yes, there really is movsww ! */
2950 { "xaddB", { Ebh1
, Gb
}, 0 },
2951 { "xaddS", { Evh1
, Gv
}, 0 },
2952 { PREFIX_TABLE (PREFIX_0FC2
) },
2953 { PREFIX_TABLE (PREFIX_0FC3
) },
2954 { "pinsrw", { MX
, Edqw
, Ib
}, PREFIX_OPCODE
},
2955 { "pextrw", { Gdq
, MS
, Ib
}, PREFIX_OPCODE
},
2956 { "shufpX", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
2957 { REG_TABLE (REG_0FC7
) },
2959 { "bswap", { RMeAX
}, 0 },
2960 { "bswap", { RMeCX
}, 0 },
2961 { "bswap", { RMeDX
}, 0 },
2962 { "bswap", { RMeBX
}, 0 },
2963 { "bswap", { RMeSP
}, 0 },
2964 { "bswap", { RMeBP
}, 0 },
2965 { "bswap", { RMeSI
}, 0 },
2966 { "bswap", { RMeDI
}, 0 },
2968 { PREFIX_TABLE (PREFIX_0FD0
) },
2969 { "psrlw", { MX
, EM
}, PREFIX_OPCODE
},
2970 { "psrld", { MX
, EM
}, PREFIX_OPCODE
},
2971 { "psrlq", { MX
, EM
}, PREFIX_OPCODE
},
2972 { "paddq", { MX
, EM
}, PREFIX_OPCODE
},
2973 { "pmullw", { MX
, EM
}, PREFIX_OPCODE
},
2974 { PREFIX_TABLE (PREFIX_0FD6
) },
2975 { MOD_TABLE (MOD_0FD7
) },
2977 { "psubusb", { MX
, EM
}, PREFIX_OPCODE
},
2978 { "psubusw", { MX
, EM
}, PREFIX_OPCODE
},
2979 { "pminub", { MX
, EM
}, PREFIX_OPCODE
},
2980 { "pand", { MX
, EM
}, PREFIX_OPCODE
},
2981 { "paddusb", { MX
, EM
}, PREFIX_OPCODE
},
2982 { "paddusw", { MX
, EM
}, PREFIX_OPCODE
},
2983 { "pmaxub", { MX
, EM
}, PREFIX_OPCODE
},
2984 { "pandn", { MX
, EM
}, PREFIX_OPCODE
},
2986 { "pavgb", { MX
, EM
}, PREFIX_OPCODE
},
2987 { "psraw", { MX
, EM
}, PREFIX_OPCODE
},
2988 { "psrad", { MX
, EM
}, PREFIX_OPCODE
},
2989 { "pavgw", { MX
, EM
}, PREFIX_OPCODE
},
2990 { "pmulhuw", { MX
, EM
}, PREFIX_OPCODE
},
2991 { "pmulhw", { MX
, EM
}, PREFIX_OPCODE
},
2992 { PREFIX_TABLE (PREFIX_0FE6
) },
2993 { PREFIX_TABLE (PREFIX_0FE7
) },
2995 { "psubsb", { MX
, EM
}, PREFIX_OPCODE
},
2996 { "psubsw", { MX
, EM
}, PREFIX_OPCODE
},
2997 { "pminsw", { MX
, EM
}, PREFIX_OPCODE
},
2998 { "por", { MX
, EM
}, PREFIX_OPCODE
},
2999 { "paddsb", { MX
, EM
}, PREFIX_OPCODE
},
3000 { "paddsw", { MX
, EM
}, PREFIX_OPCODE
},
3001 { "pmaxsw", { MX
, EM
}, PREFIX_OPCODE
},
3002 { "pxor", { MX
, EM
}, PREFIX_OPCODE
},
3004 { PREFIX_TABLE (PREFIX_0FF0
) },
3005 { "psllw", { MX
, EM
}, PREFIX_OPCODE
},
3006 { "pslld", { MX
, EM
}, PREFIX_OPCODE
},
3007 { "psllq", { MX
, EM
}, PREFIX_OPCODE
},
3008 { "pmuludq", { MX
, EM
}, PREFIX_OPCODE
},
3009 { "pmaddwd", { MX
, EM
}, PREFIX_OPCODE
},
3010 { "psadbw", { MX
, EM
}, PREFIX_OPCODE
},
3011 { PREFIX_TABLE (PREFIX_0FF7
) },
3013 { "psubb", { MX
, EM
}, PREFIX_OPCODE
},
3014 { "psubw", { MX
, EM
}, PREFIX_OPCODE
},
3015 { "psubd", { MX
, EM
}, PREFIX_OPCODE
},
3016 { "psubq", { MX
, EM
}, PREFIX_OPCODE
},
3017 { "paddb", { MX
, EM
}, PREFIX_OPCODE
},
3018 { "paddw", { MX
, EM
}, PREFIX_OPCODE
},
3019 { "paddd", { MX
, EM
}, PREFIX_OPCODE
},
3023 static const unsigned char onebyte_has_modrm
[256] = {
3024 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3025 /* ------------------------------- */
3026 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
3027 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
3028 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
3029 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
3030 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
3031 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
3032 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
3033 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
3034 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
3035 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
3036 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
3037 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
3038 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
3039 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
3040 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
3041 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
3042 /* ------------------------------- */
3043 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3046 static const unsigned char twobyte_has_modrm
[256] = {
3047 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3048 /* ------------------------------- */
3049 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
3050 /* 10 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 1f */
3051 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
3052 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
3053 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
3054 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
3055 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
3056 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
3057 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
3058 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
3059 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
3060 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
3061 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
3062 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
3063 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
3064 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
3065 /* ------------------------------- */
3066 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
3069 static char obuf
[100];
3071 static char *mnemonicendp
;
3072 static char scratchbuf
[100];
3073 static unsigned char *start_codep
;
3074 static unsigned char *insn_codep
;
3075 static unsigned char *codep
;
3076 static unsigned char *end_codep
;
3077 static int last_lock_prefix
;
3078 static int last_repz_prefix
;
3079 static int last_repnz_prefix
;
3080 static int last_data_prefix
;
3081 static int last_addr_prefix
;
3082 static int last_rex_prefix
;
3083 static int last_seg_prefix
;
3084 static int fwait_prefix
;
3085 /* The active segment register prefix. */
3086 static int active_seg_prefix
;
3087 #define MAX_CODE_LENGTH 15
3088 /* We can up to 14 prefixes since the maximum instruction length is
3090 static int all_prefixes
[MAX_CODE_LENGTH
- 1];
3091 static disassemble_info
*the_info
;
3099 static unsigned char need_modrm
;
3109 int register_specifier
;
3116 int mask_register_specifier
;
3122 static unsigned char need_vex
;
3123 static unsigned char need_vex_reg
;
3124 static unsigned char vex_w_done
;
3132 /* If we are accessing mod/rm/reg without need_modrm set, then the
3133 values are stale. Hitting this abort likely indicates that you
3134 need to update onebyte_has_modrm or twobyte_has_modrm. */
3135 #define MODRM_CHECK if (!need_modrm) abort ()
3137 static const char **names64
;
3138 static const char **names32
;
3139 static const char **names16
;
3140 static const char **names8
;
3141 static const char **names8rex
;
3142 static const char **names_seg
;
3143 static const char *index64
;
3144 static const char *index32
;
3145 static const char **index16
;
3146 static const char **names_bnd
;
3148 static const char *intel_names64
[] = {
3149 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
3150 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
3152 static const char *intel_names32
[] = {
3153 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
3154 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
3156 static const char *intel_names16
[] = {
3157 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
3158 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
3160 static const char *intel_names8
[] = {
3161 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
3163 static const char *intel_names8rex
[] = {
3164 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
3165 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
3167 static const char *intel_names_seg
[] = {
3168 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
3170 static const char *intel_index64
= "riz";
3171 static const char *intel_index32
= "eiz";
3172 static const char *intel_index16
[] = {
3173 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
3176 static const char *att_names64
[] = {
3177 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
3178 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
3180 static const char *att_names32
[] = {
3181 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
3182 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
3184 static const char *att_names16
[] = {
3185 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
3186 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
3188 static const char *att_names8
[] = {
3189 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
3191 static const char *att_names8rex
[] = {
3192 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
3193 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
3195 static const char *att_names_seg
[] = {
3196 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
3198 static const char *att_index64
= "%riz";
3199 static const char *att_index32
= "%eiz";
3200 static const char *att_index16
[] = {
3201 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
3204 static const char **names_mm
;
3205 static const char *intel_names_mm
[] = {
3206 "mm0", "mm1", "mm2", "mm3",
3207 "mm4", "mm5", "mm6", "mm7"
3209 static const char *att_names_mm
[] = {
3210 "%mm0", "%mm1", "%mm2", "%mm3",
3211 "%mm4", "%mm5", "%mm6", "%mm7"
3214 static const char *intel_names_bnd
[] = {
3215 "bnd0", "bnd1", "bnd2", "bnd3"
3218 static const char *att_names_bnd
[] = {
3219 "%bnd0", "%bnd1", "%bnd2", "%bnd3"
3222 static const char **names_xmm
;
3223 static const char *intel_names_xmm
[] = {
3224 "xmm0", "xmm1", "xmm2", "xmm3",
3225 "xmm4", "xmm5", "xmm6", "xmm7",
3226 "xmm8", "xmm9", "xmm10", "xmm11",
3227 "xmm12", "xmm13", "xmm14", "xmm15",
3228 "xmm16", "xmm17", "xmm18", "xmm19",
3229 "xmm20", "xmm21", "xmm22", "xmm23",
3230 "xmm24", "xmm25", "xmm26", "xmm27",
3231 "xmm28", "xmm29", "xmm30", "xmm31"
3233 static const char *att_names_xmm
[] = {
3234 "%xmm0", "%xmm1", "%xmm2", "%xmm3",
3235 "%xmm4", "%xmm5", "%xmm6", "%xmm7",
3236 "%xmm8", "%xmm9", "%xmm10", "%xmm11",
3237 "%xmm12", "%xmm13", "%xmm14", "%xmm15",
3238 "%xmm16", "%xmm17", "%xmm18", "%xmm19",
3239 "%xmm20", "%xmm21", "%xmm22", "%xmm23",
3240 "%xmm24", "%xmm25", "%xmm26", "%xmm27",
3241 "%xmm28", "%xmm29", "%xmm30", "%xmm31"
3244 static const char **names_ymm
;
3245 static const char *intel_names_ymm
[] = {
3246 "ymm0", "ymm1", "ymm2", "ymm3",
3247 "ymm4", "ymm5", "ymm6", "ymm7",
3248 "ymm8", "ymm9", "ymm10", "ymm11",
3249 "ymm12", "ymm13", "ymm14", "ymm15",
3250 "ymm16", "ymm17", "ymm18", "ymm19",
3251 "ymm20", "ymm21", "ymm22", "ymm23",
3252 "ymm24", "ymm25", "ymm26", "ymm27",
3253 "ymm28", "ymm29", "ymm30", "ymm31"
3255 static const char *att_names_ymm
[] = {
3256 "%ymm0", "%ymm1", "%ymm2", "%ymm3",
3257 "%ymm4", "%ymm5", "%ymm6", "%ymm7",
3258 "%ymm8", "%ymm9", "%ymm10", "%ymm11",
3259 "%ymm12", "%ymm13", "%ymm14", "%ymm15",
3260 "%ymm16", "%ymm17", "%ymm18", "%ymm19",
3261 "%ymm20", "%ymm21", "%ymm22", "%ymm23",
3262 "%ymm24", "%ymm25", "%ymm26", "%ymm27",
3263 "%ymm28", "%ymm29", "%ymm30", "%ymm31"
3266 static const char **names_zmm
;
3267 static const char *intel_names_zmm
[] = {
3268 "zmm0", "zmm1", "zmm2", "zmm3",
3269 "zmm4", "zmm5", "zmm6", "zmm7",
3270 "zmm8", "zmm9", "zmm10", "zmm11",
3271 "zmm12", "zmm13", "zmm14", "zmm15",
3272 "zmm16", "zmm17", "zmm18", "zmm19",
3273 "zmm20", "zmm21", "zmm22", "zmm23",
3274 "zmm24", "zmm25", "zmm26", "zmm27",
3275 "zmm28", "zmm29", "zmm30", "zmm31"
3277 static const char *att_names_zmm
[] = {
3278 "%zmm0", "%zmm1", "%zmm2", "%zmm3",
3279 "%zmm4", "%zmm5", "%zmm6", "%zmm7",
3280 "%zmm8", "%zmm9", "%zmm10", "%zmm11",
3281 "%zmm12", "%zmm13", "%zmm14", "%zmm15",
3282 "%zmm16", "%zmm17", "%zmm18", "%zmm19",
3283 "%zmm20", "%zmm21", "%zmm22", "%zmm23",
3284 "%zmm24", "%zmm25", "%zmm26", "%zmm27",
3285 "%zmm28", "%zmm29", "%zmm30", "%zmm31"
3288 static const char **names_mask
;
3289 static const char *intel_names_mask
[] = {
3290 "k0", "k1", "k2", "k3", "k4", "k5", "k6", "k7"
3292 static const char *att_names_mask
[] = {
3293 "%k0", "%k1", "%k2", "%k3", "%k4", "%k5", "%k6", "%k7"
3296 static const char *names_rounding
[] =
3304 static const struct dis386 reg_table
[][8] = {
3307 { "addA", { Ebh1
, Ib
}, 0 },
3308 { "orA", { Ebh1
, Ib
}, 0 },
3309 { "adcA", { Ebh1
, Ib
}, 0 },
3310 { "sbbA", { Ebh1
, Ib
}, 0 },
3311 { "andA", { Ebh1
, Ib
}, 0 },
3312 { "subA", { Ebh1
, Ib
}, 0 },
3313 { "xorA", { Ebh1
, Ib
}, 0 },
3314 { "cmpA", { Eb
, Ib
}, 0 },
3318 { "addQ", { Evh1
, Iv
}, 0 },
3319 { "orQ", { Evh1
, Iv
}, 0 },
3320 { "adcQ", { Evh1
, Iv
}, 0 },
3321 { "sbbQ", { Evh1
, Iv
}, 0 },
3322 { "andQ", { Evh1
, Iv
}, 0 },
3323 { "subQ", { Evh1
, Iv
}, 0 },
3324 { "xorQ", { Evh1
, Iv
}, 0 },
3325 { "cmpQ", { Ev
, Iv
}, 0 },
3329 { "addQ", { Evh1
, sIb
}, 0 },
3330 { "orQ", { Evh1
, sIb
}, 0 },
3331 { "adcQ", { Evh1
, sIb
}, 0 },
3332 { "sbbQ", { Evh1
, sIb
}, 0 },
3333 { "andQ", { Evh1
, sIb
}, 0 },
3334 { "subQ", { Evh1
, sIb
}, 0 },
3335 { "xorQ", { Evh1
, sIb
}, 0 },
3336 { "cmpQ", { Ev
, sIb
}, 0 },
3340 { "popU", { stackEv
}, 0 },
3341 { XOP_8F_TABLE (XOP_09
) },
3345 { XOP_8F_TABLE (XOP_09
) },
3349 { "rolA", { Eb
, Ib
}, 0 },
3350 { "rorA", { Eb
, Ib
}, 0 },
3351 { "rclA", { Eb
, Ib
}, 0 },
3352 { "rcrA", { Eb
, Ib
}, 0 },
3353 { "shlA", { Eb
, Ib
}, 0 },
3354 { "shrA", { Eb
, Ib
}, 0 },
3356 { "sarA", { Eb
, Ib
}, 0 },
3360 { "rolQ", { Ev
, Ib
}, 0 },
3361 { "rorQ", { Ev
, Ib
}, 0 },
3362 { "rclQ", { Ev
, Ib
}, 0 },
3363 { "rcrQ", { Ev
, Ib
}, 0 },
3364 { "shlQ", { Ev
, Ib
}, 0 },
3365 { "shrQ", { Ev
, Ib
}, 0 },
3367 { "sarQ", { Ev
, Ib
}, 0 },
3371 { "movA", { Ebh3
, Ib
}, 0 },
3378 { MOD_TABLE (MOD_C6_REG_7
) },
3382 { "movQ", { Evh3
, Iv
}, 0 },
3389 { MOD_TABLE (MOD_C7_REG_7
) },
3393 { "rolA", { Eb
, I1
}, 0 },
3394 { "rorA", { Eb
, I1
}, 0 },
3395 { "rclA", { Eb
, I1
}, 0 },
3396 { "rcrA", { Eb
, I1
}, 0 },
3397 { "shlA", { Eb
, I1
}, 0 },
3398 { "shrA", { Eb
, I1
}, 0 },
3400 { "sarA", { Eb
, I1
}, 0 },
3404 { "rolQ", { Ev
, I1
}, 0 },
3405 { "rorQ", { Ev
, I1
}, 0 },
3406 { "rclQ", { Ev
, I1
}, 0 },
3407 { "rcrQ", { Ev
, I1
}, 0 },
3408 { "shlQ", { Ev
, I1
}, 0 },
3409 { "shrQ", { Ev
, I1
}, 0 },
3411 { "sarQ", { Ev
, I1
}, 0 },
3415 { "rolA", { Eb
, CL
}, 0 },
3416 { "rorA", { Eb
, CL
}, 0 },
3417 { "rclA", { Eb
, CL
}, 0 },
3418 { "rcrA", { Eb
, CL
}, 0 },
3419 { "shlA", { Eb
, CL
}, 0 },
3420 { "shrA", { Eb
, CL
}, 0 },
3422 { "sarA", { Eb
, CL
}, 0 },
3426 { "rolQ", { Ev
, CL
}, 0 },
3427 { "rorQ", { Ev
, CL
}, 0 },
3428 { "rclQ", { Ev
, CL
}, 0 },
3429 { "rcrQ", { Ev
, CL
}, 0 },
3430 { "shlQ", { Ev
, CL
}, 0 },
3431 { "shrQ", { Ev
, CL
}, 0 },
3433 { "sarQ", { Ev
, CL
}, 0 },
3437 { "testA", { Eb
, Ib
}, 0 },
3439 { "notA", { Ebh1
}, 0 },
3440 { "negA", { Ebh1
}, 0 },
3441 { "mulA", { Eb
}, 0 }, /* Don't print the implicit %al register, */
3442 { "imulA", { Eb
}, 0 }, /* to distinguish these opcodes from other */
3443 { "divA", { Eb
}, 0 }, /* mul/imul opcodes. Do the same for div */
3444 { "idivA", { Eb
}, 0 }, /* and idiv for consistency. */
3448 { "testQ", { Ev
, Iv
}, 0 },
3450 { "notQ", { Evh1
}, 0 },
3451 { "negQ", { Evh1
}, 0 },
3452 { "mulQ", { Ev
}, 0 }, /* Don't print the implicit register. */
3453 { "imulQ", { Ev
}, 0 },
3454 { "divQ", { Ev
}, 0 },
3455 { "idivQ", { Ev
}, 0 },
3459 { "incA", { Ebh1
}, 0 },
3460 { "decA", { Ebh1
}, 0 },
3464 { "incQ", { Evh1
}, 0 },
3465 { "decQ", { Evh1
}, 0 },
3466 { "call{T|}", { indirEv
, BND
}, 0 },
3467 { MOD_TABLE (MOD_FF_REG_3
) },
3468 { "jmp{T|}", { indirEv
, BND
}, 0 },
3469 { MOD_TABLE (MOD_FF_REG_5
) },
3470 { "pushU", { stackEv
}, 0 },
3475 { "sldtD", { Sv
}, 0 },
3476 { "strD", { Sv
}, 0 },
3477 { "lldt", { Ew
}, 0 },
3478 { "ltr", { Ew
}, 0 },
3479 { "verr", { Ew
}, 0 },
3480 { "verw", { Ew
}, 0 },
3486 { MOD_TABLE (MOD_0F01_REG_0
) },
3487 { MOD_TABLE (MOD_0F01_REG_1
) },
3488 { MOD_TABLE (MOD_0F01_REG_2
) },
3489 { MOD_TABLE (MOD_0F01_REG_3
) },
3490 { "smswD", { Sv
}, 0 },
3492 { "lmsw", { Ew
}, 0 },
3493 { MOD_TABLE (MOD_0F01_REG_7
) },
3497 { "prefetch", { Mb
}, 0 },
3498 { "prefetchw", { Mb
}, 0 },
3499 { "prefetchwt1", { Mb
}, 0 },
3500 { "prefetch", { Mb
}, 0 },
3501 { "prefetch", { Mb
}, 0 },
3502 { "prefetch", { Mb
}, 0 },
3503 { "prefetch", { Mb
}, 0 },
3504 { "prefetch", { Mb
}, 0 },
3508 { MOD_TABLE (MOD_0F18_REG_0
) },
3509 { MOD_TABLE (MOD_0F18_REG_1
) },
3510 { MOD_TABLE (MOD_0F18_REG_2
) },
3511 { MOD_TABLE (MOD_0F18_REG_3
) },
3512 { MOD_TABLE (MOD_0F18_REG_4
) },
3513 { MOD_TABLE (MOD_0F18_REG_5
) },
3514 { MOD_TABLE (MOD_0F18_REG_6
) },
3515 { MOD_TABLE (MOD_0F18_REG_7
) },
3521 { MOD_TABLE (MOD_0F71_REG_2
) },
3523 { MOD_TABLE (MOD_0F71_REG_4
) },
3525 { MOD_TABLE (MOD_0F71_REG_6
) },
3531 { MOD_TABLE (MOD_0F72_REG_2
) },
3533 { MOD_TABLE (MOD_0F72_REG_4
) },
3535 { MOD_TABLE (MOD_0F72_REG_6
) },
3541 { MOD_TABLE (MOD_0F73_REG_2
) },
3542 { MOD_TABLE (MOD_0F73_REG_3
) },
3545 { MOD_TABLE (MOD_0F73_REG_6
) },
3546 { MOD_TABLE (MOD_0F73_REG_7
) },
3550 { "montmul", { { OP_0f07
, 0 } }, 0 },
3551 { "xsha1", { { OP_0f07
, 0 } }, 0 },
3552 { "xsha256", { { OP_0f07
, 0 } }, 0 },
3556 { "xstore-rng", { { OP_0f07
, 0 } }, 0 },
3557 { "xcrypt-ecb", { { OP_0f07
, 0 } }, 0 },
3558 { "xcrypt-cbc", { { OP_0f07
, 0 } }, 0 },
3559 { "xcrypt-ctr", { { OP_0f07
, 0 } }, 0 },
3560 { "xcrypt-cfb", { { OP_0f07
, 0 } }, 0 },
3561 { "xcrypt-ofb", { { OP_0f07
, 0 } }, 0 },
3565 { MOD_TABLE (MOD_0FAE_REG_0
) },
3566 { MOD_TABLE (MOD_0FAE_REG_1
) },
3567 { MOD_TABLE (MOD_0FAE_REG_2
) },
3568 { MOD_TABLE (MOD_0FAE_REG_3
) },
3569 { MOD_TABLE (MOD_0FAE_REG_4
) },
3570 { MOD_TABLE (MOD_0FAE_REG_5
) },
3571 { MOD_TABLE (MOD_0FAE_REG_6
) },
3572 { MOD_TABLE (MOD_0FAE_REG_7
) },
3580 { "btQ", { Ev
, Ib
}, 0 },
3581 { "btsQ", { Evh1
, Ib
}, 0 },
3582 { "btrQ", { Evh1
, Ib
}, 0 },
3583 { "btcQ", { Evh1
, Ib
}, 0 },
3588 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} }, 0 },
3590 { MOD_TABLE (MOD_0FC7_REG_3
) },
3591 { MOD_TABLE (MOD_0FC7_REG_4
) },
3592 { MOD_TABLE (MOD_0FC7_REG_5
) },
3593 { MOD_TABLE (MOD_0FC7_REG_6
) },
3594 { MOD_TABLE (MOD_0FC7_REG_7
) },
3600 { MOD_TABLE (MOD_VEX_0F71_REG_2
) },
3602 { MOD_TABLE (MOD_VEX_0F71_REG_4
) },
3604 { MOD_TABLE (MOD_VEX_0F71_REG_6
) },
3610 { MOD_TABLE (MOD_VEX_0F72_REG_2
) },
3612 { MOD_TABLE (MOD_VEX_0F72_REG_4
) },
3614 { MOD_TABLE (MOD_VEX_0F72_REG_6
) },
3620 { MOD_TABLE (MOD_VEX_0F73_REG_2
) },
3621 { MOD_TABLE (MOD_VEX_0F73_REG_3
) },
3624 { MOD_TABLE (MOD_VEX_0F73_REG_6
) },
3625 { MOD_TABLE (MOD_VEX_0F73_REG_7
) },
3631 { MOD_TABLE (MOD_VEX_0FAE_REG_2
) },
3632 { MOD_TABLE (MOD_VEX_0FAE_REG_3
) },
3634 /* REG_VEX_0F38F3 */
3637 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_1
) },
3638 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_2
) },
3639 { PREFIX_TABLE (PREFIX_VEX_0F38F3_REG_3
) },
3643 { "llwpcb", { { OP_LWPCB_E
, 0 } }, 0 },
3644 { "slwpcb", { { OP_LWPCB_E
, 0 } }, 0 },
3648 { "lwpins", { { OP_LWP_E
, 0 }, Ed
, Iq
}, 0 },
3649 { "lwpval", { { OP_LWP_E
, 0 }, Ed
, Iq
}, 0 },
3651 /* REG_XOP_TBM_01 */
3654 { "blcfill", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3655 { "blsfill", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3656 { "blcs", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3657 { "tzmsk", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3658 { "blcic", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3659 { "blsic", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3660 { "t1mskc", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3662 /* REG_XOP_TBM_02 */
3665 { "blcmsk", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3670 { "blci", { { OP_LWP_E
, 0 }, Ev
}, 0 },
3672 #define NEED_REG_TABLE
3673 #include "i386-dis-evex.h"
3674 #undef NEED_REG_TABLE
3677 static const struct dis386 prefix_table
[][4] = {
3680 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} }, 0 },
3681 { "pause", { XX
}, 0 },
3682 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} }, 0 },
3683 { NULL
, { { NULL
, 0 } }, PREFIX_IGNORED
}
3688 { "movups", { XM
, EXx
}, PREFIX_OPCODE
},
3689 { "movss", { XM
, EXd
}, PREFIX_OPCODE
},
3690 { "movupd", { XM
, EXx
}, PREFIX_OPCODE
},
3691 { "movsd", { XM
, EXq
}, PREFIX_OPCODE
},
3696 { "movups", { EXxS
, XM
}, PREFIX_OPCODE
},
3697 { "movss", { EXdS
, XM
}, PREFIX_OPCODE
},
3698 { "movupd", { EXxS
, XM
}, PREFIX_OPCODE
},
3699 { "movsd", { EXqS
, XM
}, PREFIX_OPCODE
},
3704 { MOD_TABLE (MOD_0F12_PREFIX_0
) },
3705 { "movsldup", { XM
, EXx
}, PREFIX_OPCODE
},
3706 { "movlpd", { XM
, EXq
}, PREFIX_OPCODE
},
3707 { "movddup", { XM
, EXq
}, PREFIX_OPCODE
},
3712 { MOD_TABLE (MOD_0F16_PREFIX_0
) },
3713 { "movshdup", { XM
, EXx
}, PREFIX_OPCODE
},
3714 { "movhpd", { XM
, EXq
}, PREFIX_OPCODE
},
3719 { MOD_TABLE (MOD_0F1A_PREFIX_0
) },
3720 { "bndcl", { Gbnd
, Ev_bnd
}, 0 },
3721 { "bndmov", { Gbnd
, Ebnd
}, 0 },
3722 { "bndcu", { Gbnd
, Ev_bnd
}, 0 },
3727 { MOD_TABLE (MOD_0F1B_PREFIX_0
) },
3728 { MOD_TABLE (MOD_0F1B_PREFIX_1
) },
3729 { "bndmov", { Ebnd
, Gbnd
}, 0 },
3730 { "bndcn", { Gbnd
, Ev_bnd
}, 0 },
3735 { "cvtpi2ps", { XM
, EMCq
}, PREFIX_OPCODE
},
3736 { "cvtsi2ss%LQ", { XM
, Ev
}, PREFIX_OPCODE
},
3737 { "cvtpi2pd", { XM
, EMCq
}, PREFIX_OPCODE
},
3738 { "cvtsi2sd%LQ", { XM
, Ev
}, 0 },
3743 { MOD_TABLE (MOD_0F2B_PREFIX_0
) },
3744 { MOD_TABLE (MOD_0F2B_PREFIX_1
) },
3745 { MOD_TABLE (MOD_0F2B_PREFIX_2
) },
3746 { MOD_TABLE (MOD_0F2B_PREFIX_3
) },
3751 { "cvttps2pi", { MXC
, EXq
}, PREFIX_OPCODE
},
3752 { "cvttss2siY", { Gv
, EXd
}, PREFIX_OPCODE
},
3753 { "cvttpd2pi", { MXC
, EXx
}, PREFIX_OPCODE
},
3754 { "cvttsd2siY", { Gv
, EXq
}, PREFIX_OPCODE
},
3759 { "cvtps2pi", { MXC
, EXq
}, PREFIX_OPCODE
},
3760 { "cvtss2siY", { Gv
, EXd
}, PREFIX_OPCODE
},
3761 { "cvtpd2pi", { MXC
, EXx
}, PREFIX_OPCODE
},
3762 { "cvtsd2siY", { Gv
, EXq
}, PREFIX_OPCODE
},
3767 { "ucomiss",{ XM
, EXd
}, 0 },
3769 { "ucomisd",{ XM
, EXq
}, 0 },
3774 { "comiss", { XM
, EXd
}, 0 },
3776 { "comisd", { XM
, EXq
}, 0 },
3781 { "sqrtps", { XM
, EXx
}, PREFIX_OPCODE
},
3782 { "sqrtss", { XM
, EXd
}, PREFIX_OPCODE
},
3783 { "sqrtpd", { XM
, EXx
}, PREFIX_OPCODE
},
3784 { "sqrtsd", { XM
, EXq
}, PREFIX_OPCODE
},
3789 { "rsqrtps",{ XM
, EXx
}, PREFIX_OPCODE
},
3790 { "rsqrtss",{ XM
, EXd
}, PREFIX_OPCODE
},
3795 { "rcpps", { XM
, EXx
}, PREFIX_OPCODE
},
3796 { "rcpss", { XM
, EXd
}, PREFIX_OPCODE
},
3801 { "addps", { XM
, EXx
}, PREFIX_OPCODE
},
3802 { "addss", { XM
, EXd
}, PREFIX_OPCODE
},
3803 { "addpd", { XM
, EXx
}, PREFIX_OPCODE
},
3804 { "addsd", { XM
, EXq
}, PREFIX_OPCODE
},
3809 { "mulps", { XM
, EXx
}, PREFIX_OPCODE
},
3810 { "mulss", { XM
, EXd
}, PREFIX_OPCODE
},
3811 { "mulpd", { XM
, EXx
}, PREFIX_OPCODE
},
3812 { "mulsd", { XM
, EXq
}, PREFIX_OPCODE
},
3817 { "cvtps2pd", { XM
, EXq
}, PREFIX_OPCODE
},
3818 { "cvtss2sd", { XM
, EXd
}, PREFIX_OPCODE
},
3819 { "cvtpd2ps", { XM
, EXx
}, PREFIX_OPCODE
},
3820 { "cvtsd2ss", { XM
, EXq
}, PREFIX_OPCODE
},
3825 { "cvtdq2ps", { XM
, EXx
}, PREFIX_OPCODE
},
3826 { "cvttps2dq", { XM
, EXx
}, PREFIX_OPCODE
},
3827 { "cvtps2dq", { XM
, EXx
}, PREFIX_OPCODE
},
3832 { "subps", { XM
, EXx
}, PREFIX_OPCODE
},
3833 { "subss", { XM
, EXd
}, PREFIX_OPCODE
},
3834 { "subpd", { XM
, EXx
}, PREFIX_OPCODE
},
3835 { "subsd", { XM
, EXq
}, PREFIX_OPCODE
},
3840 { "minps", { XM
, EXx
}, PREFIX_OPCODE
},
3841 { "minss", { XM
, EXd
}, PREFIX_OPCODE
},
3842 { "minpd", { XM
, EXx
}, PREFIX_OPCODE
},
3843 { "minsd", { XM
, EXq
}, PREFIX_OPCODE
},
3848 { "divps", { XM
, EXx
}, PREFIX_OPCODE
},
3849 { "divss", { XM
, EXd
}, PREFIX_OPCODE
},
3850 { "divpd", { XM
, EXx
}, PREFIX_OPCODE
},
3851 { "divsd", { XM
, EXq
}, PREFIX_OPCODE
},
3856 { "maxps", { XM
, EXx
}, PREFIX_OPCODE
},
3857 { "maxss", { XM
, EXd
}, PREFIX_OPCODE
},
3858 { "maxpd", { XM
, EXx
}, PREFIX_OPCODE
},
3859 { "maxsd", { XM
, EXq
}, PREFIX_OPCODE
},
3864 { "punpcklbw",{ MX
, EMd
}, PREFIX_OPCODE
},
3866 { "punpcklbw",{ MX
, EMx
}, PREFIX_OPCODE
},
3871 { "punpcklwd",{ MX
, EMd
}, PREFIX_OPCODE
},
3873 { "punpcklwd",{ MX
, EMx
}, PREFIX_OPCODE
},
3878 { "punpckldq",{ MX
, EMd
}, PREFIX_OPCODE
},
3880 { "punpckldq",{ MX
, EMx
}, PREFIX_OPCODE
},
3887 { "punpcklqdq", { XM
, EXx
}, PREFIX_OPCODE
},
3894 { "punpckhqdq", { XM
, EXx
}, PREFIX_OPCODE
},
3899 { "movq", { MX
, EM
}, PREFIX_OPCODE
},
3900 { "movdqu", { XM
, EXx
}, PREFIX_OPCODE
},
3901 { "movdqa", { XM
, EXx
}, PREFIX_OPCODE
},
3906 { "pshufw", { MX
, EM
, Ib
}, PREFIX_OPCODE
},
3907 { "pshufhw",{ XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3908 { "pshufd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3909 { "pshuflw",{ XM
, EXx
, Ib
}, PREFIX_OPCODE
},
3912 /* PREFIX_0F73_REG_3 */
3916 { "psrldq", { XS
, Ib
}, 0 },
3919 /* PREFIX_0F73_REG_7 */
3923 { "pslldq", { XS
, Ib
}, 0 },
3928 {"vmread", { Em
, Gm
}, 0 },
3930 {"extrq", { XS
, Ib
, Ib
}, 0 },
3931 {"insertq", { XM
, XS
, Ib
, Ib
}, 0 },
3936 {"vmwrite", { Gm
, Em
}, 0 },
3938 {"extrq", { XM
, XS
}, 0 },
3939 {"insertq", { XM
, XS
}, 0 },
3946 { "haddpd", { XM
, EXx
}, PREFIX_OPCODE
},
3947 { "haddps", { XM
, EXx
}, PREFIX_OPCODE
},
3954 { "hsubpd", { XM
, EXx
}, PREFIX_OPCODE
},
3955 { "hsubps", { XM
, EXx
}, PREFIX_OPCODE
},
3960 { "movK", { Edq
, MX
}, PREFIX_OPCODE
},
3961 { "movq", { XM
, EXq
}, PREFIX_OPCODE
},
3962 { "movK", { Edq
, XM
}, PREFIX_OPCODE
},
3967 { "movq", { EMS
, MX
}, PREFIX_OPCODE
},
3968 { "movdqu", { EXxS
, XM
}, PREFIX_OPCODE
},
3969 { "movdqa", { EXxS
, XM
}, PREFIX_OPCODE
},
3972 /* PREFIX_0FAE_REG_0 */
3975 { "rdfsbase", { Ev
}, 0 },
3978 /* PREFIX_0FAE_REG_1 */
3981 { "rdgsbase", { Ev
}, 0 },
3984 /* PREFIX_0FAE_REG_2 */
3987 { "wrfsbase", { Ev
}, 0 },
3990 /* PREFIX_0FAE_REG_3 */
3993 { "wrgsbase", { Ev
}, 0 },
3996 /* PREFIX_0FAE_REG_6 */
3998 { "xsaveopt", { FXSAVE
}, 0 },
4000 { "clwb", { Mb
}, 0 },
4003 /* PREFIX_0FAE_REG_7 */
4005 { "clflush", { Mb
}, 0 },
4007 { "clflushopt", { Mb
}, 0 },
4010 /* PREFIX_RM_0_0FAE_REG_7 */
4012 { "sfence", { Skip_MODRM
}, 0 },
4014 { "pcommit", { Skip_MODRM
}, 0 },
4020 { "popcntS", { Gv
, Ev
}, 0 },
4025 { "bsfS", { Gv
, Ev
}, 0 },
4026 { "tzcntS", { Gv
, Ev
}, 0 },
4027 { "bsfS", { Gv
, Ev
}, 0 },
4032 { "bsrS", { Gv
, Ev
}, 0 },
4033 { "lzcntS", { Gv
, Ev
}, 0 },
4034 { "bsrS", { Gv
, Ev
}, 0 },
4039 { "cmpps", { XM
, EXx
, CMP
}, PREFIX_OPCODE
},
4040 { "cmpss", { XM
, EXd
, CMP
}, PREFIX_OPCODE
},
4041 { "cmppd", { XM
, EXx
, CMP
}, PREFIX_OPCODE
},
4042 { "cmpsd", { XM
, EXq
, CMP
}, PREFIX_OPCODE
},
4047 { "movntiS", { Ma
, Gv
}, PREFIX_OPCODE
},
4050 /* PREFIX_MOD_0_0FC7_REG_6 */
4052 { "vmptrld",{ Mq
}, 0 },
4053 { "vmxon", { Mq
}, 0 },
4054 { "vmclear",{ Mq
}, 0 },
4057 /* PREFIX_MOD_3_0FC7_REG_6 */
4059 { "rdrand", { Ev
}, 0 },
4061 { "rdrand", { Ev
}, 0 }
4064 /* PREFIX_MOD_3_0FC7_REG_7 */
4066 { "rdseed", { Ev
}, 0 },
4068 { "rdseed", { Ev
}, 0 },
4075 { "addsubpd", { XM
, EXx
}, 0 },
4076 { "addsubps", { XM
, EXx
}, 0 },
4082 { "movq2dq",{ XM
, MS
}, 0 },
4083 { "movq", { EXqS
, XM
}, 0 },
4084 { "movdq2q",{ MX
, XS
}, 0 },
4090 { "cvtdq2pd", { XM
, EXq
}, PREFIX_OPCODE
},
4091 { "cvttpd2dq", { XM
, EXx
}, PREFIX_OPCODE
},
4092 { "cvtpd2dq", { XM
, EXx
}, PREFIX_OPCODE
},
4097 { "movntq", { Mq
, MX
}, PREFIX_OPCODE
},
4099 { MOD_TABLE (MOD_0FE7_PREFIX_2
) },
4107 { MOD_TABLE (MOD_0FF0_PREFIX_3
) },
4112 { "maskmovq", { MX
, MS
}, PREFIX_OPCODE
},
4114 { "maskmovdqu", { XM
, XS
}, PREFIX_OPCODE
},
4121 { "pblendvb", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4128 { "blendvps", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4135 { "blendvpd", { XM
, EXx
, XMM0
}, PREFIX_OPCODE
},
4142 { "ptest", { XM
, EXx
}, PREFIX_OPCODE
},
4149 { "pmovsxbw", { XM
, EXq
}, PREFIX_OPCODE
},
4156 { "pmovsxbd", { XM
, EXd
}, PREFIX_OPCODE
},
4163 { "pmovsxbq", { XM
, EXw
}, PREFIX_OPCODE
},
4170 { "pmovsxwd", { XM
, EXq
}, PREFIX_OPCODE
},
4177 { "pmovsxwq", { XM
, EXd
}, PREFIX_OPCODE
},
4184 { "pmovsxdq", { XM
, EXq
}, PREFIX_OPCODE
},
4191 { "pmuldq", { XM
, EXx
}, PREFIX_OPCODE
},
4198 { "pcmpeqq", { XM
, EXx
}, PREFIX_OPCODE
},
4205 { MOD_TABLE (MOD_0F382A_PREFIX_2
) },
4212 { "packusdw", { XM
, EXx
}, PREFIX_OPCODE
},
4219 { "pmovzxbw", { XM
, EXq
}, PREFIX_OPCODE
},
4226 { "pmovzxbd", { XM
, EXd
}, PREFIX_OPCODE
},
4233 { "pmovzxbq", { XM
, EXw
}, PREFIX_OPCODE
},
4240 { "pmovzxwd", { XM
, EXq
}, PREFIX_OPCODE
},
4247 { "pmovzxwq", { XM
, EXd
}, PREFIX_OPCODE
},
4254 { "pmovzxdq", { XM
, EXq
}, PREFIX_OPCODE
},
4261 { "pcmpgtq", { XM
, EXx
}, PREFIX_OPCODE
},
4268 { "pminsb", { XM
, EXx
}, PREFIX_OPCODE
},
4275 { "pminsd", { XM
, EXx
}, PREFIX_OPCODE
},
4282 { "pminuw", { XM
, EXx
}, PREFIX_OPCODE
},
4289 { "pminud", { XM
, EXx
}, PREFIX_OPCODE
},
4296 { "pmaxsb", { XM
, EXx
}, PREFIX_OPCODE
},
4303 { "pmaxsd", { XM
, EXx
}, PREFIX_OPCODE
},
4310 { "pmaxuw", { XM
, EXx
}, PREFIX_OPCODE
},
4317 { "pmaxud", { XM
, EXx
}, PREFIX_OPCODE
},
4324 { "pmulld", { XM
, EXx
}, PREFIX_OPCODE
},
4331 { "phminposuw", { XM
, EXx
}, PREFIX_OPCODE
},
4338 { "invept", { Gm
, Mo
}, PREFIX_OPCODE
},
4345 { "invvpid", { Gm
, Mo
}, PREFIX_OPCODE
},
4352 { "invpcid", { Gm
, M
}, PREFIX_OPCODE
},
4357 { "sha1nexte", { XM
, EXxmm
}, PREFIX_OPCODE
},
4362 { "sha1msg1", { XM
, EXxmm
}, PREFIX_OPCODE
},
4367 { "sha1msg2", { XM
, EXxmm
}, PREFIX_OPCODE
},
4372 { "sha256rnds2", { XM
, EXxmm
, XMM0
}, PREFIX_OPCODE
},
4377 { "sha256msg1", { XM
, EXxmm
}, PREFIX_OPCODE
},
4382 { "sha256msg2", { XM
, EXxmm
}, PREFIX_OPCODE
},
4389 { "aesimc", { XM
, EXx
}, PREFIX_OPCODE
},
4396 { "aesenc", { XM
, EXx
}, PREFIX_OPCODE
},
4403 { "aesenclast", { XM
, EXx
}, PREFIX_OPCODE
},
4410 { "aesdec", { XM
, EXx
}, PREFIX_OPCODE
},
4417 { "aesdeclast", { XM
, EXx
}, PREFIX_OPCODE
},
4422 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4424 { "movbeS", { Gv
, { MOVBE_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4425 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} }, PREFIX_OPCODE
},
4430 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
}, PREFIX_OPCODE
},
4432 { "movbeS", { { MOVBE_Fixup
, v_mode
}, Gv
}, PREFIX_OPCODE
},
4433 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} }, PREFIX_OPCODE
},
4439 { "adoxS", { Gdq
, Edq
}, PREFIX_OPCODE
},
4440 { "adcxS", { Gdq
, Edq
}, PREFIX_OPCODE
},
4448 { "roundps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4455 { "roundpd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4462 { "roundss", { XM
, EXd
, Ib
}, PREFIX_OPCODE
},
4469 { "roundsd", { XM
, EXq
, Ib
}, PREFIX_OPCODE
},
4476 { "blendps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4483 { "blendpd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4490 { "pblendw", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4497 { "pextrb", { Edqb
, XM
, Ib
}, PREFIX_OPCODE
},
4504 { "pextrw", { Edqw
, XM
, Ib
}, PREFIX_OPCODE
},
4511 { "pextrK", { Edq
, XM
, Ib
}, PREFIX_OPCODE
},
4518 { "extractps", { Edqd
, XM
, Ib
}, PREFIX_OPCODE
},
4525 { "pinsrb", { XM
, Edqb
, Ib
}, PREFIX_OPCODE
},
4532 { "insertps", { XM
, EXd
, Ib
}, PREFIX_OPCODE
},
4539 { "pinsrK", { XM
, Edq
, Ib
}, PREFIX_OPCODE
},
4546 { "dpps", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4553 { "dppd", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4560 { "mpsadbw", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4567 { "pclmulqdq", { XM
, EXx
, PCLMUL
}, PREFIX_OPCODE
},
4574 { "pcmpestrm", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4581 { "pcmpestri", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4588 { "pcmpistrm", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4595 { "pcmpistri", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4600 { "sha1rnds4", { XM
, EXxmm
, Ib
}, PREFIX_OPCODE
},
4607 { "aeskeygenassist", { XM
, EXx
, Ib
}, PREFIX_OPCODE
},
4610 /* PREFIX_VEX_0F10 */
4612 { VEX_W_TABLE (VEX_W_0F10_P_0
) },
4613 { VEX_LEN_TABLE (VEX_LEN_0F10_P_1
) },
4614 { VEX_W_TABLE (VEX_W_0F10_P_2
) },
4615 { VEX_LEN_TABLE (VEX_LEN_0F10_P_3
) },
4618 /* PREFIX_VEX_0F11 */
4620 { VEX_W_TABLE (VEX_W_0F11_P_0
) },
4621 { VEX_LEN_TABLE (VEX_LEN_0F11_P_1
) },
4622 { VEX_W_TABLE (VEX_W_0F11_P_2
) },
4623 { VEX_LEN_TABLE (VEX_LEN_0F11_P_3
) },
4626 /* PREFIX_VEX_0F12 */
4628 { MOD_TABLE (MOD_VEX_0F12_PREFIX_0
) },
4629 { VEX_W_TABLE (VEX_W_0F12_P_1
) },
4630 { VEX_LEN_TABLE (VEX_LEN_0F12_P_2
) },
4631 { VEX_W_TABLE (VEX_W_0F12_P_3
) },
4634 /* PREFIX_VEX_0F16 */
4636 { MOD_TABLE (MOD_VEX_0F16_PREFIX_0
) },
4637 { VEX_W_TABLE (VEX_W_0F16_P_1
) },
4638 { VEX_LEN_TABLE (VEX_LEN_0F16_P_2
) },
4641 /* PREFIX_VEX_0F2A */
4644 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_1
) },
4646 { VEX_LEN_TABLE (VEX_LEN_0F2A_P_3
) },
4649 /* PREFIX_VEX_0F2C */
4652 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_1
) },
4654 { VEX_LEN_TABLE (VEX_LEN_0F2C_P_3
) },
4657 /* PREFIX_VEX_0F2D */
4660 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_1
) },
4662 { VEX_LEN_TABLE (VEX_LEN_0F2D_P_3
) },
4665 /* PREFIX_VEX_0F2E */
4667 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_0
) },
4669 { VEX_LEN_TABLE (VEX_LEN_0F2E_P_2
) },
4672 /* PREFIX_VEX_0F2F */
4674 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_0
) },
4676 { VEX_LEN_TABLE (VEX_LEN_0F2F_P_2
) },
4679 /* PREFIX_VEX_0F41 */
4681 { VEX_LEN_TABLE (VEX_LEN_0F41_P_0
) },
4683 { VEX_LEN_TABLE (VEX_LEN_0F41_P_2
) },
4686 /* PREFIX_VEX_0F42 */
4688 { VEX_LEN_TABLE (VEX_LEN_0F42_P_0
) },
4690 { VEX_LEN_TABLE (VEX_LEN_0F42_P_2
) },
4693 /* PREFIX_VEX_0F44 */
4695 { VEX_LEN_TABLE (VEX_LEN_0F44_P_0
) },
4697 { VEX_LEN_TABLE (VEX_LEN_0F44_P_2
) },
4700 /* PREFIX_VEX_0F45 */
4702 { VEX_LEN_TABLE (VEX_LEN_0F45_P_0
) },
4704 { VEX_LEN_TABLE (VEX_LEN_0F45_P_2
) },
4707 /* PREFIX_VEX_0F46 */
4709 { VEX_LEN_TABLE (VEX_LEN_0F46_P_0
) },
4711 { VEX_LEN_TABLE (VEX_LEN_0F46_P_2
) },
4714 /* PREFIX_VEX_0F47 */
4716 { VEX_LEN_TABLE (VEX_LEN_0F47_P_0
) },
4718 { VEX_LEN_TABLE (VEX_LEN_0F47_P_2
) },
4721 /* PREFIX_VEX_0F4A */
4723 { VEX_LEN_TABLE (VEX_LEN_0F4A_P_0
) },
4725 { VEX_LEN_TABLE (VEX_LEN_0F4A_P_2
) },
4728 /* PREFIX_VEX_0F4B */
4730 { VEX_LEN_TABLE (VEX_LEN_0F4B_P_0
) },
4732 { VEX_LEN_TABLE (VEX_LEN_0F4B_P_2
) },
4735 /* PREFIX_VEX_0F51 */
4737 { VEX_W_TABLE (VEX_W_0F51_P_0
) },
4738 { VEX_LEN_TABLE (VEX_LEN_0F51_P_1
) },
4739 { VEX_W_TABLE (VEX_W_0F51_P_2
) },
4740 { VEX_LEN_TABLE (VEX_LEN_0F51_P_3
) },
4743 /* PREFIX_VEX_0F52 */
4745 { VEX_W_TABLE (VEX_W_0F52_P_0
) },
4746 { VEX_LEN_TABLE (VEX_LEN_0F52_P_1
) },
4749 /* PREFIX_VEX_0F53 */
4751 { VEX_W_TABLE (VEX_W_0F53_P_0
) },
4752 { VEX_LEN_TABLE (VEX_LEN_0F53_P_1
) },
4755 /* PREFIX_VEX_0F58 */
4757 { VEX_W_TABLE (VEX_W_0F58_P_0
) },
4758 { VEX_LEN_TABLE (VEX_LEN_0F58_P_1
) },
4759 { VEX_W_TABLE (VEX_W_0F58_P_2
) },
4760 { VEX_LEN_TABLE (VEX_LEN_0F58_P_3
) },
4763 /* PREFIX_VEX_0F59 */
4765 { VEX_W_TABLE (VEX_W_0F59_P_0
) },
4766 { VEX_LEN_TABLE (VEX_LEN_0F59_P_1
) },
4767 { VEX_W_TABLE (VEX_W_0F59_P_2
) },
4768 { VEX_LEN_TABLE (VEX_LEN_0F59_P_3
) },
4771 /* PREFIX_VEX_0F5A */
4773 { VEX_W_TABLE (VEX_W_0F5A_P_0
) },
4774 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_1
) },
4775 { "vcvtpd2ps%XY", { XMM
, EXx
}, 0 },
4776 { VEX_LEN_TABLE (VEX_LEN_0F5A_P_3
) },
4779 /* PREFIX_VEX_0F5B */
4781 { VEX_W_TABLE (VEX_W_0F5B_P_0
) },
4782 { VEX_W_TABLE (VEX_W_0F5B_P_1
) },
4783 { VEX_W_TABLE (VEX_W_0F5B_P_2
) },
4786 /* PREFIX_VEX_0F5C */
4788 { VEX_W_TABLE (VEX_W_0F5C_P_0
) },
4789 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_1
) },
4790 { VEX_W_TABLE (VEX_W_0F5C_P_2
) },
4791 { VEX_LEN_TABLE (VEX_LEN_0F5C_P_3
) },
4794 /* PREFIX_VEX_0F5D */
4796 { VEX_W_TABLE (VEX_W_0F5D_P_0
) },
4797 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_1
) },
4798 { VEX_W_TABLE (VEX_W_0F5D_P_2
) },
4799 { VEX_LEN_TABLE (VEX_LEN_0F5D_P_3
) },
4802 /* PREFIX_VEX_0F5E */
4804 { VEX_W_TABLE (VEX_W_0F5E_P_0
) },
4805 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_1
) },
4806 { VEX_W_TABLE (VEX_W_0F5E_P_2
) },
4807 { VEX_LEN_TABLE (VEX_LEN_0F5E_P_3
) },
4810 /* PREFIX_VEX_0F5F */
4812 { VEX_W_TABLE (VEX_W_0F5F_P_0
) },
4813 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_1
) },
4814 { VEX_W_TABLE (VEX_W_0F5F_P_2
) },
4815 { VEX_LEN_TABLE (VEX_LEN_0F5F_P_3
) },
4818 /* PREFIX_VEX_0F60 */
4822 { VEX_W_TABLE (VEX_W_0F60_P_2
) },
4825 /* PREFIX_VEX_0F61 */
4829 { VEX_W_TABLE (VEX_W_0F61_P_2
) },
4832 /* PREFIX_VEX_0F62 */
4836 { VEX_W_TABLE (VEX_W_0F62_P_2
) },
4839 /* PREFIX_VEX_0F63 */
4843 { VEX_W_TABLE (VEX_W_0F63_P_2
) },
4846 /* PREFIX_VEX_0F64 */
4850 { VEX_W_TABLE (VEX_W_0F64_P_2
) },
4853 /* PREFIX_VEX_0F65 */
4857 { VEX_W_TABLE (VEX_W_0F65_P_2
) },
4860 /* PREFIX_VEX_0F66 */
4864 { VEX_W_TABLE (VEX_W_0F66_P_2
) },
4867 /* PREFIX_VEX_0F67 */
4871 { VEX_W_TABLE (VEX_W_0F67_P_2
) },
4874 /* PREFIX_VEX_0F68 */
4878 { VEX_W_TABLE (VEX_W_0F68_P_2
) },
4881 /* PREFIX_VEX_0F69 */
4885 { VEX_W_TABLE (VEX_W_0F69_P_2
) },
4888 /* PREFIX_VEX_0F6A */
4892 { VEX_W_TABLE (VEX_W_0F6A_P_2
) },
4895 /* PREFIX_VEX_0F6B */
4899 { VEX_W_TABLE (VEX_W_0F6B_P_2
) },
4902 /* PREFIX_VEX_0F6C */
4906 { VEX_W_TABLE (VEX_W_0F6C_P_2
) },
4909 /* PREFIX_VEX_0F6D */
4913 { VEX_W_TABLE (VEX_W_0F6D_P_2
) },
4916 /* PREFIX_VEX_0F6E */
4920 { VEX_LEN_TABLE (VEX_LEN_0F6E_P_2
) },
4923 /* PREFIX_VEX_0F6F */
4926 { VEX_W_TABLE (VEX_W_0F6F_P_1
) },
4927 { VEX_W_TABLE (VEX_W_0F6F_P_2
) },
4930 /* PREFIX_VEX_0F70 */
4933 { VEX_W_TABLE (VEX_W_0F70_P_1
) },
4934 { VEX_W_TABLE (VEX_W_0F70_P_2
) },
4935 { VEX_W_TABLE (VEX_W_0F70_P_3
) },
4938 /* PREFIX_VEX_0F71_REG_2 */
4942 { VEX_W_TABLE (VEX_W_0F71_R_2_P_2
) },
4945 /* PREFIX_VEX_0F71_REG_4 */
4949 { VEX_W_TABLE (VEX_W_0F71_R_4_P_2
) },
4952 /* PREFIX_VEX_0F71_REG_6 */
4956 { VEX_W_TABLE (VEX_W_0F71_R_6_P_2
) },
4959 /* PREFIX_VEX_0F72_REG_2 */
4963 { VEX_W_TABLE (VEX_W_0F72_R_2_P_2
) },
4966 /* PREFIX_VEX_0F72_REG_4 */
4970 { VEX_W_TABLE (VEX_W_0F72_R_4_P_2
) },
4973 /* PREFIX_VEX_0F72_REG_6 */
4977 { VEX_W_TABLE (VEX_W_0F72_R_6_P_2
) },
4980 /* PREFIX_VEX_0F73_REG_2 */
4984 { VEX_W_TABLE (VEX_W_0F73_R_2_P_2
) },
4987 /* PREFIX_VEX_0F73_REG_3 */
4991 { VEX_W_TABLE (VEX_W_0F73_R_3_P_2
) },
4994 /* PREFIX_VEX_0F73_REG_6 */
4998 { VEX_W_TABLE (VEX_W_0F73_R_6_P_2
) },
5001 /* PREFIX_VEX_0F73_REG_7 */
5005 { VEX_W_TABLE (VEX_W_0F73_R_7_P_2
) },
5008 /* PREFIX_VEX_0F74 */
5012 { VEX_W_TABLE (VEX_W_0F74_P_2
) },
5015 /* PREFIX_VEX_0F75 */
5019 { VEX_W_TABLE (VEX_W_0F75_P_2
) },
5022 /* PREFIX_VEX_0F76 */
5026 { VEX_W_TABLE (VEX_W_0F76_P_2
) },
5029 /* PREFIX_VEX_0F77 */
5031 { VEX_W_TABLE (VEX_W_0F77_P_0
) },
5034 /* PREFIX_VEX_0F7C */
5038 { VEX_W_TABLE (VEX_W_0F7C_P_2
) },
5039 { VEX_W_TABLE (VEX_W_0F7C_P_3
) },
5042 /* PREFIX_VEX_0F7D */
5046 { VEX_W_TABLE (VEX_W_0F7D_P_2
) },
5047 { VEX_W_TABLE (VEX_W_0F7D_P_3
) },
5050 /* PREFIX_VEX_0F7E */
5053 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_1
) },
5054 { VEX_LEN_TABLE (VEX_LEN_0F7E_P_2
) },
5057 /* PREFIX_VEX_0F7F */
5060 { VEX_W_TABLE (VEX_W_0F7F_P_1
) },
5061 { VEX_W_TABLE (VEX_W_0F7F_P_2
) },
5064 /* PREFIX_VEX_0F90 */
5066 { VEX_LEN_TABLE (VEX_LEN_0F90_P_0
) },
5068 { VEX_LEN_TABLE (VEX_LEN_0F90_P_2
) },
5071 /* PREFIX_VEX_0F91 */
5073 { VEX_LEN_TABLE (VEX_LEN_0F91_P_0
) },
5075 { VEX_LEN_TABLE (VEX_LEN_0F91_P_2
) },
5078 /* PREFIX_VEX_0F92 */
5080 { VEX_LEN_TABLE (VEX_LEN_0F92_P_0
) },
5082 { VEX_LEN_TABLE (VEX_LEN_0F92_P_2
) },
5083 { VEX_LEN_TABLE (VEX_LEN_0F92_P_3
) },
5086 /* PREFIX_VEX_0F93 */
5088 { VEX_LEN_TABLE (VEX_LEN_0F93_P_0
) },
5090 { VEX_LEN_TABLE (VEX_LEN_0F93_P_2
) },
5091 { VEX_LEN_TABLE (VEX_LEN_0F93_P_3
) },
5094 /* PREFIX_VEX_0F98 */
5096 { VEX_LEN_TABLE (VEX_LEN_0F98_P_0
) },
5098 { VEX_LEN_TABLE (VEX_LEN_0F98_P_2
) },
5101 /* PREFIX_VEX_0F99 */
5103 { VEX_LEN_TABLE (VEX_LEN_0F99_P_0
) },
5105 { VEX_LEN_TABLE (VEX_LEN_0F99_P_2
) },
5108 /* PREFIX_VEX_0FC2 */
5110 { VEX_W_TABLE (VEX_W_0FC2_P_0
) },
5111 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_1
) },
5112 { VEX_W_TABLE (VEX_W_0FC2_P_2
) },
5113 { VEX_LEN_TABLE (VEX_LEN_0FC2_P_3
) },
5116 /* PREFIX_VEX_0FC4 */
5120 { VEX_LEN_TABLE (VEX_LEN_0FC4_P_2
) },
5123 /* PREFIX_VEX_0FC5 */
5127 { VEX_LEN_TABLE (VEX_LEN_0FC5_P_2
) },
5130 /* PREFIX_VEX_0FD0 */
5134 { VEX_W_TABLE (VEX_W_0FD0_P_2
) },
5135 { VEX_W_TABLE (VEX_W_0FD0_P_3
) },
5138 /* PREFIX_VEX_0FD1 */
5142 { VEX_W_TABLE (VEX_W_0FD1_P_2
) },
5145 /* PREFIX_VEX_0FD2 */
5149 { VEX_W_TABLE (VEX_W_0FD2_P_2
) },
5152 /* PREFIX_VEX_0FD3 */
5156 { VEX_W_TABLE (VEX_W_0FD3_P_2
) },
5159 /* PREFIX_VEX_0FD4 */
5163 { VEX_W_TABLE (VEX_W_0FD4_P_2
) },
5166 /* PREFIX_VEX_0FD5 */
5170 { VEX_W_TABLE (VEX_W_0FD5_P_2
) },
5173 /* PREFIX_VEX_0FD6 */
5177 { VEX_LEN_TABLE (VEX_LEN_0FD6_P_2
) },
5180 /* PREFIX_VEX_0FD7 */
5184 { MOD_TABLE (MOD_VEX_0FD7_PREFIX_2
) },
5187 /* PREFIX_VEX_0FD8 */
5191 { VEX_W_TABLE (VEX_W_0FD8_P_2
) },
5194 /* PREFIX_VEX_0FD9 */
5198 { VEX_W_TABLE (VEX_W_0FD9_P_2
) },
5201 /* PREFIX_VEX_0FDA */
5205 { VEX_W_TABLE (VEX_W_0FDA_P_2
) },
5208 /* PREFIX_VEX_0FDB */
5212 { VEX_W_TABLE (VEX_W_0FDB_P_2
) },
5215 /* PREFIX_VEX_0FDC */
5219 { VEX_W_TABLE (VEX_W_0FDC_P_2
) },
5222 /* PREFIX_VEX_0FDD */
5226 { VEX_W_TABLE (VEX_W_0FDD_P_2
) },
5229 /* PREFIX_VEX_0FDE */
5233 { VEX_W_TABLE (VEX_W_0FDE_P_2
) },
5236 /* PREFIX_VEX_0FDF */
5240 { VEX_W_TABLE (VEX_W_0FDF_P_2
) },
5243 /* PREFIX_VEX_0FE0 */
5247 { VEX_W_TABLE (VEX_W_0FE0_P_2
) },
5250 /* PREFIX_VEX_0FE1 */
5254 { VEX_W_TABLE (VEX_W_0FE1_P_2
) },
5257 /* PREFIX_VEX_0FE2 */
5261 { VEX_W_TABLE (VEX_W_0FE2_P_2
) },
5264 /* PREFIX_VEX_0FE3 */
5268 { VEX_W_TABLE (VEX_W_0FE3_P_2
) },
5271 /* PREFIX_VEX_0FE4 */
5275 { VEX_W_TABLE (VEX_W_0FE4_P_2
) },
5278 /* PREFIX_VEX_0FE5 */
5282 { VEX_W_TABLE (VEX_W_0FE5_P_2
) },
5285 /* PREFIX_VEX_0FE6 */
5288 { VEX_W_TABLE (VEX_W_0FE6_P_1
) },
5289 { VEX_W_TABLE (VEX_W_0FE6_P_2
) },
5290 { VEX_W_TABLE (VEX_W_0FE6_P_3
) },
5293 /* PREFIX_VEX_0FE7 */
5297 { MOD_TABLE (MOD_VEX_0FE7_PREFIX_2
) },
5300 /* PREFIX_VEX_0FE8 */
5304 { VEX_W_TABLE (VEX_W_0FE8_P_2
) },
5307 /* PREFIX_VEX_0FE9 */
5311 { VEX_W_TABLE (VEX_W_0FE9_P_2
) },
5314 /* PREFIX_VEX_0FEA */
5318 { VEX_W_TABLE (VEX_W_0FEA_P_2
) },
5321 /* PREFIX_VEX_0FEB */
5325 { VEX_W_TABLE (VEX_W_0FEB_P_2
) },
5328 /* PREFIX_VEX_0FEC */
5332 { VEX_W_TABLE (VEX_W_0FEC_P_2
) },
5335 /* PREFIX_VEX_0FED */
5339 { VEX_W_TABLE (VEX_W_0FED_P_2
) },
5342 /* PREFIX_VEX_0FEE */
5346 { VEX_W_TABLE (VEX_W_0FEE_P_2
) },
5349 /* PREFIX_VEX_0FEF */
5353 { VEX_W_TABLE (VEX_W_0FEF_P_2
) },
5356 /* PREFIX_VEX_0FF0 */
5361 { MOD_TABLE (MOD_VEX_0FF0_PREFIX_3
) },
5364 /* PREFIX_VEX_0FF1 */
5368 { VEX_W_TABLE (VEX_W_0FF1_P_2
) },
5371 /* PREFIX_VEX_0FF2 */
5375 { VEX_W_TABLE (VEX_W_0FF2_P_2
) },
5378 /* PREFIX_VEX_0FF3 */
5382 { VEX_W_TABLE (VEX_W_0FF3_P_2
) },
5385 /* PREFIX_VEX_0FF4 */
5389 { VEX_W_TABLE (VEX_W_0FF4_P_2
) },
5392 /* PREFIX_VEX_0FF5 */
5396 { VEX_W_TABLE (VEX_W_0FF5_P_2
) },
5399 /* PREFIX_VEX_0FF6 */
5403 { VEX_W_TABLE (VEX_W_0FF6_P_2
) },
5406 /* PREFIX_VEX_0FF7 */
5410 { VEX_LEN_TABLE (VEX_LEN_0FF7_P_2
) },
5413 /* PREFIX_VEX_0FF8 */
5417 { VEX_W_TABLE (VEX_W_0FF8_P_2
) },
5420 /* PREFIX_VEX_0FF9 */
5424 { VEX_W_TABLE (VEX_W_0FF9_P_2
) },
5427 /* PREFIX_VEX_0FFA */
5431 { VEX_W_TABLE (VEX_W_0FFA_P_2
) },
5434 /* PREFIX_VEX_0FFB */
5438 { VEX_W_TABLE (VEX_W_0FFB_P_2
) },
5441 /* PREFIX_VEX_0FFC */
5445 { VEX_W_TABLE (VEX_W_0FFC_P_2
) },
5448 /* PREFIX_VEX_0FFD */
5452 { VEX_W_TABLE (VEX_W_0FFD_P_2
) },
5455 /* PREFIX_VEX_0FFE */
5459 { VEX_W_TABLE (VEX_W_0FFE_P_2
) },
5462 /* PREFIX_VEX_0F3800 */
5466 { VEX_W_TABLE (VEX_W_0F3800_P_2
) },
5469 /* PREFIX_VEX_0F3801 */
5473 { VEX_W_TABLE (VEX_W_0F3801_P_2
) },
5476 /* PREFIX_VEX_0F3802 */
5480 { VEX_W_TABLE (VEX_W_0F3802_P_2
) },
5483 /* PREFIX_VEX_0F3803 */
5487 { VEX_W_TABLE (VEX_W_0F3803_P_2
) },
5490 /* PREFIX_VEX_0F3804 */
5494 { VEX_W_TABLE (VEX_W_0F3804_P_2
) },
5497 /* PREFIX_VEX_0F3805 */
5501 { VEX_W_TABLE (VEX_W_0F3805_P_2
) },
5504 /* PREFIX_VEX_0F3806 */
5508 { VEX_W_TABLE (VEX_W_0F3806_P_2
) },
5511 /* PREFIX_VEX_0F3807 */
5515 { VEX_W_TABLE (VEX_W_0F3807_P_2
) },
5518 /* PREFIX_VEX_0F3808 */
5522 { VEX_W_TABLE (VEX_W_0F3808_P_2
) },
5525 /* PREFIX_VEX_0F3809 */
5529 { VEX_W_TABLE (VEX_W_0F3809_P_2
) },
5532 /* PREFIX_VEX_0F380A */
5536 { VEX_W_TABLE (VEX_W_0F380A_P_2
) },
5539 /* PREFIX_VEX_0F380B */
5543 { VEX_W_TABLE (VEX_W_0F380B_P_2
) },
5546 /* PREFIX_VEX_0F380C */
5550 { VEX_W_TABLE (VEX_W_0F380C_P_2
) },
5553 /* PREFIX_VEX_0F380D */
5557 { VEX_W_TABLE (VEX_W_0F380D_P_2
) },
5560 /* PREFIX_VEX_0F380E */
5564 { VEX_W_TABLE (VEX_W_0F380E_P_2
) },
5567 /* PREFIX_VEX_0F380F */
5571 { VEX_W_TABLE (VEX_W_0F380F_P_2
) },
5574 /* PREFIX_VEX_0F3813 */
5578 { "vcvtph2ps", { XM
, EXxmmq
}, 0 },
5581 /* PREFIX_VEX_0F3816 */
5585 { VEX_LEN_TABLE (VEX_LEN_0F3816_P_2
) },
5588 /* PREFIX_VEX_0F3817 */
5592 { VEX_W_TABLE (VEX_W_0F3817_P_2
) },
5595 /* PREFIX_VEX_0F3818 */
5599 { VEX_W_TABLE (VEX_W_0F3818_P_2
) },
5602 /* PREFIX_VEX_0F3819 */
5606 { VEX_LEN_TABLE (VEX_LEN_0F3819_P_2
) },
5609 /* PREFIX_VEX_0F381A */
5613 { MOD_TABLE (MOD_VEX_0F381A_PREFIX_2
) },
5616 /* PREFIX_VEX_0F381C */
5620 { VEX_W_TABLE (VEX_W_0F381C_P_2
) },
5623 /* PREFIX_VEX_0F381D */
5627 { VEX_W_TABLE (VEX_W_0F381D_P_2
) },
5630 /* PREFIX_VEX_0F381E */
5634 { VEX_W_TABLE (VEX_W_0F381E_P_2
) },
5637 /* PREFIX_VEX_0F3820 */
5641 { VEX_W_TABLE (VEX_W_0F3820_P_2
) },
5644 /* PREFIX_VEX_0F3821 */
5648 { VEX_W_TABLE (VEX_W_0F3821_P_2
) },
5651 /* PREFIX_VEX_0F3822 */
5655 { VEX_W_TABLE (VEX_W_0F3822_P_2
) },
5658 /* PREFIX_VEX_0F3823 */
5662 { VEX_W_TABLE (VEX_W_0F3823_P_2
) },
5665 /* PREFIX_VEX_0F3824 */
5669 { VEX_W_TABLE (VEX_W_0F3824_P_2
) },
5672 /* PREFIX_VEX_0F3825 */
5676 { VEX_W_TABLE (VEX_W_0F3825_P_2
) },
5679 /* PREFIX_VEX_0F3828 */
5683 { VEX_W_TABLE (VEX_W_0F3828_P_2
) },
5686 /* PREFIX_VEX_0F3829 */
5690 { VEX_W_TABLE (VEX_W_0F3829_P_2
) },
5693 /* PREFIX_VEX_0F382A */
5697 { MOD_TABLE (MOD_VEX_0F382A_PREFIX_2
) },
5700 /* PREFIX_VEX_0F382B */
5704 { VEX_W_TABLE (VEX_W_0F382B_P_2
) },
5707 /* PREFIX_VEX_0F382C */
5711 { MOD_TABLE (MOD_VEX_0F382C_PREFIX_2
) },
5714 /* PREFIX_VEX_0F382D */
5718 { MOD_TABLE (MOD_VEX_0F382D_PREFIX_2
) },
5721 /* PREFIX_VEX_0F382E */
5725 { MOD_TABLE (MOD_VEX_0F382E_PREFIX_2
) },
5728 /* PREFIX_VEX_0F382F */
5732 { MOD_TABLE (MOD_VEX_0F382F_PREFIX_2
) },
5735 /* PREFIX_VEX_0F3830 */
5739 { VEX_W_TABLE (VEX_W_0F3830_P_2
) },
5742 /* PREFIX_VEX_0F3831 */
5746 { VEX_W_TABLE (VEX_W_0F3831_P_2
) },
5749 /* PREFIX_VEX_0F3832 */
5753 { VEX_W_TABLE (VEX_W_0F3832_P_2
) },
5756 /* PREFIX_VEX_0F3833 */
5760 { VEX_W_TABLE (VEX_W_0F3833_P_2
) },
5763 /* PREFIX_VEX_0F3834 */
5767 { VEX_W_TABLE (VEX_W_0F3834_P_2
) },
5770 /* PREFIX_VEX_0F3835 */
5774 { VEX_W_TABLE (VEX_W_0F3835_P_2
) },
5777 /* PREFIX_VEX_0F3836 */
5781 { VEX_LEN_TABLE (VEX_LEN_0F3836_P_2
) },
5784 /* PREFIX_VEX_0F3837 */
5788 { VEX_W_TABLE (VEX_W_0F3837_P_2
) },
5791 /* PREFIX_VEX_0F3838 */
5795 { VEX_W_TABLE (VEX_W_0F3838_P_2
) },
5798 /* PREFIX_VEX_0F3839 */
5802 { VEX_W_TABLE (VEX_W_0F3839_P_2
) },
5805 /* PREFIX_VEX_0F383A */
5809 { VEX_W_TABLE (VEX_W_0F383A_P_2
) },
5812 /* PREFIX_VEX_0F383B */
5816 { VEX_W_TABLE (VEX_W_0F383B_P_2
) },
5819 /* PREFIX_VEX_0F383C */
5823 { VEX_W_TABLE (VEX_W_0F383C_P_2
) },
5826 /* PREFIX_VEX_0F383D */
5830 { VEX_W_TABLE (VEX_W_0F383D_P_2
) },
5833 /* PREFIX_VEX_0F383E */
5837 { VEX_W_TABLE (VEX_W_0F383E_P_2
) },
5840 /* PREFIX_VEX_0F383F */
5844 { VEX_W_TABLE (VEX_W_0F383F_P_2
) },
5847 /* PREFIX_VEX_0F3840 */
5851 { VEX_W_TABLE (VEX_W_0F3840_P_2
) },
5854 /* PREFIX_VEX_0F3841 */
5858 { VEX_LEN_TABLE (VEX_LEN_0F3841_P_2
) },
5861 /* PREFIX_VEX_0F3845 */
5865 { "vpsrlv%LW", { XM
, Vex
, EXx
}, 0 },
5868 /* PREFIX_VEX_0F3846 */
5872 { VEX_W_TABLE (VEX_W_0F3846_P_2
) },
5875 /* PREFIX_VEX_0F3847 */
5879 { "vpsllv%LW", { XM
, Vex
, EXx
}, 0 },
5882 /* PREFIX_VEX_0F3858 */
5886 { VEX_W_TABLE (VEX_W_0F3858_P_2
) },
5889 /* PREFIX_VEX_0F3859 */
5893 { VEX_W_TABLE (VEX_W_0F3859_P_2
) },
5896 /* PREFIX_VEX_0F385A */
5900 { MOD_TABLE (MOD_VEX_0F385A_PREFIX_2
) },
5903 /* PREFIX_VEX_0F3878 */
5907 { VEX_W_TABLE (VEX_W_0F3878_P_2
) },
5910 /* PREFIX_VEX_0F3879 */
5914 { VEX_W_TABLE (VEX_W_0F3879_P_2
) },
5917 /* PREFIX_VEX_0F388C */
5921 { MOD_TABLE (MOD_VEX_0F388C_PREFIX_2
) },
5924 /* PREFIX_VEX_0F388E */
5928 { MOD_TABLE (MOD_VEX_0F388E_PREFIX_2
) },
5931 /* PREFIX_VEX_0F3890 */
5935 { "vpgatherd%LW", { XM
, MVexVSIBDWpX
, Vex
}, 0 },
5938 /* PREFIX_VEX_0F3891 */
5942 { "vpgatherq%LW", { XMGatherQ
, MVexVSIBQWpX
, VexGatherQ
}, 0 },
5945 /* PREFIX_VEX_0F3892 */
5949 { "vgatherdp%XW", { XM
, MVexVSIBDWpX
, Vex
}, 0 },
5952 /* PREFIX_VEX_0F3893 */
5956 { "vgatherqp%XW", { XMGatherQ
, MVexVSIBQWpX
, VexGatherQ
}, 0 },
5959 /* PREFIX_VEX_0F3896 */
5963 { "vfmaddsub132p%XW", { XM
, Vex
, EXx
}, 0 },
5966 /* PREFIX_VEX_0F3897 */
5970 { "vfmsubadd132p%XW", { XM
, Vex
, EXx
}, 0 },
5973 /* PREFIX_VEX_0F3898 */
5977 { "vfmadd132p%XW", { XM
, Vex
, EXx
}, 0 },
5980 /* PREFIX_VEX_0F3899 */
5984 { "vfmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
5987 /* PREFIX_VEX_0F389A */
5991 { "vfmsub132p%XW", { XM
, Vex
, EXx
}, 0 },
5994 /* PREFIX_VEX_0F389B */
5998 { "vfmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6001 /* PREFIX_VEX_0F389C */
6005 { "vfnmadd132p%XW", { XM
, Vex
, EXx
}, 0 },
6008 /* PREFIX_VEX_0F389D */
6012 { "vfnmadd132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6015 /* PREFIX_VEX_0F389E */
6019 { "vfnmsub132p%XW", { XM
, Vex
, EXx
}, 0 },
6022 /* PREFIX_VEX_0F389F */
6026 { "vfnmsub132s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6029 /* PREFIX_VEX_0F38A6 */
6033 { "vfmaddsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6037 /* PREFIX_VEX_0F38A7 */
6041 { "vfmsubadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6044 /* PREFIX_VEX_0F38A8 */
6048 { "vfmadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6051 /* PREFIX_VEX_0F38A9 */
6055 { "vfmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6058 /* PREFIX_VEX_0F38AA */
6062 { "vfmsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6065 /* PREFIX_VEX_0F38AB */
6069 { "vfmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6072 /* PREFIX_VEX_0F38AC */
6076 { "vfnmadd213p%XW", { XM
, Vex
, EXx
}, 0 },
6079 /* PREFIX_VEX_0F38AD */
6083 { "vfnmadd213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6086 /* PREFIX_VEX_0F38AE */
6090 { "vfnmsub213p%XW", { XM
, Vex
, EXx
}, 0 },
6093 /* PREFIX_VEX_0F38AF */
6097 { "vfnmsub213s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6100 /* PREFIX_VEX_0F38B6 */
6104 { "vfmaddsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6107 /* PREFIX_VEX_0F38B7 */
6111 { "vfmsubadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6114 /* PREFIX_VEX_0F38B8 */
6118 { "vfmadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6121 /* PREFIX_VEX_0F38B9 */
6125 { "vfmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6128 /* PREFIX_VEX_0F38BA */
6132 { "vfmsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6135 /* PREFIX_VEX_0F38BB */
6139 { "vfmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6142 /* PREFIX_VEX_0F38BC */
6146 { "vfnmadd231p%XW", { XM
, Vex
, EXx
}, 0 },
6149 /* PREFIX_VEX_0F38BD */
6153 { "vfnmadd231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6156 /* PREFIX_VEX_0F38BE */
6160 { "vfnmsub231p%XW", { XM
, Vex
, EXx
}, 0 },
6163 /* PREFIX_VEX_0F38BF */
6167 { "vfnmsub231s%XW", { XMScalar
, VexScalar
, EXVexWdqScalar
}, 0 },
6170 /* PREFIX_VEX_0F38DB */
6174 { VEX_LEN_TABLE (VEX_LEN_0F38DB_P_2
) },
6177 /* PREFIX_VEX_0F38DC */
6181 { VEX_LEN_TABLE (VEX_LEN_0F38DC_P_2
) },
6184 /* PREFIX_VEX_0F38DD */
6188 { VEX_LEN_TABLE (VEX_LEN_0F38DD_P_2
) },
6191 /* PREFIX_VEX_0F38DE */
6195 { VEX_LEN_TABLE (VEX_LEN_0F38DE_P_2
) },
6198 /* PREFIX_VEX_0F38DF */
6202 { VEX_LEN_TABLE (VEX_LEN_0F38DF_P_2
) },
6205 /* PREFIX_VEX_0F38F2 */
6207 { VEX_LEN_TABLE (VEX_LEN_0F38F2_P_0
) },
6210 /* PREFIX_VEX_0F38F3_REG_1 */
6212 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_1_P_0
) },
6215 /* PREFIX_VEX_0F38F3_REG_2 */
6217 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_2_P_0
) },
6220 /* PREFIX_VEX_0F38F3_REG_3 */
6222 { VEX_LEN_TABLE (VEX_LEN_0F38F3_R_3_P_0
) },
6225 /* PREFIX_VEX_0F38F5 */
6227 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_0
) },
6228 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_1
) },
6230 { VEX_LEN_TABLE (VEX_LEN_0F38F5_P_3
) },
6233 /* PREFIX_VEX_0F38F6 */
6238 { VEX_LEN_TABLE (VEX_LEN_0F38F6_P_3
) },
6241 /* PREFIX_VEX_0F38F7 */
6243 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_0
) },
6244 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_1
) },
6245 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_2
) },
6246 { VEX_LEN_TABLE (VEX_LEN_0F38F7_P_3
) },
6249 /* PREFIX_VEX_0F3A00 */
6253 { VEX_LEN_TABLE (VEX_LEN_0F3A00_P_2
) },
6256 /* PREFIX_VEX_0F3A01 */
6260 { VEX_LEN_TABLE (VEX_LEN_0F3A01_P_2
) },
6263 /* PREFIX_VEX_0F3A02 */
6267 { VEX_W_TABLE (VEX_W_0F3A02_P_2
) },
6270 /* PREFIX_VEX_0F3A04 */
6274 { VEX_W_TABLE (VEX_W_0F3A04_P_2
) },
6277 /* PREFIX_VEX_0F3A05 */
6281 { VEX_W_TABLE (VEX_W_0F3A05_P_2
) },
6284 /* PREFIX_VEX_0F3A06 */
6288 { VEX_LEN_TABLE (VEX_LEN_0F3A06_P_2
) },
6291 /* PREFIX_VEX_0F3A08 */
6295 { VEX_W_TABLE (VEX_W_0F3A08_P_2
) },
6298 /* PREFIX_VEX_0F3A09 */
6302 { VEX_W_TABLE (VEX_W_0F3A09_P_2
) },
6305 /* PREFIX_VEX_0F3A0A */
6309 { VEX_LEN_TABLE (VEX_LEN_0F3A0A_P_2
) },
6312 /* PREFIX_VEX_0F3A0B */
6316 { VEX_LEN_TABLE (VEX_LEN_0F3A0B_P_2
) },
6319 /* PREFIX_VEX_0F3A0C */
6323 { VEX_W_TABLE (VEX_W_0F3A0C_P_2
) },
6326 /* PREFIX_VEX_0F3A0D */
6330 { VEX_W_TABLE (VEX_W_0F3A0D_P_2
) },
6333 /* PREFIX_VEX_0F3A0E */
6337 { VEX_W_TABLE (VEX_W_0F3A0E_P_2
) },
6340 /* PREFIX_VEX_0F3A0F */
6344 { VEX_W_TABLE (VEX_W_0F3A0F_P_2
) },
6347 /* PREFIX_VEX_0F3A14 */
6351 { VEX_LEN_TABLE (VEX_LEN_0F3A14_P_2
) },
6354 /* PREFIX_VEX_0F3A15 */
6358 { VEX_LEN_TABLE (VEX_LEN_0F3A15_P_2
) },
6361 /* PREFIX_VEX_0F3A16 */
6365 { VEX_LEN_TABLE (VEX_LEN_0F3A16_P_2
) },
6368 /* PREFIX_VEX_0F3A17 */
6372 { VEX_LEN_TABLE (VEX_LEN_0F3A17_P_2
) },
6375 /* PREFIX_VEX_0F3A18 */
6379 { VEX_LEN_TABLE (VEX_LEN_0F3A18_P_2
) },
6382 /* PREFIX_VEX_0F3A19 */
6386 { VEX_LEN_TABLE (VEX_LEN_0F3A19_P_2
) },
6389 /* PREFIX_VEX_0F3A1D */
6393 { "vcvtps2ph", { EXxmmq
, XM
, Ib
}, 0 },
6396 /* PREFIX_VEX_0F3A20 */
6400 { VEX_LEN_TABLE (VEX_LEN_0F3A20_P_2
) },
6403 /* PREFIX_VEX_0F3A21 */
6407 { VEX_LEN_TABLE (VEX_LEN_0F3A21_P_2
) },
6410 /* PREFIX_VEX_0F3A22 */
6414 { VEX_LEN_TABLE (VEX_LEN_0F3A22_P_2
) },
6417 /* PREFIX_VEX_0F3A30 */
6421 { VEX_LEN_TABLE (VEX_LEN_0F3A30_P_2
) },
6424 /* PREFIX_VEX_0F3A31 */
6428 { VEX_LEN_TABLE (VEX_LEN_0F3A31_P_2
) },
6431 /* PREFIX_VEX_0F3A32 */
6435 { VEX_LEN_TABLE (VEX_LEN_0F3A32_P_2
) },
6438 /* PREFIX_VEX_0F3A33 */
6442 { VEX_LEN_TABLE (VEX_LEN_0F3A33_P_2
) },
6445 /* PREFIX_VEX_0F3A38 */
6449 { VEX_LEN_TABLE (VEX_LEN_0F3A38_P_2
) },
6452 /* PREFIX_VEX_0F3A39 */
6456 { VEX_LEN_TABLE (VEX_LEN_0F3A39_P_2
) },
6459 /* PREFIX_VEX_0F3A40 */
6463 { VEX_W_TABLE (VEX_W_0F3A40_P_2
) },
6466 /* PREFIX_VEX_0F3A41 */
6470 { VEX_LEN_TABLE (VEX_LEN_0F3A41_P_2
) },
6473 /* PREFIX_VEX_0F3A42 */
6477 { VEX_W_TABLE (VEX_W_0F3A42_P_2
) },
6480 /* PREFIX_VEX_0F3A44 */
6484 { VEX_LEN_TABLE (VEX_LEN_0F3A44_P_2
) },
6487 /* PREFIX_VEX_0F3A46 */
6491 { VEX_LEN_TABLE (VEX_LEN_0F3A46_P_2
) },
6494 /* PREFIX_VEX_0F3A48 */
6498 { VEX_W_TABLE (VEX_W_0F3A48_P_2
) },
6501 /* PREFIX_VEX_0F3A49 */
6505 { VEX_W_TABLE (VEX_W_0F3A49_P_2
) },
6508 /* PREFIX_VEX_0F3A4A */
6512 { VEX_W_TABLE (VEX_W_0F3A4A_P_2
) },
6515 /* PREFIX_VEX_0F3A4B */
6519 { VEX_W_TABLE (VEX_W_0F3A4B_P_2
) },
6522 /* PREFIX_VEX_0F3A4C */
6526 { VEX_W_TABLE (VEX_W_0F3A4C_P_2
) },
6529 /* PREFIX_VEX_0F3A5C */
6533 { "vfmaddsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6536 /* PREFIX_VEX_0F3A5D */
6540 { "vfmaddsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6543 /* PREFIX_VEX_0F3A5E */
6547 { "vfmsubaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6550 /* PREFIX_VEX_0F3A5F */
6554 { "vfmsubaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6557 /* PREFIX_VEX_0F3A60 */
6561 { VEX_LEN_TABLE (VEX_LEN_0F3A60_P_2
) },
6565 /* PREFIX_VEX_0F3A61 */
6569 { VEX_LEN_TABLE (VEX_LEN_0F3A61_P_2
) },
6572 /* PREFIX_VEX_0F3A62 */
6576 { VEX_LEN_TABLE (VEX_LEN_0F3A62_P_2
) },
6579 /* PREFIX_VEX_0F3A63 */
6583 { VEX_LEN_TABLE (VEX_LEN_0F3A63_P_2
) },
6586 /* PREFIX_VEX_0F3A68 */
6590 { "vfmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6593 /* PREFIX_VEX_0F3A69 */
6597 { "vfmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6600 /* PREFIX_VEX_0F3A6A */
6604 { VEX_LEN_TABLE (VEX_LEN_0F3A6A_P_2
) },
6607 /* PREFIX_VEX_0F3A6B */
6611 { VEX_LEN_TABLE (VEX_LEN_0F3A6B_P_2
) },
6614 /* PREFIX_VEX_0F3A6C */
6618 { "vfmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6621 /* PREFIX_VEX_0F3A6D */
6625 { "vfmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6628 /* PREFIX_VEX_0F3A6E */
6632 { VEX_LEN_TABLE (VEX_LEN_0F3A6E_P_2
) },
6635 /* PREFIX_VEX_0F3A6F */
6639 { VEX_LEN_TABLE (VEX_LEN_0F3A6F_P_2
) },
6642 /* PREFIX_VEX_0F3A78 */
6646 { "vfnmaddps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6649 /* PREFIX_VEX_0F3A79 */
6653 { "vfnmaddpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6656 /* PREFIX_VEX_0F3A7A */
6660 { VEX_LEN_TABLE (VEX_LEN_0F3A7A_P_2
) },
6663 /* PREFIX_VEX_0F3A7B */
6667 { VEX_LEN_TABLE (VEX_LEN_0F3A7B_P_2
) },
6670 /* PREFIX_VEX_0F3A7C */
6674 { "vfnmsubps", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6678 /* PREFIX_VEX_0F3A7D */
6682 { "vfnmsubpd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
6685 /* PREFIX_VEX_0F3A7E */
6689 { VEX_LEN_TABLE (VEX_LEN_0F3A7E_P_2
) },
6692 /* PREFIX_VEX_0F3A7F */
6696 { VEX_LEN_TABLE (VEX_LEN_0F3A7F_P_2
) },
6699 /* PREFIX_VEX_0F3ADF */
6703 { VEX_LEN_TABLE (VEX_LEN_0F3ADF_P_2
) },
6706 /* PREFIX_VEX_0F3AF0 */
6711 { VEX_LEN_TABLE (VEX_LEN_0F3AF0_P_3
) },
6714 #define NEED_PREFIX_TABLE
6715 #include "i386-dis-evex.h"
6716 #undef NEED_PREFIX_TABLE
6719 static const struct dis386 x86_64_table
[][2] = {
6722 { "pushP", { es
}, 0 },
6727 { "popP", { es
}, 0 },
6732 { "pushP", { cs
}, 0 },
6737 { "pushP", { ss
}, 0 },
6742 { "popP", { ss
}, 0 },
6747 { "pushP", { ds
}, 0 },
6752 { "popP", { ds
}, 0 },
6757 { "daa", { XX
}, 0 },
6762 { "das", { XX
}, 0 },
6767 { "aaa", { XX
}, 0 },
6772 { "aas", { XX
}, 0 },
6777 { "pushaP", { XX
}, 0 },
6782 { "popaP", { XX
}, 0 },
6787 { MOD_TABLE (MOD_62_32BIT
) },
6788 { EVEX_TABLE (EVEX_0F
) },
6793 { "arpl", { Ew
, Gw
}, 0 },
6794 { "movs{lq|xd}", { Gv
, Ed
}, 0 },
6799 { "ins{R|}", { Yzr
, indirDX
}, 0 },
6800 { "ins{G|}", { Yzr
, indirDX
}, 0 },
6805 { "outs{R|}", { indirDXr
, Xz
}, 0 },
6806 { "outs{G|}", { indirDXr
, Xz
}, 0 },
6811 { "Jcall{T|}", { Ap
}, 0 },
6816 { MOD_TABLE (MOD_C4_32BIT
) },
6817 { VEX_C4_TABLE (VEX_0F
) },
6822 { MOD_TABLE (MOD_C5_32BIT
) },
6823 { VEX_C5_TABLE (VEX_0F
) },
6828 { "into", { XX
}, 0 },
6833 { "aam", { Ib
}, 0 },
6838 { "aad", { Ib
}, 0 },
6843 { "Jjmp{T|}", { Ap
}, 0 },
6846 /* X86_64_0F01_REG_0 */
6848 { "sgdt{Q|IQ}", { M
}, 0 },
6849 { "sgdt", { M
}, 0 },
6852 /* X86_64_0F01_REG_1 */
6854 { "sidt{Q|IQ}", { M
}, 0 },
6855 { "sidt", { M
}, 0 },
6858 /* X86_64_0F01_REG_2 */
6860 { "lgdt{Q|Q}", { M
}, 0 },
6861 { "lgdt", { M
}, 0 },
6864 /* X86_64_0F01_REG_3 */
6866 { "lidt{Q|Q}", { M
}, 0 },
6867 { "lidt", { M
}, 0 },
6871 static const struct dis386 three_byte_table
[][256] = {
6873 /* THREE_BYTE_0F38 */
6876 { "pshufb", { MX
, EM
}, PREFIX_OPCODE
},
6877 { "phaddw", { MX
, EM
}, PREFIX_OPCODE
},
6878 { "phaddd", { MX
, EM
}, PREFIX_OPCODE
},
6879 { "phaddsw", { MX
, EM
}, PREFIX_OPCODE
},
6880 { "pmaddubsw", { MX
, EM
}, PREFIX_OPCODE
},
6881 { "phsubw", { MX
, EM
}, PREFIX_OPCODE
},
6882 { "phsubd", { MX
, EM
}, PREFIX_OPCODE
},
6883 { "phsubsw", { MX
, EM
}, PREFIX_OPCODE
},
6885 { "psignb", { MX
, EM
}, PREFIX_OPCODE
},
6886 { "psignw", { MX
, EM
}, PREFIX_OPCODE
},
6887 { "psignd", { MX
, EM
}, PREFIX_OPCODE
},
6888 { "pmulhrsw", { MX
, EM
}, PREFIX_OPCODE
},
6894 { PREFIX_TABLE (PREFIX_0F3810
) },
6898 { PREFIX_TABLE (PREFIX_0F3814
) },
6899 { PREFIX_TABLE (PREFIX_0F3815
) },
6901 { PREFIX_TABLE (PREFIX_0F3817
) },
6907 { "pabsb", { MX
, EM
}, PREFIX_OPCODE
},
6908 { "pabsw", { MX
, EM
}, PREFIX_OPCODE
},
6909 { "pabsd", { MX
, EM
}, PREFIX_OPCODE
},
6912 { PREFIX_TABLE (PREFIX_0F3820
) },
6913 { PREFIX_TABLE (PREFIX_0F3821
) },
6914 { PREFIX_TABLE (PREFIX_0F3822
) },
6915 { PREFIX_TABLE (PREFIX_0F3823
) },
6916 { PREFIX_TABLE (PREFIX_0F3824
) },
6917 { PREFIX_TABLE (PREFIX_0F3825
) },
6921 { PREFIX_TABLE (PREFIX_0F3828
) },
6922 { PREFIX_TABLE (PREFIX_0F3829
) },
6923 { PREFIX_TABLE (PREFIX_0F382A
) },
6924 { PREFIX_TABLE (PREFIX_0F382B
) },
6930 { PREFIX_TABLE (PREFIX_0F3830
) },
6931 { PREFIX_TABLE (PREFIX_0F3831
) },
6932 { PREFIX_TABLE (PREFIX_0F3832
) },
6933 { PREFIX_TABLE (PREFIX_0F3833
) },
6934 { PREFIX_TABLE (PREFIX_0F3834
) },
6935 { PREFIX_TABLE (PREFIX_0F3835
) },
6937 { PREFIX_TABLE (PREFIX_0F3837
) },
6939 { PREFIX_TABLE (PREFIX_0F3838
) },
6940 { PREFIX_TABLE (PREFIX_0F3839
) },
6941 { PREFIX_TABLE (PREFIX_0F383A
) },
6942 { PREFIX_TABLE (PREFIX_0F383B
) },
6943 { PREFIX_TABLE (PREFIX_0F383C
) },
6944 { PREFIX_TABLE (PREFIX_0F383D
) },
6945 { PREFIX_TABLE (PREFIX_0F383E
) },
6946 { PREFIX_TABLE (PREFIX_0F383F
) },
6948 { PREFIX_TABLE (PREFIX_0F3840
) },
6949 { PREFIX_TABLE (PREFIX_0F3841
) },
7020 { PREFIX_TABLE (PREFIX_0F3880
) },
7021 { PREFIX_TABLE (PREFIX_0F3881
) },
7022 { PREFIX_TABLE (PREFIX_0F3882
) },
7101 { PREFIX_TABLE (PREFIX_0F38C8
) },
7102 { PREFIX_TABLE (PREFIX_0F38C9
) },
7103 { PREFIX_TABLE (PREFIX_0F38CA
) },
7104 { PREFIX_TABLE (PREFIX_0F38CB
) },
7105 { PREFIX_TABLE (PREFIX_0F38CC
) },
7106 { PREFIX_TABLE (PREFIX_0F38CD
) },
7122 { PREFIX_TABLE (PREFIX_0F38DB
) },
7123 { PREFIX_TABLE (PREFIX_0F38DC
) },
7124 { PREFIX_TABLE (PREFIX_0F38DD
) },
7125 { PREFIX_TABLE (PREFIX_0F38DE
) },
7126 { PREFIX_TABLE (PREFIX_0F38DF
) },
7146 { PREFIX_TABLE (PREFIX_0F38F0
) },
7147 { PREFIX_TABLE (PREFIX_0F38F1
) },
7152 { PREFIX_TABLE (PREFIX_0F38F6
) },
7164 /* THREE_BYTE_0F3A */
7176 { PREFIX_TABLE (PREFIX_0F3A08
) },
7177 { PREFIX_TABLE (PREFIX_0F3A09
) },
7178 { PREFIX_TABLE (PREFIX_0F3A0A
) },
7179 { PREFIX_TABLE (PREFIX_0F3A0B
) },
7180 { PREFIX_TABLE (PREFIX_0F3A0C
) },
7181 { PREFIX_TABLE (PREFIX_0F3A0D
) },
7182 { PREFIX_TABLE (PREFIX_0F3A0E
) },
7183 { "palignr", { MX
, EM
, Ib
}, PREFIX_OPCODE
},
7189 { PREFIX_TABLE (PREFIX_0F3A14
) },
7190 { PREFIX_TABLE (PREFIX_0F3A15
) },
7191 { PREFIX_TABLE (PREFIX_0F3A16
) },
7192 { PREFIX_TABLE (PREFIX_0F3A17
) },
7203 { PREFIX_TABLE (PREFIX_0F3A20
) },
7204 { PREFIX_TABLE (PREFIX_0F3A21
) },
7205 { PREFIX_TABLE (PREFIX_0F3A22
) },
7239 { PREFIX_TABLE (PREFIX_0F3A40
) },
7240 { PREFIX_TABLE (PREFIX_0F3A41
) },
7241 { PREFIX_TABLE (PREFIX_0F3A42
) },
7243 { PREFIX_TABLE (PREFIX_0F3A44
) },
7275 { PREFIX_TABLE (PREFIX_0F3A60
) },
7276 { PREFIX_TABLE (PREFIX_0F3A61
) },
7277 { PREFIX_TABLE (PREFIX_0F3A62
) },
7278 { PREFIX_TABLE (PREFIX_0F3A63
) },
7396 { PREFIX_TABLE (PREFIX_0F3ACC
) },
7417 { PREFIX_TABLE (PREFIX_0F3ADF
) },
7456 /* THREE_BYTE_0F7A */
7495 { "ptest", { XX
}, PREFIX_OPCODE
},
7532 { "phaddbw", { XM
, EXq
}, PREFIX_OPCODE
},
7533 { "phaddbd", { XM
, EXq
}, PREFIX_OPCODE
},
7534 { "phaddbq", { XM
, EXq
}, PREFIX_OPCODE
},
7537 { "phaddwd", { XM
, EXq
}, PREFIX_OPCODE
},
7538 { "phaddwq", { XM
, EXq
}, PREFIX_OPCODE
},
7543 { "phadddq", { XM
, EXq
}, PREFIX_OPCODE
},
7550 { "phaddubw", { XM
, EXq
}, PREFIX_OPCODE
},
7551 { "phaddubd", { XM
, EXq
}, PREFIX_OPCODE
},
7552 { "phaddubq", { XM
, EXq
}, PREFIX_OPCODE
},
7555 { "phadduwd", { XM
, EXq
}, PREFIX_OPCODE
},
7556 { "phadduwq", { XM
, EXq
}, PREFIX_OPCODE
},
7561 { "phaddudq", { XM
, EXq
}, PREFIX_OPCODE
},
7568 { "phsubbw", { XM
, EXq
}, PREFIX_OPCODE
},
7569 { "phsubbd", { XM
, EXq
}, PREFIX_OPCODE
},
7570 { "phsubbq", { XM
, EXq
}, PREFIX_OPCODE
},
7749 static const struct dis386 xop_table
[][256] = {
7902 { "vpmacssww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7903 { "vpmacsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7904 { "vpmacssdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7912 { "vpmacssdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7913 { "vpmacssdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7920 { "vpmacsww", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7921 { "vpmacswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7922 { "vpmacsdql", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7930 { "vpmacsdd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7931 { "vpmacsdqh", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7935 { "vpcmov", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7936 { "vpperm", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7939 { "vpmadcsswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7957 { "vpmadcswd", { XMVexW
, Vex
, EXVexW
, EXVexW
, VexI4
}, 0 },
7969 { "vprotb", { XM
, Vex_2src_1
, Ib
}, 0 },
7970 { "vprotw", { XM
, Vex_2src_1
, Ib
}, 0 },
7971 { "vprotd", { XM
, Vex_2src_1
, Ib
}, 0 },
7972 { "vprotq", { XM
, Vex_2src_1
, Ib
}, 0 },
7982 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CC
) },
7983 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CD
) },
7984 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CE
) },
7985 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_CF
) },
8018 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EC
) },
8019 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_ED
) },
8020 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EE
) },
8021 { VEX_LEN_TABLE (VEX_LEN_0FXOP_08_EF
) },
8045 { REG_TABLE (REG_XOP_TBM_01
) },
8046 { REG_TABLE (REG_XOP_TBM_02
) },
8064 { REG_TABLE (REG_XOP_LWPCB
) },
8188 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_80
) },
8189 { VEX_LEN_TABLE (VEX_LEN_0FXOP_09_81
) },
8190 { "vfrczss", { XM
, EXd
}, 0 },
8191 { "vfrczsd", { XM
, EXq
}, 0 },
8206 { "vprotb", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8207 { "vprotw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8208 { "vprotd", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8209 { "vprotq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8210 { "vpshlb", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8211 { "vpshlw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8212 { "vpshld", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8213 { "vpshlq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8215 { "vpshab", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8216 { "vpshaw", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8217 { "vpshad", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8218 { "vpshaq", { XM
, Vex_2src_1
, Vex_2src_2
}, 0 },
8261 { "vphaddbw", { XM
, EXxmm
}, 0 },
8262 { "vphaddbd", { XM
, EXxmm
}, 0 },
8263 { "vphaddbq", { XM
, EXxmm
}, 0 },
8266 { "vphaddwd", { XM
, EXxmm
}, 0 },
8267 { "vphaddwq", { XM
, EXxmm
}, 0 },
8272 { "vphadddq", { XM
, EXxmm
}, 0 },
8279 { "vphaddubw", { XM
, EXxmm
}, 0 },
8280 { "vphaddubd", { XM
, EXxmm
}, 0 },
8281 { "vphaddubq", { XM
, EXxmm
}, 0 },
8284 { "vphadduwd", { XM
, EXxmm
}, 0 },
8285 { "vphadduwq", { XM
, EXxmm
}, 0 },
8290 { "vphaddudq", { XM
, EXxmm
}, 0 },
8297 { "vphsubbw", { XM
, EXxmm
}, 0 },
8298 { "vphsubwd", { XM
, EXxmm
}, 0 },
8299 { "vphsubdq", { XM
, EXxmm
}, 0 },
8353 { "bextr", { Gv
, Ev
, Iq
}, 0 },
8355 { REG_TABLE (REG_XOP_LWP
) },
8625 static const struct dis386 vex_table
[][256] = {
8647 { PREFIX_TABLE (PREFIX_VEX_0F10
) },
8648 { PREFIX_TABLE (PREFIX_VEX_0F11
) },
8649 { PREFIX_TABLE (PREFIX_VEX_0F12
) },
8650 { MOD_TABLE (MOD_VEX_0F13
) },
8651 { VEX_W_TABLE (VEX_W_0F14
) },
8652 { VEX_W_TABLE (VEX_W_0F15
) },
8653 { PREFIX_TABLE (PREFIX_VEX_0F16
) },
8654 { MOD_TABLE (MOD_VEX_0F17
) },
8674 { VEX_W_TABLE (VEX_W_0F28
) },
8675 { VEX_W_TABLE (VEX_W_0F29
) },
8676 { PREFIX_TABLE (PREFIX_VEX_0F2A
) },
8677 { MOD_TABLE (MOD_VEX_0F2B
) },
8678 { PREFIX_TABLE (PREFIX_VEX_0F2C
) },
8679 { PREFIX_TABLE (PREFIX_VEX_0F2D
) },
8680 { PREFIX_TABLE (PREFIX_VEX_0F2E
) },
8681 { PREFIX_TABLE (PREFIX_VEX_0F2F
) },
8702 { PREFIX_TABLE (PREFIX_VEX_0F41
) },
8703 { PREFIX_TABLE (PREFIX_VEX_0F42
) },
8705 { PREFIX_TABLE (PREFIX_VEX_0F44
) },
8706 { PREFIX_TABLE (PREFIX_VEX_0F45
) },
8707 { PREFIX_TABLE (PREFIX_VEX_0F46
) },
8708 { PREFIX_TABLE (PREFIX_VEX_0F47
) },
8712 { PREFIX_TABLE (PREFIX_VEX_0F4A
) },
8713 { PREFIX_TABLE (PREFIX_VEX_0F4B
) },
8719 { MOD_TABLE (MOD_VEX_0F50
) },
8720 { PREFIX_TABLE (PREFIX_VEX_0F51
) },
8721 { PREFIX_TABLE (PREFIX_VEX_0F52
) },
8722 { PREFIX_TABLE (PREFIX_VEX_0F53
) },
8723 { "vandpX", { XM
, Vex
, EXx
}, 0 },
8724 { "vandnpX", { XM
, Vex
, EXx
}, 0 },
8725 { "vorpX", { XM
, Vex
, EXx
}, 0 },
8726 { "vxorpX", { XM
, Vex
, EXx
}, 0 },
8728 { PREFIX_TABLE (PREFIX_VEX_0F58
) },
8729 { PREFIX_TABLE (PREFIX_VEX_0F59
) },
8730 { PREFIX_TABLE (PREFIX_VEX_0F5A
) },
8731 { PREFIX_TABLE (PREFIX_VEX_0F5B
) },
8732 { PREFIX_TABLE (PREFIX_VEX_0F5C
) },
8733 { PREFIX_TABLE (PREFIX_VEX_0F5D
) },
8734 { PREFIX_TABLE (PREFIX_VEX_0F5E
) },
8735 { PREFIX_TABLE (PREFIX_VEX_0F5F
) },
8737 { PREFIX_TABLE (PREFIX_VEX_0F60
) },
8738 { PREFIX_TABLE (PREFIX_VEX_0F61
) },
8739 { PREFIX_TABLE (PREFIX_VEX_0F62
) },
8740 { PREFIX_TABLE (PREFIX_VEX_0F63
) },
8741 { PREFIX_TABLE (PREFIX_VEX_0F64
) },
8742 { PREFIX_TABLE (PREFIX_VEX_0F65
) },
8743 { PREFIX_TABLE (PREFIX_VEX_0F66
) },
8744 { PREFIX_TABLE (PREFIX_VEX_0F67
) },
8746 { PREFIX_TABLE (PREFIX_VEX_0F68
) },
8747 { PREFIX_TABLE (PREFIX_VEX_0F69
) },
8748 { PREFIX_TABLE (PREFIX_VEX_0F6A
) },
8749 { PREFIX_TABLE (PREFIX_VEX_0F6B
) },
8750 { PREFIX_TABLE (PREFIX_VEX_0F6C
) },
8751 { PREFIX_TABLE (PREFIX_VEX_0F6D
) },
8752 { PREFIX_TABLE (PREFIX_VEX_0F6E
) },
8753 { PREFIX_TABLE (PREFIX_VEX_0F6F
) },
8755 { PREFIX_TABLE (PREFIX_VEX_0F70
) },
8756 { REG_TABLE (REG_VEX_0F71
) },
8757 { REG_TABLE (REG_VEX_0F72
) },
8758 { REG_TABLE (REG_VEX_0F73
) },
8759 { PREFIX_TABLE (PREFIX_VEX_0F74
) },
8760 { PREFIX_TABLE (PREFIX_VEX_0F75
) },
8761 { PREFIX_TABLE (PREFIX_VEX_0F76
) },
8762 { PREFIX_TABLE (PREFIX_VEX_0F77
) },
8768 { PREFIX_TABLE (PREFIX_VEX_0F7C
) },
8769 { PREFIX_TABLE (PREFIX_VEX_0F7D
) },
8770 { PREFIX_TABLE (PREFIX_VEX_0F7E
) },
8771 { PREFIX_TABLE (PREFIX_VEX_0F7F
) },
8791 { PREFIX_TABLE (PREFIX_VEX_0F90
) },
8792 { PREFIX_TABLE (PREFIX_VEX_0F91
) },
8793 { PREFIX_TABLE (PREFIX_VEX_0F92
) },
8794 { PREFIX_TABLE (PREFIX_VEX_0F93
) },
8800 { PREFIX_TABLE (PREFIX_VEX_0F98
) },
8801 { PREFIX_TABLE (PREFIX_VEX_0F99
) },
8824 { REG_TABLE (REG_VEX_0FAE
) },
8847 { PREFIX_TABLE (PREFIX_VEX_0FC2
) },
8849 { PREFIX_TABLE (PREFIX_VEX_0FC4
) },
8850 { PREFIX_TABLE (PREFIX_VEX_0FC5
) },
8851 { "vshufpX", { XM
, Vex
, EXx
, Ib
}, 0 },
8863 { PREFIX_TABLE (PREFIX_VEX_0FD0
) },
8864 { PREFIX_TABLE (PREFIX_VEX_0FD1
) },
8865 { PREFIX_TABLE (PREFIX_VEX_0FD2
) },
8866 { PREFIX_TABLE (PREFIX_VEX_0FD3
) },
8867 { PREFIX_TABLE (PREFIX_VEX_0FD4
) },
8868 { PREFIX_TABLE (PREFIX_VEX_0FD5
) },
8869 { PREFIX_TABLE (PREFIX_VEX_0FD6
) },
8870 { PREFIX_TABLE (PREFIX_VEX_0FD7
) },
8872 { PREFIX_TABLE (PREFIX_VEX_0FD8
) },
8873 { PREFIX_TABLE (PREFIX_VEX_0FD9
) },
8874 { PREFIX_TABLE (PREFIX_VEX_0FDA
) },
8875 { PREFIX_TABLE (PREFIX_VEX_0FDB
) },
8876 { PREFIX_TABLE (PREFIX_VEX_0FDC
) },
8877 { PREFIX_TABLE (PREFIX_VEX_0FDD
) },
8878 { PREFIX_TABLE (PREFIX_VEX_0FDE
) },
8879 { PREFIX_TABLE (PREFIX_VEX_0FDF
) },
8881 { PREFIX_TABLE (PREFIX_VEX_0FE0
) },
8882 { PREFIX_TABLE (PREFIX_VEX_0FE1
) },
8883 { PREFIX_TABLE (PREFIX_VEX_0FE2
) },
8884 { PREFIX_TABLE (PREFIX_VEX_0FE3
) },
8885 { PREFIX_TABLE (PREFIX_VEX_0FE4
) },
8886 { PREFIX_TABLE (PREFIX_VEX_0FE5
) },
8887 { PREFIX_TABLE (PREFIX_VEX_0FE6
) },
8888 { PREFIX_TABLE (PREFIX_VEX_0FE7
) },
8890 { PREFIX_TABLE (PREFIX_VEX_0FE8
) },
8891 { PREFIX_TABLE (PREFIX_VEX_0FE9
) },
8892 { PREFIX_TABLE (PREFIX_VEX_0FEA
) },
8893 { PREFIX_TABLE (PREFIX_VEX_0FEB
) },
8894 { PREFIX_TABLE (PREFIX_VEX_0FEC
) },
8895 { PREFIX_TABLE (PREFIX_VEX_0FED
) },
8896 { PREFIX_TABLE (PREFIX_VEX_0FEE
) },
8897 { PREFIX_TABLE (PREFIX_VEX_0FEF
) },
8899 { PREFIX_TABLE (PREFIX_VEX_0FF0
) },
8900 { PREFIX_TABLE (PREFIX_VEX_0FF1
) },
8901 { PREFIX_TABLE (PREFIX_VEX_0FF2
) },
8902 { PREFIX_TABLE (PREFIX_VEX_0FF3
) },
8903 { PREFIX_TABLE (PREFIX_VEX_0FF4
) },
8904 { PREFIX_TABLE (PREFIX_VEX_0FF5
) },
8905 { PREFIX_TABLE (PREFIX_VEX_0FF6
) },
8906 { PREFIX_TABLE (PREFIX_VEX_0FF7
) },
8908 { PREFIX_TABLE (PREFIX_VEX_0FF8
) },
8909 { PREFIX_TABLE (PREFIX_VEX_0FF9
) },
8910 { PREFIX_TABLE (PREFIX_VEX_0FFA
) },
8911 { PREFIX_TABLE (PREFIX_VEX_0FFB
) },
8912 { PREFIX_TABLE (PREFIX_VEX_0FFC
) },
8913 { PREFIX_TABLE (PREFIX_VEX_0FFD
) },
8914 { PREFIX_TABLE (PREFIX_VEX_0FFE
) },
8920 { PREFIX_TABLE (PREFIX_VEX_0F3800
) },
8921 { PREFIX_TABLE (PREFIX_VEX_0F3801
) },
8922 { PREFIX_TABLE (PREFIX_VEX_0F3802
) },
8923 { PREFIX_TABLE (PREFIX_VEX_0F3803
) },
8924 { PREFIX_TABLE (PREFIX_VEX_0F3804
) },
8925 { PREFIX_TABLE (PREFIX_VEX_0F3805
) },
8926 { PREFIX_TABLE (PREFIX_VEX_0F3806
) },
8927 { PREFIX_TABLE (PREFIX_VEX_0F3807
) },
8929 { PREFIX_TABLE (PREFIX_VEX_0F3808
) },
8930 { PREFIX_TABLE (PREFIX_VEX_0F3809
) },
8931 { PREFIX_TABLE (PREFIX_VEX_0F380A
) },
8932 { PREFIX_TABLE (PREFIX_VEX_0F380B
) },
8933 { PREFIX_TABLE (PREFIX_VEX_0F380C
) },
8934 { PREFIX_TABLE (PREFIX_VEX_0F380D
) },
8935 { PREFIX_TABLE (PREFIX_VEX_0F380E
) },
8936 { PREFIX_TABLE (PREFIX_VEX_0F380F
) },
8941 { PREFIX_TABLE (PREFIX_VEX_0F3813
) },
8944 { PREFIX_TABLE (PREFIX_VEX_0F3816
) },
8945 { PREFIX_TABLE (PREFIX_VEX_0F3817
) },
8947 { PREFIX_TABLE (PREFIX_VEX_0F3818
) },
8948 { PREFIX_TABLE (PREFIX_VEX_0F3819
) },
8949 { PREFIX_TABLE (PREFIX_VEX_0F381A
) },
8951 { PREFIX_TABLE (PREFIX_VEX_0F381C
) },
8952 { PREFIX_TABLE (PREFIX_VEX_0F381D
) },
8953 { PREFIX_TABLE (PREFIX_VEX_0F381E
) },
8956 { PREFIX_TABLE (PREFIX_VEX_0F3820
) },
8957 { PREFIX_TABLE (PREFIX_VEX_0F3821
) },
8958 { PREFIX_TABLE (PREFIX_VEX_0F3822
) },
8959 { PREFIX_TABLE (PREFIX_VEX_0F3823
) },
8960 { PREFIX_TABLE (PREFIX_VEX_0F3824
) },
8961 { PREFIX_TABLE (PREFIX_VEX_0F3825
) },
8965 { PREFIX_TABLE (PREFIX_VEX_0F3828
) },
8966 { PREFIX_TABLE (PREFIX_VEX_0F3829
) },
8967 { PREFIX_TABLE (PREFIX_VEX_0F382A
) },
8968 { PREFIX_TABLE (PREFIX_VEX_0F382B
) },
8969 { PREFIX_TABLE (PREFIX_VEX_0F382C
) },
8970 { PREFIX_TABLE (PREFIX_VEX_0F382D
) },
8971 { PREFIX_TABLE (PREFIX_VEX_0F382E
) },
8972 { PREFIX_TABLE (PREFIX_VEX_0F382F
) },
8974 { PREFIX_TABLE (PREFIX_VEX_0F3830
) },
8975 { PREFIX_TABLE (PREFIX_VEX_0F3831
) },
8976 { PREFIX_TABLE (PREFIX_VEX_0F3832
) },
8977 { PREFIX_TABLE (PREFIX_VEX_0F3833
) },
8978 { PREFIX_TABLE (PREFIX_VEX_0F3834
) },
8979 { PREFIX_TABLE (PREFIX_VEX_0F3835
) },
8980 { PREFIX_TABLE (PREFIX_VEX_0F3836
) },
8981 { PREFIX_TABLE (PREFIX_VEX_0F3837
) },
8983 { PREFIX_TABLE (PREFIX_VEX_0F3838
) },
8984 { PREFIX_TABLE (PREFIX_VEX_0F3839
) },
8985 { PREFIX_TABLE (PREFIX_VEX_0F383A
) },
8986 { PREFIX_TABLE (PREFIX_VEX_0F383B
) },
8987 { PREFIX_TABLE (PREFIX_VEX_0F383C
) },
8988 { PREFIX_TABLE (PREFIX_VEX_0F383D
) },
8989 { PREFIX_TABLE (PREFIX_VEX_0F383E
) },
8990 { PREFIX_TABLE (PREFIX_VEX_0F383F
) },
8992 { PREFIX_TABLE (PREFIX_VEX_0F3840
) },
8993 { PREFIX_TABLE (PREFIX_VEX_0F3841
) },
8997 { PREFIX_TABLE (PREFIX_VEX_0F3845
) },
8998 { PREFIX_TABLE (PREFIX_VEX_0F3846
) },
8999 { PREFIX_TABLE (PREFIX_VEX_0F3847
) },
9019 { PREFIX_TABLE (PREFIX_VEX_0F3858
) },
9020 { PREFIX_TABLE (PREFIX_VEX_0F3859
) },
9021 { PREFIX_TABLE (PREFIX_VEX_0F385A
) },
9055 { PREFIX_TABLE (PREFIX_VEX_0F3878
) },
9056 { PREFIX_TABLE (PREFIX_VEX_0F3879
) },
9077 { PREFIX_TABLE (PREFIX_VEX_0F388C
) },
9079 { PREFIX_TABLE (PREFIX_VEX_0F388E
) },
9082 { PREFIX_TABLE (PREFIX_VEX_0F3890
) },
9083 { PREFIX_TABLE (PREFIX_VEX_0F3891
) },
9084 { PREFIX_TABLE (PREFIX_VEX_0F3892
) },
9085 { PREFIX_TABLE (PREFIX_VEX_0F3893
) },
9088 { PREFIX_TABLE (PREFIX_VEX_0F3896
) },
9089 { PREFIX_TABLE (PREFIX_VEX_0F3897
) },
9091 { PREFIX_TABLE (PREFIX_VEX_0F3898
) },
9092 { PREFIX_TABLE (PREFIX_VEX_0F3899
) },
9093 { PREFIX_TABLE (PREFIX_VEX_0F389A
) },
9094 { PREFIX_TABLE (PREFIX_VEX_0F389B
) },
9095 { PREFIX_TABLE (PREFIX_VEX_0F389C
) },
9096 { PREFIX_TABLE (PREFIX_VEX_0F389D
) },
9097 { PREFIX_TABLE (PREFIX_VEX_0F389E
) },
9098 { PREFIX_TABLE (PREFIX_VEX_0F389F
) },
9106 { PREFIX_TABLE (PREFIX_VEX_0F38A6
) },
9107 { PREFIX_TABLE (PREFIX_VEX_0F38A7
) },
9109 { PREFIX_TABLE (PREFIX_VEX_0F38A8
) },
9110 { PREFIX_TABLE (PREFIX_VEX_0F38A9
) },
9111 { PREFIX_TABLE (PREFIX_VEX_0F38AA
) },
9112 { PREFIX_TABLE (PREFIX_VEX_0F38AB
) },
9113 { PREFIX_TABLE (PREFIX_VEX_0F38AC
) },
9114 { PREFIX_TABLE (PREFIX_VEX_0F38AD
) },
9115 { PREFIX_TABLE (PREFIX_VEX_0F38AE
) },
9116 { PREFIX_TABLE (PREFIX_VEX_0F38AF
) },
9124 { PREFIX_TABLE (PREFIX_VEX_0F38B6
) },
9125 { PREFIX_TABLE (PREFIX_VEX_0F38B7
) },
9127 { PREFIX_TABLE (PREFIX_VEX_0F38B8
) },
9128 { PREFIX_TABLE (PREFIX_VEX_0F38B9
) },
9129 { PREFIX_TABLE (PREFIX_VEX_0F38BA
) },
9130 { PREFIX_TABLE (PREFIX_VEX_0F38BB
) },
9131 { PREFIX_TABLE (PREFIX_VEX_0F38BC
) },
9132 { PREFIX_TABLE (PREFIX_VEX_0F38BD
) },
9133 { PREFIX_TABLE (PREFIX_VEX_0F38BE
) },
9134 { PREFIX_TABLE (PREFIX_VEX_0F38BF
) },
9166 { PREFIX_TABLE (PREFIX_VEX_0F38DB
) },
9167 { PREFIX_TABLE (PREFIX_VEX_0F38DC
) },
9168 { PREFIX_TABLE (PREFIX_VEX_0F38DD
) },
9169 { PREFIX_TABLE (PREFIX_VEX_0F38DE
) },
9170 { PREFIX_TABLE (PREFIX_VEX_0F38DF
) },
9192 { PREFIX_TABLE (PREFIX_VEX_0F38F2
) },
9193 { REG_TABLE (REG_VEX_0F38F3
) },
9195 { PREFIX_TABLE (PREFIX_VEX_0F38F5
) },
9196 { PREFIX_TABLE (PREFIX_VEX_0F38F6
) },
9197 { PREFIX_TABLE (PREFIX_VEX_0F38F7
) },
9211 { PREFIX_TABLE (PREFIX_VEX_0F3A00
) },
9212 { PREFIX_TABLE (PREFIX_VEX_0F3A01
) },
9213 { PREFIX_TABLE (PREFIX_VEX_0F3A02
) },
9215 { PREFIX_TABLE (PREFIX_VEX_0F3A04
) },
9216 { PREFIX_TABLE (PREFIX_VEX_0F3A05
) },
9217 { PREFIX_TABLE (PREFIX_VEX_0F3A06
) },
9220 { PREFIX_TABLE (PREFIX_VEX_0F3A08
) },
9221 { PREFIX_TABLE (PREFIX_VEX_0F3A09
) },
9222 { PREFIX_TABLE (PREFIX_VEX_0F3A0A
) },
9223 { PREFIX_TABLE (PREFIX_VEX_0F3A0B
) },
9224 { PREFIX_TABLE (PREFIX_VEX_0F3A0C
) },
9225 { PREFIX_TABLE (PREFIX_VEX_0F3A0D
) },
9226 { PREFIX_TABLE (PREFIX_VEX_0F3A0E
) },
9227 { PREFIX_TABLE (PREFIX_VEX_0F3A0F
) },
9233 { PREFIX_TABLE (PREFIX_VEX_0F3A14
) },
9234 { PREFIX_TABLE (PREFIX_VEX_0F3A15
) },
9235 { PREFIX_TABLE (PREFIX_VEX_0F3A16
) },
9236 { PREFIX_TABLE (PREFIX_VEX_0F3A17
) },
9238 { PREFIX_TABLE (PREFIX_VEX_0F3A18
) },
9239 { PREFIX_TABLE (PREFIX_VEX_0F3A19
) },
9243 { PREFIX_TABLE (PREFIX_VEX_0F3A1D
) },
9247 { PREFIX_TABLE (PREFIX_VEX_0F3A20
) },
9248 { PREFIX_TABLE (PREFIX_VEX_0F3A21
) },
9249 { PREFIX_TABLE (PREFIX_VEX_0F3A22
) },
9265 { PREFIX_TABLE (PREFIX_VEX_0F3A30
) },
9266 { PREFIX_TABLE (PREFIX_VEX_0F3A31
) },
9267 { PREFIX_TABLE (PREFIX_VEX_0F3A32
) },
9268 { PREFIX_TABLE (PREFIX_VEX_0F3A33
) },
9274 { PREFIX_TABLE (PREFIX_VEX_0F3A38
) },
9275 { PREFIX_TABLE (PREFIX_VEX_0F3A39
) },
9283 { PREFIX_TABLE (PREFIX_VEX_0F3A40
) },
9284 { PREFIX_TABLE (PREFIX_VEX_0F3A41
) },
9285 { PREFIX_TABLE (PREFIX_VEX_0F3A42
) },
9287 { PREFIX_TABLE (PREFIX_VEX_0F3A44
) },
9289 { PREFIX_TABLE (PREFIX_VEX_0F3A46
) },
9292 { PREFIX_TABLE (PREFIX_VEX_0F3A48
) },
9293 { PREFIX_TABLE (PREFIX_VEX_0F3A49
) },
9294 { PREFIX_TABLE (PREFIX_VEX_0F3A4A
) },
9295 { PREFIX_TABLE (PREFIX_VEX_0F3A4B
) },
9296 { PREFIX_TABLE (PREFIX_VEX_0F3A4C
) },
9314 { PREFIX_TABLE (PREFIX_VEX_0F3A5C
) },
9315 { PREFIX_TABLE (PREFIX_VEX_0F3A5D
) },
9316 { PREFIX_TABLE (PREFIX_VEX_0F3A5E
) },
9317 { PREFIX_TABLE (PREFIX_VEX_0F3A5F
) },
9319 { PREFIX_TABLE (PREFIX_VEX_0F3A60
) },
9320 { PREFIX_TABLE (PREFIX_VEX_0F3A61
) },
9321 { PREFIX_TABLE (PREFIX_VEX_0F3A62
) },
9322 { PREFIX_TABLE (PREFIX_VEX_0F3A63
) },
9328 { PREFIX_TABLE (PREFIX_VEX_0F3A68
) },
9329 { PREFIX_TABLE (PREFIX_VEX_0F3A69
) },
9330 { PREFIX_TABLE (PREFIX_VEX_0F3A6A
) },
9331 { PREFIX_TABLE (PREFIX_VEX_0F3A6B
) },
9332 { PREFIX_TABLE (PREFIX_VEX_0F3A6C
) },
9333 { PREFIX_TABLE (PREFIX_VEX_0F3A6D
) },
9334 { PREFIX_TABLE (PREFIX_VEX_0F3A6E
) },
9335 { PREFIX_TABLE (PREFIX_VEX_0F3A6F
) },
9346 { PREFIX_TABLE (PREFIX_VEX_0F3A78
) },
9347 { PREFIX_TABLE (PREFIX_VEX_0F3A79
) },
9348 { PREFIX_TABLE (PREFIX_VEX_0F3A7A
) },
9349 { PREFIX_TABLE (PREFIX_VEX_0F3A7B
) },
9350 { PREFIX_TABLE (PREFIX_VEX_0F3A7C
) },
9351 { PREFIX_TABLE (PREFIX_VEX_0F3A7D
) },
9352 { PREFIX_TABLE (PREFIX_VEX_0F3A7E
) },
9353 { PREFIX_TABLE (PREFIX_VEX_0F3A7F
) },
9461 { PREFIX_TABLE (PREFIX_VEX_0F3ADF
) },
9481 { PREFIX_TABLE (PREFIX_VEX_0F3AF0
) },
9501 #define NEED_OPCODE_TABLE
9502 #include "i386-dis-evex.h"
9503 #undef NEED_OPCODE_TABLE
9504 static const struct dis386 vex_len_table
[][2] = {
9505 /* VEX_LEN_0F10_P_1 */
9507 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
9508 { VEX_W_TABLE (VEX_W_0F10_P_1
) },
9511 /* VEX_LEN_0F10_P_3 */
9513 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
9514 { VEX_W_TABLE (VEX_W_0F10_P_3
) },
9517 /* VEX_LEN_0F11_P_1 */
9519 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
9520 { VEX_W_TABLE (VEX_W_0F11_P_1
) },
9523 /* VEX_LEN_0F11_P_3 */
9525 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
9526 { VEX_W_TABLE (VEX_W_0F11_P_3
) },
9529 /* VEX_LEN_0F12_P_0_M_0 */
9531 { VEX_W_TABLE (VEX_W_0F12_P_0_M_0
) },
9534 /* VEX_LEN_0F12_P_0_M_1 */
9536 { VEX_W_TABLE (VEX_W_0F12_P_0_M_1
) },
9539 /* VEX_LEN_0F12_P_2 */
9541 { VEX_W_TABLE (VEX_W_0F12_P_2
) },
9544 /* VEX_LEN_0F13_M_0 */
9546 { VEX_W_TABLE (VEX_W_0F13_M_0
) },
9549 /* VEX_LEN_0F16_P_0_M_0 */
9551 { VEX_W_TABLE (VEX_W_0F16_P_0_M_0
) },
9554 /* VEX_LEN_0F16_P_0_M_1 */
9556 { VEX_W_TABLE (VEX_W_0F16_P_0_M_1
) },
9559 /* VEX_LEN_0F16_P_2 */
9561 { VEX_W_TABLE (VEX_W_0F16_P_2
) },
9564 /* VEX_LEN_0F17_M_0 */
9566 { VEX_W_TABLE (VEX_W_0F17_M_0
) },
9569 /* VEX_LEN_0F2A_P_1 */
9571 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9572 { "vcvtsi2ss%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9575 /* VEX_LEN_0F2A_P_3 */
9577 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9578 { "vcvtsi2sd%LQ", { XMScalar
, VexScalar
, Ev
}, 0 },
9581 /* VEX_LEN_0F2C_P_1 */
9583 { "vcvttss2siY", { Gv
, EXdScalar
}, 0 },
9584 { "vcvttss2siY", { Gv
, EXdScalar
}, 0 },
9587 /* VEX_LEN_0F2C_P_3 */
9589 { "vcvttsd2siY", { Gv
, EXqScalar
}, 0 },
9590 { "vcvttsd2siY", { Gv
, EXqScalar
}, 0 },
9593 /* VEX_LEN_0F2D_P_1 */
9595 { "vcvtss2siY", { Gv
, EXdScalar
}, 0 },
9596 { "vcvtss2siY", { Gv
, EXdScalar
}, 0 },
9599 /* VEX_LEN_0F2D_P_3 */
9601 { "vcvtsd2siY", { Gv
, EXqScalar
}, 0 },
9602 { "vcvtsd2siY", { Gv
, EXqScalar
}, 0 },
9605 /* VEX_LEN_0F2E_P_0 */
9607 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
9608 { VEX_W_TABLE (VEX_W_0F2E_P_0
) },
9611 /* VEX_LEN_0F2E_P_2 */
9613 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
9614 { VEX_W_TABLE (VEX_W_0F2E_P_2
) },
9617 /* VEX_LEN_0F2F_P_0 */
9619 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
9620 { VEX_W_TABLE (VEX_W_0F2F_P_0
) },
9623 /* VEX_LEN_0F2F_P_2 */
9625 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
9626 { VEX_W_TABLE (VEX_W_0F2F_P_2
) },
9629 /* VEX_LEN_0F41_P_0 */
9632 { VEX_W_TABLE (VEX_W_0F41_P_0_LEN_1
) },
9634 /* VEX_LEN_0F41_P_2 */
9637 { VEX_W_TABLE (VEX_W_0F41_P_2_LEN_1
) },
9639 /* VEX_LEN_0F42_P_0 */
9642 { VEX_W_TABLE (VEX_W_0F42_P_0_LEN_1
) },
9644 /* VEX_LEN_0F42_P_2 */
9647 { VEX_W_TABLE (VEX_W_0F42_P_2_LEN_1
) },
9649 /* VEX_LEN_0F44_P_0 */
9651 { VEX_W_TABLE (VEX_W_0F44_P_0_LEN_0
) },
9653 /* VEX_LEN_0F44_P_2 */
9655 { VEX_W_TABLE (VEX_W_0F44_P_2_LEN_0
) },
9657 /* VEX_LEN_0F45_P_0 */
9660 { VEX_W_TABLE (VEX_W_0F45_P_0_LEN_1
) },
9662 /* VEX_LEN_0F45_P_2 */
9665 { VEX_W_TABLE (VEX_W_0F45_P_2_LEN_1
) },
9667 /* VEX_LEN_0F46_P_0 */
9670 { VEX_W_TABLE (VEX_W_0F46_P_0_LEN_1
) },
9672 /* VEX_LEN_0F46_P_2 */
9675 { VEX_W_TABLE (VEX_W_0F46_P_2_LEN_1
) },
9677 /* VEX_LEN_0F47_P_0 */
9680 { VEX_W_TABLE (VEX_W_0F47_P_0_LEN_1
) },
9682 /* VEX_LEN_0F47_P_2 */
9685 { VEX_W_TABLE (VEX_W_0F47_P_2_LEN_1
) },
9687 /* VEX_LEN_0F4A_P_0 */
9690 { VEX_W_TABLE (VEX_W_0F4A_P_0_LEN_1
) },
9692 /* VEX_LEN_0F4A_P_2 */
9695 { VEX_W_TABLE (VEX_W_0F4A_P_2_LEN_1
) },
9697 /* VEX_LEN_0F4B_P_0 */
9700 { VEX_W_TABLE (VEX_W_0F4B_P_0_LEN_1
) },
9702 /* VEX_LEN_0F4B_P_2 */
9705 { VEX_W_TABLE (VEX_W_0F4B_P_2_LEN_1
) },
9708 /* VEX_LEN_0F51_P_1 */
9710 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
9711 { VEX_W_TABLE (VEX_W_0F51_P_1
) },
9714 /* VEX_LEN_0F51_P_3 */
9716 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
9717 { VEX_W_TABLE (VEX_W_0F51_P_3
) },
9720 /* VEX_LEN_0F52_P_1 */
9722 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
9723 { VEX_W_TABLE (VEX_W_0F52_P_1
) },
9726 /* VEX_LEN_0F53_P_1 */
9728 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
9729 { VEX_W_TABLE (VEX_W_0F53_P_1
) },
9732 /* VEX_LEN_0F58_P_1 */
9734 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
9735 { VEX_W_TABLE (VEX_W_0F58_P_1
) },
9738 /* VEX_LEN_0F58_P_3 */
9740 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
9741 { VEX_W_TABLE (VEX_W_0F58_P_3
) },
9744 /* VEX_LEN_0F59_P_1 */
9746 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
9747 { VEX_W_TABLE (VEX_W_0F59_P_1
) },
9750 /* VEX_LEN_0F59_P_3 */
9752 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
9753 { VEX_W_TABLE (VEX_W_0F59_P_3
) },
9756 /* VEX_LEN_0F5A_P_1 */
9758 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
9759 { VEX_W_TABLE (VEX_W_0F5A_P_1
) },
9762 /* VEX_LEN_0F5A_P_3 */
9764 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
9765 { VEX_W_TABLE (VEX_W_0F5A_P_3
) },
9768 /* VEX_LEN_0F5C_P_1 */
9770 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
9771 { VEX_W_TABLE (VEX_W_0F5C_P_1
) },
9774 /* VEX_LEN_0F5C_P_3 */
9776 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
9777 { VEX_W_TABLE (VEX_W_0F5C_P_3
) },
9780 /* VEX_LEN_0F5D_P_1 */
9782 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
9783 { VEX_W_TABLE (VEX_W_0F5D_P_1
) },
9786 /* VEX_LEN_0F5D_P_3 */
9788 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
9789 { VEX_W_TABLE (VEX_W_0F5D_P_3
) },
9792 /* VEX_LEN_0F5E_P_1 */
9794 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
9795 { VEX_W_TABLE (VEX_W_0F5E_P_1
) },
9798 /* VEX_LEN_0F5E_P_3 */
9800 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
9801 { VEX_W_TABLE (VEX_W_0F5E_P_3
) },
9804 /* VEX_LEN_0F5F_P_1 */
9806 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
9807 { VEX_W_TABLE (VEX_W_0F5F_P_1
) },
9810 /* VEX_LEN_0F5F_P_3 */
9812 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
9813 { VEX_W_TABLE (VEX_W_0F5F_P_3
) },
9816 /* VEX_LEN_0F6E_P_2 */
9818 { "vmovK", { XMScalar
, Edq
}, 0 },
9819 { "vmovK", { XMScalar
, Edq
}, 0 },
9822 /* VEX_LEN_0F7E_P_1 */
9824 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
9825 { VEX_W_TABLE (VEX_W_0F7E_P_1
) },
9828 /* VEX_LEN_0F7E_P_2 */
9830 { "vmovK", { Edq
, XMScalar
}, 0 },
9831 { "vmovK", { Edq
, XMScalar
}, 0 },
9834 /* VEX_LEN_0F90_P_0 */
9836 { VEX_W_TABLE (VEX_W_0F90_P_0_LEN_0
) },
9839 /* VEX_LEN_0F90_P_2 */
9841 { VEX_W_TABLE (VEX_W_0F90_P_2_LEN_0
) },
9844 /* VEX_LEN_0F91_P_0 */
9846 { VEX_W_TABLE (VEX_W_0F91_P_0_LEN_0
) },
9849 /* VEX_LEN_0F91_P_2 */
9851 { VEX_W_TABLE (VEX_W_0F91_P_2_LEN_0
) },
9854 /* VEX_LEN_0F92_P_0 */
9856 { VEX_W_TABLE (VEX_W_0F92_P_0_LEN_0
) },
9859 /* VEX_LEN_0F92_P_2 */
9861 { VEX_W_TABLE (VEX_W_0F92_P_2_LEN_0
) },
9864 /* VEX_LEN_0F92_P_3 */
9866 { VEX_W_TABLE (VEX_W_0F92_P_3_LEN_0
) },
9869 /* VEX_LEN_0F93_P_0 */
9871 { VEX_W_TABLE (VEX_W_0F93_P_0_LEN_0
) },
9874 /* VEX_LEN_0F93_P_2 */
9876 { VEX_W_TABLE (VEX_W_0F93_P_2_LEN_0
) },
9879 /* VEX_LEN_0F93_P_3 */
9881 { VEX_W_TABLE (VEX_W_0F93_P_3_LEN_0
) },
9884 /* VEX_LEN_0F98_P_0 */
9886 { VEX_W_TABLE (VEX_W_0F98_P_0_LEN_0
) },
9889 /* VEX_LEN_0F98_P_2 */
9891 { VEX_W_TABLE (VEX_W_0F98_P_2_LEN_0
) },
9894 /* VEX_LEN_0F99_P_0 */
9896 { VEX_W_TABLE (VEX_W_0F99_P_0_LEN_0
) },
9899 /* VEX_LEN_0F99_P_2 */
9901 { VEX_W_TABLE (VEX_W_0F99_P_2_LEN_0
) },
9904 /* VEX_LEN_0FAE_R_2_M_0 */
9906 { VEX_W_TABLE (VEX_W_0FAE_R_2_M_0
) },
9909 /* VEX_LEN_0FAE_R_3_M_0 */
9911 { VEX_W_TABLE (VEX_W_0FAE_R_3_M_0
) },
9914 /* VEX_LEN_0FC2_P_1 */
9916 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
9917 { VEX_W_TABLE (VEX_W_0FC2_P_1
) },
9920 /* VEX_LEN_0FC2_P_3 */
9922 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
9923 { VEX_W_TABLE (VEX_W_0FC2_P_3
) },
9926 /* VEX_LEN_0FC4_P_2 */
9928 { VEX_W_TABLE (VEX_W_0FC4_P_2
) },
9931 /* VEX_LEN_0FC5_P_2 */
9933 { VEX_W_TABLE (VEX_W_0FC5_P_2
) },
9936 /* VEX_LEN_0FD6_P_2 */
9938 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
9939 { VEX_W_TABLE (VEX_W_0FD6_P_2
) },
9942 /* VEX_LEN_0FF7_P_2 */
9944 { VEX_W_TABLE (VEX_W_0FF7_P_2
) },
9947 /* VEX_LEN_0F3816_P_2 */
9950 { VEX_W_TABLE (VEX_W_0F3816_P_2
) },
9953 /* VEX_LEN_0F3819_P_2 */
9956 { VEX_W_TABLE (VEX_W_0F3819_P_2
) },
9959 /* VEX_LEN_0F381A_P_2_M_0 */
9962 { VEX_W_TABLE (VEX_W_0F381A_P_2_M_0
) },
9965 /* VEX_LEN_0F3836_P_2 */
9968 { VEX_W_TABLE (VEX_W_0F3836_P_2
) },
9971 /* VEX_LEN_0F3841_P_2 */
9973 { VEX_W_TABLE (VEX_W_0F3841_P_2
) },
9976 /* VEX_LEN_0F385A_P_2_M_0 */
9979 { VEX_W_TABLE (VEX_W_0F385A_P_2_M_0
) },
9982 /* VEX_LEN_0F38DB_P_2 */
9984 { VEX_W_TABLE (VEX_W_0F38DB_P_2
) },
9987 /* VEX_LEN_0F38DC_P_2 */
9989 { VEX_W_TABLE (VEX_W_0F38DC_P_2
) },
9992 /* VEX_LEN_0F38DD_P_2 */
9994 { VEX_W_TABLE (VEX_W_0F38DD_P_2
) },
9997 /* VEX_LEN_0F38DE_P_2 */
9999 { VEX_W_TABLE (VEX_W_0F38DE_P_2
) },
10002 /* VEX_LEN_0F38DF_P_2 */
10004 { VEX_W_TABLE (VEX_W_0F38DF_P_2
) },
10007 /* VEX_LEN_0F38F2_P_0 */
10009 { "andnS", { Gdq
, VexGdq
, Edq
}, 0 },
10012 /* VEX_LEN_0F38F3_R_1_P_0 */
10014 { "blsrS", { VexGdq
, Edq
}, 0 },
10017 /* VEX_LEN_0F38F3_R_2_P_0 */
10019 { "blsmskS", { VexGdq
, Edq
}, 0 },
10022 /* VEX_LEN_0F38F3_R_3_P_0 */
10024 { "blsiS", { VexGdq
, Edq
}, 0 },
10027 /* VEX_LEN_0F38F5_P_0 */
10029 { "bzhiS", { Gdq
, Edq
, VexGdq
}, 0 },
10032 /* VEX_LEN_0F38F5_P_1 */
10034 { "pextS", { Gdq
, VexGdq
, Edq
}, 0 },
10037 /* VEX_LEN_0F38F5_P_3 */
10039 { "pdepS", { Gdq
, VexGdq
, Edq
}, 0 },
10042 /* VEX_LEN_0F38F6_P_3 */
10044 { "mulxS", { Gdq
, VexGdq
, Edq
}, 0 },
10047 /* VEX_LEN_0F38F7_P_0 */
10049 { "bextrS", { Gdq
, Edq
, VexGdq
}, 0 },
10052 /* VEX_LEN_0F38F7_P_1 */
10054 { "sarxS", { Gdq
, Edq
, VexGdq
}, 0 },
10057 /* VEX_LEN_0F38F7_P_2 */
10059 { "shlxS", { Gdq
, Edq
, VexGdq
}, 0 },
10062 /* VEX_LEN_0F38F7_P_3 */
10064 { "shrxS", { Gdq
, Edq
, VexGdq
}, 0 },
10067 /* VEX_LEN_0F3A00_P_2 */
10070 { VEX_W_TABLE (VEX_W_0F3A00_P_2
) },
10073 /* VEX_LEN_0F3A01_P_2 */
10076 { VEX_W_TABLE (VEX_W_0F3A01_P_2
) },
10079 /* VEX_LEN_0F3A06_P_2 */
10082 { VEX_W_TABLE (VEX_W_0F3A06_P_2
) },
10085 /* VEX_LEN_0F3A0A_P_2 */
10087 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
10088 { VEX_W_TABLE (VEX_W_0F3A0A_P_2
) },
10091 /* VEX_LEN_0F3A0B_P_2 */
10093 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
10094 { VEX_W_TABLE (VEX_W_0F3A0B_P_2
) },
10097 /* VEX_LEN_0F3A14_P_2 */
10099 { VEX_W_TABLE (VEX_W_0F3A14_P_2
) },
10102 /* VEX_LEN_0F3A15_P_2 */
10104 { VEX_W_TABLE (VEX_W_0F3A15_P_2
) },
10107 /* VEX_LEN_0F3A16_P_2 */
10109 { "vpextrK", { Edq
, XM
, Ib
}, 0 },
10112 /* VEX_LEN_0F3A17_P_2 */
10114 { "vextractps", { Edqd
, XM
, Ib
}, 0 },
10117 /* VEX_LEN_0F3A18_P_2 */
10120 { VEX_W_TABLE (VEX_W_0F3A18_P_2
) },
10123 /* VEX_LEN_0F3A19_P_2 */
10126 { VEX_W_TABLE (VEX_W_0F3A19_P_2
) },
10129 /* VEX_LEN_0F3A20_P_2 */
10131 { VEX_W_TABLE (VEX_W_0F3A20_P_2
) },
10134 /* VEX_LEN_0F3A21_P_2 */
10136 { VEX_W_TABLE (VEX_W_0F3A21_P_2
) },
10139 /* VEX_LEN_0F3A22_P_2 */
10141 { "vpinsrK", { XM
, Vex128
, Edq
, Ib
}, 0 },
10144 /* VEX_LEN_0F3A30_P_2 */
10146 { VEX_W_TABLE (VEX_W_0F3A30_P_2_LEN_0
) },
10149 /* VEX_LEN_0F3A31_P_2 */
10151 { VEX_W_TABLE (VEX_W_0F3A31_P_2_LEN_0
) },
10154 /* VEX_LEN_0F3A32_P_2 */
10156 { VEX_W_TABLE (VEX_W_0F3A32_P_2_LEN_0
) },
10159 /* VEX_LEN_0F3A33_P_2 */
10161 { VEX_W_TABLE (VEX_W_0F3A33_P_2_LEN_0
) },
10164 /* VEX_LEN_0F3A38_P_2 */
10167 { VEX_W_TABLE (VEX_W_0F3A38_P_2
) },
10170 /* VEX_LEN_0F3A39_P_2 */
10173 { VEX_W_TABLE (VEX_W_0F3A39_P_2
) },
10176 /* VEX_LEN_0F3A41_P_2 */
10178 { VEX_W_TABLE (VEX_W_0F3A41_P_2
) },
10181 /* VEX_LEN_0F3A44_P_2 */
10183 { VEX_W_TABLE (VEX_W_0F3A44_P_2
) },
10186 /* VEX_LEN_0F3A46_P_2 */
10189 { VEX_W_TABLE (VEX_W_0F3A46_P_2
) },
10192 /* VEX_LEN_0F3A60_P_2 */
10194 { VEX_W_TABLE (VEX_W_0F3A60_P_2
) },
10197 /* VEX_LEN_0F3A61_P_2 */
10199 { VEX_W_TABLE (VEX_W_0F3A61_P_2
) },
10202 /* VEX_LEN_0F3A62_P_2 */
10204 { VEX_W_TABLE (VEX_W_0F3A62_P_2
) },
10207 /* VEX_LEN_0F3A63_P_2 */
10209 { VEX_W_TABLE (VEX_W_0F3A63_P_2
) },
10212 /* VEX_LEN_0F3A6A_P_2 */
10214 { "vfmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10217 /* VEX_LEN_0F3A6B_P_2 */
10219 { "vfmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10222 /* VEX_LEN_0F3A6E_P_2 */
10224 { "vfmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10227 /* VEX_LEN_0F3A6F_P_2 */
10229 { "vfmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10232 /* VEX_LEN_0F3A7A_P_2 */
10234 { "vfnmaddss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10237 /* VEX_LEN_0F3A7B_P_2 */
10239 { "vfnmaddsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10242 /* VEX_LEN_0F3A7E_P_2 */
10244 { "vfnmsubss", { XMVexW
, Vex128
, EXdVexW
, EXdVexW
, VexI4
}, 0 },
10247 /* VEX_LEN_0F3A7F_P_2 */
10249 { "vfnmsubsd", { XMVexW
, Vex128
, EXqVexW
, EXqVexW
, VexI4
}, 0 },
10252 /* VEX_LEN_0F3ADF_P_2 */
10254 { VEX_W_TABLE (VEX_W_0F3ADF_P_2
) },
10257 /* VEX_LEN_0F3AF0_P_3 */
10259 { "rorxS", { Gdq
, Edq
, Ib
}, 0 },
10262 /* VEX_LEN_0FXOP_08_CC */
10264 { "vpcomb", { XM
, Vex128
, EXx
, Ib
}, 0 },
10267 /* VEX_LEN_0FXOP_08_CD */
10269 { "vpcomw", { XM
, Vex128
, EXx
, Ib
}, 0 },
10272 /* VEX_LEN_0FXOP_08_CE */
10274 { "vpcomd", { XM
, Vex128
, EXx
, Ib
}, 0 },
10277 /* VEX_LEN_0FXOP_08_CF */
10279 { "vpcomq", { XM
, Vex128
, EXx
, Ib
}, 0 },
10282 /* VEX_LEN_0FXOP_08_EC */
10284 { "vpcomub", { XM
, Vex128
, EXx
, Ib
}, 0 },
10287 /* VEX_LEN_0FXOP_08_ED */
10289 { "vpcomuw", { XM
, Vex128
, EXx
, Ib
}, 0 },
10292 /* VEX_LEN_0FXOP_08_EE */
10294 { "vpcomud", { XM
, Vex128
, EXx
, Ib
}, 0 },
10297 /* VEX_LEN_0FXOP_08_EF */
10299 { "vpcomuq", { XM
, Vex128
, EXx
, Ib
}, 0 },
10302 /* VEX_LEN_0FXOP_09_80 */
10304 { "vfrczps", { XM
, EXxmm
}, 0 },
10305 { "vfrczps", { XM
, EXymmq
}, 0 },
10308 /* VEX_LEN_0FXOP_09_81 */
10310 { "vfrczpd", { XM
, EXxmm
}, 0 },
10311 { "vfrczpd", { XM
, EXymmq
}, 0 },
10315 static const struct dis386 vex_w_table
[][2] = {
10317 /* VEX_W_0F10_P_0 */
10318 { "vmovups", { XM
, EXx
}, 0 },
10321 /* VEX_W_0F10_P_1 */
10322 { "vmovss", { XMVexScalar
, VexScalar
, EXdScalar
}, 0 },
10325 /* VEX_W_0F10_P_2 */
10326 { "vmovupd", { XM
, EXx
}, 0 },
10329 /* VEX_W_0F10_P_3 */
10330 { "vmovsd", { XMVexScalar
, VexScalar
, EXqScalar
}, 0 },
10333 /* VEX_W_0F11_P_0 */
10334 { "vmovups", { EXxS
, XM
}, 0 },
10337 /* VEX_W_0F11_P_1 */
10338 { "vmovss", { EXdVexScalarS
, VexScalar
, XMScalar
}, 0 },
10341 /* VEX_W_0F11_P_2 */
10342 { "vmovupd", { EXxS
, XM
}, 0 },
10345 /* VEX_W_0F11_P_3 */
10346 { "vmovsd", { EXqVexScalarS
, VexScalar
, XMScalar
}, 0 },
10349 /* VEX_W_0F12_P_0_M_0 */
10350 { "vmovlps", { XM
, Vex128
, EXq
}, 0 },
10353 /* VEX_W_0F12_P_0_M_1 */
10354 { "vmovhlps", { XM
, Vex128
, EXq
}, 0 },
10357 /* VEX_W_0F12_P_1 */
10358 { "vmovsldup", { XM
, EXx
}, 0 },
10361 /* VEX_W_0F12_P_2 */
10362 { "vmovlpd", { XM
, Vex128
, EXq
}, 0 },
10365 /* VEX_W_0F12_P_3 */
10366 { "vmovddup", { XM
, EXymmq
}, 0 },
10369 /* VEX_W_0F13_M_0 */
10370 { "vmovlpX", { EXq
, XM
}, 0 },
10374 { "vunpcklpX", { XM
, Vex
, EXx
}, 0 },
10378 { "vunpckhpX", { XM
, Vex
, EXx
}, 0 },
10381 /* VEX_W_0F16_P_0_M_0 */
10382 { "vmovhps", { XM
, Vex128
, EXq
}, 0 },
10385 /* VEX_W_0F16_P_0_M_1 */
10386 { "vmovlhps", { XM
, Vex128
, EXq
}, 0 },
10389 /* VEX_W_0F16_P_1 */
10390 { "vmovshdup", { XM
, EXx
}, 0 },
10393 /* VEX_W_0F16_P_2 */
10394 { "vmovhpd", { XM
, Vex128
, EXq
}, 0 },
10397 /* VEX_W_0F17_M_0 */
10398 { "vmovhpX", { EXq
, XM
}, 0 },
10402 { "vmovapX", { XM
, EXx
}, 0 },
10406 { "vmovapX", { EXxS
, XM
}, 0 },
10409 /* VEX_W_0F2B_M_0 */
10410 { "vmovntpX", { Mx
, XM
}, 0 },
10413 /* VEX_W_0F2E_P_0 */
10414 { "vucomiss", { XMScalar
, EXdScalar
}, 0 },
10417 /* VEX_W_0F2E_P_2 */
10418 { "vucomisd", { XMScalar
, EXqScalar
}, 0 },
10421 /* VEX_W_0F2F_P_0 */
10422 { "vcomiss", { XMScalar
, EXdScalar
}, 0 },
10425 /* VEX_W_0F2F_P_2 */
10426 { "vcomisd", { XMScalar
, EXqScalar
}, 0 },
10429 /* VEX_W_0F41_P_0_LEN_1 */
10430 { "kandw", { MaskG
, MaskVex
, MaskR
}, 0 },
10431 { "kandq", { MaskG
, MaskVex
, MaskR
}, 0 },
10434 /* VEX_W_0F41_P_2_LEN_1 */
10435 { "kandb", { MaskG
, MaskVex
, MaskR
}, 0 },
10436 { "kandd", { MaskG
, MaskVex
, MaskR
}, 0 },
10439 /* VEX_W_0F42_P_0_LEN_1 */
10440 { "kandnw", { MaskG
, MaskVex
, MaskR
}, 0 },
10441 { "kandnq", { MaskG
, MaskVex
, MaskR
}, 0 },
10444 /* VEX_W_0F42_P_2_LEN_1 */
10445 { "kandnb", { MaskG
, MaskVex
, MaskR
}, 0 },
10446 { "kandnd", { MaskG
, MaskVex
, MaskR
}, 0 },
10449 /* VEX_W_0F44_P_0_LEN_0 */
10450 { "knotw", { MaskG
, MaskR
}, 0 },
10451 { "knotq", { MaskG
, MaskR
}, 0 },
10454 /* VEX_W_0F44_P_2_LEN_0 */
10455 { "knotb", { MaskG
, MaskR
}, 0 },
10456 { "knotd", { MaskG
, MaskR
}, 0 },
10459 /* VEX_W_0F45_P_0_LEN_1 */
10460 { "korw", { MaskG
, MaskVex
, MaskR
}, 0 },
10461 { "korq", { MaskG
, MaskVex
, MaskR
}, 0 },
10464 /* VEX_W_0F45_P_2_LEN_1 */
10465 { "korb", { MaskG
, MaskVex
, MaskR
}, 0 },
10466 { "kord", { MaskG
, MaskVex
, MaskR
}, 0 },
10469 /* VEX_W_0F46_P_0_LEN_1 */
10470 { "kxnorw", { MaskG
, MaskVex
, MaskR
}, 0 },
10471 { "kxnorq", { MaskG
, MaskVex
, MaskR
}, 0 },
10474 /* VEX_W_0F46_P_2_LEN_1 */
10475 { "kxnorb", { MaskG
, MaskVex
, MaskR
}, 0 },
10476 { "kxnord", { MaskG
, MaskVex
, MaskR
}, 0 },
10479 /* VEX_W_0F47_P_0_LEN_1 */
10480 { "kxorw", { MaskG
, MaskVex
, MaskR
}, 0 },
10481 { "kxorq", { MaskG
, MaskVex
, MaskR
}, 0 },
10484 /* VEX_W_0F47_P_2_LEN_1 */
10485 { "kxorb", { MaskG
, MaskVex
, MaskR
}, 0 },
10486 { "kxord", { MaskG
, MaskVex
, MaskR
}, 0 },
10489 /* VEX_W_0F4A_P_0_LEN_1 */
10490 { "kaddw", { MaskG
, MaskVex
, MaskR
}, 0 },
10491 { "kaddq", { MaskG
, MaskVex
, MaskR
}, 0 },
10494 /* VEX_W_0F4A_P_2_LEN_1 */
10495 { "kaddb", { MaskG
, MaskVex
, MaskR
}, 0 },
10496 { "kaddd", { MaskG
, MaskVex
, MaskR
}, 0 },
10499 /* VEX_W_0F4B_P_0_LEN_1 */
10500 { "kunpckwd", { MaskG
, MaskVex
, MaskR
}, 0 },
10501 { "kunpckdq", { MaskG
, MaskVex
, MaskR
}, 0 },
10504 /* VEX_W_0F4B_P_2_LEN_1 */
10505 { "kunpckbw", { MaskG
, MaskVex
, MaskR
}, 0 },
10508 /* VEX_W_0F50_M_0 */
10509 { "vmovmskpX", { Gdq
, XS
}, 0 },
10512 /* VEX_W_0F51_P_0 */
10513 { "vsqrtps", { XM
, EXx
}, 0 },
10516 /* VEX_W_0F51_P_1 */
10517 { "vsqrtss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10520 /* VEX_W_0F51_P_2 */
10521 { "vsqrtpd", { XM
, EXx
}, 0 },
10524 /* VEX_W_0F51_P_3 */
10525 { "vsqrtsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10528 /* VEX_W_0F52_P_0 */
10529 { "vrsqrtps", { XM
, EXx
}, 0 },
10532 /* VEX_W_0F52_P_1 */
10533 { "vrsqrtss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10536 /* VEX_W_0F53_P_0 */
10537 { "vrcpps", { XM
, EXx
}, 0 },
10540 /* VEX_W_0F53_P_1 */
10541 { "vrcpss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10544 /* VEX_W_0F58_P_0 */
10545 { "vaddps", { XM
, Vex
, EXx
}, 0 },
10548 /* VEX_W_0F58_P_1 */
10549 { "vaddss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10552 /* VEX_W_0F58_P_2 */
10553 { "vaddpd", { XM
, Vex
, EXx
}, 0 },
10556 /* VEX_W_0F58_P_3 */
10557 { "vaddsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10560 /* VEX_W_0F59_P_0 */
10561 { "vmulps", { XM
, Vex
, EXx
}, 0 },
10564 /* VEX_W_0F59_P_1 */
10565 { "vmulss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10568 /* VEX_W_0F59_P_2 */
10569 { "vmulpd", { XM
, Vex
, EXx
}, 0 },
10572 /* VEX_W_0F59_P_3 */
10573 { "vmulsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10576 /* VEX_W_0F5A_P_0 */
10577 { "vcvtps2pd", { XM
, EXxmmq
}, 0 },
10580 /* VEX_W_0F5A_P_1 */
10581 { "vcvtss2sd", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10584 /* VEX_W_0F5A_P_3 */
10585 { "vcvtsd2ss", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10588 /* VEX_W_0F5B_P_0 */
10589 { "vcvtdq2ps", { XM
, EXx
}, 0 },
10592 /* VEX_W_0F5B_P_1 */
10593 { "vcvttps2dq", { XM
, EXx
}, 0 },
10596 /* VEX_W_0F5B_P_2 */
10597 { "vcvtps2dq", { XM
, EXx
}, 0 },
10600 /* VEX_W_0F5C_P_0 */
10601 { "vsubps", { XM
, Vex
, EXx
}, 0 },
10604 /* VEX_W_0F5C_P_1 */
10605 { "vsubss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10608 /* VEX_W_0F5C_P_2 */
10609 { "vsubpd", { XM
, Vex
, EXx
}, 0 },
10612 /* VEX_W_0F5C_P_3 */
10613 { "vsubsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10616 /* VEX_W_0F5D_P_0 */
10617 { "vminps", { XM
, Vex
, EXx
}, 0 },
10620 /* VEX_W_0F5D_P_1 */
10621 { "vminss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10624 /* VEX_W_0F5D_P_2 */
10625 { "vminpd", { XM
, Vex
, EXx
}, 0 },
10628 /* VEX_W_0F5D_P_3 */
10629 { "vminsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10632 /* VEX_W_0F5E_P_0 */
10633 { "vdivps", { XM
, Vex
, EXx
}, 0 },
10636 /* VEX_W_0F5E_P_1 */
10637 { "vdivss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10640 /* VEX_W_0F5E_P_2 */
10641 { "vdivpd", { XM
, Vex
, EXx
}, 0 },
10644 /* VEX_W_0F5E_P_3 */
10645 { "vdivsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10648 /* VEX_W_0F5F_P_0 */
10649 { "vmaxps", { XM
, Vex
, EXx
}, 0 },
10652 /* VEX_W_0F5F_P_1 */
10653 { "vmaxss", { XMScalar
, VexScalar
, EXdScalar
}, 0 },
10656 /* VEX_W_0F5F_P_2 */
10657 { "vmaxpd", { XM
, Vex
, EXx
}, 0 },
10660 /* VEX_W_0F5F_P_3 */
10661 { "vmaxsd", { XMScalar
, VexScalar
, EXqScalar
}, 0 },
10664 /* VEX_W_0F60_P_2 */
10665 { "vpunpcklbw", { XM
, Vex
, EXx
}, 0 },
10668 /* VEX_W_0F61_P_2 */
10669 { "vpunpcklwd", { XM
, Vex
, EXx
}, 0 },
10672 /* VEX_W_0F62_P_2 */
10673 { "vpunpckldq", { XM
, Vex
, EXx
}, 0 },
10676 /* VEX_W_0F63_P_2 */
10677 { "vpacksswb", { XM
, Vex
, EXx
}, 0 },
10680 /* VEX_W_0F64_P_2 */
10681 { "vpcmpgtb", { XM
, Vex
, EXx
}, 0 },
10684 /* VEX_W_0F65_P_2 */
10685 { "vpcmpgtw", { XM
, Vex
, EXx
}, 0 },
10688 /* VEX_W_0F66_P_2 */
10689 { "vpcmpgtd", { XM
, Vex
, EXx
}, 0 },
10692 /* VEX_W_0F67_P_2 */
10693 { "vpackuswb", { XM
, Vex
, EXx
}, 0 },
10696 /* VEX_W_0F68_P_2 */
10697 { "vpunpckhbw", { XM
, Vex
, EXx
}, 0 },
10700 /* VEX_W_0F69_P_2 */
10701 { "vpunpckhwd", { XM
, Vex
, EXx
}, 0 },
10704 /* VEX_W_0F6A_P_2 */
10705 { "vpunpckhdq", { XM
, Vex
, EXx
}, 0 },
10708 /* VEX_W_0F6B_P_2 */
10709 { "vpackssdw", { XM
, Vex
, EXx
}, 0 },
10712 /* VEX_W_0F6C_P_2 */
10713 { "vpunpcklqdq", { XM
, Vex
, EXx
}, 0 },
10716 /* VEX_W_0F6D_P_2 */
10717 { "vpunpckhqdq", { XM
, Vex
, EXx
}, 0 },
10720 /* VEX_W_0F6F_P_1 */
10721 { "vmovdqu", { XM
, EXx
}, 0 },
10724 /* VEX_W_0F6F_P_2 */
10725 { "vmovdqa", { XM
, EXx
}, 0 },
10728 /* VEX_W_0F70_P_1 */
10729 { "vpshufhw", { XM
, EXx
, Ib
}, 0 },
10732 /* VEX_W_0F70_P_2 */
10733 { "vpshufd", { XM
, EXx
, Ib
}, 0 },
10736 /* VEX_W_0F70_P_3 */
10737 { "vpshuflw", { XM
, EXx
, Ib
}, 0 },
10740 /* VEX_W_0F71_R_2_P_2 */
10741 { "vpsrlw", { Vex
, XS
, Ib
}, 0 },
10744 /* VEX_W_0F71_R_4_P_2 */
10745 { "vpsraw", { Vex
, XS
, Ib
}, 0 },
10748 /* VEX_W_0F71_R_6_P_2 */
10749 { "vpsllw", { Vex
, XS
, Ib
}, 0 },
10752 /* VEX_W_0F72_R_2_P_2 */
10753 { "vpsrld", { Vex
, XS
, Ib
}, 0 },
10756 /* VEX_W_0F72_R_4_P_2 */
10757 { "vpsrad", { Vex
, XS
, Ib
}, 0 },
10760 /* VEX_W_0F72_R_6_P_2 */
10761 { "vpslld", { Vex
, XS
, Ib
}, 0 },
10764 /* VEX_W_0F73_R_2_P_2 */
10765 { "vpsrlq", { Vex
, XS
, Ib
}, 0 },
10768 /* VEX_W_0F73_R_3_P_2 */
10769 { "vpsrldq", { Vex
, XS
, Ib
}, 0 },
10772 /* VEX_W_0F73_R_6_P_2 */
10773 { "vpsllq", { Vex
, XS
, Ib
}, 0 },
10776 /* VEX_W_0F73_R_7_P_2 */
10777 { "vpslldq", { Vex
, XS
, Ib
}, 0 },
10780 /* VEX_W_0F74_P_2 */
10781 { "vpcmpeqb", { XM
, Vex
, EXx
}, 0 },
10784 /* VEX_W_0F75_P_2 */
10785 { "vpcmpeqw", { XM
, Vex
, EXx
}, 0 },
10788 /* VEX_W_0F76_P_2 */
10789 { "vpcmpeqd", { XM
, Vex
, EXx
}, 0 },
10792 /* VEX_W_0F77_P_0 */
10793 { "", { VZERO
}, 0 },
10796 /* VEX_W_0F7C_P_2 */
10797 { "vhaddpd", { XM
, Vex
, EXx
}, 0 },
10800 /* VEX_W_0F7C_P_3 */
10801 { "vhaddps", { XM
, Vex
, EXx
}, 0 },
10804 /* VEX_W_0F7D_P_2 */
10805 { "vhsubpd", { XM
, Vex
, EXx
}, 0 },
10808 /* VEX_W_0F7D_P_3 */
10809 { "vhsubps", { XM
, Vex
, EXx
}, 0 },
10812 /* VEX_W_0F7E_P_1 */
10813 { "vmovq", { XMScalar
, EXqScalar
}, 0 },
10816 /* VEX_W_0F7F_P_1 */
10817 { "vmovdqu", { EXxS
, XM
}, 0 },
10820 /* VEX_W_0F7F_P_2 */
10821 { "vmovdqa", { EXxS
, XM
}, 0 },
10824 /* VEX_W_0F90_P_0_LEN_0 */
10825 { "kmovw", { MaskG
, MaskE
}, 0 },
10826 { "kmovq", { MaskG
, MaskE
}, 0 },
10829 /* VEX_W_0F90_P_2_LEN_0 */
10830 { "kmovb", { MaskG
, MaskBDE
}, 0 },
10831 { "kmovd", { MaskG
, MaskBDE
}, 0 },
10834 /* VEX_W_0F91_P_0_LEN_0 */
10835 { "kmovw", { Ew
, MaskG
}, 0 },
10836 { "kmovq", { Eq
, MaskG
}, 0 },
10839 /* VEX_W_0F91_P_2_LEN_0 */
10840 { "kmovb", { Eb
, MaskG
}, 0 },
10841 { "kmovd", { Ed
, MaskG
}, 0 },
10844 /* VEX_W_0F92_P_0_LEN_0 */
10845 { "kmovw", { MaskG
, Rdq
}, 0 },
10848 /* VEX_W_0F92_P_2_LEN_0 */
10849 { "kmovb", { MaskG
, Rdq
}, 0 },
10852 /* VEX_W_0F92_P_3_LEN_0 */
10853 { "kmovd", { MaskG
, Rdq
}, 0 },
10854 { "kmovq", { MaskG
, Rdq
}, 0 },
10857 /* VEX_W_0F93_P_0_LEN_0 */
10858 { "kmovw", { Gdq
, MaskR
}, 0 },
10861 /* VEX_W_0F93_P_2_LEN_0 */
10862 { "kmovb", { Gdq
, MaskR
}, 0 },
10865 /* VEX_W_0F93_P_3_LEN_0 */
10866 { "kmovd", { Gdq
, MaskR
}, 0 },
10867 { "kmovq", { Gdq
, MaskR
}, 0 },
10870 /* VEX_W_0F98_P_0_LEN_0 */
10871 { "kortestw", { MaskG
, MaskR
}, 0 },
10872 { "kortestq", { MaskG
, MaskR
}, 0 },
10875 /* VEX_W_0F98_P_2_LEN_0 */
10876 { "kortestb", { MaskG
, MaskR
}, 0 },
10877 { "kortestd", { MaskG
, MaskR
}, 0 },
10880 /* VEX_W_0F99_P_0_LEN_0 */
10881 { "ktestw", { MaskG
, MaskR
}, 0 },
10882 { "ktestq", { MaskG
, MaskR
}, 0 },
10885 /* VEX_W_0F99_P_2_LEN_0 */
10886 { "ktestb", { MaskG
, MaskR
}, 0 },
10887 { "ktestd", { MaskG
, MaskR
}, 0 },
10890 /* VEX_W_0FAE_R_2_M_0 */
10891 { "vldmxcsr", { Md
}, 0 },
10894 /* VEX_W_0FAE_R_3_M_0 */
10895 { "vstmxcsr", { Md
}, 0 },
10898 /* VEX_W_0FC2_P_0 */
10899 { "vcmpps", { XM
, Vex
, EXx
, VCMP
}, 0 },
10902 /* VEX_W_0FC2_P_1 */
10903 { "vcmpss", { XMScalar
, VexScalar
, EXdScalar
, VCMP
}, 0 },
10906 /* VEX_W_0FC2_P_2 */
10907 { "vcmppd", { XM
, Vex
, EXx
, VCMP
}, 0 },
10910 /* VEX_W_0FC2_P_3 */
10911 { "vcmpsd", { XMScalar
, VexScalar
, EXqScalar
, VCMP
}, 0 },
10914 /* VEX_W_0FC4_P_2 */
10915 { "vpinsrw", { XM
, Vex128
, Edqw
, Ib
}, 0 },
10918 /* VEX_W_0FC5_P_2 */
10919 { "vpextrw", { Gdq
, XS
, Ib
}, 0 },
10922 /* VEX_W_0FD0_P_2 */
10923 { "vaddsubpd", { XM
, Vex
, EXx
}, 0 },
10926 /* VEX_W_0FD0_P_3 */
10927 { "vaddsubps", { XM
, Vex
, EXx
}, 0 },
10930 /* VEX_W_0FD1_P_2 */
10931 { "vpsrlw", { XM
, Vex
, EXxmm
}, 0 },
10934 /* VEX_W_0FD2_P_2 */
10935 { "vpsrld", { XM
, Vex
, EXxmm
}, 0 },
10938 /* VEX_W_0FD3_P_2 */
10939 { "vpsrlq", { XM
, Vex
, EXxmm
}, 0 },
10942 /* VEX_W_0FD4_P_2 */
10943 { "vpaddq", { XM
, Vex
, EXx
}, 0 },
10946 /* VEX_W_0FD5_P_2 */
10947 { "vpmullw", { XM
, Vex
, EXx
}, 0 },
10950 /* VEX_W_0FD6_P_2 */
10951 { "vmovq", { EXqScalarS
, XMScalar
}, 0 },
10954 /* VEX_W_0FD7_P_2_M_1 */
10955 { "vpmovmskb", { Gdq
, XS
}, 0 },
10958 /* VEX_W_0FD8_P_2 */
10959 { "vpsubusb", { XM
, Vex
, EXx
}, 0 },
10962 /* VEX_W_0FD9_P_2 */
10963 { "vpsubusw", { XM
, Vex
, EXx
}, 0 },
10966 /* VEX_W_0FDA_P_2 */
10967 { "vpminub", { XM
, Vex
, EXx
}, 0 },
10970 /* VEX_W_0FDB_P_2 */
10971 { "vpand", { XM
, Vex
, EXx
}, 0 },
10974 /* VEX_W_0FDC_P_2 */
10975 { "vpaddusb", { XM
, Vex
, EXx
}, 0 },
10978 /* VEX_W_0FDD_P_2 */
10979 { "vpaddusw", { XM
, Vex
, EXx
}, 0 },
10982 /* VEX_W_0FDE_P_2 */
10983 { "vpmaxub", { XM
, Vex
, EXx
}, 0 },
10986 /* VEX_W_0FDF_P_2 */
10987 { "vpandn", { XM
, Vex
, EXx
}, 0 },
10990 /* VEX_W_0FE0_P_2 */
10991 { "vpavgb", { XM
, Vex
, EXx
}, 0 },
10994 /* VEX_W_0FE1_P_2 */
10995 { "vpsraw", { XM
, Vex
, EXxmm
}, 0 },
10998 /* VEX_W_0FE2_P_2 */
10999 { "vpsrad", { XM
, Vex
, EXxmm
}, 0 },
11002 /* VEX_W_0FE3_P_2 */
11003 { "vpavgw", { XM
, Vex
, EXx
}, 0 },
11006 /* VEX_W_0FE4_P_2 */
11007 { "vpmulhuw", { XM
, Vex
, EXx
}, 0 },
11010 /* VEX_W_0FE5_P_2 */
11011 { "vpmulhw", { XM
, Vex
, EXx
}, 0 },
11014 /* VEX_W_0FE6_P_1 */
11015 { "vcvtdq2pd", { XM
, EXxmmq
}, 0 },
11018 /* VEX_W_0FE6_P_2 */
11019 { "vcvttpd2dq%XY", { XMM
, EXx
}, 0 },
11022 /* VEX_W_0FE6_P_3 */
11023 { "vcvtpd2dq%XY", { XMM
, EXx
}, 0 },
11026 /* VEX_W_0FE7_P_2_M_0 */
11027 { "vmovntdq", { Mx
, XM
}, 0 },
11030 /* VEX_W_0FE8_P_2 */
11031 { "vpsubsb", { XM
, Vex
, EXx
}, 0 },
11034 /* VEX_W_0FE9_P_2 */
11035 { "vpsubsw", { XM
, Vex
, EXx
}, 0 },
11038 /* VEX_W_0FEA_P_2 */
11039 { "vpminsw", { XM
, Vex
, EXx
}, 0 },
11042 /* VEX_W_0FEB_P_2 */
11043 { "vpor", { XM
, Vex
, EXx
}, 0 },
11046 /* VEX_W_0FEC_P_2 */
11047 { "vpaddsb", { XM
, Vex
, EXx
}, 0 },
11050 /* VEX_W_0FED_P_2 */
11051 { "vpaddsw", { XM
, Vex
, EXx
}, 0 },
11054 /* VEX_W_0FEE_P_2 */
11055 { "vpmaxsw", { XM
, Vex
, EXx
}, 0 },
11058 /* VEX_W_0FEF_P_2 */
11059 { "vpxor", { XM
, Vex
, EXx
}, 0 },
11062 /* VEX_W_0FF0_P_3_M_0 */
11063 { "vlddqu", { XM
, M
}, 0 },
11066 /* VEX_W_0FF1_P_2 */
11067 { "vpsllw", { XM
, Vex
, EXxmm
}, 0 },
11070 /* VEX_W_0FF2_P_2 */
11071 { "vpslld", { XM
, Vex
, EXxmm
}, 0 },
11074 /* VEX_W_0FF3_P_2 */
11075 { "vpsllq", { XM
, Vex
, EXxmm
}, 0 },
11078 /* VEX_W_0FF4_P_2 */
11079 { "vpmuludq", { XM
, Vex
, EXx
}, 0 },
11082 /* VEX_W_0FF5_P_2 */
11083 { "vpmaddwd", { XM
, Vex
, EXx
}, 0 },
11086 /* VEX_W_0FF6_P_2 */
11087 { "vpsadbw", { XM
, Vex
, EXx
}, 0 },
11090 /* VEX_W_0FF7_P_2 */
11091 { "vmaskmovdqu", { XM
, XS
}, 0 },
11094 /* VEX_W_0FF8_P_2 */
11095 { "vpsubb", { XM
, Vex
, EXx
}, 0 },
11098 /* VEX_W_0FF9_P_2 */
11099 { "vpsubw", { XM
, Vex
, EXx
}, 0 },
11102 /* VEX_W_0FFA_P_2 */
11103 { "vpsubd", { XM
, Vex
, EXx
}, 0 },
11106 /* VEX_W_0FFB_P_2 */
11107 { "vpsubq", { XM
, Vex
, EXx
}, 0 },
11110 /* VEX_W_0FFC_P_2 */
11111 { "vpaddb", { XM
, Vex
, EXx
}, 0 },
11114 /* VEX_W_0FFD_P_2 */
11115 { "vpaddw", { XM
, Vex
, EXx
}, 0 },
11118 /* VEX_W_0FFE_P_2 */
11119 { "vpaddd", { XM
, Vex
, EXx
}, 0 },
11122 /* VEX_W_0F3800_P_2 */
11123 { "vpshufb", { XM
, Vex
, EXx
}, 0 },
11126 /* VEX_W_0F3801_P_2 */
11127 { "vphaddw", { XM
, Vex
, EXx
}, 0 },
11130 /* VEX_W_0F3802_P_2 */
11131 { "vphaddd", { XM
, Vex
, EXx
}, 0 },
11134 /* VEX_W_0F3803_P_2 */
11135 { "vphaddsw", { XM
, Vex
, EXx
}, 0 },
11138 /* VEX_W_0F3804_P_2 */
11139 { "vpmaddubsw", { XM
, Vex
, EXx
}, 0 },
11142 /* VEX_W_0F3805_P_2 */
11143 { "vphsubw", { XM
, Vex
, EXx
}, 0 },
11146 /* VEX_W_0F3806_P_2 */
11147 { "vphsubd", { XM
, Vex
, EXx
}, 0 },
11150 /* VEX_W_0F3807_P_2 */
11151 { "vphsubsw", { XM
, Vex
, EXx
}, 0 },
11154 /* VEX_W_0F3808_P_2 */
11155 { "vpsignb", { XM
, Vex
, EXx
}, 0 },
11158 /* VEX_W_0F3809_P_2 */
11159 { "vpsignw", { XM
, Vex
, EXx
}, 0 },
11162 /* VEX_W_0F380A_P_2 */
11163 { "vpsignd", { XM
, Vex
, EXx
}, 0 },
11166 /* VEX_W_0F380B_P_2 */
11167 { "vpmulhrsw", { XM
, Vex
, EXx
}, 0 },
11170 /* VEX_W_0F380C_P_2 */
11171 { "vpermilps", { XM
, Vex
, EXx
}, 0 },
11174 /* VEX_W_0F380D_P_2 */
11175 { "vpermilpd", { XM
, Vex
, EXx
}, 0 },
11178 /* VEX_W_0F380E_P_2 */
11179 { "vtestps", { XM
, EXx
}, 0 },
11182 /* VEX_W_0F380F_P_2 */
11183 { "vtestpd", { XM
, EXx
}, 0 },
11186 /* VEX_W_0F3816_P_2 */
11187 { "vpermps", { XM
, Vex
, EXx
}, 0 },
11190 /* VEX_W_0F3817_P_2 */
11191 { "vptest", { XM
, EXx
}, 0 },
11194 /* VEX_W_0F3818_P_2 */
11195 { "vbroadcastss", { XM
, EXxmm_md
}, 0 },
11198 /* VEX_W_0F3819_P_2 */
11199 { "vbroadcastsd", { XM
, EXxmm_mq
}, 0 },
11202 /* VEX_W_0F381A_P_2_M_0 */
11203 { "vbroadcastf128", { XM
, Mxmm
}, 0 },
11206 /* VEX_W_0F381C_P_2 */
11207 { "vpabsb", { XM
, EXx
}, 0 },
11210 /* VEX_W_0F381D_P_2 */
11211 { "vpabsw", { XM
, EXx
}, 0 },
11214 /* VEX_W_0F381E_P_2 */
11215 { "vpabsd", { XM
, EXx
}, 0 },
11218 /* VEX_W_0F3820_P_2 */
11219 { "vpmovsxbw", { XM
, EXxmmq
}, 0 },
11222 /* VEX_W_0F3821_P_2 */
11223 { "vpmovsxbd", { XM
, EXxmmqd
}, 0 },
11226 /* VEX_W_0F3822_P_2 */
11227 { "vpmovsxbq", { XM
, EXxmmdw
}, 0 },
11230 /* VEX_W_0F3823_P_2 */
11231 { "vpmovsxwd", { XM
, EXxmmq
}, 0 },
11234 /* VEX_W_0F3824_P_2 */
11235 { "vpmovsxwq", { XM
, EXxmmqd
}, 0 },
11238 /* VEX_W_0F3825_P_2 */
11239 { "vpmovsxdq", { XM
, EXxmmq
}, 0 },
11242 /* VEX_W_0F3828_P_2 */
11243 { "vpmuldq", { XM
, Vex
, EXx
}, 0 },
11246 /* VEX_W_0F3829_P_2 */
11247 { "vpcmpeqq", { XM
, Vex
, EXx
}, 0 },
11250 /* VEX_W_0F382A_P_2_M_0 */
11251 { "vmovntdqa", { XM
, Mx
}, 0 },
11254 /* VEX_W_0F382B_P_2 */
11255 { "vpackusdw", { XM
, Vex
, EXx
}, 0 },
11258 /* VEX_W_0F382C_P_2_M_0 */
11259 { "vmaskmovps", { XM
, Vex
, Mx
}, 0 },
11262 /* VEX_W_0F382D_P_2_M_0 */
11263 { "vmaskmovpd", { XM
, Vex
, Mx
}, 0 },
11266 /* VEX_W_0F382E_P_2_M_0 */
11267 { "vmaskmovps", { Mx
, Vex
, XM
}, 0 },
11270 /* VEX_W_0F382F_P_2_M_0 */
11271 { "vmaskmovpd", { Mx
, Vex
, XM
}, 0 },
11274 /* VEX_W_0F3830_P_2 */
11275 { "vpmovzxbw", { XM
, EXxmmq
}, 0 },
11278 /* VEX_W_0F3831_P_2 */
11279 { "vpmovzxbd", { XM
, EXxmmqd
}, 0 },
11282 /* VEX_W_0F3832_P_2 */
11283 { "vpmovzxbq", { XM
, EXxmmdw
}, 0 },
11286 /* VEX_W_0F3833_P_2 */
11287 { "vpmovzxwd", { XM
, EXxmmq
}, 0 },
11290 /* VEX_W_0F3834_P_2 */
11291 { "vpmovzxwq", { XM
, EXxmmqd
}, 0 },
11294 /* VEX_W_0F3835_P_2 */
11295 { "vpmovzxdq", { XM
, EXxmmq
}, 0 },
11298 /* VEX_W_0F3836_P_2 */
11299 { "vpermd", { XM
, Vex
, EXx
}, 0 },
11302 /* VEX_W_0F3837_P_2 */
11303 { "vpcmpgtq", { XM
, Vex
, EXx
}, 0 },
11306 /* VEX_W_0F3838_P_2 */
11307 { "vpminsb", { XM
, Vex
, EXx
}, 0 },
11310 /* VEX_W_0F3839_P_2 */
11311 { "vpminsd", { XM
, Vex
, EXx
}, 0 },
11314 /* VEX_W_0F383A_P_2 */
11315 { "vpminuw", { XM
, Vex
, EXx
}, 0 },
11318 /* VEX_W_0F383B_P_2 */
11319 { "vpminud", { XM
, Vex
, EXx
}, 0 },
11322 /* VEX_W_0F383C_P_2 */
11323 { "vpmaxsb", { XM
, Vex
, EXx
}, 0 },
11326 /* VEX_W_0F383D_P_2 */
11327 { "vpmaxsd", { XM
, Vex
, EXx
}, 0 },
11330 /* VEX_W_0F383E_P_2 */
11331 { "vpmaxuw", { XM
, Vex
, EXx
}, 0 },
11334 /* VEX_W_0F383F_P_2 */
11335 { "vpmaxud", { XM
, Vex
, EXx
}, 0 },
11338 /* VEX_W_0F3840_P_2 */
11339 { "vpmulld", { XM
, Vex
, EXx
}, 0 },
11342 /* VEX_W_0F3841_P_2 */
11343 { "vphminposuw", { XM
, EXx
}, 0 },
11346 /* VEX_W_0F3846_P_2 */
11347 { "vpsravd", { XM
, Vex
, EXx
}, 0 },
11350 /* VEX_W_0F3858_P_2 */
11351 { "vpbroadcastd", { XM
, EXxmm_md
}, 0 },
11354 /* VEX_W_0F3859_P_2 */
11355 { "vpbroadcastq", { XM
, EXxmm_mq
}, 0 },
11358 /* VEX_W_0F385A_P_2_M_0 */
11359 { "vbroadcasti128", { XM
, Mxmm
}, 0 },
11362 /* VEX_W_0F3878_P_2 */
11363 { "vpbroadcastb", { XM
, EXxmm_mb
}, 0 },
11366 /* VEX_W_0F3879_P_2 */
11367 { "vpbroadcastw", { XM
, EXxmm_mw
}, 0 },
11370 /* VEX_W_0F38DB_P_2 */
11371 { "vaesimc", { XM
, EXx
}, 0 },
11374 /* VEX_W_0F38DC_P_2 */
11375 { "vaesenc", { XM
, Vex128
, EXx
}, 0 },
11378 /* VEX_W_0F38DD_P_2 */
11379 { "vaesenclast", { XM
, Vex128
, EXx
}, 0 },
11382 /* VEX_W_0F38DE_P_2 */
11383 { "vaesdec", { XM
, Vex128
, EXx
}, 0 },
11386 /* VEX_W_0F38DF_P_2 */
11387 { "vaesdeclast", { XM
, Vex128
, EXx
}, 0 },
11390 /* VEX_W_0F3A00_P_2 */
11392 { "vpermq", { XM
, EXx
, Ib
}, 0 },
11395 /* VEX_W_0F3A01_P_2 */
11397 { "vpermpd", { XM
, EXx
, Ib
}, 0 },
11400 /* VEX_W_0F3A02_P_2 */
11401 { "vpblendd", { XM
, Vex
, EXx
, Ib
}, 0 },
11404 /* VEX_W_0F3A04_P_2 */
11405 { "vpermilps", { XM
, EXx
, Ib
}, 0 },
11408 /* VEX_W_0F3A05_P_2 */
11409 { "vpermilpd", { XM
, EXx
, Ib
}, 0 },
11412 /* VEX_W_0F3A06_P_2 */
11413 { "vperm2f128", { XM
, Vex256
, EXx
, Ib
}, 0 },
11416 /* VEX_W_0F3A08_P_2 */
11417 { "vroundps", { XM
, EXx
, Ib
}, 0 },
11420 /* VEX_W_0F3A09_P_2 */
11421 { "vroundpd", { XM
, EXx
, Ib
}, 0 },
11424 /* VEX_W_0F3A0A_P_2 */
11425 { "vroundss", { XMScalar
, VexScalar
, EXdScalar
, Ib
}, 0 },
11428 /* VEX_W_0F3A0B_P_2 */
11429 { "vroundsd", { XMScalar
, VexScalar
, EXqScalar
, Ib
}, 0 },
11432 /* VEX_W_0F3A0C_P_2 */
11433 { "vblendps", { XM
, Vex
, EXx
, Ib
}, 0 },
11436 /* VEX_W_0F3A0D_P_2 */
11437 { "vblendpd", { XM
, Vex
, EXx
, Ib
}, 0 },
11440 /* VEX_W_0F3A0E_P_2 */
11441 { "vpblendw", { XM
, Vex
, EXx
, Ib
}, 0 },
11444 /* VEX_W_0F3A0F_P_2 */
11445 { "vpalignr", { XM
, Vex
, EXx
, Ib
}, 0 },
11448 /* VEX_W_0F3A14_P_2 */
11449 { "vpextrb", { Edqb
, XM
, Ib
}, 0 },
11452 /* VEX_W_0F3A15_P_2 */
11453 { "vpextrw", { Edqw
, XM
, Ib
}, 0 },
11456 /* VEX_W_0F3A18_P_2 */
11457 { "vinsertf128", { XM
, Vex256
, EXxmm
, Ib
}, 0 },
11460 /* VEX_W_0F3A19_P_2 */
11461 { "vextractf128", { EXxmm
, XM
, Ib
}, 0 },
11464 /* VEX_W_0F3A20_P_2 */
11465 { "vpinsrb", { XM
, Vex128
, Edqb
, Ib
}, 0 },
11468 /* VEX_W_0F3A21_P_2 */
11469 { "vinsertps", { XM
, Vex128
, EXd
, Ib
}, 0 },
11472 /* VEX_W_0F3A30_P_2_LEN_0 */
11473 { "kshiftrb", { MaskG
, MaskR
, Ib
}, 0 },
11474 { "kshiftrw", { MaskG
, MaskR
, Ib
}, 0 },
11477 /* VEX_W_0F3A31_P_2_LEN_0 */
11478 { "kshiftrd", { MaskG
, MaskR
, Ib
}, 0 },
11479 { "kshiftrq", { MaskG
, MaskR
, Ib
}, 0 },
11482 /* VEX_W_0F3A32_P_2_LEN_0 */
11483 { "kshiftlb", { MaskG
, MaskR
, Ib
}, 0 },
11484 { "kshiftlw", { MaskG
, MaskR
, Ib
}, 0 },
11487 /* VEX_W_0F3A33_P_2_LEN_0 */
11488 { "kshiftld", { MaskG
, MaskR
, Ib
}, 0 },
11489 { "kshiftlq", { MaskG
, MaskR
, Ib
}, 0 },
11492 /* VEX_W_0F3A38_P_2 */
11493 { "vinserti128", { XM
, Vex256
, EXxmm
, Ib
}, 0 },
11496 /* VEX_W_0F3A39_P_2 */
11497 { "vextracti128", { EXxmm
, XM
, Ib
}, 0 },
11500 /* VEX_W_0F3A40_P_2 */
11501 { "vdpps", { XM
, Vex
, EXx
, Ib
}, 0 },
11504 /* VEX_W_0F3A41_P_2 */
11505 { "vdppd", { XM
, Vex128
, EXx
, Ib
}, 0 },
11508 /* VEX_W_0F3A42_P_2 */
11509 { "vmpsadbw", { XM
, Vex
, EXx
, Ib
}, 0 },
11512 /* VEX_W_0F3A44_P_2 */
11513 { "vpclmulqdq", { XM
, Vex128
, EXx
, PCLMUL
}, 0 },
11516 /* VEX_W_0F3A46_P_2 */
11517 { "vperm2i128", { XM
, Vex256
, EXx
, Ib
}, 0 },
11520 /* VEX_W_0F3A48_P_2 */
11521 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11522 { "vpermil2ps", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11525 /* VEX_W_0F3A49_P_2 */
11526 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11527 { "vpermil2pd", { XMVexW
, Vex
, EXVexImmW
, EXVexImmW
, EXVexImmW
}, 0 },
11530 /* VEX_W_0F3A4A_P_2 */
11531 { "vblendvps", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11534 /* VEX_W_0F3A4B_P_2 */
11535 { "vblendvpd", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11538 /* VEX_W_0F3A4C_P_2 */
11539 { "vpblendvb", { XM
, Vex
, EXx
, XMVexI4
}, 0 },
11542 /* VEX_W_0F3A60_P_2 */
11543 { "vpcmpestrm", { XM
, EXx
, Ib
}, 0 },
11546 /* VEX_W_0F3A61_P_2 */
11547 { "vpcmpestri", { XM
, EXx
, Ib
}, 0 },
11550 /* VEX_W_0F3A62_P_2 */
11551 { "vpcmpistrm", { XM
, EXx
, Ib
}, 0 },
11554 /* VEX_W_0F3A63_P_2 */
11555 { "vpcmpistri", { XM
, EXx
, Ib
}, 0 },
11558 /* VEX_W_0F3ADF_P_2 */
11559 { "vaeskeygenassist", { XM
, EXx
, Ib
}, 0 },
11561 #define NEED_VEX_W_TABLE
11562 #include "i386-dis-evex.h"
11563 #undef NEED_VEX_W_TABLE
11566 static const struct dis386 mod_table
[][2] = {
11569 { "leaS", { Gv
, M
}, 0 },
11574 { RM_TABLE (RM_C6_REG_7
) },
11579 { RM_TABLE (RM_C7_REG_7
) },
11583 { "Jcall{T|}", { indirEp
}, 0 },
11587 { "Jjmp{T|}", { indirEp
}, 0 },
11590 /* MOD_0F01_REG_0 */
11591 { X86_64_TABLE (X86_64_0F01_REG_0
) },
11592 { RM_TABLE (RM_0F01_REG_0
) },
11595 /* MOD_0F01_REG_1 */
11596 { X86_64_TABLE (X86_64_0F01_REG_1
) },
11597 { RM_TABLE (RM_0F01_REG_1
) },
11600 /* MOD_0F01_REG_2 */
11601 { X86_64_TABLE (X86_64_0F01_REG_2
) },
11602 { RM_TABLE (RM_0F01_REG_2
) },
11605 /* MOD_0F01_REG_3 */
11606 { X86_64_TABLE (X86_64_0F01_REG_3
) },
11607 { RM_TABLE (RM_0F01_REG_3
) },
11610 /* MOD_0F01_REG_7 */
11611 { "invlpg", { Mb
}, 0 },
11612 { RM_TABLE (RM_0F01_REG_7
) },
11615 /* MOD_0F12_PREFIX_0 */
11616 { "movlps", { XM
, EXq
}, PREFIX_OPCODE
},
11617 { "movhlps", { XM
, EXq
}, PREFIX_OPCODE
},
11621 { "movlpX", { EXq
, XM
}, PREFIX_OPCODE
},
11624 /* MOD_0F16_PREFIX_0 */
11625 { "movhps", { XM
, EXq
}, 0 },
11626 { "movlhps", { XM
, EXq
}, 0 },
11630 { "movhpX", { EXq
, XM
}, PREFIX_OPCODE
},
11633 /* MOD_0F18_REG_0 */
11634 { "prefetchnta", { Mb
}, 0 },
11637 /* MOD_0F18_REG_1 */
11638 { "prefetcht0", { Mb
}, 0 },
11641 /* MOD_0F18_REG_2 */
11642 { "prefetcht1", { Mb
}, 0 },
11645 /* MOD_0F18_REG_3 */
11646 { "prefetcht2", { Mb
}, 0 },
11649 /* MOD_0F18_REG_4 */
11650 { "nop/reserved", { Mb
}, 0 },
11653 /* MOD_0F18_REG_5 */
11654 { "nop/reserved", { Mb
}, 0 },
11657 /* MOD_0F18_REG_6 */
11658 { "nop/reserved", { Mb
}, 0 },
11661 /* MOD_0F18_REG_7 */
11662 { "nop/reserved", { Mb
}, 0 },
11665 /* MOD_0F1A_PREFIX_0 */
11666 { "bndldx", { Gbnd
, Ev_bnd
}, 0 },
11667 { "nopQ", { Ev
}, 0 },
11670 /* MOD_0F1B_PREFIX_0 */
11671 { "bndstx", { Ev_bnd
, Gbnd
}, 0 },
11672 { "nopQ", { Ev
}, 0 },
11675 /* MOD_0F1B_PREFIX_1 */
11676 { "bndmk", { Gbnd
, Ev_bnd
}, 0 },
11677 { "nopQ", { Ev
}, 0 },
11682 { "movL", { Rd
, Td
}, 0 },
11687 { "movL", { Td
, Rd
}, 0 },
11690 /* MOD_0F2B_PREFIX_0 */
11691 {"movntps", { Mx
, XM
}, PREFIX_OPCODE
},
11694 /* MOD_0F2B_PREFIX_1 */
11695 {"movntss", { Md
, XM
}, PREFIX_OPCODE
},
11698 /* MOD_0F2B_PREFIX_2 */
11699 {"movntpd", { Mx
, XM
}, PREFIX_OPCODE
},
11702 /* MOD_0F2B_PREFIX_3 */
11703 {"movntsd", { Mq
, XM
}, PREFIX_OPCODE
},
11708 { "movmskpX", { Gdq
, XS
}, PREFIX_OPCODE
},
11711 /* MOD_0F71_REG_2 */
11713 { "psrlw", { MS
, Ib
}, 0 },
11716 /* MOD_0F71_REG_4 */
11718 { "psraw", { MS
, Ib
}, 0 },
11721 /* MOD_0F71_REG_6 */
11723 { "psllw", { MS
, Ib
}, 0 },
11726 /* MOD_0F72_REG_2 */
11728 { "psrld", { MS
, Ib
}, 0 },
11731 /* MOD_0F72_REG_4 */
11733 { "psrad", { MS
, Ib
}, 0 },
11736 /* MOD_0F72_REG_6 */
11738 { "pslld", { MS
, Ib
}, 0 },
11741 /* MOD_0F73_REG_2 */
11743 { "psrlq", { MS
, Ib
}, 0 },
11746 /* MOD_0F73_REG_3 */
11748 { PREFIX_TABLE (PREFIX_0F73_REG_3
) },
11751 /* MOD_0F73_REG_6 */
11753 { "psllq", { MS
, Ib
}, 0 },
11756 /* MOD_0F73_REG_7 */
11758 { PREFIX_TABLE (PREFIX_0F73_REG_7
) },
11761 /* MOD_0FAE_REG_0 */
11762 { "fxsave", { FXSAVE
}, 0 },
11763 { PREFIX_TABLE (PREFIX_0FAE_REG_0
) },
11766 /* MOD_0FAE_REG_1 */
11767 { "fxrstor", { FXSAVE
}, 0 },
11768 { PREFIX_TABLE (PREFIX_0FAE_REG_1
) },
11771 /* MOD_0FAE_REG_2 */
11772 { "ldmxcsr", { Md
}, 0 },
11773 { PREFIX_TABLE (PREFIX_0FAE_REG_2
) },
11776 /* MOD_0FAE_REG_3 */
11777 { "stmxcsr", { Md
}, 0 },
11778 { PREFIX_TABLE (PREFIX_0FAE_REG_3
) },
11781 /* MOD_0FAE_REG_4 */
11782 { "xsave", { FXSAVE
}, 0 },
11785 /* MOD_0FAE_REG_5 */
11786 { "xrstor", { FXSAVE
}, 0 },
11787 { RM_TABLE (RM_0FAE_REG_5
) },
11790 /* MOD_0FAE_REG_6 */
11791 { PREFIX_TABLE (PREFIX_0FAE_REG_6
) },
11792 { RM_TABLE (RM_0FAE_REG_6
) },
11795 /* MOD_0FAE_REG_7 */
11796 { PREFIX_TABLE (PREFIX_0FAE_REG_7
) },
11797 { RM_TABLE (RM_0FAE_REG_7
) },
11801 { "lssS", { Gv
, Mp
}, 0 },
11805 { "lfsS", { Gv
, Mp
}, 0 },
11809 { "lgsS", { Gv
, Mp
}, 0 },
11812 /* MOD_0FC7_REG_3 */
11813 { "xrstors", { FXSAVE
}, 0 },
11816 /* MOD_0FC7_REG_4 */
11817 { "xsavec", { FXSAVE
}, 0 },
11820 /* MOD_0FC7_REG_5 */
11821 { "xsaves", { FXSAVE
}, 0 },
11824 /* MOD_0FC7_REG_6 */
11825 { PREFIX_TABLE (PREFIX_MOD_0_0FC7_REG_6
) },
11826 { PREFIX_TABLE (PREFIX_MOD_3_0FC7_REG_6
) }
11829 /* MOD_0FC7_REG_7 */
11830 { "vmptrst", { Mq
}, 0 },
11831 { PREFIX_TABLE (PREFIX_MOD_3_0FC7_REG_7
) }
11836 { "pmovmskb", { Gdq
, MS
}, 0 },
11839 /* MOD_0FE7_PREFIX_2 */
11840 { "movntdq", { Mx
, XM
}, 0 },
11843 /* MOD_0FF0_PREFIX_3 */
11844 { "lddqu", { XM
, M
}, 0 },
11847 /* MOD_0F382A_PREFIX_2 */
11848 { "movntdqa", { XM
, Mx
}, 0 },
11852 { "bound{S|}", { Gv
, Ma
}, 0 },
11853 { EVEX_TABLE (EVEX_0F
) },
11857 { "lesS", { Gv
, Mp
}, 0 },
11858 { VEX_C4_TABLE (VEX_0F
) },
11862 { "ldsS", { Gv
, Mp
}, 0 },
11863 { VEX_C5_TABLE (VEX_0F
) },
11866 /* MOD_VEX_0F12_PREFIX_0 */
11867 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_0
) },
11868 { VEX_LEN_TABLE (VEX_LEN_0F12_P_0_M_1
) },
11872 { VEX_LEN_TABLE (VEX_LEN_0F13_M_0
) },
11875 /* MOD_VEX_0F16_PREFIX_0 */
11876 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_0
) },
11877 { VEX_LEN_TABLE (VEX_LEN_0F16_P_0_M_1
) },
11881 { VEX_LEN_TABLE (VEX_LEN_0F17_M_0
) },
11885 { VEX_W_TABLE (VEX_W_0F2B_M_0
) },
11890 { VEX_W_TABLE (VEX_W_0F50_M_0
) },
11893 /* MOD_VEX_0F71_REG_2 */
11895 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_2
) },
11898 /* MOD_VEX_0F71_REG_4 */
11900 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_4
) },
11903 /* MOD_VEX_0F71_REG_6 */
11905 { PREFIX_TABLE (PREFIX_VEX_0F71_REG_6
) },
11908 /* MOD_VEX_0F72_REG_2 */
11910 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_2
) },
11913 /* MOD_VEX_0F72_REG_4 */
11915 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_4
) },
11918 /* MOD_VEX_0F72_REG_6 */
11920 { PREFIX_TABLE (PREFIX_VEX_0F72_REG_6
) },
11923 /* MOD_VEX_0F73_REG_2 */
11925 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_2
) },
11928 /* MOD_VEX_0F73_REG_3 */
11930 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_3
) },
11933 /* MOD_VEX_0F73_REG_6 */
11935 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_6
) },
11938 /* MOD_VEX_0F73_REG_7 */
11940 { PREFIX_TABLE (PREFIX_VEX_0F73_REG_7
) },
11943 /* MOD_VEX_0FAE_REG_2 */
11944 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_2_M_0
) },
11947 /* MOD_VEX_0FAE_REG_3 */
11948 { VEX_LEN_TABLE (VEX_LEN_0FAE_R_3_M_0
) },
11951 /* MOD_VEX_0FD7_PREFIX_2 */
11953 { VEX_W_TABLE (VEX_W_0FD7_P_2_M_1
) },
11956 /* MOD_VEX_0FE7_PREFIX_2 */
11957 { VEX_W_TABLE (VEX_W_0FE7_P_2_M_0
) },
11960 /* MOD_VEX_0FF0_PREFIX_3 */
11961 { VEX_W_TABLE (VEX_W_0FF0_P_3_M_0
) },
11964 /* MOD_VEX_0F381A_PREFIX_2 */
11965 { VEX_LEN_TABLE (VEX_LEN_0F381A_P_2_M_0
) },
11968 /* MOD_VEX_0F382A_PREFIX_2 */
11969 { VEX_W_TABLE (VEX_W_0F382A_P_2_M_0
) },
11972 /* MOD_VEX_0F382C_PREFIX_2 */
11973 { VEX_W_TABLE (VEX_W_0F382C_P_2_M_0
) },
11976 /* MOD_VEX_0F382D_PREFIX_2 */
11977 { VEX_W_TABLE (VEX_W_0F382D_P_2_M_0
) },
11980 /* MOD_VEX_0F382E_PREFIX_2 */
11981 { VEX_W_TABLE (VEX_W_0F382E_P_2_M_0
) },
11984 /* MOD_VEX_0F382F_PREFIX_2 */
11985 { VEX_W_TABLE (VEX_W_0F382F_P_2_M_0
) },
11988 /* MOD_VEX_0F385A_PREFIX_2 */
11989 { VEX_LEN_TABLE (VEX_LEN_0F385A_P_2_M_0
) },
11992 /* MOD_VEX_0F388C_PREFIX_2 */
11993 { "vpmaskmov%LW", { XM
, Vex
, Mx
}, 0 },
11996 /* MOD_VEX_0F388E_PREFIX_2 */
11997 { "vpmaskmov%LW", { Mx
, Vex
, XM
}, 0 },
11999 #define NEED_MOD_TABLE
12000 #include "i386-dis-evex.h"
12001 #undef NEED_MOD_TABLE
12004 static const struct dis386 rm_table
[][8] = {
12007 { "xabort", { Skip_MODRM
, Ib
}, 0 },
12011 { "xbeginT", { Skip_MODRM
, Jv
}, 0 },
12014 /* RM_0F01_REG_0 */
12016 { "vmcall", { Skip_MODRM
}, 0 },
12017 { "vmlaunch", { Skip_MODRM
}, 0 },
12018 { "vmresume", { Skip_MODRM
}, 0 },
12019 { "vmxoff", { Skip_MODRM
}, 0 },
12022 /* RM_0F01_REG_1 */
12023 { "monitor", { { OP_Monitor
, 0 } }, 0 },
12024 { "mwait", { { OP_Mwait
, 0 } }, 0 },
12025 { "clac", { Skip_MODRM
}, 0 },
12026 { "stac", { Skip_MODRM
}, 0 },
12030 { "encls", { Skip_MODRM
}, 0 },
12033 /* RM_0F01_REG_2 */
12034 { "xgetbv", { Skip_MODRM
}, 0 },
12035 { "xsetbv", { Skip_MODRM
}, 0 },
12038 { "vmfunc", { Skip_MODRM
}, 0 },
12039 { "xend", { Skip_MODRM
}, 0 },
12040 { "xtest", { Skip_MODRM
}, 0 },
12041 { "enclu", { Skip_MODRM
}, 0 },
12044 /* RM_0F01_REG_3 */
12045 { "vmrun", { Skip_MODRM
}, 0 },
12046 { "vmmcall", { Skip_MODRM
}, 0 },
12047 { "vmload", { Skip_MODRM
}, 0 },
12048 { "vmsave", { Skip_MODRM
}, 0 },
12049 { "stgi", { Skip_MODRM
}, 0 },
12050 { "clgi", { Skip_MODRM
}, 0 },
12051 { "skinit", { Skip_MODRM
}, 0 },
12052 { "invlpga", { Skip_MODRM
}, 0 },
12055 /* RM_0F01_REG_7 */
12056 { "swapgs", { Skip_MODRM
}, 0 },
12057 { "rdtscp", { Skip_MODRM
}, 0 },
12060 { "clzero", { Skip_MODRM
}, 0 },
12063 /* RM_0FAE_REG_5 */
12064 { "lfence", { Skip_MODRM
}, 0 },
12067 /* RM_0FAE_REG_6 */
12068 { "mfence", { Skip_MODRM
}, 0 },
12071 /* RM_0FAE_REG_7 */
12072 { PREFIX_TABLE (PREFIX_RM_0_0FAE_REG_7
) },
12076 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
12078 /* We use the high bit to indicate different name for the same
12080 #define REP_PREFIX (0xf3 | 0x100)
12081 #define XACQUIRE_PREFIX (0xf2 | 0x200)
12082 #define XRELEASE_PREFIX (0xf3 | 0x400)
12083 #define BND_PREFIX (0xf2 | 0x400)
12088 int newrex
, i
, length
;
12094 last_lock_prefix
= -1;
12095 last_repz_prefix
= -1;
12096 last_repnz_prefix
= -1;
12097 last_data_prefix
= -1;
12098 last_addr_prefix
= -1;
12099 last_rex_prefix
= -1;
12100 last_seg_prefix
= -1;
12102 active_seg_prefix
= 0;
12103 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
12104 all_prefixes
[i
] = 0;
12107 /* The maximum instruction length is 15bytes. */
12108 while (length
< MAX_CODE_LENGTH
- 1)
12110 FETCH_DATA (the_info
, codep
+ 1);
12114 /* REX prefixes family. */
12131 if (address_mode
== mode_64bit
)
12135 last_rex_prefix
= i
;
12138 prefixes
|= PREFIX_REPZ
;
12139 last_repz_prefix
= i
;
12142 prefixes
|= PREFIX_REPNZ
;
12143 last_repnz_prefix
= i
;
12146 prefixes
|= PREFIX_LOCK
;
12147 last_lock_prefix
= i
;
12150 prefixes
|= PREFIX_CS
;
12151 last_seg_prefix
= i
;
12152 active_seg_prefix
= PREFIX_CS
;
12155 prefixes
|= PREFIX_SS
;
12156 last_seg_prefix
= i
;
12157 active_seg_prefix
= PREFIX_SS
;
12160 prefixes
|= PREFIX_DS
;
12161 last_seg_prefix
= i
;
12162 active_seg_prefix
= PREFIX_DS
;
12165 prefixes
|= PREFIX_ES
;
12166 last_seg_prefix
= i
;
12167 active_seg_prefix
= PREFIX_ES
;
12170 prefixes
|= PREFIX_FS
;
12171 last_seg_prefix
= i
;
12172 active_seg_prefix
= PREFIX_FS
;
12175 prefixes
|= PREFIX_GS
;
12176 last_seg_prefix
= i
;
12177 active_seg_prefix
= PREFIX_GS
;
12180 prefixes
|= PREFIX_DATA
;
12181 last_data_prefix
= i
;
12184 prefixes
|= PREFIX_ADDR
;
12185 last_addr_prefix
= i
;
12188 /* fwait is really an instruction. If there are prefixes
12189 before the fwait, they belong to the fwait, *not* to the
12190 following instruction. */
12192 if (prefixes
|| rex
)
12194 prefixes
|= PREFIX_FWAIT
;
12196 /* This ensures that the previous REX prefixes are noticed
12197 as unused prefixes, as in the return case below. */
12201 prefixes
= PREFIX_FWAIT
;
12206 /* Rex is ignored when followed by another prefix. */
12212 if (*codep
!= FWAIT_OPCODE
)
12213 all_prefixes
[i
++] = *codep
;
12221 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
12224 static const char *
12225 prefix_name (int pref
, int sizeflag
)
12227 static const char *rexes
[16] =
12230 "rex.B", /* 0x41 */
12231 "rex.X", /* 0x42 */
12232 "rex.XB", /* 0x43 */
12233 "rex.R", /* 0x44 */
12234 "rex.RB", /* 0x45 */
12235 "rex.RX", /* 0x46 */
12236 "rex.RXB", /* 0x47 */
12237 "rex.W", /* 0x48 */
12238 "rex.WB", /* 0x49 */
12239 "rex.WX", /* 0x4a */
12240 "rex.WXB", /* 0x4b */
12241 "rex.WR", /* 0x4c */
12242 "rex.WRB", /* 0x4d */
12243 "rex.WRX", /* 0x4e */
12244 "rex.WRXB", /* 0x4f */
12249 /* REX prefixes family. */
12266 return rexes
[pref
- 0x40];
12286 return (sizeflag
& DFLAG
) ? "data16" : "data32";
12288 if (address_mode
== mode_64bit
)
12289 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
12291 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
12296 case XACQUIRE_PREFIX
:
12298 case XRELEASE_PREFIX
:
12307 static char op_out
[MAX_OPERANDS
][100];
12308 static int op_ad
, op_index
[MAX_OPERANDS
];
12309 static int two_source_ops
;
12310 static bfd_vma op_address
[MAX_OPERANDS
];
12311 static bfd_vma op_riprel
[MAX_OPERANDS
];
12312 static bfd_vma start_pc
;
12315 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
12316 * (see topic "Redundant prefixes" in the "Differences from 8086"
12317 * section of the "Virtual 8086 Mode" chapter.)
12318 * 'pc' should be the address of this instruction, it will
12319 * be used to print the target address if this is a relative jump or call
12320 * The function returns the length of this instruction in bytes.
12323 static char intel_syntax
;
12324 static char intel_mnemonic
= !SYSV386_COMPAT
;
12325 static char open_char
;
12326 static char close_char
;
12327 static char separator_char
;
12328 static char scale_char
;
12330 /* Here for backwards compatibility. When gdb stops using
12331 print_insn_i386_att and print_insn_i386_intel these functions can
12332 disappear, and print_insn_i386 be merged into print_insn. */
12334 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
12338 return print_insn (pc
, info
);
12342 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
12346 return print_insn (pc
, info
);
12350 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
12354 return print_insn (pc
, info
);
12358 print_i386_disassembler_options (FILE *stream
)
12360 fprintf (stream
, _("\n\
12361 The following i386/x86-64 specific disassembler options are supported for use\n\
12362 with the -M switch (multiple options should be separated by commas):\n"));
12364 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
12365 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
12366 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
12367 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
12368 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
12369 fprintf (stream
, _(" att-mnemonic\n"
12370 " Display instruction in AT&T mnemonic\n"));
12371 fprintf (stream
, _(" intel-mnemonic\n"
12372 " Display instruction in Intel mnemonic\n"));
12373 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
12374 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
12375 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
12376 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
12377 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
12378 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
12382 static const struct dis386 bad_opcode
= { "(bad)", { XX
}, 0 };
12384 /* Get a pointer to struct dis386 with a valid name. */
12386 static const struct dis386
*
12387 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
12389 int vindex
, vex_table_index
;
12391 if (dp
->name
!= NULL
)
12394 switch (dp
->op
[0].bytemode
)
12396 case USE_REG_TABLE
:
12397 dp
= ®_table
[dp
->op
[1].bytemode
][modrm
.reg
];
12400 case USE_MOD_TABLE
:
12401 vindex
= modrm
.mod
== 0x3 ? 1 : 0;
12402 dp
= &mod_table
[dp
->op
[1].bytemode
][vindex
];
12406 dp
= &rm_table
[dp
->op
[1].bytemode
][modrm
.rm
];
12409 case USE_PREFIX_TABLE
:
12412 /* The prefix in VEX is implicit. */
12413 switch (vex
.prefix
)
12418 case REPE_PREFIX_OPCODE
:
12421 case DATA_PREFIX_OPCODE
:
12424 case REPNE_PREFIX_OPCODE
:
12434 int last_prefix
= -1;
12437 /* We check PREFIX_REPNZ and PREFIX_REPZ before PREFIX_DATA.
12438 When there are multiple PREFIX_REPNZ and PREFIX_REPZ, the
12440 if ((prefixes
& (PREFIX_REPZ
| PREFIX_REPNZ
)) != 0)
12442 if (last_repz_prefix
> last_repnz_prefix
)
12445 prefix
= PREFIX_REPZ
;
12446 last_prefix
= last_repz_prefix
;
12451 prefix
= PREFIX_REPNZ
;
12452 last_prefix
= last_repnz_prefix
;
12455 /* Check if prefix should be ignored. */
12456 if ((((prefix_table
[dp
->op
[1].bytemode
][vindex
].prefix_requirement
12457 & PREFIX_IGNORED
) >> PREFIX_IGNORED_SHIFT
)
12462 if (vindex
== 0 && (prefixes
& PREFIX_DATA
) != 0)
12465 prefix
= PREFIX_DATA
;
12466 last_prefix
= last_data_prefix
;
12471 used_prefixes
|= prefix
;
12472 all_prefixes
[last_prefix
] = 0;
12475 dp
= &prefix_table
[dp
->op
[1].bytemode
][vindex
];
12478 case USE_X86_64_TABLE
:
12479 vindex
= address_mode
== mode_64bit
? 1 : 0;
12480 dp
= &x86_64_table
[dp
->op
[1].bytemode
][vindex
];
12483 case USE_3BYTE_TABLE
:
12484 FETCH_DATA (info
, codep
+ 2);
12486 dp
= &three_byte_table
[dp
->op
[1].bytemode
][vindex
];
12488 modrm
.mod
= (*codep
>> 6) & 3;
12489 modrm
.reg
= (*codep
>> 3) & 7;
12490 modrm
.rm
= *codep
& 7;
12493 case USE_VEX_LEN_TABLE
:
12497 switch (vex
.length
)
12510 dp
= &vex_len_table
[dp
->op
[1].bytemode
][vindex
];
12513 case USE_XOP_8F_TABLE
:
12514 FETCH_DATA (info
, codep
+ 3);
12515 /* All bits in the REX prefix are ignored. */
12517 rex
= ~(*codep
>> 5) & 0x7;
12519 /* VEX_TABLE_INDEX is the mmmmm part of the XOP byte 1 "RCB.mmmmm". */
12520 switch ((*codep
& 0x1f))
12526 vex_table_index
= XOP_08
;
12529 vex_table_index
= XOP_09
;
12532 vex_table_index
= XOP_0A
;
12536 vex
.w
= *codep
& 0x80;
12537 if (vex
.w
&& address_mode
== mode_64bit
)
12540 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12541 if (address_mode
!= mode_64bit
12542 && vex
.register_specifier
> 0x7)
12548 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12549 switch ((*codep
& 0x3))
12555 vex
.prefix
= DATA_PREFIX_OPCODE
;
12558 vex
.prefix
= REPE_PREFIX_OPCODE
;
12561 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12568 dp
= &xop_table
[vex_table_index
][vindex
];
12571 FETCH_DATA (info
, codep
+ 1);
12572 modrm
.mod
= (*codep
>> 6) & 3;
12573 modrm
.reg
= (*codep
>> 3) & 7;
12574 modrm
.rm
= *codep
& 7;
12577 case USE_VEX_C4_TABLE
:
12579 FETCH_DATA (info
, codep
+ 3);
12580 /* All bits in the REX prefix are ignored. */
12582 rex
= ~(*codep
>> 5) & 0x7;
12583 switch ((*codep
& 0x1f))
12589 vex_table_index
= VEX_0F
;
12592 vex_table_index
= VEX_0F38
;
12595 vex_table_index
= VEX_0F3A
;
12599 vex
.w
= *codep
& 0x80;
12600 if (vex
.w
&& address_mode
== mode_64bit
)
12603 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12604 if (address_mode
!= mode_64bit
12605 && vex
.register_specifier
> 0x7)
12611 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12612 switch ((*codep
& 0x3))
12618 vex
.prefix
= DATA_PREFIX_OPCODE
;
12621 vex
.prefix
= REPE_PREFIX_OPCODE
;
12624 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12631 dp
= &vex_table
[vex_table_index
][vindex
];
12633 /* There is no MODRM byte for VEX [82|77]. */
12634 if (vindex
!= 0x77 && vindex
!= 0x82)
12636 FETCH_DATA (info
, codep
+ 1);
12637 modrm
.mod
= (*codep
>> 6) & 3;
12638 modrm
.reg
= (*codep
>> 3) & 7;
12639 modrm
.rm
= *codep
& 7;
12643 case USE_VEX_C5_TABLE
:
12645 FETCH_DATA (info
, codep
+ 2);
12646 /* All bits in the REX prefix are ignored. */
12648 rex
= (*codep
& 0x80) ? 0 : REX_R
;
12650 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12651 if (address_mode
!= mode_64bit
12652 && vex
.register_specifier
> 0x7)
12660 vex
.length
= (*codep
& 0x4) ? 256 : 128;
12661 switch ((*codep
& 0x3))
12667 vex
.prefix
= DATA_PREFIX_OPCODE
;
12670 vex
.prefix
= REPE_PREFIX_OPCODE
;
12673 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12680 dp
= &vex_table
[dp
->op
[1].bytemode
][vindex
];
12682 /* There is no MODRM byte for VEX [82|77]. */
12683 if (vindex
!= 0x77 && vindex
!= 0x82)
12685 FETCH_DATA (info
, codep
+ 1);
12686 modrm
.mod
= (*codep
>> 6) & 3;
12687 modrm
.reg
= (*codep
>> 3) & 7;
12688 modrm
.rm
= *codep
& 7;
12692 case USE_VEX_W_TABLE
:
12696 dp
= &vex_w_table
[dp
->op
[1].bytemode
][vex
.w
? 1 : 0];
12699 case USE_EVEX_TABLE
:
12700 two_source_ops
= 0;
12703 FETCH_DATA (info
, codep
+ 4);
12704 /* All bits in the REX prefix are ignored. */
12706 /* The first byte after 0x62. */
12707 rex
= ~(*codep
>> 5) & 0x7;
12708 vex
.r
= *codep
& 0x10;
12709 switch ((*codep
& 0xf))
12712 return &bad_opcode
;
12714 vex_table_index
= EVEX_0F
;
12717 vex_table_index
= EVEX_0F38
;
12720 vex_table_index
= EVEX_0F3A
;
12724 /* The second byte after 0x62. */
12726 vex
.w
= *codep
& 0x80;
12727 if (vex
.w
&& address_mode
== mode_64bit
)
12730 vex
.register_specifier
= (~(*codep
>> 3)) & 0xf;
12731 if (address_mode
!= mode_64bit
)
12733 /* In 16/32-bit mode silently ignore following bits. */
12737 vex
.register_specifier
&= 0x7;
12741 if (!(*codep
& 0x4))
12742 return &bad_opcode
;
12744 switch ((*codep
& 0x3))
12750 vex
.prefix
= DATA_PREFIX_OPCODE
;
12753 vex
.prefix
= REPE_PREFIX_OPCODE
;
12756 vex
.prefix
= REPNE_PREFIX_OPCODE
;
12760 /* The third byte after 0x62. */
12763 /* Remember the static rounding bits. */
12764 vex
.ll
= (*codep
>> 5) & 3;
12765 vex
.b
= (*codep
& 0x10) != 0;
12767 vex
.v
= *codep
& 0x8;
12768 vex
.mask_register_specifier
= *codep
& 0x7;
12769 vex
.zeroing
= *codep
& 0x80;
12775 dp
= &evex_table
[vex_table_index
][vindex
];
12777 FETCH_DATA (info
, codep
+ 1);
12778 modrm
.mod
= (*codep
>> 6) & 3;
12779 modrm
.reg
= (*codep
>> 3) & 7;
12780 modrm
.rm
= *codep
& 7;
12782 /* Set vector length. */
12783 if (modrm
.mod
== 3 && vex
.b
)
12799 return &bad_opcode
;
12812 if (dp
->name
!= NULL
)
12815 return get_valid_dis386 (dp
, info
);
12819 get_sib (disassemble_info
*info
, int sizeflag
)
12821 /* If modrm.mod == 3, operand must be register. */
12823 && ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
12827 FETCH_DATA (info
, codep
+ 2);
12828 sib
.index
= (codep
[1] >> 3) & 7;
12829 sib
.scale
= (codep
[1] >> 6) & 3;
12830 sib
.base
= codep
[1] & 7;
12835 print_insn (bfd_vma pc
, disassemble_info
*info
)
12837 const struct dis386
*dp
;
12839 char *op_txt
[MAX_OPERANDS
];
12841 int sizeflag
, orig_sizeflag
;
12843 struct dis_private priv
;
12846 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12847 if ((info
->mach
& bfd_mach_i386_i386
) != 0)
12848 address_mode
= mode_32bit
;
12849 else if (info
->mach
== bfd_mach_i386_i8086
)
12851 address_mode
= mode_16bit
;
12852 priv
.orig_sizeflag
= 0;
12855 address_mode
= mode_64bit
;
12857 if (intel_syntax
== (char) -1)
12858 intel_syntax
= (info
->mach
& bfd_mach_i386_intel_syntax
) != 0;
12860 for (p
= info
->disassembler_options
; p
!= NULL
; )
12862 if (CONST_STRNEQ (p
, "x86-64"))
12864 address_mode
= mode_64bit
;
12865 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12867 else if (CONST_STRNEQ (p
, "i386"))
12869 address_mode
= mode_32bit
;
12870 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
12872 else if (CONST_STRNEQ (p
, "i8086"))
12874 address_mode
= mode_16bit
;
12875 priv
.orig_sizeflag
= 0;
12877 else if (CONST_STRNEQ (p
, "intel"))
12880 if (CONST_STRNEQ (p
+ 5, "-mnemonic"))
12881 intel_mnemonic
= 1;
12883 else if (CONST_STRNEQ (p
, "att"))
12886 if (CONST_STRNEQ (p
+ 3, "-mnemonic"))
12887 intel_mnemonic
= 0;
12889 else if (CONST_STRNEQ (p
, "addr"))
12891 if (address_mode
== mode_64bit
)
12893 if (p
[4] == '3' && p
[5] == '2')
12894 priv
.orig_sizeflag
&= ~AFLAG
;
12895 else if (p
[4] == '6' && p
[5] == '4')
12896 priv
.orig_sizeflag
|= AFLAG
;
12900 if (p
[4] == '1' && p
[5] == '6')
12901 priv
.orig_sizeflag
&= ~AFLAG
;
12902 else if (p
[4] == '3' && p
[5] == '2')
12903 priv
.orig_sizeflag
|= AFLAG
;
12906 else if (CONST_STRNEQ (p
, "data"))
12908 if (p
[4] == '1' && p
[5] == '6')
12909 priv
.orig_sizeflag
&= ~DFLAG
;
12910 else if (p
[4] == '3' && p
[5] == '2')
12911 priv
.orig_sizeflag
|= DFLAG
;
12913 else if (CONST_STRNEQ (p
, "suffix"))
12914 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
12916 p
= strchr (p
, ',');
12923 names64
= intel_names64
;
12924 names32
= intel_names32
;
12925 names16
= intel_names16
;
12926 names8
= intel_names8
;
12927 names8rex
= intel_names8rex
;
12928 names_seg
= intel_names_seg
;
12929 names_mm
= intel_names_mm
;
12930 names_bnd
= intel_names_bnd
;
12931 names_xmm
= intel_names_xmm
;
12932 names_ymm
= intel_names_ymm
;
12933 names_zmm
= intel_names_zmm
;
12934 index64
= intel_index64
;
12935 index32
= intel_index32
;
12936 names_mask
= intel_names_mask
;
12937 index16
= intel_index16
;
12940 separator_char
= '+';
12945 names64
= att_names64
;
12946 names32
= att_names32
;
12947 names16
= att_names16
;
12948 names8
= att_names8
;
12949 names8rex
= att_names8rex
;
12950 names_seg
= att_names_seg
;
12951 names_mm
= att_names_mm
;
12952 names_bnd
= att_names_bnd
;
12953 names_xmm
= att_names_xmm
;
12954 names_ymm
= att_names_ymm
;
12955 names_zmm
= att_names_zmm
;
12956 index64
= att_index64
;
12957 index32
= att_index32
;
12958 names_mask
= att_names_mask
;
12959 index16
= att_index16
;
12962 separator_char
= ',';
12966 /* The output looks better if we put 7 bytes on a line, since that
12967 puts most long word instructions on a single line. Use 8 bytes
12969 if ((info
->mach
& bfd_mach_l1om
) != 0)
12970 info
->bytes_per_line
= 8;
12972 info
->bytes_per_line
= 7;
12974 info
->private_data
= &priv
;
12975 priv
.max_fetched
= priv
.the_buffer
;
12976 priv
.insn_start
= pc
;
12979 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
12987 start_codep
= priv
.the_buffer
;
12988 codep
= priv
.the_buffer
;
12990 if (OPCODES_SIGSETJMP (priv
.bailout
) != 0)
12994 /* Getting here means we tried for data but didn't get it. That
12995 means we have an incomplete instruction of some sort. Just
12996 print the first byte as a prefix or a .byte pseudo-op. */
12997 if (codep
> priv
.the_buffer
)
12999 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
13001 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
13004 /* Just print the first byte as a .byte instruction. */
13005 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
13006 (unsigned int) priv
.the_buffer
[0]);
13016 sizeflag
= priv
.orig_sizeflag
;
13018 if (!ckprefix () || rex_used
)
13020 /* Too many prefixes or unused REX prefixes. */
13022 i
< (int) ARRAY_SIZE (all_prefixes
) && all_prefixes
[i
];
13024 (*info
->fprintf_func
) (info
->stream
, "%s%s",
13026 prefix_name (all_prefixes
[i
], sizeflag
));
13030 insn_codep
= codep
;
13032 FETCH_DATA (info
, codep
+ 1);
13033 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
13035 if (((prefixes
& PREFIX_FWAIT
)
13036 && ((*codep
< 0xd8) || (*codep
> 0xdf))))
13038 /* Handle prefixes before fwait. */
13039 for (i
= 0; i
< fwait_prefix
&& all_prefixes
[i
];
13041 (*info
->fprintf_func
) (info
->stream
, "%s ",
13042 prefix_name (all_prefixes
[i
], sizeflag
));
13043 (*info
->fprintf_func
) (info
->stream
, "fwait");
13047 if (*codep
== 0x0f)
13049 unsigned char threebyte
;
13050 FETCH_DATA (info
, codep
+ 2);
13051 threebyte
= *++codep
;
13052 dp
= &dis386_twobyte
[threebyte
];
13053 need_modrm
= twobyte_has_modrm
[*codep
];
13058 dp
= &dis386
[*codep
];
13059 need_modrm
= onebyte_has_modrm
[*codep
];
13063 /* Save sizeflag for printing the extra prefixes later before updating
13064 it for mnemonic and operand processing. The prefix names depend
13065 only on the address mode. */
13066 orig_sizeflag
= sizeflag
;
13067 if (prefixes
& PREFIX_ADDR
)
13069 if ((prefixes
& PREFIX_DATA
))
13075 FETCH_DATA (info
, codep
+ 1);
13076 modrm
.mod
= (*codep
>> 6) & 3;
13077 modrm
.reg
= (*codep
>> 3) & 7;
13078 modrm
.rm
= *codep
& 7;
13086 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
13088 get_sib (info
, sizeflag
);
13089 dofloat (sizeflag
);
13093 dp
= get_valid_dis386 (dp
, info
);
13094 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
13096 get_sib (info
, sizeflag
);
13097 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13100 op_ad
= MAX_OPERANDS
- 1 - i
;
13102 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
13103 /* For EVEX instruction after the last operand masking
13104 should be printed. */
13105 if (i
== 0 && vex
.evex
)
13107 /* Don't print {%k0}. */
13108 if (vex
.mask_register_specifier
)
13111 oappend (names_mask
[vex
.mask_register_specifier
]);
13121 /* Check if the REX prefix is used. */
13122 if (rex_ignored
== 0 && (rex
^ rex_used
) == 0 && last_rex_prefix
>= 0)
13123 all_prefixes
[last_rex_prefix
] = 0;
13125 /* Check if the SEG prefix is used. */
13126 if ((prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
| PREFIX_ES
13127 | PREFIX_FS
| PREFIX_GS
)) != 0
13128 && (used_prefixes
& active_seg_prefix
) != 0)
13129 all_prefixes
[last_seg_prefix
] = 0;
13131 /* Check if the ADDR prefix is used. */
13132 if ((prefixes
& PREFIX_ADDR
) != 0
13133 && (used_prefixes
& PREFIX_ADDR
) != 0)
13134 all_prefixes
[last_addr_prefix
] = 0;
13136 /* Check if the DATA prefix is used. */
13137 if ((prefixes
& PREFIX_DATA
) != 0
13138 && (used_prefixes
& PREFIX_DATA
) != 0)
13139 all_prefixes
[last_data_prefix
] = 0;
13141 /* Print the extra prefixes. */
13143 for (i
= 0; i
< (int) ARRAY_SIZE (all_prefixes
); i
++)
13144 if (all_prefixes
[i
])
13147 name
= prefix_name (all_prefixes
[i
], orig_sizeflag
);
13150 prefix_length
+= strlen (name
) + 1;
13151 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
13154 /* If the mandatory PREFIX_REPZ/PREFIX_REPNZ/PREFIX_DATA prefix is
13155 unused, opcode is invalid. Since the PREFIX_DATA prefix may be
13156 used by putop and MMX/SSE operand and may be overriden by the
13157 PREFIX_REPZ/PREFIX_REPNZ fix, we check the PREFIX_DATA prefix
13159 if (dp
->prefix_requirement
== PREFIX_OPCODE
13160 && dp
!= &bad_opcode
13162 & (PREFIX_REPZ
| PREFIX_REPNZ
)) != 0
13164 & (PREFIX_REPZ
| PREFIX_REPNZ
)) == 0)
13166 & (PREFIX_REPZ
| PREFIX_REPNZ
| PREFIX_DATA
))
13168 && (used_prefixes
& PREFIX_DATA
) == 0))))
13170 (*info
->fprintf_func
) (info
->stream
, "(bad)");
13171 return end_codep
- priv
.the_buffer
;
13174 /* Check maximum code length. */
13175 if ((codep
- start_codep
) > MAX_CODE_LENGTH
)
13177 (*info
->fprintf_func
) (info
->stream
, "(bad)");
13178 return MAX_CODE_LENGTH
;
13181 obufp
= mnemonicendp
;
13182 for (i
= strlen (obuf
) + prefix_length
; i
< 6; i
++)
13185 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
13187 /* The enter and bound instructions are printed with operands in the same
13188 order as the intel book; everything else is printed in reverse order. */
13189 if (intel_syntax
|| two_source_ops
)
13193 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13194 op_txt
[i
] = op_out
[i
];
13196 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
13198 op_ad
= op_index
[i
];
13199 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
13200 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
13201 riprel
= op_riprel
[i
];
13202 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
13203 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
13208 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13209 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
13213 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
13217 (*info
->fprintf_func
) (info
->stream
, ",");
13218 if (op_index
[i
] != -1 && !op_riprel
[i
])
13219 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
13221 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
13225 for (i
= 0; i
< MAX_OPERANDS
; i
++)
13226 if (op_index
[i
] != -1 && op_riprel
[i
])
13228 (*info
->fprintf_func
) (info
->stream
, " # ");
13229 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
13230 + op_address
[op_index
[i
]]), info
);
13233 return codep
- priv
.the_buffer
;
13236 static const char *float_mem
[] = {
13311 static const unsigned char float_mem_mode
[] = {
13386 #define ST { OP_ST, 0 }
13387 #define STi { OP_STi, 0 }
13389 #define FGRPd9_2 NULL, { { NULL, 0 } }, 0
13390 #define FGRPd9_4 NULL, { { NULL, 1 } }, 0
13391 #define FGRPd9_5 NULL, { { NULL, 2 } }, 0
13392 #define FGRPd9_6 NULL, { { NULL, 3 } }, 0
13393 #define FGRPd9_7 NULL, { { NULL, 4 } }, 0
13394 #define FGRPda_5 NULL, { { NULL, 5 } }, 0
13395 #define FGRPdb_4 NULL, { { NULL, 6 } }, 0
13396 #define FGRPde_3 NULL, { { NULL, 7 } }, 0
13397 #define FGRPdf_4 NULL, { { NULL, 8 } }, 0
13399 static const struct dis386 float_reg
[][8] = {
13402 { "fadd", { ST
, STi
}, 0 },
13403 { "fmul", { ST
, STi
}, 0 },
13404 { "fcom", { STi
}, 0 },
13405 { "fcomp", { STi
}, 0 },
13406 { "fsub", { ST
, STi
}, 0 },
13407 { "fsubr", { ST
, STi
}, 0 },
13408 { "fdiv", { ST
, STi
}, 0 },
13409 { "fdivr", { ST
, STi
}, 0 },
13413 { "fld", { STi
}, 0 },
13414 { "fxch", { STi
}, 0 },
13424 { "fcmovb", { ST
, STi
}, 0 },
13425 { "fcmove", { ST
, STi
}, 0 },
13426 { "fcmovbe",{ ST
, STi
}, 0 },
13427 { "fcmovu", { ST
, STi
}, 0 },
13435 { "fcmovnb",{ ST
, STi
}, 0 },
13436 { "fcmovne",{ ST
, STi
}, 0 },
13437 { "fcmovnbe",{ ST
, STi
}, 0 },
13438 { "fcmovnu",{ ST
, STi
}, 0 },
13440 { "fucomi", { ST
, STi
}, 0 },
13441 { "fcomi", { ST
, STi
}, 0 },
13446 { "fadd", { STi
, ST
}, 0 },
13447 { "fmul", { STi
, ST
}, 0 },
13450 { "fsub!M", { STi
, ST
}, 0 },
13451 { "fsubM", { STi
, ST
}, 0 },
13452 { "fdiv!M", { STi
, ST
}, 0 },
13453 { "fdivM", { STi
, ST
}, 0 },
13457 { "ffree", { STi
}, 0 },
13459 { "fst", { STi
}, 0 },
13460 { "fstp", { STi
}, 0 },
13461 { "fucom", { STi
}, 0 },
13462 { "fucomp", { STi
}, 0 },
13468 { "faddp", { STi
, ST
}, 0 },
13469 { "fmulp", { STi
, ST
}, 0 },
13472 { "fsub!Mp", { STi
, ST
}, 0 },
13473 { "fsubMp", { STi
, ST
}, 0 },
13474 { "fdiv!Mp", { STi
, ST
}, 0 },
13475 { "fdivMp", { STi
, ST
}, 0 },
13479 { "ffreep", { STi
}, 0 },
13484 { "fucomip", { ST
, STi
}, 0 },
13485 { "fcomip", { ST
, STi
}, 0 },
13490 static char *fgrps
[][8] = {
13493 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13498 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
13503 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
13508 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
13513 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
13518 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13523 "fNeni(8087 only)","fNdisi(8087 only)","fNclex","fNinit",
13524 "fNsetpm(287 only)","frstpm(287 only)","(bad)","(bad)",
13529 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13534 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
13539 swap_operand (void)
13541 mnemonicendp
[0] = '.';
13542 mnemonicendp
[1] = 's';
13547 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
13548 int sizeflag ATTRIBUTE_UNUSED
)
13550 /* Skip mod/rm byte. */
13556 dofloat (int sizeflag
)
13558 const struct dis386
*dp
;
13559 unsigned char floatop
;
13561 floatop
= codep
[-1];
13563 if (modrm
.mod
!= 3)
13565 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
13567 putop (float_mem
[fp_indx
], sizeflag
);
13570 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
13573 /* Skip mod/rm byte. */
13577 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
13578 if (dp
->name
== NULL
)
13580 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
13582 /* Instruction fnstsw is only one with strange arg. */
13583 if (floatop
== 0xdf && codep
[-1] == 0xe0)
13584 strcpy (op_out
[0], names16
[0]);
13588 putop (dp
->name
, sizeflag
);
13593 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
13598 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
13602 /* Like oappend (below), but S is a string starting with '%'.
13603 In Intel syntax, the '%' is elided. */
13605 oappend_maybe_intel (const char *s
)
13607 oappend (s
+ intel_syntax
);
13611 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13613 oappend_maybe_intel ("%st");
13617 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
13619 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
13620 oappend_maybe_intel (scratchbuf
);
13623 /* Capital letters in template are macros. */
13625 putop (const char *in_template
, int sizeflag
)
13630 unsigned int l
= 0, len
= 1;
13633 #define SAVE_LAST(c) \
13634 if (l < len && l < sizeof (last)) \
13639 for (p
= in_template
; *p
; p
++)
13656 while (*++p
!= '|')
13657 if (*p
== '}' || *p
== '\0')
13660 /* Fall through. */
13665 while (*++p
!= '}')
13676 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13680 if (l
== 0 && len
== 1)
13685 if (sizeflag
& SUFFIX_ALWAYS
)
13698 if (address_mode
== mode_64bit
13699 && !(prefixes
& PREFIX_ADDR
))
13710 if (intel_syntax
&& !alt
)
13712 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
13714 if (sizeflag
& DFLAG
)
13715 *obufp
++ = intel_syntax
? 'd' : 'l';
13717 *obufp
++ = intel_syntax
? 'w' : 's';
13718 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13722 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
13725 if (modrm
.mod
== 3)
13731 if (sizeflag
& DFLAG
)
13732 *obufp
++ = intel_syntax
? 'd' : 'l';
13735 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13741 case 'E': /* For jcxz/jecxz */
13742 if (address_mode
== mode_64bit
)
13744 if (sizeflag
& AFLAG
)
13750 if (sizeflag
& AFLAG
)
13752 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13757 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
13759 if (sizeflag
& AFLAG
)
13760 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
13762 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
13763 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
13767 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
13769 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
13773 if (!(rex
& REX_W
))
13774 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13779 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
13780 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
13782 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
13785 if (prefixes
& PREFIX_DS
)
13806 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
13811 /* Fall through. */
13814 if (l
!= 0 || len
!= 1)
13822 if (sizeflag
& SUFFIX_ALWAYS
)
13826 if (intel_mnemonic
!= cond
)
13830 if ((prefixes
& PREFIX_FWAIT
) == 0)
13833 used_prefixes
|= PREFIX_FWAIT
;
13839 else if (intel_syntax
&& (sizeflag
& DFLAG
))
13843 if (!(rex
& REX_W
))
13844 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13848 && address_mode
== mode_64bit
13849 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
13854 /* Fall through. */
13857 if (l
== 0 && len
== 1)
13862 if ((rex
& REX_W
) == 0
13863 && (prefixes
& PREFIX_DATA
))
13865 if ((sizeflag
& DFLAG
) == 0)
13867 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13871 if ((prefixes
& PREFIX_DATA
)
13873 || (sizeflag
& SUFFIX_ALWAYS
))
13880 if (sizeflag
& DFLAG
)
13884 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13890 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
13896 if ((prefixes
& PREFIX_DATA
)
13898 || (sizeflag
& SUFFIX_ALWAYS
))
13905 if (sizeflag
& DFLAG
)
13906 *obufp
++ = intel_syntax
? 'd' : 'l';
13909 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13917 if (address_mode
== mode_64bit
13918 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
13920 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13924 /* Fall through. */
13927 if (l
== 0 && len
== 1)
13930 if (intel_syntax
&& !alt
)
13933 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
13939 if (sizeflag
& DFLAG
)
13940 *obufp
++ = intel_syntax
? 'd' : 'l';
13943 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13949 if (l
!= 1 || len
!= 2 || last
[0] != 'L')
13955 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
13970 else if (sizeflag
& DFLAG
)
13979 if (intel_syntax
&& !p
[1]
13980 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
13982 if (!(rex
& REX_W
))
13983 used_prefixes
|= (prefixes
& PREFIX_DATA
);
13986 if (l
== 0 && len
== 1)
13990 if (address_mode
== mode_64bit
13991 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
13993 if (sizeflag
& SUFFIX_ALWAYS
)
14015 /* Fall through. */
14018 if (l
== 0 && len
== 1)
14023 if (sizeflag
& SUFFIX_ALWAYS
)
14029 if (sizeflag
& DFLAG
)
14033 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14047 if (address_mode
== mode_64bit
14048 && !(prefixes
& PREFIX_ADDR
))
14059 if (l
!= 0 || len
!= 1)
14064 if (need_vex
&& vex
.prefix
)
14066 if (vex
.prefix
== DATA_PREFIX_OPCODE
)
14073 if (prefixes
& PREFIX_DATA
)
14077 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14081 if (l
== 0 && len
== 1)
14083 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
14094 if (l
!= 1 || len
!= 2 || last
[0] != 'X')
14102 || (modrm
.mod
== 3 && !(sizeflag
& SUFFIX_ALWAYS
)))
14104 switch (vex
.length
)
14118 if (l
== 0 && len
== 1)
14120 /* operand size flag for cwtl, cbtw */
14129 else if (sizeflag
& DFLAG
)
14133 if (!(rex
& REX_W
))
14134 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14141 && last
[0] != 'L'))
14148 if (last
[0] == 'X')
14149 *obufp
++ = vex
.w
? 'd': 's';
14151 *obufp
++ = vex
.w
? 'q': 'd';
14158 mnemonicendp
= obufp
;
14163 oappend (const char *s
)
14165 obufp
= stpcpy (obufp
, s
);
14171 /* Only print the active segment register. */
14172 if (!active_seg_prefix
)
14175 used_prefixes
|= active_seg_prefix
;
14176 switch (active_seg_prefix
)
14179 oappend_maybe_intel ("%cs:");
14182 oappend_maybe_intel ("%ds:");
14185 oappend_maybe_intel ("%ss:");
14188 oappend_maybe_intel ("%es:");
14191 oappend_maybe_intel ("%fs:");
14194 oappend_maybe_intel ("%gs:");
14202 OP_indirE (int bytemode
, int sizeflag
)
14206 OP_E (bytemode
, sizeflag
);
14210 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
14212 if (address_mode
== mode_64bit
)
14220 sprintf_vma (tmp
, disp
);
14221 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
14222 strcpy (buf
+ 2, tmp
+ i
);
14226 bfd_signed_vma v
= disp
;
14233 /* Check for possible overflow on 0x8000000000000000. */
14236 strcpy (buf
, "9223372036854775808");
14250 tmp
[28 - i
] = (v
% 10) + '0';
14254 strcpy (buf
, tmp
+ 29 - i
);
14260 sprintf (buf
, "0x%x", (unsigned int) disp
);
14262 sprintf (buf
, "%d", (int) disp
);
14266 /* Put DISP in BUF as signed hex number. */
14269 print_displacement (char *buf
, bfd_vma disp
)
14271 bfd_signed_vma val
= disp
;
14280 /* Check for possible overflow. */
14283 switch (address_mode
)
14286 strcpy (buf
+ j
, "0x8000000000000000");
14289 strcpy (buf
+ j
, "0x80000000");
14292 strcpy (buf
+ j
, "0x8000");
14302 sprintf_vma (tmp
, (bfd_vma
) val
);
14303 for (i
= 0; tmp
[i
] == '0'; i
++)
14305 if (tmp
[i
] == '\0')
14307 strcpy (buf
+ j
, tmp
+ i
);
14311 intel_operand_size (int bytemode
, int sizeflag
)
14315 && (bytemode
== x_mode
14316 || bytemode
== evex_half_bcst_xmmq_mode
))
14319 oappend ("QWORD PTR ");
14321 oappend ("DWORD PTR ");
14330 oappend ("BYTE PTR ");
14335 case dqw_swap_mode
:
14336 oappend ("WORD PTR ");
14339 if (address_mode
== mode_64bit
&& ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
14341 oappend ("QWORD PTR ");
14350 oappend ("QWORD PTR ");
14353 if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
14354 oappend ("DWORD PTR ");
14356 oappend ("WORD PTR ");
14357 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14361 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
14363 oappend ("WORD PTR ");
14364 if (!(rex
& REX_W
))
14365 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14368 if (sizeflag
& DFLAG
)
14369 oappend ("QWORD PTR ");
14371 oappend ("DWORD PTR ");
14372 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14375 case d_scalar_mode
:
14376 case d_scalar_swap_mode
:
14379 oappend ("DWORD PTR ");
14382 case q_scalar_mode
:
14383 case q_scalar_swap_mode
:
14385 oappend ("QWORD PTR ");
14388 if (address_mode
== mode_64bit
)
14389 oappend ("QWORD PTR ");
14391 oappend ("DWORD PTR ");
14394 if (sizeflag
& DFLAG
)
14395 oappend ("FWORD PTR ");
14397 oappend ("DWORD PTR ");
14398 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14401 oappend ("TBYTE PTR ");
14405 case evex_x_gscat_mode
:
14406 case evex_x_nobcst_mode
:
14409 switch (vex
.length
)
14412 oappend ("XMMWORD PTR ");
14415 oappend ("YMMWORD PTR ");
14418 oappend ("ZMMWORD PTR ");
14425 oappend ("XMMWORD PTR ");
14428 oappend ("XMMWORD PTR ");
14431 oappend ("YMMWORD PTR ");
14434 case evex_half_bcst_xmmq_mode
:
14438 switch (vex
.length
)
14441 oappend ("QWORD PTR ");
14444 oappend ("XMMWORD PTR ");
14447 oappend ("YMMWORD PTR ");
14457 switch (vex
.length
)
14462 oappend ("BYTE PTR ");
14472 switch (vex
.length
)
14477 oappend ("WORD PTR ");
14487 switch (vex
.length
)
14492 oappend ("DWORD PTR ");
14502 switch (vex
.length
)
14507 oappend ("QWORD PTR ");
14517 switch (vex
.length
)
14520 oappend ("WORD PTR ");
14523 oappend ("DWORD PTR ");
14526 oappend ("QWORD PTR ");
14536 switch (vex
.length
)
14539 oappend ("DWORD PTR ");
14542 oappend ("QWORD PTR ");
14545 oappend ("XMMWORD PTR ");
14555 switch (vex
.length
)
14558 oappend ("QWORD PTR ");
14561 oappend ("YMMWORD PTR ");
14564 oappend ("ZMMWORD PTR ");
14574 switch (vex
.length
)
14578 oappend ("XMMWORD PTR ");
14585 oappend ("OWORD PTR ");
14588 case vex_w_dq_mode
:
14589 case vex_scalar_w_dq_mode
:
14594 oappend ("QWORD PTR ");
14596 oappend ("DWORD PTR ");
14598 case vex_vsib_d_w_dq_mode
:
14599 case vex_vsib_q_w_dq_mode
:
14606 oappend ("QWORD PTR ");
14608 oappend ("DWORD PTR ");
14612 switch (vex
.length
)
14615 oappend ("XMMWORD PTR ");
14618 oappend ("YMMWORD PTR ");
14621 oappend ("ZMMWORD PTR ");
14628 case vex_vsib_q_w_d_mode
:
14629 case vex_vsib_d_w_d_mode
:
14630 if (!need_vex
|| !vex
.evex
)
14633 switch (vex
.length
)
14636 oappend ("QWORD PTR ");
14639 oappend ("XMMWORD PTR ");
14642 oappend ("YMMWORD PTR ");
14650 if (!need_vex
|| vex
.length
!= 128)
14653 oappend ("DWORD PTR ");
14655 oappend ("BYTE PTR ");
14661 oappend ("QWORD PTR ");
14663 oappend ("WORD PTR ");
14672 OP_E_register (int bytemode
, int sizeflag
)
14674 int reg
= modrm
.rm
;
14675 const char **names
;
14681 if ((sizeflag
& SUFFIX_ALWAYS
)
14682 && (bytemode
== b_swap_mode
14683 || bytemode
== v_swap_mode
14684 || bytemode
== dqw_swap_mode
))
14710 names
= address_mode
== mode_64bit
? names64
: names32
;
14716 if (address_mode
== mode_64bit
&& ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
14729 case dqw_swap_mode
:
14735 if ((sizeflag
& DFLAG
)
14736 || (bytemode
!= v_mode
14737 && bytemode
!= v_swap_mode
))
14741 used_prefixes
|= (prefixes
& PREFIX_DATA
);
14746 names
= names_mask
;
14751 oappend (INTERNAL_DISASSEMBLER_ERROR
);
14754 oappend (names
[reg
]);
14758 OP_E_memory (int bytemode
, int sizeflag
)
14761 int add
= (rex
& REX_B
) ? 8 : 0;
14767 /* In EVEX, if operand doesn't allow broadcast, vex.b should be 0. */
14769 && bytemode
!= x_mode
14770 && bytemode
!= xmmq_mode
14771 && bytemode
!= evex_half_bcst_xmmq_mode
)
14780 case dqw_swap_mode
:
14787 case vex_vsib_d_w_dq_mode
:
14788 case vex_vsib_d_w_d_mode
:
14789 case vex_vsib_q_w_dq_mode
:
14790 case vex_vsib_q_w_d_mode
:
14791 case evex_x_gscat_mode
:
14793 shift
= vex
.w
? 3 : 2;
14796 case evex_half_bcst_xmmq_mode
:
14800 shift
= vex
.w
? 3 : 2;
14803 /* Fall through if vex.b == 0. */
14807 case evex_x_nobcst_mode
:
14809 switch (vex
.length
)
14832 case q_scalar_mode
:
14834 case q_scalar_swap_mode
:
14840 case d_scalar_mode
:
14842 case d_scalar_swap_mode
:
14854 /* Make necessary corrections to shift for modes that need it.
14855 For these modes we currently have shift 4, 5 or 6 depending on
14856 vex.length (it corresponds to xmmword, ymmword or zmmword
14857 operand). We might want to make it 3, 4 or 5 (e.g. for
14858 xmmq_mode). In case of broadcast enabled the corrections
14859 aren't needed, as element size is always 32 or 64 bits. */
14861 && (bytemode
== xmmq_mode
14862 || bytemode
== evex_half_bcst_xmmq_mode
))
14864 else if (bytemode
== xmmqd_mode
)
14866 else if (bytemode
== xmmdw_mode
)
14868 else if (bytemode
== ymmq_mode
&& vex
.length
== 128)
14876 intel_operand_size (bytemode
, sizeflag
);
14879 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
14881 /* 32/64 bit address mode */
14890 int addr32flag
= !((sizeflag
& AFLAG
)
14891 || bytemode
== v_bnd_mode
14892 || bytemode
== bnd_mode
);
14893 const char **indexes64
= names64
;
14894 const char **indexes32
= names32
;
14904 vindex
= sib
.index
;
14910 case vex_vsib_d_w_dq_mode
:
14911 case vex_vsib_d_w_d_mode
:
14912 case vex_vsib_q_w_dq_mode
:
14913 case vex_vsib_q_w_d_mode
:
14923 switch (vex
.length
)
14926 indexes64
= indexes32
= names_xmm
;
14930 || bytemode
== vex_vsib_q_w_dq_mode
14931 || bytemode
== vex_vsib_q_w_d_mode
)
14932 indexes64
= indexes32
= names_ymm
;
14934 indexes64
= indexes32
= names_xmm
;
14938 || bytemode
== vex_vsib_q_w_dq_mode
14939 || bytemode
== vex_vsib_q_w_d_mode
)
14940 indexes64
= indexes32
= names_zmm
;
14942 indexes64
= indexes32
= names_ymm
;
14949 haveindex
= vindex
!= 4;
14956 rbase
= base
+ add
;
14964 if (address_mode
== mode_64bit
&& !havesib
)
14970 FETCH_DATA (the_info
, codep
+ 1);
14972 if ((disp
& 0x80) != 0)
14974 if (vex
.evex
&& shift
> 0)
14982 /* In 32bit mode, we need index register to tell [offset] from
14983 [eiz*1 + offset]. */
14984 needindex
= (havesib
14987 && address_mode
== mode_32bit
);
14988 havedisp
= (havebase
14990 || (havesib
&& (haveindex
|| scale
!= 0)));
14993 if (modrm
.mod
!= 0 || base
== 5)
14995 if (havedisp
|| riprel
)
14996 print_displacement (scratchbuf
, disp
);
14998 print_operand_value (scratchbuf
, 1, disp
);
14999 oappend (scratchbuf
);
15003 oappend (sizeflag
& AFLAG
? "(%rip)" : "(%eip)");
15007 if ((havebase
|| haveindex
|| riprel
)
15008 && (bytemode
!= v_bnd_mode
)
15009 && (bytemode
!= bnd_mode
))
15010 used_prefixes
|= PREFIX_ADDR
;
15012 if (havedisp
|| (intel_syntax
&& riprel
))
15014 *obufp
++ = open_char
;
15015 if (intel_syntax
&& riprel
)
15018 oappend (sizeflag
& AFLAG
? "rip" : "eip");
15022 oappend (address_mode
== mode_64bit
&& !addr32flag
15023 ? names64
[rbase
] : names32
[rbase
]);
15026 /* ESP/RSP won't allow index. If base isn't ESP/RSP,
15027 print index to tell base + index from base. */
15031 || (havebase
&& base
!= ESP_REG_NUM
))
15033 if (!intel_syntax
|| havebase
)
15035 *obufp
++ = separator_char
;
15039 oappend (address_mode
== mode_64bit
&& !addr32flag
15040 ? indexes64
[vindex
] : indexes32
[vindex
]);
15042 oappend (address_mode
== mode_64bit
&& !addr32flag
15043 ? index64
: index32
);
15045 *obufp
++ = scale_char
;
15047 sprintf (scratchbuf
, "%d", 1 << scale
);
15048 oappend (scratchbuf
);
15052 && (disp
|| modrm
.mod
!= 0 || base
== 5))
15054 if (!havedisp
|| (bfd_signed_vma
) disp
>= 0)
15059 else if (modrm
.mod
!= 1 && disp
!= -disp
)
15063 disp
= - (bfd_signed_vma
) disp
;
15067 print_displacement (scratchbuf
, disp
);
15069 print_operand_value (scratchbuf
, 1, disp
);
15070 oappend (scratchbuf
);
15073 *obufp
++ = close_char
;
15076 else if (intel_syntax
)
15078 if (modrm
.mod
!= 0 || base
== 5)
15080 if (!active_seg_prefix
)
15082 oappend (names_seg
[ds_reg
- es_reg
]);
15085 print_operand_value (scratchbuf
, 1, disp
);
15086 oappend (scratchbuf
);
15092 /* 16 bit address mode */
15093 used_prefixes
|= prefixes
& PREFIX_ADDR
;
15100 if ((disp
& 0x8000) != 0)
15105 FETCH_DATA (the_info
, codep
+ 1);
15107 if ((disp
& 0x80) != 0)
15112 if ((disp
& 0x8000) != 0)
15118 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
15120 print_displacement (scratchbuf
, disp
);
15121 oappend (scratchbuf
);
15124 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
15126 *obufp
++ = open_char
;
15128 oappend (index16
[modrm
.rm
]);
15130 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
15132 if ((bfd_signed_vma
) disp
>= 0)
15137 else if (modrm
.mod
!= 1)
15141 disp
= - (bfd_signed_vma
) disp
;
15144 print_displacement (scratchbuf
, disp
);
15145 oappend (scratchbuf
);
15148 *obufp
++ = close_char
;
15151 else if (intel_syntax
)
15153 if (!active_seg_prefix
)
15155 oappend (names_seg
[ds_reg
- es_reg
]);
15158 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
15159 oappend (scratchbuf
);
15162 if (vex
.evex
&& vex
.b
15163 && (bytemode
== x_mode
15164 || bytemode
== xmmq_mode
15165 || bytemode
== evex_half_bcst_xmmq_mode
))
15168 || bytemode
== xmmq_mode
15169 || bytemode
== evex_half_bcst_xmmq_mode
)
15171 switch (vex
.length
)
15174 oappend ("{1to2}");
15177 oappend ("{1to4}");
15180 oappend ("{1to8}");
15188 switch (vex
.length
)
15191 oappend ("{1to4}");
15194 oappend ("{1to8}");
15197 oappend ("{1to16}");
15207 OP_E (int bytemode
, int sizeflag
)
15209 /* Skip mod/rm byte. */
15213 if (modrm
.mod
== 3)
15214 OP_E_register (bytemode
, sizeflag
);
15216 OP_E_memory (bytemode
, sizeflag
);
15220 OP_G (int bytemode
, int sizeflag
)
15231 oappend (names8rex
[modrm
.reg
+ add
]);
15233 oappend (names8
[modrm
.reg
+ add
]);
15236 oappend (names16
[modrm
.reg
+ add
]);
15241 oappend (names32
[modrm
.reg
+ add
]);
15244 oappend (names64
[modrm
.reg
+ add
]);
15247 oappend (names_bnd
[modrm
.reg
]);
15254 case dqw_swap_mode
:
15257 oappend (names64
[modrm
.reg
+ add
]);
15260 if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
15261 oappend (names32
[modrm
.reg
+ add
]);
15263 oappend (names16
[modrm
.reg
+ add
]);
15264 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15268 if (address_mode
== mode_64bit
)
15269 oappend (names64
[modrm
.reg
+ add
]);
15271 oappend (names32
[modrm
.reg
+ add
]);
15275 oappend (names_mask
[modrm
.reg
+ add
]);
15278 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15291 FETCH_DATA (the_info
, codep
+ 8);
15292 a
= *codep
++ & 0xff;
15293 a
|= (*codep
++ & 0xff) << 8;
15294 a
|= (*codep
++ & 0xff) << 16;
15295 a
|= (*codep
++ & 0xff) << 24;
15296 b
= *codep
++ & 0xff;
15297 b
|= (*codep
++ & 0xff) << 8;
15298 b
|= (*codep
++ & 0xff) << 16;
15299 b
|= (*codep
++ & 0xff) << 24;
15300 x
= a
+ ((bfd_vma
) b
<< 32);
15308 static bfd_signed_vma
15311 bfd_signed_vma x
= 0;
15313 FETCH_DATA (the_info
, codep
+ 4);
15314 x
= *codep
++ & (bfd_signed_vma
) 0xff;
15315 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
15316 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
15317 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
15321 static bfd_signed_vma
15324 bfd_signed_vma x
= 0;
15326 FETCH_DATA (the_info
, codep
+ 4);
15327 x
= *codep
++ & (bfd_signed_vma
) 0xff;
15328 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
15329 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
15330 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
15332 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
15342 FETCH_DATA (the_info
, codep
+ 2);
15343 x
= *codep
++ & 0xff;
15344 x
|= (*codep
++ & 0xff) << 8;
15349 set_op (bfd_vma op
, int riprel
)
15351 op_index
[op_ad
] = op_ad
;
15352 if (address_mode
== mode_64bit
)
15354 op_address
[op_ad
] = op
;
15355 op_riprel
[op_ad
] = riprel
;
15359 /* Mask to get a 32-bit address. */
15360 op_address
[op_ad
] = op
& 0xffffffff;
15361 op_riprel
[op_ad
] = riprel
& 0xffffffff;
15366 OP_REG (int code
, int sizeflag
)
15373 case es_reg
: case ss_reg
: case cs_reg
:
15374 case ds_reg
: case fs_reg
: case gs_reg
:
15375 oappend (names_seg
[code
- es_reg
]);
15387 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
15388 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
15389 s
= names16
[code
- ax_reg
+ add
];
15391 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
15392 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
15395 s
= names8rex
[code
- al_reg
+ add
];
15397 s
= names8
[code
- al_reg
];
15399 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
15400 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
15401 if (address_mode
== mode_64bit
15402 && ((sizeflag
& DFLAG
) || (rex
& REX_W
)))
15404 s
= names64
[code
- rAX_reg
+ add
];
15407 code
+= eAX_reg
- rAX_reg
;
15408 /* Fall through. */
15409 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
15410 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
15413 s
= names64
[code
- eAX_reg
+ add
];
15416 if (sizeflag
& DFLAG
)
15417 s
= names32
[code
- eAX_reg
+ add
];
15419 s
= names16
[code
- eAX_reg
+ add
];
15420 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15424 s
= INTERNAL_DISASSEMBLER_ERROR
;
15431 OP_IMREG (int code
, int sizeflag
)
15443 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
15444 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
15445 s
= names16
[code
- ax_reg
];
15447 case es_reg
: case ss_reg
: case cs_reg
:
15448 case ds_reg
: case fs_reg
: case gs_reg
:
15449 s
= names_seg
[code
- es_reg
];
15451 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
15452 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
15455 s
= names8rex
[code
- al_reg
];
15457 s
= names8
[code
- al_reg
];
15459 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
15460 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
15463 s
= names64
[code
- eAX_reg
];
15466 if (sizeflag
& DFLAG
)
15467 s
= names32
[code
- eAX_reg
];
15469 s
= names16
[code
- eAX_reg
];
15470 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15473 case z_mode_ax_reg
:
15474 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
15478 if (!(rex
& REX_W
))
15479 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15482 s
= INTERNAL_DISASSEMBLER_ERROR
;
15489 OP_I (int bytemode
, int sizeflag
)
15492 bfd_signed_vma mask
= -1;
15497 FETCH_DATA (the_info
, codep
+ 1);
15502 if (address_mode
== mode_64bit
)
15507 /* Fall through. */
15514 if (sizeflag
& DFLAG
)
15524 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15536 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15541 scratchbuf
[0] = '$';
15542 print_operand_value (scratchbuf
+ 1, 1, op
);
15543 oappend_maybe_intel (scratchbuf
);
15544 scratchbuf
[0] = '\0';
15548 OP_I64 (int bytemode
, int sizeflag
)
15551 bfd_signed_vma mask
= -1;
15553 if (address_mode
!= mode_64bit
)
15555 OP_I (bytemode
, sizeflag
);
15562 FETCH_DATA (the_info
, codep
+ 1);
15572 if (sizeflag
& DFLAG
)
15582 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15590 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15595 scratchbuf
[0] = '$';
15596 print_operand_value (scratchbuf
+ 1, 1, op
);
15597 oappend_maybe_intel (scratchbuf
);
15598 scratchbuf
[0] = '\0';
15602 OP_sI (int bytemode
, int sizeflag
)
15610 FETCH_DATA (the_info
, codep
+ 1);
15612 if ((op
& 0x80) != 0)
15614 if (bytemode
== b_T_mode
)
15616 if (address_mode
!= mode_64bit
15617 || !((sizeflag
& DFLAG
) || (rex
& REX_W
)))
15619 /* The operand-size prefix is overridden by a REX prefix. */
15620 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
15628 if (!(rex
& REX_W
))
15630 if (sizeflag
& DFLAG
)
15638 /* The operand-size prefix is overridden by a REX prefix. */
15639 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
15645 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15649 scratchbuf
[0] = '$';
15650 print_operand_value (scratchbuf
+ 1, 1, op
);
15651 oappend_maybe_intel (scratchbuf
);
15655 OP_J (int bytemode
, int sizeflag
)
15659 bfd_vma segment
= 0;
15664 FETCH_DATA (the_info
, codep
+ 1);
15666 if ((disp
& 0x80) != 0)
15671 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
15676 if ((disp
& 0x8000) != 0)
15678 /* In 16bit mode, address is wrapped around at 64k within
15679 the same segment. Otherwise, a data16 prefix on a jump
15680 instruction means that the pc is masked to 16 bits after
15681 the displacement is added! */
15683 if ((prefixes
& PREFIX_DATA
) == 0)
15684 segment
= ((start_pc
+ codep
- start_codep
)
15685 & ~((bfd_vma
) 0xffff));
15687 if (!(rex
& REX_W
))
15688 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15691 oappend (INTERNAL_DISASSEMBLER_ERROR
);
15694 disp
= ((start_pc
+ (codep
- start_codep
) + disp
) & mask
) | segment
;
15696 print_operand_value (scratchbuf
, 1, disp
);
15697 oappend (scratchbuf
);
15701 OP_SEG (int bytemode
, int sizeflag
)
15703 if (bytemode
== w_mode
)
15704 oappend (names_seg
[modrm
.reg
]);
15706 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
15710 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
15714 if (sizeflag
& DFLAG
)
15724 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15726 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
15728 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
15729 oappend (scratchbuf
);
15733 OP_OFF (int bytemode
, int sizeflag
)
15737 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
15738 intel_operand_size (bytemode
, sizeflag
);
15741 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
15748 if (!active_seg_prefix
)
15750 oappend (names_seg
[ds_reg
- es_reg
]);
15754 print_operand_value (scratchbuf
, 1, off
);
15755 oappend (scratchbuf
);
15759 OP_OFF64 (int bytemode
, int sizeflag
)
15763 if (address_mode
!= mode_64bit
15764 || (prefixes
& PREFIX_ADDR
))
15766 OP_OFF (bytemode
, sizeflag
);
15770 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
15771 intel_operand_size (bytemode
, sizeflag
);
15778 if (!active_seg_prefix
)
15780 oappend (names_seg
[ds_reg
- es_reg
]);
15784 print_operand_value (scratchbuf
, 1, off
);
15785 oappend (scratchbuf
);
15789 ptr_reg (int code
, int sizeflag
)
15793 *obufp
++ = open_char
;
15794 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
15795 if (address_mode
== mode_64bit
)
15797 if (!(sizeflag
& AFLAG
))
15798 s
= names32
[code
- eAX_reg
];
15800 s
= names64
[code
- eAX_reg
];
15802 else if (sizeflag
& AFLAG
)
15803 s
= names32
[code
- eAX_reg
];
15805 s
= names16
[code
- eAX_reg
];
15807 *obufp
++ = close_char
;
15812 OP_ESreg (int code
, int sizeflag
)
15818 case 0x6d: /* insw/insl */
15819 intel_operand_size (z_mode
, sizeflag
);
15821 case 0xa5: /* movsw/movsl/movsq */
15822 case 0xa7: /* cmpsw/cmpsl/cmpsq */
15823 case 0xab: /* stosw/stosl */
15824 case 0xaf: /* scasw/scasl */
15825 intel_operand_size (v_mode
, sizeflag
);
15828 intel_operand_size (b_mode
, sizeflag
);
15831 oappend_maybe_intel ("%es:");
15832 ptr_reg (code
, sizeflag
);
15836 OP_DSreg (int code
, int sizeflag
)
15842 case 0x6f: /* outsw/outsl */
15843 intel_operand_size (z_mode
, sizeflag
);
15845 case 0xa5: /* movsw/movsl/movsq */
15846 case 0xa7: /* cmpsw/cmpsl/cmpsq */
15847 case 0xad: /* lodsw/lodsl/lodsq */
15848 intel_operand_size (v_mode
, sizeflag
);
15851 intel_operand_size (b_mode
, sizeflag
);
15854 /* Set active_seg_prefix to PREFIX_DS if it is unset so that the
15855 default segment register DS is printed. */
15856 if (!active_seg_prefix
)
15857 active_seg_prefix
= PREFIX_DS
;
15859 ptr_reg (code
, sizeflag
);
15863 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15871 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
15873 all_prefixes
[last_lock_prefix
] = 0;
15874 used_prefixes
|= PREFIX_LOCK
;
15879 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
15880 oappend_maybe_intel (scratchbuf
);
15884 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15893 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
15895 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
15896 oappend (scratchbuf
);
15900 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15902 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
15903 oappend_maybe_intel (scratchbuf
);
15907 OP_R (int bytemode
, int sizeflag
)
15909 /* Skip mod/rm byte. */
15912 OP_E_register (bytemode
, sizeflag
);
15916 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
15918 int reg
= modrm
.reg
;
15919 const char **names
;
15921 used_prefixes
|= (prefixes
& PREFIX_DATA
);
15922 if (prefixes
& PREFIX_DATA
)
15931 oappend (names
[reg
]);
15935 OP_XMM (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
15937 int reg
= modrm
.reg
;
15938 const char **names
;
15950 && bytemode
!= xmm_mode
15951 && bytemode
!= xmmq_mode
15952 && bytemode
!= evex_half_bcst_xmmq_mode
15953 && bytemode
!= ymm_mode
15954 && bytemode
!= scalar_mode
)
15956 switch (vex
.length
)
15963 || (bytemode
!= vex_vsib_q_w_dq_mode
15964 && bytemode
!= vex_vsib_q_w_d_mode
))
15976 else if (bytemode
== xmmq_mode
15977 || bytemode
== evex_half_bcst_xmmq_mode
)
15979 switch (vex
.length
)
15992 else if (bytemode
== ymm_mode
)
15996 oappend (names
[reg
]);
16000 OP_EM (int bytemode
, int sizeflag
)
16003 const char **names
;
16005 if (modrm
.mod
!= 3)
16008 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
16010 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
16011 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16013 OP_E (bytemode
, sizeflag
);
16017 if ((sizeflag
& SUFFIX_ALWAYS
) && bytemode
== v_swap_mode
)
16020 /* Skip mod/rm byte. */
16023 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16025 if (prefixes
& PREFIX_DATA
)
16034 oappend (names
[reg
]);
16037 /* cvt* are the only instructions in sse2 which have
16038 both SSE and MMX operands and also have 0x66 prefix
16039 in their opcode. 0x66 was originally used to differentiate
16040 between SSE and MMX instruction(operands). So we have to handle the
16041 cvt* separately using OP_EMC and OP_MXC */
16043 OP_EMC (int bytemode
, int sizeflag
)
16045 if (modrm
.mod
!= 3)
16047 if (intel_syntax
&& bytemode
== v_mode
)
16049 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
16050 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16052 OP_E (bytemode
, sizeflag
);
16056 /* Skip mod/rm byte. */
16059 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16060 oappend (names_mm
[modrm
.rm
]);
16064 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16066 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16067 oappend (names_mm
[modrm
.reg
]);
16071 OP_EX (int bytemode
, int sizeflag
)
16074 const char **names
;
16076 /* Skip mod/rm byte. */
16080 if (modrm
.mod
!= 3)
16082 OP_E_memory (bytemode
, sizeflag
);
16097 if ((sizeflag
& SUFFIX_ALWAYS
)
16098 && (bytemode
== x_swap_mode
16099 || bytemode
== d_swap_mode
16100 || bytemode
== dqw_swap_mode
16101 || bytemode
== d_scalar_swap_mode
16102 || bytemode
== q_swap_mode
16103 || bytemode
== q_scalar_swap_mode
))
16107 && bytemode
!= xmm_mode
16108 && bytemode
!= xmmdw_mode
16109 && bytemode
!= xmmqd_mode
16110 && bytemode
!= xmm_mb_mode
16111 && bytemode
!= xmm_mw_mode
16112 && bytemode
!= xmm_md_mode
16113 && bytemode
!= xmm_mq_mode
16114 && bytemode
!= xmm_mdq_mode
16115 && bytemode
!= xmmq_mode
16116 && bytemode
!= evex_half_bcst_xmmq_mode
16117 && bytemode
!= ymm_mode
16118 && bytemode
!= d_scalar_mode
16119 && bytemode
!= d_scalar_swap_mode
16120 && bytemode
!= q_scalar_mode
16121 && bytemode
!= q_scalar_swap_mode
16122 && bytemode
!= vex_scalar_w_dq_mode
)
16124 switch (vex
.length
)
16139 else if (bytemode
== xmmq_mode
16140 || bytemode
== evex_half_bcst_xmmq_mode
)
16142 switch (vex
.length
)
16155 else if (bytemode
== ymm_mode
)
16159 oappend (names
[reg
]);
16163 OP_MS (int bytemode
, int sizeflag
)
16165 if (modrm
.mod
== 3)
16166 OP_EM (bytemode
, sizeflag
);
16172 OP_XS (int bytemode
, int sizeflag
)
16174 if (modrm
.mod
== 3)
16175 OP_EX (bytemode
, sizeflag
);
16181 OP_M (int bytemode
, int sizeflag
)
16183 if (modrm
.mod
== 3)
16184 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
16187 OP_E (bytemode
, sizeflag
);
16191 OP_0f07 (int bytemode
, int sizeflag
)
16193 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
16196 OP_E (bytemode
, sizeflag
);
16199 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
16200 32bit mode and "xchg %rax,%rax" in 64bit mode. */
16203 NOP_Fixup1 (int bytemode
, int sizeflag
)
16205 if ((prefixes
& PREFIX_DATA
) != 0
16208 && address_mode
== mode_64bit
))
16209 OP_REG (bytemode
, sizeflag
);
16211 strcpy (obuf
, "nop");
16215 NOP_Fixup2 (int bytemode
, int sizeflag
)
16217 if ((prefixes
& PREFIX_DATA
) != 0
16220 && address_mode
== mode_64bit
))
16221 OP_IMREG (bytemode
, sizeflag
);
16224 static const char *const Suffix3DNow
[] = {
16225 /* 00 */ NULL
, NULL
, NULL
, NULL
,
16226 /* 04 */ NULL
, NULL
, NULL
, NULL
,
16227 /* 08 */ NULL
, NULL
, NULL
, NULL
,
16228 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
16229 /* 10 */ NULL
, NULL
, NULL
, NULL
,
16230 /* 14 */ NULL
, NULL
, NULL
, NULL
,
16231 /* 18 */ NULL
, NULL
, NULL
, NULL
,
16232 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
16233 /* 20 */ NULL
, NULL
, NULL
, NULL
,
16234 /* 24 */ NULL
, NULL
, NULL
, NULL
,
16235 /* 28 */ NULL
, NULL
, NULL
, NULL
,
16236 /* 2C */ NULL
, NULL
, NULL
, NULL
,
16237 /* 30 */ NULL
, NULL
, NULL
, NULL
,
16238 /* 34 */ NULL
, NULL
, NULL
, NULL
,
16239 /* 38 */ NULL
, NULL
, NULL
, NULL
,
16240 /* 3C */ NULL
, NULL
, NULL
, NULL
,
16241 /* 40 */ NULL
, NULL
, NULL
, NULL
,
16242 /* 44 */ NULL
, NULL
, NULL
, NULL
,
16243 /* 48 */ NULL
, NULL
, NULL
, NULL
,
16244 /* 4C */ NULL
, NULL
, NULL
, NULL
,
16245 /* 50 */ NULL
, NULL
, NULL
, NULL
,
16246 /* 54 */ NULL
, NULL
, NULL
, NULL
,
16247 /* 58 */ NULL
, NULL
, NULL
, NULL
,
16248 /* 5C */ NULL
, NULL
, NULL
, NULL
,
16249 /* 60 */ NULL
, NULL
, NULL
, NULL
,
16250 /* 64 */ NULL
, NULL
, NULL
, NULL
,
16251 /* 68 */ NULL
, NULL
, NULL
, NULL
,
16252 /* 6C */ NULL
, NULL
, NULL
, NULL
,
16253 /* 70 */ NULL
, NULL
, NULL
, NULL
,
16254 /* 74 */ NULL
, NULL
, NULL
, NULL
,
16255 /* 78 */ NULL
, NULL
, NULL
, NULL
,
16256 /* 7C */ NULL
, NULL
, NULL
, NULL
,
16257 /* 80 */ NULL
, NULL
, NULL
, NULL
,
16258 /* 84 */ NULL
, NULL
, NULL
, NULL
,
16259 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
16260 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
16261 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
16262 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
16263 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
16264 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
16265 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
16266 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
16267 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
16268 /* AC */ NULL
, NULL
, "pfacc", NULL
,
16269 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
16270 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
16271 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
16272 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
16273 /* C0 */ NULL
, NULL
, NULL
, NULL
,
16274 /* C4 */ NULL
, NULL
, NULL
, NULL
,
16275 /* C8 */ NULL
, NULL
, NULL
, NULL
,
16276 /* CC */ NULL
, NULL
, NULL
, NULL
,
16277 /* D0 */ NULL
, NULL
, NULL
, NULL
,
16278 /* D4 */ NULL
, NULL
, NULL
, NULL
,
16279 /* D8 */ NULL
, NULL
, NULL
, NULL
,
16280 /* DC */ NULL
, NULL
, NULL
, NULL
,
16281 /* E0 */ NULL
, NULL
, NULL
, NULL
,
16282 /* E4 */ NULL
, NULL
, NULL
, NULL
,
16283 /* E8 */ NULL
, NULL
, NULL
, NULL
,
16284 /* EC */ NULL
, NULL
, NULL
, NULL
,
16285 /* F0 */ NULL
, NULL
, NULL
, NULL
,
16286 /* F4 */ NULL
, NULL
, NULL
, NULL
,
16287 /* F8 */ NULL
, NULL
, NULL
, NULL
,
16288 /* FC */ NULL
, NULL
, NULL
, NULL
,
16292 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16294 const char *mnemonic
;
16296 FETCH_DATA (the_info
, codep
+ 1);
16297 /* AMD 3DNow! instructions are specified by an opcode suffix in the
16298 place where an 8-bit immediate would normally go. ie. the last
16299 byte of the instruction. */
16300 obufp
= mnemonicendp
;
16301 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
16303 oappend (mnemonic
);
16306 /* Since a variable sized modrm/sib chunk is between the start
16307 of the opcode (0x0f0f) and the opcode suffix, we need to do
16308 all the modrm processing first, and don't know until now that
16309 we have a bad opcode. This necessitates some cleaning up. */
16310 op_out
[0][0] = '\0';
16311 op_out
[1][0] = '\0';
16314 mnemonicendp
= obufp
;
16317 static struct op simd_cmp_op
[] =
16319 { STRING_COMMA_LEN ("eq") },
16320 { STRING_COMMA_LEN ("lt") },
16321 { STRING_COMMA_LEN ("le") },
16322 { STRING_COMMA_LEN ("unord") },
16323 { STRING_COMMA_LEN ("neq") },
16324 { STRING_COMMA_LEN ("nlt") },
16325 { STRING_COMMA_LEN ("nle") },
16326 { STRING_COMMA_LEN ("ord") }
16330 CMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16332 unsigned int cmp_type
;
16334 FETCH_DATA (the_info
, codep
+ 1);
16335 cmp_type
= *codep
++ & 0xff;
16336 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
))
16339 char *p
= mnemonicendp
- 2;
16343 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
16344 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
16348 /* We have a reserved extension byte. Output it directly. */
16349 scratchbuf
[0] = '$';
16350 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
16351 oappend_maybe_intel (scratchbuf
);
16352 scratchbuf
[0] = '\0';
16357 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
16358 int sizeflag ATTRIBUTE_UNUSED
)
16360 /* mwait %eax,%ecx */
16363 const char **names
= (address_mode
== mode_64bit
16364 ? names64
: names32
);
16365 strcpy (op_out
[0], names
[0]);
16366 strcpy (op_out
[1], names
[1]);
16367 two_source_ops
= 1;
16369 /* Skip mod/rm byte. */
16375 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
16376 int sizeflag ATTRIBUTE_UNUSED
)
16378 /* monitor %eax,%ecx,%edx" */
16381 const char **op1_names
;
16382 const char **names
= (address_mode
== mode_64bit
16383 ? names64
: names32
);
16385 if (!(prefixes
& PREFIX_ADDR
))
16386 op1_names
= (address_mode
== mode_16bit
16387 ? names16
: names
);
16390 /* Remove "addr16/addr32". */
16391 all_prefixes
[last_addr_prefix
] = 0;
16392 op1_names
= (address_mode
!= mode_32bit
16393 ? names32
: names16
);
16394 used_prefixes
|= PREFIX_ADDR
;
16396 strcpy (op_out
[0], op1_names
[0]);
16397 strcpy (op_out
[1], names
[1]);
16398 strcpy (op_out
[2], names
[2]);
16399 two_source_ops
= 1;
16401 /* Skip mod/rm byte. */
16409 /* Throw away prefixes and 1st. opcode byte. */
16410 codep
= insn_codep
+ 1;
16415 REP_Fixup (int bytemode
, int sizeflag
)
16417 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
16419 if (prefixes
& PREFIX_REPZ
)
16420 all_prefixes
[last_repz_prefix
] = REP_PREFIX
;
16427 OP_IMREG (bytemode
, sizeflag
);
16430 OP_ESreg (bytemode
, sizeflag
);
16433 OP_DSreg (bytemode
, sizeflag
);
16441 /* For BND-prefixed instructions 0xF2 prefix should be displayed as
16445 BND_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
16447 if (prefixes
& PREFIX_REPNZ
)
16448 all_prefixes
[last_repnz_prefix
] = BND_PREFIX
;
16451 /* Similar to OP_E. But the 0xf2/0xf3 prefixes should be displayed as
16452 "xacquire"/"xrelease" for memory operand if there is a LOCK prefix.
16456 HLE_Fixup1 (int bytemode
, int sizeflag
)
16459 && (prefixes
& PREFIX_LOCK
) != 0)
16461 if (prefixes
& PREFIX_REPZ
)
16462 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16463 if (prefixes
& PREFIX_REPNZ
)
16464 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16467 OP_E (bytemode
, sizeflag
);
16470 /* Similar to OP_E. But the 0xf2/0xf3 prefixes should be displayed as
16471 "xacquire"/"xrelease" for memory operand. No check for LOCK prefix.
16475 HLE_Fixup2 (int bytemode
, int sizeflag
)
16477 if (modrm
.mod
!= 3)
16479 if (prefixes
& PREFIX_REPZ
)
16480 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16481 if (prefixes
& PREFIX_REPNZ
)
16482 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16485 OP_E (bytemode
, sizeflag
);
16488 /* Similar to OP_E. But the 0xf3 prefixes should be displayed as
16489 "xrelease" for memory operand. No check for LOCK prefix. */
16492 HLE_Fixup3 (int bytemode
, int sizeflag
)
16495 && last_repz_prefix
> last_repnz_prefix
16496 && (prefixes
& PREFIX_REPZ
) != 0)
16497 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16499 OP_E (bytemode
, sizeflag
);
16503 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
16508 /* Change cmpxchg8b to cmpxchg16b. */
16509 char *p
= mnemonicendp
- 2;
16510 mnemonicendp
= stpcpy (p
, "16b");
16513 else if ((prefixes
& PREFIX_LOCK
) != 0)
16515 if (prefixes
& PREFIX_REPZ
)
16516 all_prefixes
[last_repz_prefix
] = XRELEASE_PREFIX
;
16517 if (prefixes
& PREFIX_REPNZ
)
16518 all_prefixes
[last_repnz_prefix
] = XACQUIRE_PREFIX
;
16521 OP_M (bytemode
, sizeflag
);
16525 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
16527 const char **names
;
16531 switch (vex
.length
)
16545 oappend (names
[reg
]);
16549 CRC32_Fixup (int bytemode
, int sizeflag
)
16551 /* Add proper suffix to "crc32". */
16552 char *p
= mnemonicendp
;
16571 if (sizeflag
& DFLAG
)
16575 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16579 oappend (INTERNAL_DISASSEMBLER_ERROR
);
16586 if (modrm
.mod
== 3)
16590 /* Skip mod/rm byte. */
16595 add
= (rex
& REX_B
) ? 8 : 0;
16596 if (bytemode
== b_mode
)
16600 oappend (names8rex
[modrm
.rm
+ add
]);
16602 oappend (names8
[modrm
.rm
+ add
]);
16608 oappend (names64
[modrm
.rm
+ add
]);
16609 else if ((prefixes
& PREFIX_DATA
))
16610 oappend (names16
[modrm
.rm
+ add
]);
16612 oappend (names32
[modrm
.rm
+ add
]);
16616 OP_E (bytemode
, sizeflag
);
16620 FXSAVE_Fixup (int bytemode
, int sizeflag
)
16622 /* Add proper suffix to "fxsave" and "fxrstor". */
16626 char *p
= mnemonicendp
;
16632 OP_M (bytemode
, sizeflag
);
16635 /* Display the destination register operand for instructions with
16639 OP_VEX (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
16642 const char **names
;
16650 reg
= vex
.register_specifier
;
16657 if (bytemode
== vex_scalar_mode
)
16659 oappend (names_xmm
[reg
]);
16663 switch (vex
.length
)
16670 case vex_vsib_q_w_dq_mode
:
16671 case vex_vsib_q_w_d_mode
:
16682 names
= names_mask
;
16696 case vex_vsib_q_w_dq_mode
:
16697 case vex_vsib_q_w_d_mode
:
16698 names
= vex
.w
? names_ymm
: names_xmm
;
16702 names
= names_mask
;
16716 oappend (names
[reg
]);
16719 /* Get the VEX immediate byte without moving codep. */
16721 static unsigned char
16722 get_vex_imm8 (int sizeflag
, int opnum
)
16724 int bytes_before_imm
= 0;
16726 if (modrm
.mod
!= 3)
16728 /* There are SIB/displacement bytes. */
16729 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
16731 /* 32/64 bit address mode */
16732 int base
= modrm
.rm
;
16734 /* Check SIB byte. */
16737 FETCH_DATA (the_info
, codep
+ 1);
16739 /* When decoding the third source, don't increase
16740 bytes_before_imm as this has already been incremented
16741 by one in OP_E_memory while decoding the second
16744 bytes_before_imm
++;
16747 /* Don't increase bytes_before_imm when decoding the third source,
16748 it has already been incremented by OP_E_memory while decoding
16749 the second source operand. */
16755 /* When modrm.rm == 5 or modrm.rm == 4 and base in
16756 SIB == 5, there is a 4 byte displacement. */
16758 /* No displacement. */
16761 /* 4 byte displacement. */
16762 bytes_before_imm
+= 4;
16765 /* 1 byte displacement. */
16766 bytes_before_imm
++;
16773 /* 16 bit address mode */
16774 /* Don't increase bytes_before_imm when decoding the third source,
16775 it has already been incremented by OP_E_memory while decoding
16776 the second source operand. */
16782 /* When modrm.rm == 6, there is a 2 byte displacement. */
16784 /* No displacement. */
16787 /* 2 byte displacement. */
16788 bytes_before_imm
+= 2;
16791 /* 1 byte displacement: when decoding the third source,
16792 don't increase bytes_before_imm as this has already
16793 been incremented by one in OP_E_memory while decoding
16794 the second source operand. */
16796 bytes_before_imm
++;
16804 FETCH_DATA (the_info
, codep
+ bytes_before_imm
+ 1);
16805 return codep
[bytes_before_imm
];
16809 OP_EX_VexReg (int bytemode
, int sizeflag
, int reg
)
16811 const char **names
;
16813 if (reg
== -1 && modrm
.mod
!= 3)
16815 OP_E_memory (bytemode
, sizeflag
);
16827 else if (reg
> 7 && address_mode
!= mode_64bit
)
16831 switch (vex
.length
)
16842 oappend (names
[reg
]);
16846 OP_EX_VexImmW (int bytemode
, int sizeflag
)
16849 static unsigned char vex_imm8
;
16851 if (vex_w_done
== 0)
16855 /* Skip mod/rm byte. */
16859 vex_imm8
= get_vex_imm8 (sizeflag
, 0);
16862 reg
= vex_imm8
>> 4;
16864 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
16866 else if (vex_w_done
== 1)
16871 reg
= vex_imm8
>> 4;
16873 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
16877 /* Output the imm8 directly. */
16878 scratchbuf
[0] = '$';
16879 print_operand_value (scratchbuf
+ 1, 1, vex_imm8
& 0xf);
16880 oappend_maybe_intel (scratchbuf
);
16881 scratchbuf
[0] = '\0';
16887 OP_Vex_2src (int bytemode
, int sizeflag
)
16889 if (modrm
.mod
== 3)
16891 int reg
= modrm
.rm
;
16895 oappend (names_xmm
[reg
]);
16900 && (bytemode
== v_mode
|| bytemode
== v_swap_mode
))
16902 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
16903 used_prefixes
|= (prefixes
& PREFIX_DATA
);
16905 OP_E (bytemode
, sizeflag
);
16910 OP_Vex_2src_1 (int bytemode
, int sizeflag
)
16912 if (modrm
.mod
== 3)
16914 /* Skip mod/rm byte. */
16920 oappend (names_xmm
[vex
.register_specifier
]);
16922 OP_Vex_2src (bytemode
, sizeflag
);
16926 OP_Vex_2src_2 (int bytemode
, int sizeflag
)
16929 OP_Vex_2src (bytemode
, sizeflag
);
16931 oappend (names_xmm
[vex
.register_specifier
]);
16935 OP_EX_VexW (int bytemode
, int sizeflag
)
16943 /* Skip mod/rm byte. */
16948 reg
= get_vex_imm8 (sizeflag
, 0) >> 4;
16953 reg
= get_vex_imm8 (sizeflag
, 1) >> 4;
16956 OP_EX_VexReg (bytemode
, sizeflag
, reg
);
16960 VEXI4_Fixup (int bytemode ATTRIBUTE_UNUSED
,
16961 int sizeflag ATTRIBUTE_UNUSED
)
16963 /* Skip the immediate byte and check for invalid bits. */
16964 FETCH_DATA (the_info
, codep
+ 1);
16965 if (*codep
++ & 0xf)
16970 OP_REG_VexI4 (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
16973 const char **names
;
16975 FETCH_DATA (the_info
, codep
+ 1);
16978 if (bytemode
!= x_mode
)
16985 if (reg
> 7 && address_mode
!= mode_64bit
)
16988 switch (vex
.length
)
16999 oappend (names
[reg
]);
17003 OP_XMM_VexW (int bytemode
, int sizeflag
)
17005 /* Turn off the REX.W bit since it is used for swapping operands
17008 OP_XMM (bytemode
, sizeflag
);
17012 OP_EX_Vex (int bytemode
, int sizeflag
)
17014 if (modrm
.mod
!= 3)
17016 if (vex
.register_specifier
!= 0)
17020 OP_EX (bytemode
, sizeflag
);
17024 OP_XMM_Vex (int bytemode
, int sizeflag
)
17026 if (modrm
.mod
!= 3)
17028 if (vex
.register_specifier
!= 0)
17032 OP_XMM (bytemode
, sizeflag
);
17036 VZERO_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17038 switch (vex
.length
)
17041 mnemonicendp
= stpcpy (obuf
, "vzeroupper");
17044 mnemonicendp
= stpcpy (obuf
, "vzeroall");
17051 static struct op vex_cmp_op
[] =
17053 { STRING_COMMA_LEN ("eq") },
17054 { STRING_COMMA_LEN ("lt") },
17055 { STRING_COMMA_LEN ("le") },
17056 { STRING_COMMA_LEN ("unord") },
17057 { STRING_COMMA_LEN ("neq") },
17058 { STRING_COMMA_LEN ("nlt") },
17059 { STRING_COMMA_LEN ("nle") },
17060 { STRING_COMMA_LEN ("ord") },
17061 { STRING_COMMA_LEN ("eq_uq") },
17062 { STRING_COMMA_LEN ("nge") },
17063 { STRING_COMMA_LEN ("ngt") },
17064 { STRING_COMMA_LEN ("false") },
17065 { STRING_COMMA_LEN ("neq_oq") },
17066 { STRING_COMMA_LEN ("ge") },
17067 { STRING_COMMA_LEN ("gt") },
17068 { STRING_COMMA_LEN ("true") },
17069 { STRING_COMMA_LEN ("eq_os") },
17070 { STRING_COMMA_LEN ("lt_oq") },
17071 { STRING_COMMA_LEN ("le_oq") },
17072 { STRING_COMMA_LEN ("unord_s") },
17073 { STRING_COMMA_LEN ("neq_us") },
17074 { STRING_COMMA_LEN ("nlt_uq") },
17075 { STRING_COMMA_LEN ("nle_uq") },
17076 { STRING_COMMA_LEN ("ord_s") },
17077 { STRING_COMMA_LEN ("eq_us") },
17078 { STRING_COMMA_LEN ("nge_uq") },
17079 { STRING_COMMA_LEN ("ngt_uq") },
17080 { STRING_COMMA_LEN ("false_os") },
17081 { STRING_COMMA_LEN ("neq_os") },
17082 { STRING_COMMA_LEN ("ge_oq") },
17083 { STRING_COMMA_LEN ("gt_oq") },
17084 { STRING_COMMA_LEN ("true_us") },
17088 VCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17090 unsigned int cmp_type
;
17092 FETCH_DATA (the_info
, codep
+ 1);
17093 cmp_type
= *codep
++ & 0xff;
17094 if (cmp_type
< ARRAY_SIZE (vex_cmp_op
))
17097 char *p
= mnemonicendp
- 2;
17101 sprintf (p
, "%s%s", vex_cmp_op
[cmp_type
].name
, suffix
);
17102 mnemonicendp
+= vex_cmp_op
[cmp_type
].len
;
17106 /* We have a reserved extension byte. Output it directly. */
17107 scratchbuf
[0] = '$';
17108 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
17109 oappend_maybe_intel (scratchbuf
);
17110 scratchbuf
[0] = '\0';
17115 VPCMP_Fixup (int bytemode ATTRIBUTE_UNUSED
,
17116 int sizeflag ATTRIBUTE_UNUSED
)
17118 unsigned int cmp_type
;
17123 FETCH_DATA (the_info
, codep
+ 1);
17124 cmp_type
= *codep
++ & 0xff;
17125 /* There are aliases for immediates 0, 1, 2, 4, 5, 6.
17126 If it's the case, print suffix, otherwise - print the immediate. */
17127 if (cmp_type
< ARRAY_SIZE (simd_cmp_op
)
17132 char *p
= mnemonicendp
- 2;
17134 /* vpcmp* can have both one- and two-lettered suffix. */
17148 sprintf (p
, "%s%s", simd_cmp_op
[cmp_type
].name
, suffix
);
17149 mnemonicendp
+= simd_cmp_op
[cmp_type
].len
;
17153 /* We have a reserved extension byte. Output it directly. */
17154 scratchbuf
[0] = '$';
17155 print_operand_value (scratchbuf
+ 1, 1, cmp_type
);
17156 oappend_maybe_intel (scratchbuf
);
17157 scratchbuf
[0] = '\0';
17161 static const struct op pclmul_op
[] =
17163 { STRING_COMMA_LEN ("lql") },
17164 { STRING_COMMA_LEN ("hql") },
17165 { STRING_COMMA_LEN ("lqh") },
17166 { STRING_COMMA_LEN ("hqh") }
17170 PCLMUL_Fixup (int bytemode ATTRIBUTE_UNUSED
,
17171 int sizeflag ATTRIBUTE_UNUSED
)
17173 unsigned int pclmul_type
;
17175 FETCH_DATA (the_info
, codep
+ 1);
17176 pclmul_type
= *codep
++ & 0xff;
17177 switch (pclmul_type
)
17188 if (pclmul_type
< ARRAY_SIZE (pclmul_op
))
17191 char *p
= mnemonicendp
- 3;
17196 sprintf (p
, "%s%s", pclmul_op
[pclmul_type
].name
, suffix
);
17197 mnemonicendp
+= pclmul_op
[pclmul_type
].len
;
17201 /* We have a reserved extension byte. Output it directly. */
17202 scratchbuf
[0] = '$';
17203 print_operand_value (scratchbuf
+ 1, 1, pclmul_type
);
17204 oappend_maybe_intel (scratchbuf
);
17205 scratchbuf
[0] = '\0';
17210 MOVBE_Fixup (int bytemode
, int sizeflag
)
17212 /* Add proper suffix to "movbe". */
17213 char *p
= mnemonicendp
;
17222 if (sizeflag
& SUFFIX_ALWAYS
)
17228 if (sizeflag
& DFLAG
)
17232 used_prefixes
|= (prefixes
& PREFIX_DATA
);
17237 oappend (INTERNAL_DISASSEMBLER_ERROR
);
17244 OP_M (bytemode
, sizeflag
);
17248 OP_LWPCB_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17251 const char **names
;
17253 /* Skip mod/rm byte. */
17267 oappend (names
[reg
]);
17271 OP_LWP_E (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
17273 const char **names
;
17280 oappend (names
[vex
.register_specifier
]);
17284 OP_Mask (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
17287 || (bytemode
!= mask_mode
&& bytemode
!= mask_bd_mode
))
17291 if ((rex
& REX_R
) != 0 || !vex
.r
)
17297 oappend (names_mask
[modrm
.reg
]);
17301 OP_Rounding (int bytemode
, int sizeflag ATTRIBUTE_UNUSED
)
17304 || (bytemode
!= evex_rounding_mode
17305 && bytemode
!= evex_sae_mode
))
17307 if (modrm
.mod
== 3 && vex
.b
)
17310 case evex_rounding_mode
:
17311 oappend (names_rounding
[vex
.ll
]);
17313 case evex_sae_mode
: