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

Subversion Repositories or1k

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

Go to most recent revision | Details | Compare with Previous | View Log

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\t*unknown*"), buffer[0]);
349 
  return 1;
350 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.