Complete the support for try_table.

This includes adding interpreter support for `exnref` values.
Since they must carry a `Name tag` in addition to `Literals payload`,
they did not fit into existing `GCData`. Therefore, we add another
possible type in the big `union` for `ExnData`.

Alternatively, we could make a non-`funcref` `Name` value a valid
choice for a single `Literal`, but that would require inventing a
fake `Type` for such literals, such as `Type::tag`, which would
have no spec equivalent.

This highlighted the fact that using `Name`s will not work when
cross module boundaries (for `funcref` nor `exnref` nor the thrown
`WasmException`s). Since fixing this is beyond the scope of this
commit, we leave TODO's in place.

Other than the above, the changes are straightforward. They are
inspired from existing handling of `Try` and `Break`.

Author: sjrd

scripts/fuzz_opt.py

@@ -350,10 +350,20 @@ def is_git_repo():
     'typed_continuations_contnew.wast',
     'typed_continuations_contbind.wast',
     'typed_continuations_suspend.wast',
-    # New EH implementation is in progress
+    # TODO: make sure the fuzzer supports the new EH
+    'coalesce-locals-eh.wast',
+    'code-folding-eh.wast',
+    'code-pushing-eh.wast',
+    'dce-eh.wast',
+    'eh.wast',
+    'eh-gc.wast',
     'exception-handling.wast',
+    'global-effects.wast',
+    'local-subtyping.wast',
+    'renamings.wat',
     'translate-to-new-eh.wast',
     'rse-eh.wast',
+    'vacuum-eh.wast',
 ]
 
 

src/ir/ReFinalize.cpp

@@ -127,7 +127,12 @@ void ReFinalize::visitTableGrow(TableGrow* curr) { curr->finalize(); }
 void ReFinalize::visitTableFill(TableFill* curr) { curr->finalize(); }
 void ReFinalize::visitTableCopy(TableCopy* curr) { curr->finalize(); }
 void ReFinalize::visitTry(Try* curr) { curr->finalize(); }
-void ReFinalize::visitTryTable(TryTable* curr) { curr->finalize(); }
+void ReFinalize::visitTryTable(TryTable* curr) {
+  curr->finalize();
+  for (size_t i = 0; i < curr->catchDests.size(); i++) {
+    updateBreakValueType(curr->catchDests[i], curr->sentTypes[i]);
+  }
+}
 void ReFinalize::visitThrow(Throw* curr) { curr->finalize(); }
 void ReFinalize::visitRethrow(Rethrow* curr) { curr->finalize(); }
 void ReFinalize::visitThrowRef(ThrowRef* curr) { curr->finalize(); }

src/ir/effects.h

@@ -431,6 +431,14 @@ class EffectAnalyzer {
         self->pushTask(doStartTry, currp);
         return;
       }
+      if (auto* tryTable = curr->dynCast<TryTable>()) {
+        // We need to increment try depth before starting.
+        self->pushTask(doEndTryTable, currp);
+        self->pushTask(doVisitTryTable, currp);
+        self->pushTask(scan, &tryTable->body);
+        self->pushTask(doStartTryTable, currp);
+        return;
+      }
       PostWalker<InternalAnalyzer, OverriddenVisitor<InternalAnalyzer>>::scan(
         self, currp);
     }
@@ -472,6 +480,24 @@ class EffectAnalyzer {
       self->parent.catchDepth--;
     }
 
+    static void doStartTryTable(InternalAnalyzer* self, Expression** currp) {
+      TryTable* curr = (*currp)->cast<TryTable>();
+      // We only count 'try_table's with a 'catch_all' because instructions
+      // within a 'try_table' without a 'catch_all' can still throw outside of
+      // the try.
+      if (curr->hasCatchAll()) {
+        self->parent.tryDepth++;
+      }
+    }
+
+    static void doEndTryTable(InternalAnalyzer* self, Expression** currp) {
+      TryTable* curr = (*currp)->cast<TryTable>();
+      if (curr->hasCatchAll()) {
+        assert(self->parent.tryDepth > 0 && "try depth cannot be negative");
+        self->parent.tryDepth--;
+      }
+    }
+
     void visitBlock(Block* curr) {
       if (curr->name.is()) {
         parent.breakTargets.erase(curr->name); // these were internal breaks

src/ir/linear-execution.h

@@ -171,6 +171,11 @@ struct LinearExecutionWalker : public PostWalker<SubType, VisitorType> {
         self->pushTask(SubType::scan, &curr->cast<Try>()->body);
         break;
       }
+      case Expression::Id::TryTableId: {
+        self->pushTask(SubType::doVisitTryTable, currp);
+        self->pushTask(SubType::doNoteNonLinear, currp);
+        break;
+      }
       case Expression::Id::ThrowId: {
         self->pushTask(SubType::doVisitThrow, currp);
         self->pushTask(SubType::doNoteNonLinear, currp);

src/literal.h

@@ -32,6 +32,7 @@ namespace wasm {
 
 class Literals;
 struct GCData;
+struct ExnData;
 
 class Literal {
   // store only integers, whose bits are deterministic. floats
@@ -44,6 +45,7 @@ class Literal {
     int64_t i64;
     uint8_t v128[16];
     // funcref function name. `isNull()` indicates a `null` value.
+    // TODO: handle cross-module calls using something other than a Name here.
     Name func;
     // A reference to GC data, either a Struct or an Array. For both of those we
     // store the referred data as a Literals object (which is natural for an
@@ -56,6 +58,8 @@ class Literal {
     // reference as its sole value even though internal i31 references do not
     // have a gcData.
     std::shared_ptr<GCData> gcData;
+    // A reference to Exn data.
+    std::shared_ptr<ExnData> exnData;
   };
 
 public:
@@ -85,6 +89,7 @@ class Literal {
     assert(type.isSignature());
   }
   explicit Literal(std::shared_ptr<GCData> gcData, HeapType type);
+  explicit Literal(std::shared_ptr<ExnData> exnData);
   explicit Literal(std::string_view string);
   Literal(const Literal& other);
   Literal& operator=(const Literal& other);
@@ -96,6 +101,7 @@ class Literal {
   // Whether this is GC data, that is, something stored on the heap (aside from
   // a null or i31). This includes structs, arrays, and also strings.
   bool isData() const { return type.isData(); }
+  bool isExn() const { return type.isExn(); }
   bool isString() const { return type.isString(); }
 
   bool isNull() const { return type.isNull(); }
@@ -303,6 +309,7 @@ class Literal {
     return func;
   }
   std::shared_ptr<GCData> getGCData() const;
+  std::shared_ptr<ExnData> getExnData() const;
 
   // careful!
   int32_t* geti32Ptr() {
@@ -732,6 +739,18 @@ struct GCData {
   GCData(HeapType type, Literals values) : type(type), values(values) {}
 };
 
+// The data of a (ref exn) literal.
+struct ExnData {
+  // The tag of this exn data.
+  // TODO: handle cross-module calls using something other than a Name here.
+  Name tag;
+
+  // The payload of this exn data.
+  Literals payload;
+
+  ExnData(Name tag, Literals payload) : tag(tag), payload(payload) {}
+};
+
 } // namespace wasm
 
 namespace std {

src/passes/CodeFolding.cpp

@@ -347,11 +347,12 @@ struct CodeFolding : public WalkerPass<ControlFlowWalker<CodeFolding>> {
         // out of the try scope changes the program's behavior, because the
         // expression that would otherwise have been caught by the try now
         // throws up to the next try scope or even up to the caller. We restrict
-        // the move if 'outOf' contains a 'try' anywhere in it. This is a
-        // conservative approximation because there can be cases that 'try' is
-        // within the expression that may throw so it is safe to take the
-        // expression out.
-        if (effects.throws() && !FindAll<Try>(outOf).list.empty()) {
+        // the move if 'outOf' contains a 'try' or 'try_table' anywhere in it.
+        // This is a conservative approximation because there can be cases that
+        // 'try'/'try_table' is within the expression that may throw so it is
+        // safe to take the expression out.
+        if (effects.throws() &&
+            (FindAll<Try>(outOf).has() || FindAll<TryTable>(outOf).has())) {
           return false;
         }
       }

src/passes/DeadCodeElimination.cpp

@@ -185,6 +185,12 @@ struct DeadCodeElimination
           tryy->body->type == Type::unreachable && allCatchesUnreachable) {
         typeUpdater.changeType(tryy, Type::unreachable);
       }
+    } else if (auto* tryTable = curr->dynCast<TryTable>()) {
+      // try_table can finish normally only if its body finishes normally.
+      if (tryTable->type != Type::unreachable &&
+          tryTable->body->type == Type::unreachable) {
+        typeUpdater.changeType(tryTable, Type::unreachable);
+      }
     } else {
       WASM_UNREACHABLE("unimplemented DCE control flow structure");
     }

src/passes/Vacuum.cpp

@@ -87,7 +87,7 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> {
       // Some instructions have special handling in visit*, and we should do
       // nothing for them here.
       if (curr->is<Drop>() || curr->is<Block>() || curr->is<If>() ||
-          curr->is<Loop>() || curr->is<Try>()) {
+          curr->is<Loop>() || curr->is<Try>() || curr->is<TryTable>()) {
         return curr;
       }
       // Check if this expression itself has side effects, ignoring children.
@@ -435,6 +435,22 @@ struct Vacuum : public WalkerPass<ExpressionStackWalker<Vacuum>> {
     }
   }
 
+  void visitTryTable(TryTable* curr) {
+    // If try's body does not throw, the whole try_table can be replaced with
+    // the try's body.
+    if (!EffectAnalyzer(getPassOptions(), *getModule(), curr->body).throws()) {
+      replaceCurrent(curr->body);
+      return;
+    }
+
+    // TODO Should we attempt the same thing as in `visitTry` when the body
+    // only throws, and there is a catch_all? We cannot `nop` the `TryTable`,
+    // though. Instead, we should turn it into an unconditional `br` to the
+    // target of the `catch_all`. Also, for a `catch_all_ref`, we cannot do that
+    // optimization at all since we would not know how to create the correct
+    // `exnref`.
+  }
+
   void visitFunction(Function* curr) {
     auto* optimized =
       optimize(curr->body, curr->getResults() != Type::none, true);

src/wasm-interpreter.h

@@ -47,6 +47,7 @@
 namespace wasm {
 
 struct WasmException {
+  // TODO: handle cross-module calls using something other than a Name here.
   Name tag;
   Literals values;
 };
@@ -204,6 +205,15 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     return Literal(allocation, type.getHeapType());
   }
 
+  // Same as makeGCData but for ExnData.
+  Literal makeExnData(Name tag, const Literals& payload) {
+    auto allocation = std::make_shared<ExnData>(tag, payload);
+#if __has_feature(leak_sanitizer) || __has_feature(address_sanitizer)
+    __lsan_ignore_object(allocation.get());
+#endif
+    return Literal(allocation);
+  }
+
 public:
   // Indicates no limit of maxDepth or maxLoopIterations.
   static const Index NO_LIMIT = 0;
@@ -1418,7 +1428,26 @@ class ExpressionRunner : public OverriddenVisitor<SubType, Flow> {
     WASM_UNREACHABLE("throw");
   }
   Flow visitRethrow(Rethrow* curr) { WASM_UNREACHABLE("unimp"); }
-  Flow visitThrowRef(ThrowRef* curr) { WASM_UNREACHABLE("unimp"); }
+  Flow visitThrowRef(ThrowRef* curr) {
+    NOTE_ENTER("ThrowRef");
+    Flow flow = visit(curr->exnref);
+    if (flow.breaking()) {
+      return flow;
+    }
+    const auto& exnref = flow.getSingleValue();
+    NOTE_EVAL1(exnref);
+    if (exnref.isNull()) {
+      trap("null ref");
+    }
+    const auto& exnData = exnref.getExnData();
+    WasmException exn;
+    exn.tag = exnData->tag;
+    for (auto item : exnData->payload) {
+      exn.values.push_back(item);
+    }
+    throwException(exn);
+    WASM_UNREACHABLE("throw");
+  }
   Flow visitRefI31(RefI31* curr) {
     NOTE_ENTER("RefI31");
     Flow flow = visit(curr->value);
@@ -2432,6 +2461,10 @@ class ConstantExpressionRunner : public ExpressionRunner<SubType> {
     NOTE_ENTER("Try");
     return Flow(NONCONSTANT_FLOW);
   }
+  Flow visitTryTable(TryTable* curr) {
+    NOTE_ENTER("TryTable");
+    return Flow(NONCONSTANT_FLOW);
+  }
   Flow visitRethrow(Rethrow* curr) {
     NOTE_ENTER("Rethrow");
     return Flow(NONCONSTANT_FLOW);
@@ -4046,6 +4079,31 @@ class ModuleRunnerBase : public ExpressionRunner<SubType> {
       throw;
     }
   }
+  Flow visitTryTable(TryTable* curr) {
+    NOTE_ENTER("TryTable");
+    try {
+      return self()->visit(curr->body);
+    } catch (const WasmException& e) {
+      for (size_t i = 0; i < curr->catchTags.size(); i++) {
+        auto catchTag = curr->catchTags[i];
+        if (!catchTag.is() || catchTag == e.tag) {
+          Flow ret;
+          ret.breakTo = curr->catchDests[i];
+          if (catchTag.is()) {
+            for (auto item : e.values) {
+              ret.values.push_back(item);
+            }
+          }
+          if (curr->catchRefs[i]) {
+            ret.values.push_back(self()->makeExnData(e.tag, e.values));
+          }
+          return ret;
+        }
+      }
+      // This exception is not caught by this try-catch. Rethrow it.
+      throw;
+    }
+  }
   Flow visitRethrow(Rethrow* curr) {
     for (int i = exceptionStack.size() - 1; i >= 0; i--) {
       if (exceptionStack[i].second == curr->target) {

src/wasm-type.h

@@ -170,6 +170,7 @@ class Type {
   bool isSignature() const;
   bool isStruct() const;
   bool isArray() const;
+  bool isExn() const;
   bool isString() const;
   bool isDefaultable() const;
 
@@ -388,6 +389,7 @@ class HeapType {
   bool isContinuation() const { return getKind() == HeapTypeKind::Cont; }
   bool isStruct() const { return getKind() == HeapTypeKind::Struct; }
   bool isArray() const { return getKind() == HeapTypeKind::Array; }
+  bool isExn() const { return isMaybeShared(HeapType::exn); }
   bool isString() const { return isMaybeShared(HeapType::string); }
   bool isBottom() const;
   bool isOpen() const;