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, struct value *function,
 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_UNION
 214       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
 215     {
 216       /* The default on VAX is to return structures in static memory.
 217          Consequently a function must return the address where we can
 218          find the return value.  */
 219
 220       if (readbuf)
 221         {
 222           ULONGEST addr;
 223
 224           regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
 225           read_memory (addr, readbuf, len);
 226         }
 227
 228       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 229     }
 230
 231   if (readbuf)
 232     {
 233       /* Read the contents of R0 and (if necessary) R1.  */
 234       regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
 235       if (len > 4)
 236         regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
 237       memcpy (readbuf, buf, len);
 238     }
 239   if (writebuf)
 240     {
 241       /* Read the contents to R0 and (if necessary) R1.  */
 242       memcpy (buf, writebuf, len);
 243       regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
 244       if (len > 4)
 245         regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
 246     }
 247
 248   return RETURN_VALUE_REGISTER_CONVENTION;
 249 }
 250 \f
 251
 252 /* Use the program counter to determine the contents and size of a
 253    breakpoint instruction.  Return a pointer to a string of bytes that
 254    encode a breakpoint instruction, store the length of the string in
 255    *LEN and optionally adjust *PC to point to the correct memory
 256    location for inserting the breakpoint.  */
 257
 258 static const unsigned char *
 259 vax_breakpoint_from_pc (CORE_ADDR *pc, int *len)
 260 {
 261   static unsigned char break_insn[] = { 3 };
 262
 263   *len = sizeof (break_insn);
 264   return break_insn;
 265 }
 266 \f
 267 /* Advance PC across any function entry prologue instructions
 268    to reach some "real" code.  */
 269
 270 static CORE_ADDR
 271 vax_skip_prologue (CORE_ADDR pc)
 272 {
 273   unsigned char op = read_memory_unsigned_integer (pc, 1);
 274
 275   if (op == 0x11)
 276     pc += 2;                    /* skip brb */
 277   if (op == 0x31)
 278     pc += 3;                    /* skip brw */
 279   if (op == 0xC2
 280       && (read_memory_unsigned_integer (pc + 2, 1)) == 0x5E)
 281     pc += 3;                    /* skip subl2 */
 282   if (op == 0x9E
 283       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xAE
 284       && (read_memory_unsigned_integer (pc + 3, 1)) == 0x5E)
 285     pc += 4;                    /* skip movab */
 286   if (op == 0x9E
 287       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xCE
 288       && (read_memory_unsigned_integer (pc + 4, 1)) == 0x5E)
 289     pc += 5;                    /* skip movab */
 290   if (op == 0x9E
 291       && (read_memory_unsigned_integer (pc + 1, 1)) == 0xEE
 292       && (read_memory_unsigned_integer (pc + 6, 1)) == 0x5E)
 293     pc += 7;                    /* skip movab */
 294
 295   return pc;
 296 }
 297 \f
 298
 299 /* Unwinding the stack is relatively easy since the VAX has a
 300    dedicated frame pointer, and frames are set up automatically as the
 301    result of a function call.  Most of the relevant information can be
 302    inferred from the documentation of the Procedure Call Instructions
 303    in the VAX MACRO and Instruction Set Reference Manual.  */
 304
 305 struct vax_frame_cache
 306 {
 307   /* Base address.  */
 308   CORE_ADDR base;
 309
 310   /* Table of saved registers.  */
 311   struct trad_frame_saved_reg *saved_regs;
 312 };
 313
 314 struct vax_frame_cache *
 315 vax_frame_cache (struct frame_info *next_frame, void **this_cache)
 316 {
 317   struct vax_frame_cache *cache;
 318   CORE_ADDR addr;
 319   ULONGEST mask;
 320   int regnum;
 321
 322   if (*this_cache)
 323     return *this_cache;
 324
 325   /* Allocate a new cache.  */
 326   cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
 327   cache->saved_regs = trad_frame_alloc_saved_regs (next_frame);
 328
 329   /* The frame pointer is used as the base for the frame.  */
 330   cache->base = frame_unwind_register_unsigned (next_frame, VAX_FP_REGNUM);
 331   if (cache->base == 0)
 332     return cache;
 333
 334   /* The register save mask and control bits determine the layout of
 335      the stack frame.  */
 336   mask = get_frame_memory_unsigned (next_frame, cache->base + 4, 4) >> 16;
 337
 338   /* These are always saved.  */
 339   cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
 340   cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
 341   cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
 342   cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
 343
 344   /* Scan the register save mask and record the location of the saved
 345      registers.  */
 346   addr = cache->base + 20;
 347   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
 348     {
 349       if (mask & (1 << regnum))
 350         {
 351           cache->saved_regs[regnum].addr = addr;
 352           addr += 4;
 353         }
 354     }
 355
 356   /* The CALLS/CALLG flag determines whether this frame has a General
 357      Argument List or a Stack Argument List.  */
 358   if (mask & (1 << 13))
 359     {
 360       ULONGEST numarg;
 361
 362       /* This is a procedure with Stack Argument List.  Adjust the
 363          stack address for the arguments that were pushed onto the
 364          stack.  The return instruction will automatically pop the
 365          arguments from the stack.  */
 366       numarg = get_frame_memory_unsigned (next_frame, addr, 1);
 367       addr += 4 + numarg * 4;
 368     }
 369
 370   /* Bits 1:0 of the stack pointer were saved in the control bits.  */
 371   trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
 372
 373   return cache;
 374 }
 375
 376 static void
 377 vax_frame_this_id (struct frame_info *next_frame, void **this_cache,
 378                    struct frame_id *this_id)
 379 {
 380   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
 381
 382   /* This marks the outermost frame.  */
 383   if (cache->base == 0)
 384     return;
 385
 386   (*this_id) = frame_id_build (cache->base, frame_func_unwind (next_frame));
 387 }
 388
 389 static void
 390 vax_frame_prev_register (struct frame_info *next_frame, void **this_cache,
 391                          int regnum, int *optimizedp,
 392                          enum lval_type *lvalp, CORE_ADDR *addrp,
 393                          int *realnump, void *valuep)
 394 {
 395   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
 396
 397   trad_frame_get_prev_register (next_frame, cache->saved_regs, regnum,
 398                                 optimizedp, lvalp, addrp, realnump, valuep);
 399 }
 400
 401 static const struct frame_unwind vax_frame_unwind =
 402 {
 403   NORMAL_FRAME,
 404   vax_frame_this_id,
 405   vax_frame_prev_register
 406 };
 407
 408 static const struct frame_unwind *
 409 vax_frame_sniffer (struct frame_info *next_frame)
 410 {
 411   return &vax_frame_unwind;
 412 }
 413 \f
 414
 415 static CORE_ADDR
 416 vax_frame_base_address (struct frame_info *next_frame, void **this_cache)
 417 {
 418   struct vax_frame_cache *cache = vax_frame_cache (next_frame, this_cache);
 419
 420   return cache->base;
 421 }
 422
 423 static CORE_ADDR
 424 vax_frame_args_address (struct frame_info *next_frame, void **this_cache)
 425 {
 426   return frame_unwind_register_unsigned (next_frame, VAX_AP_REGNUM);
 427 }
 428
 429 static const struct frame_base vax_frame_base =
 430 {
 431   &vax_frame_unwind,
 432   vax_frame_base_address,
 433   vax_frame_base_address,
 434   vax_frame_args_address
 435 };
 436
 437 /* Return number of arguments for FRAME.  */
 438
 439 static int
 440 vax_frame_num_args (struct frame_info *frame)
 441 {
 442   CORE_ADDR args;
 443
 444   /* Assume that the argument pointer for the outermost frame is
 445      hosed, as is the case on NetBSD/vax ELF.  */
 446   if (get_frame_base_address (frame) == 0)
 447     return 0;
 448
 449   args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
 450   return get_frame_memory_unsigned (frame, args, 1);
 451 }
 452
 453 static CORE_ADDR
 454 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 455 {
 456   return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
 457 }
 458 \f
 459
 460 /* Initialize the current architecture based on INFO.  If possible, re-use an
 461    architecture from ARCHES, which is a list of architectures already created
 462    during this debugging session.
 463
 464    Called e.g. at program startup, when reading a core file, and when reading
 465    a binary file.  */
 466
 467 static struct gdbarch *
 468 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 469 {
 470   struct gdbarch *gdbarch;
 471
 472   /* If there is already a candidate, use it.  */
 473   arches = gdbarch_list_lookup_by_info (arches, &info);
 474   if (arches != NULL)
 475     return arches->gdbarch;
 476
 477   gdbarch = gdbarch_alloc (&info, NULL);
 478
 479   /* Register info */
 480   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 481   set_gdbarch_register_name (gdbarch, vax_register_name);
 482   set_gdbarch_register_type (gdbarch, vax_register_type);
 483   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 484   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 485   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 486
 487   set_gdbarch_regset_from_core_section
 488     (gdbarch, vax_regset_from_core_section);
 489
 490   /* Frame and stack info */
 491   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 492   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 493   set_gdbarch_frame_args_skip (gdbarch, 4);
 494
 495   /* Stack grows downward.  */
 496   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 497
 498   /* Return value info */
 499   set_gdbarch_return_value (gdbarch, vax_return_value);
 500
 501   /* Call dummy code.  */
 502   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
 503   set_gdbarch_unwind_dummy_id (gdbarch, vax_unwind_dummy_id);
 504
 505   /* Breakpoint info */
 506   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 507
 508   /* Misc info */
 509   set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
 510   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 511
 512   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 513
 514   set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
 515
 516   frame_base_set_default (gdbarch, &vax_frame_base);
 517
 518   /* Hook in ABI-specific overrides, if they have been registered.  */
 519   gdbarch_init_osabi (info, gdbarch);
 520
 521   frame_unwind_append_sniffer (gdbarch, vax_frame_sniffer);
 522
 523   return (gdbarch);
 524 }
 525
 526 /* Provide a prototype to silence -Wmissing-prototypes.  */
 527 void _initialize_vax_tdep (void);
 528
 529 void
 530 _initialize_vax_tdep (void)
 531 {
 532   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 533 }