| // RUN: %target-sil-opt -enable-sil-verify-all %s -diagnostic-constant-propagation | %FileCheck %s |
| // RUN: %target-sil-opt -enable-sil-verify-all %s -performance-constant-propagation | %FileCheck %s |
| |
| // REQUIRES: objc_interop |
| |
| sil_stage canonical |
| |
| import Swift |
| import Foundation |
| import Builtin |
| |
| sil @$ss11AnyHashableVyABxcSHRzlufC : $@convention(method) <τ_0_0 where τ_0_0 : Hashable> (@in τ_0_0, @thin AnyHashable.Type) -> @out AnyHashable |
| |
| sil @guaranteed_swift_array_user : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| |
| // CHECK-LABEL: sil @array_downcast_copyonsuccess : $@convention(thin) (@guaranteed NSArray) -> () { |
| // CHECK: bb0([[ARG:%.*]] : $NSArray): |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSArray |
| // CHECK: retain_value [[ARG]] |
| // CHECK: store [[ARG]] to [[INPUT]] |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<String> |
| // CHECK: [[INPUT_VALUE:%.*]] = load [[INPUT]] |
| // CHECK: br [[BRIDGE_BB:bb[0-9]+]]([[INPUT_VALUE]] : |
| // |
| // CHECK: [[BRIDGE_BB]]([[INPUT_VALUE:%.*]] : $NSArray): |
| // CHECK: [[CAST_TMP:%.*]] = alloc_stack $Optional<Array<String>> |
| // CHECK: strong_retain [[INPUT_VALUE]] |
| // CHECK: apply {{%.*}}<Array<String>>([[CAST_TMP]], [[INPUT_VALUE]], |
| // CHECK: strong_release [[INPUT_VALUE]] |
| // CHECK: switch_enum_addr [[CAST_TMP]] : $*Optional<Array<String>>, case #Optional.some!enumelt.1: [[SUCCESS_TRAMPOLINE_BB:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL_BB:bb[0-9]+]] |
| // |
| // CHECK: [[SUCCESS_TRAMPOLINE_BB]]: |
| // CHECK: [[PROJ_ENUM:%.*]] = unchecked_take_enum_data_addr [[CAST_TMP]] |
| // CHECK: copy_addr [take] [[PROJ_ENUM]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_TMP]] |
| // CHECK: br [[SUCCESS_BB:bb[0-9]+]] |
| // |
| // CHECK: [[SUCCESS_BB]]: |
| // CHECK: [[SUCCESS_VAL:%.*]] = load [[OUTPUT]] |
| // CHECK: [[CAST_RESULT:%.*]] = apply {{%.*}}<String>([[SUCCESS_VAL]]) |
| // CHECK-NEXT: release_value [[SUCCESS_VAL]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[FAIL_BB]]: |
| // CHECK-NEXT: dealloc_stack [[CAST_TMP:%.*]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK: return |
| // |
| // CHECK: } // end sil function 'array_downcast_copyonsuccess' |
| sil @array_downcast_copyonsuccess : $@convention(thin) (@guaranteed NSArray) -> () { |
| bb0(%0 : $NSArray): |
| %4 = alloc_stack $NSArray |
| retain_value %0 : $NSArray |
| store %0 to %4 : $*NSArray |
| %7 = alloc_stack $Array<String> |
| checked_cast_addr_br copy_on_success NSArray in %4 : $*NSArray to Array<String> in %7 : $*Array<String>, bb2, bb3 |
| |
| bb2: |
| %9 = load %7 : $*Array<String> |
| %10 = function_ref @guaranteed_swift_array_user : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| apply %10<String>(%9) : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| release_value %9 : $Array<String> |
| dealloc_stack %7 : $*Array<String> |
| destroy_addr %4 : $*NSArray |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb3: |
| dealloc_stack %7 : $*Array<String> |
| destroy_addr %4 : $*NSArray |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb4: |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @array_downcast_takeonsuccess : $@convention(thin) (@guaranteed NSArray) -> () { |
| // CHECK: bb0([[ARG:%.*]] : $NSArray): |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSArray |
| // CHECK: retain_value [[ARG]] |
| // CHECK: store [[ARG]] to [[INPUT]] |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<String> |
| // CHECK: [[INPUT_VALUE:%.*]] = load [[INPUT]] |
| // CHECK: br [[BRIDGE_BB:bb[0-9]+]]([[INPUT_VALUE]] : |
| // |
| // CHECK: [[BRIDGE_BB]]([[INPUT_VALUE:%.*]] : $NSArray): |
| // CHECK: [[CAST_TMP:%.*]] = alloc_stack $Optional<Array<String>> |
| // CHECK: strong_retain [[INPUT_VALUE]] |
| // CHECK: apply {{%.*}}<Array<String>>([[CAST_TMP]], [[INPUT_VALUE]], |
| // CHECK: strong_release [[INPUT_VALUE]] |
| // NOTE: In contrast to with take_always, the release_value is above in SUCCESS_BLOCK |
| // CHECK: switch_enum_addr [[CAST_TMP]] : $*Optional<Array<String>>, case #Optional.some!enumelt.1: [[SUCCESS_TRAMPOLINE_BB:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL_BB:bb[0-9]+]] |
| // |
| // CHECK: [[SUCCESS_TRAMPOLINE_BB]]: |
| // CHECK: [[PROJ_ENUM:%.*]] = unchecked_take_enum_data_addr [[CAST_TMP]] |
| // CHECK: copy_addr [take] [[PROJ_ENUM]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_TMP]] |
| // CHECK: br [[SUCCESS_BB:bb[0-9]+]] |
| // |
| // CHECK: [[SUCCESS_BB]]: |
| // CHECK: strong_release [[INPUT_VALUE:%.*]] : |
| // CHECK: [[SUCCESS_VAL:%.*]] = load [[OUTPUT]] |
| // CHECK: [[CAST_RESULT:%.*]] = apply {{%.*}}<String>([[SUCCESS_VAL]]) |
| // CHECK-NEXT: release_value [[SUCCESS_VAL]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[FAIL_BB]]: |
| // CHECK-NEXT: dealloc_stack [[CAST_TMP:%.*]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK: return |
| // CHECK: } // end sil function 'array_downcast_takeonsuccess' |
| sil @array_downcast_takeonsuccess : $@convention(thin) (@guaranteed NSArray) -> () { |
| bb0(%0 : $NSArray): |
| %4 = alloc_stack $NSArray |
| retain_value %0 : $NSArray |
| store %0 to %4 : $*NSArray |
| %7 = alloc_stack $Array<String> |
| checked_cast_addr_br take_on_success NSArray in %4 : $*NSArray to Array<String> in %7 : $*Array<String>, bb2, bb3 |
| |
| bb2: |
| %9 = load %7 : $*Array<String> |
| %10 = function_ref @guaranteed_swift_array_user : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| apply %10<String>(%9) : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| release_value %9 : $Array<String> |
| dealloc_stack %7 : $*Array<String> |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb3: |
| dealloc_stack %7 : $*Array<String> |
| destroy_addr %4 : $*NSArray |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb4: |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @array_downcast_takealways : $@convention(thin) (@guaranteed NSArray) -> () { |
| // CHECK: bb0([[ARG:%.*]] : $NSArray): |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSArray |
| // CHECK: retain_value [[ARG]] |
| // CHECK: store [[ARG]] to [[INPUT]] |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<String> |
| // CHECK: [[INPUT_VALUE:%.*]] = load [[INPUT]] |
| // CHECK: br [[BRIDGE_BB:bb[0-9]+]]([[INPUT_VALUE]] : |
| // |
| // CHECK: [[BRIDGE_BB]]([[INPUT_VALUE:%.*]] : $NSArray): |
| // CHECK: [[CAST_TMP:%.*]] = alloc_stack $Optional<Array<String>> |
| // CHECK: strong_retain [[INPUT_VALUE]] |
| // CHECK: apply {{%.*}}<Array<String>>([[CAST_TMP]], [[INPUT_VALUE]], |
| // CHECK: strong_release [[INPUT_VALUE]] |
| // NOTE: When we perform take_always, this is the take of the cast. |
| // CHECK: strong_release [[INPUT_VALUE]] |
| // CHECK: switch_enum_addr [[CAST_TMP]] : $*Optional<Array<String>>, case #Optional.some!enumelt.1: [[SUCCESS_TRAMPOLINE_BB:bb[0-9]+]], case #Optional.none!enumelt: [[FAIL_BB]] |
| // |
| // CHECK: [[SUCCESS_TRAMPOLINE_BB]]: |
| // CHECK: [[PROJ_ENUM:%.*]] = unchecked_take_enum_data_addr [[CAST_TMP]] |
| // CHECK: copy_addr [take] [[PROJ_ENUM]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_TMP]] |
| // CHECK: br [[SUCCESS_BB]] |
| // |
| // |
| // CHECK: [[SUCCESS_BB:bb[0-9]+]]: |
| // CHECK: [[SUCCESS_VAL:%.*]] = load [[OUTPUT]] |
| // CHECK: [[CAST_RESULT:%.*]] = apply {{%.*}}<String>([[SUCCESS_VAL]]) |
| // CHECK-NEXT: release_value [[SUCCESS_VAL]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[FAIL_BB:bb[0-9]+]]: |
| // CHECK-NEXT: dealloc_stack [[CAST_TMP:%.*]] |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK: return |
| // |
| // CHECK: } // end sil function 'array_downcast_takealways' |
| sil @array_downcast_takealways : $@convention(thin) (@guaranteed NSArray) -> () { |
| bb0(%0 : $NSArray): |
| %4 = alloc_stack $NSArray |
| retain_value %0 : $NSArray |
| store %0 to %4 : $*NSArray |
| %7 = alloc_stack $Array<String> |
| checked_cast_addr_br take_always NSArray in %4 : $*NSArray to Array<String> in %7 : $*Array<String>, bb2, bb3 |
| |
| bb2: |
| %9 = load %7 : $*Array<String> |
| %10 = function_ref @guaranteed_swift_array_user : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| apply %10<String>(%9) : $@convention(thin) <τ_0_0> (@guaranteed Array<τ_0_0>) -> () |
| release_value %9 : $Array<String> |
| dealloc_stack %7 : $*Array<String> |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb3: |
| dealloc_stack %7 : $*Array<String> |
| dealloc_stack %4 : $*NSArray |
| br bb4 |
| |
| bb4: |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // Make sure we handle correctly various sorts of NSObject casts without |
| // breaking ownership invariants when compiling in ossa. |
| |
| // CHECK-LABEL: sil @nsobject_test_take_always_string : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $String |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSString, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: strong_release [[LOADED_INPUT]] |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<String> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<String>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<String>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_always_string' |
| sil @nsobject_test_take_always_string : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $String |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_always NSObject in %nsSource : $*NSObject to String in %stringDest : $*String, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*String |
| br bb4 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*String |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_on_success_string : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $String |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSString, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<String> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<String>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<String>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_on_success_string' |
| sil @nsobject_test_take_on_success_string : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $String |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_on_success NSObject in %nsSource : $*NSObject to String in %stringDest : $*String, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*String |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*String |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_copy_on_success_string : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $String |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSString, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<String> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<String>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<String>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: destroy_addr [[INPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_copy_on_success_string' |
| sil @nsobject_test_copy_on_success_string : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $String |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br copy_on_success NSObject in %nsSource : $*NSObject to String in %stringDest : $*String, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*String |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*String |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_always_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSArray, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: strong_release [[LOADED_INPUT]] |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Array<Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Array<Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Array<Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_always_array_of_any' |
| sil @nsobject_test_take_always_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Array<Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_always NSObject in %nsSource : $*NSObject to Array<Any> in %stringDest : $*Array<Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Array<Any> |
| br bb4 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Array<Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_on_success_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSArray, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Array<Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Array<Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Array<Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_on_success_array_of_any' |
| sil @nsobject_test_take_on_success_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Array<Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_on_success NSObject in %nsSource : $*NSObject to Array<Any> in %stringDest : $*Array<Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Array<Any> |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Array<Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_copy_on_success_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Array<Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSArray, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Array<Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Array<Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Array<Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: destroy_addr [[INPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_copy_on_success_array_of_any' |
| sil @nsobject_test_copy_on_success_array_of_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Array<Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br copy_on_success NSObject in %nsSource : $*NSObject to Array<Any> in %stringDest : $*Array<Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Array<Any> |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Array<Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_always_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Dictionary<AnyHashable, Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSDictionary, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: strong_release [[LOADED_INPUT]] |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Dictionary<AnyHashable, Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Dictionary<AnyHashable, Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Dictionary<AnyHashable, Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_always_dictionary_anyhashable_to_any' |
| sil @nsobject_test_take_always_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Dictionary<AnyHashable, Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_always NSObject in %nsSource : $*NSObject to Dictionary<AnyHashable, Any> in %stringDest : $*Dictionary<AnyHashable, Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Dictionary<AnyHashable, Any> |
| br bb4 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Dictionary<AnyHashable, Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_on_success_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Dictionary<AnyHashable, Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSDictionary, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Dictionary<AnyHashable, Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Dictionary<AnyHashable, Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Dictionary<AnyHashable, Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_on_success_dictionary_anyhashable_to_any' |
| sil @nsobject_test_take_on_success_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Dictionary<AnyHashable, Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_on_success NSObject in %nsSource : $*NSObject to Dictionary<AnyHashable, Any> in %stringDest : $*Dictionary<AnyHashable, Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Dictionary<AnyHashable, Any> |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Dictionary<AnyHashable, Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_copy_on_success_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Dictionary<AnyHashable, Any> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSDictionary, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Dictionary<AnyHashable, Any>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Dictionary<AnyHashable, Any>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Dictionary<AnyHashable, Any>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: destroy_addr [[INPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_copy_on_success_dictionary_anyhashable_to_any' |
| sil @nsobject_test_copy_on_success_dictionary_anyhashable_to_any : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Dictionary<AnyHashable, Any> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br copy_on_success NSObject in %nsSource : $*NSObject to Dictionary<AnyHashable, Any> in %stringDest : $*Dictionary<AnyHashable, Any>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Dictionary<AnyHashable, Any> |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Dictionary<AnyHashable, Any> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_always_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Set<AnyHashable> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSSet, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: strong_release [[LOADED_INPUT]] |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Set<AnyHashable>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Set<AnyHashable>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Set<AnyHashable>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_always_set_anyhashable' |
| sil @nsobject_test_take_always_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Set<AnyHashable> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_always NSObject in %nsSource : $*NSObject to Set<AnyHashable> in %stringDest : $*Set<AnyHashable>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Set<AnyHashable> |
| br bb4 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Set<AnyHashable> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_take_on_success_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Set<AnyHashable> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSSet, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Set<AnyHashable>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Set<AnyHashable>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Set<AnyHashable>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_take_on_success_set_anyhashable' |
| sil @nsobject_test_take_on_success_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Set<AnyHashable> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br take_on_success NSObject in %nsSource : $*NSObject to Set<AnyHashable> in %stringDest : $*Set<AnyHashable>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Set<AnyHashable> |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Set<AnyHashable> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @nsobject_test_copy_on_success_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[INPUT:%.*]] = alloc_stack $NSObject |
| // CHECK: store [[ARG]] to [[INPUT]] : |
| // CHECK: [[OUTPUT:%.*]] = alloc_stack $Set<AnyHashable> |
| // CHECK: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK: [[LOADED_INPUT:%.*]] = load [[INPUT]] |
| // CHECK: checked_cast_br [[LOADED_INPUT]] : $NSObject to $NSSet, [[YES_BB:bb[0-9]+]], [[NO_BB:bb[0-9]+]] |
| // |
| // CHECK: [[NO_BB]]: |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE:bb[0-9]+]] |
| // |
| // CHECK: [[YES_BB]]([[CASTED_INPUT:%.*]] : |
| // CHECK: [[CAST_RESULT:%.*]] = alloc_stack $Optional<Set<AnyHashable>> |
| // CHECK: strong_retain [[CASTED_INPUT]] |
| // CHECK: apply {{%.*}}<Set<AnyHashable>>([[CAST_RESULT]], [[CASTED_INPUT]], {{%.*}}) : |
| // CHECK: strong_release [[CASTED_INPUT]] |
| // CHECK-NOT: strong_release [[CASTED_INPUT]] |
| // CHECK: switch_enum_addr [[CAST_RESULT]] : $*Optional<Set<AnyHashable>>, case #Optional.some!enumelt.1: [[COND_CAST_SUCC:bb[0-9]+]], case #Optional.none!enumelt: [[COND_CAST_FAIL:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_SUCC]]: |
| // CHECK: [[UNWRAPPED_CAST_RESULT:%.*]] = unchecked_take_enum_data_addr [[CAST_RESULT]] |
| // CHECK: copy_addr [take] [[UNWRAPPED_CAST_RESULT]] to [initialization] [[OUTPUT]] |
| // CHECK: dealloc_stack [[CAST_RESULT]] |
| // CHECK: destroy_addr [[OUTPUT]] |
| // CHECK: destroy_addr [[INPUT]] |
| // CHECK: br [[EXIT_BB:bb[0-9]+]] |
| // |
| // CHECK: [[COND_CAST_FAIL]]: |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: br [[FAIL_EXIT_TRAMPOLINE]] |
| // |
| // CHECK: [[FAIL_EXIT_TRAMPOLINE]]: |
| // CHECK-NEXT: destroy_addr [[INPUT]] |
| // CHECK-NEXT: br [[EXIT_BB]] |
| // |
| // CHECK: [[EXIT_BB]]: |
| // CHECK-NEXT: dealloc_stack [[OUTPUT]] |
| // CHECK-NEXT: dealloc_stack [[INPUT]] |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: return |
| // CHECK: } // end sil function 'nsobject_test_copy_on_success_set_anyhashable' |
| sil @nsobject_test_copy_on_success_set_anyhashable : $@convention(thin) (@owned NSObject) -> () { |
| bb0(%0 : $NSObject): |
| %nsSource = alloc_stack $NSObject |
| store %0 to %nsSource : $*NSObject |
| %stringDest = alloc_stack $Set<AnyHashable> |
| br bb1 |
| |
| bb1: |
| checked_cast_addr_br copy_on_success NSObject in %nsSource : $*NSObject to Set<AnyHashable> in %stringDest : $*Set<AnyHashable>, bb2, bb3 |
| |
| bb2: |
| destroy_addr %stringDest : $*Set<AnyHashable> |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb3: |
| destroy_addr %nsSource : $*NSObject |
| br bb4 |
| |
| bb4: |
| dealloc_stack %stringDest : $*Set<AnyHashable> |
| dealloc_stack %nsSource : $*NSObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| @objc class ObjCClass {} |
| |
| struct Str: _ObjectiveCBridgeable { |
| func _bridgeToObjectiveC() -> ObjCClass |
| static func _forceBridgeFromObjectiveC(_ source: ObjCClass, |
| result: inout Str?) |
| static func _conditionallyBridgeFromObjectiveC(_ source: ObjCClass, |
| result: inout Str?) -> Bool |
| static func _unconditionallyBridgeFromObjectiveC(_ source: ObjCClass?) -> Str |
| |
| // Make it a non-trivial type |
| var x: AnyObject? |
| } |
| |
| // CHECK-LABEL: sil @checked_cast_with_take_always : |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[TEMP_MEM:%[0-9]+]] = alloc_stack |
| // CHECK: [[LOADED_VALUE:%[0-9]+]] = load [[ARG]] |
| // CHECK-NEXT: [[RESULT:%[0-9]+]] = apply %{{[0-9]+}}([[LOADED_VALUE]]) |
| // CHECK-NEXT: release_value [[LOADED_VALUE]] |
| // CHECK-NEXT: store [[RESULT]] to [[TEMP_MEM]] |
| // CHECK-NEXT: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK-NEXT: [[RESULT:%.*]] = load [[TEMP_MEM]] |
| // CHECK-NEXT: [[ENUM:%.*]] = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, [[RESULT]] |
| // CHECK-NEXT: br bb3([[ENUM]] : |
| // |
| // CHECK: bb3([[RESULT:%.*]] : $Optional<ObjCClass>): |
| // CHECK-NEXT: dealloc_stack [[TEMP_MEM]] |
| // CHECK-NEXT: return [[RESULT]] |
| // CHECK: } // end sil function 'checked_cast_with_take_always' |
| sil @checked_cast_with_take_always : $@convention(thin) (@in Str) -> @owned Optional<ObjCClass> { |
| bb0(%0 : $*Str): |
| %b = alloc_stack $ObjCClass |
| checked_cast_addr_br take_always Str in %0 : $*Str to ObjCClass in %b : $*ObjCClass, bb1, bb2 |
| |
| bb1: |
| %r1 = load %b : $*ObjCClass |
| %r1Enum = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, %r1 : $ObjCClass |
| br bb3(%r1Enum : $Optional<ObjCClass>) |
| |
| bb2: |
| %none = enum $Optional<ObjCClass>, #Optional.none!enumelt |
| br bb3(%none : $Optional<ObjCClass>) |
| |
| bb3(%result : $Optional<ObjCClass>): |
| dealloc_stack %b : $*ObjCClass |
| return %result : $Optional<ObjCClass> |
| } |
| |
| // CHECK-LABEL: sil @checked_cast_with_take_on_success : |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[TEMP_MEM:%[0-9]+]] = alloc_stack |
| // CHECK: [[LOADED_VALUE:%[0-9]+]] = load [[ARG]] |
| // CHECK-NEXT: [[RESULT:%[0-9]+]] = apply %{{[0-9]+}}([[LOADED_VALUE]]) |
| // CHECK-NEXT: store [[RESULT]] to [[TEMP_MEM]] |
| // CHECK-NEXT: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK-NEXT: release_value [[LOADED_VALUE]] |
| // CHECK-NEXT: [[RESULT:%.*]] = load [[TEMP_MEM]] |
| // CHECK-NEXT: [[ENUM:%.*]] = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, [[RESULT]] |
| // CHECK-NEXT: br bb3([[ENUM]] : |
| // |
| // CHECK: bb3([[RESULT:%.*]] : $Optional<ObjCClass>): |
| // CHECK-NEXT: dealloc_stack [[TEMP_MEM]] |
| // CHECK-NEXT: return [[RESULT]] |
| // CHECK: } // end sil function 'checked_cast_with_take_on_success' |
| sil @checked_cast_with_take_on_success : $@convention(thin) (@in Str) -> @owned Optional<ObjCClass> { |
| bb0(%0 : $*Str): |
| %b = alloc_stack $ObjCClass |
| checked_cast_addr_br take_on_success Str in %0 : $*Str to ObjCClass in %b : $*ObjCClass, bb1, bb2 |
| |
| bb1: |
| %r1 = load %b : $*ObjCClass |
| %r1Enum = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, %r1 : $ObjCClass |
| br bb3(%r1Enum : $Optional<ObjCClass>) |
| |
| bb2: |
| %none = enum $Optional<ObjCClass>, #Optional.none!enumelt |
| destroy_addr %0 : $*Str |
| br bb3(%none : $Optional<ObjCClass>) |
| |
| bb3(%result : $Optional<ObjCClass>): |
| dealloc_stack %b : $*ObjCClass |
| return %result : $Optional<ObjCClass> |
| } |
| |
| // CHECK-LABEL: sil @checked_cast_with_copy_on_success : |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[TEMP_MEM:%[0-9]+]] = alloc_stack |
| // CHECK: [[LOADED_VALUE:%[0-9]+]] = load [[ARG]] |
| // CHECK-NEXT: [[RESULT:%[0-9]+]] = apply %{{[0-9]+}}([[LOADED_VALUE]]) |
| // CHECK-NEXT: store [[RESULT]] to [[TEMP_MEM]] |
| // CHECK-NEXT: br bb1 |
| // |
| // CHECK: bb1: |
| // CHECK-NEXT: store [[LOADED_VALUE]] to [[ARG]] |
| // CHECK-NEXT: [[RESULT:%.*]] = load [[TEMP_MEM]] |
| // CHECK-NEXT: [[ENUM:%.*]] = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, [[RESULT]] |
| // CHECK-NEXT: br bb3([[ENUM]] : |
| // |
| // CHECK: bb3([[RESULT:%.*]] : $Optional<ObjCClass>): |
| // CHECK-NEXT: destroy_addr [[ARG]] |
| // CHECK-NEXT: dealloc_stack [[TEMP_MEM]] |
| // CHECK-NEXT: return [[RESULT]] |
| // CHECK: } // end sil function 'checked_cast_with_copy_on_success' |
| sil @checked_cast_with_copy_on_success : $@convention(thin) (@in Str) -> @owned Optional<ObjCClass> { |
| bb0(%0 : $*Str): |
| %b = alloc_stack $ObjCClass |
| checked_cast_addr_br copy_on_success Str in %0 : $*Str to ObjCClass in %b : $*ObjCClass, bb1, bb2 |
| |
| bb1: |
| %r1 = load %b : $*ObjCClass |
| %r1Enum = enum $Optional<ObjCClass>, #Optional.some!enumelt.1, %r1 : $ObjCClass |
| br bb3(%r1Enum : $Optional<ObjCClass>) |
| |
| bb2: |
| %none = enum $Optional<ObjCClass>, #Optional.none!enumelt |
| br bb3(%none : $Optional<ObjCClass>) |
| |
| bb3(%result : $Optional<ObjCClass>): |
| destroy_addr %0 : $*Str |
| dealloc_stack %b : $*ObjCClass |
| return %result : $Optional<ObjCClass> |
| } |
