X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=bfd%2Fcoff-i960.c;h=b3bf4e1cab490f92e03a7f1abf40c26edd94e049;hb=5a50eec623f9d8b619da02d5a38f604b0342b7fa;hp=f9b82511954f03614f800811ee6f926db1701756;hpb=ffeef0bbcb6a96f74bff342bb4292ad684fc54ab;p=deliverable%2Fbinutils-gdb.git

diff --git a/bfd/coff-i960.c b/bfd/coff-i960.c
index f9b8251195..b3bf4e1cab 100644
--- a/bfd/coff-i960.c
+++ b/bfd/coff-i960.c
@@ -1,5 +1,5 @@
 /* BFD back-end for Intel 960 COFF files.
-   Copyright (C) 1990, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
+   Copyright (C) 1990, 91, 92, 93, 94, 1995 Free Software Foundation, Inc.
    Written by Cygnus Support.
 
 This file is part of BFD, the Binary File Descriptor library.
@@ -16,7 +16,7 @@ GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
 #define I960 1
 #define BADMAG(x) I960BADMAG(x)
@@ -31,7 +31,25 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 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)
+
+/* The i960 does not support an MMU, so COFF_PAGE_SIZE can be
+   arbitrarily small.  */
+#define COFF_PAGE_SIZE 1
+
 #define COFF_LONG_FILENAMES
 
 #define CALLS	 0x66003800	/* Template for 'calls' instruction	*/
@@ -40,12 +58,12 @@ static bfd_reloc_status_type optcall_callback
 
 static bfd_reloc_status_type 
 optcall_callback (abfd, reloc_entry, symbol_in, data,
-		  ignore_input_section, ignore_bfd, error_message)
+		  input_section, ignore_bfd, error_message)
      bfd *abfd;
      arelent *reloc_entry;
      asymbol *symbol_in;
      PTR data;
-     asection *ignore_input_section;
+     asection *input_section;
      bfd *ignore_bfd;
      char **error_message;
 {
@@ -55,6 +73,13 @@ optcall_callback (abfd, reloc_entry, symbol_in, data,
   bfd_reloc_status_type result;
   coff_symbol_type *cs = coffsymbol(symbol_in);
 
+  /* Don't do anything with symbols which aren't tied up yet,
+     except move the reloc. */
+  if (bfd_is_und_section (cs->symbol.section)) {
+    reloc_entry->address += input_section->output_offset;
+    return bfd_reloc_ok;
+  }
+    
   /* So the target symbol has to be of coff type, and the symbol 
      has to have the correct native information within it */
   if ((bfd_asymbol_flavour(&cs->symbol) != bfd_target_coff_flavour)
@@ -105,18 +130,110 @@ optcall_callback (abfd, reloc_entry, symbol_in, data,
   return result;
 }
 
+/* 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 here
+   by converting all relocs against defined symbols into relocs
+   against the section symbol, when generating a relocateable output
+   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,
+		    output_bfd, error_message)
+     bfd *abfd;
+     arelent *reloc_entry;
+     asymbol *symbol;
+     PTR data;
+     asection *input_section;
+     bfd *output_bfd;
+     char **error_message;
+{
+  asection *osec;
+
+  if (output_bfd == NULL)
+    {
+      /* Not generating relocateable output file.  */
+      return bfd_reloc_continue;
+    }
+
+  if (bfd_is_und_section (bfd_get_section (symbol)))
+    {
+      /* Symbol is not defined, so no need to worry about it.  */
+      return bfd_reloc_continue;
+    }
+
+  if (bfd_is_com_section (bfd_get_section (symbol)))
+    {
+      /* I don't really know what the right action is for a common
+         symbol.  */
+      return bfd_reloc_continue;
+    }
+
+  /* Convert the reloc to use the section symbol.  FIXME: This method
+     is ridiculous.  */
+  osec = bfd_get_section (symbol)->output_section;
+  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;
+      asymbol **syms, **sym_end;
+
+      sec_name = bfd_get_section_name (output_bfd, osec);
+      syms = bfd_get_outsymbols (output_bfd);
+      sym_end = syms + bfd_get_symcount (output_bfd);
+      for (; syms < sym_end; syms++)
+	{
+	  if (bfd_asymbol_name (*syms) != NULL
+	      && (*syms)->value == 0
+	      && 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)
+	    return bfd_reloc_overflow;
+	}
+      coff_section_data (output_bfd, osec)->tdata = (PTR) syms;
+    }
+
+  /* Let bfd_perform_relocation do its thing, which will include
+     stuffing the symbol addend into the object file.  */
+  return bfd_reloc_continue;
+}
+
 static reloc_howto_type howto_rellong =
   HOWTO ((unsigned int) R_RELLONG, 0, 2, 32,false, 0,
-	 complain_overflow_bitfield, 0,"rellong", true, 0xffffffff,
-	 0xffffffff, 0);
+	 complain_overflow_bitfield, coff_i960_relocate,"rellong", true,
+	 0xffffffff, 0xffffffff, 0);
 static reloc_howto_type howto_iprmed =
-  HOWTO (R_IPRMED, 0, 2, 24,true,0, complain_overflow_signed,0,
-	 "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
+  HOWTO (R_IPRMED, 0, 2, 24,true,0, complain_overflow_signed,
+	 coff_i960_relocate, "iprmed ", true, 0x00ffffff, 0x00ffffff, 0);
 static reloc_howto_type howto_optcall =
   HOWTO (R_OPTCALL, 0,2,24,true,0, complain_overflow_signed,
 	 optcall_callback, "optcall", true, 0x00ffffff, 0x00ffffff, 0);
 
-static const reloc_howto_type *
+static reloc_howto_type *
 coff_i960_reloc_type_lookup (abfd, code)
      bfd *abfd;
      bfd_reloc_code_real_type code;
@@ -146,14 +263,310 @@ coff_i960_reloc_type_lookup (abfd, code)
      case 27: howto_ptr = &howto_optcall; break;	\
      default: howto_ptr = 0; break;			\
      }							\
-   cache_ptr->howto = howto_ptr;			\
+   (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 *) bfd_malloc (symesz);
+  if (esym == NULL)
+    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;
+
+  *adjustedp = false;
+
+  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 */
@@ -170,7 +583,6 @@ const bfd_target icoff_little_vec =
   '/',				/* ar_pad_char */
   15,				/* ar_max_namelen */
 
-  3,				/* minimum alignment power */
   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */
@@ -215,7 +627,6 @@ const bfd_target icoff_big_vec =
   '/',				/* ar_pad_char */
   15,				/* ar_max_namelen */
 
-  3,				/* minimum alignment power */
 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
      bfd_getl32, bfd_getl_signed_32, bfd_putl32,
      bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */