| // RUN: %target-sil-opt %s -escapes-dump -o /dev/null | %FileCheck %s |
| |
| // REQUIRES: asserts |
| |
| sil_stage canonical |
| |
| import Builtin |
| import Swift |
| import SwiftShims |
| |
| protocol ClassP : class { |
| func foo() |
| } |
| |
| class X : ClassP { |
| func foo() |
| deinit |
| } |
| |
| class Derived : X { |
| } |
| |
| class Y { |
| @_hasStorage var x: X |
| |
| init(newx: X) |
| } |
| |
| class Z { |
| @_hasStorage var x: X |
| init(newx: X) |
| deinit |
| } |
| |
| protocol P { |
| func foo() |
| } |
| |
| struct Pointer : P { |
| let y : Y |
| func foo() |
| } |
| |
| enum PointerEnum { |
| case B(Pointer, Pointer) |
| } |
| |
| enum PointerEnum2 { |
| case A |
| case B(Pointer) |
| case C |
| } |
| |
| class LinkedNode { |
| @_hasStorage var next: LinkedNode; |
| |
| init(_ n: LinkedNode) |
| } |
| |
| struct MyError : Error { |
| } |
| |
| final class ErrorClass : Error { |
| } |
| |
| struct SomeData { |
| let x : X |
| } |
| |
| struct FourFields { |
| let a : SomeData |
| let b : Pointer |
| let c : Builtin.RawPointer |
| let d : Y |
| } |
| |
| // Sanity check with a simple function. |
| |
| // CHECK-LABEL: CG of test_simple |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %2 |
| // CHECK-NEXT: Arg %1 Esc: G, Succ: |
| // CHECK-NEXT: Val %2 Esc: A, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: A, Succ: (%2.2) |
| // CHECK-NEXT: Con %2.2 Esc: G, Succ: %1 |
| // CHECK-NEXT: End |
| sil @test_simple : $@convention(thin) (@inout Y, @owned X) -> () { |
| bb0(%0 : $*Y, %1 : $X): |
| %2 = alloc_ref $Y |
| %3 = ref_element_addr %2 : $Y, #Y.x |
| store %1 to %3 : $*X |
| %5 = load %0 : $*Y |
| store %2 to %0 : $*Y |
| strong_release %5 : $Y |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
| // Test if a deferring edge is created for a block argument. |
| |
| // CHECK-LABEL: CG of deferringEdge |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%3.1) |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Val %3 Esc: %3, Succ: (%3.1), %0 |
| // CHECK-NEXT: Con %3.1 Esc: A, Succ: (%3.2) |
| // CHECK-NEXT: Con %3.2 Esc: A, Succ: %1 |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @deferringEdge : $@convention(thin) (@owned LinkedNode, @owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode, %1 : $LinkedNode): |
| br bb1(%0 : $LinkedNode) |
| |
| bb1(%3 : $LinkedNode): |
| %4 = ref_element_addr %3 : $LinkedNode, #LinkedNode.next |
| store %1 to %4 : $*LinkedNode |
| return %0 : $LinkedNode |
| } |
| |
| // Test a local object just escaping via return. |
| |
| // CHECK-LABEL: CG of escapes_via_return |
| // CHECK-NEXT: Val %0 Esc: R, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @escapes_via_return : $@convention(thin) () -> @owned X { |
| bb0: |
| %0 = alloc_ref $X |
| return %0 : $X |
| } |
| |
| // A linear chain of assignments is collapsed to a single node. |
| |
| // CHECK-LABEL: CG of test_linked_list |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Val %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: (%11.1) |
| // CHECK-NEXT: Val %4 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Val %7 Esc: %11, Succ: (%1.1) |
| // CHECK-NEXT: Val %11 Esc: %11, Succ: (%1.1), %7, %11.1 |
| // CHECK-NEXT: Con %11.1 Esc: A, Succ: (%1.1), %0, %1, %4 |
| // CHECK-NEXT: Ret Esc: R, Succ: %11.1 |
| // CHECK-NEXT: End |
| sil @test_linked_list : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = alloc_ref $LinkedNode |
| %2 = ref_element_addr %1 : $LinkedNode, #LinkedNode.next |
| store %0 to %2 : $*LinkedNode |
| %4 = alloc_ref $LinkedNode |
| %5 = ref_element_addr %4 : $LinkedNode, #LinkedNode.next |
| store %1 to %5 : $*LinkedNode |
| %7 = alloc_ref $LinkedNode |
| %8 = ref_element_addr %7 : $LinkedNode, #LinkedNode.next |
| store %4 to %8 : $*LinkedNode |
| br bb1(%7 : $LinkedNode) |
| |
| // This "x = x.next" loop let's the chain collapse to a single node. |
| bb1(%11 : $LinkedNode): |
| %12 = ref_element_addr %11 : $LinkedNode, #LinkedNode.next |
| %13 = load %12 : $*LinkedNode |
| cond_br undef, bb1(%13 : $LinkedNode), bb2 |
| |
| bb2: |
| return %13 : $LinkedNode |
| } |
| |
| // The same example as above but distributed over two functions. |
| |
| // CHECK-LABEL: CG of create_chain |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%7.1) |
| // CHECK-NEXT: Val %1 Esc: A, Succ: (%7.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: %0, %1, %4 |
| // CHECK-NEXT: Val %4 Esc: A, Succ: (%7.1) |
| // CHECK-NEXT: Val %7 Esc: %11, Succ: (%7.1) |
| // CHECK-NEXT: Con %7.1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Val %11 Esc: R, Succ: (%7.1), %1.1 |
| // CHECK-NEXT: Ret Esc: R, Succ: %11 |
| // CHECK-NEXT: End |
| sil @create_chain : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = alloc_ref $LinkedNode |
| %2 = ref_element_addr %1 : $LinkedNode, #LinkedNode.next |
| store %0 to %2 : $*LinkedNode |
| %4 = alloc_ref $LinkedNode |
| %5 = ref_element_addr %4 : $LinkedNode, #LinkedNode.next |
| store %1 to %5 : $*LinkedNode |
| %7 = alloc_ref $LinkedNode |
| %8 = ref_element_addr %7 : $LinkedNode, #LinkedNode.next |
| store %4 to %8 : $*LinkedNode |
| |
| %10 = function_ref @loadNext : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %11 = apply %10(%7) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| return %11 : $LinkedNode |
| } |
| |
| // CHECK-LABEL: CG of loadNext |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%2.1) |
| // CHECK-NEXT: Val %2 Esc: %2, Succ: (%2.1), %0, %2.2 |
| // CHECK-NEXT: Con %2.1 Esc: A, Succ: (%2.2) |
| // CHECK-NEXT: Con %2.2 Esc: A, Succ: (%2.1) |
| // CHECK-NEXT: Ret Esc: R, Succ: %2.2 |
| // CHECK-NEXT: End |
| sil @loadNext : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| br bb1(%0 : $LinkedNode) |
| |
| bb1(%2 : $LinkedNode): |
| %3 = ref_element_addr %2 : $LinkedNode, #LinkedNode.next |
| %4 = load %3 : $*LinkedNode |
| cond_br undef, bb1(%4 : $LinkedNode), bb2 |
| |
| bb2: |
| return %4 : $LinkedNode |
| } |
| |
| // Content nodes in the callee are duplicated in the caller. |
| |
| // CHECK-LABEL: CG of call_load_next3 |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: A, Succ: (%0.4) |
| // CHECK-NEXT: Con %0.4 Esc: A, Succ: (%0.5) |
| // CHECK-NEXT: Con %0.5 Esc: A, Succ: (%0.6) |
| // CHECK-NEXT: Con %0.6 Esc: A, Succ: |
| // CHECK-NEXT: Val %2 Esc: R, Succ: %0.6 |
| // CHECK-NEXT: Ret Esc: R, Succ: %2 |
| // CHECK-NEXT: End |
| sil @call_load_next3 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = function_ref @load_next3 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %2 = apply %1(%0) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| return %2 : $LinkedNode |
| } |
| |
| // CHECK-LABEL: CG of load_next3 |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: A, Succ: (%0.4) |
| // CHECK-NEXT: Con %0.4 Esc: A, Succ: (%0.5) |
| // CHECK-NEXT: Con %0.5 Esc: A, Succ: (%0.6) |
| // CHECK-NEXT: Con %0.6 Esc: A, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0.6 |
| // CHECK-NEXT: End |
| sil @load_next3 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = ref_element_addr %0 : $LinkedNode, #LinkedNode.next |
| %2 = load %1 : $*LinkedNode |
| %3 = ref_element_addr %2 : $LinkedNode, #LinkedNode.next |
| %4 = load %3 : $*LinkedNode |
| %5 = ref_element_addr %4 : $LinkedNode, #LinkedNode.next |
| %6 = load %5 : $*LinkedNode |
| return %6 : $LinkedNode |
| } |
| |
| sil_global @global_pointer : $Pointer |
| sil_global @global_x : $X |
| |
| // The argument escapes because it is stored to a global variable in the callee. |
| |
| // CHECK-LABEL: CG of call_store_pointer |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0.2 |
| // CHECK-NEXT: End |
| sil @call_store_pointer : $@convention(thin) (@owned Pointer) -> @owned X { |
| bb0(%0 : $Pointer): |
| debug_value %0 : $Pointer |
| %2 = function_ref @store_pointer : $@convention(thin) (@owned Pointer) -> () |
| %3 = struct_extract %0 : $Pointer, #Pointer.y |
| %5 = apply %2(%0) : $@convention(thin) (@owned Pointer) -> () |
| %6 = ref_element_addr %3 : $Y, #Y.x |
| %7 = load %6 : $*X |
| return %7 : $X |
| } |
| |
| // CHECK-LABEL: CG of store_pointer |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: %0 |
| // CHECK-NEXT: End |
| sil @store_pointer : $@convention(thin) (@owned Pointer) -> () { |
| bb0(%0 : $Pointer): |
| %1 = global_addr @global_pointer : $*Pointer |
| store %0 to %1 : $*Pointer |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| // The argument does not escape because only the content is stored to a |
| // global variable in the callee. |
| |
| // CHECK-LABEL: CG of store_content |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: %0.2 |
| // CHECK-NEXT: End |
| sil @store_content : $@convention(thin) (@owned Pointer) -> () { |
| bb0(%0 : $Pointer): |
| %1 = global_addr @global_x : $*X |
| %3 = struct_extract %0 : $Pointer, #Pointer.y |
| %4 = ref_element_addr %3 : $Y, #Y.x |
| %5 = load %4 : $*X |
| store %5 to %1 : $*X |
| %11 = tuple () |
| return %11 : $() |
| } |
| |
| // CHECK-LABEL: CG of call_store_content |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0.2 |
| // CHECK-NEXT: End |
| sil @call_store_content : $@convention(thin) (@owned Pointer) -> @owned X { |
| bb0(%0 : $Pointer): |
| %2 = function_ref @store_content : $@convention(thin) (@owned Pointer) -> () |
| %3 = struct_extract %0 : $Pointer, #Pointer.y |
| %5 = apply %2(%0) : $@convention(thin) (@owned Pointer) -> () |
| %6 = ref_element_addr %3 : $Y, #Y.x |
| %7 = load %6 : $*X |
| return %7 : $X |
| } |
| |
| // CHECK-LABEL: CG of copy_addr_content |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %1.1 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @copy_addr_content : $@convention(thin) (@in_guaranteed Int32) -> @out Int32 { |
| bb0(%0: $*Int32, %1: $*Int32): |
| copy_addr %1 to [initialization] %0 : $*Int32 |
| %2 = tuple() |
| return %2 : $() |
| } |
| |
| // CHECK-LABEL: CG of copy_addr_take_content |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %1.1 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @copy_addr_take_content : $@convention(thin) (@in_guaranteed Int32) -> @out Int32 { |
| bb0(%0: $*Int32, %1: $*Int32): |
| copy_addr [take] %1 to [initialization] %0 : $*Int32 |
| %2 = tuple() |
| return %2 : $() |
| } |
| |
| // CHECK-LABEL: CG of copy_addr_noinit_content |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: |
| // CHECK-NEXT: Arg %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @copy_addr_noinit_content : $@convention(thin) (@in_guaranteed Int32) -> @out Int32 { |
| bb0(%0: $*Int32, %1: $*Int32): |
| copy_addr [take] %1 to %0 : $*Int32 |
| %2 = tuple() |
| return %2 : $() |
| } |
| |
| // CHECK-LABEL: CG of call_copy_addr_content |
| // CHECK-NEXT: Val %0 Esc: %3, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: %3, Succ: %1.1 |
| // CHECK-NEXT: Val %1 Esc: %3, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: %3, Succ: |
| // CHECK-NEXT: End |
| sil @call_copy_addr_content : $@convention(thin) () -> () { |
| %0 = alloc_stack $Int32 |
| %1 = alloc_stack $Int32 |
| %2 = function_ref @copy_addr_content : $@convention(thin) (@in_guaranteed Int32) -> @out Int32 |
| %3 = apply %2(%0, %1) : $@convention(thin) (@in_guaranteed Int32) -> @out Int32 |
| %4 = tuple() |
| dealloc_stack %1 : $*Int32 |
| dealloc_stack %0 : $*Int32 |
| return %4 : $() |
| } |
| |
| // Test partial_apply. The partial_apply and the boxes do not escape. |
| // The X parameter does escape because it is stored in Y and the release |
| // of Y's box _could_ capture Y.x in Y's deinit. |
| |
| // CHECK-LABEL: CG of test_partial_apply |
| // CHECK-NEXT: Arg %1 Esc: G, Succ: |
| // CHECK-NEXT: Arg %2 Esc: A, Succ: (%6.3) |
| // CHECK-NEXT: Val %3 Esc: %14,%15,%17, Succ: (%6.1) |
| // CHECK-NEXT: Val %6 Esc: %14,%15,%16, Succ: (%6.1) |
| // CHECK-NEXT: Con %6.1 Esc: %14,%15,%16,%17, Succ: (%6.2) |
| // CHECK-NEXT: Con %6.2 Esc: %14,%15,%16,%17, Succ: %2 |
| // CHECK-NEXT: Con %6.3 Esc: G, Succ: |
| // CHECK-NEXT: Val %12 Esc: %14,%15, Succ: %3, %6 |
| // CHECK-NEXT: End |
| sil @test_partial_apply : $@convention(thin) (Int64, @owned X, @owned Y) -> Int64 { |
| bb0(%0 : $Int64, %1 : $X, %2 : $Y): |
| %3 = alloc_box $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| %4 = project_box %3 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| store %0 to %4 : $*Int64 |
| %6 = alloc_box $<Ï„_0_0> { var Ï„_0_0 } <Y> |
| %7 = project_box %6 : $<Ï„_0_0> { var Ï„_0_0 } <Y>, 0 |
| store %2 to %7 : $*Y |
| %9 = function_ref @closure1 : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Int64>, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> Int64 |
| strong_retain %3 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| strong_retain %6 : $<Ï„_0_0> { var Ï„_0_0 } <Y> |
| %12 = partial_apply %9(%3, %6) : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Int64>, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> Int64 |
| strong_retain %12 : $@callee_owned (@owned X) -> Int64 |
| %14 = apply %12(%1) : $@callee_owned (@owned X) -> Int64 |
| strong_release %12 : $@callee_owned (@owned X) -> Int64 |
| strong_release %6 : $<Ï„_0_0> { var Ï„_0_0 } <Y> |
| strong_release %3 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| return %14 : $Int64 |
| } |
| |
| // CHECK-LABEL: CG of closure1 |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: A, Succ: (%1.3) |
| // CHECK-NEXT: Con %1.3 Esc: G, Succ: |
| // CHECK-NEXT: Arg %2 Esc: A, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: A, Succ: (%2.2) |
| // CHECK-NEXT: Con %2.2 Esc: A, Succ: (%2.3) |
| // CHECK-NEXT: Con %2.3 Esc: G, Succ: |
| // CHECK-NEXT: Val %7 Esc: %8, Succ: %2 |
| // CHECK-NEXT: End |
| sil @closure1 : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Int64>, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> Int64 { |
| bb0(%0 : $X, %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, %2 : $<Ï„_0_0> { var Ï„_0_0 } <Y>): |
| %3 = project_box %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| %4 = project_box %2 : $<Ï„_0_0> { var Ï„_0_0 } <Y>, 0 |
| %5 = load %3 : $*Int64 |
| %6 = function_ref @closure2 : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () |
| %7 = partial_apply %6(%2) : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () |
| %8 = apply %7(%0) : $@callee_owned (@owned X) -> () |
| strong_release %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| return %5 : $Int64 |
| } |
| |
| // CHECK-LABEL: CG of closure2 |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: A, Succ: (%1.3) |
| // CHECK-NEXT: Con %1.3 Esc: G, Succ: (%1.4) |
| // CHECK-NEXT: Con %1.4 Esc: G, Succ: %0 |
| // CHECK-NEXT: End |
| sil @closure2 : $@convention(thin) (@owned X, @owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () { |
| bb0(%0 : $X, %1 : $<Ï„_0_0> { var Ï„_0_0 } <Y>): |
| %2 = project_box %1 : $<Ï„_0_0> { var Ï„_0_0 } <Y>, 0 |
| %3 = load %2 : $*Y |
| %4 = ref_element_addr %3 : $Y, #Y.x |
| store %0 to %4 : $*X |
| strong_release %1 : $<Ï„_0_0> { var Ï„_0_0 } <Y> |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
| // Test partial_apply. The box escapes in the callee. |
| |
| // CHECK-LABEL: CG of test_escaped_box |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: G, Succ: (%1.3) |
| // CHECK-NEXT: Con %1.3 Esc: G, Succ: |
| // CHECK-NEXT: Val %6 Esc: G, Succ: %1 |
| // CHECK-NEXT: End |
| sil @test_escaped_box : $@convention(thin) (Int64) -> Int64 { |
| bb0(%0 : $Int64): |
| %1 = alloc_box $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| %2 = project_box %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| store %0 to %2 : $*Int64 |
| |
| %4 = function_ref @let_box_escape : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 |
| strong_retain %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| %6 = partial_apply %4(%1) : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 |
| strong_retain %6 : $@callee_owned () -> Int64 |
| %8 = apply %6() : $@callee_owned () -> Int64 |
| strong_release %6 : $@callee_owned () -> Int64 |
| strong_release %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| return %8 : $Int64 |
| } |
| |
| // CHECK-LABEL: CG of let_box_escape |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @let_box_escape : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 { |
| bb0(%0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>): |
| %1 = project_box %0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| %2 = load %1 : $*Int64 |
| |
| %3 = function_ref @takebox : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> () |
| %4 = apply %3(%0) : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> () |
| strong_release %0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| return %2 : $Int64 |
| } |
| |
| sil @takebox : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> () |
| |
| |
| // The partial_apply itself escapes and therefore also the box escapes. |
| |
| // CHECK-LABEL: CG of test_escaped_partial_apply |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %6 Esc: G, Succ: %1 |
| // CHECK-NEXT: End |
| sil @test_escaped_partial_apply : $@convention(thin) (Int64) -> () { |
| bb0(%0 : $Int64): |
| %1 = alloc_box $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| %2 = project_box %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| store %0 to %2 : $*Int64 |
| %4 = function_ref @closure3 : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 |
| strong_retain %1 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| %6 = partial_apply %4(%1) : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 |
| strong_retain %6 : $@callee_owned () -> Int64 |
| %7 = function_ref @take_partial_apply : $@convention(thin) (@owned @callee_owned () -> Int64) -> () |
| %8 = apply %7(%6) : $@convention(thin) (@owned @callee_owned () -> Int64) -> () |
| %9 = tuple() |
| return %9 : $() |
| } |
| |
| // CHECK-LABEL: CG of closure3 |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @closure3 : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Int64>) -> Int64 { |
| bb0(%0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>): |
| %1 = project_box %0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64>, 0 |
| %2 = load %1 : $*Int64 |
| strong_release %0 : $<Ï„_0_0> { var Ï„_0_0 } <Int64> |
| return %2 : $Int64 |
| } |
| |
| sil @take_partial_apply : $@convention(thin) (@owned @callee_owned () -> Int64) -> () |
| |
| // Test if the global escape state is propagated through recursive functions. |
| |
| sil_global @global_ln : $LinkedNode |
| |
| // CHECK-LABEL: CG of load_next_recursive |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: Val %4 Esc: G, Succ: %0.2 |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @load_next_recursive : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = ref_element_addr %0 : $LinkedNode, #LinkedNode.next |
| %2 = load %1 : $*LinkedNode |
| %3 = function_ref @let_escape : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %4 = apply %3(%2) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| return %4 : $LinkedNode |
| } |
| |
| // CHECK-LABEL: CG of let_escape |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: %0 |
| // CHECK-NEXT: Val %4 Esc: G, Succ: %0 |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @let_escape : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = global_addr @global_ln : $*LinkedNode |
| store %0 to %1 : $*LinkedNode |
| %3 = function_ref @return_same : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %4 = apply %3(%0) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| return %4 : $LinkedNode |
| } |
| |
| // CHECK-LABEL: CG of return_same |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Val %3 Esc: G, Succ: (%0.1), %0.2 |
| // CHECK-NEXT: Val %5 Esc: R, Succ: %0, %3 |
| // CHECK-NEXT: Ret Esc: R, Succ: %5 |
| // CHECK-NEXT: End |
| sil @return_same : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| cond_br undef, bb1, bb2(%0 : $LinkedNode) |
| |
| bb1: |
| %2 = function_ref @load_next_recursive : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %3 = apply %2(%0) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| br bb2(%3 : $LinkedNode) |
| |
| bb2(%5 : $LinkedNode): |
| return %5 : $LinkedNode |
| } |
| |
| // Another recursion test. |
| |
| // CHECK-LABEL: CG of loadNext2 |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: A, Succ: (%0.4) |
| // CHECK-NEXT: Con %0.4 Esc: A, Succ: (%4.1) |
| // CHECK-NEXT: Val %4 Esc: R, Succ: %0.4 |
| // CHECK-NEXT: Con %4.1 Esc: A, Succ: (%4.2) |
| // CHECK-NEXT: Con %4.2 Esc: A, Succ: (%4.1) |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @loadNext2 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| %1 = ref_element_addr %0 : $LinkedNode, #LinkedNode.next |
| %2 = load %1 : $*LinkedNode |
| %3 = function_ref @returnNext2 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %4 = apply %3(%2) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| return %4 : $LinkedNode |
| } |
| |
| // CHECK-LABEL: CG of returnNext2 |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: A, Succ: (%0.4) |
| // CHECK-NEXT: Con %0.4 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Val %3 Esc: R, Succ: (%0.3), %0.4 |
| // CHECK-NEXT: Val %8 Esc: R, Succ: %0.2, %3 |
| // CHECK-NEXT: Ret Esc: R, Succ: %8 |
| // CHECK-NEXT: End |
| sil @returnNext2 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %2 = function_ref @loadNext2 : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %3 = apply %2(%0) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| br bb3(%3 : $LinkedNode) |
| |
| bb2: |
| %5 = ref_element_addr %0 : $LinkedNode, #LinkedNode.next |
| %6 = load %5 : $*LinkedNode |
| br bb3(%6 : $LinkedNode) |
| |
| bb3(%8 : $LinkedNode): |
| return %8 : $LinkedNode |
| } |
| |
| // A single-cycle recursion test. |
| |
| // CHECK-LABEL: CG of single_cycle_recursion |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Val %5 Esc: R, Succ: (%0.2), %0.1 |
| // CHECK-NEXT: Val %7 Esc: R, Succ: %0, %5 |
| // CHECK-NEXT: Ret Esc: R, Succ: %7 |
| // CHECK-NEXT: End |
| sil @single_cycle_recursion : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode { |
| bb0(%0 : $LinkedNode): |
| cond_br undef, bb1, bb2(%0 : $LinkedNode) |
| |
| bb1: |
| %1 = ref_element_addr %0 : $LinkedNode, #LinkedNode.next |
| %2 = load %1 : $*LinkedNode |
| %3 = function_ref @single_cycle_recursion : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| %4 = apply %3(%2) : $@convention(thin) (@owned LinkedNode) -> @owned LinkedNode |
| br bb2(%4 : $LinkedNode) |
| |
| bb2(%5 : $LinkedNode): |
| return %5 : $LinkedNode |
| } |
| |
| // Test if a try_apply is represented correctly in the connection graph. |
| |
| // CHECK-LABEL: CG of call_throwing_func |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Val %3 Esc: R, Succ: %0 |
| // CHECK-NEXT: Ret Esc: R, Succ: %3 |
| // CHECK-NEXT: End |
| sil @call_throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) { |
| bb0(%0 : $X): |
| %1 = function_ref @throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) |
| try_apply %1(%0) : $@convention(thin) (@owned X) -> (@owned X, @error Error), normal bb1, error bb2 |
| |
| bb1(%3 : $X): |
| return %3 : $X |
| |
| bb2(%5 : $Error): |
| throw %5 : $Error |
| } |
| |
| // CHECK-LABEL: CG of throwing_func |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Val %3 Esc: G, Succ: (%3.1) |
| // CHECK-NEXT: Con %3.1 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) { |
| bb0(%0 : $X): |
| cond_br undef, bb1, bb2 |
| |
| bb1: |
| %2 = alloc_existential_box $Error, $MyError |
| %3 = project_existential_box $MyError in %2 : $Error |
| %4 = struct $MyError () |
| store %4 to %3 : $*MyError |
| throw %2 : $Error |
| |
| bb2: |
| return %0 : $X |
| } |
| |
| // Test if a try_apply to an unknown function is handled correctly. |
| |
| // CHECK-LABEL: CG of call_unknown_throwing_func |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %3 Esc: G, Succ: |
| // CHECK-NEXT: Con %3.1 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %3 |
| // CHECK-NEXT: End |
| sil @call_unknown_throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) { |
| bb0(%0 : $X): |
| %1 = function_ref @unknown_throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) |
| try_apply %1(%0) : $@convention(thin) (@owned X) -> (@owned X, @error Error), normal bb1, error bb2 |
| |
| bb1(%3 : $X): |
| return %3 : $X |
| |
| bb2(%5 : $Error): |
| throw %5 : $Error |
| } |
| |
| sil @unknown_throwing_func : $@convention(thin) (@owned X) -> (@owned X, @error Error) |
| |
| // Test that the deinit of a box itself does not capture anything. |
| |
| // CHECK-LABEL: CG of test_release_of_partial_apply_with_box |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%1.3) |
| // CHECK-NEXT: Val %1 Esc: %6, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: %6, Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: %6, Succ: %0 |
| // CHECK-NEXT: Con %1.3 Esc: G, Succ: |
| // CHECK-NEXT: Val %5 Esc: %6, Succ: %1 |
| // CHECK-NEXT: End |
| sil @test_release_of_partial_apply_with_box : $@convention(thin) (@owned Y) -> () { |
| bb0(%0 : $Y): |
| %1 = alloc_box $<Ï„_0_0> { var Ï„_0_0 } <Y> |
| %2 = project_box %1 : $<Ï„_0_0> { var Ï„_0_0 } <Y>, 0 |
| store %0 to %2 : $*Y |
| %3 = function_ref @take_y_box : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () |
| %4 = partial_apply %3(%1) : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () |
| strong_release %4 : $@callee_owned () -> () |
| %6 = tuple () |
| return %6 : $() |
| } |
| |
| sil @take_y_box : $@convention(thin) (@owned <Ï„_0_0> { var Ï„_0_0 } <Y>) -> () |
| |
| // Test is an unknown value is merged correctly into the caller graph. |
| |
| // CHECK-LABEL: CG of store_to_unknown_reference |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Val %2 Esc: G, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: G, Succ: (%2.2) |
| // CHECK-NEXT: Con %2.2 Esc: G, Succ: %0 |
| // CHECK-NEXT: End |
| sil @store_to_unknown_reference : $@convention(thin) (@owned X) -> () { |
| bb0(%0 : $X): |
| %1 = function_ref @get_reference : $@convention(thin) () -> @owned Y |
| %2 = apply %1() : $@convention(thin) () -> @owned Y |
| %3 = ref_element_addr %2 : $Y, #Y.x |
| store %0 to %3 : $*X |
| %5 = tuple () |
| return %5 : $() |
| } |
| |
| // CHECK-LABEL: CG of get_reference |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %1 |
| // CHECK-NEXT: End |
| sil @get_reference : $@convention(thin) () -> @owned Y { |
| bb0: |
| %0 = function_ref @unknown_get_reference : $@convention(thin) () -> @owned Y |
| %1 = apply %0() : $@convention(thin) () -> @owned Y |
| return %1 : $Y |
| } |
| |
| sil @unknown_get_reference : $@convention(thin) () -> @owned Y |
| |
| // A test for a specific case of callee->caller graph merging. |
| |
| sil @unknown_set_y : $@convention(thin) () -> @out Y |
| |
| // CHECK-LABEL: CG of get_y |
| // CHECK-NEXT: Val %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0.1 |
| // CHECK-NEXT: End |
| sil @get_y : $@convention(thin) () -> @owned Y { |
| bb0: |
| %0 = alloc_stack $Y |
| %f = function_ref @unknown_set_y : $@convention(thin) () -> @out Y |
| %a = apply %f(%0) : $@convention(thin) () -> @out Y |
| %r = load %0 : $*Y |
| dealloc_stack %0 : $*Y |
| return %r : $Y |
| } |
| |
| // CHECK-LABEL: CG of create_and_store_x |
| // CHECK-NEXT: Val %0 Esc: G, Succ: |
| // CHECK-NEXT: Val %2 Esc: G, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: G, Succ: (%2.2) |
| // CHECK-NEXT: Con %2.2 Esc: G, Succ: %0 |
| // CHECK-NEXT: End |
| sil @create_and_store_x : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref $X |
| %f = function_ref @get_y : $@convention(thin) () -> @owned Y |
| %y = apply %f() : $@convention(thin) () -> @owned Y |
| %x = ref_element_addr %y : $Y, #Y.x |
| store %0 to %x : $*X |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // Test types which are considered as pointers. |
| |
| // CHECK-LABEL: CG of pointer_types |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: %1 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Val %7 Esc: R, Succ: %0 |
| // CHECK-NEXT: Ret Esc: R, Succ: %7 |
| // CHECK-NEXT: End |
| sil @pointer_types : $@convention(thin) (@owned Y, @owned Y) -> @owned Y { |
| bb0(%0 : $Y, %1 : $Y): |
| %2 = struct $Pointer (%0 : $Y) |
| %3 = struct $Pointer (%1 : $Y) |
| %4 = tuple (%2 : $Pointer, %3 : $Pointer) |
| %5 = enum $PointerEnum, #PointerEnum.B!enumelt.1, %4 : $(Pointer, Pointer) |
| switch_enum %5 : $PointerEnum, case #PointerEnum.B!enumelt.1: bb1 |
| |
| bb1(%7 : $(Pointer, Pointer)): |
| %8 = tuple_extract %7 : $(Pointer, Pointer), 1 |
| %9 = struct_extract %8 : $Pointer, #Pointer.y |
| return %9 : $Y |
| } |
| |
| // CHECK-LABEL: CG of defer_edge_cycle |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %1.1 |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: A, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: (%0.2), %0.1 |
| // CHECK-NEXT: End |
| sil @defer_edge_cycle : $@convention(thin) (@inout Y, @inout Y) -> () { |
| entry(%0 : $*Y, %1 : $*Y): |
| %l1 = load %0 : $*Y |
| store %l1 to %1 : $*Y |
| %l2 = load %1 : $*Y |
| store %l2 to %0 : $*Y |
| %x = ref_element_addr %l1 : $Y, #Y.x |
| %l3 = load %x : $*X |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of take_c_func |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: G, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @take_c_func : $@convention(thin) (@convention(c) () -> ()) -> @convention(c) () -> () { |
| bb0(%0 : $@convention(c) () -> ()): |
| %3 = apply %0() : $@convention(c) () -> () |
| return %0 : $@convention(c) () -> () |
| } |
| |
| // CHECK-LABEL: CG of c_func |
| // CHECK-NEXT: End |
| sil @c_func : $@convention(c) () -> () { |
| bb0: |
| %0 = tuple () |
| return %0 : $() |
| } |
| |
| // CHECK-LABEL: CG of pass_c_func |
| // CHECK-NEXT: Val %2 Esc: G, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @pass_c_func : $@convention(thin) () -> () { |
| bb0: |
| %0 = function_ref @take_c_func : $@convention(thin) (@convention(c) () -> ()) -> @convention(c) () -> () |
| %1 = function_ref @c_func : $@convention(c) () -> () |
| %2 = apply %0(%1) : $@convention(thin) (@convention(c) () -> ()) -> @convention(c) () -> () |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| |
| // CHECK-LABEL: CG of test_select_enum |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Arg %2 Esc: A, Succ: |
| // CHECK-NEXT: Arg %3 Esc: A, Succ: |
| // CHECK-NEXT: Val %4 Esc: R, Succ: %1, %2, %3 |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @test_select_enum : $@convention(thin) (PointerEnum2, @owned X, @owned X, @owned X) -> @owned X { |
| bb0(%0 : $PointerEnum2, %1 : $X, %2 : $X, %3 : $X): |
| %4 = select_enum %0 : $PointerEnum2, case #PointerEnum2.A!enumelt: %1, case #PointerEnum2.B!enumelt: %2, default %3 : $X |
| return %4 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_select_enum_addr |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Arg %2 Esc: A, Succ: |
| // CHECK-NEXT: Arg %3 Esc: A, Succ: |
| // CHECK-NEXT: Val %4 Esc: R, Succ: %1, %2, %3 |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @test_select_enum_addr : $@convention(thin) (@in PointerEnum2, @owned X, @owned X, @owned X) -> @owned X { |
| bb0(%0 : $*PointerEnum2, %1 : $X, %2 : $X, %3 : $X): |
| %4 = select_enum_addr %0 : $*PointerEnum2, case #PointerEnum2.A!enumelt: %1, case #PointerEnum2.B!enumelt: %2, default %3 : $X |
| return %4 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_select_value |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Arg %2 Esc: A, Succ: |
| // CHECK-NEXT: Arg %3 Esc: A, Succ: |
| // CHECK-NEXT: Val %6 Esc: R, Succ: %1, %2, %3 |
| // CHECK-NEXT: Ret Esc: R, Succ: %6 |
| // CHECK-NEXT: End |
| sil @test_select_value : $@convention(thin) (Builtin.Int64, @owned X, @owned X, @owned X) -> @owned X { |
| bb0(%0 : $Builtin.Int64, %1 : $X, %2 : $X, %3 : $X): |
| %4 = integer_literal $Builtin.Int64, 0 |
| %5 = integer_literal $Builtin.Int64, 1 |
| %6 = select_value %0 : $Builtin.Int64, case %4: %1, case %5: %2, default %3 : $X |
| return %6 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_existential_addr |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Val %1 Esc: , Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: , Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: , Succ: %0 |
| // CHECK-NEXT: End |
| sil @test_existential_addr : $@convention(thin) (@owned Pointer) -> () { |
| bb0(%0 : $Pointer): |
| %1 = alloc_stack $P |
| %2 = init_existential_addr %1 : $*P, $Pointer |
| store %0 to %2 : $*Pointer |
| %4 = open_existential_addr immutable_access %1 : $*P to $*@opened("C62B1408-97C8-11E5-8D7C-685B35C48C83") P |
| %5 = witness_method $@opened("C62B1408-97C8-11E5-8D7C-685B35C48C83") P, #P.foo!1, %4 : $*@opened("C62B1408-97C8-11E5-8D7C-685B35C48C83") P : $@convention(witness_method: P) <Ï„_0_0 where Ï„_0_0 : P> (@in_guaranteed Ï„_0_0) -> () |
| dealloc_stack %1 : $*P |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
| // CHECK-LABEL: CG of test_existential_ref |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @test_existential_ref : $@convention(thin) (@owned X) -> () { |
| bb0(%0 : $X): |
| %1 = init_existential_ref %0 : $X : $X, $ClassP |
| %2 = open_existential_ref %1 : $ClassP to $@opened("EC6B6A86-9887-11E5-926E-685B35C48C83") ClassP |
| %3 = witness_method $@opened("EC6B6A86-9887-11E5-926E-685B35C48C83") ClassP, #ClassP.foo!1, %2 : $@opened("EC6B6A86-9887-11E5-926E-685B35C48C83") ClassP : $@convention(witness_method: ClassP) <Ï„_0_0 where Ï„_0_0 : ClassP> (@guaranteed Ï„_0_0) -> () |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
| // We don't handle existential boxes currently. |
| // Check that we don't crash on this. |
| |
| // CHECK-LABEL: CG of test_unknown_store |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: |
| // CHECK-NEXT: Val %2 Esc: G, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: G, Succ: %0 |
| // CHECK-NEXT: End |
| sil @test_unknown_store : $@convention(thin) (@owned ErrorClass) -> () { |
| bb0(%0 : $ErrorClass): |
| %2 = alloc_existential_box $Error, $ErrorClass |
| %3 = project_existential_box $ErrorClass in %2 : $Error |
| store %0 to %3 : $*ErrorClass |
| %5 = tuple () |
| return %5 : $() |
| } |
| |
| // CHECK-LABEL: CG of test_raw_pointer_to_ref |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @test_raw_pointer_to_ref : $@convention(thin) (@owned X) -> @owned X { |
| bb0(%0 : $X): |
| %1 = ref_to_raw_pointer %0 : $X to $Builtin.RawPointer |
| %2 = raw_pointer_to_ref %1 : $Builtin.RawPointer to $X |
| return %2 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_bridge_object_to_ref |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @test_bridge_object_to_ref : $@convention(thin) (@owned X, Builtin.Word) -> @owned X { |
| bb0(%0 : $X, %1 : $Builtin.Word): |
| %2 = ref_to_bridge_object %0 : $X, %1 : $Builtin.Word |
| %3 = bridge_object_to_ref %2 : $Builtin.BridgeObject to $X |
| return %3 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_address_to_pointer |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %1 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @test_address_to_pointer : $@convention(thin) (@owned X) -> @out X { |
| bb0(%0 : $*X, %1 : $X): |
| %2 = address_to_pointer %0 : $*X to $Builtin.RawPointer |
| %3 = pointer_to_address %2 : $Builtin.RawPointer to [strict] $*X |
| store %1 to %3 : $*X |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
| // CHECK-LABEL: CG of test_casts |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Ret Esc: R, Succ: %0 |
| // CHECK-NEXT: End |
| sil @test_casts : $@convention(thin) (@owned AnyObject) -> @owned X { |
| bb0(%0 : $AnyObject): |
| %1 = unchecked_ref_cast %0 : $AnyObject to $Derived |
| %2 = upcast %1 : $Derived to $X |
| return %2 : $X |
| } |
| |
| // CHECK-LABEL: CG of test_unchecked_ref_cast_addr |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: %1 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @test_unchecked_ref_cast_addr : $@convention(thin) <T, U> (@in T, @thick U.Type) -> @out U { |
| bb0(%0 : $*U, %1 : $*T, %2 : $@thick U.Type): |
| unchecked_ref_cast_addr T in %1 : $*T to U in %0 : $*U |
| %5 = tuple () |
| return %5 : $() |
| } |
| |
| sil_global @global_y : $SomeData |
| |
| // CHECK-LABEL: CG of test_node_merge_during_struct_inst |
| // CHECK-NEXT: Arg %0 Esc: G, Succ: (%4.1) |
| // CHECK-NEXT: Val %1 Esc: G, Succ: (%4.1) |
| // CHECK-NEXT: Val %4 Esc: G, Succ: (%4.1) |
| // CHECK-NEXT: Con %4.1 Esc: G, Succ: (%4.1), %0, %1, %4 |
| // CHECK-NEXT: End |
| sil @test_node_merge_during_struct_inst : $@convention(thin) (Y) -> () { |
| bb0(%0 : $Y): |
| %1 = global_addr @global_y : $*SomeData |
| %2 = address_to_pointer %1 : $*SomeData to $Builtin.RawPointer |
| %3 = raw_pointer_to_ref %2 : $Builtin.RawPointer to $Y |
| |
| %4 = alloc_stack $Pointer |
| %5 = struct_element_addr %4 : $*Pointer, #Pointer.y |
| store %3 to %5 : $*Y |
| |
| %7 = load %1 : $*SomeData |
| %8 = load %4 : $*Pointer |
| %9 = address_to_pointer %4 : $*Pointer to $Builtin.RawPointer |
| |
| // Analyzing this instruction causes a node merge. |
| // Check that we don't crash on this. |
| %l = struct $FourFields(%7 : $SomeData, %8 : $Pointer, %9 : $Builtin.RawPointer, %0 : $Y) |
| |
| dealloc_stack %4 : $*Pointer |
| %r = tuple () |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_is_native_no_typecheck |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_is_native_no_typecheck : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| %f = function_ref @is_native_type_checked : $@convention(method) (@guaranteed Array<X>) -> Bool |
| %a = apply %f(%0) : $@convention(method) (@guaranteed Array<X>) -> Bool |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_check_subscript |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_check_subscript : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| %il = integer_literal $Builtin.Int32, 0 |
| %i = struct $Int32(%il : $Builtin.Int32) |
| %bl = integer_literal $Builtin.Int1, 0 |
| %b = struct $Bool (%bl : $Builtin.Int1) |
| |
| %f = function_ref @check_subscript : $@convention(method) (Int32, Bool, @guaranteed Array<X>) -> () |
| %a = apply %f(%i, %b, %0) : $@convention(method) (Int32, Bool, @guaranteed Array<X>) -> () |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_check_index |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_check_index : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| %il = integer_literal $Builtin.Int32, 0 |
| %i = struct $Int32(%il : $Builtin.Int32) |
| |
| %f = function_ref @check_index : $@convention(method) (Int32, @guaranteed Array<X>) -> () |
| %a = apply %f(%i, %0) : $@convention(method) (Int32, @guaranteed Array<X>) -> () |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_get_element |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: %1.2 |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: A, Succ: (%1.2) |
| // CHECK-NEXT: Con %1.2 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_get_element : $@convention(thin) (Array<X>) -> @out X { |
| bb0(%io : $*X, %1 : $Array<X>): |
| %il = integer_literal $Builtin.Int32, 0 |
| %i = struct $Int32(%il : $Builtin.Int32) |
| %bl = integer_literal $Builtin.Int1, 0 |
| %b = struct $Bool (%bl : $Builtin.Int1) |
| |
| %f = function_ref @get_element : $@convention(method) (Int32, Bool, Bool, @guaranteed Array<X>) -> @out X |
| %a = apply %f(%io, %i, %b, %b, %1) : $@convention(method) (Int32, Bool, Bool, @guaranteed Array<X>) -> @out X |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_make_mutable |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_make_mutable : $@convention(thin) (@inout Array<X>) -> () { |
| bb0(%0 : $*Array<X>): |
| %f = function_ref @make_mutable : $@convention(method) (@inout Array<X>) -> () |
| %a = apply %f(%0) : $@convention(method) (@inout Array<X>) -> () |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_get_element_address |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: |
| // CHECK-NEXT: Val %4 Esc: , Succ: %0.1 |
| // CHECK-NEXT: End |
| sil @arraysemantics_get_element_address : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| %il = integer_literal $Builtin.Int32, 0 |
| %i = struct $Int32(%il : $Builtin.Int32) |
| |
| %f = function_ref @get_element_address : $@convention(method) (Int32, @guaranteed Array<X>) -> UnsafeMutablePointer<X> |
| %a = apply %f(%i, %0) : $@convention(method) (Int32, @guaranteed Array<X>) -> UnsafeMutablePointer<X> |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_get_count |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_get_count : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| |
| %f = function_ref @get_count : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| %a = apply %f(%0) : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_get_capacity |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_get_capacity : $@convention(thin) (Array<X>) -> () { |
| bb0(%0 : $Array<X>): |
| |
| %f = function_ref @get_capacity : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| %a = apply %f(%0) : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_withUnsafeMutableBufferPointer |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: A, Succ: (%0.3) |
| // CHECK-NEXT: Con %0.3 Esc: G, Succ: |
| // CHECK-NEXT: Arg %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %3 Esc: %4, Succ: |
| // CHECK-NEXT: End |
| sil @arraysemantics_withUnsafeMutableBufferPointer : $@convention(thin) (@inout Array<X>, @owned @callee_owned (@inout X) -> (@out (), @error Error)) -> () { |
| bb(%0 : $*Array<X>, %1 : $@callee_owned (@inout X) -> (@out (), @error Error)): |
| |
| %2 = function_ref @withUnsafeMutableBufferPointer : $@convention(method) (@owned @callee_owned (@inout X) -> (@out (), @error Error), @inout Array<X>) -> (@out (), @error Error) |
| %3 = alloc_stack $() |
| %4 = apply [nothrow] %2(%3, %1, %0) : $@convention(method) (@owned @callee_owned (@inout X) -> (@out (), @error Error), @inout Array<X>) -> (@out (), @error Error) |
| dealloc_stack %3 : $*() |
| |
| %r = tuple() |
| return %r : $() |
| } |
| |
| // CHECK-LABEL: CG of arraysemantics_createUninitialized |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Val %2 Esc: R, Succ: (%4.2) |
| // CHECK-NEXT: Val %4 Esc: R, Succ: (%4.1) |
| // CHECK-NEXT: Con %4.1 Esc: R, Succ: %2 |
| // CHECK-NEXT: Con %4.2 Esc: R, Succ: %0 |
| // CHECK-NEXT: Ret Esc: R, Succ: %4 |
| // CHECK-NEXT: End |
| sil @arraysemantics_createUninitialized : $@convention(thin) (@owned X) -> @owned Array<X> { |
| bb0(%0 : $X): |
| %1 = function_ref @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject |
| %2 = apply %1() : $@convention(thin) () -> @owned AnyObject |
| %3 = function_ref @createUninitialized : $@convention(method) (@owned AnyObject) -> (@owned Array<X>, UnsafeMutablePointer<X>) |
| %4 = apply %3(%2) : $@convention(method) (@owned AnyObject) -> (@owned Array<X>, UnsafeMutablePointer<X>) |
| %5 = tuple_extract %4 : $(Array<X>, UnsafeMutablePointer<X>), 0 |
| %6 = tuple_extract %4 : $(Array<X>, UnsafeMutablePointer<X>), 1 |
| %7 = struct_extract %6 : $UnsafeMutablePointer<X>, #UnsafeMutablePointer._rawValue |
| %8 = pointer_to_address %7 : $Builtin.RawPointer to $*X |
| store %0 to %8 : $*X |
| return %5 : $Array<X> |
| } |
| |
| sil [_semantics "array.withUnsafeMutableBufferPointer"] @withUnsafeMutableBufferPointer : $@convention(method) (@owned @callee_owned (@inout X) -> (@out (), @error Error), @inout Array<X>) -> (@out (), @error Error) |
| sil [_semantics "array.props.isNativeTypeChecked"] @is_native_type_checked : $@convention(method) (@guaranteed Array<X>) -> Bool |
| sil [_semantics "array.check_subscript"] @check_subscript : $@convention(method) (Int32, Bool, @guaranteed Array<X>) -> () |
| sil [_semantics "array.check_index"] @check_index : $@convention(method) (Int32, @guaranteed Array<X>) -> () |
| sil [_semantics "array.get_element"] @get_element : $@convention(method) (Int32, Bool, Bool, @guaranteed Array<X>) -> @out X |
| sil [_semantics "array.make_mutable"] @make_mutable : $@convention(method) (@inout Array<X>) -> () |
| sil [_semantics "array.get_element_address"] @get_element_address : $@convention(method) (Int32, @guaranteed Array<X>) -> UnsafeMutablePointer<X> |
| sil [_semantics "array.get_count"] @get_count : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| sil [_semantics "array.get_capacity"] @get_capacity : $@convention(method) (@guaranteed Array<X>) -> Int32 |
| |
| sil [_semantics "pair_no_escaping_closure"] @unsafeWithNotEscapedSelfPointerPair : $@convention(method) (@owned X, @owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| sil [_semantics "self_no_escaping_closure"] @unsafeWithNotEscapedSelfPointer: $@convention(method) (@owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| sil [_semantics "array.uninitialized"] @createUninitialized : $@convention(method) (@owned AnyObject) -> (@owned Array<X>, UnsafeMutablePointer<X>) |
| |
| // A simplified version of swift_bufferAllocate |
| sil @swift_bufferAllocate : $@convention(thin) () -> @owned AnyObject |
| |
| // CHECK-LABEL: CG of semantics_pair_no_escaping_closure |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Arg %1 Esc: A, Succ: |
| // CHECK-NEXT: Arg %2 Esc: G, Succ: (%2.1) |
| // CHECK-NEXT: Con %2.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %4 Esc: %5, Succ: |
| // CHECK-NEXT: End |
| sil @semantics_pair_no_escaping_closure : $@convention(thin) (@owned X, @guaranteed X, @owned @callee_owned (X, X) -> (@out X, @error Error)) -> () { |
| bb(%0 : $X, %1 : $X, %2: $@callee_owned (X, X) -> (@out X, @error Error)): |
| %3 = function_ref @unsafeWithNotEscapedSelfPointerPair : $@convention(method) (@owned X, @owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| %4 = alloc_stack $X |
| %6 = apply [nothrow] %3(%4, %0, %2, %1) : $@convention(method) (@owned X, @owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| dealloc_stack %4 : $*X |
| %7 = tuple() |
| return %7 : $() |
| } |
| |
| // CHECK-LABEL: CG of semantics_self_no_escaping_closure |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: Arg %1 Esc: G, Succ: (%1.1) |
| // CHECK-NEXT: Con %1.1 Esc: G, Succ: |
| // CHECK-NEXT: Val %3 Esc: %4, Succ: |
| // CHECK-NEXT: End |
| sil @semantics_self_no_escaping_closure : $@convention(thin) (@guaranteed X, @owned @callee_owned (X, X) -> (@out X, @error Error)) -> () { |
| bb(%0 : $X, %1: $@callee_owned (X, X) -> (@out X, @error Error)): |
| %2 = function_ref @unsafeWithNotEscapedSelfPointer : $@convention(method) (@owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| %3 = alloc_stack $X |
| %6 = apply [nothrow] %2(%3, %1, %0) : $@convention(method) (@owned @callee_owned (X, X) -> (@out X, @error Error), @guaranteed X) -> (@out X, @error Error) |
| dealloc_stack %3 : $*X |
| %7 = tuple() |
| return %7 : $() |
| } |
| |
| // CHECK-LABEL: CG of check_dealloc_ref |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @check_dealloc_ref : $@convention(thin) (@owned X) -> () { |
| bb0(%0 : $X): |
| dealloc_ref %0 : $X |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| // CHECK-LABEL: CG of check_set_deallocating |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @check_set_deallocating : $@convention(thin) (@owned X) -> () { |
| bb0(%0 : $X): |
| set_deallocating %0 : $X |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| // Escape analysis should analyze the implicit destructor call which may |
| // happen due to strong_release and figure out that the object will not |
| // globally escape. |
| // CHECK-LABEL: CG of check_non_escaping_implicit_destructor_invocation_via_strong_release |
| // CHECK-NEXT: Val %0 Esc: %1, Succ: |
| // CHECK-NEXT: End |
| sil @check_non_escaping_implicit_destructor_invocation_via_strong_release : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref [stack] $X |
| strong_release %0 : $X |
| dealloc_ref [stack] %0 : $X |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| // Escape analysis should analyze the implicit destructor call which may |
| // happen due to strong_release and figure out that the object will not |
| // globally escape. |
| // CHECK-LABEL: CG of check_non_escaping_implicit_destructor_invocation_via_release_value |
| // CHECK-NEXT: Val %0 Esc: %1, Succ: |
| // CHECK-NEXT: End |
| sil @check_non_escaping_implicit_destructor_invocation_via_release_value : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref [stack] $X |
| release_value %0 : $X |
| dealloc_ref [stack] %0 : $X |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| // Escape analysis should analyze the implicit destructor call which may |
| // happen due to strong_release and figure out that the object will |
| // globally escape. |
| // CHECK-LABEL: CG of check_escaping_implicit_destructor_invocation_via_strong_release |
| // CHECK-NEXT: Val %0 Esc: %1, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: %1, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @check_escaping_implicit_destructor_invocation_via_strong_release : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref [stack] $Z |
| strong_release %0 : $Z |
| dealloc_ref [stack] %0 : $Z |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| // Escape analysis should analyze the implicit destructor call which may |
| // happen due to strong_release and figure out that the object will |
| // globally escape. |
| // CHECK-LABEL: CG of check_escaping_implicit_destructor_invocation_via_release_value |
| // CHECK-NEXT: Val %0 Esc: %1, Succ: (%0.1) |
| // CHECK-NEXT: Con %0.1 Esc: %1, Succ: (%0.2) |
| // CHECK-NEXT: Con %0.2 Esc: G, Succ: |
| // CHECK-NEXT: End |
| sil @check_escaping_implicit_destructor_invocation_via_release_value : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref [stack] $Z |
| release_value %0 : $Z |
| dealloc_ref [stack] %0 : $Z |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| |
| // Check that escape analysis can look through bb arguments and figure |
| // out that all objects are local. By analyzing a destructor implicitly |
| // invoked by strong_release it would also determine that these objects |
| // do not escape from the function. |
| // CHECK-LABEL: CG of check_is_local_object_through_bb_args |
| // CHECK-LABEL: Val %2 Esc: %6,%7, Succ: |
| // CHECK-LABEL: Val %4 Esc: %6,%7, Succ: |
| // CHECK-LABEL: Val %6 Esc: %6,%7, Succ: %2, %4 |
| // CHECK-LABEL: End |
| sil @check_is_local_object_through_bb_args: $@convention(thin) (Builtin.Int1) -> () { |
| bb0(%0 : $Builtin.Int1): |
| cond_br %0, bb1, bb2 |
| |
| bb1: |
| %2 = alloc_ref $X |
| br bb3(%2 : $X) |
| |
| bb2: |
| %4 = alloc_ref $X |
| br bb3(%4 : $X) |
| |
| bb3(%6: $X): |
| strong_release %6 : $X |
| %8 = tuple () |
| return %8 : $() |
| } |
| |
| // CHECK-LABEL: CG of check_look_through_thin_to_thick |
| // CHECK-NEXT: Arg %0 Esc: A, Succ: |
| // CHECK-NEXT: End |
| sil @check_look_through_thin_to_thick: $(@convention(thin) () -> ()) -> () { |
| bb0(%0 : $@convention(thin) () -> ()): |
| %1 = thin_to_thick_function %0 : $@convention(thin) () -> () to $@callee_owned () -> () |
| %2 = apply %1() : $@callee_owned () -> () |
| %3 = tuple () |
| return %3 : $() |
| } |
| |
| // X.deinit |
| // CHECK-LABEL: CG of $s4main1XCfD |
| // CHECK: Arg %0 Esc: A, Succ: |
| // CHECKL: End |
| sil @$s4main1XCfD: $@convention(method) (@owned X) -> () { |
| bb0(%0 : $X): |
| fix_lifetime %0 : $X |
| %1 = tuple () |
| return %1 : $() |
| } |
| |
| // Z.deinit |
| // CHECK-LABEL: CG of $s4main1ZCfD |
| // CHECK: Arg %0 Esc: A, Succ: (%0.1) |
| // CHECK: Con %0.1 Esc: A, Succ: (%0.2) |
| // CHECK: Con %0.2 Esc: G, Succ: |
| // CHECK: Val %3 Esc: G, Succ: (%3.1) |
| // CHECK: Con %3.1 Esc: G, Succ: %0.2 |
| // CHECKL: End |
| sil @$s4main1ZCfD: $@convention(method) (@owned Z) -> () { |
| bb0(%0 : $Z): |
| %1 = ref_element_addr %0 : $Z, #Z.x |
| %2 = load %1 : $*X |
| %3 = global_addr @global_x : $*X |
| store %2 to %3 : $*X |
| %5 = tuple () |
| return %5 : $() |
| } |
| |
| sil_vtable X { |
| #X.deinit!deallocator.1: @$s4main1XCfD |
| } |
| |
| sil_vtable Z { |
| #Z.deinit!deallocator.1: @$s4main1ZCfD |
| } |
| |
| |
| sil public_external @public_external_func : $@convention(thin) (@owned X) -> () { |
| bb0(%0 : $X): |
| strong_release %0 : $X |
| %5 = tuple () |
| return %5 : $() |
| } |
| |
| // CHECK-LABEL: CG of call_public_external_func |
| // CHECK: Val %0 Esc: G, Succ: (%0.1) |
| // CHECK: Con %0.1 Esc: G, Succ: |
| // CHECKL: End |
| sil @call_public_external_func : $@convention(thin) () -> () { |
| bb0: |
| %0 = alloc_ref $X |
| %1 = function_ref @public_external_func : $@convention(thin) (@owned X) -> () |
| %2 = apply %1(%0) : $@convention(thin) (@owned X) -> () |
| %7 = tuple () |
| return %7 : $() |
| } |
| |
