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