feat: Implement additional gc instructions

Author: spotandjake

src/expression.c

@@ -2086,6 +2086,18 @@ caml_binaryen_array_new_data(value _module, value _type, value _name, value _off
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
+CAMLprim value
+caml_binaryen_array_new_elem(value _module, value _type, value _seg, value _offset, value _size) {
+  CAMLparam5(_module, _type, _seg, _offset, _size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType type = BinaryenHeapType_val(_type);
+  char* seg = Safe_String_val(_seg);
+  BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayNewElem(module, type, seg, offset, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_array_new_fixed(value _module, value _type, value _values) {
   CAMLparam3(_module, _type, _values);
@@ -2151,6 +2163,18 @@ caml_binaryen_array_copy__bytecode(value * argv) {
   return caml_binaryen_array_copy(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_array_fill(value _module, value _ref, value _index, value _value, value _size) {
+  CAMLparam5(_module, _ref, _index, _value, _size);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef ref = BinaryenExpressionRef_val(_ref);
+  BinaryenExpressionRef index = BinaryenExpressionRef_val(_index);
+  BinaryenExpressionRef val = BinaryenExpressionRef_val(_value);
+  BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
+  BinaryenExpressionRef exp = BinaryenArrayFill(module, ref, index, val, size);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 // Table operations
 CAMLprim value
 caml_binaryen_table_get(value _module, value _name, value _index, value _ty) {

src/expression.js

@@ -575,13 +575,13 @@ function caml_binaryen_ref_cast(wasm_mod, ref, typ) {
 function caml_binaryen_br_on(wasm_mod, op, name, ref, typ) {
   switch (op) {
     case Binaryen.BrOnNull:
-      return wasm_mod.br_on.null(caml_jsstring_of_string(name), ref, typ);
+      return wasm_mod.br_on_null(caml_jsstring_of_string(name), ref);
     case Binaryen.BrOnNonNull:
-      return wasm_mod.br_on.non_null(caml_jsstring_of_string(name), ref, typ);
+      return wasm_mod.br_on_non_null(caml_jsstring_of_string(name), ref);
     case Binaryen.BrOnCast:
-      return wasm_mod.br_on.cast(caml_jsstring_of_string(name), ref, typ);
+      return wasm_mod.br_on_cast(caml_jsstring_of_string(name), ref, typ);
     case Binaryen.BrOnCastFail:
-      return wasm_mod.br_on.cast_fail(caml_jsstring_of_string(name), ref, typ);
+      return wasm_mod.br_on_cast_fail(caml_jsstring_of_string(name), ref, typ);
   }
 }
 
@@ -1821,11 +1821,7 @@ function caml_binaryen_struct_new(wasm_mod, operands, type) {
 //Provides: caml_binaryen_struct_get
 //Requires: caml_js_from_bool
 function caml_binaryen_struct_get(wasm_mod, index, ref, type, signed) {
-  if (caml_js_from_bool(signed)) {
-    return wasm_mod.struct.get_s(index, ref, type);
-  } else {
-    return wasm_mod.struct.get_u(index, ref, type);
-  }
+  return wasm_mod.struct.get(index, ref, type, caml_js_from_bool(signed));
 }
 
 //Provides: caml_binaryen_struct_set
@@ -1851,6 +1847,17 @@ function caml_binaryen_array_new_data(wasm_mod, type, name, offset, size) {
   );
 }
 
+//Provides: caml_binaryen_array_new_elem
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_new_elem(wasm_mod, type, name, offset, size) {
+  return wasm_mod.array.new_elem(
+    type,
+    caml_jsstring_of_string(name),
+    offset,
+    size
+  );
+}
+
 //Provides: caml_binaryen_array_new_fixed
 //Requires: caml_list_to_js_array
 function caml_binaryen_array_new_fixed(wasm_mod, type, values) {
@@ -1860,11 +1867,7 @@ function caml_binaryen_array_new_fixed(wasm_mod, type, values) {
 //Provides: caml_binaryen_array_get
 //Requires: caml_js_from_bool
 function caml_binaryen_array_get(wasm_mod, ref, index, type, signed) {
-  if (caml_js_from_bool(signed)) {
-    return wasm_mod.array.get_s(ref, index, type);
-  } else {
-    return wasm_mod.array.get_u(ref, index, type);
-  }
+  return wasm_mod.array.get(ref, index, type, caml_js_from_bool(signed));
 }
 
 //Provides: caml_binaryen_array_set
@@ -1877,6 +1880,11 @@ function caml_binaryen_array_len(wasm_mod, ref) {
   return wasm_mod.array.len(ref);
 }
 
+//Provides: caml_binaryen_array_fill
+function caml_binaryen_array_fill(wasm_mod, ref, index, value, size) {
+  return wasm_mod.array.fill(ref, index, value, size);
+}
+
 //Provides: caml_binaryen_array_copy
 function caml_binaryen_array_copy(
   wasm_mod,

src/expression.ml

@@ -899,6 +899,10 @@ module Array = struct
     = "caml_binaryen_array_new_data"
   (** Module, type, data name, offset, size *)
 
+  external new_elem : Module.t -> Heap_type.t -> string -> t -> t -> t
+    = "caml_binaryen_array_new_elem"
+  (** Module, type, seg, offset, size *)
+
   external new_fixed : Module.t -> Heap_type.t -> t list -> t
     = "caml_binaryen_array_new_fixed"
   (** Module, type, values *)
@@ -913,6 +917,10 @@ module Array = struct
   external len : Module.t -> t -> t = "caml_binaryen_array_len"
   (** Module, array *)
 
+  external fill : Module.t -> Heap_type.t -> t -> t -> t -> t
+    = "caml_binaryen_array_fill"
+  (** Module, type, seg, offset, size *)
+
   external copy : Module.t -> t -> t -> t -> t -> t -> t
     = "caml_binaryen_array_copy__bytecode" "caml_binaryen_array_copy"
   (** Module, dest, dest index, src, src index, length *)

src/expression.mli

@@ -394,6 +394,9 @@ module Array : sig
   val new_data : Module.t -> Heap_type.t -> string -> t -> t -> t
   (** Module, type, data name, offset, size *)
 
+  val new_elem : Module.t -> Heap_type.t -> string -> t -> t -> t
+  (** Module, type, seg, offset, size *)
+
   val new_fixed : Module.t -> Heap_type.t -> t list -> t
   (** Module, type, values *)
 
@@ -406,6 +409,9 @@ module Array : sig
   val len : Module.t -> t -> t
   (** Module, array *)
 
+  val fill : Module.t -> Heap_type.t -> t -> t -> t -> t
+  (** Module, type, seg, offset, size *)
+
   val copy : Module.t -> t -> t -> t -> t -> t -> t
   (** Module, dest, dest index, src, src index, length *)
 end

src/type_builder.ml

@@ -6,6 +6,7 @@ type struct_field = {
   mutable_ : bool;
 }
 
+(* Source: https://github.com/WebAssembly/binaryen/blob/64ba23996a10e229d46e41eb37736a55af87f79a/src/binaryen-c.h#L3618 *)
 type error =
   | SelfSupertype of int
   | InvalidSupertype of int
@@ -21,7 +22,8 @@ external set_signature_type : t -> int -> Type.t -> Type.t -> unit
 
 external set_struct_type :
   t -> int -> Type.t list -> Packed_type.t list -> bool list -> int -> unit
-  = "caml_type_builder_set_struct_type__bytecode" "caml_type_builder_set_struct_type"
+  = "caml_type_builder_set_struct_type__bytecode"
+    "caml_type_builder_set_struct_type"
 
 let set_struct_type builder index fields =
   let split_fields fields =
@@ -45,15 +47,15 @@ external get_temp_tuple_type : t -> Type.t list -> Type.t
 external get_temp_ref_type : t -> Heap_type.t -> bool -> Type.t
   = "caml_type_builder_get_temp_ref_type"
 
-external set_sub_type : t -> int -> Type.t -> unit
+external set_sub_type : t -> int -> Heap_type.t -> unit
   = "caml_type_builder_set_sub_type"
 
 external set_open : t -> int -> unit = "caml_type_builder_set_open"
 
 external create_rec_group : t -> int -> int -> unit
   = "caml_type_builder_create_rec_group"
 
-external build_and_dispose : t -> (Type.t array, int * int) result
+external build_and_dispose : t -> (Heap_type.t array, int * int) result
   = "caml_type_builder_build_and_dispose"
 
 let build_and_dispose builder =

src/type_builder.mli

@@ -6,6 +6,7 @@ type struct_field = {
   mutable_ : bool;
 }
 
+(* Source: https://github.com/WebAssembly/binaryen/blob/64ba23996a10e229d46e41eb37736a55af87f79a/src/binaryen-c.h#L3618 *)
 type error =
   | SelfSupertype of int
   | InvalidSupertype of int
@@ -21,7 +22,7 @@ val set_array_type : t -> int -> Type.t -> Packed_type.t -> bool -> unit
 val get_temp_heap_type : t -> int -> Heap_type.t
 val get_temp_tuple_type : t -> Type.t list -> Type.t
 val get_temp_ref_type : t -> Heap_type.t -> bool -> Type.t
-val set_sub_type : t -> int -> Type.t -> unit
+val set_sub_type : t -> int -> Heap_type.t -> unit
 val set_open : t -> int -> unit
 val create_rec_group : t -> int -> int -> unit
-val build_and_dispose : t -> (Type.t list, error) result
+val build_and_dispose : t -> (Heap_type.t list, error) result

test/test.expected

@@ -120,7 +120,7 @@
 (module
  (type $0 (struct (field i31ref) (field (ref null $0))))
  (type $1 (array (mut i8)))
- (type $2 (func (result (ref $1) (ref $0))))
+ (type $2 (func (result (ref (exact $1)) (ref (exact $0)))))
  (type $3 (func (param i32 i32) (result i32)))
  (type $4 (func))
  (type $5 (func (param anyref i32 i32) (result i32)))
@@ -170,7 +170,7 @@
   )
  )
  (func $gc (type $7) (param $0 anyref) (result anyref anyref)
-  (local $1 (ref $1))
+  (local $1 (ref (exact $1)))
   (array.set $1
    (local.tee $1
     (array.new_fixed $1 2
@@ -260,7 +260,7 @@
   )
  )
  (func $3 (type $type_4) (param $0 anyref) (result anyref anyref)
-  (local $1 (ref $type_5))
+  (local $1 (ref (exact $type_5)))
   (array.set $type_5
    (local.tee $1
     (array.new_fixed $type_5 2
@@ -343,7 +343,7 @@
   call $fimport$0
  )
  (func $3 (type $type_4) (param $0 anyref) (result anyref anyref)
-  (local $1 (ref $type_5))
+  (local $1 (ref (exact $type_5)))
   i32.const 0
   i32.const 255
   array.new_fixed $type_5 2

test/test.ml

@@ -325,25 +325,25 @@ let _ =
   let i32 v = Expression.Const.make wasm_mod (Literal.int32 v) in
   let i31 v = Expression.I31.make wasm_mod (i32 v) in
   let cons first rest =
-    Expression.Struct.new_ wasm_mod
-      (Some [ first; rest ])
-      (Type.get_heap_type list_type)
+    Expression.Struct.new_ wasm_mod (Some [ first; rest ]) list_type
   in
   let empty () =
-    Expression.Ref.null wasm_mod
-      (Type.from_heap_type (Type.get_heap_type list_type) true)
+    Expression.Ref.null wasm_mod (Type.from_heap_type list_type true)
   in
   Function.add_function wasm_mod "gc" Type.anyref
     (Type.create [| Type.anyref; Type.anyref |])
-    [| array_u8_type; list_type |]
+    [|
+      Type.from_heap_type array_u8_type false;
+      Type.from_heap_type list_type false;
+    |]
     (Expression.Block.make wasm_mod "gc_block"
        [
          Expression.Local_set.make wasm_mod 1
-           (Expression.Array.new_fixed wasm_mod
-              (Type.get_heap_type array_u8_type)
+           (Expression.Array.new_fixed wasm_mod array_u8_type
               [ i32 0l; i32 255l ]);
          Expression.Array.set wasm_mod
-           (Expression.Local_get.make wasm_mod 1 array_u8_type)
+           (Expression.Local_get.make wasm_mod 1
+              (Type.from_heap_type array_u8_type false))
            (i32 1l) (i32 42l);
          Expression.Local_set.make wasm_mod 2
            (cons
@@ -353,8 +353,10 @@ let _ =
               (cons (i31 1l) (cons (i31 2l) (cons (i31 3l) (empty ())))));
          Expression.Tuple_make.make wasm_mod
            [
-             Expression.Local_get.make wasm_mod 1 array_u8_type;
-             Expression.Local_get.make wasm_mod 2 list_type;
+             Expression.Local_get.make wasm_mod 1
+               (Type.from_heap_type array_u8_type false);
+             Expression.Local_get.make wasm_mod 2
+               (Type.from_heap_type list_type false);
            ];
        ])