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