URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [opcodes/] [h8300-dis.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


/* Disassemble h8300 instructions.
   Copyright 1993, 1994, 1996, 1998, 2000 Free Software Foundation, Inc.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
 
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
#define DEFINE_TABLE
 
#include "sysdep.h"
#define h8_opcodes h8ops
#include "opcode/h8300.h"
#include "dis-asm.h"
#include "opintl.h"
 
/* Run through the opcodes and sort them into order to make them easy
   to disassemble.  */
static void
bfd_h8_disassemble_init ()
{
  unsigned int i;
  struct h8_opcode *p;
 
  for (p = h8_opcodes; p->name; p++)
    {
      int n1 = 0;
      int n2 = 0;
 
      if ((int) p->data.nib[0] < 16)
        n1 = (int) p->data.nib[0];
      else
        n1 = 0;
 
      if ((int) p->data.nib[1] < 16)
        n2 = (int) p->data.nib[1];
      else
        n2 = 0;
 
      /* Just make sure there are an even number of nibbles in it, and
         that the count is the same as the length.  */
      for (i = 0; p->data.nib[i] != E; i++)
        ;
 
      if (i & 1)
        abort ();
 
      p->length = i / 2;
    }
}
 
unsigned int
bfd_h8_disassemble (addr, info, mode)
     bfd_vma addr;
     disassemble_info *info;
     int mode;
{
  /* Find the first entry in the table for this opcode.  */
  static CONST char *regnames[] =
    {
      "r0h", "r1h", "r2h", "r3h", "r4h", "r5h", "r6h", "r7h",
      "r0l", "r1l", "r2l", "r3l", "r4l", "r5l", "r6l", "r7l"
    };
  static CONST char *wregnames[] =
    {
      "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
      "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7"
    };
  static CONST char *lregnames[] =
    {
      "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7",
      "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7"
    };
  int rs = 0;
  int rd = 0;
  int rdisp = 0;
  int abs = 0;
  int bit = 0;
  int plen = 0;
  static boolean init = 0;
  struct h8_opcode *q;
  char CONST **pregnames = mode != 0 ? lregnames : wregnames;
  int status;
  int l;
  unsigned char data[20];
  void *stream = info->stream;
  fprintf_ftype fprintf = info->fprintf_func;
 
  if (!init)
    {
      bfd_h8_disassemble_init ();
      init = 1;
    }
 
  status = info->read_memory_func (addr, data, 2, info);
  if (status != 0)
    {
      info->memory_error_func (status, addr, info);
      return -1;
    }
 
  for (l = 2; status == 0 && l < 10; l += 2)
    status = info->read_memory_func (addr + l, data + l, 2, info);
 
  /* Find the exact opcode/arg combo.  */
  for (q = h8_opcodes; q->name; q++)
    {
      op_type *nib = q->data.nib;
      unsigned int len = 0;
 
      while (1)
        {
          op_type looking_for = *nib;
          int thisnib = data[len >> 1];
 
          thisnib = (len & 1) ? (thisnib & 0xf) : ((thisnib >> 4) & 0xf);
 
          if (looking_for < 16 && looking_for >= 0)
            {
              if (looking_for != thisnib)
                goto fail;
            }
          else
            {
              if ((int) looking_for & (int) B31)
                {
                  if (!(((int) thisnib & 0x8) != 0))
                    goto fail;
 
                  looking_for = (op_type) ((int) looking_for & ~(int) B31);
                }
 
              if ((int) looking_for & (int) B30)
                {
                  if (!(((int) thisnib & 0x8) == 0))
                    goto fail;
 
                  looking_for = (op_type) ((int) looking_for & ~(int) B30);
                }
 
              if (looking_for & DBIT)
                {
                  /* Exclude adds/subs by looking at bit 0 and 2, and
                     make sure the operand size, either w or l,
                     matches by looking at bit 1.  */
                  if ((looking_for & 7) != (thisnib & 7))
                    goto fail;
 
                  abs = (thisnib & 0x8) ? 2 : 1;
                }
              else if (looking_for & (REG | IND | INC | DEC))
                {
                  if (looking_for & SRC)
                    rs = thisnib;
                  else
                    rd = thisnib;
                }
              else if (looking_for & L_16)
                {
                  abs = (data[len >> 1]) * 256 + data[(len + 2) >> 1];
                  plen = 16;
                }
              else if (looking_for & ABSJMP)
                {
                  abs = (data[1] << 16) | (data[2] << 8) | (data[3]);
                }
              else if (looking_for & MEMIND)
                {
                  abs = data[1];
                }
              else if (looking_for & L_32)
                {
                  int i = len >> 1;
 
                  abs = (data[i] << 24)
                    | (data[i + 1] << 16)
                    | (data[i + 2] << 8)
                    | (data[i + 3]);
 
                  plen = 32;
                }
              else if (looking_for & L_24)
                {
                  int i = len >> 1;
 
                  abs = (data[i] << 16) | (data[i + 1] << 8) | (data[i + 2]);
                  plen = 24;
                }
              else if (looking_for & IGNORE)
                {
                  ;
                }
              else if (looking_for & DISPREG)
                {
                  rdisp = thisnib;
                }
              else if (looking_for & KBIT)
                {
                  switch (thisnib)
                    {
                    case 9:
                      abs = 4;
                      break;
                    case 8:
                      abs = 2;
                      break;
                    case 0:
                      abs = 1;
                      break;
                    default:
                      goto fail;
                    }
                }
              else if (looking_for & L_8)
                {
                  plen = 8;
                  abs = data[len >> 1];
                }
              else if (looking_for & L_3)
                {
                  bit = thisnib & 0x7;
                }
              else if (looking_for & L_2)
                {
                  plen = 2;
                  abs = thisnib & 0x3;
                }
              else if (looking_for & MACREG)
                {
                  abs = (thisnib == 3);
                }
              else if (looking_for == E)
                {
                  int i;
 
                  for (i = 0; i < q->length; i++)
                    fprintf (stream, "%02x ", data[i]);
 
                  for (; i < 6; i++)
                    fprintf (stream, "   ");
 
                  fprintf (stream, "%s\t", q->name);
 
                  /* Gross.  Disgusting.  */
                  if (strcmp (q->name, "ldm.l") == 0)
                    {
                      int count, high;
 
                      count = (data[1] >> 4) & 0x3;
                      high = data[3] & 0x7;
 
                      fprintf (stream, "@sp+,er%d-er%d", high - count, high);
                      return q->length;
                    }
 
                  if (strcmp (q->name, "stm.l") == 0)
                    {
                      int count, low;
 
                      count = (data[1] >> 4) & 0x3;
                      low = data[3] & 0x7;
 
                      fprintf (stream, "er%d-er%d,@-sp", low, low + count);
                      return q->length;
                    }
 
                  /* Fill in the args.  */
                  {
                    op_type *args = q->args.nib;
                    int hadone = 0;
 
                    while (*args != E)
                      {
                        int x = *args;
 
                        if (hadone)
                          fprintf (stream, ",");
 
                        if (x & L_3)
                          {
                            fprintf (stream, "#0x%x", (unsigned) bit);
                          }
                        else if (x & (IMM | KBIT | DBIT))
                          {
                            /* Bletch.  For shal #2,er0 and friends.  */
                            if (*(args + 1) & SRC_IN_DST)
                              abs = 2;
 
                            fprintf (stream, "#0x%x", (unsigned) abs);
                          }
                        else if (x & REG)
                          {
                            int rn = (x & DST) ? rd : rs;
 
                            switch (x & SIZE)
                              {
                              case L_8:
                                fprintf (stream, "%s", regnames[rn]);
                                break;
                              case L_16:
                                fprintf (stream, "%s", wregnames[rn]);
                                break;
                              case L_P:
                              case L_32:
                                fprintf (stream, "%s", lregnames[rn]);
                                break;
                              }
                          }
                        else if (x & MACREG)
                          {
                            fprintf (stream, "mac%c", abs ? 'l' : 'h');
                          }
                        else if (x & INC)
                          {
                            fprintf (stream, "@%s+", pregnames[rs]);
                          }
                        else if (x & DEC)
                          {
                            fprintf (stream, "@-%s", pregnames[rd]);
                          }
                        else if (x & IND)
                          {
                            int rn = (x & DST) ? rd : rs;
                            fprintf (stream, "@%s", pregnames[rn]);
                          }
                        else if (x & ABS8MEM)
                          {
                            fprintf (stream, "@0x%x:8", (unsigned) abs);
                          }
                        else if (x & (ABS | ABSJMP))
                          {
                            fprintf (stream, "@0x%x:%d", (unsigned) abs, plen);
                          }
                        else if (x & MEMIND)
                          {
                            fprintf (stream, "@@%d (%x)", abs, abs);
                          }
                        else if (x & PCREL)
                          {
                            if (x & L_16)
                              {
                                abs += 2;
                                fprintf (stream,
                                         ".%s%d (%x)",
                                         (short) abs > 0 ? "+" : "",
                                         (short) abs, addr + (short) abs + 2);
                              }
                            else
                              {
                                fprintf (stream,
                                         ".%s%d (%x)",
                                         (char) abs > 0 ? "+" : "",
                                         (char) abs, addr + (char) abs + 2);
                              }
                          }
                        else if (x & DISP)
                          {
                            fprintf (stream, "@(0x%x:%d,%s)",
                                     abs, plen, pregnames[rdisp]);
                          }
                        else if (x & CCR)
                          {
                            fprintf (stream, "ccr");
                          }
                        else if (x & EXR)
                          {
                            fprintf (stream, "exr");
                          }
                        else
                          /* xgettext:c-format */
                          fprintf (stream, _("Hmmmm %x"), x);
 
                        hadone = 1;
                        args++;
                      }
                  }
 
                  return q->length;
                }
              else
                /* xgettext:c-format */
                fprintf (stream, _("Don't understand %x \n"), looking_for);
            }
 
          len++;
          nib++;
        }
 
    fail:
      ;
    }
 
  /* Fell off the end.  */
  fprintf (stream, "%02x %02x        .word\tH'%x,H'%x",
           data[0], data[1],
           data[0], data[1]);
  return 2;
}
 
int
print_insn_h8300 (addr, info)
     bfd_vma addr;
     disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info, 0);
}
 
int
print_insn_h8300h (addr, info)
     bfd_vma addr;
     disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info, 1);
}
 
int
print_insn_h8300s (addr, info)
     bfd_vma addr;
     disassemble_info *info;
{
  return bfd_h8_disassemble (addr, info, 2);
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [opcodes/] [h8300-dis.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	578	markom	`/* Disassemble h8300 instructions.`
2			`Copyright 1993, 1994, 1996, 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			`}`