[deliverable/binutils-gdb.git] / opcodes / mmix-dis.c

/* mmix-dis.c -- Disassemble MMIX instructions.
   Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
   Written by Hans-Peter Nilsson (hp@bitrange.com)

This file is part of GDB and the GNU binutils.

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

GDB and the GNU binutils are distributed in the hope that they
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 file; see the file COPYING.  If not, write to the Free
Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "opcode/mmix.h"
#include "dis-asm.h"
#include "libiberty.h"
#include "bfd.h"
#include "opintl.h"

#define BAD_CASE(x)				\
 do						\
   {						\
     fprintf (stderr,				\
	      _("Bad case %d (%s) in %s:%d\n"),	\
	      x, #x, __FILE__, __LINE__);	\
     abort ();					\
   }						\
 while (0)

#define FATAL_DEBUG								\
 do										\
   {										\
     fprintf (stderr,								\
	      _("Internal: Non-debugged code (test-case missing): %s:%d"),	\
	      __FILE__, __LINE__);						\
     abort ();									\
   }						\
 while (0)

#define ROUND_MODE(n)					\
 ((n) == 1 ? "ROUND_OFF" : (n) == 2 ? "ROUND_UP" :	\
  (n) == 3 ? "ROUND_DOWN" : (n) == 4 ? "ROUND_NEAR" :	\
  _("(unknown)"))

#define INSN_IMMEDIATE_BIT (IMM_OFFSET_BIT << 24)
#define INSN_BACKWARD_OFFSET_BIT (1 << 24)

struct mmix_dis_info
 {
   const char *reg_name[256];
   const char *spec_reg_name[32];

   /* Waste a little memory so we don't have to allocate each separately.
      We could have an array with static contents for these, but on the
      other hand, we don't have to.  */
   char basic_reg_name[256][sizeof ("$255")];
 };

static bfd_boolean initialize_mmix_dis_info
  PARAMS ((struct disassemble_info *));
static const struct mmix_opcode *get_opcode
  PARAMS ((unsigned long));


/* Initialize a target-specific array in INFO.  */

static bfd_boolean
initialize_mmix_dis_info (info)
     struct disassemble_info *info;
{
  struct mmix_dis_info *minfop = malloc (sizeof (struct mmix_dis_info));
  int i;

  if (minfop == NULL)
    return FALSE;

  memset (minfop, 0, sizeof (*minfop));

  /* Initialize register names from register symbols.  If there's no
     register section, then there are no register symbols.  */
  if ((info->section != NULL && info->section->owner != NULL)
      || (info->symbols != NULL
	  && info->symbols[0] != NULL
	  && bfd_asymbol_bfd (info->symbols[0]) != NULL))
    {
      bfd *abfd = info->section && info->section->owner != NULL
	? info->section->owner
	: bfd_asymbol_bfd (info->symbols[0]);
      asection *reg_section = bfd_get_section_by_name (abfd, "*REG*");

      if (reg_section != NULL)
	{
	  /* The returned symcount *does* include the ending NULL.  */
	  long symsize = bfd_get_symtab_upper_bound (abfd);
	  asymbol **syms = malloc (symsize);
	  long nsyms;
	  long i;

	  if (syms == NULL)
	    { FATAL_DEBUG;
	      free (minfop);
	      return FALSE;
	    }
	  nsyms = bfd_canonicalize_symtab (abfd, syms);

	  /* We use the first name for a register.  If this is MMO, then
	     it's the name with the first sequence number, presumably the
	     first in the source.  */
	  for (i = 0; i < nsyms && syms[i] != NULL; i++)
	    {
	      if (syms[i]->section == reg_section
		  && syms[i]->value < 256
		  && minfop->reg_name[syms[i]->value] == NULL)
		minfop->reg_name[syms[i]->value] = syms[i]->name;
	    }
	}
    }

  /* Fill in the rest with the canonical names.  */
  for (i = 0; i < 256; i++)
    if (minfop->reg_name[i] == NULL)
      {
	sprintf (minfop->basic_reg_name[i], "$%d", i);
	minfop->reg_name[i] = minfop->basic_reg_name[i];
      }

  /* We assume it's actually a one-to-one mapping of number-to-name.  */
  for (i = 0; mmix_spec_regs[i].name != NULL; i++)
    minfop->spec_reg_name[mmix_spec_regs[i].number] = mmix_spec_regs[i].name;

  info->private_data = (PTR) minfop;
  return TRUE;
}

/* A table indexed by the first byte is constructed as we disassemble each
   tetrabyte.  The contents is a pointer into mmix_insns reflecting the
   first found entry with matching match-bits and lose-bits.  Further
   entries are considered one after one until the operand constraints
   match or the match-bits and lose-bits do not match.  Normally a
   "further entry" will just show that there was no other match.  */

static const struct mmix_opcode *
get_opcode (insn)
     unsigned long insn;
{
  static const struct mmix_opcode **opcodes = NULL;
  const struct mmix_opcode *opcodep = mmix_opcodes;
  unsigned int opcode_part = (insn >> 24) & 255;
  if (opcodes == NULL)
    opcodes = xcalloc (256, sizeof (struct mmix_opcode *));

  opcodep = opcodes[opcode_part];
  if (opcodep == NULL
      || (opcodep->match & insn) != opcodep->match
      || (opcodep->lose & insn) != 0)
    {
      /* Search through the table.  */
      for (opcodep = mmix_opcodes; opcodep->name != NULL; opcodep++)
	{
	  /* FIXME: Break out this into an initialization function.  */
	  if ((opcodep->match & (opcode_part << 24)) == opcode_part
	      && (opcodep->lose & (opcode_part << 24)) == 0)
	    opcodes[opcode_part] = opcodep;

	  if ((opcodep->match & insn) == opcodep->match
	      && (opcodep->lose & insn) == 0)
	    break;
	}
    }

  if (opcodep->name == NULL)
    return NULL;

  /* Check constraints.  If they don't match, loop through the next opcode
     entries.  */
  do
    {
      switch (opcodep->operands)
	{
	  /* These have no restraint on what can be in the lower three
	     bytes.  */
	case mmix_operands_regs:
	case mmix_operands_reg_yz:
	case mmix_operands_regs_z_opt:
	case mmix_operands_regs_z:
	case mmix_operands_jmp:
	case mmix_operands_pushgo:
	case mmix_operands_pop:
	case mmix_operands_sync:
	case mmix_operands_x_regs_z:
	case mmix_operands_neg:
	case mmix_operands_pushj:
	case mmix_operands_regaddr:
	case mmix_operands_get:
	case mmix_operands_set:
	case mmix_operands_save:
	case mmix_operands_unsave:
	case mmix_operands_xyz_opt:
	  return opcodep;

	  /* For a ROUND_MODE, the middle byte must be 0..4.  */
	case mmix_operands_roundregs_z:
	case mmix_operands_roundregs:
	  {
	    int midbyte = (insn >> 8) & 255;
	    if (midbyte <= 4)
	      return opcodep;
	  }
	break;

	case mmix_operands_put:
	  /* A "PUT".  If it is "immediate", then no restrictions,
	     otherwise we have to make sure the register number is < 32.  */
	  if ((insn & INSN_IMMEDIATE_BIT)
	      || ((insn >> 16) & 255) < 32)
	    return opcodep;
	  break;

	case mmix_operands_resume:
	  /* Middle bytes must be zero.  */
	  if ((insn & 0x00ffff00) == 0)
	    return opcodep;
	  break;

	default:
	  BAD_CASE (opcodep->operands);
	}

      opcodep++;
    }
  while ((opcodep->match & insn) == opcodep->match
	 && (opcodep->lose & insn) == 0);

  /* If we got here, we had no match.  */
  return NULL;
}

/* The main disassembly function.  */

int
print_insn_mmix (memaddr, info)
     bfd_vma memaddr;
     struct disassemble_info *info;
{
  unsigned char buffer[4];
  unsigned long insn;
  unsigned int x, y, z;
  const struct mmix_opcode *opcodep;
  int status = (*info->read_memory_func) (memaddr, buffer, 4, info);
  struct mmix_dis_info *minfop;

  if (status != 0)
    {
      (*info->memory_error_func) (status, memaddr, info);
      return -1;
    }

  /* FIXME: Is -1 suitable?  */
  if (info->private_data == NULL
      && ! initialize_mmix_dis_info (info))
    return -1;

  minfop = (struct mmix_dis_info *) info->private_data;
  x = buffer[1];
  y = buffer[2];
  z = buffer[3];

  insn = bfd_getb32 (buffer);

  opcodep = get_opcode (insn);

  if (opcodep == NULL)
    {
      (*info->fprintf_func) (info->stream, _("*unknown*"));
      return 4;
    }

  (*info->fprintf_func) (info->stream, "%s ", opcodep->name);

  /* Present bytes in the order they are laid out in memory.  */
  info->display_endian = BFD_ENDIAN_BIG;

  info->insn_info_valid = 1;
  info->bytes_per_chunk = 4;
  info->branch_delay_insns = 0;
  info->target = 0;
  switch (opcodep->type)
    {
    case mmix_type_normal:
    case mmix_type_memaccess_block:
      info->insn_type = dis_nonbranch;
      break;

    case mmix_type_branch:
      info->insn_type = dis_branch;
      break;

    case mmix_type_condbranch:
      info->insn_type = dis_condbranch;
      break;

    case mmix_type_memaccess_octa:
      info->insn_type = dis_dref;
      info->data_size = 8;
      break;

    case mmix_type_memaccess_tetra:
      info->insn_type = dis_dref;
      info->data_size = 4;
      break;

    case mmix_type_memaccess_wyde:
      info->insn_type = dis_dref;
      info->data_size = 2;
      break;

    case mmix_type_memaccess_byte:
      info->insn_type = dis_dref;
      info->data_size = 1;
      break;

    case mmix_type_jsr:
      info->insn_type = dis_jsr;
      break;

    default:
      BAD_CASE(opcodep->type);
    }

  switch (opcodep->operands)
    {
    case mmix_operands_regs:
      /*  All registers: "$X,$Y,$Z".  */
      (*info->fprintf_func) (info->stream, "%s,%s,%s",
			     minfop->reg_name[x],
			     minfop->reg_name[y],
			     minfop->reg_name[z]);
      break;

    case mmix_operands_reg_yz:
      /* Like SETH - "$X,YZ".  */
      (*info->fprintf_func) (info->stream, "%s,0x%x",
			     minfop->reg_name[x], y * 256 + z);
      break;

    case mmix_operands_regs_z_opt:
    case mmix_operands_regs_z:
    case mmix_operands_pushgo:
      /* The regular "$X,$Y,$Z|Z".  */
      if (insn & INSN_IMMEDIATE_BIT)
	(*info->fprintf_func) (info->stream, "%s,%s,%d",
			       minfop->reg_name[x], minfop->reg_name[y], z);
      else
	(*info->fprintf_func) (info->stream, "%s,%s,%s",
			       minfop->reg_name[x],
			       minfop->reg_name[y],
			       minfop->reg_name[z]);
      break;

    case mmix_operands_jmp:
      /* Address; only JMP.  */
      {
	bfd_signed_vma offset = (x * 65536 + y * 256 + z) * 4;

	if (insn & INSN_BACKWARD_OFFSET_BIT)
	  offset -= (256 * 65536) * 4;

	info->target = memaddr + offset;
	(*info->print_address_func) (memaddr + offset, info);
      }
      break;

    case mmix_operands_roundregs_z:
      /* Two registers, like FLOT, possibly with rounding: "$X,$Z|Z"
	 "$X,ROUND_MODE,$Z|Z".  */
      if (y != 0)
	{
	  if (insn & INSN_IMMEDIATE_BIT)
	    (*info->fprintf_func) (info->stream, "%s,%s,%d",
				   minfop->reg_name[x],
				   ROUND_MODE (y), z);
	  else
	    (*info->fprintf_func) (info->stream, "%s,%s,%s",
				   minfop->reg_name[x],
				   ROUND_MODE (y),
				   minfop->reg_name[z]);
	}
      else
	{
	  if (insn & INSN_IMMEDIATE_BIT)
	    (*info->fprintf_func) (info->stream, "%s,%d",
				   minfop->reg_name[x], z);
	  else
	    (*info->fprintf_func) (info->stream, "%s,%s",
				   minfop->reg_name[x],
				   minfop->reg_name[z]);
	}
      break;

    case mmix_operands_pop:
      /* Like POP - "X,YZ".  */
      (*info->fprintf_func) (info->stream, "%d,%d", x, y*256 + z);
      break;

    case mmix_operands_roundregs:
      /* Two registers, possibly with rounding: "$X,$Z" or
	 "$X,ROUND_MODE,$Z".  */
      if (y != 0)
	(*info->fprintf_func) (info->stream, "%s,%s,%s",
			       minfop->reg_name[x],
			       ROUND_MODE (y),
			       minfop->reg_name[z]);
      else
	(*info->fprintf_func) (info->stream, "%s,%s",
			       minfop->reg_name[x],
			       minfop->reg_name[z]);
      break;

    case mmix_operands_sync:
	/* Like SYNC - "XYZ".  */
      (*info->fprintf_func) (info->stream, "%u",
			     x * 65536 + y * 256 + z);
      break;

    case mmix_operands_x_regs_z:
      /* Like SYNCD - "X,$Y,$Z|Z".  */
      if (insn & INSN_IMMEDIATE_BIT)
	(*info->fprintf_func) (info->stream, "%d,%s,%d",
			       x, minfop->reg_name[y], z);
      else
	(*info->fprintf_func) (info->stream, "%d,%s,%s",
			       x, minfop->reg_name[y],
			       minfop->reg_name[z]);
      break;

    case mmix_operands_neg:
      /* Like NEG and NEGU - "$X,Y,$Z|Z".  */
      if (insn & INSN_IMMEDIATE_BIT)
	(*info->fprintf_func) (info->stream, "%s,%d,%d",
			       minfop->reg_name[x], y, z);
      else
	(*info->fprintf_func) (info->stream, "%s,%d,%s",
			       minfop->reg_name[x], y,
			       minfop->reg_name[z]);
      break;

    case mmix_operands_pushj:
    case mmix_operands_regaddr:
      /* Like GETA or branches - "$X,Address".  */
      {
	bfd_signed_vma offset = (y * 256 + z) * 4;

	if (insn & INSN_BACKWARD_OFFSET_BIT)
	  offset -= 65536 * 4;

	info->target = memaddr + offset;

	(*info->fprintf_func) (info->stream, "%s,", minfop->reg_name[x]);
	(*info->print_address_func) (memaddr + offset, info);
      }
      break;

    case mmix_operands_get:
      /* GET - "X,spec_reg".  */
      (*info->fprintf_func) (info->stream, "%s,%s",
			     minfop->reg_name[x],
			     minfop->spec_reg_name[z]);
      break;

    case mmix_operands_put:
      /* PUT - "spec_reg,$Z|Z".  */
      if (insn & INSN_IMMEDIATE_BIT)
	(*info->fprintf_func) (info->stream, "%s,%d",
			       minfop->spec_reg_name[x], z);
      else
	(*info->fprintf_func) (info->stream, "%s,%s",
			       minfop->spec_reg_name[x],
			       minfop->reg_name[z]);
      break;

    case mmix_operands_set:
      /*  Two registers, "$X,$Y".  */
      (*info->fprintf_func) (info->stream, "%s,%s",
			     minfop->reg_name[x],
			     minfop->reg_name[y]);
      break;

    case mmix_operands_save:
      /* SAVE - "$X,0".  */
      (*info->fprintf_func) (info->stream, "%s,0", minfop->reg_name[x]);
      break;

    case mmix_operands_unsave:
      /* UNSAVE - "0,$Z".  */
      (*info->fprintf_func) (info->stream, "0,%s", minfop->reg_name[z]);
      break;

    case mmix_operands_xyz_opt:
      /* Like SWYM or TRAP - "X,Y,Z".  */
      (*info->fprintf_func) (info->stream, "%d,%d,%d", x, y, z);
      break;

    case mmix_operands_resume:
      /* Just "Z", like RESUME.  */
      (*info->fprintf_func) (info->stream, "%d", z);
      break;

    default:
      (*info->fprintf_func) (info->stream, _("*unknown operands type: %d*"),
			     opcodep->operands);
      break;
    }

  return 4;
}
Commit	Line	Data
afd30973	1	/* mmix-dis.c -- Disassemble MMIX instructions.
b34976b6	2	Copyright 2000, 2001, 2002 Free Software Foundation, Inc.
afd30973 HPN	3	Written by Hans-Peter Nilsson (hp@bitrange.com)
	4
	5	This file is part of GDB and the GNU binutils.
	6
	7	GDB and the GNU binutils are free software; you can redistribute
	8	them and/or modify them under the terms of the GNU General Public
	9	License as published by the Free Software Foundation; either version 2,
	10	or (at your option) any later version.
	11
	12	GDB and the GNU binutils are distributed in the hope that they
	13	will be useful, but WITHOUT ANY WARRANTY; without even the implied
	14	warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	15	the GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this file; see the file COPYING. If not, write to the Free
	19	Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	20
	21	#include <stdio.h>
	22	#include <string.h>
	23	#include <stdlib.h>
	24	#include "opcode/mmix.h"
	25	#include "dis-asm.h"
	26	#include "libiberty.h"
	27	#include "bfd.h"
	28	#include "opintl.h"
	29
	30	#define BAD_CASE(x) \
	31	do \
	32	{ \
	33	fprintf (stderr, \
	34	_("Bad case %d (%s) in %s:%d\n"), \
	35	x, #x, __FILE__, __LINE__); \
	36	abort (); \
	37	} \
	38	while (0)
	39
	40	#define FATAL_DEBUG \
	41	do \
	42	{ \
	43	fprintf (stderr, \
	44	_("Internal: Non-debugged code (test-case missing): %s:%d"), \
	45	__FILE__, __LINE__); \
	46	abort (); \
	47	} \
	48	while (0)
	49
	50	#define ROUND_MODE(n) \
	51	((n) == 1 ? "ROUND_OFF" : (n) == 2 ? "ROUND_UP" : \
	52	(n) == 3 ? "ROUND_DOWN" : (n) == 4 ? "ROUND_NEAR" : \
	53	_("(unknown)"))
	54
	55	#define INSN_IMMEDIATE_BIT (IMM_OFFSET_BIT << 24)
	56	#define INSN_BACKWARD_OFFSET_BIT (1 << 24)
	57
	58	struct mmix_dis_info
	59	{
	60	const char *reg_name[256];
	61	const char *spec_reg_name[32];
	62
	63	/* Waste a little memory so we don't have to allocate each separately.
	64	We could have an array with static contents for these, but on the
	65	other hand, we don't have to. */
	66	char basic_reg_name[256][sizeof ("$255")];
67	};
68
b34976b6 AM	69	static bfd_boolean initialize_mmix_dis_info
	70	PARAMS ((struct disassemble_info *));
	71	static const struct mmix_opcode *get_opcode
	72	PARAMS ((unsigned long));
afd30973 HPN	73
	74
	75	/* Initialize a target-specific array in INFO. */
	76
b34976b6	77	static bfd_boolean
afd30973 HPN	78	initialize_mmix_dis_info (info)
	79	struct disassemble_info *info;
	80	{
	81	struct mmix_dis_info *minfop = malloc (sizeof (struct mmix_dis_info));
	82	int i;
	83
	84	if (minfop == NULL)
b34976b6	85	return FALSE;
afd30973 HPN	86
	87	memset (minfop, 0, sizeof (*minfop));
	88
	89	/* Initialize register names from register symbols. If there's no
	90	register section, then there are no register symbols. */
	91	if ((info->section != NULL && info->section->owner != NULL)
	92	\|\| (info->symbols != NULL
	93	&& info->symbols[0] != NULL
	94	&& bfd_asymbol_bfd (info->symbols[0]) != NULL))
	95	{
	96	bfd *abfd = info->section && info->section->owner != NULL
	97	? info->section->owner
	98	: bfd_asymbol_bfd (info->symbols[0]);
	99	asection reg_section = bfd_get_section_by_name (abfd, "REG*");
	100
	101	if (reg_section != NULL)
	102	{
	103	/* The returned symcount does include the ending NULL. */
	104	long symsize = bfd_get_symtab_upper_bound (abfd);
	105	asymbol **syms = malloc (symsize);
	106	long nsyms;
	107	long i;
	108
	109	if (syms == NULL)
	110	{ FATAL_DEBUG;
	111	free (minfop);
b34976b6	112	return FALSE;
afd30973 HPN	113	}
	114	nsyms = bfd_canonicalize_symtab (abfd, syms);
	115
	116	/* We use the first name for a register. If this is MMO, then
	117	it's the name with the first sequence number, presumably the
	118	first in the source. */
	119	for (i = 0; i < nsyms && syms[i] != NULL; i++)
	120	{
	121	if (syms[i]->section == reg_section
	122	&& syms[i]->value < 256
	123	&& minfop->reg_name[syms[i]->value] == NULL)
	124	minfop->reg_name[syms[i]->value] = syms[i]->name;
	125	}
	126	}
	127	}
	128
	129	/* Fill in the rest with the canonical names. */
	130	for (i = 0; i < 256; i++)
	131	if (minfop->reg_name[i] == NULL)
	132	{
	133	sprintf (minfop->basic_reg_name[i], "$%d", i);
	134	minfop->reg_name[i] = minfop->basic_reg_name[i];
	135	}
	136
	137	/* We assume it's actually a one-to-one mapping of number-to-name. */
	138	for (i = 0; mmix_spec_regs[i].name != NULL; i++)
	139	minfop->spec_reg_name[mmix_spec_regs[i].number] = mmix_spec_regs[i].name;
	140
	141	info->private_data = (PTR) minfop;
b34976b6	142	return TRUE;
afd30973 HPN	143	}
	144
	145	/* A table indexed by the first byte is constructed as we disassemble each
	146	tetrabyte. The contents is a pointer into mmix_insns reflecting the
	147	first found entry with matching match-bits and lose-bits. Further
	148	entries are considered one after one until the operand constraints
	149	match or the match-bits and lose-bits do not match. Normally a
	150	"further entry" will just show that there was no other match. */
	151
	152	static const struct mmix_opcode *
	153	get_opcode (insn)
	154	unsigned long insn;
	155	{
	156	static const struct mmix_opcode **opcodes = NULL;
	157	const struct mmix_opcode *opcodep = mmix_opcodes;
	158	unsigned int opcode_part = (insn >> 24) & 255;
	159	if (opcodes == NULL)
	160	opcodes = xcalloc (256, sizeof (struct mmix_opcode *));
	161
	162	opcodep = opcodes[opcode_part];
	163	if (opcodep == NULL
	164	\|\| (opcodep->match & insn) != opcodep->match
	165	\|\| (opcodep->lose & insn) != 0)
	166	{
	167	/* Search through the table. */
	168	for (opcodep = mmix_opcodes; opcodep->name != NULL; opcodep++)
	169	{
	170	/* FIXME: Break out this into an initialization function. */
	171	if ((opcodep->match & (opcode_part << 24)) == opcode_part
	172	&& (opcodep->lose & (opcode_part << 24)) == 0)
	173	opcodes[opcode_part] = opcodep;
	174
	175	if ((opcodep->match & insn) == opcodep->match
	176	&& (opcodep->lose & insn) == 0)
	177	break;
	178	}
	179	}
	180
	181	if (opcodep->name == NULL)
	182	return NULL;
	183
	184	/* Check constraints. If they don't match, loop through the next opcode
	185	entries. */
	186	do
	187	{
	188	switch (opcodep->operands)
	189	{
	190	/* These have no restraint on what can be in the lower three
	191	bytes. */
	192	case mmix_operands_regs:
	193	case mmix_operands_reg_yz:
	194	case mmix_operands_regs_z_opt:
	195	case mmix_operands_regs_z:
	196	case mmix_operands_jmp:
	197	case mmix_operands_pushgo:
	198	case mmix_operands_pop:
	199	case mmix_operands_sync:
	200	case mmix_operands_x_regs_z:
	201	case mmix_operands_neg:
	202	case mmix_operands_pushj:
	203	case mmix_operands_regaddr:
	204	case mmix_operands_get:
	205	case mmix_operands_set:
	206	case mmix_operands_save:
207	case mmix_operands_unsave:
208	case mmix_operands_xyz_opt:
209	return opcodep;
210
211	/* For a ROUND_MODE, the middle byte must be 0..4. */
212	case mmix_operands_roundregs_z:
213	case mmix_operands_roundregs:
214	{
215	int midbyte = (insn >> 8) & 255;
216	if (midbyte <= 4)
217	return opcodep;
218	}
219	break;
220
221	case mmix_operands_put:
222	/* A "PUT". If it is "immediate", then no restrictions,
223	otherwise we have to make sure the register number is < 32. */
224	if ((insn & INSN_IMMEDIATE_BIT)
225	\|\| ((insn >> 16) & 255) < 32)
226	return opcodep;
227	break;
228
229	case mmix_operands_resume:
230	/* Middle bytes must be zero. */
231	if ((insn & 0x00ffff00) == 0)
232	return opcodep;
233	break;
234
235	default:
236	BAD_CASE (opcodep->operands);
237	}
238
239	opcodep++;
240	}
241	while ((opcodep->match & insn) == opcodep->match
242	&& (opcodep->lose & insn) == 0);
243
244	/* If we got here, we had no match. */
245	return NULL;
246	}
247
248	/* The main disassembly function. */
249
250	int
251	print_insn_mmix (memaddr, info)
252	bfd_vma memaddr;
253	struct disassemble_info *info;
254	{
255	unsigned char buffer[4];
256	unsigned long insn;
257	unsigned int x, y, z;
258	const struct mmix_opcode *opcodep;
259	int status = (*info->read_memory_func) (memaddr, buffer, 4, info);
260	struct mmix_dis_info *minfop;
261
262	if (status != 0)
263	{
264	(*info->memory_error_func) (status, memaddr, info);
265	return -1;
266	}
267
268	/* FIXME: Is -1 suitable? */
269	if (info->private_data == NULL
270	&& ! initialize_mmix_dis_info (info))
271	return -1;
272
273	minfop = (struct mmix_dis_info *) info->private_data;
274	x = buffer[1];
275	y = buffer[2];
276	z = buffer[3];
277
278	insn = bfd_getb32 (buffer);
279
280	opcodep = get_opcode (insn);
281
282	if (opcodep == NULL)
283	{
284	(info->fprintf_func) (info->stream, _("unknown*"));
285	return 4;
286	}
287
288	(*info->fprintf_func) (info->stream, "%s ", opcodep->name);
289
290	/* Present bytes in the order they are laid out in memory. */
291	info->display_endian = BFD_ENDIAN_BIG;
292
293	info->insn_info_valid = 1;
294	info->bytes_per_chunk = 4;
295	info->branch_delay_insns = 0;
296	info->target = 0;
297	switch (opcodep->type)
298	{
299	case mmix_type_normal:
300	case mmix_type_memaccess_block:
301	info->insn_type = dis_nonbranch;
302	break;
303
304	case mmix_type_branch:
305	info->insn_type = dis_branch;
306	break;
307
308	case mmix_type_condbranch:
309	info->insn_type = dis_condbranch;
310	break;
311
312	case mmix_type_memaccess_octa:
313	info->insn_type = dis_dref;
314	info->data_size = 8;
315	break;
316
317	case mmix_type_memaccess_tetra:
318	info->insn_type = dis_dref;
319	info->data_size = 4;
320	break;
321
322	case mmix_type_memaccess_wyde:
323	info->insn_type = dis_dref;
324	info->data_size = 2;
325	break;
326
327	case mmix_type_memaccess_byte:
328	info->insn_type = dis_dref;
329	info->data_size = 1;
330	break;
331
332	case mmix_type_jsr:
333	info->insn_type = dis_jsr;
334	break;
335
336	default:
337	BAD_CASE(opcodep->type);
338	}
339
340	switch (opcodep->operands)
341	{
342	case mmix_operands_regs:
343	/* All registers: "$X,$Y,$Z". */
344	(*info->fprintf_func) (info->stream, "%s,%s,%s",
345	minfop->reg_name[x],
346	minfop->reg_name[y],
347	minfop->reg_name[z]);
348	break;
349
350	case mmix_operands_reg_yz:
351	/* Like SETH - "$X,YZ". */
352	(*info->fprintf_func) (info->stream, "%s,0x%x",
353	minfop->reg_name[x], y * 256 + z);
354	break;
355
356	case mmix_operands_regs_z_opt:
357	case mmix_operands_regs_z:
358	case mmix_operands_pushgo:
359	/* The regular "$X,$Y,$Z\|Z". */
360	if (insn & INSN_IMMEDIATE_BIT)
361	(*info->fprintf_func) (info->stream, "%s,%s,%d",
362	minfop->reg_name[x], minfop->reg_name[y], z);
363	else
364	(*info->fprintf_func) (info->stream, "%s,%s,%s",
365	minfop->reg_name[x],
366	minfop->reg_name[y],
367	minfop->reg_name[z]);
368	break;
369
370	case mmix_operands_jmp:
371	/* Address; only JMP. */
372	{
373	bfd_signed_vma offset = (x * 65536 + y * 256 + z) * 4;
374
375	if (insn & INSN_BACKWARD_OFFSET_BIT)
376	offset -= (256 * 65536) * 4;
377
378	info->target = memaddr + offset;
379	(*info->print_address_func) (memaddr + offset, info);
380	}
381	break;
382
383	case mmix_operands_roundregs_z:
384	/* Two registers, like FLOT, possibly with rounding: "$X,$Z\|Z"
385	"$X,ROUND_MODE,$Z\|Z". */
386	if (y != 0)
387	{
388	if (insn & INSN_IMMEDIATE_BIT)
389	(*info->fprintf_func) (info->stream, "%s,%s,%d",
390	minfop->reg_name[x],
391	ROUND_MODE (y), z);
392	else
393	(*info->fprintf_func) (info->stream, "%s,%s,%s",
394	minfop->reg_name[x],
395	ROUND_MODE (y),
396	minfop->reg_name[z]);
397	}
398	else
399	{
400	if (insn & INSN_IMMEDIATE_BIT)
401	(*info->fprintf_func) (info->stream, "%s,%d",
402	minfop->reg_name[x], z);
403	else
404	(*info->fprintf_func) (info->stream, "%s,%s",
405	minfop->reg_name[x],
406	minfop->reg_name[z]);
407	}
408	break;
409
410	case mmix_operands_pop:
411	/* Like POP - "X,YZ". */
412	(info->fprintf_func) (info->stream, "%d,%d", x, y256 + z);
413	break;
414
415	case mmix_operands_roundregs:
416	/* Two registers, possibly with rounding: "$X,$Z" or
417	"$X,ROUND_MODE,$Z". */
418	if (y != 0)
419	(*info->fprintf_func) (info->stream, "%s,%s,%s",
420	minfop->reg_name[x],
421	ROUND_MODE (y),
422	minfop->reg_name[z]);
423	else
424	(*info->fprintf_func) (info->stream, "%s,%s",
425	minfop->reg_name[x],
426	minfop->reg_name[z]);
427	break;
428
429	case mmix_operands_sync:
430	/* Like SYNC - "XYZ". */
431	(*info->fprintf_func) (info->stream, "%u",
432	x * 65536 + y * 256 + z);
433	break;
434
435	case mmix_operands_x_regs_z:
436	/* Like SYNCD - "X,$Y,$Z\|Z". */
437	if (insn & INSN_IMMEDIATE_BIT)
438	(*info->fprintf_func) (info->stream, "%d,%s,%d",
439	x, minfop->reg_name[y], z);
440	else
441	(*info->fprintf_func) (info->stream, "%d,%s,%s",
442	x, minfop->reg_name[y],
443	minfop->reg_name[z]);
444	break;
445
446	case mmix_operands_neg:
447	/* Like NEG and NEGU - "$X,Y,$Z\|Z". */
448	if (insn & INSN_IMMEDIATE_BIT)
449	(*info->fprintf_func) (info->stream, "%s,%d,%d",
450	minfop->reg_name[x], y, z);
451	else
452	(*info->fprintf_func) (info->stream, "%s,%d,%s",
453	minfop->reg_name[x], y,
454	minfop->reg_name[z]);
455	break;
456
457	case mmix_operands_pushj:
458	case mmix_operands_regaddr:
459	/* Like GETA or branches - "$X,Address". */
460	{
461	bfd_signed_vma offset = (y * 256 + z) * 4;
462
463	if (insn & INSN_BACKWARD_OFFSET_BIT)
464	offset -= 65536 * 4;
465
466	info->target = memaddr + offset;
467
468	(*info->fprintf_func) (info->stream, "%s,", minfop->reg_name[x]);
469	(*info->print_address_func) (memaddr + offset, info);
470	}
471	break;
472
473	case mmix_operands_get:
474	/* GET - "X,spec_reg". */
475	(*info->fprintf_func) (info->stream, "%s,%s",
476	minfop->reg_name[x],
477	minfop->spec_reg_name[z]);
478	break;
479
480	case mmix_operands_put:
481	/* PUT - "spec_reg,$Z\|Z". */
482	if (insn & INSN_IMMEDIATE_BIT)
483	(*info->fprintf_func) (info->stream, "%s,%d",
484	minfop->spec_reg_name[x], z);
485	else
486	(*info->fprintf_func) (info->stream, "%s,%s",
487	minfop->spec_reg_name[x],
488	minfop->reg_name[z]);
489	break;
490
491	case mmix_operands_set:
492	/* Two registers, "$X,$Y". */
493	(*info->fprintf_func) (info->stream, "%s,%s",
494	minfop->reg_name[x],
495	minfop->reg_name[y]);
496	break;
497
498	case mmix_operands_save:
499	/* SAVE - "$X,0". */
500	(*info->fprintf_func) (info->stream, "%s,0", minfop->reg_name[x]);
501	break;
502
503	case mmix_operands_unsave:
504	/* UNSAVE - "0,$Z". */
505	(*info->fprintf_func) (info->stream, "0,%s", minfop->reg_name[z]);
506	break;
507
508	case mmix_operands_xyz_opt:
509	/* Like SWYM or TRAP - "X,Y,Z". */
510	(*info->fprintf_func) (info->stream, "%d,%d,%d", x, y, z);
511	break;
512
513	case mmix_operands_resume:
514	/* Just "Z", like RESUME. */
515	(*info->fprintf_func) (info->stream, "%d", z);
516	break;
517
518	default:
519	(info->fprintf_func) (info->stream, _("unknown operands type: %d*"),
520	opcodep->operands);
521	break;
522	}
523
524	return 4;
525	}