[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

?

lld/wasm/SymbolTable.cpp

447

&& or &

469

&& or &

[sbc100]

• feedback

[jgravelle-google]

lgtm

lld/test/wasm/relocatable.ll

 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.o
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: wasm-ld -r -o %t.wasm %t.hello.o %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s --check-prefixes CHECK,NORMAL
 
 ; RUN: llc -filetype=obj %p/Inputs/hello.ll -o %t.hello.bm.o -mattr=+bulk-memory,+atomics
 ; RUN: llc -filetype=obj %s -o %t.bm.o -mattr=+bulk-memory
 ; RUN: wasm-ld -r -o %t.mt.wasm %t.hello.bm.o %t.bm.o --shared-memory --max-memory=131072
 ; RUN: obj2yaml %t.mt.wasm | FileCheck %s --check-prefixes CHECK,SHARED
 
 target triple = "wasm32-unknown-unknown"
 
+
 ; Function Attrs: nounwind
 define hidden i32 @my_func() local_unnamed_addr {
 entry:
   %call = tail call i32 @foo_import()
   %call2 = tail call i32 @bar_import()
   ret i32 1
 }
 
 declare i32 @foo_import() local_unnamed_addr
 declare extern_weak i32 @bar_import() local_unnamed_addr
 @data_import = external global i64
 
 @func_addr1 = hidden global i32()* @my_func, align 4
 @func_addr2 = hidden global i32()* @foo_import, align 4
 @func_addr3 = hidden global i32()* @bar_import, align 4
 @data_addr1 = hidden global i64* @data_import, align 8
 
 $func_comdat = comdat any
 @data_comdat = weak_odr constant [3 x i8] c"abc", comdat($func_comdat)
 define linkonce_odr i32 @func_comdat() comdat {
 entry:
   ret i32 ptrtoint ([3 x i8]* @data_comdat to i32)
 }
 
+; Test that __attribute__(used) (i.e NO_STRIP) is preserved in the relocated symbol table
[e-mail] = appending global [1 x i8*] [i8* bitcast (i32 ()* @my_func to i8*)], section "llvm.metadata"
+
 ; CHECK:      --- !WASM
 ; CHECK-NEXT: FileHeader:
 ; CHECK-NEXT:   Version:         0x00000001
 ; CHECK-NEXT: Sections:
 ; CHECK-NEXT:   - Type:            TYPE
 ; CHECK-NEXT:     Signatures:
 ; CHECK-NEXT:       - Index:           0
 ; CHECK-NEXT:         ReturnType:      NORESULT

 ; NORMAL-NEXT:      - Index:           2
 ; NORMAL-NEXT:        Kind:            FUNCTION
 ; NORMAL-NEXT:        Name:            puts
 ; NORMAL-NEXT:        Flags:           [ UNDEFINED ]
 ; NORMAL-NEXT:        Function:        0
 ; NORMAL-NEXT:      - Index:           3
 ; NORMAL-NEXT:        Kind:            FUNCTION
 ; NORMAL-NEXT:        Name:            my_func
-; NORMAL-NEXT:        Flags:           [ VISIBILITY_HIDDEN ]
+; NORMAL-NEXT:        Flags:           [ VISIBILITY_HIDDEN, NO_STRIP ]
 ; NORMAL-NEXT:        Function:        4
 ; NORMAL-NEXT:      - Index:           4
 ; NORMAL-NEXT:        Kind:            FUNCTION
 ; NORMAL-NEXT:        Name:            foo_import
 ; NORMAL-NEXT:        Flags:           [ UNDEFINED ]
 ; NORMAL-NEXT:        Function:        1
 ; NORMAL-NEXT:      - Index:           5
 ; NORMAL-NEXT:        Kind:            FUNCTION

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)

lld/wasm/SyntheticSections.cpp

 void DataCountSection::writeBody() {
   writeUleb128(bodyOutputStream, numSegments, "data count");
 }
 
 bool DataCountSection::isNeeded() const {
   return numSegments && config->sharedMemory;
 }
 
-static uint32_t getWasmFlags(const Symbol *sym) {
-  uint32_t flags = 0;
-  if (sym->isLocal())
-    flags |= WASM_SYMBOL_BINDING_LOCAL;
-  if (sym->isWeak())
-    flags |= WASM_SYMBOL_BINDING_WEAK;
-  if (sym->isHidden())
-    flags |= WASM_SYMBOL_VISIBILITY_HIDDEN;
-  if (sym->isUndefined())
-    flags |= WASM_SYMBOL_UNDEFINED;
-  if (auto *f = dyn_cast<UndefinedFunction>(sym)) {
-    if (f->getName() != f->importName)
-      flags |= WASM_SYMBOL_EXPLICIT_NAME;
-  } else if (auto *g = dyn_cast<UndefinedGlobal>(sym)) {
-    if (g->getName() != g->importName)
-      flags |= WASM_SYMBOL_EXPLICIT_NAME;
-  }
-  return flags;
-}
-
 void LinkingSection::writeBody() {
   raw_ostream &os = bodyOutputStream;
 
   writeUleb128(os, WasmMetadataVersion, "Version");
 
   if (!symtabEntries.empty()) {
     SubSection sub(WASM_SYMBOL_TABLE);
     writeUleb128(sub.os, symtabEntries.size(), "num symbols");
 
     for (const Symbol *sym : symtabEntries) {
       assert(sym->isDefined() || sym->isUndefined());
       WasmSymbolType kind = sym->getWasmType();
-      uint32_t flags = getWasmFlags(sym);
+      uint32_t flags = sym->getFlags();
 
       writeU8(sub.os, kind, "sym kind");
       writeUleb128(sub.os, flags, "sym flags");
 
       if (auto *f = dyn_cast<FunctionSymbol>(sym)) {
         writeUleb128(sub.os, f->getFunctionIndex(), "index");
         if (sym->isDefined() || (flags & WASM_SYMBOL_EXPLICIT_NAME) != 0)
           writeStr(sub.os, sym->getName(), "sym name");