Back to index

cell-binutils  2.17cvs20070401
Classes | Defines | Typedefs | Enumerations | Functions | Variables
i386-dis.c File Reference
#include "dis-asm.h"
#include "sysdep.h"
#include "opintl.h"
#include "opcode/i386.h"
#include <setjmp.h>

Go to the source code of this file.

Classes

struct  dis_private
struct  dis386
struct  dis386.op

Defines

#define USED_REX(value)
#define PREFIX_REPZ   1
#define PREFIX_REPNZ   2
#define PREFIX_LOCK   4
#define PREFIX_CS   8
#define PREFIX_SS   0x10
#define PREFIX_DS   0x20
#define PREFIX_ES   0x40
#define PREFIX_FS   0x80
#define PREFIX_GS   0x100
#define PREFIX_DATA   0x200
#define PREFIX_ADDR   0x400
#define PREFIX_FWAIT   0x800
#define FETCH_DATA(info, addr)
#define XX   { NULL, 0 }
#define Eb   { OP_E, b_mode }
#define Ev   { OP_E, v_mode }
#define Ed   { OP_E, d_mode }
#define Edq   { OP_E, dq_mode }
#define Edqw   { OP_E, dqw_mode }
#define indirEv   { OP_indirE, stack_v_mode }
#define indirEp   { OP_indirE, f_mode }
#define stackEv   { OP_E, stack_v_mode }
#define Em   { OP_E, m_mode }
#define Ew   { OP_E, w_mode }
#define M   { OP_M, 0 } /* lea, lgdt, etc. */
#define Ma   { OP_M, v_mode }
#define Mp   { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */
#define Mq   { OP_M, q_mode }
#define Gb   { OP_G, b_mode }
#define Gv   { OP_G, v_mode }
#define Gd   { OP_G, d_mode }
#define Gdq   { OP_G, dq_mode }
#define Gm   { OP_G, m_mode }
#define Gw   { OP_G, w_mode }
#define Rd   { OP_R, d_mode }
#define Rm   { OP_R, m_mode }
#define Ib   { OP_I, b_mode }
#define sIb   { OP_sI, b_mode } /* sign extened byte */
#define Iv   { OP_I, v_mode }
#define Iq   { OP_I, q_mode }
#define Iv64   { OP_I64, v_mode }
#define Iw   { OP_I, w_mode }
#define I1   { OP_I, const_1_mode }
#define Jb   { OP_J, b_mode }
#define Jv   { OP_J, v_mode }
#define Cm   { OP_C, m_mode }
#define Dm   { OP_D, m_mode }
#define Td   { OP_T, d_mode }
#define RMeAX   { OP_REG, eAX_reg }
#define RMeBX   { OP_REG, eBX_reg }
#define RMeCX   { OP_REG, eCX_reg }
#define RMeDX   { OP_REG, eDX_reg }
#define RMeSP   { OP_REG, eSP_reg }
#define RMeBP   { OP_REG, eBP_reg }
#define RMeSI   { OP_REG, eSI_reg }
#define RMeDI   { OP_REG, eDI_reg }
#define RMrAX   { OP_REG, rAX_reg }
#define RMrBX   { OP_REG, rBX_reg }
#define RMrCX   { OP_REG, rCX_reg }
#define RMrDX   { OP_REG, rDX_reg }
#define RMrSP   { OP_REG, rSP_reg }
#define RMrBP   { OP_REG, rBP_reg }
#define RMrSI   { OP_REG, rSI_reg }
#define RMrDI   { OP_REG, rDI_reg }
#define RMAL   { OP_REG, al_reg }
#define RMAL   { OP_REG, al_reg }
#define RMCL   { OP_REG, cl_reg }
#define RMDL   { OP_REG, dl_reg }
#define RMBL   { OP_REG, bl_reg }
#define RMAH   { OP_REG, ah_reg }
#define RMCH   { OP_REG, ch_reg }
#define RMDH   { OP_REG, dh_reg }
#define RMBH   { OP_REG, bh_reg }
#define RMAX   { OP_REG, ax_reg }
#define RMDX   { OP_REG, dx_reg }
#define eAX   { OP_IMREG, eAX_reg }
#define eBX   { OP_IMREG, eBX_reg }
#define eCX   { OP_IMREG, eCX_reg }
#define eDX   { OP_IMREG, eDX_reg }
#define eSP   { OP_IMREG, eSP_reg }
#define eBP   { OP_IMREG, eBP_reg }
#define eSI   { OP_IMREG, eSI_reg }
#define eDI   { OP_IMREG, eDI_reg }
#define AL   { OP_IMREG, al_reg }
#define CL   { OP_IMREG, cl_reg }
#define DL   { OP_IMREG, dl_reg }
#define BL   { OP_IMREG, bl_reg }
#define AH   { OP_IMREG, ah_reg }
#define CH   { OP_IMREG, ch_reg }
#define DH   { OP_IMREG, dh_reg }
#define BH   { OP_IMREG, bh_reg }
#define AX   { OP_IMREG, ax_reg }
#define DX   { OP_IMREG, dx_reg }
#define zAX   { OP_IMREG, z_mode_ax_reg }
#define indirDX   { OP_IMREG, indir_dx_reg }
#define Sw   { OP_SEG, w_mode }
#define Sv   { OP_SEG, v_mode }
#define Ap   { OP_DIR, 0 }
#define Ob   { OP_OFF64, b_mode }
#define Ov   { OP_OFF64, v_mode }
#define Xb   { OP_DSreg, eSI_reg }
#define Xv   { OP_DSreg, eSI_reg }
#define Xz   { OP_DSreg, eSI_reg }
#define Yb   { OP_ESreg, eDI_reg }
#define Yv   { OP_ESreg, eDI_reg }
#define DSBX   { OP_DSreg, eBX_reg }
#define es   { OP_REG, es_reg }
#define ss   { OP_REG, ss_reg }
#define cs   { OP_REG, cs_reg }
#define ds   { OP_REG, ds_reg }
#define fs   { OP_REG, fs_reg }
#define gs   { OP_REG, gs_reg }
#define MX   { OP_MMX, 0 }
#define XM   { OP_XMM, 0 }
#define EM   { OP_EM, v_mode }
#define EX   { OP_EX, v_mode }
#define MS   { OP_MS, v_mode }
#define XS   { OP_XS, v_mode }
#define EMC   { OP_EMC, v_mode }
#define MXC   { OP_MXC, 0 }
#define VM   { OP_VMX, q_mode }
#define OPSUF   { OP_3DNowSuffix, 0 }
#define OPSIMD   { OP_SIMD_Suffix, 0 }
#define Xbr   { REP_Fixup, eSI_reg }
#define Xvr   { REP_Fixup, eSI_reg }
#define Ybr   { REP_Fixup, eDI_reg }
#define Yvr   { REP_Fixup, eDI_reg }
#define Yzr   { REP_Fixup, eDI_reg }
#define indirDXr   { REP_Fixup, indir_dx_reg }
#define ALr   { REP_Fixup, al_reg }
#define eAXr   { REP_Fixup, eAX_reg }
#define cond_jump_flag   { NULL, cond_jump_mode }
#define loop_jcxz_flag   { NULL, loop_jcxz_mode }
#define SUFFIX_ALWAYS   4
#define AFLAG   2
#define DFLAG   1
#define b_mode   1 /* byte operand */
#define v_mode   2 /* operand size depends on prefixes */
#define w_mode   3 /* word operand */
#define d_mode   4 /* double word operand */
#define q_mode   5 /* quad word operand */
#define t_mode   6 /* ten-byte operand */
#define x_mode   7 /* 16-byte XMM operand */
#define m_mode   8 /* d_mode in 32bit, q_mode in 64bit mode. */
#define cond_jump_mode   9
#define loop_jcxz_mode   10
#define dq_mode   11 /* operand size depends on REX prefixes. */
#define dqw_mode   12 /* registers like dq_mode, memory like w_mode. */
#define f_mode   13 /* 4- or 6-byte pointer operand */
#define const_1_mode   14
#define stack_v_mode   15 /* v_mode for stack-related opcodes. */
#define z_mode   16 /* non-quad operand size depends on prefixes */
#define o_mode   17 /* 16-byte operand */
#define es_reg   100
#define cs_reg   101
#define ss_reg   102
#define ds_reg   103
#define fs_reg   104
#define gs_reg   105
#define eAX_reg   108
#define eCX_reg   109
#define eDX_reg   110
#define eBX_reg   111
#define eSP_reg   112
#define eBP_reg   113
#define eSI_reg   114
#define eDI_reg   115
#define al_reg   116
#define cl_reg   117
#define dl_reg   118
#define bl_reg   119
#define ah_reg   120
#define ch_reg   121
#define dh_reg   122
#define bh_reg   123
#define ax_reg   124
#define cx_reg   125
#define dx_reg   126
#define bx_reg   127
#define sp_reg   128
#define bp_reg   129
#define si_reg   130
#define di_reg   131
#define rAX_reg   132
#define rCX_reg   133
#define rDX_reg   134
#define rBX_reg   135
#define rSP_reg   136
#define rBP_reg   137
#define rSI_reg   138
#define rDI_reg   139
#define z_mode_ax_reg   149
#define indir_dx_reg   150
#define FLOATCODE   1
#define USE_GROUPS   2
#define USE_PREFIX_USER_TABLE   3
#define X86_64_SPECIAL   4
#define IS_3BYTE_OPCODE   5
#define FLOAT   NULL, { { NULL, FLOATCODE } }
#define GRP1b   NULL, { { NULL, USE_GROUPS }, { NULL, 0 } }
#define GRP1S   NULL, { { NULL, USE_GROUPS }, { NULL, 1 } }
#define GRP1Ss   NULL, { { NULL, USE_GROUPS }, { NULL, 2 } }
#define GRP2b   NULL, { { NULL, USE_GROUPS }, { NULL, 3 } }
#define GRP2S   NULL, { { NULL, USE_GROUPS }, { NULL, 4 } }
#define GRP2b_one   NULL, { { NULL, USE_GROUPS }, { NULL, 5 } }
#define GRP2S_one   NULL, { { NULL, USE_GROUPS }, { NULL, 6 } }
#define GRP2b_cl   NULL, { { NULL, USE_GROUPS }, { NULL, 7 } }
#define GRP2S_cl   NULL, { { NULL, USE_GROUPS }, { NULL, 8 } }
#define GRP3b   NULL, { { NULL, USE_GROUPS }, { NULL, 9 } }
#define GRP3S   NULL, { { NULL, USE_GROUPS }, { NULL, 10 } }
#define GRP4   NULL, { { NULL, USE_GROUPS }, { NULL, 11 } }
#define GRP5   NULL, { { NULL, USE_GROUPS }, { NULL, 12 } }
#define GRP6   NULL, { { NULL, USE_GROUPS }, { NULL, 13 } }
#define GRP7   NULL, { { NULL, USE_GROUPS }, { NULL, 14 } }
#define GRP8   NULL, { { NULL, USE_GROUPS }, { NULL, 15 } }
#define GRP9   NULL, { { NULL, USE_GROUPS }, { NULL, 16 } }
#define GRP11_C6   NULL, { { NULL, USE_GROUPS }, { NULL, 17 } }
#define GRP11_C7   NULL, { { NULL, USE_GROUPS }, { NULL, 18 } }
#define GRP12   NULL, { { NULL, USE_GROUPS }, { NULL, 19 } }
#define GRP13   NULL, { { NULL, USE_GROUPS }, { NULL, 20 } }
#define GRP14   NULL, { { NULL, USE_GROUPS }, { NULL, 21 } }
#define GRP15   NULL, { { NULL, USE_GROUPS }, { NULL, 22 } }
#define GRP16   NULL, { { NULL, USE_GROUPS }, { NULL, 23 } }
#define GRPAMD   NULL, { { NULL, USE_GROUPS }, { NULL, 24 } }
#define GRPPADLCK1   NULL, { { NULL, USE_GROUPS }, { NULL, 25 } }
#define GRPPADLCK2   NULL, { { NULL, USE_GROUPS }, { NULL, 26 } }
#define PREGRP0   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } }
#define PREGRP1   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } }
#define PREGRP2   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } }
#define PREGRP3   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } }
#define PREGRP4   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } }
#define PREGRP5   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } }
#define PREGRP6   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } }
#define PREGRP7   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } }
#define PREGRP8   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } }
#define PREGRP9   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } }
#define PREGRP10   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } }
#define PREGRP11   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } }
#define PREGRP12   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } }
#define PREGRP13   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } }
#define PREGRP14   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } }
#define PREGRP15   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } }
#define PREGRP16   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } }
#define PREGRP17   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } }
#define PREGRP18   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } }
#define PREGRP19   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } }
#define PREGRP20   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } }
#define PREGRP21   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } }
#define PREGRP22   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } }
#define PREGRP23   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } }
#define PREGRP24   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } }
#define PREGRP25   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } }
#define PREGRP26   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } }
#define PREGRP27   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } }
#define PREGRP28   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } }
#define PREGRP29   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } }
#define PREGRP30   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } }
#define PREGRP31   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } }
#define PREGRP32   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } }
#define PREGRP33   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } }
#define PREGRP34   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } }
#define PREGRP35   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } }
#define PREGRP36   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } }
#define PREGRP37   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } }
#define PREGRP38   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } }
#define X86_64_0   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }
#define X86_64_1   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }
#define X86_64_2   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }
#define X86_64_3   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }
#define THREE_BYTE_0   NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }
#define THREE_BYTE_1   NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }
#define MODRM_CHECK   if (!need_modrm) abort ()
#define INTERNAL_DISASSEMBLER_ERROR   _("<internal disassembler error>")
#define ST   { OP_ST, 0 }
#define STi   { OP_STi, 0 }
#define FGRPd9_2   NULL, { { NULL, 0 } }
#define FGRPd9_4   NULL, { { NULL, 1 } }
#define FGRPd9_5   NULL, { { NULL, 2 } }
#define FGRPd9_6   NULL, { { NULL, 3 } }
#define FGRPd9_7   NULL, { { NULL, 4 } }
#define FGRPda_5   NULL, { { NULL, 5 } }
#define FGRPdb_4   NULL, { { NULL, 6 } }
#define FGRPde_3   NULL, { { NULL, 7 } }
#define FGRPdf_4   NULL, { { NULL, 8 } }

Typedefs

typedef void(* op_rtn )(int bytemode, int sizeflag)

Enumerations

enum  address_mode {
  c_mode, far_mode, mode_16bit, mode_32bit,
  mode_64bit
}

Functions

static int fetch_data (struct disassemble_info *, bfd_byte *)
static void ckprefix (void)
static const char * prefix_name (int, int)
static int print_insn (bfd_vma, disassemble_info *)
static void dofloat (int)
static void OP_ST (int, int)
static void OP_STi (int, int)
static int putop (const char *, int)
static void oappend (const char *)
static void append_seg (void)
static void OP_indirE (int, int)
static void print_operand_value (char *, int, bfd_vma)
static void OP_E (int, int)
static void OP_G (int, int)
static bfd_vma get64 (void)
static bfd_signed_vma get32 (void)
static bfd_signed_vma get32s (void)
static int get16 (void)
static void set_op (bfd_vma, int)
static void OP_REG (int, int)
static void OP_IMREG (int, int)
static void OP_I (int, int)
static void OP_I64 (int, int)
static void OP_sI (int, int)
static void OP_J (int, int)
static void OP_SEG (int, int)
static void OP_DIR (int, int)
static void OP_OFF (int, int)
static void OP_OFF64 (int, int)
static void ptr_reg (int, int)
static void OP_ESreg (int, int)
static void OP_DSreg (int, int)
static void OP_C (int, int)
static void OP_D (int, int)
static void OP_T (int, int)
static void OP_R (int, int)
static void OP_MMX (int, int)
static void OP_XMM (int, int)
static void OP_EM (int, int)
static void OP_EX (int, int)
static void OP_EMC (int, int)
static void OP_MXC (int, int)
static void OP_MS (int, int)
static void OP_XS (int, int)
static void OP_M (int, int)
static void OP_VMX (int, int)
static void OP_0fae (int, int)
static void OP_0f07 (int, int)
static void NOP_Fixup1 (int, int)
static void NOP_Fixup2 (int, int)
static void OP_3DNowSuffix (int, int)
static void OP_SIMD_Suffix (int, int)
static void SIMD_Fixup (int, int)
static void PNI_Fixup (int, int)
static void SVME_Fixup (int, int)
static void INVLPG_Fixup (int, int)
static void BadOp (void)
static void VMX_Fixup (int, int)
static void REP_Fixup (int, int)
static void CMPXCHG8B_Fixup (int, int)
int print_insn_i386_att (bfd_vma pc, disassemble_info *info)
int print_insn_i386_intel (bfd_vma pc, disassemble_info *info)
int print_insn_i386 (bfd_vma pc, disassemble_info *info)
void print_i386_disassembler_options (FILE *stream)
static void OP_ST (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_STi (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void intel_operand_size (int bytemode, int sizeflag)
static void OP_DIR (int dummy ATTRIBUTE_UNUSED, int sizeflag)
static void OP_C (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_D (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_T (int dummy ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_MMX (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_XMM (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_MXC (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_3DNowSuffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void OP_SIMD_Suffix (int bytemode ATTRIBUTE_UNUSED, int sizeflag ATTRIBUTE_UNUSED)
static void SIMD_Fixup (int extrachar, int sizeflag ATTRIBUTE_UNUSED)
static void PNI_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)
static void VMX_Fixup (int extrachar ATTRIBUTE_UNUSED, int sizeflag)

Variables

static int used_prefixes
static struct dis386 []
static const unsigned char onebyte_has_modrm [256]
static const unsigned char twobyte_has_modrm [256]
static const unsigned char twobyte_uses_DATA_prefix [256]
static const unsigned char twobyte_uses_REPNZ_prefix [256]
static const unsigned char twobyte_uses_REPZ_prefix [256]
static const unsigned char threebyte_0x38_uses_DATA_prefix [256]
static const unsigned char threebyte_0x38_uses_REPNZ_prefix [256]
static const unsigned char threebyte_0x38_uses_REPZ_prefix [256]
static const unsigned char threebyte_0x3a_uses_DATA_prefix [256]
static const unsigned char threebyte_0x3a_uses_REPNZ_prefix [256]
static const unsigned char threebyte_0x3a_uses_REPZ_prefix [256]
static char obuf [100]
static char * obufp
static char scratchbuf [100]
static unsigned char * start_codep
static unsigned char * insn_codep
static unsigned char * codep
static disassemble_infothe_info
static int mod
static int rm
static int reg
static unsigned char need_modrm
static const char ** names64
static const char ** names32
static const char ** names16
static const char ** names8
static const char ** names8rex
static const char ** names_seg
static const char ** index16
static const char * intel_names64 []
static const char * intel_names32 []
static const char * intel_names16 []
static const char * intel_names8 []
static const char * intel_names8rex []
static const char * intel_names_seg []
static const char * intel_index16 []
static const char * att_names64 []
static const char * att_names32 []
static const char * att_names16 []
static const char * att_names8 []
static const char * att_names8rex []
static const char * att_names_seg []
static const char * att_index16 []
static char op_out [MAX_OPERANDS][100]
static int op_ad
static int op_index [MAX_OPERANDS]
static int two_source_ops
static bfd_vma op_address [MAX_OPERANDS]
static bfd_vma op_riprel [MAX_OPERANDS]
static bfd_vma start_pc
static char intel_syntax
static char open_char
static char close_char
static char separator_char
static char scale_char
static const char * float_mem []
static const unsigned char float_mem_mode []
static char * fgrps [][8]
static const char *const Suffix3DNow []
static const char * simd_cmp_op []

Class Documentation

struct dis_private

Definition at line 102 of file i386-dis.c.

Class Members
jmp_buf bailout
bfd_byte * byte_buf
bfd_vma insn_start
bfd_byte * max_fetched
int orig_sizeflag
bfd_byte the_buffer
struct dis386

Definition at line 482 of file i386-dis.c.

Class Members
const char * name
struct dis386 op
struct dis386.op

Definition at line 484 of file i386-dis.c.

Class Members
int bytemode
op_rtn rtn

Define Documentation

#define AFLAG   2

Definition at line 328 of file i386-dis.c.

#define AH   { OP_IMREG, ah_reg }

Definition at line 273 of file i386-dis.c.

#define ah_reg   120

Definition at line 369 of file i386-dis.c.

#define AL   { OP_IMREG, al_reg }

Definition at line 269 of file i386-dis.c.

#define al_reg   116

Definition at line 365 of file i386-dis.c.

#define ALr   { REP_Fixup, al_reg }

Definition at line 320 of file i386-dis.c.

#define Ap   { OP_DIR, 0 }

Definition at line 284 of file i386-dis.c.

#define AX   { OP_IMREG, ax_reg }

Definition at line 277 of file i386-dis.c.

#define ax_reg   124

Definition at line 374 of file i386-dis.c.

#define b_mode   1 /* byte operand */

Definition at line 331 of file i386-dis.c.

#define BH   { OP_IMREG, bh_reg }

Definition at line 276 of file i386-dis.c.

#define bh_reg   123

Definition at line 372 of file i386-dis.c.

#define BL   { OP_IMREG, bl_reg }

Definition at line 272 of file i386-dis.c.

#define bl_reg   119

Definition at line 368 of file i386-dis.c.

#define bp_reg   129

Definition at line 379 of file i386-dis.c.

#define bx_reg   127

Definition at line 377 of file i386-dis.c.

#define CH   { OP_IMREG, ch_reg }

Definition at line 274 of file i386-dis.c.

#define ch_reg   121

Definition at line 370 of file i386-dis.c.

#define CL   { OP_IMREG, cl_reg }

Definition at line 270 of file i386-dis.c.

#define cl_reg   117

Definition at line 366 of file i386-dis.c.

#define Cm   { OP_C, m_mode }

Definition at line 229 of file i386-dis.c.

#define cond_jump_flag   { NULL, cond_jump_mode }

Definition at line 323 of file i386-dis.c.

#define cond_jump_mode   9

Definition at line 339 of file i386-dis.c.

#define const_1_mode   14

Definition at line 344 of file i386-dis.c.

#define cs   { OP_REG, cs_reg }

Definition at line 296 of file i386-dis.c.

#define cs_reg   101

Definition at line 350 of file i386-dis.c.

#define cx_reg   125

Definition at line 375 of file i386-dis.c.

#define d_mode   4 /* double word operand */

Definition at line 334 of file i386-dis.c.

#define DFLAG   1

Definition at line 329 of file i386-dis.c.

#define DH   { OP_IMREG, dh_reg }

Definition at line 275 of file i386-dis.c.

#define dh_reg   122

Definition at line 371 of file i386-dis.c.

#define di_reg   131

Definition at line 381 of file i386-dis.c.

#define DL   { OP_IMREG, dl_reg }

Definition at line 271 of file i386-dis.c.

#define dl_reg   118

Definition at line 367 of file i386-dis.c.

#define Dm   { OP_D, m_mode }

Definition at line 230 of file i386-dis.c.

#define dq_mode   11 /* operand size depends on REX prefixes. */

Definition at line 341 of file i386-dis.c.

#define dqw_mode   12 /* registers like dq_mode, memory like w_mode. */

Definition at line 342 of file i386-dis.c.

al ds   { OP_REG, ds_reg }

Definition at line 297 of file i386-dis.c.

#define ds_reg   103

Definition at line 352 of file i386-dis.c.

#define DSBX   { OP_DSreg, eBX_reg }

Definition at line 292 of file i386-dis.c.

#define DX   { OP_IMREG, dx_reg }

Definition at line 278 of file i386-dis.c.

#define dx_reg   126

Definition at line 376 of file i386-dis.c.

#define eAX   { OP_IMREG, eAX_reg }

Definition at line 261 of file i386-dis.c.

#define eAX_reg   108

Definition at line 356 of file i386-dis.c.

#define eAXr   { REP_Fixup, eAX_reg }

Definition at line 321 of file i386-dis.c.

#define Eb   { OP_E, b_mode }

Definition at line 198 of file i386-dis.c.

#define eBP   { OP_IMREG, eBP_reg }

Definition at line 266 of file i386-dis.c.

#define eBP_reg   113

Definition at line 361 of file i386-dis.c.

#define eBX   { OP_IMREG, eBX_reg }

Definition at line 262 of file i386-dis.c.

#define eBX_reg   111

Definition at line 359 of file i386-dis.c.

#define eCX   { OP_IMREG, eCX_reg }

Definition at line 263 of file i386-dis.c.

#define eCX_reg   109

Definition at line 357 of file i386-dis.c.

#define Ed   { OP_E, d_mode }

Definition at line 200 of file i386-dis.c.

#define eDI   { OP_IMREG, eDI_reg }

Definition at line 268 of file i386-dis.c.

#define eDI_reg   115

Definition at line 363 of file i386-dis.c.

#define Edq   { OP_E, dq_mode }

Definition at line 201 of file i386-dis.c.

#define Edqw   { OP_E, dqw_mode }

Definition at line 202 of file i386-dis.c.

#define eDX   { OP_IMREG, eDX_reg }

Definition at line 264 of file i386-dis.c.

#define eDX_reg   110

Definition at line 358 of file i386-dis.c.

#define Em   { OP_E, m_mode }

Definition at line 206 of file i386-dis.c.

#define EM   { OP_EM, v_mode }

Definition at line 303 of file i386-dis.c.

#define EMC   { OP_EMC, v_mode }

Definition at line 307 of file i386-dis.c.

al es   { OP_REG, es_reg }

Definition at line 294 of file i386-dis.c.

#define es_reg   100

Definition at line 349 of file i386-dis.c.

#define eSI   { OP_IMREG, eSI_reg }

Definition at line 267 of file i386-dis.c.

#define eSI_reg   114

Definition at line 362 of file i386-dis.c.

#define eSP   { OP_IMREG, eSP_reg }

Definition at line 265 of file i386-dis.c.

#define eSP_reg   112

Definition at line 360 of file i386-dis.c.

#define Ev   { OP_E, v_mode }

Definition at line 199 of file i386-dis.c.

#define Ew   { OP_E, w_mode }

Definition at line 207 of file i386-dis.c.

#define EX   { OP_EX, v_mode }

Definition at line 304 of file i386-dis.c.

#define f_mode   13 /* 4- or 6-byte pointer operand */

Definition at line 343 of file i386-dis.c.

#define FETCH_DATA (   info,
  addr 
)
Value:
((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
   ? 1 : fetch_data ((info), (addr)))

Definition at line 163 of file i386-dis.c.

#define FGRPd9_2   NULL, { { NULL, 0 } }

Definition at line 3458 of file i386-dis.c.

#define FGRPd9_4   NULL, { { NULL, 1 } }

Definition at line 3459 of file i386-dis.c.

#define FGRPd9_5   NULL, { { NULL, 2 } }

Definition at line 3460 of file i386-dis.c.

#define FGRPd9_6   NULL, { { NULL, 3 } }

Definition at line 3461 of file i386-dis.c.

#define FGRPd9_7   NULL, { { NULL, 4 } }

Definition at line 3462 of file i386-dis.c.

#define FGRPda_5   NULL, { { NULL, 5 } }

Definition at line 3463 of file i386-dis.c.

#define FGRPdb_4   NULL, { { NULL, 6 } }

Definition at line 3464 of file i386-dis.c.

#define FGRPde_3   NULL, { { NULL, 7 } }

Definition at line 3465 of file i386-dis.c.

#define FGRPdf_4   NULL, { { NULL, 8 } }

Definition at line 3466 of file i386-dis.c.

#define FLOAT   NULL, { { NULL, FLOATCODE } }

Definition at line 401 of file i386-dis.c.

#define FLOATCODE   1

Definition at line 395 of file i386-dis.c.

#define fs   { OP_REG, fs_reg }

Definition at line 298 of file i386-dis.c.

#define fs_reg   104

Definition at line 353 of file i386-dis.c.

#define Gb   { OP_G, b_mode }

Definition at line 212 of file i386-dis.c.

#define Gd   { OP_G, d_mode }

Definition at line 214 of file i386-dis.c.

#define Gdq   { OP_G, dq_mode }

Definition at line 215 of file i386-dis.c.

#define Gm   { OP_G, m_mode }

Definition at line 216 of file i386-dis.c.

#define GRP11_C6   NULL, { { NULL, USE_GROUPS }, { NULL, 17 } }

Definition at line 420 of file i386-dis.c.

#define GRP11_C7   NULL, { { NULL, USE_GROUPS }, { NULL, 18 } }

Definition at line 421 of file i386-dis.c.

#define GRP12   NULL, { { NULL, USE_GROUPS }, { NULL, 19 } }

Definition at line 422 of file i386-dis.c.

#define GRP13   NULL, { { NULL, USE_GROUPS }, { NULL, 20 } }

Definition at line 423 of file i386-dis.c.

#define GRP14   NULL, { { NULL, USE_GROUPS }, { NULL, 21 } }

Definition at line 424 of file i386-dis.c.

#define GRP15   NULL, { { NULL, USE_GROUPS }, { NULL, 22 } }

Definition at line 425 of file i386-dis.c.

#define GRP16   NULL, { { NULL, USE_GROUPS }, { NULL, 23 } }

Definition at line 426 of file i386-dis.c.

#define GRP1b   NULL, { { NULL, USE_GROUPS }, { NULL, 0 } }

Definition at line 403 of file i386-dis.c.

#define GRP1S   NULL, { { NULL, USE_GROUPS }, { NULL, 1 } }

Definition at line 404 of file i386-dis.c.

#define GRP1Ss   NULL, { { NULL, USE_GROUPS }, { NULL, 2 } }

Definition at line 405 of file i386-dis.c.

#define GRP2b   NULL, { { NULL, USE_GROUPS }, { NULL, 3 } }

Definition at line 406 of file i386-dis.c.

#define GRP2b_cl   NULL, { { NULL, USE_GROUPS }, { NULL, 7 } }

Definition at line 410 of file i386-dis.c.

#define GRP2b_one   NULL, { { NULL, USE_GROUPS }, { NULL, 5 } }

Definition at line 408 of file i386-dis.c.

#define GRP2S   NULL, { { NULL, USE_GROUPS }, { NULL, 4 } }

Definition at line 407 of file i386-dis.c.

#define GRP2S_cl   NULL, { { NULL, USE_GROUPS }, { NULL, 8 } }

Definition at line 411 of file i386-dis.c.

#define GRP2S_one   NULL, { { NULL, USE_GROUPS }, { NULL, 6 } }

Definition at line 409 of file i386-dis.c.

#define GRP3b   NULL, { { NULL, USE_GROUPS }, { NULL, 9 } }

Definition at line 412 of file i386-dis.c.

#define GRP3S   NULL, { { NULL, USE_GROUPS }, { NULL, 10 } }

Definition at line 413 of file i386-dis.c.

#define GRP4   NULL, { { NULL, USE_GROUPS }, { NULL, 11 } }

Definition at line 414 of file i386-dis.c.

#define GRP5   NULL, { { NULL, USE_GROUPS }, { NULL, 12 } }

Definition at line 415 of file i386-dis.c.

#define GRP6   NULL, { { NULL, USE_GROUPS }, { NULL, 13 } }

Definition at line 416 of file i386-dis.c.

#define GRP7   NULL, { { NULL, USE_GROUPS }, { NULL, 14 } }

Definition at line 417 of file i386-dis.c.

#define GRP8   NULL, { { NULL, USE_GROUPS }, { NULL, 15 } }

Definition at line 418 of file i386-dis.c.

#define GRP9   NULL, { { NULL, USE_GROUPS }, { NULL, 16 } }

Definition at line 419 of file i386-dis.c.

#define GRPAMD   NULL, { { NULL, USE_GROUPS }, { NULL, 24 } }

Definition at line 427 of file i386-dis.c.

#define GRPPADLCK1   NULL, { { NULL, USE_GROUPS }, { NULL, 25 } }

Definition at line 428 of file i386-dis.c.

#define GRPPADLCK2   NULL, { { NULL, USE_GROUPS }, { NULL, 26 } }

Definition at line 429 of file i386-dis.c.

eax gs   { OP_REG, gs_reg }

Definition at line 299 of file i386-dis.c.

#define gs_reg   105

Definition at line 354 of file i386-dis.c.

#define Gv   { OP_G, v_mode }

Definition at line 213 of file i386-dis.c.

#define Gw   { OP_G, w_mode }

Definition at line 217 of file i386-dis.c.

#define I1   { OP_I, const_1_mode }

Definition at line 226 of file i386-dis.c.

#define Ib   { OP_I, b_mode }

Definition at line 220 of file i386-dis.c.

#define indir_dx_reg   150

Definition at line 393 of file i386-dis.c.

#define indirDX   { OP_IMREG, indir_dx_reg }

Definition at line 280 of file i386-dis.c.

#define indirDXr   { REP_Fixup, indir_dx_reg }

Definition at line 319 of file i386-dis.c.

#define indirEp   { OP_indirE, f_mode }

Definition at line 204 of file i386-dis.c.

#define indirEv   { OP_indirE, stack_v_mode }

Definition at line 203 of file i386-dis.c.

#define INTERNAL_DISASSEMBLER_ERROR   _("<internal disassembler error>")

Definition at line 2634 of file i386-dis.c.

#define Iq   { OP_I, q_mode }

Definition at line 223 of file i386-dis.c.

#define IS_3BYTE_OPCODE   5

Definition at line 399 of file i386-dis.c.

#define Iv   { OP_I, v_mode }

Definition at line 222 of file i386-dis.c.

#define Iv64   { OP_I64, v_mode }

Definition at line 224 of file i386-dis.c.

#define Iw   { OP_I, w_mode }

Definition at line 225 of file i386-dis.c.

#define Jb   { OP_J, b_mode }

Definition at line 227 of file i386-dis.c.

#define Jv   { OP_J, v_mode }

Definition at line 228 of file i386-dis.c.

#define loop_jcxz_flag   { NULL, loop_jcxz_mode }

Definition at line 324 of file i386-dis.c.

#define loop_jcxz_mode   10

Definition at line 340 of file i386-dis.c.

#define M   { OP_M, 0 } /* lea, lgdt, etc. */

Definition at line 208 of file i386-dis.c.

#define m_mode   8 /* d_mode in 32bit, q_mode in 64bit mode. */

Definition at line 338 of file i386-dis.c.

#define Ma   { OP_M, v_mode }

Definition at line 209 of file i386-dis.c.

#define MODRM_CHECK   if (!need_modrm) abort ()

Definition at line 1387 of file i386-dis.c.

#define Mp   { OP_M, f_mode } /* 32 or 48 bit memory operand for LDS, LES etc */

Definition at line 210 of file i386-dis.c.

#define Mq   { OP_M, q_mode }

Definition at line 211 of file i386-dis.c.

#define MS   { OP_MS, v_mode }

Definition at line 305 of file i386-dis.c.

#define MX   { OP_MMX, 0 }

Definition at line 301 of file i386-dis.c.

#define MXC   { OP_MXC, 0 }

Definition at line 308 of file i386-dis.c.

#define o_mode   17 /* 16-byte operand */

Definition at line 347 of file i386-dis.c.

#define Ob   { OP_OFF64, b_mode }

Definition at line 285 of file i386-dis.c.

#define OPSIMD   { OP_SIMD_Suffix, 0 }

Definition at line 311 of file i386-dis.c.

#define OPSUF   { OP_3DNowSuffix, 0 }

Definition at line 310 of file i386-dis.c.

#define Ov   { OP_OFF64, v_mode }

Definition at line 286 of file i386-dis.c.

#define PREFIX_ADDR   0x400

Definition at line 157 of file i386-dis.c.

#define PREFIX_CS   8

Definition at line 150 of file i386-dis.c.

#define PREFIX_DATA   0x200

Definition at line 156 of file i386-dis.c.

#define PREFIX_DS   0x20

Definition at line 152 of file i386-dis.c.

#define PREFIX_ES   0x40

Definition at line 153 of file i386-dis.c.

#define PREFIX_FS   0x80

Definition at line 154 of file i386-dis.c.

#define PREFIX_FWAIT   0x800

Definition at line 158 of file i386-dis.c.

#define PREFIX_GS   0x100

Definition at line 155 of file i386-dis.c.

#define PREFIX_LOCK   4

Definition at line 149 of file i386-dis.c.

#define PREFIX_REPNZ   2

Definition at line 148 of file i386-dis.c.

#define PREFIX_REPZ   1

Definition at line 147 of file i386-dis.c.

#define PREFIX_SS   0x10

Definition at line 151 of file i386-dis.c.

#define PREGRP0   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 0 } }

Definition at line 431 of file i386-dis.c.

#define PREGRP1   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 1 } }

Definition at line 432 of file i386-dis.c.

#define PREGRP10   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 10 } }

Definition at line 441 of file i386-dis.c.

#define PREGRP11   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 11 } }

Definition at line 442 of file i386-dis.c.

#define PREGRP12   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 12 } }

Definition at line 443 of file i386-dis.c.

#define PREGRP13   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 13 } }

Definition at line 444 of file i386-dis.c.

#define PREGRP14   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 14 } }

Definition at line 445 of file i386-dis.c.

#define PREGRP15   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 15 } }

Definition at line 446 of file i386-dis.c.

#define PREGRP16   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 16 } }

Definition at line 447 of file i386-dis.c.

#define PREGRP17   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 17 } }

Definition at line 448 of file i386-dis.c.

#define PREGRP18   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 18 } }

Definition at line 449 of file i386-dis.c.

#define PREGRP19   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 19 } }

Definition at line 450 of file i386-dis.c.

#define PREGRP2   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 2 } }

Definition at line 433 of file i386-dis.c.

#define PREGRP20   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 20 } }

Definition at line 451 of file i386-dis.c.

#define PREGRP21   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 21 } }

Definition at line 452 of file i386-dis.c.

#define PREGRP22   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 22 } }

Definition at line 453 of file i386-dis.c.

#define PREGRP23   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 23 } }

Definition at line 454 of file i386-dis.c.

#define PREGRP24   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 24 } }

Definition at line 455 of file i386-dis.c.

#define PREGRP25   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 25 } }

Definition at line 456 of file i386-dis.c.

#define PREGRP26   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 26 } }

Definition at line 457 of file i386-dis.c.

#define PREGRP27   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 27 } }

Definition at line 458 of file i386-dis.c.

#define PREGRP28   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 28 } }

Definition at line 459 of file i386-dis.c.

#define PREGRP29   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 29 } }

Definition at line 460 of file i386-dis.c.

#define PREGRP3   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 3 } }

Definition at line 434 of file i386-dis.c.

#define PREGRP30   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 30 } }

Definition at line 461 of file i386-dis.c.

#define PREGRP31   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 31 } }

Definition at line 462 of file i386-dis.c.

#define PREGRP32   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 32 } }

Definition at line 463 of file i386-dis.c.

#define PREGRP33   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 33 } }

Definition at line 464 of file i386-dis.c.

#define PREGRP34   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 34 } }

Definition at line 465 of file i386-dis.c.

#define PREGRP35   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 35 } }

Definition at line 466 of file i386-dis.c.

#define PREGRP36   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 36 } }

Definition at line 467 of file i386-dis.c.

#define PREGRP37   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 37 } }

Definition at line 468 of file i386-dis.c.

#define PREGRP38   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 38 } }

Definition at line 469 of file i386-dis.c.

#define PREGRP4   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 4 } }

Definition at line 435 of file i386-dis.c.

#define PREGRP5   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 5 } }

Definition at line 436 of file i386-dis.c.

#define PREGRP6   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 6 } }

Definition at line 437 of file i386-dis.c.

#define PREGRP7   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 7 } }

Definition at line 438 of file i386-dis.c.

#define PREGRP8   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 8 } }

Definition at line 439 of file i386-dis.c.

#define PREGRP9   NULL, { { NULL, USE_PREFIX_USER_TABLE }, { NULL, 9 } }

Definition at line 440 of file i386-dis.c.

#define q_mode   5 /* quad word operand */

Definition at line 335 of file i386-dis.c.

#define rAX_reg   132

Definition at line 383 of file i386-dis.c.

#define rBP_reg   137

Definition at line 388 of file i386-dis.c.

#define rBX_reg   135

Definition at line 386 of file i386-dis.c.

#define rCX_reg   133

Definition at line 384 of file i386-dis.c.

#define Rd   { OP_R, d_mode }

Definition at line 218 of file i386-dis.c.

#define rDI_reg   139

Definition at line 390 of file i386-dis.c.

#define rDX_reg   134

Definition at line 385 of file i386-dis.c.

#define Rm   { OP_R, m_mode }

Definition at line 219 of file i386-dis.c.

#define RMAH   { OP_REG, ah_reg }

Definition at line 254 of file i386-dis.c.

#define RMAL   { OP_REG, al_reg }

Definition at line 250 of file i386-dis.c.

#define RMAL   { OP_REG, al_reg }

Definition at line 250 of file i386-dis.c.

#define RMAX   { OP_REG, ax_reg }

Definition at line 258 of file i386-dis.c.

#define RMBH   { OP_REG, bh_reg }

Definition at line 257 of file i386-dis.c.

#define RMBL   { OP_REG, bl_reg }

Definition at line 253 of file i386-dis.c.

#define RMCH   { OP_REG, ch_reg }

Definition at line 255 of file i386-dis.c.

#define RMCL   { OP_REG, cl_reg }

Definition at line 251 of file i386-dis.c.

#define RMDH   { OP_REG, dh_reg }

Definition at line 256 of file i386-dis.c.

#define RMDL   { OP_REG, dl_reg }

Definition at line 252 of file i386-dis.c.

#define RMDX   { OP_REG, dx_reg }

Definition at line 259 of file i386-dis.c.

#define RMeAX   { OP_REG, eAX_reg }

Definition at line 233 of file i386-dis.c.

#define RMeBP   { OP_REG, eBP_reg }

Definition at line 238 of file i386-dis.c.

#define RMeBX   { OP_REG, eBX_reg }

Definition at line 234 of file i386-dis.c.

#define RMeCX   { OP_REG, eCX_reg }

Definition at line 235 of file i386-dis.c.

#define RMeDI   { OP_REG, eDI_reg }

Definition at line 240 of file i386-dis.c.

#define RMeDX   { OP_REG, eDX_reg }

Definition at line 236 of file i386-dis.c.

#define RMeSI   { OP_REG, eSI_reg }

Definition at line 239 of file i386-dis.c.

#define RMeSP   { OP_REG, eSP_reg }

Definition at line 237 of file i386-dis.c.

#define RMrAX   { OP_REG, rAX_reg }

Definition at line 241 of file i386-dis.c.

#define RMrBP   { OP_REG, rBP_reg }

Definition at line 246 of file i386-dis.c.

#define RMrBX   { OP_REG, rBX_reg }

Definition at line 242 of file i386-dis.c.

#define RMrCX   { OP_REG, rCX_reg }

Definition at line 243 of file i386-dis.c.

#define RMrDI   { OP_REG, rDI_reg }

Definition at line 248 of file i386-dis.c.

#define RMrDX   { OP_REG, rDX_reg }

Definition at line 244 of file i386-dis.c.

#define RMrSI   { OP_REG, rSI_reg }

Definition at line 247 of file i386-dis.c.

#define RMrSP   { OP_REG, rSP_reg }

Definition at line 245 of file i386-dis.c.

#define rSI_reg   138

Definition at line 389 of file i386-dis.c.

#define rSP_reg   136

Definition at line 387 of file i386-dis.c.

#define si_reg   130

Definition at line 380 of file i386-dis.c.

#define sIb   { OP_sI, b_mode } /* sign extened byte */

Definition at line 221 of file i386-dis.c.

#define sp_reg   128

Definition at line 378 of file i386-dis.c.

#define ss   { OP_REG, ss_reg }

Definition at line 295 of file i386-dis.c.

#define ss_reg   102

Definition at line 351 of file i386-dis.c.

#define ST   { OP_ST, 0 }

Definition at line 3455 of file i386-dis.c.

#define stack_v_mode   15 /* v_mode for stack-related opcodes. */

Definition at line 345 of file i386-dis.c.

#define stackEv   { OP_E, stack_v_mode }

Definition at line 205 of file i386-dis.c.

#define STi   { OP_STi, 0 }

Definition at line 3456 of file i386-dis.c.

#define SUFFIX_ALWAYS   4

Definition at line 327 of file i386-dis.c.

#define Sv   { OP_SEG, v_mode }

Definition at line 283 of file i386-dis.c.

#define Sw   { OP_SEG, w_mode }

Definition at line 282 of file i386-dis.c.

#define t_mode   6 /* ten-byte operand */

Definition at line 336 of file i386-dis.c.

#define Td   { OP_T, d_mode }

Definition at line 231 of file i386-dis.c.

#define THREE_BYTE_0   NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 0 } }

Definition at line 477 of file i386-dis.c.

#define THREE_BYTE_1   NULL, { { NULL, IS_3BYTE_OPCODE }, { NULL, 1 } }

Definition at line 478 of file i386-dis.c.

#define USE_GROUPS   2

Definition at line 396 of file i386-dis.c.

#define USE_PREFIX_USER_TABLE   3

Definition at line 397 of file i386-dis.c.

#define USED_REX (   value)
Value:
{                                                \
    if (value)                                          \
      {                                                 \
       if ((rex & value))                        \
         rex_used |= (value) | REX_OPCODE;              \
      }                                                 \
    else                                         \
      rex_used |= REX_OPCODE;                           \
  }

Definition at line 131 of file i386-dis.c.

#define v_mode   2 /* operand size depends on prefixes */

Definition at line 332 of file i386-dis.c.

#define VM   { OP_VMX, q_mode }

Definition at line 309 of file i386-dis.c.

#define w_mode   3 /* word operand */

Definition at line 333 of file i386-dis.c.

#define X86_64_0   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 0 } }

Definition at line 472 of file i386-dis.c.

#define X86_64_1   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 1 } }

Definition at line 473 of file i386-dis.c.

#define X86_64_2   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 2 } }

Definition at line 474 of file i386-dis.c.

#define X86_64_3   NULL, { { NULL, X86_64_SPECIAL }, { NULL, 3 } }

Definition at line 475 of file i386-dis.c.

#define X86_64_SPECIAL   4

Definition at line 398 of file i386-dis.c.

#define x_mode   7 /* 16-byte XMM operand */

Definition at line 337 of file i386-dis.c.

#define Xb   { OP_DSreg, eSI_reg }

Definition at line 287 of file i386-dis.c.

#define Xbr   { REP_Fixup, eSI_reg }

Definition at line 314 of file i386-dis.c.

#define XM   { OP_XMM, 0 }

Definition at line 302 of file i386-dis.c.

#define XS   { OP_XS, v_mode }

Definition at line 306 of file i386-dis.c.

#define Xv   { OP_DSreg, eSI_reg }

Definition at line 288 of file i386-dis.c.

#define Xvr   { REP_Fixup, eSI_reg }

Definition at line 315 of file i386-dis.c.

#define XX   { NULL, 0 }

Definition at line 196 of file i386-dis.c.

#define Xz   { OP_DSreg, eSI_reg }

Definition at line 289 of file i386-dis.c.

#define Yb   { OP_ESreg, eDI_reg }

Definition at line 290 of file i386-dis.c.

#define Ybr   { REP_Fixup, eDI_reg }

Definition at line 316 of file i386-dis.c.

#define Yv   { OP_ESreg, eDI_reg }

Definition at line 291 of file i386-dis.c.

#define Yvr   { REP_Fixup, eDI_reg }

Definition at line 317 of file i386-dis.c.

#define Yzr   { REP_Fixup, eDI_reg }

Definition at line 318 of file i386-dis.c.

#define z_mode   16 /* non-quad operand size depends on prefixes */

Definition at line 346 of file i386-dis.c.

#define z_mode_ax_reg   149

Definition at line 392 of file i386-dis.c.

#define zAX   { OP_IMREG, z_mode_ax_reg }

Definition at line 279 of file i386-dis.c.


Typedef Documentation

typedef void(* op_rtn)(int bytemode, int sizeflag)

Definition at line 480 of file i386-dis.c.


Enumeration Type Documentation

Enumerator:
c_mode 
far_mode 
mode_16bit 
mode_32bit 
mode_64bit 

Definition at line 111 of file i386-dis.c.


Function Documentation

static void append_seg ( void  ) [static]

Definition at line 4010 of file i386-dis.c.

{
  if (prefixes & PREFIX_CS)
    {
      used_prefixes |= PREFIX_CS;
      oappend ("%cs:" + intel_syntax);
    }
  if (prefixes & PREFIX_DS)
    {
      used_prefixes |= PREFIX_DS;
      oappend ("%ds:" + intel_syntax);
    }
  if (prefixes & PREFIX_SS)
    {
      used_prefixes |= PREFIX_SS;
      oappend ("%ss:" + intel_syntax);
    }
  if (prefixes & PREFIX_ES)
    {
      used_prefixes |= PREFIX_ES;
      oappend ("%es:" + intel_syntax);
    }
  if (prefixes & PREFIX_FS)
    {
      used_prefixes |= PREFIX_FS;
      oappend ("%fs:" + intel_syntax);
    }
  if (prefixes & PREFIX_GS)
    {
      used_prefixes |= PREFIX_GS;
      oappend ("%gs:" + intel_syntax);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void BadOp ( void  ) [static]

Definition at line 5641 of file i386-dis.c.

{
  /* Throw away prefixes and 1st. opcode byte.  */
  codep = insn_codep + 1;
  oappend ("(bad)");
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void ckprefix ( void  ) [static]

Definition at line 2637 of file i386-dis.c.

{
  int newrex;
  rex = 0;
  prefixes = 0;
  used_prefixes = 0;
  rex_used = 0;
  while (1)
    {
      FETCH_DATA (the_info, codep + 1);
      newrex = 0;
      switch (*codep)
       {
       /* REX prefixes family.  */
       case 0x40:
       case 0x41:
       case 0x42:
       case 0x43:
       case 0x44:
       case 0x45:
       case 0x46:
       case 0x47:
       case 0x48:
       case 0x49:
       case 0x4a:
       case 0x4b:
       case 0x4c:
       case 0x4d:
       case 0x4e:
       case 0x4f:
           if (address_mode == mode_64bit)
             newrex = *codep;
           else
             return;
         break;
       case 0xf3:
         prefixes |= PREFIX_REPZ;
         break;
       case 0xf2:
         prefixes |= PREFIX_REPNZ;
         break;
       case 0xf0:
         prefixes |= PREFIX_LOCK;
         break;
       case 0x2e:
         prefixes |= PREFIX_CS;
         break;
       case 0x36:
         prefixes |= PREFIX_SS;
         break;
       case 0x3e:
         prefixes |= PREFIX_DS;
         break;
       case 0x26:
         prefixes |= PREFIX_ES;
         break;
       case 0x64:
         prefixes |= PREFIX_FS;
         break;
       case 0x65:
         prefixes |= PREFIX_GS;
         break;
       case 0x66:
         prefixes |= PREFIX_DATA;
         break;
       case 0x67:
         prefixes |= PREFIX_ADDR;
         break;
       case FWAIT_OPCODE:
         /* fwait is really an instruction.  If there are prefixes
            before the fwait, they belong to the fwait, *not* to the
            following instruction.  */
         if (prefixes || rex)
           {
             prefixes |= PREFIX_FWAIT;
             codep++;
             return;
           }
         prefixes = PREFIX_FWAIT;
         break;
       default:
         return;
       }
      /* Rex is ignored when followed by another prefix.  */
      if (rex)
       {
         rex_used = rex;
         return;
       }
      rex = newrex;
      codep++;
    }
}

Here is the caller graph for this function:

static void CMPXCHG8B_Fixup ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5769 of file i386-dis.c.

{
  USED_REX (REX_W);
  if (rex & REX_W)
    {
      /* Change cmpxchg8b to cmpxchg16b.  */
      char *p = obuf + strlen (obuf) - 2;
      strcpy (p, "16b");
      bytemode = o_mode;
    }
  OP_M (bytemode, sizeflag);
}

Here is the call graph for this function:

static void dofloat ( int  sizeflag) [static]

Definition at line 3622 of file i386-dis.c.

{
  const struct dis386 *dp;
  unsigned char floatop;

  floatop = codep[-1];

  if (mod != 3)
    {
      int fp_indx = (floatop - 0xd8) * 8 + reg;

      putop (float_mem[fp_indx], sizeflag);
      obufp = op_out[0];
      op_ad = 2;
      OP_E (float_mem_mode[fp_indx], sizeflag);
      return;
    }
  /* Skip mod/rm byte.  */
  MODRM_CHECK;
  codep++;

  dp = &float_reg[floatop - 0xd8][reg];
  if (dp->name == NULL)
    {
      putop (fgrps[dp->op[0].bytemode][rm], sizeflag);

      /* Instruction fnstsw is only one with strange arg.  */
      if (floatop == 0xdf && codep[-1] == 0xe0)
       strcpy (op_out[0], names16[0]);
    }
  else
    {
      putop (dp->name, sizeflag);

      obufp = op_out[0];
      op_ad = 2;
      if (dp->op[0].rtn)
       (*dp->op[0].rtn) (dp->op[0].bytemode, sizeflag);

      obufp = op_out[1];
      op_ad = 1;
      if (dp->op[1].rtn)
       (*dp->op[1].rtn) (dp->op[1].bytemode, sizeflag);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int fetch_data ( struct disassemble_info info,
bfd_byte addr 
) [static]

Definition at line 168 of file i386-dis.c.

{
  int status;
  struct dis_private *priv = (struct dis_private *) info->private_data;
  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);

  if (addr <= priv->the_buffer + MAX_MNEM_SIZE)
    status = (*info->read_memory_func) (start,
                                   priv->max_fetched,
                                   addr - priv->max_fetched,
                                   info);
  else
    status = -1;
  if (status != 0)
    {
      /* If we did manage to read at least one byte, then
        print_insn_i386 will do something sensible.  Otherwise, print
        an error.  We do that here because this is where we know
        STATUS.  */
      if (priv->max_fetched == priv->the_buffer)
       (*info->memory_error_func) (status, start, info);
      longjmp (priv->bailout, 1);
    }
  else
    priv->max_fetched = addr;
  return 1;
}
static int get16 ( void  ) [static]

Definition at line 4562 of file i386-dis.c.

{
  int x = 0;

  FETCH_DATA (the_info, codep + 2);
  x = *codep++ & 0xff;
  x |= (*codep++ & 0xff) << 8;
  return x;
}

Here is the caller graph for this function:

static bfd_signed_vma get32 ( void  ) [static]

Definition at line 4533 of file i386-dis.c.

{
  bfd_signed_vma x = 0;

  FETCH_DATA (the_info, codep + 4);
  x = *codep++ & (bfd_signed_vma) 0xff;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;
  return x;
}

Here is the caller graph for this function:

static bfd_signed_vma get32s ( void  ) [static]

Definition at line 4546 of file i386-dis.c.

{
  bfd_signed_vma x = 0;

  FETCH_DATA (the_info, codep + 4);
  x = *codep++ & (bfd_signed_vma) 0xff;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 8;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 16;
  x |= (*codep++ & (bfd_signed_vma) 0xff) << 24;

  x = (x ^ ((bfd_signed_vma) 1 << 31)) - ((bfd_signed_vma) 1 << 31);

  return x;
}

Here is the caller graph for this function:

static bfd_vma get64 ( void  ) [static]

Definition at line 4508 of file i386-dis.c.

{
  bfd_vma x;
#ifdef BFD64
  unsigned int a;
  unsigned int b;

  FETCH_DATA (the_info, codep + 8);
  a = *codep++ & 0xff;
  a |= (*codep++ & 0xff) << 8;
  a |= (*codep++ & 0xff) << 16;
  a |= (*codep++ & 0xff) << 24;
  b = *codep++ & 0xff;
  b |= (*codep++ & 0xff) << 8;
  b |= (*codep++ & 0xff) << 16;
  b |= (*codep++ & 0xff) << 24;
  x = a + ((bfd_vma) b << 32);
#else
  abort ();
  x = 0;
#endif
  return x;
}

Here is the caller graph for this function:

static void intel_operand_size ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4110 of file i386-dis.c.

{
  switch (bytemode)
    {
    case b_mode:
      oappend ("BYTE PTR ");
      break;
    case w_mode:
    case dqw_mode:
      oappend ("WORD PTR ");
      break;
    case stack_v_mode:
      if (address_mode == mode_64bit && (sizeflag & DFLAG))
       {
         oappend ("QWORD PTR ");
         used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       }
      /* FALLTHRU */
    case v_mode:
    case dq_mode:
      USED_REX (REX_W);
      if (rex & REX_W)
       oappend ("QWORD PTR ");
      else if ((sizeflag & DFLAG) || bytemode == dq_mode)
       oappend ("DWORD PTR ");
      else
       oappend ("WORD PTR ");
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case z_mode:
      if ((rex & REX_W) || (sizeflag & DFLAG))
       *obufp++ = 'D';
      oappend ("WORD PTR ");
      if (!(rex & REX_W))
       used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case d_mode:
      oappend ("DWORD PTR ");
      break;
    case q_mode:
      oappend ("QWORD PTR ");
      break;
    case m_mode:
      if (address_mode == mode_64bit)
       oappend ("QWORD PTR ");
      else
       oappend ("DWORD PTR ");
      break;
    case f_mode:
      if (sizeflag & DFLAG)
       oappend ("FWORD PTR ");
      else
       oappend ("DWORD PTR ");
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case t_mode:
      oappend ("TBYTE PTR ");
      break;
    case x_mode:
      oappend ("XMMWORD PTR ");
      break;
    case o_mode:
      oappend ("OWORD PTR ");
      break;
    default:
      break;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void INVLPG_Fixup ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5619 of file i386-dis.c.

{
  const char *alt;

  switch (*codep)
    {
    case 0xf8:
      alt = "swapgs";
      break;
    case 0xf9:
      alt = "rdtscp";
      break;
    default:
      OP_M (bytemode, sizeflag);
      return;
    }
  /* Override "invlpg".  */
  strcpy (obuf + strlen (obuf) - 6, alt);
  codep++;
}

Here is the call graph for this function:

static void NOP_Fixup1 ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5304 of file i386-dis.c.

{
  if ((prefixes & PREFIX_DATA) != 0
      || (rex != 0
         && rex != 0x48
         && address_mode == mode_64bit))
    OP_REG (bytemode, sizeflag);
  else
    strcpy (obuf, "nop");
}
static void NOP_Fixup2 ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5316 of file i386-dis.c.

{
  if ((prefixes & PREFIX_DATA) != 0
      || (rex != 0
         && rex != 0x48
         && address_mode == mode_64bit))
    OP_IMREG (bytemode, sizeflag);
}

Here is the call graph for this function:

static void oappend ( const char *  s) [static]

Definition at line 4003 of file i386-dis.c.

{
  strcpy (obufp, s);
  obufp += strlen (s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_0f07 ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5269 of file i386-dis.c.

{
  if (mod != 3 || rm != 0)
    BadOp ();
  else
    OP_E (bytemode, sizeflag);
}

Here is the call graph for this function:

static void OP_0fae ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5278 of file i386-dis.c.

{
  if (mod == 3)
    {
      if (reg == 7)
       strcpy (obuf + strlen (obuf) - sizeof ("clflush") + 1, "sfence");

      if (reg < 5 || rm != 0)
       {
         BadOp ();   /* bad sfence, mfence, or lfence */
         return;
       }
    }
  else if (reg != 7)
    {
      BadOp ();             /* bad clflush */
      return;
    }

  OP_E (bytemode, sizeflag);
}

Here is the call graph for this function:

static void OP_3DNowSuffix ( int  ,
int   
) [static]
static void OP_3DNowSuffix ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5393 of file i386-dis.c.

{
  const char *mnemonic;

  FETCH_DATA (the_info, codep + 1);
  /* AMD 3DNow! instructions are specified by an opcode suffix in the
     place where an 8-bit immediate would normally go.  ie. the last
     byte of the instruction.  */
  obufp = obuf + strlen (obuf);
  mnemonic = Suffix3DNow[*codep++ & 0xff];
  if (mnemonic)
    oappend (mnemonic);
  else
    {
      /* Since a variable sized modrm/sib chunk is between the start
        of the opcode (0x0f0f) and the opcode suffix, we need to do
        all the modrm processing first, and don't know until now that
        we have a bad opcode.  This necessitates some cleaning up.  */
      op_out[0][0] = '\0';
      op_out[1][0] = '\0';
      BadOp ();
    }
}

Here is the call graph for this function:

static void OP_C ( int  ,
int   
) [static]
static void OP_C ( int dummy  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5067 of file i386-dis.c.

{
  int add = 0;
  if (rex & REX_R)
    {
      USED_REX (REX_R);
      add = 8;
    }
  else if (address_mode != mode_64bit && (prefixes & PREFIX_LOCK))
    {
      used_prefixes |= PREFIX_LOCK;
      add = 8;
    }
  sprintf (scratchbuf, "%%cr%d", reg + add);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_D ( int  ,
int   
) [static]
static void OP_D ( int dummy  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5085 of file i386-dis.c.

{
  int add = 0;
  USED_REX (REX_R);
  if (rex & REX_R)
    add = 8;
  if (intel_syntax)
    sprintf (scratchbuf, "db%d", reg + add);
  else
    sprintf (scratchbuf, "%%db%d", reg + add);
  oappend (scratchbuf);
}

Here is the call graph for this function:

static void OP_DIR ( int  ,
int   
) [static]
static void OP_DIR ( int dummy  ATTRIBUTE_UNUSED,
int  sizeflag 
) [static]

Definition at line 4908 of file i386-dis.c.

{
  int seg, offset;

  if (sizeflag & DFLAG)
    {
      offset = get32 ();
      seg = get16 ();
    }
  else
    {
      offset = get16 ();
      seg = get16 ();
    }
  used_prefixes |= (prefixes & PREFIX_DATA);
  if (intel_syntax)
    sprintf (scratchbuf, "0x%x:0x%x", seg, offset);
  else
    sprintf (scratchbuf, "$0x%x,$0x%x", seg, offset);
  oappend (scratchbuf);
}

Here is the call graph for this function:

static void OP_DSreg ( int  code,
int  sizeflag 
) [static]

Definition at line 5036 of file i386-dis.c.

{
  if (intel_syntax)
    {
      switch (codep[-1])
       {
       case 0x6f:    /* outsw/outsl */
         intel_operand_size (z_mode, sizeflag);
         break;
       case 0xa5:    /* movsw/movsl/movsq */
       case 0xa7:    /* cmpsw/cmpsl/cmpsq */
       case 0xad:    /* lodsw/lodsl/lodsq */
         intel_operand_size (v_mode, sizeflag);
         break;
       default:
         intel_operand_size (b_mode, sizeflag);
       }
    }
  if ((prefixes
       & (PREFIX_CS
         | PREFIX_DS
         | PREFIX_SS
         | PREFIX_ES
         | PREFIX_FS
         | PREFIX_GS)) == 0)
    prefixes |= PREFIX_DS;
  append_seg ();
  ptr_reg (code, sizeflag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_E ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4181 of file i386-dis.c.

{
  bfd_vma disp;
  int add = 0;
  int riprel = 0;
  USED_REX (REX_B);
  if (rex & REX_B)
    add += 8;

  /* Skip mod/rm byte.  */
  MODRM_CHECK;
  codep++;

  if (mod == 3)
    {
      switch (bytemode)
       {
       case b_mode:
         USED_REX (0);
         if (rex)
           oappend (names8rex[rm + add]);
         else
           oappend (names8[rm + add]);
         break;
       case w_mode:
         oappend (names16[rm + add]);
         break;
       case d_mode:
         oappend (names32[rm + add]);
         break;
       case q_mode:
         oappend (names64[rm + add]);
         break;
       case m_mode:
         if (address_mode == mode_64bit)
           oappend (names64[rm + add]);
         else
           oappend (names32[rm + add]);
         break;
       case stack_v_mode:
         if (address_mode == mode_64bit && (sizeflag & DFLAG))
           {
             oappend (names64[rm + add]);
             used_prefixes |= (prefixes & PREFIX_DATA);
             break;
           }
         bytemode = v_mode;
         /* FALLTHRU */
       case v_mode:
       case dq_mode:
       case dqw_mode:
         USED_REX (REX_W);
         if (rex & REX_W)
           oappend (names64[rm + add]);
         else if ((sizeflag & DFLAG) || bytemode != v_mode)
           oappend (names32[rm + add]);
         else
           oappend (names16[rm + add]);
         used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       case 0:
         break;
       default:
         oappend (INTERNAL_DISASSEMBLER_ERROR);
         break;
       }
      return;
    }

  disp = 0;
  if (intel_syntax)
    intel_operand_size (bytemode, sizeflag);
  append_seg ();

  if ((sizeflag & AFLAG) || address_mode == mode_64bit) /* 32 bit address mode */
    {
      int havesib;
      int havebase;
      int base;
      int index = 0;
      int scale = 0;

      havesib = 0;
      havebase = 1;
      base = rm;

      if (base == 4)
       {
         havesib = 1;
         FETCH_DATA (the_info, codep + 1);
         index = (*codep >> 3) & 7;
         if (address_mode == mode_64bit || index != 0x4)
           /* When INDEX == 0x4 in 32 bit mode, SCALE is ignored.  */
           scale = (*codep >> 6) & 3;
         base = *codep & 7;
         USED_REX (REX_X);
         if (rex & REX_X)
           index += 8;
         codep++;
       }
      base += add;

      switch (mod)
       {
       case 0:
         if ((base & 7) == 5)
           {
             havebase = 0;
             if (address_mode == mode_64bit && !havesib)
              riprel = 1;
             disp = get32s ();
           }
         break;
       case 1:
         FETCH_DATA (the_info, codep + 1);
         disp = *codep++;
         if ((disp & 0x80) != 0)
           disp -= 0x100;
         break;
       case 2:
         disp = get32s ();
         break;
       }

      if (!intel_syntax)
       if (mod != 0 || (base & 7) == 5)
         {
           print_operand_value (scratchbuf, !riprel, disp);
           oappend (scratchbuf);
           if (riprel)
             {
              set_op (disp, 1);
              oappend ("(%rip)");
             }
         }

      if (havebase || (havesib && (index != 4 || scale != 0)))
       {
         *obufp++ = open_char;
         if (intel_syntax && riprel)
           oappend ("rip + ");
         *obufp = '\0';
         if (havebase)
           oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
                   ? names64[base] : names32[base]);
         if (havesib)
           {
             if (index != 4)
              {
                if (!intel_syntax || havebase)
                  {
                    *obufp++ = separator_char;
                    *obufp = '\0';
                  }
                oappend (address_mode == mode_64bit && (sizeflag & AFLAG)
                        ? names64[index] : names32[index]);
              }
             if (scale != 0 || (!intel_syntax && index != 4))
              {
                *obufp++ = scale_char;
                *obufp = '\0';
                sprintf (scratchbuf, "%d", 1 << scale);
                oappend (scratchbuf);
              }
           }
         if (intel_syntax && disp)
           {
             if ((bfd_signed_vma) disp > 0)
              {
                *obufp++ = '+';
                *obufp = '\0';
              }
             else if (mod != 1)
              {
                *obufp++ = '-';
                *obufp = '\0';
                disp = - (bfd_signed_vma) disp;
              }

             print_operand_value (scratchbuf, mod != 1, disp);
             oappend (scratchbuf);
           }

         *obufp++ = close_char;
         *obufp = '\0';
       }
      else if (intel_syntax)
       {
         if (mod != 0 || (base & 7) == 5)
           {
             if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
                           | PREFIX_ES | PREFIX_FS | PREFIX_GS))
              ;
             else
              {
                oappend (names_seg[ds_reg - es_reg]);
                oappend (":");
              }
             print_operand_value (scratchbuf, 1, disp);
             oappend (scratchbuf);
           }
       }
    }
  else
    { /* 16 bit address mode */
      switch (mod)
       {
       case 0:
         if (rm == 6)
           {
             disp = get16 ();
             if ((disp & 0x8000) != 0)
              disp -= 0x10000;
           }
         break;
       case 1:
         FETCH_DATA (the_info, codep + 1);
         disp = *codep++;
         if ((disp & 0x80) != 0)
           disp -= 0x100;
         break;
       case 2:
         disp = get16 ();
         if ((disp & 0x8000) != 0)
           disp -= 0x10000;
         break;
       }

      if (!intel_syntax)
       if (mod != 0 || rm == 6)
         {
           print_operand_value (scratchbuf, 0, disp);
           oappend (scratchbuf);
         }

      if (mod != 0 || rm != 6)
       {
         *obufp++ = open_char;
         *obufp = '\0';
         oappend (index16[rm]);
         if (intel_syntax && disp)
           {
             if ((bfd_signed_vma) disp > 0)
              {
                *obufp++ = '+';
                *obufp = '\0';
              }
             else if (mod != 1)
              {
                *obufp++ = '-';
                *obufp = '\0';
                disp = - (bfd_signed_vma) disp;
              }

             print_operand_value (scratchbuf, mod != 1, disp);
             oappend (scratchbuf);
           }

         *obufp++ = close_char;
         *obufp = '\0';
       }
      else if (intel_syntax)
       {
         if (prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
                       | PREFIX_ES | PREFIX_FS | PREFIX_GS))
           ;
         else
           {
             oappend (names_seg[ds_reg - es_reg]);
             oappend (":");
           }
         print_operand_value (scratchbuf, 1, disp & 0xffff);
         oappend (scratchbuf);
       }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_EM ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5143 of file i386-dis.c.

{
  if (mod != 3)
    {
      if (intel_syntax && bytemode == v_mode)
       {
         bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
         used_prefixes |= (prefixes & PREFIX_DATA);
       }
      OP_E (bytemode, sizeflag);
      return;
    }

  /* Skip mod/rm byte.  */
  MODRM_CHECK;
  codep++;
  used_prefixes |= (prefixes & PREFIX_DATA);
  if (prefixes & PREFIX_DATA)
    {
      int add = 0;

      USED_REX (REX_B);
      if (rex & REX_B)
       add = 8;
      sprintf (scratchbuf, "%%xmm%d", rm + add);
    }
  else
    sprintf (scratchbuf, "%%mm%d", rm);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_EMC ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5180 of file i386-dis.c.

{
  if (mod != 3)
    {
      if (intel_syntax && bytemode == v_mode)
       {
         bytemode = (prefixes & PREFIX_DATA) ? x_mode : q_mode;
         used_prefixes |= (prefixes & PREFIX_DATA);
       }
      OP_E (bytemode, sizeflag);
      return;
    }
  
  /* Skip mod/rm byte.  */
  MODRM_CHECK;
  codep++;
  used_prefixes |= (prefixes & PREFIX_DATA);
  sprintf (scratchbuf, "%%mm%d", rm);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_ESreg ( int  code,
int  sizeflag 
) [static]

Definition at line 5012 of file i386-dis.c.

{
  if (intel_syntax)
    {
      switch (codep[-1])
       {
       case 0x6d:    /* insw/insl */
         intel_operand_size (z_mode, sizeflag);
         break;
       case 0xa5:    /* movsw/movsl/movsq */
       case 0xa7:    /* cmpsw/cmpsl/cmpsq */
       case 0xab:    /* stosw/stosl */
       case 0xaf:    /* scasw/scasl */
         intel_operand_size (v_mode, sizeflag);
         break;
       default:
         intel_operand_size (b_mode, sizeflag);
       }
    }
  oappend ("%es:" + intel_syntax);
  ptr_reg (code, sizeflag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_EX ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5210 of file i386-dis.c.

{
  int add = 0;
  if (mod != 3)
    {
      if (intel_syntax && bytemode == v_mode)
       {
         switch (prefixes & (PREFIX_DATA|PREFIX_REPZ|PREFIX_REPNZ))
           {
           case 0:            bytemode = x_mode; break;
           case PREFIX_REPZ:  bytemode = d_mode; used_prefixes |= PREFIX_REPZ;  break;
           case PREFIX_DATA:  bytemode = x_mode; used_prefixes |= PREFIX_DATA;  break;
           case PREFIX_REPNZ: bytemode = q_mode; used_prefixes |= PREFIX_REPNZ; break;
           default:           bytemode = 0; break;
           }
       }
      OP_E (bytemode, sizeflag);
      return;
    }
  USED_REX (REX_B);
  if (rex & REX_B)
    add = 8;

  /* Skip mod/rm byte.  */
  MODRM_CHECK;
  codep++;
  sprintf (scratchbuf, "%%xmm%d", rm + add);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_G ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4459 of file i386-dis.c.

{
  int add = 0;
  USED_REX (REX_R);
  if (rex & REX_R)
    add += 8;
  switch (bytemode)
    {
    case b_mode:
      USED_REX (0);
      if (rex)
       oappend (names8rex[reg + add]);
      else
       oappend (names8[reg + add]);
      break;
    case w_mode:
      oappend (names16[reg + add]);
      break;
    case d_mode:
      oappend (names32[reg + add]);
      break;
    case q_mode:
      oappend (names64[reg + add]);
      break;
    case v_mode:
    case dq_mode:
    case dqw_mode:
      USED_REX (REX_W);
      if (rex & REX_W)
       oappend (names64[reg + add]);
      else if ((sizeflag & DFLAG) || bytemode != v_mode)
       oappend (names32[reg + add]);
      else
       oappend (names16[reg + add]);
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case m_mode:
      if (address_mode == mode_64bit)
       oappend (names64[reg + add]);
      else
       oappend (names32[reg + add]);
      break;
    default:
      oappend (INTERNAL_DISASSEMBLER_ERROR);
      break;
    }
}

Here is the call graph for this function:

static void OP_I ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4699 of file i386-dis.c.

{
  bfd_signed_vma op;
  bfd_signed_vma mask = -1;

  switch (bytemode)
    {
    case b_mode:
      FETCH_DATA (the_info, codep + 1);
      op = *codep++;
      mask = 0xff;
      break;
    case q_mode:
      if (address_mode == mode_64bit)
       {
         op = get32s ();
         break;
       }
      /* Fall through.  */
    case v_mode:
      USED_REX (REX_W);
      if (rex & REX_W)
       op = get32s ();
      else if (sizeflag & DFLAG)
       {
         op = get32 ();
         mask = 0xffffffff;
       }
      else
       {
         op = get16 ();
         mask = 0xfffff;
       }
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case w_mode:
      mask = 0xfffff;
      op = get16 ();
      break;
    case const_1_mode:
      if (intel_syntax)
        oappend ("1");
      return;
    default:
      oappend (INTERNAL_DISASSEMBLER_ERROR);
      return;
    }

  op &= mask;
  scratchbuf[0] = '$';
  print_operand_value (scratchbuf + 1, 1, op);
  oappend (scratchbuf + intel_syntax);
  scratchbuf[0] = '\0';
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_I64 ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4755 of file i386-dis.c.

{
  bfd_signed_vma op;
  bfd_signed_vma mask = -1;

  if (address_mode != mode_64bit)
    {
      OP_I (bytemode, sizeflag);
      return;
    }

  switch (bytemode)
    {
    case b_mode:
      FETCH_DATA (the_info, codep + 1);
      op = *codep++;
      mask = 0xff;
      break;
    case v_mode:
      USED_REX (REX_W);
      if (rex & REX_W)
       op = get64 ();
      else if (sizeflag & DFLAG)
       {
         op = get32 ();
         mask = 0xffffffff;
       }
      else
       {
         op = get16 ();
         mask = 0xfffff;
       }
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case w_mode:
      mask = 0xfffff;
      op = get16 ();
      break;
    default:
      oappend (INTERNAL_DISASSEMBLER_ERROR);
      return;
    }

  op &= mask;
  scratchbuf[0] = '$';
  print_operand_value (scratchbuf + 1, 1, op);
  oappend (scratchbuf + intel_syntax);
  scratchbuf[0] = '\0';
}

Here is the call graph for this function:

static void OP_IMREG ( int  code,
int  sizeflag 
) [static]

Definition at line 4644 of file i386-dis.c.

{
  const char *s;

  switch (code)
    {
    case indir_dx_reg:
      if (intel_syntax)
       s = "dx";
      else
       s = "(%dx)";
      break;
    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
    case sp_reg: case bp_reg: case si_reg: case di_reg:
      s = names16[code - ax_reg];
      break;
    case es_reg: case ss_reg: case cs_reg:
    case ds_reg: case fs_reg: case gs_reg:
      s = names_seg[code - es_reg];
      break;
    case al_reg: case ah_reg: case cl_reg: case ch_reg:
    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
      USED_REX (0);
      if (rex)
       s = names8rex[code - al_reg];
      else
       s = names8[code - al_reg];
      break;
    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
      USED_REX (REX_W);
      if (rex & REX_W)
       s = names64[code - eAX_reg];
      else if (sizeflag & DFLAG)
       s = names32[code - eAX_reg];
      else
       s = names16[code - eAX_reg];
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case z_mode_ax_reg:
      if ((rex & REX_W) || (sizeflag & DFLAG))
       s = *names32;
      else
       s = *names16;
      if (!(rex & REX_W))
       used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    default:
      s = INTERNAL_DISASSEMBLER_ERROR;
      break;
    }
  oappend (s);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_indirE ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4045 of file i386-dis.c.

{
  if (!intel_syntax)
    oappend ("*");
  OP_E (bytemode, sizeflag);
}

Here is the call graph for this function:

static void OP_J ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4855 of file i386-dis.c.

{
  bfd_vma disp;
  bfd_vma mask = -1;
  bfd_vma segment = 0;

  switch (bytemode)
    {
    case b_mode:
      FETCH_DATA (the_info, codep + 1);
      disp = *codep++;
      if ((disp & 0x80) != 0)
       disp -= 0x100;
      break;
    case v_mode:
      if ((sizeflag & DFLAG) || (rex & REX_W))
       disp = get32s ();
      else
       {
         disp = get16 ();
         if ((disp & 0x8000) != 0)
           disp -= 0x10000;
         /* In 16bit mode, address is wrapped around at 64k within
            the same segment.  Otherwise, a data16 prefix on a jump
            instruction means that the pc is masked to 16 bits after
            the displacement is added!  */
         mask = 0xffff;
         if ((prefixes & PREFIX_DATA) == 0)
           segment = ((start_pc + codep - start_codep)
                     & ~((bfd_vma) 0xffff));
       }
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    default:
      oappend (INTERNAL_DISASSEMBLER_ERROR);
      return;
    }
  disp = ((start_pc + codep - start_codep + disp) & mask) | segment;
  set_op (disp, 0);
  print_operand_value (scratchbuf, 1, disp);
  oappend (scratchbuf);
}

Here is the call graph for this function:

static void OP_M ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5259 of file i386-dis.c.

{
  if (mod == 3)
    /* bad bound,lea,lds,les,lfs,lgs,lss,cmpxchg8b,vmptrst modrm */
    BadOp ();
  else
    OP_E (bytemode, sizeflag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_MMX ( int  ,
int   
) [static]
static void OP_MMX ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5115 of file i386-dis.c.

{
  used_prefixes |= (prefixes & PREFIX_DATA);
  if (prefixes & PREFIX_DATA)
    {
      int add = 0;
      USED_REX (REX_R);
      if (rex & REX_R)
       add = 8;
      sprintf (scratchbuf, "%%xmm%d", reg + add);
    }
  else
    sprintf (scratchbuf, "%%mm%d", reg);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_MS ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5241 of file i386-dis.c.

{
  if (mod == 3)
    OP_EM (bytemode, sizeflag);
  else
    BadOp ();
}

Here is the call graph for this function:

static void OP_MXC ( int  ,
int   
) [static]
static void OP_MXC ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5202 of file i386-dis.c.

{
  used_prefixes |= (prefixes & PREFIX_DATA);
  sprintf (scratchbuf, "%%mm%d", reg);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_OFF ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4931 of file i386-dis.c.

{
  bfd_vma off;

  if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
    intel_operand_size (bytemode, sizeflag);
  append_seg ();

  if ((sizeflag & AFLAG) || address_mode == mode_64bit)
    off = get32 ();
  else
    off = get16 ();

  if (intel_syntax)
    {
      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
                     | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
       {
         oappend (names_seg[ds_reg - es_reg]);
         oappend (":");
       }
    }
  print_operand_value (scratchbuf, 1, off);
  oappend (scratchbuf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void OP_OFF64 ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4958 of file i386-dis.c.

{
  bfd_vma off;

  if (address_mode != mode_64bit
      || (prefixes & PREFIX_ADDR))
    {
      OP_OFF (bytemode, sizeflag);
      return;
    }

  if (intel_syntax && (sizeflag & SUFFIX_ALWAYS))
    intel_operand_size (bytemode, sizeflag);
  append_seg ();

  off = get64 ();

  if (intel_syntax)
    {
      if (!(prefixes & (PREFIX_CS | PREFIX_SS | PREFIX_DS
                     | PREFIX_ES | PREFIX_FS | PREFIX_GS)))
       {
         oappend (names_seg[ds_reg - es_reg]);
         oappend (":");
       }
    }
  print_operand_value (scratchbuf, 1, off);
  oappend (scratchbuf);
}

Here is the call graph for this function:

static void OP_R ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5106 of file i386-dis.c.

{
  if (mod == 3)
    OP_E (bytemode, sizeflag);
  else
    BadOp ();
}

Here is the call graph for this function:

static void OP_REG ( int  code,
int  sizeflag 
) [static]

Definition at line 4590 of file i386-dis.c.

{
  const char *s;
  int add = 0;
  USED_REX (REX_B);
  if (rex & REX_B)
    add = 8;

  switch (code)
    {
    case ax_reg: case cx_reg: case dx_reg: case bx_reg:
    case sp_reg: case bp_reg: case si_reg: case di_reg:
      s = names16[code - ax_reg + add];
      break;
    case es_reg: case ss_reg: case cs_reg:
    case ds_reg: case fs_reg: case gs_reg:
      s = names_seg[code - es_reg + add];
      break;
    case al_reg: case ah_reg: case cl_reg: case ch_reg:
    case dl_reg: case dh_reg: case bl_reg: case bh_reg:
      USED_REX (0);
      if (rex)
       s = names8rex[code - al_reg + add];
      else
       s = names8[code - al_reg];
      break;
    case rAX_reg: case rCX_reg: case rDX_reg: case rBX_reg:
    case rSP_reg: case rBP_reg: case rSI_reg: case rDI_reg:
      if (address_mode == mode_64bit && (sizeflag & DFLAG))
       {
         s = names64[code - rAX_reg + add];
         break;
       }
      code += eAX_reg - rAX_reg;
      /* Fall through.  */
    case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg:
    case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg:
      USED_REX (REX_W);
      if (rex & REX_W)
       s = names64[code - eAX_reg + add];
      else if (sizeflag & DFLAG)
       s = names32[code - eAX_reg + add];
      else
       s = names16[code - eAX_reg + add];
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    default:
      s = INTERNAL_DISASSEMBLER_ERROR;
      break;
    }
  oappend (s);
}

Here is the call graph for this function:

static void OP_SEG ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4899 of file i386-dis.c.

{
  if (bytemode == w_mode)
    oappend (names_seg[reg]);
  else
    OP_E (mod == 3 ? bytemode : w_mode, sizeflag);
}

Here is the call graph for this function:

static void OP_sI ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 4806 of file i386-dis.c.

{
  bfd_signed_vma op;
  bfd_signed_vma mask = -1;

  switch (bytemode)
    {
    case b_mode:
      FETCH_DATA (the_info, codep + 1);
      op = *codep++;
      if ((op & 0x80) != 0)
       op -= 0x100;
      mask = 0xffffffff;
      break;
    case v_mode:
      USED_REX (REX_W);
      if (rex & REX_W)
       op = get32s ();
      else if (sizeflag & DFLAG)
       {
         op = get32s ();
         mask = 0xffffffff;
       }
      else
       {
         mask = 0xffffffff;
         op = get16 ();
         if ((op & 0x8000) != 0)
           op -= 0x10000;
       }
      used_prefixes |= (prefixes & PREFIX_DATA);
      break;
    case w_mode:
      op = get16 ();
      mask = 0xffffffff;
      if ((op & 0x8000) != 0)
       op -= 0x10000;
      break;
    default:
      oappend (INTERNAL_DISASSEMBLER_ERROR);
      return;
    }

  scratchbuf[0] = '$';
  print_operand_value (scratchbuf + 1, 1, op);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_SIMD_Suffix ( int  ,
int   
) [static]
static void OP_SIMD_Suffix ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5429 of file i386-dis.c.

{
  unsigned int cmp_type;

  FETCH_DATA (the_info, codep + 1);
  obufp = obuf + strlen (obuf);
  cmp_type = *codep++ & 0xff;
  if (cmp_type < 8)
    {
      char suffix1 = 'p', suffix2 = 's';
      used_prefixes |= (prefixes & PREFIX_REPZ);
      if (prefixes & PREFIX_REPZ)
       suffix1 = 's';
      else
       {
         used_prefixes |= (prefixes & PREFIX_DATA);
         if (prefixes & PREFIX_DATA)
           suffix2 = 'd';
         else
           {
             used_prefixes |= (prefixes & PREFIX_REPNZ);
             if (prefixes & PREFIX_REPNZ)
              suffix1 = 's', suffix2 = 'd';
           }
       }
      sprintf (scratchbuf, "cmp%s%c%c",
              simd_cmp_op[cmp_type], suffix1, suffix2);
      used_prefixes |= (prefixes & PREFIX_REPZ);
      oappend (scratchbuf);
    }
  else
    {
      /* We have a bad extension byte.  Clean up.  */
      op_out[0][0] = '\0';
      op_out[1][0] = '\0';
      BadOp ();
    }
}

Here is the call graph for this function:

static void OP_ST ( int  ,
int   
) [static]
static void OP_ST ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 3669 of file i386-dis.c.

{
  oappend ("%st" + intel_syntax);
}

Here is the call graph for this function:

static void OP_STi ( int  ,
int   
) [static]
static void OP_STi ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 3675 of file i386-dis.c.

{
  sprintf (scratchbuf, "%%st(%d)", rm);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_T ( int  ,
int   
) [static]
static void OP_T ( int dummy  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5099 of file i386-dis.c.

{
  sprintf (scratchbuf, "%%tr%d", reg);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_VMX ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5683 of file i386-dis.c.

{
  used_prefixes |= (prefixes & (PREFIX_DATA | PREFIX_REPZ));
  if (prefixes & PREFIX_DATA)
    strcpy (obuf, "vmclear");
  else if (prefixes & PREFIX_REPZ)
    strcpy (obuf, "vmxon");
  else
    strcpy (obuf, "vmptrld");
  OP_E (bytemode, sizeflag);
}

Here is the call graph for this function:

static void OP_XMM ( int  ,
int   
) [static]
static void OP_XMM ( int bytemode  ATTRIBUTE_UNUSED,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5132 of file i386-dis.c.

{
  int add = 0;
  USED_REX (REX_R);
  if (rex & REX_R)
    add = 8;
  sprintf (scratchbuf, "%%xmm%d", reg + add);
  oappend (scratchbuf + intel_syntax);
}

Here is the call graph for this function:

static void OP_XS ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5250 of file i386-dis.c.

{
  if (mod == 3)
    OP_EX (bytemode, sizeflag);
  else
    BadOp ();
}

Here is the call graph for this function:

static void PNI_Fixup ( int  ,
int   
) [static]
static void PNI_Fixup ( int extrachar  ATTRIBUTE_UNUSED,
int  sizeflag 
) [static]

Definition at line 5485 of file i386-dis.c.

{
  if (mod == 3 && reg == 1 && rm <= 1)
    {
      /* Override "sidt".  */
      size_t olen = strlen (obuf);
      char *p = obuf + olen - 4;
      const char **names = (address_mode == mode_64bit
                         ? names64 : names32);

      /* We might have a suffix when disassembling with -Msuffix.  */
      if (*p == 'i')
       --p;

      /* Remove "addr16/addr32" if we aren't in Intel mode.  */
      if (!intel_syntax
         && (prefixes & PREFIX_ADDR)
         && olen >= (4 + 7)
         && *(p - 1) == ' '
         && CONST_STRNEQ (p - 7, "addr")
         && (CONST_STRNEQ (p - 3, "16")
             || CONST_STRNEQ (p - 3, "32")))
       p -= 7;

      if (rm)
       {
         /* mwait %eax,%ecx  */
         strcpy (p, "mwait");
         if (!intel_syntax)
           strcpy (op_out[0], names[0]);
       }
      else
       {
         /* monitor %eax,%ecx,%edx"  */
         strcpy (p, "monitor");
         if (!intel_syntax)
           {
             const char **op1_names;
             if (!(prefixes & PREFIX_ADDR))
              op1_names = (address_mode == mode_16bit
                          ? names16 : names);
             else
              {
                op1_names = (address_mode != mode_32bit
                            ? names32 : names16);
                used_prefixes |= PREFIX_ADDR;
              }
             strcpy (op_out[0], op1_names[0]);
             strcpy (op_out[2], names[2]);
           }
       }
      if (!intel_syntax)
       {
         strcpy (op_out[1], names[1]);
         two_source_ops = 1;
       }

      codep++;
    }
  else
    OP_M (0, sizeflag);
}

Here is the call graph for this function:

static const char * prefix_name ( int  pref,
int  sizeflag 
) [static]

Definition at line 2735 of file i386-dis.c.

{
  static const char *rexes [16] =
    {
      "rex",         /* 0x40 */
      "rex.B",              /* 0x41 */
      "rex.X",              /* 0x42 */
      "rex.XB",             /* 0x43 */
      "rex.R",              /* 0x44 */
      "rex.RB",             /* 0x45 */
      "rex.RX",             /* 0x46 */
      "rex.RXB",     /* 0x47 */
      "rex.W",              /* 0x48 */
      "rex.WB",             /* 0x49 */
      "rex.WX",             /* 0x4a */
      "rex.WXB",     /* 0x4b */
      "rex.WR",             /* 0x4c */
      "rex.WRB",     /* 0x4d */
      "rex.WRX",     /* 0x4e */
      "rex.WRXB",    /* 0x4f */
    };

  switch (pref)
    {
    /* REX prefixes family.  */
    case 0x40:
    case 0x41:
    case 0x42:
    case 0x43:
    case 0x44:
    case 0x45:
    case 0x46:
    case 0x47:
    case 0x48:
    case 0x49:
    case 0x4a:
    case 0x4b:
    case 0x4c:
    case 0x4d:
    case 0x4e:
    case 0x4f:
      return rexes [pref - 0x40];
    case 0xf3:
      return "repz";
    case 0xf2:
      return "repnz";
    case 0xf0:
      return "lock";
    case 0x2e:
      return "cs";
    case 0x36:
      return "ss";
    case 0x3e:
      return "ds";
    case 0x26:
      return "es";
    case 0x64:
      return "fs";
    case 0x65:
      return "gs";
    case 0x66:
      return (sizeflag & DFLAG) ? "data16" : "data32";
    case 0x67:
      if (address_mode == mode_64bit)
       return (sizeflag & AFLAG) ? "addr32" : "addr64";
      else
       return (sizeflag & AFLAG) ? "addr16" : "addr32";
    case FWAIT_OPCODE:
      return "fwait";
    default:
      return NULL;
    }
}

Here is the caller graph for this function:

void print_i386_disassembler_options ( FILE *  stream)

Definition at line 2859 of file i386-dis.c.

{
  fprintf (stream, _("\n\
The following i386/x86-64 specific disassembler options are supported for use\n\
with the -M switch (multiple options should be separated by commas):\n"));

  fprintf (stream, _("  x86-64      Disassemble in 64bit mode\n"));
  fprintf (stream, _("  i386        Disassemble in 32bit mode\n"));
  fprintf (stream, _("  i8086       Disassemble in 16bit mode\n"));
  fprintf (stream, _("  att         Display instruction in AT&T syntax\n"));
  fprintf (stream, _("  intel       Display instruction in Intel syntax\n"));
  fprintf (stream, _("  addr64      Assume 64bit address size\n"));
  fprintf (stream, _("  addr32      Assume 32bit address size\n"));
  fprintf (stream, _("  addr16      Assume 16bit address size\n"));
  fprintf (stream, _("  data32      Assume 32bit data size\n"));
  fprintf (stream, _("  data16      Assume 16bit data size\n"));
  fprintf (stream, _("  suffix      Always display instruction suffix in AT&T syntax\n"));
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int print_insn ( bfd_vma  pc,
disassemble_info info 
) [static]

Definition at line 2879 of file i386-dis.c.

{
  const struct dis386 *dp;
  int i;
  char *op_txt[MAX_OPERANDS];
  int needcomma;
  unsigned char uses_DATA_prefix, uses_LOCK_prefix;
  unsigned char uses_REPNZ_prefix, uses_REPZ_prefix;
  int sizeflag;
  const char *p;
  struct dis_private priv;
  unsigned char op;

  if (info->mach == bfd_mach_x86_64_intel_syntax
      || info->mach == bfd_mach_x86_64)
    address_mode = mode_64bit;
  else
    address_mode = mode_32bit;

  if (intel_syntax == (char) -1)
    intel_syntax = (info->mach == bfd_mach_i386_i386_intel_syntax
                  || info->mach == bfd_mach_x86_64_intel_syntax);

  if (info->mach == bfd_mach_i386_i386
      || info->mach == bfd_mach_x86_64
      || info->mach == bfd_mach_i386_i386_intel_syntax
      || info->mach == bfd_mach_x86_64_intel_syntax)
    priv.orig_sizeflag = AFLAG | DFLAG;
  else if (info->mach == bfd_mach_i386_i8086)
    priv.orig_sizeflag = 0;
  else
    abort ();

  for (p = info->disassembler_options; p != NULL; )
    {
      if (CONST_STRNEQ (p, "x86-64"))
       {
         address_mode = mode_64bit;
         priv.orig_sizeflag = AFLAG | DFLAG;
       }
      else if (CONST_STRNEQ (p, "i386"))
       {
         address_mode = mode_32bit;
         priv.orig_sizeflag = AFLAG | DFLAG;
       }
      else if (CONST_STRNEQ (p, "i8086"))
       {
         address_mode = mode_16bit;
         priv.orig_sizeflag = 0;
       }
      else if (CONST_STRNEQ (p, "intel"))
       {
         intel_syntax = 1;
       }
      else if (CONST_STRNEQ (p, "att"))
       {
         intel_syntax = 0;
       }
      else if (CONST_STRNEQ (p, "addr"))
       {
         if (address_mode == mode_64bit)
           {
             if (p[4] == '3' && p[5] == '2')
              priv.orig_sizeflag &= ~AFLAG;
             else if (p[4] == '6' && p[5] == '4')
              priv.orig_sizeflag |= AFLAG;
           }
         else
           {
             if (p[4] == '1' && p[5] == '6')
              priv.orig_sizeflag &= ~AFLAG;
             else if (p[4] == '3' && p[5] == '2')
              priv.orig_sizeflag |= AFLAG;
           }
       }
      else if (CONST_STRNEQ (p, "data"))
       {
         if (p[4] == '1' && p[5] == '6')
           priv.orig_sizeflag &= ~DFLAG;
         else if (p[4] == '3' && p[5] == '2')
           priv.orig_sizeflag |= DFLAG;
       }
      else if (CONST_STRNEQ (p, "suffix"))
       priv.orig_sizeflag |= SUFFIX_ALWAYS;

      p = strchr (p, ',');
      if (p != NULL)
       p++;
    }

  if (intel_syntax)
    {
      names64 = intel_names64;
      names32 = intel_names32;
      names16 = intel_names16;
      names8 = intel_names8;
      names8rex = intel_names8rex;
      names_seg = intel_names_seg;
      index16 = intel_index16;
      open_char = '[';
      close_char = ']';
      separator_char = '+';
      scale_char = '*';
    }
  else
    {
      names64 = att_names64;
      names32 = att_names32;
      names16 = att_names16;
      names8 = att_names8;
      names8rex = att_names8rex;
      names_seg = att_names_seg;
      index16 = att_index16;
      open_char = '(';
      close_char =  ')';
      separator_char = ',';
      scale_char = ',';
    }

  /* The output looks better if we put 7 bytes on a line, since that
     puts most long word instructions on a single line.  */
  info->bytes_per_line = 7;

  info->private_data = &priv;
  priv.max_fetched = priv.the_buffer;
  priv.insn_start = pc;

  obuf[0] = 0;
  for (i = 0; i < MAX_OPERANDS; ++i)
    {
      op_out[i][0] = 0;
      op_index[i] = -1;
    }

  the_info = info;
  start_pc = pc;
  start_codep = priv.the_buffer;
  codep = priv.the_buffer;

  if (setjmp (priv.bailout) != 0)
    {
      const char *name;

      /* Getting here means we tried for data but didn't get it.  That
        means we have an incomplete instruction of some sort.  Just
        print the first byte as a prefix or a .byte pseudo-op.  */
      if (codep > priv.the_buffer)
       {
         name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
         if (name != NULL)
           (*info->fprintf_func) (info->stream, "%s", name);
         else
           {
             /* Just print the first byte as a .byte instruction.  */
             (*info->fprintf_func) (info->stream, ".byte 0x%x",
                                 (unsigned int) priv.the_buffer[0]);
           }

         return 1;
       }

      return -1;
    }

  obufp = obuf;
  ckprefix ();

  insn_codep = codep;
  sizeflag = priv.orig_sizeflag;

  FETCH_DATA (info, codep + 1);
  two_source_ops = (*codep == 0x62) || (*codep == 0xc8);

  if (((prefixes & PREFIX_FWAIT)
       && ((*codep < 0xd8) || (*codep > 0xdf)))
      || (rex && rex_used))
    {
      const char *name;

      /* fwait not followed by floating point instruction, or rex followed
        by other prefixes.  Print the first prefix.  */
      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
      if (name == NULL)
       name = INTERNAL_DISASSEMBLER_ERROR;
      (*info->fprintf_func) (info->stream, "%s", name);
      return 1;
    }

  op = 0;
  if (*codep == 0x0f)
    {
      unsigned char threebyte;
      FETCH_DATA (info, codep + 2);
      threebyte = *++codep;
      dp = &dis386_twobyte[threebyte];
      need_modrm = twobyte_has_modrm[*codep];
      uses_DATA_prefix = twobyte_uses_DATA_prefix[*codep];
      uses_REPNZ_prefix = twobyte_uses_REPNZ_prefix[*codep];
      uses_REPZ_prefix = twobyte_uses_REPZ_prefix[*codep];
      uses_LOCK_prefix = (*codep & ~0x02) == 0x20;
      codep++;
      if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
       {
         FETCH_DATA (info, codep + 2);
         op = *codep++;
         switch (threebyte)
           {
           case 0x38:
             uses_DATA_prefix = threebyte_0x38_uses_DATA_prefix[op];
             uses_REPNZ_prefix = threebyte_0x38_uses_REPNZ_prefix[op];
             uses_REPZ_prefix = threebyte_0x38_uses_REPZ_prefix[op];
             break;
           case 0x3a:
             uses_DATA_prefix = threebyte_0x3a_uses_DATA_prefix[op];
             uses_REPNZ_prefix = threebyte_0x3a_uses_REPNZ_prefix[op];
             uses_REPZ_prefix = threebyte_0x3a_uses_REPZ_prefix[op];
             break;
           default:
             break;
           }
       }
    }
  else
    {
      dp = &dis386[*codep];
      need_modrm = onebyte_has_modrm[*codep];
      uses_DATA_prefix = 0;
      uses_REPNZ_prefix = 0;
      /* pause is 0xf3 0x90.  */
      uses_REPZ_prefix = *codep == 0x90;
      uses_LOCK_prefix = 0;
      codep++;
    }
  
  if (!uses_REPZ_prefix && (prefixes & PREFIX_REPZ))
    {
      oappend ("repz ");
      used_prefixes |= PREFIX_REPZ;
    }
  if (!uses_REPNZ_prefix && (prefixes & PREFIX_REPNZ))
    {
      oappend ("repnz ");
      used_prefixes |= PREFIX_REPNZ;
    }

  if (!uses_LOCK_prefix && (prefixes & PREFIX_LOCK))
    {
      oappend ("lock ");
      used_prefixes |= PREFIX_LOCK;
    }

  if (prefixes & PREFIX_ADDR)
    {
      sizeflag ^= AFLAG;
      if (dp->op[2].bytemode != loop_jcxz_mode || intel_syntax)
       {
         if ((sizeflag & AFLAG) || address_mode == mode_64bit)
           oappend ("addr32 ");
         else
           oappend ("addr16 ");
         used_prefixes |= PREFIX_ADDR;
       }
    }

  if (!uses_DATA_prefix && (prefixes & PREFIX_DATA))
    {
      sizeflag ^= DFLAG;
      if (dp->op[2].bytemode == cond_jump_mode
         && dp->op[0].bytemode == v_mode
         && !intel_syntax)
       {
         if (sizeflag & DFLAG)
           oappend ("data32 ");
         else
           oappend ("data16 ");
         used_prefixes |= PREFIX_DATA;
       }
    }

  if (dp->name == NULL && dp->op[0].bytemode == IS_3BYTE_OPCODE)
    {
      dp = &three_byte_table[dp->op[1].bytemode][op];
      mod = (*codep >> 6) & 3;
      reg = (*codep >> 3) & 7;
      rm = *codep & 7;
    }
  else if (need_modrm)
    {
      FETCH_DATA (info, codep + 1);
      mod = (*codep >> 6) & 3;
      reg = (*codep >> 3) & 7;
      rm = *codep & 7;
    }

  if (dp->name == NULL && dp->op[0].bytemode == FLOATCODE)
    {
      dofloat (sizeflag);
    }
  else
    {
      int index;
      if (dp->name == NULL)
       {
         switch (dp->op[0].bytemode)
           {
           case USE_GROUPS:
             dp = &grps[dp->op[1].bytemode][reg];
             break;

           case USE_PREFIX_USER_TABLE:
             index = 0;
             used_prefixes |= (prefixes & PREFIX_REPZ);
             if (prefixes & PREFIX_REPZ)
              index = 1;
             else
              {
                /* We should check PREFIX_REPNZ and PREFIX_REPZ
                   before PREFIX_DATA.  */
                used_prefixes |= (prefixes & PREFIX_REPNZ);
                if (prefixes & PREFIX_REPNZ)
                  index = 3;
                else
                  {
                    used_prefixes |= (prefixes & PREFIX_DATA);
                    if (prefixes & PREFIX_DATA)
                     index = 2;
                  }
              }
             dp = &prefix_user_table[dp->op[1].bytemode][index];
             break;

           case X86_64_SPECIAL:
             index = address_mode == mode_64bit ? 1 : 0;
             dp = &x86_64_table[dp->op[1].bytemode][index];
             break;

           default:
             oappend (INTERNAL_DISASSEMBLER_ERROR);
             break;
           }
       }

      if (putop (dp->name, sizeflag) == 0)
        {
         for (i = 0; i < MAX_OPERANDS; ++i)
           {
             obufp = op_out[i];             
             op_ad = MAX_OPERANDS - 1 - i;
             if (dp->op[i].rtn)
              (*dp->op[i].rtn) (dp->op[i].bytemode, sizeflag);
           }
       }
    }

  /* See if any prefixes were not used.  If so, print the first one
     separately.  If we don't do this, we'll wind up printing an
     instruction stream which does not precisely correspond to the
     bytes we are disassembling.  */
  if ((prefixes & ~used_prefixes) != 0)
    {
      const char *name;

      name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
      if (name == NULL)
       name = INTERNAL_DISASSEMBLER_ERROR;
      (*info->fprintf_func) (info->stream, "%s", name);
      return 1;
    }
  if (rex & ~rex_used)
    {
      const char *name;
      name = prefix_name (rex | 0x40, priv.orig_sizeflag);
      if (name == NULL)
       name = INTERNAL_DISASSEMBLER_ERROR;
      (*info->fprintf_func) (info->stream, "%s ", name);
    }

  obufp = obuf + strlen (obuf);
  for (i = strlen (obuf); i < 6; i++)
    oappend (" ");
  oappend (" ");
  (*info->fprintf_func) (info->stream, "%s", obuf);

  /* The enter and bound instructions are printed with operands in the same
     order as the intel book; everything else is printed in reverse order.  */
  if (intel_syntax || two_source_ops)
    {
      for (i = 0; i < MAX_OPERANDS; ++i)
        op_txt[i] = op_out[i];
       
      for (i = 0; i < (MAX_OPERANDS >> 1); ++i)
       {
          op_ad = op_index[i];
          op_index[i] = op_index[MAX_OPERANDS - 1 - i];
          op_index[MAX_OPERANDS - 1 - i] = op_ad;
       }
    }
  else
    {
      for (i = 0; i < MAX_OPERANDS; ++i)
        op_txt[MAX_OPERANDS - 1 - i] = op_out[i];
    }

  needcomma = 0;
  for (i = 0; i < MAX_OPERANDS; ++i)
    if (*op_txt[i])
      {
       if (needcomma)
         (*info->fprintf_func) (info->stream, ",");
       if (op_index[i] != -1 && !op_riprel[i])
         (*info->print_address_func) ((bfd_vma) op_address[op_index[i]], info);
       else
         (*info->fprintf_func) (info->stream, "%s", op_txt[i]);
       needcomma = 1;
      }

  for (i = 0; i < MAX_OPERANDS; i++)
    if (op_index[i] != -1 && op_riprel[i])
      {
       (*info->fprintf_func) (info->stream, "        # ");
       (*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
                                          + op_address[op_index[i]]), info);
      }
  return codep - priv.the_buffer;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2851 of file i386-dis.c.

{
  intel_syntax = -1;

  return print_insn (pc, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 2835 of file i386-dis.c.

{
  intel_syntax = 0;

  return print_insn (pc, info);
}

Here is the call graph for this function:

Definition at line 2843 of file i386-dis.c.

{
  intel_syntax = 1;

  return print_insn (pc, info);
}

Here is the call graph for this function:

static void print_operand_value ( char *  buf,
int  hex,
bfd_vma  disp 
) [static]

Definition at line 4053 of file i386-dis.c.

{
  if (address_mode == mode_64bit)
    {
      if (hex)
       {
         char tmp[30];
         int i;
         buf[0] = '0';
         buf[1] = 'x';
         sprintf_vma (tmp, disp);
         for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
         strcpy (buf + 2, tmp + i);
       }
      else
       {
         bfd_signed_vma v = disp;
         char tmp[30];
         int i;
         if (v < 0)
           {
             *(buf++) = '-';
             v = -disp;
             /* Check for possible overflow on 0x8000000000000000.  */
             if (v < 0)
              {
                strcpy (buf, "9223372036854775808");
                return;
              }
           }
         if (!v)
           {
             strcpy (buf, "0");
             return;
           }

         i = 0;
         tmp[29] = 0;
         while (v)
           {
             tmp[28 - i] = (v % 10) + '0';
             v /= 10;
             i++;
           }
         strcpy (buf, tmp + 29 - i);
       }
    }
  else
    {
      if (hex)
       sprintf (buf, "0x%x", (unsigned int) disp);
      else
       sprintf (buf, "%d", (int) disp);
    }
}

Here is the caller graph for this function:

static void ptr_reg ( int  code,
int  sizeflag 
) [static]

Definition at line 4989 of file i386-dis.c.

{
  const char *s;

  *obufp++ = open_char;
  used_prefixes |= (prefixes & PREFIX_ADDR);
  if (address_mode == mode_64bit)
    {
      if (!(sizeflag & AFLAG))
       s = names32[code - eAX_reg];
      else
       s = names64[code - eAX_reg];
    }
  else if (sizeflag & AFLAG)
    s = names32[code - eAX_reg];
  else
    s = names16[code - eAX_reg];
  oappend (s);
  *obufp++ = close_char;
  *obufp = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int putop ( const char *  template,
int  sizeflag 
) [static]

Definition at line 3683 of file i386-dis.c.

{
  const char *p;
  int alt = 0;

  for (p = template; *p; p++)
    {
      switch (*p)
       {
       default:
         *obufp++ = *p;
         break;
       case '{':
         alt = 0;
         if (intel_syntax)
           alt += 1;
         if (address_mode == mode_64bit)
           alt += 2;
         while (alt != 0)
           {
             while (*++p != '|')
              {
                if (*p == '}')
                  {
                    /* Alternative not valid.  */
                    strcpy (obuf, "(bad)");
                    obufp = obuf + 5;
                    return 1;
                  }
                else if (*p == '\0')
                  abort ();
              }
             alt--;
           }
         /* Fall through.  */
       case 'I':
         alt = 1;
         continue;
       case '|':
         while (*++p != '}')
           {
             if (*p == '\0')
              abort ();
           }
         break;
       case '}':
         break;
       case 'A':
         if (intel_syntax)
           break;
         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
           *obufp++ = 'b';
         break;
       case 'B':
         if (intel_syntax)
           break;
         if (sizeflag & SUFFIX_ALWAYS)
           *obufp++ = 'b';
         break;
       case 'C':
         if (intel_syntax && !alt)
           break;
         if ((prefixes & PREFIX_DATA) || (sizeflag & SUFFIX_ALWAYS))
           {
             if (sizeflag & DFLAG)
              *obufp++ = intel_syntax ? 'd' : 'l';
             else
              *obufp++ = intel_syntax ? 'w' : 's';
             used_prefixes |= (prefixes & PREFIX_DATA);
           }
         break;
       case 'D':
         if (intel_syntax || !(sizeflag & SUFFIX_ALWAYS))
           break;
         USED_REX (REX_W);
         if (mod == 3)
           {
             if (rex & REX_W)
              *obufp++ = 'q';
             else if (sizeflag & DFLAG)
              *obufp++ = intel_syntax ? 'd' : 'l';
             else
              *obufp++ = 'w';
             used_prefixes |= (prefixes & PREFIX_DATA);
           }
         else
           *obufp++ = 'w';
         break;
       case 'E':            /* For jcxz/jecxz */
         if (address_mode == mode_64bit)
           {
             if (sizeflag & AFLAG)
              *obufp++ = 'r';
             else
              *obufp++ = 'e';
           }
         else
           if (sizeflag & AFLAG)
             *obufp++ = 'e';
         used_prefixes |= (prefixes & PREFIX_ADDR);
         break;
       case 'F':
         if (intel_syntax)
           break;
         if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
           {
             if (sizeflag & AFLAG)
              *obufp++ = address_mode == mode_64bit ? 'q' : 'l';
             else
              *obufp++ = address_mode == mode_64bit ? 'l' : 'w';
             used_prefixes |= (prefixes & PREFIX_ADDR);
           }
         break;
       case 'G':
         if (intel_syntax || (obufp[-1] != 's' && !(sizeflag & SUFFIX_ALWAYS)))
           break;
         if ((rex & REX_W) || (sizeflag & DFLAG))
           *obufp++ = 'l';
         else
           *obufp++ = 'w';
         if (!(rex & REX_W))
           used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       case 'H':
         if (intel_syntax)
           break;
         if ((prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_CS
             || (prefixes & (PREFIX_CS | PREFIX_DS)) == PREFIX_DS)
           {
             used_prefixes |= prefixes & (PREFIX_CS | PREFIX_DS);
             *obufp++ = ',';
             *obufp++ = 'p';
             if (prefixes & PREFIX_DS)
              *obufp++ = 't';
             else
              *obufp++ = 'n';
           }
         break;
       case 'J':
         if (intel_syntax)
           break;
         *obufp++ = 'l';
         break;
       case 'Z':
         if (intel_syntax)
           break;
         if (address_mode == mode_64bit && (sizeflag & SUFFIX_ALWAYS))
           {
             *obufp++ = 'q';
             break;
           }
         /* Fall through.  */
       case 'L':
         if (intel_syntax)
           break;
         if (sizeflag & SUFFIX_ALWAYS)
           *obufp++ = 'l';
         break;
       case 'N':
         if ((prefixes & PREFIX_FWAIT) == 0)
           *obufp++ = 'n';
         else
           used_prefixes |= PREFIX_FWAIT;
         break;
       case 'O':
         USED_REX (REX_W);
         if (rex & REX_W)
           *obufp++ = 'o';
         else if (intel_syntax && (sizeflag & DFLAG))
           *obufp++ = 'q';
         else
           *obufp++ = 'd';
         if (!(rex & REX_W))
           used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       case 'T':
         if (intel_syntax)
           break;
         if (address_mode == mode_64bit && (sizeflag & DFLAG))
           {
             *obufp++ = 'q';
             break;
           }
         /* Fall through.  */
       case 'P':
         if (intel_syntax)
           break;
         if ((prefixes & PREFIX_DATA)
             || (rex & REX_W)
             || (sizeflag & SUFFIX_ALWAYS))
           {
             USED_REX (REX_W);
             if (rex & REX_W)
              *obufp++ = 'q';
             else
              {
                 if (sizeflag & DFLAG)
                    *obufp++ = 'l';
                 else
                   *obufp++ = 'w';
              }
             used_prefixes |= (prefixes & PREFIX_DATA);
           }
         break;
       case 'U':
         if (intel_syntax)
           break;
         if (address_mode == mode_64bit && (sizeflag & DFLAG))
           {
             if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
              *obufp++ = 'q';
             break;
           }
         /* Fall through.  */
       case 'Q':
         if (intel_syntax && !alt)
           break;
         USED_REX (REX_W);
         if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
           {
             if (rex & REX_W)
              *obufp++ = 'q';
             else
              {
                if (sizeflag & DFLAG)
                  *obufp++ = intel_syntax ? 'd' : 'l';
                else
                  *obufp++ = 'w';
              }
             used_prefixes |= (prefixes & PREFIX_DATA);
           }
         break;
       case 'R':
         USED_REX (REX_W);
         if (rex & REX_W)
           *obufp++ = 'q';
         else if (sizeflag & DFLAG)
           {
             if (intel_syntax)
                *obufp++ = 'd';
             else
                *obufp++ = 'l';
           }
         else
           *obufp++ = 'w';
         if (intel_syntax && !p[1]
             && ((rex & REX_W) || (sizeflag & DFLAG)))
           *obufp++ = 'e';
         if (!(rex & REX_W))
           used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       case 'V':
         if (intel_syntax)
           break;
         if (address_mode == mode_64bit && (sizeflag & DFLAG))
           {
             if (sizeflag & SUFFIX_ALWAYS)
              *obufp++ = 'q';
             break;
           }
         /* Fall through.  */
       case 'S':
         if (intel_syntax)
           break;
         if (sizeflag & SUFFIX_ALWAYS)
           {
             if (rex & REX_W)
              *obufp++ = 'q';
             else
              {
                if (sizeflag & DFLAG)
                  *obufp++ = 'l';
                else
                  *obufp++ = 'w';
                used_prefixes |= (prefixes & PREFIX_DATA);
              }
           }
         break;
       case 'X':
         if (prefixes & PREFIX_DATA)
           *obufp++ = 'd';
         else
           *obufp++ = 's';
         used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       case 'Y':
         if (intel_syntax)
           break;
         if (rex & REX_W)
           {
             USED_REX (REX_W);
             *obufp++ = 'q';
           }
         break;
         /* implicit operand size 'l' for i386 or 'q' for x86-64 */
       case 'W':
         /* operand size flag for cwtl, cbtw */
         USED_REX (REX_W);
         if (rex & REX_W)
           {
             if (intel_syntax)
              *obufp++ = 'd';
             else
              *obufp++ = 'l';
           }
         else if (sizeflag & DFLAG)
           *obufp++ = 'w';
         else
           *obufp++ = 'b';
         if (!(rex & REX_W))
           used_prefixes |= (prefixes & PREFIX_DATA);
         break;
       }
      alt = 0;
    }
  *obufp = 0;
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static void REP_Fixup ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5696 of file i386-dis.c.

{
  /* The 0xf3 prefix should be displayed as "rep" for ins, outs, movs,
     lods and stos.  */
  size_t ilen = 0;

  if (prefixes & PREFIX_REPZ)
    switch (*insn_codep) 
      {
      case 0x6e:     /* outsb */
      case 0x6f:     /* outsw/outsl */
      case 0xa4:     /* movsb */
      case 0xa5:     /* movsw/movsl/movsq */
       if (!intel_syntax)
         ilen = 5;
       else
         ilen = 4;
       break;
      case 0xaa:     /* stosb */
      case 0xab:     /* stosw/stosl/stosq */
      case 0xac:     /* lodsb */
      case 0xad:     /* lodsw/lodsl/lodsq */
       if (!intel_syntax && (sizeflag & SUFFIX_ALWAYS))
         ilen = 5;
       else
         ilen = 4;
       break;
      case 0x6c:     /* insb */
      case 0x6d:     /* insl/insw */
       if (!intel_syntax)
         ilen = 4;
       else
         ilen = 3;
       break;
      default:
       abort ();
       break;
      }

  if (ilen != 0)
    {
      size_t olen;
      char *p;

      olen = strlen (obuf);
      p = obuf + olen - ilen - 1 - 4;
      /* Handle "repz [addr16|addr32]".  */
      if ((prefixes & PREFIX_ADDR))
       p -= 1 + 6;

      memmove (p + 3, p + 4, olen - (p + 3 - obuf));
    }

  switch (bytemode)
    {
    case al_reg:
    case eAX_reg:
    case indir_dx_reg:
      OP_IMREG (bytemode, sizeflag);
      break;
    case eDI_reg:
      OP_ESreg (bytemode, sizeflag);
      break;
    case eSI_reg:
      OP_DSreg (bytemode, sizeflag);
      break;
    default:
      abort ();
      break;
    }
}

Here is the call graph for this function:

static void set_op ( bfd_vma  op,
int  riprel 
) [static]

Definition at line 4573 of file i386-dis.c.

{
  op_index[op_ad] = op_ad;
  if (address_mode == mode_64bit)
    {
      op_address[op_ad] = op;
      op_riprel[op_ad] = riprel;
    }
  else
    {
      /* Mask to get a 32-bit address.  */
      op_address[op_ad] = op & 0xffffffff;
      op_riprel[op_ad] = riprel & 0xffffffff;
    }
}

Here is the caller graph for this function:

static void SIMD_Fixup ( int  ,
int   
) [static]
static void SIMD_Fixup ( int  extrachar,
int sizeflag  ATTRIBUTE_UNUSED 
) [static]

Definition at line 5469 of file i386-dis.c.

{
  /* Change movlps/movhps to movhlps/movlhps for 2 register operand
     forms of these instructions.  */
  if (mod == 3)
    {
      char *p = obuf + strlen (obuf);
      *(p + 1) = '\0';
      *p       = *(p - 1);
      *(p - 1) = *(p - 2);
      *(p - 2) = *(p - 3);
      *(p - 3) = extrachar;
    }
}

Here is the call graph for this function:

static void SVME_Fixup ( int  bytemode,
int  sizeflag 
) [static]

Definition at line 5549 of file i386-dis.c.

{
  const char *alt;
  char *p;

  switch (*codep)
    {
    case 0xd8:
      alt = "vmrun";
      break;
    case 0xd9:
      alt = "vmmcall";
      break;
    case 0xda:
      alt = "vmload";
      break;
    case 0xdb:
      alt = "vmsave";
      break;
    case 0xdc:
      alt = "stgi";
      break;
    case 0xdd:
      alt = "clgi";
      break;
    case 0xde:
      alt = "skinit";
      break;
    case 0xdf:
      alt = "invlpga";
      break;
    default:
      OP_M (bytemode, sizeflag);
      return;
    }
  /* Override "lidt".  */
  p = obuf + strlen (obuf) - 4;
  /* We might have a suffix.  */
  if (*p == 'i')
    --p;
  strcpy (p, alt);
  if (!(prefixes & PREFIX_ADDR))
    {
      ++codep;
      return;
    }
  used_prefixes |= PREFIX_ADDR;
  switch (*codep++)
    {
    case 0xdf:
      strcpy (op_out[1], names32[1]);
      two_source_ops = 1;
         /* Fall through.  */
    case 0xd8:
    case 0xda:
    case 0xdb:
      *obufp++ = open_char;
      if (address_mode == mode_64bit || (sizeflag & AFLAG))
        alt = names32[0];
      else
        alt = names16[0];
      strcpy (obufp, alt);
      obufp += strlen (alt);
      *obufp++ = close_char;
      *obufp = '\0';
      break;
    }
}

Here is the call graph for this function:

static void VMX_Fixup ( int  ,
int   
) [static]
static void VMX_Fixup ( int extrachar  ATTRIBUTE_UNUSED,
int  sizeflag 
) [static]

Definition at line 5649 of file i386-dis.c.

{
  if (mod == 3 && reg == 0 && rm >=1 && rm <= 4)
    {
      /* Override "sgdt".  */
      char *p = obuf + strlen (obuf) - 4;

      /* We might have a suffix when disassembling with -Msuffix.  */
      if (*p == 'g')
       --p;

      switch (rm)
       {
       case 1:
         strcpy (p, "vmcall");
         break;
       case 2:
         strcpy (p, "vmlaunch");
         break;
       case 3:
         strcpy (p, "vmresume");
         break;
       case 4:
         strcpy (p, "vmxoff");
         break;
       }

      codep++;
    }
  else
    OP_E (0, sizeflag);
}

Here is the call graph for this function:


Variable Documentation

const char* att_index16[] [static]
Initial value:
 {
  "%bx,%si", "%bx,%di", "%bp,%si", "%bp,%di", "%si", "%di", "%bp", "%bx"
}

Definition at line 1445 of file i386-dis.c.

const char* att_names16[] [static]
Initial value:
 {
  "%ax", "%cx", "%dx", "%bx", "%sp", "%bp", "%si", "%di",
  "%r8w", "%r9w", "%r10w", "%r11w", "%r12w", "%r13w", "%r14w", "%r15w"
}

Definition at line 1431 of file i386-dis.c.

const char* att_names32[] [static]
Initial value:
 {
  "%eax", "%ecx", "%edx", "%ebx", "%esp", "%ebp", "%esi", "%edi",
  "%r8d", "%r9d", "%r10d", "%r11d", "%r12d", "%r13d", "%r14d", "%r15d"
}

Definition at line 1427 of file i386-dis.c.

const char* att_names64[] [static]
Initial value:
 {
  "%rax", "%rcx", "%rdx", "%rbx", "%rsp", "%rbp", "%rsi", "%rdi",
  "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
}

Definition at line 1423 of file i386-dis.c.

const char* att_names8[] [static]
Initial value:
 {
  "%al", "%cl", "%dl", "%bl", "%ah", "%ch", "%dh", "%bh",
}

Definition at line 1435 of file i386-dis.c.

const char* att_names8rex[] [static]
Initial value:
 {
  "%al", "%cl", "%dl", "%bl", "%spl", "%bpl", "%sil", "%dil",
  "%r8b", "%r9b", "%r10b", "%r11b", "%r12b", "%r13b", "%r14b", "%r15b"
}

Definition at line 1438 of file i386-dis.c.

const char* att_names_seg[] [static]
Initial value:
 {
  "%es", "%cs", "%ss", "%ds", "%fs", "%gs", "%?", "%?",
}

Definition at line 1442 of file i386-dis.c.

char close_char [static]

Definition at line 2827 of file i386-dis.c.

unsigned char* codep [static]

Definition at line 1377 of file i386-dis.c.

static struct dis386 [static]

Definition at line 531 of file i386-dis.c.

char* fgrps[][8] [static]

Definition at line 3573 of file i386-dis.c.

const char* float_mem[] [static]

Definition at line 3305 of file i386-dis.c.

const unsigned char float_mem_mode[] [static]

Definition at line 3380 of file i386-dis.c.

const char** index16 [static]

Definition at line 1395 of file i386-dis.c.

unsigned char* insn_codep [static]

Definition at line 1376 of file i386-dis.c.

const char* intel_index16[] [static]
Initial value:
 {
  "bx+si", "bx+di", "bp+si", "bp+di", "si", "di", "bp", "bx"
}

Definition at line 1419 of file i386-dis.c.

const char* intel_names16[] [static]
Initial value:
 {
  "ax", "cx", "dx", "bx", "sp", "bp", "si", "di",
  "r8w", "r9w", "r10w", "r11w", "r12w", "r13w", "r14w", "r15w"
}

Definition at line 1405 of file i386-dis.c.

const char* intel_names32[] [static]
Initial value:
 {
  "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi",
  "r8d", "r9d", "r10d", "r11d", "r12d", "r13d", "r14d", "r15d"
}

Definition at line 1401 of file i386-dis.c.

const char* intel_names64[] [static]
Initial value:
 {
  "rax", "rcx", "rdx", "rbx", "rsp", "rbp", "rsi", "rdi",
  "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15"
}

Definition at line 1397 of file i386-dis.c.

const char* intel_names8[] [static]
Initial value:
 {
  "al", "cl", "dl", "bl", "ah", "ch", "dh", "bh",
}

Definition at line 1409 of file i386-dis.c.

const char* intel_names8rex[] [static]
Initial value:
 {
  "al", "cl", "dl", "bl", "spl", "bpl", "sil", "dil",
  "r8b", "r9b", "r10b", "r11b", "r12b", "r13b", "r14b", "r15b"
}

Definition at line 1412 of file i386-dis.c.

const char* intel_names_seg[] [static]
Initial value:
 {
  "es", "cs", "ss", "ds", "fs", "gs", "?", "?",
}

Definition at line 1416 of file i386-dis.c.

char intel_syntax [static]

Definition at line 2825 of file i386-dis.c.

int mod [static]

Definition at line 1379 of file i386-dis.c.

const char** names16 [static]

Definition at line 1391 of file i386-dis.c.

const char** names32 [static]

Definition at line 1390 of file i386-dis.c.

const char** names64 [static]

Definition at line 1389 of file i386-dis.c.

const char** names8 [static]

Definition at line 1392 of file i386-dis.c.

const char** names8rex [static]

Definition at line 1393 of file i386-dis.c.

const char** names_seg [static]

Definition at line 1394 of file i386-dis.c.

unsigned char need_modrm [static]

Definition at line 1382 of file i386-dis.c.

char obuf[100] [static]

Definition at line 1372 of file i386-dis.c.

char* obufp [static]

Definition at line 1373 of file i386-dis.c.

const unsigned char onebyte_has_modrm[256] [static]
Initial value:
 {
  
  
   1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, 
   1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, 
   1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, 
   1,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,1,1,0,0,0,0,0,1,0,1,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,0,0,1,1,1,1,0,0,0,0,0,0,0,0, 
   1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,1,1,0,0,0,0,0,0,1,1  
  
  
}

Definition at line 1113 of file i386-dis.c.

int op_ad [static]

Definition at line 2810 of file i386-dis.c.

Definition at line 2812 of file i386-dis.c.

Definition at line 2810 of file i386-dis.c.

char op_out[MAX_OPERANDS][100] [static]

Definition at line 2809 of file i386-dis.c.

Definition at line 2813 of file i386-dis.c.

char open_char [static]

Definition at line 2826 of file i386-dis.c.

int reg [static]

Definition at line 1381 of file i386-dis.c.

int rm [static]

Definition at line 1380 of file i386-dis.c.

char scale_char [static]

Definition at line 2829 of file i386-dis.c.

char scratchbuf[100] [static]

Definition at line 1374 of file i386-dis.c.

char separator_char [static]

Definition at line 2828 of file i386-dis.c.

const char* simd_cmp_op[] [static]
Initial value:
 {
  "eq",
  "lt",
  "le",
  "unord",
  "neq",
  "nlt",
  "nle",
  "ord"
}

Definition at line 5417 of file i386-dis.c.

unsigned char* start_codep [static]

Definition at line 1375 of file i386-dis.c.

bfd_vma start_pc [static]

Definition at line 2814 of file i386-dis.c.

const char* const Suffix3DNow[] [static]

Definition at line 5325 of file i386-dis.c.

Definition at line 1378 of file i386-dis.c.

Initial value:
 {
  
  
   1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1229 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1253 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1277 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1301 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1325 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1349 of file i386-dis.c.

int two_source_ops [static]

Definition at line 2811 of file i386-dis.c.

const unsigned char twobyte_has_modrm[256] [static]
Initial value:
 {
  
  
   1,1,1,1,0,0,0,0,0,0,0,0,0,1,0,1, 
   1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,1, 
   1,1,1,1,1,0,1,0,1,1,1,1,1,1,1,1, 
   0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,0,1,1,0,0,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   0,0,0,1,1,1,1,1,0,0,0,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,1,0,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, 
   1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0  
  
  
}

Definition at line 1136 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, 
   0,0,0,0,0,0,0,0,1,0,1,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1, 
   1,0,0,0,0,0,0,0,1,1,0,0,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0  
  
  
}

Definition at line 1159 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,1,0,0,0,0,0,0,1,1,1,0,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,0,0,0,0,0,0,0,1,1,0,0,1,1,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1182 of file i386-dis.c.

Initial value:
 {
  
  
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   1,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, 
   1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0, 
   0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0, 
   0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 
  
  
}

Definition at line 1205 of file i386-dis.c.

int used_prefixes [static]

Definition at line 144 of file i386-dis.c.