[thirdparty/binutils-gdb.git] / opcodes / pdp11-dis.c

/* Print DEC PDP-11 instructions.
   Copyright 2001, 2002, 2004, 2005 Free Software Foundation, Inc.

   This file is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   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., 51 Franklin Street - Fifth Floor, Boston,
   MA 02110-1301, USA.  */

#include "sysdep.h"
#include "dis-asm.h"
#include "opcode/pdp11.h"

#define AFTER_INSTRUCTION	"\t"
#define OPERAND_SEPARATOR	", "

#define JUMP	0x1000	/* Flag that this operand is used in a jump.  */

#define FPRINTF	(*info->fprintf_func)
#define F	info->stream

/* Sign-extend a 16-bit number in an int.  */
#define SIGN_BITS	(8 * sizeof (int) - 16)
#define sign_extend(x) (((x) << SIGN_BITS) >> SIGN_BITS)

static int
read_word (bfd_vma memaddr, int *word, disassemble_info *info)
{
  int status;
  bfd_byte x[2];

  status = (*info->read_memory_func) (memaddr, x, 2, info);
  if (status != 0)
    return -1;

  *word = x[1] << 8 | x[0];
  return 0;
}

static void
print_signed_octal (int n, disassemble_info *info)
{
  if (n < 0)
    FPRINTF (F, "-%o", -n);
  else
    FPRINTF (F, "%o", n);
}

static void
print_reg (int reg, disassemble_info *info)
{
  /* Mask off the addressing mode, if any.  */
  reg &= 7;

  switch (reg)
    {
    case 0: case 1: case 2: case 3: case 4: case 5:
		FPRINTF (F, "r%d", reg); break;
    case 6:	FPRINTF (F, "sp"); break;
    case 7:	FPRINTF (F, "pc"); break;
    default: ;	/* error */
    }
}

static void
print_freg (int freg, disassemble_info *info)
{
  FPRINTF (F, "fr%d", freg);
}

static int
print_operand (bfd_vma *memaddr, int code, disassemble_info *info)
{
  int mode = (code >> 3) & 7;
  int reg = code & 7;
  int disp;

  switch (mode)
    {
    case 0:
      print_reg (reg, info);
      break;
    case 1:
      FPRINTF (F, "(");
      print_reg (reg, info);
      FPRINTF (F, ")");
      break;
    case 2:
      if (reg == 7)
	{
	  int data;

	  if (read_word (*memaddr, &data, info) < 0)
	    return -1;
	  FPRINTF (F, "$");
	  print_signed_octal (sign_extend (data), info);
	  *memaddr += 2;
	}
      else
	{
	  FPRINTF (F, "(");
	  print_reg (reg, info);
	  FPRINTF (F, ")+");
	}
	break;
    case 3:
      if (reg == 7)
	{
	  int address;

	  if (read_word (*memaddr, &address, info) < 0)
	    return -1;
	  FPRINTF (F, "*$%o", address);
	  *memaddr += 2;
	}
      else
	{
	  FPRINTF (F, "*(");
	  print_reg (reg, info);
	  FPRINTF (F, ")+");
	}
	break;
    case 4:
      FPRINTF (F, "-(");
      print_reg (reg, info);
      FPRINTF (F, ")");
      break;
    case 5:
      FPRINTF (F, "*-(");
      print_reg (reg, info);
      FPRINTF (F, ")");
      break;
    case 6:
    case 7:
      if (read_word (*memaddr, &disp, info) < 0)
	return -1;
      *memaddr += 2;
      if (reg == 7)
	{
	  bfd_vma address = *memaddr + sign_extend (disp);

	  if (mode == 7)
	    FPRINTF (F, "*");
	  if (!(code & JUMP))
	    FPRINTF (F, "$");
	  (*info->print_address_func) (address, info);
	}
      else
	{
	  if (mode == 7)
	    FPRINTF (F, "*");
	  print_signed_octal (sign_extend (disp), info);
	  FPRINTF (F, "(");
	  print_reg (reg, info);
	  FPRINTF (F, ")");
	}
      break;
    }

  return 0;
}

static int
print_foperand (bfd_vma *memaddr, int code, disassemble_info *info)
{
  int mode = (code >> 3) & 7;
  int reg = code & 7;

  if (mode == 0)
    print_freg (reg, info);
  else
    return print_operand (memaddr, code, info);

  return 0;
}

/* Print the PDP-11 instruction at address MEMADDR in debugged memory,
   on INFO->STREAM.  Returns length of the instruction, in bytes.  */

int
print_insn_pdp11 (bfd_vma memaddr, disassemble_info *info)
{
  bfd_vma start_memaddr = memaddr;
  int opcode;
  int src, dst;
  int i;

  info->bytes_per_line = 6;
  info->bytes_per_chunk = 2;
  info->display_endian = BFD_ENDIAN_LITTLE;

  if (read_word (memaddr, &opcode, info) != 0)
    return -1;
  memaddr += 2;

  src = (opcode >> 6) & 0x3f;
  dst = opcode & 0x3f;

  for (i = 0; i < pdp11_num_opcodes; i++)
    {
#define OP pdp11_opcodes[i]
      if ((opcode & OP.mask) == OP.opcode)
	switch (OP.type)
	  {
	  case PDP11_OPCODE_NO_OPS:
	    FPRINTF (F, OP.name);
	    goto done;
	  case PDP11_OPCODE_REG:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    print_reg (dst, info);
	    goto done;
	  case PDP11_OPCODE_OP:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    if (strcmp (OP.name, "jmp") == 0)
	      dst |= JUMP;
	    if (print_operand (&memaddr, dst, info) < 0)
	      return -1;
	    goto done;
	  case PDP11_OPCODE_FOP:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    if (strcmp (OP.name, "jmp") == 0)
	      dst |= JUMP;
	    if (print_foperand (&memaddr, dst, info) < 0)
	      return -1;
	    goto done;
	  case PDP11_OPCODE_REG_OP:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    print_reg (src, info);
	    FPRINTF (F, OPERAND_SEPARATOR);
	    if (strcmp (OP.name, "jsr") == 0)
	      dst |= JUMP;
	    if (print_operand (&memaddr, dst, info) < 0)
	      return -1;
	    goto done;
	  case PDP11_OPCODE_REG_OP_REV:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    if (print_operand (&memaddr, dst, info) < 0)
	      return -1;
	    FPRINTF (F, OPERAND_SEPARATOR);
	    print_reg (src, info);
	    goto done;
	  case PDP11_OPCODE_AC_FOP:
	    {
	      int ac = (opcode & 0xe0) >> 6;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      print_freg (ac, info);
	      FPRINTF (F, OPERAND_SEPARATOR);
	      if (print_foperand (&memaddr, dst, info) < 0)
		return -1;
	      goto done;
	    }
	  case PDP11_OPCODE_FOP_AC:
	    {
	      int ac = (opcode & 0xe0) >> 6;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      if (print_foperand (&memaddr, dst, info) < 0)
		return -1;
	      FPRINTF (F, OPERAND_SEPARATOR);
	      print_freg (ac, info);
	      goto done;
	    }
	  case PDP11_OPCODE_AC_OP:
	    {
	      int ac = (opcode & 0xe0) >> 6;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      print_freg (ac, info);
	      FPRINTF (F, OPERAND_SEPARATOR);
	      if (print_operand (&memaddr, dst, info) < 0)
		return -1;
	      goto done;
	    }
	  case PDP11_OPCODE_OP_AC:
	    {
	      int ac = (opcode & 0xe0) >> 6;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      if (print_operand (&memaddr, dst, info) < 0)
		return -1;
	      FPRINTF (F, OPERAND_SEPARATOR);
	      print_freg (ac, info);
	      goto done;
	    }
	  case PDP11_OPCODE_OP_OP:
	    FPRINTF (F, OP.name);
	    FPRINTF (F, AFTER_INSTRUCTION);
	    if (print_operand (&memaddr, src, info) < 0)
	      return -1;
	    FPRINTF (F, OPERAND_SEPARATOR);
	    if (print_operand (&memaddr, dst, info) < 0)
	      return -1;
	    goto done;
	  case PDP11_OPCODE_DISPL:
	    {
	      int displ = (opcode & 0xff) << 8;
	      bfd_vma address = memaddr + (sign_extend (displ) >> 7);
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      (*info->print_address_func) (address, info);
	      goto done;
	    }
	  case PDP11_OPCODE_REG_DISPL:
	    {
	      int displ = (opcode & 0x3f) << 10;
	      bfd_vma address = memaddr - (displ >> 9);

	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      print_reg (src, info);
	      FPRINTF (F, OPERAND_SEPARATOR);
	      (*info->print_address_func) (address, info);
	      goto done;
	    }
	  case PDP11_OPCODE_IMM8:
	    {
	      int code = opcode & 0xff;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      FPRINTF (F, "%o", code);
	      goto done;
	    }
	  case PDP11_OPCODE_IMM6:
	    {
	      int code = opcode & 0x3f;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      FPRINTF (F, "%o", code);
	      goto done;
	    }
	  case PDP11_OPCODE_IMM3:
	    {
	      int code = opcode & 7;
	      FPRINTF (F, OP.name);
	      FPRINTF (F, AFTER_INSTRUCTION);
	      FPRINTF (F, "%o", code);
	      goto done;
	    }
	  case PDP11_OPCODE_ILLEGAL:
	    {
	      FPRINTF (F, ".word");
	      FPRINTF (F, AFTER_INSTRUCTION);
	      FPRINTF (F, "%o", opcode);
	      goto done;
	    }
	  default:
	    /* TODO: is this a proper way of signalling an error? */
	    FPRINTF (F, "<internal error: unrecognized instruction type>");
	    return -1;
	  }
#undef OP
    }
 done:

  return memaddr - start_memaddr;
}
Commit	Line	Data
e135f41b	1	/* Print DEC PDP-11 instructions.
47b0e7ad	2	Copyright 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
e135f41b	3
47b0e7ad NC	4	This file is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
	6	the Free Software Foundation; either version 2 of the License, or
	7	(at your option) any later version.
e135f41b	8
47b0e7ad NC	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
e135f41b	13
47b0e7ad NC	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
	17	MA 02110-1301, USA. */
e135f41b	18
fc05c67f	19	#include "sysdep.h"
e135f41b NC	20	#include "dis-asm.h"
	21	#include "opcode/pdp11.h"
	22
	23	#define AFTER_INSTRUCTION "\t"
	24	#define OPERAND_SEPARATOR ", "
	25
47b0e7ad	26	#define JUMP 0x1000 /* Flag that this operand is used in a jump. */
e135f41b NC	27
	28	#define FPRINTF (*info->fprintf_func)
	29	#define F info->stream
	30
47b0e7ad	31	/* Sign-extend a 16-bit number in an int. */
e135f41b NC	32	#define SIGN_BITS (8 * sizeof (int) - 16)
	33	#define sign_extend(x) (((x) << SIGN_BITS) >> SIGN_BITS)
	34
e135f41b	35	static int
47b0e7ad	36	read_word (bfd_vma memaddr, int word, disassemble_info info)
e135f41b NC	37	{
	38	int status;
	39	bfd_byte x[2];
	40
	41	status = (*info->read_memory_func) (memaddr, x, 2, info);
	42	if (status != 0)
	43	return -1;
	44
	45	*word = x[1] << 8 \| x[0];
	46	return 0;
	47	}
	48
	49	static void
47b0e7ad	50	print_signed_octal (int n, disassemble_info *info)
e135f41b NC	51	{
	52	if (n < 0)
	53	FPRINTF (F, "-%o", -n);
	54	else
	55	FPRINTF (F, "%o", n);
	56	}
	57
	58	static void
47b0e7ad	59	print_reg (int reg, disassemble_info *info)
e135f41b	60	{
47b0e7ad	61	/* Mask off the addressing mode, if any. */
e135f41b NC	62	reg &= 7;
	63
	64	switch (reg)
	65	{
	66	case 0: case 1: case 2: case 3: case 4: case 5:
	67	FPRINTF (F, "r%d", reg); break;
	68	case 6: FPRINTF (F, "sp"); break;
	69	case 7: FPRINTF (F, "pc"); break;
6a51a8a8	70	default: ; /* error */
e135f41b NC	71	}
	72	}
	73
	74	static void
47b0e7ad	75	print_freg (int freg, disassemble_info *info)
e135f41b NC	76	{
	77	FPRINTF (F, "fr%d", freg);
	78	}
	79
	80	static int
47b0e7ad	81	print_operand (bfd_vma memaddr, int code, disassemble_info info)
e135f41b NC	82	{
	83	int mode = (code >> 3) & 7;
	84	int reg = code & 7;
	85	int disp;
	86
	87	switch (mode)
	88	{
	89	case 0:
	90	print_reg (reg, info);
	91	break;
	92	case 1:
	93	FPRINTF (F, "(");
	94	print_reg (reg, info);
	95	FPRINTF (F, ")");
	96	break;
	97	case 2:
	98	if (reg == 7)
	99	{
	100	int data;
47b0e7ad	101
e135f41b NC	102	if (read_word (*memaddr, &data, info) < 0)
	103	return -1;
	104	FPRINTF (F, "$");
	105	print_signed_octal (sign_extend (data), info);
	106	*memaddr += 2;
	107	}
	108	else
	109	{
	110	FPRINTF (F, "(");
	111	print_reg (reg, info);
	112	FPRINTF (F, ")+");
	113	}
	114	break;
	115	case 3:
	116	if (reg == 7)
	117	{
	118	int address;
47b0e7ad	119
e135f41b NC	120	if (read_word (*memaddr, &address, info) < 0)
	121	return -1;
	122	FPRINTF (F, "*$%o", address);
	123	*memaddr += 2;
	124	}
	125	else
	126	{
	127	FPRINTF (F, "*(");
	128	print_reg (reg, info);
	129	FPRINTF (F, ")+");
	130	}
	131	break;
	132	case 4:
	133	FPRINTF (F, "-(");
	134	print_reg (reg, info);
	135	FPRINTF (F, ")");
	136	break;
	137	case 5:
	138	FPRINTF (F, "*-(");
	139	print_reg (reg, info);
	140	FPRINTF (F, ")");
	141	break;
	142	case 6:
	143	case 7:
	144	if (read_word (*memaddr, &disp, info) < 0)
	145	return -1;
	146	*memaddr += 2;
	147	if (reg == 7)
	148	{
	149	bfd_vma address = *memaddr + sign_extend (disp);
47b0e7ad	150
84dd1cff AM	151	if (mode == 7)
84dd1cff AM	152	FPRINTF (F, "*");
e135f41b	153	if (!(code & JUMP))
84dd1cff	154	FPRINTF (F, "$");
e135f41b NC	155	(*info->print_address_func) (address, info);
	156	}
	157	else
	158	{
	159	if (mode == 7)
	160	FPRINTF (F, "*");
	161	print_signed_octal (sign_extend (disp), info);
	162	FPRINTF (F, "(");
	163	print_reg (reg, info);
	164	FPRINTF (F, ")");
	165	}
	166	break;
	167	}
	168
	169	return 0;
	170	}
	171
84dd1cff	172	static int
47b0e7ad	173	print_foperand (bfd_vma memaddr, int code, disassemble_info info)
84dd1cff AM	174	{
	175	int mode = (code >> 3) & 7;
	176	int reg = code & 7;
	177
	178	if (mode == 0)
	179	print_freg (reg, info);
	180	else
	181	return print_operand (memaddr, code, info);
	182
	183	return 0;
	184	}
	185
e135f41b NC	186	/* Print the PDP-11 instruction at address MEMADDR in debugged memory,
	187	on INFO->STREAM. Returns length of the instruction, in bytes. */
	188
	189	int
47b0e7ad	190	print_insn_pdp11 (bfd_vma memaddr, disassemble_info *info)
e135f41b NC	191	{
	192	bfd_vma start_memaddr = memaddr;
	193	int opcode;
	194	int src, dst;
	195	int i;
	196
	197	info->bytes_per_line = 6;
	198	info->bytes_per_chunk = 2;
	199	info->display_endian = BFD_ENDIAN_LITTLE;
	200
	201	if (read_word (memaddr, &opcode, info) != 0)
	202	return -1;
	203	memaddr += 2;
	204
	205	src = (opcode >> 6) & 0x3f;
	206	dst = opcode & 0x3f;
	207
	208	for (i = 0; i < pdp11_num_opcodes; i++)
	209	{
	210	#define OP pdp11_opcodes[i]
	211	if ((opcode & OP.mask) == OP.opcode)
	212	switch (OP.type)
	213	{
	214	case PDP11_OPCODE_NO_OPS:
	215	FPRINTF (F, OP.name);
c6843df5	216	goto done;
e135f41b NC	217	case PDP11_OPCODE_REG:
	218	FPRINTF (F, OP.name);
	219	FPRINTF (F, AFTER_INSTRUCTION);
	220	print_reg (dst, info);
c6843df5	221	goto done;
e135f41b NC	222	case PDP11_OPCODE_OP:
	223	FPRINTF (F, OP.name);
	224	FPRINTF (F, AFTER_INSTRUCTION);
	225	if (strcmp (OP.name, "jmp") == 0)
	226	dst \|= JUMP;
	227	if (print_operand (&memaddr, dst, info) < 0)
	228	return -1;
c6843df5	229	goto done;
84dd1cff AM	230	case PDP11_OPCODE_FOP:
	231	FPRINTF (F, OP.name);
	232	FPRINTF (F, AFTER_INSTRUCTION);
	233	if (strcmp (OP.name, "jmp") == 0)
	234	dst \|= JUMP;
	235	if (print_foperand (&memaddr, dst, info) < 0)
	236	return -1;
	237	goto done;
e135f41b NC	238	case PDP11_OPCODE_REG_OP:
	239	FPRINTF (F, OP.name);
	240	FPRINTF (F, AFTER_INSTRUCTION);
	241	print_reg (src, info);
	242	FPRINTF (F, OPERAND_SEPARATOR);
	243	if (strcmp (OP.name, "jsr") == 0)
	244	dst \|= JUMP;
	245	if (print_operand (&memaddr, dst, info) < 0)
	246	return -1;
c6843df5	247	goto done;
e135f41b NC	248	case PDP11_OPCODE_REG_OP_REV:
	249	FPRINTF (F, OP.name);
	250	FPRINTF (F, AFTER_INSTRUCTION);
	251	if (print_operand (&memaddr, dst, info) < 0)
	252	return -1;
	253	FPRINTF (F, OPERAND_SEPARATOR);
	254	print_reg (src, info);
c6843df5	255	goto done;
84dd1cff AM	256	case PDP11_OPCODE_AC_FOP:
	257	{
	258	int ac = (opcode & 0xe0) >> 6;
	259	FPRINTF (F, OP.name);
	260	FPRINTF (F, AFTER_INSTRUCTION);
	261	print_freg (ac, info);
	262	FPRINTF (F, OPERAND_SEPARATOR);
	263	if (print_foperand (&memaddr, dst, info) < 0)
	264	return -1;
	265	goto done;
	266	}
	267	case PDP11_OPCODE_FOP_AC:
	268	{
	269	int ac = (opcode & 0xe0) >> 6;
	270	FPRINTF (F, OP.name);
	271	FPRINTF (F, AFTER_INSTRUCTION);
	272	if (print_foperand (&memaddr, dst, info) < 0)
	273	return -1;
	274	FPRINTF (F, OPERAND_SEPARATOR);
	275	print_freg (ac, info);
	276	goto done;
	277	}
e135f41b NC	278	case PDP11_OPCODE_AC_OP:
	279	{
	280	int ac = (opcode & 0xe0) >> 6;
	281	FPRINTF (F, OP.name);
	282	FPRINTF (F, AFTER_INSTRUCTION);
	283	print_freg (ac, info);
	284	FPRINTF (F, OPERAND_SEPARATOR);
	285	if (print_operand (&memaddr, dst, info) < 0)
	286	return -1;
c6843df5	287	goto done;
e135f41b	288	}
84dd1cff AM	289	case PDP11_OPCODE_OP_AC:
	290	{
	291	int ac = (opcode & 0xe0) >> 6;
	292	FPRINTF (F, OP.name);
	293	FPRINTF (F, AFTER_INSTRUCTION);
	294	if (print_operand (&memaddr, dst, info) < 0)
	295	return -1;
	296	FPRINTF (F, OPERAND_SEPARATOR);
	297	print_freg (ac, info);
	298	goto done;
	299	}
e135f41b NC	300	case PDP11_OPCODE_OP_OP:
	301	FPRINTF (F, OP.name);
	302	FPRINTF (F, AFTER_INSTRUCTION);
	303	if (print_operand (&memaddr, src, info) < 0)
	304	return -1;
	305	FPRINTF (F, OPERAND_SEPARATOR);
	306	if (print_operand (&memaddr, dst, info) < 0)
	307	return -1;
c6843df5	308	goto done;
e135f41b NC	309	case PDP11_OPCODE_DISPL:
	310	{
	311	int displ = (opcode & 0xff) << 8;
	312	bfd_vma address = memaddr + (sign_extend (displ) >> 7);
	313	FPRINTF (F, OP.name);
	314	FPRINTF (F, AFTER_INSTRUCTION);
	315	(*info->print_address_func) (address, info);
c6843df5	316	goto done;
e135f41b NC	317	}
	318	case PDP11_OPCODE_REG_DISPL:
	319	{
	320	int displ = (opcode & 0x3f) << 10;
14127cc4 NC	321	bfd_vma address = memaddr - (displ >> 9);
14127cc4 NC	322
e135f41b NC	323	FPRINTF (F, OP.name);
	324	FPRINTF (F, AFTER_INSTRUCTION);
	325	print_reg (src, info);
	326	FPRINTF (F, OPERAND_SEPARATOR);
	327	(*info->print_address_func) (address, info);
c6843df5	328	goto done;
e135f41b NC	329	}
	330	case PDP11_OPCODE_IMM8:
	331	{
	332	int code = opcode & 0xff;
	333	FPRINTF (F, OP.name);
	334	FPRINTF (F, AFTER_INSTRUCTION);
	335	FPRINTF (F, "%o", code);
c6843df5	336	goto done;
e135f41b NC	337	}
	338	case PDP11_OPCODE_IMM6:
	339	{
	340	int code = opcode & 0x3f;
	341	FPRINTF (F, OP.name);
	342	FPRINTF (F, AFTER_INSTRUCTION);
	343	FPRINTF (F, "%o", code);
c6843df5	344	goto done;
e135f41b NC	345	}
	346	case PDP11_OPCODE_IMM3:
	347	{
	348	int code = opcode & 7;
	349	FPRINTF (F, OP.name);
	350	FPRINTF (F, AFTER_INSTRUCTION);
	351	FPRINTF (F, "%o", code);
c6843df5 AM	352	goto done;
	353	}
	354	case PDP11_OPCODE_ILLEGAL:
	355	{
	356	FPRINTF (F, ".word");
	357	FPRINTF (F, AFTER_INSTRUCTION);
	358	FPRINTF (F, "%o", opcode);
	359	goto done;
e135f41b NC	360	}
	361	default:
	362	/* TODO: is this a proper way of signalling an error? */
	363	FPRINTF (F, "<internal error: unrecognized instruction type>");
	364	return -1;
	365	}
	366	#undef OP
	367	}
c6843df5	368	done:
e135f41b NC	369
	370	return memaddr - start_memaddr;
	371	}