static int fetch_data PARAMS ((struct disassemble_info *, bfd_byte *));
static void ckprefix PARAMS ((void));
static const char *prefix_name PARAMS ((int, int));
-static int print_insn_i386 PARAMS ((bfd_vma, disassemble_info *));
+static int print_insn PARAMS ((bfd_vma, disassemble_info *));
static void dofloat PARAMS ((int));
static void OP_ST PARAMS ((int, int));
static void OP_STi PARAMS ((int, int));
static void SIMD_Fixup PARAMS ((int, int));
static void BadOp PARAMS ((void));
-struct dis_private
-{
+struct dis_private {
/* Points to first byte not fetched. */
bfd_byte *max_fetched;
bfd_byte the_buffer[MAXLEN];
bfd_vma insn_start;
+ int orig_sizeflag;
jmp_buf bailout;
};
to ADDR (exclusive) are valid. Returns 1 for success, longjmps
on error. */
#define FETCH_DATA(info, addr) \
- ((addr) <= ((struct dis_private *)(info->private_data))->max_fetched \
+ ((addr) <= ((struct dis_private *) (info->private_data))->max_fetched \
? 1 : fetch_data ((info), (addr)))
static int
bfd_byte *addr;
{
int status;
- struct dis_private *priv = (struct dis_private *)info->private_data;
+ struct dis_private *priv = (struct dis_private *) info->private_data;
bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
status = (*info->read_memory_func) (start,
#define loop_jcxz_flag NULL, loop_jcxz_mode
/* bits in sizeflag */
-#if 0 /* leave undefined until someone adds the extra flag to objdump */
#define SUFFIX_ALWAYS 4
-#endif
#define AFLAG 2
#define DFLAG 1
'N' => print 'n' if instruction has no wait "prefix"
'O' => print 'd', or 'o'
'P' => print 'w', 'l' or 'q' if instruction has an operand size prefix,
- or suffix_always is true
- print 'q' if rex prefix is present.
- 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always is true
+ . or suffix_always is true. print 'q' if rex prefix is present.
+ 'Q' => print 'w', 'l' or 'q' if no register operands or suffix_always
+ . is true
'R' => print 'w', 'l' or 'q' ("wd" or "dq" in intel mode)
'S' => print 'w', 'l' or 'q' if suffix_always is true
'T' => print 'q' in 64bit mode and behave as 'P' otherwise
{ "(bad)", XX, XX, XX },
{ GRPAMD },
{ "femms", XX, XX, XX },
- { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix */
+ { "", MX, EM, OPSUF }, /* See OP_3DNowSuffix. */
/* 10 */
{ PREGRP8 },
{ PREGRP9 },
{ "(bad)", Eb, XX, XX },
{ "notA", Eb, XX, XX },
{ "negA", Eb, XX, XX },
- { "mulB", AL, Eb, XX },
- { "imulB", AL, Eb, XX },
- { "divB", AL, Eb, XX },
- { "idivB", AL, Eb, XX }
+ { "mulA", Eb, XX, XX }, /* Don't print the implicit %al register, */
+ { "imulA", Eb, XX, XX }, /* to distinguish these opcodes from other */
+ { "divA", Eb, XX, XX }, /* mul/imul opcodes. Do the same for div */
+ { "idivA", Eb, XX, XX } /* and idiv for consistency. */
},
/* GRP3S */
{
{ "(bad)", XX, XX, XX },
{ "notQ", Ev, XX, XX },
{ "negQ", Ev, XX, XX },
- { "mulS", eAX, Ev, XX },
- { "imulS", eAX, Ev, XX },
- { "divS", eAX, Ev, XX },
- { "idivS", eAX, Ev, XX },
+ { "mulQ", Ev, XX, XX }, /* Don't print the implicit register. */
+ { "imulQ", Ev, XX, XX },
+ { "divQ", Ev, XX, XX },
+ { "idivQ", Ev, XX, XX },
},
/* GRP4 */
{
},
/* GRP6 */
{
- { "sldt", Ew, XX, XX },
- { "str", Ew, XX, XX },
+ { "sldtQ", Ev, XX, XX },
+ { "strQ", Ev, XX, XX },
{ "lldt", Ew, XX, XX },
{ "ltr", Ew, XX, XX },
{ "verr", Ew, XX, XX },
{ "sidtQ", M, XX, XX },
{ "lgdtQ", M, XX, XX },
{ "lidtQ", M, XX, XX },
- { "smsw", Ew, XX, XX },
+ { "smswQ", Ev, XX, XX },
{ "(bad)", XX, XX, XX },
{ "lmsw", Ew, XX, XX },
{ "invlpg", Ew, XX, XX },
{ "lfence", None, XX, XX },
{ "mfence", None, XX, XX },
{ "sfence", None, XX, XX },
- /* FIXME: the sfence with memory operand is clflush! */
+ /* FIXME: the sfence with memory operand is clflush! */
},
/* GRP14 */
{
{ "(bad)", XX, XX, XX },
{ "(bad)", XX, XX, XX },
}
-
};
static const struct dis386 prefix_user_table[][4] = {
},
/* PREGRP1 */
{
- { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX */
+ { "", XM, EX, OPSIMD }, /* See OP_SIMD_SUFFIX. */
{ "", XM, EX, OPSIMD },
{ "", XM, EX, OPSIMD },
{ "", XM, EX, OPSIMD },
case 0x66:
return (sizeflag & DFLAG) ? "data16" : "data32";
case 0x67:
- return (sizeflag & AFLAG) ? "addr16" : "addr32";
+ if (mode_64bit)
+ return (sizeflag & AFLAG) ? "addr32" : "addr64";
+ else
+ return ((sizeflag & AFLAG) && !mode_64bit) ? "addr16" : "addr32";
case FWAIT_OPCODE:
return "fwait";
default:
static bfd_vma op_address[3];
static bfd_vma op_riprel[3];
static bfd_vma start_pc;
-
\f
/*
* On the 386's of 1988, the maximum length of an instruction is 15 bytes.
static char separator_char;
static char scale_char;
+/* Here for backwards compatibility. When gdb stops using
+ print_insn_i386_att and print_insn_i386_intel these functions can
+ disappear, and print_insn_i386 be merged into print_insn. */
int
print_insn_i386_att (pc, info)
bfd_vma pc;
disassemble_info *info;
{
intel_syntax = 0;
- 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 = ',';
-
- return print_insn_i386 (pc, info);
+
+ return print_insn (pc, info);
}
int
disassemble_info *info;
{
intel_syntax = 1;
- 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 = '*';
-
- return print_insn_i386 (pc, info);
+
+ return print_insn (pc, info);
}
-static int
+int
print_insn_i386 (pc, info)
bfd_vma pc;
disassemble_info *info;
+{
+ intel_syntax = -1;
+
+ return print_insn (pc, info);
+}
+
+static int
+print_insn (pc, info)
+ bfd_vma pc;
+ disassemble_info *info;
{
const struct dis386 *dp;
int i;
char *first, *second, *third;
int needcomma;
unsigned char uses_SSE_prefix;
- VOLATILE int sizeflag;
- VOLATILE int orig_sizeflag;
-
+ int sizeflag;
+ const char *p;
struct dis_private priv;
- bfd_byte *inbuf = priv.the_buffer;
mode_64bit = (info->mach == bfd_mach_x86_64_intel_syntax
|| info->mach == bfd_mach_x86_64);
+ if (intel_syntax == -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)
- sizeflag = AFLAG|DFLAG;
+ priv.orig_sizeflag = AFLAG | DFLAG;
else if (info->mach == bfd_mach_i386_i8086)
- sizeflag = 0;
+ priv.orig_sizeflag = 0;
else
abort ();
- orig_sizeflag = sizeflag;
+
+ for (p = info->disassembler_options; p != NULL; )
+ {
+ if (strncmp (p, "x86-64", 6) == 0)
+ {
+ mode_64bit = 1;
+ priv.orig_sizeflag = AFLAG | DFLAG;
+ }
+ else if (strncmp (p, "i386", 4) == 0)
+ {
+ mode_64bit = 0;
+ priv.orig_sizeflag = AFLAG | DFLAG;
+ }
+ else if (strncmp (p, "i8086", 5) == 0)
+ {
+ mode_64bit = 0;
+ priv.orig_sizeflag = 0;
+ }
+ else if (strncmp (p, "intel", 5) == 0)
+ {
+ intel_syntax = 1;
+ }
+ else if (strncmp (p, "att", 3) == 0)
+ {
+ intel_syntax = 0;
+ }
+ else if (strncmp (p, "addr", 4) == 0)
+ {
+ 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 (strncmp (p, "data", 4) == 0)
+ {
+ 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 (strncmp (p, "suffix", 6) == 0)
+ 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. */
the_info = info;
start_pc = pc;
- start_codep = inbuf;
- codep = inbuf;
+ 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 > inbuf)
+ 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 (inbuf[0], orig_sizeflag);
+ 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) inbuf[0]);
+ (unsigned int) priv.the_buffer[0]);
}
return 1;
ckprefix ();
insn_codep = codep;
+ sizeflag = priv.orig_sizeflag;
FETCH_DATA (info, codep + 1);
two_source_ops = (*codep == 0x62) || (*codep == 0xc8);
/* fwait not followed by floating point instruction. Print the
first prefix, which is probably fwait itself. */
- name = prefix_name (inbuf[0], orig_sizeflag);
+ name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
if (name == NULL)
name = INTERNAL_DISASSEMBLER_ERROR;
(*info->fprintf_func) (info->stream, "%s", name);
sizeflag ^= AFLAG;
if (dp->bytemode3 != loop_jcxz_mode || intel_syntax)
{
- if (sizeflag & AFLAG)
+ if ((sizeflag & AFLAG) || mode_64bit)
oappend ("addr32 ");
else
oappend ("addr16 ");
obufp = op1out;
op_ad = 2;
if (dp->op1)
- (*dp->op1)(dp->bytemode1, sizeflag);
+ (*dp->op1) (dp->bytemode1, sizeflag);
obufp = op2out;
op_ad = 1;
if (dp->op2)
- (*dp->op2)(dp->bytemode2, sizeflag);
+ (*dp->op2) (dp->bytemode2, sizeflag);
obufp = op3out;
op_ad = 0;
if (dp->op3)
- (*dp->op3)(dp->bytemode3, sizeflag);
+ (*dp->op3) (dp->bytemode3, sizeflag);
}
}
{
const char *name;
- name = prefix_name (inbuf[0], orig_sizeflag);
+ name = prefix_name (priv.the_buffer[0], priv.orig_sizeflag);
if (name == NULL)
name = INTERNAL_DISASSEMBLER_ERROR;
(*info->fprintf_func) (info->stream, "%s", name);
if (rex & ~rex_used)
{
const char *name;
- name = prefix_name (rex | 0x40, orig_sizeflag);
+ name = prefix_name (rex | 0x40, priv.orig_sizeflag);
if (name == NULL)
name = INTERNAL_DISASSEMBLER_ERROR;
(*info->fprintf_func) (info->stream, "%s ", name);
(*info->print_address_func) ((bfd_vma) (start_pc + codep - start_codep
+ op_address[op_index[i]]), info);
}
- return codep - inbuf;
+ return codep - priv.the_buffer;
}
static const char *float_mem[] = {
},
};
-
static char *fgrps[][8] = {
/* d9_2 0 */
{
if (mod != 3)
{
- putop (float_mem[(floatop - 0xd8 ) * 8 + reg], sizeflag);
+ putop (float_mem[(floatop - 0xd8) * 8 + reg], sizeflag);
obufp = op1out;
if (floatop == 0xdb)
OP_E (x_mode, sizeflag);
OP_E (v_mode, sizeflag);
return;
}
- /* skip mod/rm byte */
+ /* Skip mod/rm byte. */
MODRM_CHECK;
codep++;
{
putop (fgrps[dp->bytemode1][rm], sizeflag);
- /* instruction fnstsw is only one with strange arg */
+ /* Instruction fnstsw is only one with strange arg. */
if (floatop == 0xdf && codep[-1] == 0xe0)
strcpy (op1out, names16[0]);
}
obufp = op1out;
if (dp->op1)
- (*dp->op1)(dp->bytemode1, sizeflag);
+ (*dp->op1) (dp->bytemode1, sizeflag);
obufp = op2out;
if (dp->op2)
- (*dp->op2)(dp->bytemode2, sizeflag);
+ (*dp->op2) (dp->bytemode2, sizeflag);
}
}
oappend (scratchbuf + intel_syntax);
}
-/* capital letters in template are macros */
+/* Capital letters in template are macros. */
static int
putop (template, sizeflag)
const char *template;
case 'A':
if (intel_syntax)
break;
- if (mod != 3
-#ifdef SUFFIX_ALWAYS
- || (sizeflag & SUFFIX_ALWAYS)
-#endif
- )
+ if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
*obufp++ = 'b';
break;
case 'B':
if (intel_syntax)
break;
-#ifdef SUFFIX_ALWAYS
if (sizeflag & SUFFIX_ALWAYS)
*obufp++ = 'b';
-#endif
break;
case 'E': /* For jcxz/jecxz */
- if (sizeflag & AFLAG)
- *obufp++ = 'e';
+ if (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)
-#ifdef SUFFIX_ALWAYS
- || (sizeflag & SUFFIX_ALWAYS)
-#endif
- )
+ if ((prefixes & PREFIX_ADDR) || (sizeflag & SUFFIX_ALWAYS))
{
if (sizeflag & AFLAG)
- *obufp++ = 'l';
+ *obufp++ = mode_64bit ? 'q' : 'l';
else
- *obufp++ = 'w';
+ *obufp++ = mode_64bit ? 'l' : 'w';
used_prefixes |= (prefixes & PREFIX_ADDR);
}
break;
case 'L':
if (intel_syntax)
break;
-#ifdef SUFFIX_ALWAYS
if (sizeflag & SUFFIX_ALWAYS)
*obufp++ = 'l';
-#endif
break;
case 'N':
if ((prefixes & PREFIX_FWAIT) == 0)
*obufp++ = 'q';
break;
}
- /* Fall through */
+ /* Fall through. */
case 'P':
if (intel_syntax)
break;
if ((prefixes & PREFIX_DATA)
|| (rex & REX_MODE64)
-#ifdef SUFFIX_ALWAYS
- || (sizeflag & SUFFIX_ALWAYS)
-#endif
- )
+ || (sizeflag & SUFFIX_ALWAYS))
{
USED_REX (REX_MODE64);
if (rex & REX_MODE64)
*obufp++ = 'q';
break;
}
- /* Fall through */
+ /* Fall through. */
case 'Q':
if (intel_syntax)
break;
USED_REX (REX_MODE64);
- if (mod != 3
-#ifdef SUFFIX_ALWAYS
- || (sizeflag & SUFFIX_ALWAYS)
-#endif
- )
+ if (mod != 3 || (sizeflag & SUFFIX_ALWAYS))
{
if (rex & REX_MODE64)
*obufp++ = 'q';
case 'S':
if (intel_syntax)
break;
-#ifdef SUFFIX_ALWAYS
if (sizeflag & SUFFIX_ALWAYS)
{
if (rex & REX_MODE64)
used_prefixes |= (prefixes & PREFIX_DATA);
}
}
-#endif
break;
case 'X':
if (prefixes & PREFIX_DATA)
buf[0] = '0';
buf[1] = 'x';
sprintf_vma (tmp, disp);
- for (i = 0; tmp[i] == '0' && tmp[i+1]; i++);
+ for (i = 0; tmp[i] == '0' && tmp[i + 1]; i++);
strcpy (buf + 2, tmp + i);
}
else
{
*(buf++) = '-';
v = -disp;
- /* Check for possible overflow on 0x8000000000000000 */
+ /* Check for possible overflow on 0x8000000000000000. */
if (v < 0)
{
strcpy (buf, "9223372036854775808");
tmp[29] = 0;
while (v)
{
- tmp[28-i] = (v % 10) + '0';
+ tmp[28 - i] = (v % 10) + '0';
v /= 10;
i++;
}
if (rex & REX_EXTZ)
add += 8;
- /* skip mod/rm byte */
+ /* Skip mod/rm byte. */
MODRM_CHECK;
codep++;
used_prefixes |= (prefixes & PREFIX_DATA);
break;
case 0:
- if ( !(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */)
+ if (!(codep[-2] == 0xAE && codep[-1] == 0xF8 /* sfence */)
&& !(codep[-2] == 0xAE && codep[-1] == 0xF0 /* mfence */)
&& !(codep[-2] == 0xAE && codep[-1] == 0xe8 /* lfence */))
- BadOp(); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
+ BadOp (); /* bad sfence,lea,lds,les,lfs,lgs,lss modrm */
break;
default:
oappend (INTERNAL_DISASSEMBLER_ERROR);
disp = 0;
append_seg ();
- if (sizeflag & AFLAG) /* 32 bit address mode */
+ if ((sizeflag & AFLAG) || mode_64bit) /* 32 bit address mode */
{
int havesib;
int havebase;
if ((base & 7) == 5)
{
havebase = 0;
- if (mode_64bit && !havesib)
+ if (mode_64bit && !havesib && (sizeflag & AFLAG))
riprel = 1;
disp = get32s ();
}
if (!havesib && (rex & REX_EXTZ))
base += 8;
if (havebase)
- oappend (mode_64bit ? names64[base] : names32[base]);
+ oappend (mode_64bit && (sizeflag & AFLAG)
+ ? names64[base] : names32[base]);
if (havesib)
{
if (index != 4)
*obufp = '\0';
}
sprintf (scratchbuf, "%s",
- mode_64bit ? names64[index] : names32[index]);
+ mode_64bit && (sizeflag & AFLAG)
+ ? names64[index] : names32[index]);
}
else
sprintf (scratchbuf, ",%s",
- mode_64bit ? names64[index] : names32[index]);
+ mode_64bit && (sizeflag & AFLAG)
+ ? names64[index] : names32[index]);
oappend (scratchbuf);
}
if (!intel_syntax
if (intel_syntax)
if (mod != 0 || (base & 7) == 5)
{
- /* Don't print zero displacements */
+ /* Don't print zero displacements. */
if (disp != 0)
{
if ((bfd_signed_vma) disp > 0)
b |= (*codep++ & 0xff) << 24;
x = a + ((bfd_vma) b << 32);
#else
- abort();
+ abort ();
x = 0;
#endif
return x;
break;
}
code += eAX_reg - rAX_reg;
- /* Fall through */
+ /* 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_MODE64);
op = get32s ();
break;
}
- /* Fall through */
+ /* Fall through. */
case v_mode:
USED_REX (REX_MODE64);
if (rex & REX_MODE64)
else
{
mask = 0xffffffff;
- op = get16();
+ op = get16 ();
if ((op & 0x8000) != 0)
op -= 0x10000;
}
else
{
disp = get16 ();
- /* for some reason, a data16 prefix on a jump instruction
+ /* For some reason, a data16 prefix on a jump instruction
means that the pc is masked to 16 bits after the
displacement is added! */
mask = 0xffff;
append_seg ();
- if (sizeflag & AFLAG)
+ if ((sizeflag & AFLAG) || mode_64bit)
off = get32 ();
else
off = get16 ();
append_seg ();
- off = get64();
+ off = get64 ();
if (intel_syntax)
{
int sizeflag;
{
const char *s;
- if(intel_syntax)
+ if (intel_syntax)
oappend ("[");
else
oappend ("(");
USED_REX (REX_MODE64);
if (rex & REX_MODE64)
- s = names64[code - eAX_reg];
+ {
+ 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);
- if(intel_syntax)
+ if (intel_syntax)
oappend ("]");
else
oappend (")");
| PREFIX_FS
| PREFIX_GS)) == 0)
prefixes |= PREFIX_DS;
- append_seg();
+ append_seg ();
ptr_reg (code, sizeflag);
}
if (rex & REX_EXTX)
add = 8;
if (intel_syntax)
- sprintf (scratchbuf, "db%d", reg+add);
+ sprintf (scratchbuf, "db%d", reg + add);
else
- sprintf (scratchbuf, "%%db%d", reg+add);
+ sprintf (scratchbuf, "%%db%d", reg + add);
oappend (scratchbuf);
}
if (mod == 3)
OP_E (bytemode, sizeflag);
else
- BadOp();
+ BadOp ();
}
static void
if (rex & REX_EXTZ)
add = 8;
- /* skip mod/rm byte */
+ /* Skip mod/rm byte. */
MODRM_CHECK;
codep++;
used_prefixes |= (prefixes & PREFIX_DATA);
if (rex & REX_EXTZ)
add = 8;
- /* skip mod/rm byte */
+ /* Skip mod/rm byte. */
MODRM_CHECK;
codep++;
sprintf (scratchbuf, "%%xmm%d", rm + add);
if (mod == 3)
OP_EM (bytemode, sizeflag);
else
- BadOp();
+ BadOp ();
}
static void
if (mod == 3)
OP_EX (bytemode, sizeflag);
else
- BadOp();
+ BadOp ();
}
-static const char *Suffix3DNow[] = {
+static const char *const Suffix3DNow[] = {
/* 00 */ NULL, NULL, NULL, NULL,
/* 04 */ NULL, NULL, NULL, NULL,
/* 08 */ NULL, NULL, NULL, NULL,
/* 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);
+ obufp = obuf + strlen (obuf);
mnemonic = Suffix3DNow[*codep++ & 0xff];
if (mnemonic)
oappend (mnemonic);
we have a bad opcode. This necessitates some cleaning up. */
op1out[0] = '\0';
op2out[0] = '\0';
- BadOp();
+ BadOp ();
}
}
-
-static const char *simd_cmp_op [] = {
+static const char *simd_cmp_op[] = {
"eq",
"lt",
"le",
unsigned int cmp_type;
FETCH_DATA (the_info, codep + 1);
- obufp = obuf + strlen(obuf);
+ obufp = obuf + strlen (obuf);
cmp_type = *codep++ & 0xff;
if (cmp_type < 8)
{
/* We have a bad extension byte. Clean up. */
op1out[0] = '\0';
op2out[0] = '\0';
- BadOp();
+ BadOp ();
}
}
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;
+ char *p = obuf + strlen (obuf);
+ *(p + 1) = '\0';
+ *p = *(p - 1);
+ *(p - 1) = *(p - 2);
+ *(p - 2) = *(p - 3);
+ *(p - 3) = extrachar;
}
}
-static void BadOp (void)
+static void
+BadOp (void)
{
- codep = insn_codep + 1; /* throw away prefixes and 1st. opcode byte */
+ /* Throw away prefixes and 1st. opcode byte. */
+ codep = insn_codep + 1;
oappend ("(bad)");
}
projects / deliverable / binutils-gdb.git / blobdiff