Hash tables, dynamic section, i386 PLT, gold_assert.

30 files changed, 2221 insertions, 614 deletions

diff --git a/gold/common.cc b/gold/common.cc
index 7ba8adc..e83219c 100644
--- a/gold/common.cc
+++ b/gold/common.cc
@@ -120,7 +120,7 @@ Symbol_table::allocate_commons(const General_options& options, Layout* layout)
   else if (this->get_size() == 64)
     this->do_allocate_commons<64>(options, layout);
   else
-    abort();
+    gold_unreachable();
 }
 
 // Allocated the common symbols, sized version.
@@ -171,7 +171,7 @@ Symbol_table::do_allocate_commons(const General_options&,
 
   // Place them in a newly allocated .bss section.
 
-  Output_data_common *poc = new Output_data_common(addralign);
+  Output_data_space *poc = new Output_data_space(addralign);
 
   layout->add_output_section_data(".bss", elfcpp::SHT_NOBITS,
 				  elfcpp::SHF_WRITE | elfcpp::SHF_ALLOC,
@@ -202,7 +202,7 @@ Symbol_table::do_allocate_commons(const General_options&,
       off += symsize;
     }
 
-  poc->set_common_size(off);
+  poc->set_space_size(off);
 
   this->commons_.clear();
 }
diff --git a/gold/dirsearch.cc b/gold/dirsearch.cc
index 5dec3f6..d1298d8 100644
--- a/gold/dirsearch.cc
+++ b/gold/dirsearch.cc
@@ -3,7 +3,6 @@
 #include "gold.h"
 
 #include <cerrno>
-#include <cassert>
 #include <sys/types.h>
 #include <dirent.h>
 
@@ -125,7 +124,7 @@ Dir_caches::add(const char* dirname)
 
     std::pair<const char*, Dir_cache*> v(dirname, cache);
     std::pair<Cache_hash::iterator, bool> p = this->caches_.insert(v);
-    assert(p.second);
+    gold_assert(p.second);
   }
 }
 
@@ -217,14 +216,14 @@ Dirsearch::add(Workqueue* workqueue, const General_options::Dir_list& list)
 std::string
 Dirsearch::find(const std::string& n1, const std::string& n2) const
 {
-  assert(!this->token_.is_blocked());
+  gold_assert(!this->token_.is_blocked());
 
   for (std::list<const char*>::const_iterator p = this->directories_.begin();
        p != this->directories_.end();
        ++p)
     {
       Dir_cache* pdc = caches.lookup(*p);
-      assert(pdc != NULL);
+      gold_assert(pdc != NULL);
       if (pdc->find(n1))
 	return std::string(*p) + '/' + n1;
       if (!n2.empty() && pdc->find(n2))
diff --git a/gold/dynobj.cc b/gold/dynobj.cc
index ba1fb15..ac5a74b 100644
--- a/gold/dynobj.cc
+++ b/gold/dynobj.cc
@@ -5,12 +5,25 @@
 #include <vector>
 #include <cstring>
 
+#include "elfcpp.h"
 #include "symtab.h"
 #include "dynobj.h"
 
 namespace gold
 {
 
+// Class Dynobj.
+
+// Return the string to use in a DT_NEEDED entry.
+
+const char*
+Dynobj::soname() const
+{
+  if (!this->soname_.empty())
+    return this->soname_.c_str();
+  return this->name().c_str();
+}
+
 // Class Sized_dynobj.
 
 template<int size, bool big_endian>
@@ -20,8 +33,7 @@ Sized_dynobj<size, big_endian>::Sized_dynobj(
     off_t offset,
     const elfcpp::Ehdr<size, big_endian>& ehdr)
   : Dynobj(name, input_file, offset),
-    elf_file_(this, ehdr),
-    soname_()
+    elf_file_(this, ehdr)
 {
 }
 
@@ -130,7 +142,7 @@ Sized_dynobj<size, big_endian>::read_dynsym_section(
 
   typename This::Shdr shdr(pshdrs + shndx * This::shdr_size);
 
-  assert(shdr.get_sh_type() == type);
+  gold_assert(shdr.get_sh_type() == type);
 
   if (shdr.get_sh_link() != link)
     {
@@ -146,11 +158,11 @@ Sized_dynobj<size, big_endian>::read_dynsym_section(
   *view_info = shdr.get_sh_info();
 }
 
-// Set soname_ if this shared object has a DT_SONAME tag.  PSHDRS
-// points to the section headers.  DYNAMIC_SHNDX is the section index
-// of the SHT_DYNAMIC section.  STRTAB_SHNDX, STRTAB, and STRTAB_SIZE
-// are the section index and contents of a string table which may be
-// the one associated with the SHT_DYNAMIC section.
+// Set the soname field if this shared object has a DT_SONAME tag.
+// PSHDRS points to the section headers.  DYNAMIC_SHNDX is the section
+// index of the SHT_DYNAMIC section.  STRTAB_SHNDX, STRTAB, and
+// STRTAB_SIZE are the section index and contents of a string table
+// which may be the one associated with the SHT_DYNAMIC section.
 
 template<int size, bool big_endian>
 void
@@ -161,7 +173,7 @@ Sized_dynobj<size, big_endian>::set_soname(const unsigned char* pshdrs,
 					   off_t strtab_size)
 {
   typename This::Shdr dynamicshdr(pshdrs + dynamic_shndx * This::shdr_size);
-  assert(dynamicshdr.get_sh_type() == elfcpp::SHT_DYNAMIC);
+  gold_assert(dynamicshdr.get_sh_type() == elfcpp::SHT_DYNAMIC);
 
   const off_t dynamic_size = dynamicshdr.get_sh_size();
   const unsigned char* pdynamic = this->get_view(dynamicshdr.get_sh_offset(),
@@ -214,7 +226,7 @@ Sized_dynobj<size, big_endian>::set_soname(const unsigned char* pshdrs,
 	    }
 
 	  const char* strtab = reinterpret_cast<const char*>(strtabu);
-	  this->soname_ = std::string(strtab + val);
+	  this->set_soname_string(strtab + val);
 	  return;
 	}
 
@@ -259,7 +271,7 @@ Sized_dynobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
     {
       // Get the dynamic symbols.
       typename This::Shdr dynsymshdr(pshdrs + dynsym_shndx * This::shdr_size);
-      assert(dynsymshdr.get_sh_type() == elfcpp::SHT_DYNSYM);
+      gold_assert(dynsymshdr.get_sh_type() == elfcpp::SHT_DYNSYM);
 
       sd->symbols = this->get_lasting_view(dynsymshdr.get_sh_offset(),
 					   dynsymshdr.get_sh_size());
@@ -380,7 +392,7 @@ Sized_dynobj<size, big_endian>::set_version_map(
     unsigned int ndx,
     const char* name) const
 {
-  assert(ndx < version_map->size());
+  gold_assert(ndx < version_map->size());
   if ((*version_map)[ndx] != NULL)
     {
       fprintf(stderr, _("%s: %s: duplicate definition for version %u\n"),
@@ -602,8 +614,9 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
 {
   if (sd->symbols == NULL)
     {
-      assert(sd->symbol_names == NULL);
-      assert(sd->versym == NULL && sd->verdef == NULL && sd->verneed == NULL);
+      gold_assert(sd->symbol_names == NULL);
+      gold_assert(sd->versym == NULL && sd->verdef == NULL
+		  && sd->verneed == NULL);
       return;
     }
 
@@ -652,6 +665,400 @@ Sized_dynobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
     }
 }
 
+// Given a vector of hash codes, compute the number of hash buckets to
+// use.
+
+unsigned int
+Dynobj::compute_bucket_count(const std::vector<uint32_t>& hashcodes,
+			     bool for_gnu_hash_table)
+{
+  // FIXME: Implement optional hash table optimization.
+
+  // Array used to determine the number of hash table buckets to use
+  // based on the number of symbols there are.  If there are fewer
+  // than 3 symbols we use 1 bucket, fewer than 17 symbols we use 3
+  // buckets, fewer than 37 we use 17 buckets, and so forth.  We never
+  // use more than 32771 buckets.  This is straight from the old GNU
+  // linker.
+  static const unsigned int buckets[] =
+  {
+    1, 3, 17, 37, 67, 97, 131, 197, 263, 521, 1031, 2053, 4099, 8209,
+    16411, 32771
+  };
+  const int buckets_count = sizeof buckets / sizeof buckets[0];
+
+  unsigned int symcount = hashcodes.size();
+  unsigned int ret = 1;
+  for (int i = 0; i < buckets_count; ++i)
+    {
+      if (symcount < buckets[i])
+	break;
+      ret = buckets[i];
+    }
+
+  if (for_gnu_hash_table && ret < 2)
+    ret = 2;
+
+  return ret;
+}
+
+// The standard ELF hash function.  This hash function must not
+// change, as the dynamic linker uses it also.
+
+uint32_t
+Dynobj::elf_hash(const char* name)
+{
+  const unsigned char* nameu = reinterpret_cast<const unsigned char*>(name);
+  uint32_t h = 0;
+  unsigned char c;
+  while ((c = *nameu++) != '\0')
+    {
+      h = (h << 4) + c;
+      uint32_t g = h & 0xf0000000;
+      if (g != 0)
+	{
+	  h ^= g >> 24;
+	  // The ELF ABI says h &= ~g, but using xor is equivalent in
+	  // this case (since g was set from h) and may save one
+	  // instruction.
+	  h ^= g;
+	}
+    }
+  return h;
+}
+
+// Create a standard ELF hash table, setting *PPHASH and *PHASHLEN.
+// DYNSYMS is a vector with all the global dynamic symbols.
+// LOCAL_DYNSYM_COUNT is the number of local symbols in the dynamic
+// symbol table.
+
+void
+Dynobj::create_elf_hash_table(const Target* target,
+			      const std::vector<Symbol*>& dynsyms,
+			      unsigned int local_dynsym_count,
+			      unsigned char** pphash,
+			      unsigned int* phashlen)
+{
+  unsigned int dynsym_count = dynsyms.size();
+
+  // Get the hash values for all the symbols.
+  std::vector<uint32_t> dynsym_hashvals(dynsym_count);
+  for (unsigned int i = 0; i < dynsym_count; ++i)
+    dynsym_hashvals[i] = Dynobj::elf_hash(dynsyms[i]->name());
+
+  const unsigned int bucketcount =
+    Dynobj::compute_bucket_count(dynsym_hashvals, false);
+
+  std::vector<uint32_t> bucket(bucketcount);
+  std::vector<uint32_t> chain(local_dynsym_count + dynsym_count);
+
+  for (unsigned int i = 0; i < dynsym_count; ++i)
+    {
+      unsigned int dynsym_index = dynsyms[i]->dynsym_index();
+      unsigned int bucketpos = dynsym_hashvals[i] % bucketcount;
+      chain[dynsym_index] = bucket[bucketpos];
+      bucket[bucketpos] = dynsym_index;
+    }
+
+  unsigned int hashlen = ((2
+			   + bucketcount
+			   + local_dynsym_count
+			   + dynsym_count)
+			  * 4);
+  unsigned char* phash = new unsigned char[hashlen];
+
+  if (target->is_big_endian())
+    Dynobj::sized_create_elf_hash_table<true>(bucket, chain, phash, hashlen);
+  else
+    Dynobj::sized_create_elf_hash_table<false>(bucket, chain, phash, hashlen);
+
+  *pphash = phash;
+  *phashlen = hashlen;
+}
+
+// Fill in an ELF hash table.
+
+template<bool big_endian>
+void
+Dynobj::sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
+				    const std::vector<uint32_t>& chain,
+				    unsigned char* phash,
+				    unsigned int hashlen)
+{
+  unsigned char* p = phash;
+
+  const unsigned int bucketcount = bucket.size();
+  const unsigned int chaincount = chain.size();
+
+  elfcpp::Swap<32, big_endian>::writeval(p, bucketcount);
+  p += 4;
+  elfcpp::Swap<32, big_endian>::writeval(p, chaincount);
+  p += 4;
+
+  for (unsigned int i = 0; i < bucketcount; ++i)
+    {
+      elfcpp::Swap<32, big_endian>::writeval(p, bucket[i]);
+      p += 4;
+    }
+
+  for (unsigned int i = 0; i < chaincount; ++i)
+    {
+      elfcpp::Swap<32, big_endian>::writeval(p, chain[i]);
+      p += 4;
+    }
+
+  gold_assert(static_cast<unsigned int>(p - phash) == hashlen);
+}
+
+// The hash function used for the GNU hash table.  This hash function
+// must not change, as the dynamic linker uses it also.
+
+uint32_t
+Dynobj::gnu_hash(const char* name)
+{
+  const unsigned char* nameu = reinterpret_cast<const unsigned char*>(name);
+  uint32_t h = 5381;
+  unsigned char c;
+  while ((c = *nameu++) != '\0')
+    h = (h << 5) + h + c;
+  return h;
+}
+
+// Create a GNU hash table, setting *PPHASH and *PHASHLEN.  GNU hash
+// tables are an extension to ELF which are recognized by the GNU
+// dynamic linker.  They are referenced using dynamic tag DT_GNU_HASH.
+// TARGET is the target.  DYNSYMS is a vector with all the global
+// symbols which will be going into the dynamic symbol table.
+// LOCAL_DYNSYM_COUNT is the number of local symbols in the dynamic
+// symbol table.
+
+void
+Dynobj::create_gnu_hash_table(const Target* target,
+			      const std::vector<Symbol*>& dynsyms,
+			      unsigned int local_dynsym_count,
+			      unsigned char** pphash,
+			      unsigned int* phashlen)
+{
+  const unsigned int count = dynsyms.size();
+
+  // Sort the dynamic symbols into two vectors.  Symbols which we do
+  // not want to put into the hash table we store into
+  // UNHASHED_DYNSYMS.  Symbols which we do want to store we put into
+  // HASHED_DYNSYMS.  DYNSYM_HASHVALS is parallel to HASHED_DYNSYMS,
+  // and records the hash codes.
+
+  std::vector<Symbol*> unhashed_dynsyms;
+  unhashed_dynsyms.reserve(count);
+
+  std::vector<Symbol*> hashed_dynsyms;
+  hashed_dynsyms.reserve(count);
+
+  std::vector<uint32_t> dynsym_hashvals;
+  dynsym_hashvals.reserve(count);
+  
+  for (unsigned int i = 0; i < count; ++i)
+    {
+      Symbol* sym = dynsyms[i];
+
+      // FIXME: Should put on unhashed_dynsyms if the symbol is
+      // hidden.
+      if (sym->is_undefined())
+	unhashed_dynsyms.push_back(sym);
+      else
+	{
+	  hashed_dynsyms.push_back(sym);
+	  dynsym_hashvals.push_back(Dynobj::gnu_hash(sym->name()));
+	}
+    }
+
+  // Put the unhashed symbols at the start of the global portion of
+  // the dynamic symbol table.
+  const unsigned int unhashed_count = unhashed_dynsyms.size();
+  unsigned int unhashed_dynsym_index = local_dynsym_count;
+  for (unsigned int i = 0; i < unhashed_count; ++i)
+    {
+      unhashed_dynsyms[i]->set_dynsym_index(unhashed_dynsym_index);
+      ++unhashed_dynsym_index;
+    }
+
+  // For the actual data generation we call out to a templatized
+  // function.
+  int size = target->get_size();
+  bool big_endian = target->is_big_endian();
+  if (size == 32)
+    {
+      if (big_endian)
+	Dynobj::sized_create_gnu_hash_table<32, true>(hashed_dynsyms,
+						      dynsym_hashvals,
+						      unhashed_dynsym_index,
+						      pphash,
+						      phashlen);
+      else
+	Dynobj::sized_create_gnu_hash_table<32, false>(hashed_dynsyms,
+						       dynsym_hashvals,
+						       unhashed_dynsym_index,
+						       pphash,
+						       phashlen);
+    }
+  else if (size == 64)
+    {
+      if (big_endian)
+	Dynobj::sized_create_gnu_hash_table<64, true>(hashed_dynsyms,
+						      dynsym_hashvals,
+						      unhashed_dynsym_index,
+						      pphash,
+						      phashlen);
+      else
+	Dynobj::sized_create_gnu_hash_table<64, false>(hashed_dynsyms,
+						       dynsym_hashvals,
+						       unhashed_dynsym_index,
+						       pphash,
+						       phashlen);
+    }
+  else
+    gold_unreachable();
+}
+
+// Create the actual data for a GNU hash table.  This is just a copy
+// of the code from the old GNU linker.
+
+template<int size, bool big_endian>
+void
+Dynobj::sized_create_gnu_hash_table(
+    const std::vector<Symbol*>& hashed_dynsyms,
+    const std::vector<uint32_t>& dynsym_hashvals,
+    unsigned int unhashed_dynsym_count,
+    unsigned char** pphash,
+    unsigned int* phashlen)
+{
+  if (hashed_dynsyms.empty())
+    {
+      // Special case for the empty hash table.
+      unsigned int hashlen = 5 * 4 + size / 8;
+      unsigned char* phash = new unsigned char[hashlen];
+      // One empty bucket.
+      elfcpp::Swap<32, big_endian>::writeval(phash, 1);
+      // Symbol index above unhashed symbols.
+      elfcpp::Swap<32, big_endian>::writeval(phash + 4, unhashed_dynsym_count);
+      // One word for bitmask.
+      elfcpp::Swap<32, big_endian>::writeval(phash + 8, 1);
+      // Only bloom filter.
+      elfcpp::Swap<32, big_endian>::writeval(phash + 12, 0);
+      // No valid hashes.
+      elfcpp::Swap<size, big_endian>::writeval(phash + 16, 0);
+      // No hashes in only bucket.
+      elfcpp::Swap<32, big_endian>::writeval(phash + 16 + size / 8, 0);
+
+      *phashlen = hashlen;
+      *pphash = phash;
+
+      return;
+    }
+
+  const unsigned int bucketcount =
+    Dynobj::compute_bucket_count(dynsym_hashvals, true);
+
+  const unsigned int nsyms = hashed_dynsyms.size();
+
+  uint32_t maskbitslog2 = 1;
+  uint32_t x = nsyms >> 1;
+  while (x != 0)
+    {
+      ++maskbitslog2;
+      x >>= 1;
+    }
+  if (maskbitslog2 < 3)
+    maskbitslog2 = 5;
+  else if (((1U << (maskbitslog2 - 2)) & nsyms) != 0)
+    maskbitslog2 += 3;
+  else
+    maskbitslog2 += 2;
+
+  uint32_t shift1;
+  if (size == 32)
+    shift1 = 5;
+  else
+    {
+      if (maskbitslog2 == 5)
+	maskbitslog2 = 6;
+      shift1 = 6;
+    }
+  uint32_t mask = (1U << shift1) - 1U;
+  uint32_t shift2 = maskbitslog2;
+  uint32_t maskbits = 1U << maskbitslog2;
+  uint32_t maskwords = 1U << (maskbitslog2 - shift1);
+
+  typedef typename elfcpp::Elf_types<size>::Elf_WXword Word;
+  std::vector<Word> bitmask(maskwords);
+  std::vector<uint32_t> counts(bucketcount);
+  std::vector<uint32_t> indx(bucketcount);
+  uint32_t symindx = unhashed_dynsym_count;
+
+  // Count the number of times each hash bucket is used.
+  for (unsigned int i = 0; i < nsyms; ++i)
+    ++counts[dynsym_hashvals[i] % bucketcount];
+
+  unsigned int cnt = symindx;
+  for (unsigned int i = 0; i < bucketcount; ++i)
+    {
+      indx[i] = cnt;
+      cnt += counts[i];
+    }
+
+  unsigned int hashlen = (4 + bucketcount + nsyms) * 4;
+  hashlen += maskbits / 8;
+  unsigned char* phash = new unsigned char[hashlen];
+
+  elfcpp::Swap<32, big_endian>::writeval(phash, bucketcount);
+  elfcpp::Swap<32, big_endian>::writeval(phash + 4, symindx);
+  elfcpp::Swap<32, big_endian>::writeval(phash + 8, maskwords);
+  elfcpp::Swap<32, big_endian>::writeval(phash + 12, shift2);
+
+  unsigned char* p = phash + 16 + maskbits / 8;
+  for (unsigned int i = 0; i < bucketcount; ++i)
+    {
+      if (counts[i] == 0)
+	elfcpp::Swap<32, big_endian>::writeval(p, 0);
+      else
+	elfcpp::Swap<32, big_endian>::writeval(p, indx[i]);
+      p += 4;
+    }
+
+  for (unsigned int i = 0; i < nsyms; ++i)
+    {
+      Symbol* sym = hashed_dynsyms[i];
+      uint32_t hashval = dynsym_hashvals[i];
+
+      unsigned int bucket = hashval % bucketcount;
+      unsigned int val = ((hashval >> shift1)
+			  & ((maskbits >> shift1) - 1));
+      bitmask[val] |= (static_cast<Word>(1U)) << (hashval & mask);
+      bitmask[val] |= (static_cast<Word>(1U)) << ((hashval >> shift2) & mask);
+      val = hashval & ~ 1U;
+      if (counts[bucket] == 1)
+	{
+	  // Last element terminates the chain.
+	  val |= 1;
+	}
+      elfcpp::Swap<32, big_endian>::writeval(p + (indx[bucket] - symindx) * 4,
+					     val);
+      --counts[bucket];
+
+      sym->set_dynsym_index(indx[bucket]);
+      ++indx[bucket];
+    }
+
+  p = phash + 16;
+  for (unsigned int i = 0; i < maskwords; ++i)
+    {
+      elfcpp::Swap<size, big_endian>::writeval(p, bitmask[i]);
+      p += size / 8;
+    }
+
+  *phashlen = hashlen;
+  *pphash = phash;
+}
+
 // Instantiate the templates we need.  We could use the configure
 // script to restrict this to only the ones for implemented targets.
 
diff --git a/gold/dynobj.h b/gold/dynobj.h
index 04a2c63..bc877c4 100644
--- a/gold/dynobj.h
+++ b/gold/dynobj.h
@@ -17,8 +17,71 @@ class Dynobj : public Object
 {
  public:
   Dynobj(const std::string& name, Input_file* input_file, off_t offset = 0)
-    : Object(name, input_file, true, offset)
+    : Object(name, input_file, true, offset), soname_()
   { }
+
+  // Return the name to use in a DT_NEEDED entry for this object.
+  const char*
+  soname() const;
+
+  // Create a standard ELF hash table, setting *PPHASH and *PHASHLEN.
+  // DYNSYMS is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the
+  // number of local dynamic symbols, which is the index of the first
+  // dynamic gobal symbol.
+  static void
+  create_elf_hash_table(const Target*, const std::vector<Symbol*>& dynsyms,
+			unsigned int local_dynsym_count,
+			unsigned char** pphash,
+			unsigned int* phashlen);
+
+  // Create a GNU hash table, setting *PPHASH and *PHASHLEN.  DYNSYMS
+  // is the global dynamic symbols.  LOCAL_DYNSYM_COUNT is the number
+  // of local dynamic symbols, which is the index of the first dynamic
+  // gobal symbol.
+  static void
+  create_gnu_hash_table(const Target*, const std::vector<Symbol*>& dynsyms,
+			unsigned int local_dynsym_count,
+			unsigned char** pphash, unsigned int* phashlen);
+
+ protected:
+  // Set the DT_SONAME string.
+  void
+  set_soname_string(const char* s)
+  { this->soname_.assign(s); }
+
+ private:
+  // Compute the ELF hash code for a string.
+  static uint32_t
+  elf_hash(const char*);
+
+  // Compute the GNU hash code for a string.
+  static uint32_t
+  gnu_hash(const char*);
+
+  // Compute the number of hash buckets to use.
+  static unsigned int
+  compute_bucket_count(const std::vector<uint32_t>& hashcodes,
+		       bool for_gnu_hash_table);
+
+  // Sized version of create_elf_hash_table.
+  template<bool big_endian>
+  static void
+  sized_create_elf_hash_table(const std::vector<uint32_t>& bucket,
+			      const std::vector<uint32_t>& chain,
+			      unsigned char* phash,
+			      unsigned int hashlen);
+
+  // Sized version of create_gnu_hash_table.
+  template<int size, bool big_endian>
+  static void
+  sized_create_gnu_hash_table(const std::vector<Symbol*>& hashed_dynsyms,
+			      const std::vector<uint32_t>& dynsym_hashvals,
+			      unsigned int unhashed_dynsym_count,
+			      unsigned char** pphash,
+			      unsigned int* phashlen);
+
+  // The DT_SONAME name, if any.
+  std::string soname_;
 };
 
 // A dynamic object, size and endian specific version.
@@ -58,6 +121,11 @@ class Sized_dynobj : public Dynobj
   do_section_contents(unsigned int shndx)
   { return this->elf_file_.section_contents(shndx); }
 
+  // Return section flags.
+  uint64_t
+  do_section_flags(unsigned int shndx)
+  { return this->elf_file_.section_flags(shndx); }
+
  private:
   // For convenience.
   typedef Sized_dynobj<size, big_endian> This;
@@ -104,8 +172,6 @@ class Sized_dynobj : public Dynobj
 
   // General access to the ELF file.
   elfcpp::Elf_file<size, big_endian, Object> elf_file_;
-  // The DT_SONAME name, if any.
-  std::string soname_;
 };
 
 } // End namespace gold.
diff --git a/gold/fileread.cc b/gold/fileread.cc
index 43c69b3..e96476c 100644
--- a/gold/fileread.cc
+++ b/gold/fileread.cc
@@ -2,7 +2,6 @@
 
 #include "gold.h"
 
-#include <cassert>
 #include <cstring>
 #include <cerrno>
 #include <fcntl.h>
@@ -19,7 +18,7 @@ namespace gold
 
 File_read::View::~View()
 {
-  assert(!this->is_locked());
+  gold_assert(!this->is_locked());
   delete[] this->data_;
 }
 
@@ -32,7 +31,7 @@ File_read::View::lock()
 void
 File_read::View::unlock()
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   --this->lock_count_;
 }
 
@@ -49,7 +48,7 @@ File_read::View::is_locked()
 
 File_read::~File_read()
 {
-  assert(this->lock_count_ == 0);
+  gold_assert(this->lock_count_ == 0);
   if (this->descriptor_ >= 0)
     {
       if (close(this->descriptor_) < 0)
@@ -64,9 +63,9 @@ File_read::~File_read()
 bool
 File_read::open(const std::string& name)
 {
-  assert(this->lock_count_ == 0
-	 && this->descriptor_ < 0
-	 && this->name_.empty());
+  gold_assert(this->lock_count_ == 0
+	      && this->descriptor_ < 0
+	      && this->name_.empty());
   this->name_ = name;
   this->descriptor_ = ::open(this->name_.c_str(), O_RDONLY);
   ++this->lock_count_;
@@ -76,7 +75,7 @@ File_read::open(const std::string& name)
 int
 File_read::get_descriptor()
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   return this->descriptor_;
 }
 
@@ -89,7 +88,7 @@ File_read::lock()
 void
 File_read::unlock()
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   --this->lock_count_;
 }
 
@@ -121,7 +120,7 @@ File_read::find_view(off_t start, off_t size)
 off_t
 File_read::do_read(off_t start, off_t size, void* p, off_t* pbytes)
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   int o = this->descriptor_;
 
   if (lseek(o, start, SEEK_SET) < 0)
@@ -161,7 +160,7 @@ File_read::do_read(off_t start, off_t size, void* p, off_t* pbytes)
 void
 File_read::read(off_t start, off_t size, void* p, off_t* pbytes)
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
 
   File_read::View* pv = this->find_view(start, size);
   if (pv != NULL)
@@ -180,7 +179,7 @@ File_read::read(off_t start, off_t size, void* p, off_t* pbytes)
 File_read::View*
 File_read::find_or_make_view(off_t start, off_t size, off_t* pbytes)
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
 
   off_t poff = File_read::page_offset(start);
 
@@ -244,7 +243,7 @@ File_read::find_or_make_view(off_t start, off_t size, off_t* pbytes)
 const unsigned char*
 File_read::get_view(off_t start, off_t size, off_t* pbytes)
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   File_read::View* pv = this->find_or_make_view(start, size, pbytes);
   return pv->data() + (start - pv->start());
 }
@@ -252,7 +251,7 @@ File_read::get_view(off_t start, off_t size, off_t* pbytes)
 File_view*
 File_read::get_lasting_view(off_t start, off_t size, off_t* pbytes)
 {
-  assert(this->lock_count_ > 0);
+  gold_assert(this->lock_count_ > 0);
   File_read::View* pv = this->find_or_make_view(start, size, pbytes);
   pv->lock();
   return new File_view(*this, pv, pv->data() + (start - pv->start()));
@@ -271,7 +270,7 @@ File_read::clear_views(bool destroying)
 	delete p->second;
       else
 	{
-	  assert(!destroying);
+	  gold_assert(!destroying);
 	  this->saved_views_.push_back(p->second);
 	}
     }
@@ -287,7 +286,7 @@ File_read::clear_views(bool destroying)
 	}
       else
 	{
-	  assert(!destroying);
+	  gold_assert(!destroying);
 	  ++p;
 	}
     }
@@ -297,7 +296,7 @@ File_read::clear_views(bool destroying)
 
 File_view::~File_view()
 {
-  assert(this->file_.is_locked());
+  gold_assert(this->file_.is_locked());
   this->view_->unlock();
 }
 
diff --git a/gold/gold-threads.cc b/gold/gold-threads.cc
index c6e1170..5373739 100644
--- a/gold/gold-threads.cc
+++ b/gold/gold-threads.cc
@@ -1,7 +1,5 @@
 // gold-threads.cc -- thread support for gold
 
-#include <cassert>
-
 #include "gold.h"
 
 #ifdef ENABLE_THREADS
@@ -87,20 +85,20 @@ Lock_impl::Lock_impl()
 
 Lock_impl::~Lock_impl()
 {
-  assert(!this->acquired_);
+  gold_assert(!this->acquired_);
 }
 
 void
 Lock_impl::acquire()
 {
-  assert(!this->acquired_);
+  gold_assert(!this->acquired_);
   this->acquired_ = true;
 }
 
 void
 Lock_impl::release()
 {
-  assert(this->acquired_);
+  gold_assert(this->acquired_);
   this->acquired_ = false;
 }
 
@@ -192,7 +190,7 @@ Condvar_impl::~Condvar_impl()
 void
 Condvar_impl::wait(Lock_impl* li)
 {
-  assert(li->acquired_);
+  gold_assert(li->acquired_);
 }
 
 void
diff --git a/gold/gold.cc b/gold/gold.cc
index 3073b18..7c8ed8f 100644
--- a/gold/gold.cc
+++ b/gold/gold.cc
@@ -52,10 +52,14 @@ gold_nomem()
   gold_exit(false);
 }
 
+// Handle an unreachable case.
+
 void
-gold_unreachable()
+do_gold_unreachable(const char* filename, int lineno, const char* function)
 {
-  abort();
+  fprintf(stderr, "%s: internal error in %s, at %s:%d\n",
+	  program_name, function, filename, lineno);
+  gold_exit(false);
 }
 
 // This class arranges to run the functions done in the middle of the
@@ -136,6 +140,10 @@ queue_middle_tasks(const General_options& options,
 		   Layout* layout,
 		   Workqueue* workqueue)
 {
+  // Define some sections and symbols needed for a dynamic link.  This
+  // handles some cases we want to see before we read the relocs.
+  layout->create_initial_dynamic_sections(input_objects, symtab);
+
   // Predefine standard symbols.  This should be fast, so we don't
   // bother to create a task for it.
   define_standard_symbols(symtab, layout, input_objects->target());
@@ -215,7 +223,9 @@ queue_final_tasks(const General_options& options,
 
   // Queue a task to write out everything else.
   final_blocker->add_blocker();
-  workqueue->queue(new Write_data_task(layout, of, final_blocker));
+  workqueue->queue(new Write_data_task(layout, symtab,
+				       input_objects->target(),
+				       of, final_blocker));
 
   // Queue a task to close the output file.  This will be blocked by
   // FINAL_BLOCKER.
diff --git a/gold/gold.h b/gold/gold.h
index d55d1f6..78c106f 100644
--- a/gold/gold.h
+++ b/gold/gold.h
@@ -163,10 +163,18 @@ gold_fatal(const char* msg, bool perrno) ATTRIBUTE_NORETURN;
 extern void
 gold_nomem() ATTRIBUTE_NORETURN;
 
-// This function is called in cases which can not arise if the code is
-// written correctly.
-extern void
-gold_unreachable() ATTRIBUTE_NORETURN;
+// This macro and function are used in cases which can not arise if
+// the code is written correctly.
+
+#define gold_unreachable() \
+  (gold::do_gold_unreachable(__FILE__, __LINE__, __FUNCTION__))
+
+extern void do_gold_unreachable(const char*, int, const char*)
+  ATTRIBUTE_NORETURN;
+
+// Assertion check.
+
+#define gold_assert(expr) ((void)(!(expr) ? gold_unreachable(), 0 : 0))
 
 // Queue up the first set of tasks.
 extern void
diff --git a/gold/i386.cc b/gold/i386.cc
index e6522e3..488da79 100644
--- a/gold/i386.cc
+++ b/gold/i386.cc
@@ -20,6 +20,8 @@ namespace
 
 using namespace gold;
 
+class Output_data_plt_i386;
+
 // The i386 target class.
 
 class Target_i386 : public Sized_target<32, false>
@@ -27,7 +29,7 @@ class Target_i386 : public Sized_target<32, false>
  public:
   Target_i386()
     : Sized_target<32, false>(&i386_info),
-      got_(NULL)
+      got_(NULL), plt_(NULL), got_plt_(NULL)
   { }
 
   // Scan the relocations to look for symbol adjustments.
@@ -36,6 +38,7 @@ class Target_i386 : public Sized_target<32, false>
 	      Symbol_table* symtab,
 	      Layout* layout,
 	      Sized_relobj<32, false>* object,
+	      unsigned int data_shndx,
 	      unsigned int sh_type,
 	      const unsigned char* prelocs,
 	      size_t reloc_count,
@@ -61,6 +64,7 @@ class Target_i386 : public Sized_target<32, false>
     local(const General_options& options, Symbol_table* symtab,
 	  Layout* layout, Target_i386* target,
 	  Sized_relobj<32, false>* object,
+	  unsigned int data_shndx,
 	  const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
 	  const elfcpp::Sym<32, false>& lsym);
 
@@ -68,6 +72,7 @@ class Target_i386 : public Sized_target<32, false>
     global(const General_options& options, Symbol_table* symtab,
 	   Layout* layout, Target_i386* target,
 	   Sized_relobj<32, false>* object,
+	   unsigned int data_shndx,
 	   const elfcpp::Rel<32, false>& reloc, unsigned int r_type,
 	   Symbol* gsym);
   };
@@ -146,11 +151,29 @@ class Target_i386 : public Sized_target<32, false>
   // Adjust TLS relocation type based on the options and whether this
   // is a local symbol.
   static unsigned int
-  optimize_tls_reloc(const General_options*, bool is_local, int r_type);
+  optimize_tls_reloc(const General_options*, bool is_final, int r_type);
 
   // Get the GOT section, creating it if necessary.
   Output_data_got<32, false>*
-  got_section(Symbol_table*, Layout*);
+  got_section(const General_options*, Symbol_table*, Layout*);
+
+  // Create a PLT entry for a global symbol.
+  void
+  make_plt_entry(const General_options* options, Symbol_table*,
+		 Layout*, Symbol*);
+
+  // Get the PLT section.
+  Output_data_plt_i386*
+  plt_section() const
+  {
+    gold_assert(this->plt_ != NULL);
+    return this->plt_;
+  }
+
+  // Copy a relocation against a global symbol.
+  void
+  copy_reloc(const General_options*, Sized_relobj<32, false>*, unsigned int,
+	     Symbol*, const elfcpp::Rel<32, false>&);
 
   // Information about this specific target which we pass to the
   // general Target structure.
@@ -158,6 +181,10 @@ class Target_i386 : public Sized_target<32, false>
 
   // The GOT section.
   Output_data_got<32, false>* got_;
+  // The PLT section.
+  Output_data_plt_i386* plt_;
+  // The GOT PLT section.
+  Output_data_space* got_plt_;
 };
 
 const Target::Target_info Target_i386::i386_info =
@@ -176,37 +203,317 @@ const Target::Target_info Target_i386::i386_info =
 // Get the GOT section, creating it if necessary.
 
 Output_data_got<32, false>*
-Target_i386::got_section(Symbol_table* symtab, Layout* layout)
+Target_i386::got_section(const General_options* options, Symbol_table* symtab,
+			 Layout* layout)
 {
   if (this->got_ == NULL)
     {
-      this->got_ = new Output_data_got<32, false>();
+      gold_assert(options != NULL && symtab != NULL && layout != NULL);
+
+      this->got_ = new Output_data_got<32, false>(options);
 
-      assert(symtab != NULL && layout != NULL);
       layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
 				      elfcpp::SHF_ALLOC, this->got_);
 
+      // The old GNU linker creates a .got.plt section.  We just
+      // create another set of data in the .got section.  Note that we
+      // always create a PLT if we create a GOT, although the PLT
+      // might be empty.
+      this->got_plt_ = new Output_data_space(4);
+      layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS,
+				      elfcpp::SHF_ALLOC, this->got_plt_);
+
       // The first three entries are reserved.
-      this->got_->add_constant(0);
-      this->got_->add_constant(0);
-      this->got_->add_constant(0);
+      this->got_plt_->set_space_size(3 * 4);
 
-      // Define _GLOBAL_OFFSET_TABLE_ at the start of the section.
-      symtab->define_in_output_data(this, "_GLOBAL_OFFSET_TABLE_", this->got_,
+      // Define _GLOBAL_OFFSET_TABLE_ at the start of the PLT.
+      symtab->define_in_output_data(this, "_GLOBAL_OFFSET_TABLE_",
+				    this->got_plt_,
 				    0, 0, elfcpp::STT_OBJECT,
 				    elfcpp::STB_GLOBAL,
 				    elfcpp::STV_HIDDEN, 0,
 				    false, false);
     }
+
   return this->got_;
 }
 
+// A class to handle the PLT data.
+
+class Output_data_plt_i386 : public Output_section_data
+{
+ public:
+  typedef Output_data_reloc<elfcpp::SHT_REL, true, 32, false> Reloc_section;
+
+  Output_data_plt_i386(Layout*, Output_data_space*, bool is_shared);
+
+  // Add an entry to the PLT.
+  void
+  add_entry(Symbol* gsym);
+
+ private:
+  // The size of an entry in the PLT.
+  static const int plt_entry_size = 16;
+
+  // The first entry in the PLT for an executable.
+  static unsigned char exec_first_plt_entry[plt_entry_size];
+
+  // The first entry in the PLT for a shared object.
+  static unsigned char dyn_first_plt_entry[plt_entry_size];
+
+  // Other entries in the PLT for an executable.
+  static unsigned char exec_plt_entry[plt_entry_size];
+
+  // Other entries in the PLT for a shared object.
+  static unsigned char dyn_plt_entry[plt_entry_size];
+
+  // Set the final size.
+  void
+  do_set_address(uint64_t, off_t)
+  { this->set_data_size((this->count_ + 1) * plt_entry_size); }
+
+  // Write out the PLT data.
+  void
+  do_write(Output_file*);
+
+  // The reloc section.
+  Reloc_section* rel_;
+  // The .got.plt section.
+  Output_data_space* got_plt_;
+  // The number of PLT entries.
+  unsigned int count_;
+  // Whether we are generated a shared object.
+  bool is_shared_;
+};
+
+// Create the PLT section.  The ordinary .got section is an argument,
+// since we need to refer to the start.  We also create our own .got
+// section just for PLT entries.
+
+Output_data_plt_i386::Output_data_plt_i386(Layout* layout,
+					   Output_data_space* got_plt,
+					   bool is_shared)
+  : Output_section_data(4), got_plt_(got_plt), is_shared_(is_shared)
+{
+  this->rel_ = new Reloc_section();
+  layout->add_output_section_data(".rel.plt", elfcpp::SHT_REL,
+				  elfcpp::SHF_ALLOC, this->rel_);
+}
+
+// Add an entry to the PLT.
+
+void
+Output_data_plt_i386::add_entry(Symbol* gsym)
+{
+  gold_assert(!gsym->has_plt_offset());
+
+  // Note that when setting the PLT offset we skip the initial
+  // reserved PLT entry.
+  gsym->set_plt_offset((this->count_ + 1) * plt_entry_size);
+
+  ++this->count_;
+
+  off_t got_offset = this->got_plt_->data_size();
+
+  // Every PLT entry needs a GOT entry which points back to the PLT
+  // entry (this will be changed by the dynamic linker, normally
+  // lazily when the function is called).
+  this->got_plt_->set_space_size(got_offset + 4);
+
+  // Every PLT entry needs a reloc.
+  this->rel_->add_global(gsym, elfcpp::R_386_JUMP_SLOT, this->got_plt_,
+			 got_offset);
+
+  // Note that we don't need to save the symbol.  The contents of the
+  // PLT are independent of which symbols are used.  The symbols only
+  // appear in the relocations.
+}
+
+// The first entry in the PLT for an executable.
+
+unsigned char Output_data_plt_i386::exec_first_plt_entry[plt_entry_size] =
+{
+  0xff, 0x35,	// pushl contents of memory address
+  0, 0, 0, 0,	// replaced with address of .got + 4
+  0xff, 0x25,	// jmp indirect
+  0, 0, 0, 0,	// replaced with address of .got + 8
+  0, 0, 0, 0	// unused
+};
+
+// The first entry in the PLT for a shared object.
+
+unsigned char Output_data_plt_i386::dyn_first_plt_entry[plt_entry_size] =
+{
+  0xff, 0xb3, 4, 0, 0, 0,	// pushl 4(%ebx)
+  0xff, 0xa3, 8, 0, 0, 0,	// jmp *8(%ebx)
+  0, 0, 0, 0			// unused
+};
+
+// Subsequent entries in the PLT for an executable.
+
+unsigned char Output_data_plt_i386::exec_plt_entry[plt_entry_size] =
+{
+  0xff, 0x25,	// jmp indirect
+  0, 0, 0, 0,	// replaced with address of symbol in .got
+  0x68,		// pushl immediate
+  0, 0, 0, 0,	// replaced with offset into relocation table
+  0xe9,		// jmp relative
+  0, 0, 0, 0	// replaced with offset to start of .plt
+};
+
+// Subsequent entries in the PLT for a shared object.
+
+unsigned char Output_data_plt_i386::dyn_plt_entry[plt_entry_size] =
+{
+  0xff, 0xa3,	// jmp *offset(%ebx)
+  0, 0, 0, 0,	// replaced with offset of symbol in .got
+  0x68,		// pushl immediate
+  0, 0, 0, 0,	// replaced with offset into relocation table
+  0xe9,		// jmp relative
+  0, 0, 0, 0	// replaced with offset to start of .plt
+};
+
+// Write out the PLT.  This uses the hand-coded instructions above,
+// and adjusts them as needed.  This is all specified by the i386 ELF
+// Processor Supplement.
+
+void
+Output_data_plt_i386::do_write(Output_file* of)
+{
+  const off_t offset = this->offset();
+  const off_t oview_size = this->data_size();
+  unsigned char* const oview = of->get_output_view(offset, oview_size);
+
+  const off_t got_file_offset = this->got_plt_->offset();
+  const off_t got_size = this->got_plt_->data_size();
+  unsigned char* const got_view = of->get_output_view(got_file_offset,
+						      got_size);
+
+  unsigned char* pov = oview;
+
+  elfcpp::Elf_types<32>::Elf_Addr plt_address = this->address();
+  elfcpp::Elf_types<32>::Elf_Addr got_address = this->got_plt_->address();
+
+  if (this->is_shared_)
+    memcpy(pov, dyn_first_plt_entry, plt_entry_size);
+  else
+    {
+      memcpy(pov, exec_first_plt_entry, plt_entry_size);
+      elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_address + 4);
+      elfcpp::Swap<32, false>::writeval(pov + 8, got_address + 8);
+    }
+  pov += plt_entry_size;
+
+  unsigned char* got_pov = got_view;
+
+  memset(got_pov, 0, 12);
+  got_pov += 12;
+
+  const int rel_size = elfcpp::Elf_sizes<32>::rel_size;
+
+  unsigned int plt_offset = plt_entry_size;
+  unsigned int plt_rel_offset = 0;
+  unsigned int got_offset = 12;
+  const unsigned int count = this->count_;
+  for (unsigned int i = 0;
+       i < count;
+       ++i,
+	 pov += plt_entry_size,
+	 got_pov += 4,
+	 plt_offset += plt_entry_size,
+	 plt_rel_offset += rel_size,
+	 got_offset += 4)
+    {
+      // Set and adjust the PLT entry itself.
+
+      if (this->is_shared_)
+	{
+	  memcpy(pov, dyn_plt_entry, plt_entry_size);
+	  elfcpp::Swap_unaligned<32, false>::writeval(pov + 2, got_offset);
+	}
+      else
+	{
+	  memcpy(pov, exec_plt_entry, plt_entry_size);
+	  elfcpp::Swap_unaligned<32, false>::writeval(pov + 2,
+						      (got_address
+						       + got_offset));
+	}
+
+      elfcpp::Swap_unaligned<32, false>::writeval(pov + 7, plt_rel_offset);
+      elfcpp::Swap<32, false>::writeval(pov + 12,
+					- (plt_offset + plt_entry_size));
+
+      // Set the entry in the GOT.
+      elfcpp::Swap<32, false>::writeval(got_pov, plt_address + plt_offset + 6);
+    }
+
+  gold_assert(pov - oview == oview_size);
+  gold_assert(got_pov - got_view == got_size);
+
+  of->write_output_view(offset, oview_size, oview);
+  of->write_output_view(got_file_offset, got_size, got_view);
+}
+
+// Create a PLT entry for a global symbol.
+
+void
+Target_i386::make_plt_entry(const General_options* options,
+			    Symbol_table* symtab, Layout* layout, Symbol* gsym)
+{
+  if (gsym->has_plt_offset())
+    return;
+
+  if (this->plt_ == NULL)
+    {
+      // Create the GOT sections first.
+      this->got_section(options, symtab, layout);
+
+      this->plt_ = new Output_data_plt_i386(layout, this->got_plt_,
+					    options->is_shared());
+    }
+
+  this->plt_->add_entry(gsym);
+}
+
+// Handle a relocation against a non-function symbol defined in a
+// dynamic object.  The traditional way to handle this is to generate
+// a COPY relocation to copy the variable at runtime from the shared
+// object into the executable's data segment.  However, this is
+// undesirable in general, as if the size of the object changes in the
+// dynamic object, the executable will no longer work correctly.  If
+// this relocation is in a writable section, then we can create a
+// dynamic reloc and the dynamic linker will resolve it to the correct
+// address at runtime.  However, we do not want do that if the
+// relocation is in a read-only section, as it would prevent the
+// readonly segment from being shared.  And if we have to eventually
+// generate a COPY reloc, then any dynamic relocations will be
+// useless.  So this means that if this is a writable section, we need
+// to save the relocation until we see whether we have to create a
+// COPY relocation for this symbol for any other relocation.
+
+void
+Target_i386::copy_reloc(const General_options* options,
+			Sized_relobj<32, false>* object,
+			unsigned int data_shndx, Symbol* gsym,
+			const elfcpp::Rel<32, false>&)
+{
+  if (!Relocate_functions<32, false>::need_copy_reloc(options, object,
+						      data_shndx, gsym))
+    {
+      // So far we do not need a COPY reloc.  Save this relocation.
+      // If it turns out that we never a COPY reloc for this symbol,
+      // then we emit the relocation.
+    }
+
+}
+
 // Optimize the TLS relocation type based on what we know about the
-// symbol.  IS_LOCAL is true if this symbol can be resolved entirely
-// locally--i.e., does not have to be in the dynamic symbol table.
+// symbol.  IS_FINAL is true if the final address of this symbol is
+// known at link time.
 
 unsigned int
-Target_i386::optimize_tls_reloc(const General_options* options, bool is_local,
+Target_i386::optimize_tls_reloc(const General_options* options,
+				bool is_final,
 				int r_type)
 {
   // If we are generating a shared library, then we can't do anything
@@ -223,7 +530,7 @@ Target_i386::optimize_tls_reloc(const General_options* options, bool is_local,
       // access.  Since we know that we are generating an executable,
       // we can convert this to Initial-Exec.  If we also know that
       // this is a local symbol, we can further switch to Local-Exec.
-      if (is_local)
+      if (is_final)
 	return elfcpp::R_386_TLS_LE_32;
       return elfcpp::R_386_TLS_IE_32;
 
@@ -244,7 +551,7 @@ Target_i386::optimize_tls_reloc(const General_options* options, bool is_local,
       // from the GOT.  If we know that we are linking against the
       // local symbol, we can switch to Local-Exec, which links the
       // thread offset into the instruction.
-      if (is_local)
+      if (is_final)
 	return elfcpp::R_386_TLS_LE_32;
       return r_type;
 	
@@ -255,7 +562,7 @@ Target_i386::optimize_tls_reloc(const General_options* options, bool is_local,
       return r_type;
 
     default:
-      abort();
+      gold_unreachable();
     }
 }
 
@@ -267,7 +574,9 @@ Target_i386::Scan::local(const General_options& options,
 			 Layout* layout,
 			 Target_i386* target,
 			 Sized_relobj<32, false>* object,
-			 const elfcpp::Rel<32, false>&, unsigned int r_type,
+			 unsigned int,
+			 const elfcpp::Rel<32, false>&,
+			 unsigned int r_type,
 			 const elfcpp::Sym<32, false>&)
 {
   switch (r_type)
@@ -282,6 +591,7 @@ Target_i386::Scan::local(const General_options& options,
     case elfcpp::R_386_8:
       // FIXME: If we are generating a shared object we need to copy
       // this relocation into the object.
+      gold_assert(!options.is_shared());
       break;
 
     case elfcpp::R_386_PC32:
@@ -292,7 +602,7 @@ Target_i386::Scan::local(const General_options& options,
     case elfcpp::R_386_GOTOFF:
     case elfcpp::R_386_GOTPC:
       // We need a GOT section.
-      target->got_section(symtab, layout);
+      target->got_section(&options, symtab, layout);
       break;
 
     case elfcpp::R_386_COPY:
@@ -319,13 +629,16 @@ Target_i386::Scan::local(const General_options& options,
     case elfcpp::R_386_TLS_LE_32:
     case elfcpp::R_386_TLS_GOTDESC:
     case elfcpp::R_386_TLS_DESC_CALL:
-      r_type = Target_i386::optimize_tls_reloc(&options, true, r_type);
+      r_type = Target_i386::optimize_tls_reloc(&options,
+					       !options.is_shared(),
+					       r_type);
       switch (r_type)
 	{
 	case elfcpp::R_386_TLS_LE:
 	case elfcpp::R_386_TLS_LE_32:
 	  // FIXME: If generating a shared object, we need to copy
 	  // this relocation into the object.
+	  gold_assert(!options.is_shared());
 	  break;
 
 	case elfcpp::R_386_TLS_IE:
@@ -370,7 +683,9 @@ Target_i386::Scan::global(const General_options& options,
 			  Layout* layout,
 			  Target_i386* target,
 			  Sized_relobj<32, false>* object,
-			  const elfcpp::Rel<32, false>&, unsigned int r_type,
+			  unsigned int data_shndx,
+			  const elfcpp::Rel<32, false>& reloc,
+			  unsigned int r_type,
 			  Symbol* gsym)
 {
   switch (r_type)
@@ -390,32 +705,44 @@ Target_i386::Scan::global(const General_options& options,
       // copy this relocation into the object.  If this symbol is
       // defined in a shared object, we may need to copy this
       // relocation in order to avoid a COPY relocation.
+      gold_assert(!options.is_shared());
+
+      if (gsym->is_defined_in_dynobj())
+	{
+	  // This symbol is defined in a dynamic object.  If it is a
+	  // function, we make a PLT entry.  Otherwise we need to
+	  // either generate a COPY reloc or copy this reloc.
+	  if (gsym->type() == elfcpp::STT_FUNC)
+	    target->make_plt_entry(&options, symtab, layout, gsym);
+	  else
+	    target->copy_reloc(&options, object, data_shndx, gsym, reloc);
+	}
+
       break;
 
     case elfcpp::R_386_GOT32:
       // The symbol requires a GOT entry.
-      if (target->got_section(symtab, layout)->add_global(gsym))
+      if (target->got_section(&options, symtab, layout)->add_global(gsym))
 	{
-	  // If this symbol is not resolved locally, we need to add a
+	  // If this symbol is not fully resolved, we need to add a
 	  // dynamic relocation for it.
-	  if (!gsym->is_resolved_locally())
-	    abort();
+	  if (!gsym->final_value_is_known(&options))
+	    gold_unreachable();
 	}
       break;
 
     case elfcpp::R_386_PLT32:
-      // If the symbol is resolved locally, this is just a PC32 reloc.
-      if (gsym->is_resolved_locally())
+      // If the symbol is fully resolved, this is just a PC32 reloc.
+      // Otherwise we need a PLT entry.
+      if (gsym->final_value_is_known(&options))
 	break;
-      fprintf(stderr,
-	      _("%s: %s: unsupported reloc %u against global symbol %s\n"),
-	      program_name, object->name().c_str(), r_type, gsym->name());
+      target->make_plt_entry(&options, symtab, layout, gsym);
       break;
 
     case elfcpp::R_386_GOTOFF:
     case elfcpp::R_386_GOTPC:
       // We need a GOT section.
-      target->got_section(symtab, layout);
+      target->got_section(&options, symtab, layout);
       break;
 
     case elfcpp::R_386_COPY:
@@ -442,30 +769,34 @@ Target_i386::Scan::global(const General_options& options,
     case elfcpp::R_386_TLS_LE_32:
     case elfcpp::R_386_TLS_GOTDESC:
     case elfcpp::R_386_TLS_DESC_CALL:
-      r_type = Target_i386::optimize_tls_reloc(&options,
-					       gsym->is_resolved_locally(),
-					       r_type);
-      switch (r_type)
-	{
-	case elfcpp::R_386_TLS_LE:
-	case elfcpp::R_386_TLS_LE_32:
-	  // FIXME: If generating a shared object, we need to copy
-	  // this relocation into the object.
-	  break;
-
-	case elfcpp::R_386_TLS_IE:
-	case elfcpp::R_386_TLS_GOTIE:
-	case elfcpp::R_386_TLS_GD:
-	case elfcpp::R_386_TLS_LDM:
-	case elfcpp::R_386_TLS_LDO_32:
-	case elfcpp::R_386_TLS_IE_32:
-	case elfcpp::R_386_TLS_GOTDESC:
-	case elfcpp::R_386_TLS_DESC_CALL:
-	  fprintf(stderr,
-		  _("%s: %s: unsupported reloc %u against global symbol %s\n"),
-		  program_name, object->name().c_str(), r_type, gsym->name());
-	  break;
-	}
+      {
+	const bool is_final = gsym->final_value_is_known(&options);
+	r_type = Target_i386::optimize_tls_reloc(&options, is_final, r_type);
+	switch (r_type)
+	  {
+	  case elfcpp::R_386_TLS_LE:
+	  case elfcpp::R_386_TLS_LE_32:
+	    // FIXME: If generating a shared object, we need to copy
+	    // this relocation into the object.
+	    gold_assert(!options.is_shared());
+	    break;
+
+	  case elfcpp::R_386_TLS_IE:
+	  case elfcpp::R_386_TLS_GOTIE:
+	  case elfcpp::R_386_TLS_GD:
+	  case elfcpp::R_386_TLS_LDM:
+	  case elfcpp::R_386_TLS_LDO_32:
+	  case elfcpp::R_386_TLS_IE_32:
+	  case elfcpp::R_386_TLS_GOTDESC:
+	  case elfcpp::R_386_TLS_DESC_CALL:
+	    fprintf(stderr,
+		    _("%s: %s: unsupported reloc %u "
+		      "against global symbol %s\n"),
+		    program_name, object->name().c_str(), r_type,
+		    gsym->name());
+	    break;
+	  }
+      }
       break;
 
     case elfcpp::R_386_32PLT:
@@ -493,6 +824,7 @@ Target_i386::scan_relocs(const General_options& options,
 			 Symbol_table* symtab,
 			 Layout* layout,
 			 Sized_relobj<32, false>* object,
+			 unsigned int data_shndx,
 			 unsigned int sh_type,
 			 const unsigned char* prelocs,
 			 size_t reloc_count,
@@ -514,6 +846,7 @@ Target_i386::scan_relocs(const General_options& options,
     layout,
     this,
     object,
+    data_shndx,
     prelocs,
     reloc_count,
     local_symbol_count,
@@ -552,6 +885,15 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
       return false;
     }
 
+  // Pick the value to use for symbols defined in shared objects.
+  if (gsym != NULL && gsym->is_defined_in_dynobj())
+    {
+      if (gsym->has_plt_offset())
+	address = target->plt_section()->address() + gsym->plt_offset();
+      else
+	gold_unreachable();
+    }
+
   switch (r_type)
     {
     case elfcpp::R_386_NONE:
@@ -584,30 +926,26 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo,
       break;
 
     case elfcpp::R_386_PLT32:
-      if (gsym->is_resolved_locally())
-	Relocate_functions<32, false>::pcrel32(view, value, address);
-      else
-	fprintf(stderr, _("%s: %s: unsupported reloc %u\n"),
-		program_name,
-		relinfo->location(relnum, rel.get_r_offset()).c_str(),
-		r_type);
+      gold_assert(gsym->has_plt_offset()
+		  || gsym->final_value_is_known(relinfo->options));
+      Relocate_functions<32, false>::pcrel32(view, value, address);
       break;
 
     case elfcpp::R_386_GOT32:
       // Local GOT offsets not yet supported.
-      assert(gsym);
-      assert(gsym->has_got_offset());
+      gold_assert(gsym);
+      gold_assert(gsym->has_got_offset());
       value = gsym->got_offset();
       Relocate_functions<32, false>::rel32(view, value);
       break;
 
     case elfcpp::R_386_GOTOFF:
-      value -= target->got_section(NULL, NULL)->address();
+      value -= target->got_section(NULL, NULL, NULL)->address();
       Relocate_functions<32, false>::rel32(view, value);
       break;
 
     case elfcpp::R_386_GOTPC:
-      value = target->got_section(NULL, NULL)->address();
+      value = target->got_section(NULL, NULL, NULL)->address();
       Relocate_functions<32, false>::pcrel32(view, value, address);
       break;
 
@@ -685,9 +1023,11 @@ Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo,
       gold_exit(false);
     }
 
-  const bool is_local = gsym == NULL || gsym->is_resolved_locally();
+  const bool is_final = (gsym == NULL
+			 ? !relinfo->options->is_shared()
+			 : gsym->final_value_is_known(relinfo->options));
   const unsigned int opt_r_type =
-    Target_i386::optimize_tls_reloc(relinfo->options, is_local, r_type);
+    Target_i386::optimize_tls_reloc(relinfo->options, is_final, r_type);
   switch (r_type)
     {
     case elfcpp::R_386_TLS_LE_32:
@@ -955,7 +1295,7 @@ Target_i386::relocate_section(const Relocate_info<32, false>* relinfo,
 			      elfcpp::Elf_types<32>::Elf_Addr address,
 			      off_t view_size)
 {
-  assert(sh_type == elfcpp::SHT_REL);
+  gold_assert(sh_type == elfcpp::SHT_REL);
 
   gold::relocate_section<32, false, Target_i386, elfcpp::SHT_REL,
 			 Target_i386::Relocate>(
diff --git a/gold/layout.cc b/gold/layout.cc
index f9f5548..97917b0 100644
--- a/gold/layout.cc
+++ b/gold/layout.cc
@@ -2,7 +2,6 @@
 
 #include "gold.h"
 
-#include <cassert>
 #include <cstring>
 #include <algorithm>
 #include <iostream>
@@ -10,6 +9,7 @@
 
 #include "output.h"
 #include "symtab.h"
+#include "dynobj.h"
 #include "layout.h"
 
 namespace gold
@@ -39,13 +39,18 @@ Layout_task_runner::run(Workqueue* workqueue)
 // Layout methods.
 
 Layout::Layout(const General_options& options)
-  : options_(options), namepool_(), sympool_(), signatures_(),
+  : options_(options), namepool_(), sympool_(), dynpool_(), signatures_(),
     section_name_map_(), segment_list_(), section_list_(),
-    special_output_list_(), tls_segment_(NULL)
+    unattached_section_list_(), special_output_list_(),
+    tls_segment_(NULL), symtab_section_(NULL), dynsym_section_(NULL)
 {
   // Make space for more than enough segments for a typical file.
   // This is just for efficiency--it's OK if we wind up needing more.
-  segment_list_.reserve(12);
+  this->segment_list_.reserve(12);
+
+  // We expect three unattached Output_data objects: the file header,
+  // the segment headers, and the section headers.
+  this->special_output_list_.reserve(3);
 }
 
 // Hash a key we use to look up an output section mapping.
@@ -219,9 +224,10 @@ Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
 			    elfcpp::Elf_Xword flags)
 {
   Output_section* os = new Output_section(name, type, flags, true);
+  this->section_list_.push_back(os);
 
   if ((flags & elfcpp::SHF_ALLOC) == 0)
-    this->section_list_.push_back(os);
+    this->unattached_section_list_.push_back(os);
   else
     {
       // This output section goes into a PT_LOAD segment.
@@ -299,6 +305,28 @@ Layout::make_output_section(const char* name, elfcpp::Elf_Word type,
   return os;
 }
 
+// Create the dynamic sections which are needed before we read the
+// relocs.
+
+void
+Layout::create_initial_dynamic_sections(const Input_objects* input_objects,
+					Symbol_table* symtab)
+{
+  if (!input_objects->any_dynamic())
+    return;
+
+  const char* dynamic_name = this->namepool_.add(".dynamic", NULL);
+  this->dynamic_section_ = this->make_output_section(dynamic_name,
+						     elfcpp::SHT_DYNAMIC,
+						     (elfcpp::SHF_ALLOC
+						      | elfcpp::SHF_WRITE));
+
+  symtab->define_in_output_data(input_objects->target(), "_DYNAMIC",
+				this->dynamic_section_, 0, 0,
+				elfcpp::STT_OBJECT, elfcpp::STB_LOCAL,
+				elfcpp::STV_HIDDEN, 0, false, false);
+}
+
 // Find the first read-only PT_LOAD segment, creating one if
 // necessary.
 
@@ -355,7 +383,8 @@ Layout::find_first_load_seg()
 off_t
 Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
 {
-  const int size = input_objects->target()->get_size();
+  const Target* const target = input_objects->target();
+  const int size = target->get_size();
 
   Output_segment* phdr_seg = NULL;
   if (input_objects->any_dynamic())
@@ -368,17 +397,22 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
       phdr_seg = new Output_segment(elfcpp::PT_PHDR, elfcpp::PF_R);
       this->segment_list_.push_back(phdr_seg);
 
+      // This holds the dynamic tags.
+      Output_data_dynamic* odyn;
+      odyn = new Output_data_dynamic(input_objects->target(),
+				     &this->dynpool_);
+
       // Create the dynamic symbol table, including the hash table,
       // the dynamic relocations, and the version sections.
-      this->create_dynamic_symtab(size, symtab);
-
-      // Create the .dynamic section to hold the dynamic data, and put
-      // it in a PT_DYNAMIC segment.
-      this->create_dynamic_section();
+      this->create_dynamic_symtab(target, odyn, symtab);
 
       // Create the .interp section to hold the name of the
       // interpreter, and put it in a PT_INTERP segment.
-      this->create_interp(input_objects->target());
+      this->create_interp(target);
+
+      // Finish the .dynamic section to hold the dynamic data, and put
+      // it in a PT_DYNAMIC segment.
+      this->finish_dynamic_section(input_objects, symtab, odyn);
     }
 
   // FIXME: Handle PT_GNU_STACK.
@@ -386,7 +420,7 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
   Output_segment* load_seg = this->find_first_load_seg();
 
   // Lay out the segment headers.
-  bool big_endian = input_objects->target()->is_big_endian();
+  bool big_endian = target->is_big_endian();
   Output_segment_headers* segment_headers;
   segment_headers = new Output_segment_headers(size, big_endian,
 					       this->segment_list_);
@@ -400,7 +434,7 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
   file_header = new Output_file_header(size,
 				       big_endian,
 				       this->options_,
-				       input_objects->target(),
+				       target,
 				       symtab,
 				       segment_headers);
   load_seg->add_initial_output_data(file_header);
@@ -412,15 +446,13 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
 
   // Set the file offsets of all the segments, and all the sections
   // they contain.
-  off_t off = this->set_segment_offsets(input_objects->target(), load_seg,
-					&shndx);
+  off_t off = this->set_segment_offsets(target, load_seg, &shndx);
 
   // Create the symbol table sections.
   // FIXME: We don't need to do this if we are stripping symbols.
-  Output_section* osymtab;
   Output_section* ostrtab;
   this->create_symtab_sections(size, input_objects, symtab, &off,
-			       &osymtab, &ostrtab);
+			       &ostrtab);
 
   // Create the .shstrtab section.
   Output_section* shstrtab_section = this->create_shstrtab();
@@ -430,7 +462,7 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
   off = this->set_section_offsets(off, &shndx);
 
   // Now the section index of OSTRTAB is set.
-  osymtab->set_link(ostrtab->out_shndx());
+  this->symtab_section_->set_link(ostrtab->out_shndx());
 
   // Create the section table header.
   Output_section_headers* oshdrs = this->create_shdrs(size, big_endian, &off);
@@ -438,6 +470,7 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab)
   file_header->set_section_info(oshdrs, shstrtab_section);
 
   // Now we know exactly where everything goes in the output file.
+  Output_data::layout_complete();
 
   return off;
 }
@@ -457,7 +490,7 @@ Layout::segment_precedes(const Output_segment* seg1,
   // segment.  We simply make it always first.
   if (type1 == elfcpp::PT_PHDR)
     {
-      assert(type2 != elfcpp::PT_PHDR);
+      gold_assert(type2 != elfcpp::PT_PHDR);
       return true;
     }
   if (type2 == elfcpp::PT_PHDR)
@@ -467,7 +500,7 @@ Layout::segment_precedes(const Output_segment* seg1,
   // segment.  We simply make it always second.
   if (type1 == elfcpp::PT_INTERP)
     {
-      assert(type2 != elfcpp::PT_INTERP);
+      gold_assert(type2 != elfcpp::PT_INTERP);
       return true;
     }
   if (type2 == elfcpp::PT_INTERP)
@@ -497,7 +530,7 @@ Layout::segment_precedes(const Output_segment* seg1,
     {
       if (type1 != type2)
 	return type1 < type2;
-      assert(flags1 != flags2);
+      gold_assert(flags1 != flags2);
       return flags1 < flags2;
     }
 
@@ -522,7 +555,7 @@ Layout::segment_precedes(const Output_segment* seg1,
 
   uint64_t paddr1 = seg1->paddr();
   uint64_t paddr2 = seg2->paddr();
-  assert(paddr1 != paddr2);
+  gold_assert(paddr1 != paddr2);
   return paddr1 < paddr2;
 }
 
@@ -550,7 +583,7 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
       if ((*p)->type() == elfcpp::PT_LOAD)
 	{
 	  if (load_seg != NULL && load_seg != *p)
-	    abort();
+	    gold_unreachable();
 	  load_seg = NULL;
 
 	  // If the last segment was readonly, and this one is not,
@@ -630,8 +663,8 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg,
 off_t
 Layout::set_section_offsets(off_t off, unsigned int* pshndx)
 {
-  for (Layout::Section_list::iterator p = this->section_list_.begin();
-       p != this->section_list_.end();
+  for (Section_list::iterator p = this->unattached_section_list_.begin();
+       p != this->unattached_section_list_.end();
        ++p)
     {
       (*p)->set_out_shndx(*pshndx);
@@ -651,7 +684,6 @@ void
 Layout::create_symtab_sections(int size, const Input_objects* input_objects,
 			       Symbol_table* symtab,
 			       off_t* poff,
-			       Output_section** posymtab,
 			       Output_section** postrtab)
 {
   int symsize;
@@ -667,7 +699,7 @@ Layout::create_symtab_sections(int size, const Input_objects* input_objects,
       align = 8;
     }
   else
-    abort();
+    gold_unreachable();
 
   off_t off = *poff;
   off = align_address(off, align);
@@ -678,6 +710,21 @@ Layout::create_symtab_sections(int size, const Input_objects* input_objects,
   off += symsize;
   unsigned int local_symbol_index = 1;
 
+  // Add STT_SECTION symbols for each Output section which needs one.
+  for (Section_list::iterator p = this->section_list_.begin();
+       p != this->section_list_.end();
+       ++p)
+    {
+      if (!(*p)->needs_symtab_index())
+	(*p)->set_symtab_index(-1U);
+      else
+	{
+	  (*p)->set_symtab_index(local_symbol_index);
+	  ++local_symbol_index;
+	  off += symsize;
+	}
+    }
+
   for (Input_objects::Relobj_iterator p = input_objects->relobj_begin();
        p != input_objects->relobj_end();
        ++p)
@@ -691,30 +738,35 @@ Layout::create_symtab_sections(int size, const Input_objects* input_objects,
     }
 
   unsigned int local_symcount = local_symbol_index;
-  assert(local_symcount * symsize == off - startoff);
+  gold_assert(local_symcount * symsize == off - startoff);
 
   off = symtab->finalize(local_symcount, off, &this->sympool_);
 
   this->sympool_.set_string_offsets();
 
   const char* symtab_name = this->namepool_.add(".symtab", NULL);
-  Output_section* osymtab = new Output_section_symtab(symtab_name,
-						      off - startoff);
-  this->section_list_.push_back(osymtab);
+  Output_section* osymtab = this->make_output_section(symtab_name,
+						      elfcpp::SHT_SYMTAB,
+						      0);
+  this->symtab_section_ = osymtab;
+
+  Output_section_data* pos = new Output_data_space(off - startoff,
+						   align);
+  osymtab->add_output_section_data(pos);
 
   const char* strtab_name = this->namepool_.add(".strtab", NULL);
-  Output_section *ostrtab = new Output_section_strtab(strtab_name,
-						      &this->sympool_);
-  this->section_list_.push_back(ostrtab);
-  this->special_output_list_.push_back(ostrtab);
+  Output_section* ostrtab = this->make_output_section(strtab_name,
+						      elfcpp::SHT_STRTAB,
+						      0);
+
+  Output_section_data* pstr = new Output_data_strtab(&this->sympool_);
+  ostrtab->add_output_section_data(pstr);
 
   osymtab->set_address(0, startoff);
   osymtab->set_info(local_symcount);
   osymtab->set_entsize(symsize);
-  osymtab->set_addralign(align);
 
   *poff = off;
-  *posymtab = osymtab;
   *postrtab = ostrtab;
 }
 
@@ -732,10 +784,10 @@ Layout::create_shstrtab()
 
   this->namepool_.set_string_offsets();
 
-  Output_section* os = new Output_section_strtab(name, &this->namepool_);
+  Output_section* os = this->make_output_section(name, elfcpp::SHT_STRTAB, 0);
 
-  this->section_list_.push_back(os);
-  this->special_output_list_.push_back(os);
+  Output_section_data* posd = new Output_data_strtab(&this->namepool_);
+  os->add_output_section_data(posd);
 
   return os;
 }
@@ -748,7 +800,7 @@ Layout::create_shdrs(int size, bool big_endian, off_t* poff)
 {
   Output_section_headers* oshdrs;
   oshdrs = new Output_section_headers(size, big_endian, this->segment_list_,
-				      this->section_list_,
+				      this->unattached_section_list_,
 				      &this->namepool_);
   off_t off = align_address(*poff, oshdrs->addralign());
   oshdrs->set_address(0, off);
@@ -761,17 +813,109 @@ Layout::create_shdrs(int size, bool big_endian, off_t* poff)
 // Create the dynamic symbol table.
 
 void
-Layout::create_dynamic_symtab(int, Symbol_table*)
+Layout::create_dynamic_symtab(const Target* target, Output_data_dynamic* odyn,
+			      Symbol_table* symtab)
 {
-  abort();
-}
+  // Count all the symbols in the dynamic symbol table, and set the
+  // dynamic symbol indexes.
 
-// Create the .dynamic section and PT_DYNAMIC segment.
+  // Skip symbol 0, which is always all zeroes.
+  unsigned int index = 1;
 
-void
-Layout::create_dynamic_section()
-{
-  abort();
+  // Add STT_SECTION symbols for each Output section which needs one.
+  for (Section_list::iterator p = this->section_list_.begin();
+       p != this->section_list_.end();
+       ++p)
+    {
+      if (!(*p)->needs_dynsym_index())
+	(*p)->set_dynsym_index(-1U);
+      else
+	{
+	  (*p)->set_dynsym_index(index);
+	  ++index;
+	}
+    }
+
+  // FIXME: Some targets apparently require local symbols in the
+  // dynamic symbol table.  Here is where we will have to count them,
+  // and set the dynamic symbol indexes, and add the names to
+  // this->dynpool_.
+
+  unsigned int local_symcount = index;
+
+  std::vector<Symbol*> dynamic_symbols;
+
+  // FIXME: We have to tell set_dynsym_indexes whether the
+  // -E/--export-dynamic option was used.
+  index = symtab->set_dynsym_indexes(index, &dynamic_symbols,
+				     &this->dynpool_);
+
+  int symsize;
+  unsigned int align;
+  const int size = target->get_size();
+  if (size == 32)
+    {
+      symsize = elfcpp::Elf_sizes<32>::sym_size;
+      align = 4;
+    }
+  else if (size == 64)
+    {
+      symsize = elfcpp::Elf_sizes<64>::sym_size;
+      align = 8;
+    }
+  else
+    gold_unreachable();
+
+  const char* dynsym_name = this->namepool_.add(".dynsym", NULL);
+  Output_section* dynsym = this->make_output_section(dynsym_name,
+						     elfcpp::SHT_DYNSYM,
+						     elfcpp::SHF_ALLOC);
+
+  Output_section_data* odata = new Output_data_space(index * symsize,
+						     align);
+  dynsym->add_output_section_data(odata);
+
+  dynsym->set_info(local_symcount);
+  dynsym->set_entsize(symsize);
+  dynsym->set_addralign(align);
+
+  this->dynsym_section_ = dynsym;
+
+  odyn->add_section_address(elfcpp::DT_SYMTAB, dynsym);
+  odyn->add_constant(elfcpp::DT_SYMENT, symsize);
+
+  const char* dynstr_name = this->namepool_.add(".dynstr", NULL);
+  Output_section* dynstr = this->make_output_section(dynstr_name,
+						     elfcpp::SHT_STRTAB,
+						     elfcpp::SHF_ALLOC);
+
+  Output_section_data* strdata = new Output_data_strtab(&this->dynpool_);
+  dynstr->add_output_section_data(strdata);
+
+  odyn->add_section_address(elfcpp::DT_STRTAB, dynstr);
+  odyn->add_section_size(elfcpp::DT_STRSZ, dynstr);
+
+  // FIXME: We need an option to create a GNU hash table.
+
+  unsigned char* phash;
+  unsigned int hashlen;
+  Dynobj::create_elf_hash_table(target, dynamic_symbols, local_symcount,
+				&phash, &hashlen);
+
+  const char* hash_name = this->namepool_.add(".hash", NULL);
+  Output_section* hashsec = this->make_output_section(hash_name,
+						      elfcpp::SHT_HASH,
+						      elfcpp::SHF_ALLOC);
+
+  Output_section_data* hashdata = new Output_data_const_buffer(phash,
+							       hashlen,
+							       align);
+  hashsec->add_output_section_data(hashdata);
+
+  hashsec->set_entsize(4);
+  // FIXME: .hash should link to .dynsym.
+
+  odyn->add_section_address(elfcpp::DT_HASH, hashsec);
 }
 
 // Create the .interp section and PT_INTERP segment.
@@ -783,7 +927,7 @@ Layout::create_interp(const Target* target)
   if (interp == NULL)
     {
       interp = target->dynamic_linker();
-      assert(interp != NULL);
+      gold_assert(interp != NULL);
     }
 
   size_t len = strlen(interp) + 1;
@@ -801,6 +945,41 @@ Layout::create_interp(const Target* target)
   oseg->add_initial_output_section(osec, elfcpp::PF_R);
 }
 
+// Finish the .dynamic section and PT_DYNAMIC segment.
+
+void
+Layout::finish_dynamic_section(const Input_objects* input_objects,
+			       const Symbol_table* symtab,
+			       Output_data_dynamic* odyn)
+{
+  this->dynamic_section_->add_output_section_data(odyn);
+
+  Output_segment* oseg = new Output_segment(elfcpp::PT_DYNAMIC,
+					    elfcpp::PF_R | elfcpp::PF_W);
+  this->segment_list_.push_back(oseg);
+  oseg->add_initial_output_section(this->dynamic_section_,
+				   elfcpp::PF_R | elfcpp::PF_W);
+
+  for (Input_objects::Dynobj_iterator p = input_objects->dynobj_begin();
+       p != input_objects->dynobj_end();
+       ++p)
+    {
+      // FIXME: Handle --as-needed.
+      odyn->add_string(elfcpp::DT_NEEDED, (*p)->soname());
+    }
+
+  // FIXME: Support --init and --fini.
+  Symbol* sym = symtab->lookup("_init");
+  if (sym != NULL && sym->is_defined() && !sym->is_defined_in_dynobj())
+    odyn->add_symbol(elfcpp::DT_INIT, sym);
+
+  sym = symtab->lookup("_fini");
+  if (sym != NULL && sym->is_defined() && !sym->is_defined_in_dynobj())
+    odyn->add_symbol(elfcpp::DT_FINI, sym);
+
+  // FIXME: Support DT_INIT_ARRAY and DT_FINI_ARRAY.
+}
+
 // The mapping of .gnu.linkonce section names to real section names.
 
 #define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 }
@@ -950,8 +1129,51 @@ Layout::add_comdat(const char* signature, bool group)
 // Write out data not associated with a section or the symbol table.
 
 void
-Layout::write_data(Output_file* of) const
+Layout::write_data(const Symbol_table* symtab, const Target* target,
+		   Output_file* of) const
 {
+  const Output_section* symtab_section = this->symtab_section_;
+  for (Section_list::const_iterator p = this->section_list_.begin();
+       p != this->section_list_.end();
+       ++p)
+    {
+      if ((*p)->needs_symtab_index())
+	{
+	  gold_assert(symtab_section != NULL);
+	  unsigned int index = (*p)->symtab_index();
+	  gold_assert(index > 0 && index != -1U);
+	  off_t off = (symtab_section->offset()
+		       + index * symtab_section->entsize());
+	  symtab->write_section_symbol(target, *p, of, off);
+	}
+    }
+
+  const Output_section* dynsym_section = this->dynsym_section_;
+  for (Section_list::const_iterator p = this->section_list_.begin();
+       p != this->section_list_.end();
+       ++p)
+    {
+      if ((*p)->needs_dynsym_index())
+	{
+	  gold_assert(dynsym_section != NULL);
+	  unsigned int index = (*p)->dynsym_index();
+	  gold_assert(index > 0 && index != -1U);
+	  off_t off = (dynsym_section->offset()
+		       + index * dynsym_section->entsize());
+	  symtab->write_section_symbol(target, *p, of, off);
+	}
+    }
+
+  // Write out the Output_sections.  Most won't have anything to
+  // write, since most of the data will come from input sections which
+  // are handled elsewhere.  But some Output_sections do have
+  // Output_data.
+  for (Section_list::const_iterator p = this->section_list_.begin();
+       p != this->section_list_.end();
+       ++p)
+    (*p)->write(of);
+
+  // Write out the Output_data which are not in an Output_section.
   for (Data_list::const_iterator p = this->special_output_list_.begin();
        p != this->special_output_list_.end();
        ++p)
@@ -981,7 +1203,7 @@ Write_data_task::locks(Workqueue* workqueue)
 void
 Write_data_task::run(Workqueue*)
 {
-  this->layout_->write_data(this->of_);
+  this->layout_->write_data(this->symtab_, this->target_, this->of_);
 }
 
 // Write_symbols_task methods.
diff --git a/gold/layout.h b/gold/layout.h
index 759fd85..26948bb 100644
--- a/gold/layout.h
+++ b/gold/layout.h
@@ -20,10 +20,10 @@ class Input_objects;
 class Symbol_table;
 class Output_section_data;
 class Output_section;
-class Output_section_symtab;
 class Output_section_headers;
 class Output_segment;
 class Output_data;
+class Output_data_dynamic;
 class Target;
 
 // This task function handles mapping the input sections to output
@@ -80,6 +80,10 @@ class Layout
 			  elfcpp::Elf_Xword flags,
 			  Output_section_data*);
 
+  // Create dynamic sections if necessary.
+  void
+  create_initial_dynamic_sections(const Input_objects*, Symbol_table*);
+
   // Return the Stringpool used for symbol names.
   const Stringpool*
   sympool() const
@@ -110,7 +114,7 @@ class Layout
   // Write out data not associated with an input file or the symbol
   // table.
   void
-  write_data(Output_file*) const;
+  write_data(const Symbol_table*, const Target*, Output_file*) const;
 
   // Return an output section named NAME, or NULL if there is none.
   Output_section*
@@ -128,11 +132,11 @@ class Layout
 
   // The list of sections not attached to a segment.
 
-  typedef std::list<Output_section*> Section_list;
+  typedef std::vector<Output_section*> Section_list;
 
   // The list of information to write out which is not attached to
   // either a section or a segment.
-  typedef std::list<Output_data*> Data_list;
+  typedef std::vector<Output_data*> Data_list;
 
  private:
   Layout(const Layout&);
@@ -157,7 +161,6 @@ class Layout
   // Create the output sections for the symbol table.
   void
   create_symtab_sections(int size, const Input_objects*, Symbol_table*, off_t*,
-			 Output_section** osymtab,
 			 Output_section** ostrtab);
 
   // Create the .shstrtab section.
@@ -170,11 +173,12 @@ class Layout
 
   // Create the dynamic symbol table.
   void
-  create_dynamic_symtab(int size, Symbol_table*);
+  create_dynamic_symtab(const Target*, Output_data_dynamic*, Symbol_table*);
 
-  // Create the .dynamic section and PT_DYNAMIC segment.
+  // Finish the .dynamic section and PT_DYNAMIC segment.
   void
-  create_dynamic_section();
+  finish_dynamic_section(const Input_objects*, const Symbol_table*,
+			 Output_data_dynamic*);
 
   // Create the .interp section and PT_INTERP segment.
   void
@@ -256,20 +260,30 @@ class Layout
   Stringpool namepool_;
   // The output symbol names.
   Stringpool sympool_;
+  // The dynamic strings, if needed.
+  Stringpool dynpool_;
   // The list of group sections and linkonce sections which we have seen.
   Signatures signatures_;
   // The mapping from input section name/type/flags to output sections.
   Section_name_map section_name_map_;
   // The list of output segments.
   Segment_list segment_list_;
+  // The list of output sections.
+  Section_list section_list_;
   // The list of output sections which are not attached to any output
   // segment.
-  Section_list section_list_;
-  // The list of sections which require special output because they
-  // are not comprised of input sections.
+  Section_list unattached_section_list_;
+  // The list of unattached Output_data objects which require special
+  // handling because they are not Output_sections.
   Data_list special_output_list_;
   // A pointer to the PT_TLS segment if there is one.
   Output_segment* tls_segment_;
+  // The SHT_SYMTAB output section.
+  Output_section* symtab_section_;
+  // The SHT_DYNSYM output section if there is one.
+  Output_section* dynsym_section_;
+  // The SHT_DYNAMIC output section if there is one.
+  Output_section* dynamic_section_;
 };
 
 // This task handles writing out data which is not part of a section
@@ -278,9 +292,11 @@ class Layout
 class Write_data_task : public Task
 {
  public:
-  Write_data_task(const Layout* layout, Output_file* of,
+  Write_data_task(const Layout* layout, const Symbol_table* symtab,
+		  const Target* target, Output_file* of,
 		  Task_token* final_blocker)
-    : layout_(layout), of_(of), final_blocker_(final_blocker)
+    : layout_(layout), symtab_(symtab), target_(target), of_(of),
+      final_blocker_(final_blocker)
   { }
 
   // The standard Task methods.
@@ -296,6 +312,8 @@ class Write_data_task : public Task
 
  private:
   const Layout* layout_;
+  const Symbol_table* symtab_;
+  const Target* target_;
   Output_file* of_;
   Task_token* final_blocker_;
 };
diff --git a/gold/object.cc b/gold/object.cc
index 74c1347..2086fed 100644
--- a/gold/object.cc
+++ b/gold/object.cc
@@ -4,7 +4,6 @@
 
 #include <cerrno>
 #include <cstring>
-#include <cassert>
 #include <cstdarg>
 
 #include "target-select.h"
@@ -210,7 +209,7 @@ Sized_relobj<size, big_endian>::do_read_symbols(Read_symbols_data* sd)
   // Get the symbol table section header.
   typename This::Shdr symtabshdr(pshdrs
 				 + this->symtab_shndx_ * This::shdr_size);
-  assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
+  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 
   // We only need the external symbols.
   const int sym_size = This::sym_size;
@@ -477,7 +476,7 @@ Sized_relobj<size, big_endian>::do_add_symbols(Symbol_table* symtab,
 {
   if (sd->symbols == NULL)
     {
-      assert(sd->symbol_names == NULL);
+      gold_assert(sd->symbol_names == NULL);
       return;
     }
 
@@ -517,14 +516,14 @@ Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
 							  off_t off,
 							  Stringpool* pool)
 {
-  assert(this->symtab_shndx_ != -1U);
+  gold_assert(this->symtab_shndx_ != -1U);
   if (this->symtab_shndx_ == 0)
     {
       // This object has no symbols.  Weird but legal.
       return index;
     }
 
-  assert(off == static_cast<off_t>(align_address(off, size >> 3)));
+  gold_assert(off == static_cast<off_t>(align_address(off, size >> 3)));
 
   this->local_symbol_offset_ = off;
 
@@ -532,12 +531,12 @@ Sized_relobj<size, big_endian>::do_finalize_local_symbols(unsigned int index,
   const unsigned int symtab_shndx = this->symtab_shndx_;
   typename This::Shdr symtabshdr(this,
 				 this->elf_file_.section_header(symtab_shndx));
-  assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
+  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
 
   // Read the local symbols.
   const int sym_size = This::sym_size;
   const unsigned int loccount = this->local_symbol_count_;
-  assert(loccount == symtabshdr.get_sh_info());
+  gold_assert(loccount == symtabshdr.get_sh_info());
   off_t locsize = loccount * sym_size;
   const unsigned char* psyms = this->get_view(symtabshdr.get_sh_offset(),
 					      locsize);
@@ -641,7 +640,7 @@ void
 Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
 						    const Stringpool* sympool)
 {
-  assert(this->symtab_shndx_ != -1U);
+  gold_assert(this->symtab_shndx_ != -1U);
   if (this->symtab_shndx_ == 0)
     {
       // This object has no symbols.  Weird but legal.
@@ -652,9 +651,9 @@ Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
   const unsigned int symtab_shndx = this->symtab_shndx_;
   typename This::Shdr symtabshdr(this,
 				 this->elf_file_.section_header(symtab_shndx));
-  assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
+  gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
   const unsigned int loccount = this->local_symbol_count_;
-  assert(loccount == symtabshdr.get_sh_info());
+  gold_assert(loccount == symtabshdr.get_sh_info());
 
   // Read the local symbols.
   const int sym_size = This::sym_size;
@@ -676,8 +675,8 @@ Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
 
   const std::vector<Map_to_output>& mo(this->map_to_output());
 
-  assert(this->local_values_.size() == loccount);
-  assert(this->local_indexes_.size() == loccount);
+  gold_assert(this->local_values_.size() == loccount);
+  gold_assert(this->local_indexes_.size() == loccount);
 
   unsigned char* ov = oview;
   psyms += sym_size;
@@ -687,12 +686,12 @@ Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
 
       if (this->local_indexes_[i] == -1U)
 	continue;
-      assert(this->local_indexes_[i] != 0);
+      gold_assert(this->local_indexes_[i] != 0);
 
       unsigned int st_shndx = isym.get_st_shndx();
       if (st_shndx < elfcpp::SHN_LORESERVE)
 	{
-	  assert(st_shndx < mo.size());
+	  gold_assert(st_shndx < mo.size());
 	  if (mo[st_shndx].output_section == NULL)
 	    continue;
 	  st_shndx = mo[st_shndx].output_section->out_shndx();
@@ -700,7 +699,7 @@ Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
 
       elfcpp::Sym_write<size, big_endian> osym(ov);
 
-      assert(isym.get_st_name() < strtab_size);
+      gold_assert(isym.get_st_name() < strtab_size);
       const char* name = pnames + isym.get_st_name();
       osym.put_st_name(sympool->get_offset(name));
       osym.put_st_value(this->local_values_[i]);
@@ -712,7 +711,7 @@ Sized_relobj<size, big_endian>::write_local_symbols(Output_file* of,
       ov += sym_size;
     }
 
-  assert(ov - oview == output_size);
+  gold_assert(ov - oview == output_size);
 
   of->write_output_view(this->local_symbol_offset_, output_size, oview);
 }
diff --git a/gold/object.h b/gold/object.h
index b2f4706..cd2bc8d 100644
--- a/gold/object.h
+++ b/gold/object.h
@@ -3,7 +3,6 @@
 #ifndef GOLD_OBJECT_H
 #define GOLD_OBJECT_H
 
-#include <cassert>
 #include <string>
 #include <vector>
 
@@ -166,8 +165,13 @@ class Object
   // Return the name of a section given a section index.  This is only
   // used for error messages.
   std::string
-  section_name(unsigned int shnum)
-  { return this->do_section_name(shnum); }
+  section_name(unsigned int shndx)
+  { return this->do_section_name(shndx); }
+
+  // Return the section flags given a section index.
+  uint64_t
+  section_flags(unsigned int shndx)
+  { return this->do_section_flags(shndx); }
 
   // Functions and types for the elfcpp::Elf_file interface.  This
   // permit us to use Object as the File template parameter for
@@ -233,11 +237,15 @@ class Object
   // Return the location of the contents of a section.  Implemented by
   // child class.
   virtual Location
-  do_section_contents(unsigned int shnum) = 0;
+  do_section_contents(unsigned int shndx) = 0;
 
   // Get the name of a section--implemented by child class.
   virtual std::string
-  do_section_name(unsigned int shnum) = 0;
+  do_section_name(unsigned int shndx) = 0;
+
+  // Get section flags--implemented by child class.
+  virtual uint64_t
+  do_section_flags(unsigned int shndx) = 0;
 
   // Get the file.
   Input_file*
@@ -324,8 +332,8 @@ template<int size, bool big_endian>
 inline Sized_target<size, big_endian>*
 Object::sized_target(ACCEPT_SIZE_ENDIAN_ONLY)
 {
-  assert(this->target_->get_size() == size);
-  assert(this->target_->is_big_endian() ? big_endian : !big_endian);
+  gold_assert(this->target_->get_size() == size);
+  gold_assert(this->target_->is_big_endian() ? big_endian : !big_endian);
   return static_cast<Sized_target<size, big_endian>*>(this->target_);
 }
 
@@ -367,7 +375,7 @@ class Relobj : public Object
   bool
   is_section_included(unsigned int shnum) const
   {
-    assert(shnum < this->map_to_output_.size());
+    gold_assert(shnum < this->map_to_output_.size());
     return this->map_to_output_[shnum].output_section != NULL;
   }
 
@@ -381,7 +389,7 @@ class Relobj : public Object
   void
   set_section_offset(unsigned int shndx, off_t off)
   {
-    assert(shndx < this->map_to_output_.size());
+    gold_assert(shndx < this->map_to_output_.size());
     this->map_to_output_[shndx].offset = off;
   }
 
@@ -431,7 +439,7 @@ class Relobj : public Object
 inline Output_section*
 Relobj::output_section(unsigned int shnum, off_t* poff)
 {
-  assert(shnum < this->map_to_output_.size());
+  gold_assert(shnum < this->map_to_output_.size());
   const Map_to_output& mo(this->map_to_output_[shnum]);
   *poff = mo.offset;
   return mo.output_section;
@@ -460,8 +468,8 @@ class Sized_relobj : public Relobj
   unsigned int
   symtab_index(unsigned int sym) const
   {
-    assert(sym < this->local_indexes_.size());
-    assert(this->local_indexes_[sym] != 0);
+    gold_assert(sym < this->local_indexes_.size());
+    gold_assert(this->local_indexes_[sym] != 0);
     return this->local_indexes_[sym];
   }
 
@@ -506,6 +514,11 @@ class Sized_relobj : public Relobj
   do_section_contents(unsigned int shndx)
   { return this->elf_file_.section_contents(shndx); }
 
+  // Return section flags.
+  uint64_t
+  do_section_flags(unsigned int shndx)
+  { return this->elf_file_.section_flags(shndx); }
+
   // Return the appropriate Sized_target structure.
   Sized_target<size, big_endian>*
   sized_target()
diff --git a/gold/options.cc b/gold/options.cc
index 6b88429..b8339e8 100644
--- a/gold/options.cc
+++ b/gold/options.cc
@@ -291,8 +291,8 @@ Input_arguments::add_file(const Input_file_argument& file)
     this->input_argument_list_.push_back(Input_argument(file));
   else
     {
-      assert(!this->input_argument_list_.empty());
-      assert(this->input_argument_list_.back().is_group());
+      gold_assert(!this->input_argument_list_.empty());
+      gold_assert(this->input_argument_list_.back().is_group());
       this->input_argument_list_.back().group()->add_file(file);
     }
 }
@@ -302,7 +302,7 @@ Input_arguments::add_file(const Input_file_argument& file)
 void
 Input_arguments::start_group()
 {
-  assert(!this->in_group_);
+  gold_assert(!this->in_group_);
   Input_file_group* group = new Input_file_group();
   this->input_argument_list_.push_back(Input_argument(group));
   this->in_group_ = true;
@@ -313,7 +313,7 @@ Input_arguments::start_group()
 void
 Input_arguments::end_group()
 {
-  assert(this->in_group_);
+  gold_assert(this->in_group_);
   this->in_group_ = false;
 }
 
diff --git a/gold/options.h b/gold/options.h
index ac51524..56907c0 100644
--- a/gold/options.h
+++ b/gold/options.h
@@ -15,7 +15,6 @@
 #include <list>
 #include <string>
 #include <vector>
-#include <cassert>
 
 namespace gold
 {
@@ -218,7 +217,7 @@ class Input_argument
   const Input_file_argument&
   file() const
   {
-    assert(this->is_file_);
+    gold_assert(this->is_file_);
     return this->file_;
   }
 
@@ -226,14 +225,14 @@ class Input_argument
   const Input_file_group*
   group() const
   {
-    assert(!this->is_file_);
+    gold_assert(!this->is_file_);
     return this->group_;
   }
 
   Input_file_group*
   group()
   {
-    assert(!this->is_file_);
+    gold_assert(!this->is_file_);
     return this->group_;
   }
 
diff --git a/gold/output.cc b/gold/output.cc
index 0330384..e4720df 100644
--- a/gold/output.cc
+++ b/gold/output.cc
@@ -17,6 +17,10 @@
 namespace gold
 {
 
+// Output_data variables.
+
+bool Output_data::sizes_are_fixed;
+
 // Output_data methods.
 
 Output_data::~Output_data()
@@ -45,7 +49,7 @@ Output_data::default_alignment(int size)
   else if (size == 64)
     return 8;
   else
-    abort();
+    gold_unreachable();
 }
 
 // Output_section_header methods.  This currently assumes that the
@@ -55,12 +59,12 @@ Output_section_headers::Output_section_headers(
     int size,
     bool big_endian,
     const Layout::Segment_list& segment_list,
-    const Layout::Section_list& section_list,
+    const Layout::Section_list& unattached_section_list,
     const Stringpool* secnamepool)
   : size_(size),
     big_endian_(big_endian),
     segment_list_(segment_list),
-    section_list_(section_list),
+    unattached_section_list_(unattached_section_list),
     secnamepool_(secnamepool)
 {
   // Count all the sections.  Start with 1 for the null section.
@@ -70,7 +74,7 @@ Output_section_headers::Output_section_headers(
        ++p)
     if ((*p)->type() == elfcpp::PT_LOAD)
       count += (*p)->output_section_count();
-  count += section_list.size();
+  count += unattached_section_list.size();
 
   int shdr_size;
   if (size == 32)
@@ -78,7 +82,7 @@ Output_section_headers::Output_section_headers(
   else if (size == 64)
     shdr_size = elfcpp::Elf_sizes<64>::shdr_size;
   else
-    abort();
+    gold_unreachable();
 
   this->set_data_size(count * shdr_size);
 }
@@ -103,7 +107,7 @@ Output_section_headers::do_write(Output_file* of)
 	this->do_sized_write<64, false>(of);
     }
   else
-    abort();
+    gold_unreachable();
 }
 
 template<int size, bool big_endian>
@@ -139,11 +143,12 @@ Output_section_headers::do_sized_write(Output_file* of)
     v = (*p)->write_section_headers SELECT_SIZE_ENDIAN_NAME(size, big_endian) (
 	    this->secnamepool_, v, &shndx
 	    SELECT_SIZE_ENDIAN(size, big_endian));
-  for (Layout::Section_list::const_iterator p = this->section_list_.begin();
-       p != this->section_list_.end();
+  for (Layout::Section_list::const_iterator p =
+	 this->unattached_section_list_.begin();
+       p != this->unattached_section_list_.end();
        ++p)
     {
-      assert(shndx == (*p)->out_shndx());
+      gold_assert(shndx == (*p)->out_shndx());
       elfcpp::Shdr_write<size, big_endian> oshdr(v);
       (*p)->write_header(this->secnamepool_, &oshdr);
       v += shdr_size;
@@ -167,7 +172,7 @@ Output_segment_headers::Output_segment_headers(
   else if (size == 64)
     phdr_size = elfcpp::Elf_sizes<64>::phdr_size;
   else
-    abort();
+    gold_unreachable();
 
   this->set_data_size(segment_list.size() * phdr_size);
 }
@@ -190,7 +195,7 @@ Output_segment_headers::do_write(Output_file* of)
 	this->do_sized_write<64, false>(of);
     }
   else
-    abort();
+    gold_unreachable();
 }
 
 template<int size, bool big_endian>
@@ -237,7 +242,7 @@ Output_file_header::Output_file_header(int size,
   else if (size == 64)
     ehdr_size = elfcpp::Elf_sizes<64>::ehdr_size;
   else
-    abort();
+    gold_unreachable();
 
   this->set_data_size(ehdr_size);
 }
@@ -272,7 +277,7 @@ Output_file_header::do_write(Output_file* of)
 	this->do_sized_write<64, false>(of);
     }
   else
-    abort();
+    gold_unreachable();
 }
 
 // Write out the file header with appropriate size and endianess.
@@ -281,7 +286,7 @@ template<int size, bool big_endian>
 void
 Output_file_header::do_sized_write(Output_file* of)
 {
-  assert(this->offset() == 0);
+  gold_assert(this->offset() == 0);
 
   int ehdr_size = elfcpp::Elf_sizes<size>::ehdr_size;
   unsigned char* view = of->get_output_view(0, ehdr_size);
@@ -298,7 +303,7 @@ Output_file_header::do_sized_write(Output_file* of)
   else if (size == 64)
     e_ident[elfcpp::EI_CLASS] = elfcpp::ELFCLASS64;
   else
-    abort();
+    gold_unreachable();
   e_ident[elfcpp::EI_DATA] = (big_endian
 			      ? elfcpp::ELFDATA2MSB
 			      : elfcpp::ELFDATA2LSB);
@@ -352,9 +357,17 @@ Output_file_header::do_sized_write(Output_file* of)
 // Output_data_const methods.
 
 void
-Output_data_const::do_write(Output_file* output)
+Output_data_const::do_write(Output_file* of)
 {
-  output->write(this->offset(), data_.data(), data_.size());
+  of->write(this->offset(), this->data_.data(), this->data_.size());
+}
+
+// Output_data_const_buffer methods.
+
+void
+Output_data_const_buffer::do_write(Output_file* of)
+{
+  of->write(this->offset(), this->p_, this->data_size());
 }
 
 // Output_section_data methods.
@@ -362,10 +375,30 @@ Output_data_const::do_write(Output_file* output)
 unsigned int
 Output_section_data::do_out_shndx() const
 {
-  assert(this->output_section_ != NULL);
+  gold_assert(this->output_section_ != NULL);
   return this->output_section_->out_shndx();
 }
 
+// Output_data_strtab methods.
+
+// Set the address.  We don't actually care about the address, but we
+// do set our final size.
+
+void
+Output_data_strtab::do_set_address(uint64_t, off_t)
+{
+  this->strtab_->set_string_offsets();
+  this->set_data_size(this->strtab_->get_strtab_size());
+}
+
+// Write out a string table.
+
+void
+Output_data_strtab::do_write(Output_file* of)
+{
+  this->strtab_->write(of, this->offset());
+}
+
 // Output_reloc methods.
 
 // Get the symbol index of a relocation.
@@ -379,7 +412,7 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
   switch (this->local_sym_index_)
     {
     case INVALID_CODE:
-      abort();
+      gold_unreachable();
 
     case GSYM_CODE:
       if (this->u_.gsym == NULL)
@@ -403,13 +436,13 @@ Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::get_symbol_index()
 	  // FIXME: It seems that some targets may need to generate
 	  // dynamic relocations against local symbols for some
 	  // reasons.  This will have to be addressed at some point.
-	  abort();
+	  gold_unreachable();
 	}
       else
 	index = this->u_.object->symtab_index(this->local_sym_index_);
       break;
     }
-  assert(index != -1U);
+  gold_assert(index != -1U);
   return index;
 }
 
@@ -422,7 +455,10 @@ void
 Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>::write_rel(
     Write_rel* wr) const
 {
-  wr->put_r_offset(this->address_);
+  Address address = this->address_;
+  if (this->od_ != NULL)
+    address += this->od_->address();
+  wr->put_r_offset(address);
   wr->put_r_info(elfcpp::elf_r_info<size>(this->get_symbol_index(),
 					  this->type_));
 }
@@ -472,7 +508,7 @@ Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
       pov += reloc_size;
     }
 
-  assert(pov - oview == oview_size);
+  gold_assert(pov - oview == oview_size);
 
   of->write_output_view(off, oview_size, oview);
 
@@ -486,8 +522,9 @@ Output_data_reloc_base<sh_type, dynamic, size, big_endian>::do_write(
 
 template<int size, bool big_endian>
 void
-Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov)
-    const
+Output_data_got<size, big_endian>::Got_entry::write(
+    const General_options* options,
+    unsigned char* pov) const
 {
   Valtype val = 0;
 
@@ -501,7 +538,7 @@ Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov)
 	// value.  Otherwise we just write zero.  The target code is
 	// responsible for creating a relocation entry to fill in the
 	// value at runtime.
-	if (gsym->is_resolved_locally())
+	if (gsym->final_value_is_known(options))
 	  {
 	    Sized_symbol<size>* sgsym;
 	    // This cast is a bit ugly.  We don't want to put a
@@ -518,11 +555,10 @@ Output_data_got<size, big_endian>::Got_entry::write(unsigned char* pov)
       break;
 
     default:
-      abort();
+      gold_unreachable();
     }
 
-  Valtype* povv = reinterpret_cast<Valtype*>(pov);
-  elfcpp::Swap<size, big_endian>::writeval(povv, val);
+  elfcpp::Swap<size, big_endian>::writeval(pov, val);
 }
 
 // Output_data_got methods.
@@ -561,11 +597,11 @@ Output_data_got<size, big_endian>::do_write(Output_file* of)
        p != this->entries_.end();
        ++p)
     {
-      p->write(pov);
+      p->write(this->options_, pov);
       pov += add;
     }
 
-  assert(pov - oview == oview_size);
+  gold_assert(pov - oview == oview_size);
 
   of->write_output_view(off, oview_size, oview);
 
@@ -573,6 +609,121 @@ Output_data_got<size, big_endian>::do_write(Output_file* of)
   this->entries_.clear();
 }
 
+// Output_data_dynamic::Dynamic_entry methods.
+
+// Write out the entry.
+
+template<int size, bool big_endian>
+void
+Output_data_dynamic::Dynamic_entry::write(
+    unsigned char* pov,
+    const Stringpool* pool) const
+{
+  typename elfcpp::Elf_types<size>::Elf_WXword val;
+  switch (this->classification_)
+    {
+    case DYNAMIC_NUMBER:
+      val = this->u_.val;
+      break;
+
+    case DYNAMIC_SECTION_ADDRESS:
+      val = this->u_.os->address();
+      break;
+
+    case DYNAMIC_SECTION_SIZE:
+      val = this->u_.os->data_size();
+      break;
+
+    case DYNAMIC_SYMBOL:
+      {
+	Sized_symbol<size>* s = static_cast<Sized_symbol<size>*>(this->u_.sym);
+	val = s->value();
+      }
+      break;
+
+    case DYNAMIC_STRING:
+      val = pool->get_offset(this->u_.str);
+      break;
+
+    default:
+      gold_unreachable();
+    }
+
+  elfcpp::Dyn_write<size, big_endian> dw(pov);
+  dw.put_d_tag(this->tag_);
+  dw.put_d_val(val);
+}
+
+// Output_data_dynamic methods.
+
+// Set the final data size.
+
+void
+Output_data_dynamic::do_set_address(uint64_t, off_t)
+{
+  // Add the terminating entry.
+  this->add_constant(elfcpp::DT_NULL, 0);
+
+  int dyn_size;
+  if (this->target_->get_size() == 32)
+    dyn_size = elfcpp::Elf_sizes<32>::dyn_size;
+  else if (this->target_->get_size() == 64)
+    dyn_size = elfcpp::Elf_sizes<64>::dyn_size;
+  else
+    gold_unreachable();
+  this->set_data_size(this->entries_.size() * dyn_size);
+}
+
+// Write out the dynamic entries.
+
+void
+Output_data_dynamic::do_write(Output_file* of)
+{
+  if (this->target_->get_size() == 32)
+    {
+      if (this->target_->is_big_endian())
+	this->sized_write<32, true>(of);
+      else
+	this->sized_write<32, false>(of);
+    }
+  else if (this->target_->get_size() == 64)
+    {
+      if (this->target_->is_big_endian())
+	this->sized_write<64, true>(of);
+      else
+	this->sized_write<64, false>(of);
+    }
+  else
+    gold_unreachable();
+}
+
+template<int size, bool big_endian>
+void
+Output_data_dynamic::sized_write(Output_file* of)
+{
+  const int dyn_size = elfcpp::Elf_sizes<size>::dyn_size;
+
+  const off_t offset = this->offset();
+  const off_t oview_size = this->data_size();
+  unsigned char* const oview = of->get_output_view(offset, oview_size);
+
+  unsigned char* pov = oview;
+  for (typename Dynamic_entries::const_iterator p = this->entries_.begin();
+       p != this->entries_.end();
+       ++p)
+    {
+      p->write<size, big_endian>(pov, this->pool_);
+      pov += dyn_size;
+    }
+
+  gold_assert(pov - oview == oview_size);
+
+  of->write_output_view(offset, oview_size, oview);
+
+  // We no longer need the dynamic entries.
+  this->entries_.clear();
+}
+
 // Output_section::Input_section methods.
 
 // Return the data size.  For an input section we store the size here.
@@ -628,7 +779,9 @@ Output_section::Output_section(const char* name, elfcpp::Elf_Word type,
     dynsym_index_(0),
     input_sections_(),
     first_input_offset_(0),
-    may_add_data_(may_add_data)
+    may_add_data_(may_add_data),
+    needs_symtab_index_(false),
+    needs_dynsym_index_(false)
 {
 }
 
@@ -648,7 +801,7 @@ Output_section::add_input_section(Relobj* object, unsigned int shndx,
 				  const char* secname,
 				  const elfcpp::Shdr<size, big_endian>& shdr)
 {
-  assert(this->may_add_data_);
+  gold_assert(this->may_add_data_);
 
   elfcpp::Elf_Xword addralign = shdr.get_sh_addralign();
   if ((addralign & (addralign - 1)) != 0)
@@ -682,7 +835,7 @@ Output_section::add_input_section(Relobj* object, unsigned int shndx,
 void
 Output_section::add_output_section_data(Output_section_data* posd)
 {
-  assert(this->may_add_data_);
+  gold_assert(this->may_add_data_);
 
   if (this->input_sections_.empty())
     this->first_input_offset_ = this->data_size();
@@ -750,22 +903,6 @@ Output_section::do_write(Output_file* of)
     p->write(of);
 }
 
-// Output_section_strtab methods.
-
-Output_section_strtab::Output_section_strtab(const char* name,
-					     Stringpool* contents)
-  : Output_section(name, elfcpp::SHT_STRTAB, 0, false),
-    contents_(contents)
-{
-  this->set_data_size(contents->get_strtab_size());
-}
-
-void
-Output_section_strtab::do_write(Output_file* of)
-{
-  this->contents_->write(of, this->offset());
-}
-
 // Output segment methods.
 
 Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags)
@@ -790,8 +927,8 @@ Output_segment::add_output_section(Output_section* os,
 				   elfcpp::Elf_Word seg_flags,
 				   bool front)
 {
-  assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
-  assert(!this->is_align_known_);
+  gold_assert((os->flags() & elfcpp::SHF_ALLOC) != 0);
+  gold_assert(!this->is_align_known_);
 
   // Update the segment flags.
   this->flags_ |= seg_flags;
@@ -817,7 +954,7 @@ Output_segment::add_output_section(Output_section* os,
 
   if (os->type() == elfcpp::SHT_NOTE && !pdl->empty())
     {
-      Layout::Data_list::iterator p = pdl->end();
+      Output_segment::Output_data_list::iterator p = pdl->end();
       do
 	{
 	  --p;
@@ -842,7 +979,7 @@ Output_segment::add_output_section(Output_section* os,
       pdl = &this->output_data_;
       bool nobits = os->type() == elfcpp::SHT_NOBITS;
       bool sawtls = false;
-      Layout::Data_list::iterator p = pdl->end();
+      Output_segment::Output_data_list::iterator p = pdl->end();
       do
 	{
 	  --p;
@@ -888,7 +1025,7 @@ Output_segment::add_output_section(Output_section* os,
 void
 Output_segment::add_initial_output_data(Output_data* od)
 {
-  assert(!this->is_align_known_);
+  gold_assert(!this->is_align_known_);
   this->output_data_.push_front(od);
 }
 
@@ -942,7 +1079,7 @@ uint64_t
 Output_segment::set_section_addresses(uint64_t addr, off_t* poff,
 				      unsigned int* pshndx)
 {
-  assert(this->type_ == elfcpp::PT_LOAD);
+  gold_assert(this->type_ == elfcpp::PT_LOAD);
 
   this->vaddr_ = addr;
   this->paddr_ = addr;
@@ -1011,7 +1148,7 @@ Output_segment::set_section_list_addresses(Output_data_list* pdl,
 void
 Output_segment::set_offset()
 {
-  assert(this->type_ != elfcpp::PT_LOAD);
+  gold_assert(this->type_ != elfcpp::PT_LOAD);
 
   if (this->output_data_.empty() && this->output_bss_.empty())
     {
@@ -1136,7 +1273,7 @@ Output_segment::write_section_headers_list(const Stringpool* secnamepool,
       if ((*p)->is_section())
 	{
 	  const Output_section* ps = static_cast<const Output_section*>(*p);
-	  assert(*pshndx == ps->out_shndx());
+	  gold_assert(*pshndx == ps->out_shndx());
 	  elfcpp::Shdr_write<size, big_endian> oshdr(v);
 	  ps->write_header(secnamepool, &oshdr);
 	  v += shdr_size;
diff --git a/gold/output.h b/gold/output.h
index c31640f..c7d835d 100644
--- a/gold/output.h
+++ b/gold/output.h
@@ -3,7 +3,6 @@
 #ifndef GOLD_OUTPUT_H
 #define GOLD_OUTPUT_H
 
-#include <cassert>
 #include <list>
 #include <vector>
 
@@ -16,8 +15,10 @@ namespace gold
 
 class General_options;
 class Object;
+class Symbol;
 class Output_file;
 class Output_section;
+class Target;
 template<int size, bool big_endian>
 class Sized_target;
 template<int size, bool big_endian>
@@ -96,6 +97,12 @@ class Output_data
   write(Output_file* file)
   { this->do_write(file); }
 
+  // This is called by Layout::finalize to note that all sizes must
+  // now be fixed.
+  static void
+  layout_complete()
+  { Output_data::sizes_are_fixed = true; }
+
  protected:
   // Functions that child classes may or in some cases must implement.
 
@@ -127,15 +134,16 @@ class Output_data
   // Return the output section index, if there is an output section.
   virtual unsigned int
   do_out_shndx() const
-  { abort(); }
+  { gold_unreachable(); }
 
   // Set the output section index, if this is an output section.
   virtual void
   do_set_out_shndx(unsigned int)
-  { abort(); }
+  { gold_unreachable(); }
 
   // Set the address and file offset of the data.  This only needs to
-  // be implemented if the child needs to know.
+  // be implemented if the child needs to know.  The child class can
+  // set its size in this call.
   virtual void
   do_set_address(uint64_t, off_t)
   { }
@@ -145,7 +153,10 @@ class Output_data
   // Set the size of the data.
   void
   set_data_size(off_t data_size)
-  { this->data_size_ = data_size; }
+  {
+    gold_assert(!Output_data::sizes_are_fixed);
+    this->data_size_ = data_size;
+  }
 
   // Return default alignment for a size--32 or 64.
   static uint64_t
@@ -155,6 +166,10 @@ class Output_data
   Output_data(const Output_data&);
   Output_data& operator=(const Output_data&);
 
+  // This is used for verification, to make sure that we don't try to
+  // change any sizes after we set the section addresses.
+  static bool sizes_are_fixed;
+
   // Memory address in file (not always meaningful).
   uint64_t address_;
   // Size of data in file.
@@ -192,7 +207,7 @@ class Output_section_headers : public Output_data
   int size_;
   bool big_endian_;
   const Layout::Segment_list& segment_list_;
-  const Layout::Section_list& section_list_;
+  const Layout::Section_list& unattached_section_list_;
   const Stringpool* secnamepool_;
 };
 
@@ -254,7 +269,7 @@ class Output_file_header : public Output_data
   // checking.
   void
   do_set_address(uint64_t, off_t off) const
-  { assert(off == 0); }
+  { gold_assert(off == 0); }
 
  private:
   // Write the data to the file with the right size and endianness.
@@ -292,7 +307,7 @@ class Output_section_data : public Output_data
   void
   set_output_section(Output_section* os)
   {
-    assert(this->output_section_ == NULL);
+    gold_assert(this->output_section_ == NULL);
     this->output_section_ = os;
   }
 
@@ -334,36 +349,87 @@ class Output_data_const : public Output_section_data
       data_(reinterpret_cast<const char*>(p), len)
   { }
 
-  // Write the data to the file.
+  // Add more data.
+  void
+  add_data(const std::string& add)
+  {
+    this->data_.append(add);
+    this->set_data_size(this->data_.size());
+  }
+
+  // Write the data to the output file.
   void
-  do_write(Output_file* output);
+  do_write(Output_file*);
 
  private:
   std::string data_;
 };
 
-// Output_data_common is used to handle the common symbols.  This is
-// quite simple.
+// Another version of Output_data with constant data, in which the
+// buffer is allocated by the caller.
 
-class Output_data_common : public Output_section_data
+class Output_data_const_buffer : public Output_section_data
 {
  public:
-  Output_data_common(uint64_t addralign)
+  Output_data_const_buffer(const unsigned char* p, off_t len,
+			   uint64_t addralign)
+    : Output_section_data(len, addralign), p_(p)
+  { }
+
+  // Write the data the output file.
+  void
+  do_write(Output_file*);
+
+ private:
+  const unsigned char* p_;
+};
+
+// A place holder for data written out via some other mechanism.
+
+class Output_data_space : public Output_section_data
+{
+ public:
+  Output_data_space(off_t data_size, uint64_t addralign)
+    : Output_section_data(data_size, addralign)
+  { }
+
+  explicit Output_data_space(uint64_t addralign)
     : Output_section_data(addralign)
   { }
 
   // Set the size.
   void
-  set_common_size(off_t common_size)
-  { this->set_data_size(common_size); }
+  set_space_size(off_t space_size)
+  { this->set_data_size(space_size); }
 
-  // Write out the data--there is nothing to do, as common symbols are
-  // always zero and are stored in the BSS.
+  // Write out the data--this must be handled elsewhere.
   void
   do_write(Output_file*)
   { }
 };
 
+// A string table which goes into an output section.
+
+class Output_data_strtab : public Output_section_data
+{
+ public:
+  Output_data_strtab(Stringpool* strtab)
+    : Output_section_data(1), strtab_(strtab)
+  { }
+
+  // This is called to set the address and file offset.  Here we make
+  // sure that the Stringpool is finalized.
+  void
+  do_set_address(uint64_t, off_t);
+
+  // Write out the data.
+  void
+  do_write(Output_file*);
+
+ private:
+  Stringpool* strtab_;
+};
+
 // This POD class is used to represent a single reloc in the output
 // file.  This could be a private class within Output_data_reloc, but
 // the templatization is complex enough that I broke it out into a
@@ -391,23 +457,29 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
   { }
 
   // A reloc against a global symbol.
-  Output_reloc(Symbol* gsym, unsigned int type, Address address)
-    : local_sym_index_(GSYM_CODE), type_(type), address_(address)
+  Output_reloc(Symbol* gsym, unsigned int type, Output_data* od,
+	       Address address)
+    : local_sym_index_(GSYM_CODE), type_(type), od_(od), address_(address)
   { this->u_.gsym = gsym; }
 
   // A reloc against a local symbol.
   Output_reloc(Sized_relobj<size, big_endian>* object,
 	       unsigned int local_sym_index,
-	       unsigned int type, Address address)
-    : local_sym_index_(local_sym_index), type_(type), address_(address)
+	       unsigned int type,
+	       Output_data* od,
+	       Address address)
+    : local_sym_index_(local_sym_index), type_(type), od_(od),
+      address_(address)
   {
-    assert(local_sym_index != GSYM_CODE && local_sym_index != INVALID_CODE);
+    gold_assert(local_sym_index != GSYM_CODE
+		&& local_sym_index != INVALID_CODE);
     this->u_.object = object;
   }
 
   // A reloc against the STT_SECTION symbol of an output section.
-  Output_reloc(Output_section* os, unsigned int type, Address address)
-    : local_sym_index_(SECTION_CODE), type_(type), address_(address)
+  Output_reloc(Output_section* os, unsigned int type, Output_data* od,
+	       Address address)
+    : local_sym_index_(SECTION_CODE), type_(type), od_(od), address_(address)
   { this->u_.os = os; }
 
   // Write the reloc entry to an output view.
@@ -451,7 +523,13 @@ class Output_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
   // For a local symbol, the local symbol index.  This is GSYM_CODE
   // for a global symbol, or INVALID_CODE for an uninitialized value.
   unsigned int local_sym_index_;
+  // The reloc type--a processor specific code.
   unsigned int type_;
+  // If this is not NULL, then the relocation is against the contents
+  // of this output data.
+  Output_data* od_;
+  // The reloc address--if od_ is not NULL, this is the offset from
+  // the start of od_.
   Address address_;
 };
 
@@ -471,21 +549,23 @@ class Output_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
   { }
 
   // A reloc against a global symbol.
-  Output_reloc(Symbol* gsym, unsigned int type, Address address, Addend addend)
-    : rel_(gsym, type, address), addend_(addend)
+  Output_reloc(Symbol* gsym, unsigned int type, Output_data* od,
+	       Address address, Addend addend)
+    : rel_(gsym, type, od, address), addend_(addend)
   { }
 
   // A reloc against a local symbol.
   Output_reloc(Sized_relobj<size, big_endian>* object,
 	       unsigned int local_sym_index,
-	       unsigned int type, Address address, Addend addend)
-    : rel_(object, local_sym_index, type, address), addend_(addend)
+	       unsigned int type, Output_data* od, Address address,
+	       Addend addend)
+    : rel_(object, local_sym_index, type, od, address), addend_(addend)
   { }
 
   // A reloc against the STT_SECTION symbol of an output section.
-  Output_reloc(Output_section* os, unsigned int type, Address address,
-	       Addend addend)
-    : rel_(os, type, address), addend_(addend)
+  Output_reloc(Output_section* os, unsigned int type, Output_data* od,
+	       Address address, Addend addend)
+    : rel_(os, type, od, address), addend_(addend)
   { }
 
   // Write the reloc entry to an output view.
@@ -564,19 +644,21 @@ class Output_data_reloc<elfcpp::SHT_REL, dynamic, size, big_endian>
 
   // Add a reloc against a global symbol.
   void
-  add_global(Symbol* gsym, unsigned int type, Address address)
-  { this->add(Output_reloc_type(gsym, type, address)); }
+  add_global(Symbol* gsym, unsigned int type, Output_data* od, Address address)
+  { this->add(Output_reloc_type(gsym, type, od, address)); }
 
   // Add a reloc against a local symbol.
   void
   add_local(Sized_relobj<size, big_endian>* object,
-	    unsigned int local_sym_index, unsigned int type, Address address)
-  { this->add(Output_reloc_type(object, local_sym_index, type, address)); }
+	    unsigned int local_sym_index, unsigned int type,
+	    Output_data* od, Address address)
+  { this->add(Output_reloc_type(object, local_sym_index, type, od, address)); }
 
   // A reloc against the STT_SECTION symbol of an output section.
   void
-  add_output_section(Output_section* os, unsigned int type, Address address)
-  { this->add(Output_reloc_type(os, type, address)); }
+  add_output_section(Output_section* os, unsigned int type,
+		     Output_data* od, Address address)
+  { this->add(Output_reloc_type(os, type, od, address)); }
 };
 
 // The SHT_RELA version of Output_data_reloc.
@@ -600,24 +682,25 @@ class Output_data_reloc<elfcpp::SHT_RELA, dynamic, size, big_endian>
 
   // Add a reloc against a global symbol.
   void
-  add_global(Symbol* gsym, unsigned int type, Address address, Addend addend)
-  { this->add(Output_reloc_type(gsym, type, address, addend)); }
+  add_global(Symbol* gsym, unsigned int type, Output_data* od,
+	     Address address, Addend addend)
+  { this->add(Output_reloc_type(gsym, type, od, address, addend)); }
 
   // Add a reloc against a local symbol.
   void
   add_local(Sized_relobj<size, big_endian>* object,
 	    unsigned int local_sym_index, unsigned int type,
-	    Address address, Addend addend)
+	    Output_data* od, Address address, Addend addend)
   {
-    this->add(Output_reloc_type(object, local_sym_index, type, address,
+    this->add(Output_reloc_type(object, local_sym_index, type, od, address,
 				addend));
   }
 
   // A reloc against the STT_SECTION symbol of an output section.
   void
-  add_output_section(Output_section* os, unsigned int type, Address address,
-		     Addend addend)
-  { this->add(Output_reloc_type(os, type, address, addend)); }
+  add_output_section(Output_section* os, unsigned int type, Output_data* od,
+		     Address address, Addend addend)
+  { this->add(Output_reloc_type(os, type, od, address, addend)); }
 };
 
 // Output_data_got is used to manage a GOT.  Each entry in the GOT is
@@ -631,9 +714,9 @@ class Output_data_got : public Output_section_data
  public:
   typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype;
 
-  Output_data_got()
+  Output_data_got(const General_options* options)
     : Output_section_data(Output_data::default_alignment(size)),
-      entries_()
+      options_(options), entries_()
   { }
 
   // Add an entry for a global symbol to the GOT.  Return true if this
@@ -676,7 +759,7 @@ class Output_data_got : public Output_section_data
     { this->u_.constant = 0; }
 
     // Create a global symbol entry.
-    Got_entry(Symbol* gsym)
+    explicit Got_entry(Symbol* gsym)
       : local_sym_index_(GSYM_CODE)
     { this->u_.gsym = gsym; }
 
@@ -684,20 +767,20 @@ class Output_data_got : public Output_section_data
     Got_entry(Object* object, unsigned int local_sym_index)
       : local_sym_index_(local_sym_index)
     {
-      assert(local_sym_index != GSYM_CODE
-	     && local_sym_index != CONSTANT_CODE);
+      gold_assert(local_sym_index != GSYM_CODE
+		  && local_sym_index != CONSTANT_CODE);
       this->u_.object = object;
     }
 
     // Create a constant entry.  The constant is a host value--it will
     // be swapped, if necessary, when it is written out.
-    Got_entry(Valtype constant)
+    explicit Got_entry(Valtype constant)
       : local_sym_index_(CONSTANT_CODE)
     { this->u_.constant = constant; }
 
     // Write the GOT entry to an output view.
     void
-    write(unsigned char* pov) const;
+    write(const General_options*, unsigned char* pov) const;
 
    private:
     enum
@@ -737,10 +820,142 @@ class Output_data_got : public Output_section_data
   set_got_size()
   { this->set_data_size(this->got_offset(this->entries_.size())); }
 
+  // Options.
+  const General_options* options_;
   // The list of GOT entries.
   Got_entries entries_;
 };
 
+// Output_data_dynamic is used to hold the data in SHT_DYNAMIC
+// section.
+
+class Output_data_dynamic : public Output_section_data
+{
+ public:
+  Output_data_dynamic(const Target* target, Stringpool* pool)
+    : Output_section_data(Output_data::default_alignment(target->get_size())),
+      target_(target), entries_(), pool_(pool)
+  { }
+
+  // Add a new dynamic entry with a fixed numeric value.
+  void
+  add_constant(elfcpp::DT tag, unsigned int val)
+  { this->add_entry(Dynamic_entry(tag, val)); }
+
+  // Add a new dynamic entry with the address of a section.
+  void
+  add_section_address(elfcpp::DT tag, Output_section* os)
+  { this->add_entry(Dynamic_entry(tag, os, false)); }
+
+  // Add a new dynamic entry with the size of a section.
+  void
+  add_section_size(elfcpp::DT tag, Output_section* os)
+  { this->add_entry(Dynamic_entry(tag, os, true)); }
+
+  // Add a new dynamic entry with the address of a symbol.
+  void
+  add_symbol(elfcpp::DT tag, Symbol* sym)
+  { this->add_entry(Dynamic_entry(tag, sym)); }
+
+  // Add a new dynamic entry with a string.
+  void
+  add_string(elfcpp::DT tag, const char* str)
+  { this->add_entry(Dynamic_entry(tag, this->pool_->add(str, NULL))); }
+
+  // Set the final data size.
+  void
+  do_set_address(uint64_t, off_t);
+
+  // Write out the dynamic entries.
+  void
+  do_write(Output_file*);
+
+ private:
+  // This POD class holds a single dynamic entry.
+  class Dynamic_entry
+  {
+   public:
+    // Create an entry with a fixed numeric value.
+    Dynamic_entry(elfcpp::DT tag, unsigned int val)
+      : tag_(tag), classification_(DYNAMIC_NUMBER)
+    { this->u_.val = val; }
+
+    // Create an entry with the size or address of a section.
+    Dynamic_entry(elfcpp::DT tag, Output_section* os, bool section_size)
+      : tag_(tag),
+	classification_(section_size
+			? DYNAMIC_SECTION_SIZE
+			: DYNAMIC_SECTION_ADDRESS)
+    { this->u_.os = os; }
+
+    // Create an entry with the address of a symbol.
+    Dynamic_entry(elfcpp::DT tag, Symbol* sym)
+      : tag_(tag), classification_(DYNAMIC_SYMBOL)
+    { this->u_.sym = sym; }
+
+    // Create an entry with a string.
+    Dynamic_entry(elfcpp::DT tag, const char* str)
+      : tag_(tag), classification_(DYNAMIC_STRING)
+    { this->u_.str = str; }
+
+    // Write the dynamic entry to an output view.
+    template<int size, bool big_endian>
+    void
+    write(unsigned char* pov, const Stringpool*) const;
+
+   private:
+    enum Classification
+    {
+      // Number.
+      DYNAMIC_NUMBER,
+      // Section address.
+      DYNAMIC_SECTION_ADDRESS,
+      // Section size.
+      DYNAMIC_SECTION_SIZE,
+      // Symbol adress.
+      DYNAMIC_SYMBOL,
+      // String.
+      DYNAMIC_STRING
+    };
+
+    union
+    {
+      // For DYNAMIC_NUMBER.
+      unsigned int val;
+      // For DYNAMIC_SECTION_ADDRESS and DYNAMIC_SECTION_SIZE.
+      Output_section* os;
+      // For DYNAMIC_SYMBOL.
+      Symbol* sym;
+      // For DYNAMIC_STRING.
+      const char* str;
+    } u_;
+    // The dynamic tag.
+    elfcpp::DT tag_;
+    // The type of entry.
+    Classification classification_;
+  };
+
+  // Add an entry to the list.
+  void
+  add_entry(const Dynamic_entry& entry)
+  { this->entries_.push_back(entry); }
+
+  // Sized version of write function.
+  template<int size, bool big_endian>
+  void
+  sized_write(Output_file* of);
+
+  // The type of the list of entries.
+  typedef std::vector<Dynamic_entry> Dynamic_entries;
+
+  // The target.
+  const Target* target_;
+  // The entries.
+  Dynamic_entries entries_;
+  // The pool used for strings.
+  Stringpool* pool_;
+};
+
 // An output section.  We don't expect to have too many output
 // sections, so we don't bother to do a template on the size.
 
@@ -788,6 +1003,11 @@ class Output_section : public Output_data
   do_set_out_shndx(unsigned int shndx)
   { this->out_shndx_ = shndx; }
 
+  // Return the entsize field.
+  uint64_t
+  entsize() const
+  { return this->entsize_; }
+
   // Set the entsize field.
   void
   set_entsize(uint64_t v)
@@ -822,7 +1042,7 @@ class Output_section : public Output_data
   unsigned int
   symtab_index() const
   {
-    assert(this->symtab_index_ != 0);
+    gold_assert(this->symtab_index_ != 0);
     return this->symtab_index_;
   }
 
@@ -830,7 +1050,7 @@ class Output_section : public Output_data
   void
   set_symtab_index(unsigned int index)
   {
-    assert(index != 0);
+    gold_assert(index != 0);
     this->symtab_index_ = index;
   }
 
@@ -848,7 +1068,7 @@ class Output_section : public Output_data
   unsigned int
   dynsym_index() const
   {
-    assert(this->dynsym_index_ != 0);
+    gold_assert(this->dynsym_index_ != 0);
     return this->dynsym_index_;
   }
 
@@ -856,7 +1076,7 @@ class Output_section : public Output_data
   void
   set_dynsym_index(unsigned int index)
   {
-    assert(index != 0);
+    gold_assert(index != 0);
     this->dynsym_index_ = index;
   }
 
@@ -871,7 +1091,7 @@ class Output_section : public Output_data
   // does nothing: the data is written out by calling Object::Relocate
   // on each input object.  But if there are any Output_section_data
   // objects we do need to write them out here.
-  virtual void
+  void
   do_write(Output_file*);
 
   // Return the address alignment--function required by parent class.
@@ -923,7 +1143,7 @@ class Output_section : public Output_data
 	p2align_(ffsll(static_cast<long long>(addralign))),
 	data_size_(data_size)
     {
-      assert(shndx != -1U);
+      gold_assert(shndx != -1U);
       this->u_.object = object;
     }
 
@@ -936,7 +1156,11 @@ class Output_section : public Output_data
     // The required alignment.
     uint64_t
     addralign() const
-    { return static_cast<uint64_t>(1) << this->p2align_; }
+    {
+      return (this->p2align_ == 0
+	      ? 0
+	      : static_cast<uint64_t>(1) << (this->p2align_ - 1));
+    }
 
     // Return the required size.
     off_t
@@ -1024,57 +1248,6 @@ class Output_section : public Output_data
   bool needs_dynsym_index_ : 1;
 };
 
-// A special Output_section which represents the symbol table
-// (SHT_SYMTAB).  The actual data is written out by
-// Symbol_table::write_globals.
-
-class Output_section_symtab : public Output_section
-{
- public:
-  Output_section_symtab(const char* name, off_t data_size)
-    : Output_section(name, elfcpp::SHT_SYMTAB, 0, false)
-  { this->set_data_size(data_size); }
-
-  // The data is written out by Symbol_table::write_globals.  We don't
-  // do anything here.
-  void
-  do_write(Output_file*)
-  { }
-};
-
-// A special Output_section which represents the dynamic symbol table
-// (SHT_DYNSYM).  The actual data is written out by
-// Symbol_table::write_globals.
-
-class Output_section_dynsym : public Output_section
-{
- public:
-  Output_section_dynsym(const char* name, off_t data_size)
-    : Output_section(name, elfcpp::SHT_DYNSYM, 0, false)
-  { this->set_data_size(data_size); }
-
-  // The data is written out by Symbol_table::write_globals.  We don't
-  // do anything here.
-  void
-  do_write(Output_file*)
-  { }
-};
-
-// A special Output_section which holds a string table.
-
-class Output_section_strtab : public Output_section
-{
- public:
-  Output_section_strtab(const char* name, Stringpool* contents);
-
-  // Write out the data.
-  void
-  do_write(Output_file*);
-
- private:
-  Stringpool* contents_;
-};
-
 // An output segment.  PT_LOAD segments are built from collections of
 // output sections.  Other segments typically point within PT_LOAD
 // segments, and are built directly as needed.
@@ -1247,7 +1420,7 @@ class Output_file
   unsigned char*
   get_output_view(off_t start, off_t size)
   {
-    assert(start >= 0 && size >= 0 && start + size <= this->file_size_);
+    gold_assert(start >= 0 && size >= 0 && start + size <= this->file_size_);
     return this->base_ + start;
   }
 
diff --git a/gold/po/gold.pot b/gold/po/gold.pot
index b5725e5..5663031 100644
--- a/gold/po/gold.pot
+++ b/gold/po/gold.pot
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2006-11-15 16:35-0800\n"
+"POT-Creation-Date: 2006-11-29 09:53-0800\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -56,331 +56,331 @@ msgstr ""
 msgid "%s: %s: member at %ld is not an ELF object"
 msgstr ""
 
-#: dirsearch.cc:51
+#: dirsearch.cc:50
 #, c-format
 msgid "can not read directory %s"
 msgstr ""
 
-#: dynobj.cc:97
+#: dynobj.cc:109
 #, c-format
 msgid "%s: %s: unexpected duplicate type %u section: %u, %u\n"
 msgstr ""
 
-#: dynobj.cc:138
+#: dynobj.cc:150
 #, c-format
 msgid "%s: %s: unexpected link in section %u header: %u != %u\n"
 msgstr ""
 
-#: dynobj.cc:176
+#: dynobj.cc:188
 #, c-format
 msgid "%s: %s: DYNAMIC section %u link out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:186
+#: dynobj.cc:198
 #, c-format
 msgid "%s: %s: DYNAMIC section %u link %u is not a strtab\n"
 msgstr ""
 
-#: dynobj.cc:208
+#: dynobj.cc:220
 #, c-format
 msgid "%s: %s: DT_SONAME value out of range: %lld >= %lld\n"
 msgstr ""
 
-#: dynobj.cc:225
+#: dynobj.cc:237
 #, c-format
 msgid "%s: %s: missing DT_NULL in dynamic segment\n"
 msgstr ""
 
-#: dynobj.cc:273
+#: dynobj.cc:285
 #, c-format
 msgid "%s: %s: invalid dynamic symbol table name index: %u\n"
 msgstr ""
 
-#: dynobj.cc:281
+#: dynobj.cc:293
 #, c-format
 msgid "%s: %s: dynamic symbol table name section has wrong type: %u\n"
 msgstr ""
 
-#: dynobj.cc:356 object.cc:422
+#: dynobj.cc:368 object.cc:421
 #, c-format
 msgid "%s: %s: bad section name offset for section %u: %lu\n"
 msgstr ""
 
-#: dynobj.cc:386
+#: dynobj.cc:398
 #, c-format
 msgid "%s: %s: duplicate definition for version %u\n"
 msgstr ""
 
-#: dynobj.cc:430 dynobj.cc:549
+#: dynobj.cc:442 dynobj.cc:561
 #, c-format
 msgid "%s: %s: verdef vd_next field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:454
+#: dynobj.cc:466
 #, c-format
 msgid "%s: %s: verneed vn_aux field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:473
+#: dynobj.cc:485
 #, c-format
 msgid "%s: %s: verneed vna_next field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:486
+#: dynobj.cc:498
 #, c-format
 msgid "%s: %s: verneed vn_next field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:516
+#: dynobj.cc:528
 #, c-format
 msgid "%s: %s: verdef vd_cnt field too small: %u\n"
 msgstr ""
 
-#: dynobj.cc:525
+#: dynobj.cc:537
 #, c-format
 msgid "%s: %s: verdef vd_aux field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:537
+#: dynobj.cc:549
 #, c-format
 msgid "%s: %s: verdaux vda_name field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:579
+#: dynobj.cc:591
 #, c-format
 msgid "%s: %s: vernaux vna_name field out of range: %u\n"
 msgstr ""
 
-#: dynobj.cc:615
+#: dynobj.cc:628
 #, c-format
 msgid "%s: %s: size of dynamic symbols is not multiple of symbol size\n"
 msgstr ""
 
-#: fileread.cc:56
+#: fileread.cc:55
 #, c-format
 msgid "%s: warning: close(%s) failed: %s"
 msgstr ""
 
-#: fileread.cc:129
+#: fileread.cc:128
 #, c-format
 msgid "%s: %s: lseek to %lld failed: %s"
 msgstr ""
 
-#: fileread.cc:139
+#: fileread.cc:138
 #, c-format
 msgid "%s: %s: read failed: %s\n"
 msgstr ""
 
-#: fileread.cc:149 fileread.cc:232
+#: fileread.cc:148 fileread.cc:231
 #, c-format
 msgid "%s: %s: file too short: read only %lld of %lld bytes at %lld\n"
 msgstr ""
 
-#: fileread.cc:327
+#: fileread.cc:326
 #, c-format
 msgid "%s: cannot find %s\n"
 msgstr ""
 
-#: fileread.cc:335
+#: fileread.cc:334
 #, c-format
 msgid "%s: cannot open %s: %s\n"
 msgstr ""
 
-#: gold.cc:102
+#: gold.cc:106
 msgid "no input files"
 msgstr ""
 
-#: gold-threads.cc:48
+#: gold-threads.cc:46
 msgid "pthead_mutextattr_init failed"
 msgstr ""
 
-#: gold-threads.cc:51
+#: gold-threads.cc:49
 msgid "pthread_mutextattr_settype failed"
 msgstr ""
 
-#: gold-threads.cc:55
+#: gold-threads.cc:53
 msgid "pthread_mutex_init failed"
 msgstr ""
 
-#: gold-threads.cc:58
+#: gold-threads.cc:56
 msgid "pthread_mutexattr_destroy failed"
 msgstr ""
 
-#: gold-threads.cc:64
+#: gold-threads.cc:62
 msgid "pthread_mutex_destroy failed"
 msgstr ""
 
-#: gold-threads.cc:71
+#: gold-threads.cc:69
 msgid "pthread_mutex_lock failed"
 msgstr ""
 
-#: gold-threads.cc:78
+#: gold-threads.cc:76
 msgid "pthread_mutex_unlock failed"
 msgstr ""
 
-#: gold-threads.cc:159
+#: gold-threads.cc:157
 msgid "pthread_cond_init failed"
 msgstr ""
 
-#: gold-threads.cc:165
+#: gold-threads.cc:163
 msgid "pthread_cond_destroy failed"
 msgstr ""
 
-#: gold-threads.cc:172
+#: gold-threads.cc:170
 msgid "pthread_cond_wait failed"
 msgstr ""
 
-#: gold-threads.cc:179
+#: gold-threads.cc:177
 msgid "pthread_cond_signal failed"
 msgstr ""
 
 #. FIXME: This needs to specify the location somehow.
-#: i386.cc:88
+#: i386.cc:93
 #, c-format
 msgid "%s: missing expected TLS relocation\n"
 msgstr ""
 
-#: i386.cc:307 i386.cc:430 i386.cc:623
+#: i386.cc:617 i386.cc:757 i386.cc:961
 #, c-format
 msgid "%s: %s: unexpected reloc %u in object file\n"
 msgstr ""
 
-#: i386.cc:340 i386.cc:359
+#: i386.cc:653 i386.cc:672
 #, c-format
 msgid "%s: %s: unsupported reloc %u against local symbol\n"
 msgstr ""
 
-#: i386.cc:411 i386.cc:465 i386.cc:483
+#: i386.cc:793 i386.cc:814
 #, c-format
 msgid "%s: %s: unsupported reloc %u against global symbol %s\n"
 msgstr ""
 
-#: i386.cc:505
+#: i386.cc:837
 #, c-format
 msgid "%s: %s: unsupported RELA reloc section\n"
 msgstr ""
 
-#: i386.cc:544
+#: i386.cc:877
 #, c-format
 msgid "%s: %s: missing expected TLS relocation\n"
 msgstr ""
 
-#: i386.cc:590 i386.cc:655 i386.cc:728 i386.cc:739
+#: i386.cc:993 i386.cc:1068 i386.cc:1079
 #, c-format
 msgid "%s: %s: unsupported reloc %u\n"
 msgstr ""
 
-#: i386.cc:682
+#: i386.cc:1020
 #, c-format
 msgid "%s: %s: TLS reloc but no TLS segment\n"
 msgstr ""
 
-#: i386.cc:713
+#: i386.cc:1053
 #, c-format
 msgid "%s: %s: unsupported reloc type %u\n"
 msgstr ""
 
-#: i386.cc:922
+#: i386.cc:1262
 #, c-format
 msgid "%s: %s: TLS relocation out of range\n"
 msgstr ""
 
-#: i386.cc:940
+#: i386.cc:1280
 #, c-format
 msgid "%s: %s: TLS relocation against invalid instruction\n"
 msgstr ""
 
-#: object.cc:31
+#: object.cc:30
 #, c-format
 msgid "%s: %s: unsupported ELF machine number %d\n"
 msgstr ""
 
-#: object.cc:87
+#: object.cc:86
 #, c-format
 msgid "%s: %s: section name section has wrong type: %u\n"
 msgstr ""
 
-#: object.cc:230
+#: object.cc:229
 #, c-format
 msgid "%s: %s: invalid symbol table name index: %u\n"
 msgstr ""
 
-#: object.cc:238
+#: object.cc:237
 #, c-format
 msgid "%s: %s: symbol table name section has wrong type: %u\n"
 msgstr ""
 
-#: object.cc:294
+#: object.cc:293
 #, c-format
 msgid "%s: %s: section group %u info %u out of range\n"
 msgstr ""
 
-#: object.cc:311
+#: object.cc:310
 #, c-format
 msgid "%s: %s: symbol %u name offset %u out of range\n"
 msgstr ""
 
-#: object.cc:345
+#: object.cc:344
 #, c-format
 msgid "%s: %s: section %u in section group %u out of range"
 msgstr ""
 
-#: object.cc:489
+#: object.cc:488
 #, c-format
 msgid "%s: %s: size of symbols is not multiple of symbol size\n"
 msgstr ""
 
-#: object.cc:576
+#: object.cc:575
 #, c-format
 msgid "%s: %s: unknown section index %u for local symbol %u\n"
 msgstr ""
 
-#: object.cc:587
+#: object.cc:586
 #, c-format
 msgid "%s: %s: local symbol %u section index %u out of range\n"
 msgstr ""
 
-#: object.cc:616
+#: object.cc:615
 #, c-format
 msgid "%s: %s: local symbol %u section name out of range: %u >= %u\n"
 msgstr ""
 
-#: object.cc:800
+#: object.cc:799
 #, c-format
 msgid "%s: %s: unsupported ELF file type %d\n"
 msgstr ""
 
-#: object.cc:819 object.cc:872 object.cc:893
+#: object.cc:818 object.cc:871 object.cc:892
 #, c-format
 msgid "%s: %s: ELF file too short\n"
 msgstr ""
 
-#: object.cc:828
+#: object.cc:827
 #, c-format
 msgid "%s: %s: invalid ELF version 0\n"
 msgstr ""
 
-#: object.cc:831
+#: object.cc:830
 #, c-format
 msgid "%s: %s: unsupported ELF version %d\n"
 msgstr ""
 
-#: object.cc:839
+#: object.cc:838
 #, c-format
 msgid "%s: %s: invalid ELF class 0\n"
 msgstr ""
 
-#: object.cc:846
+#: object.cc:845
 #, c-format
 msgid "%s: %s: unsupported ELF class %d\n"
 msgstr ""
 
-#: object.cc:854
+#: object.cc:853
 #, c-format
 msgid "%s: %s: invalid ELF data encoding\n"
 msgstr ""
 
-#: object.cc:861
+#: object.cc:860
 #, c-format
 msgid "%s: %s: unsupported ELF data encoding %d\n"
 msgstr ""
@@ -486,7 +486,7 @@ msgstr ""
 msgid "%s: use the --help option for usage information\n"
 msgstr ""
 
-#: options.cc:565 script.cc:1128
+#: options.cc:565 script.cc:1133
 #, c-format
 msgid "%s: %s: %s\n"
 msgstr ""
@@ -496,37 +496,37 @@ msgstr ""
 msgid "%s: -%c: %s\n"
 msgstr ""
 
-#: output.cc:656
+#: output.cc:809
 #, c-format
 msgid "%s: %s: invalid alignment %lu for section \"%s\"\n"
 msgstr ""
 
-#: output.cc:1171
+#: output.cc:1308
 #, c-format
 msgid "%s: %s: open: %s\n"
 msgstr ""
 
-#: output.cc:1180
+#: output.cc:1317
 #, c-format
 msgid "%s: %s: lseek: %s\n"
 msgstr ""
 
-#: output.cc:1187
+#: output.cc:1324
 #, c-format
 msgid "%s: %s: write: %s\n"
 msgstr ""
 
-#: output.cc:1197
+#: output.cc:1334
 #, c-format
 msgid "%s: %s: mmap: %s\n"
 msgstr ""
 
-#: output.cc:1211
+#: output.cc:1348
 #, c-format
 msgid "%s: %s: munmap: %s\n"
 msgstr ""
 
-#: output.cc:1219
+#: output.cc:1356
 #, c-format
 msgid "%s: %s: close: %s\n"
 msgstr ""
@@ -577,52 +577,52 @@ msgstr ""
 msgid "%s: %s: unsupported symbol binding %d for symbol %s\n"
 msgstr ""
 
-#: symtab.cc:446 symtab.cc:543
+#: symtab.cc:445 symtab.cc:542
 #, c-format
 msgid "%s: %s: mixing 32-bit and 64-bit ELF objects\n"
 msgstr ""
 
-#: symtab.cc:463
+#: symtab.cc:462
 #, c-format
 msgid "%s: %s: bad global symbol name offset %u at %lu\n"
 msgstr ""
 
-#: symtab.cc:550
+#: symtab.cc:549
 #, c-format
 msgid "%s: %s: too few symbol versions\n"
 msgstr ""
 
-#: symtab.cc:570
+#: symtab.cc:569
 #, c-format
 msgid "%s: %s: bad symbol name offset %u at %lu\n"
 msgstr ""
 
-#: symtab.cc:614
+#: symtab.cc:613
 #, c-format
 msgid "%s: %s: versym for symbol %zu out of range: %u\n"
 msgstr ""
 
-#: symtab.cc:622
+#: symtab.cc:621
 #, c-format
 msgid "%s: %s: versym for symbol %zu has no name: %u\n"
 msgstr ""
 
-#: symtab.cc:1019 symtab.cc:1158
+#: symtab.cc:1050 symtab.cc:1201
 #, c-format
 msgid "%s: %s: unsupported symbol section 0x%x\n"
 msgstr ""
 
-#: symtab.cc:1274
+#: symtab.cc:1364
 #, c-format
 msgid "%s: %s: warning: %s\n"
 msgstr ""
 
-#: target-reloc.h:163
+#: target-reloc.h:164
 #, c-format
 msgid "%s: %s: reloc has bad offset %zu\n"
 msgstr ""
 
-#: target-reloc.h:173
+#: target-reloc.h:174
 #, c-format
 msgid "%s: %s: undefined reference to '%s'\n"
 msgstr ""
diff --git a/gold/readsyms.cc b/gold/readsyms.cc
index c301d16..2b200ba 100644
--- a/gold/readsyms.cc
+++ b/gold/readsyms.cc
@@ -56,7 +56,7 @@ Read_symbols::run(Workqueue* workqueue)
 {
   if (this->input_argument_->is_group())
     {
-      assert(this->input_group_ == NULL);
+      gold_assert(this->input_group_ == NULL);
       this->do_group(workqueue);
       return;
     }
@@ -170,7 +170,7 @@ Read_symbols::do_group(Workqueue* workqueue)
        ++p)
     {
       const Input_argument* arg = &*p;
-      assert(arg->is_file());
+      gold_assert(arg->is_file());
 
       Task_token* next_blocker = new Task_token();
       next_blocker->add_blocker();
diff --git a/gold/reloc.cc b/gold/reloc.cc
index ce6af0b..35f262e 100644
--- a/gold/reloc.cc
+++ b/gold/reloc.cc
@@ -227,17 +227,17 @@ Sized_relobj<size, big_endian>::do_read_relocs(Read_relocs_data* rd)
     }
 
   // Read the local symbols.
-  assert(this->symtab_shndx_ != -1U);
+  gold_assert(this->symtab_shndx_ != -1U);
   if (this->symtab_shndx_ == 0 || this->local_symbol_count_ == 0)
     rd->local_symbols = NULL;
   else
     {
       typename This::Shdr symtabshdr(pshdrs
 				     + this->symtab_shndx_ * This::shdr_size);
-      assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
+      gold_assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
       const int sym_size = This::sym_size;
       const unsigned int loccount = this->local_symbol_count_;
-      assert(loccount == symtabshdr.get_sh_info());
+      gold_assert(loccount == symtabshdr.get_sh_info());
       off_t locsize = loccount * sym_size;
       rd->local_symbols = this->get_lasting_view(symtabshdr.get_sh_offset(),
 						 locsize);
@@ -266,8 +266,8 @@ Sized_relobj<size, big_endian>::do_scan_relocs(const General_options& options,
        p != rd->relocs.end();
        ++p)
     {
-      target->scan_relocs(options, symtab, layout, this, p->sh_type,
-			  p->contents->data(), p->reloc_count,
+      target->scan_relocs(options, symtab, layout, this, p->data_shndx,
+			  p->sh_type, p->contents->data(), p->reloc_count,
 			  this->local_symbol_count_,
 			  local_symbols,
 			  this->symbols_);
@@ -357,8 +357,8 @@ Sized_relobj<size, big_endian>::write_sections(const unsigned char* pshdrs,
       if (sh_size == 0)
 	continue;
 
-      assert(map_sections[i].offset >= 0
-	     && map_sections[i].offset + sh_size <= os->data_size());
+      gold_assert(map_sections[i].offset >= 0
+		  && map_sections[i].offset + sh_size <= os->data_size());
 
       unsigned char* view = of->get_output_view(start, sh_size);
       this->read(shdr.get_sh_offset(), sh_size, view);
@@ -418,7 +418,7 @@ Sized_relobj<size, big_endian>::relocate_sections(
 	  continue;
 	}
 
-      assert((*pviews)[index].view != NULL);
+      gold_assert((*pviews)[index].view != NULL);
 
       if (shdr.get_sh_link() != this->symtab_shndx_)
 	{
@@ -471,6 +471,29 @@ Sized_relobj<size, big_endian>::relocate_sections(
     }
 }
 
+// Relocate_functions functions.
+
+// Return whether we need a COPY reloc for a relocation against GSYM.
+// The relocation is being applied to section SHNDX in OBJECT.
+
+template<int size, bool big_endian>
+bool
+Relocate_functions<size, big_endian>::need_copy_reloc(
+    const General_options*,
+    Relobj* object,
+    unsigned int shndx,
+    Symbol*)
+{
+  // FIXME: Handle -z nocopyrelocs.
+
+  // If this is a readonly section, then we need a COPY reloc.
+  // Otherwise we can use a dynamic reloc.
+  if ((object->section_flags(shndx) & elfcpp::SHF_WRITE) == 0)
+    return true;
+
+  return false;
+}
+
 // Instantiate the templates we need.  We could use the configure
 // script to restrict this to only the ones for implemented targets.
 
@@ -546,5 +569,28 @@ Sized_relobj<64, true>::do_relocate(const General_options& options,
 				    const Layout* layout,
 				    Output_file* of);
 
+template
+bool
+Relocate_functions<32, false>::need_copy_reloc(const General_options*,
+					       Relobj*, unsigned int,
+					       Symbol*);
+
+template
+bool
+Relocate_functions<32, true>::need_copy_reloc(const General_options*,
+					      Relobj*, unsigned int,
+					      Symbol*);
+
+template
+bool
+Relocate_functions<64, false>::need_copy_reloc(const General_options*,
+					       Relobj*, unsigned int,
+					       Symbol*);
+
+template
+bool
+Relocate_functions<64, true>::need_copy_reloc(const General_options*,
+					      Relobj*, unsigned int,
+					      Symbol*);
 
 } // End namespace gold.
diff --git a/gold/reloc.h b/gold/reloc.h
index 9b0518e..7829440 100644
--- a/gold/reloc.h
+++ b/gold/reloc.h
@@ -10,9 +10,11 @@
 namespace gold
 {
 
+class General_options;
 class Relobj;
 class Read_relocs_data;
 class Stringpool;
+class Symbol;
 class Layout;
 
 // A class to read the relocations for an object file, and then queue
@@ -227,6 +229,12 @@ public:
   {
     This::template pcrel<64>(view, value, address);
   }
+
+  // Return whether we need a COPY reloc for a reloc against GSYM,
+  // which is being applied to section SHNDX in OBJECT.
+  static bool
+  need_copy_reloc(const General_options*, Relobj* object, unsigned int shndx,
+		  Symbol* gsym);
 };
 
 } // End namespace gold.
diff --git a/gold/resolve.cc b/gold/resolve.cc
index 2b6d65c..891de8c 100644
--- a/gold/resolve.cc
+++ b/gold/resolve.cc
@@ -19,7 +19,7 @@ void
 Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym,
 		      Object* object)
 {
-  assert(this->source_ == FROM_OBJECT);
+  gold_assert(this->source_ == FROM_OBJECT);
   this->u_.from_object.object = object;
   // FIXME: Handle SHN_XINDEX.
   this->u_.from_object.shnum = sym.get_st_shndx();
@@ -98,12 +98,12 @@ Symbol_table::resolve(Sized_symbol<size>* to,
     case elfcpp::STB_LOCAL:
       // We should only see externally visible symbols in the symbol
       // table.
-      abort();
+      gold_unreachable();
 
     default:
       // Any target which wants to handle STB_LOOS, etc., needs to
       // define a resolve method.
-      abort();
+      gold_unreachable();
     }
 
   if (to->source() == Symbol::FROM_OBJECT
@@ -507,7 +507,7 @@ Symbol_table::resolve(Sized_symbol<size>* to,
       return;
 
     default:
-      abort();
+      gold_unreachable();
     }
 }
 
diff --git a/gold/script.cc b/gold/script.cc
index b22611f..f5584d9 100644
--- a/gold/script.cc
+++ b/gold/script.cc
@@ -4,7 +4,6 @@
 
 #include <string>
 #include <vector>
-#include <cassert>
 #include <cstdio>
 #include <cstdlib>
 
@@ -50,14 +49,20 @@ class Token
   Token(Classification classification, int lineno, int charpos)
     : classification_(classification), value_(), opcode_(0),
       lineno_(lineno), charpos_(charpos)
-  { assert(classification == TOKEN_INVALID || classification == TOKEN_EOF); }
+  {
+    gold_assert(classification == TOKEN_INVALID
+		|| classification == TOKEN_EOF);
+  }
 
   // A general token with a value.
   Token(Classification classification, const std::string& value,
 	int lineno, int charpos)
     : classification_(classification), value_(value), opcode_(0),
       lineno_(lineno), charpos_(charpos)
-  { assert(classification != TOKEN_INVALID && classification != TOKEN_EOF); }
+  {
+    gold_assert(classification != TOKEN_INVALID
+		&& classification != TOKEN_EOF);
+  }
 
   // A token representing a string of characters.
   Token(const std::string& s, int lineno, int charpos)
@@ -101,21 +106,21 @@ class Token
   const std::string&
   string_value() const
   {
-    assert(this->classification_ == TOKEN_STRING);
+    gold_assert(this->classification_ == TOKEN_STRING);
     return this->value_;
   }
 
   int
   operator_value() const
   {
-    assert(this->classification_ == TOKEN_OPERATOR);
+    gold_assert(this->classification_ == TOKEN_OPERATOR);
     return this->opcode_;
   }
 
   int64_t
   integer_value() const
   {
-    assert(this->classification_ == TOKEN_INTEGER);
+    gold_assert(this->classification_ == TOKEN_INTEGER);
     return strtoll(this->value_.c_str(), NULL, 0);
   }
 
@@ -1097,7 +1102,7 @@ yylex(YYSTYPE* lvalp, void* closurev)
     default:
     case Token::TOKEN_INVALID:
     case Token::TOKEN_EOF:
-      abort();
+      gold_unreachable();
 
     case Token::TOKEN_STRING:
       {
diff --git a/gold/stringpool.cc b/gold/stringpool.cc
index 5b60259..d53cf77 100644
--- a/gold/stringpool.cc
+++ b/gold/stringpool.cc
@@ -2,7 +2,6 @@
 
 #include "gold.h"
 
-#include <cassert>
 #include <cstring>
 #include <algorithm>
 #include <vector>
@@ -60,12 +59,15 @@ Stringpool::Stringpool_hash::operator()(const char* s) const
 const char*
 Stringpool::add_string(const char* s, Key* pkey)
 {
+  // We are in trouble if we've already computed the string offsets.
+  gold_assert(this->strtab_size_ == 0);
+
   // The size we allocate for a new Stringdata.
   const size_t buffer_size = 1000;
   // The amount we multiply the Stringdata index when calculating the
   // key.
   const size_t key_mult = 1024;
-  assert(key_mult >= buffer_size);
+  gold_assert(key_mult >= buffer_size);
 
   size_t len = strlen(s);
 
@@ -141,7 +143,7 @@ Stringpool::add(const char* s, Key* pkey)
   std::pair<const char*, Val> element(ret, std::make_pair(k, ozero));
   std::pair<String_set_type::iterator, bool> ins =
     this->string_set_.insert(element);
-  assert(ins.second);
+  gold_assert(ins.second);
 
   if (pkey != NULL)
     *pkey = k;
@@ -222,6 +224,12 @@ Stringpool::is_suffix(const char* s1, const char* s2)
 void
 Stringpool::set_string_offsets()
 {
+  if (this->strtab_size_ != 0)
+    {
+      // We've already computed the offsets.
+      return;
+    }
+
   size_t count = this->string_set_.size();
 
   std::vector<String_set_type::iterator> v;
@@ -260,10 +268,11 @@ Stringpool::set_string_offsets()
 off_t
 Stringpool::get_offset(const char* s) const
 {
+  gold_assert(this->strtab_size_ != 0);
   String_set_type::const_iterator p = this->string_set_.find(s);
   if (p != this->string_set_.end())
     return p->second.second;
-  abort();
+  gold_unreachable();
 }
 
 // Write the ELF strtab into the output file at the specified offset.
@@ -271,6 +280,7 @@ Stringpool::get_offset(const char* s) const
 void
 Stringpool::write(Output_file* of, off_t offset)
 {
+  gold_assert(this->strtab_size_ != 0);
   unsigned char* viewu = of->get_output_view(offset, this->strtab_size_);
   char* view = reinterpret_cast<char*>(viewu);
   view[0] = '\0';
diff --git a/gold/stringpool.h b/gold/stringpool.h
index ed549b4..05c498e 100644
--- a/gold/stringpool.h
+++ b/gold/stringpool.h
@@ -63,7 +63,10 @@ class Stringpool
   // Get the size of the ELF strtab.
   off_t
   get_strtab_size() const
-  { return this->strtab_size_; }
+  {
+    gold_assert(this->strtab_size_ != 0);
+    return this->strtab_size_;
+  }
 
   // Write the strtab into the output file at the specified offset.
   void
diff --git a/gold/symtab.cc b/gold/symtab.cc
index 92d5583..4d2bb1a 100644
--- a/gold/symtab.cc
+++ b/gold/symtab.cc
@@ -2,7 +2,6 @@
 
 #include "gold.h"
 
-#include <cassert>
 #include <stdint.h>
 #include <string>
 #include <utility>
@@ -198,8 +197,8 @@ Symbol_table::Symbol_table_eq::operator()(const Symbol_table_key& k1,
 void
 Symbol_table::make_forwarder(Symbol* from, Symbol* to)
 {
-  assert(from != to);
-  assert(!from->is_forwarder() && !to->is_forwarder());
+  gold_assert(from != to);
+  gold_assert(!from->is_forwarder() && !to->is_forwarder());
   this->forwarders_[from] = to;
   from->set_forwarder();
 }
@@ -209,10 +208,10 @@ Symbol_table::make_forwarder(Symbol* from, Symbol* to)
 Symbol*
 Symbol_table::resolve_forwards(const Symbol* from) const
 {
-  assert(from->is_forwarder());
+  gold_assert(from->is_forwarder());
   Unordered_map<const Symbol*, Symbol*>::const_iterator p =
     this->forwarders_.find(from);
-  assert(p != this->forwarders_.end());
+  gold_assert(p != this->forwarders_.end());
   return p->second;
 }
 
@@ -324,7 +323,7 @@ Symbol_table::add_from_object(Object* object,
       // We already have an entry for NAME/VERSION.
       ret = this->get_sized_symbol SELECT_SIZE_NAME(size) (ins.first->second
                                                            SELECT_SIZE(size));
-      assert(ret != NULL);
+      gold_assert(ret != NULL);
 
       was_undefined = ret->is_undefined();
       was_common = ret->is_common();
@@ -357,7 +356,7 @@ Symbol_table::add_from_object(Object* object,
   else
     {
       // This is the first time we have seen NAME/VERSION.
-      assert(ins.first->second == NULL);
+      gold_assert(ins.first->second == NULL);
 
       was_undefined = false;
       was_common = false;
@@ -406,7 +405,7 @@ Symbol_table::add_from_object(Object* object,
 	    {
 	      // This is the first time we have seen NAME/NULL.  Point
 	      // it at the new entry for NAME/VERSION.
-	      assert(insdef.second);
+	      gold_assert(insdef.second);
 	      insdef.first->second = ret;
 	    }
 	}
@@ -654,7 +653,7 @@ Symbol_table::define_special_symbol(Target* target, const char* name,
 				    bool only_if_ref
                                     ACCEPT_SIZE_ENDIAN)
 {
-  assert(this->size_ == size);
+  gold_assert(this->size_ == size);
 
   Symbol* oldsym;
   Sized_symbol<size>* sym;
@@ -685,20 +684,20 @@ Symbol_table::define_special_symbol(Target* target, const char* name,
 	{
 	  // We already have a symbol table entry for NAME.
 	  oldsym = ins.first->second;
-	  assert(oldsym != NULL);
+	  gold_assert(oldsym != NULL);
 	  sym = NULL;
 	}
       else
 	{
 	  // We haven't seen this symbol before.
-	  assert(ins.first->second == NULL);
+	  gold_assert(ins.first->second == NULL);
 
 	  if (!target->has_make_symbol())
 	    sym = new Sized_symbol<size>();
 	  else
 	    {
-	      assert(target->get_size() == size);
-	      assert(target->is_big_endian() ? big_endian : !big_endian);
+	      gold_assert(target->get_size() == size);
+	      gold_assert(target->is_big_endian() ? big_endian : !big_endian);
 	      typedef Sized_target<size, big_endian> My_target;
 	      My_target* sized_target = static_cast<My_target*>(target);
 	      sym = sized_target->make_symbol();
@@ -713,11 +712,11 @@ Symbol_table::define_special_symbol(Target* target, const char* name,
 
   if (oldsym != NULL)
     {
-      assert(sym == NULL);
+      gold_assert(sym == NULL);
 
       sym = this->get_sized_symbol SELECT_SIZE_NAME(size) (oldsym
                                                            SELECT_SIZE(size));
-      assert(sym->source() == Symbol::FROM_OBJECT);
+      gold_assert(sym->source() == Symbol::FROM_OBJECT);
       const int old_shnum = sym->shnum();
       if (old_shnum != elfcpp::SHN_UNDEF
 	  && old_shnum != elfcpp::SHN_COMMON
@@ -748,7 +747,7 @@ Symbol_table::define_in_output_data(Target* target, const char* name,
 				    bool offset_is_from_end,
 				    bool only_if_ref)
 {
-  assert(target->get_size() == this->size_);
+  gold_assert(target->get_size() == this->size_);
   if (this->size_ == 32)
     this->do_define_in_output_data<32>(target, name, od, value, symsize,
 				       type, binding, visibility, nonvis,
@@ -758,7 +757,7 @@ Symbol_table::define_in_output_data(Target* target, const char* name,
 				       type, binding, visibility, nonvis,
 				       offset_is_from_end, only_if_ref);
   else
-    abort();
+    gold_unreachable();
 }
 
 // Define a symbol in an Output_data, sized version.
@@ -808,7 +807,7 @@ Symbol_table::define_in_output_segment(Target* target, const char* name,
 				       Symbol::Segment_offset_base offset_base,
 				       bool only_if_ref)
 {
-  assert(target->get_size() == this->size_);
+  gold_assert(target->get_size() == this->size_);
   if (this->size_ == 32)
     this->do_define_in_output_segment<32>(target, name, os, value, symsize,
 					  type, binding, visibility, nonvis,
@@ -818,7 +817,7 @@ Symbol_table::define_in_output_segment(Target* target, const char* name,
 					  type, binding, visibility, nonvis,
 					  offset_base, only_if_ref);
   else
-    abort();
+    gold_unreachable();
 }
 
 // Define a symbol in an Output_segment, sized version.
@@ -866,7 +865,7 @@ Symbol_table::define_as_constant(Target* target, const char* name,
 				 elfcpp::STV visibility, unsigned char nonvis,
 				 bool only_if_ref)
 {
-  assert(target->get_size() == this->size_);
+  gold_assert(target->get_size() == this->size_);
   if (this->size_ == 32)
     this->do_define_as_constant<32>(target, name, value, symsize,
 				    type, binding, visibility, nonvis,
@@ -876,7 +875,7 @@ Symbol_table::define_as_constant(Target* target, const char* name,
 				    type, binding, visibility, nonvis,
 				    only_if_ref);
   else
-    abort();
+    gold_unreachable();
 }
 
 // Define a symbol as a constant, sized version.
@@ -955,6 +954,33 @@ Symbol_table::define_symbols(const Layout* layout, Target* target, int count,
     }
 }
 
+// Set the dynamic symbol indexes.  INDEX is the index of the first
+// global dynamic symbol.  Pointers to the symbols are stored into the
+// vector SYMS.  The names are added to DYNPOOL.  This returns an
+// updated dynamic symbol index.
+
+unsigned int
+Symbol_table::set_dynsym_indexes(unsigned int index,
+				 std::vector<Symbol*>* syms,
+				 Stringpool* dynpool)
+{
+  for (Symbol_table_type::iterator p = this->table_.begin();
+       p != this->table_.end();
+       ++p)
+    {
+      Symbol* sym = p->second;
+      if (sym->needs_dynsym_entry())
+	{
+	  sym->set_dynsym_index(index);
+	  ++index;
+	  syms->push_back(sym);
+	  dynpool->add(sym->name(), NULL);
+	}
+    }
+
+  return index;
+}
+
 // Set the final values for all the symbols.  The index of the first
 // global symbol in the output file is INDEX.  Record the file offset
 // OFF.  Add their names to POOL.  Return the new file offset.
@@ -964,7 +990,7 @@ Symbol_table::finalize(unsigned int index, off_t off, Stringpool* pool)
 {
   off_t ret;
 
-  assert(index != 0);
+  gold_assert(index != 0);
   this->first_global_index_ = index;
 
   if (this->size_ == 32)
@@ -972,7 +998,7 @@ Symbol_table::finalize(unsigned int index, off_t off, Stringpool* pool)
   else if (this->size_ == 64)
     ret = this->sized_finalize<64>(index, off, pool);
   else
-    abort();
+    gold_unreachable();
 
   // Now that we have the final symbol table, we can reliably note
   // which symbols should get warnings.
@@ -1002,7 +1028,12 @@ Symbol_table::sized_finalize(unsigned index, off_t off, Stringpool* pool)
       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
 
       // FIXME: Here we need to decide which symbols should go into
-      // the output file.
+      // the output file, based on --strip.
+
+      // The default version of a symbol may appear twice in the
+      // symbol table.  We only need to finalize it once.
+      if (sym->has_symtab_index())
+	continue;
 
       typename Sized_symbol<size>::Value_type value;
 
@@ -1072,7 +1103,7 @@ Symbol_table::sized_finalize(unsigned index, off_t off, Stringpool* pool)
 		value += os->filesz();
 		break;
 	      default:
-		abort();
+		gold_unreachable();
 	      }
 	  }
 	  break;
@@ -1082,7 +1113,7 @@ Symbol_table::sized_finalize(unsigned index, off_t off, Stringpool* pool)
 	  break;
 
 	default:
-	  abort();
+	  gold_unreachable();
 	}
 
       sym->set_value(value);
@@ -1118,7 +1149,7 @@ Symbol_table::write_globals(const Target* target, const Stringpool* sympool,
 	this->sized_write_globals<64, false>(target, sympool, of);
     }
   else
-    abort();
+    gold_unreachable();
 }
 
 // Write out the global symbols.
@@ -1141,8 +1172,20 @@ Symbol_table::sized_write_globals(const Target*,
     {
       Sized_symbol<size>* sym = static_cast<Sized_symbol<size>*>(p->second);
 
-      if (sym->symtab_index() == -1U)
-	continue;
+      unsigned int sym_index = sym->symtab_index();
+      if (sym_index == -1U)
+	{
+	  // This symbol is not included in the output file.
+	  continue;
+	}
+      if (sym_index != index)
+	{
+	  // We have already seen this symbol, because it has a
+	  // default version.
+	  gold_assert(sym_index < index);
+	  continue;
+	}
+      ++index;
 
       unsigned int shndx;
       switch (sym->source())
@@ -1173,7 +1216,7 @@ Symbol_table::sized_write_globals(const Target*,
 		Relobj* relobj = static_cast<Relobj*>(symobj);
 		off_t secoff;
 		Output_section* os = relobj->output_section(shnum, &secoff);
-		assert(os != NULL);
+		gold_assert(os != NULL);
 		shndx = os->out_shndx();
 	      }
 	  }
@@ -1192,12 +1235,9 @@ Symbol_table::sized_write_globals(const Target*,
 	  break;
 
 	default:
-	  abort();
+	  gold_unreachable();
 	}
 
-      assert(sym->symtab_index() == index);
-      ++index;
-
       elfcpp::Sym_write<size, big_endian> osym(ps);
       osym.put_st_name(sympool->get_offset(sym->name()));
       osym.put_st_value(sym->value());
@@ -1210,11 +1250,61 @@ Symbol_table::sized_write_globals(const Target*,
       ps += sym_size;
     }
 
-  assert(ps - psyms == oview_size);
+  gold_assert(ps - psyms == oview_size);
 
   of->write_output_view(this->offset_, oview_size, psyms);
 }
 
+// Write out a section symbol.  Return the update offset.
+
+void
+Symbol_table::write_section_symbol(const Target* target,
+				   const Output_section *os,
+				   Output_file* of,
+				   off_t offset) const
+{
+  if (this->size_ == 32)
+    {
+      if (target->is_big_endian())
+	this->sized_write_section_symbol<32, true>(os, of, offset);
+      else
+	this->sized_write_section_symbol<32, false>(os, of, offset);
+    }
+  else if (this->size_ == 64)
+    {
+      if (target->is_big_endian())
+	this->sized_write_section_symbol<64, true>(os, of, offset);
+      else
+	this->sized_write_section_symbol<64, false>(os, of, offset);
+    }
+  else
+    gold_unreachable();
+}
+
+// Write out a section symbol, specialized for size and endianness.
+
+template<int size, bool big_endian>
+void
+Symbol_table::sized_write_section_symbol(const Output_section* os,
+					 Output_file* of,
+					 off_t offset) const
+{
+  const int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+
+  unsigned char* pov = of->get_output_view(offset, sym_size);
+
+  elfcpp::Sym_write<size, big_endian> osym(pov);
+  osym.put_st_name(0);
+  osym.put_st_value(os->address());
+  osym.put_st_size(0);
+  osym.put_st_info(elfcpp::elf_st_info(elfcpp::STB_LOCAL,
+				       elfcpp::STT_SECTION));
+  osym.put_st_other(elfcpp::elf_st_other(elfcpp::STV_DEFAULT, 0));
+  osym.put_st_shndx(os->out_shndx());
+
+  of->write_output_view(offset, sym_size, pov);
+}
+
 // Warnings functions.
 
 // Add a new warning.
@@ -1268,9 +1358,9 @@ Warnings::note_warnings(Symbol_table* symtab)
 void
 Warnings::issue_warning(const Symbol* sym, const std::string& location) const
 {
-  assert(sym->has_warning());
+  gold_assert(sym->has_warning());
   Warning_table::const_iterator p = this->warnings_.find(sym->name());
-  assert(p != this->warnings_.end());
+  gold_assert(p != this->warnings_.end());
   fprintf(stderr, _("%s: %s: warning: %s\n"), program_name, location.c_str(),
 	  p->second.text.c_str());
 }
diff --git a/gold/symtab.h b/gold/symtab.h
index 06a4b6b..1350bf1 100644
--- a/gold/symtab.h
+++ b/gold/symtab.h
@@ -6,7 +6,6 @@
 #include <string>
 #include <utility>
 #include <vector>
-#include <cassert>
 
 #include "elfcpp.h"
 #include "stringpool.h"
@@ -26,6 +25,7 @@ class Dynobj;
 template<int size, bool big_endian>
 class Sized_dynobj;
 class Output_data;
+class Output_section;
 class Output_segment;
 class Output_file;
 class Target;
@@ -90,7 +90,7 @@ class Symbol
   Object*
   object() const
   {
-    assert(this->source_ == FROM_OBJECT);
+    gold_assert(this->source_ == FROM_OBJECT);
     return this->u_.from_object.object;
   }
 
@@ -99,7 +99,7 @@ class Symbol
   unsigned int
   shnum() const
   {
-    assert(this->source_ == FROM_OBJECT);
+    gold_assert(this->source_ == FROM_OBJECT);
     return this->u_.from_object.shnum;
   }
 
@@ -109,7 +109,7 @@ class Symbol
   Output_data*
   output_data() const
   {
-    assert(this->source_ == IN_OUTPUT_DATA);
+    gold_assert(this->source_ == IN_OUTPUT_DATA);
     return this->u_.in_output_data.output_data;
   }
 
@@ -118,7 +118,7 @@ class Symbol
   bool
   offset_is_from_end() const
   {
-    assert(this->source_ == IN_OUTPUT_DATA);
+    gold_assert(this->source_ == IN_OUTPUT_DATA);
     return this->u_.in_output_data.offset_is_from_end;
   }
 
@@ -128,7 +128,7 @@ class Symbol
   Output_segment*
   output_segment() const
   {
-    assert(this->source_ == IN_OUTPUT_SEGMENT);
+    gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
     return this->u_.in_output_segment.output_segment;
   }
 
@@ -137,7 +137,7 @@ class Symbol
   Segment_offset_base
   offset_base() const
   {
-    assert(this->source_ == IN_OUTPUT_SEGMENT);
+    gold_assert(this->source_ == IN_OUTPUT_SEGMENT);
     return this->u_.in_output_segment.offset_base;
   }
 
@@ -184,11 +184,6 @@ class Symbol
   set_needs_dynsym_entry()
   { this->needs_dynsym_entry_ = true; }
 
-  // Return whether this symbol was ever seen in a dynamic object.
-  bool
-  in_dyn() const
-  { return this->in_dyn_; }
-
   // Mark this symbol as having been seen in a dynamic object.
   void
   set_in_dyn()
@@ -202,7 +197,7 @@ class Symbol
   unsigned int
   symtab_index() const
   {
-    assert(this->symtab_index_ != 0);
+    gold_assert(this->symtab_index_ != 0);
     return this->symtab_index_;
   }
 
@@ -210,10 +205,16 @@ class Symbol
   void
   set_symtab_index(unsigned int index)
   {
-    assert(index != 0);
+    gold_assert(index != 0);
     this->symtab_index_ = index;
   }
 
+  // Return whether this symbol already has an index in the output
+  // file symbol table.
+  bool
+  has_symtab_index() const
+  { return this->symtab_index_ != 0; }
+
   // Return the index of this symbol in the dynamic symbol table.  A
   // value of -1U means that this symbol is not going into the dynamic
   // symbol table.  This starts out as zero, and is set to a non-zero
@@ -222,7 +223,7 @@ class Symbol
   unsigned int
   dynsym_index() const
   {
-    assert(this->dynsym_index_ != 0);
+    gold_assert(this->dynsym_index_ != 0);
     return this->dynsym_index_;
   }
 
@@ -230,7 +231,7 @@ class Symbol
   void
   set_dynsym_index(unsigned int index)
   {
-    assert(index != 0);
+    gold_assert(index != 0);
     this->dynsym_index_ = index;
   }
 
@@ -243,7 +244,7 @@ class Symbol
   unsigned int
   got_offset() const
   {
-    assert(this->has_got_offset());
+    gold_assert(this->has_got_offset());
     return this->got_offset_;
   }
 
@@ -255,14 +256,36 @@ class Symbol
     this->got_offset_ = got_offset;
   }
 
-  // Return whether this symbol is resolved locally.  This is always
-  // true when linking statically.  It is true for a symbol defined in
-  // this object when using -Bsymbolic.  It is true for a symbol
-  // marked local in a version file.  FIXME: This needs to be
-  // completed.
+  // Return whether this symbol has an entry in the PLT section.
   bool
-  is_resolved_locally() const
-  { return !this->in_dyn_; }
+  has_plt_offset() const
+  { return this->has_plt_offset_; }
+
+  // Return the offset into the PLT section of this symbol.
+  unsigned int
+  plt_offset() const
+  {
+    gold_assert(this->has_plt_offset());
+    return this->plt_offset_;
+  }
+
+  // Set the PLT offset of this symbol.
+  void
+  set_plt_offset(unsigned int plt_offset)
+  {
+    this->has_plt_offset_ = true;
+    this->plt_offset_ = plt_offset;
+  }
+
+  // Return true if the final value of this symbol is known at link
+  // time.
+  bool
+  final_value_is_known(const General_options* options) const
+  {
+    if (options->is_shared())
+      return false;
+    return this->source_ != FROM_OBJECT || !this->object()->is_dynamic();
+  }
 
   // Return whether this is a defined symbol (not undefined or
   // common).
@@ -270,8 +293,17 @@ class Symbol
   is_defined() const
   {
     return (this->source_ != FROM_OBJECT
-	    || (this->u_.from_object.shnum != elfcpp::SHN_UNDEF
-		&& this->u_.from_object.shnum != elfcpp::SHN_COMMON));
+	    || (this->shnum() != elfcpp::SHN_UNDEF
+		&& this->shnum() != elfcpp::SHN_COMMON));
+  }
+
+  // Return whether this symbol is defined in a dynamic object.
+  bool
+  is_defined_in_dynobj() const
+  {
+    return (this->source_ == FROM_OBJECT
+	    && this->object()->is_dynamic()
+	    && this->is_defined());
   }
 
   // Return whether this is an undefined symbol.
@@ -286,7 +318,7 @@ class Symbol
   is_common() const
   {
     return (this->source_ == FROM_OBJECT
-	    && (this->u_.from_object.shnum == elfcpp::SHN_COMMON
+	    && (this->shnum() == elfcpp::SHN_COMMON
 		|| this->type_ == elfcpp::STT_COMMON));
   }
 
@@ -401,6 +433,11 @@ class Symbol
   // is true), this is the offset from the start of the GOT section.
   unsigned int got_offset_;
 
+  // If this symbol has an entry in the PLT section (has_plt_offset_
+  // is true), then this is the offset from the start of the PLT
+  // section.
+  unsigned int plt_offset_;
+
   // Symbol type.
   elfcpp::STT type_ : 4;
   // Symbol binding.
@@ -430,6 +467,8 @@ class Symbol
   bool in_dyn_ : 1;
   // True if the symbol has an entry in the GOT section.
   bool has_got_offset_ : 1;
+  // True if the symbol has an entry in the PLT section.
+  bool has_plt_offset_ : 1;
   // True if there is a warning for this symbol.
   bool has_warning_ : 1;
 };
@@ -735,7 +774,7 @@ class Symbol_table
   Symbol*
   resolve_forwards(const Symbol* from) const;
 
-  // Return the size of the symbols in the table.
+  // Return the bitsize (32 or 64) of the symbols in the table.
   int
   get_size() const
   { return this->size_; }
@@ -774,6 +813,14 @@ class Symbol_table
   issue_warning(const Symbol* sym, const std::string& location) const
   { this->warnings_.issue_warning(sym, location); }
 
+  // Set the dynamic symbol indexes.  INDEX is the index of the first
+  // global dynamic symbol.  Pointers to the symbols are stored into
+  // the vector.  The names are stored into the Stringpool.  This
+  // returns an updated dynamic symbol index.
+  unsigned int
+  set_dynsym_indexes(unsigned int index, std::vector<Symbol*>*,
+		     Stringpool*);
+
   // Finalize the symbol table after we have set the final addresses
   // of all the input sections.  This sets the final symbol indexes,
   // values and adds the names to *POOL.  INDEX is the index of the
@@ -786,11 +833,16 @@ class Symbol_table
   void
   write_globals(const Target*, const Stringpool*, Output_file*) const;
 
+  // Write out a section symbol.  Return the updated offset.
+  void
+  write_section_symbol(const Target*, const Output_section*, Output_file*,
+		       off_t) const;
+
  private:
   Symbol_table(const Symbol_table&);
   Symbol_table& operator=(const Symbol_table&);
 
-  // Set the size of the symbols in the table.
+  // Set the size (32 or 64) of the symbols in the table.
   void
   set_size(int size)
   { this->size_ = size; }
@@ -865,6 +917,11 @@ class Symbol_table
   void
   sized_write_globals(const Target*, const Stringpool*, Output_file*) const;
 
+  // Write out a section symbol, specialized for size and endianness.
+  template<int size, bool big_endian>
+  void
+  sized_write_section_symbol(const Output_section*, Output_file*, off_t) const;
+
   // The type of the symbol hash table.
 
   typedef std::pair<Stringpool::Key, Stringpool::Key> Symbol_table_key;
@@ -932,7 +989,7 @@ template<int size>
 Sized_symbol<size>*
 Symbol_table::get_sized_symbol(Symbol* sym ACCEPT_SIZE) const
 {
-  assert(size == this->get_size());
+  gold_assert(size == this->get_size());
   return static_cast<Sized_symbol<size>*>(sym);
 }
 
@@ -940,7 +997,7 @@ template<int size>
 const Sized_symbol<size>*
 Symbol_table::get_sized_symbol(const Symbol* sym ACCEPT_SIZE) const
 {
-  assert(size == this->get_size());
+  gold_assert(size == this->get_size());
   return static_cast<const Sized_symbol<size>*>(sym);
 }
 
diff --git a/gold/target-reloc.h b/gold/target-reloc.h
index 5b057ac..727de02 100644
--- a/gold/target-reloc.h
+++ b/gold/target-reloc.h
@@ -26,6 +26,7 @@ scan_relocs(
     Layout* layout,
     Target_type* target,
     Sized_relobj<size, big_endian>* object,
+    unsigned int data_shndx,
     const unsigned char* prelocs,
     size_t reloc_count,
     size_t local_count,
@@ -47,7 +48,7 @@ scan_relocs(
 
       if (r_sym < local_count)
 	{
-	  assert(plocal_syms != NULL);
+	  gold_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();
@@ -73,18 +74,18 @@ scan_relocs(
 	      continue;
 	    }
 
-	  scan.local(options, symtab, layout, target, object, reloc, r_type,
-		     lsym);
+	  scan.local(options, symtab, layout, target, object, data_shndx,
+		     reloc, r_type, lsym);
 	}
       else
 	{
 	  Symbol* gsym = global_syms[r_sym - local_count];
-	  assert(gsym != NULL);
+	  gold_assert(gsym != NULL);
 	  if (gsym->is_forwarder())
 	    gsym = symtab->resolve_forwards(gsym);
 
-	  scan.global(options, symtab, layout, target, object, reloc, r_type,
-		      gsym);
+	  scan.global(options, symtab, layout, target, object, data_shndx,
+		      reloc, r_type, gsym);
 	}
     }
 }
@@ -146,7 +147,7 @@ relocate_section(
       else
 	{
 	  const Symbol* gsym = global_syms[r_sym - local_count];
-	  assert(gsym != NULL);
+	  gold_assert(gsym != NULL);
 	  if (gsym->is_forwarder())
 	    gsym = relinfo->symtab->resolve_forwards(gsym);
 
diff --git a/gold/target.h b/gold/target.h
index 5a86c35..039b97d 100644
--- a/gold/target.h
+++ b/gold/target.h
@@ -13,8 +13,6 @@
 #ifndef GOLD_TARGET_H
 #define GOLD_TARGET_H
 
-#include <cassert>
-
 #include "elfcpp.h"
 
 namespace gold
@@ -137,7 +135,7 @@ class Sized_target : public Target
   // returns true.
   virtual Sized_symbol<size>*
   make_symbol()
-  { abort(); }
+  { gold_unreachable(); }
 
   // Resolve a symbol for the target.  This should be overridden by a
   // target which needs to take special action.  TO is the
@@ -145,12 +143,13 @@ class Sized_target : public Target
   // This will only be called if has_resolve() returns true.
   virtual void
   resolve(Symbol*, const elfcpp::Sym<size, big_endian>&, Object*)
-  { abort(); }
+  { gold_unreachable(); }
 
   // Scan the relocs for a section, and record any information
   // required for the symbol.  OPTIONS is the command line options.
   // SYMTAB is the symbol table.  OBJECT is the object in which the
-  // section appears.  SH_TYPE is the type of the relocation section,
+  // section appears.  DATA_SHNDX is the section index that these
+  // relocs apply to.  SH_TYPE is the type of the relocation section,
   // SHT_REL or SHT_RELA.  PRELOCS points to the relocation data.
   // RELOC_COUNT is the number of relocs.  LOCAL_SYMBOL_COUNT is the
   // number of local symbols.  PLOCAL_SYMBOLS points to the local
@@ -161,6 +160,7 @@ class Sized_target : public Target
 	      Symbol_table* symtab,
 	      Layout* layout,
 	      Sized_relobj<size, big_endian>* object,
+	      unsigned int data_shndx,
 	      unsigned int sh_type,
 	      const unsigned char* prelocs,
 	      size_t reloc_count,
@@ -187,8 +187,8 @@ class Sized_target : public Target
   Sized_target(const Target::Target_info* pti)
     : Target(pti)
   {
-    assert(pti->size == size);
-    assert(pti->is_big_endian ? big_endian : !big_endian);
+    gold_assert(pti->size == size);
+    gold_assert(pti->is_big_endian ? big_endian : !big_endian);
   }
 };
 
diff --git a/gold/workqueue.cc b/gold/workqueue.cc
index 3ef3422..9062118 100644
--- a/gold/workqueue.cc
+++ b/gold/workqueue.cc
@@ -2,8 +2,6 @@
 
 #include "gold.h"
 
-#include <cassert>
-
 #include "workqueue.h"
 
 namespace gold
@@ -18,59 +16,59 @@ Task_token::Task_token()
 
 Task_token::~Task_token()
 {
-  assert(this->readers_ == 0 && this->writer_ == NULL);
+  gold_assert(this->readers_ == 0 && this->writer_ == NULL);
 }
 
 bool
 Task_token::is_readable() const
 {
-  assert(!this->is_blocker_);
+  gold_assert(!this->is_blocker_);
   return this->writer_ == NULL;
 }
 
 void
 Task_token::add_reader()
 {
-  assert(!this->is_blocker_);
-  assert(this->is_readable());
+  gold_assert(!this->is_blocker_);
+  gold_assert(this->is_readable());
   ++this->readers_;
 }
 
 void
 Task_token::remove_reader()
 {
-  assert(!this->is_blocker_);
-  assert(this->readers_ > 0);
+  gold_assert(!this->is_blocker_);
+  gold_assert(this->readers_ > 0);
   --this->readers_;
 }
 
 bool
 Task_token::is_writable() const
 {
-  assert(!this->is_blocker_);
+  gold_assert(!this->is_blocker_);
   return this->writer_ == NULL && this->readers_ == 0;
 }
 
 void
 Task_token::add_writer(const Task* t)
 {
-  assert(!this->is_blocker_);
-  assert(this->is_writable());
+  gold_assert(!this->is_blocker_);
+  gold_assert(this->is_writable());
   this->writer_ = t;
 }
 
 void
 Task_token::remove_writer(const Task* t)
 {
-  assert(!this->is_blocker_);
-  assert(this->writer_ == t);
+  gold_assert(!this->is_blocker_);
+  gold_assert(this->writer_ == t);
   this->writer_ = NULL;
 }
 
 bool
 Task_token::has_write_lock(const Task* t)
 {
-  assert(!this->is_blocker_);
+  gold_assert(!this->is_blocker_);
   return this->writer_ == t;
 }
 
@@ -82,14 +80,14 @@ Task_token::add_blocker()
   if (this->readers_ == 0 && this->writer_ == NULL)
     this->is_blocker_ = true;
   else
-    assert(this->is_blocker_);
+    gold_assert(this->is_blocker_);
   ++this->readers_;
 }
 
 bool
 Task_token::remove_blocker()
 {
-  assert(this->is_blocker_ && this->readers_ > 0);
+  gold_assert(this->is_blocker_ && this->readers_ > 0);
   --this->readers_;
   return this->readers_ == 0;
 }
@@ -97,7 +95,8 @@ Task_token::remove_blocker()
 bool
 Task_token::is_blocked() const
 {
-  assert(this->is_blocker_ || (this->readers_ == 0 && this->writer_ == NULL));
+  gold_assert(this->is_blocker_
+	      || (this->readers_ == 0 && this->writer_ == NULL));
   return this->readers_ > 0;
 }
 
@@ -109,7 +108,7 @@ Task_block_token::Task_block_token(Task_token& token, Workqueue* workqueue)
   // We must increment the block count when the task is created and
   // put on the queue.  This object is created when the task is run,
   // so we don't increment the block count here.
-  assert(this->token_.is_blocked());
+  gold_assert(this->token_.is_blocked());
 }
 
 Task_block_token::~Task_block_token()
@@ -187,9 +186,9 @@ Workqueue::Workqueue(const General_options&)
 
 Workqueue::~Workqueue()
 {
-  assert(this->tasks_.empty());
-  assert(this->completed_.empty());
-  assert(this->running_ == 0);
+  gold_assert(this->tasks_.empty());
+  gold_assert(this->completed_.empty());
+  gold_assert(this->running_ == 0);
 }
 
 // Add a task to the queue.
@@ -263,7 +262,7 @@ Workqueue::find_runnable(Task_list& tasks, bool* all_blocked)
 	      {
 		// There had better be some tasks running, or we will
 		// never find a runnable task.
-		assert(this->running_ > 0);
+		gold_assert(this->running_ > 0);
 
 		// We couldn't find any runnable tasks, and we
 		// couldn't release any locks.
@@ -322,7 +321,7 @@ Workqueue::process()
 
 	    // There must be something for us to wait for, or we won't
 	    // be able to make progress.
-	    assert(this->running_ > 0 || !this->completed_.empty());
+	    gold_assert(this->running_ > 0 || !this->completed_.empty());
 
 	    if (all_blocked)
 	      {
@@ -330,7 +329,7 @@ Workqueue::process()
 		this->clear_completed();
 		while (this->cleared_blockers_ == 0)
 		  {
-		    assert(this->running_ > 0);
+		    gold_assert(this->running_ > 0);
 		    this->completed_condvar_.wait();
 		    this->clear_completed();
 		  }
@@ -385,7 +384,7 @@ Workqueue::completed(Task* t, Task_locker* tl)
 {
   {
     Hold_lock hl(this->completed_lock_);
-    assert(this->running_ > 0);
+    gold_assert(this->running_ > 0);
     --this->running_;
     this->completed_.push_back(tl);
     this->completed_condvar_.signal();