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