PTO.CallGraphProfile = !CodeGenOpts.DisableIntegratedAS;
PTO.Coroutines = LangOpts.Coroutines;
- LoopAnalysisManager LAM(CodeGenOpts.DebugPassManager);
- FunctionAnalysisManager FAM(CodeGenOpts.DebugPassManager);
- CGSCCAnalysisManager CGAM(CodeGenOpts.DebugPassManager);
- ModuleAnalysisManager MAM(CodeGenOpts.DebugPassManager);
+ LoopAnalysisManager LAM;
+ FunctionAnalysisManager FAM;
+ CGSCCAnalysisManager CGAM;
+ ModuleAnalysisManager MAM;
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(CodeGenOpts.DebugPassManager);
public:
using Base = AnalysisManager<MachineFunction>;
- MachineFunctionAnalysisManager() : Base(false), FAM(nullptr), MAM(nullptr) {}
+ MachineFunctionAnalysisManager() : Base(), FAM(nullptr), MAM(nullptr) {}
MachineFunctionAnalysisManager(FunctionAnalysisManager &FAM,
- ModuleAnalysisManager &MAM,
- bool DebugLogging = false)
- : Base(DebugLogging), FAM(&FAM), MAM(&MAM) {}
+ ModuleAnalysisManager &MAM)
+ : Base(), FAM(&FAM), MAM(&MAM) {}
MachineFunctionAnalysisManager(MachineFunctionAnalysisManager &&) = default;
MachineFunctionAnalysisManager &
operator=(MachineFunctionAnalysisManager &&) = default;
using AfterPassInvalidatedFunc = void(StringRef, const PreservedAnalyses &);
using BeforeAnalysisFunc = void(StringRef, Any);
using AfterAnalysisFunc = void(StringRef, Any);
+ using AnalysisInvalidatedFunc = void(StringRef, Any);
+ using AnalysesClearedFunc = void(StringRef);
public:
PassInstrumentationCallbacks() {}
AfterAnalysisCallbacks.emplace_back(std::move(C));
}
+ template <typename CallableT>
+ void registerAnalysisInvalidatedCallback(CallableT C) {
+ AnalysisInvalidatedCallbacks.emplace_back(std::move(C));
+ }
+
+ template <typename CallableT>
+ void registerAnalysesClearedCallback(CallableT C) {
+ AnalysesClearedCallbacks.emplace_back(std::move(C));
+ }
+
/// Add a class name to pass name mapping for use by pass instrumentation.
void addClassToPassName(StringRef ClassName, StringRef PassName);
/// Get the pass name for a given pass class name.
/// These are run on analyses that have been run.
SmallVector<llvm::unique_function<AfterAnalysisFunc>, 4>
AfterAnalysisCallbacks;
+ /// These are run on analyses that have been invalidated.
+ SmallVector<llvm::unique_function<AnalysisInvalidatedFunc>, 4>
+ AnalysisInvalidatedCallbacks;
+ /// These are run on analyses that have been cleared.
+ SmallVector<llvm::unique_function<AnalysesClearedFunc>, 4>
+ AnalysesClearedCallbacks;
StringMap<std::string> ClassToPassName;
};
C(Analysis.name(), llvm::Any(&IR));
}
+ /// AnalysisInvalidated instrumentation point - takes \p Analysis instance
+ /// that has just been invalidated and constant reference to IR it operated
+ /// on.
+ template <typename IRUnitT, typename PassT>
+ void runAnalysisInvalidated(const PassT &Analysis, const IRUnitT &IR) const {
+ if (Callbacks)
+ for (auto &C : Callbacks->AnalysisInvalidatedCallbacks)
+ C(Analysis.name(), llvm::Any(&IR));
+ }
+
+ /// AnalysesCleared instrumentation point - takes name of IR that analyses
+ /// operated on.
+ void runAnalysesCleared(StringRef Name) const {
+ if (Callbacks)
+ for (auto &C : Callbacks->AnalysesClearedCallbacks)
+ C(Name);
+ }
+
/// Handle invalidation from the pass manager when PassInstrumentation
/// is used as the result of PassInstrumentationAnalysis.
///
};
/// Construct an empty analysis manager.
- ///
- /// If \p DebugLogging is true, we'll log our progress to llvm::dbgs().
- AnalysisManager(bool DebugLogging = false);
+ AnalysisManager();
AnalysisManager(AnalysisManager &&);
AnalysisManager &operator=(AnalysisManager &&);
/// Map from an analysis ID and IR unit to a particular cached
/// analysis result.
AnalysisResultMapT AnalysisResults;
-
- /// Indicates whether we log to \c llvm::dbgs().
- bool DebugLogging;
};
extern template class AnalysisManager<Module>;
namespace llvm {
template <typename IRUnitT, typename... ExtraArgTs>
-inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(
- bool DebugLogging)
- : DebugLogging(DebugLogging) {}
+inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager() {}
template <typename IRUnitT, typename... ExtraArgTs>
inline AnalysisManager<IRUnitT, ExtraArgTs...>::AnalysisManager(
inline void
AnalysisManager<IRUnitT, ExtraArgTs...>::clear(IRUnitT &IR,
llvm::StringRef Name) {
- if (DebugLogging)
- dbgs() << "Clearing all analysis results for: " << Name << "\n";
+ if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))
+ PI->runAnalysesCleared(Name);
auto ResultsListI = AnalysisResultLists.find(&IR);
if (ResultsListI == AnalysisResultLists.end())
continue;
}
- if (DebugLogging)
- dbgs() << "Invalidating analysis: " << this->lookUpPass(ID).name()
- << " on " << IR.getName() << "\n";
+ if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))
+ PI->runAnalysisInvalidated(this->lookUpPass(ID), IR);
I = ResultsList.erase(I);
AnalysisResults.erase({ID, &IR});
PGOOptions::IRUse, PGOOptions::CSIRUse);
}
- LoopAnalysisManager LAM(Conf.DebugPassManager);
- FunctionAnalysisManager FAM(Conf.DebugPassManager);
- CGSCCAnalysisManager CGAM(Conf.DebugPassManager);
- ModuleAnalysisManager MAM(Conf.DebugPassManager);
+ LoopAnalysisManager LAM;
+ FunctionAnalysisManager FAM;
+ CGSCCAnalysisManager CGAM;
+ ModuleAnalysisManager MAM;
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(Conf.DebugPassManager);
PIC.registerBeforeAnalysisCallback([](StringRef PassID, Any IR) {
dbgs() << "Running analysis: " << PassID << " on " << getIRName(IR) << "\n";
});
+
+ PIC.registerAnalysisInvalidatedCallback([](StringRef PassID, Any IR) {
+ dbgs() << "Invalidating analysis: " << PassID << " on " << getIRName(IR)
+ << "\n";
+ });
+ PIC.registerAnalysesClearedCallback([](StringRef IRName) {
+ dbgs() << "Clearing all analysis results for: " << IRName << "\n";
+ });
}
void PassStructurePrinter::printWithIdent(bool Expand, const Twine &Msg) {
; CHECK: Running pass: LoopUnrollPass
; CHECK: Clearing all analysis results for: inner2.header
; CHECK: Clearing all analysis results for: outer.header
-; CHECK: Invalidating analysis: LoopAccessAnalysis on inner1.header
-; CHECK-NOT: Invalidating analysis: LoopAccessAnalysis on inner1.header.1
+; CHECK: Invalidating analysis: LoopAccessAnalysis on {{.*}}inner1.header
+; CHECK-NOT: Invalidating analysis: LoopAccessAnalysis on {{.*}}inner1.header.1
; CHECK: Starting Loop pass manager run.
; CHECK: Running pass: LoopAccessInfoPrinterPass
; CHECK: Running analysis: LoopAccessAnalysis on Loop at depth 1 containing: %inner1.header
P->CSAction = PGOOptions::CSIRUse;
}
}
- LoopAnalysisManager LAM(DebugPM);
- FunctionAnalysisManager FAM(DebugPM);
- CGSCCAnalysisManager CGAM(DebugPM);
- ModuleAnalysisManager MAM(DebugPM);
+ LoopAnalysisManager LAM;
+ FunctionAnalysisManager FAM;
+ CGSCCAnalysisManager CGAM;
+ ModuleAnalysisManager MAM;
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(DebugPM, VerifyEachPass);
public:
CGSCCPassManagerTest()
- : FAM(/*DebugLogging*/ true), CGAM(/*DebugLogging*/ true),
- MAM(/*DebugLogging*/ true),
+ : FAM(), CGAM(), MAM(),
M(parseIR(
// Define a module with the following call graph, where calls go
// out the bottom of nodes and enter the top:
LLVMTargetMachine *LLVMTM = static_cast<LLVMTargetMachine *>(TM.get());
M->setDataLayout(TM->createDataLayout());
- LoopAnalysisManager LAM(/*DebugLogging=*/true);
- FunctionAnalysisManager FAM(/*DebugLogging=*/true);
- CGSCCAnalysisManager CGAM(/*DebugLogging=*/true);
- ModuleAnalysisManager MAM(/*DebugLogging=*/true);
+ LoopAnalysisManager LAM;
+ FunctionAnalysisManager FAM;
+ CGSCCAnalysisManager CGAM;
+ ModuleAnalysisManager MAM;
PassBuilder PB(TM.get());
PB.registerModuleAnalyses(MAM);
PB.registerFunctionAnalyses(FAM);
MachineFunctionAnalysisManager MFAM;
{
// Test move assignment.
- MachineFunctionAnalysisManager NestedMFAM(FAM, MAM,
- /*DebugLogging*/ true);
+ MachineFunctionAnalysisManager NestedMFAM(FAM, MAM);
NestedMFAM.registerPass([&] { return PassInstrumentationAnalysis(); });
NestedMFAM.registerPass([&] { return TestMachineFunctionAnalysis(); });
MFAM = std::move(NestedMFAM);
MachineFunctionPassManager MFPM;
{
// Test move assignment.
- MachineFunctionPassManager NestedMFPM(/*DebugLogging*/ true);
+ MachineFunctionPassManager NestedMFPM;
NestedMFPM.addPass(TestMachineModulePass(Count, TestMachineModuleCount[0]));
NestedMFPM.addPass(TestMachineFunctionPass(Count, BeforeInitialization[0],
BeforeFinalization[0],
"}\n")),
CallbacksHandle(), PB(false, nullptr, PipelineTuningOptions(), None,
&CallbacksHandle.Callbacks),
- PM(true), LAM(true), FAM(true), CGAM(true), AM(true) {
+ PM(true), LAM(), FAM(), CGAM(), AM() {
EXPECT_TRUE(&CallbacksHandle.Callbacks ==
PB.getPassInstrumentationCallbacks());
}
TEST_F(PassManagerTest, Basic) {
- FunctionAnalysisManager FAM(/*DebugLogging*/ true);
+ FunctionAnalysisManager FAM;
int FunctionAnalysisRuns = 0;
FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
- ModuleAnalysisManager MAM(/*DebugLogging*/ true);
+ ModuleAnalysisManager MAM;
int ModuleAnalysisRuns = 0;
MAM.registerPass([&] { return TestModuleAnalysis(ModuleAnalysisRuns); });
MAM.registerPass([&] { return FunctionAnalysisManagerModuleProxy(FAM); });
};
TEST_F(PassManagerTest, IndirectAnalysisInvalidation) {
- FunctionAnalysisManager FAM(/*DebugLogging*/ true);
- ModuleAnalysisManager MAM(/*DebugLogging*/ true);
+ FunctionAnalysisManager FAM;
+ ModuleAnalysisManager MAM;
int FunctionAnalysisRuns = 0, ModuleAnalysisRuns = 0,
IndirectAnalysisRuns = 0, DoublyIndirectAnalysisRuns = 0;
FAM.registerPass([&] { return TestFunctionAnalysis(FunctionAnalysisRuns); });
"}\n");
auto *F = M->getFunction("foo");
- FunctionAnalysisManager FAM(/*DebugLogging*/ true);
+ FunctionAnalysisManager FAM;
FunctionPassManager FPM(/*DebugLogging*/ true);
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(/*DebugLogging*/ true);
"}\n");
auto *F = M->getFunction("foo");
- FunctionAnalysisManager FAM(/*DebugLogging*/ true);
+ FunctionAnalysisManager FAM;
FunctionPassManager FPM(/*DebugLogging*/ true);
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(/*DebugLogging*/ true);
"}\n");
auto *F = M->getFunction("foo");
- FunctionAnalysisManager FAM(/*DebugLogging*/ true);
+ FunctionAnalysisManager FAM;
FunctionPassManager FPM(/*DebugLogging*/ true);
PassInstrumentationCallbacks PIC;
StandardInstrumentations SI(/*DebugLogging*/ true);
"end:\n"
" ret void\n"
"}\n")),
- LAM(true), FAM(true), MAM(true) {
+ LAM(), FAM(), MAM() {
// Register our mock analysis.
LAM.registerPass([&] { return MLAHandle.getAnalysis(); });