* Makefile.in (vax-tdep.o): Add $(arch_utils_h), $(inferior_h),

and vax-tdep.h.
* vax-tdep.h: New file.
* vax-tdep.c: Include inferior.h, arch-utils.h, and vax-tdep.h.
Make several routines static.
(vax_get_saved_register): New function.
(vax_gdbarch_init): New function.
(_initialize_vax_tdep): Register vax_gdbarch_init.
* config/vax/tm-vax.h: Set GDB_MULTI_ARCH to GDB_MULTI_ARCH_PARTIAL.
Remove macros now under the control of gdbarch.

1 files changed, 190 insertions, 23 deletions

diff --git a/gdb/vax-tdep.c b/gdb/vax-tdep.c
index 8fc2997..0478227 100644
--- a/gdb/vax-tdep.c
+++ b/gdb/vax-tdep.c
@@ -23,9 +23,39 @@
 #include "symtab.h"
 #include "opcode/vax.h"
 #include "gdbcore.h"
+#include "inferior.h"
 #include "regcache.h"
 #include "frame.h"
 #include "value.h"
+#include "arch-utils.h"
+
+#include "vax-tdep.h"
+
+static gdbarch_register_name_ftype vax_register_name;
+static gdbarch_register_byte_ftype vax_register_byte;
+static gdbarch_register_raw_size_ftype vax_register_raw_size;
+static gdbarch_register_virtual_size_ftype vax_register_virtual_size;
+static gdbarch_register_virtual_type_ftype vax_register_virtual_type;
+
+static gdbarch_skip_prologue_ftype vax_skip_prologue;
+static gdbarch_saved_pc_after_call_ftype vax_saved_pc_after_call;
+static gdbarch_frame_num_args_ftype vax_frame_num_args;
+static gdbarch_frame_chain_ftype vax_frame_chain;
+static gdbarch_frame_saved_pc_ftype vax_frame_saved_pc;
+static gdbarch_frame_args_address_ftype vax_frame_args_address;
+static gdbarch_frame_locals_address_ftype vax_frame_locals_address;
+static gdbarch_frame_init_saved_regs_ftype vax_frame_init_saved_regs;
+static gdbarch_get_saved_register_ftype vax_get_saved_register;
+
+static gdbarch_store_struct_return_ftype vax_store_struct_return;
+static gdbarch_extract_return_value_ftype vax_extract_return_value;
+static gdbarch_store_return_value_ftype vax_store_return_value;
+static gdbarch_extract_struct_value_address_ftype
+    vax_extract_struct_value_address;
+
+static gdbarch_push_dummy_frame_ftype vax_push_dummy_frame;
+static gdbarch_pop_frame_ftype vax_pop_frame;
+static gdbarch_fix_call_dummy_ftype vax_fix_call_dummy;
 
 /* Return 1 if P points to an invalid floating point value.
    LEN is the length in bytes -- not relevant on the Vax.  */
@@ -53,7 +83,7 @@
 
 static unsigned char *print_insn_arg ();
 
-char *
+static char *
 vax_register_name (int regno)
 {
   static char *register_names[] =
@@ -70,31 +100,76 @@ vax_register_name (int regno)
   return (register_names[regno]);
 }
 
-int
+static int
 vax_register_byte (int regno)
 {
   return (regno * 4);
 }
 
-int
+static int
 vax_register_raw_size (int regno)
 {
   return (4);
 }
 
-int
+static int
 vax_register_virtual_size (int regno)
 {
   return (4);
 }
 
-struct type *
+static struct type *
 vax_register_virtual_type (int regno)
 {
   return (builtin_type_int);
 }
 
-void
+static void
+vax_get_saved_register (char *raw_buffer, int *optimized, CORE_ADDR *addrp,
+                        struct frame_info *frame, int regnum,
+                        enum lval_type *lval)
+{
+  CORE_ADDR addr;
+
+  if (!target_has_registers)
+    error ("No registers.");
+
+  /* Normal systems don't optimize out things with register numbers.  */
+  if (optimized != NULL)
+    *optimized = 0;
+  addr = find_saved_register (frame, regnum);
+  if (addr != 0)
+    {
+      if (lval != NULL)
+	*lval = lval_memory;
+      if (regnum == SP_REGNUM)
+	{
+	  if (raw_buffer != NULL)
+	    {
+	      /* Put it back in target format.  */
+	      store_address (raw_buffer, REGISTER_RAW_SIZE (regnum),
+			     (LONGEST) addr);
+	    }
+	  if (addrp != NULL)
+	    *addrp = 0;
+	  return;
+	}
+      if (raw_buffer != NULL)
+	target_read_memory (addr, raw_buffer, REGISTER_RAW_SIZE (regnum));
+    }
+  else
+    {
+      if (lval != NULL)
+	*lval = lval_register;
+      addr = REGISTER_BYTE (regnum);
+      if (raw_buffer != NULL)
+	read_register_gen (regnum, raw_buffer);
+    }
+  if (addrp != NULL)
+    *addrp = addr;
+}
+
+static void
 vax_frame_init_saved_regs (struct frame_info *frame)
 {
   int regnum, regmask;
@@ -128,7 +203,7 @@ vax_frame_init_saved_regs (struct frame_info *frame)
   frame->saved_regs[PS_REGNUM] = frame->frame + 4;
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_frame_saved_pc (struct frame_info *frame)
 {
   if (frame->signal_handler_caller)
@@ -155,7 +230,7 @@ vax_frame_args_address_correct (struct frame_info *frame)
   return (0);
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_frame_args_address (struct frame_info *frame)
 {
   /* In most of GDB, getting the args address is too important to
@@ -167,19 +242,19 @@ vax_frame_args_address (struct frame_info *frame)
   return (read_register (AP_REGNUM));
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_frame_locals_address (struct frame_info *frame)
 {
   return (frame->frame);
 }
 
-int
+static int
 vax_frame_num_args (struct frame_info *fi)
 {
   return (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1));
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_frame_chain (struct frame_info *frame)
 {
   /* In the case of the VAX, the frame's nominal address is the FP value,
@@ -190,7 +265,7 @@ vax_frame_chain (struct frame_info *frame)
   return (read_memory_integer (frame->frame + 12, 4));
 }
 
-void
+static void
 vax_push_dummy_frame (void)
 {
   CORE_ADDR sp = read_register (SP_REGNUM);
@@ -209,7 +284,7 @@ vax_push_dummy_frame (void)
   write_register (AP_REGNUM, sp + (17 * 4));
 }
 
-void
+static void
 vax_pop_frame (void)
 {
   CORE_ADDR fp = read_register (FP_REGNUM);
@@ -243,10 +318,10 @@ vax_pop_frame (void)
 
    It is 8 bytes long.  The address and argc are patched by
    vax_fix_call_dummy().  */
-LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
-int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
+static LONGEST vax_call_dummy_words[] = { 0x329f69fb, 0x03323232 };
+static int sizeof_vax_call_dummy_words = sizeof(vax_call_dummy_words);
 
-void
+static void
 vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
                     struct value **args, struct type *type, int gcc_p)
 {
@@ -254,25 +329,25 @@ vax_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
   store_unsigned_integer (dummy + 3, 4, fun);
 }
 
-void
+static void
 vax_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 {
   write_register (1, addr);
 }
 
-void
+static void
 vax_extract_return_value (struct type *valtype, char *regbuf, char *valbuf)
 {
   memcpy (valbuf, regbuf + REGISTER_BYTE (0), TYPE_LENGTH (valtype));
 }
 
-void
+static void
 vax_store_return_value (struct type *valtype, char *valbuf)
 {
   write_register_bytes (0, valbuf, TYPE_LENGTH (valtype));
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_extract_struct_value_address (char *regbuf)
 {
   return (extract_address (regbuf + REGISTER_BYTE (0), REGISTER_RAW_SIZE (0)));
@@ -281,7 +356,7 @@ vax_extract_struct_value_address (char *regbuf)
 /* Advance PC across any function entry prologue instructions
    to reach some "real" code.  */
 
-CORE_ADDR
+static CORE_ADDR
 vax_skip_prologue (CORE_ADDR pc)
 {
   register int op = (unsigned char) read_memory_integer (pc, 1);
@@ -307,7 +382,7 @@ vax_skip_prologue (CORE_ADDR pc)
   return pc;
 }
 
-CORE_ADDR
+static CORE_ADDR
 vax_saved_pc_after_call (struct frame_info *frame)
 {
   return (FRAME_SAVED_PC(frame));
@@ -363,7 +438,7 @@ vax_print_insn (CORE_ADDR memaddr, disassemble_info *info)
     }
   return p - buffer;
 }
-
+
 static unsigned char *
 print_insn_arg (char *d, register char *p, CORE_ADDR addr,
 		disassemble_info *info)
@@ -534,9 +609,101 @@ print_insn_arg (char *d, register char *p, CORE_ADDR addr,
 
   return (unsigned char *) p;
 }
+
+/* Initialize the current architecture based on INFO.  If possible, re-use an
+   architecture from ARCHES, which is a list of architectures already created
+   during this debugging session.
+
+   Called e.g. at program startup, when reading a core file, and when reading
+   a binary file.  */
+
+static struct gdbarch *
+vax_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+  struct gdbarch *gdbarch;
+
+  /* Right now there is only one VAX architecture variant.  */
+  if (arches != NULL)
+    return (arches->gdbarch);
+
+  gdbarch = gdbarch_alloc (&info, NULL);
+
+  /* Register info */
+  set_gdbarch_num_regs (gdbarch, VAX_NUM_REGS);
+  set_gdbarch_sp_regnum (gdbarch, VAX_SP_REGNUM);
+  set_gdbarch_fp_regnum (gdbarch, VAX_FP_REGNUM);
+  set_gdbarch_pc_regnum (gdbarch, VAX_PC_REGNUM);
+  set_gdbarch_ps_regnum (gdbarch, VAX_PS_REGNUM);
+
+  set_gdbarch_register_name (gdbarch, vax_register_name);
+  set_gdbarch_register_size (gdbarch, VAX_REGISTER_SIZE);
+  set_gdbarch_register_bytes (gdbarch, VAX_REGISTER_BYTES);
+  set_gdbarch_register_byte (gdbarch, vax_register_byte);
+  set_gdbarch_register_raw_size (gdbarch, vax_register_raw_size);
+  set_gdbarch_max_register_raw_size (gdbarch, VAX_MAX_REGISTER_RAW_SIZE);
+  set_gdbarch_register_virtual_size (gdbarch, vax_register_virtual_size);
+  set_gdbarch_max_register_virtual_size (gdbarch,
+                                         VAX_MAX_REGISTER_VIRTUAL_SIZE);
+  set_gdbarch_register_virtual_type (gdbarch, vax_register_virtual_type);
+
+  /* Frame and stack info */
+  set_gdbarch_skip_prologue (gdbarch, vax_skip_prologue);
+  set_gdbarch_saved_pc_after_call (gdbarch, vax_saved_pc_after_call);
+
+  set_gdbarch_frame_num_args (gdbarch, vax_frame_num_args);
+  set_gdbarch_frameless_function_invocation (gdbarch,
+				   generic_frameless_function_invocation_not);
+
+  set_gdbarch_frame_chain (gdbarch, vax_frame_chain);
+  set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
+  set_gdbarch_frame_saved_pc (gdbarch, vax_frame_saved_pc);
+
+  set_gdbarch_frame_args_address (gdbarch, vax_frame_args_address);
+  set_gdbarch_frame_locals_address (gdbarch, vax_frame_locals_address);
+
+  set_gdbarch_frame_init_saved_regs (gdbarch, vax_frame_init_saved_regs);
+
+  set_gdbarch_frame_args_skip (gdbarch, 4);
+
+  set_gdbarch_get_saved_register (gdbarch, vax_get_saved_register);
+
+  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+
+  /* Return value info */
+  set_gdbarch_store_struct_return (gdbarch, vax_store_struct_return);
+  set_gdbarch_extract_return_value (gdbarch, vax_extract_return_value);
+  set_gdbarch_store_return_value (gdbarch, vax_store_return_value);
+  set_gdbarch_extract_struct_value_address (gdbarch,
+					    vax_extract_struct_value_address);
+
+  /* Call dummy info */
+  set_gdbarch_push_dummy_frame (gdbarch, vax_push_dummy_frame);
+  set_gdbarch_pop_frame (gdbarch, vax_pop_frame);
+  set_gdbarch_call_dummy_location (gdbarch, ON_STACK);
+  set_gdbarch_call_dummy_p (gdbarch, 1);
+  set_gdbarch_call_dummy_words (gdbarch, vax_call_dummy_words);
+  set_gdbarch_sizeof_call_dummy_words (gdbarch, sizeof_vax_call_dummy_words);
+  set_gdbarch_fix_call_dummy (gdbarch, vax_fix_call_dummy);
+  set_gdbarch_call_dummy_start_offset (gdbarch, 0);
+  set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
+  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 7);
+  set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+  set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_on_stack);
+  set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
+
+  /* Breakpoint info */
+  set_gdbarch_decr_pc_after_break (gdbarch, 0);
+
+  /* Misc info */
+  set_gdbarch_function_start_offset (gdbarch, 2);
+
+  return (gdbarch);
+}
 
 void
 _initialize_vax_tdep (void)
 {
+  gdbarch_register (bfd_arch_vax, vax_gdbarch_init, NULL);
+
   tm_print_insn = vax_print_insn;
 }