@grain/binaryen.ml 0.33.0 → 0.35.0

binaryen-archive/test/test.expected

@@ -7,11 +7,12 @@
  (i32.const 0)
 )
 (module
- (type $0 (func (param i32 i32) (result i32)))
- (type $1 (func))
- (type $2 (func (param anyref i32 i32) (result i32)))
- (type $3 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $write (type $2) (param anyref i32 i32) (result i32)))
+ (type $0 (func (param i32)))
+ (type $1 (func (param i32 i32) (result i32)))
+ (type $2 (func))
+ (type $3 (func (param anyref i32 i32) (result i32)))
+ (type $4 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $write (type $3) (param anyref i32 i32) (result i32)))
  (global $max_int64 i64 (i64.const 9223372036854775807))
  (global $max_int64_mut (mut i64) (i64.const 9223372036854775807))
  (global $test_float64_bits f64 (f64.const 1.23))
@@ -20,11 +21,14 @@
  (data $world "world")
  (table $table 1 1 funcref)
  (elem $elem (i32.const 0) $adder)
+ (tag $foo (type $0) (param i32))
+ (tag $bar (type $0) (param i32))
  (export "adder" (func $adder))
  (export "memory" (memory $0))
  (export "hello" (func $hello))
+ (export "try" (func $try))
  (start $start)
- (func $adder (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (func $adder (type $1) (param $0 i32) (param $1 i32) (result i32)
   (block $add (result i32)
    (if
     (i32.const 0)
@@ -44,7 +48,7 @@
    )
   )
  )
- (func $start (type $1)
+ (func $start (type $2)
   (block $start
    (memory.init $world
     (i32.const 2048)
@@ -52,7 +56,7 @@
     (i32.const 5)
    )
    (drop
-    (call_indirect $table (type $0)
+    (call_indirect $table (type $1)
      (i32.const 3)
      (i32.const 5)
      (i32.const 0)
@@ -60,30 +64,102 @@
    )
   )
  )
- (func $hello (type $3) (param $0 anyref) (result i32)
+ (func $hello (type $4) (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
    (i32.const 1)
   )
  )
+ (func $try (type $2)
+  (block $blk
+   (drop
+    (try $tc1 (result i32)
+     (do
+      (throw $foo
+       (i32.const 1)
+      )
+     )
+     (catch $foo
+      (block $tc1blk2 (result i32)
+       (drop
+        (pop i32)
+       )
+       (i32.const 2)
+      )
+     )
+     (catch $bar
+      (block $tc1blk3 (result i32)
+       (drop
+        (pop i32)
+       )
+       (i32.const 3)
+      )
+     )
+    )
+   )
+   (try $tc2
+    (do
+     (throw $foo
+      (i32.const 1)
+     )
+    )
+    (catch $foo
+     (block $tc2blk2
+      (drop
+       (pop i32)
+      )
+     )
+    )
+    (catch $bar
+     (block $tc2blk3
+      (drop
+       (pop i32)
+      )
+     )
+    )
+   )
+   (drop
+    (try $tc3 (result i32)
+     (do
+      (i32.const 1)
+     )
+     (catch $foo
+      (block $tc3blk2 (result i32)
+       (drop
+        (pop i32)
+       )
+       (i32.const 2)
+      )
+     )
+     (catch_all
+      (i32.const 3)
+     )
+    )
+   )
+  )
+ )
 )
 (module
- (type $0 (func (param i32 i32) (result i32)))
+ (type $0 (func (param i32)))
  (type $1 (func))
- (type $2 (func (param anyref i32 i32) (result i32)))
- (type $3 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $write (type $2) (param anyref i32 i32) (result i32)))
+ (type $2 (func (param i32 i32) (result i32)))
+ (type $3 (func (param anyref i32 i32) (result i32)))
+ (type $4 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $write (type $3) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $hello (i32.const 0) "hello")
  (data $world "world")
  (table $table 1 1 funcref)
  (elem $elem (i32.const 0) $adder)
+ (tag $foo (type $0) (param i32))
+ (tag $bar (type $0) (param i32))
  (export "adder" (func $adder))
  (export "memory" (memory $0))
  (export "hello" (func $hello))
+ (export "try" (func $try))
  (start $start)
- (func $adder (type $0) (param $0 i32) (param $1 i32) (result i32)
+ (func $adder (type $2) (param $0 i32) (param $1 i32) (result i32)
   (i32.add
    (select
     (local.get $0)
@@ -108,20 +184,60 @@
    )
   )
  )
- (func $hello (type $3) (param $0 anyref) (result i32)
+ (func $hello (type $4) (param $0 anyref) (result i32)
   (call $write
    (local.get $0)
    (i32.const 0)
    (i32.const 1)
   )
  )
+ (func $try (type $1)
+  (drop
+   (try (result i32)
+    (do
+     (throw $foo
+      (i32.const 1)
+     )
+    )
+    (catch $foo
+     (drop
+      (pop i32)
+     )
+     (i32.const 2)
+    )
+    (catch $bar
+     (drop
+      (pop i32)
+     )
+     (i32.const 3)
+    )
+   )
+  )
+  (try
+   (do
+    (throw $foo
+     (i32.const 1)
+    )
+   )
+   (catch $foo
+    (drop
+     (pop i32)
+    )
+   )
+   (catch $bar
+    (drop
+     (pop i32)
+    )
+   )
+  )
+ )
 )
 (module
- (type $type (func (param anyref i32 i32) (result i32)))
- (type $type_1 (func (param i32 i32) (result i32)))
- (type $type_2 (func))
- (type $type_3 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $fimport$0 (type $type) (param anyref i32 i32) (result i32)))
+ (type $type_3 (func))
+ (type $type_1 (func (param anyref i32 i32) (result i32)))
+ (type $type_2 (func (param i32 i32) (result i32)))
+ (type $type_4 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $fimport$0 (type $type_1) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $0 (i32.const 0) "hello")
  (data $1 "world")
@@ -130,8 +246,9 @@
  (export "adder" (func $0))
  (export "memory" (memory $0))
  (export "hello" (func $2))
+ (export "try" (func $3))
  (start $1)
- (func $0 (type $type_1) (param $0 i32) (param $1 i32) (result i32)
+ (func $0 (type $type_2) (param $0 i32) (param $1 i32) (result i32)
   (i32.add
    (select
     (local.get $0)
@@ -143,7 +260,7 @@
    (local.get $1)
   )
  )
- (func $1 (type $type_2)
+ (func $1 (type $type_3)
   (memory.init $1
    (i32.const 2048)
    (i32.const 0)
@@ -156,20 +273,26 @@
    )
   )
  )
- (func $2 (type $type_3) (param $0 anyref) (result i32)
+ (func $2 (type $type_4) (param $0 anyref) (result i32)
   (call $fimport$0
    (local.get $0)
    (i32.const 0)
    (i32.const 1)
   )
  )
+ (func $3 (type $type_3)
+  (drop
+   (unreachable)
+  )
+  (unreachable)
+ )
 )
 (module
- (type $type (func (param anyref i32 i32) (result i32)))
- (type $type_1 (func (param i32 i32) (result i32)))
- (type $type_2 (func))
- (type $type_3 (func (param anyref) (result i32)))
- (import "future-wasi" "write" (func $fimport$0 (type $type) (param anyref i32 i32) (result i32)))
+ (type $type_3 (func))
+ (type $type_1 (func (param anyref i32 i32) (result i32)))
+ (type $type_2 (func (param i32 i32) (result i32)))
+ (type $type_4 (func (param anyref) (result i32)))
+ (import "future-wasi" "write" (func $fimport$0 (type $type_1) (param anyref i32 i32) (result i32)))
  (memory $0 1)
  (data $0 (i32.const 0) "hello")
  (data $1 "world")
@@ -178,8 +301,9 @@
  (export "adder" (func $0))
  (export "memory" (memory $0))
  (export "hello" (func $2))
+ (export "try" (func $3))
  (start $1)
- (func $0 (type $type_1) (param $0 i32) (param $1 i32) (result i32)
+ (func $0 (type $type_2) (param $0 i32) (param $1 i32) (result i32)
   local.get $0
   local.get $1
   i32.load
@@ -188,7 +312,7 @@
   local.get $1
   i32.add
  )
- (func $1 (type $type_2)
+ (func $1 (type $type_3)
   i32.const 2048
   i32.const 0
   i32.const 5
@@ -198,10 +322,13 @@
   call $0
   drop
  )
- (func $2 (type $type_3) (param $0 anyref) (result i32)
+ (func $2 (type $type_4) (param $0 anyref) (result i32)
   local.get $0
   i32.const 0
   i32.const 1
   call $fimport$0
  )
+ (func $3 (type $type_3)
+  unreachable
+ )
 )

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
@@ -250,6 +254,84 @@ let _ =
       (Memory.get_segment_data wasm_mod "world")
       (Bytes.of_string "world"))
 
+let _ = Tag.add_tag wasm_mod "foo" Type.int32 Type.none
+let _ = Tag.add_tag wasm_mod "bar" Type.int32 Type.none
+
+(* Exception handling *)
+let body =
+  Expression.Throw.make wasm_mod "foo"
+    [ Expression.Const.make wasm_mod (Literal.int32 1l) ]
+
+let try_catch_1 =
+  Expression.Try.make wasm_mod (Some "tc1") body
+    [
+      ( "foo",
+        Expression.Block.make wasm_mod "tc1blk2"
+          [
+            Expression.Drop.make wasm_mod
+              (Expression.Pop.make wasm_mod Type.int32);
+            Expression.Const.make wasm_mod (Literal.int32 2l);
+          ] );
+      ( "bar",
+        Expression.Block.make wasm_mod "tc1blk3"
+          [
+            Expression.Drop.make wasm_mod
+              (Expression.Pop.make wasm_mod Type.int32);
+            Expression.Const.make wasm_mod (Literal.int32 3l);
+          ] );
+    ]
+    None
+
+let _ = assert (Expression.Try.get_name try_catch_1 = Some "tc1")
+let _ = Expression.Try.set_name try_catch_1 "renamed_tc1"
+let _ = assert (Expression.Try.get_name try_catch_1 = Some "renamed_tc1")
+let _ = Expression.Try.set_name try_catch_1 "tc1"
+
+let _ =
+  assert (
+    Expression.get_kind (Expression.Try.get_body try_catch_1)
+    = Expression.get_kind body)
+
+let _ = assert (Expression.Try.get_num_catch_tags try_catch_1 = 2)
+let _ = assert (Expression.Try.get_num_catch_bodies try_catch_1 = 2)
+
+let try_catch_2 =
+  Expression.Try.make wasm_mod (Some "tc2")
+    (Expression.Throw.make wasm_mod "foo"
+       [ Expression.Const.make wasm_mod (Literal.int32 1l) ])
+    [
+      ( "foo",
+        Expression.Block.make wasm_mod "tc2blk2"
+          [
+            Expression.Drop.make wasm_mod
+              (Expression.Pop.make wasm_mod Type.int32);
+          ] );
+      ( "bar",
+        Expression.Block.make wasm_mod "tc2blk3"
+          [
+            Expression.Drop.make wasm_mod
+              (Expression.Pop.make wasm_mod Type.int32);
+          ] );
+    ]
+    None
+
+let _ = assert (Expression.Try.get_name try_catch_2 = Some "tc2")
+
+(* Test catch_all *)
+let try_catch_all_1 =
+  Expression.Try.make wasm_mod (Some "tc3")
+    (Expression.Const.make wasm_mod (Literal.int32 1l))
+    [
+      ( "foo",
+        Expression.Block.make wasm_mod "tc3blk2"
+          [
+            Expression.Drop.make wasm_mod
+              (Expression.Pop.make wasm_mod Type.int32);
+            Expression.Const.make wasm_mod (Literal.int32 2l);
+          ] );
+    ]
+    (Some (Expression.Const.make wasm_mod (Literal.int32 3l)))
+
 (* Create an imported "write" function i32 (externref, i32, i32) *)
 (* Similar to the example here: https://bytecodealliance.org/articles/reference-types-in-wasmtime *)
 
@@ -269,7 +351,18 @@ let _ =
        ]
        Type.int32)
 
+(* Create a function with try *)
+let _ =
+  Function.add_function wasm_mod "try" Type.none Type.none [||]
+    (Expression.Block.make wasm_mod "blk"
+       [
+         Expression.Drop.make wasm_mod try_catch_1;
+         try_catch_2;
+         Expression.Drop.make wasm_mod try_catch_all_1;
+       ])
+
 let _ = Export.add_function_export wasm_mod "hello" "hello"
+let _ = Export.add_function_export wasm_mod "try" "try"
 let _ = Module.validate wasm_mod
 
 (* Shouldn't actually do anything since we aren't doing function renames *)