Update copyright years
[external/binutils.git] / opcodes / nios2-dis.c
1 /* Altera Nios II disassemble routines
2    Copyright (C) 2012-2014 Free Software Foundation, Inc.
3    Contributed by Nigel Gray (ngray@altera.com).
4    Contributed by Mentor Graphics, Inc.
5
6    This file is part of the GNU opcodes library.
7
8    This library is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3, or (at your option)
11    any later version.
12
13    It is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this file; see the file COPYING.  If not, write to the
20    Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston,
21    MA 02110-1301, USA.  */
22
23 #include "sysdep.h"
24 #include "dis-asm.h"
25 #include "opcode/nios2.h"
26 #include "libiberty.h"
27 #include <string.h>
28 #include <assert.h>
29
30 /* No symbol table is available when this code runs out in an embedded
31    system as when it is used for disassembler support in a monitor.  */
32 #if !defined(EMBEDDED_ENV)
33 #define SYMTAB_AVAILABLE 1
34 #include "elf-bfd.h"
35 #include "elf/nios2.h"
36 #endif
37
38 /* Length of Nios II instruction in bytes.  */
39 #define INSNLEN 4
40
41 /* Data structures used by the opcode hash table.  */
42 typedef struct _nios2_opcode_hash
43 {
44   const struct nios2_opcode *opcode;
45   struct _nios2_opcode_hash *next;
46 } nios2_opcode_hash;
47
48 static bfd_boolean nios2_hash_init = 0;
49 static nios2_opcode_hash *nios2_hash[(OP_MASK_OP) + 1];
50
51 /* Separate hash table for pseudo-ops.  */
52 static nios2_opcode_hash *nios2_ps_hash[(OP_MASK_OP) + 1];
53
54 /* Function to initialize the opcode hash table.  */
55 static void
56 nios2_init_opcode_hash (void)
57 {
58   unsigned int i;
59   register const struct nios2_opcode *op;
60
61   for (i = 0; i <= OP_MASK_OP; ++i)
62     nios2_hash[0] = NULL;
63   for (i = 0; i <= OP_MASK_OP; i++)
64     for (op = nios2_opcodes; op < &nios2_opcodes[NUMOPCODES]; op++)
65       {
66         nios2_opcode_hash *new_hash;
67         nios2_opcode_hash **bucket = NULL;
68
69         if ((op->pinfo & NIOS2_INSN_MACRO) == NIOS2_INSN_MACRO)
70           {
71             if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP)
72                 && (op->pinfo & (NIOS2_INSN_MACRO_MOV | NIOS2_INSN_MACRO_MOVI)
73                     & 0x7fffffff))
74               bucket = &(nios2_ps_hash[i]);
75           }
76         else if (i == ((op->match >> OP_SH_OP) & OP_MASK_OP))
77           bucket = &(nios2_hash[i]);
78
79         if (bucket)
80           {
81             new_hash =
82               (nios2_opcode_hash *) malloc (sizeof (nios2_opcode_hash));
83             if (new_hash == NULL)
84               {
85                 fprintf (stderr,
86                          "error allocating memory...broken disassembler\n");
87                 abort ();
88               }
89             new_hash->opcode = op;
90             new_hash->next = NULL;
91             while (*bucket)
92               bucket = &((*bucket)->next);
93             *bucket = new_hash;
94           }
95       }
96   nios2_hash_init = 1;
97 #ifdef DEBUG_HASHTABLE
98   for (i = 0; i <= OP_MASK_OP; ++i)
99     {
100       nios2_opcode_hash *tmp_hash = nios2_hash[i];
101       printf ("index: 0x%02X    ops: ", i);
102       while (tmp_hash != NULL)
103         {
104           printf ("%s ", tmp_hash->opcode->name);
105           tmp_hash = tmp_hash->next;
106         }
107       printf ("\n");
108     }
109
110   for (i = 0; i <= OP_MASK_OP; ++i)
111     {
112       nios2_opcode_hash *tmp_hash = nios2_ps_hash[i];
113       printf ("index: 0x%02X    ops: ", i);
114       while (tmp_hash != NULL)
115         {
116           printf ("%s ", tmp_hash->opcode->name);
117           tmp_hash = tmp_hash->next;
118         }
119       printf ("\n");
120     }
121 #endif /* DEBUG_HASHTABLE */
122 }
123
124 /* Return a pointer to an nios2_opcode struct for a given instruction
125    opcode, or NULL if there is an error.  */
126 const struct nios2_opcode *
127 nios2_find_opcode_hash (unsigned long opcode)
128 {
129   nios2_opcode_hash *entry;
130
131   /* Build a hash table to shorten the search time.  */
132   if (!nios2_hash_init)
133     nios2_init_opcode_hash ();
134
135   /* First look in the pseudo-op hashtable.  */
136   for (entry = nios2_ps_hash[(opcode >> OP_SH_OP) & OP_MASK_OP];
137        entry; entry = entry->next)
138     if (entry->opcode->match == (opcode & entry->opcode->mask))
139       return entry->opcode;
140
141   /* Otherwise look in the main hashtable.  */
142   for (entry = nios2_hash[(opcode >> OP_SH_OP) & OP_MASK_OP];
143        entry; entry = entry->next)
144     if (entry->opcode->match == (opcode & entry->opcode->mask))
145       return entry->opcode;
146
147   return NULL;
148 }
149
150 /* There are 32 regular registers, 32 coprocessor registers,
151    and 32 control registers.  */
152 #define NUMREGNAMES 32
153
154 /* Return a pointer to the base of the coprocessor register name array.  */
155 static struct nios2_reg *
156 nios2_coprocessor_regs (void)
157 {
158   static struct nios2_reg *cached = NULL;
159   
160   if (!cached)
161     {
162       int i;
163       for (i = NUMREGNAMES; i < nios2_num_regs; i++)
164         if (!strcmp (nios2_regs[i].name, "c0"))
165           {
166             cached = nios2_regs + i;
167             break;
168           }
169       assert (cached);
170     }
171   return cached;
172 }
173
174 /* Return a pointer to the base of the control register name array.  */
175 static struct nios2_reg *
176 nios2_control_regs (void)
177 {
178   static struct nios2_reg *cached = NULL;
179   
180   if (!cached)
181     {
182       int i;
183       for (i = NUMREGNAMES; i < nios2_num_regs; i++)
184         if (!strcmp (nios2_regs[i].name, "status"))
185           {
186             cached = nios2_regs + i;
187             break;
188           }
189       assert (cached);
190     }
191   return cached;
192 }
193
194 /* The function nios2_print_insn_arg uses the character pointed
195    to by ARGPTR to determine how it print the next token or separator
196    character in the arguments to an instruction.  */
197 static int
198 nios2_print_insn_arg (const char *argptr,
199                       unsigned long opcode, bfd_vma address,
200                       disassemble_info *info)
201 {
202   unsigned long i = 0;
203   struct nios2_reg *reg_base;
204
205   switch (*argptr)
206     {
207     case ',':
208     case '(':
209     case ')':
210       (*info->fprintf_func) (info->stream, "%c", *argptr);
211       break;
212     case 'd':
213       i = GET_INSN_FIELD (RRD, opcode);
214
215       if (GET_INSN_FIELD (OP, opcode) == OP_MATCH_CUSTOM
216           && GET_INSN_FIELD (CUSTOM_C, opcode) == 0)
217         reg_base = nios2_coprocessor_regs ();
218       else
219         reg_base = nios2_regs;
220
221       if (i < NUMREGNAMES)
222         (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
223       else
224         (*info->fprintf_func) (info->stream, "unknown");
225       break;
226     case 's':
227       i = GET_INSN_FIELD (RRS, opcode);
228
229       if (GET_INSN_FIELD (OP, opcode) == OP_MATCH_CUSTOM
230           && GET_INSN_FIELD (CUSTOM_A, opcode) == 0)
231         reg_base = nios2_coprocessor_regs ();
232       else
233         reg_base = nios2_regs;
234
235       if (i < NUMREGNAMES)
236         (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
237       else
238         (*info->fprintf_func) (info->stream, "unknown");
239       break;
240     case 't':
241       i = GET_INSN_FIELD (RRT, opcode);
242
243       if (GET_INSN_FIELD (OP, opcode) == OP_MATCH_CUSTOM
244           && GET_INSN_FIELD (CUSTOM_B, opcode) == 0)
245         reg_base = nios2_coprocessor_regs ();
246       else
247         reg_base = nios2_regs;
248
249       if (i < NUMREGNAMES)
250         (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
251       else
252         (*info->fprintf_func) (info->stream, "unknown");
253       break;
254     case 'i':
255       /* 16-bit signed immediate.  */
256       i = (signed) (GET_INSN_FIELD (IMM16, opcode) << 16) >> 16;
257       (*info->fprintf_func) (info->stream, "%ld", i);
258       break;
259     case 'u':
260       /* 16-bit unsigned immediate.  */
261       i = GET_INSN_FIELD (IMM16, opcode);
262       (*info->fprintf_func) (info->stream, "%ld", i);
263       break;
264     case 'o':
265       /* 16-bit signed immediate address offset.  */
266       i = (signed) (GET_INSN_FIELD (IMM16, opcode) << 16) >> 16;
267       address = address + 4 + i;
268       (*info->print_address_func) (address, info);
269       break;
270     case 'p':
271       /* 5-bit unsigned immediate.  */
272       i = GET_INSN_FIELD (CACHE_OPX, opcode);
273       (*info->fprintf_func) (info->stream, "%ld", i);
274       break;
275     case 'j':
276       /* 5-bit unsigned immediate.  */
277       i = GET_INSN_FIELD (IMM5, opcode);
278       (*info->fprintf_func) (info->stream, "%ld", i);
279       break;
280     case 'l':
281       /* 8-bit unsigned immediate.  */
282       /* FIXME - not yet implemented */
283       i = GET_INSN_FIELD (CUSTOM_N, opcode);
284       (*info->fprintf_func) (info->stream, "%lu", i);
285       break;
286     case 'm':
287       /* 26-bit unsigned immediate.  */
288       i = GET_INSN_FIELD (IMM26, opcode);
289       /* This translates to an address because it's only used in call
290          instructions.  */
291       address = (address & 0xf0000000) | (i << 2);
292       (*info->print_address_func) (address, info);
293       break;
294     case 'c':
295       /* Control register index.  */
296       i = GET_INSN_FIELD (IMM5, opcode);
297       reg_base = nios2_control_regs ();
298       (*info->fprintf_func) (info->stream, "%s", reg_base[i].name);
299       break;
300     case 'b':
301       i = GET_INSN_FIELD (IMM5, opcode);
302       (*info->fprintf_func) (info->stream, "%ld", i);
303       break;
304     default:
305       (*info->fprintf_func) (info->stream, "unknown");
306       break;
307     }
308   return 0;
309 }
310
311 /* nios2_disassemble does all the work of disassembling a Nios II
312    instruction opcode.  */
313 static int
314 nios2_disassemble (bfd_vma address, unsigned long opcode,
315                    disassemble_info *info)
316 {
317   const struct nios2_opcode *op;
318
319   info->bytes_per_line = INSNLEN;
320   info->bytes_per_chunk = INSNLEN;
321   info->display_endian = info->endian;
322   info->insn_info_valid = 1;
323   info->branch_delay_insns = 0;
324   info->data_size = 0;
325   info->insn_type = dis_nonbranch;
326   info->target = 0;
327   info->target2 = 0;
328
329   /* Find the major opcode and use this to disassemble
330      the instruction and its arguments.  */
331   op = nios2_find_opcode_hash (opcode);
332
333   if (op != NULL)
334     {
335       bfd_boolean is_nop = FALSE;
336       if (op->pinfo == NIOS2_INSN_MACRO_MOV)
337         {
338           /* Check for mov r0, r0 and change to nop.  */
339           int dst, src;
340           dst = GET_INSN_FIELD (RRD, opcode);
341           src = GET_INSN_FIELD (RRS, opcode);
342           if (dst == 0 && src == 0)
343             {
344               (*info->fprintf_func) (info->stream, "nop");
345               is_nop = TRUE;
346             }
347           else
348             (*info->fprintf_func) (info->stream, "%s", op->name);
349         }
350       else
351         (*info->fprintf_func) (info->stream, "%s", op->name);
352
353       if (!is_nop)
354         {
355           const char *argstr = op->args;
356           if (argstr != NULL && *argstr != '\0')
357             {
358               (*info->fprintf_func) (info->stream, "\t");
359               while (*argstr != '\0')
360                 {
361                   nios2_print_insn_arg (argstr, opcode, address, info);
362                   ++argstr;
363                 }
364             }
365         }
366     }
367   else
368     {
369       /* Handle undefined instructions.  */
370       info->insn_type = dis_noninsn;
371       (*info->fprintf_func) (info->stream, "0x%lx", opcode);
372     }
373   /* Tell the caller how far to advance the program counter.  */
374   return INSNLEN;
375 }
376
377
378 /* print_insn_nios2 is the main disassemble function for Nios II.
379    The function diassembler(abfd) (source in disassemble.c) returns a
380    pointer to this either print_insn_big_nios2 or
381    print_insn_little_nios2, which in turn call this function when the
382    bfd machine type is Nios II. print_insn_nios2 reads the
383    instruction word at the address given, and prints the disassembled
384    instruction on the stream info->stream using info->fprintf_func. */
385
386 static int
387 print_insn_nios2 (bfd_vma address, disassemble_info *info,
388                   enum bfd_endian endianness)
389 {
390   bfd_byte buffer[INSNLEN];
391   int status;
392
393   status = (*info->read_memory_func) (address, buffer, INSNLEN, info);
394   if (status == 0)
395     {
396       unsigned long insn;
397       if (endianness == BFD_ENDIAN_BIG)
398         insn = (unsigned long) bfd_getb32 (buffer);
399       else
400         insn = (unsigned long) bfd_getl32 (buffer);
401       status = nios2_disassemble (address, insn, info);
402     }
403   else
404     {
405       (*info->memory_error_func) (status, address, info);
406       status = -1;
407     }
408   return status;
409 }
410
411 /* These two functions are the main entry points, accessed from
412    disassemble.c.  */
413 int
414 print_insn_big_nios2 (bfd_vma address, disassemble_info *info)
415 {
416   return print_insn_nios2 (address, info, BFD_ENDIAN_BIG);
417 }
418
419 int
420 print_insn_little_nios2 (bfd_vma address, disassemble_info *info)
421 {
422   return print_insn_nios2 (address, info, BFD_ENDIAN_LITTLE);
423 }