Implement GC basics

Author: Zoltan Herczeg

include/wabt/binary-reader-logging.h

@@ -44,13 +44,20 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
 
   Result BeginTypeSection(Offset size) override;
   Result OnTypeCount(Index count) override;
+  Result OnRecursiveRange(Index start_index, Index type_count) override;
   Result OnFuncType(Index index,
+                    GCTypeExtension* gc_ext,
                     Index param_count,
                     Type* param_types,
                     Index result_count,
                     Type* result_types) override;
-  Result OnStructType(Index index, Index field_count, TypeMut* fields) override;
-  Result OnArrayType(Index index, TypeMut field) override;
+  Result OnStructType(Index index,
+                      GCTypeExtension* gc_ext,
+                      Index field_count,
+                      TypeMut* fields) override;
+  Result OnArrayType(Index index,
+                     GCTypeExtension* gc_ext,
+                     TypeMut field) override;
   Result EndTypeSection() override;
 
   Result BeginImportSection(Offset size) override;
@@ -432,6 +439,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   void LogType(Type type);
   void LogTypes(Index type_count, Type* types);
   void LogTypes(TypeVector& types);
+  void LogGCInfo(GCTypeExtension* gc_ext);
   void LogField(TypeMut field);
 
   Stream* stream_;

include/wabt/binary-reader-nop.h

@@ -45,20 +45,29 @@ class BinaryReaderNop : public BinaryReaderDelegate {
 
   /* Type section */
   Result BeginTypeSection(Offset size) override { return Result::Ok; }
+  Result OnRecursiveRange(Index start_index, Index type_count) override {
+    return Result::Ok;
+  }
   Result OnTypeCount(Index count) override { return Result::Ok; }
   Result OnFuncType(Index index,
+                    GCTypeExtension* gc_ext,
                     Index param_count,
                     Type* param_types,
                     Index result_count,
                     Type* result_types) override {
     return Result::Ok;
   }
   Result OnStructType(Index index,
+                      GCTypeExtension* gc_ext,
                       Index field_count,
                       TypeMut* fields) override {
     return Result::Ok;
   }
-  Result OnArrayType(Index index, TypeMut field) override { return Result::Ok; }
+  Result OnArrayType(Index index,
+                     GCTypeExtension* gc_ext,
+                     TypeMut field) override {
+    return Result::Ok;
+  }
   Result EndTypeSection() override { return Result::Ok; }
 
   /* Import section */

include/wabt/binary-reader.h

@@ -52,13 +52,20 @@ struct ReadBinaryOptions {
   bool skip_function_bodies = false;
 };
 
-// TODO: Move somewhere else?
+// TODO: Move both TypeMut and GCTypeInformation somewhere else?
 struct TypeMut {
   Type type;
   bool mutable_;
 };
 using TypeMutVector = std::vector<TypeMut>;
 
+// Garbage Collector specific type information
+struct GCTypeExtension {
+  bool is_final_sub_type;
+  Index sub_type_count;
+  Index* sub_types;
+};
+
 struct CatchClause {
   CatchKind kind;
   Index tag;
@@ -99,15 +106,20 @@ class BinaryReaderDelegate {
   /* Type section */
   virtual Result BeginTypeSection(Offset size) = 0;
   virtual Result OnTypeCount(Index count) = 0;
+  virtual Result OnRecursiveRange(Index start_index, Index type_count) = 0;
   virtual Result OnFuncType(Index index,
+                            GCTypeExtension* gc_ext,
                             Index param_count,
                             Type* param_types,
                             Index result_count,
                             Type* result_types) = 0;
   virtual Result OnStructType(Index index,
+                              GCTypeExtension* gc_ext,
                               Index field_count,
                               TypeMut* fields) = 0;
-  virtual Result OnArrayType(Index index, TypeMut field) = 0;
+  virtual Result OnArrayType(Index index,
+                             GCTypeExtension* gc_ext,
+                             TypeMut field) = 0;
   virtual Result EndTypeSection() = 0;
 
   /* Import section */

include/wabt/interp/interp-inl.h

@@ -42,7 +42,12 @@ inline bool FuncType::classof(const ExternType* type) {
 }
 
 inline FuncType::FuncType(ValueTypes params, ValueTypes results)
-    : ExternType(ExternKind::Func), params(params), results(results), func_types(nullptr) {}
+    : ExternType(ExternKind::Func), kind(FuncType::TypeKind::Func), params(params), results(results), func_types(nullptr) {}
+
+inline FuncType::FuncType(TypeKind kind, ValueTypes params, ValueTypes results)
+    : ExternType(ExternKind::Func), kind(kind), params(params), results(results), func_types(nullptr) {
+  assert((kind == TypeKind::Struct || kind == TypeKind::Array) && params.size() == results.size());
+}
 
 //// TableType ////
 // static

include/wabt/interp/interp.h

@@ -178,14 +178,29 @@ struct FuncType : ExternType {
   static const ExternKind skind = ExternKind::Func;
   static bool classof(const ExternType* type);
 
+  enum class TypeKind {
+    Func,
+    Struct,
+    Array,
+  };
+
+  static const Type::Enum Mutable = Type::I32;
+  static const Type::Enum Immutable = Type::I64;
+
   explicit FuncType(ValueTypes params, ValueTypes results);
+  explicit FuncType(TypeKind kind, ValueTypes params, ValueTypes results);
 
   std::unique_ptr<ExternType> Clone() const override;
 
   friend Result Match(const FuncType& expected,
                       const FuncType& actual,
                       std::string* out_msg);
 
+  // To simplify the implementation, FuncType may also represent
+  // Struct and Array types. To do this, the mutability is stored
+  // in results, which must have the same size as params.
+  // This implementation might change in the future.
+  TypeKind kind;
   ValueTypes params;
   ValueTypes results;
   // When params or results contain references, the referenced

include/wabt/ir.h

@@ -297,6 +297,20 @@ enum class TypeEntryKind {
   Array,
 };
 
+struct TypeEntryGCTypeExtension {
+  TypeEntryGCTypeExtension(bool is_final_sub_type)
+      : is_final_sub_type(is_final_sub_type) {}
+
+  void InitSubTypes(Index* sub_type_list, Index sub_type_count);
+
+  bool is_final_sub_type;
+  // The binary format allows more subtypes, although
+  // the validator limits the list to maximum 1 value.
+  // Furthermore the text parser must allow future
+  // references although the validator also disallows this.
+  std::vector<Var> sub_types;
+};
+
 class TypeEntry {
  public:
   WABT_DISALLOW_COPY_AND_ASSIGN(TypeEntry);
@@ -307,12 +321,17 @@ class TypeEntry {
 
   Location loc;
   std::string name;
+  TypeEntryGCTypeExtension gc_ext;
 
  protected:
   explicit TypeEntry(TypeEntryKind kind,
+                     bool is_final_sub_type,
                      std::string_view name = std::string_view(),
                      const Location& loc = Location())
-      : loc(loc), name(name), kind_(kind) {}
+      : loc(loc),
+        name(name),
+        gc_ext(is_final_sub_type),
+        kind_(kind) {}
 
   TypeEntryKind kind_;
 };
@@ -323,8 +342,8 @@ class FuncType : public TypeEntry {
     return entry->kind() == TypeEntryKind::Func;
   }
 
-  explicit FuncType(std::string_view name = std::string_view())
-      : TypeEntry(TypeEntryKind::Func, name) {}
+  explicit FuncType(bool is_final_sub_type, std::string_view name = std::string_view())
+      : TypeEntry(TypeEntryKind::Func, is_final_sub_type, name) {}
 
   Index GetNumParams() const { return sig.GetNumParams(); }
   Index GetNumResults() const { return sig.GetNumResults(); }
@@ -353,8 +372,8 @@ class StructType : public TypeEntry {
     return entry->kind() == TypeEntryKind::Struct;
   }
 
-  explicit StructType(std::string_view name = std::string_view())
-      : TypeEntry(TypeEntryKind::Struct) {}
+  explicit StructType(bool is_final_sub_type, std::string_view name = std::string_view())
+      : TypeEntry(TypeEntryKind::Struct, is_final_sub_type, name) {}
 
   std::vector<Field> fields;
 };
@@ -365,12 +384,17 @@ class ArrayType : public TypeEntry {
     return entry->kind() == TypeEntryKind::Array;
   }
 
-  explicit ArrayType(std::string_view name = std::string_view())
-      : TypeEntry(TypeEntryKind::Array) {}
+  explicit ArrayType(bool is_final_sub_type, std::string_view name = std::string_view())
+      : TypeEntry(TypeEntryKind::Array, is_final_sub_type, name) {}
 
   Field field;
 };
 
+struct RecursiveRange {
+  Index start_index;
+  Index type_count;
+};
+
 struct FuncDeclaration {
   Index GetNumParams() const { return sig.GetNumParams(); }
   Index GetNumResults() const { return sig.GetNumResults(); }
@@ -1319,6 +1343,8 @@ struct Module {
   std::vector<Import*> imports;
   std::vector<Export*> exports;
   std::vector<TypeEntry*> types;
+  // Ordered list of recursive ranges. Needed for binary search.
+  std::vector<RecursiveRange> recursive_ranges;
   std::vector<Table*> tables;
   std::vector<ElemSegment*> elem_segments;
   std::vector<Memory*> memories;

include/wabt/shared-validator.h

@@ -29,8 +29,6 @@
 #include "wabt/opcode.h"
 #include "wabt/type-checker.h"
 
-#include "wabt/binary-reader.h"  // For TypeMut.
-
 namespace wabt {
 
 struct ValidateOptions {
@@ -43,7 +41,11 @@ struct ValidateOptions {
 class SharedValidator {
  public:
   WABT_DISALLOW_COPY_AND_ASSIGN(SharedValidator);
+  using TypeEntry = TypeChecker::TypeEntry;
   using FuncType = TypeChecker::FuncType;
+  using StructType = TypeChecker::StructType;
+  using ArrayType = TypeChecker::ArrayType;
+  using RecursiveRange = TypeChecker::RecursiveRange;
   SharedValidator(Errors*, const ValidateOptions& options);
 
   // TODO: Move into SharedValidator?
@@ -65,14 +67,21 @@ class SharedValidator {
 
   Result EndModule();
 
+  Result OnRecursiveRange(Index start_index, Index type_count);
   Result OnFuncType(const Location&,
+                    GCTypeExtension* gc_ext,
                     Index param_count,
                     const Type* param_types,
                     Index result_count,
                     const Type* result_types,
                     Index type_index);
-  Result OnStructType(const Location&, Index field_count, TypeMut* fields);
-  Result OnArrayType(const Location&, TypeMut field);
+  Result OnStructType(const Location&,
+                      GCTypeExtension* gc_ext,
+                      Index field_count,
+                      TypeMut* fields);
+  Result OnArrayType(const Location&,
+                     GCTypeExtension* gc_ext,
+                     TypeMut field);
 
   Result OnFunction(const Location&, Var sig_var);
   Result OnTable(const Location&, Type elem_type, const Limits&, bool, bool);
@@ -225,20 +234,6 @@ class SharedValidator {
   Result OnUnreachable(const Location&);
 
  private:
-  struct StructType {
-    StructType() = default;
-    StructType(const TypeMutVector& fields) : fields(fields) {}
-
-    TypeMutVector fields;
-  };
-
-  struct ArrayType {
-    ArrayType() = default;
-    ArrayType(TypeMut field) : field(field) {}
-
-    TypeMut field;
-  };
-
   struct TableType {
     TableType() = default;
     TableType(Type element, Limits limits) : element(element), limits(limits) {}
@@ -293,6 +288,11 @@ class SharedValidator {
                    Type expected,
                    const char* desc);
   Result CheckReferenceType(const Location&, Type type, const char* desc);
+  Result CheckRecursiveReferenceType(const Location&,
+                                     Type type,
+                                     Index max_index,
+                                     const char* desc);
+  Result CheckGCInfo(const Location&, GCTypeExtension* gc_ext);
   Result CheckLimits(const Location&,
                      const Limits&,
                      uint64_t absolute_max,
@@ -344,10 +344,7 @@ class SharedValidator {
   Location expr_loc_ = Location(kInvalidOffset);
   bool in_init_expr_ = false;
 
-  Index num_types_ = 0;
-  std::map<Index, FuncType> func_types_;
-  std::map<Index, StructType> struct_types_;
-  std::map<Index, ArrayType> array_types_;
+  TypeChecker::TypeFields type_fields_;
 
   std::vector<FuncType> funcs_;       // Includes imported and defined.
   std::vector<TableType> tables_;     // Includes imported and defined.

include/wabt/token.def

@@ -21,7 +21,6 @@
 /* Tokens with no additional data (i.e. bare). */
 WABT_TOKEN(Invalid, "Invalid")
 WABT_TOKEN(After, "after")
-WABT_TOKEN(Array, "array")
 WABT_TOKEN(AssertException, "assert_exception")
 WABT_TOKEN(AssertExhaustion, "assert_exhaustion")
 WABT_TOKEN(AssertInvalid, "assert_invalid")
@@ -42,6 +41,7 @@ WABT_TOKEN(Eof, "EOF")
 WABT_TOKEN(Tag, "tag")
 WABT_TOKEN(Export, "export")
 WABT_TOKEN(Field, "field")
+WABT_TOKEN(Final, "final")
 WABT_TOKEN(Function, "function")
 WABT_TOKEN(Get, "get")
 WABT_TOKEN(Global, "global")
@@ -62,12 +62,13 @@ WABT_TOKEN(PageSize, "pagesize")
 WABT_TOKEN(Param, "param")
 WABT_TOKEN(Ref, "ref")
 WABT_TOKEN(Quote, "quote")
+WABT_TOKEN(Rec, "rec")
 WABT_TOKEN(Register, "register")
 WABT_TOKEN(Result, "result")
 WABT_TOKEN(Rpar, ")")
 WABT_TOKEN(Shared, "shared")
 WABT_TOKEN(Start, "start")
-WABT_TOKEN(Struct, "struct")
+WABT_TOKEN(Sub, "sub")
 WABT_TOKEN(Table, "table")
 WABT_TOKEN(Then, "then")
 WABT_TOKEN(Type, "type")
@@ -182,8 +183,16 @@ WABT_TOKEN_FIRST(Type, ValueType)
 WABT_TOKEN_LAST(Type, ValueType)
 
 /* Tokens with Type data, but are reference kinds. */
+WABT_TOKEN(Any, "any")
+WABT_TOKEN(Array, "array")
 WABT_TOKEN(Func, "func")
+WABT_TOKEN(Eq, "eq")
 WABT_TOKEN(Extern, "extern")
 WABT_TOKEN(Exn, "exn")
-WABT_TOKEN_FIRST(RefKind, Func)
-WABT_TOKEN_LAST(RefKind, Exn)
+WABT_TOKEN(I31, "i31")
+WABT_TOKEN(NoExtern, "noextern")
+WABT_TOKEN(NoFunc, "nofunc")
+WABT_TOKEN(None, "none")
+WABT_TOKEN(Struct, "struct")
+WABT_TOKEN_FIRST(RefKind, Any)
+WABT_TOKEN_LAST(RefKind, Struct)