Implement ref.as_non_null, br_non_null, br_on_non_null instructions

Author: zherczeg

include/wabt/binary-reader-logging.h

@@ -174,6 +174,8 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnBlockExpr(Type sig_type) override;
   Result OnBrExpr(Index depth) override;
   Result OnBrIfExpr(Index depth) override;
+  Result OnBrOnNonNullExpr(Index depth) override;
+  Result OnBrOnNullExpr(Index depth) override;
   Result OnBrTableExpr(Index num_targets,
                        Index* target_depths,
                        Index default_target_depth) override;
@@ -218,6 +220,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnTableGrowExpr(Index table) override;
   Result OnTableSizeExpr(Index table) override;
   Result OnTableFillExpr(Index table) override;
+  Result OnRefAsNonNullExpr() override;
   Result OnRefFuncExpr(Index index) override;
   Result OnRefNullExpr(Type type) override;
   Result OnRefIsNullExpr() override;

include/wabt/binary-reader-nop.h

@@ -241,6 +241,8 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnBlockExpr(Type sig_type) override { return Result::Ok; }
   Result OnBrExpr(Index depth) override { return Result::Ok; }
   Result OnBrIfExpr(Index depth) override { return Result::Ok; }
+  Result OnBrOnNonNullExpr(Index depth) override { return Result::Ok; }
+  Result OnBrOnNullExpr(Index depth) override { return Result::Ok; }
   Result OnBrTableExpr(Index num_targets,
                        Index* target_depths,
                        Index default_target_depth) override {
@@ -299,6 +301,7 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnTableGrowExpr(Index table_index) override { return Result::Ok; }
   Result OnTableSizeExpr(Index table_index) override { return Result::Ok; }
   Result OnTableFillExpr(Index table_index) override { return Result::Ok; }
+  Result OnRefAsNonNullExpr() override { return Result::Ok; }
   Result OnRefFuncExpr(Index func_index) override { return Result::Ok; }
   Result OnRefNullExpr(Type type) override { return Result::Ok; }
   Result OnRefIsNullExpr() override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -250,6 +250,8 @@ class BinaryReaderDelegate {
   virtual Result OnBlockExpr(Type sig_type) = 0;
   virtual Result OnBrExpr(Index depth) = 0;
   virtual Result OnBrIfExpr(Index depth) = 0;
+  virtual Result OnBrOnNonNullExpr(Index depth) = 0;
+  virtual Result OnBrOnNullExpr(Index depth) = 0;
   virtual Result OnBrTableExpr(Index num_targets,
                                Index* target_depths,
                                Index default_target_depth) = 0;
@@ -294,6 +296,7 @@ class BinaryReaderDelegate {
   virtual Result OnTableGrowExpr(Index table_index) = 0;
   virtual Result OnTableSizeExpr(Index table_index) = 0;
   virtual Result OnTableFillExpr(Index table_index) = 0;
+  virtual Result OnRefAsNonNullExpr() = 0;
   virtual Result OnRefFuncExpr(Index func_index) = 0;
   virtual Result OnRefNullExpr(Type type) = 0;
   virtual Result OnRefIsNullExpr() = 0;

include/wabt/expr-visitor.h

@@ -73,6 +73,8 @@ class ExprVisitor::Delegate {
   virtual Result EndBlockExpr(BlockExpr*) = 0;
   virtual Result OnBrExpr(BrExpr*) = 0;
   virtual Result OnBrIfExpr(BrIfExpr*) = 0;
+  virtual Result OnBrOnNonNullExpr(BrOnNonNullExpr*) = 0;
+  virtual Result OnBrOnNullExpr(BrOnNullExpr*) = 0;
   virtual Result OnBrTableExpr(BrTableExpr*) = 0;
   virtual Result BeginTryTableExpr(TryTableExpr*) = 0;
   virtual Result EndTryTableExpr(TryTableExpr*) = 0;
@@ -109,6 +111,7 @@ class ExprVisitor::Delegate {
   virtual Result OnTableGrowExpr(TableGrowExpr*) = 0;
   virtual Result OnTableSizeExpr(TableSizeExpr*) = 0;
   virtual Result OnTableFillExpr(TableFillExpr*) = 0;
+  virtual Result OnRefAsNonNullExpr(RefAsNonNullExpr*) = 0;
   virtual Result OnRefFuncExpr(RefFuncExpr*) = 0;
   virtual Result OnRefNullExpr(RefNullExpr*) = 0;
   virtual Result OnRefIsNullExpr(RefIsNullExpr*) = 0;
@@ -150,6 +153,8 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result EndBlockExpr(BlockExpr*) override { return Result::Ok; }
   Result OnBrExpr(BrExpr*) override { return Result::Ok; }
   Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
+  Result OnBrOnNonNullExpr(BrOnNonNullExpr*) override { return Result::Ok; };
+  Result OnBrOnNullExpr(BrOnNullExpr*) 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; }
@@ -186,6 +191,7 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnTableGrowExpr(TableGrowExpr*) override { return Result::Ok; }
   Result OnTableSizeExpr(TableSizeExpr*) override { return Result::Ok; }
   Result OnTableFillExpr(TableFillExpr*) override { return Result::Ok; }
+  Result OnRefAsNonNullExpr(RefAsNonNullExpr*) override { return Result::Ok; }
   Result OnRefFuncExpr(RefFuncExpr*) override { return Result::Ok; }
   Result OnRefNullExpr(RefNullExpr*) override { return Result::Ok; }
   Result OnRefIsNullExpr(RefIsNullExpr*) override { return Result::Ok; }

include/wabt/ir.h

@@ -398,6 +398,8 @@ enum class ExprType {
   Block,
   Br,
   BrIf,
+  BrOnNonNull,
+  BrOnNull,
   BrTable,
   Call,
   CallIndirect,
@@ -422,6 +424,7 @@ enum class ExprType {
   MemoryInit,
   MemorySize,
   Nop,
+  RefAsNonNull,
   RefIsNull,
   RefFunc,
   RefNull,
@@ -592,6 +595,7 @@ using CompareExpr = OpcodeExpr<ExprType::Compare>;
 using ConvertExpr = OpcodeExpr<ExprType::Convert>;
 using UnaryExpr = OpcodeExpr<ExprType::Unary>;
 using TernaryExpr = OpcodeExpr<ExprType::Ternary>;
+using RefAsNonNullExpr = OpcodeExpr<ExprType::RefAsNonNull>;
 
 class SimdLaneOpExpr : public ExprMixin<ExprType::SimdLaneOp> {
  public:
@@ -671,6 +675,8 @@ class MemoryVarExpr : public MemoryExpr<TypeEnum> {
 
 using BrExpr = VarExpr<ExprType::Br>;
 using BrIfExpr = VarExpr<ExprType::BrIf>;
+using BrOnNonNullExpr = VarExpr<ExprType::BrOnNonNull>;
+using BrOnNullExpr = VarExpr<ExprType::BrOnNull>;
 using CallExpr = VarExpr<ExprType::Call>;
 using RefFuncExpr = VarExpr<ExprType::RefFunc>;
 using GlobalGetExpr = VarExpr<ExprType::GlobalGet>;

include/wabt/opcode.def

@@ -267,6 +267,9 @@ WABT_OPCODE(___,  I32,  ___,  I32,  0,  0xfc, 0x11, TableFill, "table.fill", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd0, RefNull, "ref.null", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd1, RefIsNull, "ref.is_null", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd2, RefFunc, "ref.func", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd4, RefAsNonNull, "ref.as_non_null", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd5, BrOnNull, "br_on_null", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd6, BrOnNonNull, "br_on_non_null", "")
 
 /* Simd opcodes */
 WABT_OPCODE(V128, I32,  ___,  ___,  16, 0xfd, 0x00, V128Load, "v128.load", "")

include/wabt/shared-validator.h

@@ -136,6 +136,8 @@ class SharedValidator {
   Result OnBlock(const Location&, Type sig_type);
   Result OnBr(const Location&, Var depth);
   Result OnBrIf(const Location&, Var depth);
+  Result OnBrOnNonNull(const Location&, Var depth);
+  Result OnBrOnNull(const Location&, Var depth);
   Result BeginBrTable(const Location&);
   Result OnBrTableTarget(const Location&, Var depth);
   Result EndBrTable(const Location&);
@@ -176,6 +178,7 @@ class SharedValidator {
   Result OnMemoryInit(const Location&, Var segment_var, Var memidx);
   Result OnMemorySize(const Location&, Var memidx);
   Result OnNop(const Location&);
+  Result OnRefAsNonNull(const Location&);
   Result OnRefFunc(const Location&, Var func_var);
   Result OnRefIsNull(const Location&);
   Result OnRefNull(const Location&, Var func_type_var);

include/wabt/token.def

@@ -99,6 +99,8 @@ WABT_TOKEN(Binary, "BINARY")
 WABT_TOKEN(Block, "block")
 WABT_TOKEN(Br, "br")
 WABT_TOKEN(BrIf, "br_if")
+WABT_TOKEN(BrOnNonNull, "br_on_non_null")
+WABT_TOKEN(BrOnNull, "br_on_null")
 WABT_TOKEN(BrTable, "br_table")
 WABT_TOKEN(Code, "code")
 WABT_TOKEN(Call, "call")
@@ -130,6 +132,7 @@ WABT_TOKEN(MemoryGrow, "memory.grow")
 WABT_TOKEN(MemoryInit, "memory.init")
 WABT_TOKEN(MemorySize, "memory.size")
 WABT_TOKEN(Nop, "nop")
+WABT_TOKEN(RefAsNonNull, "ref.as_non_null")
 WABT_TOKEN(RefExtern, "ref.extern")
 WABT_TOKEN(RefFunc, "ref.func")
 WABT_TOKEN(RefIsNull, "ref.is_null")

include/wabt/type-checker.h

@@ -87,6 +87,8 @@ class TypeChecker {
   Result OnBlock(const TypeVector& param_types, const TypeVector& result_types);
   Result OnBr(Index depth);
   Result OnBrIf(Index depth);
+  Result OnBrOnNonNull(Index depth);
+  Result OnBrOnNull(Index depth);
   Result BeginBrTable();
   Result OnBrTableTarget(Index depth);
   Result EndBrTable();
@@ -129,6 +131,7 @@ class TypeChecker {
   Result OnTableGrow(Type elem_type, const Limits& limits);
   Result OnTableSize(const Limits& limits);
   Result OnTableFill(Type elem_type, const Limits& limits);
+  Result OnRefAsNonNullExpr();
   Result OnRefFuncExpr(Index func_type, bool force_generic_funcref);
   Result OnRefNullExpr(Type type);
   Result OnRefIsNullExpr();
@@ -192,6 +195,7 @@ class TypeChecker {
                            Type expected2,
                            Type expected3,
                            const char* desc);
+  Result PopAndCheckReference(Type* actual, const char* desc);
   Result CheckOpcode1(Opcode opcode, const Limits* limits = nullptr);
   Result CheckOpcode2(Opcode opcode, const Limits* limits = nullptr);
   Result CheckOpcode3(Opcode opcode,

src/apply-names.cc

@@ -40,6 +40,8 @@ class NameApplier : public ExprVisitor::DelegateNop {
   Result EndBlockExpr(BlockExpr*) override;
   Result OnBrExpr(BrExpr*) override;
   Result OnBrIfExpr(BrIfExpr*) override;
+  Result OnBrOnNonNullExpr(BrOnNonNullExpr*) override;
+  Result OnBrOnNullExpr(BrOnNullExpr*) override;
   Result OnBrTableExpr(BrTableExpr*) override;
   Result OnCallExpr(CallExpr*) override;
   Result OnRefFuncExpr(RefFuncExpr*) override;
@@ -350,6 +352,18 @@ Result NameApplier::OnBrIfExpr(BrIfExpr* expr) {
   return Result::Ok;
 }
 
+Result NameApplier::OnBrOnNonNullExpr(BrOnNonNullExpr* expr) {
+  std::string_view label = FindLabelByVar(&expr->var);
+  UseNameForVar(label, &expr->var);
+  return Result::Ok;
+}
+
+Result NameApplier::OnBrOnNullExpr(BrOnNullExpr* expr) {
+  std::string_view label = FindLabelByVar(&expr->var);
+  UseNameForVar(label, &expr->var);
+  return Result::Ok;
+}
+
 Result NameApplier::OnBrTableExpr(BrTableExpr* expr) {
   for (Var& target : expr->targets) {
     std::string_view label = FindLabelByVar(&target);