gdb/vax-tdep.c

   1 /* Print VAX instructions for GDB, the GNU debugger.
   2    Copyright 1986, 1989, 1991, 1992, 1995, 1996, 1998, 1999, 2000, 2002, 2003
   3    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 2 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, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "opcode/vax.h"
  25 #include "gdbcore.h"
  26 #include "inferior.h"
  27 #include "regcache.h"
  28 #include "frame.h"
  29 #include "value.h"
  30 #include "arch-utils.h"
  31 #include "gdb_string.h"
  32 #include "osabi.h"
  33
  34 #include "vax-tdep.h"
  35
  36 static gdbarch_register_name_ftype vax_register_name;
  37
  38 static gdbarch_skip_prologue_ftype vax_skip_prologue;
  39 static gdbarch_frame_num_args_ftype vax_frame_num_args;
  40 static gdbarch_deprecated_frame_chain_ftype vax_frame_chain;
  41
  42 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value;
  43 static gdbarch_deprecated_extract_struct_value_address_ftype
  44     vax_extract_struct_value_address;
  45
  46 static gdbarch_deprecated_push_dummy_frame_ftype vax_push_dummy_frame;
  47 \f
  48 static const char *
  49 vax_register_name (int regno)
  50 {
  51   static char *register_names[] =
  52   {
  53     "r0",  "r1",  "r2",  "r3", "r4", "r5", "r6", "r7",
  54     "r8",  "r9", "r10", "r11", "ap", "fp", "sp", "pc",
  55     "ps",
  56   };
  57
  58   if (regno < 0)
  59     return (NULL);
  60   if (regno >= (sizeof(register_names) / sizeof(*register_names)))
  61     return (NULL);
  62   return (register_names[regno]);
  63 }
  64
  65 static int
  66 vax_register_byte (int regno)
  67 {
  68   return (regno * 4);
  69 }
  70
  71 static int
  72 vax_register_raw_size (int regno)
  73 {
  74   return (4);
  75 }
  76
  77 static int
  78 vax_register_virtual_size (int regno)
  79 {
  80   return (4);
  81 }
  82
  83 static struct type *
  84 vax_register_virtual_type (int regno)
  85 {
  86   return (builtin_type_int);
  87 }
  88 \f
  89 static void
  90 vax_frame_init_saved_regs (struct frame_info *frame)
  91 {
  92   int regnum, regmask;
  93   CORE_ADDR next_addr;
  94
  95   if (get_frame_saved_regs (frame))
  96     return;
  97
  98   frame_saved_regs_zalloc (frame);
  99
 100   regmask = read_memory_integer (get_frame_base (frame) + 4, 4) >> 16;
 101
 102   next_addr = get_frame_base (frame) + 16;
 103
 104   /* regmask's low bit is for register 0, which is the first one
 105      what would be pushed.  */
 106   for (regnum = 0; regnum < VAX_AP_REGNUM; regnum++)
 107     {
 108       if (regmask & (1 << regnum))
 109         get_frame_saved_regs (frame)[regnum] = next_addr += 4;
 110     }
 111
 112   get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
 113   if (regmask & (1 << DEPRECATED_FP_REGNUM))
 114     get_frame_saved_regs (frame)[SP_REGNUM] +=
 115       4 + (4 * read_memory_integer (next_addr + 4, 4));
 116
 117   get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
 118   get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
 119   get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
 120   get_frame_saved_regs (frame)[PS_REGNUM] = get_frame_base (frame) + 4;
 121 }
 122
 123 /* Get saved user PC for sigtramp from sigcontext for BSD style sigtramp.  */
 124
 125 static CORE_ADDR
 126 vax_sigtramp_saved_pc (struct frame_info *frame)
 127 {
 128   CORE_ADDR sigcontext_addr;
 129   char *buf;
 130   int ptrbytes = TYPE_LENGTH (builtin_type_void_func_ptr);
 131   int sigcontext_offs = (2 * TARGET_INT_BIT) / TARGET_CHAR_BIT;
 132
 133   buf = alloca (ptrbytes);
 134   /* Get sigcontext address, it is the third parameter on the stack.  */
 135   if (get_next_frame (frame))
 136     sigcontext_addr = read_memory_typed_address
 137       (DEPRECATED_FRAME_ARGS_ADDRESS (get_next_frame (frame))
 138        + FRAME_ARGS_SKIP + sigcontext_offs,
 139        builtin_type_void_data_ptr);
 140   else
 141     sigcontext_addr = read_memory_typed_address
 142       (read_register (SP_REGNUM) + sigcontext_offs, builtin_type_void_data_ptr);
 143
 144   /* Don't cause a memory_error when accessing sigcontext in case the stack
 145      layout has changed or the stack is corrupt.  */
 146   target_read_memory (sigcontext_addr + SIGCONTEXT_PC_OFFSET, buf, ptrbytes);
 147   return extract_typed_address (buf, builtin_type_void_func_ptr);
 148 }
 149
 150 static CORE_ADDR
 151 vax_frame_saved_pc (struct frame_info *frame)
 152 {
 153   if ((get_frame_type (frame) == SIGTRAMP_FRAME))
 154     return (vax_sigtramp_saved_pc (frame)); /* XXXJRT */
 155
 156   return (read_memory_integer (get_frame_base (frame) + 16, 4));
 157 }
 158
 159 static CORE_ADDR
 160 vax_frame_args_address (struct frame_info *frame)
 161 {
 162   /* In most of GDB, getting the args address is too important to just
 163      say "I don't know".  This is sometimes wrong for functions that
 164      aren't on top of the stack, but c'est la vie.  */
 165   if (get_next_frame (frame))
 166     return (read_memory_integer (get_frame_base (get_next_frame (frame)) + 8, 4));
 167   /* Cannot find the AP register value directly from the FP value.
 168      Must find it saved in the frame called by this one, or in the AP
 169      register for the innermost frame.  However, there is no way to
 170      tell the difference between the innermost frame and a frame for
 171      which we just don't know the frame that it called (e.g. "info
 172      frame 0x7ffec789").  For the sake of argument, suppose that the
 173      stack is somewhat trashed (which is one reason that "info frame"
 174      exists).  So, return 0 (indicating we don't know the address of
 175      the arglist) if we don't know what frame this frame calls.  */
 176   return 0;
 177 }
 178
 179 static int
 180 vax_frame_num_args (struct frame_info *fi)
 181 {
 182   return (0xff & read_memory_integer (DEPRECATED_FRAME_ARGS_ADDRESS (fi), 1));
 183 }
 184
 185 static CORE_ADDR
 186 vax_frame_chain (struct frame_info *frame)
 187 {
 188   /* In the case of the VAX, the frame's nominal address is the FP value,
 189      and 12 bytes later comes the saved previous FP value as a 4-byte word.  */
 190   if (inside_entry_file (get_frame_pc (frame)))
 191     return (0);
 192
 193   return (read_memory_integer (get_frame_base (frame) + 12, 4));
 194 }
 195 \f
 196 static void
 197 vax_push_dummy_frame (void)
 198 {
 199   CORE_ADDR sp = read_register (SP_REGNUM);
 200   int regnum;
 201
 202   sp = push_word (sp, 0);       /* arglist */
 203   for (regnum = 11; regnum >= 0; regnum--)
 204     sp = push_word (sp, read_register (regnum));
 205   sp = push_word (sp, read_register (PC_REGNUM));
 206   sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
 207   sp = push_word (sp, read_register (VAX_AP_REGNUM));
 208   sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
 209   sp = push_word (sp, 0);
 210   write_register (SP_REGNUM, sp);
 211   write_register (DEPRECATED_FP_REGNUM, sp);
 212   write_register (VAX_AP_REGNUM, sp + (17 * 4));
 213 }
 214
 215 static void
 216 vax_pop_frame (void)
 217 {
 218   CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
 219   int regnum;
 220   int regmask = read_memory_integer (fp + 4, 4);
 221
 222   write_register (PS_REGNUM,
 223                   (regmask & 0xffff)
 224                   | (read_register (PS_REGNUM) & 0xffff0000));
 225   write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
 226   write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp + 12, 4));
 227   write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
 228   fp += 16;
 229   for (regnum = 0; regnum < 12; regnum++)
 230     if (regmask & (0x10000 << regnum))
 231       write_register (regnum, read_memory_integer (fp += 4, 4));
 232   fp = fp + 4 + ((regmask >> 30) & 3);
 233   if (regmask & 0x20000000)
 234     {
 235       regnum = read_memory_integer (fp, 4);
 236       fp += (regnum + 1) * 4;
 237     }
 238   write_register (SP_REGNUM, fp);
 239   flush_cached_frames ();
 240 }
 241
 242 /* The VAX call dummy sequence:
 243
 244         calls #69, @#32323232
 245         bpt
 246
 247    It is 8 bytes long.  The address and argc are patched by
 248    vax_fix_call_dummy().  */
 249 static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
 250 static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
 251
 252 static void
 253 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 254                     struct value **args, struct type *type, int gcc_p)
 255 {
 256   dummy[1] = nargs;
 257   store_unsigned_integer (dummy + 3, 4, fun);
 258 }
 259 \f
 260 static void
 261 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 262 {
 263   write_register (1, addr);
 264 }
 265
 266 static void
 267 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 268 {
 269   memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
 270 }
 271
 272 static void
 273 vax_store_return_value (struct type *valtype, char *valbuf)
 274 {
 275   deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
 276 }
 277
 278 static CORE_ADDR
 279 vax_extract_struct_value_address (char *regbuf)
 280 {
 281   return (extract_unsigned_integer (regbuf + REGISTER_BYTE (0),
 282                                     REGISTER_RAW_SIZE (0)));
 283 }
 284 \f
 285 static const unsigned char *
 286 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 287 {
 288   static const unsigned char vax_breakpoint[] = { 3 };
 289
 290   *lenptr = sizeof(vax_breakpoint);
 291   return (vax_breakpoint);
 292 }
 293 \f
 294 /* Advance PC across any function entry prologue instructions
 295    to reach some "real" code.  */
 296
 297 static CORE_ADDR
 298 vax_skip_prologue (CORE_ADDR pc)
 299 {
 300   register int op = (unsigned char) read_memory_integer (pc, 1);
 301   if (op == 0x11)
 302     pc += 2;                    /* skip brb */
 303   if (op == 0x31)
 304     pc += 3;                    /* skip brw */
 305   if (op == 0xC2
 306       && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
 307     pc += 3;                    /* skip subl2 */
 308   if (op == 0x9E
 309       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
 310       && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
 311     pc += 4;                    /* skip movab */
 312   if (op == 0x9E
 313       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
 314       && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
 315     pc += 5;                    /* skip movab */
 316   if (op == 0x9E
 317       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
 318       && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
 319     pc += 7;                    /* skip movab */
 320   return pc;
 321 }
 322
 323 static CORE_ADDR
 324 vax_saved_pc_after_call (struct frame_info *frame)
 325 {
 326   return (DEPRECATED_FRAME_SAVED_PC(frame));
 327 }
 328 \f
 329 /* Initialize the current architecture based on INFO.  If possible, re-use an
 330    architecture from ARCHES, which is a list of architectures already created
 331    during this debugging session.
 332
 333    Called e.g. at program startup, when reading a core file, and when reading
 334    a binary file.  */
 335
 336 static struct gdbarch *
 337 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 338 {
 339   struct gdbarch *gdbarch;
 340
 341   /* If there is already a candidate, use it.  */
 342   arches = gdbarch_list_lookup_by_info (arches, &info);
 343   if (arches != NULL)
 344     return arches->gdbarch;
 345
 346   gdbarch = gdbarch_alloc (&info, NULL);
 347
 348   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
 349      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
 350   set_gdbarch_deprecated_init_frame_pc (gdbarch, init_frame_pc_default);
 351
 352   /* Register info */
 353   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 354   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 355   set_gdbarch_deprecated_fp_regnum (gdbarch, VAX_FP_REGNUM);
 356   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 357   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 358
 359   set_gdbarch_register_name (gdbarch, vax_register_name);
 360   set_gdbarch_deprecated_register_size (gdbarch, VAX_REGISTER_SIZE);
 361   set_gdbarch_deprecated_register_bytes (gdbarch, VAX_REGISTER_BYTES);
 362   set_gdbarch_deprecated_register_byte (gdbarch, vax_register_byte);
 363   set_gdbarch_deprecated_register_raw_size (gdbarch, vax_register_raw_size);
 364   set_gdbarch_deprecated_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
 365   set_gdbarch_deprecated_register_virtual_size (gdbarch, vax_register_virtual_size);
 366   set_gdbarch_deprecated_max_register_virtual_size (gdbarch,
 367                                          VAX_MAX_REGISTER_VIRTUAL_SIZE);
 368   set_gdbarch_deprecated_register_virtual_type (gdbarch, vax_register_virtual_type);
 369
 370   /* Frame and stack info */
 371   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 372   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
 373
 374   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 375   set_gdbarch_frameless_function_invocation (gdbarch,
 376                                    generic_frameless_function_invocation_not);
 377
 378   set_gdbarch_deprecated_frame_chain (gdbarch, vax_frame_chain);
 379   set_gdbarch_deprecated_frame_saved_pc (gdbarch, vax_frame_saved_pc);
 380
 381   set_gdbarch_deprecated_frame_args_address (gdbarch, vax_frame_args_address);
 382
 383   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
 384
 385   set_gdbarch_frame_args_skip (gdbarch, 4);
 386
 387   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 388
 389   /* Return value info */
 390   set_gdbarch_deprecated_store_struct_return (gdbarch, vax_store_struct_return);
 391   set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
 392   set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
 393   set_gdbarch_deprecated_extract_struct_value_address (gdbarch, vax_extract_struct_value_address);
 394
 395   /* Call dummy info */
 396   set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
 397   set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
 398   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
 399   set_gdbarch_deprecated_call_dummy_words (gdbarch, vax_call_dummy_words);
 400   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
 401   set_gdbarch_deprecated_fix_call_dummy (gdbarch, vax_fix_call_dummy);
 402   set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 7);
 403   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
 404   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 405
 406   /* Breakpoint info */
 407   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 408   set_gdbarch_decr_pc_after_break (gdbarch, 0);
 409
 410   /* Misc info */
 411   set_gdbarch_function_start_offset (gdbarch, 2);
 412   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 413
 414   /* Should be using push_dummy_call.  */
 415   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
 416
 417   /* Hook in ABI-specific overrides, if they have been registered.  */
 418   gdbarch_init_osabi (info, gdbarch);
 419
 420   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 421
 422   return (gdbarch);
 423 }
 424
 425 extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
 426
 427 void
 428 _initialize_vax_tdep (void)
 429 {
 430   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 431 }