Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#include "dis-asm.h"
-#include "ieee-float.h"
-
-extern CONST struct ext_format ext_format_68881;
+#include "floatformat.h"
/* Opcode/m68k.h is a massive table. As a kludge, break it up into
two pieces. This makes nonportable C -- FIXME -- it assumes that
static unsigned char *
print_indexed PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *));
-static unsigned char *
+static int
print_insn_arg PARAMS ((char *, unsigned char *, unsigned char *, bfd_vma,
disassemble_info *));
-/* Sign-extend an (unsigned char). */
-#if __STDC__ == 1
-#define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
-#else
-#define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
-#endif
-
CONST char * CONST fpcr_names[] = {
"", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
"fpiar/fpcr", "fpsr/fpcr", "fpiar/fpsr/fpcr"};
"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0",
"a1", "a2", "a3", "a4", "a5", "fp", "sp", "ps", "pc"};
-/* Define accessors for 68K's 1, 2, and 4-byte signed quantities.
- The _SHIFT values move the quantity to the high order end of an
- `int' value, so it will sign-extend. Probably a few more casts
- are needed to make it compile without warnings on finicky systems. */
-#define BITS_PER_BYTE 8
-#define WORD_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 2))
-#define LONG_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 4))
+/* Sign-extend an (unsigned char). */
+#if __STDC__ == 1
+#define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
+#else
+#define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
+#endif
+/* Get a 1 byte signed integer. */
#define NEXTBYTE(p) (p += 2, FETCH_DATA (info, p), COERCE_SIGNED_CHAR(p[-1]))
+/* Get a 2 byte signed integer. */
+#define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000))
#define NEXTWORD(p) \
(p += 2, FETCH_DATA (info, p), \
- (((int)((p[-2] << 8) + p[-1])) << WORD_SHIFT) >> WORD_SHIFT)
+ COERCE16 ((p[-2] << 8) + p[-1]))
+/* Get a 4 byte signed integer. */
+#define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000))
#define NEXTLONG(p) \
(p += 4, FETCH_DATA (info, p), \
- (((int)((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])) \
- << LONG_SHIFT) >> LONG_SHIFT)
+ (COERCE32 ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])))
/* NEXTSINGLE and NEXTDOUBLE handle alignment problems, but not
* byte-swapping or other float format differences. FIXME! */
return 1;
}
\f
-static void
-m68k_opcode_error(info, code, place)
+/* This function is used to print to the bit-bucket. */
+static int
+#ifdef __STDC__
+dummy_printer (FILE * file, const char * format, ...)
+#else
+dummy_printer (file) FILE *file;
+#endif
+ { return 0; }
+
+void
+dummy_print_address (vma, info)
+ bfd_vma vma;
struct disassemble_info *info;
- int code, place;
{
- (*info->fprintf_func)(info->stream,
- "<internal error in opcode table: \"%c%c\">",
- code, place);
+}
+
+static const struct m68k_opcode *
+opcode (idx)
+ int idx;
+{
+#ifdef __GNUC__
+ const int max = sizeof (m68k_opcodes) / sizeof (m68k_opcodes[0]);
+ if (idx >= max)
+ return &m68k_opcodes_2[idx - max];
+#endif
+ return &m68k_opcodes[idx];
}
/* Print the m68k instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
+ on INFO->STREAM. Returns length of the instruction, in bytes. */
int
print_insn_m68k (memaddr, info)
{
register int i;
register unsigned char *p;
+ unsigned char *save_p;
register char *d;
register unsigned long bestmask;
- int best;
+ const struct m68k_opcode *best = 0;
struct private priv;
bfd_byte *buffer = priv.the_buffer;
+ fprintf_ftype save_printer = info->fprintf_func;
+ void (*save_print_address) PARAMS((bfd_vma, struct disassemble_info*))
+ = info->print_address_func;
info->private_data = (PTR) &priv;
priv.max_fetched = priv.the_buffer;
return -1;
bestmask = 0;
- best = -1;
FETCH_DATA (info, buffer + 2);
for (i = 0; i < numopcodes; i++)
{
- register unsigned long opcode = m68k_opcodes[i].opcode;
- register unsigned long match = m68k_opcodes[i].match;
+ const struct m68k_opcode *opc = opcode (i);
+ unsigned long opcode = opc->opcode;
+ unsigned long match = opc->match;
+
+ if (opc->flags & F_ALIAS)
+ continue;
+
if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
&& ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
/* Only fetch the next two bytes if we need to. */
/* Don't use for printout the variants of divul and divsl
that have the same register number in two places.
The more general variants will match instead. */
- for (d = m68k_opcodes[i].args; *d; d += 2)
+ for (d = opc->args; *d; d += 2)
if (d[1] == 'D')
break;
point coprocessor instructions which use the same
register number in two places, as above. */
if (*d == 0)
- for (d = m68k_opcodes[i].args; *d; d += 2)
+ for (d = opc->args; *d; d += 2)
if (d[1] == 't')
break;
if (*d == 0 && match > bestmask)
{
- best = i;
+ best = opc;
bestmask = match;
}
}
}
- /* Handle undefined instructions. */
- if (best < 0)
- {
- (*info->fprintf_func) (info->stream, "0%o",
- (buffer[0] << 8) + buffer[1]);
- return 2;
- }
-
- (*info->fprintf_func) (info->stream, "%s", m68k_opcodes[best].name);
+ if (best == 0)
+ goto invalid;
/* Point at first word of argument data,
and at descriptor for first argument. */
The only place this is stored in the opcode table is
in the arguments--look for arguments which specify fields in the 2nd
or 3rd words of the instruction. */
- for (d = m68k_opcodes[best].args; *d; d += 2)
+ for (d = best->args; *d; d += 2)
{
/* I don't think it is necessary to be checking d[0] here; I suspect
all this could be moved to the case statement below. */
case '7':
case '8':
case '9':
+ case 'i':
if (p - buffer < 4)
p = buffer + 4;
break;
FETCH_DATA (info, p);
- d = m68k_opcodes[best].args;
+ d = best->args;
+
+ /* We can the operands twice. The first time we don't print anything,
+ but look for errors. */
+
+ save_p = p;
+ info->print_address_func = dummy_print_address;
+ info->fprintf_func = (fprintf_ftype)dummy_printer;
+ for ( ; *d; d += 2)
+ {
+ int eaten = print_insn_arg (d, buffer, p, memaddr + p - buffer, info);
+ if (eaten >= 0)
+ p += eaten;
+ else if (eaten == -1)
+ goto invalid;
+ else
+ {
+ (*info->fprintf_func)(info->stream,
+ "<internal error in opcode table: %s %s>\n",
+ best->name,
+ best->args);
+ goto invalid;
+ }
+
+ }
+ p = save_p;
+ info->fprintf_func = save_printer;
+ info->print_address_func = save_print_address;
+
+ d = best->args;
+
+ (*info->fprintf_func) (info->stream, "%s", best->name);
if (*d)
(*info->fprintf_func) (info->stream, " ");
while (*d)
{
- p = print_insn_arg (d, buffer, p, memaddr + p - buffer, info);
+ p += print_insn_arg (d, buffer, p, memaddr + p - buffer, info);
d += 2;
if (*d && *(d - 2) != 'I' && *d != 'k')
(*info->fprintf_func) (info->stream, ",");
}
return p - buffer;
+
+ invalid:
+ /* Handle undefined instructions. */
+ info->fprintf_func = save_printer;
+ info->print_address_func = save_print_address;
+ (*info->fprintf_func) (info->stream, "0%o",
+ (buffer[0] << 8) + buffer[1]);
+ return 2;
}
-static unsigned char *
-print_insn_arg (d, buffer, p, addr, info)
+/* Returns number of bytes "eaten" by the operand, or
+ return -1 if an invalid operand was found, or -2 if
+ an opcode tabe error was found. */
+
+static int
+print_insn_arg (d, buffer, p0, addr, info)
char *d;
unsigned char *buffer;
- register unsigned char *p;
+ unsigned char *p0;
bfd_vma addr; /* PC for this arg to be relative to */
disassemble_info *info;
{
register int val = 0;
register int place = d[1];
+ register unsigned char *p = p0;
int regno;
register CONST char *regname;
register unsigned char *p1;
static struct { char *name; int value; } names[]
= {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
{"tc", 0x003}, {"itt0",0x004}, {"itt1", 0x005},
- {"dtt0",0x006}, {"dtt1",0x007},
+ {"dtt0",0x006}, {"dtt1",0x007}, {"buscr",0x008},
{"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
{"msp", 0x803}, {"isp", 0x804},
/* Should we be calling this psr like we do in case 'Y'? */
{"mmusr",0x805},
- {"urp", 0x806}, {"srp", 0x807}};
+ {"urp", 0x806}, {"srp", 0x807}, {"pcr", 0x808}};
val = fetch_arg (buffer, place, 12, info);
for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
(*info->fprintf_func) (info->stream, "{#%d}", val);
}
else
- m68k_opcode_error (info, *d, place);
+ return -2;
break;
case '#':
else if (place == 'l')
val = NEXTLONG (p1);
else
- m68k_opcode_error (info, *d, place);
+ return -2;
(*info->fprintf_func) (info->stream, "#%d", val);
break;
val = NEXTWORD (p);
}
else
- m68k_opcode_error (info, *d, place);
+ return -2;
(*info->print_address_func) (addr + val, info);
break;
if (val != 1) /* Unusual coprocessor ID? */
(*info->fprintf_func) (info->stream, "(cpid=%d) ", val);
- if (place == 'i')
- p += 2; /* Skip coprocessor extended operands */
break;
case '*':
break;
case 'x':
- ieee_extended_to_double (&ext_format_68881,
- (char *)p, &flval);
+ FETCH_DATA (info, p + 12);
+ floatformat_to_double (&floatformat_m68881_ext,
+ (char *) p, &flval);
p += 12;
break;
break;
default:
- m68k_opcode_error (info, *d, place);
+ return -1;
}
if ( flt_p ) /* Print a float? */
(*info->fprintf_func) (info->stream, "#%g", flval);
break;
default:
- (*info->fprintf_func) (info->stream,
- "<invalid address mode 0%o>",
- (unsigned) val);
+ return -1;
}
}
break;
}
}
else
- goto de_fault;
+ return -2;
break;
case 'X':
}
break;
- default: de_fault:
- m68k_opcode_error (info, *d, ' ');
+ default:
+ return -2;
}
- return (unsigned char *) p;
+ return p - p0;
}
/* Fetch BITS bits from a position in the instruction specified by CODE.
projects / deliverable / binutils-gdb.git / blobdiff