test/SILOptimizer/simplify_cfg.sil - third_party/swift - Git at Google

 // RUN: %target-sil-opt -enable-objc-interop -enforce-exclusivity=none -enable-sil-verify-all %s -jumpthread-simplify-cfg | %FileCheck %s
 // FIXME: Update for select_enum change.

 // Declare this SIL to be canonical because some tests break raw SIL
 // conventions. e.g. address-type block args. -enforce-exclusivity=none is also
 // required to allow address-type block args in canonical SIL.
 sil_stage canonical

 import Builtin
 import Swift

 ///////////////////////
 // Type Declarations //
 ///////////////////////

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

 sil @use_foo : $@convention(thin) (@owned foo) -> ()


 ///////////
 // Tests //
 ///////////

 // CHECK-LABEL: sil @test_dead_block
 // CHECK-NEXT: bb0:
 // CHECK-NEXT:   unreachable
 // CHECK-NEXT: }
 sil @test_dead_block : $() -> () {
 bb0:
   unreachable

 bb1:
   %4 = integer_literal $Builtin.Int64, 1
   br bb2

 bb2:
   %5 = struct $Int64 (%4 : $Builtin.Int64)
   unreachable
 }

 // CHECK-LABEL: @release_in_arcinert_termination_block
 // CHECK: bb0
 // CHECK:   unreachable
 // CHECK: }
 sil @release_in_arcinert_termination_block : $(@owned foo) -> () {
 bb0(%0 : $foo):
   br bb1

 bb1:
   strong_release %0 : $foo
   unreachable
 }

 // CHECK-LABEL: @release_in_nonarcinert_termination_block
 // CHECK: bb0
 // CHECK: strong_release
 // CHECK: apply
 // CHECK: unreachable
 sil @release_in_nonarcinert_termination_block : $(@owned foo) -> () {
 bb0(%0 : $foo):
   br bb1

 bb1:
   strong_release %0 : $foo
   %1 = function_ref @use_foo : $@convention(thin) (@owned foo) -> ()
   apply %1(%0) : $@convention(thin) (@owned foo) -> ()
   unreachable
 }

 // CHECK-LABEL: @test_single_pred_block
 // CHECK: bb3([[ARG:%[0-9]+]] : $Builtin.Int64):
 // CHECK: struct $Int64
 // CHECK-NEXT: return
 sil @test_single_pred_block : $@convention(thin) (Builtin.Int1) -> Int64 {
 bb0(%0 : $Builtin.Int1):
   cond_br %0, bb1, bb3

 bb1:
   %4 = integer_literal $Builtin.Int64, 1
   br bb2(%4 : $Builtin.Int64)

 bb3:
   %9 = integer_literal $Builtin.Int64, 2
   br bb2(%9 : $Builtin.Int64)

 bb2(%6 : $Builtin.Int64):
   %7 = struct $Int64 (%6 : $Builtin.Int64)
   br bb4(%7 : $Int64)

 bb4(%8 : $Int64):
   return %8 : $Int64
 }

 // CHECK-LABEL: sil @canonicalize_not_branch
 // CHECK: bb0([[ARG:%.*]] : $Builtin.Int1):
 // CHECK:   cond_br [[ARG]], bb2, bb1
 // CHECK: bb1:
 // CHECK:   integer_literal {{.*}} 2
 // CHECK:   br
 // CHECK: bb2:
 // CHECK:   integer_literal {{.*}} 3
 // CHECK:   br

 sil @canonicalize_not_branch : $@convention(thin) (Builtin.Int1) -> (Builtin.Int32) {
 bb0(%0 : $Builtin.Int1):
   %1 = integer_literal $Builtin.Int1, -1
   %2 = builtin "xor_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %2, bb1, bb2

 bb1:
   %4 = integer_literal $Builtin.Int32, 2
   br bb3(%4 : $Builtin.Int32)

 bb2:
   %5 = integer_literal $Builtin.Int32, 3
   br bb3(%5 : $Builtin.Int32)

 bb3(%6 : $Builtin.Int32):
   return %6 : $Builtin.Int32
 }

 // CHECK-LABEL: sil @canonicalize_not_branch_expect
 // CHECK: bb0([[ARG:%.*]] : $Builtin.Int1):
 // CHECK:   [[ZERO:%.*]] =  integer_literal $Builtin.Int1, 0
 // CHECK:   [[EXPECT:%.*]] = builtin "int_expect_Int1"([[ARG]] : $Builtin.Int1, [[ZERO]]
 // CHECK    cond_br [[EXPECT]], bb2, bb1
 // CHECK: bb1:
 // CHECK:   integer_literal {{.*}} 2
 // CHECK:   br
 // CHECK: bb2:
 // CHECK:   integer_literal {{.*}} 3
 // CHECK:   br

 sil @canonicalize_not_branch_expect : $@convention(thin) (Builtin.Int1) -> (Builtin.Int32) {
 bb0(%0 : $Builtin.Int1):
   %1 = integer_literal $Builtin.Int1, -1
   %2 = builtin "xor_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   %3 = builtin "int_expect_Int1"(%2 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %3, bb1, bb2

 bb1:
   %4 = integer_literal $Builtin.Int32, 2
   br bb3(%4 : $Builtin.Int32)

 bb2:
   %5 = integer_literal $Builtin.Int32, 3
   br bb3(%5 : $Builtin.Int32)

 bb3(%6 : $Builtin.Int32):
   return %6 : $Builtin.Int32
 }

 enum BoolLike { case true_, false_ }

 // func testThread(a : BoolLike) -> Int32 {
 //   if a { return 42 } else { return 17 } }
 //
 /// CHECK-LABEL: sil @testThread
 sil @testThread : $@convention(thin) (@in BoolLike) -> Int64 {
 bb0(%0 : $*BoolLike):
   // CHECK: switch_enum_addr %0 : $*BoolLike, case #BoolLike.true_!enumelt: bb1, case #BoolLike.false_!enumelt: bb2
   switch_enum_addr %0 : $*BoolLike, case #BoolLike.true_!enumelt: bb1, case #BoolLike.false_!enumelt: bb3 // id: %3

 bb1:                                              // Preds: bb0
   %4 = integer_literal $Builtin.Int1, -1          // user: %5
   br bb2(%4 : $Builtin.Int1)                      // id: %5

 bb2(%6 : $Builtin.Int1):                          // Preds: bb3 bb1
   br bb4                                          // id: %7

 bb3:                                              // Preds: bb0
   %8 = integer_literal $Builtin.Int1, 0           // user: %9
   br bb2(%8 : $Builtin.Int1)                      // id: %9

 bb4:                                              // Preds: bb2
   cond_br %6, bb5, bb6                            // id: %10

 bb5:                                              // Preds: bb4
   %11 = metatype $@thin Int64.Type
   %12 = integer_literal $Builtin.Int64, 42        // user: %13
   %13 = struct $Int64 (%12 : $Builtin.Int64)      // user: %14
   br bb7(%13 : $Int64)                            // id: %14

 bb6:                                              // Preds: bb4
   %15 = metatype $@thin Int64.Type
   %16 = integer_literal $Builtin.Int64, 17        // user: %17
   %17 = struct $Int64 (%16 : $Builtin.Int64)      // user: %18
   br bb7(%17 : $Int64)                            // id: %18

 bb7(%19 : $Int64):                                // Preds: bb6 bb5
   return %19 : $Int64                             // id: %21
 }

 // func testThread2(a : Int32) -> Int32 {
 //   enum b = (a ? _true : _false)
 //   if b == _true { return 42 } else { return 17 }
 //

 /// CHECK-LABEL: sil @testThread2
 /// CHECK: bb0([[COND:%.*]] : {{.*}}):
 /// CHECK: cond_br [[COND]], bb1, bb2
 /// CHECK: bb1:
 /// CHECK:  integer_literal $Builtin.Int64, 42
 /// CHeCK:  br bb3
 /// CHECK: bb2:
 /// CHECK:  integer_literal $Builtin.Int64, 17
 /// CHECK:  br bb3
 /// CHECK: bb3
 /// CHECK:  return

 sil @testThread2 : $@convention(thin) (Builtin.Int1) -> Int64 {
 bb0(%0 : $Builtin.Int1):
   %t = integer_literal $Builtin.Int1, 1
   %f = integer_literal $Builtin.Int1, 0
   cond_br %0, bb1, bb2

 bb1:                                              // Preds: bb0
   %4 = enum $BoolLike, #BoolLike.true_!enumelt    // user: %5
   br bb3(%4 : $BoolLike)                          // id: %5

 bb2:                                              // Preds: bb0
   %8 = enum $BoolLike, #BoolLike.false_!enumelt   // user: %9
   br bb3(%8 : $BoolLike)                          // id: %9

 bb3(%6 : $BoolLike):                              // Preds: bb3 bb1
   %100 = select_enum %6 : $BoolLike, case #BoolLike.true_!enumelt: %t, case #BoolLike.false_!enumelt: %f : $Builtin.Int1
   br bb4                                          // id: %7

 bb4:                                              // Preds: bb2
   cond_br %100, bb5, bb6                          // id: %10

 bb5:                                              // Preds: bb4
   %11 = metatype $@thin Int64.Type
   %12 = integer_literal $Builtin.Int64, 42        // user: %13
   %13 = struct $Int64 (%12 : $Builtin.Int64)      // user: %14
   br bb7(%13 : $Int64)                            // id: %14

 bb6:                                              // Preds: bb4
   %15 = metatype $@thin Int64.Type
   %16 = integer_literal $Builtin.Int64, 17        // user: %17
   %17 = struct $Int64 (%16 : $Builtin.Int64)      // user: %18
   br bb7(%17 : $Int64)                            // id: %18

 bb7(%19 : $Int64):                                // Preds: bb6 bb5
   return %19 : $Int64                             // id: %21
 }

 // func testThread3(a : Int32) -> Int32 {
 //   (enum b, val) = (a ? (_true, 16) : (_false, 17))
 //   if b == true { return 42 } else { return v } }
 //


 /// CHECK-LABEL: sil @testThread3
 /// CHECK: bb0([[COND:%.*]] : {{.*}}):
 /// CHECK: cond_br [[COND]], bb1, bb2
 /// CHECK: bb1:
 /// CHECK:  integer_literal $Builtin.Int64, 42
 /// CHeCK:  br bb3
 /// CHECK: bb2:
 /// CHECK:  integer_literal $Builtin.Int64, 17
 /// CHECK:  br bb3
 /// CHECK: bb3
 /// CHECK:  return

 sil @testThread3 : $@convention(thin) (Builtin.Int1) -> Int64 {
 bb0(%0 : $Builtin.Int1):
   %t = integer_literal $Builtin.Int1, 1
   %f = integer_literal $Builtin.Int1, 0
   cond_br %0, bb1, bb2

 bb1:                                              // Preds: bb0
   %4 = enum $BoolLike, #BoolLike.true_!enumelt          // user: %5
   %40 = integer_literal $Builtin.Int64, 16
   br bb3(%4 : $BoolLike, %40 : $Builtin.Int64)                      // id: %5

 bb2:                                              // Preds: bb0
   %8 = enum $BoolLike, #BoolLike.false_!enumelt           // user: %9
   %80 = integer_literal $Builtin.Int64, 17
   br bb3(%8 : $BoolLike, %80 : $Builtin.Int64)                      // id: %9

 bb3(%6 : $BoolLike, %60 : $Builtin.Int64):                          // Preds: bb3 bb1
   %100 = select_enum %6 : $BoolLike, case #BoolLike.true_!enumelt: %t, case #BoolLike.false_!enumelt: %f : $Builtin.Int1
   br bb4                                          // id: %7

 bb4:                                              // Preds: bb2
   cond_br %100, bb5, bb6                            // id: %10

 bb5:                                              // Preds: bb4
   %11 = metatype $@thin Int64.Type
   %12 = integer_literal $Builtin.Int64, 42        // user: %13
   %13 = struct $Int64 (%12 : $Builtin.Int64)      // user: %14
   br bb7(%13 : $Int64)                            // id: %14

 bb6:                                              // Preds: bb4
   %15 = metatype $@thin Int64.Type
   %17 = struct $Int64 (%60 : $Builtin.Int64)      // user: %18
   br bb7(%17 : $Int64)                            // id: %18

 bb7(%19 : $Int64):                                // Preds: bb6 bb5
   return %19 : $Int64                             // id: %21
 }


 /// CHECK-LABEL: sil @testCondBrFold
 /// CHECK: bb0(
 /// CHECK-NEXT: return %1 : $Int64
 sil @testCondBrFold : $@convention(thin) (Int64, Int64) -> Int64 {
 bb0(%0 : $Int64, %1 : $Int64):
   %8 = integer_literal $Builtin.Int1, 0
   cond_br %8, bb1, bb2
 bb1:
   unreachable
 bb2:
   return %1 : $Int64
 }

 /// CHECK-LABEL: sil @testSwitchEnumFold
 /// CHECK: bb0(
 /// CHECK-NEXT: return %0 : $Int64
 sil @testSwitchEnumFold : $@convention(thin) (Int64) -> Int64 {
 bb0(%0 : $Int64):
   %1 = enum $BoolLike, #BoolLike.true_!enumelt
   switch_enum %1 : $BoolLike, case #BoolLike.true_!enumelt: bb2, case #BoolLike.false_!enumelt: bb1
 bb1:
   unreachable
 bb2:
   return %0 : $Int64
 }

 // CHECK-LABEL: @elim_trampoline
 // CHECK: bb0
 // CHECK:  cond_br {{.*}}, bb1, bb2
 // CHECK:bb1:
 // CHECK:  br bb3(%1
 // CHECK:bb2:
 // CHECK:  br bb3(%2
 // CHECK:bb3({{.*}}):
 // CHECK:  return
 sil @elim_trampoline : $@convention(thin) (Builtin.Int1, Int64, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64, %2 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%2 : $Int64)

 bb1(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb2(%4 : $Int64):
   br bb3(%4 : $Int64)

 bb3(%5 : $Int64):
   return %5 : $Int64
 }

 // CHECK-LABEL: @elim_trampoline2
 // CHECK-NOT: cond_br %0, bb1(%1 : $Int64), bb1(%1 : $Int64)
 // CHECK: return
 sil @elim_trampoline2 : $@convention(thin) (Builtin.Int1, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%1 : $Int64)

 bb1(%2 : $Int64):
   br bb3(%2 : $Int64)

 bb2(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb3(%4 : $Int64):
   return %4 : $Int64
 }

 // CHECK-LABEL: @elim_trampoline_debug
 // CHECK-NOT: cond_br %0, bb1(%1 : $Int64), bb1(%1 : $Int64)
 // CHECK: return
 sil @elim_trampoline_debug : $@convention(thin) (Builtin.Int1, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%1 : $Int64)

 bb1(%2 : $Int64):
   debug_value %0 : $Builtin.Int1
   br bb3(%2 : $Int64)

 bb2(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb3(%4 : $Int64):
   return %4 : $Int64
 }

 // CHECK-LABEL: @elim_trampoline3
 // CHECK:  cond_br %0, bb1, bb2
 // CHECK:bb1:
 // CHECK:  br bb3(%1
 // CHECK:bb2:
 // CHECK:  br bb3(%2
 // CHECK:bb3({{.*}}):
 // CHECK:  return
 sil @elim_trampoline3 : $@convention(thin) (Builtin.Int1, Int64, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64, %2 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%2 : $Int64)

 bb1(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb2(%4 : $Int64):
   br bb3(%4 : $Int64)

 bb3(%5 : $Int64):
   br bb4(%5 : $Int64)

 bb4(%6 : $Int64):
   return %6 : $Int64
 }

 // Make sure the cond_br is not simplified as it would create
 // a critical edge.
 // CHECK-LABEL: @elim_trampoline4
 // CHECK: cond_br %0, bb1, bb2
 // CHECK: bb1:
 // CHECK-NEXT: br bb3
 // CHECK: bb2:
 // CHECK: br bb3
 // CHECK: bb3
 // CHECK: return
 // CHECK: }

 sil @external_f : $@convention(thin) () -> ()

 sil @elim_trampoline4 : $@convention(thin) (Builtin.Int1, Int64, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64, %2 : $Int64):
   cond_br %0, bb1, bb2

 bb1:
   br bb3(%1 : $Int64)

 bb2:
   br bb4(%2 : $Int64)

 bb4(%4 : $Int64):
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   br bb5(%4: $Int64)

 bb3(%5 : $Int64):
   br bb5(%5 : $Int64)

 bb5(%6 : $Int64):
   return %6 : $Int64
 }

 // Make sure that a conditional branch to a trampoline without parameters
 // gets eliminated by branching to a target of this trampoline.
 // CHECK-LABEL: @elim_trampoline5
 // CHECK: cond_br
 // CHECK: bb3:
 // CHECK: cond_br
 // CHECK: bb4{{.*}}:
 // Last cond_br should branch directly to the target of a trampoline
 // instead of the original bb3
 // CHECK: cond_br {{.*}}, bb3, bb5
 // CHECK: bb5:
 // CHECK-NEXT: br bb4
 // CHECK: }
 sil @elim_trampoline5 : $@convention(thin) (Int32) -> () {
 bb0(%0 : $Int32):
   %1 = integer_literal $Builtin.Int32, 0
   %2 = struct_extract %0 : $Int32, #Int32._value
   %3 = builtin "cmp_eq_Int32"(%1 : $Builtin.Int32, %2 : $Builtin.Int32) : $Builtin.Int1
   cond_br %3, bb1, bb2(%1 : $Builtin.Int32)

 bb1:
   %5 = tuple ()
   return %5 : $()

 bb2(%7 : $Builtin.Int32):
   %8 = integer_literal $Builtin.Int32, 1
   %9 = integer_literal $Builtin.Int1, 0
   %10 = integer_literal $Builtin.Int32, 2
   br bb5(%1 : $Builtin.Int32)

 bb3:
   br bb4(%8 : $Builtin.Int32)

 bb4(%13 : $Builtin.Int32):
   %14 = builtin "cmp_eq_Int32"(%13 : $Builtin.Int32, %2 : $Builtin.Int32) : $Builtin.Int1
   cond_br %14, bb1, bb2(%13 : $Builtin.Int32)

 bb5(%16 : $Builtin.Int32):
   %17 = builtin "sadd_with_overflow_Int32"(%16 : $Builtin.Int32, %8 : $Builtin.Int32, %9 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %18 = tuple_extract %17 : $(Builtin.Int32, Builtin.Int1), 0
   %19 = builtin "cmp_eq_Int32"(%18 : $Builtin.Int32, %10 : $Builtin.Int32) : $Builtin.Int1
   cond_br %19, bb3, bb5(%18 : $Builtin.Int32)
 }

 // CHECK-LABEL: @elim_trampoline_loop
 // Make sure we are not crashing on this one.
 // CHECK: return
 sil @elim_trampoline_loop : $@convention(thin) (Builtin.Int1, Int64, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64, %2 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%2 : $Int64)

 bb1(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb2(%4 : $Int64):
   br bb2(%4 : $Int64)

 bb3(%5 : $Int64):
   br bb4(%5 : $Int64)

 bb4(%6 : $Int64):
   return %6 : $Int64
 }

 // CHECK-LABEL: @elim_common_arg
 // CHECK: bb3:
 // CHECK-NEXT: return %1
 sil @elim_common_arg : $@convention(thin) (Builtin.Int1, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb1, bb2

 bb1:
   apply %f1() : $@convention(thin) () -> ()
   br bb3(%1 : $Int64)

 bb2:
   apply %f1() : $@convention(thin) () -> ()
   br bb3(%1 : $Int64)

 bb3(%a1 : $Int64):
   return %a1 : $Int64
 }

 // CHECK-LABEL: @elim_diamonds
 // CHECK: bb0
 // CHECK-NEXT: return %1
 sil @elim_diamonds : $@convention(thin) (Builtin.Int1, Int64, Int64) -> Int64 {
 bb0(%0 : $Builtin.Int1, %1 : $Int64, %2 : $Int64):
   cond_br %0, bb1(%1 : $Int64), bb2(%1 : $Int64)

 bb1(%3 : $Int64):
   br bb3(%3 : $Int64)

 bb2(%4 : $Int64):
   br bb3(%4 : $Int64)

 bb3(%5 : $Int64):
   cond_br %0, bb4(%5 : $Int64), bb5(%5 : $Int64)

 bb4(%6 : $Int64):
   br bb6(%6 : $Int64)

 bb5(%7 : $Int64):
   br bb6(%7 : $Int64)

 bb6(%8 : $Int64):
   return %8 : $Int64
 }

 // CHECK-LABEL: @infinite_loop
 // CHECK: bb0
 // CHECK-NEXT: br bb1
 // CHECK: bb1
 // CHECK-NEXT: br bb1
 sil @infinite_loop : $@convention(thin) () -> () {
 bb0:
   br bb1
 bb1:
   br bb1
 }

 import Builtin
 import Swift

 // CHECK-LABEL: @dead_loop
 // CHECK-NOT: br bb
 sil @dead_loop : $@convention(thin) () -> () {
 bb0:
   %0 = integer_literal $Builtin.Int1, 0           // users: %1, %4
   %2 = integer_literal $Builtin.Int1, -1          // user: %11
   cond_br %0, bb1, bb3                            // id: %4

 bb1:                                              // Preds: bb0
   %5 = integer_literal $Builtin.Int32, 0           // users: %6, %7
   %6 = struct $Int32 (%5 : $Builtin.Int32)
   br bb2(%5 : $Builtin.Int32)                      // id: %7

 bb2(%8 : $Builtin.Int32):                          // Preds: bb1 bb2
   %9 = integer_literal $Builtin.Int32, 1           // user: %11
   %11 = builtin "sadd_with_overflow_Int32"(%8 : $Builtin.Int32, %9 : $Builtin.Int32, %2 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %12, %13
   %12 = tuple_extract %11 : $(Builtin.Int32, Builtin.Int1), 0 // users: %15, %16
   %13 = tuple_extract %11 : $(Builtin.Int32, Builtin.Int1), 1 // user: %14
   cond_fail %13 : $Builtin.Int1                   // id: %14
   %15 = struct $Int32 (%12 : $Builtin.Int32)
   br bb2(%12 : $Builtin.Int32)                     // id: %16

 bb3:                                              // Preds: bb0
   %17 = tuple ()                                  // user: %18
   return %17 : $()                                // id: %18
 }

 // We should be able to compile this down to returning the parameter
 // but we're not quite there yet.
 // CHECK-LABEL: @nop
 sil @nop : $@convention(thin) (Bool) -> Bool {
 bb0(%0 : $Bool):
   %1 = struct_extract %0 : $Bool, #Bool._value
 // CHECK: cond_br %1, [[TRUE:[a-zA-Z0-9]+]], [[FALSE:[a-zA-Z0-9]+]]
   cond_br %1, bb1, bb2

 // CHECK: [[TRUE]]:
 bb1:
   %3 = integer_literal $Builtin.Int1, 0
   %4 = struct $Bool (%3 : $Builtin.Int1)
 // CHECK: br [[RETURN:[a-zA-Z0-9]+]]
   br bb3(%4 : $Bool)

 // CHECK: [[FALSE]]:
 bb2:
   %6 = integer_literal $Builtin.Int1, -1          // user: %7
   %7 = struct $Bool (%6 : $Builtin.Int1)          // user: %8
 // CHECK: br [[RETURN]]
   br bb3(%7 : $Bool)                              // id: %8

 // CHECK: [[RETURN]]
 bb3(%9 : $Bool):                                  // Preds: bb1 bb2
 // CHECK-NOT: struct_extract
   %10 = struct_extract %9 : $Bool, #Bool._value    // user: %11
 // CHECK: return
   cond_br %10, bb4, bb5                           // id: %11

 // CHECK-NOT: bb4
 bb4:                                              // Preds: bb3
   %12 = integer_literal $Builtin.Int1, 0          // user: %13
   %13 = struct $Bool (%12 : $Builtin.Int1)        // user: %14
   br bb6(%13 : $Bool)                             // id: %14

 // CHECK-NOT: bb5
 bb5:                                              // Preds: bb3
   %15 = integer_literal $Builtin.Int1, -1         // user: %16
   %16 = struct $Bool (%15 : $Builtin.Int1)        // user: %17
   br bb6(%16 : $Bool)                             // id: %17

 bb6(%18 : $Bool):                                 // Preds: bb4 bb5
   return %18 : $Bool                              // id: %19
 }

 class C {
   final var value: Int32
   init(v: Int32)
 }

 // CHECK-LABEL: @redundant_switchenum
 sil @redundant_switchenum : $@convention(thin) (@owned Optional<C>) -> Int32 {
 bb0(%0 : $Optional<C>):
   switch_enum %0 : $Optional<C>, case #Optional.some!enumelt.1: bb1, case #Optional.none!enumelt: bb2

 // CHECK: bb1:
 bb1:
   %9 = integer_literal $Builtin.Int1, -1
   %10 = struct $Bool (%9 : $Builtin.Int1)
 // CHECK:  br [[DEST:[a-zA-Z0-9]+]]
   br bb3(%10 : $Bool)

 // CHECK: bb2:
 bb2:
   %17 = integer_literal $Builtin.Int1, 0
   %18 = struct $Bool (%17 : $Builtin.Int1)
 // CHECK: br [[DEST]]
   br bb3(%18 : $Bool)

 // CHECK: [[DEST]]({{.*}}):
 bb3(%12 : $Bool):
   %15 = struct_extract %12 : $Bool, #Bool._value
 // CHECK-NOT: cond_br
 // CHECK: return
   cond_br %15, bb4, bb7

 // CHECK-NOT: bb4:
 bb4:
   %21 = alloc_stack $Optional<C>
   store %0 to %21 : $*Optional<C>
 // CHECK-NOT: switch_enum
   switch_enum %0 : $Optional<C>, case #Optional.some!enumelt.1: bb5, case #Optional.none!enumelt: bb6

 bb5:
   %25 = unchecked_take_enum_data_addr %21 : $*Optional<C>, #Optional.some!enumelt.1
   %26 = load %25 : $*C
   dealloc_stack %21 : $*Optional<C>
   %29 = ref_element_addr %26 : $C, #C.value
   %30 = load %29 : $*Int32
   br bb8(%30 : $Int32)

 bb6:
   %34 = builtin "int_trap"() : $()
   unreachable

 bb7:
   %36 = integer_literal $Builtin.Int32, 0
   %37 = struct $Int32 (%36 : $Builtin.Int32)
   br bb8(%37 : $Int32)

 bb8(%39 : $Int32):
   release_value %0 : $Optional<C>
   return %39 : $Int32
 }

 enum A {
   case B, C, D
 }

 // CHECK-LABEL: cannot_optimize_switch_enum
 sil @cannot_optimize_switch_enum : $@convention(thin) (A) -> () {
 // CHECK: bb0
 bb0(%0 : $A):
 // CHECK: %1 = function_ref
 // CHECK-NEXT: switch_enum %0 : $A, case #A.B!enumelt: bb1, default [[BB:bb[0-9a-zA-Z]+]]
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   switch_enum %0 : $A, case #A.B!enumelt: bb1, default bb2

 bb1:
   apply %f1() : $@convention(thin) () -> ()
   br bb5

 // CHECK: [[BB]]
 bb2:
 // CHECK-NEXT: switch_enum %0
   switch_enum %0 : $A, case #A.C!enumelt: bb3, default bb4

 bb3:
   apply %f1() : $@convention(thin) () -> ()
   br bb5

 bb4:
   apply %f1() : $@convention(thin) () -> ()
   br bb5

 bb5:
   %6 = tuple ()
   return %6 : $()
 }

 // CHECK-LABEL: sil @simplify_switch_enum1
 // CHECK: bb0:
 // CHECK-NOT: bb[0-9]
 // CHECK: apply
 // CHECK-NEXT: return
 sil @simplify_switch_enum1 : $@convention(thin) () -> Int32 {
 bb0:
   %10 = integer_literal $Builtin.Int32, 2
   %11 = struct $Int32 (%10 : $Builtin.Int32)
   %20 = integer_literal $Builtin.Int32, 3
   %21 = struct $Int32 (%20 : $Builtin.Int32)
   cond_br undef, bb1, bb2

 bb1:
   %12 = enum $Optional<Int32>, #Optional.some!enumelt.1, %11 : $Int32
   br bb3(%12 : $Optional<Int32>)

 bb2:
   %22 = enum $Optional<Int32>, #Optional.some!enumelt.1, %21 : $Int32
   br bb3(%22 : $Optional<Int32>)

 bb3(%30 : $Optional<Int32>):
   %u = function_ref @unknown : $@convention(thin) () -> ()
   apply %u() : $@convention(thin) () -> ()
   switch_enum %30 : $Optional<Int32>, case #Optional.none!enumelt: bb4, case #Optional.some!enumelt.1: bb5

 bb4:
   br bb6(%11 : $Int32)

 bb5:
   br bb6(%21 : $Int32)

 bb6(%r : $Int32):
   return %r : $Int32
 }

 // CHECK-LABEL: sil @simplify_switch_enum2
 // CHECK: bb3([[A:%[0-9]+]] : $Optional<Int32>):
 // CHECK: apply
 // CHECK: [[R:%[0-9]+]] = unchecked_enum_data [[A]] : $Optional<Int32>, #Optional.some!enumelt.1
 // CHECK: return [[R]]
 sil @simplify_switch_enum2 : $@convention(thin) (Optional<Int32>) -> Int32 {
 bb0(%0 : $Optional<Int32>):
   %10 = integer_literal $Builtin.Int32, 2
   %11 = struct $Int32 (%10 : $Builtin.Int32)
   %20 = integer_literal $Builtin.Int32, 3
   %21 = struct $Int32 (%20 : $Builtin.Int32)
   switch_enum %0 : $Optional<Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   %12 = enum $Optional<Int32>, #Optional.some!enumelt.1, %11 : $Int32
   br bb3(%12 : $Optional<Int32>)

 bb2:
   br bb3(%0 : $Optional<Int32>)

 bb3(%30 : $Optional<Int32>):
   %u = function_ref @unknown : $@convention(thin) () -> ()
   apply %u() : $@convention(thin) () -> ()
   switch_enum %30 : $Optional<Int32>, case #Optional.none!enumelt: bb4, case #Optional.some!enumelt.1: bb5

 bb4:
   br bb6(%21 : $Int32)

 bb5(%p : $Int32):
   br bb6(%p : $Int32)

 bb6(%r : $Int32):
   return %r : $Int32
 }

 // CHECK-LABEL: sil @identical_switch_enum_dests : $@convention(thin) (Optional<Int32>) -> () {
 // CHECK: bb0(%0 : $Optional<Int32>):
 // CHECK-NEXT: tuple
 // CHECK-NEXT: return
 sil @identical_switch_enum_dests : $@convention(thin) (Optional<Int32>) -> () {
 bb0(%0 : $Optional<Int32>):
   switch_enum %0 : $Optional<Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   br bb3

 bb2:
   br bb3

 bb3:
   %r = tuple()
   return %r : $()
 }

 // CHECK-LABEL: sil @identical_switch_enum_addr_dests : $@convention(thin) (@in Optional<Int32>) -> () {
 // CHECK: bb0(%0 : $*Optional<Int32>):
 // CHECK-NEXT: tuple
 // CHECK-NEXT: return
 sil @identical_switch_enum_addr_dests : $@convention(thin) (@in Optional<Int32>) -> () {
 bb0(%0 : $*Optional<Int32>):
   switch_enum_addr %0 : $*Optional<Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   br bb3

 bb2:
   br bb3

 bb3:
   %r = tuple()
   return %r : $()
 }

 // CHECK-LABEL: sil @identical_switch_value_dests : $@convention(thin) (Builtin.Int32) -> () {
 // CHECK: bb0(%0 : $Builtin.Int32):
 // CHECK-NEXT: integer_literal
 // CHECK-NEXT: integer_literal
 // CHECK-NEXT: tuple
 // CHECK-NEXT: return
 sil @identical_switch_value_dests : $@convention(thin) (Builtin.Int32) -> () {
 bb0(%0 : $Builtin.Int32):
   %1 = integer_literal $Builtin.Int32, 24
   %2 = integer_literal $Builtin.Int32, 25
   switch_value %0 : $Builtin.Int32, case %1: bb1, case %2: bb2

 bb1:
   br bb3

 bb2:
   br bb3

 bb3:
   %r = tuple()
   return %r : $()
 }

 // CHECK-LABEL: sil @fold_switch_value : $@convention(thin) () -> Int32 {
 // CHECK: bb0:
 // CHECK-NOT: bb1
 // CHECK: integer_literal $Builtin.Int32, 100
 // CHECK-NEXT: struct
 // CHECK-NEXT: return
 sil @fold_switch_value : $@convention(thin) () -> Int32 {
 bb0:
   %1 = integer_literal $Builtin.Int32, 24
   %2 = integer_literal $Builtin.Int32, 25
   switch_value %1 : $Builtin.Int32, case %1: bb1, case %2: bb2

 bb1:
   %3 = integer_literal $Builtin.Int32, 100
   br bb3(%3 : $Builtin.Int32)

 bb2:
   %4 = integer_literal $Builtin.Int32, 200
   br bb3(%4 : $Builtin.Int32)

 bb3(%5 : $Builtin.Int32):
   %r = struct $Int32 (%5 : $Builtin.Int32)
   return %r : $Int32
 }


 // CHECK-LABEL: @dominator_based_simplify_condbr
 // CHECK:  integer_literal $Builtin.Int64, 1
 // CHECK-NOT:  integer_literal $Builtin.Int64, 2
 // CHECK-NOT:  integer_literal $Builtin.Int64, 3
 // CHECK:  integer_literal $Builtin.Int64, 4
 // CHECK: return
 sil @dominator_based_simplify_condbr : $@convention(thin) (Builtin.Int1) -> Int64 {
 bb0(%0 : $Builtin.Int1):
   %l1 = integer_literal $Builtin.Int1, -1
   cond_br %0, bb1, bb4

 bb1:
   cond_br %0, bb2, bb3

 bb2:
   %1 = integer_literal $Builtin.Int64, 1
   br bb7(%1 : $Builtin.Int64)

 bb3:
   %2 = integer_literal $Builtin.Int64, 2
   br bb7(%2 : $Builtin.Int64)

 bb4:
   // expect-intrinsics should be transparent for checking the condition.
   %x1 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %l1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %x1, bb5, bb6

 bb5:
   %3 = integer_literal $Builtin.Int64, 3
   br bb7(%3 : $Builtin.Int64)

 bb6:
   %4 = integer_literal $Builtin.Int64, 4
   br bb7(%4 : $Builtin.Int64)

 bb7(%6 : $Builtin.Int64):
   %7 = struct $Int64 (%6 : $Builtin.Int64)
   return %7 : $Int64
 }

 // CHECK-LABEL: @dominator_based_simplify_condbr_with_inverts
 // CHECK-NOT:  integer_literal $Builtin.Int64, 1
 // CHECK: [[I2:%[0-9]+]] = integer_literal $Builtin.Int64, 2
 // CHECK: br bb3([[I2]] : $Builtin.Int64)
 // CHECK-NOT:  integer_literal $Builtin.Int64, 3
 // CHECK: [[I4:%[0-9]+]] = integer_literal $Builtin.Int64, 4
 // CHECK: br bb3([[I4]] : $Builtin.Int64)
 // CHECK: bb3([[R:%[0-9]+]] : $Builtin.Int64):
 // CHECK-NEXT: return [[R]]
 sil @dominator_based_simplify_condbr_with_inverts : $@convention(thin) (Builtin.Int1) -> Builtin.Int64 {
 bb0(%0 : $Builtin.Int1):
   %l1 = integer_literal $Builtin.Int1, -1
   %x1 = builtin "xor_Int1"(%0 : $Builtin.Int1, %l1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %x1, bb1, bb4

 bb1:
   cond_br %0, bb2, bb3

 bb2:
   %1 = integer_literal $Builtin.Int64, 1
   br bb7(%1 : $Builtin.Int64)

 bb3:
   %2 = integer_literal $Builtin.Int64, 2
   br bb7(%2 : $Builtin.Int64)

 bb4:
   // expect-intrinsics should be transparent for checking the condition.
   %x2 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %l1 : $Builtin.Int1) : $Builtin.Int1
   %x3 = builtin "xor_Int1"(%0 : $Builtin.Int1, %l1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %x3, bb5, bb6

 bb5:
   %3 = integer_literal $Builtin.Int64, 3
   br bb7(%3 : $Builtin.Int64)

 bb6:
   %4 = integer_literal $Builtin.Int64, 4
   br bb7(%4 : $Builtin.Int64)

 bb7(%6 : $Builtin.Int64):
   return %6 : $Builtin.Int64
 }

 // CHECK-LABEL: @switch_enum_dominates_switch_enum_arg
 // CHECK:      bb0(%0 : $Optional<Builtin.Int32>):
 // CHECK-NEXT:   switch_enum %0 {{.*}} case #Optional.some!enumelt.1: bb2
 // CHECK:      bb2:
 // CHECK-NEXT:   [[D:%[0-9]+]] = unchecked_enum_data %0
 // CHECK-NEXT:   br bb3([[D]] : $Builtin.Int32)
 // CHECK:      bb3([[R:%[0-9]+]] : $Builtin.Int32):
 // CHECK-NEXT:   return [[R]]
 sil @switch_enum_dominates_switch_enum_arg : $@convention(thin) (Optional<Builtin.Int32>) -> Builtin.Int32 {
 bb0(%0 : $Optional<Builtin.Int32>):
   switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   %i1 = integer_literal $Builtin.Int32, 1
   br bb5(%i1 : $Builtin.Int32)

 bb2:
   switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.none!enumelt: bb3, case #Optional.some!enumelt.1: bb4

 bb3:
   %i2 = integer_literal $Builtin.Int32, 2
   br bb5(%i2 : $Builtin.Int32)

 bb4(%e : $Builtin.Int32):
   br bb5(%e : $Builtin.Int32)

 bb5(%r : $Builtin.Int32):
   return %r : $Builtin.Int32
 }

 // CHECK-LABEL: @switch_enum_dominates_switch_enum_arg_reuse
 // CHECK:      bb0(%0 : $Optional<Builtin.Int32>):
 // CHECK-NEXT:   switch_enum %0 {{.*}} case #Optional.some!enumelt.1: bb2
 // CHECK:      bb2({{.*}} : $Builtin.Int32):
 // CHECK-NEXT:   [[A:%[0-9]+]] = unchecked_enum_data %0
 // CHECK-NEXT:   br bb3([[A]] : $Builtin.Int32)
 // CHECK:      bb3([[R:%[0-9]+]] : $Builtin.Int32):
 // CHECK-NEXT:   return [[R]]
 sil @switch_enum_dominates_switch_enum_arg_reuse : $@convention(thin) (Optional<Builtin.Int32>) -> Builtin.Int32 {
 bb0(%0 : $Optional<Builtin.Int32>):
   switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   %i1 = integer_literal $Builtin.Int32, 1
   br bb5(%i1 : $Builtin.Int32)

 bb2(%d : $Builtin.Int32):
   switch_enum %0 : $Optional<Builtin.Int32>, case #Optional.none!enumelt: bb3, case #Optional.some!enumelt.1: bb4

 bb3:
   %i2 = integer_literal $Builtin.Int32, 2
   br bb5(%i2 : $Builtin.Int32)

 bb4(%e : $Builtin.Int32):
   br bb5(%e : $Builtin.Int32)

 bb5(%r : $Builtin.Int32):
   return %r : $Builtin.Int32
 }

 // CHECK-LABEL: sil @simplify_loop_header
 // CHECK: bb1(
 // CHECK:  cond_br {{.*}}, bb2, bb3
 // CHECK: bb2:
 // CHECK:  return
 // CHECK: bb3:
 // CHECK:  enum $Optional<Int32>, #Optional.some
 // CHECK:  br bb1(

 sil @simplify_loop_header : $@convention(thin) () -> () {
 bb0:
   %0 = integer_literal $Builtin.Int32, 0
   %1 = integer_literal $Builtin.Int32, 1000
   br bb1(%0 : $Builtin.Int32)

 bb1(%3 : $Builtin.Int32):
   %4 = struct $Int32 (%3 : $Builtin.Int32)
   %6 = builtin "cmp_eq_Int32"(%3 : $Builtin.Int32, %1 : $Builtin.Int32) : $Builtin.Int1
   cond_br %6, bb2, bb3

 bb2:
   %8 = enum $Optional<Int32>, #Optional.none!enumelt
   br bb4(%3 : $Builtin.Int32, %8 : $Optional<Int32>)

 bb3:
   %10 = integer_literal $Builtin.Int32, 1
   %12 = integer_literal $Builtin.Int1, -1
   %13 = builtin "sadd_with_overflow_Int32"(%3 : $Builtin.Int32, %10 : $Builtin.Int32, %12 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %14 = tuple_extract %13 : $(Builtin.Int32, Builtin.Int1), 0
   %15 = tuple_extract %13 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %15 : $Builtin.Int1
   %17 = enum $Optional<Int32>, #Optional.some!enumelt.1, %4 : $Int32
   br bb4(%14 : $Builtin.Int32, %17 : $Optional<Int32>)

 bb4(%19 : $Builtin.Int32, %20 : $Optional<Int32>):
   switch_enum %20 : $Optional<Int32>, case #Optional.some!enumelt.1: bb5, case #Optional.none!enumelt: bb6

 bb5:
   // This could be a use like we generate for a loop with an induction
   // variable use like in:
   //  for i in 1..10 { a[i] = i }
   %9 = unchecked_enum_data %20 : $Optional<Int32>, #Optional.some!enumelt.1
   br bb1(%19 : $Builtin.Int32)

 bb6:
   %23 = tuple ()
   return %23 : $()
 }

 class Base {
   @inline(never) func inner()
   func middle()
   func outer()
 }

 class Derived : Base {
   override func inner()
   @inline(never) final override func middle()
 }

 class Final : Derived {
 }

 sil @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
 sil @_TFC3ccb4Base6middlefS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()

 // CHECK-LABEL: sil @redundant_checked_cast_br
 sil @redundant_checked_cast_br : $@convention(method) (@guaranteed Base) -> () {
 bb0(%0 : $Base):
 // CHECK: [[METHOD:%.*]] = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %1 = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
 // CHECK: checked_cast_br [exact] %0 : $Base to $Base, [[SUCCESS:bb[0-9]+]], [[FAIL:bb[0-9]+]]
   checked_cast_br [exact] %0 : $Base to $Base, bb2, bb7

 // CHECK: bb1
 bb1:
   %3 = tuple ()
   return %3 : $()

 bb2(%5 : $Base):
 // CHECK: [[SUCCESS]]
   %7 = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
 // CHECK-NOT: checked_cast_br
   checked_cast_br [exact] %0 : $Base to $Base, bb3, bb5
 // CHECK: [[INNER:%.*]] = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
 // CHECK: apply [[INNER]]
 // CHECK: br bb1

 bb3(%9 : $Base):
 // CHECK: [[FAIL]]
 // CHECK-NOT: function-ref
 // CHECK: apply [[METHOD]]

   %10 = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
   %11 = apply %10(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb4:
   %13 = tuple ()
   br bb6(%13 : $())

 bb5:
   %15 = apply %7(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb6(%17 : $()):
   br bb1

 bb7:
   %19 = apply %1(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb1
 }


 // CHECK-LABEL: sil @not_redundant_checked_cast_br : $@convention(method) (@guaranteed Base) -> () {
 sil @not_redundant_checked_cast_br : $@convention(method) (@guaranteed Base) -> () {
 bb0(%0 : $Base):
 // CHECK: [[METHOD:%.*]] = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %1 = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
 // CHECK: checked_cast_br [exact] %0 : $Base to $Base, [[SUCCESS:bb[0-9]+]], [[FAIL:bb[0-9]+]]
   checked_cast_br [exact] %0 : $Base to $Base, bb2, bb7

 bb1:
   %3 = tuple ()
   return %3 : $()

 bb2(%5 : $Base):
 // CHECK: [[SUCCESS]]
 // CHECK: [[METHOD2:%.*]] = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %7 = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %8 = apply %7(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb3(%9 : $Derived):
   %10 = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
   %11 = apply %10(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb4:
   %13 = tuple ()
   br bb6(%13 : $())

 bb5:
   %14 = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %15 = apply %14(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb6(%17 : $()):
   br bb1

 // CHECK: bb4:
 // CHECK: tuple ()
 // CHECK: return

 bb7:
 // CHECK: checked_cast_br [exact] %0 : $Base to $Derived
   checked_cast_br [exact] %0 : $Base to $Derived, bb3, bb5
 }

 // CHECK-LABEL: sil @failing_checked_cast_br
 sil @failing_checked_cast_br : $@convention(method) (@guaranteed Base) -> () {
 bb0(%0 : $Base):
 // CHECK: [[METHOD:%.*]] = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %1 = class_method %0 : $Base, #Base.middle!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
 // CHECK: checked_cast_br [exact] %0 : $Base to $Base, [[SUCCESS:bb[0-9]+]], [[FAIL:bb[0-9]+]]
   checked_cast_br [exact] %0 : $Base to $Base, bb2, bb7

 // CHECK-LABEL: bb1
 bb1:
   %3 = tuple ()
   return %3 : $()

 bb2(%5 : $Base):
 // CHECK: [[SUCCESS]]
 // CHECK: [[METHOD2:%.*]] = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
   %7 = class_method %0 : $Base, #Base.inner!1 : (Base) -> () -> (), $@convention(method) (@guaranteed Base) -> ()
 // CHECK-NOT: checked_cast_br [exact] %0 : $Base to $Derived
 // CHECK: apply [[METHOD2]]
 // Check that checked_cast_br [exact] was replaced by a branch to the failure BB of the checked_cast_br.
 // This is because bb2 is reached via the success branch of the checked_cast_br [exact] from bb0.
 // It means that the exact dynamic type of %0 is $Base. Thus it cannot be $Derived.
 // CHECK: br bb1
   checked_cast_br [exact] %5 : $Base to $Derived, bb3, bb5

 bb3(%9 : $Derived):
   %10 = function_ref @_TFC3ccb4Base5innerfS0_FT_T_ : $@convention(method) (@guaranteed Base) -> ()
   %11 = apply %10(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb4:
   %13 = tuple ()
   br bb6(%13 : $())

 bb5:
   %15 = apply %7(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb4

 bb6(%17 : $()):
   br bb1

 bb7:
   %19 = apply %1(%0) : $@convention(method) (@guaranteed Base) -> ()
   br bb1
 }

 sil @unknown2 : $@convention(thin) () -> ()

 // CHECK-LABEL: no_checked_cast_br_threading_with_alloc_ref_stack
 // CHECK: checked_cast_br
 // CHECK: apply
 // CHECK: apply
 // CHECK: checked_cast_br
 // CHECK: apply
 // CHECK: apply
 // CHECK: return
 sil @no_checked_cast_br_threading_with_alloc_ref_stack : $@convention(method) (@guaranteed Base) -> () {
 bb0(%0 : $Base):
   %fu = function_ref @unknown : $@convention(thin) () -> ()
   %fu2 = function_ref @unknown2 : $@convention(thin) () -> ()
   checked_cast_br [exact] %0 : $Base to $Base, bb1, bb2

 bb1(%1 : $Base):
   apply %fu() : $@convention(thin) () -> ()
   br bb3

 bb2:
   apply %fu2() : $@convention(thin) () -> ()
   br bb3

 bb3:
   %a = alloc_ref [stack] $Base
   checked_cast_br [exact] %0 : $Base to $Base, bb4, bb5

 bb4(%2 : $Base):
   apply %fu() : $@convention(thin) () -> ()
   br bb6

 bb5:
   apply %fu2() : $@convention(thin) () -> ()
   br bb6

 bb6:
   dealloc_ref [stack] %a : $Base
   %r = tuple()
   return %r : $()
 }


 // CHECK-LABEL: sil @jumpthread_switch_enum
 // CHECK-NOT: switch_enum
 // CHECK: return

 sil @jumpthread_switch_enum : $@convention(thin) (Int32) -> Int32 {
 bb0(%0 : $Int32):
   %1 = integer_literal $Builtin.Int32, 0
   %2 = integer_literal $Builtin.Int32, 1
   %3 = struct_extract %0 : $Int32, #Int32._value
   %5 = integer_literal $Builtin.Int1, -1
   %6 = builtin "sadd_with_overflow_Int32"(%3 : $Builtin.Int32, %2 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %7 = tuple_extract %6 : $(Builtin.Int32, Builtin.Int1), 0
   %8 = tuple_extract %6 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %8 : $Builtin.Int1
   %11 = builtin "cmp_eq_Int32"(%2 : $Builtin.Int32, %7 : $Builtin.Int32) : $Builtin.Int1
   cond_br %11, bb8(%1 : $Builtin.Int32), bb2

 bb2:
   %14 = integer_literal $Builtin.Int32, 2
   %15 = struct $Int32 (%2 : $Builtin.Int32)
   %16 = enum $Optional<Int32>, #Optional.some!enumelt.1, %15 : $Int32
   br bb3(%1 : $Builtin.Int32, %14 : $Builtin.Int32, %16 : $Optional<Int32>)

 bb3(%18 : $Builtin.Int32, %19 : $Builtin.Int32, %20 : $Optional<Int32>):
   switch_enum %20 : $Optional<Int32>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5

 bb4:
   %22 = unchecked_enum_data %20 : $Optional<Int32>, #Optional.some!enumelt.1
   %23 = struct_extract %22 : $Int32, #Int32._value
   %24 = builtin "sadd_with_overflow_Int32"(%18 : $Builtin.Int32, %23 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %25 = tuple_extract %24 : $(Builtin.Int32, Builtin.Int1), 0
   %26 = tuple_extract %24 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %26 : $Builtin.Int1
   %28 = struct $Int32 (%19 : $Builtin.Int32)
   %29 = builtin "cmp_eq_Int32"(%19 : $Builtin.Int32, %7 : $Builtin.Int32) : $Builtin.Int1
   cond_br %29, bb6, bb7

 bb5:
   cond_fail %5 : $Builtin.Int1
   unreachable

 bb6:
   br bb8(%25 : $Builtin.Int32)

 bb7:
   %34 = builtin "sadd_with_overflow_Int32"(%19 : $Builtin.Int32, %2 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %35 = tuple_extract %34 : $(Builtin.Int32, Builtin.Int1), 0
   %36 = tuple_extract %34 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %36 : $Builtin.Int1
   %38 = enum $Optional<Int32>, #Optional.some!enumelt.1, %28 : $Int32
   br bb3(%25 : $Builtin.Int32, %35 : $Builtin.Int32, %38 : $Optional<Int32>)

 bb8(%40 : $Builtin.Int32):
   %41 = struct $Int32 (%40 : $Builtin.Int32)
   return %41 : $Int32
 }

 // CHECK-LABEL: sil @jumpthread_switch_enum2
 // CHECK-NOT: switch_enum
 // CHECK: return

 sil @jumpthread_switch_enum2 : $@convention(thin) (Int32) -> Int32 {
 bb0(%0 : $Int32):
   %1 = integer_literal $Builtin.Int32, 0
   %3 = enum $Optional<Int32>, #Optional.some!enumelt.1, %0 : $Int32
   %4 = enum $Optional<Int32>, #Optional.none!enumelt
   br bb1(%1 : $Builtin.Int32, %3 : $Optional<Int32>)

 bb1(%6 : $Builtin.Int32, %7 : $Optional<Int32>):
   switch_enum %7 : $Optional<Int32>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb3

 bb2:
   %9 = unchecked_enum_data %7 : $Optional<Int32>, #Optional.some!enumelt.1
   %10 = struct_extract %9 : $Int32, #Int32._value
   %11 = integer_literal $Builtin.Int1, 0
   %12 = builtin "sadd_with_overflow_Int32"(%6 : $Builtin.Int32, %10 : $Builtin.Int32, %11 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %13 = tuple_extract %12 : $(Builtin.Int32, Builtin.Int1), 0
   br bb1(%13 : $Builtin.Int32, %4 : $Optional<Int32>)

 bb3:
   %17 = struct $Int32 (%6 : $Builtin.Int32)
   return %17 : $Int32
 }

 // CHECK-LABEL: sil @jumpthread_switch_enum3
 // CHECK: switch_enum %0 : $Optional<Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2
 // CHECK: bb1:
 // CHECK-NEXT: switch_enum
 // CHECK: bb2:
 // CHECK-NEXT: br bb5
 // CHECK: bb3:
 // CHECK-NEXT: br bb5
 // CHECK: bb4:
 // CHECK-NEXT: br bb6
 // CHECK: bb5:
 // CHECK-NEXT: br bb6
 // CHECK: bb6({{.*}}):
 // CHECK-NEXT: return
 sil @jumpthread_switch_enum3 : $@convention(thin) (Optional<Int32>) -> Int32 {
 bb0(%0 : $Optional<Int32>):
   %10 = integer_literal $Builtin.Int32, 2
   %11 = struct $Int32 (%10 : $Builtin.Int32)
   %20 = integer_literal $Builtin.Int32, 3
   %21 = struct $Int32 (%20 : $Builtin.Int32)
   switch_enum %0 : $Optional<Int32>, case #Optional.none!enumelt: bb1, case #Optional.some!enumelt.1: bb2

 bb1:
   br bb3(undef : $Optional<Int32>)

 bb2:
   br bb3(%0 : $Optional<Int32>)

 bb3(%30 : $Optional<Int32>):
   switch_enum %30 : $Optional<Int32>, case #Optional.none!enumelt: bb4, case #Optional.some!enumelt.1: bb5

 bb4:
   br bb6(%21 : $Int32)

 bb5:
   br bb6(%11 : $Int32)

 bb6(%r : $Int32):
   return %r : $Int32
 }

 // CHECK-LABEL: sil @jumpthread_switch_enum4
 // CHECK:      bb0:
 // CHECK-NEXT:   cond_br undef, bb1, bb2
 // CHECK:      bb1:
 // CHECK-NEXT:   cond_br undef, bb3, bb4
 // CHECK:      bb2:
 // CHECK:        integer_literal {{.*}}, 27
 // CHECK:        br bb5
 // CHECK:      bb3:
 // CHECK:        br bb4
 // CHECK:      bb4:
 // CHECK:        integer_literal {{.*}}, 28
 // CHECK:        br bb5
 // CHECK:      bb5({{.*}}):
 // CHECK-NEXT:   return
 sil @jumpthread_switch_enum4 : $@convention(thin) () -> Builtin.Int32 {
 bb0:
   cond_br undef, bb1, bb2

 bb1:
   %4 = enum $Optional<Int32>, #Optional.none!enumelt
   cond_br undef, bb3(%4 : $Optional<Int32>), bb4(%4 : $Optional<Int32>)

 bb2:
   %6 = integer_literal $Builtin.Int32, 0
   %7 = struct $Int32 (%6 : $Builtin.Int32)
   %8 = enum $Optional<Int32>, #Optional.some!enumelt.1, %7 : $Int32
   br bb3(%8 : $Optional<Int32>)


 bb3(%10 : $Optional<Int32>):
   // Some instruction which is not "trivial"
   %c1 = builtin "assert_configuration"() : $Builtin.Int32
   br bb4(%10 : $Optional<Int32>)


 bb4(%13 : $Optional<Int32>):
   switch_enum %13 : $Optional<Int32>, case #Optional.some!enumelt.1: bb5, case #Optional.none!enumelt: bb6

 bb5:
   %r1 = integer_literal $Builtin.Int32, 27
   %c2 = builtin "assert_configuration"() : $Builtin.Int32
   br bb7(%r1 : $Builtin.Int32)

 bb6:
   %r2 = integer_literal $Builtin.Int32, 28
   %c3 = builtin "assert_configuration"() : $Builtin.Int32
   br bb7(%r2 : $Builtin.Int32)

 bb7(%r : $Builtin.Int32):
   return %r : $Builtin.Int32
 }

 // CHECK-LABEL: sil @jumpthread_switch_enum5
 // CHECK:      bb0:
 // CHECK:        br bb1
 // CHECK:      bb1({{.*}}):
 // CHECK-NEXT:   cond_br undef, bb2, bb3
 // CHECK:      bb2:
 // CHECK:        br bb1
 // CHECK:      bb3:
 // CHECK-NEXT:   tuple
 // CHECK-NEXT:   return
 sil @jumpthread_switch_enum5 : $@convention(thin) () -> () {
 bb0:
   %6 = integer_literal $Builtin.Int32, 0
   %7 = struct $Int32 (%6 : $Builtin.Int32)
   %8 = enum $Optional<Int32>, #Optional.some!enumelt.1, %7 : $Int32
   br bb1(%8 : $Optional<Int32>)

 bb1(%13 : $Optional<Int32>):
   switch_enum %13 : $Optional<Int32>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb3

 bb2:
   br bb4

 bb3:
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   br bb4

 bb4:
   cond_br undef, bb1(%13 : $Optional<Int32>), bb5

 bb5:
   %r = tuple ()
   return %r : $()
 }

 /// Don't jumpthread blocks that contain objc method instructions. We don't
 /// support building phis with objc method values.

 class Bar {
   init()
   @objc func foo()
 }


 // CHECK-LABEL: @dont_jumpthread_switch_enum
 // CHECK: objc_method
 // CHECK: switch_enum
 // CHECK: return

 sil @dont_jumpthread_switch_enum : $@convention(thin) (Int32) -> Int32 {
 bb0(%0 : $Int32):
   %100 = alloc_ref $Bar
   %1 = integer_literal $Builtin.Int32, 0
   %2 = integer_literal $Builtin.Int32, 1
   %3 = struct_extract %0 : $Int32, #Int32._value
   %5 = integer_literal $Builtin.Int1, -1
   %6 = builtin "sadd_with_overflow_Int32"(%3 : $Builtin.Int32, %2 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %7 = tuple_extract %6 : $(Builtin.Int32, Builtin.Int1), 0
   %8 = tuple_extract %6 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %8 : $Builtin.Int1
   %11 = builtin "cmp_eq_Int32"(%2 : $Builtin.Int32, %7 : $Builtin.Int32) : $Builtin.Int1
   cond_br %11, bb8(%1 : $Builtin.Int32), bb2

 bb2:
   %14 = integer_literal $Builtin.Int32, 2
   %15 = struct $Int32 (%2 : $Builtin.Int32)
   %16 = enum $Optional<Int32>, #Optional.some!enumelt.1, %15 : $Int32
   br bb3(%1 : $Builtin.Int32, %14 : $Builtin.Int32, %16 : $Optional<Int32>)

 bb3(%18 : $Builtin.Int32, %19 : $Builtin.Int32, %20 : $Optional<Int32>):
   %101 = objc_method %100 : $Bar, #Bar.foo!1.foreign : (Bar) -> () -> (), $@convention(objc_method) (Bar) -> ()
   switch_enum %20 : $Optional<Int32>, case #Optional.some!enumelt.1: bb4, case #Optional.none!enumelt: bb5

 bb4:
   %102 = apply %101(%100) : $@convention(objc_method) (Bar) -> ()
   %22 = unchecked_enum_data %20 : $Optional<Int32>, #Optional.some!enumelt.1
   %23 = struct_extract %22 : $Int32, #Int32._value
   %24 = builtin "sadd_with_overflow_Int32"(%18 : $Builtin.Int32, %23 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %25 = tuple_extract %24 : $(Builtin.Int32, Builtin.Int1), 0
   %26 = tuple_extract %24 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %26 : $Builtin.Int1
   %28 = struct $Int32 (%19 : $Builtin.Int32)
   %29 = builtin "cmp_eq_Int32"(%19 : $Builtin.Int32, %7 : $Builtin.Int32) : $Builtin.Int1
   cond_br %29, bb6, bb7

 bb5:
   cond_fail %5 : $Builtin.Int1
   unreachable

 bb6:
   br bb8(%25 : $Builtin.Int32)

 bb7:
   %34 = builtin "sadd_with_overflow_Int32"(%19 : $Builtin.Int32, %2 : $Builtin.Int32, %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %35 = tuple_extract %34 : $(Builtin.Int32, Builtin.Int1), 0
   %36 = tuple_extract %34 : $(Builtin.Int32, Builtin.Int1), 1
   cond_fail %36 : $Builtin.Int1
   %38 = enum $Optional<Int32>, #Optional.none!enumelt
   br bb3(%25 : $Builtin.Int32, %35 : $Builtin.Int32, %38 : $Optional<Int32>)

 bb8(%40 : $Builtin.Int32):
   %41 = struct $Int32 (%40 : $Builtin.Int32)
   return %41 : $Int32
 }

 enum OneCase {
   case First
 }

 enum TwoCase {
   case First
   case Second
 }

 enum ThreeCase {
   case First
   case Second
   case Third
 }

 sil @unknown : $@convention(thin) () -> ()
 sil @int1_user : $@convention(thin) (Builtin.Int1) -> ()

 // CHECK-LABEL: sil @select_enum_case_canonicalization : $@convention(thin) (OneCase, TwoCase, TwoCase, ThreeCase, ThreeCase, ThreeCase) -> () {
 // CHECK: bb0([[ONE_1:%.*]] : $OneCase, [[TWO_1:%.*]] : $TwoCase, [[TWO_2:%.*]] : $TwoCase, [[THREE_1:%.*]] : $ThreeCase, [[THREE_2:%.*]] : $ThreeCase, [[THREE_3:%.*]] : $ThreeCase):
 // CHECK: [[TAG1:%.*]] = select_enum [[ONE_1]] : $OneCase, case #OneCase.First!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG2:%.*]] = select_enum [[TWO_1]] : $TwoCase, case #TwoCase.First!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG3:%.*]] = select_enum [[TWO_2]] : $TwoCase, case #TwoCase.First!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG3_OLD:%.*]] = select_enum [[TWO_2]] : $TwoCase, case #TwoCase.Second!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG4:%.*]] = select_enum [[THREE_1]] : $ThreeCase, case #ThreeCase.First!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG5:%.*]] = select_enum [[THREE_2]] : $ThreeCase, case #ThreeCase.Second!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: [[TAG6:%.*]] = select_enum [[THREE_3]] : $ThreeCase, case #ThreeCase.Third!enumelt: [[TRUE:%[0-9]+]]
 // CHECK: cond_br [[TAG1]], bb1, bb6
 // CHECK: cond_br [[TAG2]], bb2, bb3
 // CHECK: [[INT1_USER_FUN:%.*]] = function_ref @int1_user : $@convention(thin) (Builtin.Int1) -> ()
 // CHECK: apply [[INT1_USER_FUN]]([[TAG3_OLD]])
 // CHECK: cond_br [[TAG3]], bb5, bb4
 // CHECK: cond_br [[TAG4]], bb7, bb8
 // CHECK: cond_br [[TAG5]], bb9, bb10
 // CHECK: cond_br [[TAG6]], bb11, bb12
 sil @select_enum_case_canonicalization : $@convention(thin) (OneCase, TwoCase, TwoCase, ThreeCase, ThreeCase, ThreeCase) -> () {
 bb0(%0 : $OneCase, %1 : $TwoCase, %2 : $TwoCase, %3 : $ThreeCase, %4 : $ThreeCase, %5 : $ThreeCase):
   %t = integer_literal $Builtin.Int1, 1
   %f = integer_literal $Builtin.Int1, 0
   %6 = select_enum %0 : $OneCase, case #OneCase.First!enumelt: %t, default %f : $Builtin.Int1
   %7 = select_enum %1 : $TwoCase, case #TwoCase.First!enumelt: %t, default %f : $Builtin.Int1
   %8 = select_enum %2 : $TwoCase, case #TwoCase.Second!enumelt: %t, default %f : $Builtin.Int1
   %9 = select_enum %3 : $ThreeCase, case #ThreeCase.First!enumelt: %t, default %f : $Builtin.Int1
   %10 = select_enum %4 : $ThreeCase, case #ThreeCase.Second!enumelt: %t, default %f : $Builtin.Int1
   %11 = select_enum %5 : $ThreeCase, case #ThreeCase.Third!enumelt: %t, default %f : $Builtin.Int1
   %12 = function_ref @unknown : $@convention(thin) () -> ()
   cond_br %6, bb1a, bb1b

 bb1a:
   apply %12() : $@convention(thin) () -> ()
   cond_br %7, bb2a, bb3a

 bb2a:
   apply %12() : $@convention(thin) () -> ()
   %13 = function_ref @int1_user : $@convention(thin) (Builtin.Int1) -> ()
   apply %13(%8) : $@convention(thin) (Builtin.Int1) -> ()
   cond_br %8, bb4a, bb5a

 bb3a:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb4a:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb5a:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb1b:
   apply %12() : $@convention(thin) () -> ()
   cond_br %9, bb2b, bb3b

 bb2b:
   apply %12() : $@convention(thin) () -> ()
   cond_br %10, bb4b, bb5b

 bb3b:
   apply %12() : $@convention(thin) () -> ()
   cond_br %11, bb6b, bb7b

 bb4b:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb5b:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb6b:
   apply %12() : $@convention(thin) () -> ()
   br exit

 bb7b:
   apply %12() : $@convention(thin) () -> ()
   br exit

 exit:
   apply %12() : $@convention(thin) () -> ()
   %9999 = tuple()
   return %9999 : $()
 }

 // CHECK-LABEL: sil @dont_crash_jump_threading_single_case_switch_enums
 // CHECK-NOT: switch_enum
 // CHECK: } // end sil function
 sil @dont_crash_jump_threading_single_case_switch_enums : $@convention(thin) () -> () {
 bb0:
   br bb1(undef : $OneCase)

 bb1(%19 : $OneCase):
   switch_enum %19 : $OneCase, case #OneCase.First!enumelt.1: bb2

 bb2:
   switch_enum %19 : $OneCase, case #OneCase.First!enumelt.1: bb3

 bb3:
   %48 = enum $OneCase, #OneCase.First!enumelt.1
   cond_br undef, bb6, bb7

 bb6:
   %72 = tuple ()
   return %72 : $()

 bb7:
   br bb1(%48 : $OneCase)
 }


 enum IntEnum : Int32 {
   case E0
   case E1
   case E2
 }

 // CHECK-LABEL: sil @create_select_value : $@convention(thin) (Builtin.Int32) -> Optional<IntEnum> {
 // CHECK-DAG: [[X2:%[0-9]+]] = integer_literal $Builtin.Int32, 0
 // CHECK-DAG: [[X5:%[0-9]+]] = enum $Optional<IntEnum>, #Optional.none!enumelt
 // CHECK-DAG: [[X6:%[0-9]+]] = integer_literal $Builtin.Int32, 2
 // CHECK-DAG: [[X7:%[0-9]+]] = enum $IntEnum, #IntEnum.E2!enumelt
 // CHECK-DAG: [[X8:%[0-9]+]] = enum $Optional<IntEnum>, #Optional.some!enumelt.1, [[X7]] : $IntEnum
 // CHECK-DAG: [[X9:%[0-9]+]] = integer_literal $Builtin.Int32, 1
 // CHECK-DAG: [[X10:%[0-9]+]] = enum $IntEnum, #IntEnum.E1!enumelt
 // CHECK-DAG: [[X11:%[0-9]+]] = enum $Optional<IntEnum>, #Optional.some!enumelt.1, [[X10]] : $IntEnum
 // CHECK-DAG: [[X12:%[0-9]+]] = enum $IntEnum, #IntEnum.E0!enumelt
 // CHECK-DAG: [[X13:%[0-9]+]] = enum $Optional<IntEnum>, #Optional.some!enumelt.1, [[X12]] : $IntEnum
 // CHECK-DAG: [[X14:%[0-9]+]] = select_value %0 : $Builtin.Int32, case [[X6]]: [[X8]], case [[X9]]: [[X11]], case [[X2]]: [[X13]], default [[X5]] : $Optional<IntEnum>
 // CHECK-DAG: return [[X14]] : $Optional<IntEnum>
 sil @create_select_value : $@convention(thin) (Builtin.Int32) -> Optional<IntEnum> {
 bb0(%0 : $Builtin.Int32):
   %2 = integer_literal $Builtin.Int32, 0
   %4 = builtin "cmp_eq_Int32"(%2 : $Builtin.Int32, %0 : $Builtin.Int32) : $Builtin.Int1
   cond_br %4, bb1, bb2

 bb1:
   %6 = enum $IntEnum, #IntEnum.E0!enumelt
   %7 = enum $Optional<IntEnum>, #Optional.some!enumelt.1, %6 : $IntEnum
   br bb7(%7 : $Optional<IntEnum>)

 bb2:
   %9 = integer_literal $Builtin.Int32, 1
   %10 = builtin "cmp_eq_Int32"(%9 : $Builtin.Int32, %0 : $Builtin.Int32) : $Builtin.Int1
   cond_br %10, bb3, bb4

 bb3:
   %12 = enum $IntEnum, #IntEnum.E1!enumelt
   %13 = enum $Optional<IntEnum>, #Optional.some!enumelt.1, %12 : $IntEnum
   br bb7(%13 : $Optional<IntEnum>)

 bb4:
   %15 = integer_literal $Builtin.Int32, 2
   %16 = builtin "cmp_eq_Int32"(%15 : $Builtin.Int32, %0 : $Builtin.Int32) : $Builtin.Int1
   cond_br %16, bb5, bb6

 bb5:
   %18 = enum $IntEnum, #IntEnum.E2!enumelt
   %19 = enum $Optional<IntEnum>, #Optional.some!enumelt.1, %18 : $IntEnum
   br bb7(%19 : $Optional<IntEnum>)

 bb6:
   %21 = enum $Optional<IntEnum>, #Optional.none!enumelt
   br bb7(%21 : $Optional<IntEnum>)

 bb7(%23 : $Optional<IntEnum>):
   return %23 : $Optional<IntEnum>
 }


 class B {}
 class E : B {}

 // CHECK-LABEL: sil @checked_cast_anyobject_metatypeinst_to_class
 // CHECK: bb0
 // CHECK-NOT: checked_cast
 // CHECK-NOT: bb1
 // CHECK: [[RET:%.*]] = tuple ()
 // CHECK: return [[RET]] : $()

 sil @checked_cast_anyobject_metatypeinst_to_class : $@convention(thin)() -> () {
 bb0:
   %0 = metatype $@thick AnyObject.Protocol
   checked_cast_br %0 : $@thick AnyObject.Protocol to $@thick B.Type, bb1, bb2

 bb1(%3 : $@thick B.Type):
   br bb3
 bb2:
   br bb3

 bb3:
  %2 = tuple()
  return %2 : $()
 }


 // CHECK-LABEL: sil @remove_cond_fail_trueblock
 // CHECK: bb0([[COND:%.*]] :
 // CHECK-NOT: bb
 // CHECK: cond_fail [[COND]]
 // CHECK-NOT: bb
 // CHECK: return
 sil @remove_cond_fail_trueblock : $@convention(thin)(Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1):
   cond_br %0, bb1, bb2
 bb1:
   %1 = integer_literal $Builtin.Int1, -1
   cond_fail %1 : $Builtin.Int1
   unreachable
 bb2:
   %2 = tuple()
   return %2 : $()
 }

 // CHECK-LABEL: sil @remove_cond_fail_falseblock
 // CHECK: bb0([[COND:%.*]] :
 // CHECK-NOT: bb
 // CHECK: [[TRUE:%.*]] = integer_literal $Builtin.Int1, -1
 // CHECK-NOT: bb
 // CHECK: [[NOTCOND:%.*]] = builtin "xor_Int1"([[COND]]{{.*}}, [[TRUE]]
 // CHECK: cond_fail [[NOTCOND]]
 // CHECK-NOT: bb
 // CHECK: return
 sil @remove_cond_fail_falseblock : $@convention(thin)(Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1):
   cond_br %0, bb2, bb1

 bb1:
   %1 = integer_literal $Builtin.Int1, -1
   cond_fail %1 : $Builtin.Int1
   unreachable

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

 // CHECK-LABEL: sil @dont_remove_cond_fail_wrong_const
 // CHECK:      bb0(%0 : $Builtin.Int1):
 // CHECK-NEXT:   cond_br %0, bb1, bb2
 sil @dont_remove_cond_fail_wrong_const : $@convention(thin) (Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1):
   cond_br %0, bb1, bb2

 bb1:
   %i1 = integer_literal $Builtin.Int1, 0
   cond_fail %i1 : $Builtin.Int1
   br bb2

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

 // CHECK-LABEL: sil @remove_cond_fail_same_cond_in_true
 // CHECK: bb0([[COND:%[0-9]*]]
 // CHECK-NOT: bb
 // CHECK: cond_fail [[COND]]
 // CHECK: bb1:
 // CHECK: return
 sil @remove_cond_fail_same_cond_in_true : $@convention(thin)(Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   cond_br %0, bb1, bb2
 bb1:
   cond_fail %0 : $Builtin.Int1
   unreachable
 bb2:
   // Make bb1 not dominated from bb0 to prevent that dominator based
   // simplification does the same thing.
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   cond_br %1, bb1, bb3
 bb3:
   %2 = tuple()
   return %2 : $()
 }

 // CHECK-LABEL: sil @remove_cond_fail_same_cond_in_false
 // CHECK: bb0([[COND:%[0-9]*]]
 // CHECK-NOT: bb
 // CHECK: [[INV:%[0-9]*]] = builtin "xor_Int1"([[COND]]
 // CHECK-NOT: bb
 // CHECK: cond_fail [[INV]]
 // CHECK: bb1:
 // CHECK: return
 sil @remove_cond_fail_same_cond_in_false : $@convention(thin)(Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   cond_br %0, bb2, bb1
 bb1:
   %i1 = integer_literal $Builtin.Int1, -1
   %i2 = builtin "xor_Int1"(%0 : $Builtin.Int1, %i1 : $Builtin.Int1) : $Builtin.Int1
   cond_fail %i2 : $Builtin.Int1
   unreachable
 bb2:
   // Make bb1 not dominated from bb0 to prevent that dominator based
   // simplification does the same thing.
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   cond_br %1, bb1, bb3
 bb3:
   %2 = tuple()
   return %2 : $()
 }

 // CHECK-LABEL: sil @remove_cond_fail_same_cond_in_false2
 // CHECK: bb0([[COND:%[0-9]*]]
 // CHECK-NOT: bb
 // CHECK: cond_fail [[COND]]
 // CHECK: bb1:
 // CHECK: return
 sil @remove_cond_fail_same_cond_in_false2 : $@convention(thin)(Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   %i1 = integer_literal $Builtin.Int1, -1
   %i2 = builtin "xor_Int1"(%0 : $Builtin.Int1, %i1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %i2, bb2, bb1
 bb1:
   cond_fail %0 : $Builtin.Int1
   unreachable
 bb2:
   // Make bb1 not dominated from bb0 to prevent that dominator based
   // simplification does the same thing.
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   cond_br %1, bb1, bb3
 bb3:
   %2 = tuple()
   return %2 : $()
 }

 // CHECK-LABEL: sil @dont_remove_cond_fail_same_cond_in_false
 // CHECK: bb0([[COND:%[0-9]*]]
 // CHECK-NEXT: cond_br
 // CHECK: bb1:
 // CHECK-NEXT: cond_fail [[COND]]
 // CHECK: return
 sil @dont_remove_cond_fail_same_cond_in_false : $@convention(thin)(Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   cond_br %0, bb2, bb1
 bb1:
   cond_fail %0 : $Builtin.Int1
   unreachable
 bb2:
   // Make bb1 not dominated from bb0.
   %55 = function_ref @external_f : $@convention(thin) () -> ()
   apply %55() : $@convention(thin) () -> ()
   cond_br %1, bb1, bb3
 bb3:
   %2 = tuple()
   return %2 : $()
 }

 // CHECK-LABEL: sil @move_cond_fail
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   [[X:%[0-9]*]] = integer_literal $Builtin.Int1, -1
 // CHECK-NEXT:   cond_fail [[X]]
 // CHECK-NEXT:   br bb3
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   cond_fail %1
 // CHECK-NEXT:   br bb3
 // CHECK:      bb3:
 // CHECK-NOT:    cond_fail
 // CHECK:        return
 sil @move_cond_fail : $@convention(thin) (Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   %i1 = integer_literal $Builtin.Int1, -1
   br bb3(%i1 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%1 : $Builtin.Int1)

 bb3(%a3 : $Builtin.Int1):
   cond_fail %a3 : $Builtin.Int1
   %r = tuple ()
   return %r : $()
 }

 // CHECK-LABEL: sil @move_cond_fail_inverted
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   [[X:%[0-9]*]] = integer_literal $Builtin.Int1, -1
 // CHECK-NEXT:   [[Y:%[0-9]*]] = builtin "xor_Int1"(%2 : $Builtin.Int1, [[X]] : $Builtin.Int1)
 // CHECK-NEXT:   cond_fail [[Y]]
 // CHECK-NEXT:   br bb3
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   [[R:%[0-9]*]] = integer_literal $Builtin.Int1, -1
 // CHECK-NEXT:   [[S:%[0-9]*]] = builtin "xor_Int1"(%1 : $Builtin.Int1, [[R]] : $Builtin.Int1)
 // CHECK-NEXT:   cond_fail [[S]]
 // CHECK-NEXT:   br bb3
 // CHECK:      bb3({{.*}}):
 // CHECK-NOT:    cond_fail
 // CHECK:        return
 sil @move_cond_fail_inverted : $@convention(thin) (Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   %2 = integer_literal $Builtin.Int1, -1
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%2 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%1 : $Builtin.Int1)

 bb3(%a3 : $Builtin.Int1):
   %v1 = builtin "xor_Int1"(%a3 : $Builtin.Int1, %2 : $Builtin.Int1) : $Builtin.Int1
   cond_fail %v1 : $Builtin.Int1
   %r = tuple ()
   return %r : $()
 }

 // CHECK-LABEL: sil @dont_move_cond_fail_no_const
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   br bb3
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   br bb3
 // CHECK:      bb3({{.*}}):
 // CHECK-NEXT:   cond_fail
 sil @dont_move_cond_fail_no_const : $@convention(thin) (Builtin.Int1, Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1, %2 : $Builtin.Int1):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%1 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%2 : $Builtin.Int1)

 bb3(%a3 : $Builtin.Int1):
   cond_fail %a3 : $Builtin.Int1
   %r = tuple ()
   return %r : $()
 }

 // CHECK-LABEL: sil @dont_move_cond_fail_no_postdom
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   integer_literal
 // CHECK-NEXT:   br bb4
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   cond_br
 // CHECK:      bb3:
 // CHECK:        br bb4
 // CHECK:      bb4({{.*}}):
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   cond_fail
 sil @dont_move_cond_fail_no_postdom : $@convention(thin) (Builtin.Int1, Builtin.Int1, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1, %2 : $Builtin.Int1):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   %i1 = integer_literal $Builtin.Int1, -1
   br bb3(%i1 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   cond_br %2, bb3(%1 : $Builtin.Int1), bb4

 bb3(%a3 : $Builtin.Int1):
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   cond_fail %a3 : $Builtin.Int1
   br bb4

 bb4:
   %r = tuple ()
   return %r : $()
 }

 // CHECK-LABEL: sil @dont_move_cond_fail_multiple_uses
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   integer_literal
 // CHECK-NEXT:   br bb3
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   br bb3
 // CHECK:      bb3({{.*}}):
 // CHECK-NEXT:   cond_fail
 sil @dont_move_cond_fail_multiple_uses : $@convention(thin) (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   %i1 = integer_literal $Builtin.Int1, -1
   br bb3(%i1 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%1 : $Builtin.Int1)

 bb3(%a3 : $Builtin.Int1):
   cond_fail %a3 : $Builtin.Int1
   return %a3 : $Builtin.Int1
 }

 // CHECK-LABEL: sil @dont_move_cond_fail_multiple_uses2
 // CHECK:      bb1:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   br bb3
 // CHECK:      bb2:
 // CHECK-NEXT:   apply
 // CHECK-NEXT:   br bb3
 // CHECK:      bb3({{.*}}):
 // CHECK-NEXT:   builtin "xor_Int1"
 // CHECK-NEXT:   cond_fail
 // CHECK-NEXT:   return
 sil @dont_move_cond_fail_multiple_uses2 : $@convention(thin) (Builtin.Int1, Builtin.Int1) -> Builtin.Int1 {
 bb0(%0 : $Builtin.Int1, %1 : $Builtin.Int1):
   %f1 = function_ref @external_f : $@convention(thin) () -> ()
   %i1 = integer_literal $Builtin.Int1, -1
   cond_br %0, bb2, bb1

 bb1:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%i1 : $Builtin.Int1)

 bb2:
   apply %f1() : $@convention(thin) () -> () // prevent other CFG optimizations
   br bb3(%1 : $Builtin.Int1)

 bb3(%a3 : $Builtin.Int1):
   %v1 = builtin "xor_Int1"(%a3 : $Builtin.Int1, %i1 : $Builtin.Int1) : $Builtin.Int1
   cond_fail %v1 : $Builtin.Int1
   return %v1 : $Builtin.Int1
 }


 // CHECK-LABEL: sil @successful_checked_cast_br_on_alloc_ref
 // CHECK: bb0
 // CHECK-NEXT: alloc_ref
 // CHECK-NOT: checked_cast_br
 // CHECK-NOT: bb1
 // CHECK: integer_literal $Builtin.Int32, 1
 // CHECK: strong_release
 // CHECK: return
 sil @successful_checked_cast_br_on_alloc_ref : $() -> Builtin.Int32 {
 bb0:
   %1 = alloc_ref $B
   checked_cast_br [exact] %1 : $B to $B, bb1, bb2

 bb1(%2 : $B):
   %3 = integer_literal $Builtin.Int32, 1
   br bb3 (%3 : $Builtin.Int32)

 bb2:
   %5 = integer_literal $Builtin.Int32, 2
   br bb3 (%5 : $Builtin.Int32)

 bb3 (%10: $Builtin.Int32):
   strong_release %1 : $B
   return %10 : $Builtin.Int32
 }

 // CHECK-LABEL: sil @failing_checked_cast_br_on_alloc_ref
 // CHECK: bb0
 // CHECK-NEXT: alloc_ref
 // CHECK-NOT: checked_cast_br
 // CHECK-NOT: bb1
 // CHECK: integer_literal $Builtin.Int32, 2
 // CHECK: strong_release
 // CHECK: return
 sil @failing_checked_cast_br_on_alloc_ref : $() -> Builtin.Int32 {
 bb0:
   %1 = alloc_ref $E
   %2 = upcast %1 : $E to $B
   checked_cast_br [exact] %2 : $B to $B, bb1, bb2

 bb1(%3 : $B):
   %4 = integer_literal $Builtin.Int32, 1
   br bb3 (%4 : $Builtin.Int32)

 bb2:
   %5 = integer_literal $Builtin.Int32, 2
   br bb3 (%5 : $Builtin.Int32)

 bb3 (%10: $Builtin.Int32):
   strong_release %1 : $E
   return %10 : $Builtin.Int32
 }

 @objc protocol ObjcProto { func foo() }

 // CHECK-LABEL: sil @thread_objc_method_call_succ_block
 // CHECK: bb0
 // CHECK:  cond_br {{.*}}, bb1, bb2
 // CHECK: bb1
 // CHECK:  objc_method
 // CHECK:  apply
 // CHECK:  strong_release
 // CHECK:  cond_br {{.*}}, bb3, bb4
 // CHECK: bb2
 // CHECK:  strong_release
 // CHECK:  cond_br {{.*}}, bb3, bb4
 // CHECK: bb3
 // CHECK:  cond_fail
 // CHECK:  br bb4
 // CHECK: bb4:
 // CHECK:  strong_release
 // CHECK:  return

 sil @thread_objc_method_call_succ_block : $@convention(thin) <T where T : ObjcProto> (Builtin.Int1, @owned T, Builtin.Int1) -> () {
 bb0(%0: $Builtin.Int1, %1 : $T, %2 : $Builtin.Int1):
   strong_retain %1 : $T
   cond_br %0, bb1 , bb2

 bb1:
   %3 = objc_method %1 : $T, #ObjcProto.foo!1.foreign, $@convention(objc_method) <τ_0_0 where τ_0_0 : ObjcProto> (τ_0_0) -> ()
   %4 = apply %3<T>(%1) : $@convention(objc_method) <τ_0_0 where τ_0_0 : ObjcProto> (τ_0_0) -> ()
   br bb2

 bb2:
   strong_release %1 : $T
   cond_br %2, bb3, bb4

 bb3:
  cond_fail %0 : $Builtin.Int1
  br bb4

 bb4:
   strong_release %1 : $T
   %41 = tuple ()
   return %41 : $()
 }

 sil @f_use : $@convention(thin) (Builtin.Int32) -> ()

 // CHECK-LABEL: sil @switch_enum_jumpthreading_bug
 // CHECK: bb1:
 // CHECK:  [[INVADD:%.*]] = builtin "sadd
 // CHECK:  [[EXT:%.*]] = tuple_extract [[INVADD]]
 // CHECK:  switch_enum {{.*}} case #Optional.some!enumelt.1: bb3

 // CHECK: bb3{{.*}}
 // CHECK:  br bb4({{.*}} : $Builtin.Int32, %2 : $Builtin.Int32, [[EXT]]

 // CHECK: bb4({{.*}} : $Builtin.Int32, [[CUR:%.*]] : $Builtin.Int32, [[NEXT:%.*]] : $Builtin.Int32
 // CHECK:  [[F:%.*]] = function_ref @f
 // CHECK:  apply [[F]]([[CUR]])
 // CHECK:  cond_br {{.*}}, bb5, bb6

 // CHECK: bb5:
 // CHECK:   [[VARADD:%.*]] = builtin "sadd_with_overflow_Int32"([[NEXT]] : $Builtin.Int32
 // CHECK:   [[NEXT2:%.*]] = tuple_extract [[VARADD]]
 // CHECK:   br bb4({{.*}} : $Builtin.Int32, [[NEXT]] : $Builtin.Int32, [[NEXT2]]


 sil @switch_enum_jumpthreading_bug : $@convention(thin) (Optional<Builtin.Int32>, Builtin.Int1, Builtin.Int32, Builtin.Int1) -> Builtin.Int32 {
 bb0(%0 : $Optional<Builtin.Int32>, %1 : $Builtin.Int1, %2: $Builtin.Int32, %3 : $Builtin.Int1):
   cond_br %1, bb2, bb10

 bb2:
  br bb3(%2 : $Builtin.Int32, %0 : $Optional<Builtin.Int32>)

 bb3(%10 : $Builtin.Int32, %7 : $Optional<Builtin.Int32>):
   %4 = integer_literal $Builtin.Int32, 1
   %5 = integer_literal $Builtin.Int1, -1
   %6 = builtin "sadd_with_overflow_Int32"(%10 : $Builtin.Int32, %4 : $Builtin.Int32,  %5 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1)
   %16 = tuple_extract %6 : $(Builtin.Int32, Builtin.Int1), 0
   switch_enum %7 : $Optional<Builtin.Int32>, case #Optional.some!enumelt.1: bb5, case #Optional.none!enumelt: bb4

 bb4:
  cond_fail %5 : $Builtin.Int1
  unreachable

 bb5(%9 : $Builtin.Int32):
   %f = function_ref @f_use : $@convention(thin) (Builtin.Int32) -> ()
   %a = apply %f(%10) : $@convention(thin) (Builtin.Int32) -> ()
   cond_br %3, bb6, bb10

 bb6:
   %8 = enum $Optional<Builtin.Int32>, #Optional.some!enumelt.1, %9 : $Builtin.Int32
   br bb3(%16 : $Builtin.Int32, %8 : $Optional<Builtin.Int32>)

 bb10:
  br bb11(%2: $Builtin.Int32)

 bb11(%100 : $Builtin.Int32):
   return %100 : $Builtin.Int32
 }

 sil @a : $@convention(thin) () -> ()
 sil @b : $@convention(thin) () -> ()
 sil @c : $@convention(thin) () -> ()
 sil @d : $@convention(thin) () -> ()

 // CHECK-LABEL: sil @jump_thread_diamond
 // CHECK: bb1:
 // CHECK:   [[A:%.*]] = function_ref @a
 // CHECK:   apply [[A]]
 // CHECK:   [[C:%.*]] = function_ref @c
 // CHECK:   apply [[C]]
 // CHECK:   br bb3
 // CHECK: bb2:
 // CHECK:   [[B:%.*]] = function_ref @b
 // CHECK:   apply [[B]]
 // CHECK:   [[D:%.*]] = function_ref @d
 // CHECK:   apply [[D]]
 // CHECK:   br bb3

 // CHECK: return
 sil @jump_thread_diamond : $@convention(thin) (Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1):
   %1 = integer_literal $Builtin.Int1, -1
   %2 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   %8 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   %9 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %8, bb1, bb2

 bb1:
   %10 = function_ref @a : $@convention(thin) () -> ()
   %11 = apply %10() : $@convention(thin) () -> ()
   br bb3

 bb2:
   %13 = function_ref @b : $@convention(thin) () -> ()
   %14 = apply %13() : $@convention(thin) () -> ()
   br bb3

 bb3:
   %19 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   %20 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   %21 = builtin "int_expect_Int1"(%0 : $Builtin.Int1, %1 : $Builtin.Int1) : $Builtin.Int1
   cond_br %21, bb4, bb5

 bb4:
   %23 = function_ref @c : $@convention(thin) () -> ()
   %24 = apply %23() : $@convention(thin) () -> ()
   br bb6

 bb5:
   %26 = function_ref @d : $@convention(thin) () -> ()
   %27 = apply %26() : $@convention(thin) () -> ()
   br bb6

 bb6:
   %29 = tuple ()
   return %29 : $()
 }

 enum AnEnum {
   case B(Builtin.Int32), C(Builtin.Int16)
 }

 sil @f : $@convention(thin) (Builtin.Int32) -> ()
 sil @f2 : $@convention(thin) (Builtin.Int16) -> ()

 // CHECK-LABEL: sil @jump_thread_switch_enum
 // CHECK: bb0([[ARG:%.*]] : $AnEnum):
 // CHECK:  [[F:%.*]] = function_ref @f : $@convention(thin) (Builtin.Int32) -> ()
 // CHECK:  [[F2:%.*]] = function_ref @f2 : $@convention(thin) (Builtin.Int16) -> ()
 // CHECK:  switch_enum [[ARG]] : $AnEnum, case #AnEnum.B!enumelt.1: bb1, case #AnEnum.C!enumelt.1: bb2

 // CHECK: bb1([[ARG2:%.*]] : $Builtin.Int32):
 // CHECK:  apply [[F]]([[ARG2]])
 // CHECK:  [[UED:%.*]] = unchecked_enum_data [[ARG]] : $AnEnum, #AnEnum.B!enumelt.1
 // CHECK:  apply [[F]]([[UED]])
 // CHECK:  br bb3

 // CHECK: bb2([[ARG3:%.*]] : $Builtin.Int16):
 // CHECK:  apply [[F2]]([[ARG3]])
 // CHECK:  [[UED2:%.*]] = unchecked_enum_data [[ARG]] : $AnEnum, #AnEnum.C!enumelt.1
 // CHECK:  apply [[F2]]([[UED2]])
 // CHECK:  br bb3

 sil @jump_thread_switch_enum : $@convention(thin) (AnEnum) -> () {
 bb0(%0 : $AnEnum):

   %1 = function_ref @f : $@convention(thin) (Builtin.Int32) -> ()

   %2 = function_ref @f2 : $@convention(thin) (Builtin.Int16) -> ()
   switch_enum %0 : $AnEnum, case #AnEnum.B!enumelt.1: bb1, case #AnEnum.C!enumelt.1: bb3

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

 bb2:
   %6 = apply %1(%4) : $@convention(thin) (Builtin.Int32) -> ()
   br bb5

 bb3(%8 : $Builtin.Int16):
   br bb4

 bb4:
   %10 = apply %2(%8) : $@convention(thin) (Builtin.Int16) -> ()
   br bb5

 bb5:
   switch_enum %0 : $AnEnum, case #AnEnum.C!enumelt.1: bb6, case #AnEnum.B!enumelt.1: bb8

 bb6(%13 : $Builtin.Int16):
   br bb7

 bb7:
   %15 = apply %2(%13) : $@convention(thin) (Builtin.Int16) -> ()
   br bb10

 bb8(%17 : $Builtin.Int32):
   br bb9

 bb9:
   %19 = apply %1(%17) : $@convention(thin) (Builtin.Int32) -> ()
   br bb10

 bb10:
   %21 = tuple ()
   return %21 : $()
 }

 sil @fB : $@convention(thin) () -> ()
 sil @fC : $@convention(thin) () -> ()


 // Make sure that we correctly thread such that we end up calling @fB on the
 // AnEnum.B path.

 // CHECK-LABEL: sil @dont_jump_thread_switch_enum_to_cond_br
 // CHECK:    [[BFUN:%.*]] = function_ref @fB : $@convention(thin) () -> ()
 // CHECK:    [[FALSE:%.*]] = integer_literal $Builtin.Int1, 0
 // CHECK:    switch_enum [[ENUM:%.*]] : $AnEnum, case #AnEnum.B!enumelt.1: bb1
 // CHECK:  bb1:
 // CHECK:    [[F:%.*]] = select_enum [[ENUM]] : $AnEnum, case #AnEnum.B!enumelt.1: [[FALSE]]
 // CHECK:    cond_br [[F]], bb3, bb4
 // CHECK:  bb4:
 // CHECK-NOT: br
 // CHECK:    apply [[BFUN]]
 // CHECK:    br

 sil @dont_jump_thread_switch_enum_to_cond_br : $@convention(thin) (AnEnum) -> () {
 bb0(%0 : $AnEnum):
   %1 = function_ref @fB : $@convention(thin) () -> ()
   %2 = function_ref @fC : $@convention(thin) () -> ()
   %t = integer_literal $Builtin.Int1, 1
   %f = integer_literal $Builtin.Int1, 0
   switch_enum %0 : $AnEnum, case #AnEnum.B!enumelt.1: bb4, case #AnEnum.C!enumelt.1: bb5

 bb4:
   br bb1

 bb5:
   %8 = select_enum %0 : $AnEnum, case #AnEnum.B!enumelt.1: %f, case #AnEnum.C!enumelt.1: %t : $Builtin.Int1
   cond_br %8, bb10, bb1

 bb1:
   %3 = select_enum %0 : $AnEnum, case #AnEnum.B!enumelt.1: %f, case #AnEnum.C!enumelt.1: %t : $Builtin.Int1
   cond_br %3, bb2, bb3

 bb2:
   %6 = apply %2() : $@convention(thin) () -> ()
   br bb10

 bb3:
   %7 = apply %1() : $@convention(thin) () -> ()
   br bb10


 bb10:
   %21 = tuple ()
   return %21 : $()
 }

 sil @rethrow_function : $@convention(thin) (@owned @callee_owned (Int) -> (Int, @error Error)) -> (Int, @error Error)
 sil @non_throwing_closure : $@convention(thin) (Int) -> Int

 // CHECK-LABEL: sil @replace_try_apply_with_apply
 // CHECK: [[R:%[0-9]+]] = apply [nothrow] %1(%{{[0-9]+}}) : $@convention(thin) (@owned @callee_owned (Int) -> (Int, @error Error)) -> (Int, @error Error)
 // CHECK-NEXT: dealloc_stack
 // CHECK-NEXT: return [[R]] : $Int
 sil @replace_try_apply_with_apply : $@convention(thin) () -> Int {
 bb0:
   %as = alloc_stack $Builtin.Int32
   %0 = function_ref @rethrow_function : $@convention(thin) (@owned @callee_owned (Int) -> (Int, @error Error)) -> (Int, @error Error)
   %1 = function_ref @non_throwing_closure : $@convention(thin) (Int) -> Int
   %2 = thin_to_thick_function %1 : $@convention(thin) (Int) -> Int to $@callee_owned (Int) -> Int
   %3 = convert_function %2 : $@callee_owned (Int) -> Int to $@callee_owned (Int) -> (Int, @error Error)
   try_apply %0(%3) : $@convention(thin) (@owned @callee_owned (Int) -> (Int, @error Error)) -> (Int, @error Error), normal bb1, error bb2

 bb1(%5 : $Int):
   dealloc_stack %as: $*Builtin.Int32
   return %5 : $Int

 bb2(%8 : $Error):
   dealloc_stack %as: $*Builtin.Int32
   unreachable
 }

 public class EE {
   init()
 }

 public class BB {
   init()
 }

 public class CC : BB {
   @inline(never) init(e: EE)
   override init()
 }

 public protocol PP {
   var prop1: BB? { get }
 }

 public class DD : PP {
   public var prop1: BB? { get }
   init()
 }


 // CHECK-LABEL: sil @replace_try_apply_with_apply_cast_return_type : $@convention(method) (@guaranteed DD) -> @owned Optional<BB>
 // CHECK: bb0
 // CHECK: apply %{{.*}}
 // CHECK: convert_function
 // CHECK-NOT: try_apply
 // CHECK: apply
 // Check that return value is properly casted
 // CHECK-NEXT: enum $Optional<CC>, #Optional.some!enumelt.1, %{{.*}} : $CC
 // CHECK-NEXT: upcast %{{.*}} : $Optional<CC> to $Optional<BB>
 // CHECK-NEXT: return
 sil @replace_try_apply_with_apply_cast_return_type: $@convention(method) (@guaranteed DD) -> @owned Optional<BB> {
 bb0(%0 : $DD):
   %1 = alloc_ref $EE
   debug_value %1 : $EE
   %3 = function_ref @initCC : $@convention(thin) (@thick CC.Type) -> @owned @callee_owned (@owned EE) -> @owned CC
   %4 = metatype $@thick CC.Type
   %5 = apply %3(%4) : $@convention(thin) (@thick CC.Type) -> @owned @callee_owned (@owned EE) -> @owned CC
   %6 = convert_function %5 : $@callee_owned (@owned EE) -> @owned CC to $@callee_owned (@owned EE) -> (@owned Optional<BB>, @error Error)
   try_apply %6(%1) : $@callee_owned (@owned EE) -> (@owned Optional<BB>, @error Error), normal bb1, error bb2

 bb1(%8 : $Optional<BB>):
   return %8 : $Optional<BB>

 bb2(%10 : $Error):
   unreachable
 }

 // Check that we don't crash on this, because we perform casting
 // if the argument types of the converted function types do not match.
 // CHECK-LABEL: try_apply_with_apply_of_cast_argument
 // CHECK-NOT: try_apply {{%[0-9]+}}
 // CHECK: convert_function
 // CHECK: upcast
 // CHECK: apply
 // CHECK-NOT: try_apply
 // CHECK: return
 sil @try_apply_with_apply_of_cast_argument: $@convention(method) (@owned CC) -> @owned BB {
 bb0(%0 : $CC):
   %3 = function_ref @takeBB : $@convention(thin) (@owned BB) -> @owned BB
   %6 = convert_function %3 : $@convention(thin) (@owned BB) -> @owned BB to $@convention(thin) (@owned CC) -> (@owned BB, @error Error)
   try_apply %6(%0) : $@convention(thin) (@owned CC) -> (@owned BB, @error Error), normal bb1, error bb2

 bb1(%8 : $BB):
   return %8 : $BB

 bb2(%10 : $Error):
   // Prevent that the conversion is done because the error block is empty and unreachable.
   %12 = function_ref @unknown : $@convention(thin) () -> ()
   apply %12() : $@convention(thin) () -> ()
   unreachable
 }

 sil [noinline] @initCC : $@convention(thin) (@thick CC.Type) -> @owned @callee_owned (@owned EE) -> @owned CC

 sil [noinline] @takeBB : $@convention(thin) (@owned BB) -> @owned BB

 // Check that we don't crash on this.
 // The compiler should be able to cast between the labeled and unlabeled return tuple types.
 // CHECK-LABEL: @try_apply_with_convert_function_returning_casted_unlabeled_tuple
 // CHECK: [[T0:%.*]] = apply {{%[0-9]+}}
 // CHECK: return [[T0]]
 sil @try_apply_with_convert_function_returning_casted_unlabeled_tuple: $@convention(thin) () -> (Int32, Int32) {
 bb0:
   %3 = function_ref @returnLabeledTuple : $@convention(thin) () -> (Int32, Int32)
   %6 = convert_function %3 : $@convention(thin) () -> (Int32, Int32) to $@convention(thin) () -> (Int32, Int32, @error Error)
   try_apply %6() : $@convention(thin) () -> (Int32, Int32, @error Error), normal bb1, error bb2

 bb1(%8 : $(Int32, Int32)):
   return %8 : $(Int32, Int32)

 bb2(%10 : $Error):
   // Prevent that the conversion is done because the error block is empty and unreachable.
   %12 = function_ref @unknown : $@convention(thin) () -> ()
   apply %12() : $@convention(thin) () -> ()
   unreachable
 }

 // Check that we don't crash on this.
 // The compiler should be able to cast between the labeled and unlabeled return tuple types.
 // CHECK-LABEL: @try_apply_with_convert_function_returning_casted_labeled_tuple
 // CHECK: apply {{%[0-9]+}}
 // Proper tuple is created by deconstructing the old one and creating a new one using its elements.
 // CHECK: tuple_extract
 // CHECK: tuple_extract
 // CHECK: tuple
 // CHECK: return
 sil @try_apply_with_convert_function_returning_casted_labeled_tuple: $@convention(thin) () -> (Int32, Int32) {
 bb0:
   %3 = function_ref @returnUnlabeledTuple : $@convention(thin) () -> (Int32, Int32)
   %6 = convert_function %3 : $@convention(thin) () -> (Int32, Int32) to $@convention(thin) () -> (Int32, Int32, @error Error)
   try_apply %6() : $@convention(thin) () -> (Int32, Int32, @error Error), normal bb1, error bb2

 bb1(%8 : $(Int32, Int32)):
   return %8 : $(Int32, Int32)

 bb2(%10 : $Error):
   // Prevent that the conversion is done because the error block is empty and unreachable.
   %12 = function_ref @unknown : $@convention(thin) () -> ()
   apply %12() : $@convention(thin) () -> ()
   unreachable
 }

 sil [noinline] @returnLabeledTuple: $@convention(thin) () -> (Int32, Int32)
 sil [noinline] @returnUnlabeledTuple : $@convention(thin) () -> (Int32, Int32)

 public class AAA {
 }

 public class BBB : AAA {
 }

 @inline(never) func returnUnlabeledTuple(b: BBB) -> (BBB, BBB)

 func testit(f: (BBB) throws -> (AAA, AAA), _ b: BBB) throws -> (AAA, AAA)

 func callit(b: BBB) throws -> (AAA, AAA)

 sil [noinline] @returnUnlabeledTupleOfClasses : $@convention(thin) (@owned BBB) -> @owned (BBB, BBB) {
 bb0(%0 : $BBB):
   debug_value %0 : $BBB
   strong_retain %0 : $BBB
   %3 = tuple (%0 : $BBB, %0 : $BBB)
   return %3 : $(BBB, BBB)
 }

 sil @testFunctorReturningUnlabeledTuple : $@convention(thin) (@owned @callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error), @owned BBB) -> (@owned (AAA, AAA), @error Error) {
 bb0(%0 : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error), %1 : $BBB):
   debug_value %0 : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error)
   debug_value %1 : $BBB
   strong_retain %0 : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error)
   strong_retain %1 : $BBB
   try_apply %0(%1) : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error), normal bb1, error bb2

 bb1(%7 : $(AAA, AAA)):
   %8 = tuple_extract %7 : $(AAA, AAA), 0
   %9 = tuple_extract %7 : $(AAA, AAA), 1
   %10 = tuple (%8 : $AAA, %9 : $AAA)
   strong_release %1 : $BBB
   strong_release %0 : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error)
   return %10 : $(AAA, AAA)

 bb2(%14 : $Error):
   strong_release %1 : $BBB
   strong_release %0 : $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error)
   throw %14 : $Error
 }


 // Check that we don't crash on this. Currently we just do not optimize try_apply if
 // we cannot cast the actual return type into expected return type.
 // TODO: Change the checks when we support more complex casts of return types.
 // CHECK-LABEL: @testCallingFunctionWithFunctorReturningUnlabeledTuple
 // CHECK: try_apply {{%[0-9]+}}
 // CHECK: return
 sil @testCallingFunctionWithFunctorReturningUnlabeledTuple : $@convention(thin) (@owned BBB) -> (@owned (AAA, AAA), @error Error) {
 bb0(%0 : $BBB):
   debug_value %0 : $BBB

   %2 = function_ref @testFunctorReturningUnlabeledTuple : $@convention(thin) (@owned @callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error), @owned BBB) -> (@owned (AAA, AAA), @error Error)

   %3 = function_ref @returnUnlabeledTupleOfClasses : $@convention(thin) (@owned BBB) -> @owned (BBB, BBB)
   %4 = thin_to_thick_function %3 : $@convention(thin) (@owned BBB) -> @owned (BBB, BBB) to $@callee_owned (@owned BBB) -> @owned (BBB, BBB)
   %5 = convert_function %4 : $@callee_owned (@owned BBB) -> @owned (BBB, BBB) to $@callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error)
   strong_retain %0 : $BBB
   try_apply %2(%5, %0) : $@convention(thin) (@owned @callee_owned (@owned BBB) -> (@owned (AAA, AAA), @error Error), @owned BBB) -> (@owned (AAA, AAA), @error Error), normal bb1, error bb2

 bb1(%8 : $(AAA, AAA)):
   %9 = tuple_extract %8 : $(AAA, AAA), 0
   %10 = tuple_extract %8 : $(AAA, AAA), 1
   %11 = tuple (%9 : $AAA, %10 : $AAA)
   strong_release %0 : $BBB
   return %11 : $(AAA, AAA)

 bb2(%14 : $Error):
   strong_release %0 : $BBB
   throw %14 : $Error
 }

 struct UP<T> {

 }

 struct UBP<A> {
 }

 struct CAB<A> {

 }

 sil @CABIdentityGetter : $@convention(thin) <τ_0_0> (UBP<τ_0_0>) -> UP<()>
 sil @CABwithUnsafeBufferPointer : $@convention(method) <τ_0_0><τ_1_0> (@owned @callee_owned (UBP<τ_0_0>) -> (@out τ_1_0, @error Error), @guaranteed CAB<τ_0_0>) -> (@out τ_1_0, @error Error)
 sil @thunk_helper : $@convention(thin) <τ_0_0> (UBP<τ_0_0>, @owned @callee_owned (UBP<τ_0_0>) -> (UP<()>, @error Error)) -> (@out UP<()>, @error Error)

 // CHECK-LABEL: sil @check_parameters_casting_with_generics
 // CHECK-NOT: try_apply
 // CHECK: apply [nothrow] %{{.*}}<Element, UP<()>>
 // CHECK: return
 sil @check_parameters_casting_with_generics : $@convention(method) <Element> (@guaranteed CAB<Element>) -> UP<()> {
 bb0(%0 : $CAB<Element>):
   // function_ref Swift._ContiguousArrayBuffer.withUnsafeBufferPointer <A><B> (CAB<A>)((Swift.UBP<A>) throws -> B) throws -> B
   %2 = function_ref @CABwithUnsafeBufferPointer : $@convention(method) <τ_0_0><τ_1_0> (@owned @callee_owned (UBP<τ_0_0>) -> (@out τ_1_0, @error Error), @guaranteed CAB<τ_0_0>) -> (@out τ_1_0, @error Error)
   // function_ref Swift._ContiguousArrayBuffer.(identity.getter : UP<()>).(closure #1)
   %3 = function_ref @CABIdentityGetter : $@convention(thin) <τ_0_0> (UBP<τ_0_0>) -> UP<()>
   %4 = partial_apply %3<Element>() : $@convention(thin) <τ_0_0> (UBP<τ_0_0>) -> UP<()>
   %5 = convert_function %4 : $@callee_owned (UBP<Element>) -> UP<()> to $@callee_owned (UBP<Element>) -> (UP<()>, @error Error)
   // function_ref reabstraction thunk helper <A> from @callee_owned (@unowned UBP<A>) -> (@unowned UP<()>, @error @owned Swift.Error) to @callee_owned (@unowned UBP<A>) -> (@out UP<()>, @error @owned Swift.Error)
   %6 = function_ref @thunk_helper : $@convention(thin) <τ_0_0> (UBP<τ_0_0>, @owned @callee_owned (UBP<τ_0_0>) -> (UP<()>, @error Error)) -> (@out UP<()>, @error Error)
   %7 = partial_apply %6<Element>(%5) : $@convention(thin) <τ_0_0> (UBP<τ_0_0>, @owned @callee_owned (UBP<τ_0_0>) -> (UP<()>, @error Error)) -> (@out UP<()>, @error Error)
   %8 = alloc_stack $UP<()>
   %9 = unchecked_addr_cast %8 : $*UP<()> to $*UP<()>
   %10 = convert_function %7 : $@callee_owned (UBP<Element>) -> (@out UP<()>, @error Error) to $@callee_owned (UBP<Element>) -> (@out UP<()>, @error Error)
   try_apply %2<Element, UP<()>>(%8, %7, %0) : $@convention(method) <τ_0_0><τ_1_0> (@owned @callee_owned (UBP<τ_0_0>) -> (@out τ_1_0, @error Error), @guaranteed CAB<τ_0_0>) -> (@out τ_1_0, @error Error), normal bb1, error bb2

 bb1(%12 : $()):
   %13 = load %8 : $*UP<()>
   dealloc_stack %8 : $*UP<()>
   return %13 : $UP<()>

 bb2(%16 : $Error):
   unreachable
 }


 // Check that we don't crash on this.

 // CHECK-LABEL: @simplified_branch_arg_has_result_value_1
 // CHECK: [[B:%[0-9]+]] = alloc_box
 // CHECK: [[PB:%[0-9]+]] = project_box [[B]]
 // CHECK: br bb1([[PB]] : $*Builtin.Int32)
 sil @simplified_branch_arg_has_result_value_1 : $@convention(thin) (@in Builtin.Int32) -> Builtin.Int32 {
 entry(%0 : $*Builtin.Int32):
   %b = alloc_box $<τ_0_0> { var τ_0_0 } <Builtin.Int32>
   %p = project_box %b : $<τ_0_0> { var τ_0_0 } <Builtin.Int32>, 0
   %i = integer_literal $Builtin.Int32, 0
   store %i to %p : $*Builtin.Int32
   br bb1(%p : $*Builtin.Int32)

 bb1(%a : $*Builtin.Int32):
   %r = load %a : $*Builtin.Int32
   cond_br undef, bb1(%0 : $*Builtin.Int32), bb2

 bb2:
   return %r : $Builtin.Int32
 }

 // CHECK-LABEL: sil @unpack_enum_arg
 // CHECK: bb1:
 // CHECK:   br bb3(%0 : $Int)
 // CHECK: bb2:
 // CHECK:   br bb3(%1 : $Int)
 // CHECK: bb3([[A:%[0-9]+]] : $Int):
 // CHECK:   return [[A]]
 sil @unpack_enum_arg : $@convention(thin) (Int, Int) -> Int {
 bb0(%0 : $Int, %1 : $Int):
   cond_br undef, bb1, bb2

 bb1:
   %2 = enum $Optional<Int>, #Optional.some!enumelt.1, %0 : $Int
   br bb3(%2 : $Optional<Int>)

 bb2:
   %3 = enum $Optional<Int>, #Optional.some!enumelt.1, %1 : $Int
   br bb3(%3 : $Optional<Int>)

 bb3(%4 : $Optional<Int>):
   %5 = unchecked_enum_data %4 : $Optional<Int>, #Optional.some!enumelt.1
   return %5 : $Int
 }


 // CHECK-LABEL: sil @dont_crash_on_enum_payload_is_enum
 // CHECK: bb0(%0 : $TwoCase):
 // CHECK:   switch_enum %0
 // CHECK: bb1:
 // CHECK:   return
 sil @dont_crash_on_enum_payload_is_enum : $@convention(thin) (TwoCase) -> () {
 bb0(%0 : $TwoCase):
   %x = enum $Optional<TwoCase>, #Optional.some!enumelt.1, %0 : $TwoCase
   br bb1(%x : $Optional<TwoCase>)

 bb1(%10 : $Optional<TwoCase>):
   switch_enum %10 : $Optional<TwoCase>, case #Optional.some!enumelt.1: bb2, case #Optional.none!enumelt: bb5

 bb2(%1 : $TwoCase):
   // Simplification of that switch_enum crashed the compiler because
   // SILArgument::getIncomingValues returns %10 ($Optional<TwoCase>) as the
   // incoming value for %1 ($TwoCase).
   // rdar://problem/26251856
   switch_enum %1 : $TwoCase, case #TwoCase.First!enumelt: bb3, case #TwoCase.Second!enumelt: bb4

 bb3:
   %f1 = function_ref @unknown : $@convention(thin) () -> ()
   %n1 = apply %f1() : $@convention(thin) () -> ()
   br bb6

 bb4:
   br bb6

 bb5:
   br bb6

 bb6:
   %6 = tuple ()
   return %6 : $()
 }

 enum TestEnum {
   case int64(Builtin.Int64)
   case string (Base)
   case none
 }

 enum MyError : Error {
  case a
  case b
  case c(TestEnum)
 }

 enum MyError2 : Error {
  case o(Optional<MyError>)
 }

 sil @foo : $@convention(thin) (Builtin.Int64) -> Builtin.Int8
 sil @foo2 : $@convention(thin) (Builtin.Int32) -> Builtin.Int8

 sil @dont_thread_throw_block : $@convention(thin) (@guaranteed TestEnum) -> (Builtin.Int8, @error Error) {
 bb0(%0 : $TestEnum):
   switch_enum %0 : $TestEnum, case #TestEnum.int64!enumelt.1: bb1,  default bb4

 bb1(%5 : $Builtin.Int64):
   %7 = function_ref @foo : $@convention(thin) (Builtin.Int64) -> Builtin.Int8
   %9 = apply %7(%5) : $@convention(thin) (Builtin.Int64) -> Builtin.Int8
   br bb6(%9 : $Builtin.Int8)

 bb2(%11 : $Builtin.Int32):
   %13 = function_ref @foo2 : $@convention(thin) (Builtin.Int32) -> Builtin.Int8
   %15 = apply %13(%11) : $@convention(thin) (Builtin.Int32) -> Builtin.Int8
   br bb6(%15 : $Builtin.Int8)

 bb4:
   debug_value %0 : $TestEnum
   %22 = alloc_existential_box $Error, $MyError2
   %23 = project_existential_box $MyError2 in %22 : $Error
   switch_enum %0 : $TestEnum, case #TestEnum.none!enumelt: bbnone, case #TestEnum.int64!enumelt.1: bb7, case #TestEnum.string!enumelt.1: bb10

 bbnone:
   %tn = enum $TestEnum, #TestEnum.none!enumelt
   %en = enum $MyError, #MyError.c!enumelt.1, %tn : $TestEnum
 br bb5(%en : $MyError)

 bb7(%50 : $Builtin.Int64):
   %t = enum $TestEnum, #TestEnum.int64!enumelt.1, %50 : $Builtin.Int64
   %e1 = enum $MyError, #MyError.c!enumelt.1, %t : $TestEnum
   br bb5(%e1 : $MyError)

 bb10(%53 : $Base):
   %t4 = enum $TestEnum, #TestEnum.string!enumelt.1, %53 : $Base
   %e4 = enum $MyError, #MyError.c!enumelt.1, %t4 : $TestEnum
   br bb5(%e4 : $MyError)

 bb5(%e : $MyError):
   %89 = enum $Optional<MyError>, #Optional.some!enumelt.1, %e : $MyError
   %e5 = enum $MyError2, #MyError2.o!enumelt.1, %89 : $Optional<MyError>
   store %e5 to %23 : $*MyError2
   throw %22 : $Error

 bb6(%44 : $Builtin.Int8):
   return %44 : $Builtin.Int8
 }

 // CHECK-LABEL: jump_thread_retain_release
 // CHECK: cond_br
 // CHECK:   cond_br %3, bb3, bb4

 // CHECK: bb3:
 // CHECK:   strong_retain %1 : $foo
 // CHECK:   strong_release %1 : $foo
 // CHECK:   br bb5(%1 : $foo)

 // CHECK: bb4:
 // CHECK:   strong_retain %2 : $foo
 // CHECK:   strong_release %2 : $foo
 // CHECK:   br bb5(%2 : $foo)

 sil @jump_thread_retain_release : $@convention(thin) (Builtin.Int1, foo, foo, Builtin.Int1) -> () {
 bb0(%0 : $Builtin.Int1, %1 : $foo, %2 : $foo, %3 : $Builtin.Int1):
   cond_br %0, bb2, bb1

 bb1:
   br bb6(%2 : $foo)

 bb2:
   cond_br %3, bb3, bb4

 bb3:
   strong_retain %1 : $foo
   br bb5(%1 : $foo)

 bb4:
   strong_retain %2 : $foo
   br bb5(%2 : $foo)

 bb5(%11 : $foo):
   strong_release %11 : $foo
   br bb6(%11 : $foo)

 bb6(%14 : $foo):
   strong_release %14 : $foo
   %16 = tuple ()
   return %16 : $()
 }

 protocol Q {}

 class IsQ : Q {}

 // checked_cast_br take_* should be replaced by a destroy in case it ever
 // converts a managed object to an unmanaged value. Currently this doesn't
 // happen at the language level because bridge (NSNumber->Int) casts aren't
 // represented with checked_cast_br.
 // ---
 // CHECK-LABEL: sil @test_dead_checked_cast_br : $@convention(thin) (@in IsQ) -> () {
 // CHECK: bb0(%0 : $*IsQ):
 // CHECK:   [[Q:%.*]] = alloc_stack $Q
 // CHECK:   [[LD:%.*]] = load %0 : $*IsQ
 // CHECK:   strong_release [[LD]] : $IsQ
 // CHECK:   dealloc_stack [[Q]] : $*Q
 // CHECK:   [[R:%.*]] = tuple ()
 // CHECK:   return [[R]] : $()
 // CHECK-LABEL: } // end sil function 'test_dead_checked_cast_br'
 sil @test_dead_checked_cast_br : $@convention(thin) (@in IsQ) -> () {
 bb0(%0 : $*IsQ):
   %p = alloc_stack $Q
   checked_cast_addr_br take_always IsQ in %0 : $*IsQ to Q in %p : $*Q, bb1, bb3

 bb1:
   %m1 = integer_literal $Builtin.Int1, -1
   br bb2(%m1 : $Builtin.Int1)

 bb2(%5 : $Builtin.Int1):
   // To avoid violating ownership, Q needs to be destroyed here. However, that
   // would create a use of the checked_cast, defeating the test. In theory, Q
   // could be some unmananged type with no destroy, but we don't have a way to
   // express that in the type system, and bridged casts don't yet go through
   // this optimization path.
   dealloc_stack %p : $*Q
   %r = tuple ()
   return %r : $()

 bb3:
   %z = integer_literal $Builtin.Int1, 0
   br bb2(%z : $Builtin.Int1)
 }

 // CHECK-LABEL: sil @dont_hang
 // CHECK:      bb6:
 // CHECK:        integer_literal $Builtin.Int64, 1
 // CHECK-NEXT:   br bb5
 // CHECK-NEXT: }
 sil @dont_hang : $@convention(thin) () -> () {
 bb0:
   cond_br undef, bb1, bb4

 bb1:
   %0 = integer_literal $Builtin.Int64, 1
   cond_br undef, bb2, bb6

 bb2:
   br bb3

 bb3:
   br bb5

 bb4:
   %1 = integer_literal $Builtin.Int64, 1
   br bb3

 bb5:
   br bb2

 bb6:
   %2 = integer_literal $Builtin.Int64, 1
   br bb7

 bb7:
   br bb5
 }

 // CHECK-LABEL: sil @test_constant_folding
 // CHECK:  [[R:%[0-9]+]] = integer_literal $Builtin.Int32, 30
 // CHECK:  return [[R]] : $Builtin.Int32
 // CHECK-NEXT: }
 sil @test_constant_folding : $@convention(thin) () -> Builtin.Int32 {
 bb0:
   %0 = integer_literal $Builtin.Int1, 0
   %20 = integer_literal $Builtin.Int32, 20
   %30 = integer_literal $Builtin.Int32, 30
   cond_br %0, bb1, bb2
 bb1:
   br bb3(%20 : $Builtin.Int32)
 bb2:
   br bb3(%30 : $Builtin.Int32)

 bb3(%2 : $Builtin.Int32):
   %3 = builtin "cmp_slt_Int32"(%2 : $Builtin.Int32, %30 : $Builtin.Int32) : $Builtin.Int1
   cond_br %3, bb4, bb5
 bb4:
   br bb6(%20 : $Builtin.Int32)
 bb5:
   br bb6(%30 : $Builtin.Int32)

 bb6(%4 : $Builtin.Int32):
   %5 = builtin "cmp_slt_Int32"(%4 : $Builtin.Int32, %30 : $Builtin.Int32) : $Builtin.Int1
   cond_br %5, bb7, bb8
 bb7:
   br bb9(%20 : $Builtin.Int32)
 bb8:
   br bb9(%30 : $Builtin.Int32)

 bb9(%6 : $Builtin.Int32):
   return %6 : $Builtin.Int32
 }

 sil @adder : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> Builtin.Int32

 // CHECK-LABEL: sil @test_noescape
 // CHECK:  [[FN:%.*]] = function_ref @adder
 // CHECK:  [[PA:%.*]] = partial_apply [callee_guaranteed] [[FN]](%0)
 // CHECK-NOT: try_apply
 // CHECK:  apply [[PA]](%1)
 // CHECK: return
 sil @test_noescape : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> Builtin.Int32 {
 bb0(%0 : $Builtin.Int32, %1 : $Builtin.Int32):
   %f = function_ref @adder : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> Builtin.Int32
   %pa = partial_apply [callee_guaranteed] %f(%0) : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> Builtin.Int32
   %conv = convert_function %pa : $@callee_guaranteed (Builtin.Int32) -> (Builtin.Int32) to $@callee_guaranteed (Builtin.Int32) -> (Builtin.Int32, @error Error)
   %ne = convert_escape_to_noescape %conv : $@callee_guaranteed (Builtin.Int32) -> (Builtin.Int32, @error Error) to $@noescape @callee_guaranteed (Builtin.Int32) -> (Builtin.Int32, @error Error)
   try_apply %ne(%1) : $@noescape @callee_guaranteed (Builtin.Int32) -> (Builtin.Int32, @error Error), normal bb1, error bb2

 bb1(%r : $Builtin.Int32):
 	br bb3(%r : $Builtin.Int32)

 bb2(%e : $Error):
   %r1 = integer_literal $Builtin.Int32, 0
 	br bb3(%r1 : $Builtin.Int32)

 bb3(%res : $Builtin.Int32):
   release_value %pa : $@callee_guaranteed (Builtin.Int32) -> (Builtin.Int32)
   return  %res : $Builtin.Int32
 }

 struct TestStr {
   let a: Int32
   let c: Int32
 }

 enum TestEnm {
   case X
   case Y(TestStr)
 }

 // CHECK-LABEL: sil @dont_crash
 // CHECK:      bb0(%0 : $TestEnm, %1 : $Int32):
 // CHECK-NEXT:   %2 = tuple ()
 // CHECK-NEXT:   return %2 : $()
 sil @dont_crash : $@convention(method) (TestEnm, Int32) -> () {
 bb0(%2 : $TestEnm, %3 : $Int32):
   %98 = integer_literal $Builtin.Int1, -1
   cond_br %98, bb2, bb3

 bb2:
   %18 = tuple()
   return %18 : $()

 bb3:
   br bb8(%2 : $TestEnm)

 bb8(%47 : $TestEnm):
   %49 = unchecked_enum_data %47 : $TestEnm, #TestEnm.Y!enumelt.1
   %57 = struct_extract %49 : $TestStr, #TestStr.c
   cond_br undef, bb9, bb11

 bb9:
   br bb10

 bb10:
   %64 = struct $TestStr (%3 : $Int32, %57 : $Int32)
   %65 = enum $TestEnm, #TestEnm.Y!enumelt.1, %64 : $TestStr
   cond_br undef, bb2, bb16

 bb11:
   br bb10


 bb16:
   br bb8(%65 : $TestEnm)
 }

 sil @print : $@convention(thin) (@guaranteed String) -> ()
 sil @yield_string : $@yield_once @convention(thin) () -> @yields @guaranteed String

 sil @dont_clone_begin_apply : $(Builtin.Int1, @guaranteed String) -> () {
 bb0(%condition : $Builtin.Int1, %arg : $String):
   %print = function_ref @print : $@convention(thin) (@guaranteed String) -> ()
   cond_br %condition, bb1, bb2
 bb1:
   apply %print(%arg) : $@convention(thin) (@guaranteed String) -> ()
   br bb3
 bb2:
   br bb3
 bb3:
   %yield_string = function_ref @yield_string : $@yield_once @convention(thin) () -> @yields @guaranteed String
   (%yield, %token) = begin_apply %yield_string() : $@yield_once @convention(thin) () -> @yields @guaranteed String
   cond_br %condition, bb4, bb5
 bb4:
   apply %print(%yield) : $@convention(thin) (@guaranteed String) -> ()
   br bb6
 bb5:
   br bb6
 bb6:
   end_apply %token
   %rv = tuple ()
   return %rv : $()
 }

 class X {
   @objc func f() { }
 }

 sil @external_g : $@convention(thin) () -> ()

 // Don't tail duplicate dynamic_method_br. IRGen cannot handle phi nodes of
 // objc_methods.
 // CHECK-LABEL: sil @dont_tail_duplicate_dynamic_method_br
 // CHECK: dynamic_method_br
 // CHECK-NOT: dynamic_method_br
 // CHECK: return
 sil @dont_tail_duplicate_dynamic_method_br : $@convention(thin) (@owned Builtin.UnknownObject, Builtin.Int1) -> () {
 bb0(%x : $Builtin.UnknownObject, %b : $Builtin.Int1):
   cond_br %b, bb1, bb2

 bb1:
   %f = function_ref @external_f : $@convention(thin) () -> ()
   apply %f() : $@convention(thin) () -> ()
   strong_retain %x : $Builtin.UnknownObject
   br bb3(%x : $Builtin.UnknownObject)

 bb2:
   %g = function_ref @external_g : $@convention(thin) () -> ()
   apply %g() : $@convention(thin) () -> ()
   strong_retain %x : $Builtin.UnknownObject
   br bb3(%x : $Builtin.UnknownObject)

 bb3(%y: $Builtin.UnknownObject):
   strong_release %y : $Builtin.UnknownObject
   dynamic_method_br %x : $Builtin.UnknownObject, #X.f!1.foreign, bb4, bb5

 bb4(%m : $@convention(objc_method) (Builtin.UnknownObject) -> ()):
   br bb6

 bb5:
   br bb6

 bb6:
   %r = tuple()
   return %r : $()
 }