@grain/binaryen.ml 0.35.0 → 0.36.0

binaryen-archive/src/expression.js

@@ -101,6 +101,28 @@ 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_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_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
@@ -547,6 +569,32 @@ function caml_binaryen_ref_i31(wasm_mod, typ) {
   return wasm_mod.ref.i31(typ);
 }
 
+//Provides: caml_binaryen_ref_test
+function caml_binaryen_ref_test(wasm_mod, ref, typ) {
+  return wasm_mod.ref.test(ref, typ);
+}
+
+//Provides: caml_binaryen_ref_cast
+function caml_binaryen_ref_cast(wasm_mod, ref, typ) {
+  return wasm_mod.ref.cast(ref, typ);
+}
+
+//Provides: caml_binaryen_br_on
+//Requires: caml_jsstring_of_string
+//Requires: Binaryen
+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);
+    case Binaryen.BrOnNonNull:
+      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);
+    case Binaryen.BrOnCastFail:
+      return wasm_mod.br_on_cast_fail(caml_jsstring_of_string(name), ref, typ);
+  }
+}
+
 //Provides: caml_binaryen_i31_get
 function caml_binaryen_i31_get(wasm_mod, typ, signed) {
   if (signed) {
@@ -882,14 +930,10 @@ function caml_binaryen_expression_id_array_len() {
 
 //Provides: caml_binaryen_expression_print
 //Requires: Binaryen
-//Requires: caml_sys_fds
-//Requires: caml_string_of_jsstring
-//Requires: caml_ml_output, caml_ml_string_length
+//Requires: caml_ml_output_str_stdout
 function caml_binaryen_expression_print(expr) {
   var text = Binaryen.emitText(expr);
-  var chanid = caml_sys_fds[1].chanid; // stdout
-  var s = caml_string_of_jsstring(text);
-  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+  caml_ml_output_str_stdout(text);
 }
 
 //Provides: caml_binaryen_expression_finalize
@@ -1296,6 +1340,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) {
@@ -1704,7 +1810,135 @@ function caml_binaryen_ref_func(wasm_mod, name, typ) {
 
 //Provides: caml_binaryen_ref_eq
 function caml_binaryen_ref_eq(wasm_mod, left, right) {
-  return wasm_mod.ref.func(left, right);
+  return wasm_mod.ref.eq(left, right);
+}
+
+// Struct operations
+
+//Provides: caml_binaryen_struct_new
+//Requires: caml_list_to_js_array
+function caml_binaryen_struct_new(wasm_mod, operands, type) {
+  return wasm_mod.struct.new(
+    operands ? caml_list_to_js_array(operands[1]) : null,
+    type
+  );
+}
+
+//Provides: caml_binaryen_struct_get
+//Requires: caml_js_from_bool
+function caml_binaryen_struct_get(wasm_mod, index, ref, type, signed) {
+  return wasm_mod.struct.get(index, ref, type, caml_js_from_bool(signed));
+}
+
+//Provides: caml_binaryen_struct_set
+function caml_binaryen_struct_set(wasm_mod, index, ref, value) {
+  return wasm_mod.struct.set(index, ref, value);
+}
+
+// Array operations
+
+//Provides: caml_binaryen_array_new
+function caml_binaryen_array_new(wasm_mod, type, size, init) {
+  return wasm_mod.array.new(type, size, init);
+}
+
+//Provides: caml_binaryen_array_new_data
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_new_data(wasm_mod, type, name, offset, size) {
+  return wasm_mod.array.new_data(
+    type,
+    caml_jsstring_of_string(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) {
+  return wasm_mod.array.new_fixed(type, caml_list_to_js_array(values));
+}
+
+//Provides: caml_binaryen_array_get
+//Requires: caml_js_from_bool
+function caml_binaryen_array_get(wasm_mod, ref, index, type, signed) {
+  return wasm_mod.array.get(ref, index, type, caml_js_from_bool(signed));
+}
+
+//Provides: caml_binaryen_array_set
+function caml_binaryen_array_set(wasm_mod, ref, index, value) {
+  return wasm_mod.array.set(ref, index, value);
+}
+
+//Provides: caml_binaryen_array_len
+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,
+  destRef,
+  destIndex,
+  srcRef,
+  srcIndex,
+  length
+) {
+  return wasm_mod.array.copy(destRef, destIndex, srcRef, srcIndex, length);
+}
+
+//Provides: caml_binaryen_array_init_data
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_init_data(wasm_mod, name, ref, index, offset, size) {
+  return wasm_mod.array.init_data(caml_jsstring_of_string(name), ref, index, offset, size);
+}
+
+//Provides: caml_binaryen_array_init_data__bytecode
+//Requires: caml_binaryen_array_init_data
+function caml_binaryen_array_init_data__bytecode() {
+  return caml_binaryen_array_init_data(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
+//Provides: caml_binaryen_array_init_elem
+//Requires: caml_jsstring_of_string
+function caml_binaryen_array_init_elem(wasm_mod, name, ref, index, offset, size) {
+  return wasm_mod.array.init_elem(caml_jsstring_of_string(name), ref, index, offset, size);
+}
+
+//Provides: caml_binaryen_array_copy__bytecode
+//Requires: caml_binaryen_array_copy
+function caml_binaryen_array_copy__bytecode() {
+  return caml_binaryen_array_copy(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
 }
 
 // Exception handling operations

binaryen-archive/src/expression.ml

@@ -583,6 +583,44 @@ 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. *)
+  let make mod_ target params typ = make mod_ target params typ
+
+  external make_return : Module.t -> t -> t list -> Type.t -> t
+    = "caml_binaryen_return_call_ref"
+
+  (** Module, function value, params, type. *)
+  let make_return mod_ target params typ = make_return mod_ target params typ
+
+  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. *)
@@ -830,6 +868,74 @@ module Ref = struct
 
   external eq : Module.t -> t -> t -> t = "caml_binaryen_ref_eq"
   (** Module, left, right *)
+
+  external test : Module.t -> t -> Type.t -> t = "caml_binaryen_ref_test"
+  (** Module, value, type *)
+
+  external cast : Module.t -> t -> Type.t -> t = "caml_binaryen_ref_cast"
+  (** Module, value, type *)
+end
+
+module BrOn = struct
+  external make : Module.t -> Op.t -> string -> t -> Type.t -> t
+    = "caml_binaryen_br_on"
+  (** Module, op, label, value, type *)
+end
+
+module Struct = struct
+  external new_ : Module.t -> t list option -> Heap_type.t -> t
+    = "caml_binaryen_struct_new"
+  (** Mdoule, operands, type *)
+
+  external get : Module.t -> int -> t -> Type.t -> bool -> t
+    = "caml_binaryen_struct_get"
+  (** Module, index, struct, type, signed *)
+
+  external set : Module.t -> int -> t -> t -> t = "caml_binaryen_struct_set"
+  (** Module, index, struct, value *)
+end
+
+module Array = struct
+  external new_ : Module.t -> Heap_type.t -> t -> t -> t
+    = "caml_binaryen_array_new"
+  (** Module, type, size, init *)
+
+  external new_data : Module.t -> Heap_type.t -> string -> t -> t -> t
+    = "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 *)
+
+  external get : Module.t -> t -> t -> Type.t -> bool -> t
+    = "caml_binaryen_array_get"
+  (** Module, array, index, type, signed *)
+
+  external set : Module.t -> t -> t -> t -> t = "caml_binaryen_array_set"
+  (** Module, array, index, value *)
+
+  external len : Module.t -> t -> t = "caml_binaryen_array_len"
+  (** Module, array *)
+
+  external fill : Module.t -> t -> t -> t -> t -> t = "caml_binaryen_array_fill"
+  (** Module, array, index, value, offset *)
+
+  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 *)
+
+  external init_data : Module.t -> string -> t -> t -> t -> t -> t
+    = "caml_binaryen_array_init_data__bytecode" "caml_binaryen_array_init_data"
+  (** Module, name, ref, index, offset, size *)
+
+  external init_elem : Module.t -> string -> t -> t -> t -> t -> t
+    = "caml_binaryen_array_init_elem__bytecode" "caml_binaryen_array_init_elem"
+  (** Module, seg, ref, index, offset, size *)
 end
 
 (** Bindings for `try_table` instruction. *)

binaryen-archive/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
@@ -348,6 +363,63 @@ module Ref : sig
 
   val eq : Module.t -> t -> t -> t
   (** Module, left, right *)
+
+  val test : Module.t -> t -> Type.t -> t
+  (** Module, value, type *)
+
+  val cast : Module.t -> t -> Type.t -> t
+  (** Module, value, type *)
+end
+
+module BrOn : sig
+  val make : Module.t -> Op.t -> string -> t -> Type.t -> t
+  (** Module, op, label, value, type *)
+end
+
+module Struct : sig
+  val new_ : Module.t -> t list option -> Heap_type.t -> t
+  (** Mdoule, operands, type *)
+
+  val get : Module.t -> int -> t -> Type.t -> bool -> t
+  (** Module, index, struct, type, signed *)
+
+  val set : Module.t -> int -> t -> t -> t
+  (** Module, index, struct, value *)
+end
+
+module Array : sig
+  val new_ : Module.t -> Heap_type.t -> t -> t -> t
+  (** Module, type, size, init *)
+
+  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 *)
+
+  val get : Module.t -> t -> t -> Type.t -> bool -> t
+  (** Module, array, index, type, signed *)
+
+  val set : Module.t -> t -> t -> t -> t
+  (** Module, array, index, value *)
+
+  val len : Module.t -> t -> t
+  (** Module, array *)
+
+  val fill : Module.t -> t -> t -> t -> t -> t
+  (** Module, array, index, value, offset *)
+
+  val copy : Module.t -> t -> t -> t -> t -> t -> t
+  (** Module, dest, dest index, src, src index, length *)
+
+  val init_data : Module.t -> string -> t -> t -> t -> t -> t
+  (** Module, name, ref, index, offset, size *)
+
+  val init_elem : Module.t -> string -> t -> t -> t -> t -> t
+  (** Module, seg, ref, index, offset, size *)
 end
 
 (** Bindings for `try` instruction. *)

binaryen-archive/src/heap_type.c

@@ -148,3 +148,22 @@ caml_binaryen_type_get_heap_type(value _ty) {
   BinaryenHeapType heapTy = BinaryenTypeGetHeapType(ty);
   CAMLreturn(alloc_BinaryenHeapType(heapTy));
 }
+
+CAMLprim value caml_binaryen_module_set_type_name(value _module, value _heapType, value _name) {
+  CAMLparam3(_module, _heapType, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  const char* name = String_val(_name);
+  BinaryenModuleSetTypeName(module, heapType, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value caml_binaryen_module_set_field_name(value _module, value _heapType, value _index, value _name) {
+  CAMLparam4(_module, _heapType, _index, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  const char* name = String_val(_name);
+  BinaryenModuleSetFieldName(module, heapType, index, name);
+  CAMLreturn(Val_unit);
+}

binaryen-archive/src/heap_type.js

@@ -111,3 +111,15 @@ function caml_binaryen_heap_type_is_sub_type(left, right) {
 function caml_binaryen_type_get_heap_type(typ) {
   return Binaryen._BinaryenTypeGetHeapType(typ);
 }
+
+//Provides: caml_binaryen_module_set_type_name
+//Requires: caml_jsstring_of_string
+function caml_binaryen_module_set_type_name(wasm_mod, heapType, name) {
+  wasm_mod.setTypeName(heapType, caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_module_set_field_name
+//Requires: caml_jsstring_of_string
+function caml_binaryen_module_set_field_name(wasm_mod, heapType, index, name) {
+  wasm_mod.setFieldName(heapType, index, caml_jsstring_of_string(name));
+}

binaryen-archive/src/heap_type.ml

@@ -17,4 +17,13 @@ external is_struct : t -> bool = "caml_binaryen_heap_type_is_struct"
 external is_array : t -> bool = "caml_binaryen_heap_type_is_array"
 external is_bottom : t -> bool = "caml_binaryen_heap_type_is_bottom"
 external get_bottom : t -> t = "caml_binaryen_heap_type_get_bottom"
-external is_sub_type : t -> bool = "caml_binaryen_heap_type_is_sub_type"
+external is_sub_type : t -> t -> bool = "caml_binaryen_heap_type_is_sub_type"
+
+external set_type_name : Module.t -> t -> string -> unit
+  = "caml_binaryen_module_set_type_name"
+(** Sets the textual name of a compound `heapType`. Has no effect if the type
+    already has a canonical name. *)
+
+external set_field_name : Module.t -> t -> int -> string -> unit
+  = "caml_binaryen_module_set_field_name"
+(** Sets the field name of a struct `heapType` at index `index`. *)

binaryen-archive/src/heap_type.mli

@@ -17,4 +17,11 @@ val is_struct : t -> bool
 val is_array : t -> bool
 val is_bottom : t -> bool
 val get_bottom : t -> t
-val is_sub_type : t -> bool
+val is_sub_type : t -> t -> bool
+
+val set_type_name : Module.t -> t -> string -> unit
+(** Sets the textual name of a compound `heapType`. Has no effect if the type
+    already has a canonical name. *)
+
+val set_field_name : Module.t -> t -> int -> string -> unit
+(** Sets the field name of a struct `heapType` at index `index`. *)

binaryen-archive/src/memory.c

@@ -121,7 +121,12 @@ caml_binaryen_get_memory_segment_byte_offset(value _module, value _name) {
   CAMLparam2(_module, _name);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   char* name = Safe_String_val(_name);
-  CAMLreturn(Val_int(BinaryenGetMemorySegmentByteOffset(module, name)));
+  if (BinaryenGetMemorySegmentPassive(module, name)) {
+    CAMLreturn(Val_none);
+  } else {
+    int offset = BinaryenGetMemorySegmentByteOffset(module, name);
+    CAMLreturn(caml_alloc_some(Val_int(offset)));
+  }
 }
 
 CAMLprim value

binaryen-archive/src/memory.js

@@ -112,10 +112,10 @@ function caml_binaryen_get_num_memory_segments(wasm_mod) {
 }
 
 //Provides: caml_binaryen_get_memory_segment_byte_offset
-//Requires: caml_jsstring_of_string
+//Requires: caml_jsstring_of_string, to_option
 function caml_binaryen_get_memory_segment_byte_offset(wasm_mod, name) {
   var info = wasm_mod.getMemorySegmentInfo(caml_jsstring_of_string(name));
-  return info.offset;
+  return to_option(info.offset);
 }
 
 //Provides: caml_binaryen_get_memory_segment_passive

binaryen-archive/src/memory.ml

@@ -71,7 +71,7 @@ let unlimited = -1
 external get_num_segments : Module.t -> int
   = "caml_binaryen_get_num_memory_segments"
 
-external get_segment_byte_offset : Module.t -> string -> int
+external get_segment_byte_offset : Module.t -> string -> int option
   = "caml_binaryen_get_memory_segment_byte_offset"
 
 external get_segment_passive : Module.t -> string -> bool

binaryen-archive/src/memory.mli

@@ -20,6 +20,6 @@ val is_shared : Module.t -> string -> bool
 val is_64 : Module.t -> string -> bool
 val unlimited : int
 val get_num_segments : Module.t -> int
-val get_segment_byte_offset : Module.t -> string -> int
+val get_segment_byte_offset : Module.t -> string -> int option
 val get_segment_passive : Module.t -> string -> bool
 val get_segment_data : Module.t -> string -> bytes

binaryen-archive/src/module.js

@@ -17,36 +17,24 @@ function caml_binaryen_module_parse(text) {
 }
 
 //Provides: caml_binaryen_module_print
-//Requires: caml_sys_fds
-//Requires: caml_string_of_jsstring
-//Requires: caml_ml_output, caml_ml_string_length
+//Requires: caml_ml_output_str_stdout
 function caml_binaryen_module_print(wasm_mod) {
   var text = wasm_mod.emitText();
-  var chanid = caml_sys_fds[1].chanid; // stdout
-  var s = caml_string_of_jsstring(text);
-  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+  caml_ml_output_str_stdout(text);
 }
 
 //Provides: caml_binaryen_module_print_asmjs
-//Requires: caml_sys_fds
-//Requires: caml_string_of_jsstring
-//Requires: caml_ml_output, caml_ml_string_length
+//Requires: caml_ml_output_str_stdout
 function caml_binaryen_module_print_asmjs(wasm_mod) {
   var asm = wasm_mod.emitAsmjs();
-  var chanid = caml_sys_fds[1].chanid; // stdout
-  var s = caml_string_of_jsstring(asm);
-  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+  caml_ml_output_str_stdout(asm);
 }
 
 //Provides: caml_binaryen_module_print_stack_ir
-//Requires: caml_sys_fds
-//Requires: caml_string_of_jsstring
-//Requires: caml_ml_output, caml_ml_string_length
+//Requires: caml_ml_output_str_stdout
 function caml_binaryen_module_print_stack_ir(wasm_mod) {
   var stackir = wasm_mod.emitStackIR();
-  var chanid = caml_sys_fds[1].chanid; // stdout
-  var s = caml_string_of_jsstring(stackir);
-  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+  caml_ml_output_str_stdout(stackir);
 }
 
 //Provides: caml_binaryen_module_validate
@@ -132,6 +120,5 @@ function caml_binaryen_add_custom_section(wasm_mod, name, contents) {
 
 //Provides: caml_binaryen_module_update_maps
 function caml_binaryen_module_update_maps(wasm_mod) {
-  // The JS version doesn't expose `update_maps`
-  return;
+  return wasm_mod.updateMaps();
 }

binaryen-archive/src/module.ml

@@ -98,6 +98,10 @@ module Feature = struct
 
   let call_indirect_overlong = call_indirect_overlong ()
 
+  external relaxed_atomics : unit -> t = "caml_binaryen_feature_relaxed_atomics"
+
+  let relaxed_atomics = relaxed_atomics ()
+
   external all : unit -> t = "caml_binaryen_feature_all"
 
   let all = all ()

binaryen-archive/src/module.mli

@@ -25,6 +25,7 @@ module Feature : sig
   val fp16 : t
   val bulk_memory_opt : t
   val call_indirect_overlong : t
+  val relaxed_atomics : t
   val all : t
 end