| ;; 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-reftest -all -S -o - | filecheck %s |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A (ref $A)) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set inexact A. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; 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-exact (ref (exact $A))) |
| ;; Copy to exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We won't be able to optimize because the set of inexact A could go to |
| ;; anything. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref $B)))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A (ref $A)) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set inexact A. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $B (ref $B)) |
| ;; 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 $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $B (ref $B)) |
| ;; Copy to inexact B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We won't be able to optimize because the set of inexact A could go to |
| ;; anything. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref (exact $B))))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A (ref $A)) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set inexact A. |
| (struct.set $A 0 |
| (local.get $A) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B-exact) |
| ;; 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 $B-exact (ref (exact $B))) |
| ;; Copy to exact B. |
| (struct.set $B 0 |
| (local.get $B-exact) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We won't be able to optimize because the set of inexact A could go to |
| ;; anything. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (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 to inexact A. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We won't be able to optimize because the copy to inexact A could go to |
| ;; anything. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref $B)))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $B (ref $B)) |
| ;; 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 $other) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $copy (param $other (ref $other)) (param $B (ref $B)) |
| ;; Copy to inexact B. |
| (struct.set $B 0 |
| (local.get $B) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: (ref.test (ref $B) |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We can optimize! Only B will have the copied value. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref (exact $B))))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B-exact) |
| ;; 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 $B-exact (ref (exact $B))) |
| ;; Copy to exact B. |
| (struct.set $B 0 |
| (local.get $B-exact) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: (ref.test (ref $B) |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We can optimize! Only B will have the copied value. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $B))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact B. |
| (struct.set $B 0 |
| (local.get $B-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; 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-exact (ref (exact $A))) |
| ;; Copy to exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (ref.test (ref $B) |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; Switch the copy and set destinations from the previous case. We can still |
| ;; optimize! |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32)) (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32)) (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $B))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref (exact $A))))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact B. |
| (struct.set $B 0 |
| (local.get $B-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $A-exact (ref (exact $A))) |
| ;; CHECK-NEXT: (struct.set $other 1 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; 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: (struct.set $A 0 |
| ;; CHECK-NEXT: (local.get $A-exact) |
| ;; 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-exact (ref (exact $A))) |
| ;; Copy to another field and from there to exact A. |
| (struct.set $other 1 |
| (local.get $other) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ;; Copy to exact A. |
| (struct.set $A 0 |
| (local.get $A-exact) |
| (struct.get $other 1 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (select |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: (ref.test (ref $B) |
| ;; CHECK-NEXT: (ref.as_non_null |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We can still optimize after doing two copies. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
| |
| (module |
| (rec |
| ;; CHECK: (rec |
| ;; CHECK-NEXT: (type $A (sub (struct (field (mut i32))))) |
| (type $A (sub (struct (field (mut i32))))) |
| ;; CHECK: (type $B (sub $A (struct (field (mut i32))))) |
| (type $B (sub $A (struct (field (mut i32))))) |
| ;; CHECK: (type $other (sub (struct (field (mut i32)) (field (mut i32))))) |
| (type $other (sub (struct (field (mut i32)) (field (mut i32))))) |
| ) |
| |
| ;; CHECK: (type $3 (func (param (ref $other) (ref (exact $B))))) |
| |
| ;; CHECK: (type $4 (func (param (ref $other) (ref $A)))) |
| |
| ;; CHECK: (type $5 (func (param (ref $A)) (result i32))) |
| |
| ;; CHECK: (func $init (type $3) (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| ;; CHECK-NEXT: (struct.set $other 0 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; CHECK-NEXT: (i32.const 10) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: (struct.set $B 0 |
| ;; CHECK-NEXT: (local.get $B-exact) |
| ;; CHECK-NEXT: (i32.const 20) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $init (param $other (ref $other)) (param $B-exact (ref (exact $B))) |
| (struct.set $other 0 |
| (local.get $other) |
| (i32.const 10) |
| ) |
| ;; Set exact B. |
| (struct.set $B 0 |
| (local.get $B-exact) |
| (i32.const 20) |
| ) |
| ) |
| |
| ;; CHECK: (func $copy (type $4) (param $other (ref $other)) (param $A (ref $A)) |
| ;; CHECK-NEXT: (struct.set $other 1 |
| ;; CHECK-NEXT: (local.get $other) |
| ;; 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: (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 to another field and from there to inexact A. |
| (struct.set $other 1 |
| (local.get $other) |
| (struct.get $other 0 |
| (local.get $other) |
| ) |
| ) |
| ;; Copy to A. |
| (struct.set $A 0 |
| (local.get $A) |
| (struct.get $other 1 |
| (local.get $other) |
| ) |
| ) |
| ) |
| |
| ;; CHECK: (func $get (type $5) (param $A (ref $A)) (result i32) |
| ;; CHECK-NEXT: (struct.get $A 0 |
| ;; CHECK-NEXT: (local.get $A) |
| ;; CHECK-NEXT: ) |
| ;; CHECK-NEXT: ) |
| (func $get (param $A (ref $A)) (result i32) |
| ;; We cannot optimize because the copy to inexact A could write to anything. |
| (struct.get $A 0 |
| (local.get $A) |
| ) |
| ) |
| ) |
