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 } }
553 #define PREGRP107 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 107 } }
556 #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }
557 #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }
558 #define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }
559 #define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }
561 #define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }
562 #define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }
564 typedef void (*op_rtn) (int bytemode, int sizeflag);
575 /* Upper case letters in the instruction names here are macros.
576 'A' => print 'b' if no register operands or suffix_always is true
577 'B' => print 'b' if suffix_always is true
578 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
580 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
581 . suffix_always is true
582 'E' => print 'e' if 32-bit form of jcxz
583 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
584 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
585 'H' => print ",pt" or ",pn" branch hint
586 'I' => honor following macro letter even in Intel mode (implemented only
587 . for some of the macro letters)
589 'K' => print 'd' or 'q' if rex prefix is present.
590 'L' => print 'l' if suffix_always is true
591 'N' => print 'n' if instruction has no wait "prefix"
592 'O' => print 'd' or 'o' (or 'q' in Intel mode)
593 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
594 . or suffix_always is true. print 'q' if rex prefix is present.
595 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
597 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
598 'S' => print 'w', 'l' or 'q' if suffix_always is true
599 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
600 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
601 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
602 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
603 'X' => print 's', 'd' depending on data16 prefix (for XMM)
604 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
605 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
607 Many of the above letters print nothing in Intel mode. See "putop"
610 Braces '{' and '}', and vertical bars '|', indicate alternative
611 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
612 modes. In cases where there are only two alternatives, the X86_64
613 instruction is reserved, and "(bad)" is printed.
616 static const struct dis386 dis386[] = {
618 { "addB", { Eb, Gb } },
619 { "addS", { Ev, Gv } },
620 { "addB", { Gb, Eb } },
621 { "addS", { Gv, Ev } },
622 { "addB", { AL, Ib } },
623 { "addS", { eAX, Iv } },
624 { "push{T|}", { es } },
625 { "pop{T|}", { es } },
627 { "orB", { Eb, Gb } },
628 { "orS", { Ev, Gv } },
629 { "orB", { Gb, Eb } },
630 { "orS", { Gv, Ev } },
631 { "orB", { AL, Ib } },
632 { "orS", { eAX, Iv } },
633 { "push{T|}", { cs } },
634 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
636 { "adcB", { Eb, Gb } },
637 { "adcS", { Ev, Gv } },
638 { "adcB", { Gb, Eb } },
639 { "adcS", { Gv, Ev } },
640 { "adcB", { AL, Ib } },
641 { "adcS", { eAX, Iv } },
642 { "push{T|}", { ss } },
643 { "pop{T|}", { ss } },
645 { "sbbB", { Eb, Gb } },
646 { "sbbS", { Ev, Gv } },
647 { "sbbB", { Gb, Eb } },
648 { "sbbS", { Gv, Ev } },
649 { "sbbB", { AL, Ib } },
650 { "sbbS", { eAX, Iv } },
651 { "push{T|}", { ds } },
652 { "pop{T|}", { ds } },
654 { "andB", { Eb, Gb } },
655 { "andS", { Ev, Gv } },
656 { "andB", { Gb, Eb } },
657 { "andS", { Gv, Ev } },
658 { "andB", { AL, Ib } },
659 { "andS", { eAX, Iv } },
660 { "(bad)", { XX } }, /* SEG ES prefix */
661 { "daa{|}", { XX } },
663 { "subB", { Eb, Gb } },
664 { "subS", { Ev, Gv } },
665 { "subB", { Gb, Eb } },
666 { "subS", { Gv, Ev } },
667 { "subB", { AL, Ib } },
668 { "subS", { eAX, Iv } },
669 { "(bad)", { XX } }, /* SEG CS prefix */
670 { "das{|}", { XX } },
672 { "xorB", { Eb, Gb } },
673 { "xorS", { Ev, Gv } },
674 { "xorB", { Gb, Eb } },
675 { "xorS", { Gv, Ev } },
676 { "xorB", { AL, Ib } },
677 { "xorS", { eAX, Iv } },
678 { "(bad)", { XX } }, /* SEG SS prefix */
679 { "aaa{|}", { XX } },
681 { "cmpB", { Eb, Gb } },
682 { "cmpS", { Ev, Gv } },
683 { "cmpB", { Gb, Eb } },
684 { "cmpS", { Gv, Ev } },
685 { "cmpB", { AL, Ib } },
686 { "cmpS", { eAX, Iv } },
687 { "(bad)", { XX } }, /* SEG DS prefix */
688 { "aas{|}", { XX } },
690 { "inc{S|}", { RMeAX } },
691 { "inc{S|}", { RMeCX } },
692 { "inc{S|}", { RMeDX } },
693 { "inc{S|}", { RMeBX } },
694 { "inc{S|}", { RMeSP } },
695 { "inc{S|}", { RMeBP } },
696 { "inc{S|}", { RMeSI } },
697 { "inc{S|}", { RMeDI } },
699 { "dec{S|}", { RMeAX } },
700 { "dec{S|}", { RMeCX } },
701 { "dec{S|}", { RMeDX } },
702 { "dec{S|}", { RMeBX } },
703 { "dec{S|}", { RMeSP } },
704 { "dec{S|}", { RMeBP } },
705 { "dec{S|}", { RMeSI } },
706 { "dec{S|}", { RMeDI } },
708 { "pushV", { RMrAX } },
709 { "pushV", { RMrCX } },
710 { "pushV", { RMrDX } },
711 { "pushV", { RMrBX } },
712 { "pushV", { RMrSP } },
713 { "pushV", { RMrBP } },
714 { "pushV", { RMrSI } },
715 { "pushV", { RMrDI } },
717 { "popV", { RMrAX } },
718 { "popV", { RMrCX } },
719 { "popV", { RMrDX } },
720 { "popV", { RMrBX } },
721 { "popV", { RMrSP } },
722 { "popV", { RMrBP } },
723 { "popV", { RMrSI } },
724 { "popV", { RMrDI } },
730 { "(bad)", { XX } }, /* seg fs */
731 { "(bad)", { XX } }, /* seg gs */
732 { "(bad)", { XX } }, /* op size prefix */
733 { "(bad)", { XX } }, /* adr size prefix */
736 { "imulS", { Gv, Ev, Iv } },
737 { "pushT", { sIb } },
738 { "imulS", { Gv, Ev, sIb } },
739 { "ins{b||b|}", { Ybr, indirDX } },
740 { "ins{R||G|}", { Yzr, indirDX } },
741 { "outs{b||b|}", { indirDXr, Xb } },
742 { "outs{R||G|}", { indirDXr, Xz } },
744 { "joH", { Jb, XX, cond_jump_flag } },
745 { "jnoH", { Jb, XX, cond_jump_flag } },
746 { "jbH", { Jb, XX, cond_jump_flag } },
747 { "jaeH", { Jb, XX, cond_jump_flag } },
748 { "jeH", { Jb, XX, cond_jump_flag } },
749 { "jneH", { Jb, XX, cond_jump_flag } },
750 { "jbeH", { Jb, XX, cond_jump_flag } },
751 { "jaH", { Jb, XX, cond_jump_flag } },
753 { "jsH", { Jb, XX, cond_jump_flag } },
754 { "jnsH", { Jb, XX, cond_jump_flag } },
755 { "jpH", { Jb, XX, cond_jump_flag } },
756 { "jnpH", { Jb, XX, cond_jump_flag } },
757 { "jlH", { Jb, XX, cond_jump_flag } },
758 { "jgeH", { Jb, XX, cond_jump_flag } },
759 { "jleH", { Jb, XX, cond_jump_flag } },
760 { "jgH", { Jb, XX, cond_jump_flag } },
766 { "testB", { Eb, Gb } },
767 { "testS", { Ev, Gv } },
768 { "xchgB", { Eb, Gb } },
769 { "xchgS", { Ev, Gv } },
771 { "movB", { Eb, Gb } },
772 { "movS", { Ev, Gv } },
773 { "movB", { Gb, Eb } },
774 { "movS", { Gv, Ev } },
775 { "movD", { Sv, Sw } },
776 { "leaS", { Gv, M } },
777 { "movD", { Sw, Sv } },
781 { "xchgS", { RMeCX, eAX } },
782 { "xchgS", { RMeDX, eAX } },
783 { "xchgS", { RMeBX, eAX } },
784 { "xchgS", { RMeSP, eAX } },
785 { "xchgS", { RMeBP, eAX } },
786 { "xchgS", { RMeSI, eAX } },
787 { "xchgS", { RMeDI, eAX } },
789 { "cW{t||t|}R", { XX } },
790 { "cR{t||t|}O", { XX } },
791 { "Jcall{T|}", { Ap } },
792 { "(bad)", { XX } }, /* fwait */
793 { "pushfT", { XX } },
795 { "sahf{|}", { XX } },
796 { "lahf{|}", { XX } },
798 { "movB", { AL, Ob } },
799 { "movS", { eAX, Ov } },
800 { "movB", { Ob, AL } },
801 { "movS", { Ov, eAX } },
802 { "movs{b||b|}", { Ybr, Xb } },
803 { "movs{R||R|}", { Yvr, Xv } },
804 { "cmps{b||b|}", { Xb, Yb } },
805 { "cmps{R||R|}", { Xv, Yv } },
807 { "testB", { AL, Ib } },
808 { "testS", { eAX, Iv } },
809 { "stosB", { Ybr, AL } },
810 { "stosS", { Yvr, eAX } },
811 { "lodsB", { ALr, Xb } },
812 { "lodsS", { eAXr, Xv } },
813 { "scasB", { AL, Yb } },
814 { "scasS", { eAX, Yv } },
816 { "movB", { RMAL, Ib } },
817 { "movB", { RMCL, Ib } },
818 { "movB", { RMDL, Ib } },
819 { "movB", { RMBL, Ib } },
820 { "movB", { RMAH, Ib } },
821 { "movB", { RMCH, Ib } },
822 { "movB", { RMDH, Ib } },
823 { "movB", { RMBH, Ib } },
825 { "movS", { RMeAX, Iv64 } },
826 { "movS", { RMeCX, Iv64 } },
827 { "movS", { RMeDX, Iv64 } },
828 { "movS", { RMeBX, Iv64 } },
829 { "movS", { RMeSP, Iv64 } },
830 { "movS", { RMeBP, Iv64 } },
831 { "movS", { RMeSI, Iv64 } },
832 { "movS", { RMeDI, Iv64 } },
838 { "les{S|}", { Gv, Mp } },
839 { "ldsS", { Gv, Mp } },
843 { "enterT", { Iw, Ib } },
844 { "leaveT", { XX } },
849 { "into{|}", { XX } },
856 { "aam{|}", { sIb } },
857 { "aad{|}", { sIb } },
859 { "xlat", { DSBX } },
870 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
871 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
872 { "loopFH", { Jb, XX, loop_jcxz_flag } },
873 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
874 { "inB", { AL, Ib } },
875 { "inG", { zAX, Ib } },
876 { "outB", { Ib, AL } },
877 { "outG", { Ib, zAX } },
881 { "Jjmp{T|}", { Ap } },
883 { "inB", { AL, indirDX } },
884 { "inG", { zAX, indirDX } },
885 { "outB", { indirDX, AL } },
886 { "outG", { indirDX, zAX } },
888 { "(bad)", { XX } }, /* lock prefix */
890 { "(bad)", { XX } }, /* repne */
891 { "(bad)", { XX } }, /* repz */
907 static const struct dis386 dis386_twobyte[] = {
911 { "larS", { Gv, Ew } },
912 { "lslS", { Gv, Ew } },
914 { "syscall", { XX } },
916 { "sysretP", { XX } },
919 { "wbinvd", { XX } },
925 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
930 { "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } },
931 { "unpcklpX", { XM, EXq } },
932 { "unpckhpX", { XM, EXq } },
934 { "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } },
945 { "movZ", { Rm, Cm } },
946 { "movZ", { Rm, Dm } },
947 { "movZ", { Cm, Rm } },
948 { "movZ", { Dm, Rm } },
949 { "movL", { Rd, Td } },
951 { "movL", { Td, Rd } },
954 { "movapX", { XM, EXx } },
955 { "movapX", { EXx, XM } },
967 { "sysenter", { XX } },
968 { "sysexit", { XX } },
981 { "cmovo", { Gv, Ev } },
982 { "cmovno", { Gv, Ev } },
983 { "cmovb", { Gv, Ev } },
984 { "cmovae", { Gv, Ev } },
985 { "cmove", { Gv, Ev } },
986 { "cmovne", { Gv, Ev } },
987 { "cmovbe", { Gv, Ev } },
988 { "cmova", { Gv, Ev } },
990 { "cmovs", { Gv, Ev } },
991 { "cmovns", { Gv, Ev } },
992 { "cmovp", { Gv, Ev } },
993 { "cmovnp", { Gv, Ev } },
994 { "cmovl", { Gv, Ev } },
995 { "cmovge", { Gv, Ev } },
996 { "cmovle", { Gv, Ev } },
997 { "cmovg", { Gv, Ev } },
999 { "movmskpX", { Gdq, XS } },
1003 { "andpX", { XM, EXx } },
1004 { "andnpX", { XM, EXx } },
1005 { "orpX", { XM, EXx } },
1006 { "xorpX", { XM, EXx } },
1020 { "packsswb", { MX, EM } },
1021 { "pcmpgtb", { MX, EM } },
1022 { "pcmpgtw", { MX, EM } },
1023 { "pcmpgtd", { MX, EM } },
1024 { "packuswb", { MX, EM } },
1026 { "punpckhbw", { MX, EM } },
1027 { "punpckhwd", { MX, EM } },
1028 { "punpckhdq", { MX, EM } },
1029 { "packssdw", { MX, EM } },
1032 { "movd", { MX, Edq } },
1039 { "pcmpeqb", { MX, EM } },
1040 { "pcmpeqw", { MX, EM } },
1041 { "pcmpeqd", { MX, EM } },
1046 { "(bad)", { XX } },
1047 { "(bad)", { XX } },
1053 { "joH", { Jv, XX, cond_jump_flag } },
1054 { "jnoH", { Jv, XX, cond_jump_flag } },
1055 { "jbH", { Jv, XX, cond_jump_flag } },
1056 { "jaeH", { Jv, XX, cond_jump_flag } },
1057 { "jeH", { Jv, XX, cond_jump_flag } },
1058 { "jneH", { Jv, XX, cond_jump_flag } },
1059 { "jbeH", { Jv, XX, cond_jump_flag } },
1060 { "jaH", { Jv, XX, cond_jump_flag } },
1062 { "jsH", { Jv, XX, cond_jump_flag } },
1063 { "jnsH", { Jv, XX, cond_jump_flag } },
1064 { "jpH", { Jv, XX, cond_jump_flag } },
1065 { "jnpH", { Jv, XX, cond_jump_flag } },
1066 { "jlH", { Jv, XX, cond_jump_flag } },
1067 { "jgeH", { Jv, XX, cond_jump_flag } },
1068 { "jleH", { Jv, XX, cond_jump_flag } },
1069 { "jgH", { Jv, XX, cond_jump_flag } },
1072 { "setno", { Eb } },
1074 { "setae", { Eb } },
1076 { "setne", { Eb } },
1077 { "setbe", { Eb } },
1081 { "setns", { Eb } },
1083 { "setnp", { Eb } },
1085 { "setge", { Eb } },
1086 { "setle", { Eb } },
1089 { "pushT", { fs } },
1091 { "cpuid", { XX } },
1092 { "btS", { Ev, Gv } },
1093 { "shldS", { Ev, Gv, Ib } },
1094 { "shldS", { Ev, Gv, CL } },
1098 { "pushT", { gs } },
1101 { "btsS", { Ev, Gv } },
1102 { "shrdS", { Ev, Gv, Ib } },
1103 { "shrdS", { Ev, Gv, CL } },
1105 { "imulS", { Gv, Ev } },
1107 { "cmpxchgB", { Eb, Gb } },
1108 { "cmpxchgS", { Ev, Gv } },
1109 { "lssS", { Gv, Mp } },
1110 { "btrS", { Ev, Gv } },
1111 { "lfsS", { Gv, Mp } },
1112 { "lgsS", { Gv, Mp } },
1113 { "movz{bR|x|bR|x}", { Gv, Eb } },
1114 { "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
1119 { "btcS", { Ev, Gv } },
1120 { "bsfS", { Gv, Ev } },
1122 { "movs{bR|x|bR|x}", { Gv, Eb } },
1123 { "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
1125 { "xaddB", { Eb, Gb } },
1126 { "xaddS", { Ev, Gv } },
1128 { "movntiS", { Ev, Gv } },
1129 { "pinsrw", { MX, Edqw, Ib } },
1130 { "pextrw", { Gdq, MS, Ib } },
1131 { "shufpX", { XM, EXx, Ib } },
1134 { "bswap", { RMeAX } },
1135 { "bswap", { RMeCX } },
1136 { "bswap", { RMeDX } },
1137 { "bswap", { RMeBX } },
1138 { "bswap", { RMeSP } },
1139 { "bswap", { RMeBP } },
1140 { "bswap", { RMeSI } },
1141 { "bswap", { RMeDI } },
1144 { "psrlw", { MX, EM } },
1145 { "psrld", { MX, EM } },
1146 { "psrlq", { MX, EM } },
1147 { "paddq", { MX, EM } },
1148 { "pmullw", { MX, EM } },
1150 { "pmovmskb", { Gdq, MS } },
1152 { "psubusb", { MX, EM } },
1153 { "psubusw", { MX, EM } },
1154 { "pminub", { MX, EM } },
1155 { "pand", { MX, EM } },
1156 { "paddusb", { MX, EM } },
1157 { "paddusw", { MX, EM } },
1158 { "pmaxub", { MX, EM } },
1159 { "pandn", { MX, EM } },
1161 { "pavgb", { MX, EM } },
1162 { "psraw", { MX, EM } },
1163 { "psrad", { MX, EM } },
1164 { "pavgw", { MX, EM } },
1165 { "pmulhuw", { MX, EM } },
1166 { "pmulhw", { MX, EM } },
1170 { "psubsb", { MX, EM } },
1171 { "psubsw", { MX, EM } },
1172 { "pminsw", { MX, EM } },
1173 { "por", { MX, EM } },
1174 { "paddsb", { MX, EM } },
1175 { "paddsw", { MX, EM } },
1176 { "pmaxsw", { MX, EM } },
1177 { "pxor", { MX, EM } },
1180 { "psllw", { MX, EM } },
1181 { "pslld", { MX, EM } },
1182 { "psllq", { MX, EM } },
1183 { "pmuludq", { MX, EM } },
1184 { "pmaddwd", { MX, EM } },
1185 { "psadbw", { MX, EM } },
1188 { "psubb", { MX, EM } },
1189 { "psubw", { MX, EM } },
1190 { "psubd", { MX, EM } },
1191 { "psubq", { MX, EM } },
1192 { "paddb", { MX, EM } },
1193 { "paddw", { MX, EM } },
1194 { "paddd", { MX, EM } },
1195 { "(bad)", { XX } },
1198 static const unsigned char onebyte_has_modrm[256] = {
1199 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1200 /* ------------------------------- */
1201 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1202 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1203 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1204 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1205 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1206 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1207 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1208 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1209 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1210 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1211 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1212 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1213 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1214 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1215 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1216 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1217 /* ------------------------------- */
1218 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1221 static const unsigned char twobyte_has_modrm[256] = {
1222 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1223 /* ------------------------------- */
1224 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1225 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */
1226 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1227 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1228 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1229 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1230 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1231 /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1232 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1233 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1234 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1235 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1236 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1237 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1238 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1239 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1240 /* ------------------------------- */
1241 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1244 static const unsigned char twobyte_uses_DATA_prefix[256] = {
1245 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1246 /* ------------------------------- */
1247 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1248 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1249 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1250 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1251 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1252 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1253 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1254 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */
1255 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1256 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1257 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1258 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1259 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1260 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1261 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1262 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1263 /* ------------------------------- */
1264 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1267 static const unsigned char twobyte_uses_REPNZ_prefix[256] = {
1268 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1269 /* ------------------------------- */
1270 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1271 /* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1272 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1273 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1274 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1275 /* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */
1276 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1277 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */
1278 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1279 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1280 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1281 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1282 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1283 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1284 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1285 /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1286 /* ------------------------------- */
1287 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1290 static const unsigned char twobyte_uses_REPZ_prefix[256] = {
1291 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1292 /* ------------------------------- */
1293 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1294 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1295 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1296 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1297 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1298 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1299 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */
1300 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */
1301 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1302 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1303 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1304 /* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */
1305 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1306 /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1307 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1308 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1309 /* ------------------------------- */
1310 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1313 /* This is used to determine if opcode 0f 38 XX uses DATA prefix. */
1314 static const unsigned char threebyte_0x38_uses_DATA_prefix[256] = {
1315 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1316 /* ------------------------------- */
1317 /* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */
1318 /* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */
1319 /* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */
1320 /* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */
1321 /* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1322 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1323 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1324 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1325 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1326 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1327 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1328 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1329 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1330 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1, /* df */
1331 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1332 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1333 /* ------------------------------- */
1334 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1337 /* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */
1338 static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = {
1339 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1340 /* ------------------------------- */
1341 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1342 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1343 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1344 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1345 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1346 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1347 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1348 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1349 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1350 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1351 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1352 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1353 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1354 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1355 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1356 /* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1357 /* ------------------------------- */
1358 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1361 /* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */
1362 static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = {
1363 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1364 /* ------------------------------- */
1365 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1366 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1367 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1368 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1369 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1370 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1371 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1372 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1373 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1374 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1375 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1376 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1377 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1378 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1379 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1380 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1381 /* ------------------------------- */
1382 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1385 /* This is used to determine if opcode 0f 3a XX uses DATA prefix. */
1386 static const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = {
1387 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1388 /* ------------------------------- */
1389 /* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */
1390 /* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */
1391 /* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1392 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1393 /* 40 */ 1,1,1,0,1,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1394 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1395 /* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1396 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1397 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1398 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1399 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1400 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1401 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1402 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* df */
1403 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1404 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1405 /* ------------------------------- */
1406 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1409 /* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */
1410 static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = {
1411 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1412 /* ------------------------------- */
1413 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1414 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1415 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1416 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1417 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1418 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1419 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1420 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1421 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1422 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1423 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1424 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1425 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1426 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1427 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1428 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1429 /* ------------------------------- */
1430 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1433 /* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */
1434 static const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = {
1435 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1436 /* ------------------------------- */
1437 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1438 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1439 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1440 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1441 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1442 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1443 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1444 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1445 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1446 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1447 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1448 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1449 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1450 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1451 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1452 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1453 /* ------------------------------- */
1454 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1457 static char obuf[100];
1459 static char scratchbuf[100];
1460 static unsigned char *start_codep;
1461 static unsigned char *insn_codep;
1462 static unsigned char *codep;
1463 static disassemble_info *the_info;
1471 static unsigned char need_modrm;
1473 /* If we are accessing mod/rm/reg without need_modrm set, then the
1474 values are stale. Hitting this abort likely indicates that you
1475 need to update onebyte_has_modrm or twobyte_has_modrm. */
1476 #define MODRM_CHECK if (!need_modrm) abort ()
1478 static const char **names64;
1479 static const char **names32;
1480 static const char **names16;
1481 static const char **names8;
1482 static const char **names8rex;
1483 static const char **names_seg;
1484 static const char **index16;
1486 static const char *intel_names64[] = {
1487 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1488 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1490 static const char *intel_names32[] = {
1491 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1492 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1494 static const char *intel_names16[] = {
1495 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1496 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1498 static const char *intel_names8[] = {
1499 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1501 static const char *intel_names8rex[] = {
1502 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1503 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1505 static const char *intel_names_seg[] = {
1506 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1508 static const char *intel_index16[] = {
1509 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1512 static const char *att_names64[] = {
1513 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1514 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1516 static const char *att_names32[] = {
1517 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1518 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1520 static const char *att_names16[] = {
1521 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1522 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1524 static const char *att_names8[] = {
1525 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1527 static const char *att_names8rex[] = {
1528 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1529 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1531 static const char *att_names_seg[] = {
1532 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1534 static const char *att_index16[] = {
1535 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1538 static const struct dis386 grps[][8] = {
1541 { "popU", { stackEv } },
1542 { "(bad)", { XX } },
1543 { "(bad)", { XX } },
1544 { "(bad)", { XX } },
1545 { "(bad)", { XX } },
1546 { "(bad)", { XX } },
1547 { "(bad)", { XX } },
1548 { "(bad)", { XX } },
1552 { "addA", { Eb, Ib } },
1553 { "orA", { Eb, Ib } },
1554 { "adcA", { Eb, Ib } },
1555 { "sbbA", { Eb, Ib } },
1556 { "andA", { Eb, Ib } },
1557 { "subA", { Eb, Ib } },
1558 { "xorA", { Eb, Ib } },
1559 { "cmpA", { Eb, Ib } },
1563 { "addQ", { Ev, Iv } },
1564 { "orQ", { Ev, Iv } },
1565 { "adcQ", { Ev, Iv } },
1566 { "sbbQ", { Ev, Iv } },
1567 { "andQ", { Ev, Iv } },
1568 { "subQ", { Ev, Iv } },
1569 { "xorQ", { Ev, Iv } },
1570 { "cmpQ", { Ev, Iv } },
1574 { "addQ", { Ev, sIb } },
1575 { "orQ", { Ev, sIb } },
1576 { "adcQ", { Ev, sIb } },
1577 { "sbbQ", { Ev, sIb } },
1578 { "andQ", { Ev, sIb } },
1579 { "subQ", { Ev, sIb } },
1580 { "xorQ", { Ev, sIb } },
1581 { "cmpQ", { Ev, sIb } },
1585 { "rolA", { Eb, Ib } },
1586 { "rorA", { Eb, Ib } },
1587 { "rclA", { Eb, Ib } },
1588 { "rcrA", { Eb, Ib } },
1589 { "shlA", { Eb, Ib } },
1590 { "shrA", { Eb, Ib } },
1591 { "(bad)", { XX } },
1592 { "sarA", { Eb, Ib } },
1596 { "rolQ", { Ev, Ib } },
1597 { "rorQ", { Ev, Ib } },
1598 { "rclQ", { Ev, Ib } },
1599 { "rcrQ", { Ev, Ib } },
1600 { "shlQ", { Ev, Ib } },
1601 { "shrQ", { Ev, Ib } },
1602 { "(bad)", { XX } },
1603 { "sarQ", { Ev, Ib } },
1607 { "rolA", { Eb, I1 } },
1608 { "rorA", { Eb, I1 } },
1609 { "rclA", { Eb, I1 } },
1610 { "rcrA", { Eb, I1 } },
1611 { "shlA", { Eb, I1 } },
1612 { "shrA", { Eb, I1 } },
1613 { "(bad)", { XX } },
1614 { "sarA", { Eb, I1 } },
1618 { "rolQ", { Ev, I1 } },
1619 { "rorQ", { Ev, I1 } },
1620 { "rclQ", { Ev, I1 } },
1621 { "rcrQ", { Ev, I1 } },
1622 { "shlQ", { Ev, I1 } },
1623 { "shrQ", { Ev, I1 } },
1624 { "(bad)", { XX } },
1625 { "sarQ", { Ev, I1 } },
1629 { "rolA", { Eb, CL } },
1630 { "rorA", { Eb, CL } },
1631 { "rclA", { Eb, CL } },
1632 { "rcrA", { Eb, CL } },
1633 { "shlA", { Eb, CL } },
1634 { "shrA", { Eb, CL } },
1635 { "(bad)", { XX } },
1636 { "sarA", { Eb, CL } },
1640 { "rolQ", { Ev, CL } },
1641 { "rorQ", { Ev, CL } },
1642 { "rclQ", { Ev, CL } },
1643 { "rcrQ", { Ev, CL } },
1644 { "shlQ", { Ev, CL } },
1645 { "shrQ", { Ev, CL } },
1646 { "(bad)", { XX } },
1647 { "sarQ", { Ev, CL } },
1651 { "testA", { Eb, Ib } },
1652 { "(bad)", { Eb } },
1655 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
1656 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
1657 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
1658 { "idivA", { Eb } }, /* and idiv for consistency. */
1662 { "testQ", { Ev, Iv } },
1663 { "(bad)", { XX } },
1666 { "mulQ", { Ev } }, /* Don't print the implicit register. */
1667 { "imulQ", { Ev } },
1669 { "idivQ", { Ev } },
1675 { "(bad)", { XX } },
1676 { "(bad)", { XX } },
1677 { "(bad)", { XX } },
1678 { "(bad)", { XX } },
1679 { "(bad)", { XX } },
1680 { "(bad)", { XX } },
1686 { "callT", { indirEv } },
1687 { "JcallT", { indirEp } },
1688 { "jmpT", { indirEv } },
1689 { "JjmpT", { indirEp } },
1690 { "pushU", { stackEv } },
1691 { "(bad)", { XX } },
1695 { "sldtD", { Sv } },
1701 { "(bad)", { XX } },
1702 { "(bad)", { XX } },
1706 { "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } },
1707 { "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } },
1708 { "lgdt{Q|Q||}", { { XCR_Fixup, 0 } } },
1709 { "lidt{Q|Q||}", { { SVME_Fixup, 0 } } },
1710 { "smswD", { Sv } },
1711 { "(bad)", { XX } },
1713 { "invlpg", { { INVLPG_Fixup, w_mode } } },
1717 { "(bad)", { XX } },
1718 { "(bad)", { XX } },
1719 { "(bad)", { XX } },
1720 { "(bad)", { XX } },
1721 { "btQ", { Ev, Ib } },
1722 { "btsQ", { Ev, Ib } },
1723 { "btrQ", { Ev, Ib } },
1724 { "btcQ", { Ev, Ib } },
1728 { "(bad)", { XX } },
1729 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
1730 { "(bad)", { XX } },
1731 { "(bad)", { XX } },
1732 { "(bad)", { XX } },
1733 { "(bad)", { XX } },
1734 { "", { VM } }, /* See OP_VMX. */
1735 { "vmptrst", { Mq } },
1739 { "movA", { Eb, Ib } },
1740 { "(bad)", { XX } },
1741 { "(bad)", { XX } },
1742 { "(bad)", { XX } },
1743 { "(bad)", { XX } },
1744 { "(bad)", { XX } },
1745 { "(bad)", { XX } },
1746 { "(bad)", { XX } },
1750 { "movQ", { Ev, Iv } },
1751 { "(bad)", { XX } },
1752 { "(bad)", { XX } },
1753 { "(bad)", { XX } },
1754 { "(bad)", { XX } },
1755 { "(bad)", { XX } },
1756 { "(bad)", { XX } },
1757 { "(bad)", { XX } },
1761 { "(bad)", { XX } },
1762 { "(bad)", { XX } },
1763 { "psrlw", { MS, Ib } },
1764 { "(bad)", { XX } },
1765 { "psraw", { MS, Ib } },
1766 { "(bad)", { XX } },
1767 { "psllw", { MS, Ib } },
1768 { "(bad)", { XX } },
1772 { "(bad)", { XX } },
1773 { "(bad)", { XX } },
1774 { "psrld", { MS, Ib } },
1775 { "(bad)", { XX } },
1776 { "psrad", { MS, Ib } },
1777 { "(bad)", { XX } },
1778 { "pslld", { MS, Ib } },
1779 { "(bad)", { XX } },
1783 { "(bad)", { XX } },
1784 { "(bad)", { XX } },
1785 { "psrlq", { MS, Ib } },
1786 { "psrldq", { MS, Ib } },
1787 { "(bad)", { XX } },
1788 { "(bad)", { XX } },
1789 { "psllq", { MS, Ib } },
1790 { "pslldq", { MS, Ib } },
1794 { "fxsave", { Ev } },
1795 { "fxrstor", { Ev } },
1796 { "ldmxcsr", { Ev } },
1797 { "stmxcsr", { Ev } },
1798 { "xsave", { Ev } },
1799 { "xrstor", { { OP_0fae, v_mode } } },
1800 { "xsaveopt", { { OP_0fae, v_mode } } },
1801 { "clflush", { { OP_0fae, 0 } } },
1805 { "prefetchnta", { Ev } },
1806 { "prefetcht0", { Ev } },
1807 { "prefetcht1", { Ev } },
1808 { "prefetcht2", { Ev } },
1809 { "(bad)", { XX } },
1810 { "(bad)", { XX } },
1811 { "(bad)", { XX } },
1812 { "(bad)", { XX } },
1816 { "prefetch", { Eb } },
1817 { "prefetchw", { Eb } },
1818 { "(bad)", { XX } },
1819 { "(bad)", { XX } },
1820 { "(bad)", { XX } },
1821 { "(bad)", { XX } },
1822 { "(bad)", { XX } },
1823 { "(bad)", { XX } },
1827 { "xstore-rng", { { OP_0f07, 0 } } },
1828 { "xcrypt-ecb", { { OP_0f07, 0 } } },
1829 { "xcrypt-cbc", { { OP_0f07, 0 } } },
1830 { "xcrypt-ctr", { { OP_0f07, 0 } } },
1831 { "xcrypt-cfb", { { OP_0f07, 0 } } },
1832 { "xcrypt-ofb", { { OP_0f07, 0 } } },
1833 { "(bad)", { { OP_0f07, 0 } } },
1834 { "(bad)", { { OP_0f07, 0 } } },
1838 { "montmul", { { OP_0f07, 0 } } },
1839 { "xsha1", { { OP_0f07, 0 } } },
1840 { "xsha256", { { OP_0f07, 0 } } },
1841 { "(bad)", { { OP_0f07, 0 } } },
1842 { "(bad)", { { OP_0f07, 0 } } },
1843 { "(bad)", { { OP_0f07, 0 } } },
1844 { "(bad)", { { OP_0f07, 0 } } },
1845 { "(bad)", { { OP_0f07, 0 } } },
1849 static const struct dis386 prefix_user_table[][4] = {
1852 { "addps", { XM, EXx } },
1853 { "addss", { XM, EXd } },
1854 { "addpd", { XM, EXx } },
1855 { "addsd", { XM, EXq } },
1859 { "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */
1860 { "", { XM, EXx, OPSIMD } },
1861 { "", { XM, EXx, OPSIMD } },
1862 { "", { XM, EXx, OPSIMD } },
1866 { "cvtpi2ps", { XM, EMC } },
1867 { "cvtsi2ssY", { XM, Ev } },
1868 { "cvtpi2pd", { XM, EMC } },
1869 { "cvtsi2sdY", { XM, Ev } },
1873 { "cvtps2pi", { MXC, EXx } },
1874 { "cvtss2siY", { Gv, EXx } },
1875 { "cvtpd2pi", { MXC, EXx } },
1876 { "cvtsd2siY", { Gv, EXx } },
1880 { "cvttps2pi", { MXC, EXx } },
1881 { "cvttss2siY", { Gv, EXx } },
1882 { "cvttpd2pi", { MXC, EXx } },
1883 { "cvttsd2siY", { Gv, EXx } },
1887 { "divps", { XM, EXx } },
1888 { "divss", { XM, EXx } },
1889 { "divpd", { XM, EXx } },
1890 { "divsd", { XM, EXx } },
1894 { "maxps", { XM, EXx } },
1895 { "maxss", { XM, EXx } },
1896 { "maxpd", { XM, EXx } },
1897 { "maxsd", { XM, EXx } },
1901 { "minps", { XM, EXx } },
1902 { "minss", { XM, EXx } },
1903 { "minpd", { XM, EXx } },
1904 { "minsd", { XM, EXx } },
1908 { "movups", { XM, EXx } },
1909 { "movss", { XM, EXx } },
1910 { "movupd", { XM, EXx } },
1911 { "movsd", { XM, EXx } },
1915 { "movups", { EXx, XM } },
1916 { "movss", { EXx, XM } },
1917 { "movupd", { EXx, XM } },
1918 { "movsd", { EXx, XM } },
1922 { "mulps", { XM, EXx } },
1923 { "mulss", { XM, EXx } },
1924 { "mulpd", { XM, EXx } },
1925 { "mulsd", { XM, EXx } },
1929 { "rcpps", { XM, EXx } },
1930 { "rcpss", { XM, EXx } },
1931 { "(bad)", { XM, EXx } },
1932 { "(bad)", { XM, EXx } },
1936 { "rsqrtps",{ XM, EXx } },
1937 { "rsqrtss",{ XM, EXx } },
1938 { "(bad)", { XM, EXx } },
1939 { "(bad)", { XM, EXx } },
1943 { "sqrtps", { XM, EXx } },
1944 { "sqrtss", { XM, EXx } },
1945 { "sqrtpd", { XM, EXx } },
1946 { "sqrtsd", { XM, EXx } },
1950 { "subps", { XM, EXx } },
1951 { "subss", { XM, EXx } },
1952 { "subpd", { XM, EXx } },
1953 { "subsd", { XM, EXx } },
1957 { "(bad)", { XM, EXx } },
1958 { "cvtdq2pd", { XM, EXq } },
1959 { "cvttpd2dq", { XM, EXx } },
1960 { "cvtpd2dq", { XM, EXx } },
1964 { "cvtdq2ps", { XM, EXx } },
1965 { "cvttps2dq", { XM, EXx } },
1966 { "cvtps2dq", { XM, EXx } },
1967 { "(bad)", { XM, EXx } },
1971 { "cvtps2pd", { XM, EXq } },
1972 { "cvtss2sd", { XM, EXx } },
1973 { "cvtpd2ps", { XM, EXx } },
1974 { "cvtsd2ss", { XM, EXx } },
1978 { "maskmovq", { MX, MS } },
1979 { "(bad)", { XM, EXx } },
1980 { "maskmovdqu", { XM, XS } },
1981 { "(bad)", { XM, EXx } },
1985 { "movq", { MX, EM } },
1986 { "movdqu", { XM, EXx } },
1987 { "movdqa", { XM, EXx } },
1988 { "(bad)", { XM, EXx } },
1992 { "movq", { EM, MX } },
1993 { "movdqu", { EXx, XM } },
1994 { "movdqa", { EXx, XM } },
1995 { "(bad)", { EXx, XM } },
1999 { "(bad)", { EXx, XM } },
2000 { "movq2dq",{ XM, MS } },
2001 { "movq", { EXx, XM } },
2002 { "movdq2q",{ MX, XS } },
2006 { "pshufw", { MX, EM, Ib } },
2007 { "pshufhw",{ XM, EXx, Ib } },
2008 { "pshufd", { XM, EXx, Ib } },
2009 { "pshuflw",{ XM, EXx, Ib } },
2013 { "movd", { Edq, MX } },
2014 { "movq", { XM, EXx } },
2015 { "movd", { Edq, XM } },
2016 { "(bad)", { Ed, XM } },
2020 { "(bad)", { MX, EXx } },
2021 { "(bad)", { XM, EXx } },
2022 { "punpckhqdq", { XM, EXx } },
2023 { "(bad)", { XM, EXx } },
2027 { "movntq", { EM, MX } },
2028 { "(bad)", { EM, XM } },
2029 { "movntdq",{ EM, XM } },
2030 { "(bad)", { EM, XM } },
2034 { "(bad)", { MX, EXx } },
2035 { "(bad)", { XM, EXx } },
2036 { "punpcklqdq", { XM, EXx } },
2037 { "(bad)", { XM, EXx } },
2041 { "(bad)", { MX, EXx } },
2042 { "(bad)", { XM, EXx } },
2043 { "addsubpd", { XM, EXx } },
2044 { "addsubps", { XM, EXx } },
2048 { "(bad)", { MX, EXx } },
2049 { "(bad)", { XM, EXx } },
2050 { "haddpd", { XM, EXx } },
2051 { "haddps", { XM, EXx } },
2055 { "(bad)", { MX, EXx } },
2056 { "(bad)", { XM, EXx } },
2057 { "hsubpd", { XM, EXx } },
2058 { "hsubps", { XM, EXx } },
2062 { "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */
2063 { "movsldup", { XM, EXx } },
2064 { "movlpd", { XM, EXq } },
2065 { "movddup", { XM, EXq } },
2069 { "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } },
2070 { "movshdup", { XM, EXx } },
2071 { "movhpd", { XM, EXq } },
2072 { "(bad)", { XM, EXq } },
2076 { "(bad)", { XM, EXx } },
2077 { "(bad)", { XM, EXx } },
2078 { "(bad)", { XM, EXx } },
2079 { "lddqu", { XM, M } },
2083 {"movntps", { Ev, XM } },
2084 {"movntss", { Ev, XM } },
2085 {"movntpd", { Ev, XM } },
2086 {"movntsd", { Ev, XM } },
2091 {"vmread", { Em, Gm } },
2093 {"extrq", { XS, Ib, Ib } },
2094 {"insertq", { XM, XS, Ib, Ib } },
2099 {"vmwrite", { Gm, Em } },
2101 {"extrq", { XM, XS } },
2102 {"insertq", { XM, XS } },
2107 { "bsrS", { Gv, Ev } },
2108 { "lzcntS", { Gv, Ev } },
2109 { "bsrS", { Gv, Ev } },
2110 { "(bad)", { XX } },
2115 { "(bad)", { XX } },
2116 { "popcntS", { Gv, Ev } },
2117 { "(bad)", { XX } },
2118 { "(bad)", { XX } },
2123 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2124 { "pause", { XX } },
2125 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2126 { "(bad)", { XX } },
2131 { "(bad)", { XX } },
2132 { "(bad)", { XX } },
2133 { "pblendvb", {XM, EXx, XMM0 } },
2134 { "(bad)", { XX } },
2139 { "(bad)", { XX } },
2140 { "(bad)", { XX } },
2141 { "blendvps", {XM, EXx, XMM0 } },
2142 { "(bad)", { XX } },
2147 { "(bad)", { XX } },
2148 { "(bad)", { XX } },
2149 { "blendvpd", { XM, EXx, XMM0 } },
2150 { "(bad)", { XX } },
2155 { "(bad)", { XX } },
2156 { "(bad)", { XX } },
2157 { "ptest", { XM, EXx } },
2158 { "(bad)", { XX } },
2163 { "(bad)", { XX } },
2164 { "(bad)", { XX } },
2165 { "pmovsxbw", { XM, EXx } },
2166 { "(bad)", { XX } },
2171 { "(bad)", { XX } },
2172 { "(bad)", { XX } },
2173 { "pmovsxbd", { XM, EXx } },
2174 { "(bad)", { XX } },
2179 { "(bad)", { XX } },
2180 { "(bad)", { XX } },
2181 { "pmovsxbq", { XM, EXx } },
2182 { "(bad)", { XX } },
2187 { "(bad)", { XX } },
2188 { "(bad)", { XX } },
2189 { "pmovsxwd", { XM, EXx } },
2190 { "(bad)", { XX } },
2195 { "(bad)", { XX } },
2196 { "(bad)", { XX } },
2197 { "pmovsxwq", { XM, EXx } },
2198 { "(bad)", { XX } },
2203 { "(bad)", { XX } },
2204 { "(bad)", { XX } },
2205 { "pmovsxdq", { XM, EXx } },
2206 { "(bad)", { XX } },
2211 { "(bad)", { XX } },
2212 { "(bad)", { XX } },
2213 { "pmuldq", { XM, EXx } },
2214 { "(bad)", { XX } },
2219 { "(bad)", { XX } },
2220 { "(bad)", { XX } },
2221 { "pcmpeqq", { XM, EXx } },
2222 { "(bad)", { XX } },
2227 { "(bad)", { XX } },
2228 { "(bad)", { XX } },
2229 { "movntdqa", { XM, EM } },
2230 { "(bad)", { XX } },
2235 { "(bad)", { XX } },
2236 { "(bad)", { XX } },
2237 { "packusdw", { XM, EXx } },
2238 { "(bad)", { XX } },
2243 { "(bad)", { XX } },
2244 { "(bad)", { XX } },
2245 { "pmovzxbw", { XM, EXx } },
2246 { "(bad)", { XX } },
2251 { "(bad)", { XX } },
2252 { "(bad)", { XX } },
2253 { "pmovzxbd", { XM, EXx } },
2254 { "(bad)", { XX } },
2259 { "(bad)", { XX } },
2260 { "(bad)", { XX } },
2261 { "pmovzxbq", { XM, EXx } },
2262 { "(bad)", { XX } },
2267 { "(bad)", { XX } },
2268 { "(bad)", { XX } },
2269 { "pmovzxwd", { XM, EXx } },
2270 { "(bad)", { XX } },
2275 { "(bad)", { XX } },
2276 { "(bad)", { XX } },
2277 { "pmovzxwq", { XM, EXx } },
2278 { "(bad)", { XX } },
2283 { "(bad)", { XX } },
2284 { "(bad)", { XX } },
2285 { "pmovzxdq", { XM, EXx } },
2286 { "(bad)", { XX } },
2291 { "(bad)", { XX } },
2292 { "(bad)", { XX } },
2293 { "pminsb", { XM, EXx } },
2294 { "(bad)", { XX } },
2299 { "(bad)", { XX } },
2300 { "(bad)", { XX } },
2301 { "pminsd", { XM, EXx } },
2302 { "(bad)", { XX } },
2307 { "(bad)", { XX } },
2308 { "(bad)", { XX } },
2309 { "pminuw", { XM, EXx } },
2310 { "(bad)", { XX } },
2315 { "(bad)", { XX } },
2316 { "(bad)", { XX } },
2317 { "pminud", { XM, EXx } },
2318 { "(bad)", { XX } },
2323 { "(bad)", { XX } },
2324 { "(bad)", { XX } },
2325 { "pmaxsb", { XM, EXx } },
2326 { "(bad)", { XX } },
2331 { "(bad)", { XX } },
2332 { "(bad)", { XX } },
2333 { "pmaxsd", { XM, EXx } },
2334 { "(bad)", { XX } },
2339 { "(bad)", { XX } },
2340 { "(bad)", { XX } },
2341 { "pmaxuw", { XM, EXx } },
2342 { "(bad)", { XX } },
2347 { "(bad)", { XX } },
2348 { "(bad)", { XX } },
2349 { "pmaxud", { XM, EXx } },
2350 { "(bad)", { XX } },
2355 { "(bad)", { XX } },
2356 { "(bad)", { XX } },
2357 { "pmulld", { XM, EXx } },
2358 { "(bad)", { XX } },
2363 { "(bad)", { XX } },
2364 { "(bad)", { XX } },
2365 { "phminposuw", { XM, EXx } },
2366 { "(bad)", { XX } },
2371 { "(bad)", { XX } },
2372 { "(bad)", { XX } },
2373 { "roundps", { XM, EXx, Ib } },
2374 { "(bad)", { XX } },
2379 { "(bad)", { XX } },
2380 { "(bad)", { XX } },
2381 { "roundpd", { XM, EXx, Ib } },
2382 { "(bad)", { XX } },
2387 { "(bad)", { XX } },
2388 { "(bad)", { XX } },
2389 { "roundss", { XM, EXx, Ib } },
2390 { "(bad)", { XX } },
2395 { "(bad)", { XX } },
2396 { "(bad)", { XX } },
2397 { "roundsd", { XM, EXx, Ib } },
2398 { "(bad)", { XX } },
2403 { "(bad)", { XX } },
2404 { "(bad)", { XX } },
2405 { "blendps", { XM, EXx, Ib } },
2406 { "(bad)", { XX } },
2411 { "(bad)", { XX } },
2412 { "(bad)", { XX } },
2413 { "blendpd", { XM, EXx, Ib } },
2414 { "(bad)", { XX } },
2419 { "(bad)", { XX } },
2420 { "(bad)", { XX } },
2421 { "pblendw", { XM, EXx, Ib } },
2422 { "(bad)", { XX } },
2427 { "(bad)", { XX } },
2428 { "(bad)", { XX } },
2429 { "pextrb", { Edqb, XM, Ib } },
2430 { "(bad)", { XX } },
2435 { "(bad)", { XX } },
2436 { "(bad)", { XX } },
2437 { "pextrw", { Edqw, XM, Ib } },
2438 { "(bad)", { XX } },
2443 { "(bad)", { XX } },
2444 { "(bad)", { XX } },
2445 { "pextrK", { Edq, XM, Ib } },
2446 { "(bad)", { XX } },
2451 { "(bad)", { XX } },
2452 { "(bad)", { XX } },
2453 { "extractps", { Edqd, XM, Ib } },
2454 { "(bad)", { XX } },
2459 { "(bad)", { XX } },
2460 { "(bad)", { XX } },
2461 { "pinsrb", { XM, Edqb, Ib } },
2462 { "(bad)", { XX } },
2467 { "(bad)", { XX } },
2468 { "(bad)", { XX } },
2469 { "insertps", { XM, EXx, Ib } },
2470 { "(bad)", { XX } },
2475 { "(bad)", { XX } },
2476 { "(bad)", { XX } },
2477 { "pinsrK", { XM, Edq, Ib } },
2478 { "(bad)", { XX } },
2483 { "(bad)", { XX } },
2484 { "(bad)", { XX } },
2485 { "dpps", { XM, EXx, Ib } },
2486 { "(bad)", { XX } },
2491 { "(bad)", { XX } },
2492 { "(bad)", { XX } },
2493 { "dppd", { XM, EXx, Ib } },
2494 { "(bad)", { XX } },
2499 { "(bad)", { XX } },
2500 { "(bad)", { XX } },
2501 { "mpsadbw", { XM, EXx, Ib } },
2502 { "(bad)", { XX } },
2507 { "(bad)", { XX } },
2508 { "(bad)", { XX } },
2509 { "pcmpgtq", { XM, EXx } },
2510 { "(bad)", { XX } },
2515 { "(bad)", { XX } },
2516 { "(bad)", { XX } },
2517 { "(bad)", { XX } },
2518 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
2523 { "(bad)", { XX } },
2524 { "(bad)", { XX } },
2525 { "(bad)", { XX } },
2526 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
2531 { "(bad)", { XX } },
2532 { "(bad)", { XX } },
2533 { "pcmpestrm", { XM, EXx, Ib } },
2534 { "(bad)", { XX } },
2539 { "(bad)", { XX } },
2540 { "(bad)", { XX } },
2541 { "pcmpestri", { XM, EXx, Ib } },
2542 { "(bad)", { XX } },
2547 { "(bad)", { XX } },
2548 { "(bad)", { XX } },
2549 { "pcmpistrm", { XM, EXx, Ib } },
2550 { "(bad)", { XX } },
2555 { "(bad)", { XX } },
2556 { "(bad)", { XX } },
2557 { "pcmpistri", { XM, EXx, Ib } },
2558 { "(bad)", { XX } },
2563 { "ucomiss",{ XM, EXd } },
2564 { "(bad)", { XX } },
2565 { "ucomisd",{ XM, EXq } },
2566 { "(bad)", { XX } },
2571 { "comiss", { XM, EXd } },
2572 { "(bad)", { XX } },
2573 { "comisd", { XM, EXq } },
2574 { "(bad)", { XX } },
2579 { "punpcklbw",{ MX, EMd } },
2580 { "(bad)", { XX } },
2581 { "punpcklbw",{ MX, EMq } },
2582 { "(bad)", { XX } },
2587 { "punpcklwd",{ MX, EMd } },
2588 { "(bad)", { XX } },
2589 { "punpcklwd",{ MX, EMq } },
2590 { "(bad)", { XX } },
2595 { "punpckldq",{ MX, EMd } },
2596 { "(bad)", { XX } },
2597 { "punpckldq",{ MX, EMq } },
2598 { "(bad)", { XX } },
2603 { "(bad)", { XX } },
2604 { "(bad)", { XX } },
2605 { "invept", { Gm, Mo } },
2606 { "(bad)", { XX } },
2611 { "(bad)", { XX } },
2612 { "(bad)", { XX } },
2613 { "invvpid",{ Gm, Mo } },
2614 { "(bad)", { XX } },
2619 { "(bad)", { XX } },
2620 { "(bad)", { XX } },
2621 { "aesimc", { XM, EXx } },
2622 { "(bad)", { XX } },
2627 { "(bad)", { XX } },
2628 { "(bad)", { XX } },
2629 { "aesenc",{ XM, EXx } },
2630 { "(bad)", { XX } },
2635 { "(bad)", { XX } },
2636 { "(bad)", { XX } },
2637 { "aesenclast", { XM, EXx } },
2638 { "(bad)", { XX } },
2643 { "(bad)", { XX } },
2644 { "(bad)", { XX } },
2645 { "aesdec", { XM, EXx } },
2646 { "(bad)", { XX } },
2651 { "(bad)", { XX } },
2652 { "(bad)", { XX } },
2653 { "aesdeclast", { XM, EXx } },
2654 { "(bad)", { XX } },
2659 { "(bad)", { XX } },
2660 { "(bad)", { XX } },
2661 { "aeskeygenassist", { XM, EXx, Ib } },
2662 { "(bad)", { XX } },
2667 { "(bad)", { XX } },
2668 { "(bad)", { XX } },
2669 { "pclmulqdq", { XM, EXx, Ib } },
2670 { "(bad)", { XX } },
2675 { "(bad)", { XX } },
2676 { "(bad)", { XX } },
2677 { "invpcid",{ Gm, Mo } },
2678 { "(bad)", { XX } },
2682 static const struct dis386 x86_64_table[][2] = {
2684 { "pusha{P|}", { XX } },
2685 { "(bad)", { XX } },
2688 { "popa{P|}", { XX } },
2689 { "(bad)", { XX } },
2692 { "bound{S|}", { Gv, Ma } },
2693 { "(bad)", { XX } },
2696 { "arpl", { Ew, Gw } },
2697 { "movs{||lq|xd}", { Gv, Ed } },
2701 static const struct dis386 three_byte_table[][256] = {
2705 { "pshufb", { MX, EM } },
2706 { "phaddw", { MX, EM } },
2707 { "phaddd", { MX, EM } },
2708 { "phaddsw", { MX, EM } },
2709 { "pmaddubsw", { MX, EM } },
2710 { "phsubw", { MX, EM } },
2711 { "phsubd", { MX, EM } },
2712 { "phsubsw", { MX, EM } },
2714 { "psignb", { MX, EM } },
2715 { "psignw", { MX, EM } },
2716 { "psignd", { MX, EM } },
2717 { "pmulhrsw", { MX, EM } },
2718 { "(bad)", { XX } },
2719 { "(bad)", { XX } },
2720 { "(bad)", { XX } },
2721 { "(bad)", { XX } },
2724 { "(bad)", { XX } },
2725 { "(bad)", { XX } },
2726 { "(bad)", { XX } },
2729 { "(bad)", { XX } },
2732 { "(bad)", { XX } },
2733 { "(bad)", { XX } },
2734 { "(bad)", { XX } },
2735 { "(bad)", { XX } },
2736 { "pabsb", { MX, EM } },
2737 { "pabsw", { MX, EM } },
2738 { "pabsd", { MX, EM } },
2739 { "(bad)", { XX } },
2747 { "(bad)", { XX } },
2748 { "(bad)", { XX } },
2754 { "(bad)", { XX } },
2755 { "(bad)", { XX } },
2756 { "(bad)", { XX } },
2757 { "(bad)", { XX } },
2765 { "(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 } },
2840 { "(bad)", { XX } },
2841 { "(bad)", { XX } },
2842 { "(bad)", { XX } },
2843 { "(bad)", { XX } },
2844 { "(bad)", { XX } },
2845 { "(bad)", { XX } },
2846 { "(bad)", { XX } },
2847 { "(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 } },
2942 { "(bad)", { XX } },
2943 { "(bad)", { XX } },
2944 { "(bad)", { XX } },
2945 { "(bad)", { XX } },
2946 { "(bad)", { XX } },
2948 { "(bad)", { XX } },
2949 { "(bad)", { XX } },
2950 { "(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 } },
2966 { "(bad)", { XX } },
2967 { "(bad)", { XX } },
2968 { "(bad)", { XX } },
2969 { "(bad)", { XX } },
2970 { "(bad)", { XX } },
2971 { "(bad)", { XX } },
2972 { "(bad)", { XX } },
2973 { "(bad)", { XX } },
2977 { "(bad)", { XX } },
2978 { "(bad)", { XX } },
2979 { "(bad)", { XX } },
2980 { "(bad)", { XX } },
2981 { "(bad)", { XX } },
2982 { "(bad)", { XX } },
2984 { "(bad)", { XX } },
2985 { "(bad)", { XX } },
2986 { "(bad)", { XX } },
2987 { "(bad)", { XX } },
2988 { "(bad)", { XX } },
2989 { "(bad)", { XX } },
2990 { "(bad)", { XX } },
2991 { "(bad)", { XX } },
2996 { "(bad)", { XX } },
2997 { "(bad)", { XX } },
2998 { "(bad)", { XX } },
2999 { "(bad)", { XX } },
3000 { "(bad)", { XX } },
3001 { "(bad)", { XX } },
3002 { "(bad)", { XX } },
3003 { "(bad)", { XX } },
3012 { "palignr", { MX, EM, Ib } },
3014 { "(bad)", { XX } },
3015 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "(bad)", { XX } },
3023 { "(bad)", { XX } },
3024 { "(bad)", { XX } },
3025 { "(bad)", { XX } },
3026 { "(bad)", { XX } },
3027 { "(bad)", { XX } },
3028 { "(bad)", { XX } },
3029 { "(bad)", { XX } },
3030 { "(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 } },
3059 { "(bad)", { XX } },
3060 { "(bad)", { XX } },
3061 { "(bad)", { XX } },
3062 { "(bad)", { XX } },
3063 { "(bad)", { XX } },
3064 { "(bad)", { XX } },
3065 { "(bad)", { XX } },
3066 { "(bad)", { XX } },
3071 { "(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 } },
3095 { "(bad)", { XX } },
3096 { "(bad)", { XX } },
3097 { "(bad)", { XX } },
3098 { "(bad)", { XX } },
3099 { "(bad)", { XX } },
3100 { "(bad)", { XX } },
3101 { "(bad)", { XX } },
3102 { "(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 } },
3237 { "(bad)", { XX } },
3239 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "(bad)", { XX } },
3242 { "(bad)", { XX } },
3243 { "(bad)", { XX } },
3244 { "(bad)", { XX } },
3245 { "(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 } },
3275 { "(bad)", { XX } },
3276 { "(bad)", { XX } },
3277 { "(bad)", { XX } },
3278 { "(bad)", { XX } },
3279 { "(bad)", { XX } },
3280 { "(bad)", { XX } },
3281 { "(bad)", { XX } },
3282 { "(bad)", { XX } },
3286 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
3298 (void) FETCH_DATA (the_info, codep + 1);
3302 /* REX prefixes family. */
3319 if (address_mode == mode_64bit)
3325 prefixes |= PREFIX_REPZ;
3328 prefixes |= PREFIX_REPNZ;
3331 prefixes |= PREFIX_LOCK;
3334 prefixes |= PREFIX_CS;
3337 prefixes |= PREFIX_SS;
3340 prefixes |= PREFIX_DS;
3343 prefixes |= PREFIX_ES;
3346 prefixes |= PREFIX_FS;
3349 prefixes |= PREFIX_GS;
3352 prefixes |= PREFIX_DATA;
3355 prefixes |= PREFIX_ADDR;
3358 /* fwait is really an instruction. If there are prefixes
3359 before the fwait, they belong to the fwait, *not* to the
3360 following instruction. */
3361 if (prefixes || rex)
3363 prefixes |= PREFIX_FWAIT;
3367 prefixes = PREFIX_FWAIT;
3372 /* Rex is ignored when followed by another prefix. */
3383 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
3387 prefix_name (int pref, int sizeflag)
3389 static const char *rexes [16] =
3394 "rex.XB", /* 0x43 */
3396 "rex.RB", /* 0x45 */
3397 "rex.RX", /* 0x46 */
3398 "rex.RXB", /* 0x47 */
3400 "rex.WB", /* 0x49 */
3401 "rex.WX", /* 0x4a */
3402 "rex.WXB", /* 0x4b */
3403 "rex.WR", /* 0x4c */
3404 "rex.WRB", /* 0x4d */
3405 "rex.WRX", /* 0x4e */
3406 "rex.WRXB", /* 0x4f */
3411 /* REX prefixes family. */
3428 return rexes [pref - 0x40];
3448 return (sizeflag & DFLAG) ? "data16" : "data32";
3450 if (address_mode == mode_64bit)
3451 return (sizeflag & AFLAG) ? "addr32" : "addr64";
3453 return (sizeflag & AFLAG) ? "addr16" : "addr32";
3461 static char op_out[MAX_OPERANDS][100];
3462 static int op_ad, op_index[MAX_OPERANDS];
3463 static int two_source_ops;
3464 static bfd_vma op_address[MAX_OPERANDS];
3465 static bfd_vma op_riprel[MAX_OPERANDS];
3466 static bfd_vma start_pc;
3469 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
3470 * (see topic "Redundant prefixes" in the "Differences from 8086"
3471 * section of the "Virtual 8086 Mode" chapter.)
3472 * 'pc' should be the address of this instruction, it will
3473 * be used to print the target address if this is a relative jump or call
3474 * The function returns the length of this instruction in bytes.
3477 static char intel_syntax;
3478 static char open_char;
3479 static char close_char;
3480 static char separator_char;
3481 static char scale_char;
3483 /* Here for backwards compatibility. When gdb stops using
3484 print_insn_i386_att and print_insn_i386_intel these functions can
3485 disappear, and print_insn_i386 be merged into print_insn. */
3487 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
3491 return print_insn (pc, info);
3495 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
3499 return print_insn (pc, info);
3503 print_insn_i386 (bfd_vma pc, disassemble_info *info)
3507 return print_insn (pc, info);
3511 print_i386_disassembler_options (FILE *stream)
3513 fprintf (stream, _("\n\
3514 The following i386/x86-64 specific disassembler options are supported for use\n\
3515 with the -M switch (multiple options should be separated by commas):\n"));
3517 fprintf (stream, _(" x86-64 Disassemble in 64bit mode\n"));
3518 fprintf (stream, _(" i386 Disassemble in 32bit mode\n"));
3519 fprintf (stream, _(" i8086 Disassemble in 16bit mode\n"));
3520 fprintf (stream, _(" att Display instruction in AT&T syntax\n"));
3521 fprintf (stream, _(" intel Display instruction in Intel syntax\n"));
3522 fprintf (stream, _(" addr64 Assume 64bit address size\n"));
3523 fprintf (stream, _(" addr32 Assume 32bit address size\n"));
3524 fprintf (stream, _(" addr16 Assume 16bit address size\n"));
3525 fprintf (stream, _(" data32 Assume 32bit data size\n"));
3526 fprintf (stream, _(" data16 Assume 16bit data size\n"));
3527 fprintf (stream, _(" suffix Always display instruction suffix in AT&T syntax\n"));
3531 print_insn (bfd_vma pc, disassemble_info *info)
3533 const struct dis386 *dp;
3535 char *op_txt[MAX_OPERANDS];
3537 unsigned char uses_DATA_prefix, uses_LOCK_prefix;
3538 unsigned char uses_REPNZ_prefix, uses_REPZ_prefix;
3541 struct dis_private priv;
3544 if (info->mach == bfd_mach_x86_64_intel_syntax
3545 || info->mach == bfd_mach_x86_64)
3546 address_mode = mode_64bit;
3548 address_mode = mode_32bit;
3550 if (intel_syntax == (char) -1)
3551 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
3552 || info->mach == bfd_mach_x86_64_intel_syntax);
3554 if (info->mach == bfd_mach_i386_i386
3555 || info->mach == bfd_mach_x86_64
3556 || info->mach == bfd_mach_i386_i386_intel_syntax
3557 || info->mach == bfd_mach_x86_64_intel_syntax)
3558 priv.orig_sizeflag = AFLAG | DFLAG;
3559 else if (info->mach == bfd_mach_i386_i8086)
3560 priv.orig_sizeflag = 0;
3564 for (p = info->disassembler_options; p != NULL; )
3566 if (CONST_STRNEQ (p, "x86-64"))
3568 address_mode = mode_64bit;
3569 priv.orig_sizeflag = AFLAG | DFLAG;
3571 else if (CONST_STRNEQ (p, "i386"))
3573 address_mode = mode_32bit;
3574 priv.orig_sizeflag = AFLAG | DFLAG;
3576 else if (CONST_STRNEQ (p, "i8086"))
3578 address_mode = mode_16bit;
3579 priv.orig_sizeflag = 0;
3581 else if (CONST_STRNEQ (p, "intel"))
3585 else if (CONST_STRNEQ (p, "att"))
3589 else if (CONST_STRNEQ (p, "addr"))
3591 if (address_mode == mode_64bit)
3593 if (p[4] == '3' && p[5] == '2')
3594 priv.orig_sizeflag &= ~AFLAG;
3595 else if (p[4] == '6' && p[5] == '4')
3596 priv.orig_sizeflag |= AFLAG;
3600 if (p[4] == '1' && p[5] == '6')
3601 priv.orig_sizeflag &= ~AFLAG;
3602 else if (p[4] == '3' && p[5] == '2')
3603 priv.orig_sizeflag |= AFLAG;
3606 else if (CONST_STRNEQ (p, "data"))
3608 if (p[4] == '1' && p[5] == '6')
3609 priv.orig_sizeflag &= ~DFLAG;
3610 else if (p[4] == '3' && p[5] == '2')
3611 priv.orig_sizeflag |= DFLAG;
3613 else if (CONST_STRNEQ (p, "suffix"))
3614 priv.orig_sizeflag |= SUFFIX_ALWAYS;
3616 p = strchr (p, ',');
3623 names64 = intel_names64;
3624 names32 = intel_names32;
3625 names16 = intel_names16;
3626 names8 = intel_names8;
3627 names8rex = intel_names8rex;
3628 names_seg = intel_names_seg;
3629 index16 = intel_index16;
3632 separator_char = '+';
3637 names64 = att_names64;
3638 names32 = att_names32;
3639 names16 = att_names16;
3640 names8 = att_names8;
3641 names8rex = att_names8rex;
3642 names_seg = att_names_seg;
3643 index16 = att_index16;
3646 separator_char = ',';
3650 /* The output looks better if we put 7 bytes on a line, since that
3651 puts most long word instructions on a single line. */
3652 info->bytes_per_line = 7;
3654 info->private_data = &priv;
3655 priv.max_fetched = priv.the_buffer;
3656 priv.insn_start = pc;
3659 for (i = 0; i < MAX_OPERANDS; ++i)
3667 start_codep = priv.the_buffer;
3668 codep = priv.the_buffer;
3670 if (setjmp (priv.bailout) != 0)
3674 /* Getting here means we tried for data but didn't get it. That
3675 means we have an incomplete instruction of some sort. Just
3676 print the first byte as a prefix or a .byte pseudo-op. */
3677 if (codep > priv.the_buffer)
3679 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3681 (*info->fprintf_func) (info->stream, "%s", name);
3684 /* Just print the first byte as a .byte instruction. */
3685 (*info->fprintf_func) (info->stream, ".byte 0x%x",
3686 (unsigned int) priv.the_buffer[0]);
3699 sizeflag = priv.orig_sizeflag;
3701 (void) FETCH_DATA (info, codep + 1);
3702 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
3704 if (((prefixes & PREFIX_FWAIT)
3705 && ((*codep < 0xd8) || (*codep > 0xdf)))
3706 || (rex && rex_used))
3710 /* fwait not followed by floating point instruction, or rex followed
3711 by other prefixes. Print the first prefix. */
3712 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3714 name = INTERNAL_DISASSEMBLER_ERROR;
3715 (*info->fprintf_func) (info->stream, "%s", name);
3722 unsigned char threebyte;
3723 (void) FETCH_DATA (info, codep + 2);
3724 threebyte = *++codep;
3725 dp = &dis386_twobyte[threebyte];
3726 need_modrm = twobyte_has_modrm[*codep];
3727 uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep];
3728 uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep];
3729 uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep];
3730 uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
3732 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3734 (void) FETCH_DATA (info, codep + 2);
3739 uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op];
3740 uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op];
3741 uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op];
3744 uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op];
3745 uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op];
3746 uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op];
3755 dp = &dis386[*codep];
3756 need_modrm = onebyte_has_modrm[*codep];
3757 uses_DATA_prefix = 0;
3758 uses_REPNZ_prefix = 0;
3759 /* pause is 0xf3 0x90. */
3760 uses_REPZ_prefix = *codep == 0x90;
3761 uses_LOCK_prefix = 0;
3765 if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ))
3768 used_prefixes |= PREFIX_REPZ;
3770 if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ))
3773 used_prefixes |= PREFIX_REPNZ;
3776 if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
3779 used_prefixes |= PREFIX_LOCK;
3782 if (prefixes & PREFIX_ADDR)
3785 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
3787 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3788 oappend ("addr32 ");
3790 oappend ("addr16 ");
3791 used_prefixes |= PREFIX_ADDR;
3795 if (!uses_DATA_prefix && (prefixes & PREFIX_DATA))
3798 if (dp->op[2].bytemode == cond_jump_mode
3799 && dp->op[0].bytemode == v_mode
3802 if (sizeflag & DFLAG)
3803 oappend ("data32 ");
3805 oappend ("data16 ");
3806 used_prefixes |= PREFIX_DATA;
3810 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3812 dp = &three_byte_table[dp->op[1].bytemode][op];
3813 modrm.mod = (*codep >> 6) & 3;
3814 modrm.reg = (*codep >> 3) & 7;
3815 modrm.rm = *codep & 7;
3817 else if (need_modrm)
3819 (void) FETCH_DATA (info, codep + 1);
3820 modrm.mod = (*codep >> 6) & 3;
3821 modrm.reg = (*codep >> 3) & 7;
3822 modrm.rm = *codep & 7;
3825 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
3832 if (dp->name == NULL)
3834 switch (dp->op[0].bytemode)
3837 dp = &grps[dp->op[1].bytemode][modrm.reg];
3840 case USE_PREFIX_USER_TABLE:
3842 used_prefixes |= (prefixes & PREFIX_REPZ);
3843 if (prefixes & PREFIX_REPZ)
3847 /* We should check PREFIX_REPNZ and PREFIX_REPZ
3848 before PREFIX_DATA. */
3849 used_prefixes |= (prefixes & PREFIX_REPNZ);
3850 if (prefixes & PREFIX_REPNZ)
3854 used_prefixes |= (prefixes & PREFIX_DATA);
3855 if (prefixes & PREFIX_DATA)
3859 dp = &prefix_user_table[dp->op[1].bytemode][index];
3862 case X86_64_SPECIAL:
3863 index = address_mode == mode_64bit ? 1 : 0;
3864 dp = &x86_64_table[dp->op[1].bytemode][index];
3868 oappend (INTERNAL_DISASSEMBLER_ERROR);
3873 if (putop (dp->name, sizeflag) == 0)
3875 for (i = 0; i < MAX_OPERANDS; ++i)
3878 op_ad = MAX_OPERANDS - 1 - i;
3880 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
3885 /* See if any prefixes were not used. If so, print the first one
3886 separately. If we don't do this, we'll wind up printing an
3887 instruction stream which does not precisely correspond to the
3888 bytes we are disassembling. */
3889 if ((prefixes & ~used_prefixes) != 0)
3893 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3895 name = INTERNAL_DISASSEMBLER_ERROR;
3896 (*info->fprintf_func) (info->stream, "%s", name);
3899 if (rex & ~rex_used)
3902 name = prefix_name (rex | 0x40, priv.orig_sizeflag);
3904 name = INTERNAL_DISASSEMBLER_ERROR;
3905 (*info->fprintf_func) (info->stream, "%s ", name);
3908 obufp = obuf + strlen (obuf);
3909 for (i = strlen (obuf); i < 6; i++)
3912 (*info->fprintf_func) (info->stream, "%s", obuf);
3914 /* The enter and bound instructions are printed with operands in the same
3915 order as the intel book; everything else is printed in reverse order. */
3916 if (intel_syntax || two_source_ops)
3920 for (i = 0; i < MAX_OPERANDS; ++i)
3921 op_txt[i] = op_out[i];
3923 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
3925 op_ad = op_index[i];
3926 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
3927 op_index[MAX_OPERANDS - 1 - i] = op_ad;
3928 riprel = op_riprel[i];
3929 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
3930 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
3935 for (i = 0; i < MAX_OPERANDS; ++i)
3936 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
3940 for (i = 0; i < MAX_OPERANDS; ++i)
3944 (*info->fprintf_func) (info->stream, ",");
3945 if (op_index[i] != -1 && !op_riprel[i])
3946 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
3948 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
3952 for (i = 0; i < MAX_OPERANDS; i++)
3953 if (op_index[i] != -1 && op_riprel[i])
3955 (*info->fprintf_func) (info->stream, " # ");
3956 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
3957 + op_address[op_index[i]]), info);
3960 return codep - priv.the_buffer;
3963 static const char *float_mem[] = {
4038 static const unsigned char float_mem_mode[] = {
4113 #define ST { OP_ST, 0 }
4114 #define STi { OP_STi, 0 }
4116 #define FGRPd9_2 NULL, { { NULL, 0 } }
4117 #define FGRPd9_4 NULL, { { NULL, 1 } }
4118 #define FGRPd9_5 NULL, { { NULL, 2 } }
4119 #define FGRPd9_6 NULL, { { NULL, 3 } }
4120 #define FGRPd9_7 NULL, { { NULL, 4 } }
4121 #define FGRPda_5 NULL, { { NULL, 5 } }
4122 #define FGRPdb_4 NULL, { { NULL, 6 } }
4123 #define FGRPde_3 NULL, { { NULL, 7 } }
4124 #define FGRPdf_4 NULL, { { NULL, 8 } }
4126 static const struct dis386 float_reg[][8] = {
4129 { "fadd", { ST, STi } },
4130 { "fmul", { ST, STi } },
4131 { "fcom", { STi } },
4132 { "fcomp", { STi } },
4133 { "fsub", { ST, STi } },
4134 { "fsubr", { ST, STi } },
4135 { "fdiv", { ST, STi } },
4136 { "fdivr", { ST, STi } },
4141 { "fxch", { STi } },
4143 { "(bad)", { XX } },
4151 { "fcmovb", { ST, STi } },
4152 { "fcmove", { ST, STi } },
4153 { "fcmovbe",{ ST, STi } },
4154 { "fcmovu", { ST, STi } },
4155 { "(bad)", { XX } },
4157 { "(bad)", { XX } },
4158 { "(bad)", { XX } },
4162 { "fcmovnb",{ ST, STi } },
4163 { "fcmovne",{ ST, STi } },
4164 { "fcmovnbe",{ ST, STi } },
4165 { "fcmovnu",{ ST, STi } },
4167 { "fucomi", { ST, STi } },
4168 { "fcomi", { ST, STi } },
4169 { "(bad)", { XX } },
4173 { "fadd", { STi, ST } },
4174 { "fmul", { STi, ST } },
4175 { "(bad)", { XX } },
4176 { "(bad)", { XX } },
4178 { "fsub", { STi, ST } },
4179 { "fsubr", { STi, ST } },
4180 { "fdiv", { STi, ST } },
4181 { "fdivr", { STi, ST } },
4183 { "fsubr", { STi, ST } },
4184 { "fsub", { STi, ST } },
4185 { "fdivr", { STi, ST } },
4186 { "fdiv", { STi, ST } },
4191 { "ffree", { STi } },
4192 { "(bad)", { XX } },
4194 { "fstp", { STi } },
4195 { "fucom", { STi } },
4196 { "fucomp", { STi } },
4197 { "(bad)", { XX } },
4198 { "(bad)", { XX } },
4202 { "faddp", { STi, ST } },
4203 { "fmulp", { STi, ST } },
4204 { "(bad)", { XX } },
4207 { "fsubp", { STi, ST } },
4208 { "fsubrp", { STi, ST } },
4209 { "fdivp", { STi, ST } },
4210 { "fdivrp", { STi, ST } },
4212 { "fsubrp", { STi, ST } },
4213 { "fsubp", { STi, ST } },
4214 { "fdivrp", { STi, ST } },
4215 { "fdivp", { STi, ST } },
4220 { "ffreep", { STi } },
4221 { "(bad)", { XX } },
4222 { "(bad)", { XX } },
4223 { "(bad)", { XX } },
4225 { "fucomip", { ST, STi } },
4226 { "fcomip", { ST, STi } },
4227 { "(bad)", { XX } },
4231 static char *fgrps[][8] = {
4234 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4239 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
4244 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
4249 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
4254 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
4259 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4264 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
4265 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
4270 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4275 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4280 dofloat (int sizeflag)
4282 const struct dis386 *dp;
4283 unsigned char floatop;
4285 floatop = codep[-1];
4289 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
4291 putop (float_mem[fp_indx], sizeflag);
4294 OP_E (float_mem_mode[fp_indx], sizeflag);
4297 /* Skip mod/rm byte. */
4301 dp = &float_reg[floatop - 0xd8][modrm.reg];
4302 if (dp->name == NULL)
4304 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
4306 /* Instruction fnstsw is only one with strange arg. */
4307 if (floatop == 0xdf && codep[-1] == 0xe0)
4308 strcpy (op_out[0], names16[0]);
4312 putop (dp->name, sizeflag);
4317 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
4322 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
4327 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4329 oappend ("%st" + intel_syntax);
4333 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4335 sprintf (scratchbuf, "%%st(%d)", modrm.rm);
4336 oappend (scratchbuf + intel_syntax);
4339 /* Capital letters in template are macros. */
4341 putop (const char *template, int sizeflag)
4346 for (p = template; *p; p++)
4357 if (address_mode == mode_64bit)
4365 /* Alternative not valid. */
4366 strcpy (obuf, "(bad)");
4370 else if (*p == '\0')
4391 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4397 if (sizeflag & SUFFIX_ALWAYS)
4401 if (intel_syntax && !alt)
4403 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
4405 if (sizeflag & DFLAG)
4406 *obufp++ = intel_syntax ? 'd' : 'l';
4408 *obufp++ = intel_syntax ? 'w' : 's';
4409 used_prefixes |= (prefixes & PREFIX_DATA);
4413 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
4420 else if (sizeflag & DFLAG)
4421 *obufp++ = intel_syntax ? 'd' : 'l';
4424 used_prefixes |= (prefixes & PREFIX_DATA);
4429 case 'E': /* For jcxz/jecxz */
4430 if (address_mode == mode_64bit)
4432 if (sizeflag & AFLAG)
4438 if (sizeflag & AFLAG)
4440 used_prefixes |= (prefixes & PREFIX_ADDR);
4445 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
4447 if (sizeflag & AFLAG)
4448 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
4450 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
4451 used_prefixes |= (prefixes & PREFIX_ADDR);
4455 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
4457 if ((rex & REX_W) || (sizeflag & DFLAG))
4462 used_prefixes |= (prefixes & PREFIX_DATA);
4467 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
4468 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
4470 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
4473 if (prefixes & PREFIX_DS)
4494 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
4503 if (sizeflag & SUFFIX_ALWAYS)
4507 if ((prefixes & PREFIX_FWAIT) == 0)
4510 used_prefixes |= PREFIX_FWAIT;
4516 else if (intel_syntax && (sizeflag & DFLAG))
4521 used_prefixes |= (prefixes & PREFIX_DATA);
4526 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4535 if ((prefixes & PREFIX_DATA)
4537 || (sizeflag & SUFFIX_ALWAYS))
4544 if (sizeflag & DFLAG)
4549 used_prefixes |= (prefixes & PREFIX_DATA);
4555 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4557 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4563 if (intel_syntax && !alt)
4566 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4572 if (sizeflag & DFLAG)
4573 *obufp++ = intel_syntax ? 'd' : 'l';
4577 used_prefixes |= (prefixes & PREFIX_DATA);
4584 else if (sizeflag & DFLAG)
4593 if (intel_syntax && !p[1]
4594 && ((rex & REX_W) || (sizeflag & DFLAG)))
4597 used_prefixes |= (prefixes & PREFIX_DATA);
4602 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4604 if (sizeflag & SUFFIX_ALWAYS)
4612 if (sizeflag & SUFFIX_ALWAYS)
4618 if (sizeflag & DFLAG)
4622 used_prefixes |= (prefixes & PREFIX_DATA);
4627 if (prefixes & PREFIX_DATA)
4631 used_prefixes |= (prefixes & PREFIX_DATA);
4642 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
4644 /* operand size flag for cwtl, cbtw */
4653 else if (sizeflag & DFLAG)
4658 used_prefixes |= (prefixes & PREFIX_DATA);
4668 oappend (const char *s)
4671 obufp += strlen (s);
4677 if (prefixes & PREFIX_CS)
4679 used_prefixes |= PREFIX_CS;
4680 oappend ("%cs:" + intel_syntax);
4682 if (prefixes & PREFIX_DS)
4684 used_prefixes |= PREFIX_DS;
4685 oappend ("%ds:" + intel_syntax);
4687 if (prefixes & PREFIX_SS)
4689 used_prefixes |= PREFIX_SS;
4690 oappend ("%ss:" + intel_syntax);
4692 if (prefixes & PREFIX_ES)
4694 used_prefixes |= PREFIX_ES;
4695 oappend ("%es:" + intel_syntax);
4697 if (prefixes & PREFIX_FS)
4699 used_prefixes |= PREFIX_FS;
4700 oappend ("%fs:" + intel_syntax);
4702 if (prefixes & PREFIX_GS)
4704 used_prefixes |= PREFIX_GS;
4705 oappend ("%gs:" + intel_syntax);
4710 OP_indirE (int bytemode, int sizeflag)
4714 OP_E (bytemode, sizeflag);
4718 print_operand_value (char *buf, int hex, bfd_vma disp)
4720 if (address_mode == mode_64bit)
4728 sprintf_vma (tmp, disp);
4729 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
4730 strcpy (buf + 2, tmp + i);
4734 bfd_signed_vma v = disp;
4741 /* Check for possible overflow on 0x8000000000000000. */
4744 strcpy (buf, "9223372036854775808");
4758 tmp[28 - i] = (v % 10) + '0';
4762 strcpy (buf, tmp + 29 - i);
4768 sprintf (buf, "0x%x", (unsigned int) disp);
4770 sprintf (buf, "%d", (int) disp);
4774 /* Put DISP in BUF as signed hex number. */
4777 print_displacement (char *buf, bfd_vma disp)
4779 bfd_signed_vma val = disp;
4788 /* Check for possible overflow. */
4791 switch (address_mode)
4794 strcpy (buf + j, "0x8000000000000000");
4797 strcpy (buf + j, "0x80000000");
4800 strcpy (buf + j, "0x8000");
4810 sprintf_vma (tmp, val);
4811 for (i = 0; tmp[i] == '0'; i++)
4815 strcpy (buf + j, tmp + i);
4819 intel_operand_size (int bytemode, int sizeflag)
4825 oappend ("BYTE PTR ");
4829 oappend ("WORD PTR ");
4832 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4834 oappend ("QWORD PTR ");
4835 used_prefixes |= (prefixes & PREFIX_DATA);
4843 oappend ("QWORD PTR ");
4844 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
4845 oappend ("DWORD PTR ");
4847 oappend ("WORD PTR ");
4848 used_prefixes |= (prefixes & PREFIX_DATA);
4851 if ((rex & REX_W) || (sizeflag & DFLAG))
4853 oappend ("WORD PTR ");
4855 used_prefixes |= (prefixes & PREFIX_DATA);
4859 oappend ("DWORD PTR ");
4862 oappend ("QWORD PTR ");
4865 if (address_mode == mode_64bit)
4866 oappend ("QWORD PTR ");
4868 oappend ("DWORD PTR ");
4871 if (sizeflag & DFLAG)
4872 oappend ("FWORD PTR ");
4874 oappend ("DWORD PTR ");
4875 used_prefixes |= (prefixes & PREFIX_DATA);
4878 oappend ("TBYTE PTR ");
4881 oappend ("XMMWORD PTR ");
4884 oappend ("OWORD PTR ");
4892 OP_E (int bytemode, int sizeflag)
4901 /* Skip mod/rm byte. */
4912 oappend (names8rex[modrm.rm + add]);
4914 oappend (names8[modrm.rm + add]);
4917 oappend (names16[modrm.rm + add]);
4920 oappend (names32[modrm.rm + add]);
4923 oappend (names64[modrm.rm + add]);
4926 if (address_mode == mode_64bit)
4927 oappend (names64[modrm.rm + add]);
4929 oappend (names32[modrm.rm + add]);
4932 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4934 oappend (names64[modrm.rm + add]);
4935 used_prefixes |= (prefixes & PREFIX_DATA);
4947 oappend (names64[modrm.rm + add]);
4948 else if ((sizeflag & DFLAG) || bytemode != v_mode)
4949 oappend (names32[modrm.rm + add]);
4951 oappend (names16[modrm.rm + add]);
4952 used_prefixes |= (prefixes & PREFIX_DATA);
4957 oappend (INTERNAL_DISASSEMBLER_ERROR);
4965 intel_operand_size (bytemode, sizeflag);
4968 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
4970 /* 32/64 bit address mode */
4985 (void) FETCH_DATA (the_info, codep + 1);
4986 index = (*codep >> 3) & 7;
4987 if (address_mode == mode_64bit || index != 0x4)
4988 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
4989 scale = (*codep >> 6) & 3;
5001 if ((base & 7) == 5)
5004 if (address_mode == mode_64bit && !havesib)
5010 FETCH_DATA (the_info, codep + 1);
5012 if ((disp & 0x80) != 0)
5020 havedisp = havebase || (havesib && (index != 4 || scale != 0));
5023 if (modrm.mod != 0 || (base & 7) == 5)
5025 if (havedisp || riprel)
5026 print_displacement (scratchbuf, disp);
5028 print_operand_value (scratchbuf, 1, disp);
5029 oappend (scratchbuf);
5037 if (havedisp || (intel_syntax && riprel))
5039 *obufp++ = open_char;
5040 if (intel_syntax && riprel)
5047 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5048 ? names64[base] : names32[base]);
5053 if (!intel_syntax || havebase)
5055 *obufp++ = separator_char;
5058 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5059 ? names64[index] : names32[index]);
5061 if (scale != 0 || (!intel_syntax && index != 4))
5063 *obufp++ = scale_char;
5065 sprintf (scratchbuf, "%d", 1 << scale);
5066 oappend (scratchbuf);
5070 && (disp || modrm.mod != 0 || (base & 7) == 5))
5072 if ((bfd_signed_vma) disp >= 0)
5077 else if (modrm.mod != 1)
5081 disp = - (bfd_signed_vma) disp;
5084 print_displacement (scratchbuf, disp);
5085 oappend (scratchbuf);
5088 *obufp++ = close_char;
5091 else if (intel_syntax)
5093 if (modrm.mod != 0 || (base & 7) == 5)
5095 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5096 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5100 oappend (names_seg[ds_reg - es_reg]);
5103 print_operand_value (scratchbuf, 1, disp);
5104 oappend (scratchbuf);
5109 { /* 16 bit address mode */
5116 if ((disp & 0x8000) != 0)
5121 FETCH_DATA (the_info, codep + 1);
5123 if ((disp & 0x80) != 0)
5128 if ((disp & 0x8000) != 0)
5134 if (modrm.mod != 0 || modrm.rm == 6)
5136 print_displacement (scratchbuf, disp);
5137 oappend (scratchbuf);
5140 if (modrm.mod != 0 || modrm.rm != 6)
5142 *obufp++ = open_char;
5144 oappend (index16[modrm.rm]);
5146 && (disp || modrm.mod != 0 || modrm.rm == 6))
5148 if ((bfd_signed_vma) disp >= 0)
5153 else if (modrm.mod != 1)
5157 disp = - (bfd_signed_vma) disp;
5160 print_displacement (scratchbuf, disp);
5161 oappend (scratchbuf);
5164 *obufp++ = close_char;
5167 else if (intel_syntax)
5169 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5170 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5174 oappend (names_seg[ds_reg - es_reg]);
5177 print_operand_value (scratchbuf, 1, disp & 0xffff);
5178 oappend (scratchbuf);
5184 OP_G (int bytemode, int sizeflag)
5195 oappend (names8rex[modrm.reg + add]);
5197 oappend (names8[modrm.reg + add]);
5200 oappend (names16[modrm.reg + add]);
5203 oappend (names32[modrm.reg + add]);
5206 oappend (names64[modrm.reg + add]);
5215 oappend (names64[modrm.reg + add]);
5216 else if ((sizeflag & DFLAG) || bytemode != v_mode)
5217 oappend (names32[modrm.reg + add]);
5219 oappend (names16[modrm.reg + add]);
5220 used_prefixes |= (prefixes & PREFIX_DATA);
5223 if (address_mode == mode_64bit)
5224 oappend (names64[modrm.reg + add]);
5226 oappend (names32[modrm.reg + add]);
5229 oappend (INTERNAL_DISASSEMBLER_ERROR);
5242 (void) FETCH_DATA (the_info, codep + 8);
5243 a = *codep++ & 0xff;
5244 a |= (*codep++ & 0xff) << 8;
5245 a |= (*codep++ & 0xff) << 16;
5246 a |= (*codep++ & 0xff) << 24;
5247 b = *codep++ & 0xff;
5248 b |= (*codep++ & 0xff) << 8;
5249 b |= (*codep++ & 0xff) << 16;
5250 b |= (*codep++ & 0xff) << 24;
5251 x = a + ((bfd_vma) b << 32);
5259 static bfd_signed_vma
5262 bfd_signed_vma x = 0;
5264 (void) FETCH_DATA (the_info, codep + 4);
5265 x = *codep++ & (bfd_signed_vma) 0xff;
5266 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5267 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5268 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5272 static bfd_signed_vma
5275 bfd_signed_vma x = 0;
5277 (void) FETCH_DATA (the_info, codep + 4);
5278 x = *codep++ & (bfd_signed_vma) 0xff;
5279 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5280 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5281 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5283 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
5293 (void) FETCH_DATA (the_info, codep + 2);
5294 x = *codep++ & 0xff;
5295 x |= (*codep++ & 0xff) << 8;
5300 set_op (bfd_vma op, int riprel)
5302 op_index[op_ad] = op_ad;
5303 if (address_mode == mode_64bit)
5305 op_address[op_ad] = op;
5306 op_riprel[op_ad] = riprel;
5310 /* Mask to get a 32-bit address. */
5311 op_address[op_ad] = op & 0xffffffff;
5312 op_riprel[op_ad] = riprel & 0xffffffff;
5317 OP_REG (int code, int sizeflag)
5327 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5328 case sp_reg: case bp_reg: case si_reg: case di_reg:
5329 s = names16[code - ax_reg + add];
5331 case es_reg: case ss_reg: case cs_reg:
5332 case ds_reg: case fs_reg: case gs_reg:
5333 s = names_seg[code - es_reg + add];
5335 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5336 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5339 s = names8rex[code - al_reg + add];
5341 s = names8[code - al_reg];
5343 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
5344 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
5345 if (address_mode == mode_64bit && (sizeflag & DFLAG))
5347 s = names64[code - rAX_reg + add];
5350 code += eAX_reg - rAX_reg;
5352 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5353 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5356 s = names64[code - eAX_reg + add];
5357 else if (sizeflag & DFLAG)
5358 s = names32[code - eAX_reg + add];
5360 s = names16[code - eAX_reg + add];
5361 used_prefixes |= (prefixes & PREFIX_DATA);
5364 s = INTERNAL_DISASSEMBLER_ERROR;
5371 OP_IMREG (int code, int sizeflag)
5383 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5384 case sp_reg: case bp_reg: case si_reg: case di_reg:
5385 s = names16[code - ax_reg];
5387 case es_reg: case ss_reg: case cs_reg:
5388 case ds_reg: case fs_reg: case gs_reg:
5389 s = names_seg[code - es_reg];
5391 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5392 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5395 s = names8rex[code - al_reg];
5397 s = names8[code - al_reg];
5399 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5400 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5403 s = names64[code - eAX_reg];
5404 else if (sizeflag & DFLAG)
5405 s = names32[code - eAX_reg];
5407 s = names16[code - eAX_reg];
5408 used_prefixes |= (prefixes & PREFIX_DATA);
5411 if ((rex & REX_W) || (sizeflag & DFLAG))
5416 used_prefixes |= (prefixes & PREFIX_DATA);
5419 s = INTERNAL_DISASSEMBLER_ERROR;
5426 OP_I (int bytemode, int sizeflag)
5429 bfd_signed_vma mask = -1;
5434 FETCH_DATA (the_info, codep + 1);
5439 if (address_mode == mode_64bit)
5449 else if (sizeflag & DFLAG)
5459 used_prefixes |= (prefixes & PREFIX_DATA);
5470 oappend (INTERNAL_DISASSEMBLER_ERROR);
5475 scratchbuf[0] = '$';
5476 print_operand_value (scratchbuf + 1, 1, op);
5477 oappend (scratchbuf + intel_syntax);
5478 scratchbuf[0] = '\0';
5482 OP_I64 (int bytemode, int sizeflag)
5485 bfd_signed_vma mask = -1;
5487 if (address_mode != mode_64bit)
5489 OP_I (bytemode, sizeflag);
5496 FETCH_DATA (the_info, codep + 1);
5504 else if (sizeflag & DFLAG)
5514 used_prefixes |= (prefixes & PREFIX_DATA);
5521 oappend (INTERNAL_DISASSEMBLER_ERROR);
5526 scratchbuf[0] = '$';
5527 print_operand_value (scratchbuf + 1, 1, op);
5528 oappend (scratchbuf + intel_syntax);
5529 scratchbuf[0] = '\0';
5533 OP_sI (int bytemode, int sizeflag)
5536 bfd_signed_vma mask = -1;
5541 FETCH_DATA (the_info, codep + 1);
5543 if ((op & 0x80) != 0)
5551 else if (sizeflag & DFLAG)
5560 if ((op & 0x8000) != 0)
5563 used_prefixes |= (prefixes & PREFIX_DATA);
5568 if ((op & 0x8000) != 0)
5572 oappend (INTERNAL_DISASSEMBLER_ERROR);
5576 scratchbuf[0] = '$';
5577 print_operand_value (scratchbuf + 1, 1, op);
5578 oappend (scratchbuf + intel_syntax);
5582 OP_J (int bytemode, int sizeflag)
5586 bfd_vma segment = 0;
5591 FETCH_DATA (the_info, codep + 1);
5593 if ((disp & 0x80) != 0)
5597 if ((sizeflag & DFLAG) || (rex & REX_W))
5602 if ((disp & 0x8000) != 0)
5604 /* In 16bit mode, address is wrapped around at 64k within
5605 the same segment. Otherwise, a data16 prefix on a jump
5606 instruction means that the pc is masked to 16 bits after
5607 the displacement is added! */
5609 if ((prefixes & PREFIX_DATA) == 0)
5610 segment = ((start_pc + codep - start_codep)
5611 & ~((bfd_vma) 0xffff));
5613 used_prefixes |= (prefixes & PREFIX_DATA);
5616 oappend (INTERNAL_DISASSEMBLER_ERROR);
5619 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
5621 print_operand_value (scratchbuf, 1, disp);
5622 oappend (scratchbuf);
5626 OP_SEG (int bytemode, int sizeflag)
5628 if (bytemode == w_mode)
5629 oappend (names_seg[modrm.reg]);
5631 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
5635 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
5639 if (sizeflag & DFLAG)
5649 used_prefixes |= (prefixes & PREFIX_DATA);
5651 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
5653 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
5654 oappend (scratchbuf);
5658 OP_OFF (int bytemode, int sizeflag)
5662 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5663 intel_operand_size (bytemode, sizeflag);
5666 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
5673 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5674 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5676 oappend (names_seg[ds_reg - es_reg]);
5680 print_operand_value (scratchbuf, 1, off);
5681 oappend (scratchbuf);
5685 OP_OFF64 (int bytemode, int sizeflag)
5689 if (address_mode != mode_64bit
5690 || (prefixes & PREFIX_ADDR))
5692 OP_OFF (bytemode, sizeflag);
5696 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5697 intel_operand_size (bytemode, sizeflag);
5704 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5705 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5707 oappend (names_seg[ds_reg - es_reg]);
5711 print_operand_value (scratchbuf, 1, off);
5712 oappend (scratchbuf);
5716 ptr_reg (int code, int sizeflag)
5720 *obufp++ = open_char;
5721 used_prefixes |= (prefixes & PREFIX_ADDR);
5722 if (address_mode == mode_64bit)
5724 if (!(sizeflag & AFLAG))
5725 s = names32[code - eAX_reg];
5727 s = names64[code - eAX_reg];
5729 else if (sizeflag & AFLAG)
5730 s = names32[code - eAX_reg];
5732 s = names16[code - eAX_reg];
5734 *obufp++ = close_char;
5739 OP_ESreg (int code, int sizeflag)
5745 case 0x6d: /* insw/insl */
5746 intel_operand_size (z_mode, sizeflag);
5748 case 0xa5: /* movsw/movsl/movsq */
5749 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5750 case 0xab: /* stosw/stosl */
5751 case 0xaf: /* scasw/scasl */
5752 intel_operand_size (v_mode, sizeflag);
5755 intel_operand_size (b_mode, sizeflag);
5758 oappend ("%es:" + intel_syntax);
5759 ptr_reg (code, sizeflag);
5763 OP_DSreg (int code, int sizeflag)
5769 case 0x6f: /* outsw/outsl */
5770 intel_operand_size (z_mode, sizeflag);
5772 case 0xa5: /* movsw/movsl/movsq */
5773 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5774 case 0xad: /* lodsw/lodsl/lodsq */
5775 intel_operand_size (v_mode, sizeflag);
5778 intel_operand_size (b_mode, sizeflag);
5788 prefixes |= PREFIX_DS;
5790 ptr_reg (code, sizeflag);
5794 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5802 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
5804 used_prefixes |= PREFIX_LOCK;
5807 sprintf (scratchbuf, "%%cr%d", modrm.reg + add);
5808 oappend (scratchbuf + intel_syntax);
5812 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5819 sprintf (scratchbuf, "db%d", modrm.reg + add);
5821 sprintf (scratchbuf, "%%db%d", modrm.reg + add);
5822 oappend (scratchbuf);
5826 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5828 sprintf (scratchbuf, "%%tr%d", modrm.reg);
5829 oappend (scratchbuf + intel_syntax);
5833 OP_R (int bytemode, int sizeflag)
5836 OP_E (bytemode, sizeflag);
5842 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5844 used_prefixes |= (prefixes & PREFIX_DATA);
5845 if (prefixes & PREFIX_DATA)
5851 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
5854 sprintf (scratchbuf, "%%mm%d", modrm.reg);
5855 oappend (scratchbuf + intel_syntax);
5859 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5865 sprintf (scratchbuf, "%%xmm%d", modrm.reg + add);
5866 oappend (scratchbuf + intel_syntax);
5870 OP_EM (int bytemode, int sizeflag)
5874 if (intel_syntax && bytemode == v_mode)
5876 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5877 used_prefixes |= (prefixes & PREFIX_DATA);
5879 OP_E (bytemode, sizeflag);
5883 /* Skip mod/rm byte. */
5886 used_prefixes |= (prefixes & PREFIX_DATA);
5887 if (prefixes & PREFIX_DATA)
5894 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
5897 sprintf (scratchbuf, "%%mm%d", modrm.rm);
5898 oappend (scratchbuf + intel_syntax);
5901 /* cvt* are the only instructions in sse2 which have
5902 both SSE and MMX operands and also have 0x66 prefix
5903 in their opcode. 0x66 was originally used to differentiate
5904 between SSE and MMX instruction(operands). So we have to handle the
5905 cvt* separately using OP_EMC and OP_MXC */
5907 OP_EMC (int bytemode, int sizeflag)
5911 if (intel_syntax && bytemode == v_mode)
5913 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5914 used_prefixes |= (prefixes & PREFIX_DATA);
5916 OP_E (bytemode, sizeflag);
5920 /* Skip mod/rm byte. */
5923 used_prefixes |= (prefixes & PREFIX_DATA);
5924 sprintf (scratchbuf, "%%mm%d", modrm.rm);
5925 oappend (scratchbuf + intel_syntax);
5929 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5931 used_prefixes |= (prefixes & PREFIX_DATA);
5932 sprintf (scratchbuf, "%%mm%d", modrm.reg);
5933 oappend (scratchbuf + intel_syntax);
5937 OP_EX (int bytemode, int sizeflag)
5942 OP_E (bytemode, sizeflag);
5949 /* Skip mod/rm byte. */
5952 sprintf (scratchbuf, "%%xmm%d", modrm.rm + add);
5953 oappend (scratchbuf + intel_syntax);
5957 OP_MS (int bytemode, int sizeflag)
5960 OP_EM (bytemode, sizeflag);
5966 OP_XS (int bytemode, int sizeflag)
5969 OP_EX (bytemode, sizeflag);
5975 OP_M (int bytemode, int sizeflag)
5978 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst,invept,invvpid modrm */
5981 OP_E (bytemode, sizeflag);
5985 OP_0f07 (int bytemode, int sizeflag)
5987 if (modrm.mod != 3 || modrm.rm != 0)
5990 OP_E (bytemode, sizeflag);
5994 OP_0fae (int bytemode, int sizeflag)
5999 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
6000 else if (modrm.reg == 6)
6001 strcpy (obuf + strlen (obuf) - sizeof ("xsaveopt") + 1, "mfence");
6002 else if (modrm.reg == 5)
6003 strcpy (obuf + strlen (obuf) - sizeof ("xrstor") + 1, "lfence");
6005 if (modrm.reg < 5 || modrm.rm != 0)
6007 BadOp (); /* bad sfence, mfence, or lfence */
6013 OP_E (bytemode, sizeflag);
6016 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
6017 32bit mode and "xchg %rax,%rax" in 64bit mode. */
6020 NOP_Fixup1 (int bytemode, int sizeflag)
6022 if ((prefixes & PREFIX_DATA) != 0
6025 && address_mode == mode_64bit))
6026 OP_REG (bytemode, sizeflag);
6028 strcpy (obuf, "nop");
6032 NOP_Fixup2 (int bytemode, int sizeflag)
6034 if ((prefixes & PREFIX_DATA) != 0
6037 && address_mode == mode_64bit))
6038 OP_IMREG (bytemode, sizeflag);
6041 static const char *const Suffix3DNow[] = {
6042 /* 00 */ NULL, NULL, NULL, NULL,
6043 /* 04 */ NULL, NULL, NULL, NULL,
6044 /* 08 */ NULL, NULL, NULL, NULL,
6045 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
6046 /* 10 */ NULL, NULL, NULL, NULL,
6047 /* 14 */ NULL, NULL, NULL, NULL,
6048 /* 18 */ NULL, NULL, NULL, NULL,
6049 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
6050 /* 20 */ NULL, NULL, NULL, NULL,
6051 /* 24 */ NULL, NULL, NULL, NULL,
6052 /* 28 */ NULL, NULL, NULL, NULL,
6053 /* 2C */ NULL, NULL, NULL, NULL,
6054 /* 30 */ NULL, NULL, NULL, NULL,
6055 /* 34 */ NULL, NULL, NULL, NULL,
6056 /* 38 */ NULL, NULL, NULL, NULL,
6057 /* 3C */ NULL, NULL, NULL, NULL,
6058 /* 40 */ NULL, NULL, NULL, NULL,
6059 /* 44 */ NULL, NULL, NULL, NULL,
6060 /* 48 */ NULL, NULL, NULL, NULL,
6061 /* 4C */ NULL, NULL, NULL, NULL,
6062 /* 50 */ NULL, NULL, NULL, NULL,
6063 /* 54 */ NULL, NULL, NULL, NULL,
6064 /* 58 */ NULL, NULL, NULL, NULL,
6065 /* 5C */ NULL, NULL, NULL, NULL,
6066 /* 60 */ NULL, NULL, NULL, NULL,
6067 /* 64 */ NULL, NULL, NULL, NULL,
6068 /* 68 */ NULL, NULL, NULL, NULL,
6069 /* 6C */ NULL, NULL, NULL, NULL,
6070 /* 70 */ NULL, NULL, NULL, NULL,
6071 /* 74 */ NULL, NULL, NULL, NULL,
6072 /* 78 */ NULL, NULL, NULL, NULL,
6073 /* 7C */ NULL, NULL, NULL, NULL,
6074 /* 80 */ NULL, NULL, NULL, NULL,
6075 /* 84 */ NULL, NULL, NULL, NULL,
6076 /* 88 */ NULL, NULL, "pfnacc", NULL,
6077 /* 8C */ NULL, NULL, "pfpnacc", NULL,
6078 /* 90 */ "pfcmpge", NULL, NULL, NULL,
6079 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
6080 /* 98 */ NULL, NULL, "pfsub", NULL,
6081 /* 9C */ NULL, NULL, "pfadd", NULL,
6082 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
6083 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
6084 /* A8 */ NULL, NULL, "pfsubr", NULL,
6085 /* AC */ NULL, NULL, "pfacc", NULL,
6086 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
6087 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
6088 /* B8 */ NULL, NULL, NULL, "pswapd",
6089 /* BC */ NULL, NULL, NULL, "pavgusb",
6090 /* C0 */ NULL, NULL, NULL, NULL,
6091 /* C4 */ NULL, NULL, NULL, NULL,
6092 /* C8 */ NULL, NULL, NULL, NULL,
6093 /* CC */ NULL, NULL, NULL, NULL,
6094 /* D0 */ NULL, NULL, NULL, NULL,
6095 /* D4 */ NULL, NULL, NULL, NULL,
6096 /* D8 */ NULL, NULL, NULL, NULL,
6097 /* DC */ NULL, NULL, NULL, NULL,
6098 /* E0 */ NULL, NULL, NULL, NULL,
6099 /* E4 */ NULL, NULL, NULL, NULL,
6100 /* E8 */ NULL, NULL, NULL, NULL,
6101 /* EC */ NULL, NULL, NULL, NULL,
6102 /* F0 */ NULL, NULL, NULL, NULL,
6103 /* F4 */ NULL, NULL, NULL, NULL,
6104 /* F8 */ NULL, NULL, NULL, NULL,
6105 /* FC */ NULL, NULL, NULL, NULL,
6109 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6111 const char *mnemonic;
6113 (void) FETCH_DATA (the_info, codep + 1);
6114 /* AMD 3DNow! instructions are specified by an opcode suffix in the
6115 place where an 8-bit immediate would normally go. ie. the last
6116 byte of the instruction. */
6117 obufp = obuf + strlen (obuf);
6118 mnemonic = Suffix3DNow[*codep++ & 0xff];
6123 /* Since a variable sized modrm/sib chunk is between the start
6124 of the opcode (0x0f0f) and the opcode suffix, we need to do
6125 all the modrm processing first, and don't know until now that
6126 we have a bad opcode. This necessitates some cleaning up. */
6127 op_out[0][0] = '\0';
6128 op_out[1][0] = '\0';
6133 static const char *simd_cmp_op[] = {
6145 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6147 unsigned int cmp_type;
6149 (void) FETCH_DATA (the_info, codep + 1);
6150 obufp = obuf + strlen (obuf);
6151 cmp_type = *codep++ & 0xff;
6154 char suffix1 = 'p', suffix2 = 's';
6155 used_prefixes |= (prefixes & PREFIX_REPZ);
6156 if (prefixes & PREFIX_REPZ)
6160 used_prefixes |= (prefixes & PREFIX_DATA);
6161 if (prefixes & PREFIX_DATA)
6165 used_prefixes |= (prefixes & PREFIX_REPNZ);
6166 if (prefixes & PREFIX_REPNZ)
6167 suffix1 = 's', suffix2 = 'd';
6170 sprintf (scratchbuf, "cmp%s%c%c",
6171 simd_cmp_op[cmp_type], suffix1, suffix2);
6172 used_prefixes |= (prefixes & PREFIX_REPZ);
6173 oappend (scratchbuf);
6177 /* We have a bad extension byte. Clean up. */
6178 op_out[0][0] = '\0';
6179 op_out[1][0] = '\0';
6185 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
6187 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
6188 forms of these instructions. */
6191 char *p = obuf + strlen (obuf);
6194 *(p - 1) = *(p - 2);
6195 *(p - 2) = *(p - 3);
6196 *(p - 3) = extrachar;
6201 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6203 if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1)
6205 /* Override "sidt". */
6206 size_t olen = strlen (obuf);
6207 char *p = obuf + olen - 4;
6208 const char **names = (address_mode == mode_64bit
6209 ? names64 : names32);
6211 /* We might have a suffix when disassembling with -Msuffix. */
6215 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6217 && (prefixes & PREFIX_ADDR)
6220 && CONST_STRNEQ (p - 7, "addr")
6221 && (CONST_STRNEQ (p - 3, "16")
6222 || CONST_STRNEQ (p - 3, "32")))
6227 /* mwait %eax,%ecx */
6228 strcpy (p, "mwait");
6230 strcpy (op_out[0], names[0]);
6234 /* monitor %eax,%ecx,%edx" */
6235 strcpy (p, "monitor");
6238 const char **op1_names;
6239 if (!(prefixes & PREFIX_ADDR))
6240 op1_names = (address_mode == mode_16bit
6244 op1_names = (address_mode != mode_32bit
6245 ? names32 : names16);
6246 used_prefixes |= PREFIX_ADDR;
6248 strcpy (op_out[0], op1_names[0]);
6249 strcpy (op_out[2], names[2]);
6254 strcpy (op_out[1], names[1]);
6260 else if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 3)
6262 size_t olen = strlen (obuf);
6263 char *p = obuf + olen - 4;
6266 else if (*codep == 0xcb)
6275 XCR_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6277 if (modrm.mod == 3 && modrm.reg == 2 && modrm.rm <= 1)
6279 /* Override "lgdt". */
6280 size_t olen = strlen (obuf);
6281 char *p = obuf + olen - 4;
6283 /* We might have a suffix when disassembling with -Msuffix. */
6287 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6289 && (prefixes & PREFIX_ADDR)
6292 && CONST_STRNEQ (p - 7, "addr")
6293 && (CONST_STRNEQ (p - 3, "16")
6294 || CONST_STRNEQ (p - 3, "32")))
6299 strcpy (p, "xsetbv");
6303 strcpy (p, "xgetbv");
6312 SVME_Fixup (int bytemode, int sizeflag)
6344 OP_M (bytemode, sizeflag);
6347 /* Override "lidt". */
6348 p = obuf + strlen (obuf) - 4;
6349 /* We might have a suffix. */
6353 if (!(prefixes & PREFIX_ADDR))
6358 used_prefixes |= PREFIX_ADDR;
6362 strcpy (op_out[1], names32[1]);
6368 *obufp++ = open_char;
6369 if (address_mode == mode_64bit || (sizeflag & AFLAG))
6373 strcpy (obufp, alt);
6374 obufp += strlen (alt);
6375 *obufp++ = close_char;
6382 INVLPG_Fixup (int bytemode, int sizeflag)
6395 OP_M (bytemode, sizeflag);
6398 /* Override "invlpg". */
6399 strcpy (obuf + strlen (obuf) - 6, alt);
6406 /* Throw away prefixes and 1st. opcode byte. */
6407 codep = insn_codep + 1;
6412 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6419 /* Override "sgdt". */
6420 char *p = obuf + strlen (obuf) - 4;
6422 /* We might have a suffix when disassembling with -Msuffix. */
6429 strcpy (p, "vmcall");
6432 strcpy (p, "vmlaunch");
6435 strcpy (p, "vmresume");
6438 strcpy (p, "vmxoff");
6449 OP_VMX (int bytemode, int sizeflag)
6453 strcpy (obuf, "rdrand");
6454 OP_E (v_mode, sizeflag);
6458 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
6459 if (prefixes & PREFIX_DATA)
6460 strcpy (obuf, "vmclear");
6461 else if (prefixes & PREFIX_REPZ)
6462 strcpy (obuf, "vmxon");
6464 strcpy (obuf, "vmptrld");
6465 OP_E (bytemode, sizeflag);
6470 REP_Fixup (int bytemode, int sizeflag)
6472 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
6476 if (prefixes & PREFIX_REPZ)
6477 switch (*insn_codep)
6479 case 0x6e: /* outsb */
6480 case 0x6f: /* outsw/outsl */
6481 case 0xa4: /* movsb */
6482 case 0xa5: /* movsw/movsl/movsq */
6488 case 0xaa: /* stosb */
6489 case 0xab: /* stosw/stosl/stosq */
6490 case 0xac: /* lodsb */
6491 case 0xad: /* lodsw/lodsl/lodsq */
6492 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
6497 case 0x6c: /* insb */
6498 case 0x6d: /* insl/insw */
6514 olen = strlen (obuf);
6515 p = obuf + olen - ilen - 1 - 4;
6516 /* Handle "repz [addr16|addr32]". */
6517 if ((prefixes & PREFIX_ADDR))
6520 memmove (p + 3, p + 4, olen - (p + 3 - obuf));
6528 OP_IMREG (bytemode, sizeflag);
6531 OP_ESreg (bytemode, sizeflag);
6534 OP_DSreg (bytemode, sizeflag);
6543 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
6548 /* Change cmpxchg8b to cmpxchg16b. */
6549 char *p = obuf + strlen (obuf) - 2;
6553 OP_M (bytemode, sizeflag);
6557 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
6559 sprintf (scratchbuf, "%%xmm%d", reg);
6560 oappend (scratchbuf + intel_syntax);
6564 CRC32_Fixup (int bytemode, int sizeflag)
6566 /* Add proper suffix to "crc32". */
6567 char *p = obuf + strlen (obuf);
6584 else if (sizeflag & DFLAG)
6588 used_prefixes |= (prefixes & PREFIX_DATA);
6591 oappend (INTERNAL_DISASSEMBLER_ERROR);
6600 /* Skip mod/rm byte. */
6605 add = (rex & REX_B) ? 8 : 0;
6606 if (bytemode == b_mode)
6610 oappend (names8rex[modrm.rm + add]);
6612 oappend (names8[modrm.rm + add]);
6618 oappend (names64[modrm.rm + add]);
6619 else if ((prefixes & PREFIX_DATA))
6620 oappend (names16[modrm.rm + add]);
6622 oappend (names32[modrm.rm + add]);
6626 OP_E (bytemode, sizeflag);