test/lit/passes/monomorphize-drop.wast

;; NOTE: Assertions have been generated by update_lit_checks.py --all-items and should not be edited.

;; As in monomorphize-types.wast, test in both "always" mode, which always
;; monomorphizes, and in "careful" mode which does it only when it appears to
;; actually help, and use a minimum benefit of 0 to make it easy to write
;; small testcases.

;; RUN: foreach %s %t wasm-opt --monomorphize-always                                -all -S -o - | filecheck %s --check-prefix ALWAYS
;; RUN: foreach %s %t wasm-opt --monomorphize --pass-arg=monomorphize-min-benefit@0 -all -S -o - | filecheck %s --check-prefix CAREFUL

(module
  ;; Test that dropped functions are monomorphized, and the drop is reverse-
  ;; inlined into the called function, enabling more optimizations.

  ;; ALWAYS:      (type $0 (func (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32)))

  ;; ALWAYS:      (type $2 (func (param i32 i32) (result i32)))

  ;; ALWAYS:      (type $3 (func (param i32) (result i32)))

  ;; ALWAYS:      (type $4 (func))

  ;; ALWAYS:      (type $5 (func (param i32 i32)))

  ;; ALWAYS:      (func $work (type $2) (param $x i32) (param $y i32) (result i32)
  ;; ALWAYS-NEXT:  (i32.mul
  ;; ALWAYS-NEXT:   (i32.xor
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.get $y)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.div_s
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.get $y)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (type $0 (func (result i32)))

  ;; CAREFUL:      (type $1 (func (param i32)))

  ;; CAREFUL:      (type $2 (func (param i32 i32) (result i32)))

  ;; CAREFUL:      (type $3 (func (param i32) (result i32)))

  ;; CAREFUL:      (type $4 (func))

  ;; CAREFUL:      (type $5 (func (param i32 i32)))

  ;; CAREFUL:      (func $work (type $2) (param $0 i32) (param $1 i32) (result i32)
  ;; CAREFUL-NEXT:  (i32.mul
  ;; CAREFUL-NEXT:   (i32.div_s
  ;; CAREFUL-NEXT:    (local.get $0)
  ;; CAREFUL-NEXT:    (local.get $1)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.xor
  ;; CAREFUL-NEXT:    (local.get $0)
  ;; CAREFUL-NEXT:    (local.get $1)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $work (param $x i32) (param $y i32) (result i32)
    ;; Do some nontrivial work that we return. If this is dropped then we don't
    ;; need that work.
    (i32.mul
      (i32.xor
        (local.get $x)
        (local.get $y)
      )
      (i32.div_s
        (local.get $x)
        (local.get $y)
      )
    )
  )

  ;; ALWAYS:      (func $calls (type $1) (param $x i32)
  ;; ALWAYS-NEXT:  (call $work_5)
  ;; ALWAYS-NEXT:  (call $work_5)
  ;; ALWAYS-NEXT:  (call $work_6
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (call $work_7
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $calls (type $1) (param $x i32)
  ;; CAREFUL-NEXT:  (call $work_5)
  ;; CAREFUL-NEXT:  (call $work_5)
  ;; CAREFUL-NEXT:  (call $work_6
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (call $work_7
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $calls (param $x i32)
    ;; Both of these can call the same monomorphized function. In CAREFUL mode
    ;; that function's body can also be optimized into a nop.
    (drop
      (call $work
        (i32.const 3)
        (i32.const 4)
      )
    )
    (drop
      (call $work
        (i32.const 3)
        (i32.const 4)
      )
    )
    ;; Another call, now with an unknown parameter. This calls a different
    ;; monomorphized function, but once again the body can be optimized into a
    ;; nop in CAREFUL.
    (drop
      (call $work
        (i32.const 3)
        (local.get $x)
      )
    )
    ;; Two unknown parameters. Yet another monomorphized function, but the same
    ;; outcome.
    (drop
      (call $work
        (local.get $x)
        (local.get $x)
      )
    )
  )

  ;; ALWAYS:      (func $call-undropped-trivial (type $3) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (call $work
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-undropped-trivial (type $3) (param $x i32) (result i32)
  ;; CAREFUL-NEXT:  (call $work
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-undropped-trivial (param $x i32) (result i32)
    ;; A call of the same target that is dropped in the previous function, but
    ;; now without a drop. We know nothing nontrivial here, so we do nothing.
    (call $work
      (local.get $x)
      (local.get $x)
    )
  )

  ;; ALWAYS:      (func $call-undropped (type $0) (result i32)
  ;; ALWAYS-NEXT:  (call $work_8)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-undropped (type $0) (result i32)
  ;; CAREFUL-NEXT:  (call $work_8)
  ;; CAREFUL-NEXT: )
  (func $call-undropped (result i32)
    ;; As above but now with constant params. We can monomorphize here - there
    ;; is no issue in optimizing here without a drop and with a drop elsewhere -
    ;; but we do call a different function of course, that returns an i32.
    (call $work
      (i32.const 3)
      (i32.const 4)
    )
  )

  ;; ALWAYS:      (func $call-no-params-return (type $0) (result i32)
  ;; ALWAYS-NEXT:  (return_call $work
  ;; ALWAYS-NEXT:   (i32.const 10)
  ;; ALWAYS-NEXT:   (i32.const 20)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-no-params-return (type $0) (result i32)
  ;; CAREFUL-NEXT:  (return_call $work
  ;; CAREFUL-NEXT:   (i32.const 10)
  ;; CAREFUL-NEXT:   (i32.const 20)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-no-params-return (result i32)
    ;; Return calls can be monomorphized too, but we have that as a TODO atm.
    (return_call $work
      (i32.const 10)
      (i32.const 20)
    )
  )
)

;; ALWAYS:      (func $work_5 (type $4)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local $y i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (i32.const 3)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $y
;; ALWAYS-NEXT:     (i32.const 4)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (i32.mul
;; ALWAYS-NEXT:     (i32.xor
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.div_s
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $work_6 (type $1) (param $0 i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local $y i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (i32.const 3)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $y
;; ALWAYS-NEXT:     (local.get $0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (i32.mul
;; ALWAYS-NEXT:     (i32.xor
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.div_s
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $work_7 (type $5) (param $0 i32) (param $1 i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local $y i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (local.get $0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $y
;; ALWAYS-NEXT:     (local.get $1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (i32.mul
;; ALWAYS-NEXT:     (i32.xor
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.div_s
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $work_8 (type $0) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local $y i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 3)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (local.set $y
;; ALWAYS-NEXT:   (i32.const 4)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (i32.mul
;; ALWAYS-NEXT:   (i32.xor
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (local.get $y)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.div_s
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (local.get $y)
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $work_5 (type $4)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $work_6 (type $1) (param $0 i32)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (i32.div_s
;; CAREFUL-NEXT:    (i32.const 3)
;; CAREFUL-NEXT:    (local.get $0)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $work_7 (type $5) (param $0 i32) (param $1 i32)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (i32.div_s
;; CAREFUL-NEXT:    (local.get $0)
;; CAREFUL-NEXT:    (local.get $1)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $work_8 (type $0) (result i32)
;; CAREFUL-NEXT:  (i32.const 0)
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func))

  ;; ALWAYS:      (type $1 (func (param i32 i32) (result i32)))

  ;; ALWAYS:      (type $2 (func (result i32)))

  ;; ALWAYS:      (import "a" "b" (func $import (type $1) (param i32 i32) (result i32)))
  ;; CAREFUL:      (type $0 (func))

  ;; CAREFUL:      (type $1 (func (param i32 i32) (result i32)))

  ;; CAREFUL:      (type $2 (func (result i32)))

  ;; CAREFUL:      (import "a" "b" (func $import (type $1) (param i32 i32) (result i32)))
  (import "a" "b" (func $import (param i32 i32) (result i32)))

  ;; ALWAYS:      (func $no-params (type $2) (result i32)
  ;; ALWAYS-NEXT:  (i32.const 42)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $no-params (type $2) (result i32)
  ;; CAREFUL-NEXT:  (i32.const 42)
  ;; CAREFUL-NEXT: )
  (func $no-params (result i32)
    ;; A function that will be dropped, and has no params.
    (i32.const 42)
  )

  ;; ALWAYS:      (func $call-no-params (type $2) (result i32)
  ;; ALWAYS-NEXT:  (call $no-params_6)
  ;; ALWAYS-NEXT:  (call $no-params)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-no-params (type $2) (result i32)
  ;; CAREFUL-NEXT:  (call $no-params_6)
  ;; CAREFUL-NEXT:  (call $no-params)
  ;; CAREFUL-NEXT: )
  (func $call-no-params (result i32)
    ;; We can optimize the drop into the target.
    (drop
      (call $no-params)
    )
    ;; Without a drop, the call context is trivial and we do nothing.
    (call $no-params)
  )

  ;; ALWAYS:      (func $call-import (type $0)
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $import
  ;; ALWAYS-NEXT:    (i32.const 3)
  ;; ALWAYS-NEXT:    (i32.const 4)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-import (type $0)
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $import
  ;; CAREFUL-NEXT:    (i32.const 3)
  ;; CAREFUL-NEXT:    (i32.const 4)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-import
    ;; Calling an import allows no optimizations.
    (drop
      (call $import
        (i32.const 3)
        (i32.const 4)
      )
    )
  )

  ;; ALWAYS:      (func $import-work (type $1) (param $x i32) (param $y i32) (result i32)
  ;; ALWAYS-NEXT:  (call $import
  ;; ALWAYS-NEXT:   (i32.xor
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.get $y)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:   (i32.div_s
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:    (local.get $y)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $import-work (type $1) (param $0 i32) (param $1 i32) (result i32)
  ;; CAREFUL-NEXT:  (call $import
  ;; CAREFUL-NEXT:   (i32.xor
  ;; CAREFUL-NEXT:    (local.get $0)
  ;; CAREFUL-NEXT:    (local.get $1)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:   (i32.div_s
  ;; CAREFUL-NEXT:    (local.get $0)
  ;; CAREFUL-NEXT:    (local.get $1)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $import-work (param $x i32) (param $y i32) (result i32)
    ;; Do some work and also call an import.
    (call $import
      (i32.xor
        (local.get $x)
        (local.get $y)
      )
      (i32.div_s
        (local.get $x)
        (local.get $y)
      )
    )
  )

  ;; ALWAYS:      (func $call-import-work (type $0)
  ;; ALWAYS-NEXT:  (call $import-work_7)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-import-work (type $0)
  ;; CAREFUL-NEXT:  (call $import-work_7)
  ;; CAREFUL-NEXT: )
  (func $call-import-work
    ;; This is monomorphized with the drop.
    (drop
      (call $import-work
        (i32.const 3)
        (i32.const 4)
      )
    )
  )
)

;; ALWAYS:      (func $no-params_6 (type $0)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (i32.const 42)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $import-work_7 (type $0)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local $y i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (i32.const 3)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (local.set $y
;; ALWAYS-NEXT:     (i32.const 4)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (call $import
;; ALWAYS-NEXT:     (i32.xor
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.div_s
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (local.get $y)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $no-params_6 (type $0)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $import-work_7 (type $0)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (call $import
;; CAREFUL-NEXT:    (i32.const 7)
;; CAREFUL-NEXT:    (i32.const 0)
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func (param i32)))

  ;; ALWAYS:      (type $1 (func))

  ;; ALWAYS:      (type $2 (func (result i32)))

  ;; ALWAYS:      (type $3 (func (param i32) (result i32)))

  ;; ALWAYS:      (import "a" "c" (func $import (type $2) (result i32)))
  ;; CAREFUL:      (type $0 (func (param i32)))

  ;; CAREFUL:      (type $1 (func))

  ;; CAREFUL:      (type $2 (func (result i32)))

  ;; CAREFUL:      (type $3 (func (param i32) (result i32)))

  ;; CAREFUL:      (import "a" "c" (func $import (type $2) (result i32)))
  (import "a" "c" (func $import (result i32)))

  ;; ALWAYS:      (func $return-normal (type $3) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (drop
  ;; ALWAYS-NEXT:     (call $import)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:    (return
  ;; ALWAYS-NEXT:     (i32.const 0)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (i32.const 1)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $return-normal (type $3) (param $0 i32) (result i32)
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (drop
  ;; CAREFUL-NEXT:     (call $import)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:    (return
  ;; CAREFUL-NEXT:     (i32.const 0)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (i32.const 1)
  ;; CAREFUL-NEXT: )
  (func $return-normal (param $x i32) (result i32)
    ;; This function has a return, which needs to be handled in the
    ;; monomorphized function, as we'll no longer return a value.
    (if
      (local.get $x)
      (then
        (drop
          (call $import)
        )
        (return
          (i32.const 0)
        )
      )
    )
    ;; Also return a value by flowing it out.
    (i32.const 1)
  )

  ;; ALWAYS:      (func $call-return-normal (type $0) (param $x i32)
  ;; ALWAYS-NEXT:  (call $return-normal_3)
  ;; ALWAYS-NEXT:  (call $return-normal_4)
  ;; ALWAYS-NEXT:  (call $return-normal_5
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-return-normal (type $0) (param $x i32)
  ;; CAREFUL-NEXT:  (call $return-normal_3)
  ;; CAREFUL-NEXT:  (call $return-normal_4)
  ;; CAREFUL-NEXT:  (call $return-normal_5
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-return-normal (param $x i32)
    ;; Call the above function with 0, 1, and an unknown value, to test the two
    ;; code paths there + the case of the input being unknown. We monomorphize
    ;; them all (differently).
    (drop
      (call $return-normal
        (i32.const 0)
      )
    )
    (drop
      (call $return-normal
        (i32.const 1)
      )
    )
    (drop
      (call $return-normal
        (local.get $x)
      )
    )
  )
)

;; ALWAYS:      (func $return-normal_3 (type $1)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (i32.const 0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (block (result i32)
;; ALWAYS-NEXT:     (if
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (then
;; ALWAYS-NEXT:       (drop
;; ALWAYS-NEXT:        (call $import)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:       (block
;; ALWAYS-NEXT:        (drop
;; ALWAYS-NEXT:         (i32.const 0)
;; ALWAYS-NEXT:        )
;; ALWAYS-NEXT:        (return)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.const 1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $return-normal_4 (type $1)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (i32.const 1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (block (result i32)
;; ALWAYS-NEXT:     (if
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (then
;; ALWAYS-NEXT:       (drop
;; ALWAYS-NEXT:        (call $import)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:       (block
;; ALWAYS-NEXT:        (drop
;; ALWAYS-NEXT:         (i32.const 0)
;; ALWAYS-NEXT:        )
;; ALWAYS-NEXT:        (return)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.const 1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $return-normal_5 (type $0) (param $0 i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (drop
;; ALWAYS-NEXT:   (block (result i32)
;; ALWAYS-NEXT:    (local.set $x
;; ALWAYS-NEXT:     (local.get $0)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:    (block (result i32)
;; ALWAYS-NEXT:     (if
;; ALWAYS-NEXT:      (local.get $x)
;; ALWAYS-NEXT:      (then
;; ALWAYS-NEXT:       (drop
;; ALWAYS-NEXT:        (call $import)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:       (block
;; ALWAYS-NEXT:        (drop
;; ALWAYS-NEXT:         (i32.const 0)
;; ALWAYS-NEXT:        )
;; ALWAYS-NEXT:        (return)
;; ALWAYS-NEXT:       )
;; ALWAYS-NEXT:      )
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:     (i32.const 1)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $return-normal_3 (type $1)
;; CAREFUL-NEXT:  (nop)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $return-normal_4 (type $1)
;; CAREFUL-NEXT:  (drop
;; CAREFUL-NEXT:   (call $import)
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $return-normal_5 (type $0) (param $0 i32)
;; CAREFUL-NEXT:  (if
;; CAREFUL-NEXT:   (local.get $0)
;; CAREFUL-NEXT:   (then
;; CAREFUL-NEXT:    (drop
;; CAREFUL-NEXT:     (call $import)
;; CAREFUL-NEXT:    )
;; CAREFUL-NEXT:   )
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $0 (func (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))

  ;; ALWAYS:      (type $2 (func (param i32)))

  ;; ALWAYS:      (import "a" "c" (func $import (type $0) (result i32)))
  ;; CAREFUL:      (type $0 (func (result i32)))

  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))

  ;; CAREFUL:      (type $2 (func (param i32)))

  ;; CAREFUL:      (import "a" "c" (func $import (type $0) (result i32)))
  (import "a" "c" (func $import (result i32)))

  ;; ALWAYS:      (func $return-call (type $1) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call $import)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (i32.const 1)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $return-call (type $1) (param $0 i32) (result i32)
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call $import)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (i32.const 1)
  ;; CAREFUL-NEXT: )
  (func $return-call (param $x i32) (result i32)
    ;; As above, but now with a return_call. We do not monomorphize the drop
    ;; part, as if we included the drop we'd turn the call into a non-return
    ;; call, which can break things.
    (if
      (local.get $x)
      (then
        (return_call $import)
      )
    )
    (i32.const 1)
  )

  ;; ALWAYS:      (func $call-return-call (type $2) (param $x i32)
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call_3)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call_4)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-return-call (type $2) (param $x i32)
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call_3)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call_4)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-return-call (param $x i32)
    ;; As above, but due to the return call we won't monomorphize the drop. As
    ;; a result we monomorphize the first two, leaving drops here, and do
    ;; nothing for the last (as the call context is trivial).
    (drop
      (call $return-call
        (i32.const 0)
      )
    )
    (drop
      (call $return-call
        (i32.const 1)
      )
    )
    (drop
      (call $return-call
        (local.get $x)
      )
    )
  )
)

;; ALWAYS:      (func $return-call_3 (type $0) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call $import)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $return-call_4 (type $0) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call $import)
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $return-call_3 (type $0) (result i32)
;; CAREFUL-NEXT:  (i32.const 1)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $return-call_4 (type $0) (result i32)
;; CAREFUL-NEXT:  (return_call $import)
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $i (func (result i32)))
  ;; CAREFUL:      (type $i (func (result i32)))
  (type $i (func (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))

  ;; ALWAYS:      (type $2 (func (param i32)))

  ;; ALWAYS:      (import "a" "c" (func $import (type $i) (result i32)))
  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))

  ;; CAREFUL:      (type $2 (func (param i32)))

  ;; CAREFUL:      (import "a" "c" (func $import (type $i) (result i32)))
  (import "a" "c" (func $import (result i32)))

  ;; ALWAYS:      (table $table 10 10 funcref)
  ;; CAREFUL:      (table $table 10 10 funcref)
  (table $table 10 10 funcref)

  ;; ALWAYS:      (func $return-call-indirect (type $1) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call_indirect $table (type $i)
  ;; ALWAYS-NEXT:     (call $import)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (i32.const 1)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $return-call-indirect (type $1) (param $0 i32) (result i32)
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call_indirect $table (type $i)
  ;; CAREFUL-NEXT:     (call $import)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (i32.const 1)
  ;; CAREFUL-NEXT: )
  (func $return-call-indirect (param $x i32) (result i32)
    ;; As above, but now with a return_call_indirect. The outcome below is
    ;; similar.
    (if
      (local.get $x)
      (then
        (return_call_indirect (type $i)
          (call $import)
        )
      )
    )
    (i32.const 1)
  )

  ;; ALWAYS:      (func $call-return-call-indirect (type $2) (param $x i32)
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-indirect_3)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-indirect_4)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-indirect
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-return-call-indirect (type $2) (param $x i32)
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-indirect_3)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-indirect_4)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-indirect
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT: )
  (func $call-return-call-indirect (param $x i32)
    (drop
      (call $return-call-indirect
        (i32.const 0)
      )
    )
    (drop
      (call $return-call-indirect
        (i32.const 1)
      )
    )
    (drop
      (call $return-call-indirect
        (local.get $x)
      )
    )
  )
)

;; ALWAYS:      (func $return-call-indirect_3 (type $i) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call_indirect $table (type $i)
;; ALWAYS-NEXT:      (call $import)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $return-call-indirect_4 (type $i) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call_indirect $table (type $i)
;; ALWAYS-NEXT:      (call $import)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $return-call-indirect_3 (type $i) (result i32)
;; CAREFUL-NEXT:  (i32.const 1)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $return-call-indirect_4 (type $i) (result i32)
;; CAREFUL-NEXT:  (return_call_indirect $table (type $i)
;; CAREFUL-NEXT:   (call $import)
;; CAREFUL-NEXT:  )
;; CAREFUL-NEXT: )
(module
  ;; ALWAYS:      (type $i (func (result i32)))
  ;; CAREFUL:      (type $i (func (result i32)))
  (type $i (func (result i32)))

  ;; ALWAYS:      (type $1 (func (param i32) (result i32)))

  ;; ALWAYS:      (import "a" "c" (func $import (type $i) (result i32)))
  ;; CAREFUL:      (type $1 (func (param i32) (result i32)))

  ;; CAREFUL:      (import "a" "c" (func $import (type $i) (result i32)))
  (import "a" "c" (func $import (result i32)))

  ;; ALWAYS:      (table $table 10 10 funcref)
  ;; CAREFUL:      (table $table 10 10 funcref)
  (table $table 10 10 funcref)

  ;; ALWAYS:      (elem declare func $import)

  ;; ALWAYS:      (func $return-call-ref (type $1) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call_ref $i
  ;; ALWAYS-NEXT:     (ref.func $import)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (i32.const 1)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (elem declare func $import)

  ;; CAREFUL:      (func $return-call-ref (type $1) (param $0 i32) (result i32)
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $0)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call $import)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (i32.const 1)
  ;; CAREFUL-NEXT: )
  (func $return-call-ref (param $x i32) (result i32)
    ;; As above, but now with a return_call_ref. The outcome below is similar.
    (if
      (local.get $x)
      (then
        (return_call_ref $i
          (ref.func $import)
        )
      )
    )
    (i32.const 1)
  )

  ;; ALWAYS:      (func $call-return-call-ref (type $1) (param $x i32) (result i32)
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-ref_3)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-ref_4)
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (drop
  ;; ALWAYS-NEXT:   (call $return-call-ref
  ;; ALWAYS-NEXT:    (local.get $x)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call $import)
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call_indirect $table (type $i)
  ;; ALWAYS-NEXT:     (i32.const 7)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (if
  ;; ALWAYS-NEXT:   (local.get $x)
  ;; ALWAYS-NEXT:   (then
  ;; ALWAYS-NEXT:    (return_call_ref $i
  ;; ALWAYS-NEXT:     (ref.func $import)
  ;; ALWAYS-NEXT:    )
  ;; ALWAYS-NEXT:   )
  ;; ALWAYS-NEXT:  )
  ;; ALWAYS-NEXT:  (unreachable)
  ;; ALWAYS-NEXT: )
  ;; CAREFUL:      (func $call-return-call-ref (type $1) (param $x i32) (result i32)
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-ref_3)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-ref_4)
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (drop
  ;; CAREFUL-NEXT:   (call $return-call-ref
  ;; CAREFUL-NEXT:    (local.get $x)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call $import)
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call_indirect $table (type $i)
  ;; CAREFUL-NEXT:     (i32.const 7)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (if
  ;; CAREFUL-NEXT:   (local.get $x)
  ;; CAREFUL-NEXT:   (then
  ;; CAREFUL-NEXT:    (return_call_ref $i
  ;; CAREFUL-NEXT:     (ref.func $import)
  ;; CAREFUL-NEXT:    )
  ;; CAREFUL-NEXT:   )
  ;; CAREFUL-NEXT:  )
  ;; CAREFUL-NEXT:  (unreachable)
  ;; CAREFUL-NEXT: )
  (func $call-return-call-ref (param $x i32) (result i32)
    ;; As before, a set of three calls (with similar outcomes as before: the
    ;; first two are monomorphized without the drop; the last is unchanged).
    (drop
      (call $return-call-ref
        (i32.const 0)
      )
    )
    (drop
      (call $return-call-ref
        (i32.const 1)
      )
    )
    (drop
      (call $return-call-ref
        (local.get $x)
      )
    )

    ;; Also add some return calls here, to show that it is fine for the caller
    ;; to have them: we can still monomorphize some of the previous calls
    ;; (without their drops).
    (if
      (local.get $x)
      (then
        (return_call $import)
      )
    )
    (if
      (local.get $x)
      (then
        (return_call_indirect (type $i)
          (i32.const 7)
        )
      )
    )
    (if
      (local.get $x)
      (then
        (return_call_ref $i
          (ref.func $import)
        )
      )
    )
    (unreachable)
  )
)

;; ALWAYS:      (func $return-call-ref_3 (type $i) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 0)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call_ref $i
;; ALWAYS-NEXT:      (ref.func $import)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; ALWAYS:      (func $return-call-ref_4 (type $i) (result i32)
;; ALWAYS-NEXT:  (local $x i32)
;; ALWAYS-NEXT:  (local.set $x
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT:  (block (result i32)
;; ALWAYS-NEXT:   (if
;; ALWAYS-NEXT:    (local.get $x)
;; ALWAYS-NEXT:    (then
;; ALWAYS-NEXT:     (return_call_ref $i
;; ALWAYS-NEXT:      (ref.func $import)
;; ALWAYS-NEXT:     )
;; ALWAYS-NEXT:    )
;; ALWAYS-NEXT:   )
;; ALWAYS-NEXT:   (i32.const 1)
;; ALWAYS-NEXT:  )
;; ALWAYS-NEXT: )

;; CAREFUL:      (func $return-call-ref_3 (type $i) (result i32)
;; CAREFUL-NEXT:  (i32.const 1)
;; CAREFUL-NEXT: )

;; CAREFUL:      (func $return-call-ref_4 (type $i) (result i32)
;; CAREFUL-NEXT:  (return_call $import)
;; CAREFUL-NEXT: )