pdp11-dis.c revision 1.1.1.6
1 /* Print DEC PDP-11 instructions. 2 Copyright (C) 2001-2020 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 "disassemble.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_extend(x) ((((x) & 0xffff) ^ 0x8000) - 0x8000) 35 36 static int 37 read_word (bfd_vma memaddr, int *word, disassemble_info *info) 38 { 39 int status; 40 bfd_byte x[2]; 41 42 status = (*info->read_memory_func) (memaddr, x, 2, info); 43 if (status != 0) 44 return -1; 45 46 *word = x[1] << 8 | x[0]; 47 return 0; 48 } 49 50 static void 51 print_signed_octal (int n, disassemble_info *info) 52 { 53 if (n < 0) 54 FPRINTF (F, "-%o", -n); 55 else 56 FPRINTF (F, "%o", n); 57 } 58 59 static void 60 print_reg (int reg, disassemble_info *info) 61 { 62 /* Mask off the addressing mode, if any. */ 63 reg &= 7; 64 65 switch (reg) 66 { 67 case 0: case 1: case 2: case 3: case 4: case 5: 68 FPRINTF (F, "r%d", reg); break; 69 case 6: FPRINTF (F, "sp"); break; 70 case 7: FPRINTF (F, "pc"); break; 71 default: ; /* error */ 72 } 73 } 74 75 static void 76 print_freg (int freg, disassemble_info *info) 77 { 78 FPRINTF (F, "fr%d", freg); 79 } 80 81 static int 82 print_operand (bfd_vma *memaddr, int code, disassemble_info *info) 83 { 84 int mode = (code >> 3) & 7; 85 int reg = code & 7; 86 int disp; 87 88 switch (mode) 89 { 90 case 0: 91 print_reg (reg, info); 92 break; 93 case 1: 94 FPRINTF (F, "("); 95 print_reg (reg, info); 96 FPRINTF (F, ")"); 97 break; 98 case 2: 99 if (reg == 7) 100 { 101 int data; 102 103 if (read_word (*memaddr, &data, info) < 0) 104 return -1; 105 FPRINTF (F, "$"); 106 print_signed_octal (sign_extend (data), info); 107 *memaddr += 2; 108 } 109 else 110 { 111 FPRINTF (F, "("); 112 print_reg (reg, info); 113 FPRINTF (F, ")+"); 114 } 115 break; 116 case 3: 117 if (reg == 7) 118 { 119 int address; 120 121 if (read_word (*memaddr, &address, info) < 0) 122 return -1; 123 FPRINTF (F, "*$%o", address); 124 *memaddr += 2; 125 } 126 else 127 { 128 FPRINTF (F, "*("); 129 print_reg (reg, info); 130 FPRINTF (F, ")+"); 131 } 132 break; 133 case 4: 134 FPRINTF (F, "-("); 135 print_reg (reg, info); 136 FPRINTF (F, ")"); 137 break; 138 case 5: 139 FPRINTF (F, "*-("); 140 print_reg (reg, info); 141 FPRINTF (F, ")"); 142 break; 143 case 6: 144 case 7: 145 if (read_word (*memaddr, &disp, info) < 0) 146 return -1; 147 *memaddr += 2; 148 if (reg == 7) 149 { 150 bfd_vma address = *memaddr + sign_extend (disp); 151 152 if (mode == 7) 153 FPRINTF (F, "*"); 154 if (!(code & JUMP)) 155 FPRINTF (F, "$"); 156 (*info->print_address_func) (address, info); 157 } 158 else 159 { 160 if (mode == 7) 161 FPRINTF (F, "*"); 162 print_signed_octal (sign_extend (disp), info); 163 FPRINTF (F, "("); 164 print_reg (reg, info); 165 FPRINTF (F, ")"); 166 } 167 break; 168 } 169 170 return 0; 171 } 172 173 static int 174 print_foperand (bfd_vma *memaddr, int code, disassemble_info *info) 175 { 176 int mode = (code >> 3) & 7; 177 int reg = code & 7; 178 179 if (mode == 0) 180 print_freg (reg, info); 181 else 182 return print_operand (memaddr, code, info); 183 184 return 0; 185 } 186 187 /* Print the PDP-11 instruction at address MEMADDR in debugged memory, 188 on INFO->STREAM. Returns length of the instruction, in bytes. */ 189 190 int 191 print_insn_pdp11 (bfd_vma memaddr, disassemble_info *info) 192 { 193 bfd_vma start_memaddr = memaddr; 194 int opcode; 195 int src, dst; 196 int i; 197 198 info->bytes_per_line = 6; 199 info->bytes_per_chunk = 2; 200 info->display_endian = BFD_ENDIAN_LITTLE; 201 202 if (read_word (memaddr, &opcode, info) != 0) 203 return -1; 204 memaddr += 2; 205 206 src = (opcode >> 6) & 0x3f; 207 dst = opcode & 0x3f; 208 209 for (i = 0; i < pdp11_num_opcodes; i++) 210 { 211 #define OP pdp11_opcodes[i] 212 if ((opcode & OP.mask) == OP.opcode) 213 switch (OP.type) 214 { 215 case PDP11_OPCODE_NO_OPS: 216 FPRINTF (F, "%s", OP.name); 217 goto done; 218 case PDP11_OPCODE_REG: 219 FPRINTF (F, "%s", OP.name); 220 FPRINTF (F, AFTER_INSTRUCTION); 221 print_reg (dst, info); 222 goto done; 223 case PDP11_OPCODE_OP: 224 FPRINTF (F, "%s", OP.name); 225 FPRINTF (F, AFTER_INSTRUCTION); 226 if (strcmp (OP.name, "jmp") == 0) 227 dst |= JUMP; 228 if (print_operand (&memaddr, dst, info) < 0) 229 return -1; 230 goto done; 231 case PDP11_OPCODE_FOP: 232 FPRINTF (F, "%s", OP.name); 233 FPRINTF (F, AFTER_INSTRUCTION); 234 if (strcmp (OP.name, "jmp") == 0) 235 dst |= JUMP; 236 if (print_foperand (&memaddr, dst, info) < 0) 237 return -1; 238 goto done; 239 case PDP11_OPCODE_REG_OP: 240 FPRINTF (F, "%s", OP.name); 241 FPRINTF (F, AFTER_INSTRUCTION); 242 print_reg (src, info); 243 FPRINTF (F, OPERAND_SEPARATOR); 244 if (strcmp (OP.name, "jsr") == 0) 245 dst |= JUMP; 246 if (print_operand (&memaddr, dst, info) < 0) 247 return -1; 248 goto done; 249 case PDP11_OPCODE_REG_OP_REV: 250 FPRINTF (F, "%s", OP.name); 251 FPRINTF (F, AFTER_INSTRUCTION); 252 if (print_operand (&memaddr, dst, info) < 0) 253 return -1; 254 FPRINTF (F, OPERAND_SEPARATOR); 255 print_reg (src, info); 256 goto done; 257 case PDP11_OPCODE_AC_FOP: 258 { 259 int ac = (opcode & 0xe0) >> 6; 260 FPRINTF (F, "%s", OP.name); 261 FPRINTF (F, AFTER_INSTRUCTION); 262 print_freg (ac, info); 263 FPRINTF (F, OPERAND_SEPARATOR); 264 if (print_foperand (&memaddr, dst, info) < 0) 265 return -1; 266 goto done; 267 } 268 case PDP11_OPCODE_FOP_AC: 269 { 270 int ac = (opcode & 0xe0) >> 6; 271 FPRINTF (F, "%s", OP.name); 272 FPRINTF (F, AFTER_INSTRUCTION); 273 if (print_foperand (&memaddr, dst, info) < 0) 274 return -1; 275 FPRINTF (F, OPERAND_SEPARATOR); 276 print_freg (ac, info); 277 goto done; 278 } 279 case PDP11_OPCODE_AC_OP: 280 { 281 int ac = (opcode & 0xe0) >> 6; 282 FPRINTF (F, "%s", OP.name); 283 FPRINTF (F, AFTER_INSTRUCTION); 284 print_freg (ac, info); 285 FPRINTF (F, OPERAND_SEPARATOR); 286 if (print_operand (&memaddr, dst, info) < 0) 287 return -1; 288 goto done; 289 } 290 case PDP11_OPCODE_OP_AC: 291 { 292 int ac = (opcode & 0xe0) >> 6; 293 FPRINTF (F, "%s", OP.name); 294 FPRINTF (F, AFTER_INSTRUCTION); 295 if (print_operand (&memaddr, dst, info) < 0) 296 return -1; 297 FPRINTF (F, OPERAND_SEPARATOR); 298 print_freg (ac, info); 299 goto done; 300 } 301 case PDP11_OPCODE_OP_OP: 302 FPRINTF (F, "%s", OP.name); 303 FPRINTF (F, AFTER_INSTRUCTION); 304 if (print_operand (&memaddr, src, info) < 0) 305 return -1; 306 FPRINTF (F, OPERAND_SEPARATOR); 307 if (print_operand (&memaddr, dst, info) < 0) 308 return -1; 309 goto done; 310 case PDP11_OPCODE_DISPL: 311 { 312 int displ = (opcode & 0xff) << 8; 313 bfd_vma address = memaddr + (sign_extend (displ) >> 7); 314 FPRINTF (F, "%s", OP.name); 315 FPRINTF (F, AFTER_INSTRUCTION); 316 (*info->print_address_func) (address, info); 317 goto done; 318 } 319 case PDP11_OPCODE_REG_DISPL: 320 { 321 int displ = (opcode & 0x3f) << 10; 322 bfd_vma address = memaddr - (displ >> 9); 323 324 FPRINTF (F, "%s", OP.name); 325 FPRINTF (F, AFTER_INSTRUCTION); 326 print_reg (src, info); 327 FPRINTF (F, OPERAND_SEPARATOR); 328 (*info->print_address_func) (address, info); 329 goto done; 330 } 331 case PDP11_OPCODE_IMM8: 332 { 333 int code = opcode & 0xff; 334 FPRINTF (F, "%s", OP.name); 335 FPRINTF (F, AFTER_INSTRUCTION); 336 FPRINTF (F, "%o", code); 337 goto done; 338 } 339 case PDP11_OPCODE_IMM6: 340 { 341 int code = opcode & 0x3f; 342 FPRINTF (F, "%s", OP.name); 343 FPRINTF (F, AFTER_INSTRUCTION); 344 FPRINTF (F, "%o", code); 345 goto done; 346 } 347 case PDP11_OPCODE_IMM3: 348 { 349 int code = opcode & 7; 350 FPRINTF (F, "%s", OP.name); 351 FPRINTF (F, AFTER_INSTRUCTION); 352 FPRINTF (F, "%o", code); 353 goto done; 354 } 355 case PDP11_OPCODE_ILLEGAL: 356 { 357 FPRINTF (F, ".word"); 358 FPRINTF (F, AFTER_INSTRUCTION); 359 FPRINTF (F, "%o", opcode); 360 goto done; 361 } 362 default: 363 /* TODO: is this a proper way of signalling an error? */ 364 FPRINTF (F, "<internal error: unrecognized instruction type>"); 365 return -1; 366 } 367 #undef OP 368 } 369 done: 370 371 return memaddr - start_memaddr; 372 } 373
Indexes created Tue Jul 28 00:24:17 UTC 2026