TupleOptimization: Handle copies of different types in unreachable code (#5956)

2 files changed, 32 insertions, 4 deletions

diff --git a/src/passes/TupleOptimization.cpp b/src/passes/TupleOptimization.cpp
index f4fd0910b..e4fb1cf00 100644
--- a/src/passes/TupleOptimization.cpp
+++ b/src/passes/TupleOptimization.cpp
@@ -125,10 +125,18 @@ struct TupleOptimization : public WalkerPass<PostWalker<TupleOptimization>> {
       // a get), or a tuple.make.
       if (auto* tee = value->dynCast<LocalSet>()) {
         assert(tee->isTee());
-        validUses[tee->index]++;
-        validUses[curr->index]++;
-        copiedIndexes[tee->index].insert(curr->index);
-        copiedIndexes[curr->index].insert(tee->index);
+        // We don't want to count anything as valid if the inner tee is
+        // unreachable. In that case the outer tee is also unreachable, of
+        // course, and in fact they might not even have the same tuple type or
+        // the inner one might not even be a tuple (since we are in unreachable
+        // code, that is possible). We could try to optimize unreachable tees in
+        // some cases, but it's simpler to let DCE simplify the code first.
+        if (tee->type != Type::unreachable) {
+          validUses[tee->index]++;
+          validUses[curr->index]++;
+          copiedIndexes[tee->index].insert(curr->index);
+          copiedIndexes[curr->index].insert(tee->index);
+        }
       } else if (auto* get = value->dynCast<LocalGet>()) {
         validUses[get->index]++;
         validUses[curr->index]++;
diff --git a/test/lit/passes/tuple-optimization.wast b/test/lit/passes/tuple-optimization.wast
index 1788b91e9..766f51e81 100644
--- a/test/lit/passes/tuple-optimization.wast
+++ b/test/lit/passes/tuple-optimization.wast
@@ -569,6 +569,7 @@
 
   ;; CHECK:      (func $unreachability (type $0)
   ;; CHECK-NEXT:  (local $tuple (i32 i32))
+  ;; CHECK-NEXT:  (local $nontuple f64)
   ;; CHECK-NEXT:  (local.set $tuple
   ;; CHECK-NEXT:   (tuple.make
   ;; CHECK-NEXT:    (i32.const 1)
@@ -590,9 +591,17 @@
   ;; CHECK-NEXT:    )
   ;; CHECK-NEXT:   )
   ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT:  (drop
+  ;; CHECK-NEXT:   (local.tee $tuple
+  ;; CHECK-NEXT:    (local.tee $nontuple
+  ;; CHECK-NEXT:     (unreachable)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $unreachability
     (local $tuple (i32 i32))
+    (local $nontuple f64)
     (local.set $tuple
       (tuple.make
         (i32.const 1)
@@ -615,6 +624,17 @@
         )
       )
     )
+    ;; Teeing a nontuple into a tuple is allowed in unreachable code (the input
+    ;; to the outer tee is simply unreachable, so there is no checking that we
+    ;; are copying a local into another local of a compatible type). We should
+    ;; not error here.
+    (drop
+      (local.tee $tuple
+        (local.tee $nontuple
+          (unreachable)
+        )
+      )
+    )
   )
 
   ;; CHECK:      (func $tee-chain (type $0)