Merge branch 'suspends-effect' into directize-resume

Author: tlively

src/ir/effects.cpp

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

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,7 +43,7 @@ class EffectAnalyzer {
       readsMutableArray(false), writesArray(false),
       readsSharedMutableArray(false), writesSharedArray(false), trap(false),
       implicitTrap(false), throws_(false), danglingPop(false),
-      mayNotReturn(false), hasReturnCallThrow(false), suspends_(false),
+      mayNotReturn(false), hasReturnCallThrow(false), suspends(false),
       module(module), features(module.features) {}
 
   EffectAnalyzer(const PassOptions& passOptions,
@@ -138,7 +137,7 @@ class EffectAnalyzer {
   // more here.)
   bool hasReturnCallThrow : 1;
 
-  bool suspends_ : 1;
+  bool suspends : 1;
 
   const Module& module;
   FeatureSet features;
@@ -230,7 +229,7 @@ class EffectAnalyzer {
     return calls || readsSharedMutableArray || writesSharedArray;
   }
   bool throws() const { return throws_ || !delegateTargets.empty(); }
-  bool suspends() const { return suspends_; }
+
   // Check whether this may transfer control flow to somewhere outside of this
   // 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;
@@ -240,25 +239,7 @@ class EffectAnalyzer {
   // transferred inside the function, but this expression does not know that),
   // or a suspension.
   bool transfersControlFlow() const {
-    return branchesOut || throws() || hasExternalBreakTargets() || suspends();
-  }
-
-  // Explicitly marks all global mutable state as clobbered (read and written).
-  void clobbersGlobalState() {
-    readsMemory = true;
-    writesMemory = true;
-    readsSharedMemory = true;
-    writesSharedMemory = true;
-    readsTable = true;
-    writesTable = true;
-    readsMutableStruct = true;
-    writesStruct = true;
-    readsSharedMutableStruct = true;
-    writesSharedStruct = true;
-    readsMutableArray = true;
-    writesArray = true;
-    readsSharedMutableArray = true;
-    writesSharedArray = true;
+    return branchesOut || suspends || throws() || hasExternalBreakTargets();
   }
 
   // Changes something in globally-stored state.
@@ -286,7 +267,7 @@ class EffectAnalyzer {
   bool hasNonTrapSideEffects() const {
     return localsWritten.size() > 0 || danglingPop || writesGlobalState() ||
            throws() || transfersControlFlow() || hasSynchronization() ||
-           mayNotReturn || suspends();
+           mayNotReturn;
   }
 
   bool hasSideEffects() const { return trap || hasNonTrapSideEffects(); }
@@ -502,7 +483,7 @@ class EffectAnalyzer {
     danglingPop = danglingPop || other.danglingPop;
     mayNotReturn = mayNotReturn || other.mayNotReturn;
     hasReturnCallThrow = hasReturnCallThrow || other.hasReturnCallThrow;
-    suspends_ = suspends_ || other.suspends_;
+    suspends = suspends || other.suspends;
     readOrder = std::max(readOrder, other.readOrder);
     writeOrder = std::max(writeOrder, other.writeOrder);
 
@@ -1296,8 +1277,8 @@ class EffectAnalyzer {
     void visitSuspend(Suspend* curr) {
       // Suspending transfers control to an enclosing handler and executes
       // arbitrary other code before we may resume here.
-      parent.suspends_ = true;
-      parent.clobbersGlobalState();
+      parent.suspends = true;
+      parent.calls = true;
       if (parent.features.hasExceptionHandling() && parent.tryDepth == 0) {
         parent.throws_ = true;
       }
@@ -1397,7 +1378,7 @@ class EffectAnalyzer {
       // 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;
+        parent.suspends = true;
       }
     }
   };
@@ -1489,7 +1470,7 @@ class EffectAnalyzer {
     if (danglingPop) {
       effects |= SideEffects::DanglingPop;
     }
-    if (suspends_) {
+    if (suspends) {
       effects |= SideEffects::Suspends;
     }
     return effects;
@@ -1507,7 +1488,7 @@ class EffectAnalyzer {
     breakTargets.clear();
     throws_ = false;
     delegateTargets.clear();
-    suspends_ = false;
+    suspends = false;
     assert(!transfersControlFlow());
   }
 

src/passes/GlobalEffects.cpp

@@ -143,7 +143,7 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
         // 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;
+        funcInfo.effects->suspends = false;
 
         struct CallScanner
           : public PostWalker<CallScanner,
@@ -188,8 +188,8 @@ std::map<Function*, FuncInfo> analyzeFuncs(Module& module,
               if (effects.throws_ && funcInfo.effects) {
                 funcInfo.effects->throws_ = true;
               }
-              if (effects.suspends_ && funcInfo.effects) {
-                funcInfo.effects->suspends_ = true;
+              if (effects.suspends && funcInfo.effects) {
+                funcInfo.effects->suspends = true;
               }
             }
           }

src/passes/OptimizeInstructions.cpp

@@ -1505,7 +1505,7 @@ struct OptimizeInstructions
       return;
     }
 
-    if (!target->effects || target->effects->suspends()) {
+    if (!target->effects || target->effects->suspends) {
       return;
     }
 

test/gtest/effects.cpp

@@ -54,31 +54,26 @@ TEST_F(EffectAnalyzerTest, Suspend) {
   EffectAnalyzer effects(options, wasm, func->body);
 
   // Suspension detection
-  EXPECT_TRUE(effects.suspends());
+  EXPECT_TRUE(effects.suspends);
   EXPECT_THAT(&effects, Suspends());
   EXPECT_TRUE(effects.getSideEffects() & EffectAnalyzer::SideEffects::Suspends);
 
-  // Decoupled from call graph edges
-  EXPECT_FALSE(effects.calls);
-  EXPECT_THAT(&effects, Not(Calls()));
-
-  // Clobbers all global mutable state
-  EXPECT_TRUE(effects.readsMemory);
-  EXPECT_TRUE(effects.writesMemory);
-  EXPECT_TRUE(effects.readsSharedMemory);
-  EXPECT_TRUE(effects.writesSharedMemory);
-  EXPECT_TRUE(effects.readsTable);
-  EXPECT_TRUE(effects.writesTable);
-  EXPECT_TRUE(effects.readsMutableStruct);
-  EXPECT_TRUE(effects.writesStruct);
-  EXPECT_TRUE(effects.readsSharedMutableStruct);
-  EXPECT_TRUE(effects.writesSharedStruct);
-  EXPECT_TRUE(effects.readsMutableArray);
-  EXPECT_TRUE(effects.writesArray);
-  EXPECT_TRUE(effects.readsSharedMutableArray);
-  EXPECT_TRUE(effects.writesSharedArray);
+  // Suspending executes arbitrary other code in the handler before resuming,
+  // modeled as a call.
+  EXPECT_TRUE(effects.calls);
+  EXPECT_THAT(&effects, Calls());
+
+  // Accesses all global mutable state via calls
+  EXPECT_TRUE(effects.accessesMemory());
+  EXPECT_TRUE(effects.accessesSharedMemory());
+  EXPECT_TRUE(effects.accessesTable());
+  EXPECT_TRUE(effects.accessesMutableStruct());
+  EXPECT_TRUE(effects.accessesSharedMutableStruct());
+  EXPECT_TRUE(effects.accessesArray());
+  EXPECT_TRUE(effects.accessesSharedArray());
   EXPECT_TRUE(effects.writesGlobalState());
   EXPECT_TRUE(effects.readsMutableGlobalState());
+  EXPECT_TRUE(effects.accessesSharedGlobalState());
 
   // Control flow & side effect queries
   EXPECT_TRUE(effects.transfersControlFlow());
@@ -107,12 +102,12 @@ TEST_F(EffectAnalyzerTest, UnknownCall) {
   // suspension.
   wasm.features.setStackSwitching(true);
   EffectAnalyzer effectsWithStackSwitch(options, wasm, caller->body);
-  EXPECT_TRUE(effectsWithStackSwitch.suspends());
+  EXPECT_TRUE(effectsWithStackSwitch.suspends);
 
   // With stack switching disabled, calls do not suspend.
   wasm.features.setStackSwitching(false);
   EffectAnalyzer effectsWithoutStackSwitch(options, wasm, caller->body);
-  EXPECT_FALSE(effectsWithoutStackSwitch.suspends());
+  EXPECT_FALSE(effectsWithoutStackSwitch.suspends);
 }
 
 } // anonymous namespace

test/gtest/matchers/effects.h

@@ -45,7 +45,7 @@ MATCHER(Throws, "") { return arg->throws_; }
 MATCHER(DanglingPop, "") { return arg->danglingPop; }
 MATCHER(MayNotReturn, "") { return arg->mayNotReturn; }
 MATCHER(HasReturnCallThrow, "") { return arg->hasReturnCallThrow; }
-MATCHER(Suspends, "") { return arg->suspends(); }
+MATCHER(Suspends, "") { return arg->suspends; }
 
 } // namespace wasm