mirror of
https://github.com/RPCS3/llvm.git
synced 2025-05-20 12:26:02 +00:00
0fc446723e
that require deferred invalidation. This handles the other real-world invalidation scenario that we have cases of: a function analysis which caches references to a module analysis. We currently do this in the AA aggregation layer and might well do this in other places as well. Since this is relative rare, the technique is somewhat more cumbersome. Analyses need to register themselves when accessing the outer analysis manager's proxy. This proxy is already necessarily present to allow access to the outer IR unit's analyses. By registering here we can track and trigger invalidation when that outer analysis goes away. To make this work we need to enhance the PreservedAnalyses infrastructure to support a (slightly) more explicit model for "sets" of analyses, and allow abandoning a single specific analyses even when a set covering that analysis is preserved. That allows us to describe the scenario of preserving all Function analyses *except* for the one where deferred invalidation has triggered. We also need to teach the invalidator API to support direct ID calls instead of always going through a template to dispatch so that we can just record the ID mapping. I've introduced testing of all of this both for simple module<->function cases as well as for more complex cases involving a CGSCC layer. Much like the previous patch I've not tried to fully update the loop pass management layer because that layer is due to be heavily reworked to use similar techniques to the CGSCC to handle updates. As that happens, we'll have a better testing basis for adding support like this. Many thanks to both Justin and Sean for the extensive reviews on this to help bring the API design and documentation into a better state. Differential Revision: https://reviews.llvm.org/D27198 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@290594 91177308-0d34-0410-b5e6-96231b3b80d8
95 lines
3.6 KiB
C++
95 lines
3.6 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 literally everything is preserved, we're done.
|
|
if (PA.areAllPreserved())
|
|
return false; // This is still a valid proxy.
|
|
|
|
// 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.
|
|
auto PAC = PA.getChecker<FunctionAnalysisManagerModuleProxy>();
|
|
if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Module>>()) {
|
|
InnerAM->clear();
|
|
return true;
|
|
}
|
|
|
|
// Directly check if the relevant set is preserved.
|
|
bool AreFunctionAnalysesPreserved =
|
|
PA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>();
|
|
|
|
// Now walk all the functions to see if any inner analysis invalidation is
|
|
// necessary.
|
|
for (Function &F : M) {
|
|
Optional<PreservedAnalyses> FunctionPA;
|
|
|
|
// Check to see whether the preserved set needs to be pruned based on
|
|
// module-level analysis invalidation that triggers deferred invalidation
|
|
// registered with the outer analysis manager proxy for this function.
|
|
if (auto *OuterProxy =
|
|
InnerAM->getCachedResult<ModuleAnalysisManagerFunctionProxy>(F))
|
|
for (const auto &OuterInvalidationPair :
|
|
OuterProxy->getOuterInvalidations()) {
|
|
AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
|
|
const auto &InnerAnalysisIDs = OuterInvalidationPair.second;
|
|
if (Inv.invalidate(OuterAnalysisID, M, PA)) {
|
|
if (!FunctionPA)
|
|
FunctionPA = PA;
|
|
for (AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
|
|
FunctionPA->abandon(InnerAnalysisID);
|
|
}
|
|
}
|
|
|
|
// Check if we needed a custom PA set, and if so we'll need to run the
|
|
// inner invalidation.
|
|
if (FunctionPA) {
|
|
InnerAM->invalidate(F, *FunctionPA);
|
|
continue;
|
|
}
|
|
|
|
// Otherwise we only need to do invalidation if the original PA set didn't
|
|
// preserve all function analyses.
|
|
if (!AreFunctionAnalysesPreserved)
|
|
InnerAM->invalidate(F, PA);
|
|
}
|
|
|
|
// Return false to indicate that this result is still a valid proxy.
|
|
return false;
|
|
}
|
|
}
|
|
|
|
AnalysisSetKey PreservedAnalyses::AllAnalysesKey;
|