[WebAssembly] Fix crash with LTO + relocatable + undefined symbols

[sbc100]

Summary

Change the way we create the symbol table to be closer to how its down on ELF.
Now the output symbol table matches the internal symtab data structure more closely
and includes local and undefined symbols.

Fixes PR40204

[sbc100]

Revert debugging

[pcc]

wasm/Writer.cpp

906

Maybe this would be better as

for (Symbol *Sym : Symtab->getSymbols()) {
  // handle global symbols
}

for (ObjFile *File : Symtab->ObjectFiles) {
  for (Symbol *Sym : File->getSymbols()) {
    if (!Sym->isLocal())
      continue;
    // handle local/section symbols
  }
}

? I believe that's how we handle .symtab in ELF for example.

[sbc100]

• refactor symtab creation

[ruiu]

LGTM

wasm/Writer.cpp

925

Symbol* -> Symbol *

test/wasm/lto/relocatable-undefined.ll

+; RUN: llvm-as %s -o %t.o
+; RUN: wasm-ld -r -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
+target triple = "wasm32-unknown-unknown"
+
+@missing_data = external global i32
+declare i32 @missing_func() local_unnamed_addr
+
+define i32 @foo() {
+entry:
+  %0 = call i32 @missing_func()
+  %1 = load i32, i32* @missing_data, align 4
+  ret i32 %1
+}
+
+
+; CHECK:        - Type:            CUSTOM
+; CHECK-NEXT:     Name:            linking
+; CHECK-NEXT:     Version:         2
+; CHECK-NEXT:     SymbolTable:     
+; CHECK-NEXT:       - Index:           0
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            foo
+; CHECK-NEXT:         Flags:           [  ]
+; CHECK-NEXT:         Function:        1
+; CHECK-NEXT:       - Index:           1
+; CHECK-NEXT:         Kind:            FUNCTION
+; CHECK-NEXT:         Name:            missing_func
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]
+; CHECK-NEXT:         Function:        0
+; CHECK-NEXT:       - Index:           2
+; CHECK-NEXT:         Kind:            DATA
+; CHECK-NEXT:         Name:            missing_data
+; CHECK-NEXT:         Flags:           [ UNDEFINED ]

wasm/InputFiles.cpp

 // Relocations contain either symbol or type indices.  This function takes a
 // relocation and returns relocated index (i.e. translates from the input
 // symbol/type space to the output symbol/type space).
 uint32_t ObjFile::calcNewIndex(const WasmRelocation &Reloc) const {
   if (Reloc.Type == R_WEBASSEMBLY_TYPE_INDEX_LEB) {
     assert(TypeIsUsed[Reloc.Index]);
     return TypeMap[Reloc.Index];
   }
+  LLVM_DEBUG(dbgs() << "calcNewIndex: " << toString(*Symbols[Reloc.Index]) << "\n");
   return Symbols[Reloc.Index]->getOutputSymbolIndex();
 }
 
 // Relocations can contain addend for combined sections. This function takes a
 // relocation and returns updated addend by offset in the output section.
 uint32_t ObjFile::calcNewAddend(const WasmRelocation &Reloc) const {
   switch (Reloc.Type) {
   case R_WEBASSEMBLY_MEMORY_ADDR_LEB:

wasm/Writer.cpp

 }
 
 void Writer::assignSymtab() {
   if (!Config->Relocatable)
     return;
 
   StringMap<uint32_t> SectionSymbolIndices;
 
   unsigned SymbolIndex = SymtabEntries.size();
   for (ObjFile *File : Symtab->ObjectFiles) {
     LLVM_DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
     for (Symbol *Sym : File->getSymbols()) {
       if (Sym->getFile() != File)
         continue;
 
       if (auto *S = dyn_cast<SectionSymbol>(Sym)) {
         StringRef Name = S->getName();
         if (CustomSectionMapping.count(Name) == 0)
           continue;
 
         auto SSI = SectionSymbolIndices.find(Name);
         if (SSI != SectionSymbolIndices.end()) {
           Sym->setOutputSymbolIndex(SSI->second);
           continue;
         }
 
         SectionSymbolIndices[Name] = SymbolIndex;
         CustomSectionSymbols[Name] = cast<SectionSymbol>(Sym);
 
         Sym->markLive();
       }
 
       // (Since this is relocatable output, GC is not performed so symbols must
       // be live.)
       assert(Sym->isLive());
       Sym->setOutputSymbolIndex(SymbolIndex++);
       SymtabEntries.emplace_back(Sym);
     }
   }
 
+  // Undefined symbols from bitcode input files can still exist in the final
+  // output.  For defined symbols these get replaces with the symbols in the LTO
+  // object itself.
+  for (BitcodeFile *File : Symtab->BitcodeFiles) {
+    LLVM_DEBUG(dbgs() << "Symtab entries: " << File->getName() << "\n");
+    for (Symbol *Sym : File->getSymbols()) {
+      if (Sym->getFile() != File)
+        continue;
+
+      assert(Sym->isUndefined());
+
+      // (Since this is relocatable output, GC is not performed so symbols must
+      // be live.)
+      assert(Sym->isLive());
+      Sym->setOutputSymbolIndex(SymbolIndex++);
+      SymtabEntries.emplace_back(Sym);
+    }
+  }
+
   // For the moment, relocatable output doesn't contain any synthetic functions,
   // so no need to look through the Symtab for symbols not referenced by
   // Symtab->ObjectFiles.
 }
 
 uint32_t Writer::lookupType(const WasmSignature &Sig) {
   auto It = TypeIndices.find(Sig);
   if (It == TypeIndices.end()) {