1//===- LoopAnalysisManager.cpp - Loop analysis management -----------------===// 3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4// See https://llvm.org/LICENSE.txt for license information. 5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7//===----------------------------------------------------------------------===// 21// Explicit template instantiations and specialization definitions for core 29bool LoopAnalysisManagerFunctionProxy::Result::invalidate(
32// First compute the sequence of IR units covered by this proxy. We will want 33// to visit this in postorder, but because this is a tree structure we can do 34// this by building a preorder sequence and walking it backwards. We also 35// want siblings in forward program order to match the LoopPassManager so we 36// get the preorder with siblings reversed. 39// If this proxy or the loop info is going to be invalidated, we also need 40// to clear all the keys coming from that analysis. We also completely blow 41// away the loop analyses if any of the standard analyses provided by the 42// loop pass manager go away so that loop analyses can freely use these 43// without worrying about declaring dependencies on them etc. 44// FIXME: It isn't clear if this is the right tradeoff. We could instead make 45// loop analyses declare any dependencies on these and use the more general 46// invalidation logic below to act on that. 48bool invalidateMemorySSAAnalysis =
false;
57 invalidateMemorySSAAnalysis) {
58// Note that the LoopInfo may be stale at this point, however the loop 59// objects themselves remain the only viable keys that could be in the 60// analysis manager's cache. So we just walk the keys and forcibly clear 61// those results. Note that the order doesn't matter here as this will just 62// directly destroy the results without calling methods on them. 63for (
Loop *L : PreOrderLoops) {
64// NB! `L` may not be in a good enough state to run Loop::getName. 65 InnerAM->clear(*L,
"<possibly invalidated loop>");
68// We also need to null out the inner AM so that when the object gets 69// destroyed as invalid we don't try to clear the inner AM again. At that 70// point we won't be able to reliably walk the loops for this function and 71// only clear results associated with those loops the way we do here. 72// FIXME: Making InnerAM null at this point isn't very nice. Most analyses 73// try to remain valid during invalidation. Maybe we should add an 77// Now return true to indicate this *is* invalid and a fresh proxy result 78// needs to be built. This is especially important given the null InnerAM. 82// Directly check if the relevant set is preserved so we can short circuit 84bool AreLoopAnalysesPreserved =
87// Since we have a valid LoopInfo we can actually leave the cached results in 88// the analysis manager associated with the Loop keys, but we need to 89// propagate any necessary invalidation logic into them. We'd like to 90// invalidate things in roughly the same order as they were put into the 91// cache and so we walk the preorder list in reverse to form a valid 94 std::optional<PreservedAnalyses> InnerPA;
96// Check to see whether the preserved set needs to be adjusted based on 97// function-level analysis invalidation triggering deferred invalidation 101for (
constauto &OuterInvalidationPair :
102 OuterProxy->getOuterInvalidations()) {
103AnalysisKey *OuterAnalysisID = OuterInvalidationPair.first;
104constauto &InnerAnalysisIDs = OuterInvalidationPair.second;
108for (
AnalysisKey *InnerAnalysisID : InnerAnalysisIDs)
109 InnerPA->
abandon(InnerAnalysisID);
113// Check if we needed a custom PA set. If so we'll need to run the inner 116 InnerAM->invalidate(*L, *InnerPA);
120// Otherwise we only need to do invalidation if the original PA set didn't 121// preserve all Loop analyses. 122if (!AreLoopAnalysesPreserved)
123 InnerAM->invalidate(*L, PA);
126// Return false to indicate that this result is still a valid proxy. This header provides classes for managing per-loop analyses.
This file exposes an interface to building/using memory SSA to walk memory instructions using a use/d...
Provides implementations for PassManager and AnalysisManager template methods.
A manager for alias analyses.
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
API to communicate dependencies between analyses during invalidation.
bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Trigger the invalidation of some other analysis pass if not already handled and return whether it was...
A container for analyses that lazily runs them and caches their results.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
A function analysis which provides an AssumptionCache.
Analysis pass which computes a DominatorTree.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Result run(IRUnitT &IR, AnalysisManager< IRUnitT, ExtraArgTs... > &AM, ExtraArgTs...)
Run the analysis pass and create our proxy result object.
Analysis pass that exposes the LoopInfo for a function.
Represents a single loop in the control flow graph.
An analysis that produces MemorySSA for a function.
An analysis over an "inner" IR unit that provides access to an analysis manager over a "outer" IR uni...
A set of analyses that are preserved following a run of a transformation pass.
bool allAnalysesInSetPreserved() const
Directly test whether a set of analyses is preserved.
PreservedAnalysisChecker getChecker() const
Build a checker for this PreservedAnalyses and the specified analysis type.
void abandon()
Mark an analysis as abandoned.
void preserve()
Mark an analysis as preserved.
Analysis pass that exposes the ScalarEvolution for a function.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
This is an optimization pass for GlobalISel generic memory operations.
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
auto reverse(ContainerTy &&C)
PreservedAnalyses getLoopPassPreservedAnalyses()
Returns the minimum set of Analyses that all loop passes must preserve.
A special type used by analysis passes to provide an address that identifies that particular analysis...
The adaptor from a function pass to a loop pass computes these analyses and makes them available to t...
