@grain/binaryen.ml 0.20.1 → 0.22.0

binaryen-archive/src/heap_type.c

@@ -0,0 +1,171 @@
+#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_heap_type_ext(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeExt();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_func(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeFunc();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_any(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeAny();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_eq(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeEq();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_i31(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeI31();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_struct(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeStruct();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_array(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeArray();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_string(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeString();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_stringview_wtf8(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeStringviewWTF8();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_stringview_wtf16(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeStringviewWTF16();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_stringview_iter(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeStringviewIter();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_none(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeNone();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_noext(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeNoext();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_nofunc(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeNofunc();
+  CAMLreturn(alloc_BinaryenHeapType(ty));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_basic(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  bool result = BinaryenHeapTypeIsBasic(ty);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_signature(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  bool result = BinaryenHeapTypeIsSignature(ty);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_struct(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  bool result = BinaryenHeapTypeIsStruct(ty);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_array(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  bool result = BinaryenHeapTypeIsArray(ty);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_bottom(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  bool result = BinaryenHeapTypeIsBottom(ty);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_get_bottom(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenHeapType ty = BinaryenHeapType_val(_ty);
+  BinaryenHeapType heapTy = BinaryenHeapTypeGetBottom(ty);
+  CAMLreturn(alloc_BinaryenHeapType(heapTy));
+}
+
+CAMLprim value
+caml_binaryen_heap_type_is_sub_type(value _left, value _right) {
+  CAMLparam2(_left, _right);
+  BinaryenHeapType left = BinaryenHeapType_val(_left);
+  BinaryenHeapType right = BinaryenHeapType_val(_right);
+  bool result = BinaryenHeapTypeIsSubType(left, right);
+  CAMLreturn(Val_bool(result));
+}
+
+CAMLprim value
+caml_binaryen_type_get_heap_type(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenHeapType heapTy = BinaryenTypeGetHeapType(ty);
+  CAMLreturn(alloc_BinaryenHeapType(heapTy));
+}

binaryen-archive/src/heap_type.js

@@ -0,0 +1,131 @@
+//Provides: caml_binaryen_heap_type_ext
+//Requires: Binaryen
+function caml_binaryen_heap_type_ext() {
+  return Binaryen._BinaryenHeapTypeExt();
+}
+
+//Provides: caml_binaryen_heap_type_func
+//Requires: Binaryen
+function caml_binaryen_heap_type_func() {
+  return Binaryen._BinaryenHeapTypeFunc();
+}
+
+//Provides: caml_binaryen_heap_type_any
+//Requires: Binaryen
+function caml_binaryen_heap_type_any() {
+  return Binaryen._BinaryenHeapTypeAny();
+}
+
+//Provides: caml_binaryen_heap_type_eq
+//Requires: Binaryen
+function caml_binaryen_heap_type_eq() {
+  return Binaryen._BinaryenHeapTypeEq();
+}
+
+//Provides: caml_binaryen_heap_type_i31
+//Requires: Binaryen
+function caml_binaryen_heap_type_i31() {
+  return Binaryen._BinaryenHeapTypeI31();
+}
+
+//Provides: caml_binaryen_heap_type_struct
+//Requires: Binaryen
+function caml_binaryen_heap_type_struct() {
+  return Binaryen._BinaryenHeapTypeStruct();
+}
+
+//Provides: caml_binaryen_heap_type_array
+//Requires: Binaryen
+function caml_binaryen_heap_type_array() {
+  return Binaryen._BinaryenHeapTypeArray();
+}
+
+//Provides: caml_binaryen_heap_type_string
+//Requires: Binaryen
+function caml_binaryen_heap_type_string() {
+  return Binaryen._BinaryenHeapTypeString();
+}
+
+//Provides: caml_binaryen_heap_type_stringview_wtf8
+//Requires: Binaryen
+function caml_binaryen_heap_type_stringview_wtf8() {
+  return Binaryen._BinaryenHeapTypeStringviewWTF8();
+}
+
+//Provides: caml_binaryen_heap_type_stringview_wtf16
+//Requires: Binaryen
+function caml_binaryen_heap_type_stringview_wtf16() {
+  return Binaryen._BinaryenHeapTypeStringviewWTF16();
+}
+
+//Provides: caml_binaryen_heap_type_stringview_iter
+//Requires: Binaryen
+function caml_binaryen_heap_type_stringview_iter() {
+  return Binaryen._BinaryenHeapTypeStringviewIter();
+}
+
+//Provides: caml_binaryen_heap_type_none
+//Requires: Binaryen
+function caml_binaryen_heap_type_none() {
+  return Binaryen._BinaryenHeapTypeNone();
+}
+
+//Provides: caml_binaryen_heap_type_noext
+//Requires: Binaryen
+function caml_binaryen_heap_type_noext() {
+  return Binaryen._BinaryenHeapTypeNoext();
+}
+
+//Provides: caml_binaryen_heap_type_nofunc
+//Requires: Binaryen
+function caml_binaryen_heap_type_nofunc() {
+  return Binaryen._BinaryenHeapTypeNofunc();
+}
+
+//Provides: caml_binaryen_heap_type_is_basic
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_basic(ty) {
+  return Binaryen._BinaryenHeapTypeIsBasic(ty);
+}
+
+//Provides: caml_binaryen_heap_type_is_signature
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_signature(ty) {
+  return Binaryen._BinaryenHeapTypeIsSignature(ty);
+}
+
+//Provides: caml_binaryen_heap_type_is_struct
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_struct(ty) {
+  return Binaryen._BinaryenHeapTypeIsStruct(ty);
+}
+
+//Provides: caml_binaryen_heap_type_is_array
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_array(ty) {
+  return Binaryen._BinaryenHeapTypeIsArray(ty);
+}
+
+//Provides: caml_binaryen_heap_type_is_bottom
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_bottom(ty) {
+  return Binaryen._BinaryenHeapTypeIsBottom(ty);
+}
+
+//Provides: caml_binaryen_heap_type_get_bottom
+//Requires: Binaryen
+function caml_binaryen_heap_type_get_bottom(ty) {
+  return Binaryen._BinaryenHeapTypeGetBottom(ty);
+}
+
+//Provides: caml_binaryen_heap_type_is_sub_type
+//Requires: Binaryen
+function caml_binaryen_heap_type_is_sub_type(left, right) {
+  return Binaryen._BinaryenHeapTypeIsSubType(left, right);
+}
+
+//Provides: caml_binaryen_type_get_heap_type
+//Requires: Binaryen
+function caml_binaryen_type_get_heap_type(typ) {
+  return Binaryen._BinaryenTypeGetHeapType(typ);
+}

binaryen-archive/src/heap_type.ml

@@ -5,7 +5,8 @@ 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 struct_ : unit -> t = "caml_binaryen_heap_type_struct"
+external array : unit -> t = "caml_binaryen_heap_type_array"
 external string : unit -> t = "caml_binaryen_heap_type_string"
 external stringview_wtf8 : unit -> t = "caml_binaryen_heap_type_stringview_wtf8"
 
@@ -13,3 +14,13 @@ external stringview_wtf16 : unit -> t
   = "caml_binaryen_heap_type_stringview_wtf16"
 
 external stringview_iter : unit -> t = "caml_binaryen_heap_type_stringview_iter"
+external none : unit -> t = "caml_binaryen_heap_type_none"
+external noext : unit -> t = "caml_binaryen_heap_type_noext"
+external nofunc : unit -> t = "caml_binaryen_heap_type_nofunc"
+external is_basic : t -> bool = "caml_binaryen_heap_type_is_basic"
+external is_signature : t -> bool = "caml_binaryen_heap_type_is_signature"
+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"

binaryen-archive/src/heap_type.mli

@@ -5,8 +5,19 @@ val func : unit -> t
 val any : unit -> t
 val eq : unit -> t
 val i31 : unit -> t
-val data : unit -> t
+val struct_ : unit -> t
+val array : unit -> t
 val string : unit -> t
 val stringview_wtf8 : unit -> t
 val stringview_wtf16 : unit -> t
 val stringview_iter : unit -> t
+val none : unit -> t
+val noext : unit -> t
+val nofunc : unit -> t
+val is_basic : t -> bool
+val is_signature : t -> bool
+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

binaryen-archive/src/{binaryen_stubs_literals.c → literal.c}

@@ -6,15 +6,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenLiteral */
-static value alloc_BinaryenLiteral(struct BinaryenLiteral op)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(struct BinaryenLiteral), 0, 1);
-  BinaryenLiteral_val(v) = op;
-  return v;
-}
-
 CAMLprim value
 caml_binaryen_literal_int32(value _i32) {
   CAMLparam1(_i32);

binaryen-archive/src/{binaryen_stubs_memory.c → memory.c}

@@ -8,9 +8,10 @@
 
 
 CAMLprim value
-caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _exportName, value _segments, value _segmentPassive, value _segmentOffsets, value _segmentSizes, value _shared, value _memoryName) {
+caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _exportName, value _segments, value _segmentPassive, value _segmentOffsets, value _segmentSizes, value _shared, value _memory64, value _memoryName) {
   CAMLparam5(_module, _initial, _maximum, _exportName, _segments);
-  CAMLxparam5(_segmentPassive, _segmentOffsets, _segmentSizes, _shared, _memoryName);
+  CAMLxparam5(_segmentPassive, _segmentOffsets, _segmentSizes, _shared, _memory64);
+  CAMLxparam1(_memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   BinaryenIndex initial = Int_val(_initial);
   BinaryenIndex maximum = Int_val(_maximum);
@@ -39,14 +40,15 @@ caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _e
   for (int i = 0; i < segmentSizesLen; i++) {
     segmentSizes[i] = Int_val(Field(_segmentSizes, i));
   }
-  uint8_t shared = Bool_val(_shared);
+  bool shared = Bool_val(_shared);
+  bool memory64 = Bool_val(_memory64);
   char* memoryName = Safe_String_val(_memoryName);
-  BinaryenSetMemory(module, initial, maximum, exportName, segments, segmentPassive, segmentOffsets, segmentSizes, segmentsLen, shared, memoryName);
+  BinaryenSetMemory(module, initial, maximum, exportName, segments, segmentPassive, segmentOffsets, segmentSizes, segmentsLen, shared, memory64, memoryName);
   CAMLreturn(Val_unit);
 }
 CAMLprim value
 caml_binaryen_set_memory__bytecode(value * argv) {
-  return caml_binaryen_set_memory(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9]);
+  return caml_binaryen_set_memory(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7], argv[8], argv[9], argv[10]);
 }
 
 CAMLprim value
@@ -93,6 +95,14 @@ caml_binaryen_memory_is_shared(value _module, value _memoryName) {
   CAMLreturn(Val_bool(BinaryenMemoryIsShared(module, memoryName)));
 }
 
+CAMLprim value
+caml_binaryen_memory_is_64(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_bool(BinaryenMemoryIs64(module, memoryName)));
+}
+
 CAMLprim value
 caml_binaryen_get_num_memory_segments(value _module) {
   CAMLparam1(_module);

binaryen-archive/src/{binaryen_stubs_memory.js → memory.js}

@@ -11,6 +11,7 @@ function caml_binaryen_set_memory(
   segmentOffsets,
   segmentSizes,
   shared,
+  memory64,
   memoryName
 ) {
   var passives = caml_list_to_js_array(segmentPassives);
@@ -29,6 +30,7 @@ function caml_binaryen_set_memory(
     caml_jsstring_of_string(exportName),
     segs,
     caml_js_from_bool(shared),
+    caml_js_from_bool(memory64),
     caml_jsstring_of_string(memoryName)
   );
 }
@@ -45,7 +47,8 @@ function caml_binaryen_set_memory__bytecode() {
     arguments[6],
     arguments[7],
     arguments[8],
-    arguments[9]
+    arguments[9],
+    arguments[10]
   );
 }
 
@@ -92,6 +95,13 @@ function caml_binaryen_memory_is_shared(mod, memoryName) {
   return caml_js_to_bool(memory_info.shared);
 }
 
+//Provides: caml_binaryen_memory_is_64
+//Requires: caml_js_to_bool, caml_jsstring_of_string
+function caml_binaryen_memory_is_64(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
+  return caml_js_to_bool(memory_info.is64);
+}
+
 //Provides: caml_binaryen_get_num_memory_segments
 function caml_binaryen_get_num_memory_segments(wasm_mod) {
   return wasm_mod.getNumMemorySegments();

binaryen-archive/src/memory.ml

@@ -8,15 +8,16 @@ external set_memory :
   Expression.t list ->
   int list ->
   bool ->
+  bool ->
   string ->
   unit = "caml_binaryen_set_memory__bytecode" "caml_binaryen_set_memory"
 
 type segment = { data : bytes; kind : segment_kind; size : int }
 and segment_kind = Passive | Active of { offset : Expression.t }
 
-(** Module, initial size, maximum size, export name, segments, shared. *)
+(** Module, initial size, maximum size, export name, segments, shared, memory64, moduleName . *)
 let set_memory wasm_mod initial maximum export_name (segments : segment list)
-    shared =
+    shared memory64 moduleName =
   let split_segments segments =
     List.fold_right
       (fun { data; kind; size }
@@ -38,7 +39,7 @@ let set_memory wasm_mod initial maximum export_name (segments : segment list)
     split_segments segments
   in
   set_memory wasm_mod initial maximum export_name segment_data segment_passive
-    segment_offsets segment_sizes shared
+    segment_offsets segment_sizes shared memory64 moduleName
 
 external has_memory : Module.t -> bool = "caml_binaryen_has_memory"
 
@@ -51,6 +52,8 @@ external get_max : Module.t -> string -> int = "caml_binaryen_memory_get_max"
 external is_shared : Module.t -> string -> bool
   = "caml_binaryen_memory_is_shared"
 
+external is_64 : Module.t -> string -> bool = "caml_binaryen_memory_is_64"
+
 let unlimited = -1
 
 external get_num_segments : Module.t -> int

binaryen-archive/src/memory.mli

@@ -2,13 +2,22 @@ type segment = { data : bytes; kind : segment_kind; size : int }
 and segment_kind = Passive | Active of { offset : Expression.t }
 
 val set_memory :
-  Module.t -> int -> int -> string -> segment list -> bool -> string -> unit
+  Module.t ->
+  int ->
+  int ->
+  string ->
+  segment list ->
+  bool ->
+  bool ->
+  string ->
+  unit
 
 val has_memory : Module.t -> bool
 val get_initial : Module.t -> string -> int
 val has_max : Module.t -> string -> bool
 val get_max : Module.t -> string -> int
 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 -> int -> int

binaryen-archive/src/{binaryen_stubs_modules.c → module.c}

@@ -7,15 +7,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenModuleRef */
-static value alloc_BinaryenModuleRef(BinaryenModuleRef typ)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenModuleRef), 0, 1);
-  BinaryenModuleRef_val(v) = typ;
-  return v;
-}
-
 CAMLprim value
 caml_binaryen_module_create(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/module.ml

@@ -60,11 +60,6 @@ module Feature = struct
 
   let memory64 = memory64 ()
 
-  external typed_function_references : unit -> t
-    = "caml_binaryen_feature_typed_function_references"
-
-  let typed_function_references = typed_function_references ()
-
   external relaxed_simd : unit -> t = "caml_binaryen_feature_relaxed_simd"
 
   let relaxed_simd = relaxed_simd ()
@@ -77,6 +72,10 @@ module Feature = struct
 
   let strings = strings ()
 
+  external multi_memories : unit -> t = "caml_binaryen_feature_multi_memories"
+
+  let multi_memories = multi_memories ()
+
   external all : unit -> t = "caml_binaryen_feature_all"
 
   let all = all ()

binaryen-archive/src/module.mli

@@ -16,10 +16,10 @@ module Feature : sig
   val multivalue : t
   val gc : t
   val memory64 : t
-  val typed_function_references : t
   val relaxed_simd : t
   val extended_const : t
   val strings : t
+  val multi_memories : t
   val all : t
 end
 

binaryen-archive/src/{binaryen_stubs_features.c → module_feature.c}

@@ -101,12 +101,6 @@ caml_binaryen_feature_memory64(value unit) {
   CAMLreturn(Val_int(BinaryenFeatureMemory64()));
 }
 
-CAMLprim value
-caml_binaryen_feature_typed_function_references(value unit) {
-  CAMLparam1(unit);
-  CAMLreturn(Val_int(BinaryenFeatureTypedFunctionReferences()));
-}
-
 CAMLprim value
 caml_binaryen_feature_relaxed_simd(value unit) {
   CAMLparam1(unit);
@@ -125,6 +119,12 @@ caml_binaryen_feature_strings(value unit) {
   CAMLreturn(Val_int(BinaryenFeatureStrings()));
 }
 
+CAMLprim value
+caml_binaryen_feature_multi_memories(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenFeatureMultiMemories()));
+}
+
 CAMLprim value
 caml_binaryen_feature_all(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/{binaryen_stubs_features.js → module_feature.js}

@@ -86,12 +86,6 @@ function caml_binaryen_feature_memory64() {
   return Binaryen.Features.Memory64;
 }
 
-//Provides: caml_binaryen_feature_typed_function_references
-//Requires: Binaryen
-function caml_binaryen_feature_typed_function_references() {
-  return Binaryen.Features.TypedFunctionReferences;
-}
-
 //Provides: caml_binaryen_feature_relaxed_simd
 //Requires: Binaryen
 function caml_binaryen_feature_relaxed_simd() {
@@ -110,6 +104,12 @@ function caml_binaryen_feature_strings() {
   return Binaryen.Features.Strings;
 }
 
+//Provides: caml_binaryen_feature_multi_memories
+//Requires: Binaryen
+function caml_binaryen_feature_multi_memories() {
+  return Binaryen.Features.MultiMemories;
+}
+
 //Provides: caml_binaryen_feature_all
 //Requires: Binaryen
 function caml_binaryen_feature_all() {