* elf32-sparc.c (elf_sparc_howto_table): The PC10, PC22, and WPLT30 relocations

are PC-relative.

2 files changed, 665 insertions, 134 deletions

diff --git a/bfd/ChangeLog b/bfd/ChangeLog
index f0b743e..fc6da56 100644
--- a/bfd/ChangeLog
+++ b/bfd/ChangeLog
@@ -1,3 +1,13 @@
+Mon Oct 10 16:24:44 1994  Ken Raeburn  <raeburn@cujo.cygnus.com>
+
+	* elf32-sparc.c (elf_sparc_howto_table): The PC10, PC22, and
+	WPLT30 relocations are PC-relative.
+
+Thu Oct  6 12:57:26 1994  Richard Earnshaw (rwe@pegasus.esprit.ec.org)
+
+	* aoutx.h (adjust_o_magic): Correctly initialize vma if the vma of
+	the text section was user-defined.
+
 Wed Oct  5 14:42:12 1994  Ian Lance Taylor  <ian@sanguine.cygnus.com>
 
 	* archive.c (bfd_construct_extended_name_table): SVR4 uses slash
diff --git a/bfd/elf32-sparc.c b/bfd/elf32-sparc.c
index ec6d204..815784f 100644
--- a/bfd/elf32-sparc.c
+++ b/bfd/elf32-sparc.c
@@ -29,10 +29,11 @@ static void elf_info_to_howto
   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
 static boolean elf32_sparc_create_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
+static boolean elf32_sparc_check_relocs
+  PARAMS ((bfd *, struct bfd_link_info *, asection *,
+	   const Elf_Internal_Rela *));
 static boolean elf32_sparc_adjust_dynamic_symbol
   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
-static boolean elf32_sparc_allocate_dynamic_section
-  PARAMS ((bfd *, const char *));
 static boolean elf32_sparc_size_dynamic_sections
   PARAMS ((bfd *, struct bfd_link_info *));
 static boolean elf32_sparc_relocate_section
@@ -96,12 +97,12 @@ static reloc_howto_type elf_sparc_howto_table[] =
   HOWTO(R_SPARC_22,      0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_22",      false,0,0x003fffff,true),
   HOWTO(R_SPARC_13,      0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_13",      false,0,0x00001fff,true),
   HOWTO(R_SPARC_LO10,    0,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_LO10",    false,0,0x000003ff,true),
-  HOWTO(R_SPARC_GOT10,   0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_GOT10",   false,0,0x000003ff,true),
+  HOWTO(R_SPARC_GOT10,   0,2,10,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_GOT10",   false,0,0x000003ff,true),
   HOWTO(R_SPARC_GOT13,   0,2,13,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_GOT13",   false,0,0x00001fff,true),
-  HOWTO(R_SPARC_GOT22,  10,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_GOT22",   false,0,0x003fffff,true),
-  HOWTO(R_SPARC_PC10,    0,2,10,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_PC10",    false,0,0x000003ff,true),
-  HOWTO(R_SPARC_PC22,    0,2,22,false,0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_PC22",    false,0,0x003fffff,true),
-  HOWTO(R_SPARC_WPLT30,  0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_WPLT30",  false,0,0x00000000,true),
+  HOWTO(R_SPARC_GOT22,  10,2,22,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_GOT22",   false,0,0x003fffff,true),
+  HOWTO(R_SPARC_PC10,    0,2,10,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_PC10",    false,0,0x000003ff,true),
+  HOWTO(R_SPARC_PC22,    0,2,22,true, 0,complain_overflow_bitfield,bfd_elf_generic_reloc,"R_SPARC_PC22",    false,0,0x003fffff,true),
+  HOWTO(R_SPARC_WPLT30,  0,0,00,true, 0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_WPLT30",  false,0,0x00000000,true),
   HOWTO(R_SPARC_COPY,    0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_COPY",    false,0,0x00000000,true),
   HOWTO(R_SPARC_GLOB_DAT,0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_GLOB_DAT",false,0,0x00000000,true),
   HOWTO(R_SPARC_JMP_SLOT,0,0,00,false,0,complain_overflow_dont,    bfd_elf_generic_reloc,"R_SPARC_JMP_SLOT",false,0,0x00000000,true),
@@ -139,7 +140,7 @@ static CONST struct elf_reloc_map sparc_reloc_map[] =
   { BFD_RELOC_SPARC_JMP_SLOT, R_SPARC_JMP_SLOT },
   { BFD_RELOC_SPARC_RELATIVE, R_SPARC_RELATIVE },
   { BFD_RELOC_SPARC_WDISP22, R_SPARC_WDISP22 },
-  /*  { BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
+/*{ BFD_RELOC_SPARC_UA32, R_SPARC_UA32 }, not used?? */
 };
 
 static CONST struct reloc_howto_struct *
@@ -225,6 +226,11 @@ elf32_sparc_create_dynamic_sections (abfd, info)
 	  (struct bfd_link_hash_entry **) &h)))
     return false;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+  h->type = STT_OBJECT;
+
+  if (info->shared
+      && ! bfd_elf32_link_record_dynamic_symbol (info, h))
+    return false;
 
   /* The first four entries in .plt are reserved.  */
   s->_raw_size = 4 * PLT_ENTRY_SIZE;
@@ -255,6 +261,11 @@ elf32_sparc_create_dynamic_sections (abfd, info)
 	  (struct bfd_link_hash_entry **) &h)))
     return false;
   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
+  h->type = STT_OBJECT;
+
+  if (info->shared
+      && ! bfd_elf32_link_record_dynamic_symbol (info, h))
+    return false;
 
   /* The first global offset table entry is reserved.  */
   s->_raw_size += 4;
@@ -271,11 +282,261 @@ elf32_sparc_create_dynamic_sections (abfd, info)
     return false;
 
   /* The .rela.bss section holds copy relocs.  */
-  s = bfd_make_section (abfd, ".rela.bss");
-  if (s == NULL
-      || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
-      || ! bfd_set_section_alignment (abfd, s, 2))
-    return false;
+  if (! info->shared)
+    {
+      s = bfd_make_section (abfd, ".rela.bss");
+      if (s == NULL
+	  || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
+	  || ! bfd_set_section_alignment (abfd, s, 2))
+	return false;
+    }
+
+  return true;
+}
+
+/* Look through the relocs for a section during the first phase, and
+   allocate space in the global offset table or procedure linkage
+   table.  */
+
+static boolean
+elf32_sparc_check_relocs (abfd, info, sec, relocs)
+     bfd *abfd;
+     struct bfd_link_info *info;
+     asection *sec;
+     const Elf_Internal_Rela *relocs;
+{
+  bfd *dynobj;
+  Elf_Internal_Shdr *symtab_hdr;
+  struct elf_link_hash_entry **sym_hashes;
+  bfd_vma *local_got_offsets;
+  const Elf_Internal_Rela *rel;
+  const Elf_Internal_Rela *rel_end;
+  asection *sgot;
+  asection *srelgot;
+  asection *splt;
+  asection *srelplt;
+  asection *sreloc;
+
+  if (info->relocateable)
+    return true;
+
+  dynobj = elf_hash_table (info)->dynobj;
+  symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
+  sym_hashes = elf_sym_hashes (abfd);
+  local_got_offsets = elf_local_got_offsets (abfd);
+
+  sgot = NULL;
+  srelgot = NULL;
+  splt = NULL;
+  srelplt = NULL;
+  sreloc = NULL;
+
+  rel_end = relocs + sec->reloc_count;
+  for (rel = relocs; rel < rel_end; rel++)
+    {
+      long r_symndx;
+      struct elf_link_hash_entry *h;
+
+      r_symndx = ELF32_R_SYM (rel->r_info);
+      if (r_symndx < symtab_hdr->sh_info)
+	h = NULL;
+      else
+	h = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+      /* Some relocs require a global offset table.  FIXME: If this is
+	 a static link, we don't really need to create the full
+	 dynamic linking information.  */
+      if (dynobj == NULL)
+	{
+	  switch (ELF32_R_TYPE (rel->r_info))
+	    {
+	    case R_SPARC_GOT10:
+	    case R_SPARC_GOT13:
+	    case R_SPARC_GOT22:
+	    case R_SPARC_WPLT30:
+	      elf_hash_table (info)->dynobj = dynobj = abfd;
+	      if (! bfd_elf32_link_create_dynamic_sections (dynobj, info))
+		return false;
+	      break;
+
+	    default:
+	      break;
+	    }
+	}
+
+      switch (ELF32_R_TYPE (rel->r_info))
+	{
+	case R_SPARC_GOT10:
+	case R_SPARC_GOT13:
+	case R_SPARC_GOT22:
+	  /* This symbol requires a global offset table entry.  */
+
+	  if (sgot == NULL)
+	    {
+	      sgot = bfd_get_section_by_name (dynobj, ".got");
+	      srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+	      if (srelgot == NULL)
+		{
+		  srelgot = bfd_make_section (dynobj, ".rela.got");
+		  if (srelgot == NULL
+		      || ! bfd_set_section_flags (dynobj, srelgot,
+						  (SEC_ALLOC
+						   | SEC_LOAD
+						   | SEC_HAS_CONTENTS
+						   | SEC_IN_MEMORY
+						   | SEC_READONLY)))
+		    return false;
+		}
+	      BFD_ASSERT (sgot != NULL && srelgot != NULL);
+	    }
+
+	  if (h != NULL)
+	    {
+	      if (h->got_offset != (bfd_vma) -1)
+		{
+		  /* We have already allocated space in the .got.  */
+		  break;
+		}
+	      h->got_offset = sgot->_raw_size;
+	    }
+	  else
+	    {
+	      /* This is a global offset table entry for a local
+                 symbol.  */
+	      if (local_got_offsets == NULL)
+		{
+		  size_t size;
+		  register int i;
+
+		  size = symtab_hdr->sh_info * sizeof (bfd_vma);
+		  local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
+		  if (local_got_offsets == NULL)
+		    {
+		      bfd_set_error (bfd_error_no_memory);
+		      return false;
+		    }
+		  elf_local_got_offsets (abfd) = local_got_offsets;
+		  for (i = 0; i < symtab_hdr->sh_info; i++)
+		    local_got_offsets[i] = (bfd_vma) -1;
+		}
+	      if (local_got_offsets[r_symndx] != (bfd_vma) -1)
+		{
+		  /* We have already allocated space in the .got.  */
+		  break;
+		}
+	      local_got_offsets[r_symndx] = sgot->_raw_size;
+	    }
+
+	  sgot->_raw_size += 4;
+	  srelgot->_raw_size += sizeof (Elf32_External_Rela);
+
+	  break;
+
+	case R_SPARC_WPLT30:
+	  /* This symbol requires a procedure linkage table entry.  */
+
+	  if (h == NULL)
+	    {
+	      /* It does not make sense to have a procedure linkage
+                 table entry for a local symbol.  */
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+
+	  if (h->plt_offset != (bfd_vma) -1)
+	    {
+	      /* There is already an entry for this symbol in the
+                 procedure linkage table.  */
+	      break;
+	    }
+
+	  if (splt == NULL)
+	    {
+	      splt = bfd_get_section_by_name (dynobj, ".plt");
+	      srelplt = bfd_get_section_by_name (dynobj, ".rela.plt");
+	      BFD_ASSERT (splt != NULL && srelplt != NULL);
+	    }
+
+	  /* The procedure linkage table has a maximum size.  */
+	  if (splt->_raw_size >= 0x400000)
+	    {
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
+
+	  h->plt_offset = splt->_raw_size;
+
+	  /* Make room for this entry.  */
+	  splt->_raw_size += PLT_ENTRY_SIZE;
+	  srelplt->_raw_size += sizeof (Elf32_External_Rela);
+
+	  break;
+
+	case R_SPARC_PC10:
+	case R_SPARC_PC22:
+	  if (h != NULL
+	      && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
+	    break;
+	  /* Fall through.  */
+	case R_SPARC_8:
+	case R_SPARC_16:
+	case R_SPARC_32:
+	case R_SPARC_DISP8:
+	case R_SPARC_DISP16:
+	case R_SPARC_DISP32:
+	case R_SPARC_WDISP30:
+	case R_SPARC_WDISP22:
+	case R_SPARC_HI22:
+	case R_SPARC_22:
+	case R_SPARC_13:
+	case R_SPARC_LO10:
+	case R_SPARC_UA32:
+	  if (info->shared
+	      && (sec->flags & SEC_ALLOC) != 0)
+	    {
+	      /* When creating a shared object, we must copy these
+                 relocs into the output file.  We create a reloc
+                 section in dynobj and make room for the reloc.  */
+	      if (sreloc == NULL)
+		{
+		  const char *name;
+
+		  name = (elf_string_from_elf_section
+			  (abfd,
+			   elf_elfheader (abfd)->e_shstrndx,
+			   elf_section_data (sec)->rel_hdr.sh_name));
+		  if (name == NULL)
+		    return false;
+
+		  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (abfd, sec),
+					 name + 5) == 0);
+
+		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  if (sreloc == NULL)
+		    {
+		      sreloc = bfd_make_section (dynobj, name);
+		      if (sreloc == NULL
+			  || ! bfd_set_section_flags (dynobj, sreloc,
+						      (SEC_ALLOC
+						       | SEC_LOAD
+						       | SEC_HAS_CONTENTS
+						       | SEC_IN_MEMORY
+						       | SEC_READONLY))
+			  || ! bfd_set_section_alignment (dynobj, sreloc, 2))
+			return false;
+		    }
+		}
+
+	      sreloc->_raw_size += sizeof (Elf32_External_Rela);
+	    }
+
+	  break;
+
+	default:
+	  break;
+	}
+    }
 
   return true;
 }
@@ -314,28 +575,33 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
      (although we could actually do it here).  */
   if (h->type == STT_FUNC)
     {
-      s = bfd_get_section_by_name (dynobj, ".plt");
-      BFD_ASSERT (s != NULL);
-
-      /* The procedure linkage table has a maximum size.  */
-      if (s->_raw_size >= 0x400000)
+      if (h->plt_offset == (bfd_vma) -1)
 	{
-	  bfd_set_error (bfd_error_bad_value);
-	  return false;
-	}
+	  s = bfd_get_section_by_name (dynobj, ".plt");
+	  BFD_ASSERT (s != NULL);
+
+	  /* The procedure linkage table has a maximum size.  */
+	  if (s->_raw_size >= 0x400000)
+	    {
+	      bfd_set_error (bfd_error_bad_value);
+	      return false;
+	    }
 
-      /* Set the symbol to this location in the .plt.  */
-      h->root.u.def.section = s;
-      h->root.u.def.value = s->_raw_size;
+	  /* Set the symbol to this location in the .plt.  */
+	  h->root.u.def.section = s;
+	  h->root.u.def.value = s->_raw_size;
 
-      /* Make room for this entry.  */
-      s->_raw_size += PLT_ENTRY_SIZE;
+	  h->plt_offset = s->_raw_size;
 
-      /* We also need to make an entry in the .rela.plt section.  */
+	  /* Make room for this entry.  */
+	  s->_raw_size += PLT_ENTRY_SIZE;
 
-      s = bfd_get_section_by_name (dynobj, ".rela.plt");
-      BFD_ASSERT (s != NULL);
-      s->_raw_size += sizeof (Elf32_External_Rela);
+	  /* We also need to make an entry in the .rela.plt section.  */
+
+	  s = bfd_get_section_by_name (dynobj, ".rela.plt");
+	  BFD_ASSERT (s != NULL);
+	  s->_raw_size += sizeof (Elf32_External_Rela);
+	}
 
       return true;
     }
@@ -348,20 +614,28 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined);
       h->root.u.def.section = h->weakdef->root.u.def.section;
       h->root.u.def.value = h->weakdef->root.u.def.value;
-      h->copy_offset = (bfd_vma) -1;
       return true;
     }
 
   /* This is a reference to a symbol defined by a dynamic object which
-     is not a function.  We must allocate it in our .dynbss section,
-     which will become part of the .bss section of the executable.
-     There will be an entry for this symbol in the .dynsym section.
-     The dynamic object will contain position independent code, so all
-     references from the dynamic object to this symbol will go through
-     the global offset table.  The dynamic linker will use the .dynsym
-     entry to determine the address it must put in the global offset
-     table, so both the dynamic object and the regular object will
-     refer to the same memory location for the variable.  */
+     is not a function.  */
+
+  /* If we are creating a shared library, we must presume that the
+     only references to the symbol are via the global offset table.
+     For such cases we need not do anything here; the relocations will
+     be handled correctly by relocate_section.  */
+  if (info->shared)
+    return true;
+
+  /* We must allocate the symbol in our .dynbss section, which will
+     become part of the .bss section of the executable.  There will be
+     an entry for this symbol in the .dynsym section.  The dynamic
+     object will contain position independent code, so all references
+     from the dynamic object to this symbol will go through the global
+     offset table.  The dynamic linker will use the .dynsym entry to
+     determine the address it must put in the global offset table, so
+     both the dynamic object and the regular object will refer to the
+     same memory location for the variable.  */
 
   s = bfd_get_section_by_name (dynobj, ".dynbss");
   BFD_ASSERT (s != NULL);
@@ -373,16 +647,14 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
      value out of the dynamic object and into the runtime process
      image.  We need to remember the offset into the .rel.bss section
      we are going to use.  */
-  if ((h->root.u.def.section->flags & SEC_LOAD) == 0)
-    h->copy_offset = (bfd_vma) -1;
-  else
+  if ((h->root.u.def.section->flags & SEC_LOAD) != 0)
     {
       asection *srel;
 
       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
       BFD_ASSERT (srel != NULL);
-      h->copy_offset = srel->_raw_size;
       srel->_raw_size += sizeof (Elf32_External_Rela);
+      h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
     }
 
   /* We need to figure out the alignment required for this symbol.  I
@@ -410,26 +682,6 @@ elf32_sparc_adjust_dynamic_symbol (info, h)
   return true;
 }
 
-/* Allocate contents for a section.  */
-
-static INLINE boolean
-elf32_sparc_allocate_dynamic_section (dynobj, name)
-     bfd *dynobj;
-     const char *name;
-{
-  register asection *s;
-
-  s = bfd_get_section_by_name (dynobj, name);
-  BFD_ASSERT (s != NULL);
-  s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
-  if (s->contents == NULL && s->_raw_size != 0)
-    {
-      bfd_set_error (bfd_error_no_memory);
-      return false;
-    }
-  return true;
-}
-
 /* Set the sizes of the dynamic sections.  */
 
 static boolean
@@ -439,6 +691,7 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
 {
   bfd *dynobj;
   asection *s;
+  boolean reltext;
 
   dynobj = elf_hash_table (info)->dynobj;
   BFD_ASSERT (dynobj != NULL);
@@ -457,22 +710,65 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
   BFD_ASSERT (s != NULL);
   s->_raw_size += 4;
 
-  /* The adjust_dynamic_symbol entry point has determined the sizes of
-     the various dynamic sections.  Allocate some memory for them to
-     hold contents.  */
-  if (! elf32_sparc_allocate_dynamic_section (dynobj, ".plt")
-      || ! elf32_sparc_allocate_dynamic_section (dynobj, ".rela.plt")
-      || ! elf32_sparc_allocate_dynamic_section (dynobj, ".got")
-      || ! elf32_sparc_allocate_dynamic_section (dynobj, ".rela.bss"))
-    return false;
+  /* The check_relocs and adjust_dynamic_symbol entry points have
+     determined the sizes of the various dynamic sections.  Allocate
+     memory for them.  */
+  reltext = false;
+  for (s = dynobj->sections; s != NULL; s = s->next)
+    {
+      const char *name;
+
+      if ((s->flags & SEC_IN_MEMORY) == 0)
+	continue;
+
+      /* It's OK to base decisions on the section name, because none
+	 of the dynobj section names depend upon the input files.  */
+      name = bfd_get_section_name (dynobj, s);
+
+      if (strncmp (name, ".rela", 5) == 0
+	  && s->_raw_size > 0)
+	{
+	  asection *target;
+
+	  /* If this relocation section applies to a read only
+             section, then we probably need a DT_TEXTREL entry.  */
+	  target = bfd_get_section_by_name (output_bfd, name + 5);
+	  if (target != NULL
+	      && (target->flags & SEC_READONLY) != 0)
+	    reltext = true;
+
+	  /* We use the reloc_count field as a counter if we need to
+             copy relocs into the output file.  */
+	  s->reloc_count = 0;
+	}
+      else if (strcmp (name, ".plt") != 0
+	       && strcmp (name, ".got") != 0)
+	{
+	  /* It's not one of our sections, so don't allocate space.  */
+	  continue;
+	}
+	  
+      /* Allocate memory for the section contents.  */
+      s->contents = (bfd_byte *) bfd_alloc (dynobj, s->_raw_size);
+      if (s->contents == NULL && s->_raw_size != 0)
+	{
+	  bfd_set_error (bfd_error_no_memory);
+	  return false;
+	}
+    }
 
   /* Add some entries to the .dynamic section.  We fill in the values
      later, in elf32_sparc_finish_dynamic_sections, but we must add
      the entries now so that we get the correct size for the .dynamic
      section.  The DT_DEBUG entry is filled in by the dynamic linker
      and used by the debugger.  */
-  if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0)
-      || ! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
+  if (! info->shared)
+    {
+      if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
+	return false;
+    }
+
+  if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
       || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
       || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
       || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0)
@@ -482,6 +778,12 @@ elf32_sparc_size_dynamic_sections (output_bfd, info)
 					sizeof (Elf32_External_Rela)))
     return false;
 
+  if (reltext)
+    {
+      if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
+	return false;
+    }
+
   return true;
 }
 
@@ -501,13 +803,24 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
      asection **local_sections;
      char *output_names;
 {
+  bfd *dynobj;
   Elf_Internal_Shdr *symtab_hdr;
   struct elf_link_hash_entry **sym_hashes;
+  bfd_vma *local_got_offsets;
+  asection *sgot;
+  asection *splt;
+  asection *sreloc;
   Elf_Internal_Rela *rel;
   Elf_Internal_Rela *relend;
 
+  dynobj = elf_hash_table (info)->dynobj;
   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
   sym_hashes = elf_sym_hashes (input_bfd);
+  local_got_offsets = elf_local_got_offsets (input_bfd);
+
+  sgot = NULL;
+  splt = NULL;
+  sreloc = NULL;
 
   rel = relocs;
   relend = relocs + input_section->reloc_count;
@@ -565,10 +878,7 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 	}
       else
 	{
-	  long indx;
-
-	  indx = r_symndx - symtab_hdr->sh_info;
-	  h = sym_hashes[indx];
+	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 	  if (h->root.type == bfd_link_hash_defined)
 	    {
 	      sec = h->root.u.def.section;
@@ -578,6 +888,8 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 	    }
 	  else if (h->root.type == bfd_link_hash_weak)
 	    relocation = 0;
+	  else if (info->shared)
+	    relocation = 0;
 	  else
 	    {
 	      if (! ((*info->callbacks->undefined_symbol)
@@ -588,6 +900,185 @@ elf32_sparc_relocate_section (output_bfd, info, input_bfd, input_section,
 	    }
 	}
 
+      switch (r_type)
+	{
+	case R_SPARC_GOT10:
+	case R_SPARC_GOT13:
+	case R_SPARC_GOT22:
+	  /* Relocation is to the entry for this symbol in the global
+             offset table.  */
+	  if (sgot == NULL)
+	    {
+	      sgot = bfd_get_section_by_name (dynobj, ".got");
+	      BFD_ASSERT (sgot != NULL);
+	    }
+
+	  if (h != NULL)
+	    {
+	      BFD_ASSERT (h->got_offset != (bfd_vma) -1);
+	      relocation = sgot->output_offset + h->got_offset;
+	    }
+	  else
+	    {
+	      bfd_vma off;
+
+	      BFD_ASSERT (local_got_offsets != NULL
+			  && local_got_offsets[r_symndx] != (bfd_vma) -1);
+
+	      off = local_got_offsets[r_symndx];
+
+	      /* The offset must always be a multiple of 4.  We use
+                 the least significant bit to record whether we have
+                 already generated the necessary reloc.  */
+	      if ((off & 1) != 0)
+		off &= ~1;
+	      else
+		{
+		  asection *srelgot;
+		  Elf_Internal_Rela outrel;
+
+		  bfd_put_32 (output_bfd, relocation, sgot->contents + off);
+
+		  srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
+		  BFD_ASSERT (srelgot != NULL);
+
+		  outrel.r_offset = (sgot->output_section->vma
+				     + sgot->output_offset
+				     + off);
+		  outrel.r_info = ELF32_R_INFO (0, R_SPARC_RELATIVE);
+		  outrel.r_addend = 0;
+		  bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+					     (((Elf32_External_Rela *)
+					       srelgot->contents)
+					      + srelgot->reloc_count));
+		  ++srelgot->reloc_count;
+
+		  local_got_offsets[r_symndx] |= 1;
+		}
+
+	      relocation = sgot->output_offset + off;
+	    }
+
+	  break;
+
+	case R_SPARC_WPLT30:
+	  /* Relocation is to the entry for this symbol in the
+             procedure linkage table.  */
+	  if (splt == NULL)
+	    {
+	      splt = bfd_get_section_by_name (dynobj, ".plt");
+	      BFD_ASSERT (splt != NULL);
+	    }
+
+	  BFD_ASSERT (h != NULL && h->plt_offset != (bfd_vma) -1);
+	  relocation = (splt->output_section->vma
+			+ splt->output_offset
+			+ h->plt_offset);
+	  break;
+
+	case R_SPARC_PC10:
+	case R_SPARC_PC22:
+	  if (h != NULL
+	      && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
+	    break;
+	  /* Fall through.  */
+	case R_SPARC_8:
+	case R_SPARC_16:
+	case R_SPARC_32:
+	case R_SPARC_DISP8:
+	case R_SPARC_DISP16:
+	case R_SPARC_DISP32:
+	case R_SPARC_WDISP30:
+	case R_SPARC_WDISP22:
+	case R_SPARC_HI22:
+	case R_SPARC_22:
+	case R_SPARC_13:
+	case R_SPARC_LO10:
+	case R_SPARC_UA32:
+	  if (info->shared
+	      && (input_section->flags & SEC_ALLOC) != 0)
+	    {
+	      Elf_Internal_Rela outrel;
+
+	      /* When generating a shared object, these relocations
+                 are copied into the output file to be resolved at run
+                 time.  */
+
+	      if (sreloc == NULL)
+		{
+		  const char *name;
+
+		  name = (elf_string_from_elf_section
+			  (input_bfd,
+			   elf_elfheader (input_bfd)->e_shstrndx,
+			   elf_section_data (input_section)->rel_hdr.sh_name));
+		  if (name == NULL)
+		    return false;
+
+		  BFD_ASSERT (strncmp (name, ".rela", 5) == 0
+			      && strcmp (bfd_get_section_name (input_bfd,
+							       input_section),
+					 name + 5) == 0);
+
+		  sreloc = bfd_get_section_by_name (dynobj, name);
+		  BFD_ASSERT (sreloc != NULL);
+		}
+
+	      outrel.r_offset = (rel->r_offset
+				 + input_section->output_section->vma
+				 + input_section->output_offset);
+	      if (h != NULL)
+		{
+		  BFD_ASSERT (h->dynindx != (bfd_vma) -1);
+		  outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
+		  outrel.r_addend = 0;
+		}
+	      else
+		{
+		  long indx;
+
+		  sym = local_syms + r_symndx;
+
+		  /* If this isn't a section symbol, we need to map it
+                     to something that is going to be put into the
+                     dynamic symbols.  The case will probably never
+                     arise.  */
+		  BFD_ASSERT (ELF_ST_TYPE (sym->st_info) == STT_SECTION);
+
+		  sec = local_sections[r_symndx];
+		  if (sec != NULL && bfd_is_abs_section (sec))
+		    indx = 0;
+		  else if (sec == NULL || sec->owner == NULL)
+		    {
+		      bfd_set_error (bfd_error_bad_value);
+		      return false;
+		    }
+		  else
+		    {
+		      indx = sec->output_section->target_index;
+		      if (indx == 0)
+			abort ();
+		    }
+
+		  outrel.r_info = ELF32_R_INFO (indx, r_type);
+		  outrel.r_addend = sec->output_offset + sym->st_value;
+		}
+
+	      bfd_elf32_swap_reloca_out (output_bfd, &outrel,
+					 (((Elf32_External_Rela *)
+					   sreloc->contents)
+					  + sreloc->reloc_count));
+	      ++sreloc->reloc_count;
+
+	      /* This reloc will be computed at runtime, so there's no
+                 need to do anything now.  */
+	      continue;
+	    }
+
+	default:
+	  break;
+	}		
+
       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
 				    contents, rel->r_offset,
 				    relocation, rel->r_addend);
@@ -636,86 +1127,112 @@ elf32_sparc_finish_dynamic_symbol (output_bfd, info, h, sym)
      struct elf_link_hash_entry *h;
      Elf_Internal_Sym *sym;
 {
-  /* If this symbol is not defined by a dynamic object, or is not
-     referenced by a regular object, ignore it.  */
-  if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) != 0
-      || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
-      || (h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR) == 0)
-    {
-      /* Mark some specially defined symbols as absolute.  */
-      if (strcmp (h->root.root.string, "_DYNAMIC") == 0
-	  || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
-	  || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
-	sym->st_shndx = SHN_ABS;
-      return true;
-    }
+  bfd *dynobj;
 
-  BFD_ASSERT (h->root.type == bfd_link_hash_defined);
-  BFD_ASSERT (h->dynindx != -1);
+  dynobj = elf_hash_table (info)->dynobj;
 
-  if (h->type == STT_FUNC)
+  if (h->plt_offset != (bfd_vma) -1)
     {
       asection *splt;
       asection *srela;
       Elf_Internal_Rela rela;
 
-      splt = h->root.u.def.section;
-      BFD_ASSERT (strcmp (bfd_get_section_name (splt->owner, splt), ".plt")
-		  == 0);
-      srela = bfd_get_section_by_name (splt->owner, ".rela.plt");
-      BFD_ASSERT (srela != NULL);
+      /* This symbol has an entry in the procedure linkage table.  Set
+         it up.  */
+
+      BFD_ASSERT (h->dynindx != -1);
+
+      splt = bfd_get_section_by_name (dynobj, ".plt");
+      srela = bfd_get_section_by_name (dynobj, ".rela.plt");
+      BFD_ASSERT (splt != NULL && srela != NULL);
 
       /* Fill in the entry in the procedure linkage table.  */
       bfd_put_32 (output_bfd,
-		  PLT_ENTRY_WORD0 + h->root.u.def.value,
-		  splt->contents + h->root.u.def.value);
+		  PLT_ENTRY_WORD0 + h->plt_offset,
+		  splt->contents + h->plt_offset);
       bfd_put_32 (output_bfd,
 		  (PLT_ENTRY_WORD1
-		   + (((- (h->root.u.def.value + 4)) >> 2) & 0x3fffff)),
-		  splt->contents + h->root.u.def.value + 4);
+		   + (((- (h->plt_offset + 4)) >> 2) & 0x3fffff)),
+		  splt->contents + h->plt_offset + 4);
       bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
-		  splt->contents + h->root.u.def.value + 8);
+		  splt->contents + h->plt_offset + 8);
 
       /* Fill in the entry in the .rela.plt section.  */
       rela.r_offset = (splt->output_section->vma
 		       + splt->output_offset
-		       + h->root.u.def.value);
+		       + h->plt_offset);
       rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_JMP_SLOT);
       rela.r_addend = 0;
       bfd_elf32_swap_reloca_out (output_bfd, &rela,
 				 ((Elf32_External_Rela *) srela->contents
-				  + (h->root.u.def.value / PLT_ENTRY_SIZE
-				     - 4)));
+				  + h->plt_offset / PLT_ENTRY_SIZE - 4));
+
+      if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
+	{
+	  /* Mark the symbol as undefined, rather than as defined in
+	     the .plt section.  Leave the value alone.  */
+	  sym->st_shndx = SHN_UNDEF;
+	}
+    }
+
+  if (h->got_offset != (bfd_vma) -1)
+    {
+      asection *sgot;
+      asection *srela;
+      Elf_Internal_Rela rela;
+
+      /* This symbol has an entry in the global offset table.  Set it
+         up.  */
 
-      /* Mark the symbol as undefined, rather than as defined in the
-	 .plt section.  Leave the value alone.  */
-      sym->st_shndx = SHN_UNDEF;
+      BFD_ASSERT (h->dynindx != -1);
+
+      sgot = bfd_get_section_by_name (dynobj, ".got");
+      srela = bfd_get_section_by_name (dynobj, ".rela.got");
+      BFD_ASSERT (sgot != NULL && srela != NULL);
+
+      bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got_offset);
+
+      rela.r_offset = (sgot->output_section->vma
+		       + sgot->output_offset
+		       + h->got_offset);
+      rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_GLOB_DAT);
+      rela.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rela,
+				 ((Elf32_External_Rela *) srela->contents
+				  + srela->reloc_count));
+      ++srela->reloc_count;
     }
-  else
+
+  if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
     {
-      /* This is not a function.  We have already allocated memory for
-	 it in the .bss section (via .dynbss).  All we have to do here
-	 is create a COPY reloc if required.  */
-      if (h->copy_offset != (bfd_vma) -1)
-	{
-	  asection *s;
-	  Elf_Internal_Rela rela;
+      asection *s;
+      Elf_Internal_Rela rela;
 
-	  s = bfd_get_section_by_name (h->root.u.def.section->owner,
-				       ".rela.bss");
-	  BFD_ASSERT (s != NULL);
+      /* This symbols needs a copy reloc.  Set it up.  */
 
-	  rela.r_offset = (h->root.u.def.value
-			   + h->root.u.def.section->output_section->vma
-			   + h->root.u.def.section->output_offset);
-	  rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
-	  rela.r_addend = 0;
-	  bfd_elf32_swap_reloca_out (output_bfd, &rela,
-				     ((Elf32_External_Rela *)
-				      (s->contents + h->copy_offset)));
-	}
+      BFD_ASSERT (h->dynindx != -1);
+
+      s = bfd_get_section_by_name (h->root.u.def.section->owner,
+				   ".rela.bss");
+      BFD_ASSERT (s != NULL);
+
+      rela.r_offset = (h->root.u.def.value
+		       + h->root.u.def.section->output_section->vma
+		       + h->root.u.def.section->output_offset);
+      rela.r_info = ELF32_R_INFO (h->dynindx, R_SPARC_COPY);
+      rela.r_addend = 0;
+      bfd_elf32_swap_reloca_out (output_bfd, &rela,
+				 ((Elf32_External_Rela *) s->contents
+				  + s->reloc_count));
+      ++s->reloc_count;
     }
 
+  /* Mark some specially defined symbols as absolute.  */
+  if (strcmp (h->root.root.string, "_DYNAMIC") == 0
+      || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0
+      || strcmp (h->root.root.string, "_PROCEDURE_LINKAGE_TABLE_") == 0)
+    sym->st_shndx = SHN_ABS;
+
   return true;
 }
 
@@ -726,14 +1243,17 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
      bfd *output_bfd;
      struct bfd_link_info *info;
 {
+  bfd *dynobj;
   asection *splt;
   asection *sgot;
   asection *sdyn;
   Elf32_External_Dyn *dyncon, *dynconend;
 
-  splt = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".plt");
-  sgot = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".got");
-  sdyn = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".dynamic");
+  dynobj = elf_hash_table (info)->dynobj;
+
+  splt = bfd_get_section_by_name (dynobj, ".plt");
+  sgot = bfd_get_section_by_name (dynobj, ".got");
+  sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
   BFD_ASSERT (splt != NULL && sgot != NULL && sdyn != NULL);
 
   dyncon = (Elf32_External_Dyn *) sdyn->contents;
@@ -744,7 +1264,7 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
       const char *name;
       boolean size;
 
-      bfd_elf32_swap_dyn_in (elf_hash_table (info)->dynobj, dyncon, &dyn);
+      bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
 
       switch (dyn.d_tag)
 	{
@@ -803,6 +1323,7 @@ elf32_sparc_finish_dynamic_sections (output_bfd, info)
 #define ELF_MAXPAGESIZE 0x10000
 #define elf_backend_create_dynamic_sections \
 					elf32_sparc_create_dynamic_sections
+#define elf_backend_check_relocs	elf32_sparc_check_relocs
 #define elf_backend_adjust_dynamic_symbol \
 					elf32_sparc_adjust_dynamic_symbol
 #define elf_backend_size_dynamic_sections \