[WebAssembly] Add --export-all flag

[sbc100]

Summary

This causes all symbols to be exported in the final wasm binary
even if they were not compiled with default visibility.

This feature is useful for the emscripten toolchain that has a
corresponding EXPORT_ALL feature which allows the JS code to
interact with all C function.

[sbc100]

• revert

[sbc100]

Gentle ping, this is the last change needed to switch the lld by default in the llvm-backend-enabled emscripten toolchain.

[ruiu]

wasm/Writer.cpp

757 ↗

(On Diff #150063)

Why? I'd expand this comment a bit so that it includes the background and a future plan.

[sbc100]

• feedback

[sbc100]

• typo

[ruiu]

wasm/Driver.cpp

408 ↗

(On Diff #150240)

nit: implemented

[ruiu]

LGTM

lld/trunk/test/wasm/export-all.ll

+; RUN: llc -O0 -filetype=obj %s -o %t.o
+
+; RUN: wasm-ld -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s
+
+; RUN: wasm-ld --export-all -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=EXPORT
+
+; RUN: wasm-ld --export-all --no-gc-sections -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s -check-prefix=NOGC
+
+; Verify the --export-all flag exports hidden symbols
+
+target triple = "wasm32-unknown-unknown"
+
+define hidden void @bar() local_unnamed_addr {
+entry:
+  ret void
+}
+
+define hidden void @foo() local_unnamed_addr {
+entry:
+  ret void
+}
+
+define hidden void @_start() local_unnamed_addr {
+entry:
+  call void @foo()
+  ret void
+}
+
+; CHECK:      - Type:            EXPORT
+; CHECK:         - Name:            _start
+; CHECK-NOT:     - Name:            bar
+; CHECK-NOT:     - Name:            foo
+
+; EXPORT:     - Type:            EXPORT
+; EXPORT:        - Name:            _start
+; EXPORT-NOT:    - Name:            bar
+; EXPORT:        - Name:            foo
+
+; NOGC:       - Type:            EXPORT
+; NOGC:        - Name:            _start
+; NOGC:        - Name:            bar
+; NOGC:        - Name:            foo

lld/trunk/wasm/Config.h

 namespace lld {
 namespace wasm {
 
 struct Configuration {
   bool AllowUndefined;
   bool CompressRelocTargets;
   bool Demangle;
   bool DisableVerify;
+  bool ExportAll;
   bool ExportTable;
   bool GcSections;
   bool ImportMemory;
   bool ImportTable;
   bool MergeDataSegments;
   bool PrintGcSections;
   bool Relocatable;
   bool SaveTemps;

lld/trunk/wasm/Driver.cpp

void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   cl::ParseCommandLineOptions(V.size(), V.data());
 
   errorHandler().ErrorLimit = args::getInteger(Args, OPT_error_limit, 20);
 
   Config->AllowUndefined = Args.hasArg(OPT_allow_undefined);
   Config->Demangle = Args.hasFlag(OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->Entry = getEntry(Args, Args.hasArg(OPT_relocatable) ? "" : "_start");
+  Config->ExportAll = Args.hasArg(OPT_export_all);
   Config->ExportTable = Args.hasArg(OPT_export_table);
   errorHandler().FatalWarnings =
       Args.hasFlag(OPT_fatal_warnings, OPT_no_fatal_warnings, false);
   Config->ImportMemory = Args.hasArg(OPT_import_memory);
   Config->ImportTable = Args.hasArg(OPT_import_table);
   Config->LTOO = args::getInteger(Args, OPT_lto_O, 2);
   Config->LTOPartitions = args::getInteger(Args, OPT_lto_partitions, 1);
   Config->Optimize = args::getInteger(Args, OPT_O, 0);
if (Config->Relocatable) {
     if (Config->GcSections)
       error("-r and --gc-sections may not be used together");
     if (Args.hasArg(OPT_undefined))
       error("-r -and --undefined may not be used together");
   }
 
   Symbol *EntrySym = nullptr;
   if (!Config->Relocatable) {
-    // Can't export the SP right now because it's mutable, and mutable
-    // globals aren't yet supported in the official binary format.
-    // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN if/when the
-    // "mutable global" proposal is accepted.
     llvm::wasm::WasmGlobal Global;
     Global.Type = {WASM_TYPE_I32, true};
     Global.InitExpr.Value.Int32 = 0;
     Global.InitExpr.Opcode = WASM_OPCODE_I32_CONST;
     Global.SymbolName = "__stack_pointer";
     InputGlobal *StackPointer = make<InputGlobal>(Global, nullptr);
     StackPointer->Live = true;
 
     static WasmSignature NullSignature = {{}, WASM_TYPE_NORESULT};
 
     // Add synthetic symbols before any others
     WasmSym::CallCtors = Symtab->addSyntheticFunction(
         "__wasm_call_ctors", WASM_SYMBOL_VISIBILITY_HIDDEN,
         make<SyntheticFunction>(NullSignature, "__wasm_call_ctors"));
+    // TODO(sbc): Remove WASM_SYMBOL_VISIBILITY_HIDDEN when the mutable global
+    // spec proposal is implemented in all major browsers.
+    // See: https://github.com/WebAssembly/mutable-global
     WasmSym::StackPointer = Symtab->addSyntheticGlobal(
         "__stack_pointer", WASM_SYMBOL_VISIBILITY_HIDDEN, StackPointer);
     WasmSym::HeapBase = Symtab->addSyntheticDataSymbol("__heap_base", 0);
     WasmSym::DsoHandle = Symtab->addSyntheticDataSymbol(
         "__dso_handle", WASM_SYMBOL_VISIBILITY_HIDDEN);
     WasmSym::DataEnd = Symtab->addSyntheticDataSymbol("__data_end", 0);
 
     // For now, since we don't actually use the start function as the

lld/trunk/wasm/Options.td

def allow_undefined_file: J<"allow-undefined-file=">,
   HelpText<"Allow symbols listed in <file> to be undefined in linked binary">;
 
 def allow_undefined_file_s: Separate<["-"], "allow-undefined-file">,
   Alias<allow_undefined_file>;
 
 defm export: Eq<"export">,
   HelpText<"Force a symbol to be exported">;
 
+def export_all: F<"export-all">,
+  HelpText<"Export all symbols (normally combined with --no-gc-sections)">;
+
 def export_table: F<"export-table">,
   HelpText<"Export function table to the environment">;
 
 def global_base: J<"global-base=">,
   HelpText<"Where to start to place global data">;
 
 def import_memory: F<"import-memory">,
   HelpText<"Import memory from the environment">;

lld/trunk/wasm/Writer.cpp

void Writer::calculateExports() {
   if (!Config->Relocatable && Config->ExportTable)
     Exports.push_back(WasmExport{kFunctionTableName, WASM_EXTERNAL_TABLE, 0});
 
   unsigned FakeGlobalIndex = NumImportedGlobals + InputGlobals.size();
 
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!Sym->isDefined())
       continue;
-    if (Sym->isHidden() || Sym->isLocal())
+    if (Sym->isHidden() && !Config->ExportAll)
+      continue;
+    if (Sym->isLocal())
       continue;
     if (!Sym->isLive())
       continue;
 
     StringRef Name = Sym->getName();
     WasmExport Export;
     if (auto *F = dyn_cast<DefinedFunction>(Sym)) {
       Export = {Name, WASM_EXTERNAL_FUNCTION, F->getFunctionIndex()};
     } else if (auto *G = dyn_cast<DefinedGlobal>(Sym)) {
+      // TODO(sbc): Remove this check once to mutable global proposal is
+      // implement in all major browsers.
+      // See: https://github.com/WebAssembly/mutable-global
+      if (G->getGlobalType()->Mutable) {
+        // Only the __stack_pointer should ever be create as mutable.
+        assert(G == WasmSym::StackPointer);
+        continue;
+      }
       Export = {Name, WASM_EXTERNAL_GLOBAL, G->getGlobalIndex()};
     } else {
       auto *D = cast<DefinedData>(Sym);
       DefinedFakeGlobals.emplace_back(D);
       Export = {Name, WASM_EXTERNAL_GLOBAL, FakeGlobalIndex++};
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << Name << "\n");