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

Subversion Repositories or1k

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

Details | Compare with Previous | View Log


/* Disassemble h8500 instructions.
   Copyright 1993, 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.  */
 
#include <stdio.h>
 
#define DISASSEMBLER_TABLE
#define DEFINE_TABLE
 
#include "sysdep.h"
#include "h8500-opc.h"
#include "dis-asm.h"
#include "opintl.h"
 
/* Maximum length of an instruction.  */
#define MAXLEN 8
 
#include <setjmp.h>
 
struct private
{
  /* Points to first byte not fetched.  */
  bfd_byte *max_fetched;
  bfd_byte the_buffer[MAXLEN];
  bfd_vma insn_start;
  jmp_buf bailout;
};
 
/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
   to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
   on error.  */
#define FETCH_DATA(info, addr) \
  ((addr) <= ((struct private *)(info->private_data))->max_fetched \
   ? 1 : fetch_data ((info), (addr)))
 
static int
fetch_data (info, addr)
     struct disassemble_info *info;
     bfd_byte *addr;
{
  int status;
  struct private *priv = (struct private *) info->private_data;
  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
 
  status = (*info->read_memory_func) (start,
                                      priv->max_fetched,
                                      addr - priv->max_fetched,
                                      info);
  if (status != 0)
    {
      (*info->memory_error_func) (status, start, info);
      longjmp (priv->bailout, 1);
    }
  else
    priv->max_fetched = addr;
  return 1;
}
 
static char *crname[] = { "sr", "ccr", "*", "br", "ep", "dp", "*", "tp" };
 
int
print_insn_h8500 (addr, info)
     bfd_vma addr;
     disassemble_info *info;
{
  h8500_opcode_info *opcode;
  void *stream = info->stream;
  fprintf_ftype func = info->fprintf_func;
 
  struct private priv;
  bfd_byte *buffer = priv.the_buffer;
 
  info->private_data = (PTR) & priv;
  priv.max_fetched = priv.the_buffer;
  priv.insn_start = addr;
  if (setjmp (priv.bailout) != 0)
    /* Error return.  */
    return -1;
 
  if (0)
    {
      static int one;
 
      if (!one)
        {
          one = 1;
          for (opcode = h8500_table; opcode->name; opcode++)
            {
              if ((opcode->bytes[0].contents & 0x8) == 0)
                printf ("%s\n", opcode->name);
            }
        }
    }
 
  /* Run down the table to find the one which matches.  */
  for (opcode = h8500_table; opcode->name; opcode++)
    {
      int byte;
      int rn = 0;
      int rd = 0;
      int rs = 0;
      int disp = 0;
      int abs = 0;
      int imm = 0;
      int pcrel = 0;
      int qim = 0;
      int i;
      int cr = 0;
 
      for (byte = 0; byte < opcode->length; byte++)
        {
          FETCH_DATA (info, buffer + byte + 1);
          if ((buffer[byte] & opcode->bytes[byte].mask)
              != (opcode->bytes[byte].contents))
            {
              goto next;
            }
          else
            {
              /* Extract any info parts.  */
              switch (opcode->bytes[byte].insert)
                {
                case 0:
                case FP:
                  break;
                default:
                  /* xgettext:c-format */
                  func (stream, _("can't cope with insert %d\n"),
                        opcode->bytes[byte].insert);
                  break;
                case RN:
                  rn = buffer[byte] & 0x7;
                  break;
                case RS:
                  rs = buffer[byte] & 0x7;
                  break;
                case CRB:
                  cr = buffer[byte] & 0x7;
                  if (cr == 0)
                    goto next;
                  break;
                case CRW:
                  cr = buffer[byte] & 0x7;
                  if (cr != 0)
                    goto next;
                  break;
                case DISP16:
                  FETCH_DATA (info, buffer + byte + 2);
                  disp = (buffer[byte] << 8) | (buffer[byte + 1]);
                  break;
                case FPIND_D8:
                case DISP8:
                  disp = ((char) (buffer[byte]));
                  break;
                case RD:
                case RDIND:
                  rd = buffer[byte] & 0x7;
                  break;
                case ABS24:
                  FETCH_DATA (info, buffer + byte + 3);
                  abs =
                    (buffer[byte] << 16)
                    | (buffer[byte + 1] << 8)
                    | (buffer[byte + 2]);
                  break;
                case ABS16:
                  FETCH_DATA (info, buffer + byte + 2);
                  abs = (buffer[byte] << 8) | (buffer[byte + 1]);
                  break;
                case ABS8:
                  abs = (buffer[byte]);
                  break;
                case IMM16:
                  FETCH_DATA (info, buffer + byte + 2);
                  imm = (buffer[byte] << 8) | (buffer[byte + 1]);
                  break;
                case IMM4:
                  imm = (buffer[byte]) & 0xf;
                  break;
                case IMM8:
                case RLIST:
                  imm = (buffer[byte]);
                  break;
                case PCREL16:
                  FETCH_DATA (info, buffer + byte + 2);
                  pcrel = (buffer[byte] << 8) | (buffer[byte + 1]);
                  break;
                case PCREL8:
                  pcrel = (buffer[byte]);
                  break;
                case QIM:
                  switch (buffer[byte] & 0x7)
                    {
                    case 0:
                      qim = 1;
                      break;
                    case 1:
                      qim = 2;
                      break;
                    case 4:
                      qim = -1;
                      break;
                    case 5:
                      qim = -2;
                      break;
                    }
                  break;
 
                }
            }
        }
      /* We get here when all the masks have passed so we can output
         the operands.  */
      FETCH_DATA (info, buffer + opcode->length);
      for (i = 0; i < opcode->length; i++)
        {
          (func) (stream, "%02x ", buffer[i]);
        }
      for (; i < 6; i++)
        {
          (func) (stream, "   ");
        }
      (func) (stream, "%s\t", opcode->name);
      for (i = 0; i < opcode->nargs; i++)
        {
          if (i)
            (func) (stream, ",");
          switch (opcode->arg_type[i])
            {
            case FP:
              func (stream, "fp");
              break;
            case RNIND_D16:
              func (stream, "@(0x%x:16,r%d)", disp, rn);
              break;
            case RNIND_D8:
              func (stream, "@(0x%x:8 (%d),r%d)", disp & 0xff, disp, rn);
              break;
            case RDIND_D16:
              func (stream, "@(0x%x:16,r%d)", disp, rd);
              break;
            case RDIND_D8:
              func (stream, "@(0x%x:8 (%d), r%d)", disp & 0xff, disp, rd);
              break;
            case FPIND_D8:
              func (stream, "@(0x%x:8 (%d), fp)", disp & 0xff, disp, rn);
              break;
            case CRB:
            case CRW:
              func (stream, "%s", crname[cr]);
              break;
            case RN:
              func (stream, "r%d", rn);
              break;
            case RD:
              func (stream, "r%d", rd);
              break;
            case RS:
              func (stream, "r%d", rs);
              break;
            case RNDEC:
              func (stream, "@-r%d", rn);
              break;
            case RNINC:
              func (stream, "@r%d+", rn);
              break;
            case RNIND:
              func (stream, "@r%d", rn);
              break;
            case RDIND:
              func (stream, "@r%d", rd);
              break;
            case SPINC:
              func (stream, "@sp+");
              break;
            case SPDEC:
              func (stream, "@-sp");
              break;
            case ABS24:
              func (stream, "@0x%0x:24", abs);
              break;
            case ABS16:
              func (stream, "@0x%0x:16", abs & 0xffff);
              break;
            case ABS8:
              func (stream, "@0x%0x:8", abs & 0xff);
              break;
            case IMM16:
              func (stream, "#0x%0x:16", imm & 0xffff);
              break;
            case RLIST:
              {
                int i;
                int nc = 0;
                func (stream, "(");
                for (i = 0; i < 8; i++)
                  {
                    if (imm & (1 << i))
                      {
                        func (stream, "r%d", i);
                        if (nc)
                          func (stream, ",");
                        nc = 1;
                      }
                  }
                func (stream, ")");
              }
              break;
            case IMM8:
              func (stream, "#0x%0x:8", imm & 0xff);
              break;
            case PCREL16:
              func (stream, "0x%0x:16",
                    (pcrel + addr + opcode->length) & 0xffff);
              break;
            case PCREL8:
              func (stream, "#0x%0x:8",
                    ((char) pcrel + addr + opcode->length) & 0xffff);
              break;
            case QIM:
              func (stream, "#%d:q", qim);
              break;
            case IMM4:
              func (stream, "#%d:4", imm);
              break;
            }
        }
      return opcode->length;
    next:
      ;
    }
 
  /* Couldn't understand anything.  */
  /* xgettext:c-format */
  func (stream, _("%02x\t\t*unknown*"), buffer[0]);
  return 1;
}

Browse

Tools

Subversion Repositories or1k

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

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