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 "value.h"
  31 #include "arch-utils.h"
  32 #include "gdb_string.h"
  33 #include "osabi.h"
  34 #include "dis-asm.h"
  35
  36 #include "vax-tdep.h"
  37
  38 static gdbarch_register_name_ftype vax_register_name;
  39
  40 static gdbarch_skip_prologue_ftype vax_skip_prologue;
  41 static gdbarch_frame_num_args_ftype vax_frame_num_args;
  42 static gdbarch_deprecated_frame_chain_ftype vax_frame_chain;
  43
  44 static gdbarch_deprecated_extract_return_value_ftype vax_extract_return_value;
  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 (deprecated_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         deprecated_get_frame_saved_regs (frame)[regnum] = next_addr += 4;
 110     }
 111
 112   deprecated_get_frame_saved_regs (frame)[SP_REGNUM] = next_addr + 4;
 113   if (regmask & (1 << DEPRECATED_FP_REGNUM))
 114     deprecated_get_frame_saved_regs (frame)[SP_REGNUM] +=
 115       4 + (4 * read_memory_integer (next_addr + 4, 4));
 116
 117   deprecated_get_frame_saved_regs (frame)[PC_REGNUM] = get_frame_base (frame) + 16;
 118   deprecated_get_frame_saved_regs (frame)[DEPRECATED_FP_REGNUM] = get_frame_base (frame) + 12;
 119   deprecated_get_frame_saved_regs (frame)[VAX_AP_REGNUM] = get_frame_base (frame) + 8;
 120   deprecated_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   /* Offset to saved PC in sigcontext, from <sys/signal.h>.  Don't
 145      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 + 12, 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   return (read_memory_integer (get_frame_base (frame) + 12, 4));
 192 }
 193 \f
 194 static void
 195 vax_push_dummy_frame (void)
 196 {
 197   CORE_ADDR sp = read_register (SP_REGNUM);
 198   int regnum;
 199
 200   sp = push_word (sp, 0);       /* arglist */
 201   for (regnum = 11; regnum >= 0; regnum--)
 202     sp = push_word (sp, read_register (regnum));
 203   sp = push_word (sp, read_register (PC_REGNUM));
 204   sp = push_word (sp, read_register (DEPRECATED_FP_REGNUM));
 205   sp = push_word (sp, read_register (VAX_AP_REGNUM));
 206   sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) + 0x2fff0000);
 207   sp = push_word (sp, 0);
 208   write_register (SP_REGNUM, sp);
 209   write_register (DEPRECATED_FP_REGNUM, sp);
 210   write_register (VAX_AP_REGNUM, sp + (17 * 4));
 211 }
 212
 213 static void
 214 vax_pop_frame (void)
 215 {
 216   CORE_ADDR fp = read_register (DEPRECATED_FP_REGNUM);
 217   int regnum;
 218   int regmask = read_memory_integer (fp + 4, 4);
 219
 220   write_register (PS_REGNUM,
 221                   (regmask & 0xffff)
 222                   | (read_register (PS_REGNUM) & 0xffff0000));
 223   write_register (PC_REGNUM, read_memory_integer (fp + 16, 4));
 224   write_register (DEPRECATED_FP_REGNUM, read_memory_integer (fp + 12, 4));
 225   write_register (VAX_AP_REGNUM, read_memory_integer (fp + 8, 4));
 226   fp += 16;
 227   for (regnum = 0; regnum < 12; regnum++)
 228     if (regmask & (0x10000 << regnum))
 229       write_register (regnum, read_memory_integer (fp += 4, 4));
 230   fp = fp + 4 + ((regmask >> 30) & 3);
 231   if (regmask & 0x20000000)
 232     {
 233       regnum = read_memory_integer (fp, 4);
 234       fp += (regnum + 1) * 4;
 235     }
 236   write_register (SP_REGNUM, fp);
 237   flush_cached_frames ();
 238 }
 239
 240 /* The VAX call dummy sequence:
 241
 242         calls #69, @#32323232
 243         bpt
 244
 245    It is 8 bytes long.  The address and argc are patched by
 246    vax_fix_call_dummy().  */
 247 static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
 248 static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
 249
 250 static void
 251 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 252                     struct value **args, struct type *type, int gcc_p)
 253 {
 254   dummy[1] = nargs;
 255   store_unsigned_integer (dummy + 3, 4, fun);
 256 }
 257 \f
 258 static void
 259 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 260 {
 261   write_register (1, addr);
 262 }
 263
 264 static void
 265 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 266 {
 267   memcpy (valbuf, regbuf + DEPRECATED_REGISTER_BYTE (0), TYPE_LENGTH (valtype));
 268 }
 269
 270 static void
 271 vax_store_return_value (struct type *valtype, char *valbuf)
 272 {
 273   deprecated_write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
 274 }
 275 \f
 276 static const unsigned char *
 277 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 278 {
 279   static const unsigned char vax_breakpoint[] = { 3 };
 280
 281   *lenptr = sizeof(vax_breakpoint);
 282   return (vax_breakpoint);
 283 }
 284 \f
 285 /* Advance PC across any function entry prologue instructions
 286    to reach some "real" code.  */
 287
 288 static CORE_ADDR
 289 vax_skip_prologue (CORE_ADDR pc)
 290 {
 291   int op = (unsigned char) read_memory_integer (pc, 1);
 292   if (op == 0x11)
 293     pc += 2;                    /* skip brb */
 294   if (op == 0x31)
 295     pc += 3;                    /* skip brw */
 296   if (op == 0xC2
 297       && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
 298     pc += 3;                    /* skip subl2 */
 299   if (op == 0x9E
 300       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
 301       && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
 302     pc += 4;                    /* skip movab */
 303   if (op == 0x9E
 304       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
 305       && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
 306     pc += 5;                    /* skip movab */
 307   if (op == 0x9E
 308       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
 309       && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
 310     pc += 7;                    /* skip movab */
 311   return pc;
 312 }
 313
 314 static CORE_ADDR
 315 vax_saved_pc_after_call (struct frame_info *frame)
 316 {
 317   return (DEPRECATED_FRAME_SAVED_PC(frame));
 318 }
 319 \f
 320 /* Initialize the current architecture based on INFO.  If possible, re-use an
 321    architecture from ARCHES, which is a list of architectures already created
 322    during this debugging session.
 323
 324    Called e.g. at program startup, when reading a core file, and when reading
 325    a binary file.  */
 326
 327 static struct gdbarch *
 328 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 329 {
 330   struct gdbarch *gdbarch;
 331
 332   /* If there is already a candidate, use it.  */
 333   arches = gdbarch_list_lookup_by_info (arches, &info);
 334   if (arches != NULL)
 335     return arches->gdbarch;
 336
 337   gdbarch = gdbarch_alloc (&info, NULL);
 338
 339   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
 340      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
 341   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
 342
 343   /* Register info */
 344   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 345   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 346   set_gdbarch_deprecated_fp_regnum (gdbarch, VAX_FP_REGNUM);
 347   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 348   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 349
 350   set_gdbarch_register_name (gdbarch, vax_register_name);
 351   set_gdbarch_deprecated_register_size (gdbarch, VAX_REGISTER_SIZE);
 352   set_gdbarch_deprecated_register_bytes (gdbarch, VAX_REGISTER_BYTES);
 353   set_gdbarch_deprecated_register_byte (gdbarch, vax_register_byte);
 354   set_gdbarch_deprecated_register_raw_size (gdbarch, vax_register_raw_size);
 355   set_gdbarch_deprecated_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
 356   set_gdbarch_deprecated_register_virtual_size (gdbarch, vax_register_virtual_size);
 357   set_gdbarch_deprecated_max_register_virtual_size (gdbarch,
 358                                          VAX_MAX_REGISTER_VIRTUAL_SIZE);
 359   set_gdbarch_deprecated_register_virtual_type (gdbarch, vax_register_virtual_type);
 360
 361   /* Frame and stack info */
 362   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 363   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
 364
 365   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 366   set_gdbarch_frameless_function_invocation (gdbarch,
 367                                    generic_frameless_function_invocation_not);
 368
 369   set_gdbarch_deprecated_frame_chain (gdbarch, vax_frame_chain);
 370   set_gdbarch_deprecated_frame_saved_pc (gdbarch, vax_frame_saved_pc);
 371
 372   set_gdbarch_deprecated_frame_args_address (gdbarch, vax_frame_args_address);
 373
 374   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
 375
 376   set_gdbarch_frame_args_skip (gdbarch, 4);
 377
 378   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 379
 380   /* Return value info */
 381   set_gdbarch_deprecated_store_struct_return (gdbarch, vax_store_struct_return);
 382   set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
 383   set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
 384
 385   /* Call dummy info */
 386   set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
 387   set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
 388   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
 389   set_gdbarch_deprecated_call_dummy_words (gdbarch, vax_call_dummy_words);
 390   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
 391   set_gdbarch_deprecated_fix_call_dummy (gdbarch, vax_fix_call_dummy);
 392   set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 7);
 393   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
 394   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 395
 396   /* Breakpoint info */
 397   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 398
 399   /* Misc info */
 400   set_gdbarch_function_start_offset (gdbarch, 2);
 401   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 402
 403   /* Should be using push_dummy_call.  */
 404   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
 405
 406   /* Hook in ABI-specific overrides, if they have been registered.  */
 407   gdbarch_init_osabi (info, gdbarch);
 408
 409   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 410
 411   return (gdbarch);
 412 }
 413
 414 extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
 415
 416 void
 417 _initialize_vax_tdep (void)
 418 {
 419   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 420 }