| // RUN: %target-sil-opt -enable-sil-verify-all -predictable-memaccess-opts %s | %FileCheck %s |
| |
| sil_stage raw |
| |
| import Builtin |
| import Swift |
| |
| ////////////////// |
| // Declarations // |
| ////////////////// |
| |
| class Klass {} |
| |
| struct NativeObjectPair { |
| var x: Builtin.NativeObject |
| var y: Builtin.NativeObject |
| } |
| |
| struct IntPair { |
| var x: Builtin.Int32 |
| var y: Builtin.Int32 |
| } |
| |
| sil @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| sil @intpair_user : $@convention(thin) (IntPair) -> () |
| sil @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| sil @inout_int32_user : $@convention(thin) (@inout Builtin.Int32) -> () |
| sil @get_object : $@convention(thin) () -> @owned Builtin.NativeObject |
| sil @nativeobject_tuple_user : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| |
| /// Needed to avoid tuple scalarization code in the use gatherer. |
| struct NativeObjectAndTuple { |
| var first: Builtin.NativeObject |
| var second: (Builtin.NativeObject, Builtin.NativeObject) |
| } |
| |
| /////////// |
| // Tests // |
| /////////// |
| |
| //===--- |
| // Fully Available Leaf Node Values |
| // |
| |
| // CHECK-LABEL: sil [ossa] @simple_trivial_load_promotion : $@convention(thin) (Builtin.Int32) -> Builtin.Int32 { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: return [[ARG]] |
| // CHECK: } // end sil function 'simple_trivial_load_promotion' |
| sil [ossa] @simple_trivial_load_promotion : $@convention(thin) (Builtin.Int32) -> Builtin.Int32 { |
| bb0(%0 : $Builtin.Int32): |
| %1 = alloc_stack $Builtin.Int32 |
| store %0 to [trivial] %1 : $*Builtin.Int32 |
| %2 = load [trivial] %1 : $*Builtin.Int32 |
| dealloc_stack %1 : $*Builtin.Int32 |
| return %2 : $Builtin.Int32 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @simple_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[STACK:%.*]] = alloc_stack $Builtin.NativeObject |
| // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: [[ARG_COPY_2:%.*]] = copy_value [[ARG_COPY]] |
| // CHECK: destroy_value [[ARG_COPY]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[ARG_COPY_2]] |
| // CHECK: } // end sil function 'simple_nontrivial_load_promotion' |
| sil [ossa] @simple_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| %2 = load [copy] %1 : $*Builtin.NativeObject |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| return %2 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @struct_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $NativeObjectPair |
| // CHECK: [[FIRST_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: [[ARG1_COPY_BORROW:%.*]] = begin_borrow [[ARG1_COPY]] |
| // CHECK: [[ARG2_COPY_BORROW:%.*]] = begin_borrow [[ARG2_COPY]] |
| // CHECK: [[RESULT:%.*]] = struct $NativeObjectPair ([[ARG1_COPY_BORROW:%.*]] : $Builtin.NativeObject, [[ARG2_COPY_BORROW:%.*]] : $Builtin.NativeObject) |
| // CHECK: [[RESULT_COPY_1:%.*]] = copy_value [[RESULT]] |
| // CHECK: [[RESULT_COPY_2:%.*]] = copy_value [[RESULT_COPY_1]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT_COPY_2]] |
| // CHECK: } // end sil function 'struct_nontrivial_load_promotion' |
| sil [ossa] @struct_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $NativeObjectPair |
| %3 = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.x |
| %4 = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0 to [init] %3 : $*Builtin.NativeObject |
| store %1 to [init] %4 : $*Builtin.NativeObject |
| %5 = load [copy] %2 : $*NativeObjectPair |
| destroy_addr %2 : $*NativeObjectPair |
| dealloc_stack %2 : $*NativeObjectPair |
| return %5 : $NativeObjectPair |
| } |
| |
| // CHECK-LABEL: sil [ossa] @tuple_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| // CHECK: [[FIRST_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: [[RESULT:%.*]] = tuple ([[ARG1_COPY:%.*]] : $Builtin.NativeObject, [[ARG2_COPY:%.*]] : $Builtin.NativeObject) |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT]] |
| // CHECK: } // end sil function 'tuple_nontrivial_load_promotion' |
| sil [ossa] @tuple_nontrivial_load_promotion : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| %3 = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4 = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0 to [init] %3 : $*Builtin.NativeObject |
| store %1 to [init] %4 : $*Builtin.NativeObject |
| %5 = load [copy] %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| destroy_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| return %5 : $(Builtin.NativeObject, Builtin.NativeObject) |
| } |
| |
| // CHECK-LABEL: sil [ossa] @simple_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[STACK:%.*]] = alloc_stack $Builtin.NativeObject |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: br bb3([[ARG_COPY]] : |
| // |
| // CHECK: bb2: |
| // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: br bb3([[ARG_COPY]] : |
| // |
| // CHECK: bb3([[RESULT:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[RESULT_COPY_1:%.*]] = copy_value [[RESULT]] |
| // CHECK: [[RESULT_COPY_2:%.*]] = copy_value [[RESULT_COPY_1]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT_COPY_2]] |
| // CHECK: } // end sil function 'simple_nontrivial_load_promotion_multi_insertpt' |
| sil [ossa] @simple_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| %2 = load [copy] %1 : $*Builtin.NativeObject |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| return %2 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @struct_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $NativeObjectPair |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: [[FIRST_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject, [[ARG2_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb2: |
| // CHECK: [[FIRST_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject, [[ARG2_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb3([[ARG1_COPY:%.*]] : @owned $Builtin.NativeObject, [[ARG2_COPY:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[ARG1_COPY_COPY:%.*]] = copy_value [[ARG1_COPY]] |
| // CHECK: [[ARG2_COPY_COPY:%.*]] = copy_value [[ARG2_COPY]] |
| // CHECK: [[ARG1_COPY_COPY_BORROW:%.*]] = begin_borrow [[ARG1_COPY_COPY]] |
| // CHECK: [[ARG2_COPY_COPY_BORROW:%.*]] = begin_borrow [[ARG2_COPY_COPY]] |
| // CHECK: [[RESULT:%.*]] = struct $NativeObjectPair ([[ARG1_COPY_COPY_BORROW:%.*]] : $Builtin.NativeObject, [[ARG2_COPY_COPY_BORROW:%.*]] : $Builtin.NativeObject) |
| // CHECK: [[RESULT_COPY:%.*]] = copy_value [[RESULT]] |
| // CHECK: [[RESULT_COPY_2:%.*]] = copy_value [[RESULT_COPY]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT_COPY_2]] |
| // CHECK: } // end sil function 'struct_nontrivial_load_promotion_multi_insertpt' |
| sil [ossa] @struct_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $NativeObjectPair |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %3a = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.x |
| %4a = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0 to [init] %3a : $*Builtin.NativeObject |
| store %1 to [init] %4a : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| %3b = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.x |
| %4b = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0 to [init] %3b : $*Builtin.NativeObject |
| store %1 to [init] %4b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| %5 = load [copy] %2 : $*NativeObjectPair |
| destroy_addr %2 : $*NativeObjectPair |
| dealloc_stack %2 : $*NativeObjectPair |
| return %5 : $NativeObjectPair |
| } |
| |
| // CHECK-LABEL: sil [ossa] @tuple_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: [[FIRST_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject, [[ARG2_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb2: |
| // CHECK: [[FIRST_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: [[ARG2_COPY:%.*]] = copy_value [[ARG2]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject, [[ARG2_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb3([[ARG1_COPY:%.*]] : @owned $Builtin.NativeObject, [[ARG2_COPY:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[RESULT:%.*]] = tuple ([[ARG1_COPY:%.*]] : $Builtin.NativeObject, [[ARG2_COPY:%.*]] : $Builtin.NativeObject) |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT]] |
| // CHECK: } // end sil function 'tuple_nontrivial_load_promotion_multi_insertpt' |
| sil [ossa] @tuple_nontrivial_load_promotion_multi_insertpt : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %3a = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4a = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0 to [init] %3a : $*Builtin.NativeObject |
| store %1 to [init] %4a : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| %3b = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4b = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0 to [init] %3b : $*Builtin.NativeObject |
| store %1 to [init] %4b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| %5 = load [copy] %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| destroy_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| return %5 : $(Builtin.NativeObject, Builtin.NativeObject) |
| } |
| |
| //===--- |
| // Value Not Fully Available |
| // |
| |
| // CHECK-LABEL: sil [ossa] @struct_nontrivial_load_promotion_multi_insertpt_value_not_fully_available : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject, [[ARG3:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $NativeObjectPair |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: [[FIRST_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: destroy_value [[ARG3]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb2: |
| // CHECK: [[FIRST_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: destroy_value [[ARG2]] |
| // CHECK: store [[ARG3]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb3([[ARG1_COPY:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[ARG1_COPY_COPY:%.*]] = copy_value [[ARG1_COPY]] |
| // CHECK: [[SECOND_ADDR:%.*]] = struct_element_addr [[STACK]] |
| // CHECK: [[SECOND_VAL_COPY:%.*]] = load [copy] [[SECOND_ADDR]] |
| // CHECK: [[ARG1_COPY_COPY_BORROW:%.*]] = begin_borrow [[ARG1_COPY_COPY]] |
| // CHECK: [[SECOND_VAL_COPY_BORROW:%.*]] = begin_borrow [[SECOND_VAL_COPY]] |
| // CHECK: [[RESULT:%.*]] = struct $NativeObjectPair ([[ARG1_COPY_COPY_BORROW:%.*]] : $Builtin.NativeObject, [[SECOND_VAL_COPY_BORROW]] : $Builtin.NativeObject) |
| // CHECK: [[RESULT_COPY_1:%.*]] = copy_value [[RESULT]] |
| // CHECK: [[RESULT_COPY_2:%.*]] = copy_value [[RESULT_COPY_1]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT_COPY_2]] |
| // CHECK: } // end sil function 'struct_nontrivial_load_promotion_multi_insertpt_value_not_fully_available' |
| sil [ossa] @struct_nontrivial_load_promotion_multi_insertpt_value_not_fully_available : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned NativeObjectPair { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject, %arg2 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $NativeObjectPair |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %3a = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.x |
| %4a = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0 to [init] %3a : $*Builtin.NativeObject |
| store %1 to [init] %4a : $*Builtin.NativeObject |
| destroy_value %arg2 : $Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| %3b = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.x |
| %4b = struct_element_addr %2 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0 to [init] %3b : $*Builtin.NativeObject |
| destroy_value %1 : $Builtin.NativeObject |
| store %arg2 to [init] %4b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| %5 = load [copy] %2 : $*NativeObjectPair |
| destroy_addr %2 : $*NativeObjectPair |
| dealloc_stack %2 : $*NativeObjectPair |
| return %5 : $NativeObjectPair |
| } |
| |
| // CHECK-LABEL: sil [ossa] @tuple_nontrivial_load_promotion_multi_insertpt_value_not_fully_available : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| // CHECK: bb0([[ARG1:%.*]] : @owned $Builtin.NativeObject, [[ARG2:%.*]] : @owned $Builtin.NativeObject, [[ARG3:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| // This is here b/c we scalarize loads in our use list. Really, PMO shouldn't scalarize. |
| // CHECK: [[SCALARIZED_TUPLE_GEP:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: [[FIRST_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: store [[ARG2]] to [init] [[SECOND_ADDR]] |
| // CHECK: destroy_value [[ARG3]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb2: |
| // CHECK: [[FIRST_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[SECOND_ADDR:%.*]] = tuple_element_addr [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [init] [[FIRST_ADDR]] |
| // CHECK: destroy_value [[ARG2]] |
| // CHECK: store [[ARG3]] to [init] [[SECOND_ADDR]] |
| // CHECK: br bb3([[ARG1_COPY]] : $Builtin.NativeObject) |
| // |
| // CHECK: bb3([[ARG1_COPY:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[SECOND_VAL_COPY:%.*]] = load [copy] [[SCALARIZED_TUPLE_GEP]] |
| // CHECK: [[RESULT:%.*]] = tuple ([[ARG1_COPY:%.*]] : $Builtin.NativeObject, [[SECOND_VAL_COPY]] : $Builtin.NativeObject) |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT]] |
| // CHECK: } // end sil function 'tuple_nontrivial_load_promotion_multi_insertpt_value_not_fully_available' |
| sil [ossa] @tuple_nontrivial_load_promotion_multi_insertpt_value_not_fully_available : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned (Builtin.NativeObject, Builtin.NativeObject) { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject, %arg2 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %3a = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4a = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0 to [init] %3a : $*Builtin.NativeObject |
| store %1 to [init] %4a : $*Builtin.NativeObject |
| destroy_value %arg2 : $Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| %3b = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4b = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0 to [init] %3b : $*Builtin.NativeObject |
| destroy_value %1 : $Builtin.NativeObject |
| store %arg2 to [init] %4b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| %5 = load [copy] %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| destroy_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| return %5 : $(Builtin.NativeObject, Builtin.NativeObject) |
| } |
| |
| //===--- |
| // Tests For Partial Uses Of Available Value |
| // |
| |
| // CHECK-LABEL: sil [ossa] @simple_partialstructuse_load_promotion : $@convention(thin) (@owned NativeObjectPair) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : @owned $NativeObjectPair): |
| // CHECK: [[STACK:%.*]] = alloc_stack |
| // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]] |
| // CHECK: [[BORROWED_ARG_FIELD:%.*]] = struct_extract [[BORROWED_ARG]] |
| // CHECK: [[COPIED_ARG_FIELD:%.*]] = copy_value [[BORROWED_ARG_FIELD]] |
| // CHECK: end_borrow [[BORROWED_ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: [[COPIED_ARG_FIELD_COPY_1:%.*]] = copy_value [[COPIED_ARG_FIELD]] |
| // CHECK: [[COPIED_ARG_FIELD_COPY_2:%.*]] = copy_value [[COPIED_ARG_FIELD_COPY_1]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[COPIED_ARG_FIELD_COPY_2]] |
| // CHECK: } // end sil function 'simple_partialstructuse_load_promotion' |
| sil [ossa] @simple_partialstructuse_load_promotion : $@convention(thin) (@owned NativeObjectPair) -> (@owned Builtin.NativeObject) { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %3 = load [copy] %2 : $*Builtin.NativeObject |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| return %3 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @simple_partialtupleuse_load_promotion : $@convention(thin) (@owned NativeObjectAndTuple) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : @owned $NativeObjectAndTuple): |
| // CHECK: [[STACK:%.*]] = alloc_stack |
| // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]] |
| // CHECK: [[BORROWED_ARG_FIELD_1:%.*]] = struct_extract [[BORROWED_ARG]] |
| // CHECK: [[BORROWED_ARG_FIELD_2:%.*]] = tuple_extract [[BORROWED_ARG_FIELD_1]] |
| // CHECK: [[COPIED_ARG_FIELD:%.*]] = copy_value [[BORROWED_ARG_FIELD_2]] |
| // CHECK: end_borrow [[BORROWED_ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: [[COPIED_ARG_FIELD_COPY_1:%.*]] = copy_value [[COPIED_ARG_FIELD]] |
| // CHECK: [[COPIED_ARG_FIELD_COPY_2:%.*]] = copy_value [[COPIED_ARG_FIELD_COPY_1]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[COPIED_ARG_FIELD_COPY_2]] |
| // CHECK: } // end sil function 'simple_partialtupleuse_load_promotion' |
| sil [ossa] @simple_partialtupleuse_load_promotion : $@convention(thin) (@owned NativeObjectAndTuple) -> (@owned Builtin.NativeObject) { |
| bb0(%0 : @owned $NativeObjectAndTuple): |
| %1 = alloc_stack $NativeObjectAndTuple |
| store %0 to [init] %1 : $*NativeObjectAndTuple |
| %2 = struct_element_addr %1 : $*NativeObjectAndTuple, #NativeObjectAndTuple.second |
| %3 = tuple_element_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %4 = load [copy] %3 : $*Builtin.NativeObject |
| destroy_addr %1 : $*NativeObjectAndTuple |
| dealloc_stack %1 : $*NativeObjectAndTuple |
| return %4 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @simple_assignstore : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG0:%.*]] : @owned $Builtin.NativeObject, [[ARG1:%.*]] : @owned $Builtin.NativeObject): |
| // CHECK: [[STACK:%.*]] = alloc_stack $Builtin.NativeObject |
| // CHECK: store [[ARG0]] to [init] [[STACK]] |
| // CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]] |
| // CHECK: store [[ARG1]] to [assign] [[STACK]] |
| // CHECK: [[ARG1_COPY_1:%.*]] = copy_value [[ARG1_COPY]] |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[ARG1_COPY_1]] |
| // CHECK: } // end sil function 'simple_assignstore' |
| sil [ossa] @simple_assignstore : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %2 : $*Builtin.NativeObject |
| store %1 to [assign] %2 : $*Builtin.NativeObject |
| %3 = load [copy] %2 : $*Builtin.NativeObject |
| destroy_addr %2 : $*Builtin.NativeObject |
| dealloc_stack %2 : $*Builtin.NativeObject |
| return %3 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @diamond_test_2 : $@convention(thin) (@owned NativeObjectPair) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : @owned $NativeObjectPair): |
| // CHECK: [[STACK:%.*]] = alloc_stack $NativeObjectPair |
| // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]] |
| // CHECK: [[LHS1:%.*]] = struct_extract [[BORROWED_ARG]] : $NativeObjectPair, #NativeObjectPair.x |
| // CHECK: [[LHS1_COPY:%.*]] = copy_value [[LHS1]] |
| // CHECK: [[BORROWED_ARG:%.*]] = begin_borrow [[ARG]] |
| // CHECK: [[LHS2:%.*]] = struct_extract [[BORROWED_ARG]] : $NativeObjectPair, #NativeObjectPair.x |
| // CHECK: [[LHS2_COPY:%.*]] = copy_value [[LHS2]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: cond_br undef, bb1, bb2 |
| // |
| // CHECK: bb1: |
| // CHECK: destroy_value [[LHS1_COPY]] |
| // CHECK: [[LHS2_COPY_1:%.*]] = copy_value [[LHS2_COPY]] |
| // CHECK: [[LHS2_COPY_2:%.*]] = copy_value [[LHS2_COPY_1]] |
| // CHECK: br bb3([[LHS2_COPY_2]] : |
| // |
| // CHECK: bb2: |
| // CHECK: destroy_value [[LHS2_COPY]] |
| // CHECK: [[LHS1_COPY_1:%.*]] = copy_value [[LHS1_COPY]] |
| // CHECK: [[LHS1_COPY_2:%.*]] = copy_value [[LHS1_COPY_1]] |
| // CHECK: br bb3([[LHS1_COPY_2]] : |
| // |
| // CHECK: bb3([[PHI:%.*]] : |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[PHI]] |
| // CHECK: } // end sil function 'diamond_test_2' |
| sil [ossa] @diamond_test_2 : $@convention(thin) (@owned NativeObjectPair) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %3 = load [copy] %2 : $*Builtin.NativeObject |
| br bb3(%3 : $Builtin.NativeObject) |
| |
| bb2: |
| %4 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %5 = load [copy] %4 : $*Builtin.NativeObject |
| br bb3(%5 : $Builtin.NativeObject) |
| |
| bb3(%6 : @owned $Builtin.NativeObject): |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| return %6 : $Builtin.NativeObject |
| } |
| |
| //////////////////// |
| // Negative Tests // |
| //////////////////// |
| |
| // CHECK-LABEL: sil [ossa] @simple_nontrivial_loadtake_no_promote : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : |
| // CHECK: [[STACK:%.*]] = alloc_stack $Builtin.NativeObject |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: [[RESULT:%.*]] = load [take] [[STACK]] |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK: return [[RESULT]] |
| // CHECK: } // end sil function 'simple_nontrivial_loadtake_no_promote' |
| sil [ossa] @simple_nontrivial_loadtake_no_promote : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| %2 = load [take] %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| return %2 : $Builtin.NativeObject |
| } |
| |
| /////////////////////// |
| // Load Borrow Tests // |
| /////////////////////// |
| |
| // CHECK-LABEL: sil [ossa] @load_borrow_promotion : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| // CHECK: bb0([[ARG:%.*]] : |
| // Block where we have our store and do our lifetime extending copy_value. |
| // CHECK: [[STACK:%.*]] = alloc_stack $Builtin.NativeObject |
| // CHECK: [[ARG_COPY:%.*]] = copy_value [[ARG]] |
| // CHECK: store [[ARG]] to [init] [[STACK]] |
| // CHECK: br bb1 |
| // |
| // Our load block. Here, we insert our copy_value + begin_borrow that is |
| // associated with the load_borrow. We can not use the original copy since even |
| // though in this situation we know that our copy/borrow would be strongly |
| // control equivalent, this is not always true. To simplify the algorithm, we |
| // always insert the copy here. We insert a destroy_value to end the lifetime of |
| // ARG_COPY since we do not have a loop here. |
| // |
| // CHECK: bb1: |
| // CHECK: [[CONTROL_EQUIVALENT_ARG_COPY:%.*]] = copy_value [[ARG_COPY]] |
| // CHECK: [[BORROWED_ARG_COPY:%.*]] = begin_borrow [[CONTROL_EQUIVALENT_ARG_COPY]] |
| // CHECK: destroy_value [[ARG_COPY]] |
| // CHECK: br bb2 |
| // |
| // The block where the load_borrow is actually used. We destroy the control |
| // equivalent arg copy here after the end_borrow. |
| // |
| // CHECK: bb2: |
| // CHECK: [[RESULT:%.*]] = copy_value [[BORROWED_ARG_COPY]] |
| // CHECK: end_borrow [[BORROWED_ARG_COPY]] |
| // CHECK: destroy_value [[CONTROL_EQUIVALENT_ARG_COPY]] |
| // CHECK: br bb3 |
| // |
| // The block after the load_borrow is ever used. |
| // CHECK: bb3: |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: return [[RESULT]] |
| // CHECK: } // end sil function 'load_borrow_promotion' |
| sil [ossa] @load_borrow_promotion : $@convention(thin) (@owned Builtin.NativeObject) -> @owned Builtin.NativeObject { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| br bb1 |
| |
| bb1: |
| %2 = load_borrow %1 : $*Builtin.NativeObject |
| br bb2 |
| |
| bb2: |
| %3 = copy_value %2 : $Builtin.NativeObject |
| end_borrow %2 : $Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| return %3 : $Builtin.NativeObject |
| } |
| |
| // CHECK-LABEL: sil [ossa] @promote_with_loop_1 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'promote_with_loop_1' |
| sil [ossa] @promote_with_loop_1 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| br bb2 |
| |
| bb2: |
| %3 = load_borrow %2 : $*Builtin.NativeObject |
| %4 = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %4(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %3 : $Builtin.NativeObject |
| br bb2 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_borrow_loop_promote_with_loop_2 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'load_borrow_loop_promote_with_loop_2' |
| sil [ossa] @load_borrow_loop_promote_with_loop_2 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| br bb2 |
| |
| bb2: |
| %3 = load_borrow %2 : $*Builtin.NativeObject |
| %4 = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %4(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %3 : $Builtin.NativeObject |
| cond_br undef, bb3, bb4 |
| |
| bb3: |
| br bb2 |
| |
| bb4: |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_borrow_promote_two_backedge_loop : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'load_borrow_promote_two_backedge_loop' |
| sil [ossa] @load_borrow_promote_two_backedge_loop : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| br bb1 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| cond_br undef, bb3, bb4 |
| |
| bb3: |
| %2 = load_borrow %1 : $*Builtin.NativeObject |
| end_borrow %2 : $Builtin.NativeObject |
| cond_br undef, bb5, bb6 |
| |
| bb4: |
| %3 = load_borrow %1 : $*Builtin.NativeObject |
| end_borrow %3 : $Builtin.NativeObject |
| cond_br undef, bb7, bb8 |
| |
| bb5: |
| br bb2 |
| |
| bb6: |
| br bb9 |
| |
| bb7: |
| br bb2 |
| |
| bb8: |
| br bb9 |
| |
| bb9: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @load_borrow_tuple_scalarize : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| // CHECK: bb0([[ARG0:%.*]] : @owned ${{.*}}, [[ARG1:%.*]] : |
| // CHECK: [[TUP:%.*]] = tuple ([[ARG0]] : ${{.*}}, [[ARG1]] : |
| // CHECK: ([[TUP_0:%.*]], [[TUP_1:%.*]]) = destructure_tuple [[TUP]] |
| // CHECK: [[TUP_0_COPY:%.*]] = copy_value [[TUP_0]] |
| // CHECK: [[TUP_1_COPY:%.*]] = copy_value [[TUP_1]] |
| // CHECK: [[CONTROL_EQUIVALENT_TUP_0_COPY:%.*]] = copy_value [[TUP_0_COPY]] |
| // CHECK: [[BORROWED_TUP_0_COPY:%.*]] = begin_borrow [[CONTROL_EQUIVALENT_TUP_0_COPY]] |
| // CHECK: destroy_value [[TUP_0_COPY]] |
| // CHECK: [[CONTROL_EQUIVALENT_TUP_1_COPY:%.*]] = copy_value [[TUP_1_COPY]] |
| // CHECK: [[BORROWED_TUP_1_COPY:%.*]] = begin_borrow [[CONTROL_EQUIVALENT_TUP_1_COPY]] |
| // CHECK: destroy_value [[TUP_1_COPY]] |
| // CHECK: [[BORROWED_TUP:%.*]] = tuple ([[BORROWED_TUP_0_COPY]] : ${{.*}}, [[BORROWED_TUP_1_COPY]] : |
| // CHECK: [[TUP_EXT_1:%.*]] = tuple_extract [[BORROWED_TUP]] : |
| // CHECK: [[TUP_EXT_2:%.*]] = tuple_extract [[BORROWED_TUP]] : |
| // CHECK: apply {{%.*}}([[TUP_EXT_1]]) |
| // CHECK: apply {{%.*}}([[TUP_EXT_2]]) |
| // CHECK: end_borrow [[BORROWED_TUP_0_COPY]] |
| // CHECK: destroy_value [[CONTROL_EQUIVALENT_TUP_0_COPY]] |
| // CHECK: end_borrow [[BORROWED_TUP_1_COPY]] |
| // CHECK: destroy_value [[CONTROL_EQUIVALENT_TUP_1_COPY]] |
| // CHECK: } // end sil function 'load_borrow_tuple_scalarize' |
| sil [canonical] [ossa] @load_borrow_tuple_scalarize : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject, %1 : @owned $Builtin.NativeObject): |
| %2 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| %3 = tuple (%0 : $Builtin.NativeObject, %1 : $Builtin.NativeObject) |
| store %3 to [init] %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| |
| %4 = load_borrow %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| %5 = tuple_extract %4 : $(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %6 = tuple_extract %4 : $(Builtin.NativeObject, Builtin.NativeObject), 1 |
| %7 = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %7(%5) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %7(%6) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %4 : $(Builtin.NativeObject, Builtin.NativeObject) |
| |
| destroy_addr %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %2 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> () { |
| // CHECK: bb0( |
| // CHECK-NOT: load [trivial] %{{[0-9][0-9]*}} : $*IntPair |
| // CHECK-NOT: bb{{[0-9][0-9]*}}( |
| // CHECK: } // end sil function 'trivial_multiple_available_values_diamond_followed_by_loop_trivial' |
| sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial : $@convention(thin) (Builtin.Int32, Builtin.Int32) -> () { |
| bb0(%0a : $Builtin.Int32, %0b : $Builtin.Int32): |
| %func = function_ref @intpair_user : $@convention(thin) (IntPair) -> () |
| %1 = alloc_stack $IntPair |
| %1a = struct_element_addr %1 : $*IntPair, #IntPair.x |
| %1b = struct_element_addr %1 : $*IntPair, #IntPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb2: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [trivial] %1 : $*IntPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| dealloc_stack %1 : $*IntPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial_reload : $@convention(thin) (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> () { |
| // CHECK: bb0( |
| // CHECK-NOT: load [trivial] %{{[0-9][0-9]*}} : $*IntPair |
| // CHECK-NOT: bb{{[0-9][0-9]*}}( |
| // CHECK: } // end sil function 'trivial_multiple_available_values_diamond_followed_by_loop_trivial_reload' |
| sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial_reload : $@convention(thin) (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> () { |
| bb0(%0a : $Builtin.Int32, %0b : $Builtin.Int32, %0c : $Builtin.Int32): |
| %func = function_ref @intpair_user : $@convention(thin) (IntPair) -> () |
| %1 = alloc_stack $IntPair |
| %1a = struct_element_addr %1 : $*IntPair, #IntPair.x |
| %1b = struct_element_addr %1 : $*IntPair, #IntPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0c to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb2: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [trivial] %1 : $*IntPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| dealloc_stack %1 : $*IntPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial_store_in_loop : $@convention(thin) (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> () { |
| // CHECK-NOT: load |
| // CHECK: } // end sil function 'trivial_multiple_available_values_diamond_followed_by_loop_trivial_store_in_loop' |
| sil [ossa] @trivial_multiple_available_values_diamond_followed_by_loop_trivial_store_in_loop : $@convention(thin) (Builtin.Int32, Builtin.Int32, Builtin.Int32) -> () { |
| bb0(%0a : $Builtin.Int32, %0b : $Builtin.Int32, %0c : $Builtin.Int32): |
| %func = function_ref @intpair_user : $@convention(thin) (IntPair) -> () |
| %1 = alloc_stack $IntPair |
| %1a = struct_element_addr %1 : $*IntPair, #IntPair.x |
| %1b = struct_element_addr %1 : $*IntPair, #IntPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb2: |
| store %0a to [trivial] %1a : $*Builtin.Int32 |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [trivial] %1 : $*IntPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| store %0b to [trivial] %1b : $*Builtin.Int32 |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (IntPair) -> () |
| dealloc_stack %1 : $*IntPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @multiple_available_values_diamond_followed_by_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| // CHECK: bb0( |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'multiple_available_values_diamond_followed_by_loop' |
| sil [ossa] @multiple_available_values_diamond_followed_by_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load_borrow %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @multiple_available_values_diamond_followed_by_loop_reload : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'multiple_available_values_diamond_followed_by_loop_reload' |
| sil [ossa] @multiple_available_values_diamond_followed_by_loop_reload : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0c to [init] %1b : $*Builtin.NativeObject |
| destroy_value %0b : $Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| destroy_value %0c : $Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load_borrow %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @multiple_available_values_diamond_followed_by_loop_store_in_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'multiple_available_values_diamond_followed_by_loop_store_in_loop' |
| sil [ossa] @multiple_available_values_diamond_followed_by_loop_store_in_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| %0bhat = copy_value %0b : $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load_borrow %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| destroy_addr %1b : $*Builtin.NativeObject |
| %0bhat2 = copy_value %0bhat : $Builtin.NativeObject |
| store %0bhat2 to [init] %1b : $*Builtin.NativeObject |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| destroy_value %0bhat : $Builtin.NativeObject |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadborrow : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_loadborrow' |
| sil [canonical] [ossa] @loop_carry_loadborrow : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %2 = load_borrow %1 : $*Builtin.NativeObject |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadborrow_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_loadborrow_2' |
| sil [canonical] [ossa] @loop_carry_loadborrow_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %2 = load_borrow %1 : $*Builtin.NativeObject |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadborrow_3 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_loadborrow_3' |
| sil [canonical] [ossa] @loop_carry_loadborrow_3 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobject_tuple_user : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| %1 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| %1a = tuple_element_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %1b = tuple_element_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %0ccopy = copy_value %0c : $Builtin.NativeObject |
| destroy_addr %1a : $*Builtin.NativeObject |
| store %0ccopy to [init] %1a : $*Builtin.NativeObject |
| %2 = load_borrow %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| end_borrow %2 : $(Builtin.NativeObject, Builtin.NativeObject) |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| end_borrow %2 : $(Builtin.NativeObject, Builtin.NativeObject) |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadborrow_4 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_loadborrow_4' |
| sil [canonical] [ossa] @loop_carry_loadborrow_4 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %0ccopy = copy_value %0c : $Builtin.NativeObject |
| destroy_addr %1a : $*Builtin.NativeObject |
| store %0ccopy to [init] %1a : $*Builtin.NativeObject |
| %2 = load_borrow %1 : $*NativeObjectPair |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| end_borrow %2 : $NativeObjectPair |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @loop_carry_load_borrow_phi_not_control_equivalent : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_load_borrow_phi_not_control_equivalent' |
| sil [ossa] @loop_carry_load_borrow_phi_not_control_equivalent : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%arg : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %0 = alloc_stack $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| cond_br undef, bb3, bb4 |
| |
| bb2: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb5 |
| |
| bb3: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb6 |
| |
| bb4: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb7 |
| |
| bb5: |
| br bb8 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bbPreLoopHeader |
| |
| bb8: |
| br bbPreLoopHeader |
| |
| bbPreLoopHeader: |
| br bbLoop |
| |
| bbLoop: |
| br bbLoop1 |
| |
| bbLoop1: |
| br bbLoop2 |
| |
| bbLoop2: |
| %2 = load_borrow %0 : $*Builtin.NativeObject |
| cond_br undef, bbLoop3, bbLoop4 |
| |
| bbLoop3: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bbLoop2 |
| |
| bbLoop4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bbEnd |
| |
| bbEnd: |
| destroy_addr %0 : $*Builtin.NativeObject |
| dealloc_stack %0 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // In this case, we will have that we need to separately lifetime extend our phi |
| // node's copy to prevent leaks along the edge skipping the loop. |
| // CHECK-LABEL: sil [ossa] @loop_carry_load_borrow_phi_not_control_equivalent_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'loop_carry_load_borrow_phi_not_control_equivalent_2' |
| sil [ossa] @loop_carry_load_borrow_phi_not_control_equivalent_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%arg : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %0 = alloc_stack $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| cond_br undef, bb3, bb4 |
| |
| bb2: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb5 |
| |
| bb3: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb6 |
| |
| bb4: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb7 |
| |
| bb5: |
| br bb8a |
| |
| bb6: |
| br bb8a |
| |
| bb7: |
| br bbPreLoopHeader |
| |
| bb8a: |
| br bb8 |
| |
| bb8: |
| cond_br undef, bbPreLoopHeader1, bbSkipLoop |
| |
| bbPreLoopHeader: |
| br bbLoop |
| |
| bbPreLoopHeader1: |
| br bbLoop |
| |
| bbLoop: |
| br bbLoop1 |
| |
| bbLoop1: |
| br bbLoop2 |
| |
| bbLoop2: |
| %2 = load_borrow %0 : $*Builtin.NativeObject |
| br bbLoop6 |
| |
| bbLoop6: |
| cond_br undef, bbLoop3, bbLoop4 |
| |
| bbLoop3: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bbLoop5 |
| |
| bbLoop5: |
| br bbLoop2 |
| |
| bbLoop4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| end_borrow %2 : $Builtin.NativeObject |
| br bbEnd |
| |
| bbSkipLoop: |
| br bbEnd |
| |
| bbEnd: |
| destroy_addr %0 : $*Builtin.NativeObject |
| dealloc_stack %0 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| //--- |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_promote_with_loop_1 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| // CHECK-NOT: load_borrow |
| // CHECK: } // end sil function 'load_copy_promote_with_loop_1' |
| sil [ossa] @load_copy_promote_with_loop_1 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| br bb2 |
| |
| bb2: |
| %3 = load [copy] %2 : $*Builtin.NativeObject |
| %4 = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %4(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %3 : $Builtin.NativeObject |
| br bb2 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_loop_promote_with_loop_2 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'load_copy_loop_promote_with_loop_2' |
| sil [ossa] @load_copy_loop_promote_with_loop_2 : $@convention(thin) (@owned NativeObjectPair) -> () { |
| bb0(%0 : @owned $NativeObjectPair): |
| %1 = alloc_stack $NativeObjectPair |
| store %0 to [init] %1 : $*NativeObjectPair |
| %2 = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| br bb2 |
| |
| bb2: |
| %3 = load [copy] %2 : $*Builtin.NativeObject |
| %4 = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| apply %4(%3) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %3 : $Builtin.NativeObject |
| cond_br undef, bb3, bb4 |
| |
| bb3: |
| br bb2 |
| |
| bb4: |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_promote_two_backedge_loop : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'load_copy_promote_two_backedge_loop' |
| sil [ossa] @load_copy_promote_two_backedge_loop : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| br bb1 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| cond_br undef, bb3, bb4 |
| |
| bb3: |
| %2 = load [copy] %1 : $*Builtin.NativeObject |
| destroy_value %2 : $Builtin.NativeObject |
| cond_br undef, bb5, bb6 |
| |
| bb4: |
| %3 = load [copy] %1 : $*Builtin.NativeObject |
| destroy_value %3 : $Builtin.NativeObject |
| cond_br undef, bb7, bb8 |
| |
| bb5: |
| br bb2 |
| |
| bb6: |
| br bb9 |
| |
| bb7: |
| br bb2 |
| |
| bb8: |
| br bb9 |
| |
| bb9: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| // CHECK: bb0( |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'load_copy_multiple_available_values_diamond_followed_by_loop' |
| sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [copy] %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop_reload : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] {{%.*}} : $*NativeObjectPair |
| // CHECK: } // end sil function 'load_copy_multiple_available_values_diamond_followed_by_loop_reload' |
| sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop_reload : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @owned Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0c to [init] %1b : $*Builtin.NativeObject |
| destroy_value %0b : $Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| destroy_value %0c : $Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [copy] %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop_store_in_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] {{%.*}} : $*NativeObjectPair |
| // CHECK: } // end sil function 'load_copy_multiple_available_values_diamond_followed_by_loop_store_in_loop' |
| sil [ossa] @load_copy_multiple_available_values_diamond_followed_by_loop_store_in_loop : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| %0bhat = copy_value %0b : $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb2: |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| br bb3 |
| |
| bb3: |
| br bb4 |
| |
| bb4: |
| br bb5 |
| |
| bb5: |
| %2 = load [copy] %1 : $*NativeObjectPair |
| cond_br undef, bb6, bb7 |
| |
| bb6: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| destroy_addr %1b : $*Builtin.NativeObject |
| %0bhat2 = copy_value %0bhat : $Builtin.NativeObject |
| store %0bhat2 to [init] %1b : $*Builtin.NativeObject |
| br bb5 |
| |
| bb7: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| destroy_value %0bhat : $Builtin.NativeObject |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadcopy : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'loop_carry_loadcopy' |
| sil [canonical] [ossa] @loop_carry_loadcopy : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %2 = load [copy] %1 : $*Builtin.NativeObject |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadcopy_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'loop_carry_loadcopy_2' |
| sil [canonical] [ossa] @loop_carry_loadcopy_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%0 : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %1 = alloc_stack $Builtin.NativeObject |
| store %0 to [init] %1 : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %2 = load [copy] %1 : $*Builtin.NativeObject |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*Builtin.NativeObject |
| dealloc_stack %1 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadcopy_3 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'loop_carry_loadcopy_3' |
| sil [canonical] [ossa] @loop_carry_loadcopy_3 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobject_tuple_user : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| %1 = alloc_stack $(Builtin.NativeObject, Builtin.NativeObject) |
| %1a = tuple_element_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject), 0 |
| %1b = tuple_element_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject), 1 |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %0ccopy = copy_value %0c : $Builtin.NativeObject |
| destroy_addr %1a : $*Builtin.NativeObject |
| store %0ccopy to [init] %1a : $*Builtin.NativeObject |
| %2 = load [copy] %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| destroy_value %2 : $(Builtin.NativeObject, Builtin.NativeObject) |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed (Builtin.NativeObject, Builtin.NativeObject)) -> () |
| destroy_value %2 : $(Builtin.NativeObject, Builtin.NativeObject) |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| dealloc_stack %1 : $*(Builtin.NativeObject, Builtin.NativeObject) |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [canonical] [ossa] @loop_carry_loadcopy_4 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'loop_carry_loadcopy_4' |
| sil [canonical] [ossa] @loop_carry_loadcopy_4 : $@convention(thin) (@owned Builtin.NativeObject, @owned Builtin.NativeObject, @guaranteed Builtin.NativeObject) -> () { |
| bb0(%0a : @owned $Builtin.NativeObject, %0b : @owned $Builtin.NativeObject, %0c : @guaranteed $Builtin.NativeObject): |
| %func = function_ref @nativeobjectpair_user : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| %1 = alloc_stack $NativeObjectPair |
| %1a = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.x |
| %1b = struct_element_addr %1 : $*NativeObjectPair, #NativeObjectPair.y |
| store %0a to [init] %1a : $*Builtin.NativeObject |
| store %0b to [init] %1b : $*Builtin.NativeObject |
| cond_br undef, bb1, bb7 |
| |
| bb1: |
| br bb2 |
| |
| bb2: |
| br bb3 |
| |
| bb3: |
| %0ccopy = copy_value %0c : $Builtin.NativeObject |
| destroy_addr %1a : $*Builtin.NativeObject |
| store %0ccopy to [init] %1a : $*Builtin.NativeObject |
| %2 = load [copy] %1 : $*NativeObjectPair |
| cond_br undef, bb4, bb5 |
| |
| bb4: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| br bb2 |
| |
| bb5: |
| apply %func(%2) : $@convention(thin) (@guaranteed NativeObjectPair) -> () |
| destroy_value %2 : $NativeObjectPair |
| br bb6 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bb8 |
| |
| bb8: |
| destroy_addr %1 : $*NativeObjectPair |
| dealloc_stack %1 : $*NativeObjectPair |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @load_copy_loop_carry_load_copy_phi_not_control_equivalent : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'load_copy_loop_carry_load_copy_phi_not_control_equivalent' |
| sil [ossa] @load_copy_loop_carry_load_copy_phi_not_control_equivalent : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%arg : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %0 = alloc_stack $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| cond_br undef, bb3, bb4 |
| |
| bb2: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb5 |
| |
| bb3: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb6 |
| |
| bb4: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb7 |
| |
| bb5: |
| br bb8 |
| |
| bb6: |
| br bb8 |
| |
| bb7: |
| br bbPreLoopHeader |
| |
| bb8: |
| br bbPreLoopHeader |
| |
| bbPreLoopHeader: |
| br bbLoop |
| |
| bbLoop: |
| br bbLoop1 |
| |
| bbLoop1: |
| br bbLoop2 |
| |
| bbLoop2: |
| %2 = load [copy] %0 : $*Builtin.NativeObject |
| cond_br undef, bbLoop3, bbLoop4 |
| |
| bbLoop3: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bbLoop2 |
| |
| bbLoop4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bbEnd |
| |
| bbEnd: |
| destroy_addr %0 : $*Builtin.NativeObject |
| dealloc_stack %0 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // In this case, we will have that we need to separately lifetime extend our phi |
| // node's copy to prevent leaks along the edge skipping the loop. |
| // CHECK-LABEL: sil [ossa] @load_copy_loop_carry_load_copy_phi_not_control_equivalent_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| // CHECK-NOT: load [copy] |
| // CHECK: } // end sil function 'load_copy_loop_carry_load_copy_phi_not_control_equivalent_2' |
| sil [ossa] @load_copy_loop_carry_load_copy_phi_not_control_equivalent_2 : $@convention(thin) (@owned Builtin.NativeObject) -> () { |
| bb0(%arg : @owned $Builtin.NativeObject): |
| %func = function_ref @nativeobject_user : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| %0 = alloc_stack $Builtin.NativeObject |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| cond_br undef, bb3, bb4 |
| |
| bb2: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb5 |
| |
| bb3: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb6 |
| |
| bb4: |
| store %arg to [init] %0 : $*Builtin.NativeObject |
| br bb7 |
| |
| bb5: |
| br bb8a |
| |
| bb6: |
| br bb8a |
| |
| bb7: |
| br bbPreLoopHeader |
| |
| bb8a: |
| br bb8 |
| |
| bb8: |
| cond_br undef, bbPreLoopHeader1, bbSkipLoop |
| |
| bbPreLoopHeader: |
| br bbLoop |
| |
| bbPreLoopHeader1: |
| br bbLoop |
| |
| bbLoop: |
| br bbLoop1 |
| |
| bbLoop1: |
| br bbLoop2 |
| |
| bbLoop2: |
| %2 = load [copy] %0 : $*Builtin.NativeObject |
| br bbLoop6 |
| |
| bbLoop6: |
| cond_br undef, bbLoop3, bbLoop4 |
| |
| bbLoop3: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bbLoop5 |
| |
| bbLoop5: |
| br bbLoop2 |
| |
| bbLoop4: |
| apply %func(%2) : $@convention(thin) (@guaranteed Builtin.NativeObject) -> () |
| destroy_value %2 : $Builtin.NativeObject |
| br bbEnd |
| |
| bbSkipLoop: |
| br bbEnd |
| |
| bbEnd: |
| destroy_addr %0 : $*Builtin.NativeObject |
| dealloc_stack %0 : $*Builtin.NativeObject |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
