| ;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited. |
| ;; RUN: wasm-opt %s --remove-unused-brs -all -S -o - \ |
| ;; RUN: | filecheck %s |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $struct (sub (struct))) |
| (type $struct (sub (struct))) |
| ;; CHECK: (type $struct2 (struct)) |
| (type $struct2 (struct)) |
| ;; CHECK: (type $substruct (sub $struct (struct))) |
| (type $substruct (sub $struct (struct))) |
| ) |
| |
| ;; CHECK: (type $struct-nn (struct (field (ref any)))) |
| (type $struct-nn (struct (field (ref any)))) |
| |
| ;; CHECK: (global $struct (ref $struct) (struct.new_default $struct)) |
| (global $struct (ref $struct) (struct.new $struct)) |
| |
| ;; CHECK: (func $br_on-if (type $10) (param $0 (ref struct)) |
| ;; CHECK-NEXT: (block $label |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (select (result (ref struct)) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on-if (param $0 (ref struct)) |
| (block $label |
| (drop |
| ;; This br is never taken, as the input is non-nullable, so we can remove |
| ;; it. When we do so, we replace it with the if. We should not rescan that |
| ;; if, which has already been walked, as that would hit an assertion. |
| ;; |
| (br_on_null $label |
| ;; This if can also be turned into a select, separately from the above |
| ;; (that is not specifically intended to be tested here). |
| (if (result (ref struct)) |
| (i32.const 0) |
| (then |
| (local.get $0) |
| ) |
| (else |
| (local.get $0) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast (type $4) (param $0 (ref $struct)) (result (ref $struct)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (block $block (result (ref $struct)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (struct.new_default $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $block |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast $block (ref $struct) (ref $substruct) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast (param (ref $struct)) (result (ref $struct)) |
| (local $struct (ref null $struct)) |
| (block $block (result (ref $struct)) |
| (drop |
| ;; This cast can be computed at compile time: it will definitely be taken, |
| ;; so we can turn it into a normal br. |
| (br_on_cast $block anyref (ref $struct) |
| (struct.new $struct) |
| ) |
| ) |
| (drop |
| ;; This cast can be partially computed at compile time, but we still need to |
| ;; do a null check. |
| (br_on_cast $block anyref (ref $struct) |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| ;; This cast cannot be optimized at all. |
| (br_on_cast $block anyref (ref $substruct) |
| (local.get 0) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast-fallthrough (type $4) (param $0 (ref $struct)) (result (ref $struct)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $any anyref) |
| ;; CHECK-NEXT: (block $block (result (ref $struct)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (ref.cast (ref (exact $struct)) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $block |
| ;; CHECK-NEXT: (ref.cast (ref null $struct) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast $block anyref (ref $substruct) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast-fallthrough (param (ref $struct)) (result (ref $struct)) |
| ;; Same as above, but now the type information comes from fallthrough values. |
| (local $struct (ref null $struct)) |
| (local $any anyref) |
| (block $block (result (ref $struct)) |
| (drop |
| ;; Definitely taken, but will need a cast for validity. |
| (br_on_cast $block anyref (ref $struct) |
| (local.tee $any (struct.new $struct)) |
| ) |
| ) |
| (drop |
| ;; Needs a null check and cast for validity. |
| (br_on_cast $block anyref (ref $struct) |
| (local.tee $any (local.get $struct)) |
| ) |
| ) |
| (drop |
| ;; This cannot be optimized, but at least it still doesn't need an |
| ;; additional cast. |
| (br_on_cast $block anyref (ref $substruct) |
| (local.tee $any (local.get 0)) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $nested_br_on_cast (type $11) (result i31ref) |
| ;; CHECK-NEXT: (block $label$1 (result (ref i31)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $label$1 |
| ;; CHECK-NEXT: (ref.i31 |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $nested_br_on_cast (result i31ref) |
| (block $label$1 (result i31ref) |
| (drop |
| ;; The inner br_on_cast will become a direct br since the type proves it |
| ;; is in fact i31. That then becomes unreachable, and the parent must |
| ;; handle that properly (do nothing without hitting an assertion). |
| (br_on_cast $label$1 (ref any) (ref i31) |
| (br_on_cast $label$1 (ref any) (ref i31) |
| (ref.i31 (i32.const 0)) |
| ) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_unrelated (type $5) (result (ref null $struct)) |
| ;; CHECK-NEXT: (local $nullable-struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (block $block (result nullref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast $block (ref null $struct2) nullref |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_unrelated (result (ref null $struct)) |
| (local $nullable-struct2 (ref null $struct2)) |
| (block $block (result (ref null $struct)) |
| (drop |
| ;; This cast can be computed at compile time: it will definitely fail, so we |
| ;; can remove it. |
| (br_on_cast $block anyref (ref $struct) |
| (struct.new $struct2) |
| ) |
| ) |
| (drop |
| ;; We can still remove it even if the cast allows nulls. |
| (br_on_cast $block anyref (ref null $struct) |
| (struct.new $struct2) |
| ) |
| ) |
| (drop |
| ;; Or if the cast does not allow nulls and the value is nullable. |
| (br_on_cast $block anyref (ref $struct) |
| (local.get $nullable-struct2) |
| ) |
| ) |
| (drop |
| ;; But if both are nullable, then the cast will succeed only if the value is |
| ;; null, so we can partially optimize. |
| ;; TODO: Optimize this. |
| (br_on_cast $block anyref (ref null $struct) |
| (local.get $nullable-struct2) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_unrelated-fallthrough (type $5) (result (ref null $struct)) |
| ;; CHECK-NEXT: (local $any anyref) |
| ;; CHECK-NEXT: (local $nullable-struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (block $block (result nullref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast $block anyref nullref |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_unrelated-fallthrough (result (ref null $struct)) |
| ;; Same as above, but now all the type information comes from fallthrough values. |
| (local $any anyref) |
| (local $nullable-struct2 (ref null $struct2)) |
| (block $block (result (ref null $struct)) |
| (drop |
| ;; Definitely not taken. |
| (br_on_cast $block anyref (ref $struct) |
| (local.tee $any (struct.new $struct2)) |
| ) |
| ) |
| (drop |
| ;; Still not taken. Note that we start by flowing out a non-nullable value, |
| ;; and will add a cast to ensure we still do after optimization. |
| (br_on_cast $block anyref (ref null $struct) |
| (local.tee $any (struct.new $struct2)) |
| ) |
| ) |
| (drop |
| ;; Also not taken. |
| (br_on_cast $block anyref (ref $struct) |
| (local.tee $any (local.get $nullable-struct2)) |
| ) |
| ) |
| (drop |
| ;; Taken only if null. |
| ;; TODO: Optimize this. |
| (br_on_cast $block anyref (ref null $struct) |
| (local.tee $any (local.get $nullable-struct2)) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_fail (type $6) (param $0 (ref $struct)) (result anyref) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (block $block (result (ref null $struct)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new_default $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast_fail $block (ref null $struct) (ref $struct) |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast_fail $block (ref $struct) (ref $substruct) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_fail (param (ref $struct)) (result anyref) |
| (local $struct (ref null $struct)) |
| (block $block (result anyref) |
| (drop |
| ;; This cast can be computed at compile time: it will definitely succeed so |
| ;; the branch will not be taken. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (struct.new $struct) |
| ) |
| ) |
| (drop |
| ;; This cast can be partially computed at compile time, but we still need to |
| ;; do a null check. |
| ;; TODO: optimize this. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| ;; This cast cannot be optimized at all. |
| (br_on_cast_fail $block anyref (ref $substruct) |
| (local.get 0) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_fail-fallthrough (type $6) (param $0 (ref $struct)) (result anyref) |
| ;; CHECK-NEXT: (local $any anyref) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (block $block (result anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref (exact $struct)) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast_fail $block anyref (ref $struct) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_cast_fail $block anyref (ref $substruct) |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_fail-fallthrough (param (ref $struct)) (result anyref) |
| ;; Same as above, but now the type information comes from fallthrough values. |
| (local $any anyref) |
| (local $struct (ref null $struct)) |
| (block $block (result anyref) |
| (drop |
| ;; This cast will succeed. We will need a cast for validity. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.tee $any (struct.new $struct)) |
| ) |
| ) |
| (drop |
| ;; We will still need a null check. |
| ;; TODO: optimize this. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.tee $any (local.get $struct)) |
| ) |
| ) |
| (drop |
| ;; This cast cannot be optimized at all. |
| (br_on_cast_fail $block anyref (ref $substruct) |
| (local.tee $any (local.get 0)) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_fail_unrelated (type $7) (result anyref) |
| ;; CHECK-NEXT: (local $nullable-struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (block $block (result (ref null $struct2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $block |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_fail_unrelated (result anyref) |
| (local $nullable-struct2 (ref null $struct2)) |
| (block $block (result anyref) |
| (drop |
| ;; This cast can be computed at compile time: it will definitely fail, so we |
| ;; can replace it with an unconditional br. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (struct.new $struct2) |
| ) |
| ) |
| (drop |
| ;; We can still replace it even if the cast allows nulls. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (struct.new $struct2) |
| ) |
| ) |
| (drop |
| ;; Or if the cast does not allow nulls and the value is nullable. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.get $nullable-struct2) |
| ) |
| ) |
| (drop |
| ;; But if both are nullable, then we can only partially optimize because we |
| ;; still have to do a null check. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (local.get $nullable-struct2) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_fail_unrelated-fallthrough (type $7) (result anyref) |
| ;; CHECK-NEXT: (local $any anyref) |
| ;; CHECK-NEXT: (local $nullable-struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (block $block (result anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $block |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_fail_unrelated-fallthrough (result anyref) |
| ;; Same as above, but now type information comes from fallthrough values. |
| (local $any anyref) |
| (local $nullable-struct2 (ref null $struct2)) |
| (block $block (result anyref) |
| (drop |
| ;; Will definitely take the branch. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.tee $any (struct.new $struct2)) |
| ) |
| ) |
| (drop |
| ;; Ditto, but also add a ref.as_non_null, as we must keep sending a non- |
| ;; null value to the block (the block would still validate either way, but |
| ;; we do not want to un-refine the sent value). See the next function for a |
| ;; test with a non-nullable block. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (local.tee $any (struct.new $struct2)) |
| ) |
| ) |
| (drop |
| ;; Ditto. |
| (br_on_cast_fail $block anyref (ref $struct) |
| (local.tee $any (local.get $nullable-struct2)) |
| ) |
| ) |
| (drop |
| ;; Still has to do a null check. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (local.tee $any (local.get $nullable-struct2)) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast_fail_unrelated-fallthrough-non-null (type $12) (result (ref any)) |
| ;; CHECK-NEXT: (local $any anyref) |
| ;; CHECK-NEXT: (local $nullable-struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (block $block (result (ref any)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br $block |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (struct.new_default $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $block |
| ;; CHECK-NEXT: (local.tee $any |
| ;; CHECK-NEXT: (local.get $nullable-struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast_fail_unrelated-fallthrough-non-null (result (ref any)) |
| ;; Same as above, but the block is now non-nullable. Only the branches that |
| ;; work with that are tested. |
| (local $any anyref) |
| (local $nullable-struct2 (ref null $struct2)) |
| (block $block (result (ref any)) ;; this changed, and the function's results |
| (drop |
| ;; Will definitely take the branch. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (local.tee $any (struct.new $struct2)) |
| ) |
| ) |
| (drop |
| ;; Still has to do a null check. |
| (br_on_cast_fail $block anyref (ref null $struct) |
| (local.tee $any (local.get $nullable-struct2)) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $br_on_cast-unreachable (type $8) (param $i31ref i31ref) (result anyref) |
| ;; CHECK-NEXT: (block $block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result (ref none)) |
| ;; CHECK-NEXT: (ref.cast (ref none) |
| ;; CHECK-NEXT: (block (result i31ref) |
| ;; CHECK-NEXT: (local.get $i31ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result (ref none)) |
| ;; CHECK-NEXT: (ref.cast (ref none) |
| ;; CHECK-NEXT: (block (result i31ref) |
| ;; CHECK-NEXT: (local.get $i31ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $br_on_cast-unreachable (param $i31ref i31ref) (result anyref) |
| ;; Optimize out br_on_cast* where the input is uninhabitable. |
| (block $block (result anyref) |
| (drop |
| (br_on_cast $block anyref (ref i31) |
| (block (result anyref) |
| (ref.cast (ref struct) |
| (block (result anyref) |
| (local.get $i31ref) |
| ) |
| ) |
| ) |
| ) |
| ) |
| (br_on_cast_fail $block anyref (ref i31) |
| (block (result anyref) |
| (ref.cast (ref struct) |
| (block (result anyref) |
| (local.get $i31ref) |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $fallthrough-unreachable (type $8) (param $0 i31ref) (result anyref) |
| ;; CHECK-NEXT: (block $outer |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block ;; (replaces unreachable RefCast we can't emit) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref none) |
| ;; CHECK-NEXT: (local.get $0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $fallthrough-unreachable (param $0 i31ref) (result anyref) |
| (block $outer (result (ref none)) |
| (drop |
| ;; This should not crash due to the new unreachable below. |
| (br_on_cast $outer (ref none) (ref none) |
| (ref.cast (ref none) |
| ;; This will be optimized to a drop + unreachable. |
| (br_on_cast $outer (ref none) (ref none) |
| (ref.cast (ref none) |
| (local.get $0) |
| ) |
| ) |
| ) |
| ) |
| ) |
| (unreachable) |
| ) |
| ) |
| |
| ;; CHECK: (func $casts-are-costly (type $9) (param $x i32) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (if (result i32) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (ref.test (ref none) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (if (result nullref) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (ref.cast nullref |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (if (result (ref null $struct)) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (block $something (result (ref null $struct)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (br_on_non_null $something |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (select (result nullref) |
| ;; CHECK-NEXT: (block (result nullref) |
| ;; CHECK-NEXT: (block $nothing |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (br $nothing) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $casts-are-costly (param $x i32) |
| ;; We never turn an if into a select if an arm has a cast of any kind, as |
| ;; those things involve branches internally, so we'd be adding more than we |
| ;; save. |
| (local $struct (ref null $struct)) |
| (drop |
| (if (result i32) |
| (local.get $x) |
| (then |
| (ref.test (ref $struct) |
| (ref.null any) |
| ) |
| ) |
| (else |
| (i32.const 0) |
| ) |
| ) |
| ) |
| (drop |
| (if (result anyref) |
| (local.get $x) |
| (then |
| (ref.null any) |
| ) |
| (else |
| (ref.cast (ref null $struct) |
| (ref.null any) |
| ) |
| ) |
| ) |
| ) |
| ;; We do not selectify here because the amount of work in the if is |
| ;; significant (there is a cast and a branch). |
| (drop |
| (if (result anyref) |
| (local.get $x) |
| (then |
| (block (result anyref) |
| (block $something (result anyref) |
| (drop |
| (br_on_cast $something anyref (ref $struct) |
| (local.get $struct) |
| ) |
| ) |
| (ref.null any) |
| ) |
| ) |
| ) |
| (else |
| (ref.null any) |
| ) |
| ) |
| ) |
| ;; However, null checks are fairly fast, and we will emit a select here. |
| (drop |
| (if (result anyref) |
| (local.get $x) |
| (then |
| (block (result anyref) |
| (block $nothing |
| (drop |
| (br_on_null $nothing |
| (ref.null $struct) |
| ) |
| ) |
| ) |
| (ref.null any) |
| ) |
| ) |
| (else |
| (ref.null any) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $allocations-are-costly (type $9) (param $x i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (if (result (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: (then |
| ;; CHECK-NEXT: (struct.new_default $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (else |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (select (result nullref) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $allocations-are-costly (param $x i32) |
| ;; Allocations are too expensive for us to unconditionalize and selectify |
| ;; here. |
| (drop |
| (if (result anyref) |
| (local.get $x) |
| (then |
| (struct.new $struct) |
| ) |
| (else |
| (ref.null any) |
| ) |
| ) |
| ) |
| ;; But two nulls are fine. |
| (drop |
| (if (result anyref) |
| (local.get $x) |
| (then |
| (ref.null any) |
| ) |
| (else |
| (ref.null any) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $threading (type $13) (param $x anyref) |
| ;; CHECK-NEXT: (block $outer |
| ;; CHECK-NEXT: (block $inner |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (br_on_null $outer |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $threading (param $x anyref) |
| (block $outer |
| (block $inner |
| ;; This jump can go to $outer. |
| (drop |
| (br_on_null $inner |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $test (type $14) (param $x (ref any)) |
| ;; CHECK-NEXT: (local $temp anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block $block (result (ref $struct-nn)) |
| ;; CHECK-NEXT: (struct.new $struct-nn |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (br_on_cast $block anyref (ref $struct-nn) |
| ;; CHECK-NEXT: (local.tee $temp |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $x (ref any)) |
| (local $temp anyref) |
| ;; Read the inline comments blow from the bottom to the top (order of |
| ;; execution). Basically, the story is that the br_on_cast begins as |
| ;; flowing out a non-nullable type, since the cast allows nulls (so only a |
| ;; non-null can flow out). We can see that the br_on_cast receives a non- |
| ;; nullable value, even though it flows through a local.tee that un-refines |
| ;; it. Using the non-nullability, we can refine the cast type (type sent on |
| ;; the branch) to be non-nullable. But then the type of the br_on_cast itself |
| ;; becomes nullable, since nulls no longer get sent on the branch, which |
| ;; breaks the parent that must receive a non-nullable value. |
| ;; |
| ;; To fix this, we add a cast on the br's output, forcing it to the exact |
| ;; same type it had before. |
| (drop |
| (block $block (result anyref) |
| (struct.new $struct-nn ;; must provide a NON- |
| ;; nullable value for the |
| ;; struct field |
| |
| (br_on_cast $block anyref (ref null $struct-nn) ;; GLB on the castType |
| ;; makes it non-nullable, |
| ;; which makes the type |
| ;; of the br_on_cast |
| ;; nullable |
| |
| (local.tee $temp ;; nullable |
| |
| (local.get $x) ;; non-nullable |
| ) |
| ) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $select-refinalize (type $15) (param $param (ref $struct)) (result (ref struct)) |
| ;; CHECK-NEXT: (select (result (ref $struct)) |
| ;; CHECK-NEXT: (select (result (ref $struct)) |
| ;; CHECK-NEXT: (global.get $struct) |
| ;; CHECK-NEXT: (global.get $struct) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.get $param) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $select-refinalize (param $param (ref $struct)) (result (ref struct)) |
| ;; The inner if can turn into a select. The type then changes, allowing the |
| ;; outer select to be refined, which will error if we do not refinalize. |
| (select (result (ref struct)) |
| (if (result (ref struct)) |
| (i32.const 0) |
| (then |
| (global.get $struct) |
| ) |
| (else |
| (global.get $struct) |
| ) |
| ) |
| (local.get $param) |
| (i32.const 0) |
| ) |
| ) |
| ) |
