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