@grain/binaryen.ml 0.34.0 → 0.36.0

binaryen-archive/src/passes.ml

@@ -106,6 +106,9 @@ let generate_global_effects = "generate-global-effects"
 (** refine the types of globals *)
 let global_refining = "global-refining"
 
+(** globally optimize struct values, also emitting ref.cast_desc_eq *)
+let gsi_desc_cast = "gsi-desc-cast"
+
 (** globally optimize struct values *)
 let gsi = "gsi"
 
@@ -152,9 +155,6 @@ let inlining_optimizing = "inlining-optimizing"
 (** lower away binaryen intrinsics *)
 let intrinsic_lowering = "intrinsic-lowering"
 
-(** wrap imports and exports for JavaScript promise integration *)
-let jspi = "jspi"
-
 (** legalizes i64 types on the import/export boundary *)
 let legalize_js_interface = "legalize-js-interface"
 
@@ -229,13 +229,6 @@ let minify_imports_and_exports_and_modules =
 (** Split types into minimal recursion groups *)
 let minimize_rec_groups = "minimize-rec-groups"
 
-(** apply the assumption that asyncify imports always unwind, and we never
-    rewind *)
-let mod_asyncify_always_and_only_unwind = "mod-asyncify-always-and-only-unwind"
-
-(** apply the assumption that asyncify never unwinds *)
-let mod_asyncify_never_unwind = "mod-asyncify-never-unwind"
-
 (** creates specialized versions of functions *)
 let monomorphize = "monomorphize"
 
@@ -328,6 +321,9 @@ let symbolmap = "symbolmap"
 (** removes operations incompatible with js *)
 let remove_non_js_ops = "remove-non-js-ops"
 
+(** replaces relaxed SIMD instructions with unreachable *)
+let remove_relaxed_simd = "remove-relaxed-simd"
+
 (** removes imports and replaces them with nops *)
 let remove_imports = "remove-imports"
 
@@ -365,6 +361,9 @@ let reorder_globals = "reorder-globals"
 (** sorts locals by access frequency *)
 let reorder_locals = "reorder-locals"
 
+(** sorts private types by access frequency *)
+let reorder_types = "reorder-types"
+
 (** re-optimize control flow using the relooper algorithm *)
 let rereloop = "rereloop"
 
@@ -472,6 +471,9 @@ let strip_eh = "strip-eh"
 (** strip the wasm target features section *)
 let strip_target_features = "strip-target-features"
 
+(** strip all toolchain-specific code annotations *)
+let strip_toolchain_annotations = "strip-toolchain-annotations"
+
 (** translate old Phase 3 EH instructions to new ones with exnref *)
 let translate_to_exnref = "translate-to-exnref"
 
@@ -490,7 +492,7 @@ let type_finalizing = "type-finalizing"
 (** merge types to their supertypes where possible *)
 let type_merging = "type-merging"
 
-(** create new nominal types to help other optimizations *)
+(** create new types to help other optimizations *)
 let type_ssa = "type-ssa"
 
 (** mark all types as non-final (open) *)

binaryen-archive/src/passes.mli

@@ -106,6 +106,9 @@ val generate_global_effects : t
 val global_refining : t
 (** refine the types of globals *)
 
+val gsi_desc_cast : t
+(** globally optimize struct values, also emitting ref.cast_desc_eq *)
+
 val gsi : t
 (** globally optimize struct values *)
 
@@ -149,9 +152,6 @@ val inlining_optimizing : t
 val intrinsic_lowering : t
 (** lower away binaryen intrinsics *)
 
-val jspi : t
-(** wrap imports and exports for JavaScript promise integration *)
-
 val legalize_js_interface : t
 (** legalizes i64 types on the import/export boundary *)
 
@@ -225,13 +225,6 @@ val minify_imports_and_exports_and_modules : t
 val minimize_rec_groups : t
 (** Split types into minimal recursion groups *)
 
-val mod_asyncify_always_and_only_unwind : t
-(** apply the assumption that asyncify imports always unwind, and we never
-    rewind *)
-
-val mod_asyncify_never_unwind : t
-(** apply the assumption that asyncify never unwinds *)
-
 val monomorphize : t
 (** creates specialized versions of functions *)
 
@@ -323,6 +316,9 @@ val symbolmap : t
 val remove_non_js_ops : t
 (** removes operations incompatible with js *)
 
+val remove_relaxed_simd : t
+(** replaces relaxed SIMD instructions with unreachable *)
+
 val remove_imports : t
 (** removes imports and replaces them with nops *)
 
@@ -359,6 +355,9 @@ val reorder_globals : t
 val reorder_locals : t
 (** sorts locals by access frequency *)
 
+val reorder_types : t
+(** sorts private types by access frequency *)
+
 val rereloop : t
 (** re-optimize control flow using the relooper algorithm *)
 
@@ -464,6 +463,9 @@ val strip_eh : t
 val strip_target_features : t
 (** strip the wasm target features section *)
 
+val strip_toolchain_annotations : t
+(** strip all toolchain-specific code annotations *)
+
 val translate_to_exnref : t
 (** translate old Phase 3 EH instructions to new ones with exnref *)
 
@@ -483,7 +485,7 @@ val type_merging : t
 (** merge types to their supertypes where possible *)
 
 val type_ssa : t
-(** create new nominal types to help other optimizations *)
+(** create new types to help other optimizations *)
 
 val type_unfinalizing : t
 (** mark all types as non-final (open) *)

binaryen-archive/src/tag.c

@@ -0,0 +1,61 @@
+#define CAML_NAME_SPACE
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+#include <caml/alloc.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_binaryen_add_tag(value _module, value _name, value _params, value _results) {
+  CAMLparam4(_module, _name, _params, _results);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenType params = BinaryenType_val(_params);
+  BinaryenType results = BinaryenType_val(_results);
+  BinaryenTagRef tag = BinaryenAddTag(module, name, params, results);
+  CAMLreturn(alloc_BinaryenTagRef(tag));
+}
+
+CAMLprim value
+caml_binaryen_get_tag(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenTagRef tag = BinaryenGetTag(module, name);
+  CAMLreturn(alloc_BinaryenTagRef(tag));
+}
+
+CAMLprim value
+caml_binaryen_remove_tag(value _module, value _name) {
+  CAMLparam2(_module, _name);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* name = Safe_String_val(_name);
+  BinaryenRemoveTag(module, name);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_binaryen_tag_get_name(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  const char* name = BinaryenTagGetName(tag);
+  CAMLreturn(caml_copy_string(name));
+}
+
+CAMLprim value
+caml_binaryen_tag_get_params(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  BinaryenType ty = BinaryenTagGetParams(tag);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_tag_get_results(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  BinaryenType ty = BinaryenTagGetResults(tag);
+  CAMLreturn(alloc_BinaryenType(ty));
+}

binaryen-archive/src/tag.js

@@ -0,0 +1,43 @@
+//Provides: caml_binaryen_add_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_tag(wasm_mod, name, params, results) {
+  return wasm_mod.addTag(
+    caml_jsstring_of_string(name),
+    params,
+    results,
+  );
+}
+
+//Provides: caml_binaryen_get_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_get_tag(wasm_mod, name) {
+  return wasm_mod.getTag(caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_remove_tag
+//Requires: caml_jsstring_of_string
+function caml_binaryen_remove_tag(wasm_mod, name) {
+  return wasm_mod.removeTag(caml_jsstring_of_string(name));
+}
+
+//Provides: caml_binaryen_tag_get_name
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_get_name(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.name);
+}
+
+//Provides: caml_binaryen_tag_get_params
+//Requires: Binaryen
+function caml_binaryen_tag_get_params(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return tag_info.params;
+}
+
+//Provides: caml_binaryen_tag_get_results
+//Requires: Binaryen
+function caml_binaryen_tag_get_results(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return tag_info.results;
+}

binaryen-archive/src/tag.ml

@@ -0,0 +1,11 @@
+type t
+
+external add_tag : Module.t -> string -> Type.t -> Type.t -> t
+  = "caml_binaryen_add_tag"
+(** Module, name, params, result *)
+
+external get_tag : Module.t -> string -> t = "caml_binaryen_get_tag"
+external remove_tag : Module.t -> string -> unit = "caml_binaryen_remove_tag"
+external get_name : t -> string = "caml_binaryen_tag_get_name"
+external get_params : t -> Type.t = "caml_binaryen_tag_get_params"
+external get_results : t -> Type.t = "caml_binaryen_tag_get_results"

binaryen-archive/src/tag.mli

@@ -0,0 +1,8 @@
+type t
+
+val add_tag : Module.t -> string -> Type.t -> Type.t -> t
+val get_tag : Module.t -> string -> t
+val remove_tag : Module.t -> string -> unit
+val get_name : t -> string
+val get_params : t -> Type.t
+val get_results : t -> Type.t

binaryen-archive/src/type.c

@@ -147,14 +147,16 @@ caml_binaryen_type_create(value tys) {
 CAMLprim value
 caml_binaryen_type_expand(value _ty) {
   CAMLparam1(_ty);
+  CAMLlocal2(typeArray, field);
   BinaryenType ty = BinaryenType_val(_ty);
   int arity = BinaryenTypeArity(ty);
   BinaryenType* buf = malloc(sizeof(BinaryenType) * arity);
   BinaryenTypeExpand(ty, buf);
 
-  value typeArray = caml_alloc(arity, 0);
+  typeArray = caml_alloc(arity, 0);
   for (int i = 0; i < arity; i++) {
-    Field(typeArray, i) = alloc_BinaryenType(buf[i]);
+    field = alloc_BinaryenType(buf[i]);
+    Store_field(typeArray, i, field);
   }
 
   free(buf);
@@ -176,4 +178,4 @@ caml_binaryen_type_from_heap_type(value _ty, value _nullable) {
   bool nullable = Bool_val(_nullable);
   BinaryenType ty = BinaryenTypeFromHeapType(heapTy, nullable);
   CAMLreturn(alloc_BinaryenType(ty));
-}
+}

binaryen-archive/src/type.js

@@ -67,8 +67,7 @@ function caml_binaryen_type_structref() {
 //Provides: caml_binaryen_type_arrayref
 //Requires: Binaryen
 function caml_binaryen_type_arrayref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeArrayref();
+  return Binaryen.arrayref;
 }
 
 //Provides: caml_binaryen_type_stringref
@@ -80,22 +79,19 @@ function caml_binaryen_type_stringref() {
 //Provides: caml_binaryen_type_nullref
 //Requires: Binaryen
 function caml_binaryen_type_nullref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullref();
+  return Binaryen.nullref;
 }
 
 //Provides: caml_binaryen_type_null_externref
 //Requires: Binaryen
 function caml_binaryen_type_null_externref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullExternref();
+  return Binaryen.nullexternref;
 }
 
 //Provides: caml_binaryen_type_null_funcref
 //Requires: Binaryen
 function caml_binaryen_type_null_funcref() {
-  // TODO: Binaryen v111 didn't expose this directly
-  return Binaryen._BinaryenTypeNullFuncref();
+  return Binaryen.nullfuncref;
 }
 
 //Provides: caml_binaryen_type_unreachable
@@ -134,4 +130,4 @@ function caml_binaryen_type_is_nullable(typ) {
 //Requires: Binaryen
 function caml_binaryen_type_from_heap_type(typ, nullable) {
   return Binaryen._BinaryenTypeFromHeapType(typ, nullable);
-}
+}

binaryen-archive/src/type.ml

@@ -75,5 +75,8 @@ let auto = auto ()
 external create : t array -> t = "caml_binaryen_type_create"
 external expand : t -> t array = "caml_binaryen_type_expand"
 external is_nullable : t -> bool = "caml_binaryen_type_is_nullable"
-external from_heap_type : Heap_type.t -> t = "caml_binaryen_type_from_heap_type"
+
+external from_heap_type : Heap_type.t -> bool -> t
+  = "caml_binaryen_type_from_heap_type"
+
 external get_heap_type : t -> Heap_type.t = "caml_binaryen_type_get_heap_type"

binaryen-archive/src/type.mli

@@ -21,5 +21,5 @@ val auto : t
 val create : t array -> t
 val expand : t -> t array
 val is_nullable : t -> bool
-val from_heap_type : Heap_type.t -> t
+val from_heap_type : Heap_type.t -> bool -> t
 val get_heap_type : t -> Heap_type.t

binaryen-archive/src/type_builder.c

@@ -0,0 +1,180 @@
+#define CAML_NAME_SPACE
+#include <caml/alloc.h>
+#include <caml/mlvalues.h>
+#include <caml/fail.h>
+#include <caml/memory.h>
+
+#include "binaryen-c.h"
+#include "ocaml_helpers.h"
+
+CAMLprim value
+caml_type_builder_create(value _size) {
+  CAMLparam1(_size);
+  BinaryenIndex size = Int_val(_size);
+  CAMLreturn(alloc_TypeBuilderRef(TypeBuilderCreate(size)));
+}
+
+CAMLprim value
+caml_type_builder_grow(value _builder, value _count) {
+  CAMLparam2(_builder, _count);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex count = Int_val(_count);
+  TypeBuilderGrow(builder, count);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_type_builder_get_size(value _builder) {
+  CAMLparam1(_builder);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  CAMLreturn(Val_int(TypeBuilderGetSize(builder)));
+}
+
+CAMLprim value
+caml_type_builder_set_signature_type(value _builder, value _index, value _paramTypes, value _resultTypes) {
+  CAMLparam4(_builder, _index, _paramTypes, _resultTypes);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenType paramTypes = BinaryenType_val(_paramTypes);
+  BinaryenType resultTypes = BinaryenType_val(_resultTypes);
+  TypeBuilderSetSignatureType(builder, index, paramTypes, resultTypes);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_type_builder_set_struct_type(value _builder, value _index, value _fieldTypes, value _fieldPackedTypes, value _fieldMutables, value _numFields) {
+  CAMLparam5(_builder, _index, _fieldTypes, _fieldPackedTypes, _fieldMutables);
+  CAMLxparam1(_numFields);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  _fieldTypes = array_of_list(_fieldTypes);
+  int fieldTypesLen = array_length(_fieldTypes);
+  BinaryenType fieldTypes[fieldTypesLen];
+  for (int i = 0; i < fieldTypesLen; i++) {
+    fieldTypes[i] = BinaryenType_val(Field(_fieldTypes, i));
+  }
+  _fieldPackedTypes = array_of_list(_fieldPackedTypes);
+  int fieldPackedTypesLen = array_length(_fieldPackedTypes);
+  BinaryenPackedType fieldPackedTypes[fieldPackedTypesLen];
+  for (int i = 0; i < fieldPackedTypesLen; i++) {
+    fieldPackedTypes[i] = BinaryenPackedType_val(Field(_fieldPackedTypes, i));
+  }
+  _fieldMutables = array_of_list(_fieldMutables);
+  int fieldMutablesLen = array_length(_fieldMutables);
+  bool fieldMutables[fieldMutablesLen];
+  for (int i = 0; i < fieldMutablesLen; i++) {
+    fieldMutables[i] = Bool_val(Field(_fieldMutables, i));
+  }
+  int numFields = Int_val(_numFields);
+  TypeBuilderSetStructType(builder, index, fieldTypes, fieldPackedTypes, fieldMutables, numFields);
+  CAMLreturn(Val_unit);
+}
+CAMLprim value
+caml_type_builder_set_struct_type__bytecode(value * argv) {
+  return caml_type_builder_set_struct_type(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
+CAMLprim value
+caml_type_builder_set_array_type(value _builder, value _index, value _elementType, value _elementPackedType, value _elementMutable) {
+  CAMLparam5(_builder, _index, _elementType, _elementPackedType, _elementMutable);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenType elementType = BinaryenType_val(_elementType);
+  BinaryenPackedType elementPackedType = BinaryenPackedType_val(_elementPackedType);
+  bool elementMutable = Bool_val(_elementMutable);
+  TypeBuilderSetArrayType(builder, index, elementType, elementPackedType, elementMutable);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_type_builder_get_temp_heap_type(value _builder, value _index) {
+  CAMLparam2(_builder, _index);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(alloc_BinaryenHeapType(TypeBuilderGetTempHeapType(builder, index)));
+}
+
+CAMLprim value
+caml_type_builder_get_temp_tuple_type(value _builder, value _types) {
+  CAMLparam2(_builder, _types);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  _types = array_of_list(_types);
+  int typesLen = array_length(_types);
+  BinaryenType types[typesLen];
+  for (int i = 0; i < typesLen; i++) {
+    types[i] = BinaryenType_val(Field(_types, i));
+  }
+  CAMLreturn(alloc_BinaryenType(TypeBuilderGetTempTupleType(builder, types, typesLen)));
+}
+
+CAMLprim value
+caml_type_builder_get_temp_ref_type(value _builder, value _heapType, value _nullable) {
+  CAMLparam3(_builder, _heapType, _nullable);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  bool nullable = Bool_val(_nullable);
+  CAMLreturn(alloc_BinaryenType(TypeBuilderGetTempRefType(builder, heapType, nullable)));
+}
+
+CAMLprim value
+caml_type_builder_set_sub_type(value _builder, value _index, value _superType) {
+  CAMLparam3(_builder, _index, _superType);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenHeapType superType = BinaryenHeapType_val(_superType);
+  TypeBuilderSetSubType(builder, index, superType);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_type_builder_set_open(value _builder, value _index) {
+  CAMLparam2(_builder, _index);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  TypeBuilderSetOpen(builder, index);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_type_builder_create_rec_group(value _builder, value _index, value _length) {
+  CAMLparam3(_builder, _index, _length);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenIndex length = Int_val(_length);
+  TypeBuilderCreateRecGroup(builder, index, length);
+  CAMLreturn(Val_unit);
+}
+
+CAMLprim value
+caml_conv_heap_type(BinaryenHeapType heapType) {
+  return alloc_BinaryenHeapType(heapType);
+}
+
+CAMLprim value caml_type_builder_build_and_dispose(value _builder) {
+  CAMLparam1(_builder);
+  CAMLlocal5(arr, ok, error, tuple, field);
+  TypeBuilderRef builder = TypeBuilderRef_val(_builder);
+  BinaryenIndex size = TypeBuilderGetSize(builder);
+  BinaryenHeapType heapTypes[size + 1];
+  BinaryenIndex errorIndex;
+  TypeBuilderErrorReason errorReason;
+  bool success =
+      TypeBuilderBuildAndDispose(builder, heapTypes, &errorIndex, &errorReason);
+  if (success) {
+    arr = caml_alloc(size, 0);
+    for (mlsize_t i = 0; i < (mlsize_t)size; i++) {
+      field = alloc_BinaryenHeapType(heapTypes[i]);
+      Store_field(arr, i, field);
+    }
+    ok = caml_alloc_small(1, 0);
+    Store_field(ok, 0, arr);
+    CAMLreturn(ok);
+  } else {
+    error = caml_alloc_small(1, 1);
+    tuple = caml_alloc_small(2, 0);
+    Field(tuple, 0) = Val_int(errorIndex);
+    Field(tuple, 1) = Val_int(errorReason);
+    Store_field(error, 0, tuple);
+    CAMLreturn(error);
+  }
+}

binaryen-archive/src/type_builder.js

@@ -0,0 +1,116 @@
+//Provides: caml_type_builder_create
+//Requires: Binaryen
+function caml_type_builder_create(size) {
+  return new Binaryen.TypeBuilder(size);
+}
+
+//Provides: caml_type_builder_grow
+function caml_type_builder_grow(builder, count) {
+  builder.grow(count);
+}
+
+//Provides: caml_type_builder_get_size
+function caml_type_builder_get_size(builder) {
+  return builder.getSize();
+}
+
+//Provides: caml_type_builder_set_signature_type
+function caml_type_builder_set_signature_type(
+  builder,
+  index,
+  paramTypes,
+  resultTypes
+) {
+  builder.setSignatureType(index, paramTypes, resultTypes);
+}
+
+//Provides: caml_type_builder_set_struct_type
+//Requires: caml_list_to_js_array
+//Requires: caml_js_from_bool
+function caml_type_builder_set_struct_type(
+  builder,
+  index,
+  fieldTypes,
+  fieldPackedTypes,
+  fieldMutables,
+  numFields
+) {
+  var types = caml_list_to_js_array(fieldTypes);
+  var packedTypes = caml_list_to_js_array(fieldPackedTypes);
+  var mutables = caml_list_to_js_array(fieldMutables);
+  var fields = types.map(function (type, idx) {
+    return {
+      type,
+      packedType: packedTypes[idx],
+      mutable: caml_js_from_bool(mutables[idx]),
+    };
+  });
+  builder.setStructType(index, fields);
+}
+//Provides: caml_type_builder_set_struct_type__bytecode
+//Requires: caml_type_builder_set_struct_type
+function caml_type_builder_set_struct_type__bytecode() {
+  return caml_type_builder_set_struct_type(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
+//Provides: caml_type_builder_set_array_type
+function caml_type_builder_set_array_type(
+  builder,
+  index,
+  elementType,
+  elementPackedType,
+  elementMutable
+) {
+  builder.setArrayType(index, elementType, elementPackedType, elementMutable);
+}
+
+//Provides: caml_type_builder_get_temp_heap_type
+function caml_type_builder_get_temp_heap_type(builder, index) {
+  return builder.getTempHeapType(index);
+}
+
+//Provides: caml_type_builder_get_temp_tuple_type
+//Requires: caml_list_to_js_array
+function caml_type_builder_get_temp_tuple_type(builder, types) {
+  var tupleTypes = caml_list_to_js_array(types);
+  return builder.getTempTupleType(tupleTypes);
+}
+
+//Provides: caml_type_builder_get_temp_ref_type
+//Requires: caml_js_from_bool
+function caml_type_builder_get_temp_ref_type(builder, heapType, nullable) {
+  return builder.getTempRefType(heapType, caml_js_from_bool(nullable));
+}
+
+//Provides: caml_type_builder_set_sub_type
+function caml_type_builder_set_sub_type(builder, index, superType) {
+  builder.setSubType(index, superType);
+}
+
+//Provides: caml_type_builder_set_open
+function caml_type_builder_set_open(builder, index) {
+  builder.setOpen(index);
+}
+
+//Provides: caml_type_builder_create_rec_group
+function caml_type_builder_create_rec_group(builder, index, length) {
+  builder.createRecGroup(index, length);
+}
+
+//Provides: caml_type_builder_build_and_dispose
+//Requires: caml_js_to_array
+function caml_type_builder_build_and_dispose(builder) {
+  try {
+    var types = builder.buildAndDispose();
+    return [0, caml_js_to_array(types)];
+  } catch (e) {
+    return [1, [0, e.index, e.reason]];
+  }
+}