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