1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
//===--- Condition.cpp - Implements the SILGen Condition class ------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
#include "Condition.h"
#include "Initialization.h"
#include "ManagedValue.h"
#include "RValue.h"
#include "swift/SIL/SILArgument.h"
#include "swift/SIL/SILFunction.h"
using namespace swift;
using namespace Lowering;
void Condition::enter(SILGenFunction &SGF, SILBasicBlock *destBB) {
assert(destBB && "Cannot reenter a finished block.");
SGF.B.emitBlock(destBB);
}
/// Extract the last SILLocation used in BB.
static SILLocation getContinuationLoc(SILBasicBlock &BB, SILLocation Fallback) {
for (auto I = BB.rbegin(); I != BB.rend(); ++I)
if (auto L = I->getLoc())
return L;
return Fallback;
}
void Condition::exit(SILGenFunction &SGF, SILBasicBlock *destBB,
ArrayRef<SILValue> Args) {
// If the current point it reachable, branch to the continuation block.
if (!SGF.B.hasValidInsertionPoint())
return;
SGF.B.createBranch(getContinuationLoc(*SGF.B.getInsertionBB(), Loc),
ContBB, Args);
}
SILBasicBlock *Condition::complete(SILGenFunction &SGF) {
assert(!TrueBB && "enterTrue is always called.");
if (FalseBB) {
assert(ContBB->getNumArguments() == 0 &&
"block arguments require a non-empty false path.");
SILGenBuilder(SGF.B, FalseBB).createBranch(Loc, ContBB);
FalseBB = nullptr;
}
SGF.B.emitBlock(ContBB);
return ContBB;
}
ConditionalValue::ConditionalValue(SILGenFunction &SGF, SGFContext C,
SILLocation loc,
const TypeLowering &valueTL)
: SGF(SGF), tl(valueTL), contBB(SGF.createBasicBlock()), loc(loc)
{
if (tl.isAddressOnly()) {
// If the result type is address-only, get a result buffer for it.
result = SGF.getBufferForExprResult(loc, tl.getLoweredType(), C);
} else {
// Otherwise, add a BB arg to the continuation block to receive loadable
// result.
result =
contBB->createPhiArgument(tl.getLoweredType(), OwnershipKind::Owned);
}
}
SGFContext ConditionalValue::enterBranch(SILBasicBlock *bb) {
if (bb) {
assert(!SGF.B.hasValidInsertionPoint() && "already in a branch");
SGF.B.emitBlock(bb);
}
assert(!scope.has_value() && "already have a scope");
// Start a scope for the current branch.
scope.emplace(SGF.Cleanups, CleanupLocation(loc));
// Code emitted in the branch can emit into our buffer for address-only
// conditionals.
if (tl.isAddressOnly()) {
assert(!currentInitialization && "already have an initialization?!");
currentInitialization = SGF.useBufferAsTemporary(result, tl);
return SGFContext(currentInitialization.get());
}
/// TODO: We might be able to coordinate AllowPlusZero across conditionals
/// if all branches of the conditional can actually produce a +0 result.
return SGFContext();
}
void ConditionalValue::exitBranch(RValue &&condResult) {
assert(scope.has_value() && "no current scope?!");
if (tl.isAddressOnly()) {
// Transfer the result into our buffer if it wasn't emitted in-place
// already.
assert(currentInitialization && "no current initialization?!");
std::move(condResult).forwardInto(SGF, loc,
currentInitialization.release());
scope.reset();
SGF.B.createBranch(loc, contBB);
} else {
SILValue resultVal = std::move(condResult).forwardAsSingleValue(SGF, loc);
// Branch with the result as a BB argument.
scope.reset();
SGF.B.createBranch(loc, contBB, resultVal);
}
}
ManagedValue ConditionalValue::complete() {
assert(!SGF.B.hasValidInsertionPoint() && "still in a branch");
assert(!scope && "still in a branch scope");
assert(!currentInitialization && "still in a branch initialization");
SGF.B.emitBlock(contBB);
return SGF.emitManagedRValueWithCleanup(result);
}
|
