[ELF] Add --why-extract= to query why archive members/lazy object files are extracted

[MaskRay]

Summary

Similar to D69607 but for archive member extraction unrelated to GC. This patch adds --why-extract=.

Prior art:

GNU ld -M prints

Archive member included to satisfy reference by file (symbol)

a.a(a.o)                      main.o (a)
b.a(b.o)                      (b())

-M is mainly for input section/symbol assignment <-> output section mapping
(often huge output) and the information may appear ad-hoc.

Apple ld64

__Z1bv forced load of b.a(b.o)
_a forced load of a.a(a.o)

It doesn't say the reference file.

Arm's proprietary linker

Selecting member vsnprintf.o(c_wfu.l) to define vsnprintf.
...
Loading member vsnprintf.o from c_wfu.l.
              definition:  vsnprintf
              reference :  _printf_a

---

--why-extract= gives the user the full data (which is much shorter than GNU ld
-Map). It is easy to track a chain of references to one archive member with a
one-liner, e.g.

% ld.lld main.o a_b.a b_c.a c.a -o /dev/null --why-extract=- | tee stdout
reference       extracted       symbol
main.o  a_b.a(a_b.o)    a
a_b.a(a_b.o)    b_c.a(b_c.o)    b()
b_c.a(b_c.o)    c.a(c.o)        c()

% ruby -F'\t' -ane 'BEGIN{p={}}; p[$F[1]]=[$F[0],$F[2]] if $.>1; END{x="c.a(c.o)"; while y=p[x]; puts "#{y[0]} extracts #{x} to resolve #{y[1]}"; x=y[0] end}' stdout
b_c.a(b_c.o) extracts c.a(c.o) to resolve c()
a_b.a(a_b.o) extracts b_c.a(b_c.o) to resolve b()
main.o extracts a_b.a(a_b.o) to resolve a

Archive member extraction happens before --gc-sections, so this may not be a live path
under --gc-sections, but I think it is a good approximation in practice.

• Specifying a file avoids output interleaving with --verbose.
• Required = prevents accidental overwrite of an input if the user forgets =. (Most of compiler drivers' long options accept = but not )

[jhenderson]

Some conflicting thoughts:

1. Maybe this should be part of the --verbose (or possibly --trace) output?
2. If not doing the above, maybe it should be in a separate file?
3. If printing it to stdout is still desired, and not under another existing option, I think it might be better to group the output into one block somewhere. If you combine the new option with e.g. --verbose or --trace, I expect you'll get interleaved and potentially confusing output, esepcially as the table header will be divorced from the rest of the table content.

lld/test/ELF/why-extract.s

16–18

I'm not entirely sure what the right solution here is, but I think this output needs to be better tabulated, so that the columns line up (possibly with the exception of long names). Possibly alternatively, rather than using tabs to separate, how about some other symbol like ; or |?

[peter.smith]

Not had a chance to formulate a strong opinion yet, I think James has some interesting thoughts, but I expect a lot of this will come down to personal preference.

I can share the results of what Arm's proprietary linker does which has been useful. It essentially integrates this into the --verbose output, which does interleave with other verbose output but in this particular case it works out ok as it helps show where the reference and definitions are from each object. A hand edited example example, the library names are a little strange as they encode properties about the library for example .l is for little endian:

Selecting member vsnprintf.o(c_wfu.l) to define vsnprintf.
...
Loading member vsnprintf.o from c_wfu.l.
              definition:  vsnprintf
              reference :  _printf_a
               ...
Selecting member _printf_a.o(c_wfu.l) to define _printf_a.
...
Loading member _printf_a.o from c_wfu.l.
              definition:  _printf_a
              weak ref  :  _printf_fp_hex
              ...

While not complete as it only cites the first single symbol reference that is resolved by a library member, it can usually be used to trace back. The information is not tabulated so interleaving isn't as much of a problem.

[pcc]

I'm not sure this should be considered an alternative to D69607. Maybe it is if you're not using --gc-sections, but with that flag we really need something like a breadth-first search like in that patch.

[MaskRay]

In D109572#2994835, @pcc wrote:

I'm not sure this should be considered an alternative to D69607. Maybe it is if you're not using --gc-sections, but with that flag we really need something like a breadth-first search like in that patch.

Right, I removed the reference to D69607 (like ld64 -why_live). I didn't look closely at D69607. Indeed it is about --gc-sections. This is for the archive member output in GNU ld -M.

[MaskRay]

Change --why-extract= to be similar to --print-archive-stats=: use a file

[MaskRay]

Add manpage

[jhenderson]

lld/ELF/Driver.cpp

2198

We should consider adding an equivalent check to this area for the new file, for the same reason as the other cases.

lld/ELF/Symbols.cpp

326

This function may be a bit misnamed now, since it doesn't actually do any printing. Perhaps recordWhyExtract?

lld/test/ELF/why-extract.s

2

Maybe add a case where there was nothing used from an archive, to show that the file is still created, with the header.

15

I might suggest changing < why.txt to --input-file=why.txt, but it's entirely up to you. My motivation is that when using the PowerShell termainl, the < character is reserved and not used for stdin for some reason, which means you can't copy and paste this sort of line to aid in debugging.

[MaskRay]

comments

lld/test/ELF/why-extract.s

15

OK, that's why some FileCheck tests use --input-file=...

Most probably just consider this form more verbose than <, though...

Particularly in optimization and codegen test directories, opt < and llc < are really really common.

16–18

I pick \t because tsv files are common (awk one-linear just directly work on it without setting the field separator).

; or | separators are uncommon.

The terminal display probably doesn't matter that much?

[jhenderson]

LGTM, but please wait for someone else too.

lld/test/ELF/why-extract.s

15

Fortunately, I don't work with opt or llc very often :)

16–18

It's mostly about making the table pretty, because as things stand, the columns will regularly not line up. However, if you think the machine parsing support is more useful, that's fine by me.

[peter.smith]

LGTM too.

[smeenai]

Should there be a release notes entry for this? (Not sure if you prefer to add release notes in the diff itself or later after the corresponding release branch has been cut.)

[MaskRay]

• add a backward reference test
• add an entry to lld/docs/ReleaseNotes.rst

I'll wait one week before committing.

While not checking --gc-sections, I think this is a quite good approximation.
In the past, I have used a chain of -t and -y sym to dig such information.

[bd1976llvm]

Thanks for working on this. In the past I have resorted to hacking in my own ad-hoc versions of such features to solve particularly horrible dependency cases. As mentioned above there's a case for more powerful dependency tracking e.g. https://reviews.llvm.org/D69607. The more of these debugging features available the better IMO :)

[thakis]

(FYI: You likely know this but it's not mention further up: ld64.lld implements ld64's -why_load which I think does the same thing.)

[MaskRay]

In D109572#3047948, @thakis wrote:

(FYI: You likely know this but it's not mention further up: ld64.lld implements ld64's -why_load which I think does the same thing.)

(Yes, I checked ld64. I picked --why-extract= instead of --why-load= because extract (instead of load) is what Solaris ld and GNU ld's documentation say about archive member extraction.
There are 3 columns instead of 2 so that tracing a chain is easier. --whole-archive (-all_load) doesn't have dedicated output but it should be fine. Interleaved output of -why_load is another issue.)

lld/ELF/Config.h

struct Configuration {
   llvm::StringRef optRemarksFormat;
   llvm::StringRef progName;
   llvm::StringRef printArchiveStats;
   llvm::StringRef printSymbolOrder;
   llvm::StringRef soName;
   llvm::StringRef sysroot;
   llvm::StringRef thinLTOCacheDir;
   llvm::StringRef thinLTOIndexOnlyArg;
+  llvm::StringRef whyExtract;
   llvm::StringRef ltoBasicBlockSections;
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOObjectSuffixReplace;
   std::pair<llvm::StringRef, llvm::StringRef> thinLTOPrefixReplace;
   std::string rpath;
   std::vector<VersionDefinition> versionDefinitions;
   std::vector<llvm::StringRef> auxiliaryList;
   std::vector<llvm::StringRef> filterList;
   std::vector<llvm::StringRef> searchPaths;

lld/ELF/Driver.cpp

errorHandler().cleanupCallback = []() {
     outputSections.clear();
     archiveFiles.clear();
     binaryFiles.clear();
     bitcodeFiles.clear();
     lazyObjFiles.clear();
     objectFiles.clear();
     sharedFiles.clear();
     backwardReferences.clear();
+    whyExtract.clear();
 
     tar = nullptr;
     memset(&in, 0, sizeof(in));
 
     partitions = {Partition()};
 
     SharedFile::vernauxNum = 0;
   };
static void readConfigs(opt::InputArgList &args) {
   config->unique = args.hasArg(OPT_unique);
   config->useAndroidRelrTags = args.hasFlag(
       OPT_use_android_relr_tags, OPT_no_use_android_relr_tags, false);
   config->warnBackrefs =
       args.hasFlag(OPT_warn_backrefs, OPT_no_warn_backrefs, false);
   config->warnCommon = args.hasFlag(OPT_warn_common, OPT_no_warn_common, false);
   config->warnSymbolOrdering =
       args.hasFlag(OPT_warn_symbol_ordering, OPT_no_warn_symbol_ordering, true);
+  config->whyExtract = args.getLastArgValue(OPT_why_extract);
   config->zCombreloc = getZFlag(args, "combreloc", "nocombreloc", true);
   config->zCopyreloc = getZFlag(args, "copyreloc", "nocopyreloc", true);
   config->zForceBti = hasZOption(args, "force-bti");
   config->zForceIbt = hasZOption(args, "force-ibt");
   config->zGlobal = hasZOption(args, "global");
   config->zGnustack = getZGnuStack(args);
   config->zHazardplt = hasZOption(args, "hazardplt");
   config->zIfuncNoplt = hasZOption(args, "ifunc-noplt");
static void excludeLibs(opt::InputArgList &args) {
   for (InputFile *file : objectFiles)
     visit(file);
 
   for (BitcodeFile *file : bitcodeFiles)
     visit(file);
 }
 
 // Force Sym to be entered in the output.
-static void handleUndefined(Symbol *sym) {
+static void handleUndefined(Symbol *sym, const char *option) {
   // Since a symbol may not be used inside the program, LTO may
   // eliminate it. Mark the symbol as "used" to prevent it.
   sym->isUsedInRegularObj = true;
 
-  if (sym->isLazy())
-    sym->fetch();
+  if (!sym->isLazy())
+    return;
+  if (!config->whyExtract.empty())
+    whyExtract.emplace_back(option, sym->file, *sym);
 }
 
 // As an extension to GNU linkers, lld supports a variant of `-u`
 // which accepts wildcard patterns. All symbols that match a given
 // pattern are handled as if they were given by `-u`.
 static void handleUndefinedGlob(StringRef arg) {
   Expected<GlobPattern> pat = GlobPattern::create(arg);
   if (!pat) {
     error("--undefined-glob: " + toString(pat.takeError()));
     return;
   }
 
   std::vector<Symbol *> syms;
   for (Symbol *sym : symtab->symbols()) {
     // Calling Sym->fetch() from here is not safe because it may
     // add new symbols to the symbol table, invalidating the
     // current iterator. So we just keep a note.
     if (pat->match(sym->getName()))
       syms.push_back(sym);
   }
 
   for (Symbol *sym : syms)
-    handleUndefined(sym);
+    handleUndefined(sym, "--undefined-glob");
 }
 
 static void handleLibcall(StringRef name) {
   Symbol *sym = symtab->find(name);
   if (!sym || !sym->isLazy())
     return;
 
   MemoryBufferRef mb;
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
   // Fail early if the output file or map file is not writable. If a user has a
   // long link, e.g. due to a large LTO link, they do not wish to run it and
   // find that it failed because there was a mistake in their command-line.
   {
     llvm::TimeTraceScope timeScope("Create output files");
     if (auto e = tryCreateFile(config->outputFile))
       error("cannot open output file " + config->outputFile + ": " +
             e.message());
     if (auto e = tryCreateFile(config->mapFile))
       error("cannot open map file " + config->mapFile + ": " + e.message());
+    if (auto e = tryCreateFile(config->whyExtract))
+      error("cannot open --why-extract= file " + config->whyExtract + ": " +
+            e.message());
   }
   if (errorCount())
     return;
 
   // Use default entry point name if no name was given via the command
   // line nor linker scripts. For some reason, MIPS entry point name is
   // different from others.
   config->warnMissingEntry =
template <class ELFT> void LinkerDriver::link(opt::InputArgList &args) {
 
   // Prevent LTO from removing any definition referenced by -u.
   for (StringRef name : config->undefined)
     if (Defined *sym = dyn_cast_or_null<Defined>(symtab->find(name)))
       sym->isUsedInRegularObj = true;
 
   // If an entry symbol is in a static archive, pull out that file now.
   if (Symbol *sym = symtab->find(config->entry))
-    handleUndefined(sym);
+    handleUndefined(sym, "--entry");
 
   // Handle the `--undefined-glob <pattern>` options.
   for (StringRef pat : args::getStrings(args, OPT_undefined_glob))
     handleUndefinedGlob(pat);
 
   // Mark -init and -fini symbols so that the LTO doesn't eliminate them.
   if (Symbol *sym = dyn_cast_or_null<Defined>(symtab->find(config->init)))
     sym->isUsedInRegularObj = true;

lld/ELF/MapFile.h

 //===- MapFile.h ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_MAPFILE_H
 #define LLD_ELF_MAPFILE_H
 
 namespace lld {
 namespace elf {
 void writeMapFile();
+void writeWhyExtract();
 void writeCrossReferenceTable();
 void writeArchiveStats();
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/MapFile.cpp

for (BaseCommand *base : osec->sectionCommands) {
                     cmd->size, 1);
         os << indent8 << cmd->commandString << '\n';
         continue;
       }
     }
   }
 }
 
+void elf::writeWhyExtract() {
+  if (config->whyExtract.empty())
+    return;
+
+  std::error_code ec;
+  raw_fd_ostream os(config->whyExtract, ec, sys::fs::OF_None);
+  if (ec) {
+    error("cannot open --why-extract= file " + config->whyExtract + ": " +
+          ec.message());
+    return;
+  }
+
+  os << "reference\textracted\tsymbol\n";
+  for (auto &entry : whyExtract) {
+    os << std::get<0>(entry) << '\t' << toString(std::get<1>(entry)) << '\t'
+       << toString(std::get<2>(entry)) << '\n';
+  }
+}
+
 static void print(StringRef a, StringRef b) {
   lld::outs() << left_justify(a, 49) << " " << b << "\n";
 }
 
 // Output a cross reference table to stdout. This is for --cref.
 //
 // For each global symbol, we print out a file that defines the symbol
 // followed by files that uses that symbol. Here is an example.

lld/ELF/Options.td

 
 def warn_unresolved_symbols: F<"warn-unresolved-symbols">,
   HelpText<"Report unresolved symbols as warnings">;
 
 defm whole_archive: B<"whole-archive",
     "Force load of all members in a static library",
     "Do not force load of all members in a static library (default)">;
 
+def why_extract: JJ<"why-extract=">, HelpText<"Print to a file about why archive members are extracted">;
+
 defm wrap : Eq<"wrap", "Redirect symbol references to __wrap_symbol and "
                        "__real_symbol references to symbol">,
             MetaVarName<"<symbol>">;
 
 def z: JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
 def visual_studio_diagnostics_format : F<"vs-diagnostics">,

lld/ELF/Symbols.h

 
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "lld/Common/LLVM.h"
 #include "lld/Common/Strings.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.

 void reportBackrefs();
 
 // A mapping from a symbol to an InputFile referencing it backward. Used by
 // --warn-backrefs.
 extern llvm::DenseMap<const Symbol *,
                       std::pair<const InputFile *, const InputFile *>>
     backwardReferences;
 
+// A tuple of (reference, extractedFile, sym). Used by --why-extract=.
+extern SmallVector<std::tuple<std::string, const InputFile *, const Symbol &>,
+                   0>
+    whyExtract;
+
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/Symbols.cpp

 Defined *ElfSym::mipsGpDisp;
 Defined *ElfSym::mipsLocalGp;
 Defined *ElfSym::relaIpltStart;
 Defined *ElfSym::relaIpltEnd;
 Defined *ElfSym::riscvGlobalPointer;
 Defined *ElfSym::tlsModuleBase;
 DenseMap<const Symbol *, std::pair<const InputFile *, const InputFile *>>
     elf::backwardReferences;
+SmallVector<std::tuple<std::string, const InputFile *, const Symbol &>, 0>
+    elf::whyExtract;
 
 static uint64_t getSymVA(const Symbol &sym, int64_t &addend) {
   switch (sym.kind()) {
   case Symbol::DefinedKind: {
     auto &d = cast<Defined>(sym);
     SectionBase *isec = d.section;
 
     // This is an absolute symbol.
void elf::printTraceSymbol(const Symbol *sym) {
   else if (sym->isCommon())
     s = ": common definition of ";
   else
     s = ": definition of ";
 
   message(toString(sym->file) + s + sym->getName());
 }
 
+static void recordWhyExtract(const InputFile *reference,
+                             const InputFile &extracted, const Symbol &sym) {
+  whyExtract.emplace_back(toString(reference), &extracted, sym);
+}
+
 void elf::maybeWarnUnorderableSymbol(const Symbol *sym) {
   if (!config->warnSymbolOrdering)
     return;
 
   // If UnresolvedPolicy::Ignore is used, no "undefined symbol" error/warning
   // is emitted. It makes sense to not warn on undefined symbols.
   //
   // Note, ld.bfd --symbol-ordering-file= does not warn on undefined symbols,
if (isLazy()) {
     //
     // A forms group 0. B form group 1. C and D (including their member object
     // files) form group 2. E forms group 3. I think that you can see how this
     // group assignment rule simulates the traditional linker's semantics.
     bool backref = config->warnBackrefs && other.file &&
                    file->groupId < other.file->groupId;
     fetch();
 
+    if (!config->whyExtract.empty())
+      recordWhyExtract(other.file, *file, *this);
+
     // We don't report backward references to weak symbols as they can be
     // overridden later.
     //
     // A traditional linker does not error for -ldef1 -lref -ldef2 (linking
     // sandwich), where def2 may or may not be the same as def1. We don't want
     // to warn for this case, so dismiss the warning if we see a subsequent lazy
     // definition. this->file needs to be saved because in the case of LTO it
     // may be reset to nullptr or be replaced with a file named lto.tmp.
template <class LazyT> void Symbol::resolveLazy(const LazyT &other) {
   if (isWeak()) {
     uint8_t ty = type;
     replace(other);
     type = ty;
     binding = STB_WEAK;
     return;
   }
 
+  const InputFile *oldFile = file;
   other.fetch();
+  if (!config->whyExtract.empty())
+    recordWhyExtract(oldFile, *file, *this);
 }
 
 void Symbol::resolveShared(const SharedSymbol &other) {
   if (isCommon()) {
     // See the comment in resolveCommon() above.
     if (other.size > cast<CommonSymbol>(this)->size)
       cast<CommonSymbol>(this)->size = other.size;
     return;

lld/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::run() {
 
   for (Partition &part : partitions)
     setPhdrs(part);
 
   if (config->relocatable)
     for (OutputSection *sec : outputSections)
       sec->addr = 0;
 
-  // Handle --print-map(-M)/--Map, --cref and --print-archive-stats=. Dump them
-  // before checkSections() because the files may be useful in case
-  // checkSections() or openFile() fails, for example, due to an erroneous file
-  // size.
+  // Handle --print-map(-M)/--Map, --why-extract=, --cref and
+  // --print-archive-stats=. Dump them before checkSections() because the files
+  // may be useful in case checkSections() or openFile() fails, for example, due
+  // to an erroneous file size.
   writeMapFile();
+  writeWhyExtract();
   writeCrossReferenceTable();
   writeArchiveStats();
 
   if (config->checkSections)
     checkSections();
 
   // It does not make sense try to open the file if we have error already.
   if (errorCount())

lld/docs/ReleaseNotes.rst

 Non-comprehensive list of changes in this release
 =================================================
 
 ELF Improvements
 ----------------
 
 * ``--export-dynamic-symbol-list`` has been added.
   (`D107317 <https://reviews.llvm.org/D107317>`_)
+* ``--why-extract`` has been added to query why archive members/lazy object files are extracted.
+  (`D109572 <https://reviews.llvm.org/D109572>`_)
 * ``e_entry`` no longer falls back to the address of ``.text`` if the entry symbol does not exist.
   Instead, a value of 0 will be written.
   (`D110014 <https://reviews.llvm.org/D110014>`_)
 
 Breaking changes
 ----------------
 
 * ...

lld/docs/ld.lld.1

 Otherwise, there is no need to use it, as the default value does not give a
 warning.
 This flag has been introduced in late 2018, has no counter part in ld and gold
 linkers, and may be removed in the future.
 .It Fl -warn-unresolved-symbols
 Report unresolved symbols as warnings.
 .It Fl -whole-archive
 Force load of all members in a static library.
+.It Fl -why-extract Ns = Ns Ar file
+Print to a file about why archive members are extracted.
 .It Fl -wrap Ns = Ns Ar symbol
 Redirect
 .Ar symbol
 references to
 .Ar __wrap_symbol
 and
 .Ar __real_symbol
 references to

lld/test/ELF/why-extract.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t && split-file %s %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/main.s -o %t/main.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a.s -o %t/a.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/a_b.s -o %t/a_b.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64 %t/b.s -o %t/b.o
+# RUN: llvm-ar rc %t/a.a %t/a.o
+# RUN: llvm-ar rc %t/a_b.a %t/a_b.o
+# RUN: llvm-ar rc %t/b.a %t/b.o
+# RUN: cd %t
+
+## Nothing is extracted from an archive. The file is created with just a header.
+# RUN: ld.lld main.o a.o b.a -o /dev/null --why-extract=why1.txt
+# RUN: FileCheck %s --input-file=why1.txt --check-prefix=CHECK1 --match-full-lines --strict-whitespace
+
+#      CHECK1:reference extracted symbol
+#  CHECK1-NOT:{{.}}
+
+## Some archive members are extracted.
+# RUN: ld.lld main.o a_b.a b.a -o /dev/null --why-extract=why2.txt
+# RUN: FileCheck %s --input-file=why2.txt --check-prefix=CHECK2 --match-full-lines --strict-whitespace
+
+#      CHECK2:reference extracted symbol
+# CHECK2-NEXT:main.o  a_b.a(a_b.o)  a
+# CHECK2-NEXT:a_b.a(a_b.o)  b.a(b.o)  b()
+
+## Check that backward references are supported.
+## - means stdout.
+# RUN: ld.lld b.a a_b.a main.o -o /dev/null --why-extract=- | FileCheck %s --check-prefix=CHECK3
+
+#      CHECK3:reference extracted symbol
+# CHECK3-NEXT:a_b.a(a_b.o)  b.a(b.o)  b()
+# CHECK3-NEXT:main.o  a_b.a(a_b.o)  a
+
+# RUN: ld.lld main.o a_b.a b.a -o /dev/null --no-demangle --why-extract=- | FileCheck %s --check-prefix=MANGLED
+
+# MANGLED: a_b.a(a_b.o) b.a(b.o)  _Z1bv
+
+# RUN: ld.lld main.o a.a b.a -o /dev/null -u _Z1bv --why-extract=- | FileCheck %s --check-prefix=UNDEFINED
+
+## We insert -u symbol before processing other files, so its name is <internal>.
+## This is not ideal.
+# UNDEFINED: <internal> b.a(b.o)  b()
+
+# RUN: ld.lld main.o a.a b.a -o /dev/null --undefined-glob '_Z1b*' --why-extract=- | FileCheck %s --check-prefix=UNDEFINED_GLOB
+
+# UNDEFINED_GLOB: --undefined-glob  b.a(b.o)  b()
+
+# RUN: ld.lld main.o a.a b.a -o /dev/null -e _Z1bv --why-extract=- | FileCheck %s --check-prefix=ENTRY
+
+# ENTRY: --entry  b.a(b.o)  b()
+
+# RUN: ld.lld main.o b.a -o /dev/null -T a.lds --why-extract=- | FileCheck %s --check-prefix=SCRIPT
+
+# SCRIPT: <internal>  b.a(b.o)  b()
+
+# RUN: ld.lld main.o --start-lib a_b.o b.o --end-lib -o /dev/null --why-extract=- | FileCheck %s --check-prefix=LAZY
+
+# LAZY: main.o  a_b.o a
+# LAZY: a_b.o b.o b()
+
+# RUN: not ld.lld -shared main.o -o /dev/null --why-extract=/ 2>&1 | FileCheck %s --check-prefix=ERR
+
+# ERR: error: cannot open --why-extract= file /: {{.*}}
+
+#--- main.s
+.globl _start
+_start:
+  call a
+
+#--- a.s
+.globl a
+a:
+
+#--- a_b.s
+.globl a
+a:
+  call _Z1bv
+
+#--- b.s
+.globl _Z1bv
+_Z1bv:
+
+#--- a.lds
+a = _Z1bv;