@grain/binaryen.ml 0.35.0 → 0.37.0

binaryen-archive/src/module.ml

@@ -98,6 +98,15 @@ module Feature = struct
 
   let call_indirect_overlong = call_indirect_overlong ()
 
+  external relaxed_atomics : unit -> t = "caml_binaryen_feature_relaxed_atomics"
+
+  let relaxed_atomics = relaxed_atomics ()
+
+  external custom_page_sizes : unit -> t
+    = "caml_binaryen_feature_custom_page_sizes"
+
+  let custom_page_sizes = custom_page_sizes ()
+
   external all : unit -> t = "caml_binaryen_feature_all"
 
   let all = all ()

binaryen-archive/src/module.mli

@@ -25,6 +25,8 @@ module Feature : sig
   val fp16 : t
   val bulk_memory_opt : t
   val call_indirect_overlong : t
+  val relaxed_atomics : t
+  val custom_page_sizes : t
   val all : t
 end
 

binaryen-archive/src/module_feature.c

@@ -155,6 +155,18 @@ caml_binaryen_feature_call_indirect_overlong(value unit) {
   CAMLreturn(Val_int(BinaryenFeatureCallIndirectOverlong()));
 }
 
+CAMLprim value
+caml_binaryen_feature_relaxed_atomics(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenFeatureRelaxedAtomics()));
+}
+
+CAMLprim value
+caml_binaryen_feature_custom_page_sizes(value unit) {
+  CAMLparam1(unit);
+  CAMLreturn(Val_int(BinaryenFeatureCustomPageSizes()));
+}
+
 CAMLprim value
 caml_binaryen_feature_all(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/module_feature.js

@@ -140,6 +140,18 @@ function caml_binaryen_feature_call_indirect_overlong() {
   return Binaryen.Features.BulkMemoryOpt;
 }
 
+//Provides: caml_binaryen_feature_relaxed_atomics
+//Requires: Binaryen
+function caml_binaryen_feature_relaxed_atomics() {
+  return Binaryen.Features.RelaxedAtomics;
+}
+
+//Provides: caml_binaryen_feature_custom_page_sizes
+//Requires: Binaryen
+function caml_binaryen_feature_custom_page_sizes() {
+  return Binaryen.Features.CustomPageSizes;
+}
+
 //Provides: caml_binaryen_feature_all
 //Requires: Binaryen
 function caml_binaryen_feature_all() {

binaryen-archive/src/ocaml_helpers.c

@@ -3,6 +3,7 @@
 #include <caml/fail.h>
 #include <caml/memory.h>
 #include <caml/callback.h>
+#include <caml/alloc.h>
 
 #include "ocaml_helpers.h"
 
@@ -102,6 +103,14 @@ value alloc_BinaryenElementSegmentRef(BinaryenElementSegmentRef elem)
   return v;
 }
 
+/* Allocating an OCaml custom block to hold the given TypeBuilderRef */
+value alloc_TypeBuilderRef(TypeBuilderRef builder)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(TypeBuilderRef), 0, 1);
+  TypeBuilderRef_val(v) = builder;
+  return v;
+}
+
 CAMLprim value
 array_of_list(value list) {
   CAMLparam1(list);

binaryen-archive/src/ocaml_helpers.h

@@ -23,6 +23,7 @@ static struct custom_operations binaryen_ops = {
 
 #define BinaryenModuleRef_val(v) (*((BinaryenModuleRef*) Data_custom_val(v)))
 #define BinaryenType_val(v) (*((BinaryenType*) Data_custom_val(v)))
+#define BinaryenPackedType_val(v) Int_val(v)
 #define BinaryenHeapType_val(v) (*((BinaryenHeapType*) Data_custom_val(v)))
 #define BinaryenExpressionRef_val(v) (*((BinaryenExpressionRef*) Data_custom_val(v)))
 #define BinaryenOp_val(v) (*((BinaryenOp*) Data_custom_val(v)))
@@ -33,6 +34,7 @@ static struct custom_operations binaryen_ops = {
 #define BinaryenExportRef_val(v) (*((BinaryenExportRef*) Data_custom_val(v)))
 #define BinaryenTableRef_val(v) (*((BinaryenTableRef*) Data_custom_val(v)))
 #define BinaryenElementSegmentRef_val(v) (*((BinaryenElementSegmentRef*) Data_custom_val(v)))
+#define TypeBuilderRef_val(v) (*((TypeBuilderRef*) Data_custom_val(v)))
 
 #define Val_none Val_int(0)
 #define Some_val(v) Field(v, 0)
@@ -78,6 +80,9 @@ value alloc_BinaryenTableRef(BinaryenTableRef table);
 /* Allocating an OCaml custom block to hold the given BinaryenElementSegmentRef */
 value alloc_BinaryenElementSegmentRef(BinaryenElementSegmentRef elem);
 
+/* Allocating an OCaml custom block to hold the given TypeBuilderRef */
+value alloc_TypeBuilderRef(TypeBuilderRef builder);
+
 CAMLprim value
 array_of_list(value list);
 

binaryen-archive/src/ocaml_helpers.js

@@ -0,0 +1,11 @@
+//Provides: caml_ml_output_str_stdout
+//Requires: caml_ml_std_channel_id
+//Requires: caml_string_of_jsstring
+//Requires: caml_ml_output, caml_ml_string_length
+function caml_ml_output_str_stdout(text) {
+  var chanid = caml_ml_std_channel_id[1]; // stdout
+  
+  const raw_string = caml_string_of_jsstring(text);
+  const length = caml_ml_string_length(raw_string);
+  caml_ml_output(chanid, raw_string, 0, length);
+}

binaryen-archive/src/passes.ml

@@ -16,6 +16,9 @@ let dae = "dae"
     removed *)
 let dae_optimizing = "dae-optimizing"
 
+(** Experimental reimplementation of DAE *)
+let dae_2 = "dae-2"
+
 (** refine and merge abstract (never-created) types *)
 let abstract_type_refining = "abstract-type-refining"
 
@@ -106,6 +109,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 +158,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"
 
@@ -321,6 +324,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"
 
@@ -468,6 +474,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"
 
@@ -486,7 +495,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

@@ -16,6 +16,9 @@ val dae_optimizing : t
 (** removes arguments to calls in an lto-like manner, and optimizes where we
     removed *)
 
+val dae_2 : t
+(** Experimental reimplementation of DAE *)
+
 val abstract_type_refining : t
 (** refine and merge abstract (never-created) types *)
 
@@ -106,6 +109,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 +155,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 *)
 
@@ -316,6 +319,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 *)
 
@@ -352,7 +358,7 @@ val reorder_globals : t
 val reorder_locals : t
 (** sorts locals by access frequency *)
 
-val reorder_types: t
+val reorder_types : t
 (** sorts private types by access frequency *)
 
 val rereloop : t
@@ -460,6 +466,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 *)
 
@@ -479,7 +488,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/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 v125 doesn't expose this directly
-  return Binaryen._BinaryenTypeArrayref();
+  return Binaryen.arrayref;
 }
 
 //Provides: caml_binaryen_type_stringref
@@ -131,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]];
+  }
+}

binaryen-archive/src/type_builder.ml

@@ -0,0 +1,67 @@
+type t
+
+type struct_field = {
+  type_ : Type.t;
+  packed_type : Packed_type.t;
+  mutable_ : bool;
+}
+
+(* Source: https://github.com/WebAssembly/binaryen/blob/64ba23996a10e229d46e41eb37736a55af87f79a/src/binaryen-c.h#L3618 *)
+type error =
+  | SelfSupertype of int
+  | InvalidSupertype of int
+  | ForwardSupertypeReference of int
+  | ForwardChildReference of int
+
+external make : int -> t = "caml_type_builder_create"
+external grow : t -> int -> unit = "caml_type_builder_grow"
+external size : t -> int = "caml_type_builder_get_size"
+
+external set_signature_type : t -> int -> Type.t -> Type.t -> unit
+  = "caml_type_builder_set_signature_type"
+
+external set_struct_type :
+  t -> int -> Type.t list -> Packed_type.t list -> bool list -> int -> unit
+  = "caml_type_builder_set_struct_type__bytecode"
+    "caml_type_builder_set_struct_type"
+
+let set_struct_type builder index fields =
+  let split_fields fields =
+    List.fold_right
+      (fun { type_; packed_type; mutable_ } (types, packed_types, mutables) ->
+        (type_ :: types, packed_type :: packed_types, mutable_ :: mutables))
+      fields ([], [], [])
+  in
+  let types, packed_types, mutables = split_fields fields in
+  set_struct_type builder index types packed_types mutables (List.length types)
+
+external set_array_type : t -> int -> Type.t -> Packed_type.t -> bool -> unit
+  = "caml_type_builder_set_array_type"
+
+external get_temp_heap_type : t -> int -> Heap_type.t
+  = "caml_type_builder_get_temp_heap_type"
+
+external get_temp_tuple_type : t -> Type.t list -> Type.t
+  = "caml_type_builder_get_temp_tuple_type"
+
+external get_temp_ref_type : t -> Heap_type.t -> bool -> Type.t
+  = "caml_type_builder_get_temp_ref_type"
+
+external set_sub_type : t -> int -> Heap_type.t -> unit
+  = "caml_type_builder_set_sub_type"
+
+external set_open : t -> int -> unit = "caml_type_builder_set_open"
+
+external create_rec_group : t -> int -> int -> unit
+  = "caml_type_builder_create_rec_group"
+
+external build_and_dispose : t -> (Heap_type.t array, int * int) result
+  = "caml_type_builder_build_and_dispose"
+
+let build_and_dispose builder =
+  match build_and_dispose builder with
+  | Ok types -> Ok (Array.to_list types)
+  | Error (idx, 0) -> Error (SelfSupertype idx)
+  | Error (idx, 1) -> Error (InvalidSupertype idx)
+  | Error (idx, 2) -> Error (ForwardSupertypeReference idx)
+  | Error (idx, _) -> Error (ForwardChildReference idx)