| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| |
| ;; RUN: foreach %s %t wasm-opt --outlining -S -all -o - | filecheck %s |
| |
| ;; TODO: Add a test that fails to outline a single control flow that repeats |
| |
| |
| (module |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (type $1 (func (param i32))) |
| |
| ;; CHECK: (func $outline$ (type $1) (param $0 i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) (result i32) |
| ;; CHECK-NEXT: (call $outline$ |
| ;; CHECK-NEXT: (i32.const 7) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (result i32) |
| (drop |
| (i32.const 7) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| (return |
| (i32.const 4) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) (result i32) |
| ;; CHECK-NEXT: (call $outline$ |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 5) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (result i32) |
| (drop |
| (i32.const 0) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| (return |
| (i32.const 5) |
| ) |
| ) |
| ) |
| |
| ;; Tests that outlining occurs properly when the sequence is at the end of a function. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; Tests that outlining occurs properly when the sequence is at the beginning of a function. |
| ;; Also tests that the outlined function has no arguments. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 6) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (i32.const 0) |
| ) |
| (drop |
| (i32.add |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 6) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 7) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (drop |
| (i32.const 0) |
| ) |
| (drop |
| (i32.add |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (drop |
| (i32.const 7) |
| ) |
| ) |
| ) |
| |
| ;; Tests multiple sequences being outlined from the same source function into different |
| ;; outlined functions. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $outline$_4 (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.sub |
| ;; CHECK-NEXT: (i32.const 3) |
| ;; CHECK-NEXT: (i32.const 4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$_4) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (i32.add |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| (drop |
| (i32.sub |
| (i32.const 3) |
| (i32.const 4) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (call $outline$_4) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (drop |
| (i32.sub |
| (i32.const 3) |
| (i32.const 4) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $c (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $c |
| (drop |
| (i32.add |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests that outlining works correctly with if-condition |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (result i32))) |
| |
| ;; CHECK: (global $global$1 (mut i32) (i32.const 100)) |
| (global $global$1 (mut i32) (i32.const 100)) |
| ;; CHECK: (func $outline$ (type $1) (result i32) |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 15) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (if |
| (i32.eqz |
| (global.get $global$1) |
| ) |
| (then |
| (global.set $global$1 |
| (i32.const 15) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (if |
| (i32.eqz |
| (global.get $global$1) |
| ) |
| (then |
| (global.set $global$1 |
| (i32.const 20) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Outline if-true. |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (func $outline$ (type $1) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (param i32) |
| (if |
| (i32.eqz |
| (local.get 0) |
| ) |
| (then |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (param i32) |
| (if |
| (i32.eqz |
| (local.get 0) |
| ) |
| (then |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Outline if-false. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $global$1 (mut i32) (i32.const 100)) |
| (global $global$1 (mut i32) (i32.const 100)) |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 100) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 15) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (if |
| (i32.eqz |
| (global.get $global$1) |
| ) |
| (then |
| (global.set $global$1 |
| (i32.const 15) |
| ) |
| ) |
| (else |
| (block |
| (global.set $global$1 |
| (i32.const 100) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.ctz |
| ;; CHECK-NEXT: (global.get $global$1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 30) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (if |
| (i32.ctz |
| (global.get $global$1) |
| ) |
| (then |
| (global.set $global$1 |
| (i32.const 30) |
| ) |
| ) |
| (else |
| (block |
| (global.set $global$1 |
| (i32.const 100) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Outline if control flow, with matching if-condition, if-true, if-false |
| ;; TODO: Ideally outlining would keep the if-true and if-false inline in |
| ;; $outline$, instead of moving them to another outlined function ($outline$_3 |
| ;; & $outline$_4) because of the unique symbol between the if-condition and |
| ;; if-true and the unique symbol between if-true and if-false. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (global $global$1 (mut i32) (i32.const 100)) |
| (global $global$1 (mut i32) (i32.const 100)) |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (call $outline$_3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (call $outline$_4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $outline$_3 (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $outline$_4 (type $0) |
| ;; CHECK-NEXT: (global.set $global$1 |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (if |
| (i32.eqz |
| (global.get $global$1) |
| ) |
| (then |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| (else |
| (global.set $global$1 |
| (i32.const 20) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (if |
| (i32.eqz |
| (global.get $global$1) |
| ) |
| (then |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| (else |
| (global.set $global$1 |
| (i32.const 20) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests that local.get instructions are correctly filtered from being outlined. |
| (module |
| ;; CHECK: (type $0 (func (param i32))) |
| |
| ;; CHECK: (func $a (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (param i32) |
| (drop |
| (i32.add |
| (local.get 0) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) (param $0 i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (param i32) |
| (drop |
| (i32.add |
| (local.get 0) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests local.set instructions are correctly filtered from being outlined. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (local $i i32) |
| ;; CHECK-NEXT: (local.set $i |
| ;; CHECK-NEXT: (i32.const 7) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (local $i i32) |
| (local.set $i |
| (i32.const 7) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (local $i i32) |
| ;; CHECK-NEXT: (local.set $i |
| ;; CHECK-NEXT: (i32.const 7) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (local $i i32) |
| (local.set $i |
| (i32.const 7) |
| ) |
| ) |
| ) |
| |
| ;; Tests branch instructions are correctly filtered from being outlined. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (block $label1 |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br $label1) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br $label1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (block $label1 |
| (drop |
| (i32.const 4) |
| ) |
| (br $label1) |
| (drop |
| (i32.const 4) |
| ) |
| (br $label1) |
| ) |
| ) |
| ) |
| |
| ;; Tests branch with condition is reconstructed without error. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (block $label1 |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (loop |
| ;; CHECK-NEXT: (br $label1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (block $label1 |
| (drop |
| (i32.const 2) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (loop |
| (br $label1) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests br_table instruction is reconstructed without error. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (param i32) (result i32))) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $1) (param $0 i32) (result i32) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (block $block1 |
| ;; CHECK-NEXT: (br_table $block $block1 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 21) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (i32.const 22) |
| ;; CHECK-NEXT: ) |
| (func $a (param i32) (result i32) |
| (drop |
| (i32.const 2) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (block |
| (block |
| (br_table 1 0 (local.get 0)) |
| (return (i32.const 21)) |
| ) |
| (return (i32.const 20)) |
| ) |
| (drop |
| (i32.const 2) |
| ) |
| (drop |
| (i32.const 1) |
| ) |
| (i32.const 22) |
| ) |
| ) |
| |
| ;; Tests return instructions are correctly filtered from being outlined. |
| (module |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (func $a (type $0) (result i32) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (result i32) |
| (return |
| (i32.const 2) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) (result i32) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (result i32) |
| (return |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; Test that an outlined function is created with one return value. |
| (module |
| ;; CHECK: (type $0 (func (result i32))) |
| |
| ;; CHECK: (func $outline$ (type $0) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) (result i32) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a (result i32) |
| (drop |
| (i32.const 0) |
| ) |
| (i32.const 1) |
| ) |
| ;; CHECK: (func $b (type $0) (result i32) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $b (result i32) |
| (drop |
| (i32.const 0) |
| ) |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; Test that an outlined function is created with multiple return values. |
| (module |
| ;; CHECK: (type $0 (func (result i32 i32))) |
| |
| ;; CHECK: (type $1 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) (result i32 i32) |
| ;; CHECK-NEXT: (tuple.make 2 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $1) |
| ;; CHECK-NEXT: (local $scratch (tuple i32 i32)) |
| ;; CHECK-NEXT: (local $scratch_1 (tuple i32 i32)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (tuple.extract 2 0 |
| ;; CHECK-NEXT: (local.tee $scratch |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (tuple.extract 2 1 |
| ;; CHECK-NEXT: (local.get $scratch) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.mul |
| ;; CHECK-NEXT: (tuple.extract 2 0 |
| ;; CHECK-NEXT: (local.tee $scratch_1 |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (tuple.extract 2 1 |
| ;; CHECK-NEXT: (local.get $scratch_1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (i32.add |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| (drop |
| (i32.mul |
| (i32.const 0) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Test outlining works with call_indirect |
| ;; 0 results, 2 params, 3 operands |
| (module |
| (table 1 1 funcref) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (param i32 i32))) |
| |
| ;; CHECK: (table $0 1 1 funcref) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (call_indirect $0 (type $1) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (call_indirect |
| (param i32 i32) |
| (i32.const 0) |
| (i32.const 1) |
| (i32.const 2) |
| ) |
| (call_indirect |
| (param i32 i32) |
| (i32.const 0) |
| (i32.const 1) |
| (i32.const 2) |
| ) |
| ) |
| ) |
| |
| ;; Test outlining works with call_indirect |
| ;; 0 results, 0 params, 1 operand |
| (module |
| (table 1 1 funcref) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (table $0 1 1 funcref) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (call_indirect $0 (type $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (call_indirect |
| (i32.const 0) |
| ) |
| (call_indirect |
| (i32.const 0) |
| ) |
| ) |
| ) |
| |
| ;; Test outlining works with call_indirect |
| ;; 1 result, 0 params, 1 operand |
| (module |
| (table 1 1 funcref) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (result i32))) |
| |
| ;; CHECK: (table $0 1 1 funcref) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call_indirect $0 (type $1) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (call_indirect |
| (result i32) |
| (i32.const 0) |
| ) |
| ) |
| (drop |
| (call_indirect |
| (result i32) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Test outlining works with call_indirect |
| ;; 2 results, 0 params, 1 operand |
| (module |
| (table 1 1 funcref) |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (result i32 i32))) |
| |
| ;; CHECK: (table $0 1 1 funcref) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (tuple.drop 2 |
| ;; CHECK-NEXT: (call_indirect $0 (type $1) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (tuple.drop 2 |
| (call_indirect |
| (result i32 i32) |
| (i32.const 0) |
| ) |
| ) |
| (tuple.drop 2 |
| (call_indirect |
| (result i32 i32) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Outline a loop |
| ;; TODO: Ideally, a loop (like any control flow) repeated within a program can |
| ;; be outlined by itself. Right now this is not possible since a control flow |
| ;; is represented by a single symbol and only sequences of symbols >= 2 are |
| ;; candidates for outlining. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (drop |
| (i32.const 0) |
| ) |
| (loop (nop)) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (drop |
| (i32.const 0) |
| ) |
| (loop (nop)) |
| ) |
| ) |
| |
| ;; Test that no attempt is made to outline overlapping repeat substrings |
| ;; In the below module, the Outlining optimization identifies two substrings |
| ;; that each repeat twice. During filtering, one of the repeat substrings is |
| ;; found to have an overlapping interval with itself. Because an interval is |
| ;; dropped, only one of the substrings repeats enough times (minimum twice) |
| ;; to warrant outlining. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| i32.const 0 ;; Begin substring 1 |
| drop |
| i32.const 1 |
| drop |
| i32.const 2 |
| drop |
| i32.const 3 |
| drop ;; End substring 1 |
| i32.const 0 ;; Begin substring 1 repeat |
| drop |
| i32.const 1 |
| drop |
| i32.const 2 |
| drop |
| i32.const 3 |
| drop ;; End substring 1 repeat && Begin substring 2 |
| i32.const 1 |
| drop |
| i32.const 2 |
| drop ;; End substring 2 && Begin substring 2 repeat |
| i32.const 1 |
| drop |
| i32.const 2 |
| drop ;; End substring 2 repeat |
| ) |
| ) |
| |
| ;; Tests unreachable type handling |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (type $1 (func (result f32))) |
| |
| ;; CHECK: (type $2 (func (result i32))) |
| |
| ;; CHECK: (func $outline$ (type $0) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $1) (result f32) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $a (result f32) |
| i32.const 0 |
| drop |
| unreachable |
| ) |
| ;; CHECK: (func $b (type $2) (result i32) |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $b (result i32) |
| i32.const 0 |
| drop |
| unreachable |
| ) |
| ) |
| |
| ;; Tests that restricted expressions (local.set) are filtered from outlining |
| ;; even when nested within control flow. |
| (module |
| ;; CHECK: (type $0 (func)) |
| |
| ;; CHECK: (func $a (type $0) |
| ;; CHECK-NEXT: (local $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (local.set $x |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a |
| (local $x i32) |
| (block |
| (if |
| (i32.const 0) |
| (then |
| (local.set $x |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $0) |
| ;; CHECK-NEXT: (local $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (local.set $x |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b |
| (local $x i32) |
| (block |
| (if |
| (i32.const 0) |
| (then |
| (local.set $x |
| (i32.const 1) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests that the contents of Catch are outlined |
| (module |
| ;; CHECK: (type $1 (func (result i32))) |
| |
| ;; CHECK: (type $0 (func)) |
| (type $0 (func)) |
| (type $1 (func (result i32))) |
| ;; CHECK: (tag $eimport$1 (type $0)) |
| (tag $eimport$1 (type $0)) |
| ;; CHECK: (func $outline$ (type $1) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const -12) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const -2147483647) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $a (type $1) (result i32) |
| ;; CHECK-NEXT: (local $0 externref) |
| ;; CHECK-NEXT: (try (result i32) |
| ;; CHECK-NEXT: (do |
| ;; CHECK-NEXT: (i32.const -20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (catch $eimport$1 |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (catch_all |
| ;; CHECK-NEXT: (i32.const -15) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (result i32) |
| (local $0 externref) |
| (try (result i32) |
| (do |
| (i32.const -20) |
| ) |
| (catch $eimport$1 |
| (drop |
| (i32.const -12) |
| ) |
| (i32.const -2147483647) |
| ) |
| (catch_all |
| (i32.const -15) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $1) (result i32) |
| ;; CHECK-NEXT: (local $0 externref) |
| ;; CHECK-NEXT: (try (result i32) |
| ;; CHECK-NEXT: (do |
| ;; CHECK-NEXT: (i32.const -20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (catch $eimport$1 |
| ;; CHECK-NEXT: (call $outline$) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (catch_all |
| ;; CHECK-NEXT: (i32.const -15) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (result i32) |
| (local $0 externref) |
| (try (result i32) |
| (do |
| (i32.const -20) |
| ) |
| (catch $eimport$1 |
| (drop |
| (i32.const -12) |
| ) |
| (i32.const -2147483647) |
| ) |
| (catch_all |
| (i32.const -15) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Tests TryTable instructions are correctly filtered from being outlined. |
| ;; The (drop (i32.const 0)) instructions were added to form an outlineable |
| ;; sequence with the block that contains the try_table. |
| (module |
| ;; CHECK: (type $1 (func (result (ref exn)))) |
| |
| ;; CHECK: (type $0 (func)) |
| (type $0 (func)) |
| ;; CHECK: (tag $tag$0 (type $0)) |
| (tag $tag$0 (type $0)) |
| ;; CHECK: (func $a (type $1) (result (ref exn)) |
| ;; CHECK-NEXT: (loop $label1 |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (try_table (catch_all $label1) |
| ;; CHECK-NEXT: (throw $tag$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $a (result (ref exn)) |
| (loop $label1 (result (ref exn)) |
| (drop |
| (i32.const 0) |
| ) |
| (block (result (ref exn)) |
| (try_table (catch_all $label1) |
| (throw $tag$0) |
| ) |
| ) |
| ) |
| ) |
| ;; CHECK: (func $b (type $1) (result (ref exn)) |
| ;; CHECK-NEXT: (loop $label1 |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (try_table (catch_all $label1) |
| ;; CHECK-NEXT: (throw $tag$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $b (result (ref exn)) |
| (loop $label1 (result (ref exn)) |
| (drop |
| (i32.const 0) |
| ) |
| (block (result (ref exn)) |
| (try_table (catch_all $label1) |
| (throw $tag$0) |
| ) |
| ) |
| ) |
| ) |
| ) |
