[lld][WebAssembly] stub objects: Fix handling of LTO libcall dependencies

[sbc100]

Summary

This actually simplifies the code by performs a pre-pass of the stub
objects prior to LTO.

This should be the final change needed before we can make the switch
on the emscripten side: https://github.com/emscripten-core/emscripten/pull/18905

[sbc100]

• make diff simpler

[sbc100]

• shrink diff

lld/test/wasm/lto/stub-library-libcall.s

 # RUN: split-file %s %t
 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t_main.o %t/main.s
-# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t_foo.o %t/foo.s
+# RUN: llvm-as %S/Inputs/foo.ll -o %t_foo.o
 # RUN: llvm-as %S/Inputs/libcall.ll -o %t_libcall.o
 # RUN: wasm-ld %t_main.o %t_libcall.o %t_foo.o %p/Inputs/stub.so -o %t.wasm
 # RUN: obj2yaml %t.wasm | FileCheck %s
 
 # The function `func_with_libcall` will generate an undefined reference to
 # `memcpy` at LTO time.  `memcpy` itself also declared in stub.so and depends
 # on `foo`
 
 # If %t_foo.o is not included in the link we get an undefined symbol reported
 # to the dependency of memcpy on the foo export:
 
 # RUN: not wasm-ld %t_main.o %t_libcall.o %p/Inputs/stub.so -o %t.wasm 2>&1 | FileCheck --check-prefix=MISSING %s
 # MISSING: stub.so: undefined symbol: foo. Required by memcpy
 
 #--- main.s
 .functype func_with_libcall (i32, i32) -> ()
 .globl _start
 _start:
     .functype _start () -> ()
     i32.const 0
     i32.const 0
     call func_with_libcall
     end_function
 
-#--- foo.s
-.globl foo
-foo:
-  .functype foo () -> ()
-  end_function
-
 # CHECK:         Imports:
 # CHECK-NEXT:      - Module:          env
 # CHECK-NEXT:        Field:           memcpy
 # CHECK-NEXT:        Kind:            FUNCTION
 # CHECK-NEXT:        SigIndex:        0
 
 # CHECK:         Exports:
 # CHECK-NEXT:       - Name:            memory
 # CHECK-NEXT:         Kind:            MEMORY
 # CHECK-NEXT:         Index:           0
 # CHECK-NEXT:       - Name:            _start
 # CHECK-NEXT:         Kind:            FUNCTION
 # CHECK-NEXT:         Index:           1
 # CHECK-NEXT:       - Name:            foo
 # CHECK-NEXT:         Kind:            FUNCTION
-# CHECK-NEXT:         Index:           2
+# CHECK-NEXT:         Index:           3

lld/wasm/Driver.cpp

static void createOptionalSymbols() {
   // start of the `.tdata` static segment.
   //
   // __tls_size and __tls_align are not needed in this case since they are only
   // needed for __wasm_init_tls (which we do not create in this case).
   if (!config->sharedMemory)
     WasmSym::tlsBase = createOptionalGlobal("__tls_base", false);
 }
 
+static void processStubLibrariesPreLTO() {
+  log("-- processStubLibrariesPreLTO");
+  for (auto &stub_file : symtab->stubFiles) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "processing stub file: " << stub_file->getName() << "\n");
+    for (auto [name, deps]: stub_file->symbolDependencies) {
+      auto* sym = symtab->find(name);
+      // If the symbol is not present at all (yet), or if it is present but
+      // undefined, then mark the dependent symbols as used by a regular
+      // object so they will be preserved and exported by the LTO process.
+      if (!sym || sym->isUndefined()) {
+        for (const auto dep : deps) {
+          auto* needed = symtab->find(dep);
+          if (needed ) {
+            needed->isUsedInRegularObj = true;
+          }
+        }
+      }
+    }
+  }
+}
+
 static void processStubLibraries() {
   log("-- processStubLibraries");
   for (auto &stub_file : symtab->stubFiles) {
     LLVM_DEBUG(llvm::dbgs()
                << "processing stub file: " << stub_file->getName() << "\n");
     for (auto [name, deps]: stub_file->symbolDependencies) {
       auto* sym = symtab->find(name);
-      if (!sym || !sym->isUndefined() || sym->forceImport) {
-        LLVM_DEBUG(llvm::dbgs() << "stub not in needed: " << name << "\n");
+      if (!sym || !sym->isUndefined()) {
+        LLVM_DEBUG(llvm::dbgs() << "stub symbol not needed: " << name << "\n");
         continue;
       }
       // The first stub library to define a given symbol sets this and
       // definitions in later stub libraries are ignored.
+      if (sym->forceImport)
+        continue;  // Already handled
       sym->forceImport = true;
       if (sym->traced)
         message(toString(stub_file) + ": importing " + name);
       else
         LLVM_DEBUG(llvm::dbgs()
                    << toString(stub_file) << ": importing " << name << "\n");
       for (const auto dep : deps) {
         auto* needed = symtab->find(dep);
void LinkerDriver::linkerMain(ArrayRef<const char *> argsArr) {
   // definition is in bitcode. Any other required libcall symbols will be added
   // to the link after LTO when we add the LTO object file to the link.
   if (!symtab->bitcodeFiles.empty())
     for (auto *s : lto::LTO::getRuntimeLibcallSymbols())
       handleLibcall(s);
   if (errorCount())
     return;
 
-  // processStubLibraries must happen before LTO because it can trigger the
-  // export of arbirary symbols that might themselves be defined in LTO objects.
-  processStubLibraries();
+  // We process the stub libraries once beofore LTO to ensure that any possible
+  // required exports are preserved by the LTO process.
+  processStubLibrariesPreLTO();
 
   // Do link-time optimization if given files are LLVM bitcode files.
   // This compiles bitcode files into real object files.
   symtab->compileBitcodeFiles();
   if (errorCount())
     return;
 
   // The LTO process can generate new undefined symbols, specifically libcall
   // functions.  Because those symbols might be declared in a stub library we
-  // need the process the stub libraries once again after LTO to handle any
-  // newly undefined symbols.
+  // need the process the stub libraries once again after LTO to handle all
+  // undefined symbols, including ones that didn't exist prior to LTO.
   processStubLibraries();
 
   writeWhyExtract();
 
   createOptionalSymbols();
 
   // Resolve any variant symbols that were created due to signature
   // mismatchs.