[WebAssebmly][MC] Ingore undefined init functions when writing object file

[sbc100]

Summary

This is really a workaround for #62243. Ideally we would ensure that
llvm never emits object files that contain undefined init function, but
I have yet to find a small enough repro case to fully understand how the
such a things is possible.

[sbc100]

I see this as more of a workaround that fix for https://github.com/llvm/llvm-project/issues/62243 since I still haven't tracked down the root cause.

lld/wasm/LTO.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cstddef>
 #include <memory>
 #include <string>
 #include <system_error>
 #include <vector>
 
+#define DEBUG_TYPE "lld"
+
 using namespace llvm;
 
 namespace lld::wasm {
 static std::unique_ptr<lto::LTO> createLTO() {
   lto::Config c;
   c.Options = initTargetOptionsFromCodeGenFlags();
 
   // Always emit a section per function/data with LTO.
for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
     r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f;
     r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj ||
                             sym->isNoStrip() ||
                             (r.Prevailing && sym->isExported());
+    LLVM_DEBUG(llvm::dbgs()
+               << "LTO: VisibleToRegularObj: " << r.VisibleToRegularObj
+               << " Prevailing: " << r.Prevailing << " " << sym->getName()
+               << " (" << toString(*sym) << ")\n");
     if (r.Prevailing)
       undefine(sym);
 
     // We tell LTO to not apply interprocedural optimization for wrapped
     // (with --wrap) symbols because otherwise LTO would inline them while
     // their values are still not final.
     r.LinkerRedefined = !sym->canInline;
   }

lld/wasm/Writer.cpp

 void Writer::calculateInitFunctions() {
   if (!config->relocatable && !WasmSym::callCtors->isLive())
     return;
 
   for (ObjFile *file : symtab->objectFiles) {
     const WasmLinkingData &l = file->getWasmObj()->linkingData();
     for (const WasmInitFunc &f : l.InitFunctions) {
       FunctionSymbol *sym = file->getFunctionSymbol(f.Symbol);
+      LLVM_DEBUG(llvm::dbgs() << "calculateInitFunctions: " << file->getName()
+                              << ": " << toString(*sym) << "\n");
+      assert(sym->isDefined());
       // comdat exclusions can cause init functions be discarded.
       if (sym->isDiscarded() || !sym->isLive())
         continue;
       if (sym->signature->Params.size() != 0)
         error("constructor functions cannot take arguments: " + toString(*sym));
       LLVM_DEBUG(dbgs() << "initFunctions: " << toString(*sym) << "\n");
       initFunctions.emplace_back(WasmInitEntry{sym, f.Priority});
     }

llvm/lib/MC/WasmObjectWriter.cpp

for (const MCFixup &Fixup : DataFrag.getFixups()) {
       auto *SymRef = dyn_cast<MCSymbolRefExpr>(Expr);
       if (!SymRef)
         report_fatal_error("fixups in .init_array should be symbol references");
       const auto &TargetSym = cast<const MCSymbolWasm>(SymRef->getSymbol());
       if (TargetSym.getIndex() == InvalidIndex)
         report_fatal_error("symbols in .init_array should exist in symtab");
       if (!TargetSym.isFunction())
         report_fatal_error("symbols in .init_array should be for functions");
-      InitFuncs.push_back(
-          std::make_pair(Priority, TargetSym.getIndex()));
+      // For now, ignore init functions that are not defined within the module.
+      // Ideally undefined init functions should not occur, but they do seem
+      // to be showing up in some hard to reproduce cases involving LTO.
+      // FIXME: Remove this once we find the root cause of
+      // https://github.com/llvm/llvm-project/issues/62243
+      if (TargetSym.isDefined()) {
+        InitFuncs.push_back(std::make_pair(Priority, TargetSym.getIndex()));
+      }
     }
   }
 
   // Write out the Wasm header.
   writeHeader(Asm);
 
   uint32_t CodeSectionIndex, DataSectionIndex;
   if (Mode != DwoMode::DwoOnly) {

llvm/test/MC/WebAssembly/basic-assembly.s

 # RUN: llvm-mc -triple=wasm32-unknown-unknown -mattr=+tail-call,+reference-types,atomics,+simd128,+nontrapping-fptoint,+exception-handling < %s | FileCheck %s
 # Check that it converts to .o without errors, but don't check any output:
 # RUN: llvm-mc -triple=wasm32-unknown-unknown -filetype=obj -mattr=+tail-call,+reference-types,+atomics,+simd128,+nontrapping-fptoint,+exception-handling -o %t.o < %s
+# RUN: obj2yaml %t.o | FileCheck %s --check-prefix=OBJ
 
 .functype   something1 () -> ()
 .functype   something2 (i64) -> (i32, f64)
 .functype   something3 () -> (i32)
+.functype   undefined_func () -> (i32)
 .globaltype __stack_pointer, i32
 
 empty_func:
     .functype empty_func () -> ()
     end_function
 
 test0:
 # local labels can appear between label and its .functype.
.L.str:
     .size       .L.str, 28
 
     .data
     .int8       73
 
     .section    .init_array.42,"",@
     .p2align    2
     .int32      test0
+    .int32      undefined_func
 
     .ident      "clang version 9.0.0 (trunk 364502) (llvm/trunk 364571)"
 
 .tabletype empty_eref_table, externref
 empty_eref_table:
 
 .tabletype empty_fref_table, funcref
 empty_fref_table:

 
 # CHECK:           .data
 # CHECK-EMPTY:
 # CHECK-NEXT:      .int8       73
 
 # CHECK:           .section    .init_array.42,"",@
 # CHECK-NEXT:      .p2align    2
 # CHECK-NEXT:      .int32      test0
+# CHECK-NEXT:      .int32      undefined_func
 
 # CHECK:           .tabletype empty_eref_table, externref
 # CHECK-NEXT: empty_eref_table:
 
 # CHECK:           .tabletype empty_fref_table, funcref
 # CHECK-NEXT: empty_fref_table:
+
+# OBJ:         InitFunctions:
+# OBJ-NEXT:      - Priority:        42
+# OBJ-NEXT:        Symbol:          1
+# OBJ-NEXT: ...