| ;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited. |
| |
| ;; RUN: foreach %s %t wasm-opt --closed-world --cfp -all -S -o - | filecheck %s |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new_default $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Copy the default value from $A to $B. Note that we do not detect that $B |
| ;; is never allocated in this pass. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new_default $A) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Same, but copy a non-default value. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (block (result (ref $B)) |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Now the copy has to look through fallthroughs on both the source and |
| ;; destination. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $B 0 |
| (block (result (ref null $B)) |
| (local.get $B) |
| ) |
| (block (result i32) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $B |
| ;; CHECK-NEXT: (struct.new $B |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Now copy from $A to $B, but also allocate a $B with a matching value. We |
| ;; should still optimize. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ;; This is new. |
| (local.set $B |
| (struct.new $B |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Now instead of allocating $B with the same value, we set $B with the same |
| ;; value. We can still optimize. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ;; This is a set now. |
| (struct.set $B 0 |
| (local.get $B) |
| (i32.const 10) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (local.set $B |
| ;; CHECK-NEXT: (struct.new $B |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Same, but now allocate $B with a conflicting value. We cannot optimize. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| (local.set $B |
| (struct.new $B |
| ;; Does not match. |
| (i32.const 20) |
| ) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This cannot be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local $A (ref $A)) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $B (ref $B)) (result i32) |
| ;; Same, but now the conflicting value comes from a set rather than an |
| ;; allocation. |
| (local $A (ref $A)) |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ;; This is a set now. |
| (struct.set $B 0 |
| (local.get $B) |
| (i32.const 20) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This cannot be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; Now the copied value comes from a set. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; The copied value comes from both a set and an allocation, but they match. |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (local.set $A |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; Now the source values don't match, so we cannot optimize. |
| (local.set $A |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 20) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; This should be optimized. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $other) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; Copy from $other to $struct. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| ;; We never wrote to $super, so the only value we can read from it is what |
| ;; was written to $struct (which also may have been a $sub at runtime). |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $other) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; Same as above, but now we copy to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $5) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above, but now with a different value in the subtype $sub1. We |
| ;; also add an additional subtype, $sub2, which can still be optimized. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (drop |
| (struct.new $sub1 |
| (i32.const 20) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; Copy from $other to $struct. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| ;; The copy might have written to $sub1 or $sub2, but only $sub2 does not |
| ;; already have another conflicting value. We can optimize $sub2 but not |
| ;; $sub1. |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $5) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (drop |
| (struct.new $sub1 |
| (i32.const 20) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; Now the copy is to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (type $6 (func (param (ref $sub1)))) |
| |
| ;; CHECK: (type $7 (func (param (ref $other) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $6) (param $sub1 (ref $sub1)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $sub1 (ref $sub1)) |
| ;; Now the value is set to an inexact reference to $sub1. This won't make a |
| ;; difference. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $sub1 0 |
| (local.get $sub1) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $7) (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; Copy from $other to $struct. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $5 (func)) |
| |
| ;; CHECK: (type $6 (func (param (ref $sub1)))) |
| |
| ;; CHECK: (type $7 (func (param (ref $other) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $6) (param $sub1 (ref $sub1)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $sub1 (ref $sub1)) |
| ;; Same as above. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $sub1 0 |
| (local.get $sub1) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $7) (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; Now the copy is to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $5) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $other) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $super |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Now the different value is in $super. Since it's set in an exact $super, |
| ;; it won't interfere with the copy. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (drop |
| (struct.new $super |
| (i32.const 20) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; Copy from $other to $struct. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $other) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $super |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (drop |
| (struct.new $super |
| (i32.const 20) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; Copy from $other to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $super)))) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $5) (param $super (ref $super)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $super (ref $super)) |
| ;; Now the different value is in an inexact $super. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $super 0 |
| (local.get $super) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $struct (ref $struct)) |
| ;; Copy from $other to $struct. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub 0 |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub 0 |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $super)))) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $5) (param $super (ref $super)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $super (ref $super)) |
| ;; Same as above. |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| (struct.set $super 0 |
| (local.get $super) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-struct (ref (exact $struct))) |
| ;; Copy from $other to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct))) |
| (type $super (sub (struct))) |
| ;; CHECK: (type $A (sub $super (struct (field (mut i32))))) |
| (type $A (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $super (struct (field (mut i32))))) |
| (type $B (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $super)))) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (func $init (type $5) (param $super (ref $super)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $super (ref $super)) |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $A (ref $A)) |
| ;; Copy from $other to $A. The fact that the field is missing in $super |
| ;; should not cause problems. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $B (ref null $B)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $A (ref null $A)) |
| (local $B (ref null $B)) |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $A (ref null (exact $A))) |
| ;; CHECK-NEXT: (local $B (ref null (exact $B))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $A (ref null (exact $A))) |
| (local $B (ref null (exact $B))) |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct))) |
| (type $super (sub (struct))) |
| ;; CHECK: (type $A (sub $super (struct (field (mut i32))))) |
| (type $A (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $super (struct (field (mut i32))))) |
| (type $B (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $other (struct (field (mut i32)))) |
| (type $other (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $super)))) |
| |
| ;; CHECK: (type $6 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (func $init (type $5) (param $super (ref $super)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $other |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $super (ref $super)) |
| (drop |
| (struct.new $other |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $6) (param $other (ref $other)) (param $exact-A (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $exact-A) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $exact-A (ref (exact $A))) |
| ;; Same as above, but now the copy is to exact $A. |
| (struct.set $A 0 |
| (local.get $exact-A) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $B (ref null $B)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $A (ref null $A)) |
| (local $B (ref null $B)) |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $A (ref null (exact $A))) |
| ;; CHECK-NEXT: (local $B (ref null (exact $B))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $A (ref null (exact $A))) |
| (local $B (ref null (exact $B))) |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $sub1 |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $struct (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) |
| ;; Copy from $struct to itself. This propagates the write from $sub1 to |
| ;; $sub2. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $sub1 |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $struct (ref $struct)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $exact-struct (ref (exact $struct))) |
| ;; Now copy from $struct to exact $struct. This does not propagate to $sub2. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $sub1 |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $struct (ref $struct)) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $exact-struct (ref (exact $struct))) |
| ;; Now copy from exact $struct to $struct. This does nothing, since exact |
| ;; $struct is not written to originally. |
| (struct.set $struct 0 |
| (local.get $struct) |
| (struct.get $struct 0 |
| (local.get $exact-struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref (exact $struct))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above. |
| (drop |
| (struct.new $sub1 |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $exact-struct (ref (exact $struct))) |
| ;; CHECK-NEXT: (struct.set $struct 0 |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $exact-struct (ref (exact $struct))) |
| ;; Now copy from exact $struct to exact $struct. |
| (struct.set $struct 0 |
| (local.get $exact-struct) |
| (struct.get $struct 0 |
| (local.get $exact-struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $struct2 (sub $super (struct (field (mut i32))))) |
| (type $struct2 (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref $super)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $sub |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $struct (ref $struct)) (param $super (ref $super)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $super (ref $super)) |
| ;; Copy from $struct to $super. |
| (struct.set $super 0 |
| (local.get $super) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $struct2 (ref null $struct2)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $struct2 (ref null (exact $struct2))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $struct2 (ref null (exact $struct2))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $struct2 (sub $super (struct (field (mut i32))))) |
| (type $struct2 (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref (exact $super))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $sub |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $struct (ref $struct)) (param $exact-super (ref (exact $super))) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $exact-super (ref (exact $super))) |
| ;; Copy from $struct to exact $super. |
| (struct.set $super 0 |
| (local.get $exact-super) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $struct2 (ref null $struct2)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $struct2 (ref null (exact $struct2))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $struct2 (ref null (exact $struct2))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $struct2 (sub $super (struct (field (mut i32))))) |
| (type $struct2 (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref (exact $struct)) (ref $super)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $sub |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $exact-struct (ref (exact $struct))) (param $super (ref $super)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $exact-struct (ref (exact $struct))) (param $super (ref $super)) |
| ;; Copy from exact $struct to $super. |
| (struct.set $super 0 |
| (local.get $super) |
| (struct.get $struct 0 |
| (local.get $exact-struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $struct2 (ref null $struct2)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $struct2 (ref null (exact $struct2))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $struct2 (ref null (exact $struct2))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $struct2 (sub $super (struct (field (mut i32))))) |
| (type $struct2 (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $struct (struct (field (mut i32))))) |
| (type $sub (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref (exact $struct)) (ref (exact $super))))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $sub |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $exact-struct (ref (exact $struct))) (param $exact-super (ref (exact $super))) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $exact-struct (ref (exact $struct))) (param $exact-super (ref (exact $super))) |
| ;; Copy from exact $struct to exact $super. |
| (struct.set $super 0 |
| (local.get $exact-super) |
| (struct.get $struct 0 |
| (local.get $exact-struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $struct2 (ref null $struct2)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $struct2 (ref null $struct2)) |
| (local $sub (ref null $sub)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $4) |
| ;; CHECK-NEXT: (local $super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $struct (ref null (exact $struct))) |
| ;; CHECK-NEXT: (local $struct2 (ref null (exact $struct2))) |
| ;; CHECK-NEXT: (local $sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $struct2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $super (ref null (exact $super))) |
| (local $struct (ref null (exact $struct))) |
| (local $struct2 (ref null (exact $struct2))) |
| (local $sub (ref null (exact $sub))) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $struct2 0 |
| (local.get $struct2) |
| ) |
| ) |
| (drop |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $struct (sub (struct (field (mut i32))))) |
| (type $struct (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $struct) (ref $sub1)))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $struct |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $struct |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $struct (ref $struct)) (param $sub1 (ref $sub1)) |
| ;; CHECK-NEXT: (struct.set $sub1 0 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $sub1 (ref $sub1)) |
| ;; Copy from $struct to $sub1. |
| (struct.set $sub1 0 |
| (local.get $sub1) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $3) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $3) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $struct (sub (struct (field (mut i32))))) |
| (type $struct (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $struct) (ref (exact $sub1))))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $struct |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $struct |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $struct (ref $struct)) (param $exact-sub1 (ref (exact $sub1))) |
| ;; CHECK-NEXT: (struct.set $sub1 0 |
| ;; CHECK-NEXT: (local.get $exact-sub1) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $struct (ref $struct)) (param $exact-sub1 (ref (exact $sub1))) |
| ;; Copy from $struct to exact $sub1. |
| (struct.set $sub1 0 |
| (local.get $exact-sub1) |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $gets (type $3) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $gets |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $exact-gets (type $3) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null (exact $sub1))) |
| ;; CHECK-NEXT: (local $sub2 (ref null (exact $sub2))) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $exact-gets |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null (exact $sub1))) |
| (local $sub2 (ref null (exact $sub2))) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $sub1 |
| (i32.const 666) |
| (i32.const 10) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $src (ref $struct)) (param $dst (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 2 |
| ;; CHECK-NEXT: (local.get $dst) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $src) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $src (ref $struct)) (param $dst (ref $struct)) |
| ;; Copy from index 1 to index 2 in the same type. The copied value will |
| ;; conflict with the initial value and inhibit optimization. |
| (struct.set $struct 2 |
| (local.get $dst) |
| (struct.get $struct 1 |
| (local.get $src) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get-0 (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get-0 |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 0 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 0 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 0 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get-1 (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get-1 |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 1 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 1 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 1 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 1 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get-2 (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 2 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 2 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 2 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get-2 |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 2 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 2 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 2 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 2 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $struct) (ref $struct)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; Same as above, except now field 2 is initialized with the same value as |
| ;; field 1, so the copy will not do anything. |
| (drop |
| (struct.new $sub1 |
| (i32.const 666) |
| (i32.const 10) |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $src (ref $struct)) (param $dst (ref $struct)) |
| ;; CHECK-NEXT: (struct.set $struct 2 |
| ;; CHECK-NEXT: (local.get $dst) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $src) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $src (ref $struct)) (param $dst (ref $struct)) |
| ;; Copy from index 1 to index 2 in the same type. |
| (struct.set $struct 2 |
| (local.get $dst) |
| (struct.get $struct 1 |
| (local.get $src) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get-2 (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get-2 |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 2 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 2 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 2 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 2 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $super (sub (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $struct (sub $super (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $struct (sub $super (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub1 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub1 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ;; CHECK: (type $sub2 (sub $struct (struct (field (mut i32)) (field (mut i32)) (field (mut i32))))) |
| (type $sub2 (sub $struct (struct (field (mut i32) (mut i32) (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $sub1) (ref $sub1)))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $sub1 |
| ;; CHECK-NEXT: (i32.const 666) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 0) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| ;; We're back to initializing field 2 with a different value. |
| (drop |
| (struct.new $sub1 |
| (i32.const 666) |
| (i32.const 10) |
| (i32.const 0) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $5) (param $src (ref $sub1)) (param $dst (ref $sub1)) |
| ;; CHECK-NEXT: (struct.set $sub1 2 |
| ;; CHECK-NEXT: (local.get $dst) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $src) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $src (ref $sub1)) (param $dst (ref $sub1)) |
| ;; Copy from index 1 to index 2, but now on $sub1, so we will be able to |
| ;; optimize $sub2. |
| (struct.set $sub1 2 |
| (local.get $dst) |
| (struct.get $sub1 1 |
| (local.get $src) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get-2 (type $4) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $struct (ref null $struct)) |
| ;; CHECK-NEXT: (local $sub1 (ref null $sub1)) |
| ;; CHECK-NEXT: (local $sub2 (ref null $sub2)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $super 2 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $struct 2 |
| ;; CHECK-NEXT: (local.get $struct) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $sub1 2 |
| ;; CHECK-NEXT: (local.get $sub1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub2) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get-2 |
| (local $super (ref null $super)) |
| (local $struct (ref null $struct)) |
| (local $sub1 (ref null $sub1)) |
| (local $sub2 (ref null $sub2)) |
| (drop |
| (struct.get $super 2 |
| (local.get $super) |
| ) |
| ) |
| (drop |
| (struct.get $struct 2 |
| (local.get $struct) |
| ) |
| ) |
| (drop |
| (struct.get $sub1 2 |
| (local.get $sub1) |
| ) |
| ) |
| (drop |
| (struct.get $sub2 2 |
| (local.get $sub2) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $B (ref null $B)) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $B (ref null $B)) |
| (local $C (ref null $C)) |
| ;; Copy $A to $B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $B to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $4) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $B (ref null $B)) |
| ;; CHECK-NEXT: (local $exact-B (ref null (exact $B))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $exact-B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $B (ref null $B)) |
| (local $exact-B (ref null (exact $B))) |
| (local $C (ref null $C)) |
| ;; Copy $A to $B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy exact $B to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $exact-B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $4) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $B (ref null $B)) |
| ;; CHECK-NEXT: (local $exact-B (ref null (exact $B))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $exact-B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $B (ref null $B)) |
| (local $exact-B (ref null (exact $B))) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $B. |
| (struct.set $B 0 |
| (local.get $exact-B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $B to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $4) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func)) |
| |
| ;; CHECK: (type $4 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $exact-B (ref null (exact $B))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $exact-B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $exact-B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $exact-B (ref null (exact $B))) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $B. |
| (struct.set $B 0 |
| (local.get $exact-B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $exact B to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $exact-B) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $4) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $sub 0 |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $sub (ref null $sub)) |
| (local $super (ref null $super)) |
| (local $C (ref null $C)) |
| ;; Copy $A to $sub. |
| (struct.set $sub 0 |
| (local.get $sub) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $super to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (local $exact-super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $sub 0 |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $sub (ref null $sub)) |
| (local $exact-super (ref null (exact $super))) |
| (local $C (ref null $C)) |
| ;; Copy $A to $sub. |
| (struct.set $sub 0 |
| (local.get $sub) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy exact $super to $C. This does not propagate the value. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $super 0 |
| (local.get $exact-super) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $exact-sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $sub 0 |
| ;; CHECK-NEXT: (local.get $exact-sub) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $exact-sub (ref null (exact $sub))) |
| (local $super (ref null $super)) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $sub. |
| (struct.set $sub 0 |
| (local.get $exact-sub) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $super to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $super 0 |
| (local.get $super) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $exact-sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (local $exact-super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $sub 0 |
| ;; CHECK-NEXT: (local.get $exact-sub) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $exact-sub (ref null (exact $sub))) |
| (local $exact-super (ref null (exact $super))) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $sub. |
| (struct.set $sub 0 |
| (local.get $exact-sub) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy exact $super to $C. This does not propagate the value. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $super 0 |
| (local.get $exact-super) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $sub (ref null $sub)) |
| (local $super (ref null $super)) |
| (local $C (ref null $C)) |
| ;; Copy $A to $super. |
| (struct.set $super 0 |
| (local.get $super) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $sub to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $exact-sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (local $super (ref null $super)) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $exact-sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $exact-sub (ref null (exact $sub))) |
| (local $super (ref null $super)) |
| (local $C (ref null $C)) |
| ;; Copy $A to $super. |
| (struct.set $super 0 |
| (local.get $super) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy exact $sub to $C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $sub 0 |
| (local.get $exact-sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $sub (ref null $sub)) |
| ;; CHECK-NEXT: (local $exact-super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $sub (ref null $sub)) |
| (local $exact-super (ref null (exact $super))) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $super. |
| (struct.set $super 0 |
| (local.get $exact-super) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy $sub to $C. This does not propagate the value. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $sub 0 |
| (local.get $sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $super (sub (struct (field (mut i32))))) |
| (type $super (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $sub (sub $super (struct (field (mut i32))))) |
| (type $sub (sub $super (struct (field (mut i32))))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $4 (func)) |
| |
| ;; CHECK: (type $5 (func (param (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $init (type $4) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.new $A |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init |
| (drop |
| (struct.new $A |
| (i32.const 10) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) |
| ;; CHECK-NEXT: (local $A (ref null $A)) |
| ;; CHECK-NEXT: (local $exact-sub (ref null (exact $sub))) |
| ;; CHECK-NEXT: (local $exact-super (ref null (exact $super))) |
| ;; CHECK-NEXT: (local $C (ref null $C)) |
| ;; CHECK-NEXT: (struct.set $super 0 |
| ;; CHECK-NEXT: (local.get $exact-super) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $exact-sub) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy |
| (local $A (ref null $A)) |
| (local $exact-sub (ref null (exact $sub))) |
| (local $exact-super (ref null (exact $super))) |
| (local $C (ref null $C)) |
| ;; Copy $A to exact $super. |
| (struct.set $super 0 |
| (local.get $exact-super) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy exact $sub to $C. This does not propagate the value. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $sub 0 |
| (local.get $exact-sub) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| (func $get (param $C (ref $C)) (result i32) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i32 to i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i8. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i16)))) |
| (type $B (struct (field (mut i16)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x0001FFFF) |
| ) |
| ;; Copy i32 to i16. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i16. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i32. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i32. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i32 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated then sign extended i32. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i16)))) |
| (type $B (struct (field (mut i16)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i16. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i16. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i16)))) |
| (type $B (struct (field (mut i16)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i16 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated then sign extended i16. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i16)))) |
| (type $A (struct (field (mut i16)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x0001FFFF) |
| ) |
| ;; Copy i16 to i32. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i32. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i16)))) |
| (type $A (struct (field (mut i16)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: (i32.const 16) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 16) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x0001FFFF) |
| ) |
| ;; Copy i16 to i32 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated then sign extended i32. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i16)))) |
| (type $A (struct (field (mut i16)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: (i32.const 65535) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x0001FFFF) |
| ) |
| ;; Copy i16 to i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i8. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i16)))) |
| (type $A (struct (field (mut i16)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 131071) |
| ;; CHECK-NEXT: (i32.const 16) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 16) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x0001FFFF) |
| ) |
| ;; Copy i16 to i8 with sign extension. This does not make a difference. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i8. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $1 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $test (type $1) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0xFFFFFFFF) |
| ) |
| ;; Copy the i8 to itself. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i8. |
| ;; TODO: We do not optimize this because the truncated copy value conflicts |
| ;; with the untruncated value found by the initial analysis. Fix this by |
| ;; tracking truncations and sign extensions as part of the analysis. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $1 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $test (type $1) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0xFFFFFFFF) |
| ) |
| ;; Copy the i8 to itself with sign extension. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read truncated i8. Now we can optimize because the sign-extended value |
| ;; happens to match the original value. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $1 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $test (type $1) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (struct.get_s $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy the i8 to itself with sign extension. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Now the value does not match and we don't optimize, even though we could |
| ;; in principle. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (global $g i32 (i32.const 0)) |
| (global $g i32 (i32.const 0)) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get_u $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (global.get $g) |
| ) |
| ;; Copy the i32 with global to the i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i8. We do not optimize this because we cannot model the |
| ;; truncation of the global. TODO. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (global $g i32 (i32.const 0)) |
| (global $g i32 (i32.const 0)) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (global.get $g) |
| ) |
| ;; Copy the i8 with global to the i32. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i32. We still cannot optimize. TODO. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (global $g i32 (i32.const 0)) |
| (global $g i32 (i32.const 0)) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (global.get $g) |
| ) |
| ;; Copy the i8 with global to the i32 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i32. We still cannot optimize. TODO. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $1 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (global $g i32 (i32.const 0)) |
| (global $g i32 (i32.const 0)) |
| |
| ;; CHECK: (func $test (type $1) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (global.get $g) |
| ) |
| ;; Copy the i8 holding the global to itself. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i8. We cannot model the truncated global. TODO. |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| |
| (module |
| (rec |
| ;; CHECK: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $1 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (global $g i32 (i32.const 0)) |
| (global $g i32 (i32.const 0)) |
| |
| ;; CHECK: (func $test (type $1) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (global.get $g) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (struct.get_s $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get_u $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (global.get $g) |
| ) |
| ;; Copy the i8 holding the global to itself with sign extension. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i8. We cannot model the truncated global. TODO. |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; Copy the uninitialized i8 to i32. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i32. It should still be uninitialized and optimized out. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; Copy the uninitialized i8 to i32 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i32. It should still be uninitialized and optimized out. |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $2 (func (param (ref $A) (ref $B)) (result i32))) |
| |
| ;; CHECK: (func $test (type $2) (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (result i32) |
| ;; Copy the uninitialized i32 to i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read the i8. It should still be uninitialized and optimized out. |
| (struct.get_u $B 0 |
| (local.get $B) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i32 to i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy the i8 to another i32. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get_u $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read truncated i32. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i8)))) |
| (type $B (struct (field (mut i8)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i32 to i8. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy the i8 to another i32 with sign extension. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get_s $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read truncated i32. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i8)))) |
| (type $C (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i32. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_u $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy the i32 to another i8. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read the i8. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i8)))) |
| (type $A (struct (field (mut i8)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i8)))) |
| (type $C (struct (field (mut i8)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.shr_s |
| ;; CHECK-NEXT: (i32.shl |
| ;; CHECK-NEXT: (i32.const 511) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 24) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const -1) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.and |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: (i32.const 255) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 0x000001FF) |
| ) |
| ;; Copy i8 to i32 with sign extension. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get_s $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy the i32 to another i8. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read the i8. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; A and B separately copy matching values into C |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (i32.const 10) |
| ) |
| ;; Copy A to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy B to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read C. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)) (result i32))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.get $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) (result i32) |
| ;; Now A and B separately copy different values into C |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| (struct.set $B 0 |
| (local.get $B) |
| (i32.const 20) |
| ) |
| ;; Copy A to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy B to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read C. We cannot optimize because there are multiple values. |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)))) |
| |
| ;; CHECK: (func $test (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $test (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; Copy A to both B and C. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| ;; Copy A to B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy A to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Read B. We can optimize. |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Read C. We can optimize this, too. |
| (drop |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)))) |
| |
| ;; CHECK: (func $copy (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; Create a loop copying A -> B -> C -> A. |
| ;; Copy A to B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy B to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Copy C to A. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (unreachable) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; Since no value ever entered the loop, these all get optimized out. |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| (drop |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)))) |
| |
| ;; CHECK: (type $4 (func (param (ref $A)))) |
| |
| ;; CHECK: (func $init (type $4) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $A (ref $A)) |
| ;; Now we inject a value into the loop. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; Create a loop copying A -> B -> C -> A. |
| ;; Copy A to B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy B to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Copy C to A. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (block (result i32) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; These all get optimized to the one injected value. |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| (drop |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (struct (field (mut i32)))) |
| (type $A (struct (field (mut i32)))) |
| ;; CHECK: (type $B (struct (field (mut i32)))) |
| (type $B (struct (field (mut i32)))) |
| ;; CHECK: (type $C (struct (field (mut i32)))) |
| (type $C (struct (field (mut i32)))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $A) (ref $B) (ref $C)))) |
| |
| ;; CHECK: (type $4 (func (param (ref $A) (ref $C)))) |
| |
| ;; CHECK: (func $init (type $4) (param $A (ref $A)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $A (ref $A)) (param $C (ref $C)) |
| ;; Now we inject two different values into the loop in different places. We |
| ;; won't be able to optimize anything. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 10) |
| ) |
| (struct.set $C 0 |
| (local.get $C) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (struct.get $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; Create a loop copying A -> B -> C -> A. |
| ;; Copy A to B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ;; Copy B to C. |
| (struct.set $C 0 |
| (local.get $C) |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| ;; Copy C to A. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $3) (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $B 0 |
| ;; CHECK-NEXT: (local.get $B) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (drop |
| ;; CHECK-NEXT: (struct.get $C 0 |
| ;; CHECK-NEXT: (local.get $C) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (param $B (ref $B)) (param $C (ref $C)) |
| ;; These cannot be optimized. |
| (drop |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| (drop |
| (struct.get $B 0 |
| (local.get $B) |
| ) |
| ) |
| (drop |
| (struct.get $C 0 |
| (local.get $C) |
| ) |
| ) |
| ) |
| ) |
