@grain/binaryen.ml 0.8.1 → 0.11.0

binaryen-archive/test/test.expected

@@ -1,10 +1,24 @@
 (module
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
+ (type $none_=>_none (func))
+ (type $externref_=>_i32 (func (param externref) (result i32)))
+ (type $externref_i32_i32_=>_i32 (func (param externref i32 i32) (result i32)))
+ (import "future-wasi" "write" (func $write (param externref i32 i32) (result i32)))
+ (global $max_int64 i64 (i64.const 9223372036854775807))
+ (global $test_float64_bits f64 (f64.const 1.23))
  (memory $0 1)
+ (table $table 1 1 funcref)
+ (elem $elem (i32.const 0) $adder)
  (export "adder" (func $adder))
  (export "memory" (memory $0))
+ (export "hello" (func $hello))
+ (start $start)
  (func $adder (param $0 i32) (param $1 i32) (result i32)
   (block $add (result i32)
+   (if
+    (i32.const 0)
+    (unreachable)
+   )
    (i32.add
     (select
      (local.get $0)
@@ -17,12 +31,36 @@
    )
   )
  )
+ (func $start
+  (drop
+   (call_indirect $table (type $i32_i32_=>_i32)
+    (i32.const 3)
+    (i32.const 5)
+    (i32.const 0)
+   )
+  )
+ )
+ (func $hello (param $0 externref) (result i32)
+  (call $write
+   (local.get $0)
+   (i32.const 0)
+   (i32.const 1)
+  )
+ )
 )
 (module
+ (type $none_=>_none (func))
+ (type $externref_=>_i32 (func (param externref) (result i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
+ (type $externref_i32_i32_=>_i32 (func (param externref i32 i32) (result i32)))
+ (import "future-wasi" "write" (func $write (param externref i32 i32) (result i32)))
  (memory $0 1)
+ (table $table 1 1 funcref)
+ (elem $elem (i32.const 0) $adder)
  (export "adder" (func $adder))
  (export "memory" (memory $0))
+ (export "hello" (func $hello))
+ (start $start)
  (func $adder (; has Stack IR ;) (param $0 i32) (param $1 i32) (result i32)
   (i32.add
    (select
@@ -35,12 +73,35 @@
    (local.get $1)
   )
  )
+ (func $start (; has Stack IR ;)
+  (drop
+   (call $adder
+    (i32.const 3)
+    (i32.const 5)
+   )
+  )
+ )
+ (func $hello (; has Stack IR ;) (param $0 externref) (result i32)
+  (call $write
+   (local.get $0)
+   (i32.const 0)
+   (i32.const 1)
+  )
+ )
 )
 (module
+ (type $none_=>_none (func))
+ (type $externref_=>_i32 (func (param externref) (result i32)))
  (type $i32_i32_=>_i32 (func (param i32 i32) (result i32)))
+ (type $externref_i32_i32_=>_i32 (func (param externref i32 i32) (result i32)))
+ (import "future-wasi" "write" (func $fimport$0 (param externref i32 i32) (result i32)))
  (memory $0 1)
+ (table $0 1 1 funcref)
+ (elem (i32.const 0) $0)
  (export "adder" (func $0))
  (export "memory" (memory $0))
+ (export "hello" (func $2))
+ (start $1)
  (func $0 (param $0 i32) (param $1 i32) (result i32)
   (i32.add
    (select
@@ -53,4 +114,19 @@
    (local.get $1)
   )
  )
+ (func $1
+  (drop
+   (call $0
+    (i32.const 3)
+    (i32.const 5)
+   )
+  )
+ )
+ (func $2 (param $0 externref) (result i32)
+  (call $fimport$0
+   (local.get $0)
+   (i32.const 0)
+   (i32.const 1)
+  )
+ )
 )

binaryen-archive/test/test.ml

@@ -1,45 +1,147 @@
 open Binaryen
 
+(* Testing colors enable *)
+let _ = assert (Settings.are_colors_enabled () == true)
+
+let _ = Settings.set_colors_enabled false
+
+let _ = assert (Settings.are_colors_enabled () == false)
+
+let _ = Settings.set_colors_enabled true
+
+(* Testing debug_info enable *)
+let _ = assert (Settings.get_debug_info () == false)
+
+let _ = Settings.set_debug_info true
+
+let _ = assert (Settings.get_debug_info () == true)
+
+let _ = Settings.set_debug_info 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
+
 let wasm_mod = Module.create ()
 
+let _ = Module.set_features wasm_mod [ Module.Feature.all ]
+
 (* Create function type for i32 (i32, i32) *)
-let params = Type.create [| Type.int32; Type.int32 |]
+let params () = Type.create [| Type.int32; Type.int32 |]
 
 let results = Type.int32
 
-let x () = Expression.local_get wasm_mod 0 Type.int32
+let x () = Expression.Local_get.make wasm_mod 0 Type.int32
 
-let y () = Expression.local_get wasm_mod 1 Type.int32
+let y () = Expression.Local_get.make wasm_mod 1 Type.int32
 
-let load = Expression.load wasm_mod 1 ~signed:true 0 0 Type.int32 (y ())
+let load = Expression.Load.make wasm_mod 1 ~signed:true 0 0 Type.int32 (y ())
 
-let select = Expression.select wasm_mod (Expression.const wasm_mod (Literal.int32 1l)) (x ()) load
+let select =
+  Expression.Select.make wasm_mod
+    (Expression.Const.make wasm_mod (Literal.int32 1l))
+    (x ()) load
 
-let bin = Expression.binary wasm_mod Op.add_int32 select (y ())
+let bin = Expression.Binary.make wasm_mod Op.add_int32 select (y ())
 
-let add = Expression.block wasm_mod ~return_type:Type.int32 "add" [bin]
+let add =
+  Expression.Block.make wasm_mod ~return_type:Type.int32 "add"
+    [
+      Expression.If.make wasm_mod
+        (Expression.Const.make wasm_mod (Literal.int32 0l))
+        (Expression.Unreachable.make wasm_mod)
+        (Expression.Null.make ());
+      bin;
+    ]
 
 (* Create the add function *)
-let adder = Function.add_function wasm_mod "adder" params results [||] add
+let adder = Function.add_function wasm_mod "adder" (params ()) results [||] add
+
+let call_adder =
+  Expression.Call_indirect.make wasm_mod "table"
+    (Expression.Const.make wasm_mod (Literal.int32 0l))
+    [
+      Expression.Const.make wasm_mod (Literal.int32 3l);
+      Expression.Const.make wasm_mod (Literal.int32 5l);
+    ]
+    (params ()) Type.int32
+
+let start =
+  Function.add_function wasm_mod "start" Type.none Type.none [||]
+    (Expression.Drop.make wasm_mod call_adder)
 
 let _ = Export.add_function_export wasm_mod "adder" "adder"
 
+let _ = Table.add_table wasm_mod "table" 1 1
+
+let _ =
+  Global.add_global wasm_mod "max_int64" Type.int64 false
+    (Expression.Const.make wasm_mod (Literal.int64 Int64.max_int))
+
+let _ =
+  Global.add_global wasm_mod "test_float64_bits" Type.float64 false
+    (Expression.Const.make wasm_mod (Literal.float64_bits 0x3FF3AE147AE147AEL))
+
+let _ =
+  Table.add_active_element_segment wasm_mod "table" "elem" [ "adder" ]
+    (Expression.Const.make wasm_mod (Literal.int32 0l))
+
+let _ = Function.set_start wasm_mod start
+
 let _ = Memory.set_memory wasm_mod 1 Memory.unlimited "memory" [] false
 
+(* Create an imported "write" function i32 (externref, i32, i32) *)
+(* Similar to the example here: https://bytecodealliance.org/articles/reference-types-in-wasmtime *)
+
+let _ =
+  Import.add_function_import wasm_mod "write" "future-wasi" "write"
+    (Type.create [| Type.externref; Type.int32; Type.int32 |])
+    Type.int32
+
+(* Create a function that calls the imported write function *)
+let _ =
+  Function.add_function wasm_mod "hello" Type.externref Type.int32 [||]
+    (Expression.Call.make wasm_mod "write"
+       [
+         Expression.Local_get.make wasm_mod 0 Type.externref;
+         Expression.Const.make wasm_mod (Literal.int32 0l);
+         Expression.Const.make wasm_mod (Literal.int32 1l);
+       ]
+       Type.int32)
+
+let _ = Export.add_function_export wasm_mod "hello" "hello"
+
+(* Finally, we print 3 versions of the module to be checked against test.expected *)
+
+(* 1. Print the the module as-is *)
+
 let _ = Module.print wasm_mod
 
+(* 2. Optimize, then print the module *)
+
 let _ = Module.optimize wasm_mod
 
 let _ = Module.print wasm_mod
 
+(* 3. Copy previous module bytes into new module, validate, and print *)
+
 let byts, _ = Module.write wasm_mod None
 
 let new_mod = Module.read byts
 
+let _ = Module.set_features new_mod [ Module.Feature.all ]
+
 let _ = Module.validate new_mod
 
 let _ = Module.print new_mod
 
+(* Dispose the modules 👋 *)
+
 let _ = Module.dispose wasm_mod
 
 let _ = Module.dispose new_mod

binaryen-archive/virtual/dune

@@ -1,6 +1,6 @@
 (library
  (name binaryen)
  (public_name binaryen)
- (virtual_modules export expression features function function_table global
-   import literal memory module op type)
+ (virtual_modules element_segment export expression function global import
+   literal memory module op settings table type)
  (default_implementation binaryen.native))

binaryen-archive/virtual/element_segment.mli

@@ -0,0 +1,11 @@
+type t
+
+val get_name : t -> string
+
+val get_table : t -> string
+
+val get_offset : t -> Expression.t
+
+val get_length : t -> int
+
+val get_data : t -> int -> string

binaryen-archive/virtual/export.mli

@@ -8,4 +8,26 @@ val add_memory_export : Module.t -> string -> string -> t
 
 val add_global_export : Module.t -> string -> string -> t
 
+val get_export : Module.t -> string -> t
+
 val remove_export : Module.t -> string -> unit
+
+val get_num_exports : Module.t -> int
+
+val get_export_by_index : Module.t -> int -> t
+
+val get_name : t -> string
+
+val get_value : t -> string
+
+val external_function : int
+
+val external_table : int
+
+val external_memory : int
+
+val external_global : int
+
+val external_event : int
+
+val export_get_kind : t -> int