averello/swift-mirror
1
0
Fork 0
mirror of https://github.com/apple/swift.git synced 2025-12-21 12:14:44 +01:00
Code Issues Packages Projects Releases Wiki Activity
Files
cc4c4584bfa25559fd5396fe6222fba901b301cf
swift-mirror/test/SILOptimizer/functionsigopts_sroa.sil
Erik Eckstein 7cceaff5f3 SIL: don't print operand types in textual SIL 
Type annotations for instruction operands are omitted, e.g.

```
  %3 = struct $S(%1, %2)
```

Operand types are redundant anyway and were only used for sanity checking in the SIL parser.

But: operand types _are_ printed if the definition of the operand value was not printed yet.
This happens:

* if the block with the definition appears after the block where the operand's instruction is located

* if a block or instruction is printed in isolation, e.g. in a debugger

The old behavior can be restored with `-Xllvm -sil-print-types`.
This option is added to many existing test files which check for operand types in their check-lines.
2024-11-21 18:49:52 +01:00

992 lines
51 KiB
Plaintext
Raw Blame History

// RUN: %target-sil-opt -sil-print-types -enable-objc-interop -enable-sil-verify-all -enable-expand-all -inline -function-signature-opts %s | %FileCheck %s
import Builtin
/////////////////////
// Data Structures //
/////////////////////
struct S0 {
var f : Builtin.Int16
}
struct S1 {
var f1 : Builtin.Int16
var f2 : Builtin.Int32
}
sil @i16_user : $@convention(thin) (Builtin.Int16) -> ()
sil @i32_user : $@convention(thin) (Builtin.Int32) -> ()
sil @s1_user : $@convention(thin) (S1) -> ()
sil @s1_ptr_user : $@convention(thin) (@in S1) -> ()
struct S2 {
var f1 : S1
var f2 : Builtin.Int64
}
struct S3 {
var f1 : S2
var f2 : S1
}
sil @s2_user : $@convention(thin) (S2) -> ()
class C1 {
var f1 : Builtin.Int32
init()
deinit
}
sil @c1_user : $@convention(thin) (C1) -> ()
class C2 {
var f1 : S3
var f2 : C1
init()
deinit
}
struct S4 {
var f1 : Builtin.NativeObject
}
sil @s4_user : $@convention(thin) (S4) -> ()
sil @s4_pointer_user : $@convention(thin) (@in S4) -> ()
sil @s4_user_twice : $@convention(thin) (S4, S4) -> ()
struct S4Pair {
var f1 : S4
var f2 : S4
}
struct S4Triple {
var f1 : S4
var f2 : S4
var f3 : S4
}
struct S4Octet {
var f1 : S4
var f2 : S4
var f3 : S4
var f4 : S4
var f5 : S4
var f6 : S4
var f7 : S4
var f8 : S4
}
struct S4Fourtytet {
var f1 : S4Octet
var f2 : S4Octet
var f3 : S4Octet
var f4 : S4Octet
var f5 : S4Octet
}
struct S5 {
var f1 : S4
var f2 : S1
}
sil @s5_user : $@convention(thin) (S5) -> ()
struct S6 {
var f1 : S1
var f2 : S1
var f3 : (Builtin.Int32, Builtin.Int16, S1)
}
struct FakeStaticString {
var f1 : Builtin.RawPointer
var f2 : Builtin.Word
var f3 : Builtin.Word
}
sil @fakestaticstring_user : $@convention(thin) (FakeStaticString) -> ()
@objc protocol FakeAnyObject {}
struct FakeOpaquePointer {
var rawValue : Builtin.RawPointer
}
enum FakeOptional<T> {
case none
case some(T)
}
struct FakeUWord {
var value: Builtin.Word
}
struct FakeStringCore {
var baseAddress : FakeOpaquePointer
var countAndFlags : FakeUWord
var owner : FakeOptional<FakeAnyObject>
}
struct FakeString {
var core : FakeStringCore
}
sil @fakestring_user : $@convention(thin) (FakeString) -> ()
sil @tuple_user : $@convention(thin) ((Builtin.Int32, Builtin.Int16, S1)) -> ()
struct EightFieldStruct {
var a1 : Builtin.Int32
var a2 : Builtin.Int32
var a3 : Builtin.Int32
var a4 : Builtin.Int32
var a5 : Builtin.Int32
var a6 : Builtin.Int32
var a7 : Builtin.Int32
var a8 : Builtin.Int32
}
struct ThirtySixFieldStruct {
var b1 : EightFieldStruct
var b2 : EightFieldStruct
var b3 : EightFieldStruct
var b4 : EightFieldStruct
var b5 : EightFieldStruct
}
struct SingleFieldLvl1 {
var s2: SingleFieldLvl2
}
struct SingleFieldLvl2 {
var s3: SingleFieldLvl3
}
struct SingleFieldLvl3 {
var s4: Builtin.Int16
}
///////////
// Tests //
///////////
/// Verify that an argument is not exploded if it is entirely trivial even if it
/// is partly dead.
// CHECK-LABEL: sil [serialized] @single_level_dead_root_callee : $@convention(thin) (S1) -> Builtin.Int32 {
// CHECK: bb0([[INPUT:%[0-9]+]] : $S1):
// CHECK: [[RESULT:%.*]] = struct_extract [[INPUT]] : $S1, #S1.f2
// CHECK: return [[RESULT]] : $Builtin.Int32
sil [serialized] @single_level_dead_root_callee : $@convention(thin) (S1) -> Builtin.Int32 {
bb0(%0 : $S1):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%1 = struct_extract %0 : $S1, #S1.f2
return %1 : $Builtin.Int32
}
// CHECK-LABEL: sil [serialized] @single_level_dead_root_caller : $@convention(thin) (S1) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $S1):
// CHECK: [[FN:%[0-9]+]] = function_ref @single_level_dead_root_callee
// CHECK: apply [[FN]]([[INPUT]])
// CHECK-LABEL: } // end sil function 'single_level_dead_root_caller'
sil [serialized] @single_level_dead_root_caller : $@convention(thin) (S1) -> () {
bb0(%0 : $S1):
%1 = function_ref @single_level_dead_root_callee : $@convention(thin) (S1) -> Builtin.Int32
%2 = apply %1(%0) : $@convention(thin) (S1) -> Builtin.Int32
%9999 = tuple()
return %9999 : $()
}
/// Verify that fully live trivial arguments are not exploded.
// CHECK-LABEL: sil [serialized] @single_level_live_root_callee : $@convention(thin) (S1) -> Builtin.Int32 {
// CHECK: bb0([[INPUT:%[0-9]+]] : $S1):
// CHECK: [[RESULT:%.*]] = struct_extract [[INPUT]] : $S1, #S1.f2
// CHECK: [[FN:%.*]] = function_ref @s1_user : $@convention(thin) (S1) -> ()
// CHECK: apply [[FN]]([[INPUT]])
// CHECK: return [[RESULT]]
// CHECK-LABEL: } // end sil function 'single_level_live_root_callee'
sil [serialized] @single_level_live_root_callee : $@convention(thin) (S1) -> Builtin.Int32 {
bb0(%0 : $S1):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%1 = struct_extract %0 : $S1, #S1.f2
%2 = function_ref @s1_user : $@convention(thin) (S1) -> ()
apply %2(%0) : $@convention(thin) (S1) -> ()
return %1 : $Builtin.Int32
}
// CHECK-LABEL: sil [serialized] @single_level_live_root_caller : $@convention(thin) (S1) -> () {
// CHECK: bb0([[INPUT:%[0-9]+]] : $S1):
// CHECK: [[FN:%[0-9]+]] = function_ref @single_level_live_root_callee
// CHECK: apply [[FN]]([[INPUT]])
// CHECK-LABEL: } // end sil function 'single_level_live_root_caller'
sil [serialized] @single_level_live_root_caller : $@convention(thin) (S1) -> () {
bb0(%0 : $S1):
%1 = function_ref @single_level_live_root_callee : $@convention(thin) (S1) -> Builtin.Int32
%2 = apply %1(%0) : $@convention(thin) (S1) -> Builtin.Int32
%9999 = tuple()
return %9999 : $()
}
/// Verify that a two-level aggregate argument which is entirely trivial, whose
/// root is dead but all of whose leaves are live will not be exploded.
// CHECK-LABEL: sil [serialized] @multiple_level_all_root_fields_used_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64) {
// CHECK: bb0([[INPUT:%.*]] : $S2):
// CHECK: [[INPUTF1:%.*]] = struct_extract [[INPUT]] : $S2, #S2.f1
// CHECK: [[INPUTF1F1:%.*]] = struct_extract [[INPUTF1]] : $S1, #S1.f1
// CHECK: [[INPUTF2:%.*]] = struct_extract [[INPUT]] : $S2, #S2.f2
// CHECK: [[OUT:%.*]] = tuple ([[INPUTF1F1]] : $Builtin.Int16, [[INPUTF2]] : $Builtin.Int64)
// CHECK: return [[OUT]]
// CHECK-LABEL: } // end sil function 'multiple_level_all_root_fields_used_callee'
sil [serialized] @multiple_level_all_root_fields_used_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64) {
bb0(%0 : $S2):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
debug_value %0 : $S2 // debug_value should not prevent function signature optimization
%1 = struct_extract %0 : $S2, #S2.f1
debug_value %1 : $S1 // debug_value should not prevent function signature optimization
%2 = struct_extract %1 : $S1, #S1.f1
%3 = struct_extract %0 : $S2, #S2.f2
%4 = tuple(%2 : $Builtin.Int16, %3 : $Builtin.Int64)
return %4 : $(Builtin.Int16, Builtin.Int64)
}
// CHECK-LABEL: sil [serialized] @multiple_level_all_root_fields_used_caller : $@convention(thin) (S2) -> () {
// CHECK: bb0([[INPUT:%.*]] : $S2):
// CHECK: [[FN:%.*]] = function_ref @multiple_level_all_root_fields_used_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
// CHECK: apply [[FN]]([[INPUT]])
// CHECK-LABEL: } // end sil function 'multiple_level_all_root_fields_used_caller'
sil [serialized] @multiple_level_all_root_fields_used_caller : $@convention(thin) (S2) -> () {
bb0(%0 : $S2):
%1 = function_ref @multiple_level_all_root_fields_used_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
%2 = apply %1(%0) : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
%9999 = tuple()
return %9999 : $()
}
/// Verify that a three-level aggregate argument which is entirely trivial,
/// whose first level nodes are dead but some of whose leaves are live will not
/// be exploded.
// CHECK-LABEL: sil [serialized] @multiple_level_no_root_fields_have_direct_uses_callee : $@convention(thin) (S3) -> (Builtin.Int16, Builtin.Int64) {
// CHECK: bb0([[INPUT:%.*]] : $S3):
// CHECK: [[INPUTF1:%.*]] = struct_extract [[INPUT]] : $S3, #S3.f1
// CHECK: [[INPUTF1F1:%.*]] = struct_extract [[INPUTF1]] : $S2, #S2.f1
// CHECK: [[INPUTF1F1F1:%.*]] = struct_extract [[INPUTF1F1]] : $S1, #S1.f1
// CHECK: [[INPUTF1F2:%.*]] = struct_extract [[INPUTF1]] : $S2, #S2.f2
// CHECK: [[RESULT:%.*]] = tuple ([[INPUTF1F1F1]] : $Builtin.Int16, [[INPUTF1F2]] : $Builtin.Int64)
// CHECK-LABEL: } // end sil function 'multiple_level_no_root_fields_have_direct_uses_callee'
sil [serialized] @multiple_level_no_root_fields_have_direct_uses_callee : $@convention(thin) (S3) -> (Builtin.Int16, Builtin.Int64) {
bb0(%0 : $S3):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
debug_value %0 : $S3
%1 = struct_extract %0 : $S3, #S3.f1
%2 = struct_extract %1 : $S2, #S2.f1
%3 = struct_extract %2 : $S1, #S1.f1
%4 = struct_extract %1 : $S2, #S2.f2
%5 = tuple(%3 : $Builtin.Int16, %4 : $Builtin.Int64)
return %5 : $(Builtin.Int16, Builtin.Int64)
}
// CHECK-LABEL: sil [serialized] @multiple_level_no_root_fields_have_direct_uses_caller : $@convention(thin) (S3) -> () {
// CHECK: bb0([[INPUT:%.*]] : $S3):
// CHECK: [[FUNCTION:%.*]] = function_ref @multiple_level_no_root_fields_have_direct_uses_callee : $@convention(thin) (S3) -> (Builtin.Int16, Builtin.Int64)
// CHECK: apply [[FUNCTION]]([[INPUT]])
// CHECK-LABEL: } // end sil function 'multiple_level_no_root_fields_have_direct_uses_caller'
sil [serialized] @multiple_level_no_root_fields_have_direct_uses_caller : $@convention(thin) (S3) -> () {
bb0(%0 : $S3):
%1 = function_ref @multiple_level_no_root_fields_have_direct_uses_callee : $@convention(thin) (S3) -> (Builtin.Int16, Builtin.Int64)
%2 = apply %1(%0) : $@convention(thin) (S3) -> (Builtin.Int16, Builtin.Int64)
%9999 = tuple()
return %9999 : $()
}
/// Verify that a two-level aggregate argument which is entirely trivial, some
/// of whose leaves are live and which itself is live will not be exploded.
// CHECK-LABEL: sil [serialized] @multiple_level_root_must_be_reformed_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64) {
// CHECK: bb0([[INPUT:%.*]] : $S2):
// CHECK: [[INPUTF1:%.*]] = struct_extract [[INPUT]] : $S2, #S2.f1
// CHECK: [[INPUTF1F1:%.*]] = struct_extract [[INPUTF1]] : $S1, #S1.f1
// CHECK: [[INPUTF2:%.*]] = struct_extract [[INPUT]] : $S2, #S2.f2
// CHECK: [[OUT:%.*]] = tuple ([[INPUTF1F1]] : $Builtin.Int16, [[INPUTF2]] : $Builtin.Int64)
// CHECK: [[FN:%.*]] = function_ref @s2_user : $@convention(thin) (S2) -> ()
// CHECK: apply [[FN]]([[INPUT]]) : $@convention(thin) (S2) -> ()
// CHECK-LABEL: } // end sil function 'multiple_level_root_must_be_reformed_callee'
sil [serialized] @multiple_level_root_must_be_reformed_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64) {
bb0(%0 : $S2):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%2 = struct_extract %0 : $S2, #S2.f1
%3 = struct_extract %2 : $S1, #S1.f1
%4 = struct_extract %0 : $S2, #S2.f2
%5 = tuple(%3 : $Builtin.Int16, %4 : $Builtin.Int64)
%6 = function_ref @s2_user : $@convention(thin) (S2) -> ()
apply %6(%0) : $@convention(thin) (S2) -> ()
return %5 : $(Builtin.Int16, Builtin.Int64)
}
// CHECK-LABEL: sil [serialized] @multiple_level_root_must_be_reformed_caller : $@convention(thin) (S2) -> () {
// CHECK: bb0([[INPUT:%.*]] : $S2):
// CHECK: [[FUNCTION:%.*]] = function_ref @multiple_level_root_must_be_reformed_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
// CHECK: apply [[FUNCTION]]([[INPUT]])
// CHECK-LABEL: } // end sil function 'multiple_level_root_must_be_reformed_caller'
sil [serialized] @multiple_level_root_must_be_reformed_caller : $@convention(thin) (S2) -> () {
bb0(%0 : $S2):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%1 = function_ref @multiple_level_root_must_be_reformed_callee : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
%2 = apply %1(%0) : $@convention(thin) (S2) -> (Builtin.Int16, Builtin.Int64)
%9999 = tuple()
return %9999 : $()
}
/// Verify that an aggregate argument containing a single non-trivial live leaf
/// is not exploded.
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @owned_struct_1_callee : $@convention(thin) (@owned S5, @owned S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32) {
// CHECK: bb0({{%.*}} : $S5, [[INPUT:%.*]] : $S5):
// CHECK: [[FUNCTION:%.*]] = function_ref @$s21owned_struct_1_calleeTfq4dg_n : $@convention(thin) (@guaranteed S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32)
// CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[INPUT]])
// CHECK: release_value [[INPUT]] : $S5
// CHECK: release_value {{%.*}} : $S5
// CHECK: return [[RESULT]]
// CHECK-LABEL: } // end sil function 'owned_struct_1_callee'
sil [serialized] @owned_struct_1_callee : $@convention(thin) (@owned S5, @owned S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32) {
bb0(%0 : $S5, %1 : $S5):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%2 = struct_extract %0 : $S5, #S5.f2
%3 = struct_extract %2 : $S1, #S1.f1
%4 = struct_extract %2 : $S1, #S1.f2
%5 = struct_extract %1 : $S5, #S5.f2
%6 = struct_extract %5 : $S1, #S1.f1
%7 = struct_extract %5 : $S1, #S1.f2
release_value %1 : $S5
release_value %0 : $S5
release_value %1 : $S5
%8 = tuple(%6 : $Builtin.Int16, %7 : $Builtin.Int32, %6 : $Builtin.Int16, %7 : $Builtin.Int32)
return %8 : $(Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32)
}
// CHECK-LABEL: sil [serialized] @owned_struct_1_caller : $@convention(thin) (S5) -> () {
// CHECK: bb0([[INPUT:%.*]] : $S5):
// CHECK: [[INPUTF2:%.*]] = struct_extract [[INPUT]] : $S5, #S5.f2
// CHECK: [[INPUTF2F1:%.*]] = struct_extract [[INPUTF2]] : $S1, #S1.f1
// CHECK: [[INPUTF2F2:%.*]] = struct_extract [[INPUTF2]] : $S1, #S1.f2
// CHECK: [[OUT:%.*]] = tuple ([[INPUTF2F1]] : $Builtin.Int16, [[INPUTF2F2]] : $Builtin.Int32, [[INPUTF2F1]] : $Builtin.Int16, [[INPUTF2F2]] : $Builtin.Int32)
// CHECK-LABEL: } // end sil function 'owned_struct_1_caller'
sil [serialized] @owned_struct_1_caller : $@convention(thin) (S5) -> () {
bb0(%0 : $S5):
%1 = function_ref @owned_struct_1_callee : $@convention(thin) (@owned S5, @owned S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32)
%2 = apply %1(%0, %0) : $@convention(thin) (@owned S5, @owned S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32)
%9999 = tuple()
return %9999 : $()
}
/// Verify that argument explosion that increases argument count before and
/// after dead argument elimination behaves properly.
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @owned_struct_2_callee : $@convention(thin) (Builtin.Int256, Builtin.Int256, @owned S4Triple, Builtin.Int128, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128) {
// CHECK: bb0([[IN1:%.*]] : $Builtin.Int256, [[IN2:%.*]] : $Builtin.Int256, [[TRIPLE:%.*]] : $S4Triple, [[IN4:%.*]] : $Builtin.Int128, [[IN5:%.*]] : $Builtin.Int128):
// CHECK: [[FN:%.*]] = function_ref @$s21owned_struct_2_calleeTfq4ndgXdn_n : $@convention(thin) (Builtin.Int256, @guaranteed S4, @guaranteed S4, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
// CHECK: [[TRIPLEF3:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f3
// CHECK: [[TRIPLEF2:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f2
// CHECK: [[RESULT:%.*]] = apply [[FN]]([[IN1]], [[TRIPLEF2]], [[TRIPLEF3]], [[IN5]]) : $@convention(thin) (Builtin.Int256, @guaranteed S4, @guaranteed S4, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
// CHECK: release_value [[TRIPLE]] : $S4Triple
// CHECK: return [[RESULT]]
// CHECK-LABEL: } // end sil function 'owned_struct_2_callee'
sil [serialized] @owned_struct_2_callee : $@convention(thin) (Builtin.Int256, Builtin.Int256, @owned S4Triple, Builtin.Int128, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128) {
bb0(%0 : $Builtin.Int256, %1 : $Builtin.Int256, %triple : $S4Triple, %3 : $Builtin.Int128, %4 : $Builtin.Int128):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%triple_field2 = struct_extract %triple : $S4Triple, #S4Triple.f2
%triple_field3 = struct_extract %triple : $S4Triple, #S4Triple.f3
%func = function_ref @s4_user_twice : $@convention(thin) (S4, S4) -> ()
%_ = apply %func(%triple_field2, %triple_field3) : $@convention(thin) (S4, S4) -> ()
release_value %triple : $S4Triple
%result = tuple (%0 : $Builtin.Int256, %0 : $Builtin.Int256, %4 : $Builtin.Int128, %4 : $Builtin.Int128)
return %result : $(Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
}
// CHECK-LABEL: sil [serialized] @owned_struct_2_caller : $@convention(thin) (Builtin.Int256, S4Triple, Builtin.Int128) -> () {
// CHECK: bb0([[IN1:%.*]] : $Builtin.Int256, [[TRIPLE:%.*]] : $S4Triple, [[IN3:%.*]] : $Builtin.Int128):
// CHECK: [[FN:%.*]] = function_ref @$s21owned_struct_2_calleeTfq4ndgXdn_n : $@convention(thin) (Builtin.Int256, @guaranteed S4, @guaranteed S4, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
// CHECK: [[TRIPLEF3:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f3
// CHECK: [[TRIPLEF2:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f2
// CHECK: apply [[FN]]([[IN1]], [[TRIPLEF2]], [[TRIPLEF3]], [[IN3]]) : $@convention(thin) (Builtin.Int256, @guaranteed S4, @guaranteed S4, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
// CHECK-LABEL: } // end sil function 'owned_struct_2_caller'
sil [serialized] @owned_struct_2_caller : $@convention(thin) (Builtin.Int256, S4Triple, Builtin.Int128) -> () {
bb0(%0 : $Builtin.Int256, %1 : $S4Triple, %2 : $Builtin.Int128):
%3 = function_ref @owned_struct_2_callee : $@convention(thin) (Builtin.Int256, Builtin.Int256, @owned S4Triple, Builtin.Int128, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
%4 = apply %3(%0, %0, %1, %2, %2) : $@convention(thin) (Builtin.Int256, Builtin.Int256, @owned S4Triple, Builtin.Int128, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
%9999 = tuple()
return %9999 : $()
}
/// Verify that pointer arguments are ignored for now.
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @ignore_ptrs_callee : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> (S4, S4) {
// CHECK: bb0([[POINTER:%.*]] : $*S4Pair, [[PAIR1:%.*]] : $S4Pair, [[PAIR2:%.*]] : $S4Pair):
// CHECK: [[FN:%.*]] = function_ref @$s18ignore_ptrs_calleeTfq4nxx_n : $@convention(thin) (@in S4Pair, S4, S4) -> (S4, S4)
// CHECK: [[VALUE1:%.*]] = struct_extract [[PAIR1]] : $S4Pair, #S4Pair.f1
// CHECK: [[VALUE2:%.*]] = struct_extract [[PAIR2]] : $S4Pair, #S4Pair.f1
// CHECK: [[RESULT:%.*]] = apply [[FN]]([[POINTER]], [[VALUE1]], [[VALUE2]]) : $@convention(thin) (@in S4Pair, S4, S4) -> (S4, S4)
// CHECK: return [[RESULT]]
// CHECK-LABEL: } // end sil function 'ignore_ptrs_callee'
sil [serialized] @ignore_ptrs_callee : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> (S4, S4) {
bb0(%pointer : $*S4Pair, %pair1 : $S4Pair, %pair2 : $S4Pair):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%func = function_ref @s4_user : $@convention(thin) (S4) -> ()
%pointee = load %pointer : $*S4Pair
%first_pointee = struct_extract %pointee : $S4Pair, #S4Pair.f1
%_ = apply %func(%first_pointee) : $@convention(thin) (S4) -> ()
%first1 = struct_extract %pair1 : $S4Pair, #S4Pair.f1
%first2 = struct_extract %pair2 : $S4Pair, #S4Pair.f1
%result = tuple (%first1 : $S4, %first2 : $S4)
return %result : $(S4, S4)
}
// CHECK-LABEL: sil [serialized] @ignore_ptrs_caller : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> () {
// CHECK: bb0([[POINTER:%.*]] : $*S4Pair, [[PAIR1:%.*]] : $S4Pair, [[PAIR2:%.*]] : $S4Pair):
// CHECK: [[FN:%.*]] = function_ref @$s18ignore_ptrs_calleeTfq4nxx_n : $@convention(thin) (@in S4Pair, S4, S4) -> (S4, S4)
// CHECK: [[VALUE1:%.*]] = struct_extract [[PAIR1]] : $S4Pair, #S4Pair.f1
// CHECK: [[VALUE2:%.*]] = struct_extract [[PAIR2]] : $S4Pair, #S4Pair.f1
// CHECK: apply [[FN]]([[POINTER]], [[VALUE1]], [[VALUE2]]) : $@convention(thin) (@in S4Pair, S4, S4) -> (S4, S4)
// CHECK-LABEL: } // end sil function 'ignore_ptrs_caller'
sil [serialized] @ignore_ptrs_caller : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> () {
bb0(%0 : $*S4Pair, %1 : $S4Pair, %2 : $S4Pair):
%3 = function_ref @ignore_ptrs_callee : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> (S4, S4)
%4 = apply %3(%0, %1, %2) : $@convention(thin) (@in S4Pair, S4Pair, S4Pair) -> (S4, S4)
%9999 = tuple()
return %9999 : $()
}
// This test makes sure that we can handle multiple SROA arguments.
// CHECK-LABEL: sil [serialized] @multiple_sroa_callee : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> () {
// CHECK: bb0([[IN1:%.*]] : $FakeStaticString, [[IN2:%.*]] : $FakeString, [[IN3:%.*]] : $FakeStaticString):
// CHECK: [[FN:%.*]] = function_ref @fakestaticstring_user : $@convention(thin) (FakeStaticString) -> ()
// CHECK: apply [[FN]]([[IN1]]) : $@convention(thin) (FakeStaticString) -> ()
// CHECK-LABEL: } // end sil function 'multiple_sroa_callee'
sil [serialized] @multiple_sroa_callee : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> () {
bb0(%0 : $FakeStaticString, %1 : $FakeString, %2 : $FakeStaticString):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%3 = function_ref @fakestaticstring_user : $@convention(thin) (FakeStaticString) -> ()
%4 = function_ref @fakestring_user : $@convention(thin) (FakeString) -> ()
apply %3(%0) : $@convention(thin) (FakeStaticString) -> ()
apply %4(%1) : $@convention(thin) (FakeString) -> ()
apply %3(%2) : $@convention(thin) (FakeStaticString) -> ()
%9999 = tuple()
return %9999 : $()
}
// CHECK-LABEL: sil [serialized] @multiple_sroa_caller : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> () {
// CHECK: bb0([[IN1:%.*]] : $FakeStaticString, [[IN2:%.*]] : $FakeString, [[IN3:%.*]] : $FakeStaticString):
// CHECK: [[FN:%.*]] = function_ref @multiple_sroa_callee : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> ()
// CHECK-LABEL: } // end sil function 'multiple_sroa_caller'
sil [serialized] @multiple_sroa_caller : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> () {
bb0(%0 : $FakeStaticString, %1 : $FakeString, %2 : $FakeStaticString):
%3 = function_ref @multiple_sroa_callee : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> ()
%4 = apply %3(%0, %1, %2) : $@convention(thin) (FakeStaticString, @owned FakeString, FakeStaticString) -> ()
%9999 = tuple()
return %9999 : $()
}
/// Verify that in the face of an exploded argument the ordering of arguments is
/// based on ordering of fields in the original argument rather than ordering of
/// usage in the function being specialized.
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @check_out_of_order_uses_callee : $@convention(thin) (S4Triple) -> () {
// CHECK: bb0([[TRIPLE:%.*]] : $S4Triple):
// CHECK: [[FUNCTION:%.*]] = function_ref @$s30check_out_of_order_uses_calleeTfq4x_n : $@convention(thin) (S4, S4) -> ()
// CHECK: [[INPUT1F2:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f2
// CHECK: [[INPUT1F1:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f1
// CHECK: apply [[FUNCTION]]([[INPUT1F1]], [[INPUT1F2]]) : $@convention(thin) (S4, S4) -> ()
// CHECK-LABEL: } // end sil function 'check_out_of_order_uses_callee'
sil [serialized] @check_out_of_order_uses_callee : $@convention(thin) (S4Triple) -> () {
only(%triple : $S4Triple):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%second = struct_extract %triple : $S4Triple, #S4Triple.f2
%func = function_ref @s4_user : $@convention(thin) (S4) -> ()
apply %func(%second) : $@convention(thin) (S4) -> ()
%first = struct_extract %triple : $S4Triple, #S4Triple.f1
apply %func(%first) : $@convention(thin) (S4) -> ()
%result = tuple()
return %result : $()
}
// CHECK-LABEL: sil [serialized] @check_out_of_order_uses_caller : $@convention(thin) (S4Triple) -> () {
// CHECK: bb0([[TRIPLE:%.*]] : $S4Triple):
// CHECK: [[FUNCTION:%.*]] = function_ref @$s30check_out_of_order_uses_calleeTfq4x_n : $@convention(thin) (S4, S4) -> ()
// CHECK: [[TRIPLEF2:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f2
// CHECK: [[TRIPLEF1:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f1
// CHECK: [[RESULT:%.*]] = apply [[FUNCTION]]([[TRIPLEF1]], [[TRIPLEF2]]) : $@convention(thin) (S4, S4) -> ()
// CHECK: return [[RESULT]] : $()
// CHECK-LABEL: } // end sil function 'check_out_of_order_uses_caller'
sil [serialized] @check_out_of_order_uses_caller : $@convention(thin) (S4Triple) -> () {
bb0(%0 : $S4Triple):
%1 = function_ref @check_out_of_order_uses_callee : $@convention(thin) (S4Triple) -> ()
%result = apply %1(%0) : $@convention(thin) (S4Triple) -> ()
return %result : $()
}
// Make sure that we do not SROA classes.
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @class_callee_1 : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32 {
// CHECK: bb0([[IN1:%.*]] : $C1, [[IN2:%.*]] : $Builtin.Int32):
// CHECK: [[FN:%.*]] = function_ref @$s14class_callee_1Tfq4gn_n : $@convention(thin) (@guaranteed C1, Builtin.Int32) -> Builtin.Int32
// CHECK: apply [[FN]]([[IN1]], [[IN2]]) : $@convention(thin) (@guaranteed C1, Builtin.Int32) -> Builtin.Int32
// CHECK: release_value [[IN1]]
sil [serialized] @class_callee_1 : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32 {
bb0(%0 : $C1, %1 : $Builtin.Int32):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
// This use is needed so that we do not perform dead arg + owned -> guaranteed.
strong_retain %0 : $C1
%2 = function_ref @c1_user : $@convention(thin) (C1) -> ()
apply %2(%0) : $@convention(thin) (C1) -> ()
strong_release %0 : $C1
return %1 : $Builtin.Int32
}
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @class_caller_1 : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32 {
// CHECK: bb0([[IN1:%.*]] : $C1, [[IN2:%.*]] : $Builtin.Int32):
// CHECK: [[FN:%.*]] = function_ref @$s14class_callee_1Tfq4gn_n : $@convention(thin) (@guaranteed C1, Builtin.Int32) -> Builtin.Int32
// CHECK: apply [[FN]]([[IN1]], [[IN2]]) : $@convention(thin) (@guaranteed C1, Builtin.Int32) -> Builtin.Int32
// CHECK: release_value [[IN1]]
sil [serialized] @class_caller_1 : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32 {
bb0(%0 : $C1, %1 : $Builtin.Int32):
%2 = function_ref @class_callee_1 : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32
%3 = apply %2(%0, %1) : $@convention(thin) (@owned C1, Builtin.Int32) -> Builtin.Int32
return %3 : $Builtin.Int32
}
// Make sure we don't clone this despite the projection tree able to
// explode S0 if it was a loadable value.
// CHECK-LABEL: sil [serialized] @inarg_callee : $@convention(thin) (@in S1) -> () {
// CHECK: bb0([[IN:%.*]] : $*S1):
// CHECK: function_ref s1_ptr_user
// CHECK: [[FN:%.*]] = function_ref @s1_ptr_user : $@convention(thin) (@in S1) -> ()
// CHECK: apply [[FN]]
// CHECK: tuple
// CHECK: return
sil [serialized] @inarg_callee : $@convention(thin) (@in S1) -> () {
bb0(%0 : $*S1):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%1 = function_ref @s1_ptr_user : $@convention(thin) (@in S1) -> ()
%2 = apply %1(%0) : $@convention(thin) (@in S1) -> ()
%9999 = tuple()
return %9999 : $()
}
// CHECK-LABEL: sil [serialized] @inarg_caller : $@convention(thin) (@in S1) -> () {
// CHECK: bb0([[IN:%.*]] : $*S1):
// CHECK-NEXT: function_ref inarg_callee
// CHECK-NEXT: [[FN:%.*]] = function_ref @inarg_callee : $@convention(thin) (@in S1) -> ()
// CHECK-NEXT: apply [[FN]]
// CHECK-NEXT: tuple
// CHECK-NEXT: return
// CHECK-LABEL: } // end sil function 'inarg_caller'
sil [serialized] @inarg_caller : $@convention(thin) (@in S1) -> () {
bb0(%0 : $*S1):
%1 = function_ref @inarg_callee : $@convention(thin) (@in S1) -> ()
%2 = apply %1(%0) : $@convention(thin) (@in S1) -> ()
%9999 = tuple()
return %9999 : $()
}
// This test makes sure we can handle functions with more than 32 fields
// (including each subtype's field in that count). This fixes a bug where we
// were not handling the possibility of an std::vector resize invalidated
// references. This cause the this pointer to become invalidated and other
// shenanigans. So just make sure we don't crash
// CHECK-LABEL: sil [serialized] @more_than_32_type_sized_caller : $@convention(thin) (S4Fourtytet) -> S4 {
// CHECK-LABEL: } // end sil function 'more_than_32_type_sized_caller'
sil [serialized] @more_than_32_type_sized_caller : $@convention(thin) (S4Fourtytet) -> S4 {
only(%tet : $S4Fourtytet):
%func = function_ref @more_than_32_type_sized_callee : $@convention(thin) (S4Fourtytet) -> S4
%result = apply %func(%tet) : $@convention(thin) (S4Fourtytet) -> S4
return %result : $S4
}
// CHECK-LABEL: sil [serialized] [signature_optimized_thunk] [always_inline] @more_than_32_type_sized_callee : $@convention(thin) (S4Fourtytet) -> S4 {
// CHECK-LABEL: } // end sil function 'more_than_32_type_sized_callee'
sil [serialized] @more_than_32_type_sized_callee : $@convention(thin) (S4Fourtytet) -> S4 {
bb0(%tet : $S4Fourtytet):
// make it a non-trivial function
%c1 = builtin "assert_configuration"() : $Builtin.Int32
%c2 = builtin "assert_configuration"() : $Builtin.Int32
%c3 = builtin "assert_configuration"() : $Builtin.Int32
%c4 = builtin "assert_configuration"() : $Builtin.Int32
%c5 = builtin "assert_configuration"() : $Builtin.Int32
%c6 = builtin "assert_configuration"() : $Builtin.Int32
%c7 = builtin "assert_configuration"() : $Builtin.Int32
%c8 = builtin "assert_configuration"() : $Builtin.Int32
%c9 = builtin "assert_configuration"() : $Builtin.Int32
%c10 = builtin "assert_configuration"() : $Builtin.Int32
%c11 = builtin "assert_configuration"() : $Builtin.Int32
%c12 = builtin "assert_configuration"() : $Builtin.Int32
%c13 = builtin "assert_configuration"() : $Builtin.Int32
%c14 = builtin "assert_configuration"() : $Builtin.Int32
%c15 = builtin "assert_configuration"() : $Builtin.Int32
%c16 = builtin "assert_configuration"() : $Builtin.Int32
%c17 = builtin "assert_configuration"() : $Builtin.Int32
%c18 = builtin "assert_configuration"() : $Builtin.Int32
%c19 = builtin "assert_configuration"() : $Builtin.Int32
%c20 = builtin "assert_configuration"() : $Builtin.Int32
%c21 = builtin "assert_configuration"() : $Builtin.Int32
%c22 = builtin "assert_configuration"() : $Builtin.Int32
%octet = struct_extract %tet : $S4Fourtytet, #S4Fourtytet.f1
%result = struct_extract %octet : $S4Octet, #S4Octet.f1
return %result : $S4
}
// We should not specialize this since SingleFieldLvl1 is a struct that is layout compatible with its only leaf node, %0.s2.s3.s4
// CHECK-LABEL: sil [serialized] @multiple_level_all_single_field_struct_callee : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16 {
sil [serialized] @multiple_level_all_single_field_struct_callee : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16 {
bb0(%0 : $SingleFieldLvl1):
%1 = struct_extract %0 : $SingleFieldLvl1, #SingleFieldLvl1.s2
%2 = struct_extract %1 : $SingleFieldLvl2, #SingleFieldLvl2.s3
%3 = struct_extract %2 : $SingleFieldLvl3, #SingleFieldLvl3.s4
return %3 : $Builtin.Int16
}
// CHECK-LABEL: sil [serialized] @multiple_level_all_single_field_struct_caller : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16 {
sil [serialized] @multiple_level_all_single_field_struct_caller : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16 {
bb0(%0 : $SingleFieldLvl1):
%1 = function_ref @multiple_level_all_single_field_struct_callee : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16
%2 = apply %1(%0) : $@convention(thin) (SingleFieldLvl1) -> Builtin.Int16
return %2 : $Builtin.Int16
}
// Check Statements for generated code.
// CHECK-LABEL: sil shared [serialized] @$s21owned_struct_1_calleeTfq4dg_n : $@convention(thin) (@guaranteed S5) -> (Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32) {
// CHECK: bb0([[INPUT:%.*]] : $S5):
// CHECK: [[INPUTF2:%.*]] = struct_extract [[INPUT]] : $S5, #S5.f2
// CHECK: [[INPUTF2F1:%.*]] = struct_extract [[INPUTF2]] : $S1, #S1.f1
// CHECK: [[INPUTF2F2:%.*]] = struct_extract [[INPUTF2]] : $S1, #S1.f2
// CHECK: [[OUT:%.*]] = tuple ([[INPUTF2F1]] : $Builtin.Int16, [[INPUTF2F2]] : $Builtin.Int32, [[INPUTF2F1]] : $Builtin.Int16, [[INPUTF2F2]] : $Builtin.Int32)
// CHECK: return [[OUT]] : $(Builtin.Int16, Builtin.Int32, Builtin.Int16, Builtin.Int32)
// CHECK-LABEL: } // end sil function '$s21owned_struct_1_calleeTfq4dg_n'
// CHECK-LABEL: sil shared [serialized] @$s21owned_struct_2_calleeTfq4ndgXdn_n : $@convention(thin) (Builtin.Int256, @guaranteed S4, @guaranteed S4, Builtin.Int128) -> (Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128) {
// CHECK: bb0([[O1:%.*]] : $Builtin.Int256, [[INPUT1:%.*]] : $S4, [[INPUT2:%.*]] : $S4, [[O4:%.*]] : $Builtin.Int128):
// CHECK: [[FUNCTION:%.*]] = function_ref @s4_user_twice : $@convention(thin) (S4, S4) -> ()
// CHECK: apply [[FUNCTION]]([[INPUT1]], [[INPUT2]]) : $@convention(thin) (S4, S4) -> ()
// CHECK: [[RESULT:%.*]] = tuple ([[O1]] : $Builtin.Int256, [[O1]] : $Builtin.Int256, [[O4]] : $Builtin.Int128, [[O4]] : $Builtin.Int128)
// CHECK: return [[RESULT]] : $(Builtin.Int256, Builtin.Int256, Builtin.Int128, Builtin.Int128)
// CHECK-LABEL: } // end sil function '$s21owned_struct_2_calleeTfq4ndgXdn_n'
// CHECK-LABEL: sil shared [serialized] @$s18ignore_ptrs_calleeTfq4nxx_n : $@convention(thin) (@in S4Pair, S4, S4) -> (S4, S4) {
// CHECK: bb0([[POINTER:%.*]] : $*S4Pair, [[VALUE1:%.*]] : $S4, [[VALUE2:%.*]] : $S4):
// CHECK: [[FUNCTION:%.*]] = function_ref @s4_user : $@convention(thin) (S4) -> ()
// CHECK: [[POINTEE:%.*]] = load [[POINTER]] : $*S4Pair
// CHECK: [[VALUE:%.*]] = struct_extract [[POINTEE]] : $S4Pair, #S4Pair.f1
// CHECK: apply [[FUNCTION]]([[VALUE]]) : $@convention(thin) (S4) -> ()
// CHECK: [[OUT:%.*]] = tuple ([[VALUE1]] : $S4, [[VALUE2]] : $S4)
// CHECK: return [[OUT]] : $(S4, S4)
// CHECK-LABEL: } // end sil function '$s18ignore_ptrs_calleeTfq4nxx_n'
// CHECK-LABEL: sil shared [serialized] @$s30check_out_of_order_uses_calleeTfq4x_n : $@convention(thin) (S4, S4) -> () {
// CHECK: bb{{[0-9]+}}([[FIRST:%.*]] : $S4, [[SECOND:%.*]] : $S4):
// CHECK: [[TRIPLE:%.*]] = struct $S4Triple ([[FIRST]] : $S4, [[SECOND]] : $S4, undef : $S4)
// CHECK: [[UNUSED_SECOND:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f2
// CHECK: [[FUNCTION:%.*]] = function_ref @s4_user : $@convention(thin) (S4) -> ()
// CHECK: apply [[FUNCTION]]([[IN2]]) : $@convention(thin) (S4) -> ()
// CHECK: [[UNUSED_FIRST:%.*]] = struct_extract [[TRIPLE]] : $S4Triple, #S4Triple.f1
// CHECK: apply [[FUNCTION]]([[IN1]]) : $@convention(thin) (S4) -> ()
// CHECK-LABEL: } // end sil function '$s30check_out_of_order_uses_calleeTfq4x_n'
// CHECK-LABEL: sil shared [serialized] @$s14class_callee_1Tfq4gn_n : $@convention(thin) (@guaranteed C1, Builtin.Int32) -> Builtin.Int32 {
// CHECK: bb0({{%.*}} : $C1, [[IN:%.*]] : $Builtin.Int32):
// CHECK: return [[IN]] : $Builtin.Int32
Reference in New Issue View Git Blame Copy Permalink