LLVM 19.0.0git
PassManagerImpl.h
Go to the documentation of this file.
1//===- PassManagerImpl.h - Pass management infrastructure -------*- C++ -*-===//
2//
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
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// Provides implementations for PassManager and AnalysisManager template
10/// methods. These classes should be explicitly instantiated for any IR unit,
11/// and files doing the explicit instantiation should include this header.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_IR_PASSMANAGERIMPL_H
16#define LLVM_IR_PASSMANAGERIMPL_H
17
18#include "llvm/IR/Function.h"
20#include "llvm/IR/PassManager.h"
23
25
26namespace llvm {
27
28template <typename IRUnitT, typename AnalysisManagerT, typename... ExtraArgTs>
30 IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs) {
31 class StackTraceEntry : public PrettyStackTraceEntry {
32 const PassInstrumentation &PI;
33 IRUnitT &IR;
34 PassConceptT *Pass = nullptr;
35
36 public:
37 explicit StackTraceEntry(const PassInstrumentation &PI, IRUnitT &IR)
38 : PI(PI), IR(IR) {}
39
40 void setPass(PassConceptT *P) { Pass = P; }
41
42 void print(raw_ostream &OS) const override {
43 OS << "Running pass \"";
44 if (Pass)
45 Pass->printPipeline(OS, [this](StringRef ClassName) {
46 auto PassName = PI.getPassNameForClassName(ClassName);
47 return PassName.empty() ? ClassName : PassName;
48 });
49 else
50 OS << "unknown";
51 OS << "\" on ";
53 OS << "\n";
54 }
55 };
56
58
59 // Request PassInstrumentation from analysis manager, will use it to run
60 // instrumenting callbacks for the passes later.
61 // Here we use std::tuple wrapper over getResult which helps to extract
62 // AnalysisManager's arguments out of the whole ExtraArgs set.
64 detail::getAnalysisResult<PassInstrumentationAnalysis>(
65 AM, IR, std::tuple<ExtraArgTs...>(ExtraArgs...));
66
67 // RemoveDIs: if requested, convert debug-info to DbgRecord representation
68 // for duration of these passes.
70
71 StackTraceEntry Entry(PI, IR);
72 for (auto &Pass : Passes) {
73 Entry.setPass(&*Pass);
74
75 // Check the PassInstrumentation's BeforePass callbacks before running the
76 // pass, skip its execution completely if asked to (callback returns
77 // false).
78 if (!PI.runBeforePass<IRUnitT>(*Pass, IR))
79 continue;
80
81 PreservedAnalyses PassPA = Pass->run(IR, AM, ExtraArgs...);
82
83 // Update the analysis manager as each pass runs and potentially
84 // invalidates analyses.
85 AM.invalidate(IR, PassPA);
86
87 // Call onto PassInstrumentation's AfterPass callbacks immediately after
88 // running the pass.
89 PI.runAfterPass<IRUnitT>(*Pass, IR, PassPA);
90
91 // Finally, intersect the preserved analyses to compute the aggregate
92 // preserved set for this pass manager.
93 PA.intersect(std::move(PassPA));
94 }
95
96 // Invalidation was handled after each pass in the above loop for the
97 // current unit of IR. Therefore, the remaining analysis results in the
98 // AnalysisManager are preserved. We mark this with a set so that we don't
99 // need to inspect each one individually.
101
102 return PA;
103}
104
105template <typename IRUnitT, typename... ExtraArgTs>
107
108template <typename IRUnitT, typename... ExtraArgTs>
110 AnalysisManager &&) = default;
111
112template <typename IRUnitT, typename... ExtraArgTs>
113inline AnalysisManager<IRUnitT, ExtraArgTs...> &
115 default;
116
117template <typename IRUnitT, typename... ExtraArgTs>
118inline void
121 if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))
122 PI->runAnalysesCleared(Name);
123
124 auto ResultsListI = AnalysisResultLists.find(&IR);
125 if (ResultsListI == AnalysisResultLists.end())
126 return;
127 // Delete the map entries that point into the results list.
128 for (auto &IDAndResult : ResultsListI->second)
129 AnalysisResults.erase({IDAndResult.first, &IR});
130
131 // And actually destroy and erase the results associated with this IR.
132 AnalysisResultLists.erase(ResultsListI);
133}
134
135template <typename IRUnitT, typename... ExtraArgTs>
136inline typename AnalysisManager<IRUnitT, ExtraArgTs...>::ResultConceptT &
138 AnalysisKey *ID, IRUnitT &IR, ExtraArgTs... ExtraArgs) {
139 typename AnalysisResultMapT::iterator RI;
140 bool Inserted;
141 std::tie(RI, Inserted) = AnalysisResults.insert(std::make_pair(
142 std::make_pair(ID, &IR), typename AnalysisResultListT::iterator()));
143
144 // If we don't have a cached result for this function, look up the pass and
145 // run it to produce a result, which we then add to the cache.
146 if (Inserted) {
147 auto &P = this->lookUpPass(ID);
148
151 PI = getResult<PassInstrumentationAnalysis>(IR, ExtraArgs...);
153 }
154
155 AnalysisResultListT &ResultList = AnalysisResultLists[&IR];
156 ResultList.emplace_back(ID, P.run(IR, *this, ExtraArgs...));
157
158 PI.runAfterAnalysis(P, IR);
159
160 // P.run may have inserted elements into AnalysisResults and invalidated
161 // RI.
162 RI = AnalysisResults.find({ID, &IR});
163 assert(RI != AnalysisResults.end() && "we just inserted it!");
164
165 RI->second = std::prev(ResultList.end());
166 }
167
168 return *RI->second->second;
169}
170
171template <typename IRUnitT, typename... ExtraArgTs>
173 IRUnitT &IR, const PreservedAnalyses &PA) {
174 // We're done if all analyses on this IR unit are preserved.
176 return;
177
178 // Track whether each analysis's result is invalidated in
179 // IsResultInvalidated.
180 SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;
181 Invalidator Inv(IsResultInvalidated, AnalysisResults);
182 AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
183 for (auto &AnalysisResultPair : ResultsList) {
184 // This is basically the same thing as Invalidator::invalidate, but we
185 // can't call it here because we're operating on the type-erased result.
186 // Moreover if we instead called invalidate() directly, it would do an
187 // unnecessary look up in ResultsList.
188 AnalysisKey *ID = AnalysisResultPair.first;
189 auto &Result = *AnalysisResultPair.second;
191 auto IMapI = IsResultInvalidated.find(ID);
192 if (IMapI != IsResultInvalidated.end())
193 // This result was already handled via the Invalidator.
194 continue;
195
196 // Try to invalidate the result, giving it the Invalidator so it can
197 // recursively query for any dependencies it has and record the result.
198 // Note that we cannot reuse 'IMapI' here or pre-insert the ID, as
199 // Result.invalidate may insert things into the map, invalidating our
200 // iterator.
201 bool Inserted =
202 IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)}).second;
203 (void)Inserted;
204 assert(Inserted && "Should never have already inserted this ID, likely "
205 "indicates a cycle!");
206 }
207
208 // Now erase the results that were marked above as invalidated.
209 if (!IsResultInvalidated.empty()) {
210 for (auto I = ResultsList.begin(), E = ResultsList.end(); I != E;) {
211 AnalysisKey *ID = I->first;
212 if (!IsResultInvalidated.lookup(ID)) {
213 ++I;
214 continue;
215 }
216
217 if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))
218 PI->runAnalysisInvalidated(this->lookUpPass(ID), IR);
219
220 I = ResultsList.erase(I);
221 AnalysisResults.erase({ID, &IR});
222 }
223 }
224
225 if (ResultsList.empty())
226 AnalysisResultLists.erase(&IR);
227}
228} // end namespace llvm
229
230#endif // LLVM_IR_PASSMANAGERIMPL_H
static void print(raw_ostream &Out, object::Archive::Kind Kind, T Val)
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
std::string Name
Legalize the Machine IR a function s Machine IR
Definition: Legalizer.cpp:81
#define I(x, y, z)
Definition: MD5.cpp:58
#define P(N)
const char * Passes
This file defines the Pass Instrumentation classes that provide instrumentation points into the pass ...
llvm::cl::opt< bool > UseNewDbgInfoFormat
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
raw_pwrite_stream & OS
static const char PassName[]
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: Analysis.h:49
API to communicate dependencies between analyses during invalidation.
Definition: PassManager.h:292
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:253
AnalysisManager()
Construct an empty analysis manager.
void clear()
Clear all analysis results cached by this AnalysisManager.
Definition: PassManager.h:396
AnalysisManager & operator=(AnalysisManager &&)
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:155
bool empty() const
Definition: DenseMap.h:98
iterator end()
Definition: DenseMap.h:84
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
This class provides instrumentation entry points for the Pass Manager, doing calls to callbacks regis...
void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const
BeforeAnalysis instrumentation point - takes Analysis instance to be executed and constant reference ...
void runAnalysisInvalidated(const PassT &Analysis, const IRUnitT &IR) const
AnalysisInvalidated instrumentation point - takes Analysis instance that has just been invalidated an...
StringRef getPassNameForClassName(StringRef ClassName) const
Get the pass name for a given pass class name.
void runAfterPass(const PassT &Pass, const IRUnitT &IR, const PreservedAnalyses &PA) const
AfterPass instrumentation point - takes Pass instance that has just been executed and constant refere...
void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const
AfterAnalysis instrumentation point - takes Analysis instance that has just been executed and constan...
bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const
BeforePass instrumentation point - takes Pass instance to be executed and constant reference to IR it...
PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, ExtraArgTs... ExtraArgs)
Run all of the passes in this manager over the given unit of IR.
Pass interface - Implemented by all 'passes'.
Definition: Pass.h:94
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:111
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:117
bool allAnalysesInSetPreserved() const
Directly test whether a set of analyses is preserved.
Definition: Analysis.h:289
void intersect(const PreservedAnalyses &Arg)
Intersect this set with another in place.
Definition: Analysis.h:182
void preserveSet()
Mark an analysis set as preserved.
Definition: Analysis.h:146
PrettyStackTraceEntry - This class is used to represent a frame of the "pretty" stack trace that is d...
Used to temporarily set the debug info format of a function, module, or basic block for the duration ...
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
void printIRUnitNameForStackTrace(raw_ostream &OS, const IRUnitT &IR)
static AnalysisKey * ID()
Returns an opaque, unique ID for this analysis type.
Definition: PassManager.h:108
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: Analysis.h:28