Add support for the new JavaScript promise integration API. (#17724)

- Enables the new "jspi" pass in binaryen.
- Wraps all imports/exports in a suspending/promising. WebAssembly.Function.


This currently wraps everything, but we could make it only wrap async
functions as needed.

Author: brendandahl

emcc.py

@@ -600,6 +600,8 @@ def check_human_readable_list(items):
     if settings.ASYNCIFY_ONLY:
       check_human_readable_list(settings.ASYNCIFY_ONLY)
       passes += ['--pass-arg=asyncify-onlylist@%s' % ','.join(settings.ASYNCIFY_ONLY)]
+  elif settings.ASYNCIFY == 2:
+    passes += ['--jspi']
   if settings.BINARYEN_IGNORE_IMPLICIT_TRAPS:
     passes += ['--ignore-implicit-traps']
   # normally we can assume the memory, if imported, has not been modified

emscripten.py

@@ -141,6 +141,9 @@ def update_settings_glue(wasm_file, metadata):
 
   # start with the MVP features, and add any detected features.
   settings.BINARYEN_FEATURES = ['--mvp-features'] + metadata['features']
+  if settings.ASYNCIFY == 2:
+    settings.BINARYEN_FEATURES += ['--enable-reference-types']
+
   if settings.USE_PTHREADS:
     assert '--enable-threads' in settings.BINARYEN_FEATURES
   if settings.MEMORY64:

src/library_async.js

@@ -57,9 +57,6 @@ mergeInto(LibraryManager.library, {
     //       malloc() asyncify does (we could ifdef it out, but it's even more
     //       ifdefing).
 
-    // The global suspender object used with the VM's stack switching Promise
-    // API.
-    suspender: null,
     // The promise that is being suspended on in the VM atm, or null.
     promise: null,
     // The function we should call to resolve the promise at the right time.
@@ -79,11 +76,6 @@ mergeInto(LibraryManager.library, {
     instrumentWasmImports: function(imports) {
 #if ASYNCIFY_DEBUG
       err('asyncify instrumenting imports');
-#endif
-#if ASYNCIFY == 2
-      // TODO we could perhaps add an init function and put this there, but
-      //      this should work for now.
-      Asyncify.suspender = new WebAssembly.Suspender();
 #endif
       var ASYNCIFY_IMPORTS = {{{ JSON.stringify(ASYNCIFY_IMPORTS) }}}.map((x) => x.split('.')[1]);
       for (var x in imports) {
@@ -94,24 +86,23 @@ mergeInto(LibraryManager.library, {
             var isAsyncifyImport = ASYNCIFY_IMPORTS.indexOf(x) >= 0 ||
                                    x.startsWith('__asyncjs__');
 #if ASYNCIFY == 2
-            if (isAsyncifyImport) {
+            // Wrap all imports with a suspending WebAssembly function.
+            // TODO: wrap only async functions.
 #if ASSERTIONS
-              if (!sig) {
-                throw new Error('Missing __sig for ' + x);
-              }
+            assert(sig, 'Missing __sig for ' + x);
 #endif
-              var type = sigToWasmTypes(sig, original);
-              // Regardless of the original result type of the function, as it
-              // is now expected to potentially return a Promise, change it to
-              // an externref.
-              type.results = ['externref'];
+            var type = sigToWasmTypes(sig, original);
 #if ASYNCIFY_DEBUG
-              err('asyncify: suspendOnReturnedPromise for', x, original);
+            err('asyncify: suspendOnReturnedPromise for', x, original);
 #endif
-              imports[x] = original = Asyncify.suspender.suspendOnReturnedPromise(
-                new WebAssembly.Function(type, original)
-              );
-            }
+            // Add space for the suspender promise that will be used in the
+            // Wasm wrapper function.
+            type.parameters.unshift('externref');
+            imports[x] = original = new WebAssembly.Function(
+              type,
+              original,
+              { suspending: 'first' }
+            );
 #endif
 #if ASSERTIONS && ASYNCIFY != 2 // We cannot apply assertions with stack switching, as the imports must not be modified from suspender.suspendOnReturnedPromise TODO find a way
             imports[x] = function() {
@@ -159,16 +150,26 @@ mergeInto(LibraryManager.library, {
       for (var x in exports) {
         (function(x) {
           var original = exports[x];
+          if (typeof original == 'function') {
 #if ASYNCIFY == 2
-          // TODO: need a list of all suspending exports.
-          if (x === 'main') {
+            // Wrap all exports with a promising WebAssembly function.
+            // TODO: wrap only async functions.
 #if ASYNCIFY_DEBUG
             err('asyncify: returnPromiseOnSuspend for', x, original);
 #endif
-            ret[x] = original = Asyncify.suspender.returnPromiseOnSuspend(original);
-          }
+            var type = WebAssembly.Function.type(original);
+            var parameters = type.parameters;
+            var results = type.results;
+#if ASSERTIONS
+            assert(results.length !== 0, 'There must be a return result')
+#endif
+            // Remove the extern ref;
+            parameters.shift();
+            original = new WebAssembly.Function(
+              { parameters , results: ['externref'] },
+              original,
+              { promising : 'first' });
 #endif
-          if (typeof original == 'function') {
             ret[x] = function() {
 #if ASYNCIFY_DEBUG >= 2
               err('ASYNCIFY: ' + '  '.repeat(Asyncify.exportCallStack.length) + ' try ' + x);

src/postamble.js

@@ -180,9 +180,20 @@ function callMain(args) {
 #if ASSERTIONS
     assert(ret == 0, '_emscripten_proxy_main failed to start proxy thread: ' + ret);
 #endif
+#else
+#if ASYNCIFY == 2
+    // The current spec of JSPI returns a promise only if the function suspends
+    // and a plain value otherwise. This will likely change:
+    // https://github.com/WebAssembly/js-promise-integration/issues/11
+    Promise.resolve(ret).then((result) => {
+      exitJS(result, /* implicit = */ true);
+    }).catch((e) => {
+      handleException(e);
+    });
 #else
     // if we're not running an evented main loop, it's time to exit
     exitJS(ret, /* implicit = */ true);
+#endif // ASYNCIFY == 2
     return ret;
   }
   catch (e) {

test/test_core.py

@@ -8012,8 +8012,6 @@ def test_vswprintf_utf8(self):
   @no_wasm64('TODO: asyncify for wasm64')
   @with_asyncify_and_stack_switching
   def test_async_hello(self):
-    if self.get_setting('ASYNCIFY') == 2:
-      self.skipTest('https://github.com/emscripten-core/emscripten/issues/17532')
     # needs to flush stdio streams
     self.set_setting('EXIT_RUNTIME')