| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| ;; RUN: foreach %s %t wasm-opt -all --gufa -tnh --closed-world -S -o - | filecheck %s |
| |
| ;; A CallRef with no non-trapping targets must be unreachable if traps never |
| ;; happen, in a closed world, which is what this file tests. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (func)) |
| (type $A (func)) |
| ;; CHECK: (type $B (func)) |
| (type $B (func)) |
| ) |
| |
| ;; CHECK: (type $2 (func (param funcref))) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $impossible (type $A) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $impossible (type $A) |
| ;; This cannot be called if traps never happen. |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $irrelevant (type $B) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $irrelevant (type $B) |
| ;; This has a similar but different type, so it is irrelevant to this |
| ;; optimization. |
| (drop |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $2) (param $x funcref) |
| ;; CHECK-NEXT: (block ;; (replaces unreachable CallRef we can't emit) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| ;; This call must trap: the only function of the right type will trap. |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now there are no functions of type $A at all. |
| (module |
| (rec |
| ;; CHECK: (type $0 (func (param funcref))) |
| |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (func)) |
| (type $A (func)) |
| ;; CHECK: (type $B (func)) |
| (type $B (func)) |
| ) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $irrelevant (type $B) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $irrelevant (type $B) |
| ;; This has a similar but different type, so it is irrelevant to this |
| ;; optimization. |
| (drop |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $0) (param $x funcref) |
| ;; CHECK-NEXT: (block ;; (replaces unreachable CallRef we can't emit) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| ;; No function exists of type $A, so this will trap. |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now there is a function that can be called. |
| (module |
| ;; CHECK: (type $A (func)) |
| (type $A (func)) |
| |
| ;; CHECK: (type $1 (func (param funcref))) |
| |
| ;; CHECK: (elem declare func $possible) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $possible (type $A) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible (type $A) |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $1) (param $x funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.func $possible) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| ;; This must call $possible. |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; As above, with another function of that type that traps. |
| (module |
| ;; CHECK: (type $A (func)) |
| (type $A (func)) |
| |
| ;; CHECK: (type $1 (func (param funcref))) |
| |
| ;; CHECK: (elem declare func $possible) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $possible (type $A) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible (type $A) |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| |
| ;; CHECK: (func $impossible (type $A) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $impossible (type $A) |
| (unreachable) |
| ) |
| |
| ;; CHECK: (func $caller (type $1) (param $x funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.func $possible) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| ;; This must call $possible, as the trapping function won't be called. |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now we have two possible functions. We cannot optimize here. |
| (module |
| ;; CHECK: (type $A (func)) |
| (type $A (func)) |
| |
| ;; CHECK: (type $1 (func (param funcref))) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $possible (type $A) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible (type $A) |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-2 (type $A) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-2 (type $A) |
| (drop |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $1) (param $x funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now the second possible function is of a subtype. We still |
| ;; cannot optimize a call to the parent, but we can for the child. |
| (module |
| ;; CHECK: (type $A (sub (func))) |
| (type $A (sub (func))) |
| |
| ;; CHECK: (type $B (sub $A (func))) |
| (type $B (sub $A (func))) |
| |
| ;; CHECK: (type $2 (func (param funcref))) |
| |
| ;; CHECK: (elem declare func $possible-2) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $possible (type $A) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible (type $A) |
| (drop |
| (i32.const 10) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-2 (type $B) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-2 (type $B) |
| (drop |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $2) (param $x funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $x) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $B |
| ;; CHECK-NEXT: (ref.func $possible-2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") (param $x funcref) |
| ;; A has one function, but it has a subtype with another, so we cannot |
| ;; optimize |
| (call_ref $A |
| (ref.cast (ref $A) |
| (local.get $x) |
| ) |
| ) |
| ;; The second call can be optimized, as B has just one function. |
| (call_ref $B |
| (ref.cast (ref $B) |
| (local.get $x) |
| ) |
| ) |
| ) |
| ) |
| |
| ;; Two possible functions, but one has a parameter that will trap. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $X (sub (struct))) |
| (type $X (sub (struct))) |
| |
| ;; CHECK: (type $Y1 (sub $X (struct))) |
| (type $Y1 (sub $X (struct))) |
| |
| ;; CHECK: (type $Y2 (sub $X (struct))) |
| (type $Y2 (sub $X (struct))) |
| |
| ;; CHECK: (type $A (func (param anyref))) |
| (type $A (func (param anyref))) |
| ) |
| |
| ;; CHECK: (type $4 (func (param funcref funcref funcref structref))) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (elem declare func $possible-Y1 $possible-Y2) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (export "out2" (func $reffer)) |
| |
| ;; CHECK: (func $possible-Y1 (type $A) (param $ref anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-Y1 (type $A) (param $ref anyref) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-Y2 (type $A) (param $ref anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y2) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-Y2 (type $A) (param $ref anyref) |
| (drop |
| (ref.cast (ref $Y2) |
| (local.get $ref) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $4) (param $func1 funcref) (param $func2 funcref) (param $func3 funcref) (param $struct structref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (ref.func $possible-Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (ref.func $possible-Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") |
| (param $func1 funcref) |
| (param $func2 funcref) |
| (param $func3 funcref) |
| (param $struct structref) |
| |
| ;; This would trap if we called the function that casts to Y2, so we must be |
| ;; calling possible-Y1. |
| (call_ref $A |
| (struct.new $Y1) |
| (ref.cast (ref $A) |
| (local.get $func1) |
| ) |
| ) |
| ;; Inverse of the above: we must call possible-Y2. |
| (call_ref $A |
| (struct.new $Y2) |
| (ref.cast (ref $A) |
| (local.get $func2) |
| ) |
| ) |
| ;; This can call either one, and cannot be optimized. |
| (call_ref $A |
| (local.get $struct) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $reffer (type $5) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $reffer (export "out2") |
| ;; Take references to the possible functions so that GUFA does not optimize |
| ;; calls to them away. |
| (drop |
| (ref.func $possible-Y1) |
| ) |
| (drop |
| (ref.func $possible-Y2) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now the target functions have two parameters, to check for |
| ;; both of their casts being noticed. The second function still casts to Y2, but |
| ;; it casts the second parameter to that. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $X (sub (struct))) |
| (type $X (sub (struct))) |
| |
| ;; CHECK: (type $Y1 (sub $X (struct))) |
| (type $Y1 (sub $X (struct))) |
| |
| ;; CHECK: (type $Y2 (sub $X (struct))) |
| (type $Y2 (sub $X (struct))) |
| |
| ;; CHECK: (type $A (func (param anyref anyref))) |
| (type $A (func (param anyref) (param anyref))) |
| ) |
| |
| ;; CHECK: (type $4 (func (param funcref funcref funcref funcref))) |
| |
| ;; CHECK: (type $5 (func (param funcref funcref funcref funcref structref))) |
| |
| ;; CHECK: (type $6 (func)) |
| |
| ;; CHECK: (elem declare func $possible-Y1 $possible-Y2) |
| |
| ;; CHECK: (export "out" (func $caller1)) |
| |
| ;; CHECK: (export "out2" (func $caller2)) |
| |
| ;; CHECK: (export "out3" (func $reffer)) |
| |
| ;; CHECK: (func $possible-Y1 (type $A) (param $ref anyref) (param $ref2 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-Y1 (type $A) (param $ref anyref) (param $ref2 anyref) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-Y2 (type $A) (param $ref anyref) (param $ref2 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y2) |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-Y2 (type $A) (param $ref anyref) (param $ref2 anyref) |
| (drop |
| (ref.cast (ref $Y2) |
| (local.get $ref2) ;; this changed from ref to ref2. |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller1 (type $4) (param $func1 funcref) (param $func2 funcref) (param $func3 funcref) (param $func4 funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (ref.func $possible-Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (ref.func $possible-Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block ;; (replaces unreachable CallRef we can't emit) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller1 (export "out") |
| (param $func1 funcref) |
| (param $func2 funcref) |
| (param $func3 funcref) |
| (param $func4 funcref) |
| |
| ;; Both params are Y1. The cast to Y2 would fail, so this must call |
| ;; possible-Y1. |
| (call_ref $A |
| (struct.new $Y1) |
| (struct.new $Y1) |
| (ref.cast (ref $A) |
| (local.get $func1) |
| ) |
| ) |
| ;; Both params are Y2. The cast to Y1 would fail, so this must call |
| ;; possible-Y2. |
| (call_ref $A |
| (struct.new $Y2) |
| (struct.new $Y2) |
| (ref.cast (ref $A) |
| (local.get $func2) |
| ) |
| ) |
| ;; Cast the first to Y1 and the second to Y2. Both functions match here, so |
| ;; we cannot optimize. |
| (call_ref $A |
| (struct.new $Y1) |
| (struct.new $Y2) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ;; The inverse, which matches no functions at all, and we trap. |
| (call_ref $A |
| (struct.new $Y2) |
| (struct.new $Y1) |
| (ref.cast (ref $A) |
| (local.get $func4) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller2 (type $5) (param $func1 funcref) (param $func2 funcref) (param $func3 funcref) (param $func4 funcref) (param $struct structref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (ref.func $possible-Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (ref.func $possible-Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller2 (export "out2") |
| (param $func1 funcref) |
| (param $func2 funcref) |
| (param $func3 funcref) |
| (param $func4 funcref) |
| (param $struct structref) |
| |
| ;; Both are structref, so both functions are possible, and we cannot |
| ;; optimize. |
| (call_ref $A |
| (local.get $struct) |
| (local.get $struct) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ;; Y1 in the first param works in both functions; no optimization. |
| (call_ref $A |
| (struct.new $Y1) |
| (local.get $struct) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ;; Y2 in the first param fails in the first, so we optimize to the second. |
| (call_ref $A |
| (struct.new $Y2) |
| (local.get $struct) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ;; Y1 in the second param fails in the second, so we optimize to the first. |
| (call_ref $A |
| (local.get $struct) |
| (struct.new $Y1) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ;; Y2 in the second param works in both functions; no optimization. |
| (call_ref $A |
| (local.get $struct) |
| (struct.new $Y2) |
| (ref.cast (ref $A) |
| (local.get $func3) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $reffer (type $6) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-Y1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-Y2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $reffer (export "out3") |
| ;; Take references to the possible functions so that GUFA does not optimize |
| ;; calls to them away. |
| (drop |
| (ref.func $possible-Y1) |
| ) |
| (drop |
| (ref.func $possible-Y2) |
| ) |
| ) |
| ) |
| |
| ;; Casts in multiple call_ref possible targets. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $X (sub (struct))) |
| (type $X (sub (struct))) |
| |
| ;; CHECK: (type $Y1 (sub $X (struct))) |
| (type $Y1 (sub $X (struct))) |
| |
| ;; CHECK: (type $Y2 (sub $X (struct))) |
| (type $Y2 (sub $X (struct))) |
| |
| ;; CHECK: (type $A (func (param anyref anyref anyref anyref anyref anyref))) |
| (type $A (func (param anyref) (param anyref) (param anyref) (param anyref) (param anyref) (param anyref))) |
| ) |
| |
| ;; CHECK: (type $4 (func (param anyref anyref anyref anyref anyref anyref funcref))) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (elem declare func $possible-1 $possible-2) |
| |
| ;; CHECK: (export "out" (func $caller1)) |
| |
| ;; CHECK: (export "out2" (func $reffer)) |
| |
| ;; CHECK: (func $possible-1 (type $A) (param $ref anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref5) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref6) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-1 (type $A) (param $ref anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref2) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref4) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref5) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref6) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-2 (type $A) (param $ref anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref5) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y2) |
| ;; CHECK-NEXT: (local.get $ref6) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-2 (type $A) (param $ref anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref3) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref4) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref5) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y2) |
| (local.get $ref6) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller1 (type $4) (param $ref1 anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) (param $func funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast anyref |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast anyref |
| ;; CHECK-NEXT: (local.get $ref3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref4) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref5) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref6) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller1 (export "out") |
| (param $ref1 anyref) |
| (param $ref2 anyref) |
| (param $ref3 anyref) |
| (param $ref4 anyref) |
| (param $ref5 anyref) |
| (param $ref6 anyref) |
| |
| (param $func funcref) |
| |
| ;; All the params have a cast, so we can potentially refine them depending |
| ;; on the call targets. |
| (call_ref $A |
| ;; The first param is cast to $X in both targets, so we can apply that. |
| (ref.cast anyref |
| (local.get $ref1) |
| ) |
| ;; The second and third are cast to $X just in one of them, so we do |
| ;; nothing. |
| (ref.cast anyref |
| (local.get $ref2) |
| ) |
| (ref.cast anyref |
| (local.get $ref3) |
| ) |
| ;; The fourth and fifth are cast to $X and $Y1, so we can apply the LUB, |
| ;; which is $X. |
| (ref.cast anyref |
| (local.get $ref4) |
| ) |
| (ref.cast anyref |
| (local.get $ref5) |
| ) |
| ;; The last is cast to $Y1 and $Y2, and the LUB is $X. |
| (ref.cast anyref |
| (local.get $ref6) |
| ) |
| (ref.cast (ref $A) |
| (local.get $func) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $reffer (type $5) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $reffer (export "out2") |
| ;; Take references to the possible functions so that GUFA does not optimize |
| ;; calls to them away. |
| (drop |
| (ref.func $possible-1) |
| ) |
| (drop |
| (ref.func $possible-2) |
| ) |
| ) |
| ) |
| |
| ;; As above, but now the declared type is $X and not anyref, so we need to |
| ;; improve past that. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $X (sub (struct))) |
| (type $X (sub (struct))) |
| |
| ;; CHECK: (type $Y1 (sub $X (struct))) |
| (type $Y1 (sub $X (struct))) |
| |
| ;; CHECK: (type $Y2 (sub $X (struct))) |
| (type $Y2 (sub $X (struct))) |
| |
| ;; CHECK: (type $A (func (param (ref null $X) (ref null $X) (ref null $X)))) |
| (type $A (func (param (ref null $X)) (param (ref null $X)) (param (ref null $X)))) |
| ) |
| |
| ;; CHECK: (type $4 (func (param anyref anyref anyref anyref anyref anyref funcref))) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (elem declare func $possible-1 $possible-2) |
| |
| ;; CHECK: (export "out" (func $caller1)) |
| |
| ;; CHECK: (export "out2" (func $reffer)) |
| |
| ;; CHECK: (func $possible-1 (type $A) (param $ref (ref null $X)) (param $ref2 (ref null $X)) (param $ref3 (ref null $X)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-1 (type $A) (param $ref (ref null $X)) (param $ref2 (ref null $X)) (param $ref3 (ref null $X)) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref2) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref3) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $possible-2 (type $A) (param $ref (ref null $X)) (param $ref2 (ref null $X)) (param $ref3 (ref null $X)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $possible-2 (type $A) (param $ref (ref null $X)) (param $ref2 (ref null $X)) (param $ref3 (ref null $X)) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $X) |
| (local.get $ref2) |
| ) |
| ) |
| (drop |
| (ref.cast (ref $Y1) |
| (local.get $ref3) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller1 (type $4) (param $ref1 anyref) (param $ref2 anyref) (param $ref3 anyref) (param $ref4 anyref) (param $ref5 anyref) (param $ref6 anyref) (param $func funcref) |
| ;; CHECK-NEXT: (call_ref $A |
| ;; CHECK-NEXT: (ref.cast (ref null $X) |
| ;; CHECK-NEXT: (local.get $ref1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $X) |
| ;; CHECK-NEXT: (local.get $ref2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (local.get $ref3) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (ref.cast (ref $A) |
| ;; CHECK-NEXT: (local.get $func) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller1 (export "out") |
| (param $ref1 anyref) |
| (param $ref2 anyref) |
| (param $ref3 anyref) |
| (param $ref4 anyref) |
| (param $ref5 anyref) |
| (param $ref6 anyref) |
| |
| (param $func funcref) |
| |
| ;; All the params have a cast, so we can potentially refine them depending |
| ;; on the call targets. |
| (call_ref $A |
| ;; The first is cast to $Y1 in only one target, so we can do nothing. |
| (ref.cast (ref null $X) |
| (local.get $ref1) |
| ) |
| ;; The second is cast to $X in one $Y1 in the other, so we can refine the |
| ;; nullability at least. |
| (ref.cast (ref null $X) |
| (local.get $ref2) |
| ) |
| ;; The third parameter is cast to $Y1 in both, so we can optimize to that. |
| (ref.cast (ref null $X) |
| (local.get $ref3) |
| ) |
| (ref.cast (ref $A) |
| (local.get $func) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $reffer (type $5) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.func $possible-2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $reffer (export "out2") |
| ;; Take references to the possible functions so that GUFA does not optimize |
| ;; calls to them away. |
| (drop |
| (ref.func $possible-1) |
| ) |
| (drop |
| (ref.func $possible-2) |
| ) |
| ) |
| ) |
| |
| ;; Test for a cast with incompatible heap types but nullability allows the cast |
| ;; to succeed at runtime. |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $X (sub (struct))) |
| (type $X (sub (struct))) |
| |
| ;; CHECK: (type $Y1 (sub $X (struct))) |
| (type $Y1 (sub $X (struct))) |
| |
| ;; CHECK: (type $Y2 (sub $X (struct))) |
| (type $Y2 (sub $X (struct))) |
| |
| ;; CHECK: (type $A (func (param anyref))) |
| (type $A (func (param anyref))) |
| ) |
| |
| ;; CHECK: (type $4 (func (param i32))) |
| |
| ;; CHECK: (export "out" (func $caller)) |
| |
| ;; CHECK: (func $called (type $A) (param $ref anyref) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.cast (ref null $Y1) |
| ;; CHECK-NEXT: (local.get $ref) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $called (type $A) (param $ref anyref) |
| (drop |
| (ref.cast (ref null $Y1) |
| (local.get $ref) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $caller (type $4) (param $i i32) |
| ;; CHECK-NEXT: (call $called |
| ;; CHECK-NEXT: (ref.null none) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $called |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (call $called |
| ;; CHECK-NEXT: (ref.cast (ref $Y1) |
| ;; CHECK-NEXT: (select (result (ref $X)) |
| ;; CHECK-NEXT: (struct.new_default $Y1) |
| ;; CHECK-NEXT: (struct.new_default $Y2) |
| ;; CHECK-NEXT: (local.get $i) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $caller (export "out") |
| (param $i i32) |
| |
| ;; The param is either a null or a Y2, but only the null can pass the cast |
| ;; in the called function, so we can infer a value of null here. |
| (call $called |
| (select (result (ref null $Y2)) |
| (ref.null $Y2) |
| (struct.new $Y2) |
| (local.get $i) |
| ) |
| ) |
| |
| ;; If no null is possible, this must trap. |
| (call $called |
| (select (result (ref $Y2)) |
| (struct.new $Y2) |
| (struct.new $Y2) |
| (local.get $i) |
| ) |
| ) |
| |
| ;; Only Y1 would succeed, so we can infer that the cast can be to $Y1. |
| (call $called |
| (ref.cast (ref $X) |
| (select (result (ref $X)) |
| (struct.new $Y1) |
| (struct.new $Y2) |
| (local.get $i) |
| ) |
| ) |
| ) |
| ) |
| ) |
