| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| |
| ;; RUN: foreach %s %t wasm-opt --inlining --optimize-level=3 --partial-inlining-ifs=4 --all-features -S -o - | filecheck %s |
| |
| (module |
| ;; CHECK: (type $func.0 (func)) |
| |
| ;; CHECK: (type $func.1 (func (param i32))) |
| |
| ;; CHECK: (type $func.2 (func (param anyref) (result anyref))) |
| |
| ;; CHECK: (type $func.3 (func (param anyref))) |
| |
| ;; CHECK: (type $struct (struct)) |
| (type $struct (struct)) |
| |
| ;; CHECK: (type $func.4 (func (param i32 (rtt $struct)))) |
| |
| ;; CHECK: (type $func.5 (func (param i64 i32 f64))) |
| |
| ;; CHECK: (import "out" "func" (func $import)) |
| (import "out" "func" (func $import)) |
| |
| ;; CHECK: (global $glob i32 (i32.const 1)) |
| (global $glob i32 (i32.const 1)) |
| |
| ;; CHECK: (start $start-used-globally) |
| (start $start-used-globally) |
| |
| ;; Pattern A: functions beginning with |
| ;; |
| ;; if (simple) return; |
| |
| (func $maybe-work-hard (param $x i32) |
| ;; A function that does a quick check before any heavy work. We can outline |
| ;; the heavy work, so that the condition can be inlined. |
| ;; |
| ;; This function (and others lower down that we also optimize) will vanish |
| ;; in the output. Part of it will be inlined into its caller, below, and |
| ;; the rest will be outlined into a new function with suffix "outlined". |
| (if |
| (local.get $x) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-maybe-work-hard |
| ;; CHECK-NEXT: (local $0 i32) |
| ;; CHECK-NEXT: (local $1 i32) |
| ;; CHECK-NEXT: (local $2 i32) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$maybe-work-hard |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$maybe-work-hard |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$maybe-work-hard0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$maybe-work-hard |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$maybe-work-hard1 |
| ;; CHECK-NEXT: (local.set $2 |
| ;; CHECK-NEXT: (i32.const 3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$maybe-work-hard |
| ;; CHECK-NEXT: (local.get $2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-maybe-work-hard |
| ;; Call the above function to verify that we can in fact inline it after |
| ;; splitting. We should see each of these three calls replaced by inlined |
| ;; code performing the if from $maybe-work-hard, and depending on that |
| ;; result they each call the outlined code that must *not* be inlined. |
| ;; |
| ;; Note that we must call more than once, otherwise given a single use we |
| ;; will always inline the entire thing. |
| (call $maybe-work-hard (i32.const 1)) |
| (call $maybe-work-hard (i32.const 2)) |
| (call $maybe-work-hard (i32.const 3)) |
| ) |
| |
| (func $just-if (param $x i32) |
| ;; As above, but all we have is an if. |
| (if |
| (local.get $x) |
| (loop $l |
| (call $import) |
| (br_if $l |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-just-if |
| ;; CHECK-NEXT: (local $0 i32) |
| ;; CHECK-NEXT: (local $1 i32) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$just-if |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$just-if |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$just-if0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$just-if |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-just-if |
| (call $just-if (i32.const 1)) |
| (call $just-if (i32.const 2)) |
| ) |
| |
| ;; CHECK: (func $br-to-toplevel (param $x i32) |
| ;; CHECK-NEXT: (block $toplevel |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (br $toplevel) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br-to-toplevel (param $x i32) |
| (block $toplevel |
| (if |
| (local.get $x) |
| (block |
| (if |
| (local.get $x) |
| ;; A br to the toplevel block prevents us from outlining this code, |
| ;; as we can't outline a br without its target. |
| (br $toplevel) |
| (call $import) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-br-to-toplevel |
| ;; CHECK-NEXT: (call $br-to-toplevel |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $br-to-toplevel |
| ;; CHECK-NEXT: (i32.const 2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-br-to-toplevel |
| (call $br-to-toplevel (i32.const 1)) |
| (call $br-to-toplevel (i32.const 2)) |
| ) |
| |
| ;; CHECK: (func $nondefaultable-param (param $x i32) (param $y (rtt $struct)) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $nondefaultable-param (param $x i32) (param $y (rtt $struct)) |
| ;; The RTT param here prevents us from even being inlined, even with |
| ;; splitting. |
| (if |
| (local.get $x) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-nondefaultable-param |
| ;; CHECK-NEXT: (call $nondefaultable-param |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: (rtt.canon $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-nondefaultable-param |
| (call $nondefaultable-param (i32.const 0) (rtt.canon $struct)) |
| ) |
| |
| (func $many-params (param $x i64) (param $y i32) (param $z f64) |
| ;; Test that we can optimize this function even though it has multiple |
| ;; parameters, and it is not the very first one that we use in the |
| ;; condition. |
| (if |
| (local.get $y) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-many-params |
| ;; CHECK-NEXT: (local $0 i64) |
| ;; CHECK-NEXT: (local $1 i32) |
| ;; CHECK-NEXT: (local $2 f64) |
| ;; CHECK-NEXT: (local $3 i64) |
| ;; CHECK-NEXT: (local $4 i32) |
| ;; CHECK-NEXT: (local $5 f64) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$many-params |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (i64.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $2 |
| ;; CHECK-NEXT: (f64.const 3.14159) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$many-params |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: (local.get $2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$many-params0 |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (i64.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $4 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $5 |
| ;; CHECK-NEXT: (f64.const 3.14159) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$many-params |
| ;; CHECK-NEXT: (local.get $3) |
| ;; CHECK-NEXT: (local.get $4) |
| ;; CHECK-NEXT: (local.get $5) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-many-params |
| ;; Call the above function to verify that we can in fact inline it after |
| ;; splitting. We should see each of these three calls replaced by inlined |
| ;; code performing the if from $maybe-work-hard, and depending on that |
| ;; result they each call the outlined code that must *not* be inlined. |
| (call $many-params (i64.const 0) (i32.const 1) (f64.const 3.14159)) |
| (call $many-params (i64.const 0) (i32.const 1) (f64.const 3.14159)) |
| ) |
| |
| (func $condition-eqz (param $x i32) |
| (if |
| ;; More work in the condition, but work that we still consider worth |
| ;; optimizing: a unary op. |
| (i32.eqz |
| (local.get $x) |
| ) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-condition-eqz |
| ;; CHECK-NEXT: (local $0 i32) |
| ;; CHECK-NEXT: (local $1 i32) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-eqz |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-eqz0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-eqz |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-condition-eqz |
| (call $condition-eqz (i32.const 0)) |
| (call $condition-eqz (i32.const 1)) |
| ) |
| |
| (func $condition-global |
| (if |
| ;; A global read, also worth splitting. |
| (global.get $glob) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-condition-global |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-global |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-global) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-global0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-global) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-condition-global |
| (call $condition-global) |
| (call $condition-global) |
| ) |
| |
| (func $condition-ref.is (param $x anyref) |
| (if |
| ;; A ref.is operation. |
| (ref.is_null |
| (local.get $x) |
| ) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-condition-ref.is |
| ;; CHECK-NEXT: (local $0 anyref) |
| ;; CHECK-NEXT: (local $1 anyref) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-ref.is |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-ref.is |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$condition-ref.is0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$condition-ref.is |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-condition-ref.is |
| (call $condition-ref.is (ref.null any)) |
| (call $condition-ref.is (ref.null any)) |
| ) |
| |
| ;; CHECK: (func $condition-disallow-binary (param $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.add |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $condition-disallow-binary (param $x i32) |
| (if |
| ;; Work we do *not* allow (at least for now), a binary. |
| (i32.add |
| (local.get $x) |
| (local.get $x) |
| ) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-condition-disallow-binary |
| ;; CHECK-NEXT: (call $condition-disallow-binary |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $condition-disallow-binary |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-condition-disallow-binary |
| (call $condition-disallow-binary (i32.const 0)) |
| (call $condition-disallow-binary (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $condition-disallow-unreachable (param $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $condition-disallow-unreachable (param $x i32) |
| (if |
| ;; Work we do *not* allow (at least for now), an unreachable. |
| (i32.eqz |
| (unreachable) |
| ) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-condition-disallow-unreachable |
| ;; CHECK-NEXT: (call $condition-disallow-unreachable |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $condition-disallow-unreachable |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-condition-disallow-unreachable |
| (call $condition-disallow-unreachable (i32.const 0)) |
| (call $condition-disallow-unreachable (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $start-used-globally |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $start-used-globally |
| ;; This is optimizable even though it is the start function, that is is, |
| ;; having global uses of a function are not a problem for partial inlining |
| ;; (since we do not modify this function - we create new split pieces of |
| ;; it). |
| (if |
| (global.get $glob) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-start-used-globally |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$start-used-globally |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$start-used-globally) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$start-used-globally0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$start-used-globally) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-start-used-globally |
| (call $start-used-globally) |
| (call $start-used-globally) |
| ) |
| |
| (func $inlineable |
| ;; This looks optimizable, but it is also inlineable - so we do not need to |
| ;; split it. It will just be inlined directly, without any $outlined part |
| ;; that is split out. |
| (if |
| (global.get $glob) |
| (return) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-inlineable |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$inlineable |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: (br $__inlined_func$inlineable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$inlineable0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: (br $__inlined_func$inlineable0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-inlineable |
| (call $inlineable) |
| (call $inlineable) |
| ) |
| |
| ;; CHECK: (func $if-not-first (param $x i32) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $if-not-first (param $x i32) |
| ;; Except for the initial nop, we should outline this. As the if is not |
| ;; first any more, we ignore it. |
| (nop) |
| (if |
| (local.get $x) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-if-not-first |
| ;; CHECK-NEXT: (call $if-not-first |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $if-not-first |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-if-not-first |
| (call $if-not-first (i32.const 0)) |
| (call $if-not-first (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $if-else (param $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $if-else (param $x i32) |
| ;; An else in the if prevents us from recognizing the pattern we want. |
| (if |
| (local.get $x) |
| (return) |
| (nop) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-if-else |
| ;; CHECK-NEXT: (call $if-else |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $if-else |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-if-else |
| (call $if-else (i32.const 0)) |
| (call $if-else (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $if-non-return (param $x i32) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $if-non-return (param $x i32) |
| ;; Something other than a return in the if body prevents us from outlining. |
| (if |
| (local.get $x) |
| (unreachable) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-if-non-return |
| ;; CHECK-NEXT: (call $if-non-return |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $if-non-return |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-if-non-return |
| (call $if-non-return (i32.const 0)) |
| (call $if-non-return (i32.const 1)) |
| ) |
| |
| (func $colliding-name (param $x i32) |
| ;; When we outline this, the name should not collide with that of the |
| ;; function after us. |
| (if |
| (local.get $x) |
| (return) |
| ) |
| (loop $l |
| (call $import) |
| (br $l) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-colliding-name |
| ;; CHECK-NEXT: (local $0 i32) |
| ;; CHECK-NEXT: (local $1 i32) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$colliding-name |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$colliding-name_0 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$colliding-name0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$colliding-name_0 |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-colliding-name |
| (call $colliding-name (i32.const 0)) |
| (call $colliding-name (i32.const 1)) |
| ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$colliding-name |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $byn-split-outlined-A$colliding-name |
| ;; This function's name might collide with the split function we create for |
| ;; the above function; the split function's name must be fixed up. |
| ) |
| |
| ;; Pattern B: functions containing |
| ;; |
| ;; if (simple1) heavy-work-that-is-unreachable; |
| ;; if (simple..) heavy-work-that-is-unreachable; |
| ;; simplek |
| |
| (func $error-if-null (param $x anyref) (result anyref) |
| ;; A "as non null" function: If the input is null, issue an error somehow |
| ;; (here, by calling an import, but could also be a throwing of an |
| ;; exception). If not null, return the value. |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (block |
| (call $import) |
| (unreachable) |
| ) |
| ) |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-error-if-null |
| ;; CHECK-NEXT: (local $0 anyref) |
| ;; CHECK-NEXT: (local $1 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$error-if-null (result anyref) |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br $__inlined_func$byn-split-inlineable-B$error-if-null |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$error-if-null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$error-if-null0 (result anyref) |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br $__inlined_func$byn-split-inlineable-B$error-if-null0 |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$error-if-null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-error-if-null |
| (drop (call $error-if-null (ref.null any))) |
| (drop (call $error-if-null (ref.null any))) |
| ) |
| |
| ;; CHECK: (func $too-many (param $x anyref) (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| (func $too-many (param $x anyref) (result anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (block |
| (call $import) |
| (unreachable) |
| ) |
| ) |
| (nop) ;; An extra operation here prevents us from identifying the pattern. |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-too-many |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $too-many |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $too-many |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-too-many |
| (drop (call $too-many (ref.null any))) |
| (drop (call $too-many (ref.null any))) |
| ) |
| |
| ;; CHECK: (func $tail-not-simple (param $x anyref) (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $tail-not-simple (param $x anyref) (result anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (block |
| (call $import) |
| (unreachable) |
| ) |
| ) |
| (unreachable) ;; This prevents us from optimizing |
| ) |
| |
| ;; CHECK: (func $call-tail-not-simple |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $tail-not-simple |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $tail-not-simple |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-tail-not-simple |
| (drop (call $tail-not-simple (ref.null any))) |
| (drop (call $tail-not-simple (ref.null any))) |
| ) |
| |
| (func $reachable-if-body (param $x anyref) (result anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| ;; It is ok if the body is not unreachable (so long as it contains no |
| ;; returns). We will optimize this, and just do a call to the outlined |
| ;; code, without a return of a value here. |
| (call $import) |
| ) |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-reachable-if-body |
| ;; CHECK-NEXT: (local $0 anyref) |
| ;; CHECK-NEXT: (local $1 anyref) |
| ;; CHECK-NEXT: (local $2 anyref) |
| ;; CHECK-NEXT: (local $3 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$reachable-if-body (result anyref) |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-outlined-B$reachable-if-body |
| ;; CHECK-NEXT: (local.set $2 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$reachable-if-body0 (result anyref) |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-outlined-B$reachable-if-body0 |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-reachable-if-body |
| ;; Note that the above contains |
| ;; |
| ;; (block $__inlined_func$byn-split-outlined-B$reachable-if-body |
| ;; |
| ;; which indicates that we've inlined the outlined function. That seems odd, |
| ;; but it is the result of the if's body being just a call. When we outline, |
| ;; we end up with a function that all it does is make that call - which is |
| ;; worth inlining in the normal way (to avoid two calls). As a result of all |
| ;; that, we end up inlining *all* of $reachable-if-body, just by a |
| ;; roundabout way (split, outline, then inline). While this seems odd, each |
| ;; step along the way makes sense, and the result is a good one (might be a |
| ;; little hard to see before opts remove the extra block cruft etc.). |
| ;; |
| ;; We could avoid this if we detected that the if body is just a call, and |
| ;; not done any outlining - just done that call. That would be more |
| ;; efficient, but it would make the code more complicated, and the result is |
| ;; the same. |
| (drop (call $reachable-if-body (ref.null any))) |
| (drop (call $reachable-if-body (ref.null any))) |
| ) |
| |
| ;; CHECK: (func $reachable-if-body-return (param $x anyref) (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.const 1) |
| ;; CHECK-NEXT: (return |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| (func $reachable-if-body-return (param $x anyref) (result anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (if |
| (i32.const 1) |
| ;; The return here prevents the optimization. |
| (return |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| ) |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-reachable-if-body-return |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $reachable-if-body-return |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $reachable-if-body-return |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-reachable-if-body-return |
| (drop (call $reachable-if-body-return (ref.null any))) |
| (drop (call $reachable-if-body-return (ref.null any))) |
| ) |
| |
| (func $unreachable-if-body-no-result (param $x anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| ;; The if body is unreachable, but the function has no returned value. |
| ;; When we outline this code, we should not try to return a value. |
| (block |
| (call $import) |
| (unreachable) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $call-unreachable-if-body-no-result |
| ;; CHECK-NEXT: (local $0 anyref) |
| ;; CHECK-NEXT: (local $1 anyref) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$unreachable-if-body-no-result |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$unreachable-if-body-no-result |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$unreachable-if-body-no-result0 |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$unreachable-if-body-no-result |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-unreachable-if-body-no-result |
| (call $unreachable-if-body-no-result (ref.null any)) |
| (call $unreachable-if-body-no-result (ref.null any)) |
| ) |
| |
| (func $multi-if (param $x anyref) (result anyref) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| ;; A second if. We can outline both if bodies. |
| (if |
| (ref.is_func |
| (local.get $x) |
| ) |
| (loop $x |
| (call $import) |
| (br_if $x |
| (global.get $glob) |
| ) |
| ) |
| ) |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-multi-if |
| ;; CHECK-NEXT: (local $0 anyref) |
| ;; CHECK-NEXT: (local $1 anyref) |
| ;; CHECK-NEXT: (local $2 anyref) |
| ;; CHECK-NEXT: (local $3 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$multi-if (result anyref) |
| ;; CHECK-NEXT: (local.set $0 |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-outlined-B$multi-if |
| ;; CHECK-NEXT: (local.set $2 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_func |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$multi-if_0 |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-B$multi-if0 (result anyref) |
| ;; CHECK-NEXT: (local.set $1 |
| ;; CHECK-NEXT: (ref.null func) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-outlined-B$multi-if0 |
| ;; CHECK-NEXT: (local.set $3 |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_func |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-B$multi-if_0 |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-multi-if |
| (drop (call $multi-if (ref.null any))) |
| (drop (call $multi-if (ref.null func))) |
| ) |
| |
| ;; CHECK: (func $too-many-ifs (param $x anyref) (result anyref) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (ref.is_null |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| (func $too-many-ifs (param $x anyref) (result anyref) |
| ;; 5 ifs, which is too many. |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (if |
| (ref.is_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (local.get $x) |
| ) |
| |
| ;; CHECK: (func $call-too-many-ifs |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $too-many-ifs |
| ;; CHECK-NEXT: (ref.null any) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (call $too-many-ifs |
| ;; CHECK-NEXT: (ref.null func) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $call-too-many-ifs |
| (drop (call $too-many-ifs (ref.null any))) |
| (drop (call $too-many-ifs (ref.null func))) |
| ) |
| ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$maybe-work-hard (param $x i32) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-B$just-if (param $x i32) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br_if $l |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$many-params (param $x i64) (param $y i32) (param $z f64) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$condition-eqz (param $x i32) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$condition-global |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$condition-ref.is (param $x anyref) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$start-used-globally |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$colliding-name_0 (param $x i32) |
| ;; CHECK-NEXT: (loop $l |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br $l) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-B$error-if-null (param $x anyref) (result anyref) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-B$unreachable-if-body-no-result (param $x anyref) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-B$multi-if_0 (param $x anyref) |
| ;; CHECK-NEXT: (loop $x |
| ;; CHECK-NEXT: (call $import) |
| ;; CHECK-NEXT: (br_if $x |
| ;; CHECK-NEXT: (global.get $glob) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (module |
| ;; CHECK: (type $none_=>_none (func)) |
| (type $none_=>_none (func)) |
| ;; CHECK: (global $global$0 (mut i32) (i32.const 10)) |
| (global $global$0 (mut i32) (i32.const 10)) |
| ;; CHECK: (export "0" (func $0)) |
| (export "0" (func $0)) |
| ;; CHECK: (export "1" (func $1)) |
| (export "1" (func $1)) |
| ;; CHECK: (func $0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: (return) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (call $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$10 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (call $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $0 |
| ;; A function that is a good candidate to partially inline. |
| (if |
| (global.get $global$0) |
| (return) |
| ) |
| (call $1) |
| (call $1) |
| ) |
| ;; CHECK: (func $1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-outlined-A$0 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$00 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$10 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$01 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $1 |
| ;; This and the previous function are mutually recursive. As a result, we |
| ;; can keep partially inlining between them, creating new functions as we |
| ;; go, even though that is not very useful. |
| (call $0) |
| ) |
| |
| ;; Add a lot more functions, so the # of functions is high which would |
| ;; otherwise limit the # of iterations that we run. |
| ;; CHECK: (func $2 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $2 |
| (nop) |
| ) |
| ;; CHECK: (func $3 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $3 |
| (nop) |
| ) |
| ;; CHECK: (func $4 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $4 |
| (nop) |
| ) |
| ;; CHECK: (func $5 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $5 |
| (nop) |
| ) |
| ;; CHECK: (func $6 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $6 |
| (nop) |
| ) |
| ;; CHECK: (func $7 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $7 |
| (nop) |
| ) |
| ;; CHECK: (func $8 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $8 |
| (nop) |
| ) |
| ;; CHECK: (func $9 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $9 |
| (nop) |
| ) |
| ;; CHECK: (func $10 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $10 |
| (nop) |
| ) |
| ;; CHECK: (func $11 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $11 |
| (nop) |
| ) |
| ;; CHECK: (func $12 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $12 |
| (nop) |
| ) |
| ;; CHECK: (func $13 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $13 |
| (nop) |
| ) |
| ;; CHECK: (func $14 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $14 |
| (nop) |
| ) |
| ;; CHECK: (func $15 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $15 |
| (nop) |
| ) |
| ;; CHECK: (func $16 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $16 |
| (nop) |
| ) |
| ;; CHECK: (func $17 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $17 |
| (nop) |
| ) |
| ;; CHECK: (func $18 |
| ;; CHECK-NEXT: (nop) |
| ;; CHECK-NEXT: ) |
| (func $18 |
| (nop) |
| ) |
| ) |
| ;; CHECK: (func $byn-split-outlined-A$0 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0_0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$10 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$00 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0_0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$0_0 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$0 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0_1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$10 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$byn-split-inlineable-A$00 |
| ;; CHECK-NEXT: (if |
| ;; CHECK-NEXT: (i32.eqz |
| ;; CHECK-NEXT: (global.get $global$0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $byn-split-outlined-A$0_1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| |
| ;; CHECK: (func $byn-split-outlined-A$0_1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$1 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (call $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (block $__inlined_func$10 |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (call $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
