* d10v-dis.c: Fix formatting.
[platform/upstream/binutils.git] / opcodes / d30v-dis.c
1 /* Disassemble D30V instructions.
2    Copyright 1997, 1998, 2000, 2001 Free Software Foundation, Inc.
3
4 This program 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 <stdio.h>
19 #include "sysdep.h"
20 #include "opcode/d30v.h"
21 #include "dis-asm.h"
22 #include "opintl.h"
23
24 #define PC_MASK 0xFFFFFFFF
25
26 static int lookup_opcode PARAMS ((struct d30v_insn *insn, long num, int is_long));
27 static void print_insn PARAMS ((struct disassemble_info *info, bfd_vma memaddr, long long num,
28                                  struct d30v_insn *insn, int is_long, int show_ext));
29 static int extract_value PARAMS ((long long num, struct d30v_operand *oper, int is_long));
30
31 int
32 print_insn_d30v (memaddr, info)
33      bfd_vma memaddr;
34      struct disassemble_info *info;
35 {
36   int status, result;
37   bfd_byte buffer[12];
38   unsigned long in1, in2;
39   struct d30v_insn insn;
40   long long num;
41
42   insn.form = (struct d30v_format *) NULL;
43
44   info->bytes_per_line = 8;
45   info->bytes_per_chunk = 4;
46   info->display_endian = BFD_ENDIAN_BIG;
47
48   status = (*info->read_memory_func) (memaddr, buffer, 4, info);
49   if (status != 0)
50     {
51       (*info->memory_error_func) (status, memaddr, info);
52       return -1;
53     }
54   in1 = bfd_getb32 (buffer);
55
56   status = (*info->read_memory_func) (memaddr + 4, buffer, 4, info);
57   if (status != 0)
58     {
59       info->bytes_per_line = 8;
60       if (!(result = lookup_opcode (&insn, in1, 0)))
61         (*info->fprintf_func) (info->stream, ".long\t0x%x", in1);
62       else
63         print_insn (info, memaddr, (long long) in1, &insn, 0, result);
64       return 4;
65     }
66   in2 = bfd_getb32 (buffer);
67
68   if (in1 & in2 & FM01)
69     {
70       /* LONG instruction.  */
71       if (!(result = lookup_opcode (&insn, in1, 1)))
72         {
73           (*info->fprintf_func) (info->stream, ".long\t0x%x,0x%x", in1, in2);
74           return 8;
75         }
76       num = (long long) in1 << 32 | in2;
77       print_insn (info, memaddr, num, &insn, 1, result);
78     }
79   else
80     {
81       num = in1;
82       if (!(result = lookup_opcode (&insn, in1, 0)))
83         (*info->fprintf_func) (info->stream, ".long\t0x%x", in1);
84       else
85         print_insn (info, memaddr, num, &insn, 0, result);
86
87       switch (((in1 >> 31) << 1) | (in2 >> 31))
88         {
89         case 0:
90           (*info->fprintf_func) (info->stream, "\t||\t");
91           break;
92         case 1:
93           (*info->fprintf_func) (info->stream, "\t->\t");
94           break;
95         case 2:
96           (*info->fprintf_func) (info->stream, "\t<-\t");
97         default:
98           break;
99         }
100
101       insn.form = (struct d30v_format *) NULL;
102       num = in2;
103       if (!(result = lookup_opcode (&insn, in2, 0)))
104         (*info->fprintf_func) (info->stream, ".long\t0x%x", in2);
105       else
106         print_insn (info, memaddr, num, &insn, 0, result);
107     }
108   return 8;
109 }
110
111 /* Return 0 if lookup fails,
112    1 if found and only one form,
113    2 if found and there are short and long forms.  */
114
115 static int
116 lookup_opcode (insn, num, is_long)
117      struct d30v_insn *insn;
118      long num;
119      int is_long;
120 {
121   int i = 0, index;
122   struct d30v_format *f;
123   struct d30v_opcode *op = (struct d30v_opcode *) d30v_opcode_table;
124   int op1 = (num >> 25) & 0x7;
125   int op2 = (num >> 20) & 0x1f;
126   int mod = (num >> 18) & 0x3;
127
128   /* Find the opcode.  */
129   do
130     {
131       if ((op->op1 == op1) && (op->op2 == op2))
132         break;
133       op++;
134     }
135   while (op->name);
136
137   if (!op || !op->name)
138     return 0;
139
140   while (op->op1 == op1 && op->op2 == op2)
141     {
142       /* Scan through all the formats for the opcode.  */
143       index = op->format[i++];
144       do
145         {
146           f = (struct d30v_format *) &d30v_format_table[index];
147           while (f->form == index)
148             {
149               if ((!is_long || f->form >= LONG) && (f->modifier == mod))
150                 {
151                   insn->form = f;
152                   break;
153                 }
154               f++;
155             }
156           if (insn->form)
157             break;
158         }
159       while ((index = op->format[i++]) != 0);
160       if (insn->form)
161         break;
162       op++;
163       i = 0;
164     }
165   if (insn->form == NULL)
166     return 0;
167
168   insn->op = op;
169   insn->ecc = (num >> 28) & 0x7;
170   if (op->format[1])
171     return 2;
172   else
173     return 1;
174 }
175
176 static void
177 print_insn (info, memaddr, num, insn, is_long, show_ext)
178      struct disassemble_info *info;
179      bfd_vma memaddr;
180      long long num;
181      struct d30v_insn *insn;
182      int is_long;
183      int show_ext;
184 {
185   int val, opnum, need_comma = 0;
186   struct d30v_operand *oper;
187   int i, match, opind = 0, need_paren = 0, found_control = 0;
188
189   (*info->fprintf_func) (info->stream, "%s", insn->op->name);
190
191   /* Check for CMP or CMPU.  */
192   if (d30v_operand_table[insn->form->operands[0]].flags & OPERAND_NAME)
193     {
194       opind++;
195       val =
196         extract_value (num,
197                        (struct d30v_operand *) &d30v_operand_table[insn->form->operands[0]],
198                        is_long);
199       (*info->fprintf_func) (info->stream, "%s", d30v_cc_names[val]);
200     }
201
202   /* Add in ".s" or ".l".  */
203   if (show_ext == 2)
204     {
205       if (is_long)
206         (*info->fprintf_func) (info->stream, ".l");
207       else
208         (*info->fprintf_func) (info->stream, ".s");
209     }
210
211   if (insn->ecc)
212     (*info->fprintf_func) (info->stream, "/%s", d30v_ecc_names[insn->ecc]);
213
214   (*info->fprintf_func) (info->stream, "\t");
215
216   while ((opnum = insn->form->operands[opind++]) != 0)
217     {
218       int bits;
219       oper = (struct d30v_operand *) &d30v_operand_table[opnum];
220       bits = oper->bits;
221       if (oper->flags & OPERAND_SHIFT)
222         bits += 3;
223
224       if (need_comma
225           && oper->flags != OPERAND_PLUS
226           && oper->flags != OPERAND_MINUS)
227         {
228           need_comma = 0;
229           (*info->fprintf_func) (info->stream, ", ");
230         }
231
232       if (oper->flags == OPERAND_ATMINUS)
233         {
234           (*info->fprintf_func) (info->stream, "@-");
235           continue;
236         }
237       if (oper->flags == OPERAND_MINUS)
238         {
239           (*info->fprintf_func) (info->stream, "-");
240           continue;
241         }
242       if (oper->flags == OPERAND_PLUS)
243         {
244           (*info->fprintf_func) (info->stream, "+");
245           continue;
246         }
247       if (oper->flags == OPERAND_ATSIGN)
248         {
249           (*info->fprintf_func) (info->stream, "@");
250           continue;
251         }
252       if (oper->flags == OPERAND_ATPAR)
253         {
254           (*info->fprintf_func) (info->stream, "@(");
255           need_paren = 1;
256           continue;
257         }
258
259       if (oper->flags == OPERAND_SPECIAL)
260         continue;
261
262       val = extract_value (num, oper, is_long);
263
264       if (oper->flags & OPERAND_REG)
265         {
266           match = 0;
267           if (oper->flags & OPERAND_CONTROL)
268             {
269               struct d30v_operand *oper3 =
270                 (struct d30v_operand *) &d30v_operand_table[insn->form->operands[2]];
271               int id = extract_value (num, oper3, is_long);
272               found_control = 1;
273               switch (id)
274                 {
275                 case 0:
276                   val |= OPERAND_CONTROL;
277                   break;
278                 case 1:
279                 case 2:
280                   val = OPERAND_CONTROL + MAX_CONTROL_REG + id;
281                   break;
282                 case 3:
283                   val |= OPERAND_FLAG;
284                   break;
285                 default:
286                   fprintf (stderr, "illegal id (%d)\n", id);
287                 }
288             }
289           else if (oper->flags & OPERAND_ACC)
290             val |= OPERAND_ACC;
291           else if (oper->flags & OPERAND_FLAG)
292             val |= OPERAND_FLAG;
293           for (i = 0; i < reg_name_cnt (); i++)
294             {
295               if (val == pre_defined_registers[i].value)
296                 {
297                   if (pre_defined_registers[i].pname)
298                     (*info->fprintf_func)
299                       (info->stream, "%s", pre_defined_registers[i].pname);
300                   else
301                     (*info->fprintf_func)
302                       (info->stream, "%s", pre_defined_registers[i].name);
303                   match = 1;
304                   break;
305                 }
306             }
307           if (match == 0)
308             {
309               /* This would only get executed if a register was not in
310                  the register table.  */
311               (*info->fprintf_func)
312                 (info->stream, _("<unknown register %d>"), val & 0x3F);
313             }
314         }
315       /* repeati has a relocation, but its first argument is a plain
316          immediate.  OTOH instructions like djsri have a pc-relative
317          delay target, but a absolute jump target.  Therefore, a test
318          of insn->op->reloc_flag is not specific enough; we must test
319          if the actual operand we are handling now is pc-relative.  */
320       else if (oper->flags & OPERAND_PCREL)
321         {
322           int neg = 0;
323
324           /* IMM6S3 is unsigned.  */
325           if (oper->flags & OPERAND_SIGNED || bits == 32)
326             {
327               long max;
328               max = (1 << (bits - 1));
329               if (val & max)
330                 {
331                   if (bits == 32)
332                     val = -val;
333                   else
334                     val = -val & ((1 << bits) - 1);
335                   neg = 1;
336                 }
337             }
338           if (neg)
339             {
340               (*info->fprintf_func) (info->stream, "-%x\t(", val);
341               (*info->print_address_func) ((memaddr - val) & PC_MASK, info);
342               (*info->fprintf_func) (info->stream, ")");
343             }
344           else
345             {
346               (*info->fprintf_func) (info->stream, "%x\t(", val);
347               (*info->print_address_func) ((memaddr + val) & PC_MASK, info);
348               (*info->fprintf_func) (info->stream, ")");
349             }
350         }
351       else if (insn->op->reloc_flag == RELOC_ABS)
352         {
353           (*info->print_address_func) (val, info);
354         }
355       else
356         {
357           if (oper->flags & OPERAND_SIGNED)
358             {
359               int max = (1 << (bits - 1));
360               if (val & max)
361                 {
362                   val = -val;
363                   if (bits < 32)
364                     val &= ((1 << bits) - 1);
365                   (*info->fprintf_func) (info->stream, "-");
366                 }
367             }
368           (*info->fprintf_func) (info->stream, "0x%x", val);
369         }
370       /* If there is another operand, then write a comma and space.  */
371       if (insn->form->operands[opind] && !(found_control && opind == 2))
372         need_comma = 1;
373     }
374   if (need_paren)
375     (*info->fprintf_func) (info->stream, ")");
376 }
377
378 static int
379 extract_value (num, oper, is_long)
380      long long num;
381      struct d30v_operand *oper;
382      int is_long;
383 {
384   int val;
385   int shift = 12 - oper->position;
386   int mask = (0xFFFFFFFF >> (32 - oper->bits));
387
388   if (is_long)
389     {
390       if (oper->bits == 32)
391         {
392           /* Piece together 32-bit constant.  */
393           val = ((num & 0x3FFFF)
394                  | ((num & 0xFF00000) >> 2)
395                  | ((num & 0x3F00000000LL) >> 6));
396         }
397       else
398         val = (num >> (32 + shift)) & mask;
399     }
400   else
401     val = (num >> shift) & mask;
402
403   if (oper->flags & OPERAND_SHIFT)
404     val <<= 3;
405
406   return val;
407 }