gdb/vax-tdep.c

   1 /* Target-dependent code for the VAX.
   2
   3    Copyright (C) 1986-2020 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 "frame.h"
  24 #include "frame-base.h"
  25 #include "frame-unwind.h"
  26 #include "gdbcore.h"
  27 #include "gdbtypes.h"
  28 #include "osabi.h"
  29 #include "regcache.h"
  30 #include "regset.h"
  31 #include "trad-frame.h"
  32 #include "value.h"
  33
  34 #include "vax-tdep.h"
  35
  36 /* Return the name of register REGNUM.  */
  37
  38 static const char *
  39 vax_register_name (struct gdbarch *gdbarch, int regnum)
  40 {
  41   static const char *register_names[] =
  42   {
  43     "r0", "r1", "r2",  "r3",  "r4", "r5", "r6", "r7",
  44     "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc",
  45     "ps",
  46   };
  47
  48   if (regnum >= 0 && regnum < ARRAY_SIZE (register_names))
  49     return register_names[regnum];
  50
  51   return NULL;
  52 }
  53
  54 /* Return the GDB type object for the "standard" data type of data in
  55    register REGNUM.  */
  56
  57 static struct type *
  58 vax_register_type (struct gdbarch *gdbarch, int regnum)
  59 {
  60   return builtin_type (gdbarch)->builtin_int;
  61 }
  62 \f
  63 /* Core file support.  */
  64
  65 /* Supply register REGNUM from the buffer specified by GREGS and LEN
  66    in the general-purpose register set REGSET to register cache
  67    REGCACHE.  If REGNUM is -1, do this for all registers in REGSET.  */
  68
  69 static void
  70 vax_supply_gregset (const struct regset *regset, struct regcache *regcache,
  71                     int regnum, const void *gregs, size_t len)
  72 {
  73   const gdb_byte *regs = (const gdb_byte *) gregs;
  74   int i;
  75
  76   for (i = 0; i < VAX_NUM_REGS; i++)
  77     {
  78       if (regnum == i || regnum == -1)
  79         regcache->raw_supply (i, regs + i * 4);
  80     }
  81 }
  82
  83 /* VAX register set.  */
  84
  85 static const struct regset vax_gregset =
  86 {
  87   NULL,
  88   vax_supply_gregset
  89 };
  90
  91 /* Iterate over core file register note sections.  */
  92
  93 static void
  94 vax_iterate_over_regset_sections (struct gdbarch *gdbarch,
  95                                   iterate_over_regset_sections_cb *cb,
  96                                   void *cb_data,
  97                                   const struct regcache *regcache)
  98 {
  99   cb (".reg", VAX_NUM_REGS * 4, VAX_NUM_REGS * 4, &vax_gregset, NULL, cb_data);
 100 }
 101 \f
 102 /* The VAX UNIX calling convention uses R1 to pass a structure return
 103    value address instead of passing it as a first (hidden) argument as
 104    the VMS calling convention suggests.  */
 105
 106 static CORE_ADDR
 107 vax_store_arguments (struct regcache *regcache, int nargs,
 108                      struct value **args, CORE_ADDR sp)
 109 {
 110   struct gdbarch *gdbarch = regcache->arch ();
 111   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 112   gdb_byte buf[4];
 113   int count = 0;
 114   int i;
 115
 116   /* We create an argument list on the stack, and make the argument
 117      pointer to it.  */
 118
 119   /* Push arguments in reverse order.  */
 120   for (i = nargs - 1; i >= 0; i--)
 121     {
 122       int len = TYPE_LENGTH (value_enclosing_type (args[i]));
 123
 124       sp -= (len + 3) & ~3;
 125       count += (len + 3) / 4;
 126       write_memory (sp, value_contents_all (args[i]), len);
 127     }
 128
 129   /* Push argument count.  */
 130   sp -= 4;
 131   store_unsigned_integer (buf, 4, byte_order, count);
 132   write_memory (sp, buf, 4);
 133
 134   /* Update the argument pointer.  */
 135   store_unsigned_integer (buf, 4, byte_order, sp);
 136   regcache->cooked_write (VAX_AP_REGNUM, buf);
 137
 138   return sp;
 139 }
 140
 141 static CORE_ADDR
 142 vax_push_dummy_call (struct gdbarch *gdbarch, struct value *function,
 143                      struct regcache *regcache, CORE_ADDR bp_addr, int nargs,
 144                      struct value **args, CORE_ADDR sp,
 145                      function_call_return_method return_method,
 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 (return_method == return_method_struct)
 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 (VAX_SP_REGNUM, buf);
 185   regcache->cooked_write (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_CODE_STRUCT
 210       || type->code () == TYPE_CODE_UNION
 211       || type->code () == 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 (VAX_R0_REGNUM, buf);
 232       if (len > 4)
 233         regcache->cooked_read (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 (VAX_R0_REGNUM, buf);
 241       if (len > 4)
 242         regcache->cooked_write (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 constexpr gdb_byte vax_break_insn[] = { 3 };
 256
 257 typedef BP_MANIPULATION (vax_break_insn) vax_breakpoint;
 258 \f
 259 /* Advance PC across any function entry prologue instructions
 260    to reach some "real" code.  */
 261
 262 static CORE_ADDR
 263 vax_skip_prologue (struct gdbarch *gdbarch, CORE_ADDR pc)
 264 {
 265   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 266   gdb_byte op = read_memory_unsigned_integer (pc, 1, byte_order);
 267
 268   if (op == 0x11)
 269     pc += 2;                    /* skip brb */
 270   if (op == 0x31)
 271     pc += 3;                    /* skip brw */
 272   if (op == 0xC2
 273       && read_memory_unsigned_integer (pc + 2, 1, byte_order) == 0x5E)
 274     pc += 3;                    /* skip subl2 */
 275   if (op == 0x9E
 276       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xAE
 277       && read_memory_unsigned_integer (pc + 3, 1, byte_order) == 0x5E)
 278     pc += 4;                    /* skip movab */
 279   if (op == 0x9E
 280       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xCE
 281       && read_memory_unsigned_integer (pc + 4, 1, byte_order) == 0x5E)
 282     pc += 5;                    /* skip movab */
 283   if (op == 0x9E
 284       && read_memory_unsigned_integer (pc + 1, 1, byte_order) == 0xEE
 285       && read_memory_unsigned_integer (pc + 6, 1, byte_order) == 0x5E)
 286     pc += 7;                    /* skip movab */
 287
 288   return pc;
 289 }
 290 \f
 291
 292 /* Unwinding the stack is relatively easy since the VAX has a
 293    dedicated frame pointer, and frames are set up automatically as the
 294    result of a function call.  Most of the relevant information can be
 295    inferred from the documentation of the Procedure Call Instructions
 296    in the VAX MACRO and Instruction Set Reference Manual.  */
 297
 298 struct vax_frame_cache
 299 {
 300   /* Base address.  */
 301   CORE_ADDR base;
 302
 303   /* Table of saved registers.  */
 304   struct trad_frame_saved_reg *saved_regs;
 305 };
 306
 307 static struct vax_frame_cache *
 308 vax_frame_cache (struct frame_info *this_frame, void **this_cache)
 309 {
 310   struct vax_frame_cache *cache;
 311   CORE_ADDR addr;
 312   ULONGEST mask;
 313   int regnum;
 314
 315   if (*this_cache)
 316     return (struct vax_frame_cache *) *this_cache;
 317
 318   /* Allocate a new cache.  */
 319   cache = FRAME_OBSTACK_ZALLOC (struct vax_frame_cache);
 320   cache->saved_regs = trad_frame_alloc_saved_regs (this_frame);
 321
 322   /* The frame pointer is used as the base for the frame.  */
 323   cache->base = get_frame_register_unsigned (this_frame, VAX_FP_REGNUM);
 324   if (cache->base == 0)
 325     return cache;
 326
 327   /* The register save mask and control bits determine the layout of
 328      the stack frame.  */
 329   mask = get_frame_memory_unsigned (this_frame, cache->base + 4, 4) >> 16;
 330
 331   /* These are always saved.  */
 332   cache->saved_regs[VAX_PC_REGNUM].addr = cache->base + 16;
 333   cache->saved_regs[VAX_FP_REGNUM].addr = cache->base + 12;
 334   cache->saved_regs[VAX_AP_REGNUM].addr = cache->base + 8;
 335   cache->saved_regs[VAX_PS_REGNUM].addr = cache->base + 4;
 336
 337   /* Scan the register save mask and record the location of the saved
 338      registers.  */
 339   addr = cache->base + 20;
 340   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
 341     {
 342       if (mask & (1 << regnum))
 343         {
 344           cache->saved_regs[regnum].addr = addr;
 345           addr += 4;
 346         }
 347     }
 348
 349   /* The CALLS/CALLG flag determines whether this frame has a General
 350      Argument List or a Stack Argument List.  */
 351   if (mask & (1 << 13))
 352     {
 353       ULONGEST numarg;
 354
 355       /* This is a procedure with Stack Argument List.  Adjust the
 356          stack address for the arguments that were pushed onto the
 357          stack.  The return instruction will automatically pop the
 358          arguments from the stack.  */
 359       numarg = get_frame_memory_unsigned (this_frame, addr, 1);
 360       addr += 4 + numarg * 4;
 361     }
 362
 363   /* Bits 1:0 of the stack pointer were saved in the control bits.  */
 364   trad_frame_set_value (cache->saved_regs, VAX_SP_REGNUM, addr + (mask >> 14));
 365
 366   return cache;
 367 }
 368
 369 static void
 370 vax_frame_this_id (struct frame_info *this_frame, void **this_cache,
 371                    struct frame_id *this_id)
 372 {
 373   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 374
 375   /* This marks the outermost frame.  */
 376   if (cache->base == 0)
 377     return;
 378
 379   (*this_id) = frame_id_build (cache->base, get_frame_func (this_frame));
 380 }
 381
 382 static struct value *
 383 vax_frame_prev_register (struct frame_info *this_frame,
 384                          void **this_cache, int regnum)
 385 {
 386   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 387
 388   return trad_frame_get_prev_register (this_frame, cache->saved_regs, regnum);
 389 }
 390
 391 static const struct frame_unwind vax_frame_unwind =
 392 {
 393   NORMAL_FRAME,
 394   default_frame_unwind_stop_reason,
 395   vax_frame_this_id,
 396   vax_frame_prev_register,
 397   NULL,
 398   default_frame_sniffer
 399 };
 400 \f
 401
 402 static CORE_ADDR
 403 vax_frame_base_address (struct frame_info *this_frame, void **this_cache)
 404 {
 405   struct vax_frame_cache *cache = vax_frame_cache (this_frame, this_cache);
 406
 407   return cache->base;
 408 }
 409
 410 static CORE_ADDR
 411 vax_frame_args_address (struct frame_info *this_frame, void **this_cache)
 412 {
 413   return get_frame_register_unsigned (this_frame, VAX_AP_REGNUM);
 414 }
 415
 416 static const struct frame_base vax_frame_base =
 417 {
 418   &vax_frame_unwind,
 419   vax_frame_base_address,
 420   vax_frame_base_address,
 421   vax_frame_args_address
 422 };
 423
 424 /* Return number of arguments for FRAME.  */
 425
 426 static int
 427 vax_frame_num_args (struct frame_info *frame)
 428 {
 429   CORE_ADDR args;
 430
 431   /* Assume that the argument pointer for the outermost frame is
 432      hosed, as is the case on NetBSD/vax ELF.  */
 433   if (get_frame_base_address (frame) == 0)
 434     return 0;
 435
 436   args = get_frame_register_unsigned (frame, VAX_AP_REGNUM);
 437   return get_frame_memory_unsigned (frame, args, 1);
 438 }
 439
 440 \f
 441
 442 /* Initialize the current architecture based on INFO.  If possible, re-use an
 443    architecture from ARCHES, which is a list of architectures already created
 444    during this debugging session.
 445
 446    Called e.g. at program startup, when reading a core file, and when reading
 447    a binary file.  */
 448
 449 static struct gdbarch *
 450 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 451 {
 452   struct gdbarch *gdbarch;
 453
 454   /* If there is already a candidate, use it.  */
 455   arches = gdbarch_list_lookup_by_info (arches, &info);
 456   if (arches != NULL)
 457     return arches->gdbarch;
 458
 459   gdbarch = gdbarch_alloc (&info, NULL);
 460
 461   set_gdbarch_float_format (gdbarch, floatformats_vax_f);
 462   set_gdbarch_double_format (gdbarch, floatformats_vax_d);
 463   set_gdbarch_long_double_format (gdbarch, floatformats_vax_d);
 464   set_gdbarch_long_double_bit (gdbarch, 64);
 465
 466   /* Register info */
 467   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 468   set_gdbarch_register_name (gdbarch, vax_register_name);
 469   set_gdbarch_register_type (gdbarch, vax_register_type);
 470   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 471   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 472   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 473
 474   set_gdbarch_iterate_over_regset_sections
 475     (gdbarch, vax_iterate_over_regset_sections);
 476
 477   /* Frame and stack info */
 478   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 479   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 480   set_gdbarch_frame_args_skip (gdbarch, 4);
 481
 482   /* Stack grows downward.  */
 483   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 484
 485   /* Return value info */
 486   set_gdbarch_return_value (gdbarch, vax_return_value);
 487
 488   /* Call dummy code.  */
 489   set_gdbarch_push_dummy_call (gdbarch, vax_push_dummy_call);
 490   set_gdbarch_dummy_id (gdbarch, vax_dummy_id);
 491
 492   /* Breakpoint info */
 493   set_gdbarch_breakpoint_kind_from_pc (gdbarch, vax_breakpoint::kind_from_pc);
 494   set_gdbarch_sw_breakpoint_from_kind (gdbarch, vax_breakpoint::bp_from_kind);
 495
 496   /* Misc info */
 497   set_gdbarch_deprecated_function_start_offset (gdbarch, 2);
 498   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 499
 500   frame_base_set_default (gdbarch, &vax_frame_base);
 501
 502   /* Hook in ABI-specific overrides, if they have been registered.  */
 503   gdbarch_init_osabi (info, gdbarch);
 504
 505   frame_unwind_append_unwinder (gdbarch, &vax_frame_unwind);
 506
 507   return (gdbarch);
 508 }
 509
 510 void _initialize_vax_tdep ();
 511 void
 512 _initialize_vax_tdep ()
 513 {
 514   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 515 }