@grain/binaryen.ml 0.32.0 → 0.34.0

binaryen-archive/src/settings.js

@@ -36,6 +36,34 @@ function caml_binaryen_set_debug_info(on) {
   return Binaryen._BinaryenSetDebugInfo(on);
 }
 
+//Provides: caml_binaryen_get_traps_never_happen
+//Requires: Binaryen
+function caml_binaryen_get_traps_never_happen() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetTrapsNeverHappen();
+}
+
+//Provides: caml_binaryen_set_traps_never_happen
+//Requires: Binaryen
+function caml_binaryen_set_traps_never_happen(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetTrapsNeverHappen(on);
+}
+
+//Provides: caml_binaryen_get_closed_world
+//Requires: Binaryen
+function caml_binaryen_get_closed_world() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetClosedWorld();
+}
+
+//Provides: caml_binaryen_set_closed_world
+//Requires: Binaryen
+function caml_binaryen_set_closed_world(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetClosedWorld(on);
+}
+
 //Provides: caml_binaryen_get_low_memory_unused
 //Requires: Binaryen
 function caml_binaryen_get_low_memory_unused() {
@@ -50,6 +78,62 @@ function caml_binaryen_set_low_memory_unused(on) {
   return Binaryen._BinaryenSetLowMemoryUnused(on);
 }
 
+//Provides: caml_binaryen_get_zero_filled_memory
+//Requires: Binaryen
+function caml_binaryen_get_zero_filled_memory() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetZeroFilledMemory();
+}
+
+//Provides: caml_binaryen_set_zero_filled_memory
+//Requires: Binaryen
+function caml_binaryen_set_zero_filled_memory(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetZeroFilledMemory(on);
+}
+
+//Provides: caml_binaryen_get_fast_math
+//Requires: Binaryen
+function caml_binaryen_get_fast_math() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetFastMath();
+}
+
+//Provides: caml_binaryen_set_fast_math
+//Requires: Binaryen
+function caml_binaryen_set_fast_math(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetFastMath(on);
+}
+
+//Provides: caml_binaryen_get_generate_stack_ir
+//Requires: Binaryen
+function caml_binaryen_get_generate_stack_ir() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetGenerateStackIR();
+}
+
+//Provides: caml_binaryen_set_generate_stack_ir
+//Requires: Binaryen
+function caml_binaryen_set_generate_stack_ir(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetGenerateStackIR(on);
+}
+
+//Provides: caml_binaryen_get_optimize_stack_ir
+//Requires: Binaryen
+function caml_binaryen_get_optimize_stack_ir() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetOptimizeStackIR();
+}
+
+//Provides: caml_binaryen_set_optimize_stack_ir
+//Requires: Binaryen
+function caml_binaryen_set_optimize_stack_ir(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetOptimizeStackIR(on);
+}
+
 //Provides: caml_binaryen_get_pass_argument
 //Requires: Binaryen
 //Requires: caml_jsstring_of_string
@@ -70,6 +154,39 @@ function caml_binaryen_set_pass_argument(name, value) {
   );
 }
 
+//Provides: caml_binaryen_clear_pass_arguments
+//Requires: Binaryen
+function caml_binaryen_clear_pass_arguments() {
+  return Binaryen.clearPassArguments();
+}
+
+//Provides: caml_binaryen_has_pass_to_skip
+//Requires: Binaryen
+//Requires: caml_jsstring_of_string
+//Requires: caml_js_to_bool
+function caml_binaryen_has_pass_to_skip(pass) {
+  return caml_js_to_bool(
+    Binaryen.hasPassToSkip(
+      caml_jsstring_of_string(pass)
+    )
+  );
+}
+
+//Provides: caml_binaryen_add_pass_to_skip
+//Requires: Binaryen
+//Requires: caml_jsstring_of_string
+function caml_binaryen_add_pass_to_skip(pass) {
+  return Binaryen.addPassToSkip(
+    caml_jsstring_of_string(pass)
+  );
+}
+
+//Provides: caml_binaryen_clear_passes_to_skip
+//Requires: Binaryen
+function caml_binaryen_clear_passes_to_skip(pass) {
+  return Binaryen.clearPassesToSkip();
+}
+
 //Provides: caml_binaryen_get_always_inline_max_size
 //Requires: Binaryen
 function caml_binaryen_get_always_inline_max_size() {
@@ -106,6 +223,20 @@ function caml_binaryen_set_one_caller_inline_max_size(size) {
   return Binaryen.setOneCallerInlineMaxSize(size);
 }
 
+//Provides: caml_binaryen_get_allow_inlining_functions_with_loops
+//Requires: Binaryen
+function caml_binaryen_get_allow_inlining_functions_with_loops() {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenGetAllowInliningFunctionsWithLoops();
+}
+
+//Provides: caml_binaryen_set_allow_inlining_functions_with_loops
+//Requires: Binaryen
+function caml_binaryen_set_allow_inlining_functions_with_loops(on) {
+  // Uses the `_Binaryen` function because then we are working with ints which are also booleans to JSOO
+  return Binaryen._BinaryenSetAllowInliningFunctionsWithLoops(on);
+}
+
 //Provides: caml_binaryen_set_colors_enabled
 //Requires: Binaryen
 function caml_binaryen_set_colors_enabled(on) {

binaryen-archive/src/settings.ml

@@ -5,18 +5,57 @@ external set_shrink_level : int -> unit = "caml_binaryen_set_shrink_level"
 external get_debug_info : unit -> bool = "caml_binaryen_get_debug_info"
 external set_debug_info : bool -> unit = "caml_binaryen_set_debug_info"
 
+external get_traps_never_happen : unit -> bool
+  = "caml_binaryen_get_traps_never_happen"
+
+external set_traps_never_happen : bool -> unit
+  = "caml_binaryen_set_traps_never_happen"
+
+external get_closed_world : unit -> bool = "caml_binaryen_get_closed_world"
+external set_closed_world : bool -> unit = "caml_binaryen_set_closed_world"
+
 external get_low_memory_unused : unit -> bool
   = "caml_binaryen_get_low_memory_unused"
 
 external set_low_memory_unused : bool -> unit
   = "caml_binaryen_set_low_memory_unused"
 
+external get_zero_filled_memory : unit -> bool
+  = "caml_binaryen_get_zero_filled_memory"
+
+external set_zero_filled_memory : bool -> unit
+  = "caml_binaryen_set_zero_filled_memory"
+
+external get_fast_math : unit -> bool = "caml_binaryen_get_fast_math"
+external set_fast_math : bool -> unit = "caml_binaryen_set_fast_math"
+
+external get_generate_stack_ir : unit -> bool
+  = "caml_binaryen_get_generate_stack_ir"
+
+external set_generate_stack_ir : bool -> unit
+  = "caml_binaryen_set_generate_stack_ir"
+
+external get_optimize_stack_ir : unit -> bool
+  = "caml_binaryen_get_optimize_stack_ir"
+
+external set_optimize_stack_ir : bool -> unit
+  = "caml_binaryen_set_optimize_stack_ir"
+
 external get_pass_argument : string -> string option
   = "caml_binaryen_get_pass_argument"
 
 external set_pass_argument : string -> string -> unit
   = "caml_binaryen_set_pass_argument"
 
+external clear_pass_arguments : unit -> unit
+  = "caml_binaryen_clear_pass_arguments"
+
+external has_pass_to_skip : string -> bool = "caml_binaryen_has_pass_to_skip"
+external add_pass_to_skip : string -> unit = "caml_binaryen_add_pass_to_skip"
+
+external clear_passes_to_skip : unit -> unit
+  = "caml_binaryen_clear_passes_to_skip"
+
 external get_always_inline_max_size : unit -> int
   = "caml_binaryen_get_always_inline_max_size"
 
@@ -35,5 +74,11 @@ external get_one_caller_inline_max_size : unit -> int
 external set_one_caller_inline_max_size : int -> unit
   = "caml_binaryen_set_one_caller_inline_max_size"
 
+external get_allow_inlining_functions_with_loops : unit -> bool
+  = "caml_binaryen_get_allow_inlining_functions_with_loops"
+
+external set_allow_inlining_functions_with_loops : bool -> unit
+  = "caml_binaryen_set_allow_inlining_functions_with_loops"
+
 external set_colors_enabled : bool -> unit = "caml_binaryen_set_colors_enabled"
 external are_colors_enabled : unit -> bool = "caml_binaryen_are_colors_enabled"

binaryen-archive/src/settings.mli

@@ -4,15 +4,33 @@ val get_shrink_level : unit -> int
 val set_shrink_level : int -> unit
 val get_debug_info : unit -> bool
 val set_debug_info : bool -> unit
+val get_traps_never_happen : unit -> bool
+val set_traps_never_happen : bool -> unit
+val get_closed_world : unit -> bool
+val set_closed_world : bool -> unit
 val get_low_memory_unused : unit -> bool
 val set_low_memory_unused : bool -> unit
+val get_zero_filled_memory : unit -> bool
+val set_zero_filled_memory : bool -> unit
+val get_fast_math : unit -> bool
+val set_fast_math : bool -> unit
+val get_generate_stack_ir : unit -> bool
+val set_generate_stack_ir : bool -> unit
+val get_optimize_stack_ir : unit -> bool
+val set_optimize_stack_ir : bool -> unit
 val get_pass_argument : string -> string option
 val set_pass_argument : string -> string -> unit
+val clear_pass_arguments : unit -> unit
+val has_pass_to_skip : string -> bool
+val add_pass_to_skip : string -> unit
+val clear_passes_to_skip : unit -> unit
 val get_always_inline_max_size : unit -> int
 val set_always_inline_max_size : int -> unit
 val get_flexible_inline_max_size : unit -> int
 val set_flexible_inline_max_size : int -> unit
 val get_one_caller_inline_max_size : unit -> int
 val set_one_caller_inline_max_size : int -> unit
+val get_allow_inlining_functions_with_loops : unit -> bool
+val set_allow_inlining_functions_with_loops : bool -> unit
 val set_colors_enabled : bool -> unit
 val are_colors_enabled : unit -> bool

binaryen-archive/test/test.ml

@@ -12,11 +12,67 @@ let _ = Settings.set_debug_info true
 let _ = assert (Settings.get_debug_info () == true)
 let _ = Settings.set_debug_info false
 
+(* Testing traps_never_happen enable *)
+let _ = assert (Settings.get_traps_never_happen () == false)
+let _ = Settings.set_traps_never_happen true
+let _ = assert (Settings.get_traps_never_happen () == true)
+let _ = Settings.set_traps_never_happen false
+
+(* Testing closed_world enable *)
+let _ = assert (Settings.get_closed_world () == false)
+let _ = Settings.set_closed_world true
+let _ = assert (Settings.get_closed_world () == true)
+let _ = Settings.set_closed_world false
+
 (* Testing low_memory_unused enable *)
 let _ = assert (Settings.get_low_memory_unused () == false)
 let _ = Settings.set_low_memory_unused true
 let _ = assert (Settings.get_low_memory_unused () == true)
 let _ = Settings.set_low_memory_unused false
+
+(* Testing zero_filled_memory enable *)
+let _ = assert (Settings.get_zero_filled_memory () == false)
+let _ = Settings.set_zero_filled_memory true
+let _ = assert (Settings.get_zero_filled_memory () == true)
+let _ = Settings.set_zero_filled_memory false
+
+(* Testing fast_math enable *)
+let _ = assert (Settings.get_fast_math () == false)
+let _ = Settings.set_fast_math true
+let _ = assert (Settings.get_fast_math () == true)
+let _ = Settings.set_fast_math false
+
+(* Testing generate_stack_ir enable *)
+let _ = assert (Settings.get_generate_stack_ir () == false)
+let _ = Settings.set_generate_stack_ir true
+let _ = assert (Settings.get_generate_stack_ir () == true)
+let _ = Settings.set_generate_stack_ir false
+
+(* Testing optimize_stack_ir enable *)
+let _ = assert (Settings.get_optimize_stack_ir () == false)
+let _ = Settings.set_optimize_stack_ir true
+let _ = assert (Settings.get_optimize_stack_ir () == true)
+let _ = Settings.set_optimize_stack_ir false
+
+(* Testing pass_argument *)
+let _ = assert (Settings.get_pass_argument "theKey" = None)
+let _ = Settings.set_pass_argument "theKey" "theValue"
+let _ = assert (Settings.get_pass_argument "theKey" = Some "theValue")
+let _ = Settings.clear_pass_arguments ()
+let _ = assert (Settings.get_pass_argument "theKey" = None)
+
+(* Testing skip_pass *)
+let _ = assert (Settings.has_pass_to_skip "thePass" == false)
+let _ = Settings.add_pass_to_skip "thePass"
+let _ = assert (Settings.has_pass_to_skip "thePass" == true)
+let _ = Settings.clear_passes_to_skip ()
+let _ = assert (Settings.has_pass_to_skip "thePass" == false)
+
+(* Testing allow_inlining_functions_with_loops enable *)
+let _ = assert (Settings.get_allow_inlining_functions_with_loops () == false)
+let _ = Settings.set_allow_inlining_functions_with_loops true
+let _ = assert (Settings.get_allow_inlining_functions_with_loops () == true)
+let _ = Settings.set_allow_inlining_functions_with_loops false
 let wasm_mod = Module.create ()
 let _ = Module.set_features wasm_mod [ Module.Feature.all ]
 let import_wasm_mod = Module.create ()
@@ -114,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" Type.funcref
+
+(* 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"
@@ -156,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
@@ -265,11 +325,11 @@ let _ =
     [
       Module.Feature.mvp;
       Module.Feature.atomics;
-      Module.Feature.bulk_memory;
       Module.Feature.mutable_globals;
       Module.Feature.nontrapping_fp_to_int;
-      Module.Feature.sign_ext;
       Module.Feature.simd128;
+      Module.Feature.bulk_memory;
+      Module.Feature.sign_ext;
       Module.Feature.exception_handling;
       Module.Feature.tail_call;
       Module.Feature.reference_types;
@@ -280,6 +340,11 @@ let _ =
       Module.Feature.extended_const;
       Module.Feature.strings;
       Module.Feature.multi_memory;
+      Module.Feature.stack_switching;
+      Module.Feature.shared_everything;
+      Module.Feature.fp16;
+      Module.Feature.bulk_memory_opt;
+      Module.Feature.call_indirect_overlong;
       Module.Feature.all;
     ]