OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [opcodes/] [pdp11-dis.c] - Blame information for rev 165

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

Line No. Rev Author Line
1 24 jeremybenn 
/* Print DEC PDP-11 instructions.
2 
   Copyright 2001, 2002, 2004, 2005, 2007 Free Software Foundation, Inc.
3 
 
4 
   This file is part of the GNU opcodes library.
5 
 
6 
   This library is free software; you can redistribute it and/or modify
7 
   it under the terms of the GNU General Public License as published by
8 
   the Free Software Foundation; either version 3, or (at your option)
9 
   any later version.
10 
 
11 
   It is distributed in the hope that it will be useful, but WITHOUT
12 
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13 
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
14 
   License for more details.
15 
 
16 
   You should have received a copy of the GNU General Public License
17 
   along with this program; if not, write to the Free Software
18 
   Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 
   MA 02110-1301, USA.  */
20 
 
21 
#include "sysdep.h"
22 
#include "dis-asm.h"
23 
#include "opcode/pdp11.h"
24 
 
25 
#define AFTER_INSTRUCTION       "\t"
26 
#define OPERAND_SEPARATOR       ", "
27 
 
28 
#define JUMP    0x1000  /* Flag that this operand is used in a jump.  */
29 
 
30 
#define FPRINTF (*info->fprintf_func)
31 
#define F       info->stream
32 
 
33 
/* Sign-extend a 16-bit number in an int.  */
34 
#define SIGN_BITS       (8 * sizeof (int) - 16)
35 
#define sign_extend(x) (((x) << SIGN_BITS) >> SIGN_BITS)
36 
 
37 
static int
38 
read_word (bfd_vma memaddr, int *word, disassemble_info *info)
39 
{
40 
  int status;
41 
  bfd_byte x[2];
42 
 
43 
  status = (*info->read_memory_func) (memaddr, x, 2, info);
44 
  if (status != 0)
45 
    return -1;
46 
 
47 
  *word = x[1] << 8 | x[0];
48 
  return 0;
49 
}
50 
 
51 
static void
52 
print_signed_octal (int n, disassemble_info *info)
53 
{
54 
  if (n < 0)
55 
    FPRINTF (F, "-%o", -n);
56 
  else
57 
    FPRINTF (F, "%o", n);
58 
}
59 
 
60 
static void
61 
print_reg (int reg, disassemble_info *info)
62 
{
63 
  /* Mask off the addressing mode, if any.  */
64 
  reg &= 7;
65 
 
66 
  switch (reg)
67 
    {
68 
    case 0: case 1: case 2: case 3: case 4: case 5:
69 
                FPRINTF (F, "r%d", reg); break;
70 
    case 6:     FPRINTF (F, "sp"); break;
71 
    case 7:     FPRINTF (F, "pc"); break;
72 
    default: ;  /* error */
73 
    }
74 
}
75 
 
76 
static void
77 
print_freg (int freg, disassemble_info *info)
78 
{
79 
  FPRINTF (F, "fr%d", freg);
80 
}
81 
 
82 
static int
83 
print_operand (bfd_vma *memaddr, int code, disassemble_info *info)
84 
{
85 
  int mode = (code >> 3) & 7;
86 
  int reg = code & 7;
87 
  int disp;
88 
 
89 
  switch (mode)
90 
    {
91 
    case 0:
92 
      print_reg (reg, info);
93 
      break;
94 
    case 1:
95 
      FPRINTF (F, "(");
96 
      print_reg (reg, info);
97 
      FPRINTF (F, ")");
98 
      break;
99 
    case 2:
100 
      if (reg == 7)
101 
        {
102 
          int data;
103 
 
104 
          if (read_word (*memaddr, &data, info) < 0)
105 
            return -1;
106 
          FPRINTF (F, "$");
107 
          print_signed_octal (sign_extend (data), info);
108 
          *memaddr += 2;
109 
        }
110 
      else
111 
        {
112 
          FPRINTF (F, "(");
113 
          print_reg (reg, info);
114 
          FPRINTF (F, ")+");
115 
        }
116 
        break;
117 
    case 3:
118 
      if (reg == 7)
119 
        {
120 
          int address;
121 
 
122 
          if (read_word (*memaddr, &address, info) < 0)
123 
            return -1;
124 
          FPRINTF (F, "*$%o", address);
125 
          *memaddr += 2;
126 
        }
127 
      else
128 
        {
129 
          FPRINTF (F, "*(");
130 
          print_reg (reg, info);
131 
          FPRINTF (F, ")+");
132 
        }
133 
        break;
134 
    case 4:
135 
      FPRINTF (F, "-(");
136 
      print_reg (reg, info);
137 
      FPRINTF (F, ")");
138 
      break;
139 
    case 5:
140 
      FPRINTF (F, "*-(");
141 
      print_reg (reg, info);
142 
      FPRINTF (F, ")");
143 
      break;
144 
    case 6:
145 
    case 7:
146 
      if (read_word (*memaddr, &disp, info) < 0)
147 
        return -1;
148 
      *memaddr += 2;
149 
      if (reg == 7)
150 
        {
151 
          bfd_vma address = *memaddr + sign_extend (disp);
152 
 
153 
          if (mode == 7)
154 
            FPRINTF (F, "*");
155 
          if (!(code & JUMP))
156 
            FPRINTF (F, "$");
157 
          (*info->print_address_func) (address, info);
158 
        }
159 
      else
160 
        {
161 
          if (mode == 7)
162 
            FPRINTF (F, "*");
163 
          print_signed_octal (sign_extend (disp), info);
164 
          FPRINTF (F, "(");
165 
          print_reg (reg, info);
166 
          FPRINTF (F, ")");
167 
        }
168 
      break;
169 
    }
170 
 
171 
  return 0;
172 
}
173 
 
174 
static int
175 
print_foperand (bfd_vma *memaddr, int code, disassemble_info *info)
176 
{
177 
  int mode = (code >> 3) & 7;
178 
  int reg = code & 7;
179 
 
180 
  if (mode == 0)
181 
    print_freg (reg, info);
182 
  else
183 
    return print_operand (memaddr, code, info);
184 
 
185 
  return 0;
186 
}
187 
 
188 
/* Print the PDP-11 instruction at address MEMADDR in debugged memory,
189 
   on INFO->STREAM.  Returns length of the instruction, in bytes.  */
190 
 
191 
int
192 
print_insn_pdp11 (bfd_vma memaddr, disassemble_info *info)
193 
{
194 
  bfd_vma start_memaddr = memaddr;
195 
  int opcode;
196 
  int src, dst;
197 
  int i;
198 
 
199 
  info->bytes_per_line = 6;
200 
  info->bytes_per_chunk = 2;
201 
  info->display_endian = BFD_ENDIAN_LITTLE;
202 
 
203 
  if (read_word (memaddr, &opcode, info) != 0)
204 
    return -1;
205 
  memaddr += 2;
206 
 
207 
  src = (opcode >> 6) & 0x3f;
208 
  dst = opcode & 0x3f;
209 
 
210 
  for (i = 0; i < pdp11_num_opcodes; i++)
211 
    {
212 
#define OP pdp11_opcodes[i]
213 
      if ((opcode & OP.mask) == OP.opcode)
214 
        switch (OP.type)
215 
          {
216 
          case PDP11_OPCODE_NO_OPS:
217 
            FPRINTF (F, OP.name);
218 
            goto done;
219 
          case PDP11_OPCODE_REG:
220 
            FPRINTF (F, OP.name);
221 
            FPRINTF (F, AFTER_INSTRUCTION);
222 
            print_reg (dst, info);
223 
            goto done;
224 
          case PDP11_OPCODE_OP:
225 
            FPRINTF (F, OP.name);
226 
            FPRINTF (F, AFTER_INSTRUCTION);
227 
            if (strcmp (OP.name, "jmp") == 0)
228 
              dst |= JUMP;
229 
            if (print_operand (&memaddr, dst, info) < 0)
230 
              return -1;
231 
            goto done;
232 
          case PDP11_OPCODE_FOP:
233 
            FPRINTF (F, OP.name);
234 
            FPRINTF (F, AFTER_INSTRUCTION);
235 
            if (strcmp (OP.name, "jmp") == 0)
236 
              dst |= JUMP;
237 
            if (print_foperand (&memaddr, dst, info) < 0)
238 
              return -1;
239 
            goto done;
240 
          case PDP11_OPCODE_REG_OP:
241 
            FPRINTF (F, OP.name);
242 
            FPRINTF (F, AFTER_INSTRUCTION);
243 
            print_reg (src, info);
244 
            FPRINTF (F, OPERAND_SEPARATOR);
245 
            if (strcmp (OP.name, "jsr") == 0)
246 
              dst |= JUMP;
247 
            if (print_operand (&memaddr, dst, info) < 0)
248 
              return -1;
249 
            goto done;
250 
          case PDP11_OPCODE_REG_OP_REV:
251 
            FPRINTF (F, OP.name);
252 
            FPRINTF (F, AFTER_INSTRUCTION);
253 
            if (print_operand (&memaddr, dst, info) < 0)
254 
              return -1;
255 
            FPRINTF (F, OPERAND_SEPARATOR);
256 
            print_reg (src, info);
257 
            goto done;
258 
          case PDP11_OPCODE_AC_FOP:
259 
            {
260 
              int ac = (opcode & 0xe0) >> 6;
261 
              FPRINTF (F, OP.name);
262 
              FPRINTF (F, AFTER_INSTRUCTION);
263 
              print_freg (ac, info);
264 
              FPRINTF (F, OPERAND_SEPARATOR);
265 
              if (print_foperand (&memaddr, dst, info) < 0)
266 
                return -1;
267 
              goto done;
268 
            }
269 
          case PDP11_OPCODE_FOP_AC:
270 
            {
271 
              int ac = (opcode & 0xe0) >> 6;
272 
              FPRINTF (F, OP.name);
273 
              FPRINTF (F, AFTER_INSTRUCTION);
274 
              if (print_foperand (&memaddr, dst, info) < 0)
275 
                return -1;
276 
              FPRINTF (F, OPERAND_SEPARATOR);
277 
              print_freg (ac, info);
278 
              goto done;
279 
            }
280 
          case PDP11_OPCODE_AC_OP:
281 
            {
282 
              int ac = (opcode & 0xe0) >> 6;
283 
              FPRINTF (F, OP.name);
284 
              FPRINTF (F, AFTER_INSTRUCTION);
285 
              print_freg (ac, info);
286 
              FPRINTF (F, OPERAND_SEPARATOR);
287 
              if (print_operand (&memaddr, dst, info) < 0)
288 
                return -1;
289 
              goto done;
290 
            }
291 
          case PDP11_OPCODE_OP_AC:
292 
            {
293 
              int ac = (opcode & 0xe0) >> 6;
294 
              FPRINTF (F, OP.name);
295 
              FPRINTF (F, AFTER_INSTRUCTION);
296 
              if (print_operand (&memaddr, dst, info) < 0)
297 
                return -1;
298 
              FPRINTF (F, OPERAND_SEPARATOR);
299 
              print_freg (ac, info);
300 
              goto done;
301 
            }
302 
          case PDP11_OPCODE_OP_OP:
303 
            FPRINTF (F, OP.name);
304 
            FPRINTF (F, AFTER_INSTRUCTION);
305 
            if (print_operand (&memaddr, src, info) < 0)
306 
              return -1;
307 
            FPRINTF (F, OPERAND_SEPARATOR);
308 
            if (print_operand (&memaddr, dst, info) < 0)
309 
              return -1;
310 
            goto done;
311 
          case PDP11_OPCODE_DISPL:
312 
            {
313 
              int displ = (opcode & 0xff) << 8;
314 
              bfd_vma address = memaddr + (sign_extend (displ) >> 7);
315 
              FPRINTF (F, OP.name);
316 
              FPRINTF (F, AFTER_INSTRUCTION);
317 
              (*info->print_address_func) (address, info);
318 
              goto done;
319 
            }
320 
          case PDP11_OPCODE_REG_DISPL:
321 
            {
322 
              int displ = (opcode & 0x3f) << 10;
323 
              bfd_vma address = memaddr - (displ >> 9);
324 
 
325 
              FPRINTF (F, OP.name);
326 
              FPRINTF (F, AFTER_INSTRUCTION);
327 
              print_reg (src, info);
328 
              FPRINTF (F, OPERAND_SEPARATOR);
329 
              (*info->print_address_func) (address, info);
330 
              goto done;
331 
            }
332 
          case PDP11_OPCODE_IMM8:
333 
            {
334 
              int code = opcode & 0xff;
335 
              FPRINTF (F, OP.name);
336 
              FPRINTF (F, AFTER_INSTRUCTION);
337 
              FPRINTF (F, "%o", code);
338 
              goto done;
339 
            }
340 
          case PDP11_OPCODE_IMM6:
341 
            {
342 
              int code = opcode & 0x3f;
343 
              FPRINTF (F, OP.name);
344 
              FPRINTF (F, AFTER_INSTRUCTION);
345 
              FPRINTF (F, "%o", code);
346 
              goto done;
347 
            }
348 
          case PDP11_OPCODE_IMM3:
349 
            {
350 
              int code = opcode & 7;
351 
              FPRINTF (F, OP.name);
352 
              FPRINTF (F, AFTER_INSTRUCTION);
353 
              FPRINTF (F, "%o", code);
354 
              goto done;
355 
            }
356 
          case PDP11_OPCODE_ILLEGAL:
357 
            {
358 
              FPRINTF (F, ".word");
359 
              FPRINTF (F, AFTER_INSTRUCTION);
360 
              FPRINTF (F, "%o", opcode);
361 
              goto done;
362 
            }
363 
          default:
364 
            /* TODO: is this a proper way of signalling an error? */
365 
            FPRINTF (F, "<internal error: unrecognized instruction type>");
366 
            return -1;
367 
          }
368 
#undef OP
369 
    }
370 
 done:
371 
 
372 
  return memaddr - start_memaddr;
373 
}

powered by: WebSVN 2.1.0

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