wip

src/expression.c

@@ -124,6 +124,22 @@ caml_binaryen_call_indirect__bytecode(value * argv) {
   return caml_binaryen_call_indirect(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_call_ref(value _module, value _target, value _params, value _ty) {
+  CAMLparam4(_module, _target, _params, _ty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  _params = array_of_list(_params);
+  int paramsLen = array_length(_params);
+  BinaryenExpressionRef params[paramsLen];
+  for (int i = 0; i < paramsLen; i++) {
+    params[i] = BinaryenExpressionRef_val(Field(_params, i));
+  }
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenExpressionRef exp = BinaryenCallRef(module, target, params, paramsLen, ty, false);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_return_call(value _module, value _name, value _params, value _retty) {
   CAMLparam4(_module, _name, _params, _retty);
@@ -163,6 +179,22 @@ caml_binaryen_return_call_indirect__bytecode(value * argv) {
   return caml_binaryen_return_call_indirect(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_return_call_ref(value _module, value _target, value _params, value _ty) {
+  CAMLparam4(_module, _target, _params, _ty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  _params = array_of_list(_params);
+  int paramsLen = array_length(_params);
+  BinaryenExpressionRef params[paramsLen];
+  for (int i = 0; i < paramsLen; i++) {
+    params[i] = BinaryenExpressionRef_val(Field(_params, i));
+  }
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenExpressionRef exp = BinaryenCallRef(module, target, params, paramsLen, ty, true);
+  CAMLreturn(alloc_BinaryenExpressionRef(exp));
+}
+
 CAMLprim value
 caml_binaryen_local_get(value _module, value _slot, value _ty) {
   CAMLparam3(_module, _slot, _ty);
@@ -1328,6 +1360,90 @@ caml_binaryen_call_indirect_set_return(value _exp, value _isReturn) {
   CAMLreturn(Val_unit);
 }
 
+CAMLprim value
+caml_binaryen_call_ref_get_target(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef target = BinaryenCallRefGetTarget(exp);
+  CAMLreturn(alloc_BinaryenExpressionRef(target));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_target(value _exp, value _target) {
+  CAMLparam2(_exp, _target);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef target = BinaryenExpressionRef_val(_target);
+  BinaryenCallRefSetTarget(exp, target);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_get_num_operands(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  CAMLreturn(Val_int(BinaryenCallRefGetNumOperands(exp)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_get_operand_at(value _exp, value _index) {
+  CAMLparam2(_exp, _index);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenExpressionRef(BinaryenCallRefGetOperandAt(exp, index)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_operand_at(value _exp, value _index, value _operand) {
+  CAMLparam3(_exp, _index, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  BinaryenCallRefSetOperandAt(exp, index, operand);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_append_operand(value _exp, value _operand) {
+  CAMLparam2(_exp, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  CAMLreturn(Val_int(BinaryenCallRefAppendOperand(exp, operand)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_insert_operand_at(value _exp, value _index, value _operand) {
+  CAMLparam3(_exp, _index, _operand);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenExpressionRef operand = BinaryenExpressionRef_val(_operand);
+  BinaryenCallRefInsertOperandAt(exp, index, operand);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_call_ref_remove_operand_at(value _exp, value _index) {
+  CAMLparam2(_exp, _index);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenExpressionRef(BinaryenCallRefRemoveOperandAt(exp, index)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_is_return(value _exp) {
+  CAMLparam1(_exp);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  CAMLreturn(Val_bool(BinaryenCallRefIsReturn(exp)));
+}
+
+CAMLprim value
+caml_binaryen_call_ref_set_return(value _exp, value _isReturn) {
+  CAMLparam2(_exp, _isReturn);
+  BinaryenExpressionRef exp = BinaryenExpressionRef_val(_exp);
+  int isReturn = Bool_val(_isReturn);
+  BinaryenCallRefSetReturn(exp, isReturn);
+  CAMLreturn(Val_unit);
+}
+
 CAMLprim value
 caml_binaryen_local_set_get_value(value _exp) {
   CAMLparam1(_exp);

src/expression.js

@@ -101,6 +101,13 @@ function caml_binaryen_call_indirect__bytecode() {
   );
 }
 
+//Provides: caml_binaryen_call_ref
+//Requires: caml_jsstring_of_string
+//Requires: caml_list_to_js_array
+function caml_binaryen_call_ref(wasm_mod, target, params, typ) {
+  return wasm_mod.call_ref(target, caml_list_to_js_array(params), typ);
+}
+
 //Provides: caml_binaryen_return_call
 //Requires: caml_jsstring_of_string
 //Requires: caml_list_to_js_array
@@ -144,6 +151,13 @@ function caml_binaryen_return_call_indirect__bytecode() {
   );
 }
 
+//Provides: caml_binaryen_return_call_ref
+//Requires: caml_jsstring_of_string
+//Requires: caml_list_to_js_array
+function caml_binaryen_return_call_ref(wasm_mod, target, params, typ) {
+  return wasm_mod.return_call(target, caml_list_to_js_array(params), typ);
+}
+
 //Provides: caml_binaryen_local_get
 function caml_binaryen_local_get(wasm_mod, slot, typ) {
   return wasm_mod.local.get(slot, typ);
@@ -1295,6 +1309,68 @@ function caml_binaryen_call_indirect_set_return(exp, isReturn) {
   return Binaryen.CallIndirect.setReturn(exp, caml_js_from_bool(isReturn));
 }
 
+//Provides: caml_binaryen_call_ref_get_target
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_target(exp) {
+  return Binaryen.CallRef.getTarget(exp);
+}
+
+//Provides: caml_binaryen_call_ref_set_target
+//Requires: Binaryen
+function caml_binaryen_call_ref_set_target(exp, target) {
+  return Binaryen.CallRef.setTarget(exp, target);
+}
+
+//Provides: caml_binaryen_call_ref_get_num_operands
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_num_operands(exp) {
+  return Binaryen.CallRef.getNumOperands(exp);
+}
+
+//Provides: caml_binaryen_call_ref_get_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_get_operand_at(exp, index) {
+  return Binaryen.CallRef.getOperandAt(exp, index);
+}
+
+//Provides: caml_binaryen_call_ref_set_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_set_operand_at(exp, index, operand) {
+  return Binaryen.CallRef.setOperandAt(exp, index, operand);
+}
+
+//Provides: caml_binaryen_call_ref_append_operand
+//Requires: Binaryen
+function caml_binaryen_call_ref_append_operand(exp, operand) {
+  return Binaryen.CallRef.appendOperand(exp, operand);
+}
+
+//Provides: caml_binaryen_call_ref_insert_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_insert_operand_at(exp, index, operand) {
+  return Binaryen.CallRef.insertOperandAt(exp, index, operand);
+}
+
+//Provides: caml_binaryen_call_ref_remove_operand_at
+//Requires: Binaryen
+function caml_binaryen_call_ref_remove_operand_at(exp, index) {
+  return Binaryen.CallRef.removeOperandAt(exp, index);
+}
+
+//Provides: caml_binaryen_call_ref_is_return
+//Requires: Binaryen
+//Requires: caml_js_to_bool
+function caml_binaryen_call_ref_is_return(exp) {
+  return caml_js_to_bool(Binaryen.CallRef.isReturn(exp));
+}
+
+//Provides: caml_binaryen_call_ref_set_return
+//Requires: Binaryen
+//Requires: caml_js_from_bool
+function caml_binaryen_call_ref_set_return(exp, isReturn) {
+  return Binaryen.CallRef.setReturn(exp, caml_js_from_bool(isReturn));
+}
+
 //Provides: caml_binaryen_local_set_get_value
 //Requires: Binaryen
 function caml_binaryen_local_set_get_value(exp) {

src/expression.ml

@@ -581,6 +581,40 @@ module Call_indirect = struct
     = "caml_binaryen_call_indirect_set_return"
 end
 
+module Call_ref = struct
+  external make : Module.t -> t -> t list -> Type.t -> t
+    = "caml_binaryen_call_ref"
+  (** Module, function value, params, type. *)
+
+  external make_return : Module.t -> t -> t list -> Type.t -> t
+    = "caml_binaryen_return_call_ref"
+  (** Module, function value, params, type. *)
+
+  external get_target : t -> t = "caml_binaryen_call_ref_get_target"
+  external set_target : t -> t -> unit = "caml_binaryen_call_ref_set_target"
+
+  external get_num_operands : t -> int
+    = "caml_binaryen_call_ref_get_num_operands"
+
+  external get_operand_at : t -> int -> t
+    = "caml_binaryen_call_ref_get_operand_at"
+
+  external set_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_call_ref_set_operand_at"
+
+  external append_operand : t -> t -> int
+    = "caml_binaryen_call_ref_append_operand"
+
+  external insert_operand_at : t -> int -> t -> unit
+    = "caml_binaryen_call_ref_insert_operand_at"
+
+  external remove_operand_at : t -> int -> t
+    = "caml_binaryen_call_ref_remove_operand_at"
+
+  external is_return : t -> bool = "caml_binaryen_call_ref_is_return"
+  external set_return : t -> bool -> unit = "caml_binaryen_call_ref_set_return"
+end
+
 module Local_get = struct
   external make : Module.t -> int -> Type.t -> t = "caml_binaryen_local_get"
   (** Module, slot, type. *)

src/expression.mli

@@ -161,6 +161,21 @@ module Call_indirect : sig
   val set_return : t -> bool -> unit
 end
 
+module Call_ref : sig
+  val make : Module.t -> t -> t list -> Type.t -> t
+  val make_return : Module.t -> t -> t list -> Type.t -> t
+  val get_target : t -> t
+  val set_target : t -> t -> unit
+  val get_num_operands : t -> int
+  val get_operand_at : t -> int -> t
+  val set_operand_at : t -> int -> t -> unit
+  val append_operand : t -> t -> int
+  val insert_operand_at : t -> int -> t -> unit
+  val remove_operand_at : t -> int -> t
+  val is_return : t -> bool
+  val set_return : t -> bool -> unit
+end
+
 module Local_get : sig
   val make : Module.t -> int -> Type.t -> t
 end

test/test.ml

@@ -187,6 +187,13 @@ let _ =
       (Memory.get_segment_data wasm_mod "world")
       (Bytes.of_string "world"))
 
+(* Call_ref *)
+let _ =
+  Expression.Call_ref.make wasm_mod
+    (Expression.Ref.func wasm_mod "start"
+       (Type.from_heap_type (Heap_type.none ())))
+    [] Type.none
+
 (* Create an imported "write" function i32 (externref, i32, i32) *)
 (* Similar to the example here: https://bytecodealliance.org/articles/reference-types-in-wasmtime *)