ChangeLog rotatation and copyright year update
[external/binutils.git] / opcodes / h8500-dis.c
1 /* Disassemble h8500 instructions.
2    Copyright (C) 1993-2015 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 <stdio.h>
23
24 #define DISASSEMBLER_TABLE
25 #define DEFINE_TABLE
26
27 #include "h8500-opc.h"
28 #include "dis-asm.h"
29 #include "opintl.h"
30
31 /* Maximum length of an instruction.  */
32 #define MAXLEN 8
33
34 #include <setjmp.h>
35
36 struct private
37 {
38   /* Points to first byte not fetched.  */
39   bfd_byte *max_fetched;
40   bfd_byte the_buffer[MAXLEN];
41   bfd_vma insn_start;
42   OPCODES_SIGJMP_BUF bailout;
43 };
44
45 /* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
46    to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
47    on error.  */
48 #define FETCH_DATA(info, addr) \
49   ((addr) <= ((struct private *)(info->private_data))->max_fetched \
50    ? 1 : fetch_data ((info), (addr)))
51
52 static int
53 fetch_data (struct disassemble_info *info, bfd_byte *addr)
54 {
55   int status;
56   struct private *priv = (struct private *) info->private_data;
57   bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
58
59   status = (*info->read_memory_func) (start,
60                                       priv->max_fetched,
61                                       addr - priv->max_fetched,
62                                       info);
63   if (status != 0)
64     {
65       (*info->memory_error_func) (status, start, info);
66       OPCODES_SIGLONGJMP (priv->bailout, 1);
67     }
68   else
69     priv->max_fetched = addr;
70   return 1;
71 }
72
73 static char *crname[] = { "sr", "ccr", "*", "br", "ep", "dp", "*", "tp" };
74
75 int
76 print_insn_h8500 (bfd_vma addr, disassemble_info *info)
77 {
78   const h8500_opcode_info *opcode;
79   void *stream = info->stream;
80   fprintf_ftype func = info->fprintf_func;
81   struct private priv;
82   bfd_byte *buffer = priv.the_buffer;
83
84   info->private_data = (PTR) & priv;
85   priv.max_fetched = priv.the_buffer;
86   priv.insn_start = addr;
87   if (OPCODES_SIGSETJMP (priv.bailout) != 0)
88     /* Error return.  */
89     return -1;
90
91   /* Run down the table to find the one which matches.  */
92   for (opcode = h8500_table; opcode->name; opcode++)
93     {
94       int byte;
95       int rn = 0;
96       int rd = 0;
97       int rs = 0;
98       int disp = 0;
99       int abs_val = 0;
100       int imm = 0;
101       int pcrel = 0;
102       int qim = 0;
103       int i;
104       int cr = 0;
105
106       for (byte = 0; byte < opcode->length; byte++)
107         {
108           FETCH_DATA (info, buffer + byte + 1);
109           if ((buffer[byte] & opcode->bytes[byte].mask)
110               != (opcode->bytes[byte].contents))
111             goto next;
112
113           else
114             {
115               /* Extract any info parts.  */
116               switch (opcode->bytes[byte].insert)
117                 {
118                 case 0:
119                 case FP:
120                   break;
121                 default:
122                   /* xgettext:c-format */
123                   func (stream, _("can't cope with insert %d\n"),
124                         opcode->bytes[byte].insert);
125                   break;
126                 case RN:
127                   rn = buffer[byte] & 0x7;
128                   break;
129                 case RS:
130                   rs = buffer[byte] & 0x7;
131                   break;
132                 case CRB:
133                   cr = buffer[byte] & 0x7;
134                   if (cr == 0)
135                     goto next;
136                   break;
137                 case CRW:
138                   cr = buffer[byte] & 0x7;
139                   if (cr != 0)
140                     goto next;
141                   break;
142                 case DISP16:
143                   FETCH_DATA (info, buffer + byte + 2);
144                   disp = (buffer[byte] << 8) | (buffer[byte + 1]);
145                   break;
146                 case FPIND_D8:
147                 case DISP8:
148                   disp = ((char) (buffer[byte]));
149                   break;
150                 case RD:
151                 case RDIND:
152                   rd = buffer[byte] & 0x7;
153                   break;
154                 case ABS24:
155                   FETCH_DATA (info, buffer + byte + 3);
156                   abs_val =
157                     (buffer[byte] << 16)
158                     | (buffer[byte + 1] << 8)
159                     | (buffer[byte + 2]);
160                   break;
161                 case ABS16:
162                   FETCH_DATA (info, buffer + byte + 2);
163                   abs_val = (buffer[byte] << 8) | (buffer[byte + 1]);
164                   break;
165                 case ABS8:
166                   abs_val = (buffer[byte]);
167                   break;
168                 case IMM16:
169                   FETCH_DATA (info, buffer + byte + 2);
170                   imm = (buffer[byte] << 8) | (buffer[byte + 1]);
171                   break;
172                 case IMM4:
173                   imm = (buffer[byte]) & 0xf;
174                   break;
175                 case IMM8:
176                 case RLIST:
177                   imm = (buffer[byte]);
178                   break;
179                 case PCREL16:
180                   FETCH_DATA (info, buffer + byte + 2);
181                   pcrel = (buffer[byte] << 8) | (buffer[byte + 1]);
182                   break;
183                 case PCREL8:
184                   pcrel = (buffer[byte]);
185                   break;
186                 case QIM:
187                   switch (buffer[byte] & 0x7)
188                     {
189                     case 0:
190                       qim = 1;
191                       break;
192                     case 1:
193                       qim = 2;
194                       break;
195                     case 4:
196                       qim = -1;
197                       break;
198                     case 5:
199                       qim = -2;
200                       break;
201                     }
202                   break;
203
204                 }
205             }
206         }
207       /* We get here when all the masks have passed so we can output
208          the operands.  */
209       FETCH_DATA (info, buffer + opcode->length);
210       (func) (stream, "%s\t", opcode->name);
211       for (i = 0; i < opcode->nargs; i++)
212         {
213           if (i)
214             (func) (stream, ",");
215           switch (opcode->arg_type[i])
216             {
217             case FP:
218               func (stream, "fp");
219               break;
220             case RNIND_D16:
221               func (stream, "@(0x%x:16,r%d)", disp, rn);
222               break;
223             case RNIND_D8:
224               func (stream, "@(0x%x:8 (%d),r%d)", disp & 0xff, disp, rn);
225               break;
226             case RDIND_D16:
227               func (stream, "@(0x%x:16,r%d)", disp, rd);
228               break;
229             case RDIND_D8:
230               func (stream, "@(0x%x:8 (%d), r%d)", disp & 0xff, disp, rd);
231               break;
232             case FPIND_D8:
233               func (stream, "@(0x%x:8 (%d), fp)", disp & 0xff, disp);
234               break;
235             case CRB:
236             case CRW:
237               func (stream, "%s", crname[cr]);
238               break;
239             case RN:
240               func (stream, "r%d", rn);
241               break;
242             case RD:
243               func (stream, "r%d", rd);
244               break;
245             case RS:
246               func (stream, "r%d", rs);
247               break;
248             case RNDEC:
249               func (stream, "@-r%d", rn);
250               break;
251             case RNINC:
252               func (stream, "@r%d+", rn);
253               break;
254             case RNIND:
255               func (stream, "@r%d", rn);
256               break;
257             case RDIND:
258               func (stream, "@r%d", rd);
259               break;
260             case SPINC:
261               func (stream, "@sp+");
262               break;
263             case SPDEC:
264               func (stream, "@-sp");
265               break;
266             case ABS24:
267               func (stream, "@0x%0x:24", abs_val);
268               break;
269             case ABS16:
270               func (stream, "@0x%0x:16", abs_val & 0xffff);
271               break;
272             case ABS8:
273               func (stream, "@0x%0x:8", abs_val & 0xff);
274               break;
275             case IMM16:
276               func (stream, "#0x%0x:16", imm & 0xffff);
277               break;
278             case RLIST:
279               {
280                 int j;
281                 int nc = 0;
282
283                 func (stream, "(");
284                 for (j = 0; j < 8; j++)
285                   {
286                     if (imm & (1 << j))
287                       {
288                         func (stream, "r%d", j);
289                         if (nc)
290                           func (stream, ",");
291                         nc = 1;
292                       }
293                   }
294                 func (stream, ")");
295               }
296               break;
297             case IMM8:
298               func (stream, "#0x%0x:8", imm & 0xff);
299               break;
300             case PCREL16:
301               func (stream, "0x%0x:16",
302                     (int)(pcrel + addr + opcode->length) & 0xffff);
303               break;
304             case PCREL8:
305               func (stream, "#0x%0x:8",
306                     (int)((char) pcrel + addr + opcode->length) & 0xffff);
307               break;
308             case QIM:
309               func (stream, "#%d:q", qim);
310               break;
311             case IMM4:
312               func (stream, "#%d:4", imm);
313               break;
314             }
315         }
316       return opcode->length;
317     next:
318       ;
319     }
320
321   /* Couldn't understand anything.  */
322   /* xgettext:c-format */
323   func (stream, _("%02x\t\t*unknown*"), buffer[0]);
324   return 1;
325 }