gdb/vax-tdep.c

   1 /* Target-dependent code for the VAX.
   2
   3    Copyright (C) 1986-2014 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "arch-utils.h"
  22 #include "dis-asm.h"
  23 #include "floatformat.h"
  24 #include "frame.h"
  25 #include "frame-base.h"
  26 #include "frame-unwind.h"
  27 #include "gdbcore.h"
  28 #include "gdbtypes.h"
  29 #include "osabi.h"
  30 #include "regcache.h"
  31 #include "regset.h"
  32 #include "trad-frame.h"
  33 #include "value.h"
  34
  35 #include "vax-tdep.h"
  36
  37 /* Return the name of register REGNUM.  */
  38
  39 static const char *
  40 vax_register_name (struct gdbarch *gdbarch, int regnum)
  41 {
  42   static char *register_names[] =
  43   {
  44     "r0", "r1", "r2",  "r3",  "r4", "r5", "r6", "r7",
  45     "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
  46     "ps",
  47   };
  48
  49   if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
  50     return register_names[regnum];
  51
  52   return NULL;
  53 }
  54
  55 /* Return the GDB type object for the "standard" data type of data in
  56    register REGNUM.  */
  57
  58 static struct type *
  59 vax_register_type (struct gdbarch *gdbarch, int regnum)
  60 {
  61   return builtin_type (gdbarch)->builtin_int;
  62 }
  63 \f
  64 /* Core file support.  */
  65
  66 /* Supply register REGNUM from the buffer specified by GREGS and LEN
  67    in the general-purpose register set REGSET to register cache
  68    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  69
  70 static void
  71 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
  72                     int regnum, const void *gregs, size_t len)
  73 {
  74   const gdb_byte *regs = gregs;
  75   int i;
  76
  77   for (i = 0; i < VAX_NUM_REGS; i++)
  78     {
  79       if (regnum == i || regnum == -1)
  80         regcache_raw_supply (regcache, i, regs + i * 4);
  81     }
  82 }
  83
  84 /* VAX register set.  */
  85
  86 static const struct regset vax_gregset =
  87 {
  88   NULL,
  89   vax_supply_gregset
  90 };
  91
  92 /* Return the appropriate register set for the core section identified
  93    by SECT_NAME and SECT_SIZE.  */
  94
  95 static const struct regset *
  96 vax_regset_from_core_section (struct gdbarch *gdbarch,
  97                               const char *sect_name, size_t sect_size)
  98 {
  99   if (strcmp (sect_name, ".reg") == 0 && sect_size >= VAX_NUM_REGS * 4)
 100     return &vax_gregset;
 101
 102   return NULL;
 103 }
 104 \f
 105 /* The VAX UNIX calling convention uses R1 to pass a structure return
 106    value address instead of passing it as a first (hidden) argument as
 107    the VMS calling convention suggests.  */
 108
 109 static CORE_ADDR
 110 vax_store_arguments (struct regcache *regcache, int nargs,
 111                      struct value **args, CORE_ADDR sp)
 112 {
 113   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 114   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 115   gdb_byte buf[4];
 116   int count = 0;
 117   int i;
 118
 119   /* We create an argument list on the stack, and make the argument
 120      pointer to it.  */
 121
 122   /* Push arguments in reverse order.  */
 123   for (i = nargs - 1; i >= 0; i--)
 124     {
 125       int len = TYPE_LENGTH (value_enclosing_type (args[i]));
 126
 127       sp -= (len + 3) & ~3;
 128       count += (len + 3) / 4;
 129       write_memory (sp, value_contents_all (args[i]), len);
 130     }
 131
 132   /* Push argument count.  */
 133   sp -= 4;
 134   store_unsigned_integer (buf, 4, byte_order, count);
 135   write_memory (sp, buf, 4);
 136
 137   /* Update the argument pointer.  */
 138   store_unsigned_integer (buf, 4, byte_order, sp);
 139   regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
 140
 141   return sp;
 142 }
 143
 144 static CORE_ADDR
 145 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 146                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 147                      struct value **args, CORE_ADDR sp, int struct_return,
 148                      CORE_ADDR struct_addr)
 149 {
 150   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 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, byte_order, 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, byte_order, 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, byte_order, 0);
 177   write_memory (sp, buf, 4);
 178
 179   /* Store condition handler.  */
 180   sp -= 4;
 181   store_unsigned_integer (buf, 4, byte_order, 0);
 182   write_memory (sp, buf, 4);
 183
 184   /* Update the stack pointer and frame pointer.  */
 185   store_unsigned_integer (buf, 4, byte_order, 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 value *function,
 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   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 273   gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
 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, byte_order) == 0x5E)
 281     pc += 3;                    /* skip subl2 */
 282   if (op == 0x9E
 283       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
 284       && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
 285     pc += 4;                    /* skip movab */
 286   if (op == 0x9E
 287       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
 288       && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
 289     pc += 5;                    /* skip movab */
 290   if (op == 0x9E
 291       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
 292       && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 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 static struct vax_frame_cache *
 315 vax_frame_cache (struct frame_info *this_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 (this_frame);
 328
 329   /* The frame pointer is used as the base for the frame.  */
 330   cache->base = get_frame_register_unsigned (this_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 (this_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 (this_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 *this_frame, void **this_cache,
 378                    struct frame_id *this_id)
 379 {
 380   struct vax_frame_cache *cache = vax_frame_cache (this_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, get_frame_func (this_frame));
 387 }
 388
 389 static struct value *
 390 vax_frame_prev_register (struct frame_info *this_frame,
 391                          void **this_cache, int regnum)
 392 {
 393   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 394
 395   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 396 }
 397
 398 static const struct frame_unwind vax_frame_unwind =
 399 {
 400   NORMAL_FRAME,
 401   default_frame_unwind_stop_reason,
 402   vax_frame_this_id,
 403   vax_frame_prev_register,
 404   NULL,
 405   default_frame_sniffer
 406 };
 407 \f
 408
 409 static CORE_ADDR
 410 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
 411 {
 412   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 413
 414   return cache->base;
 415 }
 416
 417 static CORE_ADDR
 418 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
 419 {
 420   return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
 421 }
 422
 423 static const struct frame_base vax_frame_base =
 424 {
 425   &vax_frame_unwind,
 426   vax_frame_base_address,
 427   vax_frame_base_address,
 428   vax_frame_args_address
 429 };
 430
 431 /* Return number of arguments for FRAME.  */
 432
 433 static int
 434 vax_frame_num_args (struct frame_info *frame)
 435 {
 436   CORE_ADDR args;
 437
 438   /* Assume that the argument pointer for the outermost frame is
 439      hosed, as is the case on NetBSD/vax ELF.  */
 440   if (get_frame_base_address (frame) == 0)
 441     return 0;
 442
 443   args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
 444   return get_frame_memory_unsigned (frame, args, 1);
 445 }
 446
 447 static CORE_ADDR
 448 vax_unwind_pc (struct gdbarch *gdbarch, struct frame_info *next_frame)
 449 {
 450   return frame_unwind_register_unsigned (next_frame, VAX_PC_REGNUM);
 451 }
 452 \f
 453
 454 /* Initialize the current architecture based on INFO.  If possible, re-use an
 455    architecture from ARCHES, which is a list of architectures already created
 456    during this debugging session.
 457
 458    Called e.g. at program startup, when reading a core file, and when reading
 459    a binary file.  */
 460
 461 static struct gdbarch *
 462 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 463 {
 464   struct gdbarch *gdbarch;
 465
 466   /* If there is already a candidate, use it.  */
 467   arches = gdbarch_list_lookup_by_info (arches, &info);
 468   if (arches != NULL)
 469     return arches->gdbarch;
 470
 471   gdbarch = gdbarch_alloc (&info, NULL);
 472
 473   set_gdbarch_float_format (gdbarch, floatformats_vax_f);
 474   set_gdbarch_double_format (gdbarch, floatformats_vax_d);
 475   set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
 476   set_gdbarch_long_double_bit (gdbarch, 64);
 477
 478   /* Register info */
 479   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 480   set_gdbarch_register_name (gdbarch, vax_register_name);
 481   set_gdbarch_register_type (gdbarch, vax_register_type);
 482   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 483   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 484   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 485
 486   set_gdbarch_regset_from_core_section
 487     (gdbarch, vax_regset_from_core_section);
 488
 489   /* Frame and stack info */
 490   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 491   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 492   set_gdbarch_frame_args_skip (gdbarch, 4);
 493
 494   /* Stack grows downward.  */
 495   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 496
 497   /* Return value info */
 498   set_gdbarch_return_value (gdbarch, vax_return_value);
 499
 500   /* Call dummy code.  */
 501   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
 502   set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
 503
 504   /* Breakpoint info */
 505   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 506
 507   /* Misc info */
 508   set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
 509   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 510
 511   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 512
 513   set_gdbarch_unwind_pc (gdbarch, vax_unwind_pc);
 514
 515   frame_base_set_default (gdbarch, &vax_frame_base);
 516
 517   /* Hook in ABI-specific overrides, if they have been registered.  */
 518   gdbarch_init_osabi (info, gdbarch);
 519
 520   frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
 521
 522   return (gdbarch);
 523 }
 524
 525 /* Provide a prototype to silence -Wmissing-prototypes.  */
 526 void _initialize_vax_tdep (void);
 527
 528 void
 529 _initialize_vax_tdep (void)
 530 {
 531   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 532 }