Re: [PATCH/RFC] Get Alpha target to GDB_MULTI_ARCH_PARTIAL

[Jason R Thorpe <thorpej@wasabisystems.com>]

[-- Attachment #1: Type: text/plain, Size: 2268 bytes --]

On Sat, Apr 20, 2002 at 09:54:36AM -0700, Jason R Thorpe wrote:

 > Attached is a patch that gets the Alpha target to GDB_MULTI_ARCH_PARTIAL.
 > This is the low-hanging fruit.

Here is an updated version of this patch.  This, combined with the fix to
find_saved_register() I just committed, and using a compiler that emits
correct line number info:

                === gdb Summary ===

# of expected passes            7434
# of unexpected failures        531
# of unexpected successes       1
# of expected failures          70
# of unresolved testcases       149
# of untested testcases         6
# of unsupported tests          4

...for my alpha-netbsd target.

A bunch of the remaining failures look pretty bogus.  A bunch of the
failures are a result of:

(gdb) delete breakpoints^M
Delete all breakpoints? (y or n) info breakpoints^M
break call6i^M
Please answer y or n.^M
Delete all breakpoints? (y or n) Please answer y or n.^M
Delete all breakpoints? (y or n) UNRESOLVED: gdb.base/funcargs.exp: setting brea
kpoint at call6i (timeout)
break call6j^M
Please answer y or n.^M
Delete all breakpoints? (y or n) FAIL: gdb.base/funcargs.exp: setting breakpoint
 at call6j (timeout)
break call6k^M
Please answer y or n.^M
Delete all breakpoints? (y or n) FAIL: gdb.base/funcargs.exp: setting breakpoint
 at call6k (timeout) 
ERROR: Got interactive prompt.

...i.e. getting a prompt when one isn't expected.  Is that possibly a result
of a previous test failing and not setting up state properly for this test?

	* Makefile.in (alpha-nat.o): Add alpha-tdep.h to dependency list.
	(alpha-tdep.o): Likewise.
	* alpha-nat.c: Include alpha-tdep.h.  Update for adjusted
	Alpha target register names.
	* alphabsd-nat.c: Likewise.
	* alpha-tdep.c: Include alpha-tdep.h.  Update for adjusted
	Alpha target register names.  Make serveral routines static.
	(alpha_get_saved_register): New function.
	(alpha_gdbarch_init): New function.
	(_initialize_alpha_tdep): Register alpha_gdbarch_init.
	* alpha-tdep.h: New file.  Includes several Alpha target constants
	taken from...
	* config/alpha/tm-alpha.h: ...here.  Remove macros that we now
	let gdbarch deal with.
	(GDB_MULTI_ARCH): Define as GDB_MULTI_ARCH_PARTIAL.

-- 
        -- Jason R. Thorpe <thorpej@wasabisystems.com>

[-- Attachment #2: alpha-multiarch-2 --]
[-- Type: text/plain, Size: 41246 bytes --]

Index: Makefile.in
===================================================================
RCS file: /cvs/src/src/gdb/Makefile.in,v
retrieving revision 1.169
diff -u -r1.169 Makefile.in
--- Makefile.in	9 Apr 2002 03:06:13 -0000	1.169
+++ Makefile.in	20 Apr 2002 23:56:17 -0000
@@ -1238,11 +1238,11 @@
 	$(regcache_h)
 
 alpha-nat.o: alpha-nat.c $(defs_h) $(gdbcore_h) $(inferior_h) $(target_h) \
-	$(regcache_h)
+	$(regcache_h) alpha-tdep.h
 
 alpha-tdep.o: alpha-tdep.c $(defs_h) $(gdbcmd_h) $(gdbcore_h) \
 	$(inferior_h) $(symtab_h) $(dis_asm_h) $(gdb_string_h) $(linespec_h) \
-	$(regcache_h) $(doublest_h)
+	$(regcache_h) $(doublest_h) alpha-tdep.h
 
 annotate.o: annotate.c $(defs_h) $(annotate_h) $(value_h) $(target_h) $(gdbtypes_h)
 
Index: alpha-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-nat.c,v
retrieving revision 1.8
diff -u -r1.8 alpha-nat.c
--- alpha-nat.c	20 Oct 2001 19:32:40 -0000	1.8
+++ alpha-nat.c	20 Apr 2002 23:56:17 -0000
@@ -24,6 +24,9 @@
 #include "gdbcore.h"
 #include "target.h"
 #include "regcache.h"
+
+#include "alpha-tdep.h"
+
 #include <sys/ptrace.h>
 #ifdef __linux__
 #include <asm/reg.h>
@@ -62,7 +65,7 @@
   CORE_ADDR jb_addr;
   char raw_buffer[MAX_REGISTER_RAW_SIZE];
 
-  jb_addr = read_register (A0_REGNUM);
+  jb_addr = read_register (ALPHA_A0_REGNUM);
 
   if (target_read_memory (jb_addr + JB_PC * JB_ELEMENT_SIZE, raw_buffer,
 			  sizeof (CORE_ADDR)))
@@ -171,10 +174,11 @@
   else
     {
       /* The General Registers.  */
-      memcpy (&registers[REGISTER_BYTE (V0_REGNUM)], core_reg_sect, 31 * 8);
+      memcpy (&registers[REGISTER_BYTE (ALPHA_V0_REGNUM)], core_reg_sect,
+              31 * 8);
       memcpy (&registers[REGISTER_BYTE (PC_REGNUM)], core_reg_sect + 31 * 8, 8);
-      memset (&registers[REGISTER_BYTE (ZERO_REGNUM)], 0, 8);
-      memset (&register_valid[V0_REGNUM], 1, 32);
+      memset (&registers[REGISTER_BYTE (ALPHA_ZERO_REGNUM)], 0, 8);
+      memset (&register_valid[ALPHA_V0_REGNUM], 1, 32);
       register_valid[PC_REGNUM] = 1;
     }
 }
@@ -227,7 +231,7 @@
   supply_register (PC_REGNUM, (char *) (regp + 31));
 
   /* Fill inaccessible registers with zero.  */
-  supply_register (ZERO_REGNUM, zerobuf);
+  supply_register (ALPHA_ZERO_REGNUM, zerobuf);
   supply_register (FP_REGNUM, zerobuf);
 }
 
Index: alpha-tdep.c
===================================================================
RCS file: /cvs/src/src/gdb/alpha-tdep.c,v
retrieving revision 1.20
diff -u -r1.20 alpha-tdep.c
--- alpha-tdep.c	19 Apr 2002 05:11:52 -0000	1.20
+++ alpha-tdep.c	20 Apr 2002 23:56:19 -0000
@@ -33,6 +33,46 @@
 #include "linespec.h"
 #include "regcache.h"
 #include "doublest.h"
+#include "arch-utils.h"
+
+#include "alpha-tdep.h"
+
+static gdbarch_init_ftype alpha_gdbarch_init;
+
+static gdbarch_register_name_ftype alpha_register_name;
+static gdbarch_register_raw_size_ftype alpha_register_raw_size;
+static gdbarch_register_virtual_size_ftype alpha_register_virtual_size;
+static gdbarch_register_virtual_type_ftype alpha_register_virtual_type;
+static gdbarch_register_byte_ftype alpha_register_byte;
+static gdbarch_cannot_fetch_register_ftype alpha_cannot_fetch_register;
+static gdbarch_cannot_store_register_ftype alpha_cannot_store_register;
+static gdbarch_register_convertible_ftype alpha_register_convertible;
+static gdbarch_register_convert_to_virtual_ftype
+    alpha_register_convert_to_virtual;
+static gdbarch_register_convert_to_raw_ftype alpha_register_convert_to_raw;
+static gdbarch_store_struct_return_ftype alpha_store_struct_return;
+static gdbarch_extract_return_value_ftype alpha_extract_return_value;
+static gdbarch_store_return_value_ftype alpha_store_return_value;
+static gdbarch_extract_struct_value_address_ftype
+    alpha_extract_struct_value_address;
+static gdbarch_use_struct_convention_ftype alpha_use_struct_convention;
+
+static gdbarch_frame_args_address_ftype alpha_frame_args_address;
+static gdbarch_frame_locals_address_ftype alpha_frame_locals_address;
+
+static gdbarch_skip_prologue_ftype alpha_skip_prologue;
+static gdbarch_get_saved_register_ftype alpha_get_saved_register;
+static gdbarch_saved_pc_after_call_ftype alpha_saved_pc_after_call;
+static gdbarch_frame_chain_ftype alpha_frame_chain;
+static gdbarch_frame_saved_pc_ftype alpha_frame_saved_pc;
+static gdbarch_frame_init_saved_regs_ftype alpha_frame_init_saved_regs;
+
+static gdbarch_push_arguments_ftype alpha_push_arguments;
+static gdbarch_push_dummy_frame_ftype alpha_push_dummy_frame;
+static gdbarch_pop_frame_ftype alpha_pop_frame;
+static gdbarch_fix_call_dummy_ftype alpha_fix_call_dummy;
+static gdbarch_init_frame_pc_first_ftype alpha_init_frame_pc_first;
+static gdbarch_init_extra_frame_info_ftype alpha_init_extra_frame_info;
 
 struct frame_extra_info
   {
@@ -275,7 +315,7 @@
 }
 \f
 
-char *
+static char *
 alpha_register_name (int regno)
 {
   static char *register_names[] =
@@ -298,44 +338,44 @@
   return (register_names[regno]);
 }
 
-int
+static int
 alpha_cannot_fetch_register (int regno)
 {
-  return (regno == FP_REGNUM || regno == ZERO_REGNUM);
+  return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
 }
 
-int
+static int
 alpha_cannot_store_register (int regno)
 {
-  return (regno == FP_REGNUM || regno == ZERO_REGNUM);
+  return (regno == FP_REGNUM || regno == ALPHA_ZERO_REGNUM);
 }
 
-int
+static int
 alpha_register_convertible (int regno)
 {
   return (regno >= FP0_REGNUM && regno <= FP0_REGNUM + 31);
 }
 
-struct type *
+static struct type *
 alpha_register_virtual_type (int regno)
 {
   return ((regno >= FP0_REGNUM && regno < (FP0_REGNUM+31))
 	  ? builtin_type_double : builtin_type_long);
 }
 
-int
+static int
 alpha_register_byte (int regno)
 {
   return (regno * 8);
 }
 
-int
+static int
 alpha_register_raw_size (int regno)
 {
   return 8;
 }
 
-int
+static int
 alpha_register_virtual_size (int regno)
 {
   return 8;
@@ -433,7 +473,7 @@
   frame->saved_regs[PC_REGNUM] = frame->saved_regs[returnreg];
 }
 
-void
+static void
 alpha_frame_init_saved_regs (struct frame_info *fi)
 {
   if (fi->saved_regs == NULL)
@@ -441,7 +481,7 @@
   fi->saved_regs[SP_REGNUM] = fi->frame;
 }
 
-void
+static void
 alpha_init_frame_pc_first (int fromleaf, struct frame_info *prev)
 {
   prev->pc = (fromleaf ? SAVED_PC_AFTER_CALL (prev->next) :
@@ -468,7 +508,7 @@
   return read_register (regno);
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_frame_saved_pc (struct frame_info *frame)
 {
   alpha_extra_func_info_t proc_desc = frame->extra_info->proc_desc;
@@ -483,7 +523,55 @@
   return read_next_frame_reg (frame, pcreg);
 }
 
-CORE_ADDR
+static void
+alpha_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 CORE_ADDR
 alpha_saved_pc_after_call (struct frame_info *frame)
 {
   CORE_ADDR pc = frame->pc;
@@ -497,7 +585,7 @@
     pc = tmp;
 
   proc_desc = find_proc_desc (pc, frame->next);
-  pcreg = proc_desc ? PROC_PC_REG (proc_desc) : RA_REGNUM;
+  pcreg = proc_desc ? PROC_PC_REG (proc_desc) : ALPHA_RA_REGNUM;
 
   if (frame->signal_handler_caller)
     return alpha_frame_saved_pc (frame);
@@ -507,7 +595,7 @@
 
 
 static struct alpha_extra_func_info temp_proc_desc;
-static CORE_ADDR temp_saved_regs[NUM_REGS];
+static CORE_ADDR temp_saved_regs[ALPHA_NUM_REGS];
 
 /* Nonzero if instruction at PC is a return instruction.  "ret
    $zero,($ra),1" on alpha. */
@@ -646,7 +734,8 @@
 	     e.g. via the minimal symbol table, might obviate this hack.  */
 	  if (pcreg == -1
 	      && cur_pc < (start_pc + 80)
-	      && (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM))
+	      && (reg == ALPHA_T7_REGNUM || reg == ALPHA_T9_REGNUM
+	          || reg == ALPHA_RA_REGNUM))
 	    pcreg = reg;
 	}
       else if ((word & 0xffe0ffff) == 0x6be08001)	/* ret zero,reg,1 */
@@ -672,7 +761,8 @@
 	      && (word & 0xffff0000) != 0xb7fe0000)	/* reg != $zero */
 	    {
 	      int reg = (word & 0x03e00000) >> 21;
-	      if (reg == T7_REGNUM || reg == T9_REGNUM || reg == RA_REGNUM)
+	      if (reg == ALPHA_T7_REGNUM || reg == ALPHA_T9_REGNUM
+	          || reg == ALPHA_RA_REGNUM)
 		{
 		  pcreg = reg;
 		  break;
@@ -687,12 +777,12 @@
     }
 
   if (has_frame_reg)
-    PROC_FRAME_REG (&temp_proc_desc) = GCC_FP_REGNUM;
+    PROC_FRAME_REG (&temp_proc_desc) = ALPHA_GCC_FP_REGNUM;
   else
     PROC_FRAME_REG (&temp_proc_desc) = SP_REGNUM;
   PROC_FRAME_OFFSET (&temp_proc_desc) = frame_size;
   PROC_REG_MASK (&temp_proc_desc) = reg_mask;
-  PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? RA_REGNUM : pcreg;
+  PROC_PC_REG (&temp_proc_desc) = (pcreg == -1) ? ALPHA_RA_REGNUM : pcreg;
   PROC_LOCALOFF (&temp_proc_desc) = 0;	/* XXX - bogus */
   return &temp_proc_desc;
 }
@@ -874,7 +964,7 @@
 
 alpha_extra_func_info_t cached_proc_desc;
 
-CORE_ADDR
+static CORE_ADDR
 alpha_frame_chain (struct frame_info *frame)
 {
   alpha_extra_func_info_t proc_desc;
@@ -920,7 +1010,7 @@
 		     paddr_d (fi->extra_info->proc_desc->pdr.frameoffset));
 }
 
-void
+static void
 alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
 {
   /* Use proc_desc calculated in frame_chain */
@@ -932,7 +1022,7 @@
 
   frame->saved_regs = NULL;
   frame->extra_info->localoff = 0;
-  frame->extra_info->pc_reg = RA_REGNUM;
+  frame->extra_info->pc_reg = ALPHA_RA_REGNUM;
   frame->extra_info->proc_desc = proc_desc == &temp_proc_desc ? 0 : proc_desc;
   if (proc_desc)
     {
@@ -975,19 +1065,19 @@
 	      memcpy (frame->saved_regs, temp_saved_regs,
 	              SIZEOF_FRAME_SAVED_REGS);
 	      frame->saved_regs[PC_REGNUM]
-		= frame->saved_regs[RA_REGNUM];
+		= frame->saved_regs[ALPHA_RA_REGNUM];
 	    }
 	}
     }
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_frame_locals_address (struct frame_info *fi)
 {
   return (fi->frame - fi->extra_info->localoff);
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_frame_args_address (struct frame_info *fi)
 {
   return (fi->frame - (ALPHA_NUM_ARG_REGS * 8));
@@ -1027,7 +1117,7 @@
    If the called function is returning a structure, the address of the
    structure to be returned is passed as a hidden first argument.  */
 
-CORE_ADDR
+static CORE_ADDR
 alpha_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
 		      int struct_return, CORE_ADDR struct_addr)
 {
@@ -1102,14 +1192,14 @@
       LONGEST val;
 
       val = read_memory_integer (sp + i * 8, 8);
-      write_register (A0_REGNUM + i, val);
-      write_register (FPA0_REGNUM + i, val);
+      write_register (ALPHA_A0_REGNUM + i, val);
+      write_register (ALPHA_FPA0_REGNUM + i, val);
     }
 
   return sp + arg_regs_size;
 }
 
-void
+static void
 alpha_push_dummy_frame (void)
 {
   int ireg;
@@ -1117,7 +1207,7 @@
   alpha_extra_func_info_t proc_desc;
   CORE_ADDR sp = read_register (SP_REGNUM);
   CORE_ADDR save_address;
-  char raw_buffer[MAX_REGISTER_RAW_SIZE];
+  char raw_buffer[ALPHA_MAX_REGISTER_RAW_SIZE];
   unsigned long mask;
 
   link = (struct linked_proc_info *) xmalloc (sizeof (struct linked_proc_info));
@@ -1172,14 +1262,14 @@
      registers follow in ascending order.
      The PC is saved immediately below the SP.  */
   save_address = sp + PROC_REG_OFFSET (proc_desc);
-  store_address (raw_buffer, 8, read_register (RA_REGNUM));
+  store_address (raw_buffer, 8, read_register (ALPHA_RA_REGNUM));
   write_memory (save_address, raw_buffer, 8);
   save_address += 8;
   mask = PROC_REG_MASK (proc_desc) & 0xffffffffL;
   for (ireg = 0; mask; ireg++, mask >>= 1)
     if (mask & 1)
       {
-	if (ireg == RA_REGNUM)
+	if (ireg == ALPHA_RA_REGNUM)
 	  continue;
 	store_address (raw_buffer, 8, read_register (ireg));
 	write_memory (save_address, raw_buffer, 8);
@@ -1222,10 +1312,10 @@
   PROC_HIGH_ADDR (proc_desc) = PROC_LOW_ADDR (proc_desc) + 4;
 
   SET_PROC_DESC_IS_DUMMY (proc_desc);
-  PROC_PC_REG (proc_desc) = RA_REGNUM;
+  PROC_PC_REG (proc_desc) = ALPHA_RA_REGNUM;
 }
 
-void
+static void
 alpha_pop_frame (void)
 {
   register int regnum;
@@ -1368,7 +1458,7 @@
   return pc + offset;
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_skip_prologue (CORE_ADDR addr)
 {
   return (alpha_skip_prologue_internal (addr, 0));
@@ -1392,7 +1482,7 @@
    or
    memory format is an integer with 4 bytes or less, as the representation
    of integers in floating point registers is different. */
-void
+static void
 alpha_register_convert_to_virtual (int regnum, struct type *valtype,
 				   char *raw_buffer, char *virtual_buffer)
 {
@@ -1418,7 +1508,7 @@
     error ("Cannot retrieve value from floating point register");
 }
 
-void
+static void
 alpha_register_convert_to_raw (struct type *valtype, int regnum,
 			       char *virtual_buffer, char *raw_buffer)
 {
@@ -1450,7 +1540,7 @@
 /* Given a return value in `regbuf' with a type `valtype', 
    extract and copy its value into `valbuf'.  */
 
-void
+static void
 alpha_extract_return_value (struct type *valtype,
 			    char regbuf[REGISTER_BYTES], char *valbuf)
 {
@@ -1459,17 +1549,18 @@
 				       regbuf + REGISTER_BYTE (FP0_REGNUM),
 				       valbuf);
   else
-    memcpy (valbuf, regbuf + REGISTER_BYTE (V0_REGNUM), TYPE_LENGTH (valtype));
+    memcpy (valbuf, regbuf + REGISTER_BYTE (ALPHA_V0_REGNUM),
+            TYPE_LENGTH (valtype));
 }
 
 /* Given a return value in `regbuf' with a type `valtype', 
    write its value into the appropriate register.  */
 
-void
+static void
 alpha_store_return_value (struct type *valtype, char *valbuf)
 {
-  char raw_buffer[MAX_REGISTER_RAW_SIZE];
-  int regnum = V0_REGNUM;
+  char raw_buffer[ALPHA_MAX_REGISTER_RAW_SIZE];
+  int regnum = ALPHA_V0_REGNUM;
   int length = TYPE_LENGTH (valtype);
 
   if (TYPE_CODE (valtype) == TYPE_CODE_FLT)
@@ -1517,7 +1608,7 @@
     return SYMBOL_VALUE_ADDRESS (sym) + 4;
 }
 
-void
+static void
 alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
                       struct value **args, struct type *type, int gcc_p)
 {
@@ -1525,8 +1616,8 @@
 
   if (bp_address == 0)
     error ("no place to put call");
-  write_register (RA_REGNUM, bp_address);
-  write_register (T12_REGNUM, fun);
+  write_register (ALPHA_RA_REGNUM, bp_address);
+  write_register (ALPHA_T12_REGNUM, fun);
 }
 
 /* On the Alpha, the call dummy code is nevery copied to user space
@@ -1534,25 +1625,25 @@
    matter.  */
 LONGEST alpha_call_dummy_words[] = { 0 };
 
-int
+static int
 alpha_use_struct_convention (int gcc_p, struct type *type)
 {
   /* Structures are returned by ref in extra arg0.  */
   return 1;
 }
 
-void
+static void
 alpha_store_struct_return (CORE_ADDR addr, CORE_ADDR sp)
 {
   /* Store the address of the place in which to copy the structure the
      subroutine will return.  Handled by alpha_push_arguments.  */
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_extract_struct_value_address (char *regbuf)
 {
-  return (extract_address (regbuf + REGISTER_BYTE (V0_REGNUM),
-			   REGISTER_RAW_SIZE (V0_REGNUM)));
+  return (extract_address (regbuf + REGISTER_BYTE (ALPHA_V0_REGNUM),
+			   REGISTER_RAW_SIZE (ALPHA_V0_REGNUM)));
 }
 
 /* alpha_software_single_step() is called just before we want to resume
@@ -1664,10 +1755,130 @@
     }
 }
 
+/* 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 *
+alpha_gdbarch_init (struct gdbarch_info info, struct gdbarch_list *arches)
+{
+  struct gdbarch *gdbarch;
+
+  /* Right now there is only one Alpha architecture variant.  This will
+     change as we migrate OS-specific info into multiarch.  */
+  if (arches != NULL)
+    return arches->gdbarch;
+
+  gdbarch = gdbarch_alloc (&info, NULL);
+
+  /* Type sizes */
+  set_gdbarch_short_bit (gdbarch, 16);
+  set_gdbarch_int_bit (gdbarch, 32);
+  set_gdbarch_long_bit (gdbarch, 64);
+  set_gdbarch_long_long_bit (gdbarch, 64);
+  set_gdbarch_float_bit (gdbarch, 32);
+  set_gdbarch_double_bit (gdbarch, 64);
+  set_gdbarch_long_double_bit (gdbarch, 64);
+  set_gdbarch_ptr_bit (gdbarch, 64);
+
+  /* Register info */
+  set_gdbarch_num_regs (gdbarch, ALPHA_NUM_REGS);
+  set_gdbarch_sp_regnum (gdbarch, ALPHA_SP_REGNUM);
+  set_gdbarch_fp_regnum (gdbarch, ALPHA_FP_REGNUM);
+  set_gdbarch_pc_regnum (gdbarch, ALPHA_PC_REGNUM);
+  set_gdbarch_fp0_regnum (gdbarch, ALPHA_FP0_REGNUM);
+
+  set_gdbarch_register_name (gdbarch, alpha_register_name);
+  set_gdbarch_register_size (gdbarch, ALPHA_REGISTER_SIZE);
+  set_gdbarch_register_bytes (gdbarch, ALPHA_REGISTER_BYTES);
+  set_gdbarch_register_byte (gdbarch, alpha_register_byte);
+  set_gdbarch_register_raw_size (gdbarch, alpha_register_raw_size);
+  set_gdbarch_max_register_raw_size (gdbarch, ALPHA_MAX_REGISTER_RAW_SIZE);
+  set_gdbarch_register_virtual_size (gdbarch, alpha_register_virtual_size);
+  set_gdbarch_max_register_virtual_size (gdbarch,
+                                         ALPHA_MAX_REGISTER_VIRTUAL_SIZE);
+  set_gdbarch_register_virtual_type (gdbarch, alpha_register_virtual_type);
+
+  set_gdbarch_cannot_fetch_register (gdbarch, alpha_cannot_fetch_register);
+  set_gdbarch_cannot_store_register (gdbarch, alpha_cannot_store_register);
+
+  set_gdbarch_register_convertible (gdbarch, alpha_register_convertible);
+  set_gdbarch_register_convert_to_virtual (gdbarch,
+                                           alpha_register_convert_to_virtual);
+  set_gdbarch_register_convert_to_raw (gdbarch, alpha_register_convert_to_raw);
+
+  set_gdbarch_skip_prologue (gdbarch, alpha_skip_prologue);
+
+  set_gdbarch_frame_num_args (gdbarch, frame_num_args_unknown);
+  set_gdbarch_frameless_function_invocation (gdbarch,
+                                    generic_frameless_function_invocation_not);
+
+  set_gdbarch_saved_pc_after_call (gdbarch, alpha_saved_pc_after_call);
+
+  set_gdbarch_frame_chain (gdbarch, alpha_frame_chain);
+  set_gdbarch_frame_chain_valid (gdbarch, func_frame_chain_valid);
+  set_gdbarch_frame_saved_pc (gdbarch, alpha_frame_saved_pc);
+
+  set_gdbarch_frame_init_saved_regs (gdbarch, alpha_frame_init_saved_regs);
+  set_gdbarch_get_saved_register (gdbarch, alpha_get_saved_register);
+
+  set_gdbarch_use_struct_convention (gdbarch, alpha_use_struct_convention);
+  set_gdbarch_extract_return_value (gdbarch, alpha_extract_return_value);
+
+  set_gdbarch_store_struct_return (gdbarch, alpha_store_struct_return);
+  set_gdbarch_store_return_value (gdbarch, alpha_store_return_value);
+  set_gdbarch_extract_struct_value_address (gdbarch,
+					    alpha_extract_struct_value_address);
+
+  /* Settings for calling functions in the inferior.  */
+  set_gdbarch_use_generic_dummy_frames (gdbarch, 0);
+  set_gdbarch_call_dummy_length (gdbarch, 0);
+  set_gdbarch_push_arguments (gdbarch, alpha_push_arguments);
+  set_gdbarch_pop_frame (gdbarch, alpha_pop_frame);
+
+  /* On the Alpha, the call dummy code is never copied to user space,
+     stopping the user call is achieved via a bp_call_dummy breakpoint.
+     But we need a fake CALL_DUMMY definition to enable the proper
+     call_function_by_hand and to avoid zero length array warnings.  */
+  set_gdbarch_call_dummy_p (gdbarch, 1);
+  set_gdbarch_call_dummy_words (gdbarch, alpha_call_dummy_words);
+  set_gdbarch_sizeof_call_dummy_words (gdbarch, 0);
+  set_gdbarch_frame_args_address (gdbarch, alpha_frame_args_address);
+  set_gdbarch_frame_locals_address (gdbarch, alpha_frame_locals_address);
+  set_gdbarch_init_extra_frame_info (gdbarch, alpha_init_extra_frame_info);
+
+  /* Alpha OSF/1 inhibits execution of code on the stack.  But there is
+     no need for a dummy on the Alpha.  PUSH_ARGUMENTS takes care of all
+     argument handling and bp_call_dummy takes care of stopping the dummy.  */
+  set_gdbarch_call_dummy_location (gdbarch, AT_ENTRY_POINT);
+  set_gdbarch_call_dummy_address (gdbarch, alpha_call_dummy_address);
+  set_gdbarch_call_dummy_breakpoint_offset_p (gdbarch, 1);
+  set_gdbarch_call_dummy_breakpoint_offset (gdbarch, 0);
+  set_gdbarch_call_dummy_start_offset (gdbarch, 0);
+  set_gdbarch_pc_in_call_dummy (gdbarch, pc_in_call_dummy_at_entry_point);
+  set_gdbarch_call_dummy_stack_adjust_p (gdbarch, 0);
+  set_gdbarch_push_dummy_frame (gdbarch, alpha_push_dummy_frame);
+  set_gdbarch_fix_call_dummy (gdbarch, alpha_fix_call_dummy);
+  set_gdbarch_init_frame_pc (gdbarch, init_frame_pc_noop);
+  set_gdbarch_init_frame_pc_first (gdbarch, alpha_init_frame_pc_first);
+
+  set_gdbarch_inner_than (gdbarch, core_addr_lessthan);
+
+  set_gdbarch_decr_pc_after_break (gdbarch, 4);
+  set_gdbarch_frame_args_skip (gdbarch, 0);
+
+  return gdbarch;
+}
+
 void
 _initialize_alpha_tdep (void)
 {
   struct cmd_list_element *c;
+
+  register_gdbarch_init (bfd_arch_alpha, alpha_gdbarch_init);
 
   tm_print_insn = print_insn_alpha;
 
Index: alpha-tdep.h
===================================================================
RCS file: alpha-tdep.h
diff -N alpha-tdep.h
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ alpha-tdep.h	20 Apr 2002 23:56:19 -0000
@@ -0,0 +1,74 @@
+/* Common target dependent code for GDB on Alpha systems.
+   Copyright 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2002 Free
+   Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* Say how long (ordinary) registers are.  This is a piece of bogosity
+   used in push_word and a few other places;  REGISTER_RAW_SIZE is the
+   real way to know how big a register is.  */
+#define ALPHA_REGISTER_SIZE 8
+
+/* Number of machine registers.  */
+#define ALPHA_NUM_REGS 66
+
+/* Total amount of space needed to store our copies of the machine's
+   register state.  */
+#define ALPHA_REGISTER_BYTES (ALPHA_NUM_REGS * 8)
+
+/* Largest value REGISTER_RAW_SIZE can have.  */
+#define ALPHA_MAX_REGISTER_RAW_SIZE 8
+
+/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
+#define ALPHA_MAX_REGISTER_VIRTUAL_SIZE 8
+
+/* Register numbers of various important registers.
+   Note that most of these values are "real" register numbers,
+   and correspond to the general registers of the machine,
+   and FP_REGNUM is a "phony" register number which is too large
+   to be an actual register number as far as the user is concerned
+   but serves to get the desired value when passed to read_register.  */
+
+#define ALPHA_V0_REGNUM	     0  /* Function integer return value */
+#define ALPHA_T7_REGNUM	     8  /* Return address register for OSF/1 __add* */
+#define ALPHA_GCC_FP_REGNUM 15  /* Used by gcc as frame register */
+#define ALPHA_A0_REGNUM     16  /* Loc of first arg during a subr call */
+#define ALPHA_T9_REGNUM     23  /* Return address register for OSF/1 __div* */
+#define ALPHA_T12_REGNUM    27  /* Contains start addr of current proc */
+#define ALPHA_SP_REGNUM     30  /* Contains address of top of stack */
+#define ALPHA_RA_REGNUM     26  /* Contains return address value */
+#define ALPHA_ZERO_REGNUM   31  /* Read-only register, always 0 */
+#define ALPHA_FP0_REGNUM    32  /* Floating point register 0 */
+#define ALPHA_FPA0_REGNUM   48  /* First float arg during a subr call */
+#define ALPHA_FPCR_REGNUM   63  /* Floating point control register */
+#define ALPHA_PC_REGNUM     64  /* Contains program counter */
+#define ALPHA_FP_REGNUM     65  /* Virtual frame pointer */
+
+/* The alpha has two different virtual pointers for arguments and locals.
+   
+   The virtual argument pointer is pointing to the bottom of the argument
+   transfer area, which is located immediately below the virtual frame
+   pointer. Its size is fixed for the native compiler, it is either zero
+   (for the no arguments case) or large enough to hold all argument registers.
+   gcc uses a variable sized argument transfer area. As it has
+   to stay compatible with the native debugging tools it has to use the same
+   virtual argument pointer and adjust the argument offsets accordingly.
+   
+   The virtual local pointer is localoff bytes below the virtual frame
+   pointer, the value of localoff is obtained from the PDR.  */
+#define ALPHA_NUM_ARG_REGS   6
Index: alphabsd-nat.c
===================================================================
RCS file: /cvs/src/src/gdb/alphabsd-nat.c,v
retrieving revision 1.6
diff -u -r1.6 alphabsd-nat.c
--- alphabsd-nat.c	18 Jan 2002 17:47:13 -0000	1.6
+++ alphabsd-nat.c	20 Apr 2002 23:56:19 -0000
@@ -22,6 +22,8 @@
 #include "inferior.h"
 #include "regcache.h"
 
+#include "alpha-tdep.h"
+
 #include <sys/types.h>
 #include <sys/ptrace.h>
 #include <machine/reg.h>
@@ -103,7 +105,7 @@
 	supply_register (i, (char *) &fpregsetp->fpr_regs[i - FP0_REGNUM]);
     }
 
-  supply_register (FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
+  supply_register (ALPHA_FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
 }
 
 /* Fill register REGNO (if it is a floating-point register) in
@@ -119,8 +121,8 @@
     if ((regno == -1 || regno == i) && ! CANNOT_STORE_REGISTER (i))
       regcache_collect (i, (char *) &fpregsetp->fpr_regs[i - FP0_REGNUM]);
 
-  if (regno == -1 || regno == FPCR_REGNUM)
-    regcache_collect (FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
+  if (regno == -1 || regno == ALPHA_FPCR_REGNUM)
+    regcache_collect (ALPHA_FPCR_REGNUM, (char *) &fpregsetp->fpr_cr);
 }
 
 
@@ -130,7 +132,7 @@
 getregs_supplies (int regno)
 {
 
-  return ((regno >= V0_REGNUM && regno <= ZERO_REGNUM)
+  return ((regno >= ALPHA_V0_REGNUM && regno <= ALPHA_ZERO_REGNUM)
 	  || regno >= PC_REGNUM);
 }
 
Index: config/alpha/tm-alpha.h
===================================================================
RCS file: /cvs/src/src/gdb/config/alpha/tm-alpha.h,v
retrieving revision 1.18
diff -u -r1.18 tm-alpha.h
--- config/alpha/tm-alpha.h	19 Apr 2002 05:11:53 -0000	1.18
+++ config/alpha/tm-alpha.h	20 Apr 2002 23:56:21 -0000
@@ -24,6 +24,8 @@
 #ifndef TM_ALPHA_H
 #define TM_ALPHA_H
 
+#define GDB_MULTI_ARCH GDB_MULTI_ARCH_PARTIAL
+
 #include "regcache.h"
 #include "bfd.h"
 #include "coff/sym.h"		/* Needed for PDR below.  */
@@ -34,12 +36,6 @@
 struct value;
 struct symbol;
 
-/* Redefine some target bit sizes from the default.  */
-
-#define TARGET_LONG_BIT 64
-#define TARGET_LONG_LONG_BIT 64
-#define TARGET_PTR_BIT 64
-
 /* Number of traps that happen between exec'ing the shell 
  * to run an inferior, and when we finally get to 
  * the inferior code.  This is 2 on most implementations.
@@ -51,326 +47,21 @@
 
 #define FUNCTION_START_OFFSET 0
 
-/* Advance PC across any function entry prologue instructions
-   to reach some "real" code.  */
-
-#define SKIP_PROLOGUE(pc) alpha_skip_prologue((pc))
-extern CORE_ADDR alpha_skip_prologue (CORE_ADDR addr);
-
-/* Immediately after a function call, return the saved pc.
-   Can't always go through the frames for this because on some machines
-   the new frame is not set up until the new function executes
-   some instructions.  */
-
-#define SAVED_PC_AFTER_CALL(frame) alpha_saved_pc_after_call(frame)
-extern CORE_ADDR alpha_saved_pc_after_call (struct frame_info *);
-
 /* Are we currently handling a signal ?  */
 
 #define IN_SIGTRAMP(pc, name) alpha_osf_in_sigtramp ((pc), (name))
 extern int alpha_osf_in_sigtramp (CORE_ADDR, char *);
 
-/* Stack grows downward.  */
-
-#define INNER_THAN(lhs,rhs) core_addr_lessthan ((lhs), (rhs))
-
 #define BREAKPOINT {0x80, 0, 0, 0}	/* call_pal bpt */
 
-/* Amount PC must be decremented by after a breakpoint.
-   This is often the number of bytes in BREAKPOINT
-   but not always.  */
-
-#ifndef DECR_PC_AFTER_BREAK
-#define DECR_PC_AFTER_BREAK 4
-#endif
-
-/* Say how long (ordinary) registers are.  This is a piece of bogosity
-   used in push_word and a few other places; REGISTER_RAW_SIZE is the
-   real way to know how big a register is.  */
-
-#define REGISTER_SIZE 8
-
-/* Number of machine registers */
-
-#define NUM_REGS 66
-
-
-/* Return the name of register REGNO.  */
-
-#define REGISTER_NAME(regno) alpha_register_name ((regno))
-extern char *alpha_register_name (int);
-
-
-/* Register numbers of various important registers.
-   Note that most of these values are "real" register numbers,
-   and correspond to the general registers of the machine,
-   and FP_REGNUM is a "phony" register number which is too large
-   to be an actual register number as far as the user is concerned
-   but serves to get the desired value when passed to read_register.  */
-
-#define V0_REGNUM 0		/* Function integer return value */
-#define T7_REGNUM 8		/* Return address register for OSF/1 __add* */
-#define GCC_FP_REGNUM 15	/* Used by gcc as frame register */
-#define A0_REGNUM 16		/* Loc of first arg during a subr call */
-#define T9_REGNUM 23		/* Return address register for OSF/1 __div* */
-#define T12_REGNUM 27		/* Contains start addr of current proc */
-#define SP_REGNUM 30		/* Contains address of top of stack */
-#define RA_REGNUM 26		/* Contains return address value */
-#define ZERO_REGNUM 31		/* Read-only register, always 0 */
-#define FP0_REGNUM 32		/* Floating point register 0 */
-#define FPA0_REGNUM 48		/* First float arg during a subr call */
-#define FPCR_REGNUM 63		/* Floating point control register */
-#define PC_REGNUM 64		/* Contains program counter */
-#define FP_REGNUM 65		/* Virtual frame pointer */
-
-#define CANNOT_FETCH_REGISTER(regno) \
-  alpha_cannot_fetch_register ((regno))
-extern int alpha_cannot_fetch_register (int);
-
-#define CANNOT_STORE_REGISTER(regno) \
-  alpha_cannot_store_register ((regno))
-extern int alpha_cannot_store_register (int);
-
-/* Total amount of space needed to store our copies of the machine's
-   register state, the array `registers'.  */
-#define REGISTER_BYTES (NUM_REGS * 8)
-
-/* Index within `registers' of the first byte of the space for
-   register N.  */
-
-#define REGISTER_BYTE(N) alpha_register_byte ((N))
-extern int alpha_register_byte (int);
-
-/* Number of bytes of storage in the actual machine representation
-   for register N.  On Alphas, all regs are 8 bytes.  */
-
-#define REGISTER_RAW_SIZE(N) alpha_register_raw_size ((N))
-extern int alpha_register_raw_size (int);
-
-/* Number of bytes of storage in the program's representation
-   for register N.  On Alphas, all regs are 8 bytes.  */
-
-#define REGISTER_VIRTUAL_SIZE(N) alpha_register_virtual_size ((N))
-extern int alpha_register_virtual_size (int);
-
-/* Largest value REGISTER_RAW_SIZE can have.  */
-
-#define MAX_REGISTER_RAW_SIZE 8
-
-/* Largest value REGISTER_VIRTUAL_SIZE can have.  */
-
-#define MAX_REGISTER_VIRTUAL_SIZE 8
-
-/* Nonzero if register N requires conversion
-   from raw format to virtual format.
-   The alpha needs a conversion between register and memory format if
-   the register is a floating point register and
-   memory format is float, as the register format must be double
-   or
-   memory format is an integer with 4 bytes or less, as the representation
-   of integers in floating point registers is different. */
-
-#define REGISTER_CONVERTIBLE(N) alpha_register_convertible ((N))
-extern int alpha_register_convertible (int);
-
-/* Convert data from raw format for register REGNUM in buffer FROM
-   to virtual format with type TYPE in buffer TO.  */
-
-#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM, TYPE, FROM, TO) \
-  alpha_register_convert_to_virtual (REGNUM, TYPE, FROM, TO)
-extern void
-alpha_register_convert_to_virtual (int, struct type *, char *, char *);
-
-/* Convert data from virtual format with type TYPE in buffer FROM
-   to raw format for register REGNUM in buffer TO.  */
-
-#define REGISTER_CONVERT_TO_RAW(TYPE, REGNUM, FROM, TO)	\
-  alpha_register_convert_to_raw (TYPE, REGNUM, FROM, TO)
-extern void
-alpha_register_convert_to_raw (struct type *, int, char *, char *);
-
-/* Return the GDB type object for the "standard" data type
-   of data in register N.  */
-
-#define REGISTER_VIRTUAL_TYPE(N) alpha_register_virtual_type ((N))
-extern struct type * alpha_register_virtual_type (int);
-
-/* Store the address of the place in which to copy the structure the
-   subroutine will return.  Handled by alpha_push_arguments.  */
-
-#define STORE_STRUCT_RETURN(addr, sp) \
-  alpha_store_struct_return ((addr), (sp))
-extern void alpha_store_struct_return (CORE_ADDR, CORE_ADDR);
-/**/
-
-/* Extract from an array REGBUF containing the (raw) register state
-   a function return value of type TYPE, and copy that, in virtual format,
-   into VALBUF.  */
-
-#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \
-  alpha_extract_return_value(TYPE, REGBUF, VALBUF)
-extern void alpha_extract_return_value (struct type *, char *, char *);
-
-/* Write into appropriate registers a function return value
-   of type TYPE, given in virtual format.  */
-
-#define STORE_RETURN_VALUE(TYPE,VALBUF) \
-  alpha_store_return_value(TYPE, VALBUF)
-extern void alpha_store_return_value (struct type *, char *);
-
-/* Extract from an array REGBUF containing the (raw) register state
-   the address in which a function should return its structure value,
-   as a CORE_ADDR (or an expression that can be used as one).  */
-/* The address is passed in a0 upon entry to the function, but when
-   the function exits, the compiler has copied the value to v0.  This
-   convention is specified by the System V ABI, so I think we can rely
-   on it.  */
-
-#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \
-  alpha_extract_struct_value_address (REGBUF)
-extern CORE_ADDR alpha_extract_struct_value_address (char *);
-
-/* Structures are returned by ref in extra arg0 */
-#define USE_STRUCT_CONVENTION(gcc_p, type) \
-  alpha_use_struct_convention ((gcc_p), (type))
-extern int alpha_use_struct_convention (int, struct type *);
-\f
-
-/* Describe the pointer in each stack frame to the previous stack frame
-   (its caller).  */
-
-/* FRAME_CHAIN takes a frame's nominal address
-   and produces the frame's chain-pointer. */
-
-#define FRAME_CHAIN(thisframe) alpha_frame_chain (thisframe)
-extern CORE_ADDR alpha_frame_chain (struct frame_info *);
-
-/* Define other aspects of the stack frame.  */
-
-
-/* An expression that tells us whether the function invocation represented
-   by FI does not have a frame on the stack associated with it. */
-/* We handle this differently for alpha, and maybe we should not */
-
-#define FRAMELESS_FUNCTION_INVOCATION(FI) \
-  generic_frameless_function_invocation_not ((FI))
-
-/* Saved Pc.  */
-
-#define FRAME_SAVED_PC(FRAME) alpha_frame_saved_pc(FRAME)
-extern CORE_ADDR alpha_frame_saved_pc (struct frame_info *);
-
-/* The alpha has two different virtual pointers for arguments and locals.
-
-   The virtual argument pointer is pointing to the bottom of the argument
-   transfer area, which is located immediately below the virtual frame
-   pointer. Its size is fixed for the native compiler, it is either zero
-   (for the no arguments case) or large enough to hold all argument registers.
-   gcc uses a variable sized argument transfer area. As it has
-   to stay compatible with the native debugging tools it has to use the same
-   virtual argument pointer and adjust the argument offsets accordingly.
-
-   The virtual local pointer is localoff bytes below the virtual frame
-   pointer, the value of localoff is obtained from the PDR.  */
-
-#define ALPHA_NUM_ARG_REGS	6
-
-#define FRAME_ARGS_ADDRESS(fi) alpha_frame_args_address ((fi))
-extern CORE_ADDR alpha_frame_args_address (struct frame_info *);
-
-#define FRAME_LOCALS_ADDRESS(fi) alpha_frame_locals_address ((fi))
-extern CORE_ADDR alpha_frame_locals_address (struct frame_info *);
-
-/* Return number of args passed to a frame.
-   Can return -1, meaning no way to tell.  */
-
-#define FRAME_NUM_ARGS(fi) frame_num_args_unknown ((fi))
-
-/* Return number of bytes at start of arglist that are not really args.  */
-
-#define FRAME_ARGS_SKIP 0
-
-/* Put here the code to store, into a struct frame_saved_regs,
-   the addresses of the saved registers of frame described by FRAME_INFO.
-   This includes special registers such as pc and fp saved in special
-   ways in the stack frame.  sp is even more special:
-   the address we return for it IS the sp for the next frame.  */
-
-#define FRAME_INIT_SAVED_REGS(frame_info) \
-  alpha_frame_init_saved_regs (frame_info)
-extern void alpha_frame_init_saved_regs (struct frame_info *);
-\f
-
-/* Things needed for making the inferior call functions.  */
-
-#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \
-  (alpha_push_arguments((nargs), (args), (sp), (struct_return), (struct_addr)))
-extern CORE_ADDR
-alpha_push_arguments (int, struct value **, CORE_ADDR, int, CORE_ADDR);
-
-/* Push an empty stack frame, to record the current PC, etc.  */
-
-#define PUSH_DUMMY_FRAME alpha_push_dummy_frame()
-extern void alpha_push_dummy_frame (void);
-
-/* Discard from the stack the innermost frame, restoring all registers.  */
-
-#define POP_FRAME alpha_pop_frame()
-extern void alpha_pop_frame (void);
-
-/* Alpha OSF/1 inhibits execution of code on the stack.
-   But there is no need for a dummy on the alpha. PUSH_ARGUMENTS
-   takes care of all argument handling and bp_call_dummy takes care
-   of stopping the dummy.  */
-
-#define CALL_DUMMY_LOCATION AT_ENTRY_POINT
-
-/* On the Alpha the call dummy code is never copied to user space,
-   stopping the user call is achieved via a bp_call_dummy breakpoint.
-   But we need a fake CALL_DUMMY definition to enable the proper
-   call_function_by_hand and to avoid zero length array warnings
-   in valops.c  */
-
-#define CALL_DUMMY_P (1)
-
-#define CALL_DUMMY_WORDS alpha_call_dummy_words
-extern LONGEST alpha_call_dummy_words[];
-
-#define SIZEOF_CALL_DUMMY_WORDS 0
-
-#define CALL_DUMMY_START_OFFSET (0)
-
-#define CALL_DUMMY_BREAKPOINT_OFFSET (0)
-
-#define CALL_DUMMY_ADDRESS() alpha_call_dummy_address()
-extern CORE_ADDR alpha_call_dummy_address (void);
-
-/* Insert the specified number of args and function address
-   into a call sequence of the above form stored at DUMMYNAME.
-   We only have to set RA_REGNUM to the dummy breakpoint address
-   and T12_REGNUM (the `procedure value register') to the function address.  */
-
-#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \
-  alpha_fix_call_dummy ((dummyname), (pc), (fun), (nargs), (args), \
-			(type), (gcc_p))
-extern void alpha_fix_call_dummy (char *, CORE_ADDR, CORE_ADDR, int,
-                                  struct value **, struct type *, int);
-
-/* There's a mess in stack frame creation.  See comments in blockframe.c
-   near reference to INIT_FRAME_PC_FIRST.  */
-
-#define INIT_FRAME_PC(fromleaf, prev) init_frame_pc_noop ((fromleaf), (prev))
-
-#define INIT_FRAME_PC_FIRST(fromleaf, prev) \
-  alpha_init_frame_pc_first ((fromleaf), (prev))
-extern void alpha_init_frame_pc_first (int, struct frame_info *);
-
 /* Special symbol found in blocks associated with routines.  We can hang
    alpha_extra_func_info_t's off of this.  */
 
 #define MIPS_EFI_SYMBOL_NAME "__GDB_EFI_INFO__"
 extern void ecoff_relocate_efi (struct symbol *, CORE_ADDR);
 
+#define RA_REGNUM 26		/* XXXJRT needed by mdebugread.c */
+
 /* Specific information about a procedure.
    This overlays the ALPHA's PDR records, 
    alpharead.c (ab)uses this to save memory */
@@ -389,10 +80,6 @@
 #define mips_extra_func_info alpha_extra_func_info
 #define mips_extra_func_info_t alpha_extra_func_info_t
 
-
-#define INIT_EXTRA_FRAME_INFO(fromleaf, fci) \
-  alpha_init_extra_frame_info(fromleaf, fci)
-extern void alpha_init_extra_frame_info (int, struct frame_info *);
 
 #define PRINT_EXTRA_FRAME_INFO(fi) alpha_print_extra_frame_info ((fi))
 extern void alpha_print_extra_frame_info (struct frame_info *);