From 558562623292285e1d0ae0812c3634ac3c727527 Mon Sep 17 00:00:00 2001 From: Chandler Carruth Date: Tue, 24 Jan 2017 12:55:57 +0000 Subject: [PATCH] [PH] Replace uses of AssertingVH from members of analysis results with a lazy-asserting PoisoningVH. AssertVH is fundamentally incompatible with cache-invalidation of analysis results. The invaliadtion happens after the AssertingVH has already fired. Instead, use a PoisoningVH that will assert if the dangling handle is ever used rather than merely be assigned or destroyed. This patch also removes all of the (numerous) doomed attempts to work around this fundamental incompatibility. It is a pretty significant simplification IMO. The most interesting change is in the Inliner where we still do some clearing because we don't want to rely on the coarse grained invalidation strategy of the containing pass manager. However, I prefer the approach that contains this logic to the cleanup phase of the Inliner, and I think we could enhance the CGSCC analysis management layer to make this even better in the future if desired. The rest is straight cleanup. I've also added a test for one of the harder cases to work around: when a *module analysis* contains many AssertingVHes pointing at functions. Differential Revision: https://reviews.llvm.org/D29006 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@292928 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/CallGraph.h | 2 +- include/llvm/Analysis/ScalarEvolution.h | 4 ++-- lib/Analysis/LazyValueInfo.cpp | 12 ++++++------ lib/Transforms/IPO/FunctionAttrs.cpp | 11 ++--------- lib/Transforms/IPO/GlobalDCE.cpp | 18 +----------------- lib/Transforms/IPO/Inliner.cpp | 12 ++++++++---- .../Scalar/AlignmentFromAssumptions.cpp | 8 +------- lib/Transforms/Scalar/NaryReassociate.cpp | 8 +------- lib/Transforms/Utils/LoopSimplify.cpp | 5 +---- test/Other/new-pm-defaults.ll | 4 ---- test/Other/new-pm-lto-defaults.ll | 1 - test/Transforms/GlobalDCE/crash-assertingvh.ll | 1 + test/Transforms/Inline/clear-analyses.ll | 9 ++++----- 13 files changed, 28 insertions(+), 67 deletions(-) diff --git a/include/llvm/Analysis/CallGraph.h b/include/llvm/Analysis/CallGraph.h index 4ecbaa75ac7..ea85436ee58 100644 --- a/include/llvm/Analysis/CallGraph.h +++ b/include/llvm/Analysis/CallGraph.h @@ -272,7 +272,7 @@ public: private: friend class CallGraph; - AssertingVH F; + Function *F; std::vector CalledFunctions; diff --git a/include/llvm/Analysis/ScalarEvolution.h b/include/llvm/Analysis/ScalarEvolution.h index 1a93f9aa5fd..bc2b3a31135 100644 --- a/include/llvm/Analysis/ScalarEvolution.h +++ b/include/llvm/Analysis/ScalarEvolution.h @@ -600,14 +600,14 @@ private: /// Information about the number of times a particular loop exit may be /// reached before exiting the loop. struct ExitNotTakenInfo { - AssertingVH ExitingBlock; + PoisoningVH ExitingBlock; const SCEV *ExactNotTaken; std::unique_ptr Predicate; bool hasAlwaysTruePredicate() const { return !Predicate || Predicate->isAlwaysTrue(); } - explicit ExitNotTakenInfo(AssertingVH ExitingBlock, + explicit ExitNotTakenInfo(PoisoningVH ExitingBlock, const SCEV *ExactNotTaken, std::unique_ptr Predicate) : ExitingBlock(ExitingBlock), ExactNotTaken(ExactNotTaken), diff --git a/lib/Analysis/LazyValueInfo.cpp b/lib/Analysis/LazyValueInfo.cpp index dc22b8173a8..b2a8e6f3ce5 100644 --- a/lib/Analysis/LazyValueInfo.cpp +++ b/lib/Analysis/LazyValueInfo.cpp @@ -366,7 +366,7 @@ namespace { struct ValueCacheEntryTy { ValueCacheEntryTy(Value *V, LazyValueInfoCache *P) : Handle(V, P) {} LVIValueHandle Handle; - SmallDenseMap, LVILatticeVal, 4> BlockVals; + SmallDenseMap, LVILatticeVal, 4> BlockVals; }; /// This is all of the cached information for all values, @@ -375,13 +375,13 @@ namespace { /// This tracks, on a per-block basis, the set of values that are /// over-defined at the end of that block. - typedef DenseMap, SmallPtrSet> + typedef DenseMap, SmallPtrSet> OverDefinedCacheTy; OverDefinedCacheTy OverDefinedCache; /// Keep track of all blocks that we have ever seen, so we /// don't spend time removing unused blocks from our caches. - DenseSet > SeenBlocks; + DenseSet > SeenBlocks; public: void insertResult(Value *Val, BasicBlock *BB, const LVILatticeVal &Result) { @@ -464,10 +464,10 @@ void LazyValueInfoCache::eraseValue(Value *V) { SmallPtrSetImpl &ValueSet = I.second; ValueSet.erase(V); if (ValueSet.empty()) - ToErase.push_back(I.first); + ToErase.push_back(&*I.first); } for (auto &BB : ToErase) - OverDefinedCache.erase(BB); + OverDefinedCache.erase(&*BB); ValueCache.erase(V); } @@ -480,7 +480,7 @@ void LVIValueHandle::deleted() { void LazyValueInfoCache::eraseBlock(BasicBlock *BB) { // Shortcut if we have never seen this block. - DenseSet >::iterator I = SeenBlocks.find(BB); + DenseSet >::iterator I = SeenBlocks.find(BB); if (I == SeenBlocks.end()) return; SeenBlocks.erase(I); diff --git a/lib/Transforms/IPO/FunctionAttrs.cpp b/lib/Transforms/IPO/FunctionAttrs.cpp index 402a66552c2..740e9fb8b90 100644 --- a/lib/Transforms/IPO/FunctionAttrs.cpp +++ b/lib/Transforms/IPO/FunctionAttrs.cpp @@ -1275,16 +1275,9 @@ PreservedAnalyses ReversePostOrderFunctionAttrsPass::run(Module &M, ModuleAnalysisManager &AM) { auto &CG = AM.getResult(M); - bool Changed = deduceFunctionAttributeInRPO(M, CG); - - // CallGraphAnalysis holds AssertingVH and must be invalidated eagerly so - // that other passes don't delete stuff from under it. - // FIXME: We need to invalidate this to avoid PR28400. Is there a better - // solution? - AM.invalidate(M); - - if (!Changed) + if (!deduceFunctionAttributeInRPO(M, CG)) return PreservedAnalyses::all(); + PreservedAnalyses PA; PA.preserve(); return PA; diff --git a/lib/Transforms/IPO/GlobalDCE.cpp b/lib/Transforms/IPO/GlobalDCE.cpp index 9304e783d49..67e9d20eb92 100644 --- a/lib/Transforms/IPO/GlobalDCE.cpp +++ b/lib/Transforms/IPO/GlobalDCE.cpp @@ -144,29 +144,13 @@ PreservedAnalyses GlobalDCEPass::run(Module &M, ModuleAnalysisManager &MAM) { } } - // Because we may have cached analyses for functions we take extra care when - // deleting them if there is an active proxy. If there isn't, then we get to - // assume that everything in the function AM has been cleared already. - // FIXME: Note that all of this will happen automatically when this pass - // finishes. Unfortuantely there are analyses which hold asserting VHs to - // IR units. We could make those weak VHs that would assert if ever used - // without asserting eagerly and then all of this knowledge of the analysis - // manager could go away. - FunctionAnalysisManager *FAM = nullptr; - if (auto *FAMProxy = - MAM.getCachedResult(M)) - FAM = &FAMProxy->getManager(); - // The second pass drops the bodies of functions which are dead... std::vector DeadFunctions; for (Function &F : M) if (!AliveGlobals.count(&F)) { DeadFunctions.push_back(&F); // Keep track of dead globals - if (!F.isDeclaration()) { - if (FAM) - FAM->clear(F); + if (!F.isDeclaration()) F.deleteBody(); - } } // The third pass drops targets of aliases which are dead... diff --git a/lib/Transforms/IPO/Inliner.cpp b/lib/Transforms/IPO/Inliner.cpp index e2dc1158549..767a2076de6 100644 --- a/lib/Transforms/IPO/Inliner.cpp +++ b/lib/Transforms/IPO/Inliner.cpp @@ -887,11 +887,10 @@ PreservedAnalyses InlinerPass::run(LazyCallGraph::SCC &InitialC, // made dead by this operation on other functions). Callee.removeDeadConstantUsers(); if (Callee.use_empty()) { - // Clear all analyses and the body and queue the function itself for - // deletion when we finish inlining and call graph updates. + // Clear the body and queue the function itself for deletion when we + // finish inlining and call graph updates. // Note that after this point, it is an error to do anything other // than use the callee's address or delete it. - FAM.clear(Callee); Callee.dropAllReferences(); assert(find(DeadFunctions, &Callee) == DeadFunctions.end() && "Cannot put cause a function to become dead twice!"); @@ -939,8 +938,13 @@ PreservedAnalyses InlinerPass::run(LazyCallGraph::SCC &InitialC, // sets. for (Function *DeadF : DeadFunctions) { // Get the necessary information out of the call graph and nuke the - // function there. + // function there. Also, cclear out any cached analyses. auto &DeadC = *CG.lookupSCC(*CG.lookup(*DeadF)); + FunctionAnalysisManager &FAM = + AM.getResult(DeadC, CG) + .getManager(); + FAM.clear(*DeadF); + AM.clear(DeadC); auto &DeadRC = DeadC.getOuterRefSCC(); CG.removeDeadFunction(*DeadF); diff --git a/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp b/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp index 3cb5b5d8f7a..fd931c521c8 100644 --- a/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp +++ b/lib/Transforms/Scalar/AlignmentFromAssumptions.cpp @@ -438,13 +438,7 @@ AlignmentFromAssumptionsPass::run(Function &F, FunctionAnalysisManager &AM) { AssumptionCache &AC = AM.getResult(F); ScalarEvolution &SE = AM.getResult(F); DominatorTree &DT = AM.getResult(F); - bool Changed = runImpl(F, AC, &SE, &DT); - - // FIXME: We need to invalidate this to avoid PR28400. Is there a better - // solution? - AM.invalidate(F); - - if (!Changed) + if (!runImpl(F, AC, &SE, &DT)) return PreservedAnalyses::all(); PreservedAnalyses PA; diff --git a/lib/Transforms/Scalar/NaryReassociate.cpp b/lib/Transforms/Scalar/NaryReassociate.cpp index a16ef438d0e..c5bf2f28d18 100644 --- a/lib/Transforms/Scalar/NaryReassociate.cpp +++ b/lib/Transforms/Scalar/NaryReassociate.cpp @@ -156,13 +156,7 @@ PreservedAnalyses NaryReassociatePass::run(Function &F, auto *TLI = &AM.getResult(F); auto *TTI = &AM.getResult(F); - bool Changed = runImpl(F, AC, DT, SE, TLI, TTI); - - // FIXME: We need to invalidate this to avoid PR28400. Is there a better - // solution? - AM.invalidate(F); - - if (!Changed) + if (!runImpl(F, AC, DT, SE, TLI, TTI)) return PreservedAnalyses::all(); PreservedAnalyses PA; diff --git a/lib/Transforms/Utils/LoopSimplify.cpp b/lib/Transforms/Utils/LoopSimplify.cpp index b60e0a150c7..85bdeecb79c 100644 --- a/lib/Transforms/Utils/LoopSimplify.cpp +++ b/lib/Transforms/Utils/LoopSimplify.cpp @@ -853,12 +853,9 @@ PreservedAnalyses LoopSimplifyPass::run(Function &F, for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I) Changed |= simplifyLoop(*I, DT, LI, SE, AC, /*PreserveLCSSA*/ false); - // FIXME: We need to invalidate this to avoid PR28400. Is there a better - // solution? - AM.invalidate(F); - if (!Changed) return PreservedAnalyses::all(); + PreservedAnalyses PA; PA.preserve(); PA.preserve(); diff --git a/test/Other/new-pm-defaults.ll b/test/Other/new-pm-defaults.ll index 225b49afbf7..52ed25ef656 100644 --- a/test/Other/new-pm-defaults.ll +++ b/test/Other/new-pm-defaults.ll @@ -91,8 +91,6 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O-NEXT: Running pass: FunctionToLoopPassAdaptor<{{.*}}LoopStandardAnalysisResults{{.*}}> -; CHECK-O-NEXT: Invalidating analysis: ScalarEvolutionAnalysis -; CHECK-O-NEXT: Running analysis: ScalarEvolutionAnalysis ; CHECK-O-NEXT: Starting Loop pass manager run. ; CHECK-O-NEXT: Finished Loop pass manager run. ; CHECK-Os-NEXT: Running pass: MergedLoadStoreMotionPass @@ -120,7 +118,6 @@ ; CHECK-O-NEXT: Running pass: EliminateAvailableExternallyPass ; CHECK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass ; CHECK-O-NEXT: Running analysis: CallGraphAnalysis -; CHECK-O-NEXT: Invalidating analysis: CallGraphAnalysis ; CHECK-O-NEXT: Running pass: ModuleToFunctionPassAdaptor<{{.*}}PassManager{{.*}}> ; CHECK-O-NEXT: Starting llvm::Function pass manager run. ; CHECK-O-NEXT: Running pass: Float2IntPass @@ -133,7 +130,6 @@ ; CHECK-O-NEXT: Running pass: SimplifyCFGPass ; CHECK-O-NEXT: Running pass: InstCombinePass ; CHECK-O-NEXT: Running pass: AlignmentFromAssumptionsPass -; CHECK-O-NEXT: Invalidating analysis: ScalarEvolutionAnalysis ; CHECK-O-NEXT: Finished llvm::Function pass manager run. ; CHECK-O-NEXT: Running pass: GlobalDCEPass ; CHECK-O-NEXT: Running pass: ConstantMergePass diff --git a/test/Other/new-pm-lto-defaults.ll b/test/Other/new-pm-lto-defaults.ll index 8f54a7dfdf7..e86bcdddcda 100644 --- a/test/Other/new-pm-lto-defaults.ll +++ b/test/Other/new-pm-lto-defaults.ll @@ -37,7 +37,6 @@ ; CHECK-O-NEXT: Running analysis: TargetLibraryAnalysis ; CHECK-O-NEXT: Running pass: ReversePostOrderFunctionAttrsPass ; CHECK-O-NEXT: Running analysis: CallGraphAnalysis -; CHECK-O-NEXT: Invalidating analysis: CallGraphAnalysis ; CHECK-O-NEXT: Running pass: GlobalSplitPass ; CHECK-O-NEXT: Running pass: WholeProgramDevirtPass ; CHECK-O2-NEXT: Running pass: GlobalOptPass diff --git a/test/Transforms/GlobalDCE/crash-assertingvh.ll b/test/Transforms/GlobalDCE/crash-assertingvh.ll index 184d6ae7d8e..2919999d5e2 100644 --- a/test/Transforms/GlobalDCE/crash-assertingvh.ll +++ b/test/Transforms/GlobalDCE/crash-assertingvh.ll @@ -3,6 +3,7 @@ ; to assert when global DCE deletes the body of the function. ; ; RUN: opt -disable-output < %s -passes='module(function(jump-threading),globaldce)' +; RUN: opt -disable-output < %s -passes='module(rpo-functionattrs,globaldce)' target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128" target triple = "x86_64-unknown-linux-gnu" diff --git a/test/Transforms/Inline/clear-analyses.ll b/test/Transforms/Inline/clear-analyses.ll index 1fde513f282..4b1d37ca29a 100644 --- a/test/Transforms/Inline/clear-analyses.ll +++ b/test/Transforms/Inline/clear-analyses.ll @@ -1,8 +1,7 @@ -; Test that the inliner clears analyses which may hold references to function -; bodies when it decides to delete them after inlining the last caller. -; We check this by using correlated-propagation to populate LVI with basic -; block references that would dangle if we failed to clear the inlined function -; body. +; Test that when a pass like correlated-propagation populates an analysis such +; as LVI with references back into the IR of a function that the inliner will +; delete, this doesn't crash or go awry despite the inliner clearing the analyses +; separately from when it deletes the function. ; ; RUN: opt -debug-pass-manager -S < %s 2>&1 \ ; RUN: -passes='cgscc(inline,function(correlated-propagation))' \ -- 2.40.0