Lots of changes from gas-bfd work. Includes:

 * working reloc lookup support
 * better support for creation of COFF files from scratch
 * misc doc changes, macro tweaks, "const" additions, typo fixes, etc.
 * one or two ugly kludges that should get cleaned up (but what's one
   or two more, in BFD?)
See ChangeLog for details.

5 files changed, 344 insertions, 113 deletions

diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c
index b0a4b9d..e0727db 100644
--- a/bfd/coff-i960.c
+++ b/bfd/coff-i960.c
@@ -27,8 +27,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "sysdep.h"
 #include "libbfd.h"
 #include "obstack.h"
-#include "coff-i960.h"
-#include "internalcoff.h"
+#include "coff/i960.h"
+#include "coff/internal.h"
 #include "libcoff.h"		/* to allow easier abstraction-breaking */
 
 
@@ -37,12 +37,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define BAL_MASK 0x00ffffff
 
 static bfd_reloc_status_type 
-optcall_callback(abfd, reloc_entry, symbol_in, data, ignore_input_section)
-bfd *abfd;
-arelent *reloc_entry;
-asymbol *symbol_in;
-unsigned char *data;
-asection *ignore_input_section;
+DEFUN (optcall_callback, (abfd, reloc_entry, symbol_in, data, ignore_input_section),
+       bfd *abfd AND
+       arelent *reloc_entry AND
+       asymbol *symbol_in AND
+       PTR data AND
+       asection *ignore_input_section)
 {
   /* This item has already been relocated correctly, but we may be
    * able to patch in yet better code - done by digging out the
@@ -70,7 +70,7 @@ asection *ignore_input_section;
 	 to the correct location */
 	{
 	  union internal_auxent *aux = &((cs->native+2)->u.auxent);
-	  int word = bfd_get_32(abfd, data + reloc_entry->address);
+	  int word = bfd_get_32(abfd, (bfd_byte *)data + reloc_entry->address);
 	  int olf = (aux->x_bal.x_balntry - cs->native->u.syment.n_value);
 	  BFD_ASSERT(cs->native->u.syment.n_numaux==2);
 	  /* We replace the original call instruction with a bal to */
@@ -80,7 +80,7 @@ asection *ignore_input_section;
 	  /* offset of the bal entry point */
 
 	  word = ((word +  olf)  & BAL_MASK) | BAL;
-  	  bfd_put_32(abfd, word,  data+reloc_entry->address);
+  	  bfd_put_32(abfd, word, (bfd_byte *) data + reloc_entry->address);
   	}
 	result = bfd_reloc_ok;
 	break;
@@ -97,51 +97,47 @@ asection *ignore_input_section;
   return result;
 }
 
-
-
-static reloc_howto_type howto_table[] = 
-{
-  {0},
-  {1},
-  {2},
-  {3},
-  {4},
-  {5},
-  {6},
-  {7},
-  {8},
-  {9},
-  {10},
-  {11},
-  {12},
-  {13},
-  {14},
-  {15},
-  {16},
-
+static reloc_howto_type howto_rellong =
   { (unsigned int) R_RELLONG, 0, 2, 32,false, 0, true, true,
-      0,"rellong", true, 0xffffffff, 0xffffffff},
-  {18},
-  {19},
-  {20},
-  {21},
-  {22},
-  {23},
-  {24},
-
+      0,"rellong", true, 0xffffffff, 0xffffffff};
+static reloc_howto_type howto_iprmed =
   {  R_IPRMED, 0, 2, 24,true,0, true, true,0,"iprmed ", true,
-       0x00ffffff, 0x00ffffff},
-  {26},
- 
+       0x00ffffff, 0x00ffffff};
+static reloc_howto_type howto_optcall =
   {  R_OPTCALL, 0,2,24,true,0, true, true, optcall_callback,
-       "optcall", true, 0x00ffffff, 0x00ffffff},
+       "optcall", true, 0x00ffffff, 0x00ffffff};
 
-};
+static reloc_howto_type *
+DEFUN (coff_i960_reloc_type_lookup, (abfd, code),
+       bfd *abfd AND
+       bfd_reloc_code_type code)
+{
+  switch (code)
+    {
+    default:
+      return 0;
+    case BFD_RELOC_I960_CALLJ:
+      return &howto_optcall;
+    case BFD_RELOC_32:
+      return &howto_rellong;
+    case BFD_RELOC_24_PCREL:
+      return &howto_iprmed;
+    }
+}
 
 /* The real code is in coffcode.h */
 
 #define RTYPE2HOWTO(cache_ptr, dst) \
-	    cache_ptr->howto = howto_table + dst.r_type;
+{							\
+   reloc_howto_type *howto_ptr;				\
+   switch ((dst)->r_type) {				\
+     case 17: howto_ptr = &howto_rellong; break;	\
+     case 25: howto_ptr = &howto_iprmed; break;		\
+     case 27: howto_ptr = &howto_optcall; break;	\
+     default: howto_ptr = 0; break;			\
+     }							\
+   cache_ptr->howto = howto_ptr;			\
+ }
 
 #include "coffcode.h"
 
@@ -170,8 +166,11 @@ bfd_target icoff_little_vec =
        _bfd_generic_mkarchive, bfd_false},
     {bfd_false, coff_write_object_contents, /* bfd_write_contents */
        _bfd_write_archive_contents, bfd_false},
-  JUMP_TABLE(coff)
-  };
+  JUMP_TABLE(coff),
+  COFF_SWAP_TABLE,
+  coff_i960_reloc_type_lookup,
+  coff_make_debug_symbol,
+};
 
 
 bfd_target icoff_big_vec =
@@ -200,5 +199,7 @@ _do_getb64, _do_putb64,  _do_getb32, _do_putb32, _do_getb16, _do_putb16, /* hdrs
   {bfd_false, coff_write_object_contents,	/* bfd_write_contents */
      _bfd_write_archive_contents, bfd_false},
   JUMP_TABLE(coff),
-COFF_SWAP_TABLE
+  COFF_SWAP_TABLE,
+  coff_i960_reloc_type_lookup,
+  coff_make_debug_symbol,
 };
diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index 6c7eea9..cdb94eb 100644
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -22,6 +22,10 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 Most of this hacked by  Steve Chamberlain,
 			sac@cygnus.com 
 */
+
+#include <assert.h>
+#include <stdio.h>
+
 /*
 
 SECTION
@@ -377,23 +381,34 @@ static flagword
 DEFUN(styp_to_sec_flags, (styp_flags),
 	long	styp_flags)
 {
-    flagword	sec_flags=0;
-
-    if ((styp_flags & STYP_TEXT) || (styp_flags & STYP_DATA))
-	sec_flags = (SEC_LOAD | SEC_ALLOC);
-    else if (styp_flags & STYP_BSS)
-	sec_flags = SEC_ALLOC;
+  flagword	sec_flags=0;
 
-#ifdef STYP_LIT		/* A29k readonly text/data section type */
-    if ((styp_flags & STYP_LIT) == STYP_LIT)
-	sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
-#endif  /* STYP_LIT */
-#ifdef STYP_OTHER_LOAD	/* Other loaded sections */
-    if (styp_flags & STYP_OTHER_LOAD)
-	sec_flags = (SEC_LOAD | SEC_ALLOC);
-#endif  /* STYP_SDATA */
+  if ((styp_flags & STYP_TEXT) || (styp_flags & STYP_DATA)) 
+  {
+    sec_flags = SEC_LOAD | SEC_ALLOC;
+  }
+  else if (styp_flags & STYP_BSS) 
+  {
+    sec_flags = SEC_ALLOC;
+  }
+  else
+  {
+    sec_flags = SEC_ALLOC | SEC_LOAD;
+  }
+#ifdef STYP_LIT			/* A29k readonly text/data section type */
+  if ((styp_flags & STYP_LIT) == STYP_LIT)
+  {
+    sec_flags = (SEC_LOAD | SEC_ALLOC | SEC_READONLY);
+  }
+#endif				/* STYP_LIT */
+#ifdef STYP_OTHER_LOAD		/* Other loaded sections */
+  if (styp_flags & STYP_OTHER_LOAD)
+  {
+    sec_flags = (SEC_LOAD | SEC_ALLOC);
+  }
+#endif				/* STYP_SDATA */
 
-    return(sec_flags);
+  return(sec_flags);
 }
 
 #define	get_index(symbol)	((int) (symbol)->udata)
@@ -884,27 +899,22 @@ DEFUN(coff_swap_scnhdr_out,(abfd, in, out),
 */
 
 static          boolean
-DEFUN(coff_new_section_hook,(abfd_ignore, section),
-      bfd            *abfd_ignore AND
+DEFUN(coff_new_section_hook,(abfd, section),
+      bfd            *abfd AND
       asection       *section)
 {
-  section->alignment_power = abfd_ignore->xvec->align_power_min;
+  section->alignment_power = abfd->xvec->align_power_min;
+  /* Allocate aux records for section symbols, to store size and
+     related info.
+
+     @@ Shouldn't use constant multiplier here!  */
+  coffsymbol (section->symbol)->native =
+    (combined_entry_type *) bfd_zalloc (abfd,
+					sizeof (combined_entry_type) * 10);
   return true;
 }
 
-static asection bfd_debug_section = 
-{ "*DEBUG*" };
-
-
-
-static void
-DEFUN(make_abs_section,(abfd),
-      bfd *abfd)
-{
-    
-
-  
-}
+static asection bfd_debug_section = { "*DEBUG*" };
 
 /* Take a section header read from a coff file (in HOST byte order),
    and make a BFD "section" out of it.  */
@@ -1336,6 +1346,30 @@ DEFUN(coff_renumber_symbols,(bfd_ptr),
   unsigned int native_index = 0;
   struct internal_syment *last_file = (struct internal_syment *)NULL;
   unsigned int symbol_index;
+
+  /* COFF demands that undefined symbols come after all other symbols.
+     Since we don't need to impose this extra knowledge on all our client
+     programs, deal with that here.  Sort the symbol table; just move the
+     undefined symbols to the end, leaving the rest alone.  */
+  /* @@ Do we have some condition we could test for, so we don't always
+     have to do this?  I don't think relocatability is quite right, but
+     I'm not certain.  [raeburn:19920508.1711EST]  */
+  {
+    asymbol **newsyms;
+    int i;
+
+    newsyms = (asymbol **) bfd_alloc_by_size_t (bfd_ptr,
+						sizeof (asymbol *) * symbol_count);
+    bfd_ptr->outsymbols = newsyms;
+    for (i = 0; i < symbol_count; i++)
+      if (symbol_ptr_ptr[i]->section != &bfd_und_section)
+	*newsyms++ = symbol_ptr_ptr[i];
+    for (i = 0; i < symbol_count; i++)
+      if (symbol_ptr_ptr[i]->section == &bfd_und_section)
+	*newsyms++ = symbol_ptr_ptr[i];
+    symbol_ptr_ptr = bfd_ptr->outsymbols;
+  }
+
   for (symbol_index = 0; symbol_index < symbol_count; symbol_index++)
       {
 	coff_symbol_type *coff_symbol_ptr = coff_symbol_from(bfd_ptr, symbol_ptr_ptr[symbol_index]);
@@ -1365,6 +1399,7 @@ DEFUN(coff_renumber_symbols,(bfd_ptr),
 	  native_index++;
 	}
       }
+  obj_conv_table_size (bfd_ptr) = native_index;
 }
 
 
@@ -1475,6 +1510,12 @@ unsigned int written)
   int             class =  native->u.syment.n_sclass;
   SYMENT buf;
   unsigned int j;
+
+  /* @@ bfd_debug_section isn't accessible outside this file, but we know
+     that C_FILE symbols belong there.  So move them.  */
+  if (native->u.syment.n_sclass == C_FILE)
+    symbol->section = &bfd_debug_section;
+
   if (symbol->section == &bfd_abs_section) 
   {
     native->u.syment.n_scnum = N_ABS;
@@ -1588,7 +1629,7 @@ coff_symbol_type *symbol AND
 unsigned int written)
 {
   /*
-    Does this symbol have an ascociated line number - if so then
+    Does this symbol have an associated line number - if so then
     make it remember this symbol index. Also tag the auxent of
     this symbol to point to the right place in the lineno table
     */
@@ -1748,9 +1789,20 @@ DEFUN(coff_write_relocs,(abfd),
       struct internal_reloc    n;
       arelent        *q = p[i];
       memset((PTR)&n, 0, sizeof(n));
+
+      /* @@FIXME COFF relocs don't support addends.  Code should probably be
+	 in the target-independent code, using a target flag to decide whether
+	 to fold the addend into the section contents.  */
+      if (q->addend != 0)
+	abort ();
+
       n.r_vaddr = q->address + s->vma;
       if (q->sym_ptr_ptr) {
 	n.r_symndx = get_index((*(q->sym_ptr_ptr)));
+	/* Take notice if the symbol reloc points to a symbol we don't have
+	   in our symbol table.  What should we do for this??  */
+	if (n.r_symndx > obj_conv_table_size (abfd))
+	  abort ();
       }
 #ifdef SELECT_RELOC
       /* Work out reloc type from what is required */
@@ -1823,6 +1875,7 @@ bfd            *abfd;
     bfd_error = no_memory;
     return (NULL);
   }				/* on error */
+  new->symbol.section = 0;
   new->native = 0;
   new->lineno = (alent *) NULL;
   new->done_lineno = false;
@@ -1832,6 +1885,26 @@ bfd            *abfd;
 
 #ifndef NO_COFF_SYMBOLS
 
+static asymbol *
+DEFUN (coff_make_debug_symbol, (abfd, ptr, sz),
+       bfd *abfd AND
+       PTR ptr AND
+       unsigned long sz)
+{
+  coff_symbol_type *new = (coff_symbol_type *) bfd_alloc(abfd, sizeof(coff_symbol_type));
+  if (new == NULL) {
+    bfd_error = no_memory;
+    return (NULL);
+  }				/* on error */
+  /* @@ This shouldn't be using a constant multiplier.  */
+  new->native = (combined_entry_type *) bfd_zalloc (abfd, sizeof (combined_entry_type) * 10);
+  new->symbol.section = &bfd_debug_section;
+  new->lineno = (alent *) NULL;
+  new->done_lineno = false;
+  new->symbol.the_bfd = abfd;
+  return &new->symbol;
+}
+
 static void
 DEFUN(coff_print_symbol,(ignore_abfd, filep, symbol, how),
       bfd            *ignore_abfd AND
@@ -2128,8 +2201,115 @@ DEFUN(coff_compute_section_file_positions,(abfd),
   obj_relocbase(abfd) = sofar;
 }
 
+#ifndef NO_COFF_SYMBOLS
+static asymbol *
+coff_section_symbol (abfd, name)
+     bfd *abfd;
+     char *name;
+{
+  asection *sec = bfd_get_section_by_name (abfd, name);
+  asymbol *sym;
+  combined_entry_type *csym;
+
+  if (!sec)
+    {
+      /* create empty symbol */
+      abort ();
+    }
+  sym = sec->symbol;
+  if (coff_symbol_from (abfd, sym))
+    csym = coff_symbol_from (abfd, sym)->native;
+  else
+    csym = 0;
+  /* Make sure back-end COFF stuff is there.  */
+  if (csym == 0)
+    {
+      struct foo {
+	coff_symbol_type sym;
+	/* @@FIXME This shouldn't use a fixed size!!  */
+	combined_entry_type e[10];
+      };
+      struct foo *f;
+      f = (struct foo *) bfd_alloc_by_size_t (abfd, sizeof (*f));
+      bzero ((char *) f, sizeof (*f));
+      coff_symbol_from (abfd, sym)->native = csym = f->e;
+    }
+  csym[0].u.syment.n_sclass = C_STAT;
+  csym[0].u.syment.n_numaux = 1;
+/*  SF_SET_STATICS (sym);	@@ ??? */
+  if (sec)
+    {
+      csym[1].u.auxent.x_scn.x_scnlen = sec->_raw_size;
+      csym[1].u.auxent.x_scn.x_nreloc = sec->reloc_count;
+      csym[1].u.auxent.x_scn.x_nlinno = sec->lineno_count;
+    }
+  else
+    {
+      csym[1].u.auxent.x_scn.x_scnlen = 0;
+      csym[1].u.auxent.x_scn.x_nreloc = 0;
+      csym[1].u.auxent.x_scn.x_nlinno = 0;
+    }
+  return sym;
+}
 
+/* If .file, .text, .data, .bss symbols are missing, add them.  */
+/* @@ Should we only be adding missing symbols, or overriding the aux
+   values for existing section symbols?  */
+static void
+coff_add_missing_symbols (abfd)
+     bfd *abfd;
+{
+  unsigned int nsyms = bfd_get_symcount (abfd);
+  asymbol **sympp = abfd->outsymbols;
+  asymbol **sympp2;
+  unsigned int i;
+  int need_text = 1, need_data = 1, need_bss = 1, need_file = 1;
+  coff_data_type *cdata = coff_data (abfd);
+
+  for (i = 0; i < nsyms; i++)
+    {
+      coff_symbol_type *csym = coff_symbol_from (abfd, sympp[i]);
+      CONST char *name;
 
+      if (csym->native->u.syment.n_sclass == C_FILE)
+	{
+	  need_file = 0;
+	  continue;
+	}
+      name = csym->symbol.name;
+      if (!name)
+	continue;
+      if (!strcmp (name, _TEXT))
+	need_text = 0;
+      else if (!strcmp (name, _DATA))
+	need_data = 0;
+      else if (!strcmp (name, _BSS))
+	need_bss = 0;
+    }
+  /* Now i == bfd_get_symcount (abfd).  */
+  /* @@ For now, don't deal with .file symbol.  */
+  need_file = 0;
+
+  if (!need_text && !need_data && !need_bss && !need_file)
+    return;
+  nsyms += need_text + need_data + need_bss + need_file;
+  sympp2 = (asymbol**) bfd_alloc_by_size_t (abfd, nsyms * sizeof (asymbol *));
+  memcpy (sympp2, sympp, i * sizeof (asymbol *));
+  if (need_file)
+    {
+      /* @@ Generate fake .file symbol, in sympp2[i], and increment i.  */
+      abort ();
+    }
+  if (need_text)
+    sympp2[i++] = coff_section_symbol (abfd, _TEXT);
+  if (need_data)
+    sympp2[i++] = coff_section_symbol (abfd, _DATA);
+  if (need_bss)
+    sympp2[i++] = coff_section_symbol (abfd, _BSS);
+  assert (i == nsyms);
+  bfd_set_symtab (abfd, sympp2, nsyms);
+}
+#endif /* NO_COFF_SYMBOLS */
 
 /* SUPPRESS 558 */
 /* SUPPRESS 529 */
@@ -2159,12 +2339,15 @@ DEFUN(coff_write_object_contents,(abfd),
 
   bfd_error = system_call_error;
   /* Number the output sections, starting from one on the first section
-     with a name which doesn't start with a * */
+     with a name which doesn't start with a *.
+     @@ The code doesn't make this check.  Is it supposed to be done,
+     or isn't it??  */
   count = 1;
   for (current = abfd->sections; current != (asection *)NULL; 
        current = current->next) 
   {
       current->target_index = count;
+      count++;
   }
   
     
@@ -2424,6 +2607,7 @@ DEFUN(coff_write_object_contents,(abfd),
 
 #ifndef NO_COFF_SYMBOLS
   if (bfd_get_symcount(abfd) != 0) {
+      coff_add_missing_symbols (abfd);
       coff_renumber_symbols(abfd);
       coff_mangle_symbols(abfd);
       coff_write_symbols(abfd);
@@ -3149,6 +3333,7 @@ DEFUN(coff_slurp_symbol_table,(abfd),
   obj_symbols(abfd) = cached_area;
   obj_raw_syments(abfd) = native_symbols;
 
+  obj_conv_table_size (abfd) = bfd_get_symcount (abfd);
   bfd_get_symcount(abfd) = number_of_symbols;
   obj_convert(abfd) = table_ptr;
   /* Slurp the line tables for each section too */
@@ -3324,16 +3509,18 @@ DEFUN(coff_slurp_reloc_table,(abfd, asect, symbols),
       cache_ptr->address = dst.r_vaddr;
 
       if (dst.r_symndx != -1) 
-      {
+	{
+	  /* @@ Should never be greater than count of symbols!  */
+	  if (dst.r_symndx >= obj_conv_table_size (abfd))
+	    abort ();
 	  cache_ptr->sym_ptr_ptr = symbols + obj_convert(abfd)[dst.r_symndx];
 	  ptr = *(cache_ptr->sym_ptr_ptr);
-      }
+	}
       else 
-      {
-	cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
-        ptr = 0;
-	      
-      }
+	{
+	  cache_ptr->sym_ptr_ptr= bfd_abs_section.symbol_ptr_ptr;
+	  ptr = 0;
+	}
 
       /*
 	The symbols definitions that we have read in have been
@@ -3723,15 +3910,15 @@ DEFUN(bfd_coff_relax_section,(abfd, i, symbols),
 }
 
 static bfd_byte *
-DEFUN(bfd_coff_get_relocated_section_contents,(in_abfd, seclet),
+DEFUN(bfd_coff_get_relocated_section_contents,(in_abfd, seclet, data),
       bfd *in_abfd AND
-      bfd_seclet_type *seclet)
+      bfd_seclet_type *seclet AND
+      bfd_byte *data)
 
 {
   /* Get enough memory to hold the stuff */
   bfd *input_bfd = seclet->u.indirect.section->owner;
   asection *input_section = seclet->u.indirect.section;
-  bfd_byte  *data = (bfd_byte *)malloc(input_section->_raw_size);
   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
 						       input_section);
   arelent **reloc_vector = (arelent **)bfd_xmalloc(reloc_size);
diff --git a/bfd/cpu-a29k.c b/bfd/cpu-a29k.c
index 3e1438c..50759ee 100644
--- a/bfd/cpu-a29k.c
+++ b/bfd/cpu-a29k.c
@@ -16,7 +16,6 @@ static bfd_arch_info_type arch_info_struct =
     bfd_default_compatible, 
     bfd_default_scan ,
     0,
-    bfd_default_reloc_type_lookup,
   };
 
 void DEFUN_VOID(bfd_a29k_arch)
diff --git a/bfd/ctor.c b/bfd/ctor.c
index d81df61..0550aa8 100644
--- a/bfd/ctor.c
+++ b/bfd/ctor.c
@@ -140,9 +140,7 @@ void DEFUN(bfd_constructor_entry,(abfd, symbol_ptr_ptr, type),
        rel_section->constructor_chain = reloc;
        reloc->relent.address = rel_section->_cooked_size;
        /* ask the cpu which howto to use */
-       reloc->relent.howto =
-	bfd_reloc_type_lookup(abfd->arch_info,
-			      BFD_RELOC_CTOR);
+       reloc->relent.howto = bfd_reloc_type_lookup(abfd, BFD_RELOC_CTOR);
        rel_section->_cooked_size += sizeof(int *);
        rel_section->reloc_count++;
    }
diff --git a/bfd/reloc.c b/bfd/reloc.c
index 1c715a5..93b2af7 100644
--- a/bfd/reloc.c
+++ b/bfd/reloc.c
@@ -295,7 +295,8 @@ CODE_FRAGMENT
 .					     arelent *reloc_entry,
 .                                            struct symbol_cache_entry *symbol,
 .                                            PTR data,
-.                                            asection *input_section));
+.                                            asection *input_section, 
+.                                            bfd *output_bfd     ));
 .
 .       {* The textual name of the relocation type. *}
 .  char *name;
@@ -450,13 +451,14 @@ DEFUN(bfd_perform_relocation,(abfd,
     flag = bfd_reloc_undefined;
   }
 
-  if (howto->special_function){
+  if (howto->special_function) {
     bfd_reloc_status_type cont;
     cont = howto->special_function(abfd,
 				   reloc_entry,
 				   symbol,
 				   data,
-				   input_section);
+				   input_section,
+				   output_bfd);
     if (cont != bfd_reloc_continue) return cont;
   }
 
@@ -676,7 +678,50 @@ CODE_FRAGMENT
 .          moment probably a 32 bit wide abs address, but the cpu can
 .          choose. *}
 .
-.  BFD_RELOC_CTOR
+.  BFD_RELOC_CTOR,
+.
+.       {* 32 bits wide, simple reloc *}
+.  BFD_RELOC_32,
+.	{* 32 bits, PC-relative *}
+.  BFD_RELOC_32_PCREL,
+.
+.	{* High 22 bits of 32-bit value; simple reloc.  *}
+.  BFD_RELOC_HI22,
+.	{* Low 10 bits.  *}
+.  BFD_RELOC_LO10,
+.
+.	{* Reloc types used for i960/b.out.  *}
+.  BFD_RELOC_24_PCREL,
+.  BFD_RELOC_I960_CALLJ,
+.
+.  BFD_RELOC_16_PCREL,
+.	{* 32-bit pc-relative, shifted right 2 bits (i.e., 30-bit
+.	   word displacement, e.g. for SPARC) *}
+.  BFD_RELOC_32_PCREL_S2,
+.
+.  {* now for the sparc/elf codes *}
+.  BFD_RELOC_NONE,		{* actually used *}
+.  BFD_RELOC_SPARC_WDISP22,
+.  BFD_RELOC_SPARC22,
+.  BFD_RELOC_SPARC13,
+.  BFD_RELOC_SPARC_BASE13,
+.  BFD_RELOC_SPARC_GOT10,
+.  BFD_RELOC_SPARC_GOT13,
+.  BFD_RELOC_SPARC_GOT22,
+.  BFD_RELOC_SPARC_PC10,
+.  BFD_RELOC_SPARC_PC22,
+.  BFD_RELOC_SPARC_WPLT30,
+.  BFD_RELOC_SPARC_COPY,
+.  BFD_RELOC_SPARC_GLOB_DAT,
+.  BFD_RELOC_SPARC_JMP_SLOT,
+.  BFD_RELOC_SPARC_RELATIVE,
+.  BFD_RELOC_SPARC_UA32,
+.
+.  {* this one is a.out specific? *}
+.  BFD_RELOC_SPARC_BASE22,
+.
+.  {* this must be the highest numeric value *}
+.  BFD_RELOC_UNUSED
 . } bfd_reloc_code_real_type;
 */
 
@@ -688,8 +733,7 @@ SECTION
 
 SYNOPSIS
 	CONST struct reloc_howto_struct *
-	bfd_reloc_type_lookup
-	(CONST bfd_arch_info_type *arch, bfd_reloc_code_type code);
+	bfd_reloc_type_lookup (bfd *abfd, bfd_reloc_code_type code);
 
 DESCRIPTION
 	This routine returns a pointer to a howto struct which when
@@ -701,10 +745,10 @@ DESCRIPTION
 
 CONST struct reloc_howto_struct *
 DEFUN(bfd_reloc_type_lookup,(arch, code),
-	CONST bfd_arch_info_type *arch  AND
-	bfd_reloc_code_type code)
+      bfd *abfd AND
+      bfd_reloc_code_type code)
 {
-  return arch->reloc_type_lookup(arch, code);
+  return BFD_SEND (abfd, reloc_type_lookup, (abfd, code));
 }
 
 static reloc_howto_type bfd_howto_32 =
@@ -764,7 +808,7 @@ SYNOPSIS
 
 DESCRIPTION
 	Provides default handling for relaxing for back ends which
-	don't do relaxing - ie does nothing 
+	don't do relaxing -- i.e., does nothing.
 */
 
 boolean
@@ -786,7 +830,8 @@ INTERNAL_FUNCTION
 SYNOPSIS
 	bfd_byte *
 	   bfd_generic_get_relocated_section_contents(bfd *abfd,
-	     struct bfd_seclet_struct  *seclet)
+	     struct bfd_seclet_struct  *seclet,
+	     bfd_byte *data)
 
 DESCRIPTION
 	Provides default handling of relocation effort for back ends
@@ -795,9 +840,10 @@ DESCRIPTION
 */
 
 bfd_byte *
-DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet),
+DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet, data),
       bfd *abfd AND
-      struct bfd_seclet_struct *seclet)
+      struct bfd_seclet_struct *seclet AND
+      bfd_byte *data)
 {
   extern bfd_error_vector_type bfd_error_vector;
 
@@ -805,11 +851,11 @@ DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet),
   bfd *input_bfd = seclet->u.indirect.section->owner;
   asection *input_section = seclet->u.indirect.section;
 
-  bfd_byte *data = (bfd_byte *) bfd_xmalloc(input_section->_raw_size);
+
 
   bfd_size_type reloc_size = bfd_get_reloc_upper_bound(input_bfd,
 						       input_section);
-  arelent **reloc_vector = (arelent **) bfd_xmalloc(reloc_size);
+  arelent **reloc_vector = (arelent **) alloca(reloc_size);
   
   /* read in the section */
   bfd_get_section_contents(input_bfd,
@@ -862,7 +908,7 @@ DEFUN(bfd_generic_get_relocated_section_contents,(abfd, seclet),
     }    
   }
 
-  free((char *)reloc_vector);
+
   return data;