1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005, 2006, 2007 Free Software Foundation, Inc.
5 This file is part of the GNU opcodes library.
7 This library is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 It is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public
15 License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
23 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
25 modified by John Hassey (hassey@dg-rtp.dg.com)
26 x86-64 support added by Jan Hubicka (jh@suse.cz)
27 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
29 /* The main tables describing the instructions is essentially a copy
30 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
31 Programmers Manual. Usually, there is a capital letter, followed
32 by a small letter. The capital letter tell the addressing mode,
33 and the small letter tells about the operand size. Refer to
34 the Intel manual for details. */
39 #include "opcode/i386.h"
40 #include "libiberty.h"
44 static int fetch_data (struct disassemble_info
*, bfd_byte
*);
45 static void ckprefix (void);
46 static const char *prefix_name (int, int);
47 static int print_insn (bfd_vma
, disassemble_info
*);
48 static void dofloat (int);
49 static void OP_ST (int, int);
50 static void OP_STi (int, int);
51 static int putop (const char *, int);
52 static void oappend (const char *);
53 static void append_seg (void);
54 static void OP_indirE (int, int);
55 static void print_operand_value (char *, int, bfd_vma
);
56 static void OP_E_extended (int, int, int);
57 static void print_displacement (char *, bfd_vma
);
58 static void OP_E (int, int);
59 static void OP_G (int, int);
60 static bfd_vma
get64 (void);
61 static bfd_signed_vma
get32 (void);
62 static bfd_signed_vma
get32s (void);
63 static int get16 (void);
64 static void set_op (bfd_vma
, int);
65 static void OP_Skip_MODRM (int, int);
66 static void OP_REG (int, int);
67 static void OP_IMREG (int, int);
68 static void OP_I (int, int);
69 static void OP_I64 (int, int);
70 static void OP_sI (int, int);
71 static void OP_J (int, int);
72 static void OP_SEG (int, int);
73 static void OP_DIR (int, int);
74 static void OP_OFF (int, int);
75 static void OP_OFF64 (int, int);
76 static void ptr_reg (int, int);
77 static void OP_ESreg (int, int);
78 static void OP_DSreg (int, int);
79 static void OP_C (int, int);
80 static void OP_D (int, int);
81 static void OP_T (int, int);
82 static void OP_R (int, int);
83 static void OP_MMX (int, int);
84 static void OP_XMM (int, int);
85 static void OP_EM (int, int);
86 static void OP_EX (int, int);
87 static void OP_EMC (int,int);
88 static void OP_MXC (int,int);
89 static void OP_MS (int, int);
90 static void OP_XS (int, int);
91 static void OP_M (int, int);
92 static void OP_0f07 (int, int);
93 static void OP_Monitor (int, int);
94 static void OP_Mwait (int, int);
95 static void NOP_Fixup1 (int, int);
96 static void NOP_Fixup2 (int, int);
97 static void OP_3DNowSuffix (int, int);
98 static void OP_SIMD_Suffix (int, int);
99 static void BadOp (void);
100 static void REP_Fixup (int, int);
101 static void CMPXCHG8B_Fixup (int, int);
102 static void XMM_Fixup (int, int);
103 static void CRC32_Fixup (int, int);
104 static void print_drex_arg (unsigned int, int, int);
105 static void OP_DREX4 (int, int);
106 static void OP_DREX3 (int, int);
107 static void OP_DREX_ICMP (int, int);
108 static void OP_DREX_FCMP (int, int);
111 /* Points to first byte not fetched. */
112 bfd_byte
*max_fetched
;
113 bfd_byte the_buffer
[MAX_MNEM_SIZE
];
126 enum address_mode address_mode
;
128 /* Flags for the prefixes for the current instruction. See below. */
131 /* REX prefix the current instruction. See below. */
133 /* Bits of REX we've already used. */
135 /* Mark parts used in the REX prefix. When we are testing for
136 empty prefix (for 8bit register REX extension), just mask it
137 out. Otherwise test for REX bit is excuse for existence of REX
138 only in case value is nonzero. */
139 #define USED_REX(value) \
144 rex_used |= (value) | REX_OPCODE; \
147 rex_used |= REX_OPCODE; \
150 /* Special 'registers' for DREX handling */
151 #define DREX_REG_UNKNOWN 1000 /* not initialized */
152 #define DREX_REG_MEMORY 1001 /* use MODRM/SIB/OFFSET memory */
154 /* The DREX byte has the following fields:
155 Bits 7-4 -- DREX.Dest, xmm destination register
156 Bit 3 -- DREX.OC0, operand config bit defines operand order
157 Bit 2 -- DREX.R, equivalent to REX_R bit, to extend ModRM register
158 Bit 1 -- DREX.X, equivalent to REX_X bit, to extend SIB index field
159 Bit 0 -- DREX.W, equivalent to REX_B bit, to extend ModRM r/m field,
160 SIB base field, or opcode reg field. */
161 #define DREX_XMM(drex) ((drex >> 4) & 0xf)
162 #define DREX_OC0(drex) ((drex >> 3) & 0x1)
164 /* Flags for prefixes which we somehow handled when printing the
165 current instruction. */
166 static int used_prefixes
;
168 /* Flags stored in PREFIXES. */
169 #define PREFIX_REPZ 1
170 #define PREFIX_REPNZ 2
171 #define PREFIX_LOCK 4
173 #define PREFIX_SS 0x10
174 #define PREFIX_DS 0x20
175 #define PREFIX_ES 0x40
176 #define PREFIX_FS 0x80
177 #define PREFIX_GS 0x100
178 #define PREFIX_DATA 0x200
179 #define PREFIX_ADDR 0x400
180 #define PREFIX_FWAIT 0x800
182 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
183 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
185 #define FETCH_DATA(info, addr) \
186 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
187 ? 1 : fetch_data ((info), (addr)))
190 fetch_data (struct disassemble_info
*info
, bfd_byte
*addr
)
193 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
194 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
196 if (addr
<= priv
->the_buffer
+ MAX_MNEM_SIZE
)
197 status
= (*info
->read_memory_func
) (start
,
199 addr
- priv
->max_fetched
,
205 /* If we did manage to read at least one byte, then
206 print_insn_i386 will do something sensible. Otherwise, print
207 an error. We do that here because this is where we know
209 if (priv
->max_fetched
== priv
->the_buffer
)
210 (*info
->memory_error_func
) (status
, start
, info
);
211 longjmp (priv
->bailout
, 1);
214 priv
->max_fetched
= addr
;
218 #define XX { NULL, 0 }
220 #define Eb { OP_E, b_mode }
221 #define Ev { OP_E, v_mode }
222 #define Ed { OP_E, d_mode }
223 #define Edq { OP_E, dq_mode }
224 #define Edqw { OP_E, dqw_mode }
225 #define Edqb { OP_E, dqb_mode }
226 #define Edqd { OP_E, dqd_mode }
227 #define Eq { OP_E, q_mode }
228 #define indirEv { OP_indirE, stack_v_mode }
229 #define indirEp { OP_indirE, f_mode }
230 #define stackEv { OP_E, stack_v_mode }
231 #define Em { OP_E, m_mode }
232 #define Ew { OP_E, w_mode }
233 #define M { OP_M, 0 } /* lea, lgdt, etc. */
234 #define Ma { OP_M, v_mode }
235 #define Mb { OP_M, b_mode }
236 #define Md { OP_M, d_mode }
237 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
238 #define Mq { OP_M, q_mode }
239 #define Gb { OP_G, b_mode }
240 #define Gv { OP_G, v_mode }
241 #define Gd { OP_G, d_mode }
242 #define Gdq { OP_G, dq_mode }
243 #define Gm { OP_G, m_mode }
244 #define Gw { OP_G, w_mode }
245 #define Rd { OP_R, d_mode }
246 #define Rm { OP_R, m_mode }
247 #define Ib { OP_I, b_mode }
248 #define sIb { OP_sI, b_mode } /* sign extened byte */
249 #define Iv { OP_I, v_mode }
250 #define Iq { OP_I, q_mode }
251 #define Iv64 { OP_I64, v_mode }
252 #define Iw { OP_I, w_mode }
253 #define I1 { OP_I, const_1_mode }
254 #define Jb { OP_J, b_mode }
255 #define Jv { OP_J, v_mode }
256 #define Cm { OP_C, m_mode }
257 #define Dm { OP_D, m_mode }
258 #define Td { OP_T, d_mode }
259 #define Skip_MODRM { OP_Skip_MODRM, 0 }
261 #define RMeAX { OP_REG, eAX_reg }
262 #define RMeBX { OP_REG, eBX_reg }
263 #define RMeCX { OP_REG, eCX_reg }
264 #define RMeDX { OP_REG, eDX_reg }
265 #define RMeSP { OP_REG, eSP_reg }
266 #define RMeBP { OP_REG, eBP_reg }
267 #define RMeSI { OP_REG, eSI_reg }
268 #define RMeDI { OP_REG, eDI_reg }
269 #define RMrAX { OP_REG, rAX_reg }
270 #define RMrBX { OP_REG, rBX_reg }
271 #define RMrCX { OP_REG, rCX_reg }
272 #define RMrDX { OP_REG, rDX_reg }
273 #define RMrSP { OP_REG, rSP_reg }
274 #define RMrBP { OP_REG, rBP_reg }
275 #define RMrSI { OP_REG, rSI_reg }
276 #define RMrDI { OP_REG, rDI_reg }
277 #define RMAL { OP_REG, al_reg }
278 #define RMAL { OP_REG, al_reg }
279 #define RMCL { OP_REG, cl_reg }
280 #define RMDL { OP_REG, dl_reg }
281 #define RMBL { OP_REG, bl_reg }
282 #define RMAH { OP_REG, ah_reg }
283 #define RMCH { OP_REG, ch_reg }
284 #define RMDH { OP_REG, dh_reg }
285 #define RMBH { OP_REG, bh_reg }
286 #define RMAX { OP_REG, ax_reg }
287 #define RMDX { OP_REG, dx_reg }
289 #define eAX { OP_IMREG, eAX_reg }
290 #define eBX { OP_IMREG, eBX_reg }
291 #define eCX { OP_IMREG, eCX_reg }
292 #define eDX { OP_IMREG, eDX_reg }
293 #define eSP { OP_IMREG, eSP_reg }
294 #define eBP { OP_IMREG, eBP_reg }
295 #define eSI { OP_IMREG, eSI_reg }
296 #define eDI { OP_IMREG, eDI_reg }
297 #define AL { OP_IMREG, al_reg }
298 #define CL { OP_IMREG, cl_reg }
299 #define DL { OP_IMREG, dl_reg }
300 #define BL { OP_IMREG, bl_reg }
301 #define AH { OP_IMREG, ah_reg }
302 #define CH { OP_IMREG, ch_reg }
303 #define DH { OP_IMREG, dh_reg }
304 #define BH { OP_IMREG, bh_reg }
305 #define AX { OP_IMREG, ax_reg }
306 #define DX { OP_IMREG, dx_reg }
307 #define zAX { OP_IMREG, z_mode_ax_reg }
308 #define indirDX { OP_IMREG, indir_dx_reg }
310 #define Sw { OP_SEG, w_mode }
311 #define Sv { OP_SEG, v_mode }
312 #define Ap { OP_DIR, 0 }
313 #define Ob { OP_OFF64, b_mode }
314 #define Ov { OP_OFF64, v_mode }
315 #define Xb { OP_DSreg, eSI_reg }
316 #define Xv { OP_DSreg, eSI_reg }
317 #define Xz { OP_DSreg, eSI_reg }
318 #define Yb { OP_ESreg, eDI_reg }
319 #define Yv { OP_ESreg, eDI_reg }
320 #define DSBX { OP_DSreg, eBX_reg }
322 #define es { OP_REG, es_reg }
323 #define ss { OP_REG, ss_reg }
324 #define cs { OP_REG, cs_reg }
325 #define ds { OP_REG, ds_reg }
326 #define fs { OP_REG, fs_reg }
327 #define gs { OP_REG, gs_reg }
329 #define MX { OP_MMX, 0 }
330 #define XM { OP_XMM, 0 }
331 #define EM { OP_EM, v_mode }
332 #define EMd { OP_EM, d_mode }
333 #define EMx { OP_EM, x_mode }
334 #define EXw { OP_EX, w_mode }
335 #define EXd { OP_EX, d_mode }
336 #define EXq { OP_EX, q_mode }
337 #define EXx { OP_EX, x_mode }
338 #define MS { OP_MS, v_mode }
339 #define XS { OP_XS, v_mode }
340 #define EMCq { OP_EMC, q_mode }
341 #define MXC { OP_MXC, 0 }
342 #define OPSUF { OP_3DNowSuffix, 0 }
343 #define OPSIMD { OP_SIMD_Suffix, 0 }
344 #define XMM0 { XMM_Fixup, 0 }
346 /* Used handle "rep" prefix for string instructions. */
347 #define Xbr { REP_Fixup, eSI_reg }
348 #define Xvr { REP_Fixup, eSI_reg }
349 #define Ybr { REP_Fixup, eDI_reg }
350 #define Yvr { REP_Fixup, eDI_reg }
351 #define Yzr { REP_Fixup, eDI_reg }
352 #define indirDXr { REP_Fixup, indir_dx_reg }
353 #define ALr { REP_Fixup, al_reg }
354 #define eAXr { REP_Fixup, eAX_reg }
356 #define cond_jump_flag { NULL, cond_jump_mode }
357 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
359 /* bits in sizeflag */
360 #define SUFFIX_ALWAYS 4
364 #define b_mode 1 /* byte operand */
365 #define v_mode 2 /* operand size depends on prefixes */
366 #define w_mode 3 /* word operand */
367 #define d_mode 4 /* double word operand */
368 #define q_mode 5 /* quad word operand */
369 #define t_mode 6 /* ten-byte operand */
370 #define x_mode 7 /* 16-byte XMM operand */
371 #define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */
372 #define cond_jump_mode 9
373 #define loop_jcxz_mode 10
374 #define dq_mode 11 /* operand size depends on REX prefixes. */
375 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */
376 #define f_mode 13 /* 4- or 6-byte pointer operand */
377 #define const_1_mode 14
378 #define stack_v_mode 15 /* v_mode for stack-related opcodes. */
379 #define z_mode 16 /* non-quad operand size depends on prefixes */
380 #define o_mode 17 /* 16-byte operand */
381 #define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */
382 #define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */
384 /* Flags that are OR'ed into the bytemode field to pass extra information. */
385 #define DREX_OC1 0x4000 /* OC1 bit set */
386 #define DREX_NO_OC0 0x2000 /* OC0 bit not used */
387 #define DREX_MASK 0x6000 /* mask to delete */
432 #define z_mode_ax_reg 149
433 #define indir_dx_reg 150
437 #define USE_PREFIX_USER_TABLE 3
438 #define X86_64_SPECIAL 4
439 #define IS_3BYTE_OPCODE 5
440 #define USE_OPC_EXT_TABLE 6
441 #define USE_OPC_EXT_RM_TABLE 7
443 #define FLOAT NULL, { { NULL, FLOATCODE } }
445 #define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } }
446 #define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } }
447 #define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } }
448 #define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } }
449 #define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } }
450 #define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } }
451 #define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } }
452 #define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } }
453 #define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } }
454 #define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } }
455 #define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } }
456 #define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } }
457 #define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } }
458 #define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } }
459 #define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } }
460 #define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } }
461 #define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } }
462 #define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } }
463 #define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } }
464 #define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } }
465 #define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } }
466 #define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } }
467 #define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } }
468 #define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } }
469 #define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } }
470 #define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } }
471 #define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } }
472 #define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } }
474 #define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } }
475 #define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } }
476 #define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } }
477 #define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } }
478 #define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } }
479 #define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } }
480 #define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } }
481 #define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } }
482 #define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } }
483 #define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } }
484 #define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } }
485 #define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } }
486 #define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } }
487 #define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } }
488 #define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } }
489 #define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } }
490 #define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } }
491 #define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } }
492 #define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } }
493 #define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } }
494 #define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } }
495 #define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } }
496 #define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } }
497 #define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } }
498 #define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } }
499 #define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } }
500 #define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } }
501 #define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } }
502 #define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } }
503 #define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } }
504 #define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } }
505 #define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } }
506 #define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } }
507 #define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } }
508 #define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } }
509 #define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } }
510 #define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } }
511 #define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } }
512 #define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } }
513 #define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } }
514 #define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } }
515 #define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } }
516 #define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } }
517 #define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } }
518 #define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } }
519 #define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } }
520 #define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } }
521 #define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } }
522 #define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } }
523 #define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } }
524 #define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } }
525 #define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } }
526 #define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } }
527 #define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } }
528 #define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } }
529 #define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } }
530 #define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } }
531 #define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } }
532 #define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } }
533 #define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } }
534 #define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } }
535 #define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } }
536 #define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } }
537 #define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } }
538 #define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } }
539 #define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } }
540 #define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } }
541 #define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } }
542 #define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } }
543 #define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } }
544 #define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } }
545 #define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } }
546 #define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } }
547 #define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } }
548 #define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } }
549 #define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } }
550 #define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } }
551 #define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } }
552 #define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } }
553 #define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } }
554 #define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } }
555 #define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } }
556 #define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } }
557 #define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } }
558 #define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } }
559 #define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } }
560 #define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } }
561 #define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } }
562 #define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } }
563 #define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } }
564 #define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } }
565 #define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } }
566 #define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } }
567 #define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } }
568 #define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } }
569 #define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } }
570 #define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } }
571 #define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } }
572 #define PREGRP98 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 98 } }
573 #define PREGRP99 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 99 } }
574 #define PREGRP100 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 100 } }
577 #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }
578 #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }
579 #define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }
580 #define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }
582 #define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }
583 #define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }
584 #define THREE_BYTE_SSE5_0F24 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 2 } }
585 #define THREE_BYTE_SSE5_0F25 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 3 } }
586 #define THREE_BYTE_SSE5_0F7A NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 4 } }
587 #define THREE_BYTE_SSE5_0F7B NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 5 } }
589 #define OPC_EXT_0 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 0 } }
590 #define OPC_EXT_1 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 1 } }
591 #define OPC_EXT_2 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 2 } }
592 #define OPC_EXT_3 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 3 } }
593 #define OPC_EXT_4 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 4 } }
594 #define OPC_EXT_5 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 5 } }
595 #define OPC_EXT_6 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 6 } }
596 #define OPC_EXT_7 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 7 } }
597 #define OPC_EXT_8 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 8 } }
598 #define OPC_EXT_9 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 9 } }
599 #define OPC_EXT_10 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 10 } }
600 #define OPC_EXT_11 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 11 } }
601 #define OPC_EXT_12 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 12 } }
602 #define OPC_EXT_13 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 13 } }
603 #define OPC_EXT_14 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 14 } }
604 #define OPC_EXT_15 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 15 } }
605 #define OPC_EXT_16 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 16 } }
606 #define OPC_EXT_17 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 17 } }
607 #define OPC_EXT_18 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 18 } }
608 #define OPC_EXT_19 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 19 } }
609 #define OPC_EXT_20 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 20 } }
610 #define OPC_EXT_21 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 21 } }
611 #define OPC_EXT_22 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 22 } }
612 #define OPC_EXT_23 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 23 } }
613 #define OPC_EXT_24 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 24 } }
614 #define OPC_EXT_25 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 25 } }
615 #define OPC_EXT_26 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 26 } }
616 #define OPC_EXT_27 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 27 } }
617 #define OPC_EXT_28 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 28 } }
618 #define OPC_EXT_29 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 29 } }
619 #define OPC_EXT_30 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 30 } }
620 #define OPC_EXT_31 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 31 } }
621 #define OPC_EXT_32 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 32 } }
622 #define OPC_EXT_33 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 33 } }
623 #define OPC_EXT_34 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 34 } }
624 #define OPC_EXT_35 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 35 } }
625 #define OPC_EXT_36 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 36 } }
626 #define OPC_EXT_37 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 37 } }
627 #define OPC_EXT_38 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 38 } }
628 #define OPC_EXT_39 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 39 } }
629 #define OPC_EXT_40 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 40 } }
630 #define OPC_EXT_41 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 41 } }
631 #define OPC_EXT_42 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 42 } }
632 #define OPC_EXT_43 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 43 } }
633 #define OPC_EXT_44 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 44 } }
634 #define OPC_EXT_45 NULL, { { NULL, USE_OPC_EXT_TABLE }, { NULL, 45 } }
636 #define OPC_EXT_RM_0 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 0 } }
637 #define OPC_EXT_RM_1 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 1 } }
638 #define OPC_EXT_RM_2 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 2 } }
639 #define OPC_EXT_RM_3 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 3 } }
640 #define OPC_EXT_RM_4 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 4 } }
641 #define OPC_EXT_RM_5 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 5 } }
642 #define OPC_EXT_RM_6 NULL, { { NULL, USE_OPC_EXT_RM_TABLE }, { NULL, 6 } }
644 typedef void (*op_rtn
) (int bytemode
, int sizeflag
);
655 /* Upper case letters in the instruction names here are macros.
656 'A' => print 'b' if no register operands or suffix_always is true
657 'B' => print 'b' if suffix_always is true
658 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
660 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
661 . suffix_always is true
662 'E' => print 'e' if 32-bit form of jcxz
663 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
664 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
665 'H' => print ",pt" or ",pn" branch hint
666 'I' => honor following macro letter even in Intel mode (implemented only
667 . for some of the macro letters)
669 'K' => print 'd' or 'q' if rex prefix is present.
670 'L' => print 'l' if suffix_always is true
671 'N' => print 'n' if instruction has no wait "prefix"
672 'O' => print 'd' or 'o' (or 'q' in Intel mode)
673 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
674 . or suffix_always is true. print 'q' if rex prefix is present.
675 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
677 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
678 'S' => print 'w', 'l' or 'q' if suffix_always is true
679 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
680 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
681 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
682 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
683 'X' => print 's', 'd' depending on data16 prefix (for XMM)
684 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
685 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
687 Many of the above letters print nothing in Intel mode. See "putop"
690 Braces '{' and '}', and vertical bars '|', indicate alternative
691 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
692 modes. In cases where there are only two alternatives, the X86_64
693 instruction is reserved, and "(bad)" is printed.
696 static const struct dis386 dis386
[] = {
698 { "addB", { Eb
, Gb
} },
699 { "addS", { Ev
, Gv
} },
700 { "addB", { Gb
, Eb
} },
701 { "addS", { Gv
, Ev
} },
702 { "addB", { AL
, Ib
} },
703 { "addS", { eAX
, Iv
} },
704 { "push{T|}", { es
} },
705 { "pop{T|}", { es
} },
707 { "orB", { Eb
, Gb
} },
708 { "orS", { Ev
, Gv
} },
709 { "orB", { Gb
, Eb
} },
710 { "orS", { Gv
, Ev
} },
711 { "orB", { AL
, Ib
} },
712 { "orS", { eAX
, Iv
} },
713 { "push{T|}", { cs
} },
714 { "(bad)", { XX
} }, /* 0x0f extended opcode escape */
716 { "adcB", { Eb
, Gb
} },
717 { "adcS", { Ev
, Gv
} },
718 { "adcB", { Gb
, Eb
} },
719 { "adcS", { Gv
, Ev
} },
720 { "adcB", { AL
, Ib
} },
721 { "adcS", { eAX
, Iv
} },
722 { "push{T|}", { ss
} },
723 { "pop{T|}", { ss
} },
725 { "sbbB", { Eb
, Gb
} },
726 { "sbbS", { Ev
, Gv
} },
727 { "sbbB", { Gb
, Eb
} },
728 { "sbbS", { Gv
, Ev
} },
729 { "sbbB", { AL
, Ib
} },
730 { "sbbS", { eAX
, Iv
} },
731 { "push{T|}", { ds
} },
732 { "pop{T|}", { ds
} },
734 { "andB", { Eb
, Gb
} },
735 { "andS", { Ev
, Gv
} },
736 { "andB", { Gb
, Eb
} },
737 { "andS", { Gv
, Ev
} },
738 { "andB", { AL
, Ib
} },
739 { "andS", { eAX
, Iv
} },
740 { "(bad)", { XX
} }, /* SEG ES prefix */
741 { "daa{|}", { XX
} },
743 { "subB", { Eb
, Gb
} },
744 { "subS", { Ev
, Gv
} },
745 { "subB", { Gb
, Eb
} },
746 { "subS", { Gv
, Ev
} },
747 { "subB", { AL
, Ib
} },
748 { "subS", { eAX
, Iv
} },
749 { "(bad)", { XX
} }, /* SEG CS prefix */
750 { "das{|}", { XX
} },
752 { "xorB", { Eb
, Gb
} },
753 { "xorS", { Ev
, Gv
} },
754 { "xorB", { Gb
, Eb
} },
755 { "xorS", { Gv
, Ev
} },
756 { "xorB", { AL
, Ib
} },
757 { "xorS", { eAX
, Iv
} },
758 { "(bad)", { XX
} }, /* SEG SS prefix */
759 { "aaa{|}", { XX
} },
761 { "cmpB", { Eb
, Gb
} },
762 { "cmpS", { Ev
, Gv
} },
763 { "cmpB", { Gb
, Eb
} },
764 { "cmpS", { Gv
, Ev
} },
765 { "cmpB", { AL
, Ib
} },
766 { "cmpS", { eAX
, Iv
} },
767 { "(bad)", { XX
} }, /* SEG DS prefix */
768 { "aas{|}", { XX
} },
770 { "inc{S|}", { RMeAX
} },
771 { "inc{S|}", { RMeCX
} },
772 { "inc{S|}", { RMeDX
} },
773 { "inc{S|}", { RMeBX
} },
774 { "inc{S|}", { RMeSP
} },
775 { "inc{S|}", { RMeBP
} },
776 { "inc{S|}", { RMeSI
} },
777 { "inc{S|}", { RMeDI
} },
779 { "dec{S|}", { RMeAX
} },
780 { "dec{S|}", { RMeCX
} },
781 { "dec{S|}", { RMeDX
} },
782 { "dec{S|}", { RMeBX
} },
783 { "dec{S|}", { RMeSP
} },
784 { "dec{S|}", { RMeBP
} },
785 { "dec{S|}", { RMeSI
} },
786 { "dec{S|}", { RMeDI
} },
788 { "pushV", { RMrAX
} },
789 { "pushV", { RMrCX
} },
790 { "pushV", { RMrDX
} },
791 { "pushV", { RMrBX
} },
792 { "pushV", { RMrSP
} },
793 { "pushV", { RMrBP
} },
794 { "pushV", { RMrSI
} },
795 { "pushV", { RMrDI
} },
797 { "popV", { RMrAX
} },
798 { "popV", { RMrCX
} },
799 { "popV", { RMrDX
} },
800 { "popV", { RMrBX
} },
801 { "popV", { RMrSP
} },
802 { "popV", { RMrBP
} },
803 { "popV", { RMrSI
} },
804 { "popV", { RMrDI
} },
810 { "(bad)", { XX
} }, /* seg fs */
811 { "(bad)", { XX
} }, /* seg gs */
812 { "(bad)", { XX
} }, /* op size prefix */
813 { "(bad)", { XX
} }, /* adr size prefix */
816 { "imulS", { Gv
, Ev
, Iv
} },
817 { "pushT", { sIb
} },
818 { "imulS", { Gv
, Ev
, sIb
} },
819 { "ins{b||b|}", { Ybr
, indirDX
} },
820 { "ins{R||G|}", { Yzr
, indirDX
} },
821 { "outs{b||b|}", { indirDXr
, Xb
} },
822 { "outs{R||G|}", { indirDXr
, Xz
} },
824 { "joH", { Jb
, XX
, cond_jump_flag
} },
825 { "jnoH", { Jb
, XX
, cond_jump_flag
} },
826 { "jbH", { Jb
, XX
, cond_jump_flag
} },
827 { "jaeH", { Jb
, XX
, cond_jump_flag
} },
828 { "jeH", { Jb
, XX
, cond_jump_flag
} },
829 { "jneH", { Jb
, XX
, cond_jump_flag
} },
830 { "jbeH", { Jb
, XX
, cond_jump_flag
} },
831 { "jaH", { Jb
, XX
, cond_jump_flag
} },
833 { "jsH", { Jb
, XX
, cond_jump_flag
} },
834 { "jnsH", { Jb
, XX
, cond_jump_flag
} },
835 { "jpH", { Jb
, XX
, cond_jump_flag
} },
836 { "jnpH", { Jb
, XX
, cond_jump_flag
} },
837 { "jlH", { Jb
, XX
, cond_jump_flag
} },
838 { "jgeH", { Jb
, XX
, cond_jump_flag
} },
839 { "jleH", { Jb
, XX
, cond_jump_flag
} },
840 { "jgH", { Jb
, XX
, cond_jump_flag
} },
846 { "testB", { Eb
, Gb
} },
847 { "testS", { Ev
, Gv
} },
848 { "xchgB", { Eb
, Gb
} },
849 { "xchgS", { Ev
, Gv
} },
851 { "movB", { Eb
, Gb
} },
852 { "movS", { Ev
, Gv
} },
853 { "movB", { Gb
, Eb
} },
854 { "movS", { Gv
, Ev
} },
855 { "movD", { Sv
, Sw
} },
857 { "movD", { Sw
, Sv
} },
861 { "xchgS", { RMeCX
, eAX
} },
862 { "xchgS", { RMeDX
, eAX
} },
863 { "xchgS", { RMeBX
, eAX
} },
864 { "xchgS", { RMeSP
, eAX
} },
865 { "xchgS", { RMeBP
, eAX
} },
866 { "xchgS", { RMeSI
, eAX
} },
867 { "xchgS", { RMeDI
, eAX
} },
869 { "cW{t||t|}R", { XX
} },
870 { "cR{t||t|}O", { XX
} },
871 { "Jcall{T|}", { Ap
} },
872 { "(bad)", { XX
} }, /* fwait */
873 { "pushfT", { XX
} },
875 { "sahf{|}", { XX
} },
876 { "lahf{|}", { XX
} },
878 { "movB", { AL
, Ob
} },
879 { "movS", { eAX
, Ov
} },
880 { "movB", { Ob
, AL
} },
881 { "movS", { Ov
, eAX
} },
882 { "movs{b||b|}", { Ybr
, Xb
} },
883 { "movs{R||R|}", { Yvr
, Xv
} },
884 { "cmps{b||b|}", { Xb
, Yb
} },
885 { "cmps{R||R|}", { Xv
, Yv
} },
887 { "testB", { AL
, Ib
} },
888 { "testS", { eAX
, Iv
} },
889 { "stosB", { Ybr
, AL
} },
890 { "stosS", { Yvr
, eAX
} },
891 { "lodsB", { ALr
, Xb
} },
892 { "lodsS", { eAXr
, Xv
} },
893 { "scasB", { AL
, Yb
} },
894 { "scasS", { eAX
, Yv
} },
896 { "movB", { RMAL
, Ib
} },
897 { "movB", { RMCL
, Ib
} },
898 { "movB", { RMDL
, Ib
} },
899 { "movB", { RMBL
, Ib
} },
900 { "movB", { RMAH
, Ib
} },
901 { "movB", { RMCH
, Ib
} },
902 { "movB", { RMDH
, Ib
} },
903 { "movB", { RMBH
, Ib
} },
905 { "movS", { RMeAX
, Iv64
} },
906 { "movS", { RMeCX
, Iv64
} },
907 { "movS", { RMeDX
, Iv64
} },
908 { "movS", { RMeBX
, Iv64
} },
909 { "movS", { RMeSP
, Iv64
} },
910 { "movS", { RMeBP
, Iv64
} },
911 { "movS", { RMeSI
, Iv64
} },
912 { "movS", { RMeDI
, Iv64
} },
923 { "enterT", { Iw
, Ib
} },
924 { "leaveT", { XX
} },
929 { "into{|}", { XX
} },
936 { "aam{|}", { sIb
} },
937 { "aad{|}", { sIb
} },
939 { "xlat", { DSBX
} },
950 { "loopneFH", { Jb
, XX
, loop_jcxz_flag
} },
951 { "loopeFH", { Jb
, XX
, loop_jcxz_flag
} },
952 { "loopFH", { Jb
, XX
, loop_jcxz_flag
} },
953 { "jEcxzH", { Jb
, XX
, loop_jcxz_flag
} },
954 { "inB", { AL
, Ib
} },
955 { "inG", { zAX
, Ib
} },
956 { "outB", { Ib
, AL
} },
957 { "outG", { Ib
, zAX
} },
961 { "Jjmp{T|}", { Ap
} },
963 { "inB", { AL
, indirDX
} },
964 { "inG", { zAX
, indirDX
} },
965 { "outB", { indirDX
, AL
} },
966 { "outG", { indirDX
, zAX
} },
968 { "(bad)", { XX
} }, /* lock prefix */
970 { "(bad)", { XX
} }, /* repne */
971 { "(bad)", { XX
} }, /* repz */
987 static const struct dis386 dis386_twobyte
[] = {
991 { "larS", { Gv
, Ew
} },
992 { "lslS", { Gv
, Ew
} },
994 { "syscall", { XX
} },
996 { "sysretP", { XX
} },
999 { "wbinvd", { XX
} },
1000 { "(bad)", { XX
} },
1002 { "(bad)", { XX
} },
1004 { "femms", { XX
} },
1005 { "", { MX
, EM
, OPSUF
} }, /* See OP_3DNowSuffix. */
1011 { "unpcklpX", { XM
, EXq
} },
1012 { "unpckhpX", { XM
, EXq
} },
1017 { "(bad)", { XX
} },
1018 { "(bad)", { XX
} },
1019 { "(bad)", { XX
} },
1020 { "(bad)", { XX
} },
1021 { "(bad)", { XX
} },
1022 { "(bad)", { XX
} },
1030 { THREE_BYTE_SSE5_0F25
},
1032 { "(bad)", { XX
} },
1034 { "movapX", { XM
, EXx
} },
1035 { "movapX", { EXx
, XM
} },
1043 { "wrmsr", { XX
} },
1044 { "rdtsc", { XX
} },
1045 { "rdmsr", { XX
} },
1046 { "rdpmc", { XX
} },
1047 { "sysenter", { XX
} },
1048 { "sysexit", { XX
} },
1049 { "(bad)", { XX
} },
1050 { "(bad)", { XX
} },
1053 { "(bad)", { XX
} },
1055 { "(bad)", { XX
} },
1056 { "(bad)", { XX
} },
1057 { "(bad)", { XX
} },
1058 { "(bad)", { XX
} },
1059 { "(bad)", { XX
} },
1061 { "cmovo", { Gv
, Ev
} },
1062 { "cmovno", { Gv
, Ev
} },
1063 { "cmovb", { Gv
, Ev
} },
1064 { "cmovae", { Gv
, Ev
} },
1065 { "cmove", { Gv
, Ev
} },
1066 { "cmovne", { Gv
, Ev
} },
1067 { "cmovbe", { Gv
, Ev
} },
1068 { "cmova", { Gv
, Ev
} },
1070 { "cmovs", { Gv
, Ev
} },
1071 { "cmovns", { Gv
, Ev
} },
1072 { "cmovp", { Gv
, Ev
} },
1073 { "cmovnp", { Gv
, Ev
} },
1074 { "cmovl", { Gv
, Ev
} },
1075 { "cmovge", { Gv
, Ev
} },
1076 { "cmovle", { Gv
, Ev
} },
1077 { "cmovg", { Gv
, Ev
} },
1079 { "movmskpX", { Gdq
, XS
} },
1083 { "andpX", { XM
, EXx
} },
1084 { "andnpX", { XM
, EXx
} },
1085 { "orpX", { XM
, EXx
} },
1086 { "xorpX", { XM
, EXx
} },
1100 { "packsswb", { MX
, EM
} },
1101 { "pcmpgtb", { MX
, EM
} },
1102 { "pcmpgtw", { MX
, EM
} },
1103 { "pcmpgtd", { MX
, EM
} },
1104 { "packuswb", { MX
, EM
} },
1106 { "punpckhbw", { MX
, EM
} },
1107 { "punpckhwd", { MX
, EM
} },
1108 { "punpckhdq", { MX
, EM
} },
1109 { "packssdw", { MX
, EM
} },
1112 { "movK", { MX
, Edq
} },
1119 { "pcmpeqb", { MX
, EM
} },
1120 { "pcmpeqw", { MX
, EM
} },
1121 { "pcmpeqd", { MX
, EM
} },
1126 { THREE_BYTE_SSE5_0F7A
},
1127 { THREE_BYTE_SSE5_0F7B
},
1133 { "joH", { Jv
, XX
, cond_jump_flag
} },
1134 { "jnoH", { Jv
, XX
, cond_jump_flag
} },
1135 { "jbH", { Jv
, XX
, cond_jump_flag
} },
1136 { "jaeH", { Jv
, XX
, cond_jump_flag
} },
1137 { "jeH", { Jv
, XX
, cond_jump_flag
} },
1138 { "jneH", { Jv
, XX
, cond_jump_flag
} },
1139 { "jbeH", { Jv
, XX
, cond_jump_flag
} },
1140 { "jaH", { Jv
, XX
, cond_jump_flag
} },
1142 { "jsH", { Jv
, XX
, cond_jump_flag
} },
1143 { "jnsH", { Jv
, XX
, cond_jump_flag
} },
1144 { "jpH", { Jv
, XX
, cond_jump_flag
} },
1145 { "jnpH", { Jv
, XX
, cond_jump_flag
} },
1146 { "jlH", { Jv
, XX
, cond_jump_flag
} },
1147 { "jgeH", { Jv
, XX
, cond_jump_flag
} },
1148 { "jleH", { Jv
, XX
, cond_jump_flag
} },
1149 { "jgH", { Jv
, XX
, cond_jump_flag
} },
1152 { "setno", { Eb
} },
1154 { "setae", { Eb
} },
1156 { "setne", { Eb
} },
1157 { "setbe", { Eb
} },
1161 { "setns", { Eb
} },
1163 { "setnp", { Eb
} },
1165 { "setge", { Eb
} },
1166 { "setle", { Eb
} },
1169 { "pushT", { fs
} },
1171 { "cpuid", { XX
} },
1172 { "btS", { Ev
, Gv
} },
1173 { "shldS", { Ev
, Gv
, Ib
} },
1174 { "shldS", { Ev
, Gv
, CL
} },
1178 { "pushT", { gs
} },
1181 { "btsS", { Ev
, Gv
} },
1182 { "shrdS", { Ev
, Gv
, Ib
} },
1183 { "shrdS", { Ev
, Gv
, CL
} },
1185 { "imulS", { Gv
, Ev
} },
1187 { "cmpxchgB", { Eb
, Gb
} },
1188 { "cmpxchgS", { Ev
, Gv
} },
1190 { "btrS", { Ev
, Gv
} },
1193 { "movz{bR|x|bR|x}", { Gv
, Eb
} },
1194 { "movz{wR|x|wR|x}", { Gv
, Ew
} }, /* yes, there really is movzww ! */
1199 { "btcS", { Ev
, Gv
} },
1200 { "bsfS", { Gv
, Ev
} },
1202 { "movs{bR|x|bR|x}", { Gv
, Eb
} },
1203 { "movs{wR|x|wR|x}", { Gv
, Ew
} }, /* yes, there really is movsww ! */
1205 { "xaddB", { Eb
, Gb
} },
1206 { "xaddS", { Ev
, Gv
} },
1208 { "movntiS", { Ev
, Gv
} },
1209 { "pinsrw", { MX
, Edqw
, Ib
} },
1210 { "pextrw", { Gdq
, MS
, Ib
} },
1211 { "shufpX", { XM
, EXx
, Ib
} },
1214 { "bswap", { RMeAX
} },
1215 { "bswap", { RMeCX
} },
1216 { "bswap", { RMeDX
} },
1217 { "bswap", { RMeBX
} },
1218 { "bswap", { RMeSP
} },
1219 { "bswap", { RMeBP
} },
1220 { "bswap", { RMeSI
} },
1221 { "bswap", { RMeDI
} },
1224 { "psrlw", { MX
, EM
} },
1225 { "psrld", { MX
, EM
} },
1226 { "psrlq", { MX
, EM
} },
1227 { "paddq", { MX
, EM
} },
1228 { "pmullw", { MX
, EM
} },
1230 { "pmovmskb", { Gdq
, MS
} },
1232 { "psubusb", { MX
, EM
} },
1233 { "psubusw", { MX
, EM
} },
1234 { "pminub", { MX
, EM
} },
1235 { "pand", { MX
, EM
} },
1236 { "paddusb", { MX
, EM
} },
1237 { "paddusw", { MX
, EM
} },
1238 { "pmaxub", { MX
, EM
} },
1239 { "pandn", { MX
, EM
} },
1241 { "pavgb", { MX
, EM
} },
1242 { "psraw", { MX
, EM
} },
1243 { "psrad", { MX
, EM
} },
1244 { "pavgw", { MX
, EM
} },
1245 { "pmulhuw", { MX
, EM
} },
1246 { "pmulhw", { MX
, EM
} },
1250 { "psubsb", { MX
, EM
} },
1251 { "psubsw", { MX
, EM
} },
1252 { "pminsw", { MX
, EM
} },
1253 { "por", { MX
, EM
} },
1254 { "paddsb", { MX
, EM
} },
1255 { "paddsw", { MX
, EM
} },
1256 { "pmaxsw", { MX
, EM
} },
1257 { "pxor", { MX
, EM
} },
1260 { "psllw", { MX
, EM
} },
1261 { "pslld", { MX
, EM
} },
1262 { "psllq", { MX
, EM
} },
1263 { "pmuludq", { MX
, EM
} },
1264 { "pmaddwd", { MX
, EM
} },
1265 { "psadbw", { MX
, EM
} },
1268 { "psubb", { MX
, EM
} },
1269 { "psubw", { MX
, EM
} },
1270 { "psubd", { MX
, EM
} },
1271 { "psubq", { MX
, EM
} },
1272 { "paddb", { MX
, EM
} },
1273 { "paddw", { MX
, EM
} },
1274 { "paddd", { MX
, EM
} },
1275 { "(bad)", { XX
} },
1278 static const unsigned char onebyte_has_modrm
[256] = {
1279 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1280 /* ------------------------------- */
1281 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1282 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1283 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1284 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1285 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1286 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1287 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1288 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1289 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1290 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1291 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1292 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1293 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1294 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1295 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1296 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1297 /* ------------------------------- */
1298 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1301 static const unsigned char twobyte_has_modrm
[256] = {
1302 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1303 /* ------------------------------- */
1304 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1305 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */
1306 /* 20 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 2f */
1307 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1308 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1309 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1310 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1311 /* 70 */ 1,1,1,1,1,1,1,0,1,1,1,1,1,1,1,1, /* 7f */
1312 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1313 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1314 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1315 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1316 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1317 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1318 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1319 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1320 /* ------------------------------- */
1321 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1324 static char obuf
[100];
1326 static char scratchbuf
[100];
1327 static unsigned char *start_codep
;
1328 static unsigned char *insn_codep
;
1329 static unsigned char *codep
;
1330 static const char *lock_prefix
;
1331 static const char *data_prefix
;
1332 static const char *addr_prefix
;
1333 static const char *repz_prefix
;
1334 static const char *repnz_prefix
;
1335 static disassemble_info
*the_info
;
1343 static unsigned char need_modrm
;
1345 /* If we are accessing mod/rm/reg without need_modrm set, then the
1346 values are stale. Hitting this abort likely indicates that you
1347 need to update onebyte_has_modrm or twobyte_has_modrm. */
1348 #define MODRM_CHECK if (!need_modrm) abort ()
1350 static const char **names64
;
1351 static const char **names32
;
1352 static const char **names16
;
1353 static const char **names8
;
1354 static const char **names8rex
;
1355 static const char **names_seg
;
1356 static const char **index16
;
1358 static const char *intel_names64
[] = {
1359 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1360 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1362 static const char *intel_names32
[] = {
1363 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1364 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1366 static const char *intel_names16
[] = {
1367 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1368 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1370 static const char *intel_names8
[] = {
1371 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1373 static const char *intel_names8rex
[] = {
1374 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1375 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1377 static const char *intel_names_seg
[] = {
1378 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1380 static const char *intel_index16
[] = {
1381 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1384 static const char *att_names64
[] = {
1385 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1386 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1388 static const char *att_names32
[] = {
1389 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1390 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1392 static const char *att_names16
[] = {
1393 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1394 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1396 static const char *att_names8
[] = {
1397 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1399 static const char *att_names8rex
[] = {
1400 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1401 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1403 static const char *att_names_seg
[] = {
1404 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1406 static const char *att_index16
[] = {
1407 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1410 static const struct dis386 grps
[][8] = {
1413 { "popU", { stackEv
} },
1414 { "(bad)", { XX
} },
1415 { "(bad)", { XX
} },
1416 { "(bad)", { XX
} },
1417 { "(bad)", { XX
} },
1418 { "(bad)", { XX
} },
1419 { "(bad)", { XX
} },
1420 { "(bad)", { XX
} },
1424 { "addA", { Eb
, Ib
} },
1425 { "orA", { Eb
, Ib
} },
1426 { "adcA", { Eb
, Ib
} },
1427 { "sbbA", { Eb
, Ib
} },
1428 { "andA", { Eb
, Ib
} },
1429 { "subA", { Eb
, Ib
} },
1430 { "xorA", { Eb
, Ib
} },
1431 { "cmpA", { Eb
, Ib
} },
1435 { "addQ", { Ev
, Iv
} },
1436 { "orQ", { Ev
, Iv
} },
1437 { "adcQ", { Ev
, Iv
} },
1438 { "sbbQ", { Ev
, Iv
} },
1439 { "andQ", { Ev
, Iv
} },
1440 { "subQ", { Ev
, Iv
} },
1441 { "xorQ", { Ev
, Iv
} },
1442 { "cmpQ", { Ev
, Iv
} },
1446 { "addQ", { Ev
, sIb
} },
1447 { "orQ", { Ev
, sIb
} },
1448 { "adcQ", { Ev
, sIb
} },
1449 { "sbbQ", { Ev
, sIb
} },
1450 { "andQ", { Ev
, sIb
} },
1451 { "subQ", { Ev
, sIb
} },
1452 { "xorQ", { Ev
, sIb
} },
1453 { "cmpQ", { Ev
, sIb
} },
1457 { "rolA", { Eb
, Ib
} },
1458 { "rorA", { Eb
, Ib
} },
1459 { "rclA", { Eb
, Ib
} },
1460 { "rcrA", { Eb
, Ib
} },
1461 { "shlA", { Eb
, Ib
} },
1462 { "shrA", { Eb
, Ib
} },
1463 { "(bad)", { XX
} },
1464 { "sarA", { Eb
, Ib
} },
1468 { "rolQ", { Ev
, Ib
} },
1469 { "rorQ", { Ev
, Ib
} },
1470 { "rclQ", { Ev
, Ib
} },
1471 { "rcrQ", { Ev
, Ib
} },
1472 { "shlQ", { Ev
, Ib
} },
1473 { "shrQ", { Ev
, Ib
} },
1474 { "(bad)", { XX
} },
1475 { "sarQ", { Ev
, Ib
} },
1479 { "rolA", { Eb
, I1
} },
1480 { "rorA", { Eb
, I1
} },
1481 { "rclA", { Eb
, I1
} },
1482 { "rcrA", { Eb
, I1
} },
1483 { "shlA", { Eb
, I1
} },
1484 { "shrA", { Eb
, I1
} },
1485 { "(bad)", { XX
} },
1486 { "sarA", { Eb
, I1
} },
1490 { "rolQ", { Ev
, I1
} },
1491 { "rorQ", { Ev
, I1
} },
1492 { "rclQ", { Ev
, I1
} },
1493 { "rcrQ", { Ev
, I1
} },
1494 { "shlQ", { Ev
, I1
} },
1495 { "shrQ", { Ev
, I1
} },
1496 { "(bad)", { XX
} },
1497 { "sarQ", { Ev
, I1
} },
1501 { "rolA", { Eb
, CL
} },
1502 { "rorA", { Eb
, CL
} },
1503 { "rclA", { Eb
, CL
} },
1504 { "rcrA", { Eb
, CL
} },
1505 { "shlA", { Eb
, CL
} },
1506 { "shrA", { Eb
, CL
} },
1507 { "(bad)", { XX
} },
1508 { "sarA", { Eb
, CL
} },
1512 { "rolQ", { Ev
, CL
} },
1513 { "rorQ", { Ev
, CL
} },
1514 { "rclQ", { Ev
, CL
} },
1515 { "rcrQ", { Ev
, CL
} },
1516 { "shlQ", { Ev
, CL
} },
1517 { "shrQ", { Ev
, CL
} },
1518 { "(bad)", { XX
} },
1519 { "sarQ", { Ev
, CL
} },
1523 { "testA", { Eb
, Ib
} },
1524 { "(bad)", { Eb
} },
1527 { "mulA", { Eb
} }, /* Don't print the implicit %al register, */
1528 { "imulA", { Eb
} }, /* to distinguish these opcodes from other */
1529 { "divA", { Eb
} }, /* mul/imul opcodes. Do the same for div */
1530 { "idivA", { Eb
} }, /* and idiv for consistency. */
1534 { "testQ", { Ev
, Iv
} },
1535 { "(bad)", { XX
} },
1538 { "mulQ", { Ev
} }, /* Don't print the implicit register. */
1539 { "imulQ", { Ev
} },
1541 { "idivQ", { Ev
} },
1547 { "(bad)", { XX
} },
1548 { "(bad)", { XX
} },
1549 { "(bad)", { XX
} },
1550 { "(bad)", { XX
} },
1551 { "(bad)", { XX
} },
1552 { "(bad)", { XX
} },
1558 { "callT", { indirEv
} },
1559 { "JcallT", { indirEp
} },
1560 { "jmpT", { indirEv
} },
1561 { "JjmpT", { indirEp
} },
1562 { "pushU", { stackEv
} },
1563 { "(bad)", { XX
} },
1567 { "sldtD", { Sv
} },
1573 { "(bad)", { XX
} },
1574 { "(bad)", { XX
} },
1582 { "smswD", { Sv
} },
1583 { "(bad)", { XX
} },
1589 { "(bad)", { XX
} },
1590 { "(bad)", { XX
} },
1591 { "(bad)", { XX
} },
1592 { "(bad)", { XX
} },
1593 { "btQ", { Ev
, Ib
} },
1594 { "btsQ", { Ev
, Ib
} },
1595 { "btrQ", { Ev
, Ib
} },
1596 { "btcQ", { Ev
, Ib
} },
1600 { "(bad)", { XX
} },
1601 { "cmpxchg8b", { { CMPXCHG8B_Fixup
, q_mode
} } },
1602 { "(bad)", { XX
} },
1603 { "(bad)", { XX
} },
1604 { "(bad)", { XX
} },
1605 { "(bad)", { XX
} },
1611 { "movA", { Eb
, Ib
} },
1612 { "(bad)", { XX
} },
1613 { "(bad)", { XX
} },
1614 { "(bad)", { XX
} },
1615 { "(bad)", { XX
} },
1616 { "(bad)", { XX
} },
1617 { "(bad)", { XX
} },
1618 { "(bad)", { XX
} },
1622 { "movQ", { Ev
, Iv
} },
1623 { "(bad)", { XX
} },
1624 { "(bad)", { XX
} },
1625 { "(bad)", { XX
} },
1626 { "(bad)", { XX
} },
1627 { "(bad)", { XX
} },
1628 { "(bad)", { XX
} },
1629 { "(bad)", { XX
} },
1633 { "(bad)", { XX
} },
1634 { "(bad)", { XX
} },
1636 { "(bad)", { XX
} },
1638 { "(bad)", { XX
} },
1640 { "(bad)", { XX
} },
1644 { "(bad)", { XX
} },
1645 { "(bad)", { XX
} },
1647 { "(bad)", { XX
} },
1649 { "(bad)", { XX
} },
1651 { "(bad)", { XX
} },
1655 { "(bad)", { XX
} },
1656 { "(bad)", { XX
} },
1659 { "(bad)", { XX
} },
1660 { "(bad)", { XX
} },
1670 { "(bad)", { XX
} },
1681 { "(bad)", { XX
} },
1682 { "(bad)", { XX
} },
1683 { "(bad)", { XX
} },
1684 { "(bad)", { XX
} },
1688 { "prefetch", { Eb
} },
1689 { "prefetchw", { Eb
} },
1690 { "(bad)", { XX
} },
1691 { "(bad)", { XX
} },
1692 { "(bad)", { XX
} },
1693 { "(bad)", { XX
} },
1694 { "(bad)", { XX
} },
1695 { "(bad)", { XX
} },
1699 { "xstore-rng", { { OP_0f07
, 0 } } },
1700 { "xcrypt-ecb", { { OP_0f07
, 0 } } },
1701 { "xcrypt-cbc", { { OP_0f07
, 0 } } },
1702 { "xcrypt-ctr", { { OP_0f07
, 0 } } },
1703 { "xcrypt-cfb", { { OP_0f07
, 0 } } },
1704 { "xcrypt-ofb", { { OP_0f07
, 0 } } },
1705 { "(bad)", { { OP_0f07
, 0 } } },
1706 { "(bad)", { { OP_0f07
, 0 } } },
1710 { "montmul", { { OP_0f07
, 0 } } },
1711 { "xsha1", { { OP_0f07
, 0 } } },
1712 { "xsha256", { { OP_0f07
, 0 } } },
1713 { "(bad)", { { OP_0f07
, 0 } } },
1714 { "(bad)", { { OP_0f07
, 0 } } },
1715 { "(bad)", { { OP_0f07
, 0 } } },
1716 { "(bad)", { { OP_0f07
, 0 } } },
1717 { "(bad)", { { OP_0f07
, 0 } } },
1721 static const struct dis386 prefix_user_table
[][4] = {
1724 { "addps", { XM
, EXx
} },
1725 { "addss", { XM
, EXd
} },
1726 { "addpd", { XM
, EXx
} },
1727 { "addsd", { XM
, EXq
} },
1731 { "", { XM
, EXx
, OPSIMD
} }, /* See OP_SIMD_SUFFIX. */
1732 { "", { XM
, EXd
, OPSIMD
} },
1733 { "", { XM
, EXx
, OPSIMD
} },
1734 { "", { XM
, EXq
, OPSIMD
} },
1738 { "cvtpi2ps", { XM
, EMCq
} },
1739 { "cvtsi2ssY", { XM
, Ev
} },
1740 { "cvtpi2pd", { XM
, EMCq
} },
1741 { "cvtsi2sdY", { XM
, Ev
} },
1745 { "cvtps2pi", { MXC
, EXq
} },
1746 { "cvtss2siY", { Gv
, EXd
} },
1747 { "cvtpd2pi", { MXC
, EXx
} },
1748 { "cvtsd2siY", { Gv
, EXq
} },
1752 { "cvttps2pi", { MXC
, EXq
} },
1753 { "cvttss2siY", { Gv
, EXd
} },
1754 { "cvttpd2pi", { MXC
, EXx
} },
1755 { "cvttsd2siY", { Gv
, EXq
} },
1759 { "divps", { XM
, EXx
} },
1760 { "divss", { XM
, EXd
} },
1761 { "divpd", { XM
, EXx
} },
1762 { "divsd", { XM
, EXq
} },
1766 { "maxps", { XM
, EXx
} },
1767 { "maxss", { XM
, EXd
} },
1768 { "maxpd", { XM
, EXx
} },
1769 { "maxsd", { XM
, EXq
} },
1773 { "minps", { XM
, EXx
} },
1774 { "minss", { XM
, EXd
} },
1775 { "minpd", { XM
, EXx
} },
1776 { "minsd", { XM
, EXq
} },
1780 { "movups", { XM
, EXx
} },
1781 { "movss", { XM
, EXd
} },
1782 { "movupd", { XM
, EXx
} },
1783 { "movsd", { XM
, EXq
} },
1787 { "movups", { EXx
, XM
} },
1788 { "movss", { EXd
, XM
} },
1789 { "movupd", { EXx
, XM
} },
1790 { "movsd", { EXq
, XM
} },
1794 { "mulps", { XM
, EXx
} },
1795 { "mulss", { XM
, EXd
} },
1796 { "mulpd", { XM
, EXx
} },
1797 { "mulsd", { XM
, EXq
} },
1801 { "rcpps", { XM
, EXx
} },
1802 { "rcpss", { XM
, EXd
} },
1803 { "(bad)", { XM
, EXx
} },
1804 { "(bad)", { XM
, EXx
} },
1808 { "rsqrtps",{ XM
, EXx
} },
1809 { "rsqrtss",{ XM
, EXd
} },
1810 { "(bad)", { XM
, EXx
} },
1811 { "(bad)", { XM
, EXx
} },
1815 { "sqrtps", { XM
, EXx
} },
1816 { "sqrtss", { XM
, EXd
} },
1817 { "sqrtpd", { XM
, EXx
} },
1818 { "sqrtsd", { XM
, EXq
} },
1822 { "subps", { XM
, EXx
} },
1823 { "subss", { XM
, EXd
} },
1824 { "subpd", { XM
, EXx
} },
1825 { "subsd", { XM
, EXq
} },
1829 { "(bad)", { XM
, EXx
} },
1830 { "cvtdq2pd", { XM
, EXq
} },
1831 { "cvttpd2dq", { XM
, EXx
} },
1832 { "cvtpd2dq", { XM
, EXx
} },
1836 { "cvtdq2ps", { XM
, EXx
} },
1837 { "cvttps2dq", { XM
, EXx
} },
1838 { "cvtps2dq", { XM
, EXx
} },
1839 { "(bad)", { XM
, EXx
} },
1843 { "cvtps2pd", { XM
, EXq
} },
1844 { "cvtss2sd", { XM
, EXd
} },
1845 { "cvtpd2ps", { XM
, EXx
} },
1846 { "cvtsd2ss", { XM
, EXq
} },
1850 { "maskmovq", { MX
, MS
} },
1851 { "(bad)", { XM
, EXx
} },
1852 { "maskmovdqu", { XM
, XS
} },
1853 { "(bad)", { XM
, EXx
} },
1857 { "movq", { MX
, EM
} },
1858 { "movdqu", { XM
, EXx
} },
1859 { "movdqa", { XM
, EXx
} },
1860 { "(bad)", { XM
, EXx
} },
1864 { "movq", { EM
, MX
} },
1865 { "movdqu", { EXx
, XM
} },
1866 { "movdqa", { EXx
, XM
} },
1867 { "(bad)", { EXx
, XM
} },
1871 { "(bad)", { EXx
, XM
} },
1872 { "movq2dq",{ XM
, MS
} },
1873 { "movq", { EXq
, XM
} },
1874 { "movdq2q",{ MX
, XS
} },
1878 { "pshufw", { MX
, EM
, Ib
} },
1879 { "pshufhw",{ XM
, EXx
, Ib
} },
1880 { "pshufd", { XM
, EXx
, Ib
} },
1881 { "pshuflw",{ XM
, EXx
, Ib
} },
1885 { "movK", { Edq
, MX
} },
1886 { "movq", { XM
, EXq
} },
1887 { "movK", { Edq
, XM
} },
1888 { "(bad)", { Ed
, XM
} },
1892 { "(bad)", { MX
, EXx
} },
1893 { "(bad)", { XM
, EXx
} },
1894 { "punpckhqdq", { XM
, EXx
} },
1895 { "(bad)", { XM
, EXx
} },
1899 { "movntq", { EM
, MX
} },
1900 { "(bad)", { EM
, XM
} },
1901 { "movntdq",{ EM
, XM
} },
1902 { "(bad)", { EM
, XM
} },
1906 { "(bad)", { MX
, EXx
} },
1907 { "(bad)", { XM
, EXx
} },
1908 { "punpcklqdq", { XM
, EXx
} },
1909 { "(bad)", { XM
, EXx
} },
1913 { "(bad)", { MX
, EXx
} },
1914 { "(bad)", { XM
, EXx
} },
1915 { "addsubpd", { XM
, EXx
} },
1916 { "addsubps", { XM
, EXx
} },
1920 { "(bad)", { MX
, EXx
} },
1921 { "(bad)", { XM
, EXx
} },
1922 { "haddpd", { XM
, EXx
} },
1923 { "haddps", { XM
, EXx
} },
1927 { "(bad)", { MX
, EXx
} },
1928 { "(bad)", { XM
, EXx
} },
1929 { "hsubpd", { XM
, EXx
} },
1930 { "hsubps", { XM
, EXx
} },
1935 { "movsldup", { XM
, EXx
} },
1936 { "movlpd", { XM
, EXq
} },
1937 { "movddup", { XM
, EXq
} },
1942 { "movshdup", { XM
, EXx
} },
1943 { "movhpd", { XM
, EXq
} },
1944 { "(bad)", { XM
, EXq
} },
1948 { "(bad)", { XM
, EXx
} },
1949 { "(bad)", { XM
, EXx
} },
1950 { "(bad)", { XM
, EXx
} },
1955 {"movntps", { Ev
, XM
} },
1956 {"movntss", { Ed
, XM
} },
1957 {"movntpd", { Ev
, XM
} },
1958 {"movntsd", { Eq
, XM
} },
1963 {"vmread", { Em
, Gm
} },
1965 {"extrq", { XS
, Ib
, Ib
} },
1966 {"insertq", { XM
, XS
, Ib
, Ib
} },
1971 {"vmwrite", { Gm
, Em
} },
1973 {"extrq", { XM
, XS
} },
1974 {"insertq", { XM
, XS
} },
1979 { "bsrS", { Gv
, Ev
} },
1980 { "lzcntS", { Gv
, Ev
} },
1981 { "bsrS", { Gv
, Ev
} },
1982 { "(bad)", { XX
} },
1987 { "(bad)", { XX
} },
1988 { "popcntS", { Gv
, Ev
} },
1989 { "(bad)", { XX
} },
1990 { "(bad)", { XX
} },
1995 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
1996 { "pause", { XX
} },
1997 { "xchgS", { { NOP_Fixup1
, eAX_reg
}, { NOP_Fixup2
, eAX_reg
} } },
1998 { "(bad)", { XX
} },
2003 { "(bad)", { XX
} },
2004 { "(bad)", { XX
} },
2005 { "pblendvb", {XM
, EXx
, XMM0
} },
2006 { "(bad)", { XX
} },
2011 { "(bad)", { XX
} },
2012 { "(bad)", { XX
} },
2013 { "blendvps", {XM
, EXx
, XMM0
} },
2014 { "(bad)", { XX
} },
2019 { "(bad)", { XX
} },
2020 { "(bad)", { XX
} },
2021 { "blendvpd", { XM
, EXx
, XMM0
} },
2022 { "(bad)", { XX
} },
2027 { "(bad)", { XX
} },
2028 { "(bad)", { XX
} },
2029 { "ptest", { XM
, EXx
} },
2030 { "(bad)", { XX
} },
2035 { "(bad)", { XX
} },
2036 { "(bad)", { XX
} },
2037 { "pmovsxbw", { XM
, EXq
} },
2038 { "(bad)", { XX
} },
2043 { "(bad)", { XX
} },
2044 { "(bad)", { XX
} },
2045 { "pmovsxbd", { XM
, EXd
} },
2046 { "(bad)", { XX
} },
2051 { "(bad)", { XX
} },
2052 { "(bad)", { XX
} },
2053 { "pmovsxbq", { XM
, EXw
} },
2054 { "(bad)", { XX
} },
2059 { "(bad)", { XX
} },
2060 { "(bad)", { XX
} },
2061 { "pmovsxwd", { XM
, EXq
} },
2062 { "(bad)", { XX
} },
2067 { "(bad)", { XX
} },
2068 { "(bad)", { XX
} },
2069 { "pmovsxwq", { XM
, EXd
} },
2070 { "(bad)", { XX
} },
2075 { "(bad)", { XX
} },
2076 { "(bad)", { XX
} },
2077 { "pmovsxdq", { XM
, EXq
} },
2078 { "(bad)", { XX
} },
2083 { "(bad)", { XX
} },
2084 { "(bad)", { XX
} },
2085 { "pmuldq", { XM
, EXx
} },
2086 { "(bad)", { XX
} },
2091 { "(bad)", { XX
} },
2092 { "(bad)", { XX
} },
2093 { "pcmpeqq", { XM
, EXx
} },
2094 { "(bad)", { XX
} },
2099 { "(bad)", { XX
} },
2100 { "(bad)", { XX
} },
2101 { "movntdqa", { XM
, EM
} },
2102 { "(bad)", { XX
} },
2107 { "(bad)", { XX
} },
2108 { "(bad)", { XX
} },
2109 { "packusdw", { XM
, EXx
} },
2110 { "(bad)", { XX
} },
2115 { "(bad)", { XX
} },
2116 { "(bad)", { XX
} },
2117 { "pmovzxbw", { XM
, EXq
} },
2118 { "(bad)", { XX
} },
2123 { "(bad)", { XX
} },
2124 { "(bad)", { XX
} },
2125 { "pmovzxbd", { XM
, EXd
} },
2126 { "(bad)", { XX
} },
2131 { "(bad)", { XX
} },
2132 { "(bad)", { XX
} },
2133 { "pmovzxbq", { XM
, EXw
} },
2134 { "(bad)", { XX
} },
2139 { "(bad)", { XX
} },
2140 { "(bad)", { XX
} },
2141 { "pmovzxwd", { XM
, EXq
} },
2142 { "(bad)", { XX
} },
2147 { "(bad)", { XX
} },
2148 { "(bad)", { XX
} },
2149 { "pmovzxwq", { XM
, EXd
} },
2150 { "(bad)", { XX
} },
2155 { "(bad)", { XX
} },
2156 { "(bad)", { XX
} },
2157 { "pmovzxdq", { XM
, EXq
} },
2158 { "(bad)", { XX
} },
2163 { "(bad)", { XX
} },
2164 { "(bad)", { XX
} },
2165 { "pminsb", { XM
, EXx
} },
2166 { "(bad)", { XX
} },
2171 { "(bad)", { XX
} },
2172 { "(bad)", { XX
} },
2173 { "pminsd", { XM
, EXx
} },
2174 { "(bad)", { XX
} },
2179 { "(bad)", { XX
} },
2180 { "(bad)", { XX
} },
2181 { "pminuw", { XM
, EXx
} },
2182 { "(bad)", { XX
} },
2187 { "(bad)", { XX
} },
2188 { "(bad)", { XX
} },
2189 { "pminud", { XM
, EXx
} },
2190 { "(bad)", { XX
} },
2195 { "(bad)", { XX
} },
2196 { "(bad)", { XX
} },
2197 { "pmaxsb", { XM
, EXx
} },
2198 { "(bad)", { XX
} },
2203 { "(bad)", { XX
} },
2204 { "(bad)", { XX
} },
2205 { "pmaxsd", { XM
, EXx
} },
2206 { "(bad)", { XX
} },
2211 { "(bad)", { XX
} },
2212 { "(bad)", { XX
} },
2213 { "pmaxuw", { XM
, EXx
} },
2214 { "(bad)", { XX
} },
2219 { "(bad)", { XX
} },
2220 { "(bad)", { XX
} },
2221 { "pmaxud", { XM
, EXx
} },
2222 { "(bad)", { XX
} },
2227 { "(bad)", { XX
} },
2228 { "(bad)", { XX
} },
2229 { "pmulld", { XM
, EXx
} },
2230 { "(bad)", { XX
} },
2235 { "(bad)", { XX
} },
2236 { "(bad)", { XX
} },
2237 { "phminposuw", { XM
, EXx
} },
2238 { "(bad)", { XX
} },
2243 { "(bad)", { XX
} },
2244 { "(bad)", { XX
} },
2245 { "roundps", { XM
, EXx
, Ib
} },
2246 { "(bad)", { XX
} },
2251 { "(bad)", { XX
} },
2252 { "(bad)", { XX
} },
2253 { "roundpd", { XM
, EXx
, Ib
} },
2254 { "(bad)", { XX
} },
2259 { "(bad)", { XX
} },
2260 { "(bad)", { XX
} },
2261 { "roundss", { XM
, EXd
, Ib
} },
2262 { "(bad)", { XX
} },
2267 { "(bad)", { XX
} },
2268 { "(bad)", { XX
} },
2269 { "roundsd", { XM
, EXq
, Ib
} },
2270 { "(bad)", { XX
} },
2275 { "(bad)", { XX
} },
2276 { "(bad)", { XX
} },
2277 { "blendps", { XM
, EXx
, Ib
} },
2278 { "(bad)", { XX
} },
2283 { "(bad)", { XX
} },
2284 { "(bad)", { XX
} },
2285 { "blendpd", { XM
, EXx
, Ib
} },
2286 { "(bad)", { XX
} },
2291 { "(bad)", { XX
} },
2292 { "(bad)", { XX
} },
2293 { "pblendw", { XM
, EXx
, Ib
} },
2294 { "(bad)", { XX
} },
2299 { "(bad)", { XX
} },
2300 { "(bad)", { XX
} },
2301 { "pextrb", { Edqb
, XM
, Ib
} },
2302 { "(bad)", { XX
} },
2307 { "(bad)", { XX
} },
2308 { "(bad)", { XX
} },
2309 { "pextrw", { Edqw
, XM
, Ib
} },
2310 { "(bad)", { XX
} },
2315 { "(bad)", { XX
} },
2316 { "(bad)", { XX
} },
2317 { "pextrK", { Edq
, XM
, Ib
} },
2318 { "(bad)", { XX
} },
2323 { "(bad)", { XX
} },
2324 { "(bad)", { XX
} },
2325 { "extractps", { Edqd
, XM
, Ib
} },
2326 { "(bad)", { XX
} },
2331 { "(bad)", { XX
} },
2332 { "(bad)", { XX
} },
2333 { "pinsrb", { XM
, Edqb
, Ib
} },
2334 { "(bad)", { XX
} },
2339 { "(bad)", { XX
} },
2340 { "(bad)", { XX
} },
2341 { "insertps", { XM
, EXd
, Ib
} },
2342 { "(bad)", { XX
} },
2347 { "(bad)", { XX
} },
2348 { "(bad)", { XX
} },
2349 { "pinsrK", { XM
, Edq
, Ib
} },
2350 { "(bad)", { XX
} },
2355 { "(bad)", { XX
} },
2356 { "(bad)", { XX
} },
2357 { "dpps", { XM
, EXx
, Ib
} },
2358 { "(bad)", { XX
} },
2363 { "(bad)", { XX
} },
2364 { "(bad)", { XX
} },
2365 { "dppd", { XM
, EXx
, Ib
} },
2366 { "(bad)", { XX
} },
2371 { "(bad)", { XX
} },
2372 { "(bad)", { XX
} },
2373 { "mpsadbw", { XM
, EXx
, Ib
} },
2374 { "(bad)", { XX
} },
2379 { "(bad)", { XX
} },
2380 { "(bad)", { XX
} },
2381 { "pcmpgtq", { XM
, EXx
} },
2382 { "(bad)", { XX
} },
2387 { "(bad)", { XX
} },
2388 { "(bad)", { XX
} },
2389 { "(bad)", { XX
} },
2390 { "crc32", { Gdq
, { CRC32_Fixup
, b_mode
} } },
2395 { "(bad)", { XX
} },
2396 { "(bad)", { XX
} },
2397 { "(bad)", { XX
} },
2398 { "crc32", { Gdq
, { CRC32_Fixup
, v_mode
} } },
2403 { "(bad)", { XX
} },
2404 { "(bad)", { XX
} },
2405 { "pcmpestrm", { XM
, EXx
, Ib
} },
2406 { "(bad)", { XX
} },
2411 { "(bad)", { XX
} },
2412 { "(bad)", { XX
} },
2413 { "pcmpestri", { XM
, EXx
, Ib
} },
2414 { "(bad)", { XX
} },
2419 { "(bad)", { XX
} },
2420 { "(bad)", { XX
} },
2421 { "pcmpistrm", { XM
, EXx
, Ib
} },
2422 { "(bad)", { XX
} },
2427 { "(bad)", { XX
} },
2428 { "(bad)", { XX
} },
2429 { "pcmpistri", { XM
, EXx
, Ib
} },
2430 { "(bad)", { XX
} },
2435 { "ucomiss",{ XM
, EXd
} },
2436 { "(bad)", { XX
} },
2437 { "ucomisd",{ XM
, EXq
} },
2438 { "(bad)", { XX
} },
2443 { "comiss", { XM
, EXd
} },
2444 { "(bad)", { XX
} },
2445 { "comisd", { XM
, EXq
} },
2446 { "(bad)", { XX
} },
2451 { "punpcklbw",{ MX
, EMd
} },
2452 { "(bad)", { XX
} },
2453 { "punpcklbw",{ MX
, EMx
} },
2454 { "(bad)", { XX
} },
2459 { "punpcklwd",{ MX
, EMd
} },
2460 { "(bad)", { XX
} },
2461 { "punpcklwd",{ MX
, EMx
} },
2462 { "(bad)", { XX
} },
2467 { "punpckldq",{ MX
, EMd
} },
2468 { "(bad)", { XX
} },
2469 { "punpckldq",{ MX
, EMx
} },
2470 { "(bad)", { XX
} },
2475 { "vmptrld",{ Mq
} },
2476 { "vmxon", { Mq
} },
2477 { "vmclear",{ Mq
} },
2478 { "(bad)", { XX
} },
2483 { "(bad)", { XX
} },
2484 { "(bad)", { XX
} },
2485 { "psrldq", { MS
, Ib
} },
2486 { "(bad)", { XX
} },
2491 { "(bad)", { XX
} },
2492 { "(bad)", { XX
} },
2493 { "pslldq", { MS
, Ib
} },
2494 { "(bad)", { XX
} },
2498 static const struct dis386 x86_64_table
[][2] = {
2500 { "pusha{P|}", { XX
} },
2501 { "(bad)", { XX
} },
2504 { "popa{P|}", { XX
} },
2505 { "(bad)", { XX
} },
2509 { "(bad)", { XX
} },
2512 { "arpl", { Ew
, Gw
} },
2513 { "movs{||lq|xd}", { Gv
, Ed
} },
2517 static const struct dis386 three_byte_table
[][256] = {
2521 { "pshufb", { MX
, EM
} },
2522 { "phaddw", { MX
, EM
} },
2523 { "phaddd", { MX
, EM
} },
2524 { "phaddsw", { MX
, EM
} },
2525 { "pmaddubsw", { MX
, EM
} },
2526 { "phsubw", { MX
, EM
} },
2527 { "phsubd", { MX
, EM
} },
2528 { "phsubsw", { MX
, EM
} },
2530 { "psignb", { MX
, EM
} },
2531 { "psignw", { MX
, EM
} },
2532 { "psignd", { MX
, EM
} },
2533 { "pmulhrsw", { MX
, EM
} },
2534 { "(bad)", { XX
} },
2535 { "(bad)", { XX
} },
2536 { "(bad)", { XX
} },
2537 { "(bad)", { XX
} },
2540 { "(bad)", { XX
} },
2541 { "(bad)", { XX
} },
2542 { "(bad)", { XX
} },
2545 { "(bad)", { XX
} },
2548 { "(bad)", { XX
} },
2549 { "(bad)", { XX
} },
2550 { "(bad)", { XX
} },
2551 { "(bad)", { XX
} },
2552 { "pabsb", { MX
, EM
} },
2553 { "pabsw", { MX
, EM
} },
2554 { "pabsd", { MX
, EM
} },
2555 { "(bad)", { XX
} },
2563 { "(bad)", { XX
} },
2564 { "(bad)", { XX
} },
2570 { "(bad)", { XX
} },
2571 { "(bad)", { XX
} },
2572 { "(bad)", { XX
} },
2573 { "(bad)", { XX
} },
2581 { "(bad)", { XX
} },
2595 { "(bad)", { XX
} },
2596 { "(bad)", { XX
} },
2597 { "(bad)", { XX
} },
2598 { "(bad)", { XX
} },
2599 { "(bad)", { XX
} },
2600 { "(bad)", { XX
} },
2602 { "(bad)", { XX
} },
2603 { "(bad)", { XX
} },
2604 { "(bad)", { XX
} },
2605 { "(bad)", { XX
} },
2606 { "(bad)", { XX
} },
2607 { "(bad)", { XX
} },
2608 { "(bad)", { XX
} },
2609 { "(bad)", { XX
} },
2611 { "(bad)", { XX
} },
2612 { "(bad)", { XX
} },
2613 { "(bad)", { XX
} },
2614 { "(bad)", { XX
} },
2615 { "(bad)", { XX
} },
2616 { "(bad)", { XX
} },
2617 { "(bad)", { XX
} },
2618 { "(bad)", { XX
} },
2620 { "(bad)", { XX
} },
2621 { "(bad)", { XX
} },
2622 { "(bad)", { XX
} },
2623 { "(bad)", { XX
} },
2624 { "(bad)", { XX
} },
2625 { "(bad)", { XX
} },
2626 { "(bad)", { XX
} },
2627 { "(bad)", { XX
} },
2629 { "(bad)", { XX
} },
2630 { "(bad)", { XX
} },
2631 { "(bad)", { XX
} },
2632 { "(bad)", { XX
} },
2633 { "(bad)", { XX
} },
2634 { "(bad)", { XX
} },
2635 { "(bad)", { XX
} },
2636 { "(bad)", { XX
} },
2638 { "(bad)", { XX
} },
2639 { "(bad)", { XX
} },
2640 { "(bad)", { XX
} },
2641 { "(bad)", { XX
} },
2642 { "(bad)", { XX
} },
2643 { "(bad)", { XX
} },
2644 { "(bad)", { XX
} },
2645 { "(bad)", { XX
} },
2647 { "(bad)", { XX
} },
2648 { "(bad)", { XX
} },
2649 { "(bad)", { XX
} },
2650 { "(bad)", { XX
} },
2651 { "(bad)", { XX
} },
2652 { "(bad)", { XX
} },
2653 { "(bad)", { XX
} },
2654 { "(bad)", { XX
} },
2656 { "(bad)", { XX
} },
2657 { "(bad)", { XX
} },
2658 { "(bad)", { XX
} },
2659 { "(bad)", { XX
} },
2660 { "(bad)", { XX
} },
2661 { "(bad)", { XX
} },
2662 { "(bad)", { XX
} },
2663 { "(bad)", { XX
} },
2665 { "(bad)", { XX
} },
2666 { "(bad)", { XX
} },
2667 { "(bad)", { XX
} },
2668 { "(bad)", { XX
} },
2669 { "(bad)", { XX
} },
2670 { "(bad)", { XX
} },
2671 { "(bad)", { XX
} },
2672 { "(bad)", { XX
} },
2674 { "(bad)", { XX
} },
2675 { "(bad)", { XX
} },
2676 { "(bad)", { XX
} },
2677 { "(bad)", { XX
} },
2678 { "(bad)", { XX
} },
2679 { "(bad)", { XX
} },
2680 { "(bad)", { XX
} },
2681 { "(bad)", { XX
} },
2683 { "(bad)", { XX
} },
2684 { "(bad)", { XX
} },
2685 { "(bad)", { XX
} },
2686 { "(bad)", { XX
} },
2687 { "(bad)", { XX
} },
2688 { "(bad)", { XX
} },
2689 { "(bad)", { XX
} },
2690 { "(bad)", { XX
} },
2692 { "(bad)", { XX
} },
2693 { "(bad)", { XX
} },
2694 { "(bad)", { XX
} },
2695 { "(bad)", { XX
} },
2696 { "(bad)", { XX
} },
2697 { "(bad)", { XX
} },
2698 { "(bad)", { XX
} },
2699 { "(bad)", { XX
} },
2701 { "(bad)", { XX
} },
2702 { "(bad)", { XX
} },
2703 { "(bad)", { XX
} },
2704 { "(bad)", { XX
} },
2705 { "(bad)", { XX
} },
2706 { "(bad)", { XX
} },
2707 { "(bad)", { XX
} },
2708 { "(bad)", { XX
} },
2710 { "(bad)", { XX
} },
2711 { "(bad)", { XX
} },
2712 { "(bad)", { XX
} },
2713 { "(bad)", { XX
} },
2714 { "(bad)", { XX
} },
2715 { "(bad)", { XX
} },
2716 { "(bad)", { XX
} },
2717 { "(bad)", { XX
} },
2719 { "(bad)", { XX
} },
2720 { "(bad)", { XX
} },
2721 { "(bad)", { XX
} },
2722 { "(bad)", { XX
} },
2723 { "(bad)", { XX
} },
2724 { "(bad)", { XX
} },
2725 { "(bad)", { XX
} },
2726 { "(bad)", { XX
} },
2728 { "(bad)", { XX
} },
2729 { "(bad)", { XX
} },
2730 { "(bad)", { XX
} },
2731 { "(bad)", { XX
} },
2732 { "(bad)", { XX
} },
2733 { "(bad)", { XX
} },
2734 { "(bad)", { XX
} },
2735 { "(bad)", { XX
} },
2737 { "(bad)", { XX
} },
2738 { "(bad)", { XX
} },
2739 { "(bad)", { XX
} },
2740 { "(bad)", { XX
} },
2741 { "(bad)", { XX
} },
2742 { "(bad)", { XX
} },
2743 { "(bad)", { XX
} },
2744 { "(bad)", { XX
} },
2746 { "(bad)", { XX
} },
2747 { "(bad)", { XX
} },
2748 { "(bad)", { XX
} },
2749 { "(bad)", { XX
} },
2750 { "(bad)", { XX
} },
2751 { "(bad)", { XX
} },
2752 { "(bad)", { XX
} },
2753 { "(bad)", { XX
} },
2755 { "(bad)", { XX
} },
2756 { "(bad)", { XX
} },
2757 { "(bad)", { XX
} },
2758 { "(bad)", { XX
} },
2759 { "(bad)", { XX
} },
2760 { "(bad)", { XX
} },
2761 { "(bad)", { XX
} },
2762 { "(bad)", { XX
} },
2764 { "(bad)", { XX
} },
2765 { "(bad)", { XX
} },
2766 { "(bad)", { XX
} },
2767 { "(bad)", { XX
} },
2768 { "(bad)", { XX
} },
2769 { "(bad)", { XX
} },
2770 { "(bad)", { XX
} },
2771 { "(bad)", { XX
} },
2773 { "(bad)", { XX
} },
2774 { "(bad)", { XX
} },
2775 { "(bad)", { XX
} },
2776 { "(bad)", { XX
} },
2777 { "(bad)", { XX
} },
2778 { "(bad)", { XX
} },
2779 { "(bad)", { XX
} },
2780 { "(bad)", { XX
} },
2782 { "(bad)", { XX
} },
2783 { "(bad)", { XX
} },
2784 { "(bad)", { XX
} },
2785 { "(bad)", { XX
} },
2786 { "(bad)", { XX
} },
2787 { "(bad)", { XX
} },
2788 { "(bad)", { XX
} },
2789 { "(bad)", { XX
} },
2793 { "(bad)", { XX
} },
2794 { "(bad)", { XX
} },
2795 { "(bad)", { XX
} },
2796 { "(bad)", { XX
} },
2797 { "(bad)", { XX
} },
2798 { "(bad)", { XX
} },
2800 { "(bad)", { XX
} },
2801 { "(bad)", { XX
} },
2802 { "(bad)", { XX
} },
2803 { "(bad)", { XX
} },
2804 { "(bad)", { XX
} },
2805 { "(bad)", { XX
} },
2806 { "(bad)", { XX
} },
2807 { "(bad)", { XX
} },
2812 { "(bad)", { XX
} },
2813 { "(bad)", { XX
} },
2814 { "(bad)", { XX
} },
2815 { "(bad)", { XX
} },
2816 { "(bad)", { XX
} },
2817 { "(bad)", { XX
} },
2818 { "(bad)", { XX
} },
2819 { "(bad)", { XX
} },
2828 { "palignr", { MX
, EM
, Ib
} },
2830 { "(bad)", { XX
} },
2831 { "(bad)", { XX
} },
2832 { "(bad)", { XX
} },
2833 { "(bad)", { XX
} },
2839 { "(bad)", { XX
} },
2840 { "(bad)", { XX
} },
2841 { "(bad)", { XX
} },
2842 { "(bad)", { XX
} },
2843 { "(bad)", { XX
} },
2844 { "(bad)", { XX
} },
2845 { "(bad)", { XX
} },
2846 { "(bad)", { XX
} },
2851 { "(bad)", { XX
} },
2852 { "(bad)", { XX
} },
2853 { "(bad)", { XX
} },
2854 { "(bad)", { XX
} },
2855 { "(bad)", { XX
} },
2857 { "(bad)", { XX
} },
2858 { "(bad)", { XX
} },
2859 { "(bad)", { XX
} },
2860 { "(bad)", { XX
} },
2861 { "(bad)", { XX
} },
2862 { "(bad)", { XX
} },
2863 { "(bad)", { XX
} },
2864 { "(bad)", { XX
} },
2866 { "(bad)", { XX
} },
2867 { "(bad)", { XX
} },
2868 { "(bad)", { XX
} },
2869 { "(bad)", { XX
} },
2870 { "(bad)", { XX
} },
2871 { "(bad)", { XX
} },
2872 { "(bad)", { XX
} },
2873 { "(bad)", { XX
} },
2875 { "(bad)", { XX
} },
2876 { "(bad)", { XX
} },
2877 { "(bad)", { XX
} },
2878 { "(bad)", { XX
} },
2879 { "(bad)", { XX
} },
2880 { "(bad)", { XX
} },
2881 { "(bad)", { XX
} },
2882 { "(bad)", { XX
} },
2887 { "(bad)", { XX
} },
2888 { "(bad)", { XX
} },
2889 { "(bad)", { XX
} },
2890 { "(bad)", { XX
} },
2891 { "(bad)", { XX
} },
2893 { "(bad)", { XX
} },
2894 { "(bad)", { XX
} },
2895 { "(bad)", { XX
} },
2896 { "(bad)", { XX
} },
2897 { "(bad)", { XX
} },
2898 { "(bad)", { XX
} },
2899 { "(bad)", { XX
} },
2900 { "(bad)", { XX
} },
2902 { "(bad)", { XX
} },
2903 { "(bad)", { XX
} },
2904 { "(bad)", { XX
} },
2905 { "(bad)", { XX
} },
2906 { "(bad)", { XX
} },
2907 { "(bad)", { XX
} },
2908 { "(bad)", { XX
} },
2909 { "(bad)", { XX
} },
2911 { "(bad)", { XX
} },
2912 { "(bad)", { XX
} },
2913 { "(bad)", { XX
} },
2914 { "(bad)", { XX
} },
2915 { "(bad)", { XX
} },
2916 { "(bad)", { XX
} },
2917 { "(bad)", { XX
} },
2918 { "(bad)", { XX
} },
2924 { "(bad)", { XX
} },
2925 { "(bad)", { XX
} },
2926 { "(bad)", { XX
} },
2927 { "(bad)", { XX
} },
2929 { "(bad)", { XX
} },
2930 { "(bad)", { XX
} },
2931 { "(bad)", { XX
} },
2932 { "(bad)", { XX
} },
2933 { "(bad)", { XX
} },
2934 { "(bad)", { XX
} },
2935 { "(bad)", { XX
} },
2936 { "(bad)", { XX
} },
2938 { "(bad)", { XX
} },
2939 { "(bad)", { XX
} },
2940 { "(bad)", { XX
} },
2941 { "(bad)", { XX
} },
2942 { "(bad)", { XX
} },
2943 { "(bad)", { XX
} },
2944 { "(bad)", { XX
} },
2945 { "(bad)", { XX
} },
2947 { "(bad)", { XX
} },
2948 { "(bad)", { XX
} },
2949 { "(bad)", { XX
} },
2950 { "(bad)", { XX
} },
2951 { "(bad)", { XX
} },
2952 { "(bad)", { XX
} },
2953 { "(bad)", { XX
} },
2954 { "(bad)", { XX
} },
2956 { "(bad)", { XX
} },
2957 { "(bad)", { XX
} },
2958 { "(bad)", { XX
} },
2959 { "(bad)", { XX
} },
2960 { "(bad)", { XX
} },
2961 { "(bad)", { XX
} },
2962 { "(bad)", { XX
} },
2963 { "(bad)", { XX
} },
2965 { "(bad)", { XX
} },
2966 { "(bad)", { XX
} },
2967 { "(bad)", { XX
} },
2968 { "(bad)", { XX
} },
2969 { "(bad)", { XX
} },
2970 { "(bad)", { XX
} },
2971 { "(bad)", { XX
} },
2972 { "(bad)", { XX
} },
2974 { "(bad)", { XX
} },
2975 { "(bad)", { XX
} },
2976 { "(bad)", { XX
} },
2977 { "(bad)", { XX
} },
2978 { "(bad)", { XX
} },
2979 { "(bad)", { XX
} },
2980 { "(bad)", { XX
} },
2981 { "(bad)", { XX
} },
2983 { "(bad)", { XX
} },
2984 { "(bad)", { XX
} },
2985 { "(bad)", { XX
} },
2986 { "(bad)", { XX
} },
2987 { "(bad)", { XX
} },
2988 { "(bad)", { XX
} },
2989 { "(bad)", { XX
} },
2990 { "(bad)", { XX
} },
2992 { "(bad)", { XX
} },
2993 { "(bad)", { XX
} },
2994 { "(bad)", { XX
} },
2995 { "(bad)", { XX
} },
2996 { "(bad)", { XX
} },
2997 { "(bad)", { XX
} },
2998 { "(bad)", { XX
} },
2999 { "(bad)", { XX
} },
3001 { "(bad)", { XX
} },
3002 { "(bad)", { XX
} },
3003 { "(bad)", { XX
} },
3004 { "(bad)", { XX
} },
3005 { "(bad)", { XX
} },
3006 { "(bad)", { XX
} },
3007 { "(bad)", { XX
} },
3008 { "(bad)", { XX
} },
3010 { "(bad)", { XX
} },
3011 { "(bad)", { XX
} },
3012 { "(bad)", { XX
} },
3013 { "(bad)", { XX
} },
3014 { "(bad)", { XX
} },
3015 { "(bad)", { XX
} },
3016 { "(bad)", { XX
} },
3017 { "(bad)", { XX
} },
3019 { "(bad)", { XX
} },
3020 { "(bad)", { XX
} },
3021 { "(bad)", { XX
} },
3022 { "(bad)", { XX
} },
3023 { "(bad)", { XX
} },
3024 { "(bad)", { XX
} },
3025 { "(bad)", { XX
} },
3026 { "(bad)", { XX
} },
3028 { "(bad)", { XX
} },
3029 { "(bad)", { XX
} },
3030 { "(bad)", { XX
} },
3031 { "(bad)", { XX
} },
3032 { "(bad)", { XX
} },
3033 { "(bad)", { XX
} },
3034 { "(bad)", { XX
} },
3035 { "(bad)", { XX
} },
3037 { "(bad)", { XX
} },
3038 { "(bad)", { XX
} },
3039 { "(bad)", { XX
} },
3040 { "(bad)", { XX
} },
3041 { "(bad)", { XX
} },
3042 { "(bad)", { XX
} },
3043 { "(bad)", { XX
} },
3044 { "(bad)", { XX
} },
3046 { "(bad)", { XX
} },
3047 { "(bad)", { XX
} },
3048 { "(bad)", { XX
} },
3049 { "(bad)", { XX
} },
3050 { "(bad)", { XX
} },
3051 { "(bad)", { XX
} },
3052 { "(bad)", { XX
} },
3053 { "(bad)", { XX
} },
3055 { "(bad)", { XX
} },
3056 { "(bad)", { XX
} },
3057 { "(bad)", { XX
} },
3058 { "(bad)", { XX
} },
3059 { "(bad)", { XX
} },
3060 { "(bad)", { XX
} },
3061 { "(bad)", { XX
} },
3062 { "(bad)", { XX
} },
3064 { "(bad)", { XX
} },
3065 { "(bad)", { XX
} },
3066 { "(bad)", { XX
} },
3067 { "(bad)", { XX
} },
3068 { "(bad)", { XX
} },
3069 { "(bad)", { XX
} },
3070 { "(bad)", { XX
} },
3071 { "(bad)", { XX
} },
3073 { "(bad)", { XX
} },
3074 { "(bad)", { XX
} },
3075 { "(bad)", { XX
} },
3076 { "(bad)", { XX
} },
3077 { "(bad)", { XX
} },
3078 { "(bad)", { XX
} },
3079 { "(bad)", { XX
} },
3080 { "(bad)", { XX
} },
3082 { "(bad)", { XX
} },
3083 { "(bad)", { XX
} },
3084 { "(bad)", { XX
} },
3085 { "(bad)", { XX
} },
3086 { "(bad)", { XX
} },
3087 { "(bad)", { XX
} },
3088 { "(bad)", { XX
} },
3089 { "(bad)", { XX
} },
3091 { "(bad)", { XX
} },
3092 { "(bad)", { XX
} },
3093 { "(bad)", { XX
} },
3094 { "(bad)", { XX
} },
3095 { "(bad)", { XX
} },
3096 { "(bad)", { XX
} },
3097 { "(bad)", { XX
} },
3098 { "(bad)", { XX
} },
3100 /* THREE_BYTE_SSE5_0F24 */
3103 { "fmaddps", { { OP_DREX4
, q_mode
} } },
3104 { "fmaddpd", { { OP_DREX4
, q_mode
} } },
3105 { "fmaddss", { { OP_DREX4
, w_mode
} } },
3106 { "fmaddsd", { { OP_DREX4
, d_mode
} } },
3107 { "fmaddps", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3108 { "fmaddpd", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3109 { "fmaddss", { { OP_DREX4
, DREX_OC1
+ w_mode
} } },
3110 { "fmaddsd", { { OP_DREX4
, DREX_OC1
+ d_mode
} } },
3112 { "fmsubps", { { OP_DREX4
, q_mode
} } },
3113 { "fmsubpd", { { OP_DREX4
, q_mode
} } },
3114 { "fmsubss", { { OP_DREX4
, w_mode
} } },
3115 { "fmsubsd", { { OP_DREX4
, d_mode
} } },
3116 { "fmsubps", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3117 { "fmsubpd", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3118 { "fmsubss", { { OP_DREX4
, DREX_OC1
+ w_mode
} } },
3119 { "fmsubsd", { { OP_DREX4
, DREX_OC1
+ d_mode
} } },
3121 { "fnmaddps", { { OP_DREX4
, q_mode
} } },
3122 { "fnmaddpd", { { OP_DREX4
, q_mode
} } },
3123 { "fnmaddss", { { OP_DREX4
, w_mode
} } },
3124 { "fnmaddsd", { { OP_DREX4
, d_mode
} } },
3125 { "fnmaddps", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3126 { "fnmaddpd", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3127 { "fnmaddss", { { OP_DREX4
, DREX_OC1
+ w_mode
} } },
3128 { "fnmaddsd", { { OP_DREX4
, DREX_OC1
+ d_mode
} } },
3130 { "fnmsubps", { { OP_DREX4
, q_mode
} } },
3131 { "fnmsubpd", { { OP_DREX4
, q_mode
} } },
3132 { "fnmsubss", { { OP_DREX4
, w_mode
} } },
3133 { "fnmsubsd", { { OP_DREX4
, d_mode
} } },
3134 { "fnmsubps", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3135 { "fnmsubpd", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3136 { "fnmsubss", { { OP_DREX4
, DREX_OC1
+ w_mode
} } },
3137 { "fnmsubsd", { { OP_DREX4
, DREX_OC1
+ d_mode
} } },
3139 { "permps", { { OP_DREX4
, q_mode
} } },
3140 { "permpd", { { OP_DREX4
, q_mode
} } },
3141 { "pcmov", { { OP_DREX4
, q_mode
} } },
3142 { "pperm", { { OP_DREX4
, q_mode
} } },
3143 { "permps", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3144 { "permpd", { { OP_DREX4
, DREX_OC1
+ q_mode
} } },
3145 { "pcmov", { { OP_DREX4
, DREX_OC1
+ w_mode
} } },
3146 { "pperm", { { OP_DREX4
, DREX_OC1
+ d_mode
} } },
3148 { "(bad)", { XX
} },
3149 { "(bad)", { XX
} },
3150 { "(bad)", { XX
} },
3151 { "(bad)", { XX
} },
3152 { "(bad)", { XX
} },
3153 { "(bad)", { XX
} },
3154 { "(bad)", { XX
} },
3155 { "(bad)", { XX
} },
3157 { "(bad)", { XX
} },
3158 { "(bad)", { XX
} },
3159 { "(bad)", { XX
} },
3160 { "(bad)", { XX
} },
3161 { "(bad)", { XX
} },
3162 { "(bad)", { XX
} },
3163 { "(bad)", { XX
} },
3164 { "(bad)", { XX
} },
3166 { "(bad)", { XX
} },
3167 { "(bad)", { XX
} },
3168 { "(bad)", { XX
} },
3169 { "(bad)", { XX
} },
3170 { "(bad)", { XX
} },
3171 { "(bad)", { XX
} },
3172 { "(bad)", { XX
} },
3173 { "(bad)", { XX
} },
3175 { "protb", { { OP_DREX3
, q_mode
} } },
3176 { "protw", { { OP_DREX3
, q_mode
} } },
3177 { "protd", { { OP_DREX3
, q_mode
} } },
3178 { "protq", { { OP_DREX3
, q_mode
} } },
3179 { "pshlb", { { OP_DREX3
, q_mode
} } },
3180 { "pshlw", { { OP_DREX3
, q_mode
} } },
3181 { "pshld", { { OP_DREX3
, q_mode
} } },
3182 { "pshlq", { { OP_DREX3
, q_mode
} } },
3184 { "pshab", { { OP_DREX3
, q_mode
} } },
3185 { "pshaw", { { OP_DREX3
, q_mode
} } },
3186 { "pshad", { { OP_DREX3
, q_mode
} } },
3187 { "pshaq", { { OP_DREX3
, q_mode
} } },
3188 { "(bad)", { XX
} },
3189 { "(bad)", { XX
} },
3190 { "(bad)", { XX
} },
3191 { "(bad)", { XX
} },
3193 { "(bad)", { XX
} },
3194 { "(bad)", { XX
} },
3195 { "(bad)", { XX
} },
3196 { "(bad)", { XX
} },
3197 { "(bad)", { XX
} },
3198 { "(bad)", { XX
} },
3199 { "(bad)", { XX
} },
3200 { "(bad)", { XX
} },
3202 { "(bad)", { XX
} },
3203 { "(bad)", { XX
} },
3204 { "(bad)", { XX
} },
3205 { "(bad)", { XX
} },
3206 { "(bad)", { XX
} },
3207 { "(bad)", { XX
} },
3208 { "(bad)", { XX
} },
3209 { "(bad)", { XX
} },
3211 { "(bad)", { XX
} },
3212 { "(bad)", { XX
} },
3213 { "(bad)", { XX
} },
3214 { "(bad)", { XX
} },
3215 { "(bad)", { XX
} },
3216 { "(bad)", { XX
} },
3217 { "(bad)", { XX
} },
3218 { "(bad)", { XX
} },
3220 { "(bad)", { XX
} },
3221 { "(bad)", { XX
} },
3222 { "(bad)", { XX
} },
3223 { "(bad)", { XX
} },
3224 { "(bad)", { XX
} },
3225 { "(bad)", { XX
} },
3226 { "(bad)", { XX
} },
3227 { "(bad)", { XX
} },
3229 { "(bad)", { XX
} },
3230 { "(bad)", { XX
} },
3231 { "(bad)", { XX
} },
3232 { "(bad)", { XX
} },
3233 { "(bad)", { XX
} },
3234 { "(bad)", { XX
} },
3235 { "(bad)", { XX
} },
3236 { "(bad)", { XX
} },
3238 { "(bad)", { XX
} },
3239 { "(bad)", { XX
} },
3240 { "(bad)", { XX
} },
3241 { "(bad)", { XX
} },
3242 { "(bad)", { XX
} },
3243 { "(bad)", { XX
} },
3244 { "(bad)", { XX
} },
3245 { "(bad)", { XX
} },
3247 { "(bad)", { XX
} },
3248 { "(bad)", { XX
} },
3249 { "(bad)", { XX
} },
3250 { "(bad)", { XX
} },
3251 { "(bad)", { XX
} },
3252 { "pmacssww", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3253 { "pmacsswd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3254 { "pmacssdql", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3256 { "(bad)", { XX
} },
3257 { "(bad)", { XX
} },
3258 { "(bad)", { XX
} },
3259 { "(bad)", { XX
} },
3260 { "(bad)", { XX
} },
3261 { "(bad)", { XX
} },
3262 { "pmacssdd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3263 { "pmacssdqh", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3265 { "(bad)", { XX
} },
3266 { "(bad)", { XX
} },
3267 { "(bad)", { XX
} },
3268 { "(bad)", { XX
} },
3269 { "(bad)", { XX
} },
3270 { "pmacsww", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3271 { "pmacswd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3272 { "pmacsdql", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3274 { "(bad)", { XX
} },
3275 { "(bad)", { XX
} },
3276 { "(bad)", { XX
} },
3277 { "(bad)", { XX
} },
3278 { "(bad)", { XX
} },
3279 { "(bad)", { XX
} },
3280 { "pmacsdd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3281 { "pmacsdqh", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3283 { "(bad)", { XX
} },
3284 { "(bad)", { XX
} },
3285 { "(bad)", { XX
} },
3286 { "(bad)", { XX
} },
3287 { "(bad)", { XX
} },
3288 { "(bad)", { XX
} },
3289 { "pmadcsswd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3290 { "(bad)", { XX
} },
3292 { "(bad)", { XX
} },
3293 { "(bad)", { XX
} },
3294 { "(bad)", { XX
} },
3295 { "(bad)", { XX
} },
3296 { "(bad)", { XX
} },
3297 { "(bad)", { XX
} },
3298 { "(bad)", { XX
} },
3299 { "(bad)", { XX
} },
3301 { "(bad)", { XX
} },
3302 { "(bad)", { XX
} },
3303 { "(bad)", { XX
} },
3304 { "(bad)", { XX
} },
3305 { "(bad)", { XX
} },
3306 { "(bad)", { XX
} },
3307 { "pmadcswd", { { OP_DREX4
, DREX_OC1
+ DREX_NO_OC0
+ q_mode
} } },
3308 { "(bad)", { XX
} },
3310 { "(bad)", { XX
} },
3311 { "(bad)", { XX
} },
3312 { "(bad)", { XX
} },
3313 { "(bad)", { XX
} },
3314 { "(bad)", { XX
} },
3315 { "(bad)", { XX
} },
3316 { "(bad)", { XX
} },
3317 { "(bad)", { XX
} },
3319 { "(bad)", { XX
} },
3320 { "(bad)", { XX
} },
3321 { "(bad)", { XX
} },
3322 { "(bad)", { XX
} },
3323 { "(bad)", { XX
} },
3324 { "(bad)", { XX
} },
3325 { "(bad)", { XX
} },
3326 { "(bad)", { XX
} },
3328 { "(bad)", { XX
} },
3329 { "(bad)", { XX
} },
3330 { "(bad)", { XX
} },
3331 { "(bad)", { XX
} },
3332 { "(bad)", { XX
} },
3333 { "(bad)", { XX
} },
3334 { "(bad)", { XX
} },
3335 { "(bad)", { XX
} },
3337 { "(bad)", { XX
} },
3338 { "(bad)", { XX
} },
3339 { "(bad)", { XX
} },
3340 { "(bad)", { XX
} },
3341 { "(bad)", { XX
} },
3342 { "(bad)", { XX
} },
3343 { "(bad)", { XX
} },
3344 { "(bad)", { XX
} },
3346 { "(bad)", { XX
} },
3347 { "(bad)", { XX
} },
3348 { "(bad)", { XX
} },
3349 { "(bad)", { XX
} },
3350 { "(bad)", { XX
} },
3351 { "(bad)", { XX
} },
3352 { "(bad)", { XX
} },
3353 { "(bad)", { XX
} },
3355 { "(bad)", { XX
} },
3356 { "(bad)", { XX
} },
3357 { "(bad)", { XX
} },
3358 { "(bad)", { XX
} },
3359 { "(bad)", { XX
} },
3360 { "(bad)", { XX
} },
3361 { "(bad)", { XX
} },
3362 { "(bad)", { XX
} },
3364 { "(bad)", { XX
} },
3365 { "(bad)", { XX
} },
3366 { "(bad)", { XX
} },
3367 { "(bad)", { XX
} },
3368 { "(bad)", { XX
} },
3369 { "(bad)", { XX
} },
3370 { "(bad)", { XX
} },
3371 { "(bad)", { XX
} },
3373 { "(bad)", { XX
} },
3374 { "(bad)", { XX
} },
3375 { "(bad)", { XX
} },
3376 { "(bad)", { XX
} },
3377 { "(bad)", { XX
} },
3378 { "(bad)", { XX
} },
3379 { "(bad)", { XX
} },
3380 { "(bad)", { XX
} },
3382 { "(bad)", { XX
} },
3383 { "(bad)", { XX
} },
3384 { "(bad)", { XX
} },
3385 { "(bad)", { XX
} },
3386 { "(bad)", { XX
} },
3387 { "(bad)", { XX
} },
3388 { "(bad)", { XX
} },
3389 { "(bad)", { XX
} },
3391 /* THREE_BYTE_SSE5_0F25 */
3394 { "(bad)", { XX
} },
3395 { "(bad)", { XX
} },
3396 { "(bad)", { XX
} },
3397 { "(bad)", { XX
} },
3398 { "(bad)", { XX
} },
3399 { "(bad)", { XX
} },
3400 { "(bad)", { XX
} },
3401 { "(bad)", { XX
} },
3403 { "(bad)", { XX
} },
3404 { "(bad)", { XX
} },
3405 { "(bad)", { XX
} },
3406 { "(bad)", { XX
} },
3407 { "(bad)", { XX
} },
3408 { "(bad)", { XX
} },
3409 { "(bad)", { XX
} },
3410 { "(bad)", { XX
} },
3412 { "(bad)", { XX
} },
3413 { "(bad)", { XX
} },
3414 { "(bad)", { XX
} },
3415 { "(bad)", { XX
} },
3416 { "(bad)", { XX
} },
3417 { "(bad)", { XX
} },
3418 { "(bad)", { XX
} },
3419 { "(bad)", { XX
} },
3421 { "(bad)", { XX
} },
3422 { "(bad)", { XX
} },
3423 { "(bad)", { XX
} },
3424 { "(bad)", { XX
} },
3425 { "(bad)", { XX
} },
3426 { "(bad)", { XX
} },
3427 { "(bad)", { XX
} },
3428 { "(bad)", { XX
} },
3430 { "(bad)", { XX
} },
3431 { "(bad)", { XX
} },
3432 { "(bad)", { XX
} },
3433 { "(bad)", { XX
} },
3434 { "(bad)", { XX
} },
3435 { "(bad)", { XX
} },
3436 { "(bad)", { XX
} },
3437 { "(bad)", { XX
} },
3439 { "(bad)", { XX
} },
3440 { "(bad)", { XX
} },
3441 { "(bad)", { XX
} },
3442 { "(bad)", { XX
} },
3443 { "comps", { { OP_DREX3
, q_mode
}, { OP_DREX_FCMP
, b_mode
} } },
3444 { "compd", { { OP_DREX3
, q_mode
}, { OP_DREX_FCMP
, b_mode
} } },
3445 { "comss", { { OP_DREX3
, w_mode
}, { OP_DREX_FCMP
, b_mode
} } },
3446 { "comsd", { { OP_DREX3
, d_mode
}, { OP_DREX_FCMP
, b_mode
} } },
3448 { "(bad)", { XX
} },
3449 { "(bad)", { XX
} },
3450 { "(bad)", { XX
} },
3451 { "(bad)", { XX
} },
3452 { "(bad)", { XX
} },
3453 { "(bad)", { XX
} },
3454 { "(bad)", { XX
} },
3455 { "(bad)", { XX
} },
3457 { "(bad)", { XX
} },
3458 { "(bad)", { XX
} },
3459 { "(bad)", { XX
} },
3460 { "(bad)", { XX
} },
3461 { "(bad)", { XX
} },
3462 { "(bad)", { XX
} },
3463 { "(bad)", { XX
} },
3464 { "(bad)", { XX
} },
3466 { "(bad)", { XX
} },
3467 { "(bad)", { XX
} },
3468 { "(bad)", { XX
} },
3469 { "(bad)", { XX
} },
3470 { "(bad)", { XX
} },
3471 { "(bad)", { XX
} },
3472 { "(bad)", { XX
} },
3473 { "(bad)", { XX
} },
3475 { "(bad)", { XX
} },
3476 { "(bad)", { XX
} },
3477 { "(bad)", { XX
} },
3478 { "(bad)", { XX
} },
3479 { "pcomb", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3480 { "pcomw", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3481 { "pcomd", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3482 { "pcomq", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3484 { "(bad)", { XX
} },
3485 { "(bad)", { XX
} },
3486 { "(bad)", { XX
} },
3487 { "(bad)", { XX
} },
3488 { "(bad)", { XX
} },
3489 { "(bad)", { XX
} },
3490 { "(bad)", { XX
} },
3491 { "(bad)", { XX
} },
3493 { "(bad)", { XX
} },
3494 { "(bad)", { XX
} },
3495 { "(bad)", { XX
} },
3496 { "(bad)", { XX
} },
3497 { "(bad)", { XX
} },
3498 { "(bad)", { XX
} },
3499 { "(bad)", { XX
} },
3500 { "(bad)", { XX
} },
3502 { "(bad)", { XX
} },
3503 { "(bad)", { XX
} },
3504 { "(bad)", { XX
} },
3505 { "(bad)", { XX
} },
3506 { "(bad)", { XX
} },
3507 { "(bad)", { XX
} },
3508 { "(bad)", { XX
} },
3509 { "(bad)", { XX
} },
3511 { "(bad)", { XX
} },
3512 { "(bad)", { XX
} },
3513 { "(bad)", { XX
} },
3514 { "(bad)", { XX
} },
3515 { "pcomub", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3516 { "pcomuw", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3517 { "pcomud", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3518 { "pcomuq", { { OP_DREX3
, q_mode
}, { OP_DREX_ICMP
, b_mode
} } },
3520 { "(bad)", { XX
} },
3521 { "(bad)", { XX
} },
3522 { "(bad)", { XX
} },
3523 { "(bad)", { XX
} },
3524 { "(bad)", { XX
} },
3525 { "(bad)", { XX
} },
3526 { "(bad)", { XX
} },
3527 { "(bad)", { XX
} },
3529 { "(bad)", { XX
} },
3530 { "(bad)", { XX
} },
3531 { "(bad)", { XX
} },
3532 { "(bad)", { XX
} },
3533 { "(bad)", { XX
} },
3534 { "(bad)", { XX
} },
3535 { "(bad)", { XX
} },
3536 { "(bad)", { XX
} },
3538 { "(bad)", { XX
} },
3539 { "(bad)", { XX
} },
3540 { "(bad)", { XX
} },
3541 { "(bad)", { XX
} },
3542 { "(bad)", { XX
} },
3543 { "(bad)", { XX
} },
3544 { "(bad)", { XX
} },
3545 { "(bad)", { XX
} },
3547 { "(bad)", { XX
} },
3548 { "(bad)", { XX
} },
3549 { "(bad)", { XX
} },
3550 { "(bad)", { XX
} },
3551 { "(bad)", { XX
} },
3552 { "(bad)", { XX
} },
3553 { "(bad)", { XX
} },
3554 { "(bad)", { XX
} },
3556 { "(bad)", { XX
} },
3557 { "(bad)", { XX
} },
3558 { "(bad)", { XX
} },
3559 { "(bad)", { XX
} },
3560 { "(bad)", { XX
} },
3561 { "(bad)", { XX
} },
3562 { "(bad)", { XX
} },
3563 { "(bad)", { XX
} },
3565 { "(bad)", { XX
} },
3566 { "(bad)", { XX
} },
3567 { "(bad)", { XX
} },
3568 { "(bad)", { XX
} },
3569 { "(bad)", { XX
} },
3570 { "(bad)", { XX
} },
3571 { "(bad)", { XX
} },
3572 { "(bad)", { XX
} },
3574 { "(bad)", { XX
} },
3575 { "(bad)", { XX
} },
3576 { "(bad)", { XX
} },
3577 { "(bad)", { XX
} },
3578 { "(bad)", { XX
} },
3579 { "(bad)", { XX
} },
3580 { "(bad)", { XX
} },
3581 { "(bad)", { XX
} },
3583 { "(bad)", { XX
} },
3584 { "(bad)", { XX
} },
3585 { "(bad)", { XX
} },
3586 { "(bad)", { XX
} },
3587 { "(bad)", { XX
} },
3588 { "(bad)", { XX
} },
3589 { "(bad)", { XX
} },
3590 { "(bad)", { XX
} },
3592 { "(bad)", { XX
} },
3593 { "(bad)", { XX
} },
3594 { "(bad)", { XX
} },
3595 { "(bad)", { XX
} },
3596 { "(bad)", { XX
} },
3597 { "(bad)", { XX
} },
3598 { "(bad)", { XX
} },
3599 { "(bad)", { XX
} },
3601 { "(bad)", { XX
} },
3602 { "(bad)", { XX
} },
3603 { "(bad)", { XX
} },
3604 { "(bad)", { XX
} },
3605 { "(bad)", { XX
} },
3606 { "(bad)", { XX
} },
3607 { "(bad)", { XX
} },
3608 { "(bad)", { XX
} },
3610 { "(bad)", { XX
} },
3611 { "(bad)", { XX
} },
3612 { "(bad)", { XX
} },
3613 { "(bad)", { XX
} },
3614 { "(bad)", { XX
} },
3615 { "(bad)", { XX
} },
3616 { "(bad)", { XX
} },
3617 { "(bad)", { XX
} },
3619 { "(bad)", { XX
} },
3620 { "(bad)", { XX
} },
3621 { "(bad)", { XX
} },
3622 { "(bad)", { XX
} },
3623 { "(bad)", { XX
} },
3624 { "(bad)", { XX
} },
3625 { "(bad)", { XX
} },
3626 { "(bad)", { XX
} },
3628 { "(bad)", { XX
} },
3629 { "(bad)", { XX
} },
3630 { "(bad)", { XX
} },
3631 { "(bad)", { XX
} },
3632 { "(bad)", { XX
} },
3633 { "(bad)", { XX
} },
3634 { "(bad)", { XX
} },
3635 { "(bad)", { XX
} },
3637 { "(bad)", { XX
} },
3638 { "(bad)", { XX
} },
3639 { "(bad)", { XX
} },
3640 { "(bad)", { XX
} },
3641 { "(bad)", { XX
} },
3642 { "(bad)", { XX
} },
3643 { "(bad)", { XX
} },
3644 { "(bad)", { XX
} },
3646 { "(bad)", { XX
} },
3647 { "(bad)", { XX
} },
3648 { "(bad)", { XX
} },
3649 { "(bad)", { XX
} },
3650 { "(bad)", { XX
} },
3651 { "(bad)", { XX
} },
3652 { "(bad)", { XX
} },
3653 { "(bad)", { XX
} },
3655 { "(bad)", { XX
} },
3656 { "(bad)", { XX
} },
3657 { "(bad)", { XX
} },
3658 { "(bad)", { XX
} },
3659 { "(bad)", { XX
} },
3660 { "(bad)", { XX
} },
3661 { "(bad)", { XX
} },
3662 { "(bad)", { XX
} },
3664 { "(bad)", { XX
} },
3665 { "(bad)", { XX
} },
3666 { "(bad)", { XX
} },
3667 { "(bad)", { XX
} },
3668 { "(bad)", { XX
} },
3669 { "(bad)", { XX
} },
3670 { "(bad)", { XX
} },
3671 { "(bad)", { XX
} },
3673 { "(bad)", { XX
} },
3674 { "(bad)", { XX
} },
3675 { "(bad)", { XX
} },
3676 { "(bad)", { XX
} },
3677 { "(bad)", { XX
} },
3678 { "(bad)", { XX
} },
3679 { "(bad)", { XX
} },
3680 { "(bad)", { XX
} },
3682 /* THREE_BYTE_SSE5_0F7A */
3685 { "(bad)", { XX
} },
3686 { "(bad)", { XX
} },
3687 { "(bad)", { XX
} },
3688 { "(bad)", { XX
} },
3689 { "(bad)", { XX
} },
3690 { "(bad)", { XX
} },
3691 { "(bad)", { XX
} },
3692 { "(bad)", { XX
} },
3694 { "(bad)", { XX
} },
3695 { "(bad)", { XX
} },
3696 { "(bad)", { XX
} },
3697 { "(bad)", { XX
} },
3698 { "(bad)", { XX
} },
3699 { "(bad)", { XX
} },
3700 { "(bad)", { XX
} },
3701 { "(bad)", { XX
} },
3703 { "frczps", { XM
, EXq
} },
3704 { "frczpd", { XM
, EXq
} },
3705 { "frczss", { XM
, EXq
} },
3706 { "frczsd", { XM
, EXq
} },
3707 { "(bad)", { XX
} },
3708 { "(bad)", { XX
} },
3709 { "(bad)", { XX
} },
3710 { "(bad)", { XX
} },
3712 { "(bad)", { XX
} },
3713 { "(bad)", { XX
} },
3714 { "(bad)", { XX
} },
3715 { "(bad)", { XX
} },
3716 { "(bad)", { XX
} },
3717 { "(bad)", { XX
} },
3718 { "(bad)", { XX
} },
3719 { "(bad)", { XX
} },
3721 { "ptest", { XX
} },
3722 { "(bad)", { XX
} },
3723 { "(bad)", { XX
} },
3724 { "(bad)", { XX
} },
3725 { "(bad)", { XX
} },
3726 { "(bad)", { XX
} },
3727 { "(bad)", { XX
} },
3728 { "(bad)", { XX
} },
3730 { "(bad)", { XX
} },
3731 { "(bad)", { XX
} },
3732 { "(bad)", { XX
} },
3733 { "(bad)", { XX
} },
3734 { "(bad)", { XX
} },
3735 { "(bad)", { XX
} },
3736 { "(bad)", { XX
} },
3737 { "(bad)", { XX
} },
3739 { "cvtph2ps", { XM
, EXd
} },
3740 { "cvtps2ph", { EXd
, XM
} },
3741 { "(bad)", { XX
} },
3742 { "(bad)", { XX
} },
3743 { "(bad)", { XX
} },
3744 { "(bad)", { XX
} },
3745 { "(bad)", { XX
} },
3746 { "(bad)", { XX
} },
3748 { "(bad)", { XX
} },
3749 { "(bad)", { XX
} },
3750 { "(bad)", { XX
} },
3751 { "(bad)", { XX
} },
3752 { "(bad)", { XX
} },
3753 { "(bad)", { XX
} },
3754 { "(bad)", { XX
} },
3755 { "(bad)", { XX
} },
3757 { "(bad)", { XX
} },
3758 { "phaddbw", { XM
, EXq
} },
3759 { "phaddbd", { XM
, EXq
} },
3760 { "phaddbq", { XM
, EXq
} },
3761 { "(bad)", { XX
} },
3762 { "(bad)", { XX
} },
3763 { "phaddwd", { XM
, EXq
} },
3764 { "phaddwq", { XM
, EXq
} },
3766 { "(bad)", { XX
} },
3767 { "(bad)", { XX
} },
3768 { "(bad)", { XX
} },
3769 { "phadddq", { XM
, EXq
} },
3770 { "(bad)", { XX
} },
3771 { "(bad)", { XX
} },
3772 { "(bad)", { XX
} },
3773 { "(bad)", { XX
} },
3775 { "(bad)", { XX
} },
3776 { "phaddubw", { XM
, EXq
} },
3777 { "phaddubd", { XM
, EXq
} },
3778 { "phaddubq", { XM
, EXq
} },
3779 { "(bad)", { XX
} },
3780 { "(bad)", { XX
} },
3781 { "phadduwd", { XM
, EXq
} },
3782 { "phadduwq", { XM
, EXq
} },
3784 { "(bad)", { XX
} },
3785 { "(bad)", { XX
} },
3786 { "(bad)", { XX
} },
3787 { "phaddudq", { XM
, EXq
} },
3788 { "(bad)", { XX
} },
3789 { "(bad)", { XX
} },
3790 { "(bad)", { XX
} },
3791 { "(bad)", { XX
} },
3793 { "(bad)", { XX
} },
3794 { "phsubbw", { XM
, EXq
} },
3795 { "phsubbd", { XM
, EXq
} },
3796 { "phsubbq", { XM
, EXq
} },
3797 { "(bad)", { XX
} },
3798 { "(bad)", { XX
} },
3799 { "(bad)", { XX
} },
3800 { "(bad)", { XX
} },
3802 { "(bad)", { XX
} },
3803 { "(bad)", { XX
} },
3804 { "(bad)", { XX
} },
3805 { "(bad)", { XX
} },
3806 { "(bad)", { XX
} },
3807 { "(bad)", { XX
} },
3808 { "(bad)", { XX
} },
3809 { "(bad)", { XX
} },
3811 { "(bad)", { XX
} },
3812 { "(bad)", { XX
} },
3813 { "(bad)", { XX
} },
3814 { "(bad)", { XX
} },
3815 { "(bad)", { XX
} },
3816 { "(bad)", { XX
} },
3817 { "(bad)", { XX
} },
3818 { "(bad)", { XX
} },
3820 { "(bad)", { XX
} },
3821 { "(bad)", { XX
} },
3822 { "(bad)", { XX
} },
3823 { "(bad)", { XX
} },
3824 { "(bad)", { XX
} },
3825 { "(bad)", { XX
} },
3826 { "(bad)", { XX
} },
3827 { "(bad)", { XX
} },
3829 { "(bad)", { XX
} },
3830 { "(bad)", { XX
} },
3831 { "(bad)", { XX
} },
3832 { "(bad)", { XX
} },
3833 { "(bad)", { XX
} },
3834 { "(bad)", { XX
} },
3835 { "(bad)", { XX
} },
3836 { "(bad)", { XX
} },
3838 { "(bad)", { XX
} },
3839 { "(bad)", { XX
} },
3840 { "(bad)", { XX
} },
3841 { "(bad)", { XX
} },
3842 { "(bad)", { XX
} },
3843 { "(bad)", { XX
} },
3844 { "(bad)", { XX
} },
3845 { "(bad)", { XX
} },
3847 { "(bad)", { XX
} },
3848 { "(bad)", { XX
} },
3849 { "(bad)", { XX
} },
3850 { "(bad)", { XX
} },
3851 { "(bad)", { XX
} },
3852 { "(bad)", { XX
} },
3853 { "(bad)", { XX
} },
3854 { "(bad)", { XX
} },
3856 { "(bad)", { XX
} },
3857 { "(bad)", { XX
} },
3858 { "(bad)", { XX
} },
3859 { "(bad)", { XX
} },
3860 { "(bad)", { XX
} },
3861 { "(bad)", { XX
} },
3862 { "(bad)", { XX
} },
3863 { "(bad)", { XX
} },
3865 { "(bad)", { XX
} },
3866 { "(bad)", { XX
} },
3867 { "(bad)", { XX
} },
3868 { "(bad)", { XX
} },
3869 { "(bad)", { XX
} },
3870 { "(bad)", { XX
} },
3871 { "(bad)", { XX
} },
3872 { "(bad)", { XX
} },
3874 { "(bad)", { XX
} },
3875 { "(bad)", { XX
} },
3876 { "(bad)", { XX
} },
3877 { "(bad)", { XX
} },
3878 { "(bad)", { XX
} },
3879 { "(bad)", { XX
} },
3880 { "(bad)", { XX
} },
3881 { "(bad)", { XX
} },
3883 { "(bad)", { XX
} },
3884 { "(bad)", { XX
} },
3885 { "(bad)", { XX
} },
3886 { "(bad)", { XX
} },
3887 { "(bad)", { XX
} },
3888 { "(bad)", { XX
} },
3889 { "(bad)", { XX
} },
3890 { "(bad)", { XX
} },
3892 { "(bad)", { XX
} },
3893 { "(bad)", { XX
} },
3894 { "(bad)", { XX
} },
3895 { "(bad)", { XX
} },
3896 { "(bad)", { XX
} },
3897 { "(bad)", { XX
} },
3898 { "(bad)", { XX
} },
3899 { "(bad)", { XX
} },
3901 { "(bad)", { XX
} },
3902 { "(bad)", { XX
} },
3903 { "(bad)", { XX
} },
3904 { "(bad)", { XX
} },
3905 { "(bad)", { XX
} },
3906 { "(bad)", { XX
} },
3907 { "(bad)", { XX
} },
3908 { "(bad)", { XX
} },
3910 { "(bad)", { XX
} },
3911 { "(bad)", { XX
} },
3912 { "(bad)", { XX
} },
3913 { "(bad)", { XX
} },
3914 { "(bad)", { XX
} },
3915 { "(bad)", { XX
} },
3916 { "(bad)", { XX
} },
3917 { "(bad)", { XX
} },
3919 { "(bad)", { XX
} },
3920 { "(bad)", { XX
} },
3921 { "(bad)", { XX
} },
3922 { "(bad)", { XX
} },
3923 { "(bad)", { XX
} },
3924 { "(bad)", { XX
} },
3925 { "(bad)", { XX
} },
3926 { "(bad)", { XX
} },
3928 { "(bad)", { XX
} },
3929 { "(bad)", { XX
} },
3930 { "(bad)", { XX
} },
3931 { "(bad)", { XX
} },
3932 { "(bad)", { XX
} },
3933 { "(bad)", { XX
} },
3934 { "(bad)", { XX
} },
3935 { "(bad)", { XX
} },
3937 { "(bad)", { XX
} },
3938 { "(bad)", { XX
} },
3939 { "(bad)", { XX
} },
3940 { "(bad)", { XX
} },
3941 { "(bad)", { XX
} },
3942 { "(bad)", { XX
} },
3943 { "(bad)", { XX
} },
3944 { "(bad)", { XX
} },
3946 { "(bad)", { XX
} },
3947 { "(bad)", { XX
} },
3948 { "(bad)", { XX
} },
3949 { "(bad)", { XX
} },
3950 { "(bad)", { XX
} },
3951 { "(bad)", { XX
} },
3952 { "(bad)", { XX
} },
3953 { "(bad)", { XX
} },
3955 { "(bad)", { XX
} },
3956 { "(bad)", { XX
} },
3957 { "(bad)", { XX
} },
3958 { "(bad)", { XX
} },
3959 { "(bad)", { XX
} },
3960 { "(bad)", { XX
} },
3961 { "(bad)", { XX
} },
3962 { "(bad)", { XX
} },
3964 { "(bad)", { XX
} },
3965 { "(bad)", { XX
} },
3966 { "(bad)", { XX
} },
3967 { "(bad)", { XX
} },
3968 { "(bad)", { XX
} },
3969 { "(bad)", { XX
} },
3970 { "(bad)", { XX
} },
3971 { "(bad)", { XX
} },
3973 /* THREE_BYTE_SSE5_0F7B */
3976 { "(bad)", { XX
} },
3977 { "(bad)", { XX
} },
3978 { "(bad)", { XX
} },
3979 { "(bad)", { XX
} },
3980 { "(bad)", { XX
} },
3981 { "(bad)", { XX
} },
3982 { "(bad)", { XX
} },
3983 { "(bad)", { XX
} },
3985 { "(bad)", { XX
} },
3986 { "(bad)", { XX
} },
3987 { "(bad)", { XX
} },
3988 { "(bad)", { XX
} },
3989 { "(bad)", { XX
} },
3990 { "(bad)", { XX
} },
3991 { "(bad)", { XX
} },
3992 { "(bad)", { XX
} },
3994 { "(bad)", { XX
} },
3995 { "(bad)", { XX
} },
3996 { "(bad)", { XX
} },
3997 { "(bad)", { XX
} },
3998 { "(bad)", { XX
} },
3999 { "(bad)", { XX
} },
4000 { "(bad)", { XX
} },
4001 { "(bad)", { XX
} },
4003 { "(bad)", { XX
} },
4004 { "(bad)", { XX
} },
4005 { "(bad)", { XX
} },
4006 { "(bad)", { XX
} },
4007 { "(bad)", { XX
} },
4008 { "(bad)", { XX
} },
4009 { "(bad)", { XX
} },
4010 { "(bad)", { XX
} },
4012 { "(bad)", { XX
} },
4013 { "(bad)", { XX
} },
4014 { "(bad)", { XX
} },
4015 { "(bad)", { XX
} },
4016 { "(bad)", { XX
} },
4017 { "(bad)", { XX
} },
4018 { "(bad)", { XX
} },
4019 { "(bad)", { XX
} },
4021 { "(bad)", { XX
} },
4022 { "(bad)", { XX
} },
4023 { "(bad)", { XX
} },
4024 { "(bad)", { XX
} },
4025 { "(bad)", { XX
} },
4026 { "(bad)", { XX
} },
4027 { "(bad)", { XX
} },
4028 { "(bad)", { XX
} },
4030 { "(bad)", { XX
} },
4031 { "(bad)", { XX
} },
4032 { "(bad)", { XX
} },
4033 { "(bad)", { XX
} },
4034 { "(bad)", { XX
} },
4035 { "(bad)", { XX
} },
4036 { "(bad)", { XX
} },
4037 { "(bad)", { XX
} },
4039 { "(bad)", { XX
} },
4040 { "(bad)", { XX
} },
4041 { "(bad)", { XX
} },
4042 { "(bad)", { XX
} },
4043 { "(bad)", { XX
} },
4044 { "(bad)", { XX
} },
4045 { "(bad)", { XX
} },
4046 { "(bad)", { XX
} },
4048 { "protb", { XM
, EXq
, Ib
} },
4049 { "protw", { XM
, EXq
, Ib
} },
4050 { "protd", { XM
, EXq
, Ib
} },
4051 { "protq", { XM
, EXq
, Ib
} },
4052 { "pshlb", { XM
, EXq
, Ib
} },
4053 { "pshlw", { XM
, EXq
, Ib
} },
4054 { "pshld", { XM
, EXq
, Ib
} },
4055 { "pshlq", { XM
, EXq
, Ib
} },
4057 { "pshab", { XM
, EXq
, Ib
} },
4058 { "pshaw", { XM
, EXq
, Ib
} },
4059 { "pshad", { XM
, EXq
, Ib
} },
4060 { "pshaq", { XM
, EXq
, Ib
} },
4061 { "(bad)", { XX
} },
4062 { "(bad)", { XX
} },
4063 { "(bad)", { XX
} },
4064 { "(bad)", { XX
} },
4066 { "(bad)", { XX
} },
4067 { "(bad)", { XX
} },
4068 { "(bad)", { XX
} },
4069 { "(bad)", { XX
} },
4070 { "(bad)", { XX
} },
4071 { "(bad)", { XX
} },
4072 { "(bad)", { XX
} },
4073 { "(bad)", { XX
} },
4075 { "(bad)", { XX
} },
4076 { "(bad)", { XX
} },
4077 { "(bad)", { XX
} },
4078 { "(bad)", { XX
} },
4079 { "(bad)", { XX
} },
4080 { "(bad)", { XX
} },
4081 { "(bad)", { XX
} },
4082 { "(bad)", { XX
} },
4084 { "(bad)", { XX
} },
4085 { "(bad)", { XX
} },
4086 { "(bad)", { XX
} },
4087 { "(bad)", { XX
} },
4088 { "(bad)", { XX
} },
4089 { "(bad)", { XX
} },
4090 { "(bad)", { XX
} },
4091 { "(bad)", { XX
} },
4093 { "(bad)", { XX
} },
4094 { "(bad)", { XX
} },
4095 { "(bad)", { XX
} },
4096 { "(bad)", { XX
} },
4097 { "(bad)", { XX
} },
4098 { "(bad)", { XX
} },
4099 { "(bad)", { XX
} },
4100 { "(bad)", { XX
} },
4102 { "(bad)", { XX
} },
4103 { "(bad)", { XX
} },
4104 { "(bad)", { XX
} },
4105 { "(bad)", { XX
} },
4106 { "(bad)", { XX
} },
4107 { "(bad)", { XX
} },
4108 { "(bad)", { XX
} },
4109 { "(bad)", { XX
} },
4111 { "(bad)", { XX
} },
4112 { "(bad)", { XX
} },
4113 { "(bad)", { XX
} },
4114 { "(bad)", { XX
} },
4115 { "(bad)", { XX
} },
4116 { "(bad)", { XX
} },
4117 { "(bad)", { XX
} },
4118 { "(bad)", { XX
} },
4120 { "(bad)", { XX
} },
4121 { "(bad)", { XX
} },
4122 { "(bad)", { XX
} },
4123 { "(bad)", { XX
} },
4124 { "(bad)", { XX
} },
4125 { "(bad)", { XX
} },
4126 { "(bad)", { XX
} },
4127 { "(bad)", { XX
} },
4129 { "(bad)", { XX
} },
4130 { "(bad)", { XX
} },
4131 { "(bad)", { XX
} },
4132 { "(bad)", { XX
} },
4133 { "(bad)", { XX
} },
4134 { "(bad)", { XX
} },
4135 { "(bad)", { XX
} },
4136 { "(bad)", { XX
} },
4138 { "(bad)", { XX
} },
4139 { "(bad)", { XX
} },
4140 { "(bad)", { XX
} },
4141 { "(bad)", { XX
} },
4142 { "(bad)", { XX
} },
4143 { "(bad)", { XX
} },
4144 { "(bad)", { XX
} },
4145 { "(bad)", { XX
} },
4147 { "(bad)", { XX
} },
4148 { "(bad)", { XX
} },
4149 { "(bad)", { XX
} },
4150 { "(bad)", { XX
} },
4151 { "(bad)", { XX
} },
4152 { "(bad)", { XX
} },
4153 { "(bad)", { XX
} },
4154 { "(bad)", { XX
} },
4156 { "(bad)", { XX
} },
4157 { "(bad)", { XX
} },
4158 { "(bad)", { XX
} },
4159 { "(bad)", { XX
} },
4160 { "(bad)", { XX
} },
4161 { "(bad)", { XX
} },
4162 { "(bad)", { XX
} },
4163 { "(bad)", { XX
} },
4165 { "(bad)", { XX
} },
4166 { "(bad)", { XX
} },
4167 { "(bad)", { XX
} },
4168 { "(bad)", { XX
} },
4169 { "(bad)", { XX
} },
4170 { "(bad)", { XX
} },
4171 { "(bad)", { XX
} },
4172 { "(bad)", { XX
} },
4174 { "(bad)", { XX
} },
4175 { "(bad)", { XX
} },
4176 { "(bad)", { XX
} },
4177 { "(bad)", { XX
} },
4178 { "(bad)", { XX
} },
4179 { "(bad)", { XX
} },
4180 { "(bad)", { XX
} },
4181 { "(bad)", { XX
} },
4183 { "(bad)", { XX
} },
4184 { "(bad)", { XX
} },
4185 { "(bad)", { XX
} },
4186 { "(bad)", { XX
} },
4187 { "(bad)", { XX
} },
4188 { "(bad)", { XX
} },
4189 { "(bad)", { XX
} },
4190 { "(bad)", { XX
} },
4192 { "(bad)", { XX
} },
4193 { "(bad)", { XX
} },
4194 { "(bad)", { XX
} },
4195 { "(bad)", { XX
} },
4196 { "(bad)", { XX
} },
4197 { "(bad)", { XX
} },
4198 { "(bad)", { XX
} },
4199 { "(bad)", { XX
} },
4201 { "(bad)", { XX
} },
4202 { "(bad)", { XX
} },
4203 { "(bad)", { XX
} },
4204 { "(bad)", { XX
} },
4205 { "(bad)", { XX
} },
4206 { "(bad)", { XX
} },
4207 { "(bad)", { XX
} },
4208 { "(bad)", { XX
} },
4210 { "(bad)", { XX
} },
4211 { "(bad)", { XX
} },
4212 { "(bad)", { XX
} },
4213 { "(bad)", { XX
} },
4214 { "(bad)", { XX
} },
4215 { "(bad)", { XX
} },
4216 { "(bad)", { XX
} },
4217 { "(bad)", { XX
} },
4219 { "(bad)", { XX
} },
4220 { "(bad)", { XX
} },
4221 { "(bad)", { XX
} },
4222 { "(bad)", { XX
} },
4223 { "(bad)", { XX
} },
4224 { "(bad)", { XX
} },
4225 { "(bad)", { XX
} },
4226 { "(bad)", { XX
} },
4228 { "(bad)", { XX
} },
4229 { "(bad)", { XX
} },
4230 { "(bad)", { XX
} },
4231 { "(bad)", { XX
} },
4232 { "(bad)", { XX
} },
4233 { "(bad)", { XX
} },
4234 { "(bad)", { XX
} },
4235 { "(bad)", { XX
} },
4237 { "(bad)", { XX
} },
4238 { "(bad)", { XX
} },
4239 { "(bad)", { XX
} },
4240 { "(bad)", { XX
} },
4241 { "(bad)", { XX
} },
4242 { "(bad)", { XX
} },
4243 { "(bad)", { XX
} },
4244 { "(bad)", { XX
} },
4246 { "(bad)", { XX
} },
4247 { "(bad)", { XX
} },
4248 { "(bad)", { XX
} },
4249 { "(bad)", { XX
} },
4250 { "(bad)", { XX
} },
4251 { "(bad)", { XX
} },
4252 { "(bad)", { XX
} },
4253 { "(bad)", { XX
} },
4255 { "(bad)", { XX
} },
4256 { "(bad)", { XX
} },
4257 { "(bad)", { XX
} },
4258 { "(bad)", { XX
} },
4259 { "(bad)", { XX
} },
4260 { "(bad)", { XX
} },
4261 { "(bad)", { XX
} },
4262 { "(bad)", { XX
} },
4266 static const struct dis386 opc_ext_table
[][2] = {
4269 { "leaS", { Gv
, M
} },
4270 { "(bad)", { XX
} },
4274 { "les{S|}", { Gv
, Mp
} },
4275 { "(bad)", { XX
} },
4279 { "ldsS", { Gv
, Mp
} },
4280 { "(bad)", { XX
} },
4284 { "lssS", { Gv
, Mp
} },
4285 { "(bad)", { XX
} },
4289 { "lfsS", { Gv
, Mp
} },
4290 { "(bad)", { XX
} },
4294 { "lgsS", { Gv
, Mp
} },
4295 { "(bad)", { XX
} },
4299 { "sgdt{Q|IQ||}", { M
} },
4304 { "sidt{Q|IQ||}", { M
} },
4309 { "lgdt{Q|Q||}", { M
} },
4310 { "(bad)", { XX
} },
4315 { "(bad)", { XX
} },
4319 { "vmptrst", { Mq
} },
4320 { "(bad)", { XX
} },
4324 { "(bad)", { XX
} },
4325 { "psrlw", { MS
, Ib
} },
4329 { "(bad)", { XX
} },
4330 { "psraw", { MS
, Ib
} },
4334 { "(bad)", { XX
} },
4335 { "psllw", { MS
, Ib
} },
4339 { "(bad)", { XX
} },
4340 { "psrld", { MS
, Ib
} },
4344 { "(bad)", { XX
} },
4345 { "psrad", { MS
, Ib
} },
4349 { "(bad)", { XX
} },
4350 { "pslld", { MS
, Ib
} },
4354 { "(bad)", { XX
} },
4355 { "psrlq", { MS
, Ib
} },
4359 { "(bad)", { XX
} },
4364 { "(bad)", { XX
} },
4365 { "psllq", { MS
, Ib
} },
4369 { "(bad)", { XX
} },
4374 { "fxsave", { M
} },
4375 { "(bad)", { XX
} },
4379 { "fxrstor", { M
} },
4380 { "(bad)", { XX
} },
4384 { "ldmxcsr", { Md
} },
4385 { "(bad)", { XX
} },
4389 { "stmxcsr", { Md
} },
4390 { "(bad)", { XX
} },
4394 { "(bad)", { XX
} },
4399 { "(bad)", { XX
} },
4404 { "clflush", { Mb
} },
4409 { "prefetchnta", { Mb
} },
4410 { "(bad)", { XX
} },
4414 { "prefetcht0", { Mb
} },
4415 { "(bad)", { XX
} },
4419 { "prefetcht1", { Mb
} },
4420 { "(bad)", { XX
} },
4424 { "prefetcht2", { Mb
} },
4425 { "(bad)", { XX
} },
4429 { "lddqu", { XM
, M
} },
4430 { "(bad)", { XX
} },
4434 { "bound{S|}", { Gv
, Ma
} },
4435 { "(bad)", { XX
} },
4439 { "movlpX", { EXq
, XM
} },
4440 { "(bad)", { XX
} },
4444 { "movhpX", { EXq
, XM
} },
4445 { "(bad)", { XX
} },
4449 { "movlpX", { XM
, EXq
} },
4450 { "movhlpX", { XM
, EXq
} },
4454 { "movhpX", { XM
, EXq
} },
4455 { "movlhpX", { XM
, EXq
} },
4459 { "invlpg", { Mb
} },
4464 { "lidt{Q|Q||}", { M
} },
4469 { "(bad)", { XX
} },
4470 { "movZ", { Rm
, Cm
} },
4474 { "(bad)", { XX
} },
4475 { "movZ", { Rm
, Dm
} },
4479 { "(bad)", { XX
} },
4480 { "movZ", { Cm
, Rm
} },
4484 { "(bad)", { XX
} },
4485 { "movZ", { Dm
, Rm
} },
4489 { THREE_BYTE_SSE5_0F24
},
4490 { "movL", { Rd
, Td
} },
4494 { "(bad)", { XX
} },
4495 { "movL", { Td
, Rd
} },
4499 static const struct dis386 opc_ext_rm_table
[][8] = {
4502 { "(bad)", { XX
} },
4503 { "vmcall", { Skip_MODRM
} },
4504 { "vmlaunch", { Skip_MODRM
} },
4505 { "vmresume", { Skip_MODRM
} },
4506 { "vmxoff", { Skip_MODRM
} },
4507 { "(bad)", { XX
} },
4508 { "(bad)", { XX
} },
4509 { "(bad)", { XX
} },
4513 { "monitor", { { OP_Monitor
, 0 } } },
4514 { "mwait", { { OP_Mwait
, 0 } } },
4515 { "(bad)", { XX
} },
4516 { "(bad)", { XX
} },
4517 { "(bad)", { XX
} },
4518 { "(bad)", { XX
} },
4519 { "(bad)", { XX
} },
4520 { "(bad)", { XX
} },
4524 { "lfence", { Skip_MODRM
} },
4525 { "(bad)", { XX
} },
4526 { "(bad)", { XX
} },
4527 { "(bad)", { XX
} },
4528 { "(bad)", { XX
} },
4529 { "(bad)", { XX
} },
4530 { "(bad)", { XX
} },
4531 { "(bad)", { XX
} },
4535 { "mfence", { Skip_MODRM
} },
4536 { "(bad)", { XX
} },
4537 { "(bad)", { XX
} },
4538 { "(bad)", { XX
} },
4539 { "(bad)", { XX
} },
4540 { "(bad)", { XX
} },
4541 { "(bad)", { XX
} },
4542 { "(bad)", { XX
} },
4546 { "sfence", { Skip_MODRM
} },
4547 { "(bad)", { XX
} },
4548 { "(bad)", { XX
} },
4549 { "(bad)", { XX
} },
4550 { "(bad)", { XX
} },
4551 { "(bad)", { XX
} },
4552 { "(bad)", { XX
} },
4553 { "(bad)", { XX
} },
4557 { "swapgs", { Skip_MODRM
} },
4558 { "rdtscp", { Skip_MODRM
} },
4559 { "(bad)", { XX
} },
4560 { "(bad)", { XX
} },
4561 { "(bad)", { XX
} },
4562 { "(bad)", { XX
} },
4563 { "(bad)", { XX
} },
4564 { "(bad)", { XX
} },
4568 { "vmrun", { Skip_MODRM
} },
4569 { "vmmcall", { Skip_MODRM
} },
4570 { "vmload", { Skip_MODRM
} },
4571 { "vmsave", { Skip_MODRM
} },
4572 { "stgi", { Skip_MODRM
} },
4573 { "clgi", { Skip_MODRM
} },
4574 { "skinit", { Skip_MODRM
} },
4575 { "invlpga", { Skip_MODRM
} },
4579 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
4591 FETCH_DATA (the_info
, codep
+ 1);
4595 /* REX prefixes family. */
4612 if (address_mode
== mode_64bit
)
4618 prefixes
|= PREFIX_REPZ
;
4621 prefixes
|= PREFIX_REPNZ
;
4624 prefixes
|= PREFIX_LOCK
;
4627 prefixes
|= PREFIX_CS
;
4630 prefixes
|= PREFIX_SS
;
4633 prefixes
|= PREFIX_DS
;
4636 prefixes
|= PREFIX_ES
;
4639 prefixes
|= PREFIX_FS
;
4642 prefixes
|= PREFIX_GS
;
4645 prefixes
|= PREFIX_DATA
;
4648 prefixes
|= PREFIX_ADDR
;
4651 /* fwait is really an instruction. If there are prefixes
4652 before the fwait, they belong to the fwait, *not* to the
4653 following instruction. */
4654 if (prefixes
|| rex
)
4656 prefixes
|= PREFIX_FWAIT
;
4660 prefixes
= PREFIX_FWAIT
;
4665 /* Rex is ignored when followed by another prefix. */
4676 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
4680 prefix_name (int pref
, int sizeflag
)
4682 static const char *rexes
[16] =
4687 "rex.XB", /* 0x43 */
4689 "rex.RB", /* 0x45 */
4690 "rex.RX", /* 0x46 */
4691 "rex.RXB", /* 0x47 */
4693 "rex.WB", /* 0x49 */
4694 "rex.WX", /* 0x4a */
4695 "rex.WXB", /* 0x4b */
4696 "rex.WR", /* 0x4c */
4697 "rex.WRB", /* 0x4d */
4698 "rex.WRX", /* 0x4e */
4699 "rex.WRXB", /* 0x4f */
4704 /* REX prefixes family. */
4721 return rexes
[pref
- 0x40];
4741 return (sizeflag
& DFLAG
) ? "data16" : "data32";
4743 if (address_mode
== mode_64bit
)
4744 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
4746 return (sizeflag
& AFLAG
) ? "addr16" : "addr32";
4754 static char op_out
[MAX_OPERANDS
][100];
4755 static int op_ad
, op_index
[MAX_OPERANDS
];
4756 static int two_source_ops
;
4757 static bfd_vma op_address
[MAX_OPERANDS
];
4758 static bfd_vma op_riprel
[MAX_OPERANDS
];
4759 static bfd_vma start_pc
;
4762 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
4763 * (see topic "Redundant prefixes" in the "Differences from 8086"
4764 * section of the "Virtual 8086 Mode" chapter.)
4765 * 'pc' should be the address of this instruction, it will
4766 * be used to print the target address if this is a relative jump or call
4767 * The function returns the length of this instruction in bytes.
4770 static char intel_syntax
;
4771 static char open_char
;
4772 static char close_char
;
4773 static char separator_char
;
4774 static char scale_char
;
4776 /* Here for backwards compatibility. When gdb stops using
4777 print_insn_i386_att and print_insn_i386_intel these functions can
4778 disappear, and print_insn_i386 be merged into print_insn. */
4780 print_insn_i386_att (bfd_vma pc
, disassemble_info
*info
)
4784 return print_insn (pc
, info
);
4788 print_insn_i386_intel (bfd_vma pc
, disassemble_info
*info
)
4792 return print_insn (pc
, info
);
4796 print_insn_i386 (bfd_vma pc
, disassemble_info
*info
)
4800 return print_insn (pc
, info
);
4804 print_i386_disassembler_options (FILE *stream
)
4806 fprintf (stream
, _("\n\
4807 The following i386/x86-64 specific disassembler options are supported for use\n\
4808 with the -M switch (multiple options should be separated by commas):\n"));
4810 fprintf (stream
, _(" x86-64 Disassemble in 64bit mode\n"));
4811 fprintf (stream
, _(" i386 Disassemble in 32bit mode\n"));
4812 fprintf (stream
, _(" i8086 Disassemble in 16bit mode\n"));
4813 fprintf (stream
, _(" att Display instruction in AT&T syntax\n"));
4814 fprintf (stream
, _(" intel Display instruction in Intel syntax\n"));
4815 fprintf (stream
, _(" addr64 Assume 64bit address size\n"));
4816 fprintf (stream
, _(" addr32 Assume 32bit address size\n"));
4817 fprintf (stream
, _(" addr16 Assume 16bit address size\n"));
4818 fprintf (stream
, _(" data32 Assume 32bit data size\n"));
4819 fprintf (stream
, _(" data16 Assume 16bit data size\n"));
4820 fprintf (stream
, _(" suffix Always display instruction suffix in AT&T syntax\n"));
4823 /* Get a pointer to struct dis386 with a valid name. */
4825 static const struct dis386
*
4826 get_valid_dis386 (const struct dis386
*dp
, disassemble_info
*info
)
4830 if (dp
->name
!= NULL
)
4833 switch (dp
->op
[0].bytemode
)
4836 dp
= &grps
[dp
->op
[1].bytemode
][modrm
.reg
];
4839 case USE_PREFIX_USER_TABLE
:
4841 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
4842 if (prefixes
& PREFIX_REPZ
)
4849 /* We should check PREFIX_REPNZ and PREFIX_REPZ before
4851 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
4852 if (prefixes
& PREFIX_REPNZ
)
4855 repnz_prefix
= NULL
;
4859 used_prefixes
|= (prefixes
& PREFIX_DATA
);
4860 if (prefixes
& PREFIX_DATA
)
4867 dp
= &prefix_user_table
[dp
->op
[1].bytemode
][index
];
4870 case X86_64_SPECIAL
:
4871 index
= address_mode
== mode_64bit
? 1 : 0;
4872 dp
= &x86_64_table
[dp
->op
[1].bytemode
][index
];
4875 case IS_3BYTE_OPCODE
:
4876 FETCH_DATA (info
, codep
+ 2);
4878 dp
= &three_byte_table
[dp
->op
[1].bytemode
][index
];
4879 modrm
.mod
= (*codep
>> 6) & 3;
4880 modrm
.reg
= (*codep
>> 3) & 7;
4881 modrm
.rm
= *codep
& 7;
4884 case USE_OPC_EXT_TABLE
:
4885 index
= modrm
.mod
== 0x3 ? 1 : 0;
4886 dp
= &opc_ext_table
[dp
->op
[1].bytemode
][index
];
4889 case USE_OPC_EXT_RM_TABLE
:
4891 dp
= &opc_ext_rm_table
[dp
->op
[1].bytemode
][index
];
4895 oappend (INTERNAL_DISASSEMBLER_ERROR
);
4899 if (dp
->name
!= NULL
)
4902 return get_valid_dis386 (dp
, info
);
4906 print_insn (bfd_vma pc
, disassemble_info
*info
)
4908 const struct dis386
*dp
;
4910 char *op_txt
[MAX_OPERANDS
];
4914 struct dis_private priv
;
4916 char prefix_obuf
[32];
4919 if (info
->mach
== bfd_mach_x86_64_intel_syntax
4920 || info
->mach
== bfd_mach_x86_64
)
4921 address_mode
= mode_64bit
;
4923 address_mode
= mode_32bit
;
4925 if (intel_syntax
== (char) -1)
4926 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
4927 || info
->mach
== bfd_mach_x86_64_intel_syntax
);
4929 if (info
->mach
== bfd_mach_i386_i386
4930 || info
->mach
== bfd_mach_x86_64
4931 || info
->mach
== bfd_mach_i386_i386_intel_syntax
4932 || info
->mach
== bfd_mach_x86_64_intel_syntax
)
4933 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
4934 else if (info
->mach
== bfd_mach_i386_i8086
)
4935 priv
.orig_sizeflag
= 0;
4939 for (p
= info
->disassembler_options
; p
!= NULL
; )
4941 if (CONST_STRNEQ (p
, "x86-64"))
4943 address_mode
= mode_64bit
;
4944 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
4946 else if (CONST_STRNEQ (p
, "i386"))
4948 address_mode
= mode_32bit
;
4949 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
4951 else if (CONST_STRNEQ (p
, "i8086"))
4953 address_mode
= mode_16bit
;
4954 priv
.orig_sizeflag
= 0;
4956 else if (CONST_STRNEQ (p
, "intel"))
4960 else if (CONST_STRNEQ (p
, "att"))
4964 else if (CONST_STRNEQ (p
, "addr"))
4966 if (address_mode
== mode_64bit
)
4968 if (p
[4] == '3' && p
[5] == '2')
4969 priv
.orig_sizeflag
&= ~AFLAG
;
4970 else if (p
[4] == '6' && p
[5] == '4')
4971 priv
.orig_sizeflag
|= AFLAG
;
4975 if (p
[4] == '1' && p
[5] == '6')
4976 priv
.orig_sizeflag
&= ~AFLAG
;
4977 else if (p
[4] == '3' && p
[5] == '2')
4978 priv
.orig_sizeflag
|= AFLAG
;
4981 else if (CONST_STRNEQ (p
, "data"))
4983 if (p
[4] == '1' && p
[5] == '6')
4984 priv
.orig_sizeflag
&= ~DFLAG
;
4985 else if (p
[4] == '3' && p
[5] == '2')
4986 priv
.orig_sizeflag
|= DFLAG
;
4988 else if (CONST_STRNEQ (p
, "suffix"))
4989 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
4991 p
= strchr (p
, ',');
4998 names64
= intel_names64
;
4999 names32
= intel_names32
;
5000 names16
= intel_names16
;
5001 names8
= intel_names8
;
5002 names8rex
= intel_names8rex
;
5003 names_seg
= intel_names_seg
;
5004 index16
= intel_index16
;
5007 separator_char
= '+';
5012 names64
= att_names64
;
5013 names32
= att_names32
;
5014 names16
= att_names16
;
5015 names8
= att_names8
;
5016 names8rex
= att_names8rex
;
5017 names_seg
= att_names_seg
;
5018 index16
= att_index16
;
5021 separator_char
= ',';
5025 /* The output looks better if we put 7 bytes on a line, since that
5026 puts most long word instructions on a single line. */
5027 info
->bytes_per_line
= 7;
5029 info
->private_data
= &priv
;
5030 priv
.max_fetched
= priv
.the_buffer
;
5031 priv
.insn_start
= pc
;
5034 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
5042 start_codep
= priv
.the_buffer
;
5043 codep
= priv
.the_buffer
;
5045 if (setjmp (priv
.bailout
) != 0)
5049 /* Getting here means we tried for data but didn't get it. That
5050 means we have an incomplete instruction of some sort. Just
5051 print the first byte as a prefix or a .byte pseudo-op. */
5052 if (codep
> priv
.the_buffer
)
5054 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
5056 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
5059 /* Just print the first byte as a .byte instruction. */
5060 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
5061 (unsigned int) priv
.the_buffer
[0]);
5074 sizeflag
= priv
.orig_sizeflag
;
5076 FETCH_DATA (info
, codep
+ 1);
5077 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
5079 if (((prefixes
& PREFIX_FWAIT
)
5080 && ((*codep
< 0xd8) || (*codep
> 0xdf)))
5081 || (rex
&& rex_used
))
5085 /* fwait not followed by floating point instruction, or rex followed
5086 by other prefixes. Print the first prefix. */
5087 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
5089 name
= INTERNAL_DISASSEMBLER_ERROR
;
5090 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
5097 unsigned char threebyte
;
5098 FETCH_DATA (info
, codep
+ 2);
5099 threebyte
= *++codep
;
5100 dp
= &dis386_twobyte
[threebyte
];
5101 need_modrm
= twobyte_has_modrm
[*codep
];
5106 dp
= &dis386
[*codep
];
5107 need_modrm
= onebyte_has_modrm
[*codep
];
5111 if ((prefixes
& PREFIX_REPZ
))
5113 repz_prefix
= "repz ";
5114 used_prefixes
|= PREFIX_REPZ
;
5119 if ((prefixes
& PREFIX_REPNZ
))
5121 repnz_prefix
= "repnz ";
5122 used_prefixes
|= PREFIX_REPNZ
;
5125 repnz_prefix
= NULL
;
5127 if ((prefixes
& PREFIX_LOCK
))
5129 lock_prefix
= "lock ";
5130 used_prefixes
|= PREFIX_LOCK
;
5136 if (prefixes
& PREFIX_ADDR
)
5139 if (dp
->op
[2].bytemode
!= loop_jcxz_mode
|| intel_syntax
)
5141 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
5142 addr_prefix
= "addr32 ";
5144 addr_prefix
= "addr16 ";
5145 used_prefixes
|= PREFIX_ADDR
;
5150 if ((prefixes
& PREFIX_DATA
))
5153 if (dp
->op
[2].bytemode
== cond_jump_mode
5154 && dp
->op
[0].bytemode
== v_mode
5157 if (sizeflag
& DFLAG
)
5158 data_prefix
= "data32 ";
5160 data_prefix
= "data16 ";
5161 used_prefixes
|= PREFIX_DATA
;
5167 FETCH_DATA (info
, codep
+ 1);
5168 modrm
.mod
= (*codep
>> 6) & 3;
5169 modrm
.reg
= (*codep
>> 3) & 7;
5170 modrm
.rm
= *codep
& 7;
5173 if (dp
->name
== NULL
&& dp
->op
[0].bytemode
== FLOATCODE
)
5179 dp
= get_valid_dis386 (dp
, info
);
5180 if (dp
!= NULL
&& putop (dp
->name
, sizeflag
) == 0)
5182 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
5185 op_ad
= MAX_OPERANDS
- 1 - i
;
5187 (*dp
->op
[i
].rtn
) (dp
->op
[i
].bytemode
, sizeflag
);
5192 /* See if any prefixes were not used. If so, print the first one
5193 separately. If we don't do this, we'll wind up printing an
5194 instruction stream which does not precisely correspond to the
5195 bytes we are disassembling. */
5196 if ((prefixes
& ~used_prefixes
) != 0)
5200 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
5202 name
= INTERNAL_DISASSEMBLER_ERROR
;
5203 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
5206 if (rex
& ~rex_used
)
5209 name
= prefix_name (rex
| 0x40, priv
.orig_sizeflag
);
5211 name
= INTERNAL_DISASSEMBLER_ERROR
;
5212 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
5216 prefix_obufp
= prefix_obuf
;
5218 prefix_obufp
= stpcpy (prefix_obufp
, lock_prefix
);
5220 prefix_obufp
= stpcpy (prefix_obufp
, repz_prefix
);
5222 prefix_obufp
= stpcpy (prefix_obufp
, repnz_prefix
);
5224 prefix_obufp
= stpcpy (prefix_obufp
, addr_prefix
);
5226 prefix_obufp
= stpcpy (prefix_obufp
, data_prefix
);
5228 if (prefix_obuf
[0] != 0)
5229 (*info
->fprintf_func
) (info
->stream
, "%s", prefix_obuf
);
5231 obufp
= obuf
+ strlen (obuf
);
5232 for (i
= strlen (obuf
) + strlen (prefix_obuf
); i
< 6; i
++)
5235 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
5237 /* The enter and bound instructions are printed with operands in the same
5238 order as the intel book; everything else is printed in reverse order. */
5239 if (intel_syntax
|| two_source_ops
)
5243 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
5244 op_txt
[i
] = op_out
[i
];
5246 for (i
= 0; i
< (MAX_OPERANDS
>> 1); ++i
)
5248 op_ad
= op_index
[i
];
5249 op_index
[i
] = op_index
[MAX_OPERANDS
- 1 - i
];
5250 op_index
[MAX_OPERANDS
- 1 - i
] = op_ad
;
5251 riprel
= op_riprel
[i
];
5252 op_riprel
[i
] = op_riprel
[MAX_OPERANDS
- 1 - i
];
5253 op_riprel
[MAX_OPERANDS
- 1 - i
] = riprel
;
5258 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
5259 op_txt
[MAX_OPERANDS
- 1 - i
] = op_out
[i
];
5263 for (i
= 0; i
< MAX_OPERANDS
; ++i
)
5267 (*info
->fprintf_func
) (info
->stream
, ",");
5268 if (op_index
[i
] != -1 && !op_riprel
[i
])
5269 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[i
]], info
);
5271 (*info
->fprintf_func
) (info
->stream
, "%s", op_txt
[i
]);
5275 for (i
= 0; i
< MAX_OPERANDS
; i
++)
5276 if (op_index
[i
] != -1 && op_riprel
[i
])
5278 (*info
->fprintf_func
) (info
->stream
, " # ");
5279 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
5280 + op_address
[op_index
[i
]]), info
);
5283 return codep
- priv
.the_buffer
;
5286 static const char *float_mem
[] = {
5361 static const unsigned char float_mem_mode
[] = {
5436 #define ST { OP_ST, 0 }
5437 #define STi { OP_STi, 0 }
5439 #define FGRPd9_2 NULL, { { NULL, 0 } }
5440 #define FGRPd9_4 NULL, { { NULL, 1 } }
5441 #define FGRPd9_5 NULL, { { NULL, 2 } }
5442 #define FGRPd9_6 NULL, { { NULL, 3 } }
5443 #define FGRPd9_7 NULL, { { NULL, 4 } }
5444 #define FGRPda_5 NULL, { { NULL, 5 } }
5445 #define FGRPdb_4 NULL, { { NULL, 6 } }
5446 #define FGRPde_3 NULL, { { NULL, 7 } }
5447 #define FGRPdf_4 NULL, { { NULL, 8 } }
5449 static const struct dis386 float_reg
[][8] = {
5452 { "fadd", { ST
, STi
} },
5453 { "fmul", { ST
, STi
} },
5454 { "fcom", { STi
} },
5455 { "fcomp", { STi
} },
5456 { "fsub", { ST
, STi
} },
5457 { "fsubr", { ST
, STi
} },
5458 { "fdiv", { ST
, STi
} },
5459 { "fdivr", { ST
, STi
} },
5464 { "fxch", { STi
} },
5466 { "(bad)", { XX
} },
5474 { "fcmovb", { ST
, STi
} },
5475 { "fcmove", { ST
, STi
} },
5476 { "fcmovbe",{ ST
, STi
} },
5477 { "fcmovu", { ST
, STi
} },
5478 { "(bad)", { XX
} },
5480 { "(bad)", { XX
} },
5481 { "(bad)", { XX
} },
5485 { "fcmovnb",{ ST
, STi
} },
5486 { "fcmovne",{ ST
, STi
} },
5487 { "fcmovnbe",{ ST
, STi
} },
5488 { "fcmovnu",{ ST
, STi
} },
5490 { "fucomi", { ST
, STi
} },
5491 { "fcomi", { ST
, STi
} },
5492 { "(bad)", { XX
} },
5496 { "fadd", { STi
, ST
} },
5497 { "fmul", { STi
, ST
} },
5498 { "(bad)", { XX
} },
5499 { "(bad)", { XX
} },
5501 { "fsub", { STi
, ST
} },
5502 { "fsubr", { STi
, ST
} },
5503 { "fdiv", { STi
, ST
} },
5504 { "fdivr", { STi
, ST
} },
5506 { "fsubr", { STi
, ST
} },
5507 { "fsub", { STi
, ST
} },
5508 { "fdivr", { STi
, ST
} },
5509 { "fdiv", { STi
, ST
} },
5514 { "ffree", { STi
} },
5515 { "(bad)", { XX
} },
5517 { "fstp", { STi
} },
5518 { "fucom", { STi
} },
5519 { "fucomp", { STi
} },
5520 { "(bad)", { XX
} },
5521 { "(bad)", { XX
} },
5525 { "faddp", { STi
, ST
} },
5526 { "fmulp", { STi
, ST
} },
5527 { "(bad)", { XX
} },
5530 { "fsubp", { STi
, ST
} },
5531 { "fsubrp", { STi
, ST
} },
5532 { "fdivp", { STi
, ST
} },
5533 { "fdivrp", { STi
, ST
} },
5535 { "fsubrp", { STi
, ST
} },
5536 { "fsubp", { STi
, ST
} },
5537 { "fdivrp", { STi
, ST
} },
5538 { "fdivp", { STi
, ST
} },
5543 { "ffreep", { STi
} },
5544 { "(bad)", { XX
} },
5545 { "(bad)", { XX
} },
5546 { "(bad)", { XX
} },
5548 { "fucomip", { ST
, STi
} },
5549 { "fcomip", { ST
, STi
} },
5550 { "(bad)", { XX
} },
5554 static char *fgrps
[][8] = {
5557 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
5562 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
5567 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
5572 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
5577 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
5582 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
5587 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
5588 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
5593 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
5598 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
5603 OP_Skip_MODRM (int bytemode ATTRIBUTE_UNUSED
,
5604 int sizeflag ATTRIBUTE_UNUSED
)
5606 /* Skip mod/rm byte. */
5612 dofloat (int sizeflag
)
5614 const struct dis386
*dp
;
5615 unsigned char floatop
;
5617 floatop
= codep
[-1];
5621 int fp_indx
= (floatop
- 0xd8) * 8 + modrm
.reg
;
5623 putop (float_mem
[fp_indx
], sizeflag
);
5626 OP_E (float_mem_mode
[fp_indx
], sizeflag
);
5629 /* Skip mod/rm byte. */
5633 dp
= &float_reg
[floatop
- 0xd8][modrm
.reg
];
5634 if (dp
->name
== NULL
)
5636 putop (fgrps
[dp
->op
[0].bytemode
][modrm
.rm
], sizeflag
);
5638 /* Instruction fnstsw is only one with strange arg. */
5639 if (floatop
== 0xdf && codep
[-1] == 0xe0)
5640 strcpy (op_out
[0], names16
[0]);
5644 putop (dp
->name
, sizeflag
);
5649 (*dp
->op
[0].rtn
) (dp
->op
[0].bytemode
, sizeflag
);
5654 (*dp
->op
[1].rtn
) (dp
->op
[1].bytemode
, sizeflag
);
5659 OP_ST (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
5661 oappend ("%st" + intel_syntax
);
5665 OP_STi (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
5667 sprintf (scratchbuf
, "%%st(%d)", modrm
.rm
);
5668 oappend (scratchbuf
+ intel_syntax
);
5671 /* Capital letters in template are macros. */
5673 putop (const char *template, int sizeflag
)
5678 for (p
= template; *p
; p
++)
5689 if (address_mode
== mode_64bit
)
5697 /* Alternative not valid. */
5698 strcpy (obuf
, "(bad)");
5702 else if (*p
== '\0')
5723 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
5729 if (sizeflag
& SUFFIX_ALWAYS
)
5733 if (intel_syntax
&& !alt
)
5735 if ((prefixes
& PREFIX_DATA
) || (sizeflag
& SUFFIX_ALWAYS
))
5737 if (sizeflag
& DFLAG
)
5738 *obufp
++ = intel_syntax
? 'd' : 'l';
5740 *obufp
++ = intel_syntax
? 'w' : 's';
5741 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5745 if (intel_syntax
|| !(sizeflag
& SUFFIX_ALWAYS
))
5752 else if (sizeflag
& DFLAG
)
5753 *obufp
++ = intel_syntax
? 'd' : 'l';
5756 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5761 case 'E': /* For jcxz/jecxz */
5762 if (address_mode
== mode_64bit
)
5764 if (sizeflag
& AFLAG
)
5770 if (sizeflag
& AFLAG
)
5772 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
5777 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
5779 if (sizeflag
& AFLAG
)
5780 *obufp
++ = address_mode
== mode_64bit
? 'q' : 'l';
5782 *obufp
++ = address_mode
== mode_64bit
? 'l' : 'w';
5783 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
5787 if (intel_syntax
|| (obufp
[-1] != 's' && !(sizeflag
& SUFFIX_ALWAYS
)))
5789 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
5794 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5799 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
5800 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
5802 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
5805 if (prefixes
& PREFIX_DS
)
5826 if (address_mode
== mode_64bit
&& (sizeflag
& SUFFIX_ALWAYS
))
5835 if (sizeflag
& SUFFIX_ALWAYS
)
5839 if ((prefixes
& PREFIX_FWAIT
) == 0)
5842 used_prefixes
|= PREFIX_FWAIT
;
5848 else if (intel_syntax
&& (sizeflag
& DFLAG
))
5853 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5858 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
5867 if ((prefixes
& PREFIX_DATA
)
5869 || (sizeflag
& SUFFIX_ALWAYS
))
5876 if (sizeflag
& DFLAG
)
5881 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5887 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
5889 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
5895 if (intel_syntax
&& !alt
)
5898 if (modrm
.mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
5904 if (sizeflag
& DFLAG
)
5905 *obufp
++ = intel_syntax
? 'd' : 'l';
5909 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5916 else if (sizeflag
& DFLAG
)
5925 if (intel_syntax
&& !p
[1]
5926 && ((rex
& REX_W
) || (sizeflag
& DFLAG
)))
5929 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5934 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
5936 if (sizeflag
& SUFFIX_ALWAYS
)
5944 if (sizeflag
& SUFFIX_ALWAYS
)
5950 if (sizeflag
& DFLAG
)
5954 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5959 if (prefixes
& PREFIX_DATA
)
5963 used_prefixes
|= (prefixes
& PREFIX_DATA
);
5974 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
5976 /* operand size flag for cwtl, cbtw */
5985 else if (sizeflag
& DFLAG
)
5990 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6000 oappend (const char *s
)
6003 obufp
+= strlen (s
);
6009 if (prefixes
& PREFIX_CS
)
6011 used_prefixes
|= PREFIX_CS
;
6012 oappend ("%cs:" + intel_syntax
);
6014 if (prefixes
& PREFIX_DS
)
6016 used_prefixes
|= PREFIX_DS
;
6017 oappend ("%ds:" + intel_syntax
);
6019 if (prefixes
& PREFIX_SS
)
6021 used_prefixes
|= PREFIX_SS
;
6022 oappend ("%ss:" + intel_syntax
);
6024 if (prefixes
& PREFIX_ES
)
6026 used_prefixes
|= PREFIX_ES
;
6027 oappend ("%es:" + intel_syntax
);
6029 if (prefixes
& PREFIX_FS
)
6031 used_prefixes
|= PREFIX_FS
;
6032 oappend ("%fs:" + intel_syntax
);
6034 if (prefixes
& PREFIX_GS
)
6036 used_prefixes
|= PREFIX_GS
;
6037 oappend ("%gs:" + intel_syntax
);
6042 OP_indirE (int bytemode
, int sizeflag
)
6046 OP_E (bytemode
, sizeflag
);
6050 print_operand_value (char *buf
, int hex
, bfd_vma disp
)
6052 if (address_mode
== mode_64bit
)
6060 sprintf_vma (tmp
, disp
);
6061 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
6062 strcpy (buf
+ 2, tmp
+ i
);
6066 bfd_signed_vma v
= disp
;
6073 /* Check for possible overflow on 0x8000000000000000. */
6076 strcpy (buf
, "9223372036854775808");
6090 tmp
[28 - i
] = (v
% 10) + '0';
6094 strcpy (buf
, tmp
+ 29 - i
);
6100 sprintf (buf
, "0x%x", (unsigned int) disp
);
6102 sprintf (buf
, "%d", (int) disp
);
6106 /* Put DISP in BUF as signed hex number. */
6109 print_displacement (char *buf
, bfd_vma disp
)
6111 bfd_signed_vma val
= disp
;
6120 /* Check for possible overflow. */
6123 switch (address_mode
)
6126 strcpy (buf
+ j
, "0x8000000000000000");
6129 strcpy (buf
+ j
, "0x80000000");
6132 strcpy (buf
+ j
, "0x8000");
6142 sprintf_vma (tmp
, val
);
6143 for (i
= 0; tmp
[i
] == '0'; i
++)
6147 strcpy (buf
+ j
, tmp
+ i
);
6151 intel_operand_size (int bytemode
, int sizeflag
)
6157 oappend ("BYTE PTR ");
6161 oappend ("WORD PTR ");
6164 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
6166 oappend ("QWORD PTR ");
6167 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6175 oappend ("QWORD PTR ");
6176 else if ((sizeflag
& DFLAG
) || bytemode
== dq_mode
)
6177 oappend ("DWORD PTR ");
6179 oappend ("WORD PTR ");
6180 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6183 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
6185 oappend ("WORD PTR ");
6187 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6191 oappend ("DWORD PTR ");
6194 oappend ("QWORD PTR ");
6197 if (address_mode
== mode_64bit
)
6198 oappend ("QWORD PTR ");
6200 oappend ("DWORD PTR ");
6203 if (sizeflag
& DFLAG
)
6204 oappend ("FWORD PTR ");
6206 oappend ("DWORD PTR ");
6207 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6210 oappend ("TBYTE PTR ");
6213 oappend ("XMMWORD PTR ");
6216 oappend ("OWORD PTR ");
6224 OP_E_extended (int bytemode
, int sizeflag
, int has_drex
)
6233 /* Skip mod/rm byte. */
6244 oappend (names8rex
[modrm
.rm
+ add
]);
6246 oappend (names8
[modrm
.rm
+ add
]);
6249 oappend (names16
[modrm
.rm
+ add
]);
6252 oappend (names32
[modrm
.rm
+ add
]);
6255 oappend (names64
[modrm
.rm
+ add
]);
6258 if (address_mode
== mode_64bit
)
6259 oappend (names64
[modrm
.rm
+ add
]);
6261 oappend (names32
[modrm
.rm
+ add
]);
6264 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
6266 oappend (names64
[modrm
.rm
+ add
]);
6267 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6279 oappend (names64
[modrm
.rm
+ add
]);
6280 else if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
6281 oappend (names32
[modrm
.rm
+ add
]);
6283 oappend (names16
[modrm
.rm
+ add
]);
6284 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6289 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6297 intel_operand_size (bytemode
, sizeflag
);
6300 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
6302 /* 32/64 bit address mode */
6317 FETCH_DATA (the_info
, codep
+ 1);
6318 index
= (*codep
>> 3) & 7;
6319 if (address_mode
== mode_64bit
|| index
!= 0x4)
6320 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
6321 scale
= (*codep
>> 6) & 3;
6330 /* If we have a DREX byte, skip it now
6331 (it has already been handled) */
6334 FETCH_DATA (the_info
, codep
+ 1);
6341 if ((base
& 7) == 5)
6344 if (address_mode
== mode_64bit
&& !havesib
)
6350 FETCH_DATA (the_info
, codep
+ 1);
6352 if ((disp
& 0x80) != 0)
6360 havedisp
= havebase
|| (havesib
&& (index
!= 4 || scale
!= 0));
6363 if (modrm
.mod
!= 0 || (base
& 7) == 5)
6365 if (havedisp
|| riprel
)
6366 print_displacement (scratchbuf
, disp
);
6368 print_operand_value (scratchbuf
, 1, disp
);
6369 oappend (scratchbuf
);
6377 if (havedisp
|| (intel_syntax
&& riprel
))
6379 *obufp
++ = open_char
;
6380 if (intel_syntax
&& riprel
)
6387 oappend (address_mode
== mode_64bit
&& (sizeflag
& AFLAG
)
6388 ? names64
[base
] : names32
[base
]);
6393 if (!intel_syntax
|| havebase
)
6395 *obufp
++ = separator_char
;
6398 oappend (address_mode
== mode_64bit
6399 && (sizeflag
& AFLAG
)
6400 ? names64
[index
] : names32
[index
]);
6402 if (scale
!= 0 || (!intel_syntax
&& index
!= 4))
6404 *obufp
++ = scale_char
;
6406 sprintf (scratchbuf
, "%d", 1 << scale
);
6407 oappend (scratchbuf
);
6411 && (disp
|| modrm
.mod
!= 0 || (base
& 7) == 5))
6413 if ((bfd_signed_vma
) disp
>= 0)
6418 else if (modrm
.mod
!= 1)
6422 disp
= - (bfd_signed_vma
) disp
;
6425 print_displacement (scratchbuf
, disp
);
6426 oappend (scratchbuf
);
6429 *obufp
++ = close_char
;
6432 else if (intel_syntax
)
6434 if (modrm
.mod
!= 0 || (base
& 7) == 5)
6436 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
6437 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
6441 oappend (names_seg
[ds_reg
- es_reg
]);
6444 print_operand_value (scratchbuf
, 1, disp
);
6445 oappend (scratchbuf
);
6450 { /* 16 bit address mode */
6457 if ((disp
& 0x8000) != 0)
6462 FETCH_DATA (the_info
, codep
+ 1);
6464 if ((disp
& 0x80) != 0)
6469 if ((disp
& 0x8000) != 0)
6475 if (modrm
.mod
!= 0 || modrm
.rm
== 6)
6477 print_displacement (scratchbuf
, disp
);
6478 oappend (scratchbuf
);
6481 if (modrm
.mod
!= 0 || modrm
.rm
!= 6)
6483 *obufp
++ = open_char
;
6485 oappend (index16
[modrm
.rm
]);
6487 && (disp
|| modrm
.mod
!= 0 || modrm
.rm
== 6))
6489 if ((bfd_signed_vma
) disp
>= 0)
6494 else if (modrm
.mod
!= 1)
6498 disp
= - (bfd_signed_vma
) disp
;
6501 print_displacement (scratchbuf
, disp
);
6502 oappend (scratchbuf
);
6505 *obufp
++ = close_char
;
6508 else if (intel_syntax
)
6510 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
6511 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
6515 oappend (names_seg
[ds_reg
- es_reg
]);
6518 print_operand_value (scratchbuf
, 1, disp
& 0xffff);
6519 oappend (scratchbuf
);
6525 OP_E (int bytemode
, int sizeflag
)
6527 OP_E_extended (bytemode
, sizeflag
, 0);
6532 OP_G (int bytemode
, int sizeflag
)
6543 oappend (names8rex
[modrm
.reg
+ add
]);
6545 oappend (names8
[modrm
.reg
+ add
]);
6548 oappend (names16
[modrm
.reg
+ add
]);
6551 oappend (names32
[modrm
.reg
+ add
]);
6554 oappend (names64
[modrm
.reg
+ add
]);
6563 oappend (names64
[modrm
.reg
+ add
]);
6564 else if ((sizeflag
& DFLAG
) || bytemode
!= v_mode
)
6565 oappend (names32
[modrm
.reg
+ add
]);
6567 oappend (names16
[modrm
.reg
+ add
]);
6568 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6571 if (address_mode
== mode_64bit
)
6572 oappend (names64
[modrm
.reg
+ add
]);
6574 oappend (names32
[modrm
.reg
+ add
]);
6577 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6590 FETCH_DATA (the_info
, codep
+ 8);
6591 a
= *codep
++ & 0xff;
6592 a
|= (*codep
++ & 0xff) << 8;
6593 a
|= (*codep
++ & 0xff) << 16;
6594 a
|= (*codep
++ & 0xff) << 24;
6595 b
= *codep
++ & 0xff;
6596 b
|= (*codep
++ & 0xff) << 8;
6597 b
|= (*codep
++ & 0xff) << 16;
6598 b
|= (*codep
++ & 0xff) << 24;
6599 x
= a
+ ((bfd_vma
) b
<< 32);
6607 static bfd_signed_vma
6610 bfd_signed_vma x
= 0;
6612 FETCH_DATA (the_info
, codep
+ 4);
6613 x
= *codep
++ & (bfd_signed_vma
) 0xff;
6614 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
6615 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
6616 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
6620 static bfd_signed_vma
6623 bfd_signed_vma x
= 0;
6625 FETCH_DATA (the_info
, codep
+ 4);
6626 x
= *codep
++ & (bfd_signed_vma
) 0xff;
6627 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
6628 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
6629 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
6631 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
6641 FETCH_DATA (the_info
, codep
+ 2);
6642 x
= *codep
++ & 0xff;
6643 x
|= (*codep
++ & 0xff) << 8;
6648 set_op (bfd_vma op
, int riprel
)
6650 op_index
[op_ad
] = op_ad
;
6651 if (address_mode
== mode_64bit
)
6653 op_address
[op_ad
] = op
;
6654 op_riprel
[op_ad
] = riprel
;
6658 /* Mask to get a 32-bit address. */
6659 op_address
[op_ad
] = op
& 0xffffffff;
6660 op_riprel
[op_ad
] = riprel
& 0xffffffff;
6665 OP_REG (int code
, int sizeflag
)
6675 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
6676 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
6677 s
= names16
[code
- ax_reg
+ add
];
6679 case es_reg
: case ss_reg
: case cs_reg
:
6680 case ds_reg
: case fs_reg
: case gs_reg
:
6681 s
= names_seg
[code
- es_reg
+ add
];
6683 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
6684 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
6687 s
= names8rex
[code
- al_reg
+ add
];
6689 s
= names8
[code
- al_reg
];
6691 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
6692 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
6693 if (address_mode
== mode_64bit
&& (sizeflag
& DFLAG
))
6695 s
= names64
[code
- rAX_reg
+ add
];
6698 code
+= eAX_reg
- rAX_reg
;
6700 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
6701 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
6704 s
= names64
[code
- eAX_reg
+ add
];
6705 else if (sizeflag
& DFLAG
)
6706 s
= names32
[code
- eAX_reg
+ add
];
6708 s
= names16
[code
- eAX_reg
+ add
];
6709 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6712 s
= INTERNAL_DISASSEMBLER_ERROR
;
6719 OP_IMREG (int code
, int sizeflag
)
6731 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
6732 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
6733 s
= names16
[code
- ax_reg
];
6735 case es_reg
: case ss_reg
: case cs_reg
:
6736 case ds_reg
: case fs_reg
: case gs_reg
:
6737 s
= names_seg
[code
- es_reg
];
6739 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
6740 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
6743 s
= names8rex
[code
- al_reg
];
6745 s
= names8
[code
- al_reg
];
6747 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
6748 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
6751 s
= names64
[code
- eAX_reg
];
6752 else if (sizeflag
& DFLAG
)
6753 s
= names32
[code
- eAX_reg
];
6755 s
= names16
[code
- eAX_reg
];
6756 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6759 if ((rex
& REX_W
) || (sizeflag
& DFLAG
))
6764 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6767 s
= INTERNAL_DISASSEMBLER_ERROR
;
6774 OP_I (int bytemode
, int sizeflag
)
6777 bfd_signed_vma mask
= -1;
6782 FETCH_DATA (the_info
, codep
+ 1);
6787 if (address_mode
== mode_64bit
)
6797 else if (sizeflag
& DFLAG
)
6807 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6818 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6823 scratchbuf
[0] = '$';
6824 print_operand_value (scratchbuf
+ 1, 1, op
);
6825 oappend (scratchbuf
+ intel_syntax
);
6826 scratchbuf
[0] = '\0';
6830 OP_I64 (int bytemode
, int sizeflag
)
6833 bfd_signed_vma mask
= -1;
6835 if (address_mode
!= mode_64bit
)
6837 OP_I (bytemode
, sizeflag
);
6844 FETCH_DATA (the_info
, codep
+ 1);
6852 else if (sizeflag
& DFLAG
)
6862 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6869 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6874 scratchbuf
[0] = '$';
6875 print_operand_value (scratchbuf
+ 1, 1, op
);
6876 oappend (scratchbuf
+ intel_syntax
);
6877 scratchbuf
[0] = '\0';
6881 OP_sI (int bytemode
, int sizeflag
)
6884 bfd_signed_vma mask
= -1;
6889 FETCH_DATA (the_info
, codep
+ 1);
6891 if ((op
& 0x80) != 0)
6899 else if (sizeflag
& DFLAG
)
6908 if ((op
& 0x8000) != 0)
6911 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6916 if ((op
& 0x8000) != 0)
6920 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6924 scratchbuf
[0] = '$';
6925 print_operand_value (scratchbuf
+ 1, 1, op
);
6926 oappend (scratchbuf
+ intel_syntax
);
6930 OP_J (int bytemode
, int sizeflag
)
6934 bfd_vma segment
= 0;
6939 FETCH_DATA (the_info
, codep
+ 1);
6941 if ((disp
& 0x80) != 0)
6945 if ((sizeflag
& DFLAG
) || (rex
& REX_W
))
6950 if ((disp
& 0x8000) != 0)
6952 /* In 16bit mode, address is wrapped around at 64k within
6953 the same segment. Otherwise, a data16 prefix on a jump
6954 instruction means that the pc is masked to 16 bits after
6955 the displacement is added! */
6957 if ((prefixes
& PREFIX_DATA
) == 0)
6958 segment
= ((start_pc
+ codep
- start_codep
)
6959 & ~((bfd_vma
) 0xffff));
6961 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6964 oappend (INTERNAL_DISASSEMBLER_ERROR
);
6967 disp
= ((start_pc
+ codep
- start_codep
+ disp
) & mask
) | segment
;
6969 print_operand_value (scratchbuf
, 1, disp
);
6970 oappend (scratchbuf
);
6974 OP_SEG (int bytemode
, int sizeflag
)
6976 if (bytemode
== w_mode
)
6977 oappend (names_seg
[modrm
.reg
]);
6979 OP_E (modrm
.mod
== 3 ? bytemode
: w_mode
, sizeflag
);
6983 OP_DIR (int dummy ATTRIBUTE_UNUSED
, int sizeflag
)
6987 if (sizeflag
& DFLAG
)
6997 used_prefixes
|= (prefixes
& PREFIX_DATA
);
6999 sprintf (scratchbuf
, "0x%x:0x%x", seg
, offset
);
7001 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
7002 oappend (scratchbuf
);
7006 OP_OFF (int bytemode
, int sizeflag
)
7010 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
7011 intel_operand_size (bytemode
, sizeflag
);
7014 if ((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
7021 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
7022 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
7024 oappend (names_seg
[ds_reg
- es_reg
]);
7028 print_operand_value (scratchbuf
, 1, off
);
7029 oappend (scratchbuf
);
7033 OP_OFF64 (int bytemode
, int sizeflag
)
7037 if (address_mode
!= mode_64bit
7038 || (prefixes
& PREFIX_ADDR
))
7040 OP_OFF (bytemode
, sizeflag
);
7044 if (intel_syntax
&& (sizeflag
& SUFFIX_ALWAYS
))
7045 intel_operand_size (bytemode
, sizeflag
);
7052 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
7053 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
7055 oappend (names_seg
[ds_reg
- es_reg
]);
7059 print_operand_value (scratchbuf
, 1, off
);
7060 oappend (scratchbuf
);
7064 ptr_reg (int code
, int sizeflag
)
7068 *obufp
++ = open_char
;
7069 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
7070 if (address_mode
== mode_64bit
)
7072 if (!(sizeflag
& AFLAG
))
7073 s
= names32
[code
- eAX_reg
];
7075 s
= names64
[code
- eAX_reg
];
7077 else if (sizeflag
& AFLAG
)
7078 s
= names32
[code
- eAX_reg
];
7080 s
= names16
[code
- eAX_reg
];
7082 *obufp
++ = close_char
;
7087 OP_ESreg (int code
, int sizeflag
)
7093 case 0x6d: /* insw/insl */
7094 intel_operand_size (z_mode
, sizeflag
);
7096 case 0xa5: /* movsw/movsl/movsq */
7097 case 0xa7: /* cmpsw/cmpsl/cmpsq */
7098 case 0xab: /* stosw/stosl */
7099 case 0xaf: /* scasw/scasl */
7100 intel_operand_size (v_mode
, sizeflag
);
7103 intel_operand_size (b_mode
, sizeflag
);
7106 oappend ("%es:" + intel_syntax
);
7107 ptr_reg (code
, sizeflag
);
7111 OP_DSreg (int code
, int sizeflag
)
7117 case 0x6f: /* outsw/outsl */
7118 intel_operand_size (z_mode
, sizeflag
);
7120 case 0xa5: /* movsw/movsl/movsq */
7121 case 0xa7: /* cmpsw/cmpsl/cmpsq */
7122 case 0xad: /* lodsw/lodsl/lodsq */
7123 intel_operand_size (v_mode
, sizeflag
);
7126 intel_operand_size (b_mode
, sizeflag
);
7136 prefixes
|= PREFIX_DS
;
7138 ptr_reg (code
, sizeflag
);
7142 OP_C (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7150 else if (address_mode
!= mode_64bit
&& (prefixes
& PREFIX_LOCK
))
7153 used_prefixes
|= PREFIX_LOCK
;
7156 sprintf (scratchbuf
, "%%cr%d", modrm
.reg
+ add
);
7157 oappend (scratchbuf
+ intel_syntax
);
7161 OP_D (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7168 sprintf (scratchbuf
, "db%d", modrm
.reg
+ add
);
7170 sprintf (scratchbuf
, "%%db%d", modrm
.reg
+ add
);
7171 oappend (scratchbuf
);
7175 OP_T (int dummy ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7177 sprintf (scratchbuf
, "%%tr%d", modrm
.reg
);
7178 oappend (scratchbuf
+ intel_syntax
);
7182 OP_R (int bytemode
, int sizeflag
)
7185 OP_E (bytemode
, sizeflag
);
7191 OP_MMX (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7193 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7194 if (prefixes
& PREFIX_DATA
)
7200 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
7203 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
7204 oappend (scratchbuf
+ intel_syntax
);
7208 OP_XMM (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7214 sprintf (scratchbuf
, "%%xmm%d", modrm
.reg
+ add
);
7215 oappend (scratchbuf
+ intel_syntax
);
7219 OP_EM (int bytemode
, int sizeflag
)
7223 if (intel_syntax
&& bytemode
== v_mode
)
7225 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
7226 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7228 OP_E (bytemode
, sizeflag
);
7232 /* Skip mod/rm byte. */
7235 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7236 if (prefixes
& PREFIX_DATA
)
7243 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
7246 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
7247 oappend (scratchbuf
+ intel_syntax
);
7250 /* cvt* are the only instructions in sse2 which have
7251 both SSE and MMX operands and also have 0x66 prefix
7252 in their opcode. 0x66 was originally used to differentiate
7253 between SSE and MMX instruction(operands). So we have to handle the
7254 cvt* separately using OP_EMC and OP_MXC */
7256 OP_EMC (int bytemode
, int sizeflag
)
7260 if (intel_syntax
&& bytemode
== v_mode
)
7262 bytemode
= (prefixes
& PREFIX_DATA
) ? x_mode
: q_mode
;
7263 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7265 OP_E (bytemode
, sizeflag
);
7269 /* Skip mod/rm byte. */
7272 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7273 sprintf (scratchbuf
, "%%mm%d", modrm
.rm
);
7274 oappend (scratchbuf
+ intel_syntax
);
7278 OP_MXC (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7280 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7281 sprintf (scratchbuf
, "%%mm%d", modrm
.reg
);
7282 oappend (scratchbuf
+ intel_syntax
);
7286 OP_EX (int bytemode
, int sizeflag
)
7291 OP_E (bytemode
, sizeflag
);
7298 /* Skip mod/rm byte. */
7301 sprintf (scratchbuf
, "%%xmm%d", modrm
.rm
+ add
);
7302 oappend (scratchbuf
+ intel_syntax
);
7306 OP_MS (int bytemode
, int sizeflag
)
7309 OP_EM (bytemode
, sizeflag
);
7315 OP_XS (int bytemode
, int sizeflag
)
7318 OP_EX (bytemode
, sizeflag
);
7324 OP_M (int bytemode
, int sizeflag
)
7327 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
7330 OP_E (bytemode
, sizeflag
);
7334 OP_0f07 (int bytemode
, int sizeflag
)
7336 if (modrm
.mod
!= 3 || modrm
.rm
!= 0)
7339 OP_E (bytemode
, sizeflag
);
7342 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
7343 32bit mode and "xchg %rax,%rax" in 64bit mode. */
7346 NOP_Fixup1 (int bytemode
, int sizeflag
)
7348 if ((prefixes
& PREFIX_DATA
) != 0
7351 && address_mode
== mode_64bit
))
7352 OP_REG (bytemode
, sizeflag
);
7354 strcpy (obuf
, "nop");
7358 NOP_Fixup2 (int bytemode
, int sizeflag
)
7360 if ((prefixes
& PREFIX_DATA
) != 0
7363 && address_mode
== mode_64bit
))
7364 OP_IMREG (bytemode
, sizeflag
);
7367 static const char *const Suffix3DNow
[] = {
7368 /* 00 */ NULL
, NULL
, NULL
, NULL
,
7369 /* 04 */ NULL
, NULL
, NULL
, NULL
,
7370 /* 08 */ NULL
, NULL
, NULL
, NULL
,
7371 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
7372 /* 10 */ NULL
, NULL
, NULL
, NULL
,
7373 /* 14 */ NULL
, NULL
, NULL
, NULL
,
7374 /* 18 */ NULL
, NULL
, NULL
, NULL
,
7375 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
7376 /* 20 */ NULL
, NULL
, NULL
, NULL
,
7377 /* 24 */ NULL
, NULL
, NULL
, NULL
,
7378 /* 28 */ NULL
, NULL
, NULL
, NULL
,
7379 /* 2C */ NULL
, NULL
, NULL
, NULL
,
7380 /* 30 */ NULL
, NULL
, NULL
, NULL
,
7381 /* 34 */ NULL
, NULL
, NULL
, NULL
,
7382 /* 38 */ NULL
, NULL
, NULL
, NULL
,
7383 /* 3C */ NULL
, NULL
, NULL
, NULL
,
7384 /* 40 */ NULL
, NULL
, NULL
, NULL
,
7385 /* 44 */ NULL
, NULL
, NULL
, NULL
,
7386 /* 48 */ NULL
, NULL
, NULL
, NULL
,
7387 /* 4C */ NULL
, NULL
, NULL
, NULL
,
7388 /* 50 */ NULL
, NULL
, NULL
, NULL
,
7389 /* 54 */ NULL
, NULL
, NULL
, NULL
,
7390 /* 58 */ NULL
, NULL
, NULL
, NULL
,
7391 /* 5C */ NULL
, NULL
, NULL
, NULL
,
7392 /* 60 */ NULL
, NULL
, NULL
, NULL
,
7393 /* 64 */ NULL
, NULL
, NULL
, NULL
,
7394 /* 68 */ NULL
, NULL
, NULL
, NULL
,
7395 /* 6C */ NULL
, NULL
, NULL
, NULL
,
7396 /* 70 */ NULL
, NULL
, NULL
, NULL
,
7397 /* 74 */ NULL
, NULL
, NULL
, NULL
,
7398 /* 78 */ NULL
, NULL
, NULL
, NULL
,
7399 /* 7C */ NULL
, NULL
, NULL
, NULL
,
7400 /* 80 */ NULL
, NULL
, NULL
, NULL
,
7401 /* 84 */ NULL
, NULL
, NULL
, NULL
,
7402 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
7403 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
7404 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
7405 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
7406 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
7407 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
7408 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
7409 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
7410 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
7411 /* AC */ NULL
, NULL
, "pfacc", NULL
,
7412 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
7413 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pmulhrw",
7414 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
7415 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
7416 /* C0 */ NULL
, NULL
, NULL
, NULL
,
7417 /* C4 */ NULL
, NULL
, NULL
, NULL
,
7418 /* C8 */ NULL
, NULL
, NULL
, NULL
,
7419 /* CC */ NULL
, NULL
, NULL
, NULL
,
7420 /* D0 */ NULL
, NULL
, NULL
, NULL
,
7421 /* D4 */ NULL
, NULL
, NULL
, NULL
,
7422 /* D8 */ NULL
, NULL
, NULL
, NULL
,
7423 /* DC */ NULL
, NULL
, NULL
, NULL
,
7424 /* E0 */ NULL
, NULL
, NULL
, NULL
,
7425 /* E4 */ NULL
, NULL
, NULL
, NULL
,
7426 /* E8 */ NULL
, NULL
, NULL
, NULL
,
7427 /* EC */ NULL
, NULL
, NULL
, NULL
,
7428 /* F0 */ NULL
, NULL
, NULL
, NULL
,
7429 /* F4 */ NULL
, NULL
, NULL
, NULL
,
7430 /* F8 */ NULL
, NULL
, NULL
, NULL
,
7431 /* FC */ NULL
, NULL
, NULL
, NULL
,
7435 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7437 const char *mnemonic
;
7439 FETCH_DATA (the_info
, codep
+ 1);
7440 /* AMD 3DNow! instructions are specified by an opcode suffix in the
7441 place where an 8-bit immediate would normally go. ie. the last
7442 byte of the instruction. */
7443 obufp
= obuf
+ strlen (obuf
);
7444 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
7449 /* Since a variable sized modrm/sib chunk is between the start
7450 of the opcode (0x0f0f) and the opcode suffix, we need to do
7451 all the modrm processing first, and don't know until now that
7452 we have a bad opcode. This necessitates some cleaning up. */
7453 op_out
[0][0] = '\0';
7454 op_out
[1][0] = '\0';
7459 static const char *simd_cmp_op
[] = {
7471 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED
, int sizeflag ATTRIBUTE_UNUSED
)
7473 unsigned int cmp_type
;
7475 FETCH_DATA (the_info
, codep
+ 1);
7476 obufp
= obuf
+ strlen (obuf
);
7477 cmp_type
= *codep
++ & 0xff;
7480 char suffix1
= 'p', suffix2
= 's';
7481 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
7482 if (prefixes
& PREFIX_REPZ
)
7486 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7487 if (prefixes
& PREFIX_DATA
)
7491 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
7492 if (prefixes
& PREFIX_REPNZ
)
7493 suffix1
= 's', suffix2
= 'd';
7496 sprintf (scratchbuf
, "cmp%s%c%c",
7497 simd_cmp_op
[cmp_type
], suffix1
, suffix2
);
7498 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
7499 oappend (scratchbuf
);
7503 /* We have a bad extension byte. Clean up. */
7504 op_out
[0][0] = '\0';
7505 op_out
[1][0] = '\0';
7511 OP_Mwait (int bytemode ATTRIBUTE_UNUSED
,
7512 int sizeflag ATTRIBUTE_UNUSED
)
7514 /* mwait %eax,%ecx */
7517 const char **names
= (address_mode
== mode_64bit
7518 ? names64
: names32
);
7519 strcpy (op_out
[0], names
[0]);
7520 strcpy (op_out
[1], names
[1]);
7523 /* Skip mod/rm byte. */
7529 OP_Monitor (int bytemode ATTRIBUTE_UNUSED
,
7530 int sizeflag ATTRIBUTE_UNUSED
)
7532 /* monitor %eax,%ecx,%edx" */
7535 const char **op1_names
;
7536 const char **names
= (address_mode
== mode_64bit
7537 ? names64
: names32
);
7539 if (!(prefixes
& PREFIX_ADDR
))
7540 op1_names
= (address_mode
== mode_16bit
7544 /* Remove "addr16/addr32". */
7546 op1_names
= (address_mode
!= mode_32bit
7547 ? names32
: names16
);
7548 used_prefixes
|= PREFIX_ADDR
;
7550 strcpy (op_out
[0], op1_names
[0]);
7551 strcpy (op_out
[1], names
[1]);
7552 strcpy (op_out
[2], names
[2]);
7555 /* Skip mod/rm byte. */
7563 /* Throw away prefixes and 1st. opcode byte. */
7564 codep
= insn_codep
+ 1;
7569 REP_Fixup (int bytemode
, int sizeflag
)
7571 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
7573 if (prefixes
& PREFIX_REPZ
)
7574 repz_prefix
= "rep ";
7581 OP_IMREG (bytemode
, sizeflag
);
7584 OP_ESreg (bytemode
, sizeflag
);
7587 OP_DSreg (bytemode
, sizeflag
);
7596 CMPXCHG8B_Fixup (int bytemode
, int sizeflag
)
7601 /* Change cmpxchg8b to cmpxchg16b. */
7602 char *p
= obuf
+ strlen (obuf
) - 2;
7606 OP_M (bytemode
, sizeflag
);
7610 XMM_Fixup (int reg
, int sizeflag ATTRIBUTE_UNUSED
)
7612 sprintf (scratchbuf
, "%%xmm%d", reg
);
7613 oappend (scratchbuf
+ intel_syntax
);
7617 CRC32_Fixup (int bytemode
, int sizeflag
)
7619 /* Add proper suffix to "crc32". */
7620 char *p
= obuf
+ strlen (obuf
);
7637 else if (sizeflag
& DFLAG
)
7641 used_prefixes
|= (prefixes
& PREFIX_DATA
);
7644 oappend (INTERNAL_DISASSEMBLER_ERROR
);
7653 /* Skip mod/rm byte. */
7658 add
= (rex
& REX_B
) ? 8 : 0;
7659 if (bytemode
== b_mode
)
7663 oappend (names8rex
[modrm
.rm
+ add
]);
7665 oappend (names8
[modrm
.rm
+ add
]);
7671 oappend (names64
[modrm
.rm
+ add
]);
7672 else if ((prefixes
& PREFIX_DATA
))
7673 oappend (names16
[modrm
.rm
+ add
]);
7675 oappend (names32
[modrm
.rm
+ add
]);
7679 OP_E (bytemode
, sizeflag
);
7682 /* Print a DREX argument as either a register or memory operation. */
7684 print_drex_arg (unsigned int reg
, int bytemode
, int sizeflag
)
7686 if (reg
== DREX_REG_UNKNOWN
)
7689 else if (reg
!= DREX_REG_MEMORY
)
7691 sprintf (scratchbuf
, "%%xmm%d", reg
);
7692 oappend (scratchbuf
+ intel_syntax
);
7696 OP_E_extended (bytemode
, sizeflag
, 1);
7699 /* SSE5 instructions that have 4 arguments are encoded as:
7700 0f 24 <sub-opcode> <modrm> <optional-sib> <drex> <offset>.
7702 The <sub-opcode> byte has 1 bit (0x4) that is combined with 1 bit in
7703 the DREX field (0x8) to determine how the arguments are laid out.
7704 The destination register must be the same register as one of the
7705 inputs, and it is encoded in the DREX byte. No REX prefix is used
7706 for these instructions, since the DREX field contains the 3 extension
7707 bits provided by the REX prefix.
7709 The bytemode argument adds 2 extra bits for passing extra information:
7710 DREX_OC1 -- Set the OC1 bit to indicate dest == 1st arg
7711 DREX_NO_OC0 -- OC0 in DREX is invalid
7712 (but pretend it is set). */
7715 OP_DREX4 (int flag_bytemode
, int sizeflag
)
7717 unsigned int drex_byte
;
7718 unsigned int regs
[4];
7719 unsigned int modrm_regmem
;
7720 unsigned int modrm_reg
;
7721 unsigned int drex_reg
;
7724 int rex_used_save
= rex_used
;
7726 int oc1
= (flag_bytemode
& DREX_OC1
) ? 2 : 0;
7730 bytemode
= flag_bytemode
& ~ DREX_MASK
;
7732 for (i
= 0; i
< 4; i
++)
7733 regs
[i
] = DREX_REG_UNKNOWN
;
7735 /* Determine if we have a SIB byte in addition to MODRM before the
7737 if (((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
7742 /* Get the DREX byte. */
7743 FETCH_DATA (the_info
, codep
+ 2 + has_sib
);
7744 drex_byte
= codep
[has_sib
+1];
7745 drex_reg
= DREX_XMM (drex_byte
);
7746 modrm_reg
= modrm
.reg
+ ((drex_byte
& REX_R
) ? 8 : 0);
7748 /* Is OC0 legal? If not, hardwire oc0 == 1. */
7749 if (flag_bytemode
& DREX_NO_OC0
)
7752 if (DREX_OC0 (drex_byte
))
7756 oc0
= DREX_OC0 (drex_byte
);
7760 /* regmem == register */
7761 modrm_regmem
= modrm
.rm
+ ((drex_byte
& REX_B
) ? 8 : 0);
7763 /* skip modrm/drex since we don't call OP_E_extended */
7768 /* regmem == memory, fill in appropriate REX bits */
7769 modrm_regmem
= DREX_REG_MEMORY
;
7770 rex
= drex_byte
& (REX_B
| REX_X
| REX_R
);
7776 /* Based on the OC1/OC0 bits, lay out the arguments in the correct
7785 regs
[0] = modrm_regmem
;
7786 regs
[1] = modrm_reg
;
7792 regs
[0] = modrm_reg
;
7793 regs
[1] = modrm_regmem
;
7800 regs
[1] = modrm_regmem
;
7801 regs
[2] = modrm_reg
;
7807 regs
[1] = modrm_reg
;
7808 regs
[2] = modrm_regmem
;
7813 /* Print out the arguments. */
7814 for (i
= 0; i
< 4; i
++)
7816 int j
= (intel_syntax
) ? 3 - i
: i
;
7823 print_drex_arg (regs
[j
], bytemode
, sizeflag
);
7827 rex_used
= rex_used_save
;
7830 /* SSE5 instructions that have 3 arguments, and are encoded as:
7831 0f 24 <sub-opcode> <modrm> <optional-sib> <drex> <offset> (or)
7832 0f 25 <sub-opcode> <modrm> <optional-sib> <drex> <offset> <cmp-byte>
7834 The DREX field has 1 bit (0x8) to determine how the arguments are
7835 laid out. The destination register is encoded in the DREX byte.
7836 No REX prefix is used for these instructions, since the DREX field
7837 contains the 3 extension bits provided by the REX prefix. */
7840 OP_DREX3 (int flag_bytemode
, int sizeflag
)
7842 unsigned int drex_byte
;
7843 unsigned int regs
[3];
7844 unsigned int modrm_regmem
;
7845 unsigned int modrm_reg
;
7846 unsigned int drex_reg
;
7849 int rex_used_save
= rex_used
;
7854 bytemode
= flag_bytemode
& ~ DREX_MASK
;
7856 for (i
= 0; i
< 3; i
++)
7857 regs
[i
] = DREX_REG_UNKNOWN
;
7859 /* Determine if we have a SIB byte in addition to MODRM before the
7861 if (((sizeflag
& AFLAG
) || address_mode
== mode_64bit
)
7866 /* Get the DREX byte. */
7867 FETCH_DATA (the_info
, codep
+ 2 + has_sib
);
7868 drex_byte
= codep
[has_sib
+1];
7869 drex_reg
= DREX_XMM (drex_byte
);
7870 modrm_reg
= modrm
.reg
+ ((drex_byte
& REX_R
) ? 8 : 0);
7872 /* Is OC0 legal? If not, hardwire oc0 == 0 */
7873 oc0
= DREX_OC0 (drex_byte
);
7874 if ((flag_bytemode
& DREX_NO_OC0
) && oc0
)
7879 /* regmem == register */
7880 modrm_regmem
= modrm
.rm
+ ((drex_byte
& REX_B
) ? 8 : 0);
7882 /* skip modrm/drex since we don't call OP_E_extended. */
7887 /* regmem == memory, fill in appropriate REX bits. */
7888 modrm_regmem
= DREX_REG_MEMORY
;
7889 rex
= drex_byte
& (REX_B
| REX_X
| REX_R
);
7895 /* Based on the OC1/OC0 bits, lay out the arguments in the correct
7904 regs
[0] = modrm_regmem
;
7905 regs
[1] = modrm_reg
;
7910 regs
[0] = modrm_reg
;
7911 regs
[1] = modrm_regmem
;
7916 /* Print out the arguments. */
7917 for (i
= 0; i
< 3; i
++)
7919 int j
= (intel_syntax
) ? 2 - i
: i
;
7926 print_drex_arg (regs
[j
], bytemode
, sizeflag
);
7930 rex_used
= rex_used_save
;
7933 /* Emit a floating point comparison for comp<xx> instructions. */
7936 OP_DREX_FCMP (int bytemode ATTRIBUTE_UNUSED
,
7937 int sizeflag ATTRIBUTE_UNUSED
)
7941 static const char *const cmp_test
[] = {
7960 FETCH_DATA (the_info
, codep
+ 1);
7961 byte
= *codep
& 0xff;
7963 if (byte
>= ARRAY_SIZE (cmp_test
)
7968 /* The instruction isn't one we know about, so just append the
7969 extension byte as a numeric value. */
7975 sprintf (scratchbuf
, "com%s%s", cmp_test
[byte
], obuf
+3);
7976 strcpy (obuf
, scratchbuf
);
7981 /* Emit an integer point comparison for pcom<xx> instructions,
7982 rewriting the instruction to have the test inside of it. */
7985 OP_DREX_ICMP (int bytemode ATTRIBUTE_UNUSED
,
7986 int sizeflag ATTRIBUTE_UNUSED
)
7990 static const char *const cmp_test
[] = {
8001 FETCH_DATA (the_info
, codep
+ 1);
8002 byte
= *codep
& 0xff;
8004 if (byte
>= ARRAY_SIZE (cmp_test
)
8010 /* The instruction isn't one we know about, so just print the
8011 comparison test byte as a numeric value. */
8017 sprintf (scratchbuf
, "pcom%s%s", cmp_test
[byte
], obuf
+4);
8018 strcpy (obuf
, scratchbuf
);