From d78b376d070a6f34d80da9973ecc8b3db672c673 Mon Sep 17 00:00:00 2001 From: Nadav Rotem Date: Mon, 23 Mar 2015 21:18:58 +0000 Subject: [PATCH] [passes] Replace the old invalidation lattice with a new invalidation scheme. 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 --- include/swift/SILAnalysis/AliasAnalysis.h | 6 ++-- include/swift/SILAnalysis/Analysis.h | 32 +++++++++++-------- include/swift/SILAnalysis/CallGraphAnalysis.h | 6 ++-- .../SILAnalysis/ClassHierarchyAnalysis.h | 10 ++---- include/swift/SILAnalysis/DominanceAnalysis.h | 10 +++--- include/swift/SILAnalysis/IVAnalysis.h | 8 ++--- include/swift/SILAnalysis/LoopAnalysis.h | 8 ++--- include/swift/SILAnalysis/PostOrderAnalysis.h | 10 +++--- .../swift/SILAnalysis/RCIdentityAnalysis.h | 6 ++-- include/swift/SILPasses/PassManager.h | 4 +-- include/swift/SILPasses/Transforms.h | 6 ++-- lib/SILPasses/AllocBoxToStack.cpp | 2 +- lib/SILPasses/ArrayBoundsCheckOpts.cpp | 2 +- lib/SILPasses/COWArrayOpt.cpp | 8 ++--- lib/SILPasses/CSE.cpp | 2 +- lib/SILPasses/CapturePromotion.cpp | 2 +- lib/SILPasses/CapturePropagation.cpp | 2 +- lib/SILPasses/ClosureSpecializer.cpp | 2 +- lib/SILPasses/ConstantPropagation.cpp | 2 +- lib/SILPasses/CopyForwarding.cpp | 14 +++++--- lib/SILPasses/CropOverflowChecks.cpp | 2 +- lib/SILPasses/DeadCodeElimination.cpp | 2 +- lib/SILPasses/DeadFunctionElimination.cpp | 4 +-- lib/SILPasses/DeadObjectElimination.cpp | 2 +- lib/SILPasses/DefiniteInitialization.cpp | 4 +-- lib/SILPasses/Devirtualizer.cpp | 6 ++-- lib/SILPasses/DiagnoseUnreachable.cpp | 4 +-- lib/SILPasses/ExternalDefsToDecls.cpp | 2 +- lib/SILPasses/FunctionSignatureOpts.cpp | 2 +- lib/SILPasses/GenericSpecializer.cpp | 2 +- lib/SILPasses/GlobalARCOpts.cpp | 2 +- lib/SILPasses/GlobalOpt.cpp | 2 +- lib/SILPasses/LICM.cpp | 8 +++-- lib/SILPasses/Link.cpp | 2 +- lib/SILPasses/LoadStoreOpts.cpp | 2 +- lib/SILPasses/LoopRotate.cpp | 2 +- lib/SILPasses/MandatoryInlining.cpp | 2 +- lib/SILPasses/MergeCondFail.cpp | 2 +- lib/SILPasses/PerformanceInliner.cpp | 6 ++-- lib/SILPasses/PredictableMemOpt.cpp | 2 +- lib/SILPasses/RemovePin.cpp | 2 +- lib/SILPasses/SILCleanup.cpp | 2 +- lib/SILPasses/SILCodeMotion.cpp | 2 +- lib/SILPasses/SILCombine.cpp | 2 +- lib/SILPasses/SILLowerAggregateInstrs.cpp | 2 +- lib/SILPasses/SILMem2Reg.cpp | 2 +- lib/SILPasses/SILSROA.cpp | 2 +- lib/SILPasses/SimplifyCFG.cpp | 8 ++--- lib/SILPasses/StripDebugInfo.cpp | 2 +- 49 files changed, 113 insertions(+), 113 deletions(-) diff --git a/include/swift/SILAnalysis/AliasAnalysis.h b/include/swift/SILAnalysis/AliasAnalysis.h index 31dbd1c9b50..ec556eff635 100644 --- a/include/swift/SILAnalysis/AliasAnalysis.h +++ b/include/swift/SILAnalysis/AliasAnalysis.h @@ -127,9 +127,11 @@ public: 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, diff --git a/include/swift/SILAnalysis/Analysis.h b/include/swift/SILAnalysis/Analysis.h index 8985db5698b..1d15c69ee84 100644 --- a/include/swift/SILAnalysis/Analysis.h +++ b/include/swift/SILAnalysis/Analysis.h @@ -27,15 +27,21 @@ namespace swift { /// The base class for all SIL-level analysis. class SILAnalysis { public: - /// The invalidation Lattice. - /// This is a hierarchy of invalidation messages that are sent to analysis - /// objects. Every invalidation kind invalidates the levels before it. For - /// example, CFG invalidates Instructions and CFG. - enum class InvalidationKind { - Instructions, // Invalidate instruction-related analysis. - CFG, // The control flow changes. - CallGraph, // The call graph changed. - All, // Invalidate everything. + /// This is a list of values that allow passes to communicate to analysis + /// which traits of the code were preserved. Based on this information + /// the analysis can decide if it needs to be invalidated. This information + /// may refer to a specific function or to a list of functions depending + /// on the context in which it is used. + enum PreserveKind : unsigned { + Nothing = 0x0, // The pass does not preserve any analysis trait. + Calls = 0x1, // The pass did not modify any calls. + 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. @@ -82,10 +88,10 @@ namespace swift { bool isLocked() { return invalidationLock; } /// 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. - virtual void invalidate(SILFunction *F, InvalidationKind K) {} + virtual void invalidate(SILFunction *F, PreserveKind K) {} /// Verify the state of this analysis. virtual void verify() const {} @@ -109,12 +115,12 @@ namespace swift { return S->getKind() == AnalysisKind::CompleteFuncs; } - virtual void invalidate(InvalidationKind K) { + virtual void invalidate(PreserveKind K) { IsModulePending = true; HasChanged = true; } - virtual void invalidate(SILFunction* F, InvalidationKind) { + virtual void invalidate(SILFunction* F, PreserveKind) { PendingFuncs.insert(F); HasChanged = true; } diff --git a/include/swift/SILAnalysis/CallGraphAnalysis.h b/include/swift/SILAnalysis/CallGraphAnalysis.h index a8826658658..3ee4fbe3505 100644 --- a/include/swift/SILAnalysis/CallGraphAnalysis.h +++ b/include/swift/SILAnalysis/CallGraphAnalysis.h @@ -356,15 +356,15 @@ public: return *CG; } - virtual void invalidate(InvalidationKind K) { - if (K >= InvalidationKind::CallGraph) { + virtual void invalidate(SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Calls)) { BottomUpFunctionOrder.clear(); delete CG; CG = nullptr; } } - virtual void invalidate(SILFunction*, InvalidationKind K) { invalidate(K); } + virtual void invalidate(SILFunction*, SILAnalysis::PreserveKind K) { invalidate(K); } virtual void verify() const; }; diff --git a/include/swift/SILAnalysis/ClassHierarchyAnalysis.h b/include/swift/SILAnalysis/ClassHierarchyAnalysis.h index b48dd8f4425..07bdbe6ee7e 100644 --- a/include/swift/SILAnalysis/ClassHierarchyAnalysis.h +++ b/include/swift/SILAnalysis/ClassHierarchyAnalysis.h @@ -42,12 +42,8 @@ public: return S->getKind() == AnalysisKind::ClassHierarchyAnalysis; } - virtual void invalidate(InvalidationKind K) { - if (K >= InvalidationKind::All) { - DirectSubclassesCache.clear(); - IndirectSubclassesCache.clear(); - init(); - } + virtual void invalidate(SILAnalysis::PreserveKind K) { + // Nothing can invalidate the ClassHierarchyAnalysis! } @@ -80,7 +76,7 @@ public: IndirectSubclassesCache[C].size() > 0; } - virtual void invalidate(SILFunction *F, InvalidationKind K) { + virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) { invalidate(K); } diff --git a/include/swift/SILAnalysis/DominanceAnalysis.h b/include/swift/SILAnalysis/DominanceAnalysis.h index 79d0daa8bab..39033570ce9 100644 --- a/include/swift/SILAnalysis/DominanceAnalysis.h +++ b/include/swift/SILAnalysis/DominanceAnalysis.h @@ -60,11 +60,9 @@ class SILInstruction; return S->getKind() == AnalysisKind::Dominance; } - virtual void invalidate(InvalidationKind K) { + virtual void invalidate(SILAnalysis::PreserveKind K) { assert(!isLocked() && "invalidating a locked analysis?!"); - // FIXME: Invalidating the call graph should not invalidate the domtrees - // of all functions. - if (K >= InvalidationKind::CFG) { + if (!(K & PreserveKind::Branches)) { // Delete Dominance Info. for (auto D : DomInfo) delete D.second; @@ -79,8 +77,8 @@ class SILInstruction; } } - virtual void invalidate(SILFunction* F, InvalidationKind K) { - if (K >= InvalidationKind::CFG) { + virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Branches)) { auto &it= DomInfo.FindAndConstruct(F); if (it.second) { delete it.second; diff --git a/include/swift/SILAnalysis/IVAnalysis.h b/include/swift/SILAnalysis/IVAnalysis.h index 96951fa3f72..28c2886c39a 100644 --- a/include/swift/SILAnalysis/IVAnalysis.h +++ b/include/swift/SILAnalysis/IVAnalysis.h @@ -94,22 +94,18 @@ public: return *IVInfos[F]; } - virtual void invalidate(InvalidationKind K) { - if (K >= InvalidationKind::Instructions) { + virtual void invalidate(SILAnalysis::PreserveKind K) { for (auto IVI : IVInfos) delete IVI.second; IVInfos.clear(); - } } - virtual void invalidate(SILFunction *F, InvalidationKind K) { - if (K >= InvalidationKind::Instructions) { + virtual void invalidate(SILFunction *F, SILAnalysis::PreserveKind K) { if (IVInfos.count(F)) { delete IVInfos[F]; IVInfos.erase(F); } - } } private: diff --git a/include/swift/SILAnalysis/LoopAnalysis.h b/include/swift/SILAnalysis/LoopAnalysis.h index c2d940b18fd..46a13a27c0f 100644 --- a/include/swift/SILAnalysis/LoopAnalysis.h +++ b/include/swift/SILAnalysis/LoopAnalysis.h @@ -46,8 +46,8 @@ public: return S->getKind() == AnalysisKind::LoopInfo; } - virtual void invalidate(InvalidationKind K) { - if (K >= InvalidationKind::CFG) { + virtual void invalidate(SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Branches)) { for (auto LI : LoopInfos) delete LI.second; @@ -56,8 +56,8 @@ public: } } - virtual void invalidate(SILFunction* F, InvalidationKind K) { - if (K >= InvalidationKind::CFG) { + virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Branches)) { if (LoopInfos.count(F)) { delete LoopInfos[F]; LoopInfos.erase(F); diff --git a/include/swift/SILAnalysis/PostOrderAnalysis.h b/include/swift/SILAnalysis/PostOrderAnalysis.h index a1dabb31a8a..2b6721c59f7 100644 --- a/include/swift/SILAnalysis/PostOrderAnalysis.h +++ b/include/swift/SILAnalysis/PostOrderAnalysis.h @@ -98,16 +98,14 @@ public: return S->getKind() == AnalysisKind::PostOrder; } - virtual void invalidate(InvalidationKind K) { - // FIXME: Invalidating the call graph should not invalidate the domtrees - // of all functions. - if (K >= InvalidationKind::CFG) { + virtual void invalidate(SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Branches)) { FunctionToPOTMap.clear(); } } - virtual void invalidate(SILFunction* F, InvalidationKind K) { - if (K >= InvalidationKind::CFG) { + virtual void invalidate(SILFunction* F, SILAnalysis::PreserveKind K) { + if (!(K & PreserveKind::Branches)) { // Invalidate just this one function. We will lazily recompute it. FunctionToPOTMap[F].IsInvalidated = true; } diff --git a/include/swift/SILAnalysis/RCIdentityAnalysis.h b/include/swift/SILAnalysis/RCIdentityAnalysis.h index 5d90ced2b53..bea6f75c096 100644 --- a/include/swift/SILAnalysis/RCIdentityAnalysis.h +++ b/include/swift/SILAnalysis/RCIdentityAnalysis.h @@ -52,14 +52,12 @@ public: return S->getKind() == AnalysisKind::RCIdentity; } - virtual void invalidate(InvalidationKind K) { - if (K >= InvalidationKind::Instructions) { + virtual void invalidate(SILAnalysis::PreserveKind K) { Cache.clear(); - } } // 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); } diff --git a/include/swift/SILPasses/PassManager.h b/include/swift/SILPasses/PassManager.h index b5d69a8bf86..8aaaed747bf 100644 --- a/include/swift/SILPasses/PassManager.h +++ b/include/swift/SILPasses/PassManager.h @@ -93,7 +93,7 @@ class SILPassManager { void scheduleAnotherIteration() { anotherIteration = true; } /// \brief Broadcast the invalidation of the module to all analysis. - void invalidateAnalysis(SILAnalysis::InvalidationKind K) { + void invalidateAnalysis(SILAnalysis::PreserveKind K) { for (auto AP : Analysis) if (!AP->isLocked()) AP->invalidate(K); @@ -101,7 +101,7 @@ class SILPassManager { /// \brief Broadcast the invalidation of the function to all analysis. void invalidateAnalysis(SILFunction *F, - SILAnalysis::InvalidationKind K) { + SILAnalysis::PreserveKind K) { // Invalidate the analysis (unless they are locked) for (auto AP : Analysis) if (!AP->isLocked()) diff --git a/include/swift/SILPasses/Transforms.h b/include/swift/SILPasses/Transforms.h index 9d65e128743..6981e60542d 100644 --- a/include/swift/SILPasses/Transforms.h +++ b/include/swift/SILPasses/Transforms.h @@ -81,7 +81,7 @@ namespace swift { protected: SILFunction *getFunction() { return F; } - void invalidateAnalysis(SILAnalysis::InvalidationKind K) { + void invalidateAnalysis(SILAnalysis::PreserveKind K) { PM->invalidateAnalysis(F, K); } }; @@ -108,12 +108,12 @@ namespace swift { /// Invalidate all of functions in the module, using invalidation /// information \p K. - void invalidateAnalysis(SILAnalysis::InvalidationKind K) { + void invalidateAnalysis(SILAnalysis::PreserveKind K) { PM->invalidateAnalysis(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); } diff --git a/lib/SILPasses/AllocBoxToStack.cpp b/lib/SILPasses/AllocBoxToStack.cpp index a08a200cc00..697e8b8ee26 100644 --- a/lib/SILPasses/AllocBoxToStack.cpp +++ b/lib/SILPasses/AllocBoxToStack.cpp @@ -790,7 +790,7 @@ class AllocBoxToStack : public SILFunctionTransform { if (!Promotable.empty()) { auto Count = rewritePromotedBoxes(Promotable, ElidedOperands, Returns); NumStackPromoted += Count; - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } } diff --git a/lib/SILPasses/ArrayBoundsCheckOpts.cpp b/lib/SILPasses/ArrayBoundsCheckOpts.cpp index bcdf75542a6..5d66453f42a 100644 --- a/lib/SILPasses/ArrayBoundsCheckOpts.cpp +++ b/lib/SILPasses/ArrayBoundsCheckOpts.cpp @@ -1135,7 +1135,7 @@ public: } if (Changed) - PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions); + PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::ProgramFlow); } }; } diff --git a/lib/SILPasses/COWArrayOpt.cpp b/lib/SILPasses/COWArrayOpt.cpp index a9ca44d433b..63fe2704c50 100644 --- a/lib/SILPasses/COWArrayOpt.cpp +++ b/lib/SILPasses/COWArrayOpt.cpp @@ -891,7 +891,7 @@ class COWArrayOptPass : public SILFunctionTransform HasChanged |= COWArrayOpt(RCIA, L, DA).run(); if (HasChanged) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SIL COW Array Optimization"; } @@ -1602,7 +1602,7 @@ void ArrayPropertiesSpecializer::specializeLoopNest() { // We have potentially cloned a loop - invalidate loop info. LoopAnalysis->invalidate(Header->getParent(), - SILAnalysis::InvalidationKind::CFG); + SILAnalysis::PreserveKind::Nothing); } namespace { @@ -1658,10 +1658,10 @@ class SwiftArrayOptPass : public SILFunctionTransform { DEBUG(getFunction()->viewCFG()); } - // We preserve the dominator tree. if (HasChanged) { + // We preserve the dominator tree. Let's invalidate everything else. DA->lockInvalidation(); - invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); DA->unlockInvalidation(); } } diff --git a/lib/SILPasses/CSE.cpp b/lib/SILPasses/CSE.cpp index 8b01c85e48c..16ec3da3f2f 100644 --- a/lib/SILPasses/CSE.cpp +++ b/lib/SILPasses/CSE.cpp @@ -608,7 +608,7 @@ class SILCSE : public SILFunctionTransform { CSE C; if (C.processFunction(*getFunction(), DA->getDomInfo(getFunction()))) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "CSE"; } diff --git a/lib/SILPasses/CapturePromotion.cpp b/lib/SILPasses/CapturePromotion.cpp index 7f0ca6eaf07..87ef730818a 100644 --- a/lib/SILPasses/CapturePromotion.cpp +++ b/lib/SILPasses/CapturePromotion.cpp @@ -965,7 +965,7 @@ class CapturePromotionPass : public SILModuleTransform { processFunction(&F, Worklist); if (!Worklist.empty()) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); while (!Worklist.empty()) processFunction(Worklist.pop_back_val(), Worklist); diff --git a/lib/SILPasses/CapturePropagation.cpp b/lib/SILPasses/CapturePropagation.cpp index 10f45fb35a6..8bc693860a0 100644 --- a/lib/SILPasses/CapturePropagation.cpp +++ b/lib/SILPasses/CapturePropagation.cpp @@ -330,7 +330,7 @@ void CapturePropagation::run() { // this conservative in case someone implements interprocedural/dynamic call // graph analysis later. if (HasChanged) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } SILTransform *swift::createCapturePropagation() { diff --git a/lib/SILPasses/ClosureSpecializer.cpp b/lib/SILPasses/ClosureSpecializer.cpp index 4a3494b4c94..560f6781e55 100644 --- a/lib/SILPasses/ClosureSpecializer.cpp +++ b/lib/SILPasses/ClosureSpecializer.cpp @@ -741,7 +741,7 @@ public: // Invalidate the call graph. if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); // If for testing purposes we were asked to not eliminate dead closures, // return. diff --git a/lib/SILPasses/ConstantPropagation.cpp b/lib/SILPasses/ConstantPropagation.cpp index 0975c8adb3c..41ce6f0cde7 100644 --- a/lib/SILPasses/ConstantPropagation.cpp +++ b/lib/SILPasses/ConstantPropagation.cpp @@ -950,7 +950,7 @@ private: void run() override { if (CCPFunctionBody(*getFunction(), EnableDiagnostics, getOptions().AssertConfig)) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "Constant Propagation"; } diff --git a/lib/SILPasses/CopyForwarding.cpp b/lib/SILPasses/CopyForwarding.cpp index f260df2f75d..27bdc44bd42 100644 --- a/lib/SILPasses/CopyForwarding.cpp +++ b/lib/SILPasses/CopyForwarding.cpp @@ -312,8 +312,10 @@ public: // global hoisting will be done. DoGlobalHoisting = !F->isTransparent(); if (HasChangedCFG) { - DomAnalysis->invalidate(F, SILAnalysis::InvalidationKind::CFG); - PostOrder->invalidate(F, SILAnalysis::InvalidationKind::CFG); + // We are only invalidating the analysis that we use internally. + // 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(); IsLoadedFrom = false; @@ -984,7 +986,7 @@ class CopyForwardingPass : public SILFunctionTransform // Perform NRVO for (auto Copy : NRVOCopies) { performNRVO(Copy); - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } // Perform Copy Forwarding. @@ -1008,9 +1010,11 @@ class CopyForwardingPass : public SILFunctionTransform } while (Forwarding.hasForwardedToCopy()); } 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 - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "Copy Forwarding"; } diff --git a/lib/SILPasses/CropOverflowChecks.cpp b/lib/SILPasses/CropOverflowChecks.cpp index 4fb4992ba74..97326f5e5a8 100644 --- a/lib/SILPasses/CropOverflowChecks.cpp +++ b/lib/SILPasses/CropOverflowChecks.cpp @@ -194,7 +194,7 @@ public: if (Changed) PM->invalidateAnalysis(getFunction(), - SILAnalysis::InvalidationKind::Instructions); + SILAnalysis::PreserveKind::ProgramFlow); } /// Return True if the relationship \p Rel describes a known relation diff --git a/lib/SILPasses/DeadCodeElimination.cpp b/lib/SILPasses/DeadCodeElimination.cpp index 472a2b8d80e..b125511154f 100644 --- a/lib/SILPasses/DeadCodeElimination.cpp +++ b/lib/SILPasses/DeadCodeElimination.cpp @@ -105,7 +105,7 @@ class DCE : public SILFunctionTransform { markLive(*F); if (removeDead(*F)) - invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } bool precomputeControlInfo(SILFunction &F); diff --git a/lib/SILPasses/DeadFunctionElimination.cpp b/lib/SILPasses/DeadFunctionElimination.cpp index 4e8e5dbe4fe..afe679ae671 100644 --- a/lib/SILPasses/DeadFunctionElimination.cpp +++ b/lib/SILPasses/DeadFunctionElimination.cpp @@ -456,7 +456,7 @@ class SILDeadFuncElimination : public SILModuleTransform { bool changed = deadFunctionElimination.eliminateFunctions(); if (changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Dead Function Elimination"; } @@ -475,7 +475,7 @@ class SILExternalFuncDefinitionsElimination : public SILModuleTransform { bool changed = externalFunctionDefinitionsElimination.eliminateFunctions(); if (changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { diff --git a/lib/SILPasses/DeadObjectElimination.cpp b/lib/SILPasses/DeadObjectElimination.cpp index e14edd65d91..559896e53e4 100644 --- a/lib/SILPasses/DeadObjectElimination.cpp +++ b/lib/SILPasses/DeadObjectElimination.cpp @@ -293,7 +293,7 @@ class DeadObjectElimination : public SILFunctionTransform { void run() override { if (processFunction(*getFunction())) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "Dead Object Elimination"; } diff --git a/lib/SILPasses/DefiniteInitialization.cpp b/lib/SILPasses/DefiniteInitialization.cpp index 1c10c4732b6..b4192fc0c11 100644 --- a/lib/SILPasses/DefiniteInitialization.cpp +++ b/lib/SILPasses/DefiniteInitialization.cpp @@ -2003,13 +2003,13 @@ class DefiniteInitialization : public SILFunctionTransform { void run() override { // Walk through and promote all of the alloc_box's that we can. if (checkDefiniteInitialization(*getFunction())) - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); DEBUG(getFunction()->verify()); // Lower raw-sil only instructions used by this pass, like "assign". if (lowerRawSILOperations(*getFunction())) - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Definite Initialization"; } diff --git a/lib/SILPasses/Devirtualizer.cpp b/lib/SILPasses/Devirtualizer.cpp index c84faa3843c..2b32433e4d6 100644 --- a/lib/SILPasses/Devirtualizer.cpp +++ b/lib/SILPasses/Devirtualizer.cpp @@ -83,7 +83,7 @@ public: // Invalidate the analysis of caller functions. for (auto *AI : DevirtualizedCalls) { invalidateAnalysis(AI->getFunction(), - SILAnalysis::InvalidationKind::CallGraph); + SILAnalysis::PreserveKind::Branches); } if (Changed) { @@ -102,7 +102,7 @@ public: if (Specialized) { // We've specialized some functions and created new ones, so invalidate // the world. - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Branches); } PM->scheduleAnotherIteration(); @@ -494,7 +494,7 @@ namespace { Changed |= insertInlineCaches(AI, CHA); if (Changed) { - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } } diff --git a/lib/SILPasses/DiagnoseUnreachable.cpp b/lib/SILPasses/DiagnoseUnreachable.cpp index 17976484471..1dad0a8258a 100644 --- a/lib/SILPasses/DiagnoseUnreachable.cpp +++ b/lib/SILPasses/DiagnoseUnreachable.cpp @@ -748,7 +748,7 @@ namespace { class NoReturnFolding : public SILModuleTransform { void run() override { performNoReturnFunctionProcessing(getModule()); - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "NoReturnFolding"; } @@ -764,7 +764,7 @@ namespace { class DiagnoseUnreachable : public SILModuleTransform { void run() override { performSILDiagnoseUnreachable(getModule()); - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Diagnose Unreachable"; } diff --git a/lib/SILPasses/ExternalDefsToDecls.cpp b/lib/SILPasses/ExternalDefsToDecls.cpp index 55866b2c0d7..492dfb62330 100644 --- a/lib/SILPasses/ExternalDefsToDecls.cpp +++ b/lib/SILPasses/ExternalDefsToDecls.cpp @@ -27,7 +27,7 @@ class ExternalDefsToDecls : public SILModuleTransform { if (isAvailableExternally(F.getLinkage()) && F.isDefinition()) F.convertToDeclaration(); - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "External Defs To Decls"; } diff --git a/lib/SILPasses/FunctionSignatureOpts.cpp b/lib/SILPasses/FunctionSignatureOpts.cpp index 37ba7dcca58..ef1c4b1a621 100644 --- a/lib/SILPasses/FunctionSignatureOpts.cpp +++ b/lib/SILPasses/FunctionSignatureOpts.cpp @@ -838,7 +838,7 @@ public: // If we changed anything, invalidate the call graph. if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Function Signature Optimization"; } diff --git a/lib/SILPasses/GenericSpecializer.cpp b/lib/SILPasses/GenericSpecializer.cpp index 6c5386ab829..35029b86e98 100644 --- a/lib/SILPasses/GenericSpecializer.cpp +++ b/lib/SILPasses/GenericSpecializer.cpp @@ -50,7 +50,7 @@ public: PM->scheduleAnotherIteration(); // Invalidate the call graph. - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } } diff --git a/lib/SILPasses/GlobalARCOpts.cpp b/lib/SILPasses/GlobalARCOpts.cpp index b3ae973b0a6..b00cab2abb5 100644 --- a/lib/SILPasses/GlobalARCOpts.cpp +++ b/lib/SILPasses/GlobalARCOpts.cpp @@ -229,7 +229,7 @@ class GlobalARCOpts : public SILFunctionTransform { auto *RCIA = getAnalysis(); if (processFunction(*getFunction(), false, AA, POTA, RCIA)) { processFunction(*getFunction(), true, AA, POTA, RCIA); - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } } diff --git a/lib/SILPasses/GlobalOpt.cpp b/lib/SILPasses/GlobalOpt.cpp index cab4398ca77..ae9a26ab9b9 100644 --- a/lib/SILPasses/GlobalOpt.cpp +++ b/lib/SILPasses/GlobalOpt.cpp @@ -314,7 +314,7 @@ class SILGlobalOptPass : public SILModuleTransform void run() override { DominanceAnalysis *DA = PM->getAnalysis(); if (SILGlobalOpt(getModule(), DA).run()) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "SIL Global Optimization"; } diff --git a/lib/SILPasses/LICM.cpp b/lib/SILPasses/LICM.cpp index 8638f1c5e02..103b253bccf 100644 --- a/lib/SILPasses/LICM.cpp +++ b/lib/SILPasses/LICM.cpp @@ -460,9 +460,11 @@ public: } if (Changed) { - // TODO: Verify: We have updated the DominanceInfo and SILLoopInfo. It - // should be safe not to invalidate the CFG. - PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::Instructions); + LA->lockInvalidation(); + DA->lockInvalidation(); + PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing); + LA->unlockInvalidation(); + DA->unlockInvalidation(); } } }; diff --git a/lib/SILPasses/Link.cpp b/lib/SILPasses/Link.cpp index 3a4b79830ec..9dbdedf9e90 100644 --- a/lib/SILPasses/Link.cpp +++ b/lib/SILPasses/Link.cpp @@ -48,7 +48,7 @@ class SILLinker : public SILModuleTransform { Changed |= M.linkFunction(&Fn, SILModule::LinkingMode::LinkAll); if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "SIL Linker"; } diff --git a/lib/SILPasses/LoadStoreOpts.cpp b/lib/SILPasses/LoadStoreOpts.cpp index f23a12fa420..97a4e376d5f 100644 --- a/lib/SILPasses/LoadStoreOpts.cpp +++ b/lib/SILPasses/LoadStoreOpts.cpp @@ -1417,7 +1417,7 @@ class GlobalLoadStoreOpts : public SILFunctionTransform { Changed = true; if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SIL Load Store Opts"; } diff --git a/lib/SILPasses/LoopRotate.cpp b/lib/SILPasses/LoopRotate.cpp index 569084450c0..4a12084840f 100644 --- a/lib/SILPasses/LoopRotate.cpp +++ b/lib/SILPasses/LoopRotate.cpp @@ -576,7 +576,7 @@ class LoopRotation : public SILFunctionTransform { // We preserve loop info and the dominator tree. DA->lockInvalidation(); LA->lockInvalidation(); - PM->invalidateAnalysis(F, SILAnalysis::InvalidationKind::All); + PM->invalidateAnalysis(F, SILAnalysis::PreserveKind::Nothing); DA->unlockInvalidation(); LA->unlockInvalidation(); } diff --git a/lib/SILPasses/MandatoryInlining.cpp b/lib/SILPasses/MandatoryInlining.cpp index deee4b43217..b0776a039e9 100644 --- a/lib/SILPasses/MandatoryInlining.cpp +++ b/lib/SILPasses/MandatoryInlining.cpp @@ -515,7 +515,7 @@ class MandatoryInlining : public SILModuleTransform { M->eraseFunction(&F); } - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Mandatory Inlining"; } diff --git a/lib/SILPasses/MergeCondFail.cpp b/lib/SILPasses/MergeCondFail.cpp index 4fc40a9bd3e..9c62cd7292a 100644 --- a/lib/SILPasses/MergeCondFail.cpp +++ b/lib/SILPasses/MergeCondFail.cpp @@ -81,7 +81,7 @@ public: } if (Changed) PM->invalidateAnalysis(getFunction(), - SILAnalysis::InvalidationKind::Instructions); + SILAnalysis::PreserveKind::ProgramFlow); } /// \brief Try to merge the cond_fail instructions. Returns true if any could diff --git a/lib/SILPasses/PerformanceInliner.cpp b/lib/SILPasses/PerformanceInliner.cpp index 30053a231dd..0010cb78e0e 100644 --- a/lib/SILPasses/PerformanceInliner.cpp +++ b/lib/SILPasses/PerformanceInliner.cpp @@ -834,8 +834,8 @@ bool SILPerformanceInliner::inlineCallsIntoFunction(SILFunction *Caller, // we expect it to have happened. assert(Success && "Expected inliner to inline this function!"); AI->eraseFromParent(); - DA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG); - LA->invalidate(Caller, SILAnalysis::InvalidationKind::CFG); + DA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing); + LA->invalidate(Caller, SILAnalysis::PreserveKind::Nothing); NumFunctionsInlined++; Changed = true; } @@ -910,7 +910,7 @@ public: // Invalidate the call graph. if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CallGraph); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return PassName; } diff --git a/lib/SILPasses/PredictableMemOpt.cpp b/lib/SILPasses/PredictableMemOpt.cpp index 5fb94e0af08..55a21012b24 100644 --- a/lib/SILPasses/PredictableMemOpt.cpp +++ b/lib/SILPasses/PredictableMemOpt.cpp @@ -1000,7 +1000,7 @@ class PredictableMemoryOptimizations : public SILFunctionTransform { /// The entry point to the transformation. void run() override { if (optimizeMemoryAllocations(*getFunction())) - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Predictable Memory Opts"; } diff --git a/lib/SILPasses/RemovePin.cpp b/lib/SILPasses/RemovePin.cpp index 3c081bb4e56..33acc046180 100644 --- a/lib/SILPasses/RemovePin.cpp +++ b/lib/SILPasses/RemovePin.cpp @@ -109,7 +109,7 @@ public: if (Changed) 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 diff --git a/lib/SILPasses/SILCleanup.cpp b/lib/SILPasses/SILCleanup.cpp index b80c7415615..413538fd6f4 100644 --- a/lib/SILPasses/SILCleanup.cpp +++ b/lib/SILPasses/SILCleanup.cpp @@ -62,7 +62,7 @@ class SILCleanup : public swift::SILFunctionTransform { /// The entry point to the transformation. void run() override { cleanFunction(*getFunction()); - invalidateAnalysis(SILAnalysis::InvalidationKind::All); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "SIL Cleanup"; } diff --git a/lib/SILPasses/SILCodeMotion.cpp b/lib/SILPasses/SILCodeMotion.cpp index 360af73d79c..9d5eb9a9f49 100644 --- a/lib/SILPasses/SILCodeMotion.cpp +++ b/lib/SILPasses/SILCodeMotion.cpp @@ -1398,7 +1398,7 @@ public: " *****\n"); if (processFunction(F, AA, POTA, RCIA, HoistReleases)) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SIL Code Motion"; } diff --git a/lib/SILPasses/SILCombine.cpp b/lib/SILPasses/SILCombine.cpp index 3d85c87370e..da8681c9500 100644 --- a/lib/SILPasses/SILCombine.cpp +++ b/lib/SILPasses/SILCombine.cpp @@ -327,7 +327,7 @@ class SILCombine : public SILFunctionTransform { SILCombiner Combiner(AA, getOptions().RemoveRuntimeAsserts); bool Changed = Combiner.runOnFunction(*getFunction()); if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SIL Combine"; } diff --git a/lib/SILPasses/SILLowerAggregateInstrs.cpp b/lib/SILPasses/SILLowerAggregateInstrs.cpp index 3c45e45590c..0f2a9bbff4b 100644 --- a/lib/SILPasses/SILLowerAggregateInstrs.cpp +++ b/lib/SILPasses/SILLowerAggregateInstrs.cpp @@ -260,7 +260,7 @@ class SILLowerAggregate : public SILFunctionTransform { F->getName() << " *****\n"); bool Changed = processFunction(*F); if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "Lower Aggregate Instructions"; } diff --git a/lib/SILPasses/SILMem2Reg.cpp b/lib/SILPasses/SILMem2Reg.cpp index 0bc9b541fa0..0f4f74a09fc 100644 --- a/lib/SILPasses/SILMem2Reg.cpp +++ b/lib/SILPasses/SILMem2Reg.cpp @@ -845,7 +845,7 @@ class SILMem2Reg : public SILFunctionTransform { bool Changed = MemoryToRegisters(*F, DA->getDomInfo(F)).run(); if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SIL Mem2Reg"; } diff --git a/lib/SILPasses/SILSROA.cpp b/lib/SILPasses/SILSROA.cpp index c5729efc339..75f7c940492 100644 --- a/lib/SILPasses/SILSROA.cpp +++ b/lib/SILPasses/SILSROA.cpp @@ -311,7 +311,7 @@ class SILSROA : public SILFunctionTransform { " *****\n"); if (runSROAOnFunction(*F)) - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "SROA"; } diff --git a/lib/SILPasses/SimplifyCFG.cpp b/lib/SILPasses/SimplifyCFG.cpp index 729c7b6fae2..52503eae7bf 100644 --- a/lib/SILPasses/SimplifyCFG.cpp +++ b/lib/SILPasses/SimplifyCFG.cpp @@ -2326,7 +2326,7 @@ bool SimplifyCFG::run() { RU.run(); // Force dominator recomputation below. - PM->invalidateAnalysis(&Fn, SILAnalysis::InvalidationKind::CFG); + PM->invalidateAnalysis(&Fn, SILAnalysis::PreserveKind::Nothing); Changed = true; } @@ -3074,7 +3074,7 @@ class SimplifyCFGPass : public SILFunctionTransform { /// The entry point to the transformation. void run() override { if (SimplifyCFG(*getFunction(), PM).run()) - invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Simplify CFG"; } @@ -3108,7 +3108,7 @@ public: splitAllCriticalEdges(Fn, OnlyNonCondBrEdges, nullptr, nullptr); if (Changed) - invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); + invalidateAnalysis(SILAnalysis::PreserveKind::Calls); } StringRef getName() override { return "Split Critical Edges"; } @@ -3122,7 +3122,7 @@ public: /// The entry point to the transformation. void run() override { if (SimplifyCFG(*getFunction(), PM).simplifyBlockArgs()) - invalidateAnalysis(SILAnalysis::InvalidationKind::CFG); + invalidateAnalysis(SILAnalysis::PreserveKind::Nothing); } StringRef getName() override { return "Simplify Block Args"; } diff --git a/lib/SILPasses/StripDebugInfo.cpp b/lib/SILPasses/StripDebugInfo.cpp index 3a54b9fb08f..8f6f6ea8426 100644 --- a/lib/SILPasses/StripDebugInfo.cpp +++ b/lib/SILPasses/StripDebugInfo.cpp @@ -40,7 +40,7 @@ class StripDebugInfo : public swift::SILFunctionTransform { /// The entry point to the transformation. void run() override { stripFunction(getFunction()); - invalidateAnalysis(SILAnalysis::InvalidationKind::Instructions); + invalidateAnalysis(SILAnalysis::PreserveKind::ProgramFlow); } StringRef getName() override { return "Strip Debug Info"; }