#define indirEb OP_indirE, b_mode
#define Gb OP_G, b_mode
#define Ev OP_E, v_mode
+#define Ed OP_E, d_mode
#define indirEv OP_indirE, v_mode
#define Ew OP_E, w_mode
#define Ma OP_E, v_mode
-#define M OP_E, 0
-#define Mp OP_E, 0 /* ? */
+#define M OP_E, 0 /* lea */
+#define Mp OP_E, 0 /* 32 or 48 bit memory operand for LDS, LES etc */
#define Gv OP_G, v_mode
#define Gw OP_G, w_mode
-#define Rw OP_rm, w_mode
-#define Rd OP_rm, d_mode
+#define Rd OP_Rd, d_mode
#define Ib OP_I, b_mode
#define sIb OP_sI, b_mode /* sign extened byte */
#define Iv OP_I, v_mode
#define Iw OP_I, w_mode
#define Jb OP_J, b_mode
#define Jv OP_J, v_mode
-#if 0
-#define ONE OP_ONE, 0
-#endif
#define Cd OP_C, d_mode
#define Dd OP_D, d_mode
#define Td OP_T, d_mode
#define XM OP_XMM, 0
#define EM OP_EM, v_mode
#define EX OP_EX, v_mode
-#define MS OP_MS, b_mode
+#define MS OP_MS, v_mode
#define None OP_E, 0
#define OPSUF OP_3DNowSuffix, 0
#define OPSIMD OP_SIMD_Suffix, 0
#define AFLAG 2
#define DFLAG 1
-typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag ));
+typedef void (*op_rtn) PARAMS ((int bytemode, int sizeflag));
static void OP_E PARAMS ((int, int));
static void OP_G PARAMS ((int, int));
static void OP_C PARAMS ((int, int));
static void OP_D PARAMS ((int, int));
static void OP_T PARAMS ((int, int));
-static void OP_rm PARAMS ((int, int));
+static void OP_Rd PARAMS ((int, int));
static void OP_ST PARAMS ((int, int));
static void OP_STi PARAMS ((int, int));
-#if 0
-static void OP_ONE PARAMS ((int, int));
-#endif
static void OP_MMX PARAMS ((int, int));
static void OP_XMM PARAMS ((int, int));
static void OP_EM PARAMS ((int, int));
static void append_seg PARAMS ((void));
static void set_op PARAMS ((unsigned int op));
-static void putop PARAMS ((char *template, int sizeflag));
+static void putop PARAMS ((const char *template, int sizeflag));
static void dofloat PARAMS ((int sizeflag));
static int get16 PARAMS ((void));
static int get32 PARAMS ((void));
static void ckprefix PARAMS ((void));
static void ptr_reg PARAMS ((int, int));
+static void BadOp PARAMS ((void));
#define b_mode 1
#define v_mode 2
#define FLOAT NULL, NULL, FLOATCODE
struct dis386 {
- char *name;
+ const char *name;
op_rtn op1;
int bytemode1;
op_rtn op2;
'W' => print 'b' or 'w'
*/
-static struct dis386 dis386_att[] = {
+static const struct dis386 dis386_att[] = {
/* 00 */
{ "addB", Eb, Gb },
{ "addS", Ev, Gv },
{ GRP5 },
};
-static struct dis386 dis386_intel[] = {
+static const struct dis386 dis386_intel[] = {
/* 00 */
{ "add", Eb, Gb },
{ "add", Ev, Gv },
{ GRP5 },
};
-static struct dis386 dis386_twobyte_att[] = {
+static const struct dis386 dis386_twobyte_att[] = {
/* 00 */
{ GRP6 },
{ GRP7 },
{ "movhps", EX, XM, SIMD_Fixup, 'l' },
/* 18 */
{ GRP14 },
- { "(bad)" }, { "(bad)" }, { "(bad)" },
+ { "(bad)" }, { "(bad)" }, { "(bad)" },
{ "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" },
/* 20 */
/* these are all backward in appendix A of the intel book */
{ "movaps", EX, XM },
{ PREGRP2 },
{ "movntps", Ev, XM },
- { PREGRP4 },
+ { PREGRP4 },
{ PREGRP3 },
{ "ucomiss", XM, EX },
- { "comiss", XM, EX },
+ { "comiss", XM, EX },
/* 30 */
{ "wrmsr" }, { "rdtsc" }, { "rdmsr" }, { "rdpmc" },
{ "sysenter" }, { "sysexit" }, { "(bad)" }, { "(bad)" },
{ "andps", XM, EX },
{ "andnps", XM, EX },
{ "orps", XM, EX },
- { "xorps", XM, EX },
+ { "xorps", XM, EX },
/* 58 */
{ PREGRP0 },
{ PREGRP10 },
{ "(bad)" },
- { "(bad)" },
+ { "(bad)" },
{ PREGRP14 },
{ PREGRP7 },
{ PREGRP5 },
- { PREGRP6 },
+ { PREGRP6 },
/* 60 */
{ "punpcklbw", MX, EM },
{ "punpcklwd", MX, EM },
{ "punpckhdq", MX, EM },
{ "packssdw", MX, EM },
{ "(bad)" }, { "(bad)" },
- { "movd", MX, Ev },
+ { "movd", MX, Ed },
{ "movq", MX, EM },
/* 70 */
{ "pshufw", MX, EM, Ib },
/* 78 */
{ "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" },
{ "(bad)" }, { "(bad)" },
- { "movd", Ev, MX },
+ { "movd", Ed, MX },
{ "movq", EM, MX },
/* 80 */
{ "jo", Jv },
/* b0 */
{ "cmpxchgB", Eb, Gb },
{ "cmpxchgS", Ev, Gv },
- { "lssS", Gv, Mp }, /* 386 lists only Mp */
+ { "lssS", Gv, Mp },
{ "btrS", Ev, Gv },
- { "lfsS", Gv, Mp }, /* 386 lists only Mp */
- { "lgsS", Gv, Mp }, /* 386 lists only Mp */
+ { "lfsS", Gv, Mp },
+ { "lgsS", Gv, Mp },
{ "movzbR", Gv, Eb },
{ "movzwR", Gv, Ew }, /* yes, there really is movzww ! */
/* b8 */
{ "(bad)" },
{ "pmullw", MX, EM },
{ "(bad)" },
- { "pmovmskb", Ev, MX },
+ { "pmovmskb", Ev, MX },
/* d8 */
{ "psubusb", MX, EM },
{ "psubusw", MX, EM },
{ "pmulhuw", MX, EM },
{ "pmulhw", MX, EM },
{ "(bad)" },
- { "movntq", Ev, MX },
+ { "movntq", Ev, MX },
/* e8 */
{ "psubsb", MX, EM },
{ "psubsw", MX, EM },
{ "(bad)" },
{ "pmaddwd", MX, EM },
{ "psadbw", MX, EM },
- { "maskmovq", MX, EM },
+ { "maskmovq", MX, EM },
/* f8 */
{ "psubb", MX, EM },
{ "psubw", MX, EM },
{ "(bad)" }
};
-static struct dis386 dis386_twobyte_intel[] = {
+static const struct dis386 dis386_twobyte_intel[] = {
/* 00 */
{ GRP6 },
{ GRP7 },
{ "movhps", EX, XM, SIMD_Fixup, 'l' },
/* 18 */
{ GRP14 },
- { "(bad)" }, { "(bad)" }, { "(bad)" },
+ { "(bad)" }, { "(bad)" }, { "(bad)" },
{ "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" },
/* 20 */
/* these are all backward in appendix A of the intel book */
{ "movaps", EX, XM },
{ PREGRP2 },
{ "movntps", Ev, XM },
- { PREGRP4 },
+ { PREGRP4 },
{ PREGRP3 },
{ "ucomiss", XM, EX },
- { "comiss", XM, EX },
+ { "comiss", XM, EX },
/* 30 */
{ "wrmsr" }, { "rdtsc" }, { "rdmsr" }, { "rdpmc" },
{ "sysenter" }, { "sysexit" }, { "(bad)" }, { "(bad)" },
{ "andps", XM, EX },
{ "andnps", XM, EX },
{ "orps", XM, EX },
- { "xorps", XM, EX },
+ { "xorps", XM, EX },
/* 58 */
{ PREGRP0 },
{ PREGRP10 },
{ "(bad)" },
- { "(bad)" },
+ { "(bad)" },
{ PREGRP14 },
{ PREGRP7 },
{ PREGRP5 },
- { PREGRP6 },
+ { PREGRP6 },
/* 60 */
{ "punpcklbw", MX, EM },
{ "punpcklwd", MX, EM },
{ "punpckhdq", MX, EM },
{ "packssdw", MX, EM },
{ "(bad)" }, { "(bad)" },
- { "movd", MX, Ev },
+ { "movd", MX, Ed },
{ "movq", MX, EM },
/* 70 */
{ "pshufw", MX, EM, Ib },
/* 78 */
{ "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" },
{ "(bad)" }, { "(bad)" },
- { "movd", Ev, MX },
+ { "movd", Ed, MX },
{ "movq", EM, MX },
/* 80 */
{ "jo", Jv },
/* b0 */
{ "cmpxchg", Eb, Gb },
{ "cmpxchg", Ev, Gv },
- { "lss", Gv, Mp }, /* 386 lists only Mp */
+ { "lss", Gv, Mp },
{ "btr", Ev, Gv },
- { "lfs", Gv, Mp }, /* 386 lists only Mp */
- { "lgs", Gv, Mp }, /* 386 lists only Mp */
+ { "lfs", Gv, Mp },
+ { "lgs", Gv, Mp },
{ "movzx", Gv, Eb },
{ "movzx", Gv, Ew },
/* b8 */
{ "(bad)" },
{ "pmullw", MX, EM },
{ "(bad)" },
- { "pmovmskb", Ev, MX },
+ { "pmovmskb", Ev, MX },
/* d8 */
{ "psubusb", MX, EM },
{ "psubusw", MX, EM },
{ "pmulhuw", MX, EM },
{ "pmulhw", MX, EM },
{ "(bad)" },
- { "movntq", Ev, MX },
+ { "movntq", Ev, MX },
/* e8 */
{ "psubsb", MX, EM },
{ "psubsw", MX, EM },
{ "(bad)" },
{ "pmaddwd", MX, EM },
{ "psadbw", MX, EM },
- { "maskmovq", MX, EM },
+ { "maskmovq", MX, EM },
/* f8 */
{ "psubb", MX, EM },
{ "psubw", MX, EM },
static int mod;
static int rm;
static int reg;
-static void oappend PARAMS ((char *s));
+static void oappend PARAMS ((const char *s));
-static char *names32[]={
+static const char *names32[]={
"%eax","%ecx","%edx","%ebx", "%esp","%ebp","%esi","%edi",
};
-static char *names16[] = {
+static const char *names16[] = {
"%ax","%cx","%dx","%bx","%sp","%bp","%si","%di",
};
-static char *names8[] = {
+static const char *names8[] = {
"%al","%cl","%dl","%bl","%ah","%ch","%dh","%bh",
};
-static char *names_seg[] = {
+static const char *names_seg[] = {
"%es","%cs","%ss","%ds","%fs","%gs","%?","%?",
};
-static char *index16[] = {
+static const char *index16[] = {
"%bx,%si","%bx,%di","%bp,%si","%bp,%di","%si","%di","%bp","%bx"
};
-static struct dis386 grps[][8] = {
+static const struct dis386 grps[][8] = {
/* GRP1b */
{
{ "addA", Eb, Ib },
};
-static struct dis386 prefix_user_table[][2] = {
+static const struct dis386 prefix_user_table[][2] = {
/* PREGRP0 */
{
{ "addps", XM, EX },
},
/* PREGRP4 */
{
- { "cvttps2pi", MX, EX },
- { "cvttss2si", Gv, EX },
+ { "cvttps2pi", MX, EX },
+ { "cvttss2si", Gv, EX },
},
/* PREGRP5 */
{
* The function returns the length of this instruction in bytes.
*/
-static int print_insn_x86
- PARAMS ((bfd_vma pc, disassemble_info *info, int sizeflag));
static int print_insn_i386
PARAMS ((bfd_vma pc, disassemble_info *info));
bfd_vma pc;
disassemble_info *info;
{
- int flags;
- if (info->mach == bfd_mach_i386_i386
- || info->mach == bfd_mach_i386_i386_intel_syntax)
- flags = AFLAG|DFLAG;
- else if (info->mach == bfd_mach_i386_i8086)
- flags = 0;
- else
- abort ();
- return print_insn_x86 (pc, info, flags);
-}
-
-static int
-print_insn_x86 (pc, info, sizeflag)
- bfd_vma pc;
- disassemble_info *info;
- int sizeflag;
-{
- struct dis386 *dp;
+ const struct dis386 *dp;
int i;
int two_source_ops;
char *first, *second, *third;
int needcomma;
unsigned char need_modrm;
unsigned char uses_f3_prefix;
+ int sizeflag;
struct dis_private priv;
bfd_byte *inbuf = priv.the_buffer;
+ if (info->mach == bfd_mach_i386_i386
+ || info->mach == bfd_mach_i386_i386_intel_syntax)
+ sizeflag = AFLAG|DFLAG;
+ else if (info->mach == bfd_mach_i386_i8086)
+ sizeflag = 0;
+ else
+ abort ();
+
/* The output looks better if we put 6 bytes on a line, since that
puts most long word instructions on a single line. */
info->bytes_per_line = 6;
/* 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)
+ if (intel_syntax || two_source_ops)
{
first = op1out;
second = op2out;
return codep - inbuf;
}
-static char *float_mem_att[] = {
+static const char *float_mem_att[] = {
/* d8 */
"fadds",
"fmuls",
"fistpll",
};
-static char *float_mem_intel[] = {
+static const char *float_mem_intel[] = {
/* d8 */
"fadd",
"fmul",
#define FGRPde_3 NULL, NULL, 7
#define FGRPdf_4 NULL, NULL, 8
-static struct dis386 float_reg[][8] = {
+static const struct dis386 float_reg[][8] = {
/* d8 */
{
{ "fadd", ST, STi },
dofloat (sizeflag)
int sizeflag;
{
- struct dis386 *dp;
+ const struct dis386 *dp;
unsigned char floatop;
floatop = codep[-1];
OP_E (x_mode, sizeflag);
else if (floatop == 0xdd)
OP_E (d_mode, sizeflag);
- else
+ else
OP_E (v_mode, sizeflag);
return;
}
/* capital letters in template are macros */
static void
putop (template, sizeflag)
- char *template;
+ const char *template;
int sizeflag;
{
- char *p;
+ const char *p;
for (p = template; *p; p++)
{
static void
oappend (s)
- char *s;
+ const char *s;
{
strcpy (obufp, s);
obufp += strlen (s);
case w_mode:
oappend (names16[rm]);
break;
+ case d_mode:
+ oappend (names32[rm]);
+ break;
case v_mode:
if (sizeflag & DFLAG)
oappend (names32[rm]);
else
oappend (names16[rm]);
break;
- case 0: /* sfence */
+ case 0:
+ if ( !(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */))
+ BadOp(); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
break;
default:
oappend (INTERNAL_DISASSEMBLER_ERROR);
sprintf (scratchbuf, "0x%x", disp);
oappend (scratchbuf);
}
-
+
if (havebase || (havesib && (index != 4 || scale != 0)))
{
if (intel_syntax)
oappend (scratchbuf);
}
if (!intel_syntax
- || (intel_syntax
+ || (intel_syntax
&& bytemode != b_mode
&& bytemode != w_mode
&& bytemode != v_mode))
int code;
int sizeflag;
{
- char *s;
+ const char *s;
switch (code)
{
int code;
int sizeflag;
{
- char *s;
+ const char *s;
oappend ("(");
if (sizeflag & AFLAG)
s = names32[code - eAX_reg];
ptr_reg (code, sizeflag);
}
-#if 0
-/* Not used. */
-
-/* ARGSUSED */
-static void
-OP_ONE (dummy, sizeflag)
- int dummy;
- int sizeflag;
-{
- oappend ("1");
-}
-
-#endif
-
/* ARGSUSED */
static void
OP_C (dummy, sizeflag)
int dummy;
int sizeflag;
{
- codep++; /* skip mod/rm */
sprintf (scratchbuf, "%%cr%d", reg);
oappend (scratchbuf);
}
int dummy;
int sizeflag;
{
- codep++; /* skip mod/rm */
sprintf (scratchbuf, "%%db%d", reg);
oappend (scratchbuf);
}
int dummy;
int sizeflag;
{
- codep++; /* skip mod/rm */
sprintf (scratchbuf, "%%tr%d", reg);
oappend (scratchbuf);
}
static void
-OP_rm (bytemode, sizeflag)
+OP_Rd (bytemode, sizeflag)
int bytemode;
int sizeflag;
{
- switch (bytemode)
- {
- case d_mode:
- oappend (names32[rm]);
- break;
- case w_mode:
- oappend (names16[rm]);
- break;
- }
+ if (mod == 3)
+ OP_E (bytemode, sizeflag);
+ else
+ BadOp();
}
static void
}
static void
-OP_MS (ignore, sizeflag)
- int ignore;
+OP_MS (bytemode, sizeflag)
+ int bytemode;
int sizeflag;
{
- ++codep;
- sprintf (scratchbuf, "%%mm%d", rm);
- oappend (scratchbuf);
+ if (mod == 3)
+ OP_EM (bytemode, sizeflag);
+ else
+ BadOp();
}
static const char *Suffix3DNow[] = {
/* 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)
- strcat (obuf, 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. */
- op1out[0] = 0;
- op2out[0] = 0;
- codep = insn_codep + 1;
- strcat (obuf, "(bad)");
+ op1out[0] = '\0';
+ op2out[0] = '\0';
+ BadOp();
}
}
unsigned int cmp_type;
FETCH_DATA (the_info, codep + 1);
+ obufp = obuf + strlen(obuf);
cmp_type = *codep++ & 0xff;
if (cmp_type < 8)
{
sprintf (scratchbuf, "cmp%s%cs",
simd_cmp_op[cmp_type],
prefixes & PREFIX_REPZ ? 's' : 'p');
- strcat (obuf, scratchbuf);
+ oappend (scratchbuf);
}
else
{
/* We have a bad extension byte. Clean up. */
- op1out[0] = 0;
- op2out[0] = 0;
- codep = insn_codep + 1;
- strcat (obuf, "(bad)");
+ op1out[0] = '\0';
+ op2out[0] = '\0';
+ BadOp();
}
}
*(p-3) = extrachar;
}
}
+
+static void BadOp (void)
+{
+ codep = insn_codep + 1; /* throw away prefixes and 1st. opcode byte */
+ oappend ("(bad)");
+}
projects / binutils-gdb.git / commitdiff