@grain/binaryen.ml 0.19.0 → 0.20.1

binaryen-archive/src/binaryen_stubs_imports.c

@@ -75,10 +75,11 @@ caml_binaryen_function_import_get_module(value _fun) {
 }
 
 CAMLprim value
-caml_binaryen_memory_import_get_module(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_import_get_module(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetModule(module)));
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetModule(module, memoryName)));
 }
 
 CAMLprim value
@@ -96,10 +97,11 @@ caml_binaryen_function_import_get_base(value _fun) {
 }
 
 CAMLprim value
-caml_binaryen_memory_import_get_base(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_import_get_base(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetBase(module)));
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetBase(module, memoryName)));
 }
 
 CAMLprim value

binaryen-archive/src/binaryen_stubs_imports.js

@@ -101,9 +101,9 @@ function caml_binaryen_function_import_get_module(func) {
 }
 
 //Provides: caml_binaryen_memory_import_get_module
-//Requires: caml_string_of_jsstring
-function caml_binaryen_memory_import_get_module(mod) {
-  var memory_info = mod.getMemoryInfo();
+//Requires: caml_string_of_jsstring, caml_jsstring_of_string
+function caml_binaryen_memory_import_get_module(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
   return caml_string_of_jsstring(memory_info.module);
 }
 
@@ -124,9 +124,9 @@ function caml_binaryen_function_import_get_base(func) {
 }
 
 //Provides: caml_binaryen_memory_import_get_base
-//Requires: caml_string_of_jsstring
-function caml_binaryen_memory_import_get_base(mod) {
-  var memory_info = mod.getMemoryInfo();
+//Requires: caml_string_of_jsstring, caml_jsstring_of_string
+function caml_binaryen_memory_import_get_base(mod, memoryName) {
+  var memory_info = mod.getMemoryInfo(caml_jsstring_of_string(memoryName));
   return caml_string_of_jsstring(memory_info.base);
 }
 

binaryen-archive/src/binaryen_stubs_memory.c

@@ -8,9 +8,9 @@
 
 
 CAMLprim value
-caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _exportName, value _segments, value _segmentPassive, value _segmentOffsets, value _segmentSizes, value _shared) {
+caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _exportName, value _segments, value _segmentPassive, value _segmentOffsets, value _segmentSizes, value _shared, value _memoryName) {
   CAMLparam5(_module, _initial, _maximum, _exportName, _segments);
-  CAMLxparam4(_segmentPassive, _segmentOffsets, _segmentSizes, _shared);
+  CAMLxparam5(_segmentPassive, _segmentOffsets, _segmentSizes, _shared, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   BinaryenIndex initial = Int_val(_initial);
   BinaryenIndex maximum = Int_val(_maximum);
@@ -40,12 +40,13 @@ caml_binaryen_set_memory(value _module, value _initial, value _maximum, value _e
     segmentSizes[i] = Int_val(Field(_segmentSizes, i));
   }
   uint8_t shared = Bool_val(_shared);
-  BinaryenSetMemory(module, initial, maximum, exportName, segments, segmentPassive, segmentOffsets, segmentSizes, segmentsLen, shared);
+  char* memoryName = Safe_String_val(_memoryName);
+  BinaryenSetMemory(module, initial, maximum, exportName, segments, segmentPassive, segmentOffsets, segmentSizes, segmentsLen, shared, 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]);
+  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]);
 }
 
 CAMLprim value
@@ -56,25 +57,28 @@ caml_binaryen_has_memory(value _module) {
 }
 
 CAMLprim value
-caml_binaryen_memory_get_initial(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_get_initial(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  CAMLreturn(Val_int(BinaryenMemoryGetInitial(module)));
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_int(BinaryenMemoryGetInitial(module, memoryName)));
 }
 
 CAMLprim value
-caml_binaryen_memory_has_max(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_has_max(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  CAMLreturn(Val_bool(BinaryenMemoryHasMax(module)));
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_bool(BinaryenMemoryHasMax(module, memoryName)));
 }
 
 CAMLprim value
-caml_binaryen_memory_get_max(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_get_max(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  if (BinaryenMemoryHasMax(module)) {
-    CAMLreturn(Val_int(BinaryenMemoryGetMax(module)));
+  char* memoryName = Safe_String_val(_memoryName);
+  if (BinaryenMemoryHasMax(module, memoryName)) {
+    CAMLreturn(Val_int(BinaryenMemoryGetMax(module, memoryName)));
   } else {
     // This ensures that our return is equal to Memory.unlimited
     CAMLreturn(Val_int(-1));
@@ -82,8 +86,43 @@ caml_binaryen_memory_get_max(value _module) {
 }
 
 CAMLprim value
-caml_binaryen_memory_is_shared(value _module) {
+caml_binaryen_memory_is_shared(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_bool(BinaryenMemoryIsShared(module, memoryName)));
+}
+
+CAMLprim value
+caml_binaryen_get_num_memory_segments(value _module) {
   CAMLparam1(_module);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  CAMLreturn(Val_bool(BinaryenMemoryIsShared(module)));
+  CAMLreturn(Val_int(BinaryenGetNumMemorySegments(module)));
+}
+
+CAMLprim value
+caml_binaryen_get_memory_segment_byte_offset(value _module, value _id) {
+  CAMLparam2(_module, _id);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex id = Int_val(_id);
+  CAMLreturn(Val_int(BinaryenGetMemorySegmentByteOffset(module, id)));
+}
+
+CAMLprim value
+caml_binaryen_get_memory_segment_passive(value _module, value _id) {
+  CAMLparam2(_module, _id);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex id = Int_val(_id);
+  CAMLreturn(Val_bool(BinaryenGetMemorySegmentPassive(module, id)));
+}
+
+CAMLprim value
+caml_binaryen_get_memory_segment_data(value _module, value _id) {
+  CAMLparam2(_module, _id);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenIndex id = Int_val(_id);
+  size_t size = BinaryenGetMemorySegmentByteLength(module, id);
+  CAMLprim value bytes = caml_alloc_string(size);
+  BinaryenCopyMemorySegmentData(module, id, (char*)Bytes_val(bytes));
+  CAMLreturn(bytes);
 }

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,13 +28,25 @@ 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
@@ -33,15 +56,16 @@ function caml_binaryen_has_memory(mod) {
 }
 
 //Provides: caml_binaryen_memory_get_initial
-function caml_binaryen_memory_get_initial(mod) {
-  var memory_info = mod.getMemoryInfo();
+//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
-function caml_binaryen_memory_has_max(mod) {
-  var memory_info = mod.getMemoryInfo();
+//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 {
@@ -50,8 +74,9 @@ function caml_binaryen_memory_has_max(mod) {
 }
 
 //Provides: caml_binaryen_memory_get_max
-function caml_binaryen_memory_get_max(mod) {
-  var memory_info = mod.getMemoryInfo();
+//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 {
@@ -61,8 +86,32 @@ function caml_binaryen_memory_get_max(mod) {
 }
 
 //Provides: caml_binaryen_memory_is_shared
-//Requires: caml_js_to_bool
-function caml_binaryen_memory_is_shared(mod) {
-  var memory_info = mod.getMemoryInfo();
+//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

@@ -53,9 +53,10 @@ caml_binaryen_module_print_asmjs(value module) {
 }
 
 CAMLprim value
-caml_binaryen_module_print_stack_ir(value module) {
-  CAMLparam1(module);
-  BinaryenModulePrintStackIR(BinaryenModuleRef_val(module));
+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);
 }
 
@@ -135,10 +136,11 @@ caml_binaryen_module_write_text(value _module) {
 // 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) {
-  CAMLparam1(_module);
+caml_binaryen_module_write_stack_ir(value _module, value _optimize) {
+  CAMLparam2(_module, _optimize);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  char* result = BinaryenModuleAllocateAndWriteStackIR(module);
+  bool optimize = Bool_val(_optimize);
+  char* result = BinaryenModuleAllocateAndWriteStackIR(module, optimize);
   CAMLlocal1(text);
   text = caml_copy_string(result);
   free(result);

binaryen-archive/src/binaryen_stubs_modules.js

@@ -37,10 +37,10 @@ function caml_binaryen_module_print_asmjs(wasm_mod) {
 }
 
 //Provides: caml_binaryen_module_print_stack_ir
-//Requires: caml_string_of_jsstring
+//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) {
-  var stackir = wasm_mod.emitStackIR()
+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));
@@ -93,9 +93,9 @@ function caml_binaryen_module_write_text(wasm_mod) {
 }
 
 //Provides: caml_binaryen_module_write_stack_ir
-//Requires: caml_string_of_jsstring
-function caml_binaryen_module_write_stack_ir(wasm_mod) {
-  var text = wasm_mod.emitStackIR();
+//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);
 }
 

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)))