?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ide save/restore pio/atapi cmd transfer fields and io buffer
[qemu.git] / i386-dis.c
blobb2af03371bb7f58dbdebf603acecaa67d9862c2b
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 bfd_signed_vma mask = -1;
5524
5525 switch (bytemode)
5526 {
5527 case b_mode:
5528 FETCH_DATA (the_info, codep + 1);
5529 op = *codep++;
5530 if ((op & 0x80) != 0)
5531 op -= 0x100;
5532 mask = 0xffffffff;
5533 break;
5534 case v_mode:
5535 USED_REX (REX_W);
5536 if (rex & REX_W)
5537 op = get32s ();
5538 else if (sizeflag & DFLAG)
5539 {
5540 op = get32s ();
5541 mask = 0xffffffff;
5542 }
5543 else
5544 {
5545 mask = 0xffffffff;
5546 op = get16 ();
5547 if ((op & 0x8000) != 0)
5548 op -= 0x10000;
5549 }
5550 used_prefixes |= (prefixes & PREFIX_DATA);
5551 break;
5552 case w_mode:
5553 op = get16 ();
5554 mask = 0xffffffff;
5555 if ((op & 0x8000) != 0)
5556 op -= 0x10000;
5557 break;
5558 default:
5559 oappend (INTERNAL_DISASSEMBLER_ERROR);
5560 return;
5561 }
5562
5563 scratchbuf[0] = '$';
5564 print_operand_value (scratchbuf + 1, sizeof(scratchbuf) - 1, 1, op);
5565 oappend (scratchbuf + intel_syntax);
5566 }
5567
5568 static void
5569 OP_J (int bytemode, int sizeflag)
5570 {
5571 bfd_vma disp;
5572 bfd_vma mask = -1;
5573 bfd_vma segment = 0;
5574
5575 switch (bytemode)
5576 {
5577 case b_mode:
5578 FETCH_DATA (the_info, codep + 1);
5579 disp = *codep++;
5580 if ((disp & 0x80) != 0)
5581 disp -= 0x100;
5582 break;
5583 case v_mode:
5584 if ((sizeflag & DFLAG) || (rex & REX_W))
5585 disp = get32s ();
5586 else
5587 {
5588 disp = get16 ();
5589 if ((disp & 0x8000) != 0)
5590 disp -= 0x10000;
5591 /* In 16bit mode, address is wrapped around at 64k within
5592 the same segment. Otherwise, a data16 prefix on a jump
5593 instruction means that the pc is masked to 16 bits after
5594 the displacement is added! */
5595 mask = 0xffff;
5596 if ((prefixes & PREFIX_DATA) == 0)
5597 segment = ((start_pc + codep - start_codep)
5598 & ~((bfd_vma) 0xffff));
5599 }
5600 used_prefixes |= (prefixes & PREFIX_DATA);
5601 break;
5602 default:
5603 oappend (INTERNAL_DISASSEMBLER_ERROR);
5604 return;
5605 }
5606 disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
5607 set_op (disp, 0);
5608 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, disp);
5609 oappend (scratchbuf);
5610 }
5611
5612 static void
5613 OP_SEG (int bytemode, int sizeflag)
5614 {
5615 if (bytemode == w_mode)
5616 oappend (names_seg[modrm.reg]);
5617 else
5618 OP_E (modrm.mod == 3 ? bytemode : w_mode, sizeflag);
5619 }
5620
5621 static void
5622 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
5623 {
5624 int seg, offset;
5625
5626 if (sizeflag & DFLAG)
5627 {
5628 offset = get32 ();
5629 seg = get16 ();
5630 }
5631 else
5632 {
5633 offset = get16 ();
5634 seg = get16 ();
5635 }
5636 used_prefixes |= (prefixes & PREFIX_DATA);
5637 if (intel_syntax)
5638 snprintf (scratchbuf, sizeof(scratchbuf), "0x%x:0x%x", seg, offset);
5639 else
5640 snprintf (scratchbuf, sizeof(scratchbuf), "$0x%x,$0x%x", seg, offset);
5641 oappend (scratchbuf);
5642 }
5643
5644 static void
5645 OP_OFF (int bytemode, int sizeflag)
5646 {
5647 bfd_vma off;
5648
5649 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5650 intel_operand_size (bytemode, sizeflag);
5651 append_seg ();
5652
5653 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
5654 off = get32 ();
5655 else
5656 off = get16 ();
5657
5658 if (intel_syntax)
5659 {
5660 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5661 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5662 {
5663 oappend (names_seg[ds_reg - es_reg]);
5664 oappend (":");
5665 }
5666 }
5667 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off);
5668 oappend (scratchbuf);
5669 }
5670
5671 static void
5672 OP_OFF64 (int bytemode, int sizeflag)
5673 {
5674 bfd_vma off;
5675
5676 if (address_mode != mode_64bit
5677 || (prefixes & PREFIX_ADDR))
5678 {
5679 OP_OFF (bytemode, sizeflag);
5680 return;
5681 }
5682
5683 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
5684 intel_operand_size (bytemode, sizeflag);
5685 append_seg ();
5686
5687 off = get64 ();
5688
5689 if (intel_syntax)
5690 {
5691 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
5692 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
5693 {
5694 oappend (names_seg[ds_reg - es_reg]);
5695 oappend (":");
5696 }
5697 }
5698 print_operand_value (scratchbuf, sizeof(scratchbuf), 1, off);
5699 oappend (scratchbuf);
5700 }
5701
5702 static void
5703 ptr_reg (int code, int sizeflag)
5704 {
5705 const char *s;
5706
5707 *obufp++ = open_char;
5708 used_prefixes |= (prefixes & PREFIX_ADDR);
5709 if (address_mode == mode_64bit)
5710 {
5711 if (!(sizeflag & AFLAG))
5712 s = names32[code - eAX_reg];
5713 else
5714 s = names64[code - eAX_reg];
5715 }
5716 else if (sizeflag & AFLAG)
5717 s = names32[code - eAX_reg];
5718 else
5719 s = names16[code - eAX_reg];
5720 oappend (s);
5721 *obufp++ = close_char;
5722 *obufp = 0;
5723 }
5724
5725 static void
5726 OP_ESreg (int code, int sizeflag)
5727 {
5728 if (intel_syntax)
5729 {
5730 switch (codep[-1])
5731 {
5732 case 0x6d: /* insw/insl */
5733 intel_operand_size (z_mode, sizeflag);
5734 break;
5735 case 0xa5: /* movsw/movsl/movsq */
5736 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5737 case 0xab: /* stosw/stosl */
5738 case 0xaf: /* scasw/scasl */
5739 intel_operand_size (v_mode, sizeflag);
5740 break;
5741 default:
5742 intel_operand_size (b_mode, sizeflag);
5743 }
5744 }
5745 oappend ("%es:" + intel_syntax);
5746 ptr_reg (code, sizeflag);
5747 }
5748
5749 static void
5750 OP_DSreg (int code, int sizeflag)
5751 {
5752 if (intel_syntax)
5753 {
5754 switch (codep[-1])
5755 {
5756 case 0x6f: /* outsw/outsl */
5757 intel_operand_size (z_mode, sizeflag);
5758 break;
5759 case 0xa5: /* movsw/movsl/movsq */
5760 case 0xa7: /* cmpsw/cmpsl/cmpsq */
5761 case 0xad: /* lodsw/lodsl/lodsq */
5762 intel_operand_size (v_mode, sizeflag);
5763 break;
5764 default:
5765 intel_operand_size (b_mode, sizeflag);
5766 }
5767 }
5768 if ((prefixes
5769 & (PREFIX_CS
5770 | PREFIX_DS
5771 | PREFIX_SS
5772 | PREFIX_ES
5773 | PREFIX_FS
5774 | PREFIX_GS)) == 0)
5775 prefixes |= PREFIX_DS;
5776 append_seg ();
5777 ptr_reg (code, sizeflag);
5778 }
5779
5780 static void
5781 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5782 {
5783 int add = 0;
5784 if (rex & REX_R)
5785 {
5786 USED_REX (REX_R);
5787 add = 8;
5788 }
5789 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
5790 {
5791 used_prefixes |= PREFIX_LOCK;
5792 add = 8;
5793 }
5794 snprintf (scratchbuf, sizeof(scratchbuf), "%%cr%d", modrm.reg + add);
5795 oappend (scratchbuf + intel_syntax);
5796 }
5797
5798 static void
5799 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5800 {
5801 int add = 0;
5802 USED_REX (REX_R);
5803 if (rex & REX_R)
5804 add = 8;
5805 if (intel_syntax)
5806 snprintf (scratchbuf, sizeof(scratchbuf), "db%d", modrm.reg + add);
5807 else
5808 snprintf (scratchbuf, sizeof(scratchbuf), "%%db%d", modrm.reg + add);
5809 oappend (scratchbuf);
5810 }
5811
5812 static void
5813 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5814 {
5815 snprintf (scratchbuf, sizeof(scratchbuf), "%%tr%d", modrm.reg);
5816 oappend (scratchbuf + intel_syntax);
5817 }
5818
5819 static void
5820 OP_R (int bytemode, int sizeflag)
5821 {
5822 if (modrm.mod == 3)
5823 OP_E (bytemode, sizeflag);
5824 else
5825 BadOp ();
5826 }
5827
5828 static void
5829 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5830 {
5831 used_prefixes |= (prefixes & PREFIX_DATA);
5832 if (prefixes & PREFIX_DATA)
5833 {
5834 int add = 0;
5835 USED_REX (REX_R);
5836 if (rex & REX_R)
5837 add = 8;
5838 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add);
5839 }
5840 else
5841 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg);
5842 oappend (scratchbuf + intel_syntax);
5843 }
5844
5845 static void
5846 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5847 {
5848 int add = 0;
5849 USED_REX (REX_R);
5850 if (rex & REX_R)
5851 add = 8;
5852 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.reg + add);
5853 oappend (scratchbuf + intel_syntax);
5854 }
5855
5856 static void
5857 OP_EM (int bytemode, int sizeflag)
5858 {
5859 if (modrm.mod != 3)
5860 {
5861 if (intel_syntax && bytemode == v_mode)
5862 {
5863 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5864 used_prefixes |= (prefixes & PREFIX_DATA);
5865 }
5866 OP_E (bytemode, sizeflag);
5867 return;
5868 }
5869
5870 /* Skip mod/rm byte. */
5871 MODRM_CHECK;
5872 codep++;
5873 used_prefixes |= (prefixes & PREFIX_DATA);
5874 if (prefixes & PREFIX_DATA)
5875 {
5876 int add = 0;
5877
5878 USED_REX (REX_B);
5879 if (rex & REX_B)
5880 add = 8;
5881 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add);
5882 }
5883 else
5884 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm);
5885 oappend (scratchbuf + intel_syntax);
5886 }
5887
5888 /* cvt* are the only instructions in sse2 which have
5889 both SSE and MMX operands and also have 0x66 prefix
5890 in their opcode. 0x66 was originally used to differentiate
5891 between SSE and MMX instruction(operands). So we have to handle the
5892 cvt* separately using OP_EMC and OP_MXC */
5893 static void
5894 OP_EMC (int bytemode, int sizeflag)
5895 {
5896 if (modrm.mod != 3)
5897 {
5898 if (intel_syntax && bytemode == v_mode)
5899 {
5900 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
5901 used_prefixes |= (prefixes & PREFIX_DATA);
5902 }
5903 OP_E (bytemode, sizeflag);
5904 return;
5905 }
5906
5907 /* Skip mod/rm byte. */
5908 MODRM_CHECK;
5909 codep++;
5910 used_prefixes |= (prefixes & PREFIX_DATA);
5911 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.rm);
5912 oappend (scratchbuf + intel_syntax);
5913 }
5914
5915 static void
5916 OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
5917 {
5918 used_prefixes |= (prefixes & PREFIX_DATA);
5919 snprintf (scratchbuf, sizeof(scratchbuf), "%%mm%d", modrm.reg);
5920 oappend (scratchbuf + intel_syntax);
5921 }
5922
5923 static void
5924 OP_EX (int bytemode, int sizeflag)
5925 {
5926 int add = 0;
5927 if (modrm.mod != 3)
5928 {
5929 OP_E (bytemode, sizeflag);
5930 return;
5931 }
5932 USED_REX (REX_B);
5933 if (rex & REX_B)
5934 add = 8;
5935
5936 /* Skip mod/rm byte. */
5937 MODRM_CHECK;
5938 codep++;
5939 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", modrm.rm + add);
5940 oappend (scratchbuf + intel_syntax);
5941 }
5942
5943 static void
5944 OP_MS (int bytemode, int sizeflag)
5945 {
5946 if (modrm.mod == 3)
5947 OP_EM (bytemode, sizeflag);
5948 else
5949 BadOp ();
5950 }
5951
5952 static void
5953 OP_XS (int bytemode, int sizeflag)
5954 {
5955 if (modrm.mod == 3)
5956 OP_EX (bytemode, sizeflag);
5957 else
5958 BadOp ();
5959 }
5960
5961 static void
5962 OP_M (int bytemode, int sizeflag)
5963 {
5964 if (modrm.mod == 3)
5965 /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
5966 BadOp ();
5967 else
5968 OP_E (bytemode, sizeflag);
5969 }
5970
5971 static void
5972 OP_0f07 (int bytemode, int sizeflag)
5973 {
5974 if (modrm.mod != 3 || modrm.rm != 0)
5975 BadOp ();
5976 else
5977 OP_E (bytemode, sizeflag);
5978 }
5979
5980 static void
5981 OP_0fae (int bytemode, int sizeflag)
5982 {
5983 if (modrm.mod == 3)
5984 {
5985 if (modrm.reg == 7)
5986 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
5987
5988 if (modrm.reg < 5 || modrm.rm != 0)
5989 {
5990 BadOp (); /* bad sfence, mfence, or lfence */
5991 return;
5992 }
5993 }
5994 else if (modrm.reg != 7)
5995 {
5996 BadOp (); /* bad clflush */
5997 return;
5998 }
5999
6000 OP_E (bytemode, sizeflag);
6001 }
6002
6003 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
6004 32bit mode and "xchg %rax,%rax" in 64bit mode. */
6005
6006 static void
6007 NOP_Fixup1 (int bytemode, int sizeflag)
6008 {
6009 if ((prefixes & PREFIX_DATA) != 0
6010 || (rex != 0
6011 && rex != 0x48
6012 && address_mode == mode_64bit))
6013 OP_REG (bytemode, sizeflag);
6014 else
6015 strcpy (obuf, "nop");
6016 }
6017
6018 static void
6019 NOP_Fixup2 (int bytemode, int sizeflag)
6020 {
6021 if ((prefixes & PREFIX_DATA) != 0
6022 || (rex != 0
6023 && rex != 0x48
6024 && address_mode == mode_64bit))
6025 OP_IMREG (bytemode, sizeflag);
6026 }
6027
6028 static const char *Suffix3DNow[] = {
6029 /* 00 */ NULL, NULL, NULL, NULL,
6030 /* 04 */ NULL, NULL, NULL, NULL,
6031 /* 08 */ NULL, NULL, NULL, NULL,
6032 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
6033 /* 10 */ NULL, NULL, NULL, NULL,
6034 /* 14 */ NULL, NULL, NULL, NULL,
6035 /* 18 */ NULL, NULL, NULL, NULL,
6036 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
6037 /* 20 */ NULL, NULL, NULL, NULL,
6038 /* 24 */ NULL, NULL, NULL, NULL,
6039 /* 28 */ NULL, NULL, NULL, NULL,
6040 /* 2C */ NULL, NULL, NULL, NULL,
6041 /* 30 */ NULL, NULL, NULL, NULL,
6042 /* 34 */ NULL, NULL, NULL, NULL,
6043 /* 38 */ NULL, NULL, NULL, NULL,
6044 /* 3C */ NULL, NULL, NULL, NULL,
6045 /* 40 */ NULL, NULL, NULL, NULL,
6046 /* 44 */ NULL, NULL, NULL, NULL,
6047 /* 48 */ NULL, NULL, NULL, NULL,
6048 /* 4C */ NULL, NULL, NULL, NULL,
6049 /* 50 */ NULL, NULL, NULL, NULL,
6050 /* 54 */ NULL, NULL, NULL, NULL,
6051 /* 58 */ NULL, NULL, NULL, NULL,
6052 /* 5C */ NULL, NULL, NULL, NULL,
6053 /* 60 */ NULL, NULL, NULL, NULL,
6054 /* 64 */ NULL, NULL, NULL, NULL,
6055 /* 68 */ NULL, NULL, NULL, NULL,
6056 /* 6C */ NULL, NULL, NULL, NULL,
6057 /* 70 */ NULL, NULL, NULL, NULL,
6058 /* 74 */ NULL, NULL, NULL, NULL,
6059 /* 78 */ NULL, NULL, NULL, NULL,
6060 /* 7C */ NULL, NULL, NULL, NULL,
6061 /* 80 */ NULL, NULL, NULL, NULL,
6062 /* 84 */ NULL, NULL, NULL, NULL,
6063 /* 88 */ NULL, NULL, "pfnacc", NULL,
6064 /* 8C */ NULL, NULL, "pfpnacc", NULL,
6065 /* 90 */ "pfcmpge", NULL, NULL, NULL,
6066 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
6067 /* 98 */ NULL, NULL, "pfsub", NULL,
6068 /* 9C */ NULL, NULL, "pfadd", NULL,
6069 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
6070 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
6071 /* A8 */ NULL, NULL, "pfsubr", NULL,
6072 /* AC */ NULL, NULL, "pfacc", NULL,
6073 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
6074 /* B4 */ "pfmul", NULL, "pfrcpit2", "pmulhrw",
6075 /* B8 */ NULL, NULL, NULL, "pswapd",
6076 /* BC */ NULL, NULL, NULL, "pavgusb",
6077 /* C0 */ NULL, NULL, NULL, NULL,
6078 /* C4 */ NULL, NULL, NULL, NULL,
6079 /* C8 */ NULL, NULL, NULL, NULL,
6080 /* CC */ NULL, NULL, NULL, NULL,
6081 /* D0 */ NULL, NULL, NULL, NULL,
6082 /* D4 */ NULL, NULL, NULL, NULL,
6083 /* D8 */ NULL, NULL, NULL, NULL,
6084 /* DC */ NULL, NULL, NULL, NULL,
6085 /* E0 */ NULL, NULL, NULL, NULL,
6086 /* E4 */ NULL, NULL, NULL, NULL,
6087 /* E8 */ NULL, NULL, NULL, NULL,
6088 /* EC */ NULL, NULL, NULL, NULL,
6089 /* F0 */ NULL, NULL, NULL, NULL,
6090 /* F4 */ NULL, NULL, NULL, NULL,
6091 /* F8 */ NULL, NULL, NULL, NULL,
6092 /* FC */ NULL, NULL, NULL, NULL,
6093 };
6094
6095 static void
6096 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6097 {
6098 const char *mnemonic;
6099
6100 FETCH_DATA (the_info, codep + 1);
6101 /* AMD 3DNow! instructions are specified by an opcode suffix in the
6102 place where an 8-bit immediate would normally go. ie. the last
6103 byte of the instruction. */
6104 obufp = obuf + strlen (obuf);
6105 mnemonic = Suffix3DNow[*codep++ & 0xff];
6106 if (mnemonic)
6107 oappend (mnemonic);
6108 else
6109 {
6110 /* Since a variable sized modrm/sib chunk is between the start
6111 of the opcode (0x0f0f) and the opcode suffix, we need to do
6112 all the modrm processing first, and don't know until now that
6113 we have a bad opcode. This necessitates some cleaning up. */
6114 op_out[0][0] = '\0';
6115 op_out[1][0] = '\0';
6116 BadOp ();
6117 }
6118 }
6119
6120 static const char *simd_cmp_op[] = {
6121 "eq",
6122 "lt",
6123 "le",
6124 "unord",
6125 "neq",
6126 "nlt",
6127 "nle",
6128 "ord"
6129 };
6130
6131 static void
6132 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
6133 {
6134 unsigned int cmp_type;
6135
6136 FETCH_DATA (the_info, codep + 1);
6137 obufp = obuf + strlen (obuf);
6138 cmp_type = *codep++ & 0xff;
6139 if (cmp_type < 8)
6140 {
6141 char suffix1 = 'p', suffix2 = 's';
6142 used_prefixes |= (prefixes & PREFIX_REPZ);
6143 if (prefixes & PREFIX_REPZ)
6144 suffix1 = 's';
6145 else
6146 {
6147 used_prefixes |= (prefixes & PREFIX_DATA);
6148 if (prefixes & PREFIX_DATA)
6149 suffix2 = 'd';
6150 else
6151 {
6152 used_prefixes |= (prefixes & PREFIX_REPNZ);
6153 if (prefixes & PREFIX_REPNZ)
6154 suffix1 = 's', suffix2 = 'd';
6155 }
6156 }
6157 snprintf (scratchbuf, sizeof(scratchbuf), "cmp%s%c%c",
6158 simd_cmp_op[cmp_type], suffix1, suffix2);
6159 used_prefixes |= (prefixes & PREFIX_REPZ);
6160 oappend (scratchbuf);
6161 }
6162 else
6163 {
6164 /* We have a bad extension byte. Clean up. */
6165 op_out[0][0] = '\0';
6166 op_out[1][0] = '\0';
6167 BadOp ();
6168 }
6169 }
6170
6171 static void
6172 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
6173 {
6174 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
6175 forms of these instructions. */
6176 if (modrm.mod == 3)
6177 {
6178 char *p = obuf + strlen (obuf);
6179 *(p + 1) = '\0';
6180 *p = *(p - 1);
6181 *(p - 1) = *(p - 2);
6182 *(p - 2) = *(p - 3);
6183 *(p - 3) = extrachar;
6184 }
6185 }
6186
6187 static void
6188 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6189 {
6190 if (modrm.mod == 3 && modrm.reg == 1 && modrm.rm <= 1)
6191 {
6192 /* Override "sidt". */
6193 size_t olen = strlen (obuf);
6194 char *p = obuf + olen - 4;
6195 const char * const *names = (address_mode == mode_64bit
6196 ? names64 : names32);
6197
6198 /* We might have a suffix when disassembling with -Msuffix. */
6199 if (*p == 'i')
6200 --p;
6201
6202 /* Remove "addr16/addr32" if we aren't in Intel mode. */
6203 if (!intel_syntax
6204 && (prefixes & PREFIX_ADDR)
6205 && olen >= (4 + 7)
6206 && *(p - 1) == ' '
6207 && strncmp (p - 7, "addr", 4) == 0
6208 && (strncmp (p - 3, "16", 2) == 0
6209 || strncmp (p - 3, "32", 2) == 0))
6210 p -= 7;
6211
6212 if (modrm.rm)
6213 {
6214 /* mwait %eax,%ecx */
6215 strcpy (p, "mwait");
6216 if (!intel_syntax)
6217 strcpy (op_out[0], names[0]);
6218 }
6219 else
6220 {
6221 /* monitor %eax,%ecx,%edx" */
6222 strcpy (p, "monitor");
6223 if (!intel_syntax)
6224 {
6225 const char * const *op1_names;
6226 if (!(prefixes & PREFIX_ADDR))
6227 op1_names = (address_mode == mode_16bit
6228 ? names16 : names);
6229 else
6230 {
6231 op1_names = (address_mode != mode_32bit
6232 ? names32 : names16);
6233 used_prefixes |= PREFIX_ADDR;
6234 }
6235 strcpy (op_out[0], op1_names[0]);
6236 strcpy (op_out[2], names[2]);
6237 }
6238 }
6239 if (!intel_syntax)
6240 {
6241 strcpy (op_out[1], names[1]);
6242 two_source_ops = 1;
6243 }
6244
6245 codep++;
6246 }
6247 else
6248 OP_M (0, sizeflag);
6249 }
6250
6251 static void
6252 SVME_Fixup (int bytemode, int sizeflag)
6253 {
6254 const char *alt;
6255 char *p;
6256
6257 switch (*codep)
6258 {
6259 case 0xd8:
6260 alt = "vmrun";
6261 break;
6262 case 0xd9:
6263 alt = "vmmcall";
6264 break;
6265 case 0xda:
6266 alt = "vmload";
6267 break;
6268 case 0xdb:
6269 alt = "vmsave";
6270 break;
6271 case 0xdc:
6272 alt = "stgi";
6273 break;
6274 case 0xdd:
6275 alt = "clgi";
6276 break;
6277 case 0xde:
6278 alt = "skinit";
6279 break;
6280 case 0xdf:
6281 alt = "invlpga";
6282 break;
6283 default:
6284 OP_M (bytemode, sizeflag);
6285 return;
6286 }
6287 /* Override "lidt". */
6288 p = obuf + strlen (obuf) - 4;
6289 /* We might have a suffix. */
6290 if (*p == 'i')
6291 --p;
6292 strcpy (p, alt);
6293 if (!(prefixes & PREFIX_ADDR))
6294 {
6295 ++codep;
6296 return;
6297 }
6298 used_prefixes |= PREFIX_ADDR;
6299 switch (*codep++)
6300 {
6301 case 0xdf:
6302 strcpy (op_out[1], names32[1]);
6303 two_source_ops = 1;
6304 /* Fall through. */
6305 case 0xd8:
6306 case 0xda:
6307 case 0xdb:
6308 *obufp++ = open_char;
6309 if (address_mode == mode_64bit || (sizeflag & AFLAG))
6310 alt = names32[0];
6311 else
6312 alt = names16[0];
6313 strcpy (obufp, alt);
6314 obufp += strlen (alt);
6315 *obufp++ = close_char;
6316 *obufp = '\0';
6317 break;
6318 }
6319 }
6320
6321 static void
6322 INVLPG_Fixup (int bytemode, int sizeflag)
6323 {
6324 const char *alt;
6325
6326 switch (*codep)
6327 {
6328 case 0xf8:
6329 alt = "swapgs";
6330 break;
6331 case 0xf9:
6332 alt = "rdtscp";
6333 break;
6334 default:
6335 OP_M (bytemode, sizeflag);
6336 return;
6337 }
6338 /* Override "invlpg". */
6339 strcpy (obuf + strlen (obuf) - 6, alt);
6340 codep++;
6341 }
6342
6343 static void
6344 BadOp (void)
6345 {
6346 /* Throw away prefixes and 1st. opcode byte. */
6347 codep = insn_codep + 1;
6348 oappend ("(bad)");
6349 }
6350
6351 static void
6352 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
6353 {
6354 if (modrm.mod == 3
6355 && modrm.reg == 0
6356 && modrm.rm >=1
6357 && modrm.rm <= 4)
6358 {
6359 /* Override "sgdt". */
6360 char *p = obuf + strlen (obuf) - 4;
6361
6362 /* We might have a suffix when disassembling with -Msuffix. */
6363 if (*p == 'g')
6364 --p;
6365
6366 switch (modrm.rm)
6367 {
6368 case 1:
6369 strcpy (p, "vmcall");
6370 break;
6371 case 2:
6372 strcpy (p, "vmlaunch");
6373 break;
6374 case 3:
6375 strcpy (p, "vmresume");
6376 break;
6377 case 4:
6378 strcpy (p, "vmxoff");
6379 break;
6380 }
6381
6382 codep++;
6383 }
6384 else
6385 OP_E (0, sizeflag);
6386 }
6387
6388 static void
6389 OP_VMX (int bytemode, int sizeflag)
6390 {
6391 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
6392 if (prefixes & PREFIX_DATA)
6393 strcpy (obuf, "vmclear");
6394 else if (prefixes & PREFIX_REPZ)
6395 strcpy (obuf, "vmxon");
6396 else
6397 strcpy (obuf, "vmptrld");
6398 OP_E (bytemode, sizeflag);
6399 }
6400
6401 static void
6402 REP_Fixup (int bytemode, int sizeflag)
6403 {
6404 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
6405 lods and stos. */
6406 size_t ilen = 0;
6407
6408 if (prefixes & PREFIX_REPZ)
6409 switch (*insn_codep)
6410 {
6411 case 0x6e: /* outsb */
6412 case 0x6f: /* outsw/outsl */
6413 case 0xa4: /* movsb */
6414 case 0xa5: /* movsw/movsl/movsq */
6415 if (!intel_syntax)
6416 ilen = 5;
6417 else
6418 ilen = 4;
6419 break;
6420 case 0xaa: /* stosb */
6421 case 0xab: /* stosw/stosl/stosq */
6422 case 0xac: /* lodsb */
6423 case 0xad: /* lodsw/lodsl/lodsq */
6424 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
6425 ilen = 5;
6426 else
6427 ilen = 4;
6428 break;
6429 case 0x6c: /* insb */
6430 case 0x6d: /* insl/insw */
6431 if (!intel_syntax)
6432 ilen = 4;
6433 else
6434 ilen = 3;
6435 break;
6436 default:
6437 abort ();
6438 break;
6439 }
6440
6441 if (ilen != 0)
6442 {
6443 size_t olen;
6444 char *p;
6445
6446 olen = strlen (obuf);
6447 p = obuf + olen - ilen - 1 - 4;
6448 /* Handle "repz [addr16|addr32]". */
6449 if ((prefixes & PREFIX_ADDR))
6450 p -= 1 + 6;
6451
6452 memmove (p + 3, p + 4, olen - (p + 3 - obuf));
6453 }
6454
6455 switch (bytemode)
6456 {
6457 case al_reg:
6458 case eAX_reg:
6459 case indir_dx_reg:
6460 OP_IMREG (bytemode, sizeflag);
6461 break;
6462 case eDI_reg:
6463 OP_ESreg (bytemode, sizeflag);
6464 break;
6465 case eSI_reg:
6466 OP_DSreg (bytemode, sizeflag);
6467 break;
6468 default:
6469 abort ();
6470 break;
6471 }
6472 }
6473
6474 static void
6475 CMPXCHG8B_Fixup (int bytemode, int sizeflag)
6476 {
6477 USED_REX (REX_W);
6478 if (rex & REX_W)
6479 {
6480 /* Change cmpxchg8b to cmpxchg16b. */
6481 char *p = obuf + strlen (obuf) - 2;
6482 strcpy (p, "16b");
6483 bytemode = o_mode;
6484 }
6485 OP_M (bytemode, sizeflag);
6486 }
6487
6488 static void
6489 XMM_Fixup (int reg, int sizeflag ATTRIBUTE_UNUSED)
6490 {
6491 snprintf (scratchbuf, sizeof(scratchbuf), "%%xmm%d", reg);
6492 oappend (scratchbuf + intel_syntax);
6493 }
6494
6495 static void
6496 CRC32_Fixup (int bytemode, int sizeflag)
6497 {
6498 /* Add proper suffix to "crc32". */
6499 char *p = obuf + strlen (obuf);
6500
6501 switch (bytemode)
6502 {
6503 case b_mode:
6504 if (intel_syntax)
6505 break;
6506
6507 *p++ = 'b';
6508 break;
6509 case v_mode:
6510 if (intel_syntax)
6511 break;
6512
6513 USED_REX (REX_W);
6514 if (rex & REX_W)
6515 *p++ = 'q';
6516 else if (sizeflag & DFLAG)
6517 *p++ = 'l';
6518 else
6519 *p++ = 'w';
6520 used_prefixes |= (prefixes & PREFIX_DATA);
6521 break;
6522 default:
6523 oappend (INTERNAL_DISASSEMBLER_ERROR);
6524 break;
6525 }
6526 *p = '\0';
6527
6528 if (modrm.mod == 3)
6529 {
6530 int add;
6531
6532 /* Skip mod/rm byte. */
6533 MODRM_CHECK;
6534 codep++;
6535
6536 USED_REX (REX_B);
6537 add = (rex & REX_B) ? 8 : 0;
6538 if (bytemode == b_mode)
6539 {
6540 USED_REX (0);
6541 if (rex)
6542 oappend (names8rex[modrm.rm + add]);
6543 else
6544 oappend (names8[modrm.rm + add]);
6545 }
6546 else
6547 {
6548 USED_REX (REX_W);
6549 if (rex & REX_W)
6550 oappend (names64[modrm.rm + add]);
6551 else if ((prefixes & PREFIX_DATA))
6552 oappend (names16[modrm.rm + add]);
6553 else
6554 oappend (names32[modrm.rm + add]);
6555 }
6556 }
6557 else
6558 OP_E (bytemode, sizeflag);
6559 }
QEmu