/* Print Motorola 68k instructions for GDB, the GNU debugger.
- Copyright 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
+ Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
-#include <stdio.h>
-
#include "defs.h"
#include "symtab.h"
-#include "opcode/m68k.h"
#include "gdbcore.h"
+#include "ieee-float.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
+ two data items declared near each other will be contiguous in
+ memory. This kludge can be removed, FIXME, when GCC is fixed to not
+ be a hog about initializers. */
+
+#ifdef __GNUC__
+#define BREAK_UP_BIG_DECL }; \
+ struct m68k_opcode m68k_opcodes_2[] = {
+#define AND_OTHER_PART sizeof (m68k_opcodes_2)
+#endif
+
+#include "opcode/m68k.h"
+
+
+/* Local function prototypes */
+
+static int
+fetch_arg PARAMS ((unsigned char *, int, int));
+
+static void
+print_base PARAMS ((int, int, FILE *));
+
+static unsigned char *
+print_indexed PARAMS ((int, unsigned char *, CORE_ADDR, FILE *));
+
+static unsigned char *
+print_insn_arg PARAMS ((char *, unsigned char *, unsigned char *, CORE_ADDR,
+ FILE *));
/* 68k instructions are never longer than this many bytes. */
#define MAXLEN 22
-/* Number of elements in the opcode table. */
-#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
+const char * const fpcr_names[] = {
+ "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
+ "fpiar/fpcr", "fpsr/fpcr", "fpiar/fpsr/fpcr"};
-extern char *reg_names[];
-char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
- "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
+/* 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 BYTE_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 1))
+#define WORD_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 2))
+#define LONG_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 4))
-static unsigned char *print_insn_arg ();
-static unsigned char *print_indexed ();
-static void print_base ();
-static int fetch_arg ();
-
-#define NEXTBYTE(p) (p += 2, ((char *)p)[-1])
+#define NEXTBYTE(p) (p += 2, ((int)(p[-1]) << BYTE_SHIFT) >> BYTE_SHIFT)
#define NEXTWORD(p) \
- (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
+ (p += 2, (((int)((p[-2] << 8) + p[-1])) << WORD_SHIFT) >> WORD_SHIFT)
#define NEXTLONG(p) \
- (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
+ (p += 4, (((int)((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])) \
+ << LONG_SHIFT) >> LONG_SHIFT)
+/* Ecch -- assumes host == target float formats. FIXME. */
#define NEXTSINGLE(p) \
(p += 4, *((float *)(p - 4)))
#define NEXTDOUBLE(p) \
(p += 8, *((double *)(p - 8)))
-
-#define NEXTEXTEND(p) \
- (p += 12, 0.0) /* Need a function to convert from extended to double
- precision... */
-
-#define NEXTPACKED(p) \
- (p += 12, 0.0) /* Need a function to convert from packed to double
- precision. Actually, it's easier to print a
- packed number than a double anyway, so maybe
- there should be a special case to handle this... */
\f
/* Print the m68k instruction at address MEMADDR in debugged memory,
on STREAM. Returns length of the instruction, in bytes. */
register int bestmask;
int best;
- read_memory (memaddr, buffer, MAXLEN);
+ read_memory (memaddr, (char *) buffer, MAXLEN);
bestmask = 0;
best = -1;
- for (i = 0; i < NOPCODES; i++)
+ for (i = 0; i < numopcodes; i++)
{
register unsigned int opcode = m68k_opcodes[i].opcode;
register unsigned int match = m68k_opcodes[i].match;
register int val;
register int place = d[1];
int regno;
- register char *regname;
+ register const char *regname;
register unsigned char *p1;
- register double flval;
+ double flval;
int flt_p;
switch (*d)
{
+ case 'c': /* cache identifier */
+ {
+ static char *cacheFieldName[] = { "NOP", "dc", "ic", "bc" };
+ val = fetch_arg (buffer, place, 2);
+ fprintf_filtered (stream, cacheFieldName[val]);
+ break;
+ }
+
+ case 'a': /* address register indirect only. Cf. case '+'. */
+ {
+ fprintf_filtered (stream,
+ "%s@",
+ reg_names [fetch_arg (buffer, place, 3) + 8]);
+ break;
+ }
+
+ case '_': /* 32-bit absolute address for move16. */
+ {
+ val = NEXTLONG (p);
+ fprintf_filtered (stream, "@#");
+ print_address (val, stream);
+ break;
+ }
+
case 'C':
fprintf_filtered (stream, "ccr");
break;
{
static struct { char *name; int value; } names[]
= {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
+ {"tc", 0x003}, {"itt0",0x004}, {"itt1", 0x005},
+ {"dtt0",0x006}, {"dtt1",0x007},
{"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
- {"msp", 0x803}, {"isp", 0x804}};
+ {"msp", 0x803}, {"isp", 0x804}, {"mmusr",0x805},
+ {"urp", 0x806}, {"srp", 0x807}};
val = fetch_arg (buffer, place, 12);
for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
break;
+ case 'r':
+ fprintf_filtered (stream, "%s@", reg_names[fetch_arg (buffer, place, 4)]);
+ break;
+
case 'F':
fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3));
break;
if (place == 'b')
val = NEXTBYTE (p);
else if (place == 'B')
- val = buffer[1];
+ val = NEXTBYTE (buffer); /* from the opcode word */
else if (place == 'w' || place == 'W')
val = NEXTWORD (p);
else if (place == 'l' || place == 'L')
val = NEXTLONG (p);
else if (place == 'g')
{
- val = ((char *)buffer)[1];
+ val = NEXTBYTE (buffer);
if (val == 0)
val = NEXTWORD (p);
else if (val == -1)
case '?':
case '/':
case '&':
+ case '`':
if (place == 'd')
{
flval = NEXTDOUBLE(p);
break;
+#ifdef HAVE_68881
case 'x':
- flval = NEXTEXTEND(p);
+ ieee_extended_to_double (&ext_format_68881,
+ (char *)p, &flval);
+ p += 12;
break;
+#endif
case 'p':
- flval = NEXTPACKED(p);
+ p += 12;
+ flval = 0; /* FIXME, handle packed decimal someday. */
break;
default:
}
}
else
- abort ();
+ goto de_fault;
break;
- default:
+ default: de_fault:
error ("Invalid arg format in opcode table: \"%c\".", *d);
}
static int
fetch_arg (buffer, code, bits)
unsigned char *buffer;
- char code;
+ int code;
int bits;
{
register int val;
val >>= 10;
break;
+ case 'e':
+ val = (buffer[1] >> 6);
+ break;
+
default:
abort ();
}
switch (bits)
{
+ case 2:
+ return val & 3;
case 3:
return val & 7;
case 4:
print_indexed (basereg, p, addr, stream)
int basereg;
unsigned char *p;
- FILE *stream;
CORE_ADDR addr;
+ FILE *stream;
{
register int word;
static char *scales[] = {"", "*2", "*4", "*8"};
projects / deliverable / binutils-gdb.git / blobdiff