[EH] Add instructions for new proposal (#6181)

This adds basic support for the new instructions in the new EH proposal passed at the Oct CG hybrid CG meeting: https://github.com/WebAssembly/meetings/blob/main/main/2023/CG-10.md https://github.com/WebAssembly/exception-handling/blob/main/proposals/exception-handling/Exceptions.md This mainly adds two instructions: `try_table` and `throw_ref`. This is the bare minimum required to read and write text and binary format, and does not include analyses or optimizations. (It includes some analysis required for validation of existing instructions.) Validation for the new instructions is not yet included. `try_table` faces the same problem with the `resume` instruction in #6083 that without the module-level tag info, we are unable to know the 'sent types' of `try_table`. This solves it with a similar approach taken in #6083: this adds `Module*` parameter to `finalize` methods, which defaults to `nullptr` when not given. The `Module*` parameter is given when called from the binary and text parser, and we cache those tag types in `sentTypes` array within `TryTable` class. In later optimization passes, as long as they don't touch tags, it is fine to call `finalize` without the `Module*`. Refer to #6083 (comment) and #6096 for related discussions when `resume` was added.

Author: aheejin

scripts/gen-s-parser.py

@@ -554,8 +554,10 @@
  #
  # exception handling instructions
  ("try", "makeTry(s)"),
+ ("try_table", "makeTryTable(s)"),
  ("throw", "makeThrow(s)"),
  ("rethrow", "makeRethrow(s)"),
+ ("throw_ref", "makeThrowRef(s)"),
  # Multivalue pseudoinstructions
  ("tuple.make", "makeTupleMake(s)"),
  ("tuple.extract", "makeTupleExtract(s)"),
@@ -714,7 +716,7 @@ def instruction_parser(new_parser=False):
  inst_length = 0
  for inst, expr in instructions:
  if new_parser and inst in {"block", "loop", "if", "try", "then",
- "else"}:
+ "else", "try_table"}:
  # These are either control flow handled manually or not real
  # instructions. Skip them.
  continue

src/gen-s-parser.inc

@@ -3393,15 +3393,31 @@ switch (buf[0]) {
  case 'e':
  if (op == "then"sv) { return makeThenOrElse(s); }
  goto parse_error;
- case 'r':
- if (op == "throw"sv) { return makeThrow(s); }
+ case 'r': {
+ switch (buf[5]) {
+ case '\0':
+ if (op == "throw"sv) { return makeThrow(s); }
+ goto parse_error;
+ case '_':
+ if (op == "throw_ref"sv) { return makeThrowRef(s); }
+ goto parse_error;
+ default: goto parse_error;
+ }
+ }
+ default: goto parse_error;
+ }
+ }
+ case 'r': {
+ switch (buf[3]) {
+ case '\0':
+ if (op == "try"sv) { return makeTry(s); }
+ goto parse_error;
+ case '_':
+ if (op == "try_table"sv) { return makeTryTable(s); }
  goto parse_error;
  default: goto parse_error;
  }
  }
- case 'r':
- if (op == "try"sv) { return makeTry(s); }
- goto parse_error;
  case 'u': {
  switch (buf[6]) {
  case 'd':
@@ -8646,12 +8662,23 @@ switch (buf[0]) {
  default: goto parse_error;
  }
  }
- case 'h':
- if (op == "throw"sv) {
- CHECK_ERR(makeThrow(ctx, pos));
- return Ok{};
+ case 'h': {
+ switch (buf[5]) {
+ case '\0':
+ if (op == "throw"sv) {
+ CHECK_ERR(makeThrow(ctx, pos));
+ return Ok{};
+ }
+ goto parse_error;
+ case '_':
+ if (op == "throw_ref"sv) {
+ CHECK_ERR(makeThrowRef(ctx, pos));
+ return Ok{};
+ }
+ goto parse_error;
+ default: goto parse_error;
  }
-  goto parse_error;
+ }
  case 'u': {
  switch (buf[6]) {
  case 'd':

src/ir/ExpressionAnalyzer.cpp

@@ -205,7 +205,9 @@ bool ExpressionAnalyzer::flexibleEqual(Expression* left,
  }
 
 #define DELEGATE_FIELD_INT_ARRAY(id, field) COMPARE_LIST(field)
+#define DELEGATE_FIELD_INT_VECTOR(id, field) COMPARE_LIST(field)
 #define DELEGATE_FIELD_NAME_VECTOR(id, field) COMPARE_LIST(field)
+#define DELEGATE_FIELD_TYPE_VECTOR(id, field) COMPARE_LIST(field)
 
 #define DELEGATE_FIELD_SCOPE_NAME_DEF(id, field) \
  if (castLeft->field.is() != castRight->field.is()) { \

src/ir/ExpressionManipulator.cpp

@@ -94,8 +94,10 @@ flexibleCopy(Expression* original, Module& wasm, CustomCopier custom) {
 
 #define DELEGATE_FIELD_SCOPE_NAME_USE_VECTOR(id, field) COPY_VECTOR(field)
 #define DELEGATE_FIELD_NAME_VECTOR(id, field) COPY_VECTOR(field)
+#define DELEGATE_FIELD_TYPE_VECTOR(id, field) COPY_VECTOR(field)
 
 #define DELEGATE_FIELD_INT_ARRAY(id, field) COPY_ARRAY(field)
+#define DELEGATE_FIELD_INT_VECTOR(id, field) COPY_VECTOR(field)
 
 #include "wasm-delegations-fields.def"
 

src/ir/LocalStructuralDominance.cpp

@@ -207,6 +207,14 @@ LocalStructuralDominance::LocalStructuralDominance(Function* func,
  currp = &curr->cast<Try>()->body;
  continue;
  }
+ case Expression::Id::TryTableId: {
+ self->pushTask(Scanner::doEndScope, currp);
+ // Just call the task immediately.
+ doBeginScope(self, currp);
+ // Immediately continue in the try_table.
+ currp = &curr->cast<TryTable>()->body;
+ continue;
+ }
 
  default: {
  // Control flow structures have been handled. This is an expression,

src/ir/ReFinalize.cpp

@@ -127,8 +127,10 @@ 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::visitThrow(Throw* curr) { curr->finalize(); }
 void ReFinalize::visitRethrow(Rethrow* curr) { curr->finalize(); }
+void ReFinalize::visitThrowRef(ThrowRef* curr) { curr->finalize(); }
 void ReFinalize::visitNop(Nop* curr) { curr->finalize(); }
 void ReFinalize::visitUnreachable(Unreachable* curr) { curr->finalize(); }
 void ReFinalize::visitPop(Pop* curr) { curr->finalize(); }

src/ir/branch-utils.h

@@ -75,14 +75,22 @@ void operateOnScopeNameUsesAndSentTypes(Expression* expr, T func) {
  func(name, sw->value ? sw->value->type : Type::none);
  } else if (auto* br = expr->dynCast<BrOn>()) {
  func(name, br->getSentType());
+ } else if (auto* tt = expr->dynCast<TryTable>()) {
+ for (Index i = 0; i < tt->catchTags.size(); i++) {
+ auto dest = tt->catchDests[i];
+ if (dest == name) {
+ func(name, tt->sentTypes[i]);
+ }
+ }
  } else {
  assert(expr->is<Try>() || expr->is<Rethrow>()); // delegate or rethrow
  }
  });
 }
 
 // Similar to operateOnScopeNameUses, but also passes in the expression that is
-// sent if the branch is taken. nullptr is given if there is no value.
+// sent if the branch is taken. nullptr is given if there is no value or there
+// is a value but it is not known statically.
 template<typename T>
 void operateOnScopeNameUsesAndSentValues(Expression* expr, T func) {
  operateOnScopeNameUses(expr, [&](Name& name) {
@@ -94,6 +102,10 @@ void operateOnScopeNameUsesAndSentValues(Expression* expr, T func) {
  func(name, sw->value);
  } else if (auto* br = expr->dynCast<BrOn>()) {
  func(name, br->ref);
+ } else if (auto* tt = expr->dynCast<TryTable>()) {
+ // The values are supplied by throwing instructions, so we are unable to
+ // know what they will be here.
+ func(name, nullptr);
  } else {
  assert(expr->is<Try>() || expr->is<Rethrow>()); // delegate or rethrow
  }

src/ir/cost.h

@@ -584,6 +584,10 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
  // We assume no exception will be thrown in most cases
  return visit(curr->body);
  }
+ CostType visitTryTable(TryTable* curr) {
+ // We assume no exception will be thrown in most cases
+ return visit(curr->body);
+ }
  CostType visitThrow(Throw* curr) {
  CostType ret = Unacceptable;
  for (auto* child : curr->operands) {
@@ -592,6 +596,7 @@ struct CostAnalyzer : public OverriddenVisitor<CostAnalyzer, CostType> {
  return ret;
  }
  CostType visitRethrow(Rethrow* curr) { return Unacceptable; }
+ CostType visitThrowRef(ThrowRef* curr) { return Unacceptable; }
  CostType visitTupleMake(TupleMake* curr) {
  CostType ret = 0;
  for (auto* child : curr->operands) {

src/ir/effects.h

@@ -706,6 +706,11 @@ class EffectAnalyzer {
  parent.delegateTargets.insert(curr->delegateTarget);
  }
  }
+ void visitTryTable(TryTable* curr) {
+ for (auto name : curr->catchDests) {
+ parent.breakTargets.insert(name);
+ }
+ }
  void visitThrow(Throw* curr) {
  if (parent.tryDepth == 0) {
  parent.throws_ = true;
@@ -715,6 +720,11 @@ class EffectAnalyzer {
  if (parent.tryDepth == 0) {
  parent.throws_ = true;
  }
+ }
+ void visitThrowRef(ThrowRef* curr) {
+ if (parent.tryDepth == 0) {
+ parent.throws_ = true;
+ }
  // traps when the arg is null
  parent.implicitTrap = true;
  }

src/ir/possible-contents.cpp

@@ -1152,6 +1152,10 @@ struct InfoCollector
 #endif
  }
  }
+ void visitTryTable(TryTable* curr) {
+ // TODO: optimize when possible
+ addRoot(curr);
+ }
  void visitThrow(Throw* curr) {
  auto& operands = curr->operands;
  if (!isRelevant(operands)) {
@@ -1165,6 +1169,7 @@ struct InfoCollector
  }
  }
  void visitRethrow(Rethrow* curr) {}
+ void visitThrowRef(ThrowRef* curr) {}
 
  void visitTupleMake(TupleMake* curr) {
  if (isRelevant(curr->type)) {