8 files changed, 405 insertions, 21 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index bb67edb..9de6db3 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,30 @@
+Thu Sep 14 14:53:58 1995  Ian Lance Taylor  <ian@cygnus.com>
+
+	Convert i960 COFF to use COFF backend linker.
+	* coff-i960.c (coff_i960_relocate): Use a coff_section_data
+	structure to store the symbol being used.
+	(coff_i960_start_final_link): New static function.
+	(coff_i960_relocate_section): New static function.
+	(coff_i960_adjust_symndx): New static function.
+	(coff_start_final_link): Define.
+	(coff_relocate_section): Define.
+	(coff_adjust_symndx): Define.
+	* coffcode.h (bfd_coff_backend_data): Add new callback function
+	_bfd_coff_start_final_link.
+	(bfd_coff_start_final_link): Define.
+	(coff_start_final_link): Define if not defined.
+	(bfd_coff_std_swap_table): Add coff_start_final_link.
+	* cofflink.c (_bfd_coff_internal_syment_name): Make globally
+	visible.
+	(_bfd_coff_final_link): Call bfd_coff_start_final_link if the
+	function callback is not NULL.
+	* libcoff-in.h (struct coff_section_tdata): Add tdata field.
+	(_bfd_coff_internal_syment_name): Declare.
+	* libcoff.h: Rebuild.
+	* configure.in (icoff_big_vec): Add cofflink.o.
+	(icoff_little_vec): Likewise.
+	* configure: Rebuild.
+
 Wed Sep 13 17:38:23 1995  Fred Fish  <fnf@rtl.cygnus.com>
 
 	* Makefile.in (clean-info): Remove extraneous tab from line
diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c
index fcc8754..ece0697 100644
--- a/bfd/coff-i960.c
+++ b/bfd/coff-i960.c
@@ -33,6 +33,16 @@ static bfd_reloc_status_type optcall_callback
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
 static bfd_reloc_status_type coff_i960_relocate
   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
+static reloc_howto_type *coff_i960_reloc_type_lookup
+  PARAMS ((bfd *, bfd_reloc_code_real_type));
+static boolean coff_i960_start_final_link
+  PARAMS ((bfd *, struct bfd_link_info *));
+static boolean coff_i960_relocate_section
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
+	   struct internal_reloc *, struct internal_syment *, asection **));
+static boolean coff_i960_adjust_symndx
+  PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *,
+	   struct internal_reloc *, boolean *));
 
 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (3)
 
@@ -126,7 +136,14 @@ optcall_callback (abfd, reloc_entry, symbol_in, data,
    than adding their values into the object file.  We handle this here
    by converting all relocs against defined symbols into relocs
    against the section symbol, when generating a relocateable output
-   file.  */
+   file.
+
+   Note that this function is only called if we are not using the COFF
+   specific backend linker.  It only does something when doing a
+   relocateable link, which will almost certainly fail when not
+   generating COFF i960 output, so this function is actually no longer
+   useful.  It was used before this target was converted to use the
+   COFF specific backend linker.  */
 
 static bfd_reloc_status_type 
 coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
@@ -161,11 +178,12 @@ coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
     }
 
   /* Convert the reloc to use the section symbol.  FIXME: This method
-     is ridiculous.  Fortunately, we don't use the used_by_bfd field
-     in COFF.  */
+     is ridiculous.  */
   osec = bfd_get_section (symbol)->output_section;
-  if (osec->used_by_bfd != NULL)
-    reloc_entry->sym_ptr_ptr = (asymbol **) osec->used_by_bfd;
+  if (coff_section_data (output_bfd, osec) != NULL
+      && coff_section_data (output_bfd, osec)->tdata != NULL)
+    reloc_entry->sym_ptr_ptr =
+      (asymbol **) coff_section_data (output_bfd, osec)->tdata;
   else
     {
       const char *sec_name;
@@ -178,16 +196,28 @@ coff_i960_relocate (abfd, reloc_entry, symbol, data, input_section,
 	{
 	  if (bfd_asymbol_name (*syms) != NULL
 	      && (*syms)->value == 0
-	      && strcmp (!(*syms)->section->output_section->name, sec_name))
-	    {
-	      osec->used_by_bfd = (PTR) syms;
-	      reloc_entry->sym_ptr_ptr = syms;
-	      break;
-	    }
+	      && strcmp ((*syms)->section->output_section->name,
+			 sec_name) == 0)
+	    break;
 	}
 
       if (syms >= sym_end)
 	abort ();
+
+      reloc_entry->sym_ptr_ptr = syms;
+
+      if (coff_section_data (output_bfd, osec) == NULL)
+	{
+	  osec->used_by_bfd =
+	    ((PTR) bfd_zalloc (abfd,
+			       sizeof (struct coff_section_tdata)));
+	  if (osec->used_by_bfd == NULL)
+	    {
+	      bfd_set_error (bfd_error_no_memory);
+	      return bfd_reloc_overflow;
+	    }
+	}
+      coff_section_data (output_bfd, osec)->tdata = (PTR) syms;
     }
 
   /* Let bfd_perform_relocation do its thing, which will include
@@ -239,11 +269,308 @@ coff_i960_reloc_type_lookup (abfd, code)
    (cache_ptr)->howto = howto_ptr;			\
  }
 
-#include "coffcode.h"
+/* i960 COFF is used by VxWorks 5.1.  However, VxWorks 5.1 does not
+   appear to correctly handle a reloc against a symbol defined in the
+   same object file.  It appears to simply discard such relocs, rather
+   than adding their values into the object file.  We handle this by
+   converting all relocs against global symbols into relocs against
+   internal symbols at the start of the section.  This routine is
+   called at the start of the linking process, and it creates the
+   necessary symbols.  */
+
+static boolean
+coff_i960_start_final_link (abfd, info)
+     bfd *abfd;
+     struct bfd_link_info *info;
+{
+  bfd_size_type symesz = bfd_coff_symesz (abfd);
+  asection *o;
+  bfd_byte *esym;
+
+  if (! info->relocateable)
+    return true;
+
+  esym = (bfd_byte *) malloc (symesz);
+  if (esym == NULL)
+    {
+      bfd_set_error (bfd_error_no_memory);
+      return false;
+    }
+
+  if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0)
+    return false;
+
+  for (o = abfd->sections; o != NULL; o = o->next)
+    {
+      struct internal_syment isym;
+
+      strncpy (isym._n._n_name, o->name, SYMNMLEN);
+      isym.n_value = 0;
+      isym.n_scnum = o->target_index;
+      isym.n_type = T_NULL;
+      isym.n_sclass = C_STAT;
+      isym.n_numaux = 0;
+
+      bfd_coff_swap_sym_out (abfd, (PTR) &isym, (PTR) esym);
+
+      if (bfd_write (esym, symesz, 1, abfd) != symesz)
+	{
+	  free (esym);
+	  return false;
+	}
+
+      obj_raw_syment_count (abfd) += 1;
+    }
+
+  free (esym);
+
+  return true;
+}
+
+/* The reloc processing routine for the optimized COFF linker.  */
+
+static boolean
+coff_i960_relocate_section (output_bfd, info, input_bfd, input_section,
+			    contents, relocs, syms, sections)
+     bfd *output_bfd;
+     struct bfd_link_info *info;
+     bfd *input_bfd;
+     asection *input_section;
+     bfd_byte *contents;
+     struct internal_reloc *relocs;
+     struct internal_syment *syms;
+     asection **sections;
+{
+  struct internal_reloc *rel;
+  struct internal_reloc *relend;
+
+  rel = relocs;
+  relend = rel + input_section->reloc_count;
+  for (; rel < relend; rel++)
+    {
+      long symndx;
+      struct coff_link_hash_entry *h;
+      struct internal_syment *sym;
+      bfd_vma addend;
+      bfd_vma val;
+      reloc_howto_type *howto;
+      bfd_reloc_status_type rstat = bfd_reloc_ok;
+      boolean done;
+
+      symndx = rel->r_symndx;
+
+      if (symndx == -1)
+	{
+	  h = NULL;
+	  sym = NULL;
+	}
+      else
+	{    
+	  h = obj_coff_sym_hashes (input_bfd)[symndx];
+	  sym = syms + symndx;
+	}
+
+      if (sym != NULL && sym->n_scnum != 0)
+	addend = - sym->n_value;
+      else
+	addend = 0;
+
+      switch (rel->r_type)
+	{
+	case 17: howto = &howto_rellong; break;
+	case 25: howto = &howto_iprmed; break;
+	case 27: howto = &howto_optcall; break;
+	default:
+	  bfd_set_error (bfd_error_bad_value);
+	  return false;
+	}
+
+      val = 0;
+
+      if (h == NULL)
+	{
+	  asection *sec;
+
+	  if (symndx == -1)
+	    {
+	      sec = bfd_abs_section_ptr;
+	      val = 0;
+	    }
+	  else
+	    {
+	      sec = sections[symndx];
+              val = (sec->output_section->vma
+		     + sec->output_offset
+		     + sym->n_value
+		     - sec->vma);
+	    }
+	}
+      else
+	{
+	  if (h->root.type == bfd_link_hash_defined
+	      || h->root.type == bfd_link_hash_defweak)
+	    {
+	      asection *sec;
+
+	      sec = h->root.u.def.section;
+	      val = (h->root.u.def.value
+		     + sec->output_section->vma
+		     + sec->output_offset);
+	    }
+	  else if (! info->relocateable)
+	    {
+	      if (! ((*info->callbacks->undefined_symbol)
+		     (info, h->root.root.string, input_bfd, input_section,
+		      rel->r_vaddr - input_section->vma)))
+		return false;
+	    }
+	}
+
+      done = false;
+
+      if (howto->type == R_OPTCALL && ! info->relocateable && symndx != -1)
+	{
+	  int class;
+
+	  if (h != NULL)
+	    class = h->class;
+	  else
+	    class = sym->n_sclass;
+
+	  switch (class)
+	    {
+	    case C_NULL:
+	      /* This symbol is apparently not from a COFF input file.
+                 We warn, and then assume that it is not a leaf
+                 function.  */
+	      if (! ((*info->callbacks->reloc_dangerous)
+		     (info,
+		      "uncertain calling convention for non-COFF symbol",
+		      input_bfd, input_section,
+		      rel->r_vaddr - input_section->vma)))
+		return false;
+	      break;
+	    case C_LEAFSTAT:
+	    case C_LEAFEXT:
+	      /* This is a call to a leaf procedure; use the bal
+                 instruction.  */
+	      {
+		long olf;
+		unsigned long word;
+
+		if (h != NULL)
+		  {
+		    BFD_ASSERT (h->numaux == 2);
+		    olf = h->aux[1].x_bal.x_balntry;
+		  }
+		else
+		  {
+		    bfd_byte *esyms;
+		    union internal_auxent aux;
+
+		    BFD_ASSERT (sym->n_numaux == 2);
+		    esyms = (bfd_byte *) obj_coff_external_syms (input_bfd);
+		    esyms += (symndx + 2) * bfd_coff_symesz (input_bfd);
+		    bfd_coff_swap_aux_in (input_bfd, (PTR) esyms, sym->n_type,
+					  sym->n_sclass, 1, sym->n_numaux,
+					  (PTR) &aux);
+		    olf = aux.x_bal.x_balntry;
+		  }
+
+		word = bfd_get_32 (input_bfd,
+				   (contents
+				    + (rel->r_vaddr - input_section->vma)));
+		word = ((word + olf - val) & BAL_MASK) | BAL;
+		bfd_put_32 (input_bfd,
+			    word,
+			    (contents
+			     + (rel->r_vaddr - input_section->vma)));
+		done = true;
+	      }
+	      break;
+	    case C_SCALL:
+	      BFD_ASSERT (0);
+	      break;
+	    }
+	}
+
+      if (! done)
+	rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
+					  contents,
+					  rel->r_vaddr - input_section->vma,
+					  val, addend);
+
+      switch (rstat)
+	{
+	default:
+	  abort ();
+	case bfd_reloc_ok:
+	  break;
+	case bfd_reloc_overflow:
+	  {
+	    const char *name;
+	    char buf[SYMNMLEN + 1];
+
+	    if (symndx == -1)
+	      name = "*ABS*";
+	    else if (h != NULL)
+	      name = h->root.root.string;
+	    else
+	      {
+		name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
+		if (name == NULL)
+		  return false;
+	      }
+
+	    if (! ((*info->callbacks->reloc_overflow)
+		   (info, name, howto->name, (bfd_vma) 0, input_bfd,
+		    input_section, rel->r_vaddr - input_section->vma)))
+	      return false;
+	  }
+	}
+    }
+
+  return true;
+}
+
+/* Adjust the symbol index of any reloc against a global symbol to
+   instead be a reloc against the internal symbol we created specially
+   for the section.  */
+
+/*ARGSUSED*/
+static boolean
+coff_i960_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
+     bfd *obfd;
+     struct bfd_link_info *info;
+     bfd *ibfd;
+     asection *sec;
+     struct internal_reloc *irel;
+     boolean *adjustedp;
+{
+  struct coff_link_hash_entry *h;
+
+  h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
+  if (h == NULL
+      || (h->root.type != bfd_link_hash_defined
+	  && h->root.type != bfd_link_hash_defweak))
+    return true;
+
+  irel->r_symndx = h->root.u.def.section->output_section->target_index - 1;
+  *adjustedp = true;
+
+  return true;
+}
+
+#define coff_start_final_link coff_i960_start_final_link
+
+#define coff_relocate_section coff_i960_relocate_section
+
+#define coff_adjust_symndx coff_i960_adjust_symndx
 
-#undef coff_bfd_reloc_type_lookup
 #define coff_bfd_reloc_type_lookup coff_i960_reloc_type_lookup
 
+#include "coffcode.h"
+
 const bfd_target icoff_little_vec =
 {
   "coff-Intel-little",		/* name */
diff --git a/bfd/coffcode.h b/bfd/coffcode.h
index dd772a8..e9a808c 100644
--- a/bfd/coffcode.h
+++ b/bfd/coffcode.h
@@ -681,6 +681,9 @@ dependent COFF routines:
 .       struct internal_syment *));
 . void (*_bfd_coff_compute_section_file_positions) PARAMS ((
 .       bfd *abfd));
+. boolean (*_bfd_coff_start_final_link) PARAMS ((
+.       bfd *output_bfd,
+.       struct bfd_link_info *info));
 . boolean (*_bfd_coff_relocate_section) PARAMS ((
 .       bfd *output_bfd,
 .       struct bfd_link_info *info,
@@ -798,6 +801,9 @@ dependent COFF routines:
 .        ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
 .         (abfd))
 .
+.#define bfd_coff_start_final_link(obfd, info)\
+.        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
+.         (obfd, info))
 .#define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
 .        ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
 .         (obfd, info, ibfd, o, con, rel, isyms, secs))
@@ -2814,6 +2820,10 @@ dummy_reloc16_extra_cases (abfd, link_info, link_order, reloc, data, src_ptr,
 #endif /* ! defined (coff_relocate_section) */
 #define coff_bfd_link_split_section  _bfd_generic_link_split_section
 
+#ifndef coff_start_final_link
+#define coff_start_final_link NULL
+#endif
+
 #ifndef coff_adjust_symndx
 #define coff_adjust_symndx NULL
 #endif
@@ -2837,7 +2847,8 @@ static CONST bfd_coff_backend_data bfd_coff_std_swap_table =
   coff_set_alignment_hook, coff_slurp_symbol_table, symname_in_debug_hook,
   coff_reloc16_extra_cases, coff_reloc16_estimate,
   coff_sym_is_global, coff_compute_section_file_positions,
-  coff_relocate_section, coff_rtype_to_howto, coff_adjust_symndx
+  coff_start_final_link, coff_relocate_section, coff_rtype_to_howto,
+  coff_adjust_symndx
 };
 
 #define	coff_close_and_cleanup _bfd_generic_close_and_cleanup
diff --git a/bfd/cofflink.c b/bfd/cofflink.c
index 10c0d68..81cefb0 100644
--- a/bfd/cofflink.c
+++ b/bfd/cofflink.c
@@ -87,8 +87,6 @@ static boolean coff_link_add_object_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
 static boolean coff_link_check_archive_element
   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
-static INLINE const char *_bfd_coff_internal_syment_name
-  PARAMS ((bfd *, const struct internal_syment *, char *));
 static boolean coff_link_check_ar_symbols
   PARAMS ((bfd *, struct bfd_link_info *, boolean *));
 static boolean coff_link_add_symbols PARAMS ((bfd *, struct bfd_link_info *));
@@ -238,7 +236,7 @@ coff_link_check_archive_element (abfd, info, pneeded)
 /* Get the name of a symbol.  The caller must pass in a buffer of size
    >= SYMNMLEN + 1.  */
 
-static INLINE const char *
+INLINE const char *
 _bfd_coff_internal_syment_name (abfd, sym, buf)
      bfd *abfd;
      const struct internal_syment *sym;
@@ -710,6 +708,13 @@ _bfd_coff_final_link (abfd, info)
      table in memory as we go along.  We process all the relocations
      for a single input file at once.  */
   obj_raw_syment_count (abfd) = 0;
+
+  if (coff_backend_info (abfd)->_bfd_coff_start_final_link)
+    {
+      if (! bfd_coff_start_final_link (abfd, info))
+	goto error_return;
+    }
+
   for (o = abfd->sections; o != NULL; o = o->next)
     {
       for (p = o->link_order_head; p != NULL; p = p->next)
diff --git a/bfd/configure b/bfd/configure
index 4459986..484bdc1 100755
--- a/bfd/configure
+++ b/bfd/configure
@@ -1345,8 +1345,8 @@ do
     i386mach3_vec)		tb="$tb i386mach3.o aout32.o stab-syms.o" ;;
     i386netbsd_vec)		tb="$tb i386netbsd.o aout32.o stab-syms.o" ;;
     i386os9k_vec)		tb="$tb i386os9k.o aout32.o stab-syms.o" ;;
-    icoff_big_vec)		tb="$tb coff-i960.o" ;;
-    icoff_little_vec)		tb="$tb coff-i960.o" ;;
+    icoff_big_vec)		tb="$tb coff-i960.o cofflink.o" ;;
+    icoff_little_vec)		tb="$tb coff-i960.o cofflink.o" ;;
     ieee_vec)			tb="$tb ieee.o" ;;
     m68kcoff_vec)		tb="$tb coff-m68k.o cofflink.o" ;;
     m68kcoffun_vec)		tb="$tb coff-u68k.o coff-m68k.o cofflink.o" ;;
diff --git a/bfd/configure.in b/bfd/configure.in
index 5808c96..66eb541 100644
--- a/bfd/configure.in
+++ b/bfd/configure.in
@@ -390,8 +390,8 @@ do
     i386mach3_vec)		tb="$tb i386mach3.o aout32.o stab-syms.o" ;;
     i386netbsd_vec)		tb="$tb i386netbsd.o aout32.o stab-syms.o" ;;
     i386os9k_vec)		tb="$tb i386os9k.o aout32.o stab-syms.o" ;;
-    icoff_big_vec)		tb="$tb coff-i960.o" ;;
-    icoff_little_vec)		tb="$tb coff-i960.o" ;;
+    icoff_big_vec)		tb="$tb coff-i960.o cofflink.o" ;;
+    icoff_little_vec)		tb="$tb coff-i960.o cofflink.o" ;;
     ieee_vec)			tb="$tb ieee.o" ;;
     m68kcoff_vec)		tb="$tb coff-m68k.o cofflink.o" ;;
     m68kcoffun_vec)		tb="$tb coff-u68k.o coff-m68k.o cofflink.o" ;;
diff --git a/bfd/libcoff-in.h b/bfd/libcoff-in.h
index 8ab9aa4..bb690bb 100644
--- a/bfd/libcoff-in.h
+++ b/bfd/libcoff-in.h
@@ -115,6 +115,8 @@ struct coff_section_tdata
   bfd_byte *contents;
   /* If this is true, the contents entry may not be freed.  */
   boolean keep_contents;
+  /* Available for individual backends.  */
+  PTR tdata;
 };
 
 /* An accessor macro for the coff_section_tdata structure.  */
@@ -222,6 +224,8 @@ extern void bfd_perform_slip PARAMS ((bfd *abfd, unsigned int slip,
 
 extern struct bfd_link_hash_table *_bfd_coff_link_hash_table_create
   PARAMS ((bfd *));
+extern const char *_bfd_coff_internal_syment_name
+  PARAMS ((bfd *, const struct internal_syment *, char *));
 extern boolean _bfd_coff_link_add_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
 extern boolean _bfd_coff_final_link
diff --git a/bfd/libcoff.h b/bfd/libcoff.h
index 7053852..8f2a45e 100644
--- a/bfd/libcoff.h
+++ b/bfd/libcoff.h
@@ -115,6 +115,8 @@ struct coff_section_tdata
   bfd_byte *contents;
   /* If this is true, the contents entry may not be freed.  */
   boolean keep_contents;
+  /* Available for individual backends.  */
+  PTR tdata;
 };
 
 /* An accessor macro for the coff_section_tdata structure.  */
@@ -222,6 +224,8 @@ extern void bfd_perform_slip PARAMS ((bfd *abfd, unsigned int slip,
 
 extern struct bfd_link_hash_table *_bfd_coff_link_hash_table_create
   PARAMS ((bfd *));
+extern const char *_bfd_coff_internal_syment_name
+  PARAMS ((bfd *, const struct internal_syment *, char *));
 extern boolean _bfd_coff_link_add_symbols
   PARAMS ((bfd *, struct bfd_link_info *));
 extern boolean _bfd_coff_final_link
@@ -413,6 +417,9 @@ typedef struct
        struct internal_syment *));
  void (*_bfd_coff_compute_section_file_positions) PARAMS ((
        bfd *abfd));
+ boolean (*_bfd_coff_start_final_link) PARAMS ((
+       bfd *output_bfd,
+       struct bfd_link_info *info));
  boolean (*_bfd_coff_relocate_section) PARAMS ((
        bfd *output_bfd,
        struct bfd_link_info *info,
@@ -530,6 +537,9 @@ typedef struct
         ((coff_backend_info (abfd)->_bfd_coff_compute_section_file_positions)\
          (abfd))
 
+#define bfd_coff_start_final_link(obfd, info)\
+        ((coff_backend_info (obfd)->_bfd_coff_start_final_link)\
+         (obfd, info))
 #define bfd_coff_relocate_section(obfd,info,ibfd,o,con,rel,isyms,secs)\
         ((coff_backend_info (ibfd)->_bfd_coff_relocate_section)\
          (obfd, info, ibfd, o, con, rel, isyms, secs))