Speed up relocations against local symbols in merged sections.

10 files changed, 598 insertions, 210 deletions

diff --git a/gold/ehframe.cc b/gold/ehframe.cc
index b77148b..b2406b4 100644
--- a/gold/ehframe.cc
+++ b/gold/ehframe.cc
@@ -1041,6 +1041,15 @@ Eh_frame::do_output_offset(const Relobj* object, unsigned int shndx,
   return this->merge_map_.get_output_offset(object, shndx, offset, poutput);
 }
 
+// Return whether this is the merge section for an input section.
+
+bool
+Eh_frame::do_is_merge_section_for(const Relobj* object,
+				  unsigned int shndx) const
+{
+  return this->merge_map_.is_merge_section_for(object, shndx);
+}
+
 // Write the data to the output file.
 
 void
diff --git a/gold/ehframe.h b/gold/ehframe.h
index ce4f6df..8e09657 100644
--- a/gold/ehframe.h
+++ b/gold/ehframe.h
@@ -326,6 +326,10 @@ class Eh_frame : public Output_section_data
 		   section_offset_type offset,
 		   section_offset_type* poutput) const;
 
+  // Return whether this is the merge section for an input section.
+  bool
+  do_is_merge_section_for(const Relobj*, unsigned int shndx) const;
+
   // Write the data to the file.
   void
   do_write(Output_file*);
diff --git a/gold/layout.cc b/gold/layout.cc
index 231e2c9..3897ec7 100644
--- a/gold/layout.cc
+++ b/gold/layout.cc
@@ -732,6 +732,12 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
   // they contain.
   off_t off = this->set_segment_offsets(target, load_seg, &shndx);
 
+  // Set the file offsets of all the non-data sections we've seen so
+  // far which don't have to wait for the input sections.  We need
+  // this in order to finalize local symbols in non-allocated
+  // sections.
+  off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
+
   // Create the symbol table sections.
   this->create_symtab_sections(input_objects, symtab, task, &off);
   if (!parameters->doing_static_link())
@@ -740,8 +746,8 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab,
   // Create the .shstrtab section.
   Output_section* shstrtab_section = this->create_shstrtab();
 
-  // Set the file offsets of all the non-data sections which don't
-  // have to wait for the input sections.
+  // Set the file offsets of the rest of the non-data sections which
+  // don't have to wait for the input sections.
   off = this->set_section_offsets(off, BEFORE_INPUT_SECTIONS_PASS);
 
   // Now that all sections have been created, set the section indexes.
@@ -1113,6 +1119,10 @@ Layout::set_section_offsets(off_t off, Layout::Section_offset_pass pass)
       if (*p == this->symtab_section_)
 	continue;
 
+      // If we've already set the data size, don't set it again.
+      if ((*p)->is_offset_valid() && (*p)->is_data_size_valid())
+	continue;
+
       if (pass == BEFORE_INPUT_SECTIONS_PASS
 	  && (*p)->requires_postprocessing())
 	{
diff --git a/gold/merge.cc b/gold/merge.cc
index beb0906..75a3eee 100644
--- a/gold/merge.cc
+++ b/gold/merge.cc
@@ -30,121 +30,7 @@
 namespace gold
 {
 
-// For each object with merge sections, we store an Object_merge_map.
-// This is used to map locations in input sections to a merged output
-// section.  The output section itself is not recorded here--it can be
-// found in the map_to_output_ field of the Object.
-
-class Object_merge_map
-{
- public:
-  Object_merge_map()
-    : first_shnum_(-1U), first_map_(),
-      second_shnum_(-1U), second_map_(),
-      section_merge_maps_()
-  { }
-
-  ~Object_merge_map();
-
-  // Add a mapping for MERGE_MAP, for the bytes from OFFSET to OFFSET
-  // + LENGTH in the input section SHNDX to OUTPUT_OFFSET in the
-  // output section.  An OUTPUT_OFFSET of -1 means that the bytes are
-  // discarded.  OUTPUT_OFFSET is relative to the start of the merged
-  // data in the output section.
-  void
-  add_mapping(const Merge_map*, unsigned int shndx, section_offset_type offset,
-	      section_size_type length, section_offset_type output_offset);
-
-  // Get the output offset for an input address in MERGE_MAP.  The
-  // input address is at offset OFFSET in section SHNDX.  This sets
-  // *OUTPUT_OFFSET to the offset in the output section; this will be
-  // -1 if the bytes are not being copied to the output.  This returns
-  // true if the mapping is known, false otherwise.  *OUTPUT_OFFSET is
-  // relative to the start of the merged data in the output section.
-  bool
-  get_output_offset(const Merge_map*, unsigned int shndx,
-		    section_offset_type offset,
-		    section_offset_type *output_offset);
-
- private:
-  // Map input section offsets to a length and an output section
-  // offset.  An output section offset of -1 means that this part of
-  // the input section is being discarded.
-  struct Input_merge_entry
-  {
-    // The offset in the input section.
-    section_offset_type input_offset;
-    // The length.
-    section_size_type length;
-    // The offset in the output section.
-    section_offset_type output_offset;
-  };
-
-  // A less-than comparison routine for Input_merge_entry.
-  struct Input_merge_compare
-  {
-    bool
-    operator()(const Input_merge_entry& i1, const Input_merge_entry& i2) const
-    { return i1.input_offset < i2.input_offset; }
-  };
-
-  // A list of entries for a particular input section.
-  struct Input_merge_map
-  {
-    // We store these with the Relobj, and we look them up by input
-    // section.  It is possible to have two different merge maps
-    // associated with a single output section.  For example, this
-    // happens routinely with .rodata, when merged string constants
-    // and merged fixed size constants are both put into .rodata.  The
-    // output offset that we store is not the offset from the start of
-    // the output section; it is the offset from the start of the
-    // merged data in the output section.  That means that the caller
-    // is going to add the offset of the merged data within the output
-    // section, which means that the caller needs to know which set of
-    // merged data it found the entry in.  So it's not enough to find
-    // this data based on the input section and the output section; we
-    // also have to find it based on a set of merged data in the
-    // output section.  In order to verify that we are looking at the
-    // right data, we store a pointer to the Merge_map here, and we
-    // pass in a pointer when looking at the data.  If we are asked to
-    // look up information for a different Merge_map, we report that
-    // we don't have it, rather than trying a lookup and returning an
-    // answer which will receive the wrong offset.
-    const Merge_map* merge_map;
-    // The list of mappings.
-    std::vector<Input_merge_entry> entries;
-    // Whether the ENTRIES field is sorted by input_offset.
-    bool sorted;
-
-    Input_merge_map()
-      : merge_map(NULL), entries(), sorted(true)
-    { }
-  };
-
-  // Map input section indices to merge maps.
-  typedef std::map<unsigned int, Input_merge_map*> Section_merge_maps;
-
-  // Return a pointer to the Input_merge_map to use for the input
-  // section SHNDX, or NULL.
-  Input_merge_map*
-  get_input_merge_map(unsigned int shndx);
-
-  // Get or make the the Input_merge_map to use for the section SHNDX
-  // with MERGE_MAP.
-  Input_merge_map*
-  get_or_make_input_merge_map(const Merge_map* merge_map, unsigned int shndx);
-
-  // Any given object file will normally only have a couple of input
-  // sections with mergeable contents.  So we keep the first two input
-  // section numbers inline, and push any further ones into a map.  A
-  // value of -1U in first_shnum_ or second_shnum_ means that we don't
-  // have a corresponding entry.
-  unsigned int first_shnum_;
-  Input_merge_map first_map_;
-  unsigned int second_shnum_;
-  Input_merge_map second_map_;
-  Section_merge_maps section_merge_maps_;
-};
+// Class Object_merge_map.
 
 // Destructor.
 
@@ -261,7 +147,8 @@ Object_merge_map::get_output_offset(const Merge_map* merge_map,
 				    section_offset_type *output_offset)
 {
   Input_merge_map* map = this->get_input_merge_map(shndx);
-  if (map == NULL || map->merge_map != merge_map)
+  if (map == NULL
+      || (merge_map != NULL && map->merge_map != merge_map))
     return false;
 
   if (!map->sorted)
@@ -294,6 +181,49 @@ Object_merge_map::get_output_offset(const Merge_map* merge_map,
   return true;
 }
 
+// Return whether this is the merge map for section SHNDX.
+
+inline bool
+Object_merge_map::is_merge_section_for(const Merge_map* merge_map,
+				       unsigned int shndx)
+{
+  Input_merge_map* map = this->get_input_merge_map(shndx);
+  return map != NULL && map->merge_map == merge_map;
+}
+
+// Initialize a mapping from input offsets to output addresses.
+
+template<int size>
+void
+Object_merge_map::initialize_input_to_output_map(
+    unsigned int shndx,
+    typename elfcpp::Elf_types<size>::Elf_Addr starting_address,
+    Unordered_map<section_offset_type,
+		  typename elfcpp::Elf_types<size>::Elf_Addr>* initialize_map)
+{
+  Input_merge_map* map = this->get_input_merge_map(shndx);
+  gold_assert(map != NULL);
+
+  for (Input_merge_map::Entries::const_iterator p = map->entries.begin();
+       p != map->entries.end();
+       ++p)
+    {
+      section_offset_type output_offset = p->output_offset;
+      if (output_offset != -1)
+	output_offset += starting_address;
+      else
+	{
+	  // If we see a relocation against an address we have chosen
+	  // to discard, we relocate to zero.  FIXME: We could also
+	  // issue a warning in this case; that would require
+	  // reporting this somehow and checking it in the routines in
+	  // reloc.h.
+	  output_offset = 0;
+	}
+      initialize_map->insert(std::make_pair(p->input_offset, output_offset));
+    }
+}
+
 // Class Merge_map.
 
 // Add a mapping for the bytes from OFFSET to OFFSET + LENGTH in input
@@ -333,6 +263,17 @@ Merge_map::get_output_offset(const Relobj* object, unsigned int shndx,
 					     output_offset);
 }
 
+// Return whether this is the merge section for SHNDX in OBJECT.
+
+bool
+Merge_map::is_merge_section_for(const Relobj* object, unsigned int shndx) const
+{
+  Object_merge_map* object_merge_map = object->merge_map();
+  if (object_merge_map == NULL)
+    return false;
+  return object_merge_map->is_merge_section_for(this, shndx);
+}
+
 // Class Output_merge_base.
 
 // Return the output offset for an input offset.  The input address is
@@ -348,6 +289,15 @@ Output_merge_base::do_output_offset(const Relobj* object,
   return this->merge_map_.get_output_offset(object, shndx, offset, poutput);
 }
 
+// Return whether this is the merge section for SHNDX in OBJECT.
+
+bool
+Output_merge_base::do_is_merge_section_for(const Relobj* object,
+					   unsigned int shndx) const
+{
+  return this->merge_map_.is_merge_section_for(object, shndx);
+}
+
 // Class Output_merge_data.
 
 // Compute the hash code for a fixed-size constant.
@@ -666,4 +616,22 @@ class Output_merge_string<uint16_t>;
 template
 class Output_merge_string<uint32_t>;
 
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+template
+void
+Object_merge_map::initialize_input_to_output_map<32>(
+    unsigned int shndx,
+    elfcpp::Elf_types<32>::Elf_Addr starting_address,
+    Unordered_map<section_offset_type, elfcpp::Elf_types<32>::Elf_Addr>*);
+#endif
+
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+template
+void
+Object_merge_map::initialize_input_to_output_map<64>(
+    unsigned int shndx,
+    elfcpp::Elf_types<64>::Elf_Addr starting_address,
+    Unordered_map<section_offset_type, elfcpp::Elf_types<64>::Elf_Addr>*);
+#endif
+
 } // End namespace gold.
diff --git a/gold/merge.h b/gold/merge.h
index c232ab0..c385a44 100644
--- a/gold/merge.h
+++ b/gold/merge.h
@@ -24,6 +24,8 @@
 #define GOLD_MERGE_H
 
 #include <climits>
+#include <map>
+#include <vector>
 
 #include "stringpool.h"
 #include "output.h"
@@ -31,6 +33,142 @@
 namespace gold
 {
 
+class Merge_map;
+
+// For each object with merge sections, we store an Object_merge_map.
+// This is used to map locations in input sections to a merged output
+// section.  The output section itself is not recorded here--it can be
+// found in the map_to_output_ field of the Object.
+
+class Object_merge_map
+{
+ public:
+  Object_merge_map()
+    : first_shnum_(-1U), first_map_(),
+      second_shnum_(-1U), second_map_(),
+      section_merge_maps_()
+  { }
+
+  ~Object_merge_map();
+
+  // Add a mapping for MERGE_MAP, for the bytes from OFFSET to OFFSET
+  // + LENGTH in the input section SHNDX to OUTPUT_OFFSET in the
+  // output section.  An OUTPUT_OFFSET of -1 means that the bytes are
+  // discarded.  OUTPUT_OFFSET is relative to the start of the merged
+  // data in the output section.
+  void
+  add_mapping(const Merge_map*, unsigned int shndx, section_offset_type offset,
+	      section_size_type length, section_offset_type output_offset);
+
+  // Get the output offset for an input address.  MERGE_MAP is the map
+  // we are looking for, or NULL if we don't care.  The input address
+  // is at offset OFFSET in section SHNDX.  This sets *OUTPUT_OFFSET
+  // to the offset in the output section; this will be -1 if the bytes
+  // are not being copied to the output.  This returns true if the
+  // mapping is known, false otherwise.  *OUTPUT_OFFSET is relative to
+  // the start of the merged data in the output section.
+  bool
+  get_output_offset(const Merge_map*, unsigned int shndx,
+		    section_offset_type offset,
+		    section_offset_type *output_offset);
+
+  // Return whether this is the merge map for section SHNDX.
+  bool
+  is_merge_section_for(const Merge_map*, unsigned int shndx);
+
+  // Initialize an mapping from input offsets to output addresses for
+  // section SHNDX.  STARTING_ADDRESS is the output address of the
+  // merged section.
+  template<int size>
+  void
+  initialize_input_to_output_map(
+      unsigned int shndx,
+      typename elfcpp::Elf_types<size>::Elf_Addr starting_address,
+      Unordered_map<section_offset_type,
+		    typename elfcpp::Elf_types<size>::Elf_Addr>*);
+
+ private:
+  // Map input section offsets to a length and an output section
+  // offset.  An output section offset of -1 means that this part of
+  // the input section is being discarded.
+  struct Input_merge_entry
+  {
+    // The offset in the input section.
+    section_offset_type input_offset;
+    // The length.
+    section_size_type length;
+    // The offset in the output section.
+    section_offset_type output_offset;
+  };
+
+  // A less-than comparison routine for Input_merge_entry.
+  struct Input_merge_compare
+  {
+    bool
+    operator()(const Input_merge_entry& i1, const Input_merge_entry& i2) const
+    { return i1.input_offset < i2.input_offset; }
+  };
+
+  // A list of entries for a particular input section.
+  struct Input_merge_map
+  {
+    typedef std::vector<Input_merge_entry> Entries;
+
+    // We store these with the Relobj, and we look them up by input
+    // section.  It is possible to have two different merge maps
+    // associated with a single output section.  For example, this
+    // happens routinely with .rodata, when merged string constants
+    // and merged fixed size constants are both put into .rodata.  The
+    // output offset that we store is not the offset from the start of
+    // the output section; it is the offset from the start of the
+    // merged data in the output section.  That means that the caller
+    // is going to add the offset of the merged data within the output
+    // section, which means that the caller needs to know which set of
+    // merged data it found the entry in.  So it's not enough to find
+    // this data based on the input section and the output section; we
+    // also have to find it based on a set of merged data in the
+    // output section.  In order to verify that we are looking at the
+    // right data, we store a pointer to the Merge_map here, and we
+    // pass in a pointer when looking at the data.  If we are asked to
+    // look up information for a different Merge_map, we report that
+    // we don't have it, rather than trying a lookup and returning an
+    // answer which will receive the wrong offset.
+    const Merge_map* merge_map;
+    // The list of mappings.
+    Entries entries;
+    // Whether the ENTRIES field is sorted by input_offset.
+    bool sorted;
+
+    Input_merge_map()
+      : merge_map(NULL), entries(), sorted(true)
+    { }
+  };
+
+  // Map input section indices to merge maps.
+  typedef std::map<unsigned int, Input_merge_map*> Section_merge_maps;
+
+  // Return a pointer to the Input_merge_map to use for the input
+  // section SHNDX, or NULL.
+  Input_merge_map*
+  get_input_merge_map(unsigned int shndx);
+
+  // Get or make the the Input_merge_map to use for the section SHNDX
+  // with MERGE_MAP.
+  Input_merge_map*
+  get_or_make_input_merge_map(const Merge_map* merge_map, unsigned int shndx);
+
+  // Any given object file will normally only have a couple of input
+  // sections with mergeable contents.  So we keep the first two input
+  // section numbers inline, and push any further ones into a map.  A
+  // value of -1U in first_shnum_ or second_shnum_ means that we don't
+  // have a corresponding entry.
+  unsigned int first_shnum_;
+  Input_merge_map first_map_;
+  unsigned int second_shnum_;
+  Input_merge_map second_map_;
+  Section_merge_maps section_merge_maps_;
+};
+
 // This class manages mappings from input sections to offsets in an
 // output section.  This is used where input sections are merged.  The
 // actual data is stored in fields in Object.
@@ -63,6 +201,12 @@ class Merge_map
   get_output_offset(const Relobj* object, unsigned int shndx,
 		    section_offset_type offset,
 		    section_offset_type *output_offset) const;
+
+  // Return whether this is the merge mapping for section SHNDX in
+  // OBJECT.  This should return true when get_output_offset would
+  // return true for some input offset.
+  bool
+  is_merge_section_for(const Relobj* object, unsigned int shndx) const;
 };
 
 // A general class for SHF_MERGE data, to hold functions shared by
@@ -75,13 +219,17 @@ class Output_merge_base : public Output_section_data
     : Output_section_data(addralign), merge_map_(), entsize_(entsize)
   { }
 
+ protected:
   // Return the output offset for an input offset.
   bool
   do_output_offset(const Relobj* object, unsigned int shndx,
 		   section_offset_type offset,
 		   section_offset_type* poutput) const;
 
- protected:
+  // Return whether this is the merge section for an input section.
+  bool
+  do_is_merge_section_for(const Relobj*, unsigned int shndx) const;
+
   // Return the entry size.
   uint64_t
   entsize() const
diff --git a/gold/object.cc b/gold/object.cc
index 5216049..e92a66d 100644
--- a/gold/object.cc
+++ b/gold/object.cc
@@ -889,14 +889,30 @@ Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
 	    }
 	  else if (mo[shndx].offset == -1)
 	    {
-	      // Leave the input value in place for SHF_MERGE sections.
+	      // This is a SHF_MERGE section or one which otherwise
+	      // requires special handling.  We get the output address
+	      // of the start of the merged section.  If this is not a
+	      // section symbol, we can then determine the final
+	      // value.  If it is a section symbol, we can not, as in
+	      // that case we have to consider the addend to determine
+	      // the value to use in a relocation.
+	      section_offset_type start =
+		os->starting_output_address(this, shndx);
+	      if (!lv.is_section_symbol())
+		lv.set_output_value(lv.input_value() + start);
+	      else
+		{
+		  Merged_symbol_value<size>* msv =
+		    new Merged_symbol_value<size>(lv.input_value(), start);
+		  lv.set_merged_symbol_value(msv);
+		}
 	    }
           else if (lv.is_tls_symbol())
-	    lv.set_output_value(mo[shndx].output_section->tls_offset()
+	    lv.set_output_value(os->tls_offset()
 				+ mo[shndx].offset
 				+ lv.input_value());
 	  else
-	    lv.set_output_value(mo[shndx].output_section->address()
+	    lv.set_output_value(os->address()
 				+ mo[shndx].offset
 				+ lv.input_value());
 	}
@@ -953,40 +969,6 @@ Sized_relobj<size, big_endian>::local_symbol_value(unsigned int symndx) const
   return lv.value(this, 0);
 }
 
-// Return the value of a local symbol defined in input section SHNDX,
-// with value VALUE, adding addend ADDEND.  IS_SECTION_SYMBOL
-// indicates whether the symbol is a section symbol.  This handles
-// SHF_MERGE sections.
-template<int size, bool big_endian>
-typename elfcpp::Elf_types<size>::Elf_Addr
-Sized_relobj<size, big_endian>::local_value(unsigned int shndx,
-					    Address value,
-					    bool is_section_symbol,
-					    Address addend) const
-{
-  const std::vector<Map_to_output>& mo(this->map_to_output());
-  Output_section* os = mo[shndx].output_section;
-  if (os == NULL)
-    return addend;
-  gold_assert(mo[shndx].offset == -1);
-
-  // Do the mapping required by the output section.  If this is not a
-  // section symbol, then we want to map the symbol value, and then
-  // include the addend.  If this is a section symbol, then we need to
-  // include the addend to figure out where in the section we are,
-  // before we do the mapping.  This will do the right thing provided
-  // the assembler is careful to only convert a relocation in a merged
-  // section to a section symbol if there is a zero addend.  If the
-  // assembler does not do this, then in general we can't know what to
-  // do, because we can't distinguish the addend for the instruction
-  // format from the addend for the section offset.
-
-  if (is_section_symbol)
-    return os->output_address(this, shndx, value + addend);
-  else
-    return addend + os->output_address(this, shndx, value);
-}
-
 // Write out the local symbols.
 
 template<int size, bool big_endian>
diff --git a/gold/object.h b/gold/object.h
index 1ad9796..f5e4ab6 100644
--- a/gold/object.h
+++ b/gold/object.h
@@ -622,6 +622,71 @@ Relobj::output_section(unsigned int shndx, section_offset_type* poff) const
   return mo.output_section;
 }
 
+// This class is used to handle relocations against a section symbol
+// in an SHF_MERGE section.  For such a symbol, we need to know the
+// addend of the relocation before we can determine the final value.
+// The addend gives us the location in the input section, and we can
+// determine how it is mapped to the output section.  For a
+// non-section symbol, we apply the addend to the final value of the
+// symbol; that is done in finalize_local_symbols, and does not use
+// this class.
+
+template<int size>
+class Merged_symbol_value
+{
+ public:
+  typedef typename elfcpp::Elf_types<size>::Elf_Addr Value;
+
+  // We use a hash table to map offsets in the input section to output
+  // addresses.
+  typedef Unordered_map<section_offset_type, Value> Output_addresses;
+
+  Merged_symbol_value(Value input_value, Value output_start_address)
+    : input_value_(input_value), output_start_address_(output_start_address),
+      output_addresses_()
+  { }
+
+  // Initialize the hash table.
+  void
+  initialize_input_to_output_map(const Relobj*, unsigned int input_shndx);
+
+  // Release the hash table to save space.
+  void
+  free_input_to_output_map()
+  { this->output_addresses_.clear(); }
+
+  // Get the output value corresponding to an addend.  The object and
+  // input section index are passed in because the caller will have
+  // them; otherwise we could store them here.
+  Value
+  value(const Relobj* object, unsigned int input_shndx, Value addend) const
+  {
+    Value input_offset = this->input_value_ + addend;
+    typename Output_addresses::const_iterator p =
+      this->output_addresses_.find(input_offset);
+    if (p != this->output_addresses_.end())
+      return p->second;
+
+    return this->value_from_output_section(object, input_shndx, input_offset);
+  }
+
+ private:
+  // Get the output value for an input offset if we couldn't find it
+  // in the hash table.
+  Value
+  value_from_output_section(const Relobj*, unsigned int input_shndx,
+			    Value input_offset) const;
+
+  // The value of the section symbol in the input file.  This is
+  // normally zero, but could in principle be something else.
+  Value input_value_;
+  // The start address of this merged section in the output file.
+  Value output_start_address_;
+  // A hash table which maps offsets in the input section to output
+  // addresses.  This only maps specific offsets, not all offsets.
+  Output_addresses output_addresses_;
+};
+
 // This POD class is holds the value of a symbol.  This is used for
 // local symbols, and for all symbols during relocation processing.
 // For special sections, such as SHF_MERGE sections, this calls a
@@ -636,8 +701,8 @@ class Symbol_value
   Symbol_value()
     : output_symtab_index_(0), output_dynsym_index_(-1U), input_shndx_(0),
       is_section_symbol_(false), is_tls_symbol_(false),
-      needs_output_address_(false), value_(0)
-  { }
+      has_output_value_(true)
+  { this->u_.value = 0; }
 
   // Get the value of this symbol.  OBJECT is the object in which this
   // symbol is defined, and ADDEND is an addend to add to the value.
@@ -645,41 +710,64 @@ class Symbol_value
   Value
   value(const Sized_relobj<size, big_endian>* object, Value addend) const
   {
-    if (!this->needs_output_address_)
-      return this->value_ + addend;
-    return object->local_value(this->input_shndx_, this->value_,
-			       this->is_section_symbol_, addend);
+    if (this->has_output_value_)
+      return this->u_.value + addend;
+    else
+      return this->u_.merged_symbol_value->value(object, this->input_shndx_,
+						 addend);
   }
 
   // Set the value of this symbol in the output symbol table.
   void
   set_output_value(Value value)
+  { this->u_.value = value; }
+
+  // For a section symbol in a merged section, we need more
+  // information.
+  void
+  set_merged_symbol_value(Merged_symbol_value<size>* msv)
   {
-    this->value_ = value;
-    this->needs_output_address_ = false;
+    gold_assert(this->is_section_symbol_);
+    this->has_output_value_ = false;
+    this->u_.merged_symbol_value = msv;
   }
 
-  // Set the value of the symbol from the input file.  This value
-  // will usually be replaced during finalization with the output
-  // value, but if the symbol is mapped to an output section which
-  // requires special handling to determine the output value, we
-  // leave the input value in place until later.  This is used for
-  // SHF_MERGE sections.
+  // Initialize the input to output map for a section symbol in a
+  // merged section.  We also initialize the value of a non-section
+  // symbol in a merged section.
   void
-  set_input_value(Value value)
+  initialize_input_to_output_map(const Relobj* object)
   {
-    this->value_ = value;
-    this->needs_output_address_ = true;
+    if (!this->has_output_value_)
+      {
+	gold_assert(this->is_section_symbol_);
+	Merged_symbol_value<size>* msv = this->u_.merged_symbol_value;
+	msv->initialize_input_to_output_map(object, this->input_shndx_);
+      }
   }
 
-  // Return the input value.
-  Value
-  input_value() const
+  // Free the input to output map for a section symbol in a merged
+  // section.
+  void
+  free_input_to_output_map()
   {
-    gold_assert(this->needs_output_address_);
-    return this->value_;
+    if (!this->has_output_value_)
+      this->u_.merged_symbol_value->free_input_to_output_map();
   }
 
+  // Set the value of the symbol from the input file.  This is only
+  // called by count_local_symbols, to communicate the value to
+  // finalize_local_symbols.
+  void
+  set_input_value(Value value)
+  { this->u_.value = value; }
+
+  // Return the input value.  This is only called by
+  // finalize_local_symbols.
+  Value
+  input_value() const
+  { return this->u_.value; }
+
   // Return whether this symbol should go into the output symbol
   // table.
   bool
@@ -757,6 +845,11 @@ class Symbol_value
   input_shndx() const
   { return this->input_shndx_; }
 
+  // Whether this is a section symbol.
+  bool
+  is_section_symbol() const
+  { return this->is_section_symbol_; }
+
   // Record that this is a section symbol.
   void
   set_is_section_symbol()
@@ -786,14 +879,23 @@ class Symbol_value
   bool is_section_symbol_ : 1;
   // Whether this is a STT_TLS symbol.
   bool is_tls_symbol_ : 1;
-  // Whether getting the value of this symbol requires calling an
-  // Output_section method.  For example, this will be true of a
-  // symbol in a SHF_MERGE section.
-  bool needs_output_address_ : 1;
-  // The value of the symbol.  If !needs_output_address_, this is the
-  // value in the output file.  If needs_output_address_, this is the
-  // value in the input file.
-  Value value_;
+  // Whether this symbol has a value for the output file.  This is
+  // normally set to true during Layout::finalize, by
+  // finalize_local_symbols.  It will be false for a section symbol in
+  // a merge section, as for such symbols we can not determine the
+  // value to use in a relocation until we see the addend.
+  bool has_output_value_ : 1;
+  union
+  {
+    // This is used if has_output_value_ is true.  Between
+    // count_local_symbols and finalize_local_symbols, this is the
+    // value in the input file.  After finalize_local_symbols, it is
+    // the value in the output file.
+    Value value;
+    // This is used if has_output_value_ is false.  It points to the
+    // information we need to get the value for a merge section.
+    Merged_symbol_value<size>* merged_symbol_value;
+  } u_;
 };
 
 // A regular object file.  This is size and endian specific.
@@ -876,14 +978,6 @@ class Sized_relobj : public Relobj
   Address
   local_symbol_value(unsigned int symndx) const;
 
-  // Return the value of a local symbol defined in input section
-  // SHNDX, with value VALUE, adding addend ADDEND.  IS_SECTION_SYMBOL
-  // indicates whether the symbol is a section symbol.  This handles
-  // SHF_MERGE sections.
-  Address
-  local_value(unsigned int shndx, Address value, bool is_section_symbol,
-	      Address addend) const;
-
   void
   set_needs_output_dynsym_entry(unsigned int sym)
   {
@@ -1119,6 +1213,16 @@ class Sized_relobj : public Relobj
   relocate_sections(const General_options& options, const Symbol_table*,
 		    const Layout*, const unsigned char* pshdrs, Views*);
 
+  // Initialize input to output maps for section symbols in merged
+  // sections.
+  void
+  initialize_input_to_output_maps();
+
+  // Free the input to output maps for section symbols in merged
+  // sections.
+  void
+  free_input_to_output_maps();
+
   // Write out the local symbols.
   void
   write_local_symbols(Output_file*,
diff --git a/gold/output.cc b/gold/output.cc
index 793d6a3..3d1d27e 100644
--- a/gold/output.cc
+++ b/gold/output.cc
@@ -1369,6 +1369,18 @@ Output_section::Input_section::output_offset(
     }
 }
 
+// Return whether this is the merge section for the input section
+// SHNDX in OBJECT.
+
+inline bool
+Output_section::Input_section::is_merge_section_for(const Relobj* object,
+						    unsigned int shndx) const
+{
+  if (this->is_input_section())
+    return false;
+  return this->u2_.posd->is_merge_section_for(object, shndx);
+}
+
 // Write out the data.  We don't have to do anything for an input
 // section--they are handled via Object::relocate--but this is where
 // we write out the data for an Output_section_data.
@@ -1710,6 +1722,34 @@ Output_section::output_address(const Relobj* object, unsigned int shndx,
   gold_unreachable();
 }
 
+// Return the output address of the start of the merged section for
+// input section SHNDX in object OBJECT.
+
+uint64_t
+Output_section::starting_output_address(const Relobj* object,
+					unsigned int shndx) const
+{
+  gold_assert(object->is_section_specially_mapped(shndx));
+
+  uint64_t addr = this->address() + this->first_input_offset_;
+  for (Input_section_list::const_iterator p = this->input_sections_.begin();
+       p != this->input_sections_.end();
+       ++p)
+    {
+      addr = align_address(addr, p->addralign());
+
+      // It would be nice if we could use the existing output_offset
+      // method to get the output offset of input offset 0.
+      // Unfortunately we don't know for sure that input offset 0 is
+      // mapped at all.
+      if (p->is_merge_section_for(object, shndx))
+	return addr;
+
+      addr += p->data_size();
+    }
+  gold_unreachable();
+}
+
 // Set the data size of an Output_section.  This is where we handle
 // setting the addresses of any Output_section_data objects.
 
diff --git a/gold/output.h b/gold/output.h
index 895d703..3d1a44d 100644
--- a/gold/output.h
+++ b/gold/output.h
@@ -198,6 +198,21 @@ class Output_data
   dynamic_reloc_count() const
   { return this->dynamic_reloc_count_; }
 
+  // Whether the address is valid.
+  bool
+  is_address_valid() const
+  { return this->is_address_valid_; }
+
+  // Whether the file offset is valid.
+  bool
+  is_offset_valid() const
+  { return this->is_offset_valid_; }
+
+  // Whether the data size is valid.
+  bool
+  is_data_size_valid() const
+  { return this->is_data_size_valid_; }
+
  protected:
   // Functions that child classes may or in some cases must implement.
 
@@ -256,21 +271,6 @@ class Output_data
 
   // Functions that child classes may call.
 
-  // Whether the address is valid.
-  bool
-  is_address_valid() const
-  { return this->is_address_valid_; }
-
-  // Whether the file offset is valid.
-  bool
-  is_offset_valid() const
-  { return this->is_offset_valid_; }
-
-  // Whether the data size is valid.
-  bool
-  is_data_size_valid() const
-  { return this->is_data_size_valid_; }
-
   // Set the size of the data.
   void
   set_data_size(off_t data_size)
@@ -466,6 +466,13 @@ class Output_section_data : public Output_data
 		section_offset_type *poutput) const
   { return this->do_output_offset(object, shndx, offset, poutput); }
 
+  // Return whether this is the merge section for the input section
+  // SHNDX in OBJECT.  This should return true when output_offset
+  // would return true for some values of OFFSET.
+  bool
+  is_merge_section_for(const Relobj* object, unsigned int shndx) const
+  { return this->do_is_merge_section_for(object, shndx); }
+
   // Write the contents to a buffer.  This is used for sections which
   // require postprocessing, such as compression.
   void
@@ -499,6 +506,11 @@ class Output_section_data : public Output_data
 		   section_offset_type*) const
   { return false; }
 
+  // The child class may implement is_merge_section_for.
+  virtual bool
+  do_is_merge_section_for(const Relobj*, unsigned int) const
+  { return false; }
+
   // The child class may implement write_to_buffer.  Most child
   // classes can not appear in a compressed section, and they do not
   // implement this.
@@ -1683,6 +1695,13 @@ class Output_section : public Output_data
   output_address(const Relobj* object, unsigned int shndx,
 		 off_t offset) const;
 
+  // Return the output address of the start of the merged section for
+  // input section SHNDX in object OBJECT.  This is not necessarily
+  // the offset corresponding to input offset 0 in the section, since
+  // the section may be mapped arbitrarily.
+  uint64_t
+  starting_output_address(const Relobj* object, unsigned int shndx) const;
+
   // Write the section header into *OPHDR.
   template<int size, bool big_endian>
   void
@@ -1904,6 +1923,11 @@ class Output_section : public Output_data
 		  section_offset_type offset,
 		  section_offset_type *poutput) const;
 
+    // Return whether this is the merge section for the input section
+    // SHNDX in OBJECT.
+    bool
+    is_merge_section_for(const Relobj* object, unsigned int shndx) const;
+
     // Write out the data.  This does nothing for an input section.
     void
     write(Output_file*);
diff --git a/gold/reloc.cc b/gold/reloc.cc
index 37a9a85..e9c1326 100644
--- a/gold/reloc.cc
+++ b/gold/reloc.cc
@@ -23,9 +23,10 @@
 #include "gold.h"
 
 #include "workqueue.h"
-#include "object.h"
 #include "symtab.h"
 #include "output.h"
+#include "merge.h"
+#include "object.h"
 #include "reloc.h"
 
 namespace gold
@@ -343,10 +344,18 @@ Sized_relobj<size, big_endian>::do_relocate(const General_options& options,
 
   this->write_sections(pshdrs, of, &views);
 
+  // To speed up relocations, we set up hash tables for fast lookup of
+  // input offsets to output addresses.
+  this->initialize_input_to_output_maps();
+
   // Apply relocations.
 
   this->relocate_sections(options, symtab, layout, pshdrs, &views);
 
+  // After we've done the relocations, we release the hash tables,
+  // since we no longer need them.
+  this->free_input_to_output_maps();
+
   // Write out the accumulated views.
   for (unsigned int i = 1; i < shnum; ++i)
     {
@@ -584,6 +593,76 @@ Sized_relobj<size, big_endian>::relocate_sections(
     }
 }
 
+// Create merge hash tables for the local symbols.  These are used to
+// speed up relocations.
+
+template<int size, bool big_endian>
+void
+Sized_relobj<size, big_endian>::initialize_input_to_output_maps()
+{
+  const unsigned int loccount = this->local_symbol_count_;
+  for (unsigned int i = 1; i < loccount; ++i)
+    {
+      Symbol_value<size>& lv(this->local_values_[i]);
+      lv.initialize_input_to_output_map(this);
+    }
+}
+
+// Free merge hash tables for the local symbols.
+
+template<int size, bool big_endian>
+void
+Sized_relobj<size, big_endian>::free_input_to_output_maps()
+{
+  const unsigned int loccount = this->local_symbol_count_;
+  for (unsigned int i = 1; i < loccount; ++i)
+    {
+      Symbol_value<size>& lv(this->local_values_[i]);
+      lv.free_input_to_output_map();
+    }
+}
+
+// Class Merged_symbol_value.
+
+template<int size>
+void
+Merged_symbol_value<size>::initialize_input_to_output_map(
+    const Relobj* object,
+    unsigned int input_shndx)
+{
+  Object_merge_map* map = object->merge_map();
+  map->initialize_input_to_output_map<size>(input_shndx,
+					    this->output_start_address_,
+					    &this->output_addresses_);
+}
+
+// Get the output value corresponding to an input offset if we
+// couldn't find it in the hash table.
+
+template<int size>
+typename elfcpp::Elf_types<size>::Elf_Addr
+Merged_symbol_value<size>::value_from_output_section(
+    const Relobj* object,
+    unsigned int input_shndx,
+    typename elfcpp::Elf_types<size>::Elf_Addr input_offset) const
+{
+  section_offset_type output_offset;
+  bool found = object->merge_map()->get_output_offset(NULL, input_shndx,
+						      input_offset,
+						      &output_offset);
+
+  // If this assertion fails, it means that some relocation was
+  // against a portion of an input merge section which we didn't map
+  // to the output file and we didn't explicitly discard.  We should
+  // always map all portions of input merge sections.
+  gold_assert(found);
+
+  if (output_offset == -1)
+    return 0;
+  else
+    return this->output_start_address_ + output_offset;
+}
+
 // Copy_relocs::Copy_reloc_entry methods.
 
 // Return whether we should emit this reloc.  We should emit it if the
@@ -917,6 +996,26 @@ Sized_relobj<64, true>::do_relocate(const General_options& options,
 				    Output_file* of);
 #endif
 
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+template
+class Merged_symbol_value<32>;
+#endif
+
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+template
+class Merged_symbol_value<64>;
+#endif
+
+#if defined(HAVE_TARGET_32_LITTLE) || defined(HAVE_TARGET_32_BIG)
+template
+class Symbol_value<32>;
+#endif
+
+#if defined(HAVE_TARGET_64_LITTLE) || defined(HAVE_TARGET_64_BIG)
+template
+class Symbol_value<64>;
+#endif
+
 #ifdef HAVE_TARGET_32_LITTLE
 template
 class Copy_relocs<32, false>;