@grain/binaryen.ml 0.33.0 → 0.35.0

binaryen-archive/src/expression.mli

@@ -350,6 +350,93 @@ module Ref : sig
   (** Module, left, right *)
 end
 
+(** Bindings for `try` instruction. *)
+module Try : sig
+  val make :
+    Module.t -> string option -> t -> (string * t) list -> t option -> t
+  (** Module, name, body, catch clauses, catch all *)
+
+  val get_name : t -> string option
+  (** expr *)
+
+  val set_name : t -> string -> unit
+  (** expr, name *)
+
+  val get_body : t -> t
+  (** expr *)
+
+  val set_body : t -> t -> unit
+  (** expr, bodyExpr *)
+
+  val get_num_catch_tags : t -> int
+  (** expr *)
+
+  val get_num_catch_bodies : t -> int
+  (** expr *)
+
+  val get_catch_tag_at : t -> int -> string
+  (** expr, index *)
+
+  val set_catch_tag_at : t -> int -> string -> unit
+  (** expr, index, catchTag *)
+
+  val append_catch_tag : t -> string -> int
+  (** expr, catchTag *)
+
+  val insert_catch_tag_at : t -> int -> string -> unit
+  (** expr, index, catchTag *)
+
+  val remove_catch_tag_at : t -> int -> string
+  (** expr, index *)
+
+  val get_catch_body_at : t -> int -> t
+  (** expr, index *)
+
+  val set_catch_body_at : t -> int -> t -> unit
+  (** expr, index, catchExpr *)
+
+  val append_catch_body : t -> t -> int
+  (** expr, catchExpr *)
+
+  val insert_catch_body_at : t -> int -> t -> unit
+  (** expr, index, catchExpr *)
+
+  val remove_catch_body_at : t -> int -> t
+  (** expr, index *)
+
+  val has_catch_all : t -> bool
+  (** expr *)
+end
+
+module Throw : sig
+  val make : Module.t -> string -> t list -> t
+  (** Module, tag, operands *)
+
+  val get_tag : t -> string
+  (** expr *)
+
+  val set_tag : t -> string -> unit
+  (** expr, tagName *)
+
+  val get_num_operands : t -> int
+  (** expr *)
+
+  val get_operand_at : t -> int -> t
+  (** expr, index *)
+
+  val set_operand_at : t -> int -> t -> unit
+  (** expr, index, operandExpr *)
+
+  val append_operand : t -> t -> int
+  (** expr, operandExpr *)
+
+  val insert_operand_at : t -> int -> t -> unit
+  (** expr, index, operandExpr *)
+
+  val remove_operand_at : t -> int -> t
+  (** expr, index *)
+end
+
 module Table : sig
   val get : Module.t -> string -> t -> Type.t -> t
   (** Module, name, index, type *)

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/import.c

@@ -67,6 +67,24 @@ caml_binaryen_add_global_import__bytecode(value * argv) {
   return caml_binaryen_add_global_import(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
 }
 
+CAMLprim value
+caml_binaryen_add_tag_import(value _module, value _internalName, value _externalModuleName, value _externalBaseName, value _paramsty, value _resultsty) {
+  CAMLparam5(_module, _internalName, _externalModuleName, _externalBaseName, _paramsty);
+  CAMLxparam1(_resultsty);
+  BinaryenModuleRef module = BinaryenModuleRef_val(_module);
+  char* internalName = Safe_String_val(_internalName);
+  char* externalModuleName = Safe_String_val(_externalModuleName);
+  char* externalBaseName = Safe_String_val(_externalBaseName);
+  BinaryenType paramsty = BinaryenType_val(_paramsty);
+  BinaryenType resultsty = BinaryenType_val(_resultsty);
+  BinaryenAddTagImport(module, internalName, externalModuleName, externalBaseName, paramsty, resultsty);
+  CAMLreturn(Val_unit);
+}
+CAMLprim value
+caml_binaryen_add_tag_import__bytecode(value * argv) {
+  return caml_binaryen_add_tag_import(argv[0], argv[1], argv[2], argv[3], argv[4], argv[5]);
+}
+
 CAMLprim value
 caml_binaryen_function_import_get_module(value _fun) {
   CAMLparam1(_fun);
@@ -89,6 +107,13 @@ caml_binaryen_global_import_get_module(value _global) {
   CAMLreturn(caml_copy_string(BinaryenGlobalImportGetModule(global)));
 }
 
+CAMLprim value
+caml_binaryen_tag_import_get_module(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  CAMLreturn(caml_copy_string(BinaryenTagImportGetModule(tag)));
+}
+
 CAMLprim value
 caml_binaryen_function_import_get_base(value _fun) {
   CAMLparam1(_fun);
@@ -110,3 +135,10 @@ caml_binaryen_global_import_get_base(value _global) {
   BinaryenGlobalRef global = BinaryenGlobalRef_val(_global);
   CAMLreturn(caml_copy_string(BinaryenGlobalImportGetBase(global)));
 }
+
+CAMLprim value
+caml_binaryen_tag_import_get_base(value _tag) {
+  CAMLparam1(_tag);
+  BinaryenTagRef tag = BinaryenTagRef_val(_tag);
+  CAMLreturn(caml_copy_string(BinaryenTagImportGetBase(tag)));
+}

binaryen-archive/src/import.js

@@ -92,6 +92,37 @@ function caml_binaryen_add_global_import__bytecode() {
   );
 }
 
+//Provides: caml_binaryen_add_tag_import
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_tag_import(
+  wasm_mod,
+  internalName,
+  externalModuleName,
+  externalBaseName,
+  paramsty,
+  resultsty
+) {
+  return wasm_mod.addTagImport(
+    caml_jsstring_of_string(internalName),
+    caml_jsstring_of_string(externalModuleName),
+    caml_jsstring_of_string(externalBaseName),
+    paramsty,
+    resultsty
+  );
+}
+//Provides: caml_binaryen_add_tag_import__bytecode
+//Requires: caml_binaryen_add_tag_import
+function caml_binaryen_add_tag_import__bytecode() {
+  return caml_binaryen_add_tag_import(
+    arguments[0],
+    arguments[1],
+    arguments[2],
+    arguments[3],
+    arguments[4],
+    arguments[5]
+  );
+}
+
 //Provides: caml_binaryen_function_import_get_module
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -115,6 +146,14 @@ function caml_binaryen_global_import_get_module(global) {
   return caml_string_of_jsstring(global_info.module);
 }
 
+//Provides: caml_binaryen_tag_import_get_module
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_import_get_module(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.module);
+}
+
 //Provides: caml_binaryen_function_import_get_base
 //Requires: Binaryen
 //Requires: caml_string_of_jsstring
@@ -137,3 +176,11 @@ function caml_binaryen_global_import_get_base(global) {
   var global_info = Binaryen.getGlobalInfo(global);
   return caml_string_of_jsstring(global_info.base);
 }
+
+//Provides: caml_binaryen_tag_import_get_base
+//Requires: Binaryen
+//Requires: caml_string_of_jsstring
+function caml_binaryen_tag_import_get_base(tag) {
+  var tag_info = Binaryen.getTagInfo(tag);
+  return caml_string_of_jsstring(tag_info.base);
+}

binaryen-archive/src/import.ml

@@ -21,6 +21,12 @@ external add_global_import :
 (** Module, internal name, external module name, external base name, type,
     mutable. *)
 
+external add_tag_import :
+  Module.t -> string -> string -> string -> Type.t -> Type.t -> unit
+  = "caml_binaryen_add_tag_import__bytecode" "caml_binaryen_add_tag_import"
+(** Module, internal name, external module name, external base name, params
+    type, results type. *)
+
 external function_import_get_module : Function.t -> string
   = "caml_binaryen_function_import_get_module"
 
@@ -30,6 +36,9 @@ external memory_import_get_module : Module.t -> string -> string
 external global_import_get_module : Global.t -> string
   = "caml_binaryen_global_import_get_module"
 
+external tag_import_get_module : Tag.t -> string
+  = "caml_binaryen_tag_import_get_module"
+
 external function_import_get_base : Function.t -> string
   = "caml_binaryen_function_import_get_base"
 
@@ -38,3 +47,6 @@ external memory_import_get_base : Module.t -> string -> string
 
 external global_import_get_base : Global.t -> string
   = "caml_binaryen_global_import_get_base"
+
+external tag_import_get_base : Tag.t -> string
+  = "caml_binaryen_tag_import_get_base"

binaryen-archive/src/import.mli

@@ -7,9 +7,14 @@ val add_memory_import : Module.t -> string -> string -> string -> bool -> unit
 val add_global_import :
   Module.t -> string -> string -> string -> Type.t -> bool -> unit
 
+val add_tag_import :
+  Module.t -> string -> string -> string -> Type.t -> Type.t -> unit
+
 val function_import_get_module : Function.t -> string
 val memory_import_get_module : Module.t -> string -> string
 val global_import_get_module : Global.t -> string
+val tag_import_get_module : Tag.t -> string
 val function_import_get_base : Function.t -> string
 val memory_import_get_base : Module.t -> string -> string
 val global_import_get_base : Global.t -> string
+val tag_import_get_base : Tag.t -> string

binaryen-archive/src/module.js

@@ -122,11 +122,11 @@ function caml_binaryen_module_get_debug_info_filename(wasm_mod, index) {
 }
 
 //Provides: caml_binaryen_add_custom_section
-//Requires: caml_jsstring_of_string, caml_array_of_string
+//Requires: caml_jsstring_of_string, caml_uint8_array_of_string
 function caml_binaryen_add_custom_section(wasm_mod, name, contents) {
   return wasm_mod.addCustomSection(
     caml_jsstring_of_string(name),
-    caml_array_of_string(contents)
+    caml_uint8_array_of_string(contents)
   );
 }
 

binaryen-archive/src/ocaml_helpers.c

@@ -38,6 +38,14 @@ value alloc_BinaryenGlobalRef(BinaryenGlobalRef exp)
   return v;
 }
 
+/* Allocating an OCaml custom block to hold the given BinaryenTagRef */
+value alloc_BinaryenTagRef(BinaryenTagRef exp)
+{
+  value v = caml_alloc_custom(&binaryen_ops, sizeof(BinaryenTagRef), 0, 1);
+  BinaryenTagRef_val(v) = exp;
+  return v;
+}
+
 /* Allocating an OCaml custom block to hold the given BinaryenExportRef */
 value alloc_BinaryenExportRef(BinaryenExportRef exp)
 {

binaryen-archive/src/ocaml_helpers.h

@@ -29,6 +29,7 @@ static struct custom_operations binaryen_ops = {
 #define BinaryenLiteral_val(v) (*((struct BinaryenLiteral*) Data_custom_val(v)))
 #define BinaryenFunctionRef_val(v) (*((BinaryenFunctionRef*) Data_custom_val(v)))
 #define BinaryenGlobalRef_val(v) (*((BinaryenGlobalRef*) Data_custom_val(v)))
+#define BinaryenTagRef_val(v) (*((BinaryenTagRef*) Data_custom_val(v)))
 #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)))
@@ -53,6 +54,9 @@ value alloc_BinaryenType(BinaryenType typ);
 /* Allocating an OCaml custom block to hold the given BinaryenGlobalRef */
 value alloc_BinaryenGlobalRef(BinaryenGlobalRef exp);
 
+/* Allocating an OCaml custom block to hold the given BinaryenTagRef */
+value alloc_BinaryenTagRef(BinaryenTagRef exp);
+
 /* Allocating an OCaml custom block to hold the given BinaryenExportRef */
 value alloc_BinaryenExportRef(BinaryenExportRef exp);
 

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,12 +226,8 @@ let minify_imports_and_exports = "minify-imports-and-exports"
 let minify_imports_and_exports_and_modules =
   "minify-imports-and-exports-and-modules"
 
-(** 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"
+(** Split types into minimal recursion groups *)
+let minimize_rec_groups = "minimize-rec-groups"
 
 (** creates specialized versions of functions *)
 let monomorphize = "monomorphize"
@@ -223,6 +249,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 +278,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 +318,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,18 +346,21 @@ 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"
 
+(** sorts private types by access frequency *)
+let reorder_types = "reorder-types"
+
 (** re-optimize control flow using the relooper algorithm *)
 let rereloop = "rereloop"
 
@@ -337,6 +376,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 +430,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 +468,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"