@grain/binaryen.ml 0.9.0 → 0.11.1

binaryen-archive/test/test.expected

@@ -1,11 +1,17 @@
 (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 (i32.const 0) $adder)
+ (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)
@@ -27,22 +33,33 @@
  )
  (func $start
   (drop
-   (call_indirect (type $i32_i32_=>_i32)
+   (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 (i32.const 0) $adder)
+ (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
@@ -64,15 +81,26 @@
    )
   )
  )
+ (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
@@ -94,4 +122,11 @@
    )
   )
  )
+ (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,32 +1,61 @@
 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 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))
+  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"
+  Expression.Block.make wasm_mod ~return_type:Type.int32 "add"
     [
-      Expression.if_ wasm_mod
-        (Expression.const wasm_mod (Literal.int32 0l))
-        (Expression.unreachable wasm_mod)
-        (Expression.null ());
+      Expression.If.make wasm_mod
+        (Expression.Const.make wasm_mod (Literal.int32 0l))
+        (Expression.Unreachable.make wasm_mod)
+        (Expression.Null.make ());
       bin;
     ]
 
@@ -34,42 +63,85 @@ let add =
 let adder = Function.add_function wasm_mod "adder" (params ()) results [||] add
 
 let call_adder =
-  Expression.call_indirect wasm_mod "table"
-    (Expression.const wasm_mod (Literal.int32 0l))
+  Expression.Call_indirect.make wasm_mod "table"
+    (Expression.Const.make wasm_mod (Literal.int32 0l))
     [
-      Expression.const wasm_mod (Literal.int32 3l);
-      Expression.const wasm_mod (Literal.int32 5l);
+      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 wasm_mod call_adder)
+    (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_table wasm_mod "table" 1 1 [ "adder" ]
-    (Expression.const wasm_mod (Literal.int32 0l))
+  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 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