| ;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited. |
| ;; RUN: wasm-opt %s --optimize-instructions --traps-never-happen -all -S -o - | filecheck %s --check-prefix TNH |
| ;; RUN: wasm-opt %s --optimize-instructions -all -S -o - | filecheck %s --check-prefix NO_TNH |
| |
| (module |
| ;; TNH: (type $struct (sub (struct (field (mut i32))))) |
| ;; NO_TNH: (type $struct (sub (struct (field (mut i32))))) |
| (type $struct (sub (struct (field (mut i32))))) |
| |
| ;; TNH: (type $void (func)) |
| ;; NO_TNH: (type $void (func)) |
| (type $void (func)) |
| |
| ;; TNH: (import "a" "b" (func $import (type $2) (result i32))) |
| ;; NO_TNH: (import "a" "b" (func $import (type $2) (result i32))) |
| (import "a" "b" (func $import (result i32))) |
| |
| ;; TNH: (func $ref.eq (type $7) (param $a eqref) (param $b eqref) (result i32) |
| ;; TNH-NEXT: (ref.eq |
| ;; TNH-NEXT: (local.get $a) |
| ;; TNH-NEXT: (local.get $b) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $ref.eq (type $7) (param $a eqref) (param $b eqref) (result i32) |
| ;; NO_TNH-NEXT: (ref.eq |
| ;; NO_TNH-NEXT: (ref.cast (ref $struct) |
| ;; NO_TNH-NEXT: (local.get $a) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.cast (ref struct) |
| ;; NO_TNH-NEXT: (local.get $b) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $ref.eq (param $a (ref null eq)) (param $b (ref null eq)) (result i32) |
| ;; When traps never happen we can remove all the casts here, since they do |
| ;; not affect the comparison of the references. |
| (ref.eq |
| ;; When traps can happen we can still improve this by removing and |
| ;; combining redundant casts. |
| (ref.cast (ref struct) |
| (ref.as_non_null |
| (ref.cast (ref null $struct) |
| (local.get $a) |
| ) |
| ) |
| ) |
| ;; Note that we can remove the non-null casts here in both modes, as the |
| ;; ref.cast struct also checks for null. |
| (ref.cast (ref struct) |
| (ref.as_non_null |
| (ref.as_non_null |
| (local.get $b) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $ref.eq-no (type $8) (param $a eqref) (param $b eqref) (param $any anyref) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $ref.eq-no (type $8) (param $a eqref) (param $b eqref) (param $any anyref) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.eq |
| ;; NO_TNH-NEXT: (ref.cast (ref null $struct) |
| ;; NO_TNH-NEXT: (local.get $any) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.cast (ref struct) |
| ;; NO_TNH-NEXT: (local.get $any) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $ref.eq-no (param $a (ref null eq)) (param $b (ref null eq)) (param $any anyref) |
| ;; We must leave the inputs to ref.eq of type eqref or a subtype. |
| (drop |
| (ref.eq |
| (ref.cast (ref null $struct) |
| (local.get $any) ;; *Not* an eqref! |
| ) |
| (ref.as_non_null |
| (ref.cast (ref struct) |
| (ref.as_non_null |
| (local.get $any) ;; *Not* an eqref! |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $ref.is (type $3) (param $a eqref) (result i32) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.cast (ref $struct) |
| ;; TNH-NEXT: (local.get $a) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 0) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $ref.is (type $3) (param $a eqref) (result i32) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.cast (ref $struct) |
| ;; NO_TNH-NEXT: (local.get $a) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 0) |
| ;; NO_TNH-NEXT: ) |
| (func $ref.is (param $a (ref null eq)) (result i32) |
| ;; In this case non-nullability is enough to tell that the ref.is will |
| ;; return 0. TNH does not help here. |
| (ref.is_null |
| (ref.cast (ref $struct) |
| (ref.as_non_null |
| (ref.cast (ref struct) |
| (local.get $a) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $ref.is_b (type $9) (param $a eqref) (param $f funcref) (result i32) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.is_null |
| ;; TNH-NEXT: (local.get $a) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (ref.is_null |
| ;; TNH-NEXT: (local.get $f) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $ref.is_b (type $9) (param $a eqref) (param $f funcref) (result i32) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.is_null |
| ;; NO_TNH-NEXT: (ref.cast (ref null $struct) |
| ;; NO_TNH-NEXT: (local.get $a) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.is_null |
| ;; NO_TNH-NEXT: (ref.cast (ref null $void) |
| ;; NO_TNH-NEXT: (local.get $f) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $ref.is_b (param $a eqref) (param $f funcref) (result i32) |
| ;; Here we only have a cast, and no cast operations that force the value |
| ;; to be non-nullable. That means we cannot remove the ref.is, but we can |
| ;; remove the cast in TNH. |
| (drop |
| (ref.is_null |
| (ref.cast (ref null $struct) |
| (local.get $a) |
| ) |
| ) |
| ) |
| ;; It works on func references, too. |
| (ref.is_null |
| (ref.cast (ref null $void) |
| (local.get $f) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $ref.test (type $3) (param $a eqref) (result i32) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result i32) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.cast i31ref |
| ;; TNH-NEXT: (local.get $a) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block (result i32) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.as_non_null |
| ;; TNH-NEXT: (local.get $a) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $ref.test (type $3) (param $a eqref) (result i32) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result i32) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.cast i31ref |
| ;; NO_TNH-NEXT: (local.get $a) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (block (result i32) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.as_non_null |
| ;; NO_TNH-NEXT: (local.get $a) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $ref.test (param $a eqref) (result i32) |
| (drop |
| (ref.test i31ref |
| (ref.cast i31ref |
| (local.get $a) |
| ) |
| ) |
| ) |
| (ref.test (ref eq) |
| (ref.cast (ref eq) |
| (local.get $a) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $if.arm.null (type $4) (param $x i32) (param $ref (ref $struct)) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $if.arm.null (type $4) (param $x i32) (param $ref (ref $struct)) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (if (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: (then |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (else |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (if (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: (then |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (else |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 2) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $if.arm.null (param $x i32) (param $ref (ref $struct)) |
| ;; A set will trap on a null, so in tnh mode we know the null arm is not |
| ;; executed, and the other one is. |
| (struct.set $struct 0 |
| (if (result (ref null $struct)) |
| (local.get $x) |
| (then |
| (local.get $ref) |
| ) |
| (else |
| (ref.null none) |
| ) |
| ) |
| (i32.const 1) |
| ) |
| (struct.set $struct 0 |
| (if (result (ref null $struct)) |
| (local.get $x) |
| (then |
| (ref.null none) |
| ) |
| (else |
| (local.get $ref) |
| ) |
| ) |
| (i32.const 2) |
| ) |
| ) |
| |
| ;; TNH: (func $select.arm.null (type $4) (param $x i32) (param $ref (ref $struct)) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (block |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $select.arm.null (type $4) (param $x i32) (param $ref (ref $struct)) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (select (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (select (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 2) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $select.arm.null (param $x i32) (param $ref (ref $struct)) |
| ;; As above but with a select. |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (local.get $ref) |
| (ref.null none) |
| (local.get $x) |
| ) |
| (i32.const 1) |
| ) |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (ref.null none) |
| (local.get $ref) |
| (local.get $x) |
| ) |
| (i32.const 2) |
| ) |
| ) |
| |
| ;; TNH: (func $select.arm.null.effects (type $void) |
| ;; TNH-NEXT: (local $temp i32) |
| ;; TNH-NEXT: (local $1 (ref $struct)) |
| ;; TNH-NEXT: (local $2 (ref $struct)) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (local.set $1 |
| ;; TNH-NEXT: (struct.new $struct |
| ;; TNH-NEXT: (local.tee $temp |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result nullref) |
| ;; TNH-NEXT: (local.set $temp |
| ;; TNH-NEXT: (i32.const 2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $temp) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result nullref) |
| ;; TNH-NEXT: (local.set $temp |
| ;; TNH-NEXT: (i32.const 2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block (result (ref $struct)) |
| ;; TNH-NEXT: (local.set $2 |
| ;; TNH-NEXT: (struct.new $struct |
| ;; TNH-NEXT: (local.tee $temp |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $temp) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (local.get $2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 2) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $select.arm.null.effects (type $void) |
| ;; NO_TNH-NEXT: (local $temp i32) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (select (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (struct.new $struct |
| ;; NO_TNH-NEXT: (local.tee $temp |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (block (result nullref) |
| ;; NO_TNH-NEXT: (local.set $temp |
| ;; NO_TNH-NEXT: (i32.const 2) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (local.get $temp) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (select (result (ref null $struct)) |
| ;; NO_TNH-NEXT: (block (result nullref) |
| ;; NO_TNH-NEXT: (local.set $temp |
| ;; NO_TNH-NEXT: (i32.const 2) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.new $struct |
| ;; NO_TNH-NEXT: (local.tee $temp |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (local.get $temp) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 2) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $select.arm.null.effects |
| (local $temp i32) |
| ;; As above but there are conflicting effects and we must add a local when |
| ;; we optimize. |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (struct.new $struct |
| (local.tee $temp |
| (i32.const 1) |
| ) |
| ) |
| (block (result (ref null none)) |
| (local.set $temp |
| (i32.const 2) |
| ) |
| (ref.null none) |
| ) |
| (local.get $temp) |
| ) |
| (i32.const 1) |
| ) |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (block (result (ref null none)) |
| (local.set $temp |
| (i32.const 2) |
| ) |
| (ref.null none) |
| ) |
| (struct.new $struct |
| (local.tee $temp |
| (i32.const 1) |
| ) |
| ) |
| (local.get $temp) |
| ) |
| (i32.const 2) |
| ) |
| ) |
| |
| ;; TNH: (func $null.arm.null.effects (type $void) |
| ;; TNH-NEXT: (block ;; (replaces unreachable StructSet we can't emit) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (select |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: (call $get-i32) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result nullref) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (call $get-i32) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $null.arm.null.effects (type $void) |
| ;; NO_TNH-NEXT: (block ;; (replaces unreachable StructSet we can't emit) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (select |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: (call $get-i32) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (block |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result nullref) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (call $get-i32) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (ref.null none) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $null.arm.null.effects |
| ;; Verify we do not error on a null reference in a select, even if cast to |
| ;; non-null. |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (ref.as_non_null |
| (ref.null none) |
| ) |
| (ref.null none) |
| (call $get-i32) |
| ) |
| (i32.const 1) |
| ) |
| ;; The same, but without ref.as_non_null. |
| (struct.set $struct 0 |
| (select (result (ref null $struct)) |
| (ref.null none) |
| (ref.null none) |
| (call $get-i32) |
| ) |
| (i32.const 1) |
| ) |
| ) |
| |
| ;; TNH: (func $set-get-cast (type $10) (param $ref structref) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (struct.get $struct 0 |
| ;; TNH-NEXT: (ref.cast (ref $struct) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (ref.cast (ref $struct) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (ref.cast (ref null $struct) |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (block (result i32) |
| ;; TNH-NEXT: (return) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $set-get-cast (type $10) (param $ref structref) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (struct.get $struct 0 |
| ;; NO_TNH-NEXT: (ref.cast (ref $struct) |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (ref.cast (ref null $struct) |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (ref.cast (ref null $struct) |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (block (result i32) |
| ;; NO_TNH-NEXT: (return) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $set-get-cast (param $ref (ref null struct)) |
| ;; A nullable cast flowing into a place that traps on null can become a |
| ;; non-nullable cast. |
| (drop |
| (struct.get $struct 0 |
| (ref.cast (ref null $struct) |
| (local.get $ref) |
| ) |
| ) |
| ) |
| ;; Ditto for a set, at least in traps-happen mode. |
| ;; TODO handle non-TNH as well, but we need to be careful of effects in |
| ;; other children. |
| (struct.set $struct 0 |
| (ref.cast (ref null $struct) |
| (local.get $ref) |
| ) |
| (i32.const 1) |
| ) |
| ;; Even in TNH mode, a child with an effect of control flow transfer |
| ;; prevents us from optimizing - if the parent is not necessarily reached, |
| ;; we cannot infer the child won't trap. |
| (struct.set $struct 0 |
| (ref.cast (ref null $struct) |
| (local.get $ref) |
| ) |
| (block (result i32) |
| ;; This block has type i32, to check that we don't just look for |
| ;; unreachable. We must scan for any transfer of control flow in the |
| ;; child of the struct.set. |
| (return) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $cast-if-null (type $5) (param $x (ref none)) (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $cast-if-null (type $5) (param $x (ref none)) (result (ref $struct)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (if (result (ref none)) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: (then |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (else |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| (func $cast-if-null (param $x (ref none)) (result (ref $struct)) |
| ;; We can remove the unreachable arm of the if here in TNH mode. While doing |
| ;; so we must refinalize properly or else we'll hit an error in pass-debug |
| ;; mode. |
| (ref.cast (ref $struct) |
| (if (result (ref none)) |
| (i32.const 1) |
| (then |
| (unreachable) |
| ) |
| (else |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $cast-if-null-flip (type $5) (param $x (ref none)) (result (ref $struct)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $cast-if-null-flip (type $5) (param $x (ref none)) (result (ref $struct)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (if (result (ref none)) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: (then |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (else |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| (func $cast-if-null-flip (param $x (ref none)) (result (ref $struct)) |
| ;; As above but with arms flipped. |
| (ref.cast (ref $struct) |
| (if (result (ref none)) |
| (i32.const 1) |
| (then |
| (local.get $x) |
| ) |
| (else |
| (unreachable) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $cast-to-bottom (type $11) (param $ref (ref any)) (param $nullable-ref anyref) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result (ref none)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result (ref none)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $nullable-ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result (ref none)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result nullref) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (local.get $nullable-ref) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (ref.null none) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $cast-to-bottom (type $11) (param $ref (ref any)) (param $nullable-ref anyref) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result (ref none)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result (ref none)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (local.get $nullable-ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result (ref none)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (local.get $ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.cast nullref |
| ;; NO_TNH-NEXT: (local.get $nullable-ref) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $cast-to-bottom (param $ref (ref any)) (param $nullable-ref anyref) |
| ;; Non-nullable casts to none must trap (regardless of whether the input is |
| ;; nullable or not, the output is an impossible type). |
| (drop |
| (ref.cast (ref none) |
| (local.get $ref) |
| ) |
| ) |
| (drop |
| (ref.cast (ref none) |
| (local.get $nullable-ref) |
| ) |
| ) |
| ;; Nullable casts to null have more possibilities. First, if the input is |
| ;; non-nullable then we trap. |
| (drop |
| (ref.cast nullref |
| (local.get $ref) |
| ) |
| ) |
| ;; Second, if the value may be a null, then we either return a null or we |
| ;; trap. In TNH mode we dismiss the possibility of a trap and so we can just |
| ;; return a null here. (In non-TNH mode we could do a check for null etc., |
| ;; but we'd be increasing code size.) |
| (drop |
| (ref.cast nullref |
| (local.get $nullable-ref) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $null.cast-other.effects (type $12) (param $x (ref null $struct)) |
| ;; TNH-NEXT: (local $i i32) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: (call $import) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: (i32.const 10) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (struct.set $struct 0 |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: (local.tee $i |
| ;; TNH-NEXT: (i32.const 10) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $null.cast-other.effects (type $12) (param $x (ref null $struct)) |
| ;; NO_TNH-NEXT: (local $i i32) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (ref.as_non_null |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (call $import) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: (i32.const 10) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (struct.set $struct 0 |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: (local.tee $i |
| ;; NO_TNH-NEXT: (i32.const 10) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $null.cast-other.effects (param $x (ref null $struct)) |
| (local $i i32) |
| (struct.set $struct 0 |
| ;; We cannot remove this ref.as_non_null, even though the struct.set will |
| ;; trap if the ref is null, because that would move the trap from before |
| ;; the call to the import to be after it. But in TNH we can assume it does |
| ;; not trap, and remove it. |
| (ref.as_non_null |
| (local.get $x) |
| ) |
| (call $import) |
| ) |
| (struct.set $struct 0 |
| ;; This one can be removed even without TNH, as there are no effects after |
| ;; it. |
| (ref.as_non_null |
| (local.get $x) |
| ) |
| (i32.const 10) |
| ) |
| (struct.set $struct 0 |
| ;; This one can be removed even without TNH, even though there are effects |
| ;; in it. A tee only has local effects, which do not interfere with a |
| ;; trap. |
| (ref.as_non_null |
| (local.get $x) |
| ) |
| (local.tee $i |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $select.unreachable.child (type $6) (param $x (ref $struct)) (result (ref $struct)) |
| ;; TNH-NEXT: (block ;; (replaces unreachable RefCast we can't emit) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $select.unreachable.child (type $6) (param $x (ref $struct)) (result (ref $struct)) |
| ;; NO_TNH-NEXT: (block ;; (replaces unreachable RefCast we can't emit) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $select.unreachable.child (param $x (ref $struct)) (result (ref $struct)) |
| ;; We will turn the false arm of the select into an unreachable first, and |
| ;; then process the select. While doing so we must not error, as the select |
| ;; itself will still have a reachable type (a full refinalize only |
| ;; happens at the very end of the function). |
| (ref.cast (ref $struct) |
| (select (result (ref $struct)) |
| (ref.as_non_null |
| (ref.null none) |
| ) |
| (local.get $x) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $select.unreachable.child.flip (type $6) (param $x (ref $struct)) (result (ref $struct)) |
| ;; TNH-NEXT: (select |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $select.unreachable.child.flip (type $6) (param $x (ref $struct)) (result (ref $struct)) |
| ;; NO_TNH-NEXT: (select |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $select.unreachable.child.flip (param $x (ref $struct)) (result (ref $struct)) |
| ;; Flip case of the above. |
| (ref.cast (ref $struct) |
| (select (result (ref $struct)) |
| (local.get $x) |
| (ref.as_non_null |
| (ref.null none) |
| ) |
| (i32.const 1) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $if.null.child.but.no.flow (type $void) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (block (result (ref nofunc)) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (if (result (ref nofunc)) |
| ;; TNH-NEXT: (i32.const 1) |
| ;; TNH-NEXT: (then |
| ;; TNH-NEXT: (return) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (else |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $if.null.child.but.no.flow (type $void) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (block (result (ref nofunc)) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (if (result (ref nofunc)) |
| ;; NO_TNH-NEXT: (i32.const 1) |
| ;; NO_TNH-NEXT: (then |
| ;; NO_TNH-NEXT: (return) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (else |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $if.null.child.but.no.flow |
| ;; The if's true arm has a bottom type, which the cast would trap on. But we |
| ;; cannot optimize using that fact, as the null does not actually flow out - |
| ;; we return from the function before. So we should not replace the if with |
| ;; the false arm (that would trap, and change the behavior; tnh can remove |
| ;; traps, not add them). |
| (drop |
| (ref.cast (ref func) |
| (if (result (ref nofunc)) |
| (i32.const 1) |
| (then |
| (block (result (ref nofunc)) |
| (return) |
| ) |
| ) |
| (else |
| (unreachable) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; TNH: (func $set-of-as-non-null (type $void) |
| ;; TNH-NEXT: (local $x anyref) |
| ;; TNH-NEXT: (local.set $x |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: (drop |
| ;; TNH-NEXT: (ref.as_non_null |
| ;; TNH-NEXT: (local.tee $x |
| ;; TNH-NEXT: (local.get $x) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $set-of-as-non-null (type $void) |
| ;; NO_TNH-NEXT: (local $x anyref) |
| ;; NO_TNH-NEXT: (local.set $x |
| ;; NO_TNH-NEXT: (ref.as_non_null |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: (drop |
| ;; NO_TNH-NEXT: (ref.as_non_null |
| ;; NO_TNH-NEXT: (local.tee $x |
| ;; NO_TNH-NEXT: (local.get $x) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| ;; NO_TNH-NEXT: ) |
| (func $set-of-as-non-null |
| (local $x anyref) |
| ;; We can remove the ref.as_non_null here because the local is nullable and |
| ;; we are ignoring traps. |
| ;; TODO: Should we keep the cast to let us refine the local later? |
| (local.set $x |
| (ref.as_non_null |
| (local.get $x) |
| ) |
| ) |
| ;; The same for a tee. |
| (drop |
| (local.tee $x |
| (ref.as_non_null |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| |
| ;; Helper functions. |
| |
| ;; TNH: (func $get-i32 (type $2) (result i32) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $get-i32 (type $2) (result i32) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| (func $get-i32 (result i32) |
| (unreachable) |
| ) |
| ;; TNH: (func $get-ref (type $13) (result (ref $struct)) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $get-ref (type $13) (result (ref $struct)) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| (func $get-ref (result (ref $struct)) |
| (unreachable) |
| ) |
| ;; TNH: (func $get-null (type $14) (result nullref) |
| ;; TNH-NEXT: (unreachable) |
| ;; TNH-NEXT: ) |
| ;; NO_TNH: (func $get-null (type $14) (result nullref) |
| ;; NO_TNH-NEXT: (unreachable) |
| ;; NO_TNH-NEXT: ) |
| (func $get-null (result (ref null none)) |
| (unreachable) |
| ) |
| ) |
