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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [opcodes/] [vax-dis.c] - Blame information for rev 1771

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

Line No. Rev Author Line
1 578 markom
/* Print VAX instructions.
2
   Copyright 1995, 1998, 2000, 2001 Free Software Foundation, Inc.
3
   Contributed by Pauline Middelink <middelin@polyware.iaf.nl>
4
 
5
This program is free software; you can redistribute it and/or modify
6
it under the terms of the GNU General Public License as published by
7
the Free Software Foundation; either version 2 of the License, or
8
(at your option) any later version.
9
 
10
This program is distributed in the hope that it will be useful,
11
but WITHOUT ANY WARRANTY; without even the implied warranty of
12
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
GNU General Public License for more details.
14
 
15
You should have received a copy of the GNU General Public License
16
along with this program; if not, write to the Free Software
17
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
18
 
19
#include "sysdep.h"
20
#include "opcode/vax.h"
21
#include "dis-asm.h"
22
 
23
/* Local function prototypes */
24
static int
25
print_insn_arg PARAMS ((const char *, unsigned char *, bfd_vma,
26
                        disassemble_info *));
27
 
28
static int
29
print_insn_mode PARAMS ((int, unsigned char *, bfd_vma, disassemble_info *));
30
 
31
static char *reg_names[] =
32
{
33
  "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
34
  "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc"
35
};
36
 
37
/* Sign-extend an (unsigned char). */
38
#if __STDC__ == 1
39
#define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
40
#else
41
#define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
42
#endif
43
 
44
/* Get a 1 byte signed integer.  */
45
#define NEXTBYTE(p)  \
46
  (p += 1, FETCH_DATA (info, p), \
47
  COERCE_SIGNED_CHAR(p[-1]))
48
 
49
/* Get a 2 byte signed integer.  */
50
#define COERCE16(x) ((int) (((x) ^ 0x8000) - 0x8000))
51
#define NEXTWORD(p)  \
52
  (p += 2, FETCH_DATA (info, p), \
53
   COERCE16 ((p[-1] << 8) + p[-2]))
54
 
55
/* Get a 4 byte signed integer.  */
56
#define COERCE32(x) ((int) (((x) ^ 0x80000000) - 0x80000000))
57
#define NEXTLONG(p)  \
58
  (p += 4, FETCH_DATA (info, p), \
59
   (COERCE32 ((((((p[-1] << 8) + p[-2]) << 8) + p[-3]) << 8) + p[-4])))
60
 
61
/* Maximum length of an instruction.  */
62
#define MAXLEN 25
63
 
64
#include <setjmp.h>
65
 
66
struct private
67
{
68
  /* Points to first byte not fetched.  */
69
  bfd_byte *max_fetched;
70
  bfd_byte the_buffer[MAXLEN];
71
  bfd_vma insn_start;
72
  jmp_buf bailout;
73
};
74
 
75
/* Make sure that bytes from INFO->PRIVATE_DATA->BUFFER (inclusive)
76
   to ADDR (exclusive) are valid.  Returns 1 for success, longjmps
77
   on error.  */
78
#define FETCH_DATA(info, addr) \
79
  ((addr) <= ((struct private *)(info->private_data))->max_fetched \
80
   ? 1 : fetch_data ((info), (addr)))
81
 
82
static int
83
fetch_data (info, addr)
84
     struct disassemble_info *info;
85
     bfd_byte *addr;
86
{
87
  int status;
88
  struct private *priv = (struct private *) info->private_data;
89
  bfd_vma start = priv->insn_start + (priv->max_fetched - priv->the_buffer);
90
 
91
  status = (*info->read_memory_func) (start,
92
                                      priv->max_fetched,
93
                                      addr - priv->max_fetched,
94
                                      info);
95
  if (status != 0)
96
    {
97
      (*info->memory_error_func) (status, start, info);
98
      longjmp (priv->bailout, 1);
99
    }
100
  else
101
    priv->max_fetched = addr;
102
 
103
  return 1;
104
}
105
 
106
/* Print the vax instruction at address MEMADDR in debugged memory,
107
   on INFO->STREAM.  Returns length of the instruction, in bytes.  */
108
 
109
int
110
print_insn_vax (memaddr, info)
111
     bfd_vma memaddr;
112
     disassemble_info *info;
113
{
114
  const struct vot *votp;
115
  const char *argp = NULL;
116
  unsigned char *arg;
117
  struct private priv;
118
  bfd_byte *buffer = priv.the_buffer;
119
 
120
  info->private_data = (PTR) &priv;
121
  priv.max_fetched = priv.the_buffer;
122
  priv.insn_start = memaddr;
123
  if (setjmp (priv.bailout) != 0)
124
    {
125
      /* Error return.  */
126
      return -1;
127
    }
128
 
129
  /* Check if the info buffer has more than one byte left since
130
     the last opcode might be a single byte with no argument data.  */
131
  if (info->buffer_length - (memaddr - info->buffer_vma) > 1)
132
    {
133
      FETCH_DATA (info, buffer + 2);
134
    }
135
  else
136
    {
137
      FETCH_DATA (info, buffer + 1);
138
      buffer[1] = 0;
139
    }
140
 
141
  for (votp = &votstrs[0]; votp->name[0]; votp++)
142
    {
143
      register vax_opcodeT opcode = votp->detail.code;
144
 
145
      /* 2 byte codes match 2 buffer pos. */
146
      if ((bfd_byte) opcode == buffer[0]
147
          && (opcode >> 8 == 0 || opcode >> 8 == buffer[1]))
148
        {
149
          argp = votp->detail.args;
150
          break;
151
        }
152
    }
153
  if (argp == NULL)
154
    {
155
      /* Handle undefined instructions. */
156
      (*info->fprintf_func) (info->stream, ".word 0x%x",
157
                             (buffer[0] << 8) + buffer[1]);
158
      return 2;
159
    }
160
 
161
  /* Point at first byte of argument data, and at descriptor for first
162
     argument.  */
163
  arg = buffer + ((votp->detail.code >> 8) ? 2 : 1);
164
 
165
  /* Make sure we have it in mem */
166
  FETCH_DATA (info, arg);
167
 
168
  (*info->fprintf_func) (info->stream, "%s", votp->name);
169
  if (*argp)
170
    (*info->fprintf_func) (info->stream, " ");
171
 
172
  while (*argp)
173
    {
174
      arg += print_insn_arg (argp, arg, memaddr + arg - buffer, info);
175
      argp += 2;
176
      if (*argp)
177
        (*info->fprintf_func) (info->stream, ",");
178
    }
179
 
180
  return arg - buffer;
181
}
182
 
183
/* Returns number of bytes "eaten" by the operand, or return -1 if an
184
   invalid operand was found, or -2 if an opcode tabel error was
185
   found. */
186
 
187
static int
188
print_insn_arg (d, p0, addr, info)
189
     const char *d;
190
     unsigned char *p0;
191
     bfd_vma addr;              /* PC for this arg to be relative to */
192
     disassemble_info *info;
193
{
194
  int arg_len;
195
 
196
  /* check validity of addressing length */
197
  switch (d[1])
198
    {
199
    case 'b' : arg_len = 1;     break;
200
    case 'd' : arg_len = 8;     break;
201
    case 'f' : arg_len = 4;     break;
202
    case 'g' : arg_len = 8;     break;
203
    case 'h' : arg_len = 16;    break;
204
    case 'l' : arg_len = 4;     break;
205
    case 'o' : arg_len = 16;    break;
206
    case 'w' : arg_len = 2;     break;
207
    case 'q' : arg_len = 8;     break;
208
    default  : abort();
209
    }
210
 
211
  /* branches have no mode byte */
212
  if (d[0] == 'b')
213
    {
214
      unsigned char *p = p0;
215
 
216
      if (arg_len == 1)
217
        (*info->print_address_func) (addr + 1 + NEXTBYTE (p), info);
218
      else
219
        (*info->print_address_func) (addr + 2 + NEXTWORD (p), info);
220
 
221
      return p - p0;
222
    }
223
 
224
  return print_insn_mode (arg_len, p0, addr, info);
225
}
226
 
227
static int
228
print_insn_mode (size, p0, addr, info)
229
     int size;
230
     unsigned char *p0;
231
     bfd_vma addr;              /* PC for this arg to be relative to */
232
     disassemble_info *info;
233
{
234
  unsigned char *p = p0;
235
  unsigned char mode, reg;
236
 
237
  /* fetch and interpret mode byte */
238
  mode = (unsigned char) NEXTBYTE (p);
239
  reg = mode & 0xF;
240
  switch (mode & 0xF0)
241
    {
242
    case 0x00:
243
    case 0x10:
244
    case 0x20:
245
    case 0x30: /* literal mode                  $number */
246
      (*info->fprintf_func) (info->stream, "$0x%x", mode);
247
      break;
248
    case 0x40: /* index:                        base-addr[Rn] */
249
      p += print_insn_mode (size, p0 + 1, addr + 1, info);
250
      (*info->fprintf_func) (info->stream, "[%s]", reg_names[reg]);
251
      break;
252
    case 0x50: /* register:                     Rn */
253
      (*info->fprintf_func) (info->stream, "%s", reg_names[reg]);
254
      break;
255
    case 0x60: /* register deferred:            (Rn) */
256
      (*info->fprintf_func) (info->stream, "(%s)", reg_names[reg]);
257
      break;
258
    case 0x70: /* autodecrement:                -(Rn) */
259
      (*info->fprintf_func) (info->stream, "-(%s)", reg_names[reg]);
260
      break;
261
    case 0x80: /* autoincrement:                (Rn)+ */
262
      if (reg == 0xF)
263
        {       /* immediate? */
264
          int i;
265
 
266
          FETCH_DATA (info, p + size);
267
          (*info->fprintf_func) (info->stream, "$0x");
268
          for (i = 0; i < size; i++)
269
            (*info->fprintf_func) (info->stream, "%02x", p[size - i - 1]);
270
          p += size;
271
        }
272
      else
273
        (*info->fprintf_func) (info->stream, "(%s)+", reg_names[reg]);
274
      break;
275
    case 0x90: /* autoincrement deferred:       @(Rn)+ */
276
      if (reg == 0xF)
277
        (*info->fprintf_func) (info->stream, "*0x%x", NEXTLONG (p));
278
      else
279
        (*info->fprintf_func) (info->stream, "@(%s)+", reg_names[reg]);
280
      break;
281
    case 0xB0: /* displacement byte deferred:   *displ(Rn) */
282
      (*info->fprintf_func) (info->stream, "*");
283
    case 0xA0: /* displacement byte:            displ(Rn) */
284
      if (reg == 0xF)
285
        (*info->print_address_func) (addr + 2 + NEXTBYTE (p), info);
286
      else
287
        (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTBYTE (p),
288
                               reg_names[reg]);
289
      break;
290
    case 0xD0: /* displacement word deferred:   *displ(Rn) */
291
      (*info->fprintf_func) (info->stream, "*");
292
    case 0xC0: /* displacement word:            displ(Rn) */
293
      if (reg == 0xF)
294
        (*info->print_address_func) (addr + 3 + NEXTWORD (p), info);
295
      else
296
        (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTWORD (p),
297
                               reg_names[reg]);
298
      break;
299
    case 0xF0: /* displacement long deferred:   *displ(Rn) */
300
      (*info->fprintf_func) (info->stream, "*");
301
    case 0xE0: /* displacement long:            displ(Rn) */
302
      if (reg == 0xF)
303
        (*info->print_address_func) (addr + 5 + NEXTLONG (p), info);
304
      else
305
        (*info->fprintf_func) (info->stream, "0x%x(%s)", NEXTLONG (p),
306
                               reg_names[reg]);
307
      break;
308
    }
309
 
310
  return p - p0;
311
}

powered by: WebSVN 2.1.0

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