Implement GC opcodes

Author: zherczeg

include/wabt/binary-reader-logging.h

@@ -165,6 +165,17 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnOpcodeV128(v128 value) override;
   Result OnOpcodeBlockSig(Type sig_type) override;
   Result OnOpcodeType(Type type) override;
+  Result OnArrayCopy(Index dst_type_index, Index src_type_index) override;
+  Result OnArrayFill(Index type_index) override;
+  Result OnArrayGet(Opcode opcode, Index type_index) override;
+  Result OnArrayInitData(Index type_index, Index data_index) override;
+  Result OnArrayInitElem(Index type_index, Index elem_index) override;
+  Result OnArrayNew(Index type_index) override;
+  Result OnArrayNewData(Index type_index, Index data_index) override;
+  Result OnArrayNewDefault(Index type_index) override;
+  Result OnArrayNewElem(Index type_index, Index elem_index) override;
+  Result OnArrayNewFixed(Index type_index, Index count) override;
+  Result OnArraySet(Index type_index) override;
   Result OnAtomicLoadExpr(Opcode opcode,
                           Index memidx,
                           Address alignment_log2,
@@ -204,6 +215,7 @@ class BinaryReaderLogging : public BinaryReaderDelegate {
   Result OnF32ConstExpr(uint32_t value_bits) override;
   Result OnF64ConstExpr(uint64_t value_bits) override;
   Result OnV128ConstExpr(v128 value_bits) override;
+  Result OnGCUnaryExpr(Opcode opcode) override;
   Result OnGlobalGetExpr(Index global_index) override;
   Result OnGlobalSetExpr(Index global_index) override;
   Result OnI32ConstExpr(uint32_t value) override;
@@ -246,6 +258,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

@@ -219,6 +219,31 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnOpcodeV128(v128 value) override { return Result::Ok; }
   Result OnOpcodeBlockSig(Type sig_type) override { return Result::Ok; }
   Result OnOpcodeType(Type type) override { return Result::Ok; }
+  Result OnArrayCopy(Index dst_type_index, Index src_type_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayFill(Index type_index) override { return Result::Ok; }
+  Result OnArrayGet(Opcode opcode, Index type_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayInitData(Index type_index, Index data_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayInitElem(Index type_index, Index elem_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayNew(Index type_index) override { return Result::Ok; }
+  Result OnArrayNewData(Index type_index, Index data_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayNewDefault(Index type_index) override { return Result::Ok; }
+  Result OnArrayNewElem(Index type_index, Index elem_index) override {
+    return Result::Ok;
+  }
+  Result OnArrayNewFixed(Index type_index, Index count) override {
+    return Result::Ok;
+  }
+  Result OnArraySet(Index type_index) override { return Result::Ok; }
   Result OnAtomicLoadExpr(Opcode opcode,
                           Index memidx,
                           Address alignment_log2,
@@ -277,6 +302,7 @@ class BinaryReaderNop : public BinaryReaderDelegate {
   Result OnF32ConstExpr(uint32_t value_bits) override { return Result::Ok; }
   Result OnF64ConstExpr(uint64_t value_bits) override { return Result::Ok; }
   Result OnV128ConstExpr(v128 value_bits) override { return Result::Ok; }
+  Result OnGCUnaryExpr(Opcode opcode) override { return Result::Ok; }
   Result OnGlobalGetExpr(Index global_index) override { return Result::Ok; }
   Result OnGlobalSetExpr(Index global_index) override { return Result::Ok; }
   Result OnI32ConstExpr(uint32_t value) override { return Result::Ok; }
@@ -335,6 +361,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

@@ -237,6 +237,17 @@ class BinaryReaderDelegate {
   virtual Result OnOpcodeV128(v128 value) = 0;
   virtual Result OnOpcodeBlockSig(Type sig_type) = 0;
   virtual Result OnOpcodeType(Type type) = 0;
+  virtual Result OnArrayCopy(Index dst_type_index, Index src_type_index) = 0;
+  virtual Result OnArrayFill(Index type_index) = 0;
+  virtual Result OnArrayGet(Opcode opcode, Index type_index) = 0;
+  virtual Result OnArrayInitData(Index type_index, Index data_index) = 0;
+  virtual Result OnArrayInitElem(Index type_index, Index elem_index) = 0;
+  virtual Result OnArrayNew(Index type_index) = 0;
+  virtual Result OnArrayNewData(Index type_index, Index data_index) = 0;
+  virtual Result OnArrayNewDefault(Index type_index) = 0;
+  virtual Result OnArrayNewElem(Index type_index, Index elem_index) = 0;
+  virtual Result OnArrayNewFixed(Index type_index, Index count) = 0;
+  virtual Result OnArraySet(Index type_index) = 0;
   virtual Result OnAtomicLoadExpr(Opcode opcode,
                                   Index memidx,
                                   Address alignment_log2,
@@ -285,6 +296,7 @@ class BinaryReaderDelegate {
   virtual Result OnF32ConstExpr(uint32_t value_bits) = 0;
   virtual Result OnF64ConstExpr(uint64_t value_bits) = 0;
   virtual Result OnV128ConstExpr(v128 value_bits) = 0;
+  virtual Result OnGCUnaryExpr(Opcode opcode) = 0;
   virtual Result OnGlobalGetExpr(Index global_index) = 0;
   virtual Result OnGlobalSetExpr(Index global_index) = 0;
   virtual Result OnI32ConstExpr(uint32_t value) = 0;
@@ -328,6 +340,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,22 @@ class ExprVisitor::Delegate {
   virtual Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) = 0;
   virtual Result OnLoadSplatExpr(LoadSplatExpr*) = 0;
   virtual Result OnLoadZeroExpr(LoadZeroExpr*) = 0;
+  virtual Result OnArrayCopyExpr(ArrayCopyExpr*) = 0;
+  virtual Result OnArrayFillExpr(ArrayFillExpr*) = 0;
+  virtual Result OnArrayGetExpr(ArrayGetExpr*) = 0;
+  virtual Result OnArrayInitDataExpr(ArrayInitDataExpr*) = 0;
+  virtual Result OnArrayInitElemExpr(ArrayInitElemExpr*) = 0;
+  virtual Result OnArrayNewExpr(ArrayNewExpr*) = 0;
+  virtual Result OnArrayNewDataExpr(ArrayNewDataExpr*) = 0;
+  virtual Result OnArrayNewDefaultExpr(ArrayNewDefaultExpr*) = 0;
+  virtual Result OnArrayNewElemExpr(ArrayNewElemExpr*) = 0;
+  virtual Result OnArrayNewFixedExpr(ArrayNewFixedExpr*) = 0;
+  virtual Result OnArraySetExpr(ArraySetExpr*) = 0;
+  virtual Result OnGCUnaryExpr(GCUnaryExpr*) = 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 +246,26 @@ 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 OnArrayCopyExpr(ArrayCopyExpr*) override { return Result::Ok; }
+  Result OnArrayFillExpr(ArrayFillExpr*) override { return Result::Ok; }
+  Result OnArrayGetExpr(ArrayGetExpr*) override { return Result::Ok; }
+  Result OnArrayInitDataExpr(ArrayInitDataExpr*) override { return Result::Ok; }
+  Result OnArrayInitElemExpr(ArrayInitElemExpr*) override { return Result::Ok; }
+  Result OnArrayNewExpr(ArrayNewExpr*) override { return Result::Ok; }
+  Result OnArrayNewDataExpr(ArrayNewDataExpr*) override { return Result::Ok; }
+  Result OnArrayNewDefaultExpr(ArrayNewDefaultExpr*) override {
+    return Result::Ok;
+  }
+  Result OnArrayNewElemExpr(ArrayNewElemExpr*) override { return Result::Ok; }
+  Result OnArrayNewFixedExpr(ArrayNewFixedExpr*) override { return Result::Ok; }
+  Result OnArraySetExpr(ArraySetExpr*) override { return Result::Ok; }
+  Result OnGCUnaryExpr(GCUnaryExpr*) 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,53 @@ inline const TagType& Tag::type() const {
   return type_;
 }
 
+//// Array ////
+// static
+inline bool Array::classof(const Object* obj) {
+  return obj->kind() == skind;
+}
+
+inline Array::Ptr Array::New(Store& store,
+                             u32 size,
+                             Index type_index,
+                             Module* mod) {
+  return store.Alloc<Array>(store, size, type_index, mod);
+}
+
+inline Index Array::Size() {
+  return static_cast<Index>(items_.size());
+}
+
+inline Value Array::GetItem(Index idx) {
+  return items_[idx];
+}
+
+inline void Array::SetItem(Index idx, Value value) {
+  items_[idx] = value;
+}
+
+//// 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,8 @@ enum class ObjectKind {
   Memory,
   Global,
   Tag,
+  Array,
+  Struct,
   Module,
   Instance,
 
@@ -999,6 +1001,52 @@ class Tag : public Extern {
   TagType type_;
 };
 
+class Array : public Object {
+ public:
+  static bool classof(const Object* obj);
+  static const ObjectKind skind = ObjectKind::Array;
+  static const char* GetTypeName() { return "Array"; }
+  using Ptr = RefPtr<Array>;
+
+  static Array::Ptr New(Store&, u32 size, Index type_index, Module* mod);
+
+  Index Size();
+  Value GetItem(Index idx);
+  void SetItem(Index idx, Value value);
+
+ private:
+  friend Store;
+  explicit Array(Store&, u32 size, Index type_index, Module* mod);
+  void Mark(Store&) override;
+
+  Ref module_;
+  Index type_index_;
+  Values items_;
+};
+
+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,8 @@ 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_2,        // array.new_data
   Imm_Index_Index_Op_3,        // memory.init
   Imm_Index_Index_Op_N,        // call_indirect
   Imm_Index_Offset_Op_1,       // i32.load