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