| ;; 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 --remove-unused-module-elements --all-features -S -o - | filecheck %s |
| |
| (module |
| (memory 0) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (param i32))) |
| |
| ;; CHECK: (type $2 (func (param i32) (result i32))) |
| |
| ;; CHECK: (memory $0 0) |
| |
| ;; CHECK: (table $0 1 1 funcref) |
| |
| ;; CHECK: (elem $0 (i32.const 0) $called_indirect) |
| |
| ;; CHECK: (export "memory" (memory $0)) |
| |
| ;; CHECK: (export "exported" (func $exported)) |
| |
| ;; CHECK: (export "other1" (func $other1)) |
| |
| ;; CHECK: (export "other2" (func $other2)) |
| |
| ;; CHECK: (start $start) |
| (start $start) |
| (type $0 (func)) |
| (type $0-dupe (func)) |
| (type $1 (func (param i32))) |
| (type $1-dupe (func (param i32))) |
| (type $2 (func (param i32) (result i32))) |
| (type $2-dupe (func (param i32) (result i32))) |
| (type $2-thrupe (func (param i32) (result i32))) |
| (export "memory" (memory $0)) |
| (export "exported" (func $exported)) |
| (export "other1" (func $other1)) |
| (export "other2" (func $other2)) |
| (table 1 1 funcref) |
| (elem (i32.const 0) $called_indirect) |
| ;; CHECK: (func $start (type $0) |
| ;; CHECK-NEXT: (call $called0) |
| ;; CHECK-NEXT: ) |
| (func $start (type $0) |
| (call $called0) |
| ) |
| ;; CHECK: (func $called0 (type $0) |
| ;; CHECK-NEXT: (call $called1) |
| ;; CHECK-NEXT: ) |
| (func $called0 (type $0) |
| (call $called1) |
| ) |
| ;; CHECK: (func $called1 (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $called1 (type $0) |
| (nop) |
| ) |
| ;; CHECK: (func $called_indirect (type $0) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $called_indirect (type $0) |
| (nop) |
| ) |
| ;; CHECK: (func $exported (type $0) |
| ;; CHECK-NEXT: (call $called2) |
| ;; CHECK-NEXT: ) |
| (func $exported (type $0-dupe) |
| (call $called2) |
| ) |
| ;; CHECK: (func $called2 (type $0) |
| ;; CHECK-NEXT: (call $called2) |
| ;; CHECK-NEXT: (call $called3) |
| ;; CHECK-NEXT: ) |
| (func $called2 (type $0-dupe) |
| (call $called2) |
| (call $called3) |
| ) |
| ;; CHECK: (func $called3 (type $0) |
| ;; CHECK-NEXT: (call $called4) |
| ;; CHECK-NEXT: ) |
| (func $called3 (type $0-dupe) |
| (call $called4) |
| ) |
| ;; CHECK: (func $called4 (type $0) |
| ;; CHECK-NEXT: (call $called3) |
| ;; CHECK-NEXT: ) |
| (func $called4 (type $0-dupe) |
| (call $called3) |
| ) |
| (func $remove0 (type $0-dupe) |
| (call $remove1) |
| ) |
| (func $remove1 (type $0-dupe) |
| (nop) |
| ) |
| (func $remove2 (type $0-dupe) |
| (call $remove2) |
| ) |
| (func $remove3 (type $0) |
| (call $remove4) |
| ) |
| (func $remove4 (type $0) |
| (call $remove3) |
| ) |
| ;; CHECK: (func $other1 (type $1) (param $0 i32) |
| ;; CHECK-NEXT: (call_indirect $0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $0 (type $1) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $0 (type $1) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $0 (type $2) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $0 (type $2) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $0 (type $2) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $other1 (type $1) (param i32) |
| (call_indirect (type $0) (i32.const 0)) |
| (call_indirect (type $0) (i32.const 0)) |
| (call_indirect (type $0-dupe) (i32.const 0)) |
| (call_indirect (type $0-dupe) (i32.const 0)) |
| (call_indirect (type $1) (i32.const 0) (i32.const 0)) |
| (call_indirect (type $1-dupe) (i32.const 0) (i32.const 0)) |
| (drop (call_indirect (type $2) (i32.const 0) (i32.const 0))) |
| (drop (call_indirect (type $2-dupe) (i32.const 0) (i32.const 0))) |
| (drop (call_indirect (type $2-thrupe) (i32.const 0) (i32.const 0))) |
| ) |
| ;; CHECK: (func $other2 (type $1) (param $0 i32) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $other2 (type $1-dupe) (param i32) |
| (unreachable) |
| ) |
| ) |
| (module ;; remove the table and memory |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 0 funcref)) |
| ) |
| (module ;; remove all tables and the memory |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 0 funcref)) |
| (import "env" "table2" (table $1 2 2 funcref)) |
| (elem (table $1) (offset (i32.const 0)) func) |
| (elem (table $1) (offset (i32.const 1)) func) |
| ) |
| (module ;; remove the first table and memory, but not the second one |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 0 funcref)) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "table2" (table $1 1 1 funcref)) |
| (import "env" "table2" (table $1 1 1 funcref)) |
| (elem (table $1) (offset (i32.const 0)) func) |
| (elem (table $1) (offset (i32.const 0)) func $f) |
| ;; CHECK: (elem $1 (i32.const 0) $f) |
| |
| ;; CHECK: (func $f (type $0) |
| ;; CHECK-NEXT: ) |
| (func $f) |
| ) |
| (module ;; also when not imported |
| (memory 256) |
| (table 1 funcref) |
| ) |
| (module ;; also with multiple tables |
| (memory 256) |
| (table $0 1 funcref) |
| (table $1 1 funcref) |
| (elem (table $1) (i32.const 0) func) |
| ) |
| (module ;; but not when exported |
| ;; CHECK: (import "env" "memory" (memory $0 256)) |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 1 funcref)) |
| (export "mem" (memory 0)) |
| (export "tab" (table 0)) |
| ) |
| ;; CHECK: (import "env" "table" (table $timport$0 1 funcref)) |
| |
| ;; CHECK: (export "mem" (memory $0)) |
| |
| ;; CHECK: (export "tab" (table $timport$0)) |
| (module ;; and not when there are segments |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "memory" (memory $0 256)) |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 1 funcref)) |
| (data (i32.const 1) "hello, world!") |
| (elem (i32.const 0) $waka) |
| ;; CHECK: (import "env" "table" (table $timport$0 1 funcref)) |
| |
| ;; CHECK: (data $0 (i32.const 1) "hello, world!") |
| |
| ;; CHECK: (elem $0 (i32.const 0) $waka) |
| |
| ;; CHECK: (func $waka (type $0) |
| ;; CHECK-NEXT: ) |
| (func $waka) |
| ) |
| (module ;; and not when used |
| ;; CHECK: (type $0 (func)) |
| (type $0 (func)) |
| ;; CHECK: (import "env" "memory" (memory $0 256)) |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 0 funcref)) |
| ;; CHECK: (import "env" "table" (table $timport$0 0 funcref)) |
| |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.load |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_indirect $timport$0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (drop (i32.load (i32.const 0))) |
| (call_indirect (type $0) (i32.const 0)) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (memory $0 23 256 shared) |
| (memory $0 23 256 shared) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (i32.store |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (i32.store (i32.const 0) (i32.const 0)) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (memory $0 23 256 shared) |
| (memory $0 23 256 shared) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) (result i32) |
| ;; CHECK-NEXT: (i32.atomic.rmw.add |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user (result i32) |
| (i32.atomic.rmw.add (i32.const 0) (i32.const 0)) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (memory $0 23 256 shared) |
| (memory $0 23 256 shared) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) (result i32) |
| ;; CHECK-NEXT: (i32.atomic.rmw8.cmpxchg_u |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user (result i32) |
| (i32.atomic.rmw8.cmpxchg_u (i32.const 0) (i32.const 0) (i32.const 0)) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (memory $0 23 256 shared) |
| (memory $0 23 256 shared) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (local $0 i32) |
| ;; CHECK-NEXT: (local $1 i64) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (memory.atomic.wait32 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (local $0 i32) |
| (local $1 i64) |
| (drop |
| (memory.atomic.wait32 |
| (local.get $0) |
| (local.get $0) |
| (local.get $1) |
| ) |
| ) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (memory $0 23 256 shared) |
| (memory $0 23 256 shared) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) (result i32) |
| ;; CHECK-NEXT: (memory.atomic.notify |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user (result i32) |
| (memory.atomic.notify (i32.const 0) (i32.const 0)) |
| ) |
| ) |
| (module ;; atomic.fence and data.drop do not use a memory, so should not keep the memory alive. |
| (memory $0 1 1 shared) |
| (data "") |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (data $0 "") |
| |
| ;; CHECK: (export "fake-user" (func $user)) |
| (export "fake-user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (atomic.fence) |
| ;; CHECK-NEXT: (data.drop $0) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (atomic.fence) |
| (data.drop 0) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "mem" (memory $0 256)) |
| (import "env" "mem" (memory $0 256)) |
| ;; CHECK: (memory $1 23 256) |
| (memory $1 23 256) |
| (memory $unused 1 1) |
| |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (memory.grow $0 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (memory.grow $1 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (drop (memory.grow $0 (i32.const 0))) |
| (drop (memory.grow $1 (i32.const 0))) |
| ) |
| ) |
| (module ;; more use checks |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (memory $0 23 256) |
| (memory $0 23 256) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) (result i32) |
| ;; CHECK-NEXT: (memory.size) |
| ;; CHECK-NEXT: ) |
| (func $user (result i32) |
| (memory.size) |
| ) |
| ) |
| (module ;; memory.copy should keep both memories alive |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (memory $0 1 1) |
| (memory $0 1 1) |
| ;; CHECK: (memory $1 1 1) |
| (memory $1 1 1) |
| (memory $unused 1 1) |
| ;; CHECK: (export "user" (func $user)) |
| (export "user" (func $user)) |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (memory.copy $0 $1 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user |
| (memory.copy $0 $1 |
| (i32.const 0) |
| (i32.const 0) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "memory" (memory $0 256)) |
| (import "env" "memory" (memory $0 256)) |
| (import "env" "table" (table 0 funcref)) |
| ;; CHECK: (import "env" "table" (table $timport$0 0 funcref)) |
| |
| ;; CHECK: (import "env" "memoryBase" (global $memoryBase i32)) |
| (import "env" "memoryBase" (global $memoryBase i32)) ;; used in init |
| ;; CHECK: (import "env" "tableBase" (global $tableBase i32)) |
| (import "env" "tableBase" (global $tableBase i32)) ;; used in init |
| (data (global.get $memoryBase) "hello, world!") |
| (elem (global.get $tableBase) $waka) |
| ;; CHECK: (data $0 (global.get $memoryBase) "hello, world!") |
| |
| ;; CHECK: (elem $0 (global.get $tableBase) $waka) |
| |
| ;; CHECK: (func $waka (type $0) |
| ;; CHECK-NEXT: ) |
| (func $waka) ;; used in table |
| ) |
| (module ;; one is exported, and one->two->int global, whose init->imported |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (type $2 (func (param i32) (result i32))) |
| |
| ;; CHECK: (import "env" "imported" (global $imported i32)) |
| (import "env" "imported" (global $imported i32)) |
| (import "env" "forgetme" (global $forgetme i32)) |
| ;; CHECK: (import "env" "_puts" (func $_puts (type $2) (param i32) (result i32))) |
| (import "env" "_puts" (func $_puts (param i32) (result i32))) |
| (import "env" "forget_puts" (func $forget_puts (param i32) (result i32))) |
| ;; CHECK: (global $int (mut i32) (global.get $imported)) |
| (global $int (mut i32) (global.get $imported)) |
| ;; CHECK: (global $set (mut i32) (i32.const 100)) |
| (global $set (mut i32) (i32.const 100)) |
| (global $forglobal.get (mut i32) (i32.const 500)) |
| ;; CHECK: (global $exp_glob i32 (i32.const 600)) |
| (global $exp_glob i32 (i32.const 600)) |
| ;; CHECK: (export "one" (func $one)) |
| (export "one" (func $one)) |
| ;; CHECK: (export "three" (func $three)) |
| (export "three" (func $three)) |
| ;; CHECK: (export "exp_glob" (global $exp_glob)) |
| (export "exp_glob" (global $exp_glob)) |
| (start $starter) |
| ;; CHECK: (func $one (type $0) (result i32) |
| ;; CHECK-NEXT: (call $two) |
| ;; CHECK-NEXT: ) |
| (func $one (result i32) |
| (call $two) |
| ) |
| ;; CHECK: (func $two (type $0) (result i32) |
| ;; CHECK-NEXT: (global.get $int) |
| ;; CHECK-NEXT: ) |
| (func $two (result i32) |
| (global.get $int) |
| ) |
| ;; CHECK: (func $three (type $1) |
| ;; CHECK-NEXT: (call $four) |
| ;; CHECK-NEXT: ) |
| (func $three |
| (call $four) |
| ) |
| ;; CHECK: (func $four (type $1) |
| ;; CHECK-NEXT: (global.set $set |
| ;; CHECK-NEXT: (i32.const 200) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $_puts |
| ;; CHECK-NEXT: (i32.const 300) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $four |
| (global.set $set (i32.const 200)) |
| (drop (call $_puts (i32.const 300))) |
| ) |
| (func $forget_implemented |
| (nop) |
| ) |
| (func $starter |
| (nop) |
| ) |
| ) |
| (module ;; empty start being removed |
| (start $starter) |
| (func $starter |
| (nop) |
| ) |
| ) |
| (module ;; non-empty start being kept |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (start $starter) |
| (start $starter) |
| ;; CHECK: (func $starter (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $starter |
| (drop (i32.const 0)) |
| ) |
| ) |
| (module ;; imported start cannot be removed |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "start" (func $start (type $0))) |
| (import "env" "start" (func $start)) |
| ;; CHECK: (start $start) |
| (start $start) |
| ) |
| (module ;; the function and the table can be removed |
| (type $0 (func (param f64) (result f64))) |
| (table 6 6 funcref) |
| (func $0 (; 0 ;) (type $0) (param $var$0 f64) (result f64) |
| (if (result f64) |
| (f64.eq |
| (f64.const 1) |
| (f64.const 1) |
| ) |
| (then |
| (f64.const 1) |
| ) |
| (else |
| (f64.const 0) |
| ) |
| ) |
| ) |
| ) |
| (module ;; the function uses the table, but all are removeable |
| (type $0 (func (param f64) (result f64))) |
| (table 6 6 funcref) |
| (func $0 (; 0 ;) (type $0) (param $var$0 f64) (result f64) |
| (if (result f64) |
| (f64.eq |
| (f64.const 1) |
| (f64.const 1) |
| ) |
| (then |
| (call_indirect (type $0) (f64.const 1) (i32.const 0)) |
| ) |
| (else |
| (f64.const 0) |
| ) |
| ) |
| ) |
| ) |
| (module |
| ;; We import two tables and have an active segment that writes to one of them. |
| ;; We must keep that table and the segment, but we can remove the other table. |
| ;; CHECK: (type $0 (func (param f64) (result f64))) |
| (type $0 (func (param f64) (result f64))) |
| |
| ;; CHECK: (import "env" "written" (table $written 6 6 funcref)) |
| (import "env" "written" (table $written 6 6 funcref)) |
| |
| (import "env" "unwritten" (table $unwritten 6 6 funcref)) |
| |
| (table $defined-unused 6 6 funcref) |
| |
| ;; CHECK: (table $defined-used 6 6 funcref) |
| (table $defined-used 6 6 funcref) |
| |
| ;; CHECK: (elem $active1 (table $written) (i32.const 0) func $0) |
| (elem $active1 (table $written) (i32.const 0) func $0) |
| |
| ;; This empty active segment doesn't keep the unwritten table alive. |
| (elem $active2 (table $unwritten) (i32.const 0) func) |
| |
| (elem $active3 (table $defined-unused) (i32.const 0) func $0) |
| |
| ;; CHECK: (elem $active4 (table $defined-used) (i32.const 0) func $0) |
| (elem $active4 (table $defined-used) (i32.const 0) func $0) |
| |
| (elem $active5 (table $defined-used) (i32.const 0) func) |
| ;; CHECK: (func $0 (type $0) (param $var$0 f64) (result f64) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (table.get $defined-used |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if (result f64) |
| ;; CHECK-NEXT: (f64.eq |
| ;; CHECK-NEXT: (f64.const 1) |
| ;; CHECK-NEXT: (f64.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (f64.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (f64.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $0 (; 0 ;) (type $0) (param $var$0 f64) (result f64) |
| (drop |
| (table.get $defined-used |
| (i32.const 0) |
| ) |
| ) |
| (if (result f64) |
| (f64.eq |
| (f64.const 1) |
| (f64.const 1) |
| ) |
| (then |
| (f64.const 1) |
| ) |
| (else |
| (f64.const 0) |
| ) |
| ) |
| ) |
| ) |
| (module |
| ;; The same thing works for memories with active segments. |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "env" "written" (memory $written 1 1)) |
| (import "env" "written" (memory $written 1 1)) |
| |
| (import "env" "unwritten" (memory $unwritten 1 1)) |
| |
| (memory $defined-unused 1 1) |
| |
| ;; CHECK: (memory $defined-used 1 1) |
| (memory $defined-used 1 1) |
| |
| ;; CHECK: (data $active1 (i32.const 0) "foobar") |
| (data $active1 (memory $written) (i32.const 0) "foobar") |
| |
| (data $active2 (memory $unwritten) (i32.const 0) "") |
| |
| (data $active3 (memory $defined-unused) (i32.const 0) "hello") |
| |
| ;; CHECK: (data $active4 (memory $defined-used) (i32.const 0) "hello") |
| (data $active4 (memory $defined-used) (i32.const 0) "hello") |
| |
| (data $active5 (memory $defined-used) (i32.const 0) "") |
| |
| ;; CHECK: (export "user" (func $user)) |
| |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.load $defined-used |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user (export "user") |
| (drop |
| (i32.load $defined-used |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| (module |
| ;; Nothing should break if the unused segments precede the used segments. |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $array (array funcref)) |
| (type $array (array funcref)) |
| |
| (memory $mem 1 1) |
| (table $tab 1 1 funcref) |
| |
| (data $unused "") |
| (elem $unused func) |
| |
| ;; CHECK: (data $used "") |
| (data $used "") |
| ;; CHECK: (elem $used func) |
| (elem $used func) |
| |
| ;; CHECK: (export "user" (func $user)) |
| |
| ;; CHECK: (func $user (type $0) |
| ;; CHECK-NEXT: (data.drop $used) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (array.new_elem $array $used |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $user (export "user") |
| (data.drop 1) |
| (drop |
| (array.new_elem $array 1 |
| (i32.const 0) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| ;; SIMD operations can keep memories alive |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (memory $A 1 1) |
| (memory $A 1 1) |
| ;; CHECK: (memory $B 1 1) |
| (memory $B 1 1) |
| (memory $C-unused 1 1) |
| |
| ;; CHECK: (export "func" (func $func)) |
| |
| ;; CHECK: (func $func (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (v128.load64_splat $A |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (v128.load16_lane $B 0 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (v128.const i32x4 0x00000000 0x00000000 0x00000000 0x00000000) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $func (export "func") |
| (drop |
| (v128.load64_splat $A |
| (i32.const 0) |
| ) |
| ) |
| (drop |
| (v128.load16_lane $B 0 |
| (i32.const 0) |
| (v128.const i32x4 0 0 0 0) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; When we export a function that calls another, we can export the called |
| ;; function, skipping the one in the middle. The exports of $middle and |
| ;; $other-middle can be changed to their targets here. |
| |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "a" "b" (func $import (type $0))) |
| (import "a" "b" (func $import)) |
| |
| ;; CHECK: (export "export-import" (func $import)) |
| (export "export-import" (func $import)) |
| |
| ;; CHECK: (export "export-middle" (func $middle)) |
| (export "export-middle" (func $middle)) |
| |
| ;; CHECK: (export "export-other-middle" (func $other-middle)) |
| (export "export-other-middle" (func $other-middle)) |
| |
| ;; CHECK: (export "export-internal" (func $internal)) |
| (export "export-internal" (func $internal)) |
| |
| ;; CHECK: (func $middle (type $0) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| (func $middle |
| (call $import) |
| ) |
| |
| ;; CHECK: (func $other-middle (type $0) |
| ;; CHECK-NEXT: (call $internal) |
| ;; CHECK-NEXT: ) |
| (func $other-middle |
| (call $internal) |
| ) |
| |
| ;; CHECK: (func $internal (type $0) |
| ;; CHECK-NEXT: ) |
| (func $internal |
| ) |
| ) |
| |
| ;; As above, but we do not do that optimization when it would change the |
| ;; exported type. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (func)) |
| (type $A (func)) |
| ;; CHECK: (type $B (func)) |
| (type $B (func)) |
| ) |
| |
| ;; CHECK: (import "a" "a" (func $import-A (type $A))) |
| (import "a" "a" (func $import-A (type $A))) |
| ;; CHECK: (import "b" "b" (func $import-B (type $B))) |
| (import "b" "b" (func $import-B (type $B))) |
| |
| ;; CHECK: (export "export-import-A" (func $import-A)) |
| (export "export-import-A" (func $import-A)) |
| |
| ;; CHECK: (export "export-import-B" (func $import-B)) |
| (export "export-import-B" (func $import-B)) |
| |
| ;; CHECK: (export "export-middle-A-A" (func $middle-A-A)) |
| (export "export-middle-A-A" (func $middle-A-A)) |
| |
| ;; CHECK: (export "export-middle-A-B" (func $middle-A-B)) |
| (export "export-middle-A-B" (func $middle-A-B)) |
| |
| ;; CHECK: (export "export-middle-B-A" (func $middle-B-A)) |
| (export "export-middle-B-A" (func $middle-B-A)) |
| |
| ;; CHECK: (export "export-middle-B-B" (func $middle-B-B)) |
| (export "export-middle-B-B" (func $middle-B-B)) |
| |
| ;; CHECK: (func $middle-A-A (type $A) |
| ;; CHECK-NEXT: (call $import-A) |
| ;; CHECK-NEXT: ) |
| (func $middle-A-A (type $A) |
| (call $import-A) |
| ) |
| |
| ;; CHECK: (func $middle-A-B (type $A) |
| ;; CHECK-NEXT: (call $import-B) |
| ;; CHECK-NEXT: ) |
| (func $middle-A-B (type $A) |
| (call $import-B) |
| ) |
| |
| ;; CHECK: (func $middle-B-A (type $B) |
| ;; CHECK-NEXT: (call $import-A) |
| ;; CHECK-NEXT: ) |
| (func $middle-B-A (type $B) |
| (call $import-A) |
| ) |
| |
| ;; CHECK: (func $middle-B-B (type $B) |
| ;; CHECK-NEXT: (call $import-B) |
| ;; CHECK-NEXT: ) |
| (func $middle-B-B (type $B) |
| (call $import-B) |
| ) |
| ) |
| |
| ;; As above, but checking for parameters: It's ok to pass values through, but |
| ;; not to do anything else. |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (import "a" "b" (func $import (type $0) (param i32))) |
| (import "a" "b" (func $import (param i32))) |
| |
| ;; CHECK: (export "export-import" (func $import)) |
| (export "export-import" (func $import)) |
| |
| ;; CHECK: (export "export-middle" (func $middle)) |
| (export "export-middle" (func $middle)) |
| |
| ;; CHECK: (export "export-middle-local" (func $middle-local)) |
| (export "export-middle-local" (func $middle-local)) |
| |
| ;; CHECK: (export "export-middle-other" (func $middle-other)) |
| (export "export-middle-other" (func $middle-other)) |
| |
| ;; CHECK: (export "export-middle-noncall" (func $middle-noncall)) |
| (export "export-middle-noncall" (func $middle-noncall)) |
| |
| ;; CHECK: (func $middle (type $0) (param $x i32) |
| ;; CHECK-NEXT: (local $y i32) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle (param $x i32) |
| ;; This extra local is not a problem. |
| (local $y i32) |
| (call $import |
| (local.get $x) |
| ) |
| ) |
| |
| ;; CHECK: (func $middle-local (type $0) (param $x i32) |
| ;; CHECK-NEXT: (local $y i32) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle-local (param $x i32) |
| (local $y i32) |
| (call $import |
| ;; Now we get the local instead of the param, so we cannot optimize. |
| (local.get $y) |
| ) |
| ) |
| |
| ;; CHECK: (func $middle-other (type $0) (param $x i32) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle-other (param $x i32) |
| (call $import |
| ;; Something other than local.get, so we cannot optimize. |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; CHECK: (func $middle-noncall (type $0) (param $x i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle-noncall (param $x i32) |
| ;; Not even a call here. |
| (drop |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; Function with two parameters: we can only optimize when the arguments are in |
| ;; the right order. |
| ;; |
| ;; Also test with a return value. |
| (module |
| ;; CHECK: (type $0 (func (param i32 i32) (result f64))) |
| |
| ;; CHECK: (import "a" "b" (func $import (type $0) (param i32 i32) (result f64))) |
| (import "a" "b" (func $import (param i32) (param i32) (result f64))) |
| |
| ;; CHECK: (export "export-middle-right" (func $middle-right)) |
| (export "export-middle-right" (func $middle-right)) |
| |
| ;; CHECK: (export "export-middle-wrong" (func $middle-wrong)) |
| (export "export-middle-wrong" (func $middle-wrong)) |
| |
| ;; CHECK: (func $middle-right (type $0) (param $x i32) (param $y i32) (result f64) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle-right (param $x i32) (param $y i32) (result f64) |
| (call $import |
| (local.get $x) |
| (local.get $y) |
| ) |
| ) |
| |
| ;; CHECK: (func $middle-wrong (type $0) (param $x i32) (param $y i32) (result f64) |
| ;; CHECK-NEXT: (call $import |
| ;; CHECK-NEXT: (local.get $y) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $middle-wrong (param $x i32) (param $y i32) (result f64) |
| ;; The local.gets are reversed here, so we cannot optimize. |
| (call $import |
| (local.get $y) |
| (local.get $x) |
| ) |
| ) |
| ) |
| |
| (module |
| ;; As above, but with a return_call. We can optimize it like a call. |
| |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (import "a" "b" (func $import (type $0))) |
| (import "a" "b" (func $import)) |
| |
| ;; CHECK: (export "export-middle" (func $middle)) |
| (export "export-middle" (func $middle)) |
| |
| ;; CHECK: (func $middle (type $0) |
| ;; CHECK-NEXT: (return_call $import) |
| ;; CHECK-NEXT: ) |
| (func $middle |
| (return_call $import) |
| ) |
| ) |
