opcodes/pdp11-dis.c

   1 /* 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 }