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 /* Iterate over core file register note sections.  */
  93
  94 static void
  95 vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
  96                                   iterate_over_regset_sections_cb *cb,
  97                                   void *cb_data,
  98                                   const struct regcache *regcache)
  99 {
 100   cb (".reg", VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
 101 }
 102 \f
 103 /* The VAX UNIX calling convention uses R1 to pass a structure return
 104    value address instead of passing it as a first (hidden) argument as
 105    the VMS calling convention suggests.  */
 106
 107 static CORE_ADDR
 108 vax_store_arguments (struct regcache *regcache, int nargs,
 109                      struct value **args, CORE_ADDR sp)
 110 {
 111   struct gdbarch *gdbarch = get_regcache_arch (regcache);
 112   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 113   gdb_byte buf[4];
 114   int count = 0;
 115   int i;
 116
 117   /* We create an argument list on the stack, and make the argument
 118      pointer to it.  */
 119
 120   /* Push arguments in reverse order.  */
 121   for (i = nargs - 1; i >= 0; i--)
 122     {
 123       int len = TYPE_LENGTH (value_enclosing_type (args[i]));
 124
 125       sp -= (len + 3) & ~3;
 126       count += (len + 3) / 4;
 127       write_memory (sp, value_contents_all (args[i]), len);
 128     }
 129
 130   /* Push argument count.  */
 131   sp -= 4;
 132   store_unsigned_integer (buf, 4, byte_order, count);
 133   write_memory (sp, buf, 4);
 134
 135   /* Update the argument pointer.  */
 136   store_unsigned_integer (buf, 4, byte_order, sp);
 137   regcache_cooked_write (regcache, VAX_AP_REGNUM, buf);
 138
 139   return sp;
 140 }
 141
 142 static CORE_ADDR
 143 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 144                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 145                      struct value **args, CORE_ADDR sp, int struct_return,
 146                      CORE_ADDR struct_addr)
 147 {
 148   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 149   CORE_ADDR fp = sp;
 150   gdb_byte buf[4];
 151
 152   /* Set up the function arguments.  */
 153   sp = vax_store_arguments (regcache, nargs, args, sp);
 154
 155   /* Store return value address.  */
 156   if (struct_return)
 157     regcache_cooked_write_unsigned (regcache, VAX_R1_REGNUM, struct_addr);
 158
 159   /* Store return address in the PC slot.  */
 160   sp -= 4;
 161   store_unsigned_integer (buf, 4, byte_order, bp_addr);
 162   write_memory (sp, buf, 4);
 163
 164   /* Store the (fake) frame pointer in the FP slot.  */
 165   sp -= 4;
 166   store_unsigned_integer (buf, 4, byte_order, fp);
 167   write_memory (sp, buf, 4);
 168
 169   /* Skip the AP slot.  */
 170   sp -= 4;
 171
 172   /* Store register save mask and control bits.  */
 173   sp -= 4;
 174   store_unsigned_integer (buf, 4, byte_order, 0);
 175   write_memory (sp, buf, 4);
 176
 177   /* Store condition handler.  */
 178   sp -= 4;
 179   store_unsigned_integer (buf, 4, byte_order, 0);
 180   write_memory (sp, buf, 4);
 181
 182   /* Update the stack pointer and frame pointer.  */
 183   store_unsigned_integer (buf, 4, byte_order, sp);
 184   regcache_cooked_write (regcache, VAX_SP_REGNUM, buf);
 185   regcache_cooked_write (regcache, VAX_FP_REGNUM, buf);
 186
 187   /* Return the saved (fake) frame pointer.  */
 188   return fp;
 189 }
 190
 191 static struct frame_id
 192 vax_dummy_id (struct gdbarch *gdbarch, struct frame_info *this_frame)
 193 {
 194   CORE_ADDR fp;
 195
 196   fp = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
 197   return frame_id_build (fp, get_frame_pc (this_frame));
 198 }
 199 \f
 200
 201 static enum return_value_convention
 202 vax_return_value (struct gdbarch *gdbarch, struct value *function,
 203                   struct type *type, struct regcache *regcache,
 204                   gdb_byte *readbuf, const gdb_byte *writebuf)
 205 {
 206   int len = TYPE_LENGTH (type);
 207   gdb_byte buf[8];
 208
 209   if (TYPE_CODE (type) == TYPE_CODE_STRUCT
 210       || TYPE_CODE (type) == TYPE_CODE_UNION
 211       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
 212     {
 213       /* The default on VAX is to return structures in static memory.
 214          Consequently a function must return the address where we can
 215          find the return value.  */
 216
 217       if (readbuf)
 218         {
 219           ULONGEST addr;
 220
 221           regcache_raw_read_unsigned (regcache, VAX_R0_REGNUM, &addr);
 222           read_memory (addr, readbuf, len);
 223         }
 224
 225       return RETURN_VALUE_ABI_RETURNS_ADDRESS;
 226     }
 227
 228   if (readbuf)
 229     {
 230       /* Read the contents of R0 and (if necessary) R1.  */
 231       regcache_cooked_read (regcache, VAX_R0_REGNUM, buf);
 232       if (len > 4)
 233         regcache_cooked_read (regcache, VAX_R1_REGNUM, buf + 4);
 234       memcpy (readbuf, buf, len);
 235     }
 236   if (writebuf)
 237     {
 238       /* Read the contents to R0 and (if necessary) R1.  */
 239       memcpy (buf, writebuf, len);
 240       regcache_cooked_write (regcache, VAX_R0_REGNUM, buf);
 241       if (len > 4)
 242         regcache_cooked_write (regcache, VAX_R1_REGNUM, buf + 4);
 243     }
 244
 245   return RETURN_VALUE_REGISTER_CONVENTION;
 246 }
 247 \f
 248
 249 /* Use the program counter to determine the contents and size of a
 250    breakpoint instruction.  Return a pointer to a string of bytes that
 251    encode a breakpoint instruction, store the length of the string in
 252    *LEN and optionally adjust *PC to point to the correct memory
 253    location for inserting the breakpoint.  */
 254
 255 static const gdb_byte *
 256 vax_breakpoint_from_pc (struct gdbarch *gdbarch, CORE_ADDR *pc, int *len)
 257 {
 258   static gdb_byte break_insn[] = { 3 };
 259
 260   *len = sizeof (break_insn);
 261   return break_insn;
 262 }
 263 \f
 264 /* Advance PC across any function entry prologue instructions
 265    to reach some "real" code.  */
 266
 267 static CORE_ADDR
 268 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 269 {
 270   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 271   gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
 272
 273   if (op == 0x11)
 274     pc += 2;                    /* skip brb */
 275   if (op == 0x31)
 276     pc += 3;                    /* skip brw */
 277   if (op == 0xC2
 278       && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
 279     pc += 3;                    /* skip subl2 */
 280   if (op == 0x9E
 281       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
 282       && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
 283     pc += 4;                    /* skip movab */
 284   if (op == 0x9E
 285       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
 286       && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
 287     pc += 5;                    /* skip movab */
 288   if (op == 0x9E
 289       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
 290       && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
 291     pc += 7;                    /* skip movab */
 292
 293   return pc;
 294 }
 295 \f
 296
 297 /* Unwinding the stack is relatively easy since the VAX has a
 298    dedicated frame pointer, and frames are set up automatically as the
 299    result of a function call.  Most of the relevant information can be
 300    inferred from the documentation of the Procedure Call Instructions
 301    in the VAX MACRO and Instruction Set Reference Manual.  */
 302
 303 struct vax_frame_cache
 304 {
 305   /* Base address.  */
 306   CORE_ADDR base;
 307
 308   /* Table of saved registers.  */
 309   struct trad_frame_saved_reg *saved_regs;
 310 };
 311
 312 static struct vax_frame_cache *
 313 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
 314 {
 315   struct vax_frame_cache *cache;
 316   CORE_ADDR addr;
 317   ULONGEST mask;
 318   int regnum;
 319
 320   if (*this_cache)
 321     return *this_cache;
 322
 323   /* Allocate a new cache.  */
 324   cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
 325   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 326
 327   /* The frame pointer is used as the base for the frame.  */
 328   cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
 329   if (cache->base == 0)
 330     return cache;
 331
 332   /* The register save mask and control bits determine the layout of
 333      the stack frame.  */
 334   mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
 335
 336   /* These are always saved.  */
 337   cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
 338   cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
 339   cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
 340   cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
 341
 342   /* Scan the register save mask and record the location of the saved
 343      registers.  */
 344   addr = cache->base + 20;
 345   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
 346     {
 347       if (mask & (1 << regnum))
 348         {
 349           cache->saved_regs[regnum].addr = addr;
 350           addr += 4;
 351         }
 352     }
 353
 354   /* The CALLS/CALLG flag determines whether this frame has a General
 355      Argument List or a Stack Argument List.  */
 356   if (mask & (1 << 13))
 357     {
 358       ULONGEST numarg;
 359
 360       /* This is a procedure with Stack Argument List.  Adjust the
 361          stack address for the arguments that were pushed onto the
 362          stack.  The return instruction will automatically pop the
 363          arguments from the stack.  */
 364       numarg = get_frame_memory_unsigned (this_frame, addr, 1);
 365       addr += 4 + numarg * 4;
 366     }
 367
 368   /* Bits 1:0 of the stack pointer were saved in the control bits.  */
 369   trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
 370
 371   return cache;
 372 }
 373
 374 static void
 375 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
 376                    struct frame_id *this_id)
 377 {
 378   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 379
 380   /* This marks the outermost frame.  */
 381   if (cache->base == 0)
 382     return;
 383
 384   (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
 385 }
 386
 387 static struct value *
 388 vax_frame_prev_register (struct frame_info *this_frame,
 389                          void **this_cache, int regnum)
 390 {
 391   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 392
 393   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 394 }
 395
 396 static const struct frame_unwind vax_frame_unwind =
 397 {
 398   NORMAL_FRAME,
 399   default_frame_unwind_stop_reason,
 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_iterate_over_regset_sections
 485     (gdbarch, vax_iterate_over_regset_sections);
 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 }