Add asyncify-export-globals argument (#8074)

In the past emscripten would build the main module as relocatable, but
these days we build it statically and in that case it makes sense for
the main module to define and export these globals, rather than defining
them in JS.

Author: sbc100

src/passes/Asyncify.cpp

@@ -323,6 +323,20 @@
 // model where you can specify "instrument, but not indirect calls from me"
 // would likely have little benefit.)
 //
+// In addition, there are arguments for controlling the import/export of the
+// internal globals used by Asyncify.  These can be useful in dynamic linking.
+// By default these globals are are internal and neither imported nor exported.
+//
+//   --pass-arg=import-globals
+//
+//      Import the internal globals used by Asyncify. This allows them to be
+//      defined in another module.
+//
+//   --pass-arg=export-globals
+//
+//      Export the internal globals used by Asyncify.  This allows them to be
+//      imported into anther module built with --pass-arg=import-globals
+//
 // TODO When wasm has GC, extending the live ranges of locals can keep things
 //      alive unnecessarily. We may want to set locals to null at the end
 //      of their original range.
@@ -1759,7 +1773,11 @@ struct Asyncify : public Pass {
       String::Split::NewLineOr(","));
     auto asserts = hasArgument("asyncify-asserts");
     auto verbose = hasArgument("asyncify-verbose");
-    auto relocatable = hasArgument("asyncify-relocatable");
+    // TODO: Remove the legacy asyncify-relocatable name once emscripten is
+    // updated.
+    auto importGlobals = hasArgument("asyncify-import-globals") ||
+                         hasArgument("asyncify-relocatable");
+    auto exportGlobals = hasArgument("asyncify-export-globals");
     auto secondaryMemory = hasArgument("asyncify-in-secondary-memory");
     auto propagateAddList = hasArgument("asyncify-propagate-addlist");
 
@@ -1826,7 +1844,7 @@ struct Asyncify : public Pass {
                             verbose);
 
     // Add necessary globals before we emit code to use them.
-    addGlobals(module, relocatable);
+    addGlobals(module, importGlobals, exportGlobals);
 
     // Compute the set of functions we will instrument. All of the passes we run
     // below only need to run there.
@@ -1904,8 +1922,11 @@ struct Asyncify : public Pass {
   }
 
 private:
-  void addGlobals(Module* module, bool imported) {
+  void addGlobals(Module* module, bool imported, bool exported) {
     Builder builder(*module);
+    // It doesn't make sense to both import and export these globals at the
+    // same time.
+    assert(!(imported && exported));
 
     auto asyncifyState = builder.makeGlobal(ASYNCIFY_STATE,
                                             Type::i32,
@@ -1926,6 +1947,13 @@ struct Asyncify : public Pass {
       asyncifyData->base = ASYNCIFY_DATA;
     }
     module->addGlobal(std::move(asyncifyData));
+
+    if (exported) {
+      module->addExport(builder.makeExport(
+        ASYNCIFY_STATE, ASYNCIFY_STATE, ExternalKind::Global));
+      module->addExport(
+        builder.makeExport(ASYNCIFY_DATA, ASYNCIFY_DATA, ExternalKind::Global));
+    }
   }
 
   void addFunctions(Module* module) {

test/lit/passes/asyncify_pass-arg=asyncify-export-globals.wast

@@ -0,0 +1,11 @@
+;; RUN: wasm-opt --enable-mutable-globals --asyncify --pass-arg=asyncify-export-globals -S -o - | filecheck %s
+
+(module
+)
+;; CHECK:      (global $__asyncify_state (mut i32) (i32.const 0))
+
+;; CHECK:      (global $__asyncify_data (mut i32) (i32.const 0))
+
+;; CHECK:      (export "__asyncify_state" (global $__asyncify_state))
+
+;; CHECK:      (export "__asyncify_data" (global $__asyncify_data))

test/lit/passes/asyncify_pass-arg=asyncify-import-globals.wast

@@ -0,0 +1,10 @@
+;; RUN: wasm-opt --enable-mutable-globals --asyncify --pass-arg=asyncify-import-globals -S -o - | filecheck %s
+
+;; Also test asyncify-relocatable which is an alias for asyncify-import-globals
+;; RUN: wasm-opt --enable-mutable-globals --asyncify --pass-arg=asyncify-relocatable -S -o - | filecheck %s
+
+(module
+)
+
+;; CHECK:      (import "env" "__asyncify_state" (global $__asyncify_state (mut i32)))
+;; CHECK:      (import "env" "__asyncify_data" (global $__asyncify_data (mut i32)))