@grain/binaryen.ml 0.20.1 → 0.22.0

binaryen-archive/src/op.mli

@@ -210,6 +210,17 @@ val or_vec128 : t
 val xor_vec128 : t
 val and_not_vec128 : t
 val bitselect_vec128 : t
+val relaxed_fma_vec_f32x4 : t
+val relaxed_fms_vec_f32x4 : t
+val relaxed_fma_vec_f64x4 : t
+val relaxed_fms_vec_f64x4 : t
+val laneselect_i8x16 : t
+val laneselect_i16x8 : t
+val laneselect_i32x4 : t
+val laneselect_i64x2 : t
+val dot_i8x16_i7x16_add_s_to_vec_i32x4 : t
+val any_true_vec128 : t
+val popcnt_vec_i8x16 : t
 val abs_vec_i8x16 : t
 val neg_vec_i8x16 : t
 val all_true_vec_i8x16 : t
@@ -308,11 +319,39 @@ val narrow_u_vec_i16x8_to_vec_i8x16 : t
 val narrow_s_vec_i32x4_to_vec_i16x8 : t
 val narrow_u_vec_i32x4_to_vec_i16x8 : t
 val swizzle_vec8x16 : t
-val ref_is_null : t
-val ref_is_func : t
-val ref_is_data : t
-val ref_is_i31 : t
 val ref_as_non_null : t
-val ref_as_func : t
-val ref_as_data : t
-val ref_as_i31 : t
+val ref_as_extern_internalize : t
+val ref_as_extern_externalize : t
+val br_on_null : t
+val br_on_non_null : t
+val br_on_cast : t
+val br_on_cast_fail : t
+val string_new_utf8 : t
+val string_new_wtf8 : t
+val string_new_replace : t
+val string_new_wtf16 : t
+val string_new_utf8_array : t
+val string_new_wtf8_array : t
+val string_new_replace_array : t
+val string_new_wtf16_array : t
+val string_new_from_code_point : t
+val string_measure_utf8 : t
+val string_measure_wtf8 : t
+val string_measure_wtf16 : t
+val string_measure_is_usv : t
+val string_measure_wtf16_view : t
+val string_encode_utf8 : t
+val string_encode_wtf8 : t
+val string_encode_wtf16 : t
+val string_encode_utf8_array : t
+val string_encode_wtf8_array : t
+val string_encode_wtf16_array : t
+val string_as_wtf8 : t
+val string_as_wtf16 : t
+val string_as_iter : t
+val string_iter_move_advance : t
+val string_iter_move_rewind : t
+val string_slice_wtf8 : t
+val string_slice_wtf16 : t
+val string_eq_equal : t
+val string_eq_compare : t

binaryen-archive/src/passes.ml

@@ -15,6 +15,9 @@ let dae = "dae"
 (** removes arguments to calls in an lto-like manner, and optimizes where we removed *)
 let dae_optimizing = "dae-optimizing"
 
+(** refine and merge abstract (never-created) types *)
+let abstract_type_refining = "abstract-type-refining"
+
 (** reduce # of locals by coalescing *)
 let coalesce_locals = "coalesce-locals"
 
@@ -45,6 +48,9 @@ let denan = "denan"
 (** turns indirect calls into direct ones *)
 let directize = "directize"
 
+(** discards global effect info *)
+let discard_global_effects = "discard-global-effects"
+
 (** optimizes using the DataFlow SSA IR *)
 let dfo = "dfo"
 
@@ -81,6 +87,9 @@ let generate_dyncalls = "generate-dyncalls"
 (** generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support). *)
 let generate_i64_dyncalls = "generate-i64-dyncalls"
 
+(** generate global effect info (helps later passes) *)
+let generate_global_effects = "generate-global-effects"
+
 (** generate Stack IR *)
 let generate_stack_ir = "generate-stack-ir"
 
@@ -117,6 +126,9 @@ 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"
 
@@ -181,6 +193,19 @@ 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"
+
+(** creates specialized versions of functions (even if unhelpful) *)
+let monomorphize_always = "monomorphize-always"
+
+(** combines multiple memories into a single memory *)
+let multi_memory_lowering = "multi-memory-lowering"
+
+(** combines multiple memories into a single memory, trapping if the read or write is larger than the length of the memory's data *)
+let multi_memory_lowering_with_bounds_checks =
+  "multi-memory-lowering-with-bounds-checks"
+
 (** name list *)
 let nm = "nm"
 
@@ -196,6 +221,9 @@ let optimize_added_constants = "optimize-added-constants"
 (** optimizes added constants into load/store offsets, propagating them across locals too *)
 let optimize_added_constants_propagate = "optimize-added-constants-propagate"
 
+(** eliminate and reuse casts *)
+let optimize_casts = "optimize-casts"
+
 (** optimizes instruction combinations *)
 let optimize_instructions = "optimize-instructions"
 
@@ -266,9 +294,18 @@ let remove_unused_nonfunction_module_elements =
 (** removes names from locations that are never branched to *)
 let remove_unused_names = "remove-unused-names"
 
+(** remove unused private GC types *)
+let remove_unused_types = "remove-unused-types"
+
 (** sorts functions by access frequency *)
 let reorder_functions = "reorder-functions"
 
+(** sorts globals by access frequency *)
+let reorder_globals = "reorder-globals"
+
+(** sorts globals by access frequency (even if there are few) *)
+let reorder_globals_always = "reorder-globals-always"
+
 (** sorts locals by access frequency *)
 let reorder_locals = "reorder-locals"
 
@@ -293,6 +330,9 @@ let signature_pruning = "signature-pruning"
 (** apply more specific subtypes to signature types where possible *)
 let signature_refining = "signature-refining"
 
+(** lower sign-ext operations to wasm mvp *)
+let signext_lowering = "signext-lowering"
+
 (** miscellaneous globals-related optimizations *)
 let simplify_globals = "simplify-globals"
 
@@ -356,6 +396,12 @@ let trap_mode_clamp = "trap-mode-clamp"
 (** replace trapping operations with js semantics *)
 let trap_mode_js = "trap-mode-js"
 
+(** merge types to their supertypes where possible *)
+let type_merging = "type-merging"
+
+(** create new nominal types to help other optimizations *)
+let type_ssa = "type-ssa"
+
 (** removes local.tees, replacing them with sets and gets *)
 let untee = "untee"
 

binaryen-archive/src/passes.mli

@@ -15,6 +15,9 @@ val dae : t
 val dae_optimizing : t
 (** removes arguments to calls in an lto-like manner, and optimizes where we removed *)
 
+val abstract_type_refining : t
+(** refine and merge abstract (never-created) types *)
+
 val coalesce_locals : t
 (** reduce # of locals by coalescing *)
 
@@ -45,6 +48,9 @@ val denan : t
 val directize : t
 (** turns indirect calls into direct ones *)
 
+val discard_global_effects : t
+(** discards global effect info *)
+
 val dfo : t
 (** optimizes using the DataFlow SSA IR *)
 
@@ -81,6 +87,9 @@ val generate_dyncalls : t
 val generate_i64_dyncalls : t
 (** generate dynCall functions used by emscripten ABI, but only for functions with i64 in their signature (which cannot be invoked via the wasm table without JavaScript BigInt support). *)
 
+val generate_global_effects : t
+(** generate global effect info (helps later passes) *)
+
 val generate_stack_ir : t
 (** generate Stack IR *)
 
@@ -117,6 +126,9 @@ 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 *)
 
@@ -180,6 +192,18 @@ val mod_asyncify_always_and_only_unwind : t
 val mod_asyncify_never_unwind : t
 (** apply the assumption that asyncify never unwinds *)
 
+val monomorphize : t
+(** creates specialized versions of functions *)
+
+val monomorphize_always : t
+(** creates specialized versions of functions (even if unhelpful) *)
+
+val multi_memory_lowering : t
+(** combines multiple memories into a single memory *)
+
+val multi_memory_lowering_with_bounds_checks : t
+(** combines multiple memories into a single memory, trapping if the read or write is larger than the length of the memory's data *)
+
 val nm : t
 (** name list *)
 
@@ -195,6 +219,9 @@ val optimize_added_constants : t
 val optimize_added_constants_propagate : t
 (** optimizes added constants into load/store offsets, propagating them across locals too *)
 
+val optimize_casts : t
+(** eliminate and reuse casts *)
+
 val optimize_instructions : t
 (** optimizes instruction combinations *)
 
@@ -264,9 +291,18 @@ val remove_unused_nonfunction_module_elements : t
 val remove_unused_names : t
 (** removes names from locations that are never branched to *)
 
+val remove_unused_types : t
+(** remove unused private GC types *)
+
 val reorder_functions : t
 (** sorts functions by access frequency *)
 
+val reorder_globals : t
+(** sorts globals by access frequency *)
+
+val reorder_globals_always : t
+(** sorts globals by access frequency (even if there are few) *)
+
 val reorder_locals : t
 (** sorts locals by access frequency *)
 
@@ -291,6 +327,9 @@ val signature_pruning : t
 val signature_refining : t
 (** apply more specific subtypes to signature types where possible *)
 
+val signext_lowering : t
+(** lower sign-ext operations to wasm mvp *)
+
 val simplify_globals : t
 (** miscellaneous globals-related optimizations *)
 
@@ -354,6 +393,12 @@ val trap_mode_clamp : t
 val trap_mode_js : t
 (** replace trapping operations with js semantics *)
 
+val type_merging : t
+(** merge types to their supertypes where possible *)
+
+val type_ssa : t
+(** create new nominal types to help other optimizations *)
+
 val untee : t
 (** removes local.tees, replacing them with sets and gets *)
 

binaryen-archive/src/signature_type.c

@@ -0,0 +1,23 @@
+#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_signature_type_get_params(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenType ty = BinaryenSignatureTypeGetParams(heapType);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_signature_type_get_results(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenType ty = BinaryenSignatureTypeGetResults(heapType);
+  CAMLreturn(alloc_BinaryenType(ty));
+}

binaryen-archive/src/signature_type.js

@@ -0,0 +1,11 @@
+//Provides: caml_binaryen_signature_type_get_params
+//Requires: Binaryen
+function caml_binaryen_signature_type_get_params(heapType) {
+  return Binaryen._BinaryenSignatureTypeGetParams(heapType);
+}
+
+//Provides: caml_binaryen_signature_type_get_results
+//Requires: Binaryen
+function caml_binaryen_signature_type_get_results(heapType) {
+  return Binaryen._BinaryenSignatureTypeGetResults(heapType);
+}

binaryen-archive/src/signature_type.ml

@@ -0,0 +1,5 @@
+external get_params : Heap_type.t -> Type.t
+  = "caml_binaryen_signature_type_get_params"
+
+external get_results : Heap_type.t -> Type.t
+  = "caml_binaryen_signature_type_get_results"

binaryen-archive/src/signature_type.mli

@@ -0,0 +1,2 @@
+val get_params : Heap_type.t -> Type.t
+val get_results : Heap_type.t -> Type.t

binaryen-archive/src/struct_type.c

@@ -0,0 +1,39 @@
+#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_struct_type_get_num_fields(value _heapType) {
+  CAMLparam1(_heapType);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  CAMLreturn(Val_int(BinaryenStructTypeGetNumFields(heapType)));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_get_field_type(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  BinaryenType ty = BinaryenStructTypeGetFieldType(heapType, index);
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_get_field_packed_type(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(Val_int(BinaryenStructTypeGetFieldPackedType(heapType, index)));
+}
+
+CAMLprim value
+caml_binaryen_struct_type_is_field_mutable(value _heapType, value _index) {
+  CAMLparam2(_heapType, _index);
+  BinaryenHeapType heapType = BinaryenHeapType_val(_heapType);
+  BinaryenIndex index = Int_val(_index);
+  CAMLreturn(Val_bool(BinaryenStructTypeIsFieldMutable(heapType, index)));
+}

binaryen-archive/src/struct_type.js

@@ -0,0 +1,23 @@
+//Provides: caml_binaryen_struct_type_get_num_fields
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_num_fields(heapType) {
+  return Binaryen._BinaryenStructTypeGetNumFields(heapType);
+}
+
+//Provides: caml_binaryen_struct_type_get_field_type
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_field_type(heapType, index) {
+  return Binaryen._BinaryenStructTypeGetFieldType(heapType, index);
+}
+
+//Provides: caml_binaryen_struct_type_get_field_packed_type
+//Requires: Binaryen
+function caml_binaryen_struct_type_get_field_packed_type(heapType, index) {
+  return Binaryen._BinaryenStructTypeGetFieldPackedType(heapType, index);
+}
+
+//Provides: caml_binaryen_struct_type_is_field_mutable
+//Requires: Binaryen
+function caml_binaryen_struct_type_is_field_mutable(heapType, index) {
+  return Binaryen._BinaryenStructTypeIsFieldMutable(heapType, index);
+}

binaryen-archive/src/struct_type.ml

@@ -0,0 +1,11 @@
+external get_num_fields : Heap_type.t -> int
+  = "caml_binaryen_struct_type_get_num_fields"
+
+external get_field_type : Heap_type.t -> int -> Type.t
+  = "caml_binaryen_struct_type_get_field_type"
+
+external get_field_packed_type : Heap_type.t -> int -> Packed_type.t
+  = "caml_binaryen_struct_type_get_field_packed_type"
+
+external is_field_mutable : Heap_type.t -> int -> bool
+  = "caml_binaryen_struct_type_is_field_mutable"

binaryen-archive/src/struct_type.mli

@@ -0,0 +1,4 @@
+val get_num_fields : Heap_type.t -> int
+val get_field_type : Heap_type.t -> int -> Type.t
+val get_field_packed_type : Heap_type.t -> int -> Packed_type.t
+val is_field_mutable : Heap_type.t -> int -> bool

binaryen-archive/src/{binaryen_stubs_tables.c → table.c}

@@ -7,31 +7,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenTableRef */
-static value alloc_BinaryenTableRef(BinaryenTableRef table)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenTableRef), 0, 1);
-  BinaryenTableRef_val(v) = table;
-  return v;
-}
-
-/* Allocating an OCaml custom block to hold the given BinaryenElementSegmentRef */
-static value alloc_BinaryenElementSegmentRef(BinaryenElementSegmentRef elem)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenElementSegmentRef), 0, 1);
-  BinaryenElementSegmentRef_val(v) = elem;
-  return v;
-}
-
-/* Allocating an OCaml custom block to hold the given BinaryenExpressionRef */
-static value alloc_BinaryenExpressionRef(BinaryenExpressionRef exp)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenExpressionRef), 0, 1);
-  BinaryenExpressionRef_val(v) = exp;
-  return v;
-}
-
 CAMLprim value
 caml_binaryen_add_table(value _module, value _table, value _initial, value _maximum, value _tableType) {
   CAMLparam5(_module, _table, _initial, _maximum, _tableType);

binaryen-archive/src/{binaryen_stubs_types.c → type.c}

@@ -6,16 +6,6 @@
 #include "binaryen-c.h"
 #include "ocaml_helpers.h"
 
-
-/* Allocating an OCaml custom block to hold the given BinaryenType */
-static value alloc_BinaryenType(BinaryenType typ)
-{
-  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenType), 0, 1);
-  BinaryenType_val(v) = typ;
-  return v;
-}
-
-
 CAMLprim value
 caml_binaryen_type_none(value unit) {
   CAMLparam1(unit);
@@ -87,9 +77,16 @@ caml_binaryen_type_i31ref(value unit) {
 }
 
 CAMLprim value
-caml_binaryen_type_dataref(value unit) {
+caml_binaryen_type_structref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeStructref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_arrayref(value unit) {
   CAMLparam1(unit);
-  BinaryenType ty = BinaryenTypeDataref();
+  BinaryenType ty = BinaryenTypeArrayref();
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
@@ -121,6 +118,27 @@ caml_binaryen_type_stringview_iter(value unit) {
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
+CAMLprim value
+caml_binaryen_type_nullref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_null_externref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullExternref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
+CAMLprim value
+caml_binaryen_type_null_funcref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeNullFuncref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
 CAMLprim value
 caml_binaryen_type_unreachable(value unit) {
   CAMLparam1(unit);

binaryen-archive/src/{binaryen_stubs_types.js → type.js}

@@ -58,10 +58,17 @@ function caml_binaryen_type_i31ref() {
   return Binaryen.i31ref;
 }
 
-//Provides: caml_binaryen_type_dataref
+//Provides: caml_binaryen_type_structref
 //Requires: Binaryen
-function caml_binaryen_type_dataref() {
-  return Binaryen.dataref;
+function caml_binaryen_type_structref() {
+  return Binaryen.structref;
+}
+
+//Provides: caml_binaryen_type_arrayref
+//Requires: Binaryen
+function caml_binaryen_type_arrayref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeArrayref();
 }
 
 //Provides: caml_binaryen_type_stringref
@@ -88,6 +95,27 @@ function caml_binaryen_type_stringview_iter() {
   return Binaryen.stringview_iter;
 }
 
+//Provides: caml_binaryen_type_nullref
+//Requires: Binaryen
+function caml_binaryen_type_nullref() {
+  // TODO: Binaryen v111 didn't expose this directly
+  return Binaryen._BinaryenTypeNullref();
+}
+
+//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();
+}
+
+//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();
+}
+
 //Provides: caml_binaryen_type_unreachable
 //Requires: Binaryen
 function caml_binaryen_type_unreachable() {

binaryen-archive/src/type.ml

@@ -40,9 +40,13 @@ external i31ref : unit -> t = "caml_binaryen_type_i31ref"
 
 let i31ref = i31ref ()
 
-external dataref : unit -> t = "caml_binaryen_type_dataref"
+external structref : unit -> t = "caml_binaryen_type_structref"
 
-let dataref = dataref ()
+let structref = structref ()
+
+external arrayref : unit -> t = "caml_binaryen_type_arrayref"
+
+let arrayref = arrayref ()
 
 external stringref : unit -> t = "caml_binaryen_type_stringref"
 
@@ -60,6 +64,18 @@ external stringview_iter : unit -> t = "caml_binaryen_type_stringview_iter"
 
 let stringview_iter = stringview_iter ()
 
+external nullref : unit -> t = "caml_binaryen_type_nullref"
+
+let nullref = nullref ()
+
+external null_externref : unit -> t = "caml_binaryen_type_null_externref"
+
+let null_externref = null_externref ()
+
+external null_funcref : unit -> t = "caml_binaryen_type_null_funcref"
+
+let null_funcref = null_funcref ()
+
 external unreachable : unit -> t = "caml_binaryen_type_unreachable"
 
 let unreachable = unreachable ()

binaryen-archive/src/type.mli

@@ -10,11 +10,15 @@ val funcref : t
 val anyref : t
 val eqref : t
 val i31ref : t
-val dataref : t
+val structref : t
+val arrayref : t
 val stringref : t
 val stringview_wtf8 : t
 val stringview_wtf16 : t
 val stringview_iter : t
+val nullref : t
+val null_externref : t
+val null_funcref : t
 val unreachable : t
 val auto : t
 val create : t array -> t

binaryen-archive/src/{binaryen_stubs_type_system.c → type_system.c}

@@ -7,12 +7,6 @@
 #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);

binaryen-archive/src/{binaryen_stubs_type_system.js → type_system.js}

@@ -1,9 +1,3 @@
-//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() {

binaryen-archive/src/type_system.ml

@@ -1,6 +1,5 @@
 type t = int
 
-external equirecursive : unit -> t = "caml_binaryen_type_system_equirecursive"
 external nominal : unit -> t = "caml_binaryen_type_system_nominal"
 external isorecursive : unit -> t = "caml_binaryen_type_system_isorecursive"
 external get_type_system : unit -> t = "caml_binaryen_get_type_system"

binaryen-archive/src/type_system.mli

@@ -1,6 +1,5 @@
 type t
 
-val equirecursive : unit -> t
 val nominal : unit -> t
 val isorecursive : unit -> t
 val get_type_system : unit -> t