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