[WebAssembly] Implement NO_STRIP

[sunfish]

Summary

This patch replaces https://reviews.llvm.org/D62443 and removes the Emscripten-specific behavior. It just implements support for the NO_STRIP flag, which will allow __attribute__((used)) to be implemented.

This accompanies https://reviews.llvm.org/D62542, which will move to setting the NO_STRIP flag, and will continue to set EXPORTED for Emscripten targets for compatibility.

[sbc100]

I'm curious why a user would want to use WASM_SYMBOL_NO_STRIP if it doesn't export the symbol? Maybe for post-linker to do stuff perhaps?

Do you have plan for how you want to allow llvm user to export symbols with wasm32-wasi? Presumably using custom attribute?

Presumably tests will go with the followup CLs?

tools/lld/wasm/MarkLive.cpp

72 ↗

(On Diff #217950)

Update the comment?

[sunfish]

Include the basic test case.

[sunfish]

In D66968#1651483, @sbc100 wrote:

I'm curious why a user would want to use WASM_SYMBOL_NO_STRIP if it doesn't export the symbol? Maybe for post-linker to do stuff perhaps?

I've seen people use it to make something available in a debugger. But in any case, this is how __attribute__((used)) works on other platforms.

Do you have plan for how you want to allow llvm user to export symbols with wasm32-wasi? Presumably using custom attribute?

I don't have a specific proposal yet, but yes, I'm picturing something like __attribute__((export_name("foo"))).

Presumably tests will go with the followup CLs?

Oops, I lost the test change when I removed the other changes from the patch. I've now included it.

[sunfish]

tools/lld/wasm/MarkLive.cpp

72 ↗

(On Diff #217950)

Updated in the new patch.

docs/ReleaseNotes.rst

 MachO Improvements
 ------------------
 
 * Item 1.
 
 WebAssembly Improvements
 ------------------------
 
-* ...
+* `__data_end` and `__heap_base` are no longer exported by default,
+  as it's best to keep them internal when possible. They can be
+  explicitly exported with `--export=__data_end` and
+  `--export=__heap_base`, respectively.

docs/WebAssembly.rst

 unit but with too many arguments.
 
 In order not to generate such invalid modules, lld has two modes of handling such
 mismatches: it can simply error-out or it can create stub functions that will
 trap at runtime (functions that contain only an ``unreachable`` instruction)
 and use these stub functions at the otherwise invalid call sites.
 
 The default behaviour is to generate these stub function and to produce
-a warning.  The ``--falal-warnings`` flag can be used to disable this behaviour
+a warning.  The ``--fatal-warnings`` flag can be used to disable this behaviour
 and error out if mismatched are found.
 
 Imports and Exports
 ~~~~~~~~~~~~~~~~~~~
 
 When building a shared library any symbols marked as ``visibility=default`` will
 be exported.  When building an executable, only the entry point and symbols
 flagged as ``WASM_SYMBOL_EXPORTED`` are exported by default.  In LLVM the

test/wasm/export.ll

+; Test in default mode
 ; RUN: llc -filetype=obj %s -o %t.o
 ; RUN: not wasm-ld --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
 ; RUN: wasm-ld --export=hidden_function -o %t.wasm %t.o
 ; RUN: obj2yaml %t.wasm | FileCheck %s
 
+; Now test in Emscripten mode
+; RUN: llc -filetype=obj %s -o %t.o -mtriple=wasm32-unknown-emscripten
+; RUN: not wasm-ld --export=missing -o %t.wasm %t.o 2>&1 | FileCheck -check-prefix=CHECK-ERROR %s
+; RUN: wasm-ld --export=hidden_function -o %t.wasm %t.o
+; RUN: obj2yaml %t.wasm | FileCheck %s --check-prefixes=CHECK,EMSCRIPTEN
+
 @llvm.used = appending global [1 x i8*] [i8* bitcast (i32 ()* @used_function to i8*)], section "llvm.metadata"
 
 target triple = "wasm32-unknown-unknown"
 
 ; Not exported by default, but forced via commandline
 define hidden i32 @hidden_function() local_unnamed_addr {
 entry:
   ret i32 0

 ; CHECK:        - Type:            EXPORT
 ; CHECK-NEXT:     Exports:
 ; CHECK-NEXT:       - Name:            memory
 ; CHECK-NEXT:         Kind:            MEMORY
 ; CHECK-NEXT:         Index:           0
 ; CHECK-NEXT:       - Name:            hidden_function
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           0
-; CHECK-NEXT:       - Name:            used_function
-; CHECK-NEXT:         Kind:            FUNCTION
-; CHECK-NEXT:         Index:           1
+; EMSCRIPTEN-NEXT:  - Name:            used_function
+; EMSCRIPTEN-NEXT:    Kind:            FUNCTION
+; EMSCRIPTEN-NEXT:    Index:           1
 ; CHECK-NEXT:       - Name:            _start
 ; CHECK-NEXT:         Kind:            FUNCTION
 ; CHECK-NEXT:         Index:           2
 ; CHECK-NEXT:   - Type:            CODE

wasm/LTO.cpp

for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // 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());
     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;

wasm/MarkLive.cpp

if (sym == WasmSym::callCtors) {
       }
     }
   };
 
   // Add GC root symbols.
   if (!config->entry.empty())
     enqueue(symtab->find(config->entry));
 
-  // We need to preserve any exported symbol
+  // We need to preserve any no-strip or exported symbol
   for (Symbol *sym : symtab->getSymbols())
-    if (sym->isExported())
+    if (sym->isNoStrip() || sym->isExported())
       enqueue(sym);
 
   // For relocatable output, we need to preserve all the ctor functions
   if (config->relocatable) {
     for (const ObjFile *obj : symtab->objectFiles) {
       const WasmLinkingData &l = obj->getWasmObj()->linkingData();
       for (const WasmInitFunc &f : l.InitFunctions)
         enqueue(obj->getFunctionSymbol(f.Symbol));

wasm/Symbols.h

public:
   // Get/set the index in the output symbol table.  This is only used for
   // relocatable output.
   uint32_t getOutputSymbolIndex() const;
   void setOutputSymbolIndex(uint32_t index);
 
   WasmSymbolType getWasmType() const;
   bool isExported() const;
 
+  // Indicates that the symbol is used in an __attribute__((used)) directive
+  // or similar.
+  bool isNoStrip() const;
+
   const WasmSignature* getSignature() const;
 
   bool isInGOT() const { return gotIndex != INVALID_INDEX; }
 
   uint32_t getGOTIndex() const {
     assert(gotIndex != INVALID_INDEX);
     return gotIndex;
   }

wasm/Symbols.cpp

if (forceExport || config->exportAll)
     return true;
 
   if (config->exportDynamic && !isHidden())
     return true;
 
   return flags & WASM_SYMBOL_EXPORTED;
 }
 
+bool Symbol::isNoStrip() const {
+  return flags & WASM_SYMBOL_NO_STRIP;
+}
+
 uint32_t FunctionSymbol::getFunctionIndex() const {
   if (auto *f = dyn_cast<DefinedFunction>(this))
     return f->function->getFunctionIndex();
   assert(functionIndex != INVALID_INDEX);
   return functionIndex;
 }
 
 void FunctionSymbol::setFunctionIndex(uint32_t index) {