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