[lld][WebAssembly] Preserve symbol flags in --relocatable output

[sbc100]

Summary

Fixes https://github.com/emscripten-core/emscripten/issues/8879

[sbc100]

add test

[sbc100]

ping..

[MaskRay]

lld/test/wasm/relocatable.ll

13 ↗

(On Diff #220730)

?

lld/wasm/SymbolTable.cpp

447

&& or &

469

&& or &

[sbc100]

• feedback

[jgravelle-google]

lgtm

lld/wasm/Driver.cpp

static Symbol *handleUndefined(StringRef name) {
   if (auto *lazySym = dyn_cast<LazySymbol>(sym))
     lazySym->fetch();
 
   return sym;
 }
 
 static UndefinedGlobal *
 createUndefinedGlobal(StringRef name, llvm::wasm::WasmGlobalType *type) {
-  auto *sym =
-      cast<UndefinedGlobal>(symtab->addUndefinedGlobal(name, name,
-                                                       defaultModule, 0,
-                                                       nullptr, type));
+  auto *sym = cast<UndefinedGlobal>(symtab->addUndefinedGlobal(
+      name, name, defaultModule, WASM_SYMBOL_UNDEFINED, nullptr, type));
   config->allowUndefinedSymbols.insert(sym->getName());
   sym->isUsedInRegularObj = true;
   return sym;
 }
 
 static GlobalSymbol *createGlobalVariable(StringRef name, bool isMutable,
                                           int value) {
   llvm::wasm::WasmGlobal wasmGlobal;

 // This data structure is instantiated for each -wrap option.
 struct WrappedSymbol {
   Symbol *sym;
   Symbol *real;
   Symbol *wrap;
 };
 
 static Symbol *addUndefined(StringRef name) {
-  return symtab->addUndefinedFunction(name, "", "", 0, nullptr, nullptr, false);
+  return symtab->addUndefinedFunction(name, "", "", WASM_SYMBOL_UNDEFINED,
+                                      nullptr, nullptr, false);
 }
 
 // Handles -wrap option.
 //
 // This function instantiates wrapper symbols. At this point, they seem
 // like they are not being used at all, so we explicitly set some flags so
 // that LTO won't eliminate them.
 static std::vector<WrappedSymbol> addWrappedSymbols(opt::InputArgList &args) {

lld/wasm/InputFiles.cpp

case WASM_SYMBOL_TYPE_EVENT: {
     return symtab->addDefinedEvent(name, flags, this, event);
   }
   }
   llvm_unreachable("unknown symbol kind");
 }
 
 Symbol *ObjFile::createUndefined(const WasmSymbol &sym, bool isCalledDirectly) {
   StringRef name = sym.Info.Name;
-  uint32_t flags = sym.Info.Flags;
+  uint32_t flags = sym.Info.Flags | WASM_SYMBOL_UNDEFINED;
 
   switch (sym.Info.Kind) {
   case WASM_SYMBOL_TYPE_FUNCTION:
     if (sym.isBindingLocal())
       return make<UndefinedFunction>(name, sym.Info.ImportName,
                                      sym.Info.ImportModule, flags, this,
                                      sym.Signature, isCalledDirectly);
     return symtab->addUndefinedFunction(name, sym.Info.ImportName,
static Symbol *createBitcodeSymbol(const std::vector<bool> &keptComdats,
 
   uint32_t flags = objSym.isWeak() ? WASM_SYMBOL_BINDING_WEAK : 0;
   flags |= mapVisibility(objSym.getVisibility());
 
   int c = objSym.getComdatIndex();
   bool excludedByComdat = c != -1 && !keptComdats[c];
 
   if (objSym.isUndefined() || excludedByComdat) {
+    flags |= WASM_SYMBOL_UNDEFINED;
     if (objSym.isExecutable())
       return symtab->addUndefinedFunction(name, name, defaultModule, flags, &f,
                                           nullptr, true);
     return symtab->addUndefinedData(name, flags, &f);
   }
 
   if (objSym.isExecutable())
     return symtab->addDefinedFunction(name, flags, &f, nullptr);

lld/wasm/SymbolTable.cpp

 Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
                                           StringRef importModule,
                                           uint32_t flags, InputFile *file,
                                           const WasmSignature *sig,
                                           bool isCalledDirectly) {
   LLVM_DEBUG(dbgs() << "addUndefinedFunction: " << name << " ["
                     << (sig ? toString(*sig) : "none")
                     << "] IsCalledDirectly:" << isCalledDirectly << "\n");
+  assert(flags && WASM_SYMBOL_UNDEFINED);
 
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
   if (s->traced)
     printTraceSymbolUndefined(name, file);
 
   auto replaceSym = [&]() {
Symbol *SymbolTable::addUndefinedFunction(StringRef name, StringRef importName,
   }
 
   return s;
 }
 
 Symbol *SymbolTable::addUndefinedData(StringRef name, uint32_t flags,
                                       InputFile *file) {
   LLVM_DEBUG(dbgs() << "addUndefinedData: " << name << "\n");
+  assert(flags && WASM_SYMBOL_UNDEFINED);
 
   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");
+  assert(flags && WASM_SYMBOL_UNDEFINED);
 
   Symbol *s;
   bool wasInserted;
   std::tie(s, wasInserted) = insert(name, file);
   if (s->traced)
     printTraceSymbolUndefined(name, file);
 
   if (wasInserted)