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 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program 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 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public 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, MA 02110-1301, USA. */
21 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
23 modified by John Hassey (hassey@dg-rtp.dg.com)
24 x86-64 support added by Jan Hubicka (jh@suse.cz)
25 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
27 /* The main tables describing the instructions is essentially a copy
28 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
29 Programmers Manual. Usually, there is a capital letter, followed
30 by a small letter. The capital letter tell the addressing mode,
31 and the small letter tells about the operand size. Refer to
32 the Intel manual for details. */
37 #include "opcode/i386.h"
41 static int fetch_data (struct disassemble_info *, bfd_byte *);
42 static void ckprefix (void);
43 static const char *prefix_name (int, int);
44 static int print_insn (bfd_vma, disassemble_info *);
45 static void dofloat (int);
46 static void OP_ST (int, int);
47 static void OP_STi (int, int);
48 static int putop (const char *, int);
49 static void oappend (const char *);
50 static void append_seg (void);
51 static void OP_indirE (int, int);
52 static void print_operand_value (char *, int, bfd_vma);
53 static void print_displacement (char *, bfd_vma);
54 static void OP_E (int, int);
55 static void OP_G (int, int);
56 static bfd_vma get64 (void);
57 static bfd_signed_vma get32 (void);
58 static bfd_signed_vma get32s (void);
59 static int get16 (void);
60 static void set_op (bfd_vma, int);
61 static void OP_REG (int, int);
62 static void OP_IMREG (int, int);
63 static void OP_I (int, int);
64 static void OP_I64 (int, int);
65 static void OP_sI (int, int);
66 static void OP_J (int, int);
67 static void OP_SEG (int, int);
68 static void OP_DIR (int, int);
69 static void OP_OFF (int, int);
70 static void OP_OFF64 (int, int);
71 static void ptr_reg (int, int);
72 static void OP_ESreg (int, int);
73 static void OP_DSreg (int, int);
74 static void OP_C (int, int);
75 static void OP_D (int, int);
76 static void OP_T (int, int);
77 static void OP_R (int, int);
78 static void OP_MMX (int, int);
79 static void OP_XMM (int, int);
80 static void OP_EM (int, int);
81 static void OP_EX (int, int);
82 static void OP_EMC (int,int);
83 static void OP_MXC (int,int);
84 static void OP_MS (int, int);
85 static void OP_XS (int, int);
86 static void OP_M (int, int);
87 static void OP_VMX (int, int);
88 static void OP_0fae (int, int);
89 static void OP_0f07 (int, int);
90 static void NOP_Fixup1 (int, int);
91 static void NOP_Fixup2 (int, int);
92 static void OP_3DNowSuffix (int, int);
93 static void OP_SIMD_Suffix (int, int);
94 static void SIMD_Fixup (int, int);
95 static void PNI_Fixup (int, int);
96 static void XCR_Fixup (int, int);
97 static void SVME_Fixup (int, int);
98 static void INVLPG_Fixup (int, int);
99 static void BadOp (void);
100 static void VMX_Fixup (int, int);
101 static void REP_Fixup (int, int);
102 static void CMPXCHG8B_Fixup (int, int);
103 static void XMM_Fixup (int, int);
104 static void CRC32_Fixup (int, int);
107 /* Points to first byte not fetched. */
108 bfd_byte *max_fetched;
109 bfd_byte the_buffer[MAX_MNEM_SIZE];
122 enum address_mode address_mode;
124 /* Flags for the prefixes for the current instruction. See below. */
127 /* REX prefix the current instruction. See below. */
129 /* Bits of REX we've already used. */
131 /* Mark parts used in the REX prefix. When we are testing for
132 empty prefix (for 8bit register REX extension), just mask it
133 out. Otherwise test for REX bit is excuse for existence of REX
134 only in case value is nonzero. */
135 #define USED_REX(value) \
140 rex_used |= (value) | REX_OPCODE; \
143 rex_used |= REX_OPCODE; \
146 /* Flags for prefixes which we somehow handled when printing the
147 current instruction. */
148 static int used_prefixes;
150 /* Flags stored in PREFIXES. */
151 #define PREFIX_REPZ 1
152 #define PREFIX_REPNZ 2
153 #define PREFIX_LOCK 4
155 #define PREFIX_SS 0x10
156 #define PREFIX_DS 0x20
157 #define PREFIX_ES 0x40
158 #define PREFIX_FS 0x80
159 #define PREFIX_GS 0x100
160 #define PREFIX_DATA 0x200
161 #define PREFIX_ADDR 0x400
162 #define PREFIX_FWAIT 0x800
164 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
165 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
167 #define FETCH_DATA(info, addr) \
168 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
169 ? 1 : fetch_data ((info), (addr)))
172 fetch_data (struct disassemble_info *info, bfd_byte *addr)
175 struct dis_private *priv = (struct dis_private *) info->private_data;
176 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
178 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
179 status = (*info->read_memory_func) (start,
181 addr - priv->max_fetched,
187 /* If we did manage to read at least one byte, then
188 print_insn_i386 will do something sensible. Otherwise, print
189 an error. We do that here because this is where we know
191 if (priv->max_fetched == priv->the_buffer)
192 (*info->memory_error_func) (status, start, info);
193 longjmp (priv->bailout, 1);
196 priv->max_fetched = addr;
200 #define XX { NULL, 0 }
202 #define Eb { OP_E, b_mode }
203 #define Ev { OP_E, v_mode }
204 #define Ed { OP_E, d_mode }
205 #define Edq { OP_E, dq_mode }
206 #define Edqw { OP_E, dqw_mode }
207 #define Edqb { OP_E, dqb_mode }
208 #define Edqd { OP_E, dqd_mode }
209 #define indirEv { OP_indirE, stack_v_mode }
210 #define indirEp { OP_indirE, f_mode }
211 #define stackEv { OP_E, stack_v_mode }
212 #define Em { OP_E, m_mode }
213 #define Ew { OP_E, w_mode }
214 #define M { OP_M, 0 } /* lea, lgdt, etc. */
215 #define Ma { OP_M, v_mode }
216 #define Mo { OP_M, o_mode }
217 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
218 #define Mq { OP_M, q_mode }
219 #define Gb { OP_G, b_mode }
220 #define Gv { OP_G, v_mode }
221 #define Gd { OP_G, d_mode }
222 #define Gdq { OP_G, dq_mode }
223 #define Gm { OP_G, m_mode }
224 #define Gw { OP_G, w_mode }
225 #define Rd { OP_R, d_mode }
226 #define Rm { OP_R, m_mode }
227 #define Ib { OP_I, b_mode }
228 #define sIb { OP_sI, b_mode } /* sign extened byte */
229 #define Iv { OP_I, v_mode }
230 #define Iq { OP_I, q_mode }
231 #define Iv64 { OP_I64, v_mode }
232 #define Iw { OP_I, w_mode }
233 #define I1 { OP_I, const_1_mode }
234 #define Jb { OP_J, b_mode }
235 #define Jv { OP_J, v_mode }
236 #define Cm { OP_C, m_mode }
237 #define Dm { OP_D, m_mode }
238 #define Td { OP_T, d_mode }
240 #define RMeAX { OP_REG, eAX_reg }
241 #define RMeBX { OP_REG, eBX_reg }
242 #define RMeCX { OP_REG, eCX_reg }
243 #define RMeDX { OP_REG, eDX_reg }
244 #define RMeSP { OP_REG, eSP_reg }
245 #define RMeBP { OP_REG, eBP_reg }
246 #define RMeSI { OP_REG, eSI_reg }
247 #define RMeDI { OP_REG, eDI_reg }
248 #define RMrAX { OP_REG, rAX_reg }
249 #define RMrBX { OP_REG, rBX_reg }
250 #define RMrCX { OP_REG, rCX_reg }
251 #define RMrDX { OP_REG, rDX_reg }
252 #define RMrSP { OP_REG, rSP_reg }
253 #define RMrBP { OP_REG, rBP_reg }
254 #define RMrSI { OP_REG, rSI_reg }
255 #define RMrDI { OP_REG, rDI_reg }
256 #define RMAL { OP_REG, al_reg }
257 #define RMAL { OP_REG, al_reg }
258 #define RMCL { OP_REG, cl_reg }
259 #define RMDL { OP_REG, dl_reg }
260 #define RMBL { OP_REG, bl_reg }
261 #define RMAH { OP_REG, ah_reg }
262 #define RMCH { OP_REG, ch_reg }
263 #define RMDH { OP_REG, dh_reg }
264 #define RMBH { OP_REG, bh_reg }
265 #define RMAX { OP_REG, ax_reg }
266 #define RMDX { OP_REG, dx_reg }
268 #define eAX { OP_IMREG, eAX_reg }
269 #define eBX { OP_IMREG, eBX_reg }
270 #define eCX { OP_IMREG, eCX_reg }
271 #define eDX { OP_IMREG, eDX_reg }
272 #define eSP { OP_IMREG, eSP_reg }
273 #define eBP { OP_IMREG, eBP_reg }
274 #define eSI { OP_IMREG, eSI_reg }
275 #define eDI { OP_IMREG, eDI_reg }
276 #define AL { OP_IMREG, al_reg }
277 #define CL { OP_IMREG, cl_reg }
278 #define DL { OP_IMREG, dl_reg }
279 #define BL { OP_IMREG, bl_reg }
280 #define AH { OP_IMREG, ah_reg }
281 #define CH { OP_IMREG, ch_reg }
282 #define DH { OP_IMREG, dh_reg }
283 #define BH { OP_IMREG, bh_reg }
284 #define AX { OP_IMREG, ax_reg }
285 #define DX { OP_IMREG, dx_reg }
286 #define zAX { OP_IMREG, z_mode_ax_reg }
287 #define indirDX { OP_IMREG, indir_dx_reg }
289 #define Sw { OP_SEG, w_mode }
290 #define Sv { OP_SEG, v_mode }
291 #define Ap { OP_DIR, 0 }
292 #define Ob { OP_OFF64, b_mode }
293 #define Ov { OP_OFF64, v_mode }
294 #define Xb { OP_DSreg, eSI_reg }
295 #define Xv { OP_DSreg, eSI_reg }
296 #define Xz { OP_DSreg, eSI_reg }
297 #define Yb { OP_ESreg, eDI_reg }
298 #define Yv { OP_ESreg, eDI_reg }
299 #define DSBX { OP_DSreg, eBX_reg }
301 #define es { OP_REG, es_reg }
302 #define ss { OP_REG, ss_reg }
303 #define cs { OP_REG, cs_reg }
304 #define ds { OP_REG, ds_reg }
305 #define fs { OP_REG, fs_reg }
306 #define gs { OP_REG, gs_reg }
308 #define MX { OP_MMX, 0 }
309 #define XM { OP_XMM, 0 }
310 #define EM { OP_EM, v_mode }
311 #define EMd { OP_EM, d_mode }
312 #define EMq { OP_EM, q_mode }
313 #define EXd { OP_EX, d_mode }
314 #define EXq { OP_EX, q_mode }
315 #define EXx { OP_EX, x_mode }
316 #define MS { OP_MS, v_mode }
317 #define XS { OP_XS, v_mode }
318 #define EMC { OP_EMC, v_mode }
319 #define MXC { OP_MXC, 0 }
320 #define VM { OP_VMX, q_mode }
321 #define OPSUF { OP_3DNowSuffix, 0 }
322 #define OPSIMD { OP_SIMD_Suffix, 0 }
323 #define XMM0 { XMM_Fixup, 0 }
325 /* Used handle "rep" prefix for string instructions. */
326 #define Xbr { REP_Fixup, eSI_reg }
327 #define Xvr { REP_Fixup, eSI_reg }
328 #define Ybr { REP_Fixup, eDI_reg }
329 #define Yvr { REP_Fixup, eDI_reg }
330 #define Yzr { REP_Fixup, eDI_reg }
331 #define indirDXr { REP_Fixup, indir_dx_reg }
332 #define ALr { REP_Fixup, al_reg }
333 #define eAXr { REP_Fixup, eAX_reg }
335 #define cond_jump_flag { NULL, cond_jump_mode }
336 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
338 /* bits in sizeflag */
339 #define SUFFIX_ALWAYS 4
343 #define b_mode 1 /* byte operand */
344 #define v_mode 2 /* operand size depends on prefixes */
345 #define w_mode 3 /* word operand */
346 #define d_mode 4 /* double word operand */
347 #define q_mode 5 /* quad word operand */
348 #define t_mode 6 /* ten-byte operand */
349 #define x_mode 7 /* 16-byte XMM operand */
350 #define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */
351 #define cond_jump_mode 9
352 #define loop_jcxz_mode 10
353 #define dq_mode 11 /* operand size depends on REX prefixes. */
354 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */
355 #define f_mode 13 /* 4- or 6-byte pointer operand */
356 #define const_1_mode 14
357 #define stack_v_mode 15 /* v_mode for stack-related opcodes. */
358 #define z_mode 16 /* non-quad operand size depends on prefixes */
359 #define o_mode 17 /* 16-byte operand */
360 #define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */
361 #define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */
406 #define z_mode_ax_reg 149
407 #define indir_dx_reg 150
411 #define USE_PREFIX_USER_TABLE 3
412 #define X86_64_SPECIAL 4
413 #define IS_3BYTE_OPCODE 5
415 #define FLOAT NULL, { { NULL, FLOATCODE } }
417 #define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } }
418 #define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } }
419 #define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } }
420 #define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } }
421 #define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } }
422 #define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } }
423 #define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } }
424 #define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } }
425 #define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } }
426 #define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } }
427 #define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } }
428 #define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } }
429 #define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } }
430 #define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } }
431 #define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } }
432 #define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } }
433 #define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } }
434 #define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } }
435 #define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } }
436 #define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } }
437 #define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } }
438 #define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } }
439 #define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } }
440 #define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } }
441 #define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } }
442 #define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } }
443 #define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } }
444 #define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } }
446 #define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } }
447 #define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } }
448 #define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } }
449 #define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } }
450 #define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } }
451 #define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } }
452 #define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } }
453 #define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } }
454 #define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } }
455 #define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } }
456 #define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } }
457 #define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } }
458 #define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } }
459 #define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } }
460 #define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } }
461 #define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } }
462 #define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } }
463 #define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } }
464 #define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } }
465 #define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } }
466 #define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } }
467 #define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } }
468 #define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } }
469 #define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } }
470 #define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } }
471 #define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } }
472 #define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } }
473 #define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } }
474 #define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } }
475 #define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } }
476 #define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } }
477 #define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } }
478 #define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } }
479 #define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } }
480 #define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } }
481 #define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } }
482 #define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } }
483 #define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } }
484 #define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } }
485 #define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } }
486 #define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } }
487 #define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } }
488 #define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } }
489 #define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } }
490 #define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } }
491 #define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } }
492 #define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } }
493 #define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } }
494 #define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } }
495 #define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } }
496 #define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } }
497 #define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } }
498 #define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } }
499 #define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } }
500 #define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } }
501 #define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } }
502 #define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } }
503 #define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } }
504 #define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } }
505 #define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } }
506 #define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } }
507 #define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } }
508 #define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } }
509 #define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } }
510 #define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } }
511 #define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } }
512 #define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } }
513 #define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } }
514 #define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } }
515 #define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } }
516 #define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } }
517 #define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } }
518 #define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } }
519 #define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } }
520 #define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } }
521 #define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } }
522 #define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } }
523 #define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } }
524 #define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } }
525 #define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } }
526 #define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } }
527 #define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } }
528 #define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } }
529 #define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } }
530 #define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } }
531 #define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } }
532 #define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } }
533 #define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } }
534 #define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } }
535 #define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } }
536 #define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } }
537 #define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } }
538 #define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } }
539 #define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } }
540 #define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } }
541 #define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } }
542 #define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } }
543 #define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } }
544 #define PREGRP98 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 98 } }
545 #define PREGRP99 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 99 } }
546 #define PREGRP100 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 100 } }
547 #define PREGRP101 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 101 } }
548 #define PREGRP102 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 102 } }
549 #define PREGRP103 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 103 } }
550 #define PREGRP104 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 104 } }
551 #define PREGRP105 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 105 } }
552 #define PREGRP106 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 106 } }
555 #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }
556 #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }
557 #define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }
558 #define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }
560 #define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }
561 #define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }
563 typedef void (*op_rtn) (int bytemode, int sizeflag);
574 /* Upper case letters in the instruction names here are macros.
575 'A' => print 'b' if no register operands or suffix_always is true
576 'B' => print 'b' if suffix_always is true
577 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
579 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
580 . suffix_always is true
581 'E' => print 'e' if 32-bit form of jcxz
582 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
583 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
584 'H' => print ",pt" or ",pn" branch hint
585 'I' => honor following macro letter even in Intel mode (implemented only
586 . for some of the macro letters)
588 'K' => print 'd' or 'q' if rex prefix is present.
589 'L' => print 'l' if suffix_always is true
590 'N' => print 'n' if instruction has no wait "prefix"
591 'O' => print 'd' or 'o' (or 'q' in Intel mode)
592 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
593 . or suffix_always is true. print 'q' if rex prefix is present.
594 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
596 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
597 'S' => print 'w', 'l' or 'q' if suffix_always is true
598 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
599 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
600 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
601 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
602 'X' => print 's', 'd' depending on data16 prefix (for XMM)
603 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
604 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
606 Many of the above letters print nothing in Intel mode. See "putop"
609 Braces '{' and '}', and vertical bars '|', indicate alternative
610 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
611 modes. In cases where there are only two alternatives, the X86_64
612 instruction is reserved, and "(bad)" is printed.
615 static const struct dis386 dis386[] = {
617 { "addB", { Eb, Gb } },
618 { "addS", { Ev, Gv } },
619 { "addB", { Gb, Eb } },
620 { "addS", { Gv, Ev } },
621 { "addB", { AL, Ib } },
622 { "addS", { eAX, Iv } },
623 { "push{T|}", { es } },
624 { "pop{T|}", { es } },
626 { "orB", { Eb, Gb } },
627 { "orS", { Ev, Gv } },
628 { "orB", { Gb, Eb } },
629 { "orS", { Gv, Ev } },
630 { "orB", { AL, Ib } },
631 { "orS", { eAX, Iv } },
632 { "push{T|}", { cs } },
633 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
635 { "adcB", { Eb, Gb } },
636 { "adcS", { Ev, Gv } },
637 { "adcB", { Gb, Eb } },
638 { "adcS", { Gv, Ev } },
639 { "adcB", { AL, Ib } },
640 { "adcS", { eAX, Iv } },
641 { "push{T|}", { ss } },
642 { "pop{T|}", { ss } },
644 { "sbbB", { Eb, Gb } },
645 { "sbbS", { Ev, Gv } },
646 { "sbbB", { Gb, Eb } },
647 { "sbbS", { Gv, Ev } },
648 { "sbbB", { AL, Ib } },
649 { "sbbS", { eAX, Iv } },
650 { "push{T|}", { ds } },
651 { "pop{T|}", { ds } },
653 { "andB", { Eb, Gb } },
654 { "andS", { Ev, Gv } },
655 { "andB", { Gb, Eb } },
656 { "andS", { Gv, Ev } },
657 { "andB", { AL, Ib } },
658 { "andS", { eAX, Iv } },
659 { "(bad)", { XX } }, /* SEG ES prefix */
660 { "daa{|}", { XX } },
662 { "subB", { Eb, Gb } },
663 { "subS", { Ev, Gv } },
664 { "subB", { Gb, Eb } },
665 { "subS", { Gv, Ev } },
666 { "subB", { AL, Ib } },
667 { "subS", { eAX, Iv } },
668 { "(bad)", { XX } }, /* SEG CS prefix */
669 { "das{|}", { XX } },
671 { "xorB", { Eb, Gb } },
672 { "xorS", { Ev, Gv } },
673 { "xorB", { Gb, Eb } },
674 { "xorS", { Gv, Ev } },
675 { "xorB", { AL, Ib } },
676 { "xorS", { eAX, Iv } },
677 { "(bad)", { XX } }, /* SEG SS prefix */
678 { "aaa{|}", { XX } },
680 { "cmpB", { Eb, Gb } },
681 { "cmpS", { Ev, Gv } },
682 { "cmpB", { Gb, Eb } },
683 { "cmpS", { Gv, Ev } },
684 { "cmpB", { AL, Ib } },
685 { "cmpS", { eAX, Iv } },
686 { "(bad)", { XX } }, /* SEG DS prefix */
687 { "aas{|}", { XX } },
689 { "inc{S|}", { RMeAX } },
690 { "inc{S|}", { RMeCX } },
691 { "inc{S|}", { RMeDX } },
692 { "inc{S|}", { RMeBX } },
693 { "inc{S|}", { RMeSP } },
694 { "inc{S|}", { RMeBP } },
695 { "inc{S|}", { RMeSI } },
696 { "inc{S|}", { RMeDI } },
698 { "dec{S|}", { RMeAX } },
699 { "dec{S|}", { RMeCX } },
700 { "dec{S|}", { RMeDX } },
701 { "dec{S|}", { RMeBX } },
702 { "dec{S|}", { RMeSP } },
703 { "dec{S|}", { RMeBP } },
704 { "dec{S|}", { RMeSI } },
705 { "dec{S|}", { RMeDI } },
707 { "pushV", { RMrAX } },
708 { "pushV", { RMrCX } },
709 { "pushV", { RMrDX } },
710 { "pushV", { RMrBX } },
711 { "pushV", { RMrSP } },
712 { "pushV", { RMrBP } },
713 { "pushV", { RMrSI } },
714 { "pushV", { RMrDI } },
716 { "popV", { RMrAX } },
717 { "popV", { RMrCX } },
718 { "popV", { RMrDX } },
719 { "popV", { RMrBX } },
720 { "popV", { RMrSP } },
721 { "popV", { RMrBP } },
722 { "popV", { RMrSI } },
723 { "popV", { RMrDI } },
729 { "(bad)", { XX } }, /* seg fs */
730 { "(bad)", { XX } }, /* seg gs */
731 { "(bad)", { XX } }, /* op size prefix */
732 { "(bad)", { XX } }, /* adr size prefix */
735 { "imulS", { Gv, Ev, Iv } },
736 { "pushT", { sIb } },
737 { "imulS", { Gv, Ev, sIb } },
738 { "ins{b||b|}", { Ybr, indirDX } },
739 { "ins{R||G|}", { Yzr, indirDX } },
740 { "outs{b||b|}", { indirDXr, Xb } },
741 { "outs{R||G|}", { indirDXr, Xz } },
743 { "joH", { Jb, XX, cond_jump_flag } },
744 { "jnoH", { Jb, XX, cond_jump_flag } },
745 { "jbH", { Jb, XX, cond_jump_flag } },
746 { "jaeH", { Jb, XX, cond_jump_flag } },
747 { "jeH", { Jb, XX, cond_jump_flag } },
748 { "jneH", { Jb, XX, cond_jump_flag } },
749 { "jbeH", { Jb, XX, cond_jump_flag } },
750 { "jaH", { Jb, XX, cond_jump_flag } },
752 { "jsH", { Jb, XX, cond_jump_flag } },
753 { "jnsH", { Jb, XX, cond_jump_flag } },
754 { "jpH", { Jb, XX, cond_jump_flag } },
755 { "jnpH", { Jb, XX, cond_jump_flag } },
756 { "jlH", { Jb, XX, cond_jump_flag } },
757 { "jgeH", { Jb, XX, cond_jump_flag } },
758 { "jleH", { Jb, XX, cond_jump_flag } },
759 { "jgH", { Jb, XX, cond_jump_flag } },
765 { "testB", { Eb, Gb } },
766 { "testS", { Ev, Gv } },
767 { "xchgB", { Eb, Gb } },
768 { "xchgS", { Ev, Gv } },
770 { "movB", { Eb, Gb } },
771 { "movS", { Ev, Gv } },
772 { "movB", { Gb, Eb } },
773 { "movS", { Gv, Ev } },
774 { "movD", { Sv, Sw } },
775 { "leaS", { Gv, M } },
776 { "movD", { Sw, Sv } },
780 { "xchgS", { RMeCX, eAX } },
781 { "xchgS", { RMeDX, eAX } },
782 { "xchgS", { RMeBX, eAX } },
783 { "xchgS", { RMeSP, eAX } },
784 { "xchgS", { RMeBP, eAX } },
785 { "xchgS", { RMeSI, eAX } },
786 { "xchgS", { RMeDI, eAX } },
788 { "cW{t||t|}R", { XX } },
789 { "cR{t||t|}O", { XX } },
790 { "Jcall{T|}", { Ap } },
791 { "(bad)", { XX } }, /* fwait */
792 { "pushfT", { XX } },
794 { "sahf{|}", { XX } },
795 { "lahf{|}", { XX } },
797 { "movB", { AL, Ob } },
798 { "movS", { eAX, Ov } },
799 { "movB", { Ob, AL } },
800 { "movS", { Ov, eAX } },
801 { "movs{b||b|}", { Ybr, Xb } },
802 { "movs{R||R|}", { Yvr, Xv } },
803 { "cmps{b||b|}", { Xb, Yb } },
804 { "cmps{R||R|}", { Xv, Yv } },
806 { "testB", { AL, Ib } },
807 { "testS", { eAX, Iv } },
808 { "stosB", { Ybr, AL } },
809 { "stosS", { Yvr, eAX } },
810 { "lodsB", { ALr, Xb } },
811 { "lodsS", { eAXr, Xv } },
812 { "scasB", { AL, Yb } },
813 { "scasS", { eAX, Yv } },
815 { "movB", { RMAL, Ib } },
816 { "movB", { RMCL, Ib } },
817 { "movB", { RMDL, Ib } },
818 { "movB", { RMBL, Ib } },
819 { "movB", { RMAH, Ib } },
820 { "movB", { RMCH, Ib } },
821 { "movB", { RMDH, Ib } },
822 { "movB", { RMBH, Ib } },
824 { "movS", { RMeAX, Iv64 } },
825 { "movS", { RMeCX, Iv64 } },
826 { "movS", { RMeDX, Iv64 } },
827 { "movS", { RMeBX, Iv64 } },
828 { "movS", { RMeSP, Iv64 } },
829 { "movS", { RMeBP, Iv64 } },
830 { "movS", { RMeSI, Iv64 } },
831 { "movS", { RMeDI, Iv64 } },
837 { "les{S|}", { Gv, Mp } },
838 { "ldsS", { Gv, Mp } },
842 { "enterT", { Iw, Ib } },
843 { "leaveT", { XX } },
848 { "into{|}", { XX } },
855 { "aam{|}", { sIb } },
856 { "aad{|}", { sIb } },
858 { "xlat", { DSBX } },
869 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
870 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
871 { "loopFH", { Jb, XX, loop_jcxz_flag } },
872 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
873 { "inB", { AL, Ib } },
874 { "inG", { zAX, Ib } },
875 { "outB", { Ib, AL } },
876 { "outG", { Ib, zAX } },
880 { "Jjmp{T|}", { Ap } },
882 { "inB", { AL, indirDX } },
883 { "inG", { zAX, indirDX } },
884 { "outB", { indirDX, AL } },
885 { "outG", { indirDX, zAX } },
887 { "(bad)", { XX } }, /* lock prefix */
889 { "(bad)", { XX } }, /* repne */
890 { "(bad)", { XX } }, /* repz */
906 static const struct dis386 dis386_twobyte[] = {
910 { "larS", { Gv, Ew } },
911 { "lslS", { Gv, Ew } },
913 { "syscall", { XX } },
915 { "sysretP", { XX } },
918 { "wbinvd", { XX } },
924 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
929 { "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } },
930 { "unpcklpX", { XM, EXq } },
931 { "unpckhpX", { XM, EXq } },
933 { "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } },
944 { "movZ", { Rm, Cm } },
945 { "movZ", { Rm, Dm } },
946 { "movZ", { Cm, Rm } },
947 { "movZ", { Dm, Rm } },
948 { "movL", { Rd, Td } },
950 { "movL", { Td, Rd } },
953 { "movapX", { XM, EXx } },
954 { "movapX", { EXx, XM } },
966 { "sysenter", { XX } },
967 { "sysexit", { XX } },
980 { "cmovo", { Gv, Ev } },
981 { "cmovno", { Gv, Ev } },
982 { "cmovb", { Gv, Ev } },
983 { "cmovae", { Gv, Ev } },
984 { "cmove", { Gv, Ev } },
985 { "cmovne", { Gv, Ev } },
986 { "cmovbe", { Gv, Ev } },
987 { "cmova", { Gv, Ev } },
989 { "cmovs", { Gv, Ev } },
990 { "cmovns", { Gv, Ev } },
991 { "cmovp", { Gv, Ev } },
992 { "cmovnp", { Gv, Ev } },
993 { "cmovl", { Gv, Ev } },
994 { "cmovge", { Gv, Ev } },
995 { "cmovle", { Gv, Ev } },
996 { "cmovg", { Gv, Ev } },
998 { "movmskpX", { Gdq, XS } },
1002 { "andpX", { XM, EXx } },
1003 { "andnpX", { XM, EXx } },
1004 { "orpX", { XM, EXx } },
1005 { "xorpX", { XM, EXx } },
1019 { "packsswb", { MX, EM } },
1020 { "pcmpgtb", { MX, EM } },
1021 { "pcmpgtw", { MX, EM } },
1022 { "pcmpgtd", { MX, EM } },
1023 { "packuswb", { MX, EM } },
1025 { "punpckhbw", { MX, EM } },
1026 { "punpckhwd", { MX, EM } },
1027 { "punpckhdq", { MX, EM } },
1028 { "packssdw", { MX, EM } },
1031 { "movd", { MX, Edq } },
1038 { "pcmpeqb", { MX, EM } },
1039 { "pcmpeqw", { MX, EM } },
1040 { "pcmpeqd", { MX, EM } },
1045 { "(bad)", { XX } },
1046 { "(bad)", { XX } },
1052 { "joH", { Jv, XX, cond_jump_flag } },
1053 { "jnoH", { Jv, XX, cond_jump_flag } },
1054 { "jbH", { Jv, XX, cond_jump_flag } },
1055 { "jaeH", { Jv, XX, cond_jump_flag } },
1056 { "jeH", { Jv, XX, cond_jump_flag } },
1057 { "jneH", { Jv, XX, cond_jump_flag } },
1058 { "jbeH", { Jv, XX, cond_jump_flag } },
1059 { "jaH", { Jv, XX, cond_jump_flag } },
1061 { "jsH", { Jv, XX, cond_jump_flag } },
1062 { "jnsH", { Jv, XX, cond_jump_flag } },
1063 { "jpH", { Jv, XX, cond_jump_flag } },
1064 { "jnpH", { Jv, XX, cond_jump_flag } },
1065 { "jlH", { Jv, XX, cond_jump_flag } },
1066 { "jgeH", { Jv, XX, cond_jump_flag } },
1067 { "jleH", { Jv, XX, cond_jump_flag } },
1068 { "jgH", { Jv, XX, cond_jump_flag } },
1071 { "setno", { Eb } },
1073 { "setae", { Eb } },
1075 { "setne", { Eb } },
1076 { "setbe", { Eb } },
1080 { "setns", { Eb } },
1082 { "setnp", { Eb } },
1084 { "setge", { Eb } },
1085 { "setle", { Eb } },
1088 { "pushT", { fs } },
1090 { "cpuid", { XX } },
1091 { "btS", { Ev, Gv } },
1092 { "shldS", { Ev, Gv, Ib } },
1093 { "shldS", { Ev, Gv, CL } },
1097 { "pushT", { gs } },
1100 { "btsS", { Ev, Gv } },
1101 { "shrdS", { Ev, Gv, Ib } },
1102 { "shrdS", { Ev, Gv, CL } },
1104 { "imulS", { Gv, Ev } },
1106 { "cmpxchgB", { Eb, Gb } },
1107 { "cmpxchgS", { Ev, Gv } },
1108 { "lssS", { Gv, Mp } },
1109 { "btrS", { Ev, Gv } },
1110 { "lfsS", { Gv, Mp } },
1111 { "lgsS", { Gv, Mp } },
1112 { "movz{bR|x|bR|x}", { Gv, Eb } },
1113 { "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
1118 { "btcS", { Ev, Gv } },
1119 { "bsfS", { Gv, Ev } },
1121 { "movs{bR|x|bR|x}", { Gv, Eb } },
1122 { "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
1124 { "xaddB", { Eb, Gb } },
1125 { "xaddS", { Ev, Gv } },
1127 { "movntiS", { Ev, Gv } },
1128 { "pinsrw", { MX, Edqw, Ib } },
1129 { "pextrw", { Gdq, MS, Ib } },
1130 { "shufpX", { XM, EXx, Ib } },
1133 { "bswap", { RMeAX } },
1134 { "bswap", { RMeCX } },
1135 { "bswap", { RMeDX } },
1136 { "bswap", { RMeBX } },
1137 { "bswap", { RMeSP } },
1138 { "bswap", { RMeBP } },
1139 { "bswap", { RMeSI } },
1140 { "bswap", { RMeDI } },
1143 { "psrlw", { MX, EM } },
1144 { "psrld", { MX, EM } },
1145 { "psrlq", { MX, EM } },
1146 { "paddq", { MX, EM } },
1147 { "pmullw", { MX, EM } },
1149 { "pmovmskb", { Gdq, MS } },
1151 { "psubusb", { MX, EM } },
1152 { "psubusw", { MX, EM } },
1153 { "pminub", { MX, EM } },
1154 { "pand", { MX, EM } },
1155 { "paddusb", { MX, EM } },
1156 { "paddusw", { MX, EM } },
1157 { "pmaxub", { MX, EM } },
1158 { "pandn", { MX, EM } },
1160 { "pavgb", { MX, EM } },
1161 { "psraw", { MX, EM } },
1162 { "psrad", { MX, EM } },
1163 { "pavgw", { MX, EM } },
1164 { "pmulhuw", { MX, EM } },
1165 { "pmulhw", { MX, EM } },
1169 { "psubsb", { MX, EM } },
1170 { "psubsw", { MX, EM } },
1171 { "pminsw", { MX, EM } },
1172 { "por", { MX, EM } },
1173 { "paddsb", { MX, EM } },
1174 { "paddsw", { MX, EM } },
1175 { "pmaxsw", { MX, EM } },
1176 { "pxor", { MX, EM } },
1179 { "psllw", { MX, EM } },
1180 { "pslld", { MX, EM } },
1181 { "psllq", { MX, EM } },
1182 { "pmuludq", { MX, EM } },
1183 { "pmaddwd", { MX, EM } },
1184 { "psadbw", { MX, EM } },
1187 { "psubb", { MX, EM } },
1188 { "psubw", { MX, EM } },
1189 { "psubd", { MX, EM } },
1190 { "psubq", { MX, EM } },
1191 { "paddb", { MX, EM } },
1192 { "paddw", { MX, EM } },
1193 { "paddd", { MX, EM } },
1194 { "(bad)", { XX } },
1197 static const unsigned char onebyte_has_modrm[256] = {
1198 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1199 /* ------------------------------- */
1200 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1201 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1202 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1203 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1204 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1205 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1206 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1207 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1208 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1209 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1210 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1211 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1212 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1213 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1214 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1215 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1216 /* ------------------------------- */
1217 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1220 static const unsigned char twobyte_has_modrm[256] = {
1221 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1222 /* ------------------------------- */
1223 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1224 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */
1225 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1226 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1227 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1228 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1229 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1230 /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1231 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1232 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1233 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1234 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1235 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1236 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1237 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1238 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1239 /* ------------------------------- */
1240 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1243 static const unsigned char twobyte_uses_DATA_prefix[256] = {
1244 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1245 /* ------------------------------- */
1246 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1247 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1248 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1249 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1250 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1251 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1252 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1253 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */
1254 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1255 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1256 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1257 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1258 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1259 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1260 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1261 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1262 /* ------------------------------- */
1263 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1266 static const unsigned char twobyte_uses_REPNZ_prefix[256] = {
1267 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1268 /* ------------------------------- */
1269 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1270 /* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1271 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1272 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1273 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1274 /* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */
1275 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1276 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */
1277 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1278 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1279 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1280 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1281 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1282 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1283 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1284 /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1285 /* ------------------------------- */
1286 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1289 static const unsigned char twobyte_uses_REPZ_prefix[256] = {
1290 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1291 /* ------------------------------- */
1292 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1293 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1294 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1295 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1296 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1297 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1298 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */
1299 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */
1300 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1301 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1302 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1303 /* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */
1304 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1305 /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1306 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1307 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1308 /* ------------------------------- */
1309 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1312 /* This is used to determine if opcode 0f 38 XX uses DATA prefix. */
1313 static const unsigned char threebyte_0x38_uses_DATA_prefix[256] = {
1314 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1315 /* ------------------------------- */
1316 /* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */
1317 /* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */
1318 /* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */
1319 /* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */
1320 /* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1321 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1322 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1323 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1324 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1325 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1326 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1327 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1328 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1329 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1, /* df */
1330 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1331 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1332 /* ------------------------------- */
1333 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1336 /* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */
1337 static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = {
1338 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1339 /* ------------------------------- */
1340 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1341 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1342 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1343 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1344 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1345 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1346 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1347 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1348 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1349 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1350 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1351 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1352 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1353 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1354 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1355 /* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1356 /* ------------------------------- */
1357 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1360 /* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */
1361 static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = {
1362 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1363 /* ------------------------------- */
1364 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1365 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1366 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1367 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1368 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1369 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1370 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1371 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1372 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1373 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1374 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1375 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1376 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1377 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1378 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1379 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1380 /* ------------------------------- */
1381 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1384 /* This is used to determine if opcode 0f 3a XX uses DATA prefix. */
1385 static const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = {
1386 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1387 /* ------------------------------- */
1388 /* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */
1389 /* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */
1390 /* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1391 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1392 /* 40 */ 1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1393 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1394 /* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1395 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1396 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1397 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1398 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1399 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1400 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1401 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* df */
1402 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1403 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1404 /* ------------------------------- */
1405 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1408 /* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */
1409 static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = {
1410 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1411 /* ------------------------------- */
1412 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1413 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1414 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1415 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1416 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1417 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1418 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1419 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1420 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1421 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1422 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1423 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1424 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1425 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1426 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1427 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1428 /* ------------------------------- */
1429 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1432 /* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */
1433 static const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = {
1434 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1435 /* ------------------------------- */
1436 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1437 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1438 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1439 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1440 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1441 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1442 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1443 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1444 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1445 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1446 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1447 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1448 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1449 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1450 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1451 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1452 /* ------------------------------- */
1453 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1456 static char obuf[100];
1458 static char scratchbuf[100];
1459 static unsigned char *start_codep;
1460 static unsigned char *insn_codep;
1461 static unsigned char *codep;
1462 static disassemble_info *the_info;
1470 static unsigned char need_modrm;
1472 /* If we are accessing mod/rm/reg without need_modrm set, then the
1473 values are stale. Hitting this abort likely indicates that you
1474 need to update onebyte_has_modrm or twobyte_has_modrm. */
1475 #define MODRM_CHECK if (!need_modrm) abort ()
1477 static const char **names64;
1478 static const char **names32;
1479 static const char **names16;
1480 static const char **names8;
1481 static const char **names8rex;
1482 static const char **names_seg;
1483 static const char **index16;
1485 static const char *intel_names64[] = {
1486 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1487 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1489 static const char *intel_names32[] = {
1490 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1491 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1493 static const char *intel_names16[] = {
1494 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1495 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1497 static const char *intel_names8[] = {
1498 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1500 static const char *intel_names8rex[] = {
1501 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1502 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1504 static const char *intel_names_seg[] = {
1505 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1507 static const char *intel_index16[] = {
1508 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1511 static const char *att_names64[] = {
1512 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1513 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1515 static const char *att_names32[] = {
1516 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1517 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1519 static const char *att_names16[] = {
1520 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1521 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1523 static const char *att_names8[] = {
1524 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1526 static const char *att_names8rex[] = {
1527 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1528 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1530 static const char *att_names_seg[] = {
1531 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1533 static const char *att_index16[] = {
1534 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1537 static const struct dis386 grps[][8] = {
1540 { "popU", { stackEv } },
1541 { "(bad)", { XX } },
1542 { "(bad)", { XX } },
1543 { "(bad)", { XX } },
1544 { "(bad)", { XX } },
1545 { "(bad)", { XX } },
1546 { "(bad)", { XX } },
1547 { "(bad)", { XX } },
1551 { "addA", { Eb, Ib } },
1552 { "orA", { Eb, Ib } },
1553 { "adcA", { Eb, Ib } },
1554 { "sbbA", { Eb, Ib } },
1555 { "andA", { Eb, Ib } },
1556 { "subA", { Eb, Ib } },
1557 { "xorA", { Eb, Ib } },
1558 { "cmpA", { Eb, Ib } },
1562 { "addQ", { Ev, Iv } },
1563 { "orQ", { Ev, Iv } },
1564 { "adcQ", { Ev, Iv } },
1565 { "sbbQ", { Ev, Iv } },
1566 { "andQ", { Ev, Iv } },
1567 { "subQ", { Ev, Iv } },
1568 { "xorQ", { Ev, Iv } },
1569 { "cmpQ", { Ev, Iv } },
1573 { "addQ", { Ev, sIb } },
1574 { "orQ", { Ev, sIb } },
1575 { "adcQ", { Ev, sIb } },
1576 { "sbbQ", { Ev, sIb } },
1577 { "andQ", { Ev, sIb } },
1578 { "subQ", { Ev, sIb } },
1579 { "xorQ", { Ev, sIb } },
1580 { "cmpQ", { Ev, sIb } },
1584 { "rolA", { Eb, Ib } },
1585 { "rorA", { Eb, Ib } },
1586 { "rclA", { Eb, Ib } },
1587 { "rcrA", { Eb, Ib } },
1588 { "shlA", { Eb, Ib } },
1589 { "shrA", { Eb, Ib } },
1590 { "(bad)", { XX } },
1591 { "sarA", { Eb, Ib } },
1595 { "rolQ", { Ev, Ib } },
1596 { "rorQ", { Ev, Ib } },
1597 { "rclQ", { Ev, Ib } },
1598 { "rcrQ", { Ev, Ib } },
1599 { "shlQ", { Ev, Ib } },
1600 { "shrQ", { Ev, Ib } },
1601 { "(bad)", { XX } },
1602 { "sarQ", { Ev, Ib } },
1606 { "rolA", { Eb, I1 } },
1607 { "rorA", { Eb, I1 } },
1608 { "rclA", { Eb, I1 } },
1609 { "rcrA", { Eb, I1 } },
1610 { "shlA", { Eb, I1 } },
1611 { "shrA", { Eb, I1 } },
1612 { "(bad)", { XX } },
1613 { "sarA", { Eb, I1 } },
1617 { "rolQ", { Ev, I1 } },
1618 { "rorQ", { Ev, I1 } },
1619 { "rclQ", { Ev, I1 } },
1620 { "rcrQ", { Ev, I1 } },
1621 { "shlQ", { Ev, I1 } },
1622 { "shrQ", { Ev, I1 } },
1623 { "(bad)", { XX } },
1624 { "sarQ", { Ev, I1 } },
1628 { "rolA", { Eb, CL } },
1629 { "rorA", { Eb, CL } },
1630 { "rclA", { Eb, CL } },
1631 { "rcrA", { Eb, CL } },
1632 { "shlA", { Eb, CL } },
1633 { "shrA", { Eb, CL } },
1634 { "(bad)", { XX } },
1635 { "sarA", { Eb, CL } },
1639 { "rolQ", { Ev, CL } },
1640 { "rorQ", { Ev, CL } },
1641 { "rclQ", { Ev, CL } },
1642 { "rcrQ", { Ev, CL } },
1643 { "shlQ", { Ev, CL } },
1644 { "shrQ", { Ev, CL } },
1645 { "(bad)", { XX } },
1646 { "sarQ", { Ev, CL } },
1650 { "testA", { Eb, Ib } },
1651 { "(bad)", { Eb } },
1654 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
1655 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
1656 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
1657 { "idivA", { Eb } }, /* and idiv for consistency. */
1661 { "testQ", { Ev, Iv } },
1662 { "(bad)", { XX } },
1665 { "mulQ", { Ev } }, /* Don't print the implicit register. */
1666 { "imulQ", { Ev } },
1668 { "idivQ", { Ev } },
1674 { "(bad)", { XX } },
1675 { "(bad)", { XX } },
1676 { "(bad)", { XX } },
1677 { "(bad)", { XX } },
1678 { "(bad)", { XX } },
1679 { "(bad)", { XX } },
1685 { "callT", { indirEv } },
1686 { "JcallT", { indirEp } },
1687 { "jmpT", { indirEv } },
1688 { "JjmpT", { indirEp } },
1689 { "pushU", { stackEv } },
1690 { "(bad)", { XX } },
1694 { "sldtD", { Sv } },
1700 { "(bad)", { XX } },
1701 { "(bad)", { XX } },
1705 { "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } },
1706 { "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } },
1707 { "lgdt{Q|Q||}", { { XCR_Fixup, 0 } } },
1708 { "lidt{Q|Q||}", { { SVME_Fixup, 0 } } },
1709 { "smswD", { Sv } },
1710 { "(bad)", { XX } },
1712 { "invlpg", { { INVLPG_Fixup, w_mode } } },
1716 { "(bad)", { XX } },
1717 { "(bad)", { XX } },
1718 { "(bad)", { XX } },
1719 { "(bad)", { XX } },
1720 { "btQ", { Ev, Ib } },
1721 { "btsQ", { Ev, Ib } },
1722 { "btrQ", { Ev, Ib } },
1723 { "btcQ", { Ev, Ib } },
1727 { "(bad)", { XX } },
1728 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
1729 { "(bad)", { XX } },
1730 { "(bad)", { XX } },
1731 { "(bad)", { XX } },
1732 { "(bad)", { XX } },
1733 { "", { VM } }, /* See OP_VMX. */
1734 { "vmptrst", { Mq } },
1738 { "movA", { Eb, Ib } },
1739 { "(bad)", { XX } },
1740 { "(bad)", { XX } },
1741 { "(bad)", { XX } },
1742 { "(bad)", { XX } },
1743 { "(bad)", { XX } },
1744 { "(bad)", { XX } },
1745 { "(bad)", { XX } },
1749 { "movQ", { Ev, Iv } },
1750 { "(bad)", { XX } },
1751 { "(bad)", { XX } },
1752 { "(bad)", { XX } },
1753 { "(bad)", { XX } },
1754 { "(bad)", { XX } },
1755 { "(bad)", { XX } },
1756 { "(bad)", { XX } },
1760 { "(bad)", { XX } },
1761 { "(bad)", { XX } },
1762 { "psrlw", { MS, Ib } },
1763 { "(bad)", { XX } },
1764 { "psraw", { MS, Ib } },
1765 { "(bad)", { XX } },
1766 { "psllw", { MS, Ib } },
1767 { "(bad)", { XX } },
1771 { "(bad)", { XX } },
1772 { "(bad)", { XX } },
1773 { "psrld", { MS, Ib } },
1774 { "(bad)", { XX } },
1775 { "psrad", { MS, Ib } },
1776 { "(bad)", { XX } },
1777 { "pslld", { MS, Ib } },
1778 { "(bad)", { XX } },
1782 { "(bad)", { XX } },
1783 { "(bad)", { XX } },
1784 { "psrlq", { MS, Ib } },
1785 { "psrldq", { MS, Ib } },
1786 { "(bad)", { XX } },
1787 { "(bad)", { XX } },
1788 { "psllq", { MS, Ib } },
1789 { "pslldq", { MS, Ib } },
1793 { "fxsave", { Ev } },
1794 { "fxrstor", { Ev } },
1795 { "ldmxcsr", { Ev } },
1796 { "stmxcsr", { Ev } },
1797 { "xsave", { Ev } },
1798 { "xrstor", { { OP_0fae, v_mode } } },
1799 { "xsaveopt", { { OP_0fae, v_mode } } },
1800 { "clflush", { { OP_0fae, 0 } } },
1804 { "prefetchnta", { Ev } },
1805 { "prefetcht0", { Ev } },
1806 { "prefetcht1", { Ev } },
1807 { "prefetcht2", { Ev } },
1808 { "(bad)", { XX } },
1809 { "(bad)", { XX } },
1810 { "(bad)", { XX } },
1811 { "(bad)", { XX } },
1815 { "prefetch", { Eb } },
1816 { "prefetchw", { Eb } },
1817 { "(bad)", { XX } },
1818 { "(bad)", { XX } },
1819 { "(bad)", { XX } },
1820 { "(bad)", { XX } },
1821 { "(bad)", { XX } },
1822 { "(bad)", { XX } },
1826 { "xstore-rng", { { OP_0f07, 0 } } },
1827 { "xcrypt-ecb", { { OP_0f07, 0 } } },
1828 { "xcrypt-cbc", { { OP_0f07, 0 } } },
1829 { "xcrypt-ctr", { { OP_0f07, 0 } } },
1830 { "xcrypt-cfb", { { OP_0f07, 0 } } },
1831 { "xcrypt-ofb", { { OP_0f07, 0 } } },
1832 { "(bad)", { { OP_0f07, 0 } } },
1833 { "(bad)", { { OP_0f07, 0 } } },
1837 { "montmul", { { OP_0f07, 0 } } },
1838 { "xsha1", { { OP_0f07, 0 } } },
1839 { "xsha256", { { OP_0f07, 0 } } },
1840 { "(bad)", { { OP_0f07, 0 } } },
1841 { "(bad)", { { OP_0f07, 0 } } },
1842 { "(bad)", { { OP_0f07, 0 } } },
1843 { "(bad)", { { OP_0f07, 0 } } },
1844 { "(bad)", { { OP_0f07, 0 } } },
1848 static const struct dis386 prefix_user_table[][4] = {
1851 { "addps", { XM, EXx } },
1852 { "addss", { XM, EXd } },
1853 { "addpd", { XM, EXx } },
1854 { "addsd", { XM, EXq } },
1858 { "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */
1859 { "", { XM, EXx, OPSIMD } },
1860 { "", { XM, EXx, OPSIMD } },
1861 { "", { XM, EXx, OPSIMD } },
1865 { "cvtpi2ps", { XM, EMC } },
1866 { "cvtsi2ssY", { XM, Ev } },
1867 { "cvtpi2pd", { XM, EMC } },
1868 { "cvtsi2sdY", { XM, Ev } },
1872 { "cvtps2pi", { MXC, EXx } },
1873 { "cvtss2siY", { Gv, EXx } },
1874 { "cvtpd2pi", { MXC, EXx } },
1875 { "cvtsd2siY", { Gv, EXx } },
1879 { "cvttps2pi", { MXC, EXx } },
1880 { "cvttss2siY", { Gv, EXx } },
1881 { "cvttpd2pi", { MXC, EXx } },
1882 { "cvttsd2siY", { Gv, EXx } },
1886 { "divps", { XM, EXx } },
1887 { "divss", { XM, EXx } },
1888 { "divpd", { XM, EXx } },
1889 { "divsd", { XM, EXx } },
1893 { "maxps", { XM, EXx } },
1894 { "maxss", { XM, EXx } },
1895 { "maxpd", { XM, EXx } },
1896 { "maxsd", { XM, EXx } },
1900 { "minps", { XM, EXx } },
1901 { "minss", { XM, EXx } },
1902 { "minpd", { XM, EXx } },
1903 { "minsd", { XM, EXx } },
1907 { "movups", { XM, EXx } },
1908 { "movss", { XM, EXx } },
1909 { "movupd", { XM, EXx } },
1910 { "movsd", { XM, EXx } },
1914 { "movups", { EXx, XM } },
1915 { "movss", { EXx, XM } },
1916 { "movupd", { EXx, XM } },
1917 { "movsd", { EXx, XM } },
1921 { "mulps", { XM, EXx } },
1922 { "mulss", { XM, EXx } },
1923 { "mulpd", { XM, EXx } },
1924 { "mulsd", { XM, EXx } },
1928 { "rcpps", { XM, EXx } },
1929 { "rcpss", { XM, EXx } },
1930 { "(bad)", { XM, EXx } },
1931 { "(bad)", { XM, EXx } },
1935 { "rsqrtps",{ XM, EXx } },
1936 { "rsqrtss",{ XM, EXx } },
1937 { "(bad)", { XM, EXx } },
1938 { "(bad)", { XM, EXx } },
1942 { "sqrtps", { XM, EXx } },
1943 { "sqrtss", { XM, EXx } },
1944 { "sqrtpd", { XM, EXx } },
1945 { "sqrtsd", { XM, EXx } },
1949 { "subps", { XM, EXx } },
1950 { "subss", { XM, EXx } },
1951 { "subpd", { XM, EXx } },
1952 { "subsd", { XM, EXx } },
1956 { "(bad)", { XM, EXx } },
1957 { "cvtdq2pd", { XM, EXq } },
1958 { "cvttpd2dq", { XM, EXx } },
1959 { "cvtpd2dq", { XM, EXx } },
1963 { "cvtdq2ps", { XM, EXx } },
1964 { "cvttps2dq", { XM, EXx } },
1965 { "cvtps2dq", { XM, EXx } },
1966 { "(bad)", { XM, EXx } },
1970 { "cvtps2pd", { XM, EXq } },
1971 { "cvtss2sd", { XM, EXx } },
1972 { "cvtpd2ps", { XM, EXx } },
1973 { "cvtsd2ss", { XM, EXx } },
1977 { "maskmovq", { MX, MS } },
1978 { "(bad)", { XM, EXx } },
1979 { "maskmovdqu", { XM, XS } },
1980 { "(bad)", { XM, EXx } },
1984 { "movq", { MX, EM } },
1985 { "movdqu", { XM, EXx } },
1986 { "movdqa", { XM, EXx } },
1987 { "(bad)", { XM, EXx } },
1991 { "movq", { EM, MX } },
1992 { "movdqu", { EXx, XM } },
1993 { "movdqa", { EXx, XM } },
1994 { "(bad)", { EXx, XM } },
1998 { "(bad)", { EXx, XM } },
1999 { "movq2dq",{ XM, MS } },
2000 { "movq", { EXx, XM } },
2001 { "movdq2q",{ MX, XS } },
2005 { "pshufw", { MX, EM, Ib } },
2006 { "pshufhw",{ XM, EXx, Ib } },
2007 { "pshufd", { XM, EXx, Ib } },
2008 { "pshuflw",{ XM, EXx, Ib } },
2012 { "movd", { Edq, MX } },
2013 { "movq", { XM, EXx } },
2014 { "movd", { Edq, XM } },
2015 { "(bad)", { Ed, XM } },
2019 { "(bad)", { MX, EXx } },
2020 { "(bad)", { XM, EXx } },
2021 { "punpckhqdq", { XM, EXx } },
2022 { "(bad)", { XM, EXx } },
2026 { "movntq", { EM, MX } },
2027 { "(bad)", { EM, XM } },
2028 { "movntdq",{ EM, XM } },
2029 { "(bad)", { EM, XM } },
2033 { "(bad)", { MX, EXx } },
2034 { "(bad)", { XM, EXx } },
2035 { "punpcklqdq", { XM, EXx } },
2036 { "(bad)", { XM, EXx } },
2040 { "(bad)", { MX, EXx } },
2041 { "(bad)", { XM, EXx } },
2042 { "addsubpd", { XM, EXx } },
2043 { "addsubps", { XM, EXx } },
2047 { "(bad)", { MX, EXx } },
2048 { "(bad)", { XM, EXx } },
2049 { "haddpd", { XM, EXx } },
2050 { "haddps", { XM, EXx } },
2054 { "(bad)", { MX, EXx } },
2055 { "(bad)", { XM, EXx } },
2056 { "hsubpd", { XM, EXx } },
2057 { "hsubps", { XM, EXx } },
2061 { "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */
2062 { "movsldup", { XM, EXx } },
2063 { "movlpd", { XM, EXq } },
2064 { "movddup", { XM, EXq } },
2068 { "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } },
2069 { "movshdup", { XM, EXx } },
2070 { "movhpd", { XM, EXq } },
2071 { "(bad)", { XM, EXq } },
2075 { "(bad)", { XM, EXx } },
2076 { "(bad)", { XM, EXx } },
2077 { "(bad)", { XM, EXx } },
2078 { "lddqu", { XM, M } },
2082 {"movntps", { Ev, XM } },
2083 {"movntss", { Ev, XM } },
2084 {"movntpd", { Ev, XM } },
2085 {"movntsd", { Ev, XM } },
2090 {"vmread", { Em, Gm } },
2092 {"extrq", { XS, Ib, Ib } },
2093 {"insertq", { XM, XS, Ib, Ib } },
2098 {"vmwrite", { Gm, Em } },
2100 {"extrq", { XM, XS } },
2101 {"insertq", { XM, XS } },
2106 { "bsrS", { Gv, Ev } },
2107 { "lzcntS", { Gv, Ev } },
2108 { "bsrS", { Gv, Ev } },
2109 { "(bad)", { XX } },
2114 { "(bad)", { XX } },
2115 { "popcntS", { Gv, Ev } },
2116 { "(bad)", { XX } },
2117 { "(bad)", { XX } },
2122 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2123 { "pause", { XX } },
2124 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2125 { "(bad)", { XX } },
2130 { "(bad)", { XX } },
2131 { "(bad)", { XX } },
2132 { "pblendvb", {XM, EXx, XMM0 } },
2133 { "(bad)", { XX } },
2138 { "(bad)", { XX } },
2139 { "(bad)", { XX } },
2140 { "blendvps", {XM, EXx, XMM0 } },
2141 { "(bad)", { XX } },
2146 { "(bad)", { XX } },
2147 { "(bad)", { XX } },
2148 { "blendvpd", { XM, EXx, XMM0 } },
2149 { "(bad)", { XX } },
2154 { "(bad)", { XX } },
2155 { "(bad)", { XX } },
2156 { "ptest", { XM, EXx } },
2157 { "(bad)", { XX } },
2162 { "(bad)", { XX } },
2163 { "(bad)", { XX } },
2164 { "pmovsxbw", { XM, EXx } },
2165 { "(bad)", { XX } },
2170 { "(bad)", { XX } },
2171 { "(bad)", { XX } },
2172 { "pmovsxbd", { XM, EXx } },
2173 { "(bad)", { XX } },
2178 { "(bad)", { XX } },
2179 { "(bad)", { XX } },
2180 { "pmovsxbq", { XM, EXx } },
2181 { "(bad)", { XX } },
2186 { "(bad)", { XX } },
2187 { "(bad)", { XX } },
2188 { "pmovsxwd", { XM, EXx } },
2189 { "(bad)", { XX } },
2194 { "(bad)", { XX } },
2195 { "(bad)", { XX } },
2196 { "pmovsxwq", { XM, EXx } },
2197 { "(bad)", { XX } },
2202 { "(bad)", { XX } },
2203 { "(bad)", { XX } },
2204 { "pmovsxdq", { XM, EXx } },
2205 { "(bad)", { XX } },
2210 { "(bad)", { XX } },
2211 { "(bad)", { XX } },
2212 { "pmuldq", { XM, EXx } },
2213 { "(bad)", { XX } },
2218 { "(bad)", { XX } },
2219 { "(bad)", { XX } },
2220 { "pcmpeqq", { XM, EXx } },
2221 { "(bad)", { XX } },
2226 { "(bad)", { XX } },
2227 { "(bad)", { XX } },
2228 { "movntdqa", { XM, EM } },
2229 { "(bad)", { XX } },
2234 { "(bad)", { XX } },
2235 { "(bad)", { XX } },
2236 { "packusdw", { XM, EXx } },
2237 { "(bad)", { XX } },
2242 { "(bad)", { XX } },
2243 { "(bad)", { XX } },
2244 { "pmovzxbw", { XM, EXx } },
2245 { "(bad)", { XX } },
2250 { "(bad)", { XX } },
2251 { "(bad)", { XX } },
2252 { "pmovzxbd", { XM, EXx } },
2253 { "(bad)", { XX } },
2258 { "(bad)", { XX } },
2259 { "(bad)", { XX } },
2260 { "pmovzxbq", { XM, EXx } },
2261 { "(bad)", { XX } },
2266 { "(bad)", { XX } },
2267 { "(bad)", { XX } },
2268 { "pmovzxwd", { XM, EXx } },
2269 { "(bad)", { XX } },
2274 { "(bad)", { XX } },
2275 { "(bad)", { XX } },
2276 { "pmovzxwq", { XM, EXx } },
2277 { "(bad)", { XX } },
2282 { "(bad)", { XX } },
2283 { "(bad)", { XX } },
2284 { "pmovzxdq", { XM, EXx } },
2285 { "(bad)", { XX } },
2290 { "(bad)", { XX } },
2291 { "(bad)", { XX } },
2292 { "pminsb", { XM, EXx } },
2293 { "(bad)", { XX } },
2298 { "(bad)", { XX } },
2299 { "(bad)", { XX } },
2300 { "pminsd", { XM, EXx } },
2301 { "(bad)", { XX } },
2306 { "(bad)", { XX } },
2307 { "(bad)", { XX } },
2308 { "pminuw", { XM, EXx } },
2309 { "(bad)", { XX } },
2314 { "(bad)", { XX } },
2315 { "(bad)", { XX } },
2316 { "pminud", { XM, EXx } },
2317 { "(bad)", { XX } },
2322 { "(bad)", { XX } },
2323 { "(bad)", { XX } },
2324 { "pmaxsb", { XM, EXx } },
2325 { "(bad)", { XX } },
2330 { "(bad)", { XX } },
2331 { "(bad)", { XX } },
2332 { "pmaxsd", { XM, EXx } },
2333 { "(bad)", { XX } },
2338 { "(bad)", { XX } },
2339 { "(bad)", { XX } },
2340 { "pmaxuw", { XM, EXx } },
2341 { "(bad)", { XX } },
2346 { "(bad)", { XX } },
2347 { "(bad)", { XX } },
2348 { "pmaxud", { XM, EXx } },
2349 { "(bad)", { XX } },
2354 { "(bad)", { XX } },
2355 { "(bad)", { XX } },
2356 { "pmulld", { XM, EXx } },
2357 { "(bad)", { XX } },
2362 { "(bad)", { XX } },
2363 { "(bad)", { XX } },
2364 { "phminposuw", { XM, EXx } },
2365 { "(bad)", { XX } },
2370 { "(bad)", { XX } },
2371 { "(bad)", { XX } },
2372 { "roundps", { XM, EXx, Ib } },
2373 { "(bad)", { XX } },
2378 { "(bad)", { XX } },
2379 { "(bad)", { XX } },
2380 { "roundpd", { XM, EXx, Ib } },
2381 { "(bad)", { XX } },
2386 { "(bad)", { XX } },
2387 { "(bad)", { XX } },
2388 { "roundss", { XM, EXx, Ib } },
2389 { "(bad)", { XX } },
2394 { "(bad)", { XX } },
2395 { "(bad)", { XX } },
2396 { "roundsd", { XM, EXx, Ib } },
2397 { "(bad)", { XX } },
2402 { "(bad)", { XX } },
2403 { "(bad)", { XX } },
2404 { "blendps", { XM, EXx, Ib } },
2405 { "(bad)", { XX } },
2410 { "(bad)", { XX } },
2411 { "(bad)", { XX } },
2412 { "blendpd", { XM, EXx, Ib } },
2413 { "(bad)", { XX } },
2418 { "(bad)", { XX } },
2419 { "(bad)", { XX } },
2420 { "pblendw", { XM, EXx, Ib } },
2421 { "(bad)", { XX } },
2426 { "(bad)", { XX } },
2427 { "(bad)", { XX } },
2428 { "pextrb", { Edqb, XM, Ib } },
2429 { "(bad)", { XX } },
2434 { "(bad)", { XX } },
2435 { "(bad)", { XX } },
2436 { "pextrw", { Edqw, XM, Ib } },
2437 { "(bad)", { XX } },
2442 { "(bad)", { XX } },
2443 { "(bad)", { XX } },
2444 { "pextrK", { Edq, XM, Ib } },
2445 { "(bad)", { XX } },
2450 { "(bad)", { XX } },
2451 { "(bad)", { XX } },
2452 { "extractps", { Edqd, XM, Ib } },
2453 { "(bad)", { XX } },
2458 { "(bad)", { XX } },
2459 { "(bad)", { XX } },
2460 { "pinsrb", { XM, Edqb, Ib } },
2461 { "(bad)", { XX } },
2466 { "(bad)", { XX } },
2467 { "(bad)", { XX } },
2468 { "insertps", { XM, EXx, Ib } },
2469 { "(bad)", { XX } },
2474 { "(bad)", { XX } },
2475 { "(bad)", { XX } },
2476 { "pinsrK", { XM, Edq, Ib } },
2477 { "(bad)", { XX } },
2482 { "(bad)", { XX } },
2483 { "(bad)", { XX } },
2484 { "dpps", { XM, EXx, Ib } },
2485 { "(bad)", { XX } },
2490 { "(bad)", { XX } },
2491 { "(bad)", { XX } },
2492 { "dppd", { XM, EXx, Ib } },
2493 { "(bad)", { XX } },
2498 { "(bad)", { XX } },
2499 { "(bad)", { XX } },
2500 { "mpsadbw", { XM, EXx, Ib } },
2501 { "(bad)", { XX } },
2506 { "(bad)", { XX } },
2507 { "(bad)", { XX } },
2508 { "pcmpgtq", { XM, EXx } },
2509 { "(bad)", { XX } },
2514 { "(bad)", { XX } },
2515 { "(bad)", { XX } },
2516 { "(bad)", { XX } },
2517 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
2522 { "(bad)", { XX } },
2523 { "(bad)", { XX } },
2524 { "(bad)", { XX } },
2525 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
2530 { "(bad)", { XX } },
2531 { "(bad)", { XX } },
2532 { "pcmpestrm", { XM, EXx, Ib } },
2533 { "(bad)", { XX } },
2538 { "(bad)", { XX } },
2539 { "(bad)", { XX } },
2540 { "pcmpestri", { XM, EXx, Ib } },
2541 { "(bad)", { XX } },
2546 { "(bad)", { XX } },
2547 { "(bad)", { XX } },
2548 { "pcmpistrm", { XM, EXx, Ib } },
2549 { "(bad)", { XX } },
2554 { "(bad)", { XX } },
2555 { "(bad)", { XX } },
2556 { "pcmpistri", { XM, EXx, Ib } },
2557 { "(bad)", { XX } },
2562 { "ucomiss",{ XM, EXd } },
2563 { "(bad)", { XX } },
2564 { "ucomisd",{ XM, EXq } },
2565 { "(bad)", { XX } },
2570 { "comiss", { XM, EXd } },
2571 { "(bad)", { XX } },
2572 { "comisd", { XM, EXq } },
2573 { "(bad)", { XX } },
2578 { "punpcklbw",{ MX, EMd } },
2579 { "(bad)", { XX } },
2580 { "punpcklbw",{ MX, EMq } },
2581 { "(bad)", { XX } },
2586 { "punpcklwd",{ MX, EMd } },
2587 { "(bad)", { XX } },
2588 { "punpcklwd",{ MX, EMq } },
2589 { "(bad)", { XX } },
2594 { "punpckldq",{ MX, EMd } },
2595 { "(bad)", { XX } },
2596 { "punpckldq",{ MX, EMq } },
2597 { "(bad)", { XX } },
2602 { "(bad)", { XX } },
2603 { "(bad)", { XX } },
2604 { "invept", { Gm, Mo } },
2605 { "(bad)", { XX } },
2610 { "(bad)", { XX } },
2611 { "(bad)", { XX } },
2612 { "invvpid",{ Gm, Mo } },
2613 { "(bad)", { XX } },
2618 { "(bad)", { XX } },
2619 { "(bad)", { XX } },
2620 { "aesimc", { XM, EXx } },
2621 { "(bad)", { XX } },
2626 { "(bad)", { XX } },
2627 { "(bad)", { XX } },
2628 { "aesenc",{ XM, EXx } },
2629 { "(bad)", { XX } },
2634 { "(bad)", { XX } },
2635 { "(bad)", { XX } },
2636 { "aesenclast", { XM, EXx } },
2637 { "(bad)", { XX } },
2642 { "(bad)", { XX } },
2643 { "(bad)", { XX } },
2644 { "aesdec", { XM, EXx } },
2645 { "(bad)", { XX } },
2650 { "(bad)", { XX } },
2651 { "(bad)", { XX } },
2652 { "aesdeclast", { XM, EXx } },
2653 { "(bad)", { XX } },
2658 { "(bad)", { XX } },
2659 { "(bad)", { XX } },
2660 { "aeskeygenassist", { XM, EXx, Ib } },
2661 { "(bad)", { XX } },
2666 { "(bad)", { XX } },
2667 { "(bad)", { XX } },
2668 { "pclmulqdq", { XM, EXx, Ib } },
2669 { "(bad)", { XX } },
2673 static const struct dis386 x86_64_table[][2] = {
2675 { "pusha{P|}", { XX } },
2676 { "(bad)", { XX } },
2679 { "popa{P|}", { XX } },
2680 { "(bad)", { XX } },
2683 { "bound{S|}", { Gv, Ma } },
2684 { "(bad)", { XX } },
2687 { "arpl", { Ew, Gw } },
2688 { "movs{||lq|xd}", { Gv, Ed } },
2692 static const struct dis386 three_byte_table[][256] = {
2696 { "pshufb", { MX, EM } },
2697 { "phaddw", { MX, EM } },
2698 { "phaddd", { MX, EM } },
2699 { "phaddsw", { MX, EM } },
2700 { "pmaddubsw", { MX, EM } },
2701 { "phsubw", { MX, EM } },
2702 { "phsubd", { MX, EM } },
2703 { "phsubsw", { MX, EM } },
2705 { "psignb", { MX, EM } },
2706 { "psignw", { MX, EM } },
2707 { "psignd", { MX, EM } },
2708 { "pmulhrsw", { MX, EM } },
2709 { "(bad)", { XX } },
2710 { "(bad)", { XX } },
2711 { "(bad)", { XX } },
2712 { "(bad)", { XX } },
2715 { "(bad)", { XX } },
2716 { "(bad)", { XX } },
2717 { "(bad)", { XX } },
2720 { "(bad)", { XX } },
2723 { "(bad)", { XX } },
2724 { "(bad)", { XX } },
2725 { "(bad)", { XX } },
2726 { "(bad)", { XX } },
2727 { "pabsb", { MX, EM } },
2728 { "pabsw", { MX, EM } },
2729 { "pabsd", { MX, EM } },
2730 { "(bad)", { XX } },
2738 { "(bad)", { XX } },
2739 { "(bad)", { XX } },
2745 { "(bad)", { XX } },
2746 { "(bad)", { XX } },
2747 { "(bad)", { XX } },
2748 { "(bad)", { XX } },
2756 { "(bad)", { XX } },
2770 { "(bad)", { XX } },
2771 { "(bad)", { XX } },
2772 { "(bad)", { XX } },
2773 { "(bad)", { XX } },
2774 { "(bad)", { XX } },
2775 { "(bad)", { XX } },
2777 { "(bad)", { XX } },
2778 { "(bad)", { XX } },
2779 { "(bad)", { XX } },
2780 { "(bad)", { XX } },
2781 { "(bad)", { XX } },
2782 { "(bad)", { XX } },
2783 { "(bad)", { XX } },
2784 { "(bad)", { XX } },
2786 { "(bad)", { XX } },
2787 { "(bad)", { XX } },
2788 { "(bad)", { XX } },
2789 { "(bad)", { XX } },
2790 { "(bad)", { XX } },
2791 { "(bad)", { XX } },
2792 { "(bad)", { XX } },
2793 { "(bad)", { XX } },
2795 { "(bad)", { XX } },
2796 { "(bad)", { XX } },
2797 { "(bad)", { XX } },
2798 { "(bad)", { XX } },
2799 { "(bad)", { XX } },
2800 { "(bad)", { XX } },
2801 { "(bad)", { XX } },
2802 { "(bad)", { XX } },
2804 { "(bad)", { XX } },
2805 { "(bad)", { XX } },
2806 { "(bad)", { XX } },
2807 { "(bad)", { XX } },
2808 { "(bad)", { XX } },
2809 { "(bad)", { XX } },
2810 { "(bad)", { XX } },
2811 { "(bad)", { XX } },
2813 { "(bad)", { XX } },
2814 { "(bad)", { XX } },
2815 { "(bad)", { XX } },
2816 { "(bad)", { XX } },
2817 { "(bad)", { XX } },
2818 { "(bad)", { XX } },
2819 { "(bad)", { XX } },
2820 { "(bad)", { XX } },
2822 { "(bad)", { XX } },
2823 { "(bad)", { XX } },
2824 { "(bad)", { XX } },
2825 { "(bad)", { XX } },
2826 { "(bad)", { XX } },
2827 { "(bad)", { XX } },
2828 { "(bad)", { XX } },
2829 { "(bad)", { XX } },
2831 { "(bad)", { XX } },
2832 { "(bad)", { XX } },
2833 { "(bad)", { XX } },
2834 { "(bad)", { XX } },
2835 { "(bad)", { XX } },
2836 { "(bad)", { XX } },
2837 { "(bad)", { XX } },
2838 { "(bad)", { XX } },
2842 { "(bad)", { XX } },
2843 { "(bad)", { XX } },
2844 { "(bad)", { XX } },
2845 { "(bad)", { XX } },
2846 { "(bad)", { XX } },
2847 { "(bad)", { XX } },
2849 { "(bad)", { XX } },
2850 { "(bad)", { XX } },
2851 { "(bad)", { XX } },
2852 { "(bad)", { XX } },
2853 { "(bad)", { XX } },
2854 { "(bad)", { XX } },
2855 { "(bad)", { XX } },
2856 { "(bad)", { XX } },
2858 { "(bad)", { XX } },
2859 { "(bad)", { XX } },
2860 { "(bad)", { XX } },
2861 { "(bad)", { XX } },
2862 { "(bad)", { XX } },
2863 { "(bad)", { XX } },
2864 { "(bad)", { XX } },
2865 { "(bad)", { XX } },
2867 { "(bad)", { XX } },
2868 { "(bad)", { XX } },
2869 { "(bad)", { XX } },
2870 { "(bad)", { XX } },
2871 { "(bad)", { XX } },
2872 { "(bad)", { XX } },
2873 { "(bad)", { XX } },
2874 { "(bad)", { XX } },
2876 { "(bad)", { XX } },
2877 { "(bad)", { XX } },
2878 { "(bad)", { XX } },
2879 { "(bad)", { XX } },
2880 { "(bad)", { XX } },
2881 { "(bad)", { XX } },
2882 { "(bad)", { XX } },
2883 { "(bad)", { XX } },
2885 { "(bad)", { XX } },
2886 { "(bad)", { XX } },
2887 { "(bad)", { XX } },
2888 { "(bad)", { XX } },
2889 { "(bad)", { XX } },
2890 { "(bad)", { XX } },
2891 { "(bad)", { XX } },
2892 { "(bad)", { XX } },
2894 { "(bad)", { XX } },
2895 { "(bad)", { XX } },
2896 { "(bad)", { XX } },
2897 { "(bad)", { XX } },
2898 { "(bad)", { XX } },
2899 { "(bad)", { XX } },
2900 { "(bad)", { XX } },
2901 { "(bad)", { XX } },
2903 { "(bad)", { XX } },
2904 { "(bad)", { XX } },
2905 { "(bad)", { XX } },
2906 { "(bad)", { XX } },
2907 { "(bad)", { XX } },
2908 { "(bad)", { XX } },
2909 { "(bad)", { XX } },
2910 { "(bad)", { XX } },
2912 { "(bad)", { XX } },
2913 { "(bad)", { XX } },
2914 { "(bad)", { XX } },
2915 { "(bad)", { XX } },
2916 { "(bad)", { XX } },
2917 { "(bad)", { XX } },
2918 { "(bad)", { XX } },
2919 { "(bad)", { XX } },
2921 { "(bad)", { XX } },
2922 { "(bad)", { XX } },
2923 { "(bad)", { XX } },
2924 { "(bad)", { XX } },
2925 { "(bad)", { XX } },
2926 { "(bad)", { XX } },
2927 { "(bad)", { XX } },
2928 { "(bad)", { XX } },
2930 { "(bad)", { XX } },
2931 { "(bad)", { XX } },
2932 { "(bad)", { XX } },
2933 { "(bad)", { XX } },
2934 { "(bad)", { XX } },
2935 { "(bad)", { XX } },
2936 { "(bad)", { XX } },
2937 { "(bad)", { XX } },
2939 { "(bad)", { XX } },
2940 { "(bad)", { XX } },
2941 { "(bad)", { XX } },
2948 { "(bad)", { XX } },
2949 { "(bad)", { XX } },
2950 { "(bad)", { XX } },
2951 { "(bad)", { XX } },
2952 { "(bad)", { XX } },
2953 { "(bad)", { XX } },
2954 { "(bad)", { XX } },
2955 { "(bad)", { XX } },
2957 { "(bad)", { XX } },
2958 { "(bad)", { XX } },
2959 { "(bad)", { XX } },
2960 { "(bad)", { XX } },
2961 { "(bad)", { XX } },
2962 { "(bad)", { XX } },
2963 { "(bad)", { XX } },
2964 { "(bad)", { XX } },
2968 { "(bad)", { XX } },
2969 { "(bad)", { XX } },
2970 { "(bad)", { XX } },
2971 { "(bad)", { XX } },
2972 { "(bad)", { XX } },
2973 { "(bad)", { XX } },
2975 { "(bad)", { XX } },
2976 { "(bad)", { XX } },
2977 { "(bad)", { XX } },
2978 { "(bad)", { XX } },
2979 { "(bad)", { XX } },
2980 { "(bad)", { XX } },
2981 { "(bad)", { XX } },
2982 { "(bad)", { XX } },
2987 { "(bad)", { XX } },
2988 { "(bad)", { XX } },
2989 { "(bad)", { XX } },
2990 { "(bad)", { XX } },
2991 { "(bad)", { XX } },
2992 { "(bad)", { XX } },
2993 { "(bad)", { XX } },
2994 { "(bad)", { XX } },
3003 { "palignr", { MX, EM, Ib } },
3005 { "(bad)", { XX } },
3006 { "(bad)", { XX } },
3007 { "(bad)", { XX } },
3008 { "(bad)", { XX } },
3014 { "(bad)", { XX } },
3015 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "(bad)", { XX } },
3018 { "(bad)", { XX } },
3019 { "(bad)", { XX } },
3020 { "(bad)", { XX } },
3021 { "(bad)", { XX } },
3026 { "(bad)", { XX } },
3027 { "(bad)", { XX } },
3028 { "(bad)", { XX } },
3029 { "(bad)", { XX } },
3030 { "(bad)", { XX } },
3032 { "(bad)", { XX } },
3033 { "(bad)", { XX } },
3034 { "(bad)", { XX } },
3035 { "(bad)", { XX } },
3036 { "(bad)", { XX } },
3037 { "(bad)", { XX } },
3038 { "(bad)", { XX } },
3039 { "(bad)", { XX } },
3041 { "(bad)", { XX } },
3042 { "(bad)", { XX } },
3043 { "(bad)", { XX } },
3044 { "(bad)", { XX } },
3045 { "(bad)", { XX } },
3046 { "(bad)", { XX } },
3047 { "(bad)", { XX } },
3048 { "(bad)", { XX } },
3050 { "(bad)", { XX } },
3051 { "(bad)", { XX } },
3052 { "(bad)", { XX } },
3053 { "(bad)", { XX } },
3054 { "(bad)", { XX } },
3055 { "(bad)", { XX } },
3056 { "(bad)", { XX } },
3057 { "(bad)", { XX } },
3062 { "(bad)", { XX } },
3064 { "(bad)", { XX } },
3065 { "(bad)", { XX } },
3066 { "(bad)", { XX } },
3068 { "(bad)", { XX } },
3069 { "(bad)", { XX } },
3070 { "(bad)", { XX } },
3071 { "(bad)", { XX } },
3072 { "(bad)", { XX } },
3073 { "(bad)", { XX } },
3074 { "(bad)", { XX } },
3075 { "(bad)", { XX } },
3077 { "(bad)", { XX } },
3078 { "(bad)", { XX } },
3079 { "(bad)", { XX } },
3080 { "(bad)", { XX } },
3081 { "(bad)", { XX } },
3082 { "(bad)", { XX } },
3083 { "(bad)", { XX } },
3084 { "(bad)", { XX } },
3086 { "(bad)", { XX } },
3087 { "(bad)", { XX } },
3088 { "(bad)", { XX } },
3089 { "(bad)", { XX } },
3090 { "(bad)", { XX } },
3091 { "(bad)", { XX } },
3092 { "(bad)", { XX } },
3093 { "(bad)", { XX } },
3099 { "(bad)", { XX } },
3100 { "(bad)", { XX } },
3101 { "(bad)", { XX } },
3102 { "(bad)", { XX } },
3104 { "(bad)", { XX } },
3105 { "(bad)", { XX } },
3106 { "(bad)", { XX } },
3107 { "(bad)", { XX } },
3108 { "(bad)", { XX } },
3109 { "(bad)", { XX } },
3110 { "(bad)", { XX } },
3111 { "(bad)", { XX } },
3113 { "(bad)", { XX } },
3114 { "(bad)", { XX } },
3115 { "(bad)", { XX } },
3116 { "(bad)", { XX } },
3117 { "(bad)", { XX } },
3118 { "(bad)", { XX } },
3119 { "(bad)", { XX } },
3120 { "(bad)", { XX } },
3122 { "(bad)", { XX } },
3123 { "(bad)", { XX } },
3124 { "(bad)", { XX } },
3125 { "(bad)", { XX } },
3126 { "(bad)", { XX } },
3127 { "(bad)", { XX } },
3128 { "(bad)", { XX } },
3129 { "(bad)", { XX } },
3131 { "(bad)", { XX } },
3132 { "(bad)", { XX } },
3133 { "(bad)", { XX } },
3134 { "(bad)", { XX } },
3135 { "(bad)", { XX } },
3136 { "(bad)", { XX } },
3137 { "(bad)", { XX } },
3138 { "(bad)", { XX } },
3140 { "(bad)", { XX } },
3141 { "(bad)", { XX } },
3142 { "(bad)", { XX } },
3143 { "(bad)", { XX } },
3144 { "(bad)", { XX } },
3145 { "(bad)", { XX } },
3146 { "(bad)", { XX } },
3147 { "(bad)", { XX } },
3149 { "(bad)", { XX } },
3150 { "(bad)", { XX } },
3151 { "(bad)", { XX } },
3152 { "(bad)", { XX } },
3153 { "(bad)", { XX } },
3154 { "(bad)", { XX } },
3155 { "(bad)", { XX } },
3156 { "(bad)", { XX } },
3158 { "(bad)", { XX } },
3159 { "(bad)", { XX } },
3160 { "(bad)", { XX } },
3161 { "(bad)", { XX } },
3162 { "(bad)", { XX } },
3163 { "(bad)", { XX } },
3164 { "(bad)", { XX } },
3165 { "(bad)", { XX } },
3167 { "(bad)", { XX } },
3168 { "(bad)", { XX } },
3169 { "(bad)", { XX } },
3170 { "(bad)", { XX } },
3171 { "(bad)", { XX } },
3172 { "(bad)", { XX } },
3173 { "(bad)", { XX } },
3174 { "(bad)", { XX } },
3176 { "(bad)", { XX } },
3177 { "(bad)", { XX } },
3178 { "(bad)", { XX } },
3179 { "(bad)", { XX } },
3180 { "(bad)", { XX } },
3181 { "(bad)", { XX } },
3182 { "(bad)", { XX } },
3183 { "(bad)", { XX } },
3185 { "(bad)", { XX } },
3186 { "(bad)", { XX } },
3187 { "(bad)", { XX } },
3188 { "(bad)", { XX } },
3189 { "(bad)", { XX } },
3190 { "(bad)", { XX } },
3191 { "(bad)", { XX } },
3192 { "(bad)", { XX } },
3194 { "(bad)", { XX } },
3195 { "(bad)", { XX } },
3196 { "(bad)", { XX } },
3197 { "(bad)", { XX } },
3198 { "(bad)", { XX } },
3199 { "(bad)", { XX } },
3200 { "(bad)", { XX } },
3201 { "(bad)", { XX } },
3203 { "(bad)", { XX } },
3204 { "(bad)", { XX } },
3205 { "(bad)", { XX } },
3206 { "(bad)", { XX } },
3207 { "(bad)", { XX } },
3208 { "(bad)", { XX } },
3209 { "(bad)", { XX } },
3210 { "(bad)", { XX } },
3212 { "(bad)", { XX } },
3213 { "(bad)", { XX } },
3214 { "(bad)", { XX } },
3215 { "(bad)", { XX } },
3216 { "(bad)", { XX } },
3217 { "(bad)", { XX } },
3218 { "(bad)", { XX } },
3219 { "(bad)", { XX } },
3221 { "(bad)", { XX } },
3222 { "(bad)", { XX } },
3223 { "(bad)", { XX } },
3224 { "(bad)", { XX } },
3225 { "(bad)", { XX } },
3226 { "(bad)", { XX } },
3227 { "(bad)", { XX } },
3228 { "(bad)", { XX } },
3230 { "(bad)", { XX } },
3231 { "(bad)", { XX } },
3232 { "(bad)", { XX } },
3233 { "(bad)", { XX } },
3234 { "(bad)", { XX } },
3235 { "(bad)", { XX } },
3236 { "(bad)", { XX } },
3239 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "(bad)", { XX } },
3242 { "(bad)", { XX } },
3243 { "(bad)", { XX } },
3244 { "(bad)", { XX } },
3245 { "(bad)", { XX } },
3246 { "(bad)", { XX } },
3248 { "(bad)", { XX } },
3249 { "(bad)", { XX } },
3250 { "(bad)", { XX } },
3251 { "(bad)", { XX } },
3252 { "(bad)", { XX } },
3253 { "(bad)", { XX } },
3254 { "(bad)", { XX } },
3255 { "(bad)", { XX } },
3257 { "(bad)", { XX } },
3258 { "(bad)", { XX } },
3259 { "(bad)", { XX } },
3260 { "(bad)", { XX } },
3261 { "(bad)", { XX } },
3262 { "(bad)", { XX } },
3263 { "(bad)", { XX } },
3264 { "(bad)", { XX } },
3266 { "(bad)", { XX } },
3267 { "(bad)", { XX } },
3268 { "(bad)", { XX } },
3269 { "(bad)", { XX } },
3270 { "(bad)", { XX } },
3271 { "(bad)", { XX } },
3272 { "(bad)", { XX } },
3273 { "(bad)", { XX } },
3277 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
3289 (void) FETCH_DATA (the_info, codep + 1);
3293 /* REX prefixes family. */
3310 if (address_mode == mode_64bit)
3316 prefixes |= PREFIX_REPZ;
3319 prefixes |= PREFIX_REPNZ;
3322 prefixes |= PREFIX_LOCK;
3325 prefixes |= PREFIX_CS;
3328 prefixes |= PREFIX_SS;
3331 prefixes |= PREFIX_DS;
3334 prefixes |= PREFIX_ES;
3337 prefixes |= PREFIX_FS;
3340 prefixes |= PREFIX_GS;
3343 prefixes |= PREFIX_DATA;
3346 prefixes |= PREFIX_ADDR;
3349 /* fwait is really an instruction. If there are prefixes
3350 before the fwait, they belong to the fwait, *not* to the
3351 following instruction. */
3352 if (prefixes || rex)
3354 prefixes |= PREFIX_FWAIT;
3358 prefixes = PREFIX_FWAIT;
3363 /* Rex is ignored when followed by another prefix. */
3374 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
3378 prefix_name (int pref, int sizeflag)
3380 static const char *rexes [16] =
3385 "rex.XB", /* 0x43 */
3387 "rex.RB", /* 0x45 */
3388 "rex.RX", /* 0x46 */
3389 "rex.RXB", /* 0x47 */
3391 "rex.WB", /* 0x49 */
3392 "rex.WX", /* 0x4a */
3393 "rex.WXB", /* 0x4b */
3394 "rex.WR", /* 0x4c */
3395 "rex.WRB", /* 0x4d */
3396 "rex.WRX", /* 0x4e */
3397 "rex.WRXB", /* 0x4f */
3402 /* REX prefixes family. */
3419 return rexes [pref - 0x40];
3439 return (sizeflag & DFLAG) ? "data16" : "data32";
3441 if (address_mode == mode_64bit)
3442 return (sizeflag & AFLAG) ? "addr32" : "addr64";
3444 return (sizeflag & AFLAG) ? "addr16" : "addr32";
3452 static char op_out[MAX_OPERANDS][100];
3453 static int op_ad, op_index[MAX_OPERANDS];
3454 static int two_source_ops;
3455 static bfd_vma op_address[MAX_OPERANDS];
3456 static bfd_vma op_riprel[MAX_OPERANDS];
3457 static bfd_vma start_pc;
3460 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
3461 * (see topic "Redundant prefixes" in the "Differences from 8086"
3462 * section of the "Virtual 8086 Mode" chapter.)
3463 * 'pc' should be the address of this instruction, it will
3464 * be used to print the target address if this is a relative jump or call
3465 * The function returns the length of this instruction in bytes.
3468 static char intel_syntax;
3469 static char open_char;
3470 static char close_char;
3471 static char separator_char;
3472 static char scale_char;
3474 /* Here for backwards compatibility. When gdb stops using
3475 print_insn_i386_att and print_insn_i386_intel these functions can
3476 disappear, and print_insn_i386 be merged into print_insn. */
3478 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
3482 return print_insn (pc, info);
3486 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
3490 return print_insn (pc, info);
3494 print_insn_i386 (bfd_vma pc, disassemble_info *info)
3498 return print_insn (pc, info);
3502 print_i386_disassembler_options (FILE *stream)
3504 fprintf (stream, _("\n\
3505 The following i386/x86-64 specific disassembler options are supported for use\n\
3506 with the -M switch (multiple options should be separated by commas):\n"));
3508 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
3509 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
3510 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
3511 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
3512 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
3513 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
3514 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
3515 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
3516 fprintf (stream, _(" data32 Assume 32bit data size\n"));
3517 fprintf (stream, _(" data16 Assume 16bit data size\n"));
3518 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
3522 print_insn (bfd_vma pc, disassemble_info *info)
3524 const struct dis386 *dp;
3526 char *op_txt[MAX_OPERANDS];
3528 unsigned char uses_DATA_prefix, uses_LOCK_prefix;
3529 unsigned char uses_REPNZ_prefix, uses_REPZ_prefix;
3532 struct dis_private priv;
3535 if (info->mach == bfd_mach_x86_64_intel_syntax
3536 || info->mach == bfd_mach_x86_64)
3537 address_mode = mode_64bit;
3539 address_mode = mode_32bit;
3541 if (intel_syntax == (char) -1)
3542 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
3543 || info->mach == bfd_mach_x86_64_intel_syntax);
3545 if (info->mach == bfd_mach_i386_i386
3546 || info->mach == bfd_mach_x86_64
3547 || info->mach == bfd_mach_i386_i386_intel_syntax
3548 || info->mach == bfd_mach_x86_64_intel_syntax)
3549 priv.orig_sizeflag = AFLAG | DFLAG;
3550 else if (info->mach == bfd_mach_i386_i8086)
3551 priv.orig_sizeflag = 0;
3555 for (p = info->disassembler_options; p != NULL; )
3557 if (CONST_STRNEQ (p, "x86-64"))
3559 address_mode = mode_64bit;
3560 priv.orig_sizeflag = AFLAG | DFLAG;
3562 else if (CONST_STRNEQ (p, "i386"))
3564 address_mode = mode_32bit;
3565 priv.orig_sizeflag = AFLAG | DFLAG;
3567 else if (CONST_STRNEQ (p, "i8086"))
3569 address_mode = mode_16bit;
3570 priv.orig_sizeflag = 0;
3572 else if (CONST_STRNEQ (p, "intel"))
3576 else if (CONST_STRNEQ (p, "att"))
3580 else if (CONST_STRNEQ (p, "addr"))
3582 if (address_mode == mode_64bit)
3584 if (p[4] == '3' && p[5] == '2')
3585 priv.orig_sizeflag &= ~AFLAG;
3586 else if (p[4] == '6' && p[5] == '4')
3587 priv.orig_sizeflag |= AFLAG;
3591 if (p[4] == '1' && p[5] == '6')
3592 priv.orig_sizeflag &= ~AFLAG;
3593 else if (p[4] == '3' && p[5] == '2')
3594 priv.orig_sizeflag |= AFLAG;
3597 else if (CONST_STRNEQ (p, "data"))
3599 if (p[4] == '1' && p[5] == '6')
3600 priv.orig_sizeflag &= ~DFLAG;
3601 else if (p[4] == '3' && p[5] == '2')
3602 priv.orig_sizeflag |= DFLAG;
3604 else if (CONST_STRNEQ (p, "suffix"))
3605 priv.orig_sizeflag |= SUFFIX_ALWAYS;
3607 p = strchr (p, ',');
3614 names64 = intel_names64;
3615 names32 = intel_names32;
3616 names16 = intel_names16;
3617 names8 = intel_names8;
3618 names8rex = intel_names8rex;
3619 names_seg = intel_names_seg;
3620 index16 = intel_index16;
3623 separator_char = '+';
3628 names64 = att_names64;
3629 names32 = att_names32;
3630 names16 = att_names16;
3631 names8 = att_names8;
3632 names8rex = att_names8rex;
3633 names_seg = att_names_seg;
3634 index16 = att_index16;
3637 separator_char = ',';
3641 /* The output looks better if we put 7 bytes on a line, since that
3642 puts most long word instructions on a single line. */
3643 info->bytes_per_line = 7;
3645 info->private_data = &priv;
3646 priv.max_fetched = priv.the_buffer;
3647 priv.insn_start = pc;
3650 for (i = 0; i < MAX_OPERANDS; ++i)
3658 start_codep = priv.the_buffer;
3659 codep = priv.the_buffer;
3661 if (setjmp (priv.bailout) != 0)
3665 /* Getting here means we tried for data but didn't get it. That
3666 means we have an incomplete instruction of some sort. Just
3667 print the first byte as a prefix or a .byte pseudo-op. */
3668 if (codep > priv.the_buffer)
3670 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3672 (*info->fprintf_func) (info->stream, "%s", name);
3675 /* Just print the first byte as a .byte instruction. */
3676 (*info->fprintf_func) (info->stream, ".byte 0x%x",
3677 (unsigned int) priv.the_buffer[0]);
3690 sizeflag = priv.orig_sizeflag;
3692 (void) FETCH_DATA (info, codep + 1);
3693 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
3695 if (((prefixes & PREFIX_FWAIT)
3696 && ((*codep < 0xd8) || (*codep > 0xdf)))
3697 || (rex && rex_used))
3701 /* fwait not followed by floating point instruction, or rex followed
3702 by other prefixes. Print the first prefix. */
3703 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3705 name = INTERNAL_DISASSEMBLER_ERROR;
3706 (*info->fprintf_func) (info->stream, "%s", name);
3713 unsigned char threebyte;
3714 (void) FETCH_DATA (info, codep + 2);
3715 threebyte = *++codep;
3716 dp = &dis386_twobyte[threebyte];
3717 need_modrm = twobyte_has_modrm[*codep];
3718 uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep];
3719 uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep];
3720 uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep];
3721 uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
3723 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3725 (void) FETCH_DATA (info, codep + 2);
3730 uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op];
3731 uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op];
3732 uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op];
3735 uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op];
3736 uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op];
3737 uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op];
3746 dp = &dis386[*codep];
3747 need_modrm = onebyte_has_modrm[*codep];
3748 uses_DATA_prefix = 0;
3749 uses_REPNZ_prefix = 0;
3750 /* pause is 0xf3 0x90. */
3751 uses_REPZ_prefix = *codep == 0x90;
3752 uses_LOCK_prefix = 0;
3756 if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ))
3759 used_prefixes |= PREFIX_REPZ;
3761 if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ))
3764 used_prefixes |= PREFIX_REPNZ;
3767 if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
3770 used_prefixes |= PREFIX_LOCK;
3773 if (prefixes & PREFIX_ADDR)
3776 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
3778 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3779 oappend ("addr32 ");
3781 oappend ("addr16 ");
3782 used_prefixes |= PREFIX_ADDR;
3786 if (!uses_DATA_prefix && (prefixes & PREFIX_DATA))
3789 if (dp->op[2].bytemode == cond_jump_mode
3790 && dp->op[0].bytemode == v_mode
3793 if (sizeflag & DFLAG)
3794 oappend ("data32 ");
3796 oappend ("data16 ");
3797 used_prefixes |= PREFIX_DATA;
3801 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3803 dp = &three_byte_table[dp->op[1].bytemode][op];
3804 modrm.mod = (*codep >> 6) & 3;
3805 modrm.reg = (*codep >> 3) & 7;
3806 modrm.rm = *codep & 7;
3808 else if (need_modrm)
3810 (void) FETCH_DATA (info, codep + 1);
3811 modrm.mod = (*codep >> 6) & 3;
3812 modrm.reg = (*codep >> 3) & 7;
3813 modrm.rm = *codep & 7;
3816 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
3823 if (dp->name == NULL)
3825 switch (dp->op[0].bytemode)
3828 dp = &grps[dp->op[1].bytemode][modrm.reg];
3831 case USE_PREFIX_USER_TABLE:
3833 used_prefixes |= (prefixes & PREFIX_REPZ);
3834 if (prefixes & PREFIX_REPZ)
3838 /* We should check PREFIX_REPNZ and PREFIX_REPZ
3839 before PREFIX_DATA. */
3840 used_prefixes |= (prefixes & PREFIX_REPNZ);
3841 if (prefixes & PREFIX_REPNZ)
3845 used_prefixes |= (prefixes & PREFIX_DATA);
3846 if (prefixes & PREFIX_DATA)
3850 dp = &prefix_user_table[dp->op[1].bytemode][index];
3853 case X86_64_SPECIAL:
3854 index = address_mode == mode_64bit ? 1 : 0;
3855 dp = &x86_64_table[dp->op[1].bytemode][index];
3859 oappend (INTERNAL_DISASSEMBLER_ERROR);
3864 if (putop (dp->name, sizeflag) == 0)
3866 for (i = 0; i < MAX_OPERANDS; ++i)
3869 op_ad = MAX_OPERANDS - 1 - i;
3871 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
3876 /* See if any prefixes were not used. If so, print the first one
3877 separately. If we don't do this, we'll wind up printing an
3878 instruction stream which does not precisely correspond to the
3879 bytes we are disassembling. */
3880 if ((prefixes & ~used_prefixes) != 0)
3884 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3886 name = INTERNAL_DISASSEMBLER_ERROR;
3887 (*info->fprintf_func) (info->stream, "%s", name);
3890 if (rex & ~rex_used)
3893 name = prefix_name (rex | 0x40, priv.orig_sizeflag);
3895 name = INTERNAL_DISASSEMBLER_ERROR;
3896 (*info->fprintf_func) (info->stream, "%s ", name);
3899 obufp = obuf + strlen (obuf);
3900 for (i = strlen (obuf); i < 6; i++)
3903 (*info->fprintf_func) (info->stream, "%s", obuf);
3905 /* The enter and bound instructions are printed with operands in the same
3906 order as the intel book; everything else is printed in reverse order. */
3907 if (intel_syntax || two_source_ops)
3911 for (i = 0; i < MAX_OPERANDS; ++i)
3912 op_txt[i] = op_out[i];
3914 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
3916 op_ad = op_index[i];
3917 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
3918 op_index[MAX_OPERANDS - 1 - i] = op_ad;
3919 riprel = op_riprel[i];
3920 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
3921 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
3926 for (i = 0; i < MAX_OPERANDS; ++i)
3927 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
3931 for (i = 0; i < MAX_OPERANDS; ++i)
3935 (*info->fprintf_func) (info->stream, ",");
3936 if (op_index[i] != -1 && !op_riprel[i])
3937 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
3939 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
3943 for (i = 0; i < MAX_OPERANDS; i++)
3944 if (op_index[i] != -1 && op_riprel[i])
3946 (*info->fprintf_func) (info->stream, " # ");
3947 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
3948 + op_address[op_index[i]]), info);
3951 return codep - priv.the_buffer;
3954 static const char *float_mem[] = {
4029 static const unsigned char float_mem_mode[] = {
4104 #define ST { OP_ST, 0 }
4105 #define STi { OP_STi, 0 }
4107 #define FGRPd9_2 NULL, { { NULL, 0 } }
4108 #define FGRPd9_4 NULL, { { NULL, 1 } }
4109 #define FGRPd9_5 NULL, { { NULL, 2 } }
4110 #define FGRPd9_6 NULL, { { NULL, 3 } }
4111 #define FGRPd9_7 NULL, { { NULL, 4 } }
4112 #define FGRPda_5 NULL, { { NULL, 5 } }
4113 #define FGRPdb_4 NULL, { { NULL, 6 } }
4114 #define FGRPde_3 NULL, { { NULL, 7 } }
4115 #define FGRPdf_4 NULL, { { NULL, 8 } }
4117 static const struct dis386 float_reg[][8] = {
4120 { "fadd", { ST, STi } },
4121 { "fmul", { ST, STi } },
4122 { "fcom", { STi } },
4123 { "fcomp", { STi } },
4124 { "fsub", { ST, STi } },
4125 { "fsubr", { ST, STi } },
4126 { "fdiv", { ST, STi } },
4127 { "fdivr", { ST, STi } },
4132 { "fxch", { STi } },
4134 { "(bad)", { XX } },
4142 { "fcmovb", { ST, STi } },
4143 { "fcmove", { ST, STi } },
4144 { "fcmovbe",{ ST, STi } },
4145 { "fcmovu", { ST, STi } },
4146 { "(bad)", { XX } },
4148 { "(bad)", { XX } },
4149 { "(bad)", { XX } },
4153 { "fcmovnb",{ ST, STi } },
4154 { "fcmovne",{ ST, STi } },
4155 { "fcmovnbe",{ ST, STi } },
4156 { "fcmovnu",{ ST, STi } },
4158 { "fucomi", { ST, STi } },
4159 { "fcomi", { ST, STi } },
4160 { "(bad)", { XX } },
4164 { "fadd", { STi, ST } },
4165 { "fmul", { STi, ST } },
4166 { "(bad)", { XX } },
4167 { "(bad)", { XX } },
4169 { "fsub", { STi, ST } },
4170 { "fsubr", { STi, ST } },
4171 { "fdiv", { STi, ST } },
4172 { "fdivr", { STi, ST } },
4174 { "fsubr", { STi, ST } },
4175 { "fsub", { STi, ST } },
4176 { "fdivr", { STi, ST } },
4177 { "fdiv", { STi, ST } },
4182 { "ffree", { STi } },
4183 { "(bad)", { XX } },
4185 { "fstp", { STi } },
4186 { "fucom", { STi } },
4187 { "fucomp", { STi } },
4188 { "(bad)", { XX } },
4189 { "(bad)", { XX } },
4193 { "faddp", { STi, ST } },
4194 { "fmulp", { STi, ST } },
4195 { "(bad)", { XX } },
4198 { "fsubp", { STi, ST } },
4199 { "fsubrp", { STi, ST } },
4200 { "fdivp", { STi, ST } },
4201 { "fdivrp", { STi, ST } },
4203 { "fsubrp", { STi, ST } },
4204 { "fsubp", { STi, ST } },
4205 { "fdivrp", { STi, ST } },
4206 { "fdivp", { STi, ST } },
4211 { "ffreep", { STi } },
4212 { "(bad)", { XX } },
4213 { "(bad)", { XX } },
4214 { "(bad)", { XX } },
4216 { "fucomip", { ST, STi } },
4217 { "fcomip", { ST, STi } },
4218 { "(bad)", { XX } },
4222 static char *fgrps[][8] = {
4225 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4230 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
4235 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
4240 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
4245 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
4250 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4255 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
4256 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
4261 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4266 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4271 dofloat (int sizeflag)
4273 const struct dis386 *dp;
4274 unsigned char floatop;
4276 floatop = codep[-1];
4280 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
4282 putop (float_mem[fp_indx], sizeflag);
4285 OP_E (float_mem_mode[fp_indx], sizeflag);
4288 /* Skip mod/rm byte. */
4292 dp = &float_reg[floatop - 0xd8][modrm.reg];
4293 if (dp->name == NULL)
4295 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
4297 /* Instruction fnstsw is only one with strange arg. */
4298 if (floatop == 0xdf && codep[-1] == 0xe0)
4299 strcpy (op_out[0], names16[0]);
4303 putop (dp->name, sizeflag);
4308 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
4313 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
4318 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4320 oappend ("%st" + intel_syntax);
4324 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4326 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
4327 oappend (scratchbuf + intel_syntax);
4330 /* Capital letters in template are macros. */
4332 putop (const char *template, int sizeflag)
4337 for (p = template; *p; p++)
4348 if (address_mode == mode_64bit)
4356 /* Alternative not valid. */
4357 strcpy (obuf, "(bad)");
4361 else if (*p == '\0')
4382 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4388 if (sizeflag & SUFFIX_ALWAYS)
4392 if (intel_syntax && !alt)
4394 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
4396 if (sizeflag & DFLAG)
4397 *obufp++ = intel_syntax ? 'd' : 'l';
4399 *obufp++ = intel_syntax ? 'w' : 's';
4400 used_prefixes |= (prefixes & PREFIX_DATA);
4404 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
4411 else if (sizeflag & DFLAG)
4412 *obufp++ = intel_syntax ? 'd' : 'l';
4415 used_prefixes |= (prefixes & PREFIX_DATA);
4420 case 'E': /* For jcxz/jecxz */
4421 if (address_mode == mode_64bit)
4423 if (sizeflag & AFLAG)
4429 if (sizeflag & AFLAG)
4431 used_prefixes |= (prefixes & PREFIX_ADDR);
4436 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
4438 if (sizeflag & AFLAG)
4439 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
4441 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
4442 used_prefixes |= (prefixes & PREFIX_ADDR);
4446 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
4448 if ((rex & REX_W) || (sizeflag & DFLAG))
4453 used_prefixes |= (prefixes & PREFIX_DATA);
4458 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
4459 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
4461 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
4464 if (prefixes & PREFIX_DS)
4485 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
4494 if (sizeflag & SUFFIX_ALWAYS)
4498 if ((prefixes & PREFIX_FWAIT) == 0)
4501 used_prefixes |= PREFIX_FWAIT;
4507 else if (intel_syntax && (sizeflag & DFLAG))
4512 used_prefixes |= (prefixes & PREFIX_DATA);
4517 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4526 if ((prefixes & PREFIX_DATA)
4528 || (sizeflag & SUFFIX_ALWAYS))
4535 if (sizeflag & DFLAG)
4540 used_prefixes |= (prefixes & PREFIX_DATA);
4546 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4548 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4554 if (intel_syntax && !alt)
4557 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4563 if (sizeflag & DFLAG)
4564 *obufp++ = intel_syntax ? 'd' : 'l';
4568 used_prefixes |= (prefixes & PREFIX_DATA);
4575 else if (sizeflag & DFLAG)
4584 if (intel_syntax && !p[1]
4585 && ((rex & REX_W) || (sizeflag & DFLAG)))
4588 used_prefixes |= (prefixes & PREFIX_DATA);
4593 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4595 if (sizeflag & SUFFIX_ALWAYS)
4603 if (sizeflag & SUFFIX_ALWAYS)
4609 if (sizeflag & DFLAG)
4613 used_prefixes |= (prefixes & PREFIX_DATA);
4618 if (prefixes & PREFIX_DATA)
4622 used_prefixes |= (prefixes & PREFIX_DATA);
4633 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
4635 /* operand size flag for cwtl, cbtw */
4644 else if (sizeflag & DFLAG)
4649 used_prefixes |= (prefixes & PREFIX_DATA);
4659 oappend (const char *s)
4662 obufp += strlen (s);
4668 if (prefixes & PREFIX_CS)
4670 used_prefixes |= PREFIX_CS;
4671 oappend ("%cs:" + intel_syntax);
4673 if (prefixes & PREFIX_DS)
4675 used_prefixes |= PREFIX_DS;
4676 oappend ("%ds:" + intel_syntax);
4678 if (prefixes & PREFIX_SS)
4680 used_prefixes |= PREFIX_SS;
4681 oappend ("%ss:" + intel_syntax);
4683 if (prefixes & PREFIX_ES)
4685 used_prefixes |= PREFIX_ES;
4686 oappend ("%es:" + intel_syntax);
4688 if (prefixes & PREFIX_FS)
4690 used_prefixes |= PREFIX_FS;
4691 oappend ("%fs:" + intel_syntax);
4693 if (prefixes & PREFIX_GS)
4695 used_prefixes |= PREFIX_GS;
4696 oappend ("%gs:" + intel_syntax);
4701 OP_indirE (int bytemode, int sizeflag)
4705 OP_E (bytemode, sizeflag);
4709 print_operand_value (char *buf, int hex, bfd_vma disp)
4711 if (address_mode == mode_64bit)
4719 sprintf_vma (tmp, disp);
4720 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
4721 strcpy (buf + 2, tmp + i);
4725 bfd_signed_vma v = disp;
4732 /* Check for possible overflow on 0x8000000000000000. */
4735 strcpy (buf, "9223372036854775808");
4749 tmp[28 - i] = (v % 10) + '0';
4753 strcpy (buf, tmp + 29 - i);
4759 sprintf (buf, "0x%x", (unsigned int) disp);
4761 sprintf (buf, "%d", (int) disp);
4765 /* Put DISP in BUF as signed hex number. */
4768 print_displacement (char *buf, bfd_vma disp)
4770 bfd_signed_vma val = disp;
4779 /* Check for possible overflow. */
4782 switch (address_mode)
4785 strcpy (buf + j, "0x8000000000000000");
4788 strcpy (buf + j, "0x80000000");
4791 strcpy (buf + j, "0x8000");
4801 sprintf_vma (tmp, val);
4802 for (i = 0; tmp[i] == '0'; i++)
4806 strcpy (buf + j, tmp + i);
4810 intel_operand_size (int bytemode, int sizeflag)
4816 oappend ("BYTE PTR ");
4820 oappend ("WORD PTR ");
4823 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4825 oappend ("QWORD PTR ");
4826 used_prefixes |= (prefixes & PREFIX_DATA);
4834 oappend ("QWORD PTR ");
4835 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
4836 oappend ("DWORD PTR ");
4838 oappend ("WORD PTR ");
4839 used_prefixes |= (prefixes & PREFIX_DATA);
4842 if ((rex & REX_W) || (sizeflag & DFLAG))
4844 oappend ("WORD PTR ");
4846 used_prefixes |= (prefixes & PREFIX_DATA);
4850 oappend ("DWORD PTR ");
4853 oappend ("QWORD PTR ");
4856 if (address_mode == mode_64bit)
4857 oappend ("QWORD PTR ");
4859 oappend ("DWORD PTR ");
4862 if (sizeflag & DFLAG)
4863 oappend ("FWORD PTR ");
4865 oappend ("DWORD PTR ");
4866 used_prefixes |= (prefixes & PREFIX_DATA);
4869 oappend ("TBYTE PTR ");
4872 oappend ("XMMWORD PTR ");
4875 oappend ("OWORD PTR ");
4883 OP_E (int bytemode, int sizeflag)
4892 /* Skip mod/rm byte. */
4903 oappend (names8rex[modrm.rm + add]);
4905 oappend (names8[modrm.rm + add]);
4908 oappend (names16[modrm.rm + add]);
4911 oappend (names32[modrm.rm + add]);
4914 oappend (names64[modrm.rm + add]);
4917 if (address_mode == mode_64bit)
4918 oappend (names64[modrm.rm + add]);
4920 oappend (names32[modrm.rm + add]);
4923 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4925 oappend (names64[modrm.rm + add]);
4926 used_prefixes |= (prefixes & PREFIX_DATA);
4938 oappend (names64[modrm.rm + add]);
4939 else if ((sizeflag & DFLAG) || bytemode != v_mode)
4940 oappend (names32[modrm.rm + add]);
4942 oappend (names16[modrm.rm + add]);
4943 used_prefixes |= (prefixes & PREFIX_DATA);
4948 oappend (INTERNAL_DISASSEMBLER_ERROR);
4956 intel_operand_size (bytemode, sizeflag);
4959 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
4961 /* 32/64 bit address mode */
4976 (void) FETCH_DATA (the_info, codep + 1);
4977 index = (*codep >> 3) & 7;
4978 if (address_mode == mode_64bit || index != 0x4)
4979 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
4980 scale = (*codep >> 6) & 3;
4992 if ((base & 7) == 5)
4995 if (address_mode == mode_64bit && !havesib)
5001 FETCH_DATA (the_info, codep + 1);
5003 if ((disp & 0x80) != 0)
5011 havedisp = havebase || (havesib && (index != 4 || scale != 0));
5014 if (modrm.mod != 0 || (base & 7) == 5)
5016 if (havedisp || riprel)
5017 print_displacement (scratchbuf, disp);
5019 print_operand_value (scratchbuf, 1, disp);
5020 oappend (scratchbuf);
5028 if (havedisp || (intel_syntax && riprel))
5030 *obufp++ = open_char;
5031 if (intel_syntax && riprel)
5038 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5039 ? names64[base] : names32[base]);
5044 if (!intel_syntax || havebase)
5046 *obufp++ = separator_char;
5049 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5050 ? names64[index] : names32[index]);
5052 if (scale != 0 || (!intel_syntax && index != 4))
5054 *obufp++ = scale_char;
5056 sprintf (scratchbuf, "%d", 1 << scale);
5057 oappend (scratchbuf);
5061 && (disp || modrm.mod != 0 || (base & 7) == 5))
5063 if ((bfd_signed_vma) disp >= 0)
5068 else if (modrm.mod != 1)
5072 disp = - (bfd_signed_vma) disp;
5075 print_displacement (scratchbuf, disp);
5076 oappend (scratchbuf);
5079 *obufp++ = close_char;
5082 else if (intel_syntax)
5084 if (modrm.mod != 0 || (base & 7) == 5)
5086 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5087 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5091 oappend (names_seg[ds_reg - es_reg]);
5094 print_operand_value (scratchbuf, 1, disp);
5095 oappend (scratchbuf);
5100 { /* 16 bit address mode */
5107 if ((disp & 0x8000) != 0)
5112 FETCH_DATA (the_info, codep + 1);
5114 if ((disp & 0x80) != 0)
5119 if ((disp & 0x8000) != 0)
5125 if (modrm.mod != 0 || modrm.rm == 6)
5127 print_displacement (scratchbuf, disp);
5128 oappend (scratchbuf);
5131 if (modrm.mod != 0 || modrm.rm != 6)
5133 *obufp++ = open_char;
5135 oappend (index16[modrm.rm]);
5137 && (disp || modrm.mod != 0 || modrm.rm == 6))
5139 if ((bfd_signed_vma) disp >= 0)
5144 else if (modrm.mod != 1)
5148 disp = - (bfd_signed_vma) disp;
5151 print_displacement (scratchbuf, disp);
5152 oappend (scratchbuf);
5155 *obufp++ = close_char;
5158 else if (intel_syntax)
5160 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5161 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5165 oappend (names_seg[ds_reg - es_reg]);
5168 print_operand_value (scratchbuf, 1, disp & 0xffff);
5169 oappend (scratchbuf);
5175 OP_G (int bytemode, int sizeflag)
5186 oappend (names8rex[modrm.reg + add]);
5188 oappend (names8[modrm.reg + add]);
5191 oappend (names16[modrm.reg + add]);
5194 oappend (names32[modrm.reg + add]);
5197 oappend (names64[modrm.reg + add]);
5206 oappend (names64[modrm.reg + add]);
5207 else if ((sizeflag & DFLAG) || bytemode != v_mode)
5208 oappend (names32[modrm.reg + add]);
5210 oappend (names16[modrm.reg + add]);
5211 used_prefixes |= (prefixes & PREFIX_DATA);
5214 if (address_mode == mode_64bit)
5215 oappend (names64[modrm.reg + add]);
5217 oappend (names32[modrm.reg + add]);
5220 oappend (INTERNAL_DISASSEMBLER_ERROR);
5233 (void) FETCH_DATA (the_info, codep + 8);
5234 a = *codep++ & 0xff;
5235 a |= (*codep++ & 0xff) << 8;
5236 a |= (*codep++ & 0xff) << 16;
5237 a |= (*codep++ & 0xff) << 24;
5238 b = *codep++ & 0xff;
5239 b |= (*codep++ & 0xff) << 8;
5240 b |= (*codep++ & 0xff) << 16;
5241 b |= (*codep++ & 0xff) << 24;
5242 x = a + ((bfd_vma) b << 32);
5250 static bfd_signed_vma
5253 bfd_signed_vma x = 0;
5255 (void) FETCH_DATA (the_info, codep + 4);
5256 x = *codep++ & (bfd_signed_vma) 0xff;
5257 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5258 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5259 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5263 static bfd_signed_vma
5266 bfd_signed_vma x = 0;
5268 (void) FETCH_DATA (the_info, codep + 4);
5269 x = *codep++ & (bfd_signed_vma) 0xff;
5270 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5271 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5272 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5274 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
5284 (void) FETCH_DATA (the_info, codep + 2);
5285 x = *codep++ & 0xff;
5286 x |= (*codep++ & 0xff) << 8;
5291 set_op (bfd_vma op, int riprel)
5293 op_index[op_ad] = op_ad;
5294 if (address_mode == mode_64bit)
5296 op_address[op_ad] = op;
5297 op_riprel[op_ad] = riprel;
5301 /* Mask to get a 32-bit address. */
5302 op_address[op_ad] = op & 0xffffffff;
5303 op_riprel[op_ad] = riprel & 0xffffffff;
5308 OP_REG (int code, int sizeflag)
5318 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5319 case sp_reg: case bp_reg: case si_reg: case di_reg:
5320 s = names16[code - ax_reg + add];
5322 case es_reg: case ss_reg: case cs_reg:
5323 case ds_reg: case fs_reg: case gs_reg:
5324 s = names_seg[code - es_reg + add];
5326 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5327 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5330 s = names8rex[code - al_reg + add];
5332 s = names8[code - al_reg];
5334 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
5335 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
5336 if (address_mode == mode_64bit && (sizeflag & DFLAG))
5338 s = names64[code - rAX_reg + add];
5341 code += eAX_reg - rAX_reg;
5343 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5344 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5347 s = names64[code - eAX_reg + add];
5348 else if (sizeflag & DFLAG)
5349 s = names32[code - eAX_reg + add];
5351 s = names16[code - eAX_reg + add];
5352 used_prefixes |= (prefixes & PREFIX_DATA);
5355 s = INTERNAL_DISASSEMBLER_ERROR;
5362 OP_IMREG (int code, int sizeflag)
5374 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5375 case sp_reg: case bp_reg: case si_reg: case di_reg:
5376 s = names16[code - ax_reg];
5378 case es_reg: case ss_reg: case cs_reg:
5379 case ds_reg: case fs_reg: case gs_reg:
5380 s = names_seg[code - es_reg];
5382 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5383 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5386 s = names8rex[code - al_reg];
5388 s = names8[code - al_reg];
5390 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5391 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5394 s = names64[code - eAX_reg];
5395 else if (sizeflag & DFLAG)
5396 s = names32[code - eAX_reg];
5398 s = names16[code - eAX_reg];
5399 used_prefixes |= (prefixes & PREFIX_DATA);
5402 if ((rex & REX_W) || (sizeflag & DFLAG))
5407 used_prefixes |= (prefixes & PREFIX_DATA);
5410 s = INTERNAL_DISASSEMBLER_ERROR;
5417 OP_I (int bytemode, int sizeflag)
5420 bfd_signed_vma mask = -1;
5425 FETCH_DATA (the_info, codep + 1);
5430 if (address_mode == mode_64bit)
5440 else if (sizeflag & DFLAG)
5450 used_prefixes |= (prefixes & PREFIX_DATA);
5461 oappend (INTERNAL_DISASSEMBLER_ERROR);
5466 scratchbuf[0] = '$';
5467 print_operand_value (scratchbuf + 1, 1, op);
5468 oappend (scratchbuf + intel_syntax);
5469 scratchbuf[0] = '\0';
5473 OP_I64 (int bytemode, int sizeflag)
5476 bfd_signed_vma mask = -1;
5478 if (address_mode != mode_64bit)
5480 OP_I (bytemode, sizeflag);
5487 FETCH_DATA (the_info, codep + 1);
5495 else if (sizeflag & DFLAG)
5505 used_prefixes |= (prefixes & PREFIX_DATA);
5512 oappend (INTERNAL_DISASSEMBLER_ERROR);
5517 scratchbuf[0] = '$';
5518 print_operand_value (scratchbuf + 1, 1, op);
5519 oappend (scratchbuf + intel_syntax);
5520 scratchbuf[0] = '\0';
5524 OP_sI (int bytemode, int sizeflag)
5527 bfd_signed_vma mask = -1;
5532 FETCH_DATA (the_info, codep + 1);
5534 if ((op & 0x80) != 0)
5542 else if (sizeflag & DFLAG)
5551 if ((op & 0x8000) != 0)
5554 used_prefixes |= (prefixes & PREFIX_DATA);
5559 if ((op & 0x8000) != 0)
5563 oappend (INTERNAL_DISASSEMBLER_ERROR);
5567 scratchbuf[0] = '$';
5568 print_operand_value (scratchbuf + 1, 1, op);
5569 oappend (scratchbuf + intel_syntax);
5573 OP_J (int bytemode, int sizeflag)
5577 bfd_vma segment = 0;
5582 FETCH_DATA (the_info, codep + 1);
5584 if ((disp & 0x80) != 0)
5588 if ((sizeflag & DFLAG) || (rex & REX_W))
5593 if ((disp & 0x8000) != 0)
5595 /* In 16bit mode, address is wrapped around at 64k within
5596 the same segment. Otherwise, a data16 prefix on a jump
5597 instruction means that the pc is masked to 16 bits after
5598 the displacement is added! */
5600 if ((prefixes & PREFIX_DATA) == 0)
5601 segment = ((start_pc + codep - start_codep)
5602 & ~((bfd_vma) 0xffff));
5604 used_prefixes |= (prefixes & PREFIX_DATA);
5607 oappend (INTERNAL_DISASSEMBLER_ERROR);
5610 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
5612 print_operand_value (scratchbuf, 1, disp);
5613 oappend (scratchbuf);
5617 OP_SEG (int bytemode, int sizeflag)
5619 if (bytemode == w_mode)
5620 oappend (names_seg[modrm.reg]);
5622 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
5626 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
5630 if (sizeflag & DFLAG)
5640 used_prefixes |= (prefixes & PREFIX_DATA);
5642 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
5644 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
5645 oappend (scratchbuf);
5649 OP_OFF (int bytemode, int sizeflag)
5653 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5654 intel_operand_size (bytemode, sizeflag);
5657 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
5664 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5665 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5667 oappend (names_seg[ds_reg - es_reg]);
5671 print_operand_value (scratchbuf, 1, off);
5672 oappend (scratchbuf);
5676 OP_OFF64 (int bytemode, int sizeflag)
5680 if (address_mode != mode_64bit
5681 || (prefixes & PREFIX_ADDR))
5683 OP_OFF (bytemode, sizeflag);
5687 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5688 intel_operand_size (bytemode, sizeflag);
5695 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5696 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5698 oappend (names_seg[ds_reg - es_reg]);
5702 print_operand_value (scratchbuf, 1, off);
5703 oappend (scratchbuf);
5707 ptr_reg (int code, int sizeflag)
5711 *obufp++ = open_char;
5712 used_prefixes |= (prefixes & PREFIX_ADDR);
5713 if (address_mode == mode_64bit)
5715 if (!(sizeflag & AFLAG))
5716 s = names32[code - eAX_reg];
5718 s = names64[code - eAX_reg];
5720 else if (sizeflag & AFLAG)
5721 s = names32[code - eAX_reg];
5723 s = names16[code - eAX_reg];
5725 *obufp++ = close_char;
5730 OP_ESreg (int code, int sizeflag)
5736 case 0x6d: /* insw/insl */
5737 intel_operand_size (z_mode, sizeflag);
5739 case 0xa5: /* movsw/movsl/movsq */
5740 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5741 case 0xab: /* stosw/stosl */
5742 case 0xaf: /* scasw/scasl */
5743 intel_operand_size (v_mode, sizeflag);
5746 intel_operand_size (b_mode, sizeflag);
5749 oappend ("%es:" + intel_syntax);
5750 ptr_reg (code, sizeflag);
5754 OP_DSreg (int code, int sizeflag)
5760 case 0x6f: /* outsw/outsl */
5761 intel_operand_size (z_mode, sizeflag);
5763 case 0xa5: /* movsw/movsl/movsq */
5764 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5765 case 0xad: /* lodsw/lodsl/lodsq */
5766 intel_operand_size (v_mode, sizeflag);
5769 intel_operand_size (b_mode, sizeflag);
5779 prefixes |= PREFIX_DS;
5781 ptr_reg (code, sizeflag);
5785 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5793 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
5795 used_prefixes |= PREFIX_LOCK;
5798 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
5799 oappend (scratchbuf + intel_syntax);
5803 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5810 sprintf (scratchbuf, "db%d", modrm.reg + add);
5812 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
5813 oappend (scratchbuf);
5817 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5819 sprintf (scratchbuf, "%%tr%d", modrm.reg);
5820 oappend (scratchbuf + intel_syntax);
5824 OP_R (int bytemode, int sizeflag)
5827 OP_E (bytemode, sizeflag);
5833 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5835 used_prefixes |= (prefixes & PREFIX_DATA);
5836 if (prefixes & PREFIX_DATA)
5842 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
5845 sprintf (scratchbuf, "%%mm%d", modrm.reg);
5846 oappend (scratchbuf + intel_syntax);
5850 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5856 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
5857 oappend (scratchbuf + intel_syntax);
5861 OP_EM (int bytemode, int sizeflag)
5865 if (intel_syntax && bytemode == v_mode)
5867 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5868 used_prefixes |= (prefixes & PREFIX_DATA);
5870 OP_E (bytemode, sizeflag);
5874 /* Skip mod/rm byte. */
5877 used_prefixes |= (prefixes & PREFIX_DATA);
5878 if (prefixes & PREFIX_DATA)
5885 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
5888 sprintf (scratchbuf, "%%mm%d", modrm.rm);
5889 oappend (scratchbuf + intel_syntax);
5892 /* cvt* are the only instructions in sse2 which have
5893 both SSE and MMX operands and also have 0x66 prefix
5894 in their opcode. 0x66 was originally used to differentiate
5895 between SSE and MMX instruction(operands). So we have to handle the
5896 cvt* separately using OP_EMC and OP_MXC */
5898 OP_EMC (int bytemode, int sizeflag)
5902 if (intel_syntax && bytemode == v_mode)
5904 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5905 used_prefixes |= (prefixes & PREFIX_DATA);
5907 OP_E (bytemode, sizeflag);
5911 /* Skip mod/rm byte. */
5914 used_prefixes |= (prefixes & PREFIX_DATA);
5915 sprintf (scratchbuf, "%%mm%d", modrm.rm);
5916 oappend (scratchbuf + intel_syntax);
5920 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5922 used_prefixes |= (prefixes & PREFIX_DATA);
5923 sprintf (scratchbuf, "%%mm%d", modrm.reg);
5924 oappend (scratchbuf + intel_syntax);
5928 OP_EX (int bytemode, int sizeflag)
5933 OP_E (bytemode, sizeflag);
5940 /* Skip mod/rm byte. */
5943 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
5944 oappend (scratchbuf + intel_syntax);
5948 OP_MS (int bytemode, int sizeflag)
5951 OP_EM (bytemode, sizeflag);
5957 OP_XS (int bytemode, int sizeflag)
5960 OP_EX (bytemode, sizeflag);
5966 OP_M (int bytemode, int sizeflag)
5969 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst,invept,invvpid modrm */
5972 OP_E (bytemode, sizeflag);
5976 OP_0f07 (int bytemode, int sizeflag)
5978 if (modrm.mod != 3 || modrm.rm != 0)
5981 OP_E (bytemode, sizeflag);
5985 OP_0fae (int bytemode, int sizeflag)
5990 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
5991 else if (modrm.reg == 6)
5992 strcpy (obuf + strlen (obuf) - sizeof ("xsaveopt") + 1, "mfence");
5993 else if (modrm.reg == 5)
5994 strcpy (obuf + strlen (obuf) - sizeof ("xrstor") + 1, "lfence");
5996 if (modrm.reg < 5 || modrm.rm != 0)
5998 BadOp (); /* bad sfence, mfence, or lfence */
6004 OP_E (bytemode, sizeflag);
6007 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
6008 32bit mode and "xchg %rax,%rax" in 64bit mode. */
6011 NOP_Fixup1 (int bytemode, int sizeflag)
6013 if ((prefixes & PREFIX_DATA) != 0
6016 && address_mode == mode_64bit))
6017 OP_REG (bytemode, sizeflag);
6019 strcpy (obuf, "nop");
6023 NOP_Fixup2 (int bytemode, int sizeflag)
6025 if ((prefixes & PREFIX_DATA) != 0
6028 && address_mode == mode_64bit))
6029 OP_IMREG (bytemode, sizeflag);
6032 static const char *const Suffix3DNow[] = {
6033 /* 00 */ NULL, NULL, NULL, NULL,
6034 /* 04 */ NULL, NULL, NULL, NULL,
6035 /* 08 */ NULL, NULL, NULL, NULL,
6036 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
6037 /* 10 */ NULL, NULL, NULL, NULL,
6038 /* 14 */ NULL, NULL, NULL, NULL,
6039 /* 18 */ NULL, NULL, NULL, NULL,
6040 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
6041 /* 20 */ NULL, NULL, NULL, NULL,
6042 /* 24 */ NULL, NULL, NULL, NULL,
6043 /* 28 */ NULL, NULL, NULL, NULL,
6044 /* 2C */ NULL, NULL, NULL, NULL,
6045 /* 30 */ NULL, NULL, NULL, NULL,
6046 /* 34 */ NULL, NULL, NULL, NULL,
6047 /* 38 */ NULL, NULL, NULL, NULL,
6048 /* 3C */ NULL, NULL, NULL, NULL,
6049 /* 40 */ NULL, NULL, NULL, NULL,
6050 /* 44 */ NULL, NULL, NULL, NULL,
6051 /* 48 */ NULL, NULL, NULL, NULL,
6052 /* 4C */ NULL, NULL, NULL, NULL,
6053 /* 50 */ NULL, NULL, NULL, NULL,
6054 /* 54 */ NULL, NULL, NULL, NULL,
6055 /* 58 */ NULL, NULL, NULL, NULL,
6056 /* 5C */ NULL, NULL, NULL, NULL,
6057 /* 60 */ NULL, NULL, NULL, NULL,
6058 /* 64 */ NULL, NULL, NULL, NULL,
6059 /* 68 */ NULL, NULL, NULL, NULL,
6060 /* 6C */ NULL, NULL, NULL, NULL,
6061 /* 70 */ NULL, NULL, NULL, NULL,
6062 /* 74 */ NULL, NULL, NULL, NULL,
6063 /* 78 */ NULL, NULL, NULL, NULL,
6064 /* 7C */ NULL, NULL, NULL, NULL,
6065 /* 80 */ NULL, NULL, NULL, NULL,
6066 /* 84 */ NULL, NULL, NULL, NULL,
6067 /* 88 */ NULL, NULL, "pfnacc", NULL,
6068 /* 8C */ NULL, NULL, "pfpnacc", NULL,
6069 /* 90 */ "pfcmpge", NULL, NULL, NULL,
6070 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
6071 /* 98 */ NULL, NULL, "pfsub", NULL,
6072 /* 9C */ NULL, NULL, "pfadd", NULL,
6073 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
6074 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
6075 /* A8 */ NULL, NULL, "pfsubr", NULL,
6076 /* AC */ NULL, NULL, "pfacc", NULL,
6077 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
6078 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
6079 /* B8 */ NULL, NULL, NULL, "pswapd",
6080 /* BC */ NULL, NULL, NULL, "pavgusb",
6081 /* C0 */ NULL, NULL, NULL, NULL,
6082 /* C4 */ NULL, NULL, NULL, NULL,
6083 /* C8 */ NULL, NULL, NULL, NULL,
6084 /* CC */ NULL, NULL, NULL, NULL,
6085 /* D0 */ NULL, NULL, NULL, NULL,
6086 /* D4 */ NULL, NULL, NULL, NULL,
6087 /* D8 */ NULL, NULL, NULL, NULL,
6088 /* DC */ NULL, NULL, NULL, NULL,
6089 /* E0 */ NULL, NULL, NULL, NULL,
6090 /* E4 */ NULL, NULL, NULL, NULL,
6091 /* E8 */ NULL, NULL, NULL, NULL,
6092 /* EC */ NULL, NULL, NULL, NULL,
6093 /* F0 */ NULL, NULL, NULL, NULL,
6094 /* F4 */ NULL, NULL, NULL, NULL,
6095 /* F8 */ NULL, NULL, NULL, NULL,
6096 /* FC */ NULL, NULL, NULL, NULL,
6100 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6102 const char *mnemonic;
6104 (void) FETCH_DATA (the_info, codep + 1);
6105 /* AMD 3DNow! instructions are specified by an opcode suffix in the
6106 place where an 8-bit immediate would normally go. ie. the last
6107 byte of the instruction. */
6108 obufp = obuf + strlen (obuf);
6109 mnemonic = Suffix3DNow[*codep++ & 0xff];
6114 /* Since a variable sized modrm/sib chunk is between the start
6115 of the opcode (0x0f0f) and the opcode suffix, we need to do
6116 all the modrm processing first, and don't know until now that
6117 we have a bad opcode. This necessitates some cleaning up. */
6118 op_out[0][0] = '\0';
6119 op_out[1][0] = '\0';
6124 static const char *simd_cmp_op[] = {
6136 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6138 unsigned int cmp_type;
6140 (void) FETCH_DATA (the_info, codep + 1);
6141 obufp = obuf + strlen (obuf);
6142 cmp_type = *codep++ & 0xff;
6145 char suffix1 = 'p', suffix2 = 's';
6146 used_prefixes |= (prefixes & PREFIX_REPZ);
6147 if (prefixes & PREFIX_REPZ)
6151 used_prefixes |= (prefixes & PREFIX_DATA);
6152 if (prefixes & PREFIX_DATA)
6156 used_prefixes |= (prefixes & PREFIX_REPNZ);
6157 if (prefixes & PREFIX_REPNZ)
6158 suffix1 = 's', suffix2 = 'd';
6161 sprintf (scratchbuf, "cmp%s%c%c",
6162 simd_cmp_op[cmp_type], suffix1, suffix2);
6163 used_prefixes |= (prefixes & PREFIX_REPZ);
6164 oappend (scratchbuf);
6168 /* We have a bad extension byte. Clean up. */
6169 op_out[0][0] = '\0';
6170 op_out[1][0] = '\0';
6176 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
6178 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
6179 forms of these instructions. */
6182 char *p = obuf + strlen (obuf);
6185 *(p - 1) = *(p - 2);
6186 *(p - 2) = *(p - 3);
6187 *(p - 3) = extrachar;
6192 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6194 if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1)
6196 /* Override "sidt". */
6197 size_t olen = strlen (obuf);
6198 char *p = obuf + olen - 4;
6199 const char **names = (address_mode == mode_64bit
6200 ? names64 : names32);
6202 /* We might have a suffix when disassembling with -Msuffix. */
6206 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6208 && (prefixes & PREFIX_ADDR)
6211 && CONST_STRNEQ (p - 7, "addr")
6212 && (CONST_STRNEQ (p - 3, "16")
6213 || CONST_STRNEQ (p - 3, "32")))
6218 /* mwait %eax,%ecx */
6219 strcpy (p, "mwait");
6221 strcpy (op_out[0], names[0]);
6225 /* monitor %eax,%ecx,%edx" */
6226 strcpy (p, "monitor");
6229 const char **op1_names;
6230 if (!(prefixes & PREFIX_ADDR))
6231 op1_names = (address_mode == mode_16bit
6235 op1_names = (address_mode != mode_32bit
6236 ? names32 : names16);
6237 used_prefixes |= PREFIX_ADDR;
6239 strcpy (op_out[0], op1_names[0]);
6240 strcpy (op_out[2], names[2]);
6245 strcpy (op_out[1], names[1]);
6256 XCR_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6258 if (modrm.mod == 3 && modrm.reg == 2 && modrm.rm <= 1)
6260 /* Override "lgdt". */
6261 size_t olen = strlen (obuf);
6262 char *p = obuf + olen - 4;
6264 /* We might have a suffix when disassembling with -Msuffix. */
6268 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6270 && (prefixes & PREFIX_ADDR)
6273 && CONST_STRNEQ (p - 7, "addr")
6274 && (CONST_STRNEQ (p - 3, "16")
6275 || CONST_STRNEQ (p - 3, "32")))
6280 strcpy (p, "xsetbv");
6284 strcpy (p, "xgetbv");
6293 SVME_Fixup (int bytemode, int sizeflag)
6325 OP_M (bytemode, sizeflag);
6328 /* Override "lidt". */
6329 p = obuf + strlen (obuf) - 4;
6330 /* We might have a suffix. */
6334 if (!(prefixes & PREFIX_ADDR))
6339 used_prefixes |= PREFIX_ADDR;
6343 strcpy (op_out[1], names32[1]);
6349 *obufp++ = open_char;
6350 if (address_mode == mode_64bit || (sizeflag & AFLAG))
6354 strcpy (obufp, alt);
6355 obufp += strlen (alt);
6356 *obufp++ = close_char;
6363 INVLPG_Fixup (int bytemode, int sizeflag)
6376 OP_M (bytemode, sizeflag);
6379 /* Override "invlpg". */
6380 strcpy (obuf + strlen (obuf) - 6, alt);
6387 /* Throw away prefixes and 1st. opcode byte. */
6388 codep = insn_codep + 1;
6393 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6400 /* Override "sgdt". */
6401 char *p = obuf + strlen (obuf) - 4;
6403 /* We might have a suffix when disassembling with -Msuffix. */
6410 strcpy (p, "vmcall");
6413 strcpy (p, "vmlaunch");
6416 strcpy (p, "vmresume");
6419 strcpy (p, "vmxoff");
6430 OP_VMX (int bytemode, int sizeflag)
6432 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
6433 if (prefixes & PREFIX_DATA)
6434 strcpy (obuf, "vmclear");
6435 else if (prefixes & PREFIX_REPZ)
6436 strcpy (obuf, "vmxon");
6438 strcpy (obuf, "vmptrld");
6439 OP_E (bytemode, sizeflag);
6443 REP_Fixup (int bytemode, int sizeflag)
6445 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
6449 if (prefixes & PREFIX_REPZ)
6450 switch (*insn_codep)
6452 case 0x6e: /* outsb */
6453 case 0x6f: /* outsw/outsl */
6454 case 0xa4: /* movsb */
6455 case 0xa5: /* movsw/movsl/movsq */
6461 case 0xaa: /* stosb */
6462 case 0xab: /* stosw/stosl/stosq */
6463 case 0xac: /* lodsb */
6464 case 0xad: /* lodsw/lodsl/lodsq */
6465 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
6470 case 0x6c: /* insb */
6471 case 0x6d: /* insl/insw */
6487 olen = strlen (obuf);
6488 p = obuf + olen - ilen - 1 - 4;
6489 /* Handle "repz [addr16|addr32]". */
6490 if ((prefixes & PREFIX_ADDR))
6493 memmove (p + 3, p + 4, olen - (p + 3 - obuf));
6501 OP_IMREG (bytemode, sizeflag);
6504 OP_ESreg (bytemode, sizeflag);
6507 OP_DSreg (bytemode, sizeflag);
6516 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
6521 /* Change cmpxchg8b to cmpxchg16b. */
6522 char *p = obuf + strlen (obuf) - 2;
6526 OP_M (bytemode, sizeflag);
6530 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
6532 sprintf (scratchbuf, "%%xmm%d", reg);
6533 oappend (scratchbuf + intel_syntax);
6537 CRC32_Fixup (int bytemode, int sizeflag)
6539 /* Add proper suffix to "crc32". */
6540 char *p = obuf + strlen (obuf);
6557 else if (sizeflag & DFLAG)
6561 used_prefixes |= (prefixes & PREFIX_DATA);
6564 oappend (INTERNAL_DISASSEMBLER_ERROR);
6573 /* Skip mod/rm byte. */
6578 add = (rex & REX_B) ? 8 : 0;
6579 if (bytemode == b_mode)
6583 oappend (names8rex[modrm.rm + add]);
6585 oappend (names8[modrm.rm + add]);
6591 oappend (names64[modrm.rm + add]);
6592 else if ((prefixes & PREFIX_DATA))
6593 oappend (names16[modrm.rm + add]);
6595 oappend (names32[modrm.rm + add]);
6599 OP_E (bytemode, sizeflag);