Handle try in Flatten pass

This adds handling of try in the Flatten pass. This is in a way similar
to 'if' handling.

Author: aheejin

src/passes/Flatten.cpp

@@ -166,6 +166,36 @@ struct Flatten
         loop->finalize();
         replaceCurrent(rep);
 
+      } else if (auto* tryy = curr->dynCast<Try>()) {
+        // remove a try value
+        Expression* rep = tryy;
+        auto* originalBody = tryy->body;
+        auto* originalCatchBody = tryy->catchBody;
+        auto type = tryy->type;
+        Expression* prelude = nullptr;
+        if (type.isConcrete()) {
+          Index temp = builder.addVar(getFunction(), type);
+          if (tryy->body->type.isConcrete()) {
+            tryy->body = builder.makeLocalSet(temp, tryy->body);
+          }
+          if (tryy->catchBody->type.isConcrete()) {
+            tryy->catchBody = builder.makeLocalSet(temp, tryy->catchBody);
+          }
+          // the whole try is now a prelude
+          prelude = tryy;
+          // and we leave just a get of the value
+          rep = builder.makeLocalGet(temp, type);
+        }
+        tryy->body = getPreludesWithExpression(originalBody, tryy->body);
+        tryy->catchBody =
+          getPreludesWithExpression(originalCatchBody, tryy->catchBody);
+        tryy->finalize();
+        if (prelude) {
+          ReFinalizeNode().visit(prelude);
+          ourPreludes.push_back(prelude);
+        }
+        replaceCurrent(rep);
+
       } else {
         WASM_UNREACHABLE("unexpected expr type");
       }
@@ -218,10 +248,9 @@ struct Flatten
             //   )
             // )
             // In this case we need two locals to store (ref.null); one with
-            // anyref type that's for the target block ($label0) and one more
-            // with nullref type in case for flowing out. Here we create the
-            // second 'flowing out' local in case two block's types are
-            // different.
+            // anyref type that's for the target block ($any) and one more with
+            // nullref type in case for flowing out. Here we create the second
+            // 'flowing out' local in case two block's types are different.
             if (type != blockType) {
               temp = builder.addVar(getFunction(), type);
               ourPreludes.push_back(builder.makeLocalSet(
@@ -273,7 +302,6 @@ struct Flatten
         }
       }
     }
-    // TODO Handle br_on_exn
 
     // continue for general handling of everything, control flow or otherwise
     curr = getCurrent(); // we may have replaced it

test/passes/flatten_all-features.txt

@@ -4,12 +4,14 @@
  (type $i32_i32_=>_none (func (param i32 i32)))
  (type $i32_=>_i32 (func (param i32) (result i32)))
  (type $none_=>_f32 (func (result f32)))
+ (type $i32_=>_none (func (param i32)))
  (type $i64_i64_=>_i64 (func (param i64 i64) (result i64)))
  (type $none_=>_anyref (func (result anyref)))
  (memory $0 10)
  (table $0 1 1 funcref)
  (elem (i32.const 0) $call-me)
  (global $x (mut i32) (i32.const 0))
+ (event $e0 (attr 0) (param i32))
  (func $a1 (; 0 ;)
   (local $0 i32)
   (local.set $0
@@ -2240,15 +2242,15 @@
   (local $5 nullref)
   (local $6 nullref)
   (local $7 anyref)
-  (block $label0
+  (block $any
    (block $block
     (local.set $1
      (ref.null)
     )
     (local.set $2
      (ref.null)
     )
-    (br_if $label0
+    (br_if $any
      (i32.const 0)
     )
     (local.set $3
@@ -2278,4 +2280,38 @@
    (local.get $7)
   )
  )
+ (func $try_catch (; 44 ;)
+  (local $exn exnref)
+  (local $1 exnref)
+  (try
+   (throw $e0
+    (i32.const 0)
+   )
+   (catch
+    (local.set $1
+     (exnref.pop)
+    )
+    (local.set $exn
+     (local.get $1)
+    )
+   )
+  )
+ )
+ (func $try_catch_br (; 45 ;)
+  (local $0 exnref)
+  (block $label$0
+   (try
+    (nop)
+    (catch
+     (local.set $0
+      (exnref.pop)
+     )
+     (drop
+      (local.get $0)
+     )
+     (br $label$0)
+    )
+   )
+  )
+ )
 )

test/passes/flatten_all-features.wast

@@ -1028,15 +1028,39 @@
   ;; value type, we need the value to be set into two locals: one with the outer
   ;; block's type, and one with its value type.
   (func $subtype (result anyref) (local $0 nullref)
-    (block $label0 (result anyref)
+    (block $any (result anyref)
       (block (result nullref)
         (local.tee $0
-          (br_if $label0
+          (br_if $any
             (ref.null)
             (i32.const 0)
           )
         )
       )
     )
   )
+
+  (event $e0 (attr 0) (param i32))
+  (func $try_catch (local $exn exnref)
+    (try
+      (throw $e0 (i32.const 0))
+      (catch
+        (local.set $exn (exnref.pop))
+      )
+    )
+  )
+
+ (func $try_catch_br
+   (block $label$0
+     (try
+       (nop)
+       (catch
+         (drop
+           (exnref.pop)
+         )
+         (br $label$0)
+       )
+     )
+   )
+ )
 )