Framework for relocation scanning. Implement simple static TLS

relocations.

1 files changed, 92 insertions, 22 deletions

diff --git a/gold/target-reloc.h b/gold/target-reloc.h
index f972b117d9a..2d1fe306fb4 100644
--- a/gold/target-reloc.h
+++ b/gold/target-reloc.h
@@ -4,6 +4,7 @@
 #define GOLD_TARGET_RELOC_H
 
 #include "elfcpp.h"
+#include "object.h"
 #include "symtab.h"
 
 namespace gold
@@ -29,7 +30,79 @@ struct Reloc_types<elfcpp::SHT_RELA, size, big_endian>
   static const int reloc_size = elfcpp::Elf_sizes<size>::rela_size;
 };
 
-// This function implements the generic part of relocation handling.
+// This function implements the generic part of reloc scanning.  This
+// is an inline function which takes a class whose operator()
+// implements the machine specific part of scanning.  We do it this
+// way to avoidmaking a function call for each relocation, and to
+// avoid repeating the generic code for each target.
+
+template<int size, bool big_endian, int sh_type, typename Scan>
+inline void
+scan_relocs(
+    const General_options& options,
+    Symbol_table* symtab,
+    Sized_object<size, big_endian>* object,
+    const unsigned char* prelocs,
+    size_t reloc_count,
+    size_t local_count,
+    const unsigned char* plocal_syms,
+    Symbol** global_syms)
+{
+  typedef typename Reloc_types<sh_type, size, big_endian>::Reloc Reltype;
+  const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
+  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+  Scan scan;
+
+  for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
+    {
+      Reltype reloc(prelocs);
+
+      typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info();
+      unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info);
+      unsigned int r_type = elfcpp::elf_r_type<size>(r_info);
+
+      if (r_sym < local_count)
+	{
+	  assert(plocal_syms != NULL);
+	  typename elfcpp::Sym<size, big_endian> lsym(plocal_syms
+						      + r_sym * sym_size);
+	  const unsigned int shndx = lsym.get_st_shndx();
+	  if (shndx < elfcpp::SHN_LORESERVE
+	      && !object->is_section_included(lsym.get_st_shndx()))
+	    {
+	      // RELOC is a relocation against a local symbol in a
+	      // section we are discarding.  We can ignore this
+	      // relocation.  It will eventually become a reloc
+	      // against the value zero.
+	      //
+	      // FIXME: We should issue a warning if this is an
+	      // allocated section; is this the best place to do it?
+	      // 
+	      // FIXME: The old GNU linker would in some cases look
+	      // for the linkonce section which caused this section to
+	      // be discarded, and, if the other section was the same
+	      // size, change the reloc to refer to the other section.
+	      // That seems risky and weird to me, and I don't know of
+	      // any case where it is actually required.
+
+	      continue;
+	    }
+
+	  scan.local(options, object, reloc, r_type, lsym);
+	}
+      else
+	{
+	  Symbol* gsym = global_syms[r_sym - local_count];
+	  assert(gsym != NULL);
+	  if (gsym->is_forwarder())
+	    gsym = symtab->resolve_forwards(gsym);
+
+	  scan.global(options, object, reloc, r_type, gsym);
+	}
+    }
+}
+
+// This function implements the generic part of relocation processing.
 // This is an inline function which take a class whose operator()
 // implements the machine specific part of relocation.  We do it this
 // way to avoid making a function call for each relocation, and to
@@ -37,27 +110,19 @@ struct Reloc_types<elfcpp::SHT_RELA, size, big_endian>
 // target.
 
 // SIZE is the ELF size: 32 or 64.  BIG_ENDIAN is the endianness of
-// the data.  SH_TYPE is the section type: SHT_REL or SHT_RELA.  RELOC
-// implements operator() to do a relocation.
+// the data.  SH_TYPE is the section type: SHT_REL or SHT_RELA.
+// RELOCATE implements operator() to do a relocation.
 
-// OBJECT is the object for we are processing relocs.  SH_TYPE is the
-// type of relocation: SHT_REL or SHT_RELA.  PRELOCS points to the
-// relocation data.  RELOC_COUNT is the number of relocs.  LOCAL_COUNT
-// is the number of local symbols.  LOCAL_VALUES holds the values of
-// the local symbols.  GLOBAL_SYMS points to the global symbols.  VIEW
-// is the section data, VIEW_ADDRESS is its memory address, and
-// VIEW_SIZE is the size.
+// PRELOCS points to the relocation data.  RELOC_COUNT is the number
+// of relocs.  VIEW is the section data, VIEW_ADDRESS is its memory
+// address, and VIEW_SIZE is the size.
 
 template<int size, bool big_endian, int sh_type, typename Relocate>
 inline void
 relocate_section(
-    const Symbol_table* symtab,
-    Sized_object<size, big_endian>* object,
+    const Relocate_info<size, big_endian>* relinfo,
     const unsigned char* prelocs,
     size_t reloc_count,
-    size_t local_count,
-    const typename elfcpp::Elf_types<size>::Elf_Addr* local_values,
-    Symbol** global_syms,
     unsigned char* view,
     typename elfcpp::Elf_types<size>::Elf_Addr view_address,
     off_t view_size)
@@ -66,6 +131,10 @@ relocate_section(
   const int reloc_size = Reloc_types<sh_type, size, big_endian>::reloc_size;
   Relocate relocate;
 
+  unsigned int local_count = relinfo->local_symbol_count;
+  typename elfcpp::Elf_types<size>::Elf_Addr *local_values = relinfo->values;
+  Symbol** global_syms = relinfo->symbols;
+
   for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size)
     {
       Reltype reloc(prelocs);
@@ -73,9 +142,9 @@ relocate_section(
       off_t offset = reloc.get_r_offset();
       if (offset < 0 || offset >= view_size)
 	{
-	  fprintf(stderr, _("%s: %s: reloc %zu has bad offset %lu\n"),
-		  program_name, object->name().c_str(), i,
-		  static_cast<unsigned long>(offset));
+	  fprintf(stderr, _("%s: %s: reloc has bad offset %zu\n"),
+		  program_name, relinfo->location(i, offset).c_str(),
+		  static_cast<size_t>(offset));
 	  gold_exit(false);
 	}
 
@@ -96,7 +165,7 @@ relocate_section(
 	  Symbol* gsym = global_syms[r_sym - local_count];
 	  assert(gsym != NULL);
 	  if (gsym->is_forwarder())
-	    gsym = symtab->resolve_forwards(gsym);
+	    gsym = relinfo->symtab->resolve_forwards(gsym);
 
 	  sym = static_cast<Sized_symbol<size>*>(gsym);
 	  value = sym->value();
@@ -105,13 +174,14 @@ relocate_section(
 	      && sym->binding() != elfcpp::STB_WEAK)
 	    {
 	      fprintf(stderr, _("%s: %s: undefined reference to '%s'\n"),
-		      program_name, object->name().c_str(), sym->name());
+		      program_name, relinfo->location(i, offset).c_str(),
+		      sym->name());
 	      // gold_exit(false);
 	    }
 	}
 
-      relocate(object, reloc, r_type, sym, value, view + offset,
-	       view_address + offset);
+      relocate.relocate(relinfo, i, reloc, r_type, sym, value, view + offset,
+			view_address + offset, view_size);
     }
 }