[lld][WebAssembly] Fix --export-all when __stack_pointer is present

[sbc100]

Summary

With https://reviews.llvm.org/D87537 we made it an error
to export a mutable global with the +mutable-globals feature
present. However, this broke the use of the --export-all
flag because the __stack_pointer which is present in almost
all programs is a mutable global.

This also revealed that we didn't have any test coverage for
the --export-all flag.

This change fixes the current breakage on the emscripten-releases
roller.

[sbc100]

fix

[tlively]

Looks good!

lld/test/wasm/mutable-globals.s

2

Why was this change necessary?

lld/wasm/Writer.cpp

1117–1118

I'm nervous that some of the intervening steps might have depended on the features having been parsed for some reason, but if there was no test breakage, there's probably no issue.

[sbc100]

lld/test/wasm/mutable-globals.s

2

Because I moved the calculation of the features section later on the link process, the error regarding foo being undefined now get generated before the error we are checking for here mutable global imported but 'mutable-globals' feature not present in inputs.

Does this seems like a reasonable change?

[sbc100]

revert part

[sbc100]

lld/test/wasm/mutable-globals.s

2

Landing https://reviews.llvm.org/D87666 first made this unnecessary so I could revert it.

lld/test/wasm/export-all.s

+# RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
+# RUN: wasm-ld --export-all -o %t.wasm %t.o
+# RUN: obj2yaml %t.wasm | FileCheck %s
+
+.globl _start
+
+_start:
+  .functype _start () -> ()
+  i32.const 3
+  global.set __stack_pointer
+  end_function
+
+foo:
+  .functype foo () -> (i32)
+  i32.const 42
+  end_function
+
+.globaltype __stack_pointer, i32
+
+#      CHECK:   - Type:            EXPORT
+# CHECK-NEXT:     Exports:
+# CHECK-NEXT:       - Name:            memory
+# CHECK-NEXT:         Kind:            MEMORY
+# CHECK-NEXT:         Index:           0
+# CHECK-NEXT:       - Name:            __wasm_call_ctors
+# CHECK-NEXT:         Kind:            FUNCTION
+# CHECK-NEXT:         Index:           0
+# CHECK-NEXT:       - Name:            _start
+# CHECK-NEXT:         Kind:            FUNCTION
+# CHECK-NEXT:         Index:           1
+# CHECK-NEXT:       - Name:            __dso_handle
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           1
+# CHECK-NEXT:       - Name:            __data_end
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           2
+# CHECK-NEXT:       - Name:            __global_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           3
+# CHECK-NEXT:       - Name:            __heap_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           4
+# CHECK-NEXT:       - Name:            __memory_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           5
+# CHECK-NEXT:       - Name:            __table_base
+# CHECK-NEXT:         Kind:            GLOBAL
+# CHECK-NEXT:         Index:           6

lld/test/wasm/mutable-globals.s

 # RUN: llvm-mc -filetype=obj -triple=wasm32-unknown-unknown -o %t.o %s
-# RUN: not wasm-ld %t.o -o %t.wasm 2>&1 | FileCheck %s
+# RUN: not wasm-ld --allow-undefined %t.o -o %t.wasm 2>&1 | FileCheck %s
 
 .globl _start
 _start:
   .functype _start () -> ()
   i32.const 1
   global.set foo
   end_function
 
 .globaltype foo, i32
 
 # CHECK: error: mutable global imported but 'mutable-globals' feature not present in inputs: `foo`. Use --no-check-features to suppress.

lld/wasm/SyntheticSections.h

 
 class ExportSection : public SyntheticSection {
 public:
   ExportSection() : SyntheticSection(llvm::wasm::WASM_SEC_EXPORT) {}
   bool isNeeded() const override { return exports.size() > 0; }
   void writeBody() override;
 
   std::vector<llvm::wasm::WasmExport> exports;
+  std::vector<const Symbol *> exportedSymbols;
 };
 
 class StartSection : public SyntheticSection {
 public:
   StartSection(bool hasInitializedSegments)
       : SyntheticSection(llvm::wasm::WASM_SEC_START),
         hasInitializedSegments(hasInitializedSegments) {}
   bool isNeeded() const override;

lld/wasm/Writer.cpp

if (!config->relocatable && allowed.count("atomics") &&
     else
       error("'atomics' feature is used, so --shared-memory must be used");
   }
 
   if (!config->checkFeatures)
     return;
 
   if (!config->relocatable && used.count("mutable-globals") == 0) {
-    for (Symbol *sym : symtab->getSymbols()) {
+    for (const Symbol *sym : out.importSec->importedSymbols) {
       if (auto *global = dyn_cast<GlobalSymbol>(sym)) {
         if (global->getGlobalType()->Mutable) {
-          if (!sym->isLive())
-            continue;
-          if (!sym->isUsedInRegularObj)
-            continue;
-          if (sym->isUndefined() && sym->isWeak() && !config->relocatable)
-            continue;
-          if (sym->isUndefined())
-            error(Twine("mutable global imported but 'mutable-globals' feature "
-                        "not present in inputs: `") +
-                  toString(*sym) + "`. Use --no-check-features to suppress.");
-          else if (sym->isExported())
-            error(Twine("mutable global exported but 'mutable-globals' feature "
-                        "not present in inputs: `") +
-                  toString(*sym) + "`. Use --no-check-features to suppress.");
-        }
-      }
-    }
-  }
+        }
+      }
+    }
+    for (const Symbol *sym : out.exportSec->exportedSymbols) {
+      if (auto *global = dyn_cast<GlobalSymbol>(sym)) {
 
   if (config->sharedMemory) {
     if (disallowed.count("shared-mem"))
       error("--shared-memory is disallowed by " + disallowed["shared-mem"] +
             " because it was not compiled with 'atomics' or 'bulk-memory' "
             "features.");
 
     for (auto feature : {"atomics", "bulk-memory"})
for (Symbol *sym : symtab->getSymbols()) {
     } else {
       auto *d = cast<DefinedData>(sym);
       out.globalSec->dataAddressGlobals.push_back(d);
       export_ = {name, WASM_EXTERNAL_GLOBAL, globalIndex++};
     }
 
     LLVM_DEBUG(dbgs() << "Export: " << name << "\n");
     out.exportSec->exports.push_back(export_);
+    out.exportSec->exportedSymbols.push_back(sym);
   }
 }
 
 void Writer::populateSymtab() {
   if (!config->relocatable && !config->emitRelocs)
     return;
 
   for (Symbol *sym : symtab->getSymbols())
void Writer::run() {
   }
 
   log("-- createOutputSegments");
   createOutputSegments();
   log("-- createSyntheticSections");
   createSyntheticSections();
   log("-- populateProducers");
   populateProducers();
-  log("-- populateTargetFeatures");
-  populateTargetFeatures();
   log("-- calculateImports");
   calculateImports();
   log("-- layoutMemory");
   layoutMemory();
 
   if (!config->relocatable) {
     // Create linker synthesized __start_SECNAME/__stop_SECNAME symbols
     // This has to be done after memory layout is performed.
void Writer::run() {
   log("-- calculateTypes");
   calculateTypes();
   log("-- calculateExports");
   calculateExports();
   log("-- calculateCustomSections");
   calculateCustomSections();
   log("-- populateSymtab");
   populateSymtab();
+  log("-- populateTargetFeatures");
+  populateTargetFeatures();
   log("-- addSections");
   addSections();
 
   if (errorHandler().verbose) {
     log("Defined Functions: " + Twine(out.functionSec->inputFunctions.size()));
     log("Defined Globals  : " + Twine(out.globalSec->numGlobals()));
     log("Defined Events   : " + Twine(out.eventSec->inputEvents.size()));
     log("Function Imports : " +