mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
4fc787e70d
Summary: This never really got implemented, and was very hard to test before a lot of the refactoring changes to make things more robust. But now we can test it thoroughly and cleanly, especially at the CGSCC level. The core idea is that when an inner analysis manager proxy receives the invalidation event for the outer IR unit, it needs to walk the inner IR units and propagate it to the inner analysis manager for each of those units. For example, each function in the SCC needs to get an invalidation event when the SCC gets one. The function / module interaction is somewhat boring here. This really becomes interesting in the face of analysis-backed IR units. This patch effectively handles all of the CGSCC layer's needs -- both invalidating SCC analysis and invalidating function analysis when an SCC gets invalidated. However, this second aspect doesn't really handle the LoopAnalysisManager well at this point. That one will need some change of design in order to fully integrate, because unlike the call graph, the entire function behind a LoopAnalysis's results can vanish out from under us, and we won't even have a cached API to access. I'd like to try to separate solving the loop problems into a subsequent patch though in order to keep this more focused so I've adapted them to the API and updated the tests that immediately fail, but I've not added the level of testing and validation at that layer that I have at the CGSCC layer. An important aspect of this change is that the proxy for the FunctionAnalysisManager at the SCC pass layer doesn't work like the other proxies for an inner IR unit as it doesn't directly manage the FunctionAnalysisManager and invalidation or clearing of it. This would create an ever worsening problem of dual ownership of this responsibility, split between the module-level FAM proxy and this SCC-level FAM proxy. Instead, this patch changes the SCC-level FAM proxy to work in terms of the module-level proxy and defer to it to handle much of the updates. It only does SCC-specific invalidation. This will become more important in subsequent patches that support more complex invalidaiton scenarios. Reviewers: jlebar Subscribers: mehdi_amini, mcrosier, mzolotukhin, llvm-commits Differential Revision: https://reviews.llvm.org/D27197 llvm-svn: 289317
55 lines
2.0 KiB
C++
55 lines
2.0 KiB
C++
//===- PassManager.cpp - Infrastructure for managing & running IR passes --===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/IR/PassManager.h"
|
|
#include "llvm/ADT/STLExtras.h"
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
using namespace llvm;
|
|
|
|
// Explicit template instantiations and specialization defininitions for core
|
|
// template typedefs.
|
|
namespace llvm {
|
|
template class AllAnalysesOn<Module>;
|
|
template class AllAnalysesOn<Function>;
|
|
template class PassManager<Module>;
|
|
template class PassManager<Function>;
|
|
template class AnalysisManager<Module>;
|
|
template class AnalysisManager<Function>;
|
|
template class InnerAnalysisManagerProxy<FunctionAnalysisManager, Module>;
|
|
template class OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
|
|
|
|
template <>
|
|
bool FunctionAnalysisManagerModuleProxy::Result::invalidate(
|
|
Module &M, const PreservedAnalyses &PA,
|
|
ModuleAnalysisManager::Invalidator &Inv) {
|
|
// If this proxy isn't marked as preserved, then even if the result remains
|
|
// valid, the key itself may no longer be valid, so we clear everything.
|
|
//
|
|
// Note that in order to preserve this proxy, a module pass must ensure that
|
|
// the FAM has been completely updated to handle the deletion of functions.
|
|
// Specifically, any FAM-cached results for those functions need to have been
|
|
// forcibly cleared. When preserved, this proxy will only invalidate results
|
|
// cached on functions *still in the module* at the end of the module pass.
|
|
if (!PA.preserved(FunctionAnalysisManagerModuleProxy::ID())) {
|
|
InnerAM->clear();
|
|
return true;
|
|
}
|
|
|
|
// Otherwise propagate the invalidation event to all the remaining IR units.
|
|
for (Function &F : M)
|
|
InnerAM->invalidate(F, PA);
|
|
|
|
// Return false to indicate that this result is still a valid proxy.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
AnalysisKey PreservedAnalyses::AllAnalysesKey;
|