@grain/binaryen.ml 0.33.0 → 0.34.0

binaryen-archive/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## [0.34.0](https://github.com/grain-lang/binaryen.ml/compare/v0.33.0...v0.34.0) (2025-11-12)
+
+
+### ⚠ BREAKING CHANGES
+
+* Update Passes api for Binaryen v124
+* Upgrade to Binaryen v124 ([#241](https://github.com/grain-lang/binaryen.ml/issues/241))
+
+### Features
+
+* Update Passes api for Binaryen v124 ([305137a](https://github.com/grain-lang/binaryen.ml/commit/305137a264049f3f38bf8828c57aad190195ca49))
+* Upgrade to Binaryen v124 ([#241](https://github.com/grain-lang/binaryen.ml/issues/241)) ([02829f8](https://github.com/grain-lang/binaryen.ml/commit/02829f805cd3133bb4b04c83abac8380996bd0ec))
+
 ## [0.33.0](https://github.com/grain-lang/binaryen.ml/compare/v0.32.0...v0.33.0) (2025-11-12)
 
 

binaryen-archive/binaryen.opam

@@ -1,5 +1,5 @@
 opam-version: "2.0"
-version: "0.33.0"
+version: "0.34.0"
 synopsis: "OCaml bindings for Binaryen"
 maintainer: "oscar@grain-lang.org"
 author: "Oscar Spencer"
@@ -16,6 +16,6 @@ depends: [
   "dune" {>= "3.0.0"}
   "dune-configurator" {>= "3.0.0"}
   "js_of_ocaml-compiler" {>= "6.0.0" < "7.0.0"}
-  "libbinaryen" {>= "123.0.1" < "124.0.0"}
+  "libbinaryen" {>= "124.0.1" < "125.0.0"}
 ]
 x-maintenance-intent: ["0.(latest)"]

binaryen-archive/esy.lock/index.json

@@ -1,5 +1,5 @@
 {
-  "checksum": "155674e15af22e7cb1432c6d5b252eee",
+  "checksum": "43b607828957b76c0263dc0b329d0237",
   "root": "@grain/binaryen.ml@link-dev:./package.json",
   "node": {
     "ocaml@5.3.0@d41d8cd9": {
@@ -1960,14 +1960,14 @@
         [ "windows", "x86_64" ]
       ]
     },
-    "@grain/libbinaryen@123.0.1@d41d8cd9": {
-      "id": "@grain/libbinaryen@123.0.1@d41d8cd9",
+    "@grain/libbinaryen@124.0.1@d41d8cd9": {
+      "id": "@grain/libbinaryen@124.0.1@d41d8cd9",
       "name": "@grain/libbinaryen",
-      "version": "123.0.1",
+      "version": "124.0.1",
       "source": {
         "type": "install",
         "source": [
-          "archive:https://registry.npmjs.org/@grain/libbinaryen/-/libbinaryen-123.0.1.tgz#sha1:5d4c992f6761d67d7d297bb48f0f4093ab5328e4"
+          "archive:https://registry.npmjs.org/@grain/libbinaryen/-/libbinaryen-124.0.1.tgz#sha1:7b29acc4a62ab5a849c6e01c3d8e90c78efd05f2"
         ]
       },
       "overrides": [],
@@ -1999,7 +1999,7 @@
         "ocaml@5.3.0@d41d8cd9",
         "@opam/dune-configurator@opam:3.20.2@7eb6ff01",
         "@opam/dune@opam:3.20.2@8daef28d",
-        "@grain/libbinaryen@123.0.1@d41d8cd9"
+        "@grain/libbinaryen@124.0.1@d41d8cd9"
       ],
       "devDependencies": [
         "@opam/ocamlformat@opam:0.27.0@c40d4612",

binaryen-archive/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@grain/binaryen.ml",
-  "version": "0.33.0",
+  "version": "0.34.0",
   "description": "OCaml bindings for Binaryen.",
   "author": "Oscar Spencer <oscar@grain-lang.org>",
   "license": "Apache-2.0",
   "dependencies": {
     "ocaml": ">= 4.13.0 < 5.4.0",
-    "@grain/libbinaryen": ">= 123.0.0 < 124.0.0",
+    "@grain/libbinaryen": ">= 124.0.0 < 125.0.0",
     "@opam/dune": ">= 3.0.0",
     "@opam/dune-configurator": ">= 3.0.0"
   },

binaryen-archive/src/function.c

@@ -73,6 +73,14 @@ caml_binaryen_set_start(value _module, value _fun) {
   CAMLreturn(Val_unit);
 }
 
+CAMLprim value
+caml_binaryen_get_start(value _module) {
+  CAMLparam1(_module);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  BinaryenFunctionRef fun = BinaryenGetStart(module);
+  CAMLreturn(alloc_BinaryenFunctionRef(fun));
+}
+
 CAMLprim value
 caml_binaryen_function_set_debug_location(value _fun, value _exp, value _file, value _line, value _column) {
   CAMLparam5(_fun, _exp, _file, _line, _column);

binaryen-archive/src/function.js

@@ -56,6 +56,11 @@ function caml_binaryen_set_start(wasm_mod, func) {
   return wasm_mod.setStart(func);
 }
 
+//Provides: caml_binaryen_get_start
+function caml_binaryen_get_start(wasm_mod) {
+  return wasm_mod.getStart();
+}
+
 //Provides: caml_binaryen_function_set_debug_location
 //Requires: Binaryen
 function caml_binaryen_function_set_debug_location(

binaryen-archive/src/function.ml

@@ -6,6 +6,7 @@ external add_function :
 (** Module, name, params type, results type, locals types, body. *)
 
 external set_start : Module.t -> t -> unit = "caml_binaryen_set_start"
+external get_start : Module.t -> t = "caml_binaryen_get_start"
 
 external set_debug_location : t -> Expression.t -> int -> int -> int -> unit
   = "caml_binaryen_function_set_debug_location"

binaryen-archive/src/function.mli

@@ -4,6 +4,7 @@ val add_function :
   Module.t -> string -> Type.t -> Type.t -> Type.t array -> Expression.t -> t
 
 val set_start : Module.t -> t -> unit
+val get_start : Module.t -> t
 val set_debug_location : t -> Expression.t -> int -> int -> int -> unit
 val get_function : Module.t -> string -> t
 val get_function_by_index : Module.t -> int -> t

binaryen-archive/src/passes.ml

@@ -37,12 +37,18 @@ let const_hoisting = "const-hoisting"
 (** propagate constant struct field values *)
 let cfp = "cfp"
 
+(** propagate constant struct field values, using ref.test *)
+let cfp_reftest = "cfp-reftest"
+
 (** removes unreachable code *)
 let dce = "dce"
 
 (** forces all loads and stores to have alignment 1 *)
 let dealign = "dealign"
 
+(** propagate debug location from parents or previous siblings to child nodes *)
+let propagate_debug_locs = "propagate-debug-locs"
+
 (** instrument the wasm to convert NaNs into 0 at runtime *)
 let denan = "denan"
 
@@ -67,6 +73,9 @@ let duplicate_function_elimination = "duplicate-function-elimination"
 (** emit the target features section in the output *)
 let emit_target_features = "emit-target-features"
 
+(** modify the wasm (destructively) for closed-world *)
+let enclose_world = "enclose-world"
+
 (** leaves just one function (useful for debugging) *)
 let extract_function = "extract-function"
 
@@ -94,9 +103,6 @@ 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"
 
@@ -110,15 +116,30 @@ let gto = "gto"
     about what content can actually appear in each location *)
 let gufa = "gufa"
 
+(** GUFA plus add casts for all inferences *)
+let gufa_cast_all = "gufa-cast-all"
+
 (** GUFA plus local optimizations in functions we modified *)
 let gufa_optimizing = "gufa-optimizing"
 
+(** optimizes J2CL specific constructs. *)
+let optimize_j2cl = "optimize-j2cl"
+
+(** Merges itable structures into vtables to make types more compact *)
+let merge_j2cl_itables = "merge-j2cl-itables"
+
 (** apply more specific subtypes to type fields where possible *)
 let type_refining = "type-refining"
 
+(** apply more specific subtypes to type fields where possible (using GUFA) *)
+let type_refining_gufa = "type-refining-gufa"
+
 (** replace GC allocations with locals *)
 let heap2local = "heap2local"
 
+(** optimize heap (GC) stores *)
+let heap_store_optimization = "heap-store-optimization"
+
 (** inline __original_main into main *)
 let inline_main = "inline-main"
 
@@ -137,9 +158,8 @@ let jspi = "jspi"
 (** legalizes i64 types on the import/export boundary *)
 let legalize_js_interface = "legalize-js-interface"
 
-(** legalizes i64 types on the import/export boundary in a minimal manner, only
-    on things only JS will call *)
-let legalize_js_interface_minimally = "legalize-js-interface-minimally"
+(** legalizes the import/export boundary and prunes when needed *)
+let legalize_and_prune_js_interface = "legalize-and-prune-js-interface"
 
 (** common subexpression elimination inside basic blocks *)
 let local_cse = "local-cse"
@@ -153,6 +173,9 @@ let log_execution = "log-execution"
 (** lower all uses of i64s to use i32s instead *)
 let i64_to_i32_lowering = "i64-to-i32-lowering"
 
+(** instrument the build with code to intercept specific function calls *)
+let trace_calls = "trace-calls"
+
 (** instrument the build with code to intercept all loads and stores *)
 let instrument_locals = "instrument-locals"
 
@@ -168,6 +191,13 @@ let limit_segments = "limit-segments"
 (** lower loads and stores to a 64-bit memory to instead use a 32-bit one *)
 let memory64_lowering = "memory64-lowering"
 
+(** alias for memory64-lowering *)
+let table64_lowering = "table64-lowering"
+
+(** Lower memory.copy and memory.fill to wasm mvp and disable the bulk-memory
+    feature. *)
+let llvm_memory_copy_fill_lowering = "llvm-memory-copy-fill-lowering"
+
 (** packs memory into separate segments, skipping zeros *)
 let memory_packing = "memory-packing"
 
@@ -196,6 +226,9 @@ let minify_imports_and_exports = "minify-imports-and-exports"
 let minify_imports_and_exports_and_modules =
   "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"
@@ -223,6 +256,19 @@ let nm = "nm"
 (** (re)name all heap types *)
 let name_types = "name-types"
 
+(** mark functions as no-inline *)
+let no_inline = "no-inline"
+
+(** mark functions as no-inline (for full inlining only) *)
+let no_full_inline = "no-full-inline"
+
+(** mark functions as no-inline (for partial inlining only) *)
+let no_partial_inline = "no-partial-inline"
+
+(** lower nontrapping float-to-int operations to wasm mvp and disable the
+    nontrapping fptoint feature *)
+let llvm_nontrapping_fptoint_lowering = "llvm-nontrapping-fptoint-lowering"
+
 (** reduces calls to code that only runs once *)
 let once_reduction = "once-reduction"
 
@@ -239,9 +285,6 @@ let optimize_casts = "optimize-casts"
 (** optimizes instruction combinations *)
 let optimize_instructions = "optimize-instructions"
 
-(** optimize Stack IR *)
-let optimize_stack_ir = "optimize-stack-ir"
-
 (** pick load signs based on their uses *)
 let pick_load_signs = "pick-load-signs"
 
@@ -282,15 +325,15 @@ let print_function_map = "print-function-map"
 (** alias for print_function_map *)
 let symbolmap = "symbolmap"
 
-(** print out Stack IR (useful for internal debugging) *)
-let print_stack_ir = "print-stack-ir"
-
 (** removes operations incompatible with js *)
 let remove_non_js_ops = "remove-non-js-ops"
 
 (** removes imports and replaces them with nops *)
 let remove_imports = "remove-imports"
 
+(** removes memory initialization *)
+let remove_memory_init = "remove-memory-init"
+
 (** removes memory segments *)
 let remove_memory = "remove-memory"
 
@@ -310,15 +353,15 @@ let remove_unused_names = "remove-unused-names"
 (** remove unused private GC types *)
 let remove_unused_types = "remove-unused-types"
 
+(** sorts functions by name (useful for debugging) *)
+let reorder_functions_by_name = "reorder-functions-by-name"
+
 (** 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"
 
@@ -337,6 +380,9 @@ let safe_heap = "safe-heap"
 (** sets specified globals to specified values *)
 let set_globals = "set-globals"
 
+(** write data segments to a file and strip them from the module *)
+let separate_data_segments = "separate-data-segments"
+
 (** remove params from function signature types where possible *)
 let signature_pruning = "signature-pruning"
 
@@ -388,6 +434,23 @@ let ssa = "ssa"
 (** ssa-ify variables so that they have a single assignment, ignoring merges *)
 let ssa_nomerge = "ssa-nomerge"
 
+(** gathers wasm strings to globals *)
+let string_gathering = "string-gathering"
+
+(** lift string imports to wasm strings *)
+let string_lifting = "string-lifting"
+
+(** lowers wasm strings and operations to imports *)
+let string_lowering = "string-lowering"
+
+(** same as string-lowering, but encodes well-formed strings as magic imports *)
+let string_lowering_magic_imports = "string-lowering-magic-imports"
+
+(** same as string-lowering-magic-imports, but raise a fatal error if there are
+    invalid strings *)
+let string_lowering_magic_imports_assert =
+  "string-lowering-magic-imports-assert"
+
 (** deprecated; same as strip-debug *)
 let strip = "strip"
 
@@ -409,18 +472,33 @@ let strip_eh = "strip-eh"
 (** strip the wasm target features section *)
 let strip_target_features = "strip-target-features"
 
+(** translate old Phase 3 EH instructions to new ones with exnref *)
+let translate_to_exnref = "translate-to-exnref"
+
 (** replace trapping operations with clamping semantics *)
 let trap_mode_clamp = "trap-mode-clamp"
 
 (** replace trapping operations with js semantics *)
 let trap_mode_js = "trap-mode-js"
 
+(** optimize trivial tuples away *)
+let tuple_optimization = "tuple-optimization"
+
+(** mark all leaf types as final *)
+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 *)
 let type_ssa = "type-ssa"
 
+(** mark all types as non-final (open) *)
+let type_unfinalizing = "type-unfinalizing"
+
+(** removes removes unnecessary subtyping relationships *)
+let unsubtyping = "unsubtyping"
+
 (** removes local.tees, replacing them with sets and gets *)
 let untee = "untee"
 

binaryen-archive/src/passes.mli

@@ -37,12 +37,18 @@ val const_hoisting : t
 val cfp : t
 (** propagate constant struct field values *)
 
+val cfp_reftest : t
+(** propagate constant struct field values, using ref.test *)
+
 val dce : t
 (** removes unreachable code *)
 
 val dealign : t
 (** forces all loads and stores to have alignment 1 *)
 
+val propagate_debug_locs : t
+(** propagate debug location from parents or previous siblings to child nodes *)
+
 val denan : t
 (** instrument the wasm to convert NaNs into 0 at runtime *)
 
@@ -67,6 +73,9 @@ val duplicate_function_elimination : t
 val emit_target_features : t
 (** emit the target features section in the output *)
 
+val enclose_world : t
+(** modify the wasm (destructively) for closed-world *)
+
 val extract_function : t
 (** leaves just one function (useful for debugging) *)
 
@@ -94,9 +103,6 @@ val generate_i64_dyncalls : t
 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 *)
 
@@ -110,15 +116,27 @@ val gufa : t
 (** Grand Unified Flow Analysis: optimize the entire program using information
     about what content can actually appear in each location *)
 
+val gufa_cast_all : t
+(** GUFA plus add casts for all inferences *)
+
 val gufa_optimizing : t
 (** GUFA plus local optimizations in functions we modified *)
 
+val optimize_j2cl : t
+(** optimizes J2CL specific constructs. *)
+
+val merge_j2cl_itables : t
+(** Merges itable structures into vtables to make types more compact *)
+
 val type_refining : t
 (** apply more specific subtypes to type fields where possible *)
 
 val heap2local : t
 (** replace GC allocations with locals *)
 
+val heap_store_optimization : t
+(** optimize heap (GC) stores *)
+
 val inline_main : t
 (** inline __original_main into main *)
 
@@ -137,9 +155,8 @@ val jspi : t
 val legalize_js_interface : t
 (** legalizes i64 types on the import/export boundary *)
 
-val legalize_js_interface_minimally : t
-(** legalizes i64 types on the import/export boundary in a minimal manner, only
-    on things only JS will call *)
+val legalize_and_prune_js_interface : t
+(** legalizes the import/export boundary and prunes when needed *)
 
 val local_cse : t
 (** common subexpression elimination inside basic blocks *)
@@ -153,6 +170,9 @@ val log_execution : t
 val i64_to_i32_lowering : t
 (** lower all uses of i64s to use i32s instead *)
 
+val trace_calls : t
+(** instrument the build with code to intercept specific function calls *)
+
 val instrument_locals : t
 (** instrument the build with code to intercept all loads and stores *)
 
@@ -168,6 +188,13 @@ val limit_segments : t
 val memory64_lowering : t
 (** lower loads and stores to a 64-bit memory to instead use a 32-bit one *)
 
+val table64_lowering : t
+(** alias for memory64-lowering *)
+
+val llvm_memory_copy_fill_lowering : t
+(** Lower memory.copy and memory.fill to wasm mvp and disable the bulk-memory
+    feature. *)
+
 val memory_packing : t
 (** packs memory into separate segments, skipping zeros *)
 
@@ -195,6 +222,9 @@ val minify_imports_and_exports_and_modules : t
 (** minifies both import and export names, and emits a mapping to the minified
     ones, and minifies the modules as well *)
 
+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 *)
@@ -221,6 +251,19 @@ val nm : t
 val name_types : t
 (** (re)name all heap types *)
 
+val no_inline : t
+(** mark functions as no-inline *)
+
+val no_full_inline : t
+(** mark functions as no-inline (for full inlining only) *)
+
+val no_partial_inline : t
+(** mark functions as no-inline (for partial inlining only) *)
+
+val llvm_nontrapping_fptoint_lowering : t
+(** lower nontrapping float-to-int operations to wasm mvp and disable the
+    nontrapping fptoint feature *)
+
 val once_reduction : t
 (** reduces calls to code that only runs once *)
 
@@ -237,9 +280,6 @@ val optimize_casts : t
 val optimize_instructions : t
 (** optimizes instruction combinations *)
 
-val optimize_stack_ir : t
-(** optimize Stack IR *)
-
 val pick_load_signs : t
 (** pick load signs based on their uses *)
 
@@ -280,15 +320,15 @@ val print_function_map : t
 val symbolmap : t
 (** alias for print_function_map *)
 
-val print_stack_ir : t
-(** print out Stack IR (useful for internal debugging) *)
-
 val remove_non_js_ops : t
 (** removes operations incompatible with js *)
 
 val remove_imports : t
 (** removes imports and replaces them with nops *)
 
+val remove_memory_init : t
+(** removes memory initialization *)
+
 val remove_memory : t
 (** removes memory segments *)
 
@@ -307,15 +347,15 @@ val remove_unused_names : t
 val remove_unused_types : t
 (** remove unused private GC types *)
 
+val reorder_functions_by_name : t
+(** sorts functions by name (useful for debugging) *)
+
 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 *)
 
@@ -334,6 +374,9 @@ val safe_heap : t
 val set_globals : t
 (** sets specified globals to specified values *)
 
+val separate_data_segments : t
+(** write data segments to a file and strip them from the module *)
+
 val signature_pruning : t
 (** remove params from function signature types where possible *)
 
@@ -384,6 +427,22 @@ val ssa : t
 val ssa_nomerge : t
 (** ssa-ify variables so that they have a single assignment, ignoring merges *)
 
+val string_gathering : t
+(** gathers wasm strings to globals *)
+
+val string_lifting : t
+(** lift string imports to wasm strings *)
+
+val string_lowering : t
+(** lowers wasm strings and operations to imports *)
+
+val string_lowering_magic_imports : t
+(** same as string-lowering, but encodes well-formed strings as magic imports *)
+
+val string_lowering_magic_imports_assert : t
+(** same as string-lowering-magic-imports, but raise a fatal error if there are
+    invalid strings *)
+
 val strip : t
 (** deprecated; same as strip-debug *)
 
@@ -405,18 +464,33 @@ val strip_eh : t
 val strip_target_features : t
 (** strip the wasm target features section *)
 
+val translate_to_exnref : t
+(** translate old Phase 3 EH instructions to new ones with exnref *)
+
 val trap_mode_clamp : t
 (** replace trapping operations with clamping semantics *)
 
 val trap_mode_js : t
 (** replace trapping operations with js semantics *)
 
+val tuple_optimization : t
+(** optimize trivial tuples away *)
+
+val type_finalizing : t
+(** mark all leaf types as final *)
+
 val type_merging : t
 (** merge types to their supertypes where possible *)
 
 val type_ssa : t
 (** create new nominal types to help other optimizations *)
 
+val type_unfinalizing : t
+(** mark all types as non-final (open) *)
+
+val unsubtyping : t
+(** removes removes unnecessary subtyping relationships *)
+
 val untee : t
 (** removes local.tees, replacing them with sets and gets *)
 

binaryen-archive/test/test.ml

@@ -170,12 +170,14 @@ let start =
 
 let _ = Export.add_function_export wasm_mod "adder" "adder"
 let _ = Table.add_table wasm_mod "table" 1 1 Type.funcref
-let funcref_expr1 = Expression.Ref.func wasm_mod "adder" (Heap_type.func ())
+
+(* TODO(#240): Re-enable after type-builder api is merged *)
+(* let funcref_expr1 = Expression.Ref.func wasm_mod "adder" (Heap_type.func ())
 
 let _ =
   Expression.Table.set wasm_mod "table"
     (Expression.Const.make wasm_mod (Literal.int32 0l))
-    funcref_expr1
+    funcref_expr1 *)
 
 let funcref_expr2 =
   Expression.Table.get wasm_mod "table"
@@ -212,6 +214,8 @@ let _ =
     (Expression.Const.make wasm_mod (Literal.int32 0l))
 
 let _ = Function.set_start wasm_mod start
+let start_func = Function.get_start wasm_mod
+let _ = assert (Function.get_name start_func = "start")
 
 let segment : Binaryen.Memory.segment =
   let data = Bytes.of_string "hello" in