1 /* Print VAX instructions for GDB, the GNU debugger. 2 3 Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 4 2002, 2003, 2004 Free Software Foundation, Inc. 5 6 This file is part of GDB. 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place - Suite 330, 21 Boston, MA 02111-1307, USA. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "opcode/vax.h" 26 #include "gdbcore.h" 27 #include "inferior.h" 28 #include "regcache.h" 29 #include "frame.h" 30 #include "frame-base.h" 31 #include "frame-unwind.h" 32 #include "trad-frame.h" 33 #include "value.h" 34 #include "arch-utils.h" 35 #include "osabi.h" 36 #include "dis-asm.h" 37 #include "regset.h" 38 39 #include "gdb_string.h" 40 41 #include "vax-tdep.h" 42 43 /* Return the name of register REGNUM. */ 44 45 static const char * 46 vax_register_name (int regnum) 47 { 48 static char *register_names[] = 49 { 50 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", 51 "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc", 52 "ps", 53 }; 54 55 if (regnum >= 0 && regnum < ARRAY_SIZE (register_names)) 56 return register_names[regnum]; 57 58 return NULL; 59 } 60 61 /* Return the GDB type object for the "standard" data type of data in 62 register REGNUM. */ 63 64 static struct type * 65 vax_register_type (struct gdbarch *gdbarch, int regnum) 66 { 67 return builtin_type_int; 68 } 69 70 /* Core file support. */ 71 72 /* Supply register REGNUM from the buffer specified by GREGS and LEN 73 in the general-purpose register set REGSET to register cache 74 REGCACHE. If REGNUM is -1, do this for all registers in REGSET. */ 75 76 static void 77 vax_supply_gregset (const struct regset *regset, struct regcache *regcache, 78 int regnum, const void *gregs, size_t len) 79 { 80 const char *regs = gregs; 81 int i; 82 83 for (i = 0; i < VAX_NUM_REGS; i++) 84 { 85 if (regnum == i || regnum == -1) 86 regcache_raw_supply (regcache, i, regs + i * 4); 87 } 88 } 89 90 /* VAX register set. */ 91 92 static struct regset vax_gregset = 93 { 94 NULL, 95 vax_supply_gregset 96 }; 97 98 /* Return the appropriate register set for the core section identified 99 by SECT_NAME and SECT_SIZE. */ 100 101 static const struct regset * 102 vax_regset_from_core_section (struct gdbarch *gdbarch, 103 const char *sect_name, size_t sect_size) 104 { 105 if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4) 106 return &vax_gregset; 107 108 return NULL; 109 } 110 111 /* The VAX Unix calling convention uses R1 to pass a structure return 112 value address instead of passing it as a first (hidden) argument as 113 the VMS calling convention suggests. */ 114 115 static CORE_ADDR 116 vax_store_arguments (struct regcache *regcache, int nargs, 117 struct value **args, CORE_ADDR sp) 118 { 119 char buf[4]; 120 int count = 0; 121 int i; 122 123 /* We create an argument list on the stack, and make the argument 124 pointer to it. */ 125 126 /* Push arguments in reverse order. */ 127 for (i = nargs - 1; i >= 0; i--) 128 { 129 int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); 130 131 sp -= (len + 3) & ~3; 132 count += (len + 3) / 4; 133 write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len); 134 } 135 136 /* Push argument count. */ 137 sp -= 4; 138 store_unsigned_integer (buf, 4, count); 139 write_memory (sp, buf, 4); 140 141 /* Update the argument pointer. */ 142 store_unsigned_integer (buf, 4, sp); 143 regcache_cooked_write (regcache, VAX_AP_REGNUM, buf); 144 145 return sp; 146 } 147 148 static CORE_ADDR 149 vax_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr, 150 struct regcache *regcache, CORE_ADDR bp_addr, int nargs, 151 struct value **args, CORE_ADDR sp, int struct_return, 152 CORE_ADDR struct_addr) 153 { 154 CORE_ADDR fp = sp; 155 char buf[4]; 156 157 /* Set up the function arguments. */ 158 sp = vax_store_arguments (regcache, nargs, args, sp); 159 160 /* Store return value address. */ 161 if (struct_return) 162 regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr); 163 164 /* Store return address in the PC slot. */ 165 sp -= 4; 166 store_unsigned_integer (buf, 4, bp_addr); 167 write_memory (sp, buf, 4); 168 169 /* Store the (fake) frame pointer in the FP slot. */ 170 sp -= 4; 171 store_unsigned_integer (buf, 4, fp); 172 write_memory (sp, buf, 4); 173 174 /* Skip the AP slot. */ 175 sp -= 4; 176 177 /* Store register save mask and control bits. */ 178 sp -= 4; 179 store_unsigned_integer (buf, 4, 0); 180 write_memory (sp, buf, 4); 181 182 /* Store condition handler. */ 183 sp -= 4; 184 store_unsigned_integer (buf, 4, 0); 185 write_memory (sp, buf, 4); 186 187 /* Update the stack pointer and frame pointer. */ 188 store_unsigned_integer (buf, 4, sp); 189 regcache_cooked_write (regcache, VAX_SP_REGNUM, buf); 190 regcache_cooked_write (regcache, VAX_FP_REGNUM, buf); 191 192 /* Return the saved (fake) frame pointer. */ 193 return fp; 194 } 195 196 static struct frame_id 197 vax_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame) 198 { 199 CORE_ADDR fp; 200 201 fp = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM); 202 return frame_id_build (fp, frame_pc_unwind (next_frame)); 203 } 204 205 206 static enum return_value_convention 207 vax_return_value (struct gdbarch *gdbarch, struct type *type, 208 struct regcache *regcache, void *readbuf, 209 const void *writebuf) 210 { 211 int len = TYPE_LENGTH (type); 212 char buf[8]; 213 214 if (TYPE_CODE (type) == TYPE_CODE_STRUCT 215 || TYPE_CODE (type) == TYPE_CODE_STRUCT 216 || TYPE_CODE (type) == TYPE_CODE_ARRAY) 217 return RETURN_VALUE_STRUCT_CONVENTION; 218 219 if (readbuf) 220 { 221 /* Read the contents of R0 and (if necessary) R1. */ 222 regcache_cooked_read (regcache, VAX_R0_REGNUM, buf); 223 if (len > 4) 224 regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4); 225 memcpy (readbuf, buf, len); 226 } 227 if (writebuf) 228 { 229 /* Read the contents to R0 and (if necessary) R1. */ 230 memcpy (buf, writebuf, len); 231 regcache_cooked_write (regcache, VAX_R0_REGNUM, buf); 232 if (len > 4) 233 regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4); 234 } 235 236 return RETURN_VALUE_REGISTER_CONVENTION; 237 } 238 239 240 /* Use the program counter to determine the contents and size of a 241 breakpoint instruction. Return a pointer to a string of bytes that 242 encode a breakpoint instruction, store the length of the string in 243 *LEN and optionally adjust *PC to point to the correct memory 244 location for inserting the breakpoint. */ 245 246 static const unsigned char * 247 vax_breakpoint_from_pc (CORE_ADDR *pc, int *len) 248 { 249 static unsigned char break_insn[] = { 3 }; 250 251 *len = sizeof (break_insn); 252 return break_insn; 253 } 254 255 /* Advance PC across any function entry prologue instructions 256 to reach some "real" code. */ 257 258 static CORE_ADDR 259 vax_skip_prologue (CORE_ADDR pc) 260 { 261 int op = (unsigned char) read_memory_integer (pc, 1); 262 if (op == 0x11) 263 pc += 2; /* skip brb */ 264 if (op == 0x31) 265 pc += 3; /* skip brw */ 266 if (op == 0xC2 267 && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E) 268 pc += 3; /* skip subl2 */ 269 if (op == 0x9E 270 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE 271 && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E) 272 pc += 4; /* skip movab */ 273 if (op == 0x9E 274 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE 275 && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E) 276 pc += 5; /* skip movab */ 277 if (op == 0x9E 278 && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE 279 && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E) 280 pc += 7; /* skip movab */ 281 return pc; 282 } 283 284 285 /* Unwinding the stack is relatively easy since the VAX has a 286 dedicated frame pointer, and frames are set up automatically as the 287 result of a function call. Most of the relevant information can be 288 inferred from the documentation of the Procedure Call Instructions 289 in the VAX MACRO and Instruction Set Reference Manual. */ 290 291 struct vax_frame_cache 292 { 293 /* Base address. */ 294 CORE_ADDR base; 295 296 /* Table of saved registers. */ 297 struct trad_frame_saved_reg *saved_regs; 298 }; 299 300 struct vax_frame_cache * 301 vax_frame_cache (struct frame_info *next_frame, void **this_cache) 302 { 303 struct vax_frame_cache *cache; 304 CORE_ADDR addr; 305 ULONGEST mask; 306 int regnum; 307 308 if (*this_cache) 309 return *this_cache; 310 311 /* Allocate a new cache. */ 312 cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache); 313 cache->saved_regs = trad_frame_alloc_saved_regs (next_frame); 314 315 /* The frame pointer is used as the base for the frame. */ 316 cache->base = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM); 317 if (cache->base == 0) 318 return cache; 319 320 /* The register save mask and control bits determine the layout of 321 the stack frame. */ 322 mask = get_frame_memory_unsigned (next_frame, cache->base + 4, 4) >> 16; 323 324 /* These are always saved. */ 325 cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16; 326 cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12; 327 cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8; 328 cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4; 329 330 /* Scan the register save mask and record the location of the saved 331 registers. */ 332 addr = cache->base + 20; 333 for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++) 334 { 335 if (mask & (1 << regnum)) 336 { 337 cache->saved_regs[regnum].addr = addr; 338 addr += 4; 339 } 340 } 341 342 /* The CALLS/CALLG flag determines whether this frame has a General 343 Argument List or a Stack Argument List. */ 344 if (mask & (1 << 13)) 345 { 346 ULONGEST numarg; 347 348 /* This is a procedure with Stack Argument List. Adjust the 349 stack address for the arguments that were pushed onto the 350 stack. The return instruction will automatically pop the 351 arguments from the stack. */ 352 numarg = get_frame_memory_unsigned (next_frame, addr, 1); 353 addr += 4 + numarg * 4; 354 } 355 356 /* Bits 1:0 of the stack pointer were saved in the control bits. */ 357 trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14)); 358 359 return cache; 360 } 361 362 static void 363 vax_frame_this_id (struct frame_info *next_frame, void **this_cache, 364 struct frame_id *this_id) 365 { 366 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); 367 368 /* This marks the outermost frame. */ 369 if (cache->base == 0) 370 return; 371 372 (*this_id) = frame_id_build (cache->base, frame_pc_unwind (next_frame)); 373 } 374 375 static void 376 vax_frame_prev_register (struct frame_info *next_frame, void **this_cache, 377 int regnum, int *optimizedp, 378 enum lval_type *lvalp, CORE_ADDR *addrp, 379 int *realnump, void *valuep) 380 { 381 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); 382 383 trad_frame_prev_register (next_frame, cache->saved_regs, regnum, 384 optimizedp, lvalp, addrp, realnump, valuep); 385 } 386 387 static const struct frame_unwind vax_frame_unwind = 388 { 389 NORMAL_FRAME, 390 vax_frame_this_id, 391 vax_frame_prev_register 392 }; 393 394 static const struct frame_unwind * 395 vax_frame_sniffer (struct frame_info *next_frame) 396 { 397 return &vax_frame_unwind; 398 } 399 400 401 static CORE_ADDR 402 vax_frame_base_address (struct frame_info *next_frame, void **this_cache) 403 { 404 struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache); 405 406 return cache->base; 407 } 408 409 static CORE_ADDR 410 vax_frame_args_address (struct frame_info *next_frame, void **this_cache) 411 { 412 return frame_unwind_register_unsigned (next_frame, VAX_AP_REGNUM); 413 } 414 415 static const struct frame_base vax_frame_base = 416 { 417 &vax_frame_unwind, 418 vax_frame_base_address, 419 vax_frame_base_address, 420 vax_frame_args_address 421 }; 422 423 /* Return number of arguments for FRAME. */ 424 425 static int 426 vax_frame_num_args (struct frame_info *frame) 427 { 428 CORE_ADDR args; 429 430 /* Assume that the argument pointer for the outermost frame is 431 hosed, as is the case on NetBSD/vax ELF. */ 432 if (get_frame_base (frame) == 0) 433 return 0; 434 435 args = get_frame_register_unsigned (frame, VAX_AP_REGNUM); 436 return get_frame_memory_unsigned (frame, args, 1); 437 } 438 439 static CORE_ADDR 440 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame) 441 { 442 return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM); 443 } 444 445 446 /* Initialize the current architecture based on INFO. If possible, re-use an 447 architecture from ARCHES, which is a list of architectures already created 448 during this debugging session. 449 450 Called e.g. at program startup, when reading a core file, and when reading 451 a binary file. */ 452 453 static struct gdbarch * 454 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches) 455 { 456 struct gdbarch *gdbarch; 457 458 /* If there is already a candidate, use it. */ 459 arches = gdbarch_list_lookup_by_info (arches, &info); 460 if (arches != NULL) 461 return arches->gdbarch; 462 463 gdbarch = gdbarch_alloc (&info, NULL); 464 465 /* Register info */ 466 set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS); 467 set_gdbarch_register_name (gdbarch, vax_register_name); 468 set_gdbarch_register_type (gdbarch, vax_register_type); 469 set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM); 470 set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM); 471 set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM); 472 473 set_gdbarch_regset_from_core_section 474 (gdbarch, vax_regset_from_core_section); 475 476 /* Frame and stack info */ 477 set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue); 478 set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args); 479 480 set_gdbarch_frame_args_skip (gdbarch, 4); 481 482 /* Stack grows downward. */ 483 set_gdbarch_inner_than (gdbarch, core_addr_lessthan); 484 485 /* Return value info */ 486 set_gdbarch_return_value (gdbarch, vax_return_value); 487 488 /* Call dummy code. */ 489 set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call); 490 set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id); 491 492 /* Breakpoint info */ 493 set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc); 494 495 /* Misc info */ 496 set_gdbarch_function_start_offset (gdbarch, 2); 497 set_gdbarch_believe_pcc_promotion (gdbarch, 1); 498 499 set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc); 500 501 frame_base_set_default (gdbarch, &vax_frame_base); 502 503 /* Hook in ABI-specific overrides, if they have been registered. */ 504 gdbarch_init_osabi (info, gdbarch); 505 506 frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer); 507 508 set_gdbarch_print_insn (gdbarch, print_insn_vax); 509 510 return (gdbarch); 511 } 512 513 extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */ 514 515 void 516 _initialize_vax_tdep (void) 517 { 518 gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL); 519 } 520