This commit was generated by cvs2svn to track changes on a CVS vendor
[external/binutils.git] / opcodes / h8300-dis.c
1 /* Disassemble h8300 instructions.
2    Copyright (C) 1993, 1998, 2000 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 #define DEFINE_TABLE
19
20 #include "sysdep.h"
21 #define h8_opcodes h8ops
22 #include "opcode/h8300.h"
23 #include "dis-asm.h"
24 #include "opintl.h"
25
26 /* Run through the opcodes and sort them into order to make them easy
27    to disassemble.  */
28 static void
29 bfd_h8_disassemble_init ()
30 {
31   unsigned int i;
32   struct h8_opcode *p;
33
34   for (p = h8_opcodes; p->name; p++)
35     {
36       int n1 = 0;
37       int n2 = 0;
38
39       if ((int) p->data.nib[0] < 16)
40         n1 = (int) p->data.nib[0];
41       else
42         n1 = 0;
43
44       if ((int) p->data.nib[1] < 16)
45         n2 = (int) p->data.nib[1];
46       else
47         n2 = 0;
48
49       /* Just make sure there are an even number of nibbles in it, and
50          that the count is the same as the length.  */
51       for (i = 0; p->data.nib[i] != E; i++)
52         ;
53
54       if (i & 1)
55         abort ();
56
57       p->length = i / 2;
58     }
59 }
60
61 unsigned int
62 bfd_h8_disassemble (addr, info, mode)
63      bfd_vma addr;
64      disassemble_info *info;
65      int mode;
66 {
67   /* Find the first entry in the table for this opcode.  */
68   static CONST char *regnames[] =
69     {
70       "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
71       "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l"
72     };
73   static CONST char *wregnames[] =
74     {
75       "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
76       "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7"
77     };
78   static CONST char *lregnames[] =
79     {
80       "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7",
81       "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7"
82     };
83   int rs = 0;
84   int rd = 0;
85   int rdisp = 0;
86   int abs = 0;
87   int bit = 0;
88   int plen = 0;
89   static boolean init = 0;
90   struct h8_opcode *q;
91   char CONST **pregnames = mode != 0 ? lregnames : wregnames;
92   int status;
93   int l;
94   unsigned char data[20];
95   void *stream = info->stream;
96   fprintf_ftype fprintf = info->fprintf_func;
97
98   if (!init)
99     {
100       bfd_h8_disassemble_init ();
101       init = 1;
102     }
103
104   status = info->read_memory_func (addr, data, 2, info);
105   if (status != 0)
106     {
107       info->memory_error_func (status, addr, info);
108       return -1;
109     }
110
111   for (l = 2; status == 0 && l < 10; l += 2)
112     status = info->read_memory_func (addr + l, data + l, 2, info);
113
114   /* Find the exact opcode/arg combo.  */
115   for (q = h8_opcodes; q->name; q++)
116     {
117       op_type *nib = q->data.nib;
118       unsigned int len = 0;
119
120       while (1)
121         {
122           op_type looking_for = *nib;
123           int thisnib = data[len >> 1];
124
125           thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
126
127           if (looking_for < 16 && looking_for >= 0)
128             {
129               if (looking_for != thisnib)
130                 goto fail;
131             }
132           else
133             {
134               if ((int) looking_for & (int) B31)
135                 {
136                   if (!(((int) thisnib & 0x8) != 0))
137                     goto fail;
138
139                   looking_for = (op_type) ((int) looking_for & ~(int) B31);
140                 }
141
142               if ((int) looking_for & (int) B30)
143                 {
144                   if (!(((int) thisnib & 0x8) == 0))
145                     goto fail;
146
147                   looking_for = (op_type) ((int) looking_for & ~(int) B30);
148                 }
149
150               if (looking_for & DBIT)
151                 {
152                   /* Exclude adds/subs by looking at bit 0 and 2, and
153                      make sure the operand size, either w or l,
154                      matches by looking at bit 1.  */
155                   if ((looking_for & 7) != (thisnib & 7))
156                     goto fail;
157
158                   abs = (thisnib & 0x8) ? 2 : 1;
159                 }
160               else if (looking_for & (REG | IND | INC | DEC))
161                 {
162                   if (looking_for & SRC)
163                     rs = thisnib;
164                   else
165                     rd = thisnib;
166                 }
167               else if (looking_for & L_16)
168                 {
169                   abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
170                   plen = 16;
171                 }
172               else if (looking_for & ABSJMP)
173                 {
174                   abs = (data[1] << 16) | (data[2] << 8) | (data[3]);
175                 }
176               else if (looking_for & MEMIND)
177                 {
178                   abs = data[1];
179                 }
180               else if (looking_for & L_32)
181                 {
182                   int i = len >> 1;
183
184                   abs = (data[i] << 24)
185                     | (data[i + 1] << 16)
186                     | (data[i + 2] << 8)
187                     | (data[i + 3]);
188
189                   plen = 32;
190                 }
191               else if (looking_for & L_24)
192                 {
193                   int i = len >> 1;
194
195                   abs = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
196                   plen = 24;
197                 }
198               else if (looking_for & IGNORE)
199                 {
200                   ;
201                 }
202               else if (looking_for & DISPREG)
203                 {
204                   rdisp = thisnib;
205                 }
206               else if (looking_for & KBIT)
207                 {
208                   switch (thisnib)
209                     {
210                     case 9:
211                       abs = 4;
212                       break;
213                     case 8:
214                       abs = 2;
215                       break;
216                     case 0:
217                       abs = 1;
218                       break;
219                     default:
220                       goto fail;
221                     }
222                 }
223               else if (looking_for & L_8)
224                 {
225                   plen = 8;
226                   abs = data[len >> 1];
227                 }
228               else if (looking_for & L_3)
229                 {
230                   bit = thisnib & 0x7;
231                 }
232               else if (looking_for & L_2)
233                 {
234                   plen = 2;
235                   abs = thisnib & 0x3;
236                 }
237               else if (looking_for & MACREG)
238                 {
239                   abs = (thisnib == 3);
240                 }
241               else if (looking_for == E)
242                 {
243                   int i;
244
245                   for (i = 0; i < q->length; i++)
246                     fprintf (stream, "%02x ", data[i]);
247
248                   for (; i < 6; i++)
249                     fprintf (stream, "   ");
250
251                   fprintf (stream, "%s\t", q->name);
252
253                   /* Gross.  Disgusting.  */
254                   if (strcmp (q->name, "ldm.l") == 0)
255                     {
256                       int count, high;
257
258                       count = (data[1] >> 4) & 0x3;
259                       high = data[3] & 0x7;
260
261                       fprintf (stream, "@sp+,er%d-er%d", high - count, high);
262                       return q->length;
263                     }
264
265                   if (strcmp (q->name, "stm.l") == 0)
266                     {
267                       int count, low;
268
269                       count = (data[1] >> 4) & 0x3;
270                       low = data[3] & 0x7;
271
272                       fprintf (stream, "er%d-er%d,@-sp", low, low + count);
273                       return q->length;
274                     }
275
276                   /* Fill in the args.  */
277                   {
278                     op_type *args = q->args.nib;
279                     int hadone = 0;
280
281                     while (*args != E)
282                       {
283                         int x = *args;
284
285                         if (hadone)
286                           fprintf (stream, ",");
287
288                         if (x & L_3)
289                           {
290                             fprintf (stream, "#0x%x", (unsigned) bit);
291                           }
292                         else if (x & (IMM | KBIT | DBIT))
293                           {
294                             /* Bletch.  For shal #2,er0 and friends.  */
295                             if (*(args + 1) & SRC_IN_DST)
296                               abs = 2;
297
298                             fprintf (stream, "#0x%x", (unsigned) abs);
299                           }
300                         else if (x & REG)
301                           {
302                             int rn = (x & DST) ? rd : rs;
303
304                             switch (x & SIZE)
305                               {
306                               case L_8:
307                                 fprintf (stream, "%s", regnames[rn]);
308                                 break;
309                               case L_16:
310                                 fprintf (stream, "%s", wregnames[rn]);
311                                 break;
312                               case L_P:
313                               case L_32:
314                                 fprintf (stream, "%s", lregnames[rn]);
315                                 break;
316                               }
317                           }
318                         else if (x & MACREG)
319                           {
320                             fprintf (stream, "mac%c", abs ? 'l' : 'h');
321                           }
322                         else if (x & INC)
323                           {
324                             fprintf (stream, "@%s+", pregnames[rs]);
325                           }
326                         else if (x & DEC)
327                           {
328                             fprintf (stream, "@-%s", pregnames[rd]);
329                           }
330                         else if (x & IND)
331                           {
332                             int rn = (x & DST) ? rd : rs;
333                             fprintf (stream, "@%s", pregnames[rn]);
334                           }
335                         else if (x & ABS8MEM)
336                           {
337                             fprintf (stream, "@0x%x:8", (unsigned) abs);
338                           }
339                         else if (x & (ABS | ABSJMP))
340                           {
341                             fprintf (stream, "@0x%x:%d", (unsigned) abs, plen);
342                           }
343                         else if (x & MEMIND)
344                           {
345                             fprintf (stream, "@@%d (%x)", abs, abs);
346                           }
347                         else if (x & PCREL)
348                           {
349                             if (x & L_16)
350                               {
351                                 abs += 2;
352                                 fprintf (stream,
353                                          ".%s%d (%x)",
354                                          (short) abs > 0 ? "+" : "",
355                                          (short) abs, addr + (short) abs + 2);
356                               }
357                             else
358                               {
359                                 fprintf (stream,
360                                          ".%s%d (%x)",
361                                          (char) abs > 0 ? "+" : "",
362                                          (char) abs, addr + (char) abs + 2);
363                               }
364                           }
365                         else if (x & DISP)
366                           {
367                             fprintf (stream, "@(0x%x:%d,%s)",
368                                      abs, plen, pregnames[rdisp]);
369                           }
370                         else if (x & CCR)
371                           {
372                             fprintf (stream, "ccr");
373                           }
374                         else if (x & EXR)
375                           {
376                             fprintf (stream, "exr");
377                           }
378                         else
379                           /* xgettext:c-format */
380                           fprintf (stream, _("Hmmmm %x"), x);
381
382                         hadone = 1;
383                         args++;
384                       }
385                   }
386
387                   return q->length;
388                 }
389               else
390                 /* xgettext:c-format */
391                 fprintf (stream, _("Don't understand %x \n"), looking_for);
392             }
393
394           len++;
395           nib++;
396         }
397
398     fail:
399       ;
400     }
401
402   /* Fell off the end.  */
403   fprintf (stream, "%02x %02x        .word\tH'%x,H'%x",
404            data[0], data[1],
405            data[0], data[1]);
406   return 2;
407 }
408
409 int
410 print_insn_h8300 (addr, info)
411      bfd_vma addr;
412      disassemble_info *info;
413 {
414   return bfd_h8_disassemble (addr, info, 0);
415 }
416
417 int
418 print_insn_h8300h (addr, info)
419      bfd_vma addr;
420      disassemble_info *info;
421 {
422   return bfd_h8_disassemble (addr, info, 1);
423 }
424
425 int
426 print_insn_h8300s (addr, info)
427      bfd_vma addr;
428      disassemble_info *info;
429 {
430   return bfd_h8_disassemble (addr, info, 2);
431 }