[lld] Trace all references with lld --trace-symbol

[sbc100]

Summary

Previously undefined symbol references were only traced in they were
seen before that definition.

Fixes https://bugs.llvm.org/show_bug.cgi?id=41878

[ruiu]

Undefined symbols are indeed not currently displayed by --trace-symbol under the condition you mentioned, but that's also true for other types of symbols such as shared symbols.

A large refactoring is going on, and https://reviews.llvm.org/D61898, and once it's landed, I think we can fix the issue for all symbol types. Do you think you can wait until then?

[sbc100]

In D61929#1502456, @ruiu wrote:

Undefined symbols are indeed not currently displayed by --trace-symbol under the condition you mentioned, but that's also true for other types of symbols such as shared symbols.

A large refactoring is going on, and https://reviews.llvm.org/D61898, and once it's landed, I think we can fix the issue for all symbol types. Do you think you can wait until then?

Indeed, this change in not urgent.

[sbc100]

• rebase

[sbc100]

rebased. PTAL

[sbc100]

rebase

[sbc100]

Should be good to go now. PTAL.

[sbc100]

• rebase

[sbc100]

ping

[ruiu]

LGTM

lld/ELF/SymbolTable.cpp

 static void addUndefined(Symbol *Old, const Undefined &New) {
   // An undefined symbol with non default visibility must be satisfied
   // in the same DSO.
   if (Old->isShared() && New.Visibility != STV_DEFAULT) {
     Old->replace(New);
     return;
   }
 
+  if (Old->Traced)
+    printTraceSymbol(&New);
+
   if (Old->isShared() || Old->isLazy() ||
       (Old->isUndefined() && New.Binding != STB_WEAK))
     Old->Binding = New.Binding;
 
   if (Old->isLazy()) {
     // An undefined weak will not fetch archive members. See comment on Lazy in
     // Symbols.h for the details.
     if (New.Binding == STB_WEAK) {

lld/ELF/Symbols.h

static inline void assertSymbols() {
   AssertSymbol<Defined>();
   AssertSymbol<CommonSymbol>();
   AssertSymbol<Undefined>();
   AssertSymbol<SharedSymbol>();
   AssertSymbol<LazyArchive>();
   AssertSymbol<LazyObject>();
 }
 
-void printTraceSymbol(Symbol *Sym);
+void printTraceSymbol(const Symbol *Sym);
 
 size_t Symbol::getSymbolSize() const {
   switch (kind()) {
   case CommonKind:
     return sizeof(CommonSymbol);
   case DefinedKind:
     return sizeof(Defined);
   case LazyArchiveKind:

lld/ELF/Symbols.cpp

bool Symbol::includeInDynsym() const {
   if (isUndefWeak() && Config->Pie && SharedFiles.empty())
     return false;
   if (!isDefined())
     return true;
   return ExportDynamic;
 }
 
 // Print out a log message for --trace-symbol.
-void elf::printTraceSymbol(Symbol *Sym) {
+void elf::printTraceSymbol(const Symbol *Sym) {
   std::string S;
   if (Sym->isUndefined())
     S = ": reference to ";
   else if (Sym->isLazy())
     S = ": lazy definition of ";
   else if (Sym->isShared())
     S = ": shared definition of ";
   else if (Sym->isCommon())

lld/test/ELF/trace-symbols.s

 
 # RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol \
 # RUN:   %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTD1FOO %s
 # OBJECTD1FOO: trace-symbols.s.tmp: reference to foo
 # OBJECTD1FOO: trace-symbols.s.tmp1: common definition of common
 # OBJECTD1FOO: trace-symbols.s.tmp1: definition of foo
 # OBJECTD1FOO: trace-symbols.s.tmp2: definition of foo
 
+# RUN: ld.lld -y foo %t1 %t2 %t -o %t3 | FileCheck -check-prefix=REFLAST %s
+# REFLAST: trace-symbols.s.tmp1: definition of foo
+# REFLAST: trace-symbols.s.tmp2: definition of foo
+# REFLAST: trace-symbols.s.tmp: reference to foo
+
 # RUN: ld.lld -y foo -trace-symbol=common -trace-symbol=hsymbol \
 # RUN:   %t %t1 %t2 -o %t3 | FileCheck -check-prefix=OBJECTD2FOO %s
 # RUN: ld.lld -y foo -y common --trace-symbol=hsymbol \
-# RUN:   %t %t2 %t1 -o /dev/null | FileCheck -check-prefix=OBJECTD2FOO %s
+# RUN:   %t %t2 %t1 -o %t3 | FileCheck -check-prefix=OBJECTD2FOO %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

lld/test/wasm/trace-symbol.ll

 ; RUN: llc -filetype=obj %p/Inputs/ret32.ll -o %t.ret32.o
-; RUN: llc -filetype=obj -o %t.o %s
-; RUN: wasm-ld -o %t.wasm %t.o %t.ret32.o -y ret32 -y _start | FileCheck %s -check-prefix=BOTH
+; RUN: llc -filetype=obj -o %t.start.o %s
+; RUN: wasm-ld -o %t.wasm %t.start.o %t.ret32.o -y ret32 -y _start | FileCheck %s -check-prefix=BOTH
+; RUN: wasm-ld -o %t.wasm %t.ret32.o %t.start.o -y ret32 -y _start | FileCheck %s -check-prefix=REVERSED
 
 ; check alias
-; RUN: wasm-ld -o %t.wasm %t.o %t.ret32.o -trace-symbol=_start | FileCheck %s -check-prefixes=JUST-START
+; RUN: wasm-ld -o %t.wasm %t.start.o %t.ret32.o -trace-symbol=_start | FileCheck %s -check-prefixes=JUST-START
 
 target triple = "wasm32-unknown-unknown"
 
 declare i32 @ret32(float %arg)
 
 define void @_start() {
 entry:
   %call1 = call i32 @ret32(float 0.0)
   ret void
 }
 
-; BOTH: .o: definition of _start
-; BOTH: .o: reference to ret32
-; BOTH: .ret32.o: definition of ret32
+; BOTH:          start.o: definition of _start
+; BOTH-NEXT:     start.o: reference to ret32
+; BOTH-NEXT:     ret32.o: definition of ret32
+
+; REVERSED:      ret32.o: definition of ret32
+; REVERSED-NEXT: start.o: definition of _start
+; REVERSED-NEXT: start.o: reference to ret32
 
-; JUST-START: .o: definition of _start
+; JUST-START: start.o: definition of _start
 ; JUST-START-NOT: ret32

lld/wasm/SymbolTable.cpp

Symbol *SymbolTable::addUndefinedFunction(StringRef Name, StringRef ImportName,
                                           uint32_t Flags, InputFile *File,
                                           const WasmSignature *Sig) {
   LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << Name <<
              " [" << (Sig ? toString(*Sig) : "none") << "]\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
+  if (S->Traced)
+    printTraceSymbolUndefined(Name, File);
 
   auto Replace = [&]() {
     replaceSymbol<UndefinedFunction>(S, Name, ImportName, ImportModule, Flags,
                                      File, Sig);
   };
 
   if (WasInserted)
     Replace();

 
 Symbol *SymbolTable::addUndefinedData(StringRef Name, uint32_t Flags,
                                       InputFile *File) {
   LLVM_DEBUG(dbgs() << "addUndefinedData: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
+  if (S->Traced)
+    printTraceSymbolUndefined(Name, File);
 
   if (WasInserted)
     replaceSymbol<UndefinedData>(S, Name, Flags, File);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkDataType(S, File);
   return S;
 }
 
 Symbol *SymbolTable::addUndefinedGlobal(StringRef Name, StringRef ImportName,
                                         StringRef ImportModule, uint32_t Flags,
                                         InputFile *File,
                                         const WasmGlobalType *Type) {
   LLVM_DEBUG(dbgs() << "addUndefinedGlobal: " << Name << "\n");
 
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, File);
+  if (S->Traced)
+    printTraceSymbolUndefined(Name, File);
 
   if (WasInserted)
     replaceSymbol<UndefinedGlobal>(S, Name, ImportName, ImportModule, Flags,
                                    File, Type);
   else if (auto *Lazy = dyn_cast<LazySymbol>(S))
     Lazy->fetch();
   else if (S->isDefined())
     checkGlobalType(S, File, Type);

lld/wasm/Symbols.h

union SymbolUnion {
   alignas(LazySymbol) char E[sizeof(LazySymbol)];
   alignas(UndefinedFunction) char F[sizeof(UndefinedFunction)];
   alignas(UndefinedData) char G[sizeof(UndefinedData)];
   alignas(UndefinedGlobal) char H[sizeof(UndefinedGlobal)];
   alignas(SectionSymbol) char I[sizeof(SectionSymbol)];
 };
 
 void printTraceSymbol(Symbol *Sym);
+void printTraceSymbolUndefined(StringRef Name, const InputFile* File);
 
 template <typename T, typename... ArgT>
 T *replaceSymbol(Symbol *S, ArgT &&... Arg) {
   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");

lld/wasm/Symbols.cpp

std::string lld::toString(wasm::Symbol::Kind Kind) {
   case wasm::Symbol::SectionKind:
     return "SectionKind";
   case wasm::Symbol::OutputSectionKind:
     return "OutputSectionKind";
   }
   llvm_unreachable("invalid symbol kind");
 }
 
+
+void lld::wasm::printTraceSymbolUndefined(StringRef Name, const InputFile* File) {
+  message(toString(File) + ": reference to " + Name);
+}
+
 // Print out a log message for --trace-symbol.
 void lld::wasm::printTraceSymbol(Symbol *Sym) {
-  std::string S;
+  // Undefined symbols are traced via printTraceSymbolUndefined
   if (Sym->isUndefined())
-    S = ": reference to ";
-  else if (Sym->isLazy())
+    return;
+
+  std::string S;
+  if (Sym->isLazy())
     S = ": lazy definition of ";
   else
     S = ": definition of ";
 
   message(toString(Sym->getFile()) + S + Sym->getName());
 }
 
 const char *lld::wasm::DefaultModule = "env";
 const char *lld::wasm::FunctionTableName = "__indirect_function_table";