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

/* Print Motorola 68k instructions for GDB, the GNU debugger.
   Copyright 1986, 1987, 1989, 1991, 1992, 1993 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 "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

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 < numopcodes; 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':		/* 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;

    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},
	     {"tc",  0x003}, {"itt0",0x004}, {"itt1", 0x005},
             {"dtt0",0x006}, {"dtt1",0x007},
	     {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
	     {"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--)
	  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 '&':
    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,
					   (char *)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;

    case 'e':
      val = (buffer[1] >> 6);
      break;

    default:
      abort ();
    }

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