Add a suspends effect (#9070)

This will be necessary for a future optimization that turns resumes of
continuations that never suspend into calls. Update the effect analysis
of suspends to set the new effect and clobber global state because the
suspend handler might do anything before returning. Test that the
effects are analyzed as intended and that they work with global effect
analysis.

Author: tlively

scripts/test/wasm2js.py

@@ -88,10 +88,11 @@ def test_wasm2js_output():
             for module, asserts in support.split_wast(t):
                 support.write_wast('split.wast', module, asserts)
 
-                # wasm2js does not yet support EH, and enabling it can reduce
-                # optimization opportunities
+                # wasm2js does not yet support EH or stack switching, and
+                # enabling them can reduce optimization opportunities
                 cmd = shared.WASM2JS + ['split.wast', '-all',
-                                        '--disable-exception-handling']
+                                        '--disable-exception-handling',
+                                        '--disable-stack-switching']
                 if opt:
                     cmd += ['-O']
                 if 'emscripten' in basename:
@@ -150,7 +151,8 @@ def test_asserts_output():
 
         wasm = os.path.join(shared.get_test_dir('wasm2js'), wasm)
         cmd = shared.WASM2JS + [wasm, '--allow-asserts', '-all',
-                                '--disable-exception-handling']
+                                '--disable-exception-handling',
+                                '--disable-stack-switching']
         out = support.run_command(cmd)
         shared.fail_if_not_identical_to_file(out, asserts_expected_file)
 
@@ -201,10 +203,11 @@ def update_wasm2js_tests():
             for module, asserts in support.split_wast(t):
                 support.write_wast('split.wast', module, asserts)
 
-                # wasm2js does not yet support EH, and enable it can reduce
-                # optimization opportunities
+                # wasm2js does not yet support EH or stack switching, and
+                # enabling them can reduce optimization opportunities
                 cmd = shared.WASM2JS + ['split.wast', '-all',
-                                        '--disable-exception-handling']
+                                        '--disable-exception-handling',
+                                        '--disable-stack-switching']
                 if opt:
                     cmd += ['-O']
                 if 'emscripten' in basename:
@@ -225,7 +228,7 @@ def update_wasm2js_tests():
         asserts_expected_file = os.path.join(shared.options.binaryen_test, 'wasm2js', asserts)
         traps_expected_file = os.path.join(shared.options.binaryen_test, 'wasm2js', traps)
 
-        cmd = shared.WASM2JS + [os.path.join(shared.get_test_dir('wasm2js'), wasm), '--allow-asserts', '-all', '--disable-exception-handling']
+        cmd = shared.WASM2JS + [os.path.join(shared.get_test_dir('wasm2js'), wasm), '--allow-asserts', '-all', '--disable-exception-handling', '--disable-stack-switching']
         out = support.run_command(cmd)
         with open(asserts_expected_file, 'w') as o:
             o.write(out)

src/binaryen-c.cpp

@@ -6687,6 +6687,10 @@ BinaryenSideEffects BinaryenSideEffectDanglingPop(void) {
   return static_cast<BinaryenSideEffects>(
     EffectAnalyzer::SideEffects::DanglingPop);
 }
+BinaryenSideEffects BinaryenSideEffectSuspends(void) {
+  return static_cast<BinaryenSideEffects>(
+    EffectAnalyzer::SideEffects::Suspends);
+}
 BinaryenSideEffects BinaryenSideEffectAny(void) {
   return static_cast<BinaryenSideEffects>(EffectAnalyzer::SideEffects::Any);
 }

src/binaryen-c.h

@@ -3669,6 +3669,7 @@ BINARYEN_API BinaryenSideEffects BinaryenSideEffectTrapsNeverHappen(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectIsAtomic(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectThrows(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectDanglingPop(void);
+BINARYEN_API BinaryenSideEffects BinaryenSideEffectSuspends(void);
 BINARYEN_API BinaryenSideEffects BinaryenSideEffectAny(void);
 
 BINARYEN_API BinaryenSideEffects BinaryenExpressionGetSideEffects(

src/ir/effects.cpp

@@ -96,6 +96,9 @@ std::ostream& operator<<(std::ostream& o, const EffectAnalyzer& effects) {
   if (effects.throws_) {
     o << "throws_\n";
   }
+  if (effects.suspends) {
+    o << "suspends_\n";
+  }
   if (effects.tryDepth) {
     o << "tryDepth\n";
   }

src/ir/effects.h

@@ -23,7 +23,6 @@
 #include "ir/intrinsics.h"
 #include "pass.h"
 #include "support/name.h"
-#include "support/utilities.h"
 #include "wasm-traversal.h"
 #include "wasm-type.h"
 #include "wasm.h"
@@ -44,8 +43,8 @@ class EffectAnalyzer {
       readsMutableArray(false), writesArray(false),
       readsSharedMutableArray(false), writesSharedArray(false), trap(false),
       implicitTrap(false), throws_(false), danglingPop(false),
-      mayNotReturn(false), hasReturnCallThrow(false), module(module),
-      features(module.features) {}
+      mayNotReturn(false), hasReturnCallThrow(false), suspends(false),
+      module(module), features(module.features) {}
 
   EffectAnalyzer(const PassOptions& passOptions,
                  const Module& module,
@@ -138,6 +137,8 @@ class EffectAnalyzer {
   // more here.)
   bool hasReturnCallThrow : 1;
 
+  bool suspends : 1;
+
   const Module& module;
   FeatureSet features;
 
@@ -228,15 +229,17 @@ class EffectAnalyzer {
     return calls || readsSharedMutableArray || writesSharedArray;
   }
   bool throws() const { return throws_ || !delegateTargets.empty(); }
+
   // Check whether this may transfer control flow to somewhere outside of this
-  // expression (aside from just flowing out normally). That includes a break
-  // or a throw (if the throw is not known to be caught inside this expression;
+  // expression (aside from just flowing out normally). That includes a break,
+  // a throw (if the throw is not known to be caught inside this expression;
   // note that if the throw is not caught in this expression then it might be
   // caught in this function but outside of this expression, or it might not be
   // caught in the function at all, which would mean control flow cannot be
-  // transferred inside the function, but this expression does not know that).
+  // transferred inside the function, but this expression does not know that),
+  // or a suspension.
   bool transfersControlFlow() const {
-    return branchesOut || throws() || hasExternalBreakTargets();
+    return branchesOut || suspends || throws() || hasExternalBreakTargets();
   }
 
   // Changes something in globally-stored state.
@@ -480,6 +483,7 @@ class EffectAnalyzer {
     danglingPop = danglingPop || other.danglingPop;
     mayNotReturn = mayNotReturn || other.mayNotReturn;
     hasReturnCallThrow = hasReturnCallThrow || other.hasReturnCallThrow;
+    suspends = suspends || other.suspends;
     readOrder = std::max(readOrder, other.readOrder);
     writeOrder = std::max(writeOrder, other.writeOrder);
 
@@ -1271,8 +1275,9 @@ class EffectAnalyzer {
       parent.calls = true;
     }
     void visitSuspend(Suspend* curr) {
-      // Similar to resume/call: Suspending means that we execute arbitrary
-      // other code before we may resume here.
+      // Suspending transfers control to an enclosing handler and executes
+      // arbitrary other code before we may resume here.
+      parent.suspends = true;
       parent.calls = true;
       if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) {
         parent.throws_ = true;
@@ -1370,6 +1375,11 @@ class EffectAnalyzer {
           parent.throws_ = true;
         }
       }
+      // If stack switching is enabled and we don't have global effects
+      // information, assume that the call target may suspend.
+      if (parent.features.hasStackSwitching()) {
+        parent.suspends = true;
+      }
     }
   };
 
@@ -1407,7 +1417,8 @@ class EffectAnalyzer {
     Throws = 1 << 12,
     DanglingPop = 1 << 13,
     TrapsNeverHappen = 1 << 14,
-    Any = (1 << 15) - 1
+    Suspends = 1 << 15,
+    Any = (1 << 16) - 1
   };
   uint32_t getSideEffects() const {
     uint32_t effects = 0;
@@ -1459,12 +1470,15 @@ class EffectAnalyzer {
     if (danglingPop) {
       effects |= SideEffects::DanglingPop;
     }
+    if (suspends) {
+      effects |= SideEffects::Suspends;
+    }
     return effects;
   }
 
-  // Ignores all forms of control flow transfers: breaks, returns, and
-  // exceptions. (Note that traps are not considered relevant here - a trap does
-  // not just transfer control flow, but can be seen as halting the entire
+  // Ignores all forms of control flow transfers: breaks, returns, exceptions,
+  // and suspensions. (Note that traps are not considered relevant here - a trap
+  // does not just transfer control flow, but can be seen as halting the entire
   // program.)
   //
   // This function matches transfersControlFlow(), that is, after calling this
@@ -1474,6 +1488,7 @@ class EffectAnalyzer {
     breakTargets.clear();
     throws_ = false;
     delegateTargets.clear();
+    suspends = false;
     assert(!transfersControlFlow());
   }
 

src/js/binaryen.js-post.js

@@ -666,6 +666,7 @@ function initializeConstants() {
     'Throws',
     'DanglingPop',
     'TrapsNeverHappen',
+    'Suspends',
     'Any'
   ].forEach(name => {
     Module['SideEffects'][name] = Module['_BinaryenSideEffect' + name]();

src/passes/GlobalEffects.cpp

@@ -138,10 +138,12 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
         // below.
         funcInfo.effects->calls = false;
 
-        // Clear throws as well, as we are "forgetting" calls right now, and
-        // want to forget their throwing effect as well. If we see something
-        // else that throws, below, then we'll note that there.
+        // Clear throws and suspends as well, as we are "forgetting" calls right
+        // now, and want to forget their throwing and suspending effects as
+        // well. If we see something else that throws or suspends, below, then
+        // we'll note that there.
         funcInfo.effects->throws_ = false;
+        funcInfo.effects->suspends = false;
 
         struct CallScanner
           : public PostWalker<CallScanner,
@@ -179,12 +181,16 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
               assert(options.worldMode == WorldMode::Open);
               funcInfo.effects = std::nullopt;
             } else {
-              // No call here, but update throwing if we see it. (Only do so,
-              // however, if we have effects; if we cleared it - see before -
-              // then we assume the worst anyhow, and have nothing to update.)
+              // No call here, but update throwing and suspending if we see it.
+              // (Only do so, however, if we have effects; if we cleared it -
+              // see before - then we assume the worst anyhow, and have nothing
+              // to update.)
               if (effects.throws_ && funcInfo.effects) {
                 funcInfo.effects->throws_ = true;
               }
+              if (effects.suspends && funcInfo.effects) {
+                funcInfo.effects->suspends = true;
+              }
             }
           }
         };

test/binaryen.js/sideffects.js

@@ -14,6 +14,7 @@ console.log("SideEffects.IsAtomic=" + binaryen.SideEffects.IsAtomic);
 console.log("SideEffects.Throws=" + binaryen.SideEffects.Throws);
 console.log("SideEffects.DanglingPop=" + binaryen.SideEffects.DanglingPop);
 console.log("SideEffects.TrapsNeverHappen=" + binaryen.SideEffects.TrapsNeverHappen);
+console.log("SideEffects.Suspends=" + binaryen.SideEffects.Suspends);
 console.log("SideEffects.Any=" + binaryen.SideEffects.Any);
 
 var module = new binaryen.Module();
@@ -114,7 +115,7 @@ assert(
 );
 
 // If exception handling feature is enabled, calls can throw
-module.setFeatures(binaryen.Features.All);
+module.setFeatures(binaryen.Features.ExceptionHandling);
 assert(
   binaryen.getSideEffects(
     module.call("test", [], binaryen.i32),
@@ -124,6 +125,28 @@ assert(
   (binaryen.SideEffects.Calls | binaryen.SideEffects.Throws)
 );
 
+// If stack switching feature is enabled, calls can suspend
+module.setFeatures(binaryen.Features.StackSwitching);
+assert(
+  binaryen.getSideEffects(
+    module.call("test", [], binaryen.i32),
+    module
+  )
+  ==
+  (binaryen.SideEffects.Calls | binaryen.SideEffects.Suspends)
+);
+
+// If all features are enabled, calls can throw and suspend
+module.setFeatures(binaryen.Features.All);
+assert(
+  binaryen.getSideEffects(
+    module.call("test", [], binaryen.i32),
+    module
+  )
+  ==
+  (binaryen.SideEffects.Calls | binaryen.SideEffects.Throws | binaryen.SideEffects.Suspends)
+);
+
 assert(
   binaryen.getSideEffects(
     module.drop(module.i32.pop()),

test/binaryen.js/sideffects.js.txt

@@ -14,4 +14,5 @@ SideEffects.IsAtomic=2048
 SideEffects.Throws=4096
 SideEffects.DanglingPop=8192
 SideEffects.TrapsNeverHappen=16384
-SideEffects.Any=32767
+SideEffects.Suspends=32768
+SideEffects.Any=65535

test/gtest/CMakeLists.txt

@@ -15,6 +15,7 @@ set(unittest_SOURCES
   delta_debugging.cpp
   dfa_minimization.cpp
   disjoint_sets.cpp
+  effects.cpp
   graph.cpp
   int128.cpp
   leaves.cpp