LinearExecutionWalker indirect call effects

Author: stevenfontanella

src/ir/linear-execution.h

@@ -80,7 +80,12 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
   static void scan(SubType* self, Expression** currp) {
     Expression* curr = *currp;
 
-    auto handleCall = [&](bool mayThrow, bool isReturn) {
+    auto handleCall = [&](bool isReturn, const EffectAnalyzer* effects) {
+      bool refutesThrowEffect = effects && !effects->throws();
+      bool mayThrow = !self->getModule() ||
+                      self->getModule()->features.hasExceptionHandling();
+      mayThrow = mayThrow && !refutesThrowEffect;
+
       if (!self->connectAdjacentBlocks) {
         // Control is nonlinear if we return or throw. Traps don't need to be
         // taken into account since they don't break control flow in a way
@@ -156,40 +161,39 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
       case Expression::Id::CallId: {
         auto* call = curr->cast<Call>();
 
-        bool mayThrow = !self->getModule() ||
-                        self->getModule()->features.hasExceptionHandling();
-        if (mayThrow && self->getModule()) {
-          auto* effects =
-            self->getModule()->getFunction(call->target)->effects.get();
-
-          if (effects && !effects->throws_) {
-            mayThrow = false;
-          }
-        }
-
-        handleCall(mayThrow, call->isReturn);
+        const EffectAnalyzer* effects =
+          self->getModule()
+            ? self->getModule()->getFunction(call->target)->effects.get()
+            : nullptr;
+        handleCall(call->isReturn, effects);
         break;
       }
       case Expression::Id::CallRefId: {
         auto* callRef = curr->cast<CallRef>();
 
-        // TODO: Effect analysis for indirect calls isn't implemented yet.
-        // Assume any indirect call may throw for now.
-        bool mayThrow = !self->getModule() ||
-                        self->getModule()->features.hasExceptionHandling();
-
-        handleCall(mayThrow, callRef->isReturn);
+        const EffectAnalyzer* effects = nullptr;
+        if (self->getModule()) {
+          if (const auto& effects_ptr =
+                find_or_null(self->getModule()->indirectCallEffects,
+                             callRef->target->type.getHeapType())) {
+            effects = effects_ptr->get();
+          }
+        }
+        handleCall(callRef->isReturn, effects);
         break;
       }
       case Expression::Id::CallIndirectId: {
         auto* callIndirect = curr->cast<CallIndirect>();
 
-        // TODO: Effect analysis for indirect calls isn't implemented yet.
-        // Assume any indirect call may throw for now.
-        bool mayThrow = !self->getModule() ||
-                        self->getModule()->features.hasExceptionHandling();
-
-        handleCall(mayThrow, callIndirect->isReturn);
+        const EffectAnalyzer* effects = nullptr;
+        if (self->getModule()) {
+          if (const auto& effects_ptr =
+                find_or_null(self->getModule()->indirectCallEffects,
+                             callIndirect->heapType)) {
+            effects = effects_ptr->get();
+          }
+        }
+        handleCall(callIndirect->isReturn, effects);
         break;
       }
       case Expression::Id::TryId: {

src/support/utilities.h

@@ -107,6 +107,14 @@ template<typename... Ts> struct overloaded : Ts... {
 
 template<typename... Ts> overloaded(Ts...) -> overloaded<Ts...>;
 
+// Lookup a value from `map` and return a pointer to the underlying value
+// or nullptr if not present. Returns a const pointer if `map` is const and
+// non-const otherwise
+auto* find_or_null(auto& map, const auto& key) {
+  auto it = map.find(key);
+  return it != map.end() ? &it->second : nullptr;
+}
+
 } // namespace wasm
 
 #endif // wasm_support_utilities_h

test/lit/passes/simplify-locals-global-effects-eh.wast

@@ -92,24 +92,20 @@
 
   ;; CHECK:      (func $read-g (type $3) (param $ref (ref null $const-type)) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
-  ;; CHECK-NEXT:  (local.set $x
-  ;; CHECK-NEXT:   (global.get $g)
-  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (call_ref $const-type
   ;; CHECK-NEXT:    (local.get $ref)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
-  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT:  (global.get $g)
   ;; CHECK-NEXT: )
   (func $read-g (param $ref (ref null $const-type)) (result i32)
     (local $x i32)
     (local.set $x (global.get $g))
 
-    ;; With more precise effect analysis for indirect calls, we can determine
-    ;; that the only possible target for this ref is $const in a closed world,
-    ;; which wouldn't block our optimizations.
-    ;; TODO: Add effects analysis for indirect calls.
+    ;; With --closed-world enabled, we can tell that this can only possibly call
+    ;; $const, which doesn't block our optimizations.
     (drop (call_ref $const-type (local.get $ref)))
 
     (local.get $x)
@@ -140,15 +136,13 @@
 
   ;; CHECK:      (func $read-g-with-call-indirect-in-between (type $5) (result i32)
   ;; CHECK-NEXT:  (local $x i32)
-  ;; CHECK-NEXT:  (local.set $x
-  ;; CHECK-NEXT:   (global.get $g)
-  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (nop)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (call_indirect $t (type $const-type)
   ;; CHECK-NEXT:    (i32.const 0)
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
-  ;; CHECK-NEXT:  (local.get $x)
+  ;; CHECK-NEXT:  (global.get $g)
   ;; CHECK-NEXT: )
   (func $read-g-with-call-indirect-in-between (result i32)
     (local $x i32)