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