gdb/vax-tdep.c

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