gdb/vax-tdep.c

   1 /* Target-dependent code for the VAX.
   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 "arch-utils.h"
  25 #include "dis-asm.h"
  26 #include "frame.h"
  27 #include "frame-base.h"
  28 #include "frame-unwind.h"
  29 #include "gdbcore.h"
  30 #include "gdbtypes.h"
  31 #include "osabi.h"
  32 #include "regcache.h"
  33 #include "regset.h"
  34 #include "trad-frame.h"
  35 #include "value.h"
  36
  37 #include "gdb_string.h"
  38
  39 #include "vax-tdep.h"
  40
  41 /* Return the name of register REGNUM.  */
  42
  43 static const char *
  44 vax_register_name (int regnum)
  45 {
  46   static char *register_names[] =
  47   {
  48     "r0", "r1", "r2",  "r3",  "r4", "r5", "r6", "r7",
  49     "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
  50     "ps",
  51   };
  52
  53   if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
  54     return register_names[regnum];
  55
  56   return NULL;
  57 }
  58
  59 /* Return the GDB type object for the "standard" data type of data in
  60    register REGNUM. */
  61
  62 static struct type *
  63 vax_register_type (struct gdbarch *gdbarch, int regnum)
  64 {
  65   return builtin_type_int;
  66 }
  67 \f
  68 /* Core file support.  */
  69
  70 /* Supply register REGNUM from the buffer specified by GREGS and LEN
  71    in the general-purpose register set REGSET to register cache
  72    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  73
  74 static void
  75 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
  76                     int regnum, const void *gregs, size_t len)
  77 {
  78   const char *regs = gregs;
  79   int i;
  80
  81   for (i = 0; i < VAX_NUM_REGS; i++)
  82     {
  83       if (regnum == i || regnum == -1)
  84         regcache_raw_supply (regcache, i, regs + i * 4);
  85     }
  86 }
  87
  88 /* VAX register set.  */
  89
  90 static struct regset vax_gregset =
  91 {
  92   NULL,
  93   vax_supply_gregset
  94 };
  95
  96 /* Return the appropriate register set for the core section identified
  97    by SECT_NAME and SECT_SIZE.  */
  98
  99 static const struct regset *
 100 vax_regset_from_core_section (struct gdbarch *gdbarch,
 101                               const char *sect_name, size_t sect_size)
 102 {
 103   if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4)
 104     return &vax_gregset;
 105
 106   return NULL;
 107 }
 108 \f
 109 /* The VAX Unix calling convention uses R1 to pass a structure return
 110    value address instead of passing it as a first (hidden) argument as
 111    the VMS calling convention suggests.  */
 112
 113 static CORE_ADDR
 114 vax_store_arguments (struct regcache *regcache, int nargs,
 115                      struct value **args, CORE_ADDR sp)
 116 {
 117   char buf[4];
 118   int count = 0;
 119   int i;
 120
 121   /* We create an argument list on the stack, and make the argument
 122      pointer to it.  */
 123
 124   /* Push arguments in reverse order.  */
 125   for (i = nargs - 1; i >= 0; i--)
 126     {
 127       int len = TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i]));
 128
 129       sp -= (len + 3) & ~3;
 130       count += (len + 3) / 4;
 131       write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
 132     }
 133
 134   /* Push argument count.  */
 135   sp -= 4;
 136   store_unsigned_integer (buf, 4, count);
 137   write_memory (sp, buf, 4);
 138
 139   /* Update the argument pointer.  */
 140   store_unsigned_integer (buf, 4, sp);
 141   regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
 142
 143   return sp;
 144 }
 145
 146 static CORE_ADDR
 147 vax_push_dummy_call (struct gdbarch *gdbarch, CORE_ADDR func_addr,
 148                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 149                      struct value **args, CORE_ADDR sp, int struct_return,
 150                      CORE_ADDR struct_addr)
 151 {
 152   CORE_ADDR fp = sp;
 153   char buf[4];
 154
 155   /* Set up the function arguments.  */
 156   sp = vax_store_arguments (regcache, nargs, args, sp);
 157
 158   /* Store return value address.  */
 159   if (struct_return)
 160     regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
 161
 162   /* Store return address in the PC slot.  */
 163   sp -= 4;
 164   store_unsigned_integer (buf, 4, bp_addr);
 165   write_memory (sp, buf, 4);
 166
 167   /* Store the (fake) frame pointer in the FP slot.  */
 168   sp -= 4;
 169   store_unsigned_integer (buf, 4, fp);
 170   write_memory (sp, buf, 4);
 171
 172   /* Skip the AP slot.  */
 173   sp -= 4;
 174
 175   /* Store register save mask and control bits.  */
 176   sp -= 4;
 177   store_unsigned_integer (buf, 4, 0);
 178   write_memory (sp, buf, 4);
 179
 180   /* Store condition handler.  */
 181   sp -= 4;
 182   store_unsigned_integer (buf, 4, 0);
 183   write_memory (sp, buf, 4);
 184
 185   /* Update the stack pointer and frame pointer.  */
 186   store_unsigned_integer (buf, 4, sp);
 187   regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
 188   regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
 189
 190   /* Return the saved (fake) frame pointer.  */
 191   return fp;
 192 }
 193
 194 static struct frame_id
 195 vax_unwind_dummy_id (struct gdbarch *gdbarch, struct frame_info *next_frame)
 196 {
 197   CORE_ADDR fp;
 198
 199   fp = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
 200   return frame_id_build (fp, frame_pc_unwind (next_frame));
 201 }
 202 \f
 203
 204 static enum return_value_convention
 205 vax_return_value (struct gdbarch *gdbarch, struct type *type,
 206                   struct regcache *regcache, void *readbuf,
 207                   const void *writebuf)
 208 {
 209   int len = TYPE_LENGTH (type);
 210   char buf[8];
 211
 212   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 213       || TYPE_CODE (type) == TYPE_CODE_STRUCT
 214       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
 215     return RETURN_VALUE_STRUCT_CONVENTION;
 216
 217   if (readbuf)
 218     {
 219       /* Read the contents of R0 and (if necessary) R1.  */
 220       regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
 221       if (len > 4)
 222         regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
 223       memcpy (readbuf, buf, len);
 224     }
 225   if (writebuf)
 226     {
 227       /* Read the contents to R0 and (if necessary) R1.  */
 228       memcpy (buf, writebuf, len);
 229       regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
 230       if (len > 4)
 231         regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
 232     }
 233
 234   return RETURN_VALUE_REGISTER_CONVENTION;
 235 }
 236 \f
 237
 238 /* Use the program counter to determine the contents and size of a
 239    breakpoint instruction.  Return a pointer to a string of bytes that
 240    encode a breakpoint instruction, store the length of the string in
 241    *LEN and optionally adjust *PC to point to the correct memory
 242    location for inserting the breakpoint.  */
 243
 244 static const unsigned char *
 245 vax_breakpoint_from_pc (CORE_ADDR *pc, int *len)
 246 {
 247   static unsigned char break_insn[] = { 3 };
 248
 249   *len = sizeof (break_insn);
 250   return break_insn;
 251 }
 252 \f
 253 /* Advance PC across any function entry prologue instructions
 254    to reach some "real" code.  */
 255
 256 static CORE_ADDR
 257 vax_skip_prologue (CORE_ADDR pc)
 258 {
 259   unsigned char op = read_memory_unsigned_integer (pc, 1);
 260
 261   if (op == 0x11)
 262     pc += 2;                    /* skip brb */
 263   if (op == 0x31)
 264     pc += 3;                    /* skip brw */
 265   if (op == 0xC2
 266       && (read_memory_unsigned_integer (pc + 2, 1)) == 0x5E)
 267     pc += 3;                    /* skip subl2 */
 268   if (op == 0x9E
 269       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xAE
 270       && (read_memory_unsigned_integer (pc + 3, 1)) == 0x5E)
 271     pc += 4;                    /* skip movab */
 272   if (op == 0x9E
 273       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xCE
 274       && (read_memory_unsigned_integer (pc + 4, 1)) == 0x5E)
 275     pc += 5;                    /* skip movab */
 276   if (op == 0x9E
 277       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xEE
 278       && (read_memory_unsigned_integer (pc + 6, 1)) == 0x5E)
 279     pc += 7;                    /* skip movab */
 280
 281   return pc;
 282 }
 283 \f
 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 \f
 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_address (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 \f
 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   set_gdbarch_frame_args_skip (gdbarch, 4);
 480
 481   /* Stack grows downward.  */
 482   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 483
 484   /* Return value info */
 485   set_gdbarch_return_value (gdbarch, vax_return_value);
 486
 487   /* Call dummy code.  */
 488   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
 489   set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id);
 490
 491   /* Breakpoint info */
 492   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 493
 494   /* Misc info */
 495   set_gdbarch_function_start_offset (gdbarch, 2);
 496   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 497
 498   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 499
 500   set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
 501
 502   frame_base_set_default (gdbarch, &vax_frame_base);
 503
 504   /* Hook in ABI-specific overrides, if they have been registered.  */
 505   gdbarch_init_osabi (info, gdbarch);
 506
 507   frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer);
 508
 509   return (gdbarch);
 510 }
 511
 512 /* Provide a prototype to silence -Wmissing-prototypes.  */
 513 void _initialize_vax_tdep (void);
 514
 515 void
 516 _initialize_vax_tdep (void)
 517 {
 518   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 519 }