Skip to content

Commit 359eda5

Browse files
gottesmmgottesmm
committed
[silgenpattern] Change all loadable types to always go through the ownership preserving tuple code.
To do this the commit does a few things: 1. If we enter the tuple dispatch code with an address that is loadable, we always immediately perform a load_borrow and change the consumable managed value to BorrowAlways. 2. If we have a take_on_success object, we immediately borrow. We do not want to do with TakeOnSuccess since we want to define away the need to unforward since unforwarding recreates a destroy on the already invalidated parent tuple object. Notice that this code still handles TakeAlways so in simple cases where we have a +1 value, everything still works. Since emitTupleDispatchWithOwnership now handles only objects, I renamed it to emitTupleObjectDispatch. rdar://29791263
1 parent 56ab120 commit 359eda5

File tree

6 files changed

+77
-60
lines changed

6 files changed

+77
-60
lines changed

‎lib/SILGen/SILGenPattern.cpp

Lines changed: 42 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -465,10 +465,10 @@ class PatternMatchEmission {
465465
void emitSpecializedDispatch(ClauseMatrix &matrix, ArgArray args,
466466
unsigned &lastRow, unsigned column,
467467
const FailureHandler &failure);
468-
void emitTupleDispatchWithOwnership(ArrayRef<RowToSpecialize> rows,
469-
ConsumableManagedValue src,
470-
const SpecializationHandler &handleSpec,
471-
const FailureHandler &failure);
468+
void emitTupleObjectDispatch(ArrayRef<RowToSpecialize> rows,
469+
ConsumableManagedValue src,
470+
const SpecializationHandler &handleSpec,
471+
const FailureHandler &failure);
472472
void emitTupleDispatch(ArrayRef<RowToSpecialize> rows,
473473
ConsumableManagedValue src,
474474
const SpecializationHandler &handleSpec,
@@ -1371,7 +1371,7 @@ emitReabstractedSubobject(SILGenFunction &SGF, SILLocation loc,
13711371
SGF.emitOrigToSubstValue(loc, mv, abstraction, substFormalType));
13721372
}
13731373

1374-
void PatternMatchEmission::emitTupleDispatchWithOwnership(
1374+
void PatternMatchEmission::emitTupleObjectDispatch(
13751375
ArrayRef<RowToSpecialize> rows, ConsumableManagedValue src,
13761376
const SpecializationHandler &handleCase,
13771377
const FailureHandler &outerFailure) {
@@ -1399,8 +1399,7 @@ void PatternMatchEmission::emitTupleDispatchWithOwnership(
13991399
destructured.push_back({v, src.getFinalConsumption()});
14001400
});
14011401

1402-
// Break down the values.
1403-
// Recurse.
1402+
// Since we did all of our work at +0, we just send down the outer failure.
14041403
handleCase(destructured, specializedRows, outerFailure);
14051404
}
14061405

@@ -1411,13 +1410,45 @@ void PatternMatchEmission::
14111410
emitTupleDispatch(ArrayRef<RowToSpecialize> rows, ConsumableManagedValue src,
14121411
const SpecializationHandler &handleCase,
14131412
const FailureHandler &outerFailure) {
1414-
if (SGF.getOptions().EnableSILOwnership && src.getType().isObject()) {
1415-
return emitTupleDispatchWithOwnership(rows, src, handleCase, outerFailure);
1416-
}
14171413
auto firstPat = rows[0].Pattern;
1418-
auto sourceType = cast<TupleType>(firstPat->getType()->getCanonicalType());
14191414
SILLocation loc = firstPat;
14201415

1416+
// If our source is an address that is loadable, perform a load_borrow.
1417+
if (src.getType().isAddress() && src.getType().isLoadable(SGF.getModule())) {
1418+
src = {SGF.B.createLoadBorrow(loc, src.getFinalManagedValue()),
1419+
CastConsumptionKind::BorrowAlways};
1420+
}
1421+
1422+
// Then if we have an object...
1423+
if (src.getType().isObject()) {
1424+
// Make sure that if we ahve a copy_on_success, non-trivial value that we do
1425+
// not have a value with @owned ownership.
1426+
assert((!src.getType().isTrivial(SGF.getModule()) ||
1427+
src.getFinalConsumption() != CastConsumptionKind::CopyOnSuccess ||
1428+
src.getOwnershipKind() != ValueOwnershipKind::Owned) &&
1429+
"@owned value without cleanup + copy_on_success");
1430+
1431+
// If we have are asked to perform TakeOnSuccess, borrow the value instead.
1432+
//
1433+
// The reason why do this for TakeOnSuccess is that we want to not have to
1434+
// deal with unforwarding of aggregate tuples in failing cases since that
1435+
// causes ownership invariants to be violated since we already forwarded the
1436+
// aggregate to create cleanups on its elements.
1437+
//
1438+
// In contrast, we do still want to allow for TakeAlways variants to not
1439+
// need to borrow, so we do not borrow if we take always.
1440+
if (!src.getType().isTrivial(SGF.getModule()) &&
1441+
src.getFinalConsumption() == CastConsumptionKind::TakeOnSuccess) {
1442+
src = {src.getFinalManagedValue().borrow(SGF, loc),
1443+
CastConsumptionKind::BorrowAlways};
1444+
}
1445+
1446+
// Then perform a forward or reborrow destructure on the object.
1447+
return emitTupleObjectDispatch(rows, src, handleCase, outerFailure);
1448+
}
1449+
1450+
auto sourceType = cast<TupleType>(firstPat->getType()->getCanonicalType());
1451+
14211452
SILValue v = src.getFinalManagedValue().forward(SGF);
14221453
SmallVector<ConsumableManagedValue, 4> destructured;
14231454

‎test/SILGen/indirect_enum.swift

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -176,8 +176,7 @@ func switchTreeA<T>(_ x: TreeA<T>) {
176176
// CHECK: [[BRANCH_CASE]]([[NODE_BOX:%.*]] : @owned $<τ_0_0> { var (left: TreeA<τ_0_0>, right: TreeA<τ_0_0>) } <T>):
177177
// CHECK: [[TUPLE_ADDR:%.*]] = project_box [[NODE_BOX]]
178178
// CHECK: [[TUPLE:%.*]] = load_borrow [[TUPLE_ADDR]]
179-
// CHECK: [[LEFT:%.*]] = tuple_extract [[TUPLE]] {{.*}}, 0
180-
// CHECK: [[RIGHT:%.*]] = tuple_extract [[TUPLE]] {{.*}}, 1
179+
// CHECK: ([[LEFT:%.*]], [[RIGHT:%.*]]) = destructure_tuple [[TUPLE]]
181180
// CHECK: switch_enum [[LEFT]] : $TreeA<T>,
182181
// CHECK: case #TreeA.Leaf!enumelt.1: [[LEAF_CASE_LEFT:bb[0-9]+]],
183182
// CHECK: default [[FAIL_LEFT:bb[0-9]+]]

‎test/SILGen/switch.swift

Lines changed: 4 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -705,8 +705,7 @@ func test_union_1(u: MaybePair) {
705705

706706
// CHECK: [[IS_BOTH]]([[TUP:%.*]] : @owned $(Int, String)):
707707
case .Both:
708-
// CHECK: tuple_extract [[TUP]] : $(Int, String), 0
709-
// CHECK: [[TUP_STR:%.*]] = tuple_extract [[TUP]] : $(Int, String), 1
708+
// CHECK: ({{%.*}}, [[TUP_STR:%.*]]) = destructure_tuple [[TUP]]
710709
// CHECK: destroy_value [[TUP_STR]] : $String
711710
// CHECK: function_ref @$s6switch1dyyF
712711
// CHECK: br [[CONT]]
@@ -915,9 +914,7 @@ enum Foo { case A, B }
915914
// CHECK-LABEL: sil hidden @$s6switch05test_A11_two_unions1x1yyAA3FooO_AFtF
916915
func test_switch_two_unions(x: Foo, y: Foo) {
917916
// CHECK: [[T0:%.*]] = tuple (%0 : $Foo, %1 : $Foo)
918-
// CHECK: [[X:%.*]] = tuple_extract [[T0]] : $(Foo, Foo), 0
919-
// CHECK: [[Y:%.*]] = tuple_extract [[T0]] : $(Foo, Foo), 1
920-
917+
// CHECK: ([[X:%.*]], [[Y:%.*]]) = destructure_tuple [[T0]]
921918
// CHECK: switch_enum [[Y]] : $Foo, case #Foo.A!enumelt: [[IS_CASE1:bb[0-9]+]], default [[IS_NOT_CASE1:bb[0-9]+]]
922919

923920
switch (x, y) {
@@ -980,8 +977,7 @@ func rdar14835992<T, U>(t: Rdar14835992, tt: T, uu: U) {
980977
enum ABC { case A, B, C }
981978

982979
// CHECK-LABEL: sil hidden @$s6switch18testTupleWildcardsyyAA3ABCO_ADtF
983-
// CHECK: [[X:%.*]] = tuple_extract {{%.*}} : $(ABC, ABC), 0
984-
// CHECK: [[Y:%.*]] = tuple_extract {{%.*}} : $(ABC, ABC), 1
980+
// CHECK: ([[X:%.*]], [[Y:%.*]]) = destructure_tuple {{%.*}} : $(ABC, ABC)
985981
// CHECK: switch_enum [[X]] : $ABC, case #ABC.A!enumelt: [[X_A:bb[0-9]+]], default [[X_NOT_A:bb[0-9]+]]
986982
// CHECK: [[X_A]]:
987983
// CHECK: function_ref @$s6switch1ayyF
@@ -1022,7 +1018,7 @@ func testLabeledScalarPayload(_ lsp: LabeledScalarPayload) -> Any {
10221018
// CHECK: switch_enum {{%.*}}, case #LabeledScalarPayload.Payload!enumelt.1: bb1
10231019
switch lsp {
10241020
// CHECK: bb1([[TUPLE:%.*]] : @trivial $(name: Int)):
1025-
// CHECK: [[X:%.*]] = tuple_extract [[TUPLE]]
1021+
// CHECK: [[X:%.*]] = destructure_tuple [[TUPLE]]
10261022
// CHECK: [[ANY_X_ADDR:%.*]] = init_existential_addr {{%.*}}, $Int
10271023
// CHECK: store [[X]] to [trivial] [[ANY_X_ADDR]]
10281024
case let .Payload(x):

‎test/SILGen/switch_isa.swift

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -55,9 +55,8 @@ func guardFn(_ l: D, _ r: D) -> Bool { return true }
5555
// CHECK: [[ARG0_COPY:%.*]] = copy_value [[ARG0]]
5656
// CHECK: [[ARG1_COPY:%.*]] = copy_value [[ARG1]]
5757
// CHECK: [[TUP:%.*]] = tuple ([[ARG0_COPY:%.*]] : $B, [[ARG1_COPY:%.*]] : $B)
58-
// TODO: This should be destructures not tuple extracts.
59-
// CHECK: [[TUP_1:%.*]] = tuple_extract [[TUP]] : $(B, B), 0
60-
// CHECK: [[TUP_2:%.*]] = tuple_extract [[TUP]] : $(B, B), 1
58+
// CHECK: [[BORROWED_TUP:%.*]] = begin_borrow [[TUP]]
59+
// CHECK: ([[TUP_1:%.*]], [[TUP_2:%.*]]) = destructure_tuple [[BORROWED_TUP]]
6160
// CHECK: checked_cast_br [[TUP_1]] : $B to $D, [[R_CAST_YES:bb[0-9]+]], [[R_CAST_NO:bb[0-9]+]]
6261
//
6362
// CHECK: [[R_CAST_YES]]([[R:%.*]] : @guaranteed $D):
@@ -74,8 +73,8 @@ func guardFn(_ l: D, _ r: D) -> Bool { return true }
7473
// CHECK-NEXT: destroy_value [[R2]]
7574
// CHECK-NEXT: end_borrow [[L]]
7675
// CHECK-NEXT: end_borrow [[R]]
77-
// CHECK-NEXT: destroy_value [[TUP_2]]
78-
// CHECK-NEXT: destroy_value [[TUP_1]]
76+
// CHECK-NEXT: end_borrow [[BORROWED_TUP]]
77+
// CHECK-NEXT: destroy_value [[TUP]]
7978
// CHECK-NEXT: br [[EXIT:bb[0-9]+]]
8079
//
8180
// CHECK: [[GUARD_NO]]:
@@ -84,12 +83,14 @@ func guardFn(_ l: D, _ r: D) -> Bool { return true }
8483
// TODO: Infer end_borrow from the input begin_borrow. This should be eliminated.
8584
// CHECK-NEXT: end_borrow [[L]]
8685
// CHECK-NEXT: end_borrow [[R]]
86+
// CHECK-NEXT: end_borrow [[BORROWED_TUP]]
8787
// CHECK-NEXT: br [[CONT:bb[0-9]+]]
8888
//
8989
// CHECK: [[L_CAST_NO]]([[LFAIL:%.*]] : @guaranteed $B):
9090
// CHECK-NEXT: end_borrow [[LFAIL]]
9191
// CHECK-NEXT: destroy_value [[R2]]
9292
// CHECK-NEXT: end_borrow [[R]]
93+
// CHECK-NEXT: end_borrow [[BORROWED_TUP]]
9394
// CHECK-NEXT: br [[CONT]]
9495
//
9596
// CHECK: [[CONT]]:

‎test/SILGen/switch_ownership.swift

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -60,6 +60,7 @@ func test_switch_two_trivial_unions(x: Foo, y: Foo) {
6060
// CHECK: unreachable
6161
}
6262
}
63+
// CHECK: } // end sil function '$s6switch05test_A19_two_trivial_unions1x1yyAA3FooO_AFtF'
6364

6465
// CHECK-LABEL: sil hidden @$s6switch05test_A22_two_nontrivial_unions1x1yyAA13NonTrivialFooO_AFtF : $@convention(thin) (@guaranteed NonTrivialFoo, @guaranteed NonTrivialFoo) -> () {
6566
func test_switch_two_nontrivial_unions(x: NonTrivialFoo, y: NonTrivialFoo) {
@@ -98,3 +99,4 @@ func test_switch_two_nontrivial_unions(x: NonTrivialFoo, y: NonTrivialFoo) {
9899
// CHECK: unreachable
99100
}
100101
}
102+
// CHECK: } // end sil function '$s6switch05test_A22_two_nontrivial_unions1x1yyAA13NonTrivialFooO_AFtF'

‎test/SILGen/switch_var.swift

Lines changed: 22 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -618,20 +618,16 @@ func test_multiple_patterns3() {
618618
switch f {
619619
// CHECK: switch_enum {{%.*}} : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
620620
case .A(let x, let n), .B(let n, let x), .C(_, let x, let n):
621-
// CHECK: [[A]]({{%.*}} : @trivial $(Int, Double)):
622-
// CHECK: [[A_X:%.*]] = tuple_extract
623-
// CHECK: [[A_N:%.*]] = tuple_extract
621+
// CHECK: [[A]]([[A_TUP:%.*]] : @trivial $(Int, Double)):
622+
// CHECK: ([[A_X:%.*]], [[A_N:%.*]]) = destructure_tuple [[A_TUP]]
624623
// CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int, [[A_N]] : $Double)
625624

626-
// CHECK: [[B]]({{%.*}} : @trivial $(Double, Int)):
627-
// CHECK: [[B_N:%.*]] = tuple_extract
628-
// CHECK: [[B_X:%.*]] = tuple_extract
625+
// CHECK: [[B]]([[B_TUP:%.*]] : @trivial $(Double, Int)):
626+
// CHECK: ([[B_N:%.*]], [[B_X:%.*]]) = destructure_tuple [[B_TUP]]
629627
// CHECK: br [[CASE_BODY]]([[B_X]] : $Int, [[B_N]] : $Double)
630628

631-
// CHECK: [[C]]({{%.*}} : @trivial $(Int, Int, Double)):
632-
// CHECK: [[C__:%.*]] = tuple_extract
633-
// CHECK: [[C_X:%.*]] = tuple_extract
634-
// CHECK: [[C_N:%.*]] = tuple_extract
629+
// CHECK: [[C]]([[C_TUP:%.*]] : @trivial $(Int, Int, Double)):
630+
// CHECK: ([[C__:%.*]], [[C_X:%.*]], [[C_N:%.*]]) = destructure_tuple [[C_TUP]]
635631
// CHECK: br [[CASE_BODY]]([[C_X]] : $Int, [[C_N]] : $Double)
636632

637633
// CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : @trivial $Int, [[BODY_N:%.*]] : @trivial $Double):
@@ -652,27 +648,23 @@ func test_multiple_patterns4() {
652648
switch b {
653649
// CHECK: switch_enum {{%.*}} : $Bar, case #Bar.Y!enumelt.1: [[Y:bb[0-9]+]], case #Bar.Z!enumelt.1: [[Z:bb[0-9]+]]
654650
case .Y(.A(let x, _), _), .Y(.B(_, let x), _), .Y(.C, let x), .Z(let x, _):
655-
// CHECK: [[Y]]({{%.*}} : @trivial $(Foo, Int)):
656-
// CHECK: [[Y_F:%.*]] = tuple_extract
657-
// CHECK: [[Y_X:%.*]] = tuple_extract
651+
// CHECK: [[Y]]([[Y_TUP:%.*]] : @trivial $(Foo, Int)):
652+
// CHECK: ([[Y_F:%.*]], [[Y_X:%.*]]) = destructure_tuple [[Y_TUP]]
658653
// CHECK: switch_enum [[Y_F]] : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
659654

660-
// CHECK: [[A]]({{%.*}} : @trivial $(Int, Double)):
661-
// CHECK: [[A_X:%.*]] = tuple_extract
662-
// CHECK: [[A_N:%.*]] = tuple_extract
655+
// CHECK: [[A]]([[A_TUP:%.*]] : @trivial $(Int, Double)):
656+
// CHECK: ([[A_X:%.*]], [[A_N:%.*]]) = destructure_tuple [[A_TUP]]
663657
// CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int)
664658

665-
// CHECK: [[B]]({{%.*}} : @trivial $(Double, Int)):
666-
// CHECK: [[B_N:%.*]] = tuple_extract
667-
// CHECK: [[B_X:%.*]] = tuple_extract
659+
// CHECK: [[B]]([[B_TUP:%.*]] : @trivial $(Double, Int)):
660+
// CHECK: ([[B_N:%.*]], [[B_X:%.*]]) = destructure_tuple [[B_TUP]]
668661
// CHECK: br [[CASE_BODY]]([[B_X]] : $Int)
669662

670663
// CHECK: [[C]]({{%.*}} : @trivial $(Int, Int, Double)):
671664
// CHECK: br [[CASE_BODY]]([[Y_X]] : $Int)
672665

673-
// CHECK: [[Z]]({{%.*}} : @trivial $(Int, Foo)):
674-
// CHECK: [[Z_X:%.*]] = tuple_extract
675-
// CHECK: [[Z_F:%.*]] = tuple_extract
666+
// CHECK: [[Z]]([[Z_TUP:%.*]] : @trivial $(Int, Foo)):
667+
// CHECK: ([[Z_X:%.*]], [[Z_F:%.*]]) = destructure_tuple [[Z_TUP]]
676668
// CHECK: br [[CASE_BODY]]([[Z_X]] : $Int)
677669

678670
// CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : @trivial $Int):
@@ -690,27 +682,23 @@ func test_multiple_patterns5() {
690682
switch b {
691683
// CHECK: switch_enum {{%.*}} : $Bar, case #Bar.Y!enumelt.1: [[Y:bb[0-9]+]], case #Bar.Z!enumelt.1: [[Z:bb[0-9]+]]
692684
case .Y(.A(var x, _), _), .Y(.B(_, var x), _), .Y(.C, var x), .Z(var x, _):
693-
// CHECK: [[Y]]({{%.*}} : @trivial $(Foo, Int)):
694-
// CHECK: [[Y_F:%.*]] = tuple_extract
695-
// CHECK: [[Y_X:%.*]] = tuple_extract
685+
// CHECK: [[Y]]([[Y_TUP:%.*]] : @trivial $(Foo, Int)):
686+
// CHECK: ([[Y_F:%.*]], [[Y_X:%.*]]) = destructure_tuple [[Y_TUP]]
696687
// CHECK: switch_enum [[Y_F]] : $Foo, case #Foo.A!enumelt.1: [[A:bb[0-9]+]], case #Foo.B!enumelt.1: [[B:bb[0-9]+]], case #Foo.C!enumelt.1: [[C:bb[0-9]+]]
697688

698-
// CHECK: [[A]]({{%.*}} : @trivial $(Int, Double)):
699-
// CHECK: [[A_X:%.*]] = tuple_extract
700-
// CHECK: [[A_N:%.*]] = tuple_extract
689+
// CHECK: [[A]]([[A_TUP:%.*]] : @trivial $(Int, Double)):
690+
// CHECK: ([[A_X:%.*]], [[A_N:%.*]]) = destructure_tuple [[A_TUP]]
701691
// CHECK: br [[CASE_BODY:bb[0-9]+]]([[A_X]] : $Int)
702692

703-
// CHECK: [[B]]({{%.*}} : @trivial $(Double, Int)):
704-
// CHECK: [[B_N:%.*]] = tuple_extract
705-
// CHECK: [[B_X:%.*]] = tuple_extract
693+
// CHECK: [[B]]([[B_TUP:%.*]] : @trivial $(Double, Int)):
694+
// CHECK: ([[B_N:%.*]], [[B_X:%.*]]) = destructure_tuple [[B_TUP]]
706695
// CHECK: br [[CASE_BODY]]([[B_X]] : $Int)
707696

708697
// CHECK: [[C]]({{%.*}} : @trivial $(Int, Int, Double)):
709698
// CHECK: br [[CASE_BODY]]([[Y_X]] : $Int)
710699

711-
// CHECK: [[Z]]({{%.*}} : @trivial $(Int, Foo)):
712-
// CHECK: [[Z_X:%.*]] = tuple_extract
713-
// CHECK: [[Z_F:%.*]] = tuple_extract
700+
// CHECK: [[Z]]([[Z_TUP:%.*]] : @trivial $(Int, Foo)):
701+
// CHECK: ([[Z_X:%.*]], [[Z_F:%.*]]) = destructure_tuple [[Z_TUP]]
714702
// CHECK: br [[CASE_BODY]]([[Z_X]] : $Int)
715703

716704
// CHECK: [[CASE_BODY]]([[BODY_X:%.*]] : @trivial $Int):

0 commit comments

Comments
 (0)