| // RUN: %target-sil-opt -sil-inline-generics -enable-sil-verify-all -inline -function-signature-opts %s | %FileCheck %s |
| |
| import Builtin |
| import Swift |
| |
| // ==========================================================================={{ |
| // ============================================================================= |
| // ===== SUPPORT ===== |
| // ============================================================================= |
| // ============================================================================= |
| |
| class Klass { |
| var value : Builtin.Int2048 |
| } |
| |
| struct Wrapper { |
| var klass: Klass |
| var int: Int |
| } |
| |
| struct Pair { |
| var klass1: Klass |
| var klass2: Klass |
| } |
| |
| struct Quintuple { |
| var klass1: Klass |
| var klass2: Klass |
| var klass3: Klass |
| var klass4: Klass |
| var klass5: Klass |
| } |
| |
| sil @take_nothing : $@convention(thin) () -> () |
| sil @take_klass : $@convention(thin) (Klass) -> () |
| sil @take_klass_and_klass : $@convention(thin) (Klass, Klass) -> () |
| sil @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| sil @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| sil @take_int : $@convention(thin) (Int) -> () |
| |
| // ============================================================================= |
| // ============================================================================= |
| // ===== SUPPORT ===== |
| // ============================================================================= |
| // ===========================================================================}} |
| |
| |
| |
| // ==========================================================================={{ |
| // ============================================================================= |
| // ===== TESTS ===== |
| // ============================================================================= |
| // ============================================================================= |
| |
| |
| |
| // ==========================================================================={{ |
| // = WRAPPER = |
| // ============================================================================= |
| |
| // struct Wrapper { |
| // var klass: Klass |
| // var int: Int |
| // } |
| |
| // = Wrapper, #Wrapper.klass ================================================={{ |
| |
| |
| |
| // TEST_WrKlPu: TYPE: Wrapper, FIELD: #Wrapper.klass, VISIBILITY: public |
| // VERIFY: NO-EXPLODE |
| // The function take_wrapper has a single argument of type Wrapper from which |
| // it uses only the klass field. The int field goes unused. Argument explosion |
| // should *not* result in a specialization in this case because (1) the |
| // function could be used outside this module (so a thunk would be generated if |
| // we specialized) and (2) specializing does not reduce ARC traffic because the |
| // stripped field is trivial. |
| // |
| // CHECK-LABEL: sil [noinline] @take_wrapper : $@convention(thin) (Wrapper) -> () { |
| // CHECK: [[KLASS:%.*]] = struct_extract {{%.*}} : $Wrapper, #Wrapper.klass |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper' |
| // CHECK-NOT: sil shared [noinline] @$s12take_wrapperTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK-NOT: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK-NOT: [[RESULT:%.*]] = apply [[FUNCTION]](%0) |
| // CHECK-NOT: return [[RESULT]] : $() |
| // CHECK-NOT: } // end sil function '$s12take_wrapperTf4x_n' |
| sil public [noinline] @take_wrapper : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %klass = struct_extract %wrapper : $Wrapper, #Wrapper.klass |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper' |
| |
| // CHECK-LABEL: sil @take_wrapper_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_wrapper |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[WRAPPER]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_caller' |
| sil @take_wrapper_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_caller' |
| |
| |
| |
| // TEST_WrKlPuEx: TYPE: Wrapper, FIELD: #Wrapper.klass, VISIBILITY: public_external |
| // VERIFY: NO-EXPLODE |
| // The function take_wrapper has a single argument of type Wrapper from which |
| // it uses only the klass field. The int field goes unused. Argument explosion |
| // should *not* result in a specialization in this case because (1) the |
| // function is definend outside this module (so a thunk would be generated if |
| // we specialized) and (2) specializing does not reduce ARC traffic because the |
| // stripped field is trivial. |
| // |
| // CHECK-LABEL: sil public_external [noinline] @take_wrapper_public_external : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_wrapper_public_external' |
| sil public_external [noinline] @take_wrapper_public_external : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %klass = struct_extract %wrapper : $Wrapper, #Wrapper.klass |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_public_external' |
| |
| // CHECK-LABEL: sil @take_wrapper_public_external_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_wrapper_public_external |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[WRAPPER]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_wrapper_public_external_caller' |
| sil @take_wrapper_public_external_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_public_external : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_public_external_caller' |
| |
| |
| |
| // TEST_WrKlSh: TYPE: Wrapper, FIELD: #Wrapper.klass, VISIBILITY: shared |
| // VERIFY: EXPLODE: (Wrapper) => (#Wrapper.klass) |
| // The function take_wrapper_shared has a single argument of type Wrapper from |
| // which it uses only the klass field. The int field goes unused. Argument |
| // explosion should result in a specialization in this case because because |
| // there are dead leaves of the relevant sort, the relevant sort here being |
| // potentially trivial because specializing the function will not result in a |
| // thunk. |
| // |
| // CHECK-LABEL: sil shared [signature_optimized_thunk] [always_inline] @take_wrapper_shared : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s19take_wrapper_sharedTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_shared' |
| sil shared [noinline] @take_wrapper_shared : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %klass = struct_extract %wrapper : $Wrapper, #Wrapper.klass |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_shared' |
| |
| // CHECK-LABEL: sil @take_wrapper_shared_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s19take_wrapper_sharedTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_shared_caller' |
| sil @take_wrapper_shared_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_shared : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_shared_caller' |
| |
| |
| |
| // TEST_WrKlHi: TYPE: Wrapper, FIELD: #Wrapper.klass, VISIBILITY: hidden |
| // VERIFY: NO-EXPLODE |
| // The function take_wrapper_hidden has a single argument of type Wrapper from |
| // which it uses only the klass field. The int field goes unused. Argument |
| // explosion should *not* result in a specialization in this case because, while |
| // all the non-trivial leaves are live, there is only a single non-trivial |
| // leaf, so there will be no downstream benefits from introducing a separate RC |
| // identities for each leaf. |
| // |
| // CHECK-LABEL: sil hidden [noinline] @take_wrapper_hidden : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_hidden' |
| sil hidden [noinline] @take_wrapper_hidden : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %klass = struct_extract %wrapper : $Wrapper, #Wrapper.klass |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_hidden' |
| |
| // CHECK-LABEL: sil @take_wrapper_hidden_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_wrapper_hidden |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[WRAPPER]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_hidden_caller' |
| sil @take_wrapper_hidden_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_hidden : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil funcntion 'take_wrapper_hidden_caller' |
| |
| |
| |
| // TEST_WrKlPr: TYPE: Wrapper, FIELD: #Wrapper.klass, VISIBILITY: private |
| // VERIFY: EXPLODE: (Wrapper) => (#Wrapper.klass) |
| // The function take_wrapper_private has a single argument of type Wrapper from |
| // which it uses only the klass field. The int field goes unused. Argument |
| // explosion should result in a specialization in this case because, there are |
| // dead leaves of the relevant sort, that being potentially trivial because |
| // specializing the function will not result in a thunk. |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_wrapper_private : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_wrapper_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_private' |
| sil private [noinline] @take_wrapper_private : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %klass = struct_extract %wrapper : $Wrapper, #Wrapper.klass |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_private' |
| |
| // CHECK-LABEL: sil @take_wrapper_private_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_wrapper_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_private_caller' |
| sil @take_wrapper_private_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_private : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_private_caller' |
| |
| |
| |
| // = END: Wrapper, #Wrapper.klass ============================================}} |
| |
| |
| |
| // = Wrapper, #Wrapper.int ==================================================={{ |
| |
| |
| |
| // TEST_WrInPu: TYPE: Wrapper, FIELD: #Wrapper.int, VISIBILITY: public |
| // VERIFY: EXPLODE (Wrapper) => (#Wrapper.int) |
| // The function take_wrapper_for_int has a single argument of type Wrapper from |
| // which it only uses the int field. The klass field goes unused. Without |
| // changes there would be needless ARC traffic around the klass field. So, |
| // argument explosion *should* result in a specialization in this case. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_wrapper_for_int : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_wrapper_for_intTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_for_int' |
| sil public [noinline] @take_wrapper_for_int : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %int = struct_extract %wrapper : $Wrapper, #Wrapper.int |
| %func = function_ref @take_int : $@convention(thin) (Int) -> () |
| %result = apply %func(%int) : $@convention(thin) (Int) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int' |
| |
| // CHECK-LABEL: sil @take_wrapper_for_int_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_wrapper_for_intTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_for_int_caller' |
| sil @take_wrapper_for_int_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_for_int : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_caller' |
| |
| |
| |
| // TEST_WrInPuEx: TYPE: Wrapper, FIELD: #Wrapper.int, VISIBILITY: public_external |
| // VERIFY: EXPLODE (Wrapper) => (#Wrapper.int) |
| // The function take_wrapper_for_int has a single argument of type Wrapper from |
| // which it only uses the int field. The klass field goes unused. Without |
| // changes there would be needless ARC traffic around the klass field. So, |
| // argument explosion *should* result in a specialization in this case. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_wrapper_for_int_public_external : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_wrapper_for_int_public_externalTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_for_int_public_external' |
| sil public_external [noinline] @take_wrapper_for_int_public_external : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %int = struct_extract %wrapper : $Wrapper, #Wrapper.int |
| %func = function_ref @take_int : $@convention(thin) (Int) -> () |
| %result = apply %func(%int) : $@convention(thin) (Int) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_public_external' |
| |
| // CHECK-LABEL: sil @take_wrapper_for_int_public_external_caller : $@convention(thin) (Wrapper) -> () { |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_wrapper_for_int_public_externalTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_wrapper_for_int_public_external_caller' |
| sil @take_wrapper_for_int_public_external_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_for_int_public_external : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_public_external_caller' |
| |
| |
| |
| // TEST_WrInHi: TYPE: Wrapper, FIELD: #Wrapper.int, VISIBILITY: hidden |
| // VERIFY: EXPLODE (Wrapper) => (#Wrapper.int) |
| // The function take_wrapper_for_int_hidden has a single argument of type |
| // Wrapper from which it only uses the int field. The klass field goes unused. |
| // Without changes there would be needless ARC traffic around the klass field. |
| // So, argument explosion *should* result in a specialization in this case. |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_wrapper_for_int_hidden |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_wrapper_for_int_hiddenTf4x_n : $@convention(thin) (Int) -> () |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: // end sil function 'take_wrapper_for_int_hidden' |
| sil hidden [noinline] @take_wrapper_for_int_hidden : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %int = struct_extract %wrapper : $Wrapper, #Wrapper.int |
| %func = function_ref @take_int : $@convention(thin) (Int) -> () |
| %result = apply %func(%int) : $@convention(thin) (Int) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_hidden' |
| |
| // CHECK-LABEL: sil @take_wrapper_for_int_hidden_caller |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_wrapper_for_int_hiddenTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: // end sil function 'take_wrapper_for_int_hidden_caller' |
| sil @take_wrapper_for_int_hidden_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_for_int_hidden : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_hidden_caller' |
| |
| |
| |
| // TEST_WrInPr: TYPE: Wrapper, FIELD: #Wrapper.int, VISIBILITY: private |
| // VERIFY: EXPLODE (Wrapper) => (#Wrapper.int) |
| // The function take_wrapper_for_int_private has a single argument of type |
| // Wrapper from which it only uses the int field. The klass field goes unused. |
| // Without changes there would be needless ARC traffic around the klass field. |
| // So, argument explosion *should* result in a specialization in this case. |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_wrapper_for_int_private |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_wrapper_for_int_privateTf4x_n : $@convention(thin) (Int) -> () |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: // end sil function 'take_wrapper_for_int_private' |
| sil private [noinline] @take_wrapper_for_int_private : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %int = struct_extract %wrapper : $Wrapper, #Wrapper.int |
| %func = function_ref @take_int : $@convention(thin) (Int) -> () |
| %result = apply %func(%int) : $@convention(thin) (Int) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_private' |
| |
| // CHECK-LABEL: sil @take_wrapper_for_int_private_caller |
| // CHECK: bb{{[0-9]*}}([[WRAPPER:%.*]] : $Wrapper) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_wrapper_for_int_privateTf4x_n |
| // CHECK: [[INT:%.*]] = struct_extract [[WRAPPER]] : $Wrapper, #Wrapper.int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: // end sil function 'take_wrapper_for_int_private_caller' |
| sil @take_wrapper_for_int_private_caller : $@convention(thin) (Wrapper) -> () { |
| only(%wrapper : $Wrapper): |
| %func = function_ref @take_wrapper_for_int_private : $@convention(thin) (Wrapper) -> () |
| %result = apply %func(%wrapper) : $@convention(thin) (Wrapper) -> () |
| return %result : $() |
| } // end sil function 'take_wrapper_for_int_private_caller' |
| |
| |
| |
| // = END: Wrapper, #Wrapper.int ==============================================}} |
| |
| |
| |
| // ===========================================================================}} |
| // = END: WRAPPER = |
| // ============================================================================= |
| |
| |
| |
| // ==========================================================================={{ |
| // = PAIR = |
| // ============================================================================= |
| |
| // struct Pair { |
| // var klass1: Klass |
| // var klass2: Klass |
| // } |
| |
| // = Pair, No fields ========================================================={{ |
| |
| |
| |
| // TEST_PaPu: TYPE: Pair, FIELD: , VISIBILITY: public |
| // VERIFY: EXPLODE (Pair) => () |
| // The function take_pair_unused has a single argument of type Pair from which |
| // it uses no fields. Both the klass1 and klass2 fields go unused. Argument |
| // explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // fields are non-trivial. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_pair_unused : $@convention(thin) (Pair) -> () |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s16take_pair_unusedTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: // end sil function 'take_pair_unused' |
| sil public [noinline] @take_pair_unused : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_nothing : $@convention(thin) () -> () |
| %result = apply %func() : $@convention(thin) () -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused' |
| |
| // CHECK-LABEL: sil @take_pair_unused_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s16take_pair_unusedTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_caller' |
| sil @take_pair_unused_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_unused : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused_caller' |
| |
| |
| |
| // TEST_PaPuEx: TYPE: Pair, FIELD: , VISIBILITY: public_external |
| // VERIFY: EXPLODE (Pair) => () |
| // The function take_pair_unused has a single argument of type Pair from which |
| // it uses no fields. Both the klass1 and klass2 fields go unused. Argument |
| // explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // fields are non-trivial. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_pair_unused_public_external : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s32take_pair_unused_public_externalTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_public_external' |
| sil public_external [noinline] @take_pair_unused_public_external : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_nothing : $@convention(thin) () -> () |
| %result = apply %func() : $@convention(thin) () -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused_public_external' |
| |
| // CHECK-LABEL: sil @take_pair_unused_public_external_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s32take_pair_unused_public_externalTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_public_external_caller' |
| sil @take_pair_unused_public_external_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_unused_public_external : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused_public_external_caller' |
| |
| |
| |
| // TEST_PaHi: TYPE: Pair, FIELD: , VISIBILITY: hidden |
| // VERIFY: EXPLODE: (Pair) => () |
| // The function take_pair_unused_hidden has a single argument of type Pair from |
| // which it uses no fields. Both the klass1 and klass2 fields go unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // fields are non-trivial. |
| // |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_pair_unused_hidden : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s23take_pair_unused_hiddenTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_hidden' |
| sil hidden [noinline] @take_pair_unused_hidden : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_nothing : $@convention(thin) () -> () |
| %result = apply %func() : $@convention(thin) () -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused_hidden' |
| |
| // CHECK-LABEL: sil @take_pair_unused_hidden_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s23take_pair_unused_hiddenTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_hidden_caller' |
| sil @take_pair_unused_hidden_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_unused_hidden : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_unused_hidden_caller' |
| |
| |
| |
| // TEST_PaPr: TYPE: Pair, FIELD: , VISIBILITY: private |
| // VERIFY: EXPLODE: (Pair) => () |
| // The function take_pair_unused_private has a single argument of type Pair from |
| // which it uses no fields. Both the klass1 and klass2 fields go unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // fields are non-trivial. |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_pair_unused_private : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s24take_pair_unused_privateTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_private' |
| sil private [noinline] @take_pair_unused_private : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_nothing : $@convention(thin) () -> () |
| %result = apply %func() : $@convention(thin) () -> () |
| return %result : $() |
| } // end sil function 'take_pair_unused_private' |
| |
| // CHECK-LABEL: sil @take_pair_unused_private_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s24take_pair_unused_privateTf4d_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_unused_private_caller' |
| sil @take_pair_unused_private_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_unused_private : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_unused_private_caller' |
| |
| |
| |
| // = END: Pair, No fields ====================================================}} |
| |
| |
| |
| // = Pair, #Pair.klass1 ======================================================{{ |
| |
| |
| |
| // TEST_PaK1Pu: TYPE: Pair, FIELD: #Pair.klass1, VISIBILITY: public |
| // VERIFY: EXPLODE (Pair) => (#Pair.klass1) |
| // The function take_pair_for_klass1 has a single argument of type Pair |
| // from which it uses only the klass1 field. The klass2 field goes unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // field is non-trivial. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_pair_for_klass1 : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_pair_for_klass1Tf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1' |
| sil public [noinline] @take_pair_for_klass1 : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass1 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_pair_for_klass1Tf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract {{%.*}} : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_caller' |
| sil @take_pair_for_klass1_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1 : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_caller' |
| |
| |
| |
| // TEST_PaK1PuEx: TYPE: Pair, FIELD: #Pair.klass1, VISIBILITY: public_external |
| // VERIFY: EXPLODE (Pair) => (#Pair.klass1) |
| // The function take_pair_for_klass1 has a single argument of type Pair |
| // from which it uses only the klass1 field. The klass2 field goes unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // field is non-trivial. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_pair_for_klass1_public_external : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_pair_for_klass1_public_externalTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_public_external' |
| sil public_external [noinline] @take_pair_for_klass1_public_external : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass1 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_public_external' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_public_external_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_pair_for_klass1_public_externalTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_public_external_caller' |
| sil @take_pair_for_klass1_public_external_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_public_external : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_public_external_caller' |
| |
| |
| |
| // TEST_PaK1Hi: TYPE: Pair, FIELD: #Pair.klass1, VISIBILITY: hidden |
| // VERIFY: EXPLODE: (Pair) => (#Pair.klass1) |
| // The function take_pair_for_klass1_hidden has a single argument of type Pair from |
| // which it uses only the klass1 field. The klass2 field goes unused. Argument |
| // explosion should result in a specialization in this case both because (1) the |
| // function can *not* be used outside this module (so no thunk |
| // will remain after dead code elimination) because it is hidden and because (2) |
| // avoiding passing the full Pair with its unused field klass2 avoids extraneous |
| // ARC traffic around that field (i.e. #Pair.klass2). |
| // |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_pair_for_klass1_hidden : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_pair_for_klass1_hiddenTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_hidden' |
| sil hidden [noinline] @take_pair_for_klass1_hidden : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass1 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_hidden' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_hidden_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_pair_for_klass1_hiddenTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_hidden_caller' |
| sil @take_pair_for_klass1_hidden_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_hidden : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass1_hidden_caller' |
| |
| |
| |
| // TEST_PaK1Pr: TYPE: Pair, FIELD: #Pair.klass1, VISIBILITY: private |
| // VERIFY: EXPLODE: (Pair) => (#Pair.klass1) |
| // The function take_pair_for_klass1_private has a single argument of type Pair from |
| // which it uses only the klass1 field. The klass2 field goes unused. Argument |
| // explosion should result in a specialization in this case both because (1) the |
| // function can *not* be used outside this module (so no thunk |
| // will remain after dead code elimination) because it is private and because |
| // (2) avoiding passing the full Pair with its unused field klass2 avoids |
| // extraneous ARC traffic around that field (i.e. #Pair.klass2). |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_pair_for_klass1_private : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_pair_for_klass1_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_private' |
| sil private [noinline] @take_pair_for_klass1_private : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass1 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_private' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_private_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_pair_for_klass1_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_private_caller' |
| sil @take_pair_for_klass1_private_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_private : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass1_private_caller' |
| |
| |
| |
| // = END: Pair, #Pair.klass1 =================================================}} |
| |
| |
| |
| // = Pair, #Pair.klass2 ======================================================{{ |
| |
| |
| |
| // TEST_PaK2Pu: TYPE: Pair, FIELD: #Pair.klass2, VISIBILITY: public |
| // VERIFY: EXPLODE (Pair) => (#Pair.klass2) |
| // The function take_pair_for_klass2 has a single argument of type Pair |
| // from which it uses only the klass2 field. The klass1 field goes unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // field is non-trivial. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_pair_for_klass2 : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_pair_for_klass2Tf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2' |
| sil public [noinline] @take_pair_for_klass2 : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass2_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s20take_pair_for_klass2Tf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract {{%.*}} : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_caller' |
| sil @take_pair_for_klass2_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass2 : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2_caller' |
| |
| |
| |
| // TEST_PaK2PuEx: TYPE: Pair, FIELD: #Pair.klass2, VISIBILITY: public_external |
| // VERIFY: EXPLODE (Pair) => (#Pair.klass2) |
| // The function take_pair_for_klass2 has a single argument of type Pair |
| // from which it uses only the klass2 field. The klass1 field goes unused. |
| // Argument explosion *should* result in a specialization in this case because |
| // specializing reduces ARC traffic on account of the fact that the stripped |
| // field is non-trivial. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_pair_for_klass2_public_external : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_pair_for_klass2_public_externalTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_public_external' |
| sil public_external [noinline] @take_pair_for_klass2_public_external : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2_public_external' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass2_public_external_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s36take_pair_for_klass2_public_externalTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_public_external_caller' |
| sil @take_pair_for_klass2_public_external_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass2_public_external : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2_public_external_caller' |
| |
| |
| |
| // TEST_PaK2Hi: TYPE: Pair, FIELD: #Pair.klass2, VISIBILITY: hidden |
| // VERIFY: EXPLODE: (Pair) => (#Pair.klass2) |
| // The function take_pair_for_klass2_hidden has a single argument of type Pair from |
| // which it uses only the klass2 field. The klass1 field goes unused. Argument |
| // explosion should result in a specialization in this case both because (1) the |
| // function can *not* be used outside this module (so no thunk |
| // will remain after dead code elimination) because it is hidden and because (2) |
| // avoiding passing the full Pair with its unused field klass1 avoids extraneous |
| // ARC traffic around that field (i.e. #Pair.klass1). |
| // |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_pair_for_klass2_hidden : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_pair_for_klass2_hiddenTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_hidden' |
| sil hidden [noinline] @take_pair_for_klass2_hidden : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2_hidden' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass2_hidden_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s27take_pair_for_klass2_hiddenTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_hidden_caller' |
| sil @take_pair_for_klass2_hidden_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass2_hidden : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass2_hidden_caller' |
| |
| |
| |
| // TEST_PaK2Pr: TYPE: Pair, FIELD: #Pair.klass2, VISIBILITY: private |
| // VERIFY: EXPLODE: (Pair) => (#Pair.klass2) |
| // The function take_pair_for_klass2_private has a single argument of type Pair from |
| // which it uses only the klass2 field. The klass1 field goes unused. Argument |
| // explosion should result in a specialization in this case both because (1) the |
| // function can *not* be used outside this module (so no thunk |
| // will remain after dead code elimination) because it is private and because |
| // (2) avoiding passing the full Pair with its unused field klass1 avoids |
| // extraneous ARC traffic around that field (i.e. #Pair.klass1). |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_pair_for_klass2_private : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_pair_for_klass2_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_private' |
| sil private [noinline] @take_pair_for_klass2_private : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| %result = apply %func(%klass) : $@convention(thin) (Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass2_private' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass2_private_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s28take_pair_for_klass2_privateTf4x_n |
| // CHECK: [[KLASS:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass2_private_caller' |
| sil @take_pair_for_klass2_private_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass2_private : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass2_private_caller' |
| |
| |
| |
| // = END: Pair, #Pair.klass2 =================================================}} |
| |
| |
| |
| // = Pair, #Pair.klass1, #Pair.klass2 ========================================{{ |
| |
| |
| |
| // TEST_PaK1K2Pu: TYPE: Pair, FIELD: #Pair.klass1 & #Pair.klass2, VISIBILITY: public |
| // VERIFY: NO-EXPLODE |
| // The function take_pair_for_klass1_and_klass2 has a single argument of type |
| // Pair from which it uses both the klass1 and klass2 fields. Argument |
| // explosion should *not* result in a specialization in this case because (1) |
| // specializing does not affect ARC traffic on account of the fact that no |
| // fields are stripped and (2) specializing increases code size. |
| // |
| // CHECK-LABEL: sil [noinline] @take_pair_for_klass1_and_klass2 : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_and_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2' |
| sil public [noinline] @take_pair_for_klass1_and_klass2 : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass1 = struct_extract %pair : $Pair, #Pair.klass1 |
| %klass2 = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass_and_klass : $@convention(thin) (Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2) : $@convention(thin) (Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_and_klass2_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_pair_for_klass1_and_klass2 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[PAIR]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_caller' |
| sil @take_pair_for_klass1_and_klass2_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_and_klass2 : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2_caller' |
| |
| |
| |
| // TEST_PaK1K2PuEx: TYPE: Pair, FIELD: #Pair.klass1 & #Pair.klass2, VISIBILITY: public_external |
| // VERIFY: NO-EXPLODE |
| // The function take_pair_for_klass1_and_klass2 has a single argument of type |
| // Pair from which it uses both the klass1 and klass2 fields. Argument |
| // explosion should *not* result in a specialization in this case because (1) |
| // specializing does not affect ARC traffic on account of the fact that no |
| // fields are stripped and (2) specializing increases code size. |
| // |
| // CHECK-LABEL: sil public_external [noinline] @take_pair_for_klass1_and_klass2_public_external : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_public_external' |
| sil public_external [noinline] @take_pair_for_klass1_and_klass2_public_external : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass1 = struct_extract %pair : $Pair, #Pair.klass1 |
| %klass2 = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass_and_klass : $@convention(thin) (Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2) : $@convention(thin) (Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2_public_external' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_and_klass2_public_external_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_pair_for_klass1_and_klass2_public_external |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[PAIR]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_public_external_caller' |
| sil @take_pair_for_klass1_and_klass2_public_external_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_and_klass2_public_external : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2_public_external_caller' |
| |
| |
| |
| // TEST_PaK1K2Hi: TYPE: Pair, FIELD: #Pair.klass1 & #Pair.klass2, VISIBILITY: hidden |
| // VERIFY: NO-EXPLODE |
| // The function take_pair_for_klass1_and_klass2_hidden has a single argument of |
| // type Pair from which it uses both the klass1 and klass2 fields. Argument |
| // explosion should *not* result in a specialization in this case because there |
| // are no dead leaves. |
| // |
| // CHECK-LABEL: sil hidden [noinline] @take_pair_for_klass1_and_klass2_hidden : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_and_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_hidden' |
| sil hidden [noinline] @take_pair_for_klass1_and_klass2_hidden : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass1 = struct_extract %pair : $Pair, #Pair.klass1 |
| %klass2 = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass_and_klass : $@convention(thin) (Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2) : $@convention(thin) (Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2_hidden' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_and_klass2_hidden_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_pair_for_klass1_and_klass2_hidden |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[PAIR]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_hidden_caller' |
| sil @take_pair_for_klass1_and_klass2_hidden_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_and_klass2_hidden : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass1_and_klass2_hidden_caller' |
| |
| |
| |
| // TEST_PaK1K2Pr: TYPE: Pair, FIELD: #Pair.klass1 & #Pair.klass2, VISIBILITY: private |
| // VERIFY: NO-EXPLODE |
| // The function take_pair_for_klass1_and_klass2_private has a single argument of |
| // type Pair from which it uses both the klass1 and klass2 fields. Argument |
| // explosion should *not* result in a specialization in this case because there |
| // are no dead leaves. |
| // |
| // CHECK-LABEL: sil private [noinline] @take_pair_for_klass1_and_klass2_private : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair): |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[PAIR]] : $Pair, #Pair.klass2 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_and_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_private' |
| sil private [noinline] @take_pair_for_klass1_and_klass2_private : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %klass1 = struct_extract %pair : $Pair, #Pair.klass1 |
| %klass2 = struct_extract %pair : $Pair, #Pair.klass2 |
| %func = function_ref @take_klass_and_klass : $@convention(thin) (Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2) : $@convention(thin) (Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_pair_for_klass1_and_klass2_private' |
| |
| // CHECK-LABEL: sil @take_pair_for_klass1_and_klass2_private_caller : $@convention(thin) (Pair) -> () { |
| // CHECK: bb{{[0-9]*}}([[PAIR:%.*]] : $Pair) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_pair_for_klass1_and_klass2_private |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[PAIR]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_pair_for_klass1_and_klass2_private_caller' |
| sil @take_pair_for_klass1_and_klass2_private_caller : $@convention(thin) (Pair) -> () { |
| only(%pair : $Pair): |
| %func = function_ref @take_pair_for_klass1_and_klass2_private : $@convention(thin) (Pair) -> () |
| %result = apply %func(%pair) : $@convention(thin) (Pair) -> () |
| return %result : $() |
| } // end sil funcntion 'take_pair_for_klass1_and_klass2_private_caller' |
| |
| |
| |
| // = END: Pair, #Pair.klass1, #Pair.klass2 ===================================}} |
| |
| |
| |
| // ===========================================================================}} |
| // = END: PAIR = |
| // ============================================================================= |
| |
| |
| |
| // ==========================================================================={{ |
| // = QUINTUPLE = |
| // ============================================================================= |
| |
| |
| |
| // = Quintuple, #.klass1, #.klass2, #.klass3 ================================={{ |
| |
| |
| |
| // TEST_QuK1K2K3Pu: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3, VISIBILITY: public |
| // VERIFY: EXPLODE: (Quintuple) => (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klass3) |
| // The function take_quintuple_for_klass1_through_3 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, and klass3 fields. |
| // The klass4 and klass5 fields goes unused. Argument explosion *should* |
| // result in specialization because there are only three (the heuristic for max |
| // explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3 : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s35take_quintuple_for_klass1_through_3Tf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3' |
| sil public [noinline] @take_quintuple_for_klass1_through_3 : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_3_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s35take_quintuple_for_klass1_through_3Tf4x_n |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_caller' |
| sil @take_quintuple_for_klass1_through_3_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3 : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_caller' |
| |
| // TEST_QuK1K2K3PuEx: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3, VISIBILITY: public_external |
| // VERIFY: EXPLODE: (Quintuple) => (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klass3) |
| // The function take_quintuple_for_klass1_through_3 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, and klass3 fields. |
| // The klass4 and klass5 fields goes unused. Argument explosion *should* |
| // result in specialization because there are only three (the heuristic for max |
| // explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_public_external : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s51take_quintuple_for_klass1_through_3_public_externalTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_public_external' |
| sil public_external [noinline] @take_quintuple_for_klass1_through_3_public_external : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_public_external' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_3_public_external_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s51take_quintuple_for_klass1_through_3_public_externalTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_public_external_caller' |
| sil @take_quintuple_for_klass1_through_3_public_external_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_public_external : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_public_external_caller' |
| |
| // TEST_QuK1K2K3Sh: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3, VISIBILITY: shared |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_3 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, and klass3 fields. |
| // The klass4 and klass5 fields goes unused. Argument explosion *should* |
| // result in specialization because there are only three (the heuristic for max |
| // explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil shared [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_shared : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_3_sharedTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_shared' |
| sil shared [noinline] @take_quintuple_for_klass1_through_3_shared : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_shared' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_3_shared_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_3_sharedTf4x_n |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_shared_caller' |
| sil @take_quintuple_for_klass1_through_3_shared_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_shared : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_shared_caller' |
| |
| // TEST_QuK1K2K3Hi: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3, VISIBILITY: hidden |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_3 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, and klass3 fields. |
| // The klass4 and klass5 fields goes unused. Argument explosion *should* |
| // result in specialization because there are only three (the heuristic for max |
| // explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_hidden : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_3_hiddenTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_hidden' |
| sil hidden [noinline] @take_quintuple_for_klass1_through_3_hidden : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_hidden' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_3_hidden_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_3_hiddenTf4x_n |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_hidden_caller' |
| sil @take_quintuple_for_klass1_through_3_hidden_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_hidden : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_hidden_caller' |
| |
| // TEST_QuK1K2K3Pr: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3, VISIBILITY: private |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_3 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, and klass3 fields. |
| // The klass4 and klass5 fields goes unused. Argument explosion *should* |
| // result in specialization because there are only three (the heuristic for max |
| // explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_private : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s43take_quintuple_for_klass1_through_3_privateTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_private' |
| sil private [noinline] @take_quintuple_for_klass1_through_3_private : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_private' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_3_private_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s43take_quintuple_for_klass1_through_3_privateTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_private_caller' |
| sil @take_quintuple_for_klass1_through_3_private_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_private : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_private_caller' |
| |
| |
| |
| // = END: Quintuple, #.klass1, #.klass2, #.klass3 ============================}} |
| |
| |
| |
| // = Quintuple, #.klass1, #.klass2, #.klass3, #.klass4 ======================={{ |
| |
| |
| |
| // TEST_QuK1K2K3K4Pu: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & #.klass4, VISIBILITY: public |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_4 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, klass3, and klass4 |
| // fields. The klass5 field goes unused. Argument explosion should *not* |
| // result in specialization because there are more than three (the heuristic |
| // for max explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_4 : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4' |
| sil public [noinline] @take_quintuple_for_klass1_through_4 : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %func = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3, %klass4) : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_4_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_quintuple_for_klass1_through_4 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[QUINTUPLE]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_caller' |
| sil @take_quintuple_for_klass1_through_4_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_4 : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_caller' |
| |
| // TEST_QuK1K2K3K4PuEx: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & #.klass4, VISIBILITY: public_external |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_4 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, klass3, and klass4 |
| // fields. The klass5 field goes unused. Argument explosion should *not* |
| // result in specialization because there are more than three (the heuristic |
| // for max explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil public_external [noinline] @take_quintuple_for_klass1_through_4_public_external : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_public_external' |
| sil public_external [noinline] @take_quintuple_for_klass1_through_4_public_external : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %func = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3, %klass4) : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_public_external' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_4_public_external_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_quintuple_for_klass1_through_4_public_external |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[QUINTUPLE]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_public_external_caller' |
| sil @take_quintuple_for_klass1_through_4_public_external_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_4_public_external : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_public_external_caller' |
| |
| // TEST_QuK1K2K3K4Sh: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & #.klass4, VISIBILITY: shared |
| // VERIFY: EXPLODE (Quintuple) => (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klass3, #Quintuple.klass4) |
| // The function take_quintuple_for_klass1_through_4 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, klass3, and klass4 |
| // fields. The klass5 field goes unused. Argument explosion *should* |
| // result in specialization because there are dead leaves and there are fewer |
| // live than the limit imposed by the heuristic, six because the specializing |
| // the function will not result in a thunk. |
| // |
| // CHECK-LABEL: sil shared [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_4_shared : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_4_sharedTf4x_n : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_shared' |
| sil shared [noinline] @take_quintuple_for_klass1_through_4_shared : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %func = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3, %klass4) : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_shared' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_4_shared_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s42take_quintuple_for_klass1_through_4_sharedTf4x_n : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_shared_caller' |
| sil @take_quintuple_for_klass1_through_4_shared_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_4_shared : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_shared_caller' |
| |
| |
| |
| // TEST_QuK1K2K3K4Hi: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & #.klass4, VISIBILITY: hidden |
| // VERIFY: NO-EXPLODE |
| // The function take_quintuple_for_klass1_through_4 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, klass3, and klass4 |
| // fields. The klass5 field goes unused. Argument explosion should *not* |
| // result in specialization because there are more than three (the heuristic |
| // for max explosion size) live nodes in the type-tree. |
| // |
| // CHECK-LABEL: sil hidden [noinline] @take_quintuple_for_klass1_through_4_hidden : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_hidden' |
| sil hidden [noinline] @take_quintuple_for_klass1_through_4_hidden : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %func = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3, %klass4) : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_hidden' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_4_hidden_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_quintuple_for_klass1_through_4_hidden |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[QUINTUPLE]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_hidden_caller' |
| sil @take_quintuple_for_klass1_through_4_hidden_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_4_hidden : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_hidden_caller' |
| |
| // TEST_QuK1K2K3K4Pr: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & #.klass4, VISIBILITY: private |
| // VERIFY: EXPLODE (Quintuple) => (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klass3, #Quintuple.klass4) |
| // The function take_quintuple_for_klass1_through_4 has a single argument of |
| // type Quintuple from which it uses the klass1, klass2, klass3, and klass4 |
| // fields. The klass5 field goes unused. Argument explosion *should* |
| // result in specialization because there are dead leaves and there are fewer |
| // live than the limit imposed by the heuristic, six because the specializing |
| // the function will not result in a thunk. |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_4_private : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s43take_quintuple_for_klass1_through_4_privateTf4x_n : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_private' |
| sil private [noinline] @take_quintuple_for_klass1_through_4_private : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %func = function_ref @take_klass_four_times : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| %result = apply %func(%klass1, %klass2, %klass3, %klass4) : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_private' |
| |
| // CHECK-LABEL: sil @take_quintuple_for_klass1_through_4_private_caller : $@convention(thin) (Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s43take_quintuple_for_klass1_through_4_privateTf4x_n : $@convention(thin) (Klass, Klass, Klass, Klass) -> () |
| // CHECK: [[KLASS4:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass4 |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]], [[KLASS4]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_4_private_caller' |
| sil @take_quintuple_for_klass1_through_4_private_caller : $@convention(thin) (Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_4_private : $@convention(thin) (Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_4_private_caller' |
| |
| |
| |
| // = END: Quintuple, #.klass1, #.klass2, #.klass3, #.klass4 ==================}} |
| |
| |
| |
| // = Quintuple, #.klass1, #.klass2, #.klass3; owned #.klass4, #.klass5 ======={{ |
| |
| |
| |
| // TEST_QuK1K2K3OwK4OwK5Pu: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & owned #.klass4 & owned #.klass5, VISIBILITY: public |
| // VERIFY: EXPLODE: (Quintuple) -> (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klaass3) |
| // The function take_quintuple_for_klass1_through_3_owned_klass4_through_5 has a |
| // single argument of type Quintuple from which it uses the klass1, klass2, |
| // klass3 fields and releases the klass4 and klass5 fields. Argument explosion |
| // *should* result in specialization because there are only three live leaves in |
| // the type tree after considering the owned-to-guaranteed transformation. |
| // |
| // CHECK-LABEL: sil [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5 : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E2_5Tf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5' |
| sil public [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5 : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %klass5 = struct_extract %quintuple : $Quintuple, #Quintuple.klass5 |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| strong_release %klass4 : $Klass |
| strong_release %klass5 : $Klass |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5' |
| |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_caller : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E2_5Tf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_caller' |
| sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_caller : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_owned_klass4_through_5 : $@convention(thin) (@owned Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (@owned Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_caller' |
| |
| |
| |
| // TEST_QuK1K2K3OwK4OwK5PuEx: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & owned #.klass4 & owned #.klass5, VISIBILITY: public_external |
| // VERIFY: EXPLODE: (Quintuple) -> (#Quintuple.klass1, #Quintuple.klass2, #Quintuple.klaass3) |
| // The function take_quintuple_for_klass1_through_3_owned_klass4_through_5 has a |
| // single argument of type Quintuple from which it uses the klass1, klass2, |
| // klass3 fields and releases the klass4 and klass5 fields. Argument explosion |
| // *should* result in specialization because there are only three live leaves in |
| // the type tree after considering the owned-to-guaranteed transformation. |
| // |
| // CHECK-LABEL: sil public_external [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E18_5_public_externalTf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external' |
| sil public_external [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %klass5 = struct_extract %quintuple : $Quintuple, #Quintuple.klass5 |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| strong_release %klass4 : $Klass |
| strong_release %klass5 : $Klass |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external' |
| |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external_caller : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E18_5_public_externalTf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external_caller' |
| sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external_caller : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external : $@convention(thin) (@owned Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (@owned Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_public_external_caller' |
| |
| |
| |
| // TEST_QuK1K2K3OwK4OwK5Sh: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & owned #.klass4 & owned #.klass5, VISIBILITY: shared |
| // VERIFY: EXPLODE |
| // The function |
| // take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared has a |
| // single argument of type Quintuple from which it uses the klass1, klass2, |
| // klass3 fields and releases the klass4 and klass5 fields. Argument explosion |
| // *should* result in specialization because there are only three live leaves |
| // in the type tree after considering the owned-to-guaranteed transformation. |
| // |
| // CHECK-LABEL: sil shared [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_sharedTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared' |
| sil shared [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %klass5 = struct_extract %quintuple : $Quintuple, #Quintuple.klass5 |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| strong_release %klass4 : $Klass |
| strong_release %klass5 : $Klass |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared' |
| |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared_caller : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_sharedTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared_caller' |
| sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared_caller : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared : $@convention(thin) (@owned Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (@owned Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_shared_caller' |
| |
| |
| |
| // TEST_QuK1K2K3OwK4OwK5Hi: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & owned #.klass4 & owned #.klass5, VISIBILITY: hidden |
| // VERIFY: EXPLODE |
| // The function |
| // take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden has a |
| // single argument of type Quintuple from which it uses the klass1, klass2, |
| // klass3 fields and releases the klass4 and klass5 fields. Argument explosion |
| // *should* result in specialization because there are only three live leaves |
| // in the type tree after considering the owned-to-guaranteed transformation. |
| // |
| // CHECK-LABEL: sil hidden [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_hiddenTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden' |
| sil hidden [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %klass5 = struct_extract %quintuple : $Quintuple, #Quintuple.klass5 |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| strong_release %klass4 : $Klass |
| strong_release %klass5 : $Klass |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden' |
| |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden_caller : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_hiddenTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden_caller' |
| sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden_caller : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden : $@convention(thin) (@owned Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (@owned Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_hidden_caller' |
| |
| |
| |
| // TEST_QuK1K2K3OwK4OwK5Pr: TYPE: Quintuple, FIELD: #.klass1 & #.klass2 & #.klass3 & owned #.klass4 & owned #.klass5, VISIBILITY: private |
| // VERIFY: EXPLODE |
| // The function |
| // take_quintuple_for_klass1_through_3_owned_klass4_through_5_private has a |
| // single argument of type Quintuple from which it uses the klass1, klass2, |
| // klass3 fields and releases the klass4 and klass5 fields. Argument explosion |
| // *should* result in specialization because there are only three live leaves |
| // in the type tree after considering the owned-to-guaranteed transformation. |
| // |
| // CHECK-LABEL: sil private [signature_optimized_thunk] [always_inline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_private : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E10_5_privateTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_private' |
| sil private [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_private : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| %klass1 = struct_extract %quintuple : $Quintuple, #Quintuple.klass1 |
| %klass2 = struct_extract %quintuple : $Quintuple, #Quintuple.klass2 |
| %klass3 = struct_extract %quintuple : $Quintuple, #Quintuple.klass3 |
| %klass4 = struct_extract %quintuple : $Quintuple, #Quintuple.klass4 |
| %klass5 = struct_extract %quintuple : $Quintuple, #Quintuple.klass5 |
| %result = apply %func(%klass1, %klass2, %klass3) : $@convention(thin) (Klass, Klass, Klass) -> () |
| strong_release %klass4 : $Klass |
| strong_release %klass5 : $Klass |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_private' |
| |
| // CHECK-LABEL: sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_private_caller : $@convention(thin) (@owned Quintuple) -> () { |
| // CHECK: bb{{[0-9]+}}([[QUINTUPLE:%.*]] : $Quintuple): |
| // CHECK: [[KLASS3:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass3 |
| // CHECK: [[KLASS2:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass2 |
| // CHECK: [[KLASS1:%.*]] = struct_extract [[QUINTUPLE]] : $Quintuple, #Quintuple.klass1 |
| // CHECK: [[FUNCTION:%.*]] = function_ref @$s049take_quintuple_for_klass1_through_3_owned_klass4_E10_5_privateTf4x_nTf4nnndd_n |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_private_caller' |
| sil [noinline] @take_quintuple_for_klass1_through_3_owned_klass4_through_5_private_caller : $@convention(thin) (@owned Quintuple) -> () { |
| only(%quintuple : $Quintuple): |
| %func = function_ref @take_quintuple_for_klass1_through_3_owned_klass4_through_5_private : $@convention(thin) (@owned Quintuple) -> () |
| %result = apply %func(%quintuple) : $@convention(thin) (@owned Quintuple) -> () |
| return %result : $() |
| } // end sil function 'take_quintuple_for_klass1_through_3_owned_klass4_through_5_private_caller' |
| |
| |
| |
| // = END: Quintuple, #.klass1, #.klass2, #.klass3; owned #.klass4, #.klass5 ==}} |
| |
| |
| |
| // ===========================================================================}} |
| // = END: QUINTUPLE = |
| // ============================================================================= |
| |
| |
| // ============================================================================= |
| // ============================================================================= |
| // ===== END: TESTS ===== |
| // ============================================================================= |
| // ===========================================================================}} |
| |
| |
| |
| // ==========================================================================={{ |
| // ============================================================================= |
| // ===== SPECIALIZATIONS ===== |
| // ===== All the specializations are added at the bottom of the output. ===== |
| // ===== The tests around them follow. They are tied back to the original ===== |
| // ===== code via a TEST_<FOO> identifier. ===== |
| // ============================================================================= |
| // ============================================================================= |
| |
| |
| // TEST_WrKlPu: |
| // Nothing to check. |
| |
| // TEST_WrKlPuEx: |
| // Nothig to check. |
| |
| // TEST_WrKlSh: |
| // CHECK: sil shared [noinline] @$s19take_wrapper_sharedTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]](%0) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK: } // end sil function '$s19take_wrapper_sharedTf4x_n' |
| |
| // TEST_WrKlHi: |
| // CHECK-NOT: sil shared [noinline] @$s19take_wrapper_hiddenTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK-NOT: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK-NOT: [[RESULT:%.*]] = apply [[FUNCTION]](%0) |
| // CHECK-NOT: return [[RESULT]] : $() |
| // CHECK-NOT: } // end sil function '$s19take_wrapper_hiddenTf4x_n' |
| |
| // TEST_WrKlPr: |
| // CHECK: sil private [noinline] @$s20take_wrapper_privateTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]](%0) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK: } // end sil function '$s20take_wrapper_privateTf4x_n' |
| |
| // TEST_WrInPu: |
| // CHECK-LABEL: sil shared [noinline] @$s20take_wrapper_for_intTf4x_n : $@convention(thin) (Int) -> () { |
| // CHECK: bb{{[0-9]*}}([[INT:%.*]] : $Int) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s20take_wrapper_for_intTf4x_n' |
| |
| // TEST_WrInPuEx: |
| // CHECK-LABEL: sil shared [noinline] @$s36take_wrapper_for_int_public_externalTf4x_n : $@convention(thin) (Int) -> () { |
| // CHECK: bb{{[0-9]*}}([[INT:%.*]] : $Int) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s36take_wrapper_for_int_public_externalTf4x_n' |
| |
| // TEST_WrInHi: |
| // CHECK-LABEL: sil shared [noinline] @$s27take_wrapper_for_int_hiddenTf4x_n : $@convention(thin) (Int) -> () { |
| // CHECK: bb{{[0-9]*}}([[INT:%.*]] : $Int) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s27take_wrapper_for_int_hiddenTf4x_n' |
| |
| // TEST_WrInPr: |
| // CHECK-LABEL: sil private [noinline] @$s28take_wrapper_for_int_privateTf4x_n : $@convention(thin) (Int) -> () { |
| // CHECK: bb{{[0-9]*}}([[INT:%.*]] : $Int) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_int |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INT]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s28take_wrapper_for_int_privateTf4x_n' |
| |
| // TEST_PaPu: |
| // CHECK-LABEL: sil shared [noinline] @$s16take_pair_unusedTf4d_n : $@convention(thin) () -> () { |
| // CHECK: bb{{[0-9]*}} |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_nothing : $@convention(thin) () -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s16take_pair_unusedTf4d_n' |
| |
| // TEST_PaPuEx: |
| // CHECK-LABEL: sil shared [noinline] @$s32take_pair_unused_public_externalTf4d_n |
| // CHECK: bb{{[0-9]*}} |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_nothing : $@convention(thin) () -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s32take_pair_unused_public_externalTf4d_n' |
| |
| // TEST_PaHi: |
| // CHECK-LABEL: sil shared [noinline] @$s23take_pair_unused_hiddenTf4d_n : $@convention(thin) () -> () { |
| // CHECK: bb{{[0-9]*}} |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_nothing : $@convention(thin) () -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s23take_pair_unused_hiddenTf4d_n' |
| |
| // TEST_PaPr: |
| // CHECK-LABEL: sil private [noinline] @$s24take_pair_unused_privateTf4d_n : $@convention(thin) () -> () { |
| // CHECK: bb{{[0-9]*}} |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_nothing : $@convention(thin) () -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]() |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s24take_pair_unused_privateTf4d_n' |
| |
| // TEST_PaK1Pu: |
| // CHECK-LABEL: sil shared [noinline] @$s20take_pair_for_klass1Tf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS:%.*]] : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s20take_pair_for_klass1Tf4x_n' |
| |
| // TEST_PaK1PuEx: |
| // CHECK-LABEL: sil shared [noinline] @$s36take_pair_for_klass1_public_externalTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS:%.*]] : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s36take_pair_for_klass1_public_externalTf4x_n' |
| |
| // TEST_PaK1Hi: |
| // CHECK-LABEL: sil shared [noinline] @$s27take_pair_for_klass1_hiddenTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s27take_pair_for_klass1_hiddenTf4x_n' |
| |
| // TEST_PaK1Pr: |
| // CHECK-LABEL: sil private [noinline] @$s28take_pair_for_klass1_privateTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s28take_pair_for_klass1_privateTf4x_n' |
| |
| // TEST_PaK2Pu: |
| // CHECK-LABEL: sil shared [noinline] @$s20take_pair_for_klass2Tf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s20take_pair_for_klass2Tf4x_n' |
| |
| // TEST_PaK2PuEx: |
| // CHECK-LABEL: sil shared [noinline] @$s36take_pair_for_klass2_public_externalTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s36take_pair_for_klass2_public_externalTf4x_n' |
| |
| // TEST_PaK2Hi: |
| // CHECK-LABEL: sil shared [noinline] @$s27take_pair_for_klass2_hiddenTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s27take_pair_for_klass2_hiddenTf4x_n' |
| |
| // TEST_PaK2Pr: |
| // CHECK-LABEL: sil private [noinline] @$s28take_pair_for_klass2_privateTf4x_n : $@convention(thin) (Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass) |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass : $@convention(thin) (Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s28take_pair_for_klass2_privateTf4x_n' |
| |
| // TEST_PaK1K2Pu: |
| // Nothing to check. |
| |
| // TEST_PaK1K2PuEx: |
| // Nothing to check. |
| |
| // TEST_PaK1K2Hi: |
| // Nothing to check. |
| |
| // TEST_PaK1K2Pr: |
| // Nothing to check. |
| |
| |
| // TEST_QuK1K2K3Pu: |
| // CHECK-LABEL: sil shared [noinline] @$s35take_quintuple_for_klass1_through_3Tf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass, {{%.*}} : $Klass, {{%.*}} : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}, {{%.*}}, {{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s35take_quintuple_for_klass1_through_3Tf4x_n' |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3PuEx: |
| // FIXME: THIS CHANGED |
| |
| // TEST_QuK1K2K3Sh: |
| // CHECK-LABEL: sil shared [noinline] @$s42take_quintuple_for_klass1_through_3_sharedTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass, {{%.*}} : $Klass, {{%.*}} : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}, {{%.*}}, {{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s42take_quintuple_for_klass1_through_3_sharedTf4x_n' |
| |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3Hi: |
| // CHECK-LABEL: sil shared [noinline] @$s42take_quintuple_for_klass1_through_3_hiddenTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass, {{%.*}} : $Klass, {{%.*}} : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}, {{%.*}}, {{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s42take_quintuple_for_klass1_through_3_hiddenTf4x_n' |
| |
| // TEST_QuK1K2K3Pr: |
| // CHECK-LABEL: sil private [noinline] @$s43take_quintuple_for_klass1_through_3_privateTf4x_n : $@convention(thin) (Klass, Klass, Klass) -> () { |
| // CHECK: bb{{[0-9]*}}({{%.*}} : $Klass, {{%.*}} : $Klass, {{%.*}} : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]({{%.*}}, {{%.*}}, {{%.*}}) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s43take_quintuple_for_klass1_through_3_privateTf4x_n' |
| |
| // TEST_QuK1K2K3K4Pu: |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3K4PuEx: |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3K4Sh: |
| // FIXME: THIS CHANGED |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3K4Hi: |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3K4Pr: |
| // Nothing to check. |
| |
| // TEST_QuK1K2K3OwK4OwK5Pu: |
| // CHECK-LABEL: sil shared [noinline] @$s049take_quintuple_for_klass1_through_3_owned_klass4_E2_5Tf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS1:%.*]] : $Klass, [[KLASS2:%.*]] : $Klass, [[KLASS3:%.*]] : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s049take_quintuple_for_klass1_through_3_owned_klass4_E2_5Tf4x_nTf4nnndd_n' |
| |
| // TEST_QuK1K2K3OwK4OwK5PuEx: |
| // FIXME: THIS CHANGED |
| |
| // TEST_QuK1K2K3OwK4OwK5Sh: |
| // CHECK-LABEL: sil shared [noinline] @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_sharedTf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS1:%.*]] : $Klass, [[KLASS2:%.*]] : $Klass, [[KLASS3:%.*]] : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_sharedTf4x_nTf4nnndd_n' |
| |
| // TEST_QuK1K2K3OwK4OwK5Hi: |
| // CHECK-LABEL: sil shared [noinline] @$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_hiddenTf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS1:%.*]] : $Klass, [[KLASS2:%.*]] : $Klass, [[KLASS3:%.*]] : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s049take_quintuple_for_klass1_through_3_owned_klass4_E9_5_hiddenTf4x_nTf4nnndd_n' |
| |
| // TEST_QuK1K2K3OwK4OwK5Pr: |
| // CHECK-LABEL: sil private [noinline] @$s049take_quintuple_for_klass1_through_3_owned_klass4_E10_5_privateTf4x_nTf4nnndd_n : $@convention(thin) (@owned Klass, @owned Klass, @owned Klass) -> () { |
| // CHECK: bb{{[0-9]*}}([[KLASS1:%.*]] : $Klass, [[KLASS2:%.*]] : $Klass, [[KLASS3:%.*]] : $Klass): |
| // CHECK: [[FUNCTION:%.*]] = function_ref @take_klass_three_times : $@convention(thin) (Klass, Klass, Klass) -> () |
| // CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[KLASS1]], [[KLASS2]], [[KLASS3]]) |
| // CHECK: return [[RESULT]] : $() |
| // CHECK-LABEL: } // end sil function '$s049take_quintuple_for_klass1_through_3_owned_klass4_E10_5_privateTf4x_nTf4nnndd_n' |
| |
| // ============================================================================= |
| // ============================================================================= |
| // ===== END: SPECIALIZATIONS ===== |
| // ============================================================================= |
| // ===========================================================================}} |