@grain/binaryen.ml 0.18.0 → 0.20.0

binaryen-archive/src/binaryen_stubs_expressions.js

@@ -173,16 +173,88 @@ function caml_binaryen_global_set(wasm_mod, name, value) {
 
 //Provides: caml_binaryen_load
 //Requires: Binaryen
-function caml_binaryen_load(wasm_mod, bytes, signed, offset, align, typ, ptr) {
-  return Binaryen._BinaryenLoad(
-    wasm_mod,
-    bytes,
-    signed,
-    offset,
-    align,
-    typ,
-    ptr
-  );
+//Requires: caml_jsstring_of_string
+//Requires: caml_failwith
+function caml_binaryen_load(
+  wasm_mod,
+  bytes,
+  signed,
+  offset,
+  align,
+  typ,
+  ptr,
+  memoryName
+) {
+  var name = caml_jsstring_of_string(memoryName);
+
+  switch (typ) {
+    case Binaryen.i32: {
+      if (signed) {
+        if (bytes === 4) {
+          return wasm_mod.i32.load(offset, align, ptr, name);
+        }
+
+        if (bytes === 1) {
+          return wasm_mod.i32.load8_s(offset, align, ptr, name);
+        }
+
+        if (bytes === 2) {
+          return wasm_mod.i32.load16_s(offset, align, ptr, name);
+        }
+      } else {
+        if (bytes === 1) {
+          return wasm_mod.i32.load8_u(offset, align, ptr, name);
+        }
+
+        if (bytes === 2) {
+          return wasm_mod.i32.load16_u(offset, align, ptr, name);
+        }
+      }
+    }
+    case Binaryen.i64: {
+      if (signed) {
+        if (bytes === 8) {
+          return wasm_mod.i64.load(offset, align, ptr, name);
+        }
+
+        if (bytes === 1) {
+          return wasm_mod.i64.load8_s(offset, align, ptr, name);
+        }
+
+        if (bytes === 2) {
+          return wasm_mod.i64.load16_s(offset, align, ptr, name);
+        }
+
+        if (bytes === 4) {
+          return wasm_mod.i64.load32_s(offset, align, ptr, name);
+        }
+      } else {
+        if (bytes === 1) {
+          return wasm_mod.i64.load8_u(offset, align, ptr, name);
+        }
+
+        if (bytes === 2) {
+          return wasm_mod.i64.load16_u(offset, align, ptr, name);
+        }
+
+        if (bytes === 4) {
+          return wasm_mod.i64.load32_u(offset, align, ptr, name);
+        }
+      }
+    }
+    case Binaryen.f32: {
+      return wasm_mod.f32.load(offset, align, ptr, name);
+    }
+    case Binaryen.f64: {
+      return wasm_mod.f64.load(offset, align, ptr, name);
+    }
+    case Binaryen.v128: {
+      return wasm_mod.v128.load(offset, align, ptr, name);
+    }
+    default: {
+      caml_failwith("Invalid arguments to BinaryenLoad");
+    }
+  }
 }
 //Provides: caml_binaryen_load__bytecode
 //Requires: caml_binaryen_load
@@ -194,22 +266,71 @@ function caml_binaryen_load__bytecode() {
     arguments[3],
     arguments[4],
     arguments[5],
-    arguments[6]
+    arguments[6],
+    arguments[7]
   );
 }
 
 //Provides: caml_binaryen_store
 //Requires: Binaryen
-function caml_binaryen_store(wasm_mod, bytes, offset, align, ptr, value, typ) {
-  return Binaryen._BinaryenStore(
-    wasm_mod,
-    bytes,
-    offset,
-    align,
-    ptr,
-    value,
-    typ
-  );
+//Requires: caml_jsstring_of_string
+//Requires: caml_failwith
+function caml_binaryen_store(
+  wasm_mod,
+  bytes,
+  offset,
+  align,
+  ptr,
+  value,
+  typ,
+  memoryName
+) {
+  var name = caml_jsstring_of_string(memoryName);
+
+  switch (typ) {
+    case Binaryen.i32: {
+      if (bytes === 4) {
+        return wasm_mod.i32.store(offset, align, ptr, value, name);
+      }
+
+      if (bytes === 1) {
+        return wasm_mod.i32.store8(offset, align, ptr, value, name);
+      }
+
+      if (bytes === 2) {
+        return wasm_mod.i32.store16(offset, align, ptr, value, name);
+      }
+    }
+    case Binaryen.i64: {
+      if (bytes === 8) {
+        return wasm_mod.i64.store(offset, align, ptr, value, name);
+      }
+
+      if (bytes === 1) {
+        return wasm_mod.i64.store8(offset, align, ptr, value, name);
+      }
+
+      if (bytes === 2) {
+        return wasm_mod.i64.store16(offset, align, ptr, value, name);
+      }
+
+      if (bytes === 4) {
+        return wasm_mod.i64.store32(offset, align, ptr, value, name);
+      }
+    }
+    case Binaryen.f32: {
+      return wasm_mod.f32.store(offset, align, ptr, value, name);
+    }
+    case Binaryen.f64: {
+      return wasm_mod.f64.store(offset, align, ptr, value, name);
+    }
+    case Binaryen.v128: {
+      return wasm_mod.v128.store(offset, align, ptr, value, name);
+    }
+    default: {
+      caml_failwith("Invalid arguments to BinaryenStore");
+    }
+  }
 }
 //Provides: caml_binaryen_store__bytecode
 //Requires: caml_binaryen_store
@@ -221,7 +342,8 @@ function caml_binaryen_store__bytecode() {
     arguments[3],
     arguments[4],
     arguments[5],
-    arguments[6]
+    arguments[6],
+    arguments[7]
   );
 }
 
@@ -286,13 +408,22 @@ function caml_binaryen_return(wasm_mod, value) {
 }
 
 //Provides: caml_binaryen_memory_size
-function caml_binaryen_memory_size(wasm_mod) {
-  return wasm_mod.memory.size();
+//Requires: caml_jsstring_of_string, caml_js_from_bool
+function caml_binaryen_memory_size(wasm_mod, memoryName, memoryIs64) {
+  return wasm_mod.memory.size(
+    caml_jsstring_of_string(memoryName),
+    caml_js_from_bool(memoryIs64)
+  );
 }
 
 //Provides: caml_binaryen_memory_grow
-function caml_binaryen_memory_grow(wasm_mod, value) {
-  return wasm_mod.memory.grow(value);
+//Requires: caml_jsstring_of_string, caml_js_from_bool
+function caml_binaryen_memory_grow(wasm_mod, value, memoryName, memoryIs64) {
+  return wasm_mod.memory.grow(
+    value,
+    caml_jsstring_of_string(memoryName),
+    caml_js_from_bool(memoryIs64)
+  );
 }
 
 //Provides: caml_binaryen_nop
@@ -306,8 +437,34 @@ function caml_binaryen_unreachable(wasm_mod) {
 }
 
 //Provides: caml_binaryen_memory_init
-function caml_binaryen_memory_init(wasm_mod, segment, dest, offset, size) {
-  return wasm_mod.memory.init(segment, dest, offset, size);
+//Requires: caml_jsstring_of_string
+function caml_binaryen_memory_init(
+  wasm_mod,
+  segment,
+  dest,
+  offset,
+  size,
+  memoryName
+) {
+  return wasm_mod.memory.init(
+    segment,
+    dest,
+    offset,
+    size,
+    caml_jsstring_of_string(memoryName)
+  );
+}
+//Provides: caml_binaryen_memory_init__bytecode
+//Requires: caml_binaryen_memory_init
+function caml_binaryen_memory_init__bytecode() {
+  return caml_binaryen_memory_init(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
 }
 
 //Provides: caml_binaryen_data_drop
@@ -316,13 +473,45 @@ function caml_binaryen_data_drop(wasm_mod, segment) {
 }
 
 //Provides: caml_binaryen_memory_copy
-function caml_binaryen_memory_copy(wasm_mod, dest, source, size) {
-  return wasm_mod.memory.copy(dest, source, size);
+//Requires: caml_jsstring_of_string
+function caml_binaryen_memory_copy(
+  wasm_mod,
+  dest,
+  source,
+  size,
+  dest_memory,
+  source_memory
+) {
+  return wasm_mod.memory.copy(
+    dest,
+    source,
+    size,
+    caml_jsstring_of_string(dest_memory),
+    caml_jsstring_of_string(source_memory)
+  );
+}
+//Provides: caml_binaryen_memory_copy__bytecode
+//Requires: caml_binaryen_memory_copy
+function caml_binaryen_memory_copy__bytecode() {
+  return caml_binaryen_memory_copy(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
 }
 
 //Provides: caml_binaryen_memory_fill
-function caml_binaryen_memory_fill(wasm_mod, dest, value, size) {
-  return wasm_mod.memory.fill(dest, value, size);
+//Requires: caml_jsstring_of_string
+function caml_binaryen_memory_fill(wasm_mod, dest, value, size, memoryName) {
+  return wasm_mod.memory.fill(
+    dest,
+    value,
+    size,
+    caml_jsstring_of_string(memoryName)
+  );
 }
 
 //Provides: caml_binaryen_tuple_make
@@ -628,16 +817,6 @@ function caml_binaryen_expression_id_ref_cast() {
 function caml_binaryen_expression_id_br_on() {
   return Binaryen.BrOnId;
 }
-//Provides: caml_binaryen_expression_id_rtt_canon
-//Requires: Binaryen
-function caml_binaryen_expression_id_rtt_canon() {
-  return Binaryen.RttCanonId;
-}
-//Provides: caml_binaryen_expression_id_rtt_sub
-//Requires: Binaryen
-function caml_binaryen_expression_id_rtt_sub() {
-  return Binaryen.RttSubId;
-}
 //Provides: caml_binaryen_expression_id_struct_new
 //Requires: Binaryen
 function caml_binaryen_expression_id_struct_new() {

binaryen-archive/src/binaryen_stubs_features.c

@@ -119,6 +119,12 @@ caml_binaryen_feature_extended_const(value unit) {
   CAMLreturn(Val_int(BinaryenFeatureExtendedConst()));
 }
 
+CAMLprim value
+caml_binaryen_feature_strings(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenFeatureStrings()));
+}
+
 CAMLprim value
 caml_binaryen_feature_all(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/binaryen_stubs_features.js

@@ -104,6 +104,12 @@ function caml_binaryen_feature_extended_const() {
   return Binaryen.Features.ExtendedConst;
 }
 
+//Provides: caml_binaryen_feature_strings
+//Requires: Binaryen
+function caml_binaryen_feature_strings() {
+  return Binaryen.Features.Strings;
+}
+
 //Provides: caml_binaryen_feature_all
 //Requires: Binaryen
 function caml_binaryen_feature_all() {

binaryen-archive/src/binaryen_stubs_heap_types.c

@@ -0,0 +1,95 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+
+/* Allocating an OCaml custom block to hold the given BinaryenHeapType */
+static value alloc_BinaryenHeapType(BinaryenHeapType typ)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenHeapType), 0, 1);
+  BinaryenHeapType_val(v) = typ;
+  return v;
+}
+
+
+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_data(value unit) {
+  CAMLparam1(unit);
+  BinaryenHeapType ty = BinaryenHeapTypeData();
+  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_type_get_heap_type(value _ty) {
+  CAMLparam1(_ty);
+  BinaryenType ty = BinaryenType_val(_ty);
+  BinaryenHeapType heapTy = BinaryenTypeGetHeapType(ty);
+  CAMLreturn(alloc_BinaryenHeapType(heapTy));
+}

binaryen-archive/src/binaryen_stubs_heap_types.js

@@ -0,0 +1,65 @@
+//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_data
+//Requires: Binaryen
+function caml_binaryen_heap_type_data() {
+  return Binaryen._BinaryenHeapTypeData();
+}
+
+//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_type_get_heap_type
+//Requires: Binaryen
+function caml_binaryen_type_get_heap_type(typ) {
+  return Binaryen._BinaryenTypeGetHeapType(typ);
+}

binaryen-archive/src/binaryen_stubs_imports.c

@@ -74,6 +74,14 @@ caml_binaryen_function_import_get_module(value _fun) {
   CAMLreturn(caml_copy_string(BinaryenFunctionImportGetModule(fun)));
 }
 
+CAMLprim value
+caml_binaryen_memory_import_get_module(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetModule(module, memoryName)));
+}
+
 CAMLprim value
 caml_binaryen_global_import_get_module(value _global) {
   CAMLparam1(_global);
@@ -88,6 +96,14 @@ caml_binaryen_function_import_get_base(value _fun) {
   CAMLreturn(caml_copy_string(BinaryenFunctionImportGetBase(fun)));
 }
 
+CAMLprim value
+caml_binaryen_memory_import_get_base(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(caml_copy_string(BinaryenMemoryImportGetBase(module, memoryName)));
+}
+
 CAMLprim value
 caml_binaryen_global_import_get_base(value _global) {
   CAMLparam1(_global);

binaryen-archive/src/binaryen_stubs_imports.js

@@ -100,6 +100,13 @@ function caml_binaryen_function_import_get_module(func) {
   return caml_string_of_jsstring(func_info.module);
 }
 
+//Provides: caml_binaryen_memory_import_get_module
+//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);
+}
+
 //Provides: caml_binaryen_global_import_get_module
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -116,6 +123,13 @@ function caml_binaryen_function_import_get_base(func) {
   return caml_string_of_jsstring(func_info.base);
 }
 
+//Provides: caml_binaryen_memory_import_get_base
+//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);
+}
+
 //Provides: caml_binaryen_global_import_get_base
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring

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,10 +40,89 @@ 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
+caml_binaryen_has_memory(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  CAMLreturn(Val_bool(BinaryenHasMemory(module)));
+}
+
+CAMLprim value
+caml_binaryen_memory_get_initial(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_int(BinaryenMemoryGetInitial(module, memoryName)));
+}
+
+CAMLprim value
+caml_binaryen_memory_has_max(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* memoryName = Safe_String_val(_memoryName);
+  CAMLreturn(Val_bool(BinaryenMemoryHasMax(module, memoryName)));
+}
+
+CAMLprim value
+caml_binaryen_memory_get_max(value _module, value _memoryName) {
+  CAMLparam2(_module, _memoryName);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_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));
+  }
+}
+
+CAMLprim value
+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_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);
 }