* elf32-hppa.c: Second half of major cleanup. More comments,

	PARAMize and staticize rest of functions.  Delete unused
	functions.  Delete unused/unnecessary arguments to some functions.
	Group static vars together.  Abort for bad errors until we have
	error code propogation working.  Work on spacing and indention.
	Add FIXMEs for unresolved problems.  Use enums rather than
	#defines for lots of things.  Merge two functions which build
	linker stubs into a single function (so they can easily share a
	ton of common code).

3 files changed, 864 insertions, 947 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index 44b4f50..3f8fae9 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,15 @@
+Sun Feb 27 11:18:47 1994  Jeffrey A. Law  (law@snake.cs.utah.edu)
+
+	* elf32-hppa.c: Second half of major cleanup.  More comments,
+	PARAMize and staticize rest of functions.  Delete unused
+	functions.  Delete unused/unnecessary arguments to some functions.
+	Group static vars together.  Abort for bad errors until we have
+	error code propogation working.  Work on spacing and indention.
+	Add FIXMEs for unresolved problems.  Use enums rather than
+	#defines for lots of things.  Merge two functions which build
+	linker stubs into a single function (so they can easily share a
+	ton of common code).
+
 Sat Feb 26 10:00:45 1994  Ian Lance Taylor  (ian@cygnus.com)
 
 	* reloc.c (_bfd_relocate_contents): Adjust handling of overflow to
diff --git a/bfd/elf32-hppa.c b/bfd/elf32-hppa.c
index d4e94bd..74399a8 100644
--- a/bfd/elf32-hppa.c
+++ b/bfd/elf32-hppa.c
@@ -44,7 +44,155 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "aout/aout64.h"
 #include "hppa_stubs.h"
 
-/* ELF/PA relocation howto entries.  */
+/* The basic stub types supported.  If/when shared libraries are
+   implemented some form of IMPORT and EXPORT stubs will be needed.  */
+typedef enum
+{
+  HPPA_STUB_ILLEGAL,
+  HPPA_STUB_ARG_RELOC,
+  HPPA_STUB_LONG_CALL,
+} hppa_stub_type;
+
+/* This is a list of all the stubs for a particular BFD.  */
+
+typedef struct elf32_hppa_stub_name_list_struct
+{
+  /* The symbol associated with this stub.  */
+  asymbol *sym;
+  /* Pointer to chain of all stub chains.  */
+  struct elf32_hppa_stub_description_struct *stub_desc;
+  /* Pointer to the stub contents (eg instructions).  */  
+  int *stub_secp;
+  /* Size of this stub?  (in what units?  FIXME).  */
+  unsigned size;
+  /* Pointer to the next stub entry in the chain.  */
+  struct elf32_hppa_stub_name_list_struct *next;
+} elf32_hppa_stub_name_list;
+
+/* This is a linked list in which each entry describes all the
+   linker stubs for a particular bfd.  */
+   
+typedef struct elf32_hppa_stub_description_struct
+{
+  /* The next group of stubs.  */
+  struct elf32_hppa_stub_description_struct *next;
+  /* Used to identify this group of stubs as belonging
+     to a particular bfd.  */
+  bfd *this_bfd;
+  /* FIXME: The stub section for this group of stubs?  Is
+     this redundant with stub_listP->sym->section?  */
+  asection *stub_sec;
+  /* FIXME: what the hell is this?  */
+  unsigned relocs_allocated_cnt;
+  /* The current real size of the stubs (in bytes?).  */
+  unsigned real_size;
+  /* How much space we have allocated for stubs (in bytes?).  */
+  unsigned allocated_size;
+  /* Pointer to the first available space for new stubs.  */
+  int *stub_secp;
+  /* Pointer to the beginning of the stubs.  FIXME: Why an int *
+     above and a char * here?  */
+  char *stub_contents;
+  /* The list of stubs for this bfd.  */
+  elf32_hppa_stub_name_list *stub_listP;
+  /* I guess we just carry this around for fun.  */
+  struct bfd_link_info *link_info;
+} elf32_hppa_stub_description;
+
+/* FIXME.  */
+#define ARGUMENTS	0
+#define RETURN_VALUE	1
+
+/* The various argument relocations that may be performed.
+   Note GRX,GRY really means ARGX,ARGY.  */
+typedef enum
+{
+  /* No relocation.  */
+  NO_ARG_RELOC,
+  /* Relocate 32 bits from general to FP register.  */
+  R_TO_FR,
+  /* Relocate 64 bits from arg0,arg1 to FParg1.  */
+  R01_TO_FR,
+  /* Relocate 64 bits from arg2,arg3 to FParg3.  */
+  R23_TO_FR,
+  /* Relocate 32 bits from FP to general register.  */
+  FR_TO_R,
+  /* Relocate 64 bits from FParg1 to arg0,arg1.  */
+  FR_TO_R01,
+  /* Relocate 64 bits from FParg3 to arg2,arg3.  */
+  FR_TO_R23,
+  /* Death.  */
+  ARG_RELOC_ERR,
+} arg_reloc_type;
+
+/* Where (what register type) is an argument comming from?  */
+typedef enum
+{
+  /* Not in a register.  */
+  AR_NO,
+  /* In a general argument register.  */
+  AR_GR,
+  /* In right half of a FP argument register.  */
+  AR_FR,
+  /* In upper (left) half of a FP argument register.  */
+  AR_FU,
+  /* In general argument register pair 0 (arg0, arg1).  */
+  AR_DBL01,
+  /* In general argument register pair 1 (arg2, arg3).  */
+  AR_DBL23,
+} arg_location;
+
+/* What is being relocated (eg which argument or the return value).  */
+typedef enum
+{
+  ARG0, ARG1, ARG2, ARG3, RETVAL,
+} arg_reloc_location;
+
+/* Horizontal represents callee's argument location information, vertical
+   represents caller's argument location information.  Value at a particular
+   X, Y location represents what (if any) argument relocation needs to
+   be performed to make caller and callee agree.  */
+static CONST arg_reloc_type mismatches[6][6] =
+{
+ {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR,
+    NO_ARG_RELOC, NO_ARG_RELOC},
+ {NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR,
+    R01_TO_FR, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, ARG_RELOC_ERR},
+ {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR,
+    NO_ARG_RELOC, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, NO_ARG_RELOC},
+};
+
+/* Likewise for the return value.  */
+static CONST arg_reloc_type retval_mismatches[6][6] =
+{
+ {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR,
+    NO_ARG_RELOC, NO_ARG_RELOC},
+ {NO_ARG_RELOC, NO_ARG_RELOC, FR_TO_R, ARG_RELOC_ERR,
+    FR_TO_R01, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, R_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, ARG_RELOC_ERR},
+ {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, R01_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR,
+    NO_ARG_RELOC, ARG_RELOC_ERR},
+ {NO_ARG_RELOC, R23_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR,
+    ARG_RELOC_ERR, NO_ARG_RELOC},
+};
+
+/* Used for index mapping in symbol-extension sections.  */
+struct elf32_hppa_symextn_map_struct
+{
+  int old_index;
+  bfd *bfd;
+  asymbol *sym;
+  int new_index;
+};
 
 static bfd_reloc_status_type hppa_elf_reloc
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
@@ -58,12 +206,72 @@ static void hppa_elf_relocate_unwind_table
 	   unsigned long, unsigned long));
 
 static long get_symbol_value PARAMS ((asymbol *));
+
 static bfd_reloc_status_type hppa_elf_reloc
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd*, char **));
 
 static CONST reloc_howto_type * elf_hppa_reloc_type_lookup
   PARAMS ((bfd_arch_info_type *, bfd_reloc_code_real_type));
 
+static symext_entryS elf32_hppa_get_sym_extn PARAMS ((bfd *, asymbol *, int));
+
+static elf32_hppa_stub_description * find_stubs PARAMS ((bfd *, asection *));
+
+static elf32_hppa_stub_description * new_stub
+  PARAMS ((bfd *, asection *, struct bfd_link_info *));
+
+static arg_reloc_type type_of_mismatch PARAMS ((int, int, int));
+
+static elf32_hppa_stub_name_list * find_stub_by_name
+  PARAMS ((bfd *, asection *, char *));
+
+static elf32_hppa_stub_name_list * add_stub_by_name
+  PARAMS ((bfd *, asection *, asymbol *, struct bfd_link_info *));
+
+static void hppa_elf_stub_finish PARAMS ((bfd *));
+
+static void hppa_elf_stub_reloc
+  PARAMS ((elf32_hppa_stub_description *, bfd *, asymbol *, int,
+	   elf32_hppa_reloc_type));
+
+static int hppa_elf_arg_reloc_needed_p
+  PARAMS ((bfd *, arelent *, arg_reloc_type [5], symext_entryS));
+
+static asymbol * hppa_elf_build_linker_stub
+  PARAMS ((bfd *, bfd *, struct bfd_link_info *, arelent *,
+	   arg_reloc_type [5], int, unsigned *, hppa_stub_type));
+
+static void hppa_elf_create_stub_sec 
+  PARAMS ((bfd *, bfd *, asection **, struct bfd_link_info *));
+
+static int hppa_elf_long_branch_needed_p
+  PARAMS ((bfd *, asection *, arelent *, asymbol *, unsigned));
+
+static boolean hppa_elf_set_section_contents
+  PARAMS ((bfd *, sec_ptr, PTR, file_ptr, bfd_size_type));
+
+static void elf_info_to_howto
+  PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
+
+static void elf32_hppa_backend_symbol_processing PARAMS ((bfd *, asymbol *));
+
+static boolean elf32_hppa_backend_section_processing
+  PARAMS ((bfd *, Elf32_Internal_Shdr *));
+
+static boolean elf32_hppa_backend_symbol_table_processing
+  PARAMS ((bfd *, elf_symbol_type *, int));
+
+static boolean elf32_hppa_backend_section_from_shdr
+  PARAMS ((bfd *, Elf32_Internal_Shdr *, char *));
+
+static boolean elf32_hppa_backend_fake_sections
+  PARAMS ((bfd *, Elf_Internal_Shdr *, asection *));
+
+static boolean elf32_hppa_backend_section_from_bfd_section
+  PARAMS ((bfd *, Elf32_Internal_Shdr *, asection *, int *));
+
+/* ELF/PA relocation howto entries.  */
+
 static reloc_howto_type elf_hppa_howto_table[ELF_HOWTO_TABLE_SIZE] =
 {
   {R_HPPA_NONE, 0, 3, 19, false, 0, complain_overflow_bitfield, hppa_elf_reloc, "R_HPPA_NONE"},
@@ -197,9 +405,18 @@ static long global_value;
 static long GOT_value;
 static asymbol *global_symbol;
 static int global_sym_defined;
-
 static symext_entryS *symextn_contents;
 static unsigned int symextn_contents_real_size;
+static elf32_hppa_stub_description *elf_hppa_stub_rootP;
+static boolean stubs_finished = false;
+static struct elf32_hppa_symextn_map_struct *elf32_hppa_symextn_map;
+static int elf32_hppa_symextn_map_size;
+
+static char *linker_stubs = NULL;
+static int linker_stubs_size = 0;
+static int linker_stubs_max_size = 0;
+#define STUB_ALLOC_INCR	100
+#define STUB_SYM_BUFFER_INC	5
 
 /* Relocate the given INSN given the various input parameters.
 
@@ -364,9 +581,7 @@ get_symbol_value (symbol)
 }
 
 /* Return one (or more) BFD relocations which implement the base
-   relocation with modifications based on format and field.
-
-   FIXME:  Needs a decl in elf32-hppa.h.  */
+   relocation with modifications based on format and field.  */
 
 elf32_hppa_reloc_type **
 hppa_elf_gen_reloc_type (abfd, base_type, format, field)
@@ -1477,109 +1692,37 @@ elf_hppa_tc_make_sections (abfd, symext_root)
   return;
 }
 
-/* Support for HP PA-RISC stub generation.
-
-   Written by
-
-	Center for Software Science
-	Department of Computer Science
-	University of Utah
-
-    */
-
-/*
-    HP-PA calling conventions state:
+/* Return the symbol extension record of type TYPE for the symbol SYM.  */
 
-    1. an argument relocation stub is required whenever the callee and
-    caller argument relocation bits do not match exactly.  The exception
-    to this rule is if either the caller or callee argument relocation
-    bit are 00 (do not relocate).
-
-    2. The linker can optionally add a symbol record for the stub so that
-    the stub can be reused.  The symbol record will be the same as the
-    original export symbol record, except that the relocation bits will
-    reflect the input of the stub, the type would be STUB and the symbol
-    value will be the location of the relocation stub.
-
-    Other notes:
-
-    Stubs can be inserted *before* the section of the caller.  The stubs
-    can be treated as calls to code that manipulates the arguments.
-
- */
-
-typedef enum
-  {
-    HPPA_STUB_ILLEGAL,
-    HPPA_STUB_ARG_RELOC,
-    HPPA_STUB_LONG_BRANCH
-  } hppa_stub_type;
-
-symext_entryS
+static symext_entryS
 elf32_hppa_get_sym_extn (abfd, sym, type)
      bfd *abfd;
      asymbol *sym;
      int type;
 {
-  /* This function finds the symbol extension record of the */
-  /* specified type for the specified symbol.  It returns the */
-  /* value of the symbol extension record.	*/
-  symext_entryS retval;
-
   switch (type)
     {
-    case HPPA_SXT_NULL:
-      retval = (symext_entryS) 0;
-      break;
     case HPPA_SXT_SYMNDX:
-      retval = (symext_entryS) 0;	/* XXX: need to fix this */
-      break;
+    case HPPA_SXT_NULL:
+      return (symext_entryS) 0;
     case HPPA_SXT_ARG_RELOC:
       {
 	elf_symbol_type *esymP = (elf_symbol_type *) sym;
 
-	retval = (symext_entryS) esymP->tc_data.hppa_arg_reloc;
-	break;
+	return (symext_entryS) esymP->tc_data.hppa_arg_reloc;
       }
     /* This should never happen.  */
     default:
       abort();
     }
-  return retval;
 }
 
-typedef struct elf32_hppa_stub_name_list_struct
-{
-  /* name of this stub  */
-  asymbol *sym;
-  /* stub description for this stub  */
-  struct elf32_hppa_stub_description_struct *stub_desc;
-  /* pointer into stub contents  */
-  int *stub_secp;
-  /* size of this stub  */
-  unsigned size;
-  /* next stub name entry  */
-  struct elf32_hppa_stub_name_list_struct *next;
-} elf32_hppa_stub_name_list;
-
-typedef struct elf32_hppa_stub_description_struct
-  {
-    struct elf32_hppa_stub_description_struct *next;
-    bfd *this_bfd;		/* bfd to which this stub applies */
-    asection *stub_sec;		/* stub section for this bfd */
-    unsigned relocs_allocated_cnt; /* count of relocations for this stub section */
-    unsigned real_size;
-    unsigned allocated_size;
-    int *stub_secp;		/* pointer to the next available location in the buffer */
-    char *stub_contents;	/* contents of the stubs for this bfd */
-    elf32_hppa_stub_name_list *stub_listP;
-    struct bfd_link_info *link_info;
-  }
-elf32_hppa_stub_description;
+/* Search the chain of stub descriptions and locate the stub
+   description for this the given section within the given bfd.
 
-static elf32_hppa_stub_description *elf_hppa_stub_rootP;
+   FIXME:  I see yet another wonderful linear linked list search
+   here.  This is probably bad.  */
 
-/* Locate the stub section information for the given bfd. */
 static elf32_hppa_stub_description *
 find_stubs (abfd, stub_sec)
      bfd *abfd;
@@ -1589,12 +1732,11 @@ find_stubs (abfd, stub_sec)
 
   for (stubP = elf_hppa_stub_rootP; stubP; stubP = stubP->next)
     {
-      if (stubP->this_bfd == abfd
-	  && stubP->stub_sec == stub_sec)
+      /* Is this the right one?  */ 
+      if (stubP->this_bfd == abfd && stubP->stub_sec == stub_sec)
 	return stubP;
     }
-
-  return (elf32_hppa_stub_description *) NULL;
+  return NULL;
 }
 
 static elf32_hppa_stub_description *
@@ -1605,10 +1747,13 @@ new_stub (abfd, stub_sec, link_info)
 {
   elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
 
+  /* If we found a list for this bfd, then use it.  */
   if (stub)
     return stub;
 
-  stub = (elf32_hppa_stub_description *) bfd_zalloc (abfd, sizeof (elf32_hppa_stub_description));
+  /* Nope, allocate and initialize a new entry in the stub list chain.  */
+  stub = (elf32_hppa_stub_description *)
+    bfd_zalloc (abfd, sizeof (elf32_hppa_stub_description));
   if (stub)
     {
       stub->this_bfd = abfd;
@@ -1631,30 +1776,37 @@ new_stub (abfd, stub_sec, link_info)
   return stub;
 }
 
-/* Locate the stub by the given name.  */
+/* Try and locate a stub with the name NAME within the stubs
+   associated with ABFD.  More linked list searches.  */
+
 static elf32_hppa_stub_name_list *
 find_stub_by_name (abfd, stub_sec, name)
      bfd *abfd;
      asection *stub_sec;
      char *name;
 {
+  /* Find the stubs associated with this bfd.  */
   elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
 
+  /* If found, then we have to walk down them looking for a match.  */
   if (stub)
     {
       elf32_hppa_stub_name_list *name_listP;
 
-      for (name_listP = stub->stub_listP; name_listP; name_listP = name_listP->next)
+      for (name_listP = stub->stub_listP;
+	   name_listP;
+	   name_listP = name_listP->next)
 	{
 	  if (!strcmp (name_listP->sym->name, name))
 	    return name_listP;
 	}
     }
 
+  /* Not found.  */
   return 0;
 }
 
-/* Locate the stub by the given name.  */
+/* Add a new stub (SYM) to the list of stubs associated with the given BFD.  */
 static elf32_hppa_stub_name_list *
 add_stub_by_name(abfd, stub_sec, sym, link_info)
      bfd *abfd;
@@ -1665,11 +1817,14 @@ add_stub_by_name(abfd, stub_sec, sym, link_info)
   elf32_hppa_stub_description *stub = find_stubs (abfd, stub_sec);
   elf32_hppa_stub_name_list *stub_entry;
 
+  /* If no stubs are associated with this bfd, then we have to make
+     a chain-of-stubs associated with this bfd.  */
   if (!stub)
-    stub = new_stub(abfd, stub_sec, link_info);
+    stub = new_stub (abfd, stub_sec, link_info);
 
   if (stub)
     {
+      /* Allocate and initialize an entry in the stub chain.  */
       stub_entry = (elf32_hppa_stub_name_list *)
 	bfd_zalloc (abfd, sizeof (elf32_hppa_stub_name_list));
 
@@ -1681,6 +1836,7 @@ add_stub_by_name(abfd, stub_sec, sym, link_info)
 	  /* First byte of this stub is the pointer to
 	     the next available location in the stub buffer.  */
 	  stub_entry->stub_secp = stub->stub_secp;
+	  /* Add it to the chain.  */
 	  if (stub->stub_listP)
 	    stub_entry->next = stub->stub_listP;
 	  else
@@ -1694,84 +1850,16 @@ add_stub_by_name(abfd, stub_sec, sym, link_info)
 	  abort();		/* FIXME */
 	}
     }
-
+  /* Death by mis-adventure.  */
+  abort ();
   return (elf32_hppa_stub_name_list *)NULL;
 }
 
-#define ARGUMENTS	0
-#define RETURN_VALUE	1
-
-#define	NO_ARG_RELOC	0
-#define R_TO_FR		1
-#define R01_TO_FR	2
-#define R23_TO_FR	3
-#define FR_TO_R		4
-#define FR_TO_R01	5
-#define FR_TO_R23	6
-#define	ARG_RELOC_ERR	7
-
-#define ARG0	0
-#define ARG1	1
-#define ARG2	2
-#define ARG3	3
-#define RETVAL	4
-
-#define AR_NO	0
-#define AR_GR	1
-#define AR_FR	2
-#define AR_FU	3
-/* FP register in arg0/arg1.  This value can only appear in the arg0 location. */
-#define AR_DBL01	4
-/* FP register in arg2/arg3.  This value can only appear in the arg2 location. */
-#define AR_DBL23	5
-
-#define AR_WARN(type,loc) \
-  fprintf(stderr,"WARNING:  Illegal argument relocation: %s for %s\n", \
-	  reloc_type_strings[type],reloc_loc_strings[loc])
-
-static CONST char *CONST reloc_type_strings[] =
-{
-  "NONE", "GR->FR", "GR0,GR1->FR1", "GR2,GR3->FR3", "FR->GR", "FR->GR0,GR1", "FR->GR2,GR3", "ERROR"
-};
-
-static CONST char *CONST reloc_loc_strings[] =
-{
-  "ARG0", "ARG1", "ARG2", "ARG3", "RETVAL"
-};
-
-static CONST char mismatches[6][6] =
-{				/* 	CALLEE NONE	CALLEE GR	CALLEE FR	CALLEE FU	CALLEE DBL01	CALLEE DBL23	*/
-  /* CALLER NONE	*/
- {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
- /* CALLER GR	*/
- {NO_ARG_RELOC, NO_ARG_RELOC, R_TO_FR, ARG_RELOC_ERR, R01_TO_FR, ARG_RELOC_ERR},
- /* CALLER FR	*/
- {NO_ARG_RELOC, FR_TO_R, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR},
- /* CALLER FU	*/
- {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
- /* CALLER DBL01	*/
- {NO_ARG_RELOC, FR_TO_R01, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
- /* CALLER DBL23	*/
- {NO_ARG_RELOC, FR_TO_R23, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
-};
-
-static CONST char retval_mismatches[6][6] =
-{	/* 	CALLEE NONE	CALLEE GR	CALLEE FR	CALLEE FU	CALLEE DBL01	CALLEE DBL23	*/
-  /* CALLER NONE	*/
- {NO_ARG_RELOC, NO_ARG_RELOC, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, NO_ARG_RELOC},
- /* CALLER GR	*/
- {NO_ARG_RELOC, NO_ARG_RELOC, FR_TO_R, ARG_RELOC_ERR, FR_TO_R01, ARG_RELOC_ERR},
- /* CALLER FR	*/
- {NO_ARG_RELOC, R_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
- /* CALLER FU	*/
- {ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR, ARG_RELOC_ERR},
- /* CALLER DBL01	*/
- {NO_ARG_RELOC, R01_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, NO_ARG_RELOC, ARG_RELOC_ERR},
- /* CALLER DBL23	*/
- {NO_ARG_RELOC, R23_TO_FR, NO_ARG_RELOC, ARG_RELOC_ERR, ARG_RELOC_ERR, NO_ARG_RELOC},
-};
+/* For the given caller/callee argument location information and the
+   type of relocation (arguments or return value), return the type
+   of argument relocation needed to make caller and callee happy.  */
 
-static int
+static arg_reloc_type
 type_of_mismatch (caller_bits, callee_bits, type)
      int caller_bits;
      int callee_bits;
@@ -1784,76 +1872,84 @@ type_of_mismatch (caller_bits, callee_bits, type)
     case RETURN_VALUE:
       return retval_mismatches[caller_bits][callee_bits];
     }
-
-  return 0;
+  return ARG_RELOC_ERR;
 }
 
-#define EXTRACT_ARBITS(ar,which)	((ar) >> (8-(which*2))) & 3
+/* Extract specific argument location bits for WHICH from the
+   the full argument location information in AR.  */
+#define EXTRACT_ARBITS(ar, which)	((ar) >> (8 - ((which) * 2))) & 3
 
-#define NEW_INSTRUCTION(entry,insn)	\
+/* Add the new instruction INSN into the stub area denoted by ENTRY.
+   FIXME:  Looks like more cases where we assume sizeof (int) ==
+   sizeof (insn) which may not be true if building cross tools.  */
+#define NEW_INSTRUCTION(entry, insn)	\
 { \
   *((entry)->stub_desc->stub_secp)++ = (insn);	\
-  (entry)->stub_desc->real_size += sizeof(int);	\
+  (entry)->stub_desc->real_size += sizeof (int);	\
   (entry)->size += sizeof(int);	\
   bfd_set_section_size((entry)->stub_desc->this_bfd,	\
 		       (entry)->stub_desc->stub_sec,	\
 		       (entry)->stub_desc->real_size);	\
 }
 
+/* Find the offset of the current stub?  Looks more like it
+   finds the offset of the last instruction to me.  */
 #define CURRENT_STUB_OFFSET(entry)	\
   ((char *)(entry)->stub_desc->stub_secp \
    - (char *)(entry)->stub_desc->stub_contents - 4)
 
-static boolean stubs_finished = false;
+/* All the stubs have already been built, finish up stub stuff
+   by applying relocations to the stubs.  */
 
-void
+static void
 hppa_elf_stub_finish (output_bfd)
      bfd *output_bfd;
 {
   elf32_hppa_stub_description *stub_list = elf_hppa_stub_rootP;
-  /* All the stubs have been built.  Finish up building	*/
-  /* stub section.  Apply relocations to the section.	*/
 
+  /* If the stubs have been finished, then we're already done.  */
   if (stubs_finished)
     return;
 
+  /* Walk down the list of stub lists. */
   for (; stub_list; stub_list = stub_list->next)
     {
+      /* If this list has stubs, then do something.  */
       if (stub_list->real_size)
 	{
 	  bfd *stub_bfd = stub_list->this_bfd;
-	  asection *stub_sec = bfd_get_section_by_name (stub_bfd, ".hppa_linker_stubs");
+	  asection *stub_sec = bfd_get_section_by_name (stub_bfd,
+							".hppa_linker_stubs");
 	  bfd_size_type reloc_size;
 	  arelent **reloc_vector;
 
+	  /* Some sanity checking.  */
 	  BFD_ASSERT (stub_sec == stub_list->stub_sec);
-	  reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
-	  reloc_vector = (arelent **) alloca (reloc_size);
-
 	  BFD_ASSERT (stub_sec);
 
-	  /* We are not relaxing the section, so just copy the size info */
+	  /* For stub sections raw_size == cooked_size.  Also update
+	     reloc_done as we're handling the relocs now.  */
 	  stub_sec->_cooked_size = stub_sec->_raw_size;
 	  stub_sec->reloc_done = true;
 
+	  /* Make space to hold the relocations for the stub section.  */
+	  reloc_size = bfd_get_reloc_upper_bound (stub_bfd, stub_sec);
+	  reloc_vector = (arelent **) alloca (reloc_size);
 
-	  if (bfd_canonicalize_reloc (stub_bfd,
-				      stub_sec,
-				      reloc_vector,
+	  /* If we have relocations, do them.  */
+	  if (bfd_canonicalize_reloc (stub_bfd, stub_sec, reloc_vector,
 				      output_bfd->outsymbols))
 	    {
 	      arelent **parent;
-	      for (parent = reloc_vector; *parent != (arelent *) NULL;
-		   parent++)
+	      for (parent = reloc_vector; *parent != NULL; parent++)
 		{
-		  char *err = (char *) NULL;
+		  char *err = NULL;
 		  bfd_reloc_status_type r =
-		    bfd_perform_relocation (stub_bfd,
-					    *parent,
+		    bfd_perform_relocation (stub_bfd, *parent,
 					    stub_list->stub_contents,
 					    stub_sec, (bfd *) NULL, &err);
 
-
+		  /* If there was an error, tell someone about it.  */
 		  if (r != bfd_reloc_ok)
 		    {
 		      struct bfd_link_info *link_info = stub_list->link_info;
@@ -1894,89 +1990,35 @@ hppa_elf_stub_finish (output_bfd)
 		}
 	    }
 
-	  bfd_set_section_contents (output_bfd,
-				    stub_sec,
+	  /* All done with the relocations.  Set the final contents
+	     of the stub section.  FIXME: no check of return value!  */
+	  bfd_set_section_contents (output_bfd, stub_sec,
 				    stub_list->stub_contents,
-				    0,
-				    stub_list->real_size);
-
-	  free (reloc_vector);
+				    0, stub_list->real_size);
 	}
     }
+  /* All done.  */
   stubs_finished = true;
 }
 
-void
-hppa_elf_stub_branch_reloc (stub_desc,	/* the bfd */
-			    output_bfd,	/* the output bfd */
-			    target_sym,	/* the target symbol */
-			    offset)	/* the offset within the stub buffer (pre-calculated) */
-     elf32_hppa_stub_description *stub_desc;
-     bfd *output_bfd;
-     asymbol *target_sym;
-     int offset;
-{
-  /* Allocate a new relocation entry. */
-  arelent relent;
-  int size;
-
-  if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
-    {
-      if (stub_desc->stub_sec->relocation == NULL)
-	{
-	  stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
-	  size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
-	  stub_desc->stub_sec->relocation = (arelent *) bfd_zmalloc (size);
-	}
-      else
-	{
-	  stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
-	  size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
-	  stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
-								 size);
-	}
-      if (!stub_desc->stub_sec->relocation)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  abort();		/* FIXME */
-	}
-    }
-
-  /* Fill in the details. */
-  relent.address = offset;
-  relent.addend = 0;
-  relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
-  BFD_ASSERT (relent.sym_ptr_ptr); /* FIXME */
-
-  relent.sym_ptr_ptr[0] = target_sym;
-  relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, R_HPPA_PCREL_CALL_17);
+/* Allocate a new relocation entry to be used in a linker stub.  */
 
-  /* Save it in the array of relocations for the stub section. */
-
-  memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
-	  &relent,
-	  sizeof (arelent));
-}
-
-void
-hppa_elf_stub_reloc (stub_desc,	/* the bfd */
-		     output_bfd,	/* the output bfd */
-		     target_sym,	/* the target symbol */
-		     offset,	/* the offset within the stub buffer (pre-calculated) */
-		     type)
+static void
+hppa_elf_stub_reloc (stub_desc, output_bfd, target_sym, offset, type)
      elf32_hppa_stub_description *stub_desc;
      bfd *output_bfd;
      asymbol *target_sym;
      int offset;
      elf32_hppa_reloc_type type;
 {
-  /* Allocate a new relocation entry. */
   arelent relent;
   int size;
   Elf_Internal_Shdr *rela_hdr;
 
+  /* I really don't like the realloc nonsense in here.  FIXME.  */
   if (stub_desc->relocs_allocated_cnt == stub_desc->stub_sec->reloc_count)
     {
+      /* Allocate the first few relocation entries.  */
       if (stub_desc->stub_sec->relocation == NULL)
 	{
 	  stub_desc->relocs_allocated_cnt = STUB_RELOC_INCR;
@@ -1985,15 +2027,17 @@ hppa_elf_stub_reloc (stub_desc,	/* the bfd */
 	}
       else
 	{
+	  /* We've used all the entries we've already allocated.  So get
+	     some more.  */
 	  stub_desc->relocs_allocated_cnt += STUB_RELOC_INCR;
 	  size = sizeof (arelent) * stub_desc->relocs_allocated_cnt;
-	  stub_desc->stub_sec->relocation = (arelent *) realloc (stub_desc->stub_sec->relocation,
-								 size);
+	  stub_desc->stub_sec->relocation = (arelent *)
+	    realloc (stub_desc->stub_sec->relocation, size);
 	}
       if (!stub_desc->stub_sec->relocation)
 	{
 	  bfd_set_error (bfd_error_no_memory);
-	  abort();		/* FIXME */
+	  abort ();		/* FIXME */
 	}
     }
 
@@ -2003,39 +2047,40 @@ hppa_elf_stub_reloc (stub_desc,	/* the bfd */
   /* Fill in the details. */
   relent.address = offset;
   relent.addend = 0;
-  relent.sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd, sizeof (asymbol *));
-  BFD_ASSERT (relent.sym_ptr_ptr); /* FIXME */
-
-  relent.sym_ptr_ptr[0] = target_sym;
+  relent.sym_ptr_ptr = &target_sym;
   relent.howto = bfd_reloc_type_lookup (stub_desc->this_bfd, type);
 
-  /* Save it in the array of relocations for the stub section. */
-
+  /* Save it in the array of relocations for the stub section.  */
   memcpy (&stub_desc->stub_sec->relocation[stub_desc->stub_sec->reloc_count++],
-	  &relent,
-	  sizeof (arelent));
+	  &relent, sizeof (arelent));
 }
 
-asymbol *
-hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
-			       stub_types, rtn_adjust, data)
+/* Build an argument relocation stub.  RTN_ADJUST is a hint that an
+   adjust to the return pointer from within the stub itself may be
+   needed.  */
+
+static asymbol *
+hppa_elf_build_linker_stub (abfd, output_bfd, link_info, reloc_entry,
+			    stub_types, rtn_adjust, data, linker_stub_type)
      bfd *abfd;
      bfd *output_bfd;
      struct bfd_link_info *link_info;
      arelent *reloc_entry;
-     int stub_types[5];
+     arg_reloc_type stub_types[5];
      int rtn_adjust;
      unsigned *data;
+     hppa_stub_type linker_stub_type;
 {
-  asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
-  elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
-  asymbol *stub_sym = NULL;
-  asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
-  asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
   int i;
+  boolean milli, dyncall;
   char stub_sym_name[128];
   elf32_hppa_stub_name_list *stub_entry;
+  /* Some initialization.  */
   unsigned insn = data[0];
+  asymbol *stub_sym = NULL;
+  asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
+  asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
+  elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
 
   /* Perform some additional checks on whether we should really do the
      return adjustment.  For example, if the instruction is nullified
@@ -2053,18 +2098,45 @@ hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
 	rtn_adjust = false;
     }
 
-  /* See if the proper stub entry has already been made.  */
+  /* Some special code for long-call stubs.  */
+  if (linker_stub_type == HPPA_STUB_LONG_CALL)
+    {
+      
+      /* Is this a millicode call?  If so, the return address
+	 comes in on r31 rather than r2 (rp) so a slightly
+	 different code sequence is needed.  */
+      unsigned rtn_reg = (insn & 0x03e00000) >> 21;
+      if (rtn_reg == 31)
+	milli = true;
+      
+      /* Dyncall is special because the user code has already
+	 put the return pointer in %r2 (aka RP).  Other millicode
+	 calls have the return pointer in %r31.  */
+      if (strcmp (target_sym->name, "$$dyncall") == 0)
+	dyncall = true;
+      
+      /* If we are creating a call from a stub to another stub, then
+	 never do the instruction reordering.  We can tell if we are
+	 going to be calling one stub from another by the fact that
+	 the symbol name has '_stub_' (arg. reloc. stub) or '_lb_stub_'
+	 prepended to the name.  Alternatively, the section of the
+	 symbol will be '.hppa_linker_stubs'.  This is only an issue
+	 for long-calls; they are the only stubs allowed to call another
+	 stub.  */
+      if ((strncmp (target_sym->name, "_stub_", 6) == 0)
+	  || (strncmp (target_sym->name, "_lb_stub_", 9) == 0))
+	{
+	  BFD_ASSERT (strcmp (target_sym->section->name, ".hppa_linker_stubs")
+		      == 0);
+	  rtn_adjust = false;
+	}
+    }
+
+  /* Create the stub section if necessary.  */
   if (!stub_sec)
     {
       BFD_ASSERT (stub_desc == NULL);
-      stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
-      bfd_set_section_flags (abfd,
-			     stub_sec,
-			     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
-			     | SEC_RELOC | SEC_CODE | SEC_READONLY);
-      stub_sec->output_section = output_text_section->output_section;
-      stub_sec->output_offset = 0;
-      bfd_set_section_alignment (abfd, stub_sec, 2);
+      hppa_elf_create_stub_sec (abfd, output_bfd, &stub_sec, link_info);
       stub_desc = new_stub (abfd, stub_sec, link_info);
     }
 
@@ -2073,16 +2145,11 @@ hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
     stub_desc = new_stub (abfd, stub_sec, link_info);
 
   /* Allocate space to write the stub.
-     FIXME.  Why using realloc?!?  */
+     FIXME:  Why using realloc?!?  */
   if (!stub_desc->stub_contents)
     {
       stub_desc->allocated_size = STUB_BUFFER_INCR;
       stub_desc->stub_contents = (char *) malloc (STUB_BUFFER_INCR);
-      if (!stub_desc->stub_contents)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
     }
   else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
     {
@@ -2091,35 +2158,45 @@ hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
 						   stub_desc->allocated_size);
     }
 
+  /* If no memory die.  (I seriously doubt the other routines
+     are prepared to get a NULL return value).  */
+  if (!stub_desc->stub_contents)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      abort ();
+    }
+
+  /* Generate an appropriate name for this stub.  */
+  if (linker_stub_type == HPPA_STUB_ARG_RELOC)
+    sprintf (stub_sym_name,
+	     "_stub_%s_%02d_%02d_%02d_%02d_%02d_%s",
+	     reloc_entry->sym_ptr_ptr[0]->name,
+	     stub_types[0], stub_types[1], stub_types[2],
+	     stub_types[3], stub_types[4],
+	     rtn_adjust ? "RA" : "");
+  else
+    sprintf (stub_sym_name,
+	     "_lb_stub_%s_%s", reloc_entry->sym_ptr_ptr[0]->name,
+	     rtn_adjust ? "RA" : "");
+
+
   stub_desc->stub_secp
     = (int *) (stub_desc->stub_contents + stub_desc->real_size);
-
-  sprintf (stub_sym_name,
-	   "_stub_%s_%02d_%02d_%02d_%02d_%02d_%s",
-	   reloc_entry->sym_ptr_ptr[0]->name,
-	   stub_types[0], stub_types[1], stub_types[2],
-	   stub_types[3], stub_types[4],
-	   rtn_adjust ? "RA" : "");
   stub_entry = find_stub_by_name (abfd, stub_sec, stub_sym_name);
 
+  /* See if we already have one by this name.  */
   if (stub_entry)
     {
+      /* Yes, re-use it.  Redirect the original relocation from the
+	 old symbol (a function symbol) to the stub (the stub will call
+	 the original function).  */
       stub_sym = stub_entry->sym;
-      /* Redirect the original relocation from the old symbol (a function)
-	 to the stub (the stub calls the function).  Should we need to
-	 change the relocation type?  */
-      reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
-							  sizeof (asymbol *));
-      if (!reloc_entry->sym_ptr_ptr)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      reloc_entry->sym_ptr_ptr[0] = stub_sym;
-      if (reloc_entry->howto->type != R_HPPA_PLABEL_32
-	  && (get_opcode(insn) == BLE
-	      || get_opcode (insn) == BE
-	      || get_opcode (insn) == BL))
+      reloc_entry->sym_ptr_ptr = &stub_sym;
+      if (linker_stub_type == HPPA_STUB_LONG_CALL
+	  || (reloc_entry->howto->type != R_HPPA_PLABEL_32
+	      && (get_opcode(insn) == BLE
+		  || get_opcode (insn) == BE
+		  || get_opcode (insn) == BL)))
 	reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
     }
   else
@@ -2129,13 +2206,13 @@ hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
       if (!stub_sym)
 	{
 	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
+	  abort ();
 	}
       stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
       if (!stub_sym->name)
 	{
 	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
+	  abort ();
 	}
       strcpy ((char *) stub_sym->name, stub_sym_name);
       stub_sym->value
@@ -2145,221 +2222,282 @@ hppa_elf_build_arg_reloc_stub (abfd, output_bfd, link_info, reloc_entry,
       stub_entry = add_stub_by_name (abfd, stub_sec, stub_sym, link_info);
 
       /* Redirect the original relocation from the old symbol (a function)
-	 to the stub (the stub calls the function).  Change the type of
-	 relocation to be the internal use only stub R_HPPA_STUB_CALL_17.  */
-      reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
-							  sizeof (asymbol *));
-      if (!reloc_entry->sym_ptr_ptr)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      reloc_entry->sym_ptr_ptr[0] = stub_sym;
-      if (reloc_entry->howto->type != R_HPPA_PLABEL_32
-	  && (get_opcode (insn) == BLE
-	      || get_opcode (insn) == BE
-	      || get_opcode (insn) == BL))
+	 to the stub (the stub calls the function).  */
+      reloc_entry->sym_ptr_ptr = &stub_sym;
+      if (linker_stub_type == HPPA_STUB_LONG_CALL
+	  || (reloc_entry->howto->type != R_HPPA_PLABEL_32
+	      && (get_opcode (insn) == BLE
+		  || get_opcode (insn) == BE
+		  || get_opcode (insn) == BL)))
 	reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
 
-      /* Generate common code for all stubs.  */
+      /* Now generate the code for the stub.  Starting with two
+	 common instructions.
 
-      NEW_INSTRUCTION (stub_entry, LDSID_31_1);
-      NEW_INSTRUCTION (stub_entry, MTSP_1_SR0);
-      NEW_INSTRUCTION (stub_entry, ADDI_8_SP);
+	 FIXME:  Do we still need the SP adjustment?
+		 Do we still need to muck with space registers?  */
+      NEW_INSTRUCTION (stub_entry, LDSID_31_1)
+      NEW_INSTRUCTION (stub_entry, MTSP_1_SR0)
 
-      /* Generate code to move the arguments around.  */
-      for (i = ARG0; i < ARG3; i++)
+      if (linker_stub_type == HPPA_STUB_ARG_RELOC)
 	{
-	  if (stub_types[i] != NO_ARG_RELOC)
-	    {
-	      switch (stub_types[i])
-		{
-		case R_TO_FR:
-		  switch (i)
-		    {
-		    case ARG0:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG0_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG0);
-		      break;
-		    case ARG1:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG1);
-		      break;
-		    case ARG2:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG2_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG2);
-		      break;
-		    case ARG3:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG3);
-		      break;
-		    }
-		  continue;
-		  
-		case R01_TO_FR:
-		  switch (i)
-		    {
-		    case ARG0:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG0_M4SP);
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG1);
-		      break;
-		    default:
-		      AR_WARN (stub_types[i],i);
-		      break;
-		    }
-		  continue;
-		  
-		case R23_TO_FR:
-		  switch (i)
-		    {
-		    case ARG2:
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG2_M4SP);
-		      NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP);
-		      NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG3);
-		      break;
-		    default:
-		      AR_WARN (stub_types[i],i);
-		      break;
-		    }
-		  continue;
-		  
-		case FR_TO_R:
-		  switch (i)
-		    {
-		    case ARG0:
-		      NEW_INSTRUCTION (stub_entry, FSTWS_FARG0_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0);
-		      break;
-		    case ARG1:
-		      NEW_INSTRUCTION (stub_entry, FSTWS_FARG1_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG1);
-		      break;
-		    case ARG2:
-		      NEW_INSTRUCTION (stub_entry, FSTWS_FARG2_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2);
-		      break;
-		    case ARG3:
-		      NEW_INSTRUCTION (stub_entry, FSTWS_FARG3_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG3);
-		      break;
-		    }
-		  continue;
-		  
-		case FR_TO_R01:
-		  switch (i)
-		    {
-		    case ARG0:
-		      NEW_INSTRUCTION (stub_entry, FSTDS_FARG1_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG1);
-		      break;
-		    default:
-		      AR_WARN (stub_types[i],i);
-		      break;
-		    }
-		  continue;
-		  
-		case FR_TO_R23:
-		  switch (i)
-		    {
-		    case ARG2:
-		      NEW_INSTRUCTION (stub_entry, FSTDS_FARG3_M8SP);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2);
-		      NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG3);
-		      break;
-		    default:
-		      AR_WARN (stub_types[i],i);
-		      break;
-		    }
-		  continue;
-		  
-		}
-	    }
-	}
+	  NEW_INSTRUCTION (stub_entry, ADDI_8_SP)
 
-      NEW_INSTRUCTION (stub_entry, ADDI_M8_SP_SP);
+	  /* Examine each argument, generating code to relocate it
+	     into a different register if necessary.  */
+	    for (i = ARG0; i < ARG3; i++)
+	      {
+		switch (stub_types[i])
+		  {
 
-      /* Adjust the return address if necessary.  */
-      if (rtn_adjust)
+		  case NO_ARG_RELOC:
+		    continue;
+
+		  case R_TO_FR:
+		    switch (i)
+		      {
+		      case ARG0:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG0_M8SP)
+			NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG0)
+			  break;
+		      case ARG1:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP)
+		        NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG1)
+			  break;
+		      case ARG2:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG2_M8SP)
+			NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG2)
+			  break;
+		      case ARG3:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP)
+			NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FARG3)
+			  break;
+		      }
+		    continue;
+	      
+		  case R01_TO_FR:
+		    switch (i)
+		      {
+		      case ARG0:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG0_M4SP)
+			NEW_INSTRUCTION (stub_entry, STWS_ARG1_M8SP)
+			NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG1)
+			  break;
+		      default:
+			abort ();
+			break;
+		      }
+		    continue;
+
+		  case R23_TO_FR:
+		    switch (i)
+		      {
+		      case ARG2:
+			NEW_INSTRUCTION (stub_entry, STWS_ARG2_M4SP)
+			NEW_INSTRUCTION (stub_entry, STWS_ARG3_M8SP)
+			NEW_INSTRUCTION (stub_entry, FLDDS_M8SP_FARG3)
+			  break;
+		      default:
+			abort ();
+			break;
+		      }
+		    continue;
+
+		  case FR_TO_R:
+		    switch (i)
+		      {
+		      case ARG0:
+			NEW_INSTRUCTION (stub_entry, FSTWS_FARG0_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0)
+			  break;
+		      case ARG1:
+			NEW_INSTRUCTION (stub_entry, FSTWS_FARG1_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG1)
+			  break;
+		      case ARG2:
+			NEW_INSTRUCTION (stub_entry, FSTWS_FARG2_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2)
+			  break;
+		      case ARG3:
+			NEW_INSTRUCTION (stub_entry, FSTWS_FARG3_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG3)
+			  break;
+		      }
+		    continue;
+	      
+		  case FR_TO_R01:
+		    switch (i)
+		      {
+		      case ARG0:
+			NEW_INSTRUCTION (stub_entry, FSTDS_FARG1_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG0)
+			NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG1)
+			  break;
+		      default:
+			abort ();
+			break;
+		      }
+		    continue;
+	      
+		  case FR_TO_R23:
+		    switch (i)
+		      {
+		      case ARG2:
+			NEW_INSTRUCTION (stub_entry, FSTDS_FARG3_M8SP)
+			NEW_INSTRUCTION (stub_entry, LDWS_M4SP_ARG2)
+			NEW_INSTRUCTION (stub_entry, LDWS_M8SP_ARG3)
+			  break;
+		      default:
+			abort ();
+			break;
+		      }
+		    continue;
+
+		  default:
+		    abort ();
+		    break;
+		  }
+	      }
+
+	  /* Put the stack pointer back.  FIXME:  Is this still necessary?  */
+	  NEW_INSTRUCTION (stub_entry, ADDI_M8_SP_SP)
+	}
+
+      /* Common code again.  Return pointer adjustment and the like.  */
+      if (!dyncall)
 	{
-	  NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
+	  /* This isn't dyncall.  */ 
+	  if (!milli)
+	    {
+	      /* It's not a millicode call, so get the correct return
+		 value into %r2 (aka RP).  */
+	      if (rtn_adjust)
+		NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP)
+	      else
+		NEW_INSTRUCTION (stub_entry, COPY_31_2)
+	    }
+	  else
+	    {
+	      /* It is a millicode call, so get the correct return
+		 value into %r1?!?.  FIXME:  Shouldn't this be
+		 %r31?  Yes, and a little re-arrangement of the
+		 code below would make that possible.  */
+	      if (rtn_adjust)
+		NEW_INSTRUCTION (stub_entry, ADDI_M4_31_1)
+	      else
+		NEW_INSTRUCTION (stub_entry, COPY_31_1)
+	    }
 	}
       else
-	NEW_INSTRUCTION (stub_entry, COPY_31_2);
+	{
+	  /* This is dyncall, so the code is a little different as the
+	     return pointer is already in %r2 (aka RP).  */
+	  if (rtn_adjust)
+	    NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP)
+	}
 
       /* Save the return address.  */
-      NEW_INSTRUCTION (stub_entry, STW_RP_M8SP);
+      if (linker_stub_type == HPPA_STUB_ARG_RELOC)
+	NEW_INSTRUCTION (stub_entry, STW_RP_M8SP)
 
       /* Long branch to the target function.  */
-      NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
+      NEW_INSTRUCTION (stub_entry, LDIL_XXX_31)
       hppa_elf_stub_reloc (stub_entry->stub_desc,
-			   abfd,
-			   target_sym,
+			   abfd, target_sym,
 			   CURRENT_STUB_OFFSET (stub_entry),
 			   R_HPPA_L21);
-      NEW_INSTRUCTION (stub_entry, BLE_XXX_0_31);
+      NEW_INSTRUCTION (stub_entry, BLE_XXX_0_31)
       hppa_elf_stub_reloc (stub_entry->stub_desc,
-			   abfd,
-			   target_sym,
+			   abfd, target_sym,
 			   CURRENT_STUB_OFFSET (stub_entry),
 			   R_HPPA_ABS_CALL_R17);
-      NEW_INSTRUCTION (stub_entry, COPY_31_2);
-      
 
-      /* Restore the return address.  */
-      NEW_INSTRUCTION (stub_entry, LDW_M8SP_RP);
+      if (linker_stub_type == HPPA_STUB_ARG_RELOC)
+	{
+	  /* In delay slot of long-call, copy %r31 into %r2 so that
+	     the callee can return in the normal fashion.  */
+	  NEW_INSTRUCTION (stub_entry, COPY_31_2)
+
+	  /* Restore the return address.  */
+	  NEW_INSTRUCTION (stub_entry, LDW_M8SP_RP)
       
-      /* Generate the code to move the return value around.  */
-      i = RETVAL;
-      if (stub_types[i] != NO_ARG_RELOC)
+	  /* Generate the code to move the return value around.  */
+	    switch (stub_types[RETVAL])
+	      {
+	      case NO_ARG_RELOC:
+		break;
+	  
+	      case R_TO_FR:
+		NEW_INSTRUCTION (stub_entry, STWS_RET0_M8SP)
+		NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FRET0)
+		  break;
+	  
+	      case FR_TO_R:
+		NEW_INSTRUCTION (stub_entry, FSTWS_FRET0_M8SP)
+		NEW_INSTRUCTION (stub_entry, LDWS_M4SP_RET0)
+		  break;
+
+	      default:
+		abort ();
+		break;
+	      }
+
+	  /* Return back to the main code stream.  */
+	  NEW_INSTRUCTION (stub_entry, BV_N_0_RP)
+	}
+      else
 	{
-	  switch (stub_types[i])
+	  if (!dyncall)
 	    {
-	    case R_TO_FR:
-	      NEW_INSTRUCTION (stub_entry, STWS_RET0_M8SP);
-	      NEW_INSTRUCTION (stub_entry, FLDWS_M8SP_FRET0);
-	      break;
-	      
-	    case FR_TO_R:
-	      NEW_INSTRUCTION (stub_entry, FSTWS_FRET0_M8SP);
-	      NEW_INSTRUCTION (stub_entry, LDWS_M4SP_RET0);
-	      break;
+	      /* Get return address into %r31.  Both variants may be necessary
+		 (I think) as we could be cascading into another stub.  */
+	      if (!milli)
+		NEW_INSTRUCTION (stub_entry, COPY_2_31)
+	      else
+		NEW_INSTRUCTION (stub_entry, COPY_1_31)
+	    }
+	  else
+	    {
+	      /* Get the return address into %r31 too.  Might be necessary
+		 (I think) as we could be cascading into another stub.  */
+	      NEW_INSTRUCTION (stub_entry, COPY_2_31)
 	    }
+
+	  /* No need for a return to the main stream.  */
 	}
-      NEW_INSTRUCTION (stub_entry, BV_N_0_RP);
     }
-
   return stub_sym;
 }
 
-int
+/* Return nonzero if an argument relocation will be needed to call
+   the function (symbol in RELOC_ENTRY) assuming the caller has
+   argument relocation bugs CALLER_AR.  */
+
+static int
 hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar)
      bfd *abfd;
      arelent *reloc_entry;
-     int stub_types[5];
+     arg_reloc_type stub_types[5];
      symext_entryS caller_ar;
 {
-  /* If the symbol is still undefined, there is	*/
-  /* no way to know if a stub is required.	*/
-
-  if (reloc_entry->sym_ptr_ptr[0] && reloc_entry->sym_ptr_ptr[0]->section != &bfd_und_section)
+  /* If the symbol is still undefined, then it's impossible to know
+     if an argument relocation is needed.  */
+  if (reloc_entry->sym_ptr_ptr[0] 
+      && reloc_entry->sym_ptr_ptr[0]->section != &bfd_und_section)
     {
       symext_entryS callee_ar = elf32_hppa_get_sym_extn (abfd,
 						reloc_entry->sym_ptr_ptr[0],
 							 HPPA_SXT_ARG_RELOC);
 
-      /* Now, determine if a stub is */
-      /* required.  A stub is required if they the callee and caller	*/
-      /* argument relocation bits are both nonzero and not equal.	*/
-
+      /* Now examine all the argument and return value location
+	 information to determine if a relocation stub will be needed.  */
       if (caller_ar && callee_ar)
 	{
-	  /* Both are non-zero, we need to do further checking. */
-	  /* First, check if there is a return value relocation to be done */
-	  int caller_loc[5];
-	  int callee_loc[5];
+	  arg_location caller_loc[5];
+	  arg_location callee_loc[5];
 
+	  /* Extract the location information for the return value
+	     and argument registers separately.  */
 	  callee_loc[RETVAL] = EXTRACT_ARBITS (callee_ar, RETVAL);
 	  caller_loc[RETVAL] = EXTRACT_ARBITS (caller_ar, RETVAL);
 	  callee_loc[ARG0] = EXTRACT_ARBITS (callee_ar, ARG0);
@@ -2371,9 +2509,11 @@ hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar)
 	  callee_loc[ARG3] = EXTRACT_ARBITS (callee_ar, ARG3);
 	  caller_loc[ARG3] = EXTRACT_ARBITS (caller_ar, ARG3);
 
-	  /* Check some special combinations.  For */
-	  /* example, if FU appears in ARG1 or ARG3, we */
-	  /* can move it to ARG0 or ARG2, respectively. */
+	  /* Check some special combinations.  For example, if FU 
+	     appears in ARG1 or ARG3, we can move it to ARG0 or ARG2,
+	     respectively.  (I guess this braindamage is correct?  It'd
+	     take an hour or two of reading PA calling conventions to
+	     really know).  */
 
 	  if (caller_loc[ARG0] == AR_FU || caller_loc[ARG1] == AR_FU)
 	    {
@@ -2396,368 +2536,110 @@ hppa_elf_arg_reloc_needed_p (abfd, reloc_entry, stub_types, caller_ar)
 	      callee_loc[ARG3] = AR_NO;
 	    }
 
-	  stub_types[ARG0] = type_of_mismatch (caller_loc[ARG0], callee_loc[ARG0], ARGUMENTS);
-	  stub_types[ARG1] = type_of_mismatch (caller_loc[ARG1], callee_loc[ARG1], ARGUMENTS);
-	  stub_types[ARG2] = type_of_mismatch (caller_loc[ARG2], callee_loc[ARG2], ARGUMENTS);
-	  stub_types[ARG3] = type_of_mismatch (caller_loc[ARG3], callee_loc[ARG3], ARGUMENTS);
-	  stub_types[RETVAL] = type_of_mismatch (caller_loc[RETVAL], callee_loc[RETVAL], RETURN_VALUE);
-
-	  /* Steps involved in building stubs: */
-	  /* 1. Determine what argument registers need to relocated.  This */
-	  /* 	step is already done here. */
-	  /* 2. Build the appropriate stub in the .hppa_linker_stubs section. */
-	  /* 	This section should never appear in an object file.  It is */
-	  /* 	only used internally.  The output_section of the */
-	  /* 	.hppa_linker_stubs section is the .text section of the */
-	  /* 	executable.	*/
-	  /* 3. Build a symbol that is used (internally only) as the entry */
-	  /*	point of the stub. */
-	  /* 4. Change the instruction of the original branch into a branch to */
-	  /* 	the stub routine. */
-	  /* 5. Build a relocation entry for the instruction of the original */
-	  /*	branch to be R_HPPA_PCREL_CALL to the stub routine. */
-
-
-	  if (stub_types[0]
-	      || stub_types[1]
-	      || stub_types[2]
-	      || stub_types[3]
-	      || stub_types[4])
-	    {
-#ifdef DETECT_STUBS
-	      int i;
-
-	      fprintf (stderr, "Stub needed for %s @ %s+0x%x: callee/caller ar=0x%x/0x%x ",
-		       reloc_entry->sym_ptr_ptr[0]->name,
-		       abfd->filename, reloc_entry->address,
-		       callee_ar, caller_ar);
-	      for (i = ARG0; i < RETVAL; i++)
-		{
-		  if (stub_types[i] != NO_ARG_RELOC)
-		    {
-		      fprintf (stderr, "%s%d: %s ",
-			       i == RETVAL ? "ret" : "arg",
-			       i == RETVAL ? 0 : i,
-			       reloc_type_strings[stub_types[i]]);
-		    }
-		}
-	      fprintf (stderr, "\n");
-#endif
-	      return 1;
-	    }
-
+	  /* Now look up potential mismatches.  */
+	  stub_types[ARG0] = type_of_mismatch (caller_loc[ARG0],
+					       callee_loc[ARG0],
+					       ARGUMENTS);
+	  stub_types[ARG1] = type_of_mismatch (caller_loc[ARG1],
+					       callee_loc[ARG1],
+					       ARGUMENTS);
+	  stub_types[ARG2] = type_of_mismatch (caller_loc[ARG2],
+					       callee_loc[ARG2],
+					       ARGUMENTS);
+	  stub_types[ARG3] = type_of_mismatch (caller_loc[ARG3],
+					       callee_loc[ARG3],
+					       ARGUMENTS);
+	  stub_types[RETVAL] = type_of_mismatch (caller_loc[RETVAL],
+						 callee_loc[RETVAL],
+						 RETURN_VALUE);
+
+	  /* If any of the arguments or return value need an argument
+	     relocation, then we will need an argument relocation stub.  */
+	  if (stub_types[ARG0] != NO_ARG_RELOC
+	      || stub_types[ARG1] != NO_ARG_RELOC
+	      || stub_types[ARG2] != NO_ARG_RELOC
+	      || stub_types[ARG3] != NO_ARG_RELOC
+	      || stub_types[RETVAL] != NO_ARG_RELOC)
+	    return 1;
 	}
     }
   return 0;
 }
 
-asymbol *
-hppa_elf_build_long_branch_stub (abfd, output_bfd, link_info, reloc_entry,
-				 symbol, data)
+/* Create the linker stub section.  */
+
+static void
+hppa_elf_create_stub_sec (abfd, output_bfd, secptr, link_info)
      bfd *abfd;
      bfd *output_bfd;
+     asection **secptr;
      struct bfd_link_info *link_info;
-     arelent *reloc_entry;
-     asymbol *symbol;
-     unsigned *data;
 {
-  asection *stub_sec = bfd_get_section_by_name (abfd, ".hppa_linker_stubs");
-  elf32_hppa_stub_description *stub_desc = find_stubs (abfd, stub_sec);
-  asymbol *stub_sym = NULL;
-  asymbol *target_sym = reloc_entry->sym_ptr_ptr[0];
-  asection *output_text_section = bfd_get_section_by_name (output_bfd, ".text");
-  char stub_sym_name[128];
-  int milli = false;
-  int dyncall = false;
-  elf32_hppa_stub_name_list *stub_entry;
-  int rtn_adjust = true;
-  int rtn_reg;
-  unsigned insn;
-
-  /* Create the stub section if it does not already exist.  */
-  if (!stub_sec)
-    {
-      BFD_ASSERT (stub_desc == NULL);
-      stub_sec = bfd_make_section (abfd, ".hppa_linker_stubs");
-      bfd_set_section_flags (abfd,
-			     stub_sec,
-			     SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
-			     | SEC_RELOC | SEC_CODE | SEC_READONLY);
-      stub_sec->output_section = output_text_section->output_section;
-      stub_sec->output_offset = 0;
-
-      /* Set up the ELF section header for this new section.  This
-	 is basically the same processing as elf_make_sections().  
-	 elf_make_sections is static and therefore not accessable
-	 here.  */
+  asection *output_text_section;
+  
+  output_text_section = bfd_get_section_by_name (output_bfd, ".text");
+  *secptr = bfd_make_section (abfd, ".hppa_linker_stubs");
+  bfd_set_section_flags (abfd, *secptr,
+			 SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD
+			 | SEC_RELOC | SEC_CODE | SEC_READONLY);
+  (*secptr)->output_section = output_text_section->output_section;
+  (*secptr)->output_offset = 0;
+  
+  /* Set up the ELF section header for this new section.  This
+     is basically the same processing as elf_make_sections().  
+     elf_make_sections is static and therefore not accessable
+     here.  */
+  {
+    Elf_Internal_Shdr *this_hdr;
+    this_hdr = &elf_section_data ((*secptr))->this_hdr;
+    
+    /* Set the sizes of this section.  The contents have already
+       been set up ?!?  */
+    this_hdr->sh_addr = (*secptr)->vma;
+    this_hdr->sh_size = (*secptr)->_raw_size;
+    
+    /* Set appropriate flags for sections with relocations.  */
+    if ((*secptr)->flags & SEC_RELOC)
       {
-	Elf_Internal_Shdr *this_hdr;
-	this_hdr = &elf_section_data (stub_sec)->this_hdr;
+	Elf_Internal_Shdr *rela_hdr;
+	int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
 	
-	/* Set the sizes of this section.  The contents have already
-	   been set up ?!?  */
-	this_hdr->sh_addr = stub_sec->vma;
-	this_hdr->sh_size = stub_sec->_raw_size;
+	rela_hdr = &elf_section_data ((*secptr))->rel_hdr;
 	
-	/* Set appropriate flags for sections with relocations.  */
-	if (stub_sec->flags & SEC_RELOC)
+	if (use_rela_p)
 	  {
-	    Elf_Internal_Shdr *rela_hdr;
-	    int use_rela_p = get_elf_backend_data (abfd)->use_rela_p;
-	    
-	    rela_hdr = &elf_section_data (stub_sec)->rel_hdr;
-	    
-	    if (use_rela_p)
-	      {
-		rela_hdr->sh_type = SHT_RELA;
-		rela_hdr->sh_entsize = sizeof (Elf32_External_Rela);
-	      }
-	    else
-	      {
-		rela_hdr->sh_type = SHT_REL;
-		rela_hdr->sh_entsize = sizeof (Elf32_External_Rel);
-	      }
-	    rela_hdr->sh_flags = 0;
-	    rela_hdr->sh_addr = 0;
-	    rela_hdr->sh_offset = 0;
-	    rela_hdr->sh_addralign = 0;
-	    rela_hdr->size = 0;
+	    rela_hdr->sh_type = SHT_RELA;
+	    rela_hdr->sh_entsize = sizeof (Elf32_External_Rela);
 	  }
-
-	if (stub_sec->flags & SEC_ALLOC)
+	else
 	  {
-	    this_hdr->sh_flags |= SHF_ALLOC;
-	    /* FIXME.  If SEC_LOAD is true should we do something with
-	       with sh_type?  */
+	    rela_hdr->sh_type = SHT_REL;
+	    rela_hdr->sh_entsize = sizeof (Elf32_External_Rel);
 	  }
-
-	if (!(stub_sec->flags & SEC_READONLY))
-	  this_hdr->sh_flags |= SHF_WRITE;
-	
-	if (stub_sec->flags & SEC_CODE)
-	  this_hdr->sh_flags |= SHF_EXECINSTR;
+	rela_hdr->sh_flags = 0;
+	rela_hdr->sh_addr = 0;
+	rela_hdr->sh_offset = 0;
+	rela_hdr->sh_addralign = 0;
+	rela_hdr->size = 0;
       }
-      
-      bfd_set_section_alignment (abfd, stub_sec, 2);
-      stub_desc = new_stub (abfd, stub_sec, link_info);
-    }
-  
-  if (!stub_desc)
-    stub_desc = new_stub (abfd, stub_sec, link_info);
-  
-  /* Allocate memory to contain the stub.  FIXME.  Why isn't this using
-     the BFD memory allocation routines?  */
-  if (!stub_desc->stub_contents)
-    {
-      stub_desc->allocated_size = STUB_BUFFER_INCR;
-      stub_desc->stub_contents = (char *) malloc (STUB_BUFFER_INCR);
-    }
-  else if ((stub_desc->allocated_size - stub_desc->real_size) < STUB_MAX_SIZE)
-    {
-      stub_desc->allocated_size = stub_desc->allocated_size + STUB_BUFFER_INCR;
-      stub_desc->stub_contents = (char *) realloc (stub_desc->stub_contents,
-						   stub_desc->allocated_size);
-    }
-  
-  stub_desc->stub_secp
-    = (int *) (stub_desc->stub_contents + stub_desc->real_size);
-  
-  /* Is this a millicode call?  If so, the return address
-     comes in on r31 rather than r2 (rp) so a slightly
-     different code sequence is needed.  */
-  
-  insn = data[0];
-  rtn_reg = (insn & 0x03e00000) >> 21;
-  if (rtn_reg == 31)
-    milli = true;
-  
-  if (strcmp (symbol->name, "$$dyncall") == 0)
-    dyncall = true;
-
-  /* If we are creating a call from a stub to another stub, then
-     never do the instruction reordering.  We can tell if we are
-     going to be calling one stub from another by the fact that
-     the symbol name has '_stub_' (arg. reloc. stub) or '_lb_stub_'
-     prepended to the name.  Alternatively, the section of the
-     symbol will be '.hppa_linker_stubs'.  */
-
-  if ((strncmp (symbol->name, "_stub_", 6) == 0)
-      || (strncmp (symbol->name, "_lb_stub_", 9) == 0))
-    {
-      BFD_ASSERT (strcmp (symbol->section->name, ".hppa_linker_stubs") == 0);
-      rtn_adjust = false;
-    }
-  
-  /* Check to see if we modify the return pointer
-     in the delay slot of the branch.  */
-  {
-    unsigned delay_insn = data[1];
     
-    /* If we nullify the delay slot, or if the delay slot contains an
-       instruction that modifies the return pointer, then no additional
-       modification of the return pointer is necessary.  */
-    if (insn & 2 || insn == 0)
-      rtn_adjust = false;
-    else
-      {
-	if (get_opcode (delay_insn) == LDO
-	    && (((delay_insn & 0x001f0000) >> 16) == rtn_reg))
-	  rtn_adjust = false;
-        if (milli)
-          rtn_adjust = false;
-      }
+    if ((*secptr)->flags & SEC_ALLOC)
+      this_hdr->sh_flags |= SHF_ALLOC;
+    
+    if (!((*secptr)->flags & SEC_READONLY))
+      this_hdr->sh_flags |= SHF_WRITE;
+    
+    if ((*secptr)->flags & SEC_CODE)
+      this_hdr->sh_flags |= SHF_EXECINSTR;
   }
   
-  sprintf (stub_sym_name,
-	   "_lb_stub_%s_%s", reloc_entry->sym_ptr_ptr[0]->name,
-	   rtn_adjust ? "RA" : "");
-  stub_entry = find_stub_by_name(abfd, stub_sec, stub_sym_name);
-
-  /* If a copy of this stub already exists re-use it.  */
-  if (stub_entry)
-    {
-      stub_sym = stub_entry->sym;
-
-      /* Change symbol associated with the original relocation to point
-	 to the stub.
-
-	 FIXME.  Is there a need to change the relocation type too?  */
-      reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
-							  sizeof (asymbol *));
-      if (!reloc_entry->sym_ptr_ptr)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      reloc_entry->sym_ptr_ptr[0] = stub_sym;
-      reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
-    }
-  else
-    {
-      /* We will need to allocate a new stub.  */
-      stub_sym = bfd_make_empty_symbol (abfd);
-      if (!stub_sym)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      stub_sym->name = bfd_zalloc (abfd, strlen (stub_sym_name) + 1);
-      if (!stub_sym->name)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      strcpy ((char *) stub_sym->name, stub_sym_name);
-      stub_sym->value
-	= (char *) stub_desc->stub_secp - (char *) stub_desc->stub_contents;
-      stub_sym->section = stub_sec;
-      stub_sym->flags = BSF_LOCAL | BSF_FUNCTION;
-      stub_entry = add_stub_by_name (abfd, stub_sec, stub_sym, link_info);
-      
-      /* Change symbol associated with the original relocation to point
-	 to the stub.
-
-	 FIXME.  Is there a need to change the relocation type too?  */
-      reloc_entry->sym_ptr_ptr = (asymbol **) bfd_zalloc (stub_desc->this_bfd,
-							  sizeof (asymbol *));
-      if (!reloc_entry->sym_ptr_ptr)
-	{
-	  bfd_set_error (bfd_error_no_memory);
-	  return NULL;
-	}
-      reloc_entry->sym_ptr_ptr[0] = stub_sym;
-      reloc_entry->howto = bfd_reloc_type_lookup (abfd, R_HPPA_STUB_CALL_17);
-      
-      /* Build the stub.  */
-      
-      /* 1. initialization for the call. */
-      NEW_INSTRUCTION (stub_entry, LDSID_31_1);
-      NEW_INSTRUCTION (stub_entry, MTSP_1_SR0);
-      
-      if (!dyncall)
-	{
-	  if (!milli)
-	    {
-	      if (rtn_adjust)
-		{
-		  NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
-		}
-	      else
-		{
-		  NEW_INSTRUCTION (stub_entry, COPY_31_2);
-		}
-	    }
-	  else
-	    {
-	      if (rtn_adjust)
-		{
-		  NEW_INSTRUCTION (stub_entry, ADDI_M4_31_1);
-		}
-	      else
-		{
-		  NEW_INSTRUCTION (stub_entry, COPY_31_1);
-		}
-	    }
-	  
-	  NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
-	  hppa_elf_stub_reloc (stub_desc,
-			       abfd,
-			       target_sym,
-			       CURRENT_STUB_OFFSET (stub_entry),
-			       R_HPPA_L21);
-	  
-	  /* 2. Make the call. */
-	  if (!milli)
-	    {
-	      NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
-	      hppa_elf_stub_reloc (stub_desc,
-				   abfd,
-				   target_sym,
-				   CURRENT_STUB_OFFSET (stub_entry),
-				   R_HPPA_ABS_CALL_R17);
-	      NEW_INSTRUCTION (stub_entry, COPY_2_31);
-	    }
-	  else
-	    {
-	      NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
-	      hppa_elf_stub_reloc (stub_desc,
-				   abfd,
-				   target_sym,
-				   CURRENT_STUB_OFFSET (stub_entry),
-				   R_HPPA_ABS_CALL_R17);
-	      NEW_INSTRUCTION (stub_entry, COPY_1_31);
-	    }
-	}
-      else
-	{
-	  /* 3. Branch back to the original location.
-	     (For non-millicode calls, this is accomplished with the
-	     COPY_31_2 instruction.  For millicode calls, the return
-	     location is already in r2.)  */
-	  if (rtn_adjust)
-	    {
-	      NEW_INSTRUCTION (stub_entry, ADDI_M4_31_RP);
-	    }
-	  NEW_INSTRUCTION (stub_entry, LDIL_XXX_31);
-	  hppa_elf_stub_reloc (stub_desc,
-			       abfd,
-			       target_sym,
-			       CURRENT_STUB_OFFSET (stub_entry),
-			       R_HPPA_L21);
-	  
-	  NEW_INSTRUCTION (stub_entry, BE_XXX_0_31);
-	  hppa_elf_stub_reloc (stub_desc,
-			       abfd,
-			       target_sym,
-			       CURRENT_STUB_OFFSET (stub_entry),
-			       R_HPPA_ABS_CALL_R17);
-	  NEW_INSTRUCTION (stub_entry, COPY_2_31);
-	}
-    }
-  return stub_sym;
+  bfd_set_section_alignment (abfd, *secptr, 2);
 }
 
-int
+/* Return nonzero if a long-call stub will be needed to call the
+   function (symbol in RELOC_ENTRY).  */
+
+static int
 hppa_elf_long_branch_needed_p (abfd, asec, reloc_entry, symbol, insn)
      bfd *abfd;
      asection *asec;
@@ -2765,32 +2647,35 @@ hppa_elf_long_branch_needed_p (abfd, asec, reloc_entry, symbol, insn)
      asymbol *symbol;
      unsigned insn;
 {
-  long sym_value = get_symbol_value(symbol);
+  long sym_value = get_symbol_value (symbol);
   int fmt = reloc_entry->howto->bitsize;
-  unsigned char op = get_opcode(insn);
+  unsigned char op = get_opcode (insn);
   unsigned raddr;
 
-#define too_far(val,num_bits)	((int)(val) > (1<<(num_bits))-1) || ((int)(val) < (-1<<(num_bits)))
+#define too_far(val,num_bits) \
+  ((int)(val) > (1 << (num_bits)) - 1) || ((int)(val) < (-1 << (num_bits)))
 
   switch (op)
     {
     case BL:
       raddr =
 	reloc_entry->address + asec->output_offset + asec->output_section->vma;
-      if (too_far(sym_value - raddr,fmt+1))
-	{
-#ifdef DETECT_STUBS
-	  fprintf(stderr,"long_branch needed on BL insn: abfd=%s,sym=%s,distance=0x%x\n",abfd->filename,symbol->name,sym_value - reloc_entry->address);
-#endif
+      /* If the symbol and raddr (relocated addr?) are too far away from
+	 each other, then a long-call stub will be needed.  */
+      if (too_far (sym_value - raddr, fmt + 1))
 	  return 1;
-	}
       break;
     }  
   return 0;
 }
 
-#define STUB_SYM_BUFFER_INC	5
+/* Search the given section and determine if linker stubs will be
+   needed for any calls within that section.
+
+   Return any new stub symbols created.
 
+   Used out of hppaelf.em in the linker.  */
+   
 asymbol *
 hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 				syms, new_sym_cnt, link_info)
@@ -2803,28 +2688,31 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
      struct bfd_link_info *link_info;
 {
   int i;
-  int stub_types[5];
-  asymbol *new_syms = (asymbol *) NULL;
+  arg_reloc_type stub_types[5];
+  asymbol *new_syms = NULL;
   int new_cnt = 0;
   int new_max = 0;
 
   /* Relocations are in different places depending on whether this is
      an output section or an input section.  Also, the relocations are
-     in different forms.  Sigh.  Luckily, we have
-     bfd_canonicalize_reloc() to straighten this out for us . */
-
+     in different forms.  Sigh.  Luckily, we have bfd_canonicalize_reloc()
+     to straighten this out for us . */
   if (asec->reloc_count > 0)
     {
       arelent **reloc_vector
 	= (arelent **) alloca (asec->reloc_count * (sizeof (arelent *) + 1));
 
       bfd_canonicalize_reloc (abfd, asec, reloc_vector, syms);
+
+      /* Examine each relocation entry in this section.  */
       for (i = 0; i < asec->reloc_count; i++)
 	{
 	  arelent *rle = reloc_vector[i];
 
 	  switch (rle->howto->type)
 	    {
+	    /* Any call could need argument relocation stubs, and
+	       some may need long-call stubs.  */
 	    case R_HPPA_ABS_CALL_11:
 	    case R_HPPA_ABS_CALL_14:
 	    case R_HPPA_ABS_CALL_17:
@@ -2867,8 +2755,11 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 		  = (symext_entryS) HPPA_R_ARG_RELOC (rle->addend);
 		unsigned insn[2];
 
+		/* We'll need this for the long-call checks.  */
 		bfd_get_section_contents (abfd, asec, insn, rle->address,
 					  sizeof(insn));
+
+		/* See if this call needs an argument relocation stub.  */
 		if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
 						 caller_ar))
 		  {
@@ -2880,22 +2771,19 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 			new_max += STUB_SYM_BUFFER_INC;
 			new_syms = (asymbol *)
 			  realloc (new_syms, new_max * sizeof (asymbol));
+			if (new_syms == NULL)
+			  abort ();
 		      }
 
-		    /* The rtn_adjust argument is true here because we
-		       know that we have a branch and (with a few exceptions
-		       detailed under the relocation code for relocation type
-		       R_HPPA_STUB_CALL_17) it will be possible to perform
-		       the code reorientation.  */
-		    r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd,
-						       link_info, rle,
-						       stub_types,
-						       true, insn);
+		    /* Build the argument relocation stub.  */
+		    r = hppa_elf_build_linker_stub (stub_bfd, output_bfd,
+						    link_info, rle,
+						    stub_types, true, insn, 
+						    HPPA_STUB_ARG_RELOC);
 		    new_syms[new_cnt++] = *r;
 		  }
 
-		/* We need to retrieve the section contents to check for
-		   long branch stubs.  */
+		/* See if this call needs a long-call stub.  */
 		if (hppa_elf_long_branch_needed_p (abfd, asec, rle,
 						   rle->sym_ptr_ptr[0],
 						   insn[0]))
@@ -2908,16 +2796,21 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 			new_max += STUB_SYM_BUFFER_INC;
 			new_syms = (asymbol *)
 			  realloc (new_syms, (new_max * sizeof (asymbol)));
+			if (! new_syms)
+			  abort ();
 		      }
-		    r = hppa_elf_build_long_branch_stub (stub_bfd, output_bfd,
-							 link_info, rle,
-							 rle->sym_ptr_ptr[0],
-							 insn);
+
+		    /* Build the long-call stub.  */
+		    r = hppa_elf_build_linker_stub (stub_bfd, output_bfd,
+						    link_info, rle,
+						    NULL, true, insn, 
+						    HPPA_STUB_LONG_CALL);
 		    new_syms[new_cnt++] = *r;
 		  }
 	      }
 	      break;
 
+	    /* PLABELs may need argument relocation stubs.  */
 	    case R_HPPA_PLABEL_32:
 	    case R_HPPA_PLABEL_11:
 	    case R_HPPA_PLABEL_14:
@@ -2926,14 +2819,17 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 	    case R_HPPA_PLABEL_R14:
 	      {
 		/* On a plabel relocation, assume the arguments of the
-		   caller are set up in general registers.
-		   NOTE:  0x155 = ARGW0=CR,ARGW1=GR,ARGW2=GR,RETVAL=GR */
+		   caller are set up in general registers (indirect
+		   calls only use general registers.
+		   NOTE:  0x155 = ARGW0=GR,ARGW1=GR,ARGW2=GR,RETVAL=GR.  */
 		symext_entryS caller_ar = (symext_entryS) 0x155;
 		unsigned insn[2];
 
+		/* Do we really need this?  */
 		bfd_get_section_contents (abfd, asec, insn, rle->address,
 					  sizeof(insn));
 
+		/* See if this call needs an argument relocation stub.  */
 		if (hppa_elf_arg_reloc_needed_p (abfd, rle, stub_types,
 						 caller_ar))
 		  {
@@ -2953,7 +2849,6 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 		       (see the relocation code for relocation type 
 		       R_HPPA_STUB_CALL_17) is possible.  Basically,
 		       determine whether we are looking at a branch or not.  */
-							      
 		    if (rle->howto->type == R_HPPA_PLABEL_32)
 		      rtn_adjust = false;
 		    else
@@ -2968,10 +2863,12 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 			    rtn_adjust = false;
 			  }
 		      }
-		    r = hppa_elf_build_arg_reloc_stub (stub_bfd, output_bfd,
-						       link_info, rle,
-						       stub_types,
-						       rtn_adjust, insn);
+
+		    /* Build the argument relocation stub.  */
+		    r = hppa_elf_build_linker_stub (stub_bfd, output_bfd,
+						    link_info, rle, stub_types,
+						    rtn_adjust, insn,
+						    HPPA_STUB_ARG_RELOC);
 		    new_syms[new_cnt++] = *r;
 		  }
 	      }
@@ -2979,21 +2876,18 @@ hppa_look_for_stubs_in_section (stub_bfd, abfd, output_bfd, asec,
 
 	    default:
 	      break;
-
 	    }
 	}
     }
+
+  /* Return the new symbols and update the counters.  */
   *new_sym_cnt = new_cnt;
   return new_syms;
 }
 
+/* Set the contents of a particular section at a particular location.  */
 
-char *linker_stubs = NULL;
-int linker_stubs_size = 0;
-int linker_stubs_max_size = 0;
-#define STUB_ALLOC_INCR	100
-
-boolean
+static boolean
 hppa_elf_set_section_contents (abfd, section, location, offset, count)
      bfd *abfd;
      sec_ptr section;
@@ -3001,21 +2895,27 @@ hppa_elf_set_section_contents (abfd, section, location, offset, count)
      file_ptr offset;
      bfd_size_type count;
 {
-  if (strcmp(section->name, ".hppa_linker_stubs") == 0)
+  /* Linker stubs are handled a little differently.  */
+  if (! strcmp (section->name, ".hppa_linker_stubs"))
     {
       if (linker_stubs_max_size < offset + count)
 	{
 	  linker_stubs_max_size = offset + count + STUB_ALLOC_INCR;
-	  linker_stubs = (char *)realloc(linker_stubs, linker_stubs_max_size);
+	  linker_stubs = (char *)realloc (linker_stubs, linker_stubs_max_size);
+	  if (! linker_stubs)
+	    abort ();
 	}
 
       if (offset + count > linker_stubs_size)
 	linker_stubs_size = offset + count;
 
-      memcpy(linker_stubs + offset,location,count);
+      /* Set the contents.  */
+      memcpy(linker_stubs + offset, location, count);
       return (true);
     }
   else
+    /* For everything but the linker stub section, use the generic
+       code.  */
     return bfd_elf32_set_section_contents (abfd, section, location,
 					   offset, count);
 }
@@ -3077,14 +2977,14 @@ hppa_elf_get_section_contents (abfd, section, location, offset, count)
 	{
 	  int i;
 	  int *symtab_map =
-	    (int *) elf_sym_extra(section->output_section->owner);
+	    (int *) elf_sym_extra (section->output_section->owner);
 	  
 	  for (i = 0; i < section->output_section->owner->symcount; i++)
 	    {
-	      elf_hppa_tc_symbol(section->output_section->owner,
-				 ((elf_symbol_type *)
-				  section->output_section->owner->outsymbols[i]),
-				 symtab_map[i], &symext_rootP, &symext_lastP);
+	      elf_hppa_tc_symbol (section->output_section->owner,
+				  ((elf_symbol_type *)
+				   section->output_section->owner->outsymbols[i]),
+				  symtab_map[i], &symext_rootP, &symext_lastP);
 	    }
 	  symext_chain_built++;
 	  elf_hppa_tc_make_sections (section->output_section->owner, 
@@ -3102,15 +3002,19 @@ hppa_elf_get_section_contents (abfd, section, location, offset, count)
 	return (false);
       
       memcpy (location,
-	      ((char *)symextn_contents + section->output_offset + offset),
+	      (char *)symextn_contents + section->output_offset + offset,
 	      count);
       return (true);
     }
   else
+    /* It's not the symbol extension or linker stub sections, use
+       the generic routines.  */
     return bfd_generic_get_section_contents (abfd, section, location,
 					     offset, count);
 }
 
+/* Translate from an elf into field into a howto relocation pointer.  */
+
 static void
 elf_info_to_howto (abfd, cache_ptr, dst)
      bfd *abfd;
@@ -3118,9 +3022,12 @@ elf_info_to_howto (abfd, cache_ptr, dst)
      Elf32_Internal_Rela *dst;
 {
   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_HPPA_UNIMPLEMENTED);
-  cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE(dst->r_info)];
+  cache_ptr->howto = &elf_hppa_howto_table[ELF32_R_TYPE (dst->r_info)];
 }
 
+/* Do PA ELF specific processing for symbols.  Needed to find the
+   value of $global$.  */
+
 static void
 elf32_hppa_backend_symbol_processing (abfd, sym)
      bfd *abfd;
@@ -3128,7 +3035,6 @@ elf32_hppa_backend_symbol_processing (abfd, sym)
 {
   /* Is this a definition of $global$?  If so, keep it because it will be
     needed if any relocations are performed.  */
-
   if (!strcmp (sym->name, "$global$")
       && sym->section != &bfd_und_section)
     {
@@ -3136,43 +3042,29 @@ elf32_hppa_backend_symbol_processing (abfd, sym)
     }
 }
 
-#define elf_backend_symbol_processing	elf32_hppa_backend_symbol_processing
-
-struct elf32_hppa_symextn_map_struct
-{
-  int old_index;
-  bfd *bfd;
-  asymbol *sym;
-  int new_index;
-};
-
-static struct elf32_hppa_symextn_map_struct *elf32_hppa_symextn_map;
-static int elf32_hppa_symextn_map_size;
-
+/* Do some PA ELF specific work after reading in the symbol table.
+   In particular attach the argument relocation from the 
+   symbol extension section to the appropriate symbols.  */
 static boolean
 elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
      bfd *abfd;
      elf_symbol_type *esyms;
      int symcnt;
 {
-  Elf32_Internal_Shdr *symextn_hdr = bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
-  int i;
-  int current_sym_idx = 0;
-
-  /* If the symbol extension section does not exist, all the symbol */
-  /* all the symbol extension information is assumed to be zero.	*/
+  Elf32_Internal_Shdr *symextn_hdr =
+    bfd_elf_find_section (abfd, SYMEXTN_SECTION_NAME);
+  int i, current_sym_idx = 0;
 
+  /* If no symbol extension existed, then all symbol extension information
+     is assumed to be zero.  */
   if (symextn_hdr == NULL)
     {
       for (i = 0; i < symcnt; i++)
-	{
-	  esyms[i].tc_data.hppa_arg_reloc = 0;
-	}
+	esyms[i].tc_data.hppa_arg_reloc = 0;
       return (true);
     }
 
-  /* allocate a buffer of the appropriate size for the symextn section */
-
+  /* Allocate a buffer of the appropriate size for the symextn section.  */
   symextn_hdr->contents = bfd_zalloc(abfd,symextn_hdr->sh_size);
   if (!symextn_hdr->contents)
     {
@@ -3181,8 +3073,7 @@ elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
     }
   symextn_hdr->size = symextn_hdr->sh_size;
 	
-  /* read in the symextn section */
-
+  /* Read in the symextn section.  */
   if (bfd_seek (abfd, symextn_hdr->sh_offset, SEEK_SET) == -1)
     {
       bfd_set_error (bfd_error_system_call);
@@ -3191,18 +3082,17 @@ elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
   if (bfd_read ((PTR) symextn_hdr->contents, 1, symextn_hdr->size, abfd) 
       != symextn_hdr->size)
     {
-      free ((PTR)symextn_hdr->contents);
       bfd_set_error (bfd_error_system_call);
       return (false);
     }	
 
-  /* parse the entries, updating the symtab entries as we go */
-
+  /* Parse entries in the symbol extension section, updating the symtab
+     entries as we go */
   for (i = 0; i < symextn_hdr->size / sizeof(symext_entryS); i++)
     {
       symext_entryS *seP = ((symext_entryS *)symextn_hdr->contents) + i;
-      int se_value = ELF32_HPPA_SX_VAL(*seP);
-      int se_type = ELF32_HPPA_SX_TYPE(*seP);
+      int se_value = ELF32_HPPA_SX_VAL (*seP);
+      int se_type = ELF32_HPPA_SX_TYPE (*seP);
 
       switch (se_type)
 	{
@@ -3213,7 +3103,6 @@ elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
 	  if (se_value >= symcnt)
 	    {
 	      bfd_set_error (bfd_error_bad_value);
-	      bfd_perror("elf32_hppa_backend_symbol_table_processing -- symbol index");
 	      return (false);
 	    }
 	  current_sym_idx = se_value - 1;
@@ -3225,29 +3114,30 @@ elf32_hppa_backend_symbol_table_processing (abfd, esyms,symcnt)
 
 	default:
 	  bfd_set_error (bfd_error_bad_value);
-	  bfd_perror("elf32_hppa_backend_symbol_table_processing");
 	  return (false);
 	}
     }
   return (true);
 }
 
-#define elf_backend_symbol_table_processing	elf32_hppa_backend_symbol_table_processing
+/* Perform on PA ELF specific processing once a section has been
+   read in.  In particular keep the symbol indexes correct for
+   the symbol extension information.  */
 
 static boolean
 elf32_hppa_backend_section_processing (abfd, secthdr)
      bfd *abfd;
      Elf32_Internal_Shdr *secthdr;
 {
-  int i,j,k;
+  int i, j, k;
 
   if (secthdr->sh_type == SHT_HPPA_SYMEXTN)
     {
-      for (i = 0; i < secthdr->size / sizeof(symext_entryS); i++)
+      for (i = 0; i < secthdr->size / sizeof (symext_entryS); i++)
 	{
 	  symext_entryS *seP = ((symext_entryS *)secthdr->contents) + i;
-	  int se_value = ELF32_HPPA_SX_VAL(*seP);
-	  int se_type = ELF32_HPPA_SX_TYPE(*seP);
+	  int se_value = ELF32_HPPA_SX_VAL (*seP);
+	  int se_type = ELF32_HPPA_SX_TYPE (*seP);
 	  
 	  switch (se_type)
 	    {
@@ -3257,15 +3147,16 @@ elf32_hppa_backend_section_processing (abfd, secthdr)
 	    case HPPA_SXT_SYMNDX:
 	      for (j = 0; j < abfd->symcount; j++)
 		{
-		  /* locate the map entry for this symbol, if there is one. */
-		  /* modify the symbol extension section symbol index entry */
-		  /* to reflect the new symbol table index */
-		  
+		  /* Locate the map entry for this symbol and modify the
+		     symbol extension section symbol index entry to reflect
+		     the new symbol table index.  */
 		  for (k = 0; k < elf32_hppa_symextn_map_size; k++)
 		    {
 		      if (elf32_hppa_symextn_map[k].old_index == se_value
-			  && elf32_hppa_symextn_map[k].bfd == abfd->outsymbols[j]->the_bfd
-			  && elf32_hppa_symextn_map[k].sym == abfd->outsymbols[j])
+			  && elf32_hppa_symextn_map[k].bfd
+			     == abfd->outsymbols[j]->the_bfd
+			  && elf32_hppa_symextn_map[k].sym
+			     == abfd->outsymbols[j])
 			{
 			  bfd_put_32(abfd,
 				     ELF32_HPPA_SX_WORD (HPPA_SXT_SYMNDX, j),
@@ -3280,7 +3171,6 @@ elf32_hppa_backend_section_processing (abfd, secthdr)
 	      
 	    default:
 	      bfd_set_error (bfd_error_bad_value);
-	      bfd_perror("elf32_hppa_backend_section_processing");
 	      return (false);
 	    }
 	}
@@ -3288,7 +3178,9 @@ elf32_hppa_backend_section_processing (abfd, secthdr)
   return true;
 }
 
-#define elf_backend_section_processing	elf32_hppa_backend_section_processing
+/* What does this really do?  Just determine if there is an appropriate
+   mapping from ELF section headers to backend sections?  More symbol
+   extension braindamage.  */
 
 static boolean
 elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
@@ -3300,9 +3192,9 @@ elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
 
   if (hdr->sh_type == SHT_HPPA_SYMEXTN)
     {
-      BFD_ASSERT (strcmp(name,".hppa_symextn") == 0);
+      BFD_ASSERT (strcmp (name, ".hppa_symextn") == 0);
 
-      /* Bits that get saved. This one is real. */
+      /* Bits that get saved. This one is real.  */
       if (!hdr->rawdata)
 	{
 	  newsect = bfd_make_section (abfd, name);
@@ -3310,7 +3202,7 @@ elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
 	    {
 	      newsect->vma = hdr->sh_addr;
 	      newsect->_raw_size = hdr->sh_size;
-	      newsect->filepos = hdr->sh_offset;	/* so we can read back the bits */
+	      newsect->filepos = hdr->sh_offset;
 	      newsect->flags |= SEC_HAS_CONTENTS;
 	      newsect->alignment_power = hdr->sh_addralign;
 
@@ -3324,7 +3216,7 @@ elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
 		newsect->flags |= SEC_READONLY;
 
 	      if (hdr->sh_flags & SHF_EXECINSTR)
-		newsect->flags |= SEC_CODE;	/* FIXME: may only contain SOME code */
+		newsect->flags |= SEC_CODE;
 	      else
 		newsect->flags |= SEC_DATA;
 
@@ -3336,7 +3228,7 @@ elf32_hppa_backend_section_from_shdr (abfd, hdr, name)
   return false;
 }
 
-#define elf_backend_section_from_shdr	elf32_hppa_backend_section_from_shdr
+/* Return true if the given section is a fake section.  */
 
 static boolean
 elf32_hppa_backend_fake_sections (abfd, secthdr, asect)
@@ -3379,14 +3271,15 @@ elf32_hppa_backend_fake_sections (abfd, secthdr, asect)
   return false;
 }
 
-#define elf_backend_fake_sections	elf32_hppa_backend_fake_sections
+/* Return true if there is a mapping from bfd section into a
+   backend section.  */
 
 static boolean
-elf32_hppa_backend_section_from_bfd_section (abfd, hdr, asect, retval)
+elf32_hppa_backend_section_from_bfd_section (abfd, hdr, asect, ignored)
      bfd *abfd;
      Elf32_Internal_Shdr *hdr;
      asection *asect;
-     int *retval;
+     int *ignored;
 {
   if (hdr->sh_type == SHT_HPPA_SYMEXTN)
     {
@@ -3394,7 +3287,7 @@ elf32_hppa_backend_section_from_bfd_section (abfd, hdr, asect, retval)
 	{
 	  if (((struct sec *) (hdr->rawdata)) == asect)
 	    {
-	      BFD_ASSERT (strcmp(asect->name, ".hppa_symextn") == 0);
+	      BFD_ASSERT (strcmp (asect->name, ".hppa_symextn") == 0);
 	      return true;
 	    }
 	}
@@ -3417,9 +3310,17 @@ elf32_hppa_backend_section_from_bfd_section (abfd, hdr, asect, retval)
 #define bfd_elf32_bfd_reloc_type_lookup	elf_hppa_reloc_type_lookup
 #define elf_backend_section_from_bfd_section	elf32_hppa_backend_section_from_bfd_section
 
+#define elf_backend_symbol_processing	elf32_hppa_backend_symbol_processing
+#define elf_backend_symbol_table_processing	elf32_hppa_backend_symbol_table_processing
+
 #define bfd_generic_get_section_contents	hppa_elf_get_section_contents
 #define bfd_elf32_set_section_contents		hppa_elf_set_section_contents
 
+#define elf_backend_section_processing	elf32_hppa_backend_section_processing
+
+#define elf_backend_section_from_shdr	elf32_hppa_backend_section_from_shdr
+#define elf_backend_fake_sections	elf32_hppa_backend_fake_sections
+
 #define TARGET_BIG_SYM		bfd_elf32_hppa_vec
 #define TARGET_BIG_NAME		"elf32-hppa"
 #define ELF_ARCH		bfd_arch_hppa
diff --git a/bfd/elf32-hppa.h b/bfd/elf32-hppa.h
index 7b1aede..86e8e3c 100644
--- a/bfd/elf32-hppa.h
+++ b/bfd/elf32-hppa.h
@@ -342,13 +342,17 @@ struct symext_chain
 
 typedef struct symext_chain symext_chainS;
 
-void elf_hppa_tc_symbol PARAMS ((bfd *, elf_symbol_type *, int,
-				 symext_chainS **, symext_chainS **));
-void elf_hppa_tc_make_sections PARAMS ((bfd *, symext_chainS *));
-void hppa_elf_stub_finish PARAMS ((bfd *));
-elf32_hppa_reloc_type **hppa_elf_gen_reloc_type PARAMS ((bfd *, 
-							 elf32_hppa_reloc_type,
-							 int, int));
+void elf_hppa_tc_symbol
+  PARAMS ((bfd *, elf_symbol_type *, int, symext_chainS **, symext_chainS **));
+
+elf32_hppa_reloc_type **hppa_elf_gen_reloc_type
+  PARAMS ((bfd *, elf32_hppa_reloc_type, int, int));
+
+asymbol * hppa_look_for_stub_in_section
+  PARAMS ((bfd *, bfd *, bfd *, asection *, asymbol **,
+	   int *, struct bfd_link_info *));
+
 void elf_hppa_final_processing PARAMS ((void));
+void elf_hppa_tc_make_sections PARAMS ((bfd *, symext_chainS *));
 
 #endif /* _ELF32_HPPA_H */