[lld][WebAssembly] Fix crash on undefined/weak function symbols in LTO objects

[sbc100]

Summary

Symbols from LTO objects don't contain Wasm signatures, but we need a
signature when we create undefined/stub functions for missing weakly
undefined symbols.

Luckily, after LTO, we know that symbols that are not referenced by a
regular object file must not be needed in the final output so there
is no need to generate undefined/stub function for them.

[sbc100]

Still working on a test..

[sbc100]

• add test

[sbc100]

• typo

lld/test/wasm/lto/weak-undefined.ll

 ; RUN: llvm-as %s -o %t.o
 ; RUN: wasm-ld %t.o -o %t.wasm
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
 ; Test that undefined weak external functions are handled in the LTO case
 ; We had a bug where stub function generation was failing because functions
 ; that are in bitcode (pre-LTO) don't have signatures assigned.
 
 target datalayout = "e-m:e-p:32:32-p10:8:8-p20:8:8-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown"
 
 declare extern_weak i32 @foo()
 
+declare extern_weak i32 @bar()
+
+; The reference to bar here will exist in the LTO file, but the LTO process will
+; remove it, so it will never be referenced by an normal object file, and
+; therefore never have a signature.
+define void @unused_function() #0 {
+entry:
+    %call2 = call i32 @bar()
+    ret void
+}
+
 define void @_start() #0 {
 entry:
     %call2 = call i32 @foo()
     ret void
 }
 
 ; CHECK: Name:            'undefined_weak:foo'

lld/wasm/SymbolTable.cpp

InputFunction *SymbolTable::replaceWithUnreachable(Symbol *sym,
   // should always compare equal to the null pointer.
   sym->isStub = true;
   return func;
 }
 
 void SymbolTable::replaceWithUndefined(Symbol *sym) {
   // Add a synthetic dummy for weak undefined functions.  These dummies will
   // be GC'd if not used as the target of any "call" instructions.
-  StringRef debugName = saver().save("undefined_weak:" + toString(*sym));
+  StringRef debugName = saver().save("undefined_weak:" + sym->getName());
   replaceWithUnreachable(sym, *sym->getSignature(), debugName);
   // Hide our dummy to prevent export.
   sym->setHidden(true);
 }
 
 // For weak undefined functions, there may be "call" instructions that reference
 // the symbol. In this case, we need to synthesise a dummy/stub function that
 // will abort at runtime, so that relocations can still provided an operand to
 // the call instruction that passes Wasm validation.
 void SymbolTable::handleWeakUndefines() {
   for (Symbol *sym : getSymbols()) {
-    if (sym->isUndefWeak()) {
+    if (sym->isUndefWeak() && sym->isUsedInRegularObj) {
       if (sym->getSignature()) {
         replaceWithUndefined(sym);
       } else {
         // It is possible for undefined functions not to have a signature (eg.
         // if added via "--undefined"), but weak undefined ones do have a
         // signature.  Lazy symbols may not be functions and therefore Sig can
         // still be null in some circumstance.
         assert(!isa<FunctionSymbol>(sym));