Support all gc tests

Author: zherczeg

include/wabt/interp/interp.h

@@ -1237,6 +1237,7 @@ class Thread {
   void Push(Ref);
 
   bool CheckRefCast(Ref ref, Type expected);
+  bool CheckRefFunc(Ref ref, Index expected_index, Func* new_func);
 
   template <typename R, typename T>
   using UnopFunc = R WABT_VECTORCALL(T);

include/wabt/shared-validator.h

@@ -99,7 +99,8 @@ class SharedValidator {
   Result OnTable(const Location&, Type elem_type, const Limits&, TableImportStatus import_status, TableInitExprStatus init_provided);
   Result OnMemory(const Location&, const Limits&, uint32_t page_size);
   Result OnGlobalImport(const Location&, Type type, bool mutable_);
-  Result OnGlobal(const Location&, Type type, bool mutable_);
+  Result BeginGlobal(const Location&, Type type, bool mutable_);
+  Result EndGlobal(const Location&);
   Result OnTag(const Location&, Var sig_var);
 
   Result OnExport(const Location&,
@@ -394,7 +395,7 @@ class SharedValidator {
   std::vector<TagType> tags_;         // Includes imported and defined.
   std::vector<ElemType> elems_;
   Index starts_ = 0;
-  Index num_imported_globals_ = 0;
+  Index last_initialized_global_ = 0;
   Index data_segments_ = 0;
   Index last_rec_type_end_ = 0;
   // Recursive type checks may enter to infinite loop for invalid values.

src/binary-writer-spec.cc

@@ -161,6 +161,10 @@ void BinaryWriterSpec::WriteVar(const Var& var) {
 void BinaryWriterSpec::WriteTypeObject(Type type) {
   json_stream_->Writef("{");
   WriteKey("type");
+  if (type.IsReferenceWithIndex()) {
+    // This should happen only for invalid modules.
+    type = Type::AnyRef;
+  }
   WriteString(type.GetName().c_str());
   json_stream_->Writef("}");
 }
@@ -284,6 +288,7 @@ void BinaryWriterSpec::WriteConst(const Const& const_) {
       break;
     }
 
+    case Type::NullFuncRef:
     case Type::FuncRef: {
       WriteString("funcref");
       WriteSeparator();

src/interp/binary-reader-interp.cc

@@ -812,7 +812,7 @@ Result BinaryReaderInterp::OnGlobalCount(Index count) {
 }
 
 Result BinaryReaderInterp::BeginGlobal(Index index, Type type, bool mutable_) {
-  CHECK_RESULT(validator_.OnGlobal(GetLocation(), type, mutable_));
+  CHECK_RESULT(validator_.BeginGlobal(GetLocation(), type, mutable_));
   GlobalType global_type{type, ToMutability(mutable_)};
   FuncDesc init_func{FuncType{{}, {type}}, {}, Istream::kInvalidOffset, {}};
   module_.globals.push_back(GlobalDesc{global_type, init_func});
@@ -845,6 +845,7 @@ Result BinaryReaderInterp::BeginInitExpr(FuncDesc* func) {
 }
 
 Result BinaryReaderInterp::EndGlobalInitExpr(Index index) {
+  CHECK_RESULT(validator_.EndGlobal(GetLocation()));
   return EndInitExpr();
 }
 
@@ -1466,7 +1467,8 @@ Result BinaryReaderInterp::OnCallIndirectExpr(Index sig_index,
   CHECK_RESULT(validator_.OnCallIndirect(GetLocation(),
                                          Var(sig_index, GetLocation()),
                                          Var(table_index, GetLocation())));
-  istream_.Emit(Opcode::CallIndirect, table_index, sig_index);
+  istream_.Emit(Opcode::CallIndirect, table_index,
+                module_.func_types[sig_index].canonical_index);
   return Result::Ok;
 }
 
@@ -1531,7 +1533,8 @@ Result BinaryReaderInterp::OnReturnCallIndirectExpr(Index sig_index,
       Var(table_index, GetLocation())));
   istream_.EmitDropKeep(drop_count, keep_count);
   istream_.EmitCatchDrop(catch_drop_count);
-  istream_.Emit(Opcode::ReturnCallIndirect, table_index, sig_index);
+  istream_.Emit(Opcode::ReturnCallIndirect, table_index,
+                module_.func_types[sig_index].canonical_index);
   return Result::Ok;
 }
 

src/interp/interp.cc

@@ -1606,6 +1606,31 @@ bool Thread::CheckRefCast(Ref ref, Type expected) {
   return false;
 }
 
+bool Thread::CheckRefFunc(Ref ref, Index expected_type_index, Func* new_func) {
+  // Validator checks that the table contains funcrefs.
+  assert(!ref.IsI31OrHostVal());
+  Object* object = store_.UnsafeGet<Object>(ref).get();
+  assert(Func::classof(object));
+
+  const FuncType& type = cast<Func>(object)->type();
+  if (type.func_types != &mod_->desc().func_types) {
+    auto&& func_type = mod_->desc().func_types[expected_type_index];
+    return Succeeded(Match(new_func->type(), func_type, nullptr));
+  }
+  Index actual_type_index = type.canonical_index;
+
+  do {
+    if (expected_type_index == actual_type_index) {
+      return true;
+    }
+
+    actual_type_index =
+        mod_->desc().func_types[actual_type_index].canonical_sub_index;
+  } while (actual_type_index != kInvalidIndex);
+
+  return false;
+}
+
 RunResult Thread::StepInternal(Trap::Ptr* out_trap) {
   using O = Opcode;
 
@@ -1676,15 +1701,14 @@ RunResult Thread::StepInternal(Trap::Ptr* out_trap) {
     case O::CallIndirect:
     case O::ReturnCallIndirect: {
       Table::Ptr table{store_, inst_->tables()[instr.imm_u32x2.fst]};
-      auto&& func_type = mod_->desc().func_types[instr.imm_u32x2.snd];
       u64 entry = PopPtr(table);
       TRAP_IF(entry >= table->elements().size(), "undefined table index");
       auto new_func_ref = table->elements()[entry];
       TRAP_IF(new_func_ref == Ref::Null, "uninitialized table element");
       Func::Ptr new_func{store_, new_func_ref};
-      TRAP_IF(
-          Failed(Match(new_func->type(), func_type, nullptr)),
-          "indirect call signature mismatch");  // TODO: don't use "signature"
+      // TODO: don't use "signature"
+      TRAP_IF(!CheckRefFunc(new_func_ref, instr.imm_u32x2.snd, new_func.get()),
+              "indirect call signature mismatch");
       if (instr.op == O::ReturnCallIndirect) {
         return DoReturnCall(new_func, out_trap);
       } else {

src/shared-validator.cc

@@ -88,8 +88,8 @@ Result SharedValidator::OnFuncType(const Location& loc,
     }
 
     type_validation_result_ |= result;
-    result |= CheckSupertypes(loc, supertypes);
   }
+  result |= CheckSupertypes(loc, supertypes);
 
   return result;
 }
@@ -237,19 +237,26 @@ Result SharedValidator::OnGlobalImport(const Location& loc,
     result |= PrintError(loc, "mutable globals cannot be imported");
   }
   globals_.push_back(GlobalType{type, mutable_});
-  ++num_imported_globals_;
+  ++last_initialized_global_;
   return result;
 }
 
-Result SharedValidator::OnGlobal(const Location& loc,
-                                 Type type,
-                                 bool mutable_) {
+Result SharedValidator::BeginGlobal(const Location& loc,
+                                    Type type,
+                                    bool mutable_) {
   CHECK_RESULT(
       CheckReferenceType(loc, type, type_fields_.NumTypes(), "globals"));
   globals_.push_back(GlobalType{type, mutable_});
   return Result::Ok;
 }
 
+Result SharedValidator::EndGlobal(const Location&) {
+  if (options_.features.gc_enabled()) {
+    last_initialized_global_++;
+  }
+  return Result::Ok;
+}
+
 Result SharedValidator::CheckType(const Location& loc,
                                   Type actual,
                                   Type expected,
@@ -278,8 +285,6 @@ Result SharedValidator::CheckReferenceType(const Location& loc,
 
 Result SharedValidator::CheckSupertypes(const Location& loc,
                                         SupertypesInfo* supertypes) {
-  assert(options_.features.function_references_enabled());
-
   TypeEntry& entry = type_fields_.type_entries.back();
   Index current_index = type_fields_.NumTypes() - 1;
   Index end_index;
@@ -787,8 +792,7 @@ Index SharedValidator::GetCanonicalTypeIndex(Index type_index) {
     return kInvalidIndex;
   }
 
-  if (options_.features.function_references_enabled() &&
-      Succeeded(type_validation_result_)) {
+  if (Succeeded(type_validation_result_)) {
     return type_fields_.type_entries[type_index].canonical_index;
   }
 
@@ -1321,7 +1325,7 @@ Result SharedValidator::OnGlobalGet(const Location& loc, Var global_var) {
   result |= CheckGlobalIndex(global_var, &global_type);
   result |= typechecker_.OnGlobalGet(global_type.type);
   if (Succeeded(result) && in_init_expr_) {
-    if (global_var.index() >= num_imported_globals_) {
+    if (global_var.index() >= last_initialized_global_) {
       result |= PrintError(
           global_var.loc,
           "initializer expression can only reference an imported global");

src/tools/spectest-interp.cc

@@ -2001,6 +2001,8 @@ wabt::Result CommandRunner::CheckAssertReturnResult(
           ok = obj->kind() == ObjectKind::Array ||
                obj->kind() == ObjectKind::Struct;
         }
+      } else {
+        ok = expected.value.type == Type::AnyRef;
       }
       break;
     }

src/validator.cc

@@ -1080,14 +1080,15 @@ Result Validator::CheckModule() {
   for (const ModuleField& field : module->fields) {
     if (auto* f = dyn_cast<GlobalModuleField>(&field)) {
       result_ |=
-          validator_.OnGlobal(field.loc, f->global.type, f->global.mutable_);
+          validator_.BeginGlobal(field.loc, f->global.type, f->global.mutable_);
 
       // Init expr.
       result_ |= validator_.BeginInitExpr(field.loc, f->global.type);
       ExprVisitor visitor(this);
       result_ |=
           visitor.VisitExprList(const_cast<ExprList&>(f->global.init_expr));
       result_ |= validator_.EndInitExpr();
+      result_ |= validator_.EndGlobal(field.loc);
     }
   }
 

test/spec/gc/array_new_data.txt

@@ -0,0 +1,10 @@
+;;; TOOL: run-interp-spec
+;;; STDIN_FILE: third_party/testsuite/proposals/gc/array_new_data.wast
+;;; ARGS*: --enable-gc
+(;; STDOUT ;;;
+out/test/spec/gc/array_new_data.wast:18: assert_trap passed: invalid range
+out/test/spec/gc/array_new_data.wast:19: assert_trap passed: invalid range
+out/test/spec/gc/array_new_data.wast:20: assert_trap passed: invalid range
+out/test/spec/gc/array_new_data.wast:21: assert_trap passed: invalid range
+15/15 tests passed.
+;;; STDOUT ;;)

test/spec/gc/array_new_elem.txt

@@ -0,0 +1,14 @@
+;;; TOOL: run-interp-spec
+;;; STDIN_FILE: third_party/testsuite/proposals/gc/array_new_elem.wast
+;;; ARGS*: --enable-gc
+(;; STDOUT ;;;
+out/test/spec/gc/array_new_elem.wast:24: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:25: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:26: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:27: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:72: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:73: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:74: assert_trap passed: invalid range
+out/test/spec/gc/array_new_elem.wast:75: assert_trap passed: invalid range
+22/22 tests passed.
+;;; STDOUT ;;)