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
jgrynspan/windows-GUID-hashable-6.2.1
swift-mirror/test/SILOptimizer/sroa_ossa.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

586 lines
29 KiB
Plaintext
Raw Permalink Blame History

// RUN: %target-sil-opt -sil-print-types -enable-sil-verify-all -sroa %s | %FileCheck %s
sil_stage canonical
import Builtin
import Swift
///////////////////////////////
// Struct with Scalar Fields //
///////////////////////////////
struct S1 {
var x : Builtin.Int1
var y : Builtin.Int32
var z : Builtin.Int64
}
sil [ossa] @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-LABEL: sil [ossa] @struct_with_scalar_fields : $@convention(thin) (S1) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $S1):
// CHECK-NEXT: [[VAR_1:%[0-9]+]] = alloc_stack $Builtin.Int1
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: ([[VAR_4:%[0-9]+]], [[VAR_6:%[0-9]+]], [[VAR_8:%[0-9]+]]) = destructure_struct [[VAR_0]]
// CHECK-NEXT: store [[VAR_4]] to [trivial] [[VAR_1]] : $*Builtin.Int1
// CHECK-NEXT: store [[VAR_6]] to [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_8]] to [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_10:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_11:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_12:%[0-9]+]] = apply [[VAR_10]]([[VAR_11]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_13:%[0-9]+]] = load [trivial] [[VAR_1]] : $*Builtin.Int1
// CHECK-NEXT: [[VAR_14:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = struct $S1 ([[VAR_13]] : $Builtin.Int1, [[VAR_14]] : $Builtin.Int32, [[VAR_15]] : $Builtin.Int64)
// CHECK: dealloc_stack [[VAR_3]] : $*Builtin.Int64
// CHECK: dealloc_stack [[VAR_2]] : $*Builtin.Int32
// CHECK: dealloc_stack [[VAR_1]] : $*Builtin.Int1
// CHECK: [[VAR_20:%[0-9]+]] = tuple ()
// CHECK: return [[VAR_20]] : $()
sil [ossa] @struct_with_scalar_fields : $@convention(thin) (S1) -> () {
bb0(%0 : $S1):
%1 = alloc_stack $S1
store %0 to [trivial] %1 : $*S1
%2 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
%3 = struct_element_addr %1 : $*S1, #S1.y
%4 = load [trivial] %3 : $*Builtin.Int32
apply %2(%4) : $@convention(thin) (Builtin.Int32) -> ()
%5 = load [trivial] %1 : $*S1
dealloc_stack %1 : $*S1
%6 = tuple ()
return %6 : $()
}
// CHECK-LABEL: sil [ossa] @dont_sroa_without_benefit : $@convention(thin) (S1) -> S1
// CHECK: bb0
// CHECK-NEXT: alloc_stack $S1
// CHECK-NEXT: store %0 to [trivial] %1 : $*S1
// CHECK-NEXT: load [trivial] %1 : $*S1
// CHECK-NEXT: dealloc_stack %1 : $*S1
// CHECK-NEXT: return
sil [ossa] @dont_sroa_without_benefit : $@convention(thin) (S1) -> S1 {
bb0(%0 : $S1):
%1 = alloc_stack $S1
store %0 to [trivial] %1 : $*S1
%3 = load [trivial] %1 : $*S1
dealloc_stack %1 : $*S1
return %3 : $S1
}
///////////////////////////////
// Struct With Struct Fields //
///////////////////////////////
sil [ossa] @use_s1 : $@convention(thin) (S1) -> ()
struct S2 {
var alpha : Builtin.FPIEEE32
var beta : S1
}
// CHECK-LABEL: sil [ossa] @struct_with_struct_fields : $@convention(thin) (S2, Builtin.Int64) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $S2, [[VAR_1:%[0-9]+]] : $Builtin.Int64):
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.FPIEEE32
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int1
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_5:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: ([[VAR_6:%[0-9]+]], [[VAR_8:%[0-9]+]]) = destructure_struct [[VAR_0]]
// CHECK-NEXT: store [[VAR_6]] to [trivial] [[VAR_2]] : $*Builtin.FPIEEE32
// CHECK-NEXT: ([[VAR_9:%[0-9]+]], [[VAR_11:%[0-9]+]], [[VAR_13:%[0-9]+]]) = destructure_struct [[VAR_8]]
// CHECK-NEXT: store [[VAR_9]] to [trivial] [[VAR_3]] : $*Builtin.Int1
// CHECK-NEXT: store [[VAR_11]] to [trivial] [[VAR_4]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_13]] to [trivial] [[VAR_5]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int1
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_17:%[0-9]+]] = load [trivial] [[VAR_5]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_18:%[0-9]+]] = struct $S1 ([[VAR_15]] : $Builtin.Int1, [[VAR_16]] : $Builtin.Int32, [[VAR_17]] : $Builtin.Int64)
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_19:%[0-9]+]] = function_ref @use_s1 : $@convention(thin) (S1) -> ()
// CHECK-NEXT: [[VAR_20:%[0-9]+]] = apply [[VAR_19]]([[VAR_18]]) : $@convention(thin) (S1) -> ()
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_21:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_22:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_23:%[0-9]+]] = apply [[VAR_21]]([[VAR_22]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_24:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.FPIEEE32
// CHECK-NEXT: [[VAR_25:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int1
// CHECK-NEXT: [[VAR_26:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_27:%[0-9]+]] = load [trivial] [[VAR_5]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_28:%[0-9]+]] = struct $S1 ([[VAR_25]] : $Builtin.Int1, [[VAR_26]] : $Builtin.Int32, [[VAR_27]] : $Builtin.Int64)
// CHECK-NEXT: [[VAR_29:%[0-9]+]] = struct $S2 ([[VAR_24]] : $Builtin.FPIEEE32, [[VAR_28]] : $S1)
// CHECK-NEXT: store [[VAR_1]] to [trivial] [[VAR_5]] : $*Builtin.Int64
// CHECK-NEXT: dealloc_stack [[VAR_5]] : $*Builtin.Int64
// CHECK-NEXT: dealloc_stack [[VAR_4]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_3]] : $*Builtin.Int1
// CHECK-NEXT: dealloc_stack [[VAR_2]] : $*Builtin.FPIEEE32
// CHECK-NEXT: [[VAR_35:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_35]] : $()
sil [ossa] @struct_with_struct_fields : $@convention(thin) (S2, Builtin.Int64) -> () {
bb0(%0 : $S2, %1 : $Builtin.Int64):
%2 = alloc_stack $S2
store %0 to [trivial] %2 : $*S2
%3 = struct_element_addr %2 : $*S2, #S2.beta
%4 = load [trivial] %3 : $*S1
%5 = function_ref @use_s1 : $@convention(thin) (S1) -> ()
apply %5(%4) : $@convention(thin) (S1) -> ()
%6 = struct_element_addr %3 : $*S1, #S1.y
%7 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
%8 = load [trivial] %6 : $*Builtin.Int32
apply %7(%8) : $@convention(thin) (Builtin.Int32) -> ()
%9 = load [trivial] %2 : $*S2
%10 = struct_element_addr %3 : $*S1, #S1.z
store %1 to [trivial] %10 : $*Builtin.Int64
dealloc_stack %2 : $*S2
%11 = tuple()
return %11 : $()
}
//////////////////////////////
// Struct with Tuple Fields //
//////////////////////////////
sil [ossa] @use_tup : $@convention(thin) ((Builtin.Int32, Builtin.Int64, Builtin.Int16)) -> ()
struct S3 {
var gamma : (Builtin.Int32, Builtin.Int64, Builtin.Int16)
var delta : Builtin.FPIEEE32
}
// CHECK-LABEL: sil [ossa] @struct_with_tuple_fields : $@convention(thin) (S3, Builtin.Int64) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $S3, [[VAR_1:%[0-9]+]] : $Builtin.Int64):
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = alloc_stack $Builtin.Int16
// CHECK-NEXT: [[VAR_5:%[0-9]+]] = alloc_stack $Builtin.FPIEEE32
// CHECK-NEXT: ([[VAR_6:%[0-9]+]], [[VAR_13:%[0-9]+]]) = destructure_struct [[VAR_0]]
// CHECK-NEXT: ([[VAR_7:%[0-9]+]], [[VAR_9:%[0-9]+]], [[VAR_11:%[0-9]+]]) = destructure_tuple [[VAR_6]]
// CHECK-NEXT: store [[VAR_7]] to [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_9]] to [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: store [[VAR_11]] to [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: store [[VAR_13]] to [trivial] [[VAR_5]] : $*Builtin.FPIEEE32
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = function_ref @use_tup : $@convention(thin) ((Builtin.Int32, Builtin.Int64, Builtin.Int16)) -> ()
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_17:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_18:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: [[VAR_19:%[0-9]+]] = tuple ([[VAR_16]] : $Builtin.Int32, [[VAR_17]] : $Builtin.Int64, [[VAR_18]] : $Builtin.Int16)
// CHECK-NEXT: [[VAR_20:%[0-9]+]] = apply [[VAR_15]]([[VAR_19]]) : $@convention(thin) ((Builtin.Int32, Builtin.Int64, Builtin.Int16)) -> ()
// CHECK-NEXT: [[VAR_21:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_22:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_23:%[0-9]+]] = apply [[VAR_22]]([[VAR_21]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_24:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_25:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_26:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: [[VAR_27:%[0-9]+]] = tuple ([[VAR_24]] : $Builtin.Int32, [[VAR_25]] : $Builtin.Int64, [[VAR_26]] : $Builtin.Int16)
// CHECK-NEXT: [[VAR_28:%[0-9]+]] = load [trivial] [[VAR_5]] : $*Builtin.FPIEEE32
// CHECK-NEXT: [[VAR_29:%[0-9]+]] = struct $S3 ([[VAR_27]] : $(Builtin.Int32, Builtin.Int64, Builtin.Int16), [[VAR_28]] : $Builtin.FPIEEE32)
// CHECK-NEXT: store [[VAR_1]] to [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: dealloc_stack [[VAR_5]] : $*Builtin.FPIEEE32
// CHECK-NEXT: dealloc_stack [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: dealloc_stack [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: dealloc_stack [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_35:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_35]] : $()
sil [ossa] @struct_with_tuple_fields : $@convention(thin) (S3, Builtin.Int64) -> () {
bb0(%0 : $S3, %1 : $Builtin.Int64):
%2 = alloc_stack $S3
store %0 to [trivial] %2 : $*S3
%3 = function_ref @use_tup : $@convention(thin) ((Builtin.Int32, Builtin.Int64, Builtin.Int16)) -> ()
%4 = struct_element_addr %2 : $*S3, #S3.gamma
%5 = load [trivial] %4 : $*(Builtin.Int32, Builtin.Int64, Builtin.Int16)
apply %3(%5) : $@convention(thin) ((Builtin.Int32, Builtin.Int64, Builtin.Int16)) -> ()
%6 = tuple_element_addr %4 : $*(Builtin.Int32, Builtin.Int64, Builtin.Int16), 0
%7 = load [trivial] %6 : $*Builtin.Int32
%8 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
apply %8(%7) : $@convention(thin) (Builtin.Int32) -> ()
%9 = load [trivial] %2 : $*S3
%10 = tuple_element_addr %4 : $*(Builtin.Int32, Builtin.Int64, Builtin.Int16), 1
store %1 to [trivial] %10 : $*Builtin.Int64
dealloc_stack %2 : $*S3
%11 = tuple ()
return %11 : $()
}
//////////////////////////////
// Tuple with Scalar Fields //
//////////////////////////////
// CHECK-LABEL: sil [ossa] @tuple_with_scalar_fields : $@convention(thin) ((Builtin.Int1, Builtin.Int32, Builtin.Int64)) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $(Builtin.Int1, Builtin.Int32, Builtin.Int64)):
// CHECK-NEXT: [[VAR_1:%[0-9]+]] = alloc_stack $Builtin.Int1
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: ([[VAR_4:%[0-9]+]], [[VAR_6:%[0-9]+]], [[VAR_8:%[0-9]+]]) = destructure_tuple [[VAR_0]]
// CHECK-NEXT: store [[VAR_4]] to [trivial] [[VAR_1]] : $*Builtin.Int1
// CHECK-NEXT: store [[VAR_6]] to [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_8]] to [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_10:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_11:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_12:%[0-9]+]] = apply [[VAR_10]]([[VAR_11]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_13:%[0-9]+]] = load [trivial] [[VAR_1]] : $*Builtin.Int1
// CHECK-NEXT: [[VAR_14:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = tuple ([[VAR_13]] : $Builtin.Int1, [[VAR_14]] : $Builtin.Int32, [[VAR_15]] : $Builtin.Int64)
// CHECK-NEXT: dealloc_stack [[VAR_3]] : $*Builtin.Int64
// CHECK-NEXT: dealloc_stack [[VAR_2]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_1]] : $*Builtin.Int1
// CHECK-NEXT: [[VAR_20:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_20]] : $()
sil [ossa] @tuple_with_scalar_fields : $@convention(thin) ((Builtin.Int1, Builtin.Int32, Builtin.Int64)) -> () {
bb0(%0 : $(Builtin.Int1, Builtin.Int32, Builtin.Int64)):
%1 = alloc_stack $(Builtin.Int1, Builtin.Int32, Builtin.Int64)
store %0 to [trivial] %1 : $*(Builtin.Int1, Builtin.Int32, Builtin.Int64)
%2 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
%3 = tuple_element_addr %1 : $*(Builtin.Int1, Builtin.Int32, Builtin.Int64), 1
%4 = load [trivial] %3 : $*Builtin.Int32
apply %2(%4) : $@convention(thin) (Builtin.Int32) -> ()
%5 = load [trivial] %1 : $*(Builtin.Int1, Builtin.Int32, Builtin.Int64)
dealloc_stack %1 : $*(Builtin.Int1, Builtin.Int32, Builtin.Int64)
%6 = tuple()
return %6 : $()
}
//////////////////////////////
// Tuple With Struct Fields //
//////////////////////////////
struct S4 {
var aleph : Builtin.Int64
var bet : Builtin.Int32
}
sil [ossa] @use_str4 : $@convention(thin) (S4) -> ()
// CHECK-LABEL: sil [ossa] @tuple_with_struct_fields : $@convention(thin) ((S4, Builtin.Int16), Builtin.Int16) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $(S4, Builtin.Int16), [[VAR_1:%[0-9]+]] : $Builtin.Int16):
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = alloc_stack $Builtin.Int16
// CHECK-NEXT: ([[VAR_5:%[0-9]+]], [[VAR_10:%[0-9]+]]) = destructure_tuple [[VAR_0]]
// CHECK-NEXT: ([[VAR_6:%[0-9]+]], [[VAR_8:%[0-9]+]]) = destructure_struct [[VAR_5]]
// CHECK-NEXT: store [[VAR_6]] to [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: store [[VAR_8]] to [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_10]] to [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_12:%[0-9]+]] = function_ref @use_str4 : $@convention(thin) (S4) -> ()
// CHECK-NEXT: [[VAR_13:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_14:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = struct $S4 ([[VAR_13]] : $Builtin.Int64, [[VAR_14]] : $Builtin.Int32)
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = apply [[VAR_12]]([[VAR_15]]) : $@convention(thin) (S4) -> ()
// CHECK-NEXT: [[VAR_17:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_18:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_19:%[0-9]+]] = apply [[VAR_18]]([[VAR_17]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_20:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_21:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_22:%[0-9]+]] = struct $S4 ([[VAR_20]] : $Builtin.Int64, [[VAR_21]] : $Builtin.Int32)
// CHECK-NEXT: [[VAR_23:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: [[VAR_24:%[0-9]+]] = tuple ([[VAR_22]] : $S4, [[VAR_23]] : $Builtin.Int16)
// CHECK-NEXT: store [[VAR_1]] to [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: dealloc_stack [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: dealloc_stack [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_29:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_29]] : $()
sil [ossa] @tuple_with_struct_fields : $@convention(thin) ((S4, Builtin.Int16), Builtin.Int16) -> () {
bb0(%0 : $(S4, Builtin.Int16), %1 : $Builtin.Int16):
%2 = alloc_stack $(S4, Builtin.Int16)
store %0 to [trivial] %2 : $*(S4, Builtin.Int16)
%3 = function_ref @use_str4 : $@convention(thin) (S4) -> ()
%4 = tuple_element_addr %2 : $*(S4, Builtin.Int16), 0
%5 = load [trivial] %4 : $*S4
apply %3(%5) : $@convention(thin) (S4) -> ()
%6 = struct_element_addr %4 : $*S4, #S4.bet
%7 = load [trivial] %6 : $*Builtin.Int32
%8 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
apply %8(%7) : $@convention(thin) (Builtin.Int32) -> ()
%9 = load [trivial] %2 : $*(S4, Builtin.Int16)
%10 = tuple_element_addr %2 : $*(S4, Builtin.Int16), 1
store %1 to [trivial] %10 : $*Builtin.Int16
dealloc_stack %2 : $*(S4, Builtin.Int16)
%11 = tuple()
return %11 : $()
}
/////////////////////////////////
// Tuple with Tuple Field Test //
/////////////////////////////////
sil [ossa] @use_tup2 : $@convention(thin) ((Builtin.Int64, Builtin.Int32)) -> ()
sil [ossa] @use_int16 : $@convention(thin) (Builtin.Int16) -> ()
// CHECK-LABEL: sil [ossa] @tuple_with_tuple_fields : $@convention(thin) (((Builtin.Int64, Builtin.Int32), Builtin.Int16), Builtin.Int16) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $((Builtin.Int64, Builtin.Int32), Builtin.Int16), [[VAR_1:%[0-9]+]] : $Builtin.Int16):
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Builtin.Int64
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = alloc_stack $Builtin.Int32
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = alloc_stack $Builtin.Int16
// CHECK-NEXT: ([[VAR_5:%[0-9]+]], [[VAR_10:%[0-9]+]]) = destructure_tuple [[VAR_0]]
// CHECK-NEXT: ([[VAR_6:%[0-9]+]], [[VAR_8:%[0-9]+]]) = destructure_tuple [[VAR_5]]
// CHECK-NEXT: store [[VAR_6]] to [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: store [[VAR_8]] to [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: store [[VAR_10]] to [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: [[VAR_12:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_13:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_14:%[0-9]+]] = tuple ([[VAR_12]] : $Builtin.Int64, [[VAR_13]] : $Builtin.Int32)
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_15:%[0-9]+]] = function_ref @use_tup2 : $@convention(thin) ((Builtin.Int64, Builtin.Int32)) -> ()
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = apply [[VAR_15]]([[VAR_14]]) : $@convention(thin) ((Builtin.Int64, Builtin.Int32)) -> ()
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_17:%[0-9]+]] = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_18:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_19:%[0-9]+]] = apply [[VAR_17]]([[VAR_18]]) : $@convention(thin) (Builtin.Int32) -> ()
// CHECK-NEXT: [[VAR_20:%[0-9]+]] = load [trivial] [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_21:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: [[VAR_22:%[0-9]+]] = tuple ([[VAR_20]] : $Builtin.Int64, [[VAR_21]] : $Builtin.Int32)
// CHECK-NEXT: [[VAR_23:%[0-9]+]] = load [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: [[VAR_24:%[0-9]+]] = tuple ([[VAR_22]] : $(Builtin.Int64, Builtin.Int32), [[VAR_23]] : $Builtin.Int16)
// CHECK-NEXT: store [[VAR_1]] to [trivial] [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: dealloc_stack [[VAR_4]] : $*Builtin.Int16
// CHECK-NEXT: dealloc_stack [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_2]] : $*Builtin.Int64
// CHECK-NEXT: [[VAR_29:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_29]] : $()
sil [ossa] @tuple_with_tuple_fields : $@convention(thin) (((Builtin.Int64, Builtin.Int32), Builtin.Int16), Builtin.Int16) -> () {
bb0(%0 : $((Builtin.Int64, Builtin.Int32), Builtin.Int16), %1 : $Builtin.Int16):
%2 = alloc_stack $((Builtin.Int64, Builtin.Int32), Builtin.Int16)
store %0 to [trivial] %2 : $*((Builtin.Int64, Builtin.Int32), Builtin.Int16)
%3 = tuple_element_addr %2 : $*((Builtin.Int64, Builtin.Int32), Builtin.Int16), 0
%4 = load [trivial] %3 : $*(Builtin.Int64, Builtin.Int32)
%5 = function_ref @use_tup2 : $@convention(thin) ((Builtin.Int64, Builtin.Int32)) -> ()
apply %5(%4) : $@convention(thin) ((Builtin.Int64, Builtin.Int32)) -> ()
%6 = tuple_element_addr %3 : $*(Builtin.Int64, Builtin.Int32), 1
%7 = function_ref @use_int32 : $@convention(thin) (Builtin.Int32) -> ()
%8 = load [trivial] %6 : $*Builtin.Int32
apply %7(%8) : $@convention(thin) (Builtin.Int32) -> ()
%9 = load [trivial] %2 : $*((Builtin.Int64, Builtin.Int32), Builtin.Int16)
%10 = tuple_element_addr %2 : $*((Builtin.Int64, Builtin.Int32), Builtin.Int16), 1
store %1 to [trivial] %10 : $*Builtin.Int16
dealloc_stack %2 : $*((Builtin.Int64, Builtin.Int32), Builtin.Int16)
%11 = tuple()
return %11 : $()
}
/////////////////////////
// Capture Struct Test //
/////////////////////////
struct CapturedS {
var x : Builtin.Int32
}
sil [ossa] @use_capturedstruct : $@convention(thin) (@inout CapturedS) -> ()
// CHECK-LABEL: sil [ossa] @captured_struct : $@convention(thin) (CapturedS) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $CapturedS):
// CHECK-NEXT: [[VAR_1:%[0-9]+]] = alloc_stack $CapturedS
// CHECK-NEXT: store [[VAR_0]] to [trivial] [[VAR_1]] : $*CapturedS
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = struct_element_addr [[VAR_1]] : $*CapturedS, #CapturedS.x
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_5:%[0-9]+]] = function_ref @use_capturedstruct : $@convention(thin) (@inout CapturedS) -> ()
// CHECK-NEXT: [[VAR_6:%[0-9]+]] = apply [[VAR_5]]([[VAR_1]]) : $@convention(thin) (@inout CapturedS) -> ()
// CHECK-NEXT: [[VAR_7:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_1]] : $*CapturedS
// CHECK-NEXT: [[VAR_9:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_9]] : $()
sil [ossa] @captured_struct : $@convention(thin) (CapturedS) -> () {
bb0(%0 : $CapturedS):
%1 = alloc_stack $CapturedS
store %0 to [trivial] %1 : $*CapturedS
%3 = struct_element_addr %1 : $*CapturedS, #CapturedS.x
%4 = load [trivial] %3 : $*Builtin.Int32
%5 = function_ref @use_capturedstruct : $@convention(thin) (@inout CapturedS) -> ()
%6 = apply %5(%1) : $@convention(thin) (@inout CapturedS) -> ()
%7 = load [trivial] %3 : $*Builtin.Int32
dealloc_stack %1 : $*CapturedS
%9 = tuple ()
return %9 : $()
}
/////////////////////////
// Captured Tuple Test //
/////////////////////////
sil [ossa] @use_capturedtuple : $@convention(thin) (@inout (Builtin.Int32, Builtin.Int64)) -> ()
// CHECK-LABEL: sil [ossa] @captured_tuple : $@convention(thin) ((Builtin.Int32, Builtin.Int64)) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : $(Builtin.Int32, Builtin.Int64)):
// CHECK-NEXT: [[VAR_1:%[0-9]+]] = alloc_stack $(Builtin.Int32, Builtin.Int64)
// CHECK-NEXT: store [[VAR_0]] to [trivial] [[VAR_1]] : $*(Builtin.Int32, Builtin.Int64)
// CHECK-NEXT: [[VAR_3:%[0-9]+]] = tuple_element_addr [[VAR_1]] : $*(Builtin.Int32, Builtin.Int64), 0
// CHECK-NEXT: [[VAR_4:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_5:%[0-9]+]] = function_ref @use_capturedtuple : $@convention(thin) (@inout (Builtin.Int32, Builtin.Int64)) -> ()
// CHECK-NEXT: [[VAR_6:%[0-9]+]] = apply [[VAR_5]]([[VAR_1]]) : $@convention(thin) (@inout (Builtin.Int32, Builtin.Int64)) -> ()
// CHECK-NEXT: [[VAR_7:%[0-9]+]] = load [trivial] [[VAR_3]] : $*Builtin.Int32
// CHECK-NEXT: dealloc_stack [[VAR_1]] : $*(Builtin.Int32, Builtin.Int64)
// CHECK-NEXT: [[VAR_9:%[0-9]+]] = tuple ()
// CHECK-NEXT: return [[VAR_9]] : $()
sil [ossa] @captured_tuple : $@convention(thin) ((Builtin.Int32, Builtin.Int64)) -> () {
bb0(%0 : $(Builtin.Int32, Builtin.Int64)):
%1 = alloc_stack $(Builtin.Int32, Builtin.Int64)
store %0 to [trivial] %1 : $*(Builtin.Int32, Builtin.Int64)
%3 = tuple_element_addr %1 : $*(Builtin.Int32, Builtin.Int64), 0
%4 = load [trivial] %3 : $*Builtin.Int32
%5 = function_ref @use_capturedtuple : $@convention(thin) (@inout (Builtin.Int32, Builtin.Int64)) -> ()
%6 = apply %5(%1) : $@convention(thin) (@inout (Builtin.Int32, Builtin.Int64)) -> ()
%7 = load [trivial] %3 : $*Builtin.Int32
dealloc_stack %1 : $*(Builtin.Int32, Builtin.Int64)
%9 = tuple ()
return %9 : $()
}
///////////////////////
// Non-trivial Tests //
///////////////////////
class Obj { }
struct NotTrivial {
var x : Obj
var y : Obj
}
sil [ossa] @use_obj : $@convention(thin) (@owned Obj) -> ()
// CHECK-LABEL: sil [ossa] @struct_with_obj_fields : $@convention(thin) (@owned NotTrivial) -> ()
// CHECK: bb0([[VAR_0:%[0-9]+]] : @owned $NotTrivial):
// CHECK-NEXT: [[VAR_1:%[0-9]+]] = alloc_stack $Obj
// CHECK-NEXT: [[VAR_2:%[0-9]+]] = alloc_stack $Obj
// CHECK-NEXT: ([[VAR_4:%[0-9]+]], [[VAR_6:%[0-9]+]]) = destructure_struct [[VAR_0]]
// CHECK-NEXT: store [[VAR_4]] to [init] [[VAR_1]] : $*Obj
// CHECK-NEXT: store [[VAR_6]] to [init] [[VAR_2]] : $*Obj
// CHECK-NEXT: function_ref
// CHECK-NEXT: [[VAR_10:%[0-9]+]] = function_ref @use_obj : $@convention(thin) (@owned Obj) -> ()
// Make sure we use [copy] here ▼▼▼▼▼▼
// CHECK-NEXT: [[VAR_11:%[0-9]+]] = load [copy] [[VAR_2]] : $*Obj
// CHECK-NEXT: [[VAR_12:%[0-9]+]] = apply [[VAR_10]]([[VAR_11]]) : $@convention(thin) (@owned Obj) -> ()
// CHECK-NEXT: [[VAR_13:%[0-9]+]] = load [take] [[VAR_1]] : $*Obj
// CHECK-NEXT: [[VAR_14:%[0-9]+]] = load [take] [[VAR_2]] : $*Obj
// CHECK-NEXT: [[VAR_16:%[0-9]+]] = struct $NotTrivial ([[VAR_13]] : $Obj, [[VAR_14]] : $Obj)
// CHECK: dealloc_stack [[VAR_2]] : $*Obj
// CHECK: dealloc_stack [[VAR_1]] : $*Obj
// CHECK: [[VAR_20:%[0-9]+]] = tuple ()
// CHECK: return [[VAR_20]] : $()
sil [ossa] @struct_with_obj_fields : $@convention(thin) (@owned NotTrivial) -> () {
bb0(%0 : @owned $NotTrivial):
%1 = alloc_stack $NotTrivial
store %0 to [init] %1 : $*NotTrivial
%2 = function_ref @use_obj : $@convention(thin) (@owned Obj) -> ()
%3 = struct_element_addr %1 : $*NotTrivial, #NotTrivial.y
// Make sure that SROA respects the [copy] qual.
%4 = load [copy] %3 : $*Obj
apply %2(%4) : $@convention(thin) (@owned Obj) -> ()
%5 = load [take] %1 : $*NotTrivial
destroy_value %5 : $NotTrivial
dealloc_stack %1 : $*NotTrivial
%6 = tuple ()
return %6 : $()
}
// CHECK-LABEL: sil [ossa] @struct_with_obj_fields_multiple_stores :
// CHECK: bb0([[ARG_0:%[0-9]+]] : @owned $NotTrivial, [[ARG_1:%[0-9]+]] : @owned $NotTrivial):
// CHECK: [[VAR_1:%[0-9]+]] = alloc_stack $Obj
// CHECK: [[VAR_2:%[0-9]+]] = alloc_stack $Obj
// CHECK: ([[VAR_4:%[0-9]+]], [[VAR_6:%[0-9]+]]) = destructure_struct [[ARG_0]]
// CHECK: store [[VAR_4]] to [init] [[VAR_1]] : $*Obj
// CHECK: store [[VAR_6]] to [init] [[VAR_2]] : $*Obj
// CHECK: ([[VAR_4a:%[0-9]+]], [[VAR_6a:%[0-9]+]]) = destructure_struct [[ARG_1]]
// Make sure we use [assign] here
// CHECK: store [[VAR_4a]] to [assign] [[VAR_1]] : $*Obj
// CHECK: store [[VAR_6a]] to [assign] [[VAR_2]] : $*Obj
// CHECK-LABEL: } // end sil function 'struct_with_obj_fields_multiple_stores'
sil [ossa] @struct_with_obj_fields_multiple_stores : $@convention(thin) (@owned NotTrivial, @owned NotTrivial) -> () {
bb0(%0 : @owned $NotTrivial, %1 : @owned $NotTrivial):
%stk = alloc_stack $NotTrivial
store %0 to [init] %stk : $*NotTrivial
%3 = struct_element_addr %stk : $*NotTrivial, #NotTrivial.y
%4 = load [copy] %3 : $*Obj
%2 = function_ref @use_obj : $@convention(thin) (@owned Obj) -> ()
apply %2(%4) : $@convention(thin) (@owned Obj) -> ()
store %1 to [assign] %stk : $*NotTrivial
%4a = load [copy] %3 : $*Obj
apply %2(%4a) : $@convention(thin) (@owned Obj) -> ()
%5 = load [take] %stk : $*NotTrivial
destroy_value %5 : $NotTrivial
dealloc_stack %stk : $*NotTrivial
%6 = tuple ()
return %6 : $()
}
class Klass {
}
struct NonTrivialStruct {
var x : Klass
var y : Klass
var z : Klass
}
sil @get_klasstriple : $@convention(thin) () -> (@owned Klass, @owned Klass, @owned Klass)
// CHECK-LABEL: sil [ossa] @test_dynamiclifetime :
// CHECK: alloc_stack [dynamic_lifetime] $Klass
// CHECK: alloc_stack [dynamic_lifetime] $Klass
// CHECK: alloc_stack [dynamic_lifetime] $Klass
// CHECK-LABEL: } // end sil function 'test_dynamiclifetime'
sil [ossa] @test_dynamiclifetime : $@convention(thin) () -> () {
bb0:
%2 = alloc_stack $Builtin.Int1
%3 = alloc_stack [dynamic_lifetime] $NonTrivialStruct
%4 = integer_literal $Builtin.Int1, 0
store %4 to [trivial] %2 : $*Builtin.Int1
cond_br undef, bb1, bb2
bb1:
br bb3
bb2:
%func = function_ref @get_klasstriple : $@convention(thin) () -> (@owned Klass, @owned Klass, @owned Klass)
%r = apply %func() : $@convention(thin) () -> (@owned Klass, @owned Klass, @owned Klass)
(%v1, %v2, %v3) = destructure_tuple %r : $(Klass, Klass, Klass)
%27 = integer_literal $Builtin.Int1, -1
store %27 to [trivial] %2 : $*Builtin.Int1
%f1 = struct_element_addr %3 : $*NonTrivialStruct, #NonTrivialStruct.x
store %v1 to [init] %f1 : $*Klass
%f2 = struct_element_addr %3 : $*NonTrivialStruct, #NonTrivialStruct.y
store %v2 to [init] %f2 : $*Klass
%f3 = struct_element_addr %3 : $*NonTrivialStruct, #NonTrivialStruct.z
store %v3 to [init] %f3 : $*Klass
br bb3
bb3:
%32 = load [trivial] %2 : $*Builtin.Int1
cond_br %32, bb4, bb5
bb4:
%34 = load [take] %3 : $*NonTrivialStruct
destroy_value %34 : $NonTrivialStruct
br bb6
bb5:
br bb6
bb6:
dealloc_stack %3 : $*NonTrivialStruct
dealloc_stack %2 : $*Builtin.Int1
%res = tuple ()
return %res : $()
}
Reference in New Issue View Git Blame Copy Permalink