@grain/binaryen.ml 0.20.0 → 0.21.0

binaryen-archive/src/op.mli

@@ -316,3 +316,41 @@ 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 : unit -> t
+val ref_as_extern_externalize : unit -> t
+val br_on_null : unit -> t
+val br_on_non_null : unit -> t
+val br_on_cast : unit -> t
+val br_on_cast_fail : unit -> t
+val br_on_func : unit -> t
+val br_on_non_func : unit -> t
+val br_on_data : unit -> t
+val br_on_non_data : unit -> t
+val br_on_i31 : unit -> t
+val br_on_non_i31 : unit -> t
+val string_new_utf8 : unit -> t
+val string_new_wtf8 : unit -> t
+val string_new_replace : unit -> t
+val string_new_wtf16 : unit -> t
+val string_new_utf8_array : unit -> t
+val string_new_wtf8_array : unit -> t
+val string_new_replace_array : unit -> t
+val string_new_wtf16_array : unit -> t
+val string_measure_utf8 : unit -> t
+val string_measure_wtf8 : unit -> t
+val string_measure_wtf16 : unit -> t
+val string_measure_is_usv : unit -> t
+val string_measure_wtf16_view : unit -> t
+val string_encode_utf8 : unit -> t
+val string_encode_wtf8 : unit -> t
+val string_encode_wtf16 : unit -> t
+val string_encode_utf8_array : unit -> t
+val string_encode_wtf8_array : unit -> t
+val string_encode_wtf16_array : unit -> t
+val string_as_wtf8 : unit -> t
+val string_as_wtf16 : unit -> t
+val string_as_iter : unit -> t
+val string_iter_move_advance : unit -> t
+val string_iter_move_rewind : unit -> t
+val string_slice_wtf8 : unit -> t
+val string_slice_wtf16 : unit -> t

binaryen-archive/src/passes.ml

@@ -45,6 +45,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,17 +84,26 @@ 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"
 
 (** refine the types of globals *)
 let global_refining = "global-refining"
 
+(** globally optimize struct values *)
+let gsi = "gsi"
+
 (** globally optimize GC types *)
 let gto = "gto"
 
-(** globally optimize struct values *)
-let gsi = "gsi"
+(** Grand Unified Flow Analysis: optimize the entire program using information about what content can actually appear in each location *)
+let gufa = "gufa"
+
+(** GUFA plus local optimizations in functions we modified *)
+let gufa_optimizing = "gufa-optimizing"
 
 (** apply more specific subtypes to type fields where possible *)
 let type_refining = "type-refining"
@@ -111,6 +123,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"
 
@@ -175,6 +190,15 @@ 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"
+
 (** name list *)
 let nm = "nm"
 
@@ -190,6 +214,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"
 
@@ -263,6 +290,12 @@ let remove_unused_names = "remove-unused-names"
 (** 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"
 
@@ -287,6 +320,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"
 

binaryen-archive/src/passes.mli

@@ -45,6 +45,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,17 +84,26 @@ 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 *)
 
 val global_refining : t
 (** refine the types of globals *)
 
+val gsi : t
+(** globally optimize struct values *)
+
 val gto : t
 (** globally optimize GC types *)
 
-val gsi : t
-(** globally optimize struct values *)
+val gufa : t
+(** Grand Unified Flow Analysis: optimize the entire program using information about what content can actually appear in each location *)
+
+val gufa_optimizing : t
+(** GUFA plus local optimizations in functions we modified *)
 
 val type_refining : t
 (** apply more specific subtypes to type fields where possible *)
@@ -111,6 +123,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 *)
 
@@ -174,6 +189,15 @@ 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 nm : t
 (** name list *)
 
@@ -189,6 +213,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 *)
 
@@ -261,6 +288,12 @@ val remove_unused_names : t
 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 *)
 
@@ -285,6 +318,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 *)
 

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);
@@ -93,6 +83,13 @@ caml_binaryen_type_dataref(value unit) {
   CAMLreturn(alloc_BinaryenType(ty));
 }
 
+CAMLprim value
+caml_binaryen_type_arrayref(value unit) {
+  CAMLparam1(unit);
+  BinaryenType ty = BinaryenTypeArrayref();
+  CAMLreturn(alloc_BinaryenType(ty));
+}
+
 CAMLprim value
 caml_binaryen_type_stringref(value unit) {
   CAMLparam1(unit);
@@ -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}

@@ -64,6 +64,13 @@ function caml_binaryen_type_dataref() {
   return Binaryen.dataref;
 }
 
+//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
 //Requires: Binaryen
 function 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

@@ -44,6 +44,10 @@ external dataref : unit -> t = "caml_binaryen_type_dataref"
 
 let dataref = dataref ()
 
+external arrayref : unit -> t = "caml_binaryen_type_arrayref"
+
+let arrayref = arrayref ()
+
 external stringref : unit -> t = "caml_binaryen_type_stringref"
 
 let stringref = 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

@@ -11,10 +11,14 @@ val anyref : t
 val eqref : t
 val i31ref : t
 val dataref : 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/test/test.expected

@@ -3,7 +3,7 @@
 )
 (table.size $table)
 (table.grow $table
- (ref.null func)
+ (ref.null nofunc)
  (i32.const 0)
 )
 (module
@@ -33,7 +33,7 @@
    (i32.add
     (select
      (local.get $0)
-     (i32.load8_s
+     (i32.load
       (local.get $1)
      )
      (i32.const 1)
@@ -85,7 +85,7 @@
   (i32.add
    (select
     (local.get $0)
-    (i32.load8_s
+    (i32.load
      (local.get $1)
     )
     (i32.const 1)
@@ -133,7 +133,7 @@
   (i32.add
    (select
     (local.get $0)
-    (i32.load8_s
+    (i32.load
      (local.get $1)
     )
     (i32.const 1)
@@ -180,7 +180,7 @@
  (func $0 (param $0 i32) (param $1 i32) (result i32)
   local.get $0
   local.get $1
-  i32.load8_s $0
+  i32.load $0
   i32.const 1
   select
   local.get $1

binaryen-archive/test/test.ml

@@ -36,6 +36,7 @@ let _ =
     = "external_base_name")
 
 let _ = assert (Memory.is_shared import_wasm_mod "internal_name" = true)
+let _ = assert (Memory.is_64 import_wasm_mod "internal_name" = false)
 
 (* Testing Return.get_value *)
 let _ =
@@ -58,7 +59,7 @@ let x () = Expression.Local_get.make wasm_mod 0 Type.int32
 let y () = Expression.Local_get.make wasm_mod 1 Type.int32
 
 let load =
-  Expression.Load.make wasm_mod 1 ~signed:true 0 0 Type.int32 (y ()) "0"
+  Expression.Load.make wasm_mod 4 ~signed:false 0 0 Type.int32 (y ()) "0"
 
 let select =
   Expression.Select.make wasm_mod
@@ -169,14 +170,14 @@ let _ = assert (Memory.has_memory wasm_mod = false)
 let _ =
   Memory.set_memory wasm_mod 1 Memory.unlimited "memory"
     [ segment; passive_segment ]
-    false "0"
+    false false "0"
 
 let _ = assert (Memory.has_memory wasm_mod = true)
 let _ = assert (Memory.get_initial wasm_mod "0" = 1)
 let _ = assert (Memory.has_max wasm_mod "0" = false)
 let _ = assert (Memory.get_max wasm_mod "0" = Memory.unlimited)
 let max_memory_wasm_mod = Module.create ()
-let _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false "0"
+let _ = Memory.set_memory max_memory_wasm_mod 1 2 "memory" [] false false "0"
 let _ = assert (Memory.has_max max_memory_wasm_mod "0" = true)
 let _ = assert (Memory.get_max max_memory_wasm_mod "0" = 2)
 
@@ -204,6 +205,7 @@ let _ =
        Type.int32)
 
 let _ = Export.add_function_export wasm_mod "hello" "hello"
+let _ = Module.validate wasm_mod
 
 (* Shouldn't actually do anything since we aren't doing function renames *)
 let _ = Module.update_maps wasm_mod
@@ -233,7 +235,20 @@ let new_mod = Module.read byts
 
 let _ =
   Module.run_passes new_mod
-    [ Passes.name_types; Passes.merge_similar_functions; Passes.spill_pointers ]
+    [
+      Passes.generate_global_effects;
+      Passes.name_types;
+      Passes.merge_similar_functions;
+      Passes.spill_pointers;
+      Passes.gufa;
+      Passes.gufa_optimizing;
+      Passes.reorder_globals;
+      Passes.optimize_casts;
+      Passes.multi_memory_lowering;
+      Passes.monomorphize;
+      Passes.signext_lowering;
+      Passes.discard_global_effects;
+    ]
 
 let _ =
   Module.set_features new_mod
@@ -251,10 +266,10 @@ let _ =
       Module.Feature.multivalue;
       Module.Feature.gc;
       Module.Feature.memory64;
-      Module.Feature.typed_function_references;
       Module.Feature.relaxed_simd;
       Module.Feature.extended_const;
       Module.Feature.strings;
+      Module.Feature.multi_memories;
       Module.Feature.all;
     ]