X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=opcodes%2Fm68k-dis.c;h=10c461dae598f904092fef4a7052e03353774010;hb=c5d05dbb5e1f4d75a09a77cdd19d23639621e875;hp=ffea1afd00ad92c6ba416c0cc2921d91116ed11b;hpb=e6fb7139eeb742694bc4cc5010a40d64b225c344;p=deliverable%2Fbinutils-gdb.git diff --git a/opcodes/m68k-dis.c b/opcodes/m68k-dis.c index ffea1afd00..10c461dae5 100644 --- a/opcodes/m68k-dis.c +++ b/opcodes/m68k-dis.c @@ -1,5 +1,6 @@ /* Print Motorola 68k instructions. - Copyright 1986, 1987, 1989, 1991, 1992, 1993 Free Software Foundation, Inc. + Copyright 1986, 87, 89, 91, 92, 93, 94, 95, 96, 97, 98, 1999 + Free Software Foundation, Inc. This file is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -13,42 +14,45 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software -Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +#include "sysdep.h" #include "dis-asm.h" -#include "ieee-float.h" - -extern CONST struct ext_format ext_format_68881; - -/* 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 "floatformat.h" +#include +#include "opintl.h" #include "opcode/m68k.h" - /* Local function prototypes */ +static int +fetch_data PARAMS ((struct disassemble_info *, bfd_byte *)); + +static void +dummy_print_address PARAMS ((bfd_vma, struct disassemble_info *)); + static int fetch_arg PARAMS ((unsigned char *, int, int, disassemble_info *)); static void -print_base PARAMS ((int, int, disassemble_info*)); +print_base PARAMS ((int, bfd_vma, disassemble_info*)); static unsigned char * print_indexed PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *)); -static unsigned char * -print_insn_arg PARAMS ((char *, unsigned char *, unsigned char *, bfd_vma, - disassemble_info *)); +static int +print_insn_arg PARAMS ((const char *, unsigned char *, unsigned char *, + bfd_vma, disassemble_info *)); + +CONST char * CONST fpcr_names[] = { + "", "%fpiar", "%fpsr", "%fpiar/%fpsr", "%fpcr", + "%fpiar/%fpcr", "%fpsr/%fpcr", "%fpiar/%fpsr/%fpcr"}; + +static char *const reg_names[] = { + "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7", + "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%fp", "%sp", + "%ps", "%pc"}; /* Sign-extend an (unsigned char). */ #if __STDC__ == 1 @@ -57,57 +61,40 @@ print_insn_arg PARAMS ((char *, unsigned char *, unsigned char *, bfd_vma, #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"}; - -static char *reg_names[] = { - "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)) - +/* 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) ((bfd_signed_vma) ((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) - -/* NEXTSINGLE and NEXTDOUBLE handle alignment problems, but not - * byte-swapping or other float format differences. FIXME! */ + (COERCE32 ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1]))) -union number { - double d; - float f; - char c[10]; -}; +/* Get a 4 byte unsigned integer. */ +#define NEXTULONG(p) \ + (p += 4, FETCH_DATA (info, p), \ + (unsigned int) ((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])) +/* Get a single precision float. */ #define NEXTSINGLE(val, p) \ - { int i; union number u;\ - FETCH_DATA (info, p + sizeof (float));\ - for (i = 0; i < sizeof(float); i++) u.c[i] = *p++; \ - val = u.f; } + (p += 4, FETCH_DATA (info, p), \ + floatformat_to_double (&floatformat_ieee_single_big, (char *) p - 4, &val)) +/* Get a double precision float. */ #define NEXTDOUBLE(val, p) \ - { int i; union number u;\ - FETCH_DATA (info, p + sizeof (double));\ - for (i = 0; i < sizeof(double); i++) u.c[i] = *p++; \ - val = u.d; } + (p += 8, FETCH_DATA (info, p), \ + floatformat_to_double (&floatformat_ieee_double_big, (char *) p - 8, &val)) -/* Need a function to convert from extended to double precision... */ -#define NEXTEXTEND(p) \ - (p += 12, FETCH_DATA (info, p), 0.0) +/* Get an extended precision float. */ +#define NEXTEXTEND(val, p) \ + (p += 12, FETCH_DATA (info, p), \ + floatformat_to_double (&floatformat_m68881_ext, (char *) p - 12, &val)) /* Need a function to convert from packed to double precision. Actually, it's easier to print a @@ -161,18 +148,24 @@ fetch_data (info, addr) return 1; } +/* 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; } + static void -m68k_opcode_error(info, code, place) +dummy_print_address (vma, info) + bfd_vma vma; struct disassemble_info *info; - int code, place; { - (*info->fprintf_func)(info->stream, - "", - code, place); } /* 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) @@ -181,26 +174,99 @@ print_insn_m68k (memaddr, info) { register int i; register unsigned char *p; - register char *d; + unsigned char *save_p; + register const char *d; register unsigned long bestmask; - int best; + const struct m68k_opcode *best = 0; + unsigned int arch_mask; 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; + int major_opcode; + static int numopcodes[16]; + static const struct m68k_opcode **opcodes[16]; + + if (!opcodes[0]) + { + /* Speed up the matching by sorting the opcode table on the upper + four bits of the opcode. */ + const struct m68k_opcode **opc_pointer[16]; + + /* First count how many opcodes are in each of the sixteen buckets. */ + for (i = 0; i < m68k_numopcodes; i++) + numopcodes[(m68k_opcodes[i].opcode >> 28) & 15]++; + + /* Then create a sorted table of pointers that point into the + unsorted table. */ + opc_pointer[0] = ((const struct m68k_opcode **) + xmalloc (sizeof (struct m68k_opcode *) + * m68k_numopcodes)); + opcodes[0] = opc_pointer[0]; + for (i = 1; i < 16; i++) + { + opc_pointer[i] = opc_pointer[i - 1] + numopcodes[i - 1]; + opcodes[i] = opc_pointer[i]; + } + + for (i = 0; i < m68k_numopcodes; i++) + *opc_pointer[(m68k_opcodes[i].opcode >> 28) & 15]++ = &m68k_opcodes[i]; + + } info->private_data = (PTR) &priv; + /* Tell objdump to use two bytes per chunk and six bytes per line for + displaying raw data. */ + info->bytes_per_chunk = 2; + info->bytes_per_line = 6; + info->display_endian = BFD_ENDIAN_BIG; priv.max_fetched = priv.the_buffer; priv.insn_start = memaddr; if (setjmp (priv.bailout) != 0) /* Error return. */ return -1; + switch (info->mach) + { + default: + case 0: + arch_mask = (unsigned int) -1; + break; + case bfd_mach_m68000: + arch_mask = m68000; + break; + case bfd_mach_m68008: + arch_mask = m68008; + break; + case bfd_mach_m68010: + arch_mask = m68010; + break; + case bfd_mach_m68020: + arch_mask = m68020; + break; + case bfd_mach_m68030: + arch_mask = m68030; + break; + case bfd_mach_m68040: + arch_mask = m68040; + break; + case bfd_mach_m68060: + arch_mask = m68060; + break; + } + + arch_mask |= m68881 | m68851; + bestmask = 0; - best = -1; FETCH_DATA (info, buffer + 2); - for (i = 0; i < numopcodes; i++) + major_opcode = (buffer[0] >> 4) & 15; + for (i = 0; i < numopcodes[major_opcode]; i++) { - register unsigned long opcode = m68k_opcodes[i].opcode; - register unsigned long match = m68k_opcodes[i].match; + const struct m68k_opcode *opc = opcodes[major_opcode][i]; + unsigned long opcode = opc->opcode; + unsigned long match = opc->match; + 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. */ @@ -209,40 +275,51 @@ print_insn_m68k (memaddr, info) (FETCH_DATA (info, buffer + 4) && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8))) && ((0xff & buffer[3] & match) == (0xff & opcode))) - )) + ) + && (opc->arch & arch_mask) != 0) { /* 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; /* Don't use for printout the variants of most floating 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) + if (*d == '\0') + for (d = opc->args; *d; d += 2) if (d[1] == 't') break; - if (*d == 0 && match > bestmask) + /* Don't match fmovel with more than one register; wait for + fmoveml. */ + if (*d == '\0') + { + for (d = opc->args; *d; d += 2) + { + if (d[0] == 's' && d[1] == '8') + { + int val; + + val = fetch_arg (buffer, d[1], 3, info); + if ((val & (val - 1)) != 0) + 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. */ @@ -252,7 +329,7 @@ print_insn_m68k (memaddr, info) 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. */ @@ -273,6 +350,7 @@ print_insn_m68k (memaddr, info) case '7': case '8': case '9': + case 'i': if (p - buffer < 4) p = buffer + 4; break; @@ -286,49 +364,114 @@ print_insn_m68k (memaddr, info) break; } } - /* pflusha is an exception; it takes no arguments but is two words long. */ - if (buffer[0] == 0xf0 && buffer[1] == 0 && buffer[2] == 0x24 && - buffer[3] == 0) + + /* pflusha is an exceptions. It takes no arguments but is two words + long. Recognize it by looking at the lower 16 bits of the mask. */ + if (p - buffer < 4 && (best->match & 0xFFFF) != 0) p = buffer + 4; - + + /* lpstop is another exception. It takes a one word argument but is + three words long. */ + if (p - buffer < 6 + && (best->match & 0xffff) == 0xffff + && best->args[0] == '#' + && best->args[1] == 'w') + { + /* Copy the one word argument into the usual location for a one + word argument, to simplify printing it. We can get away with + this because we know exactly what the second word is, and we + aren't going to print anything based on it. */ + p = buffer + 6; + FETCH_DATA (info, p); + buffer[2] = buffer[4]; + buffer[3] = buffer[5]; + } + 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, + /* xgettext:c-format */ + _("\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) - char *d; +/* 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) + const 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; double flval; int flt_p; + bfd_signed_vma disp; + unsigned int uval; switch (*d) { case 'c': /* cache identifier */ { - static char *cacheFieldName[] = { "NOP", "dc", "ic", "bc" }; + static char *const cacheFieldName[] = { "nc", "dc", "ic", "bc" }; val = fetch_arg (buffer, place, 2, info); (*info->fprintf_func) (info->stream, cacheFieldName[val]); break; @@ -345,43 +488,54 @@ print_insn_arg (d, buffer, p, addr, info) case '_': /* 32-bit absolute address for move16. */ { - val = NEXTLONG (p); - (*info->fprintf_func) (info->stream, "@#"); - (*info->print_address_func) (val, info); + uval = NEXTULONG (p); + (*info->print_address_func) (uval, info); break; } case 'C': - (*info->fprintf_func) (info->stream, "ccr"); + (*info->fprintf_func) (info->stream, "%%ccr"); break; case 'S': - (*info->fprintf_func) (info->stream, "sr"); + (*info->fprintf_func) (info->stream, "%%sr"); break; case 'U': - (*info->fprintf_func) (info->stream, "usp"); + (*info->fprintf_func) (info->stream, "%%usp"); + break; + + case 'E': + (*info->fprintf_func) (info->stream, "%%acc"); + break; + + case 'G': + (*info->fprintf_func) (info->stream, "%%macsr"); + break; + + case 'H': + (*info->fprintf_func) (info->stream, "%%mask"); break; case 'J': { - 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}, + static const struct { char *name; int value; } names[] + = {{"%sfc", 0x000}, {"%dfc", 0x001}, {"%cacr", 0x002}, + {"%tc", 0x003}, {"%itt0",0x004}, {"%itt1", 0x005}, + {"%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}, + {"%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--) if (names[regno].value == val) { - (*info->fprintf_func) (info->stream, names[regno].name); + (*info->fprintf_func) (info->stream, "%s", names[regno].name); break; } if (regno < 0) @@ -398,10 +552,19 @@ print_insn_arg (d, buffer, p, addr, info) break; case 'M': - val = fetch_arg (buffer, place, 8, info); - if (val & 0x80) - val = val - 0x100; - (*info->fprintf_func) (info->stream, "#%d", val); + if (place == 'h') + { + static char *const scalefactor_name[] = { "<<", ">>" }; + val = fetch_arg (buffer, place, 1, info); + (*info->fprintf_func) (info->stream, scalefactor_name[val]); + } + else + { + val = fetch_arg (buffer, place, 8, info); + if (val & 0x80) + val = val - 0x100; + (*info->fprintf_func) (info->stream, "#%d", val); + } break; case 'T': @@ -427,14 +590,16 @@ print_insn_arg (d, buffer, p, addr, info) break; case 'r': - (*info->fprintf_func) - (info->stream, "%s@", - reg_names[fetch_arg (buffer, place, 4, info)]); + regno = fetch_arg (buffer, place, 4, info); + if (regno > 7) + (*info->fprintf_func) (info->stream, "%s@", reg_names[regno]); + else + (*info->fprintf_func) (info->stream, "@(%s)", reg_names[regno]); break; case 'F': (*info->fprintf_func) - (info->stream, "fp%d", + (info->stream, "%%fp%d", fetch_arg (buffer, place, 3, info)); break; @@ -471,7 +636,7 @@ print_insn_arg (d, buffer, p, addr, info) (*info->fprintf_func) (info->stream, "{#%d}", val); } else - m68k_opcode_error (info, *d, place); + return -2; break; case '#': @@ -487,50 +652,50 @@ print_insn_arg (d, buffer, p, addr, info) val = fetch_arg (buffer, place, 8, info); else if (place == 'b') val = NEXTBYTE (p1); - else if (place == 'w') + else if (place == 'w' || place == 'W') val = NEXTWORD (p1); else if (place == 'l') val = NEXTLONG (p1); else - m68k_opcode_error (info, *d, place); + return -2; (*info->fprintf_func) (info->stream, "#%d", val); break; case 'B': if (place == 'b') - val = NEXTBYTE (p); + disp = NEXTBYTE (p); else if (place == 'B') - val = COERCE_SIGNED_CHAR(buffer[1]); + disp = COERCE_SIGNED_CHAR(buffer[1]); else if (place == 'w' || place == 'W') - val = NEXTWORD (p); - else if (place == 'l' || place == 'L') - val = NEXTLONG (p); + disp = NEXTWORD (p); + else if (place == 'l' || place == 'L' || place == 'C') + disp = NEXTLONG (p); else if (place == 'g') { - val = NEXTBYTE (buffer); - if (val == 0) - val = NEXTWORD (p); - else if (val == -1) - val = NEXTLONG (p); + disp = NEXTBYTE (buffer); + if (disp == 0) + disp = NEXTWORD (p); + else if (disp == -1) + disp = NEXTLONG (p); } else if (place == 'c') { if (buffer[1] & 0x40) /* If bit six is one, long offset */ - val = NEXTLONG (p); + disp = NEXTLONG (p); else - val = NEXTWORD (p); + disp = NEXTWORD (p); } else - m68k_opcode_error (info, *d, place); + return -2; - (*info->print_address_func) (addr + val, info); + (*info->print_address_func) (addr + disp, info); break; case 'd': val = NEXTWORD (p); (*info->fprintf_func) (info->stream, "%s@(%d)", - reg_names[fetch_arg (buffer, place, 3, info)], val); + reg_names[fetch_arg (buffer, place, 3, info) + 8], val); break; case 's': @@ -544,8 +709,6 @@ print_insn_arg (d, buffer, p, addr, info) 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 '*': @@ -558,8 +721,15 @@ print_insn_arg (d, buffer, p, addr, info) case '?': case '/': case '&': - case '`': case '|': + case '<': + case '>': + case 'm': + case 'n': + case 'o': + case 'p': + case 'q': + case 'v': if (place == 'd') { @@ -608,19 +778,19 @@ print_insn_arg (d, buffer, p, addr, info) { case 0: val = NEXTWORD (p); - (*info->fprintf_func) (info->stream, "@#"); (*info->print_address_func) (val, info); break; case 1: - val = NEXTLONG (p); - (*info->fprintf_func) (info->stream, "@#"); - (*info->print_address_func) (val, info); + uval = NEXTULONG (p); + (*info->print_address_func) (uval, info); break; case 2: val = NEXTWORD (p); + (*info->fprintf_func) (info->stream, "%%pc@("); (*info->print_address_func) (addr + val, info); + (*info->fprintf_func) (info->stream, ")"); break; case 3: @@ -655,9 +825,7 @@ print_insn_arg (d, buffer, p, addr, info) break; case 'x': - ieee_extended_to_double (&ext_format_68881, - (char *)p, &flval); - p += 12; + NEXTEXTEND(flval, p); break; case 'p': @@ -665,7 +833,7 @@ print_insn_arg (d, buffer, p, addr, info) break; default: - m68k_opcode_error (info, *d, place); + return -1; } if ( flt_p ) /* Print a float? */ (*info->fprintf_func) (info->stream, "#%g", flval); @@ -674,9 +842,7 @@ print_insn_arg (d, buffer, p, addr, info) break; default: - (*info->fprintf_func) (info->stream, - "", - (unsigned) val); + return -1; } } break; @@ -749,16 +915,23 @@ print_insn_arg (d, buffer, p, addr, info) if (doneany) (*info->fprintf_func) (info->stream, "/"); doneany = 1; - (*info->fprintf_func) (info->stream, "fp%d", regno); + (*info->fprintf_func) (info->stream, "%%fp%d", regno); first_regno = regno; while (val & (1 << (regno + 1))) ++regno; if (regno > first_regno) - (*info->fprintf_func) (info->stream, "-fp%d", regno); + (*info->fprintf_func) (info->stream, "-%%fp%d", regno); } } + else if (place == '8') + { + /* fmoveml for FP status registers */ + (*info->fprintf_func) (info->stream, "%s", + fpcr_names[fetch_arg (buffer, place, 3, + info)]); + } else - goto de_fault; + return -2; break; case 'X': @@ -766,31 +939,33 @@ print_insn_arg (d, buffer, p, addr, info) case 'Y': case 'Z': case 'W': + case '0': + case '1': + case '2': case '3': - case 'P': { int val = fetch_arg (buffer, place, 5, info); char *name = 0; switch (val) { - case 2: name = "tt0"; break; - case 3: name = "tt1"; break; - case 0x10: name = "tc"; break; - case 0x11: name = "drp"; break; - case 0x12: name = "srp"; break; - case 0x13: name = "crp"; break; - case 0x14: name = "cal"; break; - case 0x15: name = "val"; break; - case 0x16: name = "scc"; break; - case 0x17: name = "ac"; break; - case 0x18: name = "psr"; break; - case 0x19: name = "pcsr"; break; + case 2: name = "%tt0"; break; + case 3: name = "%tt1"; break; + case 0x10: name = "%tc"; break; + case 0x11: name = "%drp"; break; + case 0x12: name = "%srp"; break; + case 0x13: name = "%crp"; break; + case 0x14: name = "%cal"; break; + case 0x15: name = "%val"; break; + case 0x16: name = "%scc"; break; + case 0x17: name = "%ac"; break; + case 0x18: name = "%psr"; break; + case 0x19: name = "%pcsr"; break; case 0x1c: case 0x1d: { int break_reg = ((buffer[3] >> 2) & 7); (*info->fprintf_func) - (info->stream, val == 0x1c ? "bad%d" : "bac%d", + (info->stream, val == 0x1c ? "%%bad%d" : "%%bac%d", break_reg); } break; @@ -798,7 +973,7 @@ print_insn_arg (d, buffer, p, addr, info) (*info->fprintf_func) (info->stream, "", val); } if (name) - (*info->fprintf_func) (info->stream, name); + (*info->fprintf_func) (info->stream, "%s", name); } break; @@ -806,16 +981,17 @@ print_insn_arg (d, buffer, p, addr, info) { int fc = fetch_arg (buffer, place, 5, info); if (fc == 1) - (*info->fprintf_func) (info->stream, "dfc"); + (*info->fprintf_func) (info->stream, "%%dfc"); else if (fc == 0) - (*info->fprintf_func) (info->stream, "sfc"); + (*info->fprintf_func) (info->stream, "%%sfc"); else - (*info->fprintf_func) (info->stream, "", fc); + /* xgettext:c-format */ + (*info->fprintf_func) (info->stream, _(""), fc); } break; case 'V': - (*info->fprintf_func) (info->stream, "val"); + (*info->fprintf_func) (info->stream, "%%val"); break; case 't': @@ -825,11 +1001,27 @@ print_insn_arg (d, buffer, p, addr, info) } break; - default: de_fault: - m68k_opcode_error (info, *d, ' '); + case 'u': + { + short is_upper = 0; + int reg = fetch_arg (buffer, place, 5, info); + + if (reg & 0x10) + { + is_upper = 1; + reg &= 0xf; + } + (*info->fprintf_func) (info->stream, "%s%s", + reg_names[reg], + is_upper ? "u" : "l"); + } + break; + + default: + return -2; } - return (unsigned char *) p; + return p - p0; } /* Fetch BITS bits from a position in the instruction specified by CODE. @@ -928,12 +1120,40 @@ fetch_arg (buffer, code, bits, info) val = (buffer[1] >> 6); break; + case 'm': + val = (buffer[1] & 0x40 ? 0x8 : 0) + | ((buffer[0] >> 1) & 0x7) + | (buffer[3] & 0x80 ? 0x10 : 0); + break; + + case 'n': + val = (buffer[1] & 0x40 ? 0x8 : 0) | ((buffer[0] >> 1) & 0x7); + break; + + case 'o': + val = (buffer[2] >> 4) | (buffer[3] & 0x80 ? 0x10 : 0); + break; + + case 'M': + val = buffer[1] | (buffer[3] & 0x40 ? 0x10 : 0); + break; + + case 'N': + val = buffer[3] | (buffer[3] & 0x40 ? 0x10 : 0); + break; + + case 'h': + val = buffer[2] >> 2; + break; + default: abort (); } switch (bits) { + case 1: + return val & 1; case 2: return val & 3; case 3: @@ -967,16 +1187,17 @@ print_indexed (basereg, p, addr, info) disassemble_info *info; { register int word; - static char *scales[] = {"", "*2", "*4", "*8"}; - register int base_disp; - register int outer_disp; + static char *const scales[] = {"", ":2", ":4", ":8"}; + bfd_vma base_disp; + bfd_vma outer_disp; char buf[40]; + char vmabuf[50]; word = NEXTWORD (p); /* Generate the text for the index register. Where this will be output is not yet determined. */ - sprintf (buf, "[%s.%c%s]", + sprintf (buf, "%s:%c%s", reg_names[(word >> 12) & 0xf], (word & 0x800) ? 'l' : 'w', scales[(word >> 9) & 3]); @@ -985,11 +1206,13 @@ print_indexed (basereg, p, addr, info) if ((word & 0x100) == 0) { - print_base (basereg, - ((word & 0x80) ? word | 0xff00 : word & 0xff) - + ((basereg == -1) ? addr : 0), - info); - (*info->fprintf_func) (info->stream, "%s", buf); + base_disp = word & 0xff; + if ((base_disp & 0x80) != 0) + base_disp -= 0x100; + if (basereg == -1) + base_disp += addr; + print_base (basereg, base_disp, info); + (*info->fprintf_func) (info->stream, ",%s)", buf); return p; } @@ -997,9 +1220,14 @@ print_indexed (basereg, p, addr, info) /* First, compute the displacement to add to the base register. */ if (word & 0200) - basereg = -2; + { + if (basereg == -1) + basereg = -3; + else + basereg = -2; + } if (word & 0100) - buf[0] = 0; + buf[0] = '\0'; base_disp = 0; switch ((word >> 4) & 3) { @@ -1017,7 +1245,9 @@ print_indexed (basereg, p, addr, info) if ((word & 7) == 0) { print_base (basereg, base_disp, info); - (*info->fprintf_func) (info->stream, "%s", buf); + if (buf[0] != '\0') + (*info->fprintf_func) (info->stream, ",%s", buf); + (*info->fprintf_func) (info->stream, ")"); return p; } @@ -1033,15 +1263,17 @@ print_indexed (basereg, p, addr, info) outer_disp = NEXTLONG (p); } - (*info->fprintf_func) (info->stream, "%d(", outer_disp); print_base (basereg, base_disp, info); - - /* If postindexed, print the closeparen before the index. */ - if (word & 4) - (*info->fprintf_func) (info->stream, ")%s", buf); - /* If preindexed, print the closeparen after the index. */ - else - (*info->fprintf_func) (info->stream, "%s)", buf); + if ((word & 4) == 0 && buf[0] != '\0') + { + (*info->fprintf_func) (info->stream, ",%s", buf); + buf[0] = '\0'; + } + sprintf_vma (vmabuf, outer_disp); + (*info->fprintf_func) (info->stream, ")@(%s", vmabuf); + if (buf[0] != '\0') + (*info->fprintf_func) (info->stream, ",%s", buf); + (*info->fprintf_func) (info->stream, ")"); return p; } @@ -1052,13 +1284,26 @@ print_indexed (basereg, p, addr, info) static void print_base (regno, disp, info) int regno; - int disp; + bfd_vma disp; disassemble_info *info; { - if (regno == -2) - (*info->fprintf_func) (info->stream, "%d", disp); - else if (regno == -1) - (*info->fprintf_func) (info->stream, "0x%x", (unsigned) disp); + if (regno == -1) + { + (*info->fprintf_func) (info->stream, "%%pc@("); + (*info->print_address_func) (disp, info); + } else - (*info->fprintf_func) (info->stream, "%d(%s)", disp, reg_names[regno]); + { + char buf[50]; + + if (regno == -2) + (*info->fprintf_func) (info->stream, "@("); + else if (regno == -3) + (*info->fprintf_func) (info->stream, "%%zpc@("); + else + (*info->fprintf_func) (info->stream, "%s@(", reg_names[regno]); + + sprintf_vma (buf, disp); + (*info->fprintf_func) (info->stream, "%s", buf); + } }