[Outlining] Add TryTable (#7504)

Supports try_table in the stringify of the module, and filters out
try_table outlining sequences.

Author: ashleynh

src/passes/Outlining.cpp

@@ -151,6 +151,9 @@ struct ReconstructStringifyWalker
     } else if (reason.getCatchAllStart()) {
       ASSERT_OK(existingBuilder.visitCatchAll());
       ODBG(desc = "Catch All Start at");
+    } else if (auto curr = reason.getTryTableStart()) {
+      ODBG(desc = "Try Table Start at ");
+      ASSERT_OK(existingBuilder.visitTryTableStart(curr->tryt));
     } else if (reason.getEnd()) {
       ODBG(desc = "End at ");
       ASSERT_OK(existingBuilder.visitEnd());
@@ -346,9 +349,9 @@ struct Outlining : public Pass {
     substrings = StringifyProcessor::dedupe(substrings);
     // Remove substrings with overlapping indices.
     substrings = StringifyProcessor::filterOverlaps(substrings);
-    // Remove substrings with branch and return instructions until an analysis
-    // is performed to see if the intended destination of the branch is included
-    // in the substring to be outlined.
+    // Remove substrings with branch, return, and try_table instructions until
+    // an analysis is performed to see if the intended destination of the branch
+    // is included in the substring to be outlined.
     substrings =
       StringifyProcessor::filterBranches(substrings, stringify.exprs);
     // Remove substrings with local.set instructions until Outlining is extended

src/passes/hash-stringify-walker.cpp

@@ -269,7 +269,8 @@ std::vector<SuffixTree::RepeatedSubstring> StringifyProcessor::filterBranches(
   const std::vector<Expression*>& exprs) {
   return StringifyProcessor::filter(
     substrings, exprs, [](const Expression* curr) {
-      return Properties::isBranch(curr) || curr->is<Return>();
+      return Properties::isBranch(curr) || curr->is<Return>() ||
+             curr->is<TryTable>();
     });
 }
 

src/passes/stringify-walker-impl.h

@@ -118,6 +118,13 @@ template<typename SubType> void StringifyWalker<SubType>::dequeueControlFlow() {
       addUniqueSymbol(SeparatorReason::makeEnd());
       break;
     }
+    case Expression::Id::TryTableId: {
+      auto* tryt = curr->cast<TryTable>();
+      addUniqueSymbol(SeparatorReason::makeTryTableStart(tryt));
+      Super::walk(tryt->body);
+      addUniqueSymbol(SeparatorReason::makeEnd());
+      break;
+    }
     default: {
       assert(Properties::isControlFlowStructure(curr));
       WASM_UNREACHABLE("unexpected expression");

src/passes/stringify-walker.h

@@ -99,6 +99,10 @@ struct StringifyWalker
 
     struct CatchAllStart {};
 
+    struct TryTableStart {
+      TryTable* tryt;
+    };
+
     struct End {
       Expression* curr;
     };
@@ -110,6 +114,7 @@ struct StringifyWalker
                                    TryStart,
                                    CatchStart,
                                    CatchAllStart,
+                                   TryTableStart,
                                    End>;
 
     Separator reason;
@@ -140,6 +145,9 @@ struct StringifyWalker
     static SeparatorReason makeCatchAllStart() {
       return SeparatorReason(CatchAllStart{});
     }
+    static SeparatorReason makeTryTableStart(TryTable* tryt) {
+      return SeparatorReason(TryTableStart{tryt});
+    }
     static SeparatorReason makeEnd() { return SeparatorReason(End{}); }
     FuncStart* getFuncStart() { return std::get_if<FuncStart>(&reason); }
     BlockStart* getBlockStart() { return std::get_if<BlockStart>(&reason); }
@@ -151,6 +159,9 @@ struct StringifyWalker
     CatchAllStart* getCatchAllStart() {
       return std::get_if<CatchAllStart>(&reason);
     }
+    TryTableStart* getTryTableStart() {
+      return std::get_if<TryTableStart>(&reason);
+    }
     End* getEnd() { return std::get_if<End>(&reason); }
   };
 
@@ -173,6 +184,8 @@ struct StringifyWalker
       return o << "Catch Start";
     } else if (reason.getCatchAllStart()) {
       return o << "Catch All Start";
+    } else if (reason.getTryTableStart()) {
+      return o << "Try Table Start";
     } else if (reason.getEnd()) {
       return o << "End";
     }

test/lit/passes/outlining.wast

@@ -1244,3 +1244,63 @@
     )
   )
 )
+
+;; Tests TryTable instructions are correctly filtered from being outlined.
+;; The (drop (i32.const 0)) instructions were added to form an outlineable
+;; sequence with the block that contains the try_table.
+(module
+  ;; CHECK:      (type $1 (func (result (ref exn))))
+
+  ;; CHECK:      (type $0 (func))
+  (type $0 (func))
+  ;; CHECK:      (tag $tag$0 (type $0))
+  (tag $tag$0 (type $0))
+  ;; CHECK:      (func $a (type $1) (result (ref exn))
+  ;; CHECK-NEXT:  (loop $label1
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (block
+  ;; CHECK-NEXT:    (try_table (catch_all $label1)
+  ;; CHECK-NEXT:     (throw $tag$0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $a (result (ref exn))
+    (loop $label1 (result (ref exn))
+      (drop
+        (i32.const 0)
+      )
+      (block (result (ref exn))
+        (try_table (catch_all $label1)
+          (throw $tag$0)
+        )
+      )
+    )
+  )
+  ;; CHECK:      (func $b (type $1) (result (ref exn))
+  ;; CHECK-NEXT:  (loop $label1
+  ;; CHECK-NEXT:   (drop
+  ;; CHECK-NEXT:    (i32.const 0)
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:   (block
+  ;; CHECK-NEXT:    (try_table (catch_all $label1)
+  ;; CHECK-NEXT:     (throw $tag$0)
+  ;; CHECK-NEXT:    )
+  ;; CHECK-NEXT:   )
+  ;; CHECK-NEXT:  )
+  ;; CHECK-NEXT: )
+  (func $b (result (ref exn))
+    (loop $label1 (result (ref exn))
+      (drop
+        (i32.const 0)
+      )
+      (block (result (ref exn))
+        (try_table (catch_all $label1)
+          (throw $tag$0)
+        )
+      )
+    )
+  )
+)