3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/dbg/i386/i386-dis.c
6 * PURPOSE: No purpose listed.
8 * PROGRAMMERS: No programmer listed.
13 /* ReactOS compatibility stuff. */
16 typedef enum bfd_flavour
18 bfd_target_unknown_flavour
,
20 typedef enum bfd_architecture
24 typedef unsigned int bfd_vma
;
25 typedef unsigned char bfd_byte
;
26 enum bfd_endian
{ BFD_ENDIAN_BIG
, BIG_ENDIAN_LITTLE
, BFD_ENDIAN_UNKNOWN
};
29 typedef signed int bfd_signed_vma
;
31 #define bfd_mach_x86_64_intel_syntax 0
32 #define bfd_mach_x86_64 1
33 #define bfd_mach_i386_i386_intel_syntax 2
34 #define bfd_mach_i386_i386 3
35 #define bfd_mach_i386_i8086 4
36 #define abort() __asm__("int $3\n\t")
38 #define ATTRIBUTE_UNUSED
39 extern char* strcpy(char *dest
, const char *src
);
40 extern unsigned int strlen(const char *s
);
41 extern int sprintf(char *str
, const char *format
, ...);
42 extern int vsprintf(char *buf
, const char *format
, va_list ap
);
43 extern void* memcpy(void *dest
, const void *src
, unsigned int length
);
44 extern void DbgPrint(const char *format
, ...);
45 #define sprintf_vma(BUF, VMA) sprintf(BUF, "0x%X", VMA)
46 #define _setjmp setjmp
47 extern unsigned int KdbSymPrintAddress(void* address
);
48 struct disassemble_info
;
50 #define KdbpSafeReadMemory(dst, src, size) MmSafeCopyFromUser(dst, src, size)
51 extern long MmSafeCopyFromUser(void *Dest
, void *Src
, unsigned long NumberOfBytes
);
55 print_insn_i386_att (bfd_vma pc
, struct disassemble_info
*info
);
58 KdbPrintDisasm(void* Ignored
, const char* fmt
, ...)
61 static char buffer
[256];
65 ret
= vsprintf(buffer
, fmt
, ap
);
72 KdbNopPrintDisasm(void* Ignored
, const char* fmt
, ...)
78 KdbReadMemory(unsigned int Addr
, unsigned char* Data
, unsigned int Length
,
79 struct disassemble_info
* Ignored
)
81 return KdbpSafeReadMemory(Data
, (void *)Addr
, Length
); /* 0 means no error */
85 KdbMemoryError(int Status
, unsigned int Addr
,
86 struct disassemble_info
* Ignored
)
91 KdbPrintAddressInCode(unsigned int Addr
, struct disassemble_info
* Ignored
)
93 if (!KdbSymPrintAddress((void*)Addr
))
95 DbgPrint("<0x%X>", Addr
);
100 KdbNopPrintAddress(unsigned int Addr
, struct disassemble_info
* Ignored
)
107 KdbGetInstLength(unsigned int Address
)
109 disassemble_info info
;
111 info
.fprintf_func
= KdbNopPrintDisasm
;
113 info
.application_data
= NULL
;
114 info
.flavour
= bfd_target_unknown_flavour
;
115 info
.arch
= bfd_arch_i386
;
116 info
.mach
= bfd_mach_i386_i386
;
119 info
.read_memory_func
= KdbReadMemory
;
120 info
.memory_error_func
= KdbMemoryError
;
121 info
.print_address_func
= KdbNopPrintAddress
;
122 info
.symbol_at_address_func
= NULL
;
124 info
.buffer_vma
= info
.buffer_length
= 0;
125 info
.bytes_per_chunk
= 0;
126 info
.display_endian
= BIG_ENDIAN_LITTLE
;
127 info
.disassembler_options
= NULL
;
129 return(print_insn_i386_att(Address
, &info
));
133 KdbDisassemble(unsigned int Address
)
135 disassemble_info info
;
137 info
.fprintf_func
= KdbPrintDisasm
;
139 info
.application_data
= NULL
;
140 info
.flavour
= bfd_target_unknown_flavour
;
141 info
.arch
= bfd_arch_i386
;
142 info
.mach
= bfd_mach_i386_i386
;
145 info
.read_memory_func
= KdbReadMemory
;
146 info
.memory_error_func
= KdbMemoryError
;
147 info
.print_address_func
= KdbPrintAddressInCode
;
148 info
.symbol_at_address_func
= NULL
;
150 info
.buffer_vma
= info
.buffer_length
= 0;
151 info
.bytes_per_chunk
= 0;
152 info
.display_endian
= BIG_ENDIAN_LITTLE
;
153 info
.disassembler_options
= NULL
;
155 return(print_insn_i386_att(Address
, &info
));
158 /* Print i386 instructions for GDB, the GNU debugger.
159 Copyright 1988, 1989, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
161 Free Software Foundation, Inc.
163 This file is part of GDB.
165 This program is free software; you can redistribute it and/or modify
166 it under the terms of the GNU General Public License as published by
167 the Free Software Foundation; either version 2 of the License, or
168 (at your option) any later version.
170 This program is distributed in the hope that it will be useful,
171 but WITHOUT ANY WARRANTY; without even the implied warranty of
172 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
173 GNU General Public License for more details.
175 You should have received a copy of the GNU General Public License
176 along with this program; if not, write to the Free Software
177 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
180 * 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu)
182 * modified by John Hassey (hassey@dg-rtp.dg.com)
183 * x86-64 support added by Jan Hubicka (jh@suse.cz)
187 * The main tables describing the instructions is essentially a copy
188 * of the "Opcode Map" chapter (Appendix A) of the Intel 80386
189 * Programmers Manual. Usually, there is a capital letter, followed
190 * by a small letter. The capital letter tell the addressing mode,
191 * and the small letter tells about the operand size. Refer to
192 * the Intel manual for details.
205 #ifndef UNIXWARE_COMPAT
206 /* Set non-zero for broken, compatible instructions. Set to zero for
207 non-broken opcodes. */
208 #define UNIXWARE_COMPAT 1
211 static int fetch_data
PARAMS ((struct disassemble_info
*, bfd_byte
*));
212 static void ckprefix
PARAMS ((void));
213 static const char *prefix_name
PARAMS ((int, int));
214 static int print_insn
PARAMS ((bfd_vma
, disassemble_info
*));
215 static void dofloat
PARAMS ((int));
216 static void OP_ST
PARAMS ((int, int));
217 static void OP_STi
PARAMS ((int, int));
218 static int putop
PARAMS ((const char *, int));
219 static void oappend
PARAMS ((const char *));
220 static void append_seg
PARAMS ((void));
221 static void OP_indirE
PARAMS ((int, int));
222 static void print_operand_value
PARAMS ((char *, int, bfd_vma
));
223 static void OP_E
PARAMS ((int, int));
224 static void OP_G
PARAMS ((int, int));
225 static bfd_vma get64
PARAMS ((void));
226 static bfd_signed_vma get32
PARAMS ((void));
227 static bfd_signed_vma get32s
PARAMS ((void));
228 static int get16
PARAMS ((void));
229 static void set_op
PARAMS ((bfd_vma
, int));
230 static void OP_REG
PARAMS ((int, int));
231 static void OP_IMREG
PARAMS ((int, int));
232 static void OP_I
PARAMS ((int, int));
233 static void OP_I64
PARAMS ((int, int));
234 static void OP_sI
PARAMS ((int, int));
235 static void OP_J
PARAMS ((int, int));
236 static void OP_SEG
PARAMS ((int, int));
237 static void OP_DIR
PARAMS ((int, int));
238 static void OP_OFF
PARAMS ((int, int));
239 static void OP_OFF64
PARAMS ((int, int));
240 static void ptr_reg
PARAMS ((int, int));
241 static void OP_ESreg
PARAMS ((int, int));
242 static void OP_DSreg
PARAMS ((int, int));
243 static void OP_C
PARAMS ((int, int));
244 static void OP_D
PARAMS ((int, int));
245 static void OP_T
PARAMS ((int, int));
246 static void OP_Rd
PARAMS ((int, int));
247 static void OP_MMX
PARAMS ((int, int));
248 static void OP_XMM
PARAMS ((int, int));
249 static void OP_EM
PARAMS ((int, int));
250 static void OP_EX
PARAMS ((int, int));
251 static void OP_MS
PARAMS ((int, int));
252 static void OP_XS
PARAMS ((int, int));
253 static void OP_3DNowSuffix
PARAMS ((int, int));
254 static void OP_SIMD_Suffix
PARAMS ((int, int));
255 static void SIMD_Fixup
PARAMS ((int, int));
256 static void BadOp
PARAMS ((void));
259 /* Points to first byte not fetched. */
260 bfd_byte
*max_fetched
;
261 bfd_byte the_buffer
[MAXLEN
];
267 /* The opcode for the fwait instruction, which we treat as a prefix
269 #define FWAIT_OPCODE (0x9b)
271 /* Set to 1 for 64bit mode disassembly. */
272 static int mode_64bit
;
274 /* Flags for the prefixes for the current instruction. See below. */
277 /* REX prefix the current instruction. See below. */
279 /* Bits of REX we've already used. */
285 /* Mark parts used in the REX prefix. When we are testing for
286 empty prefix (for 8bit register REX extension), just mask it
287 out. Otherwise test for REX bit is excuse for existence of REX
288 only in case value is nonzero. */
289 #define USED_REX(value) \
292 rex_used |= (rex & value) ? (value) | 0x40 : 0; \
297 /* Flags for prefixes which we somehow handled when printing the
298 current instruction. */
299 static int used_prefixes
;
301 /* Flags stored in PREFIXES. */
302 #define PREFIX_REPZ 1
303 #define PREFIX_REPNZ 2
304 #define PREFIX_LOCK 4
306 #define PREFIX_SS 0x10
307 #define PREFIX_DS 0x20
308 #define PREFIX_ES 0x40
309 #define PREFIX_FS 0x80
310 #define PREFIX_GS 0x100
311 #define PREFIX_DATA 0x200
312 #define PREFIX_ADDR 0x400
313 #define PREFIX_FWAIT 0x800
315 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
316 to ADDR (exclusive) are valid. Returns 1 for success, longjmps
318 #define FETCH_DATA(info, addr) \
319 ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
320 ? 1 : fetch_data ((info), (addr)))
323 fetch_data (info
, addr
)
324 struct disassemble_info
*info
;
328 struct dis_private
*priv
= (struct dis_private
*) info
->private_data
;
329 bfd_vma start
= priv
->insn_start
+ (priv
->max_fetched
- priv
->the_buffer
);
331 status
= (*info
->read_memory_func
) (start
,
333 addr
- priv
->max_fetched
,
337 /* If we did manage to read at least one byte, then
338 print_insn_i386 will do something sensible. Otherwise, print
339 an error. We do that here because this is where we know
341 if (priv
->max_fetched
== priv
->the_buffer
)
342 (*info
->memory_error_func
) (status
, start
, info
);
343 longjmp (priv
->bailout
, 1);
346 priv
->max_fetched
= addr
;
352 #define Eb OP_E, b_mode
353 #define Ev OP_E, v_mode
354 #define Ed OP_E, d_mode
355 #define indirEb OP_indirE, b_mode
356 #define indirEv OP_indirE, v_mode
357 #define Ew OP_E, w_mode
358 #define Ma OP_E, v_mode
359 #define M OP_E, 0 /* lea, lgdt, etc. */
360 #define Mp OP_E, 0 /* 32 or 48 bit memory operand for LDS, LES etc */
361 #define Gb OP_G, b_mode
362 #define Gv OP_G, v_mode
363 #define Gd OP_G, d_mode
364 #define Gw OP_G, w_mode
365 #define Rd OP_Rd, d_mode
366 #define Rm OP_Rd, m_mode
367 #define Ib OP_I, b_mode
368 #define sIb OP_sI, b_mode /* sign extened byte */
369 #define Iv OP_I, v_mode
370 #define Iq OP_I, q_mode
371 #define Iv64 OP_I64, v_mode
372 #define Iw OP_I, w_mode
373 #define Jb OP_J, b_mode
374 #define Jv OP_J, v_mode
375 #define Cm OP_C, m_mode
376 #define Dm OP_D, m_mode
377 #define Td OP_T, d_mode
379 #define RMeAX OP_REG, eAX_reg
380 #define RMeBX OP_REG, eBX_reg
381 #define RMeCX OP_REG, eCX_reg
382 #define RMeDX OP_REG, eDX_reg
383 #define RMeSP OP_REG, eSP_reg
384 #define RMeBP OP_REG, eBP_reg
385 #define RMeSI OP_REG, eSI_reg
386 #define RMeDI OP_REG, eDI_reg
387 #define RMrAX OP_REG, rAX_reg
388 #define RMrBX OP_REG, rBX_reg
389 #define RMrCX OP_REG, rCX_reg
390 #define RMrDX OP_REG, rDX_reg
391 #define RMrSP OP_REG, rSP_reg
392 #define RMrBP OP_REG, rBP_reg
393 #define RMrSI OP_REG, rSI_reg
394 #define RMrDI OP_REG, rDI_reg
395 #define RMAL OP_REG, al_reg
396 #define RMAL OP_REG, al_reg
397 #define RMCL OP_REG, cl_reg
398 #define RMDL OP_REG, dl_reg
399 #define RMBL OP_REG, bl_reg
400 #define RMAH OP_REG, ah_reg
401 #define RMCH OP_REG, ch_reg
402 #define RMDH OP_REG, dh_reg
403 #define RMBH OP_REG, bh_reg
404 #define RMAX OP_REG, ax_reg
405 #define RMDX OP_REG, dx_reg
407 #define eAX OP_IMREG, eAX_reg
408 #define eBX OP_IMREG, eBX_reg
409 #define eCX OP_IMREG, eCX_reg
410 #define eDX OP_IMREG, eDX_reg
411 #define eSP OP_IMREG, eSP_reg
412 #define eBP OP_IMREG, eBP_reg
413 #define eSI OP_IMREG, eSI_reg
414 #define eDI OP_IMREG, eDI_reg
415 #define AL OP_IMREG, al_reg
416 #define AL OP_IMREG, al_reg
417 #define CL OP_IMREG, cl_reg
418 #define DL OP_IMREG, dl_reg
419 #define BL OP_IMREG, bl_reg
420 #define AH OP_IMREG, ah_reg
421 #define CH OP_IMREG, ch_reg
422 #define DH OP_IMREG, dh_reg
423 #define BH OP_IMREG, bh_reg
424 #define AX OP_IMREG, ax_reg
425 #define DX OP_IMREG, dx_reg
426 #define indirDX OP_IMREG, indir_dx_reg
428 #define Sw OP_SEG, w_mode
430 #define Ob OP_OFF, b_mode
431 #define Ob64 OP_OFF64, b_mode
432 #define Ov OP_OFF, v_mode
433 #define Ov64 OP_OFF64, v_mode
434 #define Xb OP_DSreg, eSI_reg
435 #define Xv OP_DSreg, eSI_reg
436 #define Yb OP_ESreg, eDI_reg
437 #define Yv OP_ESreg, eDI_reg
438 #define DSBX OP_DSreg, eBX_reg
440 #define es OP_REG, es_reg
441 #define ss OP_REG, ss_reg
442 #define cs OP_REG, cs_reg
443 #define ds OP_REG, ds_reg
444 #define fs OP_REG, fs_reg
445 #define gs OP_REG, gs_reg
449 #define EM OP_EM, v_mode
450 #define EX OP_EX, v_mode
451 #define MS OP_MS, v_mode
452 #define XS OP_XS, v_mode
454 #define OPSUF OP_3DNowSuffix, 0
455 #define OPSIMD OP_SIMD_Suffix, 0
457 #define cond_jump_flag NULL, cond_jump_mode
458 #define loop_jcxz_flag NULL, loop_jcxz_mode
460 /* bits in sizeflag */
461 #define SUFFIX_ALWAYS 4
465 #define b_mode 1 /* byte operand */
466 #define v_mode 2 /* operand size depends on prefixes */
467 #define w_mode 3 /* word operand */
468 #define d_mode 4 /* double word operand */
469 #define q_mode 5 /* quad word operand */
471 #define m_mode 7 /* d_mode in 32bit, q_mode in 64bit mode. */
472 #define cond_jump_mode 8
473 #define loop_jcxz_mode 9
518 #define indir_dx_reg 150
522 #define USE_PREFIX_USER_TABLE 3
523 #define X86_64_SPECIAL 4
525 #define FLOAT NULL, NULL, FLOATCODE, NULL, 0, NULL, 0
527 #define GRP1b NULL, NULL, USE_GROUPS, NULL, 0, NULL, 0
528 #define GRP1S NULL, NULL, USE_GROUPS, NULL, 1, NULL, 0
529 #define GRP1Ss NULL, NULL, USE_GROUPS, NULL, 2, NULL, 0
530 #define GRP2b NULL, NULL, USE_GROUPS, NULL, 3, NULL, 0
531 #define GRP2S NULL, NULL, USE_GROUPS, NULL, 4, NULL, 0
532 #define GRP2b_one NULL, NULL, USE_GROUPS, NULL, 5, NULL, 0
533 #define GRP2S_one NULL, NULL, USE_GROUPS, NULL, 6, NULL, 0
534 #define GRP2b_cl NULL, NULL, USE_GROUPS, NULL, 7, NULL, 0
535 #define GRP2S_cl NULL, NULL, USE_GROUPS, NULL, 8, NULL, 0
536 #define GRP3b NULL, NULL, USE_GROUPS, NULL, 9, NULL, 0
537 #define GRP3S NULL, NULL, USE_GROUPS, NULL, 10, NULL, 0
538 #define GRP4 NULL, NULL, USE_GROUPS, NULL, 11, NULL, 0
539 #define GRP5 NULL, NULL, USE_GROUPS, NULL, 12, NULL, 0
540 #define GRP6 NULL, NULL, USE_GROUPS, NULL, 13, NULL, 0
541 #define GRP7 NULL, NULL, USE_GROUPS, NULL, 14, NULL, 0
542 #define GRP8 NULL, NULL, USE_GROUPS, NULL, 15, NULL, 0
543 #define GRP9 NULL, NULL, USE_GROUPS, NULL, 16, NULL, 0
544 #define GRP10 NULL, NULL, USE_GROUPS, NULL, 17, NULL, 0
545 #define GRP11 NULL, NULL, USE_GROUPS, NULL, 18, NULL, 0
546 #define GRP12 NULL, NULL, USE_GROUPS, NULL, 19, NULL, 0
547 #define GRP13 NULL, NULL, USE_GROUPS, NULL, 20, NULL, 0
548 #define GRP14 NULL, NULL, USE_GROUPS, NULL, 21, NULL, 0
549 #define GRPAMD NULL, NULL, USE_GROUPS, NULL, 22, NULL, 0
551 #define PREGRP0 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 0, NULL, 0
552 #define PREGRP1 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 1, NULL, 0
553 #define PREGRP2 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 2, NULL, 0
554 #define PREGRP3 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 3, NULL, 0
555 #define PREGRP4 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 4, NULL, 0
556 #define PREGRP5 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 5, NULL, 0
557 #define PREGRP6 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 6, NULL, 0
558 #define PREGRP7 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 7, NULL, 0
559 #define PREGRP8 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 8, NULL, 0
560 #define PREGRP9 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 9, NULL, 0
561 #define PREGRP10 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 10, NULL, 0
562 #define PREGRP11 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 11, NULL, 0
563 #define PREGRP12 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 12, NULL, 0
564 #define PREGRP13 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 13, NULL, 0
565 #define PREGRP14 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 14, NULL, 0
566 #define PREGRP15 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 15, NULL, 0
567 #define PREGRP16 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 16, NULL, 0
568 #define PREGRP17 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 17, NULL, 0
569 #define PREGRP18 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 18, NULL, 0
570 #define PREGRP19 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 19, NULL, 0
571 #define PREGRP20 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 20, NULL, 0
572 #define PREGRP21 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 21, NULL, 0
573 #define PREGRP22 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 22, NULL, 0
574 #define PREGRP23 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 23, NULL, 0
575 #define PREGRP24 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 24, NULL, 0
576 #define PREGRP25 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 25, NULL, 0
577 #define PREGRP26 NULL, NULL, USE_PREFIX_USER_TABLE, NULL, 26, NULL, 0
579 #define X86_64_0 NULL, NULL, X86_64_SPECIAL, NULL, 0, NULL, 0
581 typedef void (*op_rtn
) PARAMS ((int bytemode
, int sizeflag
));
593 /* Upper case letters in the instruction names here are macros.
594 'A' => print 'b' if no register operands or suffix_always is true
595 'B' => print 'b' if suffix_always is true
596 'E' => print 'e' if 32-bit form of jcxz
597 'F' => print 'w' or 'l' depending on address size prefix (loop insns)
598 'H' => print ",pt" or ",pn" branch hint
599 'L' => print 'l' if suffix_always is true
600 'N' => print 'n' if instruction has no wait "prefix"
601 'O' => print 'd', or 'o'
602 'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
603 . or suffix_always is true. print 'q' if rex prefix is present.
604 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
606 'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
607 'S' => print 'w', 'l' or 'q' if suffix_always is true
608 'T' => print 'q' in 64bit mode and behave as 'P' otherwise
609 'U' => print 'q' in 64bit mode and behave as 'Q' otherwise
610 'X' => print 's', 'd' depending on data16 prefix (for XMM)
611 'W' => print 'b' or 'w' ("w" or "de" in intel mode)
612 'Y' => 'q' if instruction has an REX 64bit overwrite prefix
614 Many of the above letters print nothing in Intel mode. See "putop"
617 Braces '{' and '}', and vertical bars '|', indicate alternative
618 mnemonic strings for AT&T, Intel, X86_64 AT&T, and X86_64 Intel
619 modes. In cases where there are only two alternatives, the X86_64
620 instruction is reserved, and "(bad)" is printed.
623 static const struct dis386 dis386
[] = {
625 { "addB", Eb
, Gb
, XX
},
626 { "addS", Ev
, Gv
, XX
},
627 { "addB", Gb
, Eb
, XX
},
628 { "addS", Gv
, Ev
, XX
},
629 { "addB", AL
, Ib
, XX
},
630 { "addS", eAX
, Iv
, XX
},
631 { "push{T|}", es
, XX
, XX
},
632 { "pop{T|}", es
, XX
, XX
},
634 { "orB", Eb
, Gb
, XX
},
635 { "orS", Ev
, Gv
, XX
},
636 { "orB", Gb
, Eb
, XX
},
637 { "orS", Gv
, Ev
, XX
},
638 { "orB", AL
, Ib
, XX
},
639 { "orS", eAX
, Iv
, XX
},
640 { "push{T|}", cs
, XX
, XX
},
641 { "(bad)", XX
, XX
, XX
}, /* 0x0f extended opcode escape */
643 { "adcB", Eb
, Gb
, XX
},
644 { "adcS", Ev
, Gv
, XX
},
645 { "adcB", Gb
, Eb
, XX
},
646 { "adcS", Gv
, Ev
, XX
},
647 { "adcB", AL
, Ib
, XX
},
648 { "adcS", eAX
, Iv
, XX
},
649 { "push{T|}", ss
, XX
, XX
},
650 { "popT|}", ss
, XX
, XX
},
652 { "sbbB", Eb
, Gb
, XX
},
653 { "sbbS", Ev
, Gv
, XX
},
654 { "sbbB", Gb
, Eb
, XX
},
655 { "sbbS", Gv
, Ev
, XX
},
656 { "sbbB", AL
, Ib
, XX
},
657 { "sbbS", eAX
, Iv
, XX
},
658 { "push{T|}", ds
, XX
, XX
},
659 { "pop{T|}", ds
, XX
, XX
},
661 { "andB", Eb
, Gb
, XX
},
662 { "andS", Ev
, Gv
, XX
},
663 { "andB", Gb
, Eb
, XX
},
664 { "andS", Gv
, Ev
, XX
},
665 { "andB", AL
, Ib
, XX
},
666 { "andS", eAX
, Iv
, XX
},
667 { "(bad)", XX
, XX
, XX
}, /* SEG ES prefix */
668 { "daa{|}", XX
, XX
, XX
},
670 { "subB", Eb
, Gb
, XX
},
671 { "subS", Ev
, Gv
, XX
},
672 { "subB", Gb
, Eb
, XX
},
673 { "subS", Gv
, Ev
, XX
},
674 { "subB", AL
, Ib
, XX
},
675 { "subS", eAX
, Iv
, XX
},
676 { "(bad)", XX
, XX
, XX
}, /* SEG CS prefix */
677 { "das{|}", XX
, XX
, XX
},
679 { "xorB", Eb
, Gb
, XX
},
680 { "xorS", Ev
, Gv
, XX
},
681 { "xorB", Gb
, Eb
, XX
},
682 { "xorS", Gv
, Ev
, XX
},
683 { "xorB", AL
, Ib
, XX
},
684 { "xorS", eAX
, Iv
, XX
},
685 { "(bad)", XX
, XX
, XX
}, /* SEG SS prefix */
686 { "aaa{|}", XX
, XX
, XX
},
688 { "cmpB", Eb
, Gb
, XX
},
689 { "cmpS", Ev
, Gv
, XX
},
690 { "cmpB", Gb
, Eb
, XX
},
691 { "cmpS", Gv
, Ev
, XX
},
692 { "cmpB", AL
, Ib
, XX
},
693 { "cmpS", eAX
, Iv
, XX
},
694 { "(bad)", XX
, XX
, XX
}, /* SEG DS prefix */
695 { "aas{|}", XX
, XX
, XX
},
697 { "inc{S|}", RMeAX
, XX
, XX
},
698 { "inc{S|}", RMeCX
, XX
, XX
},
699 { "inc{S|}", RMeDX
, XX
, XX
},
700 { "inc{S|}", RMeBX
, XX
, XX
},
701 { "inc{S|}", RMeSP
, XX
, XX
},
702 { "inc{S|}", RMeBP
, XX
, XX
},
703 { "inc{S|}", RMeSI
, XX
, XX
},
704 { "inc{S|}", RMeDI
, XX
, XX
},
706 { "dec{S|}", RMeAX
, XX
, XX
},
707 { "dec{S|}", RMeCX
, XX
, XX
},
708 { "dec{S|}", RMeDX
, XX
, XX
},
709 { "dec{S|}", RMeBX
, XX
, XX
},
710 { "dec{S|}", RMeSP
, XX
, XX
},
711 { "dec{S|}", RMeBP
, XX
, XX
},
712 { "dec{S|}", RMeSI
, XX
, XX
},
713 { "dec{S|}", RMeDI
, XX
, XX
},
715 { "pushS", RMrAX
, XX
, XX
},
716 { "pushS", RMrCX
, XX
, XX
},
717 { "pushS", RMrDX
, XX
, XX
},
718 { "pushS", RMrBX
, XX
, XX
},
719 { "pushS", RMrSP
, XX
, XX
},
720 { "pushS", RMrBP
, XX
, XX
},
721 { "pushS", RMrSI
, XX
, XX
},
722 { "pushS", RMrDI
, XX
, XX
},
724 { "popS", RMrAX
, XX
, XX
},
725 { "popS", RMrCX
, XX
, XX
},
726 { "popS", RMrDX
, XX
, XX
},
727 { "popS", RMrBX
, XX
, XX
},
728 { "popS", RMrSP
, XX
, XX
},
729 { "popS", RMrBP
, XX
, XX
},
730 { "popS", RMrSI
, XX
, XX
},
731 { "popS", RMrDI
, XX
, XX
},
733 { "pusha{P|}", XX
, XX
, XX
},
734 { "popa{P|}", XX
, XX
, XX
},
735 { "bound{S|}", Gv
, Ma
, XX
},
737 { "(bad)", XX
, XX
, XX
}, /* seg fs */
738 { "(bad)", XX
, XX
, XX
}, /* seg gs */
739 { "(bad)", XX
, XX
, XX
}, /* op size prefix */
740 { "(bad)", XX
, XX
, XX
}, /* adr size prefix */
742 { "pushT", Iq
, XX
, XX
},
743 { "imulS", Gv
, Ev
, Iv
},
744 { "pushT", sIb
, XX
, XX
},
745 { "imulS", Gv
, Ev
, sIb
},
746 { "ins{b||b|}", Yb
, indirDX
, XX
},
747 { "ins{R||R|}", Yv
, indirDX
, XX
},
748 { "outs{b||b|}", indirDX
, Xb
, XX
},
749 { "outs{R||R|}", indirDX
, Xv
, XX
},
751 { "joH", Jb
, XX
, cond_jump_flag
},
752 { "jnoH", Jb
, XX
, cond_jump_flag
},
753 { "jbH", Jb
, XX
, cond_jump_flag
},
754 { "jaeH", Jb
, XX
, cond_jump_flag
},
755 { "jeH", Jb
, XX
, cond_jump_flag
},
756 { "jneH", Jb
, XX
, cond_jump_flag
},
757 { "jbeH", Jb
, XX
, cond_jump_flag
},
758 { "jaH", Jb
, XX
, cond_jump_flag
},
760 { "jsH", Jb
, XX
, cond_jump_flag
},
761 { "jnsH", Jb
, XX
, cond_jump_flag
},
762 { "jpH", Jb
, XX
, cond_jump_flag
},
763 { "jnpH", Jb
, XX
, cond_jump_flag
},
764 { "jlH", Jb
, XX
, cond_jump_flag
},
765 { "jgeH", Jb
, XX
, cond_jump_flag
},
766 { "jleH", Jb
, XX
, cond_jump_flag
},
767 { "jgH", Jb
, XX
, cond_jump_flag
},
771 { "(bad)", XX
, XX
, XX
},
773 { "testB", Eb
, Gb
, XX
},
774 { "testS", Ev
, Gv
, XX
},
775 { "xchgB", Eb
, Gb
, XX
},
776 { "xchgS", Ev
, Gv
, XX
},
778 { "movB", Eb
, Gb
, XX
},
779 { "movS", Ev
, Gv
, XX
},
780 { "movB", Gb
, Eb
, XX
},
781 { "movS", Gv
, Ev
, XX
},
782 { "movQ", Ev
, Sw
, XX
},
783 { "leaS", Gv
, M
, XX
},
784 { "movQ", Sw
, Ev
, XX
},
785 { "popU", Ev
, XX
, XX
},
787 { "nop", XX
, XX
, XX
},
788 /* FIXME: NOP with REPz prefix is called PAUSE. */
789 { "xchgS", RMeCX
, eAX
, XX
},
790 { "xchgS", RMeDX
, eAX
, XX
},
791 { "xchgS", RMeBX
, eAX
, XX
},
792 { "xchgS", RMeSP
, eAX
, XX
},
793 { "xchgS", RMeBP
, eAX
, XX
},
794 { "xchgS", RMeSI
, eAX
, XX
},
795 { "xchgS", RMeDI
, eAX
, XX
},
797 { "cW{tR||tR|}", XX
, XX
, XX
},
798 { "cR{tO||tO|}", XX
, XX
, XX
},
799 { "lcall{T|}", Ap
, XX
, XX
},
800 { "(bad)", XX
, XX
, XX
}, /* fwait */
801 { "pushfT", XX
, XX
, XX
},
802 { "popfT", XX
, XX
, XX
},
803 { "sahf{|}", XX
, XX
, XX
},
804 { "lahf{|}", XX
, XX
, XX
},
806 { "movB", AL
, Ob64
, XX
},
807 { "movS", eAX
, Ov64
, XX
},
808 { "movB", Ob64
, AL
, XX
},
809 { "movS", Ov64
, eAX
, XX
},
810 { "movs{b||b|}", Yb
, Xb
, XX
},
811 { "movs{R||R|}", Yv
, Xv
, XX
},
812 { "cmps{b||b|}", Xb
, Yb
, XX
},
813 { "cmps{R||R|}", Xv
, Yv
, XX
},
815 { "testB", AL
, Ib
, XX
},
816 { "testS", eAX
, Iv
, XX
},
817 { "stosB", Yb
, AL
, XX
},
818 { "stosS", Yv
, eAX
, XX
},
819 { "lodsB", AL
, Xb
, XX
},
820 { "lodsS", eAX
, Xv
, XX
},
821 { "scasB", AL
, Yb
, XX
},
822 { "scasS", eAX
, Yv
, XX
},
824 { "movB", RMAL
, Ib
, XX
},
825 { "movB", RMCL
, Ib
, XX
},
826 { "movB", RMDL
, Ib
, XX
},
827 { "movB", RMBL
, Ib
, XX
},
828 { "movB", RMAH
, Ib
, XX
},
829 { "movB", RMCH
, Ib
, XX
},
830 { "movB", RMDH
, Ib
, XX
},
831 { "movB", RMBH
, Ib
, XX
},
833 { "movS", RMeAX
, Iv64
, XX
},
834 { "movS", RMeCX
, Iv64
, XX
},
835 { "movS", RMeDX
, Iv64
, XX
},
836 { "movS", RMeBX
, Iv64
, XX
},
837 { "movS", RMeSP
, Iv64
, XX
},
838 { "movS", RMeBP
, Iv64
, XX
},
839 { "movS", RMeSI
, Iv64
, XX
},
840 { "movS", RMeDI
, Iv64
, XX
},
844 { "retT", Iw
, XX
, XX
},
845 { "retT", XX
, XX
, XX
},
846 { "les{S|}", Gv
, Mp
, XX
},
847 { "ldsS", Gv
, Mp
, XX
},
848 { "movA", Eb
, Ib
, XX
},
849 { "movQ", Ev
, Iv
, XX
},
851 { "enterT", Iw
, Ib
, XX
},
852 { "leaveT", XX
, XX
, XX
},
853 { "lretP", Iw
, XX
, XX
},
854 { "lretP", XX
, XX
, XX
},
855 { "int3", XX
, XX
, XX
},
856 { "int", Ib
, XX
, XX
},
857 { "into{|}", XX
, XX
, XX
},
858 { "iretP", XX
, XX
, XX
},
864 { "aam{|}", sIb
, XX
, XX
},
865 { "aad{|}", sIb
, XX
, XX
},
866 { "(bad)", XX
, XX
, XX
},
867 { "xlat", DSBX
, XX
, XX
},
878 { "loopneFH", Jb
, XX
, loop_jcxz_flag
},
879 { "loopeFH", Jb
, XX
, loop_jcxz_flag
},
880 { "loopFH", Jb
, XX
, loop_jcxz_flag
},
881 { "jEcxzH", Jb
, XX
, loop_jcxz_flag
},
882 { "inB", AL
, Ib
, XX
},
883 { "inS", eAX
, Ib
, XX
},
884 { "outB", Ib
, AL
, XX
},
885 { "outS", Ib
, eAX
, XX
},
887 { "callT", Jv
, XX
, XX
},
888 { "jmpT", Jv
, XX
, XX
},
889 { "ljmp{T|}", Ap
, XX
, XX
},
890 { "jmp", Jb
, XX
, XX
},
891 { "inB", AL
, indirDX
, XX
},
892 { "inS", eAX
, indirDX
, XX
},
893 { "outB", indirDX
, AL
, XX
},
894 { "outS", indirDX
, eAX
, XX
},
896 { "(bad)", XX
, XX
, XX
}, /* lock prefix */
897 { "(bad)", XX
, XX
, XX
},
898 { "(bad)", XX
, XX
, XX
}, /* repne */
899 { "(bad)", XX
, XX
, XX
}, /* repz */
900 { "hlt", XX
, XX
, XX
},
901 { "cmc", XX
, XX
, XX
},
905 { "clc", XX
, XX
, XX
},
906 { "stc", XX
, XX
, XX
},
907 { "cli", XX
, XX
, XX
},
908 { "sti", XX
, XX
, XX
},
909 { "cld", XX
, XX
, XX
},
910 { "std", XX
, XX
, XX
},
915 static const struct dis386 dis386_twobyte
[] = {
919 { "larS", Gv
, Ew
, XX
},
920 { "lslS", Gv
, Ew
, XX
},
921 { "(bad)", XX
, XX
, XX
},
922 { "syscall", XX
, XX
, XX
},
923 { "clts", XX
, XX
, XX
},
924 { "sysretP", XX
, XX
, XX
},
926 { "invd", XX
, XX
, XX
},
927 { "wbinvd", XX
, XX
, XX
},
928 { "(bad)", XX
, XX
, XX
},
929 { "ud2a", XX
, XX
, XX
},
930 { "(bad)", XX
, XX
, XX
},
932 { "femms", XX
, XX
, XX
},
933 { "", MX
, EM
, OPSUF
}, /* See OP_3DNowSuffix. */
937 { "movlpX", XM
, EX
, SIMD_Fixup
, 'h' }, /* really only 2 operands */
938 { "movlpX", EX
, XM
, SIMD_Fixup
, 'h' },
939 { "unpcklpX", XM
, EX
, XX
},
940 { "unpckhpX", XM
, EX
, XX
},
941 { "movhpX", XM
, EX
, SIMD_Fixup
, 'l' },
942 { "movhpX", EX
, XM
, SIMD_Fixup
, 'l' },
945 { "(bad)", XX
, XX
, XX
},
946 { "(bad)", XX
, XX
, XX
},
947 { "(bad)", XX
, XX
, XX
},
948 { "(bad)", XX
, XX
, XX
},
949 { "(bad)", XX
, XX
, XX
},
950 { "(bad)", XX
, XX
, XX
},
951 { "(bad)", XX
, XX
, XX
},
953 { "movL", Rm
, Cm
, XX
},
954 { "movL", Rm
, Dm
, XX
},
955 { "movL", Cm
, Rm
, XX
},
956 { "movL", Dm
, Rm
, XX
},
957 { "movL", Rd
, Td
, XX
},
958 { "(bad)", XX
, XX
, XX
},
959 { "movL", Td
, Rd
, XX
},
960 { "(bad)", XX
, XX
, XX
},
962 { "movapX", XM
, EX
, XX
},
963 { "movapX", EX
, XM
, XX
},
965 { "movntpX", Ev
, XM
, XX
},
968 { "ucomisX", XM
,EX
, XX
},
969 { "comisX", XM
,EX
, XX
},
971 { "wrmsr", XX
, XX
, XX
},
972 { "rdtsc", XX
, XX
, XX
},
973 { "rdmsr", XX
, XX
, XX
},
974 { "rdpmc", XX
, XX
, XX
},
975 { "sysenter", XX
, XX
, XX
},
976 { "sysexit", XX
, XX
, XX
},
977 { "(bad)", XX
, XX
, XX
},
978 { "(bad)", XX
, XX
, XX
},
980 { "(bad)", XX
, XX
, XX
},
981 { "(bad)", XX
, XX
, XX
},
982 { "(bad)", XX
, XX
, XX
},
983 { "(bad)", XX
, XX
, XX
},
984 { "(bad)", XX
, XX
, XX
},
985 { "(bad)", XX
, XX
, XX
},
986 { "(bad)", XX
, XX
, XX
},
987 { "(bad)", XX
, XX
, XX
},
989 { "cmovo", Gv
, Ev
, XX
},
990 { "cmovno", Gv
, Ev
, XX
},
991 { "cmovb", Gv
, Ev
, XX
},
992 { "cmovae", Gv
, Ev
, XX
},
993 { "cmove", Gv
, Ev
, XX
},
994 { "cmovne", Gv
, Ev
, XX
},
995 { "cmovbe", Gv
, Ev
, XX
},
996 { "cmova", Gv
, Ev
, XX
},
998 { "cmovs", Gv
, Ev
, XX
},
999 { "cmovns", Gv
, Ev
, XX
},
1000 { "cmovp", Gv
, Ev
, XX
},
1001 { "cmovnp", Gv
, Ev
, XX
},
1002 { "cmovl", Gv
, Ev
, XX
},
1003 { "cmovge", Gv
, Ev
, XX
},
1004 { "cmovle", Gv
, Ev
, XX
},
1005 { "cmovg", Gv
, Ev
, XX
},
1007 { "movmskpX", Gd
, XS
, XX
},
1011 { "andpX", XM
, EX
, XX
},
1012 { "andnpX", XM
, EX
, XX
},
1013 { "orpX", XM
, EX
, XX
},
1014 { "xorpX", XM
, EX
, XX
},
1025 { "punpcklbw", MX
, EM
, XX
},
1026 { "punpcklwd", MX
, EM
, XX
},
1027 { "punpckldq", MX
, EM
, XX
},
1028 { "packsswb", MX
, EM
, XX
},
1029 { "pcmpgtb", MX
, EM
, XX
},
1030 { "pcmpgtw", MX
, EM
, XX
},
1031 { "pcmpgtd", MX
, EM
, XX
},
1032 { "packuswb", MX
, EM
, XX
},
1034 { "punpckhbw", MX
, EM
, XX
},
1035 { "punpckhwd", MX
, EM
, XX
},
1036 { "punpckhdq", MX
, EM
, XX
},
1037 { "packssdw", MX
, EM
, XX
},
1040 { "movd", MX
, Ed
, XX
},
1047 { "pcmpeqb", MX
, EM
, XX
},
1048 { "pcmpeqw", MX
, EM
, XX
},
1049 { "pcmpeqd", MX
, EM
, XX
},
1050 { "emms", XX
, XX
, XX
},
1052 { "(bad)", XX
, XX
, XX
},
1053 { "(bad)", XX
, XX
, XX
},
1054 { "(bad)", XX
, XX
, XX
},
1055 { "(bad)", XX
, XX
, XX
},
1056 { "(bad)", XX
, XX
, XX
},
1057 { "(bad)", XX
, XX
, XX
},
1061 { "joH", Jv
, XX
, cond_jump_flag
},
1062 { "jnoH", Jv
, XX
, cond_jump_flag
},
1063 { "jbH", Jv
, XX
, cond_jump_flag
},
1064 { "jaeH", Jv
, XX
, cond_jump_flag
},
1065 { "jeH", Jv
, XX
, cond_jump_flag
},
1066 { "jneH", Jv
, XX
, cond_jump_flag
},
1067 { "jbeH", Jv
, XX
, cond_jump_flag
},
1068 { "jaH", Jv
, XX
, cond_jump_flag
},
1070 { "jsH", Jv
, XX
, cond_jump_flag
},
1071 { "jnsH", Jv
, XX
, cond_jump_flag
},
1072 { "jpH", Jv
, XX
, cond_jump_flag
},
1073 { "jnpH", Jv
, XX
, cond_jump_flag
},
1074 { "jlH", Jv
, XX
, cond_jump_flag
},
1075 { "jgeH", Jv
, XX
, cond_jump_flag
},
1076 { "jleH", Jv
, XX
, cond_jump_flag
},
1077 { "jgH", Jv
, XX
, cond_jump_flag
},
1079 { "seto", Eb
, XX
, XX
},
1080 { "setno", Eb
, XX
, XX
},
1081 { "setb", Eb
, XX
, XX
},
1082 { "setae", Eb
, XX
, XX
},
1083 { "sete", Eb
, XX
, XX
},
1084 { "setne", Eb
, XX
, XX
},
1085 { "setbe", Eb
, XX
, XX
},
1086 { "seta", Eb
, XX
, XX
},
1088 { "sets", Eb
, XX
, XX
},
1089 { "setns", Eb
, XX
, XX
},
1090 { "setp", Eb
, XX
, XX
},
1091 { "setnp", Eb
, XX
, XX
},
1092 { "setl", Eb
, XX
, XX
},
1093 { "setge", Eb
, XX
, XX
},
1094 { "setle", Eb
, XX
, XX
},
1095 { "setg", Eb
, XX
, XX
},
1097 { "pushT", fs
, XX
, XX
},
1098 { "popT", fs
, XX
, XX
},
1099 { "cpuid", XX
, XX
, XX
},
1100 { "btS", Ev
, Gv
, XX
},
1101 { "shldS", Ev
, Gv
, Ib
},
1102 { "shldS", Ev
, Gv
, CL
},
1103 { "(bad)", XX
, XX
, XX
},
1104 { "(bad)", XX
, XX
, XX
},
1106 { "pushT", gs
, XX
, XX
},
1107 { "popT", gs
, XX
, XX
},
1108 { "rsm", XX
, XX
, XX
},
1109 { "btsS", Ev
, Gv
, XX
},
1110 { "shrdS", Ev
, Gv
, Ib
},
1111 { "shrdS", Ev
, Gv
, CL
},
1113 { "imulS", Gv
, Ev
, XX
},
1115 { "cmpxchgB", Eb
, Gb
, XX
},
1116 { "cmpxchgS", Ev
, Gv
, XX
},
1117 { "lssS", Gv
, Mp
, XX
},
1118 { "btrS", Ev
, Gv
, XX
},
1119 { "lfsS", Gv
, Mp
, XX
},
1120 { "lgsS", Gv
, Mp
, XX
},
1121 { "movz{bR|x|bR|x}", Gv
, Eb
, XX
},
1122 { "movz{wR|x|wR|x}", Gv
, Ew
, XX
}, /* yes, there really is movzww ! */
1124 { "(bad)", XX
, XX
, XX
},
1125 { "ud2b", XX
, XX
, XX
},
1127 { "btcS", Ev
, Gv
, XX
},
1128 { "bsfS", Gv
, Ev
, XX
},
1129 { "bsrS", Gv
, Ev
, XX
},
1130 { "movs{bR|x|bR|x}", Gv
, Eb
, XX
},
1131 { "movs{wR|x|wR|x}", Gv
, Ew
, XX
}, /* yes, there really is movsww ! */
1133 { "xaddB", Eb
, Gb
, XX
},
1134 { "xaddS", Ev
, Gv
, XX
},
1136 { "movntiS", Ev
, Gv
, XX
},
1137 { "pinsrw", MX
, Ed
, Ib
},
1138 { "pextrw", Gd
, MS
, Ib
},
1139 { "shufpX", XM
, EX
, Ib
},
1142 { "bswap", RMeAX
, XX
, XX
},
1143 { "bswap", RMeCX
, XX
, XX
},
1144 { "bswap", RMeDX
, XX
, XX
},
1145 { "bswap", RMeBX
, XX
, XX
},
1146 { "bswap", RMeSP
, XX
, XX
},
1147 { "bswap", RMeBP
, XX
, XX
},
1148 { "bswap", RMeSI
, XX
, XX
},
1149 { "bswap", RMeDI
, XX
, XX
},
1151 { "(bad)", XX
, XX
, XX
},
1152 { "psrlw", MX
, EM
, XX
},
1153 { "psrld", MX
, EM
, XX
},
1154 { "psrlq", MX
, EM
, XX
},
1155 { "paddq", MX
, EM
, XX
},
1156 { "pmullw", MX
, EM
, XX
},
1158 { "pmovmskb", Gd
, MS
, XX
},
1160 { "psubusb", MX
, EM
, XX
},
1161 { "psubusw", MX
, EM
, XX
},
1162 { "pminub", MX
, EM
, XX
},
1163 { "pand", MX
, EM
, XX
},
1164 { "paddusb", MX
, EM
, XX
},
1165 { "paddusw", MX
, EM
, XX
},
1166 { "pmaxub", MX
, EM
, XX
},
1167 { "pandn", MX
, EM
, XX
},
1169 { "pavgb", MX
, EM
, XX
},
1170 { "psraw", MX
, EM
, XX
},
1171 { "psrad", MX
, EM
, XX
},
1172 { "pavgw", MX
, EM
, XX
},
1173 { "pmulhuw", MX
, EM
, XX
},
1174 { "pmulhw", MX
, EM
, XX
},
1178 { "psubsb", MX
, EM
, XX
},
1179 { "psubsw", MX
, EM
, XX
},
1180 { "pminsw", MX
, EM
, XX
},
1181 { "por", MX
, EM
, XX
},
1182 { "paddsb", MX
, EM
, XX
},
1183 { "paddsw", MX
, EM
, XX
},
1184 { "pmaxsw", MX
, EM
, XX
},
1185 { "pxor", MX
, EM
, XX
},
1187 { "(bad)", XX
, XX
, XX
},
1188 { "psllw", MX
, EM
, XX
},
1189 { "pslld", MX
, EM
, XX
},
1190 { "psllq", MX
, EM
, XX
},
1191 { "pmuludq", MX
, EM
, XX
},
1192 { "pmaddwd", MX
, EM
, XX
},
1193 { "psadbw", MX
, EM
, XX
},
1196 { "psubb", MX
, EM
, XX
},
1197 { "psubw", MX
, EM
, XX
},
1198 { "psubd", MX
, EM
, XX
},
1199 { "psubq", MX
, EM
, XX
},
1200 { "paddb", MX
, EM
, XX
},
1201 { "paddw", MX
, EM
, XX
},
1202 { "paddd", MX
, EM
, XX
},
1203 { "(bad)", XX
, XX
, XX
}
1206 static const unsigned char onebyte_has_modrm
[256] = {
1207 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1208 /* ------------------------------- */
1209 /* 00 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 00 */
1210 /* 10 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 10 */
1211 /* 20 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 20 */
1212 /* 30 */ 1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, /* 30 */
1213 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 40 */
1214 /* 50 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 50 */
1215 /* 60 */ 0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, /* 60 */
1216 /* 70 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 70 */
1217 /* 80 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 80 */
1218 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 90 */
1219 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* a0 */
1220 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* b0 */
1221 /* c0 */ 1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, /* c0 */
1222 /* d0 */ 1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* d0 */
1223 /* e0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* e0 */
1224 /* f0 */ 0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1 /* f0 */
1225 /* ------------------------------- */
1226 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1229 static const unsigned char twobyte_has_modrm
[256] = {
1230 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1231 /* ------------------------------- */
1232 /* 00 */ 1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, /* 0f */
1233 /* 10 */ 1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, /* 1f */
1234 /* 20 */ 1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, /* 2f */
1235 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1236 /* 40 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 4f */
1237 /* 50 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 5f */
1238 /* 60 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 6f */
1239 /* 70 */ 1,1,1,1,1,1,1,0,0,0,0,0,0,0,1,1, /* 7f */
1240 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1241 /* 90 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* 9f */
1242 /* a0 */ 0,0,0,1,1,1,0,0,0,0,0,1,1,1,1,1, /* af */
1243 /* b0 */ 1,1,1,1,1,1,1,1,0,0,1,1,1,1,1,1, /* bf */
1244 /* c0 */ 1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, /* cf */
1245 /* d0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* df */
1246 /* e0 */ 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, /* ef */
1247 /* f0 */ 0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0 /* ff */
1248 /* ------------------------------- */
1249 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1252 static const unsigned char twobyte_uses_SSE_prefix
[256] = {
1253 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1254 /* ------------------------------- */
1255 /* 00 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0f */
1256 /* 10 */ 1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 1f */
1257 /* 20 */ 0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0, /* 2f */
1258 /* 30 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 3f */
1259 /* 40 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 4f */
1260 /* 50 */ 0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, /* 5f */
1261 /* 60 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, /* 6f */
1262 /* 70 */ 1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, /* 7f */
1263 /* 80 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 8f */
1264 /* 90 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 9f */
1265 /* a0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* af */
1266 /* b0 */ 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* bf */
1267 /* c0 */ 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, /* cf */
1268 /* d0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* df */
1269 /* e0 */ 0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, /* ef */
1270 /* f0 */ 0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0 /* ff */
1271 /* ------------------------------- */
1272 /* 0 1 2 3 4 5 6 7 8 9 a b c d e f */
1275 static char obuf
[100];
1277 static char scratchbuf
[100];
1278 static unsigned char *start_codep
;
1279 static unsigned char *insn_codep
;
1280 static unsigned char *codep
;
1281 static disassemble_info
*the_info
;
1285 static unsigned char need_modrm
;
1287 /* If we are accessing mod/rm/reg without need_modrm set, then the
1288 values are stale. Hitting this abort likely indicates that you
1289 need to update onebyte_has_modrm or twobyte_has_modrm. */
1290 #define MODRM_CHECK if (!need_modrm) abort ()
1292 static const char **names64
;
1293 static const char **names32
;
1294 static const char **names16
;
1295 static const char **names8
;
1296 static const char **names8rex
;
1297 static const char **names_seg
;
1298 static const char **index16
;
1300 static const char *intel_names64
[] = {
1301 "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
1302 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
1304 static const char *intel_names32
[] = {
1305 "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
1306 "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
1308 static const char *intel_names16
[] = {
1309 "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
1310 "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
1312 static const char *intel_names8
[] = {
1313 "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
1315 static const char *intel_names8rex
[] = {
1316 "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
1317 "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
1319 static const char *intel_names_seg
[] = {
1320 "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
1322 static const char *intel_index16
[] = {
1323 "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
1326 static const char *att_names64
[] = {
1327 "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
1328 "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
1330 static const char *att_names32
[] = {
1331 "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
1332 "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
1334 static const char *att_names16
[] = {
1335 "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
1336 "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
1338 static const char *att_names8
[] = {
1339 "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
1341 static const char *att_names8rex
[] = {
1342 "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
1343 "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
1345 static const char *att_names_seg
[] = {
1346 "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
1348 static const char *att_index16
[] = {
1349 "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
1352 static const struct dis386 grps
[][8] = {
1355 { "addA", Eb
, Ib
, XX
},
1356 { "orA", Eb
, Ib
, XX
},
1357 { "adcA", Eb
, Ib
, XX
},
1358 { "sbbA", Eb
, Ib
, XX
},
1359 { "andA", Eb
, Ib
, XX
},
1360 { "subA", Eb
, Ib
, XX
},
1361 { "xorA", Eb
, Ib
, XX
},
1362 { "cmpA", Eb
, Ib
, XX
}
1366 { "addQ", Ev
, Iv
, XX
},
1367 { "orQ", Ev
, Iv
, XX
},
1368 { "adcQ", Ev
, Iv
, XX
},
1369 { "sbbQ", Ev
, Iv
, XX
},
1370 { "andQ", Ev
, Iv
, XX
},
1371 { "subQ", Ev
, Iv
, XX
},
1372 { "xorQ", Ev
, Iv
, XX
},
1373 { "cmpQ", Ev
, Iv
, XX
}
1377 { "addQ", Ev
, sIb
, XX
},
1378 { "orQ", Ev
, sIb
, XX
},
1379 { "adcQ", Ev
, sIb
, XX
},
1380 { "sbbQ", Ev
, sIb
, XX
},
1381 { "andQ", Ev
, sIb
, XX
},
1382 { "subQ", Ev
, sIb
, XX
},
1383 { "xorQ", Ev
, sIb
, XX
},
1384 { "cmpQ", Ev
, sIb
, XX
}
1388 { "rolA", Eb
, Ib
, XX
},
1389 { "rorA", Eb
, Ib
, XX
},
1390 { "rclA", Eb
, Ib
, XX
},
1391 { "rcrA", Eb
, Ib
, XX
},
1392 { "shlA", Eb
, Ib
, XX
},
1393 { "shrA", Eb
, Ib
, XX
},
1394 { "(bad)", XX
, XX
, XX
},
1395 { "sarA", Eb
, Ib
, XX
},
1399 { "rolQ", Ev
, Ib
, XX
},
1400 { "rorQ", Ev
, Ib
, XX
},
1401 { "rclQ", Ev
, Ib
, XX
},
1402 { "rcrQ", Ev
, Ib
, XX
},
1403 { "shlQ", Ev
, Ib
, XX
},
1404 { "shrQ", Ev
, Ib
, XX
},
1405 { "(bad)", XX
, XX
, XX
},
1406 { "sarQ", Ev
, Ib
, XX
},
1410 { "rolA", Eb
, XX
, XX
},
1411 { "rorA", Eb
, XX
, XX
},
1412 { "rclA", Eb
, XX
, XX
},
1413 { "rcrA", Eb
, XX
, XX
},
1414 { "shlA", Eb
, XX
, XX
},
1415 { "shrA", Eb
, XX
, XX
},
1416 { "(bad)", XX
, XX
, XX
},
1417 { "sarA", Eb
, XX
, XX
},
1421 { "rolQ", Ev
, XX
, XX
},
1422 { "rorQ", Ev
, XX
, XX
},
1423 { "rclQ", Ev
, XX
, XX
},
1424 { "rcrQ", Ev
, XX
, XX
},
1425 { "shlQ", Ev
, XX
, XX
},
1426 { "shrQ", Ev
, XX
, XX
},
1427 { "(bad)", XX
, XX
, XX
},
1428 { "sarQ", Ev
, XX
, XX
},
1432 { "rolA", Eb
, CL
, XX
},
1433 { "rorA", Eb
, CL
, XX
},
1434 { "rclA", Eb
, CL
, XX
},
1435 { "rcrA", Eb
, CL
, XX
},
1436 { "shlA", Eb
, CL
, XX
},
1437 { "shrA", Eb
, CL
, XX
},
1438 { "(bad)", XX
, XX
, XX
},
1439 { "sarA", Eb
, CL
, XX
},
1443 { "rolQ", Ev
, CL
, XX
},
1444 { "rorQ", Ev
, CL
, XX
},
1445 { "rclQ", Ev
, CL
, XX
},
1446 { "rcrQ", Ev
, CL
, XX
},
1447 { "shlQ", Ev
, CL
, XX
},
1448 { "shrQ", Ev
, CL
, XX
},
1449 { "(bad)", XX
, XX
, XX
},
1450 { "sarQ", Ev
, CL
, XX
}
1454 { "testA", Eb
, Ib
, XX
},
1455 { "(bad)", Eb
, XX
, XX
},
1456 { "notA", Eb
, XX
, XX
},
1457 { "negA", Eb
, XX
, XX
},
1458 { "mulA", Eb
, XX
, XX
}, /* Don't print the implicit %al register, */
1459 { "imulA", Eb
, XX
, XX
}, /* to distinguish these opcodes from other */
1460 { "divA", Eb
, XX
, XX
}, /* mul/imul opcodes. Do the same for div */
1461 { "idivA", Eb
, XX
, XX
} /* and idiv for consistency. */
1465 { "testQ", Ev
, Iv
, XX
},
1466 { "(bad)", XX
, XX
, XX
},
1467 { "notQ", Ev
, XX
, XX
},
1468 { "negQ", Ev
, XX
, XX
},
1469 { "mulQ", Ev
, XX
, XX
}, /* Don't print the implicit register. */
1470 { "imulQ", Ev
, XX
, XX
},
1471 { "divQ", Ev
, XX
, XX
},
1472 { "idivQ", Ev
, XX
, XX
},
1476 { "incA", Eb
, XX
, XX
},
1477 { "decA", Eb
, XX
, XX
},
1478 { "(bad)", XX
, XX
, XX
},
1479 { "(bad)", XX
, XX
, XX
},
1480 { "(bad)", XX
, XX
, XX
},
1481 { "(bad)", XX
, XX
, XX
},
1482 { "(bad)", XX
, XX
, XX
},
1483 { "(bad)", XX
, XX
, XX
},
1487 { "incQ", Ev
, XX
, XX
},
1488 { "decQ", Ev
, XX
, XX
},
1489 { "callT", indirEv
, XX
, XX
},
1490 { "lcallT", indirEv
, XX
, XX
},
1491 { "jmpT", indirEv
, XX
, XX
},
1492 { "ljmpT", indirEv
, XX
, XX
},
1493 { "pushU", Ev
, XX
, XX
},
1494 { "(bad)", XX
, XX
, XX
},
1498 { "sldtQ", Ev
, XX
, XX
},
1499 { "strQ", Ev
, XX
, XX
},
1500 { "lldt", Ew
, XX
, XX
},
1501 { "ltr", Ew
, XX
, XX
},
1502 { "verr", Ew
, XX
, XX
},
1503 { "verw", Ew
, XX
, XX
},
1504 { "(bad)", XX
, XX
, XX
},
1505 { "(bad)", XX
, XX
, XX
}
1509 { "sgdtQ", M
, XX
, XX
},
1510 { "sidtQ", M
, XX
, XX
},
1511 { "lgdtQ", M
, XX
, XX
},
1512 { "lidtQ", M
, XX
, XX
},
1513 { "smswQ", Ev
, XX
, XX
},
1514 { "(bad)", XX
, XX
, XX
},
1515 { "lmsw", Ew
, XX
, XX
},
1516 { "invlpg", Ew
, XX
, XX
},
1520 { "(bad)", XX
, XX
, XX
},
1521 { "(bad)", XX
, XX
, XX
},
1522 { "(bad)", XX
, XX
, XX
},
1523 { "(bad)", XX
, XX
, XX
},
1524 { "btQ", Ev
, Ib
, XX
},
1525 { "btsQ", Ev
, Ib
, XX
},
1526 { "btrQ", Ev
, Ib
, XX
},
1527 { "btcQ", Ev
, Ib
, XX
},
1531 { "(bad)", XX
, XX
, XX
},
1532 { "cmpxchg8b", Ev
, XX
, XX
},
1533 { "(bad)", XX
, XX
, XX
},
1534 { "(bad)", XX
, XX
, XX
},
1535 { "(bad)", XX
, XX
, XX
},
1536 { "(bad)", XX
, XX
, XX
},
1537 { "(bad)", XX
, XX
, XX
},
1538 { "(bad)", XX
, XX
, XX
},
1542 { "(bad)", XX
, XX
, XX
},
1543 { "(bad)", XX
, XX
, XX
},
1544 { "psrlw", MS
, Ib
, XX
},
1545 { "(bad)", XX
, XX
, XX
},
1546 { "psraw", MS
, Ib
, XX
},
1547 { "(bad)", XX
, XX
, XX
},
1548 { "psllw", MS
, Ib
, XX
},
1549 { "(bad)", XX
, XX
, XX
},
1553 { "(bad)", XX
, XX
, XX
},
1554 { "(bad)", XX
, XX
, XX
},
1555 { "psrld", MS
, Ib
, XX
},
1556 { "(bad)", XX
, XX
, XX
},
1557 { "psrad", MS
, Ib
, XX
},
1558 { "(bad)", XX
, XX
, XX
},
1559 { "pslld", MS
, Ib
, XX
},
1560 { "(bad)", XX
, XX
, XX
},
1564 { "(bad)", XX
, XX
, XX
},
1565 { "(bad)", XX
, XX
, XX
},
1566 { "psrlq", MS
, Ib
, XX
},
1567 { "psrldq", MS
, Ib
, XX
},
1568 { "(bad)", XX
, XX
, XX
},
1569 { "(bad)", XX
, XX
, XX
},
1570 { "psllq", MS
, Ib
, XX
},
1571 { "pslldq", MS
, Ib
, XX
},
1575 { "fxsave", Ev
, XX
, XX
},
1576 { "fxrstor", Ev
, XX
, XX
},
1577 { "ldmxcsr", Ev
, XX
, XX
},
1578 { "stmxcsr", Ev
, XX
, XX
},
1579 { "(bad)", XX
, XX
, XX
},
1580 { "lfence", None
, XX
, XX
},
1581 { "mfence", None
, XX
, XX
},
1582 { "sfence", None
, XX
, XX
},
1583 /* FIXME: the sfence with memory operand is clflush! */
1587 { "prefetchnta", Ev
, XX
, XX
},
1588 { "prefetcht0", Ev
, XX
, XX
},
1589 { "prefetcht1", Ev
, XX
, XX
},
1590 { "prefetcht2", Ev
, XX
, XX
},
1591 { "(bad)", XX
, XX
, XX
},
1592 { "(bad)", XX
, XX
, XX
},
1593 { "(bad)", XX
, XX
, XX
},
1594 { "(bad)", XX
, XX
, XX
},
1598 { "prefetch", Eb
, XX
, XX
},
1599 { "prefetchw", Eb
, XX
, XX
},
1600 { "(bad)", XX
, XX
, XX
},
1601 { "(bad)", XX
, XX
, XX
},
1602 { "(bad)", XX
, XX
, XX
},
1603 { "(bad)", XX
, XX
, XX
},
1604 { "(bad)", XX
, XX
, XX
},
1605 { "(bad)", XX
, XX
, XX
},
1609 static const struct dis386 prefix_user_table
[][4] = {
1612 { "addps", XM
, EX
, XX
},
1613 { "addss", XM
, EX
, XX
},
1614 { "addpd", XM
, EX
, XX
},
1615 { "addsd", XM
, EX
, XX
},
1619 { "", XM
, EX
, OPSIMD
}, /* See OP_SIMD_SUFFIX. */
1620 { "", XM
, EX
, OPSIMD
},
1621 { "", XM
, EX
, OPSIMD
},
1622 { "", XM
, EX
, OPSIMD
},
1626 { "cvtpi2ps", XM
, EM
, XX
},
1627 { "cvtsi2ssY", XM
, Ev
, XX
},
1628 { "cvtpi2pd", XM
, EM
, XX
},
1629 { "cvtsi2sdY", XM
, Ev
, XX
},
1633 { "cvtps2pi", MX
, EX
, XX
},
1634 { "cvtss2siY", Gv
, EX
, XX
},
1635 { "cvtpd2pi", MX
, EX
, XX
},
1636 { "cvtsd2siY", Gv
, EX
, XX
},
1640 { "cvttps2pi", MX
, EX
, XX
},
1641 { "cvttss2siY", Gv
, EX
, XX
},
1642 { "cvttpd2pi", MX
, EX
, XX
},
1643 { "cvttsd2siY", Gv
, EX
, XX
},
1647 { "divps", XM
, EX
, XX
},
1648 { "divss", XM
, EX
, XX
},
1649 { "divpd", XM
, EX
, XX
},
1650 { "divsd", XM
, EX
, XX
},
1654 { "maxps", XM
, EX
, XX
},
1655 { "maxss", XM
, EX
, XX
},
1656 { "maxpd", XM
, EX
, XX
},
1657 { "maxsd", XM
, EX
, XX
},
1661 { "minps", XM
, EX
, XX
},
1662 { "minss", XM
, EX
, XX
},
1663 { "minpd", XM
, EX
, XX
},
1664 { "minsd", XM
, EX
, XX
},
1668 { "movups", XM
, EX
, XX
},
1669 { "movss", XM
, EX
, XX
},
1670 { "movupd", XM
, EX
, XX
},
1671 { "movsd", XM
, EX
, XX
},
1675 { "movups", EX
, XM
, XX
},
1676 { "movss", EX
, XM
, XX
},
1677 { "movupd", EX
, XM
, XX
},
1678 { "movsd", EX
, XM
, XX
},
1682 { "mulps", XM
, EX
, XX
},
1683 { "mulss", XM
, EX
, XX
},
1684 { "mulpd", XM
, EX
, XX
},
1685 { "mulsd", XM
, EX
, XX
},
1689 { "rcpps", XM
, EX
, XX
},
1690 { "rcpss", XM
, EX
, XX
},
1691 { "(bad)", XM
, EX
, XX
},
1692 { "(bad)", XM
, EX
, XX
},
1696 { "rsqrtps", XM
, EX
, XX
},
1697 { "rsqrtss", XM
, EX
, XX
},
1698 { "(bad)", XM
, EX
, XX
},
1699 { "(bad)", XM
, EX
, XX
},
1703 { "sqrtps", XM
, EX
, XX
},
1704 { "sqrtss", XM
, EX
, XX
},
1705 { "sqrtpd", XM
, EX
, XX
},
1706 { "sqrtsd", XM
, EX
, XX
},
1710 { "subps", XM
, EX
, XX
},
1711 { "subss", XM
, EX
, XX
},
1712 { "subpd", XM
, EX
, XX
},
1713 { "subsd", XM
, EX
, XX
},
1717 { "(bad)", XM
, EX
, XX
},
1718 { "cvtdq2pd", XM
, EX
, XX
},
1719 { "cvttpd2dq", XM
, EX
, XX
},
1720 { "cvtpd2dq", XM
, EX
, XX
},
1724 { "cvtdq2ps", XM
, EX
, XX
},
1725 { "cvttps2dq",XM
, EX
, XX
},
1726 { "cvtps2dq",XM
, EX
, XX
},
1727 { "(bad)", XM
, EX
, XX
},
1731 { "cvtps2pd", XM
, EX
, XX
},
1732 { "cvtss2sd", XM
, EX
, XX
},
1733 { "cvtpd2ps", XM
, EX
, XX
},
1734 { "cvtsd2ss", XM
, EX
, XX
},
1738 { "maskmovq", MX
, MS
, XX
},
1739 { "(bad)", XM
, EX
, XX
},
1740 { "maskmovdqu", XM
, EX
, XX
},
1741 { "(bad)", XM
, EX
, XX
},
1745 { "movq", MX
, EM
, XX
},
1746 { "movdqu", XM
, EX
, XX
},
1747 { "movdqa", XM
, EX
, XX
},
1748 { "(bad)", XM
, EX
, XX
},
1752 { "movq", EM
, MX
, XX
},
1753 { "movdqu", EX
, XM
, XX
},
1754 { "movdqa", EX
, XM
, XX
},
1755 { "(bad)", EX
, XM
, XX
},
1759 { "(bad)", EX
, XM
, XX
},
1760 { "movq2dq", XM
, MS
, XX
},
1761 { "movq", EX
, XM
, XX
},
1762 { "movdq2q", MX
, XS
, XX
},
1766 { "pshufw", MX
, EM
, Ib
},
1767 { "pshufhw", XM
, EX
, Ib
},
1768 { "pshufd", XM
, EX
, Ib
},
1769 { "pshuflw", XM
, EX
, Ib
},
1773 { "movd", Ed
, MX
, XX
},
1774 { "movq", XM
, EX
, XX
},
1775 { "movd", Ed
, XM
, XX
},
1776 { "(bad)", Ed
, XM
, XX
},
1780 { "(bad)", MX
, EX
, XX
},
1781 { "(bad)", XM
, EX
, XX
},
1782 { "punpckhqdq", XM
, EX
, XX
},
1783 { "(bad)", XM
, EX
, XX
},
1787 { "movntq", Ev
, MX
, XX
},
1788 { "(bad)", Ev
, XM
, XX
},
1789 { "movntdq", Ev
, XM
, XX
},
1790 { "(bad)", Ev
, XM
, XX
},
1794 { "(bad)", MX
, EX
, XX
},
1795 { "(bad)", XM
, EX
, XX
},
1796 { "punpcklqdq", XM
, EX
, XX
},
1797 { "(bad)", XM
, EX
, XX
},
1801 static const struct dis386 x86_64_table
[][2] = {
1803 { "arpl", Ew
, Gw
, XX
},
1804 { "movs{||lq|xd}", Gv
, Ed
, XX
},
1808 #define INTERNAL_DISASSEMBLER_ERROR _("<internal disassembler error>")
1820 FETCH_DATA (the_info
, codep
+ 1);
1824 /* REX prefixes family. */
1847 prefixes
|= PREFIX_REPZ
;
1850 prefixes
|= PREFIX_REPNZ
;
1853 prefixes
|= PREFIX_LOCK
;
1856 prefixes
|= PREFIX_CS
;
1859 prefixes
|= PREFIX_SS
;
1862 prefixes
|= PREFIX_DS
;
1865 prefixes
|= PREFIX_ES
;
1868 prefixes
|= PREFIX_FS
;
1871 prefixes
|= PREFIX_GS
;
1874 prefixes
|= PREFIX_DATA
;
1877 prefixes
|= PREFIX_ADDR
;
1880 /* fwait is really an instruction. If there are prefixes
1881 before the fwait, they belong to the fwait, *not* to the
1882 following instruction. */
1885 prefixes
|= PREFIX_FWAIT
;
1889 prefixes
= PREFIX_FWAIT
;
1894 /* Rex is ignored when followed by another prefix. */
1897 oappend (prefix_name (rex
, 0));
1905 /* Return the name of the prefix byte PREF, or NULL if PREF is not a
1909 prefix_name (pref
, sizeflag
)
1915 /* REX prefixes family. */
1967 return (sizeflag
& DFLAG
) ? "data16" : "data32";
1970 return (sizeflag
& AFLAG
) ? "addr32" : "addr64";
1972 return ((sizeflag
& AFLAG
) && !mode_64bit
) ? "addr16" : "addr32";
1980 static char op1out
[100], op2out
[100], op3out
[100];
1981 static int op_ad
, op_index
[3];
1982 static bfd_vma op_address
[3];
1983 static bfd_vma op_riprel
[3];
1984 static bfd_vma start_pc
;
1987 * On the 386's of 1988, the maximum length of an instruction is 15 bytes.
1988 * (see topic "Redundant prefixes" in the "Differences from 8086"
1989 * section of the "Virtual 8086 Mode" chapter.)
1990 * 'pc' should be the address of this instruction, it will
1991 * be used to print the target address if this is a relative jump or call
1992 * The function returns the length of this instruction in bytes.
1995 static char intel_syntax
;
1996 static char open_char
;
1997 static char close_char
;
1998 static char separator_char
;
1999 static char scale_char
;
2001 /* Here for backwards compatibility. When gdb stops using
2002 print_insn_i386_att and print_insn_i386_intel these functions can
2003 disappear, and print_insn_i386 be merged into print_insn. */
2005 print_insn_i386_att (pc
, info
)
2007 disassemble_info
*info
;
2011 return print_insn (pc
, info
);
2015 print_insn_i386_intel (pc
, info
)
2017 disassemble_info
*info
;
2021 return print_insn (pc
, info
);
2025 print_insn_i386 (pc
, info
)
2027 disassemble_info
*info
;
2031 return print_insn (pc
, info
);
2035 print_insn (pc
, info
)
2037 disassemble_info
*info
;
2039 const struct dis386
*dp
;
2042 char *first
, *second
, *third
;
2044 unsigned char uses_SSE_prefix
;
2047 struct dis_private priv
;
2049 mode_64bit
= (info
->mach
== bfd_mach_x86_64_intel_syntax
2050 || info
->mach
== bfd_mach_x86_64
);
2052 if (intel_syntax
== -1)
2053 intel_syntax
= (info
->mach
== bfd_mach_i386_i386_intel_syntax
2054 || info
->mach
== bfd_mach_x86_64_intel_syntax
);
2056 if (info
->mach
== bfd_mach_i386_i386
2057 || info
->mach
== bfd_mach_x86_64
2058 || info
->mach
== bfd_mach_i386_i386_intel_syntax
2059 || info
->mach
== bfd_mach_x86_64_intel_syntax
)
2060 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
2061 else if (info
->mach
== bfd_mach_i386_i8086
)
2062 priv
.orig_sizeflag
= 0;
2067 for (p
= info
->disassembler_options
; p
!= NULL
; )
2069 if (strncmp (p
, "x86-64", 6) == 0)
2072 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
2074 else if (strncmp (p
, "i386", 4) == 0)
2077 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
2079 else if (strncmp (p
, "i8086", 5) == 0)
2082 priv
.orig_sizeflag
= 0;
2084 else if (strncmp (p
, "intel", 5) == 0)
2088 else if (strncmp (p
, "att", 3) == 0)
2092 else if (strncmp (p
, "addr", 4) == 0)
2094 if (p
[4] == '1' && p
[5] == '6')
2095 priv
.orig_sizeflag
&= ~AFLAG
;
2096 else if (p
[4] == '3' && p
[5] == '2')
2097 priv
.orig_sizeflag
|= AFLAG
;
2099 else if (strncmp (p
, "data", 4) == 0)
2101 if (p
[4] == '1' && p
[5] == '6')
2102 priv
.orig_sizeflag
&= ~DFLAG
;
2103 else if (p
[4] == '3' && p
[5] == '2')
2104 priv
.orig_sizeflag
|= DFLAG
;
2106 else if (strncmp (p
, "suffix", 6) == 0)
2107 priv
.orig_sizeflag
|= SUFFIX_ALWAYS
;
2109 p
= strchr (p
, ',');
2115 priv
.orig_sizeflag
= AFLAG
| DFLAG
;
2121 names64
= intel_names64
;
2122 names32
= intel_names32
;
2123 names16
= intel_names16
;
2124 names8
= intel_names8
;
2125 names8rex
= intel_names8rex
;
2126 names_seg
= intel_names_seg
;
2127 index16
= intel_index16
;
2130 separator_char
= '+';
2135 names64
= att_names64
;
2136 names32
= att_names32
;
2137 names16
= att_names16
;
2138 names8
= att_names8
;
2139 names8rex
= att_names8rex
;
2140 names_seg
= att_names_seg
;
2141 index16
= att_index16
;
2144 separator_char
= ',';
2148 /* The output looks better if we put 7 bytes on a line, since that
2149 puts most long word instructions on a single line. */
2150 info
->bytes_per_line
= 7;
2152 info
->private_data
= (PTR
) &priv
;
2153 priv
.max_fetched
= priv
.the_buffer
;
2154 priv
.insn_start
= pc
;
2161 op_index
[0] = op_index
[1] = op_index
[2] = -1;
2165 start_codep
= priv
.the_buffer
;
2166 codep
= priv
.the_buffer
;
2168 if (setjmp (priv
.bailout
) != 0)
2172 /* Getting here means we tried for data but didn't get it. That
2173 means we have an incomplete instruction of some sort. Just
2174 print the first byte as a prefix or a .byte pseudo-op. */
2175 if (codep
> priv
.the_buffer
)
2177 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
2179 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
2182 /* Just print the first byte as a .byte instruction. */
2183 (*info
->fprintf_func
) (info
->stream
, ".byte 0x%x",
2184 (unsigned int) priv
.the_buffer
[0]);
2197 sizeflag
= priv
.orig_sizeflag
;
2199 FETCH_DATA (info
, codep
+ 1);
2200 two_source_ops
= (*codep
== 0x62) || (*codep
== 0xc8);
2202 if ((prefixes
& PREFIX_FWAIT
)
2203 && ((*codep
< 0xd8) || (*codep
> 0xdf)))
2207 /* fwait not followed by floating point instruction. Print the
2208 first prefix, which is probably fwait itself. */
2209 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
2211 name
= INTERNAL_DISASSEMBLER_ERROR
;
2212 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
2218 FETCH_DATA (info
, codep
+ 2);
2219 dp
= &dis386_twobyte
[*++codep
];
2220 need_modrm
= twobyte_has_modrm
[*codep
];
2221 uses_SSE_prefix
= twobyte_uses_SSE_prefix
[*codep
];
2225 dp
= &dis386
[*codep
];
2226 need_modrm
= onebyte_has_modrm
[*codep
];
2227 uses_SSE_prefix
= 0;
2231 if (!uses_SSE_prefix
&& (prefixes
& PREFIX_REPZ
))
2234 used_prefixes
|= PREFIX_REPZ
;
2236 if (!uses_SSE_prefix
&& (prefixes
& PREFIX_REPNZ
))
2239 used_prefixes
|= PREFIX_REPNZ
;
2241 if (prefixes
& PREFIX_LOCK
)
2244 used_prefixes
|= PREFIX_LOCK
;
2247 if (prefixes
& PREFIX_ADDR
)
2250 if (dp
->bytemode3
!= loop_jcxz_mode
|| intel_syntax
)
2252 if ((sizeflag
& AFLAG
) || mode_64bit
)
2253 oappend ("addr32 ");
2255 oappend ("addr16 ");
2256 used_prefixes
|= PREFIX_ADDR
;
2260 if (!uses_SSE_prefix
&& (prefixes
& PREFIX_DATA
))
2263 if (dp
->bytemode3
== cond_jump_mode
2264 && dp
->bytemode1
== v_mode
2267 if (sizeflag
& DFLAG
)
2268 oappend ("data32 ");
2270 oappend ("data16 ");
2271 used_prefixes
|= PREFIX_DATA
;
2277 FETCH_DATA (info
, codep
+ 1);
2278 mod
= (*codep
>> 6) & 3;
2279 reg
= (*codep
>> 3) & 7;
2283 if (dp
->name
== NULL
&& dp
->bytemode1
== FLOATCODE
)
2290 if (dp
->name
== NULL
)
2292 switch (dp
->bytemode1
)
2295 dp
= &grps
[dp
->bytemode2
][reg
];
2298 case USE_PREFIX_USER_TABLE
:
2300 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
2301 if (prefixes
& PREFIX_REPZ
)
2305 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2306 if (prefixes
& PREFIX_DATA
)
2310 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
2311 if (prefixes
& PREFIX_REPNZ
)
2315 dp
= &prefix_user_table
[dp
->bytemode2
][index
];
2318 case X86_64_SPECIAL
:
2319 dp
= &x86_64_table
[dp
->bytemode2
][mode_64bit
];
2323 oappend (INTERNAL_DISASSEMBLER_ERROR
);
2328 if (putop (dp
->name
, sizeflag
) == 0)
2333 (*dp
->op1
) (dp
->bytemode1
, sizeflag
);
2338 (*dp
->op2
) (dp
->bytemode2
, sizeflag
);
2343 (*dp
->op3
) (dp
->bytemode3
, sizeflag
);
2347 /* See if any prefixes were not used. If so, print the first one
2348 separately. If we don't do this, we'll wind up printing an
2349 instruction stream which does not precisely correspond to the
2350 bytes we are disassembling. */
2351 if ((prefixes
& ~used_prefixes
) != 0)
2355 name
= prefix_name (priv
.the_buffer
[0], priv
.orig_sizeflag
);
2357 name
= INTERNAL_DISASSEMBLER_ERROR
;
2358 (*info
->fprintf_func
) (info
->stream
, "%s", name
);
2361 if (rex
& ~rex_used
)
2364 name
= prefix_name (rex
| 0x40, priv
.orig_sizeflag
);
2366 name
= INTERNAL_DISASSEMBLER_ERROR
;
2367 (*info
->fprintf_func
) (info
->stream
, "%s ", name
);
2370 obufp
= obuf
+ strlen (obuf
);
2371 for (i
= strlen (obuf
); i
< 6; i
++)
2374 (*info
->fprintf_func
) (info
->stream
, "%s", obuf
);
2376 /* The enter and bound instructions are printed with operands in the same
2377 order as the intel book; everything else is printed in reverse order. */
2378 if (intel_syntax
|| two_source_ops
)
2383 op_ad
= op_index
[0];
2384 op_index
[0] = op_index
[2];
2385 op_index
[2] = op_ad
;
2396 if (op_index
[0] != -1 && !op_riprel
[0])
2397 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[0]], info
);
2399 (*info
->fprintf_func
) (info
->stream
, "%s", first
);
2405 (*info
->fprintf_func
) (info
->stream
, ",");
2406 if (op_index
[1] != -1 && !op_riprel
[1])
2407 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[1]], info
);
2409 (*info
->fprintf_func
) (info
->stream
, "%s", second
);
2415 (*info
->fprintf_func
) (info
->stream
, ",");
2416 if (op_index
[2] != -1 && !op_riprel
[2])
2417 (*info
->print_address_func
) ((bfd_vma
) op_address
[op_index
[2]], info
);
2419 (*info
->fprintf_func
) (info
->stream
, "%s", third
);
2421 for (i
= 0; i
< 3; i
++)
2422 if (op_index
[i
] != -1 && op_riprel
[i
])
2424 (*info
->fprintf_func
) (info
->stream
, " # ");
2425 (*info
->print_address_func
) ((bfd_vma
) (start_pc
+ codep
- start_codep
2426 + op_address
[op_index
[i
]]), info
);
2428 return codep
- priv
.the_buffer
;
2431 static const char *float_mem
[] = {
2507 #define STi OP_STi, 0
2509 #define FGRPd9_2 NULL, NULL, 0, NULL, 0, NULL, 0
2510 #define FGRPd9_4 NULL, NULL, 1, NULL, 0, NULL, 0
2511 #define FGRPd9_5 NULL, NULL, 2, NULL, 0, NULL, 0
2512 #define FGRPd9_6 NULL, NULL, 3, NULL, 0, NULL, 0
2513 #define FGRPd9_7 NULL, NULL, 4, NULL, 0, NULL, 0
2514 #define FGRPda_5 NULL, NULL, 5, NULL, 0, NULL, 0
2515 #define FGRPdb_4 NULL, NULL, 6, NULL, 0, NULL, 0
2516 #define FGRPde_3 NULL, NULL, 7, NULL, 0, NULL, 0
2517 #define FGRPdf_4 NULL, NULL, 8, NULL, 0, NULL, 0
2519 static const struct dis386 float_reg
[][8] = {
2522 { "fadd", ST
, STi
, XX
},
2523 { "fmul", ST
, STi
, XX
},
2524 { "fcom", STi
, XX
, XX
},
2525 { "fcomp", STi
, XX
, XX
},
2526 { "fsub", ST
, STi
, XX
},
2527 { "fsubr", ST
, STi
, XX
},
2528 { "fdiv", ST
, STi
, XX
},
2529 { "fdivr", ST
, STi
, XX
},
2533 { "fld", STi
, XX
, XX
},
2534 { "fxch", STi
, XX
, XX
},
2536 { "(bad)", XX
, XX
, XX
},
2544 { "fcmovb", ST
, STi
, XX
},
2545 { "fcmove", ST
, STi
, XX
},
2546 { "fcmovbe",ST
, STi
, XX
},
2547 { "fcmovu", ST
, STi
, XX
},
2548 { "(bad)", XX
, XX
, XX
},
2550 { "(bad)", XX
, XX
, XX
},
2551 { "(bad)", XX
, XX
, XX
},
2555 { "fcmovnb",ST
, STi
, XX
},
2556 { "fcmovne",ST
, STi
, XX
},
2557 { "fcmovnbe",ST
, STi
, XX
},
2558 { "fcmovnu",ST
, STi
, XX
},
2560 { "fucomi", ST
, STi
, XX
},
2561 { "fcomi", ST
, STi
, XX
},
2562 { "(bad)", XX
, XX
, XX
},
2566 { "fadd", STi
, ST
, XX
},
2567 { "fmul", STi
, ST
, XX
},
2568 { "(bad)", XX
, XX
, XX
},
2569 { "(bad)", XX
, XX
, XX
},
2571 { "fsub", STi
, ST
, XX
},
2572 { "fsubr", STi
, ST
, XX
},
2573 { "fdiv", STi
, ST
, XX
},
2574 { "fdivr", STi
, ST
, XX
},
2576 { "fsubr", STi
, ST
, XX
},
2577 { "fsub", STi
, ST
, XX
},
2578 { "fdivr", STi
, ST
, XX
},
2579 { "fdiv", STi
, ST
, XX
},
2584 { "ffree", STi
, XX
, XX
},
2585 { "(bad)", XX
, XX
, XX
},
2586 { "fst", STi
, XX
, XX
},
2587 { "fstp", STi
, XX
, XX
},
2588 { "fucom", STi
, XX
, XX
},
2589 { "fucomp", STi
, XX
, XX
},
2590 { "(bad)", XX
, XX
, XX
},
2591 { "(bad)", XX
, XX
, XX
},
2595 { "faddp", STi
, ST
, XX
},
2596 { "fmulp", STi
, ST
, XX
},
2597 { "(bad)", XX
, XX
, XX
},
2600 { "fsubp", STi
, ST
, XX
},
2601 { "fsubrp", STi
, ST
, XX
},
2602 { "fdivp", STi
, ST
, XX
},
2603 { "fdivrp", STi
, ST
, XX
},
2605 { "fsubrp", STi
, ST
, XX
},
2606 { "fsubp", STi
, ST
, XX
},
2607 { "fdivrp", STi
, ST
, XX
},
2608 { "fdivp", STi
, ST
, XX
},
2613 { "ffreep", STi
, XX
, XX
},
2614 { "(bad)", XX
, XX
, XX
},
2615 { "(bad)", XX
, XX
, XX
},
2616 { "(bad)", XX
, XX
, XX
},
2618 { "fucomip",ST
, STi
, XX
},
2619 { "fcomip", ST
, STi
, XX
},
2620 { "(bad)", XX
, XX
, XX
},
2624 static char *fgrps
[][8] = {
2627 "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2632 "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)",
2637 "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)",
2642 "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp",
2647 "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos",
2652 "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2657 "feni(287 only)","fdisi(287 only)","fNclex","fNinit",
2658 "fNsetpm(287 only)","(bad)","(bad)","(bad)",
2663 "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2668 "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)",
2676 const struct dis386
*dp
;
2677 unsigned char floatop
;
2679 floatop
= codep
[-1];
2683 putop (float_mem
[(floatop
- 0xd8) * 8 + reg
], sizeflag
);
2685 if (floatop
== 0xdb)
2686 OP_E (x_mode
, sizeflag
);
2687 else if (floatop
== 0xdd)
2688 OP_E (d_mode
, sizeflag
);
2690 OP_E (v_mode
, sizeflag
);
2693 /* Skip mod/rm byte. */
2697 dp
= &float_reg
[floatop
- 0xd8][reg
];
2698 if (dp
->name
== NULL
)
2700 putop (fgrps
[dp
->bytemode1
][rm
], sizeflag
);
2702 /* Instruction fnstsw is only one with strange arg. */
2703 if (floatop
== 0xdf && codep
[-1] == 0xe0)
2704 strcpy (op1out
, names16
[0]);
2708 putop (dp
->name
, sizeflag
);
2712 (*dp
->op1
) (dp
->bytemode1
, sizeflag
);
2715 (*dp
->op2
) (dp
->bytemode2
, sizeflag
);
2720 OP_ST (bytemode
, sizeflag
)
2721 int bytemode ATTRIBUTE_UNUSED
;
2722 int sizeflag ATTRIBUTE_UNUSED
;
2728 OP_STi (bytemode
, sizeflag
)
2729 int bytemode ATTRIBUTE_UNUSED
;
2730 int sizeflag ATTRIBUTE_UNUSED
;
2732 sprintf (scratchbuf
, "%%st(%d)", rm
);
2733 oappend (scratchbuf
+ intel_syntax
);
2736 /* Capital letters in template are macros. */
2738 putop (template, sizeflag
)
2739 const char *template;
2745 for (p
= template; *p
; p
++)
2764 /* Alternative not valid. */
2765 strcpy (obuf
, "(bad)");
2769 else if (*p
== '\0')
2787 if (mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
2793 if (sizeflag
& SUFFIX_ALWAYS
)
2796 case 'E': /* For jcxz/jecxz */
2799 if (sizeflag
& AFLAG
)
2805 if (sizeflag
& AFLAG
)
2807 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
2812 if ((prefixes
& PREFIX_ADDR
) || (sizeflag
& SUFFIX_ALWAYS
))
2814 if (sizeflag
& AFLAG
)
2815 *obufp
++ = mode_64bit
? 'q' : 'l';
2817 *obufp
++ = mode_64bit
? 'l' : 'w';
2818 used_prefixes
|= (prefixes
& PREFIX_ADDR
);
2824 if ((prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_CS
2825 || (prefixes
& (PREFIX_CS
| PREFIX_DS
)) == PREFIX_DS
)
2827 used_prefixes
|= prefixes
& (PREFIX_CS
| PREFIX_DS
);
2830 if (prefixes
& PREFIX_DS
)
2839 if (sizeflag
& SUFFIX_ALWAYS
)
2843 if ((prefixes
& PREFIX_FWAIT
) == 0)
2846 used_prefixes
|= PREFIX_FWAIT
;
2849 USED_REX (REX_MODE64
);
2850 if (rex
& REX_MODE64
)
2867 if ((prefixes
& PREFIX_DATA
)
2868 || (rex
& REX_MODE64
)
2869 || (sizeflag
& SUFFIX_ALWAYS
))
2871 USED_REX (REX_MODE64
);
2872 if (rex
& REX_MODE64
)
2876 if (sizeflag
& DFLAG
)
2880 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2896 USED_REX (REX_MODE64
);
2897 if (mod
!= 3 || (sizeflag
& SUFFIX_ALWAYS
))
2899 if (rex
& REX_MODE64
)
2903 if (sizeflag
& DFLAG
)
2907 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2912 USED_REX (REX_MODE64
);
2915 if (rex
& REX_MODE64
)
2920 else if (sizeflag
& DFLAG
)
2933 if (rex
& REX_MODE64
)
2935 else if (sizeflag
& DFLAG
)
2940 if (!(rex
& REX_MODE64
))
2941 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2946 if (sizeflag
& SUFFIX_ALWAYS
)
2948 if (rex
& REX_MODE64
)
2952 if (sizeflag
& DFLAG
)
2956 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2961 if (prefixes
& PREFIX_DATA
)
2965 used_prefixes
|= (prefixes
& PREFIX_DATA
);
2970 if (rex
& REX_MODE64
)
2972 USED_REX (REX_MODE64
);
2976 /* implicit operand size 'l' for i386 or 'q' for x86-64 */
2978 /* operand size flag for cwtl, cbtw */
2982 else if (sizeflag
& DFLAG
)
2993 if (sizeflag
& DFLAG
)
3004 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3017 obufp
+= strlen (s
);
3023 if (prefixes
& PREFIX_CS
)
3025 used_prefixes
|= PREFIX_CS
;
3026 oappend ("%cs:" + intel_syntax
);
3028 if (prefixes
& PREFIX_DS
)
3030 used_prefixes
|= PREFIX_DS
;
3031 oappend ("%ds:" + intel_syntax
);
3033 if (prefixes
& PREFIX_SS
)
3035 used_prefixes
|= PREFIX_SS
;
3036 oappend ("%ss:" + intel_syntax
);
3038 if (prefixes
& PREFIX_ES
)
3040 used_prefixes
|= PREFIX_ES
;
3041 oappend ("%es:" + intel_syntax
);
3043 if (prefixes
& PREFIX_FS
)
3045 used_prefixes
|= PREFIX_FS
;
3046 oappend ("%fs:" + intel_syntax
);
3048 if (prefixes
& PREFIX_GS
)
3050 used_prefixes
|= PREFIX_GS
;
3051 oappend ("%gs:" + intel_syntax
);
3056 OP_indirE (bytemode
, sizeflag
)
3062 OP_E (bytemode
, sizeflag
);
3066 print_operand_value (buf
, hex
, disp
)
3079 sprintf_vma (tmp
, disp
);
3080 for (i
= 0; tmp
[i
] == '0' && tmp
[i
+ 1]; i
++);
3081 strcpy (buf
+ 2, tmp
+ i
);
3085 bfd_signed_vma v
= disp
;
3092 /* Check for possible overflow on 0x8000000000000000. */
3095 strcpy (buf
, "9223372036854775808");
3109 tmp
[28 - i
] = (v
% 10) + '0';
3113 strcpy (buf
, tmp
+ 29 - i
);
3119 sprintf (buf
, "0x%x", (unsigned int) disp
);
3121 sprintf (buf
, "%d", (int) disp
);
3126 OP_E (bytemode
, sizeflag
)
3133 USED_REX (REX_EXTZ
);
3137 /* Skip mod/rm byte. */
3148 oappend (names8rex
[rm
+ add
]);
3150 oappend (names8
[rm
+ add
]);
3153 oappend (names16
[rm
+ add
]);
3156 oappend (names32
[rm
+ add
]);
3159 oappend (names64
[rm
+ add
]);
3163 oappend (names64
[rm
+ add
]);
3165 oappend (names32
[rm
+ add
]);
3168 USED_REX (REX_MODE64
);
3169 if (rex
& REX_MODE64
)
3170 oappend (names64
[rm
+ add
]);
3171 else if (sizeflag
& DFLAG
)
3172 oappend (names32
[rm
+ add
]);
3174 oappend (names16
[rm
+ add
]);
3175 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3178 if (!(codep
[-2] == 0xAE && codep
[-1] == 0xF8 /* sfence */)
3179 && !(codep
[-2] == 0xAE && codep
[-1] == 0xF0 /* mfence */)
3180 && !(codep
[-2] == 0xAE && codep
[-1] == 0xe8 /* lfence */))
3181 BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
3184 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3193 if ((sizeflag
& AFLAG
) || mode_64bit
) /* 32 bit address mode */
3208 FETCH_DATA (the_info
, codep
+ 1);
3209 scale
= (*codep
>> 6) & 3;
3210 index
= (*codep
>> 3) & 7;
3212 USED_REX (REX_EXTY
);
3213 USED_REX (REX_EXTZ
);
3224 if ((base
& 7) == 5)
3227 if (mode_64bit
&& !havesib
&& (sizeflag
& AFLAG
))
3233 FETCH_DATA (the_info
, codep
+ 1);
3235 if ((disp
& 0x80) != 0)
3244 if (mod
!= 0 || (base
& 7) == 5)
3246 print_operand_value (scratchbuf
, !riprel
, disp
);
3247 oappend (scratchbuf
);
3255 if (havebase
|| (havesib
&& (index
!= 4 || scale
!= 0)))
3262 oappend ("BYTE PTR ");
3265 oappend ("WORD PTR ");
3268 oappend ("DWORD PTR ");
3271 oappend ("QWORD PTR ");
3275 oappend ("DWORD PTR ");
3277 oappend ("QWORD PTR ");
3280 oappend ("XWORD PTR ");
3286 *obufp
++ = open_char
;
3287 if (intel_syntax
&& riprel
)
3290 USED_REX (REX_EXTZ
);
3291 if (!havesib
&& (rex
& REX_EXTZ
))
3294 oappend (mode_64bit
&& (sizeflag
& AFLAG
)
3295 ? names64
[base
] : names32
[base
]);
3304 *obufp
++ = separator_char
;
3307 sprintf (scratchbuf
, "%s",
3308 mode_64bit
&& (sizeflag
& AFLAG
)
3309 ? names64
[index
] : names32
[index
]);
3312 sprintf (scratchbuf
, ",%s",
3313 mode_64bit
&& (sizeflag
& AFLAG
)
3314 ? names64
[index
] : names32
[index
]);
3315 oappend (scratchbuf
);
3319 && bytemode
!= b_mode
3320 && bytemode
!= w_mode
3321 && bytemode
!= v_mode
))
3323 *obufp
++ = scale_char
;
3325 sprintf (scratchbuf
, "%d", 1 << scale
);
3326 oappend (scratchbuf
);
3330 if (mod
!= 0 || (base
& 7) == 5)
3332 /* Don't print zero displacements. */
3335 if ((bfd_signed_vma
) disp
> 0)
3341 print_operand_value (scratchbuf
, 0, disp
);
3342 oappend (scratchbuf
);
3346 *obufp
++ = close_char
;
3349 else if (intel_syntax
)
3351 if (mod
!= 0 || (base
& 7) == 5)
3353 if (prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
3354 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
))
3358 oappend (names_seg
[ds_reg
- es_reg
]);
3361 print_operand_value (scratchbuf
, 1, disp
);
3362 oappend (scratchbuf
);
3367 { /* 16 bit address mode */
3374 if ((disp
& 0x8000) != 0)
3379 FETCH_DATA (the_info
, codep
+ 1);
3381 if ((disp
& 0x80) != 0)
3386 if ((disp
& 0x8000) != 0)
3392 if (mod
!= 0 || (rm
& 7) == 6)
3394 print_operand_value (scratchbuf
, 0, disp
);
3395 oappend (scratchbuf
);
3398 if (mod
!= 0 || (rm
& 7) != 6)
3400 *obufp
++ = open_char
;
3402 oappend (index16
[rm
+ add
]);
3403 *obufp
++ = close_char
;
3410 OP_G (bytemode
, sizeflag
)
3415 USED_REX (REX_EXTX
);
3423 oappend (names8rex
[reg
+ add
]);
3425 oappend (names8
[reg
+ add
]);
3428 oappend (names16
[reg
+ add
]);
3431 oappend (names32
[reg
+ add
]);
3434 oappend (names64
[reg
+ add
]);
3437 USED_REX (REX_MODE64
);
3438 if (rex
& REX_MODE64
)
3439 oappend (names64
[reg
+ add
]);
3440 else if (sizeflag
& DFLAG
)
3441 oappend (names32
[reg
+ add
]);
3443 oappend (names16
[reg
+ add
]);
3444 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3447 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3460 FETCH_DATA (the_info
, codep
+ 8);
3461 a
= *codep
++ & 0xff;
3462 a
|= (*codep
++ & 0xff) << 8;
3463 a
|= (*codep
++ & 0xff) << 16;
3464 a
|= (*codep
++ & 0xff) << 24;
3465 b
= *codep
++ & 0xff;
3466 b
|= (*codep
++ & 0xff) << 8;
3467 b
|= (*codep
++ & 0xff) << 16;
3468 b
|= (*codep
++ & 0xff) << 24;
3469 x
= a
+ ((bfd_vma
) b
<< 32);
3477 static bfd_signed_vma
3480 bfd_signed_vma x
= 0;
3482 FETCH_DATA (the_info
, codep
+ 4);
3483 x
= *codep
++ & (bfd_signed_vma
) 0xff;
3484 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
3485 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
3486 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
3490 static bfd_signed_vma
3493 bfd_signed_vma x
= 0;
3495 FETCH_DATA (the_info
, codep
+ 4);
3496 x
= *codep
++ & (bfd_signed_vma
) 0xff;
3497 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 8;
3498 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 16;
3499 x
|= (*codep
++ & (bfd_signed_vma
) 0xff) << 24;
3501 x
= (x
^ ((bfd_signed_vma
) 1 << 31)) - ((bfd_signed_vma
) 1 << 31);
3511 FETCH_DATA (the_info
, codep
+ 2);
3512 x
= *codep
++ & 0xff;
3513 x
|= (*codep
++ & 0xff) << 8;
3522 op_index
[op_ad
] = op_ad
;
3525 op_address
[op_ad
] = op
;
3526 op_riprel
[op_ad
] = riprel
;
3530 /* Mask to get a 32-bit address. */
3531 op_address
[op_ad
] = op
& 0xffffffff;
3532 op_riprel
[op_ad
] = riprel
& 0xffffffff;
3537 OP_REG (code
, sizeflag
)
3543 USED_REX (REX_EXTZ
);
3555 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
3556 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
3557 s
= names16
[code
- ax_reg
+ add
];
3559 case es_reg
: case ss_reg
: case cs_reg
:
3560 case ds_reg
: case fs_reg
: case gs_reg
:
3561 s
= names_seg
[code
- es_reg
+ add
];
3563 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
3564 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
3567 s
= names8rex
[code
- al_reg
+ add
];
3569 s
= names8
[code
- al_reg
];
3571 case rAX_reg
: case rCX_reg
: case rDX_reg
: case rBX_reg
:
3572 case rSP_reg
: case rBP_reg
: case rSI_reg
: case rDI_reg
:
3575 s
= names64
[code
- rAX_reg
+ add
];
3578 code
+= eAX_reg
- rAX_reg
;
3580 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
3581 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
3582 USED_REX (REX_MODE64
);
3583 if (rex
& REX_MODE64
)
3584 s
= names64
[code
- eAX_reg
+ add
];
3585 else if (sizeflag
& DFLAG
)
3586 s
= names32
[code
- eAX_reg
+ add
];
3588 s
= names16
[code
- eAX_reg
+ add
];
3589 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3592 s
= INTERNAL_DISASSEMBLER_ERROR
;
3599 OP_IMREG (code
, sizeflag
)
3613 case ax_reg
: case cx_reg
: case dx_reg
: case bx_reg
:
3614 case sp_reg
: case bp_reg
: case si_reg
: case di_reg
:
3615 s
= names16
[code
- ax_reg
];
3617 case es_reg
: case ss_reg
: case cs_reg
:
3618 case ds_reg
: case fs_reg
: case gs_reg
:
3619 s
= names_seg
[code
- es_reg
];
3621 case al_reg
: case ah_reg
: case cl_reg
: case ch_reg
:
3622 case dl_reg
: case dh_reg
: case bl_reg
: case bh_reg
:
3625 s
= names8rex
[code
- al_reg
];
3627 s
= names8
[code
- al_reg
];
3629 case eAX_reg
: case eCX_reg
: case eDX_reg
: case eBX_reg
:
3630 case eSP_reg
: case eBP_reg
: case eSI_reg
: case eDI_reg
:
3631 USED_REX (REX_MODE64
);
3632 if (rex
& REX_MODE64
)
3633 s
= names64
[code
- eAX_reg
];
3634 else if (sizeflag
& DFLAG
)
3635 s
= names32
[code
- eAX_reg
];
3637 s
= names16
[code
- eAX_reg
];
3638 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3641 s
= INTERNAL_DISASSEMBLER_ERROR
;
3648 OP_I (bytemode
, sizeflag
)
3653 bfd_signed_vma mask
= -1;
3658 FETCH_DATA (the_info
, codep
+ 1);
3670 USED_REX (REX_MODE64
);
3671 if (rex
& REX_MODE64
)
3673 else if (sizeflag
& DFLAG
)
3683 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3690 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3695 scratchbuf
[0] = '$';
3696 print_operand_value (scratchbuf
+ 1, 1, op
);
3697 oappend (scratchbuf
+ intel_syntax
);
3698 scratchbuf
[0] = '\0';
3702 OP_I64 (bytemode
, sizeflag
)
3707 bfd_signed_vma mask
= -1;
3711 OP_I (bytemode
, sizeflag
);
3718 FETCH_DATA (the_info
, codep
+ 1);
3723 USED_REX (REX_MODE64
);
3724 if (rex
& REX_MODE64
)
3726 else if (sizeflag
& DFLAG
)
3736 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3743 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3748 scratchbuf
[0] = '$';
3749 print_operand_value (scratchbuf
+ 1, 1, op
);
3750 oappend (scratchbuf
+ intel_syntax
);
3751 scratchbuf
[0] = '\0';
3755 OP_sI (bytemode
, sizeflag
)
3760 bfd_signed_vma mask
= -1;
3765 FETCH_DATA (the_info
, codep
+ 1);
3767 if ((op
& 0x80) != 0)
3772 USED_REX (REX_MODE64
);
3773 if (rex
& REX_MODE64
)
3775 else if (sizeflag
& DFLAG
)
3784 if ((op
& 0x8000) != 0)
3787 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3792 if ((op
& 0x8000) != 0)
3796 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3800 scratchbuf
[0] = '$';
3801 print_operand_value (scratchbuf
+ 1, 1, op
);
3802 oappend (scratchbuf
+ intel_syntax
);
3806 OP_J (bytemode
, sizeflag
)
3816 FETCH_DATA (the_info
, codep
+ 1);
3818 if ((disp
& 0x80) != 0)
3822 if (sizeflag
& DFLAG
)
3827 /* For some reason, a data16 prefix on a jump instruction
3828 means that the pc is masked to 16 bits after the
3829 displacement is added! */
3834 oappend (INTERNAL_DISASSEMBLER_ERROR
);
3837 disp
= (start_pc
+ codep
- start_codep
+ disp
) & mask
;
3839 print_operand_value (scratchbuf
, 1, disp
);
3840 oappend (scratchbuf
);
3844 OP_SEG (dummy
, sizeflag
)
3845 int dummy ATTRIBUTE_UNUSED
;
3846 int sizeflag ATTRIBUTE_UNUSED
;
3848 oappend (names_seg
[reg
]);
3852 OP_DIR (dummy
, sizeflag
)
3853 int dummy ATTRIBUTE_UNUSED
;
3858 if (sizeflag
& DFLAG
)
3868 used_prefixes
|= (prefixes
& PREFIX_DATA
);
3870 sprintf (scratchbuf
, "0x%x,0x%x", seg
, offset
);
3872 sprintf (scratchbuf
, "$0x%x,$0x%x", seg
, offset
);
3873 oappend (scratchbuf
);
3877 OP_OFF (bytemode
, sizeflag
)
3878 int bytemode ATTRIBUTE_UNUSED
;
3885 if ((sizeflag
& AFLAG
) || mode_64bit
)
3892 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
3893 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
3895 oappend (names_seg
[ds_reg
- es_reg
]);
3899 print_operand_value (scratchbuf
, 1, off
);
3900 oappend (scratchbuf
);
3904 OP_OFF64 (bytemode
, sizeflag
)
3905 int bytemode ATTRIBUTE_UNUSED
;
3906 int sizeflag ATTRIBUTE_UNUSED
;
3912 OP_OFF (bytemode
, sizeflag
);
3922 if (!(prefixes
& (PREFIX_CS
| PREFIX_SS
| PREFIX_DS
3923 | PREFIX_ES
| PREFIX_FS
| PREFIX_GS
)))
3925 oappend (names_seg
[ds_reg
- es_reg
]);
3929 print_operand_value (scratchbuf
, 1, off
);
3930 oappend (scratchbuf
);
3934 ptr_reg (code
, sizeflag
)
3944 USED_REX (REX_MODE64
);
3945 if (rex
& REX_MODE64
)
3947 if (!(sizeflag
& AFLAG
))
3948 s
= names32
[code
- eAX_reg
];
3950 s
= names64
[code
- eAX_reg
];
3952 else if (sizeflag
& AFLAG
)
3953 s
= names32
[code
- eAX_reg
];
3955 s
= names16
[code
- eAX_reg
];
3964 OP_ESreg (code
, sizeflag
)
3968 oappend ("%es:" + intel_syntax
);
3969 ptr_reg (code
, sizeflag
);
3973 OP_DSreg (code
, sizeflag
)
3984 prefixes
|= PREFIX_DS
;
3986 ptr_reg (code
, sizeflag
);
3990 OP_C (dummy
, sizeflag
)
3991 int dummy ATTRIBUTE_UNUSED
;
3992 int sizeflag ATTRIBUTE_UNUSED
;
3995 USED_REX (REX_EXTX
);
3998 sprintf (scratchbuf
, "%%cr%d", reg
+ add
);
3999 oappend (scratchbuf
+ intel_syntax
);
4003 OP_D (dummy
, sizeflag
)
4004 int dummy ATTRIBUTE_UNUSED
;
4005 int sizeflag ATTRIBUTE_UNUSED
;
4008 USED_REX (REX_EXTX
);
4012 sprintf (scratchbuf
, "db%d", reg
+ add
);
4014 sprintf (scratchbuf
, "%%db%d", reg
+ add
);
4015 oappend (scratchbuf
);
4019 OP_T (dummy
, sizeflag
)
4020 int dummy ATTRIBUTE_UNUSED
;
4021 int sizeflag ATTRIBUTE_UNUSED
;
4023 sprintf (scratchbuf
, "%%tr%d", reg
);
4024 oappend (scratchbuf
+ intel_syntax
);
4028 OP_Rd (bytemode
, sizeflag
)
4033 OP_E (bytemode
, sizeflag
);
4039 OP_MMX (bytemode
, sizeflag
)
4040 int bytemode ATTRIBUTE_UNUSED
;
4041 int sizeflag ATTRIBUTE_UNUSED
;
4044 USED_REX (REX_EXTX
);
4047 used_prefixes
|= (prefixes
& PREFIX_DATA
);
4048 if (prefixes
& PREFIX_DATA
)
4049 sprintf (scratchbuf
, "%%xmm%d", reg
+ add
);
4051 sprintf (scratchbuf
, "%%mm%d", reg
+ add
);
4052 oappend (scratchbuf
+ intel_syntax
);
4056 OP_XMM (bytemode
, sizeflag
)
4057 int bytemode ATTRIBUTE_UNUSED
;
4058 int sizeflag ATTRIBUTE_UNUSED
;
4061 USED_REX (REX_EXTX
);
4064 sprintf (scratchbuf
, "%%xmm%d", reg
+ add
);
4065 oappend (scratchbuf
+ intel_syntax
);
4069 OP_EM (bytemode
, sizeflag
)
4076 OP_E (bytemode
, sizeflag
);
4079 USED_REX (REX_EXTZ
);
4083 /* Skip mod/rm byte. */
4086 used_prefixes
|= (prefixes
& PREFIX_DATA
);
4087 if (prefixes
& PREFIX_DATA
)
4088 sprintf (scratchbuf
, "%%xmm%d", rm
+ add
);
4090 sprintf (scratchbuf
, "%%mm%d", rm
+ add
);
4091 oappend (scratchbuf
+ intel_syntax
);
4095 OP_EX (bytemode
, sizeflag
)
4102 OP_E (bytemode
, sizeflag
);
4105 USED_REX (REX_EXTZ
);
4109 /* Skip mod/rm byte. */
4112 sprintf (scratchbuf
, "%%xmm%d", rm
+ add
);
4113 oappend (scratchbuf
+ intel_syntax
);
4117 OP_MS (bytemode
, sizeflag
)
4122 OP_EM (bytemode
, sizeflag
);
4128 OP_XS (bytemode
, sizeflag
)
4133 OP_EX (bytemode
, sizeflag
);
4138 static const char *Suffix3DNow
[] = {
4139 /* 00 */ NULL
, NULL
, NULL
, NULL
,
4140 /* 04 */ NULL
, NULL
, NULL
, NULL
,
4141 /* 08 */ NULL
, NULL
, NULL
, NULL
,
4142 /* 0C */ "pi2fw", "pi2fd", NULL
, NULL
,
4143 /* 10 */ NULL
, NULL
, NULL
, NULL
,
4144 /* 14 */ NULL
, NULL
, NULL
, NULL
,
4145 /* 18 */ NULL
, NULL
, NULL
, NULL
,
4146 /* 1C */ "pf2iw", "pf2id", NULL
, NULL
,
4147 /* 20 */ NULL
, NULL
, NULL
, NULL
,
4148 /* 24 */ NULL
, NULL
, NULL
, NULL
,
4149 /* 28 */ NULL
, NULL
, NULL
, NULL
,
4150 /* 2C */ NULL
, NULL
, NULL
, NULL
,
4151 /* 30 */ NULL
, NULL
, NULL
, NULL
,
4152 /* 34 */ NULL
, NULL
, NULL
, NULL
,
4153 /* 38 */ NULL
, NULL
, NULL
, NULL
,
4154 /* 3C */ NULL
, NULL
, NULL
, NULL
,
4155 /* 40 */ NULL
, NULL
, NULL
, NULL
,
4156 /* 44 */ NULL
, NULL
, NULL
, NULL
,
4157 /* 48 */ NULL
, NULL
, NULL
, NULL
,
4158 /* 4C */ NULL
, NULL
, NULL
, NULL
,
4159 /* 50 */ NULL
, NULL
, NULL
, NULL
,
4160 /* 54 */ NULL
, NULL
, NULL
, NULL
,
4161 /* 58 */ NULL
, NULL
, NULL
, NULL
,
4162 /* 5C */ NULL
, NULL
, NULL
, NULL
,
4163 /* 60 */ NULL
, NULL
, NULL
, NULL
,
4164 /* 64 */ NULL
, NULL
, NULL
, NULL
,
4165 /* 68 */ NULL
, NULL
, NULL
, NULL
,
4166 /* 6C */ NULL
, NULL
, NULL
, NULL
,
4167 /* 70 */ NULL
, NULL
, NULL
, NULL
,
4168 /* 74 */ NULL
, NULL
, NULL
, NULL
,
4169 /* 78 */ NULL
, NULL
, NULL
, NULL
,
4170 /* 7C */ NULL
, NULL
, NULL
, NULL
,
4171 /* 80 */ NULL
, NULL
, NULL
, NULL
,
4172 /* 84 */ NULL
, NULL
, NULL
, NULL
,
4173 /* 88 */ NULL
, NULL
, "pfnacc", NULL
,
4174 /* 8C */ NULL
, NULL
, "pfpnacc", NULL
,
4175 /* 90 */ "pfcmpge", NULL
, NULL
, NULL
,
4176 /* 94 */ "pfmin", NULL
, "pfrcp", "pfrsqrt",
4177 /* 98 */ NULL
, NULL
, "pfsub", NULL
,
4178 /* 9C */ NULL
, NULL
, "pfadd", NULL
,
4179 /* A0 */ "pfcmpgt", NULL
, NULL
, NULL
,
4180 /* A4 */ "pfmax", NULL
, "pfrcpit1", "pfrsqit1",
4181 /* A8 */ NULL
, NULL
, "pfsubr", NULL
,
4182 /* AC */ NULL
, NULL
, "pfacc", NULL
,
4183 /* B0 */ "pfcmpeq", NULL
, NULL
, NULL
,
4184 /* B4 */ "pfmul", NULL
, "pfrcpit2", "pfmulhrw",
4185 /* B8 */ NULL
, NULL
, NULL
, "pswapd",
4186 /* BC */ NULL
, NULL
, NULL
, "pavgusb",
4187 /* C0 */ NULL
, NULL
, NULL
, NULL
,
4188 /* C4 */ NULL
, NULL
, NULL
, NULL
,
4189 /* C8 */ NULL
, NULL
, NULL
, NULL
,
4190 /* CC */ NULL
, NULL
, NULL
, NULL
,
4191 /* D0 */ NULL
, NULL
, NULL
, NULL
,
4192 /* D4 */ NULL
, NULL
, NULL
, NULL
,
4193 /* D8 */ NULL
, NULL
, NULL
, NULL
,
4194 /* DC */ NULL
, NULL
, NULL
, NULL
,
4195 /* E0 */ NULL
, NULL
, NULL
, NULL
,
4196 /* E4 */ NULL
, NULL
, NULL
, NULL
,
4197 /* E8 */ NULL
, NULL
, NULL
, NULL
,
4198 /* EC */ NULL
, NULL
, NULL
, NULL
,
4199 /* F0 */ NULL
, NULL
, NULL
, NULL
,
4200 /* F4 */ NULL
, NULL
, NULL
, NULL
,
4201 /* F8 */ NULL
, NULL
, NULL
, NULL
,
4202 /* FC */ NULL
, NULL
, NULL
, NULL
,
4206 OP_3DNowSuffix (bytemode
, sizeflag
)
4207 int bytemode ATTRIBUTE_UNUSED
;
4208 int sizeflag ATTRIBUTE_UNUSED
;
4210 const char *mnemonic
;
4212 FETCH_DATA (the_info
, codep
+ 1);
4213 /* AMD 3DNow! instructions are specified by an opcode suffix in the
4214 place where an 8-bit immediate would normally go. ie. the last
4215 byte of the instruction. */
4216 obufp
= obuf
+ strlen (obuf
);
4217 mnemonic
= Suffix3DNow
[*codep
++ & 0xff];
4222 /* Since a variable sized modrm/sib chunk is between the start
4223 of the opcode (0x0f0f) and the opcode suffix, we need to do
4224 all the modrm processing first, and don't know until now that
4225 we have a bad opcode. This necessitates some cleaning up. */
4232 static const char *simd_cmp_op
[] = {
4244 OP_SIMD_Suffix (bytemode
, sizeflag
)
4245 int bytemode ATTRIBUTE_UNUSED
;
4246 int sizeflag ATTRIBUTE_UNUSED
;
4248 unsigned int cmp_type
;
4250 FETCH_DATA (the_info
, codep
+ 1);
4251 obufp
= obuf
+ strlen (obuf
);
4252 cmp_type
= *codep
++ & 0xff;
4255 char suffix1
= 'p', suffix2
= 's';
4256 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
4257 if (prefixes
& PREFIX_REPZ
)
4261 used_prefixes
|= (prefixes
& PREFIX_DATA
);
4262 if (prefixes
& PREFIX_DATA
)
4266 used_prefixes
|= (prefixes
& PREFIX_REPNZ
);
4267 if (prefixes
& PREFIX_REPNZ
)
4268 suffix1
= 's', suffix2
= 'd';
4271 sprintf (scratchbuf
, "cmp%s%c%c",
4272 simd_cmp_op
[cmp_type
], suffix1
, suffix2
);
4273 used_prefixes
|= (prefixes
& PREFIX_REPZ
);
4274 oappend (scratchbuf
);
4278 /* We have a bad extension byte. Clean up. */
4286 SIMD_Fixup (extrachar
, sizeflag
)
4288 int sizeflag ATTRIBUTE_UNUSED
;
4290 /* Change movlps/movhps to movhlps/movlhps for 2 register operand
4291 forms of these instructions. */
4294 char *p
= obuf
+ strlen (obuf
);
4297 *(p
- 1) = *(p
- 2);
4298 *(p
- 2) = *(p
- 3);
4299 *(p
- 3) = extrachar
;
4306 /* Throw away prefixes and 1st. opcode byte. */
4307 codep
= insn_codep
+ 1;