// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -inline -function-signature-opts %s | %FileCheck %s
// RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all -inline -function-signature-opts %s | %FileCheck -check-prefix=CHECK-NEGATIVE %s

import Builtin
import Swift

/////////////////////
// Data Structures //
/////////////////////

class foo {
  var a: Int
   deinit
  init()
}

class bar {
  var start: foo
  var end: foo
   deinit
  init()
}

struct baz {
  var start: foo
  var end: foo
  init()
}

struct boo {
  var tbaz = baz()
  var a = 0
  init()
}

struct lotsoffield {
  var tbaz = baz()
  var a = 0
  var b = 0
  var c = 0
  var d = 0
  init()
}

struct goo {
  var left : foo
  var right : foo
  var top : foo
  var bottom : foo
}

public protocol P {
  func foo() -> Int64
}

public protocol KlassFoo : class {
  func bar() -> Int64
}

public class KlassBar : KlassFoo {
  public func bar() -> Int64
  deinit
  init()
}

sil @use_Int : $@convention(thin) (Int) -> ()
sil @use_Int64 : $@convention(thin) (Int64) -> ()
sil @use_Generic : $@convention(thin) <T>(@in_guaranteed T) -> ()


// CHECK-LABEL: sil [thunk] [always_inline] @argument_with_incomplete_epilogue_release
// CHECK: [[IN2:%.*]] = struct_extract [[IN1:%.*]] : $goo, #goo.top
// CHECK: function_ref @_T041argument_with_incomplete_epilogue_releaseTf4x_nTf4gn_n : $@convention(thin) (@guaranteed foo, @owned foo) -> ()
// CHECK: release_value [[IN2]]
sil @argument_with_incomplete_epilogue_release : $@convention(thin) (@owned goo) -> () {
bb0(%0 : $goo):
  // make inline costs = 2
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32


  %1 = struct_extract %0 : $goo, #goo.top
  %2 = ref_element_addr %1 : $foo, #foo.a
  %3 = load %2 : $*Int
  %4 = function_ref @use_Int : $@convention(thin) (Int) -> ()
  apply %4(%3) : $@convention(thin) (Int) -> ()

  %5 = struct_extract %0 : $goo, #goo.bottom
  %6 = ref_element_addr %5 : $foo, #foo.a
  %7 = load %6 : $*Int
  apply %4(%7) : $@convention(thin) (Int) -> ()

  release_value %1 : $foo
  %8 = tuple ()
  return %8 : $()
}

// We do this check separately to ensure that this does not occur anywhere in
// the output for the file. (Maybe this is an interesting enough feature to add to FileCheck?).

// CHECK-NEGATIVE-NOT: sil [serialized] @_TTSfq4d_n__dead_arg_no_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK-NEGATIVE-NOT: sil [serialized] @_TTSfq4g__owned_to_guaranteed_multibb_callee_with_release_not_in_exit : $@convention(thin) (@owned Builtin.NativeObject) -> () {

sil [serialized] @user : $@convention(thin) (Builtin.NativeObject) -> ()
sil [serialized] @create_object : $@convention(thin) () -> Builtin.NativeObject

// Make sure argument is exploded and the baz part is not passed in as argument, as its only use
// is a release.
//
// CHECK-LABEL: sil [thunk] [always_inline] @dead_argument_due_to_only_release_user
// CHECK: [[IN:%.*]] = function_ref @_T038dead_argument_due_to_only_release_userTf4gX_n
// CHECK: [[IN2:%.*]] = struct_extract [[IN1:%.*]] : $boo, #boo.a
// CHECK: apply [[IN]]([[IN2]])
sil @dead_argument_due_to_only_release_user : $@convention(thin) (@owned boo) -> (Int, Int) {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = struct_extract %0 : $boo, #boo.tbaz
  %2 = struct_extract %0 : $boo, #boo.a
  release_value  %1 : $baz
  %4 = tuple (%2  : $Int, %2 : $Int)
  return %4 : $(Int, Int)
}

// Make sure argument is exploded and the baz part is not passed in as argument, as its only use
// is a release.
// CHECK-LABEL: sil [thunk] [always_inline] @dead_argument_due_to_only_release_user_but__exploded
// CHECK: [[FN1:%.*]] = function_ref @_T052dead_argument_due_to_only_release_user_but__explodedTf4gX_n
// CHECK: [[IN1:%.*]] = struct_extract %0 : $lotsoffield, #lotsoffield.c
// CHECK: [[IN2:%.*]] = struct_extract %0 : $lotsoffield, #lotsoffield.b
// CHECK: [[IN3:%.*]] = struct_extract %0 : $lotsoffield, #lotsoffield.a
// CHECK: apply [[FN1]]([[IN3]], [[IN2]], [[IN1]])
sil @dead_argument_due_to_only_release_user_but__exploded : $@convention(thin) (@owned lotsoffield) -> (Int, Int, Int) {
bb0(%0 : $lotsoffield):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = struct_extract %0 : $lotsoffield, #lotsoffield.tbaz
  %2 = struct_extract %0 : $lotsoffield, #lotsoffield.a
  %3 = struct_extract %0 : $lotsoffield, #lotsoffield.b
  %4 = struct_extract %0 : $lotsoffield, #lotsoffield.c
  release_value  %1 : $baz
  %5 = tuple (%2  : $Int, %3 : $Int, %4 : $Int)
  return %5 : $(Int, Int, Int)
}

// Make sure argument is exploded and the baz part is not passed in as argument, as its only use
// is a release.
// CHECK-LABEL: sil [thunk] [always_inline] @dead_argument_due_to_more_than_release_user
// CHECK: [[FN1:%.*]] = function_ref @_T043dead_argument_due_to_more_than_release_userTf4gX_n : $@convention(thin) (@guaranteed baz, Int) -> (Int, Int)
sil @dead_argument_due_to_more_than_release_user : $@convention(thin) (@owned boo) -> (Int, Int) {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = struct_extract %0 : $boo, #boo.tbaz
  %2 = struct_extract %0 : $boo, #boo.a
  retain_value %1 : $baz
  release_value %1 : $baz
  %4 = tuple (%2  : $Int, %2 : $Int)
  return %4 : $(Int, Int)
}


// CHECK-LABEL: sil [serialized] @dead_arg_no_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK-NOT: function_ref @_TTSf4d_n__dead_arg_no_callsites
sil [serialized] @dead_arg_no_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  %3 = apply %2(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  %4 = tuple()
  return %4 : $()
}

// Make sure %0 is a dead argument.
//
// CHECK-LABEL: sil [thunk] [always_inline] @exploded_release_to_dead_argument
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $boo):
// CHECK: [[IN1:%.*]] = function_ref @_T033exploded_release_to_dead_argumentTf4d_n
// CHECK: apply [[IN1]]()
// CHECK: release_value [[INPUT_ARG0]]
sil @exploded_release_to_dead_argument : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = struct_extract %0 : $boo, #boo.tbaz
  %2 = struct_extract %1 : $baz, #baz.start
  %3 = struct_extract %1 : $baz, #baz.end
  release_value  %2 : $foo
  release_value  %3 : $foo
  %4 = tuple ()
  return %4 : $()
}


// Make sure %0 is not a dead argument, but gets converted to a guaranteed arg.
//
// CHECK-LABEL: sil [thunk] [always_inline] @exploded_release_to_guaranteed_param
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $boo):
// CHECK: [[IN1:%.*]] = function_ref @_T036exploded_release_to_guaranteed_paramTf4gX_n
// CHECK: release_value [[INPUT_ARG0]]
sil @exploded_release_to_guaranteed_param : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = struct_extract %0 : $boo, #boo.tbaz
  %2 = struct_extract %1 : $baz, #baz.start
  %3 = struct_extract %1 : $baz, #baz.end
  %4 = struct_extract %0 : $boo, #boo.a
  %5 = function_ref @use_Int : $@convention(thin) (Int) -> ()
  apply %5(%4) : $@convention(thin) (Int) -> ()
  release_value  %2 : $foo
  release_value  %3 : $foo
  %6 = tuple ()
  return %6 : $()
}

// CHECK-LABEL: sil [thunk] [always_inline] @single_owned_return_value
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $boo):
// CHECK: [[IN1:%.*]] = function_ref @_T025single_owned_return_valueTf4n_g
// CHECK: [[IN2:%.*]] = apply [[IN1]]([[INPUT_ARG0]]
// CHECK: retain_value [[IN2]]
sil @single_owned_return_value : $@convention(thin) (@owned boo) -> @owned boo {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  retain_value %0 : $boo
  return %0 : $boo
}


// CHECK-LABEL: sil [thunk] [always_inline] @single_owned_return_value_with_self_recursion
// CHECK: function_ref @_T045single_owned_return_value_with_self_recursionTf4n_g
// CHECK: [[RET:%.*]] = apply
// CHECK: retain_value [[RET]]
sil @single_owned_return_value_with_self_recursion : $@convention(thin) (@owned boo) -> @owned boo {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  cond_br undef, bb1, bb2
bb1:
  retain_value %0 : $boo
  br bb3(%0 : $boo)
bb2:
  %2 = function_ref @single_owned_return_value_with_self_recursion : $@convention(thin) (@owned boo) -> @owned boo
  %3 = apply %2(%0) : $@convention(thin) (@owned boo) -> @owned boo
  br bb3 (%3 : $boo)
bb3(%4 : $boo):
  return %4 : $boo
}

// CHECK-LABEL: sil [thunk] [always_inline] @single_owned_return_value_with_interfering_release
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $boo):
// CHECK: [[IN1:%.*]] = function_ref @_T050single_owned_return_value_with_interfering_releaseTf4x_nTf4gnn_n
// CHECK-NOT: retain_value
// CHECK: return
sil @single_owned_return_value_with_interfering_release : $@convention(thin) (@owned boo) ->  boo {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  retain_value %0 : $boo
  %1 = struct_extract %0 : $boo, #boo.tbaz
  %2 = struct_extract %1 : $baz, #baz.start
  release_value %2: $foo
  return %0 : $boo
}

// Make sure we do not move the retain_value in the throw block.
//
// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_unowned_retval_with_error_result : $@convention(thin) (@owned boo) -> (@owned boo, @error Error) {
// CHECK: function_ref @_T041owned_to_unowned_retval_with_error_resultTfq4n_g : $@convention(thin) (@owned boo) -> (boo, @error Error)
// CHECK: bb1
// CHECK-NOT retain_value
// CHECK: bb2
sil [serialized] @owned_to_unowned_retval_with_error_result : $@convention(thin) (@owned boo) -> (@owned boo, @error Error) {
bb0(%0 : $boo):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  cond_br undef, bb1, bb2

bb1:
  retain_value %0 : $boo
  return %0 : $boo

bb2:
  retain_value %0 : $boo
  throw undef : $Error
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK: bb0
// CHECK-NEXT: function_ref
// CHECK-NEXT: function_ref @_T023dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> ()
// CHECK-NEXT: apply
// CHECK-NEXT: return
sil [serialized] @dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  debug_value %0 : $Builtin.NativeObject // debug_value of a dead arg should also be deleted.
  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  %3 = apply %2(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  %4 = tuple()
  return %4 : $()
}

// CHECK-NOT: sil hidden [serialized] @private_dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
sil private [serialized] @private_dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  %3 = apply %2(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  %4 = tuple()
  return %4 : $()
}

// CHECK-LABEL: sil [serialized] @dead_arg_callsite_1 : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK: bb0
// CHECK: [[OPT_FUN:%[0-9]+]] = function_ref @_T023dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> ()
// CHECK-NEXT: apply [[OPT_FUN]](
// CHECK: [[PRIV_OPT_FUN:%[0-9]+]] = function_ref @_T031private_dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> ()
// CHECK-NEXT: apply [[PRIV_OPT_FUN]]
sil [serialized] @dead_arg_callsite_1 : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  %2 = function_ref @dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %3 = apply %2(%0, %1) : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %4 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()

  // This ensures that %0 is not dead in this function. We don't want to specialize this.
  apply %4(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  %5 = function_ref @private_dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %6 = apply %5(%0, %1) : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %7 = tuple()
  return %7 : $()
}

// This test makes sure we can look up an already specialized callee instead of regenerating one.
// CHECK-LABEL: sil [serialized] @dead_arg_callsite_2 : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK: [[OPT_FUN:%[0-9]+]] = function_ref @_T023dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> ()
// CHECK-NEXT: apply [[OPT_FUN]](
sil [serialized] @dead_arg_callsite_2 : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  %2 = function_ref @dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %3 = apply %2(%0, %1) : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %4 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  // This ensures that %0 is not dead in this function. We don't want to specialize this.
  apply %4(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  %5 = tuple()
  return %5 : $()
}

// DISABLED for now. Inliner does not look through thin_to_thick_function.
//
// This test case verifies we can specialize functions called through thin_to_thick_function.
// DISABLECHECK-LABEL: sil [serialized] @dead_arg_obfuscated_callsite : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// DISABLECHECK: [[OPT_FUN:%[0-9]+]] = function_ref @_TTSf4d_n__dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject) -> ()
// DISABLECHECK-NEXT: apply [[OPT_FUN]](
sil [serialized] @dead_arg_obfuscated_callsite : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  %2 = function_ref @dead_arg_with_callsites : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %3 = thin_to_thick_function %2 : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () to $@callee_owned (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %4 = apply %3(%0, %1) : $@callee_owned (Builtin.NativeObject, Builtin.NativeObject) -> ()
  %5 = tuple()
  return %5 : $()
}

sil [serialized] @exploded_release_to_guaranteed_param_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  %2 = function_ref @exploded_release_to_guaranteed_param : $@convention(thin) (@owned boo) -> ()
  retain_value %0 : $boo
  %4 = apply %2(%0) : $@convention(thin) (@owned boo) -> ()
  %5 = tuple()
  return %5 : $()
}

// Make sure we pull out the retain_value from the callee.
//
// The retain and release can be got rid of easily by arc this way.
//
// CHECK-LABEL: sil @single_owned_return_value_with_self_recursion_callsite
// CHECK: [[RET:%.*]] = apply
// CHECK: retain_value [[RET]]
// CHECK: release_value [[RET]]
sil @single_owned_return_value_with_self_recursion_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  %2 = function_ref @single_owned_return_value_with_self_recursion : $@convention(thin) (@owned boo) -> @owned boo
  %4 = apply %2(%0) : $@convention(thin) (@owned boo) -> @owned boo
  release_value %4 : $boo
  %5 = tuple()
  return %5 : $()
}

sil [serialized] @exploded_release_to_dead_param_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  %2 = function_ref @exploded_release_to_dead_argument : $@convention(thin) (@owned boo) -> ()
  retain_value %0 : $boo
  %4 = apply %2(%0) : $@convention(thin) (@owned boo) -> ()
  %5 = tuple()
  return %5 : $()
}


sil [serialized] @single_owned_return_value_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @single_owned_return_value : $@convention(thin) (@owned boo) -> @owned boo
  %3 = apply %2(%0) : $@convention(thin) (@owned boo) -> @owned boo
  %4 = tuple()
  return %4 : $()
}

sil [serialized] @single_owned_return_value_with_interfering_release_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @single_owned_return_value_with_interfering_release : $@convention(thin) (@owned boo) -> boo
  %3 = apply %2(%0) : $@convention(thin) (@owned boo) -> boo
  %4 = tuple()
  return %4 : $()
}

sil [serialized] @owned_to_unowned_retval_with_error_result_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  cond_br undef, bb1, bb2

bb1:
  br bb3

bb2:
  br bb3

bb3:
  %2 = function_ref @owned_to_unowned_retval_with_error_result : $@convention(thin) (@owned boo) -> (@owned boo, @error Error)
  try_apply %2(%0) : $@convention(thin) (@owned boo) -> (@owned boo, @error Error), normal bb4, error bb5

bb4(%99 : $boo):
  %4 = tuple()
  return %4 : $()

bb5(%100 : $Error):
  unreachable
}

sil [serialized] @dead_argument_due_to_only_release_user_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  %2 = function_ref @dead_argument_due_to_only_release_user : $@convention(thin) (@owned boo) -> (Int, Int)
  %4 = apply %2(%0) : $@convention(thin) (@owned boo) -> (Int, Int)
  %5 = tuple()
  return %5 : $()
}

sil [serialized] @dead_argument_due_to_only_release_user_but__exploded_callsite : $@convention(thin) (@owned lotsoffield) -> () {
bb0(%0 : $lotsoffield):
  %2 = function_ref @dead_argument_due_to_only_release_user_but__exploded : $@convention(thin) (@owned lotsoffield) -> (Int, Int, Int)
  %4 = apply %2(%0) : $@convention(thin) (@owned lotsoffield) -> (Int, Int, Int)
  %5 = tuple()
  return %5 : $()
}

sil [serialized] @dead_argument_due_to_more_than_release_user_callsite : $@convention(thin) (@owned boo) -> () {
bb0(%0 : $boo):
  %2 = function_ref @dead_argument_due_to_more_than_release_user : $@convention(thin) (@owned boo) -> (Int, Int)
  %4 = apply %2(%0) : $@convention(thin) (@owned boo) -> (Int, Int)
  %5 = tuple()
  return %5 : $()
}

sil [serialized] @argument_with_incomplete_epilogue_release_callsite : $@convention(thin) (@owned goo) -> () {
bb0(%0 : $goo):
  %2 = function_ref @argument_with_incomplete_epilogue_release : $@convention(thin) (@owned goo) -> ()
  %4 = apply %2(%0) : $@convention(thin) (@owned goo) -> ()
  %5 = tuple()
  return %5 : $()
}


//========================================
// @owned => @guaranteed with error result

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_with_error_result : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error) {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T037owned_to_guaranteed_with_error_resultTfq4gn_n : $@convention(thin) (@guaranteed Builtin.NativeObject, Int)
// CHECK: try_apply [[FUNC_REF]]({{.*}}, normal bb1, error bb2
// CHECK: bb1([[NORMRET:%[0-9]+]] : $Int):
// CHECK-NEXT: release_value
// CHECK-NEXT: return [[NORMRET]]
// CHECK: bb2([[THROW:%[0-9]+]] : $Error):
// CHECK-NEXT: release_value
// CHECK-NEXT: throw [[THROW]]
sil [serialized] @owned_to_guaranteed_with_error_result : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error) {
bb0(%0 : $Builtin.NativeObject, %1 : $Int):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %f1 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %f1(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  cond_br undef, bb1, bb2

bb1:
  release_value %0 : $Builtin.NativeObject
  return %1 : $Int

bb2:
  release_value %0 : $Builtin.NativeObject
  throw undef : $Error
}

// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_with_error_caller : $@convention(thin) (Builtin.NativeObject, Int) -> (Int, @error Error) {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T037owned_to_guaranteed_with_error_resultTfq4gn_n : $@convention(thin) (@guaranteed Builtin.NativeObject, Int)
// CHECK: try_apply [[FUNC_REF]]({{.*}}, normal bb1, error bb2
// CHECK: bb1([[NORMRET:%[0-9]+]] : $Int):
// CHECK-NEXT: release_value
// CHECK: bb2([[THROW:%[0-9]+]] : $Error):
// CHECK-NEXT: release_value
sil [serialized] @owned_to_guaranteed_with_error_caller : $@convention(thin) (Builtin.NativeObject, Int) -> (Int, @error Error) {
bb0(%0 : $Builtin.NativeObject, %1 : $Int):
  %f1 = function_ref @owned_to_guaranteed_with_error_result : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error)
  try_apply %f1(%0, %1) : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error), normal bb1, error bb2

bb1(%a1 : $Int):
  return %a1 : $Int

bb2(%a2 : $Error):
  throw %a2 : $Error
}

// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_with_nothrow_caller : $@convention(thin) (Builtin.NativeObject, Int) -> Int {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T037owned_to_guaranteed_with_error_resultTfq4gn_n : $@convention(thin) (@guaranteed Builtin.NativeObject, Int)
// CHECK: try_apply [[FUNC_REF]]({{.*}}, normal bb1, error bb2
// CHECK: bb1([[NORMRET:%[0-9]+]] : $Int):
// CHECK-NEXT: release_value
// CHECK: bb2([[THROW:%[0-9]+]] : $Error):
// CHECK-NEXT: release_value
sil [serialized] @owned_to_guaranteed_with_nothrow_caller : $@convention(thin) (Builtin.NativeObject, Int) -> Int {
bb0(%0 : $Builtin.NativeObject, %1 : $Int):
  %f1 = function_ref @owned_to_guaranteed_with_error_result : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error)
  %r1 = apply [nothrow] %f1(%0, %1) : $@convention(thin) (@owned Builtin.NativeObject, Int) -> (Int, @error Error)
  return %r1 : $Int
}

//======================
// @owned => @guaranteed

// We should optimize this call.
// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_simple_singlebb_callee : $@convention(thin) (@owned Builtin.NativeObject) -> () {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T042owned_to_guaranteed_simple_singlebb_calleeTfq4g_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[FUNC_REF]]
// CHECK-NOT: fix_lifetime
// CHECK: release_value
sil [serialized] @owned_to_guaranteed_simple_singlebb_callee : $@convention(thin) (@owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  release_value %0 : $Builtin.NativeObject
  %2 = tuple()
  return %2 : $()
}

// Callee to make sure we handle multiple callees properly.
// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_simple_singlebb_caller1 : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK-NOT: fix_lifetime
// CHECK: release_value
sil [serialized] @owned_to_guaranteed_simple_singlebb_caller1 : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = function_ref @owned_to_guaranteed_simple_singlebb_callee : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_simple_singlebb_caller2 : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK-NOT: fix_lifetime
// CHECK: release_value
sil [serialized] @owned_to_guaranteed_simple_singlebb_caller2 : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = function_ref @owned_to_guaranteed_simple_singlebb_callee : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  %2 = tuple()
  return %2 : $()
}

// We should not optimize this call due to the user.
// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_sideeffectblock_singlebb_callee
// CHECK-NOT: @guaranteed
// CHECK: return
sil [serialized] @owned_to_guaranteed_sideeffectblock_singlebb_callee : $@convention(thin) (@owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  release_value %0 : $Builtin.NativeObject
  %1 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  %2 = tuple()
  return %2 : $()
}

// We should be able to optimize this callee since the release is in the exit
// BB. Additionally this test makes sure that we delete dead parameters before
// invalidating the owned argument -> release map.
// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_multibb_callee_with_release_in_exit : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject) -> () {
// CHECK-NOT: fix_lifetime
// CHECK: release_value %1 : $Builtin.NativeObject
sil [serialized] @owned_to_guaranteed_multibb_callee_with_release_in_exit : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.Int1, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %9999 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  cond_br undef, bb1, bb2

bb1:
  br bb2

bb2:
  strong_release %1 : $Builtin.NativeObject
  %2 = tuple()
  return %2 : $()
}

// In this case the release is not in the exit, so we cannot specialize.
// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_multibb_callee_with_release_not_in_exit : $@convention(thin) (@owned Builtin.NativeObject) -> () {
// CHECK-NOT: @guaranteed
// CHECK: return
sil [serialized] @owned_to_guaranteed_multibb_callee_with_release_not_in_exit : $@convention(thin) (@owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  strong_release %0 : $Builtin.NativeObject
  cond_br undef, bb1, bb2

bb1:
  br bb2

bb2:
  %1 = tuple()
  return %1 : $()
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_simple_singlebb_multiple_arg_callee : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject, Builtin.Int1) -> () {
sil [serialized] @owned_to_guaranteed_simple_singlebb_multiple_arg_callee : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject, Builtin.Int1) -> () {
bb0(%0 : $Builtin.Int1, %1 : $Builtin.NativeObject, %2 : $Builtin.Int1):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32
  %c23 = builtin "assert_configuration"() : $Builtin.Int32
  %c24 = builtin "assert_configuration"() : $Builtin.Int32
  %c25 = builtin "assert_configuration"() : $Builtin.Int32
  %c26 = builtin "assert_configuration"() : $Builtin.Int32
  %c27 = builtin "assert_configuration"() : $Builtin.Int32
  %c28 = builtin "assert_configuration"() : $Builtin.Int32
  %c29 = builtin "assert_configuration"() : $Builtin.Int32
  %c30 = builtin "assert_configuration"() : $Builtin.Int32

  %9999 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  cond_br %0, bb1, bb2

bb1:
  cond_br %2, bb2, bb3

bb2:
  br bb3

bb3:
  release_value %1 : $Builtin.NativeObject
  %3 = tuple()
  return %3 : $()
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_1 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () {
// CHECK: bb0([[INPUT_PTR1:%.*]] : $Builtin.NativeObject, [[INPUT_PTR2:%.*]] : $Builtin.NativeObject):
// CHECK: release_value [[INPUT_PTR2]] : $Builtin.NativeObject
// CHECK: release_value [[INPUT_PTR1]] : $Builtin.NativeObject
sil [serialized] @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_1 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %9999 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  cond_br undef, bb1, bb2

bb1:
  br bb2

bb2:
  strong_release %1 : $Builtin.NativeObject
  strong_release %0 : $Builtin.NativeObject
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_2 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () {
// CHECK: bb0([[INPUT_PTR1:%.*]] : $Builtin.NativeObject, [[INPUT_PTR2:%.*]] : $Builtin.NativeObject):
// CHECK: release_value [[INPUT_PTR2]] : $Builtin.NativeObject
// CHECK: release_value [[INPUT_PTR1]] : $Builtin.NativeObject
sil [serialized] @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_2 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %9999 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %9999(%1) : $@convention(thin) (Builtin.NativeObject) -> ()
  %2 = function_ref @create_object : $@convention(thin) () -> Builtin.NativeObject
  %3 = apply %2() : $@convention(thin) () -> Builtin.NativeObject
  cond_br undef, bb1(%3 : $Builtin.NativeObject), bb2(%3 : $Builtin.NativeObject)

bb1(%4 : $Builtin.NativeObject):
  br bb2(%4 : $Builtin.NativeObject)

bb2(%5 : $Builtin.NativeObject):
  strong_release %5 : $Builtin.NativeObject
  strong_release %0 : $Builtin.NativeObject
  strong_release %1 : $Builtin.NativeObject
  %6 = tuple()
  return %6 : $()
}

// CHECK-LABEL: sil [serialized] @owned_to_guaranteed_simple_singlebb_multiple_arg_caller : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
// CHECK: bb0([[INPUT_PTR_1:%.*]] : $Builtin.NativeObject, [[INPUT_PTR_2:%.*]] : $Builtin.NativeObject):
// CHECK: [[SINGLEBB_MULTIPLEARG_CALLEE:%.*]] = function_ref @_T055owned_to_guaranteed_simple_singlebb_multiple_arg_calleeTfq4ngn_n : $@convention(thin) (Builtin.Int1, @guaranteed Builtin.NativeObject, Builtin.Int1) -> ()
// CHECK: apply [[SINGLEBB_MULTIPLEARG_CALLEE]]({{%.*}}, [[INPUT_PTR_1]], {{%.*}})
// CHECK: release_value [[INPUT_PTR_1]]
// CHECK: [[MULTIBB_RELEASENOTINEXIT_CALLEE:%.*]] = function_ref @owned_to_guaranteed_multibb_callee_with_release_not_in_exit : $@convention(thin) (@owned Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASENOTINEXIT_CALLEE]]([[INPUT_PTR_1]])
// CHECK: [[MULTIBB_RELEASEINEXIT_CALLEE:%.*]] = function_ref @_T055owned_to_guaranteed_multibb_callee_with_release_in_exitTfq4dg_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASEINEXIT_CALLEE]]([[INPUT_PTR_1]])
// CHECK-NEXT: release_value [[INPUT_PTR_1]] : $Builtin.NativeObject
// CHECK: [[MULTIBB_RELEASEINEXIT_TWOARGS1:%.*]] = function_ref @_T066owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_1Tfq4gg_n : $@convention(thin) (@guaranteed Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASEINEXIT_TWOARGS1]]([[INPUT_PTR_1]], [[INPUT_PTR_2]])
// CHECK: release_value [[INPUT_PTR_2]]
// CHECK: release_value [[INPUT_PTR_1]]
// CHECK: [[MULTIBB_RELEASEINEXIT_TWOARGS1:%.*]] = function_ref @_T066owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_1Tfq4gg_n : $@convention(thin) (@guaranteed Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASEINEXIT_TWOARGS1]]([[INPUT_PTR_2]], [[INPUT_PTR_1]])
// CHECK: release_value [[INPUT_PTR_1]]
// CHECK: release_value [[INPUT_PTR_2]]

// CHECK: [[MULTIBB_RELEASEINEXIT_TWOARGS2:%.*]] = function_ref @_T066owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_2Tfq4gg_n : $@convention(thin) (@guaranteed Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASEINEXIT_TWOARGS2]]([[INPUT_PTR_2]], [[INPUT_PTR_1]])
// CHECK: release_value [[INPUT_PTR_1]]
// CHECK: release_value [[INPUT_PTR_2]]
// CHECK: [[MULTIBB_RELEASEINEXIT_TWOARGS2:%.*]] = function_ref @_T066owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_2Tfq4gg_n : $@convention(thin) (@guaranteed Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[MULTIBB_RELEASEINEXIT_TWOARGS2]]([[INPUT_PTR_1]], [[INPUT_PTR_2]])
// CHECK: release_value [[INPUT_PTR_2]]
// CHECK: release_value [[INPUT_PTR_1]]

sil [serialized] @owned_to_guaranteed_simple_singlebb_multiple_arg_caller : $@convention(thin) (Builtin.NativeObject, Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject):
  %2 = function_ref @owned_to_guaranteed_simple_singlebb_multiple_arg_callee : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject, Builtin.Int1) -> ()
  %3 = integer_literal $Builtin.Int1, 0
  %4 = integer_literal $Builtin.Int1, 0
  apply %2(%3, %0, %4) : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject, Builtin.Int1) -> ()
  %5 = function_ref @owned_to_guaranteed_multibb_callee_with_release_not_in_exit : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  apply %5(%0) : $@convention(thin) (@owned Builtin.NativeObject) -> ()
  %6 = integer_literal $Builtin.Int1, 0
  %7 = function_ref @owned_to_guaranteed_multibb_callee_with_release_in_exit : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject) -> ()
  apply %7(%6, %0) : $@convention(thin) (Builtin.Int1, @owned Builtin.NativeObject) -> ()
  %8 = function_ref @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_1 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()
  apply %8(%0, %1) : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()
  apply %8(%1, %0) : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()
  %9 = function_ref @owned_to_guaranteed_multibb_callee_with_release_in_exit_two_args_2 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()
  apply %9(%1, %0) : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()
  apply %9(%0, %1) : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> ()

  %9999 = tuple()
  return %9999 : $()
}


// CHECK-NEGATIVE-NOT: sil {{.*}}_dont_explode_single_enum

sil [noinline] @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo {
bb0(%0 : $Optional<(foo, foo)>):
  %281 = unchecked_enum_data %0 : $Optional<(foo, foo)>, #Optional.some!enumelt.1
  %282 = tuple_extract %281 : $(foo, foo), 0
  %283 = tuple_extract %281 : $(foo, foo), 1
  strong_release %283 : $foo
  return %282 : $foo
}


// CHECK-LABEL: sil @call_with_single_enum
// CHECK: [[F:%[0-9]+]] = function_ref @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
// CHECK: apply [[F]](%0)
// CHECK: return
sil @call_with_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo {
bb0(%0 : $Optional<(foo, foo)>):
  %f = function_ref @dont_explode_single_enum : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
  %a = apply %f(%0) : $@convention(thin) (@owned Optional<(foo, foo)>) -> @owned foo
  return %a : $foo
}


// Check if externally available functions are optimized.

sil public_external [noinline] @externally_available_with_dead_arg : $@convention(thin) (@guaranteed foo) -> () {
bb0(%0 : $foo):
  %r = tuple()
  return %r : $()
}

// CHECK-LABEL: sil @call_externally_available
// CHECK: [[F:%[0-9]+]] = function_ref @_T034externally_available_with_dead_argTf4d_n : $@convention(thin) () -> ()
// CHECK: apply [[F]]()
// CHECK: return
sil @call_externally_available : $@convention(thin) (@guaranteed foo) -> () {
bb0(%0 : $foo):
  %f = function_ref @externally_available_with_dead_arg : $@convention(thin) (@guaranteed foo) -> ()
  %a = apply %f(%0) : $@convention(thin) (@guaranteed foo) -> ()
  %r = tuple()
  return %r : $()
}


// We should remove the array semantic from specialized calls.

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] [_semantics "array.foobar"] @array_semantic : $@convention(method) (@owned Builtin.NativeObject) -> () {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T014array_semanticTfq4g_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[FUNC_REF]]
// CHECK: release_value
sil [serialized] [_semantics "array.foobar"] @array_semantic : $@convention(method) (@owned Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = function_ref @user : $@convention(thin) (Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(thin) (Builtin.NativeObject) -> ()
  release_value %0 : $Builtin.NativeObject
  %2 = tuple()
  return %2 : $()
}

// CHECK-LABEL: sil [serialized] @array_semantic_caller : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK: [[FUNC_REF:%[0-9]+]] = function_ref @_T014array_semanticTfq4g_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> ()
// CHECK: apply [[FUNC_REF]]
// CHECK: release_value
sil [serialized] @array_semantic_caller : $@convention(thin) (Builtin.NativeObject) -> () {
bb0(%0 : $Builtin.NativeObject):
  %1 = function_ref @array_semantic : $@convention(method) (@owned Builtin.NativeObject) -> ()
  apply %1(%0) : $@convention(method) (@owned Builtin.NativeObject) -> ()
  %2 = tuple()
  return %2 : $()
}

// Make sure that we are processing in bottom up order. This test
// works since the default order in which the SIL Parser places
// SILFunctions into the SILModule is the order in which the function
// is parsed. Thus if we are just processing in that order, s3 will
// call s2 instead of s2 with the dead argument.
//
// CHECK-LABEL: sil [serialized] @s3 : $@convention(thin) (Builtin.Int32) -> () {
// CHECK: [[FUN:%.*]] = function_ref @_T02s2Tfq4d_n
// CHECK: apply [[FUN]](
sil [serialized] @s3 : $@convention(thin) (Builtin.Int32) -> () {
bb0(%0 : $Builtin.Int32):
  %1 = function_ref @s2 : $@convention(thin) (Builtin.Int32) -> ()
  apply %1(%0) : $@convention(thin) (Builtin.Int32) -> ()
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @s2 : $@convention(thin) (Builtin.Int32) -> () {
sil [serialized] @s2 : $@convention(thin) (Builtin.Int32) -> () {
bb0(%0 : $Builtin.Int32):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %1 = function_ref @s1 : $@convention(thin) (Builtin.Int32) -> ()
  apply %1(%0) : $@convention(thin) (Builtin.Int32) -> ()
  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil [serialized] [thunk] [always_inline] @s1 : $@convention(thin) (Builtin.Int32) -> () {
sil [serialized] @s1 : $@convention(thin) (Builtin.Int32) -> () {
bb0(%0 : $Builtin.Int32):
  // make it a non-trivial function
  %c1 = builtin "assert_configuration"() : $Builtin.Int32
  %c2 = builtin "assert_configuration"() : $Builtin.Int32
  %c3 = builtin "assert_configuration"() : $Builtin.Int32
  %c4 = builtin "assert_configuration"() : $Builtin.Int32
  %c5 = builtin "assert_configuration"() : $Builtin.Int32
  %c6 = builtin "assert_configuration"() : $Builtin.Int32
  %c7 = builtin "assert_configuration"() : $Builtin.Int32
  %c8 = builtin "assert_configuration"() : $Builtin.Int32
  %c9 = builtin "assert_configuration"() : $Builtin.Int32
  %c10 = builtin "assert_configuration"() : $Builtin.Int32
  %c11 = builtin "assert_configuration"() : $Builtin.Int32
  %c12 = builtin "assert_configuration"() : $Builtin.Int32
  %c13 = builtin "assert_configuration"() : $Builtin.Int32
  %c14 = builtin "assert_configuration"() : $Builtin.Int32
  %c15 = builtin "assert_configuration"() : $Builtin.Int32
  %c16 = builtin "assert_configuration"() : $Builtin.Int32
  %c17 = builtin "assert_configuration"() : $Builtin.Int32
  %c18 = builtin "assert_configuration"() : $Builtin.Int32
  %c19 = builtin "assert_configuration"() : $Builtin.Int32
  %c20 = builtin "assert_configuration"() : $Builtin.Int32
  %c21 = builtin "assert_configuration"() : $Builtin.Int32
  %c22 = builtin "assert_configuration"() : $Builtin.Int32

  %9999 = tuple()
  return %9999 : $()
}

// CHECK-LABEL: sil hidden [thunk] [always_inline] @generic_owned_to_guaranteed : $@convention(thin) <T where T : KlassFoo> (@owned T) -> Int64
// CHECK: function_ref @_T027generic_owned_to_guaranteedTf4g_n 
// CHECK: apply
// CHECK: release_value
// CHECK: end sil function 'generic_owned_to_guaranteed'

// CHECK-LABEL: sil [thunk] [always_inline] @generic_owned_to_guaranteed_caller : $@convention(thin) <T where T : KlassFoo> (@owned T) -> Int64 
// CHECK: function_ref @_T034generic_owned_to_guaranteed_callerTf4g_n 
// CHECK: apply
// CHECK: release_value
// CHECK: end sil function 'generic_owned_to_guaranteed_caller'

sil hidden [noinline] @generic_owned_to_guaranteed : $@convention(thin) <T where T : KlassFoo> (@owned T) -> Int64 {
bb0(%0 : $T):
  %2 = witness_method $T, #KlassFoo.bar!1 : <Self where Self : KlassFoo> (Self) -> () -> Int64 : $@convention(witness_method) <τ_0_0 where τ_0_0 : KlassFoo> (@guaranteed τ_0_0) -> Int64
  %3 = apply %2<T>(%0) : $@convention(witness_method) <τ_0_0 where τ_0_0 : KlassFoo> (@guaranteed τ_0_0) -> Int64
  strong_release %0 : $T
  return %3 : $Int64
}

sil @generic_owned_to_guaranteed_caller : $@convention(thin) <T where T : KlassFoo> (@owned T) -> Int64 {
bb0(%0 : $T):
  %2 = function_ref @generic_owned_to_guaranteed : $@convention(thin) <τ_0_0 where τ_0_0 : KlassFoo> (@owned τ_0_0) -> Int64
  strong_retain %0 : $T
  %4 = apply %2<T>(%0) : $@convention(thin) <τ_0_0 where τ_0_0 : KlassFoo> (@owned τ_0_0) -> Int64
  %5 = function_ref @generic_owned_to_guaranteed : $@convention(thin) <τ_0_0 where τ_0_0 : KlassFoo> (@owned τ_0_0) -> Int64
  strong_retain %0 : $T
  %7 = apply %5<T>(%0) : $@convention(thin) <τ_0_0 where τ_0_0 : KlassFoo> (@owned τ_0_0) -> Int64
  %8 = struct_extract %4 : $Int64, #Int64._value
  %9 = struct_extract %7 : $Int64, #Int64._value
  %10 = integer_literal $Builtin.Int1, -1
  %11 = builtin "sadd_with_overflow_Int64"(%8 : $Builtin.Int64, %9 : $Builtin.Int64, %10 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %12 = tuple_extract %11 : $(Builtin.Int64, Builtin.Int1), 0
  %13 = tuple_extract %11 : $(Builtin.Int64, Builtin.Int1), 1
  cond_fail %13 : $Builtin.Int1
  %15 = struct $Int64 (%12 : $Builtin.Int64)
  strong_release %0 : $T
  return %15 : $Int64
}

// CHECK-LABEL: sil hidden [thunk] [always_inline] @generic_in_to_guaranteed : $@convention(thin) <T where T : P> (@in T) -> Int64
// CHECK: function_ref @_T024generic_in_to_guaranteedTf4g_n 
// CHECK: apply
// CHECK: destroy_addr
// CHECK: end sil function 'generic_in_to_guaranteed'

// CHECK-LABEL: sil [thunk] [always_inline] @generic_in_to_guaranteed_caller : $@convention(thin) <T where T : P> (@in T) -> Int64 
// CHECK: function_ref @_T031generic_in_to_guaranteed_callerTf4g_n 
// CHECK: apply
// CHECK: destroy_addr
// CHECK: end sil function 'generic_in_to_guaranteed_caller'

sil hidden [noinline] @generic_in_to_guaranteed : $@convention(thin) <T where T : P> (@in T) -> Int64 {
bb0(%0 : $*T):
  %2 = witness_method $T, #P.foo!1 : <Self where Self : P> (Self) -> () -> Int64 : $@convention(witness_method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
  %3 = apply %2<T>(%0) : $@convention(witness_method) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
  destroy_addr %0 : $*T
  return %3 : $Int64
}

sil @generic_in_to_guaranteed_caller : $@convention(thin) <T where T : P> (@in T) -> Int64 {
bb0(%0 : $*T):
  %2 = function_ref @generic_in_to_guaranteed : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in τ_0_0) -> Int64
  %3 = alloc_stack $T
  copy_addr %0 to [initialization] %3 : $*T
  %5 = apply %2<T>(%3) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in τ_0_0) -> Int64
  dealloc_stack %3 : $*T
  %7 = apply %2<T>(%0) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in τ_0_0) -> Int64
  %8 = struct_extract %5 : $Int64, #Int64._value
  %9 = struct_extract %7 : $Int64, #Int64._value
  %10 = integer_literal $Builtin.Int1, -1
  %11 = builtin "sadd_with_overflow_Int64"(%8 : $Builtin.Int64, %9 : $Builtin.Int64, %10 : $Builtin.Int1) : $(Builtin.Int64, Builtin.Int1)
  %12 = tuple_extract %11 : $(Builtin.Int64, Builtin.Int1), 0
  %13 = tuple_extract %11 : $(Builtin.Int64, Builtin.Int1), 1
  cond_fail %13 : $Builtin.Int1
  %15 = struct $Int64 (%12 : $Builtin.Int64)
  return %15 : $Int64
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_dead_non_generic_arg : $@convention(thin) <T> (@owned foo, @in T) -> ()
// CHECK: function_ref @_T0027generic_func_with_dead_non_A4_argTf4dd_n : $@convention(thin) () -> ()
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: destroy_addr
// CHECK: end sil function 'generic_func_with_dead_non_generic_arg'
sil [noinline] @generic_func_with_dead_non_generic_arg : $@convention(thin) <T> (@owned foo, @in T) -> () {
bb0(%0 : $foo, %1 : $*T):
  destroy_addr %1 : $*T
  %r = tuple()
  return %r : $()
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_dead_generic_arg : $@convention(thin) <T> (Int64, @in T) -> Int64
// CHECK: function_ref @_T0023generic_func_with_dead_A4_argTf4nd_n : $@convention(thin) (Int64) -> Int64 
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: destroy_addr
// CHECK: end sil function 'generic_func_with_dead_generic_arg'
sil [noinline] @generic_func_with_dead_generic_arg : $@convention(thin) <T> (Int64, @in T) -> Int64 {
bb0(%0 : $Int64, %1 : $*T):
  destroy_addr %1 : $*T
  return %0 : $Int64
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_unused_generic_param_and_non_generic_arg : $@convention(thin) <T> (Int64) -> Int64 
// CHECK: function_ref @_T0025generic_func_with_unused_a15_param_and_non_A4_argTf4n_n : $@convention(thin) (Int64) -> Int64 
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: end sil function 'generic_func_with_unused_generic_param_and_non_generic_arg'
sil [noinline] @generic_func_with_unused_generic_param_and_non_generic_arg : $@convention(thin) <T> (Int64) -> Int64 {
bb0(%0 : $Int64):
  return %0 : $Int64
}

sil [noinline] @generic_func_with_unused_generic_param_and_non_generic_arg_caller : $@convention(thin) <T> (Int64) -> Int64 {
bb0(%0 : $Int64):
  %f = function_ref @generic_func_with_unused_generic_param_and_non_generic_arg : $@convention(thin) <T> (Int64) -> Int64 
  %r = apply %f<T>(%0) : $@convention(thin) <T> (Int64) -> Int64 
  return %r : $Int64
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_unused_generic_param_and_dead_non_generic_arg : $@convention(thin) <T> (Int64, Int64) -> Int64
// CHECK: function_ref @_T0025generic_func_with_unused_a20_param_and_dead_non_A4_argTf4nd_n : $@convention(thin) (Int64) -> Int64 
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: end sil function 'generic_func_with_unused_generic_param_and_dead_non_generic_arg'
sil [noinline] @generic_func_with_unused_generic_param_and_dead_non_generic_arg : $@convention(thin) <T> (Int64, Int64) -> Int64 {
bb0(%0 : $Int64, %1 : $Int64):
  return %0 : $Int64
}

sil [noinline] @generic_func_with_unused_generic_param_and_dead_non_generic_arg_caller : $@convention(thin) <T> (Int64) -> Int64 {
bb0(%0 : $Int64):
  %f = function_ref @generic_func_with_unused_generic_param_and_dead_non_generic_arg : $@convention(thin) <T> (Int64, Int64) -> Int64 
  %r = apply %f<T>(%0, %0) : $@convention(thin) <T> (Int64, Int64) -> Int64 
  return %r : $Int64
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_unused_generic_param_and_dead_generic_arg : $@convention(thin) <T> (@in_guaranteed T) -> ()
// CHECK: function_ref @_T0025generic_func_with_unused_a16_param_and_dead_A4_argTf4d_n : $@convention(thin) () -> ()
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: end sil function 'generic_func_with_unused_generic_param_and_dead_generic_arg'
sil [noinline] @generic_func_with_unused_generic_param_and_dead_generic_arg : $@convention(thin) <T> (@in_guaranteed T) -> () {
bb0(%0 : $*T):
  %r = tuple()
  return %r : $()
}

sil [noinline] @generic_func_with_unused_generic_param_and_dead_generic_arg_caller : $@convention(thin) <T> (@in_guaranteed T) -> () {
bb0(%0 : $*T):
  %f = function_ref @generic_func_with_unused_generic_param_and_dead_generic_arg : $@convention(thin) <T> (@in_guaranteed T) -> () 
  apply %f<T>(%0) : $@convention(thin) <T> (@in_guaranteed T) -> ()  
  %r = tuple()
  return %r : $()
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_unused_generic_param_and_dead_owned_generic_arg : $@convention(thin) <T where T : KlassFoo> (@owned T) -> ()
// CHECK: function_ref @_T0025generic_func_with_unused_a22_param_and_dead_owned_A4_argTf4d_n : $@convention(thin) () -> ()
// Call the specialization which is not polymorphic.
// CHECK: apply
// CHECK: release_value %0
// CHECK: end sil function 'generic_func_with_unused_generic_param_and_dead_owned_generic_arg'
sil [noinline] @generic_func_with_unused_generic_param_and_dead_owned_generic_arg : $@convention(thin) <T where T: KlassFoo> (@owned T) -> () {
bb0(%0 : $T):
  release_value %0 : $T
  %r = tuple()
  return %r : $()
}

sil [noinline] @generic_func_with_unused_generic_param_and_dead_owned_generic_arg_caller : $@convention(thin) <T where T: KlassFoo> (@owned T) -> () {
bb0(%0 : $T):
  %f = function_ref @generic_func_with_unused_generic_param_and_dead_owned_generic_arg : $@convention(thin) <T where T: KlassFoo> (@owned T) -> () 
  apply %f<T>(%0) : $@convention(thin) <T where T: KlassFoo> (@owned T) -> ()  
  %r = tuple()
  return %r : $()
}

// CHECK-LABEL: sil [thunk] [always_inline] @generic_func_with_multple_generic_args_and_dead_generic_arg : $@convention(thin) <T, S> (@in T, @in S) -> ()
// CHECK: function_ref @_T0026generic_func_with_multple_a15_args_and_dead_A4_argTf4nd_n : $@convention(thin) <τ_0_0, τ_0_1> (@in τ_0_0) -> ()
// Call the specialization which has only one function argument, because another one is dead
// and was eliminated.
// CHECK: apply
// CHECK: end sil function 'generic_func_with_multple_generic_args_and_dead_generic_arg'
sil [noinline] @generic_func_with_multple_generic_args_and_dead_generic_arg : $@convention(thin) <T, S> (@in T, @in S) -> () {
bb0(%0 : $*T, %1 : $*S):
  %f = function_ref @use_Generic : $@convention(thin) <T>(@in_guaranteed T) -> ()
  apply %f<T>(%0) : $@convention(thin) <T>(@in_guaranteed T) -> ()
  %r = tuple()
  return %r : $()
}

sil [noinline] @generic_func_with_multple_generic_args_and_dead_generic_arg_caller : $@convention(thin) <T> (@in T) -> () {
bb0(%0 : $*T):
  %2 = alloc_stack $T
  copy_addr %0 to [initialization] %2 : $*T
  %4 = alloc_stack $T
  copy_addr %0 to [initialization] %4 : $*T
  %f = function_ref @generic_func_with_multple_generic_args_and_dead_generic_arg : $@convention(thin) <T, S> (@in T, @in S) -> ()
  apply %f<T, T>(%2, %4) : $@convention(thin) <T, S> (@in T, @in S) -> () 
  dealloc_stack %4 : $*T
  dealloc_stack %2 : $*T
  %r = tuple()
  return %r : $()
}

// CHECK-LABEL: sil @_T036exploded_release_to_guaranteed_paramTf4gX_n
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $Int):
// CHECK-NOT: strong_release
// CHECK: return

// CHECK-LABEL: sil @_T025single_owned_return_valueTf4n_g : $@convention(thin) (@owned boo) -> boo
// CHECK: bb0([[INPUT_ARG0:%[0-9]+]] : $boo):
// CHECK-NOT: retain_value
// CHECK: return

// There should not be a single retain in this function.
//
// CHECK-LABEL: sil @_T045single_owned_return_value_with_self_recursionTf4n_g : $@convention(thin) (@owned boo) -> boo
// CHECK: bb0
// CHECK-NOT: retain_value
// CHECK: return

// CHECK-LABEL: @_T041owned_to_unowned_retval_with_error_resultTfq4n_g : $@convention(thin) (@owned boo) -> (boo, @error Error) {
// CHECK: bb2
// CHECK: retain_value
// CHECK: throw

// Check that we specialized this function by removing the dead argument and
// copied everything appropriately.

// CHECK-LABEL: sil [serialized] @_T023dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK: bb0([[INPUT_ARG:%[0-9]+]] : $Builtin.NativeObject):
// CHECK: cond_br undef, bb1, bb2
// CHECK: bb1:
// CHECK-NEXT: br bb3
// CHECK: bb2:
// CHECK-NEXT: br bb3
// CHECK: bb3:
// CHECK-NEXT: function_ref
// CHECK-NEXT: function_ref @user
// CHECK-NEXT: apply
// CHECK-NEXT: tuple
// CHECK-NEXT: return

// CHECK-LABEL: sil private [serialized] @_T031private_dead_arg_with_callsitesTfq4dn_n : $@convention(thin) (Builtin.NativeObject) -> () {
// CHECK: bb0(

// CHECK-LABEL: sil [serialized] @_T037owned_to_guaranteed_with_error_resultTfq4gn_n : $@convention(thin) (@guaranteed Builtin.NativeObject, Int) -> (Int, @error Error) {
// CHECK-NOT: release
// CHECK: throw

// CHECK-LABEL: sil [serialized] @_T042owned_to_guaranteed_simple_singlebb_calleeTfq4g_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {

// CHECK-LABEL: sil [serialized] @_T055owned_to_guaranteed_multibb_callee_with_release_in_exitTfq4dg_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
// CHECK: bb0(
// CHECK:  function_ref user
// CHECK:  function_ref @user
// CHECK:  apply
// CHECK:  cond_br undef, bb1, bb2
// CHECK: bb1:
// CHECK-NEXT:  br bb2
// CHECK: bb2:
// CHECK-NEXT:  tuple
// CHECK-NEXT:  return


// Check that we have remove the array semantic attribute from the specialized
// function.
// Also make sure we have change the calling convention to freestanding from
// method because we have changed the self argument.

// CHECK-LABEL: sil [serialized] @_T014array_semanticTfq4g_n : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () {
// CHECK: bb0(%0 : $Builtin.NativeObject)
// CHECK:  function_ref user
// CHECK:  function_ref @user
// CHECK:  apply
// CHECK:  tuple
// CHECK:  return

// Check that a owned-to-guaranteed has happened.
// CHECK-LABEL: sil hidden [noinline] @_T027generic_owned_to_guaranteedTf4g_n : $@convention(thin) <T where T : KlassFoo> (@guaranteed T) -> Int64
// CHECK-NOT: release_value 
// CHECK-NOT: strong_release 
// CHECK-NOT: destroy_addr 
// CHECK: end sil function '_T027generic_owned_to_guaranteedTf4g_n'

// Check that a owned-to-guaranteed has happened.
// CHECK-LABEL: sil @_T034generic_owned_to_guaranteed_callerTf4g_n : $@convention(thin) <T where T : KlassFoo> (@guaranteed T) -> Int64
// Call the specialized function. It should have a guaranteed param now. 
// CHECK: function_ref @_T027generic_owned_to_guaranteedTf4g_n : $@convention(thin) <τ_0_0 where τ_0_0 : KlassFoo> (@guaranteed τ_0_0) -> Int64
// CHECK: apply
// CHECK: end sil function '_T034generic_owned_to_guaranteed_callerTf4g_n'

// Check that a in-to-guaranteed has happened.
// CHECK-LABEL: sil hidden [noinline] @_T024generic_in_to_guaranteedTf4g_n : $@convention(thin) <T where T : P> (@in_guaranteed T) -> Int64
// CHECK-NOT: destroy_addr
// CHECK: end sil function '_T024generic_in_to_guaranteedTf4g_n'

// Check that a in-to-guaranteed has happened.
// CHECK-LABEL: sil @_T031generic_in_to_guaranteed_callerTf4g_n : $@convention(thin) <T where T : P> (@in_guaranteed T) -> Int64
// Call the specialized function. It should have a guaranteed param now. 
// CHECK: function_ref @_T024generic_in_to_guaranteedTf4g_n : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@in_guaranteed τ_0_0) -> Int64
// CHECK: apply
// CHECK: end sil function '_T031generic_in_to_guaranteed_callerTf4g_n'