| // RUN: %target-sil-opt -assume-parsing-unqualified-ownership-sil -enable-sil-verify-all %s -lower-aggregate-instrs | %FileCheck %s |
| |
| // This file makes sure that given the current code-size metric we properly |
| // expand operations for small structs and not for large structs in a consistent |
| // way for all operations we expand. |
| |
| sil_stage canonical |
| |
| import Swift |
| import Builtin |
| |
| class C1 { |
| var data : Builtin.Int64 |
| init() |
| } |
| |
| class C2 { |
| var data : Builtin.FPIEEE32 |
| init() |
| } |
| |
| class C3 { |
| var data : Builtin.FPIEEE64 |
| init() |
| } |
| |
| struct S2 { |
| var cls1 : C1 |
| var cls2 : C2 |
| var trivial : Builtin.FPIEEE32 |
| } |
| |
| struct S { |
| var trivial : Builtin.Int64 |
| var cls : C3 |
| var inner_struct : S2 |
| } |
| |
| enum E { |
| case NoElement() |
| case TrivialElement(Builtin.Int64) |
| case ReferenceElement(C1) |
| case StructNonTrivialElt(S) |
| case TupleNonTrivialElt((Builtin.Int64, S, C3)) |
| } |
| |
| // This struct is larger than our current code-size limit (> 6 leaf nodes). |
| struct LargeStruct { |
| var trivial1 : Builtin.Int64 |
| var cls : S |
| var trivial2 : Builtin.Int64 |
| var trivial3 : Builtin.Int64 |
| } |
| |
| /////////// |
| // Tests // |
| /////////// |
| |
| // This test makes sure that we /do not/ expand retain_value, release_value and |
| // promote copy_addr/destroy_value to non-expanded retain_value, release_value. |
| // CHECK-LABEL: sil @large_struct_test : $@convention(thin) (@owned LargeStruct, @in LargeStruct) -> () { |
| // CHECK: bb0([[ARG0:%.*]] : $LargeStruct, [[ARG1:%.*]] : $*LargeStruct): |
| // CHECK: retain_value [[ARG0]] |
| // CHECK: release_value [[ARG0]] |
| // CHECK: [[ALLOC_STACK:%.*]] = alloc_stack $LargeStruct |
| // CHECK: [[LOADED_ARG1:%.*]] = load [[ARG1]] |
| // CHECK: [[LOADED_OLD_VAL:%.*]] = load [[ALLOC_STACK]] |
| // CHECK: retain_value [[LOADED_ARG1]] |
| // CHECK: release_value [[LOADED_OLD_VAL]] |
| // CHECK: store [[LOADED_ARG1]] to [[ALLOC_STACK]] |
| // CHECK: [[LOADED_ARG1:%.*]] = load [[ARG1]] |
| // CHECK: release_value [[LOADED_ARG1]] |
| // CHECK: dealloc_stack [[ALLOC_STACK]] |
| // CHECK: } // end sil function 'large_struct_test' |
| sil @large_struct_test : $@convention(thin) (@owned LargeStruct, @in LargeStruct) -> () { |
| bb0(%0 : $LargeStruct, %1 : $*LargeStruct): |
| retain_value %0 : $LargeStruct |
| release_value %0 : $LargeStruct |
| %2 = alloc_stack $LargeStruct |
| copy_addr %1 to %2 : $*LargeStruct |
| destroy_addr %1 : $*LargeStruct |
| dealloc_stack %2 : $*LargeStruct |
| %9999 = tuple() |
| return %9999 : $() |
| } |
| |
| // CHECK-LABEL: sil @small_struct_test : $@convention(thin) (@owned S2, @in S2) -> () { |
| // CHECK: bb0([[ARG0:%.*]] : $S2, [[ARG1:%.*]] : $*S2): |
| // CHECK: [[ARG0cls1:%.*]] = struct_extract [[ARG0]] : $S2, #S2.cls1 |
| // CHECK: strong_retain [[ARG0cls1]] : $C1 |
| // CHECK: [[ARG0cls2:%.*]] = struct_extract [[ARG0]] : $S2, #S2.cls2 |
| // CHECK: strong_retain [[ARG0cls2]] : $C2 |
| // CHECK: [[ARG0cls1:%.*]] = struct_extract [[ARG0]] : $S2, #S2.cls1 |
| // CHECK: strong_release [[ARG0cls1]] : $C1 |
| // CHECK: [[ARG0cls2:%.*]] = struct_extract [[ARG0]] : $S2, #S2.cls2 |
| // CHECK: strong_release [[ARG0cls2]] : $C2 |
| // |
| // CHECK: [[ALLOC_STACK:%.*]] = alloc_stack $S2 |
| // CHECK: [[LOADED_ARG1:%.*]] = load [[ARG1]] |
| // CHECK: [[LOADED_OLDVALUE:%.*]] = load [[ALLOC_STACK]] |
| // CHECK: [[LOADED_ARG1cls1:%.*]] = struct_extract [[LOADED_ARG1]] : $S2, #S2.cls1 |
| // CHECK: strong_retain [[LOADED_ARG1cls1]] : $C1 |
| // CHECK: [[LOADED_ARG1cls2:%.*]] = struct_extract [[LOADED_ARG1]] : $S2, #S2.cls2 |
| // CHECK: strong_retain [[LOADED_ARG1cls2]] : $C2 |
| // CHECK: [[LOADED_OLDVALUEcls1:%.*]] = struct_extract [[LOADED_OLDVALUE]] : $S2, #S2.cls1 |
| // CHECK: strong_release [[LOADED_OLDVALUEcls1]] : $C1 |
| // CHECK: [[LOADED_OLDVALUEcls2:%.*]] = struct_extract [[LOADED_OLDVALUE]] : $S2, #S2.cls2 |
| // CHECK: strong_release [[LOADED_OLDVALUEcls2]] : $C2 |
| // |
| // CHECK: [[LOADED_ARG1:%.*]] = load [[ARG1]] |
| // CHECK: [[LOADED_ARG1cls1:%.*]] = struct_extract [[LOADED_ARG1]] : $S2, #S2.cls1 |
| // CHECK: strong_release [[LOADED_ARG1cls1]] : $C1 |
| // CHECK: [[LOADED_ARG1cls2:%.*]] = struct_extract [[LOADED_ARG1]] : $S2, #S2.cls2 |
| // CHECK: strong_release [[LOADED_ARG1cls2]] : $C2 |
| // CHECK: } // end sil function 'small_struct_test' |
| sil @small_struct_test : $@convention(thin) (@owned S2, @in S2) -> () { |
| bb0(%0 : $S2, %1 : $*S2): |
| retain_value %0 : $S2 |
| release_value %0 : $S2 |
| %2 = alloc_stack $S2 |
| copy_addr %1 to %2 : $*S2 |
| destroy_addr %1 : $*S2 |
| dealloc_stack %2 : $*S2 |
| %9999 = tuple() |
| return %9999 : $() |
| } |