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