| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| ;; NOTE: This test was ported using port_passes_tests_to_lit.py and could be cleaned up. |
| |
| ;; RUN: foreach %s %t wasm-opt --directize --all-features -S -o - | filecheck %s --check-prefix=CHECK |
| ;; RUN: foreach %s %t wasm-opt --directize --pass-arg=directize-initial-contents-immutable --all-features -S -o - | filecheck %s --check-prefix=IMMUT |
| |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (table $t64 i64 5 5 funcref) |
| |
| ;; CHECK: (elem $elem (table $0) (i32.const 1) func $foo) |
| ;; IMMUT: (table $t64 i64 5 5 funcref) |
| |
| ;; IMMUT: (elem $elem (table $0) (i32.const 1) func $foo) |
| (elem $elem (i32.const 1) $foo) |
| |
| (table $t64 i64 5 5 funcref) |
| |
| ;; CHECK: (elem $elem64 (table $t64) (i64.const 1) func $foo) |
| ;; IMMUT: (elem $elem64 (table $t64) (i64.const 1) func $foo) |
| (elem $elem64 (table $t64) (i64.const 1) funcref (ref.func $foo)) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| ;; helper function |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call $foo |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (type $1 (func (param i32) (result i32))) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (type $1 (func (param i32) (result i32))) |
| |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (table $1 5 5 funcref) |
| ;; IMMUT: (table $1 5 5 funcref) |
| (table $1 5 5 funcref) |
| (elem (table $0) (i32.const 1) func $dummy) |
| (elem (table $1) (i32.const 1) func $f) |
| ;; CHECK: (elem $0 (table $0) (i32.const 1) func $dummy) |
| |
| ;; CHECK: (elem $1 (table $1) (i32.const 1) func $f) |
| |
| ;; CHECK: (func $dummy (type $1) (param $0 i32) (result i32) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (table $0) (i32.const 1) func $dummy) |
| |
| ;; IMMUT: (elem $1 (table $1) (i32.const 1) func $f) |
| |
| ;; IMMUT: (func $dummy (type $1) (param $0 i32) (result i32) |
| ;; IMMUT-NEXT: (local.get $0) |
| ;; IMMUT-NEXT: ) |
| (func $dummy (param i32) (result i32) |
| (local.get 0) |
| ) |
| ;; CHECK: (func $f (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $f (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $f (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $g (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call $f |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $g (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $f |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $g (param $x i32) (param $y i32) |
| (call_indirect $1 (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; at table edges |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (table $1 5 5 funcref) |
| ;; IMMUT: (table $1 5 5 funcref) |
| (table $1 5 5 funcref) |
| (elem (table $1) (i32.const 4) func $foo) |
| ;; CHECK: (elem $0 (table $1) (i32.const 4) func $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (table $1) (i32.const 4) func $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call $foo |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect $1 (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 4) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 0) $foo) |
| ;; CHECK: (elem $0 (i32.const 0) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 0) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call $foo |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (table $1 5 5 funcref) |
| ;; IMMUT: (table $1 5 5 funcref) |
| (table $1 5 5 funcref) |
| (elem (i32.const 0) $foo $foo $foo $foo $foo) |
| (elem (table $1) (i32.const 0) func $foo $foo $foo $foo $foo) |
| ;; CHECK: (elem $0 (table $0) (i32.const 0) func $foo $foo $foo $foo $foo) |
| |
| ;; CHECK: (elem $1 (table $1) (i32.const 0) func $foo $foo $foo $foo $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (table $0) (i32.const 0) func $foo $foo $foo $foo $foo) |
| |
| ;; IMMUT: (elem $1 (table $1) (i32.const 0) func $foo $foo $foo $foo $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call $foo |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect $1 (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; imported table. only optimizable in the immutable case. |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (import "env" "table" (table $table 5 5 funcref)) |
| ;; IMMUT: (import "env" "table" (table $table 5 5 funcref)) |
| (import "env" "table" (table $table 5 5 funcref)) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; CHECK: (func $out-of-bounds (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 999) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $out-of-bounds (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call_indirect $table (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (i32.const 999) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $out-of-bounds (param $x i32) (param $y i32) |
| ;; The index here, 999, is out of bounds. We can't optimize that even in the |
| ;; immutable case, since we only assume the initial contents in the table are |
| ;; immutable, and so something might be written to offset 999 later. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 999) |
| ) |
| ) |
| ) |
| |
| ;; exported table. only optimizable in the immutable case. |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (export "tab" (table $0)) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (export "tab" (table $0)) |
| (export "tab" (table $0)) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; non-constant table offset |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| (global $g (import "env" "g") i32) |
| |
| ;; CHECK: (import "env" "g" (global $g i32)) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (import "env" "g" (global $g i32)) |
| |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| |
| (elem (global.get $g) $foo) |
| ;; CHECK: (elem $0 (global.get $g) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (global.get $g) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| (global $g (import "env" "g") i32) |
| |
| ;; CHECK: (import "env" "g" (global $g i32)) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (import "env" "g" (global $g i32)) |
| |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| ;; CHECK: (table $1 5 5 funcref) |
| ;; IMMUT: (table $1 5 5 funcref) |
| (table $1 5 5 funcref) |
| |
| (elem (table $1) (global.get $g) func $foo) |
| ;; CHECK: (elem $0 (table $1) (global.get $g) func $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (table $1) (global.get $g) func $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $1 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (call_indirect $1 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect $1 (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; non-constant call index |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (type $1 (func (param i32 i32 i32))) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (type $1 (func (param i32 i32 i32))) |
| |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $1) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $1) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) (param $z i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (local.get $z) |
| ) |
| ) |
| ) |
| |
| ;; bad index |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.tee $y |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (drop |
| ;; IMMUT-NEXT: (local.tee $y |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| ;; Use a local.tee to show that an operand with side effects is kept/dropped. |
| (local.tee $y |
| (local.get $y) |
| ) |
| (i32.const 5) |
| ) |
| ) |
| ) |
| |
| ;; missing index |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; bad type |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $0 (func (param i32))) |
| |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $0) (param $0 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; no table |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (func $foo (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (type $0 (func (param i32))) |
| |
| ;; IMMUT: (func $foo (type $0) (param $0 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) |
| (unreachable) |
| ) |
| ) |
| |
| ;; change types |
| (module |
| (type (func)) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (table $0 8 8 funcref) |
| ;; IMMUT: (type $0 (func)) |
| |
| ;; IMMUT: (table $0 8 8 funcref) |
| (table $0 8 8 funcref) |
| ;; CHECK: (func $0 (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $0 (type $0) |
| ;; IMMUT-NEXT: (nop) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (block ;; the type of this block will change |
| (nop) |
| (call_indirect (type 0) |
| (i32.const 15) |
| ) |
| ) |
| ) |
| ) |
| |
| (module ;; indirect tail call |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo) |
| ;; CHECK: (elem $0 (i32.const 1) $foo) |
| |
| ;; CHECK: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo) |
| |
| ;; IMMUT: (func $foo (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (return_call $foo |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (return_call $foo |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| (return_call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $0 (func (param i32 i32 i32))) |
| |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $0 (func (param i32 i32 i32))) |
| |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| |
| (type $none (func)) |
| |
| ;; CHECK: (type $2 (func (param i32))) |
| |
| ;; CHECK: (table $0 5 5 funcref) |
| ;; IMMUT: (type $2 (func (param i32))) |
| |
| ;; IMMUT: (table $0 5 5 funcref) |
| (table $0 5 5 funcref) |
| (elem (i32.const 1) $foo1 $foo2) |
| ;; CHECK: (elem $0 (i32.const 1) $foo1 $foo2) |
| |
| ;; CHECK: (func $foo1 (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo1 $foo2) |
| |
| ;; IMMUT: (func $foo1 (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo1 (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $foo2 (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $foo2 (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo2 (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $select (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (local $3 i32) |
| ;; CHECK-NEXT: (local $4 i32) |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $4 |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $foo1 |
| ;; CHECK-NEXT: (local.get $3) |
| ;; CHECK-NEXT: (local.get $4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $foo2 |
| ;; CHECK-NEXT: (local.get $3) |
| ;; CHECK-NEXT: (local.get $4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (local $3 i32) |
| ;; IMMUT-NEXT: (local $4 i32) |
| ;; IMMUT-NEXT: (local.set $3 |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (local.set $4 |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (if |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (then |
| ;; IMMUT-NEXT: (call $foo1 |
| ;; IMMUT-NEXT: (local.get $3) |
| ;; IMMUT-NEXT: (local.get $4) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (else |
| ;; IMMUT-NEXT: (call $foo2 |
| ;; IMMUT-NEXT: (local.get $3) |
| ;; IMMUT-NEXT: (local.get $4) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select (param $x i32) (param $y i32) (param $z i32) |
| ;; Test we can optimize a call_indirect whose index is a select between two |
| ;; constants. We can emit an if and two direct calls for that. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (i32.const 1) |
| (i32.const 2) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-bad-1 (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-bad-1 (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (i32.const 2) |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-bad-1 (param $x i32) (param $y i32) (param $z i32) |
| ;; As above but one select arm is not constant. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (local.get $z) |
| (i32.const 2) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-bad-2 (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-bad-2 (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (i32.const 2) |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-bad-2 (param $x i32) (param $y i32) (param $z i32) |
| ;; As above but the other select arm is not constant. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (i32.const 2) |
| (local.get $z) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-out-of-range (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (local $3 i32) |
| ;; CHECK-NEXT: (local $4 i32) |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $4 |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $foo2 |
| ;; CHECK-NEXT: (local.get $3) |
| ;; CHECK-NEXT: (local.get $4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-out-of-range (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (local $3 i32) |
| ;; IMMUT-NEXT: (local $4 i32) |
| ;; IMMUT-NEXT: (local.set $3 |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (local.set $4 |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (if |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (then |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (else |
| ;; IMMUT-NEXT: (call $foo2 |
| ;; IMMUT-NEXT: (local.get $3) |
| ;; IMMUT-NEXT: (local.get $4) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-out-of-range (param $x i32) (param $y i32) (param $z i32) |
| ;; Both are constants, but one is out of range for the table, and there is no |
| ;; valid function to call there; emit an unreachable. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (i32.const 99999) |
| (i32.const 2) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-both-out-of-range (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (local $3 i32) |
| ;; CHECK-NEXT: (local $4 i32) |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $4 |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-both-out-of-range (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (local $3 i32) |
| ;; IMMUT-NEXT: (local $4 i32) |
| ;; IMMUT-NEXT: (local.set $3 |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (local.set $4 |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (if |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (then |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (else |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-both-out-of-range (param $x i32) (param $y i32) (param $z i32) |
| ;; Both are constants, and both are out of range for the table. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (i32.const 99999) |
| (i32.const -1) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-unreachable-operand (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-unreachable-operand (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: (i32.const 2) |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-unreachable-operand (param $x i32) (param $y i32) (param $z i32) |
| ;; One operand is unreachable. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (unreachable) |
| (i32.const 2) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-unreachable-condition (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-unreachable-condition (type $0) (param $x i32) (param $y i32) (param $z i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: (i32.const 2) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-unreachable-condition (param $x i32) (param $y i32) (param $z i32) |
| ;; The condition is unreachable. We should not even create any vars here, and |
| ;; just not do anything. |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (select |
| (i32.const 1) |
| (i32.const 2) |
| (unreachable) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $select-bad-type (type $2) (param $z i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $z) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-bad-type (type $2) (param $z i32) |
| ;; IMMUT-NEXT: (if |
| ;; IMMUT-NEXT: (local.get $z) |
| ;; IMMUT-NEXT: (then |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (else |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-bad-type (param $z i32) |
| ;; The type here is $none, which does not match the functions at indexes 1 and |
| ;; 2, so we know they will trap and can emit unreachables. |
| (call_indirect (type $none) |
| (select |
| (i32.const 1) |
| (i32.const 2) |
| (local.get $z) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; CHECK: (type $F (func (param (ref func)))) |
| |
| ;; CHECK: (type $1 (func (param i32))) |
| |
| ;; CHECK: (type $2 (func)) |
| |
| ;; CHECK: (table $0 15 15 funcref) |
| ;; IMMUT: (type $F (func (param (ref func)))) |
| |
| ;; IMMUT: (type $1 (func (param i32))) |
| |
| ;; IMMUT: (type $2 (func)) |
| |
| ;; IMMUT: (table $0 15 15 funcref) |
| (table $0 15 15 funcref) |
| (type $F (func (param (ref func)))) |
| (elem (i32.const 10) $foo-ref $foo-ref) |
| |
| ;; CHECK: (elem $0 (i32.const 10) $foo-ref $foo-ref) |
| |
| ;; CHECK: (elem declare func $select-non-nullable) |
| |
| ;; CHECK: (func $foo-ref (type $F) (param $0 (ref func)) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 10) $foo-ref $foo-ref) |
| |
| ;; IMMUT: (elem declare func $select-non-nullable) |
| |
| ;; IMMUT: (func $foo-ref (type $F) (param $0 (ref func)) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo-ref (param (ref func)) |
| ;; helper function |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $select-non-nullable (type $1) (param $x i32) |
| ;; CHECK-NEXT: (local $1 (ref $1)) |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.func $select-non-nullable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $foo-ref |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $foo-ref |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-non-nullable (type $1) (param $x i32) |
| ;; IMMUT-NEXT: (local $1 (ref $1)) |
| ;; IMMUT-NEXT: (local.set $1 |
| ;; IMMUT-NEXT: (ref.func $select-non-nullable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (if |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (then |
| ;; IMMUT-NEXT: (call $foo-ref |
| ;; IMMUT-NEXT: (local.get $1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (else |
| ;; IMMUT-NEXT: (call $foo-ref |
| ;; IMMUT-NEXT: (local.get $1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-non-nullable (param $x i32) |
| ;; Test we can handle a non-nullable value when optimizing a select, during |
| ;; which we place values in locals. The local can remain non-nullable since it |
| ;; dominates the uses. |
| (call_indirect (type $F) |
| (ref.func $select-non-nullable) |
| (select |
| (i32.const 10) |
| (i32.const 11) |
| (local.get $x) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $select-non-nullable-unreachable-condition (type $2) |
| ;; CHECK-NEXT: (call_indirect $0 (type $F) |
| ;; CHECK-NEXT: (ref.func $select-non-nullable) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 11) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-non-nullable-unreachable-condition (type $2) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $F) |
| ;; IMMUT-NEXT: (ref.func $select-non-nullable) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (i32.const 10) |
| ;; IMMUT-NEXT: (i32.const 11) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-non-nullable-unreachable-condition |
| ;; Test we ignore an unreachable condition and don't make any changes at all |
| ;; to the code (in particular, we shouldn't add any vars). |
| (call_indirect (type $F) |
| (ref.func $select-non-nullable) |
| (select |
| (i32.const 10) |
| (i32.const 11) |
| (unreachable) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $select-non-nullable-unreachable-arm (type $2) |
| ;; CHECK-NEXT: (call_indirect $0 (type $F) |
| ;; CHECK-NEXT: (ref.func $select-non-nullable) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (f32.const 3.141590118408203) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-non-nullable-unreachable-arm (type $2) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $F) |
| ;; IMMUT-NEXT: (ref.func $select-non-nullable) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (f32.const 3.141590118408203) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-non-nullable-unreachable-arm |
| ;; Test we ignore an unreachable arm and don't make any changes at all |
| ;; to the code (in particular, we shouldn't add any vars). |
| (call_indirect (type $F) |
| (ref.func $select-non-nullable) |
| (select |
| ;; Note how the type here is not even an i32, so we must not even try to |
| ;; look into the select's values at all - the select is unreachable and we |
| ;; should give up on optimizing. |
| (f32.const 3.14159) |
| (unreachable) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $select-non-nullable-unreachable-arg (type $1) (param $x i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $F) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 11) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $select-non-nullable-unreachable-arg (type $1) (param $x i32) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $F) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: (select |
| ;; IMMUT-NEXT: (i32.const 10) |
| ;; IMMUT-NEXT: (i32.const 11) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $select-non-nullable-unreachable-arg (param $x i32) |
| ;; Test we ignore an unreachable argument and don't make any changes at all |
| ;; to the code (in particular, we shouldn't add any vars). |
| (call_indirect (type $F) |
| (unreachable) |
| (select |
| (i32.const 10) |
| (i32.const 11) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; A table.set prevents optimization. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| ;; CHECK: (table $has-set 5 5 funcref) |
| ;; IMMUT: (table $has-set 5 5 funcref) |
| (table $has-set 5 5 funcref) |
| |
| ;; CHECK: (table $no-set 5 5 funcref) |
| ;; IMMUT: (table $no-set 5 5 funcref) |
| (table $no-set 5 5 funcref) |
| |
| ;; CHECK: (elem $0 (table $has-set) (i32.const 1) func $foo) |
| ;; IMMUT: (elem $0 (table $has-set) (i32.const 1) func $foo) |
| (elem $0 (table $has-set) (i32.const 1) func $foo) |
| |
| ;; CHECK: (elem $1 (table $no-set) (i32.const 1) func $foo) |
| ;; IMMUT: (elem $1 (table $no-set) (i32.const 1) func $foo) |
| (elem $1 (table $no-set) (i32.const 1) func $foo) |
| |
| ;; CHECK: (func $foo (type $v) |
| ;; CHECK-NEXT: (table.set $has-set |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (ref.func $foo) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $foo (type $v) |
| ;; IMMUT-NEXT: (table.set $has-set |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: (ref.func $foo) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $foo |
| ;; Technically this set writes the same value as is already there, but the |
| ;; analysis will give up on optimizing when it sees any set to a table. |
| (table.set $has-set |
| (i32.const 1) |
| (ref.func $foo) |
| ) |
| ) |
| |
| ;; CHECK: (func $bar (type $v) |
| ;; CHECK-NEXT: (call_indirect $has-set (type $v) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $foo) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $v) |
| ;; IMMUT-NEXT: (call $foo) |
| ;; IMMUT-NEXT: (call $foo) |
| ;; IMMUT-NEXT: ) |
| (func $bar |
| ;; We can't optimize this one, but we can the one after it. (But we can |
| ;; optimize both in the immutable case.) |
| (call_indirect $has-set (type $v) |
| (i32.const 1) |
| ) |
| (call_indirect $no-set (type $v) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; An imported table with a non-contiguous range in the initial contents. |
| (module |
| ;; CHECK: (type $ii (func (param i32 i32))) |
| ;; IMMUT: (type $ii (func (param i32 i32))) |
| (type $ii (func (param i32 i32))) |
| |
| ;; CHECK: (import "env" "table" (table $table 5 5 funcref)) |
| ;; IMMUT: (import "env" "table" (table $table 5 5 funcref)) |
| (import "env" "table" (table $table 5 5 funcref)) |
| (elem (i32.const 1) $foo1) |
| (elem (i32.const 3) $foo2) |
| |
| ;; CHECK: (elem $0 (i32.const 1) $foo1) |
| |
| ;; CHECK: (elem $1 (i32.const 3) $foo2) |
| |
| ;; CHECK: (func $foo1 (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (elem $0 (i32.const 1) $foo1) |
| |
| ;; IMMUT: (elem $1 (i32.const 3) $foo2) |
| |
| ;; IMMUT: (func $foo1 (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo1 (param i32) (param i32) |
| (unreachable) |
| ) |
| ;; CHECK: (func $foo2 (type $ii) (param $0 i32) (param $1 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $foo2 (type $ii) (param $0 i32) (param $1 i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $foo2 (param i32) (param i32) |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $table (type $ii) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (i32.const 4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $bar (type $ii) (param $x i32) (param $y i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: (call $foo1 |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: (call $foo2 |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: (call_indirect $table (type $ii) |
| ;; IMMUT-NEXT: (local.get $x) |
| ;; IMMUT-NEXT: (local.get $y) |
| ;; IMMUT-NEXT: (i32.const 4) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $bar (param $x i32) (param $y i32) |
| ;; When assuming the initial contents are immutable, we can optimize some |
| ;; of these cases. 0 and 2 are offsets that are known to contain a null, so |
| ;; they will trap, and 1 and 3 contain known contents we can do a direct call |
| ;; to. 4 is out of bounds so we cannot optimize there. (And in all of these, |
| ;; we cannot optimize anything in the non-immutable case, since the table is |
| ;; imported.) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 0) |
| ) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 1) |
| ) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 2) |
| ) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 3) |
| ) |
| (call_indirect (type $ii) |
| (local.get $x) |
| (local.get $y) |
| (i32.const 4) |
| ) |
| ) |
| ) |
| |
| ;; A table.fill prevents optimization. |
| (module |
| ;; CHECK: (type $i32 (func (result i32))) |
| ;; IMMUT: (type $i32 (func (result i32))) |
| (type $i32 (func (result i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (table $table 111 funcref) |
| ;; IMMUT: (type $1 (func)) |
| |
| ;; IMMUT: (table $table 111 funcref) |
| (table $table 111 funcref) |
| (elem (i32.const 0) $func-A) |
| |
| ;; CHECK: (elem $0 (i32.const 0) $func-A) |
| |
| ;; CHECK: (elem declare func $func-B) |
| |
| ;; CHECK: (export "a" (func $fill)) |
| ;; IMMUT: (elem $0 (i32.const 0) $func-A) |
| |
| ;; IMMUT: (elem declare func $func-B) |
| |
| ;; IMMUT: (export "a" (func $fill)) |
| (export "a" (func $fill)) |
| ;; CHECK: (export "b" (func $call)) |
| ;; IMMUT: (export "b" (func $call)) |
| (export "b" (func $call)) |
| |
| ;; CHECK: (func $func-A (type $i32) (result i32) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $func-A (type $i32) (result i32) |
| ;; IMMUT-NEXT: (i32.const 0) |
| ;; IMMUT-NEXT: ) |
| (func $func-A (result i32) |
| (i32.const 0) |
| ) |
| |
| ;; CHECK: (func $func-B (type $i32) (result i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $func-B (type $i32) (result i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $func-B (result i32) |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $fill (type $1) |
| ;; CHECK-NEXT: (table.fill $table |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (ref.func $func-B) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $fill (type $1) |
| ;; IMMUT-NEXT: (table.fill $table |
| ;; IMMUT-NEXT: (i32.const 0) |
| ;; IMMUT-NEXT: (ref.func $func-B) |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $fill |
| (table.fill $table |
| (i32.const 0) |
| (ref.func $func-B) |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; CHECK: (func $call (type $1) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $table (type $i32) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $call (type $1) |
| ;; IMMUT-NEXT: (drop |
| ;; IMMUT-NEXT: (call $func-A) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $call |
| (drop |
| ;; This cannot be turned into a direct call due to the table.fill, unless we |
| ;; assume initial contents are immutable. |
| (call_indirect (type $i32) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; A table.init prevents optimization. |
| (module |
| ;; CHECK: (type $i32 (func (result i32))) |
| ;; IMMUT: (type $i32 (func (result i32))) |
| (type $i32 (func (result i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (table $table 111 funcref) |
| ;; IMMUT: (type $1 (func)) |
| |
| ;; IMMUT: (table $table 111 funcref) |
| (table $table 111 funcref) |
| (elem (i32.const 0) $func-A) |
| |
| ;; CHECK: (elem $0 (i32.const 0) $func-A) |
| |
| ;; CHECK: (elem $elem func $func-B) |
| ;; IMMUT: (elem $0 (i32.const 0) $func-A) |
| |
| ;; IMMUT: (elem $elem func $func-B) |
| (elem $elem $func-B) |
| |
| ;; CHECK: (export "a" (func $init)) |
| ;; IMMUT: (export "a" (func $init)) |
| (export "a" (func $init)) |
| ;; CHECK: (export "b" (func $call)) |
| ;; IMMUT: (export "b" (func $call)) |
| (export "b" (func $call)) |
| |
| ;; CHECK: (func $func-A (type $i32) (result i32) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $func-A (type $i32) (result i32) |
| ;; IMMUT-NEXT: (i32.const 0) |
| ;; IMMUT-NEXT: ) |
| (func $func-A (result i32) |
| (i32.const 0) |
| ) |
| |
| ;; CHECK: (func $func-B (type $i32) (result i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $func-B (type $i32) (result i32) |
| ;; IMMUT-NEXT: (unreachable) |
| ;; IMMUT-NEXT: ) |
| (func $func-B (result i32) |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $init (type $1) |
| ;; CHECK-NEXT: (table.init $table $elem |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $init (type $1) |
| ;; IMMUT-NEXT: (table.init $table $elem |
| ;; IMMUT-NEXT: (i32.const 0) |
| ;; IMMUT-NEXT: (i32.const 0) |
| ;; IMMUT-NEXT: (i32.const 1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $init |
| (table.init $table $elem |
| (i32.const 0) |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; CHECK: (func $call (type $1) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $table (type $i32) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (func $call (type $1) |
| ;; IMMUT-NEXT: (drop |
| ;; IMMUT-NEXT: (call $func-A) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $call |
| (drop |
| ;; This cannot be turned into a direct call due to the table.init, unless we |
| ;; assume initial contents are immutable. |
| (call_indirect (type $i32) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; The elem's offset is way out of bounds, which we should not error on, and do |
| ;; nothing otherwise. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| (table 10 10 funcref) |
| |
| (elem (i32.const -1) $0) |
| |
| ;; CHECK: (table $0 10 10 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const -1) $0) |
| |
| ;; CHECK: (func $0 (type $v) |
| ;; CHECK-NEXT: (call_indirect $0 (type $v) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (table $0 10 10 funcref) |
| |
| ;; IMMUT: (elem $0 (i32.const -1) $0) |
| |
| ;; IMMUT: (func $0 (type $v) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $v) |
| ;; IMMUT-NEXT: (i32.const -1) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (call_indirect (type $v) |
| (i32.const -1) |
| ) |
| ) |
| ) |
| |
| ;; Another elem offset that is way out of bounds. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| (table 10 10 funcref) |
| |
| (elem (i32.const -2) $0) |
| |
| ;; CHECK: (table $0 10 10 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const -2) $0) |
| |
| ;; CHECK: (func $0 (type $v) |
| ;; CHECK-NEXT: (call_indirect $0 (type $v) |
| ;; CHECK-NEXT: (i32.const -2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (table $0 10 10 funcref) |
| |
| ;; IMMUT: (elem $0 (i32.const -2) $0) |
| |
| ;; IMMUT: (func $0 (type $v) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $v) |
| ;; IMMUT-NEXT: (i32.const -2) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (call_indirect (type $v) |
| (i32.const -2) |
| ) |
| ) |
| ) |
| |
| ;; The elem is just out of bounds due to its offset. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| (table 10 10 funcref) |
| |
| (elem (i32.const 10) $0) |
| |
| ;; CHECK: (table $0 10 10 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const 10) $0) |
| |
| ;; CHECK: (func $0 (type $v) |
| ;; CHECK-NEXT: (call_indirect $0 (type $v) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (table $0 10 10 funcref) |
| |
| ;; IMMUT: (elem $0 (i32.const 10) $0) |
| |
| ;; IMMUT: (func $0 (type $v) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $v) |
| ;; IMMUT-NEXT: (i32.const 10) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (call_indirect (type $v) |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; The elem is just out of bounds due to its length. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| (table 10 10 funcref) |
| |
| (elem (i32.const 9) $0 $0) |
| |
| ;; CHECK: (table $0 10 10 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const 9) $0 $0) |
| |
| ;; CHECK: (func $0 (type $v) |
| ;; CHECK-NEXT: (call_indirect $0 (type $v) |
| ;; CHECK-NEXT: (i32.const 9) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (table $0 10 10 funcref) |
| |
| ;; IMMUT: (elem $0 (i32.const 9) $0 $0) |
| |
| ;; IMMUT: (func $0 (type $v) |
| ;; IMMUT-NEXT: (call_indirect $0 (type $v) |
| ;; IMMUT-NEXT: (i32.const 9) |
| ;; IMMUT-NEXT: ) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (call_indirect (type $v) |
| ;; We could in theory optimize this, as the out of bounds part is after us, |
| ;; but the wasm traps anyhow, so leave it alone. |
| (i32.const 9) |
| ) |
| ) |
| ) |
| |
| ;; The elem is ok, and we can optimize. |
| (module |
| ;; CHECK: (type $v (func)) |
| ;; IMMUT: (type $v (func)) |
| (type $v (func)) |
| |
| (table 10 10 funcref) |
| |
| (elem (i32.const 9) $0) |
| |
| ;; CHECK: (table $0 10 10 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const 9) $0) |
| |
| ;; CHECK: (func $0 (type $v) |
| ;; CHECK-NEXT: (call $0) |
| ;; CHECK-NEXT: ) |
| ;; IMMUT: (table $0 10 10 funcref) |
| |
| ;; IMMUT: (elem $0 (i32.const 9) $0) |
| |
| ;; IMMUT: (func $0 (type $v) |
| ;; IMMUT-NEXT: (call $0) |
| ;; IMMUT-NEXT: ) |
| (func $0 |
| (call_indirect (type $v) |
| (i32.const 9) |
| ) |
| ) |
| ) |
