// RUN: %target-sil-opt -enable-objc-interop -enable-sil-verify-all %s -jumpthread-simplify-cfg -cse | %FileCheck %s

// Check that jump-threading works for sequences of checked_cast_br instructions produced by the devirtualizer.
// This allows for simplifications of code like e.g. f.foo() + f.foo()

sil_stage canonical

import Builtin
import Swift
import SwiftShims

/// 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()
}

public class FooClass {
  @_hasStorage var value: Int32 { get set }
  @inline(never) func foo(x: Int32) -> Int32
  init(value: Int32)
   deinit
}

// devirt_jump_thread.FooClass.value.getter : Swift.Int32
sil [transparent] [serialized] @_TFC18devirt_jump_thread8FooClassg5valueSi : $@convention(method) (@guaranteed FooClass) -> Int32 {
bb0(%0 : $FooClass):
  %1 = ref_element_addr %0 : $FooClass, #FooClass.value // user: %2
  %2 = load %1 : $*Int32                            // user: %4
  return %2 : $Int32                                // id: %4
}

// devirt_jump_thread.FooClass.value.setter : Swift.Int32
sil [transparent] [serialized] @_TFC18devirt_jump_thread8FooClasss5valueSi : $@convention(method) (Int32, @guaranteed FooClass) -> () {
bb0(%0 : $Int32, %1 : $FooClass):
  %2 = ref_element_addr %1 : $FooClass, #FooClass.value // user: %3
  store %0 to %2 : $*Int32                          // id: %3
  %5 = tuple ()                                   // user: %6
  return %5 : $()                                 // id: %6
}

// devirt_jump_thread.FooClass.foo (devirt_jump_thread.FooClass)(Swift.Int32) -> Swift.Int32
sil [noinline] @_TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 {
bb0(%0 : $Int32, %1 : $FooClass):
  // function_ref @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
  %2 = function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %3
  %3 = apply %2(%0, %1) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %6
  return %3 : $Int32                                // id: %6
}

// Check that checked_cast_br instructions resulting from devirtualization
// get jump-threaded.
//
// CHECK-LABEL: sil @_TF18devirt_jump_thread26jumpthread_checked_cast_brFCS_8FooClassSi
// CHECK: checked_cast_br
// CHECK: bb2(%{{.*}} : $FooClass):
// CHECK: function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi
// CHECK-NOT: function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi
// CHECK-NOT: class_method
// CHECK: br bb1
// CHECK-NOT: checked_cast_br
// CHECK: bb3:
// CHECK-NOT: function_ref
// CHECK: class_method
// CHECK-NOT: function_ref
// CHECK: br bb1
// CHECK: }
// devirt_jump_thread.jumpthread_checked_cast_br (devirt_jump_thread.FooClass) -> Swift.Int32
sil @_TF18devirt_jump_thread26jumpthread_checked_cast_brFCS_8FooClassSi : $@convention(thin) (@guaranteed FooClass) -> Int32 {
bb0(%0 : $FooClass):
  %1 = integer_literal $Builtin.Int32, 2           // user: %2
  %2 = struct $Int32 (%1 : $Builtin.Int32)           // users: %37, %43, %48, %54
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb5, bb6 // id: %3

bb1(%4 : $Int32):                                   // Preds: bb5 bb6
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb7, bb8 // id: %5

bb2(%6 : $Int32):                                   // Preds: bb7 bb8
  %7 = struct_extract %4 : $Int32, #Int32._value       // user: %10
  %8 = struct_extract %6 : $Int32, #Int32._value       // user: %10
  %9 = integer_literal $Builtin.Int1, -1          // users: %10, %19, %28
  %10 = builtin "sadd_with_overflow_Int32"(%7 : $Builtin.Int32, %8 : $Builtin.Int32, %9 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %11, %12
  %11 = tuple_extract %10 : $(Builtin.Int32, Builtin.Int1), 0 // user: %19
  %12 = tuple_extract %10 : $(Builtin.Int32, Builtin.Int1), 1 // user: %13
  cond_fail %12 : $Builtin.Int1                   // id: %13
  %14 = integer_literal $Builtin.Int32, 3          // user: %15
  %15 = struct $Int32 (%14 : $Builtin.Int32)         // users: %59, %65
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb9, bb10 // id: %16

bb3(%17 : $Int32):                                  // Preds: bb9 bb10
  %18 = struct_extract %17 : $Int32, #Int32._value     // user: %19
  %19 = builtin "sadd_with_overflow_Int32"(%11 : $Builtin.Int32, %18 : $Builtin.Int32, %9 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %20, %21
  %20 = tuple_extract %19 : $(Builtin.Int32, Builtin.Int1), 0 // user: %28
  %21 = tuple_extract %19 : $(Builtin.Int32, Builtin.Int1), 1 // user: %22
  cond_fail %21 : $Builtin.Int1                   // id: %22
  %23 = integer_literal $Builtin.Int32, 4          // user: %24
  %24 = struct $Int32 (%23 : $Builtin.Int32)         // users: %69, %74
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb11, bb12 // id: %25

bb4(%26 : $Int32):                                  // Preds: bb11 bb12
  %27 = struct_extract %26 : $Int32, #Int32._value     // user: %28
  %28 = builtin "sadd_with_overflow_Int32"(%20 : $Builtin.Int32, %27 : $Builtin.Int32, %9 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %29, %30
  %29 = tuple_extract %28 : $(Builtin.Int32, Builtin.Int1), 0 // user: %32
  %30 = tuple_extract %28 : $(Builtin.Int32, Builtin.Int1), 1 // user: %31
  cond_fail %30 : $Builtin.Int1                   // id: %31
  %32 = struct $Int32 (%29 : $Builtin.Int32)         // user: %33
  return %32 : $Int32                               // id: %33

bb5(%34 : $FooClass):                             // Preds: bb0
  // function_ref @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
  %35 = function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %37
  strong_retain %0 : $FooClass                    // id: %36
  %37 = apply %35(%2, %34) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %40
  fix_lifetime %34 : $FooClass                    // id: %38
  strong_release %0 : $FooClass                   // id: %39
  br bb1(%37 : $Int32)                              // id: %40

bb6:                                              // Preds: bb0
  %41 = class_method %0 : $FooClass, #FooClass.foo!1 : (FooClass) -> (Int32) -> Int32, $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %43
  strong_retain %0 : $FooClass                    // id: %42
  %43 = apply %41(%2, %0) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %44
  br bb1(%43 : $Int32)                              // id: %44

bb7(%45 : $FooClass):                             // Preds: bb1
  // function_ref @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
  %46 = function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %48
  strong_retain %0 : $FooClass                    // id: %47
  %48 = apply %46(%2, %45) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %51
  fix_lifetime %45 : $FooClass                    // id: %49
  strong_release %0 : $FooClass                   // id: %50
  br bb2(%48 : $Int32)                              // id: %51

bb8:                                              // Preds: bb1
  %52 = class_method %0 : $FooClass, #FooClass.foo!1 : (FooClass) -> (Int32) -> Int32, $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %54
  strong_retain %0 : $FooClass                    // id: %53
  %54 = apply %52(%2, %0) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %55
  br bb2(%54 : $Int32)                              // id: %55

bb9(%56 : $FooClass):                             // Preds: bb2
  // function_ref @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
  %57 = function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %59
  strong_retain %0 : $FooClass                    // id: %58
  %59 = apply %57(%15, %56) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %62
  fix_lifetime %56 : $FooClass                    // id: %60
  strong_release %0 : $FooClass                   // id: %61
  br bb3(%59 : $Int32)                              // id: %62

bb10:                                             // Preds: bb2
  %63 = class_method %0 : $FooClass, #FooClass.foo!1 : (FooClass) -> (Int32) -> Int32, $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %65
  strong_retain %0 : $FooClass                    // id: %64
  %65 = apply %63(%15, %0) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %66
  br bb3(%65 : $Int32)                              // id: %66

bb11(%67 : $FooClass):                            // Preds: bb3
  // function_ref @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
  %68 = function_ref @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %69
  %69 = apply %68(%24, %67) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %72
  fix_lifetime %67 : $FooClass                    // id: %70
  strong_release %67 : $FooClass                  // id: %71
  br bb4(%69 : $Int32)                              // id: %72

bb12:                                             // Preds: bb3
  %73 = class_method %0 : $FooClass, #FooClass.foo!1 : (FooClass) -> (Int32) -> Int32, $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %74
  %74 = apply %73(%24, %0) : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 // user: %75
  br bb4(%74 : $Int32)                              // id: %75
}

// Check that checked_cast_br gets jump threaded
// CHECK-LABEL: sil @_TF18devirt_jump_thread6doubleFCS_8FooClassSi
// CHECK: checked_cast_br
// CHECK: bb2(%{{.*}} : $FooClass):
// CHECK-NOT: class_method
// CHECK: br bb1
// CHECK-NOT: checked_cast_br
// CHECK: bb3
// CHECK: class_method
// CHECK: br bb1
// CHECK }
// devirt_jump_thread.double (devirt_jump_thread.FooClass) -> Swift.Int32
sil @_TF18devirt_jump_thread6doubleFCS_8FooClassSi : $@convention(thin) (@guaranteed FooClass) -> Int32 {
bb0(%0 : $FooClass):
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb3, bb4 // id: %1

bb1(%2 : $Int32):                                   // Preds: bb3 bb4
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb5, bb6 // id: %3

bb2(%4 : $Int32):                                   // Preds: bb5 bb6
  %5 = struct_extract %2 : $Int32, #Int32._value       // user: %8
  %6 = struct_extract %4 : $Int32, #Int32._value       // user: %8
  %7 = integer_literal $Builtin.Int1, -1          // user: %8
  %8 = builtin "sadd_with_overflow_Int32"(%5 : $Builtin.Int32, %6 : $Builtin.Int32, %7 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %9, %10
  %9 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 0 // user: %12
  %10 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 1 // user: %11
  cond_fail %10 : $Builtin.Int1                   // id: %11
  %12 = struct $Int32 (%9 : $Builtin.Int32)          // user: %13
  return %12 : $Int32                               // id: %13

bb3(%14 : $FooClass):                             // Preds: bb0
  %15 = ref_element_addr %14 : $FooClass, #FooClass.value // user: %16
  %16 = load %15 : $*Int32                          // user: %17
  br bb1(%16 : $Int32)                              // id: %17

bb4:                                              // Preds: bb0
  %18 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %20
  strong_retain %0 : $FooClass                    // id: %19
  %20 = apply %18(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %21
  br bb1(%20 : $Int32)                              // id: %21

bb5(%22 : $FooClass):                             // Preds: bb1
  %23 = ref_element_addr %22 : $FooClass, #FooClass.value // user: %24
  %24 = load %23 : $*Int32                          // user: %26
  strong_release %22 : $FooClass                  // id: %25
  br bb2(%24 : $Int32)                              // id: %26

bb6:                                              // Preds: bb1
  %27 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %28
  %28 = apply %27(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %29
  br bb2(%28 : $Int32)                              // id: %29
}


// Check that checked_cast_br in bb1 does not get jump threaded
// because bb1 contains some instructions that cannot be cloned, namely alloc_stack.
//
// CHECK-LABEL: sil @_TF18devirt_jump_thread6dont_jump_thread_alloc_stackFCS_8FooClassSi
// CHECK: bb0(%{{.*}} : $FooClass):
// CHECK: checked_cast_br
// CHECK: bb1(%{{.*}} : $Int32):
// CHECK: checked_cast_br
// CHECK: bb2(%{{.*}} : $Int32):
// CHECK }
sil @_TF18devirt_jump_thread6dont_jump_thread_alloc_stackFCS_8FooClassSi : $@convention(thin) (@guaranteed FooClass) -> Int32 {
bb0(%0 : $FooClass):
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb3, bb4 // id: %1

bb1(%2 : $Int32):                                   // Preds: bb3 bb4
  %60 = alloc_stack $Int32
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb5, bb6 // id: %3

bb2(%4 : $Int32):                                   // Preds: bb5 bb6
  %5 = struct_extract %2 : $Int32, #Int32._value       // user: %8
  %6 = struct_extract %4 : $Int32, #Int32._value       // user: %8
  %7 = integer_literal $Builtin.Int1, -1          // user: %8
  %8 = builtin "sadd_with_overflow_Int32"(%5 : $Builtin.Int32, %6 : $Builtin.Int32, %7 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %9, %10
  %9 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 0 // user: %12
  %10 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 1 // user: %11
  cond_fail %10 : $Builtin.Int1                   // id: %11
  dealloc_stack %60 : $*Int32
  %12 = struct $Int32 (%9 : $Builtin.Int32)          // user: %13
  return %12 : $Int32                               // id: %13

bb3(%14 : $FooClass):                             // Preds: bb0
  %15 = ref_element_addr %14 : $FooClass, #FooClass.value // user: %16
  %16 = load %15 : $*Int32                          // user: %17
  br bb1(%16 : $Int32)                              // id: %17

bb4:                                              // Preds: bb0
  %18 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %20
  %20 = apply %18(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %21
  br bb1(%20 : $Int32)                              // id: %21

bb5(%22 : $FooClass):                             // Preds: bb1
  %23 = ref_element_addr %22 : $FooClass, #FooClass.value // user: %24
  %24 = load %23 : $*Int32                          // user: %26
  br bb2(%24 : $Int32)                              // id: %26

bb6:                                              // Preds: bb1
  %27 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %28
  %28 = apply %27(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %29
  br bb2(%28 : $Int32)                              // id: %29
}


// Check that checked_cast_br in bb1 does not get jump threaded
// because bb1 contains some instructions that cannot be cloned, e.g. class_method
// referring to an objc method.
//
// CHECK-LABEL: sil @_TF18devirt_jump_thread6dont_jump_thread_objc_methodFCS_8FooClassSi
// CHECK: bb0(%{{.*}} : $FooClass):
// CHECK: checked_cast_br
// CHECK: bb1(%{{.*}} : $Int32):
// CHECK: checked_cast_br
// CHECK: bb2(%{{.*}} : $Int32):
// CHECK }
sil @_TF18devirt_jump_thread6dont_jump_thread_objc_methodFCS_8FooClassSi : $@convention(thin) (@guaranteed FooClass) -> Int32 {
bb0(%0 : $FooClass):
  %100 = alloc_ref $Bar
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb3, bb4 // id: %1

bb1(%2 : $Int32):                                   // Preds: bb3 bb4
  %101 = objc_method %100 : $Bar, #Bar.foo!1.foreign : (Bar) -> () -> (), $@convention(objc_method) (Bar) -> ()
  checked_cast_br [exact] %0 : $FooClass to $FooClass, bb5, bb6 // id: %3

bb2(%4 : $Int32):                                   // Preds: bb5 bb6
  %5 = struct_extract %2 : $Int32, #Int32._value       // user: %8
  %6 = struct_extract %4 : $Int32, #Int32._value       // user: %8
  %7 = integer_literal $Builtin.Int1, -1          // user: %8
  %8 = builtin "sadd_with_overflow_Int32"(%5 : $Builtin.Int32, %6 : $Builtin.Int32, %7 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %9, %10
  %9 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 0 // user: %12
  %10 = tuple_extract %8 : $(Builtin.Int32, Builtin.Int1), 1 // user: %11
  cond_fail %10 : $Builtin.Int1                   // id: %11
  %12 = struct $Int32 (%9 : $Builtin.Int32)          // user: %13
  return %12 : $Int32                               // id: %13

bb3(%14 : $FooClass):                             // Preds: bb0
  %15 = ref_element_addr %14 : $FooClass, #FooClass.value // user: %16
  %16 = load %15 : $*Int32                          // user: %17
  br bb1(%16 : $Int32)                              // id: %17

bb4:                                              // Preds: bb0
  %18 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %20
  strong_retain %0 : $FooClass                    // id: %19
  %20 = apply %18(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %21
  br bb1(%20 : $Int32)                              // id: %21

bb5(%22 : $FooClass):                             // Preds: bb1
  %23 = ref_element_addr %22 : $FooClass, #FooClass.value // user: %24
  %24 = load %23 : $*Int32                          // user: %26
  strong_release %22 : $FooClass                  // id: %25
  br bb2(%24 : $Int32)                              // id: %26

bb6:                                              // Preds: bb1
  %27 = class_method %0 : $FooClass, #FooClass.value!getter.1 : (FooClass) -> () -> Int32, $@convention(method) (@guaranteed FooClass) -> Int32 // user: %28
  %28 = apply %27(%0) : $@convention(method) (@guaranteed FooClass) -> Int32 // user: %29
  br bb2(%28 : $Int32)                              // id: %29
}

// @!objc with unmangled suffix "no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi"
sil [noinline] @_TTOS_no2g__TFC18devirt_jump_thread8FooClass3foofS0_FSiSi : $@convention(method) (Int32, @guaranteed FooClass) -> Int32 {
bb0(%0 : $Int32, %1 : $FooClass):
  %2 = integer_literal $Builtin.Int32, 11          // user: %5
  %3 = struct_extract %0 : $Int32, #Int32._value       // user: %5
  %4 = integer_literal $Builtin.Int1, -1          // user: %5
  %5 = builtin "sadd_with_overflow_Int32"(%3 : $Builtin.Int32, %2 : $Builtin.Int32, %4 : $Builtin.Int1) : $(Builtin.Int32, Builtin.Int1) // users: %6, %7
  %6 = tuple_extract %5 : $(Builtin.Int32, Builtin.Int1), 0 // user: %9
  %7 = tuple_extract %5 : $(Builtin.Int32, Builtin.Int1), 1 // user: %8
  cond_fail %7 : $Builtin.Int1                    // id: %8
  %9 = struct $Int32 (%6 : $Builtin.Int32)           // user: %10
  return %9 : $Int32                                // id: %10
}


sil_vtable FooClass {
  #FooClass.foo!1: @_TFC18devirt_jump_thread8FooClass3foofS0_FSiSi	// devirt_jump_thread.FooClass.foo (devirt_jump_thread.FooClass)(Swift.Int32) -> Swift.Int32
  #FooClass.value!getter.1: @_TFC18devirt_jump_thread8FooClassg5valueSi	// devirt_jump_thread.FooClass.value.getter : Swift.Int32
  #FooClass.value!setter.1: @_TFC18devirt_jump_thread8FooClasss5valueSi	// devirt_jump_thread.FooClass.value.setter : Swift.Int32
}

class C {
   deinit
   init()
}

// Check that checked_cast_br jump-threading works properly when both
// conditions are arguments of the function's entry block.
// CHECK: sil @test_checked_cast_br_jump_threading_with_entry_bb_arguments
// CHECK: checked_cast_br %0
// CHECK: checked_cast_br %1
// CHECK: return
sil @test_checked_cast_br_jump_threading_with_entry_bb_arguments : $@convention(thin) (@owned AnyObject, @owned AnyObject) -> Int32 {
bb0(%0 : $AnyObject, %1 : $AnyObject):
  strong_retain %0 : $AnyObject
  checked_cast_br %0 : $AnyObject to $C, bb1, bb2

bb1(%4 : $C):
  %5 = enum $Optional<C>, #Optional.some!enumelt.1, %4 : $C
  br bb3(%5 : $Optional<C>)

bb2:
  strong_release %0 : $AnyObject
  %8 = enum $Optional<C>, #Optional.none!enumelt
  br bb3(%8 : $Optional<C>)

bb3(%10 : $Optional<C>):
  switch_enum %10 : $Optional<C>, case #Optional.some!enumelt.1: bb5, default bb4

bb4:
  br bb13

bb5(%13 : $C):
  strong_retain %1 : $AnyObject
  checked_cast_br %1 : $AnyObject to $C, bb6, bb7

bb6(%16 : $C):
  %17 = enum $Optional<C>, #Optional.some!enumelt.1, %16 : $C
  br bb8(%17 : $Optional<C>)

bb7:
  strong_release %1 : $AnyObject
  %20 = enum $Optional<C>, #Optional.none!enumelt
  br bb8(%20 : $Optional<C>)

bb8(%22 : $Optional<C>):
  switch_enum %22 : $Optional<C>, case #Optional.some!enumelt.1: bb10, default bb9

bb9:
  strong_release %13 : $C
  br bb13

bb10(%26 : $C):

  %27 = function_ref @_TZFsoi3eeeFTGSqPs9AnyObject__GSqPS____Sb : $@convention(thin) (@owned Optional<AnyObject>, @owned Optional<AnyObject>) -> Bool
  strong_retain %13 : $C
  %29 = init_existential_ref %13 : $C : $C, $AnyObject
  %30 = enum $Optional<AnyObject>, #Optional.some!enumelt.1, %29 : $AnyObject
  strong_retain %26 : $C
  %32 = init_existential_ref %26 : $C : $C, $AnyObject
  %33 = enum $Optional<AnyObject>, #Optional.some!enumelt.1, %32 : $AnyObject
  %34 = apply %27(%30, %33) : $@convention(thin) (@owned Optional<AnyObject>, @owned Optional<AnyObject>) -> Bool
  %35 = struct_extract %34 : $Bool, #Bool._value
  cond_br %35, bb11, bb12

bb11:
  %37 = integer_literal $Builtin.Int32, 1
  %38 = struct $Int32 (%37 : $Builtin.Int32)
  strong_release %26 : $C
  strong_release %13 : $C
  br bb14(%38 : $Int32)

bb12:
  strong_release %26 : $C
  strong_release %13 : $C
  br bb13

bb13:
  %45 = integer_literal $Builtin.Int32, 0
  %46 = struct $Int32 (%45 : $Builtin.Int32)
  br bb14(%46 : $Int32)

bb14(%48 : $Int32):
  strong_release %1 : $AnyObject
  strong_release %0 : $AnyObject
  return %48 : $Int32
}


sil [serialized] @_TZFsoi3eeeFTGSqPs9AnyObject__GSqPS____Sb : $@convention(thin) (@owned Optional<AnyObject>, @owned Optional<AnyObject>) -> Bool