binary/wat: Implement EHv4 (#2470)

This pull request implements EHv4. Binary is mostly untested until
interp is working.

Author: SoniEx2

include/wabt/binary-reader-logging.h

@@ -232,7 +232,10 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
                      Address alignment_log2,
                      Address offset) override;
   Result OnThrowExpr(Index tag_index) override;
+  Result OnThrowRefExpr() override;
   Result OnTryExpr(Type sig_type) override;
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override;
   Result OnUnaryExpr(Opcode opcode) override;
   Result OnTernaryExpr(Opcode opcode) override;
   Result OnUnreachableExpr() override;

include/wabt/binary-reader-nop.h

@@ -319,7 +319,12 @@ class BinaryReaderNop : public BinaryReaderDelegate {
     return Result::Ok;
   }
   Result OnThrowExpr(Index depth) override { return Result::Ok; }
+  Result OnThrowRefExpr() override { return Result::Ok; }
   Result OnTryExpr(Type sig_type) override { return Result::Ok; }
+  Result OnTryTableExpr(Type sig_type,
+                        const CatchClauseVector& catches) override {
+    return Result::Ok;
+  }
   Result OnUnaryExpr(Opcode opcode) override { return Result::Ok; }
   Result OnTernaryExpr(Opcode opcode) override { return Result::Ok; }
   Result OnUnreachableExpr() override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -59,6 +59,13 @@ struct TypeMut {
 };
 using TypeMutVector = std::vector<TypeMut>;
 
+struct CatchClause {
+  CatchKind kind;
+  Index tag;
+  Index depth;
+};
+using CatchClauseVector = std::vector<CatchClause>;
+
 class BinaryReaderDelegate {
  public:
   struct State {
@@ -302,7 +309,10 @@ class BinaryReaderDelegate {
                              Address alignment_log2,
                              Address offset) = 0;
   virtual Result OnThrowExpr(Index tag_index) = 0;
+  virtual Result OnThrowRefExpr() = 0;
   virtual Result OnTryExpr(Type sig_type) = 0;
+  virtual Result OnTryTableExpr(Type sig_type,
+                                const CatchClauseVector& catches) = 0;
 
   virtual Result OnUnaryExpr(Opcode opcode) = 0;
   virtual Result OnTernaryExpr(Opcode opcode) = 0;

include/wabt/common.h

@@ -194,6 +194,7 @@ enum class LabelType {
   If,
   Else,
   Try,
+  TryTable,
   Catch,
 
   First = Func,
@@ -239,6 +240,13 @@ enum class SegmentKind {
   Declared,
 };
 
+enum class CatchKind {
+  Catch,
+  CatchRef,
+  CatchAll,
+  CatchAllRef,
+};
+
 // Used in test asserts for special expected values "nan:canonical" and
 // "nan:arithmetic"
 enum class ExpectedNan {

include/wabt/expr-visitor.h

@@ -41,6 +41,7 @@ class ExprVisitor {
     IfFalse,
     Loop,
     Try,
+    TryTable,
     Catch,
   };
 
@@ -73,6 +74,8 @@ class ExprVisitor::Delegate {
   virtual Result OnBrExpr(BrExpr*) = 0;
   virtual Result OnBrIfExpr(BrIfExpr*) = 0;
   virtual Result OnBrTableExpr(BrTableExpr*) = 0;
+  virtual Result BeginTryTableExpr(TryTableExpr*) = 0;
+  virtual Result EndTryTableExpr(TryTableExpr*) = 0;
   virtual Result OnCallExpr(CallExpr*) = 0;
   virtual Result OnCallIndirectExpr(CallIndirectExpr*) = 0;
   virtual Result OnCallRefExpr(CallRefExpr*) = 0;
@@ -122,6 +125,7 @@ class ExprVisitor::Delegate {
   virtual Result OnDelegateExpr(TryExpr*) = 0;
   virtual Result EndTryExpr(TryExpr*) = 0;
   virtual Result OnThrowExpr(ThrowExpr*) = 0;
+  virtual Result OnThrowRefExpr(ThrowRefExpr*) = 0;
   virtual Result OnRethrowExpr(RethrowExpr*) = 0;
   virtual Result OnAtomicWaitExpr(AtomicWaitExpr*) = 0;
   virtual Result OnAtomicFenceExpr(AtomicFenceExpr*) = 0;
@@ -147,6 +151,8 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnBrExpr(BrExpr*) override { return Result::Ok; }
   Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
   Result OnBrTableExpr(BrTableExpr*) override { return Result::Ok; }
+  Result BeginTryTableExpr(TryTableExpr*) override { return Result::Ok; }
+  Result EndTryTableExpr(TryTableExpr*) override { return Result::Ok; }
   Result OnCallExpr(CallExpr*) override { return Result::Ok; }
   Result OnCallIndirectExpr(CallIndirectExpr*) override { return Result::Ok; }
   Result OnCallRefExpr(CallRefExpr*) override { return Result::Ok; }
@@ -198,6 +204,7 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnDelegateExpr(TryExpr*) override { return Result::Ok; }
   Result EndTryExpr(TryExpr*) override { return Result::Ok; }
   Result OnThrowExpr(ThrowExpr*) override { return Result::Ok; }
+  Result OnThrowRefExpr(ThrowRefExpr*) override { return Result::Ok; }
   Result OnRethrowExpr(RethrowExpr*) override { return Result::Ok; }
   Result OnAtomicWaitExpr(AtomicWaitExpr*) override { return Result::Ok; }
   Result OnAtomicFenceExpr(AtomicFenceExpr*) override { return Result::Ok; }

include/wabt/ir.h

@@ -21,11 +21,11 @@
 #include <cstddef>
 #include <cstdint>
 #include <memory>
+#include <set>
 #include <string>
 #include <string_view>
 #include <type_traits>
 #include <vector>
-#include <set>
 
 #include "wabt/binding-hash.h"
 #include "wabt/common.h"
@@ -422,7 +422,9 @@ enum class ExprType {
   TableFill,
   Ternary,
   Throw,
+  ThrowRef,
   Try,
+  TryTable,
   Unary,
   Unreachable,
 
@@ -460,6 +462,21 @@ struct Catch {
 };
 using CatchVector = std::vector<Catch>;
 
+struct TableCatch {
+  explicit TableCatch(const Location& loc = Location()) : loc(loc) {}
+  Location loc;
+  Var tag;
+  Var target;
+  CatchKind kind;
+  bool IsCatchAll() const {
+    return kind == CatchKind::CatchAll || kind == CatchKind::CatchAllRef;
+  }
+  bool IsRef() const {
+    return kind == CatchKind::CatchRef || kind == CatchKind::CatchAllRef;
+  }
+};
+using TryTableVector = std::vector<TableCatch>;
+
 enum class TryKind { Plain, Catch, Delegate };
 
 class Expr : public intrusive_list_base<Expr> {
@@ -516,6 +533,7 @@ using DropExpr = ExprMixin<ExprType::Drop>;
 using NopExpr = ExprMixin<ExprType::Nop>;
 using ReturnExpr = ExprMixin<ExprType::Return>;
 using UnreachableExpr = ExprMixin<ExprType::Unreachable>;
+using ThrowRefExpr = ExprMixin<ExprType::ThrowRef>;
 
 using MemoryGrowExpr = MemoryExpr<ExprType::MemoryGrow>;
 using MemorySizeExpr = MemoryExpr<ExprType::MemorySize>;
@@ -743,6 +761,15 @@ class IfExpr : public ExprMixin<ExprType::If> {
   Location false_end_loc;
 };
 
+class TryTableExpr : public ExprMixin<ExprType::TryTable> {
+ public:
+  explicit TryTableExpr(const Location& loc = Location())
+      : ExprMixin<ExprType::TryTable>(loc) {}
+
+  Block block;
+  TryTableVector catches;
+};
+
 class TryExpr : public ExprMixin<ExprType::Try> {
  public:
   explicit TryExpr(const Location& loc = Location())

include/wabt/opcode.def

@@ -45,6 +45,7 @@ WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x06, Try, "try", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x07, Catch, "catch", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x08, Throw, "throw", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x09, Rethrow, "rethrow", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0a, ThrowRef, "throw_ref", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0b, End, "end", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x0c, Br, "br", "")
 WABT_OPCODE(___,  I32,  ___,  ___,  0,  0,    0x0d, BrIf, "br_if", "")
@@ -60,6 +61,7 @@ WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x19, CatchAll, "catch_all", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x1a, Drop, "drop", "")
 WABT_OPCODE(___,  ___,  ___,  I32,  0,  0,    0x1b, Select, "select", "")
 WABT_OPCODE(___,  ___,  ___,  I32,  0,  0,    0x1c, SelectT, "select", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x1f, TryTable, "try_table", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x20, LocalGet, "local.get", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x21, LocalSet, "local.set", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0x22, LocalTee, "local.tee", "")

include/wabt/shared-validator.h

@@ -211,7 +211,11 @@ class SharedValidator {
   Result OnTableSize(const Location&, Var table_var);
   Result OnTernary(const Location&, Opcode);
   Result OnThrow(const Location&, Var tag_var);
+  Result OnThrowRef(const Location&);
   Result OnTry(const Location&, Type sig_type);
+  Result BeginTryTable(const Location&, Type sig_type);
+  Result OnTryTableCatch(const Location&, const TableCatch&);
+  Result EndTryTable(const Location&, Type sig_type);
   Result OnUnary(const Location&, Opcode);
   Result OnUnreachable(const Location&);
 

include/wabt/token.def

@@ -105,6 +105,8 @@ WABT_TOKEN(CallIndirect, "call_indirect")
 WABT_TOKEN(CallRef, "call_ref")
 WABT_TOKEN(Catch, "catch")
 WABT_TOKEN(CatchAll, "catch_all")
+WABT_TOKEN(CatchRef, "catch_ref")
+WABT_TOKEN(CatchAllRef, "catch_all_ref")
 WABT_TOKEN(Compare, "COMPARE")
 WABT_TOKEN(Const, "CONST")
 WABT_TOKEN(Convert, "CONVERT")
@@ -151,7 +153,9 @@ WABT_TOKEN(TableSet, "table.set")
 WABT_TOKEN(TableSize, "table.size")
 WABT_TOKEN(Ternary, "TERNARY")
 WABT_TOKEN(Throw, "throw")
+WABT_TOKEN(ThrowRef, "throw_ref")
 WABT_TOKEN(Try, "try")
+WABT_TOKEN(TryTable, "try_table")
 WABT_TOKEN(Unary, "UNARY")
 WABT_TOKEN(Unreachable, "unreachable")
 WABT_TOKEN_FIRST(Opcode, AtomicFence)

include/wabt/type-checker.h

@@ -128,7 +128,12 @@ class TypeChecker {
   Result OnStore(Opcode, const Limits& limits);
   Result OnTernary(Opcode);
   Result OnThrow(const TypeVector& sig);
+  Result OnThrowRef();
   Result OnTry(const TypeVector& param_types, const TypeVector& result_types);
+  Result OnTryTableCatch(const TypeVector& sig, Index);
+  Result BeginTryTable(const TypeVector& param_types);
+  Result EndTryTable(const TypeVector& param_types,
+                     const TypeVector& result_types);
   Result OnUnary(Opcode);
   Result OnUnreachable();
   Result EndFunction();