Implement GC opcodes

Author: Zoltan Herczeg

include/wabt/binary-reader-logging.h

@@ -246,6 +246,12 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
                      Index memidx,
                      Address alignment_log2,
                      Address offset) override;
+  Result OnStructGet(Opcode opcode,
+                     Index type_index,
+                     Index field_index) override;
+  Result OnStructNew(Index type_index) override;
+  Result OnStructNewDefault(Index type_index) override;
+  Result OnStructSet(Index type_index, Index field_index) override;
   Result OnThrowExpr(Index tag_index) override;
   Result OnThrowRefExpr() override;
   Result OnTryExpr(Type sig_type) override;

include/wabt/binary-reader-nop.h

@@ -335,6 +335,14 @@ class BinaryReaderNop : public BinaryReaderDelegate {
                      Address offset) override {
     return Result::Ok;
   }
+  Result OnStructGet(Opcode opcode,
+                     Index type_index,
+                     Index field_index) override {
+    return Result::Ok;
+  }
+  Result OnStructNew(Index type_index) override { return Result::Ok; }
+  Result OnStructNewDefault(Index type_index) override { return Result::Ok; }
+  Result OnStructSet(Index type_index, Index field_index) override { return Result::Ok; }
   Result OnThrowExpr(Index depth) override { return Result::Ok; }
   Result OnThrowRefExpr() override { return Result::Ok; }
   Result OnTryExpr(Type sig_type) override { return Result::Ok; }

include/wabt/binary-reader.h

@@ -328,6 +328,12 @@ class BinaryReaderDelegate {
                              Index memidx,
                              Address alignment_log2,
                              Address offset) = 0;
+  virtual Result OnStructGet(Opcode opcode,
+                             Index type_index,
+                             Index field_index) = 0;
+  virtual Result OnStructNew(Index type_index) = 0;
+  virtual Result OnStructNewDefault(Index type_index) = 0;
+  virtual Result OnStructSet(Index type_index, Index field_index) = 0;
   virtual Result OnThrowExpr(Index tag_index) = 0;
   virtual Result OnThrowRefExpr() = 0;
   virtual Result OnTryExpr(Type sig_type) = 0;

include/wabt/expr-visitor.h

@@ -145,6 +145,10 @@ class ExprVisitor::Delegate {
   virtual Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) = 0;
   virtual Result OnLoadSplatExpr(LoadSplatExpr*) = 0;
   virtual Result OnLoadZeroExpr(LoadZeroExpr*) = 0;
+  virtual Result OnStructGetExpr(StructGetExpr*) = 0;
+  virtual Result OnStructNewExpr(StructNewExpr*) = 0;
+  virtual Result OnStructNewDefaultExpr(StructNewDefaultExpr*) = 0;
+  virtual Result OnStructSetExpr(StructSetExpr*) = 0;
 };
 
 class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
@@ -230,6 +234,12 @@ class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) override { return Result::Ok; }
   Result OnLoadSplatExpr(LoadSplatExpr*) override { return Result::Ok; }
   Result OnLoadZeroExpr(LoadZeroExpr*) override { return Result::Ok; }
+  Result OnStructGetExpr(StructGetExpr*) override { return Result::Ok; }
+  Result OnStructNewExpr(StructNewExpr*) override { return Result::Ok; }
+  Result OnStructNewDefaultExpr(StructNewDefaultExpr*) override {
+    return Result::Ok;
+  }
+  Result OnStructSetExpr(StructSetExpr*) override { return Result::Ok; }
 };
 
 }  // namespace wabt

include/wabt/interp/interp-inl.h

@@ -902,6 +902,28 @@ inline const TagType& Tag::type() const {
   return type_;
 }
 
+//// Struct ////
+// static
+inline bool Struct::classof(const Object* obj) {
+  return obj->kind() == skind;
+}
+
+inline Struct::Ptr Struct::New(Store& store, Index type_index, Module* mod) {
+  return store.Alloc<Struct>(store, type_index, mod);
+}
+
+inline Index Struct::Size() {
+  return static_cast<Index>(fields_.size());
+}
+
+inline Value Struct::GetField(Index idx) {
+  return fields_[idx];
+}
+
+inline void Struct::SetField(Index idx, Value value) {
+  fields_[idx] = value;
+}
+
 //// ElemSegment ////
 inline void ElemSegment::Drop() {
   elements_.clear();

include/wabt/interp/interp.h

@@ -89,6 +89,7 @@ enum class ObjectKind {
   Memory,
   Global,
   Tag,
+  Struct,
   Module,
   Instance,
 
@@ -999,6 +1000,29 @@ class Tag : public Extern {
   TagType type_;
 };
 
+class Struct : public Object {
+ public:
+  static bool classof(const Object* obj);
+  static const ObjectKind skind = ObjectKind::Struct;
+  static const char* GetTypeName() { return "Struct"; }
+  using Ptr = RefPtr<Struct>;
+
+  static Struct::Ptr New(Store&, Index type_index, Module* mod);
+
+  Index Size();
+  Value GetField(Index idx);
+  void SetField(Index idx, Value value);
+
+ private:
+  friend Store;
+  explicit Struct(Store&, Index type_index, Module* mod);
+  void Mark(Store&) override;
+
+  Ref module_;
+  Index type_index_;
+  Values fields_;
+};
+
 class ElemSegment {
  public:
   explicit ElemSegment(Store& store, const ElemDesc*, RefPtr<Instance>&);

include/wabt/interp/istream.h

@@ -54,6 +54,7 @@ enum class InstrKind {
   Imm_Index_Op_2,              // table.set
   Imm_Index_Op_3,              // memory.fill
   Imm_Index_Op_N,              // call
+  Imm_Index_Index_Op_1,        // struct.get_s
   Imm_Index_Index_Op_3,        // memory.init
   Imm_Index_Index_Op_N,        // call_indirect
   Imm_Index_Offset_Op_1,       // i32.load

include/wabt/ir.h

@@ -183,6 +183,7 @@ struct Const {
   void set_funcref() { From<uintptr_t>(Type::FuncRef, 0); }
   void set_externref(uintptr_t x) { From(Type::ExternRef, x); }
   void set_extern(uintptr_t x) { From(Type(Type::ExternRef, Type::ReferenceNonNull), x); }
+  void set_ref_struct() { From<uintptr_t>(Type(Type::StructRef, Type::ReferenceNonNull), 0); }
   void set_null(Type type) { From<uintptr_t>(type, kRefNullBits); }
 
   bool is_expected_nan(int lane = 0) const {
@@ -457,6 +458,10 @@ enum class ExprType {
   SimdLoadLane,
   SimdStoreLane,
   SimdShuffleOp,
+  StructGet,
+  StructNew,
+  StructNewDefault,
+  StructSet,
   LoadSplat,
   LoadZero,
   Store,
@@ -707,6 +712,8 @@ using LocalTeeExpr = VarExpr<ExprType::LocalTee>;
 using ReturnCallExpr = VarExpr<ExprType::ReturnCall>;
 using ThrowExpr = VarExpr<ExprType::Throw>;
 using RethrowExpr = VarExpr<ExprType::Rethrow>;
+using StructNewExpr = VarExpr<ExprType::StructNew>;
+using StructNewDefaultExpr = VarExpr<ExprType::StructNewDefault>;
 
 using DataDropExpr = VarExpr<ExprType::DataDrop>;
 using ElemDropExpr = VarExpr<ExprType::ElemDrop>;
@@ -896,6 +903,28 @@ class AtomicFenceExpr : public ExprMixin<ExprType::AtomicFence> {
   uint32_t consistency_model;
 };
 
+template <ExprType TypeEnum>
+class TypeVarExpr : public ExprMixin<TypeEnum> {
+ public:
+  TypeVarExpr(const Var& comp_type, const Var& var, const Location& loc = Location())
+      : ExprMixin<TypeEnum>(loc), comp_type(comp_type), var(var) {}
+
+  Var comp_type;
+  Var var;
+};
+
+using StructSetExpr = TypeVarExpr<ExprType::StructSet>;
+
+class StructGetExpr : public ExprMixin<ExprType::StructGet> {
+ public:
+  StructGetExpr(Opcode opcode, const Var& comp_type, const Var& var, const Location& loc = Location())
+      : ExprMixin<ExprType::StructGet>(loc), opcode(opcode), comp_type(comp_type), var(var) {}
+
+  Opcode opcode;
+  Var comp_type;
+  Var var;
+};
+
 struct Tag {
   explicit Tag(std::string_view name) : name(name) {}
 
@@ -1282,6 +1311,10 @@ struct Module {
   Index GetFuncTypeIndex(const FuncSignature&) const;
   const FuncType* GetFuncType(const Var&) const;
   FuncType* GetFuncType(const Var&);
+  const StructType* GetStructType(const Var&) const;
+  StructType* GetStructType(const Var&);
+  const ArrayType* GetArrayType(const Var&) const;
+  ArrayType* GetArrayType(const Var&);
   Index GetFuncIndex(const Var&) const;
   const Func* GetFunc(const Var&) const;
   Func* GetFunc(const Var&);

include/wabt/opcode.def

@@ -272,6 +272,14 @@ WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd4, RefAsNonNull, "ref.as_non_nu
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd5, BrOnNull, "br_on_null", "")
 WABT_OPCODE(___,  ___,  ___,  ___,  0,  0,    0xd6, BrOnNonNull, "br_on_non_null", "")
 
+/* Garbage collection opcodes */
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x00, StructNew, "struct.new", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x01, StructNewDefault, "struct.new_default", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x02, StructGet, "struct.get", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x03, StructGetS, "struct.get_s", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x04, StructGetU, "struct.get_u", "")
+WABT_OPCODE(___,  ___,  ___,  ___,  0,  0xfb, 0x05, StructSet, "struct.set", "")
+
 /* Simd opcodes */
 WABT_OPCODE(V128, I32,  ___,  ___,  16, 0xfd, 0x00, V128Load, "v128.load", "")
 WABT_OPCODE(V128, I32,   ___, ___,  8,  0xfd, 0x01, V128Load8X8S, "v128.load8x8_s", "")

include/wabt/opcode.h

@@ -84,7 +84,7 @@ struct Opcode {
   Address GetAlignment(Address alignment) const;
 
   static bool IsPrefixByte(uint8_t byte) {
-    return byte == kMathPrefix || byte == kThreadsPrefix || byte == kSimdPrefix;
+    return byte == kMathPrefix || byte == kThreadsPrefix || byte == kGarbageCollectionPrefix || byte == kSimdPrefix;
   }
 
   bool IsEnabled(const Features& features) const;
@@ -93,6 +93,7 @@ struct Opcode {
  private:
   static constexpr uint32_t kMathPrefix = 0xfc;
   static constexpr uint32_t kThreadsPrefix = 0xfe;
+  static constexpr uint32_t kGarbageCollectionPrefix = 0xfb;
   static constexpr uint32_t kSimdPrefix = 0xfd;
 
   struct Info {