| // RUN: %target-sil-opt -enable-sil-verify-all %s -allocbox-to-stack | %FileCheck %s |
| |
| import Builtin |
| |
| struct Int { |
| var _value: Builtin.Int64 |
| } |
| |
| struct Bool { |
| var _value: Builtin.Int1 |
| } |
| |
| protocol Error {} |
| |
| // CHECK-LABEL: sil [ossa] @simple_promotion |
| sil [ossa] @simple_promotion : $@convention(thin) (Int) -> Int { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| store %0 to [trivial] %1a : $*Int |
| |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| return %3 : $Int |
| // CHECK: alloc_stack |
| // CHECK-NOT: alloc_box |
| // CHECK-NOT: destroy_value |
| // CHECK: return |
| } |
| |
| // CHECK-LABEL: sil [ossa] @double_project_box |
| sil [ossa] @double_project_box : $@convention(thin) (Int) -> (Int, Int) { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| store %0 to [trivial] %1a : $*Int |
| %3 = load [trivial] %1a : $*Int |
| |
| %1b = project_box %1 : ${ var Int }, 0 |
| %3b = load [trivial] %1b : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple (%3 : $Int, %3b : $Int) |
| return %r : $(Int, Int) |
| |
| // CHECK: alloc_stack |
| // CHECK-NOT: alloc_box |
| // CHECK-NOT: project_box |
| // CHECK-NOT: destroy_value |
| // CHECK: return |
| } |
| // CHECK-LABEL: sil [ossa] @init_var |
| sil [ossa] @init_var : $@convention(thin) () -> Int { |
| bb0: |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| return %3 : $Int |
| |
| // CHECK: %0 = alloc_stack |
| // CHECK-NOT: alloc_box |
| // CHECK-NOT: destroy_value |
| // CHECK-NOT: destroy_addr |
| // CHECK: dealloc_stack %0 : $*Int |
| // CHECK: return |
| } |
| |
| // CHECK-LABEL: sil [ossa] @multi_destroy_value |
| sil [ossa] @multi_destroy_value : $@convention(thin) () -> Int { |
| bb0: |
| %1 = alloc_box ${ var Int } |
| %1a = mark_uninitialized [rootself] %1 : ${ var Int } |
| %2 = project_box %1a : ${ var Int }, 0 |
| %3 = load [trivial] %2 : $*Int |
| %x = copy_value %1a : ${ var Int } |
| destroy_value %1a : ${ var Int } |
| br bb1 |
| |
| bb1: |
| destroy_value %x : ${ var Int } |
| return %3 : $Int |
| |
| // CHECK: %0 = alloc_stack |
| // CHECK: bb1: |
| // CHECK: dealloc_stack %0 : $*Int |
| // CHECK: return |
| } |
| |
| struct TestStruct { |
| var Elt : Int |
| } |
| |
| // CHECK-LABEL: sil [ossa] @struct_tuple_element_addr |
| sil [ossa] @struct_tuple_element_addr : $@convention(thin) (Int) -> Int { |
| bb1(%0 : $Int): |
| // CHECK-DAG: [[STRUCT:%.*]] = alloc_stack $TestStruct |
| // CHECK-DAG: [[TUPLE:%.*]] = alloc_stack $(Int, Int) |
| %1 = alloc_box ${ var TestStruct } |
| %1a = project_box %1 : ${ var TestStruct }, 0 |
| %a = alloc_box ${ var (Int, Int) } |
| %aa = project_box %a : ${ var (Int, Int) }, 0 |
| |
| %2 = struct_element_addr %1a : $*TestStruct, #TestStruct.Elt |
| store %0 to [trivial] %2 : $*Int |
| |
| %b = tuple_element_addr %aa : $*(Int, Int), 0 |
| store %0 to [trivial] %b : $*Int |
| |
| %6 = struct_element_addr %1a : $*TestStruct, #TestStruct.Elt |
| %7 = load [trivial] %6 : $*Int |
| destroy_value %a : ${ var (Int, Int) } |
| destroy_value %1 : ${ var TestStruct } |
| |
| return %7 : $Int |
| |
| // CHECK-DAG: dealloc_stack [[STRUCT]] |
| // CHECK-DAG: dealloc_stack [[TUPLE]] |
| // CHECK: return |
| } |
| |
| sil [ossa] @callee : $@convention(thin) (@inout Int) -> () |
| |
| // CHECK-LABEL: sil [ossa] @inout_nocapture |
| sil [ossa] @inout_nocapture : $@convention(thin) () -> Int { |
| bb0: |
| // CHECK: alloc_stack |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| %6 = function_ref @callee : $@convention(thin) (@inout Int) -> () |
| %7 = apply %6(%1a) : $@convention(thin) (@inout Int) -> () |
| %8 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %10 = address_to_pointer %1a : $*Int to $Builtin.RawPointer |
| %11 = pointer_to_address %10 : $Builtin.RawPointer to [strict] $*Int |
| %12 = load [trivial] %11 : $*Int |
| return %8 : $Int |
| // CHECK: return |
| } |
| |
| protocol P { |
| } |
| |
| sil [ossa] @returns_protocol : $@convention(thin) () -> @out P |
| |
| // CHECK-LABEL: sil [ossa] @test_indirect_return |
| sil [ossa] @test_indirect_return : $@convention(thin) () -> () { |
| bb0: |
| // CHECK: alloc_stack |
| %1 = function_ref @returns_protocol : $@convention(thin) () -> @out P |
| %2 = alloc_box ${ var P } |
| %2a = project_box %2 : ${ var P }, 0 |
| %3 = apply %1(%2a) : $@convention(thin) () -> @out P |
| destroy_value %2 : ${ var P } |
| %0 = tuple () |
| return %0 : $() |
| // CHECK: return |
| } |
| |
| class SomeClass {} |
| |
| // CHECK-LABEL: sil [ossa] @class_promotion |
| sil [ossa] @class_promotion : $@convention(thin) (@owned SomeClass) -> @owned SomeClass { |
| bb0(%0 : @owned $SomeClass): |
| %1 = alloc_box ${ var SomeClass } |
| %1a = project_box %1 : ${ var SomeClass }, 0 |
| store %0 to [init] %1a : $*SomeClass |
| %3 = load [take] %1a : $*SomeClass |
| destroy_value %1 : ${ var SomeClass } |
| return %3 : $SomeClass |
| |
| // CHECK: %1 = alloc_stack |
| // CHECK-NOT: alloc_box |
| // CHECK-NOT: destroy_value |
| // CHECK: destroy_addr {{.*}} : $*SomeClass |
| // CHECK: return |
| } |
| |
| protocol LogicValue { |
| func getLogicValue() -> Bool |
| } |
| |
| // CHECK-LABEL: @protocols |
| sil [ossa] @protocols : $@convention(thin) (@in LogicValue, @thin Bool.Type) -> Bool { |
| bb0(%0 : $*LogicValue, %1 : $@thin Bool.Type): |
| %2 = alloc_box ${ var LogicValue } |
| %2a = project_box %2 : ${ var LogicValue }, 0 |
| // CHECK: %2 = alloc_stack $LogicValue |
| copy_addr [take] %0 to [initialization] %2a : $*LogicValue |
| %6 = open_existential_addr mutable_access %2a : $*LogicValue to $*@opened("01234567-89ab-cdef-0123-000000000000") LogicValue |
| %7 = witness_method $@opened("01234567-89ab-cdef-0123-000000000000") LogicValue, #LogicValue.getLogicValue!1, %6 : $*@opened("01234567-89ab-cdef-0123-000000000000") LogicValue : $@convention(witness_method: LogicValue) <T: LogicValue> (@in_guaranteed T) -> Bool |
| %8 = apply %7<@opened("01234567-89ab-cdef-0123-000000000000") LogicValue>(%6) : $@convention(witness_method: LogicValue) <T: LogicValue> (@in_guaranteed T) -> Bool |
| destroy_value %2 : ${ var LogicValue } |
| // CHECK: destroy_addr %2 : $*LogicValue |
| // CHECK-NEXT: dealloc_stack %2 : $*LogicValue |
| // CHECK-NEXT: return |
| return %8 : $Bool |
| } |
| |
| |
| // Generics test, which is address-only. |
| class Generic<T> {} |
| |
| // CHECK-LABEL: sil [ossa] @dealloc_box_test |
| sil [ossa] @dealloc_box_test : $@convention(thin) <T> () -> () { |
| bb0: // CHECK-NEXT: bb0: |
| // CHECK-NEXT: alloc_stack |
| %1 = alloc_box $<τ_0_0> { var Generic<τ_0_0> } <T> |
| dealloc_box %1 : $<τ_0_0> { var Generic<τ_0_0> } <T> |
| |
| %0 = tuple () // CHECK: tuple () |
| return %0 : $() |
| // CHECK: return |
| } |
| |
| |
| enum SomeUnion { |
| case x(Int) |
| case y(SomeClass) |
| } |
| |
| |
| |
| sil [ossa] @$s1t9SomeUnionO1yfMS0_FCS_9SomeClassS0_ : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion |
| sil [ossa] @$s1t9SomeClassCCfMS0_FT_S0_ : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| |
| // CHECK-LABEL: sil [ossa] @union_test |
| sil [ossa] @union_test : $@convention(thin) () -> () { |
| bb0: |
| // CHECK: [[UNION:%.*]] = alloc_stack |
| %1 = alloc_box ${ var SomeUnion } |
| %1a = project_box %1 : ${ var SomeUnion }, 0 |
| %2 = function_ref @$s1t9SomeUnionO1yfMS0_FCS_9SomeClassS0_ : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion // user: %7 |
| %3 = metatype $@thin SomeUnion.Type |
| %4 = function_ref @$s1t9SomeClassCCfMS0_FT_S0_ : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass // user: %6 |
| %5 = metatype $@thick SomeClass.Type |
| %6 = apply %4(%5) : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| %7 = apply %2(%6, %3) : $@convention(thin) (@owned SomeClass, @thin SomeUnion.Type) -> @owned SomeUnion |
| store %7 to [init] %1a : $*SomeUnion |
| destroy_value %1 : ${ var SomeUnion } |
| %10 = tuple () |
| return %10 : $() |
| // CHECK: dealloc_stack [[UNION]] |
| // CHECK: [[T0:%.*]] = tuple () |
| // CHECK-NEXT: return [[T0]] : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @multiple_destroy_test |
| sil [ossa] @multiple_destroy_test : $@convention(thin) (Bool) -> Bool { |
| bb0(%0 : $Bool): |
| %1 = alloc_box ${ var Bool } |
| %1a = project_box %1 : ${ var Bool }, 0 |
| store %0 to [trivial] %1a : $*Bool |
| %2 = copy_value %1 : ${ var Bool } |
| %3 = copy_value %1 : ${ var Bool } |
| %5 = tuple () |
| %6 = load [trivial] %1a : $*Bool |
| destroy_value %3 : ${ var Bool } |
| destroy_value %2 : ${ var Bool } |
| destroy_value %1 : ${ var Bool } |
| return %6 : $Bool |
| |
| // CHECK: alloc_stack $Bool |
| // CHECK-NEXT: store |
| // CHECK-NEXT: tuple () |
| // CHECK-NEXT: load |
| // CHECK-NEXT: dealloc_stack |
| // CHECK-NEXT: return |
| } |
| |
| // Make sure that we can promote this box and dealloc_stack |
| // on each path. |
| // |
| // CHECK-LABEL: sil [ossa] @box_reachable_from_destroy_test |
| sil [ossa] @box_reachable_from_destroy_test : $@convention(thin) () -> () { |
| bb0: |
| br bb1 |
| |
| // CHECK: bb1: |
| // CHECK-NEXT: alloc_stack |
| bb1: |
| %1 = alloc_box ${ var Bool } |
| cond_br undef, bb2, bb3 |
| |
| // CHECK: bb2: |
| // CHECK-NEXT: dealloc_stack |
| bb2: |
| destroy_value %1 : ${ var Bool } |
| br bb1 |
| |
| // CHECK: bb3: |
| // CHECK-NEXT: dealloc_stack |
| bb3: |
| destroy_value %1 : ${ var Bool } |
| %2 = tuple () |
| // CHECK: return |
| return %2 : $() |
| } |
| |
| |
| |
| sil [ossa] @useSomeClass : $@convention(thin) (@owned SomeClass) -> () |
| |
| |
| // <rdar://problem/16382973> DI misses destroy_addr because allocbox_to_stack isn't preserving mark_uninitialized invariants |
| // When allocbox_to_stack promotes the box, it should rewrite the multiple |
| // destroy_values into destroy_addr/dealloc_stack pairs. However, it needs to |
| // make sure to use the MUI result for the destroy addr. |
| |
| public protocol My_Incrementable { } |
| |
| extension Int : My_Incrementable { } |
| |
| // CHECK-LABEL: sil [ossa] @test_mui |
| sil [ossa] @test_mui : $@convention(thin) (Builtin.Int1) -> () { |
| bb0(%0 : $Builtin.Int1): |
| %2 = alloc_box ${ var SomeClass } |
| %2a = mark_uninitialized [var] %2 : ${ var SomeClass } |
| %3 = project_box %2a : ${ var SomeClass }, 0 |
| // CHECK: [[STACK:%[0-9]+]] = alloc_stack |
| // CHECK: [[MUI:%[0-9]+]] = mark_uninitialized |
| cond_br %0, bb1, bb3 |
| |
| bb1: |
| %7 = function_ref @$s1t9SomeClassCCfMS0_FT_S0_ : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass // user: %6 |
| %8 = metatype $@thick SomeClass.Type |
| %9 = apply %7(%8) : $@convention(thin) (@thick SomeClass.Type) -> @owned SomeClass |
| |
| assign %9 to %3 : $*SomeClass |
| %11 = function_ref @useSomeClass : $@convention(thin) (@owned SomeClass) -> () |
| %12 = load [copy] %3 : $*SomeClass |
| %14 = apply %11(%12) : $@convention(thin) (@owned SomeClass) -> () |
| |
| destroy_value %2a : ${ var SomeClass } |
| // CHECK: destroy_addr [[MUI]] |
| // CHECK-NEXT: dealloc_stack [[STACK]] |
| br bb2 |
| |
| // CHECK: bb2 |
| bb2: |
| %17 = tuple () |
| // CHECK: return |
| return %17 : $() |
| |
| bb3: |
| destroy_value %2a : ${ var SomeClass } |
| // CHECK: destroy_addr [[MUI]] |
| // CHECK-NEXT: dealloc_stack [[STACK]] |
| br bb2 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @$s6struct5apply1fS2iyc_tF |
| // struct.apply (f : () -> Swift.Int) -> Swift.Int |
| sil [ossa] @$s6struct5apply1fS2iyc_tF : $@convention(thin) (@owned @callee_owned () -> Int) -> Int { |
| bb0(%0 : @owned $@callee_owned () -> Int): |
| debug_value %0 : $@callee_owned () -> Int, let, name "f" // id: %1 |
| %1 = copy_value %0 : $@callee_owned () -> Int // id: %2 |
| %3 = apply %1() : $@callee_owned () -> Int // user: %5 |
| destroy_value %0 : $@callee_owned () -> Int // id: %4 |
| return %3 : $Int // id: %5 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @$s6struct6escape1fSiycSiyc_tF |
| // struct.escape (f : () -> Swift.Int) -> () -> Swift.Int |
| sil [ossa] @$s6struct6escape1fSiycSiyc_tF : $@convention(thin) (@owned @callee_owned () -> Int) -> @owned @callee_owned () -> Int { |
| bb0(%0 : @owned $@callee_owned () -> Int): |
| debug_value %0 : $@callee_owned () -> Int, let, name "f" // id: %1 |
| return %0 : $@callee_owned () -> Int // id: %2 |
| } |
| |
| // CHECK-LABEL: sil [ossa] @$s6struct8useStack1tySi_tF |
| // struct.useStack (t : Swift.Int) -> () |
| sil [ossa] @$s6struct8useStack1tySi_tF : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| debug_value %0 : $Int, let, name "t" // id: %1 |
| // CHECK: alloc_stack |
| %2 = alloc_box $<τ_0_0> { var τ_0_0 } <Int>, var, name "s" // users: %3, %6, %7, %7, %9 |
| %2a = project_box %2 : $<τ_0_0> { var τ_0_0 } <Int>, 0 |
| store %0 to [trivial] %2a : $*Int // id: %3 |
| // function_ref struct.apply (f : () -> Swift.Int) -> Swift.Int |
| %4 = function_ref @$s6struct5apply1fS2iyc_tF : $@convention(thin) (@owned @callee_owned () -> Int) -> Int // user: %8 |
| // CHECK: [[FUNC:%[a-zA-Z0-9]+]] = function_ref @$s6struct8useStack1tySi_tFSiycfU_Tf0s_n |
| // function_ref struct.(useStack (t : Swift.Int) -> ()).(closure #1) |
| %5 = function_ref @$s6struct8useStack1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int // user: %7 |
| %6 = copy_value %2 : $<τ_0_0> { var τ_0_0 } <Int> // id: %6 |
| // CHECK: [[PA:%[a-zA-Z0-9]+]] = partial_apply [[FUNC]] |
| %7 = partial_apply %5(%6) : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int // user: %8 |
| %8 = apply %4(%7) : $@convention(thin) (@owned @callee_owned () -> Int) -> Int |
| destroy_value %2 : $<τ_0_0> { var τ_0_0 } <Int> |
| %10 = tuple () // user: %11 |
| return %10 : $() // id: %11 |
| } |
| |
| // CHECK-LABEL: sil shared [ossa] @$s6struct8useStack1tySi_tFSiycfU_Tf0s_n |
| // CHECK-LABEL: sil private [ossa] @$s6struct8useStack1tySi_tFSiycfU_ |
| // struct.(useStack (t : Swift.Int) -> ()).(closure #1) |
| sil private [ossa] @$s6struct8useStack1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int { |
| bb0(%0 : @owned $<τ_0_0> { var τ_0_0 } <Int>): |
| %1 = project_box %0 : $<τ_0_0> { var τ_0_0 } <Int>, 0 |
| // function_ref Swift.++ @postfix <A : Swift._Incrementable>(x : @inout A) -> A |
| %2 = function_ref @_TFsoP2ppUs14_Incrementable__FT1xRQ__Q_ : $@convention(thin) <τ_0_0 where τ_0_0 : My_Incrementable> (@inout τ_0_0) -> @out τ_0_0 // user: %4 |
| %3 = alloc_stack $Int // users: %4, %5, %6 |
| %4 = apply %2<Int>(%3, %1) : $@convention(thin) <τ_0_0 where τ_0_0 : My_Incrementable> (@inout τ_0_0) -> @out τ_0_0 |
| %5 = load [trivial] %3 : $*Int // user: %8 |
| dealloc_stack %3 : $*Int // id: %6 |
| destroy_value %0 : $<τ_0_0> { var τ_0_0 } <Int> // id: %7 |
| return %5 : $Int // id: %8 |
| } |
| |
| // Swift.++ @postfix <A : Swift._Incrementable>(x : @inout A) -> A |
| sil [transparent] @_TFsoP2ppUs14_Incrementable__FT1xRQ__Q_ : $@convention(thin) <τ_0_0 where τ_0_0 : My_Incrementable> (@inout τ_0_0) -> @out τ_0_0 |
| |
| // CHECK-LABEL: sil [ossa] @$s6struct6useBox1tySi_tF |
| // struct.useBox (t : Swift.Int) -> () |
| sil [ossa] @$s6struct6useBox1tySi_tF : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| debug_value %0 : $Int, let, name "t" // id: %1 |
| // CHECK: alloc_box |
| %2 = alloc_box $<τ_0_0> { var τ_0_0 } <Int>, var, name "s" // users: %3, %6, %7, %7, %10 |
| %2a = project_box %2 : $<τ_0_0> { var τ_0_0 } <Int>, 0 |
| store %0 to [trivial] %2a : $*Int // id: %3 |
| // function_ref struct.escape (f : () -> Swift.Int) -> () -> Swift.Int |
| %4 = function_ref @$s6struct6escape1fSiycSiyc_tF : $@convention(thin) (@owned @callee_owned () -> Int) -> @owned @callee_owned () -> Int // user: %8 |
| // function_ref struct.(useBox (t : Swift.Int) -> ()).(closure #1) |
| %5 = function_ref @$s6struct6useBox1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int // user: %7 |
| %6 = copy_value %2 : $<τ_0_0> { var τ_0_0 } <Int> // id: %6 |
| %7 = partial_apply %5(%6) : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int // user: %8 |
| %8 = apply %4(%7) : $@convention(thin) (@owned @callee_owned () -> Int) -> @owned @callee_owned () -> Int // user: %9 |
| %9 = apply %8() : $@callee_owned () -> Int |
| destroy_value %2 : $<τ_0_0> { var τ_0_0 } <Int> // id: %10 |
| %11 = tuple () // user: %12 |
| return %11 : $() // id: %12 |
| } |
| |
| // CHECK-LABEL: sil private [ossa] @$s6struct6useBox1tySi_tFSiycfU_ |
| // struct.(useBox (t : Swift.Int) -> ()).(closure #1) |
| sil private [ossa] @$s6struct6useBox1tySi_tFSiycfU_ : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> Int { |
| bb0(%0 : @owned $<τ_0_0> { var τ_0_0 } <Int>): |
| %1 = project_box %0 : $<τ_0_0> { var τ_0_0 } <Int>, 0 |
| // function_ref Swift.++ @postfix <A : Swift._Incrementable>(x : @inout A) -> A |
| %2 = function_ref @_TFsoP2ppUs14_Incrementable__FT1xRQ__Q_ : $@convention(thin) <τ_0_0 where τ_0_0 : My_Incrementable> (@inout τ_0_0) -> @out τ_0_0 // user: %4 |
| %3 = alloc_stack $Int // users: %4, %5, %6 |
| %4 = apply %2<Int>(%3, %1) : $@convention(thin) <τ_0_0 where τ_0_0 : My_Incrementable> (@inout τ_0_0) -> @out τ_0_0 |
| %5 = load [trivial] %3 : $*Int // user: %8 |
| dealloc_stack %3 : $*Int // id: %6 |
| destroy_value %0 : $<τ_0_0> { var τ_0_0 } <Int> // id: %7 |
| return %5 : $Int // id: %8 |
| } |
| |
| // CHECK-LABEL: sil @closure |
| sil @closure : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> () |
| |
| // CHECK-LABEL: sil [ossa] @no_final_destroy |
| sil [ossa] @no_final_destroy : $@convention(thin) (Int) -> Bool { |
| bb0(%0 : $Int): |
| // This is not destroyed, but the unreachable makes the verifier not trip. |
| %1 = alloc_box $<τ_0_0> { var τ_0_0 } <Int> |
| %1a = project_box %1 : $<τ_0_0> { var τ_0_0 } <Int>, 0 |
| store %0 to [trivial] %1a : $*Int |
| // function_ref main.(newFoo (Swift.Int) -> Swift.Bool).(modify #1) (())() |
| %3 = function_ref @closure : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> () |
| %4 = copy_value %1 : $<τ_0_0> { var τ_0_0 } <Int> |
| %5 = partial_apply %3(%4) : $@convention(thin) (@owned <τ_0_0> { var τ_0_0 } <Int>) -> () |
| %6 = copy_value %5 : $@callee_owned () -> () |
| apply %6() : $@callee_owned () -> () |
| destroy_value %5 : $@callee_owned () -> () |
| unreachable |
| } |
| |
| // CHECK-LABEL: sil [transparent] [serialized] [ossa] @mightApply : $@convention(thin) <U where U : P> (@owned @callee_owned () -> @out U) -> () |
| sil [transparent] [serialized] [ossa] @mightApply : $@convention(thin) <U where U : P> (@owned @callee_owned () -> @out U) -> () { |
| // CHECK: bb0 |
| bb0(%0 : @owned $@callee_owned () -> @out U): |
| debug_value %0 : $@callee_owned () -> @out U |
| %1 = copy_value %0 : $@callee_owned () -> @out U |
| %3 = alloc_stack $U |
| %4 = apply %1(%3) : $@callee_owned () -> @out U |
| destroy_addr %3 : $*U |
| dealloc_stack %3 : $*U |
| destroy_value %0 : $@callee_owned () -> @out U |
| %8 = tuple () |
| // CHECK: return |
| return %8 : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @callWithAutoclosure |
| sil [ossa] @callWithAutoclosure : $@convention(thin) <T where T : P> (@in T) -> () { |
| // CHECK: bb0 |
| bb0(%0 : $*T): |
| // CHECK: debug_value_addr |
| debug_value_addr %0 : $*T |
| // CHECK: function_ref @mightApply |
| %2 = function_ref @mightApply : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned @callee_owned () -> @out τ_0_0) -> () |
| %3 = function_ref @closure_to_specialize : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0 |
| // CHECK-NOT: alloc_box |
| // CHECK: [[STACK:%[0-9a-zA-Z_]+]] = alloc_stack $T |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T> |
| %4a = project_box %4 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| // CHECK: copy_addr %0 to [initialization] [[STACK]] : $*T |
| copy_addr %0 to [initialization] %4a : $*T |
| // CHECK: [[CLOSURE:%[0-9a-zA-Z]+]] = function_ref @$s21closure_to_specializeTf0ns_n |
| // CHECK: partial_apply [[CLOSURE]]<T>([[STACK]]) |
| %6 = partial_apply %3<T>(%4) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> @out τ_0_0 |
| %7 = apply %2<T>(%6) : $@convention(thin) <τ_0_0 where τ_0_0 : P> (@owned @callee_owned () -> @out τ_0_0) -> () |
| // CHECK: destroy_addr [[STACK]] : $*T |
| // CHECK: dealloc_stack [[STACK]] : $*T |
| destroy_addr %0 : $*T |
| %9 = tuple () |
| // CHECK: return |
| return %9 : $() |
| } |
| |
| // CHECK-LABEL: sil shared [ossa] @$s21closure_to_specializeTf0ns_n : $@convention(thin) <T where T : P> (@inout_aliasable T) -> @out T |
| sil shared [ossa] @closure_to_specialize : $@convention(thin) <T where T : P> (@owned <τ_0_0> { var τ_0_0 } <T>) -> @out T { |
| // CHECK: bb0 |
| bb0(%0 : $*T, %1 : @owned $<τ_0_0> { var τ_0_0 } <T>): |
| %2 = project_box %1 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| // CHECK-NEXT: copy_addr |
| copy_addr %2 to [initialization] %0 : $*T |
| // CHECK-NOT: destroy_value |
| destroy_value %1 : $<τ_0_0> { var τ_0_0 } <T> |
| %5 = tuple () |
| // CHECK: return |
| return %5 : $() |
| } |
| |
| protocol Count { |
| var count: Int { get } |
| } |
| |
| struct Q : Count { |
| var count: Int { get } |
| init() |
| } |
| |
| struct S<T : Count> { |
| @_hasStorage var t: T |
| var count: Int { get } |
| func test(i: Int) -> Bool |
| init(t: T) |
| } |
| |
| // CHECK-LABEL: sil [noinline] [ossa] @inner |
| sil [noinline] [ossa] @inner : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : @owned $@callee_owned () -> Bool): |
| debug_value %0 : $@callee_owned () -> Bool |
| %1 = copy_value %0 : $@callee_owned () -> Bool |
| %3 = apply %1() : $@callee_owned () -> Bool |
| destroy_value %0 : $@callee_owned () -> Bool |
| // CHECK: return |
| return %3 : $Bool |
| } |
| |
| // CHECK-LABEL: sil [noinline] [ossa] @outer |
| sil [noinline] [ossa] @outer : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : @owned $@callee_owned () -> Bool): |
| debug_value %0 : $@callee_owned () -> Bool |
| %1 = copy_value %0 : $@callee_owned () -> Bool |
| %3 = apply %1() : $@callee_owned () -> Bool |
| destroy_value %0 : $@callee_owned () -> Bool |
| // CHECK: return |
| return %3 : $Bool |
| } |
| |
| // CHECK-LABEL: sil @get |
| sil @get : $@convention(method) <T where T : Count> (@in S<T>) -> Int |
| |
| // CHECK-LABEL: sil shared [ossa] @specialized |
| sil shared [ossa] @specialized : $@convention(method) (Int, @in S<Q>) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : $Int, %1 : $*S<Q>): |
| debug_value %0 : $Int |
| debug_value_addr %1 : $*S<Q> |
| %4 = function_ref @outer : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| %5 = function_ref @closure1 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool |
| %6 = alloc_box $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <Q> |
| %6a = project_box %6 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <Q>, 0 |
| copy_addr %1 to [initialization] %6a : $*S<Q> |
| %8 = partial_apply %5<Q>(%0, %6) : $@convention(thin) <τ_0_0 where τ_0_0 : Count> (Int, @owned <τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <τ_0_0>) -> Bool |
| %9 = apply %4(%8) : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| destroy_addr %1 : $*S<Q> |
| // CHECK: return |
| return %9 : $Bool |
| } |
| |
| // CHECK-LABEL: sil [ossa] @unspecialized |
| sil [ossa] @unspecialized : $@convention(method) <T where T : Count> (Int, @in S<T>) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : $Int, %1 : $*S<T>): |
| debug_value %0 : $Int |
| debug_value_addr %1 : $*S<T> |
| %4 = function_ref @outer : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| %5 = function_ref @closure1 : $@convention(thin) <τ_0_0 where τ_0_0 : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <τ_0_0>) -> Bool |
| %6 = alloc_box $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T> |
| %6a = project_box %6 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>, 0 |
| copy_addr %1 to [initialization] %6a : $*S<T> |
| %8 = partial_apply %5<T>(%0, %6) : $@convention(thin) <τ_0_0 where τ_0_0 : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <τ_0_0>) -> Bool |
| %9 = apply %4(%8) : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| destroy_addr %1 : $*S<T> |
| // CHECK: return |
| return %9 : $Bool |
| } |
| |
| // CHECK-LABEL: sil shared [ossa] @closure1 |
| sil shared [ossa] @closure1 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>): |
| %2 = project_box %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>, 0 |
| %3 = function_ref @inner : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| %4 = function_ref @closure2 : $@convention(thin) <τ_0_0 where τ_0_0 : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <τ_0_0>) -> Bool |
| %5 = alloc_box $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T> |
| %5a = project_box %5 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>, 0 |
| copy_addr %2 to [initialization] %5a : $*S<T> |
| %7 = partial_apply %4<T>(%0, %5) : $@convention(thin) <τ_0_0 where τ_0_0 : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <τ_0_0>) -> Bool |
| %8 = apply %3(%7) : $@convention(thin) (@owned @callee_owned () -> Bool) -> Bool |
| destroy_value %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T> |
| // CHECK: return |
| return %8 : $Bool |
| } |
| |
| // CHECK-LABEL: sil shared [ossa] @$s8closure2Tf0ns_n |
| // CHECK: bb0 |
| // CHECK: return |
| // CHECK-NOT: bb1 |
| |
| // CHECK-LABEL: sil shared [ossa] @closure2 |
| sil shared [ossa] @closure2 : $@convention(thin) <T where T : Count> (Int, @owned <τ_0_0 : Count> { var S<τ_0_0> } <T>) -> Bool { |
| // CHECK: bb0 |
| bb0(%0 : $Int, %1 : @owned $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>): |
| %2 = project_box %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T>, 0 |
| %3 = function_ref @binary : $@convention(thin) (Int, Int) -> Bool |
| %4 = alloc_stack $S<T> |
| copy_addr %2 to [initialization] %4 : $*S<T> |
| %6 = function_ref @get : $@convention(method) <τ_0_0 where τ_0_0 : Count> (@in S<τ_0_0>) -> Int |
| %7 = apply %6<T>(%4) : $@convention(method) <τ_0_0 where τ_0_0 : Count> (@in S<τ_0_0>) -> Int |
| %8 = apply %3(%0, %7) : $@convention(thin) (Int, Int) -> Bool |
| dealloc_stack %4 : $*S<T> |
| destroy_value %1 : $<τ_0_0 where τ_0_0 : Count> { var S<τ_0_0> } <T> |
| // CHECK: return |
| return %8 : $Bool |
| } |
| |
| // CHECK-LABEL: sil [transparent] [serialized] @binary |
| sil [transparent] [serialized] @binary : $@convention(thin) (Int, Int) -> Bool |
| |
| // CHECK-LABEL: sil [ossa] @destroy_stack_value_after_closure |
| sil [ossa] @destroy_stack_value_after_closure : $@convention(thin) <T> (@in T) -> @out T { |
| // CHECK: bb0 |
| bb0(%0 : $*T, %1 : $*T): |
| // CHECK: [[STACK:%.*]] = alloc_stack |
| // CHECK: copy_addr %1 to [initialization] [[STACK]] |
| // CHECK: [[APPLIED:%.*]] = function_ref |
| %3 = function_ref @applied : $@convention(thin) <τ_0_0> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> () |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T> |
| %4a = project_box %4 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| copy_addr %1 to [initialization] %4a : $*T |
| // CHECK: [[PARTIAL:%.*]] = partial_apply [[APPLIED]]<T>([[STACK]]) |
| %6 = partial_apply %3<T>(%4) : $@convention(thin) <τ_0_0> (@owned <τ_0_0> { var τ_0_0 } <τ_0_0>) -> () |
| // CHECK: debug_value [[PARTIAL]] |
| debug_value %6 : $@callee_owned () -> () |
| // CHECK: [[COPIED_PARTIAL:%.*]] = copy_value [[PARTIAL]] |
| %7 = copy_value %6 : $@callee_owned () -> () |
| // CHECK: apply [[COPIED_PARTIAL]]() : $@callee_owned () -> () |
| %9 = apply %7() : $@callee_owned () -> () |
| copy_addr %1 to [initialization] %0 : $*T |
| // CHECK: destroy_value [[PARTIAL]] |
| destroy_value %6 : $@callee_owned () -> () |
| // CHECK: destroy_addr [[STACK]] |
| // CHECK: destroy_addr %1 |
| destroy_addr %1 : $*T |
| %13 = tuple () |
| return %13 : $() |
| } |
| |
| sil [ossa] @applied : $@convention(thin) <T> (@owned <τ_0_0> { var τ_0_0 } <T>) -> () { |
| bb0(%0 : @owned $<τ_0_0> { var τ_0_0 } <T>): |
| %1 = project_box %0 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| %2 = function_ref @consume : $@convention(thin) <τ_0_0> (@in τ_0_0) -> () |
| %3 = alloc_stack $T |
| copy_addr %1 to [initialization] %3 : $*T |
| %5 = apply %2<T>(%3) : $@convention(thin) <τ_0_0> (@in τ_0_0) -> () |
| dealloc_stack %3 : $*T |
| destroy_value %0 : $<τ_0_0> { var τ_0_0 } <T> |
| %8 = tuple () |
| return %8 : $() |
| } |
| |
| sil hidden [noinline] @consume : $@convention(thin) <T> (@in T) -> () { |
| bb0(%0 : $*T): |
| debug_value_addr %0 : $*T |
| destroy_addr %0 : $*T |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| class ThrowBaseClass { |
| required init() throws |
| init(noFail: ()) |
| } |
| |
| class ThrowDerivedClass : ThrowBaseClass { |
| //final init(failBeforeFullInitialization: Int) throws |
| } |
| |
| sil [ossa] @throwing_unwrap : $@convention(thin) (Int) -> (Int, @error Error) |
| sil [ossa] @fake_throwing_init : $@convention(method) (Int, @owned ThrowDerivedClass) -> (@owned ThrowDerivedClass, @error Error) |
| |
| sil hidden [ossa] @try_apply_during_chaining_init : $@convention(method) (Int, @owned ThrowDerivedClass) -> (@owned ThrowDerivedClass, @error Error) { |
| // %0 // users: %11, %5 |
| // %1 // user: %7 |
| bb0(%0 : $Int, %1 : @owned $ThrowDerivedClass): |
| %2 = alloc_box ${ var ThrowDerivedClass }, let, name "self" |
| %3 = mark_uninitialized [delegatingself] %2 : ${ var ThrowDerivedClass } |
| %4 = project_box %3 : ${ var ThrowDerivedClass }, 0 |
| store %1 to [init] %4 : $*ThrowDerivedClass |
| %8 = load [take] %4 : $*ThrowDerivedClass |
| %9 = function_ref @fake_throwing_init : $@convention(method) (Int, @owned ThrowDerivedClass) -> (@owned ThrowDerivedClass, @error Error) |
| %10 = function_ref @throwing_unwrap : $@convention(thin) (Int) -> (Int, @error Error) |
| try_apply %10(%0) : $@convention(thin) (Int) -> (Int, @error Error), normal bb1, error bb3 |
| |
| // %12 // user: %13 |
| bb1(%12 : $Int): // Preds: bb0 |
| try_apply %9(%12, %8) : $@convention(method) (Int, @owned ThrowDerivedClass) -> (@owned ThrowDerivedClass, @error Error), normal bb2, error bb4 |
| |
| // %14 // user: %15 |
| bb2(%14 : @owned $ThrowDerivedClass): // Preds: bb1 |
| store %14 to [init] %4 : $*ThrowDerivedClass |
| %16 = load [copy] %4 : $*ThrowDerivedClass |
| destroy_value %3 : ${ var ThrowDerivedClass } |
| return %16 : $ThrowDerivedClass |
| |
| // %20 // user: %22 |
| bb3(%20 : @owned $Error): // Preds: bb0 |
| destroy_value %8 : $ThrowDerivedClass |
| br bb5(%20 : $Error) |
| |
| // %23 // user: %24 |
| bb4(%23 : @owned $Error): // Preds: bb1 |
| br bb5(%23 : $Error) |
| |
| // %25 // user: %27 |
| bb5(%25 : @owned $Error): // Preds: bb4 bb3 |
| destroy_value %3 : ${ var ThrowDerivedClass } |
| throw %25 : $Error |
| } |
| |
| // CHECK-LABEL: sil [ossa] @deal_with_wrong_nesting |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[STACK1:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: bb1: |
| // CHECK-NEXT: dealloc_stack [[BOX]] |
| // CHECK-NEXT: dealloc_stack [[STACK1]] |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: [[STACK2:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: dealloc_stack [[STACK2]] |
| // CHECK-NEXT: dealloc_stack [[BOX]] |
| // CHECK-NEXT: dealloc_stack [[STACK1]] |
| // CHECK: bb3: |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @deal_with_wrong_nesting : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %as1 = alloc_stack $Bool |
| %1 = alloc_box ${ var Int } |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| destroy_value %1 : ${ var Int } |
| dealloc_stack %as1 : $*Bool |
| br bb3 |
| |
| bb2: |
| %1a = project_box %1 : ${ var Int }, 0 |
| store %0 to [trivial] %1a : $*Int |
| dealloc_stack %as1 : $*Bool |
| %3 = load [trivial] %1a : $*Int |
| %as2 = alloc_stack $Bool |
| destroy_value %1 : ${ var Int } |
| dealloc_stack %as2 : $*Bool |
| br bb3 |
| |
| bb3: |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @wrong_nesting_with_alloc_ref |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[REF:%[0-9]+]] = alloc_ref [stack] $SomeClass |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: store |
| // CHECK: dealloc_stack [[BOX]] |
| // CHECK-NEXT: dealloc_ref [stack] [[REF]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @wrong_nesting_with_alloc_ref : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %as1 = alloc_ref [stack] $SomeClass |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| store %0 to [trivial] %1a : $*Int |
| dealloc_ref [stack] %as1 : $SomeClass |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable1 |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[STACK1:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: bb1: |
| // CHECK-NEXT: [[STACK2:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: dealloc_stack [[STACK2]] |
| // CHECK-NEXT: unreachable |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: dealloc_stack [[BOX]] |
| // CHECK-NEXT: dealloc_stack [[STACK1]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @nesting_and_unreachable1 : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %as1 = alloc_stack $Bool |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %as2 = alloc_stack $Bool |
| dealloc_stack %as2 : $*Bool |
| unreachable |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| dealloc_stack %as1 : $*Bool |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable2 |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[STACK1:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: bb1: |
| // CHECK-NEXT: [[STACK2:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: dealloc_stack [[STACK2]] |
| // CHECK-NEXT: dealloc_stack [[BOX]] |
| // CHECK-NEXT: unreachable |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: dealloc_stack [[BOX]] |
| // CHECK-NEXT: dealloc_stack [[STACK1]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @nesting_and_unreachable2 : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %as1 = alloc_stack $Bool |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %as2 = alloc_stack $Bool |
| destroy_value %1 : ${ var Int } |
| dealloc_stack %as2 : $*Bool |
| unreachable |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| dealloc_stack %as1 : $*Bool |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable3 |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK-NEXT: [[STACK:%[0-9]+]] = alloc_stack $Bool |
| // CHECK: bb1: |
| // CHECK-NEXT: unreachable |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: dealloc_stack [[STACK]] |
| // CHECK-NEXT: dealloc_stack [[BOX]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @nesting_and_unreachable3 : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %as1 = alloc_stack $Bool |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| destroy_value %1 : ${ var Int } |
| unreachable |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| %3 = load [trivial] %1a : $*Int |
| dealloc_stack %as1 : $*Bool |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable4 |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: bb1: |
| // CHECK-NEXT: unreachable |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: dealloc_stack [[BOX]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @nesting_and_unreachable4 : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| unreachable |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable5 |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK: bb1: |
| // CHECK-NEXT: {{.*}} = alloc_stack $Bool |
| // CHECK-NEXT: {{.*}} = alloc_stack $Bool |
| // CHECK-NEXT: unreachable |
| // CHECK: bb2: |
| // CHECK: store |
| // CHECK: dealloc_stack [[BOX]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| sil [ossa] @nesting_and_unreachable5 : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %as1 = alloc_stack $Bool |
| %as2 = alloc_stack $Bool |
| unreachable |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| %3 = load [trivial] %1a : $*Int |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: sil [ossa] @nesting_and_unreachable_critical_edge |
| // CHECK: bb0(%0 : $Int): |
| // CHECK-NEXT: [[BOX:%[0-9]+]] = alloc_stack $Int |
| // CHECK-NEXT: [[STACK1:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: cond_br |
| // CHECK: bb1: |
| // CHECK-NEXT: [[STACK2:%[0-9]+]] = alloc_stack $Bool |
| // CHECK-NEXT: cond_br |
| // CHECK: bb2: |
| // CHECK-NEXT: dealloc_stack [[STACK2]] |
| // CHECK-NEXT: br bb4 |
| // CHECK: bb3: |
| // CHECK: store |
| // CHECK: dealloc_stack [[STACK2]] |
| // CHECK-NEXT: dealloc_stack [[STACK1]] |
| // CHECK-NEXT: dealloc_stack [[BOX]] |
| // CHECK-NEXT: tuple |
| // CHECK-NEXT: return |
| // CHECK: bb4: |
| // CHECK-NEXT: unreachable |
| sil [ossa] @nesting_and_unreachable_critical_edge : $@convention(thin) (Int) -> () { |
| bb0(%0 : $Int): |
| %1 = alloc_box ${ var Int } |
| %as1 = alloc_stack $Bool |
| %1a = project_box %1 : ${ var Int }, 0 |
| cond_br undef, bb1, bb3 |
| |
| bb1: |
| %as2 = alloc_stack $Bool |
| cond_br undef, bb2, bb3 |
| |
| bb2: |
| store %0 to [trivial] %1a : $*Int |
| %3 = load [trivial] %1a : $*Int |
| dealloc_stack %as2 : $*Bool |
| dealloc_stack %as1 : $*Bool |
| destroy_value %1 : ${ var Int } |
| %r = tuple () |
| return %r : $() |
| |
| bb3: |
| destroy_value %1 : ${ var Int } |
| unreachable |
| } |
| |
| // Test that |
| // begin_access [read], copy_addr, end_access, destroy_addr |
| // is folded into |
| // begin_access [deinit], copy_addr [take], end_access |
| // |
| // CHECK-LABEL: sil [ossa] @deinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) { |
| // CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T): |
| // CHECK: [[STK:%.*]] = alloc_stack $T, var, name "x" |
| // CHECK: copy_addr %2 to [initialization] [[STK]] : $*T |
| // CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*T |
| // CHECK: copy_addr [[READ]] to [initialization] %0 : $*T |
| // CHECK: end_access [[READ]] : $*T |
| // CHECK: [[READ:%.*]] = begin_access [deinit] [static] [[STK]] : $*T |
| // CHECK: copy_addr [take] [[READ]] to [initialization] %1 : $*T |
| // CHECK: end_access [[READ]] : $*T |
| // CHECK-NOT: destroy_addr |
| // CHECK: dealloc_stack [[STK]] : $*T |
| // CHECK: destroy_addr %2 : $*T |
| // CHECK: return %{{.*}} : $() |
| // CHECK-LABEL: } // end sil function 'deinit_access' |
| sil [ossa] @deinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) { |
| bb0(%0 : @owned $*T, %1 : @owned $*T, %2 : @owned $*T): |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T>, var, name "x" |
| %5 = project_box %4 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| copy_addr %2 to [initialization] %5 : $*T |
| %7 = begin_access [read] [static] %5 : $*T |
| copy_addr %7 to [initialization] %0 : $*T |
| end_access %7 : $*T |
| %10 = begin_access [read] [static] %5 : $*T |
| copy_addr %10 to [initialization] %1 : $*T |
| end_access %10 : $*T |
| destroy_value %4 : $<τ_0_0> { var τ_0_0 } <T> |
| destroy_addr %2 : $*T |
| %15 = tuple () |
| return %15 : $() |
| } |
| |
| // Test that |
| // begin_access [read], <other access>, copy_addr, end_access, destroy_addr |
| // is *not* folded into |
| // begin_access [deinit], copy_addr [take], end_access |
| // |
| // CHECK-LABEL: sil [ossa] @nodeinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) { |
| // CHECK: bb0(%0 : $*T, %1 : $*T, %2 : $*T): |
| // CHECK: [[STK:%.*]] = alloc_stack $T, var, name "x" |
| // CHECK: copy_addr %2 to [initialization] [[STK]] : $*T |
| // CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*T |
| // CHECK: copy_addr [[READ]] to [initialization] %0 : $*T |
| // CHECK: end_access [[READ]] : $*T |
| // CHECK: [[READ:%.*]] = begin_access [read] [static] [[STK]] : $*T |
| // CHECK: [[INNER:%.*]] = begin_access [read] [static] [[READ]] : $*T |
| // CHECK: end_access [[INNER]] : $*T |
| // CHECK: copy_addr [[READ]] to [initialization] %1 : $*T |
| // CHECK: end_access [[READ]] : $*T |
| // CHECK: destroy_addr [[STK]] : $*T |
| // CHECK: dealloc_stack [[STK]] : $*T |
| // CHECK: destroy_addr %2 : $*T |
| // CHECK: return %{{.*}} : $() |
| // CHECK-LABEL: } // end sil function 'nodeinit_access' |
| sil [ossa] @nodeinit_access : $@convention(thin) <T> (@in T) -> (@out T, @out T) { |
| bb0(%0 : @owned $*T, %1 : @owned $*T, %2 : @owned $*T): |
| %4 = alloc_box $<τ_0_0> { var τ_0_0 } <T>, var, name "x" |
| %5 = project_box %4 : $<τ_0_0> { var τ_0_0 } <T>, 0 |
| copy_addr %2 to [initialization] %5 : $*T |
| %7 = begin_access [read] [static] %5 : $*T |
| copy_addr %7 to [initialization] %0 : $*T |
| end_access %7 : $*T |
| %10 = begin_access [read] [static] %5 : $*T |
| %innerAccess = begin_access [read] [static] %10 : $*T |
| end_access %innerAccess : $*T |
| copy_addr %10 to [initialization] %1 : $*T |
| end_access %10 : $*T |
| destroy_value %4 : $<τ_0_0> { var τ_0_0 } <T> |
| destroy_addr %2 : $*T |
| %15 = tuple () |
| return %15 : $() |
| } |
