1 /* Print DEC PDP-11 instructions.
2    Copyright 2001, 2002, 2004, 2005 Free Software Foundation, Inc.
3 
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.
8 
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.
13 
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.  */
18 
19 #include "sysdep.h"
20 #include "dis-asm.h"
21 #include "opcode/pdp11.h"
22 
23 #define AFTER_INSTRUCTION	"\t"
24 #define OPERAND_SEPARATOR	", "
25 
26 #define JUMP	0x1000	/* Flag that this operand is used in a jump.  */
27 
28 #define FPRINTF	(*info->fprintf_func)
29 #define F	info->stream
30 
31 /* Sign-extend a 16-bit number in an int.  */
32 #define SIGN_BITS	(8 * sizeof (int) - 16)
33 #define sign_extend(x) (((x) << SIGN_BITS) >> SIGN_BITS)
34 
35 static int
36 read_word (bfd_vma memaddr, int *word, disassemble_info *info)
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
50 print_signed_octal (int n, disassemble_info *info)
51 {
52   if (n < 0)
53     FPRINTF (F, "-%o", -n);
54   else
55     FPRINTF (F, "%o", n);
56 }
57 
58 static void
59 print_reg (int reg, disassemble_info *info)
60 {
61   /* Mask off the addressing mode, if any.  */
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;
70     default: ;	/* error */
71     }
72 }
73 
74 static void
75 print_freg (int freg, disassemble_info *info)
76 {
77   FPRINTF (F, "fr%d", freg);
78 }
79 
80 static int
81 print_operand (bfd_vma *memaddr, int code, disassemble_info *info)
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;
101 
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;
119 
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);
150 
151 	  if (mode == 7)
152 	    FPRINTF (F, "*");
153 	  if (!(code & JUMP))
154 	    FPRINTF (F, "$");
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 
172 static int
173 print_foperand (bfd_vma *memaddr, int code, disassemble_info *info)
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 
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
190 print_insn_pdp11 (bfd_vma memaddr, disassemble_info *info)
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);
216 	    goto done;
217 	  case PDP11_OPCODE_REG:
218 	    FPRINTF (F, OP.name);
219 	    FPRINTF (F, AFTER_INSTRUCTION);
220 	    print_reg (dst, info);
221 	    goto done;
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;
229 	    goto done;
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;
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;
247 	    goto done;
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);
255 	    goto done;
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 	    }
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;
287 	      goto done;
288 	    }
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 	    }
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;
308 	    goto done;
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);
316 	      goto done;
317 	    }
318 	  case PDP11_OPCODE_REG_DISPL:
319 	    {
320 	      int displ = (opcode & 0x3f) << 10;
321 	      bfd_vma address = memaddr - (displ >> 9);
322 
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);
328 	      goto done;
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);
336 	      goto done;
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);
344 	      goto done;
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);
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;
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     }
368  done:
369 
370   return memaddr - start_memaddr;
371 }
372