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