* 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.
* Makefile.in (alpha-nat.o): Add alpha-tdep.h and $(BFD_SRC)/elf-bfd
to dependency list.
* 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_abi_names): New.
(process_note_abi_tag_sections): New function.
(get_elfosabi): New function.
(alpha_gdbarch_init): New function.
(alpha_dump_tdep): New function.
(_initialize_alpha_tdep): Register alpha_gdbarch_init.

1 files changed, 464 insertions, 51 deletions

diff --git a/gdb/alpha-tdep.c b/gdb/alpha-tdep.c
index 1a81ec8c31c..7d99cf5f449 100644
--- a/gdb/alpha-tdep.c
+++ b/gdb/alpha-tdep.c
@@ -33,6 +33,48 @@
 #include "linespec.h"
 #include "regcache.h"
 #include "doublest.h"
+#include "arch-utils.h"
+
+#include "elf-bfd.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 +317,7 @@ push_sigtramp_desc (CORE_ADDR low_addr)
 }
 
 
-char *
+static char *
 alpha_register_name (int regno)
 {
   static char *register_names[] =
@@ -298,44 +340,44 @@ alpha_register_name (int regno)
   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 +475,7 @@ alpha_find_saved_regs (struct frame_info *frame)
   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 +483,7 @@ alpha_frame_init_saved_regs (struct frame_info *fi)
   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 +510,7 @@ read_next_frame_reg (struct frame_info *fi, int regno)
   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 +525,55 @@ alpha_frame_saved_pc (struct frame_info *frame)
   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 +587,7 @@ alpha_saved_pc_after_call (struct frame_info *frame)
     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 +597,7 @@ alpha_saved_pc_after_call (struct frame_info *frame)
 
 
 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 +736,8 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
 	     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 +763,8 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
 	      && (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 +779,12 @@ heuristic_proc_desc (CORE_ADDR start_pc, CORE_ADDR limit_pc,
     }
 
   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 +966,7 @@ find_proc_desc (CORE_ADDR pc, struct frame_info *next_frame)
 
 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 +1012,7 @@ alpha_print_extra_frame_info (struct frame_info *fi)
 		     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 +1024,7 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
 
   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 +1067,19 @@ alpha_init_extra_frame_info (int fromleaf, struct frame_info *frame)
 	      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 +1119,7 @@ alpha_setup_arbitrary_frame (int argc, CORE_ADDR *argv)
    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 +1194,14 @@ alpha_push_arguments (int nargs, struct value **args, CORE_ADDR sp,
       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 +1209,7 @@ alpha_push_dummy_frame (void)
   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 +1264,14 @@ alpha_push_dummy_frame (void)
      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 +1314,10 @@ alpha_push_dummy_frame (void)
   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 +1460,7 @@ alpha_skip_prologue_internal (CORE_ADDR pc, int lenient)
   return pc + offset;
 }
 
-CORE_ADDR
+static CORE_ADDR
 alpha_skip_prologue (CORE_ADDR addr)
 {
   return (alpha_skip_prologue_internal (addr, 0));
@@ -1392,7 +1484,7 @@ alpha_in_lenient_prologue (CORE_ADDR startaddr, CORE_ADDR pc)
    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 +1510,7 @@ alpha_register_convert_to_virtual (int regnum, struct type *valtype,
     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 +1542,7 @@ alpha_register_convert_to_raw (struct type *valtype, int regnum,
 /* 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 +1551,18 @@ alpha_extract_return_value (struct type *valtype,
 				       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 +1610,7 @@ alpha_call_dummy_address (void)
     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 +1618,8 @@ alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
 
   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 +1627,25 @@ alpha_fix_call_dummy (char *dummy, CORE_ADDR pc, CORE_ADDR fun, int nargs,
    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,11 +1757,331 @@ alpha_software_single_step (enum target_signal sig, int insert_breakpoints_p)
     }
 }
 
+
+/* This table matches the indices assigned to enum alpha_abi.  Keep
+   them in sync.  */
+static const char * const alpha_abi_names[] =
+{
+  "<unknown>",
+  "OSF/1",
+  "GNU/Linux",
+  "FreeBSD",
+  "NetBSD",
+  NULL
+};
+
+static void
+process_note_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
+{
+  enum alpha_abi *os_ident_ptr = obj;
+  const char *name;
+  unsigned int sectsize;
+
+  name = bfd_get_section_name (abfd, sect);
+  sectsize = bfd_section_size (abfd, sect);
+
+  if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
+    {
+      unsigned int name_length, data_length, note_type;
+      char *note;
+
+      /* If the section is larger than this, it's probably not what we are
+	 looking for.  */
+      if (sectsize > 128)
+	sectsize = 128;
+
+      note = alloca (sectsize);
+
+      bfd_get_section_contents (abfd, sect, note,
+				(file_ptr) 0, (bfd_size_type) sectsize);
+
+      name_length = bfd_h_get_32 (abfd, note);
+      data_length = bfd_h_get_32 (abfd, note + 4);
+      note_type   = bfd_h_get_32 (abfd, note + 8);
+
+      if (name_length == 4 && data_length == 16 && note_type == 1
+	  && strcmp (note + 12, "GNU") == 0)
+	{
+	  int os_number = bfd_h_get_32 (abfd, note + 16);
+
+	  /* The case numbers are from abi-tags in glibc.  */
+	  switch (os_number)
+	    {
+	    case 0 :
+	      *os_ident_ptr = ALPHA_ABI_LINUX;
+	      break;
+
+	    case 1 :
+	      internal_error
+		(__FILE__, __LINE__,
+		 "process_note_abi_sections: Hurd objects not supported");
+	      break;
+
+	    case 2 :
+	      internal_error
+		(__FILE__, __LINE__,
+		 "process_note_abi_sections: Solaris objects not supported");
+	      break;
+
+	    default :
+	      internal_error
+		(__FILE__, __LINE__,
+		 "process_note_abi_sections: unknown OS number %d",
+		 os_number);
+	      break;
+	    }
+	}
+    }
+  /* NetBSD uses a similar trick.  */
+  else if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
+    {
+      unsigned int name_length, desc_length, note_type;
+      char *note;
+
+      /* If the section is larger than this, it's probably not what we are
+         looking for.  */
+      if (sectsize > 128)
+	sectsize = 128;
+
+      note = alloca (sectsize);
+
+      bfd_get_section_contents (abfd, sect, note,
+				 (file_ptr) 0, (bfd_size_type) sectsize);
+      
+      name_length = bfd_h_get_32 (abfd, note);
+      desc_length = bfd_h_get_32 (abfd, note + 4);
+      note_type   = bfd_h_get_32 (abfd, note + 8);
+
+      if (name_length == 7 && desc_length == 4 && note_type == 1
+	  && strcmp (note + 12, "NetBSD") == 0)
+	/* XXX Should we check the version here?
+	   Probably not necessary yet.  */
+	*os_ident_ptr = ALPHA_ABI_NETBSD;
+    }
+}
+
+static int
+get_elfosabi (bfd *abfd)
+{
+  int elfosabi;
+  enum alpha_abi alpha_abi = ALPHA_ABI_UNKNOWN;
+
+  elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
+
+  /* When elfosabi is 0 (ELFOSABI_NONE), this is supposed to indicate
+     what we're on a SYSV system.  However, GNU/Linux uses a note section
+     to record OS/ABI info, but leaves e_ident[EI_OSABI] zero.  So we
+     have to check the note sections too.  */
+  if (elfosabi == 0)
+    {
+      bfd_map_over_sections (abfd,
+			     process_note_abi_tag_sections,
+			     &alpha_abi);
+    }
+
+  if (alpha_abi != ALPHA_ABI_UNKNOWN)
+    return alpha_abi;
+
+  switch (elfosabi)
+    {
+    case ELFOSABI_NONE:
+      /* Leave it as unknown.  */
+      break;
+
+    case ELFOSABI_NETBSD:
+      return ALPHA_ABI_NETBSD;
+
+    case ELFOSABI_FREEBSD:
+      return ALPHA_ABI_FREEBSD;
+
+    case ELFOSABI_LINUX:
+      return ALPHA_ABI_LINUX;
+    }
+
+  return ALPHA_ABI_UNKNOWN;
+}
+
+/* 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_tdep *tdep;
+  struct gdbarch *gdbarch;
+  enum alpha_abi alpha_abi = ALPHA_ABI_UNKNOWN;
+
+  /* Try to determine the ABI of the object we are loading.  */
+
+  if (info.abfd != NULL)
+    {
+      switch (bfd_get_flavour (info.abfd))
+	{
+	case bfd_target_elf_flavour:
+	  alpha_abi = get_elfosabi (info.abfd);
+	  break;
+
+	case bfd_target_ecoff_flavour:
+	  /* Assume it's OSF/1.  */
+	  alpha_abi = ALPHA_ABI_OSF1;
+          break;
+
+	default:
+	  /* Not sure what to do here, leave the ABI as unknown.  */
+	  break;
+	}
+    }
+
+  /* Find a candidate among extant architectures.  */
+  for (arches = gdbarch_list_lookup_by_info (arches, &info);
+       arches != NULL;
+       arches = gdbarch_list_lookup_by_info (arches->next, &info))
+    {
+      /* Make sure the ABI selection matches.  */
+      tdep = gdbarch_tdep (arches->gdbarch);
+      if (tdep && tdep->alpha_abi == alpha_abi)
+	return arches->gdbarch;
+    }
+
+  tdep = xmalloc (sizeof (struct gdbarch_tdep));
+  gdbarch = gdbarch_alloc (&info, tdep);
+
+  tdep->alpha_abi = alpha_abi;
+  if (alpha_abi < ALPHA_ABI_INVALID)
+    tdep->abi_name = alpha_abi_names[alpha_abi];
+  else
+    {
+      internal_error (__FILE__, __LINE__, "Invalid setting of alpha_abi %d",
+		      (int) alpha_abi);
+      tdep->abi_name = "<invalid>";
+    }
+
+  /* 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;
+}
+
+static void
+alpha_dump_tdep (struct gdbarch *current_gdbarch, struct ui_file *file)
+{
+  struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
+
+  if (tdep == NULL)
+    return;
+
+  if (tdep->abi_name != NULL)
+    fprintf_unfiltered (file, "alpha_dump_tdep: ABI = %s\n", tdep->abi_name);
+  else
+    internal_error (__FILE__, __LINE__,
+		    "alpha_dump_tdep: illegal setting of tdep->alpha_abi (%d)",
+		    (int) tdep->alpha_abi);
+}
+
 void
 _initialize_alpha_tdep (void)
 {
   struct cmd_list_element *c;
 
+  gdbarch_register (bfd_arch_alpha, alpha_gdbarch_init, alpha_dump_tdep);
+
   tm_print_insn = print_insn_alpha;
 
   /* Let the user set the fence post for heuristic_proc_start.  */