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