gdb/vax-tdep.c

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