@grain/binaryen.ml 0.19.0 → 0.20.1

binaryen-archive/src/binaryen_stubs_expressions.c

@@ -224,9 +224,9 @@ caml_binaryen_global_set(value _module, value _name, value _val) {
 }
 
 CAMLprim value
-caml_binaryen_load(value _module, value _bytes, value _signed_, value _offset, value _align, value _ty, value _ptr) {
+caml_binaryen_load(value _module, value _bytes, value _signed_, value _offset, value _align, value _ty, value _ptr, value _memoryName) {
   CAMLparam5(_module, _bytes, _signed_, _offset, _align);
-  CAMLxparam2(_ty, _ptr);
+  CAMLxparam3(_ty, _ptr, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   int bytes = Int_val(_bytes);
   int8_t signed_ = Bool_val(_signed_);
@@ -234,18 +234,19 @@ caml_binaryen_load(value _module, value _bytes, value _signed_, value _offset, v
   int align = Int_val(_align);
   BinaryenType ty = BinaryenType_val(_ty);
   BinaryenExpressionRef ptr = BinaryenExpressionRef_val(_ptr);
-  BinaryenExpressionRef exp = BinaryenLoad(module, bytes, signed_, offset, align, ty, ptr);
+  char* memoryName = Safe_String_val(_memoryName);
+  BinaryenExpressionRef exp = BinaryenLoad(module, bytes, signed_, offset, align, ty, ptr, memoryName);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 CAMLprim value
 caml_binaryen_load__bytecode(value * argv) {
-  return caml_binaryen_load(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
+  return caml_binaryen_load(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
 }
 
 CAMLprim value
-caml_binaryen_store(value _module, value _bytes, value _offset, value _align, value _ptr, value _val, value _ty) {
+caml_binaryen_store(value _module, value _bytes, value _offset, value _align, value _ptr, value _val, value _ty, value _memoryName) {
   CAMLparam5(_module, _bytes, _offset, _align, _ptr);
-  CAMLxparam2(_val, _ty);
+  CAMLxparam3(_val, _ty, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   int bytes = Int_val(_bytes);
   int offset = Int_val(_offset);
@@ -253,12 +254,13 @@ caml_binaryen_store(value _module, value _bytes, value _offset, value _align, va
   BinaryenExpressionRef ptr = BinaryenExpressionRef_val(_ptr);
   BinaryenExpressionRef val = BinaryenExpressionRef_val(_val);
   BinaryenType ty = BinaryenType_val(_ty);
-  BinaryenExpressionRef exp = BinaryenStore(module, bytes, offset, align, ptr, val, ty);
+  char* memoryName = Safe_String_val(_memoryName);
+  BinaryenExpressionRef exp = BinaryenStore(module, bytes, offset, align, ptr, val, ty, memoryName);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 CAMLprim value
 caml_binaryen_store__bytecode(value * argv) {
-  return caml_binaryen_store(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6]);
+  return caml_binaryen_store(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7]);
 }
 
 CAMLprim value
@@ -322,19 +324,23 @@ caml_binaryen_return(value _module, value _p1) {
 }
 
 CAMLprim value
-caml_binaryen_memory_size(value _module) {
-  CAMLparam1(_module);
+caml_binaryen_memory_size(value _module, value _memoryName, value _memoryIs64) {
+  CAMLparam3(_module, _memoryName, _memoryIs64);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  BinaryenExpressionRef exp = BinaryenMemorySize(module);
+  char* memoryName = Safe_String_val(_memoryName);
+  bool memoryIs64 = Bool_val(_memoryIs64);
+  BinaryenExpressionRef exp = BinaryenMemorySize(module, memoryName, memoryIs64);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
 CAMLprim value
-caml_binaryen_memory_grow(value _module, value _p1) {
-  CAMLparam2(_module, _p1);
+caml_binaryen_memory_grow(value _module, value _delta, value _memoryName, value _memoryIs64) {
+  CAMLparam4(_module, _delta, _memoryName, _memoryIs64);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
-  BinaryenExpressionRef p1 = BinaryenExpressionRef_val(_p1);
-  BinaryenExpressionRef exp = BinaryenMemoryGrow(module, p1);
+  BinaryenExpressionRef delta = BinaryenExpressionRef_val(_delta);
+  char* memoryName = Safe_String_val(_memoryName);
+  bool memoryIs64 = Bool_val(_memoryIs64);
+  BinaryenExpressionRef exp = BinaryenMemoryGrow(module, delta, memoryName, memoryIs64);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
@@ -355,16 +361,22 @@ caml_binaryen_unreachable(value _module) {
 }
 
 CAMLprim value
-caml_binaryen_memory_init(value _module, value _segment, value _dest, value _offset, value _size) {
+caml_binaryen_memory_init(value _module, value _segment, value _dest, value _offset, value _size, value _memoryName) {
   CAMLparam5(_module, _segment, _dest, _offset, _size);
+  CAMLxparam1(_memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   uint32_t segment = Int_val(_segment);
   BinaryenExpressionRef dest = BinaryenExpressionRef_val(_dest);
   BinaryenExpressionRef offset = BinaryenExpressionRef_val(_offset);
   BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
-  BinaryenExpressionRef exp = BinaryenMemoryInit(module, segment, dest, offset, size);
+  char* memoryName = Safe_String_val(_memoryName);
+  BinaryenExpressionRef exp = BinaryenMemoryInit(module, segment, dest, offset, size, memoryName);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
+CAMLprim value
+caml_binaryen_memory_init__bytecode(value * argv) {
+  return caml_binaryen_memory_init(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
 
 CAMLprim value
 caml_binaryen_data_drop(value _module, value _segment) {
@@ -376,24 +388,32 @@ caml_binaryen_data_drop(value _module, value _segment) {
 }
 
 CAMLprim value
-caml_binaryen_memory_copy(value _module, value _dest, value _source, value _size) {
-  CAMLparam4(_module, _dest, _source, _size);
+caml_binaryen_memory_copy(value _module, value _dest, value _source, value _size, value _destMemory, value _sourceMemory) {
+  CAMLparam5(_module, _dest, _source, _size, _destMemory);
+  CAMLxparam1(_sourceMemory);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   BinaryenExpressionRef dest = BinaryenExpressionRef_val(_dest);
   BinaryenExpressionRef source = BinaryenExpressionRef_val(_source);
   BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
-  BinaryenExpressionRef exp = BinaryenMemoryCopy(module, dest, source, size);
+  char* destMemory = Safe_String_val(_destMemory);
+  char* sourceMemory = Safe_String_val(_sourceMemory);
+  BinaryenExpressionRef exp = BinaryenMemoryCopy(module, dest, source, size, destMemory, sourceMemory);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
+CAMLprim value
+caml_binaryen_memory_copy__bytecode(value * argv) {
+  return caml_binaryen_memory_copy(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
 
 CAMLprim value
-caml_binaryen_memory_fill(value _module, value _dest, value _val, value _size) {
-  CAMLparam4(_module, _dest, _val, _size);
+caml_binaryen_memory_fill(value _module, value _dest, value _val, value _size, value _memoryName) {
+  CAMLparam5(_module, _dest, _val, _size, _memoryName);
   BinaryenModuleRef module = BinaryenModuleRef_val(_module);
   BinaryenExpressionRef dest = BinaryenExpressionRef_val(_dest);
   BinaryenExpressionRef val = BinaryenExpressionRef_val(_val);
   BinaryenExpressionRef size = BinaryenExpressionRef_val(_size);
-  BinaryenExpressionRef exp = BinaryenMemoryFill(module, dest, val, size);
+  char* memoryName = Safe_String_val(_memoryName);
+  BinaryenExpressionRef exp = BinaryenMemoryFill(module, dest, val, size, memoryName);
   CAMLreturn(alloc_BinaryenExpressionRef(exp));
 }
 
@@ -717,16 +737,6 @@ caml_binaryen_expression_id_br_on(value unit) {
   CAMLreturn(Val_int(BinaryenBrOnId()));
 }
 CAMLprim value
-caml_binaryen_expression_id_rtt_canon(value unit) {
-  CAMLparam1(unit);
-  CAMLreturn(Val_int(BinaryenRttCanonId()));
-}
-CAMLprim value
-caml_binaryen_expression_id_rtt_sub(value unit) {
-  CAMLparam1(unit);
-  CAMLreturn(Val_int(BinaryenRttSubId()));
-}
-CAMLprim value
 caml_binaryen_expression_id_struct_new(value unit) {
   CAMLparam1(unit);
   CAMLreturn(Val_int(BinaryenStructNewId()));

binaryen-archive/src/binaryen_stubs_expressions.js

@@ -173,16 +173,94 @@ 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: {
+      // Using four bytes doesn't matter if it is signed or unsigned
+      if (bytes === 4) {
+        return wasm_mod.i32.load(offset, align, ptr, name);
+      }
+
+      if (signed) {
+        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);
+        }
+      }
+
+      break;
+    }
+    case Binaryen.i64: {
+      // Using eight bytes doesn't matter if it is signed or unsigned
+      if (bytes === 8) {
+        return wasm_mod.i64.load(offset, align, ptr, name);
+      }
+
+      if (signed) {
+        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);
+        }
+      }
+
+      break;
+    }
+    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 +272,75 @@ 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);
+      }
+
+      break;
+    }
+    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);
+      }
+
+      break;
+    }
+    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 +352,8 @@ function caml_binaryen_store__bytecode() {
     arguments[3],
     arguments[4],
     arguments[5],
-    arguments[6]
+    arguments[6],
+    arguments[7]
   );
 }
 
@@ -286,13 +418,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 +447,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 +483,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 +827,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);
+}