Warn about archives with no symbol table

[• espindola]

Summary

Not having a symbol table is an indication of something missing in a build setup. We can handle it, but it is probably a good idea to inform the user.

This patch only warns once and only if a member is actually used in the build. This should avoid any false warnings with dead or empty archives.

[ruiu]

It seems it is only me who wants it to be silent, but if we can make it virtually zero-overhead, do you still want to warn on it?

Currently reading public symbols for LazyObject is serialized, but it should be easy to parallelize, so there's a large room for improvement.

ELF/Config.h

struct Configuration {
   std::vector<llvm::StringRef> AuxiliaryList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> SymbolOrderingFile;
   std::vector<llvm::StringRef> Undefined;
   std::vector<SymbolVersion> VersionScriptGlobals;
   std::vector<SymbolVersion> VersionScriptLocals;
   std::vector<uint8_t> BuildIdVector;
   bool AllowMultipleDefinition;
+  bool ArchiveWithoutSymbolsWarned = false;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool ColorDiagnostics = false;
   bool CompressDebugSections;
   bool DefineCommon;
   bool Demangle = true;
   bool DisableVerify;

ELF/Driver.cpp

std::unique_ptr<Archive> File =
         check(Archive::create(MBRef), Path + ": failed to parse archive");
 
     // If an archive file has no symbol table, it is likely that a user
     // is attempting LTO and using a default ar command that doesn't
     // understand the LLVM bitcode file. It is a pretty common error, so
     // we'll handle it as if it had a symbol table.
     if (!File->hasSymbolTable()) {
       for (MemoryBufferRef MB : getArchiveMembers(MBRef))
-        Files.push_back(make<LazyObjectFile>(MB));
+        Files.push_back(make<LazyObjectFile>(MB, MBRef.getBufferIdentifier()));
       return;
     }
 
     // Handle the regular case.
     Files.push_back(make<ArchiveFile>(std::move(File)));
     return;
   }
   case file_magic::elf_shared_object:
case file_magic::elf_shared_object:
     // If a file was specified by -lfoo, the directory part is not
     // significant, as a user did not specify it. This behavior is
     // compatible with GNU.
     Files.push_back(createSharedFile(
         MBRef, WithLOption ? sys::path::filename(Path) : Path));
     return;
   default:
     if (InLib)
-      Files.push_back(make<LazyObjectFile>(MBRef));
+      Files.push_back(make<LazyObjectFile>(MBRef, ""));
     else
       Files.push_back(createObjectFile(MBRef));
   }
 }
 
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   if (Optional<std::string> Path = searchLibrary(Name))

ELF/InputFiles.h

 // the file contains lazy symbols. The difference is that
 // LazyObjectFile wraps a single file instead of multiple files.
 //
 // This class is used for --start-lib and --end-lib options which
 // instruct the linker to link object files between them with the
 // archive file semantics.
 class LazyObjectFile : public InputFile {
 public:
-  explicit LazyObjectFile(MemoryBufferRef M) : InputFile(LazyObjectKind, M) {}
+  explicit LazyObjectFile(MemoryBufferRef M, StringRef ArchiveName)
+      : InputFile(LazyObjectKind, M) {
+    this->ArchiveName = ArchiveName;
+  }
 
   static bool classof(const InputFile *F) {
     return F->kind() == LazyObjectKind;
   }
 
   template <class ELFT> void parse();
   MemoryBufferRef getBuffer();
   InputFile *fetch();

ELF/InputFiles.cpp

MemoryBufferRef LazyObjectFile::getBuffer() {
   Seen = true;
   return MB;
 }
 
 InputFile *LazyObjectFile::fetch() {
   MemoryBufferRef MBRef = getBuffer();
   if (MBRef.getBuffer().empty())
     return nullptr;
+  if (!ArchiveName.empty() && !Config->ArchiveWithoutSymbolsWarned) {
+    warn("At least the " + ArchiveName +
+         " archive listed no symbols in its index. This can happen when "
+         "creating archives with a version of ar that does not understand the "
+         "object files in the archive. For example, if you are using LLVM "
+         "bitcode objects (such as created by -flto), you may need to use "
+         "llvm-ar or GNU ar with a plugin.");
+    // Set to true so that we print the message only once.
+    Config->ArchiveWithoutSymbolsWarned = true;
+  }
   return createObjectFile(MBRef);
 }
 
 template <class ELFT> void LazyObjectFile::parse() {
   for (StringRef Sym : getSymbols())
     Symtab<ELFT>::X->addLazyObject(Sym, *this);
 }
 

test/ELF/lto/archive-no-index.ll

 ; REQUIRES: x86
 ; Tests that we suggest that LTO symbols missing from an archive index
 ; may be the cause of undefined references, but only if we both
 ; encountered an empty archive index and undefined references (to prevent
 ; noisy false alarms).
 
 ; RUN: llvm-as -o %t1.o %s
 ; RUN: llvm-as -o %t2.o %S/Inputs/archive.ll
 
 ; RUN: rm -f %t1.a %t2.a
 ; RUN: llvm-ar crS %t1.a %t2.o
 ; RUN: llvm-ar crs %t2.a %t2.o
 
-; RUN: ld.lld -o %t -emain -m elf_x86_64 %t1.o %t1.a
+; RUN: ld.lld -o %t -emain -m elf_x86_64 %t1.o %t1.a 2>&1 | FileCheck %s
 ; RUN: ld.lld -o %t -emain -m elf_x86_64 %t1.o %t2.a
 
+; CHECK: warning: At least the {{.*}}archive-no-index.ll.tmp1.a archive listed no symbols in its index. This can happen when creating archives with a version of ar that does not understand the object files in the archive. For example, if you are using LLVM bitcode objects (such as created by -flto), you may need to use llvm-ar or GNU ar with a plugin.
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare void @f()
 
 define i32 @main() {
   call void @f()
   ret i32 0
 }