URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [pdp11-dis.c] - Blame information for rev 38

Go to most recent revision | Details | Compare with Previous | View Log


/* Print DEC PDP-11 instructions.
   Copyright 2001, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
 
   This file is part of the GNU opcodes library.
 
   This library 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 3, or (at your option)
   any later version.
 
   It 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;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [binutils-2.18.50/] [opcodes/] [pdp11-dis.c] - Blame information for rev 38

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