Google Git
Sign in
chromium / external / github.com / WebAssembly / binaryen / refs/heads/refactor-type-printing-2 / . / test / lit / passes / heap2local.wast
blob: 262561d0cbb8b94f47251f9713a558adea65bb2a [file] [log] [blame]
;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
;; (remove-unused-names allows the pass to see that blocks flow values)
;; RUN: wasm-opt %s -all --remove-unused-names --heap2local -S -o - | filecheck %s
;; RUN: wasm-opt %s -all --remove-unused-names --heap2local --nominal -S -o - | filecheck %s --check-prefix=NOMNL
(module
;; CHECK: (type $struct.A (struct (field (mut i32) (mut f64))))
;; NOMNL: (type $struct.A (struct_subtype (field (mut i32) (mut f64)) data))
(type $struct.A (struct (field (mut i32)) (field (mut f64))))
;; CHECK: (type $struct.recursive (struct (field (mut (ref null $struct.recursive)))))
;; CHECK: (type $struct.nonnullable (struct (field (ref $struct.A))))
;; CHECK: (type $struct.packed (struct (field (mut i8))))
;; NOMNL: (type $struct.recursive (struct_subtype (field (mut (ref null $struct.recursive))) data))
;; NOMNL: (type $struct.nonnullable (struct_subtype (field (ref $struct.A)) data))
;; NOMNL: (type $struct.packed (struct_subtype (field (mut i8)) data))
(type $struct.packed (struct (field (mut i8))))
;; CHECK: (type $struct.nondefaultable (struct (field (rtt $struct.A))))
;; NOMNL: (type $struct.nondefaultable (struct_subtype (field (rtt $struct.A)) data))
(type $struct.nondefaultable (struct (field (rtt $struct.A))))
(type $struct.recursive (struct (field (mut (ref null $struct.recursive)))))
(type $struct.nonnullable (struct (field (ref $struct.A))))
;; CHECK: (func $simple
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $simple (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $simple
;; Other passes can remove such a trivial case of an unused allocation, but
;; we still optimize it.
(drop
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
;; CHECK: (func $to-local
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $to-local (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $to-local
(local $ref (ref null $struct.A))
;; While set to a local, this allocation has no get/set operations. Other
;; optimizations can remove it, but so can we, turning the set into a
;; drop (and adding some unnecessary code to allocate the values, which we
;; depend on other passes to remove).
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
;; CHECK: (func $one-get
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $one-get (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $one-get
;; An allocation followed by an immediate get of a field. This is a non-
;; escaping allocation, with a use, so we can optimize it out. The
;; allocation is dropped (letting later opts remove it), and the
;; allocation's data is moved to locals: we write the initial value to the
;; locals, and we read from the locals instead of the struct.get.
(drop
(struct.get $struct.A 0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $one-get-b
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $one-get-b (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $one-get-b
;; Similar to the above, but using a different field index.
(drop
(struct.get $struct.A 1
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $one-set
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $one-set (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $one-set
;; A simple optimizable allocation only used in one set.
(struct.set $struct.A 0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
(i32.const 1)
)
)
;; CHECK: (func $packed
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (struct.get_u $struct.packed 0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.packed
;; CHECK-NEXT: (rtt.canon $struct.packed)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $packed (type $func.0)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (struct.get_u $struct.packed 0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.packed
;; NOMNL-NEXT: (rtt.canon $struct.packed)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $packed
;; We do not optimize packed structs yet.
(drop
(struct.get $struct.packed 0
(struct.new_default_with_rtt $struct.packed
(rtt.canon $struct.packed)
)
)
)
)
;; CHECK: (func $with-init-values
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 3.14159)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $with-init-values (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.const 2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 3.14159)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $with-init-values
;; When we get values to initialize the struct with, assign them to the
;; proper locals.
(drop
(struct.get $struct.A 0
(struct.new_with_rtt $struct.A
(i32.const 2)
(f64.const 3.14159)
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $ignore-unreachable
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block ;; (replaces something unreachable we can't emit)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block ;; (replaces something unreachable we can't emit)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (unreachable)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $ignore-unreachable (type $func.0)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block ;; (replaces something unreachable we can't emit)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block ;; (replaces something unreachable we can't emit)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (i32.const 2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (unreachable)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $ignore-unreachable
;; An unreachable allocation is not worth trying to process; DCE should
;; remove it.
(drop
(struct.get $struct.A 0
(struct.new_with_rtt $struct.A
(i32.const 2)
(unreachable)
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $nondefaultable
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (struct.get $struct.nondefaultable 0
;; CHECK-NEXT: (struct.new_with_rtt $struct.nondefaultable
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: (rtt.canon $struct.nondefaultable)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $nondefaultable (type $func.0)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (struct.get $struct.nondefaultable 0
;; NOMNL-NEXT: (struct.new_with_rtt $struct.nondefaultable
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: (rtt.canon $struct.nondefaultable)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $nondefaultable
;; We do not optimize structs with nondefaultable types that we cannot
;; handle, like rtts.
(drop
(struct.get $struct.nondefaultable 0
(struct.new_with_rtt $struct.nondefaultable
(rtt.canon $struct.A)
(rtt.canon $struct.nondefaultable)
)
)
)
)
;; CHECK: (func $simple-one-local-set
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $simple-one-local-set (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $simple-one-local-set
(local $ref (ref null $struct.A))
;; A simple optimizable allocation only used in one set, and also stored
;; to a local. The local.set should not prevent our optimization, and the
;; local.set can be turned into a drop.
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.set $struct.A 0
(local.get $ref)
(i32.const 1)
)
)
;; CHECK: (func $simple-one-local-get (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $simple-one-local-get (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $simple-one-local-get (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; A simple optimizable allocation only used in one get, via a local.
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $send-ref (param $0 (ref null $struct.A))
;; CHECK-NEXT: (nop)
;; CHECK-NEXT: )
;; NOMNL: (func $send-ref (type $func.5) (param $0 (ref null $struct.A))
;; NOMNL-NEXT: (nop)
;; NOMNL-NEXT: )
(func $send-ref (param (ref null $struct.A))
)
;; CHECK: (func $safe-to-drop (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $safe-to-drop (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $safe-to-drop (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; An extra drop does not let the allocation escape.
(drop
(local.get $ref)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $escape-via-call (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local.set $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (call $send-ref
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $escape-via-call (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local.set $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (call $send-ref
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $escape-via-call (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; The allocation escapes into a call.
(call $send-ref
(local.get $ref)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $safe-to-drop-multiflow (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $safe-to-drop-multiflow (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $safe-to-drop-multiflow (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; An extra drop + multiple flows through things do not stop us.
(drop
(block (result (ref null $struct.A))
(block (result (ref null $struct.A))
(loop (result (ref null $struct.A))
(local.get $ref)
)
)
)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $escape-after-multiflow (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local.set $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (call $send-ref
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $escape-after-multiflow (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local.set $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (call $send-ref
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $escape-after-multiflow (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; An escape after multiple flows.
(call $send-ref
(block (result (ref null $struct.A))
(block (result (ref null $struct.A))
(loop (result (ref null $struct.A))
(local.get $ref)
)
)
)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $non-exclusive-set (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local.set $ref
;; CHECK-NEXT: (select (result (ref $struct.A))
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $non-exclusive-set (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local.set $ref
;; NOMNL-NEXT: (select (result (ref $struct.A))
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $non-exclusive-set (result f64)
(local $ref (ref null $struct.A))
;; A set that receives two different allocations, and so we should not try
;; to optimize it.
(local.set $ref
(select
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
(i32.const 1)
)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $local-copies (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $local-copies (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $local-copies (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; Copying our allocation through locals does not bother us.
(local.set $ref
(local.get $ref)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $local-copies-2
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $ref-2 (ref null $struct.A))
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $local-copies-2 (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $ref-2 (ref null $struct.A))
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $local-copies-2
(local $ref (ref null $struct.A))
(local $ref-2 (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; Copying our allocation through locals does not bother us, even if it's
;; another local.
(local.set $ref-2
(local.get $ref)
)
(drop
(struct.get $struct.A 0
(local.get $ref)
)
)
(drop
(struct.get $struct.A 1
(local.get $ref-2)
)
)
)
;; CHECK: (func $local-copies-conditional (param $x i32) (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (if
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $local-copies-conditional (type $func.2) (param $x i32) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (if
;; NOMNL-NEXT: (local.get $x)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $local-copies-conditional (param $x i32) (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; Possibly copying our allocation through locals does not bother us. Note
;; that as a result of this the final local.get has two sets that send it
;; values, but we know they are both the same allocation.
(if (local.get $x)
(local.set $ref
(local.get $ref)
)
)
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $block-value (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (call $send-ref
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $block-value (type $func.1) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (call $send-ref
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $block-value (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; Returning our allocation from a block does not bother us.
(struct.get $struct.A 1
(block (result (ref null $struct.A))
;; This call in the block should not bother us either.
(call $send-ref
(ref.null $struct.A)
)
(local.get $ref)
)
)
)
;; CHECK: (func $non-exclusive-get (param $x i32) (result f64)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local.set $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (if
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: (local.set $ref
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $non-exclusive-get (type $func.2) (param $x i32) (result f64)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local.set $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (if
;; NOMNL-NEXT: (local.get $x)
;; NOMNL-NEXT: (local.set $ref
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $non-exclusive-get (param $x i32) (result f64)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(if (local.get $x)
(local.set $ref
(ref.null $struct.A)
)
)
;; A get that receives two different allocations, and so we should not try
;; to optimize it.
(struct.get $struct.A 1
(local.get $ref)
)
)
;; CHECK: (func $tee (result i32)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; NOMNL: (func $tee (type $func.3) (result i32)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
(func $tee (result i32)
(local $ref (ref null $struct.A))
(struct.get $struct.A 0
;; A tee flows out the value, and we can optimize this allocation.
(local.tee $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $tee-set
;; CHECK-NEXT: (local $ref (ref null $struct.recursive))
;; CHECK-NEXT: (local $1 (ref null $struct.recursive))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.recursive))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $tee-set (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.recursive))
;; NOMNL-NEXT: (local $1 (ref null $struct.recursive))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.recursive))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $tee-set
(local $ref (ref null $struct.recursive))
;; As above, but with a set, and also a recursive type.
(struct.set $struct.recursive 0
(local.tee $ref
(struct.new_default_with_rtt $struct.recursive
(rtt.canon $struct.recursive)
)
)
(ref.null $struct.recursive)
)
)
;; CHECK: (func $set-value
;; CHECK-NEXT: (local $ref (ref null $struct.recursive))
;; CHECK-NEXT: (struct.set $struct.recursive 0
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: (local.tee $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.recursive
;; CHECK-NEXT: (rtt.canon $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $set-value (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.recursive))
;; NOMNL-NEXT: (struct.set $struct.recursive 0
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: (local.tee $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.recursive
;; NOMNL-NEXT: (rtt.canon $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $set-value
(local $ref (ref null $struct.recursive))
(struct.set $struct.recursive 0
(ref.null $struct.recursive)
;; As above, but operands reversed: the allocation is now the value, not
;; the reference, and so it escapes.
(local.tee $ref
(struct.new_default_with_rtt $struct.recursive
(rtt.canon $struct.recursive)
)
)
)
)
;; CHECK: (func $initialize-with-reference
;; CHECK-NEXT: (local $0 (ref null $struct.recursive))
;; CHECK-NEXT: (local $1 (ref null $struct.recursive))
;; CHECK-NEXT: (local $2 (ref null $struct.recursive))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.recursive))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.recursive
;; CHECK-NEXT: (rtt.canon $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.recursive))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.recursive)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $initialize-with-reference (type $func.0)
;; NOMNL-NEXT: (local $0 (ref null $struct.recursive))
;; NOMNL-NEXT: (local $1 (ref null $struct.recursive))
;; NOMNL-NEXT: (local $2 (ref null $struct.recursive))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.recursive))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.recursive
;; NOMNL-NEXT: (rtt.canon $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.recursive))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.recursive)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $initialize-with-reference
(local $0 (ref null $struct.recursive))
(local.set $0
;; The outer allocation can be optimized, as it does not escape.
(struct.new_with_rtt $struct.recursive
;; The inner allocation should not prevent the outer one from being
;; optimized through some form of confusion.
;; After the outer one is optimized, the inner one can be optimized in
;; principle, as it can be seen to no longer escape. However, we depend
;; on other optimizations to actually remove the outer allocation (like
;; vacuum), and so it cannot be optimized. If we ran vaccum, and then
;; additional iterations, this might be handled.
(struct.new_default_with_rtt $struct.recursive
(rtt.canon $struct.recursive)
)
(rtt.canon $struct.recursive)
)
)
(drop
(struct.get $struct.recursive 0
(local.get $0)
)
)
)
;; CHECK: (func $escape-flow-out (result anyref)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (struct.set $struct.A 0
;; CHECK-NEXT: (local.tee $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; NOMNL: (func $escape-flow-out (type $func.4) (result anyref)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (struct.set $struct.A 0
;; NOMNL-NEXT: (local.tee $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
(func $escape-flow-out (result anyref)
(local $ref (ref null $struct.A))
(struct.set $struct.A 0
(local.tee $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(i32.const 1)
)
;; The allocation escapes out to the caller by flowing out.
(local.get $ref)
)
;; CHECK: (func $escape-return (result anyref)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (struct.set $struct.A 0
;; CHECK-NEXT: (local.tee $ref
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (local.get $ref)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $escape-return (type $func.4) (result anyref)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (struct.set $struct.A 0
;; NOMNL-NEXT: (local.tee $ref
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (local.get $ref)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $escape-return (result anyref)
(local $ref (ref null $struct.A))
(struct.set $struct.A 0
(local.tee $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(i32.const 1)
)
;; The allocation escapes out to the caller by a return.
(return
(local.get $ref)
)
)
;; CHECK: (func $non-nullable (param $a (ref $struct.A))
;; CHECK-NEXT: (local $1 (ref null $struct.A))
;; CHECK-NEXT: (local $2 (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.nonnullable))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (local.get $a)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (ref.as_non_null
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.nonnullable)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.nonnullable)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.as_non_null
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $non-nullable (type $func.6) (param $a (ref $struct.A))
;; NOMNL-NEXT: (local $1 (ref null $struct.A))
;; NOMNL-NEXT: (local $2 (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.nonnullable))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (local.get $a)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (ref.as_non_null
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.nonnullable)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.nonnullable)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.as_non_null
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $non-nullable (param $a (ref $struct.A))
(drop
;; An optimizable case where the type is non-nullable, which requires
;; special handling in locals.
(struct.get $struct.nonnullable 0
(struct.new_with_rtt $struct.nonnullable
(local.get $a)
(rtt.canon $struct.nonnullable)
)
)
)
)
;; CHECK: (func $before-loop-use-multi (param $x i32)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (local $4 i32)
;; CHECK-NEXT: (local $5 f64)
;; CHECK-NEXT: (loop $outer
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $4
;; CHECK-NEXT: (i32.const 2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $5
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (local.get $4)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (local.get $5)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (if
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 42)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (loop $inner
;; CHECK-NEXT: (block
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.add
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (br_if $inner
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (if
;; CHECK-NEXT: (local.get $x)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (br $outer)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $before-loop-use-multi (type $func.7) (param $x i32)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (local $4 i32)
;; NOMNL-NEXT: (local $5 f64)
;; NOMNL-NEXT: (loop $outer
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $4
;; NOMNL-NEXT: (i32.const 2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $5
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (local.get $4)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (local.get $5)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (if
;; NOMNL-NEXT: (local.get $x)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 42)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (loop $inner
;; NOMNL-NEXT: (block
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.add
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (br_if $inner
;; NOMNL-NEXT: (local.get $x)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (if
;; NOMNL-NEXT: (local.get $x)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (br $outer)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $before-loop-use-multi (param $x i32)
(local $ref (ref null $struct.A))
;; Allocate in a loop, and use that allocation multiple times in that loop
;; in various ways inside.
(loop $outer
(local.set $ref
(struct.new_with_rtt $struct.A
(i32.const 2)
(f64.const 2.1828)
(rtt.canon $struct.A)
)
)
(drop
(struct.get $struct.A 0
(local.get $ref)
)
)
(if (local.get $x)
(drop
(struct.get $struct.A 1
(local.get $ref)
)
)
(struct.set $struct.A 1
(local.get $ref)
(f64.const 42)
)
)
(loop $inner
(struct.set $struct.A 0
(local.get $ref)
(i32.add
(struct.get $struct.A 0
(local.get $ref)
)
(i32.const 1)
)
)
(br_if $inner
(local.get $x)
)
)
(if (local.get $x)
(drop
(struct.get $struct.A 0
(local.get $ref)
)
)
(drop
(struct.get $struct.A 1
(local.get $ref)
)
)
)
(br $outer)
)
)
;; CHECK: (func $multi-separate
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (local $4 i32)
;; CHECK-NEXT: (local $5 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $4
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $5
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $5)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $multi-separate (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (local $4 i32)
;; NOMNL-NEXT: (local $5 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $4
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $5
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $5)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $multi-separate
;; Multiple independent things we can optimize.
(drop
(struct.get $struct.A 0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
(drop
(struct.get $struct.A 0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
(drop
(struct.get $struct.A 1
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
)
;; CHECK: (func $multi-separate-same-local-index
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (local $3 i32)
;; CHECK-NEXT: (local $4 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $4
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $multi-separate-same-local-index (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (local $3 i32)
;; NOMNL-NEXT: (local $4 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $4
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $multi-separate-same-local-index
(local $ref (ref null $struct.A))
;; Multiple independent things we can optimize that use the same local
;; index, but they do not conflict in their live ranges.
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(drop
(struct.get $struct.A 0
(local.get $ref)
)
)
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(drop
(struct.get $struct.A 0
(local.get $ref)
)
)
)
;; CHECK: (func $multi-separate-different-local-index-overlapping-lifetimes
;; CHECK-NEXT: (local $ref1 (ref null $struct.A))
;; CHECK-NEXT: (local $ref2 (ref null $struct.A))
;; CHECK-NEXT: (local $2 i32)
;; CHECK-NEXT: (local $3 f64)
;; CHECK-NEXT: (local $4 i32)
;; CHECK-NEXT: (local $5 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $4
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $5
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $4)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $multi-separate-different-local-index-overlapping-lifetimes (type $func.0)
;; NOMNL-NEXT: (local $ref1 (ref null $struct.A))
;; NOMNL-NEXT: (local $ref2 (ref null $struct.A))
;; NOMNL-NEXT: (local $2 i32)
;; NOMNL-NEXT: (local $3 f64)
;; NOMNL-NEXT: (local $4 i32)
;; NOMNL-NEXT: (local $5 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $4
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $5
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $4)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $multi-separate-different-local-index-overlapping-lifetimes
(local $ref1 (ref null $struct.A))
(local $ref2 (ref null $struct.A))
;; Multiple independent things we can optimize that use different local
;; indexes, but whose lifetimes overlap. We should not be confused by that.
(local.set $ref1
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(local.set $ref2
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(drop
(struct.get $struct.A 0
(local.get $ref1)
)
)
(drop
(struct.get $struct.A 0
(local.get $ref2)
)
)
)
;; CHECK: (func $get-through-block (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $get-through-block (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $get-through-block (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
;; A branch to the block. This ensures its name is not removable. And
;; it indicates that the block does not have a single value that
;; flows out, which means we do not have exclusive use of the
;; allocation on this path, and must give up.
(br_if $block
(ref.null $struct.A)
(i32.const 0)
)
)
(local.get $0)
)
)
)
;; CHECK: (func $branch-to-block (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $branch-to-block (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $branch-to-block (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
;; A branch to the block of our allocation. However, there is also
;; a fallthrough value as well, so we must give up.
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(ref.null $struct.A)
)
)
)
;; CHECK: (func $branch-to-block-no-fallthrough (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $branch-to-block-no-fallthrough (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $branch-to-block-no-fallthrough (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
;; A branch to the block of our allocation. In this case there is no
;; other value reaching the block, and so our branch is the sole value
;; which means there is no mixing, and we can optimize this.
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(return (f64.const 2.1828))
)
)
)
;; CHECK: (func $two-branches (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $two-branches (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $two-branches (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
;; A branch to the block of our allocation.
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(drop
;; Another branch, causing mixing that prevents optimizations.
(br_if $block
(ref.null $struct.A)
(i32.const 0)
)
)
(return (f64.const 2.1828))
)
)
)
;; CHECK: (func $two-branches-b (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $two-branches-b (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $two-branches-b (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(drop
;; As in $two-branches, but the value here is our allocation, the same
;; as in the first branch above us. We do not yet optimize such merges
;; of our allocation, but we could in the future.
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(return (f64.const 2.1828))
)
)
)
;; CHECK: (func $br_if_flow (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (struct.new_default_with_rtt $struct.A
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (struct.get $struct.A 1
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (call $send-ref
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (local.get $0)
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $br_if_flow (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (struct.new_default_with_rtt $struct.A
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (struct.get $struct.A 1
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (call $send-ref
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (local.get $0)
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $br_if_flow (result f64)
(local $0 (ref null $struct.A))
(local.set $0
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
;; If it were not for the call here then we would be able to optimize
;; the allocation in this function. (The branch with the allocation is
;; ok, but the br_if also flows the value into a call, that escapes it.)
(call $send-ref
(br_if $block
(local.get $0)
(i32.const 0)
)
)
(return (f64.const 2.1828))
)
)
)
;; CHECK: (func $ref-as-non-null
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (block
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.as_non_null
;; CHECK-NEXT: (ref.null any)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $ref-as-non-null (type $func.0)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.as_non_null
;; NOMNL-NEXT: (ref.null any)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $ref-as-non-null
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
(struct.set $struct.A 0
;; We can see that the input to this RefAsNonNull is always non-null, as
;; it is our allocation, and so it does not prevent us from optimizing
;; here.
(ref.as_non_null
(local.get $ref)
)
(i32.const 1)
)
;; Another RefAsNonNull, to check we do not modify irrelevant ones.
(drop
(ref.as_non_null
(ref.null any)
)
)
)
;; CHECK: (func $ref-as-non-null-through-local (result i32)
;; CHECK-NEXT: (local $ref (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result i32)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $1)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $ref-as-non-null-through-local (type $func.3) (result i32)
;; NOMNL-NEXT: (local $ref (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result i32)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $1)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $ref-as-non-null-through-local (result i32)
(local $ref (ref null $struct.A))
(local.set $ref
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
;; Copy the allocation through a ref.as_non_null. This must not trap: it may
;; trap if we leave the ref.as_non_null there and also we do not assign
;; anything to the local (if we skip assignments to the local when we
;; optimize). To avoid that, we should remove the ref.as_non_null, which is
;; safe since we know our allocation is passed into it, which is not null,
;; and will not trap.
(local.set $ref
(ref.as_non_null
(local.get $ref)
)
)
(struct.get $struct.A 0
(local.get $ref)
)
)
;; CHECK: (func $br_if-allocation (result f64)
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (local $3 i32)
;; CHECK-NEXT: (local $4 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block $block (result (ref null $struct.A))
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (br_if $block
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $3
;; CHECK-NEXT: (i32.const 42)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $4
;; CHECK-NEXT: (f64.const 13.37)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (local.get $3)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (local.get $4)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (return
;; CHECK-NEXT: (f64.const 2.1828)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.get $2)
;; CHECK-NEXT: )
;; NOMNL: (func $br_if-allocation (type $func.1) (result f64)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (local $3 i32)
;; NOMNL-NEXT: (local $4 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block $block (result (ref null $struct.A))
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (br_if $block
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $3
;; NOMNL-NEXT: (i32.const 42)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $4
;; NOMNL-NEXT: (f64.const 13.37)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (local.get $3)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (local.get $4)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (return
;; NOMNL-NEXT: (f64.const 2.1828)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.get $2)
;; NOMNL-NEXT: )
(func $br_if-allocation (result f64)
(local $0 (ref null $struct.A))
(struct.get $struct.A 1
(block $block (result (ref null $struct.A))
(drop
;; Our allocation flows into a br_if, which therefore has non-nullable
;; type, which we must update after optimizing.
(br_if $block
(struct.new_with_rtt $struct.A
(i32.const 42)
(f64.const 13.37)
(rtt.canon $struct.A)
)
(i32.const 0)
)
)
(return (f64.const 2.1828))
)
)
)
;; CHECK: (func $simple-no-rtt
;; CHECK-NEXT: (local $0 i32)
;; CHECK-NEXT: (local $1 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $0
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $simple-no-rtt (type $func.0)
;; NOMNL-NEXT: (local $0 i32)
;; NOMNL-NEXT: (local $1 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $0
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $simple-no-rtt
(drop
;; This allocation has no rtt, so we have nothing to drop from it when
;; we optimize.
(struct.new_default $struct.A)
)
)
;; CHECK: (func $pass-through-loop
;; CHECK-NEXT: (local $0 (ref null $struct.A))
;; CHECK-NEXT: (local $1 i32)
;; CHECK-NEXT: (local $2 f64)
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (loop $loop (result (ref null $struct.A))
;; CHECK-NEXT: (br_if $loop
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (block (result (ref null $struct.A))
;; CHECK-NEXT: (local.set $1
;; CHECK-NEXT: (i32.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (local.set $2
;; CHECK-NEXT: (f64.const 0)
;; CHECK-NEXT: )
;; CHECK-NEXT: (drop
;; CHECK-NEXT: (rtt.canon $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: (ref.null $struct.A)
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; CHECK-NEXT: )
;; NOMNL: (func $pass-through-loop (type $func.0)
;; NOMNL-NEXT: (local $0 (ref null $struct.A))
;; NOMNL-NEXT: (local $1 i32)
;; NOMNL-NEXT: (local $2 f64)
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (loop $loop (result (ref null $struct.A))
;; NOMNL-NEXT: (br_if $loop
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (block (result (ref null $struct.A))
;; NOMNL-NEXT: (local.set $1
;; NOMNL-NEXT: (i32.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (local.set $2
;; NOMNL-NEXT: (f64.const 0)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (drop
;; NOMNL-NEXT: (rtt.canon $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: (ref.null $struct.A)
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
;; NOMNL-NEXT: )
(func $pass-through-loop
(local $0 (ref null $struct.A))
;; The allocation pass through a loop, which should change type to be
;; nullable.
(drop
(loop $loop (result (ref $struct.A))
;; Include a branch to the loop, so that the testcase does not become
;; trivial (remove-unused-names will turn a loop with no name into a
;; block).
(br_if $loop (i32.const 0))
;; The allocation that will be turned into locals.
(struct.new_default_with_rtt $struct.A
(rtt.canon $struct.A)
)
)
)
)
)