?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
target-mips: rename helpers from do_ to helper_
[qemu/mini2440/sniper_sniper_test.git] / i386-dis.c
blob87c8b9dffc73768da49f69c48a919c34d10ed824
1 /* opcodes/i386-dis.c r1.126 */
2 /* Print i386 instructions for GDB, the GNU debugger.
3 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
4 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
21
22 /* 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
23 July 1988
24 modified by John Hassey (hassey@dg-rtp.dg.com)
25 x86-64 support added by Jan Hubicka (jh@suse.cz)
26 VIA PadLock support by Michal Ludvig (mludvig@suse.cz). */
27
28 /* The main tables describing the instructions is essentially a copy
29 of the "Opcode Map" chapter (Appendix A) of the Intel 80386
30 Programmers Manual. Usually, there is a capital letter, followed
31 by a small letter. The capital letter tell the addressing mode,
32 and the small letter tells about the operand size. Refer to
33 the Intel manual for details. */
34
35 #include <stdlib.h>
36 #include "dis-asm.h"
37 /* include/opcode/i386.h r1.78 */
38
39 /* opcode/i386.h -- Intel 80386 opcode macros
40 Copyright 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
41 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
42 Free Software Foundation, Inc.
43
44 This file is part of GAS, the GNU Assembler, and GDB, the GNU Debugger.
45
46 This program is free software; you can redistribute it and/or modify
47 it under the terms of the GNU General Public License as published by
48 the Free Software Foundation; either version 2 of the License, or
49 (at your option) any later version.
50
51 This program is distributed in the hope that it will be useful,
52 but WITHOUT ANY WARRANTY; without even the implied warranty of
53 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
54 GNU General Public License for more details.
55
56 You should have received a copy of the GNU General Public License
57 along with this program; if not, write to the Free Software
58 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
59
60 /* The SystemV/386 SVR3.2 assembler, and probably all AT&T derived
61 ix86 Unix assemblers, generate floating point instructions with
62 reversed source and destination registers in certain cases.
63 Unfortunately, gcc and possibly many other programs use this
64 reversed syntax, so we're stuck with it.
65
66 eg. `fsub %st(3),%st' results in st = st - st(3) as expected, but
67 `fsub %st,%st(3)' results in st(3) = st - st(3), rather than
68 the expected st(3) = st(3) - st
69
70 This happens with all the non-commutative arithmetic floating point
71 operations with two register operands, where the source register is
72 %st, and destination register is %st(i).
73
74 The affected opcode map is dceX, dcfX, deeX, defX. */
75
76 #ifndef SYSV386_COMPAT
77 /* Set non-zero for broken, compatible instructions. Set to zero for
78 non-broken opcodes at your peril. gcc generates SystemV/386
79 compatible instructions. */
80 #define SYSV386_COMPAT 1
81 #endif
82 #ifndef OLDGCC_COMPAT
83 /* Set non-zero to cater for old (<= 2.8.1) versions of gcc that could
84 generate nonsense fsubp, fsubrp, fdivp and fdivrp with operands
85 reversed. */
86 #define OLDGCC_COMPAT SYSV386_COMPAT
87 #endif
88
89 #define MOV_AX_DISP32 0xa0
90 #define POP_SEG_SHORT 0x07
91 #define JUMP_PC_RELATIVE 0xeb
92 #define INT_OPCODE 0xcd
93 #define INT3_OPCODE 0xcc
94 /* The opcode for the fwait instruction, which disassembler treats as a
95 prefix when it can. */
96 #define FWAIT_OPCODE 0x9b
97 #define ADDR_PREFIX_OPCODE 0x67
98 #define DATA_PREFIX_OPCODE 0x66
99 #define LOCK_PREFIX_OPCODE 0xf0
100 #define CS_PREFIX_OPCODE 0x2e
101 #define DS_PREFIX_OPCODE 0x3e
102 #define ES_PREFIX_OPCODE 0x26
103 #define FS_PREFIX_OPCODE 0x64
104 #define GS_PREFIX_OPCODE 0x65
105 #define SS_PREFIX_OPCODE 0x36
106 #define REPNE_PREFIX_OPCODE 0xf2
107 #define REPE_PREFIX_OPCODE 0xf3
108
109 #define TWO_BYTE_OPCODE_ESCAPE 0x0f
110 #define NOP_OPCODE (char) 0x90
111
112 /* register numbers */
113 #define EBP_REG_NUM 5
114 #define ESP_REG_NUM 4
115
116 /* modrm_byte.regmem for twobyte escape */
117 #define ESCAPE_TO_TWO_BYTE_ADDRESSING ESP_REG_NUM
118 /* index_base_byte.index for no index register addressing */
119 #define NO_INDEX_REGISTER ESP_REG_NUM
120 /* index_base_byte.base for no base register addressing */
121 #define NO_BASE_REGISTER EBP_REG_NUM
122 #define NO_BASE_REGISTER_16 6
123
124 /* modrm.mode = REGMEM_FIELD_HAS_REG when a register is in there */
125 #define REGMEM_FIELD_HAS_REG 0x3/* always = 0x3 */
126 #define REGMEM_FIELD_HAS_MEM (~REGMEM_FIELD_HAS_REG)
127
128 /* x86-64 extension prefix. */
129 #define REX_OPCODE 0x40
130
131 /* Indicates 64 bit operand size. */
132 #define REX_W 8
133 /* High extension to reg field of modrm byte. */
134 #define REX_R 4
135 /* High extension to SIB index field. */
136 #define REX_X 2
137 /* High extension to base field of modrm or SIB, or reg field of opcode. */
138 #define REX_B 1
139
140 /* max operands per insn */
141 #define MAX_OPERANDS 4
142
143 /* max immediates per insn (lcall, ljmp, insertq, extrq) */
144 #define MAX_IMMEDIATE_OPERANDS 2
145
146 /* max memory refs per insn (string ops) */
147 #define MAX_MEMORY_OPERANDS 2
148
149 /* max size of insn mnemonics. */
150 #define MAX_MNEM_SIZE 16
151
152 /* max size of register name in insn mnemonics. */
153 #define MAX_REG_NAME_SIZE 8
154
155 /* opcodes/i386-dis.c r1.126 */
156 #include "qemu-common.h"
157
158 #include <setjmp.h>
159
160 static int fetch_data (struct disassemble_info *, bfd_byte *);
161 static void ckprefix (void);
162 static const char *prefix_name (int, int);
163 static int print_insn (bfd_vma, disassemble_info *);
164 static void dofloat (int);
165 static void OP_ST (int, int);
166 static void OP_STi (int, int);
167 static int putop (const char *, int);
168 static void oappend (const char *);
169 static void append_seg (void);
170 static void OP_indirE (int, int);
171 static void print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp);
172 static void print_displacement (char *, bfd_vma);
173 static void OP_E (int, int);
174 static void OP_G (int, int);
175 static bfd_vma get64 (void);
176 static bfd_signed_vma get32 (void);
177 static bfd_signed_vma get32s (void);
178 static int get16 (void);
179 static void set_op (bfd_vma, int);
180 static void OP_REG (int, int);
181 static void OP_IMREG (int, int);
182 static void OP_I (int, int);
183 static void OP_I64 (int, int);
184 static void OP_sI (int, int);
185 static void OP_J (int, int);
186 static void OP_SEG (int, int);
187 static void OP_DIR (int, int);
188 static void OP_OFF (int, int);
189 static void OP_OFF64 (int, int);
190 static void ptr_reg (int, int);
191 static void OP_ESreg (int, int);
192 static void OP_DSreg (int, int);
193 static void OP_C (int, int);
194 static void OP_D (int, int);
195 static void OP_T (int, int);
196 static void OP_R (int, int);
197 static void OP_MMX (int, int);
198 static void OP_XMM (int, int);
199 static void OP_EM (int, int);
200 static void OP_EX (int, int);
201 static void OP_EMC (int,int);
202 static void OP_MXC (int,int);
203 static void OP_MS (int, int);
204 static void OP_XS (int, int);
205 static void OP_M (int, int);
206 static void OP_VMX (int, int);
207 static void OP_0fae (int, int);
208 static void OP_0f07 (int, int);
209 static void NOP_Fixup1 (int, int);
210 static void NOP_Fixup2 (int, int);
211 static void OP_3DNowSuffix (int, int);
212 static void OP_SIMD_Suffix (int, int);
213 static void SIMD_Fixup (int, int);
214 static void PNI_Fixup (int, int);
215 static void SVME_Fixup (int, int);
216 static void INVLPG_Fixup (int, int);
217 static void BadOp (void);
218 static void VMX_Fixup (int, int);
219 static void REP_Fixup (int, int);
220 static void CMPXCHG8B_Fixup (int, int);
221 static void XMM_Fixup (int, int);
222 static void CRC32_Fixup (int, int);
223
224 struct dis_private {
225 /* Points to first byte not fetched. */
226 bfd_byte *max_fetched;
227 bfd_byte the_buffer[MAX_MNEM_SIZE];
228 bfd_vma insn_start;
229 int orig_sizeflag;
230 jmp_buf bailout;
231 };
232
233 enum address_mode
234 {
235 mode_16bit,
236 mode_32bit,
237 mode_64bit
238 };
239
240 static enum address_mode address_mode;
241
242 /* Flags for the prefixes for the current instruction. See below. */
243 static int prefixes;
244
245 /* REX prefix the current instruction. See below. */
246 static int rex;
247 /* Bits of REX we've already used. */
248 static int rex_used;
249 /* Mark parts used in the REX prefix. When we are testing for
250 empty prefix (for 8bit register REX extension), just mask it
251 out. Otherwise test for REX bit is excuse for existence of REX
252 only in case value is nonzero. */
253 #define USED_REX(value) \
254 { \
255 if (value) \
256 { \
257 if ((rex & value)) \
258 rex_used |= (value) | REX_OPCODE; \
259 } \
260 else \
261 rex_used |= REX_OPCODE; \
262 }
263
264 /* Flags for prefixes which we somehow handled when printing the
265 current instruction. */
266 static int used_prefixes;
267
268 /* Flags stored in PREFIXES. */
269 #define PREFIX_REPZ 1
270 #define PREFIX_REPNZ 2
271 #define PREFIX_LOCK 4
272 #define PREFIX_CS 8
273 #define PREFIX_SS 0x10
274 #define PREFIX_DS 0x20
275 #define PREFIX_ES 0x40
276 #define PREFIX_FS 0x80
277 #define PREFIX_GS 0x100
278 #define PREFIX_DATA 0x200
279 #define PREFIX_ADDR 0x400
280 #define PREFIX_FWAIT 0x800
281
282 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
283 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
284 on error. */
285 #define FETCH_DATA(info, addr) \
286 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
287 ? 1 : fetch_data ((info), (addr)))
288
289 static int
290 fetch_data (struct disassemble_info *info, bfd_byte *addr)
291 {
292 int status;
293 struct dis_private *priv = (struct dis_private *) info->private_data;
294 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
295
296 if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
297 status = (*info->read_memory_func) (start,
298 priv->max_fetched,
299 addr - priv->max_fetched,
300 info);
301 else
302 status = -1;
303 if (status != 0)
304 {
305 /* If we did manage to read at least one byte, then
306 print_insn_i386 will do something sensible. Otherwise, print
307 an error. We do that here because this is where we know
308 STATUS. */
309 if (priv->max_fetched == priv->the_buffer)
310 (*info->memory_error_func) (status, start, info);
311 longjmp (priv->bailout, 1);
312 }
313 else
314 priv->max_fetched = addr;
315 return 1;
316 }
317
318 #define XX { NULL, 0 }
319
320 #define Eb { OP_E, b_mode }
321 #define Ev { OP_E, v_mode }
322 #define Ed { OP_E, d_mode }
323 #define Edq { OP_E, dq_mode }
324 #define Edqw { OP_E, dqw_mode }
325 #define Edqb { OP_E, dqb_mode }
326 #define Edqd { OP_E, dqd_mode }
327 #define indirEv { OP_indirE, stack_v_mode }
328 #define indirEp { OP_indirE, f_mode }
329 #define stackEv { OP_E, stack_v_mode }
330 #define Em { OP_E, m_mode }
331 #define Ew { OP_E, w_mode }
332 #define M { OP_M, 0 } /* lea, lgdt, etc. */
333 #define Ma { OP_M, v_mode }
334 #define Mp { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
335 #define Mq { OP_M, q_mode }
336 #define Gb { OP_G, b_mode }
337 #define Gv { OP_G, v_mode }
338 #define Gd { OP_G, d_mode }
339 #define Gdq { OP_G, dq_mode }
340 #define Gm { OP_G, m_mode }
341 #define Gw { OP_G, w_mode }
342 #define Rd { OP_R, d_mode }
343 #define Rm { OP_R, m_mode }
344 #define Ib { OP_I, b_mode }
345 #define sIb { OP_sI, b_mode } /* sign extened byte */
346 #define Iv { OP_I, v_mode }
347 #define Iq { OP_I, q_mode }
348 #define Iv64 { OP_I64, v_mode }
349 #define Iw { OP_I, w_mode }
350 #define I1 { OP_I, const_1_mode }
351 #define Jb { OP_J, b_mode }
352 #define Jv { OP_J, v_mode }
353 #define Cm { OP_C, m_mode }
354 #define Dm { OP_D, m_mode }
355 #define Td { OP_T, d_mode }
356
357 #define RMeAX { OP_REG, eAX_reg }
358 #define RMeBX { OP_REG, eBX_reg }
359 #define RMeCX { OP_REG, eCX_reg }
360 #define RMeDX { OP_REG, eDX_reg }
361 #define RMeSP { OP_REG, eSP_reg }
362 #define RMeBP { OP_REG, eBP_reg }
363 #define RMeSI { OP_REG, eSI_reg }
364 #define RMeDI { OP_REG, eDI_reg }
365 #define RMrAX { OP_REG, rAX_reg }
366 #define RMrBX { OP_REG, rBX_reg }
367 #define RMrCX { OP_REG, rCX_reg }
368 #define RMrDX { OP_REG, rDX_reg }
369 #define RMrSP { OP_REG, rSP_reg }
370 #define RMrBP { OP_REG, rBP_reg }
371 #define RMrSI { OP_REG, rSI_reg }
372 #define RMrDI { OP_REG, rDI_reg }
373 #define RMAL { OP_REG, al_reg }
374 #define RMAL { OP_REG, al_reg }
375 #define RMCL { OP_REG, cl_reg }
376 #define RMDL { OP_REG, dl_reg }
377 #define RMBL { OP_REG, bl_reg }
378 #define RMAH { OP_REG, ah_reg }
379 #define RMCH { OP_REG, ch_reg }
380 #define RMDH { OP_REG, dh_reg }
381 #define RMBH { OP_REG, bh_reg }
382 #define RMAX { OP_REG, ax_reg }
383 #define RMDX { OP_REG, dx_reg }
384
385 #define eAX { OP_IMREG, eAX_reg }
386 #define eBX { OP_IMREG, eBX_reg }
387 #define eCX { OP_IMREG, eCX_reg }
388 #define eDX { OP_IMREG, eDX_reg }
389 #define eSP { OP_IMREG, eSP_reg }
390 #define eBP { OP_IMREG, eBP_reg }
391 #define eSI { OP_IMREG, eSI_reg }
392 #define eDI { OP_IMREG, eDI_reg }
393 #define AL { OP_IMREG, al_reg }
394 #define CL { OP_IMREG, cl_reg }
395 #define DL { OP_IMREG, dl_reg }
396 #define BL { OP_IMREG, bl_reg }
397 #define AH { OP_IMREG, ah_reg }
398 #define CH { OP_IMREG, ch_reg }
399 #define DH { OP_IMREG, dh_reg }
400 #define BH { OP_IMREG, bh_reg }
401 #define AX { OP_IMREG, ax_reg }
402 #define DX { OP_IMREG, dx_reg }
403 #define zAX { OP_IMREG, z_mode_ax_reg }
404 #define indirDX { OP_IMREG, indir_dx_reg }
405
406 #define Sw { OP_SEG, w_mode }
407 #define Sv { OP_SEG, v_mode }
408 #define Ap { OP_DIR, 0 }
409 #define Ob { OP_OFF64, b_mode }
410 #define Ov { OP_OFF64, v_mode }
411 #define Xb { OP_DSreg, eSI_reg }
412 #define Xv { OP_DSreg, eSI_reg }
413 #define Xz { OP_DSreg, eSI_reg }
414 #define Yb { OP_ESreg, eDI_reg }
415 #define Yv { OP_ESreg, eDI_reg }
416 #define DSBX { OP_DSreg, eBX_reg }
417
418 #define es { OP_REG, es_reg }
419 #define ss { OP_REG, ss_reg }
420 #define cs { OP_REG, cs_reg }
421 #define ds { OP_REG, ds_reg }
422 #define fs { OP_REG, fs_reg }
423 #define gs { OP_REG, gs_reg }
424
425 #define MX { OP_MMX, 0 }
426 #define XM { OP_XMM, 0 }
427 #define EM { OP_EM, v_mode }
428 #define EMd { OP_EM, d_mode }
429 #define EMq { OP_EM, q_mode }
430 #define EXd { OP_EX, d_mode }
431 #define EXq { OP_EX, q_mode }
432 #define EXx { OP_EX, x_mode }
433 #define MS { OP_MS, v_mode }
434 #define XS { OP_XS, v_mode }
435 #define EMC { OP_EMC, v_mode }
436 #define MXC { OP_MXC, 0 }
437 #define VM { OP_VMX, q_mode }
438 #define OPSUF { OP_3DNowSuffix, 0 }
439 #define OPSIMD { OP_SIMD_Suffix, 0 }
440 #define XMM0 { XMM_Fixup, 0 }
441
442 /* Used handle "rep" prefix for string instructions. */
443 #define Xbr { REP_Fixup, eSI_reg }
444 #define Xvr { REP_Fixup, eSI_reg }
445 #define Ybr { REP_Fixup, eDI_reg }
446 #define Yvr { REP_Fixup, eDI_reg }
447 #define Yzr { REP_Fixup, eDI_reg }
448 #define indirDXr { REP_Fixup, indir_dx_reg }
449 #define ALr { REP_Fixup, al_reg }
450 #define eAXr { REP_Fixup, eAX_reg }
451
452 #define cond_jump_flag { NULL, cond_jump_mode }
453 #define loop_jcxz_flag { NULL, loop_jcxz_mode }
454
455 /* bits in sizeflag */
456 #define SUFFIX_ALWAYS 4
457 #define AFLAG 2
458 #define DFLAG 1
459
460 #define b_mode 1 /* byte operand */
461 #define v_mode 2 /* operand size depends on prefixes */
462 #define w_mode 3 /* word operand */
463 #define d_mode 4 /* double word operand */
464 #define q_mode 5 /* quad word operand */
465 #define t_mode 6 /* ten-byte operand */
466 #define x_mode 7 /* 16-byte XMM operand */
467 #define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */
468 #define cond_jump_mode 9
469 #define loop_jcxz_mode 10
470 #define dq_mode 11 /* operand size depends on REX prefixes. */
471 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */
472 #define f_mode 13 /* 4- or 6-byte pointer operand */
473 #define const_1_mode 14
474 #define stack_v_mode 15 /* v_mode for stack-related opcodes. */
475 #define z_mode 16 /* non-quad operand size depends on prefixes */
476 #define o_mode 17 /* 16-byte operand */
477 #define dqb_mode 18 /* registers like dq_mode, memory like b_mode. */
478 #define dqd_mode 19 /* registers like dq_mode, memory like d_mode. */
479
480 #define es_reg 100
481 #define cs_reg 101
482 #define ss_reg 102
483 #define ds_reg 103
484 #define fs_reg 104
485 #define gs_reg 105
486
487 #define eAX_reg 108
488 #define eCX_reg 109
489 #define eDX_reg 110
490 #define eBX_reg 111
491 #define eSP_reg 112
492 #define eBP_reg 113
493 #define eSI_reg 114
494 #define eDI_reg 115
495
496 #define al_reg 116
497 #define cl_reg 117
498 #define dl_reg 118
499 #define bl_reg 119
500 #define ah_reg 120
501 #define ch_reg 121
502 #define dh_reg 122
503 #define bh_reg 123
504
505 #define ax_reg 124
506 #define cx_reg 125
507 #define dx_reg 126
508 #define bx_reg 127
509 #define sp_reg 128
510 #define bp_reg 129
511 #define si_reg 130
512 #define di_reg 131
513
514 #define rAX_reg 132
515 #define rCX_reg 133
516 #define rDX_reg 134
517 #define rBX_reg 135
518 #define rSP_reg 136
519 #define rBP_reg 137
520 #define rSI_reg 138
521 #define rDI_reg 139
522
523 #define z_mode_ax_reg 149
524 #define indir_dx_reg 150
525
526 #define FLOATCODE 1
527 #define USE_GROUPS 2
528 #define USE_PREFIX_USER_TABLE 3
529 #define X86_64_SPECIAL 4
530 #define IS_3BYTE_OPCODE 5
531
532 #define FLOAT NULL, { { NULL, FLOATCODE } }
533
534 #define GRP1a NULL, { { NULL, USE_GROUPS }, { NULL, 0 } }
535 #define GRP1b NULL, { { NULL, USE_GROUPS }, { NULL, 1 } }
536 #define GRP1S NULL, { { NULL, USE_GROUPS }, { NULL, 2 } }
537 #define GRP1Ss NULL, { { NULL, USE_GROUPS }, { NULL, 3 } }
538 #define GRP2b NULL, { { NULL, USE_GROUPS }, { NULL, 4 } }
539 #define GRP2S NULL, { { NULL, USE_GROUPS }, { NULL, 5 } }
540 #define GRP2b_one NULL, { { NULL, USE_GROUPS }, { NULL, 6 } }
541 #define GRP2S_one NULL, { { NULL, USE_GROUPS }, { NULL, 7 } }
542 #define GRP2b_cl NULL, { { NULL, USE_GROUPS }, { NULL, 8 } }
543 #define GRP2S_cl NULL, { { NULL, USE_GROUPS }, { NULL, 9 } }
544 #define GRP3b NULL, { { NULL, USE_GROUPS }, { NULL, 10 } }
545 #define GRP3S NULL, { { NULL, USE_GROUPS }, { NULL, 11 } }
546 #define GRP4 NULL, { { NULL, USE_GROUPS }, { NULL, 12 } }
547 #define GRP5 NULL, { { NULL, USE_GROUPS }, { NULL, 13 } }
548 #define GRP6 NULL, { { NULL, USE_GROUPS }, { NULL, 14 } }
549 #define GRP7 NULL, { { NULL, USE_GROUPS }, { NULL, 15 } }
550 #define GRP8 NULL, { { NULL, USE_GROUPS }, { NULL, 16 } }
551 #define GRP9 NULL, { { NULL, USE_GROUPS }, { NULL, 17 } }
552 #define GRP11_C6 NULL, { { NULL, USE_GROUPS }, { NULL, 18 } }
553 #define GRP11_C7 NULL, { { NULL, USE_GROUPS }, { NULL, 19 } }
554 #define GRP12 NULL, { { NULL, USE_GROUPS }, { NULL, 20 } }
555 #define GRP13 NULL, { { NULL, USE_GROUPS }, { NULL, 21 } }
556 #define GRP14 NULL, { { NULL, USE_GROUPS }, { NULL, 22 } }
557 #define GRP15 NULL, { { NULL, USE_GROUPS }, { NULL, 23 } }
558 #define GRP16 NULL, { { NULL, USE_GROUPS }, { NULL, 24 } }
559 #define GRPAMD NULL, { { NULL, USE_GROUPS }, { NULL, 25 } }
560 #define GRPPADLCK1 NULL, { { NULL, USE_GROUPS }, { NULL, 26 } }
561 #define GRPPADLCK2 NULL, { { NULL, USE_GROUPS }, { NULL, 27 } }
562
563 #define PREGRP0 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } }
564 #define PREGRP1 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } }
565 #define PREGRP2 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } }
566 #define PREGRP3 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } }
567 #define PREGRP4 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } }
568 #define PREGRP5 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } }
569 #define PREGRP6 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } }
570 #define PREGRP7 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } }
571 #define PREGRP8 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } }
572 #define PREGRP9 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } }
573 #define PREGRP10 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } }
574 #define PREGRP11 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } }
575 #define PREGRP12 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } }
576 #define PREGRP13 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } }
577 #define PREGRP14 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } }
578 #define PREGRP15 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } }
579 #define PREGRP16 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } }
580 #define PREGRP17 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } }
581 #define PREGRP18 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } }
582 #define PREGRP19 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } }
583 #define PREGRP20 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } }
584 #define PREGRP21 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } }
585 #define PREGRP22 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } }
586 #define PREGRP23 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } }
587 #define PREGRP24 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } }
588 #define PREGRP25 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } }
589 #define PREGRP26 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } }
590 #define PREGRP27 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } }
591 #define PREGRP28 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } }
592 #define PREGRP29 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } }
593 #define PREGRP30 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } }
594 #define PREGRP31 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } }
595 #define PREGRP32 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } }
596 #define PREGRP33 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } }
597 #define PREGRP34 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } }
598 #define PREGRP35 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } }
599 #define PREGRP36 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } }
600 #define PREGRP37 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } }
601 #define PREGRP38 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } }
602 #define PREGRP39 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 39 } }
603 #define PREGRP40 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 40 } }
604 #define PREGRP41 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 41 } }
605 #define PREGRP42 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 42 } }
606 #define PREGRP43 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 43 } }
607 #define PREGRP44 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 44 } }
608 #define PREGRP45 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 45 } }
609 #define PREGRP46 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 46 } }
610 #define PREGRP47 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 47 } }
611 #define PREGRP48 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 48 } }
612 #define PREGRP49 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 49 } }
613 #define PREGRP50 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 50 } }
614 #define PREGRP51 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 51 } }
615 #define PREGRP52 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 52 } }
616 #define PREGRP53 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 53 } }
617 #define PREGRP54 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 54 } }
618 #define PREGRP55 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 55 } }
619 #define PREGRP56 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 56 } }
620 #define PREGRP57 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 57 } }
621 #define PREGRP58 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 58 } }
622 #define PREGRP59 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 59 } }
623 #define PREGRP60 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 60 } }
624 #define PREGRP61 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 61 } }
625 #define PREGRP62 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 62 } }
626 #define PREGRP63 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 63 } }
627 #define PREGRP64 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 64 } }
628 #define PREGRP65 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 65 } }
629 #define PREGRP66 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 66 } }
630 #define PREGRP67 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 67 } }
631 #define PREGRP68 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 68 } }
632 #define PREGRP69 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 69 } }
633 #define PREGRP70 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 70 } }
634 #define PREGRP71 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 71 } }
635 #define PREGRP72 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 72 } }
636 #define PREGRP73 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 73 } }
637 #define PREGRP74 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 74 } }
638 #define PREGRP75 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 75 } }
639 #define PREGRP76 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 76 } }
640 #define PREGRP77 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 77 } }
641 #define PREGRP78 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 78 } }
642 #define PREGRP79 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 79 } }
643 #define PREGRP80 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 80 } }
644 #define PREGRP81 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 81 } }
645 #define PREGRP82 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 82 } }
646 #define PREGRP83 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 83 } }
647 #define PREGRP84 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 84 } }
648 #define PREGRP85 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 85 } }
649 #define PREGRP86 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 86 } }
650 #define PREGRP87 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 87 } }
651 #define PREGRP88 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 88 } }
652 #define PREGRP89 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 89 } }
653 #define PREGRP90 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 90 } }
654 #define PREGRP91 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 91 } }
655 #define PREGRP92 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 92 } }
656 #define PREGRP93 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 93 } }
657 #define PREGRP94 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 94 } }
658 #define PREGRP95 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 95 } }
659 #define PREGRP96 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 96 } }
660 #define PREGRP97 NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 97 } }
661
662
663 #define X86_64_0 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }
664 #define X86_64_1 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }
665 #define X86_64_2 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }
666 #define X86_64_3 NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }
667
668 #define THREE_BYTE_0 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }
669 #define THREE_BYTE_1 NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }
670
671 typedef void (*op_rtn) (int bytemode, int sizeflag);
672
673 struct dis386 {
674 const char *name;
675 struct
676 {
677 op_rtn rtn;
678 int bytemode;
679 } op[MAX_OPERANDS];
680 };
681
682 /* Upper case letters in the instruction names here are macros.
683 'A' => print 'b' if no register operands or suffix_always is true
684 'B' => print 'b' if suffix_always is true
685 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
686 . size prefix
687 'D' => print 'w' if no register operands or 'w', 'l' or 'q', if
688 . suffix_always is true
689 'E' => print 'e' if 32-bit form of jcxz
690 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
691 'G' => print 'w' or 'l' depending on operand size prefix (i/o insns)
692 'H' => print ",pt" or ",pn" branch hint
693 'I' => honor following macro letter even in Intel mode (implemented only
694 . for some of the macro letters)
695 'J' => print 'l'
696 'K' => print 'd' or 'q' if rex prefix is present.
697 'L' => print 'l' if suffix_always is true
698 'N' => print 'n' if instruction has no wait "prefix"
699 'O' => print 'd' or 'o' (or 'q' in Intel mode)
700 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
701 . or suffix_always is true. print 'q' if rex prefix is present.
702 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
703 . is true
704 'R' => print 'w', 'l' or 'q' ('d' for 'l' and 'e' in Intel mode)
705 'S' => print 'w', 'l' or 'q' if suffix_always is true
706 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
707 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
708 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
709 'W' => print 'b', 'w' or 'l' ('d' in Intel mode)
710 'X' => print 's', 'd' depending on data16 prefix (for XMM)
711 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
712 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
713
714 Many of the above letters print nothing in Intel mode. See "putop"
715 for the details.
716
717 Braces '{' and '}', and vertical bars '|', indicate alternative
718 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
719 modes. In cases where there are only two alternatives, the X86_64
720 instruction is reserved, and "(bad)" is printed.
721 */
722
723 static const struct dis386 dis386[] = {
724 /* 00 */
725 { "addB", { Eb, Gb } },
726 { "addS", { Ev, Gv } },
727 { "addB", { Gb, Eb } },
728 { "addS", { Gv, Ev } },
729 { "addB", { AL, Ib } },
730 { "addS", { eAX, Iv } },
731 { "push{T|}", { es } },
732 { "pop{T|}", { es } },
733 /* 08 */
734 { "orB", { Eb, Gb } },
735 { "orS", { Ev, Gv } },
736 { "orB", { Gb, Eb } },
737 { "orS", { Gv, Ev } },
738 { "orB", { AL, Ib } },
739 { "orS", { eAX, Iv } },
740 { "push{T|}", { cs } },
741 { "(bad)", { XX } }, /* 0x0f extended opcode escape */
742 /* 10 */
743 { "adcB", { Eb, Gb } },
744 { "adcS", { Ev, Gv } },
745 { "adcB", { Gb, Eb } },
746 { "adcS", { Gv, Ev } },
747 { "adcB", { AL, Ib } },
748 { "adcS", { eAX, Iv } },
749 { "push{T|}", { ss } },
750 { "pop{T|}", { ss } },
751 /* 18 */
752 { "sbbB", { Eb, Gb } },
753 { "sbbS", { Ev, Gv } },
754 { "sbbB", { Gb, Eb } },
755 { "sbbS", { Gv, Ev } },
756 { "sbbB", { AL, Ib } },
757 { "sbbS", { eAX, Iv } },
758 { "push{T|}", { ds } },
759 { "pop{T|}", { ds } },
760 /* 20 */
761 { "andB", { Eb, Gb } },
762 { "andS", { Ev, Gv } },
763 { "andB", { Gb, Eb } },
764 { "andS", { Gv, Ev } },
765 { "andB", { AL, Ib } },
766 { "andS", { eAX, Iv } },
767 { "(bad)", { XX } }, /* SEG ES prefix */
768 { "daa{|}", { XX } },
769 /* 28 */
770 { "subB", { Eb, Gb } },
771 { "subS", { Ev, Gv } },
772 { "subB", { Gb, Eb } },
773 { "subS", { Gv, Ev } },
774 { "subB", { AL, Ib } },
775 { "subS", { eAX, Iv } },
776 { "(bad)", { XX } }, /* SEG CS prefix */
777 { "das{|}", { XX } },
778 /* 30 */
779 { "xorB", { Eb, Gb } },
780 { "xorS", { Ev, Gv } },
781 { "xorB", { Gb, Eb } },
782 { "xorS", { Gv, Ev } },
783 { "xorB", { AL, Ib } },
784 { "xorS", { eAX, Iv } },
785 { "(bad)", { XX } }, /* SEG SS prefix */
786 { "aaa{|}", { XX } },
787 /* 38 */
788 { "cmpB", { Eb, Gb } },
789 { "cmpS", { Ev, Gv } },
790 { "cmpB", { Gb, Eb } },
791 { "cmpS", { Gv, Ev } },
792 { "cmpB", { AL, Ib } },
793 { "cmpS", { eAX, Iv } },
794 { "(bad)", { XX } }, /* SEG DS prefix */
795 { "aas{|}", { XX } },
796 /* 40 */
797 { "inc{S|}", { RMeAX } },
798 { "inc{S|}", { RMeCX } },
799 { "inc{S|}", { RMeDX } },
800 { "inc{S|}", { RMeBX } },
801 { "inc{S|}", { RMeSP } },
802 { "inc{S|}", { RMeBP } },
803 { "inc{S|}", { RMeSI } },
804 { "inc{S|}", { RMeDI } },
805 /* 48 */
806 { "dec{S|}", { RMeAX } },
807 { "dec{S|}", { RMeCX } },
808 { "dec{S|}", { RMeDX } },
809 { "dec{S|}", { RMeBX } },
810 { "dec{S|}", { RMeSP } },
811 { "dec{S|}", { RMeBP } },
812 { "dec{S|}", { RMeSI } },
813 { "dec{S|}", { RMeDI } },
814 /* 50 */
815 { "pushV", { RMrAX } },
816 { "pushV", { RMrCX } },
817 { "pushV", { RMrDX } },
818 { "pushV", { RMrBX } },
819 { "pushV", { RMrSP } },
820 { "pushV", { RMrBP } },
821 { "pushV", { RMrSI } },
822 { "pushV", { RMrDI } },
823 /* 58 */
824 { "popV", { RMrAX } },
825 { "popV", { RMrCX } },
826 { "popV", { RMrDX } },
827 { "popV", { RMrBX } },
828 { "popV", { RMrSP } },
829 { "popV", { RMrBP } },
830 { "popV", { RMrSI } },
831 { "popV", { RMrDI } },
832 /* 60 */
833 { X86_64_0 },
834 { X86_64_1 },
835 { X86_64_2 },
836 { X86_64_3 },
837 { "(bad)", { XX } }, /* seg fs */
838 { "(bad)", { XX } }, /* seg gs */
839 { "(bad)", { XX } }, /* op size prefix */
840 { "(bad)", { XX } }, /* adr size prefix */
841 /* 68 */
842 { "pushT", { Iq } },
843 { "imulS", { Gv, Ev, Iv } },
844 { "pushT", { sIb } },
845 { "imulS", { Gv, Ev, sIb } },
846 { "ins{b||b|}", { Ybr, indirDX } },
847 { "ins{R||G|}", { Yzr, indirDX } },
848 { "outs{b||b|}", { indirDXr, Xb } },
849 { "outs{R||G|}", { indirDXr, Xz } },
850 /* 70 */
851 { "joH", { Jb, XX, cond_jump_flag } },
852 { "jnoH", { Jb, XX, cond_jump_flag } },
853 { "jbH", { Jb, XX, cond_jump_flag } },
854 { "jaeH", { Jb, XX, cond_jump_flag } },
855 { "jeH", { Jb, XX, cond_jump_flag } },
856 { "jneH", { Jb, XX, cond_jump_flag } },
857 { "jbeH", { Jb, XX, cond_jump_flag } },
858 { "jaH", { Jb, XX, cond_jump_flag } },
859 /* 78 */
860 { "jsH", { Jb, XX, cond_jump_flag } },
861 { "jnsH", { Jb, XX, cond_jump_flag } },
862 { "jpH", { Jb, XX, cond_jump_flag } },
863 { "jnpH", { Jb, XX, cond_jump_flag } },
864 { "jlH", { Jb, XX, cond_jump_flag } },
865 { "jgeH", { Jb, XX, cond_jump_flag } },
866 { "jleH", { Jb, XX, cond_jump_flag } },
867 { "jgH", { Jb, XX, cond_jump_flag } },
868 /* 80 */
869 { GRP1b },
870 { GRP1S },
871 { "(bad)", { XX } },
872 { GRP1Ss },
873 { "testB", { Eb, Gb } },
874 { "testS", { Ev, Gv } },
875 { "xchgB", { Eb, Gb } },
876 { "xchgS", { Ev, Gv } },
877 /* 88 */
878 { "movB", { Eb, Gb } },
879 { "movS", { Ev, Gv } },
880 { "movB", { Gb, Eb } },
881 { "movS", { Gv, Ev } },
882 { "movD", { Sv, Sw } },
883 { "leaS", { Gv, M } },
884 { "movD", { Sw, Sv } },
885 { GRP1a },
886 /* 90 */
887 { PREGRP38 },
888 { "xchgS", { RMeCX, eAX } },
889 { "xchgS", { RMeDX, eAX } },
890 { "xchgS", { RMeBX, eAX } },
891 { "xchgS", { RMeSP, eAX } },
892 { "xchgS", { RMeBP, eAX } },
893 { "xchgS", { RMeSI, eAX } },
894 { "xchgS", { RMeDI, eAX } },
895 /* 98 */
896 { "cW{t||t|}R", { XX } },
897 { "cR{t||t|}O", { XX } },
898 { "Jcall{T|}", { Ap } },
899 { "(bad)", { XX } }, /* fwait */
900 { "pushfT", { XX } },
901 { "popfT", { XX } },
902 { "sahf{|}", { XX } },
903 { "lahf{|}", { XX } },
904 /* a0 */
905 { "movB", { AL, Ob } },
906 { "movS", { eAX, Ov } },
907 { "movB", { Ob, AL } },
908 { "movS", { Ov, eAX } },
909 { "movs{b||b|}", { Ybr, Xb } },
910 { "movs{R||R|}", { Yvr, Xv } },
911 { "cmps{b||b|}", { Xb, Yb } },
912 { "cmps{R||R|}", { Xv, Yv } },
913 /* a8 */
914 { "testB", { AL, Ib } },
915 { "testS", { eAX, Iv } },
916 { "stosB", { Ybr, AL } },
917 { "stosS", { Yvr, eAX } },
918 { "lodsB", { ALr, Xb } },
919 { "lodsS", { eAXr, Xv } },
920 { "scasB", { AL, Yb } },
921 { "scasS", { eAX, Yv } },
922 /* b0 */
923 { "movB", { RMAL, Ib } },
924 { "movB", { RMCL, Ib } },
925 { "movB", { RMDL, Ib } },
926 { "movB", { RMBL, Ib } },
927 { "movB", { RMAH, Ib } },
928 { "movB", { RMCH, Ib } },
929 { "movB", { RMDH, Ib } },
930 { "movB", { RMBH, Ib } },
931 /* b8 */
932 { "movS", { RMeAX, Iv64 } },
933 { "movS", { RMeCX, Iv64 } },
934 { "movS", { RMeDX, Iv64 } },
935 { "movS", { RMeBX, Iv64 } },
936 { "movS", { RMeSP, Iv64 } },
937 { "movS", { RMeBP, Iv64 } },
938 { "movS", { RMeSI, Iv64 } },
939 { "movS", { RMeDI, Iv64 } },
940 /* c0 */
941 { GRP2b },
942 { GRP2S },
943 { "retT", { Iw } },
944 { "retT", { XX } },
945 { "les{S|}", { Gv, Mp } },
946 { "ldsS", { Gv, Mp } },
947 { GRP11_C6 },
948 { GRP11_C7 },
949 /* c8 */
950 { "enterT", { Iw, Ib } },
951 { "leaveT", { XX } },
952 { "lretP", { Iw } },
953 { "lretP", { XX } },
954 { "int3", { XX } },
955 { "int", { Ib } },
956 { "into{|}", { XX } },
957 { "iretP", { XX } },
958 /* d0 */
959 { GRP2b_one },
960 { GRP2S_one },
961 { GRP2b_cl },
962 { GRP2S_cl },
963 { "aam{|}", { sIb } },
964 { "aad{|}", { sIb } },
965 { "(bad)", { XX } },
966 { "xlat", { DSBX } },
967 /* d8 */
968 { FLOAT },
969 { FLOAT },
970 { FLOAT },
971 { FLOAT },
972 { FLOAT },
973 { FLOAT },
974 { FLOAT },
975 { FLOAT },
976 /* e0 */
977 { "loopneFH", { Jb, XX, loop_jcxz_flag } },
978 { "loopeFH", { Jb, XX, loop_jcxz_flag } },
979 { "loopFH", { Jb, XX, loop_jcxz_flag } },
980 { "jEcxzH", { Jb, XX, loop_jcxz_flag } },
981 { "inB", { AL, Ib } },
982 { "inG", { zAX, Ib } },
983 { "outB", { Ib, AL } },
984 { "outG", { Ib, zAX } },
985 /* e8 */
986 { "callT", { Jv } },
987 { "jmpT", { Jv } },
988 { "Jjmp{T|}", { Ap } },
989 { "jmp", { Jb } },
990 { "inB", { AL, indirDX } },
991 { "inG", { zAX, indirDX } },
992 { "outB", { indirDX, AL } },
993 { "outG", { indirDX, zAX } },
994 /* f0 */
995 { "(bad)", { XX } }, /* lock prefix */
996 { "icebp", { XX } },
997 { "(bad)", { XX } }, /* repne */
998 { "(bad)", { XX } }, /* repz */
999 { "hlt", { XX } },
1000 { "cmc", { XX } },
1001 { GRP3b },
1002 { GRP3S },
1003 /* f8 */
1004 { "clc", { XX } },
1005 { "stc", { XX } },
1006 { "cli", { XX } },
1007 { "sti", { XX } },
1008 { "cld", { XX } },
1009 { "std", { XX } },
1010 { GRP4 },
1011 { GRP5 },
1012 };
1013
1014 static const struct dis386 dis386_twobyte[] = {
1015 /* 00 */
1016 { GRP6 },
1017 { GRP7 },
1018 { "larS", { Gv, Ew } },
1019 { "lslS", { Gv, Ew } },
1020 { "(bad)", { XX } },
1021 { "syscall", { XX } },
1022 { "clts", { XX } },
1023 { "sysretP", { XX } },
1024 /* 08 */
1025 { "invd", { XX } },
1026 { "wbinvd", { XX } },
1027 { "(bad)", { XX } },
1028 { "ud2a", { XX } },
1029 { "(bad)", { XX } },
1030 { GRPAMD },
1031 { "femms", { XX } },
1032 { "", { MX, EM, OPSUF } }, /* See OP_3DNowSuffix. */
1033 /* 10 */
1034 { PREGRP8 },
1035 { PREGRP9 },
1036 { PREGRP30 },
1037 { "movlpX", { EXq, XM, { SIMD_Fixup, 'h' } } },
1038 { "unpcklpX", { XM, EXq } },
1039 { "unpckhpX", { XM, EXq } },
1040 { PREGRP31 },
1041 { "movhpX", { EXq, XM, { SIMD_Fixup, 'l' } } },
1042 /* 18 */
1043 { GRP16 },
1044 { "(bad)", { XX } },
1045 { "(bad)", { XX } },
1046 { "(bad)", { XX } },
1047 { "(bad)", { XX } },
1048 { "(bad)", { XX } },
1049 { "(bad)", { XX } },
1050 { "nopQ", { Ev } },
1051 /* 20 */
1052 { "movZ", { Rm, Cm } },
1053 { "movZ", { Rm, Dm } },
1054 { "movZ", { Cm, Rm } },
1055 { "movZ", { Dm, Rm } },
1056 { "movL", { Rd, Td } },
1057 { "(bad)", { XX } },
1058 { "movL", { Td, Rd } },
1059 { "(bad)", { XX } },
1060 /* 28 */
1061 { "movapX", { XM, EXx } },
1062 { "movapX", { EXx, XM } },
1063 { PREGRP2 },
1064 { PREGRP33 },
1065 { PREGRP4 },
1066 { PREGRP3 },
1067 { PREGRP93 },
1068 { PREGRP94 },
1069 /* 30 */
1070 { "wrmsr", { XX } },
1071 { "rdtsc", { XX } },
1072 { "rdmsr", { XX } },
1073 { "rdpmc", { XX } },
1074 { "sysenter", { XX } },
1075 { "sysexit", { XX } },
1076 { "(bad)", { XX } },
1077 { "(bad)", { XX } },
1078 /* 38 */
1079 { THREE_BYTE_0 },
1080 { "(bad)", { XX } },
1081 { THREE_BYTE_1 },
1082 { "(bad)", { XX } },
1083 { "(bad)", { XX } },
1084 { "(bad)", { XX } },
1085 { "(bad)", { XX } },
1086 { "(bad)", { XX } },
1087 /* 40 */
1088 { "cmovo", { Gv, Ev } },
1089 { "cmovno", { Gv, Ev } },
1090 { "cmovb", { Gv, Ev } },
1091 { "cmovae", { Gv, Ev } },
1092 { "cmove", { Gv, Ev } },
1093 { "cmovne", { Gv, Ev } },
1094 { "cmovbe", { Gv, Ev } },
1095 { "cmova", { Gv, Ev } },
1096 /* 48 */
1097 { "cmovs", { Gv, Ev } },
1098 { "cmovns", { Gv, Ev } },
1099 { "cmovp", { Gv, Ev } },
1100 { "cmovnp", { Gv, Ev } },
1101 { "cmovl", { Gv, Ev } },
1102 { "cmovge", { Gv, Ev } },
1103 { "cmovle", { Gv, Ev } },
1104 { "cmovg", { Gv, Ev } },
1105 /* 50 */
1106 { "movmskpX", { Gdq, XS } },
1107 { PREGRP13 },
1108 { PREGRP12 },
1109 { PREGRP11 },
1110 { "andpX", { XM, EXx } },
1111 { "andnpX", { XM, EXx } },
1112 { "orpX", { XM, EXx } },
1113 { "xorpX", { XM, EXx } },
1114 /* 58 */
1115 { PREGRP0 },
1116 { PREGRP10 },
1117 { PREGRP17 },
1118 { PREGRP16 },
1119 { PREGRP14 },
1120 { PREGRP7 },
1121 { PREGRP5 },
1122 { PREGRP6 },
1123 /* 60 */
1124 { PREGRP95 },
1125 { PREGRP96 },
1126 { PREGRP97 },
1127 { "packsswb", { MX, EM } },
1128 { "pcmpgtb", { MX, EM } },
1129 { "pcmpgtw", { MX, EM } },
1130 { "pcmpgtd", { MX, EM } },
1131 { "packuswb", { MX, EM } },
1132 /* 68 */
1133 { "punpckhbw", { MX, EM } },
1134 { "punpckhwd", { MX, EM } },
1135 { "punpckhdq", { MX, EM } },
1136 { "packssdw", { MX, EM } },
1137 { PREGRP26 },
1138 { PREGRP24 },
1139 { "movd", { MX, Edq } },
1140 { PREGRP19 },
1141 /* 70 */
1142 { PREGRP22 },
1143 { GRP12 },
1144 { GRP13 },
1145 { GRP14 },
1146 { "pcmpeqb", { MX, EM } },
1147 { "pcmpeqw", { MX, EM } },
1148 { "pcmpeqd", { MX, EM } },
1149 { "emms", { XX } },
1150 /* 78 */
1151 { PREGRP34 },
1152 { PREGRP35 },
1153 { "(bad)", { XX } },
1154 { "(bad)", { XX } },
1155 { PREGRP28 },
1156 { PREGRP29 },
1157 { PREGRP23 },
1158 { PREGRP20 },
1159 /* 80 */
1160 { "joH", { Jv, XX, cond_jump_flag } },
1161 { "jnoH", { Jv, XX, cond_jump_flag } },
1162 { "jbH", { Jv, XX, cond_jump_flag } },
1163 { "jaeH", { Jv, XX, cond_jump_flag } },
1164 { "jeH", { Jv, XX, cond_jump_flag } },
1165 { "jneH", { Jv, XX, cond_jump_flag } },
1166 { "jbeH", { Jv, XX, cond_jump_flag } },
1167 { "jaH", { Jv, XX, cond_jump_flag } },
1168 /* 88 */
1169 { "jsH", { Jv, XX, cond_jump_flag } },
1170 { "jnsH", { Jv, XX, cond_jump_flag } },
1171 { "jpH", { Jv, XX, cond_jump_flag } },
1172 { "jnpH", { Jv, XX, cond_jump_flag } },
1173 { "jlH", { Jv, XX, cond_jump_flag } },
1174 { "jgeH", { Jv, XX, cond_jump_flag } },
1175 { "jleH", { Jv, XX, cond_jump_flag } },
1176 { "jgH", { Jv, XX, cond_jump_flag } },
1177 /* 90 */
1178 { "seto", { Eb } },
1179 { "setno", { Eb } },
1180 { "setb", { Eb } },
1181 { "setae", { Eb } },
1182 { "sete", { Eb } },
1183 { "setne", { Eb } },
1184 { "setbe", { Eb } },
1185 { "seta", { Eb } },
1186 /* 98 */
1187 { "sets", { Eb } },
1188 { "setns", { Eb } },
1189 { "setp", { Eb } },
1190 { "setnp", { Eb } },
1191 { "setl", { Eb } },
1192 { "setge", { Eb } },
1193 { "setle", { Eb } },
1194 { "setg", { Eb } },
1195 /* a0 */
1196 { "pushT", { fs } },
1197 { "popT", { fs } },
1198 { "cpuid", { XX } },
1199 { "btS", { Ev, Gv } },
1200 { "shldS", { Ev, Gv, Ib } },
1201 { "shldS", { Ev, Gv, CL } },
1202 { GRPPADLCK2 },
1203 { GRPPADLCK1 },
1204 /* a8 */
1205 { "pushT", { gs } },
1206 { "popT", { gs } },
1207 { "rsm", { XX } },
1208 { "btsS", { Ev, Gv } },
1209 { "shrdS", { Ev, Gv, Ib } },
1210 { "shrdS", { Ev, Gv, CL } },
1211 { GRP15 },
1212 { "imulS", { Gv, Ev } },
1213 /* b0 */
1214 { "cmpxchgB", { Eb, Gb } },
1215 { "cmpxchgS", { Ev, Gv } },
1216 { "lssS", { Gv, Mp } },
1217 { "btrS", { Ev, Gv } },
1218 { "lfsS", { Gv, Mp } },
1219 { "lgsS", { Gv, Mp } },
1220 { "movz{bR|x|bR|x}", { Gv, Eb } },
1221 { "movz{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movzww ! */
1222 /* b8 */
1223 { PREGRP37 },
1224 { "ud2b", { XX } },
1225 { GRP8 },
1226 { "btcS", { Ev, Gv } },
1227 { "bsfS", { Gv, Ev } },
1228 { PREGRP36 },
1229 { "movs{bR|x|bR|x}", { Gv, Eb } },
1230 { "movs{wR|x|wR|x}", { Gv, Ew } }, /* yes, there really is movsww ! */
1231 /* c0 */
1232 { "xaddB", { Eb, Gb } },
1233 { "xaddS", { Ev, Gv } },
1234 { PREGRP1 },
1235 { "movntiS", { Ev, Gv } },
1236 { "pinsrw", { MX, Edqw, Ib } },
1237 { "pextrw", { Gdq, MS, Ib } },
1238 { "shufpX", { XM, EXx, Ib } },
1239 { GRP9 },
1240 /* c8 */
1241 { "bswap", { RMeAX } },
1242 { "bswap", { RMeCX } },
1243 { "bswap", { RMeDX } },
1244 { "bswap", { RMeBX } },
1245 { "bswap", { RMeSP } },
1246 { "bswap", { RMeBP } },
1247 { "bswap", { RMeSI } },
1248 { "bswap", { RMeDI } },
1249 /* d0 */
1250 { PREGRP27 },
1251 { "psrlw", { MX, EM } },
1252 { "psrld", { MX, EM } },
1253 { "psrlq", { MX, EM } },
1254 { "paddq", { MX, EM } },
1255 { "pmullw", { MX, EM } },
1256 { PREGRP21 },
1257 { "pmovmskb", { Gdq, MS } },
1258 /* d8 */
1259 { "psubusb", { MX, EM } },
1260 { "psubusw", { MX, EM } },
1261 { "pminub", { MX, EM } },
1262 { "pand", { MX, EM } },
1263 { "paddusb", { MX, EM } },
1264 { "paddusw", { MX, EM } },
1265 { "pmaxub", { MX, EM } },
1266 { "pandn", { MX, EM } },
1267 /* e0 */
1268 { "pavgb", { MX, EM } },
1269 { "psraw", { MX, EM } },
1270 { "psrad", { MX, EM } },
1271 { "pavgw", { MX, EM } },
1272 { "pmulhuw", { MX, EM } },
1273 { "pmulhw", { MX, EM } },
1274 { PREGRP15 },
1275 { PREGRP25 },
1276 /* e8 */
1277 { "psubsb", { MX, EM } },
1278 { "psubsw", { MX, EM } },
1279 { "pminsw", { MX, EM } },
1280 { "por", { MX, EM } },
1281 { "paddsb", { MX, EM } },
1282 { "paddsw", { MX, EM } },
1283 { "pmaxsw", { MX, EM } },
1284 { "pxor", { MX, EM } },
1285 /* f0 */
1286 { PREGRP32 },
1287 { "psllw", { MX, EM } },
1288 { "pslld", { MX, EM } },
1289 { "psllq", { MX, EM } },
1290 { "pmuludq", { MX, EM } },
1291 { "pmaddwd", { MX, EM } },
1292 { "psadbw", { MX, EM } },
1293 { PREGRP18 },
1294 /* f8 */
1295 { "psubb", { MX, EM } },
1296 { "psubw", { MX, EM } },
1297 { "psubd", { MX, EM } },
1298 { "psubq", { MX, EM } },
1299 { "paddb", { MX, EM } },
1300 { "paddw", { MX, EM } },
1301 { "paddd", { MX, EM } },
1302 { "(bad)", { XX } },
1303 };
1304
1305 static const unsigned char onebyte_has_modrm[256] = {
1306 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1307 /* ------------------------------- */
1308 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1309 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1310 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1311 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1312 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1313 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1314 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1315 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1316 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1317 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1318 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1319 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1320 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1321 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1322 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1323 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1324 /* ------------------------------- */
1325 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1326 };
1327
1328 static const unsigned char twobyte_has_modrm[256] = {
1329 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1330 /* ------------------------------- */
1331 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1332 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */
1333 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1334 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1335 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1336 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1337 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1338 /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1339 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1340 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1341 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1342 /* b0 */ 1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, /* bf */
1343 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1344 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1345 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1346 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1347 /* ------------------------------- */
1348 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1349 };
1350
1351 static const unsigned char twobyte_uses_DATA_prefix[256] = {
1352 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1353 /* ------------------------------- */
1354 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1355 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1356 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1357 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1358 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1359 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1360 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1361 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, /* 7f */
1362 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1363 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1364 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1365 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1366 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1367 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1368 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1369 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1370 /* ------------------------------- */
1371 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1372 };
1373
1374 static const unsigned char twobyte_uses_REPNZ_prefix[256] = {
1375 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1376 /* ------------------------------- */
1377 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1378 /* 10 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1379 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1380 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1381 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1382 /* 50 */ 0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, /* 5f */
1383 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1384 /* 70 */ 1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, /* 7f */
1385 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1386 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1387 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1388 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1389 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1390 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1391 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1392 /* f0 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1393 /* ------------------------------- */
1394 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1395 };
1396
1397 static const unsigned char twobyte_uses_REPZ_prefix[256] = {
1398 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1399 /* ------------------------------- */
1400 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1401 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1402 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, /* 2f */
1403 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1404 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1405 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1406 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, /* 6f */
1407 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */
1408 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1409 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1410 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1411 /* b0 */ 0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, /* bf */
1412 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1413 /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1414 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1415 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1416 /* ------------------------------- */
1417 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1418 };
1419
1420 /* This is used to determine if opcode 0f 38 XX uses DATA prefix. */
1421 static const unsigned char threebyte_0x38_uses_DATA_prefix[256] = {
1422 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1423 /* ------------------------------- */
1424 /* 00 */ 1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, /* 0f */
1425 /* 10 */ 1,0,0,0,1,1,0,1,0,0,0,0,1,1,1,0, /* 1f */
1426 /* 20 */ 1,1,1,1,1,1,0,0,1,1,1,1,0,0,0,0, /* 2f */
1427 /* 30 */ 1,1,1,1,1,1,0,1,1,1,1,1,1,1,1,1, /* 3f */
1428 /* 40 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1429 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1430 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1431 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1432 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1433 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1434 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1435 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1436 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1437 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1438 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1439 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1440 /* ------------------------------- */
1441 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1442 };
1443
1444 /* This is used to determine if opcode 0f 38 XX uses REPNZ prefix. */
1445 static const unsigned char threebyte_0x38_uses_REPNZ_prefix[256] = {
1446 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1447 /* ------------------------------- */
1448 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1449 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1450 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1451 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1452 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1453 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1454 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1455 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1456 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1457 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1458 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1459 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1460 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1461 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1462 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1463 /* f0 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1464 /* ------------------------------- */
1465 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1466 };
1467
1468 /* This is used to determine if opcode 0f 38 XX uses REPZ prefix. */
1469 static const unsigned char threebyte_0x38_uses_REPZ_prefix[256] = {
1470 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1471 /* ------------------------------- */
1472 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1473 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1474 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1475 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1476 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1477 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1478 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1479 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1480 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1481 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1482 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1483 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1484 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1485 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1486 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1487 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1488 /* ------------------------------- */
1489 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1490 };
1491
1492 /* This is used to determine if opcode 0f 3a XX uses DATA prefix. */
1493 static const unsigned char threebyte_0x3a_uses_DATA_prefix[256] = {
1494 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1495 /* ------------------------------- */
1496 /* 00 */ 0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, /* 0f */
1497 /* 10 */ 0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* 1f */
1498 /* 20 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1499 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1500 /* 40 */ 1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1501 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1502 /* 60 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1503 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1504 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1505 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1506 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1507 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1508 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1509 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1510 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1511 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1512 /* ------------------------------- */
1513 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1514 };
1515
1516 /* This is used to determine if opcode 0f 3a XX uses REPNZ prefix. */
1517 static const unsigned char threebyte_0x3a_uses_REPNZ_prefix[256] = {
1518 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1519 /* ------------------------------- */
1520 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1521 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1522 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1523 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1524 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1525 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1526 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1527 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1528 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1529 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1530 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1531 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1532 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1533 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1534 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1535 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1536 /* ------------------------------- */
1537 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1538 };
1539
1540 /* This is used to determine if opcode 0f 3a XX uses REPZ prefix. */
1541 static const unsigned char threebyte_0x3a_uses_REPZ_prefix[256] = {
1542 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1543 /* ------------------------------- */
1544 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1545 /* 10 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1546 /* 20 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 2f */
1547 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1548 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1549 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 5f */
1550 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 6f */
1551 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 7f */
1552 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1553 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1554 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1555 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1556 /* c0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1557 /* d0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* df */
1558 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ef */
1559 /* f0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* ff */
1560 /* ------------------------------- */
1561 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1562 };
1563
1564 static char obuf[100];
1565 static char *obufp;
1566 static char scratchbuf[100];
1567 static unsigned char *start_codep;
1568 static unsigned char *insn_codep;
1569 static unsigned char *codep;
1570 static disassemble_info *the_info;
1571 static struct
1572 {
1573 int mod;
1574 int reg;
1575 int rm;
1576 }
1577 modrm;
1578 static unsigned char need_modrm;
1579
1580 /* If we are accessing mod/rm/reg without need_modrm set, then the
1581 values are stale. Hitting this abort likely indicates that you
1582 need to update onebyte_has_modrm or twobyte_has_modrm. */
1583 #define MODRM_CHECK if (!need_modrm) abort ()
1584
1585 static const char * const *names64;
1586 static const char * const *names32;
1587 static const char * const *names16;
1588 static const char * const *names8;
1589 static const char * const *names8rex;
1590 static const char * const *names_seg;
1591 static const char * const *index16;
1592
1593 static const char * const intel_names64[] = {
1594 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1595 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1596 };
1597 static const char * const intel_names32[] = {
1598 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1599 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1600 };
1601 static const char * const intel_names16[] = {
1602 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1603 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1604 };
1605 static const char * const intel_names8[] = {
1606 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1607 };
1608 static const char * const intel_names8rex[] = {
1609 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1610 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1611 };
1612 static const char * const intel_names_seg[] = {
1613 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1614 };
1615 static const char * const intel_index16[] = {
1616 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1617 };
1618
1619 static const char * const att_names64[] = {
1620 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1621 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1622 };
1623 static const char * const att_names32[] = {
1624 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1625 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1626 };
1627 static const char * const att_names16[] = {
1628 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1629 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1630 };
1631 static const char * const att_names8[] = {
1632 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1633 };
1634 static const char * const att_names8rex[] = {
1635 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1636 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1637 };
1638 static const char * const att_names_seg[] = {
1639 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1640 };
1641 static const char * const att_index16[] = {
1642 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1643 };
1644
1645 static const struct dis386 grps[][8] = {
1646 /* GRP1a */
1647 {
1648 { "popU", { stackEv } },
1649 { "(bad)", { XX } },
1650 { "(bad)", { XX } },
1651 { "(bad)", { XX } },
1652 { "(bad)", { XX } },
1653 { "(bad)", { XX } },
1654 { "(bad)", { XX } },
1655 { "(bad)", { XX } },
1656 },
1657 /* GRP1b */
1658 {
1659 { "addA", { Eb, Ib } },
1660 { "orA", { Eb, Ib } },
1661 { "adcA", { Eb, Ib } },
1662 { "sbbA", { Eb, Ib } },
1663 { "andA", { Eb, Ib } },
1664 { "subA", { Eb, Ib } },
1665 { "xorA", { Eb, Ib } },
1666 { "cmpA", { Eb, Ib } },
1667 },
1668 /* GRP1S */
1669 {
1670 { "addQ", { Ev, Iv } },
1671 { "orQ", { Ev, Iv } },
1672 { "adcQ", { Ev, Iv } },
1673 { "sbbQ", { Ev, Iv } },
1674 { "andQ", { Ev, Iv } },
1675 { "subQ", { Ev, Iv } },
1676 { "xorQ", { Ev, Iv } },
1677 { "cmpQ", { Ev, Iv } },
1678 },
1679 /* GRP1Ss */
1680 {
1681 { "addQ", { Ev, sIb } },
1682 { "orQ", { Ev, sIb } },
1683 { "adcQ", { Ev, sIb } },
1684 { "sbbQ", { Ev, sIb } },
1685 { "andQ", { Ev, sIb } },
1686 { "subQ", { Ev, sIb } },
1687 { "xorQ", { Ev, sIb } },
1688 { "cmpQ", { Ev, sIb } },
1689 },
1690 /* GRP2b */
1691 {
1692 { "rolA", { Eb, Ib } },
1693 { "rorA", { Eb, Ib } },
1694 { "rclA", { Eb, Ib } },
1695 { "rcrA", { Eb, Ib } },
1696 { "shlA", { Eb, Ib } },
1697 { "shrA", { Eb, Ib } },
1698 { "(bad)", { XX } },
1699 { "sarA", { Eb, Ib } },
1700 },
1701 /* GRP2S */
1702 {
1703 { "rolQ", { Ev, Ib } },
1704 { "rorQ", { Ev, Ib } },
1705 { "rclQ", { Ev, Ib } },
1706 { "rcrQ", { Ev, Ib } },
1707 { "shlQ", { Ev, Ib } },
1708 { "shrQ", { Ev, Ib } },
1709 { "(bad)", { XX } },
1710 { "sarQ", { Ev, Ib } },
1711 },
1712 /* GRP2b_one */
1713 {
1714 { "rolA", { Eb, I1 } },
1715 { "rorA", { Eb, I1 } },
1716 { "rclA", { Eb, I1 } },
1717 { "rcrA", { Eb, I1 } },
1718 { "shlA", { Eb, I1 } },
1719 { "shrA", { Eb, I1 } },
1720 { "(bad)", { XX } },
1721 { "sarA", { Eb, I1 } },
1722 },
1723 /* GRP2S_one */
1724 {
1725 { "rolQ", { Ev, I1 } },
1726 { "rorQ", { Ev, I1 } },
1727 { "rclQ", { Ev, I1 } },
1728 { "rcrQ", { Ev, I1 } },
1729 { "shlQ", { Ev, I1 } },
1730 { "shrQ", { Ev, I1 } },
1731 { "(bad)", { XX } },
1732 { "sarQ", { Ev, I1 } },
1733 },
1734 /* GRP2b_cl */
1735 {
1736 { "rolA", { Eb, CL } },
1737 { "rorA", { Eb, CL } },
1738 { "rclA", { Eb, CL } },
1739 { "rcrA", { Eb, CL } },
1740 { "shlA", { Eb, CL } },
1741 { "shrA", { Eb, CL } },
1742 { "(bad)", { XX } },
1743 { "sarA", { Eb, CL } },
1744 },
1745 /* GRP2S_cl */
1746 {
1747 { "rolQ", { Ev, CL } },
1748 { "rorQ", { Ev, CL } },
1749 { "rclQ", { Ev, CL } },
1750 { "rcrQ", { Ev, CL } },
1751 { "shlQ", { Ev, CL } },
1752 { "shrQ", { Ev, CL } },
1753 { "(bad)", { XX } },
1754 { "sarQ", { Ev, CL } },
1755 },
1756 /* GRP3b */
1757 {
1758 { "testA", { Eb, Ib } },
1759 { "(bad)", { Eb } },
1760 { "notA", { Eb } },
1761 { "negA", { Eb } },
1762 { "mulA", { Eb } }, /* Don't print the implicit %al register, */
1763 { "imulA", { Eb } }, /* to distinguish these opcodes from other */
1764 { "divA", { Eb } }, /* mul/imul opcodes. Do the same for div */
1765 { "idivA", { Eb } }, /* and idiv for consistency. */
1766 },
1767 /* GRP3S */
1768 {
1769 { "testQ", { Ev, Iv } },
1770 { "(bad)", { XX } },
1771 { "notQ", { Ev } },
1772 { "negQ", { Ev } },
1773 { "mulQ", { Ev } }, /* Don't print the implicit register. */
1774 { "imulQ", { Ev } },
1775 { "divQ", { Ev } },
1776 { "idivQ", { Ev } },
1777 },
1778 /* GRP4 */
1779 {
1780 { "incA", { Eb } },
1781 { "decA", { Eb } },
1782 { "(bad)", { XX } },
1783 { "(bad)", { XX } },
1784 { "(bad)", { XX } },
1785 { "(bad)", { XX } },
1786 { "(bad)", { XX } },
1787 { "(bad)", { XX } },
1788 },
1789 /* GRP5 */
1790 {
1791 { "incQ", { Ev } },
1792 { "decQ", { Ev } },
1793 { "callT", { indirEv } },
1794 { "JcallT", { indirEp } },
1795 { "jmpT", { indirEv } },
1796 { "JjmpT", { indirEp } },
1797 { "pushU", { stackEv } },
1798 { "(bad)", { XX } },
1799 },
1800 /* GRP6 */
1801 {
1802 { "sldtD", { Sv } },
1803 { "strD", { Sv } },
1804 { "lldt", { Ew } },
1805 { "ltr", { Ew } },
1806 { "verr", { Ew } },
1807 { "verw", { Ew } },
1808 { "(bad)", { XX } },
1809 { "(bad)", { XX } },
1810 },
1811 /* GRP7 */
1812 {
1813 { "sgdt{Q|IQ||}", { { VMX_Fixup, 0 } } },
1814 { "sidt{Q|IQ||}", { { PNI_Fixup, 0 } } },
1815 { "lgdt{Q|Q||}", { M } },
1816 { "lidt{Q|Q||}", { { SVME_Fixup, 0 } } },
1817 { "smswD", { Sv } },
1818 { "(bad)", { XX } },
1819 { "lmsw", { Ew } },
1820 { "invlpg", { { INVLPG_Fixup, w_mode } } },
1821 },
1822 /* GRP8 */
1823 {
1824 { "(bad)", { XX } },
1825 { "(bad)", { XX } },
1826 { "(bad)", { XX } },
1827 { "(bad)", { XX } },
1828 { "btQ", { Ev, Ib } },
1829 { "btsQ", { Ev, Ib } },
1830 { "btrQ", { Ev, Ib } },
1831 { "btcQ", { Ev, Ib } },
1832 },
1833 /* GRP9 */
1834 {
1835 { "(bad)", { XX } },
1836 { "cmpxchg8b", { { CMPXCHG8B_Fixup, q_mode } } },
1837 { "(bad)", { XX } },
1838 { "(bad)", { XX } },
1839 { "(bad)", { XX } },
1840 { "(bad)", { XX } },
1841 { "", { VM } }, /* See OP_VMX. */
1842 { "vmptrst", { Mq } },
1843 },
1844 /* GRP11_C6 */
1845 {
1846 { "movA", { Eb, Ib } },
1847 { "(bad)", { XX } },
1848 { "(bad)", { XX } },
1849 { "(bad)", { XX } },
1850 { "(bad)", { XX } },
1851 { "(bad)", { XX } },
1852 { "(bad)", { XX } },
1853 { "(bad)", { XX } },
1854 },
1855 /* GRP11_C7 */
1856 {
1857 { "movQ", { Ev, Iv } },
1858 { "(bad)", { XX } },
1859 { "(bad)", { XX } },
1860 { "(bad)", { XX } },
1861 { "(bad)", { XX } },
1862 { "(bad)", { XX } },
1863 { "(bad)", { XX } },
1864 { "(bad)", { XX } },
1865 },
1866 /* GRP12 */
1867 {
1868 { "(bad)", { XX } },
1869 { "(bad)", { XX } },
1870 { "psrlw", { MS, Ib } },
1871 { "(bad)", { XX } },
1872 { "psraw", { MS, Ib } },
1873 { "(bad)", { XX } },
1874 { "psllw", { MS, Ib } },
1875 { "(bad)", { XX } },
1876 },
1877 /* GRP13 */
1878 {
1879 { "(bad)", { XX } },
1880 { "(bad)", { XX } },
1881 { "psrld", { MS, Ib } },
1882 { "(bad)", { XX } },
1883 { "psrad", { MS, Ib } },
1884 { "(bad)", { XX } },
1885 { "pslld", { MS, Ib } },
1886 { "(bad)", { XX } },
1887 },
1888 /* GRP14 */
1889 {
1890 { "(bad)", { XX } },
1891 { "(bad)", { XX } },
1892 { "psrlq", { MS, Ib } },
1893 { "psrldq", { MS, Ib } },
1894 { "(bad)", { XX } },
1895 { "(bad)", { XX } },
1896 { "psllq", { MS, Ib } },
1897 { "pslldq", { MS, Ib } },
1898 },
1899 /* GRP15 */
1900 {
1901 { "fxsave", { Ev } },
1902 { "fxrstor", { Ev } },
1903 { "ldmxcsr", { Ev } },
1904 { "stmxcsr", { Ev } },
1905 { "(bad)", { XX } },
1906 { "lfence", { { OP_0fae, 0 } } },
1907 { "mfence", { { OP_0fae, 0 } } },
1908 { "clflush", { { OP_0fae, 0 } } },
1909 },
1910 /* GRP16 */
1911 {
1912 { "prefetchnta", { Ev } },
1913 { "prefetcht0", { Ev } },
1914 { "prefetcht1", { Ev } },
1915 { "prefetcht2", { Ev } },
1916 { "(bad)", { XX } },
1917 { "(bad)", { XX } },
1918 { "(bad)", { XX } },
1919 { "(bad)", { XX } },
1920 },
1921 /* GRPAMD */
1922 {
1923 { "prefetch", { Eb } },
1924 { "prefetchw", { Eb } },
1925 { "(bad)", { XX } },
1926 { "(bad)", { XX } },
1927 { "(bad)", { XX } },
1928 { "(bad)", { XX } },
1929 { "(bad)", { XX } },
1930 { "(bad)", { XX } },
1931 },
1932 /* GRPPADLCK1 */
1933 {
1934 { "xstore-rng", { { OP_0f07, 0 } } },
1935 { "xcrypt-ecb", { { OP_0f07, 0 } } },
1936 { "xcrypt-cbc", { { OP_0f07, 0 } } },
1937 { "xcrypt-ctr", { { OP_0f07, 0 } } },
1938 { "xcrypt-cfb", { { OP_0f07, 0 } } },
1939 { "xcrypt-ofb", { { OP_0f07, 0 } } },
1940 { "(bad)", { { OP_0f07, 0 } } },
1941 { "(bad)", { { OP_0f07, 0 } } },
1942 },
1943 /* GRPPADLCK2 */
1944 {
1945 { "montmul", { { OP_0f07, 0 } } },
1946 { "xsha1", { { OP_0f07, 0 } } },
1947 { "xsha256", { { OP_0f07, 0 } } },
1948 { "(bad)", { { OP_0f07, 0 } } },
1949 { "(bad)", { { OP_0f07, 0 } } },
1950 { "(bad)", { { OP_0f07, 0 } } },
1951 { "(bad)", { { OP_0f07, 0 } } },
1952 { "(bad)", { { OP_0f07, 0 } } },
1953 }
1954 };
1955
1956 static const struct dis386 prefix_user_table[][4] = {
1957 /* PREGRP0 */
1958 {
1959 { "addps", { XM, EXx } },
1960 { "addss", { XM, EXd } },
1961 { "addpd", { XM, EXx } },
1962 { "addsd", { XM, EXq } },
1963 },
1964 /* PREGRP1 */
1965 {
1966 { "", { XM, EXx, OPSIMD } }, /* See OP_SIMD_SUFFIX. */
1967 { "", { XM, EXx, OPSIMD } },
1968 { "", { XM, EXx, OPSIMD } },
1969 { "", { XM, EXx, OPSIMD } },
1970 },
1971 /* PREGRP2 */
1972 {
1973 { "cvtpi2ps", { XM, EMC } },
1974 { "cvtsi2ssY", { XM, Ev } },
1975 { "cvtpi2pd", { XM, EMC } },
1976 { "cvtsi2sdY", { XM, Ev } },
1977 },
1978 /* PREGRP3 */
1979 {
1980 { "cvtps2pi", { MXC, EXx } },
1981 { "cvtss2siY", { Gv, EXx } },
1982 { "cvtpd2pi", { MXC, EXx } },
1983 { "cvtsd2siY", { Gv, EXx } },
1984 },
1985 /* PREGRP4 */
1986 {
1987 { "cvttps2pi", { MXC, EXx } },
1988 { "cvttss2siY", { Gv, EXx } },
1989 { "cvttpd2pi", { MXC, EXx } },
1990 { "cvttsd2siY", { Gv, EXx } },
1991 },
1992 /* PREGRP5 */
1993 {
1994 { "divps", { XM, EXx } },
1995 { "divss", { XM, EXx } },
1996 { "divpd", { XM, EXx } },
1997 { "divsd", { XM, EXx } },
1998 },
1999 /* PREGRP6 */
2000 {
2001 { "maxps", { XM, EXx } },
2002 { "maxss", { XM, EXx } },
2003 { "maxpd", { XM, EXx } },
2004 { "maxsd", { XM, EXx } },
2005 },
2006 /* PREGRP7 */
2007 {
2008 { "minps", { XM, EXx } },
2009 { "minss", { XM, EXx } },
2010 { "minpd", { XM, EXx } },
2011 { "minsd", { XM, EXx } },
2012 },
2013 /* PREGRP8 */
2014 {
2015 { "movups", { XM, EXx } },
2016 { "movss", { XM, EXx } },
2017 { "movupd", { XM, EXx } },
2018 { "movsd", { XM, EXx } },
2019 },
2020 /* PREGRP9 */
2021 {
2022 { "movups", { EXx, XM } },
2023 { "movss", { EXx, XM } },
2024 { "movupd", { EXx, XM } },
2025 { "movsd", { EXx, XM } },
2026 },
2027 /* PREGRP10 */
2028 {
2029 { "mulps", { XM, EXx } },
2030 { "mulss", { XM, EXx } },
2031 { "mulpd", { XM, EXx } },
2032 { "mulsd", { XM, EXx } },
2033 },
2034 /* PREGRP11 */
2035 {
2036 { "rcpps", { XM, EXx } },
2037 { "rcpss", { XM, EXx } },
2038 { "(bad)", { XM, EXx } },
2039 { "(bad)", { XM, EXx } },
2040 },
2041 /* PREGRP12 */
2042 {
2043 { "rsqrtps",{ XM, EXx } },
2044 { "rsqrtss",{ XM, EXx } },
2045 { "(bad)", { XM, EXx } },
2046 { "(bad)", { XM, EXx } },
2047 },
2048 /* PREGRP13 */
2049 {
2050 { "sqrtps", { XM, EXx } },
2051 { "sqrtss", { XM, EXx } },
2052 { "sqrtpd", { XM, EXx } },
2053 { "sqrtsd", { XM, EXx } },
2054 },
2055 /* PREGRP14 */
2056 {
2057 { "subps", { XM, EXx } },
2058 { "subss", { XM, EXx } },
2059 { "subpd", { XM, EXx } },
2060 { "subsd", { XM, EXx } },
2061 },
2062 /* PREGRP15 */
2063 {
2064 { "(bad)", { XM, EXx } },
2065 { "cvtdq2pd", { XM, EXq } },
2066 { "cvttpd2dq", { XM, EXx } },
2067 { "cvtpd2dq", { XM, EXx } },
2068 },
2069 /* PREGRP16 */
2070 {
2071 { "cvtdq2ps", { XM, EXx } },
2072 { "cvttps2dq", { XM, EXx } },
2073 { "cvtps2dq", { XM, EXx } },
2074 { "(bad)", { XM, EXx } },
2075 },
2076 /* PREGRP17 */
2077 {
2078 { "cvtps2pd", { XM, EXq } },
2079 { "cvtss2sd", { XM, EXx } },
2080 { "cvtpd2ps", { XM, EXx } },
2081 { "cvtsd2ss", { XM, EXx } },
2082 },
2083 /* PREGRP18 */
2084 {
2085 { "maskmovq", { MX, MS } },
2086 { "(bad)", { XM, EXx } },
2087 { "maskmovdqu", { XM, XS } },
2088 { "(bad)", { XM, EXx } },
2089 },
2090 /* PREGRP19 */
2091 {
2092 { "movq", { MX, EM } },
2093 { "movdqu", { XM, EXx } },
2094 { "movdqa", { XM, EXx } },
2095 { "(bad)", { XM, EXx } },
2096 },
2097 /* PREGRP20 */
2098 {
2099 { "movq", { EM, MX } },
2100 { "movdqu", { EXx, XM } },
2101 { "movdqa", { EXx, XM } },
2102 { "(bad)", { EXx, XM } },
2103 },
2104 /* PREGRP21 */
2105 {
2106 { "(bad)", { EXx, XM } },
2107 { "movq2dq",{ XM, MS } },
2108 { "movq", { EXx, XM } },
2109 { "movdq2q",{ MX, XS } },
2110 },
2111 /* PREGRP22 */
2112 {
2113 { "pshufw", { MX, EM, Ib } },
2114 { "pshufhw",{ XM, EXx, Ib } },
2115 { "pshufd", { XM, EXx, Ib } },
2116 { "pshuflw",{ XM, EXx, Ib } },
2117 },
2118 /* PREGRP23 */
2119 {
2120 { "movd", { Edq, MX } },
2121 { "movq", { XM, EXx } },
2122 { "movd", { Edq, XM } },
2123 { "(bad)", { Ed, XM } },
2124 },
2125 /* PREGRP24 */
2126 {
2127 { "(bad)", { MX, EXx } },
2128 { "(bad)", { XM, EXx } },
2129 { "punpckhqdq", { XM, EXx } },
2130 { "(bad)", { XM, EXx } },
2131 },
2132 /* PREGRP25 */
2133 {
2134 { "movntq", { EM, MX } },
2135 { "(bad)", { EM, XM } },
2136 { "movntdq",{ EM, XM } },
2137 { "(bad)", { EM, XM } },
2138 },
2139 /* PREGRP26 */
2140 {
2141 { "(bad)", { MX, EXx } },
2142 { "(bad)", { XM, EXx } },
2143 { "punpcklqdq", { XM, EXx } },
2144 { "(bad)", { XM, EXx } },
2145 },
2146 /* PREGRP27 */
2147 {
2148 { "(bad)", { MX, EXx } },
2149 { "(bad)", { XM, EXx } },
2150 { "addsubpd", { XM, EXx } },
2151 { "addsubps", { XM, EXx } },
2152 },
2153 /* PREGRP28 */
2154 {
2155 { "(bad)", { MX, EXx } },
2156 { "(bad)", { XM, EXx } },
2157 { "haddpd", { XM, EXx } },
2158 { "haddps", { XM, EXx } },
2159 },
2160 /* PREGRP29 */
2161 {
2162 { "(bad)", { MX, EXx } },
2163 { "(bad)", { XM, EXx } },
2164 { "hsubpd", { XM, EXx } },
2165 { "hsubps", { XM, EXx } },
2166 },
2167 /* PREGRP30 */
2168 {
2169 { "movlpX", { XM, EXq, { SIMD_Fixup, 'h' } } }, /* really only 2 operands */
2170 { "movsldup", { XM, EXx } },
2171 { "movlpd", { XM, EXq } },
2172 { "movddup", { XM, EXq } },
2173 },
2174 /* PREGRP31 */
2175 {
2176 { "movhpX", { XM, EXq, { SIMD_Fixup, 'l' } } },
2177 { "movshdup", { XM, EXx } },
2178 { "movhpd", { XM, EXq } },
2179 { "(bad)", { XM, EXq } },
2180 },
2181 /* PREGRP32 */
2182 {
2183 { "(bad)", { XM, EXx } },
2184 { "(bad)", { XM, EXx } },
2185 { "(bad)", { XM, EXx } },
2186 { "lddqu", { XM, M } },
2187 },
2188 /* PREGRP33 */
2189 {
2190 {"movntps", { Ev, XM } },
2191 {"movntss", { Ev, XM } },
2192 {"movntpd", { Ev, XM } },
2193 {"movntsd", { Ev, XM } },
2194 },
2195
2196 /* PREGRP34 */
2197 {
2198 {"vmread", { Em, Gm } },
2199 {"(bad)", { XX } },
2200 {"extrq", { XS, Ib, Ib } },
2201 {"insertq", { XM, XS, Ib, Ib } },
2202 },
2203
2204 /* PREGRP35 */
2205 {
2206 {"vmwrite", { Gm, Em } },
2207 {"(bad)", { XX } },
2208 {"extrq", { XM, XS } },
2209 {"insertq", { XM, XS } },
2210 },
2211
2212 /* PREGRP36 */
2213 {
2214 { "bsrS", { Gv, Ev } },
2215 { "lzcntS", { Gv, Ev } },
2216 { "bsrS", { Gv, Ev } },
2217 { "(bad)", { XX } },
2218 },
2219
2220 /* PREGRP37 */
2221 {
2222 { "(bad)", { XX } },
2223 { "popcntS", { Gv, Ev } },
2224 { "(bad)", { XX } },
2225 { "(bad)", { XX } },
2226 },
2227
2228 /* PREGRP38 */
2229 {
2230 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2231 { "pause", { XX } },
2232 { "xchgS", { { NOP_Fixup1, eAX_reg }, { NOP_Fixup2, eAX_reg } } },
2233 { "(bad)", { XX } },
2234 },
2235
2236 /* PREGRP39 */
2237 {
2238 { "(bad)", { XX } },
2239 { "(bad)", { XX } },
2240 { "pblendvb", {XM, EXx, XMM0 } },
2241 { "(bad)", { XX } },
2242 },
2243
2244 /* PREGRP40 */
2245 {
2246 { "(bad)", { XX } },
2247 { "(bad)", { XX } },
2248 { "blendvps", {XM, EXx, XMM0 } },
2249 { "(bad)", { XX } },
2250 },
2251
2252 /* PREGRP41 */
2253 {
2254 { "(bad)", { XX } },
2255 { "(bad)", { XX } },
2256 { "blendvpd", { XM, EXx, XMM0 } },
2257 { "(bad)", { XX } },
2258 },
2259
2260 /* PREGRP42 */
2261 {
2262 { "(bad)", { XX } },
2263 { "(bad)", { XX } },
2264 { "ptest", { XM, EXx } },
2265 { "(bad)", { XX } },
2266 },
2267
2268 /* PREGRP43 */
2269 {
2270 { "(bad)", { XX } },
2271 { "(bad)", { XX } },
2272 { "pmovsxbw", { XM, EXx } },
2273 { "(bad)", { XX } },
2274 },
2275
2276 /* PREGRP44 */
2277 {
2278 { "(bad)", { XX } },
2279 { "(bad)", { XX } },
2280 { "pmovsxbd", { XM, EXx } },
2281 { "(bad)", { XX } },
2282 },
2283
2284 /* PREGRP45 */
2285 {
2286 { "(bad)", { XX } },
2287 { "(bad)", { XX } },
2288 { "pmovsxbq", { XM, EXx } },
2289 { "(bad)", { XX } },
2290 },
2291
2292 /* PREGRP46 */
2293 {
2294 { "(bad)", { XX } },
2295 { "(bad)", { XX } },
2296 { "pmovsxwd", { XM, EXx } },
2297 { "(bad)", { XX } },
2298 },
2299
2300 /* PREGRP47 */
2301 {
2302 { "(bad)", { XX } },
2303 { "(bad)", { XX } },
2304 { "pmovsxwq", { XM, EXx } },
2305 { "(bad)", { XX } },
2306 },
2307
2308 /* PREGRP48 */
2309 {
2310 { "(bad)", { XX } },
2311 { "(bad)", { XX } },
2312 { "pmovsxdq", { XM, EXx } },
2313 { "(bad)", { XX } },
2314 },
2315
2316 /* PREGRP49 */
2317 {
2318 { "(bad)", { XX } },
2319 { "(bad)", { XX } },
2320 { "pmuldq", { XM, EXx } },
2321 { "(bad)", { XX } },
2322 },
2323
2324 /* PREGRP50 */
2325 {
2326 { "(bad)", { XX } },
2327 { "(bad)", { XX } },
2328 { "pcmpeqq", { XM, EXx } },
2329 { "(bad)", { XX } },
2330 },
2331
2332 /* PREGRP51 */
2333 {
2334 { "(bad)", { XX } },
2335 { "(bad)", { XX } },
2336 { "movntdqa", { XM, EM } },
2337 { "(bad)", { XX } },
2338 },
2339
2340 /* PREGRP52 */
2341 {
2342 { "(bad)", { XX } },
2343 { "(bad)", { XX } },
2344 { "packusdw", { XM, EXx } },
2345 { "(bad)", { XX } },
2346 },
2347
2348 /* PREGRP53 */
2349 {
2350 { "(bad)", { XX } },
2351 { "(bad)", { XX } },
2352 { "pmovzxbw", { XM, EXx } },
2353 { "(bad)", { XX } },
2354 },
2355
2356 /* PREGRP54 */
2357 {
2358 { "(bad)", { XX } },
2359 { "(bad)", { XX } },
2360 { "pmovzxbd", { XM, EXx } },
2361 { "(bad)", { XX } },
2362 },
2363
2364 /* PREGRP55 */
2365 {
2366 { "(bad)", { XX } },
2367 { "(bad)", { XX } },
2368 { "pmovzxbq", { XM, EXx } },
2369 { "(bad)", { XX } },
2370 },
2371
2372 /* PREGRP56 */
2373 {
2374 { "(bad)", { XX } },
2375 { "(bad)", { XX } },
2376 { "pmovzxwd", { XM, EXx } },
2377 { "(bad)", { XX } },
2378 },
2379
2380 /* PREGRP57 */
2381 {
2382 { "(bad)", { XX } },
2383 { "(bad)", { XX } },
2384 { "pmovzxwq", { XM, EXx } },
2385 { "(bad)", { XX } },
2386 },
2387
2388 /* PREGRP58 */
2389 {
2390 { "(bad)", { XX } },
2391 { "(bad)", { XX } },
2392 { "pmovzxdq", { XM, EXx } },
2393 { "(bad)", { XX } },
2394 },
2395
2396 /* PREGRP59 */
2397 {
2398 { "(bad)", { XX } },
2399 { "(bad)", { XX } },
2400 { "pminsb", { XM, EXx } },
2401 { "(bad)", { XX } },
2402 },
2403
2404 /* PREGRP60 */
2405 {
2406 { "(bad)", { XX } },
2407 { "(bad)", { XX } },
2408 { "pminsd", { XM, EXx } },
2409 { "(bad)", { XX } },
2410 },
2411
2412 /* PREGRP61 */
2413 {
2414 { "(bad)", { XX } },
2415 { "(bad)", { XX } },
2416 { "pminuw", { XM, EXx } },
2417 { "(bad)", { XX } },
2418 },
2419
2420 /* PREGRP62 */
2421 {
2422 { "(bad)", { XX } },
2423 { "(bad)", { XX } },
2424 { "pminud", { XM, EXx } },
2425 { "(bad)", { XX } },
2426 },
2427
2428 /* PREGRP63 */
2429 {
2430 { "(bad)", { XX } },
2431 { "(bad)", { XX } },
2432 { "pmaxsb", { XM, EXx } },
2433 { "(bad)", { XX } },
2434 },
2435
2436 /* PREGRP64 */
2437 {
2438 { "(bad)", { XX } },
2439 { "(bad)", { XX } },
2440 { "pmaxsd", { XM, EXx } },
2441 { "(bad)", { XX } },
2442 },
2443
2444 /* PREGRP65 */
2445 {
2446 { "(bad)", { XX } },
2447 { "(bad)", { XX } },
2448 { "pmaxuw", { XM, EXx } },
2449 { "(bad)", { XX } },
2450 },
2451
2452 /* PREGRP66 */
2453 {
2454 { "(bad)", { XX } },
2455 { "(bad)", { XX } },
2456 { "pmaxud", { XM, EXx } },
2457 { "(bad)", { XX } },
2458 },
2459
2460 /* PREGRP67 */
2461 {
2462 { "(bad)", { XX } },
2463 { "(bad)", { XX } },
2464 { "pmulld", { XM, EXx } },
2465 { "(bad)", { XX } },
2466 },
2467
2468 /* PREGRP68 */
2469 {
2470 { "(bad)", { XX } },
2471 { "(bad)", { XX } },
2472 { "phminposuw", { XM, EXx } },
2473 { "(bad)", { XX } },
2474 },
2475
2476 /* PREGRP69 */
2477 {
2478 { "(bad)", { XX } },
2479 { "(bad)", { XX } },
2480 { "roundps", { XM, EXx, Ib } },
2481 { "(bad)", { XX } },
2482 },
2483
2484 /* PREGRP70 */
2485 {
2486 { "(bad)", { XX } },
2487 { "(bad)", { XX } },
2488 { "roundpd", { XM, EXx, Ib } },
2489 { "(bad)", { XX } },
2490 },
2491
2492 /* PREGRP71 */
2493 {
2494 { "(bad)", { XX } },
2495 { "(bad)", { XX } },
2496 { "roundss", { XM, EXx, Ib } },
2497 { "(bad)", { XX } },
2498 },
2499
2500 /* PREGRP72 */
2501 {
2502 { "(bad)", { XX } },
2503 { "(bad)", { XX } },
2504 { "roundsd", { XM, EXx, Ib } },
2505 { "(bad)", { XX } },
2506 },
2507
2508 /* PREGRP73 */
2509 {
2510 { "(bad)", { XX } },
2511 { "(bad)", { XX } },
2512 { "blendps", { XM, EXx, Ib } },
2513 { "(bad)", { XX } },
2514 },
2515
2516 /* PREGRP74 */
2517 {
2518 { "(bad)", { XX } },
2519 { "(bad)", { XX } },
2520 { "blendpd", { XM, EXx, Ib } },
2521 { "(bad)", { XX } },
2522 },
2523
2524 /* PREGRP75 */
2525 {
2526 { "(bad)", { XX } },
2527 { "(bad)", { XX } },
2528 { "pblendw", { XM, EXx, Ib } },
2529 { "(bad)", { XX } },
2530 },
2531
2532 /* PREGRP76 */
2533 {
2534 { "(bad)", { XX } },
2535 { "(bad)", { XX } },
2536 { "pextrb", { Edqb, XM, Ib } },
2537 { "(bad)", { XX } },
2538 },
2539
2540 /* PREGRP77 */
2541 {
2542 { "(bad)", { XX } },
2543 { "(bad)", { XX } },
2544 { "pextrw", { Edqw, XM, Ib } },
2545 { "(bad)", { XX } },
2546 },
2547
2548 /* PREGRP78 */
2549 {
2550 { "(bad)", { XX } },
2551 { "(bad)", { XX } },
2552 { "pextrK", { Edq, XM, Ib } },
2553 { "(bad)", { XX } },
2554 },
2555
2556 /* PREGRP79 */
2557 {
2558 { "(bad)", { XX } },
2559 { "(bad)", { XX } },
2560 { "extractps", { Edqd, XM, Ib } },
2561 { "(bad)", { XX } },
2562 },
2563
2564 /* PREGRP80 */
2565 {
2566 { "(bad)", { XX } },
2567 { "(bad)", { XX } },
2568 { "pinsrb", { XM, Edqb, Ib } },
2569 { "(bad)", { XX } },
2570 },
2571
2572 /* PREGRP81 */
2573 {
2574 { "(bad)", { XX } },
2575 { "(bad)", { XX } },
2576 { "insertps", { XM, EXx, Ib } },
2577 { "(bad)", { XX } },
2578 },
2579
2580 /* PREGRP82 */
2581 {
2582 { "(bad)", { XX } },
2583 { "(bad)", { XX } },
2584 { "pinsrK", { XM, Edq, Ib } },
2585 { "(bad)", { XX } },
2586 },
2587
2588 /* PREGRP83 */
2589 {
2590 { "(bad)", { XX } },
2591 { "(bad)", { XX } },
2592 { "dpps", { XM, EXx, Ib } },
2593 { "(bad)", { XX } },
2594 },
2595
2596 /* PREGRP84 */
2597 {
2598 { "(bad)", { XX } },
2599 { "(bad)", { XX } },
2600 { "dppd", { XM, EXx, Ib } },
2601 { "(bad)", { XX } },
2602 },
2603
2604 /* PREGRP85 */
2605 {
2606 { "(bad)", { XX } },
2607 { "(bad)", { XX } },
2608 { "mpsadbw", { XM, EXx, Ib } },
2609 { "(bad)", { XX } },
2610 },
2611
2612 /* PREGRP86 */
2613 {
2614 { "(bad)", { XX } },
2615 { "(bad)", { XX } },
2616 { "pcmpgtq", { XM, EXx } },
2617 { "(bad)", { XX } },
2618 },
2619
2620 /* PREGRP87 */
2621 {
2622 { "(bad)", { XX } },
2623 { "(bad)", { XX } },
2624 { "(bad)", { XX } },
2625 { "crc32", { Gdq, { CRC32_Fixup, b_mode } } },
2626 },
2627
2628 /* PREGRP88 */
2629 {
2630 { "(bad)", { XX } },
2631 { "(bad)", { XX } },
2632 { "(bad)", { XX } },
2633 { "crc32", { Gdq, { CRC32_Fixup, v_mode } } },
2634 },
2635
2636 /* PREGRP89 */
2637 {
2638 { "(bad)", { XX } },
2639 { "(bad)", { XX } },
2640 { "pcmpestrm", { XM, EXx, Ib } },
2641 { "(bad)", { XX } },
2642 },
2643
2644 /* PREGRP90 */
2645 {
2646 { "(bad)", { XX } },
2647 { "(bad)", { XX } },
2648 { "pcmpestri", { XM, EXx, Ib } },
2649 { "(bad)", { XX } },
2650 },
2651
2652 /* PREGRP91 */
2653 {
2654 { "(bad)", { XX } },
2655 { "(bad)", { XX } },
2656 { "pcmpistrm", { XM, EXx, Ib } },
2657 { "(bad)", { XX } },
2658 },
2659
2660 /* PREGRP92 */
2661 {
2662 { "(bad)", { XX } },
2663 { "(bad)", { XX } },
2664 { "pcmpistri", { XM, EXx, Ib } },
2665 { "(bad)", { XX } },
2666 },
2667
2668 /* PREGRP93 */
2669 {
2670 { "ucomiss",{ XM, EXd } },
2671 { "(bad)", { XX } },
2672 { "ucomisd",{ XM, EXq } },
2673 { "(bad)", { XX } },
2674 },
2675
2676 /* PREGRP94 */
2677 {
2678 { "comiss", { XM, EXd } },
2679 { "(bad)", { XX } },
2680 { "comisd", { XM, EXq } },
2681 { "(bad)", { XX } },
2682 },
2683
2684 /* PREGRP95 */
2685 {
2686 { "punpcklbw",{ MX, EMd } },
2687 { "(bad)", { XX } },
2688 { "punpcklbw",{ MX, EMq } },
2689 { "(bad)", { XX } },
2690 },
2691
2692 /* PREGRP96 */
2693 {
2694 { "punpcklwd",{ MX, EMd } },
2695 { "(bad)", { XX } },
2696 { "punpcklwd",{ MX, EMq } },
2697 { "(bad)", { XX } },
2698 },
2699
2700 /* PREGRP97 */
2701 {
2702 { "punpckldq",{ MX, EMd } },
2703 { "(bad)", { XX } },
2704 { "punpckldq",{ MX, EMq } },
2705 { "(bad)", { XX } },
2706 },
2707 };
2708
2709 static const struct dis386 x86_64_table[][2] = {
2710 {
2711 { "pusha{P|}", { XX } },
2712 { "(bad)", { XX } },
2713 },
2714 {
2715 { "popa{P|}", { XX } },
2716 { "(bad)", { XX } },
2717 },
2718 {
2719 { "bound{S|}", { Gv, Ma } },
2720 { "(bad)", { XX } },
2721 },
2722 {
2723 { "arpl", { Ew, Gw } },
2724 { "movs{||lq|xd}", { Gv, Ed } },
2725 },
2726 };
2727
2728 static const struct dis386 three_byte_table[][256] = {
2729 /* THREE_BYTE_0 */
2730 {
2731 /* 00 */
2732 { "pshufb", { MX, EM } },
2733 { "phaddw", { MX, EM } },
2734 { "phaddd", { MX, EM } },
2735 { "phaddsw", { MX, EM } },
2736 { "pmaddubsw", { MX, EM } },
2737 { "phsubw", { MX, EM } },
2738 { "phsubd", { MX, EM } },
2739 { "phsubsw", { MX, EM } },
2740 /* 08 */
2741 { "psignb", { MX, EM } },
2742 { "psignw", { MX, EM } },
2743 { "psignd", { MX, EM } },
2744 { "pmulhrsw", { MX, EM } },
2745 { "(bad)", { XX } },
2746 { "(bad)", { XX } },
2747 { "(bad)", { XX } },
2748 { "(bad)", { XX } },
2749 /* 10 */
2750 { PREGRP39 },
2751 { "(bad)", { XX } },
2752 { "(bad)", { XX } },
2753 { "(bad)", { XX } },
2754 { PREGRP40 },
2755 { PREGRP41 },
2756 { "(bad)", { XX } },
2757 { PREGRP42 },
2758 /* 18 */
2759 { "(bad)", { XX } },
2760 { "(bad)", { XX } },
2761 { "(bad)", { XX } },
2762 { "(bad)", { XX } },
2763 { "pabsb", { MX, EM } },
2764 { "pabsw", { MX, EM } },
2765 { "pabsd", { MX, EM } },
2766 { "(bad)", { XX } },
2767 /* 20 */
2768 { PREGRP43 },
2769 { PREGRP44 },
2770 { PREGRP45 },
2771 { PREGRP46 },
2772 { PREGRP47 },
2773 { PREGRP48 },
2774 { "(bad)", { XX } },
2775 { "(bad)", { XX } },
2776 /* 28 */
2777 { PREGRP49 },
2778 { PREGRP50 },
2779 { PREGRP51 },
2780 { PREGRP52 },
2781 { "(bad)", { XX } },
2782 { "(bad)", { XX } },
2783 { "(bad)", { XX } },
2784 { "(bad)", { XX } },
2785 /* 30 */
2786 { PREGRP53 },
2787 { PREGRP54 },
2788 { PREGRP55 },
2789 { PREGRP56 },
2790 { PREGRP57 },
2791 { PREGRP58 },
2792 { "(bad)", { XX } },
2793 { PREGRP86 },
2794 /* 38 */
2795 { PREGRP59 },
2796 { PREGRP60 },
2797 { PREGRP61 },
2798 { PREGRP62 },
2799 { PREGRP63 },
2800 { PREGRP64 },
2801 { PREGRP65 },
2802 { PREGRP66 },
2803 /* 40 */
2804 { PREGRP67 },
2805 { PREGRP68 },
2806 { "(bad)", { XX } },
2807 { "(bad)", { XX } },
2808 { "(bad)", { XX } },
2809 { "(bad)", { XX } },
2810 { "(bad)", { XX } },
2811 { "(bad)", { XX } },
2812 /* 48 */
2813 { "(bad)", { XX } },
2814 { "(bad)", { XX } },
2815 { "(bad)", { XX } },
2816 { "(bad)", { XX } },
2817 { "(bad)", { XX } },
2818 { "(bad)", { XX } },
2819 { "(bad)", { XX } },
2820 { "(bad)", { XX } },
2821 /* 50 */
2822 { "(bad)", { XX } },
2823 { "(bad)", { XX } },
2824 { "(bad)", { XX } },
2825 { "(bad)", { XX } },
2826 { "(bad)", { XX } },
2827 { "(bad)", { XX } },
2828 { "(bad)", { XX } },
2829 { "(bad)", { XX } },
2830 /* 58 */
2831 { "(bad)", { XX } },
2832 { "(bad)", { XX } },
2833 { "(bad)", { XX } },
2834 { "(bad)", { XX } },
2835 { "(bad)", { XX } },
2836 { "(bad)", { XX } },
2837 { "(bad)", { XX } },
2838 { "(bad)", { XX } },
2839 /* 60 */
2840 { "(bad)", { XX } },
2841 { "(bad)", { XX } },
2842 { "(bad)", { XX } },
2843 { "(bad)", { XX } },
2844 { "(bad)", { XX } },
2845 { "(bad)", { XX } },
2846 { "(bad)", { XX } },
2847 { "(bad)", { XX } },
2848 /* 68 */
2849 { "(bad)", { XX } },
2850 { "(bad)", { XX } },
2851 { "(bad)", { XX } },
2852 { "(bad)", { XX } },
2853 { "(bad)", { XX } },
2854 { "(bad)", { XX } },
2855 { "(bad)", { XX } },
2856 { "(bad)", { XX } },
2857 /* 70 */
2858 { "(bad)", { XX } },
2859 { "(bad)", { XX } },
2860 { "(bad)", { XX } },
2861 { "(bad)", { XX } },
2862 { "(bad)", { XX } },
2863 { "(bad)", { XX } },
2864 { "(bad)", { XX } },
2865 { "(bad)", { XX } },
2866 /* 78 */
2867 { "(bad)", { XX } },
2868 { "(bad)", { XX } },
2869 { "(bad)", { XX } },
2870 { "(bad)", { XX } },
2871 { "(bad)", { XX } },
2872 { "(bad)", { XX } },
2873 { "(bad)", { XX } },
2874 { "(bad)", { XX } },
2875 /* 80 */
2876 { "(bad)", { XX } },
2877 { "(bad)", { XX } },
2878 { "(bad)", { XX } },
2879 { "(bad)", { XX } },
2880 { "(bad)", { XX } },
2881 { "(bad)", { XX } },
2882 { "(bad)", { XX } },
2883 { "(bad)", { XX } },
2884 /* 88 */
2885 { "(bad)", { XX } },
2886 { "(bad)", { XX } },
2887 { "(bad)", { XX } },
2888 { "(bad)", { XX } },
2889 { "(bad)", { XX } },
2890 { "(bad)", { XX } },
2891 { "(bad)", { XX } },
2892 { "(bad)", { XX } },
2893 /* 90 */
2894 { "(bad)", { XX } },
2895 { "(bad)", { XX } },
2896 { "(bad)", { XX } },
2897 { "(bad)", { XX } },
2898 { "(bad)", { XX } },
2899 { "(bad)", { XX } },
2900 { "(bad)", { XX } },
2901 { "(bad)", { XX } },
2902 /* 98 */
2903 { "(bad)", { XX } },
2904 { "(bad)", { XX } },
2905 { "(bad)", { XX } },
2906 { "(bad)", { XX } },
2907 { "(bad)", { XX } },
2908 { "(bad)", { XX } },
2909 { "(bad)", { XX } },
2910 { "(bad)", { XX } },
2911 /* a0 */
2912 { "(bad)", { XX } },
2913 { "(bad)", { XX } },
2914 { "(bad)", { XX } },
2915 { "(bad)", { XX } },
2916 { "(bad)", { XX } },
2917 { "(bad)", { XX } },
2918 { "(bad)", { XX } },
2919 { "(bad)", { XX } },
2920 /* a8 */
2921 { "(bad)", { XX } },
2922 { "(bad)", { XX } },
2923 { "(bad)", { XX } },
2924 { "(bad)", { XX } },
2925 { "(bad)", { XX } },
2926 { "(bad)", { XX } },
2927 { "(bad)", { XX } },
2928 { "(bad)", { XX } },
2929 /* b0 */
2930 { "(bad)", { XX } },
2931 { "(bad)", { XX } },
2932 { "(bad)", { XX } },
2933 { "(bad)", { XX } },
2934 { "(bad)", { XX } },
2935 { "(bad)", { XX } },
2936 { "(bad)", { XX } },
2937 { "(bad)", { XX } },
2938 /* b8 */
2939 { "(bad)", { XX } },
2940 { "(bad)", { XX } },
2941 { "(bad)", { XX } },
2942 { "(bad)", { XX } },
2943 { "(bad)", { XX } },
2944 { "(bad)", { XX } },
2945 { "(bad)", { XX } },
2946 { "(bad)", { XX } },
2947 /* c0 */
2948 { "(bad)", { XX } },
2949 { "(bad)", { XX } },
2950 { "(bad)", { XX } },
2951 { "(bad)", { XX } },
2952 { "(bad)", { XX } },
2953 { "(bad)", { XX } },
2954 { "(bad)", { XX } },
2955 { "(bad)", { XX } },
2956 /* c8 */
2957 { "(bad)", { XX } },
2958 { "(bad)", { XX } },
2959 { "(bad)", { XX } },
2960 { "(bad)", { XX } },
2961 { "(bad)", { XX } },
2962 { "(bad)", { XX } },
2963 { "(bad)", { XX } },
2964 { "(bad)", { XX } },
2965 /* d0 */
2966 { "(bad)", { XX } },
2967 { "(bad)", { XX } },
2968 { "(bad)", { XX } },
2969 { "(bad)", { XX } },
2970 { "(bad)", { XX } },
2971 { "(bad)", { XX } },
2972 { "(bad)", { XX } },
2973 { "(bad)", { XX } },
2974 /* d8 */
2975 { "(bad)", { XX } },
2976 { "(bad)", { XX } },
2977 { "(bad)", { XX } },
2978 { "(bad)", { XX } },
2979 { "(bad)", { XX } },
2980 { "(bad)", { XX } },
2981 { "(bad)", { XX } },
2982 { "(bad)", { XX } },
2983 /* e0 */
2984 { "(bad)", { XX } },
2985 { "(bad)", { XX } },
2986 { "(bad)", { XX } },
2987 { "(bad)", { XX } },
2988 { "(bad)", { XX } },
2989 { "(bad)", { XX } },
2990 { "(bad)", { XX } },
2991 { "(bad)", { XX } },
2992 /* e8 */
2993 { "(bad)", { XX } },
2994 { "(bad)", { XX } },
2995 { "(bad)", { XX } },
2996 { "(bad)", { XX } },
2997 { "(bad)", { XX } },
2998 { "(bad)", { XX } },
2999 { "(bad)", { XX } },
3000 { "(bad)", { XX } },
3001 /* f0 */
3002 { PREGRP87 },
3003 { PREGRP88 },
3004 { "(bad)", { XX } },
3005 { "(bad)", { XX } },
3006 { "(bad)", { XX } },
3007 { "(bad)", { XX } },
3008 { "(bad)", { XX } },
3009 { "(bad)", { XX } },
3010 /* f8 */
3011 { "(bad)", { XX } },
3012 { "(bad)", { XX } },
3013 { "(bad)", { XX } },
3014 { "(bad)", { XX } },
3015 { "(bad)", { XX } },
3016 { "(bad)", { XX } },
3017 { "(bad)", { XX } },
3018 { "(bad)", { XX } },
3019 },
3020 /* THREE_BYTE_1 */
3021 {
3022 /* 00 */
3023 { "(bad)", { XX } },
3024 { "(bad)", { XX } },
3025 { "(bad)", { XX } },
3026 { "(bad)", { XX } },
3027 { "(bad)", { XX } },
3028 { "(bad)", { XX } },
3029 { "(bad)", { XX } },
3030 { "(bad)", { XX } },
3031 /* 08 */
3032 { PREGRP69 },
3033 { PREGRP70 },
3034 { PREGRP71 },
3035 { PREGRP72 },
3036 { PREGRP73 },
3037 { PREGRP74 },
3038 { PREGRP75 },
3039 { "palignr", { MX, EM, Ib } },
3040 /* 10 */
3041 { "(bad)", { XX } },
3042 { "(bad)", { XX } },
3043 { "(bad)", { XX } },
3044 { "(bad)", { XX } },
3045 { PREGRP76 },
3046 { PREGRP77 },
3047 { PREGRP78 },
3048 { PREGRP79 },
3049 /* 18 */
3050 { "(bad)", { XX } },
3051 { "(bad)", { XX } },
3052 { "(bad)", { XX } },
3053 { "(bad)", { XX } },
3054 { "(bad)", { XX } },
3055 { "(bad)", { XX } },
3056 { "(bad)", { XX } },
3057 { "(bad)", { XX } },
3058 /* 20 */
3059 { PREGRP80 },
3060 { PREGRP81 },
3061 { PREGRP82 },
3062 { "(bad)", { XX } },
3063 { "(bad)", { XX } },
3064 { "(bad)", { XX } },
3065 { "(bad)", { XX } },
3066 { "(bad)", { XX } },
3067 /* 28 */
3068 { "(bad)", { XX } },
3069 { "(bad)", { XX } },
3070 { "(bad)", { XX } },
3071 { "(bad)", { XX } },
3072 { "(bad)", { XX } },
3073 { "(bad)", { XX } },
3074 { "(bad)", { XX } },
3075 { "(bad)", { XX } },
3076 /* 30 */
3077 { "(bad)", { XX } },
3078 { "(bad)", { XX } },
3079 { "(bad)", { XX } },
3080 { "(bad)", { XX } },
3081 { "(bad)", { XX } },
3082 { "(bad)", { XX } },
3083 { "(bad)", { XX } },
3084 { "(bad)", { XX } },
3085 /* 38 */
3086 { "(bad)", { XX } },
3087 { "(bad)", { XX } },
3088 { "(bad)", { XX } },
3089 { "(bad)", { XX } },
3090 { "(bad)", { XX } },
3091 { "(bad)", { XX } },
3092 { "(bad)", { XX } },
3093 { "(bad)", { XX } },
3094 /* 40 */
3095 { PREGRP83 },
3096 { PREGRP84 },
3097 { PREGRP85 },
3098 { "(bad)", { XX } },
3099 { "(bad)", { XX } },
3100 { "(bad)", { XX } },
3101 { "(bad)", { XX } },
3102 { "(bad)", { XX } },
3103 /* 48 */
3104 { "(bad)", { XX } },
3105 { "(bad)", { XX } },
3106 { "(bad)", { XX } },
3107 { "(bad)", { XX } },
3108 { "(bad)", { XX } },
3109 { "(bad)", { XX } },
3110 { "(bad)", { XX } },
3111 { "(bad)", { XX } },
3112 /* 50 */
3113 { "(bad)", { XX } },
3114 { "(bad)", { XX } },
3115 { "(bad)", { XX } },
3116 { "(bad)", { XX } },
3117 { "(bad)", { XX } },
3118 { "(bad)", { XX } },
3119 { "(bad)", { XX } },
3120 { "(bad)", { XX } },
3121 /* 58 */
3122 { "(bad)", { XX } },
3123 { "(bad)", { XX } },
3124 { "(bad)", { XX } },
3125 { "(bad)", { XX } },
3126 { "(bad)", { XX } },
3127 { "(bad)", { XX } },
3128 { "(bad)", { XX } },
3129 { "(bad)", { XX } },
3130 /* 60 */
3131 { PREGRP89 },
3132 { PREGRP90 },
3133 { PREGRP91 },
3134 { PREGRP92 },
3135 { "(bad)", { XX } },
3136 { "(bad)", { XX } },
3137 { "(bad)", { XX } },
3138 { "(bad)", { XX } },
3139 /* 68 */
3140 { "(bad)", { XX } },
3141 { "(bad)", { XX } },
3142 { "(bad)", { XX } },
3143 { "(bad)", { XX } },
3144 { "(bad)", { XX } },
3145 { "(bad)", { XX } },
3146 { "(bad)", { XX } },
3147 { "(bad)", { XX } },
3148 /* 70 */
3149 { "(bad)", { XX } },
3150 { "(bad)", { XX } },
3151 { "(bad)", { XX } },
3152 { "(bad)", { XX } },
3153 { "(bad)", { XX } },
3154 { "(bad)", { XX } },
3155 { "(bad)", { XX } },
3156 { "(bad)", { XX } },
3157 /* 78 */
3158 { "(bad)", { XX } },
3159 { "(bad)", { XX } },
3160 { "(bad)", { XX } },
3161 { "(bad)", { XX } },
3162 { "(bad)", { XX } },
3163 { "(bad)", { XX } },
3164 { "(bad)", { XX } },
3165 { "(bad)", { XX } },
3166 /* 80 */
3167 { "(bad)", { XX } },
3168 { "(bad)", { XX } },
3169 { "(bad)", { XX } },
3170 { "(bad)", { XX } },
3171 { "(bad)", { XX } },
3172 { "(bad)", { XX } },
3173 { "(bad)", { XX } },
3174 { "(bad)", { XX } },
3175 /* 88 */
3176 { "(bad)", { XX } },
3177 { "(bad)", { XX } },
3178 { "(bad)", { XX } },
3179 { "(bad)", { XX } },
3180 { "(bad)", { XX } },
3181 { "(bad)", { XX } },
3182 { "(bad)", { XX } },
3183 { "(bad)", { XX } },
3184 /* 90 */
3185 { "(bad)", { XX } },
3186 { "(bad)", { XX } },
3187 { "(bad)", { XX } },
3188 { "(bad)", { XX } },
3189 { "(bad)", { XX } },
3190 { "(bad)", { XX } },
3191 { "(bad)", { XX } },
3192 { "(bad)", { XX } },
3193 /* 98 */
3194 { "(bad)", { XX } },
3195 { "(bad)", { XX } },
3196 { "(bad)", { XX } },
3197 { "(bad)", { XX } },
3198 { "(bad)", { XX } },
3199 { "(bad)", { XX } },
3200 { "(bad)", { XX } },
3201 { "(bad)", { XX } },
3202 /* a0 */
3203 { "(bad)", { XX } },
3204 { "(bad)", { XX } },
3205 { "(bad)", { XX } },
3206 { "(bad)", { XX } },
3207 { "(bad)", { XX } },
3208 { "(bad)", { XX } },
3209 { "(bad)", { XX } },
3210 { "(bad)", { XX } },
3211 /* a8 */
3212 { "(bad)", { XX } },
3213 { "(bad)", { XX } },
3214 { "(bad)", { XX } },
3215 { "(bad)", { XX } },
3216 { "(bad)", { XX } },
3217 { "(bad)", { XX } },
3218 { "(bad)", { XX } },
3219 { "(bad)", { XX } },
3220 /* b0 */
3221 { "(bad)", { XX } },
3222 { "(bad)", { XX } },
3223 { "(bad)", { XX } },
3224 { "(bad)", { XX } },
3225 { "(bad)", { XX } },
3226 { "(bad)", { XX } },
3227 { "(bad)", { XX } },
3228 { "(bad)", { XX } },
3229 /* b8 */
3230 { "(bad)", { XX } },
3231 { "(bad)", { XX } },
3232 { "(bad)", { XX } },
3233 { "(bad)", { XX } },
3234 { "(bad)", { XX } },
3235 { "(bad)", { XX } },
3236 { "(bad)", { XX } },
3237 { "(bad)", { XX } },
3238 /* c0 */
3239 { "(bad)", { XX } },
3240 { "(bad)", { XX } },
3241 { "(bad)", { XX } },
3242 { "(bad)", { XX } },
3243 { "(bad)", { XX } },
3244 { "(bad)", { XX } },
3245 { "(bad)", { XX } },
3246 { "(bad)", { XX } },
3247 /* c8 */
3248 { "(bad)", { XX } },
3249 { "(bad)", { XX } },
3250 { "(bad)", { XX } },
3251 { "(bad)", { XX } },
3252 { "(bad)", { XX } },
3253 { "(bad)", { XX } },
3254 { "(bad)", { XX } },
3255 { "(bad)", { XX } },
3256 /* d0 */
3257 { "(bad)", { XX } },
3258 { "(bad)", { XX } },
3259 { "(bad)", { XX } },
3260 { "(bad)", { XX } },
3261 { "(bad)", { XX } },
3262 { "(bad)", { XX } },
3263 { "(bad)", { XX } },
3264 { "(bad)", { XX } },
3265 /* d8 */
3266 { "(bad)", { XX } },
3267 { "(bad)", { XX } },
3268 { "(bad)", { XX } },
3269 { "(bad)", { XX } },
3270 { "(bad)", { XX } },
3271 { "(bad)", { XX } },
3272 { "(bad)", { XX } },
3273 { "(bad)", { XX } },
3274 /* e0 */
3275 { "(bad)", { XX } },
3276 { "(bad)", { XX } },
3277 { "(bad)", { XX } },
3278 { "(bad)", { XX } },
3279 { "(bad)", { XX } },
3280 { "(bad)", { XX } },
3281 { "(bad)", { XX } },
3282 { "(bad)", { XX } },
3283 /* e8 */
3284 { "(bad)", { XX } },
3285 { "(bad)", { XX } },
3286 { "(bad)", { XX } },
3287 { "(bad)", { XX } },
3288 { "(bad)", { XX } },
3289 { "(bad)", { XX } },
3290 { "(bad)", { XX } },
3291 { "(bad)", { XX } },
3292 /* f0 */
3293 { "(bad)", { XX } },
3294 { "(bad)", { XX } },
3295 { "(bad)", { XX } },
3296 { "(bad)", { XX } },
3297 { "(bad)", { XX } },
3298 { "(bad)", { XX } },
3299 { "(bad)", { XX } },
3300 { "(bad)", { XX } },
3301 /* f8 */
3302 { "(bad)", { XX } },
3303 { "(bad)", { XX } },
3304 { "(bad)", { XX } },
3305 { "(bad)", { XX } },
3306 { "(bad)", { XX } },
3307 { "(bad)", { XX } },
3308 { "(bad)", { XX } },
3309 { "(bad)", { XX } },
3310 }
3311 };
3312
3313 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
3314
3315 static void
3316 ckprefix (void)
3317 {
3318 int newrex;
3319 rex = 0;
3320 prefixes = 0;
3321 used_prefixes = 0;
3322 rex_used = 0;
3323 while (1)
3324 {
3325 FETCH_DATA (the_info, codep + 1);
3326 newrex = 0;
3327 switch (*codep)
3328 {
3329 /* REX prefixes family. */
3330 case 0x40:
3331 case 0x41:
3332 case 0x42:
3333 case 0x43:
3334 case 0x44:
3335 case 0x45:
3336 case 0x46:
3337 case 0x47:
3338 case 0x48:
3339 case 0x49:
3340 case 0x4a:
3341 case 0x4b:
3342 case 0x4c:
3343 case 0x4d:
3344 case 0x4e:
3345 case 0x4f:
3346 if (address_mode == mode_64bit)
3347 newrex = *codep;
3348 else
3349 return;
3350 break;
3351 case 0xf3:
3352 prefixes |= PREFIX_REPZ;
3353 break;
3354 case 0xf2:
3355 prefixes |= PREFIX_REPNZ;
3356 break;
3357 case 0xf0:
3358 prefixes |= PREFIX_LOCK;
3359 break;
3360 case 0x2e:
3361 prefixes |= PREFIX_CS;
3362 break;
3363 case 0x36:
3364 prefixes |= PREFIX_SS;
3365 break;
3366 case 0x3e:
3367 prefixes |= PREFIX_DS;
3368 break;
3369 case 0x26:
3370 prefixes |= PREFIX_ES;
3371 break;
3372 case 0x64:
3373 prefixes |= PREFIX_FS;
3374 break;
3375 case 0x65:
3376 prefixes |= PREFIX_GS;
3377 break;
3378 case 0x66:
3379 prefixes |= PREFIX_DATA;
3380 break;
3381 case 0x67:
3382 prefixes |= PREFIX_ADDR;
3383 break;
3384 case FWAIT_OPCODE:
3385 /* fwait is really an instruction. If there are prefixes
3386 before the fwait, they belong to the fwait, *not* to the
3387 following instruction. */
3388 if (prefixes || rex)
3389 {
3390 prefixes |= PREFIX_FWAIT;
3391 codep++;
3392 return;
3393 }
3394 prefixes = PREFIX_FWAIT;
3395 break;
3396 default:
3397 return;
3398 }
3399 /* Rex is ignored when followed by another prefix. */
3400 if (rex)
3401 {
3402 rex_used = rex;
3403 return;
3404 }
3405 rex = newrex;
3406 codep++;
3407 }
3408 }
3409
3410 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
3411 prefix byte. */
3412
3413 static const char *
3414 prefix_name (int pref, int sizeflag)
3415 {
3416 static const char * const rexes [16] =
3417 {
3418 "rex", /* 0x40 */
3419 "rex.B", /* 0x41 */
3420 "rex.X", /* 0x42 */
3421 "rex.XB", /* 0x43 */
3422 "rex.R", /* 0x44 */
3423 "rex.RB", /* 0x45 */
3424 "rex.RX", /* 0x46 */
3425 "rex.RXB", /* 0x47 */
3426 "rex.W", /* 0x48 */
3427 "rex.WB", /* 0x49 */
3428 "rex.WX", /* 0x4a */
3429 "rex.WXB", /* 0x4b */
3430 "rex.WR", /* 0x4c */
3431 "rex.WRB", /* 0x4d */
3432 "rex.WRX", /* 0x4e */
3433 "rex.WRXB", /* 0x4f */
3434 };
3435
3436 switch (pref)
3437 {
3438 /* REX prefixes family. */
3439 case 0x40:
3440 case 0x41:
3441 case 0x42:
3442 case 0x43:
3443 case 0x44:
3444 case 0x45:
3445 case 0x46:
3446 case 0x47:
3447 case 0x48:
3448 case 0x49:
3449 case 0x4a:
3450 case 0x4b:
3451 case 0x4c:
3452 case 0x4d:
3453 case 0x4e:
3454 case 0x4f:
3455 return rexes [pref - 0x40];
3456 case 0xf3:
3457 return "repz";
3458 case 0xf2:
3459 return "repnz";
3460 case 0xf0:
3461 return "lock";
3462 case 0x2e:
3463 return "cs";
3464 case 0x36:
3465 return "ss";
3466 case 0x3e:
3467 return "ds";
3468 case 0x26:
3469 return "es";
3470 case 0x64:
3471 return "fs";
3472 case 0x65:
3473 return "gs";
3474 case 0x66:
3475 return (sizeflag & DFLAG) ? "data16" : "data32";
3476 case 0x67:
3477 if (address_mode == mode_64bit)
3478 return (sizeflag & AFLAG) ? "addr32" : "addr64";
3479 else
3480 return (sizeflag & AFLAG) ? "addr16" : "addr32";
3481 case FWAIT_OPCODE:
3482 return "fwait";
3483 default:
3484 return NULL;
3485 }
3486 }
3487
3488 static char op_out[MAX_OPERANDS][100];
3489 static int op_ad, op_index[MAX_OPERANDS];
3490 static int two_source_ops;
3491 static bfd_vma op_address[MAX_OPERANDS];
3492 static bfd_vma op_riprel[MAX_OPERANDS];
3493 static bfd_vma start_pc;
3494
3495 /*
3496 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
3497 * (see topic "Redundant prefixes" in the "Differences from 8086"
3498 * section of the "Virtual 8086 Mode" chapter.)
3499 * 'pc' should be the address of this instruction, it will
3500 * be used to print the target address if this is a relative jump or call
3501 * The function returns the length of this instruction in bytes.
3502 */
3503
3504 static char intel_syntax;
3505 static char open_char;
3506 static char close_char;
3507 static char separator_char;
3508 static char scale_char;
3509
3510 int
3511 print_insn_i386 (bfd_vma pc, disassemble_info *info)
3512 {
3513 intel_syntax = -1;
3514
3515 return print_insn (pc, info);
3516 }
3517
3518 static int
3519 print_insn (bfd_vma pc, disassemble_info *info)
3520 {
3521 const struct dis386 *dp;
3522 int i;
3523 char *op_txt[MAX_OPERANDS];
3524 int needcomma;
3525 unsigned char uses_DATA_prefix, uses_LOCK_prefix;
3526 unsigned char uses_REPNZ_prefix, uses_REPZ_prefix;
3527 int sizeflag;
3528 const char *p;
3529 struct dis_private priv;
3530 unsigned char op;
3531
3532 if (info->mach == bfd_mach_x86_64_intel_syntax
3533 || info->mach == bfd_mach_x86_64)
3534 address_mode = mode_64bit;
3535 else
3536 address_mode = mode_32bit;
3537
3538 if (intel_syntax == (char) -1)
3539 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
3540 || info->mach == bfd_mach_x86_64_intel_syntax);
3541
3542 if (info->mach == bfd_mach_i386_i386
3543 || info->mach == bfd_mach_x86_64
3544 || info->mach == bfd_mach_i386_i386_intel_syntax
3545 || info->mach == bfd_mach_x86_64_intel_syntax)
3546 priv.orig_sizeflag = AFLAG | DFLAG;
3547 else if (info->mach == bfd_mach_i386_i8086)
3548 priv.orig_sizeflag = 0;
3549 else
3550 abort ();
3551
3552 for (p = info->disassembler_options; p != NULL; )
3553 {
3554 if (strncmp (p, "x86-64", 6) == 0)
3555 {
3556 address_mode = mode_64bit;
3557 priv.orig_sizeflag = AFLAG | DFLAG;
3558 }
3559 else if (strncmp (p, "i386", 4) == 0)
3560 {
3561 address_mode = mode_32bit;
3562 priv.orig_sizeflag = AFLAG | DFLAG;
3563 }
3564 else if (strncmp (p, "i8086", 5) == 0)
3565 {
3566 address_mode = mode_16bit;
3567 priv.orig_sizeflag = 0;
3568 }
3569 else if (strncmp (p, "intel", 5) == 0)
3570 {
3571 intel_syntax = 1;
3572 }
3573 else if (strncmp (p, "att", 3) == 0)
3574 {
3575 intel_syntax = 0;
3576 }
3577 else if (strncmp (p, "addr", 4) == 0)
3578 {
3579 if (address_mode == mode_64bit)
3580 {
3581 if (p[4] == '3' && p[5] == '2')
3582 priv.orig_sizeflag &= ~AFLAG;
3583 else if (p[4] == '6' && p[5] == '4')
3584 priv.orig_sizeflag |= AFLAG;
3585 }
3586 else
3587 {
3588 if (p[4] == '1' && p[5] == '6')
3589 priv.orig_sizeflag &= ~AFLAG;
3590 else if (p[4] == '3' && p[5] == '2')
3591 priv.orig_sizeflag |= AFLAG;
3592 }
3593 }
3594 else if (strncmp (p, "data", 4) == 0)
3595 {
3596 if (p[4] == '1' && p[5] == '6')
3597 priv.orig_sizeflag &= ~DFLAG;
3598 else if (p[4] == '3' && p[5] == '2')
3599 priv.orig_sizeflag |= DFLAG;
3600 }
3601 else if (strncmp (p, "suffix", 6) == 0)
3602 priv.orig_sizeflag |= SUFFIX_ALWAYS;
3603
3604 p = strchr (p, ',');
3605 if (p != NULL)
3606 p++;
3607 }
3608
3609 if (intel_syntax)
3610 {
3611 names64 = intel_names64;
3612 names32 = intel_names32;
3613 names16 = intel_names16;
3614 names8 = intel_names8;
3615 names8rex = intel_names8rex;
3616 names_seg = intel_names_seg;
3617 index16 = intel_index16;
3618 open_char = '[';
3619 close_char = ']';
3620 separator_char = '+';
3621 scale_char = '*';
3622 }
3623 else
3624 {
3625 names64 = att_names64;
3626 names32 = att_names32;
3627 names16 = att_names16;
3628 names8 = att_names8;
3629 names8rex = att_names8rex;
3630 names_seg = att_names_seg;
3631 index16 = att_index16;
3632 open_char = '(';
3633 close_char = ')';
3634 separator_char = ',';
3635 scale_char = ',';
3636 }
3637
3638 /* The output looks better if we put 7 bytes on a line, since that
3639 puts most long word instructions on a single line. */
3640 info->bytes_per_line = 7;
3641
3642 info->private_data = &priv;
3643 priv.max_fetched = priv.the_buffer;
3644 priv.insn_start = pc;
3645
3646 obuf[0] = 0;
3647 for (i = 0; i < MAX_OPERANDS; ++i)
3648 {
3649 op_out[i][0] = 0;
3650 op_index[i] = -1;
3651 }
3652
3653 the_info = info;
3654 start_pc = pc;
3655 start_codep = priv.the_buffer;
3656 codep = priv.the_buffer;
3657
3658 if (setjmp (priv.bailout) != 0)
3659 {
3660 const char *name;
3661
3662 /* Getting here means we tried for data but didn't get it. That
3663 means we have an incomplete instruction of some sort. Just
3664 print the first byte as a prefix or a .byte pseudo-op. */
3665 if (codep > priv.the_buffer)
3666 {
3667 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3668 if (name != NULL)
3669 (*info->fprintf_func) (info->stream, "%s", name);
3670 else
3671 {
3672 /* Just print the first byte as a .byte instruction. */
3673 (*info->fprintf_func) (info->stream, ".byte 0x%x",
3674 (unsigned int) priv.the_buffer[0]);
3675 }
3676
3677 return 1;
3678 }
3679
3680 return -1;
3681 }
3682
3683 obufp = obuf;
3684 ckprefix ();
3685
3686 insn_codep = codep;
3687 sizeflag = priv.orig_sizeflag;
3688
3689 FETCH_DATA (info, codep + 1);
3690 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
3691
3692 if (((prefixes & PREFIX_FWAIT)
3693 && ((*codep < 0xd8) || (*codep > 0xdf)))
3694 || (rex && rex_used))
3695 {
3696 const char *name;
3697
3698 /* fwait not followed by floating point instruction, or rex followed
3699 by other prefixes. Print the first prefix. */
3700 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3701 if (name == NULL)
3702 name = INTERNAL_DISASSEMBLER_ERROR;
3703 (*info->fprintf_func) (info->stream, "%s", name);
3704 return 1;
3705 }
3706
3707 op = 0;
3708 if (*codep == 0x0f)
3709 {
3710 unsigned char threebyte;
3711 FETCH_DATA (info, codep + 2);
3712 threebyte = *++codep;
3713 dp = &dis386_twobyte[threebyte];
3714 need_modrm = twobyte_has_modrm[*codep];
3715 uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep];
3716 uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep];
3717 uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep];
3718 uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
3719 codep++;
3720 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3721 {
3722 FETCH_DATA (info, codep + 2);
3723 op = *codep++;
3724 switch (threebyte)
3725 {
3726 case 0x38:
3727 uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op];
3728 uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op];
3729 uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op];
3730 break;
3731 case 0x3a:
3732 uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op];
3733 uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op];
3734 uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op];
3735 break;
3736 default:
3737 break;
3738 }
3739 }
3740 }
3741 else
3742 {
3743 dp = &dis386[*codep];
3744 need_modrm = onebyte_has_modrm[*codep];
3745 uses_DATA_prefix = 0;
3746 uses_REPNZ_prefix = 0;
3747 /* pause is 0xf3 0x90. */
3748 uses_REPZ_prefix = *codep == 0x90;
3749 uses_LOCK_prefix = 0;
3750 codep++;
3751 }
3752
3753 if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ))
3754 {
3755 oappend ("repz ");
3756 used_prefixes |= PREFIX_REPZ;
3757 }
3758 if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ))
3759 {
3760 oappend ("repnz ");
3761 used_prefixes |= PREFIX_REPNZ;
3762 }
3763
3764 if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
3765 {
3766 oappend ("lock ");
3767 used_prefixes |= PREFIX_LOCK;
3768 }
3769
3770 if (prefixes & PREFIX_ADDR)
3771 {
3772 sizeflag ^= AFLAG;
3773 if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
3774 {
3775 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
3776 oappend ("addr32 ");
3777 else
3778 oappend ("addr16 ");
3779 used_prefixes |= PREFIX_ADDR;
3780 }
3781 }
3782
3783 if (!uses_DATA_prefix && (prefixes & PREFIX_DATA))
3784 {
3785 sizeflag ^= DFLAG;
3786 if (dp->op[2].bytemode == cond_jump_mode
3787 && dp->op[0].bytemode == v_mode
3788 && !intel_syntax)
3789 {
3790 if (sizeflag & DFLAG)
3791 oappend ("data32 ");
3792 else
3793 oappend ("data16 ");
3794 used_prefixes |= PREFIX_DATA;
3795 }
3796 }
3797
3798 if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
3799 {
3800 dp = &three_byte_table[dp->op[1].bytemode][op];
3801 modrm.mod = (*codep >> 6) & 3;
3802 modrm.reg = (*codep >> 3) & 7;
3803 modrm.rm = *codep & 7;
3804 }
3805 else if (need_modrm)
3806 {
3807 FETCH_DATA (info, codep + 1);
3808 modrm.mod = (*codep >> 6) & 3;
3809 modrm.reg = (*codep >> 3) & 7;
3810 modrm.rm = *codep & 7;
3811 }
3812
3813 if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
3814 {
3815 dofloat (sizeflag);
3816 }
3817 else
3818 {
3819 int index;
3820 if (dp->name == NULL)
3821 {
3822 switch (dp->op[0].bytemode)
3823 {
3824 case USE_GROUPS:
3825 dp = &grps[dp->op[1].bytemode][modrm.reg];
3826 break;
3827
3828 case USE_PREFIX_USER_TABLE:
3829 index = 0;
3830 used_prefixes |= (prefixes & PREFIX_REPZ);
3831 if (prefixes & PREFIX_REPZ)
3832 index = 1;
3833 else
3834 {
3835 /* We should check PREFIX_REPNZ and PREFIX_REPZ
3836 before PREFIX_DATA. */
3837 used_prefixes |= (prefixes & PREFIX_REPNZ);
3838 if (prefixes & PREFIX_REPNZ)
3839 index = 3;
3840 else
3841 {
3842 used_prefixes |= (prefixes & PREFIX_DATA);
3843 if (prefixes & PREFIX_DATA)
3844 index = 2;
3845 }
3846 }
3847 dp = &prefix_user_table[dp->op[1].bytemode][index];
3848 break;
3849
3850 case X86_64_SPECIAL:
3851 index = address_mode == mode_64bit ? 1 : 0;
3852 dp = &x86_64_table[dp->op[1].bytemode][index];
3853 break;
3854
3855 default:
3856 oappend (INTERNAL_DISASSEMBLER_ERROR);
3857 break;
3858 }
3859 }
3860
3861 if (putop (dp->name, sizeflag) == 0)
3862 {
3863 for (i = 0; i < MAX_OPERANDS; ++i)
3864 {
3865 obufp = op_out[i];
3866 op_ad = MAX_OPERANDS - 1 - i;
3867 if (dp->op[i].rtn)
3868 (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
3869 }
3870 }
3871 }
3872
3873 /* See if any prefixes were not used. If so, print the first one
3874 separately. If we don't do this, we'll wind up printing an
3875 instruction stream which does not precisely correspond to the
3876 bytes we are disassembling. */
3877 if ((prefixes & ~used_prefixes) != 0)
3878 {
3879 const char *name;
3880
3881 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
3882 if (name == NULL)
3883 name = INTERNAL_DISASSEMBLER_ERROR;
3884 (*info->fprintf_func) (info->stream, "%s", name);
3885 return 1;
3886 }
3887 if (rex & ~rex_used)
3888 {
3889 const char *name;
3890 name = prefix_name (rex | 0x40, priv.orig_sizeflag);
3891 if (name == NULL)
3892 name = INTERNAL_DISASSEMBLER_ERROR;
3893 (*info->fprintf_func) (info->stream, "%s ", name);
3894 }
3895
3896 obufp = obuf + strlen (obuf);
3897 for (i = strlen (obuf); i < 6; i++)
3898 oappend (" ");
3899 oappend (" ");
3900 (*info->fprintf_func) (info->stream, "%s", obuf);
3901
3902 /* The enter and bound instructions are printed with operands in the same
3903 order as the intel book; everything else is printed in reverse order. */
3904 if (intel_syntax || two_source_ops)
3905 {
3906 bfd_vma riprel;
3907
3908 for (i = 0; i < MAX_OPERANDS; ++i)
3909 op_txt[i] = op_out[i];
3910
3911 for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
3912 {
3913 op_ad = op_index[i];
3914 op_index[i] = op_index[MAX_OPERANDS - 1 - i];
3915 op_index[MAX_OPERANDS - 1 - i] = op_ad;
3916 riprel = op_riprel[i];
3917 op_riprel[i] = op_riprel [MAX_OPERANDS - 1 - i];
3918 op_riprel[MAX_OPERANDS - 1 - i] = riprel;
3919 }
3920 }
3921 else
3922 {
3923 for (i = 0; i < MAX_OPERANDS; ++i)
3924 op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
3925 }
3926
3927 needcomma = 0;
3928 for (i = 0; i < MAX_OPERANDS; ++i)
3929 if (*op_txt[i])
3930 {
3931 if (needcomma)
3932 (*info->fprintf_func) (info->stream, ",");
3933 if (op_index[i] != -1 && !op_riprel[i])
3934 (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
3935 else
3936 (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
3937 needcomma = 1;
3938 }
3939
3940 for (i = 0; i < MAX_OPERANDS; i++)
3941 if (op_index[i] != -1 && op_riprel[i])
3942 {
3943 (*info->fprintf_func) (info->stream, " # ");
3944 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
3945 + op_address[op_index[i]]), info);
3946 break;
3947 }
3948 return codep - priv.the_buffer;
3949 }
3950
3951 static const char *float_mem[] = {
3952 /* d8 */
3953 "fadd{s||s|}",
3954 "fmul{s||s|}",
3955 "fcom{s||s|}",
3956 "fcomp{s||s|}",
3957 "fsub{s||s|}",
3958 "fsubr{s||s|}",
3959 "fdiv{s||s|}",
3960 "fdivr{s||s|}",
3961 /* d9 */
3962 "fld{s||s|}",
3963 "(bad)",
3964 "fst{s||s|}",
3965 "fstp{s||s|}",
3966 "fldenvIC",
3967 "fldcw",
3968 "fNstenvIC",
3969 "fNstcw",
3970 /* da */
3971 "fiadd{l||l|}",
3972 "fimul{l||l|}",
3973 "ficom{l||l|}",
3974 "ficomp{l||l|}",
3975 "fisub{l||l|}",
3976 "fisubr{l||l|}",
3977 "fidiv{l||l|}",
3978 "fidivr{l||l|}",
3979 /* db */
3980 "fild{l||l|}",
3981 "fisttp{l||l|}",
3982 "fist{l||l|}",
3983 "fistp{l||l|}",
3984 "(bad)",
3985 "fld{t||t|}",
3986 "(bad)",
3987 "fstp{t||t|}",
3988 /* dc */
3989 "fadd{l||l|}",
3990 "fmul{l||l|}",
3991 "fcom{l||l|}",
3992 "fcomp{l||l|}",
3993 "fsub{l||l|}",
3994 "fsubr{l||l|}",
3995 "fdiv{l||l|}",
3996 "fdivr{l||l|}",
3997 /* dd */
3998 "fld{l||l|}",
3999 "fisttp{ll||ll|}",
4000 "fst{l||l|}",
4001 "fstp{l||l|}",
4002 "frstorIC",
4003 "(bad)",
4004 "fNsaveIC",
4005 "fNstsw",
4006 /* de */
4007 "fiadd",
4008 "fimul",
4009 "ficom",
4010 "ficomp",
4011 "fisub",
4012 "fisubr",
4013 "fidiv",
4014 "fidivr",
4015 /* df */
4016 "fild",
4017 "fisttp",
4018 "fist",
4019 "fistp",
4020 "fbld",
4021 "fild{ll||ll|}",
4022 "fbstp",
4023 "fistp{ll||ll|}",
4024 };
4025
4026 static const unsigned char float_mem_mode[] = {
4027 /* d8 */
4028 d_mode,
4029 d_mode,
4030 d_mode,
4031 d_mode,
4032 d_mode,
4033 d_mode,
4034 d_mode,
4035 d_mode,
4036 /* d9 */
4037 d_mode,
4038 0,
4039 d_mode,
4040 d_mode,
4041 0,
4042 w_mode,
4043 0,
4044 w_mode,
4045 /* da */
4046 d_mode,
4047 d_mode,
4048 d_mode,
4049 d_mode,
4050 d_mode,
4051 d_mode,
4052 d_mode,
4053 d_mode,
4054 /* db */
4055 d_mode,
4056 d_mode,
4057 d_mode,
4058 d_mode,
4059 0,
4060 t_mode,
4061 0,
4062 t_mode,
4063 /* dc */
4064 q_mode,
4065 q_mode,
4066 q_mode,
4067 q_mode,
4068 q_mode,
4069 q_mode,
4070 q_mode,
4071 q_mode,
4072 /* dd */
4073 q_mode,
4074 q_mode,
4075 q_mode,
4076 q_mode,
4077 0,
4078 0,
4079 0,
4080 w_mode,
4081 /* de */
4082 w_mode,
4083 w_mode,
4084 w_mode,
4085 w_mode,
4086 w_mode,
4087 w_mode,
4088 w_mode,
4089 w_mode,
4090 /* df */
4091 w_mode,
4092 w_mode,
4093 w_mode,
4094 w_mode,
4095 t_mode,
4096 q_mode,
4097 t_mode,
4098 q_mode
4099 };
4100
4101 #define ST { OP_ST, 0 }
4102 #define STi { OP_STi, 0 }
4103
4104 #define FGRPd9_2 NULL, { { NULL, 0 } }
4105 #define FGRPd9_4 NULL, { { NULL, 1 } }
4106 #define FGRPd9_5 NULL, { { NULL, 2 } }
4107 #define FGRPd9_6 NULL, { { NULL, 3 } }
4108 #define FGRPd9_7 NULL, { { NULL, 4 } }
4109 #define FGRPda_5 NULL, { { NULL, 5 } }
4110 #define FGRPdb_4 NULL, { { NULL, 6 } }
4111 #define FGRPde_3 NULL, { { NULL, 7 } }
4112 #define FGRPdf_4 NULL, { { NULL, 8 } }
4113
4114 static const struct dis386 float_reg[][8] = {
4115 /* d8 */
4116 {
4117 { "fadd", { ST, STi } },
4118 { "fmul", { ST, STi } },
4119 { "fcom", { STi } },
4120 { "fcomp", { STi } },
4121 { "fsub", { ST, STi } },
4122 { "fsubr", { ST, STi } },
4123 { "fdiv", { ST, STi } },
4124 { "fdivr", { ST, STi } },
4125 },
4126 /* d9 */
4127 {
4128 { "fld", { STi } },
4129 { "fxch", { STi } },
4130 { FGRPd9_2 },
4131 { "(bad)", { XX } },
4132 { FGRPd9_4 },
4133 { FGRPd9_5 },
4134 { FGRPd9_6 },
4135 { FGRPd9_7 },
4136 },
4137 /* da */
4138 {
4139 { "fcmovb", { ST, STi } },
4140 { "fcmove", { ST, STi } },
4141 { "fcmovbe",{ ST, STi } },
4142 { "fcmovu", { ST, STi } },
4143 { "(bad)", { XX } },
4144 { FGRPda_5 },
4145 { "(bad)", { XX } },
4146 { "(bad)", { XX } },
4147 },
4148 /* db */
4149 {
4150 { "fcmovnb",{ ST, STi } },
4151 { "fcmovne",{ ST, STi } },
4152 { "fcmovnbe",{ ST, STi } },
4153 { "fcmovnu",{ ST, STi } },
4154 { FGRPdb_4 },
4155 { "fucomi", { ST, STi } },
4156 { "fcomi", { ST, STi } },
4157 { "(bad)", { XX } },
4158 },
4159 /* dc */
4160 {
4161 { "fadd", { STi, ST } },
4162 { "fmul", { STi, ST } },
4163 { "(bad)", { XX } },
4164 { "(bad)", { XX } },
4165 #if SYSV386_COMPAT
4166 { "fsub", { STi, ST } },
4167 { "fsubr", { STi, ST } },
4168 { "fdiv", { STi, ST } },
4169 { "fdivr", { STi, ST } },
4170 #else
4171 { "fsubr", { STi, ST } },
4172 { "fsub", { STi, ST } },
4173 { "fdivr", { STi, ST } },
4174 { "fdiv", { STi, ST } },
4175 #endif
4176 },
4177 /* dd */
4178 {
4179 { "ffree", { STi } },
4180 { "(bad)", { XX } },
4181 { "fst", { STi } },
4182 { "fstp", { STi } },
4183 { "fucom", { STi } },
4184 { "fucomp", { STi } },
4185 { "(bad)", { XX } },
4186 { "(bad)", { XX } },
4187 },
4188 /* de */
4189 {
4190 { "faddp", { STi, ST } },
4191 { "fmulp", { STi, ST } },
4192 { "(bad)", { XX } },
4193 { FGRPde_3 },
4194 #if SYSV386_COMPAT
4195 { "fsubp", { STi, ST } },
4196 { "fsubrp", { STi, ST } },
4197 { "fdivp", { STi, ST } },
4198 { "fdivrp", { STi, ST } },
4199 #else
4200 { "fsubrp", { STi, ST } },
4201 { "fsubp", { STi, ST } },
4202 { "fdivrp", { STi, ST } },
4203 { "fdivp", { STi, ST } },
4204 #endif
4205 },
4206 /* df */
4207 {
4208 { "ffreep", { STi } },
4209 { "(bad)", { XX } },
4210 { "(bad)", { XX } },
4211 { "(bad)", { XX } },
4212 { FGRPdf_4 },
4213 { "fucomip", { ST, STi } },
4214 { "fcomip", { ST, STi } },
4215 { "(bad)", { XX } },
4216 },
4217 };
4218
4219 static const char *fgrps[][8] = {
4220 /* d9_2 0 */
4221 {
4222 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4223 },
4224
4225 /* d9_4 1 */
4226 {
4227 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
4228 },
4229
4230 /* d9_5 2 */
4231 {
4232 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
4233 },
4234
4235 /* d9_6 3 */
4236 {
4237 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
4238 },
4239
4240 /* d9_7 4 */
4241 {
4242 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
4243 },
4244
4245 /* da_5 5 */
4246 {
4247 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4248 },
4249
4250 /* db_4 6 */
4251 {
4252 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
4253 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
4254 },
4255
4256 /* de_3 7 */
4257 {
4258 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4259 },
4260
4261 /* df_4 8 */
4262 {
4263 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
4264 },
4265 };
4266
4267 static void
4268 dofloat (int sizeflag)
4269 {
4270 const struct dis386 *dp;
4271 unsigned char floatop;
4272
4273 floatop = codep[-1];
4274
4275 if (modrm.mod != 3)
4276 {
4277 int fp_indx = (floatop - 0xd8) * 8 + modrm.reg;
4278
4279 putop (float_mem[fp_indx], sizeflag);
4280 obufp = op_out[0];
4281 op_ad = 2;
4282 OP_E (float_mem_mode[fp_indx], sizeflag);
4283 return;
4284 }
4285 /* Skip mod/rm byte. */
4286 MODRM_CHECK;
4287 codep++;
4288
4289 dp = &float_reg[floatop - 0xd8][modrm.reg];
4290 if (dp->name == NULL)
4291 {
4292 putop (fgrps[dp->op[0].bytemode][modrm.rm], sizeflag);
4293
4294 /* Instruction fnstsw is only one with strange arg. */
4295 if (floatop == 0xdf && codep[-1] == 0xe0)
4296 pstrcpy (op_out[0], sizeof(op_out[0]), names16[0]);
4297 }
4298 else
4299 {
4300 putop (dp->name, sizeflag);
4301
4302 obufp = op_out[0];
4303 op_ad = 2;
4304 if (dp->op[0].rtn)
4305 (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);
4306
4307 obufp = op_out[1];
4308 op_ad = 1;
4309 if (dp->op[1].rtn)
4310 (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
4311 }
4312 }
4313
4314 static void
4315 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4316 {
4317 oappend ("%st" + intel_syntax);
4318 }
4319
4320 static void
4321 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4322 {
4323 snprintf (scratchbuf, sizeof(scratchbuf), "%%st(%d)", modrm.rm);
4324 oappend (scratchbuf + intel_syntax);
4325 }
4326
4327 /* Capital letters in template are macros. */
4328 static int
4329 putop (const char *template, int sizeflag)
4330 {
4331 const char *p;
4332 int alt = 0;
4333
4334 for (p = template; *p; p++)
4335 {
4336 switch (*p)
4337 {
4338 default:
4339 *obufp++ = *p;
4340 break;
4341 case '{':
4342 alt = 0;
4343 if (intel_syntax)
4344 alt += 1;
4345 if (address_mode == mode_64bit)
4346 alt += 2;
4347 while (alt != 0)
4348 {
4349 while (*++p != '|')
4350 {
4351 if (*p == '}')
4352 {
4353 /* Alternative not valid. */
4354 pstrcpy (obuf, sizeof(obuf), "(bad)");
4355 obufp = obuf + 5;
4356 return 1;
4357 }
4358 else if (*p == '\0')
4359 abort ();
4360 }
4361 alt--;
4362 }
4363 /* Fall through. */
4364 case 'I':
4365 alt = 1;
4366 continue;
4367 case '|':
4368 while (*++p != '}')
4369 {
4370 if (*p == '\0')
4371 abort ();
4372 }
4373 break;
4374 case '}':
4375 break;
4376 case 'A':
4377 if (intel_syntax)
4378 break;
4379 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4380 *obufp++ = 'b';
4381 break;
4382 case 'B':
4383 if (intel_syntax)
4384 break;
4385 if (sizeflag & SUFFIX_ALWAYS)
4386 *obufp++ = 'b';
4387 break;
4388 case 'C':
4389 if (intel_syntax && !alt)
4390 break;
4391 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
4392 {
4393 if (sizeflag & DFLAG)
4394 *obufp++ = intel_syntax ? 'd' : 'l';
4395 else
4396 *obufp++ = intel_syntax ? 'w' : 's';
4397 used_prefixes |= (prefixes & PREFIX_DATA);
4398 }
4399 break;
4400 case 'D':
4401 if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
4402 break;
4403 USED_REX (REX_W);
4404 if (modrm.mod == 3)
4405 {
4406 if (rex & REX_W)
4407 *obufp++ = 'q';
4408 else if (sizeflag & DFLAG)
4409 *obufp++ = intel_syntax ? 'd' : 'l';
4410 else
4411 *obufp++ = 'w';
4412 used_prefixes |= (prefixes & PREFIX_DATA);
4413 }
4414 else
4415 *obufp++ = 'w';
4416 break;
4417 case 'E': /* For jcxz/jecxz */
4418 if (address_mode == mode_64bit)
4419 {
4420 if (sizeflag & AFLAG)
4421 *obufp++ = 'r';
4422 else
4423 *obufp++ = 'e';
4424 }
4425 else
4426 if (sizeflag & AFLAG)
4427 *obufp++ = 'e';
4428 used_prefixes |= (prefixes & PREFIX_ADDR);
4429 break;
4430 case 'F':
4431 if (intel_syntax)
4432 break;
4433 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
4434 {
4435 if (sizeflag & AFLAG)
4436 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
4437 else
4438 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
4439 used_prefixes |= (prefixes & PREFIX_ADDR);
4440 }
4441 break;
4442 case 'G':
4443 if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
4444 break;
4445 if ((rex & REX_W) || (sizeflag & DFLAG))
4446 *obufp++ = 'l';
4447 else
4448 *obufp++ = 'w';
4449 if (!(rex & REX_W))
4450 used_prefixes |= (prefixes & PREFIX_DATA);
4451 break;
4452 case 'H':
4453 if (intel_syntax)
4454 break;
4455 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
4456 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
4457 {
4458 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
4459 *obufp++ = ',';
4460 *obufp++ = 'p';
4461 if (prefixes & PREFIX_DS)
4462 *obufp++ = 't';
4463 else
4464 *obufp++ = 'n';
4465 }
4466 break;
4467 case 'J':
4468 if (intel_syntax)
4469 break;
4470 *obufp++ = 'l';
4471 break;
4472 case 'K':
4473 USED_REX (REX_W);
4474 if (rex & REX_W)
4475 *obufp++ = 'q';
4476 else
4477 *obufp++ = 'd';
4478 break;
4479 case 'Z':
4480 if (intel_syntax)
4481 break;
4482 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
4483 {
4484 *obufp++ = 'q';
4485 break;
4486 }
4487 /* Fall through. */
4488 case 'L':
4489 if (intel_syntax)
4490 break;
4491 if (sizeflag & SUFFIX_ALWAYS)
4492 *obufp++ = 'l';
4493 break;
4494 case 'N':
4495 if ((prefixes & PREFIX_FWAIT) == 0)
4496 *obufp++ = 'n';
4497 else
4498 used_prefixes |= PREFIX_FWAIT;
4499 break;
4500 case 'O':
4501 USED_REX (REX_W);
4502 if (rex & REX_W)
4503 *obufp++ = 'o';
4504 else if (intel_syntax && (sizeflag & DFLAG))
4505 *obufp++ = 'q';
4506 else
4507 *obufp++ = 'd';
4508 if (!(rex & REX_W))
4509 used_prefixes |= (prefixes & PREFIX_DATA);
4510 break;
4511 case 'T':
4512 if (intel_syntax)
4513 break;
4514 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4515 {
4516 *obufp++ = 'q';
4517 break;
4518 }
4519 /* Fall through. */
4520 case 'P':
4521 if (intel_syntax)
4522 break;
4523 if ((prefixes & PREFIX_DATA)
4524 || (rex & REX_W)
4525 || (sizeflag & SUFFIX_ALWAYS))
4526 {
4527 USED_REX (REX_W);
4528 if (rex & REX_W)
4529 *obufp++ = 'q';
4530 else
4531 {
4532 if (sizeflag & DFLAG)
4533 *obufp++ = 'l';
4534 else
4535 *obufp++ = 'w';
4536 }
4537 used_prefixes |= (prefixes & PREFIX_DATA);
4538 }
4539 break;
4540 case 'U':
4541 if (intel_syntax)
4542 break;
4543 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4544 {
4545 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4546 *obufp++ = 'q';
4547 break;
4548 }
4549 /* Fall through. */
4550 case 'Q':
4551 if (intel_syntax && !alt)
4552 break;
4553 USED_REX (REX_W);
4554 if (modrm.mod != 3 || (sizeflag & SUFFIX_ALWAYS))
4555 {
4556 if (rex & REX_W)
4557 *obufp++ = 'q';
4558 else
4559 {
4560 if (sizeflag & DFLAG)
4561 *obufp++ = intel_syntax ? 'd' : 'l';
4562 else
4563 *obufp++ = 'w';
4564 }
4565 used_prefixes |= (prefixes & PREFIX_DATA);
4566 }
4567 break;
4568 case 'R':
4569 USED_REX (REX_W);
4570 if (rex & REX_W)
4571 *obufp++ = 'q';
4572 else if (sizeflag & DFLAG)
4573 {
4574 if (intel_syntax)
4575 *obufp++ = 'd';
4576 else
4577 *obufp++ = 'l';
4578 }
4579 else
4580 *obufp++ = 'w';
4581 if (intel_syntax && !p[1]
4582 && ((rex & REX_W) || (sizeflag & DFLAG)))
4583 *obufp++ = 'e';
4584 if (!(rex & REX_W))
4585 used_prefixes |= (prefixes & PREFIX_DATA);
4586 break;
4587 case 'V':
4588 if (intel_syntax)
4589 break;
4590 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4591 {
4592 if (sizeflag & SUFFIX_ALWAYS)
4593 *obufp++ = 'q';
4594 break;
4595 }
4596 /* Fall through. */
4597 case 'S':
4598 if (intel_syntax)
4599 break;
4600 if (sizeflag & SUFFIX_ALWAYS)
4601 {
4602 if (rex & REX_W)
4603 *obufp++ = 'q';
4604 else
4605 {
4606 if (sizeflag & DFLAG)
4607 *obufp++ = 'l';
4608 else
4609 *obufp++ = 'w';
4610 used_prefixes |= (prefixes & PREFIX_DATA);
4611 }
4612 }
4613 break;
4614 case 'X':
4615 if (prefixes & PREFIX_DATA)
4616 *obufp++ = 'd';
4617 else
4618 *obufp++ = 's';
4619 used_prefixes |= (prefixes & PREFIX_DATA);
4620 break;
4621 case 'Y':
4622 if (intel_syntax)
4623 break;
4624 if (rex & REX_W)
4625 {
4626 USED_REX (REX_W);
4627 *obufp++ = 'q';
4628 }
4629 break;
4630 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
4631 case 'W':
4632 /* operand size flag for cwtl, cbtw */
4633 USED_REX (REX_W);
4634 if (rex & REX_W)
4635 {
4636 if (intel_syntax)
4637 *obufp++ = 'd';
4638 else
4639 *obufp++ = 'l';
4640 }
4641 else if (sizeflag & DFLAG)
4642 *obufp++ = 'w';
4643 else
4644 *obufp++ = 'b';
4645 if (!(rex & REX_W))
4646 used_prefixes |= (prefixes & PREFIX_DATA);
4647 break;
4648 }
4649 alt = 0;
4650 }
4651 *obufp = 0;
4652 return 0;
4653 }
4654
4655 static void
4656 oappend (const char *s)
4657 {
4658 strcpy (obufp, s);
4659 obufp += strlen (s);
4660 }
4661
4662 static void
4663 append_seg (void)
4664 {
4665 if (prefixes & PREFIX_CS)
4666 {
4667 used_prefixes |= PREFIX_CS;
4668 oappend ("%cs:" + intel_syntax);
4669 }
4670 if (prefixes & PREFIX_DS)
4671 {
4672 used_prefixes |= PREFIX_DS;
4673 oappend ("%ds:" + intel_syntax);
4674 }
4675 if (prefixes & PREFIX_SS)
4676 {
4677 used_prefixes |= PREFIX_SS;
4678 oappend ("%ss:" + intel_syntax);
4679 }
4680 if (prefixes & PREFIX_ES)
4681 {
4682 used_prefixes |= PREFIX_ES;
4683 oappend ("%es:" + intel_syntax);
4684 }
4685 if (prefixes & PREFIX_FS)
4686 {
4687 used_prefixes |= PREFIX_FS;
4688 oappend ("%fs:" + intel_syntax);
4689 }
4690 if (prefixes & PREFIX_GS)
4691 {
4692 used_prefixes |= PREFIX_GS;
4693 oappend ("%gs:" + intel_syntax);
4694 }
4695 }
4696
4697 static void
4698 OP_indirE (int bytemode, int sizeflag)
4699 {
4700 if (!intel_syntax)
4701 oappend ("*");
4702 OP_E (bytemode, sizeflag);
4703 }
4704
4705 static void
4706 print_operand_value (char *buf, size_t bufsize, int hex, bfd_vma disp)
4707 {
4708 if (address_mode == mode_64bit)
4709 {
4710 if (hex)
4711 {
4712 char tmp[30];
4713 int i;
4714 buf[0] = '0';
4715 buf[1] = 'x';
4716 snprintf_vma (tmp, sizeof(tmp), disp);
4717 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
4718 pstrcpy (buf + 2, bufsize - 2, tmp + i);
4719 }
4720 else
4721 {
4722 bfd_signed_vma v = disp;
4723 char tmp[30];
4724 int i;
4725 if (v < 0)
4726 {
4727 *(buf++) = '-';
4728 v = -disp;
4729 /* Check for possible overflow on 0x8000000000000000. */
4730 if (v < 0)
4731 {
4732 pstrcpy (buf, bufsize, "9223372036854775808");
4733 return;
4734 }
4735 }
4736 if (!v)
4737 {
4738 pstrcpy (buf, bufsize, "0");
4739 return;
4740 }
4741
4742 i = 0;
4743 tmp[29] = 0;
4744 while (v)
4745 {
4746 tmp[28 - i] = (v % 10) + '0';
4747 v /= 10;
4748 i++;
4749 }
4750 pstrcpy (buf, bufsize, tmp + 29 - i);
4751 }
4752 }
4753 else
4754 {
4755 if (hex)
4756 snprintf (buf, bufsize, "0x%x", (unsigned int) disp);
4757 else
4758 snprintf (buf, bufsize, "%d", (int) disp);
4759 }
4760 }
4761
4762 /* Put DISP in BUF as signed hex number. */
4763
4764 static void
4765 print_displacement (char *buf, bfd_vma disp)
4766 {
4767 bfd_signed_vma val = disp;
4768 char tmp[30];
4769 int i, j = 0;
4770
4771 if (val < 0)
4772 {
4773 buf[j++] = '-';
4774 val = -disp;
4775
4776 /* Check for possible overflow. */
4777 if (val < 0)
4778 {
4779 switch (address_mode)
4780 {
4781 case mode_64bit:
4782 strcpy (buf + j, "0x8000000000000000");
4783 break;
4784 case mode_32bit:
4785 strcpy (buf + j, "0x80000000");
4786 break;
4787 case mode_16bit:
4788 strcpy (buf + j, "0x8000");
4789 break;
4790 }
4791 return;
4792 }
4793 }
4794
4795 buf[j++] = '0';
4796 buf[j++] = 'x';
4797
4798 snprintf_vma (tmp, sizeof(tmp), val);
4799 for (i = 0; tmp[i] == '0'; i++)
4800 continue;
4801 if (tmp[i] == '\0')
4802 i--;
4803 strcpy (buf + j, tmp + i);
4804 }
4805
4806 static void
4807 intel_operand_size (int bytemode, int sizeflag)
4808 {
4809 switch (bytemode)
4810 {
4811 case b_mode:
4812 case dqb_mode:
4813 oappend ("BYTE PTR ");
4814 break;
4815 case w_mode:
4816 case dqw_mode:
4817 oappend ("WORD PTR ");
4818 break;
4819 case stack_v_mode:
4820 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4821 {
4822 oappend ("QWORD PTR ");
4823 used_prefixes |= (prefixes & PREFIX_DATA);
4824 break;
4825 }
4826 /* FALLTHRU */
4827 case v_mode:
4828 case dq_mode:
4829 USED_REX (REX_W);
4830 if (rex & REX_W)
4831 oappend ("QWORD PTR ");
4832 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
4833 oappend ("DWORD PTR ");
4834 else
4835 oappend ("WORD PTR ");
4836 used_prefixes |= (prefixes & PREFIX_DATA);
4837 break;
4838 case z_mode:
4839 if ((rex & REX_W) || (sizeflag & DFLAG))
4840 *obufp++ = 'D';
4841 oappend ("WORD PTR ");
4842 if (!(rex & REX_W))
4843 used_prefixes |= (prefixes & PREFIX_DATA);
4844 break;
4845 case d_mode:
4846 case dqd_mode:
4847 oappend ("DWORD PTR ");
4848 break;
4849 case q_mode:
4850 oappend ("QWORD PTR ");
4851 break;
4852 case m_mode:
4853 if (address_mode == mode_64bit)
4854 oappend ("QWORD PTR ");
4855 else
4856 oappend ("DWORD PTR ");
4857 break;
4858 case f_mode:
4859 if (sizeflag & DFLAG)
4860 oappend ("FWORD PTR ");
4861 else
4862 oappend ("DWORD PTR ");
4863 used_prefixes |= (prefixes & PREFIX_DATA);
4864 break;
4865 case t_mode:
4866 oappend ("TBYTE PTR ");
4867 break;
4868 case x_mode:
4869 oappend ("XMMWORD PTR ");
4870 break;
4871 case o_mode:
4872 oappend ("OWORD PTR ");
4873 break;
4874 default:
4875 break;
4876 }
4877 }
4878
4879 static void
4880 OP_E (int bytemode, int sizeflag)
4881 {
4882 bfd_vma disp;
4883 int add = 0;
4884 int riprel = 0;
4885 USED_REX (REX_B);
4886 if (rex & REX_B)
4887 add += 8;
4888
4889 /* Skip mod/rm byte. */
4890 MODRM_CHECK;
4891 codep++;
4892
4893 if (modrm.mod == 3)
4894 {
4895 switch (bytemode)
4896 {
4897 case b_mode:
4898 USED_REX (0);
4899 if (rex)
4900 oappend (names8rex[modrm.rm + add]);
4901 else
4902 oappend (names8[modrm.rm + add]);
4903 break;
4904 case w_mode:
4905 oappend (names16[modrm.rm + add]);
4906 break;
4907 case d_mode:
4908 oappend (names32[modrm.rm + add]);
4909 break;
4910 case q_mode:
4911 oappend (names64[modrm.rm + add]);
4912 break;
4913 case m_mode:
4914 if (address_mode == mode_64bit)
4915 oappend (names64[modrm.rm + add]);
4916 else
4917 oappend (names32[modrm.rm + add]);
4918 break;
4919 case stack_v_mode:
4920 if (address_mode == mode_64bit && (sizeflag & DFLAG))
4921 {
4922 oappend (names64[modrm.rm + add]);
4923 used_prefixes |= (prefixes & PREFIX_DATA);
4924 break;
4925 }
4926 bytemode = v_mode;
4927 /* FALLTHRU */
4928 case v_mode:
4929 case dq_mode:
4930 case dqb_mode:
4931 case dqd_mode:
4932 case dqw_mode:
4933 USED_REX (REX_W);
4934 if (rex & REX_W)
4935 oappend (names64[modrm.rm + add]);
4936 else if ((sizeflag & DFLAG) || bytemode != v_mode)
4937 oappend (names32[modrm.rm + add]);
4938 else
4939 oappend (names16[modrm.rm + add]);
4940 used_prefixes |= (prefixes & PREFIX_DATA);
4941 break;
4942 case 0:
4943 break;
4944 default:
4945 oappend (INTERNAL_DISASSEMBLER_ERROR);
4946 break;
4947 }
4948 return;
4949 }
4950
4951 disp = 0;
4952 if (intel_syntax)
4953 intel_operand_size (bytemode, sizeflag);
4954 append_seg ();
4955
4956 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
4957 {
4958 /* 32/64 bit address mode */
4959 int havedisp;
4960 int havesib;
4961 int havebase;
4962 int base;
4963 int index = 0;
4964 int scale = 0;
4965
4966 havesib = 0;
4967 havebase = 1;
4968 base = modrm.rm;
4969
4970 if (base == 4)
4971 {
4972 havesib = 1;
4973 FETCH_DATA (the_info, codep + 1);
4974 index = (*codep >> 3) & 7;
4975 if (address_mode == mode_64bit || index != 0x4)
4976 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
4977 scale = (*codep >> 6) & 3;
4978 base = *codep & 7;
4979 USED_REX (REX_X);
4980 if (rex & REX_X)
4981 index += 8;
4982 codep++;
4983 }
4984 base += add;
4985
4986 switch (modrm.mod)
4987 {
4988 case 0:
4989 if ((base & 7) == 5)
4990 {
4991 havebase = 0;
4992 if (address_mode == mode_64bit && !havesib)
4993 riprel = 1;
4994 disp = get32s ();
4995 }
4996 break;
4997 case 1:
4998 FETCH_DATA (the_info, codep + 1);
4999 disp = *codep++;
5000 if ((disp & 0x80) != 0)
5001 disp -= 0x100;
5002 break;
5003 case 2:
5004 disp = get32s ();
5005 break;
5006 }
5007
5008 havedisp = havebase || (havesib && (index != 4 || scale != 0));
5009
5010 if (!intel_syntax)
5011 if (modrm.mod != 0 || (base & 7) == 5)
5012 {
5013 if (havedisp || riprel)
5014 print_displacement (scratchbuf, disp);
5015 else
5016 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
5017 oappend (scratchbuf);
5018 if (riprel)
5019 {
5020 set_op (disp, 1);
5021 oappend ("(%rip)");
5022 }
5023 }
5024
5025 if (havedisp || (intel_syntax && riprel))
5026 {
5027 *obufp++ = open_char;
5028 if (intel_syntax && riprel)
5029 {
5030 set_op (disp, 1);
5031 oappend ("rip");
5032 }
5033 *obufp = '\0';
5034 if (havebase)
5035 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5036 ? names64[base] : names32[base]);
5037 if (havesib)
5038 {
5039 if (index != 4)
5040 {
5041 if (!intel_syntax || havebase)
5042 {
5043 *obufp++ = separator_char;
5044 *obufp = '\0';
5045 }
5046 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
5047 ? names64[index] : names32[index]);
5048 }
5049 if (scale != 0 || (!intel_syntax && index != 4))
5050 {
5051 *obufp++ = scale_char;
5052 *obufp = '\0';
5053 snprintf (scratchbuf, sizeof(scratchbuf), "%d", 1 << scale);
5054 oappend (scratchbuf);
5055 }
5056 }
5057 if (intel_syntax
5058 && (disp || modrm.mod != 0 || (base & 7) == 5))
5059 {
5060 if ((bfd_signed_vma) disp >= 0)
5061 {
5062 *obufp++ = '+';
5063 *obufp = '\0';
5064 }
5065 else if (modrm.mod != 1)
5066 {
5067 *obufp++ = '-';
5068 *obufp = '\0';
5069 disp = - (bfd_signed_vma) disp;
5070 }
5071
5072 print_displacement (scratchbuf, disp);
5073 oappend (scratchbuf);
5074 }
5075
5076 *obufp++ = close_char;
5077 *obufp = '\0';
5078 }
5079 else if (intel_syntax)
5080 {
5081 if (modrm.mod != 0 || (base & 7) == 5)
5082 {
5083 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5084 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5085 ;
5086 else
5087 {
5088 oappend (names_seg[ds_reg - es_reg]);
5089 oappend (":");
5090 }
5091 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
5092 oappend (scratchbuf);
5093 }
5094 }
5095 }
5096 else
5097 { /* 16 bit address mode */
5098 switch (modrm.mod)
5099 {
5100 case 0:
5101 if (modrm.rm == 6)
5102 {
5103 disp = get16 ();
5104 if ((disp & 0x8000) != 0)
5105 disp -= 0x10000;
5106 }
5107 break;
5108 case 1:
5109 FETCH_DATA (the_info, codep + 1);
5110 disp = *codep++;
5111 if ((disp & 0x80) != 0)
5112 disp -= 0x100;
5113 break;
5114 case 2:
5115 disp = get16 ();
5116 if ((disp & 0x8000) != 0)
5117 disp -= 0x10000;
5118 break;
5119 }
5120
5121 if (!intel_syntax)
5122 if (modrm.mod != 0 || modrm.rm == 6)
5123 {
5124 print_displacement (scratchbuf, disp);
5125 oappend (scratchbuf);
5126 }
5127
5128 if (modrm.mod != 0 || modrm.rm != 6)
5129 {
5130 *obufp++ = open_char;
5131 *obufp = '\0';
5132 oappend (index16[modrm.rm]);
5133 if (intel_syntax
5134 && (disp || modrm.mod != 0 || modrm.rm == 6))
5135 {
5136 if ((bfd_signed_vma) disp >= 0)
5137 {
5138 *obufp++ = '+';
5139 *obufp = '\0';
5140 }
5141 else if (modrm.mod != 1)
5142 {
5143 *obufp++ = '-';
5144 *obufp = '\0';
5145 disp = - (bfd_signed_vma) disp;
5146 }
5147
5148 print_displacement (scratchbuf, disp);
5149 oappend (scratchbuf);
5150 }
5151
5152 *obufp++ = close_char;
5153 *obufp = '\0';
5154 }
5155 else if (intel_syntax)
5156 {
5157 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5158 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
5159 ;
5160 else
5161 {
5162 oappend (names_seg[ds_reg - es_reg]);
5163 oappend (":");
5164 }
5165 print_operand_value (scratchbuf, sizeof(scratchbuf), 1,
5166 disp & 0xffff);
5167 oappend (scratchbuf);
5168 }
5169 }
5170 }
5171
5172 static void
5173 OP_G (int bytemode, int sizeflag)
5174 {
5175 int add = 0;
5176 USED_REX (REX_R);
5177 if (rex & REX_R)
5178 add += 8;
5179 switch (bytemode)
5180 {
5181 case b_mode:
5182 USED_REX (0);
5183 if (rex)
5184 oappend (names8rex[modrm.reg + add]);
5185 else
5186 oappend (names8[modrm.reg + add]);
5187 break;
5188 case w_mode:
5189 oappend (names16[modrm.reg + add]);
5190 break;
5191 case d_mode:
5192 oappend (names32[modrm.reg + add]);
5193 break;
5194 case q_mode:
5195 oappend (names64[modrm.reg + add]);
5196 break;
5197 case v_mode:
5198 case dq_mode:
5199 case dqb_mode:
5200 case dqd_mode:
5201 case dqw_mode:
5202 USED_REX (REX_W);
5203 if (rex & REX_W)
5204 oappend (names64[modrm.reg + add]);
5205 else if ((sizeflag & DFLAG) || bytemode != v_mode)
5206 oappend (names32[modrm.reg + add]);
5207 else
5208 oappend (names16[modrm.reg + add]);
5209 used_prefixes |= (prefixes & PREFIX_DATA);
5210 break;
5211 case m_mode:
5212 if (address_mode == mode_64bit)
5213 oappend (names64[modrm.reg + add]);
5214 else
5215 oappend (names32[modrm.reg + add]);
5216 break;
5217 default:
5218 oappend (INTERNAL_DISASSEMBLER_ERROR);
5219 break;
5220 }
5221 }
5222
5223 static bfd_vma
5224 get64 (void)
5225 {
5226 bfd_vma x;
5227 #ifdef BFD64
5228 unsigned int a;
5229 unsigned int b;
5230
5231 FETCH_DATA (the_info, codep + 8);
5232 a = *codep++ & 0xff;
5233 a |= (*codep++ & 0xff) << 8;
5234 a |= (*codep++ & 0xff) << 16;
5235 a |= (*codep++ & 0xff) << 24;
5236 b = *codep++ & 0xff;
5237 b |= (*codep++ & 0xff) << 8;
5238 b |= (*codep++ & 0xff) << 16;
5239 b |= (*codep++ & 0xff) << 24;
5240 x = a + ((bfd_vma) b << 32);
5241 #else
5242 abort ();
5243 x = 0;
5244 #endif
5245 return x;
5246 }
5247
5248 static bfd_signed_vma
5249 get32 (void)
5250 {
5251 bfd_signed_vma x = 0;
5252
5253 FETCH_DATA (the_info, codep + 4);
5254 x = *codep++ & (bfd_signed_vma) 0xff;
5255 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5256 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5257 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5258 return x;
5259 }
5260
5261 static bfd_signed_vma
5262 get32s (void)
5263 {
5264 bfd_signed_vma x = 0;
5265
5266 FETCH_DATA (the_info, codep + 4);
5267 x = *codep++ & (bfd_signed_vma) 0xff;
5268 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
5269 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
5270 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
5271
5272 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
5273
5274 return x;
5275 }
5276
5277 static int
5278 get16 (void)
5279 {
5280 int x = 0;
5281
5282 FETCH_DATA (the_info, codep + 2);
5283 x = *codep++ & 0xff;
5284 x |= (*codep++ & 0xff) << 8;
5285 return x;
5286 }
5287
5288 static void
5289 set_op (bfd_vma op, int riprel)
5290 {
5291 op_index[op_ad] = op_ad;
5292 if (address_mode == mode_64bit)
5293 {
5294 op_address[op_ad] = op;
5295 op_riprel[op_ad] = riprel;
5296 }
5297 else
5298 {
5299 /* Mask to get a 32-bit address. */
5300 op_address[op_ad] = op & 0xffffffff;
5301 op_riprel[op_ad] = riprel & 0xffffffff;
5302 }
5303 }
5304
5305 static void
5306 OP_REG (int code, int sizeflag)
5307 {
5308 const char *s;
5309 int add = 0;
5310 USED_REX (REX_B);
5311 if (rex & REX_B)
5312 add = 8;
5313
5314 switch (code)
5315 {
5316 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5317 case sp_reg: case bp_reg: case si_reg: case di_reg:
5318 s = names16[code - ax_reg + add];
5319 break;
5320 case es_reg: case ss_reg: case cs_reg:
5321 case ds_reg: case fs_reg: case gs_reg:
5322 s = names_seg[code - es_reg + add];
5323 break;
5324 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5325 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5326 USED_REX (0);
5327 if (rex)
5328 s = names8rex[code - al_reg + add];
5329 else
5330 s = names8[code - al_reg];
5331 break;
5332 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
5333 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
5334 if (address_mode == mode_64bit && (sizeflag & DFLAG))
5335 {
5336 s = names64[code - rAX_reg + add];
5337 break;
5338 }
5339 code += eAX_reg - rAX_reg;
5340 /* Fall through. */
5341 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5342 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5343 USED_REX (REX_W);
5344 if (rex & REX_W)
5345 s = names64[code - eAX_reg + add];
5346 else if (sizeflag & DFLAG)
5347 s = names32[code - eAX_reg + add];
5348 else
5349 s = names16[code - eAX_reg + add];
5350 used_prefixes |= (prefixes & PREFIX_DATA);
5351 break;
5352 default:
5353 s = INTERNAL_DISASSEMBLER_ERROR;
5354 break;
5355 }
5356 oappend (s);
5357 }
5358
5359 static void
5360 OP_IMREG (int code, int sizeflag)
5361 {
5362 const char *s;
5363
5364 switch (code)
5365 {
5366 case indir_dx_reg:
5367 if (intel_syntax)
5368 s = "dx";
5369 else
5370 s = "(%dx)";
5371 break;
5372 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
5373 case sp_reg: case bp_reg: case si_reg: case di_reg:
5374 s = names16[code - ax_reg];
5375 break;
5376 case es_reg: case ss_reg: case cs_reg:
5377 case ds_reg: case fs_reg: case gs_reg:
5378 s = names_seg[code - es_reg];
5379 break;
5380 case al_reg: case ah_reg: case cl_reg: case ch_reg:
5381 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
5382 USED_REX (0);
5383 if (rex)
5384 s = names8rex[code - al_reg];
5385 else
5386 s = names8[code - al_reg];
5387 break;
5388 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
5389 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
5390 USED_REX (REX_W);
5391 if (rex & REX_W)
5392 s = names64[code - eAX_reg];
5393 else if (sizeflag & DFLAG)
5394 s = names32[code - eAX_reg];
5395 else
5396 s = names16[code - eAX_reg];
5397 used_prefixes |= (prefixes & PREFIX_DATA);
5398 break;
5399 case z_mode_ax_reg:
5400 if ((rex & REX_W) || (sizeflag & DFLAG))
5401 s = *names32;
5402 else
5403 s = *names16;
5404 if (!(rex & REX_W))
5405 used_prefixes |= (prefixes & PREFIX_DATA);
5406 break;
5407 default:
5408 s = INTERNAL_DISASSEMBLER_ERROR;
5409 break;
5410 }
5411 oappend (s);
5412 }
5413
5414 static void
5415 OP_I (int bytemode, int sizeflag)
5416 {
5417 bfd_signed_vma op;
5418 bfd_signed_vma mask = -1;
5419
5420 switch (bytemode)
5421 {
5422 case b_mode:
5423 FETCH_DATA (the_info, codep + 1);
5424 op = *codep++;
5425 mask = 0xff;
5426 break;
5427 case q_mode:
5428 if (address_mode == mode_64bit)
5429 {
5430 op = get32s ();
5431 break;
5432 }
5433 /* Fall through. */
5434 case v_mode:
5435 USED_REX (REX_W);
5436 if (rex & REX_W)
5437 op = get32s ();
5438 else if (sizeflag & DFLAG)
5439 {
5440 op = get32 ();
5441 mask = 0xffffffff;
5442 }
5443 else
5444 {
5445 op = get16 ();
5446 mask = 0xfffff;
5447 }
5448 used_prefixes |= (prefixes & PREFIX_DATA);
5449 break;
5450 case w_mode:
5451 mask = 0xfffff;
5452 op = get16 ();
5453 break;
5454 case const_1_mode:
5455 if (intel_syntax)
5456 oappend ("1");
5457 return;
5458 default:
5459 oappend (INTERNAL_DISASSEMBLER_ERROR);
5460 return;
5461 }
5462
5463 op &= mask;
5464 scratchbuf[0] = '$';
5465 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op);
5466 oappend (scratchbuf + intel_syntax);
5467 scratchbuf[0] = '\0';
5468 }
5469
5470 static void
5471 OP_I64 (int bytemode, int sizeflag)
5472 {
5473 bfd_signed_vma op;
5474 bfd_signed_vma mask = -1;
5475
5476 if (address_mode != mode_64bit)
5477 {
5478 OP_I (bytemode, sizeflag);
5479 return;
5480 }
5481
5482 switch (bytemode)
5483 {
5484 case b_mode:
5485 FETCH_DATA (the_info, codep + 1);
5486 op = *codep++;
5487 mask = 0xff;
5488 break;
5489 case v_mode:
5490 USED_REX (REX_W);
5491 if (rex & REX_W)
5492 op = get64 ();
5493 else if (sizeflag & DFLAG)
5494 {
5495 op = get32 ();
5496 mask = 0xffffffff;
5497 }
5498 else
5499 {
5500 op = get16 ();
5501 mask = 0xfffff;
5502 }
5503 used_prefixes |= (prefixes & PREFIX_DATA);
5504 break;
5505 case w_mode:
5506 mask = 0xfffff;
5507 op = get16 ();
5508 break;
5509 default:
5510 oappend (INTERNAL_DISASSEMBLER_ERROR);
5511 return;
5512 }
5513
5514 op &= mask;
5515 scratchbuf[0] = '$';
5516 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op);
5517 oappend (scratchbuf + intel_syntax);
5518 scratchbuf[0] = '\0';
5519 }
5520
5521 static void
5522 OP_sI (int bytemode, int sizeflag)
5523 {
5524 bfd_signed_vma op;
5525 bfd_signed_vma mask = -1;
5526
5527 switch (bytemode)
5528 {
5529 case b_mode:
5530 FETCH_DATA (the_info, codep + 1);
5531 op = *codep++;
5532 if ((op & 0x80) != 0)
5533 op -= 0x100;
5534 mask = 0xffffffff;
5535 break;
5536 case v_mode:
5537 USED_REX (REX_W);
5538 if (rex & REX_W)
5539 op = get32s ();
5540 else if (sizeflag & DFLAG)
5541 {
5542 op = get32s ();
5543 mask = 0xffffffff;
5544 }
5545 else
5546 {
5547 mask = 0xffffffff;
5548 op = get16 ();
5549 if ((op & 0x8000) != 0)
5550 op -= 0x10000;
5551 }
5552 used_prefixes |= (prefixes & PREFIX_DATA);
5553 break;
5554 case w_mode:
5555 op = get16 ();
5556 mask = 0xffffffff;
5557 if ((op & 0x8000) != 0)
5558 op -= 0x10000;
5559 break;
5560 default:
5561 oappend (INTERNAL_DISASSEMBLER_ERROR);
5562 return;
5563 }
5564
5565 scratchbuf[0] = '$';
5566 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op);
5567 oappend (scratchbuf + intel_syntax);
5568 }
5569
5570 static void
5571 OP_J (int bytemode, int sizeflag)
5572 {
5573 bfd_vma disp;
5574 bfd_vma mask = -1;
5575 bfd_vma segment = 0;
5576
5577 switch (bytemode)
5578 {
5579 case b_mode:
5580 FETCH_DATA (the_info, codep + 1);
5581 disp = *codep++;
5582 if ((disp & 0x80) != 0)
5583 disp -= 0x100;
5584 break;
5585 case v_mode:
5586 if ((sizeflag & DFLAG) || (rex & REX_W))
5587 disp = get32s ();
5588 else
5589 {
5590 disp = get16 ();
5591 if ((disp & 0x8000) != 0)
5592 disp -= 0x10000;
5593 /* In 16bit mode, address is wrapped around at 64k within
5594 the same segment. Otherwise, a data16 prefix on a jump
5595 instruction means that the pc is masked to 16 bits after
5596 the displacement is added! */
5597 mask = 0xffff;
5598 if ((prefixes & PREFIX_DATA) == 0)
5599 segment = ((start_pc + codep - start_codep)
5600 & ~((bfd_vma) 0xffff));
5601 }
5602 used_prefixes |= (prefixes & PREFIX_DATA);
5603 break;
5604 default:
5605 oappend (INTERNAL_DISASSEMBLER_ERROR);
5606 return;
5607 }
5608 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
5609 set_op (disp, 0);
5610 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
5611 oappend (scratchbuf);
5612 }
5613
5614 static void
5615 OP_SEG (int bytemode, int sizeflag)
5616 {
5617 if (bytemode == w_mode)
5618 oappend (names_seg[modrm.reg]);
5619 else
5620 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
5621 }
5622
5623 static void
5624 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
5625 {
5626 int seg, offset;
5627
5628 if (sizeflag & DFLAG)
5629 {
5630 offset = get32 ();
5631 seg = get16 ();
5632 }
5633 else
5634 {
5635 offset = get16 ();
5636 seg = get16 ();
5637 }
5638 used_prefixes |= (prefixes & PREFIX_DATA);
5639 if (intel_syntax)
5640 snprintf (scratchbuf, sizeof(scratchbuf), "0x%x:0x%x", seg, offset);
5641 else
5642 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset);
5643 oappend (scratchbuf);
5644 }
5645
5646 static void
5647 OP_OFF (int bytemode, int sizeflag)
5648 {
5649 bfd_vma off;
5650
5651 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5652 intel_operand_size (bytemode, sizeflag);
5653 append_seg ();
5654
5655 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
5656 off = get32 ();
5657 else
5658 off = get16 ();
5659
5660 if (intel_syntax)
5661 {
5662 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5663 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5664 {
5665 oappend (names_seg[ds_reg - es_reg]);
5666 oappend (":");
5667 }
5668 }
5669 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off);
5670 oappend (scratchbuf);
5671 }
5672
5673 static void
5674 OP_OFF64 (int bytemode, int sizeflag)
5675 {
5676 bfd_vma off;
5677
5678 if (address_mode != mode_64bit
5679 || (prefixes & PREFIX_ADDR))
5680 {
5681 OP_OFF (bytemode, sizeflag);
5682 return;
5683 }
5684
5685 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5686 intel_operand_size (bytemode, sizeflag);
5687 append_seg ();
5688
5689 off = get64 ();
5690
5691 if (intel_syntax)
5692 {
5693 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5694 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5695 {
5696 oappend (names_seg[ds_reg - es_reg]);
5697 oappend (":");
5698 }
5699 }
5700 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off);
5701 oappend (scratchbuf);
5702 }
5703
5704 static void
5705 ptr_reg (int code, int sizeflag)
5706 {
5707 const char *s;
5708
5709 *obufp++ = open_char;
5710 used_prefixes |= (prefixes & PREFIX_ADDR);
5711 if (address_mode == mode_64bit)
5712 {
5713 if (!(sizeflag & AFLAG))
5714 s = names32[code - eAX_reg];
5715 else
5716 s = names64[code - eAX_reg];
5717 }
5718 else if (sizeflag & AFLAG)
5719 s = names32[code - eAX_reg];
5720 else
5721 s = names16[code - eAX_reg];
5722 oappend (s);
5723 *obufp++ = close_char;
5724 *obufp = 0;
5725 }
5726
5727 static void
5728 OP_ESreg (int code, int sizeflag)
5729 {
5730 if (intel_syntax)
5731 {
5732 switch (codep[-1])
5733 {
5734 case 0x6d: /* insw/insl */
5735 intel_operand_size (z_mode, sizeflag);
5736 break;
5737 case 0xa5: /* movsw/movsl/movsq */
5738 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5739 case 0xab: /* stosw/stosl */
5740 case 0xaf: /* scasw/scasl */
5741 intel_operand_size (v_mode, sizeflag);
5742 break;
5743 default:
5744 intel_operand_size (b_mode, sizeflag);
5745 }
5746 }
5747 oappend ("%es:" + intel_syntax);
5748 ptr_reg (code, sizeflag);
5749 }
5750
5751 static void
5752 OP_DSreg (int code, int sizeflag)
5753 {
5754 if (intel_syntax)
5755 {
5756 switch (codep[-1])
5757 {
5758 case 0x6f: /* outsw/outsl */
5759 intel_operand_size (z_mode, sizeflag);
5760 break;
5761 case 0xa5: /* movsw/movsl/movsq */
5762 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5763 case 0xad: /* lodsw/lodsl/lodsq */
5764 intel_operand_size (v_mode, sizeflag);
5765 break;
5766 default:
5767 intel_operand_size (b_mode, sizeflag);
5768 }
5769 }
5770 if ((prefixes
5771 & (PREFIX_CS
5772 | PREFIX_DS
5773 | PREFIX_SS
5774 | PREFIX_ES
5775 | PREFIX_FS
5776 | PREFIX_GS)) == 0)
5777 prefixes |= PREFIX_DS;
5778 append_seg ();
5779 ptr_reg (code, sizeflag);
5780 }
5781
5782 static void
5783 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5784 {
5785 int add = 0;
5786 if (rex & REX_R)
5787 {
5788 USED_REX (REX_R);
5789 add = 8;
5790 }
5791 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
5792 {
5793 used_prefixes |= PREFIX_LOCK;
5794 add = 8;
5795 }
5796 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", modrm.reg + add);
5797 oappend (scratchbuf + intel_syntax);
5798 }
5799
5800 static void
5801 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5802 {
5803 int add = 0;
5804 USED_REX (REX_R);
5805 if (rex & REX_R)
5806 add = 8;
5807 if (intel_syntax)
5808 snprintf (scratchbuf, sizeof(scratchbuf), "db%d", modrm.reg + add);
5809 else
5810 snprintf (scratchbuf, sizeof(scratchbuf), "%%db%d", modrm.reg + add);
5811 oappend (scratchbuf);
5812 }
5813
5814 static void
5815 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5816 {
5817 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", modrm.reg);
5818 oappend (scratchbuf + intel_syntax);
5819 }
5820
5821 static void
5822 OP_R (int bytemode, int sizeflag)
5823 {
5824 if (modrm.mod == 3)
5825 OP_E (bytemode, sizeflag);
5826 else
5827 BadOp ();
5828 }
5829
5830 static void
5831 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5832 {
5833 used_prefixes |= (prefixes & PREFIX_DATA);
5834 if (prefixes & PREFIX_DATA)
5835 {
5836 int add = 0;
5837 USED_REX (REX_R);
5838 if (rex & REX_R)
5839 add = 8;
5840 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add);
5841 }
5842 else
5843 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg);
5844 oappend (scratchbuf + intel_syntax);
5845 }
5846
5847 static void
5848 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5849 {
5850 int add = 0;
5851 USED_REX (REX_R);
5852 if (rex & REX_R)
5853 add = 8;
5854 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add);
5855 oappend (scratchbuf + intel_syntax);
5856 }
5857
5858 static void
5859 OP_EM (int bytemode, int sizeflag)
5860 {
5861 if (modrm.mod != 3)
5862 {
5863 if (intel_syntax && bytemode == v_mode)
5864 {
5865 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5866 used_prefixes |= (prefixes & PREFIX_DATA);
5867 }
5868 OP_E (bytemode, sizeflag);
5869 return;
5870 }
5871
5872 /* Skip mod/rm byte. */
5873 MODRM_CHECK;
5874 codep++;
5875 used_prefixes |= (prefixes & PREFIX_DATA);
5876 if (prefixes & PREFIX_DATA)
5877 {
5878 int add = 0;
5879
5880 USED_REX (REX_B);
5881 if (rex & REX_B)
5882 add = 8;
5883 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add);
5884 }
5885 else
5886 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm);
5887 oappend (scratchbuf + intel_syntax);
5888 }
5889
5890 /* cvt* are the only instructions in sse2 which have
5891 both SSE and MMX operands and also have 0x66 prefix
5892 in their opcode. 0x66 was originally used to differentiate
5893 between SSE and MMX instruction(operands). So we have to handle the
5894 cvt* separately using OP_EMC and OP_MXC */
5895 static void
5896 OP_EMC (int bytemode, int sizeflag)
5897 {
5898 if (modrm.mod != 3)
5899 {
5900 if (intel_syntax && bytemode == v_mode)
5901 {
5902 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5903 used_prefixes |= (prefixes & PREFIX_DATA);
5904 }
5905 OP_E (bytemode, sizeflag);
5906 return;
5907 }
5908
5909 /* Skip mod/rm byte. */
5910 MODRM_CHECK;
5911 codep++;
5912 used_prefixes |= (prefixes & PREFIX_DATA);
5913 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm);
5914 oappend (scratchbuf + intel_syntax);
5915 }
5916
5917 static void
5918 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5919 {
5920 used_prefixes |= (prefixes & PREFIX_DATA);
5921 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg);
5922 oappend (scratchbuf + intel_syntax);
5923 }
5924
5925 static void
5926 OP_EX (int bytemode, int sizeflag)
5927 {
5928 int add = 0;
5929 if (modrm.mod != 3)
5930 {
5931 OP_E (bytemode, sizeflag);
5932 return;
5933 }
5934 USED_REX (REX_B);
5935 if (rex & REX_B)
5936 add = 8;
5937
5938 /* Skip mod/rm byte. */
5939 MODRM_CHECK;
5940 codep++;
5941 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add);
5942 oappend (scratchbuf + intel_syntax);
5943 }
5944
5945 static void
5946 OP_MS (int bytemode, int sizeflag)
5947 {
5948 if (modrm.mod == 3)
5949 OP_EM (bytemode, sizeflag);
5950 else
5951 BadOp ();
5952 }
5953
5954 static void
5955 OP_XS (int bytemode, int sizeflag)
5956 {
5957 if (modrm.mod == 3)
5958 OP_EX (bytemode, sizeflag);
5959 else
5960 BadOp ();
5961 }
5962
5963 static void
5964 OP_M (int bytemode, int sizeflag)
5965 {
5966 if (modrm.mod == 3)
5967 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
5968 BadOp ();
5969 else
5970 OP_E (bytemode, sizeflag);
5971 }
5972
5973 static void
5974 OP_0f07 (int bytemode, int sizeflag)
5975 {
5976 if (modrm.mod != 3 || modrm.rm != 0)
5977 BadOp ();
5978 else
5979 OP_E (bytemode, sizeflag);
5980 }
5981
5982 static void
5983 OP_0fae (int bytemode, int sizeflag)
5984 {
5985 if (modrm.mod == 3)
5986 {
5987 if (modrm.reg == 7)
5988 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
5989
5990 if (modrm.reg < 5 || modrm.rm != 0)
5991 {
5992 BadOp (); /* bad sfence, mfence, or lfence */
5993 return;
5994 }
5995 }
5996 else if (modrm.reg != 7)
5997 {
5998 BadOp (); /* bad clflush */
5999 return;
6000 }
6001
6002 OP_E (bytemode, sizeflag);
6003 }
6004
6005 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
6006 32bit mode and "xchg %rax,%rax" in 64bit mode. */
6007
6008 static void
6009 NOP_Fixup1 (int bytemode, int sizeflag)
6010 {
6011 if ((prefixes & PREFIX_DATA) != 0
6012 || (rex != 0
6013 && rex != 0x48
6014 && address_mode == mode_64bit))
6015 OP_REG (bytemode, sizeflag);
6016 else
6017 strcpy (obuf, "nop");
6018 }
6019
6020 static void
6021 NOP_Fixup2 (int bytemode, int sizeflag)
6022 {
6023 if ((prefixes & PREFIX_DATA) != 0
6024 || (rex != 0
6025 && rex != 0x48
6026 && address_mode == mode_64bit))
6027 OP_IMREG (bytemode, sizeflag);
6028 }
6029
6030 static const char *Suffix3DNow[] = {
6031 /* 00 */ NULL, NULL, NULL, NULL,
6032 /* 04 */ NULL, NULL, NULL, NULL,
6033 /* 08 */ NULL, NULL, NULL, NULL,
6034 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
6035 /* 10 */ NULL, NULL, NULL, NULL,
6036 /* 14 */ NULL, NULL, NULL, NULL,
6037 /* 18 */ NULL, NULL, NULL, NULL,
6038 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
6039 /* 20 */ NULL, NULL, NULL, NULL,
6040 /* 24 */ NULL, NULL, NULL, NULL,
6041 /* 28 */ NULL, NULL, NULL, NULL,
6042 /* 2C */ NULL, NULL, NULL, NULL,
6043 /* 30 */ NULL, NULL, NULL, NULL,
6044 /* 34 */ NULL, NULL, NULL, NULL,
6045 /* 38 */ NULL, NULL, NULL, NULL,
6046 /* 3C */ NULL, NULL, NULL, NULL,
6047 /* 40 */ NULL, NULL, NULL, NULL,
6048 /* 44 */ NULL, NULL, NULL, NULL,
6049 /* 48 */ NULL, NULL, NULL, NULL,
6050 /* 4C */ NULL, NULL, NULL, NULL,
6051 /* 50 */ NULL, NULL, NULL, NULL,
6052 /* 54 */ NULL, NULL, NULL, NULL,
6053 /* 58 */ NULL, NULL, NULL, NULL,
6054 /* 5C */ NULL, NULL, NULL, NULL,
6055 /* 60 */ NULL, NULL, NULL, NULL,
6056 /* 64 */ NULL, NULL, NULL, NULL,
6057 /* 68 */ NULL, NULL, NULL, NULL,
6058 /* 6C */ NULL, NULL, NULL, NULL,
6059 /* 70 */ NULL, NULL, NULL, NULL,
6060 /* 74 */ NULL, NULL, NULL, NULL,
6061 /* 78 */ NULL, NULL, NULL, NULL,
6062 /* 7C */ NULL, NULL, NULL, NULL,
6063 /* 80 */ NULL, NULL, NULL, NULL,
6064 /* 84 */ NULL, NULL, NULL, NULL,
6065 /* 88 */ NULL, NULL, "pfnacc", NULL,
6066 /* 8C */ NULL, NULL, "pfpnacc", NULL,
6067 /* 90 */ "pfcmpge", NULL, NULL, NULL,
6068 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
6069 /* 98 */ NULL, NULL, "pfsub", NULL,
6070 /* 9C */ NULL, NULL, "pfadd", NULL,
6071 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
6072 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
6073 /* A8 */ NULL, NULL, "pfsubr", NULL,
6074 /* AC */ NULL, NULL, "pfacc", NULL,
6075 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
6076 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
6077 /* B8 */ NULL, NULL, NULL, "pswapd",
6078 /* BC */ NULL, NULL, NULL, "pavgusb",
6079 /* C0 */ NULL, NULL, NULL, NULL,
6080 /* C4 */ NULL, NULL, NULL, NULL,
6081 /* C8 */ NULL, NULL, NULL, NULL,
6082 /* CC */ NULL, NULL, NULL, NULL,
6083 /* D0 */ NULL, NULL, NULL, NULL,
6084 /* D4 */ NULL, NULL, NULL, NULL,
6085 /* D8 */ NULL, NULL, NULL, NULL,
6086 /* DC */ NULL, NULL, NULL, NULL,
6087 /* E0 */ NULL, NULL, NULL, NULL,
6088 /* E4 */ NULL, NULL, NULL, NULL,
6089 /* E8 */ NULL, NULL, NULL, NULL,
6090 /* EC */ NULL, NULL, NULL, NULL,
6091 /* F0 */ NULL, NULL, NULL, NULL,
6092 /* F4 */ NULL, NULL, NULL, NULL,
6093 /* F8 */ NULL, NULL, NULL, NULL,
6094 /* FC */ NULL, NULL, NULL, NULL,
6095 };
6096
6097 static void
6098 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6099 {
6100 const char *mnemonic;
6101
6102 FETCH_DATA (the_info, codep + 1);
6103 /* AMD 3DNow! instructions are specified by an opcode suffix in the
6104 place where an 8-bit immediate would normally go. ie. the last
6105 byte of the instruction. */
6106 obufp = obuf + strlen (obuf);
6107 mnemonic = Suffix3DNow[*codep++ & 0xff];
6108 if (mnemonic)
6109 oappend (mnemonic);
6110 else
6111 {
6112 /* Since a variable sized modrm/sib chunk is between the start
6113 of the opcode (0x0f0f) and the opcode suffix, we need to do
6114 all the modrm processing first, and don't know until now that
6115 we have a bad opcode. This necessitates some cleaning up. */
6116 op_out[0][0] = '\0';
6117 op_out[1][0] = '\0';
6118 BadOp ();
6119 }
6120 }
6121
6122 static const char *simd_cmp_op[] = {
6123 "eq",
6124 "lt",
6125 "le",
6126 "unord",
6127 "neq",
6128 "nlt",
6129 "nle",
6130 "ord"
6131 };
6132
6133 static void
6134 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6135 {
6136 unsigned int cmp_type;
6137
6138 FETCH_DATA (the_info, codep + 1);
6139 obufp = obuf + strlen (obuf);
6140 cmp_type = *codep++ & 0xff;
6141 if (cmp_type < 8)
6142 {
6143 char suffix1 = 'p', suffix2 = 's';
6144 used_prefixes |= (prefixes & PREFIX_REPZ);
6145 if (prefixes & PREFIX_REPZ)
6146 suffix1 = 's';
6147 else
6148 {
6149 used_prefixes |= (prefixes & PREFIX_DATA);
6150 if (prefixes & PREFIX_DATA)
6151 suffix2 = 'd';
6152 else
6153 {
6154 used_prefixes |= (prefixes & PREFIX_REPNZ);
6155 if (prefixes & PREFIX_REPNZ)
6156 suffix1 = 's', suffix2 = 'd';
6157 }
6158 }
6159 snprintf (scratchbuf, sizeof(scratchbuf), "cmp%s%c%c",
6160 simd_cmp_op[cmp_type], suffix1, suffix2);
6161 used_prefixes |= (prefixes & PREFIX_REPZ);
6162 oappend (scratchbuf);
6163 }
6164 else
6165 {
6166 /* We have a bad extension byte. Clean up. */
6167 op_out[0][0] = '\0';
6168 op_out[1][0] = '\0';
6169 BadOp ();
6170 }
6171 }
6172
6173 static void
6174 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
6175 {
6176 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
6177 forms of these instructions. */
6178 if (modrm.mod == 3)
6179 {
6180 char *p = obuf + strlen (obuf);
6181 *(p + 1) = '\0';
6182 *p = *(p - 1);
6183 *(p - 1) = *(p - 2);
6184 *(p - 2) = *(p - 3);
6185 *(p - 3) = extrachar;
6186 }
6187 }
6188
6189 static void
6190 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6191 {
6192 if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1)
6193 {
6194 /* Override "sidt". */
6195 size_t olen = strlen (obuf);
6196 char *p = obuf + olen - 4;
6197 const char * const *names = (address_mode == mode_64bit
6198 ? names64 : names32);
6199
6200 /* We might have a suffix when disassembling with -Msuffix. */
6201 if (*p == 'i')
6202 --p;
6203
6204 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6205 if (!intel_syntax
6206 && (prefixes & PREFIX_ADDR)
6207 && olen >= (4 + 7)
6208 && *(p - 1) == ' '
6209 && strncmp (p - 7, "addr", 4) == 0
6210 && (strncmp (p - 3, "16", 2) == 0
6211 || strncmp (p - 3, "32", 2) == 0))
6212 p -= 7;
6213
6214 if (modrm.rm)
6215 {
6216 /* mwait %eax,%ecx */
6217 strcpy (p, "mwait");
6218 if (!intel_syntax)
6219 strcpy (op_out[0], names[0]);
6220 }
6221 else
6222 {
6223 /* monitor %eax,%ecx,%edx" */
6224 strcpy (p, "monitor");
6225 if (!intel_syntax)
6226 {
6227 const char * const *op1_names;
6228 if (!(prefixes & PREFIX_ADDR))
6229 op1_names = (address_mode == mode_16bit
6230 ? names16 : names);
6231 else
6232 {
6233 op1_names = (address_mode != mode_32bit
6234 ? names32 : names16);
6235 used_prefixes |= PREFIX_ADDR;
6236 }
6237 strcpy (op_out[0], op1_names[0]);
6238 strcpy (op_out[2], names[2]);
6239 }
6240 }
6241 if (!intel_syntax)
6242 {
6243 strcpy (op_out[1], names[1]);
6244 two_source_ops = 1;
6245 }
6246
6247 codep++;
6248 }
6249 else
6250 OP_M (0, sizeflag);
6251 }
6252
6253 static void
6254 SVME_Fixup (int bytemode, int sizeflag)
6255 {
6256 const char *alt;
6257 char *p;
6258
6259 switch (*codep)
6260 {
6261 case 0xd8:
6262 alt = "vmrun";
6263 break;
6264 case 0xd9:
6265 alt = "vmmcall";
6266 break;
6267 case 0xda:
6268 alt = "vmload";
6269 break;
6270 case 0xdb:
6271 alt = "vmsave";
6272 break;
6273 case 0xdc:
6274 alt = "stgi";
6275 break;
6276 case 0xdd:
6277 alt = "clgi";
6278 break;
6279 case 0xde:
6280 alt = "skinit";
6281 break;
6282 case 0xdf:
6283 alt = "invlpga";
6284 break;
6285 default:
6286 OP_M (bytemode, sizeflag);
6287 return;
6288 }
6289 /* Override "lidt". */
6290 p = obuf + strlen (obuf) - 4;
6291 /* We might have a suffix. */
6292 if (*p == 'i')
6293 --p;
6294 strcpy (p, alt);
6295 if (!(prefixes & PREFIX_ADDR))
6296 {
6297 ++codep;
6298 return;
6299 }
6300 used_prefixes |= PREFIX_ADDR;
6301 switch (*codep++)
6302 {
6303 case 0xdf:
6304 strcpy (op_out[1], names32[1]);
6305 two_source_ops = 1;
6306 /* Fall through. */
6307 case 0xd8:
6308 case 0xda:
6309 case 0xdb:
6310 *obufp++ = open_char;
6311 if (address_mode == mode_64bit || (sizeflag & AFLAG))
6312 alt = names32[0];
6313 else
6314 alt = names16[0];
6315 strcpy (obufp, alt);
6316 obufp += strlen (alt);
6317 *obufp++ = close_char;
6318 *obufp = '\0';
6319 break;
6320 }
6321 }
6322
6323 static void
6324 INVLPG_Fixup (int bytemode, int sizeflag)
6325 {
6326 const char *alt;
6327
6328 switch (*codep)
6329 {
6330 case 0xf8:
6331 alt = "swapgs";
6332 break;
6333 case 0xf9:
6334 alt = "rdtscp";
6335 break;
6336 default:
6337 OP_M (bytemode, sizeflag);
6338 return;
6339 }
6340 /* Override "invlpg". */
6341 strcpy (obuf + strlen (obuf) - 6, alt);
6342 codep++;
6343 }
6344
6345 static void
6346 BadOp (void)
6347 {
6348 /* Throw away prefixes and 1st. opcode byte. */
6349 codep = insn_codep + 1;
6350 oappend ("(bad)");
6351 }
6352
6353 static void
6354 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6355 {
6356 if (modrm.mod == 3
6357 && modrm.reg == 0
6358 && modrm.rm >=1
6359 && modrm.rm <= 4)
6360 {
6361 /* Override "sgdt". */
6362 char *p = obuf + strlen (obuf) - 4;
6363
6364 /* We might have a suffix when disassembling with -Msuffix. */
6365 if (*p == 'g')
6366 --p;
6367
6368 switch (modrm.rm)
6369 {
6370 case 1:
6371 strcpy (p, "vmcall");
6372 break;
6373 case 2:
6374 strcpy (p, "vmlaunch");
6375 break;
6376 case 3:
6377 strcpy (p, "vmresume");
6378 break;
6379 case 4:
6380 strcpy (p, "vmxoff");
6381 break;
6382 }
6383
6384 codep++;
6385 }
6386 else
6387 OP_E (0, sizeflag);
6388 }
6389
6390 static void
6391 OP_VMX (int bytemode, int sizeflag)
6392 {
6393 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
6394 if (prefixes & PREFIX_DATA)
6395 strcpy (obuf, "vmclear");
6396 else if (prefixes & PREFIX_REPZ)
6397 strcpy (obuf, "vmxon");
6398 else
6399 strcpy (obuf, "vmptrld");
6400 OP_E (bytemode, sizeflag);
6401 }
6402
6403 static void
6404 REP_Fixup (int bytemode, int sizeflag)
6405 {
6406 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
6407 lods and stos. */
6408 size_t ilen = 0;
6409
6410 if (prefixes & PREFIX_REPZ)
6411 switch (*insn_codep)
6412 {
6413 case 0x6e: /* outsb */
6414 case 0x6f: /* outsw/outsl */
6415 case 0xa4: /* movsb */
6416 case 0xa5: /* movsw/movsl/movsq */
6417 if (!intel_syntax)
6418 ilen = 5;
6419 else
6420 ilen = 4;
6421 break;
6422 case 0xaa: /* stosb */
6423 case 0xab: /* stosw/stosl/stosq */
6424 case 0xac: /* lodsb */
6425 case 0xad: /* lodsw/lodsl/lodsq */
6426 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
6427 ilen = 5;
6428 else
6429 ilen = 4;
6430 break;
6431 case 0x6c: /* insb */
6432 case 0x6d: /* insl/insw */
6433 if (!intel_syntax)
6434 ilen = 4;
6435 else
6436 ilen = 3;
6437 break;
6438 default:
6439 abort ();
6440 break;
6441 }
6442
6443 if (ilen != 0)
6444 {
6445 size_t olen;
6446 char *p;
6447
6448 olen = strlen (obuf);
6449 p = obuf + olen - ilen - 1 - 4;
6450 /* Handle "repz [addr16|addr32]". */
6451 if ((prefixes & PREFIX_ADDR))
6452 p -= 1 + 6;
6453
6454 memmove (p + 3, p + 4, olen - (p + 3 - obuf));
6455 }
6456
6457 switch (bytemode)
6458 {
6459 case al_reg:
6460 case eAX_reg:
6461 case indir_dx_reg:
6462 OP_IMREG (bytemode, sizeflag);
6463 break;
6464 case eDI_reg:
6465 OP_ESreg (bytemode, sizeflag);
6466 break;
6467 case eSI_reg:
6468 OP_DSreg (bytemode, sizeflag);
6469 break;
6470 default:
6471 abort ();
6472 break;
6473 }
6474 }
6475
6476 static void
6477 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
6478 {
6479 USED_REX (REX_W);
6480 if (rex & REX_W)
6481 {
6482 /* Change cmpxchg8b to cmpxchg16b. */
6483 char *p = obuf + strlen (obuf) - 2;
6484 strcpy (p, "16b");
6485 bytemode = o_mode;
6486 }
6487 OP_M (bytemode, sizeflag);
6488 }
6489
6490 static void
6491 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
6492 {
6493 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg);
6494 oappend (scratchbuf + intel_syntax);
6495 }
6496
6497 static void
6498 CRC32_Fixup (int bytemode, int sizeflag)
6499 {
6500 /* Add proper suffix to "crc32". */
6501 char *p = obuf + strlen (obuf);
6502
6503 switch (bytemode)
6504 {
6505 case b_mode:
6506 if (intel_syntax)
6507 break;
6508
6509 *p++ = 'b';
6510 break;
6511 case v_mode:
6512 if (intel_syntax)
6513 break;
6514
6515 USED_REX (REX_W);
6516 if (rex & REX_W)
6517 *p++ = 'q';
6518 else if (sizeflag & DFLAG)
6519 *p++ = 'l';
6520 else
6521 *p++ = 'w';
6522 used_prefixes |= (prefixes & PREFIX_DATA);
6523 break;
6524 default:
6525 oappend (INTERNAL_DISASSEMBLER_ERROR);
6526 break;
6527 }
6528 *p = '\0';
6529
6530 if (modrm.mod == 3)
6531 {
6532 int add;
6533
6534 /* Skip mod/rm byte. */
6535 MODRM_CHECK;
6536 codep++;
6537
6538 USED_REX (REX_B);
6539 add = (rex & REX_B) ? 8 : 0;
6540 if (bytemode == b_mode)
6541 {
6542 USED_REX (0);
6543 if (rex)
6544 oappend (names8rex[modrm.rm + add]);
6545 else
6546 oappend (names8[modrm.rm + add]);
6547 }
6548 else
6549 {
6550 USED_REX (REX_W);
6551 if (rex & REX_W)
6552 oappend (names64[modrm.rm + add]);
6553 else if ((prefixes & PREFIX_DATA))
6554 oappend (names16[modrm.rm + add]);
6555 else
6556 oappend (names32[modrm.rm + add]);
6557 }
6558 }
6559 else
6560 OP_E (bytemode, sizeflag);
6561 }