[lld] support --trace-symbol (alias -y) option

[• joshishr]

Summary

I have implemented "--trace-symbol=symbol" (alias -y symbol) option.

This option provides names of all the link time modules which define and reference symbols requested by user. This helps to speed up application development by detecting references causing undefined symbols. It also helps in detecting symbols being resolved to wrong (unintended) definitions in case of applications containing multiple definitions for same symbols with different types, bindings.

Implementation contains symbols from object files, shared and archive libraries and executable.

Bugzilla - Bug - PR#28226

subversion revision in lld trunk on which this patch is created: #273248

Patch by Shridhar Joshi

[ruiu]

ELF/Config.h

70

Use StringSet<> instead. I'd name this TraceSymbol since all members in Config class are named after their corresponding command line options.

ELF/Driver.cpp

420

Remove {}

423

Define -y as an alias to --trace-symbol in Options.td instead of handling the two as different options.

ELF/Error.cpp

53 ↗

(On Diff #61347)

No need to define this function -- just print out to out().

ELF/InputFiles.cpp

318

This generic name is overkill. I'd define two functions

void ObjectFile<ELFT>::traceDefined(StringRef Name);
void ObjectFile<ELFT>::traceUndefined(StringRef Name);

where traceDefined prints out "definition of" message and traceUndefined prints out "reference to" message, and call them from ObjectFile<ELFT>::createSymbolBody.

ELF/Options.td

171

"Trace references to symbol"

ELF/SymbolTable.cpp

348–349

Remove.

test/ELF/trace-symbols.s

2

Insert blank lines to separate this file in meaningful blocks. Wrap in 80 columns.

[ruiu]

Noticed that there's a better way to print out "definition of" messages.

First, just add traceUndefined member function to ObjectFile and print out "reference to" messages if a given string is a member of Config->TraceSymbol.

And then define traceSymbol member function to SymbolTable. That function should iterate over all strings in Config->TraceSymbol. For each string, it looks up a defined symbol, and if it is defined, it prints out a "definition of" message. SymbolTable has scan* functions, and they are good examples how to do it.

In this way, I think code for --trace-symbol would be separated nicely from the main code.

[grimar]

ELF/InputFiles.cpp

316

Comments should be started from uppercase and ended with dot.

test/ELF/Inputs/trace-symbols-foo-global.s

22 ↗

(On Diff #61347)

I think this file contains too much excessive data for test. Like file name, .ident and asm code.
Can you cleanup this ?

[• joshishr]

In D21550#463069, @ruiu wrote:

Noticed that there's a better way to print out "definition of" messages.

First, just add traceUndefined member function to ObjectFile and print out "reference to" messages if a given string is a member of Config->TraceSymbol.

This will not address references from shared file.

And then define traceSymbol member function to SymbolTable. That function should iterate over all strings in Config->TraceSymbol. For each string, it looks up a defined symbol, and if it is defined, it prints out a "definition of" message. SymbolTable has scan* functions, and they are good examples how to do it.

In this way, I think code for --trace-symbol would be separated nicely from the main code.

This will not address symbol defined in different object files with strong and weak bindings and with different link order of those object files. It also will not address same symbol defined in archive and shared library with archive library being first in link order.

ELF/SymbolTable.cpp

348–349

This is required to print object files names containing weak and strong definitions as below.
main.o references foo function
foo-weak.o contains weak definition of foo
foo-strong.o contains strong definition of foo

$ld.lld --trace-symbol=foo main.o foo-weak.o foo-strong.o
main.o: reference to foo
foo-weak.o: definition of foo
foo-strong.o: definition of foo

now if the link order of foo-weak.o and foo-strong.o is changed then:
$ld.lld --trace-symbol=foo main.o foo-strong.o foo-weak.o
main.o: reference to foo
foo-strong.o: definition of foo

Please note it has not print "foo-weak.o definition of foo"

[• joshishr]

Incorporated review comments.

[• rafael]

Please also add a test with --start-lib/--end-lib.

ELF/InputFiles.cpp

322

This is duplicated with elf::getFilename(InputFile *F).

326

I don't think you need the llvm:: prefix.

341

Can you share a bit more code with traceDefined?

384

Don't you want to trace this?

537

Do you really want to trace this? It is not a "real" undefined symbol. We will not fetch archive members or report an error for it.

[ruiu]

ELF/Config.h

70

As you can see, the members of this class are sorted alphabetically. So, move this right after llvm::StringRef Sysroot.

ELF/InputFiles.cpp

318

StringRef is a small object (containing two pointers) and usually passed by value. Remove &.

319

Guard this with

if (Config->TraceSymbol.empty() || !Config->TraceSymbol.count(Name))
  return;

Because empty() is going to be inlined, the first expression is compiled to two machine instructions. On the other hand, I believe count() is expensive.

320

Do not construct a string to print it out because it's needlessly slow. You can print it out directly to outs().

537

Agreed. That's why I asked to define traceUndefined to ObjectFile instead of InputFile since the class is the only class that needs the method.

ELF/Options.td

167

Please rebase this patch and use J macro.

ELF/SymbolTable.cpp

348–349

I don't think we need to print out weak symbols that are not linked to the resulting executable. We are trying hard to minimize the amount of code that's executed for each symbol, so I don't want to add new code here. Please iterate only over symbols passed as --trace-symbol arguments instead of iterating over all symbols in all input files.

test/ELF/trace-symbols.s

5

We usually indent continued lines with two spaces.

11–12

We usually group a test command and its expected result as one block, instead of writing all commands at beginning of file and all CHECK conditions at end of file.

[• joshishr]

In D21550#463636, @rafael wrote:

Please also add a test with --start-lib/--end-lib.

Added.

ELF/InputFiles.cpp

384

It was traced inside addRegular to distinguish between weak and strong symbol. In updated patch it is handled in SymbolTable.

537

This was required to print undefined symbols from shared library and not from archive members.
For e.g. main calls foo() defined in libfoo.so and this foo() calls bar() defined in libbar.so. this call to traceUndefined() was required to print reference to bar(). Anyway i have removed it in updated patch and so updated patch does not report references from shared library.

Anyway if you think this is required and we should also move traceUndefined() to ObjectFile then also we can report this using Undefs inside SymbolTable. But then we have to rename traceDefined() as it will handle undefined symbols from shared library as well as defined symbols from object files, shared and archive libraries.

Please confirm.

ELF/SymbolTable.cpp

348–349

With traceDefined() moved to SymbolTable class, there is change in behaviour:

1. Definition to weak function will not be printed even if the object file or shared shared library defining it comes before in the link order than object file or shared library defining the same symbol strong.
2. Definition of common symbols from object files and archive library will not be printed but common symbols from shared library will be printed. This looks like because DefinedCommon class does not contain source file information.

[• joshishr]

Moved trace* functions out of core symbol resolution code. Incorporated more review comments.

[ruiu]

Thank you for making the changes. Almost looking good, a few nits.

Do you have a commit access?

ELF/Driver.cpp

514

What this function does is similar to scan* functions, so move this after scanVersionScript.

ELF/InputFiles.cpp

321

outs() knows how to print out StringRefs, so remove .str().

ELF/SymbolTable.cpp

548

Let's name B instead of L since it is a sort of convention in LLD.

[• joshishr]

In D21550#465268, @ruiu wrote:

Thank you for making the changes. Almost looking good, a few nits.

Do you have a commit access?

Incorporated all review comments.

No i don't have commit access. I will apply to get commit access.
For now, if no issue please check it in.

[• joshishr]

Incorporated all review comments and created updated patch.

subversion revision in lld trunk on which this patch is created: #273532

[ruiu]

Submitted as 273536.

[• joshishr]

In D21550#465360, @ruiu wrote:

Submitted as 273536.

Thank you
-Shridhar Joshi

ELF/Config.h

 //===- Config.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_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSet.h"
 #include "llvm/Support/ELF.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf {
 
 class InputFile;
struct Configuration {
   llvm::StringRef Emulation;
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef LtoAAPipeline;
   llvm::StringRef LtoNewPmPasses;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
+  llvm::StringSet<> TraceSymbol;
   std::string RPath;
   std::vector<Version> SymbolVersions;
   std::vector<llvm::StringRef> DynamicList;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
   std::vector<llvm::StringRef> VersionScriptGlobals;
   std::vector<uint8_t> BuildIdVector;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
   bool BsymbolicFunctions;
   bool Demangle = true;
   bool DisableVerify;
   bool DiscardAll;
   bool DiscardLocals;

ELF/Driver.cpp

void LinkerDriver::readConfigs(opt::InputArgList &Args) {
 
   for (auto *Arg : Args.filtered(OPT_export_dynamic_symbol))
     Config->DynamicList.push_back(Arg->getValue());
 
   if (auto *Arg = Args.getLastArg(OPT_version_script)) {
     if (Optional<MemoryBufferRef> Buffer = readFile(Arg->getValue()))
       parseVersionScript(*Buffer);
   }
+
+  for (auto *Arg : Args.filtered(OPT_trace_symbol))
+    Config->TraceSymbol.insert(Arg->getValue());
 }
 
 void LinkerDriver::createFiles(opt::InputArgList &Args) {
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:
       addLibrary(Arg->getValue());
       break;
     case OPT_alias_script_T:
for (std::unique_ptr<InputFile> &F : Files)
     Symtab.addFile(std::move(F));
   if (HasError)
     return; // There were duplicate symbols or incompatible files
 
   Symtab.scanUndefinedFlags();
   Symtab.scanShlibUndefined();
   Symtab.scanDynamicList();
   Symtab.scanVersionScript();
+  Symtab.traceDefined();
 
   Symtab.addCombinedLtoObject();
   if (HasError)
     return;
 
   for (auto *Arg : Args.filtered(OPT_wrap))
     Symtab.wrap(Arg->getValue());
 
   // Write the result to the file.
   if (Config->GcSections)
     markLive<ELFT>();
   if (Config->ICF)
     doIcf<ELFT>();
 
   // MergeInputSection::splitIntoPieces needs to be called before
   // any call of MergeInputSection::getOffset. Do that.
   for (const std::unique_ptr<elf::ObjectFile<ELFT>> &F :
        Symtab.getObjectFiles())
     for (InputSectionBase<ELFT> *S : F->getSections())
       if (S && S != &InputSection<ELFT>::Discarded && S->Live)
         if (auto *MS = dyn_cast<MergeInputSection<ELFT>>(S))
           MS->splitIntoPieces();
 
   writeResult<ELFT>(&Symtab);
 }

ELF/InputFiles.h

public:
 
   template <typename RelT> SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }
 
   const Elf_Shdr *getSymbolTable() const { return this->Symtab; };
 
+  void traceUndefined(StringRef Name);
+
   // Get MIPS GP0 value defined by this file. This value represents the gp value
   // used to create the relocatable object and required to support
   // R_MIPS_GPREL16 / R_MIPS_GPREL32 relocations.
   uint32_t getMipsGp0() const;
 
   // The number is the offset in the string table. It will be used as the
   // st_name of the symbol.
   std::vector<std::pair<const DefinedRegular<ELFT> *, unsigned>> KeptLocalSyms;

ELF/InputFiles.cpp

elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec) {
   // output was choosen. Proccess them as usual input sections.
   if (!Config->Relocatable && Name == ".eh_frame")
     return new (EHAlloc.Allocate()) EhInputSection<ELFT>(this, &Sec);
   if (shouldMerge<ELFT>(Sec))
     return new (MAlloc.Allocate()) MergeInputSection<ELFT>(this, &Sec);
   return new (IAlloc.Allocate()) InputSection<ELFT>(this, &Sec);
 }
 
+// Print the module names which reference the notified
+// symbols provided through -y or --trace-symbol option.
+template <class ELFT> 
+void elf::ObjectFile<ELFT>::traceUndefined(StringRef Name) {
+  if (!Config->TraceSymbol.empty() && Config->TraceSymbol.count(Name))
+    outs() << getFilename(this) << ": reference to " << Name << "\n";
+}
+
 template <class ELFT> void elf::ObjectFile<ELFT>::initializeSymbols() {
   this->initStringTable();
   Elf_Sym_Range Syms = this->getElfSymbols(false);
   uint32_t NumSymbols = std::distance(Syms.begin(), Syms.end());
   SymbolBodies.reserve(NumSymbols);
   for (const Elf_Sym &Sym : Syms)
     SymbolBodies.push_back(createSymbolBody(&Sym));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index == 0)
     return nullptr;
   if (Index >= Sections.size() || !Sections[Index])
     fatal("invalid section index");
   InputSectionBase<ELFT> *S = Sections[Index];
   if (S == &InputSectionBase<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   unsigned char Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
   if (Binding == STB_LOCAL) {
     if (Sym->st_shndx == SHN_UNDEF)
       return new (Alloc) Undefined(Sym->st_name, Sym->st_other, Sym->getType());
     return new (Alloc) DefinedRegular<ELFT>(*Sym, Sec);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable));
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
+    traceUndefined(Name);
     return elf::Symtab<ELFT>::X
         ->addUndefined(Name, Binding, Sym->st_other, Sym->getType(),
                        /*CanOmitFromDynSym*/ false, this)
         ->body();
   case SHN_COMMON:
     return elf::Symtab<ELFT>::X
         ->addCommon(Name, Sym->st_size, Sym->st_value, Binding, Sym->st_other,
                     Sym->getType(), this)
         ->body();
   }
 
   switch (Binding) {
   default:
     fatal("unexpected binding");
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE:
     if (Sec == &InputSection<ELFT>::Discarded)
       return elf::Symtab<ELFT>::X
           ->addUndefined(Name, Binding, Sym->st_other, Sym->getType(),
                          /*CanOmitFromDynSym*/ false, this)
           ->body();
     return elf::Symtab<ELFT>::X->addRegular(Name, *Sym, Sec)->body();
   }
 }
 
 template <class ELFT> void ArchiveFile::parse() {
   File = check(Archive::create(MB), "failed to parse archive");
 
   // Read the symbol table to construct Lazy objects.
   for (const Archive::Symbol &Sym : File->symbols())
for (const Elf_Sym &Sym : Syms) {
     unsigned VersymIndex = 0;
     if (Versym) {
       VersymIndex = Versym->vs_index;
       ++Versym;
     }
 
     StringRef Name = check(Sym.getName(this->StringTable));
     if (Sym.isUndefined()) {
       Undefs.push_back(Name);
       continue;
     }
 
     if (Versym) {
       // Ignore local symbols and non-default versions.
       if (VersymIndex == VER_NDX_LOCAL || (VersymIndex & VERSYM_HIDDEN))
         continue;
     }

ELF/Options.td

def whole_archive: F<"whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 def wrap: S<"wrap">, MetaVarName<"<symbol>">,
   HelpText<"Use wrapper functions for symbol">;
 
 def z: JS<"z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
+def trace_symbol : J<"trace-symbol=">, HelpText<"Trace references to symbols">;
+
 // Aliases
 def alias_Bdynamic_call_shared: F<"call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: F<"dy">, Alias<Bdynamic>;
 def alias_Bstatic_dn: F<"dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: F<"non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: F<"static">, Alias<Bstatic>;
 def alias_L__library_path: J<"library-path=">, Alias<L>;
 def alias_discard_all_x: F<"x">, Alias<discard_all>;
 def alias_discard_locals_X: F<"X">, Alias<discard_locals>;
 def alias_dynamic_list: J<"dynamic-list=">, Alias<dynamic_list>;
 def alias_entry_e: JS<"e">, Alias<entry>;

 def alias_shared_Bshareable: F<"Bshareable">, Alias<shared>;
 def alias_soname_h: JS<"h">, Alias<soname>;
 def alias_soname_soname: S<"soname">, Alias<soname>;
 def alias_strip_all: F<"s">, Alias<strip_all>;
 def alias_strip_debug_S: F<"S">, Alias<strip_debug>;
 def alias_trace: F<"t">, Alias<trace>;
 def alias_undefined_u: JoinedOrSeparate<["-"], "u">, Alias<undefined>;
 def alias_wrap_wrap: J<"wrap=">, Alias<wrap>;
+def alias_trace_symbol_y : JS<"y">, Alias<trace_symbol>;
 
 // Our symbol resolution algorithm handles symbols in archive files differently
 // than traditional linkers, so we don't need --start-group and --end-group.
 // These options are recongized for compatibility but ignored.
 def end_group: F<"end-group">;
 def end_group_paren: F<")">;
 def start_group: F<"start-group">;
 def start_group_paren: F<"(">;

ELF/SymbolTable.h

Symbol *addCommon(StringRef N, uint64_t Size, uint64_t Alignment,
                     InputFile *File);
 
   void scanUndefinedFlags();
   void scanShlibUndefined();
   void scanDynamicList();
   void scanVersionScript();
   SymbolBody *find(StringRef Name);
   void wrap(StringRef Name);
+  void traceDefined();
 
 private:
   std::pair<Symbol *, bool> insert(StringRef Name);
   std::pair<Symbol *, bool> insert(StringRef Name, uint8_t Type,
                                    uint8_t Visibility, bool CanOmitFromDynSym,
                                    bool IsUsedInRegularObj, InputFile *File);
 
   std::string conflictMsg(SymbolBody *Existing, InputFile *NewFile);

ELF/SymbolTable.cpp

Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, const Elf_Sym &Sym,
                                       InputSectionBase<ELFT> *Section) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Sym.getType(), Sym.getVisibility(),
              /*CanOmitFromDynSym*/ false, /*IsUsedInRegularObj*/ true,
              Section ? Section->getFile() : nullptr);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Sym.getBinding());
   if (Cmp > 0)
     replaceBody<DefinedRegular<ELFT>>(S, Name, Sym, Section);
   else if (Cmp == 0)
     reportDuplicate(S->body(), Section->getFile());
   return S;
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t Binding,
                                       uint8_t StOther) {
for (StringRef Name : V.Globals)
             B->symbol()->VersionId != VER_NDX_LOCAL)
           error("duplicate symbol " + Name + " in version script");
         B->symbol()->VersionId = I;
       }
     ++I;
   }
 }
 
+// Print the module names which define the notified
+// symbols provided through -y or --trace-symbol option.
+template <class ELFT> void SymbolTable<ELFT>::traceDefined() {
+  for (const auto &symbol : Config->TraceSymbol) {
+    if (SymbolBody *B = find(symbol.getKey()))
+      if (B->isDefined() || B->isCommon())
+        if (InputFile *File = B->getSourceFile<ELFT>())
+          outs() << getFilename(File) << ": definition of " 
+                 << B->getName() << "\n";
+  }
+}
+
 template class elf::SymbolTable<ELF32LE>;
 template class elf::SymbolTable<ELF32BE>;
 template class elf::SymbolTable<ELF64LE>;
 template class elf::SymbolTable<ELF64BE>;

test/ELF/Inputs/trace-symbols-foo-strong.s

+.text
+.globl  foo
+.type foo, @function
+foo:
+nop
+
+.globl  bar
+.type bar, @function
+bar:
+nop
+
+.global func2
+.type   func2, @function
+func2:

test/ELF/Inputs/trace-symbols-foo-weak.s

+.comm common,4,4
+.text
+.weak foo
+.type foo, @function
+foo:
+callq bar@PLT
+
+.globl  func1
+.type   func1, @function
+func1:
+call func2@PLT
+

test/ELF/trace-symbols.s

+# Test -y symbol and -trace-symbol=symbol
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux  \
+# RUN: %p/Inputs/trace-symbols-foo-weak.s -o %t1
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux  \
+# RUN: %p/Inputs/trace-symbols-foo-strong.s -o %t2
+# RUN: ld.lld -shared %t1 -o %t1.so
+# RUN: ld.lld -shared %t2 -o %t2.so
+# RUN: ar -r %t1.a %t1
+# RUN: ar -r %t2.a %t2 
+
+# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol  \
+# RUN: %t %t1 %t2 -o %t3 2>&1 | FileCheck -check-prefix=OBJECTRFOO %s
+# OBJECTRFOO: trace-symbols.s.tmp: reference to foo
+
+# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol  \ 
+# RUN: %t %t1 %t2 -o %t3 2>&1 | not FileCheck -check-prefix=OBJECTDCOMMON %s
+# OBJECTDCOMMON: trace-symbols.s.tmp1: definition of common
+
+# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol  \
+# RUN: %t %t1 %t2 -o %t3 2>&1 | not FileCheck -check-prefix=OBJECTD1FOO %s
+# RUN: ld.lld -y foo -y common %t %t2 %t1 -o %t3 2>&1 | not FileCheck  \
+# RUN: -check-prefix=OBJECTD1FOO %s
+# OBJECTD1FOO: trace-symbols.s.tmp1: definition of foo
+
+# RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol  \
+# RUN: %t %t1 %t2 -o %t3 2>&1 | FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN: ld.lld -y foo -y common --trace-symbol=hsymbol  \
+# RUN: %t %t2 %t1 -o %t4 2>&1 | FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 2>&1 |  \
+# RUN: FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o %t3 2>&1 |  \
+# RUN: FileCheck -check-prefix=OBJECTD2FOO %s
+# OBJECTD2FOO: trace-symbols.s.tmp2: definition of foo
+
+# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 2>&1 |  \
+# RUN: FileCheck -check-prefix=SHLIBDCOMMON %s
+# SHLIBDCOMMON: trace-symbols.s.tmp1.so: definition of common
+
+# RUN: ld.lld -y foo -y common %t %t1.so %t2 -o %t3 2>&1 |  \
+# RUN: not FileCheck -check-prefix=SHLIBD1FOO %s
+# RUN: ld.lld -y foo -y common %t %t1.so %t2.so -o %t3 2>&1 |  \
+# RUN: FileCheck -check-prefix=SHLIBD1FOO %s
+# RUN: ld.lld -y foo %t %t1.so %t2.a -o %t3 |  \
+# RUN: FileCheck -check-prefix=SHLIBD1FOO %s
+# SHLIBD1FOO: trace-symbols.s.tmp1.so: definition of foo
+
+# RUN: ld.lld -y foo -y common %t %t2.so %t1.so -o %t3 2>&1 |  \
+# RUN: FileCheck -check-prefix=SHLIBD2FOO %s
+# RUN: ld.lld -y foo %t %t1.a %t2.so -o %t3 |  \
+# RUN: not FileCheck -check-prefix=SHLIBD2FOO %s
+# SHLIBD2FOO: trace-symbols.s.tmp2.so: definition of foo
+
+# RUN: ld.lld -y foo -y common %t %t2 %t1.a -o %t3 2>&1 |  \
+# RUN: not FileCheck -check-prefix=ARCHIVEDCOMMON %s
+# ARCHIVEDCOMMON: trace-symbols.s.tmp1.a(trace-symbols.s.tmp1): definition of \
+# common
+
+# RUN: ld.lld -y foo %t %t1.a %t2.so -o %t3 |  \
+# RUN: FileCheck -check-prefix=ARCHIVED1FOO %s
+# ARCHIVED1FOO: trace-symbols.s.tmp1.a(trace-symbols.s.tmp1): definition of foo
+
+# RUN: ld.lld -y foo %t %t1.a %t2.a -o %t3 |  \
+# RUN: FileCheck -check-prefix=ARCHIVED2FOO %s
+# ARCHIVED2FOO: trace-symbols.s.tmp2.a(trace-symbols.s.tmp2): definition of foo
+
+# RUN: ld.lld -y bar %t %t1.so %t2.so -o %t3 |  \
+# RUN: FileCheck -check-prefix=SHLIBDBAR %s
+# SHLIBDBAR: trace-symbols.s.tmp2.so: definition of bar
+
+# RUN: ld.lld -y foo -y bar %t %t1.so %t2.so -o %t3 |  \
+# RUN: not FileCheck -check-prefix=SHLIBRBAR %s
+# SHLIBRBAR: trace-symbols.s.tmp1.so: reference to bar
+
+# RUN: ld.lld -y foo -y bar %t -u bar --start-lib %t1 %t2 --end-lib -o %t3 |  \
+# RUN: FileCheck -check-prefix=STARTLIB %s
+# STARTLIB: trace-symbols.s.tmp1: reference to bar 
+
+.hidden hsymbol 
+.globl  _start
+.type _start, @function
+_start:
+call foo