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