[WebAssembly] Add symbol flag to the binary format corresponding to llvm.used

[sbc100]

Summary

Rather than add a new attribute for forcing the symbol to be alive and exported
in the final wasm binary we can use the existing llvm.used/no_dead_strip
mechanism.

See https://github.com/WebAssembly/tool-conventions/issues/64

[sbc100]

• update obj2yaml

[sbc100]

update

[sbc100]

rebase

include/llvm/BinaryFormat/Wasm.h

 const unsigned WASM_SYMBOL_VISIBILITY_MASK = 0xc;
 
 const unsigned WASM_SYMBOL_BINDING_GLOBAL = 0x0;
 const unsigned WASM_SYMBOL_BINDING_WEAK = 0x1;
 const unsigned WASM_SYMBOL_BINDING_LOCAL = 0x2;
 const unsigned WASM_SYMBOL_VISIBILITY_DEFAULT = 0x0;
 const unsigned WASM_SYMBOL_VISIBILITY_HIDDEN = 0x4;
 const unsigned WASM_SYMBOL_UNDEFINED = 0x10;
+const unsigned WASM_SYMBOL_EXPORTED = 0x20;
 
 #define WASM_RELOC(name, value) name = value,
 
 enum : unsigned {
 #include "WasmRelocs.def"
 };
 
 #undef WASM_RELOC

include/llvm/MC/MCSymbolWasm.h

public:
   bool isFunction() const { return Type == wasm::WASM_SYMBOL_TYPE_FUNCTION; }
   bool isData() const { return Type == wasm::WASM_SYMBOL_TYPE_DATA; }
   bool isGlobal() const { return Type == wasm::WASM_SYMBOL_TYPE_GLOBAL; }
   bool isSection() const { return Type == wasm::WASM_SYMBOL_TYPE_SECTION; }
   bool isEvent() const { return Type == wasm::WASM_SYMBOL_TYPE_EVENT; }
   wasm::WasmSymbolType getType() const { return Type; }
   void setType(wasm::WasmSymbolType type) { Type = type; }
 
+  bool isExported() const {
+    return getFlags() & wasm::WASM_SYMBOL_EXPORTED;
+  }
+  void setExported() const {
+    modifyFlags(wasm::WASM_SYMBOL_EXPORTED, wasm::WASM_SYMBOL_EXPORTED);
+  }
+
   bool isWeak() const { return IsWeak; }
   void setWeak(bool isWeak) { IsWeak = isWeak; }
 
   bool isHidden() const { return IsHidden; }
   void setHidden(bool isHidden) { IsHidden = isHidden; }
 
   bool isComdat() const { return IsComdat; }
   void setComdat(bool isComdat) { IsComdat = isComdat; }

lib/MC/MCAsmInfoWasm.cpp

 
 #include "llvm/MC/MCAsmInfoWasm.h"
 using namespace llvm;
 
 void MCAsmInfoWasm::anchor() {}
 
 MCAsmInfoWasm::MCAsmInfoWasm() {
   HasIdentDirective = true;
+  HasNoDeadStrip = true;
   WeakRefDirective = "\t.weak\t";
   PrivateGlobalPrefix = ".L";
   PrivateLabelPrefix = ".L";
 }

lib/MC/MCWasmStreamer.cpp

bool MCWasmStreamer::EmitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
   case MCSA_ELF_TypeFunction:
     Symbol->setType(wasm::WASM_SYMBOL_TYPE_FUNCTION);
     break;
 
   case MCSA_ELF_TypeObject:
   case MCSA_Cold:
     break;
 
+  case MCSA_NoDeadStrip:
+    Symbol->setExported();
+    break;
+
   default:
     // unrecognized directive
     llvm_unreachable("unexpected MCSymbolAttr");
     return false;
   }
 
   return true;
 }

lib/MC/WasmObjectWriter.cpp

for (const MCSymbol &S : Asm.symbols()) {
     if (WS.isWeak())
       Flags |= wasm::WASM_SYMBOL_BINDING_WEAK;
     if (WS.isHidden())
       Flags |= wasm::WASM_SYMBOL_VISIBILITY_HIDDEN;
     if (!WS.isExternal() && WS.isDefined())
       Flags |= wasm::WASM_SYMBOL_BINDING_LOCAL;
     if (WS.isUndefined())
       Flags |= wasm::WASM_SYMBOL_UNDEFINED;
+    if (WS.isExported())
+      Flags |= wasm::WASM_SYMBOL_EXPORTED;
 
     wasm::WasmSymbolInfo Info;
     Info.Name = WS.getName();
     Info.Kind = WS.getType();
     Info.Flags = Flags;
     if (!WS.isData()) {
       assert(WasmIndices.count(&WS) > 0);
       Info.ElementIndex = WasmIndices.find(&WS)->second;

lib/ObjectYAML/WasmYAML.cpp

 #define BCaseMask(M, X)                                                        \
   IO.maskedBitSetCase(Value, #X, wasm::WASM_SYMBOL_##X, wasm::WASM_SYMBOL_##M)
   // BCaseMask(BINDING_MASK, BINDING_GLOBAL);
   BCaseMask(BINDING_MASK, BINDING_WEAK);
   BCaseMask(BINDING_MASK, BINDING_LOCAL);
   // BCaseMask(VISIBILITY_MASK, VISIBILITY_DEFAULT);
   BCaseMask(VISIBILITY_MASK, VISIBILITY_HIDDEN);
   BCaseMask(UNDEFINED, UNDEFINED);
+  BCaseMask(EXPORTED, EXPORTED);
 #undef BCaseMask
 }
 
 void ScalarEnumerationTraits<WasmYAML::SymbolKind>::enumeration(
     IO &IO, WasmYAML::SymbolKind &Kind) {
 #define ECase(X) IO.enumCase(Kind, #X, wasm::WASM_SYMBOL_TYPE_##X);
   ECase(FUNCTION);
   ECase(DATA);

test/MC/WebAssembly/no-dead-strip.ll

+; RUN: llc -filetype=obj -wasm-keep-registers %s -o - | llvm-readobj --symbols | FileCheck %s
+
+target triple = "wasm32-unknown-unknown"
+
[e-mail] = appending global [1 x i8*] [i8* bitcast (i32 ()* @foo to i8*)], section "llvm.metadata"
+
+define i32 @foo() {
+entry:
+    ret i32 0
+}
+
+; CHECK:      Symbols [
+; CHECK-NEXT:   Symbol {
+; CHECK-NEXT:     Name: foo
+; CHECK-NEXT:     Type: FUNCTION (0x0)
+; CHECK-NEXT:     Flags [ (0x20)
+; CHECK-NEXT:       EXPORTED (0x20)
+; CHECK-NEXT:     ]
+; CHECK-NEXT:     ElementIndex: 0x0
+; CHECK-NEXT:   }
+; CHECK-NEXT: ]

tools/llvm-readobj/WasmDumper.cpp

 #define ENUM_ENTRY(X)                                                          \
   { #X, wasm::WASM_SYMBOL_##X }
   ENUM_ENTRY(BINDING_GLOBAL),
   ENUM_ENTRY(BINDING_WEAK),
   ENUM_ENTRY(BINDING_LOCAL),
   ENUM_ENTRY(VISIBILITY_DEFAULT),
   ENUM_ENTRY(VISIBILITY_HIDDEN),
   ENUM_ENTRY(UNDEFINED),
+  ENUM_ENTRY(EXPORTED),
 #undef ENUM_ENTRY
 };
 
 class WasmDumper : public ObjDumper {
 public:
   WasmDumper(const WasmObjectFile *Obj, ScopedPrinter &Writer)
       : ObjDumper(Writer), Obj(Obj) {}