[Parser] Parse throw_ref

Author: tlively

src/parser/contexts.h

@@ -453,6 +453,7 @@ struct NullInstrParserCtx {
   Result<> makeTableCopy(Index, TableIdxT*, TableIdxT*) { return Ok{}; }
   Result<> makeThrow(Index, TagIdxT) { return Ok{}; }
   Result<> makeRethrow(Index, LabelIdxT) { return Ok{}; }
+  Result<> makeThrowRef(Index) { return Ok{}; }
   Result<> makeTupleMake(Index, uint32_t) { return Ok{}; }
   Result<> makeTupleExtract(Index, uint32_t, uint32_t) { return Ok{}; }
   Result<> makeTupleDrop(Index, uint32_t) { return Ok{}; }
@@ -1406,7 +1407,9 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
       irBuilder.makeTry(label ? *label : Name{}, type.getSignature().results));
   }
 
-  Result<> makeTryTable(Index pos, std::optional<Name> label, HeapType type,
+  Result<> makeTryTable(Index pos,
+                        std::optional<Name> label,
+                        HeapType type,
                         const std::vector<CatchInfo>& info) {
     std::vector<Name> tags;
     std::vector<Index> labels;
@@ -1416,10 +1419,12 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
       labels.push_back(info.label);
       isRefs.push_back(info.isRef);
     }
-    return withLoc(
-      pos,
-      irBuilder.makeTryTable(label ? *label : Name{}, type.getSignature().results,
-                             tags, labels, isRefs));
+    return withLoc(pos,
+                   irBuilder.makeTryTable(label ? *label : Name{},
+                                          type.getSignature().results,
+                                          tags,
+                                          labels,
+                                          isRefs));
   }
 
   Result<> visitCatch(Index pos, Name tag) {
@@ -1717,6 +1722,10 @@ struct ParseDefsCtx : TypeParserCtx<ParseDefsCtx> {
     return withLoc(pos, irBuilder.makeRethrow(label));
   }
 
+  Result<> makeThrowRef(Index pos) {
+    return withLoc(pos, irBuilder.makeThrowRef());
+  }
+
   Result<> makeTupleMake(Index pos, uint32_t arity) {
     return withLoc(pos, irBuilder.makeTupleMake(arity));
   }

src/parser/parsers.h

@@ -1646,7 +1646,7 @@ template<typename Ctx> Result<> makeRethrow(Ctx& ctx, Index pos) {
 }
 
 template<typename Ctx> Result<> makeThrowRef(Ctx& ctx, Index pos) {
-  return ctx.in.err("unimplemented instruction");
+  return ctx.makeThrowRef(pos);
 }
 
 template<typename Ctx> Result<> makeTupleMake(Ctx& ctx, Index pos) {

src/wasm-ir-builder.h

@@ -65,7 +65,8 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> visitElse();
   [[nodiscard]] Result<> visitLoopStart(Loop* iff);
   [[nodiscard]] Result<> visitTryStart(Try* tryy, Name label = {});
-  [[nodiscard]] Result<> visitTryTableStart(TryTable* trytable, Name label = {});
+  [[nodiscard]] Result<> visitTryTableStart(TryTable* trytable,
+                                            Name label = {});
   [[nodiscard]] Result<> visitCatch(Name tag);
   [[nodiscard]] Result<> visitCatchAll();
   [[nodiscard]] Result<> visitDelegate(Index label);
@@ -156,10 +157,14 @@ class IRBuilder : public UnifiedExpressionVisitor<IRBuilder, Result<>> {
   [[nodiscard]] Result<> makeTableFill(Name table);
   [[nodiscard]] Result<> makeTableCopy(Name destTable, Name srcTable);
   [[nodiscard]] Result<> makeTry(Name label, Type type);
-  [[nodiscard]] Result<> makeTryTable(Name label, Type type, const std::vector<Name>& tags, const std::vector<Index>& labels, const std::vector<bool>& isRefs);
+  [[nodiscard]] Result<> makeTryTable(Name label,
+                                      Type type,
+                                      const std::vector<Name>& tags,
+                                      const std::vector<Index>& labels,
+                                      const std::vector<bool>& isRefs);
   [[nodiscard]] Result<> makeThrow(Name tag);
   [[nodiscard]] Result<> makeRethrow(Index label);
-  // [[nodiscard]] Result<> makeThrowRef();
+  [[nodiscard]] Result<> makeThrowRef();
   [[nodiscard]] Result<> makeTupleMake(uint32_t arity);
   [[nodiscard]] Result<> makeTupleExtract(uint32_t arity, uint32_t index);
   [[nodiscard]] Result<> makeTupleDrop(uint32_t arity);

src/wasm.h

@@ -1522,6 +1522,7 @@ class Rethrow : public SpecificExpression<Expression::RethrowId> {
 // 'throw_ref' from the new EH proposal
 class ThrowRef : public SpecificExpression<Expression::ThrowRefId> {
 public:
+  ThrowRef() {}
   ThrowRef(MixedArena& allocator) {}
 
   Expression* exnref;

src/wasm/wasm-ir-builder.cpp

@@ -1356,8 +1356,11 @@ Result<> IRBuilder::makeTry(Name label, Type type) {
   return visitTryStart(tryy, label);
 }
 
-Result<> IRBuilder::makeTryTable(Name label, Type type, const std::vector<Name>& tags,
-                                 const std::vector<Index>& labels, const std::vector<bool>& isRefs) {
+Result<> IRBuilder::makeTryTable(Name label,
+                                 Type type,
+                                 const std::vector<Name>& tags,
+                                 const std::vector<Index>& labels,
+                                 const std::vector<bool>& isRefs) {
   auto* trytable = wasm.allocator.alloc<TryTable>();
   trytable->type = type;
   trytable->catchTags.set(tags);
@@ -1387,7 +1390,12 @@ Result<> IRBuilder::makeRethrow(Index label) {
   return Ok{};
 }
 
-// Result<> IRBuilder::makeThrowRef() {}
+Result<> IRBuilder::makeThrowRef() {
+  ThrowRef curr;
+  CHECK_ERR(visitThrowRef(&curr));
+  push(builder.makeThrowRef(curr.exnref));
+  return Ok{};
+}
 
 Result<> IRBuilder::makeTupleMake(uint32_t arity) {
   TupleMake curr(wasm.allocator);