[ELF] Parse archives as --start-lib object files

[MaskRay]

Summary

https://maskray.me/blog/2022-01-16-archives-and-start-lib

For every definition in an extracted archive member, we intern the symbol twice,
once for the archive index entry, once for the .o symbol table after extraction.
This is inefficient.

Symbols in a --start-lib ObjFile/BitcodeFile are only interned once because the
result is cached in symbols[i].

Just handle an archive using the --start-lib code path. We can therefore remove
ArchiveFile and LazyArchive. For many projects, archive member extraction ratio
is high and it is a net performance win. Linking a Release build of clang is
1.01x as fast.

Note: --start-lib scans symbols in the same order that llvm-ar adds them to the
index, so in the common case the semantics should be identical. If the archive
symbol table was created in a different order, or is incomplete, this strategy
may have different semantics. Such cases are considered user error.

The is neither ET_REL nor LLVM bitcode error is changed to a warning.
Previously an archive may have such members without a diagnostic. Using a
warning prevents breakage.

• For some tests, the diagnostics get improved where we did not consider the archive member name: b.a: => b.a(b.o):.
• no-obj.s: the link is now allowed, matching GNU ld
• archive-no-index.s: the is neither ET_REL nor LLVM bitcode diagnostic is demoted to a warning.
• incompatible.s: even when an archive is unextracted, we may report an "incompatible with" error.

---

I recently decreased sizeof(SymbolUnion) by 8 and decreased memory usage quite a
bit, so retaining symbols for un-extracted archive members should not cause a
memory usage problem.

[peter.smith]

Just come back from being out of office, will try and work my way through this but may take a bit of time. Hopefully by the end of the week.

[MaskRay]

rebase after recent header clean-up

[MaskRay]

rebase

[MaskRay]

add a test to incompatible.s: we may now report "incompatible with" for an unextracted archive

[peter.smith]

Apologies, I ran out of time this Friday, will try again early next week.

[peter.smith]

I've had a chance to look through this. Assuming the user-visible behaviour changes are limited to what has been mentioned in the description I'm in favour of the change. I've only made one suggestion surrounding a comment. To check my understanding all files in archives are handled with createLazyFile which would make their symbols LazyObject ? If I'm wrong then I'll need to re-read the code to make sure I understand first.

lld/ELF/Driver.cpp

231–243

Is it worth a design decision comment here? I'm thinking of people new to LLD wondering where the traditional archive handling code is.

For example

LLD chooses to handle archives and --start-lib and --end-lib using the same code-path. This scans all the ELF files in the archive rather than just the index file, with the benefit that the symbols are only loaded once. For many projects archives see high utilization rates so in these cases it is a net performance win.

lld/ELF/Symbols.h

412

As I understand it, traditional archives are effectively being handled as if they've been expanded by --start-lib and --end-lib is it worth mentioning this here.

// LazyObject symbols represents symbols in object files between --start-lib and --end-lib options. LLD also handles traditional archives as if all the files in the archive where extracted while being surrounded by --start-lib and --end-lib.

[MaskRay]

improve comments

[peter.smith]

Thanks for the update. LGTM.

[bd1976llvm]

lld/ELF/Driver.cpp

236

Maybe worth expanding this some more: "--start-lib and --end-lib scans symbols in the same order that llvm-ar adds them, so in the common case the semantics should be identical. If the archive symbol table was created in a different order, or is incomplete, this strategy has different semantics, such cases are considered user error."

[MaskRay]

update comments

[bd1976llvm]

I am slightly concerned about penalising links with low utilisation archives. However, I don't have any specific data on low utilisation archives or any example of them. We did do some testing of a similar feature (in our proprietary linker) on game code, and low utilisation archives did not cause a problem for any of the games tested. Users should be able to create high utilisation versions of problematic archives in any case.

LGTM from me.

[MaskRay]

lld/ELF/Driver.cpp

231–243

Thanks for the suggestion!

[MaskRay]

In D119074#3323417, @bd1976llvm wrote:

I am slightly concerned about penalising links with low utilisation archives. However, I don't have any specific data on low utilisation archives or any example of them. We did do some testing of a similar feature (in our proprietary linker) on game code, and low utilisation archives did not cause a problem for any of the games tested. Users should be able to create high utilisation versions of problematic archives in any case.

LGTM from me.

I think the utilization ratio needs to be quite low to observe a performance loss (I guess for 50% utilization with regular defined-vs-undefined ratio, it's still a net win). Even in that case the performance loss can be restored by parallel input file scanning (https://discourse.llvm.org/t/parallel-input-file-parsing/60164).

The removal of 155 line code is also important.

[MaskRay]

For a default build of chromium, this change makes the link 1.05x as fast :)

% hyperfine --warmup 2 --min-runs 16 "numactl -C 20-27 "{/tmp/c/0,/tmp/c/1}" -flavor gnu @response.txt --threads=8 -o lld"
Benchmark 1: numactl -C 20-27 /tmp/c/0 -flavor gnu @response.txt --threads=8 -o lld
  Time (mean ± σ):      6.911 s ±  0.034 s    [User: 10.447 s, System: 2.791 s]
  Range (min … max):    6.843 s …  6.980 s    16 runs
 
Benchmark 2: numactl -C 20-27 /tmp/c/1 -flavor gnu @response.txt --threads=8 -o lld
  Time (mean ± σ):      6.574 s ±  0.034 s    [User: 10.068 s, System: 2.844 s]
  Range (min … max):    6.505 s …  6.624 s    16 runs
 
Summary
  'numactl -C 20-27 /tmp/c/1 -flavor gnu @response.txt --threads=8 -o lld' ran
    1.05 ± 0.01 times faster than 'numactl -C 20-27 /tmp/c/0 -flavor gnu @response.txt --threads=8 -o lld'

[thakis]

Hooray for the speedup!

Looks like this breaks tests on Windows though: https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket/8822094137116818593/+/u/package_clang/stdout?format=raw

tail: cannot open `+9' for reading: No such file or directory

Looks like the gnuwin version of tail doesn't like -c +9 syntax. Is there a different way of writing this?

[MaskRay]

In D119074#3326237, @thakis wrote:

Hooray for the speedup!

Looks like this breaks tests on Windows though: https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket/8822094137116818593/+/u/package_clang/stdout?format=raw

tail: cannot open `+9' for reading: No such file or directory

Looks like the gnuwin version of tail doesn't like -c +9 syntax. Is there a different way of writing this?

The -c +9 usage conforms to https://pubs.opengroup.org/onlinepubs/007904975/utilities/tail.html

We can unsupport the test on Windows. Is it that old? http://gnuwin32.sourceforge.net/packages/coreutils.htm

[aeubanks]

In D119074#3326697, @MaskRay wrote:

In D119074#3326237, @thakis wrote:

Hooray for the speedup!

Looks like this breaks tests on Windows though: https://logs.chromium.org/logs/chromium/buildbucket/cr-buildbucket/8822094137116818593/+/u/package_clang/stdout?format=raw

tail: cannot open `+9' for reading: No such file or directory

Looks like the gnuwin version of tail doesn't like -c +9 syntax. Is there a different way of writing this?

The -c +9 usage conforms to https://pubs.opengroup.org/onlinepubs/007904975/utilities/tail.html

We can unsupport the test on Windows. Is it that old? http://gnuwin32.sourceforge.net/packages/coreutils.htm

Unsupporting the test on Windows is fine, I can send out a patch.
We can't change gnuwin32 and it's what all the LLVM docs say to use, so we have to deal with it.

[jhenderson]

In D119074#3326760, @aeubanks wrote:

Unsupporting the test on Windows is fine, I can send out a patch.
We can't change gnuwin32 and it's what all the LLVM docs say to use, so we have to deal with it.

Which docs are you referring to? The latest LLVM docs no longer say to use GNUWin32 (because it's so old). See D108513. The consensus nowadays seems to be to rely on the tools shipped with git.

[aeubanks]

In D119074#3326772, @jhenderson wrote:

In D119074#3326760, @aeubanks wrote:

Unsupporting the test on Windows is fine, I can send out a patch.
We can't change gnuwin32 and it's what all the LLVM docs say to use, so we have to deal with it.

Which docs are you referring to? The latest LLVM docs no longer say to use GNUWin32 (because it's so old). See D108513. The consensus nowadays seems to be to rely on the tools shipped with git.

Ah I do vaguely remember that patch going through.
I grepped for gnuwin and saw a bunch of references to it, all of them saying/implying that we should be using gnuwin. Perhaps those should be updated?
The thing with git bash tools is that although they're great for development, it's non trivial to download them and unpack them somewhere as part of bot builds.

[jhenderson]

In D119074#3326828, @aeubanks wrote:

In D119074#3326772, @jhenderson wrote:

In D119074#3326760, @aeubanks wrote:

Unsupporting the test on Windows is fine, I can send out a patch.
We can't change gnuwin32 and it's what all the LLVM docs say to use, so we have to deal with it.

Which docs are you referring to? The latest LLVM docs no longer say to use GNUWin32 (because it's so old). See D108513. The consensus nowadays seems to be to rely on the tools shipped with git.

Ah I do vaguely remember that patch going through.
I grepped for gnuwin and saw a bunch of references to it, all of them saying/implying that we should be using gnuwin. Perhaps those should be updated?

Yes, probably!

The thing with git bash tools is that although they're great for development, it's non trivial to download them and unpack them somewhere as part of bot builds.

Don't these bots need git installed already though to checkout the LLVM repository?

[aeubanks]

In D119074#3326835, @jhenderson wrote:

In D119074#3326828, @aeubanks wrote:

In D119074#3326772, @jhenderson wrote:

In D119074#3326760, @aeubanks wrote:

Unsupporting the test on Windows is fine, I can send out a patch.
We can't change gnuwin32 and it's what all the LLVM docs say to use, so we have to deal with it.

Which docs are you referring to? The latest LLVM docs no longer say to use GNUWin32 (because it's so old). See D108513. The consensus nowadays seems to be to rely on the tools shipped with git.

Ah I do vaguely remember that patch going through.
I grepped for gnuwin and saw a bunch of references to it, all of them saying/implying that we should be using gnuwin. Perhaps those should be updated?

Yes, probably!

The thing with git bash tools is that although they're great for development, it's non trivial to download them and unpack them somewhere as part of bot builds.

Don't these bots need git installed already though to checkout the LLVM repository?

let's move this conversation to D108513

lld/ELF/Driver.h

private:
 
   // True if we are in --start-lib and --end-lib.
   bool inLib = false;
 
   // For LTO.
   std::unique_ptr<BitcodeCompiler> lto;
 
   std::vector<InputFile *> files;
+
+public:
+  SmallVector<std::pair<StringRef, unsigned>, 0> archiveFiles;
 };
 
 // Parses command line options.
 class ELFOptTable : public llvm::opt::OptTable {
 public:
   ELFOptTable();
   llvm::opt::InputArgList parse(ArrayRef<const char *> argv);
 };

lld/ELF/Driver.cpp

 #include "lld/Common/Strings.h"
 #include "lld/Common/TargetOptionsCommandFlags.h"
 #include "lld/Common/Version.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Config/llvm-config.h"
 #include "llvm/LTO/LTO.h"
+#include "llvm/Object/Archive.h"
 #include "llvm/Remarks/HotnessThresholdParser.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/GlobPattern.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/Parallel.h"
 #include "llvm/Support/Path.h"
bool elf::link(ArrayRef<const char *> args, llvm::raw_ostream &stdoutOS,
   // This driver-specific context will be freed later by lldMain().
   auto *ctx = new CommonLinkerContext;
 
   ctx->e.initialize(stdoutOS, stderrOS, exitEarly, disableOutput);
   ctx->e.cleanupCallback = []() {
     inputSections.clear();
     outputSections.clear();
     memoryBuffers.clear();
-    archiveFiles.clear();
     binaryFiles.clear();
     bitcodeFiles.clear();
     lazyBitcodeFiles.clear();
     objectFiles.clear();
     sharedFiles.clear();
     backwardReferences.clear();
     whyExtract.clear();
     symAux.clear();
case file_magic::unknown:
     return;
   case file_magic::archive: {
     if (inWholeArchive) {
       for (const auto &p : getArchiveMembers(mbref))
         files.push_back(createObjectFile(p.first, path, p.second));
       return;
     }
 
-    std::unique_ptr<Archive> file =
-        CHECK(Archive::create(mbref), path + ": failed to parse archive");
-
-    // If an archive file has no symbol table, it may be intentional (used as a
-    // group of lazy object files where the symbol table is not useful), or the
-    // user is attempting LTO and using a default ar command that doesn't
-    // understand the LLVM bitcode file. Treat the archive as a group of lazy
-    // object files.
-    if (file->isEmpty() || file->hasSymbolTable()) {
-      // Handle the regular case.
-      files.push_back(make<ArchiveFile>(std::move(file)));
-      return;
-    }
+    auto members = getArchiveMembers(mbref);
+    archiveFiles.emplace_back(path, members.size());
 
+    // Handle archives and --start-lib/--end-lib using the same code path. This
+    // scans all the ELF relocatable object files and bitcode files in the
+    // archive rather than just the index file, with the benefit that the
+    // symbols are only loaded once. For many projects archives see high
+    // utilization rates and it is a net performance win. --start-lib scans
+    // symbols in the same order that llvm-ar adds them to the index, so in the
+    // common case the semantics are identical. If the archive symbol table was
+    // created in a different order, or is incomplete, this strategy has
+    // different semantics. Such output differences are considered user error.
+    //
     // All files within the archive get the same group ID to allow mutual
     // references for --warn-backrefs.
     bool saved = InputFile::isInGroup;
     InputFile::isInGroup = true;
-    for (const std::pair<MemoryBufferRef, uint64_t> &p :
-         getArchiveMembers(mbref)) {
+    for (const std::pair<MemoryBufferRef, uint64_t> &p : members) {
       auto magic = identify_magic(p.first.getBuffer());
       if (magic == file_magic::bitcode || magic == file_magic::elf_relocatable)
         files.push_back(createLazyFile(p.first, path, p.second));
       else
-        error(path + ": archive member '" + p.first.getBufferIdentifier() +
-              "' is neither ET_REL nor LLVM bitcode");
+        warn(path + ": archive member '" + p.first.getBufferIdentifier() +
     }
     InputFile::isInGroup = saved;
     if (!saved)
       ++InputFile::nextGroupId;
     return;
   }
   case file_magic::elf_shared_object:
     if (config->isStatic || config->relocatable) {

 
 void LinkerDriver::createFiles(opt::InputArgList &args) {
   llvm::TimeTraceScope timeScope("Load input files");
   // For --{push,pop}-state.
   std::vector<std::tuple<bool, bool, bool>> stack;
 
   // Iterate over argv to process input files and positional arguments.
   InputFile::isInGroup = false;
+  bool hasInput = false;
   for (auto *arg : args) {
     switch (arg->getOption().getID()) {
     case OPT_library:
       addLibrary(arg->getValue());
+      hasInput = true;
       break;
     case OPT_INPUT:
       addFile(arg->getValue(), /*withLOption=*/false);
+      hasInput = true;
       break;
     case OPT_defsym: {
       StringRef from;
       StringRef to;
       std::tie(from, to) = StringRef(arg->getValue()).split('=');
       if (from.empty() || to.empty())
         error("--defsym: syntax error: " + StringRef(arg->getValue()));
       else
case OPT_pop_state:
         break;
       }
       std::tie(config->asNeeded, config->isStatic, inWholeArchive) = stack.back();
       stack.pop_back();
       break;
     }
   }
 
-  if (files.empty() && errorCount() == 0)
+  if (files.empty() && !hasInput && errorCount() == 0)
     error("no input files");
 }
 
 // If -m <machine_type> was not given, infer it from object files.
 void LinkerDriver::inferMachineType() {
   if (config->ekind != ELFNoneKind)
     return;
 

 }
 
 static void handleLibcall(StringRef name) {
   Symbol *sym = symtab->find(name);
   if (!sym || !sym->isLazy())
     return;
 
   MemoryBufferRef mb;
-  if (auto *lo = dyn_cast<LazyObject>(sym))
-    mb = lo->file->mb;
-  else
-    mb = cast<LazyArchive>(sym)->getMemberBuffer();
+  mb = cast<LazyObject>(sym)->file->mb;
 
   if (isBitcode(mb))
     sym->extract();
 }
 
 // Handle --dependency-file=<path>. If that option is given, lld creates a
 // file at a given path with the following contents:
 //

lld/ELF/InputFiles.h

 #define LLD_ELF_INPUT_FILES_H
 
 #include "Config.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Reproduce.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/BinaryFormat/Magic.h"
-#include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
+#include "llvm/Support/MemoryBufferRef.h"
 #include "llvm/Support/Threading.h"
 
 namespace llvm {
 struct DILineInfo;
 class TarWriter;
 namespace lto {
 class InputFile;
 }
 } // namespace llvm
 
 namespace lld {
 class DWARFCache;
 
 // Returns "<internal>", "foo.a(bar.o)" or "baz.o".
 std::string toString(const elf::InputFile *f);
 
 namespace elf {
 
-using llvm::object::Archive;
-
 class InputSection;
 class Symbol;
 
 // If --reproduce is specified, all input files are written to this tar archive.
 extern std::unique_ptr<llvm::TarWriter> tar;
 
 // Opens a given file.
 llvm::Optional<MemoryBufferRef> readFile(StringRef path);
private:
   // Debugging information to retrieve source file and line for error
   // reporting. Linker may find reasonable number of errors in a
   // single object file, so we cache debugging information in order to
   // parse it only once for each object file we link.
   std::unique_ptr<DWARFCache> dwarf;
   llvm::once_flag initDwarf;
 };
 
-// An ArchiveFile object represents a .a file.
-class ArchiveFile : public InputFile {
-public:
-  explicit ArchiveFile(std::unique_ptr<Archive> &&file);
-  static bool classof(const InputFile *f) { return f->kind() == ArchiveKind; }
-  void parse();
-
-  // Pulls out an object file that contains a definition for Sym and
-  // returns it. If the same file was instantiated before, this
-  // function does nothing (so we don't instantiate the same file
-  // more than once.)
-  void extract(const Archive::Symbol &sym);
-
-  // Check if a non-common symbol should be extracted to override a common
-  // definition.
-  bool shouldExtractForCommon(const Archive::Symbol &sym);
-
-  size_t getMemberCount() const;
-  size_t getExtractedMemberCount() const { return seen.size(); }
-
-  bool parsed = false;
-
-private:
-  std::unique_ptr<Archive> file;
-  llvm::DenseSet<uint64_t> seen;
-};
-
 class BitcodeFile : public InputFile {
 public:
   BitcodeFile(MemoryBufferRef m, StringRef archiveName,
               uint64_t offsetInArchive, bool lazy);
   static bool classof(const InputFile *f) { return f->kind() == BitcodeKind; }
   template <class ELFT> void parse();
   void parseLazy();
   std::unique_ptr<llvm::lto::InputFile> obj;

 
 inline bool isBitcode(MemoryBufferRef mb) {
   return identify_magic(mb.getBuffer()) == llvm::file_magic::bitcode;
 }
 
 std::string replaceThinLTOSuffix(StringRef path);
 
 extern SmallVector<std::unique_ptr<MemoryBuffer>> memoryBuffers;
-extern SmallVector<ArchiveFile *, 0> archiveFiles;
 extern SmallVector<BinaryFile *, 0> binaryFiles;
 extern SmallVector<BitcodeFile *, 0> bitcodeFiles;
 extern SmallVector<BitcodeFile *, 0> lazyBitcodeFiles;
 extern SmallVector<ELFFileBase *, 0> objectFiles;
 extern SmallVector<SharedFile *, 0> sharedFiles;
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/InputFiles.cpp

 using namespace llvm::support::endian;
 using namespace lld;
 using namespace lld::elf;
 
 bool InputFile::isInGroup;
 uint32_t InputFile::nextGroupId;
 
 SmallVector<std::unique_ptr<MemoryBuffer>> elf::memoryBuffers;
-SmallVector<ArchiveFile *, 0> elf::archiveFiles;
 SmallVector<BinaryFile *, 0> elf::binaryFiles;
 SmallVector<BitcodeFile *, 0> elf::bitcodeFiles;
 SmallVector<BitcodeFile *, 0> elf::lazyBitcodeFiles;
 SmallVector<ELFFileBase *, 0> elf::objectFiles;
 SmallVector<SharedFile *, 0> elf::sharedFiles;
 
 std::unique_ptr<TarWriter> elf::tar;
 
template <class ELFT> static void doParseFile(InputFile *file) {
 
   // Binary file
   if (auto *f = dyn_cast<BinaryFile>(file)) {
     binaryFiles.push_back(f);
     f->parse();
     return;
   }
 
-  // .a file
-  if (auto *f = dyn_cast<ArchiveFile>(file)) {
-    archiveFiles.push_back(f);
-    f->parse();
-    return;
-  }
-
   // Lazy object file
   if (file->lazy) {
     if (auto *f = dyn_cast<BitcodeFile>(file)) {
       lazyBitcodeFiles.push_back(f);
       f->parseLazy();
     } else {
       cast<ObjFile<ELFT>>(file)->parseLazy();
     }
for (size_t i = firstGlobal, end = eSyms.size(); i != end; ++i) {
 
     // If a defined symbol is in a discarded section, handle it as if it
     // were an undefined symbol. Such symbol doesn't comply with the
     // standard, but in practice, a .eh_frame often directly refer
     // COMDAT member sections, and if a comdat group is discarded, some
     // defined symbol in a .eh_frame becomes dangling symbols.
     if (sec == &InputSection::discarded) {
       Undefined und{this, StringRef(), binding, stOther, type, secIdx};
-      // !ArchiveFile::parsed or !LazyObjFile::lazy means that the file
-      // containing this object has not finished processing, i.e. this symbol is
-      // a result of a lazy symbol extract. We should demote the lazy symbol to
-      // an Undefined so that any relocations outside of the group to it will
-      // trigger a discarded section error.
-      if ((sym->symbolKind == Symbol::LazyArchiveKind &&
-           !cast<ArchiveFile>(sym->file)->parsed) ||
-          (sym->symbolKind == Symbol::LazyObjectKind && !sym->file->lazy)) {
+      // !LazyObjFile::lazy indicates that the file containing this object has
+      // not finished processing, i.e. this symbol is a result of a lazy symbol
+      // extract. We should demote the lazy symbol to an Undefined so that any
+      // relocations outside of the group to it will trigger a discarded section
+      // error.
+      if (sym->symbolKind == Symbol::LazyObjectKind && !sym->file->lazy) {
         sym->replace(und);
         // Prevent LTO from internalizing the symbol in case there is a
         // reference to this symbol from this file.
         sym->isUsedInRegularObj = true;
       } else
         sym->resolve(und);
       continue;
     }
for (unsigned i : undefineds) {
     const Elf_Sym &eSym = eSyms[i];
     Symbol *sym = symbols[i];
     sym->resolve(Undefined{this, StringRef(), eSym.getBinding(), eSym.st_other,
                            eSym.getType()});
     sym->referenced = true;
   }
 }
 
-ArchiveFile::ArchiveFile(std::unique_ptr<Archive> &&file)
-    : InputFile(ArchiveKind, file->getMemoryBufferRef()),
-      file(std::move(file)) {}
-
-void ArchiveFile::parse() {
-  SymbolTable &symtab = *elf::symtab;
-  for (const Archive::Symbol &sym : file->symbols())
-    symtab.addSymbol(LazyArchive{*this, sym});
-
-  // Inform a future invocation of ObjFile<ELFT>::initializeSymbols() that this
-  // archive has been processed.
-  parsed = true;
-}
-
-// Returns a buffer pointing to a member file containing a given symbol.
-void ArchiveFile::extract(const Archive::Symbol &sym) {
-  Archive::Child c =
-      CHECK(sym.getMember(), toString(this) +
-                                 ": could not get the member for symbol " +
-                                 toELFString(sym));
-
-  if (!seen.insert(c.getChildOffset()).second)
-    return;
-
-  MemoryBufferRef mb =
-      CHECK(c.getMemoryBufferRef(),
-            toString(this) +
-                ": could not get the buffer for the member defining symbol " +
-                toELFString(sym));
-
-  if (tar && c.getParent()->isThin())
-    tar->append(relativeToRoot(CHECK(c.getFullName(), this)), mb.getBuffer());
-
-  InputFile *file = createObjectFile(mb, getName(), c.getChildOffset());
-  file->groupId = groupId;
-  parseFile(file);
-}
-
 // The handling of tentative definitions (COMMON symbols) in archives is murky.
 // A tentative definition will be promoted to a global definition if there are
 // no non-tentative definitions to dominate it. When we hold a tentative
 // definition to a symbol and are inspecting archive members for inclusion
 // there are 2 ways we can proceed:
 //
 // 1) Consider the tentative definition a 'real' definition (ie promotion from
 //    tentative to real definition has already happened) and not inspect
case ELF64LEKind:
     return isNonCommonDef<ELF64LE>(mb, symName, archiveName);
   case ELF64BEKind:
     return isNonCommonDef<ELF64BE>(mb, symName, archiveName);
   default:
     llvm_unreachable("getELFKind");
   }
 }
 
-bool ArchiveFile::shouldExtractForCommon(const Archive::Symbol &sym) {
-  Archive::Child c =
-      CHECK(sym.getMember(), toString(this) +
-                                 ": could not get the member for symbol " +
-                                 toELFString(sym));
-  MemoryBufferRef mb =
-      CHECK(c.getMemoryBufferRef(),
-            toString(this) +
-                ": could not get the buffer for the member defining symbol " +
-                toELFString(sym));
-
-  if (isBitcode(mb))
-    return isBitcodeNonCommonDef(mb, sym.getName(), getName());
-
-  return isNonCommonDef(mb, sym.getName(), getName());
-}
-
-size_t ArchiveFile::getMemberCount() const {
-  size_t count = 0;
-  Error err = Error::success();
-  for (const Archive::Child &c : file->children(err)) {
-    (void)c;
-    ++count;
-  }
-  // This function is used by --print-archive-stats=, where an error does not
-  // really matter.
-  consumeError(std::move(err));
-  return count;
-}
-
 unsigned SharedFile::vernauxNum;
 
 // Parse the version definitions in the object file if present, and return a
 // vector whose nth element contains a pointer to the Elf_Verdef for version
 // identifier n. Version identifiers that are not definitions map to nullptr.
 template <typename ELFT>
 static SmallVector<const void *, 0>
 parseVerdefs(const uint8_t *base, const typename ELFT::Shdr *sec) {

lld/ELF/MapFile.cpp

 //   00201000 00000015     4 .text
 //   00201000 0000000e     4         test.o:(.text)
 //   0020100e 00000000     0                 local
 //   00201005 00000000     0                 f(int)
 //
 //===----------------------------------------------------------------------===//
 
 #include "MapFile.h"
+#include "Driver.h"
 #include "InputFiles.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallPtrSet.h"
void elf::writeArchiveStats() {
   raw_fd_ostream os(config->printArchiveStats, ec, sys::fs::OF_None);
   if (ec) {
     error("--print-archive-stats=: cannot open " + config->printArchiveStats +
           ": " + ec.message());
     return;
   }
 
   os << "members\textracted\tarchive\n";
-  for (const ArchiveFile *f : archiveFiles)
-    os << f->getMemberCount() << '\t' << f->getExtractedMemberCount() << '\t'
-       << f->getName() << '\n';
+
+  SmallVector<StringRef, 0> archives;
+  DenseMap<CachedHashStringRef, unsigned> all, extracted;
+  for (ELFFileBase *file : objectFiles)
+    if (file->archiveName.size())
+      ++extracted[CachedHashStringRef(file->archiveName)];
+  for (BitcodeFile *file : bitcodeFiles)
+    if (file->archiveName.size())
+      ++extracted[CachedHashStringRef(file->archiveName)];
+  for (std::pair<StringRef, unsigned> f : driver->archiveFiles) {
+    unsigned &v = extracted[CachedHashString(f.first)];
+    os << f.second << '\t' << v << '\t' << f.first << '\n';
+    // If the archive occurs multiple times, other instances have a count of 0.
+    v = 0;
+  }
 }

lld/ELF/Symbols.h

 
 #ifndef LLD_ELF_SYMBOLS_H
 #define LLD_ELF_SYMBOLS_H
 
 #include "InputFiles.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Memory.h"
 #include "llvm/ADT/DenseMap.h"
-#include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 #include <tuple>
 
 namespace lld {
 // Returns a string representation for a symbol for diagnostics.
 std::string toString(const elf::Symbol &);
 
-// There are two different ways to convert an Archive::Symbol to a string:
-// One for Microsoft name mangling and one for Itanium name mangling.
-// Call the functions toCOFFString and toELFString, not just toString.
-std::string toELFString(const llvm::object::Archive::Symbol &);
-
 namespace elf {
 class CommonSymbol;
 class Defined;
 class OutputSection;
 class SectionBase;
 class SharedSymbol;
 class Symbol;
 class Undefined;

 class Symbol {
 public:
   enum Kind {
     PlaceholderKind,
     DefinedKind,
     CommonKind,
     SharedKind,
     UndefinedKind,
-    LazyArchiveKind,
     LazyObjectKind,
   };
 
   Kind kind() const { return static_cast<Kind>(symbolKind); }
 
   // The file from which this symbol was created.
   InputFile *file;
 
public:
   bool isUndefined() const { return symbolKind == UndefinedKind; }
   bool isCommon() const { return symbolKind == CommonKind; }
   bool isDefined() const { return symbolKind == DefinedKind; }
   bool isShared() const { return symbolKind == SharedKind; }
   bool isPlaceholder() const { return symbolKind == PlaceholderKind; }
 
   bool isLocal() const { return binding == llvm::ELF::STB_LOCAL; }
 
-  bool isLazy() const {
-    return symbolKind == LazyArchiveKind || symbolKind == LazyObjectKind;
-  }
+  bool isLazy() const { return symbolKind == LazyObjectKind; }
 
   // True if this is an undefined weak symbol. This only works once
   // all input files have been added.
   bool isUndefWeak() const { return isWeak() && isUndefined(); }
 
   StringRef getName() const { return {nameData, nameSize}; }
 
   void setName(StringRef s) {
public:
 
   SharedFile &getFile() const { return *cast<SharedFile>(file); }
 
   uint64_t value; // st_value
   uint64_t size;  // st_size
   uint32_t alignment;
 };
 
-// LazyArchive and LazyObject represent a symbols that is not yet in the link,
-// but we know where to find it if needed. If the resolver finds both Undefined
-// and Lazy for the same name, it will ask the Lazy to load a file.
+// LazyObject symbols represent symbols in object files between --start-lib and
+// --end-lib options. LLD also handles traditional archives as if all the files
+// in the archive are surrounded by --start-lib and --end-lib.
 //
 // A special complication is the handling of weak undefined symbols. They should
 // not load a file, but we have to remember we have seen both the weak undefined
 // and the lazy. We represent that with a lazy symbol with a weak binding. This
 // means that code looking for undefined symbols normally also has to take lazy
 // symbols into consideration.
-
-// 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.
-class LazyArchive : public Symbol {
-public:
-  LazyArchive(InputFile &file, const llvm::object::Archive::Symbol s)
-      : Symbol(LazyArchiveKind, &file, s.getName(), llvm::ELF::STB_GLOBAL,
-               llvm::ELF::STV_DEFAULT, llvm::ELF::STT_NOTYPE),
-        sym(s) {}
-
-  static bool classof(const Symbol *s) { return s->kind() == LazyArchiveKind; }
-
-  MemoryBufferRef getMemberBuffer();
-
-  const llvm::object::Archive::Symbol sym;
-};
-
-// LazyObject symbols represents symbols in object files between
-// --start-lib and --end-lib options.
 class LazyObject : public Symbol {
 public:
   LazyObject(InputFile &file)
       : Symbol(LazyObjectKind, &file, {}, llvm::ELF::STB_GLOBAL,
                llvm::ELF::STV_DEFAULT, llvm::ELF::STT_NOTYPE) {
     isUsedInRegularObj = false;
   }
 

 // A buffer class that is large enough to hold any Symbol-derived
 // object. We allocate memory using this class and instantiate a symbol
 // using the placement new.
 union SymbolUnion {
   alignas(Defined) char a[sizeof(Defined)];
   alignas(CommonSymbol) char b[sizeof(CommonSymbol)];
   alignas(Undefined) char c[sizeof(Undefined)];
   alignas(SharedSymbol) char d[sizeof(SharedSymbol)];
-  alignas(LazyArchive) char e[sizeof(LazyArchive)];
-  alignas(LazyObject) char f[sizeof(LazyObject)];
+  alignas(LazyObject) char e[sizeof(LazyObject)];
 };
 
 // It is important to keep the size of SymbolUnion small for performance and
 // memory usage reasons. 64 bytes is a soft limit based on the size of Defined
 // on a 64-bit system.
 static_assert(sizeof(SymbolUnion) <= 64, "SymbolUnion too large");
 
 template <typename T> struct AssertSymbol {
   static_assert(std::is_trivially_destructible<T>(),
                 "Symbol types must be trivially destructible");
   static_assert(sizeof(T) <= sizeof(SymbolUnion), "SymbolUnion too small");
   static_assert(alignof(T) <= alignof(SymbolUnion),
                 "SymbolUnion not aligned enough");
 };
 
 static inline void assertSymbols() {
   AssertSymbol<Defined>();
   AssertSymbol<CommonSymbol>();
   AssertSymbol<Undefined>();
   AssertSymbol<SharedSymbol>();
-  AssertSymbol<LazyArchive>();
   AssertSymbol<LazyObject>();
 }
 
 void printTraceSymbol(const Symbol &sym, StringRef name);
 
 size_t Symbol::getSymbolSize() const {
   switch (kind()) {
   case CommonKind:
     return sizeof(CommonSymbol);
   case DefinedKind:
     return sizeof(Defined);
-  case LazyArchiveKind:
-    return sizeof(LazyArchive);
   case LazyObjectKind:
     return sizeof(LazyObject);
   case SharedKind:
     return sizeof(SharedSymbol);
   case UndefinedKind:
     return sizeof(Undefined);
   case PlaceholderKind:
     return sizeof(Symbol);

lld/ELF/Symbols.cpp

std::string lld::toString(const elf::Symbol &sym) {
   std::string ret = demangle(name, config->demangle);
 
   const char *suffix = sym.getVersionSuffix();
   if (*suffix == '@')
     ret += suffix;
   return ret;
 }
 
-std::string lld::toELFString(const Archive::Symbol &b) {
-  return demangle(b.getName(), config->demangle);
-}
-
 Defined *ElfSym::bss;
 Defined *ElfSym::etext1;
 Defined *ElfSym::etext2;
 Defined *ElfSym::edata1;
 Defined *ElfSym::edata2;
 Defined *ElfSym::end1;
 Defined *ElfSym::end2;
 Defined *ElfSym::globalOffsetTable;
if (d.isTls() && !config->relocatable) {
               " has an STT_TLS symbol but doesn't have an SHF_TLS section");
       return va - Out::tlsPhdr->firstSec->addr;
     }
     return va;
   }
   case Symbol::SharedKind:
   case Symbol::UndefinedKind:
     return 0;
-  case Symbol::LazyArchiveKind:
   case Symbol::LazyObjectKind:
     llvm_unreachable("lazy symbol reached writer");
   case Symbol::CommonKind:
     llvm_unreachable("common symbol reached writer");
   case Symbol::PlaceholderKind:
     llvm_unreachable("placeholder symbol reached writer");
   }
   llvm_unreachable("invalid symbol kind");
void Symbol::parseSymbolVersion() {
   // if the symbol has a local version as it won't be in the dynamic
   // symbol table.
   if (config->shared && versionId != VER_NDX_LOCAL)
     error(toString(file) + ": symbol " + s + " has undefined version " +
           verstr);
 }
 
 void Symbol::extract() const {
-  if (auto *sym = dyn_cast<LazyArchive>(this)) {
-    cast<ArchiveFile>(sym->file)->extract(sym->sym);
-  } else if (file->lazy) {
+  if (file->lazy) {
     file->lazy = false;
     parseFile(file);
   }
 }
 
-MemoryBufferRef LazyArchive::getMemberBuffer() {
-  Archive::Child c =
-      CHECK(sym.getMember(),
-            "could not get the member for symbol " + toELFString(sym));
-
-  return CHECK(c.getMemoryBufferRef(),
-               "could not get the buffer for the member defining symbol " +
-                   toELFString(sym));
-}
-
 uint8_t Symbol::computeBinding() const {
   if ((visibility != STV_DEFAULT && visibility != STV_PROTECTED) ||
       versionId == VER_NDX_LOCAL)
     return STB_LOCAL;
   if (binding == STB_GNU_UNIQUE && !config->gnuUnique)
     return STB_GLOBAL;
   return binding;
 }
case Symbol::UndefinedKind:
     resolveUndefined(cast<Undefined>(other));
     break;
   case Symbol::CommonKind:
     resolveCommon(cast<CommonSymbol>(other));
     break;
   case Symbol::DefinedKind:
     resolveDefined(cast<Defined>(other));
     break;
-  case Symbol::LazyArchiveKind:
-    resolveLazy(cast<LazyArchive>(other));
-    break;
   case Symbol::LazyObjectKind:
     resolveLazy(cast<LazyObject>(other));
     break;
   case Symbol::SharedKind:
     resolveShared(cast<SharedSymbol>(other));
     break;
   case Symbol::PlaceholderKind:
     llvm_unreachable("bad symbol kind");
static void replaceCommon(Symbol &oldSym, const LazyT &newSym) {
   oldSym.replace(newSym);
   newSym.extract();
 }
 
 template <class LazyT> void Symbol::resolveLazy(const LazyT &other) {
   // For common objects, we want to look for global or weak definitions that
   // should be extracted as the canonical definition instead.
   if (isCommon() && elf::config->fortranCommon) {
-    if (auto *laSym = dyn_cast<LazyArchive>(&other)) {
-      ArchiveFile *archive = cast<ArchiveFile>(laSym->file);
-      const Archive::Symbol &archiveSym = laSym->sym;
-      if (archive->shouldExtractForCommon(archiveSym)) {
-        replaceCommon(*this, other);
-        return;
-      }
-    } else if (auto *loSym = dyn_cast<LazyObject>(&other)) {
+    if (auto *loSym = dyn_cast<LazyObject>(&other)) {
       if (loSym->file->shouldExtractForCommon(getName())) {
         replaceCommon(*this, other);
         return;
       }
     }
   }
 
   if (!isUndefined()) {

lld/test/ELF/archive-as-start-lib.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t && split-file %s %t && cd %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 a.s -o a.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64 b.s -o b.o
+
+## Create an archive with incomplete index: foo is missing.
+# RUN: llvm-ar --format=gnu rc a.a a.o
+# RUN: llvm-ar --format=gnu rcS b.a b.o && tail -c +9 b.a > b-tail
+# RUN: cat a.a b-tail > weird.a
+# RUN: llvm-nm --print-armap weird.a | FileCheck %s --check-prefix=ARMAP
+
+# ARMAP:      Archive map
+# ARMAP-NEXT: _start in a.o
+# ARMAP-EMPTY:
+
+## The incomplete archive index is ignored. -u foo extracts weird.a(b.o).
+## In GNU ld, foo is undefined.
+# RUN: ld.lld -m elf_x86_64 -u foo weird.a -o lazy
+# RUN: llvm-nm lazy | FileCheck %s --implicit-check-not={{.}}
+
+# CHECK: [[#%x,]] T _start
+# CHECK: [[#%x,]] T foo
+
+#--- a.s
+.globl _start
+_start:
+
+#--- b.s
+.globl foo
+foo:

lld/test/ELF/archive-no-index.s

 # REQUIRES: x86
 # Tests error on archive file without a symbol table
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux -o %t.o %s
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux -o %t.archive.o %S/Inputs/archive.s
 # RUN: rm -f %t.a
 # RUN: llvm-ar crS %t.a %t.archive.o
 
 # RUN: ld.lld %t.o %t.a -o /dev/null 2>&1 | count 0
 
 # RUN: ld.lld -shared %t.archive.o -o %t.so
 # RUN: llvm-ar crS %t.a %t.so
-# RUN: not ld.lld %t.o %t.a --noinhibit-exec -o /dev/null 2>&1 | FileCheck %s --check-prefix=ERR
+# RUN: ld.lld %t.o %t.a -o /dev/null 2>&1 | FileCheck %s --check-prefix=WARN
 
-# ERR: error: {{.*}}.a: archive member '{{.*}}.so' is neither ET_REL nor LLVM bitcode
+# WARN: warning: {{.*}}.a: archive member '{{.*}}.so' is neither ET_REL nor LLVM bitcode
 
 .globl _start
 _start:

lld/test/ELF/archive-thin-missing-member.s

 # REQUIRES: x86
 
 # RUN: rm -f %t-no-syms.a
 # RUN: rm -f %t-syms.a
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-ar rcTS %t-no-syms.a %t.o
 # RUN: llvm-ar rcT %t-syms.a %t.o
 # RUN: rm %t.o
 
 # Test error when loading symbols from missing thin archive member.
 # RUN: not ld.lld --entry=_Z1fi %t-no-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR1
 # ERR1: {{.*}}-no-syms.a: could not get the buffer for a child of the archive: '{{.*}}.o': [[MSG]]
 
 # Test error when thin archive has symbol table but member is missing.
 # RUN: not ld.lld --entry=_Z1fi -m elf_amd64_fbsd %t-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR2
-# ERR2: {{.*}}-syms.a: could not get the buffer for the member defining symbol f(int): '{{.*}}.o': [[MSG]]
-# RUN: not ld.lld --entry=_Z1fi --no-demangle -m elf_amd64_fbsd %t-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR2MANGLE
-# ERR2MANGLE: {{.*}}-syms.a: could not get the buffer for the member defining symbol _Z1fi: '{{.*}}.o': [[MSG]]
+# RUN: not ld.lld --entry=_Z1fi --no-demangle -m elf_amd64_fbsd %t-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR2
 
 # Test error when thin archive is linked using --whole-archive but member is missing.
-# RUN: not ld.lld --entry=_Z1fi --whole-archive %t-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR3
-# ERR3: {{.*}}-syms.a: could not get the buffer for a child of the archive: '{{.*}}.o': [[MSG]]
+# RUN: not ld.lld --entry=_Z1fi --whole-archive %t-syms.a -o /dev/null 2>&1 | FileCheck -DMSG=%errc_ENOENT %s --check-prefix=ERR2
+# ERR2: {{.*}}-syms.a: could not get the buffer for a child of the archive: '{{.*}}.o': [[MSG]]
 
 .global _Z1fi
 _Z1fi:
     nop

lld/test/ELF/incompatible-ar-first.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/archive.s -o %ta.o
 // RUN: rm -f %t.a
 // RUN: llvm-ar rc %t.a %ta.o
 // RUN: llvm-mc -filetype=obj -triple=i686-linux %s -o %tb.o
 // RUN: not ld.lld %t.a %tb.o -o /dev/null 2>&1 | FileCheck %s
 
 // We used to crash when
 // * The first object seen by the symbol table is from an archive.
 // * -m was not used.
-// CHECK: .a({{.*}}a.o) is incompatible with {{.*}}b.o
 
-// RUN: not ld.lld --start-lib %ta.o --end-lib %tb.o -o /dev/null 2>&1 | FileCheck %s --check-prefix=CHECK2
+// RUN: not ld.lld --start-lib %ta.o --end-lib %tb.o -o /dev/null 2>&1 | FileCheck %s
 
-// CHECK2: {{.*}}b.o is incompatible{{$}}
+// CHECK: {{.*}}b.o is incompatible{{$}}

lld/test/ELF/incompatible.s

 // RUN:   FileCheck --check-prefix=A-AND-SCRIPT %s
 // A-AND-SCRIPT: a.o is incompatible with elf32-i386
 
 // RUN: echo 'OUTPUT_FORMAT(elf32-i386-freebsd)' > %t-freebsd.script
 // RUN: not ld.lld %t-freebsd.script %ta.o -o /dev/null 2>&1 | \
 // RUN:   FileCheck --check-prefix=A-AND-FREEBSD-SCRIPT %s
 // A-AND-FREEBSD-SCRIPT: a.o is incompatible with elf32-i386-freebsd
 
+/// %tb.a is not extracted, but we report an error anyway.
+// RUN: rm -f %tb.a && llvm-ar rc %tb.a %tb.o
+// RUN: not ld.lld %ta.o %tb.a -o /dev/null 2>&1 | FileCheck --check-prefix=UNEXTRACTED-ARCHIVE %s
+// UNEXTRACTED-ARCHIVE: {{.*}}.a({{.*}}b.o) is incompatible with {{.*}}a.o
+
 // We used to fail to identify this incompatibility and crash trying to
 // read a 64 bit file as a 32 bit one.
-// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/archive2.s -o %ta.o
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/archive2.s -o %tc.o
 // RUN: rm -f %t.a
-// RUN: llvm-ar rc %t.a %ta.o
-// RUN: llvm-mc -filetype=obj -triple=i686-linux %s -o %tb.o
-// RUN: not ld.lld %t.a %tb.o 2>&1 -o /dev/null | FileCheck --check-prefix=ARCHIVE %s
-// ARCHIVE: .a({{.*}}a.o) is incompatible with {{.*}}b.o
+// RUN: llvm-ar rc %t.a %tc.o
+// RUN: llvm-mc -filetype=obj -triple=i686-linux %s -o %td.o
+// RUN: not ld.lld %t.a %td.o 2>&1 -o /dev/null | FileCheck --check-prefix=ARCHIVE %s
+// ARCHIVE: {{.*}}d.o is incompatible
 .global _start
 _start:
 .data
         .long foo
 

lld/test/ELF/lto/comdat-mixed-archive.test

 RUN: ld.lld start.o lib.a -y foo -y bar -o /dev/null | FileCheck %s --check-prefix=TRACE
 
 ;; "bar" should be encountered before "foo" so that it triggers the loading of
 ;; "obj.o" while "foo" is still lazy.
 BCSYM:      U bar
 BCSYM-NEXT: W foo
 
 ;; Check that the symbols are handled in the expected order.
-TRACE:      lib.a: lazy definition of foo
-TRACE-NEXT: lib.a: lazy definition of bar
+TRACE:      lib.a(obj.o): lazy definition of foo
+TRACE-NEXT: lib.a(obj.o): lazy definition of bar
 TRACE-NEXT: lib.a(bc.bc): reference to bar
 TRACE-NEXT: lib.a(obj.o): reference to foo
 TRACE-NEXT: lib.a(obj.o): definition of bar
 TRACE-NEXT: lib.a(bc.bc): definition of foo
 TRACE-NEXT: <internal>: reference to foo
 ;; The definition of "foo" is visible outside the LTO result.
 TRACE-NEXT: lto.tmp: definition of foo
 TRACE-NEXT: lto.tmp: reference to bar

lld/test/ELF/lto/exclude-libs-libcall.ll

 ; REQUIRES: x86
 ; RUN: rm -rf %t && split-file %s %t
 ; RUN: llvm-as %t/a.ll -o %t/a.bc
 ; RUN: llvm-mc -filetype=obj -triple=x86_64 %t/b.s -o %t/b.o
 ; RUN: llvm-ar rc %t/b.a %t/b.o
 ; RUN: ld.lld -shared --exclude-libs=b.a %t/a.bc %t/b.a -o %t.so -y __divti3 2>&1 | FileCheck %s --check-prefix=TRACE
 ; RUN: llvm-readelf --dyn-syms %t.so | FileCheck %s
 
-; TRACE:      {{.*}}/b.a: lazy definition of __divti3
+; TRACE:      {{.*}}/b.a(b.o): lazy definition of __divti3
 ; TRACE-NEXT: lto.tmp: reference to __divti3
 ; TRACE-NEXT: {{.*}}/b.a(b.o): definition of __divti3
 
 ; CHECK:     Symbol table '.dynsym' contains 2 entries:
 ; CHECK-NOT: __divti3
 
 ;--- a.ll
 target triple = "x86_64-unknown-linux"

lld/test/ELF/no-obj.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: rm -f %t.a
 // RUN: llvm-ar rcs %t.a %t.o
-// RUN: not ld.lld -o /dev/null -u _start %t.a 2>&1 | FileCheck %s
-
-// CHECK: target emulation unknown: -m or at least one .o file required
+// RUN: ld.lld -o /dev/null -u _start %t.a 2>&1 | count 0
 
 .global _start
 _start:

lld/test/ELF/trace-symbols.s

 # RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 | \
 # RUN:   FileCheck -check-prefix=OBJECTD2FOO %s
 # OBJECTD2FOO: trace-symbols.s.tmp2: definition of foo
 
 # RUN: ld.lld -y foo -y common %t %t2 %t1.a -o %t3 | \
 # RUN:   FileCheck -check-prefix=FOO_AND_COMMON %s
 # FOO_AND_COMMON: trace-symbols.s.tmp: reference to foo
 # FOO_AND_COMMON: trace-symbols.s.tmp2: definition of foo
-# FOO_AND_COMMON: trace-symbols.s.tmp1.a: lazy definition of common
+# FOO_AND_COMMON: trace-symbols.s.tmp1.a({{.*}}.tmp1): lazy definition of common
 
 # RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 | \
 # RUN:   FileCheck -check-prefix=SHLIBDCOMMON %s
 # SHLIBDCOMMON: trace-symbols.s.tmp1.so: shared definition of common
 
 # RUN: ld.lld -y foo -y common %t %t2.so %t1.so -o %t3 | \
 # RUN:   FileCheck -check-prefix=SHLIBD2FOO %s
 # RUN: ld.lld -y foo %t %t1.a %t2.so -o %t3 | \