ConstraintAnalysis: Handle fallthrough values (#9000)

Author: kripken

src/passes/ConstraintAnalysis.cpp

@@ -543,7 +543,33 @@ struct ConstraintAnalysis
       }
 #endif
 
-      constraints.set(set->index, set->value);
+      // Look at the fallthrough. It is valid to do so, because our constraints
+      // only track two things, constants and locals. For a constant, it does
+      // not change while falling through. For a local, the only way for the
+      // local to change while falling through is to go through a tee of that
+      // local - but that would keep the same value there anyhow. That is:
+      //
+      //  (local.set $other
+      //    (block
+      //      ..
+      //      (local.tee $source
+      //        (block
+      //          ..
+      //          (local.get $source)
+      //        )
+      //      )
+      //    )
+      //  )
+      //
+      // The fallthrough here is the local.get of $source. We can set $other to
+      // the value in $source, because while $source did have a write while
+      // falling through, it did not alter the value, and there is no
+      // opportunity to write any other value while falling through. (And, any
+      // local.tee appearing here would have been reached earlier in the
+      // traversal, and handled.)
+      auto* value =
+        Properties::getFallthrough(set->value, getPassOptions(), *getModule());
+      constraints.set(set->index, value);
     }
   }
 

test/lit/passes/constraint-analysis.wast

@@ -4608,4 +4608,45 @@
       )
     )
   )
+
+  ;; CHECK:      (func $fallthrough (type $1)
+  ;; CHECK-NEXT:  (local $x i32)
+  ;; CHECK-NEXT:  (local.set $x
+  ;; CHECK-NEXT:   (block (result i32)
+  ;; CHECK-NEXT:    (call $fallthrough)
+  ;; CHECK-NEXT:    (i32.const 10)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (i32.const 1)
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  ;; OPTIN:      (func $fallthrough (type $1)
+  ;; OPTIN-NEXT:  (local $x i32)
+  ;; OPTIN-NEXT:  (local.set $x
+  ;; OPTIN-NEXT:   (block (result i32)
+  ;; OPTIN-NEXT:    (call $fallthrough)
+  ;; OPTIN-NEXT:    (i32.const 10)
+  ;; OPTIN-NEXT:   )
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT:  (drop
+  ;; OPTIN-NEXT:   (i32.const 1)
+  ;; OPTIN-NEXT:  )
+  ;; OPTIN-NEXT: )
+  (func $fallthrough
+    ;; We can read values through a fallthrough.
+    (local $x i32)
+    (local.set $x
+      (block (result i32)
+        (call $fallthrough)
+        (i32.const 10)
+      )
+    )
+    (drop
+      (i32.eq
+        (local.get $x)
+        (i32.const 10)
+      )
+    )
+  )
 )