mirror of
https://github.com/apple/swift.git
synced 2025-12-21 12:14:44 +01:00
fd4828e40a
I am doing this separately from the actual change to eliminate the option to make it easier to review.
127 lines
4.3 KiB
Plaintext
127 lines
4.3 KiB
Plaintext
// RUN: %target-sil-opt -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 : $()
|
|
}
|