| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| ;; RUN: foreach %s %t wasm-opt --once-reduction -all -S -o - | filecheck %s |
| |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| ;; A minimal "once" function. It is so trivial we can remove its body. |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; Call a once function more than once, in a way that we can optimize: the |
| ;; first dominates the second. The second call will become a nop. |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 100) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ;; Add some more content in the function. |
| (drop (i32.const 100)) |
| ) |
| |
| ;; CHECK: (func $caller-if-1 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-if-1 |
| ;; Add more calls, and ones that are conditional. |
| (if |
| (i32.const 1) |
| (then |
| (block |
| (call $once) |
| (call $once) |
| (call $once) |
| (call $once) |
| ) |
| ) |
| ) |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller-if-2 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-if-2 |
| ;; Call in both arms. As we only handle dominance, and not merges, the first |
| ;; call after the if is *not* optimized. |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| (else |
| (block |
| (call $once) |
| (call $once) |
| ) |
| ) |
| ) |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller-loop-1 (type $0) |
| ;; CHECK-NEXT: (loop $loop |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (br_if $loop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-loop-1 |
| ;; Add calls in a loop. |
| (loop $loop |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (call $once) |
| (br_if $loop (i32.const 1)) |
| ) |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller-loop-2 (type $0) |
| ;; CHECK-NEXT: (loop $loop |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br_if $loop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-loop-2 |
| ;; Add a single conditional call in a loop. |
| (loop $loop |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (br_if $loop (i32.const 1)) |
| ) |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller-single (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller-single |
| ;; A short function with a single call. |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller-empty (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-empty |
| ;; A tiny function with nothing at all, just to verify we do not crash on |
| ;; such things. |
| ) |
| ) |
| |
| ;; Corner case: Initial value is not zero. We can still optimize this here, |
| ;; though in fact the function will never execute the payload call of foo(), |
| ;; which in theory we could further optimize. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "foo" (func $foo (type $0))) |
| (import "env" "foo" (func $foo)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 42)) |
| (global $once (mut i32) (i32.const 42)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $foo) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: function is not quite once, there is code before the if, so no |
| ;; optimization will happen. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "foo" (func $foo (type $0))) |
| (import "env" "foo" (func $foo)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 42)) |
| (global $once (mut i32) (i32.const 42)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (nop) |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $foo) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: a nop after the if. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "foo" (func $foo (type $0))) |
| (import "env" "foo" (func $foo)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 42)) |
| (global $once (mut i32) (i32.const 42)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (nop) |
| (global.set $once (i32.const 1)) |
| (call $foo) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: The if has an else. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "foo" (func $foo (type $0))) |
| (import "env" "foo" (func $foo)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 42)) |
| (global $once (mut i32) (i32.const 42)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| (else |
| (call $foo) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $foo) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: different global names in the get and set |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once1 (mut i32) (i32.const 0)) |
| (global $once1 (mut i32) (i32.const 0)) |
| ;; CHECK: (global $once2 (mut i32) (i32.const 0)) |
| (global $once2 (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once2 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once2 (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: The global is written a zero. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 0)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: The global is written a zero elsewhere. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| (global.set $once (i32.const 0)) |
| ) |
| ) |
| |
| ;; Corner case: The global is written a non-zero value elsewhere. This is ok to |
| ;; optimize, and in fact we can write a value different than 1 both there and |
| ;; in the "once" function, and we can still optimize. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 42)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| (global.set $once (i32.const 1337)) |
| ) |
| |
| ;; CHECK: (func $caller-2 (type $0) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1337) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller-2 |
| ;; Reverse order of the above. |
| (global.set $once (i32.const 1337)) |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; It is ok to call the "once" function inside itself - as that call appears |
| ;; behind a set of the global, the call is redundant and we optimize it away. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Non-integer global, which we ignore. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut f64) (f64.const 0)) |
| (global $once (mut f64) (f64.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.trunc_f64_s |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (f64.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| ;; We must cast this to an integer for the wasm to validate. |
| (i32.trunc_f64_s |
| (global.get $once) |
| ) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (f64.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Non-constant initial value. This is fine, as the initial value |
| ;; does not matter (if it is zero, then this is a "classic" "once" global; if |
| ;; not then it will never be written to, and the "once" function will never run |
| ;; at all, which is fine too) |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "glob" (global $import i32)) |
| (import "env" "glob" (global $import i32)) |
| |
| ;; CHECK: (global $once (mut i32) (global.get $import)) |
| (global $once (mut i32) (global.get $import)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Non-constant later value. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.eqz (i32.eqz (i32.const 1)))) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: "Once" function has a param. |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) (param $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once (param $x i32) |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $1) |
| ;; CHECK-NEXT: (call $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once (i32.const 1)) |
| (call $once (i32.const 1)) |
| ) |
| ) |
| |
| ;; Corner case: "Once" function has a result. |
| (module |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) (result i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 3) |
| ;; CHECK-NEXT: ) |
| (func $once (result i32) |
| (if |
| (global.get $once) |
| (then |
| (return (i32.const 2)) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (i32.const 3) |
| ) |
| |
| ;; CHECK: (func $caller (type $1) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (drop (call $once)) |
| (drop (call $once)) |
| ) |
| ) |
| |
| ;; Corner case: "Once" function body is not a block. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (loop $loop |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (loop $loop |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Once body is too short. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Additional reads of the global. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| (drop (global.get $once)) |
| ) |
| ) |
| |
| ;; Corner case: Additional reads of the global in the "once" func. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (drop (global.get $once)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Optimization opportunties in unreachable code (which we can |
| ;; ignore, but should not error on). |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| (unreachable) |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Add a very long chain of control flow. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (nop) |
| ) |
| (else |
| (nop) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (nop) |
| ) |
| (else |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (nop) |
| ) |
| (else |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; A test with a try-catch. This verifies that we emit their contents properly |
| ;; in reverse postorder and do not hit any assertions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (param i32))) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (tag $tag (param i32)) |
| (tag $tag (param i32)) |
| |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $try-catch (type $0) |
| ;; CHECK-NEXT: (try $label$5 |
| ;; CHECK-NEXT: (do |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (catch $tag |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (pop i32) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $try-catch |
| (try $label$5 |
| (do |
| (if |
| (i32.const 1) |
| (then |
| (call $once) |
| ) |
| ) |
| ) |
| (catch $tag |
| (drop |
| (pop i32) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; Test a module with more than one global that we can optimize, and more than |
| ;; one that we cannot. |
| |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once1 (mut i32) (i32.const 0)) |
| (global $once1 (mut i32) (i32.const 0)) |
| ;; CHECK: (global $many1 (mut i32) (i32.const 0)) |
| (global $many1 (mut i32) (i32.const 0)) |
| ;; CHECK: (global $once2 (mut i32) (i32.const 0)) |
| (global $once2 (mut i32) (i32.const 0)) |
| ;; CHECK: (global $many2 (mut i32) (i32.const 0)) |
| (global $many2 (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once1 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (call $once2) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: ) |
| (func $once1 |
| (if |
| (global.get $once1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once1 (i32.const 1)) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| ) |
| |
| ;; CHECK: (func $many1 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $many1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $many1 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (call $once1) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (call $once2) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $many1 |
| (if |
| (global.get $many1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $many1 (i32.const 0)) ;; prevent this global being "once" |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| ) |
| |
| ;; CHECK: (func $once2 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once2) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once2 |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (call $once1) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: ) |
| (func $once2 |
| (if |
| (global.get $once2) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once2 (i32.const 2)) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| ) |
| |
| ;; CHECK: (func $many2 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $many2) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $many1 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (call $once2) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (call $once1) |
| ;; CHECK-NEXT: (call $many1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $many2) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $many2 |
| (if |
| (global.get $many2) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $many1 (i32.const 0)) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| (call $many1) |
| (call $once2) |
| (call $many2) |
| (call $once1) |
| ) |
| ) |
| |
| ;; Test for propagation of information about called functions: if A->B->C->D |
| ;; and D calls some "once" functions, then A can infer that it's call to B does |
| ;; so. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $A (type $0) |
| ;; CHECK-NEXT: (call $B) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $A |
| ;; We can infer that calling B calls C and then D, and D calls this "once" |
| ;; function, so we can remove the call after it |
| (call $B) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $B (type $0) |
| ;; CHECK-NEXT: (call $C) |
| ;; CHECK-NEXT: ) |
| (func $B |
| (call $C) |
| ) |
| |
| ;; CHECK: (func $C (type $0) |
| ;; CHECK-NEXT: (call $D) |
| ;; CHECK-NEXT: ) |
| (func $C |
| (call $D) |
| ) |
| |
| ;; CHECK: (func $D (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $D |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $bad-A (type $0) |
| ;; CHECK-NEXT: (call $bad-B) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $bad-A |
| ;; Call a function that does *not* do anything useful. We should not remove |
| ;; the second call here. |
| (call $bad-B) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $bad-B (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $bad-B |
| ) |
| ) |
| |
| ;; Corner case: Imported mutable global. We cannot optimize it, since the |
| ;; outside may read and write it. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "glob" (global $once (mut i32))) |
| (import "env" "glob" (global $once (mut i32))) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Corner case: Exported mutable global. We cannot optimize it, since the |
| ;; outside may read and write it. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (export "once-global" (global $once)) |
| (export "once-global" (global $once)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Test calls of other "once" functions in "once" functions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (global $once.1 (mut i32) (i32.const 0)) |
| (global $once.1 (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: ) |
| (func $once |
| ;; A minimal "once" function, which calls another. We can remove the first |
| ;; two lines here (the early-exit logic). |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $once.1 (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once.1 |
| ;; Another minimal "once" function. It has no payload and we can empty it |
| ;; out. |
| (if |
| (global.get $once.1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once.1 (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; Call a once function more than once. The second call will become a nop. |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller$1 (type $0) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller$1 |
| ;; Two calls to the second function. Again, the second becomes a nop. |
| (call $once.1) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $caller$2 (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: ) |
| (func $caller$2 |
| ;; A mix of calls. We can remove the second in principle, because we know |
| ;; the first will call it, but we leave that for later optimizations |
| ;; ($once turns into a call to $once.1 that inlining will remove, and then |
| ;; we'll have two identical calls here). |
| (call $once) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $caller$3 (type $0) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller$3 |
| ;; Reverse of the above; again we cannot optimize (as $once.1 does not call |
| ;; $once). |
| (call $once.1) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller$4 (type $0) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (call $caller$4) |
| ;; CHECK-NEXT: ) |
| (func $caller$4 |
| ;; Here we cannot optimize, since the second function is not a "once" |
| ;; function. |
| (call $once.1) |
| (call $caller$4) |
| ) |
| ) |
| |
| ;; Test loops between "once" functions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (global $once.1 (mut i32) (i32.const 0)) |
| (global $once.1 (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: ) |
| (func $once |
| ;; This "once" function calls another, and so we can remove the early-exit |
| ;; logic. |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $once.1 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once.1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once.1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $once.1 |
| ;; This early-exit logic looks removable, since we call another "once" |
| ;; function. However, we remove that function's early-exit logic, so we |
| ;; cannot do so here (it would risk an infinite loop). |
| (if |
| (global.get $once.1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once.1 (i32.const 1)) |
| (call $once) ;; This call was added. |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; The second call will become a nop. |
| (call $once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller$1 (type $0) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller$1 |
| ;; Again, the second becomes a nop. |
| (call $once.1) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $caller$2 (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: ) |
| (func $caller$2 |
| ;; The second could become a nop, but we leave that for later optimizations |
| ;; (after inlining the call to $once becomes a call to $once.1). |
| (call $once) |
| (call $once.1) |
| ) |
| |
| ;; CHECK: (func $caller$3 (type $0) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller$3 |
| ;; Reverse order, same result (no optimization). |
| (call $once.1) |
| (call $once) |
| ) |
| ) |
| |
| ;; Test a dangerous triple loop. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (param i32))) |
| |
| ;; CHECK: (import "env" "foo" (func $import (type $1) (param i32))) |
| (import "env" "foo" (func $import (param i32))) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (global $once.1 (mut i32) (i32.const 0)) |
| (global $once.1 (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (global $once.2 (mut i32) (i32.const 0)) |
| (global $once.2 (mut i32) (i32.const 0)) |
| |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (call $once.2) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| (call $once.1) |
| ;; We cannot remove this second call. While $once.1 calls $once.2, we may |
| ;; be in this situation: a call started at $once.1, which calls $once |
| ;; (here) which then calls $once.1 which immediately exits (as the global |
| ;; has been set for it), and then we call $once.2 from here, which calls |
| ;; the other two that immediately exit as well, and then we call the import |
| ;; from there with value 2. Then we call it from here with value 0, and |
| ;; then we return to the caller, $once.1, which calls with 1, so we have |
| ;; 2, 0, 1. If we remove the call here to $once.2 then the order would be |
| ;; 0, 2, 1. |
| ;; |
| ;; The problem is that the setting of the global happens at the very start |
| ;; of the once function, but that does not mean we have executed the body |
| ;; yet, and without executing it, we cannot infer anything about other |
| ;; globals. |
| (call $once.2) |
| (call $import |
| (i32.const 0) |
| ) |
| ) |
| |
| ;; CHECK: (func $once.1 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once.1) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once.1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once.2) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once.1 |
| (if |
| (global.get $once.1) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once.1 (i32.const 1)) |
| (call $once) |
| ;; As above, by symmetry, we cannot remove this second call. |
| (call $once.2) |
| (call $import |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; CHECK: (func $once.2 (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once.2) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once.2 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $once.1) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $once.2 |
| (if |
| (global.get $once.2) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once.2 (i32.const 1)) |
| (call $once) |
| ;; As above, by symmetry, we cannot remove this second call. |
| (call $once.1) |
| (call $import |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; Test a self-loop. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ;; A recursive call. This of course does not recurse infinitely since the |
| ;; next call early exits, as the global is set, and for that reason we can |
| ;; optimize this to a nop. |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; The second call will become a nop. |
| (call $once) |
| (call $once) |
| ) |
| ) |
| |
| ;; Calls from non-"once" functions to "once" functions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $once |
| ;; A minimal "once" function. |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $do-once (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $do-once |
| ;; Call the once function. |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $do-once) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; The first proves the second is not needed, and can be nopped. |
| (call $do-once) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller2 (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $do-once) |
| ;; CHECK-NEXT: ) |
| (func $caller2 |
| ;; Reverse order of the above. We cannot optimize here: $do-once does |
| ;; nothing aside from call $once, but all we know is that it is not a "once" |
| ;; function itself, and we only remove calls to "once" functions. |
| (call $once) |
| (call $do-once) |
| ) |
| ) |
| |
| ;; Calls from "once" functions to non-"once" functions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $once (mut i32) (i32.const 0)) |
| (global $once (mut i32) (i32.const 0)) |
| |
| ;; CHECK: (func $once (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $once) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.set $once |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $other) |
| ;; CHECK-NEXT: ) |
| (func $once |
| ;; We should not remove this early-exit logic. |
| (if |
| (global.get $once) |
| (then |
| (return) |
| ) |
| ) |
| (global.set $once (i32.const 1)) |
| ;; A call to a non-"once" function. |
| (call $other) |
| ) |
| |
| ;; CHECK: (func $other (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $other |
| ) |
| |
| ;; CHECK: (func $caller (type $0) |
| ;; CHECK-NEXT: (call $other) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: ) |
| (func $caller |
| ;; There is nothing to optimize here. |
| (call $other) |
| (call $once) |
| ) |
| |
| ;; CHECK: (func $caller2 (type $0) |
| ;; CHECK-NEXT: (call $once) |
| ;; CHECK-NEXT: (call $other) |
| ;; CHECK-NEXT: ) |
| (func $caller2 |
| ;; Reverse order of the above. Also nothing to do. |
| (call $once) |
| (call $other) |
| ) |
| ) |
