[deliverable/binutils-gdb.git] / gdb / m68k-pinsn.c

/* Print Motorola 68k instructions for GDB, the GNU debugger.
   Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.

This file is part of GDB.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
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.  */

#include "defs.h"
#include "symtab.h"
#include "opcode/m68k.h"
#include "gdbcore.h"
#include "ieee-float.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"};

/* 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))

#define NEXTBYTE(p)  (p += 2, ((int)(p[-1]) << BYTE_SHIFT) >> BYTE_SHIFT)

#define NEXTWORD(p)  \
  (p += 2, (((int)((p[-2] << 8) + p[-1])) << WORD_SHIFT) >> WORD_SHIFT)

#define NEXTLONG(p)  \
  (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)))
\f
/* Print the m68k instruction at address MEMADDR in debugged memory,
   on STREAM.  Returns length of the instruction, in bytes.  */

int
print_insn (memaddr, stream)
     CORE_ADDR memaddr;
     FILE *stream;
{
  unsigned char buffer[MAXLEN];
  register int i;
  register unsigned char *p;
  register char *d;
  register int bestmask;
  int best;

  read_memory (memaddr, (char *) buffer, MAXLEN);

  bestmask = 0;
  best = -1;
  for (i = 0; i < NOPCODES; i++)
    {
      register unsigned int opcode = m68k_opcodes[i].opcode;
      register unsigned int match = m68k_opcodes[i].match;
      if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
	  && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
	  && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
	  && ((0xff & buffer[3] & match) == (0xff & opcode)))
	{
	  /* 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)
	    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[1] == 't')
		break;

	  if (*d == 0 && match > bestmask)
	    {
	      best = i;
	      bestmask = match;
	    }
	}
    }

  /* Handle undefined instructions.  */
  if (best < 0)
    {
      fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]);
      return 2;
    }

  fprintf_filtered (stream, "%s", m68k_opcodes[best].name);

  /* Point at first word of argument data,
     and at descriptor for first argument.  */
  p = buffer + 2;
  
  /* Why do this this way? -MelloN */
  for (d = m68k_opcodes[best].args; *d; d += 2)
    {
      if (d[0] == '#')
	{
	  if (d[1] == 'l' && p - buffer < 6)
	    p = buffer + 6;
	  else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
	    p = buffer + 4;
	}
      if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
	p = buffer + 4;
      if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
	p = buffer + 6;
      if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
	p = buffer + 4;
    }

  d = m68k_opcodes[best].args;

  if (*d)
    fputs_filtered (" ", stream);

  while (*d)
    {
      p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
      d += 2;
      if (*d && *(d - 2) != 'I' && *d != 'k')
	fputs_filtered (",", stream);
    }
  return p - buffer;
}

static unsigned char *
print_insn_arg (d, buffer, p, addr, stream)
     char *d;
     unsigned char *buffer;
     register unsigned char *p;
     CORE_ADDR addr;		/* PC for this arg to be relative to */
     FILE *stream;
{
  register int val;
  register int place = d[1];
  int regno;
  register const char *regname;
  register unsigned char *p1;
  double flval;
  int flt_p;

  switch (*d)
    {
    case 'C':
      fprintf_filtered (stream, "ccr");
      break;

    case 'S':
      fprintf_filtered (stream, "sr");
      break;

    case 'U':
      fprintf_filtered (stream, "usp");
      break;

    case 'J':
      {
	static struct { char *name; int value; } names[]
	  = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
	     {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
	     {"msp", 0x803}, {"isp", 0x804}};

	val = fetch_arg (buffer, place, 12);
	for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
	  if (names[regno].value == val)
	    {
	      fprintf_filtered (stream, names[regno].name);
	      break;
	    }
	if (regno < 0)
	  fprintf_filtered (stream, "%d", val);
      }
      break;

    case 'Q':
      val = fetch_arg (buffer, place, 3);
      /* 0 means 8, except for the bkpt instruction... */
      if (val == 0 && d[1] != 's')
	val = 8;
      fprintf_filtered (stream, "#%d", val);
      break;

    case 'M':
      val = fetch_arg (buffer, place, 8);
      if (val & 0x80)
	val = val - 0x100;
      fprintf_filtered (stream, "#%d", val);
      break;

    case 'T':
      val = fetch_arg (buffer, place, 4);
      fprintf_filtered (stream, "#%d", val);
      break;

    case 'D':
      fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
      break;

    case 'A':
      fprintf_filtered (stream, "%s",
			reg_names[fetch_arg (buffer, place, 3) + 010]);
      break;

    case 'R':
      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;

    case 'O':
      val = fetch_arg (buffer, place, 6);
      if (val & 0x20)
	fprintf_filtered (stream, "%s", reg_names [val & 7]);
      else
	fprintf_filtered (stream, "%d", val);
      break;

    case '+':
      fprintf_filtered (stream, "%s@+",
			reg_names[fetch_arg (buffer, place, 3) + 8]);
      break;

    case '-':
      fprintf_filtered (stream, "%s@-",
	       reg_names[fetch_arg (buffer, place, 3) + 8]);
      break;

    case 'k':
      if (place == 'k')
	fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
      else if (place == 'C')
	{
	  val = fetch_arg (buffer, place, 7);
	  if ( val > 63 )		/* This is a signed constant. */
	    val -= 128;
	  fprintf_filtered (stream, "{#%d}", val);
	}
      else
	error ("Invalid arg format in opcode table: \"%c%c\".",
	       *d, place);
      break;

    case '#':
    case '^':
      p1 = buffer + (*d == '#' ? 2 : 4);
      if (place == 's')
	val = fetch_arg (buffer, place, 4);
      else if (place == 'C')
	val = fetch_arg (buffer, place, 7);
      else if (place == '8')
	val = fetch_arg (buffer, place, 3);
      else if (place == '3')
	val = fetch_arg (buffer, place, 8);
      else if (place == 'b')
	val = NEXTBYTE (p1);
      else if (place == 'w')
	val = NEXTWORD (p1);
      else if (place == 'l')
	val = NEXTLONG (p1);
      else
	error ("Invalid arg format in opcode table: \"%c%c\".",
	       *d, place);
      fprintf_filtered (stream, "#%d", val);
      break;

    case 'B':
      if (place == 'b')
	val = NEXTBYTE (p);
      else if (place == 'B')
	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 = NEXTBYTE (buffer);
	  if (val == 0)
	    val = NEXTWORD (p);
	  else if (val == -1)
	    val = NEXTLONG (p);
	}
      else if (place == 'c')
	{
	  if (buffer[1] & 0x40)		/* If bit six is one, long offset */
	    val = NEXTLONG (p);
	  else
	    val = NEXTWORD (p);
	}
      else
	error ("Invalid arg format in opcode table: \"%c%c\".",
	       *d, place);

      print_address (addr + val, stream);
      break;

    case 'd':
      val = NEXTWORD (p);
      fprintf_filtered (stream, "%s@(%d)",
			reg_names[fetch_arg (buffer, place, 3)], val);
      break;

    case 's':
      fprintf_filtered (stream, "%s",
			fpcr_names[fetch_arg (buffer, place, 3)]);
      break;

    case 'I':
      val = fetch_arg (buffer, 'd', 3);		  /* Get coprocessor ID... */
      if (val != 1)				/* Unusual coprocessor ID? */
	fprintf_filtered (stream, "(cpid=%d) ", val);
      if (place == 'i')
	p += 2;			     /* Skip coprocessor extended operands */
      break;

    case '*':
    case '~':
    case '%':
    case ';':
    case '@':
    case '!':
    case '$':
    case '?':
    case '/':
    case '&':

      if (place == 'd')
	{
	  val = fetch_arg (buffer, 'x', 6);
	  val = ((val & 7) << 3) + ((val >> 3) & 7);
	}
      else
	val = fetch_arg (buffer, 's', 6);

      /* Get register number assuming address register.  */
      regno = (val & 7) + 8;
      regname = reg_names[regno];
      switch (val >> 3)
	{
	case 0:
	  fprintf_filtered (stream, "%s", reg_names[val]);
	  break;

	case 1:
	  fprintf_filtered (stream, "%s", regname);
	  break;

	case 2:
	  fprintf_filtered (stream, "%s@", regname);
	  break;

	case 3:
	  fprintf_filtered (stream, "%s@+", regname);
	  break;

	case 4:
	  fprintf_filtered (stream, "%s@-", regname);
	  break;

	case 5:
	  val = NEXTWORD (p);
	  fprintf_filtered (stream, "%s@(%d)", regname, val);
	  break;

	case 6:
	  p = print_indexed (regno, p, addr, stream);
	  break;

	case 7:
	  switch (val & 7)
	    {
	    case 0:
	      val = NEXTWORD (p);
	      fprintf_filtered (stream, "@#");
	      print_address (val, stream);
	      break;

	    case 1:
	      val = NEXTLONG (p);
	      fprintf_filtered (stream, "@#");
	      print_address (val, stream);
	      break;

	    case 2:
	      val = NEXTWORD (p);
	      print_address (addr + val, stream);
	      break;

	    case 3:
	      p = print_indexed (-1, p, addr, stream);
	      break;

	    case 4:
	      flt_p = 1;	/* Assume it's a float... */
	      switch( place )
	      {
		case 'b':
		  val = NEXTBYTE (p);
		  flt_p = 0;
		  break;

		case 'w':
		  val = NEXTWORD (p);
		  flt_p = 0;
		  break;

		case 'l':
		  val = NEXTLONG (p);
		  flt_p = 0;
		  break;

		case 'f':
		  flval = NEXTSINGLE(p);
		  break;

		case 'F':
		  flval = NEXTDOUBLE(p);
		  break;

#ifdef HAVE_68881
		case 'x':
		  ieee_extended_to_double (&ext_format_68881, p, &flval);
		  p += 12;
		  break;
#endif

		case 'p':
		  p += 12;
		  flval = 0;	/* FIXME, handle packed decimal someday.  */
		  break;

		default:
		  error ("Invalid arg format in opcode table: \"%c%c\".",
		       *d, place);
	      }
	      if ( flt_p )	/* Print a float? */
		fprintf_filtered (stream, "#%g", flval);
	      else
		fprintf_filtered (stream, "#%d", val);
	      break;

	    default:
	      fprintf_filtered (stream, "<invalid address mode 0%o>", val);
	    }
	}
      break;

    case 'L':
    case 'l':
	if (place == 'w')
	  {
	    char doneany;
	    p1 = buffer + 2;
	    val = NEXTWORD (p1);
	    /* Move the pointer ahead if this point is farther ahead
	       than the last.  */
	    p = p1 > p ? p1 : p;
	    if (val == 0)
	      {
		fputs_filtered ("#0", stream);
		break;
	      }
	    if (*d == 'l')
	      {
		register int newval = 0;
		for (regno = 0; regno < 16; ++regno)
		  if (val & (0x8000 >> regno))
		    newval |= 1 << regno;
		val = newval;
	      }
	    val &= 0xffff;
	    doneany = 0;
	    for (regno = 0; regno < 16; ++regno)
	      if (val & (1 << regno))
		{
		  int first_regno;
		  if (doneany)
		    fputs_filtered ("/", stream);
		  doneany = 1;
		  fprintf_filtered (stream, "%s", reg_names[regno]);
		  first_regno = regno;
		  while (val & (1 << (regno + 1)))
		    ++regno;
		  if (regno > first_regno)
		    fprintf_filtered (stream, "-%s", reg_names[regno]);
		}
	  }
	else if (place == '3')
	  {
	    /* `fmovem' insn.  */
	    char doneany;
	    val = fetch_arg (buffer, place, 8);
	    if (val == 0)
	      {
		fputs_filtered ("#0", stream);
		break;
	      }
	    if (*d == 'l')
	      {
		register int newval = 0;
		for (regno = 0; regno < 8; ++regno)
		  if (val & (0x80 >> regno))
		    newval |= 1 << regno;
		val = newval;
	      }
	    val &= 0xff;
	    doneany = 0;
	    for (regno = 0; regno < 8; ++regno)
	      if (val & (1 << regno))
		{
		  int first_regno;
		  if (doneany)
		    fputs_filtered ("/", stream);
		  doneany = 1;
		  fprintf_filtered (stream, "fp%d", regno);
		  first_regno = regno;
		  while (val & (1 << (regno + 1)))
		    ++regno;
		  if (regno > first_regno)
		    fprintf_filtered (stream, "-fp%d", regno);
		}
	  }
	else
	  goto de_fault;
      break;

    default:  de_fault:
      error ("Invalid arg format in opcode table: \"%c\".", *d);
    }

  return (unsigned char *) p;
}

/* Fetch BITS bits from a position in the instruction specified by CODE.
   CODE is a "place to put an argument", or 'x' for a destination
   that is a general address (mode and register).
   BUFFER contains the instruction.  */

static int
fetch_arg (buffer, code, bits)
     unsigned char *buffer;
     int code;
     int bits;
{
  register int val;
  switch (code)
    {
    case 's':
      val = buffer[1];
      break;

    case 'd':			/* Destination, for register or quick.  */
      val = (buffer[0] << 8) + buffer[1];
      val >>= 9;
      break;

    case 'x':			/* Destination, for general arg */
      val = (buffer[0] << 8) + buffer[1];
      val >>= 6;
      break;

    case 'k':
      val = (buffer[3] >> 4);
      break;

    case 'C':
      val = buffer[3];
      break;

    case '1':
      val = (buffer[2] << 8) + buffer[3];
      val >>= 12;
      break;

    case '2':
      val = (buffer[2] << 8) + buffer[3];
      val >>= 6;
      break;

    case '3':
    case 'j':
      val = (buffer[2] << 8) + buffer[3];
      break;

    case '4':
      val = (buffer[4] << 8) + buffer[5];
      val >>= 12;
      break;

    case '5':
      val = (buffer[4] << 8) + buffer[5];
      val >>= 6;
      break;

    case '6':
      val = (buffer[4] << 8) + buffer[5];
      break;

    case '7':
      val = (buffer[2] << 8) + buffer[3];
      val >>= 7;
      break;
      
    case '8':
      val = (buffer[2] << 8) + buffer[3];
      val >>= 10;
      break;

    default:
      abort ();
    }

  switch (bits)
    {
    case 3:
      return val & 7;
    case 4:
      return val & 017;
    case 5:
      return val & 037;
    case 6:
      return val & 077;
    case 7:
      return val & 0177;
    case 8:
      return val & 0377;
    case 12:
      return val & 07777;
    default:
      abort ();
    }
}

/* Print an indexed argument.  The base register is BASEREG (-1 for pc).
   P points to extension word, in buffer.
   ADDR is the nominal core address of that extension word.  */

static unsigned char *
print_indexed (basereg, p, addr, stream)
     int basereg;
     unsigned char *p;
     CORE_ADDR addr;
     FILE *stream;
{
  register int word;
  static char *scales[] = {"", "*2", "*4", "*8"};
  register int base_disp;
  register int outer_disp;
  char buf[40];

  word = NEXTWORD (p);

  /* Generate the text for the index register.
     Where this will be output is not yet determined.  */
  sprintf (buf, "[%s.%c%s]",
	   reg_names[(word >> 12) & 0xf],
	   (word & 0x800) ? 'l' : 'w',
	   scales[(word >> 9) & 3]);

  /* Handle the 68000 style of indexing.  */

  if ((word & 0x100) == 0)
    {
      print_base (basereg,
		  ((word & 0x80) ? word | 0xff00 : word & 0xff)
		  + ((basereg == -1) ? addr : 0),
		  stream);
      fputs_filtered (buf, stream);
      return p;
    }

  /* Handle the generalized kind.  */
  /* First, compute the displacement to add to the base register.  */

  if (word & 0200)
    basereg = -2;
  if (word & 0100)
    buf[0] = 0;
  base_disp = 0;
  switch ((word >> 4) & 3)
    {
    case 2:
      base_disp = NEXTWORD (p);
      break;
    case 3:
      base_disp = NEXTLONG (p);
    }
  if (basereg == -1)
    base_disp += addr;

  /* Handle single-level case (not indirect) */

  if ((word & 7) == 0)
    {
      print_base (basereg, base_disp, stream);
      fputs_filtered (buf, stream);
      return p;
    }

  /* Two level.  Compute displacement to add after indirection.  */

  outer_disp = 0;
  switch (word & 3)
    {
    case 2:
      outer_disp = NEXTWORD (p);
      break;
    case 3:
      outer_disp = NEXTLONG (p);
    }

  fprintf_filtered (stream, "%d(", outer_disp);
  print_base (basereg, base_disp, stream);

  /* If postindexed, print the closeparen before the index.  */
  if (word & 4)
    fprintf_filtered (stream, ")%s", buf);
  /* If preindexed, print the closeparen after the index.  */
  else
    fprintf_filtered (stream, "%s)", buf);

  return p;
}

/* Print a base register REGNO and displacement DISP, on STREAM.
   REGNO = -1 for pc, -2 for none (suppressed).  */

static void
print_base (regno, disp, stream)
     int regno;
     int disp;
     FILE *stream;
{
  if (regno == -2)
    fprintf_filtered (stream, "%d", disp);
  else if (regno == -1)
    fprintf_filtered (stream, "0x%x", disp);
  else
    fprintf_filtered (stream, "%d(%s)", disp, reg_names[regno]);
}
Commit	Line	Data
7d9884b9	1	/* Print Motorola 68k instructions for GDB, the GNU debugger.
8970a55e	2	Copyright 1986, 1987, 1989, 1991, 1992 Free Software Foundation, Inc.
dd3b648e RP	3
	4	This file is part of GDB.
	5
99a7de40	6	This program is free software; you can redistribute it and/or modify
dd3b648e	7	it under the terms of the GNU General Public License as published by
99a7de40 JG	8	the Free Software Foundation; either version 2 of the License, or
99a7de40 JG	9	(at your option) any later version.
dd3b648e	10
99a7de40	11	This program is distributed in the hope that it will be useful,
dd3b648e RP	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
99a7de40 JG	17	along with this program; if not, write to the Free Software
99a7de40 JG	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
dd3b648e	19
dd3b648e	20	#include "defs.h"
dd3b648e	21	#include "symtab.h"
7e258d18	22	#include "opcode/m68k.h"
dd3b648e	23	#include "gdbcore.h"
8970a55e	24	#include "ieee-float.h"
dd3b648e	25
1ab3bf1b JG	26	/* Local function prototypes */
	27
	28	static int
	29	fetch_arg PARAMS ((unsigned char *, int, int));
	30
	31	static void
	32	print_base PARAMS ((int, int, FILE *));
	33
	34	static unsigned char *
	35	print_indexed PARAMS ((int, unsigned char , CORE_ADDR, FILE ));
	36
	37	static unsigned char *
	38	print_insn_arg PARAMS ((char , unsigned char , unsigned char *, CORE_ADDR,
	39	FILE *));
	40
dd3b648e RP	41	/* 68k instructions are never longer than this many bytes. */
	42	#define MAXLEN 22
	43
	44	/* Number of elements in the opcode table. */
	45	#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
	46
609f87d4 JG	47	const char * const fpcr_names[] = {
609f87d4 JG	48	"", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
d6b38bfb	49	"fpiar/fpcr", "fpsr/fpcr", "fpiar/fpsr/fpcr"};
dd3b648e	50
8970a55e JG	51	/* Define accessors for 68K's 1, 2, and 4-byte signed quantities.
	52	The _SHIFT values move the quantity to the high order end of an
	53	`int' value, so it will sign-extend. Probably a few more casts
	54	are needed to make it compile without warnings on finicky systems. */
	55	#define BITS_PER_BYTE 8
	56	#define BYTE_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 1))
	57	#define WORD_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 2))
	58	#define LONG_SHIFT (BITS_PER_BYTE * ((sizeof (int)) - 4))
dd3b648e	59
8970a55e	60	#define NEXTBYTE(p) (p += 2, ((int)(p[-1]) << BYTE_SHIFT) >> BYTE_SHIFT)
dd3b648e RP	61
dd3b648e RP	62	#define NEXTWORD(p) \
8970a55e	63	(p += 2, (((int)((p[-2] << 8) + p[-1])) << WORD_SHIFT) >> WORD_SHIFT)
dd3b648e RP	64
dd3b648e RP	65	#define NEXTLONG(p) \
8970a55e JG	66	(p += 4, (((int)((((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])) \
8970a55e JG	67	<< LONG_SHIFT) >> LONG_SHIFT)
dd3b648e	68
8970a55e	69	/* Ecch -- assumes host == target float formats. FIXME. */
dd3b648e RP	70	#define NEXTSINGLE(p) \
	71	(p += 4, ((float )(p - 4)))
	72
	73	#define NEXTDOUBLE(p) \
	74	(p += 8, ((double )(p - 8)))
dd3b648e RP	75	\f
	76	/* Print the m68k instruction at address MEMADDR in debugged memory,
	77	on STREAM. Returns length of the instruction, in bytes. */
	78
	79	int
	80	print_insn (memaddr, stream)
	81	CORE_ADDR memaddr;
	82	FILE *stream;
	83	{
	84	unsigned char buffer[MAXLEN];
	85	register int i;
	86	register unsigned char *p;
	87	register char *d;
	88	register int bestmask;
	89	int best;
	90
1ab3bf1b	91	read_memory (memaddr, (char *) buffer, MAXLEN);
dd3b648e RP	92
	93	bestmask = 0;
	94	best = -1;
	95	for (i = 0; i < NOPCODES; i++)
	96	{
	97	register unsigned int opcode = m68k_opcodes[i].opcode;
	98	register unsigned int match = m68k_opcodes[i].match;
	99	if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
	100	&& ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
	101	&& ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
	102	&& ((0xff & buffer[3] & match) == (0xff & opcode)))
	103	{
	104	/* Don't use for printout the variants of divul and divsl
	105	that have the same register number in two places.
	106	The more general variants will match instead. */
	107	for (d = m68k_opcodes[i].args; *d; d += 2)
	108	if (d[1] == 'D')
	109	break;
	110
	111	/* Don't use for printout the variants of most floating
	112	point coprocessor instructions which use the same
	113	register number in two places, as above. */
	114	if (*d == 0)
	115	for (d = m68k_opcodes[i].args; *d; d += 2)
	116	if (d[1] == 't')
	117	break;
	118
	119	if (*d == 0 && match > bestmask)
	120	{
	121	best = i;
	122	bestmask = match;
	123	}
	124	}
	125	}
	126
	127	/* Handle undefined instructions. */
	128	if (best < 0)
	129	{
	130	fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]);
	131	return 2;
	132	}
	133
	134	fprintf_filtered (stream, "%s", m68k_opcodes[best].name);
	135
	136	/* Point at first word of argument data,
	137	and at descriptor for first argument. */
	138	p = buffer + 2;
	139
	140	/* Why do this this way? -MelloN */
	141	for (d = m68k_opcodes[best].args; *d; d += 2)
	142	{
	143	if (d[0] == '#')
	144	{
	145	if (d[1] == 'l' && p - buffer < 6)
	146	p = buffer + 6;
	147	else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
	148	p = buffer + 4;
	149	}
	150	if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
	151	p = buffer + 4;
	152	if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
	153	p = buffer + 6;
	154	if ((d[0] == 'L' \|\| d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
	155	p = buffer + 4;
156	}
157
158	d = m68k_opcodes[best].args;
159
160	if (*d)
161	fputs_filtered (" ", stream);
162
163	while (*d)
164	{
165	p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream);
166	d += 2;
167	if (d && (d - 2) != 'I' && *d != 'k')
168	fputs_filtered (",", stream);
169	}
170	return p - buffer;
171	}
172
173	static unsigned char *
174	print_insn_arg (d, buffer, p, addr, stream)
175	char *d;
176	unsigned char *buffer;
177	register unsigned char *p;
178	CORE_ADDR addr; /* PC for this arg to be relative to */
179	FILE *stream;
180	{
181	register int val;
182	register int place = d[1];
183	int regno;
2304d9a5	184	register const char *regname;
dd3b648e	185	register unsigned char *p1;
8970a55e	186	double flval;
dd3b648e RP	187	int flt_p;
	188
	189	switch (*d)
	190	{
	191	case 'C':
	192	fprintf_filtered (stream, "ccr");
	193	break;
	194
	195	case 'S':
	196	fprintf_filtered (stream, "sr");
	197	break;
	198
	199	case 'U':
	200	fprintf_filtered (stream, "usp");
	201	break;
	202
	203	case 'J':
	204	{
	205	static struct { char *name; int value; } names[]
	206	= {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
	207	{"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
	208	{"msp", 0x803}, {"isp", 0x804}};
	209
	210	val = fetch_arg (buffer, place, 12);
	211	for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
	212	if (names[regno].value == val)
	213	{
	214	fprintf_filtered (stream, names[regno].name);
	215	break;
	216	}
	217	if (regno < 0)
	218	fprintf_filtered (stream, "%d", val);
	219	}
	220	break;
	221
	222	case 'Q':
	223	val = fetch_arg (buffer, place, 3);
	224	/* 0 means 8, except for the bkpt instruction... */
	225	if (val == 0 && d[1] != 's')
	226	val = 8;
	227	fprintf_filtered (stream, "#%d", val);
	228	break;
	229
	230	case 'M':
	231	val = fetch_arg (buffer, place, 8);
	232	if (val & 0x80)
	233	val = val - 0x100;
	234	fprintf_filtered (stream, "#%d", val);
	235	break;
	236
	237	case 'T':
	238	val = fetch_arg (buffer, place, 4);
	239	fprintf_filtered (stream, "#%d", val);
	240	break;
	241
	242	case 'D':
	243	fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
	244	break;
	245
	246	case 'A':
	247	fprintf_filtered (stream, "%s",
	248	reg_names[fetch_arg (buffer, place, 3) + 010]);
	249	break;
	250
251	case 'R':
252	fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
253	break;
254
664cf438 ILT	255	case 'r':
	256	fprintf_filtered (stream, "%s@", reg_names[fetch_arg (buffer, place, 4)]);
	257	break;
	258
dd3b648e RP	259	case 'F':
	260	fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3));
	261	break;
	262
	263	case 'O':
	264	val = fetch_arg (buffer, place, 6);
	265	if (val & 0x20)
	266	fprintf_filtered (stream, "%s", reg_names [val & 7]);
	267	else
	268	fprintf_filtered (stream, "%d", val);
	269	break;
	270
	271	case '+':
	272	fprintf_filtered (stream, "%s@+",
	273	reg_names[fetch_arg (buffer, place, 3) + 8]);
	274	break;
	275
	276	case '-':
	277	fprintf_filtered (stream, "%s@-",
	278	reg_names[fetch_arg (buffer, place, 3) + 8]);
	279	break;
	280
	281	case 'k':
	282	if (place == 'k')
	283	fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
	284	else if (place == 'C')
	285	{
	286	val = fetch_arg (buffer, place, 7);
	287	if ( val > 63 ) /* This is a signed constant. */
	288	val -= 128;
	289	fprintf_filtered (stream, "{#%d}", val);
	290	}
	291	else
	292	error ("Invalid arg format in opcode table: \"%c%c\".",
	293	*d, place);
	294	break;
	295
	296	case '#':
	297	case '^':
	298	p1 = buffer + (*d == '#' ? 2 : 4);
	299	if (place == 's')
	300	val = fetch_arg (buffer, place, 4);
	301	else if (place == 'C')
	302	val = fetch_arg (buffer, place, 7);
	303	else if (place == '8')
	304	val = fetch_arg (buffer, place, 3);
	305	else if (place == '3')
	306	val = fetch_arg (buffer, place, 8);
	307	else if (place == 'b')
	308	val = NEXTBYTE (p1);
	309	else if (place == 'w')
	310	val = NEXTWORD (p1);
	311	else if (place == 'l')
	312	val = NEXTLONG (p1);
	313	else
	314	error ("Invalid arg format in opcode table: \"%c%c\".",
	315	*d, place);
	316	fprintf_filtered (stream, "#%d", val);
	317	break;
	318
	319	case 'B':
	320	if (place == 'b')
	321	val = NEXTBYTE (p);
abefb1f1	322	else if (place == 'B')
8970a55e	323	val = NEXTBYTE (buffer); /* from the opcode word */
abefb1f1	324	else if (place == 'w' \|\| place == 'W')
dd3b648e	325	val = NEXTWORD (p);
abefb1f1	326	else if (place == 'l' \|\| place == 'L')
dd3b648e RP	327	val = NEXTLONG (p);
	328	else if (place == 'g')
	329	{
8970a55e	330	val = NEXTBYTE (buffer);
dd3b648e RP	331	if (val == 0)
	332	val = NEXTWORD (p);
	333	else if (val == -1)
	334	val = NEXTLONG (p);
	335	}
	336	else if (place == 'c')
	337	{
	338	if (buffer[1] & 0x40) /* If bit six is one, long offset */
	339	val = NEXTLONG (p);
	340	else
	341	val = NEXTWORD (p);
	342	}
	343	else
	344	error ("Invalid arg format in opcode table: \"%c%c\".",
	345	*d, place);
	346
	347	print_address (addr + val, stream);
	348	break;
	349
	350	case 'd':
	351	val = NEXTWORD (p);
	352	fprintf_filtered (stream, "%s@(%d)",
	353	reg_names[fetch_arg (buffer, place, 3)], val);
	354	break;
	355
	356	case 's':
	357	fprintf_filtered (stream, "%s",
	358	fpcr_names[fetch_arg (buffer, place, 3)]);
	359	break;
	360
	361	case 'I':
	362	val = fetch_arg (buffer, 'd', 3); /* Get coprocessor ID... */
	363	if (val != 1) /* Unusual coprocessor ID? */
	364	fprintf_filtered (stream, "(cpid=%d) ", val);
	365	if (place == 'i')
	366	p += 2; /* Skip coprocessor extended operands */
	367	break;
	368
	369	case '*':
	370	case '~':
	371	case '%':
	372	case ';':
	373	case '@':
	374	case '!':
	375	case '$':
	376	case '?':
	377	case '/':
	378	case '&':
	379
	380	if (place == 'd')
	381	{
	382	val = fetch_arg (buffer, 'x', 6);
	383	val = ((val & 7) << 3) + ((val >> 3) & 7);
	384	}
	385	else
	386	val = fetch_arg (buffer, 's', 6);
	387
	388	/* Get register number assuming address register. */
	389	regno = (val & 7) + 8;
	390	regname = reg_names[regno];
	391	switch (val >> 3)
	392	{
	393	case 0:
	394	fprintf_filtered (stream, "%s", reg_names[val]);
395	break;
396
397	case 1:
398	fprintf_filtered (stream, "%s", regname);
399	break;
400
401	case 2:
402	fprintf_filtered (stream, "%s@", regname);
403	break;
404
405	case 3:
406	fprintf_filtered (stream, "%s@+", regname);
407	break;
408
409	case 4:
410	fprintf_filtered (stream, "%s@-", regname);
411	break;
412
413	case 5:
414	val = NEXTWORD (p);
415	fprintf_filtered (stream, "%s@(%d)", regname, val);
416	break;
417
418	case 6:
419	p = print_indexed (regno, p, addr, stream);
420	break;
421
422	case 7:
423	switch (val & 7)
424	{
425	case 0:
426	val = NEXTWORD (p);
427	fprintf_filtered (stream, "@#");
428	print_address (val, stream);
429	break;
430
431	case 1:
432	val = NEXTLONG (p);
433	fprintf_filtered (stream, "@#");
434	print_address (val, stream);
435	break;
436
437	case 2:
438	val = NEXTWORD (p);
439	print_address (addr + val, stream);
440	break;
441
442	case 3:
443	p = print_indexed (-1, p, addr, stream);
444	break;
445
446	case 4:
447	flt_p = 1; /* Assume it's a float... */
448	switch( place )
449	{
450	case 'b':
451	val = NEXTBYTE (p);
452	flt_p = 0;
453	break;
454
455	case 'w':
456	val = NEXTWORD (p);
457	flt_p = 0;
458	break;
459
460	case 'l':
461	val = NEXTLONG (p);
462	flt_p = 0;
463	break;
464
465	case 'f':
466	flval = NEXTSINGLE(p);
467	break;
468
469	case 'F':
470	flval = NEXTDOUBLE(p);
471	break;
472
67c9f54c	473	#ifdef HAVE_68881
dd3b648e	474	case 'x':
48079d66	475	ieee_extended_to_double (&ext_format_68881, p, &flval);
8970a55e	476	p += 12;
dd3b648e	477	break;
67c9f54c	478	#endif
dd3b648e RP	479
dd3b648e RP	480	case 'p':
8970a55e JG	481	p += 12;
8970a55e JG	482	flval = 0; /* FIXME, handle packed decimal someday. */
dd3b648e RP	483	break;
	484
	485	default:
	486	error ("Invalid arg format in opcode table: \"%c%c\".",
	487	*d, place);
	488	}
	489	if ( flt_p ) /* Print a float? */
	490	fprintf_filtered (stream, "#%g", flval);
	491	else
	492	fprintf_filtered (stream, "#%d", val);
	493	break;
	494
	495	default:
	496	fprintf_filtered (stream, "<invalid address mode 0%o>", val);
	497	}
	498	}
	499	break;
	500
	501	case 'L':
	502	case 'l':
	503	if (place == 'w')
	504	{
	505	char doneany;
	506	p1 = buffer + 2;
	507	val = NEXTWORD (p1);
	508	/* Move the pointer ahead if this point is farther ahead
	509	than the last. */
	510	p = p1 > p ? p1 : p;
	511	if (val == 0)
	512	{
	513	fputs_filtered ("#0", stream);
	514	break;
	515	}
	516	if (*d == 'l')
	517	{
	518	register int newval = 0;
	519	for (regno = 0; regno < 16; ++regno)
	520	if (val & (0x8000 >> regno))
	521	newval \|= 1 << regno;
	522	val = newval;
	523	}
	524	val &= 0xffff;
	525	doneany = 0;
	526	for (regno = 0; regno < 16; ++regno)
	527	if (val & (1 << regno))
	528	{
	529	int first_regno;
	530	if (doneany)
	531	fputs_filtered ("/", stream);
	532	doneany = 1;
	533	fprintf_filtered (stream, "%s", reg_names[regno]);
	534	first_regno = regno;
	535	while (val & (1 << (regno + 1)))
	536	++regno;
	537	if (regno > first_regno)
	538	fprintf_filtered (stream, "-%s", reg_names[regno]);
	539	}
	540	}
	541	else if (place == '3')
	542	{
	543	/* `fmovem' insn. */
	544	char doneany;
	545	val = fetch_arg (buffer, place, 8);
	546	if (val == 0)
547	{
548	fputs_filtered ("#0", stream);
549	break;
550	}
551	if (*d == 'l')
552	{
553	register int newval = 0;
554	for (regno = 0; regno < 8; ++regno)
555	if (val & (0x80 >> regno))
556	newval \|= 1 << regno;
557	val = newval;
558	}
559	val &= 0xff;
560	doneany = 0;
561	for (regno = 0; regno < 8; ++regno)
562	if (val & (1 << regno))
563	{
564	int first_regno;
565	if (doneany)
566	fputs_filtered ("/", stream);
567	doneany = 1;
568	fprintf_filtered (stream, "fp%d", regno);
569	first_regno = regno;
570	while (val & (1 << (regno + 1)))
571	++regno;
572	if (regno > first_regno)
573	fprintf_filtered (stream, "-fp%d", regno);
574	}
575	}
576	else
8970a55e	577	goto de_fault;
dd3b648e RP	578	break;
dd3b648e RP	579
8970a55e	580	default: de_fault:
dd3b648e RP	581	error ("Invalid arg format in opcode table: \"%c\".", *d);
	582	}
	583
	584	return (unsigned char *) p;
	585	}
	586
	587	/* Fetch BITS bits from a position in the instruction specified by CODE.
	588	CODE is a "place to put an argument", or 'x' for a destination
	589	that is a general address (mode and register).
	590	BUFFER contains the instruction. */
	591
	592	static int
	593	fetch_arg (buffer, code, bits)
	594	unsigned char *buffer;
1ab3bf1b	595	int code;
dd3b648e RP	596	int bits;
	597	{
	598	register int val;
	599	switch (code)
	600	{
	601	case 's':
	602	val = buffer[1];
	603	break;
	604
	605	case 'd': /* Destination, for register or quick. */
	606	val = (buffer[0] << 8) + buffer[1];
	607	val >>= 9;
	608	break;
	609
	610	case 'x': /* Destination, for general arg */
	611	val = (buffer[0] << 8) + buffer[1];
	612	val >>= 6;
	613	break;
	614
	615	case 'k':
	616	val = (buffer[3] >> 4);
	617	break;
	618
	619	case 'C':
	620	val = buffer[3];
	621	break;
	622
	623	case '1':
	624	val = (buffer[2] << 8) + buffer[3];
	625	val >>= 12;
	626	break;
	627
	628	case '2':
	629	val = (buffer[2] << 8) + buffer[3];
	630	val >>= 6;
	631	break;
	632
	633	case '3':
	634	case 'j':
	635	val = (buffer[2] << 8) + buffer[3];
	636	break;
	637
	638	case '4':
	639	val = (buffer[4] << 8) + buffer[5];
	640	val >>= 12;
	641	break;
	642
	643	case '5':
	644	val = (buffer[4] << 8) + buffer[5];
	645	val >>= 6;
	646	break;
	647
	648	case '6':
	649	val = (buffer[4] << 8) + buffer[5];
	650	break;
	651
	652	case '7':
	653	val = (buffer[2] << 8) + buffer[3];
	654	val >>= 7;
	655	break;
	656
	657	case '8':
	658	val = (buffer[2] << 8) + buffer[3];
	659	val >>= 10;
660	break;
661
662	default:
663	abort ();
664	}
665
666	switch (bits)
667	{
668	case 3:
669	return val & 7;
670	case 4:
671	return val & 017;
672	case 5:
673	return val & 037;
674	case 6:
675	return val & 077;
676	case 7:
677	return val & 0177;
678	case 8:
679	return val & 0377;
680	case 12:
681	return val & 07777;
682	default:
683	abort ();
684	}
685	}
686
687	/* Print an indexed argument. The base register is BASEREG (-1 for pc).
688	P points to extension word, in buffer.
689	ADDR is the nominal core address of that extension word. */
690
691	static unsigned char *
692	print_indexed (basereg, p, addr, stream)
693	int basereg;
694	unsigned char *p;
dd3b648e	695	CORE_ADDR addr;
1ab3bf1b	696	FILE *stream;
dd3b648e RP	697	{
	698	register int word;
	699	static char scales[] = {"", "2", "4", "8"};
	700	register int base_disp;
	701	register int outer_disp;
	702	char buf[40];
	703
	704	word = NEXTWORD (p);
	705
	706	/* Generate the text for the index register.
	707	Where this will be output is not yet determined. */
	708	sprintf (buf, "[%s.%c%s]",
	709	reg_names[(word >> 12) & 0xf],
	710	(word & 0x800) ? 'l' : 'w',
	711	scales[(word >> 9) & 3]);
	712
	713	/* Handle the 68000 style of indexing. */
	714
	715	if ((word & 0x100) == 0)
	716	{
	717	print_base (basereg,
	718	((word & 0x80) ? word \| 0xff00 : word & 0xff)
	719	+ ((basereg == -1) ? addr : 0),
	720	stream);
	721	fputs_filtered (buf, stream);
	722	return p;
	723	}
	724
	725	/* Handle the generalized kind. */
	726	/* First, compute the displacement to add to the base register. */
	727
	728	if (word & 0200)
	729	basereg = -2;
	730	if (word & 0100)
	731	buf[0] = 0;
	732	base_disp = 0;
	733	switch ((word >> 4) & 3)
	734	{
	735	case 2:
	736	base_disp = NEXTWORD (p);
	737	break;
	738	case 3:
	739	base_disp = NEXTLONG (p);
	740	}
	741	if (basereg == -1)
	742	base_disp += addr;
	743
	744	/* Handle single-level case (not indirect) */
	745
	746	if ((word & 7) == 0)
	747	{
	748	print_base (basereg, base_disp, stream);
	749	fputs_filtered (buf, stream);
	750	return p;
	751	}
	752
	753	/* Two level. Compute displacement to add after indirection. */
	754
	755	outer_disp = 0;
	756	switch (word & 3)
	757	{
	758	case 2:
	759	outer_disp = NEXTWORD (p);
	760	break;
761	case 3:
762	outer_disp = NEXTLONG (p);
763	}
764
765	fprintf_filtered (stream, "%d(", outer_disp);
766	print_base (basereg, base_disp, stream);
767
768	/* If postindexed, print the closeparen before the index. */
769	if (word & 4)
770	fprintf_filtered (stream, ")%s", buf);
771	/* If preindexed, print the closeparen after the index. */
772	else
773	fprintf_filtered (stream, "%s)", buf);
774
775	return p;
776	}
777
778	/* Print a base register REGNO and displacement DISP, on STREAM.
779	REGNO = -1 for pc, -2 for none (suppressed). */
780
781	static void
782	print_base (regno, disp, stream)
783	int regno;
784	int disp;
785	FILE *stream;
786	{
787	if (regno == -2)
788	fprintf_filtered (stream, "%d", disp);
789	else if (regno == -1)
790	fprintf_filtered (stream, "0x%x", disp);
791	else
792	fprintf_filtered (stream, "%d(%s)", disp, reg_names[regno]);
793	}