projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
gas/testsuite/
[deliverable/binutils-gdb.git] / opcodes / i386-dis.c
1 /* Print i386 instructions for GDB, the GNU debugger.
2 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
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 "dis-asm.h"
35 #include "sysdep.h"
36 #include "opintl.h"
37
38 #define MAXLEN 15
39
40 #include <setjmp.h>
41
42 #ifndef UNIXWARE_COMPAT
43 /* Set non-zero for broken, compatible instructions. Set to zero for
44 non-broken opcodes. */
45 #define UNIXWARE_COMPAT 1
46 #endif
47
48 static int fetch_data (struct disassemble_info *, bfd_byte *);
49 static void ckprefix (void);
50 static const char *prefix_name (int, int);
51 static int print_insn (bfd_vma, disassemble_info *);
52 static void dofloat (int);
53 static void OP_ST (int, int);
54 static void OP_STi (int, int);
55 static int putop (const char *, int);
56 static void oappend (const char *);
57 static void append_seg (void);
58 static void OP_indirE (int, int);
59 static void print_operand_value (char *, int, bfd_vma);
60 static void OP_E (int, int);
61 static void OP_G (int, int);
62 static bfd_vma get64 (void);
63 static bfd_signed_vma get32 (void);
64 static bfd_signed_vma get32s (void);
65 static int get16 (void);
66 static void set_op (bfd_vma, int);
67 static void OP_REG (int, int);
68 static void OP_IMREG (int, int);
69 static void OP_I (int, int);
70 static void OP_I64 (int, int);
71 static void OP_sI (int, int);
72 static void OP_J (int, int);
73 static void OP_SEG (int, int);
74 static void OP_DIR (int, int);
75 static void OP_OFF (int, int);
76 static void OP_OFF64 (int, int);
77 static void ptr_reg (int, int);
78 static void OP_ESreg (int, int);
79 static void OP_DSreg (int, int);
80 static void OP_C (int, int);
81 static void OP_D (int, int);
82 static void OP_T (int, int);
83 static void OP_Rd (int, int);
84 static void OP_MMX (int, int);
85 static void OP_XMM (int, int);
86 static void OP_EM (int, int);
87 static void OP_EX (int, int);
88 static void OP_MS (int, int);
89 static void OP_XS (int, int);
90 static void OP_M (int, int);
91 static void OP_VMX (int, int);
92 static void OP_0fae (int, int);
93 static void OP_0f07 (int, int);
94 static void NOP_Fixup1 (int, int);
95 static void NOP_Fixup2 (int, int);
96 static void OP_3DNowSuffix (int, int);
97 static void OP_SIMD_Suffix (int, int);
98 static void SIMD_Fixup (int, int);
99 static void PNI_Fixup (int, int);
100 static void SVME_Fixup (int, int);
101 static void INVLPG_Fixup (int, int);
102 static void BadOp (void);
103 static void SEG_Fixup (int, int);
104 static void VMX_Fixup (int, int);
105 static void REP_Fixup (int, int);
106
107 struct dis_private {
108 /* Points to first byte not fetched. */
109 bfd_byte *max_fetched;
110 bfd_byte the_buffer[MAXLEN];
111 bfd_vma insn_start;
112 int orig_sizeflag;
113 jmp_buf bailout;
114 };
115
116 /* The opcode for the fwait instruction, which we treat as a prefix
117 when we can. */
118 #define FWAIT_OPCODE (0x9b)
119
120 enum address_mode
121 {
122 mode_16bit,
123 mode_32bit,
124 mode_64bit
125 };
126
127 enum address_mode address_mode;
128
129 /* Flags for the prefixes for the current instruction. See below. */
130 static int prefixes;
131
132 /* REX prefix the current instruction. See below. */
133 static int rex;
134 /* Bits of REX we've already used. */
135 static int rex_used;
136 #define REX_MODE64 8
137 #define REX_EXTX 4
138 #define REX_EXTY 2
139 #define REX_EXTZ 1
140 /* Mark parts used in the REX prefix. When we are testing for
141 empty prefix (for 8bit register REX extension), just mask it
142 out. Otherwise test for REX bit is excuse for existence of REX
143 only in case value is nonzero. */
144 #define USED_REX(value) \
145 { \
146 if (value) \
147 rex_used |= (rex & value) ? (value) | 0x40 : 0; \
148 else \
149 rex_used |= 0x40; \
150 }
151
152 /* Flags for prefixes which we somehow handled when printing the
153 current instruction. */
154 static int used_prefixes;
155
156 /* Flags stored in PREFIXES. */
157 #define PREFIX_REPZ 1
158 #define PREFIX_REPNZ 2
159 #define PREFIX_LOCK 4
160 #define PREFIX_CS 8
161 #define PREFIX_SS 0x10
162 #define PREFIX_DS 0x20
163 #define PREFIX_ES 0x40
164 #define PREFIX_FS 0x80
165 #define PREFIX_GS 0x100
166 #define PREFIX_DATA 0x200
167 #define PREFIX_ADDR 0x400
168 #define PREFIX_FWAIT 0x800
169
170 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
171 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
172 on error. */
173 #define FETCH_DATA(info, addr) \
174 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
175 ? 1 : fetch_data ((info), (addr)))
176
177 static int
178 fetch_data (struct disassemble_info *info, bfd_byte *addr)
179 {
180 int status;
181 struct dis_private *priv = (struct dis_private *) info->private_data;
182 bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
183
184 if (addr <= priv->the_buffer + MAXLEN)
185 status = (*info->read_memory_func) (start,
186 priv->max_fetched,
187 addr - priv->max_fetched,
188 info);
189 else
190 status = -1;
191 if (status != 0)
192 {
193 /* If we did manage to read at least one byte, then
194 print_insn_i386 will do something sensible. Otherwise, print
195 an error. We do that here because this is where we know
196 STATUS. */
197 if (priv->max_fetched == priv->the_buffer)
198 (*info->memory_error_func) (status, start, info);
199 longjmp (priv->bailout, 1);
200 }
201 else
202 priv->max_fetched = addr;
203 return 1;
204 }
205
206 #define XX NULL, 0
207
208 #define Eb OP_E, b_mode
209 #define Ev OP_E, v_mode
210 #define Ed OP_E, d_mode
211 #define Eq OP_E, q_mode
212 #define Edq OP_E, dq_mode
213 #define Edqw OP_E, dqw_mode
214 #define indirEv OP_indirE, stack_v_mode
215 #define indirEp OP_indirE, f_mode
216 #define stackEv OP_E, stack_v_mode
217 #define Em OP_E, m_mode
218 #define Ew OP_E, w_mode
219 #define Ma OP_E, v_mode
220 #define M OP_M, 0 /* lea, lgdt, etc. */
221 #define Mp OP_M, f_mode /* 32 or 48 bit memory operand for LDS, LES etc */
222 #define Gb OP_G, b_mode
223 #define Gv OP_G, v_mode
224 #define Gd OP_G, d_mode
225 #define Gdq OP_G, dq_mode
226 #define Gm OP_G, m_mode
227 #define Gw OP_G, w_mode
228 #define Rd OP_Rd, d_mode
229 #define Rm OP_Rd, m_mode
230 #define Ib OP_I, b_mode
231 #define sIb OP_sI, b_mode /* sign extened byte */
232 #define Iv OP_I, v_mode
233 #define Iq OP_I, q_mode
234 #define Iv64 OP_I64, v_mode
235 #define Iw OP_I, w_mode
236 #define I1 OP_I, const_1_mode
237 #define Jb OP_J, b_mode
238 #define Jv OP_J, v_mode
239 #define Cm OP_C, m_mode
240 #define Dm OP_D, m_mode
241 #define Td OP_T, d_mode
242 #define Sv SEG_Fixup, v_mode
243
244 #define RMeAX OP_REG, eAX_reg
245 #define RMeBX OP_REG, eBX_reg
246 #define RMeCX OP_REG, eCX_reg
247 #define RMeDX OP_REG, eDX_reg
248 #define RMeSP OP_REG, eSP_reg
249 #define RMeBP OP_REG, eBP_reg
250 #define RMeSI OP_REG, eSI_reg
251 #define RMeDI OP_REG, eDI_reg
252 #define RMrAX OP_REG, rAX_reg
253 #define RMrBX OP_REG, rBX_reg
254 #define RMrCX OP_REG, rCX_reg
255 #define RMrDX OP_REG, rDX_reg
256 #define RMrSP OP_REG, rSP_reg
257 #define RMrBP OP_REG, rBP_reg
258 #define RMrSI OP_REG, rSI_reg
259 #define RMrDI OP_REG, rDI_reg
260 #define RMAL OP_REG, al_reg
261 #define RMAL OP_REG, al_reg
262 #define RMCL OP_REG, cl_reg
263 #define RMDL OP_REG, dl_reg
264 #define RMBL OP_REG, bl_reg
265 #define RMAH OP_REG, ah_reg
266 #define RMCH OP_REG, ch_reg
267 #define RMDH OP_REG, dh_reg
268 #define RMBH OP_REG, bh_reg
269 #define RMAX OP_REG, ax_reg
270 #define RMDX OP_REG, dx_reg
271
272 #define eAX OP_IMREG, eAX_reg
273 #define eBX OP_IMREG, eBX_reg
274 #define eCX OP_IMREG, eCX_reg
275 #define eDX OP_IMREG, eDX_reg
276 #define eSP OP_IMREG, eSP_reg
277 #define eBP OP_IMREG, eBP_reg
278 #define eSI OP_IMREG, eSI_reg
279 #define eDI OP_IMREG, eDI_reg
280 #define AL OP_IMREG, al_reg
281 #define CL OP_IMREG, cl_reg
282 #define DL OP_IMREG, dl_reg
283 #define BL OP_IMREG, bl_reg
284 #define AH OP_IMREG, ah_reg
285 #define CH OP_IMREG, ch_reg
286 #define DH OP_IMREG, dh_reg
287 #define BH OP_IMREG, bh_reg
288 #define AX OP_IMREG, ax_reg
289 #define DX OP_IMREG, dx_reg
290 #define indirDX OP_IMREG, indir_dx_reg
291
292 #define Sw OP_SEG, w_mode
293 #define Ap OP_DIR, 0
294 #define Ob OP_OFF64, b_mode
295 #define Ov OP_OFF64, v_mode
296 #define Xb OP_DSreg, eSI_reg
297 #define Xv OP_DSreg, eSI_reg
298 #define Yb OP_ESreg, eDI_reg
299 #define Yv OP_ESreg, eDI_reg
300 #define DSBX OP_DSreg, eBX_reg
301
302 #define es OP_REG, es_reg
303 #define ss OP_REG, ss_reg
304 #define cs OP_REG, cs_reg
305 #define ds OP_REG, ds_reg
306 #define fs OP_REG, fs_reg
307 #define gs OP_REG, gs_reg
308
309 #define MX OP_MMX, 0
310 #define XM OP_XMM, 0
311 #define EM OP_EM, v_mode
312 #define EX OP_EX, v_mode
313 #define MS OP_MS, v_mode
314 #define XS OP_XS, v_mode
315 #define VM OP_VMX, q_mode
316 #define OPSUF OP_3DNowSuffix, 0
317 #define OPSIMD OP_SIMD_Suffix, 0
318
319 /* Used handle "rep" prefix for string instructions. */
320 #define Xbr REP_Fixup, eSI_reg
321 #define Xvr REP_Fixup, eSI_reg
322 #define Ybr REP_Fixup, eDI_reg
323 #define Yvr REP_Fixup, eDI_reg
324 #define indirDXr REP_Fixup, indir_dx_reg
325 #define ALr REP_Fixup, al_reg
326 #define eAXr REP_Fixup, eAX_reg
327
328 #define cond_jump_flag NULL, cond_jump_mode
329 #define loop_jcxz_flag NULL, loop_jcxz_mode
330
331 /* bits in sizeflag */
332 #define SUFFIX_ALWAYS 4
333 #define AFLAG 2
334 #define DFLAG 1
335
336 #define b_mode 1 /* byte operand */
337 #define v_mode 2 /* operand size depends on prefixes */
338 #define w_mode 3 /* word operand */
339 #define d_mode 4 /* double word operand */
340 #define q_mode 5 /* quad word operand */
341 #define t_mode 6 /* ten-byte operand */
342 #define x_mode 7 /* 16-byte XMM operand */
343 #define m_mode 8 /* d_mode in 32bit, q_mode in 64bit mode. */
344 #define cond_jump_mode 9
345 #define loop_jcxz_mode 10
346 #define dq_mode 11 /* operand size depends on REX prefixes. */
347 #define dqw_mode 12 /* registers like dq_mode, memory like w_mode. */
348 #define f_mode 13 /* 4- or 6-byte pointer operand */
349 #define const_1_mode 14
350 #define stack_v_mode 15 /* v_mode for stack-related opcodes. */
351
352 #define es_reg 100
353 #define cs_reg 101
354 #define ss_reg 102
355 #define ds_reg 103
356 #define fs_reg 104
357 #define gs_reg 105
358
359 #define eAX_reg 108
360 #define eCX_reg 109
361 #define eDX_reg 110
362 #define eBX_reg 111
363 #define eSP_reg 112
364 #define eBP_reg 113
365 #define eSI_reg 114
366 #define eDI_reg 115
367
368 #define al_reg 116
369 #define cl_reg 117
370 #define dl_reg 118
371 #define bl_reg 119
372 #define ah_reg 120
373 #define ch_reg 121
374 #define dh_reg 122
375 #define bh_reg 123
376
377 #define ax_reg 124
378 #define cx_reg 125
379 #define dx_reg 126
380 #define bx_reg 127
381 #define sp_reg 128
382 #define bp_reg 129
383 #define si_reg 130
384 #define di_reg 131
385
386 #define rAX_reg 132
387 #define rCX_reg 133
388 #define rDX_reg 134
389 #define rBX_reg 135
390 #define rSP_reg 136
391 #define rBP_reg 137
392 #define rSI_reg 138
393 #define rDI_reg 139
394
395 #define indir_dx_reg 150
396
397 #define FLOATCODE 1
398 #define USE_GROUPS 2
399 #define USE_PREFIX_USER_TABLE 3
400 #define X86_64_SPECIAL 4
401 #define IS_3BYTE_OPCODE 5
402
403 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
404
405 #define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0
406 #define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0
407 #define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0
408 #define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0
409 #define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0
410 #define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0
411 #define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0
412 #define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0
413 #define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0
414 #define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0
415 #define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0
416 #define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0
417 #define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0
418 #define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0
419 #define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0
420 #define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0
421 #define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0
422 #define GRP12 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0
423 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0
424 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0
425 #define GRP15 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
426 #define GRP16 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
427 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
428 #define GRPPADLCK1 NULL, NULL, USE_GROUPS, NULL, 23, NULL, 0
429 #define GRPPADLCK2 NULL, NULL, USE_GROUPS, NULL, 24, NULL, 0
430
431 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0
432 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0
433 #define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0
434 #define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0
435 #define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0
436 #define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0
437 #define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0
438 #define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0
439 #define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0
440 #define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0
441 #define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0
442 #define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0
443 #define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0
444 #define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0
445 #define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0
446 #define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0
447 #define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0
448 #define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0
449 #define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0
450 #define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0
451 #define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0
452 #define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0
453 #define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0
454 #define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0
455 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
456 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
457 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
458 #define PREGRP27 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 27, NULL, 0
459 #define PREGRP28 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 28, NULL, 0
460 #define PREGRP29 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 29, NULL, 0
461 #define PREGRP30 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 30, NULL, 0
462 #define PREGRP31 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 31, NULL, 0
463 #define PREGRP32 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 32, NULL, 0
464
465 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0
466
467 #define THREE_BYTE_0 NULL, NULL, IS_3BYTE_OPCODE, NULL, 0, NULL, 0
468 #define THREE_BYTE_1 NULL, NULL, IS_3BYTE_OPCODE, NULL, 1, NULL, 0
469
470 typedef void (*op_rtn) (int bytemode, int sizeflag);
471
472 struct dis386 {
473 const char *name;
474 op_rtn op1;
475 int bytemode1;
476 op_rtn op2;
477 int bytemode2;
478 op_rtn op3;
479 int bytemode3;
480 };
481
482 /* Upper case letters in the instruction names here are macros.
483 'A' => print 'b' if no register operands or suffix_always is true
484 'B' => print 'b' if suffix_always is true
485 'C' => print 's' or 'l' ('w' or 'd' in Intel mode) depending on operand
486 . size prefix
487 'E' => print 'e' if 32-bit form of jcxz
488 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
489 'H' => print ",pt" or ",pn" branch hint
490 'I' => honor following macro letter even in Intel mode (implemented only
491 . for some of the macro letters)
492 'J' => print 'l'
493 'L' => print 'l' if suffix_always is true
494 'N' => print 'n' if instruction has no wait "prefix"
495 'O' => print 'd', or 'o'
496 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
497 . or suffix_always is true. print 'q' if rex prefix is present.
498 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
499 . is true
500 'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
501 'S' => print 'w', 'l' or 'q' if suffix_always is true
502 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
503 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
504 'V' => print 'q' in 64bit mode and behave as 'S' otherwise
505 'W' => print 'b' or 'w' ("w" or "de" in intel mode)
506 'X' => print 's', 'd' depending on data16 prefix (for XMM)
507 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
508 'Z' => print 'q' in 64bit mode and behave as 'L' otherwise
509
510 Many of the above letters print nothing in Intel mode. See "putop"
511 for the details.
512
513 Braces '{' and '}', and vertical bars '|', indicate alternative
514 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
515 modes. In cases where there are only two alternatives, the X86_64
516 instruction is reserved, and "(bad)" is printed.
517 */
518
519 static const struct dis386 dis386[] = {
520 /* 00 */
521 { "addB", Eb, Gb, XX },
522 { "addS", Ev, Gv, XX },
523 { "addB", Gb, Eb, XX },
524 { "addS", Gv, Ev, XX },
525 { "addB", AL, Ib, XX },
526 { "addS", eAX, Iv, XX },
527 { "push{T|}", es, XX, XX },
528 { "pop{T|}", es, XX, XX },
529 /* 08 */
530 { "orB", Eb, Gb, XX },
531 { "orS", Ev, Gv, XX },
532 { "orB", Gb, Eb, XX },
533 { "orS", Gv, Ev, XX },
534 { "orB", AL, Ib, XX },
535 { "orS", eAX, Iv, XX },
536 { "push{T|}", cs, XX, XX },
537 { "(bad)", XX, XX, XX }, /* 0x0f extended opcode escape */
538 /* 10 */
539 { "adcB", Eb, Gb, XX },
540 { "adcS", Ev, Gv, XX },
541 { "adcB", Gb, Eb, XX },
542 { "adcS", Gv, Ev, XX },
543 { "adcB", AL, Ib, XX },
544 { "adcS", eAX, Iv, XX },
545 { "push{T|}", ss, XX, XX },
546 { "pop{T|}", ss, XX, XX },
547 /* 18 */
548 { "sbbB", Eb, Gb, XX },
549 { "sbbS", Ev, Gv, XX },
550 { "sbbB", Gb, Eb, XX },
551 { "sbbS", Gv, Ev, XX },
552 { "sbbB", AL, Ib, XX },
553 { "sbbS", eAX, Iv, XX },
554 { "push{T|}", ds, XX, XX },
555 { "pop{T|}", ds, XX, XX },
556 /* 20 */
557 { "andB", Eb, Gb, XX },
558 { "andS", Ev, Gv, XX },
559 { "andB", Gb, Eb, XX },
560 { "andS", Gv, Ev, XX },
561 { "andB", AL, Ib, XX },
562 { "andS", eAX, Iv, XX },
563 { "(bad)", XX, XX, XX }, /* SEG ES prefix */
564 { "daa{|}", XX, XX, XX },
565 /* 28 */
566 { "subB", Eb, Gb, XX },
567 { "subS", Ev, Gv, XX },
568 { "subB", Gb, Eb, XX },
569 { "subS", Gv, Ev, XX },
570 { "subB", AL, Ib, XX },
571 { "subS", eAX, Iv, XX },
572 { "(bad)", XX, XX, XX }, /* SEG CS prefix */
573 { "das{|}", XX, XX, XX },
574 /* 30 */
575 { "xorB", Eb, Gb, XX },
576 { "xorS", Ev, Gv, XX },
577 { "xorB", Gb, Eb, XX },
578 { "xorS", Gv, Ev, XX },
579 { "xorB", AL, Ib, XX },
580 { "xorS", eAX, Iv, XX },
581 { "(bad)", XX, XX, XX }, /* SEG SS prefix */
582 { "aaa{|}", XX, XX, XX },
583 /* 38 */
584 { "cmpB", Eb, Gb, XX },
585 { "cmpS", Ev, Gv, XX },
586 { "cmpB", Gb, Eb, XX },
587 { "cmpS", Gv, Ev, XX },
588 { "cmpB", AL, Ib, XX },
589 { "cmpS", eAX, Iv, XX },
590 { "(bad)", XX, XX, XX }, /* SEG DS prefix */
591 { "aas{|}", XX, XX, XX },
592 /* 40 */
593 { "inc{S|}", RMeAX, XX, XX },
594 { "inc{S|}", RMeCX, XX, XX },
595 { "inc{S|}", RMeDX, XX, XX },
596 { "inc{S|}", RMeBX, XX, XX },
597 { "inc{S|}", RMeSP, XX, XX },
598 { "inc{S|}", RMeBP, XX, XX },
599 { "inc{S|}", RMeSI, XX, XX },
600 { "inc{S|}", RMeDI, XX, XX },
601 /* 48 */
602 { "dec{S|}", RMeAX, XX, XX },
603 { "dec{S|}", RMeCX, XX, XX },
604 { "dec{S|}", RMeDX, XX, XX },
605 { "dec{S|}", RMeBX, XX, XX },
606 { "dec{S|}", RMeSP, XX, XX },
607 { "dec{S|}", RMeBP, XX, XX },
608 { "dec{S|}", RMeSI, XX, XX },
609 { "dec{S|}", RMeDI, XX, XX },
610 /* 50 */
611 { "pushV", RMrAX, XX, XX },
612 { "pushV", RMrCX, XX, XX },
613 { "pushV", RMrDX, XX, XX },
614 { "pushV", RMrBX, XX, XX },
615 { "pushV", RMrSP, XX, XX },
616 { "pushV", RMrBP, XX, XX },
617 { "pushV", RMrSI, XX, XX },
618 { "pushV", RMrDI, XX, XX },
619 /* 58 */
620 { "popV", RMrAX, XX, XX },
621 { "popV", RMrCX, XX, XX },
622 { "popV", RMrDX, XX, XX },
623 { "popV", RMrBX, XX, XX },
624 { "popV", RMrSP, XX, XX },
625 { "popV", RMrBP, XX, XX },
626 { "popV", RMrSI, XX, XX },
627 { "popV", RMrDI, XX, XX },
628 /* 60 */
629 { "pusha{P|}", XX, XX, XX },
630 { "popa{P|}", XX, XX, XX },
631 { "bound{S|}", Gv, Ma, XX },
632 { X86_64_0 },
633 { "(bad)", XX, XX, XX }, /* seg fs */
634 { "(bad)", XX, XX, XX }, /* seg gs */
635 { "(bad)", XX, XX, XX }, /* op size prefix */
636 { "(bad)", XX, XX, XX }, /* adr size prefix */
637 /* 68 */
638 { "pushT", Iq, XX, XX },
639 { "imulS", Gv, Ev, Iv },
640 { "pushT", sIb, XX, XX },
641 { "imulS", Gv, Ev, sIb },
642 { "ins{b||b|}", Ybr, indirDX, XX },
643 { "ins{R||R|}", Yvr, indirDX, XX },
644 { "outs{b||b|}", indirDXr, Xb, XX },
645 { "outs{R||R|}", indirDXr, Xv, XX },
646 /* 70 */
647 { "joH", Jb, XX, cond_jump_flag },
648 { "jnoH", Jb, XX, cond_jump_flag },
649 { "jbH", Jb, XX, cond_jump_flag },
650 { "jaeH", Jb, XX, cond_jump_flag },
651 { "jeH", Jb, XX, cond_jump_flag },
652 { "jneH", Jb, XX, cond_jump_flag },
653 { "jbeH", Jb, XX, cond_jump_flag },
654 { "jaH", Jb, XX, cond_jump_flag },
655 /* 78 */
656 { "jsH", Jb, XX, cond_jump_flag },
657 { "jnsH", Jb, XX, cond_jump_flag },
658 { "jpH", Jb, XX, cond_jump_flag },
659 { "jnpH", Jb, XX, cond_jump_flag },
660 { "jlH", Jb, XX, cond_jump_flag },
661 { "jgeH", Jb, XX, cond_jump_flag },
662 { "jleH", Jb, XX, cond_jump_flag },
663 { "jgH", Jb, XX, cond_jump_flag },
664 /* 80 */
665 { GRP1b },
666 { GRP1S },
667 { "(bad)", XX, XX, XX },
668 { GRP1Ss },
669 { "testB", Eb, Gb, XX },
670 { "testS", Ev, Gv, XX },
671 { "xchgB", Eb, Gb, XX },
672 { "xchgS", Ev, Gv, XX },
673 /* 88 */
674 { "movB", Eb, Gb, XX },
675 { "movS", Ev, Gv, XX },
676 { "movB", Gb, Eb, XX },
677 { "movS", Gv, Ev, XX },
678 { "movQ", Sv, Sw, XX },
679 { "leaS", Gv, M, XX },
680 { "movQ", Sw, Sv, XX },
681 { "popU", stackEv, XX, XX },
682 /* 90 */
683 { "xchgS", NOP_Fixup1, eAX_reg, NOP_Fixup2, eAX_reg, XX },
684 { "xchgS", RMeCX, eAX, XX },
685 { "xchgS", RMeDX, eAX, XX },
686 { "xchgS", RMeBX, eAX, XX },
687 { "xchgS", RMeSP, eAX, XX },
688 { "xchgS", RMeBP, eAX, XX },
689 { "xchgS", RMeSI, eAX, XX },
690 { "xchgS", RMeDI, eAX, XX },
691 /* 98 */
692 { "cW{tR||tR|}", XX, XX, XX },
693 { "cR{tO||tO|}", XX, XX, XX },
694 { "Jcall{T|}", Ap, XX, XX },
695 { "(bad)", XX, XX, XX }, /* fwait */
696 { "pushfT", XX, XX, XX },
697 { "popfT", XX, XX, XX },
698 { "sahf{|}", XX, XX, XX },
699 { "lahf{|}", XX, XX, XX },
700 /* a0 */
701 { "movB", AL, Ob, XX },
702 { "movS", eAX, Ov, XX },
703 { "movB", Ob, AL, XX },
704 { "movS", Ov, eAX, XX },
705 { "movs{b||b|}", Ybr, Xb, XX },
706 { "movs{R||R|}", Yvr, Xv, XX },
707 { "cmps{b||b|}", Xb, Yb, XX },
708 { "cmps{R||R|}", Xv, Yv, XX },
709 /* a8 */
710 { "testB", AL, Ib, XX },
711 { "testS", eAX, Iv, XX },
712 { "stosB", Ybr, AL, XX },
713 { "stosS", Yvr, eAX, XX },
714 { "lodsB", ALr, Xb, XX },
715 { "lodsS", eAXr, Xv, XX },
716 { "scasB", AL, Yb, XX },
717 { "scasS", eAX, Yv, XX },
718 /* b0 */
719 { "movB", RMAL, Ib, XX },
720 { "movB", RMCL, Ib, XX },
721 { "movB", RMDL, Ib, XX },
722 { "movB", RMBL, Ib, XX },
723 { "movB", RMAH, Ib, XX },
724 { "movB", RMCH, Ib, XX },
725 { "movB", RMDH, Ib, XX },
726 { "movB", RMBH, Ib, XX },
727 /* b8 */
728 { "movS", RMeAX, Iv64, XX },
729 { "movS", RMeCX, Iv64, XX },
730 { "movS", RMeDX, Iv64, XX },
731 { "movS", RMeBX, Iv64, XX },
732 { "movS", RMeSP, Iv64, XX },
733 { "movS", RMeBP, Iv64, XX },
734 { "movS", RMeSI, Iv64, XX },
735 { "movS", RMeDI, Iv64, XX },
736 /* c0 */
737 { GRP2b },
738 { GRP2S },
739 { "retT", Iw, XX, XX },
740 { "retT", XX, XX, XX },
741 { "les{S|}", Gv, Mp, XX },
742 { "ldsS", Gv, Mp, XX },
743 { "movA", Eb, Ib, XX },
744 { "movQ", Ev, Iv, XX },
745 /* c8 */
746 { "enterT", Iw, Ib, XX },
747 { "leaveT", XX, XX, XX },
748 { "lretP", Iw, XX, XX },
749 { "lretP", XX, XX, XX },
750 { "int3", XX, XX, XX },
751 { "int", Ib, XX, XX },
752 { "into{|}", XX, XX, XX },
753 { "iretP", XX, XX, XX },
754 /* d0 */
755 { GRP2b_one },
756 { GRP2S_one },
757 { GRP2b_cl },
758 { GRP2S_cl },
759 { "aam{|}", sIb, XX, XX },
760 { "aad{|}", sIb, XX, XX },
761 { "(bad)", XX, XX, XX },
762 { "xlat", DSBX, XX, XX },
763 /* d8 */
764 { FLOAT },
765 { FLOAT },
766 { FLOAT },
767 { FLOAT },
768 { FLOAT },
769 { FLOAT },
770 { FLOAT },
771 { FLOAT },
772 /* e0 */
773 { "loopneFH", Jb, XX, loop_jcxz_flag },
774 { "loopeFH", Jb, XX, loop_jcxz_flag },
775 { "loopFH", Jb, XX, loop_jcxz_flag },
776 { "jEcxzH", Jb, XX, loop_jcxz_flag },
777 { "inB", AL, Ib, XX },
778 { "inS", eAX, Ib, XX },
779 { "outB", Ib, AL, XX },
780 { "outS", Ib, eAX, XX },
781 /* e8 */
782 { "callT", Jv, XX, XX },
783 { "jmpT", Jv, XX, XX },
784 { "Jjmp{T|}", Ap, XX, XX },
785 { "jmp", Jb, XX, XX },
786 { "inB", AL, indirDX, XX },
787 { "inS", eAX, indirDX, XX },
788 { "outB", indirDX, AL, XX },
789 { "outS", indirDX, eAX, XX },
790 /* f0 */
791 { "(bad)", XX, XX, XX }, /* lock prefix */
792 { "icebp", XX, XX, XX },
793 { "(bad)", XX, XX, XX }, /* repne */
794 { "(bad)", XX, XX, XX }, /* repz */
795 { "hlt", XX, XX, XX },
796 { "cmc", XX, XX, XX },
797 { GRP3b },
798 { GRP3S },
799 /* f8 */
800 { "clc", XX, XX, XX },
801 { "stc", XX, XX, XX },
802 { "cli", XX, XX, XX },
803 { "sti", XX, XX, XX },
804 { "cld", XX, XX, XX },
805 { "std", XX, XX, XX },
806 { GRP4 },
807 { GRP5 },
808 };
809
810 static const struct dis386 dis386_twobyte[] = {
811 /* 00 */
812 { GRP6 },
813 { GRP7 },
814 { "larS", Gv, Ew, XX },
815 { "lslS", Gv, Ew, XX },
816 { "(bad)", XX, XX, XX },
817 { "syscall", XX, XX, XX },
818 { "clts", XX, XX, XX },
819 { "sysretP", XX, XX, XX },
820 /* 08 */
821 { "invd", XX, XX, XX },
822 { "wbinvd", XX, XX, XX },
823 { "(bad)", XX, XX, XX },
824 { "ud2a", XX, XX, XX },
825 { "(bad)", XX, XX, XX },
826 { GRPAMD },
827 { "femms", XX, XX, XX },
828 { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */
829 /* 10 */
830 { PREGRP8 },
831 { PREGRP9 },
832 { PREGRP30 },
833 { "movlpX", EX, XM, SIMD_Fixup, 'h' },
834 { "unpcklpX", XM, EX, XX },
835 { "unpckhpX", XM, EX, XX },
836 { PREGRP31 },
837 { "movhpX", EX, XM, SIMD_Fixup, 'l' },
838 /* 18 */
839 { GRP16 },
840 { "(bad)", XX, XX, XX },
841 { "(bad)", XX, XX, XX },
842 { "(bad)", XX, XX, XX },
843 { "(bad)", XX, XX, XX },
844 { "(bad)", XX, XX, XX },
845 { "(bad)", XX, XX, XX },
846 { "nopQ", Ev, XX, XX },
847 /* 20 */
848 { "movZ", Rm, Cm, XX },
849 { "movZ", Rm, Dm, XX },
850 { "movZ", Cm, Rm, XX },
851 { "movZ", Dm, Rm, XX },
852 { "movL", Rd, Td, XX },
853 { "(bad)", XX, XX, XX },
854 { "movL", Td, Rd, XX },
855 { "(bad)", XX, XX, XX },
856 /* 28 */
857 { "movapX", XM, EX, XX },
858 { "movapX", EX, XM, XX },
859 { PREGRP2 },
860 { "movntpX", Ev, XM, XX },
861 { PREGRP4 },
862 { PREGRP3 },
863 { "ucomisX", XM,EX, XX },
864 { "comisX", XM,EX, XX },
865 /* 30 */
866 { "wrmsr", XX, XX, XX },
867 { "rdtsc", XX, XX, XX },
868 { "rdmsr", XX, XX, XX },
869 { "rdpmc", XX, XX, XX },
870 { "sysenter", XX, XX, XX },
871 { "sysexit", XX, XX, XX },
872 { "(bad)", XX, XX, XX },
873 { "(bad)", XX, XX, XX },
874 /* 38 */
875 { THREE_BYTE_0 },
876 { "(bad)", XX, XX, XX },
877 { THREE_BYTE_1 },
878 { "(bad)", XX, XX, XX },
879 { "(bad)", XX, XX, XX },
880 { "(bad)", XX, XX, XX },
881 { "(bad)", XX, XX, XX },
882 { "(bad)", XX, XX, XX },
883 /* 40 */
884 { "cmovo", Gv, Ev, XX },
885 { "cmovno", Gv, Ev, XX },
886 { "cmovb", Gv, Ev, XX },
887 { "cmovae", Gv, Ev, XX },
888 { "cmove", Gv, Ev, XX },
889 { "cmovne", Gv, Ev, XX },
890 { "cmovbe", Gv, Ev, XX },
891 { "cmova", Gv, Ev, XX },
892 /* 48 */
893 { "cmovs", Gv, Ev, XX },
894 { "cmovns", Gv, Ev, XX },
895 { "cmovp", Gv, Ev, XX },
896 { "cmovnp", Gv, Ev, XX },
897 { "cmovl", Gv, Ev, XX },
898 { "cmovge", Gv, Ev, XX },
899 { "cmovle", Gv, Ev, XX },
900 { "cmovg", Gv, Ev, XX },
901 /* 50 */
902 { "movmskpX", Gdq, XS, XX },
903 { PREGRP13 },
904 { PREGRP12 },
905 { PREGRP11 },
906 { "andpX", XM, EX, XX },
907 { "andnpX", XM, EX, XX },
908 { "orpX", XM, EX, XX },
909 { "xorpX", XM, EX, XX },
910 /* 58 */
911 { PREGRP0 },
912 { PREGRP10 },
913 { PREGRP17 },
914 { PREGRP16 },
915 { PREGRP14 },
916 { PREGRP7 },
917 { PREGRP5 },
918 { PREGRP6 },
919 /* 60 */
920 { "punpcklbw", MX, EM, XX },
921 { "punpcklwd", MX, EM, XX },
922 { "punpckldq", MX, EM, XX },
923 { "packsswb", MX, EM, XX },
924 { "pcmpgtb", MX, EM, XX },
925 { "pcmpgtw", MX, EM, XX },
926 { "pcmpgtd", MX, EM, XX },
927 { "packuswb", MX, EM, XX },
928 /* 68 */
929 { "punpckhbw", MX, EM, XX },
930 { "punpckhwd", MX, EM, XX },
931 { "punpckhdq", MX, EM, XX },
932 { "packssdw", MX, EM, XX },
933 { PREGRP26 },
934 { PREGRP24 },
935 { "movd", MX, Edq, XX },
936 { PREGRP19 },
937 /* 70 */
938 { PREGRP22 },
939 { GRP12 },
940 { GRP13 },
941 { GRP14 },
942 { "pcmpeqb", MX, EM, XX },
943 { "pcmpeqw", MX, EM, XX },
944 { "pcmpeqd", MX, EM, XX },
945 { "emms", XX, XX, XX },
946 /* 78 */
947 { "vmread", Em, Gm, XX },
948 { "vmwrite", Gm, Em, XX },
949 { "(bad)", XX, XX, XX },
950 { "(bad)", XX, XX, XX },
951 { PREGRP28 },
952 { PREGRP29 },
953 { PREGRP23 },
954 { PREGRP20 },
955 /* 80 */
956 { "joH", Jv, XX, cond_jump_flag },
957 { "jnoH", Jv, XX, cond_jump_flag },
958 { "jbH", Jv, XX, cond_jump_flag },
959 { "jaeH", Jv, XX, cond_jump_flag },
960 { "jeH", Jv, XX, cond_jump_flag },
961 { "jneH", Jv, XX, cond_jump_flag },
962 { "jbeH", Jv, XX, cond_jump_flag },
963 { "jaH", Jv, XX, cond_jump_flag },
964 /* 88 */
965 { "jsH", Jv, XX, cond_jump_flag },
966 { "jnsH", Jv, XX, cond_jump_flag },
967 { "jpH", Jv, XX, cond_jump_flag },
968 { "jnpH", Jv, XX, cond_jump_flag },
969 { "jlH", Jv, XX, cond_jump_flag },
970 { "jgeH", Jv, XX, cond_jump_flag },
971 { "jleH", Jv, XX, cond_jump_flag },
972 { "jgH", Jv, XX, cond_jump_flag },
973 /* 90 */
974 { "seto", Eb, XX, XX },
975 { "setno", Eb, XX, XX },
976 { "setb", Eb, XX, XX },
977 { "setae", Eb, XX, XX },
978 { "sete", Eb, XX, XX },
979 { "setne", Eb, XX, XX },
980 { "setbe", Eb, XX, XX },
981 { "seta", Eb, XX, XX },
982 /* 98 */
983 { "sets", Eb, XX, XX },
984 { "setns", Eb, XX, XX },
985 { "setp", Eb, XX, XX },
986 { "setnp", Eb, XX, XX },
987 { "setl", Eb, XX, XX },
988 { "setge", Eb, XX, XX },
989 { "setle", Eb, XX, XX },
990 { "setg", Eb, XX, XX },
991 /* a0 */
992 { "pushT", fs, XX, XX },
993 { "popT", fs, XX, XX },
994 { "cpuid", XX, XX, XX },
995 { "btS", Ev, Gv, XX },
996 { "shldS", Ev, Gv, Ib },
997 { "shldS", Ev, Gv, CL },
998 { GRPPADLCK2 },
999 { GRPPADLCK1 },
1000 /* a8 */
1001 { "pushT", gs, XX, XX },
1002 { "popT", gs, XX, XX },
1003 { "rsm", XX, XX, XX },
1004 { "btsS", Ev, Gv, XX },
1005 { "shrdS", Ev, Gv, Ib },
1006 { "shrdS", Ev, Gv, CL },
1007 { GRP15 },
1008 { "imulS", Gv, Ev, XX },
1009 /* b0 */
1010 { "cmpxchgB", Eb, Gb, XX },
1011 { "cmpxchgS", Ev, Gv, XX },
1012 { "lssS", Gv, Mp, XX },
1013 { "btrS", Ev, Gv, XX },
1014 { "lfsS", Gv, Mp, XX },
1015 { "lgsS", Gv, Mp, XX },
1016 { "movz{bR|x|bR|x}", Gv, Eb, XX },
1017 { "movz{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movzww ! */
1018 /* b8 */
1019 { "(bad)", XX, XX, XX },
1020 { "ud2b", XX, XX, XX },
1021 { GRP8 },
1022 { "btcS", Ev, Gv, XX },
1023 { "bsfS", Gv, Ev, XX },
1024 { "bsrS", Gv, Ev, XX },
1025 { "movs{bR|x|bR|x}", Gv, Eb, XX },
1026 { "movs{wR|x|wR|x}", Gv, Ew, XX }, /* yes, there really is movsww ! */
1027 /* c0 */
1028 { "xaddB", Eb, Gb, XX },
1029 { "xaddS", Ev, Gv, XX },
1030 { PREGRP1 },
1031 { "movntiS", Ev, Gv, XX },
1032 { "pinsrw", MX, Edqw, Ib },
1033 { "pextrw", Gdq, MS, Ib },
1034 { "shufpX", XM, EX, Ib },
1035 { GRP9 },
1036 /* c8 */
1037 { "bswap", RMeAX, XX, XX },
1038 { "bswap", RMeCX, XX, XX },
1039 { "bswap", RMeDX, XX, XX },
1040 { "bswap", RMeBX, XX, XX },
1041 { "bswap", RMeSP, XX, XX },
1042 { "bswap", RMeBP, XX, XX },
1043 { "bswap", RMeSI, XX, XX },
1044 { "bswap", RMeDI, XX, XX },
1045 /* d0 */
1046 { PREGRP27 },
1047 { "psrlw", MX, EM, XX },
1048 { "psrld", MX, EM, XX },
1049 { "psrlq", MX, EM, XX },
1050 { "paddq", MX, EM, XX },
1051 { "pmullw", MX, EM, XX },
1052 { PREGRP21 },
1053 { "pmovmskb", Gdq, MS, XX },
1054 /* d8 */
1055 { "psubusb", MX, EM, XX },
1056 { "psubusw", MX, EM, XX },
1057 { "pminub", MX, EM, XX },
1058 { "pand", MX, EM, XX },
1059 { "paddusb", MX, EM, XX },
1060 { "paddusw", MX, EM, XX },
1061 { "pmaxub", MX, EM, XX },
1062 { "pandn", MX, EM, XX },
1063 /* e0 */
1064 { "pavgb", MX, EM, XX },
1065 { "psraw", MX, EM, XX },
1066 { "psrad", MX, EM, XX },
1067 { "pavgw", MX, EM, XX },
1068 { "pmulhuw", MX, EM, XX },
1069 { "pmulhw", MX, EM, XX },
1070 { PREGRP15 },
1071 { PREGRP25 },
1072 /* e8 */
1073 { "psubsb", MX, EM, XX },
1074 { "psubsw", MX, EM, XX },
1075 { "pminsw", MX, EM, XX },
1076 { "por", MX, EM, XX },
1077 { "paddsb", MX, EM, XX },
1078 { "paddsw", MX, EM, XX },
1079 { "pmaxsw", MX, EM, XX },
1080 { "pxor", MX, EM, XX },
1081 /* f0 */
1082 { PREGRP32 },
1083 { "psllw", MX, EM, XX },
1084 { "pslld", MX, EM, XX },
1085 { "psllq", MX, EM, XX },
1086 { "pmuludq", MX, EM, XX },
1087 { "pmaddwd", MX, EM, XX },
1088 { "psadbw", MX, EM, XX },
1089 { PREGRP18 },
1090 /* f8 */
1091 { "psubb", MX, EM, XX },
1092 { "psubw", MX, EM, XX },
1093 { "psubd", MX, EM, XX },
1094 { "psubq", MX, EM, XX },
1095 { "paddb", MX, EM, XX },
1096 { "paddw", MX, EM, XX },
1097 { "paddd", MX, EM, XX },
1098 { "(bad)", XX, XX, XX }
1099 };
1100
1101 static const unsigned char onebyte_has_modrm[256] = {
1102 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1103 /* ------------------------------- */
1104 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1105 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1106 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1107 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1108 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1109 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1110 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1111 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1112 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1113 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1114 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1115 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1116 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1117 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1118 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1119 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1120 /* ------------------------------- */
1121 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1122 };
1123
1124 static const unsigned char twobyte_has_modrm[256] = {
1125 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1126 /* ------------------------------- */
1127 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1128 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, /* 1f */
1129 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1130 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1131 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1132 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1133 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1134 /* 70 */ 1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, /* 7f */
1135 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1136 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1137 /* a0 */ 0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, /* af */
1138 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
1139 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1140 /* d0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1141 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1142 /* f0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1143 /* ------------------------------- */
1144 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1145 };
1146
1147 static const unsigned char twobyte_uses_SSE_prefix[256] = {
1148 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1149 /* ------------------------------- */
1150 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1151 /* 10 */ 1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, /* 1f */
1152 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
1153 /* 30 */ 0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, /* 3f */
1154 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1155 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1156 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1157 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, /* 7f */
1158 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1159 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1160 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1161 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1162 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1163 /* d0 */ 1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1164 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1165 /* f0 */ 1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1166 /* ------------------------------- */
1167 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1168 };
1169
1170 static char obuf[100];
1171 static char *obufp;
1172 static char scratchbuf[100];
1173 static unsigned char *start_codep;
1174 static unsigned char *insn_codep;
1175 static unsigned char *codep;
1176 static disassemble_info *the_info;
1177 static int mod;
1178 static int rm;
1179 static int reg;
1180 static unsigned char need_modrm;
1181
1182 /* If we are accessing mod/rm/reg without need_modrm set, then the
1183 values are stale. Hitting this abort likely indicates that you
1184 need to update onebyte_has_modrm or twobyte_has_modrm. */
1185 #define MODRM_CHECK if (!need_modrm) abort ()
1186
1187 static const char **names64;
1188 static const char **names32;
1189 static const char **names16;
1190 static const char **names8;
1191 static const char **names8rex;
1192 static const char **names_seg;
1193 static const char **index16;
1194
1195 static const char *intel_names64[] = {
1196 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1197 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1198 };
1199 static const char *intel_names32[] = {
1200 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1201 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1202 };
1203 static const char *intel_names16[] = {
1204 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1205 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1206 };
1207 static const char *intel_names8[] = {
1208 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1209 };
1210 static const char *intel_names8rex[] = {
1211 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1212 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1213 };
1214 static const char *intel_names_seg[] = {
1215 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1216 };
1217 static const char *intel_index16[] = {
1218 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1219 };
1220
1221 static const char *att_names64[] = {
1222 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1223 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1224 };
1225 static const char *att_names32[] = {
1226 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1227 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1228 };
1229 static const char *att_names16[] = {
1230 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1231 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1232 };
1233 static const char *att_names8[] = {
1234 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1235 };
1236 static const char *att_names8rex[] = {
1237 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1238 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1239 };
1240 static const char *att_names_seg[] = {
1241 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1242 };
1243 static const char *att_index16[] = {
1244 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1245 };
1246
1247 static const struct dis386 grps[][8] = {
1248 /* GRP1b */
1249 {
1250 { "addA", Eb, Ib, XX },
1251 { "orA", Eb, Ib, XX },
1252 { "adcA", Eb, Ib, XX },
1253 { "sbbA", Eb, Ib, XX },
1254 { "andA", Eb, Ib, XX },
1255 { "subA", Eb, Ib, XX },
1256 { "xorA", Eb, Ib, XX },
1257 { "cmpA", Eb, Ib, XX }
1258 },
1259 /* GRP1S */
1260 {
1261 { "addQ", Ev, Iv, XX },
1262 { "orQ", Ev, Iv, XX },
1263 { "adcQ", Ev, Iv, XX },
1264 { "sbbQ", Ev, Iv, XX },
1265 { "andQ", Ev, Iv, XX },
1266 { "subQ", Ev, Iv, XX },
1267 { "xorQ", Ev, Iv, XX },
1268 { "cmpQ", Ev, Iv, XX }
1269 },
1270 /* GRP1Ss */
1271 {
1272 { "addQ", Ev, sIb, XX },
1273 { "orQ", Ev, sIb, XX },
1274 { "adcQ", Ev, sIb, XX },
1275 { "sbbQ", Ev, sIb, XX },
1276 { "andQ", Ev, sIb, XX },
1277 { "subQ", Ev, sIb, XX },
1278 { "xorQ", Ev, sIb, XX },
1279 { "cmpQ", Ev, sIb, XX }
1280 },
1281 /* GRP2b */
1282 {
1283 { "rolA", Eb, Ib, XX },
1284 { "rorA", Eb, Ib, XX },
1285 { "rclA", Eb, Ib, XX },
1286 { "rcrA", Eb, Ib, XX },
1287 { "shlA", Eb, Ib, XX },
1288 { "shrA", Eb, Ib, XX },
1289 { "(bad)", XX, XX, XX },
1290 { "sarA", Eb, Ib, XX },
1291 },
1292 /* GRP2S */
1293 {
1294 { "rolQ", Ev, Ib, XX },
1295 { "rorQ", Ev, Ib, XX },
1296 { "rclQ", Ev, Ib, XX },
1297 { "rcrQ", Ev, Ib, XX },
1298 { "shlQ", Ev, Ib, XX },
1299 { "shrQ", Ev, Ib, XX },
1300 { "(bad)", XX, XX, XX },
1301 { "sarQ", Ev, Ib, XX },
1302 },
1303 /* GRP2b_one */
1304 {
1305 { "rolA", Eb, I1, XX },
1306 { "rorA", Eb, I1, XX },
1307 { "rclA", Eb, I1, XX },
1308 { "rcrA", Eb, I1, XX },
1309 { "shlA", Eb, I1, XX },
1310 { "shrA", Eb, I1, XX },
1311 { "(bad)", XX, XX, XX },
1312 { "sarA", Eb, I1, XX },
1313 },
1314 /* GRP2S_one */
1315 {
1316 { "rolQ", Ev, I1, XX },
1317 { "rorQ", Ev, I1, XX },
1318 { "rclQ", Ev, I1, XX },
1319 { "rcrQ", Ev, I1, XX },
1320 { "shlQ", Ev, I1, XX },
1321 { "shrQ", Ev, I1, XX },
1322 { "(bad)", XX, XX, XX},
1323 { "sarQ", Ev, I1, XX },
1324 },
1325 /* GRP2b_cl */
1326 {
1327 { "rolA", Eb, CL, XX },
1328 { "rorA", Eb, CL, XX },
1329 { "rclA", Eb, CL, XX },
1330 { "rcrA", Eb, CL, XX },
1331 { "shlA", Eb, CL, XX },
1332 { "shrA", Eb, CL, XX },
1333 { "(bad)", XX, XX, XX },
1334 { "sarA", Eb, CL, XX },
1335 },
1336 /* GRP2S_cl */
1337 {
1338 { "rolQ", Ev, CL, XX },
1339 { "rorQ", Ev, CL, XX },
1340 { "rclQ", Ev, CL, XX },
1341 { "rcrQ", Ev, CL, XX },
1342 { "shlQ", Ev, CL, XX },
1343 { "shrQ", Ev, CL, XX },
1344 { "(bad)", XX, XX, XX },
1345 { "sarQ", Ev, CL, XX }
1346 },
1347 /* GRP3b */
1348 {
1349 { "testA", Eb, Ib, XX },
1350 { "(bad)", Eb, XX, XX },
1351 { "notA", Eb, XX, XX },
1352 { "negA", Eb, XX, XX },
1353 { "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */
1354 { "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */
1355 { "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */
1356 { "idivA", Eb, XX, XX } /* and idiv for consistency. */
1357 },
1358 /* GRP3S */
1359 {
1360 { "testQ", Ev, Iv, XX },
1361 { "(bad)", XX, XX, XX },
1362 { "notQ", Ev, XX, XX },
1363 { "negQ", Ev, XX, XX },
1364 { "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */
1365 { "imulQ", Ev, XX, XX },
1366 { "divQ", Ev, XX, XX },
1367 { "idivQ", Ev, XX, XX },
1368 },
1369 /* GRP4 */
1370 {
1371 { "incA", Eb, XX, XX },
1372 { "decA", Eb, XX, XX },
1373 { "(bad)", XX, XX, XX },
1374 { "(bad)", XX, XX, XX },
1375 { "(bad)", XX, XX, XX },
1376 { "(bad)", XX, XX, XX },
1377 { "(bad)", XX, XX, XX },
1378 { "(bad)", XX, XX, XX },
1379 },
1380 /* GRP5 */
1381 {
1382 { "incQ", Ev, XX, XX },
1383 { "decQ", Ev, XX, XX },
1384 { "callT", indirEv, XX, XX },
1385 { "JcallT", indirEp, XX, XX },
1386 { "jmpT", indirEv, XX, XX },
1387 { "JjmpT", indirEp, XX, XX },
1388 { "pushU", stackEv, XX, XX },
1389 { "(bad)", XX, XX, XX },
1390 },
1391 /* GRP6 */
1392 {
1393 { "sldtQ", Ev, XX, XX },
1394 { "strQ", Ev, XX, XX },
1395 { "lldt", Ew, XX, XX },
1396 { "ltr", Ew, XX, XX },
1397 { "verr", Ew, XX, XX },
1398 { "verw", Ew, XX, XX },
1399 { "(bad)", XX, XX, XX },
1400 { "(bad)", XX, XX, XX }
1401 },
1402 /* GRP7 */
1403 {
1404 { "sgdt{Q|IQ||}", VMX_Fixup, 0, XX, XX },
1405 { "sidt{Q|IQ||}", PNI_Fixup, 0, XX, XX },
1406 { "lgdt{Q|Q||}", M, XX, XX },
1407 { "lidt{Q|Q||}", SVME_Fixup, 0, XX, XX },
1408 { "smswQ", Ev, XX, XX },
1409 { "(bad)", XX, XX, XX },
1410 { "lmsw", Ew, XX, XX },
1411 { "invlpg", INVLPG_Fixup, w_mode, XX, XX },
1412 },
1413 /* GRP8 */
1414 {
1415 { "(bad)", XX, XX, XX },
1416 { "(bad)", XX, XX, XX },
1417 { "(bad)", XX, XX, XX },
1418 { "(bad)", XX, XX, XX },
1419 { "btQ", Ev, Ib, XX },
1420 { "btsQ", Ev, Ib, XX },
1421 { "btrQ", Ev, Ib, XX },
1422 { "btcQ", Ev, Ib, XX },
1423 },
1424 /* GRP9 */
1425 {
1426 { "(bad)", XX, XX, XX },
1427 { "cmpxchg8b", Eq, XX, XX },
1428 { "(bad)", XX, XX, XX },
1429 { "(bad)", XX, XX, XX },
1430 { "(bad)", XX, XX, XX },
1431 { "(bad)", XX, XX, XX },
1432 { "", VM, XX, XX }, /* See OP_VMX. */
1433 { "vmptrst", Eq, XX, XX },
1434 },
1435 /* GRP12 */
1436 {
1437 { "(bad)", XX, XX, XX },
1438 { "(bad)", XX, XX, XX },
1439 { "psrlw", MS, Ib, XX },
1440 { "(bad)", XX, XX, XX },
1441 { "psraw", MS, Ib, XX },
1442 { "(bad)", XX, XX, XX },
1443 { "psllw", MS, Ib, XX },
1444 { "(bad)", XX, XX, XX },
1445 },
1446 /* GRP13 */
1447 {
1448 { "(bad)", XX, XX, XX },
1449 { "(bad)", XX, XX, XX },
1450 { "psrld", MS, Ib, XX },
1451 { "(bad)", XX, XX, XX },
1452 { "psrad", MS, Ib, XX },
1453 { "(bad)", XX, XX, XX },
1454 { "pslld", MS, Ib, XX },
1455 { "(bad)", XX, XX, XX },
1456 },
1457 /* GRP14 */
1458 {
1459 { "(bad)", XX, XX, XX },
1460 { "(bad)", XX, XX, XX },
1461 { "psrlq", MS, Ib, XX },
1462 { "psrldq", MS, Ib, XX },
1463 { "(bad)", XX, XX, XX },
1464 { "(bad)", XX, XX, XX },
1465 { "psllq", MS, Ib, XX },
1466 { "pslldq", MS, Ib, XX },
1467 },
1468 /* GRP15 */
1469 {
1470 { "fxsave", Ev, XX, XX },
1471 { "fxrstor", Ev, XX, XX },
1472 { "ldmxcsr", Ev, XX, XX },
1473 { "stmxcsr", Ev, XX, XX },
1474 { "(bad)", XX, XX, XX },
1475 { "lfence", OP_0fae, 0, XX, XX },
1476 { "mfence", OP_0fae, 0, XX, XX },
1477 { "clflush", OP_0fae, 0, XX, XX },
1478 },
1479 /* GRP16 */
1480 {
1481 { "prefetchnta", Ev, XX, XX },
1482 { "prefetcht0", Ev, XX, XX },
1483 { "prefetcht1", Ev, XX, XX },
1484 { "prefetcht2", Ev, XX, XX },
1485 { "(bad)", XX, XX, XX },
1486 { "(bad)", XX, XX, XX },
1487 { "(bad)", XX, XX, XX },
1488 { "(bad)", XX, XX, XX },
1489 },
1490 /* GRPAMD */
1491 {
1492 { "prefetch", Eb, XX, XX },
1493 { "prefetchw", Eb, XX, XX },
1494 { "(bad)", XX, XX, XX },
1495 { "(bad)", XX, XX, XX },
1496 { "(bad)", XX, XX, XX },
1497 { "(bad)", XX, XX, XX },
1498 { "(bad)", XX, XX, XX },
1499 { "(bad)", XX, XX, XX },
1500 },
1501 /* GRPPADLCK1 */
1502 {
1503 { "xstore-rng", OP_0f07, 0, XX, XX },
1504 { "xcrypt-ecb", OP_0f07, 0, XX, XX },
1505 { "xcrypt-cbc", OP_0f07, 0, XX, XX },
1506 { "xcrypt-ctr", OP_0f07, 0, XX, XX },
1507 { "xcrypt-cfb", OP_0f07, 0, XX, XX },
1508 { "xcrypt-ofb", OP_0f07, 0, XX, XX },
1509 { "(bad)", OP_0f07, 0, XX, XX },
1510 { "(bad)", OP_0f07, 0, XX, XX },
1511 },
1512 /* GRPPADLCK2 */
1513 {
1514 { "montmul", OP_0f07, 0, XX, XX },
1515 { "xsha1", OP_0f07, 0, XX, XX },
1516 { "xsha256", OP_0f07, 0, XX, XX },
1517 { "(bad)", OP_0f07, 0, XX, XX },
1518 { "(bad)", OP_0f07, 0, XX, XX },
1519 { "(bad)", OP_0f07, 0, XX, XX },
1520 { "(bad)", OP_0f07, 0, XX, XX },
1521 { "(bad)", OP_0f07, 0, XX, XX },
1522 }
1523 };
1524
1525 static const struct dis386 prefix_user_table[][4] = {
1526 /* PREGRP0 */
1527 {
1528 { "addps", XM, EX, XX },
1529 { "addss", XM, EX, XX },
1530 { "addpd", XM, EX, XX },
1531 { "addsd", XM, EX, XX },
1532 },
1533 /* PREGRP1 */
1534 {
1535 { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */
1536 { "", XM, EX, OPSIMD },
1537 { "", XM, EX, OPSIMD },
1538 { "", XM, EX, OPSIMD },
1539 },
1540 /* PREGRP2 */
1541 {
1542 { "cvtpi2ps", XM, EM, XX },
1543 { "cvtsi2ssY", XM, Ev, XX },
1544 { "cvtpi2pd", XM, EM, XX },
1545 { "cvtsi2sdY", XM, Ev, XX },
1546 },
1547 /* PREGRP3 */
1548 {
1549 { "cvtps2pi", MX, EX, XX },
1550 { "cvtss2siY", Gv, EX, XX },
1551 { "cvtpd2pi", MX, EX, XX },
1552 { "cvtsd2siY", Gv, EX, XX },
1553 },
1554 /* PREGRP4 */
1555 {
1556 { "cvttps2pi", MX, EX, XX },
1557 { "cvttss2siY", Gv, EX, XX },
1558 { "cvttpd2pi", MX, EX, XX },
1559 { "cvttsd2siY", Gv, EX, XX },
1560 },
1561 /* PREGRP5 */
1562 {
1563 { "divps", XM, EX, XX },
1564 { "divss", XM, EX, XX },
1565 { "divpd", XM, EX, XX },
1566 { "divsd", XM, EX, XX },
1567 },
1568 /* PREGRP6 */
1569 {
1570 { "maxps", XM, EX, XX },
1571 { "maxss", XM, EX, XX },
1572 { "maxpd", XM, EX, XX },
1573 { "maxsd", XM, EX, XX },
1574 },
1575 /* PREGRP7 */
1576 {
1577 { "minps", XM, EX, XX },
1578 { "minss", XM, EX, XX },
1579 { "minpd", XM, EX, XX },
1580 { "minsd", XM, EX, XX },
1581 },
1582 /* PREGRP8 */
1583 {
1584 { "movups", XM, EX, XX },
1585 { "movss", XM, EX, XX },
1586 { "movupd", XM, EX, XX },
1587 { "movsd", XM, EX, XX },
1588 },
1589 /* PREGRP9 */
1590 {
1591 { "movups", EX, XM, XX },
1592 { "movss", EX, XM, XX },
1593 { "movupd", EX, XM, XX },
1594 { "movsd", EX, XM, XX },
1595 },
1596 /* PREGRP10 */
1597 {
1598 { "mulps", XM, EX, XX },
1599 { "mulss", XM, EX, XX },
1600 { "mulpd", XM, EX, XX },
1601 { "mulsd", XM, EX, XX },
1602 },
1603 /* PREGRP11 */
1604 {
1605 { "rcpps", XM, EX, XX },
1606 { "rcpss", XM, EX, XX },
1607 { "(bad)", XM, EX, XX },
1608 { "(bad)", XM, EX, XX },
1609 },
1610 /* PREGRP12 */
1611 {
1612 { "rsqrtps", XM, EX, XX },
1613 { "rsqrtss", XM, EX, XX },
1614 { "(bad)", XM, EX, XX },
1615 { "(bad)", XM, EX, XX },
1616 },
1617 /* PREGRP13 */
1618 {
1619 { "sqrtps", XM, EX, XX },
1620 { "sqrtss", XM, EX, XX },
1621 { "sqrtpd", XM, EX, XX },
1622 { "sqrtsd", XM, EX, XX },
1623 },
1624 /* PREGRP14 */
1625 {
1626 { "subps", XM, EX, XX },
1627 { "subss", XM, EX, XX },
1628 { "subpd", XM, EX, XX },
1629 { "subsd", XM, EX, XX },
1630 },
1631 /* PREGRP15 */
1632 {
1633 { "(bad)", XM, EX, XX },
1634 { "cvtdq2pd", XM, EX, XX },
1635 { "cvttpd2dq", XM, EX, XX },
1636 { "cvtpd2dq", XM, EX, XX },
1637 },
1638 /* PREGRP16 */
1639 {
1640 { "cvtdq2ps", XM, EX, XX },
1641 { "cvttps2dq",XM, EX, XX },
1642 { "cvtps2dq",XM, EX, XX },
1643 { "(bad)", XM, EX, XX },
1644 },
1645 /* PREGRP17 */
1646 {
1647 { "cvtps2pd", XM, EX, XX },
1648 { "cvtss2sd", XM, EX, XX },
1649 { "cvtpd2ps", XM, EX, XX },
1650 { "cvtsd2ss", XM, EX, XX },
1651 },
1652 /* PREGRP18 */
1653 {
1654 { "maskmovq", MX, MS, XX },
1655 { "(bad)", XM, EX, XX },
1656 { "maskmovdqu", XM, EX, XX },
1657 { "(bad)", XM, EX, XX },
1658 },
1659 /* PREGRP19 */
1660 {
1661 { "movq", MX, EM, XX },
1662 { "movdqu", XM, EX, XX },
1663 { "movdqa", XM, EX, XX },
1664 { "(bad)", XM, EX, XX },
1665 },
1666 /* PREGRP20 */
1667 {
1668 { "movq", EM, MX, XX },
1669 { "movdqu", EX, XM, XX },
1670 { "movdqa", EX, XM, XX },
1671 { "(bad)", EX, XM, XX },
1672 },
1673 /* PREGRP21 */
1674 {
1675 { "(bad)", EX, XM, XX },
1676 { "movq2dq", XM, MS, XX },
1677 { "movq", EX, XM, XX },
1678 { "movdq2q", MX, XS, XX },
1679 },
1680 /* PREGRP22 */
1681 {
1682 { "pshufw", MX, EM, Ib },
1683 { "pshufhw", XM, EX, Ib },
1684 { "pshufd", XM, EX, Ib },
1685 { "pshuflw", XM, EX, Ib },
1686 },
1687 /* PREGRP23 */
1688 {
1689 { "movd", Edq, MX, XX },
1690 { "movq", XM, EX, XX },
1691 { "movd", Edq, XM, XX },
1692 { "(bad)", Ed, XM, XX },
1693 },
1694 /* PREGRP24 */
1695 {
1696 { "(bad)", MX, EX, XX },
1697 { "(bad)", XM, EX, XX },
1698 { "punpckhqdq", XM, EX, XX },
1699 { "(bad)", XM, EX, XX },
1700 },
1701 /* PREGRP25 */
1702 {
1703 { "movntq", EM, MX, XX },
1704 { "(bad)", EM, XM, XX },
1705 { "movntdq", EM, XM, XX },
1706 { "(bad)", EM, XM, XX },
1707 },
1708 /* PREGRP26 */
1709 {
1710 { "(bad)", MX, EX, XX },
1711 { "(bad)", XM, EX, XX },
1712 { "punpcklqdq", XM, EX, XX },
1713 { "(bad)", XM, EX, XX },
1714 },
1715 /* PREGRP27 */
1716 {
1717 { "(bad)", MX, EX, XX },
1718 { "(bad)", XM, EX, XX },
1719 { "addsubpd", XM, EX, XX },
1720 { "addsubps", XM, EX, XX },
1721 },
1722 /* PREGRP28 */
1723 {
1724 { "(bad)", MX, EX, XX },
1725 { "(bad)", XM, EX, XX },
1726 { "haddpd", XM, EX, XX },
1727 { "haddps", XM, EX, XX },
1728 },
1729 /* PREGRP29 */
1730 {
1731 { "(bad)", MX, EX, XX },
1732 { "(bad)", XM, EX, XX },
1733 { "hsubpd", XM, EX, XX },
1734 { "hsubps", XM, EX, XX },
1735 },
1736 /* PREGRP30 */
1737 {
1738 { "movlpX", XM, EX, SIMD_Fixup, 'h' }, /* really only 2 operands */
1739 { "movsldup", XM, EX, XX },
1740 { "movlpd", XM, EX, XX },
1741 { "movddup", XM, EX, XX },
1742 },
1743 /* PREGRP31 */
1744 {
1745 { "movhpX", XM, EX, SIMD_Fixup, 'l' },
1746 { "movshdup", XM, EX, XX },
1747 { "movhpd", XM, EX, XX },
1748 { "(bad)", XM, EX, XX },
1749 },
1750 /* PREGRP32 */
1751 {
1752 { "(bad)", XM, EX, XX },
1753 { "(bad)", XM, EX, XX },
1754 { "(bad)", XM, EX, XX },
1755 { "lddqu", XM, M, XX },
1756 },
1757 };
1758
1759 static const struct dis386 x86_64_table[][2] = {
1760 {
1761 { "arpl", Ew, Gw, XX },
1762 { "movs{||lq|xd}", Gv, Ed, XX },
1763 },
1764 };
1765
1766 static const struct dis386 three_byte_table[][32] = {
1767 /* THREE_BYTE_0 */
1768 {
1769 { "pshufb", MX, EM, XX },
1770 { "phaddw", MX, EM, XX },
1771 { "phaddd", MX, EM, XX },
1772 { "phaddsw", MX, EM, XX },
1773 { "pmaddubsw", MX, EM, XX },
1774 { "phsubw", MX, EM, XX },
1775 { "phsubd", MX, EM, XX },
1776 { "phsubsw", MX, EM, XX },
1777 { "psignb", MX, EM, XX },
1778 { "psignw", MX, EM, XX },
1779 { "psignd", MX, EM, XX },
1780 { "pmulhrsw", MX, EM, XX },
1781 { "(bad)", XX, XX, XX },
1782 { "(bad)", XX, XX, XX },
1783 { "(bad)", XX, XX, XX },
1784 { "(bad)", XX, XX, XX },
1785 { "(bad)", XX, XX, XX },
1786 { "(bad)", XX, XX, XX },
1787 { "(bad)", XX, XX, XX },
1788 { "(bad)", XX, XX, XX },
1789 { "(bad)", XX, XX, XX },
1790 { "(bad)", XX, XX, XX },
1791 { "(bad)", XX, XX, XX },
1792 { "(bad)", XX, XX, XX },
1793 { "(bad)", XX, XX, XX },
1794 { "(bad)", XX, XX, XX },
1795 { "(bad)", XX, XX, XX },
1796 { "(bad)", XX, XX, XX },
1797 { "pabsb", MX, EM, XX },
1798 { "pabsw", MX, EM, XX },
1799 { "pabsd", MX, EM, XX },
1800 { "(bad)", XX, XX, XX }
1801 },
1802 /* THREE_BYTE_1 */
1803 {
1804 { "(bad)", XX, XX, XX },
1805 { "(bad)", XX, XX, XX },
1806 { "(bad)", XX, XX, XX },
1807 { "(bad)", XX, XX, XX },
1808 { "(bad)", XX, XX, XX },
1809 { "(bad)", XX, XX, XX },
1810 { "(bad)", XX, XX, XX },
1811 { "(bad)", XX, XX, XX },
1812 { "(bad)", XX, XX, XX },
1813 { "(bad)", XX, XX, XX },
1814 { "(bad)", XX, XX, XX },
1815 { "(bad)", XX, XX, XX },
1816 { "(bad)", XX, XX, XX },
1817 { "(bad)", XX, XX, XX },
1818 { "(bad)", XX, XX, XX },
1819 { "palignr", MX, EM, Ib },
1820 { "(bad)", XX, XX, XX },
1821 { "(bad)", XX, XX, XX },
1822 { "(bad)", XX, XX, XX },
1823 { "(bad)", XX, XX, XX },
1824 { "(bad)", XX, XX, XX },
1825 { "(bad)", XX, XX, XX },
1826 { "(bad)", XX, XX, XX },
1827 { "(bad)", XX, XX, XX },
1828 { "(bad)", XX, XX, XX },
1829 { "(bad)", XX, XX, XX },
1830 { "(bad)", XX, XX, XX },
1831 { "(bad)", XX, XX, XX },
1832 { "(bad)", XX, XX, XX },
1833 { "(bad)", XX, XX, XX },
1834 { "(bad)", XX, XX, XX },
1835 { "(bad)", XX, XX, XX }
1836 },
1837 };
1838
1839 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
1840
1841 static void
1842 ckprefix (void)
1843 {
1844 int newrex;
1845 rex = 0;
1846 prefixes = 0;
1847 used_prefixes = 0;
1848 rex_used = 0;
1849 while (1)
1850 {
1851 FETCH_DATA (the_info, codep + 1);
1852 newrex = 0;
1853 switch (*codep)
1854 {
1855 /* REX prefixes family. */
1856 case 0x40:
1857 case 0x41:
1858 case 0x42:
1859 case 0x43:
1860 case 0x44:
1861 case 0x45:
1862 case 0x46:
1863 case 0x47:
1864 case 0x48:
1865 case 0x49:
1866 case 0x4a:
1867 case 0x4b:
1868 case 0x4c:
1869 case 0x4d:
1870 case 0x4e:
1871 case 0x4f:
1872 if (address_mode == mode_64bit)
1873 newrex = *codep;
1874 else
1875 return;
1876 break;
1877 case 0xf3:
1878 prefixes |= PREFIX_REPZ;
1879 break;
1880 case 0xf2:
1881 prefixes |= PREFIX_REPNZ;
1882 break;
1883 case 0xf0:
1884 prefixes |= PREFIX_LOCK;
1885 break;
1886 case 0x2e:
1887 prefixes |= PREFIX_CS;
1888 break;
1889 case 0x36:
1890 prefixes |= PREFIX_SS;
1891 break;
1892 case 0x3e:
1893 prefixes |= PREFIX_DS;
1894 break;
1895 case 0x26:
1896 prefixes |= PREFIX_ES;
1897 break;
1898 case 0x64:
1899 prefixes |= PREFIX_FS;
1900 break;
1901 case 0x65:
1902 prefixes |= PREFIX_GS;
1903 break;
1904 case 0x66:
1905 prefixes |= PREFIX_DATA;
1906 break;
1907 case 0x67:
1908 prefixes |= PREFIX_ADDR;
1909 break;
1910 case FWAIT_OPCODE:
1911 /* fwait is really an instruction. If there are prefixes
1912 before the fwait, they belong to the fwait, *not* to the
1913 following instruction. */
1914 if (prefixes || rex)
1915 {
1916 prefixes |= PREFIX_FWAIT;
1917 codep++;
1918 return;
1919 }
1920 prefixes = PREFIX_FWAIT;
1921 break;
1922 default:
1923 return;
1924 }
1925 /* Rex is ignored when followed by another prefix. */
1926 if (rex)
1927 {
1928 rex_used = rex;
1929 return;
1930 }
1931 rex = newrex;
1932 codep++;
1933 }
1934 }
1935
1936 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
1937 prefix byte. */
1938
1939 static const char *
1940 prefix_name (int pref, int sizeflag)
1941 {
1942 switch (pref)
1943 {
1944 /* REX prefixes family. */
1945 case 0x40:
1946 return "rex";
1947 case 0x41:
1948 return "rexZ";
1949 case 0x42:
1950 return "rexY";
1951 case 0x43:
1952 return "rexYZ";
1953 case 0x44:
1954 return "rexX";
1955 case 0x45:
1956 return "rexXZ";
1957 case 0x46:
1958 return "rexXY";
1959 case 0x47:
1960 return "rexXYZ";
1961 case 0x48:
1962 return "rex64";
1963 case 0x49:
1964 return "rex64Z";
1965 case 0x4a:
1966 return "rex64Y";
1967 case 0x4b:
1968 return "rex64YZ";
1969 case 0x4c:
1970 return "rex64X";
1971 case 0x4d:
1972 return "rex64XZ";
1973 case 0x4e:
1974 return "rex64XY";
1975 case 0x4f:
1976 return "rex64XYZ";
1977 case 0xf3:
1978 return "repz";
1979 case 0xf2:
1980 return "repnz";
1981 case 0xf0:
1982 return "lock";
1983 case 0x2e:
1984 return "cs";
1985 case 0x36:
1986 return "ss";
1987 case 0x3e:
1988 return "ds";
1989 case 0x26:
1990 return "es";
1991 case 0x64:
1992 return "fs";
1993 case 0x65:
1994 return "gs";
1995 case 0x66:
1996 return (sizeflag & DFLAG) ? "data16" : "data32";
1997 case 0x67:
1998 if (address_mode == mode_64bit)
1999 return (sizeflag & AFLAG) ? "addr32" : "addr64";
2000 else
2001 return (sizeflag & AFLAG) ? "addr16" : "addr32";
2002 case FWAIT_OPCODE:
2003 return "fwait";
2004 default:
2005 return NULL;
2006 }
2007 }
2008
2009 static char op1out[100], op2out[100], op3out[100];
2010 static int op_ad, op_index[3];
2011 static int two_source_ops;
2012 static bfd_vma op_address[3];
2013 static bfd_vma op_riprel[3];
2014 static bfd_vma start_pc;
2015 \f
2016 /*
2017 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
2018 * (see topic "Redundant prefixes" in the "Differences from 8086"
2019 * section of the "Virtual 8086 Mode" chapter.)
2020 * 'pc' should be the address of this instruction, it will
2021 * be used to print the target address if this is a relative jump or call
2022 * The function returns the length of this instruction in bytes.
2023 */
2024
2025 static char intel_syntax;
2026 static char open_char;
2027 static char close_char;
2028 static char separator_char;
2029 static char scale_char;
2030
2031 /* Here for backwards compatibility. When gdb stops using
2032 print_insn_i386_att and print_insn_i386_intel these functions can
2033 disappear, and print_insn_i386 be merged into print_insn. */
2034 int
2035 print_insn_i386_att (bfd_vma pc, disassemble_info *info)
2036 {
2037 intel_syntax = 0;
2038
2039 return print_insn (pc, info);
2040 }
2041
2042 int
2043 print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
2044 {
2045 intel_syntax = 1;
2046
2047 return print_insn (pc, info);
2048 }
2049
2050 int
2051 print_insn_i386 (bfd_vma pc, disassemble_info *info)
2052 {
2053 intel_syntax = -1;
2054
2055 return print_insn (pc, info);
2056 }
2057
2058 static int
2059 print_insn (bfd_vma pc, disassemble_info *info)
2060 {
2061 const struct dis386 *dp;
2062 int i;
2063 char *first, *second, *third;
2064 int needcomma;
2065 unsigned char uses_SSE_prefix, uses_LOCK_prefix;
2066 int sizeflag;
2067 const char *p;
2068 struct dis_private priv;
2069
2070 if (info->mach == bfd_mach_x86_64_intel_syntax
2071 || info->mach == bfd_mach_x86_64)
2072 address_mode = mode_64bit;
2073 else
2074 address_mode = mode_32bit;
2075
2076 if (intel_syntax == (char) -1)
2077 intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
2078 || info->mach == bfd_mach_x86_64_intel_syntax);
2079
2080 if (info->mach == bfd_mach_i386_i386
2081 || info->mach == bfd_mach_x86_64
2082 || info->mach == bfd_mach_i386_i386_intel_syntax
2083 || info->mach == bfd_mach_x86_64_intel_syntax)
2084 priv.orig_sizeflag = AFLAG | DFLAG;
2085 else if (info->mach == bfd_mach_i386_i8086)
2086 priv.orig_sizeflag = 0;
2087 else
2088 abort ();
2089
2090 for (p = info->disassembler_options; p != NULL; )
2091 {
2092 if (strncmp (p, "x86-64", 6) == 0)
2093 {
2094 address_mode = mode_64bit;
2095 priv.orig_sizeflag = AFLAG | DFLAG;
2096 }
2097 else if (strncmp (p, "i386", 4) == 0)
2098 {
2099 address_mode = mode_32bit;
2100 priv.orig_sizeflag = AFLAG | DFLAG;
2101 }
2102 else if (strncmp (p, "i8086", 5) == 0)
2103 {
2104 address_mode = mode_16bit;
2105 priv.orig_sizeflag = 0;
2106 }
2107 else if (strncmp (p, "intel", 5) == 0)
2108 {
2109 intel_syntax = 1;
2110 }
2111 else if (strncmp (p, "att", 3) == 0)
2112 {
2113 intel_syntax = 0;
2114 }
2115 else if (strncmp (p, "addr", 4) == 0)
2116 {
2117 if (p[4] == '1' && p[5] == '6')
2118 priv.orig_sizeflag &= ~AFLAG;
2119 else if (p[4] == '3' && p[5] == '2')
2120 priv.orig_sizeflag |= AFLAG;
2121 }
2122 else if (strncmp (p, "data", 4) == 0)
2123 {
2124 if (p[4] == '1' && p[5] == '6')
2125 priv.orig_sizeflag &= ~DFLAG;
2126 else if (p[4] == '3' && p[5] == '2')
2127 priv.orig_sizeflag |= DFLAG;
2128 }
2129 else if (strncmp (p, "suffix", 6) == 0)
2130 priv.orig_sizeflag |= SUFFIX_ALWAYS;
2131
2132 p = strchr (p, ',');
2133 if (p != NULL)
2134 p++;
2135 }
2136
2137 if (intel_syntax)
2138 {
2139 names64 = intel_names64;
2140 names32 = intel_names32;
2141 names16 = intel_names16;
2142 names8 = intel_names8;
2143 names8rex = intel_names8rex;
2144 names_seg = intel_names_seg;
2145 index16 = intel_index16;
2146 open_char = '[';
2147 close_char = ']';
2148 separator_char = '+';
2149 scale_char = '*';
2150 }
2151 else
2152 {
2153 names64 = att_names64;
2154 names32 = att_names32;
2155 names16 = att_names16;
2156 names8 = att_names8;
2157 names8rex = att_names8rex;
2158 names_seg = att_names_seg;
2159 index16 = att_index16;
2160 open_char = '(';
2161 close_char = ')';
2162 separator_char = ',';
2163 scale_char = ',';
2164 }
2165
2166 /* The output looks better if we put 7 bytes on a line, since that
2167 puts most long word instructions on a single line. */
2168 info->bytes_per_line = 7;
2169
2170 info->private_data = &priv;
2171 priv.max_fetched = priv.the_buffer;
2172 priv.insn_start = pc;
2173
2174 obuf[0] = 0;
2175 op1out[0] = 0;
2176 op2out[0] = 0;
2177 op3out[0] = 0;
2178
2179 op_index[0] = op_index[1] = op_index[2] = -1;
2180
2181 the_info = info;
2182 start_pc = pc;
2183 start_codep = priv.the_buffer;
2184 codep = priv.the_buffer;
2185
2186 if (setjmp (priv.bailout) != 0)
2187 {
2188 const char *name;
2189
2190 /* Getting here means we tried for data but didn't get it. That
2191 means we have an incomplete instruction of some sort. Just
2192 print the first byte as a prefix or a .byte pseudo-op. */
2193 if (codep > priv.the_buffer)
2194 {
2195 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2196 if (name != NULL)
2197 (*info->fprintf_func) (info->stream, "%s", name);
2198 else
2199 {
2200 /* Just print the first byte as a .byte instruction. */
2201 (*info->fprintf_func) (info->stream, ".byte 0x%x",
2202 (unsigned int) priv.the_buffer[0]);
2203 }
2204
2205 return 1;
2206 }
2207
2208 return -1;
2209 }
2210
2211 obufp = obuf;
2212 ckprefix ();
2213
2214 insn_codep = codep;
2215 sizeflag = priv.orig_sizeflag;
2216
2217 FETCH_DATA (info, codep + 1);
2218 two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
2219
2220 if (((prefixes & PREFIX_FWAIT)
2221 && ((*codep < 0xd8) || (*codep > 0xdf)))
2222 || (rex && rex_used))
2223 {
2224 const char *name;
2225
2226 /* fwait not followed by floating point instruction, or rex followed
2227 by other prefixes. Print the first prefix. */
2228 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2229 if (name == NULL)
2230 name = INTERNAL_DISASSEMBLER_ERROR;
2231 (*info->fprintf_func) (info->stream, "%s", name);
2232 return 1;
2233 }
2234
2235 if (*codep == 0x0f)
2236 {
2237 FETCH_DATA (info, codep + 2);
2238 dp = &dis386_twobyte[*++codep];
2239 need_modrm = twobyte_has_modrm[*codep];
2240 uses_SSE_prefix = twobyte_uses_SSE_prefix[*codep];
2241 uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
2242 }
2243 else
2244 {
2245 dp = &dis386[*codep];
2246 need_modrm = onebyte_has_modrm[*codep];
2247 uses_SSE_prefix = 0;
2248 uses_LOCK_prefix = 0;
2249 }
2250 codep++;
2251
2252 if (!uses_SSE_prefix && (prefixes & PREFIX_REPZ))
2253 {
2254 oappend ("repz ");
2255 used_prefixes |= PREFIX_REPZ;
2256 }
2257 if (!uses_SSE_prefix && (prefixes & PREFIX_REPNZ))
2258 {
2259 oappend ("repnz ");
2260 used_prefixes |= PREFIX_REPNZ;
2261 }
2262 if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
2263 {
2264 oappend ("lock ");
2265 used_prefixes |= PREFIX_LOCK;
2266 }
2267
2268 if (prefixes & PREFIX_ADDR)
2269 {
2270 sizeflag ^= AFLAG;
2271 if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
2272 {
2273 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
2274 oappend ("addr32 ");
2275 else
2276 oappend ("addr16 ");
2277 used_prefixes |= PREFIX_ADDR;
2278 }
2279 }
2280
2281 if (!uses_SSE_prefix && (prefixes & PREFIX_DATA))
2282 {
2283 sizeflag ^= DFLAG;
2284 if (dp->bytemode3 == cond_jump_mode
2285 && dp->bytemode1 == v_mode
2286 && !intel_syntax)
2287 {
2288 if (sizeflag & DFLAG)
2289 oappend ("data32 ");
2290 else
2291 oappend ("data16 ");
2292 used_prefixes |= PREFIX_DATA;
2293 }
2294 }
2295
2296 if (dp->name == NULL && dp->bytemode1 == IS_3BYTE_OPCODE)
2297 {
2298 FETCH_DATA (info, codep + 2);
2299 dp = &three_byte_table[dp->bytemode2][*codep++];
2300 mod = (*codep >> 6) & 3;
2301 reg = (*codep >> 3) & 7;
2302 rm = *codep & 7;
2303 }
2304 else if (need_modrm)
2305 {
2306 FETCH_DATA (info, codep + 1);
2307 mod = (*codep >> 6) & 3;
2308 reg = (*codep >> 3) & 7;
2309 rm = *codep & 7;
2310 }
2311
2312 if (dp->name == NULL && dp->bytemode1 == FLOATCODE)
2313 {
2314 dofloat (sizeflag);
2315 }
2316 else
2317 {
2318 int index;
2319 if (dp->name == NULL)
2320 {
2321 switch (dp->bytemode1)
2322 {
2323 case USE_GROUPS:
2324 dp = &grps[dp->bytemode2][reg];
2325 break;
2326
2327 case USE_PREFIX_USER_TABLE:
2328 index = 0;
2329 used_prefixes |= (prefixes & PREFIX_REPZ);
2330 if (prefixes & PREFIX_REPZ)
2331 index = 1;
2332 else
2333 {
2334 used_prefixes |= (prefixes & PREFIX_DATA);
2335 if (prefixes & PREFIX_DATA)
2336 index = 2;
2337 else
2338 {
2339 used_prefixes |= (prefixes & PREFIX_REPNZ);
2340 if (prefixes & PREFIX_REPNZ)
2341 index = 3;
2342 }
2343 }
2344 dp = &prefix_user_table[dp->bytemode2][index];
2345 break;
2346
2347 case X86_64_SPECIAL:
2348 index = address_mode == mode_64bit ? 1 : 0;
2349 dp = &x86_64_table[dp->bytemode2][index];
2350 break;
2351
2352 default:
2353 oappend (INTERNAL_DISASSEMBLER_ERROR);
2354 break;
2355 }
2356 }
2357
2358 if (putop (dp->name, sizeflag) == 0)
2359 {
2360 obufp = op1out;
2361 op_ad = 2;
2362 if (dp->op1)
2363 (*dp->op1) (dp->bytemode1, sizeflag);
2364
2365 obufp = op2out;
2366 op_ad = 1;
2367 if (dp->op2)
2368 (*dp->op2) (dp->bytemode2, sizeflag);
2369
2370 obufp = op3out;
2371 op_ad = 0;
2372 if (dp->op3)
2373 (*dp->op3) (dp->bytemode3, sizeflag);
2374 }
2375 }
2376
2377 /* See if any prefixes were not used. If so, print the first one
2378 separately. If we don't do this, we'll wind up printing an
2379 instruction stream which does not precisely correspond to the
2380 bytes we are disassembling. */
2381 if ((prefixes & ~used_prefixes) != 0)
2382 {
2383 const char *name;
2384
2385 name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
2386 if (name == NULL)
2387 name = INTERNAL_DISASSEMBLER_ERROR;
2388 (*info->fprintf_func) (info->stream, "%s", name);
2389 return 1;
2390 }
2391 if (rex & ~rex_used)
2392 {
2393 const char *name;
2394 name = prefix_name (rex | 0x40, priv.orig_sizeflag);
2395 if (name == NULL)
2396 name = INTERNAL_DISASSEMBLER_ERROR;
2397 (*info->fprintf_func) (info->stream, "%s ", name);
2398 }
2399
2400 obufp = obuf + strlen (obuf);
2401 for (i = strlen (obuf); i < 6; i++)
2402 oappend (" ");
2403 oappend (" ");
2404 (*info->fprintf_func) (info->stream, "%s", obuf);
2405
2406 /* The enter and bound instructions are printed with operands in the same
2407 order as the intel book; everything else is printed in reverse order. */
2408 if (intel_syntax || two_source_ops)
2409 {
2410 first = op1out;
2411 second = op2out;
2412 third = op3out;
2413 op_ad = op_index[0];
2414 op_index[0] = op_index[2];
2415 op_index[2] = op_ad;
2416 }
2417 else
2418 {
2419 first = op3out;
2420 second = op2out;
2421 third = op1out;
2422 }
2423 needcomma = 0;
2424 if (*first)
2425 {
2426 if (op_index[0] != -1 && !op_riprel[0])
2427 (*info->print_address_func) ((bfd_vma) op_address[op_index[0]], info);
2428 else
2429 (*info->fprintf_func) (info->stream, "%s", first);
2430 needcomma = 1;
2431 }
2432 if (*second)
2433 {
2434 if (needcomma)
2435 (*info->fprintf_func) (info->stream, ",");
2436 if (op_index[1] != -1 && !op_riprel[1])
2437 (*info->print_address_func) ((bfd_vma) op_address[op_index[1]], info);
2438 else
2439 (*info->fprintf_func) (info->stream, "%s", second);
2440 needcomma = 1;
2441 }
2442 if (*third)
2443 {
2444 if (needcomma)
2445 (*info->fprintf_func) (info->stream, ",");
2446 if (op_index[2] != -1 && !op_riprel[2])
2447 (*info->print_address_func) ((bfd_vma) op_address[op_index[2]], info);
2448 else
2449 (*info->fprintf_func) (info->stream, "%s", third);
2450 }
2451 for (i = 0; i < 3; i++)
2452 if (op_index[i] != -1 && op_riprel[i])
2453 {
2454 (*info->fprintf_func) (info->stream, " # ");
2455 (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
2456 + op_address[op_index[i]]), info);
2457 }
2458 return codep - priv.the_buffer;
2459 }
2460
2461 static const char *float_mem[] = {
2462 /* d8 */
2463 "fadd{s||s|}",
2464 "fmul{s||s|}",
2465 "fcom{s||s|}",
2466 "fcomp{s||s|}",
2467 "fsub{s||s|}",
2468 "fsubr{s||s|}",
2469 "fdiv{s||s|}",
2470 "fdivr{s||s|}",
2471 /* d9 */
2472 "fld{s||s|}",
2473 "(bad)",
2474 "fst{s||s|}",
2475 "fstp{s||s|}",
2476 "fldenvIC",
2477 "fldcw",
2478 "fNstenvIC",
2479 "fNstcw",
2480 /* da */
2481 "fiadd{l||l|}",
2482 "fimul{l||l|}",
2483 "ficom{l||l|}",
2484 "ficomp{l||l|}",
2485 "fisub{l||l|}",
2486 "fisubr{l||l|}",
2487 "fidiv{l||l|}",
2488 "fidivr{l||l|}",
2489 /* db */
2490 "fild{l||l|}",
2491 "fisttp{l||l|}",
2492 "fist{l||l|}",
2493 "fistp{l||l|}",
2494 "(bad)",
2495 "fld{t||t|}",
2496 "(bad)",
2497 "fstp{t||t|}",
2498 /* dc */
2499 "fadd{l||l|}",
2500 "fmul{l||l|}",
2501 "fcom{l||l|}",
2502 "fcomp{l||l|}",
2503 "fsub{l||l|}",
2504 "fsubr{l||l|}",
2505 "fdiv{l||l|}",
2506 "fdivr{l||l|}",
2507 /* dd */
2508 "fld{l||l|}",
2509 "fisttp{ll||ll|}",
2510 "fst{l||l|}",
2511 "fstp{l||l|}",
2512 "frstorIC",
2513 "(bad)",
2514 "fNsaveIC",
2515 "fNstsw",
2516 /* de */
2517 "fiadd",
2518 "fimul",
2519 "ficom",
2520 "ficomp",
2521 "fisub",
2522 "fisubr",
2523 "fidiv",
2524 "fidivr",
2525 /* df */
2526 "fild",
2527 "fisttp",
2528 "fist",
2529 "fistp",
2530 "fbld",
2531 "fild{ll||ll|}",
2532 "fbstp",
2533 "fistp{ll||ll|}",
2534 };
2535
2536 static const unsigned char float_mem_mode[] = {
2537 /* d8 */
2538 d_mode,
2539 d_mode,
2540 d_mode,
2541 d_mode,
2542 d_mode,
2543 d_mode,
2544 d_mode,
2545 d_mode,
2546 /* d9 */
2547 d_mode,
2548 0,
2549 d_mode,
2550 d_mode,
2551 0,
2552 w_mode,
2553 0,
2554 w_mode,
2555 /* da */
2556 d_mode,
2557 d_mode,
2558 d_mode,
2559 d_mode,
2560 d_mode,
2561 d_mode,
2562 d_mode,
2563 d_mode,
2564 /* db */
2565 d_mode,
2566 d_mode,
2567 d_mode,
2568 d_mode,
2569 0,
2570 t_mode,
2571 0,
2572 t_mode,
2573 /* dc */
2574 q_mode,
2575 q_mode,
2576 q_mode,
2577 q_mode,
2578 q_mode,
2579 q_mode,
2580 q_mode,
2581 q_mode,
2582 /* dd */
2583 q_mode,
2584 q_mode,
2585 q_mode,
2586 q_mode,
2587 0,
2588 0,
2589 0,
2590 w_mode,
2591 /* de */
2592 w_mode,
2593 w_mode,
2594 w_mode,
2595 w_mode,
2596 w_mode,
2597 w_mode,
2598 w_mode,
2599 w_mode,
2600 /* df */
2601 w_mode,
2602 w_mode,
2603 w_mode,
2604 w_mode,
2605 t_mode,
2606 q_mode,
2607 t_mode,
2608 q_mode
2609 };
2610
2611 #define ST OP_ST, 0
2612 #define STi OP_STi, 0
2613
2614 #define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0
2615 #define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0
2616 #define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0
2617 #define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0
2618 #define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0
2619 #define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0
2620 #define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0
2621 #define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0
2622 #define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0
2623
2624 static const struct dis386 float_reg[][8] = {
2625 /* d8 */
2626 {
2627 { "fadd", ST, STi, XX },
2628 { "fmul", ST, STi, XX },
2629 { "fcom", STi, XX, XX },
2630 { "fcomp", STi, XX, XX },
2631 { "fsub", ST, STi, XX },
2632 { "fsubr", ST, STi, XX },
2633 { "fdiv", ST, STi, XX },
2634 { "fdivr", ST, STi, XX },
2635 },
2636 /* d9 */
2637 {
2638 { "fld", STi, XX, XX },
2639 { "fxch", STi, XX, XX },
2640 { FGRPd9_2 },
2641 { "(bad)", XX, XX, XX },
2642 { FGRPd9_4 },
2643 { FGRPd9_5 },
2644 { FGRPd9_6 },
2645 { FGRPd9_7 },
2646 },
2647 /* da */
2648 {
2649 { "fcmovb", ST, STi, XX },
2650 { "fcmove", ST, STi, XX },
2651 { "fcmovbe",ST, STi, XX },
2652 { "fcmovu", ST, STi, XX },
2653 { "(bad)", XX, XX, XX },
2654 { FGRPda_5 },
2655 { "(bad)", XX, XX, XX },
2656 { "(bad)", XX, XX, XX },
2657 },
2658 /* db */
2659 {
2660 { "fcmovnb",ST, STi, XX },
2661 { "fcmovne",ST, STi, XX },
2662 { "fcmovnbe",ST, STi, XX },
2663 { "fcmovnu",ST, STi, XX },
2664 { FGRPdb_4 },
2665 { "fucomi", ST, STi, XX },
2666 { "fcomi", ST, STi, XX },
2667 { "(bad)", XX, XX, XX },
2668 },
2669 /* dc */
2670 {
2671 { "fadd", STi, ST, XX },
2672 { "fmul", STi, ST, XX },
2673 { "(bad)", XX, XX, XX },
2674 { "(bad)", XX, XX, XX },
2675 #if UNIXWARE_COMPAT
2676 { "fsub", STi, ST, XX },
2677 { "fsubr", STi, ST, XX },
2678 { "fdiv", STi, ST, XX },
2679 { "fdivr", STi, ST, XX },
2680 #else
2681 { "fsubr", STi, ST, XX },
2682 { "fsub", STi, ST, XX },
2683 { "fdivr", STi, ST, XX },
2684 { "fdiv", STi, ST, XX },
2685 #endif
2686 },
2687 /* dd */
2688 {
2689 { "ffree", STi, XX, XX },
2690 { "(bad)", XX, XX, XX },
2691 { "fst", STi, XX, XX },
2692 { "fstp", STi, XX, XX },
2693 { "fucom", STi, XX, XX },
2694 { "fucomp", STi, XX, XX },
2695 { "(bad)", XX, XX, XX },
2696 { "(bad)", XX, XX, XX },
2697 },
2698 /* de */
2699 {
2700 { "faddp", STi, ST, XX },
2701 { "fmulp", STi, ST, XX },
2702 { "(bad)", XX, XX, XX },
2703 { FGRPde_3 },
2704 #if UNIXWARE_COMPAT
2705 { "fsubp", STi, ST, XX },
2706 { "fsubrp", STi, ST, XX },
2707 { "fdivp", STi, ST, XX },
2708 { "fdivrp", STi, ST, XX },
2709 #else
2710 { "fsubrp", STi, ST, XX },
2711 { "fsubp", STi, ST, XX },
2712 { "fdivrp", STi, ST, XX },
2713 { "fdivp", STi, ST, XX },
2714 #endif
2715 },
2716 /* df */
2717 {
2718 { "ffreep", STi, XX, XX },
2719 { "(bad)", XX, XX, XX },
2720 { "(bad)", XX, XX, XX },
2721 { "(bad)", XX, XX, XX },
2722 { FGRPdf_4 },
2723 { "fucomip",ST, STi, XX },
2724 { "fcomip", ST, STi, XX },
2725 { "(bad)", XX, XX, XX },
2726 },
2727 };
2728
2729 static char *fgrps[][8] = {
2730 /* d9_2 0 */
2731 {
2732 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2733 },
2734
2735 /* d9_4 1 */
2736 {
2737 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
2738 },
2739
2740 /* d9_5 2 */
2741 {
2742 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
2743 },
2744
2745 /* d9_6 3 */
2746 {
2747 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
2748 },
2749
2750 /* d9_7 4 */
2751 {
2752 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
2753 },
2754
2755 /* da_5 5 */
2756 {
2757 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2758 },
2759
2760 /* db_4 6 */
2761 {
2762 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
2763 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
2764 },
2765
2766 /* de_3 7 */
2767 {
2768 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2769 },
2770
2771 /* df_4 8 */
2772 {
2773 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2774 },
2775 };
2776
2777 static void
2778 dofloat (int sizeflag)
2779 {
2780 const struct dis386 *dp;
2781 unsigned char floatop;
2782
2783 floatop = codep[-1];
2784
2785 if (mod != 3)
2786 {
2787 int fp_indx = (floatop - 0xd8) * 8 + reg;
2788
2789 putop (float_mem[fp_indx], sizeflag);
2790 obufp = op1out;
2791 op_ad = 2;
2792 OP_E (float_mem_mode[fp_indx], sizeflag);
2793 return;
2794 }
2795 /* Skip mod/rm byte. */
2796 MODRM_CHECK;
2797 codep++;
2798
2799 dp = &float_reg[floatop - 0xd8][reg];
2800 if (dp->name == NULL)
2801 {
2802 putop (fgrps[dp->bytemode1][rm], sizeflag);
2803
2804 /* Instruction fnstsw is only one with strange arg. */
2805 if (floatop == 0xdf && codep[-1] == 0xe0)
2806 strcpy (op1out, names16[0]);
2807 }
2808 else
2809 {
2810 putop (dp->name, sizeflag);
2811
2812 obufp = op1out;
2813 op_ad = 2;
2814 if (dp->op1)
2815 (*dp->op1) (dp->bytemode1, sizeflag);
2816
2817 obufp = op2out;
2818 op_ad = 1;
2819 if (dp->op2)
2820 (*dp->op2) (dp->bytemode2, sizeflag);
2821 }
2822 }
2823
2824 static void
2825 OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2826 {
2827 oappend ("%st" + intel_syntax);
2828 }
2829
2830 static void
2831 OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
2832 {
2833 sprintf (scratchbuf, "%%st(%d)", rm);
2834 oappend (scratchbuf + intel_syntax);
2835 }
2836
2837 /* Capital letters in template are macros. */
2838 static int
2839 putop (const char *template, int sizeflag)
2840 {
2841 const char *p;
2842 int alt = 0;
2843
2844 for (p = template; *p; p++)
2845 {
2846 switch (*p)
2847 {
2848 default:
2849 *obufp++ = *p;
2850 break;
2851 case '{':
2852 alt = 0;
2853 if (intel_syntax)
2854 alt += 1;
2855 if (address_mode == mode_64bit)
2856 alt += 2;
2857 while (alt != 0)
2858 {
2859 while (*++p != '|')
2860 {
2861 if (*p == '}')
2862 {
2863 /* Alternative not valid. */
2864 strcpy (obuf, "(bad)");
2865 obufp = obuf + 5;
2866 return 1;
2867 }
2868 else if (*p == '\0')
2869 abort ();
2870 }
2871 alt--;
2872 }
2873 /* Fall through. */
2874 case 'I':
2875 alt = 1;
2876 continue;
2877 case '|':
2878 while (*++p != '}')
2879 {
2880 if (*p == '\0')
2881 abort ();
2882 }
2883 break;
2884 case '}':
2885 break;
2886 case 'A':
2887 if (intel_syntax)
2888 break;
2889 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
2890 *obufp++ = 'b';
2891 break;
2892 case 'B':
2893 if (intel_syntax)
2894 break;
2895 if (sizeflag & SUFFIX_ALWAYS)
2896 *obufp++ = 'b';
2897 break;
2898 case 'C':
2899 if (intel_syntax && !alt)
2900 break;
2901 if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
2902 {
2903 if (sizeflag & DFLAG)
2904 *obufp++ = intel_syntax ? 'd' : 'l';
2905 else
2906 *obufp++ = intel_syntax ? 'w' : 's';
2907 used_prefixes |= (prefixes & PREFIX_DATA);
2908 }
2909 break;
2910 case 'E': /* For jcxz/jecxz */
2911 if (address_mode == mode_64bit)
2912 {
2913 if (sizeflag & AFLAG)
2914 *obufp++ = 'r';
2915 else
2916 *obufp++ = 'e';
2917 }
2918 else
2919 if (sizeflag & AFLAG)
2920 *obufp++ = 'e';
2921 used_prefixes |= (prefixes & PREFIX_ADDR);
2922 break;
2923 case 'F':
2924 if (intel_syntax)
2925 break;
2926 if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
2927 {
2928 if (sizeflag & AFLAG)
2929 *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
2930 else
2931 *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
2932 used_prefixes |= (prefixes & PREFIX_ADDR);
2933 }
2934 break;
2935 case 'H':
2936 if (intel_syntax)
2937 break;
2938 if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
2939 || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
2940 {
2941 used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
2942 *obufp++ = ',';
2943 *obufp++ = 'p';
2944 if (prefixes & PREFIX_DS)
2945 *obufp++ = 't';
2946 else
2947 *obufp++ = 'n';
2948 }
2949 break;
2950 case 'J':
2951 if (intel_syntax)
2952 break;
2953 *obufp++ = 'l';
2954 break;
2955 case 'Z':
2956 if (intel_syntax)
2957 break;
2958 if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
2959 {
2960 *obufp++ = 'q';
2961 break;
2962 }
2963 /* Fall through. */
2964 case 'L':
2965 if (intel_syntax)
2966 break;
2967 if (sizeflag & SUFFIX_ALWAYS)
2968 *obufp++ = 'l';
2969 break;
2970 case 'N':
2971 if ((prefixes & PREFIX_FWAIT) == 0)
2972 *obufp++ = 'n';
2973 else
2974 used_prefixes |= PREFIX_FWAIT;
2975 break;
2976 case 'O':
2977 USED_REX (REX_MODE64);
2978 if (rex & REX_MODE64)
2979 *obufp++ = 'o';
2980 else
2981 *obufp++ = 'd';
2982 break;
2983 case 'T':
2984 if (intel_syntax)
2985 break;
2986 if (address_mode == mode_64bit && (sizeflag & DFLAG))
2987 {
2988 *obufp++ = 'q';
2989 break;
2990 }
2991 /* Fall through. */
2992 case 'P':
2993 if (intel_syntax)
2994 break;
2995 if ((prefixes & PREFIX_DATA)
2996 || (rex & REX_MODE64)
2997 || (sizeflag & SUFFIX_ALWAYS))
2998 {
2999 USED_REX (REX_MODE64);
3000 if (rex & REX_MODE64)
3001 *obufp++ = 'q';
3002 else
3003 {
3004 if (sizeflag & DFLAG)
3005 *obufp++ = 'l';
3006 else
3007 *obufp++ = 'w';
3008 }
3009 used_prefixes |= (prefixes & PREFIX_DATA);
3010 }
3011 break;
3012 case 'U':
3013 if (intel_syntax)
3014 break;
3015 if (address_mode == mode_64bit && (sizeflag & DFLAG))
3016 {
3017 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
3018 *obufp++ = 'q';
3019 break;
3020 }
3021 /* Fall through. */
3022 case 'Q':
3023 if (intel_syntax && !alt)
3024 break;
3025 USED_REX (REX_MODE64);
3026 if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
3027 {
3028 if (rex & REX_MODE64)
3029 *obufp++ = 'q';
3030 else
3031 {
3032 if (sizeflag & DFLAG)
3033 *obufp++ = intel_syntax ? 'd' : 'l';
3034 else
3035 *obufp++ = 'w';
3036 }
3037 used_prefixes |= (prefixes & PREFIX_DATA);
3038 }
3039 break;
3040 case 'R':
3041 USED_REX (REX_MODE64);
3042 if (intel_syntax)
3043 {
3044 if (rex & REX_MODE64)
3045 {
3046 *obufp++ = 'q';
3047 *obufp++ = 't';
3048 }
3049 else if (sizeflag & DFLAG)
3050 {
3051 *obufp++ = 'd';
3052 *obufp++ = 'q';
3053 }
3054 else
3055 {
3056 *obufp++ = 'w';
3057 *obufp++ = 'd';
3058 }
3059 }
3060 else
3061 {
3062 if (rex & REX_MODE64)
3063 *obufp++ = 'q';
3064 else if (sizeflag & DFLAG)
3065 *obufp++ = 'l';
3066 else
3067 *obufp++ = 'w';
3068 }
3069 if (!(rex & REX_MODE64))
3070 used_prefixes |= (prefixes & PREFIX_DATA);
3071 break;
3072 case 'V':
3073 if (intel_syntax)
3074 break;
3075 if (address_mode == mode_64bit && (sizeflag & DFLAG))
3076 {
3077 if (sizeflag & SUFFIX_ALWAYS)
3078 *obufp++ = 'q';
3079 break;
3080 }
3081 /* Fall through. */
3082 case 'S':
3083 if (intel_syntax)
3084 break;
3085 if (sizeflag & SUFFIX_ALWAYS)
3086 {
3087 if (rex & REX_MODE64)
3088 *obufp++ = 'q';
3089 else
3090 {
3091 if (sizeflag & DFLAG)
3092 *obufp++ = 'l';
3093 else
3094 *obufp++ = 'w';
3095 used_prefixes |= (prefixes & PREFIX_DATA);
3096 }
3097 }
3098 break;
3099 case 'X':
3100 if (prefixes & PREFIX_DATA)
3101 *obufp++ = 'd';
3102 else
3103 *obufp++ = 's';
3104 used_prefixes |= (prefixes & PREFIX_DATA);
3105 break;
3106 case 'Y':
3107 if (intel_syntax)
3108 break;
3109 if (rex & REX_MODE64)
3110 {
3111 USED_REX (REX_MODE64);
3112 *obufp++ = 'q';
3113 }
3114 break;
3115 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
3116 case 'W':
3117 /* operand size flag for cwtl, cbtw */
3118 USED_REX (0);
3119 if (rex)
3120 *obufp++ = 'l';
3121 else if (sizeflag & DFLAG)
3122 *obufp++ = 'w';
3123 else
3124 *obufp++ = 'b';
3125 if (intel_syntax)
3126 {
3127 if (rex)
3128 {
3129 *obufp++ = 'q';
3130 *obufp++ = 'e';
3131 }
3132 if (sizeflag & DFLAG)
3133 {
3134 *obufp++ = 'd';
3135 *obufp++ = 'e';
3136 }
3137 else
3138 {
3139 *obufp++ = 'w';
3140 }
3141 }
3142 if (!rex)
3143 used_prefixes |= (prefixes & PREFIX_DATA);
3144 break;
3145 }
3146 alt = 0;
3147 }
3148 *obufp = 0;
3149 return 0;
3150 }
3151
3152 static void
3153 oappend (const char *s)
3154 {
3155 strcpy (obufp, s);
3156 obufp += strlen (s);
3157 }
3158
3159 static void
3160 append_seg (void)
3161 {
3162 if (prefixes & PREFIX_CS)
3163 {
3164 used_prefixes |= PREFIX_CS;
3165 oappend ("%cs:" + intel_syntax);
3166 }
3167 if (prefixes & PREFIX_DS)
3168 {
3169 used_prefixes |= PREFIX_DS;
3170 oappend ("%ds:" + intel_syntax);
3171 }
3172 if (prefixes & PREFIX_SS)
3173 {
3174 used_prefixes |= PREFIX_SS;
3175 oappend ("%ss:" + intel_syntax);
3176 }
3177 if (prefixes & PREFIX_ES)
3178 {
3179 used_prefixes |= PREFIX_ES;
3180 oappend ("%es:" + intel_syntax);
3181 }
3182 if (prefixes & PREFIX_FS)
3183 {
3184 used_prefixes |= PREFIX_FS;
3185 oappend ("%fs:" + intel_syntax);
3186 }
3187 if (prefixes & PREFIX_GS)
3188 {
3189 used_prefixes |= PREFIX_GS;
3190 oappend ("%gs:" + intel_syntax);
3191 }
3192 }
3193
3194 static void
3195 OP_indirE (int bytemode, int sizeflag)
3196 {
3197 if (!intel_syntax)
3198 oappend ("*");
3199 OP_E (bytemode, sizeflag);
3200 }
3201
3202 static void
3203 print_operand_value (char *buf, int hex, bfd_vma disp)
3204 {
3205 if (address_mode == mode_64bit)
3206 {
3207 if (hex)
3208 {
3209 char tmp[30];
3210 int i;
3211 buf[0] = '0';
3212 buf[1] = 'x';
3213 sprintf_vma (tmp, disp);
3214 for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
3215 strcpy (buf + 2, tmp + i);
3216 }
3217 else
3218 {
3219 bfd_signed_vma v = disp;
3220 char tmp[30];
3221 int i;
3222 if (v < 0)
3223 {
3224 *(buf++) = '-';
3225 v = -disp;
3226 /* Check for possible overflow on 0x8000000000000000. */
3227 if (v < 0)
3228 {
3229 strcpy (buf, "9223372036854775808");
3230 return;
3231 }
3232 }
3233 if (!v)
3234 {
3235 strcpy (buf, "0");
3236 return;
3237 }
3238
3239 i = 0;
3240 tmp[29] = 0;
3241 while (v)
3242 {
3243 tmp[28 - i] = (v % 10) + '0';
3244 v /= 10;
3245 i++;
3246 }
3247 strcpy (buf, tmp + 29 - i);
3248 }
3249 }
3250 else
3251 {
3252 if (hex)
3253 sprintf (buf, "0x%x", (unsigned int) disp);
3254 else
3255 sprintf (buf, "%d", (int) disp);
3256 }
3257 }
3258
3259 static void
3260 intel_operand_size (int bytemode, int sizeflag)
3261 {
3262 switch (bytemode)
3263 {
3264 case b_mode:
3265 oappend ("BYTE PTR ");
3266 break;
3267 case w_mode:
3268 case dqw_mode:
3269 oappend ("WORD PTR ");
3270 break;
3271 case stack_v_mode:
3272 if (address_mode == mode_64bit && (sizeflag & DFLAG))
3273 {
3274 oappend ("QWORD PTR ");
3275 used_prefixes |= (prefixes & PREFIX_DATA);
3276 break;
3277 }
3278 /* FALLTHRU */
3279 case v_mode:
3280 case dq_mode:
3281 USED_REX (REX_MODE64);
3282 if (rex & REX_MODE64)
3283 oappend ("QWORD PTR ");
3284 else if ((sizeflag & DFLAG) || bytemode == dq_mode)
3285 oappend ("DWORD PTR ");
3286 else
3287 oappend ("WORD PTR ");
3288 used_prefixes |= (prefixes & PREFIX_DATA);
3289 break;
3290 case d_mode:
3291 oappend ("DWORD PTR ");
3292 break;
3293 case q_mode:
3294 oappend ("QWORD PTR ");
3295 break;
3296 case m_mode:
3297 if (address_mode == mode_64bit)
3298 oappend ("QWORD PTR ");
3299 else
3300 oappend ("DWORD PTR ");
3301 break;
3302 case f_mode:
3303 if (sizeflag & DFLAG)
3304 oappend ("FWORD PTR ");
3305 else
3306 oappend ("DWORD PTR ");
3307 used_prefixes |= (prefixes & PREFIX_DATA);
3308 break;
3309 case t_mode:
3310 oappend ("TBYTE PTR ");
3311 break;
3312 case x_mode:
3313 oappend ("XMMWORD PTR ");
3314 break;
3315 default:
3316 break;
3317 }
3318 }
3319
3320 static void
3321 OP_E (int bytemode, int sizeflag)
3322 {
3323 bfd_vma disp;
3324 int add = 0;
3325 int riprel = 0;
3326 USED_REX (REX_EXTZ);
3327 if (rex & REX_EXTZ)
3328 add += 8;
3329
3330 /* Skip mod/rm byte. */
3331 MODRM_CHECK;
3332 codep++;
3333
3334 if (mod == 3)
3335 {
3336 switch (bytemode)
3337 {
3338 case b_mode:
3339 USED_REX (0);
3340 if (rex)
3341 oappend (names8rex[rm + add]);
3342 else
3343 oappend (names8[rm + add]);
3344 break;
3345 case w_mode:
3346 oappend (names16[rm + add]);
3347 break;
3348 case d_mode:
3349 oappend (names32[rm + add]);
3350 break;
3351 case q_mode:
3352 oappend (names64[rm + add]);
3353 break;
3354 case m_mode:
3355 if (address_mode == mode_64bit)
3356 oappend (names64[rm + add]);
3357 else
3358 oappend (names32[rm + add]);
3359 break;
3360 case stack_v_mode:
3361 if (address_mode == mode_64bit && (sizeflag & DFLAG))
3362 {
3363 oappend (names64[rm + add]);
3364 used_prefixes |= (prefixes & PREFIX_DATA);
3365 break;
3366 }
3367 bytemode = v_mode;
3368 /* FALLTHRU */
3369 case v_mode:
3370 case dq_mode:
3371 case dqw_mode:
3372 USED_REX (REX_MODE64);
3373 if (rex & REX_MODE64)
3374 oappend (names64[rm + add]);
3375 else if ((sizeflag & DFLAG) || bytemode != v_mode)
3376 oappend (names32[rm + add]);
3377 else
3378 oappend (names16[rm + add]);
3379 used_prefixes |= (prefixes & PREFIX_DATA);
3380 break;
3381 case 0:
3382 break;
3383 default:
3384 oappend (INTERNAL_DISASSEMBLER_ERROR);
3385 break;
3386 }
3387 return;
3388 }
3389
3390 disp = 0;
3391 if (intel_syntax)
3392 intel_operand_size (bytemode, sizeflag);
3393 append_seg ();
3394
3395 if ((sizeflag & AFLAG) || address_mode == mode_64bit) /* 32 bit address mode */
3396 {
3397 int havesib;
3398 int havebase;
3399 int base;
3400 int index = 0;
3401 int scale = 0;
3402
3403 havesib = 0;
3404 havebase = 1;
3405 base = rm;
3406
3407 if (base == 4)
3408 {
3409 havesib = 1;
3410 FETCH_DATA (the_info, codep + 1);
3411 index = (*codep >> 3) & 7;
3412 if (address_mode == mode_64bit || index != 0x4)
3413 /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored. */
3414 scale = (*codep >> 6) & 3;
3415 base = *codep & 7;
3416 USED_REX (REX_EXTY);
3417 if (rex & REX_EXTY)
3418 index += 8;
3419 codep++;
3420 }
3421 base += add;
3422
3423 switch (mod)
3424 {
3425 case 0:
3426 if ((base & 7) == 5)
3427 {
3428 havebase = 0;
3429 if (address_mode == mode_64bit && !havesib)
3430 riprel = 1;
3431 disp = get32s ();
3432 }
3433 break;
3434 case 1:
3435 FETCH_DATA (the_info, codep + 1);
3436 disp = *codep++;
3437 if ((disp & 0x80) != 0)
3438 disp -= 0x100;
3439 break;
3440 case 2:
3441 disp = get32s ();
3442 break;
3443 }
3444
3445 if (!intel_syntax)
3446 if (mod != 0 || (base & 7) == 5)
3447 {
3448 print_operand_value (scratchbuf, !riprel, disp);
3449 oappend (scratchbuf);
3450 if (riprel)
3451 {
3452 set_op (disp, 1);
3453 oappend ("(%rip)");
3454 }
3455 }
3456
3457 if (havebase || (havesib && (index != 4 || scale != 0)))
3458 {
3459 *obufp++ = open_char;
3460 if (intel_syntax && riprel)
3461 oappend ("rip + ");
3462 *obufp = '\0';
3463 if (havebase)
3464 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3465 ? names64[base] : names32[base]);
3466 if (havesib)
3467 {
3468 if (index != 4)
3469 {
3470 if (!intel_syntax || havebase)
3471 {
3472 *obufp++ = separator_char;
3473 *obufp = '\0';
3474 }
3475 oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
3476 ? names64[index] : names32[index]);
3477 }
3478 if (scale != 0 || (!intel_syntax && index != 4))
3479 {
3480 *obufp++ = scale_char;
3481 *obufp = '\0';
3482 sprintf (scratchbuf, "%d", 1 << scale);
3483 oappend (scratchbuf);
3484 }
3485 }
3486 if (intel_syntax && disp)
3487 {
3488 if ((bfd_signed_vma) disp > 0)
3489 {
3490 *obufp++ = '+';
3491 *obufp = '\0';
3492 }
3493 else if (mod != 1)
3494 {
3495 *obufp++ = '-';
3496 *obufp = '\0';
3497 disp = - (bfd_signed_vma) disp;
3498 }
3499
3500 print_operand_value (scratchbuf, mod != 1, disp);
3501 oappend (scratchbuf);
3502 }
3503
3504 *obufp++ = close_char;
3505 *obufp = '\0';
3506 }
3507 else if (intel_syntax)
3508 {
3509 if (mod != 0 || (base & 7) == 5)
3510 {
3511 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3512 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3513 ;
3514 else
3515 {
3516 oappend (names_seg[ds_reg - es_reg]);
3517 oappend (":");
3518 }
3519 print_operand_value (scratchbuf, 1, disp);
3520 oappend (scratchbuf);
3521 }
3522 }
3523 }
3524 else
3525 { /* 16 bit address mode */
3526 switch (mod)
3527 {
3528 case 0:
3529 if (rm == 6)
3530 {
3531 disp = get16 ();
3532 if ((disp & 0x8000) != 0)
3533 disp -= 0x10000;
3534 }
3535 break;
3536 case 1:
3537 FETCH_DATA (the_info, codep + 1);
3538 disp = *codep++;
3539 if ((disp & 0x80) != 0)
3540 disp -= 0x100;
3541 break;
3542 case 2:
3543 disp = get16 ();
3544 if ((disp & 0x8000) != 0)
3545 disp -= 0x10000;
3546 break;
3547 }
3548
3549 if (!intel_syntax)
3550 if (mod != 0 || rm == 6)
3551 {
3552 print_operand_value (scratchbuf, 0, disp);
3553 oappend (scratchbuf);
3554 }
3555
3556 if (mod != 0 || rm != 6)
3557 {
3558 *obufp++ = open_char;
3559 *obufp = '\0';
3560 oappend (index16[rm]);
3561 if (intel_syntax && disp)
3562 {
3563 if ((bfd_signed_vma) disp > 0)
3564 {
3565 *obufp++ = '+';
3566 *obufp = '\0';
3567 }
3568 else if (mod != 1)
3569 {
3570 *obufp++ = '-';
3571 *obufp = '\0';
3572 disp = - (bfd_signed_vma) disp;
3573 }
3574
3575 print_operand_value (scratchbuf, mod != 1, disp);
3576 oappend (scratchbuf);
3577 }
3578
3579 *obufp++ = close_char;
3580 *obufp = '\0';
3581 }
3582 else if (intel_syntax)
3583 {
3584 if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
3585 | PREFIX_ES | PREFIX_FS | PREFIX_GS))
3586 ;
3587 else
3588 {
3589 oappend (names_seg[ds_reg - es_reg]);
3590 oappend (":");
3591 }
3592 print_operand_value (scratchbuf, 1, disp & 0xffff);
3593 oappend (scratchbuf);
3594 }
3595 }
3596 }
3597
3598 static void
3599 OP_G (int bytemode, int sizeflag)
3600 {
3601 int add = 0;
3602 USED_REX (REX_EXTX);
3603 if (rex & REX_EXTX)
3604 add += 8;
3605 switch (bytemode)
3606 {
3607 case b_mode:
3608 USED_REX (0);
3609 if (rex)
3610 oappend (names8rex[reg + add]);
3611 else
3612 oappend (names8[reg + add]);
3613 break;
3614 case w_mode:
3615 oappend (names16[reg + add]);
3616 break;
3617 case d_mode:
3618 oappend (names32[reg + add]);
3619 break;
3620 case q_mode:
3621 oappend (names64[reg + add]);
3622 break;
3623 case v_mode:
3624 case dq_mode:
3625 case dqw_mode:
3626 USED_REX (REX_MODE64);
3627 if (rex & REX_MODE64)
3628 oappend (names64[reg + add]);
3629 else if ((sizeflag & DFLAG) || bytemode != v_mode)
3630 oappend (names32[reg + add]);
3631 else
3632 oappend (names16[reg + add]);
3633 used_prefixes |= (prefixes & PREFIX_DATA);
3634 break;
3635 case m_mode:
3636 if (address_mode == mode_64bit)
3637 oappend (names64[reg + add]);
3638 else
3639 oappend (names32[reg + add]);
3640 break;
3641 default:
3642 oappend (INTERNAL_DISASSEMBLER_ERROR);
3643 break;
3644 }
3645 }
3646
3647 static bfd_vma
3648 get64 (void)
3649 {
3650 bfd_vma x;
3651 #ifdef BFD64
3652 unsigned int a;
3653 unsigned int b;
3654
3655 FETCH_DATA (the_info, codep + 8);
3656 a = *codep++ & 0xff;
3657 a |= (*codep++ & 0xff) << 8;
3658 a |= (*codep++ & 0xff) << 16;
3659 a |= (*codep++ & 0xff) << 24;
3660 b = *codep++ & 0xff;
3661 b |= (*codep++ & 0xff) << 8;
3662 b |= (*codep++ & 0xff) << 16;
3663 b |= (*codep++ & 0xff) << 24;
3664 x = a + ((bfd_vma) b << 32);
3665 #else
3666 abort ();
3667 x = 0;
3668 #endif
3669 return x;
3670 }
3671
3672 static bfd_signed_vma
3673 get32 (void)
3674 {
3675 bfd_signed_vma x = 0;
3676
3677 FETCH_DATA (the_info, codep + 4);
3678 x = *codep++ & (bfd_signed_vma) 0xff;
3679 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3680 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3681 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3682 return x;
3683 }
3684
3685 static bfd_signed_vma
3686 get32s (void)
3687 {
3688 bfd_signed_vma x = 0;
3689
3690 FETCH_DATA (the_info, codep + 4);
3691 x = *codep++ & (bfd_signed_vma) 0xff;
3692 x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
3693 x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
3694 x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
3695
3696 x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);
3697
3698 return x;
3699 }
3700
3701 static int
3702 get16 (void)
3703 {
3704 int x = 0;
3705
3706 FETCH_DATA (the_info, codep + 2);
3707 x = *codep++ & 0xff;
3708 x |= (*codep++ & 0xff) << 8;
3709 return x;
3710 }
3711
3712 static void
3713 set_op (bfd_vma op, int riprel)
3714 {
3715 op_index[op_ad] = op_ad;
3716 if (address_mode == mode_64bit)
3717 {
3718 op_address[op_ad] = op;
3719 op_riprel[op_ad] = riprel;
3720 }
3721 else
3722 {
3723 /* Mask to get a 32-bit address. */
3724 op_address[op_ad] = op & 0xffffffff;
3725 op_riprel[op_ad] = riprel & 0xffffffff;
3726 }
3727 }
3728
3729 static void
3730 OP_REG (int code, int sizeflag)
3731 {
3732 const char *s;
3733 int add = 0;
3734 USED_REX (REX_EXTZ);
3735 if (rex & REX_EXTZ)
3736 add = 8;
3737
3738 switch (code)
3739 {
3740 case indir_dx_reg:
3741 if (intel_syntax)
3742 s = "[dx]";
3743 else
3744 s = "(%dx)";
3745 break;
3746 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3747 case sp_reg: case bp_reg: case si_reg: case di_reg:
3748 s = names16[code - ax_reg + add];
3749 break;
3750 case es_reg: case ss_reg: case cs_reg:
3751 case ds_reg: case fs_reg: case gs_reg:
3752 s = names_seg[code - es_reg + add];
3753 break;
3754 case al_reg: case ah_reg: case cl_reg: case ch_reg:
3755 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3756 USED_REX (0);
3757 if (rex)
3758 s = names8rex[code - al_reg + add];
3759 else
3760 s = names8[code - al_reg];
3761 break;
3762 case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
3763 case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
3764 if (address_mode == mode_64bit && (sizeflag & DFLAG))
3765 {
3766 s = names64[code - rAX_reg + add];
3767 break;
3768 }
3769 code += eAX_reg - rAX_reg;
3770 /* Fall through. */
3771 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3772 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3773 USED_REX (REX_MODE64);
3774 if (rex & REX_MODE64)
3775 s = names64[code - eAX_reg + add];
3776 else if (sizeflag & DFLAG)
3777 s = names32[code - eAX_reg + add];
3778 else
3779 s = names16[code - eAX_reg + add];
3780 used_prefixes |= (prefixes & PREFIX_DATA);
3781 break;
3782 default:
3783 s = INTERNAL_DISASSEMBLER_ERROR;
3784 break;
3785 }
3786 oappend (s);
3787 }
3788
3789 static void
3790 OP_IMREG (int code, int sizeflag)
3791 {
3792 const char *s;
3793
3794 switch (code)
3795 {
3796 case indir_dx_reg:
3797 if (intel_syntax)
3798 s = "[dx]";
3799 else
3800 s = "(%dx)";
3801 break;
3802 case ax_reg: case cx_reg: case dx_reg: case bx_reg:
3803 case sp_reg: case bp_reg: case si_reg: case di_reg:
3804 s = names16[code - ax_reg];
3805 break;
3806 case es_reg: case ss_reg: case cs_reg:
3807 case ds_reg: case fs_reg: case gs_reg:
3808 s = names_seg[code - es_reg];
3809 break;
3810 case al_reg: case ah_reg: case cl_reg: case ch_reg:
3811 case dl_reg: case dh_reg: case bl_reg: case bh_reg:
3812 USED_REX (0);
3813 if (rex)
3814 s = names8rex[code - al_reg];
3815 else
3816 s = names8[code - al_reg];
3817 break;
3818 case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
3819 case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
3820 USED_REX (REX_MODE64);
3821 if (rex & REX_MODE64)
3822 s = names64[code - eAX_reg];
3823 else if (sizeflag & DFLAG)
3824 s = names32[code - eAX_reg];
3825 else
3826 s = names16[code - eAX_reg];
3827 used_prefixes |= (prefixes & PREFIX_DATA);
3828 break;
3829 default:
3830 s = INTERNAL_DISASSEMBLER_ERROR;
3831 break;
3832 }
3833 oappend (s);
3834 }
3835
3836 static void
3837 OP_I (int bytemode, int sizeflag)
3838 {
3839 bfd_signed_vma op;
3840 bfd_signed_vma mask = -1;
3841
3842 switch (bytemode)
3843 {
3844 case b_mode:
3845 FETCH_DATA (the_info, codep + 1);
3846 op = *codep++;
3847 mask = 0xff;
3848 break;
3849 case q_mode:
3850 if (address_mode == mode_64bit)
3851 {
3852 op = get32s ();
3853 break;
3854 }
3855 /* Fall through. */
3856 case v_mode:
3857 USED_REX (REX_MODE64);
3858 if (rex & REX_MODE64)
3859 op = get32s ();
3860 else if (sizeflag & DFLAG)
3861 {
3862 op = get32 ();
3863 mask = 0xffffffff;
3864 }
3865 else
3866 {
3867 op = get16 ();
3868 mask = 0xfffff;
3869 }
3870 used_prefixes |= (prefixes & PREFIX_DATA);
3871 break;
3872 case w_mode:
3873 mask = 0xfffff;
3874 op = get16 ();
3875 break;
3876 case const_1_mode:
3877 if (intel_syntax)
3878 oappend ("1");
3879 return;
3880 default:
3881 oappend (INTERNAL_DISASSEMBLER_ERROR);
3882 return;
3883 }
3884
3885 op &= mask;
3886 scratchbuf[0] = '$';
3887 print_operand_value (scratchbuf + 1, 1, op);
3888 oappend (scratchbuf + intel_syntax);
3889 scratchbuf[0] = '\0';
3890 }
3891
3892 static void
3893 OP_I64 (int bytemode, int sizeflag)
3894 {
3895 bfd_signed_vma op;
3896 bfd_signed_vma mask = -1;
3897
3898 if (address_mode != mode_64bit)
3899 {
3900 OP_I (bytemode, sizeflag);
3901 return;
3902 }
3903
3904 switch (bytemode)
3905 {
3906 case b_mode:
3907 FETCH_DATA (the_info, codep + 1);
3908 op = *codep++;
3909 mask = 0xff;
3910 break;
3911 case v_mode:
3912 USED_REX (REX_MODE64);
3913 if (rex & REX_MODE64)
3914 op = get64 ();
3915 else if (sizeflag & DFLAG)
3916 {
3917 op = get32 ();
3918 mask = 0xffffffff;
3919 }
3920 else
3921 {
3922 op = get16 ();
3923 mask = 0xfffff;
3924 }
3925 used_prefixes |= (prefixes & PREFIX_DATA);
3926 break;
3927 case w_mode:
3928 mask = 0xfffff;
3929 op = get16 ();
3930 break;
3931 default:
3932 oappend (INTERNAL_DISASSEMBLER_ERROR);
3933 return;
3934 }
3935
3936 op &= mask;
3937 scratchbuf[0] = '$';
3938 print_operand_value (scratchbuf + 1, 1, op);
3939 oappend (scratchbuf + intel_syntax);
3940 scratchbuf[0] = '\0';
3941 }
3942
3943 static void
3944 OP_sI (int bytemode, int sizeflag)
3945 {
3946 bfd_signed_vma op;
3947 bfd_signed_vma mask = -1;
3948
3949 switch (bytemode)
3950 {
3951 case b_mode:
3952 FETCH_DATA (the_info, codep + 1);
3953 op = *codep++;
3954 if ((op & 0x80) != 0)
3955 op -= 0x100;
3956 mask = 0xffffffff;
3957 break;
3958 case v_mode:
3959 USED_REX (REX_MODE64);
3960 if (rex & REX_MODE64)
3961 op = get32s ();
3962 else if (sizeflag & DFLAG)
3963 {
3964 op = get32s ();
3965 mask = 0xffffffff;
3966 }
3967 else
3968 {
3969 mask = 0xffffffff;
3970 op = get16 ();
3971 if ((op & 0x8000) != 0)
3972 op -= 0x10000;
3973 }
3974 used_prefixes |= (prefixes & PREFIX_DATA);
3975 break;
3976 case w_mode:
3977 op = get16 ();
3978 mask = 0xffffffff;
3979 if ((op & 0x8000) != 0)
3980 op -= 0x10000;
3981 break;
3982 default:
3983 oappend (INTERNAL_DISASSEMBLER_ERROR);
3984 return;
3985 }
3986
3987 scratchbuf[0] = '$';
3988 print_operand_value (scratchbuf + 1, 1, op);
3989 oappend (scratchbuf + intel_syntax);
3990 }
3991
3992 static void
3993 OP_J (int bytemode, int sizeflag)
3994 {
3995 bfd_vma disp;
3996 bfd_vma mask = -1;
3997
3998 switch (bytemode)
3999 {
4000 case b_mode:
4001 FETCH_DATA (the_info, codep + 1);
4002 disp = *codep++;
4003 if ((disp & 0x80) != 0)
4004 disp -= 0x100;
4005 break;
4006 case v_mode:
4007 if ((sizeflag & DFLAG) || (rex & REX_MODE64))
4008 disp = get32s ();
4009 else
4010 {
4011 disp = get16 ();
4012 /* For some reason, a data16 prefix on a jump instruction
4013 means that the pc is masked to 16 bits after the
4014 displacement is added! */
4015 mask = 0xffff;
4016 }
4017 break;
4018 default:
4019 oappend (INTERNAL_DISASSEMBLER_ERROR);
4020 return;
4021 }
4022 disp = (start_pc + codep - start_codep + disp) & mask;
4023 set_op (disp, 0);
4024 print_operand_value (scratchbuf, 1, disp);
4025 oappend (scratchbuf);
4026 }
4027
4028 static void
4029 OP_SEG (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4030 {
4031 oappend (names_seg[reg]);
4032 }
4033
4034 static void
4035 OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
4036 {
4037 int seg, offset;
4038
4039 if (sizeflag & DFLAG)
4040 {
4041 offset = get32 ();
4042 seg = get16 ();
4043 }
4044 else
4045 {
4046 offset = get16 ();
4047 seg = get16 ();
4048 }
4049 used_prefixes |= (prefixes & PREFIX_DATA);
4050 if (intel_syntax)
4051 sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
4052 else
4053 sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
4054 oappend (scratchbuf);
4055 }
4056
4057 static void
4058 OP_OFF (int bytemode, int sizeflag)
4059 {
4060 bfd_vma off;
4061
4062 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
4063 intel_operand_size (bytemode, sizeflag);
4064 append_seg ();
4065
4066 if ((sizeflag & AFLAG) || address_mode == mode_64bit)
4067 off = get32 ();
4068 else
4069 off = get16 ();
4070
4071 if (intel_syntax)
4072 {
4073 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
4074 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
4075 {
4076 oappend (names_seg[ds_reg - es_reg]);
4077 oappend (":");
4078 }
4079 }
4080 print_operand_value (scratchbuf, 1, off);
4081 oappend (scratchbuf);
4082 }
4083
4084 static void
4085 OP_OFF64 (int bytemode, int sizeflag)
4086 {
4087 bfd_vma off;
4088
4089 if (address_mode != mode_64bit)
4090 {
4091 OP_OFF (bytemode, sizeflag);
4092 return;
4093 }
4094
4095 if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
4096 intel_operand_size (bytemode, sizeflag);
4097 append_seg ();
4098
4099 off = get64 ();
4100
4101 if (intel_syntax)
4102 {
4103 if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
4104 | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
4105 {
4106 oappend (names_seg[ds_reg - es_reg]);
4107 oappend (":");
4108 }
4109 }
4110 print_operand_value (scratchbuf, 1, off);
4111 oappend (scratchbuf);
4112 }
4113
4114 static void
4115 ptr_reg (int code, int sizeflag)
4116 {
4117 const char *s;
4118
4119 *obufp++ = open_char;
4120 used_prefixes |= (prefixes & PREFIX_ADDR);
4121 if (address_mode == mode_64bit)
4122 {
4123 if (!(sizeflag & AFLAG))
4124 s = names32[code - eAX_reg];
4125 else
4126 s = names64[code - eAX_reg];
4127 }
4128 else if (sizeflag & AFLAG)
4129 s = names32[code - eAX_reg];
4130 else
4131 s = names16[code - eAX_reg];
4132 oappend (s);
4133 *obufp++ = close_char;
4134 *obufp = 0;
4135 }
4136
4137 static void
4138 OP_ESreg (int code, int sizeflag)
4139 {
4140 if (intel_syntax)
4141 intel_operand_size (codep[-1] & 1 ? v_mode : b_mode, sizeflag);
4142 oappend ("%es:" + intel_syntax);
4143 ptr_reg (code, sizeflag);
4144 }
4145
4146 static void
4147 OP_DSreg (int code, int sizeflag)
4148 {
4149 if (intel_syntax)
4150 intel_operand_size (codep[-1] != 0xd7 && (codep[-1] & 1)
4151 ? v_mode
4152 : b_mode,
4153 sizeflag);
4154 if ((prefixes
4155 & (PREFIX_CS
4156 | PREFIX_DS
4157 | PREFIX_SS
4158 | PREFIX_ES
4159 | PREFIX_FS
4160 | PREFIX_GS)) == 0)
4161 prefixes |= PREFIX_DS;
4162 append_seg ();
4163 ptr_reg (code, sizeflag);
4164 }
4165
4166 static void
4167 OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4168 {
4169 int add = 0;
4170 if (rex & REX_EXTX)
4171 {
4172 USED_REX (REX_EXTX);
4173 add = 8;
4174 }
4175 else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
4176 {
4177 used_prefixes |= PREFIX_LOCK;
4178 add = 8;
4179 }
4180 sprintf (scratchbuf, "%%cr%d", reg + add);
4181 oappend (scratchbuf + intel_syntax);
4182 }
4183
4184 static void
4185 OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4186 {
4187 int add = 0;
4188 USED_REX (REX_EXTX);
4189 if (rex & REX_EXTX)
4190 add = 8;
4191 if (intel_syntax)
4192 sprintf (scratchbuf, "db%d", reg + add);
4193 else
4194 sprintf (scratchbuf, "%%db%d", reg + add);
4195 oappend (scratchbuf);
4196 }
4197
4198 static void
4199 OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4200 {
4201 sprintf (scratchbuf, "%%tr%d", reg);
4202 oappend (scratchbuf + intel_syntax);
4203 }
4204
4205 static void
4206 OP_Rd (int bytemode, int sizeflag)
4207 {
4208 if (mod == 3)
4209 OP_E (bytemode, sizeflag);
4210 else
4211 BadOp ();
4212 }
4213
4214 static void
4215 OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4216 {
4217 used_prefixes |= (prefixes & PREFIX_DATA);
4218 if (prefixes & PREFIX_DATA)
4219 {
4220 int add = 0;
4221 USED_REX (REX_EXTX);
4222 if (rex & REX_EXTX)
4223 add = 8;
4224 sprintf (scratchbuf, "%%xmm%d", reg + add);
4225 }
4226 else
4227 sprintf (scratchbuf, "%%mm%d", reg);
4228 oappend (scratchbuf + intel_syntax);
4229 }
4230
4231 static void
4232 OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4233 {
4234 int add = 0;
4235 USED_REX (REX_EXTX);
4236 if (rex & REX_EXTX)
4237 add = 8;
4238 sprintf (scratchbuf, "%%xmm%d", reg + add);
4239 oappend (scratchbuf + intel_syntax);
4240 }
4241
4242 static void
4243 OP_EM (int bytemode, int sizeflag)
4244 {
4245 if (mod != 3)
4246 {
4247 if (intel_syntax && bytemode == v_mode)
4248 {
4249 bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
4250 used_prefixes |= (prefixes & PREFIX_DATA);
4251 }
4252 OP_E (bytemode, sizeflag);
4253 return;
4254 }
4255
4256 /* Skip mod/rm byte. */
4257 MODRM_CHECK;
4258 codep++;
4259 used_prefixes |= (prefixes & PREFIX_DATA);
4260 if (prefixes & PREFIX_DATA)
4261 {
4262 int add = 0;
4263
4264 USED_REX (REX_EXTZ);
4265 if (rex & REX_EXTZ)
4266 add = 8;
4267 sprintf (scratchbuf, "%%xmm%d", rm + add);
4268 }
4269 else
4270 sprintf (scratchbuf, "%%mm%d", rm);
4271 oappend (scratchbuf + intel_syntax);
4272 }
4273
4274 static void
4275 OP_EX (int bytemode, int sizeflag)
4276 {
4277 int add = 0;
4278 if (mod != 3)
4279 {
4280 if (intel_syntax && bytemode == v_mode)
4281 {
4282 switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
4283 {
4284 case 0: bytemode = x_mode; break;
4285 case PREFIX_REPZ: bytemode = d_mode; used_prefixes |= PREFIX_REPZ; break;
4286 case PREFIX_DATA: bytemode = x_mode; used_prefixes |= PREFIX_DATA; break;
4287 case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
4288 default: bytemode = 0; break;
4289 }
4290 }
4291 OP_E (bytemode, sizeflag);
4292 return;
4293 }
4294 USED_REX (REX_EXTZ);
4295 if (rex & REX_EXTZ)
4296 add = 8;
4297
4298 /* Skip mod/rm byte. */
4299 MODRM_CHECK;
4300 codep++;
4301 sprintf (scratchbuf, "%%xmm%d", rm + add);
4302 oappend (scratchbuf + intel_syntax);
4303 }
4304
4305 static void
4306 OP_MS (int bytemode, int sizeflag)
4307 {
4308 if (mod == 3)
4309 OP_EM (bytemode, sizeflag);
4310 else
4311 BadOp ();
4312 }
4313
4314 static void
4315 OP_XS (int bytemode, int sizeflag)
4316 {
4317 if (mod == 3)
4318 OP_EX (bytemode, sizeflag);
4319 else
4320 BadOp ();
4321 }
4322
4323 static void
4324 OP_M (int bytemode, int sizeflag)
4325 {
4326 if (mod == 3)
4327 BadOp (); /* bad lea,lds,les,lfs,lgs,lss modrm */
4328 else
4329 OP_E (bytemode, sizeflag);
4330 }
4331
4332 static void
4333 OP_0f07 (int bytemode, int sizeflag)
4334 {
4335 if (mod != 3 || rm != 0)
4336 BadOp ();
4337 else
4338 OP_E (bytemode, sizeflag);
4339 }
4340
4341 static void
4342 OP_0fae (int bytemode, int sizeflag)
4343 {
4344 if (mod == 3)
4345 {
4346 if (reg == 7)
4347 strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");
4348
4349 if (reg < 5 || rm != 0)
4350 {
4351 BadOp (); /* bad sfence, mfence, or lfence */
4352 return;
4353 }
4354 }
4355 else if (reg != 7)
4356 {
4357 BadOp (); /* bad clflush */
4358 return;
4359 }
4360
4361 OP_E (bytemode, sizeflag);
4362 }
4363
4364 /* NOP is an alias of "xchg %ax,%ax" in 16bit mode, "xchg %eax,%eax" in
4365 32bit mode and "xchg %rax,%rax" in 64bit mode. NOP with REPZ prefix
4366 is called PAUSE. We display "xchg %ax,%ax" instead of "data16 nop".
4367 */
4368
4369 static void
4370 NOP_Fixup1 (int bytemode, int sizeflag)
4371 {
4372 if (prefixes == PREFIX_REPZ)
4373 strcpy (obuf, "pause");
4374 else if (prefixes == PREFIX_DATA
4375 || ((rex & REX_MODE64) && rex != 0x48))
4376 OP_REG (bytemode, sizeflag);
4377 else
4378 strcpy (obuf, "nop");
4379 }
4380
4381 static void
4382 NOP_Fixup2 (int bytemode, int sizeflag)
4383 {
4384 if (prefixes == PREFIX_DATA
4385 || ((rex & REX_MODE64) && rex != 0x48))
4386 OP_IMREG (bytemode, sizeflag);
4387 }
4388
4389 static const char *const Suffix3DNow[] = {
4390 /* 00 */ NULL, NULL, NULL, NULL,
4391 /* 04 */ NULL, NULL, NULL, NULL,
4392 /* 08 */ NULL, NULL, NULL, NULL,
4393 /* 0C */ "pi2fw", "pi2fd", NULL, NULL,
4394 /* 10 */ NULL, NULL, NULL, NULL,
4395 /* 14 */ NULL, NULL, NULL, NULL,
4396 /* 18 */ NULL, NULL, NULL, NULL,
4397 /* 1C */ "pf2iw", "pf2id", NULL, NULL,
4398 /* 20 */ NULL, NULL, NULL, NULL,
4399 /* 24 */ NULL, NULL, NULL, NULL,
4400 /* 28 */ NULL, NULL, NULL, NULL,
4401 /* 2C */ NULL, NULL, NULL, NULL,
4402 /* 30 */ NULL, NULL, NULL, NULL,
4403 /* 34 */ NULL, NULL, NULL, NULL,
4404 /* 38 */ NULL, NULL, NULL, NULL,
4405 /* 3C */ NULL, NULL, NULL, NULL,
4406 /* 40 */ NULL, NULL, NULL, NULL,
4407 /* 44 */ NULL, NULL, NULL, NULL,
4408 /* 48 */ NULL, NULL, NULL, NULL,
4409 /* 4C */ NULL, NULL, NULL, NULL,
4410 /* 50 */ NULL, NULL, NULL, NULL,
4411 /* 54 */ NULL, NULL, NULL, NULL,
4412 /* 58 */ NULL, NULL, NULL, NULL,
4413 /* 5C */ NULL, NULL, NULL, NULL,
4414 /* 60 */ NULL, NULL, NULL, NULL,
4415 /* 64 */ NULL, NULL, NULL, NULL,
4416 /* 68 */ NULL, NULL, NULL, NULL,
4417 /* 6C */ NULL, NULL, NULL, NULL,
4418 /* 70 */ NULL, NULL, NULL, NULL,
4419 /* 74 */ NULL, NULL, NULL, NULL,
4420 /* 78 */ NULL, NULL, NULL, NULL,
4421 /* 7C */ NULL, NULL, NULL, NULL,
4422 /* 80 */ NULL, NULL, NULL, NULL,
4423 /* 84 */ NULL, NULL, NULL, NULL,
4424 /* 88 */ NULL, NULL, "pfnacc", NULL,
4425 /* 8C */ NULL, NULL, "pfpnacc", NULL,
4426 /* 90 */ "pfcmpge", NULL, NULL, NULL,
4427 /* 94 */ "pfmin", NULL, "pfrcp", "pfrsqrt",
4428 /* 98 */ NULL, NULL, "pfsub", NULL,
4429 /* 9C */ NULL, NULL, "pfadd", NULL,
4430 /* A0 */ "pfcmpgt", NULL, NULL, NULL,
4431 /* A4 */ "pfmax", NULL, "pfrcpit1", "pfrsqit1",
4432 /* A8 */ NULL, NULL, "pfsubr", NULL,
4433 /* AC */ NULL, NULL, "pfacc", NULL,
4434 /* B0 */ "pfcmpeq", NULL, NULL, NULL,
4435 /* B4 */ "pfmul", NULL, "pfrcpit2", "pfmulhrw",
4436 /* B8 */ NULL, NULL, NULL, "pswapd",
4437 /* BC */ NULL, NULL, NULL, "pavgusb",
4438 /* C0 */ NULL, NULL, NULL, NULL,
4439 /* C4 */ NULL, NULL, NULL, NULL,
4440 /* C8 */ NULL, NULL, NULL, NULL,
4441 /* CC */ NULL, NULL, NULL, NULL,
4442 /* D0 */ NULL, NULL, NULL, NULL,
4443 /* D4 */ NULL, NULL, NULL, NULL,
4444 /* D8 */ NULL, NULL, NULL, NULL,
4445 /* DC */ NULL, NULL, NULL, NULL,
4446 /* E0 */ NULL, NULL, NULL, NULL,
4447 /* E4 */ NULL, NULL, NULL, NULL,
4448 /* E8 */ NULL, NULL, NULL, NULL,
4449 /* EC */ NULL, NULL, NULL, NULL,
4450 /* F0 */ NULL, NULL, NULL, NULL,
4451 /* F4 */ NULL, NULL, NULL, NULL,
4452 /* F8 */ NULL, NULL, NULL, NULL,
4453 /* FC */ NULL, NULL, NULL, NULL,
4454 };
4455
4456 static void
4457 OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4458 {
4459 const char *mnemonic;
4460
4461 FETCH_DATA (the_info, codep + 1);
4462 /* AMD 3DNow! instructions are specified by an opcode suffix in the
4463 place where an 8-bit immediate would normally go. ie. the last
4464 byte of the instruction. */
4465 obufp = obuf + strlen (obuf);
4466 mnemonic = Suffix3DNow[*codep++ & 0xff];
4467 if (mnemonic)
4468 oappend (mnemonic);
4469 else
4470 {
4471 /* Since a variable sized modrm/sib chunk is between the start
4472 of the opcode (0x0f0f) and the opcode suffix, we need to do
4473 all the modrm processing first, and don't know until now that
4474 we have a bad opcode. This necessitates some cleaning up. */
4475 op1out[0] = '\0';
4476 op2out[0] = '\0';
4477 BadOp ();
4478 }
4479 }
4480
4481 static const char *simd_cmp_op[] = {
4482 "eq",
4483 "lt",
4484 "le",
4485 "unord",
4486 "neq",
4487 "nlt",
4488 "nle",
4489 "ord"
4490 };
4491
4492 static void
4493 OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
4494 {
4495 unsigned int cmp_type;
4496
4497 FETCH_DATA (the_info, codep + 1);
4498 obufp = obuf + strlen (obuf);
4499 cmp_type = *codep++ & 0xff;
4500 if (cmp_type < 8)
4501 {
4502 char suffix1 = 'p', suffix2 = 's';
4503 used_prefixes |= (prefixes & PREFIX_REPZ);
4504 if (prefixes & PREFIX_REPZ)
4505 suffix1 = 's';
4506 else
4507 {
4508 used_prefixes |= (prefixes & PREFIX_DATA);
4509 if (prefixes & PREFIX_DATA)
4510 suffix2 = 'd';
4511 else
4512 {
4513 used_prefixes |= (prefixes & PREFIX_REPNZ);
4514 if (prefixes & PREFIX_REPNZ)
4515 suffix1 = 's', suffix2 = 'd';
4516 }
4517 }
4518 sprintf (scratchbuf, "cmp%s%c%c",
4519 simd_cmp_op[cmp_type], suffix1, suffix2);
4520 used_prefixes |= (prefixes & PREFIX_REPZ);
4521 oappend (scratchbuf);
4522 }
4523 else
4524 {
4525 /* We have a bad extension byte. Clean up. */
4526 op1out[0] = '\0';
4527 op2out[0] = '\0';
4528 BadOp ();
4529 }
4530 }
4531
4532 static void
4533 SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
4534 {
4535 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
4536 forms of these instructions. */
4537 if (mod == 3)
4538 {
4539 char *p = obuf + strlen (obuf);
4540 *(p + 1) = '\0';
4541 *p = *(p - 1);
4542 *(p - 1) = *(p - 2);
4543 *(p - 2) = *(p - 3);
4544 *(p - 3) = extrachar;
4545 }
4546 }
4547
4548 static void
4549 PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
4550 {
4551 if (mod == 3 && reg == 1 && rm <= 1)
4552 {
4553 /* Override "sidt". */
4554 size_t olen = strlen (obuf);
4555 char *p = obuf + olen - 4;
4556 const char **names = (address_mode == mode_64bit
4557 ? names64 : names32);
4558
4559 /* We might have a suffix when disassembling with -Msuffix. */
4560 if (*p == 'i')
4561 --p;
4562
4563 /* Remove "addr16/addr32" if we aren't in Intel mode. */
4564 if (!intel_syntax
4565 && (prefixes & PREFIX_ADDR)
4566 && olen >= (4 + 7)
4567 && *(p - 1) == ' '
4568 && strncmp (p - 7, "addr", 4) == 0
4569 && (strncmp (p - 3, "16", 2) == 0
4570 || strncmp (p - 3, "32", 2) == 0))
4571 p -= 7;
4572
4573 if (rm)
4574 {
4575 /* mwait %eax,%ecx */
4576 strcpy (p, "mwait");
4577 if (!intel_syntax)
4578 strcpy (op1out, names[0]);
4579 }
4580 else
4581 {
4582 /* monitor %eax,%ecx,%edx" */
4583 strcpy (p, "monitor");
4584 if (!intel_syntax)
4585 {
4586 const char **op1_names;
4587 if (!(prefixes & PREFIX_ADDR))
4588 op1_names = (address_mode == mode_16bit
4589 ? names16 : names);
4590 else
4591 {
4592 op1_names = (address_mode != mode_32bit
4593 ? names32 : names16);
4594 used_prefixes |= PREFIX_ADDR;
4595 }
4596 strcpy (op1out, op1_names[0]);
4597 strcpy (op3out, names[2]);
4598 }
4599 }
4600 if (!intel_syntax)
4601 {
4602 strcpy (op2out, names[1]);
4603 two_source_ops = 1;
4604 }
4605
4606 codep++;
4607 }
4608 else
4609 OP_M (0, sizeflag);
4610 }
4611
4612 static void
4613 SVME_Fixup (int bytemode, int sizeflag)
4614 {
4615 const char *alt;
4616 char *p;
4617
4618 switch (*codep)
4619 {
4620 case 0xd8:
4621 alt = "vmrun";
4622 break;
4623 case 0xd9:
4624 alt = "vmmcall";
4625 break;
4626 case 0xda:
4627 alt = "vmload";
4628 break;
4629 case 0xdb:
4630 alt = "vmsave";
4631 break;
4632 case 0xdc:
4633 alt = "stgi";
4634 break;
4635 case 0xdd:
4636 alt = "clgi";
4637 break;
4638 case 0xde:
4639 alt = "skinit";
4640 break;
4641 case 0xdf:
4642 alt = "invlpga";
4643 break;
4644 default:
4645 OP_M (bytemode, sizeflag);
4646 return;
4647 }
4648 /* Override "lidt". */
4649 p = obuf + strlen (obuf) - 4;
4650 /* We might have a suffix. */
4651 if (*p == 'i')
4652 --p;
4653 strcpy (p, alt);
4654 if (!(prefixes & PREFIX_ADDR))
4655 {
4656 ++codep;
4657 return;
4658 }
4659 used_prefixes |= PREFIX_ADDR;
4660 switch (*codep++)
4661 {
4662 case 0xdf:
4663 strcpy (op2out, names32[1]);
4664 two_source_ops = 1;
4665 /* Fall through. */
4666 case 0xd8:
4667 case 0xda:
4668 case 0xdb:
4669 *obufp++ = open_char;
4670 if (address_mode == mode_64bit || (sizeflag & AFLAG))
4671 alt = names32[0];
4672 else
4673 alt = names16[0];
4674 strcpy (obufp, alt);
4675 obufp += strlen (alt);
4676 *obufp++ = close_char;
4677 *obufp = '\0';
4678 break;
4679 }
4680 }
4681
4682 static void
4683 INVLPG_Fixup (int bytemode, int sizeflag)
4684 {
4685 const char *alt;
4686
4687 switch (*codep)
4688 {
4689 case 0xf8:
4690 alt = "swapgs";
4691 break;
4692 case 0xf9:
4693 alt = "rdtscp";
4694 break;
4695 default:
4696 OP_M (bytemode, sizeflag);
4697 return;
4698 }
4699 /* Override "invlpg". */
4700 strcpy (obuf + strlen (obuf) - 6, alt);
4701 codep++;
4702 }
4703
4704 static void
4705 BadOp (void)
4706 {
4707 /* Throw away prefixes and 1st. opcode byte. */
4708 codep = insn_codep + 1;
4709 oappend ("(bad)");
4710 }
4711
4712 static void
4713 SEG_Fixup (int extrachar, int sizeflag)
4714 {
4715 if (mod == 3)
4716 {
4717 /* We need to add a proper suffix with
4718
4719 movw %ds,%ax
4720 movl %ds,%eax
4721 movq %ds,%rax
4722 movw %ax,%ds
4723 movl %eax,%ds
4724 movq %rax,%ds
4725 */
4726 const char *suffix;
4727
4728 if (prefixes & PREFIX_DATA)
4729 suffix = "w";
4730 else
4731 {
4732 USED_REX (REX_MODE64);
4733 if (rex & REX_MODE64)
4734 suffix = "q";
4735 else
4736 suffix = "l";
4737 }
4738 strcat (obuf, suffix);
4739 }
4740 else
4741 {
4742 /* We need to fix the suffix for
4743
4744 movw %ds,(%eax)
4745 movw %ds,(%rax)
4746 movw (%eax),%ds
4747 movw (%rax),%ds
4748
4749 Override "mov[l|q]". */
4750 char *p = obuf + strlen (obuf) - 1;
4751
4752 /* We might not have a suffix. */
4753 if (*p == 'v')
4754 ++p;
4755 *p = 'w';
4756 }
4757
4758 OP_E (extrachar, sizeflag);
4759 }
4760
4761 static void
4762 VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
4763 {
4764 if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
4765 {
4766 /* Override "sgdt". */
4767 char *p = obuf + strlen (obuf) - 4;
4768
4769 /* We might have a suffix when disassembling with -Msuffix. */
4770 if (*p == 'g')
4771 --p;
4772
4773 switch (rm)
4774 {
4775 case 1:
4776 strcpy (p, "vmcall");
4777 break;
4778 case 2:
4779 strcpy (p, "vmlaunch");
4780 break;
4781 case 3:
4782 strcpy (p, "vmresume");
4783 break;
4784 case 4:
4785 strcpy (p, "vmxoff");
4786 break;
4787 }
4788
4789 codep++;
4790 }
4791 else
4792 OP_E (0, sizeflag);
4793 }
4794
4795 static void
4796 OP_VMX (int bytemode, int sizeflag)
4797 {
4798 used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
4799 if (prefixes & PREFIX_DATA)
4800 strcpy (obuf, "vmclear");
4801 else if (prefixes & PREFIX_REPZ)
4802 strcpy (obuf, "vmxon");
4803 else
4804 strcpy (obuf, "vmptrld");
4805 OP_E (bytemode, sizeflag);
4806 }
4807
4808 static void
4809 REP_Fixup (int bytemode, int sizeflag)
4810 {
4811 /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
4812 lods and stos. */
4813 size_t ilen = 0;
4814
4815 if (prefixes & PREFIX_REPZ)
4816 switch (*insn_codep)
4817 {
4818 case 0x6e: /* outsb */
4819 case 0x6f: /* outsw/outsl */
4820 case 0xa4: /* movsb */
4821 case 0xa5: /* movsw/movsl/movsq */
4822 if (!intel_syntax)
4823 ilen = 5;
4824 else
4825 ilen = 4;
4826 break;
4827 case 0xaa: /* stosb */
4828 case 0xab: /* stosw/stosl/stosq */
4829 case 0xac: /* lodsb */
4830 case 0xad: /* lodsw/lodsl/lodsq */
4831 if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
4832 ilen = 5;
4833 else
4834 ilen = 4;
4835 break;
4836 case 0x6c: /* insb */
4837 case 0x6d: /* insl/insw */
4838 if (!intel_syntax)
4839 ilen = 4;
4840 else
4841 ilen = 3;
4842 break;
4843 default:
4844 abort ();
4845 break;
4846 }
4847
4848 if (ilen != 0)
4849 {
4850 size_t olen;
4851 char *p;
4852
4853 olen = strlen (obuf);
4854 p = obuf + olen - ilen - 1 - 4;
4855 /* Handle "repz [addr16|addr32]". */
4856 if ((prefixes & PREFIX_ADDR))
4857 p -= 1 + 6;
4858
4859 memmove (p + 3, p + 4, olen - (p + 3 - obuf));
4860 }
4861
4862 switch (bytemode)
4863 {
4864 case al_reg:
4865 case eAX_reg:
4866 case indir_dx_reg:
4867 OP_IMREG (bytemode, sizeflag);
4868 break;
4869 case eDI_reg:
4870 OP_ESreg (bytemode, sizeflag);
4871 break;
4872 case eSI_reg:
4873 OP_DSreg (bytemode, sizeflag);
4874 break;
4875 default:
4876 abort ();
4877 break;
4878 }
4879 }
GDB Binutils - Deliverables
This page took 0.141041 seconds and 5 git commands to generate.