Fix compile time warnings
[external/binutils.git] / opcodes / pdp11-dis.c
1 /* Print DEC PDP-11 instructions.
2    Copyright 2001 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
17
18 #include "sysdep.h"
19 #include "dis-asm.h"
20 #include "opcode/pdp11.h"
21
22 #define AFTER_INSTRUCTION       "\t"
23 #define OPERAND_SEPARATOR       ", "
24
25 #define JUMP    0x1000  /* flag that this operand is used in a jump */
26
27 #define FPRINTF (*info->fprintf_func)
28 #define F       info->stream
29
30 /* sign-extend a 16-bit number in an int */
31 #define SIGN_BITS       (8 * sizeof (int) - 16)
32 #define sign_extend(x) (((x) << SIGN_BITS) >> SIGN_BITS)
33
34 static int read_word PARAMS ((bfd_vma memaddr, int *word,
35                               disassemble_info *info));
36 static void print_signed_octal PARAMS ((int n, disassemble_info *info));
37 static void print_reg PARAMS ((int reg, disassemble_info *info));
38 static void print_freg PARAMS ((int freg, disassemble_info *info));
39 static int print_operand PARAMS ((bfd_vma *memaddr, int code,
40                                   disassemble_info *info));
41 int print_insn_pdp11 PARAMS ((bfd_vma memaddr, disassemble_info *info));
42
43 static int
44 read_word (memaddr, word, info)
45      bfd_vma memaddr;
46      int *word;
47      disassemble_info *info;
48 {
49   int status;
50   bfd_byte x[2];
51
52   status = (*info->read_memory_func) (memaddr, x, 2, info);
53   if (status != 0)
54     return -1;
55
56   *word = x[1] << 8 | x[0];
57   return 0;
58 }
59
60 static void
61 print_signed_octal (n, info)
62      int n;
63      disassemble_info *info;
64 {
65   if (n < 0)
66     FPRINTF (F, "-%o", -n);
67   else
68     FPRINTF (F, "%o", n);
69 }
70
71 static void
72 print_reg (reg, info)
73      int reg;
74      disassemble_info *info;
75 {
76   /* mask off the addressing mode, if any */
77   reg &= 7;
78
79   switch (reg)
80     {
81     case 0: case 1: case 2: case 3: case 4: case 5:
82                 FPRINTF (F, "r%d", reg); break;
83     case 6:     FPRINTF (F, "sp"); break;
84     case 7:     FPRINTF (F, "pc"); break;
85     default:    /* error */
86     }
87 }
88
89 static void
90 print_freg (freg, info)
91      int freg;
92      disassemble_info *info;
93 {
94   FPRINTF (F, "fr%d", freg);
95 }
96
97 static int
98 print_operand (memaddr, code, info)
99      bfd_vma *memaddr;
100      int code;
101      disassemble_info *info;
102 {
103   int mode = (code >> 3) & 7;
104   int reg = code & 7;
105   int disp;
106
107   switch (mode)
108     {
109     case 0:
110       print_reg (reg, info);
111       break;
112     case 1:
113       FPRINTF (F, "(");
114       print_reg (reg, info);
115       FPRINTF (F, ")");
116       break;
117     case 2:
118       if (reg == 7)
119         {
120           int data;
121           if (read_word (*memaddr, &data, info) < 0)
122             return -1;
123           FPRINTF (F, "$");
124           print_signed_octal (sign_extend (data), info);
125           *memaddr += 2;
126         }
127       else
128         {
129           FPRINTF (F, "(");
130           print_reg (reg, info);
131           FPRINTF (F, ")+");
132         }
133         break;
134     case 3:
135       if (reg == 7)
136         {
137           int address;
138           if (read_word (*memaddr, &address, info) < 0)
139             return -1;
140           FPRINTF (F, "*$%o", address);
141           *memaddr += 2;
142         }
143       else
144         {
145           FPRINTF (F, "*(");
146           print_reg (reg, info);
147           FPRINTF (F, ")+");
148         }
149         break;
150     case 4:
151       FPRINTF (F, "-(");
152       print_reg (reg, info);
153       FPRINTF (F, ")");
154       break;
155     case 5:
156       FPRINTF (F, "*-(");
157       print_reg (reg, info);
158       FPRINTF (F, ")");
159       break;
160     case 6:
161     case 7:
162       if (read_word (*memaddr, &disp, info) < 0)
163         return -1;
164       *memaddr += 2;
165       if (reg == 7)
166         {
167           bfd_vma address = *memaddr + sign_extend (disp);
168           if (!(code & JUMP))
169             FPRINTF (F, "*$");
170           (*info->print_address_func) (address, info);
171         }
172       else
173         {
174           if (mode == 7)
175             FPRINTF (F, "*");
176           print_signed_octal (sign_extend (disp), info);
177           FPRINTF (F, "(");
178           print_reg (reg, info);
179           FPRINTF (F, ")");
180         }
181       break;
182     }
183
184   return 0;
185 }
186
187 /* Print the PDP-11 instruction at address MEMADDR in debugged memory,
188    on INFO->STREAM.  Returns length of the instruction, in bytes.  */
189
190 int
191 print_insn_pdp11 (memaddr, info)
192      bfd_vma memaddr;
193      disassemble_info *info;
194 {
195   bfd_vma start_memaddr = memaddr;
196   int opcode;
197   int src, dst;
198   int i;
199
200   info->bytes_per_line = 6;
201   info->bytes_per_chunk = 2;
202   info->display_endian = BFD_ENDIAN_LITTLE;
203
204   if (read_word (memaddr, &opcode, info) != 0)
205     return -1;
206   memaddr += 2;
207
208   src = (opcode >> 6) & 0x3f;
209   dst = opcode & 0x3f;
210
211   for (i = 0; i < pdp11_num_opcodes; i++)
212     {
213 #define OP pdp11_opcodes[i]
214       if ((opcode & OP.mask) == OP.opcode)
215         switch (OP.type)
216           {
217           case PDP11_OPCODE_NO_OPS:
218             FPRINTF (F, OP.name);
219             break;
220           case PDP11_OPCODE_REG:
221             FPRINTF (F, OP.name);
222             FPRINTF (F, AFTER_INSTRUCTION);
223             print_reg (dst, info);
224             break;
225           case PDP11_OPCODE_OP:
226             FPRINTF (F, OP.name);
227             FPRINTF (F, AFTER_INSTRUCTION);
228             if (strcmp (OP.name, "jmp") == 0)
229               dst |= JUMP;
230             if (print_operand (&memaddr, dst, info) < 0)
231               return -1;
232             break;
233           case PDP11_OPCODE_REG_OP:
234             FPRINTF (F, OP.name);
235             FPRINTF (F, AFTER_INSTRUCTION);
236             print_reg (src, info);
237             FPRINTF (F, OPERAND_SEPARATOR);
238             if (strcmp (OP.name, "jsr") == 0)
239               dst |= JUMP;
240             if (print_operand (&memaddr, dst, info) < 0)
241               return -1;
242             break;
243           case PDP11_OPCODE_REG_OP_REV:
244             FPRINTF (F, OP.name);
245             FPRINTF (F, AFTER_INSTRUCTION);
246             if (print_operand (&memaddr, dst, info) < 0)
247               return -1;
248             FPRINTF (F, OPERAND_SEPARATOR);
249             print_reg (src, info);
250             break;
251           case PDP11_OPCODE_AC_OP:
252             {
253               int ac = (opcode & 0xe0) >> 6;
254               FPRINTF (F, OP.name);
255               FPRINTF (F, AFTER_INSTRUCTION);
256               print_freg (ac, info);
257               FPRINTF (F, OPERAND_SEPARATOR);
258               if (print_operand (&memaddr, dst, info) < 0)
259                 return -1;
260               break;
261             }
262           case PDP11_OPCODE_OP_OP:
263             FPRINTF (F, OP.name);
264             FPRINTF (F, AFTER_INSTRUCTION);
265             if (print_operand (&memaddr, src, info) < 0)
266               return -1;
267             FPRINTF (F, OPERAND_SEPARATOR);
268             if (print_operand (&memaddr, dst, info) < 0)
269               return -1;
270             break;
271           case PDP11_OPCODE_DISPL:
272             {
273               int displ = (opcode & 0xff) << 8;
274               bfd_vma address = memaddr + (sign_extend (displ) >> 7);
275               FPRINTF (F, OP.name);
276               FPRINTF (F, AFTER_INSTRUCTION);
277               (*info->print_address_func) (address, info);
278               break;
279             }
280           case PDP11_OPCODE_REG_DISPL:
281             {
282               int displ = (opcode & 0x3f) << 10;
283               bfd_vma address = memaddr + (sign_extend (displ) >> 9);
284               FPRINTF (F, OP.name);
285               FPRINTF (F, AFTER_INSTRUCTION);
286               print_reg (src, info);
287               FPRINTF (F, OPERAND_SEPARATOR);
288               (*info->print_address_func) (address, info);
289               break;
290             }
291           case PDP11_OPCODE_IMM8:
292             {
293               int code = opcode & 0xff;
294               FPRINTF (F, OP.name);
295               FPRINTF (F, AFTER_INSTRUCTION);
296               FPRINTF (F, "%o", code);
297               break;
298             }
299           case PDP11_OPCODE_IMM6:
300             {
301               int code = opcode & 0x3f;
302               FPRINTF (F, OP.name);
303               FPRINTF (F, AFTER_INSTRUCTION);
304               FPRINTF (F, "%o", code);
305               break;
306             }
307           case PDP11_OPCODE_IMM3:
308             {
309               int code = opcode & 7;
310               FPRINTF (F, OP.name);
311               FPRINTF (F, AFTER_INSTRUCTION);
312               FPRINTF (F, "%o", code);
313               break;
314             }
315           default:
316             /* TODO: is this a proper way of signalling an error? */
317             FPRINTF (F, "<internal error: unrecognized instruction type>");
318             return -1;
319           }
320 #undef OP
321     }
322
323   return memaddr - start_memaddr;
324 }