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   /* 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 (deprecated_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 + DEPRECATED_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 \f
 278 static const unsigned char *
 279 vax_breakpoint_from_pc (CORE_ADDR *pcptr, int *lenptr)
 280 {
 281   static const unsigned char vax_breakpoint[] = { 3 };
 282
 283   *lenptr = sizeof(vax_breakpoint);
 284   return (vax_breakpoint);
 285 }
 286 \f
 287 /* Advance PC across any function entry prologue instructions
 288    to reach some "real" code.  */
 289
 290 static CORE_ADDR
 291 vax_skip_prologue (CORE_ADDR pc)
 292 {
 293   int op = (unsigned char) read_memory_integer (pc, 1);
 294   if (op == 0x11)
 295     pc += 2;                    /* skip brb */
 296   if (op == 0x31)
 297     pc += 3;                    /* skip brw */
 298   if (op == 0xC2
 299       && ((unsigned char) read_memory_integer (pc + 2, 1)) == 0x5E)
 300     pc += 3;                    /* skip subl2 */
 301   if (op == 0x9E
 302       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xAE
 303       && ((unsigned char) read_memory_integer (pc + 3, 1)) == 0x5E)
 304     pc += 4;                    /* skip movab */
 305   if (op == 0x9E
 306       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xCE
 307       && ((unsigned char) read_memory_integer (pc + 4, 1)) == 0x5E)
 308     pc += 5;                    /* skip movab */
 309   if (op == 0x9E
 310       && ((unsigned char) read_memory_integer (pc + 1, 1)) == 0xEE
 311       && ((unsigned char) read_memory_integer (pc + 6, 1)) == 0x5E)
 312     pc += 7;                    /* skip movab */
 313   return pc;
 314 }
 315
 316 static CORE_ADDR
 317 vax_saved_pc_after_call (struct frame_info *frame)
 318 {
 319   return (DEPRECATED_FRAME_SAVED_PC(frame));
 320 }
 321 \f
 322 /* Initialize the current architecture based on INFO.  If possible, re-use an
 323    architecture from ARCHES, which is a list of architectures already created
 324    during this debugging session.
 325
 326    Called e.g. at program startup, when reading a core file, and when reading
 327    a binary file.  */
 328
 329 static struct gdbarch *
 330 vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
 331 {
 332   struct gdbarch *gdbarch;
 333
 334   /* If there is already a candidate, use it.  */
 335   arches = gdbarch_list_lookup_by_info (arches, &info);
 336   if (arches != NULL)
 337     return arches->gdbarch;
 338
 339   gdbarch = gdbarch_alloc (&info, NULL);
 340
 341   /* NOTE: cagney/2002-12-06: This can be deleted when this arch is
 342      ready to unwind the PC first (see frame.c:get_prev_frame()).  */
 343   set_gdbarch_deprecated_init_frame_pc (gdbarch, deprecated_init_frame_pc_default);
 344
 345   /* Register info */
 346   set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
 347   set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
 348   set_gdbarch_deprecated_fp_regnum (gdbarch, VAX_FP_REGNUM);
 349   set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
 350   set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
 351
 352   set_gdbarch_register_name (gdbarch, vax_register_name);
 353   set_gdbarch_deprecated_register_size (gdbarch, VAX_REGISTER_SIZE);
 354   set_gdbarch_deprecated_register_bytes (gdbarch, VAX_REGISTER_BYTES);
 355   set_gdbarch_deprecated_register_byte (gdbarch, vax_register_byte);
 356   set_gdbarch_deprecated_register_raw_size (gdbarch, vax_register_raw_size);
 357   set_gdbarch_deprecated_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
 358   set_gdbarch_deprecated_register_virtual_size (gdbarch, vax_register_virtual_size);
 359   set_gdbarch_deprecated_max_register_virtual_size (gdbarch,
 360                                          VAX_MAX_REGISTER_VIRTUAL_SIZE);
 361   set_gdbarch_deprecated_register_virtual_type (gdbarch, vax_register_virtual_type);
 362
 363   /* Frame and stack info */
 364   set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
 365   set_gdbarch_deprecated_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
 366
 367   set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
 368   set_gdbarch_frameless_function_invocation (gdbarch,
 369                                    generic_frameless_function_invocation_not);
 370
 371   set_gdbarch_deprecated_frame_chain (gdbarch, vax_frame_chain);
 372   set_gdbarch_deprecated_frame_saved_pc (gdbarch, vax_frame_saved_pc);
 373
 374   set_gdbarch_deprecated_frame_args_address (gdbarch, vax_frame_args_address);
 375
 376   set_gdbarch_deprecated_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
 377
 378   set_gdbarch_frame_args_skip (gdbarch, 4);
 379
 380   set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
 381
 382   /* Return value info */
 383   set_gdbarch_deprecated_store_struct_return (gdbarch, vax_store_struct_return);
 384   set_gdbarch_deprecated_extract_return_value (gdbarch, vax_extract_return_value);
 385   set_gdbarch_deprecated_store_return_value (gdbarch, vax_store_return_value);
 386
 387   /* Call dummy info */
 388   set_gdbarch_deprecated_push_dummy_frame (gdbarch, vax_push_dummy_frame);
 389   set_gdbarch_deprecated_pop_frame (gdbarch, vax_pop_frame);
 390   set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
 391   set_gdbarch_deprecated_call_dummy_words (gdbarch, vax_call_dummy_words);
 392   set_gdbarch_deprecated_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
 393   set_gdbarch_deprecated_fix_call_dummy (gdbarch, vax_fix_call_dummy);
 394   set_gdbarch_deprecated_call_dummy_breakpoint_offset (gdbarch, 7);
 395   set_gdbarch_deprecated_use_generic_dummy_frames (gdbarch, 0);
 396   set_gdbarch_deprecated_pc_in_call_dummy (gdbarch, deprecated_pc_in_call_dummy_on_stack);
 397
 398   /* Breakpoint info */
 399   set_gdbarch_breakpoint_from_pc (gdbarch, vax_breakpoint_from_pc);
 400
 401   /* Misc info */
 402   set_gdbarch_function_start_offset (gdbarch, 2);
 403   set_gdbarch_believe_pcc_promotion (gdbarch, 1);
 404
 405   /* Should be using push_dummy_call.  */
 406   set_gdbarch_deprecated_dummy_write_sp (gdbarch, deprecated_write_sp);
 407
 408   /* Hook in ABI-specific overrides, if they have been registered.  */
 409   gdbarch_init_osabi (info, gdbarch);
 410
 411   set_gdbarch_print_insn (gdbarch, print_insn_vax);
 412
 413   return (gdbarch);
 414 }
 415
 416 extern initialize_file_ftype _initialize_vax_tdep; /* -Wmissing-prototypes */
 417
 418 void
 419 _initialize_vax_tdep (void)
 420 {
 421   gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
 422 }