@grain/binaryen.ml 0.18.0 → 0.20.0

binaryen-archive/src/binaryen_stubs_memory.js

@@ -1,15 +1,26 @@
 //Provides: caml_binaryen_set_memory
 //Requires: caml_list_to_js_array, caml_convert_bytes_to_array
 //Requires: caml_jsstring_of_string, caml_js_from_bool
-function caml_binaryen_set_memory(wasm_mod, initial, maximum, exportName, segments, segmentPassives, segmentOffsets, segmentSizes, shared) {
+function caml_binaryen_set_memory(
+  wasm_mod,
+  initial,
+  maximum,
+  exportName,
+  segments,
+  segmentPassives,
+  segmentOffsets,
+  segmentSizes,
+  shared,
+  memoryName
+) {
   var passives = caml_list_to_js_array(segmentPassives);
   var offsets = caml_list_to_js_array(segmentOffsets);
   var segs = caml_list_to_js_array(segments).map(function (segment, idx) {
     return {
       data: caml_convert_bytes_to_array(segment),
       passive: caml_js_from_bool(passives[idx]),
-      offset: offsets[idx]
-    }
+      offset: offsets[idx],
+    };
   });
 
   return wasm_mod.setMemory(
@@ -17,11 +28,90 @@ function caml_binaryen_set_memory(wasm_mod, initial, maximum, exportName, segmen
     maximum,
     caml_jsstring_of_string(exportName),
     segs,
-    caml_js_from_bool(shared)
+    caml_js_from_bool(shared),
+    caml_jsstring_of_string(memoryName)
   );
 }
 //Provides: caml_binaryen_set_memory__bytecode
 //Requires: caml_binaryen_set_memory
 function caml_binaryen_set_memory__bytecode() {
-  return caml_binaryen_set_memory(arguments[0], arguments[1], arguments[2], arguments[3], arguments[4], arguments[5], arguments[6], arguments[7], arguments[8]);
+  return caml_binaryen_set_memory(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5],
+    arguments[6],
+    arguments[7],
+    arguments[8],
+    arguments[9]
+  );
+}
+
+//Provides: caml_binaryen_has_memory
+//Requires: caml_js_to_bool
+function caml_binaryen_has_memory(mod) {
+  return caml_js_to_bool(mod.hasMemory());
+}
+
+//Provides: caml_binaryen_memory_get_initial
+//Requires: caml_jsstring_of_string
+function caml_binaryen_memory_get_initial(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
+  return memory_info.initial;
+}
+
+//Provides: caml_binaryen_memory_has_max
+//Requires: caml_js_to_bool, caml_jsstring_of_string
+function caml_binaryen_memory_has_max(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
+  if (memory_info.max != null) {
+    return caml_js_to_bool(true);
+  } else {
+    return caml_js_to_bool(false);
+  }
+}
+
+//Provides: caml_binaryen_memory_get_max
+//Requires: caml_jsstring_of_string
+function caml_binaryen_memory_get_max(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
+  if (memory_info.max != null) {
+    return memory_info.max;
+  } else {
+    // This ensures that our return is equal to Memory.unlimited
+    return -1;
+  }
+}
+
+//Provides: caml_binaryen_memory_is_shared
+//Requires: caml_js_to_bool, caml_jsstring_of_string
+function caml_binaryen_memory_is_shared(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
+  return caml_js_to_bool(memory_info.shared);
+}
+
+//Provides: caml_binaryen_get_num_memory_segments
+function caml_binaryen_get_num_memory_segments(wasm_mod) {
+  return wasm_mod.getNumMemorySegments();
+}
+
+//Provides: caml_binaryen_get_memory_segment_byte_offset
+function caml_binaryen_get_memory_segment_byte_offset(wasm_mod, idx) {
+  var info = wasm_mod.getMemorySegmentInfoByIndex(idx);
+  return info.offset;
+}
+
+//Provides: caml_binaryen_get_memory_segment_passive
+function caml_binaryen_get_memory_segment_passive(wasm_mod, idx) {
+  var info = wasm_mod.getMemorySegmentInfoByIndex(idx);
+  return info.passive;
+}
+
+//Provides: caml_binaryen_get_memory_segment_data
+//Requires: caml_bytes_of_array
+function caml_binaryen_get_memory_segment_data(wasm_mod, idx) {
+  var info = wasm_mod.getMemorySegmentInfoByIndex(idx);
+  return caml_bytes_of_array(info.data);
 }

binaryen-archive/src/binaryen_stubs_modules.c

@@ -52,6 +52,14 @@ caml_binaryen_module_print_asmjs(value module) {
   CAMLreturn(Val_unit);
 }
 
+CAMLprim value
+caml_binaryen_module_print_stack_ir(value module, value _optimize) {
+  CAMLparam2(module, _optimize);
+  bool optimize = Bool_val(_optimize);
+  BinaryenModulePrintStackIR(BinaryenModuleRef_val(module), optimize);
+  CAMLreturn(Val_unit);
+}
+
 CAMLprim value
 caml_binaryen_module_validate(value module) {
   CAMLparam1(module);
@@ -125,6 +133,20 @@ caml_binaryen_module_write_text(value _module) {
   CAMLreturn(text);
 }
 
+// There is something weird with this function that causes a bunch of newlines to
+// be printed on stdout when calling it. Not sure if that's a bug in Binaryen.
+CAMLprim value
+caml_binaryen_module_write_stack_ir(value _module, value _optimize) {
+  CAMLparam2(_module, _optimize);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  bool optimize = Bool_val(_optimize);
+  char* result = BinaryenModuleAllocateAndWriteStackIR(module, optimize);
+  CAMLlocal1(text);
+  text = caml_copy_string(result);
+  free(result);
+  CAMLreturn(text);
+}
+
 CAMLprim value
 caml_binaryen_module_read(value _bytes) {
   CAMLparam1(_bytes);

binaryen-archive/src/binaryen_stubs_modules.js

@@ -36,6 +36,16 @@ function caml_binaryen_module_print_asmjs(wasm_mod) {
   caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
 }
 
+//Provides: caml_binaryen_module_print_stack_ir
+//Requires: caml_string_of_jsstring, caml_js_from_bool
+//Requires: caml_ml_output, caml_ml_string_length
+function caml_binaryen_module_print_stack_ir(wasm_mod, optimize) {
+  var stackir = wasm_mod.emitStackIR(caml_js_from_bool(optimize));
+  var chanid = 1; // stdout
+  var s = caml_string_of_jsstring(stackir);
+  caml_ml_output(chanid, s, 0, caml_ml_string_length(s));
+}
+
 //Provides: caml_binaryen_module_validate
 function caml_binaryen_module_validate(wasm_mod) {
   return wasm_mod.validate();
@@ -82,6 +92,13 @@ function caml_binaryen_module_write_text(wasm_mod) {
   return caml_string_of_jsstring(text);
 }
 
+//Provides: caml_binaryen_module_write_stack_ir
+//Requires: caml_string_of_jsstring, caml_js_from_bool
+function caml_binaryen_module_write_stack_ir(wasm_mod, optimize) {
+  var text = wasm_mod.emitStackIR(caml_js_from_bool(optimize));
+  return caml_string_of_jsstring(text);
+}
+
 //Provides: caml_binaryen_module_read
 //Requires: Binaryen
 //Requires: caml_array_of_bytes

binaryen-archive/src/binaryen_stubs_packed_types.c

@@ -0,0 +1,26 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+
+CAMLprim value
+caml_binaryen_packed_type_not_packed(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenPackedTypeNotPacked()));
+}
+
+CAMLprim value
+caml_binaryen_packed_type_int8(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenPackedTypeInt8()));
+}
+
+CAMLprim value
+caml_binaryen_packed_type_int16(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenPackedTypeInt16()));
+}

binaryen-archive/src/binaryen_stubs_packed_types.js

@@ -0,0 +1,17 @@
+//Provides: caml_binaryen_packed_type_not_packed
+//Requires: Binaryen
+function caml_binaryen_packed_type_not_packed() {
+  return Binaryen._BinaryenPackedTypeNotPacked();
+}
+
+//Provides: caml_binaryen_packed_type_int8
+//Requires: Binaryen
+function caml_binaryen_packed_type_int8() {
+  return Binaryen._BinaryenPackedTypeInt8();
+}
+
+//Provides: caml_binaryen_packed_type_int16
+//Requires: Binaryen
+function caml_binaryen_packed_type_int16() {
+  return Binaryen._BinaryenPackedTypeInt16();
+}

binaryen-archive/src/binaryen_stubs_type_system.c

@@ -0,0 +1,40 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+
+CAMLprim value
+caml_binaryen_type_system_equirecursive(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenTypeSystemEquirecursive()));
+}
+
+CAMLprim value
+caml_binaryen_type_system_nominal(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenTypeSystemNominal()));
+}
+
+CAMLprim value
+caml_binaryen_type_system_isorecursive(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenTypeSystemIsorecursive()));
+}
+
+CAMLprim value
+caml_binaryen_get_type_system(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenGetTypeSystem()));
+}
+
+CAMLprim value
+caml_binaryen_set_type_system(value _typeSystem) {
+  CAMLparam1(_typeSystem);
+  BinaryenTypeSystem typeSystem = Int_val(_typeSystem);
+  BinaryenSetTypeSystem(typeSystem);
+  CAMLreturn(Val_unit);
+}

binaryen-archive/src/binaryen_stubs_type_system.js

@@ -0,0 +1,29 @@
+//Provides: caml_binaryen_type_system_equirecursive
+//Requires: Binaryen
+function caml_binaryen_type_system_equirecursive() {
+  return Binaryen._BinaryenTypeSystemEquirecursive();
+}
+
+//Provides: caml_binaryen_type_system_nominal
+//Requires: Binaryen
+function caml_binaryen_type_system_nominal() {
+  return Binaryen._BinaryenTypeSystemNominal();
+}
+
+//Provides: caml_binaryen_type_system_isorecursive
+//Requires: Binaryen
+function caml_binaryen_type_system_isorecursive() {
+  return Binaryen._BinaryenTypeSystemIsorecursive();
+}
+
+//Provides: caml_binaryen_get_type_system
+//Requires: Binaryen
+function caml_binaryen_get_type_system() {
+  return Binaryen._BinaryenGetTypeSystem();
+}
+
+//Provides: caml_binaryen_set_type_system
+//Requires: Binaryen
+function caml_binaryen_set_type_system(typeSystem) {
+  Binaryen._BinaryenSetTypeSystem(typeSystem);
+}

binaryen-archive/src/binaryen_stubs_types.c

@@ -93,6 +93,34 @@ caml_binaryen_type_dataref(value unit) {
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
+CAMLprim value
+caml_binaryen_type_stringref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeStringref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_stringview_wtf8(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeStringviewWTF8();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_stringview_wtf16(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeStringviewWTF16();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_stringview_iter(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeStringviewIter();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
 CAMLprim value
 caml_binaryen_type_unreachable(value unit) {
   CAMLparam1(unit);
@@ -136,3 +164,19 @@ caml_binaryen_type_expand(value _ty) {
 
   CAMLreturn(typeArray);
 }
+
+CAMLprim value
+caml_binaryen_type_is_nullable(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenType ty = BinaryenType_val(_ty);
+  CAMLreturn(Val_bool(BinaryenTypeIsNullable(ty)));
+}
+
+CAMLprim value
+caml_binaryen_type_from_heap_type(value _ty, value _nullable) {
+  CAMLparam2(_ty, _nullable);
+  BinaryenHeapType heapTy = BinaryenHeapType_val(_ty);
+  bool nullable = Bool_val(_nullable);
+  BinaryenType ty = BinaryenTypeFromHeapType(heapTy, nullable);
+  CAMLreturn(alloc_BinaryenType(ty));
+}

binaryen-archive/src/binaryen_stubs_types.js

@@ -64,6 +64,30 @@ function caml_binaryen_type_dataref() {
   return Binaryen.dataref;
 }
 
+//Provides: caml_binaryen_type_stringref
+//Requires: Binaryen
+function caml_binaryen_type_stringref() {
+  return Binaryen.stringref;
+}
+
+//Provides: caml_binaryen_type_stringview_wtf8
+//Requires: Binaryen
+function caml_binaryen_type_stringview_wtf8() {
+  return Binaryen.stringview_wtf8;
+}
+
+//Provides: caml_binaryen_type_stringview_wtf16
+//Requires: Binaryen
+function caml_binaryen_type_stringview_wtf16() {
+  return Binaryen.stringview_wtf16;
+}
+
+//Provides: caml_binaryen_type_stringview_iter
+//Requires: Binaryen
+function caml_binaryen_type_stringview_iter() {
+  return Binaryen.stringview_iter;
+}
+
 //Provides: caml_binaryen_type_unreachable
 //Requires: Binaryen
 function caml_binaryen_type_unreachable() {
@@ -89,3 +113,15 @@ function caml_binaryen_type_create(typs) {
 function caml_binaryen_type_expand(typ) {
   return caml_js_to_array(Binaryen.expandType(typ));
 }
+
+//Provides: caml_binaryen_type_is_nullable
+//Requires: Binaryen
+function caml_binaryen_type_is_nullable(typ) {
+  return Binaryen._BinaryenTypeIsNullable(typ);
+}
+
+//Provides: caml_binaryen_type_from_heap_type
+//Requires: Binaryen
+function caml_binaryen_type_from_heap_type(typ, nullable) {
+  return Binaryen._BinaryenTypeFromHeapType(typ, nullable);
+}

binaryen-archive/src/dune

@@ -4,17 +4,40 @@
  (libraries libbinaryen.c)
  (foreign_stubs
   (language c)
-  (names binaryen_stubs_types binaryen_stubs_ops binaryen_stubs_literals
-    binaryen_stubs_expressions binaryen_stubs_functions
-    binaryen_stubs_imports binaryen_stubs_exports binaryen_stubs_globals
-    binaryen_stubs_tables binaryen_stubs_memory binaryen_stubs_features
-    binaryen_stubs_modules binaryen_stubs_settings ocaml_helpers)
+  (names
+   binaryen_stubs_types
+   binaryen_stubs_ops
+   binaryen_stubs_literals
+   binaryen_stubs_expressions
+   binaryen_stubs_functions
+   binaryen_stubs_imports
+   binaryen_stubs_exports
+   binaryen_stubs_globals
+   binaryen_stubs_tables
+   binaryen_stubs_memory
+   binaryen_stubs_features
+   binaryen_stubs_modules
+   binaryen_stubs_settings
+   binaryen_stubs_packed_types
+   binaryen_stubs_heap_types
+   binaryen_stubs_type_system
+   ocaml_helpers)
   (flags :standard -O2 -Wall -Wextra))
  (js_of_ocaml
-  (javascript_files binaryen_stubs_types.js binaryen_stubs_ops.js
-    binaryen_stubs_literals.js binaryen_stubs_expressions.js
-    binaryen_stubs_functions.js binaryen_stubs_imports.js
-    binaryen_stubs_exports.js binaryen_stubs_globals.js
-    binaryen_stubs_tables.js binaryen_stubs_memory.js
-    binaryen_stubs_features.js binaryen_stubs_modules.js
-    binaryen_stubs_settings.js)))
+  (javascript_files
+   binaryen_stubs_types.js
+   binaryen_stubs_ops.js
+   binaryen_stubs_literals.js
+   binaryen_stubs_expressions.js
+   binaryen_stubs_functions.js
+   binaryen_stubs_imports.js
+   binaryen_stubs_exports.js
+   binaryen_stubs_globals.js
+   binaryen_stubs_tables.js
+   binaryen_stubs_memory.js
+   binaryen_stubs_features.js
+   binaryen_stubs_modules.js
+   binaryen_stubs_settings.js
+   binaryen_stubs_packed_types.js
+   binaryen_stubs_heap_types.js
+   binaryen_stubs_type_system.js)))

binaryen-archive/src/expression.ml

@@ -57,8 +57,6 @@ type kind =
   | RefTest
   | RefCast
   | BrOn
-  | RttCanon
-  | RttSub
   | StructNew
   | StructGet
   | StructSet
@@ -310,14 +308,6 @@ external id_br_on : unit -> int = "caml_binaryen_expression_id_br_on"
 
 let id_br_on = id_br_on ()
 
-external id_rtt_canon : unit -> int = "caml_binaryen_expression_id_rtt_canon"
-
-let id_rtt_canon = id_rtt_canon ()
-
-external id_rtt_sub : unit -> int = "caml_binaryen_expression_id_rtt_sub"
-
-let id_rtt_sub = id_rtt_sub ()
-
 external id_struct_new : unit -> int = "caml_binaryen_expression_id_struct_new"
 
 let id_struct_new = id_struct_new ()
@@ -409,8 +399,6 @@ let get_kind expr =
   | n when n = id_ref_test -> RefTest
   | n when n = id_ref_cast -> RefCast
   | n when n = id_br_on -> BrOn
-  | n when n = id_rtt_canon -> RttCanon
-  | n when n = id_rtt_sub -> RttSub
   | n when n = id_struct_new -> StructNew
   | n when n = id_struct_get -> StructGet
   | n when n = id_struct_set -> StructSet
@@ -630,10 +618,11 @@ module Global_set = struct
 end
 
 module Load = struct
-  external make : Module.t -> int -> bool -> int -> int -> Type.t -> t -> t
+  external make :
+    Module.t -> int -> bool -> int -> int -> Type.t -> t -> string -> t
     = "caml_binaryen_load__bytecode" "caml_binaryen_load"
 
-  (** Module, num_bytes, ?signed, offset, align, type, ptr. *)
+  (** Module, num_bytes, ?signed, offset, align, type, ptr, memory_name *)
   let make wasm_mod bytes ?(signed = false) offset align ty ptr =
     make wasm_mod bytes signed offset align ty ptr
 
@@ -642,9 +631,10 @@ module Load = struct
 end
 
 module Store = struct
-  external make : Module.t -> int -> int -> int -> t -> t -> Type.t -> t
+  external make :
+    Module.t -> int -> int -> int -> t -> t -> Type.t -> string -> t
     = "caml_binaryen_store__bytecode" "caml_binaryen_store"
-  (** Module, num_bytes, offset, align, ptr, value, type. *)
+  (** Module, num_bytes, offset, align, ptr, value, type, memory_name *)
 
   external get_ptr : t -> t = "caml_binaryen_store_get_ptr"
   external set_ptr : t -> t -> unit = "caml_binaryen_store_set_ptr"
@@ -698,18 +688,23 @@ module Return = struct
 end
 
 module Memory_size = struct
-  external make : Module.t -> t = "caml_binaryen_memory_size"
+  external make : Module.t -> string -> bool -> t = "caml_binaryen_memory_size"
+  (** Module, memory_name, memory_is_64 *)
 end
 
 module Memory_grow = struct
-  external make : Module.t -> t -> t = "caml_binaryen_memory_grow"
+  external make : Module.t -> t -> string -> bool -> t
+    = "caml_binaryen_memory_grow"
+  (** Module, delta, memory_name, memory_is_64 *)
+
   external get_delta : t -> t = "caml_binaryen_memory_grow_get_delta"
   external set_delta : t -> t -> unit = "caml_binaryen_memory_grow_set_delta"
 end
 
 module Memory_init = struct
-  external make : Module.t -> int -> t -> t -> t = "caml_binaryen_memory_init"
-  (** Module, segment, destination, offset, size. *)
+  external make : Module.t -> int -> t -> t -> t -> string -> t
+    = "caml_binaryen_memory_init__bytecode" "caml_binaryen_memory_init"
+  (** Module, segment, destination, offset, size, memory_name *)
 
   external get_segment : t -> int = "caml_binaryen_memory_init_get_segment"
 
@@ -735,8 +730,9 @@ module Data_drop = struct
 end
 
 module Memory_copy = struct
-  external make : Module.t -> t -> t -> t -> t = "caml_binaryen_memory_copy"
-  (** Module, destination, source, size. *)
+  external make : Module.t -> t -> t -> t -> string -> string -> t
+    = "caml_binaryen_memory_copy__bytecode" "caml_binaryen_memory_copy"
+  (** Module, destination, source, size, dest_memory, source_memory *)
 
   external get_dest : t -> t = "caml_binaryen_memory_copy_get_dest"
   external set_dest : t -> t -> unit = "caml_binaryen_memory_copy_set_dest"
@@ -747,8 +743,9 @@ module Memory_copy = struct
 end
 
 module Memory_fill = struct
-  external make : Module.t -> t -> t -> t -> t = "caml_binaryen_memory_fill"
-  (** Module, destination, value, size. *)
+  external make : Module.t -> t -> t -> t -> string -> t
+    = "caml_binaryen_memory_fill"
+  (** Module, destination, value, size, memory_name *)
 
   external get_dest : t -> t = "caml_binaryen_memory_fill_get_dest"
   external set_dest : t -> t -> unit = "caml_binaryen_memory_fill_set_dest"

binaryen-archive/src/expression.mli

@@ -57,8 +57,6 @@ type kind =
   | RefTest
   | RefCast
   | BrOn
-  | RttCanon
-  | RttSub
   | StructNew
   | StructGet
   | StructSet
@@ -192,13 +190,15 @@ module Global_set : sig
 end
 
 module Load : sig
-  val make : Module.t -> int -> ?signed:bool -> int -> int -> Type.t -> t -> t
+  val make :
+    Module.t -> int -> ?signed:bool -> int -> int -> Type.t -> t -> string -> t
+
   val get_ptr : t -> t
   val set_ptr : t -> t -> unit
 end
 
 module Store : sig
-  val make : Module.t -> int -> int -> int -> t -> t -> Type.t -> t
+  val make : Module.t -> int -> int -> int -> t -> t -> Type.t -> string -> t
   val get_ptr : t -> t
   val set_ptr : t -> t -> unit
   val get_value : t -> t
@@ -246,17 +246,17 @@ module Return : sig
 end
 
 module Memory_size : sig
-  val make : Module.t -> t
+  val make : Module.t -> string -> bool -> t
 end
 
 module Memory_grow : sig
-  val make : Module.t -> t -> t
+  val make : Module.t -> t -> string -> bool -> t
   val get_delta : t -> t
   val set_delta : t -> t -> unit
 end
 
 module Memory_init : sig
-  val make : Module.t -> int -> t -> t -> t
+  val make : Module.t -> int -> t -> t -> t -> string -> t
   val get_segment : t -> int
   val set_segment : t -> int -> unit
   val get_dest : t -> t
@@ -274,7 +274,7 @@ module Data_drop : sig
 end
 
 module Memory_copy : sig
-  val make : Module.t -> t -> t -> t -> t
+  val make : Module.t -> t -> t -> t -> string -> string -> t
   val get_dest : t -> t
   val set_dest : t -> t -> unit
   val get_source : t -> t
@@ -284,7 +284,7 @@ module Memory_copy : sig
 end
 
 module Memory_fill : sig
-  val make : Module.t -> t -> t -> t -> t
+  val make : Module.t -> t -> t -> t -> string -> t
   val get_dest : t -> t
   val set_dest : t -> t -> unit
   val get_value : t -> t

binaryen-archive/src/heap_type.ml

@@ -0,0 +1,15 @@
+type t
+
+external ext : unit -> t = "caml_binaryen_heap_type_ext"
+external func : unit -> t = "caml_binaryen_heap_type_func"
+external any : unit -> t = "caml_binaryen_heap_type_any"
+external eq : unit -> t = "caml_binaryen_heap_type_eq"
+external i31 : unit -> t = "caml_binaryen_heap_type_i31"
+external data : unit -> t = "caml_binaryen_heap_type_data"
+external string : unit -> t = "caml_binaryen_heap_type_string"
+external stringview_wtf8 : unit -> t = "caml_binaryen_heap_type_stringview_wtf8"
+
+external stringview_wtf16 : unit -> t
+  = "caml_binaryen_heap_type_stringview_wtf16"
+
+external stringview_iter : unit -> t = "caml_binaryen_heap_type_stringview_iter"

binaryen-archive/src/heap_type.mli

@@ -0,0 +1,12 @@
+type t
+
+val ext : unit -> t
+val func : unit -> t
+val any : unit -> t
+val eq : unit -> t
+val i31 : unit -> t
+val data : unit -> t
+val string : unit -> t
+val stringview_wtf8 : unit -> t
+val stringview_wtf16 : unit -> t
+val stringview_iter : unit -> t

binaryen-archive/src/import.ml

@@ -20,11 +20,17 @@ external add_global_import :
 external function_import_get_module : Function.t -> string
   = "caml_binaryen_function_import_get_module"
 
+external memory_import_get_module : Module.t -> string -> string
+  = "caml_binaryen_memory_import_get_module"
+
 external global_import_get_module : Global.t -> string
   = "caml_binaryen_global_import_get_module"
 
 external function_import_get_base : Function.t -> string
   = "caml_binaryen_function_import_get_base"
 
+external memory_import_get_base : Module.t -> string -> string
+  = "caml_binaryen_memory_import_get_base"
+
 external global_import_get_base : Global.t -> string
   = "caml_binaryen_global_import_get_base"