[llvm] b5db65e - Reland [GlobalOpt] Preserve CFG analyses
Arthur Eubanks via llvm-commits
llvm-commits at lists.llvm.org
Tue Jun 21 09:23:27 PDT 2022
Author: Arthur Eubanks
Date: 2022-06-21T09:19:59-07:00
New Revision: b5db65e0da1748d58b0657b4ffb3a41d7fd58449
URL: https://github.com/llvm/llvm-project/commit/b5db65e0da1748d58b0657b4ffb3a41d7fd58449
DIFF: https://github.com/llvm/llvm-project/commit/b5db65e0da1748d58b0657b4ffb3a41d7fd58449.diff
LOG: Reland [GlobalOpt] Preserve CFG analyses
The only place we modify the CFG is when calling
removeUnreachableBlocks(), so insert a callback there which invalidates
analyses for that function (or recomputes DT in the legacy PM).
We may delete functions, make sure to clear analyses for those
functions. (this was missed in the original revision)
Small compile time wins across the board:
https://llvm-compile-time-tracker.com/compare.php?from=f444ea8ce0aaaa5ec1a4129809389da15cc41396&to=698f41f4fc26cbf1006ed5d88e9d658edfc5b749&stat=instructions
Reviewed By: nikic
Differential Revision: https://reviews.llvm.org/D128145
Added:
llvm/test/Transforms/GlobalOpt/analysis-invalidation.ll
Modified:
llvm/lib/Transforms/IPO/GlobalOpt.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/IPO/GlobalOpt.cpp b/llvm/lib/Transforms/IPO/GlobalOpt.cpp
index a2b47166cdfc4..fc268a062392b 100644
--- a/llvm/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/llvm/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1279,8 +1279,10 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
return true;
}
-static bool deleteIfDead(
- GlobalValue &GV, SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
+static bool
+deleteIfDead(GlobalValue &GV,
+ SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats,
+ function_ref<void(Function &)> DeleteFnCallback = nullptr) {
GV.removeDeadConstantUsers();
if (!GV.isDiscardableIfUnused() && !GV.isDeclaration())
@@ -1299,6 +1301,10 @@ static bool deleteIfDead(
return false;
LLVM_DEBUG(dbgs() << "GLOBAL DEAD: " << GV << "\n");
+ if (auto *F = dyn_cast<Function>(&GV)) {
+ if (DeleteFnCallback)
+ DeleteFnCallback(*F);
+ }
GV.eraseFromParent();
++NumDeleted;
return true;
@@ -1906,7 +1912,9 @@ OptimizeFunctions(Module &M,
function_ref<TargetTransformInfo &(Function &)> GetTTI,
function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
function_ref<DominatorTree &(Function &)> LookupDomTree,
- SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats) {
+ SmallPtrSetImpl<const Comdat *> &NotDiscardableComdats,
+ function_ref<void(Function &F)> ChangedCFGCallback,
+ function_ref<void(Function &F)> DeleteFnCallback) {
bool Changed = false;
@@ -1926,7 +1934,7 @@ OptimizeFunctions(Module &M,
if (!F.hasName() && !F.isDeclaration() && !F.hasLocalLinkage())
F.setLinkage(GlobalValue::InternalLinkage);
- if (deleteIfDead(F, NotDiscardableComdats)) {
+ if (deleteIfDead(F, NotDiscardableComdats, DeleteFnCallback)) {
Changed = true;
continue;
}
@@ -1939,13 +1947,11 @@ OptimizeFunctions(Module &M,
// So, remove unreachable blocks from the function, because a) there's
// no point in analyzing them and b) GlobalOpt should otherwise grow
// some more complicated logic to break these cycles.
- // Removing unreachable blocks might invalidate the dominator so we
- // recalculate it.
+ // Notify the analysis manager that we've modified the function's CFG.
if (!F.isDeclaration()) {
if (removeUnreachableBlocks(F)) {
- auto &DT = LookupDomTree(F);
- DT.recalculate(F);
Changed = true;
+ ChangedCFGCallback(F);
}
}
@@ -2408,12 +2414,14 @@ static bool OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn) {
return Changed;
}
-static bool optimizeGlobalsInModule(
- Module &M, const DataLayout &DL,
- function_ref<TargetLibraryInfo &(Function &)> GetTLI,
- function_ref<TargetTransformInfo &(Function &)> GetTTI,
- function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
- function_ref<DominatorTree &(Function &)> LookupDomTree) {
+static bool
+optimizeGlobalsInModule(Module &M, const DataLayout &DL,
+ function_ref<TargetLibraryInfo &(Function &)> GetTLI,
+ function_ref<TargetTransformInfo &(Function &)> GetTTI,
+ function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
+ function_ref<DominatorTree &(Function &)> LookupDomTree,
+ function_ref<void(Function &F)> ChangedCFGCallback,
+ function_ref<void(Function &F)> DeleteFnCallback) {
SmallPtrSet<const Comdat *, 8> NotDiscardableComdats;
bool Changed = false;
bool LocalChange = true;
@@ -2438,7 +2446,8 @@ static bool optimizeGlobalsInModule(
// Delete functions that are trivially dead, ccc -> fastcc
LocalChange |= OptimizeFunctions(M, GetTLI, GetTTI, GetBFI, LookupDomTree,
- NotDiscardableComdats);
+ NotDiscardableComdats, ChangedCFGCallback,
+ DeleteFnCallback);
// Optimize global_ctors list.
LocalChange |=
@@ -2491,10 +2500,23 @@ PreservedAnalyses GlobalOptPass::run(Module &M, ModuleAnalysisManager &AM) {
auto GetBFI = [&FAM](Function &F) -> BlockFrequencyInfo & {
return FAM.getResult<BlockFrequencyAnalysis>(F);
};
+ auto ChangedCFGCallback = [&FAM](Function &F) {
+ FAM.invalidate(F, PreservedAnalyses::none());
+ };
+ auto DeleteFnCallback = [&FAM](Function &F) { FAM.clear(F, F.getName()); };
- if (!optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI, LookupDomTree))
+ if (!optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI, LookupDomTree,
+ ChangedCFGCallback, DeleteFnCallback))
return PreservedAnalyses::all();
- return PreservedAnalyses::none();
+
+ PreservedAnalyses PA = PreservedAnalyses::none();
+ // We made sure to clear analyses for deleted functions.
+ PA.preserve<FunctionAnalysisManagerModuleProxy>();
+ // The only place we modify the CFG is when calling
+ // removeUnreachableBlocks(), but there we make sure to invalidate analyses
+ // for modified functions.
+ PA.preserveSet<CFGAnalyses>();
+ return PA;
}
namespace {
@@ -2525,8 +2547,13 @@ struct GlobalOptLegacyPass : public ModulePass {
return this->getAnalysis<BlockFrequencyInfoWrapperPass>(F).getBFI();
};
- return optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI,
- LookupDomTree);
+ auto ChangedCFGCallback = [&LookupDomTree](Function &F) {
+ auto &DT = LookupDomTree(F);
+ DT.recalculate(F);
+ };
+
+ return optimizeGlobalsInModule(M, DL, GetTLI, GetTTI, GetBFI, LookupDomTree,
+ ChangedCFGCallback, nullptr);
}
void getAnalysisUsage(AnalysisUsage &AU) const override {
diff --git a/llvm/test/Transforms/GlobalOpt/analysis-invalidation.ll b/llvm/test/Transforms/GlobalOpt/analysis-invalidation.ll
new file mode 100644
index 0000000000000..510ced4759639
--- /dev/null
+++ b/llvm/test/Transforms/GlobalOpt/analysis-invalidation.ll
@@ -0,0 +1,8 @@
+; RUN: opt -passes='function(require<no-op-function>),globalopt' %s -debug-pass-manager -S 2>&1 | FileCheck %s
+
+; CHECK: Clearing all analysis results for: f
+; CHECK-NOT: @f
+
+define internal void @f() {
+ ret void
+}
More information about the llvm-commits
mailing list