[elf2] Add basic archive file support.

[• rafael]

The patch is not git-clang-format clean

building I get these warnings:

/home/espindola/llvm/llvm/tools/lld/ELF/Driver.cpp:83:11: warning:
enumeration value 'ArchiveKind' not handled in switch [-Wswitch]

switch (FirstObj.kind()) {
        ^

1 warning generated.
[6/8] Building CXX object tools/lld/ELF/CMakeFiles/lldELF2.dir/SymbolTable.cpp.o
/home/espindola/llvm/llvm/tools/lld/ELF/SymbolTable.cpp:46:13:
warning: enumeration value 'ArchiveKind' not handled in switch
[-Wswitch]

switch (File->kind()) {
        ^

/home/espindola/llvm/llvm/tools/lld/ELF/SymbolTable.cpp:64:13:
warning: enumeration value 'ArchiveKind' not handled in switch
[-Wswitch]

switch (File->kind()) {
        ^

2 warnings generated.
[6/8] Building CXX object tools/lld/ELF/CMakeFiles/lldELF2.dir/Writer.cpp.o
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]

switch (Body->kind()) {
        ^

/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]

[• rafael]

The test seems to do a bit more than what is needed:

• Why do you need to disassemble?
• _start is already undefined at the start of the link, you shouldn't

need to introduce a new undefined reference to it just to fetch the
member.

[• rafael]

ELF/InputFiles.cpp

15

Not used.

[• rafael]

Why use a llvm::MallocAllocator? It seems better to not have an
allocator and use a smart pointer or use a BumpPtrAllocator.

Given that the allocator is used for exactly one allocation per file,
wouldn't it be the same to replace

std::vector<Lazy *> LazySymbols;
llvm::MallocAllocator Alloc;

With

std::vector<Lazy> LazySymbols

?

[• rafael]

The warnings with the file kind were really an issue with the existing
code. I have fixed that and rebased your patch. I also include the
change to use std::vector<Lazy> LazySymbols;.

The remaining warnings look like new issues:

/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]

switch (Body->kind()) {
        ^

/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch]
/home/espindola/llvm/llvm/tools/lld/ELF/Writer.cpp:317:13: warning:
enumeration value 'LazyKind' not handled in switch [-Wswitch

Please fix them and upload a new patch.

• t.diff13 KBDownload

[• rafael]

Another thing: I see that you moved createFile out of Driver.cpp.

That is not what COFF does and I think I agree with COFF on this one.
The files we will support at the top level are not the ones we support
inside a .a. It is better to error early if we are given a .so or a
linker script inside an archive.

Cheers,
Rafael

[• rafael]

I also noticed that we can statically know if getSymbols is available.

Attached.

• t.diff13 KBDownload

[Bigcheese]

Address comments.

[• rafael]

+ case SymbolBody::LazyKind:
+ assert("Lazy symbols shouldn't get here.");

You want an llvm_unreachable, no? That assert never fails.

[• rafael]

+ auto ItOrErr = Sym->getMember();

Non obvious type. Please don't use auto.

Can you extend the test to cover us not adding a member twice? Should
be as simple as adding a second undefined symbol defined by the same
member.

+ llvm::DenseMap<uint64_t, bool> Seen;

Can this be a DenseSet?

+// Returns a buffer pointing to a member file containing a given symbol.
+MemoryBufferRef ArchiveFile::getMember(const Archive::Symbol *Sym) {

The comment is effectively duplicated from the header.

[• rafael]

A few more nits:

+ if (Existing->isDefined() || isa<Lazy>(Existing))
+ return;
+ Sym->Body = New;
+ if (Existing->isUndefined())
+ addMemberFile(New);

The second if should be an assert. On ELF we have

bool isDefined() const { return !isUndefined(); }

+ getMember returns an empty buffer if the member was already
+ read from the library.
+ if (!File)
+ return;

Returns nullptr, no?

+static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+ // FIXME: duplicated

Please fix it :-)
We need a basic function that only handles objects. It is used in here
and Driver.cpp uses it if not given an archive or shared library.

So only nits. LGTM with all of them fixed.

Cheers,
Rafael

ELF/Driver.cpp

if (IsShared)
     return make_unique<SharedFile<ELFT>>(MB);
   return make_unique<ObjectFile<ELFT>>(MB);
 }
 
 static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
   using namespace llvm::sys::fs;
   file_magic Magic = identify_magic(MB.getBuffer());
 
+  if (Magic == file_magic::archive)
+    return llvm::make_unique<ArchiveFile>(MB);
+
   std::pair<unsigned char, unsigned char> Type =
       object::getElfArchType(MB.getBuffer());
   if (Type.second != ELF::ELFDATA2LSB && Type.second != ELF::ELFDATA2MSB)
     error("Invalid data encoding");
 
   bool IsShared = Magic == file_magic::elf_shared_object;
   if (Type.first == ELF::ELFCLASS32) {
     if (Type.second == ELF::ELFDATA2LSB)

ELF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_FILES_H
 #define LLD_ELF_INPUT_FILES_H
 
 #include "Chunks.h"
 #include "Symbols.h"
 
 #include "lld/Core/LLVM.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
+
+using llvm::object::Archive;
+
+class Lazy;
 class SymbolBody;
 
 // The root class of input files.
 class InputFile {
 public:
-  enum Kind { ObjectKind, SharedKind };
+  enum Kind { ObjectKind, SharedKind, ArchiveKind };
   Kind kind() const { return FileKind; }
   virtual ~InputFile() {}
 
   // Reads a file (constructors don't do that).
   virtual void parse() = 0;
 
   StringRef getName() const { return MB.getBufferIdentifier(); }
 
private:
 
   // List of all chunks defined by this file.
   std::vector<SectionChunk<ELFT> *> Chunks;
 
   const Elf_Shdr *Symtab = nullptr;
   ArrayRef<Elf_Word> SymtabSHNDX;
 };
 
+class ArchiveFile : public InputFile {
+public:
+  explicit ArchiveFile(MemoryBufferRef M) : InputFile(ArchiveKind, M) {}
+  static bool classof(const InputFile *F) { return F->kind() == ArchiveKind; }
+  void parse() override;
+
+  // Returns a memory buffer for a given symbol. An empty memory buffer
+  // is returned if we have already returned the same memory buffer.
+  // (So that we don't instantiate same members more than once.)
+  MemoryBufferRef getMember(const Archive::Symbol *Sym);
+
+  llvm::MutableArrayRef<Lazy> getLazySymbols() { return LazySymbols; }
+
+private:
+  std::unique_ptr<Archive> File;
+  std::vector<Lazy> LazySymbols;
+  llvm::DenseMap<uint64_t, bool> Seen;
+};
+
 // .so file.
 class SharedFileBase : public ELFFileBase {
 public:
   explicit SharedFileBase(ELFKind EKind, MemoryBufferRef M)
       : ELFFileBase(SharedKind, EKind, M) {}
   static bool classof(const InputFile *F) { return F->kind() == SharedKind; }
 };
 

ELF/InputFiles.cpp

 //===- InputFiles.cpp -----------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InputFiles.h"
 #include "Chunks.h"
 #include "Error.h"
 #include "Symbols.h"
 #include "llvm/ADT/STLExtras.h"
 
+using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf2;
 
 template <class ELFT> static uint16_t getEMachine(const ELFFileBase &B) {
   bool IsShared = isa<SharedFileBase>(B);
SymbolBody *elf2::ObjectFile<ELFT>::createSymbolBody(StringRef StringTable,
   default:
     error("unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
     return new (Alloc) DefinedRegular<ELFT>(Name, *Sym, *Chunks[SecIndex]);
   }
 }
 
+void ArchiveFile::parse() {
+  auto ArchiveOrErr = Archive::create(MB);
+  error(ArchiveOrErr, "Failed to parse archive");
+  File = std::move(*ArchiveOrErr);
+
+  // Allocate a buffer for Lazy objects.
+  size_t NumSyms = File->getNumberOfSymbols();
+  LazySymbols.reserve(NumSyms);
+
+  // Read the symbol table to construct Lazy objects.
+  for (const Archive::Symbol &Sym : File->symbols())
+    LazySymbols.emplace_back(this, Sym);
+}
+
+// Returns a buffer pointing to a member file containing a given symbol.
+MemoryBufferRef ArchiveFile::getMember(const Archive::Symbol *Sym) {
+  auto ItOrErr = Sym->getMember();
+  error(ItOrErr,
+        Twine("Could not get the member for symbol ") + Sym->getName());
+  Archive::child_iterator It = *ItOrErr;
+
+  // Return an empty buffer if we have already returned the same buffer.
+  bool &SeenMember = Seen[It->getChildOffset()];
+  if (SeenMember) {
+    return MemoryBufferRef();
+  }
+  SeenMember = true;
+  ErrorOr<MemoryBufferRef> Ret = It->getMemoryBufferRef();
+  error(Ret, Twine("Could not get the buffer for the member defining symbol ") +
+                 Sym->getName());
+  return *Ret;
+}
+
 template <class ELFT> void SharedFile<ELFT>::parse() { this->openELF(MB); }
 
 namespace lld {
 namespace elf2 {
 template class elf2::ObjectFile<llvm::object::ELF32LE>;
 template class elf2::ObjectFile<llvm::object::ELF32BE>;
 template class elf2::ObjectFile<llvm::object::ELF64LE>;
 template class elf2::ObjectFile<llvm::object::ELF64BE>;
 
 template class elf2::SharedFile<llvm::object::ELF32LE>;
 template class elf2::SharedFile<llvm::object::ELF32BE>;
 template class elf2::SharedFile<llvm::object::ELF64LE>;
 template class elf2::SharedFile<llvm::object::ELF64BE>;
 }
 }

ELF/SymbolTable.h

const llvm::DenseMap<StringRef, Symbol *> &getSymbols() const {
     return Symtab;
   }
 
   const std::vector<std::unique_ptr<ObjectFileBase>> &getObjectFiles() const {
     return ObjectFiles;
   }
 
 private:
+  Symbol *insert(SymbolBody *New);
   void addELFFile(ELFFileBase *File);
+  void addLazy(Lazy *New);
+  void addMemberFile(Lazy *Body);
 
   template <class ELFT> void init();
   template <class ELFT> void resolve(SymbolBody *Body);
 
+  std::vector<std::unique_ptr<ArchiveFile>> ArchiveFiles;
+
   llvm::DenseMap<StringRef, Symbol *> Symtab;
   llvm::BumpPtrAllocator Alloc;
 
   // The writer needs to infer the machine type from the object files.
   std::vector<std::unique_ptr<ObjectFileBase>> ObjectFiles;
 
   std::vector<std::unique_ptr<SharedFileBase>> SharedFiles;
 };
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/SymbolTable.cpp

 using namespace lld::elf2;
 
 SymbolTable::SymbolTable() {
 }
 
 void SymbolTable::addFile(std::unique_ptr<InputFile> File) {
   File->parse();
   InputFile *FileP = File.release();
-  auto *P = cast<ELFFileBase>(FileP);
-  addELFFile(P);
+  if (auto *AF = dyn_cast<ArchiveFile>(FileP)) {
+    ArchiveFiles.emplace_back(AF);
+    for (Lazy &Sym : AF->getLazySymbols())
+      addLazy(&Sym);
+    return;
+  }
+  addELFFile(cast<ELFFileBase>(FileP));
 }
 
 template <class ELFT> void SymbolTable::init() {
   resolve<ELFT>(new (Alloc)
                     Undefined<ELFT>("_start", Undefined<ELFT>::Synthetic));
 }
 
 void SymbolTable::addELFFile(ELFFileBase *File) {
for (auto &I : Symtab) {
     if (Body->isStrongUndefined())
       error(Twine("undefined symbol: ") + Body->getName());
   }
 }
 
 // This function resolves conflicts if there's an existing symbol with
 // the same name. Decisions are made based on symbol type.
 template <class ELFT> void SymbolTable::resolve(SymbolBody *New) {
+  Symbol *Sym = insert(New);
+  if (Sym->Body == New)
+    return;
+
+  SymbolBody *Existing = Sym->Body;
+
+  if (Lazy *L = dyn_cast<Lazy>(Existing)) {
+    if (New->isUndefined()) {
+      addMemberFile(L);
+      return;
+    }
+
+    // Found a definition for something also in an archive. Ignore the archive
+    // definition.
+    Sym->Body = New;
+    return;
+  }
+
+  // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
+  // equivalent (conflicting), or more preferable, respectively.
+  int comp = Existing->compare<ELFT>(New);
+  if (comp < 0)
+    Sym->Body = New;
+  if (comp == 0)
+    error(Twine("duplicate symbol: ") + Sym->Body->getName());
+}
+
+Symbol *SymbolTable::insert(SymbolBody *New) {
   // Find an existing Symbol or create and insert a new one.
   StringRef Name = New->getName();
   Symbol *&Sym = Symtab[Name];
   if (!Sym) {
     Sym = new (Alloc) Symbol(New);
     New->setBackref(Sym);
-    return;
+    return Sym;
   }
   New->setBackref(Sym);
+  return Sym;
+}
 
-  // compare() returns -1, 0, or 1 if the lhs symbol is less preferable,
-  // equivalent (conflicting), or more preferable, respectively.
+void SymbolTable::addLazy(Lazy *New) {
+  Symbol *Sym = insert(New);
+  if (Sym->Body == New)
+    return;
   SymbolBody *Existing = Sym->Body;
-  int comp = Existing->compare<ELFT>(New);
-  if (comp < 0)
-    Sym->Body = New;
-  if (comp == 0)
-    error(Twine("duplicate symbol: ") + Name);
+  if (Existing->isDefined() || isa<Lazy>(Existing))
+    return;
+  if (Existing->isUndefined())
+    addMemberFile(New);
+}
+
+void SymbolTable::addMemberFile(Lazy *Body) {
+  std::unique_ptr<InputFile> File = Body->getMember();
+
+  // getMember returns an empty buffer if the member was already
+  // read from the library.
+  if (!File)
+    return;
+
+  addFile(std::move(File));
 }

ELF/Symbols.h

 //===- Symbols.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOLS_H
 #define LLD_ELF_SYMBOLS_H
 
 #include "Chunks.h"
 
 #include "lld/Core/LLVM.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
 namespace elf2 {
 
-using llvm::object::ELFFile;
-
+class ArchiveFile;
 class Chunk;
 class InputFile;
 class SymbolBody;
 template <class ELFT> class ObjectFile;
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
 // The resolver updates SymbolBody pointers as it resolves symbols.
 struct Symbol {
   explicit Symbol(SymbolBody *P) : Body(P) {}
   SymbolBody *Body;
 };
 
 // The base class for real symbol classes.
 class SymbolBody {
 public:
   enum Kind {
     DefinedFirst = 0,
     DefinedRegularKind = 0,
     DefinedAbsoluteKind = 1,
     DefinedCommonKind = 2,
     DefinedLast = 2,
-    UndefinedKind = 3
+    UndefinedKind = 3,
+    LazyKind = 4,
   };
 
   Kind kind() const { return static_cast<Kind>(SymbolKind); }
 
   bool isWeak() const { return IsWeak; }
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
   bool isDefined() const { return !isUndefined(); }
   bool isStrongUndefined() const { return !IsWeak && isUndefined(); }
   bool isCommon() const { return SymbolKind == DefinedCommonKind; }
+  bool isLazy() const { return SymbolKind == LazyKind; }
 
   // Returns the symbol name.
   StringRef getName() const { return Name; }
 
   uint8_t getMostConstrainingVisibility() const {
     return MostConstrainingVisibility;
   }
 
public:
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::UndefinedKind;
   }
 };
 
 template <class ELFT>
 typename Undefined<ELFT>::Elf_Sym Undefined<ELFT>::Synthetic;
 
+// This class represents a symbol defined in an archive file. It is
+// created from an archive file header, and it knows how to load an
+// object file from an archive to replace itself with a defined
+// symbol. If the resolver finds both Undefined and Lazy for
+// the same name, it will ask the Lazy to load a file.
+class Lazy : public SymbolBody {
+public:
+  Lazy(ArchiveFile *F, const llvm::object::Archive::Symbol S)
+      : SymbolBody(LazyKind, S.getName(), false, llvm::ELF::STV_DEFAULT),
+        File(F), Sym(S) {}
+
+  static bool classof(const SymbolBody *S) { return S->kind() == LazyKind; }
+
+  // Returns an object file for this symbol, or a nullptr if the file
+  // was already returned.
+  std::unique_ptr<InputFile> getMember();
+
+private:
+  ArchiveFile *File;
+  const llvm::object::Archive::Symbol Sym;
+};
+
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "Chunks.h"
 #include "Error.h"
 #include "InputFiles.h"
 
+#include "llvm/ADT/STLExtras.h"
+
+using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 static uint8_t getMinVisibility(uint8_t VA, uint8_t VB) {
   if (VA == STV_DEFAULT)
     return VB;
   if (VB == STV_DEFAULT)
     return VA;
   return std::min(VA, VB);
 }
 
 // Returns 1, 0 or -1 if this symbol should take precedence
 // over the Other, tie or lose, respectively.
 template <class ELFT> int SymbolBody::compare(SymbolBody *Other) {
+  assert(!isLazy() && !Other->isLazy());
   std::pair<bool, bool> L(isDefined(), !isWeak());
   std::pair<bool, bool> R(Other->isDefined(), !Other->isWeak());
 
   // Normalize
   if (L > R)
     return -Other->compare<ELFT>(this);
 
   uint8_t LV = getMostConstrainingVisibility();
if (L.first && L.second) {
     }
     if (Other->isCommon())
       return 1;
     return 0;
   }
   return 1;
 }
 
+static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+  // FIXME: duplicated
+  std::pair<unsigned char, unsigned char> Type = getElfArchType(MB.getBuffer());
+  if (Type.second != ELFDATA2LSB && Type.second != ELFDATA2MSB)
+    error("Invalid data encoding");
+
+  if (Type.first == ELFCLASS32) {
+    if (Type.second == ELFDATA2LSB)
+      return make_unique<ObjectFile<ELF32LE>>(MB);
+    return make_unique<ObjectFile<ELF32BE>>(MB);
+  }
+  if (Type.first == ELFCLASS64) {
+    if (Type.second == ELFDATA2LSB)
+      return make_unique<ObjectFile<ELF64LE>>(MB);
+    return make_unique<ObjectFile<ELF64BE>>(MB);
+  }
+  error("Invalid file class");
+}
+
+std::unique_ptr<InputFile> Lazy::getMember() {
+  MemoryBufferRef MBRef = File->getMember(&Sym);
+
+  // getMember returns an empty buffer if the member was already
+  // read from the library.
+  if (MBRef.getBuffer().empty())
+    return std::unique_ptr<InputFile>(nullptr);
+
+  return createFile(MBRef);
+}
+
 template int SymbolBody::compare<ELF32LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF32BE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64BE>(SymbolBody *Other);

ELF/Writer.cpp

 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   uint8_t *BufStart = Buf;
 
   Buf += sizeof(Elf_Sym);
   for (auto &P : Table.getSymbols()) {
     StringRef Name = P.first;
     Symbol *Sym = P.second;
     SymbolBody *Body = Sym->Body;
+    if (Body->isLazy())
+      continue;
     const Elf_Sym &InputSym = cast<ELFSymbolBody<ELFT>>(Body)->Sym;
 
     uint8_t V = Body->getMostConstrainingVisibility();
     if (V != STV_DEFAULT && V != STV_PROTECTED)
       continue;
 
     auto *ESym = reinterpret_cast<Elf_Sym *>(Buf);
     ESym->st_name = Builder.getOffset(Name);
 
     const SectionChunk<ELFT> *Section = nullptr;
     OutputSection<ELFT> *Out = nullptr;
 
     switch (Body->kind()) {
     case SymbolBody::DefinedRegularKind:
       Section = &cast<DefinedRegular<ELFT>>(Body)->Section;
       break;
     case SymbolBody::DefinedCommonKind:
       Out = BSSSec;
       break;
     case SymbolBody::UndefinedKind:
       assert(Body->isWeak() && "Should be defined by now");
     case SymbolBody::DefinedAbsoluteKind:
       break;
+    case SymbolBody::LazyKind:
+      assert("Lazy symbols shouldn't get here.");
     }
 
     uint8_t Type = InputSym.getType();
     uint8_t Binding = InputSym.getBinding();
     ESym->setBindingAndType(Binding, Type);
     ESym->st_size = InputSym.st_size;
     uint8_t Other = InputSym.st_other;
     ESym->st_other = (Other & ~0x3) | Body->getMostConstrainingVisibility();
template <class ELFT> void Writer<ELFT>::createSections() {
   OutputSection<ELFT> *BSSSec = SymTable.BSSSec;
   // FIXME: Try to avoid the extra walk over all global symbols.
   unsigned &NumVisible = SymTable.NumVisible;
   llvm::StringTableBuilder &Builder = StringTable.StrTabBuilder;
   std::vector<DefinedCommon<ELFT> *> CommonSymbols;
   for (auto &P : Symtab.getSymbols()) {
     StringRef Name = P.first;
     SymbolBody *Body = P.second->Body;
+    if (Body->isLazy())
+      continue;
     if (auto *C = dyn_cast<DefinedCommon<ELFT>>(Body))
       CommonSymbols.push_back(C);
     uint8_t V = Body->getMostConstrainingVisibility();
     if (V != STV_DEFAULT && V != STV_PROTECTED)
       continue;
     NumVisible++;
     Builder.add(Name);
   }

test/elf2/archive.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/basic.s -o %t2
+# RUN: llvm-ar rcs %tar %t2
+# RUN: lld -flavor gnu2 %t %tar -o %tout
+# RUN: llvm-nm %tout | FileCheck %s
+# REQUIRES: x86
+
+# Nothing here. Just needed for the linker to create a undefined _start symbol.
+
+# CHECK: T _start