X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gold%2Farchive.cc;h=1d83d6a2f79e85c364bc2828470552eb59da53a6;hb=16ad93705cfed2630f48ba44b7dde9d20a4c6f44;hp=1442731f045ef867507b3acc203df318802ae24e;hpb=3e95a404c8ed29f01447b979392c203a846f6f2f;p=deliverable%2Fbinutils-gdb.git

diff --git a/gold/archive.cc b/gold/archive.cc
index 1442731f04..1d83d6a2f7 100644
--- a/gold/archive.cc
+++ b/gold/archive.cc
@@ -1,6 +1,6 @@
 // archive.cc -- archive support for gold
 
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -26,14 +26,18 @@
 #include <cstring>
 #include <climits>
 #include <vector>
+#include "libiberty.h"
+#include "filenames.h"
 
 #include "elfcpp.h"
 #include "options.h"
+#include "mapfile.h"
 #include "fileread.h"
 #include "readsyms.h"
 #include "symtab.h"
 #include "object.h"
 #include "archive.h"
+#include "plugin.h"
 
 namespace gold
 {
@@ -60,6 +64,11 @@ struct Archive::Archive_header
   char ar_fmag[2];
 };
 
+// Class Archive static variables.
+unsigned int Archive::total_archives;
+unsigned int Archive::total_members;
+unsigned int Archive::total_members_loaded;
+
 // Archive methods.
 
 const char Archive::armag[sarmag] =
@@ -67,6 +76,11 @@ const char Archive::armag[sarmag] =
   '!', '<', 'a', 'r', 'c', 'h', '>', '\n'
 };
 
+const char Archive::armagt[sarmag] =
+{
+  '!', '<', 't', 'h', 'i', 'n', '>', '\n'
+};
+
 const char Archive::arfmag[2] = { '`', '\n' };
 
 // Set up the archive: read the symbol map and the extended name
@@ -77,48 +91,76 @@ Archive::setup()
 {
   // We need to ignore empty archives.
   if (this->input_file_->file().filesize() == sarmag)
-    {
-      this->input_file_->file().unlock();
-      return;
-    }
+    return;
 
   // The first member of the archive should be the symbol table.
   std::string armap_name;
-  off_t armap_size = this->read_header(sarmag, &armap_name);
+  section_size_type armap_size =
+    convert_to_section_size_type(this->read_header(sarmag, false,
+						   &armap_name, NULL));
   off_t off = sarmag;
   if (armap_name.empty())
     {
       this->read_armap(sarmag + sizeof(Archive_header), armap_size);
       off = sarmag + sizeof(Archive_header) + armap_size;
     }
-  else if (!this->input_file_->options().include_whole_archive())
+  else if (!this->input_file_->options().whole_archive())
     gold_error(_("%s: no archive symbol table (run ranlib)"),
 	       this->name().c_str());
 
-  // See if there is an extended name table.
+  // See if there is an extended name table.  We cache these views
+  // because it is likely that we will want to read the following
+  // header in the add_symbols routine.
   if ((off & 1) != 0)
     ++off;
   std::string xname;
-  off_t extended_size = this->read_header(off, &xname);
+  section_size_type extended_size =
+    convert_to_section_size_type(this->read_header(off, true, &xname, NULL));
   if (xname == "/")
     {
       const unsigned char* p = this->get_view(off + sizeof(Archive_header),
-                                              extended_size, false);
+                                              extended_size, false, true);
       const char* px = reinterpret_cast<const char*>(p);
       this->extended_names_.assign(px, extended_size);
     }
+  bool preread_syms = (parameters->options().threads()
+                       && parameters->options().preread_archive_symbols());
+#ifndef ENABLE_THREADS
+  preread_syms = false;
+#else
+  if (parameters->options().has_plugins())
+    preread_syms = false;
+#endif
+  if (preread_syms)
+    this->read_all_symbols();
+}
+
+// Unlock any nested archives.
 
-  // Opening the file locked it.  Unlock it now.
-  this->input_file_->file().unlock();
+void
+Archive::unlock_nested_archives()
+{
+  for (Nested_archive_table::iterator p = this->nested_archives_.begin();
+       p != this->nested_archives_.end();
+       ++p)
+    {
+      p->second->unlock(this->task_);
+    }
 }
 
 // Read the archive symbol map.
 
 void
-Archive::read_armap(off_t start, off_t size)
+Archive::read_armap(off_t start, section_size_type size)
 {
+  // To count the total number of archive members, we'll just count
+  // the number of times the file offset changes.  Since most archives
+  // group the symbols in the armap by object, this ought to give us
+  // an accurate count.
+  off_t last_seen_offset = -1;
+
   // Read in the entire armap.
-  const unsigned char* p = this->get_view(start, size, false);
+  const unsigned char* p = this->get_view(start, size, true, false);
 
   // Numbers in the armap are always big-endian.
   const elfcpp::Elf_Word* pword = reinterpret_cast<const elfcpp::Elf_Word*>(p);
@@ -127,21 +169,27 @@ Archive::read_armap(off_t start, off_t size)
 
   // Note that the addition is in units of sizeof(elfcpp::Elf_Word).
   const char* pnames = reinterpret_cast<const char*>(pword + nsyms);
-  off_t names_size = reinterpret_cast<const char*>(p) + size - pnames;
+  section_size_type names_size =
+    reinterpret_cast<const char*>(p) + size - pnames;
   this->armap_names_.assign(pnames, names_size);
 
   this->armap_.resize(nsyms);
 
-  off_t name_offset = 0;
+  section_offset_type name_offset = 0;
   for (unsigned int i = 0; i < nsyms; ++i)
     {
       this->armap_[i].name_offset = name_offset;
       this->armap_[i].file_offset = elfcpp::Swap<32, true>::readval(pword);
       name_offset += strlen(pnames + name_offset) + 1;
       ++pword;
+      if (this->armap_[i].file_offset != last_seen_offset)
+        {
+          last_seen_offset = this->armap_[i].file_offset;
+          ++this->num_members_;
+        }
     }
 
-  if (reinterpret_cast<const unsigned char*>(pnames) - p > size)
+  if (static_cast<section_size_type>(name_offset) > names_size)
     gold_error(_("%s: bad archive symbol table names"),
 	       this->name().c_str());
 
@@ -155,11 +203,13 @@ Archive::read_armap(off_t start, off_t size)
 // of the member.
 
 off_t
-Archive::read_header(off_t off, std::string* pname)
+Archive::read_header(off_t off, bool cache, std::string* pname,
+                     off_t* nested_off)
 {
-  const unsigned char* p = this->get_view(off, sizeof(Archive_header), false);
+  const unsigned char* p = this->get_view(off, sizeof(Archive_header), true,
+					  cache);
   const Archive_header* hdr = reinterpret_cast<const Archive_header*>(p);
-  return this->interpret_header(hdr, off,  pname);
+  return this->interpret_header(hdr, off,  pname, nested_off);
 }
 
 // Interpret the header of HDR, the header of the archive member at
@@ -168,7 +218,7 @@ Archive::read_header(off_t off, std::string* pname)
 
 off_t
 Archive::interpret_header(const Archive_header* hdr, off_t off,
-                          std::string* pname)
+                          std::string* pname, off_t* nested_off) const
 {
   if (memcmp(hdr->ar_fmag, arfmag, sizeof arfmag) != 0)
     {
@@ -208,6 +258,8 @@ Archive::interpret_header(const Archive_header* hdr, off_t off,
 	  return this->input_file_->file().filesize() - off;
 	}
       pname->assign(hdr->ar_name, name_end - hdr->ar_name);
+      if (nested_off != NULL)
+        *nested_off = 0;
     }
   else if (hdr->ar_name[1] == ' ')
     {
@@ -223,6 +275,9 @@ Archive::interpret_header(const Archive_header* hdr, off_t off,
     {
       errno = 0;
       long x = strtol(hdr->ar_name + 1, &end, 10);
+      long y = 0;
+      if (*end == ':')
+        y = strtol(end + 1, &end, 10);
       if (*end != ' '
 	  || x < 0
 	  || (x == LONG_MAX && errno == ERANGE)
@@ -234,33 +289,341 @@ Archive::interpret_header(const Archive_header* hdr, off_t off,
 	}
 
       const char* name = this->extended_names_.data() + x;
-      const char* name_end = strchr(name, '/');
+      const char* name_end = strchr(name, '\n');
       if (static_cast<size_t>(name_end - name) > this->extended_names_.size()
-	  || name_end[1] != '\n')
+	  || name_end[-1] != '/')
 	{
 	  gold_error(_("%s: bad extended name entry at header %zu"),
 		     this->name().c_str(), static_cast<size_t>(off));
 	  return this->input_file_->file().filesize() - off;
 	}
-      pname->assign(name, name_end - name);
+      pname->assign(name, name_end - 1 - name);
+      if (nested_off != NULL)
+        *nested_off = y;
     }
 
   return member_size;
 }
 
+// An archive member iterator.
+
+class Archive::const_iterator
+{
+ public:
+  // The header of an archive member.  This is what this iterator
+  // points to.
+  struct Header
+  {
+    // The name of the member.
+    std::string name;
+    // The file offset of the member.
+    off_t off;
+    // The file offset of a nested archive member.
+    off_t nested_off;
+    // The size of the member.
+    off_t size;
+  };
+
+  const_iterator(Archive* archive, off_t off)
+    : archive_(archive), off_(off)
+  { this->read_next_header(); }
+
+  const Header&
+  operator*() const
+  { return this->header_; }
+
+  const Header*
+  operator->() const
+  { return &this->header_; }
+
+  const_iterator&
+  operator++()
+  {
+    if (this->off_ == this->archive_->file().filesize())
+      return *this;
+    this->off_ += sizeof(Archive_header);
+    if (!this->archive_->is_thin_archive())
+      this->off_ += this->header_.size;
+    if ((this->off_ & 1) != 0)
+      ++this->off_;
+    this->read_next_header();
+    return *this;
+  }
+
+  const_iterator
+  operator++(int)
+  {
+    const_iterator ret = *this;
+    ++*this;
+    return ret;
+  }
+
+  bool
+  operator==(const const_iterator p) const
+  { return this->off_ == p->off; }
+
+  bool
+  operator!=(const const_iterator p) const
+  { return this->off_ != p->off; }
+
+ private:
+  void
+  read_next_header();
+
+  // The underlying archive.
+  Archive* archive_;
+  // The current offset in the file.
+  off_t off_;
+  // The current archive header.
+  Header header_;
+};
+
+// Read the next archive header.
+
+void
+Archive::const_iterator::read_next_header()
+{
+  off_t filesize = this->archive_->file().filesize();
+  while (true)
+    {
+      if (filesize - this->off_ < static_cast<off_t>(sizeof(Archive_header)))
+	{
+	  if (filesize != this->off_)
+	    {
+	      gold_error(_("%s: short archive header at %zu"),
+			 this->archive_->filename().c_str(),
+			 static_cast<size_t>(this->off_));
+	      this->off_ = filesize;
+	    }
+	  this->header_.off = filesize;
+	  return;
+	}
+
+      unsigned char buf[sizeof(Archive_header)];
+      this->archive_->file().read(this->off_, sizeof(Archive_header), buf);
+
+      const Archive_header* hdr = reinterpret_cast<const Archive_header*>(buf);
+      this->header_.size =
+	this->archive_->interpret_header(hdr, this->off_, &this->header_.name,
+					 &this->header_.nested_off);
+      this->header_.off = this->off_;
+
+      // Skip special members.
+      if (!this->header_.name.empty() && this->header_.name != "/")
+	return;
+
+      this->off_ += sizeof(Archive_header) + this->header_.size;
+      if ((this->off_ & 1) != 0)
+	++this->off_;
+    }
+}
+
+// Initial iterator.
+
+Archive::const_iterator
+Archive::begin()
+{
+  return Archive::const_iterator(this, sarmag);
+}
+
+// Final iterator.
+
+Archive::const_iterator
+Archive::end()
+{
+  return Archive::const_iterator(this, this->input_file_->file().filesize());
+}
+
+// Get the file and offset for an archive member, which may be an
+// external member of a thin archive.  Set *INPUT_FILE to the
+// file containing the actual member, *MEMOFF to the offset
+// within that file (0 if not a nested archive), and *MEMBER_NAME
+// to the name of the archive member.  Return TRUE on success.
+
+bool
+Archive::get_file_and_offset(off_t off, Input_file** input_file, off_t* memoff,
+                             off_t* memsize, std::string* member_name)
+{
+  off_t nested_off;
+
+  *memsize = this->read_header(off, false, member_name, &nested_off);
+
+  *input_file = this->input_file_;
+  *memoff = off + static_cast<off_t>(sizeof(Archive_header));
+
+  if (!this->is_thin_archive_)
+    return true;
+
+  // Adjust a relative pathname so that it is relative
+  // to the directory containing the archive.
+  if (!IS_ABSOLUTE_PATH(member_name->c_str()))
+    {
+      const char* arch_path = this->filename().c_str();
+      const char* basename = lbasename(arch_path);
+      if (basename > arch_path)
+        member_name->replace(0, 0,
+                             this->filename().substr(0, basename - arch_path));
+    }
+
+  if (nested_off > 0)
+    {
+      // This is a member of a nested archive.  Open the containing
+      // archive if we don't already have it open, then do a recursive
+      // call to include the member from that archive.
+      Archive* arch;
+      Nested_archive_table::const_iterator p =
+        this->nested_archives_.find(*member_name);
+      if (p != this->nested_archives_.end())
+        arch = p->second;
+      else
+        {
+          Input_file_argument* input_file_arg =
+            new Input_file_argument(member_name->c_str(), false, "", false,
+                                    parameters->options());
+          *input_file = new Input_file(input_file_arg);
+	  int dummy = 0;
+          if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy))
+            return false;
+          arch = new Archive(*member_name, *input_file, false, this->dirpath_,
+                             this->task_);
+          arch->setup();
+          std::pair<Nested_archive_table::iterator, bool> ins =
+            this->nested_archives_.insert(std::make_pair(*member_name, arch));
+          gold_assert(ins.second);
+        }
+      return arch->get_file_and_offset(nested_off, input_file, memoff,
+				       memsize, member_name);
+    }
+
+  // This is an external member of a thin archive.  Open the
+  // file as a regular relocatable object file.
+  Input_file_argument* input_file_arg =
+      new Input_file_argument(member_name->c_str(), false, "", false,
+                              this->input_file_->options());
+  *input_file = new Input_file(input_file_arg);
+  int dummy = 0;
+  if (!(*input_file)->open(*this->dirpath_, this->task_, &dummy))
+    return false;
+
+  *memoff = 0;
+  *memsize = (*input_file)->file().filesize();
+  return true;
+}
+
+// Return an ELF object for the member at offset OFF.  If the ELF
+// object has an unsupported target type, set *PUNCONFIGURED to true
+// and return NULL.
+
+Object*
+Archive::get_elf_object_for_member(off_t off, bool* punconfigured)
+{
+  *punconfigured = false;
+
+  Input_file* input_file;
+  off_t memoff;
+  off_t memsize;
+  std::string member_name;
+  if (!this->get_file_and_offset(off, &input_file, &memoff, &memsize,
+				 &member_name))
+    return NULL;
+
+  if (parameters->options().has_plugins())
+    {
+      Object* obj = parameters->options().plugins()->claim_file(input_file,
+                                                                memoff,
+                                                                memsize);
+      if (obj != NULL)
+        {
+          // The input file was claimed by a plugin, and its symbols
+          // have been provided by the plugin.
+          return obj;
+        }
+    }
+
+  off_t filesize = input_file->file().filesize();
+  int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
+  if (filesize - memoff < read_size)
+    read_size = filesize - memoff;
+
+  if (read_size < 4)
+    {
+      gold_error(_("%s: member at %zu is not an ELF object"),
+		 this->name().c_str(), static_cast<size_t>(off));
+      return NULL;
+    }
+
+  const unsigned char* ehdr = input_file->file().get_view(memoff, 0, read_size,
+							  true, false);
+
+  static unsigned char elfmagic[4] =
+    {
+      elfcpp::ELFMAG0, elfcpp::ELFMAG1,
+      elfcpp::ELFMAG2, elfcpp::ELFMAG3
+    };
+  if (memcmp(ehdr, elfmagic, 4) != 0)
+    {
+      gold_error(_("%s: member at %zu is not an ELF object"),
+		 this->name().c_str(), static_cast<size_t>(off));
+      return NULL;
+    }
+
+  return make_elf_object((std::string(this->input_file_->filename())
+			  + "(" + member_name + ")"),
+			 input_file, memoff, ehdr, read_size,
+			 punconfigured);
+}
+
+// Read the symbols from all the archive members in the link.
+
+void
+Archive::read_all_symbols()
+{
+  for (Archive::const_iterator p = this->begin();
+       p != this->end();
+       ++p)
+    this->read_symbols(p->off);
+}
+
+// Read the symbols from an archive member in the link.  OFF is the file
+// offset of the member header.
+
+void
+Archive::read_symbols(off_t off)
+{
+  bool dummy;
+  Object* obj = this->get_elf_object_for_member(off, &dummy);
+
+  if (obj == NULL)
+    return;
+
+  Read_symbols_data* sd = new Read_symbols_data;
+  obj->read_symbols(sd);
+  Archive_member member(obj, sd);
+  this->members_[off] = member;
+}
+
 // Select members from the archive and add them to the link.  We walk
 // through the elements in the archive map, and look each one up in
 // the symbol table.  If it exists as a strong undefined symbol, we
 // pull in the corresponding element.  We have to do this in a loop,
 // since pulling in one element may create new undefined symbols which
-// may be satisfied by other objects in the archive.
+// may be satisfied by other objects in the archive.  Return true in
+// the normal case, false if the first member we tried to add from
+// this archive had an incompatible target.
 
-void
+bool
 Archive::add_symbols(Symbol_table* symtab, Layout* layout,
-		     Input_objects* input_objects)
+		     Input_objects* input_objects, Mapfile* mapfile)
 {
-  if (this->input_file_->options().include_whole_archive())
-    return this->include_all_members(symtab, layout, input_objects);
+  ++Archive::total_archives;
+
+  if (this->input_file_->options().whole_archive())
+    return this->include_all_members(symtab, layout, input_objects,
+				     mapfile);
+
+  Archive::total_members += this->num_members_;
+
+  input_objects->archive_start(this);
 
   const size_t armap_size = this->armap_.size();
 
@@ -272,6 +635,8 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout,
   // Track which symbols in the symbol table we've already found to be
   // defined.
 
+  char* tmpbuf = NULL;
+  size_t tmpbuflen = 0;
   bool added_new_object;
   do
     {
@@ -295,9 +660,46 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout,
 
 	  const char* sym_name = (this->armap_names_.data()
 				  + this->armap_[i].name_offset);
-	  Symbol* sym = symtab->lookup(sym_name);
+
+	  // In an object file, and therefore in an archive map, an
+	  // '@' in the name separates the symbol name from the
+	  // version name.  If there are two '@' characters, this is
+	  // the default version.
+	  const char* ver = strchr(sym_name, '@');
+	  bool def = false;
+	  if (ver != NULL)
+	    {
+	      size_t symlen = ver - sym_name;
+	      if (symlen + 1 > tmpbuflen)
+		{
+		  tmpbuf = static_cast<char*>(realloc(tmpbuf, symlen + 1));
+		  tmpbuflen = symlen + 1;
+		}
+	      memcpy(tmpbuf, sym_name, symlen);
+	      tmpbuf[symlen] = '\0';
+	      sym_name = tmpbuf;
+
+	      ++ver;
+	      if (*ver == '@')
+		{
+		  ++ver;
+		  def = true;
+		}
+	    }
+
+	  Symbol* sym = symtab->lookup(sym_name, ver);
+	  if (def
+	      && (sym == NULL
+		  || !sym->is_undefined()
+		  || sym->binding() == elfcpp::STB_WEAK))
+	    sym = symtab->lookup(sym_name, NULL);
+
 	  if (sym == NULL)
-	    continue;
+	    {
+	      // Check whether the symbol was named in a -u option.
+	      if (!parameters->options().is_undefined(sym_name))
+		continue;
+	    }
 	  else if (!sym->is_undefined())
 	    {
               this->armap_checked_[i] = true;
@@ -310,115 +712,183 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout,
 	  last_seen_offset = this->armap_[i].file_offset;
 	  this->seen_offsets_.insert(last_seen_offset);
           this->armap_checked_[i] = true;
-	  this->include_member(symtab, layout, input_objects,
-			       last_seen_offset);
+
+	  std::string why;
+	  if (sym == NULL)
+	    {
+	      why = "-u ";
+	      why += sym_name;
+	    }
+	  if (!this->include_member(symtab, layout, input_objects,
+				    last_seen_offset, mapfile, sym,
+				    why.c_str()))
+	    {
+	      if (tmpbuf != NULL)
+		free(tmpbuf);
+	      return false;
+	    }
+
 	  added_new_object = true;
 	}
     }
   while (added_new_object);
+
+  if (tmpbuf != NULL)
+    free(tmpbuf);
+
+  input_objects->archive_stop(this);
+
+  return true;
 }
 
 // Include all the archive members in the link.  This is for --whole-archive.
 
-void
+bool
 Archive::include_all_members(Symbol_table* symtab, Layout* layout,
-                             Input_objects* input_objects)
+                             Input_objects* input_objects, Mapfile* mapfile)
 {
-  off_t off = sarmag;
-  off_t filesize = this->input_file_->file().filesize();
-  while (true)
-    {
-      if (filesize - off < static_cast<off_t>(sizeof(Archive_header)))
-        {
-          if (filesize != off)
-	    gold_error(_("%s: short archive header at %zu"),
-		       this->name().c_str(), static_cast<size_t>(off));
-          break;
-        }
-
-      unsigned char hdr_buf[sizeof(Archive_header)];
-      this->input_file_->file().read(off, sizeof(Archive_header), hdr_buf);
+  input_objects->archive_start(this);
 
-      const Archive_header* hdr =
-	reinterpret_cast<const Archive_header*>(hdr_buf);
-      std::string name;
-      off_t size = this->interpret_header(hdr, off, &name);
-      if (name.empty())
+  if (this->members_.size() > 0)
+    {
+      std::map<off_t, Archive_member>::const_iterator p;
+      for (p = this->members_.begin();
+           p != this->members_.end();
+           ++p)
         {
-          // Symbol table.
+          if (!this->include_member(symtab, layout, input_objects, p->first,
+				    mapfile, NULL, "--whole-archive"))
+	    return false;
+          ++Archive::total_members;
         }
-      else if (name == "/")
+    }
+  else
+    {
+      for (Archive::const_iterator p = this->begin();
+           p != this->end();
+           ++p)
         {
-          // Extended name table.
+          if (!this->include_member(symtab, layout, input_objects, p->off,
+				    mapfile, NULL, "--whole-archive"))
+	    return false;
+          ++Archive::total_members;
         }
-      else
-        this->include_member(symtab, layout, input_objects, off);
-
-      off += sizeof(Archive_header) + size;
-      if ((off & 1) != 0)
-        ++off;
     }
+
+  input_objects->archive_stop(this);
+
+  return true;
+}
+
+// Return the number of members in the archive.  This is only used for
+// reports.
+
+size_t
+Archive::count_members()
+{
+  size_t ret = 0;
+  for (Archive::const_iterator p = this->begin();
+       p != this->end();
+       ++p)
+    ++ret;
+  return ret;
 }
 
 // Include an archive member in the link.  OFF is the file offset of
-// the member header.
+// the member header.  WHY is the reason we are including this member.
+// Return true if we added the member or if we had an error, return
+// false if this was the first member we tried to add from this
+// archive and it had an incompatible format.
 
-void
+bool
 Archive::include_member(Symbol_table* symtab, Layout* layout,
-			Input_objects* input_objects, off_t off)
+			Input_objects* input_objects, off_t off,
+			Mapfile* mapfile, Symbol* sym, const char* why)
 {
-  std::string n;
-  this->read_header(off, &n);
+  ++Archive::total_members_loaded;
 
-  const off_t memoff = off + static_cast<off_t>(sizeof(Archive_header));
+  std::map<off_t, Archive_member>::const_iterator p = this->members_.find(off);
+  if (p != this->members_.end())
+    {
+      Object *obj = p->second.obj_;
 
-  // Read enough of the file to pick up the entire ELF header.
-  unsigned char ehdr_buf[elfcpp::Elf_sizes<64>::ehdr_size];
+      if (!this->included_member_
+	  && this->searched_for()
+	  && !parameters->is_compatible_target(obj->target()))
+	return false;
 
-  off_t filesize = this->input_file_->file().filesize();
-  int read_size = elfcpp::Elf_sizes<64>::ehdr_size;
-  if (filesize - memoff < read_size)
-    read_size = filesize - memoff;
+      Read_symbols_data *sd = p->second.sd_;
+      if (mapfile != NULL)
+        mapfile->report_include_archive_member(obj->name(), sym, why);
+      if (input_objects->add_object(obj))
+        {
+          obj->layout(symtab, layout, sd);
+          obj->add_symbols(symtab, sd, layout);
+	  this->included_member_ = true;
+        }
+      delete sd;
+      return true;
+    }
 
-  if (read_size < 4)
+  bool unconfigured;
+  Object* obj = this->get_elf_object_for_member(off, &unconfigured);
+
+  if (!this->included_member_
+      && this->searched_for()
+      && (obj == NULL
+	  ? unconfigured
+	  : !parameters->is_compatible_target(obj->target())))
     {
-      gold_error(_("%s: member at %zu is not an ELF object"),
-		 this->name().c_str(), static_cast<size_t>(off));
-      return;
+      if (obj != NULL)
+	delete obj;
+      return false;
     }
 
-  this->input_file_->file().read(memoff, read_size, ehdr_buf);
+  if (obj == NULL)
+    return true;
 
-  static unsigned char elfmagic[4] =
-    {
-      elfcpp::ELFMAG0, elfcpp::ELFMAG1,
-      elfcpp::ELFMAG2, elfcpp::ELFMAG3
-    };
-  if (memcmp(ehdr_buf, elfmagic, 4) != 0)
+  if (mapfile != NULL)
+    mapfile->report_include_archive_member(obj->name(), sym, why);
+
+  Pluginobj* pluginobj = obj->pluginobj();
+  if (pluginobj != NULL)
     {
-      gold_error(_("%s: member at %zu is not an ELF object"),
-		 this->name().c_str(), static_cast<size_t>(off));
-      return;
+      pluginobj->add_symbols(symtab, NULL, layout);
+      this->included_member_ = true;
+      return true;
     }
 
-  Object* obj = make_elf_object((std::string(this->input_file_->filename())
-				 + "(" + n + ")"),
-				this->input_file_, memoff, ehdr_buf,
-				read_size);
-
-  if (input_objects->add_object(obj))
+  if (!input_objects->add_object(obj))
+    delete obj;
+  else
     {
       Read_symbols_data sd;
       obj->read_symbols(&sd);
       obj->layout(symtab, layout, &sd);
-      obj->add_symbols(symtab, &sd);
-    }
-  else
-    {
-      // FIXME: We need to close the descriptor here.
-      delete obj;
+      obj->add_symbols(symtab, &sd, layout);
+
+      // If this is an external member of a thin archive, unlock the file
+      // for the next task.
+      if (obj->offset() == 0)
+        obj->unlock(this->task_);
+
+      this->included_member_ = true;
     }
 
+  return true;
+}
+
+// Print statistical information to stderr.  This is used for --stats.
+
+void
+Archive::print_stats()
+{
+  fprintf(stderr, _("%s: archive libraries: %u\n"),
+          program_name, Archive::total_archives);
+  fprintf(stderr, _("%s: total archive members: %u\n"),
+          program_name, Archive::total_members);
+  fprintf(stderr, _("%s: loaded archive members: %u\n"),
+          program_name, Archive::total_members_loaded);
 }
 
 // Add_archive_symbols methods.
@@ -434,40 +904,45 @@ Add_archive_symbols::~Add_archive_symbols()
 // Return whether we can add the archive symbols.  We are blocked by
 // this_blocker_.  We block next_blocker_.  We also lock the file.
 
-Task::Is_runnable_type
-Add_archive_symbols::is_runnable(Workqueue*)
+Task_token*
+Add_archive_symbols::is_runnable()
 {
   if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked())
-    return IS_BLOCKED;
-  return IS_RUNNABLE;
+    return this->this_blocker_;
+  return NULL;
 }
 
-class Add_archive_symbols::Add_archive_symbols_locker : public Task_locker
-{
- public:
-  Add_archive_symbols_locker(Task_token& token, Workqueue* workqueue,
-			     File_read& file)
-    : blocker_(token, workqueue), filelock_(file)
-  { }
-
- private:
-  Task_locker_block blocker_;
-  Task_locker_obj<File_read> filelock_;
-};
-
-Task_locker*
-Add_archive_symbols::locks(Workqueue* workqueue)
+void
+Add_archive_symbols::locks(Task_locker* tl)
 {
-  return new Add_archive_symbols_locker(*this->next_blocker_,
-					workqueue,
-					this->archive_->file());
+  tl->add(this, this->next_blocker_);
+  tl->add(this, this->archive_->token());
 }
 
 void
-Add_archive_symbols::run(Workqueue*)
+Add_archive_symbols::run(Workqueue* workqueue)
 {
-  this->archive_->add_symbols(this->symtab_, this->layout_,
-			      this->input_objects_);
+  bool added = this->archive_->add_symbols(this->symtab_, this->layout_,
+					   this->input_objects_,
+					   this->mapfile_);
+  this->archive_->unlock_nested_archives();
+
+  this->archive_->release();
+  this->archive_->clear_uncached_views();
+
+  if (!added)
+    {
+      // This archive holds object files which are incompatible with
+      // our output file.
+      Read_symbols::incompatible_warning(this->input_argument_,
+					 this->archive_->input_file());
+      Read_symbols::requeue(workqueue, this->input_objects_, this->symtab_,
+			    this->layout_, this->dirpath_, this->dirindex_,
+			    this->mapfile_, this->input_argument_,
+			    this->input_group_, this->next_blocker_);
+      delete this->archive_;
+      return;
+    }
 
   if (this->input_group_ != NULL)
     this->input_group_->add_archive(this->archive_);
@@ -475,6 +950,7 @@ Add_archive_symbols::run(Workqueue*)
     {
       // We no longer need to know about this archive.
       delete this->archive_;
+      this->archive_ = NULL;
     }
 }