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

[passes] Replace the old invalidation lattice with a new invalidation scheme.

Browse Source 
The old invalidation lattice was incorrect because changes to control flow could cause changes to the
call graph, so we've decided to change the way passes invalidate analysis.  In the new scheme, the lattice
is replaced with a list of traits that passes preserve or invalidate. The current traits are Calls and Branches.
Now, passes report which traits they preserve, which is the opposite of the previous implementation where
passes needed to report what they invalidate.

Node: I tried to limit the changes in this commit to mechanical changes to ease the review. I will cleanup some
of the code in a following commit.

Swift SVN r26449
This commit is contained in:
Nadav Rotem
2015-03-23 21:18:58 +00:00
parent 5b91651107
commit d78b376d07
49 changed files with 113 additions and 113 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
include/swift/SILAnalysis/AliasAnalysis.h
View File

@@ -127,9 +127,11 @@ public:
return getMemoryBehavior(Inst, V) == MemoryBehavior::MayHaveSideEffects; return getMemoryBehavior(Inst, V) == MemoryBehavior::MayHaveSideEffects;
} }
virtual void invalidate(InvalidationKind K) { AliasCache.clear(); } virtual void invalidate(SILAnalysis::PreserveKind K) { AliasCache.clear(); }
virtual void invalidate(SILFunction *, InvalidationKind K) { invalidate(K); } virtual void invalidate(SILFunction *, SILAnalysis::PreserveKind K) {
invalidate(K);
}
}; };
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,

32
include/swift/SILAnalysis/Analysis.h
View File

@@ -27,15 +27,21 @@ namespace swift {
/// The base class for all SIL-level analysis. /// The base class for all SIL-level analysis.
class SILAnalysis { class SILAnalysis {
public: public:
/// The invalidation Lattice. /// This is a list of values that allow passes to communicate to analysis
/// This is a hierarchy of invalidation messages that are sent to analysis /// which traits of the code were preserved. Based on this information
/// objects. Every invalidation kind invalidates the levels before it. For /// the analysis can decide if it needs to be invalidated. This information
/// example, CFG invalidates Instructions and CFG. /// may refer to a specific function or to a list of functions depending
enum class InvalidationKind { /// on the context in which it is used.
Instructions, // Invalidate instruction-related analysis. enum PreserveKind : unsigned {
CFG, // The control flow changes. Nothing = 0x0, // The pass does not preserve any analysis trait.
CallGraph, // The call graph changed. Calls = 0x1, // The pass did not modify any calls.
All, // Invalidate everything. Branches = 0x2, // The pass did not modify any branches.
// This is a list of combined traits that is defined to make the use of
/// the invalidation API more convenient.
ProgramFlow = Calls | Branches, // The pass changed some instructions but
// did not change the overall flow
// of the code.
}; };
/// A list of the known analysis. /// A list of the known analysis.
@@ -82,10 +88,10 @@ namespace swift {
bool isLocked() { return invalidationLock; } bool isLocked() { return invalidationLock; }
/// Invalidate all information in this analysis. /// Invalidate all information in this analysis.
virtual void invalidate(InvalidationKind K) {} virtual void invalidate(PreserveKind K) {}
/// Invalidate all of the information for a specific function. /// Invalidate all of the information for a specific function.
virtual void invalidate(SILFunction *F, InvalidationKind K) {} virtual void invalidate(SILFunction *F, PreserveKind K) {}
/// Verify the state of this analysis. /// Verify the state of this analysis.
virtual void verify() const {} virtual void verify() const {}
@@ -109,12 +115,12 @@ namespace swift {
return S->getKind() == AnalysisKind::CompleteFuncs; return S->getKind() == AnalysisKind::CompleteFuncs;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(PreserveKind K) {
IsModulePending = true; IsModulePending = true;
HasChanged = true; HasChanged = true;
} }
virtual void invalidate(SILFunction* F, InvalidationKind) { virtual void invalidate(SILFunction* F, PreserveKind) {
PendingFuncs.insert(F); PendingFuncs.insert(F);
HasChanged = true; HasChanged = true;
} }

6
include/swift/SILAnalysis/CallGraphAnalysis.h
View File

@@ -356,15 +356,15 @@ public:
return *CG; return *CG;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::CallGraph) { if (!(K & PreserveKind::Calls)) {
BottomUpFunctionOrder.clear(); BottomUpFunctionOrder.clear();
delete CG; delete CG;
CG = nullptr; CG = nullptr;
} }
} }
virtual void invalidate(SILFunction*, InvalidationKind K) { invalidate(K); } virtual void invalidate(SILFunction*, SILAnalysis::PreserveKind K) { invalidate(K); }
virtual void verify() const; virtual void verify() const;
}; };

10
include/swift/SILAnalysis/ClassHierarchyAnalysis.h
View File

@@ -42,12 +42,8 @@ public:
return S->getKind() == AnalysisKind::ClassHierarchyAnalysis; return S->getKind() == AnalysisKind::ClassHierarchyAnalysis;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::All) { // Nothing can invalidate the ClassHierarchyAnalysis!
DirectSubclassesCache.clear();
IndirectSubclassesCache.clear();
init();
}
} }
@@ -80,7 +76,7 @@ public:
IndirectSubclassesCache[C].size() > 0; IndirectSubclassesCache[C].size() > 0;
} }
virtual void invalidate(SILFunction *F, InvalidationKind K) { virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) {
invalidate(K); invalidate(K);
} }

10
include/swift/SILAnalysis/DominanceAnalysis.h
View File

@@ -60,11 +60,9 @@ class SILInstruction;
return S->getKind() == AnalysisKind::Dominance; return S->getKind() == AnalysisKind::Dominance;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
assert(!isLocked() && "invalidating a locked analysis?!"); assert(!isLocked() && "invalidating a locked analysis?!");
// FIXME: Invalidating the call graph should not invalidate the domtrees if (!(K & PreserveKind::Branches)) {
// of all functions.
if (K >= InvalidationKind::CFG) {
// Delete Dominance Info. // Delete Dominance Info.
for (auto D : DomInfo) for (auto D : DomInfo)
delete D.second; delete D.second;
@@ -79,8 +77,8 @@ class SILInstruction;
} }
} }
virtual void invalidate(SILFunction* F, InvalidationKind K) { virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::CFG) { if (!(K & PreserveKind::Branches)) {
auto &it= DomInfo.FindAndConstruct(F); auto &it= DomInfo.FindAndConstruct(F);
if (it.second) { if (it.second) {
delete it.second; delete it.second;

8
include/swift/SILAnalysis/IVAnalysis.h
View File

@@ -94,22 +94,18 @@ public:
return *IVInfos[F]; return *IVInfos[F];
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::Instructions) {
for (auto IVI : IVInfos) for (auto IVI : IVInfos)
delete IVI.second; delete IVI.second;
IVInfos.clear(); IVInfos.clear();
}
} }
virtual void invalidate(SILFunction *F, InvalidationKind K) { virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::Instructions) {
if (IVInfos.count(F)) { if (IVInfos.count(F)) {
delete IVInfos[F]; delete IVInfos[F];
IVInfos.erase(F); IVInfos.erase(F);
} }
}
} }
private: private:

8
include/swift/SILAnalysis/LoopAnalysis.h
View File

@@ -46,8 +46,8 @@ public:
return S->getKind() == AnalysisKind::LoopInfo; return S->getKind() == AnalysisKind::LoopInfo;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::CFG) { if (!(K & PreserveKind::Branches)) {
for (auto LI : LoopInfos) for (auto LI : LoopInfos)
delete LI.second; delete LI.second;
@@ -56,8 +56,8 @@ public:
} }
} }
virtual void invalidate(SILFunction* F, InvalidationKind K) { virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::CFG) { if (!(K & PreserveKind::Branches)) {
if (LoopInfos.count(F)) { if (LoopInfos.count(F)) {
delete LoopInfos[F]; delete LoopInfos[F];
LoopInfos.erase(F); LoopInfos.erase(F);

10
include/swift/SILAnalysis/PostOrderAnalysis.h
View File

@@ -98,16 +98,14 @@ public:
return S->getKind() == AnalysisKind::PostOrder; return S->getKind() == AnalysisKind::PostOrder;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
// FIXME: Invalidating the call graph should not invalidate the domtrees if (!(K & PreserveKind::Branches)) {
// of all functions.
if (K >= InvalidationKind::CFG) {
FunctionToPOTMap.clear(); FunctionToPOTMap.clear();
} }
} }
virtual void invalidate(SILFunction* F, InvalidationKind K) { virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::CFG) { if (!(K & PreserveKind::Branches)) {
// Invalidate just this one function. We will lazily recompute it. // Invalidate just this one function. We will lazily recompute it.
FunctionToPOTMap[F].IsInvalidated = true; FunctionToPOTMap[F].IsInvalidated = true;
} }

6
include/swift/SILAnalysis/RCIdentityAnalysis.h
View File

@@ -52,14 +52,12 @@ public:
return S->getKind() == AnalysisKind::RCIdentity; return S->getKind() == AnalysisKind::RCIdentity;
} }
virtual void invalidate(InvalidationKind K) { virtual void invalidate(SILAnalysis::PreserveKind K) {
if (K >= InvalidationKind::Instructions) {
Cache.clear(); Cache.clear();
}
} }
// TODO: Add function specific cache to save compile time. // TODO: Add function specific cache to save compile time.
virtual void invalidate(SILFunction* F, InvalidationKind K) { virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) {
invalidate(K); invalidate(K);
} }

4
include/swift/SILPasses/PassManager.h
View File

@@ -93,7 +93,7 @@ class SILPassManager {
void scheduleAnotherIteration() { anotherIteration = true; } void scheduleAnotherIteration() { anotherIteration = true; }
/// \brief Broadcast the invalidation of the module to all analysis. /// \brief Broadcast the invalidation of the module to all analysis.
void invalidateAnalysis(SILAnalysis::InvalidationKind K) { void invalidateAnalysis(SILAnalysis::PreserveKind K) {
for (auto AP : Analysis) for (auto AP : Analysis)
if (!AP->isLocked()) if (!AP->isLocked())
AP->invalidate(K); AP->invalidate(K);
@@ -101,7 +101,7 @@ class SILPassManager {
/// \brief Broadcast the invalidation of the function to all analysis. /// \brief Broadcast the invalidation of the function to all analysis.
void invalidateAnalysis(SILFunction *F, void invalidateAnalysis(SILFunction *F,
SILAnalysis::InvalidationKind K) { SILAnalysis::PreserveKind K) {
// Invalidate the analysis (unless they are locked) // Invalidate the analysis (unless they are locked)
for (auto AP : Analysis) for (auto AP : Analysis)
if (!AP->isLocked()) if (!AP->isLocked())

6
include/swift/SILPasses/Transforms.h
View File

@@ -81,7 +81,7 @@ namespace swift {
protected: protected:
SILFunction *getFunction() { return F; } SILFunction *getFunction() { return F; }
void invalidateAnalysis(SILAnalysis::InvalidationKind K) { void invalidateAnalysis(SILAnalysis::PreserveKind K) {
PM->invalidateAnalysis(F, K); PM->invalidateAnalysis(F, K);
} }
}; };
@@ -108,12 +108,12 @@ namespace swift {
/// Invalidate all of functions in the module, using invalidation /// Invalidate all of functions in the module, using invalidation
/// information \p K. /// information \p K.
void invalidateAnalysis(SILAnalysis::InvalidationKind K) { void invalidateAnalysis(SILAnalysis::PreserveKind K) {
PM->invalidateAnalysis(K); PM->invalidateAnalysis(K);
} }
/// Invalidate only the function \p F, using invalidation information \p K. /// Invalidate only the function \p F, using invalidation information \p K.
void invalidateAnalysis(SILFunction *F, SILAnalysis::InvalidationKind K) { void invalidateAnalysis(SILFunction *F, SILAnalysis::PreserveKind K) {
PM->invalidateAnalysis(F, K); PM->invalidateAnalysis(F, K);
} }

2
lib/SILPasses/AllocBoxToStack.cpp
View File

@@ -790,7 +790,7 @@ class AllocBoxToStack : public SILFunctionTransform {
if (!Promotable.empty()) { if (!Promotable.empty()) {
auto Count = rewritePromotedBoxes(Promotable, ElidedOperands, Returns); auto Count = rewritePromotedBoxes(Promotable, ElidedOperands, Returns);
NumStackPromoted += Count; NumStackPromoted += Count;
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
} }

2
lib/SILPasses/ArrayBoundsCheckOpts.cpp
View File

@@ -1135,7 +1135,7 @@ public:
} }
if (Changed) if (Changed)
PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions); PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::ProgramFlow);
} }
}; };
} }

8
lib/SILPasses/COWArrayOpt.cpp
View File

@@ -891,7 +891,7 @@ class COWArrayOptPass : public SILFunctionTransform
HasChanged |= COWArrayOpt(RCIA, L, DA).run(); HasChanged |= COWArrayOpt(RCIA, L, DA).run();
if (HasChanged) if (HasChanged)
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SIL COW Array Optimization"; } StringRef getName() override { return "SIL COW Array Optimization"; }
@@ -1602,7 +1602,7 @@ void ArrayPropertiesSpecializer::specializeLoopNest() {
// We have potentially cloned a loop - invalidate loop info. // We have potentially cloned a loop - invalidate loop info.
LoopAnalysis->invalidate(Header->getParent(), LoopAnalysis->invalidate(Header->getParent(),
SILAnalysis::InvalidationKind::CFG); SILAnalysis::PreserveKind::Nothing);
} }
namespace { namespace {
@@ -1658,10 +1658,10 @@ class SwiftArrayOptPass : public SILFunctionTransform {
DEBUG(getFunction()->viewCFG()); DEBUG(getFunction()->viewCFG());
} }
// We preserve the dominator tree.
if (HasChanged) { if (HasChanged) {
// We preserve the dominator tree. Let's invalidate everything else.
DA->lockInvalidation(); DA->lockInvalidation();
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
DA->unlockInvalidation(); DA->unlockInvalidation();
} }
} }

2
lib/SILPasses/CSE.cpp
View File

@@ -608,7 +608,7 @@ class SILCSE : public SILFunctionTransform {
CSE C; CSE C;
if (C.processFunction(*getFunction(), DA->getDomInfo(getFunction()))) if (C.processFunction(*getFunction(), DA->getDomInfo(getFunction())))
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "CSE"; } StringRef getName() override { return "CSE"; }

2
lib/SILPasses/CapturePromotion.cpp
View File

@@ -965,7 +965,7 @@ class CapturePromotionPass : public SILModuleTransform {
processFunction(&F, Worklist); processFunction(&F, Worklist);
if (!Worklist.empty()) if (!Worklist.empty())
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
while (!Worklist.empty()) while (!Worklist.empty())
processFunction(Worklist.pop_back_val(), Worklist); processFunction(Worklist.pop_back_val(), Worklist);

2
lib/SILPasses/CapturePropagation.cpp
View File

@@ -330,7 +330,7 @@ void CapturePropagation::run() {
// this conservative in case someone implements interprocedural/dynamic call // this conservative in case someone implements interprocedural/dynamic call
// graph analysis later. // graph analysis later.
if (HasChanged) if (HasChanged)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
SILTransform *swift::createCapturePropagation() { SILTransform *swift::createCapturePropagation() {

2
lib/SILPasses/ClosureSpecializer.cpp
View File

@@ -741,7 +741,7 @@ public:
// Invalidate the call graph. // Invalidate the call graph.
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
// If for testing purposes we were asked to not eliminate dead closures, // If for testing purposes we were asked to not eliminate dead closures,
// return. // return.

2
lib/SILPasses/ConstantPropagation.cpp
View File

@@ -950,7 +950,7 @@ private:
void run() override { void run() override {
if (CCPFunctionBody(*getFunction(), EnableDiagnostics, if (CCPFunctionBody(*getFunction(), EnableDiagnostics,
getOptions().AssertConfig)) getOptions().AssertConfig))
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "Constant Propagation"; } StringRef getName() override { return "Constant Propagation"; }

14
lib/SILPasses/CopyForwarding.cpp
View File

@@ -312,8 +312,10 @@ public:
// global hoisting will be done. // global hoisting will be done.
DoGlobalHoisting = !F->isTransparent(); DoGlobalHoisting = !F->isTransparent();
if (HasChangedCFG) { if (HasChangedCFG) {
DomAnalysis->invalidate(F, SILAnalysis::InvalidationKind::CFG); // We are only invalidating the analysis that we use internally.
PostOrder->invalidate(F, SILAnalysis::InvalidationKind::CFG); // We'll invalidate the analysis that are used by other passes at the end.
DomAnalysis->invalidate(F, SILAnalysis::PreserveKind::Nothing);
PostOrder->invalidate(F, SILAnalysis::PreserveKind::Nothing);
} }
CurrentDef = SILValue(); CurrentDef = SILValue();
IsLoadedFrom = false; IsLoadedFrom = false;
@@ -984,7 +986,7 @@ class CopyForwardingPass : public SILFunctionTransform
// Perform NRVO // Perform NRVO
for (auto Copy : NRVOCopies) { for (auto Copy : NRVOCopies) {
performNRVO(Copy); performNRVO(Copy);
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
// Perform Copy Forwarding. // Perform Copy Forwarding.
@@ -1008,9 +1010,11 @@ class CopyForwardingPass : public SILFunctionTransform
} while (Forwarding.hasForwardedToCopy()); } while (Forwarding.hasForwardedToCopy());
} }
if (Forwarding.hasChangedCFG()) if (Forwarding.hasChangedCFG())
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); // We've split critical edges so we can't preserve CFG, but we did not
// change calls so we can preserve them.
invalidateAnalysis(SILAnalysis::PreserveKind::Calls);
else else
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "Copy Forwarding"; } StringRef getName() override { return "Copy Forwarding"; }

2
lib/SILPasses/CropOverflowChecks.cpp
View File

@@ -194,7 +194,7 @@ public:
if (Changed) if (Changed)
PM->invalidateAnalysis(getFunction(), PM->invalidateAnalysis(getFunction(),
SILAnalysis::InvalidationKind::Instructions); SILAnalysis::PreserveKind::ProgramFlow);
} }
/// Return True if the relationship \p Rel describes a known relation /// Return True if the relationship \p Rel describes a known relation

2
lib/SILPasses/DeadCodeElimination.cpp
View File

@@ -105,7 +105,7 @@ class DCE : public SILFunctionTransform {
markLive(*F); markLive(*F);
if (removeDead(*F)) if (removeDead(*F))
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
bool precomputeControlInfo(SILFunction &F); bool precomputeControlInfo(SILFunction &F);

4
lib/SILPasses/DeadFunctionElimination.cpp
View File

@@ -456,7 +456,7 @@ class SILDeadFuncElimination : public SILModuleTransform {
bool changed = deadFunctionElimination.eliminateFunctions(); bool changed = deadFunctionElimination.eliminateFunctions();
if (changed) if (changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Dead Function Elimination"; } StringRef getName() override { return "Dead Function Elimination"; }
@@ -475,7 +475,7 @@ class SILExternalFuncDefinitionsElimination : public SILModuleTransform {
bool changed = externalFunctionDefinitionsElimination.eliminateFunctions(); bool changed = externalFunctionDefinitionsElimination.eliminateFunctions();
if (changed) if (changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { StringRef getName() override {

2
lib/SILPasses/DeadObjectElimination.cpp
View File

@@ -293,7 +293,7 @@ class DeadObjectElimination : public SILFunctionTransform {
void run() override { void run() override {
if (processFunction(*getFunction())) if (processFunction(*getFunction()))
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "Dead Object Elimination"; } StringRef getName() override { return "Dead Object Elimination"; }

4
lib/SILPasses/DefiniteInitialization.cpp
View File

@@ -2003,13 +2003,13 @@ class DefiniteInitialization : public SILFunctionTransform {
void run() override { void run() override {
// Walk through and promote all of the alloc_box's that we can. // Walk through and promote all of the alloc_box's that we can.
if (checkDefiniteInitialization(*getFunction())) if (checkDefiniteInitialization(*getFunction()))
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
DEBUG(getFunction()->verify()); DEBUG(getFunction()->verify());
// Lower raw-sil only instructions used by this pass, like "assign". // Lower raw-sil only instructions used by this pass, like "assign".
if (lowerRawSILOperations(*getFunction())) if (lowerRawSILOperations(*getFunction()))
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Definite Initialization"; } StringRef getName() override { return "Definite Initialization"; }

6
lib/SILPasses/Devirtualizer.cpp
View File

@@ -83,7 +83,7 @@ public:
// Invalidate the analysis of caller functions. // Invalidate the analysis of caller functions.
for (auto *AI : DevirtualizedCalls) { for (auto *AI : DevirtualizedCalls) {
invalidateAnalysis(AI->getFunction(), invalidateAnalysis(AI->getFunction(),
SILAnalysis::InvalidationKind::CallGraph); SILAnalysis::PreserveKind::Branches);
} }
if (Changed) { if (Changed) {
@@ -102,7 +102,7 @@ public:
if (Specialized) { if (Specialized) {
// We've specialized some functions and created new ones, so invalidate // We've specialized some functions and created new ones, so invalidate
// the world. // the world.
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Branches);
} }
PM->scheduleAnotherIteration(); PM->scheduleAnotherIteration();
@@ -494,7 +494,7 @@ namespace {
Changed |= insertInlineCaches(AI, CHA); Changed |= insertInlineCaches(AI, CHA);
if (Changed) { if (Changed) {
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
} }

4
lib/SILPasses/DiagnoseUnreachable.cpp
View File

@@ -748,7 +748,7 @@ namespace {
class NoReturnFolding : public SILModuleTransform { class NoReturnFolding : public SILModuleTransform {
void run() override { void run() override {
performNoReturnFunctionProcessing(getModule()); performNoReturnFunctionProcessing(getModule());
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "NoReturnFolding"; } StringRef getName() override { return "NoReturnFolding"; }
@@ -764,7 +764,7 @@ namespace {
class DiagnoseUnreachable : public SILModuleTransform { class DiagnoseUnreachable : public SILModuleTransform {
void run() override { void run() override {
performSILDiagnoseUnreachable(getModule()); performSILDiagnoseUnreachable(getModule());
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Diagnose Unreachable"; } StringRef getName() override { return "Diagnose Unreachable"; }

2
lib/SILPasses/ExternalDefsToDecls.cpp
View File

@@ -27,7 +27,7 @@ class ExternalDefsToDecls : public SILModuleTransform {
if (isAvailableExternally(F.getLinkage()) && F.isDefinition()) if (isAvailableExternally(F.getLinkage()) && F.isDefinition())
F.convertToDeclaration(); F.convertToDeclaration();
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "External Defs To Decls"; } StringRef getName() override { return "External Defs To Decls"; }

2
lib/SILPasses/FunctionSignatureOpts.cpp
View File

@@ -838,7 +838,7 @@ public:
// If we changed anything, invalidate the call graph. // If we changed anything, invalidate the call graph.
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Function Signature Optimization"; } StringRef getName() override { return "Function Signature Optimization"; }

2
lib/SILPasses/GenericSpecializer.cpp
View File

@@ -50,7 +50,7 @@ public:
PM->scheduleAnotherIteration(); PM->scheduleAnotherIteration();
// Invalidate the call graph. // Invalidate the call graph.
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
} }

2
lib/SILPasses/GlobalARCOpts.cpp
View File

@@ -229,7 +229,7 @@ class GlobalARCOpts : public SILFunctionTransform {
auto *RCIA = getAnalysis<RCIdentityAnalysis>(); auto *RCIA = getAnalysis<RCIdentityAnalysis>();
if (processFunction(*getFunction(), false, AA, POTA, RCIA)) { if (processFunction(*getFunction(), false, AA, POTA, RCIA)) {
processFunction(*getFunction(), true, AA, POTA, RCIA); processFunction(*getFunction(), true, AA, POTA, RCIA);
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
} }

2
lib/SILPasses/GlobalOpt.cpp
View File

@@ -314,7 +314,7 @@ class SILGlobalOptPass : public SILModuleTransform
void run() override { void run() override {
DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>(); DominanceAnalysis *DA = PM->getAnalysis<DominanceAnalysis>();
if (SILGlobalOpt(getModule(), DA).run()) if (SILGlobalOpt(getModule(), DA).run())
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "SIL Global Optimization"; } StringRef getName() override { return "SIL Global Optimization"; }

8
lib/SILPasses/LICM.cpp
View File

@@ -460,9 +460,11 @@ public:
} }
if (Changed) { if (Changed) {
// TODO: Verify: We have updated the DominanceInfo and SILLoopInfo. It LA->lockInvalidation();
// should be safe not to invalidate the CFG. DA->lockInvalidation();
PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions); PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing);
LA->unlockInvalidation();
DA->unlockInvalidation();
} }
} }
}; };

2
lib/SILPasses/Link.cpp
View File

@@ -48,7 +48,7 @@ class SILLinker : public SILModuleTransform {
Changed |= M.linkFunction(&Fn, SILModule::LinkingMode::LinkAll); Changed |= M.linkFunction(&Fn, SILModule::LinkingMode::LinkAll);
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "SIL Linker"; } StringRef getName() override { return "SIL Linker"; }

2
lib/SILPasses/LoadStoreOpts.cpp
View File

@@ -1417,7 +1417,7 @@ class GlobalLoadStoreOpts : public SILFunctionTransform {
Changed = true; Changed = true;
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SIL Load Store Opts"; } StringRef getName() override { return "SIL Load Store Opts"; }

2
lib/SILPasses/LoopRotate.cpp
View File

@@ -576,7 +576,7 @@ class LoopRotation : public SILFunctionTransform {
// We preserve loop info and the dominator tree. // We preserve loop info and the dominator tree.
DA->lockInvalidation(); DA->lockInvalidation();
LA->lockInvalidation(); LA->lockInvalidation();
PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::All); PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing);
DA->unlockInvalidation(); DA->unlockInvalidation();
LA->unlockInvalidation(); LA->unlockInvalidation();
} }

2
lib/SILPasses/MandatoryInlining.cpp
View File

@@ -515,7 +515,7 @@ class MandatoryInlining : public SILModuleTransform {
M->eraseFunction(&F); M->eraseFunction(&F);
} }
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Mandatory Inlining"; } StringRef getName() override { return "Mandatory Inlining"; }

2
lib/SILPasses/MergeCondFail.cpp
View File

@@ -81,7 +81,7 @@ public:
} }
if (Changed) if (Changed)
PM->invalidateAnalysis(getFunction(), PM->invalidateAnalysis(getFunction(),
SILAnalysis::InvalidationKind::Instructions); SILAnalysis::PreserveKind::ProgramFlow);
} }
/// \brief Try to merge the cond_fail instructions. Returns true if any could /// \brief Try to merge the cond_fail instructions. Returns true if any could

6
lib/SILPasses/PerformanceInliner.cpp
View File

@@ -834,8 +834,8 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller,
// we expect it to have happened. // we expect it to have happened.
assert(Success && "Expected inliner to inline this function!"); assert(Success && "Expected inliner to inline this function!");
AI->eraseFromParent(); AI->eraseFromParent();
DA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG); DA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing);
LA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG); LA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing);
NumFunctionsInlined++; NumFunctionsInlined++;
Changed = true; Changed = true;
} }
@@ -910,7 +910,7 @@ public:
// Invalidate the call graph. // Invalidate the call graph.
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return PassName; } StringRef getName() override { return PassName; }

2
lib/SILPasses/PredictableMemOpt.cpp
View File

@@ -1000,7 +1000,7 @@ class PredictableMemoryOptimizations : public SILFunctionTransform {
/// The entry point to the transformation. /// The entry point to the transformation.
void run() override { void run() override {
if (optimizeMemoryAllocations(*getFunction())) if (optimizeMemoryAllocations(*getFunction()))
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Predictable Memory Opts"; } StringRef getName() override { return "Predictable Memory Opts"; }

2
lib/SILPasses/RemovePin.cpp
View File

@@ -109,7 +109,7 @@ public:
if (Changed) if (Changed)
PM->invalidateAnalysis(getFunction(), PM->invalidateAnalysis(getFunction(),
SILAnalysis::InvalidationKind::Instructions); SILAnalysis::PreserveKind::ProgramFlow);
} }
/// Pin uses are safe if they either mark a dependence or if it is the unpin we /// Pin uses are safe if they either mark a dependence or if it is the unpin we

2
lib/SILPasses/SILCleanup.cpp
View File

@@ -62,7 +62,7 @@ class SILCleanup : public swift::SILFunctionTransform {
/// The entry point to the transformation. /// The entry point to the transformation.
void run() override { void run() override {
cleanFunction(*getFunction()); cleanFunction(*getFunction());
invalidateAnalysis(SILAnalysis::InvalidationKind::All); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "SIL Cleanup"; } StringRef getName() override { return "SIL Cleanup"; }

2
lib/SILPasses/SILCodeMotion.cpp
View File

@@ -1398,7 +1398,7 @@ public:
" *****\n"); " *****\n");
if (processFunction(F, AA, POTA, RCIA, HoistReleases)) if (processFunction(F, AA, POTA, RCIA, HoistReleases))
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SIL Code Motion"; } StringRef getName() override { return "SIL Code Motion"; }

2
lib/SILPasses/SILCombine.cpp
View File

@@ -327,7 +327,7 @@ class SILCombine : public SILFunctionTransform {
SILCombiner Combiner(AA, getOptions().RemoveRuntimeAsserts); SILCombiner Combiner(AA, getOptions().RemoveRuntimeAsserts);
bool Changed = Combiner.runOnFunction(*getFunction()); bool Changed = Combiner.runOnFunction(*getFunction());
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SIL Combine"; } StringRef getName() override { return "SIL Combine"; }

2
lib/SILPasses/SILLowerAggregateInstrs.cpp
View File

@@ -260,7 +260,7 @@ class SILLowerAggregate : public SILFunctionTransform {
F->getName() << " *****\n"); F->getName() << " *****\n");
bool Changed = processFunction(*F); bool Changed = processFunction(*F);
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "Lower Aggregate Instructions"; } StringRef getName() override { return "Lower Aggregate Instructions"; }

2
lib/SILPasses/SILMem2Reg.cpp
View File

@@ -845,7 +845,7 @@ class SILMem2Reg : public SILFunctionTransform {
bool Changed = MemoryToRegisters(*F, DA->getDomInfo(F)).run(); bool Changed = MemoryToRegisters(*F, DA->getDomInfo(F)).run();
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SIL Mem2Reg"; } StringRef getName() override { return "SIL Mem2Reg"; }

2
lib/SILPasses/SILSROA.cpp
View File

@@ -311,7 +311,7 @@ class SILSROA : public SILFunctionTransform {
" *****\n"); " *****\n");
if (runSROAOnFunction(*F)) if (runSROAOnFunction(*F))
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "SROA"; } StringRef getName() override { return "SROA"; }

8
lib/SILPasses/SimplifyCFG.cpp
View File

@@ -2326,7 +2326,7 @@ bool SimplifyCFG::run() {
RU.run(); RU.run();
// Force dominator recomputation below. // Force dominator recomputation below.
PM->invalidateAnalysis(&Fn, SILAnalysis::InvalidationKind::CFG); PM->invalidateAnalysis(&Fn, SILAnalysis::PreserveKind::Nothing);
Changed = true; Changed = true;
} }
@@ -3074,7 +3074,7 @@ class SimplifyCFGPass : public SILFunctionTransform {
/// The entry point to the transformation. /// The entry point to the transformation.
void run() override { void run() override {
if (SimplifyCFG(*getFunction(), PM).run()) if (SimplifyCFG(*getFunction(), PM).run())
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Simplify CFG"; } StringRef getName() override { return "Simplify CFG"; }
@@ -3108,7 +3108,7 @@ public:
splitAllCriticalEdges(Fn, OnlyNonCondBrEdges, nullptr, nullptr); splitAllCriticalEdges(Fn, OnlyNonCondBrEdges, nullptr, nullptr);
if (Changed) if (Changed)
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); invalidateAnalysis(SILAnalysis::PreserveKind::Calls);
} }
StringRef getName() override { return "Split Critical Edges"; } StringRef getName() override { return "Split Critical Edges"; }
@@ -3122,7 +3122,7 @@ public:
/// The entry point to the transformation. /// The entry point to the transformation.
void run() override { void run() override {
if (SimplifyCFG(*getFunction(), PM).simplifyBlockArgs()) if (SimplifyCFG(*getFunction(), PM).simplifyBlockArgs())
invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); invalidateAnalysis(SILAnalysis::PreserveKind::Nothing);
} }
StringRef getName() override { return "Simplify Block Args"; } StringRef getName() override { return "Simplify Block Args"; }

2
lib/SILPasses/StripDebugInfo.cpp
View File

@@ -40,7 +40,7 @@ class StripDebugInfo : public swift::SILFunctionTransform {
/// The entry point to the transformation. /// The entry point to the transformation.
void run() override { void run() override {
stripFunction(getFunction()); stripFunction(getFunction());
invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow);
} }
StringRef getName() override { return "Strip Debug Info"; } StringRef getName() override { return "Strip Debug Info"; }